Documentation improvements and added main #19

Author: Nereuxofficial

docs/Notizen zum AST.md

@@ -1,16 +1,30 @@
 # Notizen zum AST
 
-Die Definition des ASTs wurde stark von den Ansätzen aus der Vorlesung inspiriert. Im folgenden sollen v.a. anders getroffene Entscheidungen begründet werden. Zusätzlich soll kurz erklärt werden, wie das Diagramm genau zu lesen ist. Das ist nötig, weil die Programmiersprache, die zur Erstellung des Compilers genutzt wurde, nicht objekt-orientiert ist und eine Übersetzung von UML-Diagramm zur Definition im Code somit leicht anders als bei Java Programmen ist.
+Die Definition des ASTs wurde stark von den Ansätzen aus der Vorlesung inspiriert. Im Folgenden sollen v.a. anders 
+getroffene Entscheidungen begründet werden. Zusätzlich soll kurz erklärt werden, wie das Diagramm genau zu lesen ist.
+Das ist nötig, weil die Programmiersprache, die zur Erstellung des Compilers genutzt wurde, nicht objekt-orientiert ist 
+und eine Übersetzung von UML-Diagramm zur Definition im Code somit leicht anders als bei Java Programmen ist.
 
 ## Erklärung des Diagramms
 
-Einige Klassen des Diagramms haben einen blauen Rand. Das zeigt an, dass diese Elemente noch nicht beim Parsen erstellt werden, sondern erst beim Typcheck hinzugefügt werden. Speziell werden alle Statements, Expression und Statemnt-Expressions in TypedStmt, TypedExpr bzw. TypedStmtExpr gepackt. Somit kann Typ-Information hinzugefügt werden, die beim Parsing noch nicht vorhanden war. Auch werden alle LocalOrFieldVar Objekte bei der Typisierung in LocalVar bzw. FieldVar Objekte transformiert. Der Grund dahinter liegt darin, dass der Typchecker sowieso herausfinden muss, ob es sich bei der Variable um eine lokale Variable oder ein Attribut der Klasse handelt. Da die Codegenerierung diese Informationen ebenfalls benötigt, werden die dann beim Typchecker direkt in den AST geliefert.
+Einige Klassen des Diagramms haben einen blauen Rand. 
+Das zeigt an, dass diese Elemente noch nicht beim Parsen erstellt werden, sondern erst beim Typcheck hinzugefügt werden. 
+Speziell werden alle Statements, Expression und Statement-Expressions in TypedStmt, TypedExpr bzw. TypedStmtExpr gepackt. 
+Somit kann Typ-Information hinzugefügt werden, die beim Parsing noch nicht vorhanden war. Auch werden alle `LocalOrFieldVar`
+Objekte bei der Typisierung in LocalVar bzw. FieldVar Objekte transformiert. Der Grund dahinter liegt darin, dass der 
+Typchecker sowieso herausfinden muss, ob es sich bei der Variable um eine lokale Variable oder ein Attribut der Klasse 
+handelt. Da die Codegenerierung diese Informationen ebenfalls benötigt, werden die dann beim Typchecker direkt in den 
+AST geliefert.
 
