main.py

编译工具

                             
    stream.out(template.builddesc_member,
               guard_name = guard_name,
               fqname = fqname,
               num_members = str(num_members),
               private_prefix = prefix,
               cases = str(cases))
    
    return



def visitStruct(node):
    startingNode(node)

    scopedName = id.Name(node.scopedName())
    guard_name = scopedName.guard()
    fqname = scopedName.fullyQualify()
    prefix = config.state['Private Prefix']
    
    # if it's recursive, stick in a forward declaration
    if node.recursive():
        stream.out("// struct is recursive")
        forward(node)

    # output code for constructed members (eg nested structs)
    for m in node.members():
        memberType = m.memberType()
        if m.constrType():
            memberType.decl().accept(self)

    def member_desc(node = node, stream = stream, fqname = fqname,
                    guard_name = guard_name, prefix = prefix):
        visitMembers(node, stream, fqname, guard_name, prefix,
                     static = "static")
        
    stream.out(template.struct,
               fqname = fqname, guard_name = guard_name,
               member_desc = member_desc,
               private_prefix = prefix)

    # <---
    required_symbols = [ prefix + "_buildDesc_c" + guard_name ]
    generated_symbols = [ prefix + "_delete_" + guard_name ]
    assertDefined(required_symbols)
    defineSymbols(generated_symbols)
    # <---
    
    finishingNode()

def visitStructForward(node):
    startingNode(node)

    scopedName = id.Name(node.scopedName())
    guard_name = scopedName.guard()
    fqname = scopedName.fullyQualify()
    prefix = config.state['Private Prefix']

    stream.out("// forward declaration")
    forward(node)

    required_symbols = [ prefix + "_buildDesc_c" + guard_name ]
    generated_symbols = [ prefix + "_delete_" + guard_name ]
    assertDefined(required_symbols)
    defineSymbols(generated_symbols)

    finishingNode()



def visitTypedef(node):
    startingNode(node)
    
    aliasType = types.Type(node.aliasType())
    deref_aliasType = aliasType.deref()
    type_dims = aliasType.dims()
    prefix = config.state['Private Prefix']

    if node.constrType():
        aliasType.type().decl().accept(self)

    # we don't need to recurse on the aliased type here because
    # the code generated is only used from the code generated from
    # an array declarator.
    # visitArray() would take care of it for us.
    # Don't do this:
    #   aliasType.accept(self)

    alias_cname = mangler.canonTypeName(aliasType)
    alias_tyname = aliasType.base()
    deref_alias_tyname = deref_aliasType.base()
    if deref_aliasType.objref():
        alias_tyname = aliasType.objRefTemplate("Member")
        deref_alias_tyname = deref_aliasType.objRefTemplate("Member")
    elif deref_aliasType.string():
        alias_tyname = "CORBA::String_member"
    elif deref_aliasType.wstring():
        alias_tyname = "CORBA::WString_member"

    for declarator in node.declarators():
        first_declarator = declarator == node.declarators()[0]
        
        decl_dims = declarator.sizes()
        full_dims = decl_dims + type_dims
        is_array = full_dims != []
        is_array_declarator = decl_dims != []
        scopedName = id.Name(declarator.scopedName())
        fqname = scopedName.fullyQualify()
        tc_name = scopedName.prefix("_tc_").fullyQualify()
        guard_name = scopedName.guard()

        decl_cname = mangler.canonTypeName(aliasType, declarator)

        if is_array_declarator:
            defineSymbols([ prefix + "_delete_" + guard_name ])
            stream.out(template.typedef_array_decl_delete,
                       fqname = fqname, guard_name = guard_name,
                       private_prefix = prefix)

            visitArray(aliasType, declarator)

            dims_str   = map(str, full_dims)
            dims_index = map(lambda x:"[" + x + "]", dims_str)
            dims_tail_index = dims_index[1:]
            tail_dims = string.join(dims_tail_index, "")

            argtype = deref_alias_tyname
            if deref_aliasType.sequence():
                argtype = deref_aliasType.sequenceTemplate()
            if deref_aliasType.string():
                argtype = "CORBA::String_member"
            elif deref_aliasType.wstring():
                argtype = "CORBA::WString_member"
            elif deref_aliasType.typecode():
                argtype = "CORBA::TypeCode_member"
                
            assertDefined([ prefix + "_buildDesc" + decl_cname ])
            stream.out(template.typedef_array_decl_oper,
                       fqname = fqname,
                       decl_cname = decl_cname,
                       type = alias_tyname,
                       dtype = argtype,
                       tail_dims = tail_dims,
                       private_prefix = config.state['Private Prefix'],
                       tcname = tc_name,
                       guard_name = guard_name)

        # --- sequences
        if not is_array_declarator and aliasType.sequence():

            if first_declarator:
                deref_aliasType.type().accept(self)

            stream.out(template.typedef_sequence_oper,
                       fqname = fqname,
                       tcname = tc_name,
                       decl_cname = decl_cname,
                       private_prefix = config.state['Private Prefix'],
                       guard_name = guard_name)

    finishingNode()


