main.py

来自「编译工具」· Python 代码 · 共 1,130 行 · 第 1/3 页

    if ast.shouldGenerateCodeForDecl(decl) \
       and not isRecursive(decl) and not type.typedef():
        # types declared in the same file will be handled
        #   unless type is recursive -> forward declaration required
        #   unless type is an alias in this file to something in another file
        return

    if type.typedef():
        if type.type().decl().sizes() != []:
            visitArray(types.Type(type.type().decl().alias().aliasType()),
                       type.type().decl())
        else:
            type.type().decl().alias().aliasType().accept(self)
        return

    mem_name = None
    d_type = type.deref()
    if d_type.objref():
        mem_name = d_type.objRefTemplate("tcDesc_arg")
    
    # make an extern/ forward declaration
    if isRecursive(decl):
        forward(decl, mem_name)
        return
    external(d_type.type().decl(), mem_name)

def visitStringType(type):
    bound = type.bound()
    if bound != 0:
        prefix = config.state['Private Prefix']
        n = str(bound)
        # <---
        generated_symbol = prefix + "_buildDesc_c" + n + "string"
        if isDefined(generated_symbol):
            return
        required_symbols  = [ prefix + "_buildDesc_c" + "string" ]
        defineSymbols([ generated_symbol ])
        assertDefined(required_symbols)
        # <---
        stream.out(template.bdesc_string, n = n,
                   private_prefix = prefix)
        

def visitWStringType(type):
    bound = type.bound()
    if bound != 0:
        prefix = config.state['Private Prefix']
        n = str(bound)
        # <---
        generated_symbol = prefix + "_buildDesc_c" + n + "wstring"
        if isDefined(generated_symbol):
            return
        required_symbols  = [ prefix + "_buildDesc_c" + "wstring" ]
        defineSymbols([ generated_symbol ])
        assertDefined(required_symbols)
        # <---
        stream.out(template.bdesc_wstring, n = n,
                   private_prefix = prefix)
        
def visitFixedType(type):
    prefix = config.state['Private Prefix']
    digits = str(type.digits())
    scale  = str(type.scale())
    generated_symbol = prefix + "_buildDesc_c%s_%sfixed" % (digits, scale)
    if isDefined(generated_symbol):
        return
    required_symbols = [ prefix + "_buildDesc_cfixed" ]
    defineSymbols([ generated_symbol ])
    assertDefined(required_symbols)
    stream.out(template.bdesc_fixed, digits=digits, scale=scale,
               private_prefix = prefix)

def visitSequenceType(type):
    seqType = types.Type(type.seqType())
    d_seqType = seqType.deref()

    seqType_cname = mangler.canonTypeName(seqType.deref(keep_dims = 1))
    sequence_template = types.Type(type).sequenceTemplate()
    d_type = types.Type(type).deref()
    memberType_cname = mangler.canonTypeName(d_type)

    seqType_dims = seqType.dims()
    is_array = seqType_dims != []

    # check if the sequence is recursive
    is_recursive = isinstance(seqType.type(), idltype.Declared) and \
                   isRecursive(seqType.type().decl())

    seqType.type().accept(self)

    # something very strange happens here with strings and casting
    sequence_desc = "((" + sequence_template + "*)_desc->opq_seq)"
    thing = "(*" + sequence_desc + ")[_index]"
    if is_array:
        thing = docast(seqType, None, thing)

    elementDesc = output.StringStream()
    prefix = config.state['Private Prefix']
    # djr and jnw's "Super-Hacky Optimisation"
    # (amended by dpg1 to be even more hacky, since char/wchar now don't work)
    if isinstance(d_seqType.type(), idltype.Base) and \
       not d_seqType.variable() and \
       not d_seqType.type().kind() in [idltype.tk_char, idltype.tk_wchar] and \
       not is_array:
        elementDesc.out(template.sequence_elementDesc_contiguous,
                        sequence = sequence_desc)
    else:
        # <---
        required_symbols = [ prefix + "_buildDesc" + seqType_cname ]
        assertDefined(required_symbols)
        # <---
        elementDesc.out(template.sequence_elementDesc_noncontiguous,
                        private_prefix = prefix,
                        thing_cname = seqType_cname,
                        thing = thing)

    # <---
    cname = memberType_cname
    # this is the #ifdef guard
    generated_symbol = prefix + "_tcParser_buildDesc" + cname
    if isDefined(generated_symbol):
        return
    generated_symbols = [ generated_symbol,
                          prefix + "_buildDesc" + cname,
                          prefix + "_tcParser_setElementCount" + cname,
                          prefix + "_tcParser_getElementCount" + cname,
                          prefix + "_tcParser_getElementDesc" + cname ]
    defineSymbols(generated_symbols)
    # <---
    stream.out(template.anon_sequence,
               cname = memberType_cname, thing_cname = seqType_cname,
               sequence_template = sequence_template,
               elementDesc = str(elementDesc),
               private_prefix = config.state['Private Prefix'])

