home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / fnb101.zip / Lib / site-packages / Fnorb / parser / IDLParser.py < prev    next >
Text File  |  1999-06-28  |  59KB  |  1,984 lines
  1. #!/usr/bin/env python
  2. #############################################################################
  3. # Copyright (C) DSTC Pty Ltd (ACN 052 372 577) 1997, 1998, 1999
  4. # All Rights Reserved.
  5. #
  6. # The software contained on this media is the property of the DSTC Pty
  7. # Ltd.  Use of this software is strictly in accordance with the
  8. # license agreement in the accompanying LICENSE.HTML file.  If your
  9. # distribution of this software does not contain a LICENSE.HTML file
  10. # then you have no rights to use this software in any manner and
  11. # should contact DSTC at the address below to determine an appropriate
  12. # licensing arrangement.
  13. # 
  14. #      DSTC Pty Ltd
  15. #      Level 7, GP South
  16. #      Staff House Road
  17. #      University of Queensland
  18. #      St Lucia, 4072
  19. #      Australia
  20. #      Tel: +61 7 3365 4310
  21. #      Fax: +61 7 3365 4311
  22. #      Email: enquiries@dstc.edu.au
  23. # 
  24. # This software is being provided "AS IS" without warranty of any
  25. # kind.  In no event shall DSTC Pty Ltd be liable for damage of any
  26. # kind arising out of or in connection with the use or performance of
  27. # this software.
  28. #
  29. # Project:      Fnorb
  30. # File:         $Source: /units/arch/src/Fnorb/parser/RCS/IDLParser.py,v $
  31. # Version:      @(#)$RCSfile: IDLParser.py,v $ $Revision: 1.12 $
  32. #
  33. #############################################################################
  34. """ Parser for OMG IDL. """
  35.  
  36.  
  37. # Standard/built-in modules.
  38. import new, string, sys, types
  39.  
  40. # Fnorb modules.
  41. from Fnorb.orb import CORBA, Fixed, Limits, Util
  42.  
  43. # Fnorb extension modules.
  44. import bison
  45.  
  46. # Parser modules.
  47. import Declarator, Prefix, Stack
  48.  
  49.  
  50. class IDLParser:
  51.     """ Parser for OMG IDL.
  52.  
  53.     This class implements the semantic actions for the IDL parser. The actual
  54.     parsing engine is implemented in 'C' using 'flex' and 'bison'. 
  55.  
  56.     """
  57.  
  58.     #########################################################################
  59.     # Parser interface.
  60.     #########################################################################
  61.  
  62.     def parse(self, repository, filename, yyin):
  63.     """ Parse some IDL!
  64.  
  65.     'repository' is the interface repository (IFR) to be populated.
  66.     'filename'   is the filename of the top-level IDL file.
  67.     'yyin'       is an open file object to read the IDL from.
  68.  
  69.     """
  70.     self.__repository = repository
  71.     self.__filename = filename
  72.  
  73.     # Initialise the various data structures used during parsing.
  74.     self.__initialise()
  75.  
  76.     # Do the parsing!
  77.     result = bison.yyparse(self, yyin)
  78.  
  79.     # Clean up!
  80.     self.__cleanup()
  81.  
  82.     return (result, self.__top_level_definitions)
  83.  
  84.     def yyerror(self, message):
  85.     """ Error function called from the 'bison' parser. """
  86.  
  87.     sys.stderr.write("Error: %s on line %d of %s\n" % \
  88.              (message, bison.yylineno(), self.__current_file))
  89.     return
  90.  
  91.     def yywarning(self, message):
  92.     """ Warning function. """
  93.  
  94.     sys.stderr.write("Warning: %s on line %d of %s\n" % \
  95.              (message, bison.yylineno(), self.__current_file))
  96.     return
  97.  
  98.     #########################################################################
  99.     # Semantic actions (called from 'grammar.y').
  100.     #########################################################################
  101.  
  102.     def specification_start(self):
  103.     """ specification: """
  104.  
  105.     # The container stack initially contains just the repository.
  106.     self.__container_stack = Stack.Stack()
  107.     self.__container_stack.push(self.__repository)
  108.  
  109.     return
  110.  
  111.     def specification_end(self):
  112.     """ specification: definition_PLUS """
  113.  
  114.     # Report an error for any interfaces that were 'forward' declared but
  115.     # not defined!
  116.     self.__check_forward_interfaces()
  117.  
  118.     # Pop the repository from the container stack, and make sure that the
  119.     # stack really is empty!
  120.     self.__container_stack.pop()
  121.     assert(len(self.__container_stack) == 0)
  122.  
  123.     return
  124.  
  125.     def module_header(self, name):
  126.     """ MODULE IDENTIFIER """
  127.  
  128.     # Get the container and prefix from the stacks.
  129.     container = self.__container_stack.get()
  130.     prefix = self.__prefix_stack.get()
  131.  
  132.     # Does the container already contain a definition with this name?
  133.     module = container.lookup(name)
  134.  
  135.     # If there is *no* definition with this name then we can safely create
  136.     # a new module.
  137.     if module is None:
  138.         # Currently the version is always "1.0"!
  139.         version = "1.0"
  140.  
  141.         # Generate an interface repository id.
  142.         ifr_id = self.__create_ifr_id(prefix, name, version)
  143.  
  144.         # Create a new module definition in the container.
  145.         module = container.create_module(ifr_id, name, version)
  146.  
  147.         # If the module is defined at the global scope of the top-level IDL
  148.         # file then add it to our list of top-level definitions.
  149.         if self.__is_a_top_level_definition(module):
  150.         self.__top_level_definitions.append(module)
  151.  
  152.     # Otherwise, a definition with this name already exists.
  153.     else:
  154.         # If it is a module definition then we just "re-open" it to allow
  155.         # more definitions to be added.  If it is not a module definition
  156.         # then it is illegal!
  157.         if module._get_def_kind() != CORBA.dk_Module:
  158.         self.yyerror("Redefinition of name '%s'" % name)
  159.         raise bison.YYERROR
  160.  
  161.         # If the module is defined at the global scope of the top-level IDL
  162.         # file then add it to our list of top-level definitions.
  163.         #
  164.         # We have to do this here as the first occurence of the module may
  165.         # have been in a file that was '#included'.
  166.         if self.__is_a_top_level_definition(module):
  167.         self.__top_level_definitions.append(module)
  168.  
  169.         # fixme: Check for ID compatability in the case of '#pragma ID'?
  170.         pass
  171.  
  172.     # Push the module onto the container stack.
  173.     self.__container_stack.push(module)
  174.  
  175.     # Push the new prefix onto the prefix stack.
  176.     self.__prefix_stack.push(self.__create_prefix(prefix, name))    
  177.  
  178.     return
  179.  
  180.     def module_body(self):
  181.     """ '{' definition_STAR '}' """
  182.     
  183.     # Pop the container and prefix from the stacks.
  184.     self.__container_stack.pop()
  185.     self.__prefix_stack.pop()
  186.     
  187.     return
  188.  
  189.     def interface_dcl_header(self, name, base_interfaces):
  190.     """ INTERFACE IDENTIFIER inheritance_spec_OPT """
  191.  
  192.     # Get the container and prefix from the stacks.
  193.     container = self.__container_stack.get()
  194.     prefix = self.__prefix_stack.get()
  195.  
  196.     # Does the container already contain a definition with this name?
  197.     interface = container.lookup(name)
  198.  
  199.     # If there is *no* definition with this name then we can safely create
  200.     # a new interface.
  201.     if interface is None:
  202.         # Currently the version is always "1.0"!
  203.         version = "1.0"
  204.  
  205.         # Generate an interface repository id.
  206.         ifr_id = self.__create_ifr_id(prefix, name, version)
  207.  
  208.         # Create a new interface definition in the container.
  209.         interface = container.create_interface(ifr_id, name, version, [])
  210.  
  211.         # If the interface is defined at the global scope of the top-level
  212.         # IDL file then add it to our list of top-level definitions.
  213.         if self.__is_a_top_level_definition(interface):
  214.         self.__top_level_definitions.append(interface)
  215.  
  216.     # Otherwise, a definition with this name already exists.
  217.     else:
  218.         # If it is *not* an interface definition then it is definitely
  219.         # illegal!
  220.         if interface._get_def_kind() != CORBA.dk_Interface:
  221.         self.yyerror("Redefinition of name '%s'" % name)
  222.         raise bison.YYERROR
  223.  
  224.         # If it *is* an interface definition then it must be a forward
  225.         # declaration. If not then it is also illegal!
  226.         if interface._get_version() != 'forward':
  227.         self.yyerror("Redefinition of name '%s'" % name)
  228.         raise bison.YYERROR
  229.  
  230.         # fixme: Check for ID compatability in the case of '#pragma ID'?
  231.         pass
  232.  
  233.         # 'Move' the interface definition to the same container (this has
  234.         # the side-effect of placing it last in the containers list of
  235.         # contents ;^)
  236.         interface.move(container, name, "1.0")
  237.  
  238.         # Delete the interface from the dictionary containing forward
  239.         # declared but undefined interfaces,
  240.         del self.__forward_interfaces[interface._get_id()]
  241.  
  242.     # Check the base interfaces.
  243.     for base in base_interfaces:
  244.         # Make sure that the base interface is not a forward delcaration.
  245.         if base._get_version() == 'forward':
  246.         self.yyerror("Interface '%s' not defined" % base._get_name())
  247.         raise bison.YYERROR
  248.  
  249.         # Make sure that some poor shmuck is not attempting to make the 
  250.         # interface inherit from itself!
  251.         #
  252.         # fixme: Will this work in the presence of '#pragma ID'?
  253.         if base._get_id() == interface._get_id():
  254.         self.yyerror("Interface '%s' inherits from itself!" % name)
  255.         raise bison.YYERROR
  256.  
  257.     # Update the list of base interfaces.
  258.     interface._set_base_interfaces(base_interfaces)
  259.         
  260.     # Push the interface onto the container stack.
  261.     self.__container_stack.push(interface)
  262.  
  263.     # Push a new prefix onto the prefix stack.
  264.     self.__prefix_stack.push(self.__create_prefix(prefix, name))    
  265.  
  266.     return interface
  267.  
  268.     def interface_dcl_body(self, interface):
  269.     """ '{' export_STAR '}' """
  270.  
  271.     # Get the interface description.
  272.     description = interface.describe_interface()
  273.  
  274.     # Get the names of all of the interface's operations and attributes.
  275.     names = map(lambda o: o.name, description.operations)
  276.     names = names + map(lambda a: a.name, description.attributes)
  277.  
  278.     # Add the interface to the interface dictionary.
  279.     self.__interfaces[interface._get_id()] = names
  280.  
  281.     # Get the names of all inherited operations and attributes.
  282.     inherited = self.__get_inherited_operations(interface, [])
  283.  
  284.     # Make sure there are no clashes!
  285.     if len(inherited) > 0:
  286.         for name in names:
  287.         if name in inherited:
  288.             self.yyerror("Overloaded operation/attribute '%s'" % name)
  289.             raise bison.YYERROR
  290.  
  291.     # Pop the container and prefix from the stacks.
  292.     self.__container_stack.pop()
  293.     self.__prefix_stack.pop()
  294.     
  295.     return
  296.  
  297.     def foward_dcl(self, name):
  298.     """ forward_dcl: INTERFACE IDENTIFIER """
  299.  
  300.     # Get the container and prefix from the stacks.
  301.     container = self.__container_stack.get()
  302.     prefix = self.__prefix_stack.get()
  303.  
  304.     # Does the container already contain a definition with this name?
  305.     interface = container.lookup(name)
  306.  
  307.     # If there is *no* definition with this name then we can safely create
  308.     # a new interface.
  309.     if interface is None:
  310.         # Currently the version is always "1.0"!
  311.         version = "1.0"
  312.  
  313.         # Generate a repository id.
  314.         ifr_id = self.__create_ifr_id(prefix, name, version)
  315.  
  316.         # Create a new interface definition in the container and tag it
  317.         # with a version of "forward".
  318.         interface = container.create_interface(ifr_id, name, "forward", [])
  319.  
  320.         # If the interface is defined at the global scope of the top-level
  321.         # IDL file then add it to our list of top-level definitions.
  322.         if self.__is_a_top_level_definition(interface):
  323.         self.__top_level_definitions.append(interface)
  324.  
  325.         # Add the interface to the dictionary of forward declared but
  326.         # undefined interfaces.
  327.         self.__forward_interfaces[ifr_id] = (interface, bison.yylineno())
  328.  
  329.     # Otherwise, a definition with this name already exists.
  330.     else:
  331.         # If it is *not* an interface definition then it is illegal!
  332.         if interface._get_def_kind() != CORBA.dk_Interface:
  333.         self.yyerror("Redefinition of name '%s'" % name)
  334.         raise bison.YYERROR
  335.  
  336.         # fixme: Check for ID compatability in the case of '#pragma ID'?
  337.         pass
  338.  
  339.     return
  340.  
  341.     def inheritance_spec_empty(self):
  342.     """ inheritance_spec: /* empty */ """
  343.  
  344.     return [] # [InterfaceDef]
  345.  
  346.     def inheritance_spec_full(self, scoped_names):
  347.     """ inheritance_spec: ':' scoped_name_CSV_PLUS """
  348.  
  349.     # Get the container from the stack.
  350.     container = self.__container_stack.get()
  351.  
  352.     # Find the interface definition for each scoped name.
  353.     base_interfaces = []
  354.     for scoped_name in scoped_names:
  355.         # Lookup the definition.
  356.         interface = self.__find_scoped_name(container, scoped_name)
  357.         if interface is None:
  358.         raise bison.YYERROR
  359.  
  360.         # If it is *not* an interface definition then it is illegal!
  361.         if interface._get_def_kind() != CORBA.dk_Interface:
  362.         self.yyerror("'%s' is not an interface" % scoped_name)
  363.         raise bison.YYERROR
  364.  
  365.         base_interfaces.append(interface)
  366.  
  367.     return base_interfaces
  368.  
  369.     def scoped_name_absolute(self, identifier):
  370.     """ scoped_name: SCOPE_DELIMITER IDENTIFIER """
  371.  
  372.     return "::" + identifier
  373.  
  374.     def scoped_name_relative(self, scoped_name, identifier):
  375.     """ scoped_name: scoped_name SCOPE_DELIMITER IDENTIFIER """
  376.  
  377.     return scoped_name + "::" + identifier
  378.  
  379.     def const_dcl(self, type_def, name, any):
  380.     """ const_dcl: CONST const_type IDENTIFIER '=' const_expr """
  381.  
  382.     # Get the container and prefix from the stacks.
  383.     container = self.__container_stack.get()
  384.     prefix = self.__prefix_stack.get()
  385.  
  386.     # Does the container already contain a definition with this name?
  387.     constant = container.lookup(name)
  388.  
  389.     # If there is *no* definition with this name then we can safely create
  390.     # a new constant.
  391.     if constant is None:
  392.         # Make sure that the value is of the appropriate type.
  393.         if not self.__check_constant_type(type_def, any):
  394.         self.yyerror("Constant '%s' invalid value type" % name)
  395.         raise bison.YYERROR
  396.  
  397.         # Make sure that the value is within the limits of the type, and
  398.         # coerce it if necessary.
  399.         (result, value) = self.__check_limits(type_def, any)
  400.         if not result:
  401.         self.yyerror("Constant '%s' out of range" % name)
  402.         raise bison.YYERROR
  403.  
  404.         # Wrap the coerced value back in an 'Any' of the appropriate type.
  405.         any = CORBA.Any(type_def._get_type(), value)
  406.  
  407.         # Currently the version is always "1.0"!
  408.         version = "1.0"
  409.  
  410.         # Generate an interface repository id.
  411.         ifr_id = self.__create_ifr_id(prefix, name, version)
  412.  
  413.         # Create a new constant definition in the container.
  414.         constant = container.create_constant(ifr_id, name, version,
  415.                          type_def, any)
  416.  
  417.         # If the constant is defined at the global scope of the top-level
  418.         # IDL file then add it to our list of top-level definitions.
  419.         if self.__is_a_top_level_definition(constant):
  420.         self.__top_level_definitions.append(constant)
  421.  
  422.     # Otherwise, a definition with this name already exists.
  423.     else:
  424.         self.yyerror("Redefinition of name '%s'" % name)
  425.         raise bison.YYERROR
  426.  
  427.     return constant
  428.  
  429.     # Valid types for constant expressions.
  430.     __CONST_TYPES = [CORBA.pk_short,
  431.              CORBA.pk_long,
  432.              CORBA.pk_ushort,
  433.              CORBA.pk_ulong,
  434.              CORBA.pk_char,
  435.              CORBA.pk_boolean,
  436.              CORBA.pk_float,
  437.              CORBA.pk_double,
  438.              CORBA.pk_string,
  439.              CORBA.pk_longlong,
  440.              CORBA.pk_ulonglong,
  441.              CORBA.pk_longdouble,
  442.              CORBA.pk_wchar,
  443.              CORBA.pk_wstring]
  444.  
  445.     def const_type_scoped_name(self, scoped_name):
  446.     """ const_type: scoped_name """
  447.  
  448.     # Get the container from the stack.
  449.     container = self.__container_stack.get()
  450.  
  451.     # Lookup the definition referenced by the scoped name.
  452.     definition = self.__find_scoped_name(container, scoped_name)
  453.  
  454.     # Unwind any 'typedef' chain.
  455.     definition = self.__unwind_typedef_chain(definition)
  456.  
  457.     # Make sure that the definition is either:-
  458.     #
  459.     # 1) One of the following primitive types:-
  460.     #
  461.     #    integer, char, wchar, boolean, floating point, string, wstring
  462.     #
  463.     # 2) Of type 'fixed'.
  464.     if definition._get_def_kind() == CORBA.dk_Primitive \
  465.        and definition._get_kind() in IDLParser.__CONST_TYPES:
  466.         pass
  467.  
  468.     elif definition._get_def_kind() == CORBA.dk_Fixed:
  469.         pass
  470.  
  471.     else:
  472.         self.yyerror("Invalid constant type '%s'" % scoped_name)
  473.          raise bison.YYERROR
  474.  
  475.     return definition
  476.  
  477.     # The arguments to constant expression operators are 'Any's, and the
  478.     # operations are implemented in the 'Any' module.
  479.     def or_expr(self, x, y):
  480.     """ or_expr: or_expr '|' xor_expr """
  481.  
  482.     return x | y
  483.  
  484.     def xor_expr(self, x, y):
  485.     """ xor_expr: xor_expr '^' and_expr """
  486.  
  487.     return x ^ y
  488.  
  489.     def and_expr(self, x, y):
  490.     """ and_expr: and_expr '&' shift_expr """
  491.  
  492.     return x & y
  493.  
  494.     def shift_expr_right(self, x, y):
  495.     """ shift_expr: shift_expr RIGHT_SHIFT add_expr """
  496.  
  497.     return x >> y
  498.  
  499.     def shift_expr_left(self, x, y):
  500.     """ shift_expr: shift_expr LEFT_SHIFT add_expr """
  501.  
  502.     return x << y
  503.  
  504.     def add_expr_add(self, x, y):
  505.     """ add_expr: add_expr '+' mult_expr """
  506.  
  507.     return x + y
  508.  
  509.     def add_expr_subtract(self, x, y):
  510.     """ add_expr: add_expr '-' mult_expr """
  511.  
  512.     return x - y
  513.  
  514.     def mult_expr_multiply(self, x, y):
  515.     """ mult_expr: mult_expr '*' unary_expr """
  516.  
  517.     return x * y
  518.  
  519.     def mult_expr_divide(self, x, y):
  520.     """ mult_expr: mult_expr '/' unary_expr """
  521.  
  522.     return x / y
  523.  
  524.     def mult_expr_mod(self, x, y):
  525.     """ mult_expr: mult_expr '%' unary_expr """
  526.  
  527.     return x % y
  528.  
  529.     def unary_expr_neg(self, x):
  530.     """ unary_expr: '-' primary_expr """
  531.  
  532.     return -x
  533.  
  534.     def unary_expr_pos(self, x):
  535.     """ unary_expr: '+' primary_expr """
  536.  
  537.     return +x
  538.  
  539.     def unary_expr_invert(self, x):
  540.     """ unary_expr: '~' primary_expr """
  541.  
  542.     return ~x
  543.  
  544.     def primary_expr_scoped_name(self, scoped_name):
  545.     """ primary_expr: scoped_name """
  546.  
  547.     # Get the container from the stack.
  548.     container = self.__container_stack.get()
  549.  
  550.     # Lookup the definition referenced by the scoped name.
  551.     definition = self.__find_scoped_name(container, scoped_name)
  552.     if definition is None:
  553.         raise bison.YYERROR
  554.  
  555.     # If it is not a constant definition then it is illegal!
  556.     if definition._get_def_kind() != CORBA.dk_Constant:
  557.         self.yyerror("'%s' is not a constant expression" % scoped_name)
  558.         raise bison.YYERROR
  559.  
  560.     # Return the constant's value (an 'Any').
  561.     return definition._get_value()
  562.  
  563.     def literal_integer_literal(self, value):
  564.     """ literal: INTEGER_LITERAL """
  565.  
  566.     # We get integer literals as the raw string token from the lexer.
  567.     #
  568.     # fixme: Should we do this for floating point literals as well?
  569.  
  570.     # All integer literals are converted to Python *long* integers and then
  571.     # coerced back as appropriate.
  572.     return CORBA.Any(CORBA.TC_longlong, eval(value + "L"))
  573.  
  574.     def literal_string_literal(self, value):
  575.     """ literal: STRING_LITERAL """
  576.  
  577.     # Evaluate the string containing the string!
  578.     return CORBA.Any(CORBA.TC_string, eval(value))
  579.  
  580.     def literal_character_literal(self, value):
  581.     """ literal: CHARACTER_LITERAL """
  582.  
  583.     # Evaluate the string containing the character!
  584.     return CORBA.Any(CORBA.TC_char, eval(value))
  585.  
  586.     def literal_fixed_pt_literal(self, value):
  587.     """ literal: FIXED_PT_LITERAL """
  588.  
  589.     # Fixed point values are instances of the 'Fixed' class.
  590.     fixed = new.instance(Fixed.Fixed, {})
  591.  
  592.     # Initialise the instance from the literal.
  593.     fixed._fnorb_from_literal(value)
  594.  
  595.     return CORBA.Any(fixed._fnorb_typecode(), fixed)
  596.  
  597.     def literal_floating_pt_literal(self, value):
  598.     """ literal: FLOATING_PT_LITERAL """
  599.  
  600.     return CORBA.Any(CORBA.TC_double, value)
  601.  
  602.     def boolean_literal_true(self):
  603.     """ boolean_literal: TRUE """
  604.     
  605.     return CORBA.Any(CORBA.TC_boolean, 1)
  606.  
  607.     def boolean_literal_false(self):
  608.     """ boolean_literal: FALSE """
  609.     
  610.     return CORBA.Any(CORBA.TC_boolean, 0)
  611.     
  612.     def positive_int_const(self, any):
  613.     """ positive_int_const: const_expr """
  614.  
  615.     # Get the typecode's 'kind'.
  616.     kind = any.typecode().kind()
  617.  
  618.     # Make sure that it really is a positive, integer ;^)
  619.     if kind not in IDLParser.__TK_INT or any.value() < 0:
  620.         self.yyerror("Positive integer value required")
  621.         raise bison.YYERROR
  622.  
  623.     # Extract the value from the 'Any'.
  624.     return any.value()
  625.  
  626.     def type_declarator(self, type_def, declarators):
  627.     """ type_declarator: type_spec declarators """
  628.  
  629.     # Get the container and prefix from the stacks.
  630.     container = self.__container_stack.get()
  631.     prefix = self.__prefix_stack.get()
  632.  
  633.     # Create a 'typedef' definition for each declarator.
  634.     for declarator in declarators:
  635.         # Get the name of the declarator.
  636.         name = declarator.name()
  637.  
  638.         # Does the container already contain a definition with this name?
  639.         definition = container.lookup(name)
  640.  
  641.         # If there is *no* definition with this name then we can safely
  642.         # create a new 'typedef' definition.
  643.         if definition is None:
  644.         # Currently the version is always "1.0"!
  645.         version = "1.0"
  646.  
  647.         # Generate an interface repository id.
  648.         ifr_id = self.__create_ifr_id(prefix, name, version)
  649.  
  650.         # If this is an array declarator.
  651.         if isinstance(declarator, Declarator.ArrayDeclarator):
  652.             # Get the array dimensions.
  653.             dimensions = declarator.dimensions()
  654.  
  655.             # Create the array type.
  656.             actual_type_def = self.__create_array(type_def, dimensions)
  657.  
  658.         # Otherwise it is a simple declarator.
  659.         else:
  660.             actual_type_def = type_def
  661.  
  662.         # Create a new 'typedef' definition in the container.
  663.         definition = container.create_alias(ifr_id, name, version,
  664.                             actual_type_def)
  665.  
  666.         # If the 'typedef' is defined at the global scope of the
  667.         # top-level IDL file then add it to our list of top-level
  668.         # definitions.
  669.         if self.__is_a_top_level_definition(definition):
  670.             self.__top_level_definitions.append(definition)
  671.  
  672.         # Otherwise, a definition with this name already exists.
  673.         else:
  674.         self.yyerror("Redefinition of name '%s'" % name)
  675.         raise bison.YYERROR
  676.         
  677.     return
  678.  
  679.     def simple_declarator(self, name):
  680.     """ simple_declarator: IDENTIFIER """
  681.  
  682.     return Declarator.SimpleDeclarator(name)
  683.  
  684.     def float_type(self):
  685.     """ floating_pt_type: FLOAT """
  686.  
  687.     return self.__repository.get_primitive(CORBA.pk_float)
  688.  
  689.     def double_type(self):
  690.     """ floating_pt_type: DOUBLE """
  691.  
  692.     return self.__repository.get_primitive(CORBA.pk_double)
  693.  
  694.     def longdouble_type(self):
  695.     """ floating_pt_type: LONG DOUBLE """
  696.  
  697.     self.yywarning("'long double' not supported by Fnorb runtime")
  698.     return self.__repository.get_primitive(CORBA.pk_longdouble)
  699.  
  700.     def signed_short_int(self):
  701.     """ signed_short_int: SHORT """
  702.  
  703.     return self.__repository.get_primitive(CORBA.pk_short)
  704.  
  705.     def signed_long_int(self):
  706.     """ signed_long_int: LONG """
  707.  
  708.     return self.__repository.get_primitive(CORBA.pk_long)
  709.  
  710.     def signed_longlong_int(self):
  711.     """ signed_longlong_int: LONG LONG"""
  712.  
  713.     return self.__repository.get_primitive(CORBA.pk_longlong)
  714.  
  715.     def unsigned_short_int(self):
  716.     """ unsigned_short_int: UNSIGNED SHORT """
  717.  
  718.     return self.__repository.get_primitive(CORBA.pk_ushort)
  719.  
  720.     def unsigned_long_int(self):
  721.     """ unsigned_long_int: UNSIGNED LONG """
  722.  
  723.     return self.__repository.get_primitive(CORBA.pk_ulong)
  724.  
  725.     def unsigned_longlong_int(self):
  726.     """ unsigned_longlong_int: UNSIGNED LONG LONG"""
  727.  
  728.     return self.__repository.get_primitive(CORBA.pk_ulonglong)
  729.  
  730.     def char_type(self):
  731.     """ char_type: CHAR """
  732.  
  733.     return self.__repository.get_primitive(CORBA.pk_char)
  734.  
  735.     def wide_char_type(self):
  736.     """ wide_char_type: WCHAR """
  737.  
  738.     self.yywarning("'wchar' not supported by Fnorb runtime")
  739.     return self.__repository.get_primitive(CORBA.pk_wchar)
  740.  
  741.     def boolean_type(self):
  742.     """ boolean_type: BOOLEAN """
  743.  
  744.     return self.__repository.get_primitive(CORBA.pk_boolean)
  745.  
  746.     def octet_type(self):
  747.     """ octet_type: OCTET """
  748.  
  749.     return self.__repository.get_primitive(CORBA.pk_octet)
  750.  
  751.     def any_type(self):
  752.     """ any_type: IDL_ANY """
  753.  
  754.     return self.__repository.get_primitive(CORBA.pk_any)
  755.  
  756.     def object_type(self):
  757.     """ object_type: OBJECT """
  758.  
  759.     return self.__repository.get_primitive(CORBA.pk_objref)
  760.  
  761.     def struct_type_header(self, name):
  762.     """ struct_type: STRUCT IDENTIFIER """
  763.  
  764.     # Get the container and prefix from the stacks.
  765.     container = self.__container_stack.get()
  766.     prefix = self.__prefix_stack.get()
  767.  
  768.     # Does the container already contain a definition with this name?
  769.     struct = container.lookup(name)
  770.  
  771.     # If there is *no* definition with this name then we can safely create
  772.     # a new structure definition.
  773.     if struct is None:
  774.         # Set the version to "wip" (for Work In Progress) to allow the
  775.         # detection of recursive types.
  776.         version = "wip"
  777.         
  778.         # Generate an interface repository id.
  779.         ifr_id = self.__create_ifr_id(prefix, name, version)
  780.  
  781.         # Create a new structure definition in the container.
  782.         struct = container.create_struct(ifr_id, name, version, [])
  783.  
  784.         # If the structure is defined at the global scope of the top-level
  785.         # IDL file then add it to our list of top-level definitions.
  786.         if self.__is_a_top_level_definition(struct):
  787.         self.__top_level_definitions.append(struct)
  788.  
  789.     # Otherwise, a definition with this name already exists.
  790.     else:
  791.         self.yyerror("Redefinition of name '%s'" % name)
  792.         raise bison.YYERROR
  793.  
  794.     # Push the structure onto the container stack.
  795.     self.__container_stack.push(struct)
  796.  
  797.     # Push a new prefix onto the prefix stack.
  798.     self.__prefix_stack.push(self.__create_prefix(prefix, name))    
  799.  
  800.     return struct
  801.  
  802.     def struct_type_body(self, struct, members):
  803.     """ struct_type: '{'  member_PLUS '}' """
  804.  
  805.     # Make sure that all member names are unique.
  806.     dict = {}
  807.     for member in members:
  808.         if dict.has_key(member.name):
  809.         self.yyerror("Duplicate member name '%s'" % name)
  810.         raise bison.YYERROR
  811.  
  812.         dict[member.name] = None
  813.  
  814.          # Check for recursive members.
  815.          if self.__is_recursive_member(member.type_def):
  816.          # Get the repository id of the recursive structure.
  817.          ifr_id = member.type_def._get_element_type_def()._get_id()
  818.  
  819.          # Find out how deep the recursion is.
  820.          offset = self.__get_recursion_depth(struct, ifr_id)
  821.  
  822.          # Get the bound of the sequence type.
  823.          length = member.type.length()
  824.  
  825.          # Replace the sequence typecode with a recursive sequence
  826.          # typecode.
  827.          member.type = CORBA.RecursiveSequenceTypeCode(length, offset)
  828.  
  829.     # Fixup the version.
  830.     struct._set_version("1.0")
  831.  
  832.     # Update the structure definition.
  833.     struct._set_members(members)
  834.  
  835.     # Pop the container and prefix from the stacks.
  836.     self.__container_stack.pop()
  837.     self.__prefix_stack.pop()
  838.     
  839.     return struct
  840.  
  841.     def member(self, type_def, declarators):
  842.     """ member: type_spec declarators """
  843.  
  844.     members = []
  845.     for declarator in declarators:
  846.         # If this is an array declarator.
  847.         if isinstance(declarator, Declarator.ArrayDeclarator):
  848.         # Get the array dimensions.
  849.         dimensions = declarator.dimensions()
  850.  
  851.         # Create the array type.
  852.         actual_type_def = self.__create_array(type_def, dimensions)
  853.  
  854.         # Otherwise it is a simple declarator.
  855.         else:
  856.         actual_type_def = type_def
  857.  
  858.         # Create a 'StructMember' instance.
  859.         members.append(CORBA.StructMember(declarator.name(),
  860.                           actual_type_def._get_type(),
  861.                           actual_type_def))
  862.     return members
  863.  
  864.     def union_type_header(self, name, type_def):
  865.     """ union_type: UNION IDENTIFIER SWITCH '(' switch_type_spec ')' """
  866.  
  867.     # Get the container and prefix from the stacks.
  868.     container = self.__container_stack.get()
  869.     prefix = self.__prefix_stack.get()
  870.  
  871.     # Does the container already contain a definition with this name?
  872.     union = container.lookup(name)
  873.  
  874.     # If there is *no* definition with this name then we can safely create
  875.     # a new union.
  876.     if union is None:
  877.         # Set the version to "wip" (for Work In Progress) to allow the
  878.         # detection of recursive types.
  879.         version = "wip"
  880.  
  881.         # Generate an interface repository id.
  882.         ifr_id = self.__create_ifr_id(prefix, name, version)
  883.  
  884.         # Create a new union definition in the container.
  885.         union = container.create_union(ifr_id, name, version, type_def, [])
  886.  
  887.         # If the union is defined at the global scope of the top-level IDL
  888.         # file then add it to our list of top-level definitions.
  889.         if self.__is_a_top_level_definition(union):
  890.         self.__top_level_definitions.append(union)
  891.  
  892.     # Otherwise, a definition with this name already exists.
  893.     else:
  894.         self.yyerror("Redefinition of name '%s'" % name)
  895.         raise bison.YYERROR
  896.  
  897.     # Push the union onto the container stack.
  898.     self.__container_stack.push(union)
  899.  
  900.     # Push a new prefix onto the prefix stack.
  901.     self.__prefix_stack.push(self.__create_prefix(prefix, name))    
  902.  
  903.     return union
  904.  
  905.     def union_type_body(self, union, members):
  906.     """ union_type: '{' switch_body '}' """
  907.  
  908.     # Get the union's discrimintator (aka switch) typecode and type
  909.     # definition.
  910.     typecode = union._get_discriminator_type()
  911.     type_def = union._get_discriminator_type_def()
  912.  
  913.     # Make sure that all member names and label values are unique. This
  914.     # could take some time if some idiot has used, say an unsigned long as
  915.     # the discriminator type and a couple of billion cases ;^)
  916.     name_dict = {}
  917.     label_dict = {}
  918.     default_used = 0
  919.  
  920.     for member in members:
  921.         # Ignore the default case.
  922.         if member.label.typecode().kind() == CORBA.tk_octet:
  923.         default_used = 1
  924.  
  925.         else:
  926.         # Get the label value.
  927.         value = member.label.value()
  928.  
  929.         # Make sure the label is the same type as the discriminant (or
  930.         # coercable to it).
  931.         if not self.__check_label_type(type_def, member.label):
  932.             self.yyerror("Invalid label value %s" % str(value))
  933.             raise bison.YYERROR
  934.  
  935.         # Make sure that the value is within the limits of the type,
  936.         # and coerce it if necessary.
  937.         (result, value) = self.__check_limits(type_def, member.label)
  938.         if not result:
  939.             self.yyerror("Label value '%s' out of range" % str(value))
  940.             raise bison.YYERROR
  941.  
  942.         # Wrap the coerced value back in an 'Any' of the appropriate
  943.         # type.
  944.         member.label = CORBA.Any(typecode, value)
  945.  
  946.         # Name check.
  947.         if name_dict.has_key(member.name):
  948.             self.yyerror("Duplicate member name '%s'" % member.name)
  949.             raise bison.YYERROR
  950.  
  951.         name_dict[member.name] = None
  952.  
  953.         # Label check.
  954.         if label_dict.has_key(value):
  955.             self.yyerror("Duplicate case label %s" % str(value))
  956.             raise bison.YYERROR
  957.  
  958.         label_dict[value] = None
  959.  
  960.         # Check for recursive members.
  961.         if self.__is_recursive_member(member.type_def):
  962.             # Get the repository id of the recursive structure.
  963.             ifr_id = member.type_def._get_element_type_def()._get_id()
  964.  
  965.             # Find out how deep the recursion is.
  966.             offset = self.__get_recursion_depth(union, ifr_id)
  967.  
  968.             # Get the bound of the sequence type.
  969.             length = member.type.length()
  970.  
  971.             # Replace the sequence typecode with a recursive sequence
  972.             # typecode.
  973.             member.type = CORBA.RecursiveSequenceTypeCode(length,
  974.                                   offset)
  975.  
  976.     # If a default case has been specified, then make sure that the
  977.     # case labels for the specified type haven't been exhausted.
  978.     if default_used:
  979.         # Get the typecode kind.
  980.         kind = typecode.kind()
  981.  
  982.         if kind == CORBA.tk_enum:
  983.         limit = typecode.member_count()
  984.         
  985.         elif kind == CORBA.tk_short \
  986.          or typecode.kind() == CORBA.tk_ushort:
  987.         limit = 65536 # 2 ^ 16
  988.  
  989.         elif kind == CORBA.tk_long \
  990.              or typecode.kind() == CORBA.tk_ulong:
  991.         limit = 4294967296L # 2 ^ 32
  992.  
  993.         elif kind == CORBA.tk_longlong \
  994.              or typecode.kind() == CORBA.tk_ulonglong:
  995.         limit = 18446744073709551616L # 2 ^ 64
  996.  
  997.         elif kind == CORBA.tk_char:
  998.         limit = 256 # 2 ^ 8
  999.  
  1000.         elif kind == CORBA.tk_boolean:
  1001.         limit = 2 # 2 ;^)
  1002.  
  1003.         if len(members) - 1 >= limit:
  1004.         self.yyerror("All case labels exhausted")
  1005.         raise bison.YYERROR
  1006.  
  1007.     # Fixup the version.
  1008.     union._set_version("1.0")
  1009.  
  1010.     # Update the union definition.
  1011.     union._set_members(members)
  1012.  
  1013.     # Pop the container and prefix from the stacks.
  1014.     self.__container_stack.pop()
  1015.     self.__prefix_stack.pop()
  1016.     
  1017.     return union
  1018.  
  1019.     # Valid types for union switch specifications.
  1020.     __SWITCH_TYPES = [CORBA.pk_short,
  1021.               CORBA.pk_long,
  1022.               CORBA.pk_longlong,
  1023.               CORBA.pk_ushort,
  1024.               CORBA.pk_ulong,
  1025.               CORBA.pk_ulonglong,
  1026.               CORBA.pk_char,
  1027.               CORBA.pk_boolean]
  1028.  
  1029.     def switch_type_spec_scoped_name(self, scoped_name):
  1030.     """ switch_type_spec: scoped_name """
  1031.  
  1032.     # Get the container from the stack.
  1033.     container = self.__container_stack.get()
  1034.  
  1035.     # Lookup the definition referenced by the scoped name.
  1036.     definition = self.__find_scoped_name(container, scoped_name)
  1037.  
  1038.     # Unwind any 'typedef' chain.
  1039.     definition = self.__unwind_typedef_chain(definition)
  1040.  
  1041.     # Make sure the definition type is either integer, char, boolean, or
  1042.     # an enumeration.
  1043.     if definition._get_def_kind() == CORBA.dk_Primitive:
  1044.         if definition._get_kind() not in IDLParser.__SWITCH_TYPES:
  1045.         self.yyerror("Invalid switch type '%s'" % scoped_name)
  1046.         raise bison.YYERROR
  1047.  
  1048.     elif definition._get_def_kind() != CORBA.dk_Enum:
  1049.         self.yyerror("Invalid switch type '%s'" % scoped_name)
  1050.         raise bison.YYERROR
  1051.        
  1052.     return definition
  1053.  
  1054.     def case(self, labels, (type_def, declarator)):
  1055.     """ case: case_label_PLUS element_spec ';' """
  1056.  
  1057.     typecode = type_def._get_type()
  1058.     name = declarator.name()
  1059.  
  1060.     members = []
  1061.     for label in labels:
  1062.         members.append(CORBA.UnionMember(name, label, typecode, type_def))
  1063.     
  1064.     return members
  1065.  
  1066.     def case_label_default(self):
  1067.     """ case_label: DEFAULT ':' """
  1068.  
  1069.     return CORBA.Any(CORBA.TC_octet, 0)
  1070.  
  1071.     def element_spec(self, type_def, declarator):
  1072.     """ element_spec: type_def declarator """
  1073.  
  1074.     return (type_def, declarator)
  1075.  
  1076.     def enum_type_header(self, name):
  1077.     """ enum_type: ENUM IDENTIFIER """
  1078.  
  1079.     # Get the container and prefix from the stacks.
  1080.     container = self.__container_stack.get()
  1081.     prefix = self.__prefix_stack.get()
  1082.  
  1083.     # Does the container already contain a definition with this name?
  1084.     enum = container.lookup(name)
  1085.  
  1086.     # If there is *no* definition with this name then we can safely create
  1087.     # a new enumeration.
  1088.     if enum is None:
  1089.         # Currently the version is always "1.0"!
  1090.         version = "1.0"
  1091.  
  1092.         # Generate an interface repository id.
  1093.         ifr_id = self.__create_ifr_id(prefix, name, version)
  1094.  
  1095.         # Create a new enumeration definition in the container.
  1096.         enum = container.create_enum(ifr_id, name, version, [])
  1097.  
  1098.         # If the enumeration is defined at the global scope of the
  1099.         # top-level IDL file then add it to our list of top-level
  1100.         # definitions.
  1101.         if self.__is_a_top_level_definition(enum):
  1102.         self.__top_level_definitions.append(enum)
  1103.  
  1104.     # Otherwise, a definition with this name already exists.
  1105.     else:
  1106.         self.yyerror("Redefinition of name '%s'" % name)
  1107.         raise bison.YYERROR
  1108.  
  1109.     return enum
  1110.  
  1111.     def enum_type_body(self, enum, members):
  1112.     """ enum_type: '{' enumerators '}' """
  1113.  
  1114.     # Get the container and prefix from the stacks.
  1115.     container = self.__container_stack.get()
  1116.     prefix = self.__prefix_stack.get()
  1117.  
  1118.     # Create temporary constant definitions for each member.
  1119.     for i in range(len(members)):
  1120.         # Get the name of the member.
  1121.         name = members[i]
  1122.  
  1123.         # Does the container already contain a definition with this name?
  1124.         constant = container.lookup(name)
  1125.  
  1126.         # If there is *no* definition with this name then we can safely
  1127.         # create a new constant.
  1128.         if constant is None:
  1129.         # Tag the enum member with a distinctive version ;^)
  1130.         version = "Delete Me!"
  1131.  
  1132.         # Generate an interface repository id.
  1133.         ifr_id = self.__create_ifr_id(prefix, name, version)
  1134.  
  1135.         # Create an Enum member instance.
  1136.         any = CORBA.Any(enum._get_type(), Util.EnumMember(name, i))
  1137.  
  1138.         # Create a new constant definition in the container.
  1139.         constant = container.create_constant(ifr_id, name, version,
  1140.                              enum, any)
  1141.  
  1142.             # Add the definition to our list of enumeration members to
  1143.         # be cleaned up at the end.
  1144.         self.__enum_members.append(constant)
  1145.  
  1146.         # Otherwise, a definition with this name already exists.
  1147.         else:
  1148.         self.yyerror("Redefinition of name '%s'" % name)
  1149.         raise bison.YYERROR
  1150.  
  1151.     # Update the enumeration definition.
  1152.     enum._set_members(members)
  1153.  
  1154.     return enum
  1155.  
  1156.     def native_type_dcl(self, identifier):
  1157.     """ type_dcl: NATIVE simple_declarator """
  1158.     
  1159.     self.yywarning('No native types specified in the language mapping')
  1160.     return
  1161.  
  1162.     def sequence_type(self, element_type_def, bound=0):
  1163.     """ sequence_type: SEQUENCE
  1164.                           '<' simple_type_spec ',' positive_int_const '>'
  1165.                           |
  1166.                           SEQUENCE '<' simple_type_spec '>'
  1167.         """
  1168.         return self.__repository.create_sequence(bound, element_type_def)
  1169.  
  1170.     def string_type(self, bound=0):
  1171.     """ string_type: STRING '<' positive_int_const '>'
  1172.                          |
  1173.                          STRING
  1174.         """
  1175.     if bound == 0:
  1176.         definition = self.__repository.get_primitive(CORBA.pk_string)
  1177.  
  1178.     else:
  1179.         definition = self.__repository.create_string(bound)
  1180.  
  1181.     return definition
  1182.  
  1183.     def wide_string_type(self, bound=0):
  1184.     """ wide_string_type: WSTRING '<' positive_int_const '>'
  1185.                               |
  1186.                               WSTRING
  1187.         """
  1188.     self.yywarning("'wstring' not supported by Fnorb runtime")
  1189.     if bound == 0:
  1190.         definition = self.__repository.get_primitive(CORBA.pk_wstring)
  1191.  
  1192.     else:
  1193.         definition = self.__repository.create_wstring(bound)
  1194.  
  1195.     return definition
  1196.  
  1197.     def array_declarator(self, name, dimensions):
  1198.     """ array_declarator: IDENTIFIER fixed_array_size_PLUS """
  1199.  
  1200.     return Declarator.ArrayDeclarator(name, dimensions)
  1201.  
  1202.     def fixed_array_size(self, dimension):
  1203.     """ fixed_array_size: '[' positive_int_const ']' """
  1204.  
  1205.     return dimension
  1206.  
  1207.     def attr_dcl(self, mode, type_def, declarators):
  1208.     """ attr_dcl: readonly_OPT ATTRIBUTE param_type_spec
  1209.                       simple_declarators
  1210.  
  1211.     """
  1212.     # Get the container and prefix from the stacks.
  1213.     container = self.__container_stack.get()
  1214.     prefix = self.__prefix_stack.get()
  1215.  
  1216.     for declarator in declarators:
  1217.         # Get the name of the declarator.
  1218.         name = declarator.name()
  1219.  
  1220.         # Does the container already contain a definition with this name?
  1221.         attribute = container.lookup(name)
  1222.  
  1223.         # If there is *no* definition with this name then we can safely
  1224.         # create a new attribute.
  1225.         if attribute is None:
  1226.         # Currently the version is always "1.0"!
  1227.         version = "1.0"
  1228.  
  1229.         # Generate an interface repository id.
  1230.         ifr_id = self.__create_ifr_id(prefix, name, version)
  1231.  
  1232.         # Create a new attribute definition in the container.
  1233.         attribute = container.create_attribute(ifr_id, name, version,
  1234.                                type_def, mode)
  1235.  
  1236.         # Otherwise, a definition with this name already exists.
  1237.         else:
  1238.         self.yyerror("Redefinition of name '%s'" % name)
  1239.         raise bison.YYERROR
  1240.  
  1241.     return
  1242.  
  1243.     def readonly_OPT_normal(self):
  1244.     """ readonly_OPT: /* empty */ """
  1245.  
  1246.     return CORBA.ATTR_NORMAL
  1247.  
  1248.     def readonly_OPT_readonly(self):
  1249.     """ readonly_OPT: READONLY """
  1250.  
  1251.     return CORBA.ATTR_READONLY
  1252.  
  1253.     def except_dcl_header(self, name):
  1254.     """ EXCEPTION IDENTIFIER """
  1255.     
  1256.     # Get the container and prefix from the stacks.
  1257.     container = self.__container_stack.get()
  1258.     prefix = self.__prefix_stack.get()
  1259.  
  1260.     # Does the container already contain a definition with this name?
  1261.     exception = container.lookup(name)
  1262.  
  1263.     # If there is *no* definition with this name then we can safely create
  1264.     # a new exception.
  1265.     if exception is None:
  1266.         # Currently the version is always "1.0"!
  1267.         version = "1.0"
  1268.  
  1269.         # Generate an interface repository id.
  1270.         ifr_id = self.__create_ifr_id(prefix, name, version)
  1271.  
  1272.         # Create a new exception definition in the container.
  1273.         exception = container.create_exception(ifr_id, name, version, [])
  1274.  
  1275.         # If the exception is defined at the global scope of the top-level
  1276.         # IDL file then add it to our list of top-level definitions.
  1277.         if self.__is_a_top_level_definition(exception):
  1278.         self.__top_level_definitions.append(exception)
  1279.  
  1280.     # Otherwise, a definition with this name already exists.
  1281.     else:
  1282.         self.yyerror("Redefinition of name '%s'" % name)
  1283.         raise bison.YYERROR
  1284.  
  1285.     # Push the exception onto the container stack.
  1286.     self.__container_stack.push(exception)
  1287.  
  1288.     # Push a new prefix onto the prefix stack.
  1289.     self.__prefix_stack.push(self.__create_prefix(prefix, name))    
  1290.  
  1291.     return exception
  1292.  
  1293.     def except_dcl_body(self, exception, members):
  1294.     """ except_dcl: '{' member_STAR '}' """
  1295.     
  1296.     # The same as for structure definitions!
  1297.     self.struct_type_body(exception, members)
  1298.     return
  1299.  
  1300.     def op_dcl_header(self, mode, result_type_def, name):
  1301.     """ op_dcl: op_attribute_OPT op_type_spec IDENTIFER """
  1302.  
  1303.     # Get the container and prefix from the stacks.
  1304.     container = self.__container_stack.get()
  1305.     prefix = self.__prefix_stack.get()
  1306.  
  1307.     # Does the container already contain a definition with this name?
  1308.     operation = container.lookup(name)
  1309.  
  1310.     # If there is *no* definition with this name then we can safely create
  1311.     # a new operation.
  1312.     if operation is None:
  1313.         # Currently the version is always "1.0"!
  1314.         version = "1.0"
  1315.  
  1316.         # Generate an interface repository id.
  1317.         ifr_id = self.__create_ifr_id(prefix, name, version)
  1318.  
  1319.         # Create a new operation definition in the container.
  1320.         operation = container.create_operation(ifr_id, name, version,
  1321.                            result_type_def,
  1322.                            mode,
  1323.                            [], # Parameters.
  1324.                            [], # Exceptions.
  1325.                            []) # Contexts.
  1326.  
  1327.     # Otherwise, a definition with this name already exists.
  1328.     else:
  1329.         self.yyerror("Redefinition of name '%s'" % name)
  1330.         raise bison.YYERROR
  1331.  
  1332.     return operation
  1333.  
  1334.     def op_dcl_body(self, operation, params, exceptions, contexts):
  1335.     """ op_dcl: op_attribute_OPT op_type_spec IDENTIFER """
  1336.  
  1337.     # Make sure that the parameter names are unique.
  1338.     dict = {}
  1339.     for param in params:
  1340.         if dict.has_key(param.name):
  1341.         self.yyerror("Duplicate parameter name '%s'" % param.name)
  1342.         raise bison.YYERROR
  1343.  
  1344.         dict[param.name] = None
  1345.  
  1346.     # Update the operation definition.
  1347.     operation._set_params(params)
  1348.     operation._set_exceptions(exceptions)
  1349.     operation._set_contexts(contexts)
  1350.  
  1351.     return
  1352.  
  1353.     def op_attribute_OPT_empty(self):
  1354.     """ op_attribute_OPT: /* empty */ """
  1355.  
  1356.     return CORBA.OP_NORMAL
  1357.  
  1358.     def op_attribute_OPT_oneway(self):
  1359.     """ op_attribute_OPT: ONEWAY """
  1360.  
  1361.     return CORBA.OP_ONEWAY
  1362.  
  1363.     def op_type_spec_void(self):
  1364.     """ op_type_spec: VOID """
  1365.  
  1366.     return self.__repository.get_primitive(CORBA.pk_void)
  1367.  
  1368.     def parameter_dcls_empty(self):
  1369.     """ parameter_dcls: '(' ')' """
  1370.  
  1371.     return []
  1372.  
  1373.     def param_dcl(self, mode, type_def, declarator):
  1374.     """ param_dcl: param_attribute param_type_spec simple_declarator """
  1375.  
  1376.     return CORBA.ParameterDescription(declarator.name(),
  1377.                       type_def._get_type(),
  1378.                       type_def,
  1379.                       mode)
  1380.     def param_attribute_in(self):
  1381.     """ param_attribute: IN """
  1382.  
  1383.     return CORBA.PARAM_IN
  1384.  
  1385.     def param_attribute_out(self):
  1386.     """ param_attribute: OUT """
  1387.  
  1388.     return CORBA.PARAM_OUT
  1389.  
  1390.     def param_attribute_inout(self):
  1391.     """ param_attribute: INOUT """
  1392.  
  1393.     return CORBA.PARAM_INOUT
  1394.  
  1395.     def raises_expr_OPT_empty(self):
  1396.     """ raises_expr_OPT: /* empty */ """
  1397.  
  1398.     return []
  1399.  
  1400.     def raises_expr(self, scoped_names):
  1401.     """ raises_expr: RAISES '(' scoped_name_CSV_PLUS ')' """
  1402.  
  1403.     # Get the container and prefix from the stacks.
  1404.     container = self.__container_stack.get()
  1405.  
  1406.     # Make sure that all of the names refer to exceptions!
  1407.     exceptions = []
  1408.     for scoped_name in scoped_names:
  1409.         # Lookup the definition referenced by the scoped name.
  1410.         definition = self.__find_scoped_name(container, scoped_name)
  1411.         if definition is None:
  1412.         raise bison.YYERROR
  1413.  
  1414.         # Make sure that it is an exception definition.
  1415.         if definition._get_def_kind() != CORBA.dk_Exception:
  1416.         self.yyerror("'%s' is not an exception" % scoped_name)
  1417.         raise bison.YYERROR
  1418.  
  1419.         exceptions.append(definition)
  1420.  
  1421.     return exceptions
  1422.  
  1423.     def context_expr_OPT_empty(self):
  1424.     """ context_expr_OPT: /* empty */ """
  1425.  
  1426.     return []
  1427.  
  1428.     def context_expr(self, string_literals):
  1429.     """ context_expr: CONTEXT '(' string_literal_CSV_PLUS ')' """
  1430.  
  1431.     # fixme: Fnorb does not support contexts!
  1432.     for string_literal in string_literals:
  1433.         self.yywarning("%s context ignored" % string_literal)
  1434.  
  1435.     return []
  1436.  
  1437.     def fixed_pt_type(self, digits, scale):
  1438.     """ fixed_pt_type: FIXED '<' positive_int_const ',' integer_literal '>'
  1439.  
  1440.         The fixed point type is not yet implemented.
  1441.  
  1442.         """
  1443.     self.yywarning("'fixed' not supported by Fnorb runtime")
  1444.  
  1445.     # 'digits' is a positive integer constant and is returned as a Python
  1446.     # long, and ;scale' is an integer literal which is returned as an
  1447.     # 'Any'.
  1448.     return self.__repository.create_fixed(digits, scale.value())
  1449.  
  1450.     def fixed_pt_const_type(self):
  1451.     """ fixed_pt_const_type: FIXED """
  1452.  
  1453.     self.yywarning("'fixed' constants not supported by Fnorb runtime")
  1454.     return self.__repository.create_fixed(0, 0)
  1455.     #
  1456.     # '#pragma' directives.
  1457.     #
  1458.     def pragma(self, yytext):
  1459.     """ PRAGMA """
  1460.  
  1461.     # Split the text of the directive on spaces.
  1462.     components = string.split(yytext)
  1463.  
  1464.     # Ignore any malformed directives.
  1465.     if len(components) == 3:
  1466.         if components[1] == 'prefix':
  1467.         try:
  1468.             # The prefix must be a quoted string.
  1469.             pragma_prefix = eval(components[2])
  1470.             if type(pragma_prefix) != types.StringType:
  1471.             raise TypeError
  1472.  
  1473.             # Get the current prefix from the stack.
  1474.             prefix = self.__prefix_stack.get()    
  1475.  
  1476.             # Update the 'pragma' portion of the prefix.
  1477.             prefix.set_pragma(pragma_prefix)
  1478.             
  1479.         # Ignore any errors.
  1480.             except:
  1481.             self.yywarning("Malformed #pragma prefix")
  1482.  
  1483.     elif len(components) == 4:
  1484.         if components[1] == 'ID':
  1485.         try:
  1486.             # Get the name of the definition.
  1487.             name = components[2]
  1488.  
  1489.             # The id must be a quoted string.
  1490.             ifr_id = eval(components[3])
  1491.             if type(ifr_id) != types.StringType:
  1492.             raise TypeError
  1493.  
  1494.             # Get the container from the stacks.
  1495.             container = self.__container_stack.get()
  1496.  
  1497.             # Lookup the definition referenced by the scoped name.
  1498.             definition = self.__find_scoped_name(container, name)
  1499.             if definition is None:
  1500.             raise bison.YYERROR
  1501.  
  1502.             # Update the definition's interface repository id.
  1503.             definition._set_id(ifr_id)
  1504.             
  1505.         # Ignore any errors.
  1506.             except:
  1507.             self.yywarning("Malformed #pragma ID")
  1508.  
  1509.         elif components[1] == 'version':
  1510.         try:
  1511.             # Get the name of the definition.
  1512.             name = components[2]
  1513.  
  1514.             # The version is used as a string, but must be in the
  1515.             # format <major>.<minor>
  1516.             version = components[3]
  1517.             if type(eval(version)) != types.FloatType:
  1518.             raise TypeError
  1519.             
  1520.             # Get the container from the stacks.
  1521.             container = self.__container_stack.get()
  1522.  
  1523.             # Lookup the definition referenced by the scoped name.
  1524.             definition = self.__find_scoped_name(container, name)
  1525.             if definition is None:
  1526.             raise bison.YYERROR
  1527.  
  1528.             # Update the definition's version.
  1529.             definition._set_version(version)
  1530.             
  1531.         # Ignore any errors.
  1532.             except:
  1533.             self.yywarning("Malformed #pragma version")
  1534.  
  1535.     return
  1536.  
  1537.     def line_directive(self, yytext):
  1538.     """ Parse line/file pre-processor directives.
  1539.     
  1540.     This method is called from the lexer (see the file 'lexer.l').
  1541.  
  1542.     """
  1543.     line = None
  1544.     file = None
  1545.  
  1546.     # Split the text on spaces.
  1547.     components = string.split(yytext)
  1548.  
  1549.     # If this a '# line' directive.
  1550.     if components[1] == 'line':
  1551.         # e.g. '# line 1'
  1552.         line = eval(components[2])
  1553.         
  1554.         # e.g. '# line 1 "filename.idl"
  1555.         if len(components) >= 4:
  1556.         file = eval(components[3])
  1557.  
  1558.     # Otherwise this is a pre-processor inserted line.
  1559.         else:
  1560.         # e.g. '# 1'
  1561.         line = eval(components[1])
  1562.             
  1563.         # e.g. '# 1 "filename.idl"
  1564.         if len(components) >= 3:
  1565.         file = eval(components[2])
  1566.  
  1567.     # Update the line number.
  1568.     if line is not None:
  1569.         bison.yylineno(line)
  1570.         
  1571.     # Update the file.
  1572.     if file is not None:
  1573.         # Get the prefix stack for this file.
  1574.         try:
  1575.         self.__prefix_stack = self.__prefix_stacks[file]
  1576.  
  1577.         # If there is no prefix stack for this file then create one!
  1578.         except KeyError:
  1579.         # The prefix stack initially contains just an empty prefix.
  1580.         self.__prefix_stack = Stack.Stack()
  1581.         self.__prefix_stack.push(Prefix.Prefix())
  1582.         self.__prefix_stacks[file] = self.__prefix_stack
  1583.  
  1584.         # Update the current filename.
  1585.         self.__current_file = file
  1586.         
  1587.     return
  1588.     #
  1589.     # Generic actions.
  1590.     #
  1591.     def list_empty(self):
  1592.     """ Generic empty list. """
  1593.  
  1594.     return []
  1595.  
  1596.     def list_insert(self, item, list):
  1597.     """ Generic list insert. """
  1598.  
  1599.     if type(item) == types.ListType:
  1600.         list = item + list
  1601.  
  1602.     else:
  1603.         list.insert(0, item)
  1604.  
  1605.     return list
  1606.  
  1607.     def idl_type_scoped_name(self, scoped_name):
  1608.     """ Check that the scoped name references an IDL type definition. """
  1609.  
  1610.     # Get the container from the stack.
  1611.     container = self.__container_stack.get()
  1612.  
  1613.     # Lookup the definition referenced by the scoped name.
  1614.     definition = self.__find_scoped_name(container, scoped_name)
  1615.     if definition is None:
  1616.         raise bison.YYERROR
  1617.  
  1618.     # If it is not an 'IDLType' definition then it is illegal.
  1619.     if not definition._is_a("IDL:omg.org/CORBA/IDLType:1.0"):
  1620.         self.yyerror("'%s' is not a type name" % scoped_name)
  1621.         raise bison.YYERROR
  1622.  
  1623.     return definition
  1624.  
  1625.     #########################################################################
  1626.     # Private interface.
  1627.     #########################################################################
  1628.  
  1629.     def __initialise(self):
  1630.     """ Initialise the various data structures used during parsing. """
  1631.  
  1632.     # The name of the IDL file currently being parsed.
  1633.     self.__current_file = self.__filename
  1634.  
  1635.     # A dictionary of prefix stacks - keyed on filename.
  1636.     self.__prefix_stacks = {} # {Filename: Stack<Prefix>}
  1637.  
  1638.     # The prefix stack initially contains just an empty prefix.
  1639.     self.__prefix_stack = Stack.Stack()
  1640.     self.__prefix_stack.push(Prefix.Prefix())
  1641.     self.__prefix_stacks[self.__filename] = self.__prefix_stack
  1642.  
  1643.     # A list of all definitions at the global scope of the top-level IDL
  1644.     # file.
  1645.     self.__top_level_definitions = []
  1646.  
  1647.     # A dictionary of all interfaces along with the names of their
  1648.     # operations and attributes.
  1649.     self.__interfaces = {} # {RepositoryId: [NamesofOpsAndAttributes]}
  1650.  
  1651.     # A dictionary of forward declared but undefined interfaces.
  1652.     self.__forward_interfaces = {} # {RepositoryId: (InterfaceDef, LineNo)}
  1653.  
  1654.     # A list of the temporary constant definitions created for members of 
  1655.     # enumerations.
  1656.     self.__enum_members = []
  1657.  
  1658.     return
  1659.  
  1660.     def __cleanup(self):
  1661.     """ Cleanup after parsing. """
  1662.  
  1663.     # Get rid of the temporary contant definitions created for members of
  1664.     # enumerations.
  1665.     for enum_member in self.__enum_members:
  1666.         enum_member.destroy()
  1667.  
  1668.     return
  1669.  
  1670.     def __create_prefix(self, prefix, name):
  1671.     """ Create a new prefix. """
  1672.  
  1673.     new_prefix = "%s%s/" % (prefix.get_prefix(), name)
  1674.     return Prefix.Prefix(prefix.get_pragma(), new_prefix)
  1675.  
  1676.     def __create_ifr_id(self, prefix, name, version):
  1677.     """ Create an interface repository id. """
  1678.  
  1679.     return "IDL:%s%s:%s" % (str(prefix), name, version)
  1680.  
  1681.     def __find_scoped_name(self, container, scoped_name):
  1682.     """ Find the definition for the scoped name. """
  1683.  
  1684.     if scoped_name == "TypeCode":
  1685.         definition = self.__repository.get_primitive(CORBA.pk_TypeCode)
  1686.  
  1687.     elif scoped_name == "Principal":
  1688.         definition = self.__repository.get_primitive(CORBA.pk_Principal)
  1689.  
  1690.     else:
  1691.         # If the container is an interface then we look first in
  1692.         # the interface itself, and then recursively through its base
  1693.         # interfaces.
  1694.         if container._get_def_kind() == CORBA.dk_Interface:
  1695.         definition = self.__find_inherited(container, scoped_name)
  1696.  
  1697.         # Otherwise, we start by searching the current container, and then
  1698.         # its enclosing scopes.
  1699.         else:
  1700.         definition = container.lookup(scoped_name)
  1701.  
  1702.         # While the definition is not found.
  1703.         while definition is None:
  1704.         # Is the container also 'contained'?
  1705.         if container._is_a("IDL:omg.org/CORBA/Contained:1.0"):
  1706.             # Get the container's container ;^)
  1707.             container = container._get_defined_in()
  1708.  
  1709.             # Look in there!
  1710.             definition = container.lookup(scoped_name)
  1711.  
  1712.         else:
  1713.             self.yyerror("Undeclared scoped name '%s'" % scoped_name)
  1714.             break
  1715.  
  1716.     return definition
  1717.  
  1718.     def __find_inherited(self, container, scoped_name):
  1719.     """ Find the definition for the scoped name. """
  1720.  
  1721.     # Lookup the name in the interface first.
  1722.     definition = container.lookup(scoped_name)
  1723.     if definition is None:
  1724.         # Look through all base interfaces.
  1725.         for base in container._get_base_interfaces():
  1726.         # Lookup the name in the base's base interfaces!
  1727.         definition = self.__find_inherited(base, scoped_name)
  1728.         if definition is not None:
  1729.             break
  1730.  
  1731.     return definition
  1732.  
  1733.     def __create_array(self, type_def, dims):
  1734.     """ Create an array type definition. """
  1735.  
  1736.     # Single dimension
  1737.     if len(dims) == 1:
  1738.         array_type_def = self.__repository.create_array(dims[0], type_def)
  1739.  
  1740.     # Multi-dimension
  1741.     else:
  1742.         # Create the 'slice' type.
  1743.         slice_type_def = self.__repository.create_array(dims[-1], type_def)
  1744.  
  1745.         # Recursively create the array type.
  1746.         array_type_def = self.__create_array(slice_type_def, dims[:-1])
  1747.  
  1748.     return array_type_def
  1749.  
  1750.     def __is_a_top_level_definition(self, definition):
  1751.     """ Is the defn at the global scope of the top-level IDL file? """
  1752.  
  1753.     if self.__current_file == self.__filename \
  1754.        and definition._get_defined_in() == self.__repository:
  1755.         result = 1
  1756.     
  1757.     else:
  1758.         # Include any global scope definitions that are not modules!
  1759.         if definition._get_defined_in() == self.__repository \
  1760.            and definition._get_def_kind() != CORBA.dk_Module:
  1761.         result = 1
  1762.  
  1763.         else:
  1764.         result = 0
  1765.  
  1766.     return result
  1767.  
  1768.     # Integer typecode kinds.
  1769.     __TK_INT = [CORBA.tk_short,
  1770.         CORBA.tk_long,
  1771.         CORBA.tk_longlong,
  1772.         CORBA.tk_ushort,
  1773.         CORBA.tk_ulong,
  1774.         CORBA.tk_ulonglong]
  1775.  
  1776.     # Floating point typecode kinds.
  1777.     __TK_FP = [CORBA.tk_float,
  1778.            CORBA.tk_double,
  1779.            CORBA.tk_longdouble]
  1780.  
  1781.     def __check_constant_type(self, type_def, any):
  1782.     """ Make sure that the value is of the specified type. """
  1783.  
  1784.     # Get the typecode 'kind's.
  1785.     type_def_kind = type_def._get_type().kind()
  1786.     any_kind = any.typecode().kind()
  1787.  
  1788.     if type_def_kind in IDLParser.__TK_INT \
  1789.        and any_kind in IDLParser.__TK_INT:
  1790.         result = 1
  1791.  
  1792.     elif type_def_kind in IDLParser.__TK_FP \
  1793.          and any_kind in IDLParser.__TK_FP:
  1794.         result = 1
  1795.  
  1796.     elif type_def_kind == any_kind:
  1797.         result = 1
  1798.  
  1799.     else:
  1800.         result = 0
  1801.  
  1802.     return result
  1803.  
  1804.     def __check_limits(self, type_def, any):
  1805.     """ Make sure that the value is within the limits of the type. """
  1806.  
  1807.     # Get the typecode 'kind'.
  1808.     type_def_kind = type_def._get_type().kind()
  1809.  
  1810.     # Get the value out of the any.
  1811.     value = any.value()
  1812.  
  1813.     if type_def_kind == CORBA.tk_short:
  1814.         if value < Limits.MIN_SHORT or value > Limits.MAX_SHORT:
  1815.         result = 0
  1816.         
  1817.         else:
  1818.         result = 1
  1819.         value = int(value)
  1820.  
  1821.     elif type_def_kind == CORBA.tk_ushort:
  1822.         if value < Limits.MIN_USHORT or value > Limits.MAX_USHORT:
  1823.         result = 0
  1824.  
  1825.         else:
  1826.         result = 1
  1827.         value = int(value)
  1828.  
  1829.     elif type_def_kind == CORBA.tk_long:
  1830.         if value < Limits.MIN_LONG or value > Limits.MAX_LONG:
  1831.         result = 0
  1832.  
  1833.         else:
  1834.         result = 1
  1835.         value = int(value)
  1836.  
  1837.     elif type_def_kind == CORBA.tk_ulong:
  1838.         if value < Limits.MIN_ULONG or value > Limits.MAX_ULONG:
  1839.         result = 0
  1840.  
  1841.         else:
  1842.         result = 1
  1843.  
  1844.     elif type_def_kind == CORBA.tk_longlong:
  1845.         if value < Limits.MIN_LONGLONG or value > Limits.MAX_LONGLONG:
  1846.         result = 0
  1847.  
  1848.         else:
  1849.         result = 1
  1850.  
  1851.     elif type_def_kind == CORBA.tk_ulonglong:
  1852.         if value < Limits.MIN_ULONGLONG or value > Limits.MAX_ULONGLONG:
  1853.         result = 0
  1854.  
  1855.         else:
  1856.         result = 1
  1857.         
  1858.     # fixme: This should not be here!!!
  1859.     elif type_def_kind == CORBA.tk_fixed:
  1860.         any_typecode = any.typecode()
  1861.         type_def._set_digits(any_typecode.fixed_digits())
  1862.         type_def._set_scale(any_typecode.fixed_scale())
  1863.  
  1864.         result = 1
  1865.  
  1866.     else:
  1867.         result = 1
  1868.  
  1869.     return (result, value)
  1870.  
  1871.     def __check_label_type(self, type_def, any):
  1872.     """ Make sure that the value is of the specified type. """
  1873.  
  1874.     # Get the typecode 'kind's.
  1875.     type_def_kind = type_def._get_type().kind()
  1876.     any_kind = any.typecode().kind()
  1877.  
  1878.     if type_def_kind in IDLParser.__TK_INT \
  1879.        and any_kind in IDLParser.__TK_INT:
  1880.         result = 1
  1881.  
  1882.     elif type_def_kind == any_kind:
  1883.         # If the union is switched on an enumeration then make sure that
  1884.         # the value is a valid element of the same enumeration!
  1885.         if type_def_kind == CORBA.tk_enum:
  1886.         if type_def._get_type().id() == any.typecode().id():
  1887.             result = 1
  1888.  
  1889.         else:
  1890.             result = 0
  1891.         else:
  1892.         result = 1
  1893.  
  1894.     else:
  1895.         result = 0
  1896.  
  1897.     return result
  1898.  
  1899.     def __check_forward_interfaces(self):
  1900.     """ Make sure that all forward declared interfaces were defined. """
  1901.  
  1902.     if len(self.__forward_interfaces) > 0:
  1903.         for (interface, yylineno) in self.__forward_interfaces.values():
  1904.         # Set the line number for error reporting.
  1905.         bison.yylineno(yylineno)
  1906.  
  1907.         # Report the error.
  1908.         self.yyerror("Interface '%s' declared but not defined" % \
  1909.                  interface._get_name())
  1910.         
  1911.         raise bison.YYERROR
  1912.  
  1913.     return
  1914.  
  1915.     def __get_inherited_operations(self, interface, visited):
  1916.     """ Get all operations and attributes inherited by an interface. """
  1917.  
  1918.     names = []
  1919.     for base in interface._get_base_interfaces():
  1920.         # Get the interface repository id of the interface.
  1921.         ifr_id = base._get_id()
  1922.         
  1923.         # Only include the operations and attributes for the interface
  1924.         # once!
  1925.         if ifr_id not in visited:
  1926.         # Add the interface's operations and attributes to the list.
  1927.         names = names + self.__interfaces[ifr_id]
  1928.  
  1929.         # Add the interface repository id of the interface to the list
  1930.         # of those already visited.
  1931.         visited.append(ifr_id)
  1932.  
  1933.         # Do it recursively!
  1934.         names = names + self.__get_inherited_operations(base, visited)
  1935.  
  1936.     # Check for duplicates!
  1937.     tmp = {}
  1938.     for name in names:
  1939.         if tmp.has_key(name):
  1940.         self.yyerror("Overloaded operation/attribute '%s'" % name)
  1941.         raise bison.YYERROR
  1942.  
  1943.         else:
  1944.         tmp[name] = None
  1945.  
  1946.     return names
  1947.  
  1948.     def __unwind_typedef_chain(self, definition):
  1949.     """ Unwind any 'typedef' chain! """
  1950.  
  1951.     # fixme: Which will it be? dk_Typedef or dk_Alias?!?!?!?!?! My bet is
  1952.     # on dk_Alias!
  1953.     while definition._get_def_kind() == CORBA.dk_Typedef \
  1954.           or definition._get_def_kind() == CORBA.dk_Alias:
  1955.         definition = definition._get_original_type_def()
  1956.  
  1957.     return definition
  1958.  
  1959.     def __is_recursive_member(self, type_def):
  1960.     """ Determine whether or not this is a recursive member. """
  1961.  
  1962.     if type_def._get_def_kind() == CORBA.dk_Sequence:
  1963.         element_type_def = type_def._get_element_type_def()
  1964.         if element_type_def._get_def_kind() == CORBA.dk_Struct or \
  1965.            element_type_def._get_def_kind() == CORBA.dk_Union:
  1966.         if element_type_def._get_version() == "wip":
  1967.             return 1
  1968.             
  1969.     return 0
  1970.  
  1971.     def __get_recursion_depth(self, type_def, ifr_id, depth=1):
  1972.     """ Find the depth (or 'offset') of a recursive type. """
  1973.  
  1974.     if type_def._get_id() == ifr_id:
  1975.         return depth
  1976.  
  1977.     else:
  1978.         return self.__get_recursion_depth(type_def._get_defined_in(),
  1979.                           ifr_id,
  1980.                           depth + 1)
  1981.     return
  1982.  
  1983. #############################################################################
  1984.