Beispiel #1
0
 def choose(switchType = switchtype,
            values = ast.allCaseLabelValues(node),
            environment = environment):
     switchType = switchType.deref()
     def min_unused(start, used = values):
         x = start
         while x in used:
             x = x + 1
         return x
     kind = switchType.type().kind()
     if switchType.integer():
         (low, high) = ast.integer_type_ranges[kind]
         s = switchType.literal(min_unused(low+1))
         return s
     elif kind == idltype.tk_char:
         all = map(chr, range(0, 255))
     elif kind == idltype.tk_boolean:
         all = [0, 1]
     elif kind == idltype.tk_enum:
         all = switchType.type().decl().enumerators()
     else:
         util.fatalError("Failed to generate a default union " +\
                             "discriminator value")
     possibles = util.minus(all, values)
     return switchType.literal(possibles[0], environment)
Beispiel #2
0
    def visitInterface(self, node):
        self.__allInterfaces.append(node)
        # listed scope and interface name
        dict = self.createDecl('interface')
        self.createInterfaceIdent(dict, node)
        self.createInterfaceFileInfo(dict, node)

        dict['inherits'] = []
        for ihnode in ast.allInherits(node):
            idict = self.createDecl('inherit')
            self.createInterfaceIdent(idict, ihnode)
            self.createInterfaceFileInfo(idict, ihnode)
            dict['inherits'].append(idict)

        env = id.lookup(node)

        allInterfaces = [node]# + ast.allInherits(node)
        allCallables = util.fold( map(lambda x:x.callables(), allInterfaces),
                                  [], lambda x, y: x + y )

        dict['operations'] = []
        dict['attributes'] = []
        for c in allCallables:
            if isinstance(c, idlast.Attribute):
                attrType = types.Type(c.attrType())
                d_attrType = attrType.deref()
                (corba_atype, local_atype, is_primitive) = self.getType(attrType)

                for i in c.identifiers():
                    ident = id.mapID(i)
                    returnType = attrType.op(types.RET)
                    inType = attrType.op(types.IN)

                    adict = createDecl('attribute')
                    cdict = adict['corba']
                    ldict = adict['local']
                    cdict['base_type'] = corba_atype;
                    ldict['base_type'] = local_atype
                    cdict['name'] = ident
                    adict['return'] = self.createReturn(c)
                    adict['arg'] = {}
                    self.createArg(adict['arg'], attrType, False)

                    dict['attributes'].append(adict)
                    if c.readonly():
                        dict['readonly'] = 'yes'
                    dict['attributes'].append(gdict)

            elif isinstance(c, idlast.Operation):
                # operations
                op_dict           = self.createOperation(c)
                op_dict['return'] = self.createReturn(c)
                op_dict['args']   = self.createArgs(c, env)
                dict['operations'].append(op_dict)
            else:
                util.fatalError("Internal error generating interface member")
                raise "No code for interface member: " + repr(c)

#        self.dict['interfaces'].append(dict)
        self.dict['tree'].append(dict)
        return
Beispiel #3
0
def run(tree, args):
    """Entrypoint to the doil backend"""

    global run_before

    if run_before:
        util.fatalError("Sorry, the doil backend cannot process more "
                        "than one IDL file at a time.")
    run_before = 1

    dirname, filename = os.path.split(tree.file())
    basename,ext      = os.path.splitext(filename)
    config.state['Basename']  = basename
    config.state['Directory'] = dirname
    
    process_args(args)

    if config.state['MappingFile'] == '':
        config.state['TypeMapping'] = {}
    else:
        import yaml
        mapping_file = config.state['MappingFile']
        f = open(mapping_file, "r")
        mapping = yaml.load(f.read())
        f.close()
        config.state['TypeMapping'] = mapping


    try:
        # Check the input tree only contains stuff we understand
        support.checkIDL(tree)

        # initialise the handy ast module
        ast.__init__(tree)

        tree.accept(id.WalkTree())
        # Initialise the descriptor generating code
        # currently doil does not use descriptor
        #        descriptor.__init__(tree)
        from omniidl_be.doil import dictbuilder
        dict = dictbuilder.run(tree, config.state)

        if config.state['Interface']:
            from omniidl_be.doil import interface
            interface.generate_interface(dict)
            interface.generate_types(dict)
        if config.state['CORBAServant']:
            from omniidl_be.doil import corba
            corba.generate_servant(dict)
            corba.generate_types(dict)
        if config.state['CORBAAdapter']:
            from omniidl_be.doil import corba
            corba.generate_adapter(dict)
            corba.generate_types(dict)
        if config.state['CORBAProxy']:
            from omniidl_be.doil import corba
            corba.generate_proxy(dict)
            corba.generate_types(dict)
        if config.state['IceSlice']:
            from omniidl_be.doil import ice
            ice.generate_slice(dict)

        if config.state['IceAdapter']:
            from omniidl_be.doil import ice
            ice.generate_adapter(dict)

        if config.state['IceProxy']:
            from omniidl_be.doil import ice
            ice.generate_proxy(dict)

        if config.state['IceServant']:
            from omniidl_be.doil import ice
            ice.generate_servant(dict)

    except AttributeError, e:
        name = e[0]
        unsupported_visitors = map(lambda x:"visit" + x,
                                   AST_unsupported_nodes[:])
        if name in unsupported_visitors:
            util.unsupportedIDL()
            
        util.fatalError("An AttributeError exception was caught")