def canonDims(d):
    canon = map(lambda x:"_a" + str(x), d)
    return string.join(canon, "")


# We want to treat anonymous arrays (inside structures) the same as typedef
# generated ones. However the AST.Declarator node does not have the type
# of the declarator, or a pointer to its declaration _unless_ its a typedef
# alias. So this is outside the normal tree walking pattern.
def visitArray(type, declarator):
    d_dims = declarator.sizes()
    d_scopedName = id.Name(declarator.scopedName())
    d_cname = mangler.canonTypeName(type, declarator)

    deref_type = type.deref()
    deref_kd_type = type.deref(keep_dims = 1)
    type_dims = type.dims()
    full_dims = d_dims + type_dims

    type.type().accept(self)

    # recursively ensure that dependent type info is available
    # (if other typedef dimensions are in a different file)
    if deref_kd_type.typedef():
        # must be an array with dimensions
        decl = deref_kd_type.type().decl()
        visitArray(types.Type(decl.alias().aliasType()), decl)

    fqname = d_scopedName.fullyQualify()
    tc_name = d_scopedName.prefix("_tc_").fullyQualify()
    guard_name = d_scopedName.guard()

    # problem with sequences as always
    # Probably should look into derefKeepDims here
    if deref_type.sequence() and type.typedef():
        alias = type.type().decl().alias()
        alias_cname = mangler.canonTypeName(types.Type(alias.aliasType()))
    else:
        alias_cname = mangler.canonTypeName(deref_type)
    alias_tyname = type.member()

    if type.typedef():
        alias_tyname = id.Name(type.type().scopedName()).fullyQualify()

    deref_kd_alias_tyname = deref_kd_type.base()
    deref_alias_tyname = deref_type.base()

    if deref_type.objref():
        objref_name = deref_type.objRefTemplate("Member")
        deref_alias_tyname = objref_name
        if type_dims == []:
            alias_tyname = objref_name

    # a multidimensional declarator will create several of
    # these functions (dimension by dimension)
    current_dims = []
    index = len(d_dims) - 1

    # if thing being aliased is also an array declarator, we need
    # to add its dimensions too.
    if type.typedef():
        current_dims = type.type().decl().sizes()
        alias_cname = mangler.canonTypeName(types.Type(type.type().decl().alias().aliasType()))

    prev_cname = canonDims(current_dims) + alias_cname
    prefix = config.state['Private Prefix']
    builddesc_nonarray_str = prefix + "_buildDesc" + alias_cname +\
                             "(_desc, " + prefix + "_tmp);"

    required_symbols = [ prefix + "_buildDesc" + alias_cname ]
    assertDefined(required_symbols)

    def builddesc_array(cname, prefix = prefix):
        return """\
_desc.p_array.getElementDesc = """ + prefix + """_tcParser_getElementDesc""" + cname + """;
_desc.p_array.opq_array = &""" + prefix + """_tmp;"""

    if type_dims == []:
        builddesc_str = builddesc_nonarray_str
    else:
        builddesc_str = builddesc_array(prev_cname)

    element_name = alias_tyname
    
    if deref_type.string():
        if type_dims == []:
            element_name = "CORBA::String_member"
    elif deref_type.wstring():
        if type_dims == []:
            element_name = "CORBA::WString_member"
    elif type.sequence():
        element_name = type.sequenceTemplate()
    elif deref_type.typecode():
        if type_dims == []:
            element_name = "CORBA::TypeCode_member"


    element_dims = []
    while index >= 0:

        first_iteration = element_dims == []
        
        element_dims = [d_dims[index]] + element_dims
        current_dims = [d_dims[index]] + current_dims
        index = index - 1

        new_cname = canonDims(element_dims[1:]) + prev_cname
        
        builddesc_str = builddesc_array(new_cname)
        # first iteration, check for special case
        if first_iteration:
            if type_dims == []:
                builddesc_str = builddesc_nonarray_str

        element_tail_dims = element_dims[1:]
        dims_index = map(lambda x:"[" + str(x) + "]", element_dims)
        dims_tail_index = dims_index[1:]
        this_cname = canonDims(current_dims) + alias_cname

        generated_symbol = prefix +"_tcParser_getElementDesc"+ this_cname

        if not isDefined(generated_symbol):
            defineSymbols([ generated_symbol ])
        
            stream.out(template.getdesc_array,
                       this_cname = this_cname,
                       type = element_name,
                       tail_dims = string.join(dims_tail_index, ""),
                       builddesc = builddesc_str,
                       index_string = string.join(dims_index, ""),
                       private_prefix = prefix)
            
    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_type.sequence():
        argtype = deref_type.sequenceTemplate()
    elif deref_type.typecode():
        argtype = "CORBA::TypeCode_member"
    elif deref_type.string():
        argtype = "CORBA::String_member"
    elif deref_type.wstring():
        argtype = "CORBA::WString_member"

    required_symbols = [ prefix + "_tcParser_getElementDesc" + d_cname ]
    generated_symbol = prefix + "_buildDesc" + d_cname
    if not isDefined(generated_symbol):
        defineSymbols([ generated_symbol ])
        assertDefined(required_symbols)
    
        stream.out(template.builddesc_array,
                   decl_cname = d_cname,
                   tail_dims = tail_dims,
                   dtype = argtype,
                   type = alias_tyname,
                   private_prefix = prefix)


# <-- Code to deal with normal members
def visitMembers(node, stream, fqname, guard_name, prefix, static = ""):
        
    # total up the number of members (enums are a scoping special case)
    num_members = 0
    for m in node.members():
        memberType = types.Type(m.memberType())
        if memberType.enum() and m.constrType():
            num_members = num_members + \
                          len(memberType.type().decl().enumerators())

        for d in m.declarators():
            num_members = num_members + 1

    # deal with types 
    for m in node.members():
        memberType = m.memberType()
        memberType.accept(self)
        
        # needs to deal with array declarators....
        for d in m.declarators():
            d_sizes = d.sizes()
            is_array_declarator = d_sizes != []
            if is_array_declarator:
                visitArray(types.Type(memberType), d)

    # build the case expression
    cases = output.StringStream()
    index = 0
    for m in node.members():
        memberType = types.Type(m.memberType())
        deref_memberType = memberType.deref(keep_dims = 1)
        member_dims = memberType.dims()
        for d in m.declarators():
            d_scopedName = id.Name(d.scopedName())
            d_name = d_scopedName.simple()
            d_cname = mangler.canonTypeName(deref_memberType, d)
            d_dims = d.sizes()
            full_dims = d_dims + member_dims
            is_array = full_dims != []
            is_array_declarator = d_dims != []
            
            thing = "((" + fqname + "*)_desc->opq_struct)->" +\
                    d_name
            if is_array:
                thing = docast(memberType, d, thing)

            assertDefined([ prefix + "_buildDesc" + d_cname ])
            cases.out("""\
case @n@:
  @private_prefix@_buildDesc@cname@(_newdesc, @thing@);
  return 1;""",
                      n = str(index), cname = d_cname,
                      private_prefix = prefix,
                      thing = thing)
            index = index + 1

    stream.out("""\
@static@ CORBA::Boolean
@private_prefix@_tcParser_getMemberDesc_@guard_name@(const tcStructDesc *_desc, CORBA::ULong _index, tcDescriptor &_newdesc){
  switch (_index) {
  @cases@
  default:
    return 0;
  };
}
@static@ CORBA::ULong
""", cases = str(cases), private_prefix = prefix, static = static,
               guard_name = guard_name)
       
    defineSymbols([ prefix + "_tcParser_getMemberDesc_" + guard_name ])

    # <---
    required_symbols = [ prefix + "_tcParser_getMemberDesc_" + guard_name ]
    generated_symbols = [ prefix + "_tcParser_getMemberCount_" +\
                          guard_name,
                          prefix + "_buildDesc_c" + guard_name]
    assertDefined(required_symbols)
    defineSymbols(generated_symbols)
    # <---