src/compiler/backend/mod.rs

@@ -2,10 +2,12 @@
 mod tests;
 
 use crate::compiler::{
-    AddressingModel, ExecutionMode, ExecutionModel, MemoryModel, Module, StorageClass,
+    AddressingModel, BuiltinDecoration, Decoration, ExecutionMode, ExecutionModel, Instruction,
+    MemoryModel, Module, StorageClass,
 };
 use std::fmt;
-use std::fmt::Write;
+
+use crate::parser::Ast;
 
 #[derive(Debug, PartialEq, Clone)]
 pub enum Type {
@@ -42,48 +44,43 @@ pub fn parse_type(typ: &String) -> Type {
     // So, *v4f32i is a pointer to a vector of 4 floats, with the storage class Input.
     // *v4f32o is a pointer to a vector of 4 floats, with the storage class Output.
 
-    let c = typ.chars().next().unwrap();
-    match c {
-        '<' => {
+    let mut chars = typ.chars();
+    match chars.next() {
+        Some('<') => {
             assert_eq!(typ.as_str(), "<>");
             Type::Void
         }
-        '*' => {
-            let mut chars = typ.chars();
-            chars.next();
-            let typ = chars.collect::<String>();
-            let storage_class = match typ.chars().last().unwrap() {
-                'i' => StorageClass::Input,
-                'o' => StorageClass::Output,
+        Some('*') => {
+            let mut typ = chars.collect::<String>();
+            let storage_class = match typ.pop() {
+                Some('i') => StorageClass::Input,
+                Some('o') => StorageClass::Output,
                 _ => panic!("Invalid storage class"),
             };
-            let typ = typ.chars().take(typ.len() - 1).collect::<String>();
             Type::Pointer(Box::new(parse_type(&typ)), storage_class)
         }
-        'v' => {
-            let mut chars = typ.chars();
-            chars.next();
-            let size = chars.next().unwrap().to_digit(10).unwrap();
+        Some('v') => {
+            let size = chars.next().map(|s| s.to_digit(10)).flatten().unwrap();
             let typ = chars.collect::<String>();
             Type::Vector(Box::new(parse_type(&typ)), size)
         }
-        'f' => {
-            let size = typ.chars().skip(1).collect::<String>().parse().unwrap();
+        Some('f') => {
+            let size = chars.collect::<String>().parse().unwrap();
             Type::Float(size)
         }
-        's' => {
-            let size = typ.chars().skip(1).collect::<String>().parse().unwrap();
+        Some('s') => {
+            let size = chars.collect::<String>().parse().unwrap();
             Type::Int(size)
         }
-        'u' => {
-            let size = typ.chars().skip(1).collect::<String>().parse().unwrap();
+        Some('u') => {
+            let size = chars.collect::<String>().parse().unwrap();
             Type::Unsigned(size)
         }
         _ => panic!("Invalid type"),
     }
 }
 
-fn emit_type(typ: Type, ops: &mut Vec<(String, String)>) {
+fn emit_type(typ: &Type, ops: &mut Vec<(String, String)>) {
     match &typ {
         Type::Void => {
             ops.push(("%void".to_string(), "OpTypeVoid".to_string()));
@@ -107,18 +104,14 @@ fn emit_type(typ: Type, ops: &mut Vec<(String, String)>) {
             ));
         }
         Type::Vector(in_typ, size) => {
-            emit_type(*in_typ.clone(), ops);
+            emit_type(in_typ, ops);
             ops.push((
                 fix_name(&typ.to_string()),
-                format!(
-                    "OpTypeVector {} {}",
-                    fix_name(&in_typ.clone().to_string()),
-                    size
-                ),
+                format!("OpTypeVector {} {}", fix_name(&in_typ.to_string()), size),
             ))
         }
         Type::Pointer(in_typ, storage_class) => {
-            emit_type(*in_typ.clone(), ops);
+            emit_type(in_typ, ops);
             let typ_id = fix_name(&typ.to_string());
             let storage_class = match storage_class {
                 StorageClass::Input => "Input",
@@ -137,27 +130,23 @@ fn emit_type(typ: Type, ops: &mut Vec<(String, String)>) {
     }
 }
 
-fn fix_name(name: &String) -> String {
+fn fix_name(name: &str) -> String {
     format!(
         "%{}",
-        name.clone()
-            .replace("-", "_")
+        name.replace("-", "_")
             .replace("*", "p")
             .replace("<>", "void")
+            .replace(".", "_")
     )
 }
 
-fn has_id(name: String, ops: &Vec<(Option<String>, Vec<String>)>) -> bool {
-    for op in ops {
-        if op.0.is_some() && op.0.clone().unwrap() == name {
-            return true;
-        }
-    }
-    false
+fn has_id<T>(name: &str, ops: &Vec<(Option<String>, T)>) -> bool {
+    ops.iter()
+        .find(|op| op.0.as_ref().map(|s| *s == name).unwrap_or(false))
+        .is_some()
 }
 
-pub fn spirv_meta(module: Module) -> String {
-    let mut spirv_asm = String::new();
+pub fn spirv_meta(module: &mut Module) -> Vec<(Option<String>, Vec<String>)> {
     let mut ops: Vec<(Option<String>, Vec<String>)> = Vec::new();
 
     let capabilities: Vec<String> = module
@@ -190,7 +179,7 @@ pub fn spirv_meta(module: Module) -> String {
         ],
     ));
 
-    for entry in module.entry_points {
+    for entry in module.entry_points.clone() {
         let exec_model = match entry.execution_model {
             ExecutionModel::Fragment => "Fragment",
             ExecutionModel::Vertex => "Vertex",
@@ -223,8 +212,25 @@ pub fn spirv_meta(module: Module) -> String {
             ],
         ));
     }
+    for global in module.globals.clone() {
+        let name: String = fix_name(&global.name);
+
+        for dec in global.decorations {
+            // Decorations have the format Location 0, or Builtin FragCoord
+            let dec = match dec {
+                crate::compiler::Decoration::Location(loc) => format!("Location {}", loc),
+                crate::compiler::Decoration::BuiltIn(builtin) => {
+                    let builtin = match builtin {
+                        crate::compiler::BuiltinDecoration::FragCoord => "FragCoord",
+                    };
+                    format!("BuiltIn {}", builtin)
+                }
+            };
+            ops.push((None, vec!["OpDecorate".to_string(), name.clone(), dec]));
+        }
+    }
 
-    for global in module.globals {
+    for global in module.globals.clone() {
         let name = fix_name(&global.name);
         let typ = global.typ;
         let storage_class = match global.storage_class {
@@ -233,9 +239,9 @@ pub fn spirv_meta(module: Module) -> String {
             StorageClass::Undefined => panic!("Bound a non-declared variable"),
         };
         let mut type_ops = Vec::new();
-        emit_type(parse_type(&typ), &mut type_ops);
+        emit_type(&parse_type(&typ), &mut type_ops);
         for op in type_ops {
-            if has_id(op.0.clone(), &ops) {
+            if has_id(&op.0, &ops) {
                 continue;
             }
             ops.push((Some(op.0), vec![op.1]));
@@ -248,47 +254,419 @@ pub fn spirv_meta(module: Module) -> String {
                 storage_class.to_string(),
             ],
         ));
-        for dec in global.decorations {
-            // Decorations have the format Location 0, or Builtin FragCoord
-            let dec = match dec {
-                crate::compiler::Decoration::Location(loc) => format!("Location {}", loc),
-                crate::compiler::Decoration::BuiltIn(builtin) => {
-                    let builtin = match builtin {
-                        crate::compiler::BuiltinDecoration::FragCoord => "FragCoord",
-                    };
-                    format!("BuiltIn {}", builtin)
-                }
-            };
-            ops.push((None, vec!["OpDecorate".to_string(), name.clone(), dec]));
-        }
     }
 
-    for fun in module.functions {
-        let name = fix_name(&fun.name);
+    for fun in module.functions.clone() {
+        let name = fix_name(&format!("l_{}", fun.name));
         let return_type = fix_name(&fun.return_type);
         let mut type_ops = Vec::new();
-        emit_type(parse_type(&fun.return_type), &mut type_ops);
+        emit_type(&parse_type(&fun.return_type), &mut type_ops);
         for op in type_ops {
-            if has_id(op.0.clone(), &ops) {
+            if has_id(&op.0, &ops) {
                 continue;
             }
             ops.push((Some(op.0), vec![op.1]));
         }
         // Push OpFunctionType
-        ops.push((
-            Some(name.clone()),
-            vec!["OpTypeFunction".to_string(), return_type.clone()],
-        ));
+        ops.push((Some(name), vec!["OpTypeFunction".to_string(), return_type]));
     }
 
-    for op in ops {
-        if op.0.is_some() {
-            write!(spirv_asm, "{} = ", op.0.unwrap()).unwrap();
+    // for op in ops {
+    //     if op.0.is_some() {
+    //         write!(spirv_asm, "{} = ", op.0.unwrap()).unwrap();
+    //     }
+    //     for arg in op.1 {
+    //         write!(spirv_asm, "{} ", arg).unwrap();
+    //     }
+    //     writeln!(spirv_asm).unwrap();
+    // }
+    // spirv_asm
+    ops
+}
+
+enum Number {
+    Int(i32),
+    Float(f32),
+    NotANumber,
+}
+
+fn match_number(s: &str) -> Number {
+    // floats have to be in the format of [0-9]+\.[0-9]*
+    // integers have to be in the format of [0-9]+
+    let mut chars = s.chars();
+    let mut has_dot = false;
+    while let Some(c) = chars.next() {
+        if c == '.' {
+            if has_dot {
+                // only one dot allowed.
+                return Number::NotANumber;
+            }
+            has_dot = true;
+        } else if !c.is_digit(10) {
+            // not a number;
+            // has a character that is not a digit or a dot.
+            return Number::NotANumber;
         }
-        for arg in op.1 {
-            write!(spirv_asm, "{} ", arg).unwrap();
+    }
+    if has_dot {
+        // we have checked that the whole thing is numbers and dots
+        // and that there is precisely one dot
+        // that matches the regex.
+        Number::Float(s.parse().unwrap())
+    } else {
+        // this is an integer, since no dots.
+        Number::Int(s.parse().unwrap())
+    }
+}
+
+fn compile_biop(
+    op: &str,
+    lst: &mut Vec<Ast>,
+    vars: &mut Vec<(String, String)>,
+    constants: &mut Vec<(String, String)>,
+    types: &mut Vec<String>,
+    counter: &mut i32,
+    stack: &mut Vec<String>,
+    out: &mut Vec<(Option<String>, String)>,
+    typ: &str,
+) {
+    assert!(lst.len() == 2);
+    let rhs = lst.pop().unwrap();
+    let lhs = lst.pop().unwrap();
+    compile_ast_ssa(lhs, vars, constants, types, counter, stack, out);
+    compile_ast_ssa(rhs, vars, constants, types, counter, stack, out);
+    let rhs_id = stack.pop().unwrap();
+    let lhs_id = stack.pop().unwrap();
+    let id = String::from(counter.to_string());
+    *counter += 1;
+    out.push((
+        Some(id.clone()),
+        format!(
+            "{} {} {} {}",
+            op,
+            fix_name(&String::from(typ)),
+            fix_name(&lhs_id),
+            fix_name(&rhs_id),
+        ),
+    ));
+    stack.push(id);
+}
+
+fn compile_comp_constr(
+    lst: &mut Vec<Ast>,
+    vars: &mut Vec<(String, String)>,
+    constants: &mut Vec<(String, String)>,
+    types: &mut Vec<String>,
+    counter: &mut i32,
+    stack: &mut Vec<String>,
+    out: &mut Vec<(Option<String>, String)>,
+    typ: &str,
+) {
+    types.push(String::from(typ));
+    let typ_parsed = parse_type(&String::from(typ));
+    match typ_parsed {
+        Type::Vector(_, size) => {
+            assert!(lst.len() == size as usize);
+            let mut inners: Vec<String> = vec![];
+            for _ in 0..size {
+                let ast = lst.pop().unwrap();
+                compile_ast_ssa(ast, vars, constants, types, counter, stack, out);
+                let res_id = stack.pop().unwrap();
+                inners.push(res_id);
+            }
+            let id = String::from(counter.to_string());
+            *counter += 1;
+            let mut out_str = String::new();
+            out_str.push_str(
+                format!("OpCompositeConstruct {}", fix_name(&String::from(typ))).as_str(),
+            );
+            inners.reverse();
+            for inn in inners {
+                out_str.push_str(format!(" {}", fix_name(&inn)).as_str());
+            }
+            out.push((Some(id.clone()), out_str));
+            stack.push(id);
+        }
+        _ => {
+            panic!("Invalid vector!")
+        }
+    }
+}
+
+fn compile_comp_extract(
+    lst: &mut Vec<Ast>,
+    vars: &mut Vec<(String, String)>,
+    constants: &mut Vec<(String, String)>,
+    types: &mut Vec<String>,
+    counter: &mut i32,
+    stack: &mut Vec<String>,
+    out: &mut Vec<(Option<String>, String)>,
+    typ: &str,
+    inx: u32,
+) {
+    assert!(lst.len() == 1);
+    let vec = lst.pop().unwrap();
+    compile_ast_ssa(vec, vars, constants, types, counter, stack, out);
+    let vec_id = stack.pop().unwrap();
+    let id = counter.to_string();
+    *counter += 1;
+    out.push((
+        Some(id.clone()),
+        format!(
+            "OpCompositeExtract {} {} {}",
+            fix_name(&String::from(typ)),
+            fix_name(&vec_id),
+            inx
+        ),
+    ));
+    stack.push(id);
+}
+
+pub fn compile_ast_ssa(
+    ast: Ast,
+    vars: &mut Vec<(String, String)>,
+    constants: &mut Vec<(String, String)>,
+    types: &mut Vec<String>,
+    counter: &mut i32,
+    stack: &mut Vec<String>,
+    out: &mut Vec<(Option<String>, String)>,
+) {
+    match ast.clone().list() {
+        Some(mut lst) => {
+            assert!(!lst.is_empty());
+            let fun = lst.remove(0);
+            assert!(true); // no safe remove, thanks Rust
+            let fun_name = fun.symbol();
+            assert!(fun_name.is_some());
+            let fun_name = fun_name.unwrap();
+            if fun_name.starts_with(".") {
+                let to_split = &fun_name[1..fun_name.len()];
+                let split = to_split.split("-").collect::<Vec<&str>>();
+                assert!(split.len() == 2);
+                let inx = split[0];
+                let typ = split[1];
+                let inx = str::parse::<u32>(inx).expect("Invalid index!");
+                compile_comp_extract(
+                    &mut lst, vars, constants, types, counter, stack, out, typ, inx,
+                );
+                return;
+            }
+
+            if fun_name.starts_with("/") {
+                let typ = &fun_name[1..fun_name.len()];
+                compile_biop(
+                    "OpFDiv", &mut lst, vars, constants, types, counter, stack, out, typ,
+                );
+                return;
+            }
+
+            if fun_name.starts_with("*") {
+                let typ = &fun_name[1..fun_name.len()];
+                compile_biop(
+                    "OpFMul", &mut lst, vars, constants, types, counter, stack, out, typ,
+                );
+                return;
+            }
+
+            if fun_name.starts_with("+") {
+                let typ = &fun_name[1..fun_name.len()];
+                compile_biop(
+                    "OpFAdd", &mut lst, vars, constants, types, counter, stack, out, typ,
+                );
+                return;
+            }
+
+            if fun_name.starts_with("-") {
+                let typ = &fun_name[1..fun_name.len()];
+                compile_biop(
+                    "OpFSub", &mut lst, vars, constants, types, counter, stack, out, typ,
+                );
+                return;
+            }
+
+            if fun_name.starts_with("v") {
+                compile_comp_constr(
+                    &mut lst,
+                    vars,
+                    constants,
+                    types,
+                    counter,
+                    stack,
+                    out,
+                    fun_name.as_str(),
+                );
+                return;
+            }
+
+            if fun_name.starts_with("load-ptr-") {
+                let typ = &fun_name[9..fun_name.len()];
+                assert!(lst.len() == 1);
+                let ptr = lst.pop().unwrap();
+                compile_ast_ssa(ptr, vars, constants, types, counter, stack, out);
+                let ptr_id = stack.pop().unwrap();
+                let id: String = counter.to_string();
+                *counter += 1;
+                out.push((
+                    Some(id.clone()),
+                    format!(
+                        "OpLoad {} {}",
+                        fix_name(&String::from(typ)),
+                        fix_name(&ptr_id)
+                    ),
+                ));
+                stack.push(id);
+                return;
+            }
+
+            match fun_name.as_str() {
+                "store-ptr" => {
+                    assert!(lst.len() == 2);
+                    let val = lst.pop().unwrap();
+                    let ptr = lst.pop().unwrap();
+                    compile_ast_ssa(val, vars, constants, types, counter, stack, out);
+                    compile_ast_ssa(ptr, vars, constants, types, counter, stack, out);
+                    let val_id = stack.pop().unwrap();
+                    let ptr_id = stack.pop().unwrap();
+                    out.push((
+                        None,
+                        format!("OpStore {} {}", fix_name(&val_id), fix_name(&ptr_id)),
+                    ));
+                }
+                s => {
+                    panic!(
+                        "Unknown function: {} with params {:#?} in context:\n{:#?}",
+                        s, lst, ast
+                    );
+                }
+            }
+        }
+        None => {
+            let sym = ast.symbol().expect("This must be a symbol");
+            match match_number(&sym) {
+                Number::Int(i) => {
+                    let key = format!("i32_{}", i);
+                    let mut contains = false;
+                    for c in constants.iter() {
+                        if c.0 == key {
+                            contains = true;
+                        }
+                    }
+                    if !contains {
+                        constants.push((key.clone(), format!("OpConstant %i32 {}", i.to_string())));
+                    }
+                    stack.push(key);
+                }
+                Number::Float(f) => {
+                    let key = format!("f32_{}", f);
+                    let mut contains = false;
+                    for c in constants.iter() {
+                        if c.0 == key {
+                            contains = true;
+                        }
+                    }
+                    if !contains {
+                        constants.push((key.clone(), format!("OpConstant %f32 {}", f.to_string())));
+                    }
+                    for t in types.iter() {
+                        if t == "f32" {
+                            contains = true;
+                        }
+                    }
+                    if !contains {
+                        types.push("f32".to_string());
+                    }
+                    stack.push(key);
+                }
+                Number::NotANumber => {
+                    for v in vars.iter() {
+                        if v.0 == sym {
+                            stack.push(v.0.clone());
+                            return;
+                        }
+                    }
+                    panic!("Unknown variable or constant: {}", sym);
+                }
+            }
+        }
+    }
+}
+
+pub fn compile_fun_ssa(module: &mut Module, ops: &Vec<(Option<String>, String)>) {
+    let mut label_counter = Box::new(0);
+    for fun in module.functions.iter_mut() {
+        assert!(fun.ast.is_some());
+        let ast = fun.ast.as_mut().unwrap();
+        let block = ast.clone().list().unwrap().get(0).unwrap().clone();
+        let mut vars = vec![];
+        let mut constants = vec![];
+        let mut types = vec![];
+        let mut counter = Box::new(0);
+        let mut stack = vec![];
+        let mut out_op = vec![];
+        for v in &module.globals {
+            vars.push((v.name.clone(), v.typ.clone()));
+        }
+        compile_ast_ssa(
+            block,
+            &mut vars,
+            &mut constants,
+            &mut types,
+            &mut counter,
+            &mut stack,
+            &mut out_op,
+        );
+        let mut out_pre = vec![];
+        for t in &types {
+            let typ = parse_type(t);
+            if has_id(&fix_name(&typ.to_string()), ops) {
+                continue;
+            }
+            if has_id(&fix_name(&typ.to_string()), &out_pre) {
+                continue;
+            }
+            let mut type_ops = vec![];
+            emit_type(&typ, &mut type_ops);
+            for type_op in type_ops {
+                out_pre.push((Some(type_op.0), type_op.1));
+            }
+        }
+        for c in &constants {
+            out_pre.push((Some(fix_name(&c.0.clone())), c.1.clone()));
+        }
+
+        // TODO non-void type
+        out_pre.push((
+            Some(fix_name(&fun.name)),
+            format!("OpFunction %void None %l_{}", fun.name),
+        ));
+        out_pre.push((
+            Some(format!("%n_{}", label_counter.to_string())),
+            "OpLabel".to_string(),
+        ));
+        *label_counter += 1;
+        let mut out_ops = out_pre.clone();
+        for op in out_op {
+            if op.0.is_some() {
+                out_ops.push((Some(fix_name(&op.0.unwrap())), op.1));
+            } else {
+                out_ops.push((None, op.1));
+            }
+        }
+
+        out_ops.push((None, String::from("OpReturn")));
+        out_ops.push((None, String::from("OpFunctionEnd")));
+
+        for op in out_ops {
+            let split: Vec<String> = op.1.split(" ").map(|s| s.to_string()).collect();
+            let op_name: String = (&split[0]).clone();
+            let op_args: Vec<String> = split[1..].iter().map(|s| s.clone()).collect();
+            let op_id = op.0.clone();
+            let ins: Instruction = Instruction {
+                result_id: op_id,
+                op: op_name,
+                operands: op_args,
+            };
+            fun.body.as_mut().unwrap().push(ins);
         }
-        writeln!(spirv_asm).unwrap();
     }
-    spirv_asm
 }

src/compiler/backend/tests.rs

@@ -12,16 +12,17 @@ fn test_emit() {
 (dec out-color:*v4f32o Output)
 (entry main Fragment OriginUpperLeft (:frag-coord :out-color))
 (fun (main) :<>
-  (store-ptr (out-color)
+  (store-ptr out-color
     (v4f32i (/ (.xy (load-ptr frag-coord))
                (v2f32 1920.0 1080.0)) 
             1.0 
             1.0)))
 ";
     let ast = parse(tokenize(src));
-    let module = meta_compile(ast.unwrap()).unwrap();
-    let res = spirv_meta(module);
-    println!("{}", res);
+    let mut module = meta_compile(ast.unwrap()).unwrap();
+    let res = spirv_meta(&mut module);
+    println!("{:#?}", res);
+    // TODO add an assert
 }
 
 #[test]
@@ -49,3 +50,161 @@ fn test_type_parse() {
     assert_eq!(parse_type(&"f32".to_string()), Float(32));
     assert_eq!(parse_type(&"s32".to_string()), Int(32));
 }
+
+#[test]
+fn test_block_ssa() {
+    use crate::compiler::backend::*;
+    use crate::compiler::*;
+    use crate::parser::*;
+    let src = "
+    (module Shader Logical GLSL450)
+(import :std GLSL.std.450)
+(bind (out-color:*f32o) (Location 0))
+(dec out-color:*f32o Output)
+(entry main Fragment OriginUpperLeft (:out-color))
+(fun (main) :<>
+  (store-ptr out-color (/f32 1.0 (+f32 1.0 1.0))))
+";
+    let ast = parse(tokenize(src));
+    let mut module = meta_compile(ast.unwrap()).unwrap();
+    let fun = module.functions.pop().unwrap();
+    let block = fun.ast.unwrap();
+    let block = block.list().unwrap().get(0).unwrap().clone();
+    println!("{:#?}", block);
+    let mut vars = vec![];
+    let mut constants = vec![];
+    let mut types = vec![];
+    let mut counter = Box::new(0);
+    let mut stack = vec![];
+    let mut out = vec![];
+    for v in &module.globals {
+        vars.push((v.name.clone(), v.typ.clone()));
+    }
+    compile_ast_ssa(
+        block,
+        &mut vars,
+        &mut constants,
+        &mut types,
+        &mut counter,
+        &mut stack,
+        &mut out,
+    );
+    println!("\n---vars:---\n{:#?}\n-----------", vars);
+    println!("\n---constants:---\n{:#?}\n----------------", constants);
+    println!("\n---types:---\n{:#?}\n------------", types);
+    println!("\n---stack:---\n{:#?}\n------------", stack);
+    println!("\n---counter:---\n{}\n--------------", counter);
+    println!("\n---out:---");
+    for (a, b) in &out {
+        match a {
+            Some(a) => println!("%{} = {}", a, b),
+            None => println!("{}", b),
+        }
+    }
+    println!("----------");
+    assert!(stack.is_empty());
+}
+
+#[test]
+fn test_fun_ssa() {
+    use crate::compiler::backend::*;
+    use crate::compiler::*;
+    use crate::parser::*;
+    let src = "
+        (module Shader Logical GLSL450)
+        (import :std GLSL.std.450)
+        (bind (out-color:*f32o) (Location 0))
+        (dec out-color:*f32o Output)
+        (entry main Fragment OriginUpperLeft (:out-color))
+        (fun (main) :<>
+            (store-ptr out-color (/f32 1.0 (+f32 1.0 1.0))))
+";
+    let ast = parse(tokenize(src));
+    let mut module = meta_compile(ast.unwrap()).unwrap();
+    let ops = vec![];
+    compile_fun_ssa(&mut module, &ops);
+    let res = module.functions.pop().unwrap();
+    let res = res.body.unwrap();
+    println!("{:#?}", res);
+    // TODO we need to unify the place where we call fix_name
+    let res_spv: Vec<Instruction> = vec![
+        Instruction {
+            result_id: Some("%f32".to_string()),
+            op: "OpTypeFloat".to_string(),
+            operands: vec!["32".to_string()],
+        },
+        Instruction {
+            result_id: Some("%f32_1".to_string()),
+            op: "OpConstant".to_string(),
+            operands: vec!["%f32".to_string(), "1".to_string()],
+        },
+        Instruction {
+            result_id: Some("%main".to_string()),
+            op: "OpFunction".to_string(),
+            operands: vec![
+                "%void".to_string(),
+                "None".to_string(),
+                "%l_main".to_string(),
+            ],
+        },
+        Instruction {
+            result_id: Some("%n_0".to_string()),
+            op: "OpLabel".to_string(),
+            operands: vec![],
+        },
+        Instruction {
+            result_id: Some("%0".to_string()),
+            op: "OpFAdd".to_string(),
+            operands: vec![
+                "%f32".to_string(),
+                "%f32_1".to_string(),
+                "%f32_1".to_string(),
+            ],
+        },
+        Instruction {
+            result_id: Some("%1".to_string()),
+            op: "OpFDiv".to_string(),
+            operands: vec!["%f32".to_string(), "%f32_1".to_string(), "%0".to_string()],
+        },
+        Instruction {
+            result_id: None,
+            op: "OpStore".to_string(),
+            operands: vec!["%out_color".to_string(), "%1".to_string()],
+        },
+        Instruction {
+            result_id: None,
+            op: "OpReturn".to_string(),
+            operands: vec![],
+        },
+        Instruction {
+            result_id: None,
+            op: "OpFunctionEnd".to_string(),
+            operands: vec![],
+        },
+    ];
+    assert_eq!(res, res_spv);
+}
+
+#[test]
+fn test_fun_ssa_vec() {
+    use crate::compiler::backend::*;
+    use crate::compiler::*;
+    use crate::parser::*;
+    let src = "
+        (module Shader Logical GLSL450)
+        (import :std GLSL.std.450)
+        (bind (out-color:*v4f32o) (Location 0))
+        (dec out-color:*v4f32o Output)
+        (entry main Fragment OriginUpperLeft (:out-color))
+        (fun (main) :<>
+            (store-ptr out-color (v4f32 1.0 1.0 0.0 1.0)))
+";
+    let ast = parse(tokenize(src));
+    let mut module = meta_compile(ast.unwrap()).unwrap();
+    let ops = vec![];
+    compile_fun_ssa(&mut module, &ops);
+    let res = module.functions.pop().unwrap();
+    let res = res.body.unwrap();
+    println!("{:#?}", res);
+    println!("{:#?}", module)
+}

src/compiler/meta_compile.rs

@@ -194,7 +194,7 @@ pub fn compile_fun<I: Iterator<Item = Ast>>(
     };
     let fun = Function {
         name: name.to_string(),
-        return_type: return_type,
+        return_type,
         arguments: vec![],
         body: Some(vec![]),
         ast: Some(Ast::List(Localised {

src/main.rs

@@ -1,31 +1,26 @@
-use compiler::{backend::spirv_meta, meta_compile};
+use compiler::{
+    backend::{compile_fun_ssa, spirv_meta},
+    meta_compile,
+};
 use error::print_error;
-use std::{env, fs, path::PathBuf};
+use std::{env, fs, path::PathBuf, process::ExitCode};
 
-use parser::{parse_string, tokenize, Token};
+use parser::parse_string;
 pub mod compiler;
 mod error;
 pub mod parser;
 
-#[derive(Debug, Default, PartialEq)]
-enum Trace {
-    Tokens,
-    AST,
-    #[default] Normal
-}
-
 #[derive(Debug, Default)]
 struct CompilerArgs {
     input: Option<PathBuf>,
     output: Option<PathBuf>,
-    trace: Trace,
     print_help: bool,
     print_version: bool,
 }
 
 const SPIRV_VERSION: &'static str = "1.0";
 
-fn main() {
+fn main() -> ExitCode {
     let args = parse_args();
     if args.print_version || args.print_help {
         if args.print_help {
@@ -34,59 +29,78 @@ fn main() {
         if args.print_version {
             print_version();
         }
-        return;
+        return ExitCode::FAILURE;
     }
 
     let Some(input) = args.input else {
         eprintln!("No input specified");
-        return;
+        return ExitCode::FAILURE;
     };
 
-    let output = args.output.unwrap_or(PathBuf::from("./out.spv"));
+    let output = args.output.unwrap_or(PathBuf::from("./out.spvas"));
 
     let src = match fs::read_to_string(input) {
         Ok(i) => i,
         Err(e) => {
             eprintln!("{e}");
-            return;
+            return ExitCode::FAILURE;
         }
     };
-    if args.trace == Trace::Tokens {
-        let tokens = tokenize(&src);
-        for tok in tokens {
-            match tok.item {
-                Token::LeftParen => println!("{:>3}:{:<3} LeftParen",tok.location.line_start(), tok.location.col_start()),
-                Token::RightParen => println!("{:>3}:{:<3} RightParen",tok.location.line_start(), tok.location.col_start()),
-                Token::Symbol( val ) => println!("{:>3}:{:<3} Symbol `{}`",tok.location.line_start(), tok.location.col_start(), val)
-            }
-        }
-        return;
-    }
 
     let ast = match parse_string(&src) {
         Ok(i) => i,
         Err(e) => {
             print_error(e, Some(&src));
-            return;
+            return ExitCode::FAILURE;
         }
     };
-    
-    if args.trace == Trace::AST {
-        ast.pretty_print(None,None);
-        return;
-    }
 
-    let module = match meta_compile(ast) {
+    let mut module = match meta_compile(ast) {
         Ok(m) => m,
         Err(e) => {
             print_error(e, Some(&src));
-            return;
+            return ExitCode::FAILURE;
         }
     };
 
-    let res = spirv_meta(module);
+    use std::fmt::Write;
+
+    let ops_split_params = spirv_meta(&mut module);
+    let mut ops_merged_param = vec![];
+    for op in ops_split_params.clone() {
+        ops_merged_param.push((op.0, op.1.join(" ")));
+    }
+    compile_fun_ssa(&mut module, &ops_merged_param);
+
+    let mut res = String::new();
+
+    for op in ops_split_params {
+        if op.0.is_some() {
+            write!(res, "{} = ", op.0.unwrap()).unwrap();
+        }
+        for arg in op.1 {
+            write!(res, "{} ", arg).unwrap();
+        }
+        writeln!(res).unwrap();
+    }
+
+    for fun in module.functions.iter() {
+        // TODO non-void type
+        for inst in fun.body.clone().unwrap().iter() {
+            if let Some(id) = inst.result_id.as_ref() {
+                write!(res, "{} = ", id).unwrap();
+            }
+            write!(res, "{}", inst.op).unwrap();
+            for op in inst.operands.iter() {
+                write!(res, " {}", op).unwrap();
+            }
+            writeln!(res).unwrap();
+        }
+    }
 
     fs::write(output, res).unwrap();
+
+    ExitCode::SUCCESS
 }
 
 fn parse_args() -> CompilerArgs {
@@ -135,36 +149,6 @@ fn parse_args() -> CompilerArgs {
                         return parsed_args;
                     }
                 }
-                "trace" => {
-                    if parsed_args.trace == Trace::Normal {
-                        let Some(output) = args.next() else {
-                            parsed_args.print_help = true;
-                            eprintln!("trace needs a file");
-                            eprintln!();
-                            return parsed_args;
-                        };
-                        match output.as_str() {
-                            "ast" | "AST" | "Ast" => {
-                                parsed_args.trace = Trace::AST;
-                            }
-                            "token" | "tokens" => {
-                                parsed_args.trace = Trace::Tokens;
-                            }
-                            a => {
-                                eprintln!("unknown trace value {a}");
-                                eprintln!();
-                                parsed_args.print_help = true;
-                                return parsed_args;
-                            }
-                        }
-
-                    } else {
-                        eprintln!("trace can be passed only once");
-                        eprintln!();
-                        parsed_args.print_help = true;
-                        return parsed_args;
-                    }
-                }
                 a => {
                     eprintln!("unknown arg --{a}");
                     eprintln!();
@@ -255,7 +239,7 @@ fn print_help() {
     println!("\t\tThe shader to be parsed and compiled, manadory argument");
     println!();
     println!("\t-o --output:");
-    println!("\t\tWhere to output the compiled spirv assembly to, default: out.spv");
+    println!("\t\tWhere to output the compiled spirv assembly to, default: out.spvas");
     println!();
     println!("\t-h --help:");
     println!("\t\tPrint this and exit");

src/parser/mod.rs

@@ -148,36 +148,18 @@ impl Ast {
         }
     }
 
-    pub fn location(&self) -> &Location {
+    pub fn list(self) -> Option<Vec<Ast>> {
         match self {
-            Ast::Symbol(Localised { location, .. }) => location,
-            Ast::List(Localised { location, .. }) => location,
-            Ast::Root(_) => &Location::All,
+            Ast::List(Localised { item, .. }) => Some(item),
+            _ => None,
         }
     }
 
-    pub fn pretty_print(&self, prefix: Option<&String>, body_prefix: Option<&String>) {
-        let empty_string_to_make_rust_happy = &String::from("");
-        let prefix_ = prefix.unwrap_or(&empty_string_to_make_rust_happy);
-        let body_prefix_ = body_prefix.unwrap_or(&empty_string_to_make_rust_happy);
+    pub fn location(&self) -> &Location {
         match self {
-            Ast::Symbol(Localised { item, location }) => {
-                println!("{} Symbol `{}` ({}:{})", prefix_, item, location.line_start(), location.col_start());
-            },
-            Ast::List(Localised { item, location }) => {
-                println!("{} List ({}:{})", prefix_, location.line_start(), location.col_start());
-                for i in 0..item.len()-1 {
-                    item[i].pretty_print(Some(&(body_prefix_.to_owned() + &String::from(" ├─ "))), Some(&(body_prefix_.to_owned() + &String::from(" │  "))));
-                }
-                item[item.len()-1].pretty_print(Some(&(body_prefix_.to_owned() + &String::from(" ╰─ "))), Some(&(body_prefix_.to_owned() + &String::from("    "))));
-            },
-            Ast::Root( items ) => {
-                println!("{} Root", prefix_);
-                for i in 0..items.len()-2 {
-                    items[i].pretty_print(Some(&(body_prefix_.to_owned() + &String::from(" ├─ "))), Some(&(body_prefix_.to_owned() + &String::from(" │  "))));
-                }
-                items[items.len()-1].pretty_print(Some(&(body_prefix_.to_owned() + &String::from(" ╰─ "))), Some(&(body_prefix_.to_owned() + &String::from("    "))));
-            },
+            Ast::Symbol(Localised { location, .. }) => location,
+            Ast::List(Localised { location, .. }) => location,
+            Ast::Root(_) => &Location::All,
         }
     }
 }

src/parser/tests.rs

@@ -44,7 +44,7 @@ fn test_parse() {
 (dec out-color:*v4f32o Output)
 (entry main Fragment OriginUpperLeft (:frag-coord :out-color))
 (fun (main) :<>
-  (store-ptr (out-color)
+  (store-ptr out-color
     (v4f32i (/ (.xy (load-ptr frag-coord))
                (v2f32 1920.0 1080.0)) 
             1.0 
@@ -111,9 +111,7 @@ fn test_parse() {
             Ast::Symbol(Localised::dummy_location(":<>".to_string())),
             Ast::List(Localised::dummy_location(vec![
                 Ast::Symbol(Localised::dummy_location("store-ptr".to_string())),
-                Ast::List(Localised::dummy_location(vec![Ast::Symbol(
-                    Localised::dummy_location("out-color".to_string()),
-                )])),
+                Ast::Symbol(Localised::dummy_location("out-color".to_string())),
                 Ast::List(Localised::dummy_location(vec![
                     Ast::Symbol(Localised::dummy_location("v4f32i".to_string())),
                     Ast::List(Localised::dummy_location(vec![

test.sdr

@@ -1,14 +0,0 @@
-(module Shader Logical GLSL450)
-(import :std GLSL.std.450)
-(bind (frag-coord:*v4f32i) (BuiltIn FragCoord))
-(bind (out-color:*v4f32o) (Location 0))
-(dec frag-coord:*v4f32i Input)
-(decr out-color:*v4f32o Output)
-(entry main Fragment OriginUpperLeft (:frag-coord :out-color))
-(fun (main)
-  (store-ptr (out-color)
-    (v4f32i (/ (.xy (load-ptr frag-coord))
-               (v2f32 1920.0 1080.0)) 
-            1.0 
-            1.0)))
-

test.spv

@@ -1,12 +0,0 @@
-OpCapability Shader 
-OpMemoryModel Logical GLSL450 
-OpEntryPoint Fragment %main "main" %frag_coord %out_color 
-OpExecutionMode %main OriginUpperLeft 
-%f32 = OpTypeFloat 32 
-%v4f32 = OpTypeVector %f32 4 
-%pv4f32i = OpTypePointer Input %v4f32 
-%frag_coord = OpVariable %pv4f32i Input 
-OpDecorate %frag_coord BuiltIn FragCoord 
-%pv4f32o = OpTypePointer Output %v4f32 
-%out_color = OpVariable %pv4f32o Output 
-OpDecorate %out_color Location 0