home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / fnb101.zip / Lib / site-packages / Fnorb / compiler / SkelGenerator.py < prev    next >
Encoding:
Python Source  |  1999-06-28  |  13.2 KB  |  410 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/compiler/RCS/SkelGenerator.py,v $
  31. # Version:      @(#)$RCSfile: SkelGenerator.py,v $ $Revision: 1.7 $
  32. #
  33. #############################################################################
  34. """ Python skeleton generator for CORBA IDL. """
  35.  
  36.  
  37. # Standard/built-in modules.
  38. import string
  39.  
  40. # Fnorb modules.
  41. from Fnorb.orb import CORBA, Util
  42.  
  43. # Compiler modules.
  44. import CodeGenerator
  45.  
  46.  
  47. # Prefix for skeleton methods,
  48. SKEL_PREFIX = '_skel_'
  49.  
  50.  
  51. class SkelGenerator(CodeGenerator.CodeGenerator):
  52.     """ Python skeleton generator for CORBA IDL. """
  53.  
  54.     #########################################################################
  55.     # CodeGenerator protected interface.
  56.     #########################################################################
  57.  
  58.     def _generate_attribute(self, context, file, ifr_object, indent):
  59.     """ Generate Python code for an IDL attribute. """
  60.  
  61.     # Get the description of the attribute.
  62.     description = ifr_object.describe()
  63.     attribute_desc = description.value.value()
  64.  
  65.         #####################################################################
  66.     # Accessor.
  67.         #####################################################################
  68.  
  69.     # Method header.
  70.     file.write(self._indent(indent))
  71.     file.write('def %s_get_%s' % (SKEL_PREFIX, attribute_desc.name))
  72.     file.write('(self, server_request):\n')
  73.  
  74.     # Indent.
  75.     indent = indent + 1
  76.  
  77.     # Documentation string.
  78.     file.write(self._indent(indent))
  79.     file.write('""" Attribute: %s """\n\n' % attribute_desc.id)
  80.  
  81.     # Create the output typecode.
  82.     file.write(self._indent(indent))
  83.     file.write('# Typecode for the attribute value.\n')
  84.     file.write(self._indent(indent))
  85.     file.write('outputs = []\n')
  86.     file.write(self._indent(indent))
  87.     file.write('outputs.append(')
  88.     file.write(self._get_typecode(attribute_desc.type))
  89.     file.write(')\n\n')
  90.  
  91.     # Boiler plate.
  92.     file.write(self._indent(indent))
  93.     file.write('# Initialise the server request object.\n')
  94.     file.write(self._indent(indent))
  95.     file.write('server_request.initialise([], outputs, [])\n\n')
  96.  
  97.     # Invoke the operation on the implementation.
  98.     file.write(self._indent(indent))
  99.     file.write('# Invoke the implementation.\n')
  100.     file.write(self._indent(indent))
  101.     file.write('results = self._get_%s()\n\n' % attribute_desc.name)
  102.  
  103.     file.write(self._indent(indent))
  104.     file.write('# Create the reply.\n')
  105.     file.write(self._indent(indent))
  106.     file.write('server_request.results(results)\n\n')
  107.  
  108.     file.write(self._indent(indent))
  109.     file.write('return\n\n')
  110.  
  111.     # Outdent.
  112.     indent = indent - 1
  113.  
  114.         #####################################################################
  115.     # Modifier (unless the attribute is read only ;^).
  116.         #####################################################################
  117.  
  118.     if attribute_desc.mode != CORBA.ATTR_READONLY:
  119.         # Method header.
  120.         file.write(self._indent(indent))
  121.         file.write('def %s_set_%s' % (SKEL_PREFIX, attribute_desc.name))
  122.         file.write('(self, server_request):\n')
  123.  
  124.         # Indent.
  125.         indent = indent + 1
  126.  
  127.         # Documentation string.
  128.         file.write(self._indent(indent))
  129.         file.write('""" Attribute: %s """\n\n' % attribute_desc.id)
  130.  
  131.         # Create the input typecode.
  132.         file.write(self._indent(indent))
  133.         file.write("# Typecode for the attribute value.\n")
  134.         file.write(self._indent(indent))
  135.         file.write('inputs = []\n')
  136.  
  137.         file.write(self._indent(indent))
  138.         file.write('inputs.append(')
  139.         file.write(self._get_typecode(attribute_desc.type))
  140.         file.write(')\n\n')
  141.  
  142.         # Boiler plate.
  143.         file.write(self._indent(indent))
  144.         file.write('# Initialise the server request object.\n')
  145.         file.write(self._indent(indent))
  146.         file.write('server_request.initialise(inputs, [], [])\n\n')
  147.  
  148.         # Unmarshal the parameter.
  149.         file.write(self._indent(indent))
  150.         file.write('# Unmarshal the attribute value.\n')
  151.         file.write(self._indent(indent))
  152.         file.write('value = server_request.arguments()[0]\n\n')
  153.  
  154.         # Invoke the operation on the implementation.
  155.         file.write(self._indent(indent))
  156.         file.write('# Invoke the implementation.\n')
  157.         file.write(self._indent(indent))
  158.         file.write('results = self._set_%s(value)' % attribute_desc.name)
  159.         file.write('\n\n')
  160.  
  161.         file.write(self._indent(indent))
  162.         file.write('# Create the reply.\n')
  163.         file.write(self._indent(indent))
  164.         file.write('server_request.results(results)\n\n')
  165.  
  166.         file.write(self._indent(indent))
  167.         file.write('return\n\n')
  168.  
  169.     return
  170.  
  171.     def _generate_interface(self, context, file, ifr_object, indent):
  172.     """ Generate Python code to represent an IDL interface. """
  173.  
  174.     # Get the description of the interface.
  175.     description = ifr_object.describe()
  176.     interface_desc = description.value.value()
  177.  
  178.     # Make sure that the interface name is not a Python keyword.
  179.     py_interface_name = Util.python_name(interface_desc.name)
  180.  
  181.     # Get the scoped name of the interface.
  182.     interface_scoped_name =Util.ScopedName(ifr_object._get_absolute_name())
  183.  
  184.     # Fix up any clashes with Python keywords.
  185.     interface_scoped_name.pythonise()
  186.  
  187.     # Base interfaces.
  188.     bases = ['Fnorb.orb.CORBA.Object_skel']
  189.     packages = []
  190.  
  191.     for base in ifr_object._get_base_interfaces():
  192.         # Get the scoped name of the base interface.
  193.         base_scoped_name = Util.ScopedName(base._get_absolute_name())
  194.  
  195.         # Fix up any clashes with Python keywords.
  196.         base_scoped_name.pythonise()
  197.  
  198.         # If the base interface is defined in a different IDL module (ie.
  199.         # in a different Python package).
  200.         if base_scoped_name[:-1] != interface_scoped_name[:-1]:
  201.         # If the base interface is defined at the global scope then
  202.         # add the name of global package.
  203.         if len(base_scoped_name) == 1:
  204.             base_scoped_name.insert(0, context.globals())
  205.  
  206.         # Use the full scoped name in the Python class header.
  207.         base_python_name = base_scoped_name.join('_skel.') + '_skel'
  208.  
  209.         # Add the Python package that the base interface is defined in
  210.         # to the list of packages to import.
  211.         packages.append(base_scoped_name[:-1].join('_skel.') + '_skel')
  212.  
  213.         # Otherwise, the base interface is defined in the same IDL module
  214.         # as the interface itself, so we just use the base interface name
  215.         # in the Python class header.
  216.         else:
  217.         base_python_name = base_scoped_name[-1] + '_skel'
  218.  
  219.         # Add to the list of base classes for the class header.
  220.         bases.append(base_python_name)
  221.  
  222.     # Import base interface packages.
  223.     if len(packages) > 0:
  224.         file.write(self._indent(indent))
  225.         file.write('# Import base interface packages.\n')
  226.         for package in packages:
  227.         file.write(self._indent(indent))
  228.         file.write(context.create_import_statement(package))
  229.         file.write('\n')
  230.  
  231.         file.write('\n')
  232.         
  233.     # Class header.
  234.     file.write(self._indent(indent))
  235.     file.write('class %s_skel' % py_interface_name)
  236.     file.write('(%s):\n' % string.join(bases, ', '))
  237.  
  238.     # Indent.
  239.     indent = indent + 1
  240.  
  241.     # Documentation string.
  242.     file.write(self._indent(indent))
  243.     file.write('""" Interface: %s """\n\n' % interface_desc.id)
  244.  
  245.     # Repository id attribute.
  246.     file.write(self._indent(indent))
  247.     file.write('_FNORB_ID = "%s"\n\n' % interface_desc.id)
  248.  
  249.     # Generate code for every definition contained in the interface
  250.     # (ignoring inherited definitions).
  251.     contents = ifr_object.contents(CORBA.dk_all, 1)
  252.     if len(contents) > 0:
  253.         for contained in contents:
  254.         self.generate(context, file, contained, indent)
  255.  
  256.     # Empty interface.
  257.     else:
  258.         file.write(self._indent(indent))
  259.         file.write('pass\n\n')
  260.  
  261.     return
  262.  
  263.     def _generate_module(self, context, file, ifr_object, indent):
  264.     """ Generate Python code to represent an IDL module. """
  265.  
  266.     # Get the description of the module.
  267.     description = ifr_object.describe()
  268.     module_desc = description.value.value()
  269.  
  270.     # Make sure that the module name is not a Python keyword.
  271.     py_module_name = Util.python_name(module_desc.name)
  272.  
  273.     # Get the scoped name of the module.
  274.     scoped_name = Util.ScopedName(ifr_object._get_absolute_name())
  275.  
  276.     # Fix up any clashes with Python keywords.
  277.     scoped_name.pythonise()
  278.  
  279.     # Make the 'skeleton' package name (by appending '_skel' to each
  280.     # component of the scoped name).
  281.     package = Util.ScopedName(scoped_name.join('_skel::') + '_skel')
  282.  
  283.     # Create a Python package to represent the IDL module.
  284.     file = self._create_package(context, package.join('/'), module_desc.id)
  285.     
  286.      # Generate code for every definition contained in the module.
  287.      for contained in ifr_object.contents(CORBA.dk_all, 0):
  288.          self.generate(context, file, contained, 0)
  289.  
  290.      # End of the package.
  291.      self._end_package(file, indent)
  292.  
  293.     # All done!
  294.     file.close()
  295.  
  296.     return
  297.  
  298.     def _generate_operation(self, context, file, ifr_object, indent):
  299.     """ Generate Python code to represent an IDL operation. """
  300.  
  301.     # Get the description of the operation.
  302.     description = ifr_object.describe()
  303.     operation_desc = description.value.value()
  304.  
  305.     # Make sure that the operation name is not a Python keyword.
  306.     py_operation_name = Util.python_name(operation_desc.name)
  307.  
  308.     # Method header.
  309.     file.write(self._indent(indent))
  310.     file.write('def %s%s' % (SKEL_PREFIX, operation_desc.name))
  311.     file.write('(self, server_request):\n')
  312.  
  313.     # Indent.
  314.     indent = indent + 1
  315.  
  316.     # Documentation string.
  317.     file.write(self._indent(indent))
  318.     file.write('""" Operation: %s """\n\n' % operation_desc.id)
  319.  
  320.     # Create the input typecodes.
  321.     file.write(self._indent(indent))
  322.     file.write("# Typecodes for 'in' and 'inout' parameters.\n")
  323.     file.write(self._indent(indent))
  324.     file.write('inputs = []\n')
  325.  
  326.     no_of_inputs = 0
  327.     for p in operation_desc.parameters:
  328.         if p.mode == CORBA.PARAM_IN or p.mode == CORBA.PARAM_INOUT:
  329.         file.write(self._indent(indent))
  330.         file.write('inputs.append(%s)' % self._get_typecode(p.type))
  331.         file.write('\n')
  332.         no_of_inputs = no_of_inputs + 1
  333.  
  334.     file.write('\n')
  335.         
  336.     # Create the output typecodes.
  337.     file.write(self._indent(indent))
  338.     file.write("# Typecodes for the result, 'inout' and 'out' parameters.")
  339.     file.write('\n')
  340.     file.write(self._indent(indent))
  341.     file.write('outputs = []\n')
  342.  
  343.     # The result.
  344.     if operation_desc.result.kind() != CORBA.tk_void:
  345.         file.write(self._indent(indent))
  346.         file.write('outputs.append(')
  347.         file.write(self._get_typecode(operation_desc.result))
  348.         file.write(')\n')
  349.  
  350.     # 'inout' and 'out' parameters.
  351.     for p in operation_desc.parameters:
  352.         if p.mode == CORBA.PARAM_INOUT or p.mode == CORBA.PARAM_OUT:
  353.         file.write(self._indent(indent))
  354.         file.write('outputs.append(%s)' % self._get_typecode(p.type))
  355.         file.write('\n')
  356.  
  357.     file.write('\n')
  358.  
  359.     # Create the exception typecodes.
  360.     file.write(self._indent(indent))
  361.     file.write("# Typecodes for user exceptions.\n")
  362.     file.write(self._indent(indent))
  363.     file.write('exceptions = []\n')
  364.  
  365.     for ex in operation_desc.exceptions:
  366.         file.write(self._indent(indent))
  367.         file.write('exceptions.append(Fnorb.orb.CORBA.typecode("%s"))\n' \
  368.                % ex.id)
  369.  
  370.     file.write('\n')
  371.  
  372.     # Boiler plate.
  373.     file.write(self._indent(indent))
  374.     file.write('# Initialise the server request object.\n')
  375.     file.write(self._indent(indent))
  376.     file.write('server_request.initialise(inputs, outputs, exceptions)\n')
  377.     file.write('\n')
  378.  
  379.     # Unmarshal all 'in' and 'inout' parameters.
  380.     if no_of_inputs > 0:
  381.         file.write(self._indent(indent))
  382.         file.write('# Unmarshal the arguments to the request.\n')
  383.         file.write(self._indent(indent))
  384.         file.write('arguments = server_request.arguments()\n\n')
  385.  
  386.     else:
  387.         file.write(self._indent(indent))
  388.         file.write('# This operation has no arguments.\n')
  389.         file.write(self._indent(indent))
  390.         file.write('arguments = ()\n\n')
  391.  
  392.     # Invoke the operation on the implementation.
  393.       file.write(self._indent(indent))
  394.     file.write('# Invoke the implementation.\n')
  395.     file.write(self._indent(indent))
  396.     file.write('results = apply(self.%s, arguments)' % py_operation_name)
  397.     file.write('\n\n')
  398.  
  399.     file.write(self._indent(indent))
  400.     file.write('# Create the reply.\n')
  401.     file.write(self._indent(indent))
  402.     file.write('server_request.results(results)\n\n')
  403.  
  404.     file.write(self._indent(indent))
  405.     file.write('return\n\n')
  406.  
  407.     return
  408.  
  409. #############################################################################
  410.