Skip to content
Fetching contributors…
Cannot retrieve contributors at this time
3632 lines (3361 sloc) 119 KB
--
-- Project: LuaIDL
-- Author: Ricardo Cosme <rcosme@tecgraf.puc-rio.br>
-- Filename: sin.lua
--
-- OMG IDL Grammar (Corba v3.0)
-- LL(1)
--(1) <specification> := <import_l> <definition_l>
--(2) <import_l> := <import> <import_l>
--(3) | empty
--(4) <import> := TK_IMPORT <imported_scope> ";"
--(5) <imported_scope> := <scoped_name>
--(6) | TK_STRING_LITERAL
--(7) <scoped_name> := TK_ID <scoped_name>
--(8) | ":" ":" TK_ID <scoped_name_l>
--(9) <scoped_name_l> := ":" ":" TK_ID <scoped_name_l>
--(10) | empty
--(11) <definition_l> := <definition> <definition_l_r>
--(12) <definition_l_r> := <definition> <definition_l_r>
--(13) | empty
--(14) <definition> := <type_dcl> ";"
--(15) | <const_dcl> ";"
--(16) | <except_dcl> ";"
--(17) | <inter_value_event> ";"
--(18) | <module> ";"
--(19) | <type_id_dcl> ";"
--(20) | <type_prefix_dcl> ";"
--(21) | <component> ";"
--(22) | <home_dcl> ";"
--(23) <type_dcl> := "typedef" <type_declarator>
--(24) | <enum_type>
--(25) | TK_NATIVE TK_ID
--(26) | <union_or_struct>
--(27) <type_declarator> := <type_spec> <declarator_l>
--(28) <type_spec> := <simple_type_spec>
--(29) | <constr_type_spec>
--(30) <simple_type_spec> := <base_type_spec>
--(31) | <template_type_spec>
--(32) | <scoped_name>
--(33) <constr_type_spec> := <struct_type>
--(34) | <union_type>
--(35) | <enum_type>
--(36) <base_type_spec> := <float_type_or_int_type>
--(37) | TK_CHAR
-- | TK_WCHAR **
--(38) | TK_BOOLEAN
--(39) | TK_OCTET
--(40) | TK_ANY
--(41) | TK_OBJECT
--(42) | TK_VALUEBASE
--(43) <float_type_or_int_type>:= <floating_pt_type>
--(44) | <integer_type>
--(45) | TK_LONG <long_or_double>
--(46) <floating_pt_type> := TK_FLOAT
--(47) | TK_DOUBLE
--(48) <integer_type> := TK_SHORT
--(49) | <unsigned_int>
--(50) <unsigned_int> := TK_UNSIGNED <unsigned_int_tail>
--(51) <unsigned_int_tail> := TK_LONG <long_e>
--(52) | TK_SHORT
--(53) <long_e> := TK_LONG
--(54) | empty
--(55) <long_or_double> := TK_LONG
--(56) | TK_DOUBLE
--(57) | empty
--(58) <template_type_spec> := <sequence_type>
--(59) | <string_type>
-- | <wide_string_type> **
--(60) | <fixed_pt_type>
--(61) <sequence_type> := TK_SEQUENCE "<" <simple_type_spec> <sequence_type_tail>
--(69) <sequence_type_tail> := "," <positive_int_const> ">"
--(70) | ">"
--(71) <string_type> := TK_STRING <string_type_tail>
--(72) <string_type_tail> := "<" <positive_int_const> ">"
--(73) | empty
-- <wide_string_type> := TK_WSTRING <string_type_tail> **
--(74) <fixed_pt_type> := TK_FIXED "<" <positive_int_const> "," <positive_int_const> ">"
--(75) <positive_int_const> := <xor_expr> <or_expr_l>
--(91) <or_expr_l> := "|" <xor_expr> <or_expr_l>
--(92) | empty
--(93) <xor_expr> := <and_expr> <xor_expr_l>
--(94) <xor_expr_l> := "^" <and_expr> <xor_expr_l>
--(95) | empty
--(96) <and_expr> := <shift_expr> <and_expr_l>
--(97) <and_expr_l> := "&" <shift_expr> <and_expr_l>
--(98) | empty
--(99) <shift_expr> := <add_expr> <shift_expr_l>
--(100) <shift_expr_l> := ">>" <add_expr> <shift_expr_l>
--(101) | "<<" <add_expr> <shift_expr_l>
--(102) | empty
--(103) <add_expr> := <mult_expr> <add_expr_l>
--(104) <add_expr_l> := "+" <mult_expr> <add_expr_l>
--(105) | "-" <mult_expr> <add_expr_l>
--(106) | empty
--(107) <mult_expr> := <unary_expr> <mult_expr_l>
--(108) <mult_expr_l> := "*" <unary_expr> <mult_expr_l>
--(109) | "/" <unary_expr> <mult_expr_l>
--(110) | "%" <unary_expr> <mult_expr_l>
--(111) | empty
--(112) <unary_expr> := <unary_operator> <primary_expr>
--(113) | <primary_expr>
--(114) <unary_operator> := "-"
--(115) | "+"
--(116) | "~"
--(117) <primary_expr> := <scoped_name>
--(118) | <literal>
--(119) | "(" <positive_int_const3> ")"
--(120) <literal> := 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) | <boolean_literal>
--(126) <boolean_literal> := TK_TRUE
--(127) | TK_FALSE
--(136) <struct_type> := TK_STRUCT TK_ID "{" <member_l> "}"
--(137) <member_l> := <member> <member_r>
--(138) <member_r> := <member> <member_r>
--(139) | empty
--(140) <member> := <type_spec> <declarator_l> ";"
--(141) <typedef_dcl_l> := <typedef_dcl> <typedef_l_r>
--(142) <typedef_l_r> := "," <typedef_dcl> <typedef_l_r>
--(143) | empty
--(144) <typedef_dcl> := TK_ID <fixed_array_size_l>
--(145) <fixed_array_size_l> := <fixed_array_size> <fixed_array_size_l>
--(146) | empty
--(147) <fixed_array_size> := "[" <positive_int_const4> "]"
--(148) <union_type> := TK_UNION TK_ID TK_SWITCH "(" <switch_type_spec> ")"
-- "{" <case_l> "}"
--(149) <switch_type_spec> := <integer_type>
--(150) | TK_LONG <long_e>
--(151) | TK_CHAR
--(152) | TK_BOOLEAN
--(153) | TK_ENUM
--(154) | <scoped_name>
--(155) <case_l> := <case> <case_l_r>
--(156) <case_l_r> := <case> <case_l_r>
--(157) | empty
--(158) <case> := <case_label_l> <element_spec> ";"
--(159) <case_label_l> := <case_label> <case_label_l_r>
--(160) <case_label_l_r> := <case_label> <case_label_l_r>
--(161) | empty
--(162) <case_label> := TK_CASE <positive_int_const5> ":"
--(163) | TK_DEFAULT ":"
--(164) <element_spec> := <type_spec> <declarator>
--(165) <enum_type> := TK_ENUM <enumerator>
-- "{" <enumerator> <enumerator_l> "}"
--(166) <enumerator_l> := "," <enumerator> <enumerator_l>
--(167) | empty
--(168) <union_or_struct> := TK_STRUCT TK_ID <struct_tail>
--(169) | TK_UNION TK_ID TK_SWITCH <union_tail>
--(170) <struct_tail> := "{" <member_l> "}"
--(171) | empty
--(172) <union_tail> := TK_SWITCH "(" <switch_type_spec> ")"
-- "{" <case_l> "}"
--(173) | empty
--(174) <const_dcl> := TK_CONST <const_type> TK_ID "=" <positive_int_const>
--(175) <const_type> := <float_type_or_int_type>
--(176) | TK_CHAR
-- | TK_WCHAR **
--(177) | TK_BOOLEAN
--(178) | TK_STRING
-- | TK_WSTRING **
--(179) | <scoped_name>
--(180) | TK_OCTET
--(181) | TK_FIXED
--(186) <except_dcl> := TK_EXCEPTION TK_ID "{" <member_l_empty> "}"
--(187) <member_l_empty> := <member> <member_l_empty>
--(188) | empty
--(189) <inter_value_event> := TK_ABSTRACT <abstract_tail>
--(190) | TK_LOCAL TK_INTERFACE TK_ID <interface_tail>
--(191) | TK_CUSTOM <value_or_event>
--(192) | TK_INTERFACE TK_ID <interface_tail>
--(193) | TK_VALUETYPE TK_ID <value_tail>
--(194) | TK_EVENTTYPE TK_ID <eventtype_tail>
--(195) <abstract_tail> := TK_INTERFACE TK_ID <interface_tail>
--(196) | TK_VALUETYPE TK_ID <valueinhe_export_empty>
--(197) | TK_EVENTTYPE TK_ID <valueinhe_export_empty>
--(198) <interface_tail> := ":" <scoped_name> <bases> "{" <export_l> "}"
--(199) | "{" <export_l> "}"
--(200) | empty
--(205) <bases> := "," <scoped_name> <bases>
--(206) | empty
--(207) <export_l> := <export> <export_l>
--(208) | empty
--(209) <export> := <type_dcl> ";"
--(210) | <const_dcl> ";"
--(211) | <except_dcl> ";"
--(212) | <attr_dcl> ";"
--(213) | <op_dcl> ";"
--(214) | <type_id_dcl> ";"
--(215) | <type_prefix_dcl> ";"
--(216) <attr_dcl> := <readonly_attr_spec>
--(217) | <attr_spec>
--(218) <readonly_attr_spec> := TK_READONLY TK_ATTRIBUTE <param_type_spec> <readonly_attr_dec>
--(219) <param_type_spec> := <base_type_spec>
--(220) | <string_type>
-- | <wide_string_type> **
--(221) | <scoped_name>
--(226) <readonly_attr_dec> := TK_ID <readonly_attr_dec_tail>
--(227) <readonly_attr_dec_tail>:= <raises_expr>
--(228) | <simple_dec_l>
-- | empty
--(229) <raises_expr> := TK_RAISES "(" <scoped_name> <inter_name_seq> ")"
--(230) <simple_dec_l) := "," TK_ID <simple_dec_l>
--(231) | empty
--(232) <attr_spec> := TK_ATTRIBUTE <param_type_spec> <attr_declarator>
--(233) <attr_declarator> := TK_ID <attr_declarator_tail>
--(234) <attr_declarator_tail> := <attr_raises_expr>
--(235) | <simple_dec_l>
-- | empty
--(236) <attr_raises_expr> := TK_GETRAISES <exception_l> <attr_raises_expr_tail>
--(237) | TK_SETRAISES <exception_l>
--(238) <attr_raises_expr_tail> := TK_SETRAISES <exception_l>
--(239) | empty
--(240) <exception_l> := "(" <scoped_name> <inter_name_seq> ")"
--(241) <inter_name_seq> := "," <scoped_name> <inter_name_seq>
--(242) | empty
--(243) <op_dcl> := TK_ONEWAY <op_type_spec> TK_ID <parameter_dcls> <raises_expr_e>
-- <context_expr_e>
--(244) | <op_type_spec> TK_ID <parameter_dcls> <raises_expr_e>
-- <context_expr_e>
--(245) <op_type_spec> := <param_type_spec>
--(246) | TK_VOID
--(247) <parameter_dcls> := "(" <parameter_dcls_tail>
--(248) <parameter_dcls_tail> := <param_dcl> <param_dcl_l>
--(249) | ")"
--(250) <param_dcl> := <param_attribute> <param_type_spec> TK_ID
--(251) <param_attribute> := TK_IN
--(252) | TK_OUT
--(253) | TK_INOUT
--(254) <param_dcl_l> := "," <param_dcl> <param_dcl_l>
--(255) | empty
--(256) <context_expr> := TK_CONTEXT "(" <context> <string_literal_l> ")"
--(257) <string_literal_l> := "," <context> <string_literal_l>
--(258) | empty
--(259) <type_id_dcl> := TK_TYPEID <scoped_name> TK_STRING_LITERAL
--(260) <type_prefix_dcl> := TK_TYPEPREFIX <scoped_name> TK_STRING_LITERAL
--(265) <valueinhe_export_empty>:= <value_inhe_spec> "{" <export_l> "}
--(266) | "{" <export_l> "}"
--(267) | empty
--(268) <value_inhe_spec> := ":" <truncatable_e> <value_name> <value_name_list>
-- <supports_e>
--(269) | <supports_e>
--(270) | empty
--(271) <truncatable_e> := TK_TRUNCATABLE
--(272) | empty
--(273) <value_name> := TK_ID <value_name_l>
--(274) | ":" ":" TK_ID <value_name_l>
--(275) <value_name_l> := ":" ":" TK_ID <value_name_l>
--(276) | empty
--(277) <value_name_list> := "," <value_name> <value_name_list>
--(278) | empty
--(279) <supports_e> := TK_SUPPORTS <inter_name> <inter_name_seq2>
--(280) | empty
--(281) <value_or_event> := TK_VALUETYPE TK_ID <valueinhe_export>
--(282) | TK_EVENTTYPE TK_ID <valueinhe_export>
--(283) <valueinhe_export> := <value_inhe_spec> "{" <value_element_l> "}"
--(284) | "{" <value_element_l> "}"
--(285) <value_element_l> := <value_element> <value_element_l>
--(286) | empty
--(287) <value_element> := <export>
--(288) | <state_member>
--(289) | <init_dcl>
--(290) <state_member> := TK_PUBLIC <type_spec> <declarator_l> ";"
--(291) | TK_PRIVATE <type_spec> <declarator_l> ";"
--(292) <init_dcl> := TK_FACTORY TK_ID "(" <init_param_dcl_l_e> ")"
-- <raises_expr_e> ";"
--(293) <init_param_dcl_l_e> := <init_param_dcl> <init_param_dcl_l_e_r>
--(294) | empty
--(295) <init_param_dcl_l_e_r> := "," <init_param_dcl> <init_param_dcl_l_e_r>
--(296) | empty
--(297) <init_param_dcl> := TK_IN <param_type_spec> TK_ID
--(298) <value_tail> := <value_inhe_spec> "{" <value_element_l> "}"
--(299) | "{" <value_element_l> "}"
--(300) | <type_spec>
--(301) | empty
--(302) <eventtype_tail> := <value_inhe_spec> "{" <value_element_l> "}"
--(303) | "{" <value_element_l> "}"
--(304) | empty
--(305) <module> := TK_MODULE TK_ID "{" <definition_l> "}"
--(306) <component> := TK_COMPONENT TK_ID <component_tail>
--(307) <component_tail> := <component_inh_spec> <supp_inter_spec>
-- "{" <component_body> "}"
--(308) | <supp_inter_spec> "{" <component_body> "}"
--(309) | "{" <component_body> "}"
--(310) | empty
--(311) <component_inh_spec> := ":" <component_name>
--(312) <component_name> := TK_ID <component_name_l>
--(313) | ":" ":" TK_ID <component_name_l>
--(314) <component_name_l> := ":" ":" TK_ID <component_name_l>
--(315) | empty
--(316) <supp_inter_spec> := TK_SUPPORTS <supp_name> <supp_name_list>
--(316e) | empty
--(317) <supp_name> := TK_ID <supp_name_l>
--(318) | ":" ":" TK_ID <supp_name_l>
--(319) <supp_name_l> := ":" ":" TK_ID <supp_name_l>
--(320) | empty
--(321) <supp_name_list> := "," <supp_name> <supp_name_list>
--(322) | empty
--(323) <component_body> := <component_export> <component_body>
--(324) | empty
--(325) <component_export> := <provides_dcl> ";"
--(326) | <uses_dcl> ";"
--(327) | <emits_dcl> ";"
--(328) | <publishes_dcl> ";"
--(329) | <consumes_dcl> ";"
--(330) | <attr_dcl> ";"
--(331) <provides_dcl> := TK_PROVIDES <interface_type> TK_ID
--(332) <interface_type> := <scoped_name>
--(333) | TK_OBJECT
--(338) <uses_dcl> := TK_USES <multiple_e> <interface_type> TK_ID
--(339) <multiple_e> := TK_MULTIPLE
--(340) | empty
--(341) <emits_dcl> := TK_EMITS <scoped_name> TK_ID
--(342) <publishes_dcl> := TK_PUBLISHES <scoped_name> TK_ID
--(343) <consumes_dcl> := TK_CONSUMES <scoped_name> TK_ID
--(344) <home_dcl> := TK_HOME TK_ID <home_dcl_tail>
--(345) <home_dcl_tail> := <home_inh_spec> <supp_inter_spec>
-- TK_MANAGES <home_name> <primary_key_spec_e>
-- "{" <home_export_l> "}"raises_expr>
--(346) | <supp_inter_spec> TK_MANAGES <home_name> <primary_key_spec_e>
-- "{" <home_export_l> "}"
--(347) | TK_MANAGES <home_name> <primary_key_spec_e>
-- "{" <home_export_l> "}"
--(348) <home_inh_spec> := ":" <scoped_name>
--(353) <primary_key_spec_e> := TK_PRIMARYKEY <scoped_name>
--(354) | empty
--(359) <home_export_l> := <home_export> <home_export_l>
--(360) | empty
--(361) <home_export> := <export>
--(362) | <factory_dcl> ";"
--(363) | <finder_dcl> ";"
--(364) <factory_dcl> := TK_FACTORY TK_ID "(" <init_param_dcls> ")"
-- <raises_expr_e>
--(365) <finder_dcl> := TK_FINDER TK_ID "(" <init_param_dcls> ")"
-- <raises_expr_e>
--(366) <init_param_dcls> := <init_param_dcl> <init_param_dcl_list>
--(367) | empty
--(368) <init_param_dcl_list> := "," <init_param_dcl> <init_param_dcl_list>
--(369) | empty
--(370) <raises_expr_e> := <raises_expr>
--(371) | empty
--(376) <enumerator> := TK_ID
--(377) <context_expr_e> := <context_expr>
--(378) | empty
--(379) <context> := 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] = "<identifier>",
[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] = "<integer literal>",
[lex.tab_tokens.TK_FLOAT_LITERAL] = "<float literal>",
[lex.tab_tokens.TK_CHAR_LITERAL] = "<char literal>",
[lex.tab_tokens.TK_WCHAR_LITERAL] = "<wchar literal>",
[lex.tab_tokens.TK_STRING_LITERAL] = "<string literal>",
[lex.tab_tokens.TK_WSTRING_LITERAL] = "<wstring literal>",
[lex.tab_tokens.TK_FIXED_LITERAL] = "<fixed literal>",
[lex.tab_tokens.TK_PRAGMA_PREFIX] = "<pragma prefix>",
[lex.tab_tokens.TK_PRAGMA_ID] = "<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, ':', <integer literal>,"..
"<string literal>, <char literal>, <fixed literal>,"..
"<float literal>, 'TRUE' or 'FALSE'",
[14] = "'-', '+', '~'",
[15] = "'(', identifier, ':', <integer literal>,"..
"<string literal>, <char literal>, <fixed literal>,"..
"<float literal>, 'TK_TRUE', 'TK_FALSE'",
[16] = "<integer literal>, <string literal>, <char literal>,"..
"<fixed literal>, <float literal>",
[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 <name> "<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 "<string>"
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 <name> 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 <name> 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 <scoped_name> in the <const_type> production must be a previously \
defined name of an <integer_type>, <char_type>, <wide_char_type>, \
<boolean_type>, <floating_pt_type>, \
<string_type>, <wide_string_type>, <octet_type>, or <enum_type> 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, '<identifier>')
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("<identifier> 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', <identifier>, ':' 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) <primary_key_spec_e> := TK_PRIMARYKEY <scoped_name>
--(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.r