Fixed memory leaks & added cleanup to error exits

reltham · reltham · commit 4f2dc81a0803 · 2014-03-06T02:02:09.000-08:00
Fixed memory leaks in the preprocessor, and Hashtable code.
Added memory cleanup stuff to all the error exit paths.
diff --git a/PropellerCompiler/Utilities.h b/PropellerCompiler/Utilities.h
@@ -83,6 +83,10 @@ struct HashNode
 
     ~HashNode()
     {
+        if (pNext)
+        {
+            delete pNext;
+        }
         delete pValue;
     }
 };
diff --git a/SpinSource/openspin.cpp b/SpinSource/openspin.cpp
@@ -470,6 +470,18 @@ void ComposeRAM(unsigned char** ppBuffer, int& bufferSize, bool bDATonly, bool b
     }
 }
 
+void CleanupMemory()
+{
+    // cleanup
+    delete [] s_pCompilerData->list;
+    delete [] s_pCompilerData->doc;
+    delete [] s_pCompilerData->obj;
+    delete [] s_pCompilerData->source;
+    CleanObjectHeap();
+    CleanupPathEntries();
+    Cleanup();
+}
+
 int main(int argc, char* argv[])
 {
     char* infile = NULL;
@@ -511,6 +523,7 @@ int main(int argc, char* argv[])
                 else
                 {
                     Usage();
+                    CleanupMemory();
                     return 1;
                 }
                 AddPath(p);
@@ -528,12 +541,14 @@ int main(int argc, char* argv[])
                 else
                 {
                     Usage();
+                    CleanupMemory();
                     return 1;
                 }
                 sscanf(p, "%d", &eeprom_size);
                 if (eeprom_size > 16777216)
                 {
                     Usage();
+                    CleanupMemory();
                     return 1;
                 }
                 break;
@@ -550,6 +565,7 @@ int main(int argc, char* argv[])
                 else
                 {
                     Usage();
+                    CleanupMemory();
                     return 1;
                 }
                 break;
@@ -576,13 +592,15 @@ int main(int argc, char* argv[])
                     else
                     {
                         Usage();
+                        CleanupMemory();
                         return 1;
                     }
                     // just skipping these for now
                 }
                 else
                 {
                     Usage();
+                    CleanupMemory();
                     return 1;
                 }
                 break;
@@ -626,6 +644,7 @@ int main(int argc, char* argv[])
             case 'h':
             default:
                 Usage();
+                CleanupMemory();
                 return 1;
                 break;
             }
@@ -635,6 +654,7 @@ int main(int argc, char* argv[])
             if (infile)
             {
                 Usage();
+                CleanupMemory();
                 return 1;
             }
             infile = argv[i];
@@ -645,6 +665,7 @@ int main(int argc, char* argv[])
     if (!infile)
     {
         Usage();
+        CleanupMemory();
         return 1;
     }
 
@@ -678,6 +699,7 @@ int main(int argc, char* argv[])
                         else
                         {
                             Usage();
+                            CleanupMemory();
                             return 1;
                         }
                         // add any predefined symbols here - note that when using the 
@@ -688,6 +710,7 @@ int main(int argc, char* argv[])
                     else
                     {
                         Usage();
+                        CleanupMemory();
                         return 1;
                     }
                     break;
@@ -715,6 +738,7 @@ int main(int argc, char* argv[])
         {
             printf("ERROR: spinfile must have .spin extension. You passed in: %s\n", infile);
             Usage();
+            CleanupMemory();
             return 1;
         }
         else
@@ -786,6 +810,7 @@ int main(int argc, char* argv[])
 
     if (!CompileRecursively(infile, bQuiet, bFileTreeOutputOnly))
     {
+        CleanupMemory();
         return 1;
     }
 
@@ -940,14 +965,7 @@ int main(int argc, char* argv[])
         }
     }
 
-    // cleanup
-    delete [] s_pCompilerData->list;
-    delete [] s_pCompilerData->doc;
-    delete [] s_pCompilerData->obj;
-    delete [] s_pCompilerData->source;
-    CleanObjectHeap();
-    CleanupPathEntries();
-    Cleanup();
+    CleanupMemory();
 
     return 0;
 }
