| -------------------------------------------------------------------------------- |
| -- Copyright (c) 2011-2012 Sierra Wireless. |
| -- All rights reserved. This program and the accompanying materials |
| -- are made available under the terms of the Eclipse Public License v1.0 |
| -- which accompanies this distribution, and is available at |
| -- http://www.eclipse.org/legal/epl-v10.html |
| -- |
| -- Contributors: |
| -- Simon BERNARD <sbernard@sierrawireless.com> |
| -- - initial API and implementation and initial documentation |
| -------------------------------------------------------------------------------- |
| local M = {} |
| |
| -------------------------------------------------------------------------------- |
| -- API MODEL |
| -------------------------------------------------------------------------------- |
| |
| function M._file() |
| local file = { |
| -- FIELDS |
| tag = "file", |
| name = nil, -- string |
| shortdescription = "", -- string |
| description = "", -- string |
| types = {}, -- map from typename to type |
| globalvars = {}, -- map from varname to item |
| returns = {}, -- list of return |
| |
| -- FUNCTIONS |
| addtype = function (self,type) |
| self.types[type.name] = type |
| type.parent = self |
| end, |
| |
| mergetype = function (self,newtype,erase,erasesourcerangefield) |
| local currenttype = self.types[newtype.name] |
| if currenttype then |
| -- merge recordtypedef |
| if currenttype.tag =="recordtypedef" and newtype.tag == "recordtypedef" then |
| -- merge fields |
| for fieldname ,field in pairs( newtype.fields) do |
| local currentfield = currenttype.fields[fieldname] |
| if erase or not currentfield then |
| currenttype:addfield(field) |
| elseif erasesourcerangefield then |
| if field.sourcerange.min and field.sourcerange.max then |
| currentfield.sourcerange.min = field.sourcerange.min |
| currentfield.sourcerange.max = field.sourcerange.max |
| end |
| end |
| end |
| |
| -- merge descriptions and source ranges |
| if erase then |
| if newtype.description or newtype.description == "" then currenttype.description = newtype.description end |
| if newtype.shortdescription or newtype.shortdescription == "" then currenttype.shortdescription = newtype.shortdescription end |
| if newtype.sourcerange.min and newtype.sourcerange.max then |
| currenttype.sourcerange.min = newtype.sourcerange.min |
| currenttype.sourcerange.max = newtype.sourcerange.max |
| end |
| end |
| -- merge functiontypedef |
| elseif currenttype.tag == "functiontypedef" and newtype.tag == "functiontypedef" then |
| -- merge params |
| for i, param1 in ipairs(newtype.params) do |
| local missing = true |
| for j, param2 in ipairs(currenttype.params) do |
| if param1.name == param2.name then |
| missing = false |
| break |
| end |
| end |
| if missing then |
| table.insert(currenttype.params,param1) |
| end |
| end |
| |
| -- merge descriptions and source ranges |
| if erase then |
| if newtype.description or newtype.description == "" then currenttype.description = newtype.description end |
| if newtype.shortdescription or newtype.shortdescription == "" then currenttype.shortdescription = newtype.shortdescription end |
| if newtype.sourcerange.min and newtype.sourcerange.max then |
| currenttype.sourcerange.min = newtype.sourcerange.min |
| currenttype.sourcerange.max = newtype.sourcerange.max |
| end |
| end |
| end |
| else |
| self:addtype(newtype) |
| end |
| end, |
| |
| addglobalvar = function (self,item) |
| self.globalvars[item.name] = item |
| item.parent = self |
| end, |
| |
| moduletyperef = function (self) |
| if self and self.returns[1] and self.returns[1].types[1] then |
| local typeref = self.returns[1].types[1] |
| return typeref |
| end |
| end |
| } |
| return file |
| end |
| |
| function M._recordtypedef(name) |
| local recordtype = { |
| -- FIELDS |
| tag = "recordtypedef", |
| name = name, -- string (mandatory) |
| shortdescription = "", -- string |
| description = "", -- string |
| fields = {}, -- map from fieldname to field |
| sourcerange = {min=0,max=0}, |
| supertype = nil, -- supertype of the type def (inheritance), should be a recordtypedef ref |
| defaultkeytyperef = nil, -- the default typeref of key |
| defaultvaluetyperef = nil, -- the default typeref of value |
| structurekind = nil, -- kind of structure of the type: could be nil, "map" or "list" |
| structuredescription = nil, -- description of the structure |
| call = nil, -- typeref to the function use as __call on the type. |
| -- FUNCTIONS |
| addfield = function (self,field) |
| self.fields[field.name] = field |
| field.parent = self |
| end, |
| |
| getcalldef = function( self) |
| if self.call and self.call.tag == 'internaltyperef' then |
| if self.parent and self.parent.tag == 'file' then |
| local file = self.parent |
| return file.types[self.call.typename] |
| end |
| end |
| end |
| } |
| return recordtype |
| end |
| |
| function M._functiontypedef(name) |
| return { |
| tag = "functiontypedef", |
| name = name, -- string (mandatory) |
| shortdescription = "", -- string |
| description = "", -- string |
| params = {}, -- list of parameter |
| returns = {} -- list of return |
| } |
| end |
| |
| function M._parameter(name) |
| return { |
| tag = "parameter", |
| name = name, -- string (mandatory) |
| description = "", -- string |
| type = nil -- typeref (external or internal or primitive typeref) |
| } |
| end |
| |
| function M._item(name) |
| return { |
| -- FIELDS |
| tag = "item", |
| name = name, -- string (mandatory) |
| shortdescription = "", -- string |
| description = "", -- string |
| type = nil, -- typeref (external or internal or primitive typeref) |
| occurrences = {}, -- list of identifier (see internalmodel) |
| sourcerange = {min=0, max=0}, |
| |
| -- This is A TRICK |
| -- This value is ALWAYS nil, except for internal purposes (short references). |
| external = nil, |
| |
| -- FUNCTIONS |
| addoccurence = function (self,occ) |
| table.insert(self.occurrences,occ) |
| occ.definition = self |
| end, |
| |
| resolvetype = function (self,file) |
| if self and self.type then |
| if self.type.tag =="internaltyperef" then |
| -- if file is not given try to retrieve it. |
| if not file then |
| if self.parent and self.parent.tag == 'recordtypedef' then |
| file = self.parent.parent |
| elseif self.parent.tag == 'file' then |
| file = self.parent |
| end |
| end |
| if file then return file.types[self.type.typename] end |
| elseif self.type.tag =="inlinetyperef" then |
| return self.type.def |
| end |
| end |
| end |
| } |
| end |
| |
| function M._externaltypref(modulename, typename) |
| return { |
| tag = "externaltyperef", |
| modulename = modulename, -- string |
| typename = typename -- string |
| } |
| end |
| |
| function M._internaltyperef(typename) |
| return { |
| tag = "internaltyperef", |
| typename = typename -- string |
| } |
| end |
| |
| function M._primitivetyperef(typename) |
| return { |
| tag = "primitivetyperef", |
| typename = typename -- string |
| } |
| end |
| |
| function M._moduletyperef(modulename,returnposition) |
| return { |
| tag = "moduletyperef", |
| modulename = modulename, -- string |
| returnposition = returnposition -- number |
| } |
| end |
| |
| function M._exprtyperef(expression,returnposition) |
| return { |
| tag = "exprtyperef", |
| expression = expression, -- expression (see internal model) |
| returnposition = returnposition -- number |
| } |
| end |
| |
| function M._inlinetyperef(definition) |
| return { |
| tag = "inlinetyperef", |
| def = definition, -- expression (see internal model) |
| |
| } |
| end |
| |
| function M._return(description) |
| return { |
| tag = "return", |
| description = description or "", -- string |
| types = {} -- list of typref (external or internal or primitive typeref) |
| } |
| end |
| return M |
