cpp_codegen.py

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

            swrite('END_EVENT_TABLE();\n')

        if prev_src is not None and not is_new:
            tag = '<%swxGlade replace %s event_table>' % (nonce, 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::event_table block " \
                               "not found, relative code NOT generated" % \
                               (code_obj.klass))
            else:
                prev_src.source_content = prev_src.source_content.\
                                          replace(tag, "".join(source_buffer))
            source_buffer = []
            swrite = source_buffer.append

        # 2) event handler stubs...
        if prev_src is not None:
            already_there = prev_src.event_handlers.get(code_obj.klass, {})
        else:
            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:
                swrite('\n\nvoid %s::%s(%s &event)\n{\n' % \
                       (code_obj.klass, handler, evt_type))
                swrite(tab + 'event.Skip();\n')
                swrite(tab + 'wxLogDebug(wxT("Event handler (%s::%s) not '
                       'implemented yet")); //notify the user '
                       'that he hasn\'t implemented the event handler yet\n' % \
                       (code_obj.klass, handler))
                swrite('}\n')
                already_there[handler] = 1
        if is_new or prev_src is None:
            swrite('\n\n')
        swrite('// wxGlade: add %s event handlers\n' % code_obj.klass)
        if is_new or prev_src is None:
            swrite('\n')

        if prev_src is not None and not is_new:
            tag = '<%swxGlade add %s event handlers>' % \
                  (nonce, 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 event handlers " \
                               "marker not found, relative code NOT generated" \
                               % (code_obj.klass))
            else:
                prev_src.source_content = prev_src.source_content.\
                                          replace(tag, "".join(source_buffer))
            source_buffer = []
            swrite = source_buffer.append
    

    # set_properties
##     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 = []
    if hasattr(builder, 'get_properties_code'):
        obj_p = builder.get_properties_code(code_obj)
    else:
        obj_p = generate_common_properties(code_obj)

    # set_properties
    if is_new:
        swrite('\nvoid %s::set_properties()\n{\n' % code_obj.klass)
    swrite(tab + '// begin wxGlade: %s::set_properties\n' % code_obj.klass)
    for l in obj_p: swrite(tab + l)
    for l in classes[code_obj.klass].props:
        swrite(tab + l)
    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 set_properties>' % (nonce, code_obj.klass)
        if prev_src.source_content.find(tag) < 0:
            # no set_properties tag found, issue a warning and do nothing
            common.message("WARNING", "wxGlade %s::set_properties block "\
                           "not found, relative code NOT generated" % \
                           (code_obj.klass))
        else:
            prev_src.source_content = prev_src.source_content.\
                                      replace(tag, "".join(source_buffer))
        source_buffer = []
        swrite = source_buffer.append


    # do_layout
    if is_new:
        swrite('\nvoid %s::do_layout()\n{\n' % code_obj.klass)
    layout_lines = classes[code_obj.klass].layout
    sizers_init_lines = classes[code_obj.klass].sizers_init
    swrite(tab + '// begin wxGlade: %s::do_layout\n' % code_obj.klass)
    sizers_init_lines.reverse()
    for l in sizers_init_lines: swrite(tab + l)
    for l in layout_lines: swrite(tab + l)

    #if sizers_init_lines or layout_lines: swrite(tab + 'Layout();\n')

    # now, check if there are extra layout lines to add
    if hasattr(builder, 'get_layout_code'):
        for l in builder.get_layout_code(code_obj):
            swrite(tab + l)
    
    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 do_layout>' % (nonce, code_obj.klass)
        if prev_src.source_content.find(tag) < 0:
            # no do_layout tag found, issue a warning and do nothing
            common.message("WARNING", "wxGlade %s::do_layout block "\
                           "not found, relative code NOT generated" %
                           (code_obj.klass))
        else:
            prev_src.source_content = prev_src.source_content.\
                                      replace(tag, "".join(source_buffer))
        source_buffer = []
        swrite = source_buffer.append


    # the code has been generated
    classes[code_obj.klass].done = True

    if not multiple_files and prev_src is not None:
        # if this is a new class, add its code to the new_classes list of the
        # SourceFileContent instance
        if is_new: prev_src.new_classes.append( ("".join(header_buffer),
                                                "".join(source_buffer)) )
        return

    if multiple_files:
        if code_obj.base in obj_builders:
            classes[code_obj.klass].dependencies.extend(
                getattr(obj_builders[code_obj.base], 'extra_headers', []))
        if prev_src is not None:
            tag = '<%swxGlade insert new_classes>' % nonce
            prev_src.header_content = prev_src.header_content.replace(tag, "")
            
            # insert the module dependencies of this class
            extra_modules = classes[code_obj.klass].dependencies
            #print 'extra_modules:', extra_modules, code_obj.base
            deps = ['// begin wxGlade: ::dependencies\n']
            for module in _unique(extra_modules):
                if module and ('"' != module[0] != '<'):
                    deps.append('#include "%s.h"\n' % module)
                else:
                    deps.append('#include %s\n' % module)
            deps.append('// end wxGlade\n')
            # WARNING: there's a double space '  ' between 'replace' and
            # 'dependencies' in the tag below, because there is no class name
            # (see SourceFileContent, line ~147)
            tag = '<%swxGlade replace  dependencies>' % nonce
            prev_src.header_content = prev_src.header_content.\
                                      replace(tag, "".join(deps))

            # insert the extra code of this class
            extra_code_h = "".join(classes[code_obj.klass].extra_code_h[::-1])
            extra_code_cpp = \
                           "".join(classes[code_obj.klass].extra_code_cpp[::-1])
            # if there's extra code but we are not overwriting existing
            # sources, warn the user
            if extra_code_h or extra_code_cpp:
                common.message('WARNING', '%s (or one of its chilren) has '
                               'extra code classes, but you are '
                               'not overwriting existing sources: please check '
                               'that the resulting code is correct!' % \
                               code_obj.name)
            
            extra_code_h = '// begin wxGlade: ::extracode\n%s\n' \
                           '// end wxGlade\n' % extra_code_h
            extra_code_cpp = '// begin wxGlade: ::extracode\n%s\n' \
                             '// end wxGlade\n' % extra_code_cpp
            tag = '<%swxGlade replace  extracode>' % nonce
            prev_src.header_content = prev_src.header_content.replace(
                tag, extra_code_h)
            prev_src.source_content = prev_src.source_content.replace(
                tag, extra_code_cpp)
            
            # store the new file contents to disk
            name = os.path.join(out_dir, code_obj.klass)
            common.save_file(name + '.h', prev_src.header_content, 'codegen')
            common.save_file(name + '.cpp', prev_src.source_content, 'codegen')
            return

        # create the new source file
        header_file = os.path.join(out_dir, code_obj.klass + '.h')
        source_file = os.path.join(out_dir, code_obj.klass + '.cpp')
        hout = cStringIO.StringIO()
        sout = cStringIO.StringIO()
        # header file
        hwrite = hout.write
        # write the common lines
        for line in header_lines: hwrite(line)
        # isolation directives
        hn = os.path.basename(header_file).upper().replace('.', '_')
        hwrite('\n#ifndef %s\n#define %s\n' % (hn, hn))
        # write the module dependecies for this class
        #extra_headers = classes[code_obj.klass].dependencies
        hwrite('\n// begin wxGlade: ::dependencies\n')
        extra_modules = classes[code_obj.klass].dependencies
        for module in _unique(extra_modules):
            if module and ('"' != module[0] != '<'):
                hwrite('#include "%s.h"\n' % module)
            else:
                hwrite('#include %s\n' % module)
        hwrite('// end wxGlade\n')
        hwrite('\n')

        # insert the extra code of this class
        extra_code_h = "".join(classes[code_obj.klass].extra_code_h[::-1])
        extra_code_h = '// begin wxGlade: ::extracode\n%s\n// end wxGlade\n' % \
                       extra_code_h
        hwrite(extra_code_h)
        hwrite('\n')
        
        # write the class body
        for line in header_buffer: hwrite(line)
        hwrite('\n#endif // %s\n' % hn)

        # source file
        swrite = sout.write
        # write the common lines
        #for line in header_lines: swrite(line)
        swrite(header_lines[0])
        swrite('#include "%s"\n\n' % os.path.basename(header_file))

        # insert the extra code of this class
        extra_code_cpp = "".join(classes[code_obj.klass].extra_code_cpp[::-1])
        extra_code_cpp = '// begin wxGlade: ::extracode\n%s\n' \
                         '// end wxGlade\n' % extra_code_cpp
        swrite(extra_code_cpp)
        swrite('\n')
        
        # write the class implementation
        for line in source_buffer: swrite(line)

        # store source to disk
        common.save_file(header_file, hout.getvalue(), 'codegen')
        common.save_file(source_file, sout.getvalue(), 'codegen')

        hout.close()
        sout.close()

    else: # not multiple_files
        # write the class body onto the single source file 
        hwrite = output_header.write
        for line in header_buffer: hwrite(line)
        swrite = output_source.write
        for line in source_buffer: swrite(line)
        # extra code
        if classes[code_obj.klass].extra_code_h:
            _current_extra_code_h.extend(
                classes[code_obj.klass].extra_code_h[::-1])
        if classes[code_obj.klass].extra_code_cpp:
            _current_extra_code_cpp.extend(
                classes[code_obj.klass].extra_code_h[::-1])


def add_app(app_attrs, top_win_class):
    """\
    Generates the code for a wxApp instance.
    if the 'class' property has no value, the function does nothing
    """
    if not multiple_files: prev_src = previous_source
    else:
        filename = os.path.join(out_dir, 'main.cpp')
        if not os.path.exists(filename): prev_src = None
        elif _overwrite: prev_src = None
        else:
            # prev_src doesn't need to be a SourceFileContent instance in this
            # case, as we do nothing if it is not None
            prev_src = 1
    if prev_src is not None:
        return # do nothing if the file existed

    klass = app_attrs.get('class')
    top_win = app_attrs.get('top_window')
    if not klass or not top_win: return # do nothing in these cases

    lines = []
    append = lines.append
    tab = tabs(1)
    append('\n\nclass %s: public wxApp {\n' % klass)
    append('public:\n')
    append(tab + 'bool OnInit();\n')
    append('};\n\n')
    append('IMPLEMENT_APP(%s)\n\n' % klass)
    append('bool %s::OnInit()\n{\n' % klass)
    append(tab + 'wxInitAllImageHandlers();\n') # we add this to avoid troubles
    append(tab + '%s* %s = new %s(NULL, wxID_ANY, wxEmptyString);\n' % \
           (top_win_class, top_win, top_win_class))
    append(tab + 'SetTopWindow(%s);\n' % top_win)
    append(tab + '%s->Show();\n' % top_win)
    append(tab + 'return true;\n}\n')

    if multiple_files:
        filename = os.path.join(out_dir, 'main.cpp')
        out = cStringIO.StringIO()
        write = out.write
        # write the common lines