diff --git a/SpinSource/preprocess.c b/SpinSource/preprocess.c
@@ -853,6 +853,7 @@ pp_run(struct preprocess *pp)
             } else {
                 char *line = flexbuf_get(&pp->line);
                 flexbuf_addstr(&pp->whole, line);
+                free(line);
             }
         }
         pp_pop_file(pp);
@@ -863,6 +864,8 @@ char *
 pp_finish(struct preprocess *pp)
 {
     flexbuf_addchar(&pp->whole, 0);
+    pp_clear_define_state(pp);
+    flexbuf_delete(&pp->line);
     return flexbuf_get(&pp->whole);
 }
 
@@ -908,6 +911,25 @@ pp_restore_define_state(struct preprocess *pp, void *vp)
     pp->defs = x;
 }
 
+void
+pp_clear_define_state(struct preprocess *pp)
+{
+    struct predef *x, *old;
+
+    x = pp->defs;
+    while (x) {
+        old = x;
+        x = old->next;
+        if (old->flags & PREDEF_FLAG_FREEDEFS)
+        {
+            free((void *)old->name);
+            if (old->def) free((void *)old->def);
+        }
+        free(old);
+    }
+    pp->defs = 0;
+}
+
 #ifdef TEST
 char *
 preprocess(const char *filename, bool alternate)
diff --git a/SpinSource/preprocess.h b/SpinSource/preprocess.h
@@ -94,6 +94,9 @@ void *pp_get_define_state(struct preprocess *pp);
 /* restore the define state to the state given by a previous call to get_define_state */
 void pp_restore_define_state(struct preprocess *pp, void *ptr);
 
+/* clear all the define state */
+void pp_clear_define_state(struct preprocess *pp);
+
 /* actually perform the preprocessing on all files that have been pushed so far */
 void pp_run(struct preprocess *pp);
 

Original file line number	Diff line number	Diff line change
`@@ -83,6 +83,10 @@ struct HashNode`
`83`	`83`
`84`	`84`	`~HashNode()`
`85`	`85`	`{`
	`86`	`+ if (pNext)`
	`87`	`+ {`
	`88`	`+ delete pNext;`
	`89`	`+ }`
`86`	`90`	`delete pValue;`
`87`	`91`	`}`
`88`	`92`	`};`
Original file line number	Diff line number	Diff line change
`@@ -470,6 +470,18 @@ void ComposeRAM(unsigned char** ppBuffer, int& bufferSize, bool bDATonly, bool b`
`470`	`470`	`}`
`471`	`471`	`}`
`472`	`472`
	`473`	`+void CleanupMemory()`
	`474`	`+{`
	`475`	`+ // cleanup`
	`476`	`+ delete [] s_pCompilerData->list;`
	`477`	`+ delete [] s_pCompilerData->doc;`
	`478`	`+ delete [] s_pCompilerData->obj;`
	`479`	`+ delete [] s_pCompilerData->source;`
	`480`	`+ CleanObjectHeap();`
	`481`	`+ CleanupPathEntries();`
	`482`	`+ Cleanup();`
	`483`	`+}`
	`484`	`+`
`473`	`485`	`int main(int argc, char* argv[])`
`474`	`486`	`{`
`475`	`487`	`char* infile = NULL;`
`@@ -511,6 +523,7 @@ int main(int argc, char* argv[])`
`511`	`523`	`else`
`512`	`524`	`{`
`513`	`525`	`Usage();`
	`526`	`+ CleanupMemory();`
`514`	`527`	`return 1;`
`515`	`528`	`}`
`516`	`529`	`AddPath(p);`
`@@ -528,12 +541,14 @@ int main(int argc, char* argv[])`
`528`	`541`	`else`
`529`	`542`	`{`
`530`	`543`	`Usage();`
	`544`	`+ CleanupMemory();`
`531`	`545`	`return 1;`
`532`	`546`	`}`
`533`	`547`	`sscanf(p, "%d", &eeprom_size);`
`534`	`548`	`if (eeprom_size > 16777216)`
`535`	`549`	`{`
`536`	`550`	`Usage();`
	`551`	`+ CleanupMemory();`
`537`	`552`	`return 1;`
`538`	`553`	`}`
`539`	`554`	`break;`
`@@ -550,6 +565,7 @@ int main(int argc, char* argv[])`
`550`	`565`	`else`
`551`	`566`	`{`
`552`	`567`	`Usage();`
	`568`	`+ CleanupMemory();`
`553`	`569`	`return 1;`
`554`	`570`	`}`
`555`	`571`	`break;`
`@@ -576,13 +592,15 @@ int main(int argc, char* argv[])`
`576`	`592`	`else`
`577`	`593`	`{`
`578`	`594`	`Usage();`
	`595`	`+ CleanupMemory();`
`579`	`596`	`return 1;`
`580`	`597`	`}`
`581`	`598`	`// just skipping these for now`
`582`	`599`	`}`
`583`	`600`	`else`
`584`	`601`	`{`
`585`	`602`	`Usage();`
	`603`	`+ CleanupMemory();`
`586`	`604`	`return 1;`
`587`	`605`	`}`
`588`	`606`	`break;`
`@@ -626,6 +644,7 @@ int main(int argc, char* argv[])`
`626`	`644`	`case 'h':`
`627`	`645`	`default:`
`628`	`646`	`Usage();`
	`647`	`+ CleanupMemory();`
`629`	`648`	`return 1;`
`630`	`649`	`break;`
`631`	`650`	`}`
`@@ -635,6 +654,7 @@ int main(int argc, char* argv[])`
`635`	`654`	`if (infile)`
`636`	`655`	`{`
`637`	`656`	`Usage();`
	`657`	`+ CleanupMemory();`
`638`	`658`	`return 1;`
`639`	`659`	`}`
`640`	`660`	`infile = argv[i];`
`@@ -645,6 +665,7 @@ int main(int argc, char* argv[])`
`645`	`665`	`if (!infile)`
`646`	`666`	`{`
`647`	`667`	`Usage();`
	`668`	`+ CleanupMemory();`
`648`	`669`	`return 1;`
`649`	`670`	`}`
`650`	`671`
`@@ -678,6 +699,7 @@ int main(int argc, char* argv[])`
`678`	`699`	`else`
`679`	`700`	`{`
`680`	`701`	`Usage();`
	`702`	`+ CleanupMemory();`
`681`	`703`	`return 1;`
`682`	`704`	`}`
`683`	`705`	`// add any predefined symbols here - note that when using the`
`@@ -688,6 +710,7 @@ int main(int argc, char* argv[])`
`688`	`710`	`else`
`689`	`711`	`{`
`690`	`712`	`Usage();`
	`713`	`+ CleanupMemory();`
`691`	`714`	`return 1;`
`692`	`715`	`}`
`693`	`716`	`break;`
`@@ -715,6 +738,7 @@ int main(int argc, char* argv[])`
`715`	`738`	`{`
`716`	`739`	`printf("ERROR: spinfile must have .spin extension. You passed in: %s\n", infile);`
`717`	`740`	`Usage();`
	`741`	`+ CleanupMemory();`
`718`	`742`	`return 1;`
`719`	`743`	`}`
`720`	`744`	`else`
`@@ -786,6 +810,7 @@ int main(int argc, char* argv[])`
`786`	`810`
`787`	`811`	`if (!CompileRecursively(infile, bQuiet, bFileTreeOutputOnly))`
`788`	`812`	`{`
	`813`	`+ CleanupMemory();`
`789`	`814`	`return 1;`
`790`	`815`	`}`
`791`	`816`
`@@ -940,14 +965,7 @@ int main(int argc, char* argv[])`
`940`	`965`	`}`
`941`	`966`	`}`
`942`	`967`
`943`		`- // cleanup`
`944`		`- delete [] s_pCompilerData->list;`
`945`		`- delete [] s_pCompilerData->doc;`
`946`		`- delete [] s_pCompilerData->obj;`
`947`		`- delete [] s_pCompilerData->source;`
`948`		`- CleanObjectHeap();`
`949`		`- CleanupPathEntries();`
`950`		`- Cleanup();`
	`968`	`+ CleanupMemory();`
`951`	`969`
`952`	`970`	`return 0;`
`953`	`971`	`}`