-Im Quellcode werden viele der "Klassen" des Diagramms als Enumerations dargestellt. Das liegt daran, dass die gewählte Programmiersprache - [Rust](https://www.rust-lang.org/) - sehr mächtige Enumerations zur Verfügung stellt. Bei Rust kann jeder Option aus einem Enum eine eigene Menge an Parametern gegeben werden. Somit können alle Attribute der Klasse als Parameter des Enums abgebildet werden. Speziell wurde das bei der Definition von `Stmt`, `Expr` und `StmtExpr` genutzt. Da alle diese Elemente nicht wirklich von eine Überklasse erben, sondern eigentlich Optionen eines Enums sind, wurden sie im Diagramm als einzelne Klassen in einer Box, die das Enum darstellt, abgebildet.
+Im Quellcode werden viele der "Klassen" des Diagramms als Enumerations dargestellt. Das liegt daran, dass die gewählte 
+Programmiersprache - [Rust](https://www.rust-lang.org/) - sehr mächtige Enumerations zur Verfügung stellt. 
+Bei Rust kann jeder Variante aus einem Enum eine eigene Menge an Parametern gegeben werden. Somit können alle Attribute 
+der Klasse als Parameter des Enums abgebildet werden. Speziell wurde das bei der Definition von `Stmt`, `Expr` und 
+`StmtExpr` genutzt. Da alle diese Elemente nicht wirklich von eine Überklasse erben, sondern eigentlich Varianten eines 
+Enums sind, wurden sie im Diagramm als einzelne Klassen in einer Box, die das Enum darstellt, abgebildet.
 
 ## Erklärung unserer Entscheidungen
 
-TBD
-
--   FieldDecl hat optional value Attribut
--   ...
+- Assign nimmt eine expression für die Variable auf, da wir bei der Codegenerierung wissen müssen um welchen Typ an Variable es sich handelt, da dort dann unterschiedlicher Bytecode generiert werden muss
+- FieldDecl nimmt einen optionalen Wert zur direkten Zuweisung auf
+- Type wurde um Class erweitert um die Codegenerierung zu vereinfachen

docs/Project-Doc.md

@@ -6,9 +6,9 @@
 -   Wer hat welche Arbeit am Parser gemacht?
 -   Wie wurde Pest fürs Parsing eingesetzt? (sehr ähnlich zu ANTLR)
 
-## Typchecker
+## Typechecker
 
-Geschrieben von: Maximilian Floto, Philipp Wolf
+Geschrieben von: Maximilian Floto und Philipp Wolf im Pair Programming
 
 Der Typechecker akzeptiert einen Abstract Syntax Tree (AST) und gibt einen getypten AST (TAST) zurück.
 Er führt eine umfassende Analyse durch, um die Typen aller Variablen und Ausdrücke im Code zu bestimmen.
@@ -44,9 +44,11 @@ Folgende Fehler werden vom Typechecker erkannt:
 
 ## Codegenerierung
 
-Geschrieben von: Marion Hinkel, Benedikt Brandmaier, Val Richter
--   Wer hat welche Arbeit bei codegen gemacht?
--   Was für Arbeit musste alles zusätzlich getan werden, weil wir nicht Java + ASM genutzt haben?
+ByteCode-Umwandlung, Bugfixes, StackSize und Improvements: Val Richter
+
+Definition DIR(Intermediate Representation), ConstantPool, LocalVarPool, Methoden zur Instruction-generierung, BugFixes, etwas ByteCode-Umwandlung und Umwandlung relativer in absolute Jumps: Marion Hinkel und Benedikt Brandmaier im Pair Programming
+- Wer hat welche Arbeit bei codegen gemacht?
+- Was für Arbeit musste alles zusätzlich getan werden, weil wir nicht Java + ASM genutzt haben?
 
 ## Testing
 

docs/User-Doc.md

@@ -1,18 +1,36 @@
 TBD
 
--   Jeweils erwähnen wie man die Teile kompiliert und laufen lassen kann. Nicht vergessen: Wie sollte die Eingabe aussehen und wie sieht die Ausgabe dann aus?
--   Vielleicht sollten wir Command-Line Befehle für jeden der Teile im Binary Crate zur Verfügung stellen?
+- Jeweils erwähnen wie man die Teile kompiliert und laufen lassen kann. Nicht vergessen: Wie sollte die Eingabe aussehen und wie sieht die Ausgabe dann aus?
+- Vielleicht sollten wir Command-Line Befehle für jeden der Teile im Binary Crate zur Verfügung stellen?
+
+## Vorbedingungen
+[Rust installieren](https://rustup.rs/):
+```bash
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+```
+- [JDK 20](https://www.oracle.com/java/technologies/downloads/)(Wird in Tests für die Validierung des Codegens benötigt)
+
+# Ausführen
+Um eine .java in eine .class-datei zu kompilieren:
+```bash
+cargo run -- <input_file>
+```
+
+# Testen
+1. Projekt bauen: `cargo build`
 
 ## Parser
 
+2. Parser tests ausführen: `cargo test test_parser`
 ## Typchecker
 
-1. Projekt bauen: `cargo build`
-2. Go to lib folder: `cd lib`
-3. Typechecker tests ausführen: `cargo test test_typechecker`
+2. Typechecker tests ausführen: `cargo test test_typechecker`
 
 Spezifischen Test ausführen: `cargo test <test_name>::test_typechecker`
 
 ## Codegenerierung
 
+2. Codegenerierung tests ausführen: `cargo test test_codegen`
+
 ## Testing
+Zur ausführung aller tests: `cargo test`

lib/src/codegen/ir.rs

@@ -3,6 +3,7 @@
 #![allow(non_snake_case)]
 
 use crate::codegen::reljumps::convert_to_absolute_jumps;
+use crate::codegen::Instruction::getfield;
 use crate::types::Expr::Binary;
 use crate::types::*;
 use std::fmt::Debug;
@@ -844,7 +845,27 @@ fn generate_code_stmt_expr(
                                 result.push(Instruction::putfield(idx));
                                 stack.update(-2);
                             }
-                            _ => panic!("Unexpected variable type for assignment"),
+                            Expr::InstVar(expr, name) => {
+                                // FIXME: Searches for something here
+                                let idx = constant_pool.add(Constant::FieldRef(FieldRef {
+                                    class: class_name.to_string(),
+                                    field: NameAndType {
+                                        name: name.to_string(),
+                                        r#type: t.to_ir_string(),
+                                    },
+                                }));
+                                result.append(&mut generate_code_expr(
+                                    expr.deref().clone(),
+                                    stack,
+                                    constant_pool,
+                                    local_var_pool,
+                                    class_name,
+                                ));
+                                result.append(&mut expr_code);
+                                result.push(Instruction::putfield(idx));
+                                stack.update(-2);
+                            }
+                            _ => panic!("Unexpected variable type for assignment: {:?}", var),
                         },
                         _ => panic!("Expected typed stmt"),
                     }
@@ -867,7 +888,6 @@ fn generate_code_stmt_expr(
                     stack.update(-1);
                 }
                 StmtExpr::MethodCall(_expr, name, args) => {
-                    // FIXME: Needs to update stack + probably doesn't work yet anyways
                     // Generate bytecode for method call
                     // Principally this should work this way:
                     // 1. Write Function Name into Constant Pool generating the necessary Constants
@@ -967,10 +987,35 @@ fn generate_code_expr(
                     stack.update(1);
                 }
                 Expr::InstVar(exprs, name) => {
-                    result.push(Instruction::aload(0));
-                    stack.update(1);
-
-                    // FIXME: There should be more here, right?
+                    match exprs.deref() {
+                        Expr::TypedExpr(expr, r#type) => match expr.deref() {
+                            Expr::This => {
+                                result.push(Instruction::aload(0));
+                                result.push(Instruction::getfield(constant_pool.add(
+                                    Constant::FieldRef(FieldRef {
+                                        class: class_name.to_string(),
+                                        field: NameAndType {
+                                            name: name.clone(),
+                                            r#type: r#type.to_ir_string(),
+                                        },
+                                    }),
+                                )));
+                            }
+                            _ => panic!("Expected this got {:?}", exprs),
+                        },
+                        _ => panic!("Expected typed stmt got {:?}", exprs),
+                    }
+                    let field_index = constant_pool.add(Constant::FieldRef(FieldRef {
+                        class: class_name.to_string(),
+                        field: NameAndType {
+                            name: name.clone(),
+                            r#type: r#type.to_ir_string(),
+                        },
+                    }));
+                    result.push(getfield(field_index));
+                    // I'm thinking 2 here since we load the field here too and leave the class on the stack
+                    stack.update(2);
+                    // TODO: Val check if thats correct pls
                 }
 
                 Binary(op, left, right) => {

lib/src/parser/parser.rs

@@ -8,6 +8,7 @@ extern crate pest_derive;
 use crate::types::{Class, Expr, FieldDecl, MethodDecl, Stmt, StmtExpr, Type};
 use pest::error::Error;
 use pest::iterators::{Pair, Pairs};
+use pest::unicode::RUNIC;
 use pest::Parser;
 use pest_derive::Parser;
 
@@ -26,7 +27,8 @@ pub fn parse_programm(file: &str) -> Result<Vec<Class>, Error<Rule>> {
 }
 
 fn parse_class(pair: Pair<Rule>) -> Class {
-    match pair.as_rule() {
+    let rule = pair.as_rule();
+    match rule {
         Rule::ClassDecl => {
             let mut inners = pair.into_inner();
             let other_name = next_id(&mut inners);
@@ -51,7 +53,7 @@ fn parse_class(pair: Pair<Rule>) -> Class {
                 methods,
             }
         }
-        _ => todo!(),
+        _ => unreachable!(),
     }
 }
 fn next_id(inners: &mut Pairs<Rule>) -> String {
@@ -360,17 +362,26 @@ fn parse_expr(pair: Pair<Rule>) -> Expr {
             obj
         }
         Rule::UnaryExpr => {
-            todo!()
-        }
-        Rule::ParanthesizedExpr => {
-            todo!()
+            let mut inners = pair.into_inner();
+            let unaryOp = inners.next().unwrap().as_str().trim().to_string();
+            let second = inners.next().unwrap();
+            let result = if second.as_rule() == Rule::Identifier {
+                Expr::LocalOrFieldVar(second.as_str().trim().to_string()) //@Notice: duno if this is corect
+            } else {
+                parse_expr(second)
+            };
+            Expr::Unary(unaryOp, Box::new(result))
         }
+        Rule::ParanthesizedExpr => parse_expr(pair.into_inner().next().unwrap()),
         Rule::IntLiteral => Expr::Integer(pair.as_str().parse().unwrap()),
         Rule::BoolLiteral => Expr::Bool(pair.as_str().parse().unwrap()),
         Rule::CharLiteral => Expr::Char(get_str_content(pair.as_str()).parse().unwrap()),
         Rule::StrLiteral => Expr::String(get_str_content(pair.as_str()).to_string()),
         Rule::StmtExpr => Expr::StmtExprExpr(Box::new(parse_StmtExpr(pair))),
         Rule::NonBinaryExpr => parse_expr(pair.into_inner().next().unwrap()),
+        Rule::Prec3BinExpr => {
+            todo!()
+        }
         _ => {
             dbg!(pair.as_rule());
             unreachable!()

lib/src/tests/mod.rs

@@ -44,7 +44,7 @@ use tast_to_ast::*;
 fn normalize_str(s: std::string::String) -> std::string::String {
     s.split('\n')
         .fold("".to_string(), |acc, s| acc + s)
-        .split("\t")
+        .split('\t')
         .fold("".to_string(), |acc, s| acc + s)
 }
 
@@ -122,7 +122,7 @@ pub fn codegen_test(tast: &Class, name: &str) {
 
     File::create(format! {"lib/testcases/{name}-Test.java"})
         .expect("failed to create Test.java")
-        .write(java_code.as_bytes())
+        .write_all(java_code.as_bytes())
         .expect("failed to write to Test.java");
     // Compile original java code for expected result
     compile_java(name);
@@ -137,10 +137,10 @@ pub fn codegen_test(tast: &Class, name: &str) {
     // Compile & run tests on generated DIR
     let mut dir = generate_dir(&vec![tast.clone()]);
     let generated_bytes = dir.as_bytes();
-    File::create(format!("lib/testcases/{name}.class"))
-        .expect(&format!("failed to create {name}.class"))
-        .write(&generated_bytes)
-        .expect(&format!("failed to write generated DIR into {name}.class"));
+    File::create(format!("lib/testcases/{name}-generated.class"))
+        .unwrap_or_else(|_| panic!("failed to create {name}-generated.class"))
+        .write_all(&generated_bytes)
+        .unwrap_or_else(|_| panic!("failed to write generated DIR into {name}.class"));
     println!("Generated bytes: {:?}", generated_bytes);
     disassemble_java(name, &format!("{name}-codegen")); // Probably useful for debugging
     compile_java(&format!("{name}-Test"));
@@ -174,11 +174,11 @@ pub fn class_test(ast: &Class, tast: Option<&Class>, name: &str) {
     println!("{class_code}");
     let mut file = File::create(format!("lib/testcases/{name}.java"))
         .expect("failed to open original java file for writing generated code");
-    file.write(class_code.as_bytes())
+    file.write_all(class_code.as_bytes())
         .expect("failed to write generated java code in original java file");
     let mut file = File::create(format!("lib/testcases/{name}-expected.java")) // Only for debugging tests
         .expect("failed to open generated java file for writing generated code");
-    file.write(class_code.as_bytes())
+    file.write_all(class_code.as_bytes())
         .expect("failed to write generated java code in generated java file");
 
     // Compile generated java code
@@ -188,7 +188,7 @@ pub fn class_test(ast: &Class, tast: Option<&Class>, name: &str) {
     // Compile original java code
     let mut file = File::create(format!("lib/testcases/{name}.java"))
         .expect("failed to open original java file for writing");
-    file.write(og_java_code.as_bytes())
+    file.write_all(og_java_code.as_bytes())
         .expect("failed to write original java code back");
     compile_java(name);
     let og_clz = disassemble_java(name, &format!("{name}"));
@@ -228,7 +228,7 @@ fn disassemble_java(name: &str, out: &str) -> Vec<u8> {
         .arg(clz_file_path)
         .stdout(Stdio::from(file))
         .spawn()
-        .expect(&format!("failed to disassemble {name}.java"));
+        .unwrap_or_else(|_| panic!("failed to disassemble {name}.java"));
     let ecode = child
         .wait()
         .unwrap_or_else(|_| panic!("failed to wait on child disassembling {name}.java"));

lib/src/types.rs

@@ -254,7 +254,7 @@ impl Type {
             Type::Bool => "Z",
             Type::String => "Ljava/lang/String;",
             Type::Void => "V",
-            // TODO: Either the class has the formatting `L<class>;' or we have to add it here.
+            // FIXME: Either the class has the formatting `L<class>;' or we have to add it here.
             Type::Class(name) => name,
             _ => panic!("Invalid type: {}", self),
         }

src/main.rs

@@ -1,16 +1,36 @@
 use lib::codegen::generate_dir;
+use lib::parser::parse_programm;
 use lib::typechecker::typechecker;
+use lib::typechecker::typechecker::TypeChecker;
 use lib::types::{Class, Expr, FieldDecl, MethodDecl, Prg, Stmt, StmtExpr, Type};
 use serde_json::Value;
-use std::fs::File;
-use std::io::Read;
+use std::fs::{read_to_string, File};
+use std::io::{Read, Write};
 use tracing::info;
 
 fn main() -> color_eyre::Result<()> {
     color_eyre::install()?;
     tracing_subscriber::fmt::init();
-    info!("Hello RustyJ!");
-
-    lib::hi();
+    let args = std::env::args().collect::<Vec<_>>();
+    let input_file = args.get(1).unwrap_or_else(|| {
+        panic!("No input file provided. Usage: {} <input_file>", args[0]);
+    });
+    info!("Parsing the file {}", args[1]);
+    let mut file = read_to_string(&args[1])?;
+    let prg_parsed = parse_programm(&file)?;
+    info!("Typechecking the program...");
+    let prg_typechecked = TypeChecker::new(prg_parsed)
+        .unwrap_or_else(|e| panic!("{}", e))
+        .check_and_type_program()
+        .unwrap_or_else(|e| panic!("{}", e));
+    info!("Generating code using ducc...");
+    // Generate code using codegen_ducc
+    let mut dir = generate_dir(&prg_typechecked);
+    let bytes = dir.as_bytes();
+    let alt_outfile = "out.class".to_string();
+    let out_file = args.get(2).unwrap_or(&alt_outfile);
+    info!("Writing code to {}", out_file);
+    let mut file = File::create(out_file)?;
+    file.write_all(bytes.as_slice())?;
     Ok(())
 }