generate a single output file

@@ -6,6 +6,8 @@
 #  $Id: cx86.py,v 1.3 2004/06/02 21:05:23 varmaa Exp $
 #  $Id: cx86.py,v 1.3 2004/06/02 21:05:23 varmaa Exp $
 #  ---------------------------------------------------------------
 #  ---------------------------------------------------------------
 
 
+import io
+
 from . import cparse
 from . import cparse
 from .cvisitors import Visitor
 from .cvisitors import Visitor
 
 
@@ -394,28 +396,25 @@ class CodeGenVisitor(Visitor):
     """Visitor that generates x86 assembly code for the abstract
     """Visitor that generates x86 assembly code for the abstract
     syntax tree."""
     syntax tree."""
 
 
-    def __init__(self, file, show_comments=0):
+    # The current label number we're on, for generating
+    # jump labels in the assembly code (e.g., 'LO', 'L1', etc).
+    __label = 0
+
+    # Current label number for generating string literal labels.
+    __str_literal_label = 0
+
+    def __init__(self, path):
         """Constructor.  'file' is the file object to output the
         """Constructor.  'file' is the file object to output the
-        resulting code to.  If 'show_comments' is true, then annotated
-        comments are produced for the generated assembly code."""
+        resulting code to."""
 
 
         Visitor.__init__(self)
         Visitor.__init__(self)
 
 
-        # The current label number we're on, for generating
-        # jump labels in the assembly code (e.g., 'LO', 'L1', etc).
-        self.__label = 0
-
-        # Current label number for generating string literal labels.
-        self.__str_literal_label = 0
+        # path of compiled C source
+        self.path = path
 
 
         # Current assembly code for string literals.
         # Current assembly code for string literals.
-        self.__str_literal_str = ""
-
-        # Whether we should show comments or not.
-        self.show_comments = show_comments
-
-        # The file we're outputting the generated code to.
-        self.file = file
+        self.str_literal_str = io.StringIO()
+        self.str_literal_dict = {}
 
 
         # A hashtable of binary operators and the assembly
         # A hashtable of binary operators and the assembly
         # instructions corresponding to them.  Certain instructions
         # instructions corresponding to them.  Certain instructions
@@ -454,7 +453,7 @@ class CodeGenVisitor(Visitor):
         """Generate a new jump label and return it."""
         """Generate a new jump label and return it."""
 
 
         label = ".L%d" % self.__label
         label = ".L%d" % self.__label
-        self.__label += 1
+        self.__class__.__label += 1
         return label
         return label
 
 
     def o(self, str, comment=None):
     def o(self, str, comment=None):
