Merge pull request #54 from qupa-project/staging

Version 0.1.0

Author: AjaniBilby

README.md

@@ -25,4 +25,5 @@ You can also find a few examples in `test/pre-alpha/`.
 | `--execute` | Executes the binary output after successful compilation |
 | `--version` | Prints the version of the compiler |
 | `--verifyOnly` | Compiles to LLVM, but does not store the results or compiles further |
+| `--compileOnly` | Compiles to binary, but does not execute the result |
 | `--opt {num}` | Runs optimisation passes over the output (any number between 0-3 inclusive) |

changelog.md

@@ -1,5 +1,37 @@
 # Change Log
 
+## Version 0.1.0
+
+## Added
+- [x] ``--compileOnly`` flag which compiles to a binary, but does not execute the result
+- [x] Primitive class implementation
+- [x] Delete instruction to consume values
+- [x] Class destructors
+- [x] Class clone operations
+- [x] String class
+- [x] No longer need a return statement on a void function
+- [x] Bitwise cast (for core development only)
+- [x] Elif statement
+- [x] Fixed inverted signedness issues on integer comparison
+- [x] Escaped string characters
+- [x] Constant Function Arguments
+
+## Fixes
+- [x] Bug with nested structure access
+- [x] Composition of stats where value is undefined in all
+- [x] Consumption of single continuous state (when one branch of an if returns)
+- [x] Fixed not detecting deconstruction of values within if-statements
+- [x] Ability to override function in file
+- [x] Allowing multiple definitions of structure term
+
+## Changes
+- [x] The ``uvc`` command now executes the result by default.
+- [x] No longer need a return statement for void functions
+
+## Tweaks
+- [x] Tweaked the automated testing to reflect the new argument changes
+- [x] Compiler skips merging changes between a branch if the value has not been updated in either branch
+
 ## Version 0.0.2
 
 ### Added

compiler/compile.js

@@ -8,7 +8,7 @@ const os = require('os');
 const fs = require('fs');
 const { exec, spawn, spawnSync } = require('child_process');
 
-const version = "Uniview Compiler v0.0.2";
+const version = "Uniview Compiler v0.1.0 Alpha";
 const root = path.resolve("./");
 
 
