cpp_codegen.py

用python写的ide开发环境,巨强大,不过需要wxpython的支持

    else:
        is_new = True

    header_buffer = []
    source_buffer = []
    hwrite = header_buffer.append
    swrite = source_buffer.append

    if not classes.has_key(code_obj.klass):
        # if the class body was empty, create an empty ClassLines
        classes[code_obj.klass] = ClassLines()


##     # first thing to do, call the property writer: we do this here because it
##     # is admissible for the property code generator to have side effects (i.e.
##     # to operate on the ClassLines instance): this is actually done in the
##     # toplevel menubar
##     props_builder = obj_properties.get(code_obj.base)
##     write_body = len(classes[code_obj.klass].props)
##     if props_builder:
##         obj_p = props_builder(code_obj)#obj_properties[code_obj.base](code_obj)
##         if not write_body: write_body = len(obj_p)
##     else: obj_p = []

    try:
        builder = obj_builders[code_obj.base]
    except KeyError:
        print code_obj
        raise # this shouldn't happen

    # try to see if there's some extra code to add to this class
    extra_code = getattr(builder, 'extracode',
                         code_obj.properties.get('extracode', ""))
    if extra_code:
        extra_code = re.sub(r'\\n', '\n', extra_code)
        extra_code = re.split(re.compile(r'^###\s*$', re.M), extra_code, 1)
        classes[code_obj.klass].extra_code_h.append(extra_code[0])
        if len(extra_code) > 1:
            classes[code_obj.klass].extra_code_cpp.append(extra_code[1])
        if not is_new:
            common.message('WARNING', '%s has extra code, but you are '
                           'not overwriting existing sources: please check '
                           'that the resulting code is correct!' % \
                           code_obj.name)

    if not multiple_files and extra_code:
        _current_extra_code_h.append("".join(
            classes[code_obj.klass].extra_code_h[::-1]))
        _current_extra_code_cpp.append("".join(
            classes[code_obj.klass].extra_code_cpp[::-1]))
    #------------------------------------------------------------

    default_sign = [('wxWindow*', 'parent'), ('int', 'id')]