@@ -462,22 +461,20 @@ class CodeGenVisitor(Visitor):
         with an optional annotated comment (if comments are
         with an optional annotated comment (if comments are
         enabled)."""
         enabled)."""
 
 
-        if self.show_comments and comment != None:
+        if comment != None:
             comment = "# %s" % comment
             comment = "# %s" % comment
-            self.curr_str += "%-35s %s\n" % (str, comment)
+            self.curr_str.write("%-35s %s\n" % (str, comment))
         else:
         else:
             if str == "":
             if str == "":
                 return
                 return
-            self.curr_str += str + "\n"
+            self.curr_str.write(str + "\n")
 
 
     def c(self, str, indent_amt=2):
     def c(self, str, indent_amt=2):
-        """Output a single-line comment to the output file, if
-        comments are enabled."""
+        "Output a single-line comment to the output file."
 
 
         indent = " " * indent_amt
         indent = " " * indent_amt
 
 
-        if self.show_comments:
-            self.o("\n%s# %s\n" % (indent, str))
+        self.o("\n%s# %s\n" % (indent, str))
 
 
     def vNodeList(self, node):
     def vNodeList(self, node):
         self._visitList(node.nodes)
         self._visitList(node.nodes)
@@ -513,36 +510,43 @@ class CodeGenVisitor(Visitor):
         """Generate and return a list of global variable
         """Generate and return a list of global variable
         definitions."""
         definitions."""
 
 
-        globals_str = ".global_vars:\n"
+        globals_str = io.StringIO()
         for symbol in node.symtab.entries.values():
         for symbol in node.symtab.entries.values():
             symbol.compile_loc = self.symbol_prepend + symbol.name
             symbol.compile_loc = self.symbol_prepend + symbol.name
             if not symbol.type.is_function() and not symbol.extern:
             if not symbol.type.is_function() and not symbol.extern:
-                globals_str += "  .comm %s,%d\n" % \
-                (symbol.compile_loc, \
-                 self._calc_var_size(symbol.type)*WEIRD_MULTIPLIER)
+                globals_str.write("  .comm %s,%d\n"
+                                  % (symbol.compile_loc,
+                                     self._calc_var_size(symbol.type)*WEIRD_MULTIPLIER))
         return globals_str
         return globals_str
 
 
     def vTranslationUnit(self, node):
     def vTranslationUnit(self, node):
         """Outputs the entire assembly source file."""
         """Outputs the entire assembly source file."""
 
 
-        self.curr_str = ""
-        self.o("# Generated by c.py")
-        self.o("# Atul Varma (Spring 2004)\n")
-        self.o("    .text")
+        self.curr_str = io.StringIO()
 
 
-        globals_str = self._generate_global_variable_definitions(node)
+        self.globals_str = self._generate_global_variable_definitions(node)
 
 
         # Generate the main code.
         # Generate the main code.
         self._visitList(node.nodes)
         self._visitList(node.nodes)
 
 
-        # Append global variable definitions.
-        self.o(globals_str)
-
-        # Append string literal definitions.
-        self.o(self.__str_literal_str)
-
-        # Output the entire file.
-        self.file.write(self.curr_str)
+    @classmethod
+    def concat (cls, outfile, chunks) :
+        outfile.write("# Generated by cct\n"
+                      "# Franck Pommereau (2018)\n"
+                      "# Adapted from Atul Varma's c.py (Spring 2004)\n\n")
+        #
+        outfile.write(".text\n\n")
+        for c in chunks :
+            outfile.write("# code from file %r\n" % c.path)
+            outfile.write(c.curr_str.getvalue())
+            #
+        outfile.write(".global_vars:\n\n")
+        for c in chunks :
+            outfile.write("\n# globals from file %r\n\n" % c.path)
+            outfile.write(c.globals_str.getvalue())
+        for c in chunks :
+            outfile.write("\n# string literals from file %r\n\n" % c.path)
+            outfile.write(c.str_literal_str.getvalue())
 
 
     def _calc_var_size(self, type):
     def _calc_var_size(self, type):
         """Calculate and return the size of the given type, in
         """Calculate and return the size of the given type, in
@@ -674,7 +678,7 @@ class CodeGenVisitor(Visitor):
         # insert it into our code later on.
         # insert it into our code later on.
 
 
         old_str = self.curr_str
         old_str = self.curr_str
-        self.curr_str = ""
+        self.curr_str = io.StringIO()
 
 
         node.body.accept(self)
         node.body.accept(self)
 
 
@@ -692,7 +696,7 @@ class CodeGenVisitor(Visitor):
         self.stack.save_callee_saves()
         self.stack.save_callee_saves()
 
 
         # Add the previously-generated assembly code for the function.
         # Add the previously-generated assembly code for the function.
-        self.curr_str += function_str
+        self.curr_str.write(function_str.getvalue())
 
 
         self.o("%s:" % self.curr_func_end_label)
         self.o("%s:" % self.curr_func_end_label)
 
 
@@ -816,10 +820,14 @@ class CodeGenVisitor(Visitor):
         generate (but do not yet emit) the assembly for it, and return
         generate (but do not yet emit) the assembly for it, and return
         the name of the new label."""
         the name of the new label."""
 
 
+        if str in self.str_literal_dict :
+            return self.str_literal_dict[str]
+
         label_str = "LC%d" % self.__str_literal_label
         label_str = "LC%d" % self.__str_literal_label
+        self.str_literal_dict[str] = label_str
         str = str.replace('\n', '\\12')
         str = str.replace('\n', '\\12')
-        self.__str_literal_str += """%s:\n  .ascii "%s\\0"\n""" % (label_str, str)
-        self.__str_literal_label += 1
+        self.str_literal_str.write("""%s:\n  .ascii "%s\\0"\n""" % (label_str, str))
+        self.__class__.__str_literal_label += 1
         return label_str
         return label_str
 
 
     def vStringLiteral(self, node):
     def vStringLiteral(self, node):

@@ -20,8 +20,9 @@ class Compiler (object) :
     """This object encapsulates the front-end for the compiler and
     """This object encapsulates the front-end for the compiler and
     serves as a facade interface to the 'meat' of the compiler
     serves as a facade interface to the 'meat' of the compiler
     underneath."""
     underneath."""
-    def __init__ (self, arch) :
+    def __init__ (self, arch, path) :
         self.arch = arch
         self.arch = arch
+        self.path = path
         self.total_errors = 0
         self.total_errors = 0
         self.total_warnings = 0
         self.total_warnings = 0
     def _parse (self) :
     def _parse (self) :
@@ -34,37 +35,39 @@ class Compiler (object) :
         self.total_warnings += visitor.warnings
         self.total_warnings += visitor.warnings
         if visitor.has_errors():
         if visitor.has_errors():
             raise CompileError()
             raise CompileError()
-    def _do_compile (self, outfile, ast_file) :
+    def _do_compile (self, ast_file) :
         """Compiles the code to the given file object.  Enabling
         """Compiles the code to the given file object.  Enabling
         show_ast prints out the abstract syntax tree."""
         show_ast prints out the abstract syntax tree."""
         self._parse()
         self._parse()
         self._compile_phase(cvisitors.SymtabVisitor())
         self._compile_phase(cvisitors.SymtabVisitor())
         self._compile_phase(cvisitors.TypeCheckVisitor())
         self._compile_phase(cvisitors.TypeCheckVisitor())
         self._compile_phase(cvisitors.FlowControlVisitor())
         self._compile_phase(cvisitors.FlowControlVisitor())
-        self._compile_phase(self.arch.CodeGenVisitor(outfile))
+        comp = self.arch.CodeGenVisitor(self.path)
+        self._compile_phase(comp)
         if ast_file is not None:
         if ast_file is not None:
             self._compile_phase(cvisitors.ASTPrinterVisitor(ast_file))
             self._compile_phase(cvisitors.ASTPrinterVisitor(ast_file))
+        return comp
     def _print_stats (self) :
     def _print_stats (self) :
         "Prints the total number of errors/warnings from compilation."
         "Prints the total number of errors/warnings from compilation."
         if self.total_errors :
         if self.total_errors :
             print("%d errors" % self.total_errors)
             print("%d errors" % self.total_errors)
         if self.total_warnings :
         if self.total_warnings :
             print("%s warnings" % self.total_warnings)
             print("%s warnings" % self.total_warnings)
-    def compile (self, code, outfile, show_ast) :
+    def compile (self, code, show_ast) :
         "Compiles the given code string to the given file object."
         "Compiles the given code string to the given file object."
         self.code = code
         self.code = code
         try:
         try:
-            self._do_compile(outfile, show_ast)
+            chunk = self._do_compile(show_ast)
         except cparse.ParseError:
         except cparse.ParseError:
             print("Errors encountered, bailing.")
             print("Errors encountered, bailing.")
-            return 1
+            return
         except CompileError:
         except CompileError:
             self._print_stats()
             self._print_stats()
             print("Errors encountered, bailing.")
             print("Errors encountered, bailing.")
-            return 1
+            return
         self._print_stats()
         self._print_stats()
         print("Compile successful.")
         print("Compile successful.")
-        return 0
+        return chunk
 
 
 def main (args=None) :
 def main (args=None) :
     parser = argparse.ArgumentParser(prog="cct",
     parser = argparse.ArgumentParser(prog="cct",
@@ -83,6 +86,7 @@ def main (args=None) :
     parser.add_argument("source", nargs="+", metavar="PATH",
     parser.add_argument("source", nargs="+", metavar="PATH",
                         help="C source files(s) to compile")
                         help="C source files(s) to compile")
     args = parser.parse_args(args)
     args = parser.parse_args(args)
+    chunks = []
     for src in args.source :
     for src in args.source :
         print("Compiling %r" % src)
         print("Compiling %r" % src)
         if args.ast :
         if args.ast :
@@ -92,8 +96,10 @@ def main (args=None) :
         else :
         else :
             ast_file = None
             ast_file = None
         code = "\n".join(open(src).readlines())
         code = "\n".join(open(src).readlines())
-        retval = Compiler(ARCH[args.arch]).compile(code, args.o, ast_file)
+        ret = Compiler(ARCH[args.arch], src).compile(code, ast_file)
         if ast_file is not None :
         if ast_file is not None :
             ast_file.close()
             ast_file.close()
-        if retval != 0 :
-            sys.exit(retval)
+        if ret is None :
+            sys.exit(1)
+        chunks.append(ret)
+    ARCH[args.arch].CodeGenVisitor.concat(args.o, chunks)

@@ -149,5 +149,11 @@ int main(int argc, char **argv) {
     printf("array-built string is: %s\n", c);
     printf("array-built string is: %s\n", c);
     free(c);
     free(c);
   }
   }
+
+  /* multiple defined strings */
+
+  printf("this string is defined twice\n");
+  printf("this string is defined twice\n");
+  
   return 0;
   return 0;
 }
 }

@@ -11,16 +11,8 @@
 /* Test global variable. */
 /* Test global variable. */
 int stuff_count;
 int stuff_count;
 
 
-/* Test of static function definition, to make sure it
-   doesn't conflict with fib() defined in foo.c. */
-static int fib()
-{
-  return stuff_count += 1;
-}
-
 /* Increment global variable. */
 /* Increment global variable. */
 int increment_stuff_count()
 int increment_stuff_count()
 {
 {
-  fib();
-  return 0;
+  return stuff_count += 1;
 }
 }