def visitUnion(node):
    startingNode(node)
    
    scopedName = id.Name(node.scopedName())
    guard_name = scopedName.guard()
    fqname = scopedName.fullyQualify()
    switchType = types.Type(node.switchType())
    deref_switchType = switchType.deref()
    discrim_cname = mangler.canonTypeName(switchType)
    discrim_type = deref_switchType.base()

    isExhaustive = ast.exhaustiveMatch(switchType,ast.allCaseLabelValues(node))

    prefix = config.state['Private Prefix']

    # grab the default case if it exists
    default_case = None
    for c in node.cases():
        for l in c.labels():
            if l.default():
                default_case = c
                break

    # if it's recursive, stick in a forward declaration
    if (node.recursive()):
        stream.out("// forward declaration because union is recursive")
        forward(node)

    # this may need an extern
    node.switchType().accept(self)
    
    # constructed types
    if node.constrType():
        node.switchType().decl().accept(self)
    for n in node.cases():
        if n.constrType():
            n.caseType().decl().accept(self)

    required_symbols = []
            
    switch = output.StringStream()
    if default_case:
        default_decl = default_case.declarator()
        default_type = types.Type(default_case.caseType())
        default_dims = default_type.dims()
        decl_dims = default_decl.sizes()
        full_dims = decl_dims + default_dims
    
        default_is_array = full_dims != []
        mem_cname = mangler.canonTypeName(default_type, default_decl)
        default_decl_name = id.Name(default_decl.scopedName())
        mem_name = default_decl_name.simple()
        thing = "_u->_pd_" + mem_name
        if default_is_array:
            thing = docast(default_type, default_decl, thing)

        required_symbols.append(prefix + "_buildDesc" + mem_cname)
        
        switch.out("""\
if( _u->_pd__default ) {
  @private_prefix@_buildDesc@mem_cname@(_newdesc, @thing@);
} else {""",
                   mem_cname = mem_cname,
                   private_prefix = prefix,
                   thing = thing)
        switch.inc_indent()

    # handle the main cases
    switch.out("""\
switch( _u->_pd__d ) {""")

    # deal with types
    for c in node.cases():
        caseType = types.Type(c.caseType())
        caseType.type().accept(self)
        
        declarator = c.declarator()
        d_sizes = declarator.sizes()
        is_array_declarator = d_sizes != []
        if is_array_declarator:
            visitArray(caseType, declarator)
                
        deref_caseType = caseType.deref()
        type_cname = mangler.canonTypeName(caseType, declarator)
        type_name = caseType.base()
        deref_type_name = deref_caseType.base()
        mem_name = id.Name(c.declarator().scopedName()).simple()
        case_dims = caseType.dims()
        full_dims = d_sizes + case_dims
        
        is_array = full_dims != []
        is_array_declarator = declarator.sizes() != []
        union_member = "_u->_pd_" + mem_name
        cast = union_member
        if is_array:
            cast = docast(caseType, declarator, cast)
            
        for l in c.labels():
            if l.default():
                continue

            label = switchType.literal(l.value())
            required_symbols.append(prefix + "_buildDesc" + type_cname)
            switch.out("""\
case @label@:
  @private_prefix@_buildDesc@type_cname@(_newdesc, @cast@);
  break;""", label = label, type_cname = type_cname, cast = cast,
                       private_prefix = prefix)
            switch.dec_indent()

    if not isExhaustive:
        switch.out("""\
default: return 0;""")
    switch.dec_indent()
    switch.out("""\
}""")
    if default_case:
        switch.out("""\
}""")
        
    assertDefined(required_symbols) # needed by the switch

    stream.out(template.union_tcParser,
               guard_name = guard_name,
               discrim_cname = discrim_cname,
               discrim_type = discrim_type,
               switch = str(switch),
               private_prefix = prefix,
               fqname = fqname)

    generated_symbols = [ prefix + "_buildDesc_c" + guard_name,
                          prefix + "_delete_" + guard_name ]
    defineSymbols(generated_symbols)
    
    stream.out(template.union,
               guard_name = guard_name, fqname = fqname,
               private_prefix = prefix)
               

    finishingNode()

def visitUnionForward(node):
    startingNode(node)

    scopedName = id.Name(node.scopedName())
    guard_name = scopedName.guard()
    fqname = scopedName.fullyQualify()
    prefix = config.state['Private Prefix']

    stream.out("// forward declaration")
    forward(node)

    required_symbols = [ prefix + "_buildDesc_c" + guard_name ]
    generated_symbols = [ prefix + "_delete_" + guard_name ]
    assertDefined(required_symbols)
    defineSymbols(generated_symbols)

    finishingNode()


def visitForward(node):
    scopedName = id.Name(node.scopedName())
    guard_name = scopedName.guard()
    prefix = config.state['Private Prefix']

    symbol = prefix + "_buildDesc_c" + guard_name
    if not isDefined(symbol):
        stream.out("// forward declaration of interface")
        interface_type = types.Type(idltype.Declared(node, node.scopedName(),
                                          idltype.tk_objref,0))
        mem_name = interface_type.objRefTemplate("tcDesc_arg")

        forward(node, mem_name)


def visitConst(node):
    pass
def visitDeclarator(node):
    pass
def visitMember(node):
    pass

def visitException(node):
    startingNode(node)
    
    scopedName = id.Name(node.scopedName())
    guard_name = scopedName.guard()
    fqname = scopedName.fullyQualify()
    prefix = config.state['Private Prefix']

    for m in node.members():
        memberType = m.memberType()
        if m.constrType():
            memberType.decl().accept(self)


    visitMembers(node, stream, fqname, guard_name, prefix)
    
    required_symbols = [ prefix + "_buildDesc_c" + guard_name ]
    generated_symbols = [ prefix + "_delete_" + guard_name ]
    assertDefined(required_symbols)
    defineSymbols(generated_symbols)

    stream.out(template.exception,
               guard_name = guard_name, fqname = fqname,
               private_prefix = config.state['Private Prefix'])


    finishingNode()