@@ -26,9 +26,10 @@ if (process.argv.includes("--version")) {
 let config = {
 	output: "out",
 	source: false,
-	execute: false,
+	execute: true,
+	compileOnly: false,
+	verifyOnly: false,
 	optimisation: "0",
-	verifyOnly: false
 };
 let index = process.argv.indexOf('-o');
 if (index != -1 && index > 2) {
@@ -39,6 +40,11 @@ if (process.argv.includes('--execute')) {
 }
 if (process.argv.includes('--verifyOnly')) {
 	config.verifyOnly = true;
+	config.execute = false;
+}
+if (process.argv.includes('--compileOnly')) {
+	config.compileOnly = true;
+	config.execute = false;
 }
 index = process.argv.indexOf('-s');
 if (index != -1) {
@@ -51,6 +57,10 @@ if (index != -1) {
 	);
 }
 
+if (config.execute + config.verifyOnly + config.compileOnly > 1) {
+	console.error("Invalid arguments");
+	process.exit(1);
+}
 
 
 
@@ -104,6 +114,7 @@ if (config.execute && config.source !== false) {
 if (config.source != "llvm") {
 	let args = project.includes
 		.concat([
+			["-Wno-override-module"],
 			["--language=ir", `${config.output}.ll`],
 			[`-O${config.optimisation}`]
 		])

compiler/component/class.js

@@ -0,0 +1,221 @@
+const Function = require('./function.js');
+const Structure = require('./struct.js');
+const LLVM = require('./../middle/llvm.js');
+
+class Class extends Structure {
+	constructor (ctx, ast, external = false) {
+		super(ctx, ast, external);
+		this.names = {};
+		this.meta = "CLASS";
+	}
+
+	parse () {
+		this.name = this.ast.tokens[0].tokens;
+		this.represent = "%class." + (
+			this.external ? this.name : `${this.name}.${this.ctx.represent}`
+		);
+	}
+
+	link (stack = []) {
+		if (stack.indexOf(this) != -1) {
+			this.ctx.getFile().throw(
+				`Error: Structure ${this.name} contains itself, either directly or indirectly`,
+				this.ast.ref.start,
+				this.ast.ref.end
+			);
+			return;
+		}
+		if (this.linked) {
+			return;
+		}
+
+		this.size = 0;
+		for (let node of this.ast.tokens[1].tokens) {
+			switch (node.type) {
+				case "comment":
+					break;
+				case "struct_attribute":
+					if (this.linkTerm(node, stack) == false) {
+						return;
+					}
+					break;
+				case "function":
+					let space = new Function(this, node, false, false);
+
+					if (!this.names[space.name]) {
+						this.names[space.name] = space;
+					} else if (
+						!this.names[space.name].merge ||
+						!this.names[space.name].merge(space)
+					) {
+						let first = this.names[space.name].ref.index < space.ref.index ?
+						this.names[space.name].ref : space.ref;
+						let second = this.names[space.name].ref.index > space.ref.index ?
+						this.names[space.name].ref : space.ref;
+
+						this.getFile().throw(
+							`Multiple definitions of same name ${space.name}`,
+							first, second
+						);
+						this.project.markError();
+						return false;
+					}
+
+					break;
+				default:
+					throw new Error(`Unexpected attribute ${node.type}`);
+			}
+		}
+
+		// Link all successful functions
+		for (let name in this.names) {
+			this.names[name].link();
+		}
+
+
+		// Ensure this class has a destructor if any child does
+		if (!this.getDestructor()) {
+			let found = false;
+			let ref = null;
+			for (let child of this.terms) {
+				let type = child.typeRef.type;
+				if (type instanceof Class && type.getDestructor()) {
+					found = true;
+					ref = child.declared;
+					break;
+				}
+			}
+
+			if (found) {
+				this.getFile().throw(
+					`Error: This class contains no destrutor function, however it's attributes do`,
+					this.ref, ref
+				);
+			}
+		}
+
+		// Ensure this class has a clone operation if any child does
+		let cloner = this.getCloner();
+		if (!cloner) {
+			let found = false;
+			let ref = null;
+			for (let child of this.terms) {
+				let type = child.typeRef.type;
+				if (type instanceof Class && type.getCloner()) {
+					found = true;
+					ref = child.declared;
+					break;
+				}
+			}
+
+			if (found) {
+				this.getFile().throw(
+					`Error: This class contains no clone function, however at least one of it's attributes do`,
+					this.ref, ref
+				);
+			}
+		} else {
+			if (!cloner.returnType.match(new TypeRef(0, this, false))) {
+				this.getFile().throw(
+					`Error: Cloning functions must return a "${this.name}" value`,
+					this.ref, cloner.ref
+				);
+			}
+		}
+
+		this.linked = true;
+	}
+
+	getFunction (access, signature, template) {
+		let name;
+		if (access.length == 0) {
+			name = "New";
+		} else if (access.length != 1) {
+			return null;
+		} else {
+			name = access[0][1];
+		}
+
+		if (this.names[name]) {
+			return this.names[name].getFunction([], signature, template);
+		}
+
+		return null;
+	}
+
+	getDestructor () {
+		if (!this.names['Delete']) {
+			return false;
+		}
+
+		return this.names['Delete'].getFunction([], [new TypeRef(0, this, false)], null);
+	}
+	getCloner () {
+		if (!this.names['Clone']) {
+			return false;
+		}
+
+		return this.names['Clone'].getFunction([], [new TypeRef(0, this, true)], null);
+	}
+
+	cloneInstance (argument, ref) {
+		let cloner = this.getCloner();
+		if (cloner) {
+			let preamble = new LLVM.Fragment();
+			let irType = new TypeRef(0, this, false);
+			let id = new LLVM.ID();
+
+			preamble.append(new LLVM.Set(
+				new LLVM.Name(id),
+				new LLVM.Alloc(irType.toLLVM(ref, true))
+			));
+
+			let instruction = new LLVM.Argument (
+				irType.toLLVM(ref, false, true),
+				new LLVM.Name(id.reference())
+			);
+
+			// Call the clone opperation
+			preamble.append(new LLVM.Call(
+				new LLVM.Type("void", 0),
+				new LLVM.Name(cloner.represent, true, ref),
+				[
+					instruction,
+					argument
+				], ref
+			));
+
+			return {
+				preamble,
+				instruction
+			};
+		} else {
+			return super.cloneInstance(argument, ref);
+		}
+	}
+
+
+	compile () {
+		super.compile();
+
+		for (let name in this.names) {
+			this.names[name].compile();
+		}
+	}
+
+	toLLVM () {
+		let out = new LLVM.Fragment();
+		out.append(super.toLLVM());
+
+		for (let name in this.names) {
+			out.append(this.names[name].toLLVM());
+		}
+
+		return out;
+	}
+}
+
+
+const TypeRef = require('./typeRef.js');
+
+module.exports = Class;

compiler/component/execution/base.js

@@ -115,17 +115,15 @@ class ExecutionBase {
 			return res;
 		}
 
-		let access = ast.tokens[2];
-		while (access.length > 0) {
+		let accesses = ast.tokens[2];
+		for (let access of accesses) {
 			res.hasUpdated = res.hasUpdated || !read;
-			res = res.access(access[0][1], access[0][1].ref);
+			res = res.access(access[1].tokens, access[1].ref);
 			if (res.error) {
 				return res;
 			}
 			preamble.merge(res.preamble);
 			res = res.variable;
-
-			access.splice(0, 1);
 		}
 
 		return {
@@ -178,15 +176,6 @@ class ExecutionBase {
 			template
 		);
 
-		if (type === null) {
-			return null;
-		}
-
-		// Linear types are handled by address, not value
-		if (type.type.typeSystem == "linear") {
-			type.pointer++;
-		}
-
 		return type;
 	}
 
@@ -223,7 +212,7 @@ class ExecutionBase {
 
 	sync (branches, segment, ref){
 		return this.scope.sync(
-			branches.map(x => [x.entryPoint, x.scope]),
+			branches,
 			segment,
 			ref
 		);