Beispiel #4
0
def process_args(args):
    for arg in args:
        if arg == "d":
            config.state['Debug']                  = True
        elif arg[:2] == "m=":
            config.state['MappingFile']            = arg[2:]
        elif arg[:2] == "i=":
            config.state['IncludeHeaders'].append(arg[2:])
        # generator options
        elif arg == "implicit":
            config.state['ImplicitInclude']        = True
        elif arg == "interface":
            config.state['Interface']              = True
        elif arg == "corbaservant":
            config.state['CORBAServant']           = True
        elif arg == "corbaadapter":
            config.state['CORBAAdapter']           = True
        elif arg == "corbaproxy":
            config.state['CORBAProxy']             = True
        elif arg == "iceslice":
            config.state['IceSlice']               = True
        elif arg == "iceservant":
            config.state['IceServant']             = True
        elif arg == "iceadapter":
            config.state['IceAdapter']             = True
        elif arg == "iceproxy":
            config.state['IceProxy']               = True
        # for servant
        elif arg[:3] == "ss=":
            config.state['ServantSuffix']          = arg[3:]
        elif arg[:3] == "sp=":
            config.state['ServantPrefix']          = arg[3:]
        elif arg[:4] == "sns=":
            config.state['ServantNs']              = arg[4:].split('::')
        elif arg[:5] == "sdir=":
            config.state['ServantDir']             = arg[5:]
        # for adapter
        elif arg[:3] == "as=":
            config.state['AdapterSuffix']          = arg[3:]
        elif arg[:3] == "ap=":
            config.state['AdapterPrefix']          = arg[3:]
        elif arg[:4] == "ans=":
            config.state['AdapterNs']              = arg[4:].split('::')
        elif arg[:5] == "adir=":
            config.state['AdapterDir']             = arg[5:]
        # for proxy 
        elif arg[:3] == "ps=":
            config.state['ProxySuffix']            = arg[3:]
        elif arg[:3] == "pp=":
            config.state['ProxyPrefix']            = arg[3:]
        elif arg[:4] == "pns=":
            config.state['ProxyNs']                = arg[4:].split('::')
        elif arg[:5] == "pdir=":
            config.state['ProxyDir']               = arg[5:]
        # for interface
        elif arg[:3] == "is=":
            config.state['IfaceSuffix']            = arg[3:]
        elif arg[:3] == "ip=":
            config.state['IfacePrefix']            = arg[3:]
        elif arg[:4] == "ins=":
            config.state['IfaceNs']                = arg[4:].split('::')
        elif arg[:5] == "idir=":
            config.state['IfaceDir']               = arg[5:]
        else:
            util.fatalError("Argument \"" + str(arg) + "\" is unknown")
Beispiel #5
0
            corba.generate_proxy(dict)
            corba.generate_types(dict)
        if config.state['IceSlice']:
            from omniidl_be.doil import ice
            ice.generate_slice(dict)

        if config.state['IceAdapter']:
            from omniidl_be.doil import ice
            ice.generate_adapter(dict)

        if config.state['IceProxy']:
            from omniidl_be.doil import ice
            ice.generate_proxy(dict)

        if config.state['IceServant']:
            from omniidl_be.doil import ice
            ice.generate_servant(dict)

    except AttributeError, e:
        name = e[0]
        unsupported_visitors = map(lambda x:"visit" + x,
                                   AST_unsupported_nodes[:])
        if name in unsupported_visitors:
            util.unsupportedIDL()
            
        util.fatalError("An AttributeError exception was caught")
    except SystemExit, e:
        raise e
    except:
        util.fatalError("An internal exception was caught")