From 044d0814cacbcd3f3869276583cd566da182b0b2 Mon Sep 17 00:00:00 2001
From: Peter Wu <lekensteyn@gmail.com>
Date: Sat, 3 Dec 2011 15:11:13 +0000
Subject: Fix error when initializing an array and with constant init

---
 pp2cc.py | 30 +++++++++++++-----------------
 1 file changed, 13 insertions(+), 17 deletions(-)

diff --git a/pp2cc.py b/pp2cc.py
index bc9259f..9420de3 100755
--- a/pp2cc.py
+++ b/pp2cc.py
@@ -1032,7 +1032,6 @@ class Parse(object):
                 except RuntimeError as errmsg:
                     self.logger.error(errmsg, linked_node=linked_node)
 
-            init_vals = []
             linked_init = LinkedNode(linked_node.node.init, linked_node)
             if (linked_type.type == "ArrayDecl" and
                 linked_init.type == "ExprList"):
@@ -1045,7 +1044,7 @@ class Parse(object):
                         # only constant expressions are allowed in array init
                         init_val = str(self.determineConstValue(linked_arrelm))
                         if in_function:
-                            init_vals.append(self.asm.binary_op("LOAD",
+                            lines.append(self.asm.binary_op("LOAD",
                                 reg_value, init_val))
                         else:
                             # +1 because the first element is reserved for pointer
@@ -1056,37 +1055,36 @@ class Parse(object):
                         if not in_function:
                             self.logger.error(errmsg, linked_node=linked_arrelm)
 
-                        init_vals.append(self.asm.push(reg_array))
+                        lines.append(self.asm.push(reg_array))
                         init_val = self.parseExpression(array_elm, linked_init)
                         # if the result register has changed, update
                         res_reg = self.registers.find_register(init_val, fatal=True)
-                        init_vals += init_val
+                        lines += init_val
 
                         # swap registers if the result would be overwritten
                         if res_reg == reg_array:
                             reg_value, reg_array = reg_array, res_value
-                        init_vals.append(self.asm.pull(reg_array))
+                        lines.append(self.asm.pull(reg_array))
 
                         # store the array element in the array instead of the
                         # pointer itself
-                        init_vals.append(self.asm.binary_op("LOAD", reg_value,
+                        lines.append(self.asm.binary_op("LOAD", reg_value,
                                                            init_val))
                     if in_function:
                         # save the value to the array's base address + index
-                        init_vals.append(self.asm.binary_op("STOR", reg_value,
+                        lines.append(self.asm.binary_op("STOR", reg_value,
                              "[" + reg_array + "+" + str(array_index) + "]"))
 
                     array_index += 1
                     # ignore elements which do not fit in the allocated space
                     if array_index > size:
                         break
-                if init_vals:
-                    init_vals = pre_init + init_vals
             else:
+                result_reg = self.registers.next_free()
                 try:
                     init_val = str(self.determineConstValue(linked_init))
                     if in_function:
-                        init_vals.append(self.asm.binary_op("LOAD", result_reg,
+                        lines.append(self.asm.binary_op("LOAD", result_reg,
                                                             init_val))
                     else:
                         self.varNames[var_disp][0] = init_val
@@ -1098,16 +1096,14 @@ class Parse(object):
                     init_vals = self.parseExpression(linked_node.node.init,
                                                  linked_node)
                     result_reg = self.registers.find_register(init_vals)
+                    lines += init_vals
+
                 if in_function:
-                    init_vals.append(self.asm.binary_op("STOR", result_reg,
+                    lines.append(self.asm.binary_op("STOR", result_reg,
                                                         "[" + var_reg + "+" +
                                                         var_disp + "]"))
-
-            # if global context (i.e. not in a function)
-            if not in_function:
-                self.globalInit += init_vals
-            else:
-                lines += init_vals
+        # if not in a function (in global scope), the only lines that may be
+        # returned are initialization of the array pointer address
         return lines
     def parseBreak(self, linked_node):
         loop_node = linked_node.getBreakNode()
-- 
cgit v1.2.1