##     sign = obj_constructors.get(code_obj.base, default_sign)
    sign = getattr(builder, 'constructor', default_sign)
    
    defaults = []
    for t in sign:
        if len(t) == 3: defaults.append(t[2])
        else: defaults.append(None)
    tmp_sign = [ t[0] + ' ' + t[1] for t in sign ]
    sign_decl2 = ', '.join(tmp_sign)
    for i in range(len(tmp_sign)):
        if defaults[i] is not None:
            tmp_sign[i] += '=%s' % defaults[i]
    sign_decl1 = ', '.join(tmp_sign)
    sign_inst = ', '.join([ t[1] for t in sign])


    # ALB 2004-12-08 event handling
    event_handlers = classes[code_obj.klass].event_handlers
    if hasattr(builder, 'get_events'):
        event_handlers.extend(builder.get_events(code_obj))

    # ALB 2007-08-31 custom base classes support
    custom_base = getattr(code_obj, 'custom_base',
                          code_obj.properties.get('custom_base', None))
    if custom_base and not custom_base.strip():
        custom_base = None

    if not is_new and custom_base is not None:
        # custom base classes set, but "overwrite existing sources" not
        # set. Issue a warning about this
        common.message('WARNING', '%s has custom base classes, but you are '
                       'not overwriting existing sources: please check that '
                       'the resulting code is correct!' % code_obj.name)        

    if is_new:
        # header file
        base = code_obj.base
        if custom_base is not None:
            base = ", public ".join([b.strip() for b in custom_base.split(',')])
        hwrite('\nclass %s: public %s {\n' % (code_obj.klass, base))
        hwrite('public:\n')
        # the first thing to add it the enum of the various ids
        hwrite(tabs(1) + '// begin wxGlade: %s::ids\n' % code_obj.klass)
        ids = classes[code_obj.klass].ids

        # let's try to see if there are extra ids to add to the enum
        if hasattr(builder, 'get_ids_code'):
            ids.extend(builder.get_ids_code(code_obj))
        
        if ids:
            hwrite(tabs(1) + 'enum {\n')
            ids = (',\n' + tabs(2)).join(ids)
            hwrite(tabs(2) + ids)
            hwrite('\n' + tabs(1) + '};\n')
        hwrite(tabs(1) + '// end wxGlade\n\n')
        # constructor prototype
        hwrite(tabs(1) + '%s(%s);\n' % (code_obj.klass, sign_decl1))
        hwrite('\nprivate:\n')
        # set_properties and do_layout prototypes
        hwrite(tabs(1) + '// begin wxGlade: %s::methods\n' % code_obj.klass)
        hwrite(tabs(1) + 'void set_properties();\n')
        hwrite(tabs(1) + 'void do_layout();\n')
        hwrite(tabs(1) + '// end wxGlade\n')
        # declarations of the attributes
        hwrite('\n')
        hwrite('protected:\n')
        hwrite(tabs(1) + '// begin wxGlade: %s::attributes\n' % code_obj.klass)
        for o_type, o_name in classes[code_obj.klass].sub_objs:
            hwrite(tabs(1) + '%s* %s;\n' % (o_type, o_name))
        hwrite(tabs(1) + '// end wxGlade\n')

        # ALB 2004-12-08 event handling
        if event_handlers:
            t = tabs(1)
            hwrite('\n' + t + 'DECLARE_EVENT_TABLE();\n')
            hwrite('\npublic:\n')
            already_there = {}
            for tpl in event_handlers:
                if len(tpl) == 4:
                    win_id, event, handler, evt_type = tpl
                else:
                    win_id, event, handler = tpl
                    evt_type = 'wxCommandEvent'
                if handler not in already_there:
                    # Sebastien JEFFROY & Steve MULLER contribution
                    # Adding virtual attribute permits to derivate from the
                    # class generated by wxGlade
                    hwrite(t + 'virtual void %s(%s &event); '
                           '// wxGlade: <event_handler>\n' %
                           (handler, evt_type))
                    already_there[handler] = 1
        
        hwrite('}; // wxGlade: end class\n\n')
        
    elif prev_src is not None:
        hwrite(tabs(1) + '// begin wxGlade: %s::ids\n' % code_obj.klass)
        ids = classes[code_obj.klass].ids

        # let's try to see if there are extra ids to add to the enum
        if hasattr(builder, 'get_ids_code'):
            ids.extend(builder.get_ids_code(code_obj))

        if ids:
            hwrite(tabs(1) + 'enum {\n')
            ids = (',\n' + tabs(2)).join(ids)
            hwrite(tabs(2) + ids)
            hwrite('\n' + tabs(1) + '};\n')
        hwrite(tabs(1) + '// end wxGlade\n')
        tag = '<%swxGlade replace %s ids>' % (nonce, code_obj.klass)
        if prev_src.header_content.find(tag) < 0:
            # no ids tag found, issue a warning and do nothing
            common.message("WARNING", "wxGlade ids block not found for %s," \
                           " ids declarations code NOT generated" % \
                           code_obj.name)
        else:
            prev_src.header_content = prev_src.header_content.\
                                      replace(tag, "".join(header_buffer))
        header_buffer = [ tabs(1) + '// begin wxGlade: %s::methods\n' % \
                          code_obj.klass,
                          tabs(1) + 'void set_properties();\n',
                          tabs(1) + 'void do_layout();\n',
                          tabs(1) + '// end wxGlade\n' ]
        tag = '<%swxGlade replace %s methods>' % (nonce, code_obj.klass)
        if prev_src.header_content.find(tag) < 0:
            # no methods tag found, issue a warning and do nothing
            common.message("WARNING",
                           "wxGlade methods block not found for %s," \
                           " methods declarations code NOT generated" % \
                           code_obj.name)
        else:
            prev_src.header_content = prev_src.header_content.\
                                      replace(tag, "".join(header_buffer))
        header_buffer = []
        hwrite = header_buffer.append
        hwrite(tabs(1) + '// begin wxGlade: %s::attributes\n' % code_obj.klass)
        for o_type, o_name in classes[code_obj.klass].sub_objs:
            hwrite(tabs(1) + '%s* %s;\n' % (o_type, o_name))
        hwrite(tabs(1) + '// end wxGlade\n')
        tag = '<%swxGlade replace %s attributes>' % (nonce, code_obj.klass)
        if prev_src.header_content.find(tag) < 0:
            # no attributes tag found, issue a warning and do nothing
            common.message("WARNING",
                           "wxGlade attributes block " \
                           "not found for %s, attributes declarations code " \
                           "NOT generated" % code_obj.name)
        else:
            prev_src.header_content = prev_src.header_content.\
                                      replace(tag, "".join(header_buffer))

        header_buffer = []
        hwrite = header_buffer.append
        # ALB 2004-12-08 event handling
        if event_handlers:
            already_there = prev_src.event_handlers.get(code_obj.klass, {})
            t = tabs(1)
            for tpl in event_handlers:
                if len(tpl) == 4:
                    win_id, event, handler, evt_type = tpl
                else:
                    win_id, event, handler = tpl
                    evt_type = 'wxCommandEvent'
                if handler not in already_there:
                    # Sebastien JEFFROY & Steve MULLER contribution :
                    # Adding virtual attribute permits to derivate from the
                    # class generated by wxGlade
                    hwrite(t + 'virtual void %s(%s &event); // wxGlade: '
                           '<event_handler>\n' % (handler, evt_type))
                    already_there[handler] = 1
            if code_obj.klass not in prev_src.event_table_def:
                hwrite('\nprotected:\n')
                hwrite(tabs(1) + 'DECLARE_EVENT_TABLE()\n')
        tag = '<%swxGlade event_handlers %s>' % (nonce, code_obj.klass)
        if prev_src.header_content.find(tag) < 0:
            # no attributes tag found, issue a warning and do nothing
            common.message("WARNING", "wxGlade events block " \
                           "not found for %s, event table code NOT generated" %
                           code_obj.name)
        else:
            prev_src.header_content = prev_src.header_content.\
                                      replace(tag, "".join(header_buffer))
        
    # source file
    # set the window's style
    prop = code_obj.properties
    style = prop.get("style", None)
    if style is not None:
        sign_inst = sign_inst.replace('style', '%s' % style)
    
    # constructor
    if is_new:
        base = "%s(%s)" % (code_obj.base, sign_inst)
        if custom_base:
            bases = [b.strip() for b  in custom_base.split(',')]
            if bases:
                base = "%s(%s)" % (bases[0], sign_inst)
                rest = ", ".join([b + "()" for b in bases[1:]])
                if rest: base += ", " + rest
            
        swrite('\n%s::%s(%s):\n%s%s\n{\n' % (code_obj.klass,
                                             code_obj.klass,
                                             sign_decl2, tabs(1), base))
