-- -- Project: LuaIDL -- Author: Ricardo Cosme -- Filename: sin.lua -- -- OMG IDL Grammar (Corba v3.0) -- LL(1) --(1) := --(2) := --(3) | empty --(4) := TK_IMPORT ";" --(5) := --(6) | TK_STRING_LITERAL --(7) := TK_ID --(8) | ":" ":" TK_ID --(9) := ":" ":" TK_ID --(10) | empty --(11) := --(12) := --(13) | empty --(14) := ";" --(15) | ";" --(16) | ";" --(17) | ";" --(18) | ";" --(19) | ";" --(20) | ";" --(21) | ";" --(22) | ";" --(23) := "typedef" --(24) | --(25) | TK_NATIVE TK_ID --(26) | --(27) := --(28) := --(29) | --(30) := --(31) | --(32) | --(33) := --(34) | --(35) | --(36) := --(37) | TK_CHAR -- | TK_WCHAR ** --(38) | TK_BOOLEAN --(39) | TK_OCTET --(40) | TK_ANY --(41) | TK_OBJECT --(42) | TK_VALUEBASE --(43) := --(44) | --(45) | TK_LONG --(46) := TK_FLOAT --(47) | TK_DOUBLE --(48) := TK_SHORT --(49) | --(50) := TK_UNSIGNED --(51) := TK_LONG --(52) | TK_SHORT --(53) := TK_LONG --(54) | empty --(55) := TK_LONG --(56) | TK_DOUBLE --(57) | empty --(58) := --(59) | -- | ** --(60) | --(61) := TK_SEQUENCE "<" --(69) := "," ">" --(70) | ">" --(71) := TK_STRING --(72) := "<" ">" --(73) | empty -- := TK_WSTRING ** --(74) := TK_FIXED "<" "," ">" --(75) := --(91) := "|" --(92) | empty --(93) := --(94) := "^" --(95) | empty --(96) := --(97) := "&" --(98) | empty --(99) := --(100) := ">>" --(101) | "<<" --(102) | empty --(103) := --(104) := "+" --(105) | "-" --(106) | empty --(107) := --(108) := "*" --(109) | "/" --(110) | "%" --(111) | empty --(112) := --(113) | --(114) := "-" --(115) | "+" --(116) | "~" --(117) := --(118) | --(119) | "(" ")" --(120) := TK_INTEGER_LITERAL --(121) | TK_STRING_LITERAL -- | TK_WSTRING_LITERAL ** --(122) | TK_CHAR_LITERAL -- | TK_WCHAR_LITERAL ** --(123) | TK_FIXED_LITERAL --(124) | TK_FLOAT_LITERAL --(125) | --(126) := TK_TRUE --(127) | TK_FALSE --(136) := TK_STRUCT TK_ID "{" "}" --(137) := --(138) := --(139) | empty --(140) := ";" --(141) := --(142) := "," --(143) | empty --(144) := TK_ID --(145) := --(146) | empty --(147) := "[" "]" --(148) := TK_UNION TK_ID TK_SWITCH "(" ")" -- "{" "}" --(149) := --(150) | TK_LONG --(151) | TK_CHAR --(152) | TK_BOOLEAN --(153) | TK_ENUM --(154) | --(155) := --(156) := --(157) | empty --(158) := ";" --(159) := --(160) := --(161) | empty --(162) := TK_CASE ":" --(163) | TK_DEFAULT ":" --(164) := --(165) := TK_ENUM -- "{" "}" --(166) := "," --(167) | empty --(168) := TK_STRUCT TK_ID --(169) | TK_UNION TK_ID TK_SWITCH --(170) := "{" "}" --(171) | empty --(172) := TK_SWITCH "(" ")" -- "{" "}" --(173) | empty --(174) := TK_CONST TK_ID "=" --(175) := --(176) | TK_CHAR -- | TK_WCHAR ** --(177) | TK_BOOLEAN --(178) | TK_STRING -- | TK_WSTRING ** --(179) | --(180) | TK_OCTET --(181) | TK_FIXED --(186) := TK_EXCEPTION TK_ID "{" "}" --(187) := --(188) | empty --(189) := TK_ABSTRACT --(190) | TK_LOCAL TK_INTERFACE TK_ID --(191) | TK_CUSTOM --(192) | TK_INTERFACE TK_ID --(193) | TK_VALUETYPE TK_ID --(194) | TK_EVENTTYPE TK_ID --(195) := TK_INTERFACE TK_ID --(196) | TK_VALUETYPE TK_ID --(197) | TK_EVENTTYPE TK_ID --(198) := ":" "{" "}" --(199) | "{" "}" --(200) | empty --(205) := "," --(206) | empty --(207) := --(208) | empty --(209) := ";" --(210) | ";" --(211) | ";" --(212) | ";" --(213) | ";" --(214) | ";" --(215) | ";" --(216) := --(217) | --(218) := TK_READONLY TK_ATTRIBUTE --(219) := --(220) | -- | ** --(221) | --(226) := TK_ID --(227) := --(228) | -- | empty --(229) := TK_RAISES "(" ")" --(230) --(231) | empty --(232) := TK_ATTRIBUTE --(233) := TK_ID --(234) := --(235) | -- | empty --(236) := TK_GETRAISES --(237) | TK_SETRAISES --(238) := TK_SETRAISES --(239) | empty --(240) := "(" ")" --(241) := "," --(242) | empty --(243) := TK_ONEWAY TK_ID -- --(244) | TK_ID -- --(245) := --(246) | TK_VOID --(247) := "(" --(248) := --(249) | ")" --(250) := TK_ID --(251) := TK_IN --(252) | TK_OUT --(253) | TK_INOUT --(254) := "," --(255) | empty --(256) := TK_CONTEXT "(" ")" --(257) := "," --(258) | empty --(259) := TK_TYPEID TK_STRING_LITERAL --(260) := TK_TYPEPREFIX TK_STRING_LITERAL --(265) := "{" "} --(266) | "{" "}" --(267) | empty --(268) := ":" -- --(269) | --(270) | empty --(271) := TK_TRUNCATABLE --(272) | empty --(273) := TK_ID --(274) | ":" ":" TK_ID --(275) := ":" ":" TK_ID --(276) | empty --(277) := "," --(278) | empty --(279) := TK_SUPPORTS --(280) | empty --(281) := TK_VALUETYPE TK_ID --(282) | TK_EVENTTYPE TK_ID --(283) := "{" "}" --(284) | "{" "}" --(285) := --(286) | empty --(287) := --(288) | --(289) | --(290) := TK_PUBLIC ";" --(291) | TK_PRIVATE ";" --(292) := TK_FACTORY TK_ID "(" ")" -- ";" --(293) := --(294) | empty --(295) := "," --(296) | empty --(297) := TK_IN TK_ID --(298) := "{" "}" --(299) | "{" "}" --(300) | --(301) | empty --(302) := "{" "}" --(303) | "{" "}" --(304) | empty --(305) := TK_MODULE TK_ID "{" "}" --(306) := TK_COMPONENT TK_ID --(307) := -- "{" "}" --(308) | "{" "}" --(309) | "{" "}" --(310) | empty --(311) := ":" --(312) := TK_ID --(313) | ":" ":" TK_ID --(314) := ":" ":" TK_ID --(315) | empty --(316) := TK_SUPPORTS --(316e) | empty --(317) := TK_ID --(318) | ":" ":" TK_ID --(319) := ":" ":" TK_ID --(320) | empty --(321) := "," --(322) | empty --(323) := --(324) | empty --(325) := ";" --(326) | ";" --(327) | ";" --(328) | ";" --(329) | ";" --(330) | ";" --(331) := TK_PROVIDES TK_ID --(332) := --(333) | TK_OBJECT --(338) := TK_USES TK_ID --(339) := TK_MULTIPLE --(340) | empty --(341) := TK_EMITS TK_ID --(342) := TK_PUBLISHES TK_ID --(343) := TK_CONSUMES TK_ID --(344) := TK_HOME TK_ID --(345) := -- TK_MANAGES -- "{" "}"raises_expr> --(346) | TK_MANAGES -- "{" "}" --(347) | TK_MANAGES -- "{" "}" --(348) := ":" --(353) := TK_PRIMARYKEY --(354) | empty --(359) := --(360) | empty --(361) := --(362) | ";" --(363) | ";" --(364) := TK_FACTORY TK_ID "(" ")" -- --(365) := TK_FINDER TK_ID "(" ")" -- --(366) := --(367) | empty --(368) := "," --(369) | empty --(370) := --(371) | empty --(376) := TK_ID --(377) := --(378) | empty --(379) := TK_STRING_LITERAL local type = type local pairs = pairs local tonumber = tonumber local require = require local error = error local ipairs = ipairs local math = require "math" local string = require "string" local table = require "table" module 'luaidl.sin' local lex = require 'luaidl.lex' local tab_firsts = {} local tab_follow = {} local function set_firsts(firsts) local tab = {} for _, token in ipairs(firsts) do local tokenDcl = lex.tab_tokens[token] if tokenDcl then tab[tokenDcl] = true else tab[token] = true end end return tab end tab_firsts.rule_1 = set_firsts { 'TK_IMPORT' } tab_firsts.rule_11 = set_firsts { 'TK_TYPEDEF','TK_ENUM','TK_NATIVE','TK_UNION','TK_STRUCT', 'TK_CONST','TK_EXCEPTION','TK_ABSTRACT','TK_LOCAL', 'TK_INTERFACE','TK_CUSTOM','TK_VALUETYPE', 'TK_EVENTTYPE','TK_MODULE','TK_TYPEID', 'TK_TYPEPREFIX','TK_COMPONENT','TK_HOME' } tab_firsts.rule_12 = tab_firsts.rule_11 tab_firsts.rule_14 = set_firsts { 'TK_TYPEDEF', 'TK_ENUM', 'TK_NATIVE', 'TK_UNION', 'TK_STRUCT' } tab_firsts.rule_15 = set_firsts { 'TK_CONST' } tab_firsts.rule_16 = set_firsts { 'TK_EXCEPTION' } tab_firsts.rule_17 = set_firsts { 'TK_ABSTRACT', 'TK_LOCAL', 'TK_INTERFACE', 'TK_CUSTOM', 'TK_VALUETYPE', 'TK_EVENTTYPE' } tab_firsts.rule_18 = set_firsts { 'TK_MODULE' } tab_firsts.rule_19 = set_firsts { 'TK_TYPEID' } tab_firsts.rule_20 = set_firsts { 'TK_TYPEPREFIX' } tab_firsts.rule_21 = set_firsts { 'TK_COMPONENT' } tab_firsts.rule_22 = set_firsts { 'TK_HOME' } tab_firsts.rule_23 = set_firsts { 'TK_TYPEDEF' } tab_firsts.rule_24 = set_firsts { 'TK_ENUM' } tab_firsts.rule_25 = set_firsts { 'TK_NATIVE' } tab_firsts.rule_26 = set_firsts { 'TK_STRUCT', 'TK_UNION' } tab_firsts.rule_27 = set_firsts { 'TK_CHAR', 'TK_BOOLEAN', 'TK_OCTET', 'TK_ANY', 'TK_OBJECT', 'TK_VALUEBASE', 'TK_LONG', 'TK_FLOAT', 'TK_DOUBLE', 'TK_SHORT', 'TK_UNSIGNED', 'TK_SEQUENCE' , 'TK_STRING', 'TK_FIXED' , 'TK_ID', ":", 'TK_STRUCT', 'TK_UNION', 'TK_ENUM', } tab_firsts.rule_28 = set_firsts { 'TK_CHAR', 'TK_BOOLEAN', 'TK_OCTET', 'TK_ANY', 'TK_OBJECT', 'TK_VALUEBASE', 'TK_LONG', 'TK_FLOAT', 'TK_DOUBLE', 'TK_SHORT', 'TK_UNSIGNED', 'TK_SEQUENCE' , 'TK_STRING', 'TK_FIXED' , 'TK_ID', ":", } tab_firsts.rule_29 = set_firsts { 'TK_STRUCT', 'TK_UNION', 'TK_ENUM' } tab_firsts.rule_30 = set_firsts { 'TK_CHAR', 'TK_BOOLEAN', 'TK_OCTET', 'TK_ANY', 'TK_OBJECT', 'TK_VALUEBASE', 'TK_LONG', 'TK_FLOAT', 'TK_DOUBLE', 'TK_SHORT', 'TK_UNSIGNED', } tab_firsts.rule_31 = set_firsts { 'TK_SEQUENCE', 'TK_STRING', 'TK_FIXED' } tab_firsts.rule_32 = set_firsts { 'TK_ID', ':' } tab_firsts.rule_33 = set_firsts { 'TK_STRUCT' } tab_firsts.rule_34 = set_firsts { 'TK_UNION' } tab_firsts.rule_35 = set_firsts { 'TK_ENUM' } tab_firsts.rule_36 = set_firsts { 'TK_FLOAT', 'TK_DOUBLE', 'TK_SHORT', 'TK_UNSIGNED', 'TK_LONG' } tab_firsts.rule_37 = set_firsts { 'TK_CHAR' } tab_firsts.rule_38 = set_firsts { 'TK_BOOLEAN' } tab_firsts.rule_39 = set_firsts { 'TK_OCTET' } tab_firsts.rule_40 = set_firsts { 'TK_ANY' } tab_firsts.rule_41 = set_firsts { 'TK_OBJECT' } tab_firsts.rule_42 = set_firsts { 'TK_VALUEBASE' } tab_firsts.rule_43 = set_firsts { 'TK_FLOAT', 'TK_DOUBLE' } tab_firsts.rule_44 = set_firsts { 'TK_SHORT', 'TK_UNSIGNED' } tab_firsts.rule_45 = set_firsts { 'TK_LONG' } tab_firsts.rule_46 = set_firsts { 'TK_FLOAT' } tab_firsts.rule_47 = set_firsts { 'TK_DOUBLE' } tab_firsts.rule_48 = set_firsts { 'TK_SHORT' } tab_firsts.rule_49 = set_firsts { 'TK_UNSIGNED' } tab_firsts.rule_50 = tab_firsts.rule_49 tab_firsts.rule_51 = tab_firsts.rule_45 tab_firsts.rule_52 = set_firsts { 'TK_SHORT' } tab_firsts.rule_53 = set_firsts { 'TK_LONG' } tab_firsts.rule_55 = set_firsts { 'TK_LONG' } tab_firsts.rule_56 = set_firsts { 'TK_DOUBLE' } tab_firsts.rule_58 = set_firsts { 'TK_SEQUENCE' } tab_firsts.rule_59 = set_firsts { 'TK_STRING' } tab_firsts.rule_60 = set_firsts { 'TK_FIXED' } tab_firsts.rule_62 = tab_firsts.rule_30 tab_firsts.rule_63 = tab_firsts.rule_31 tab_firsts.rule_64 = tab_firsts.rule_32 tab_firsts.rule_69 = set_firsts { ',' } tab_firsts.rule_70 = set_firsts { '>' } tab_firsts.rule_72 = set_firsts { '<' } tab_firsts.rule_75 = set_firsts { '-', '+', '~', '(', 'TK_ID', ':', 'TK_INTEGER_LITERAL', 'TK_STRING_LITERAL', 'TK_CHAR_LITERAL', 'TK_FIXED_LITERAL', 'TK_FLOAT_LITERAL', 'TK_TRUE', 'TK_FALSE' } tab_firsts.rule_93 = tab_firsts.rule_75 tab_firsts.rule_91 = set_firsts { '|' } tab_firsts.rule_94 = set_firsts { '^' } tab_firsts.rule_96 = tab_firsts.rule_75 tab_firsts.rule_97 = set_firsts { '&' } tab_firsts.rule_99 = tab_firsts.rule_75 tab_firsts.rule_100 = set_firsts { '>>' } tab_firsts.rule_101 = set_firsts { '<<' } tab_firsts.rule_103 = tab_firsts.rule_75 tab_firsts.rule_104 = set_firsts { '+' } tab_firsts.rule_105 = set_firsts { '-' } tab_firsts.rule_107 = tab_firsts.rule_75 tab_firsts.rule_108 = set_firsts { '*' } tab_firsts.rule_109 = set_firsts { '/' } tab_firsts.rule_110 = set_firsts { '%' } tab_firsts.rule_112 = set_firsts { '-', '+', '~' } tab_firsts.rule_113 = set_firsts { '(', 'TK_ID', ':', 'TK_INTEGER_LITERAL', 'TK_STRING_LITERAL', 'TK_CHAR_LITERAL', 'TK_FIXED_LITERAL', 'TK_FLOAT_LITERAL', 'TK_TRUE', 'TK_FALSE' } tab_firsts.rule_114 = set_firsts { '-' } tab_firsts.rule_115 = set_firsts { '+' } tab_firsts.rule_116 = set_firsts { '~' } tab_firsts.rule_117 = set_firsts { 'TK_ID', ':' } tab_firsts.rule_118 = set_firsts { 'TK_INTEGER_LITERAL', 'TK_STRING_LITERAL', 'TK_CHAR_LITERAL', 'TK_FIXED_LITERAL', 'TK_FLOAT_LITERAL', 'TK_TRUE', 'TK_FALSE' } tab_firsts.rule_119 = set_firsts { '(' } tab_firsts.rule_120 = set_firsts { 'TK_INTEGER_LITERAL' } tab_firsts.rule_121 = set_firsts { 'TK_STRING_LITERAL' } tab_firsts.rule_122 = set_firsts { 'TK_CHAR_LITERAL' } tab_firsts.rule_123 = set_firsts { 'TK_FIXED_LITERAL' } tab_firsts.rule_124 = set_firsts { 'TK_FLOAT_LITERAL' } tab_firsts.rule_125 = set_firsts { 'TK_TRUE', 'TK_FALSE' } tab_firsts.rule_126 = set_firsts { 'TK_TRUE' } tab_firsts.rule_127 = set_firsts { 'TK_FALSE' } tab_firsts.rule_137 = tab_firsts.rule_27 tab_firsts.rule_138 = tab_firsts.rule_137 tab_firsts.rule_140 = tab_firsts.rule_138 tab_firsts.rule_141 = set_firsts { 'TK_ID' } tab_firsts.rule_142 = set_firsts { "," } tab_firsts.rule_144 = tab_firsts.rule_141 tab_firsts.rule_145 = set_firsts { "[" } tab_firsts.rule_147 = tab_firsts.rule_145 tab_firsts.rule_148 = set_firsts { 'TK_UNION' } tab_firsts.rule_149 = tab_firsts.rule_44 tab_firsts.rule_150 = set_firsts { 'TK_LONG' } tab_firsts.rule_151 = set_firsts { 'TK_CHAR' } tab_firsts.rule_152 = set_firsts { 'TK_BOOLEAN' } tab_firsts.rule_153 = set_firsts { 'TK_ENUM' } tab_firsts.rule_154 = set_firsts { 'TK_ID', ':' } tab_firsts.rule_155 = set_firsts { 'TK_CASE', 'TK_DEFAULT' } tab_firsts.rule_156 = set_firsts { 'TK_CASE', 'TK_DEFAULT' } tab_firsts.rule_158 = set_firsts { 'TK_CASE', 'TK_DEFAULT' } tab_firsts.rule_159 = set_firsts { 'TK_CASE', 'TK_DEFAULT' } tab_firsts.rule_160 = set_firsts { 'TK_CASE', 'TK_DEFAULT' } tab_firsts.rule_162 = set_firsts { 'TK_CASE' } tab_firsts.rule_163 = set_firsts { 'TK_DEFAULT' } tab_firsts.rule_164 = tab_firsts.rule_27 tab_firsts.rule_166 = set_firsts { "," } tab_firsts.rule_168 = set_firsts { 'TK_STRUCT' } tab_firsts.rule_169 = set_firsts { 'TK_UNION' } tab_firsts.rule_170 = set_firsts { '{' } tab_firsts.rule_172 = set_firsts { 'TK_SWITCH' } tab_firsts.rule_174 = set_firsts { 'TK_CONST' } tab_firsts.rule_175 = tab_firsts.rule_36 tab_firsts.rule_176 = set_firsts { 'TK_CHAR' } tab_firsts.rule_177 = set_firsts { 'TK_BOOLEAN' } tab_firsts.rule_178 = set_firsts { 'TK_STRING' } tab_firsts.rule_179 = set_firsts { 'TK_ID', ':' } tab_firsts.rule_180 = set_firsts { 'TK_OCTET' } tab_firsts.rule_181 = set_firsts { 'TK_FIXED' } tab_firsts.rule_186 = set_firsts { 'TK_EXCEPTION' } tab_firsts.rule_187 = tab_firsts.rule_137 tab_firsts.rule_189 = set_firsts { 'TK_ABSTRACT' } tab_firsts.rule_190 = set_firsts { 'TK_LOCAL' } tab_firsts.rule_191 = set_firsts { 'TK_CUSTOM' } tab_firsts.rule_192 = set_firsts { 'TK_INTERFACE' } tab_firsts.rule_193 = set_firsts { 'TK_VALUETYPE' } tab_firsts.rule_194 = set_firsts { 'TK_EVENTTYPE' } tab_firsts.rule_195 = set_firsts { 'TK_INTERFACE' } tab_firsts.rule_196 = set_firsts { 'TK_VALUETYPE' } tab_firsts.rule_198 = set_firsts { ':' } tab_firsts.rule_199 = set_firsts { '{' } tab_firsts.rule_207 = set_firsts { 'TK_ONEWAY', 'TK_VOID', 'TK_STRING', 'TK_ID', ':', 'TK_CHAR', 'TK_BOOLEAN', 'TK_OCTET', 'TK_ANY', 'TK_OBJECT', 'TK_VALUEBASE', 'TK_LONG', 'TK_FLOAT', 'TK_DOUBLE', 'TK_SHORT', 'TK_UNSIGNED','TK_TYPEDEF', 'TK_ENUM', 'TK_NATIVE', 'TK_UNION', 'TK_STRUCT', 'TK_EXCEPTION', 'TK_READONLY', 'TK_ATTRIBUTE', 'TK_CONST', -- 'TK_TYPECODE', } tab_firsts.rule_209 = tab_firsts.rule_14 tab_firsts.rule_210 = set_firsts { 'TK_CONST' } tab_firsts.rule_211 = set_firsts { 'TK_EXCEPTION' } tab_firsts.rule_212 = set_firsts { 'TK_READONLY', 'TK_ATTRIBUTE' } tab_firsts.rule_213 = set_firsts { 'TK_ONEWAY', 'TK_VOID', 'TK_STRING', 'TK_ID', ':', 'TK_CHAR', 'TK_BOOLEAN', 'TK_OCTET', 'TK_ANY', 'TK_OBJECT', 'TK_VALUEBASE', 'TK_LONG', 'TK_FLOAT', 'TK_DOUBLE', 'TK_SHORT', 'TK_UNSIGNED', } tab_firsts.rule_216 = set_firsts { 'TK_READONLY' } tab_firsts.rule_217 = set_firsts { 'TK_ATTRIBUTE' } tab_firsts.rule_219 = tab_firsts.rule_30 tab_firsts.rule_220 = set_firsts { 'TK_STRING' } tab_firsts.rule_221 = tab_firsts.rule_32 tab_firsts.rule_227 = set_firsts { 'TK_RAISES' } tab_firsts.rule_228 = set_firsts { ',' } tab_firsts.rule_230 = set_firsts { 'TK_ID' } tab_firsts.rule_234 = set_firsts { 'TK_GETRAISES', 'TK_SETRAISES' } tab_firsts.rule_235 = set_firsts { ',' } tab_firsts.rule_236 = set_firsts { 'TK_GETRAISES' } tab_firsts.rule_237 = set_firsts { 'TK_SETRAISES' } tab_firsts.rule_238 = tab_firsts.rule_237 tab_firsts.rule_243 = set_firsts { 'TK_ONEWAY' } tab_firsts.rule_244 = set_firsts { 'TK_VOID', 'TK_STRING', 'TK_ID', ':', 'TK_CHAR', 'TK_BOOLEAN', 'TK_OCTET', 'TK_ANY', 'TK_OBJECT', 'TK_VALUEBASE', 'TK_LONG', 'TK_FLOAT', 'TK_DOUBLE', 'TK_SHORT', 'TK_UNSIGNED', } tab_firsts.rule_245 = set_firsts { 'TK_CHAR', 'TK_BOOLEAN', 'TK_OCTET', 'TK_ANY', 'TK_OBJECT', 'TK_VALUEBASE', 'TK_LONG', 'TK_FLOAT', 'TK_DOUBLE', 'TK_SHORT', 'TK_UNSIGNED', 'TK_STRING', 'TK_ID', ":", } tab_firsts.rule_246 = set_firsts { 'TK_VOID' } tab_firsts.rule_248 = set_firsts { 'TK_IN', 'TK_OUT', 'TK_INOUT' } tab_firsts.rule_249 = set_firsts { ')' } tab_firsts.rule_251 = set_firsts { 'TK_IN' } tab_firsts.rule_252 = set_firsts { 'TK_OUT' } tab_firsts.rule_253 = set_firsts { 'TK_INOUT' } tab_firsts.rule_254 = set_firsts { ',' } tab_firsts.rule_257 = set_firsts { ',' } tab_firsts.rule_268 = set_firsts { ':' } tab_firsts.rule_269 = set_firsts { 'TK_SUPPORTS' } tab_firsts.rule_271 = set_firsts { 'TK_TRUNCATABLE' } tab_firsts.rule_277 = set_firsts { ',' } tab_firsts.rule_281 = set_firsts { 'TK_VALUETYPE' } tab_firsts.rule_285 = set_firsts { 'TK_ONEWAY', 'TK_VOID', 'TK_STRING', 'TK_ID', ':', 'TK_CHAR', 'TK_BOOLEAN', 'TK_OCTET', 'TK_ANY', 'TK_OBJECT', 'TK_VALUEBASE', 'TK_LONG', 'TK_FLOAT', 'TK_DOUBLE', 'TK_SHORT', 'TK_UNSIGNED','TK_TYPEDEF', 'TK_ENUM', 'TK_NATIVE', 'TK_UNION', 'TK_STRUCT', 'TK_EXCEPTION', 'TK_READONLY', 'TK_ATTRIBUTE', 'TK_PUBLIC', 'TK_PRIVATE', 'TK_FACTORY' } tab_firsts.rule_287 = tab_firsts.rule_207 tab_firsts.rule_288 = set_firsts { 'TK_PUBLIC', 'TK_PRIVATE' } tab_firsts.rule_289 = set_firsts { 'TK_FACTORY' } tab_firsts.rule_290 = set_firsts { 'TK_PUBLIC' } tab_firsts.rule_291 = set_firsts { 'TK_PRIVATE' } tab_firsts.rule_292 = tab_firsts.rule_289 tab_firsts.rule_297 = set_firsts { 'TK_IN' } tab_firsts.rule_298 = set_firsts { ':', 'TK_SUPPORTS' } tab_firsts.rule_299 = set_firsts { '{' } tab_firsts.rule_300 = tab_firsts.rule_27 tab_firsts.rule_302 = tab_firsts.rule_298 tab_firsts.rule_303 = set_firsts { '{' } tab_firsts.rule_305 = set_firsts { 'TK_MODULE' } tab_firsts.rule_306 = set_firsts { 'TK_COMPONENT' } tab_firsts.rule_307 = set_firsts { ':' } tab_firsts.rule_308 = set_firsts { 'TK_SUPPORTS' } tab_firsts.rule_309 = set_firsts { '{' } tab_firsts.rule_316 = set_firsts { 'TK_SUPPORTS' } tab_firsts.rule_321 = set_firsts { ',' } tab_firsts.rule_323 = set_firsts { 'TK_PROVIDES', 'TK_USES', 'TK_EMITS', 'TK_PUBLISHES', 'TK_CONSUMES', 'TK_READONLY', 'TK_ATTRIBUTE' } tab_firsts.rule_325 = set_firsts { 'TK_PROVIDES' } tab_firsts.rule_326 = set_firsts { 'TK_USES' } tab_firsts.rule_327 = set_firsts { 'TK_EMITS' } tab_firsts.rule_328 = set_firsts { 'TK_PUBLISHES' } tab_firsts.rule_329 = set_firsts { 'TK_CONSUMES' } tab_firsts.rule_330 = set_firsts { 'TK_READONLY', 'TK_ATTRIBUTE' } tab_firsts.rule_332 = set_firsts { 'TK_ID', ':' } tab_firsts.rule_333 = set_firsts { 'TK_OBJECT' } tab_firsts.rule_339 = set_firsts { 'TK_MULTIPLE' } tab_firsts.rule_345 = set_firsts { ':' } tab_firsts.rule_346 = set_firsts { 'TK_SUPPORTS' } tab_firsts.rule_347 = set_firsts { 'TK_MANAGES' } tab_firsts.rule_353 = set_firsts { 'TK_PRIMARYKEY' } tab_firsts.rule_359 = set_firsts { 'TK_ONEWAY', 'TK_VOID', 'TK_STRING', 'TK_ID', ':', 'TK_CHAR', 'TK_BOOLEAN', 'TK_OCTET', 'TK_ANY', 'TK_OBJECT', 'TK_VALUEBASE', 'TK_LONG', 'TK_FLOAT', 'TK_DOUBLE', 'TK_SHORT', 'TK_UNSIGNED','TK_TYPEDEF', 'TK_ENUM', 'TK_NATIVE', 'TK_UNION', 'TK_STRUCT', 'TK_EXCEPTION', 'TK_READONLY', 'TK_ATTRIBUTE', 'TK_FACTORY', 'TK_FINDER' } tab_firsts.rule_361 = tab_firsts.rule_207 tab_firsts.rule_362 = set_firsts { 'TK_FACTORY' } tab_firsts.rule_363 = set_firsts { 'TK_FINDER' } tab_firsts.rule_364 = tab_firsts.rule_362 tab_firsts.rule_365 = tab_firsts.rule_363 tab_firsts.rule_366 = tab_firsts.rule_297 tab_firsts.rule_368 = set_firsts { ',' } tab_firsts.rule_370 = set_firsts { 'TK_RAISES' } tab_firsts.rule_377 = set_firsts { 'TK_CONTEXT' } tab_firsts.rule_400 = set_firsts { 'TK_ID' } tab_firsts.rule_401 = set_firsts { ':' } tab_follow.rule_32 = set_firsts { 'TK_ID', ';' } tab_follow.rule_54 = set_firsts { 'TK_ID', '>', ';' } tab_follow.rule_61 = set_firsts { '>', ',' } tab_follow.rule_64 = set_firsts { ',', '>' } tab_follow.rule_69 = set_firsts { '>' } tab_follow.rule_72 = set_firsts { '>' } tab_follow.rule_73 = set_firsts { 'TK_ID' } tab_follow.rule_95 = set_firsts { '|', ']', ')' } tab_follow.rule_98 = set_firsts { '^', ']', ')' } tab_follow.rule_102 = set_firsts { '&', ']', ')' } tab_follow.rule_106 = set_firsts { '>>', '<<', '&', '^', '|', ']', ')' } tab_follow.rule_111 = set_firsts { '+', '-', '>>', '<<', '&', '^', '|', ']', ')' } tab_follow.rule_119 = set_firsts { ')' } tab_follow.rule_139 = set_firsts { '}' } tab_follow.rule_143 = set_firsts { ';' } tab_follow.rule_146 = set_firsts { ',', ';' } tab_follow.rule_147 = set_firsts { '*', '/', '%', '+', '-', '>>', '<<', '&', '^', '|', ']', ')' } tab_follow.rule_148 = set_firsts { ')' } tab_follow.rule_154 = set_firsts { ',', ')' } tab_follow.rule_157 = set_firsts { '}' } tab_follow.rule_161 = set_firsts { 'TK_CHAR', 'TK_BOOLEAN', 'TK_OCTET', 'TK_ANY', 'TK_OBJECT', 'TK_VALUEBASE', 'TK_LONG', 'TK_FLOAT', 'TK_DOUBLE', 'TK_SHORT', 'TK_UNSIGNED', 'TK_SEQUENCE' , 'TK_STRING', 'TK_FIXED' , 'TK_ID', ":", 'TK_STRUCT', 'TK_UNION', 'TK_ENUM', } tab_follow.rule_162 = set_firsts { ":" } tab_follow.rule_167 = set_firsts { "}" } tab_follow.rule_204 = set_firsts { ',', '{' } tab_follow.rule_221 = set_firsts { 'TK_ID' } tab_follow.rule_229 = set_firsts { ',', ')' } tab_follow.rule_268 = set_firsts { ',', 'TK_SUPPORTS', '{' } tab_follow.rule_272 = set_firsts { ':', 'TK_ID' } tab_follow.rule_278 = set_firsts { 'TK_SUPPORTS', '{' } tab_follow.rule_286 = set_firsts { '}' } tab_follow.rule_301 = set_firsts { ';' } tab_follow.rule_304 = set_firsts { ';' } tab_follow.rule_307 = set_firsts { 'TK_SUPPORTS', '{' } tab_follow.rule_308 = set_firsts { ',', '{' } tab_follow.rule_316 = set_firsts { ',', '{' } tab_follow.rule_316e = set_firsts { '{' } tab_follow.rule_321 = tab_follow.rule_316 tab_follow.rule_332 = set_firsts { 'TK_ID' } tab_follow.rule_340 = set_firsts { 'TK_MULTIPLE', 'TK_ID', ':', 'TK_OBJECT' } tab_follow.rule_341 = set_firsts { 'TK_ID' } tab_follow.rule_342 = tab_follow.rule_341 tab_follow.rule_343 = tab_follow.rule_342 tab_follow.rule_345 = set_firsts { ',', ':', 'TK_MANAGES' } tab_follow.rule_347 = set_firsts { 'TK_PRIMARYKEY', '{' } tab_follow.rule_348 = set_firsts { 'TK_SUPPORTS' } tab_follow.rule_353 = set_firsts { '{' } tab_follow.rule_359 = set_firsts { '}' } tab_follow.rule_367 = set_firsts { ',', ')' } tab_follow.rule_369 = set_firsts { ')' } tab_follow.rule_600 = set_firsts { 'TK_STRING_LITERAL' } local tab_follow_rule_error_msg = { [32] = 'identifier', [64] = "',' or '>'", [154] = "',' or ')'", [161] = "'char', 'boolean', 'octet', 'any', 'Object',".. "'ValueBase', 'long', 'float', 'double', 'short'".. "'unsigned', 'sequence', 'string', 'fixed', identifier,".. "'struct', 'union', 'enum'", [204] = "',', '{'", [221] = "identifier", [229] = "',', ')'", [268] = "',', 'supports' or '{'", [307] = "'{'", [308] = "',' or '{'", [345] = "':', ',' or 'manages'", [316] = "',', '{'", [332] = "identifier", [600] = 'string literal', } local token = lex.token local currentScope local namespaces -- It is a stack of roots. local scopeRoots local currentScopeName local CORBAVisible local tab_identifiers = {} -- this a list of type declarations local TAB_TYPEID = { ['CONST'] = 'const', ['NATIVE'] = 'native', ['CHAR'] = 'char', ['BOOLEAN'] = 'boolean', ['OCTET'] = 'octet', ['ANY'] = 'any', ['OBJECT'] = 'Object', ['VALUEBASE'] = 'valuebase', ['STRUCT'] = 'struct', ['FLOAT'] = 'float', ['SHORT'] = 'short', ['FLOAT'] = 'float', ['DOUBLE'] = 'double', ['USHORT'] = 'ushort', ['ULLONG'] = 'ulonglong', ['ULONG'] = 'ulong', ['LLONG'] = 'longlong', ['LDOUBLE'] = 'longdouble', ['LONG'] = 'long', ['STRING'] = 'string', ['FIXED'] = 'fixed', ['EXCEPTION'] = 'except', ['INTERFACE'] = 'interface', ['VOID'] = 'void', ['OPERATION'] = 'operation', ['TYPEDEF'] = 'typedef', ['ENUM'] = 'enum', ['SEQUENCE'] = 'sequence', ['ATTRIBUTE'] = 'attribute', ['MODULE'] = 'module', ['UNION'] = 'union', ['TYPECODE'] = 'TypeCode', ['COMPONENT'] = 'component', ['HOME'] = 'home', ['FACTORY'] = 'factory', ['FINDER'] = 'finder', ['VALUEBOX'] = 'valuebox', ['VALUETYPE'] = 'valuetype', ['EVENTTYPE'] = 'eventtype', } local TAB_BASICTYPE = { ['NATIVE'] = { _type = TAB_TYPEID['NATIVE'] }, ['CHAR'] = { _type = TAB_TYPEID['CHAR'] }, ['BOOLEAN'] = { _type = TAB_TYPEID['BOOLEAN'] }, ['OCTET'] = { _type = TAB_TYPEID['OCTET'] }, ['ANY'] = { _type = TAB_TYPEID['ANY'] }, ['OBJECT'] = { _type = TAB_TYPEID['OBJECT'], repID = 'IDL:omg.org/CORBA/Object:1.0' }, ['VALUEBASE'] = { _type = TAB_TYPEID['VALUEBASE'] }, ['FLOAT'] = { _type = TAB_TYPEID['FLOAT'] }, ['SHORT'] = { _type = TAB_TYPEID['SHORT'] }, ['FLOAT'] = { _type = TAB_TYPEID['FLOAT'] } , ['DOUBLE'] = { _type = TAB_TYPEID['DOUBLE'] }, ['USHORT'] = { _type = TAB_TYPEID['USHORT'] }, ['ULLONG'] = { _type = TAB_TYPEID['ULLONG'] }, ['ULONG'] = { _type = TAB_TYPEID['ULONG'] }, ['LLONG'] = { _type = TAB_TYPEID['LLONG'] }, ['LDOUBLE'] = { _type = TAB_TYPEID['LDOUBLE'] }, ['LONG'] = { _type = TAB_TYPEID['LONG'] }, ['FIXED'] = { _type = TAB_TYPEID['FIXED'] }, ['VOID'] = { _type = TAB_TYPEID['VOID'] }, ['STRING'] = { _type = TAB_TYPEID['STRING'] }, } local TAB_IMPLICITTYPE = { ['TYPECODE'] = { _type = TAB_TYPEID['TYPECODE'], repID = 'IDL:omg.org/CORBA/TypeCode:1.0' }, } local tab_legal_type = { [TAB_TYPEID.TYPEDEF] = true, [TAB_TYPEID.STRUCT] = true, [TAB_TYPEID.ENUM] = true, [TAB_TYPEID.INTERFACE] = true, [TAB_TYPEID.NATIVE] = true, [TAB_TYPEID.UNION] = true, [TAB_TYPEID.CHAR] = true, [TAB_TYPEID.BOOLEAN] = true, [TAB_TYPEID.OCTET] = true, [TAB_TYPEID.ANY] = true, [TAB_TYPEID.OBJECT] = true, [TAB_TYPEID.VALUEBASE] = true, [TAB_TYPEID.FLOAT] = true, [TAB_TYPEID.DOUBLE] = true, [TAB_TYPEID.SHORT] = true, [TAB_TYPEID.USHORT] = true, [TAB_TYPEID.ULLONG] = true, [TAB_TYPEID.ULONG] = true, [TAB_TYPEID.LLONG] = true, [TAB_TYPEID.LDOUBLE] = true, [TAB_TYPEID.LONG] = true, [TAB_TYPEID.FIXED] = true, [TAB_TYPEID.VOID] = true, [TAB_TYPEID.TYPECODE] = true, [TAB_TYPEID.SEQUENCE] = true, [TAB_TYPEID.STRING] = true, } local tab_accept_definition = { [TAB_TYPEID.STRUCT] = true, [TAB_TYPEID.EXCEPTION] = true, [TAB_TYPEID.INTERFACE] = true, [TAB_TYPEID.MODULE] = true, [TAB_TYPEID.COMPONENT] = true, [TAB_TYPEID.HOME] = true, [TAB_TYPEID.VALUETYPE] = true, [TAB_TYPEID.EVENTTYPE] = true, } local tab_define_scope = { [TAB_TYPEID.INTERFACE] = true, [TAB_TYPEID.EXCEPTION] = true, [TAB_TYPEID.OPERATION] = true, [TAB_TYPEID.FACTORY] = true, [TAB_TYPEID.STRUCT] = true, [TAB_TYPEID.UNION] = true, [TAB_TYPEID.MODULE] = true, [TAB_TYPEID.COMPONENT] = true, [TAB_TYPEID.VALUETYPE] = true, } local tab_is_contained = { [TAB_TYPEID.ATTRIBUTE] = true, [TAB_TYPEID.TYPEDEF] = true, [TAB_TYPEID.INTERFACE] = true, [TAB_TYPEID.OPERATION] = true, [TAB_TYPEID.CONST] = true, [TAB_TYPEID.STRUCT] = true, [TAB_TYPEID.EXCEPTION] = true, [TAB_TYPEID.MODULE] = true, [TAB_TYPEID.ENUM] = true, [TAB_TYPEID.UNION] = true, [TAB_TYPEID.COMPONENT] = true, [TAB_TYPEID.HOME] = true, [TAB_TYPEID.VALUETYPE] = true, [TAB_TYPEID.VALUEBOX] = true, [TAB_TYPEID.EVENTTYPE] = true, [TAB_TYPEID.TYPECODE] = true, } local TAB_VALUEEXPECTED = { [lex.tab_tokens.TK_ID] = "", [lex.tab_tokens.TK_ABSTRACT] = "abstract", [lex.tab_tokens.TK_ANY] = TAB_TYPEID.ANY, [lex.tab_tokens.TK_ATTRIBUTE] = TAB_TYPEID.ATTRIBUTE, [lex.tab_tokens.TK_BOOLEAN] = TAB_TYPEID.BOOLEAN, [lex.tab_tokens.TK_CASE] = "case", [lex.tab_tokens.TK_CHAR] = TAB_TYPEID.CHAR, [lex.tab_tokens.TK_COMPONENT] = TAB_TYPEID.COMPONENT, [lex.tab_tokens.TK_CONST] = TAB_TYPEID.CONST, [lex.tab_tokens.TK_CONSUMES] = "consumes", [lex.tab_tokens.TK_CONTEXT] = "context", [lex.tab_tokens.TK_CUSTOM] = "custom", [lex.tab_tokens.TK_DEFAULT] = "default", [lex.tab_tokens.TK_DOUBLE] = TAB_TYPEID.DOUBLEF, [lex.tab_tokens.TK_EXCEPTION] = TAB_TYPEID.EXCEPTION, [lex.tab_tokens.TK_EMITS] = "emits", [lex.tab_tokens.TK_ENUM] = TAB_TYPEID.ENUM, [lex.tab_tokens.TK_EVENTTYPE] = TAB_TYPEID.EVENTTYPE, [lex.tab_tokens.TK_FACTORY] = TAB_TYPEID.FACTORY, [lex.tab_tokens.TK_FALSE] = "FALSE", [lex.tab_tokens.TK_FINDER] = TAB_TYPEID.FINDER, [lex.tab_tokens.TK_FIXED] = TAB_TYPEID.FIXED, [lex.tab_tokens.TK_FLOAT] = TAB_TYPEID.FLOAT, [lex.tab_tokens.TK_GETRAISES] = "getraises", [lex.tab_tokens.TK_HOME] = TAB_TYPEID.HOME, [lex.tab_tokens.TK_IMPORT] = "import", [lex.tab_tokens.TK_IN] = "in", [lex.tab_tokens.TK_INOUT] = "inout", [lex.tab_tokens.TK_INTERFACE] = TAB_TYPEID.INTERFACE, [lex.tab_tokens.TK_LOCAL] = "local", [lex.tab_tokens.TK_LONG] = TAB_TYPEID.LONG, [lex.tab_tokens.TK_MODULE] = TAB_TYPEID.MODULE, [lex.tab_tokens.TK_MULTIPLE] = "multiple", [lex.tab_tokens.TK_NATIVE] = TAB_TYPEID.NATIVE, [lex.tab_tokens.TK_OBJECT] = TAB_TYPEID.OBJECT, [lex.tab_tokens.TK_OCTET] = TAB_TYPEID.OCTET, [lex.tab_tokens.TK_ONEWAY] = "oneway", [lex.tab_tokens.TK_OUT] = "out", [lex.tab_tokens.TK_PRIMARYKEY] = "primarykey", [lex.tab_tokens.TK_PRIVATE] = "private", [lex.tab_tokens.TK_PROVIDES] = "provides", [lex.tab_tokens.TK_PUBLIC] = "public", [lex.tab_tokens.TK_PUBLISHES] = "publishes", [lex.tab_tokens.TK_RAISES] = "raises", [lex.tab_tokens.TK_READONLY] = "readonly", [lex.tab_tokens.TK_SETRAISES] = "setraises", [lex.tab_tokens.TK_SEQUENCE] = "sequence", [lex.tab_tokens.TK_SHORT] = TAB_TYPEID.SHORT, [lex.tab_tokens.TK_STRING] = TAB_TYPEID.STRING, [lex.tab_tokens.TK_STRUCT] = TAB_TYPEID.STRUCT, [lex.tab_tokens.TK_SUPPORTS] = "supports", [lex.tab_tokens.TK_SWITCH] = "switch", [lex.tab_tokens.TK_TRUE] = "TRUE", [lex.tab_tokens.TK_TRUNCATABLE] = "truncatable", [lex.tab_tokens.TK_TYPEDEF] = TAB_TYPEID.TYPEDEF, [lex.tab_tokens.TK_TYPEID] = "typeid", [lex.tab_tokens.TK_TYPEPREFIX] = "typeprefix", [lex.tab_tokens.TK_UNSIGNED] = "unsigned", [lex.tab_tokens.TK_UNION] = TAB_TYPEID.UNION, [lex.tab_tokens.TK_USES] = "uses", [lex.tab_tokens.TK_VALUEBASE] = TAB_TYPEID.VALUEBASE, [lex.tab_tokens.TK_VALUETYPE] = TAB_TYPEID.VALUETYPE, [lex.tab_tokens.TK_VOID] = TAB_TYPEID.VOID, [lex.tab_tokens.TK_WCHAR] = "wchar", [lex.tab_tokens.TK_WSTRING] = "wstring", [lex.tab_tokens.TK_INTEGER_LITERAL] = "", [lex.tab_tokens.TK_FLOAT_LITERAL] = "", [lex.tab_tokens.TK_CHAR_LITERAL] = "", [lex.tab_tokens.TK_WCHAR_LITERAL] = "", [lex.tab_tokens.TK_STRING_LITERAL] = "", [lex.tab_tokens.TK_WSTRING_LITERAL] = "", [lex.tab_tokens.TK_FIXED_LITERAL] = "", [lex.tab_tokens.TK_PRAGMA_PREFIX] = "", [lex.tab_tokens.TK_PRAGMA_ID] = "", [lex.tab_tokens.TK_MANAGES] = "manages", } local rules = {} --- -- Error reporting --------------------------------------------------------------------------------------------------- local ERRMSG_DECLARED = "'%s' has already been declared" local ERRMSG_PARAMDECLARED = "parameter '%s' has already been declared" local ERRMSG_RAISESDECLARED = "raise '%s' has already been declared" local ERRMSG_OPDECLARED = "operation '%s' has already been declared" local ERRMSG_REDEFINITION = "redefinition of '%s'" local ERRMSG_NOTTYPE = "%s is not a legal type" local ERRMSG_UNDECLARED = "%s is an undeclared type" local ERRMSG_FORWARD = "There is a forward reference to %s, but it is not defined" local tab_ERRORMSG ={ [01] = "definition ('typedef', 'enum', 'native', 'union', 'struct', ".. "'const', 'exception', 'abstract', 'local', ".. "'interface', 'custom', 'valuetype', 'eventtype', ".. "'module', 'typeid', 'typeprefix', 'component' or 'home')", [02] = "type declaration ('typedef', 'struct', 'union', 'enum' or 'native')", [03] = "type specification ('char', 'boolean', 'octet', 'any', 'Object', ".. "'ValueBase', 'long', 'float', 'double', 'short', 'unsigned', 'sequence', ".. "'string', 'fixed', identifier, 'struct', 'union', 'enum')", [04] = "simple type specification (base type, template type or a scoped name)", [05] = "base type specification ('char', 'boolean', 'octet', 'any', 'Object', ".. "'ValueBase', 'long', 'float', 'double', 'short', 'unsigned')", [06] = "'float', 'double', 'short', 'unsigned' or 'long'", [07] = "'float' or 'double'", [08] = "'short' or 'unsigned'", [09] = "'long' or 'short'", --follows!? [10] = "'long'", [11] = "',' or ';'", [12] = "'[', ',' or ';'", [13] = "'-', '+', '~', '(', identifier, ':', ,".. ", , ,".. ", 'TRUE' or 'FALSE'", [14] = "'-', '+', '~'", [15] = "'(', identifier, ':', ,".. ", , ,".. ", 'TK_TRUE', 'TK_FALSE'", [16] = ", , ,".. ", ", [17] = "'TK_TRUE', 'TK_FALSE'", [18] = "'*', '/', '%', '+', '-', ']', ')', '>>', '<<', '&', '^', '|'", [19] = "'+', '-', '>>', '<<'", [20] = "'>>', '<<', '&'", [21] = "'&', '^'", [22] = "'^', '|'", [23] = "'|'", [24] = "you must entry with a positive integer", [25] = "you must entry with a integer", [26] = "'<' or identifier", [27] = "constructed type specification ('struct', 'union' or 'enum')", [28] = "type specification or '}'", [29] = "'short', 'unsigned', 'char', 'boolean', 'enum', identifier, '::'", [30] = "'case', 'default'", [31] = "'case', 'default' or type specification", [32] = "'case', 'default' or '}'", } local function sinError(valueExpected) error(string.format("%s(line %i): %s expected, encountered '%s'." , lex.srcfilename, lex.line, valueExpected, lex.tokenvalue), 2) end local function semanticError(error_msg) local scope = currentScope.absolute_name if (scope == '') then scope = 'GLOBAL' end error(string.format("%s(line %i):Scope:'%s': %s.", lex.srcfilename, lex.line, scope, error_msg), 2) end --------------------------------------------------------------------------------------------------- --- -- Auxiliar functions --------------------------------------------------------------------------------------------------- local function getID() return lex.tokenvalue_previous end local function registerID(id) if (string.sub(id, 1, 2) == "::") then id = string.sub(id, 3) end tab_identifiers[string.upper(currentScope.absolute_name.."::"..id)] = true; end local function gotoFatherScope() if (scopeRoots[#scopeRoots].scope == currentScope.absolute_name) then table.remove(scopeRoots) end local currentRoot = scopeRoots[#scopeRoots].root if (currentScope._type == TAB_TYPEID.MODULE) then currentRoot = string.gsub(currentRoot, "::[^:]+$", "") scopeRoots[#scopeRoots].root = currentRoot elseif (currentScope._type == TAB_TYPEID.INTERFACE) or (currentScope._type == TAB_TYPEID.STRUCT) or (currentScope._type == TAB_TYPEID.UNION) or (currentScope._type == TAB_TYPEID.EXCEPTION) then currentScopeName = string.gsub(currentScopeName, "::[^:]+$", "") end currentScope = namespaces[currentScope.absolute_name].father_scope end local function getAbsolutename(scope, name) return scope.absolute_name..'::'..name end local function dclName(name, target, value) local absolutename = getAbsolutename(currentScope, name) if namespaces[absolutename] then semanticError(string.format(ERRMSG_DECLARED, name)) else if tab_identifiers[string.upper(absolutename)] then semanticError("collision with '"..name.."'") end namespaces[absolutename] = {namespace = name} if value then value.name = name table.insert(target, value) else table.insert(target, name) end end end local recognize local function getToken() token = lex.lexer(idl) for _, linemark in ipairs(lex.tab_linemarks) do if linemark['1'] then table.insert(scopeRoots, {root = '', scope = currentScope.absolute_name}) elseif linemark['2'] then table.remove(scopeRoots) end end lex.tab_linemarks = {} -- The ID Pragma -- #pragma ID "" if (token == lex.tab_tokens.TK_PRAGMA_ID) then token = lex.lexer(idl) local definition = rules.scoped_name(600) local repid = lex.tokenvalue recognize(lex.tab_tokens.TK_STRING_LITERAL) local absolutename = definition.absolute_name if namespaces[absolutename].pragmaID then if (definition.repID ~= repid) then semanticError("repository ID ever defined") end else namespaces[absolutename].pragmaID = true definition.repID = repid end -- The Prefix Pragma -- #pragma prefix "" elseif (token == lex.tab_tokens.TK_PRAGMA_PREFIX) then token = lex.lexer(idl) local prefix = lex.tokenvalue if (scopeRoots[#scopeRoots].scope == currentScope.absolute_name) then table.remove(scopeRoots) end table.insert(scopeRoots, {root = prefix, scope = currentScope.absolute_name}) recognize(lex.tab_tokens.TK_STRING_LITERAL) end return token end function recognize(tokenExpected) if (tokenExpected == token) then token = getToken() else local valueExpected = TAB_VALUEEXPECTED[tokenExpected] if not valueExpected then valueExpected = "'"..tokenExpected.."'" end sinError(valueExpected) end end local function updateGlobalName(type, name) local localName = '' local currentRoot = scopeRoots[#scopeRoots].root -- Whenever a module is encountered, the string "::" and the are appended -- to the name of the current root. if (type == TAB_TYPEID.MODULE) then currentRoot = currentRoot..'::'..name -- Whenever a interface, struct, union or exception is encountered, -- the string "::" and the are appended to the name of the current scope. elseif ( (type == TAB_TYPEID.INTERFACE) or (type == TAB_TYPEID.STRUCT) or (type == TAB_TYPEID.UNION) or (type == TAB_TYPEID.EXCEPTION) ) then currentScopeName = currentScopeName..'::'..name else localName = '::'..name end scopeRoots[#scopeRoots].root = currentRoot return currentRoot, currentScopeName, localName end -- Define an OMG IDL definition. local function define(name, type, namespace) local absolutename = getAbsolutename(currentScope, name) local definitions -- Esta definição já foi declarada anteriormente? if (namespaces[absolutename]) then -- Um módulo está sendo reaberto? if ( (namespaces[absolutename].namespace._type == TAB_TYPEID.MODULE) and (type == TAB_TYPEID.MODULE) ) then namespace = namespaces[absolutename].namespace currentScope = namespace updateGlobalName(type, name) return nil, namespace else semanticError(string.format(ERRMSG_REDEFINITION, name)) end end -- A definição já foi declarada como forward? if forwardDeclarations[absolutename] then namespace = forwardDeclarations[absolutename] forwardDeclarations[absolutename] = nil end if (not definitions and tab_accept_definition[type]) then definitions = {} end local root, scope, localName = updateGlobalName(type, name) repID = root..scope..localName repID = string.gsub(string.gsub(repID, "^::", ""), "::", "/") if (not namespace) then namespace = {} end namespace.name = name namespace._type = type namespace.absolute_name = absolutename namespace.repID = "IDL:"..repID..":"..lex.PRAGMA_VERSION namespace.definitions = definitions if (tab_is_contained[type] and currentScope ~= output) then table.insert(currentScope.definitions, namespace) elseif (type == TAB_TYPEID.FACTORY) then currentScope.initializers = currentScope.initializers or {} table.insert(currentScope.initializers, namespace) else table.insert(currentScope, namespace) end if (tab_define_scope[type]) then namespaces[absolutename] = { father_scope = currentScope, namespace = namespace, } currentScope = namespace else namespaces[absolutename] = {namespace = namespace} end return true, namespace end -- This is an auxiliar function for getDefinition(). local function getTabDefinition(name) local namespace if namespaces[name] then namespace = namespaces[name].namespace end return namespace or forwardDeclarations[name] end local function getDefinition(name, baseScope) local scope = currentScope -- Busca uma definição em um escopo previamente fornecido. if baseScope then local definition = getTabDefinition(baseScope..'::'..name) if (definition) then return definition end else while true do local absolutename = getAbsolutename(scope, name) local definition = getTabDefinition(absolutename) if definition then return definition end if (scope._type == TAB_TYPEID.INTERFACE) then -- Busca a definição nas interfaces de base. for _, base in ipairs(scope) do absolutename = getAbsolutename(namespaces[base.absolute_name].namespace, name) local definition = getTabDefinition(absolutename) if definition then return definition end end end -- Se a definição não foi encontrada no escopo atual, então a busca continua -- no escopo *pai*. if (scope ~= output) then scope = namespaces[scope.absolute_name].father_scope else if (currentScope._type == TAB_TYPEID.UNION) then if (currentScope.switch._type == TAB_TYPEID.ENUM) then return namespaces[getAbsolutename(currentScope.switch, scope)].namespace end end break end end end semanticError(string.format(ERRMSG_UNDECLARED, name)) end -- Define uma declaração forward. local function dclForward(name, type) local absolute_name = getAbsolutename(currentScope, name) local definition = namespaces[absolute_name] or forwardDeclarations[absolute_name] if not definition then definition = {name = name, _type = type, absolute_name = absolute_name} forwardDeclarations[absolute_name] = definition end return definition end --------------------------------------------------------------------------------------------------- --- -- GRAMMAR RULES -------------------------------------------------------------------------- rules.specification = function () -- import_l() if (callbacks.start) then callbacks.start() end rules.definition_l() -- Is there any forward reference without definition? for definition, _ in pairs(forwardDeclarations) do semanticError(string.format(ERRMSG_FORWARD, definition)) end if (callbacks.finish) then callbacks.finish() end end rules.definition_l = function () if (tab_firsts.rule_11[token]) then rules.definition() rules.definition_l_r() else sinError(tab_ERRORMSG[01]) end end rules.definition_l_r = function () if (tab_firsts.rule_12[token]) then rules.definition() rules.definition_l_r() elseif (not token) then --empty else sinError(tab_ERRORMSG[01]) end end rules.definition = function () if (tab_firsts.rule_14[token]) then rules.type_dcl() elseif (tab_firsts.rule_15[token]) then rules.const_dcl() elseif (tab_firsts.rule_16[token]) then rules.except_dcl() elseif (tab_firsts.rule_17[token]) then rules.inter_value_event() elseif (tab_firsts.rule_18[token]) then rules.module() elseif (tab_firsts.rule_19[token]) then rules.type_id_dcl() elseif (tab_firsts.rule_20[token]) then rules.type_prefix_dcl() elseif (tab_firsts.rule_21[token]) then rules.component() elseif (tab_firsts.rule_22[token]) then rules.home_dcl() end recognize(";") end rules.const_dcl = function () if (tab_firsts.rule_174[token]) then recognize(lex.tab_tokens.TK_CONST) local type = rules.const_type() recognize(lex.tab_tokens.TK_ID) local name = getID() recognize("=") local value = rules.positive_int_const(143) local const = {type = type, value = value} define(name, TAB_TYPEID.CONST, const) if (callbacks.const) then callbacks.const(const) end end end rules.const_type = function () if (tab_firsts.rule_175[token]) then return rules.float_type_or_int_type() elseif (tab_firsts.rule_176[token]) then recognize(lex.tab_tokens.TK_CHAR) return TAB_BASICTYPE.CHAR elseif (tab_firsts.rule_177[token]) then recognize(lex.tab_tokens.TK_BOOLEAN) return TAB_BASICTYPE.BOOLEAN elseif (tab_firsts.rule_178[token]) then recognize(lex.tab_tokens.TK_STRING) return TAB_BASICTYPE.STRING elseif (tab_firsts.rule_179[token]) then return rules.scoped_name(32) elseif (tab_firsts.rule_180[token]) then recognize(lex.tab_tokens.TK_OCTET) return TAB_BASICTYPE.OCTET elseif (tab_firsts.rule_181[token]) then recognize(lex.tab_tokens.TK_FIXED) return TAB_BASICTYPE.FIXED end end rules.type_dcl = function () if (tab_firsts.rule_23[token]) then recognize(lex.tab_tokens.TK_TYPEDEF) rules.type_declarator() elseif (tab_firsts.rule_24[token]) then rules.enum_type() elseif (tab_firsts.rule_25[token]) then recognize(lex.tab_tokens.TK_NATIVE) recognize(lex.tab_tokens.TK_ID) define(getID(), TAB_TYPEID.NATIVE) elseif (tab_firsts.rule_26[token]) then rules.union_or_struct() else sinError(tab_ERRORMSG[02]) end end rules.type_declarator = function () local type = rules.type_spec() if (not tab_legal_type[type._type]) then semanticError(string.format(ERRMSG_NOTTYPE, type._type)) end rules.type_dcl_name_l(type) end rules.type_spec = function (numrule) if (tab_firsts.rule_28[token]) then return rules.simple_type_spec(numrule) elseif (tab_firsts.rule_29[token]) then return rules.constr_type_spec() else sinError(tab_ERRORMSG[03]) end end rules.simple_type_spec = function (numrule) if (tab_firsts.rule_30[token]) then return rules.base_type_spec() elseif (tab_firsts.rule_31[token]) then return rules.template_type_spec() elseif (tab_firsts.rule_32[token]) then tab = rules.scoped_name(numrule or 32) return tab else sinError(tab_ERRORMSG[04]) end end rules.base_type_spec = function () if (tab_firsts.rule_36[token]) then return rules.float_type_or_int_type() elseif (tab_firsts.rule_37[token]) then recognize(lex.tab_tokens.TK_CHAR) return TAB_BASICTYPE.CHAR elseif (tab_firsts.rule_38[token]) then recognize(lex.tab_tokens.TK_BOOLEAN) return TAB_BASICTYPE.BOOLEAN elseif (tab_firsts.rule_39[token]) then recognize(lex.tab_tokens.TK_OCTET) return TAB_BASICTYPE.OCTET elseif (tab_firsts.rule_40[token]) then recognize(lex.tab_tokens.TK_ANY) return TAB_BASICTYPE.ANY elseif (tab_firsts.rule_41[token]) then recognize(lex.tab_tokens.TK_OBJECT) return TAB_BASICTYPE.OBJECT elseif (tab_firsts.rule_42[token]) then recognize(lex.tab_tokens.TK_VALUEBASE) return TAB_BASICTYPE.VALUEBASE -- else -- sinError(tab_ERRORMSG[05]) end end rules.float_type_or_int_type = function () if (tab_firsts.rule_43[token]) then return rules.floating_pt_type() elseif (tab_firsts.rule_44[token]) then return rules.integer_type(54) elseif (tab_firsts.rule_45[token]) then recognize(lex.tab_tokens.TK_LONG) return rules.long_or_double() else sinError(tab_ERRORMSG[06]) end end rules.floating_pt_type = function () if (tab_firsts.rule_46[token]) then recognize(lex.tab_tokens.TK_FLOAT) return TAB_BASICTYPE.FLOAT elseif (tab_firsts.rule_47[token]) then recognize(lex.tab_tokens.TK_DOUBLE) return TAB_BASICTYPE.DOUBLE -- else -- sinError(tab_ERRORMSG[07]) end end rules.integer_type = function (numrule) if (tab_firsts.rule_48[token]) then recognize(lex.tab_tokens.TK_SHORT) return TAB_BASICTYPE.SHORT elseif (tab_firsts.rule_49[token]) then return rules.unsigned_int(numrule) -- else -- sinError(tab_ERRORMSG[08]) end end rules.unsigned_int = function (numrule) recognize(lex.tab_tokens.TK_UNSIGNED) return rules.unsigned_int_tail(numrule) end rules.unsigned_int_tail = function (numrule) if (tab_firsts.rule_51[token]) then recognize(lex.tab_tokens.TK_LONG) return rules.ulong_e(numrule) elseif (tab_firsts.rule_52[token]) then recognize(lex.tab_tokens.TK_SHORT) return TAB_BASICTYPE.USHORT else sinError(tab_ERRORMSG[09]) end end rules.long_e = function (numrule) if (tab_firsts.rule_53[token]) then recognize(lex.tab_tokens.TK_LONG) return TAB_BASICTYPE.LLONG elseif (tab_follow['rule_'..numrule][token]) then return TAB_BASICTYPE.LONG --empty else sinError(tab_ERRORMSG[10]) end end rules.ulong_e = function (numrule) if (tab_firsts.rule_53[token]) then recognize(lex.tab_tokens.TK_LONG) return TAB_BASICTYPE.ULLONG elseif (tab_follow['rule_'..numrule][token]) then return TAB_BASICTYPE.ULONG --empty else sinError(tab_ERRORMSG[10]) end end rules.type_dcl_name_l = function (type) rules.type_dcl_name(type) rules.type_dcl_name_l_r(type) end rules.type_dcl_name_l_r = function (type) if (tab_firsts.rule_142[token]) then recognize(",") rules.type_dcl_name(type) rules.type_dcl_name_l_r(type) elseif (tab_follow.rule_143 [token]) then --empty else sinError(tab_ERRORMSG[11]) end end rules.type_dcl_name = function (type) recognize(lex.tab_tokens.TK_ID) local name = getID() local typedef = {original_type = rules.fixed_array_size_l(type)} define(name, TAB_TYPEID.TYPEDEF, typedef) if (callbacks.typedef) then callbacks.typedef(typedef) end end -- without revision rules.fixed_array_size_l = function (tab_type_spec) if (tab_firsts.rule_145[token]) then local array = { length = rules.fixed_array_size(tab_type_spec), elementtype = rules.fixed_array_size_l(tab_type_spec), _type = 'array' } if callbacks.array then callbacks.array(array) end return array elseif (tab_follow.rule_146[token]) then --empty return tab_type_spec else sinError(tab_ERRORMSG[12]) end end rules.fixed_array_size = function (tab_type_spec) recognize("[") local const = rules.positive_int_const(147) recognize("]") return const end -- without revision --without revision --without bitwise logical operations rules.positive_int_const = function (numrule) if tab_firsts.rule_75[token] then local const1 = rules.xor_expr(numrule) rules.or_expr_l(numrule) if type(const1) == "string" and string.find(const1, '[%d]') then const1 = tonumber(const1) if const1 < 0 then semanticError(tab_ERRORMSG[24]) end end return const1 else sinError(tab_ERRORMSG[13]) end end rules.xor_expr = function (numrule) if tab_firsts.rule_93[token] then local exp1 = rules.and_expr(numrule) rules.xor_expr_l(numrule) return exp1 -- else -- sinError(tab_ERRORMSG[13]) end end rules.and_expr = function (numrule) if tab_firsts.rule_96[token] then local const1 = rules.shift_expr(numrule) return rules.and_expr_l(const1, numrule) -- else -- sinError(tab_ERRORMSG[13]) end end rules.shift_expr = function (numrule) if tab_firsts.rule_99[token] then local const1 = rules.add_expr(numrule) return rules.shift_expr_l(const1, numrule) -- else -- sinError(tab_ERRORMSG[13]) end end rules.add_expr = function (numrule) if tab_firsts.rule_103[token] then local const1 = rules.mult_expr(numrule) return rules.add_expr_l(const1, numrule) -- else -- sinError(tab_ERRORMSG[13]) end end rules.mult_expr = function (numrule) if tab_firsts.rule_107[token] then local const = rules.unary_expr() --[[ if not is_num(const) then semanticError(tab_ERRORMSG[25]) end ]] const = rules.mult_expr_l(const, numrule) return const -- else -- sinError(tab_ERRORMSG[13]) end end --semantic of '~' operator ???!! rules.unary_expr = function () if tab_firsts.rule_112[token] then local op = rules.unary_operator() local exp = rules.primary_expr() if tonumber(exp) then if op == '-' then exp = tonumber('-'..exp) elseif op == '+' then exp = tonumber('+'..exp) end end return exp elseif tab_firsts.rule_113[token] then return rules.primary_expr() -- else -- sinError(tab_ERRORMSG[13]) end end rules.unary_operator = function () if tab_firsts.rule_114[token] then recognize("-") return '-' elseif tab_firsts.rule_115[token] then recognize("+") return '+' elseif tab_firsts.rule_116[token] then recognize("~") return '~' -- else -- sinError(tab_ERRORMSG[14]) end end rules.primary_expr = function () if tab_firsts.rule_117[token] then local value = rules.case_label_aux() if type(value) == 'table' then sinError("The in the production must be a previously \ defined name of an , , , \ , , \ , , , or constant.") end return value elseif tab_firsts.rule_118[token] then local value = rules.literal() if (currentScope._type == TAB_TYPEID.UNION) then recognize(":") end return value elseif tab_firsts.rule_119[token] then recognize("(") local const = rules.positive_int_const(119) recognize(")") return const else sinError(tab_ERRORMSG[15]) end end rules.literal = function () if tab_firsts.rule_120[token] then recognize(lex.tab_tokens.TK_INTEGER_LITERAL) return getID() elseif tab_firsts.rule_121[token] then recognize(lex.tab_tokens.TK_STRING_LITERAL) return getID() elseif tab_firsts.rule_122[token] then recognize(lex.tab_tokens.TK_CHAR_LITERAL) return getID() elseif tab_firsts.rule_123[token] then recognize(lex.tab_tokens.TK_FIXED_LITERAL) return getID() elseif tab_firsts.rule_124[token] then recognize(lex.tab_tokens.TK_FLOAT_LITERAL) return getID() elseif tab_firsts.rule_125[token] then return rules.boolean_literal() -- else -- sinError(tab_ERRORMSG[16]) end end rules.boolean_literal = function () if tab_firsts.rule_126[token] then recognize(lex.tab_tokens.TK_TRUE) return true elseif tab_firsts.rule_127[token] then recognize(lex.tab_tokens.TK_FALSE) return false -- else -- sinError(tab_ERRORMSG[17]) end end rules.mult_expr_l = function (const1, numrule) if tab_firsts.rule_108[token] then recognize("*") local const2 = rules.unary_expr() if not tonumber(const2) then semanticError(tab_ERRORMSG[25]) end local const = const1 * const2 return rules.mult_expr_l(const, numrule) elseif tab_firsts.rule_109[token] then recognize("/") local const2 = rules.unary_expr() if not tonumber(const2) then semanticError(tab_ERRORMSG[25]) end local const = const1 / const2 return rules.mult_expr_l(const, numrule) elseif tab_firsts.rule_110[token] then recognize("%") local const2 = rules.unary_expr() if not tonumber(const2) then semanticError(tab_ERRORMSG[25]) end local const = math.mod(const1, const2) return rules.mult_expr_l(const, numrule) elseif ( tab_follow.rule_111[token] or tab_follow['rule_'..numrule][token] or (getID() == ':') ) then --empty return const1 else sinError(tab_ERRORMSG[18]) end end rules.add_expr_l = function (const1, numrule) if tab_firsts.rule_104[token] then recognize("+") if not tonumber(const1) then semanticError(tab_ERRORMSG[25]) end local const2 = rules.mult_expr(numrule) local const = const1 + const2 return rules.add_expr_l(const, numrule) elseif tab_firsts.rule_105[token] then recognize("-") if not tonumber(const1) then semanticError(tab_ERRORMSG[25]) end local const2 = rules.mult_expr(numrule) local const = const1 - const2 return rules.add_expr_l(const, numrule) elseif ( tab_follow.rule_106[token] or tab_follow['rule_'..numrule][token] or (getID() == ':') ) then --empty return const1 else sinError(tab_ERRORMSG[19]) end end rules.shift_expr_l = function (const1, numrule) if tab_firsts.rule_100[token] then recognize(">>") rules.add_expr(numrule) rules.shift_expr_l(numrule) elseif tab_firsts.rule_101[token] then recognize("<<") rules.add_expr(numrule) rules.shift_expr_l(numrule) elseif ( tab_follow.rule_102[token] or tab_follow['rule_'..numrule][token] or (getID() == ':') ) then --empty return const1 else sinError(tab_ERRORMSG[20]) end end rules.and_expr_l = function (const1, numrule) if tab_firsts.rule_97[token] then recognize("&") --[[ if not is_num(const1) then semanticError(tab_ERRORMSG[25]) end]] local const2 = rulesshift_expr(numrule) -- local const = const1 and const2 return rules.and_expr_l(const, numrule) elseif ( tab_follow.rule_98[token] or tab_follow['rule_'..numrule][token] or (getID() == ':') ) then --empty return const1 else sinError(tab_ERRORMSG[21]) end end rules.xor_expr_l = function (numrule) if tab_firsts.rule_94[token] then recognize("^") rules.and_expr(numrule) rules.xor_expr_l(numrule) elseif ( tab_follow.rule_95[token] or tab_follow['rule_'..numrule][token] or (getID() == ':') ) then --empty else sinError(tab_ERRORMSG[22]) end end rules.or_expr_l = function (numrule) if tab_firsts.rule_91[token] then recognize("|") rules.xor_expr(numrule) rules.or_expr_l(numrule) elseif ( tab_follow['rule_'..numrule][token] or (getID() == ':') ) then --empty else sinError(tab_ERRORMSG[23]) end end rules.template_type_spec = function () if tab_firsts.rule_58[token] then return rules.sequence_type() elseif tab_firsts.rule_59[token] then return rules.string_type() elseif tab_firsts.rule_60[token] then return rules.fixed_pt_type() end end rules.sequence_type = function () recognize(lex.tab_tokens.TK_SEQUENCE, "'sequence'") recognize("<") local tab_type_spec = rules.simple_type_spec(61) tab_type_spec = rules.sequence_type_tail(tab_type_spec) if callbacks.sequence then callbacks.sequence(tab_type_spec) end return tab_type_spec end rules.sequence_type_tail = function (tab_type_spec) if tab_firsts.rule_69[token] then recognize(",") local const = rules.positive_int_const(69) recognize(">") return { _type = TAB_TYPEID.SEQUENCE, elementtype = tab_type_spec, maxlength = const } elseif tab_firsts.rule_70[token] then recognize(">") --maxlength?? return { _type = TAB_TYPEID.SEQUENCE, elementtype = tab_type_spec, maxlength = 0 } else sinError("',' or '>'") end end rules.string_type = function () recognize(lex.tab_tokens.TK_STRING) --maxlength?? return TAB_BASICTYPE.STRING end rules.string_type_tail = function () if tab_firsts.rule_72[token] then recognize("<") local const = positive_int_const(72) recognize(">") return const elseif tab_follow.rule_73[token] then return nil --empty else sinError(tab_ERRORMSG[26]) end end rules.fixed_pt_type = function () recognize(lex.tab_tokens.TK_FIXED) recognize("<") local const1 = rules.positive_int_const(74) recognize(",") local const2 = rules.positive_int_const(74) recognize(">") return TAB_BASICTYPE.FIXED end rules.constr_type_spec = function () if tab_firsts.rule_33[token] then return rules.struct_type() elseif tab_firsts.rule_34[token] then return rules.union_type() elseif tab_firsts.rule_35[token] then return rules.enum_type() else sinError(tab_ERRORMSG[27]) end end rules.struct_type = function () recognize(lex.tab_tokens.TK_STRUCT) recognize(lex.tab_tokens.TK_ID) define(getID(), TAB_TYPEID.STRUCT) recognize("{") rules.member_l() local struct = currentScope gotoFatherScope() recognize("}") if callbacks.struct then callbacks.struct(struct) end return struct end rules.union_type = function () if tab_firsts.rule_148[token] then recognize(lex.tab_tokens.TK_UNION) recognize(lex.tab_tokens.TK_ID) local union_name = getID() recognize(lex.tab_tokens.TK_SWITCH) define(union_name, TAB_TYPEID.UNION) recognize("(") currentScope.switch = rules.switch_type_spec() recognize(")") recognize("{") currentScope.default = -1 rules.case_l() recognize("}") local union = currentScope gotoFatherScope() if callbacks.union then callbacks.union(union) end return tab_union else sinError(tab_ERRORMSG[29]) end end rules.switch_type_spec = function () if tab_firsts.rule_149[token] then return rules.integer_type(148) elseif tab_firsts.rule_150[token] then recognize(lex.tab_tokens.TK_LONG) return rules.long_e(148) elseif tab_firsts.rule_151[token] then recognize(lex.tab_tokens.TK_CHAR) return TAB_BASICTYPE.CHAR elseif tab_firsts.rule_152[token] then recognize(lex.tab_tokens.TK_BOOLEAN) return TAB_BASICTYPE.BOOLEAN elseif tab_firsts.rule_153[token] then recognize(lex.tab_tokens.TK_ENUM) return TAB_BASICTYPE.ENUM elseif tab_firsts.rule_154[token] then return rules.scoped_name(154) else sinError(tab_ERRORMSG[30]) end end rules.case_l = function () if tab_firsts.rule_155[token] then rules.case() rules.case_l_r() else sinError(tab_ERRORMSG[31]) end end rules.case_l_r = function () if tab_firsts.rule_156[token] then rules.case() rules.case_l_r() elseif tab_follow.rule_157[token] then --empty else sinError(tab_ERRORMSG[33]) end end rules.case = function () if tab_firsts.rule_158[token] then local cases = rules.case_label_l() local tab_type_spec, name = rules.element_spec(cases) for i, case in pairs(cases) do if i == 1 then dclName(name, currentScope, {type = tab_type_spec, label = case}) registerID(name); else table.insert(currentScope, {name = name, type = tab_type_spec, label = case}) end if case == 'none' then currentScope.default = table.getn(currentScope) end end recognize(";") else sinError(tab_ERRORMSG[31]) end end rules.case_label_l = function () local cases = {} if tab_firsts.rule_159[token] then rules.case_label(cases) rules.case_label_l_r(cases) else sinError(tab_ERRORMSG[31]) end return cases end rules.case_label_l_r = function (cases) if tab_firsts.rule_160[token] then rules.case_label(cases) rules.case_label_l_r(cases) elseif tab_follow.rule_161[token] then --empty else sinError(tab_ERRORMSG[32]) end end rules.case_label = function (cases) if (tab_firsts.rule_162[token]) then recognize(lex.tab_tokens.TK_CASE) local value = rules.positive_int_const(162) table.insert(cases, value) elseif (tab_firsts.rule_163[token]) then recognize(lex.tab_tokens.TK_DEFAULT) recognize(":") if (currentScope.default ~= -1) then semanticError("A default case can appear at most once.") else table.insert(cases, 'none') currentScope.default = 1 end else sinError(tab_ERRORMSG[31]) end end rules.case_label_aux = function () if (token == lex.tab_tokens.TK_ID) then recognize(lex.tab_tokens.TK_ID) tab_scope = getDefinition(getID()) recognize(":") return rules.case_label_tail(tab_scope) elseif (token == ':') then recognize(":") recognize(":") recognize(lex.tab_tokens.TK_ID, "identifier") tab_scope = getDefinition(getID()) recognize(":") return rules.case_label_tail(tab_scope) end end rules.case_label_tail = function (tab_scope) if (token == ':') then recognize(":") return rules.case_label_tail_aux(tab_scope) elseif (tab_firsts.rule_28[token] or tab_firsts.rule_29[token]) then --empty return tab_scope end end rules.case_label_tail_aux = function (tab_scope) if (token == ':') then recognize(":") elseif (token == lex.tab_tokens.TK_ID) then recognize(lex.tab_tokens.TK_ID) local namespace = getID() tab_scope = getDefinition(namespace, tab_scope.absolute_name) tab_scope = rules.case_label_tail_aux(tab_scope) end return tab_scope end rules.element_spec = function (cases) if (tab_firsts.rule_164[token]) then local tab_type_spec = rules.type_spec(221) recognize(lex.tab_tokens.TK_ID) local name = getID() return tab_type_spec, name else sinError(tab_ERRORMSG[03]) end end rules.enum_type = function () recognize(lex.tab_tokens.TK_ENUM) recognize(lex.tab_tokens.TK_ID) local _, tab_enum = define(getID(), TAB_TYPEID.ENUM) recognize("{") rules.enumerator(tab_enum) rules.enumerator_l(tab_enum) recognize("}") if callbacks.enum then callbacks.enum(tab_enum) end return tab_enum end rules.enumerator = function (tab_enum) recognize(lex.tab_tokens.TK_ID) local name = getID() dclName(name, tab_enum) registerID(name); end rules.enumerator_l = function (tab_enum) if (tab_firsts.rule_166[token]) then recognize(",") rules.enumerator(tab_enum) rules.enumerator_l(tab_enum) elseif (tab_follow.rule_167[token]) then -- empty else sinError("',' or '}'") end end rules.module = function () if (tab_firsts.rule_305[token]) then recognize(lex.tab_tokens.TK_MODULE) recognize(lex.tab_tokens.TK_ID) local name = getID() if (name == 'CORBA') then CORBAVisible = true end local status, _module = define(name, TAB_TYPEID.MODULE) recognize("{") rules.definition_l_module() local module = currentScope gotoFatherScope() recognize("}") if callbacks.module then callbacks.module(module) end end end rules.long_or_double = function () if tab_firsts.rule_55[token] then recognize(lex.tab_tokens.TK_LONG) return TAB_BASICTYPE.LLONG elseif tab_firsts.rule_56[token] then recognize(lex.tab_tokens.TK_DOUBLE) return TAB_BASICTYPE.LDOUBLE else return TAB_BASICTYPE.LONG end end rules.scoped_name_l = function (tab_scope, full_namespace, num_follow_rule) if (token == ":") then recognize(":") recognize(":") recognize(lex.tab_tokens.TK_ID) local namespace = getID() full_namespace = tab_scope.absolute_name..'::'..namespace tab_scope = getDefinition(namespace, tab_scope.absolute_name) tab_scope = rules.scoped_name_l(tab_scope, full_namespace, num_follow_rule) elseif (tab_follow['rule_'..num_follow_rule][token]) then -- empty else sinError("':' or "..tab_follow_rule_error_msg[num_follow_rule]) end return tab_scope end rules.scoped_name = function (num_follow_rule) local name = '' local tab_scope = {} if (token == lex.tab_tokens.TK_ID) then recognize(lex.tab_tokens.TK_ID) name = getID() tab_scope = getDefinition(name) tab_scope = rules.scoped_name_l(tab_scope, name, num_follow_rule) elseif (token == ":") then recognize(":") recognize(":") recognize(lex.tab_tokens.TK_ID) name = getID() tab_scope = getDefinition(name) tab_scope = rules.scoped_name_l(tab_scope, name, num_follow_rule) end local absolute_name if (tab_scope.absolute_name) then absolute_name = tab_scope.absolute_name registerID(tab_scope.absolute_name) else end return tab_scope end rules.union_or_struct = function () if (tab_firsts.rule_168[token]) then recognize(lex.tab_tokens.TK_STRUCT) recognize(lex.tab_tokens.TK_ID) local name = getID() return rules.struct_tail(name) elseif (tab_firsts.rule_169[token]) then recognize(lex.tab_tokens.TK_UNION) recognize(lex.tab_tokens.TK_ID) define(getID(), TAB_TYPEID.UNION) rules.union_tail() local union = currentScope gotoFatherScope() if callbacks.union then callbacks.union(union) end return union else sinError("'struct' or 'union'") end end rules.struct_tail = function (name) if (tab_firsts.rule_170[token]) then define(name, TAB_TYPEID.STRUCT) recognize("{") rules.member_l() recognize("}") local struct = currentScope gotoFatherScope() if callbacks.struct then callbacks.struct(struct) end return struct elseif (token == ";") then return dclForward(name, TAB_TYPEID.STRUCT) else sinError(" '{' or ';' ") end end rules.member_l = function () if (tab_firsts.rule_137[token]) then rules.member() rules.member_r() else sinError(tab_ERRORMSG[03]) end end rules.member = function () if (tab_firsts.rule_140[token]) then rules.declarator_l(rules.type_spec()) recognize(";") else sinError(tab_ERRORMSG[03]) end end rules.member_r = function () if tab_firsts.rule_138[token] then rules.member() rules.member_r() elseif tab_follow.rule_139[token] then -- empty else sinError(tab_ERRORMSG[28]) end end rules.declarator_l = function (type, access) rules.declarator(type, access) rules.declarator_l_r(type, access) end rules.declarator_l_r = function (type, access) if (tab_firsts.rule_142[token]) then recognize(",") rules.declarator(type, access) rules.declarator_l_r(type, access) elseif (tab_follow.rule_143[token]) then --empty else sinError(tab_ERRORMSG[11]) end end rules.declarator = function (type, access) recognize(lex.tab_tokens.TK_ID) local name = getID() dclName(name, currentScope, { type = rules.fixed_array_size_l(type), access = access, }) registerID(name); end rules.union_tail = function () if (tab_firsts.rule_172[token]) then recognize(lex.tab_tokens.TK_SWITCH) recognize("(") currentScope.switch = rules.switch_type_spec() recognize(")") recognize("{") currentScope.default = -1 rules.case_l() recognize("}") else sinError("'switch'") end end rules.except_dcl = function () recognize(lex.tab_tokens.TK_EXCEPTION) recognize(lex.tab_tokens.TK_ID) local name = getID() define(name, TAB_TYPEID.EXCEPTION) recognize("{") rules.member_l_empty() local except = currentScope gotoFatherScope() recognize("}") if callbacks.except then callbacks.except(except) end end rules.member_l_empty = function () if (tab_firsts.rule_187[token]) then rules.member() rules.member_l_empty() elseif (token == "}") then -- empty else sinError("member list { ... } or '}'") end end rules.definition_l_r_module = function () if (tab_firsts.rule_12[token]) then rules.definition() rules.definition_l_r_module() elseif (token == '}') then -- empty else sinError("definition") end end rules.definition_l_module = function () if (tab_firsts.rule_11[token]) then rules.definition() rules.definition_l_r_module() else sinError("definition") end end --- -- INTERFACE DECLARATION -------------------------------------------------------------------------- rules.inter_value_event = function () if (tab_firsts.rule_192[token]) then recognize(lex.tab_tokens.TK_INTERFACE) recognize(lex.tab_tokens.TK_ID) local name = getID() local interface = rules.interface_tail(name) if callbacks.interface then callbacks.interface(interface) end elseif (tab_firsts.rule_189[token]) then recognize(lex.tab_tokens.TK_ABSTRACT) rules.abstract_tail() elseif (tab_firsts.rule_190[token]) then recognize(lex.tab_tokens.TK_LOCAL) recognize(lex.tab_tokens.TK_INTERFACE) recognize(lex.tab_tokens.TK_ID) local name = getID() local interface = rules.interface_tail(name, 'local') if callbacks.interface and interface then callbacks.interface(interface) end elseif (tab_firsts.rule_193[token]) then recognize(lex.tab_tokens.TK_VALUETYPE) recognize(lex.tab_tokens.TK_ID) local name = getID() rules.value_tail(name) elseif (tab_firsts.rule_191[token]) then recognize(lex.tab_tokens.TK_CUSTOM) rules.value_or_event() elseif tab_firsts.rule_194[token] then recognize(lex.tab_tokens.TK_EVENTTYPE) recognize(lex.tab_tokens.TK_ID) local name = getID() local tab_eventtypescope = rules.eventtype_tail(name) if callbacks.eventtype then callbacks.eventtype(tab_eventtypescope) end else sinError("'interface', 'abstract', 'local' or 'valuetype'") end end rules.abstract_tail = function () if (tab_firsts.rule_195[token]) then recognize(lex.tab_tokens.TK_INTERFACE) recognize(lex.tab_tokens.TK_ID) local name = getID() local interface = rules.interface_tail(name, 'abstract') if callbacks.interface then callbacks.interface(interface) end elseif (tab_firsts.rule_196[token]) then recognize(lex.tab_tokens.TK_VALUETYPE) recognize(lex.tab_tokens.TK_ID) local name = getID() rules.value_tail(name, "abstract") elseif tab_firsts.rule_197[token] then recognize(lex.tab_tokens.TK_EVENTTYPE) recognize(lex.tab_tokens.TK_ID) local name = getID() local tab_eventtypescope = rules.eventtype_tail(name, "abstract") if callbacks.eventtype then callbacks.eventtype(tab_eventtypescope) end else sinError("'interface', 'valuetype' or 'event'") end end rules.interface_tail = function (name, header) if (tab_firsts.rule_198[token]) then recognize(":") local base = rules.scoped_name(204) define(name, TAB_TYPEID.INTERFACE) table.insert(currentScope, base) rules.bases() recognize("{") rules.export_l() recognize("}") local interface = currentScope rules.verifyHeader(header) gotoFatherScope() return interface elseif (tab_firsts.rule_199[token]) then recognize("{") define(name, TAB_TYPEID.INTERFACE) rules.export_l() recognize("}") local interface = currentScope rules.verifyHeader(header) gotoFatherScope() return interface elseif (token == ';') then return dclForward(name, TAB_TYPEID.INTERFACE) else sinError("'{', ':' or ';'") end end rules.bases = function () if (tab_firsts.rule_254[token]) then recognize(",") local base = rules.scoped_name(204) table.insert(currentScope, base) rules.bases() elseif (token == '{') then -- empty else sinError("',' or '{'") end end rules.verifyHeader = function (header) if (header == 'local') then currentScope['header'] = true elseif (header == 'abstract') then currentScope['abstract'] = true end end rules.export_l = function () if (tab_firsts.rule_207[token]) then rules.export() rules.export_l() elseif (token == "}") then --empty else sinError("empty interface, a declaration or '}'") end end rules.export = function () if (tab_firsts.rule_209[token]) then rules.type_dcl() recognize(";") elseif (tab_firsts.rule_210[token]) then rules.const_dcl() recognize(";") elseif (tab_firsts.rule_211[token]) then rules.except_dcl() recognize(";") elseif (tab_firsts.rule_212[token]) then rules.attr_dcl() recognize(";") elseif (tab_firsts.rule_213[token]) then rules.op_dcl() recognize(";") else sinError("constant, type, exception, attribute or operation declaration") end end --- -- OPERATION DECLARATION -------------------------------------------------------------------------- rules.op_dcl = function () if (tab_firsts.rule_243[token]) then recognize(lex.tab_tokens.TK_ONEWAY) local result = rules.op_type_spec() if (result._type ~= 'void') then semanticError("An operation with the oneway attribute must specify a 'void' return type.") end recognize(lex.tab_tokens.TK_ID) local name = getID() define(name, TAB_TYPEID.OPERATION) currentScope.name = name currentScope.oneway = true rules.parameter_dcls() rules.raises_expr_e(currentScope) rules.context_expr_e() local operation = currentScope gotoFatherScope() if (callbacks.operation) then callbacks.operation(operation) end elseif tab_firsts.rule_244[token] then local result = rules.op_type_spec() recognize(lex.tab_tokens.TK_ID) local name = getID() define(name, TAB_TYPEID.OPERATION) currentScope.name = name currentScope.result = result rules.parameter_dcls() rules.raises_expr_e(currentScope) rules.context_expr_e() local operation = currentScope gotoFatherScope() if callbacks.operation then callbacks.operation(operation) end else sinError("'oneway' or type specification") end end rules.op_type_spec = function () if (tab_firsts.rule_245[token]) then return rules.param_type_spec() elseif (tab_firsts.rule_246[token]) then recognize(lex.tab_tokens.TK_VOID) return TAB_BASICTYPE.VOID else sinError("type return") end end rules.parameter_dcls = function () recognize("(") rules.parameter_dcls_tail() end rules.parameter_dcls_tail = function () if (tab_firsts.rule_248[token]) then currentScope.parameters = {} rules.param_dcl() rules.param_dcl_l() recognize(")") elseif (tab_firsts.rule_249[token]) then recognize(")") else sinError("'in', 'out', 'inout' or ')'") end end rules.param_dcl = function () local attribute = rules.param_attribute() local type = rules.param_type_spec() recognize(lex.tab_tokens.TK_ID) local name = getID() dclName(name, currentScope.parameters, {mode = attribute, type = type}) registerID(name); end rules.param_dcl_l = function () if (tab_firsts.rule_254[token]) then recognize(",") rules.param_dcl() rules.param_dcl_l() elseif token == lex.tab_tokens.TK_RAISES or token == lex.tab_tokens.TK_CONTEXT or token == ')' then -- empty else sinError("',', ')', 'raises' or 'context'") end end rules.param_attribute = function () if (tab_firsts.rule_251[token]) then recognize(lex.tab_tokens.TK_IN) return 'PARAM_IN' elseif (tab_firsts.rule_252[token]) then recognize(lex.tab_tokens.TK_OUT) return 'PARAM_OUT' elseif (tab_firsts.rule_253[token]) then recognize(lex.tab_tokens.TK_INOUT) return 'PARAM_INOUT' end end rules.param_type_spec = function () if (tab_firsts.rule_219[token]) then return rules.base_type_spec() elseif (tab_firsts.rule_220[token]) then return rules.string_type() elseif (tab_firsts.rule_221[token]) then return rules.scoped_name(221) else sinError('type specification') end end rules.raises_expr = function (tab) recognize(lex.tab_tokens.TK_RAISES) recognize("(") tab.exceptions = {} rules.raises(tab.exceptions) rules.inter_name_seq(tab.exceptions) recognize(")") end rules.raises = function (raises) local exception = rules.scoped_name(229) if (exception._type ~= TAB_TYPEID.EXCEPTION) then semanticError(string.format("The type of '%s' is %s, but it should be exception.", exception.absolute_name, exception._type)) end table.insert(raises, exception) end rules.inter_name_seq = function (_raises) if (tab_firsts.rule_254[token]) then recognize(",") rules.raises(_raises) rules.inter_name_seq(_raises) elseif (token == ')') then -- empty else sinError("')'") end end rules.raises_expr_e = function (tab) if (tab_firsts.rule_370[token]) then rules.raises_expr(tab) elseif (token == ';' or token == lex.tab_tokens.TK_CONTEXT) then -- empty else sinError("'raises', 'context', ';'") end end rules.context_expr_e = function () if (tab_firsts.rule_377[token]) then rules.context_expr() elseif (token == ';') then -- empty else sinError("'context' or ';'") end end rules.context_expr = function () recognize(lex.tab_tokens.TK_CONTEXT) recognize("(") currentScope.contexts = {} rules.context() rules.string_literal_l() recognize(")") end rules.context = function () recognize(lex.tab_tokens.TK_STRING_LITERAL) local name = getID() dclName(name, currentScope.contexts, {}) registerID(name); end rules.string_literal_l = function () if (tab_firsts.rule_257[token]) then recognize(",") rules.context() rules.string_literal_l() elseif (token == ')') then -- empty else sinError("',' or ')'") end end --- -- ATTRIBUTE -------------------------------------------------------------------------- rules.attr_dcl = function () if (tab_firsts.rule_216[token]) then rules.readonly_attr_spec() elseif (tab_firsts.rule_217[token]) then rules.attr_spec() else sinError("'readonly' or 'attribute'") end end rules.readonly_attr_spec = function () recognize(lex.tab_tokens.TK_READONLY) recognize(lex.tab_tokens.TK_ATTRIBUTE) local type = rules.param_type_spec() rules.readonly_attr_spec_dec(type) end rules.attr_spec = function () recognize(lex.tab_tokens.TK_ATTRIBUTE) local type = rules.param_type_spec() rules.attr_declarator(type) end rules.readonly_attr_spec_dec = function (type) local attribute = {type = type, readonly = true} local name = rules.simple_dcl() define(name, TAB_TYPEID.ATTRIBUTE, attribute) rules.readonly_attr_spec_dec_tail(attribute) if callbacks.attribute then callbacks.attribute(attribute) end end rules.attr_declarator = function (type) local attribute = {type = type} local name = rules.simple_dcl() define(name, TAB_TYPEID.ATTRIBUTE, attribute) rules.attr_declarator_tail(attribute) if callbacks.attribute then callbacks.attribute(attribute) end end rules.readonly_attr_spec_dec_tail = function (attribute) if (tab_firsts.rule_227[token]) then rules.raises_expr(attribute) elseif (tab_firsts.rule_228[token]) then rules.simple_dcl_l(type, true) elseif (token == ';') then -- empty else sinError("'raises', ',' or ';'") end end rules.attr_declarator_tail = function (attribute) if (tab_firsts.rule_234[token]) then rules.attr_raises_expr(attribute) elseif (tab_firsts.rule_235[token]) then rules.simple_dcl_l(attribute.type) elseif (token == ';') then -- empty else sinError("'getraises', 'setraises', ',' or ';'") end end rules.simple_dcl = function () recognize(lex.tab_tokens.TK_ID) return getID() end rules.simple_dcl_l = function (type, readonly) if (tab_firsts.rule_142[token]) then recognize(",") local attribute = {type = type, readonly = readonly} local name = rules.simple_dcl() define(name, TAB_TYPEID.ATTRIBUTE, attribute) rules.simple_dcl_l(type) elseif (token == ';') then -- empty end end rules.attr_raises_expr = function (attribute) if (tab_firsts.rule_236[token]) then recognize(lex.tab_tokens.TK_GETRAISES) attribute.raises = {} rules.exception_l(attribute, 'getraises') rules.attr_raises_expr_tail(attribute) elseif (tab_firsts.rule_237[token]) then recognize(lex.tab_tokens.TK_SETRAISES) attribute.raises = {} rules.exception_l(attribute, 'setraises') end end rules.attr_raises_expr_tail = function (attribute) if (tab_firsts.rule_238[token]) then recognize(lex.tab_tokens.TK_SETRAISES) rules.exception_l(attribute, 'setraises') elseif (token == ';') then --empty else sinError("'setraises' or ';'") end end rules.exception = function (attribute, raises_type) local exception = {type = raises_type, exception = rules.scoped_name(229)} table.insert(attribute.raises, exception) end rules.exception_l = function (attribute, raises_type) recognize("(") rules.exception(attribute, raises_type) rules.exception_l_seq(attribute, raises_type) recognize(")") end rules.exception_l_seq = function (attribute, raises_type) if (tab_firsts.rule_142[token]) then recognize(",") rules.exception(attribute, raises_type) rules.exception_l_seq(attribute, raises_type) elseif (token == ';') then -- empty end end --- -- COMPONENT DECLARATION -------------------------------------------------------------------------- rules.component = function () recognize(lex.tab_tokens.TK_COMPONENT) recognize(lex.tab_tokens.TK_ID) local name = getID() define(name, TAB_TYPEID.COMPONENT) currentScope.declarations = {} rules.component_tail(name) gotoFatherScope() end rules.component_tail = function (name) if (tab_firsts.rule_307[token]) then recognize(":", "':'") local component = rules.scoped_name(307) if component._type ~= TAB_TYPEID.COMPONENT then semanticError("The previously-defined type is not a COMPONENT") end currentScope.component_base = component rules.supp_inter_spec(308) recognize("{") rules.component_body() recognize("}") elseif (tab_firsts.rule_308[token]) then rules.supp_inter_spec(308) recognize("{") rules.component_body() recognize("}") elseif (tab_firsts.rule_309[token]) then recognize("{") rules.component_body() recognize("}") elseif (token == ';') then dclForward(name, TAB_TYPEID.COMPONENT) --empty else sinError("':', 'supports' or '{'") end end rules.supp_inter_spec = function (num_follow_rule) if tab_firsts.rule_316[token] then recognize(lex.tab_tokens.TK_SUPPORTS) currentScope.supports = {} local interface = rules.scoped_name(num_follow_rule) if (interface._type ~= TAB_TYPEID.INTERFACE) then semanticError("The 'SUPPORTS' construction must be reference to an interface") end table.insert(currentScope.supports, interface) rules.supp_name_list(num_follow_rule) elseif (tab_follow['rule_'..num_follow_rule][token]) then -- empty else sinError("':', ',', or "..tab_follow_rule_error_msg[num_follow_rule]) end end rules.supp_name_list = function (num_follow_rule) if (tab_firsts.rule_321[token]) then recognize(',') local interface = rules.scoped_name(num_follow_rule) if (interface._type ~= TAB_TYPEID.INTERFACE) then semanticError("The 'SUPPORTS' construction must be reference to an interface") end table.insert(currentScope.supports, interface) rules.supp_name_list(num_follow_rule) elseif (tab_follow['rule_'..num_follow_rule][token]) then --empty else sinError("',' or '{'") end end rules.component_body = function () if (tab_firsts.rule_323[token]) then rules.component_export() rules.component_body() elseif (token == '}') then --empty else sinError("'provides', 'uses', 'emits', 'publishes', 'consumes', 'readonly' 'attribute' or '}'") end end rules.component_export = function () if (tab_firsts.rule_325[token]) then rules.provides_dcl() recognize(';') elseif (tab_firsts.rule_326[token]) then rules.uses_dcl() recognize(';') elseif (tab_firsts.rule_327[token]) then rules.emits_dcl() recognize(';') elseif (tab_firsts.rule_328[token]) then rules.publishes_dcl() recognize(';') elseif (tab_firsts.rule_329[token]) then rules.consumes_dcl() recognize(';') elseif (tab_firsts.rule_330[token]) then rules.attr_dcl() recognize(';') end end rules.provides_dcl = function () recognize(lex.tab_tokens.TK_PROVIDES, 'provides') local tab_provides = { _type = 'provides' } tab_provides.interface_type = rules.interface_type() recognize(lex.tab_tokens.TK_ID, '') local name = getID() -- new_name(name, name, currentScope.declarations, tab_provides, ERRMSG_DECLARED, name) end rules.interface_type = function () if (tab_firsts.rule_332[token]) then local scope = rules.scoped_name(332) if (scope._type ~= TAB_TYPEID.INTERFACE) then semanticError("The interface type of this provides declaration shall be either the keyword \ Object or a scoped name that denotes a previously-declared interface type") end return scope elseif (tab_firsts.rule_333[token]) then recognize(lex.tab_tokens.TK_OBJECT) return TAB_BASICTYPE.OBJECT else sinError(" or 'Object'") end end rules.uses_dcl = function () recognize(lex.tab_tokens.TK_USES) local tab_uses = { _type = 'uses' } tab_uses.multiple = rules.multiple_e() tab_uses.interface_type = rules.interface_type() recognize(lex.tab_tokens.TK_ID) local name = getID() -- new_name(name, name, currentScope.declarations, tab_uses, ERRMSG_DECLARED, name) end rules.multiple_e = function () if (tab_firsts.rule_339[token]) then recognize(lex.tab_tokens.TK_MULTIPLE) return true elseif (tab_follow.rule_340[token]) then return nil --empty else sinError("'multiple', , ':' or 'Object'") end end rules.emits_dcl = function () recognize(lex.tab_tokens.TK_EMITS) local name = getID() local tab_uses = { _type = 'emits' } -- new_name(name, name, currentScope.declarations, tab_emits, ERRMSG_DECLARED, name) tab_uses.event_type = rules.scoped_name(341) recognize(lex.tab_tokens.TK_ID) tab_uses.evtsrc = getID() end rules.publishes_dcl = function () recognize(lex.tab_tokens.TK_PUBLISHES) local name = getID() local tab_publishes = { _type = 'publishes' } -- new_name(name, name, currentScope.declarations, tab_publishes, ERRMSG_DECLARED, name) tab_uses.event_type = rules.scoped_name(342) recognize(lex.tab_tokens.TK_ID) tab_uses.evtsrc = getID() end rules.consumes_dcl = function () recognize(lex.tab_tokens.TK_CONSUMES) local name = getID() local tab_publishes = { _type = 'consumes' } -- new_name(name, name, currentScope.declarations, tab_consumes, ERRMSG_DECLARED, name) tab_uses.event_type = rules.scoped_name(343) recognize(lex.tab_tokens.TK_ID) tab_uses.evtsink = getID() end --- -- HOME DECLARATION -------------------------------------------------------------------------- rules.home_dcl = function () recognize(lex.tab_tokens.TK_HOME) recognize(lex.tab_tokens.TK_ID) local name = getID() define(name, TAB_TYPEID.HOME) rules.home_dcl_tail(name) gotoFatherScope() end rules.home_dcl_tail = function (name) if (tab_firsts.rule_345[token])then rules.home_inh_spec() rules.supp_inter_spec(345) recognize(lex.tab_tokens.TK_MANAGES) local component = rules.scoped_name(347) currentScope.manages = component rules.primary_key_spec_e() recognize("{") rules.home_export_l() recognize("}") elseif (tab_firsts.rule_346[token]) then rules.supp_inter_spec(345) recognize(lex.tab_tokens.TK_MANAGES) local component = rules.scoped_name(347) currentScope.manages = component rules.primary_key_spec_e() recognize("{") rules.home_export_l() recognize("}") elseif (tab_firsts.rule_347[token]) then recognize(lex.tab_tokens.TK_MANAGES) currentScope.component = rules.scoped_name(347) rules.primary_key_spec_e() recognize("{") rules.home_export_l() recognize("}") else sin.error("'supports', 'manages', ':'") end end rules.home_inh_spec = function () if (tab_firsts.rule_348[token]) then recognize(":") local home = rules.scoped_name(348) if (home._type ~= TAB_TYPEID.HOME) then semanticError("The previously-defined type is not a HOME") end currentScope.home_base = home end end --(353) := TK_PRIMARYKEY --(354) | empty rules.primary_key_spec_e = function () if tab_firsts.rule_353[token] then recognize(lex.tab_tokens.TK_PRIMARYKEY, 'primarykey') rules.scoped_name(353) elseif tab_follow.rule_353[token] then --empty end end rules.home_export_l = function () if tab_firsts.rule_359[token] then rules.home_export() rules.home_export_l() elseif tab_follow.rule_359[token] then --empty end end rules.home_export = function () if tab_firsts.rule_361[token] then rules.export() elseif tab_firsts.rule_362[token] then rules.factory_dcl() recognize(";") elseif tab_firsts.rule_363[token] then rules.finder_dcl() recognize(";") else sinError("error") end end rules.factory_dcl = function () if tab_firsts.rule_364[token] then recognize(lex.tab_tokens.TK_FACTORY) recognize(lex.tab_tokens.TK_ID) local name = getID() define(name, TAB_TYPEID.FACTORY) recognize("(") rules.init_param_dcls() recognize(")") rules.raises_expr_e() end end rules.init_param_dcls = function () if tab_firsts.rule_366[token] then currentScope.members = {} rules.init_param_dcl() rules.init_param_dcl_list() elseif tab_follow.rule_367[token] then --empty end end rules.init_param_dcl = function () if tab_firsts.rule_297[token] then recognize(lex.tab_tokens.TK_IN) local tab_type_spec = rules.param_type_spec() recognize(lex.tab_tokens.TK_ID) local param_name = getID() dclName(param_name, currentScope.members, { type = tab_type_spec, name = param_name, }) else sinError("'in'") end end rules.init_param_dcl_list = function () if tab_firsts.rule_368[token] then recognize(",") rules.init_param_dcl() rules.init_param_dcl_list() elseif tab_follow.rule_369[token] then --empty end end rules.finder_dcl = function () if tab_firsts.rule_365[token] then recognize(lex.tab_tokens.TK_FINDER) recognize(lex.tab_tokens.TK_ID) local name = getID() local tab_finder = { _type = TAB_TYPEID.FINDER, name = name } -- new_name(name, name, -- currentScope.members, tab_finder, ERRMSG_OPDECLARED, name) recognize("(") rules.init_param_dcls(tab_finder) recognize(")") rules.raises_expr_e(tab_finder) else sinError("'finder'") end end rules.value_or_event = function () if (tab_firsts.rule_281[token]) then recognize(lex.tab_tokens.TK_VALUETYPE) recognize(lex.tab_tokens.TK_ID) local name = getID() rules.value_tail(name, "custom") elseif (tab_firsts.rule_282[token]) then recognize(lex.tab_tokens.TK_EVENTTYPE) recognize(lex.tab_tokens.TK_ID) local name = getID() local tab_eventtypescope = rules.eventtype_tail(name, "custom") if callbacks.eventtype then callbacks.eventtype(tab_eventtypescope) end else sinError("'valuetype' or 'eventtype'") end end --- -- VALUE DECLARATION -------------------------------------------------------------------------- rules.value_tail = function (name, modifier) if (tab_firsts.rule_299[token]) then define(name, TAB_TYPEID.VALUETYPE) if modifier then currentScope[modifier] = true end local tab_valuetypescope = rules.value_tail_aux(name) if callbacks.valuetype then callbacks.valuetype(tab_valuetypescope) end return tab_valuetypescope elseif (tab_firsts.rule_298[token]) then define(name, TAB_TYPEID.VALUETYPE) if modifier then currentScope[modifier] = true end rules.value_inhe_spec() local tab_valuetypescope = rules.value_tail_aux(name) if callbacks.valuetype then callbacks.valuetype(tab_valuetypescope) end return tab_valuetypescope elseif tab_firsts.rule_300[token] then local _, nameSpace = define(name, TAB_TYPEID.VALUEBOX) if modifier then nameSpace[modifier] = true end nameSpace.original_type = rules.type_spec() if callbacks.valuebox then callbacks.valuebox(nameSpace) end return nameSpace elseif tab_follow.rule_301[token] then return dclForward(name, TAB_TYPEID.VALUETYPE) end end rules.value_tail_aux = function (name) recognize("{") rules.value_element_l() recognize("}") local tab_valuetypescope = currentScope gotoFatherScope() return tab_valuetypescope end rules.value_inhe_spec = function () if tab_firsts.rule_268[token] then recognize(":") local truncatable = rules.truncatable_e() local value = rules.scoped_name(268) if (value._type ~= TAB_TYPEID.VALUETYPE and value._type ~= TAB_TYPEID.INTERFACE) then semanticError("The previously-defined type is not a VALUETYPE or INTERFACE") end currentScope.truncatable = truncatable if (not value.abstract) then currentScope.base_value = value else currentScope.abstract_base_values = {} table.insert(currentScope.abstract_base_values, value) end rules.value_name_list() rules.supp_inter_spec(308) elseif tab_firsts.rule_269[token] then rules.supp_inter_spec(308) else sinError("':', 'supports'") end end rules.value_name_list = function () if tab_firsts.rule_277[token] then recognize(",") local value = rules.scoped_name(268) if (not value.abstract) then if (currentScope.base_value) then sinError("The single base concrete has been declared.") else sinError("The single base concrete must be the first element specified in the inheritance list.") end else currentScope.abstract_base_values = currentScope.abstract_base_values or {} table.insert(currentScope.abstract_base_values, value) end rules.value_name_list() elseif tab_follow.rule_278[token] then --empty end end rules.truncatable_e = function () if tab_firsts.rule_271[token] then recognize(lex.tab_tokens.TK_TRUNCATABLE) return true elseif tab_follow.rule_272[token] then --empty end end rules.value_element_l = function () if (tab_firsts.rule_285[token]) then rules.value_element() rules.value_element_l() elseif (tab_follow.rule_286[token]) then --empty end end rules.value_element = function () if (tab_firsts.rule_287[token]) then rules.export() elseif (tab_firsts.rule_288[token]) then rules.state_member() elseif (tab_firsts.rule_289[token]) then rules.init_dcl() end end rules.state_member = function () if (tab_firsts.rule_290[token]) then recognize(lex.tab_tokens.TK_PUBLIC) rules.state_member_tail("public") elseif (tab_firsts.rule_291[token]) then recognize(lex.tab_tokens.TK_PRIVATE) rules.state_member_tail("private") end end rules.state_member_tail = function (access) rules.declarator_l(rules.type_spec(), access) recognize(";") end rules.init_dcl = function () if (tab_firsts.rule_292[token]) then recognize(lex.tab_tokens.TK_FACTORY) recognize(lex.tab_tokens.TK_ID) local name = getID() define(name, TAB_TYPEID.FACTORY) recognize("(") rules.init_param_dcls() recognize(")") rules.raises_expr_e() recognize(";") gotoFatherScope() end end --- -- EVENT DECLARATION -------------------------------------------------------------------------- rules.eventtype_tail = function (name) if tab_firsts.rule_302[token] then define(name, TAB_TYPEID.EVENTTYPE) rules.value_inhe_spec() recognize("{") rules.value_element_l() recognize("}") local tab_eventtypescope = currentScope gotoFatherScope() return tab_eventtypescope elseif tab_firsts.rule_303[token] then define(name, TAB_TYPEID.EVENTTYPE) recognize("{") rules.value_element_l() recognize("}") local tab_eventtypescope = currentScope gotoFatherScope() return tab_eventtypescope elseif tab_follow.rule_304[token] then return dclForward(name, TAB_TYPEID.EVENTTYPE) end end --[[function type_prefix_dcl() if tab_firsts.rule_260[token] then recognize(lex.tab_tokens.TK_TYPEPREFIX) rules.scoped_name() recognize(lex.tab_tokens.TK_STRING_LITERAL) else sinError("'typeprefix'") end end ]] --- -- API -------------------------------------------------------------------------- function parse(stridl, options) if not options then options = {} end if options.callbacks then callbacks = options.callbacks for type, tab in pairs(TAB_BASICTYPE) do local callback = callbacks[type] if callback then if (type == 'TYPECODE') then else TAB_BASICTYPE[type] = callback end end end for type, tab in pairs(TAB_IMPLICITTYPE) do local callback = callbacks[type] if callback then TAB_IMPLICITTYPE[type] = callback end end else callbacks = {} end -- Estrutura que armazena o grafo de saída. -- A tabela é inicializada com o escopo 'GLOBAL'. output = {absolute_name = ''} currentScope = output -- Estrutura que armazena informações pertinentes a cada identificador mapeado. -- Auxilia o processo de geração do grafo de saída. -- A tabela é indexada por *absolute name*. namespaces = {[''] = {namespace = output}} forwardDeclarations = {} idl = stridl CORBAVisible = nil currentScopeName = '' tab_identifiers = {} scopeRoots = {} table.insert(scopeRoots, {root = '', scope = ''}) lex.init() token = getToken() --Implicit definitions -- CORBA::TypeCode if not options.notypecode then define('CORBA', TAB_TYPEID.MODULE) define('TypeCode', TAB_TYPEID.TYPECODE, TAB_IMPLICITTYPE.TYPECODE) gotoFatherScope() end -- Starts parsing with the first grammar rule. rules.specification() -- Removing CORBA::TypeCode implicit definition. if (not options.notypecode) and (not CORBAVisible) then table.remove(output, 1) end return output end