zkas: Compiler skeleton.

zkas/src/analyzer.rs

@@ -13,10 +13,10 @@ use crate::{
 pub struct Analyzer {
     file: String,
     lines: Vec<String>,
-    constants: Constants,
-    witnesses: Witnesses,
-    statements: Statements,
-    stack: Variables,
+    pub constants: Constants,
+    pub witnesses: Witnesses,
+    pub statements: Statements,
+    pub stack: Variables,
 }
 
 impl Analyzer {
@@ -203,9 +203,9 @@ impl Analyzer {
     }
 
     pub fn analyze_semantic(&mut self) {
-        println!("{:#?}", self.constants);
-        println!("{:#?}", self.witnesses);
-        println!("{:#?}", self.statements);
+        // println!("{:#?}", self.constants);
+        // println!("{:#?}", self.witnesses);
+        // println!("{:#?}", self.statements);
     }
 
     fn lookup_var(&self, name: &str) -> Option<Var> {

zkas/src/compiler.rs

@@ -0,0 +1,54 @@
+use std::str::Chars;
+
+use crate::ast::{Constants, Statements, Variables, Witnesses};
+
+pub struct Compiler {
+    file: String,
+    lines: Vec<String>,
+    constants: Constants,
+    witnesses: Witnesses,
+    statements: Statements,
+    stack: Variables,
+    debug_info: bool,
+}
+
+impl Compiler {
+    pub fn new(
+        filename: &str,
+        source: Chars,
+        constants: Constants,
+        witnesses: Witnesses,
+        statements: Statements,
+        stack: Variables,
+        debug_info: bool,
+    ) -> Self {
+        // For nice error reporting, we'll load everything into a string
+        // vector so we have references to lines.
+        let lines = source.as_str().lines().map(|x| x.to_string()).collect();
+        Compiler {
+            file: filename.to_string(),
+            lines,
+            constants,
+            witnesses,
+            statements,
+            stack,
+            debug_info,
+        }
+    }
+
+    pub fn compile(&self) -> Vec<u8> {
+        if self.debug_info {
+            return self.compile_with_debug_info()
+        }
+
+        self.compile_without_debug_info()
+    }
+
+    fn compile_with_debug_info(&self) -> Vec<u8> {
+        vec![]
+    }
+
+    fn compile_without_debug_info(&self) -> Vec<u8> {
+        vec![]
+    }
+}

zkas/src/lib.rs

@@ -2,6 +2,8 @@
 pub mod analyzer;
 /// AST
 pub mod ast;
+/// Compiler
+pub mod compiler;
 /// Lexer module
 pub mod lexer;
 /// Language opcodes

zkas/src/main.rs

@@ -2,7 +2,7 @@ use anyhow::Result;
 use clap::Parser as ClapParser;
 use std::fs::read_to_string;
 
-use zkas::{analyzer::Analyzer, lexer::Lexer, parser::Parser};
+use zkas::{analyzer::Analyzer, compiler::Compiler, lexer::Lexer, parser::Parser};
 
 #[derive(clap::Parser)]
 #[clap(name = "zkas", version)]
@@ -32,18 +32,34 @@ fn main() -> Result<()> {
     let lexer = Lexer::new(filename, source.chars());
     let tokens = lexer.lex();
 
-    // println!("{:#?}", tokens);
-
     let parser = Parser::new(filename, source.chars(), tokens);
     let (constants, witnesses, statements) = parser.parse();
 
-    // println!("{:#?}", constants);
-    // println!("{:#?}", witnesses);
-    // println!("{:#?}", statements);
-
     let mut analyzer = Analyzer::new(filename, source.chars(), constants, witnesses, statements);
     analyzer.analyze_types();
     analyzer.analyze_semantic();
 
+    if cli.evaluate {
+        println!("{:#?}", analyzer.constants);
+        println!("{:#?}", analyzer.witnesses);
+        println!("{:#?}", analyzer.statements);
+        println!("{:#?}", analyzer.stack);
+        return Ok(())
+    }
+
+    let compiler = Compiler::new(
+        filename,
+        source.chars(),
+        analyzer.constants,
+        analyzer.witnesses,
+        analyzer.statements,
+        analyzer.stack,
+        !cli.strip,
+    );
+
+    let bincode = compiler.compile();
+
+    println!("{:#?}", bincode);
+
     Ok(())
 }