##                                                  code_obj.base, sign_inst))
    swrite(tabs(1) + '// begin wxGlade: %s::%s\n' % (code_obj.klass,
                                                     code_obj.klass))
    tab = tabs(1)
    init_lines = classes[code_obj.klass].init
    # --- patch 2002-08-26 ---------------------------------------------------
    parents_init = classes[code_obj.klass].parents_init
    parents_init.reverse()    
    for l in parents_init: swrite(tab + l)
    # ------------------------------------------------------------------------
    for l in init_lines: swrite(tab + l)

    # now see if there are extra init lines to add
    if hasattr(builder, 'get_init_code'):
        for l in builder.get_init_code(code_obj):
            swrite(tab + l)
    
    swrite('\n' + tab + 'set_properties();\n')
    swrite(tab + 'do_layout();\n')
    # end tag
    swrite(tab + '// end wxGlade\n')
    if is_new: swrite('}\n\n')

    if prev_src is not None and not is_new:
        # replace the lines inside the constructor wxGlade block
        # with the new ones
        tag = '<%swxGlade replace %s %s>' % (nonce, code_obj.klass,
                                             code_obj.klass)
        if prev_src.source_content.find(tag) < 0:
            # no constructor tag found, issue a warning and do nothing
            common.message("WARNING", "wxGlade %s::%s block not found," \
                           " relative code NOT generated" % (code_obj.klass,
                                                             code_obj.klass))
        else:
            prev_src.source_content = prev_src.source_content.\
                                      replace(tag, "".join(source_buffer))
        source_buffer = []
        swrite = source_buffer.append

    # ALB 2004-12-08 event handling code
    if event_handlers:
        # 1) event table declaration/definition...
        if prev_src is not None and \
               code_obj.klass in prev_src.event_table_decl:
            has_event_table = True
        else:
            has_event_table = False
        if is_new or not has_event_table:
            swrite('\nBEGIN_EVENT_TABLE(%s, %s)\n' % \
                   (code_obj.klass, code_obj.base))
            
        swrite(tab + '// begin wxGlade: %s::event_table\n' % code_obj.klass)
        for tpl in event_handlers:
            win_id, event, handler = tpl[:3]
            swrite(tab + '%s(%s, %s::%s)\n' % \
                   (event, win_id, code_obj.klass, handler))
        swrite(tab + '// end wxGlade\n')
        
        if is_new or not has_event_table: