add a few more options to cli, including ability to compile c and execute binary

Author: robertDurst

examples/stack.fish

@@ -31,7 +31,7 @@ Cfn Node {
     <- void
     -> int
     {
-	return own.data
+        return own.data
     }
 }
 
@@ -52,75 +52,81 @@ Cfn Stack {
     <- void
     -> int
     {
-	return own.size
+        return own.size
     }
 
     fun peek
     <- void
     -> int
     {
-    	// super hacky way of accessing methods on attributes
-	dec Node temp = new Node { next: void, data: 0 }
-	temp = own.head
-	return temp.data
+        // since return is at end, must declare a return value here
+        dec int i = 0
+        if | own...is_empty() == true | {
+            // do nothing
+        } else {
+            // super hacky way of accessing methods on attributes
+            dec Node temp = new Node { next: void, data: 0 }
+            temp = own.head
+            i = temp...data()            
+        }
+
+        return i
     }
 
 
     fun push
     <- Node node
     -> void
     {
-	if | is_empty == false | { own.head = node }
-	else {
-		node...set_next(own.head)
-		own.head = node
-	}
-
-	own.size = own.size + 1
+        node...set_next(own.head)
+        own.head = node
+        own.size = own.size + 1
     }
 
     fun pop
     <- void
     -> void
     {
-	if | is_empty == true | { }
-	else {
-		dec Node temp = new Node { next: void, data: 0 }
-		temp = own.head
-		own.head = temp...next()
-		
-		own.size = own.size - 1 
-	}
+        if | own...is_empty() == true | { }
+        else {
+            dec Node temp = new Node { next: void, data: 0 }
+            temp = own.head
+            own.head = temp...next()
+            
+            own.size = own.size - 1 
+        }
     }
 
     fun print_
     <- Node node
     -> void
     {
     	if | node!= void| {
-    	     display_int(node...data())
-	     display_str(" ")
-	     own...print_(node...next())
-	} 
+    	    display_int(node...data())
+	        display_str(" ")
+	        own...print_(node...next())
+	    } 
 
-	else {}
+	    else {}
     }
 
     fun print
     <- void
     -> void
     {
     	display_str("Stack contents: ")
-	own...print_(own.head)	
-	display_str("\n")
+        own...print_(own.head)	
+        display_str("\n")
     }
 }
 
 
 start {
-    dec Node a = new Node { next: void, data: 1 }
-    dec Node b = new Node { next: void, data: 2 }
-    dec Node c = new Node { next: void, data: 3 }
+    dec Node a = new Node { next: void, data: 10 }
+    dec Node b = new Node { next: void, data: 20 }
+    dec Node c = new Node { next: void, data: 30 }
+    dec Node d = new Node { next: void, data: 40 }
+    dec Node e = new Node { next: void, data: 50 }
 
     dec Stack s = new Stack { head: void, size: 0 }
 
@@ -136,6 +142,9 @@ start {
     display_int(s...peek())
     display_str("\n")
 
+    s...pop()
+    s...pop()
+    s...pop()
     s...pop()
     s...pop()
 
@@ -144,4 +153,11 @@ start {
     display_str("\tTop: ")
     display_int(s...peek())
     display_str("\n")
+
+    s...push(d)
+    s...push(e)
+    s...push(c)
+    s...push(b)
+
+     s...print()
 }

out.c

@@ -63,30 +63,32 @@ size(Stack* own)
 }
 int
 peek(Stack* own)
+{
+    int i = 0;
+    if(is_empty(own)==1)
+{
+
+}
+else 
 {
     Node*temp = construct_Node(NULL,0);
     temp = own->head;
-    return temp->data;
+    i = data(temp);
+}
+
+    return i;
 }
 void
 push(Stack* own, Node* node)
-{
-    if(is_empty==0)
-{
-    own->head = node;
-}
-else 
 {
     set_next(node, own->head);
     own->head = node;
-}
-
     own->size = own->size+1;
 }
 void
 pop(Stack* own)
 {
-    if(is_empty==1)
+    if(is_empty(own)==1)
 {
 
 }
@@ -124,24 +126,34 @@ print(Stack* own)
 int
 main()
 {
-    Node*a = construct_Node(NULL,1);
-    Node*b = construct_Node(NULL,2);
-    Node*c = construct_Node(NULL,3);
+    Node*a = construct_Node(NULL,10);
+    Node*b = construct_Node(NULL,20);
+    Node*c = construct_Node(NULL,30);
+    Node*d = construct_Node(NULL,40);
+    Node*e = construct_Node(NULL,50);
     Stack*s = construct_Stack(NULL,0);
     push(s, a);
     push(s, b);
     push(s, c);
     print(s);
     print_str("Size: ");
     print_int(size(s));
-    print_str("\tTop:");
+    print_str("\tTop: ");
     print_int(peek(s));
     print_str("\n");
     pop(s);
     pop(s);
+    pop(s);
+    pop(s);
+    pop(s);
     print_str("Size: ");
     print_int(size(s));
-    print_str("\tTop:");
+    print_str("\tTop: ");
     print_int(peek(s));
     print_str("\n");
+    push(s, d);
+    push(s, e);
+    push(s, c);
+    push(s, b);
+    print(s);
 }

src/main/CommandLine.cpp

@@ -14,8 +14,10 @@ helpMessage()
                  "\n\tsailfishc --help\n"
                  "\n\tsailfishc --version\n"
                  "\n\tsailfishc --lex_only [filename]\n"
-                 "\n\tsailfishc --parse_only [filename]\n\n"
-                 "\n\tsailfishc --semantic_analysis_only [filename]\n\n";
+                 "\n\tsailfishc --parse_only [filename]\n"
+                 "\n\tsailfishc --semantic_analysis_only [filename]\n"
+                 "\n\tsailfishc --compile_c [filename]\n"
+                 "\n\tsailfishc --compile_and_execute [filename]\n\n";
 }
 
 void
@@ -24,6 +26,32 @@ versionInfo()
     std::cout << "sailfishc 0.0.1\n";
 }
 
+bool
+compileC()
+{
+    // check to see if we can use system
+    if (!system(NULL))
+    {
+        std::cout << "System command processor doesn't exist. Please compile "
+                     "sailfishc generated C code yourself.\n";
+        return false;
+    }
+
+    std::cout << "EXECUTING: gcc out.c\n";
+    system("gcc out.c");
+
+    std::cout << "gcc compiled out.c to: a.out\n";
+
+    return true;
+}
+
+void
+executeBinary()
+{
+    std::cout << "EXECUTING: ./a.out.\n";
+    system("./a.out");
+}
+
 void
 fullCompilation(std::string filename)
 {
@@ -43,7 +71,7 @@ fullCompilation(std::string filename)
                                        s->getSymbolTable());
         t->transpile();
 
-        std::cout << "Success. Compiled to: out.c\n";
+        std::cout << "Success. sailfishc compiled " + filename + " to: out.c\n";
     }
     catch (const std::string msg)
     {
@@ -127,12 +155,36 @@ handleCommandLine(int argc, char* const* argv)
                 std::cerr << msg;
             }
         }
+        else if (std::string("--compile_c").compare(argv[1]) == 0)
+        {
+            // compile sailfish
+            fullCompilation(argv[2]);
+
+            // compile c
+            compileC();
+        }
+        else if (std::string("--compile_and_execute").compare(argv[1]) == 0)
+        {
+            // compile sailfish
+            fullCompilation(argv[2]);
+
+            // compile c
+            if (compileC())
+                // execute gcc generated binary
+                executeBinary();
+        }
+        else
+        {
+            std::cout
+                << "Unrecognized flag. "
+                   "Try again or type sailfishc to see command options!\n";
+        }
 
         return 0;
 
     default:
         std::cout << "Unexpected number of arguments. "
-                     "Try again or type sailfishc to see command opetions!\n";
+                     "Try again or type sailfishc to see command options!\n";
         return 0;
     }
 }

src/main/CommandLine.h

@@ -9,6 +9,7 @@
 #include "../semantics/SemanticAnalyzer.h"
 #include "../transpiler/Transpiler.h"
 #include <iostream>
+#include <stdlib.h>
 #include <string>
 
 int handleCommandLine(int, char* const* argv);