Merge pull request #71 from UB-CSE443/Dev

Dev

README.MD

@@ -1,17 +1,89 @@
 # The Translators α Compiler
 #### Members: Annie Slenker, Meyer Simon, Partho Bhattacharya, & Scarlett Kadan
 
-## Lexical Analyzer
+## Alpha Compiler Flags & Expected Results:
-* **Undefined Behavior:**
+### -tok
-  * Spaces are not required between tokens. For instance, an INTEGER and an ID are valid even if there is no space between them
+Prints the token stream provided by the Lexical Analyzer to a `.tok` file. Output can be found in `/out/<file>.tok`. Tokenization follows the specified format found in the alpha language spec.
+
+### -st
+Prints the symbol table to a file. Follows the format provided in the alpha language spec. if the `-ir` flag is also present, the symbol table will print out temporary variables. Output can be found in `out/<file>.st`.
+
+### -asc
+Prints the annotated alpha source code to a file. Will display any syntax errors that are present below the line they occur on. If more than one error is present, the messages will stack. Output can be found in `out/<file>.asc`.
+
+### -tc
+Throws type check errors to the asc output file. If the `-asc` flag is not present, no errors will be displayed. Output can be found in `out/<file>.asc` 
+
+### -ir
+Prints the intermediate code representation stream to a file. Output can be found in `out/<file>.ir`. This flag modifies the `-st` flag, allowing for temporary variables to print out.
+
+### -cg
+Prints the alpha program's unique x86 assembly to a `.s` file. Assembly stream is valid x86 code that can be assembled and linked with other .s files. Output can be found in `out/<file>.s`
+
+### -debug
+Prints debug messages to the console if present. Our debug messages utilizes a wrapper function for `printf()` called `printdebug()`. This allows for us to file names, code lines, and colors!
+
+### -help
+Prints a general help message. (If you read this far, you probably won't need this flag)
+
+
+## Alpha Tools: Testing & Building
+We have built a few tools to aid in the development processes. These include `./test.sh` and `./genx.sh`. Below you can find information about each.
+
+### ./test.sh
+All tests under sprint 1, 2, 3, & 4 will work with the testing suite, along with running it directly with the alpha executable. These files do not use the `#include` directive, instead opting to define everything used within the file.
+> **Arguments:**</br> 
+>    `-exp`     Generate expected output files</br>
+>    `-diff`    Compare output files with expected output files</br>
+>    `-help`    Show this help message</br>
+
+> **Usage:**</br>
+>    `./test.sh <file.alpha> [flags]`   Run the test on a single file</br>
+>    `./test.sh <directory> [flags]`   Run the test on all files in a directory</br>
+
+> **Examples:** </br>
+>    `./test.sh test.alpha`   Runs test flags in header on test.alpha</br>
+>    `./test.sh test/`   Runs test flags in header on all .alpha files in test/</br>
+>    `./test.sh test/ -exp`   Runs test flags in header on all .alpha files in test/ and generates expected output files</br>
+>    `./test.sh test/ -diff`   Runs test flags in header on all .alpha files in test/ and compares output files with expected output files</br>
+>    `./test.sh test/ -exp -diff`   Runs test flags in header on all .alpha files in test/ and generates expected output files and compares output files with expected output files</br>
+
+> **Notes:**</br>
+>    To create a test file, on the first line of the .alpha file, add:</br>
+>    `(* TEST: [ <test_flags> ] *)`</br>
+>    where <test_flags> are the alpha flags to be used. Ex:</br>
+>    `(* TEST: [ -debug -asc -tc ] *)`</br>
+
+### ./genx.sh
+GenX is our preprocessor tool. It is able to handle `#include` statements within an alpha file. The tool allows for includes of `.alpha`, `.s`, and `.c` files, given a relative path to them. You can also include our library file `std.alpha` which does not require a relative path.</br>
+
+**NOTE:** *Due to the nature of include statements, running the alpha compiler on alpha files that use include statements will most likely result in syntax/type errors. When dealing with a file with include statements, it is advised to use GenX.*</br>
+
+*You can also use the following command to preprocess a file:* `cpp -P -x c -o simple.cpp.alpha simple.alpha`
+
+> **Arguments:** </br>
+>    `-help`    Displays this message</br>
+
+> **Usage:** </br>
+>    `./genx.sh <file.alpha || file.s>`  </br>Generates executable file from <file.alpha></br>
+
+> **Notes:** </br>
+>    Generates .s and links alpha driver and general library and other includes.</br>
+
+## Other Notes: 
+
+### Lexical Analyzer:
+**Undefined Behavior:**</br>
+* Spaces are not required between tokens. For instance, an INTEGER and an ID are valid even if there is no space between them
 ```
 Input:		*5variable*
 Output:		2 14 301 "5"
 			1 1 101 "variable"
 ```
+* Added an `#include` token to stop syntax errors from being reported on certain alpha files.
 
-## Syntax Analyzer
+### CG/IR Not Implemented:
-* *Incomplete*
+* Arrays
-
+* And conditionals not tested
-## Symbol Table
+* While loops may or may not be working (More testing needed)
-* *TODO: Create diagram.*
+* *...and other small issues*

genx.sh

@@ -25,6 +25,8 @@ sToInclude=()
 cToBuild=()
 sToInclude+=("library/alpha_lib_reg.s")
 sToInclude+=("library/alpha_driver.s")
+sToInclude+=("library/std.s")
+sToInclude+=("library/boundscheck.s")
 
 filename=""
 s_name=""
@@ -192,7 +194,7 @@ if [ $# -eq 1 ]; then
 
             getIncludes "$1"
             appendStr "$1"
-            ./alpha -ir -tc -asc -cg -st "$1"
+            ./alpha -ir -tc -asc -cg -st -tok "$1"
 
             # include a grep here of asc to see if there are any errors
 

library/alphastdio.c

@@ -0,0 +1,61 @@
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+
+int printS(char *str) {
+    if (str == NULL) return -1;
+    printf("%s", str);
+    return 0;
+}
+
+char *inS() {
+    char *buffer = malloc(100);
+    if (buffer == NULL) return NULL;
+    if (fgets(buffer, 100, stdin) == NULL) {
+        free(buffer);
+        return NULL;
+    }
+    buffer[strcspn(buffer, "\n")] = 0;
+    return buffer;
+}
+
+
+
+int printI(int i) {
+    printf("%d", i);
+    return 0;
+}
+
+int inI() {
+    int i;
+    char buffer[100];
+    if (fgets(buffer, sizeof(buffer), stdin) == NULL) return 0;
+    if (sscanf(buffer, "%d", &i) != 1) return 0;
+    return i;
+}
+
+
+
+int printC(char c) {
+    printf("%c", c);
+    return 0;
+}
+
+char inC() {
+    char c;
+    if (scanf(" %c", &c) != 1) return 0;
+    return c;
+}
+
+
+
+int printB(bool b) {
+    if (b)
+        printf("true");
+    else
+        printf("false");
+    return 0;
+}

library/boundscheck.c

@@ -0,0 +1,23 @@
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+int BoundsError(int d){
+    printf("You are trying to access memory that isn't yours.\n");
+    exit(1);
+}
+
+void BoundsCheck(int argc, void * start, ...){
+    va_list argptr;
+    va_start(argptr, start);
+    int index = 0;
+    while (argc){
+        argc--;
+        index = va_arg(argptr, int);
+        if(index > *(int*)start){
+            BoundsError(index);
+        }
+        start += sizeof(int);
+    }
+    va_end(argptr);
+}

library/boundscheck.s

@@ -0,0 +1,112 @@
+	.file	"boundscheck.c"
+	.text
+	.section	.rodata
+	.align 8
+.LC0:
+	.string	"You are trying to access memory that isn't yours."
+	.text
+	.globl	BoundsError
+	.type	BoundsError, @function
+BoundsError:
+.LFB6:
+	.cfi_startproc
+	pushq	%rbp
+	.cfi_def_cfa_offset 16
+	.cfi_offset 6, -16
+	movq	%rsp, %rbp
+	.cfi_def_cfa_register 6
+	subq	$16, %rsp
+	movl	%edi, -4(%rbp)
+	leaq	.LC0(%rip), %rax
+	movq	%rax, %rdi
+	call	puts@PLT
+	movl	$1, %edi
+	call	exit@PLT
+	.cfi_endproc
+.LFE6:
+	.size	BoundsError, .-BoundsError
+	.globl	BoundsCheck
+	.type	BoundsCheck, @function
+BoundsCheck:
+.LFB7:
+	.cfi_startproc
+	pushq	%rbp
+	.cfi_def_cfa_offset 16
+	.cfi_offset 6, -16
+	movq	%rsp, %rbp
+	.cfi_def_cfa_register 6
+	subq	$240, %rsp
+	movl	%edi, -228(%rbp)
+	movq	%rsi, -240(%rbp)
+	movq	%rdx, -160(%rbp)
+	movq	%rcx, -152(%rbp)
+	movq	%r8, -144(%rbp)
+	movq	%r9, -136(%rbp)
+	testb	%al, %al
+	je	.L3
+	movaps	%xmm0, -128(%rbp)
+	movaps	%xmm1, -112(%rbp)
+	movaps	%xmm2, -96(%rbp)
+	movaps	%xmm3, -80(%rbp)
+	movaps	%xmm4, -64(%rbp)
+	movaps	%xmm5, -48(%rbp)
+	movaps	%xmm6, -32(%rbp)
+	movaps	%xmm7, -16(%rbp)
+.L3:
+	movq	%fs:40, %rax
+	movq	%rax, -184(%rbp)
+	xorl	%eax, %eax
+	movl	$16, -208(%rbp)
+	movl	$48, -204(%rbp)
+	leaq	16(%rbp), %rax
+	movq	%rax, -200(%rbp)
+	leaq	-176(%rbp), %rax
+	movq	%rax, -192(%rbp)
+	movl	$0, -212(%rbp)
+	jmp	.L4
+.L8:
+	subl	$1, -228(%rbp)
+	movl	-208(%rbp), %eax
+	cmpl	$47, %eax
+	ja	.L5
+	movq	-192(%rbp), %rax
+	movl	-208(%rbp), %edx
+	movl	%edx, %edx
+	addq	%rdx, %rax
+	movl	-208(%rbp), %edx
+	addl	$8, %edx
+	movl	%edx, -208(%rbp)
+	jmp	.L6
+.L5:
+	movq	-200(%rbp), %rax
+	leaq	8(%rax), %rdx
+	movq	%rdx, -200(%rbp)
+.L6:
+	movl	(%rax), %eax
+	movl	%eax, -212(%rbp)
+	movq	-240(%rbp), %rax
+	movl	(%rax), %eax
+	cmpl	%eax, -212(%rbp)
+	jle	.L7
+	movl	-212(%rbp), %eax
+	movl	%eax, %edi
+	call	BoundsError
+.L7:
+	addq	$4, -240(%rbp)
+.L4:
+	cmpl	$0, -228(%rbp)
+	jne	.L8
+	nop
+	movq	-184(%rbp), %rax
+	subq	%fs:40, %rax
+	je	.L9
+	call	__stack_chk_fail@PLT
+.L9:
+	leave
+	.cfi_def_cfa 7, 8
+	ret
+	.cfi_endproc
+.LFE7:
+	.size	BoundsCheck, .-BoundsCheck
+	.ident	"GCC: (GNU) 14.2.1 20250207"
+	.section	.note.GNU-stack,"",@progbits

library/std.alpha

@@ -1,4 +1,4 @@
-(* Standard Alpha Library - Provided by Carl *)
+(* Standard Alpha Library *)
 
 type string: 1 -> character
 type BooleanXBoolean: [Boolean: x; Boolean: y]
@@ -16,9 +16,20 @@ type characterXcharacter2Boolean: characterXcharacter -> Boolean
 type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
 type integer2address: integer -> address
 type address2integer: address -> integer
+type integer2string: integer -> string
+type integer2character: integer -> character
+type integer2Boolean: integer -> Boolean
+
 
 external function printInteger: integer2integer
 external function printCharacter: character2integer
 external function printBoolean: Boolean2integer
 
-function entry: string2integer
+external function printS: string2integer
+external function printI: integer2integer
+external function printC: character2integer
+external function printB: Boolean2integer
+
+external function inS: integer2string
+external function inI: integer2integer
+external function inC: integer2character

library/std.s

@@ -0,0 +1,273 @@
+	.file	"alphastdio.c"
+	.text
+	.section	.rodata
+.LC0:
+	.string	"%s"
+	.text
+	.globl	printS
+	.type	printS, @function
+printS:
+.LFB6:
+	.cfi_startproc
+	pushq	%rbp
+	.cfi_def_cfa_offset 16
+	.cfi_offset 6, -16
+	movq	%rsp, %rbp
+	.cfi_def_cfa_register 6
+	subq	$16, %rsp
+	movq	%rdi, -8(%rbp)
+	cmpq	$0, -8(%rbp)
+	jne	.L2
+	movl	$-1, %eax
+	jmp	.L3
+.L2:
+	movq	-8(%rbp), %rax
+	movq	%rax, %rsi
+	leaq	.LC0(%rip), %rax
+	movq	%rax, %rdi
+	movl	$0, %eax
+	call	printf@PLT
+	movl	$0, %eax
+.L3:
+	leave
+	.cfi_def_cfa 7, 8
+	ret
+	.cfi_endproc
+.LFE6:
+	.size	printS, .-printS
+	.section	.rodata
+.LC1:
+	.string	"\n"
+	.text
+	.globl	inS
+	.type	inS, @function
+inS:
+.LFB7:
+	.cfi_startproc
+	pushq	%rbp
+	.cfi_def_cfa_offset 16
+	.cfi_offset 6, -16
+	movq	%rsp, %rbp
+	.cfi_def_cfa_register 6
+	subq	$16, %rsp
+	movl	$100, %edi
+	call	malloc@PLT
+	movq	%rax, -8(%rbp)
+	cmpq	$0, -8(%rbp)
+	jne	.L5
+	movl	$0, %eax
+	jmp	.L6
+.L5:
+	movq	stdin(%rip), %rdx
+	movq	-8(%rbp), %rax
+	movl	$100, %esi
+	movq	%rax, %rdi
+	call	fgets@PLT
+	testq	%rax, %rax
+	jne	.L7
+	movq	-8(%rbp), %rax
+	movq	%rax, %rdi
+	call	free@PLT
+	movl	$0, %eax
+	jmp	.L6
+.L7:
+	movq	-8(%rbp), %rax
+	leaq	.LC1(%rip), %rdx
+	movq	%rdx, %rsi
+	movq	%rax, %rdi
+	call	strcspn@PLT
+	movq	-8(%rbp), %rdx
+	addq	%rdx, %rax
+	movb	$0, (%rax)
+	movq	-8(%rbp), %rax
+.L6:
+	leave
+	.cfi_def_cfa 7, 8
+	ret
+	.cfi_endproc
+.LFE7:
+	.size	inS, .-inS
+	.section	.rodata
+.LC2:
+	.string	"%d"
+	.text
+	.globl	printI
+	.type	printI, @function
+printI:
+.LFB8:
+	.cfi_startproc
+	pushq	%rbp
+	.cfi_def_cfa_offset 16
+	.cfi_offset 6, -16
+	movq	%rsp, %rbp
+	.cfi_def_cfa_register 6
+	subq	$16, %rsp
+	movl	%edi, -4(%rbp)
+	movl	-4(%rbp), %eax
+	movl	%eax, %esi
+	leaq	.LC2(%rip), %rax
+	movq	%rax, %rdi
+	movl	$0, %eax
+	call	printf@PLT
+	movl	$0, %eax
+	leave
+	.cfi_def_cfa 7, 8
+	ret
+	.cfi_endproc
+.LFE8:
+	.size	printI, .-printI
+	.globl	inI
+	.type	inI, @function
+inI:
+.LFB9:
+	.cfi_startproc
+	pushq	%rbp
+	.cfi_def_cfa_offset 16
+	.cfi_offset 6, -16
+	movq	%rsp, %rbp
+	.cfi_def_cfa_register 6
+	addq	$-128, %rsp
+	movq	%fs:40, %rax
+	movq	%rax, -8(%rbp)
+	xorl	%eax, %eax
+	movq	stdin(%rip), %rdx
+	leaq	-112(%rbp), %rax
+	movl	$100, %esi
+	movq	%rax, %rdi
+	call	fgets@PLT
+	testq	%rax, %rax
+	jne	.L11
+	movl	$0, %eax
+	jmp	.L14
+.L11:
+	leaq	-116(%rbp), %rdx
+	leaq	-112(%rbp), %rax
+	leaq	.LC2(%rip), %rcx
+	movq	%rcx, %rsi
+	movq	%rax, %rdi
+	movl	$0, %eax
+	call	__isoc99_sscanf@PLT
+	cmpl	$1, %eax
+	je	.L13
+	movl	$0, %eax
+	jmp	.L14
+.L13:
+	movl	-116(%rbp), %eax
+.L14:
+	movq	-8(%rbp), %rdx
+	subq	%fs:40, %rdx
+	je	.L15
+	call	__stack_chk_fail@PLT
+.L15:
+	leave
+	.cfi_def_cfa 7, 8
+	ret
+	.cfi_endproc
+.LFE9:
+	.size	inI, .-inI
+	.globl	printC
+	.type	printC, @function
+printC:
+.LFB10:
+	.cfi_startproc
+	pushq	%rbp
+	.cfi_def_cfa_offset 16
+	.cfi_offset 6, -16
+	movq	%rsp, %rbp
+	.cfi_def_cfa_register 6
+	subq	$16, %rsp
+	movl	%edi, %eax
+	movb	%al, -4(%rbp)
+	movsbl	-4(%rbp), %eax
+	movl	%eax, %edi
+	call	putchar@PLT
+	movl	$0, %eax
+	leave
+	.cfi_def_cfa 7, 8
+	ret
+	.cfi_endproc
+.LFE10:
+	.size	printC, .-printC
+	.section	.rodata
+.LC3:
+	.string	" %c"
+	.text
+	.globl	inC
+	.type	inC, @function
+inC:
+.LFB11:
+	.cfi_startproc
+	pushq	%rbp
+	.cfi_def_cfa_offset 16
+	.cfi_offset 6, -16
+	movq	%rsp, %rbp
+	.cfi_def_cfa_register 6
+	subq	$16, %rsp
+	movq	%fs:40, %rax
+	movq	%rax, -8(%rbp)
+	xorl	%eax, %eax
+	leaq	-9(%rbp), %rax
+	movq	%rax, %rsi
+	leaq	.LC3(%rip), %rax
+	movq	%rax, %rdi
+	movl	$0, %eax
+	call	__isoc99_scanf@PLT
+	cmpl	$1, %eax
+	je	.L19
+	movl	$0, %eax
+	jmp	.L21
+.L19:
+	movzbl	-9(%rbp), %eax
+.L21:
+	movq	-8(%rbp), %rdx
+	subq	%fs:40, %rdx
+	je	.L22
+	call	__stack_chk_fail@PLT
+.L22:
+	leave
+	.cfi_def_cfa 7, 8
+	ret
+	.cfi_endproc
+.LFE11:
+	.size	inC, .-inC
+	.section	.rodata
+.LC4:
+	.string	"true"
+.LC5:
+	.string	"false"
+	.text
+	.globl	printB
+	.type	printB, @function
+printB:
+.LFB12:
+	.cfi_startproc
+	pushq	%rbp
+	.cfi_def_cfa_offset 16
+	.cfi_offset 6, -16
+	movq	%rsp, %rbp
+	.cfi_def_cfa_register 6
+	subq	$16, %rsp
+	movl	%edi, %eax
+	movb	%al, -4(%rbp)
+	cmpb	$0, -4(%rbp)
+	je	.L24
+	leaq	.LC4(%rip), %rax
+	movq	%rax, %rdi
+	movl	$0, %eax
+	call	printf@PLT
+	jmp	.L25
+.L24:
+	leaq	.LC5(%rip), %rax
+	movq	%rax, %rdi
+	movl	$0, %eax
+	call	printf@PLT
+.L25:
+	movl	$0, %eax
+	leave
+	.cfi_def_cfa 7, 8
+	ret
+	.cfi_endproc
+.LFE12:
+	.size	printB, .-printB
+	.ident	"GCC: (GNU) 14.2.1 20250207"
+	.section	.note.GNU-stack,"",@progbits

src/codegen.c

@@ -3,92 +3,112 @@
 
 #include "codegen.h"
 int paramCount = 0;
+int funDec = 0;
 int generate() {
     offset = 0;
     currentsp = 0;
     Instruction *i = begin;
-
+    funList = NULL;
     // temporary
     fprintf(cg_flag, ".globl entry\n");
 
     while (i != NULL) {
         switch (getOp(i)) {
-            case E_LABEL:
+        case E_LABEL:
-                generateLabel(i);
+            generateLabel(i);
-                break;
+            break;
-            case E_ADD:
+        case E_ADD:
-                generateAdd(i);
+            generateAdd(i);
-                break;
+            break;
-            case E_SUB:
+        case E_SUB:
-                generateSub(i);
+            generateSub(i);
-                break;
+            break;
-            case E_MUL:
+        case E_MUL:
-                generateMult(i);
+            generateMult(i);
-                break;
+            break;
-            case E_DIV:
+        case E_DIV:
-                generateDiv(i);
+            generateDiv(i);
-                break;
+            break;
-            case E_MOD:
+        case E_MOD:
-                generateMod(i);
+            generateMod(i);
-                break;
+            break;
-            case E_OR:
+        case E_OR:
-                generateOr(i);
+            generateOr(i);
-                break;
+            break;
-            case E_AND:
+        case E_AND:
-                generateAnd(i);
+            generateAnd(i);
-                break;
+            break;
-            case E_NEG:
+        case E_NEG:
-                generateNeg(i);
+            generateNeg(i);
-                break;
+            break;
-            case E_NOT:
+        case E_NOT:
-                generateNot(i);
+            generateNot(i);
-                break;
+            break;
-            case E_ASSIGN:
+        case E_ASSIGN:
-                generateAssign(i);
+            generateAssign(i);
-                break;
+            break;
-            case E_GOTO:
+        case E_GOTO:
-                generateGoto(i);
+            generateGoto(i);
-                break;
+            break;
-            case E_IF_X_TRUE:
+        case E_IF_X_TRUE:
-                generateIfTrue(i);
+            generateIfTrue(i);
-                break;
+            break;
-            case E_IF_X_FALSE:
+        case E_IF_X_FALSE:
-                generateIfFalse(i);
+            generateIfFalse(i);
-                break;
+            break;
-            case E_LESS_THAN:
+        case E_LESS_THAN:
-                generateLessThan(i);
+            generateLessThan(i);
-                break;
+            break;
-            case E_EQUAL_TO:
+        case E_EQUAL_TO:
-                generateEqualTo(i);
+            generateEqualTo(i);
-                break;
+            break;
-            case E_CALL:
+        case E_CALL:
-                generateCall(i);
+            generateCall(i);
-                break;
+            break;
-            case E_PARAM:
+        case E_PARAM:
-                generateParam(i);
+            generateParam(i);
-                break;
+            break;
-            case E_RETURN:
+        case E_RETURN:
-                generateReturn(i);
+            generateReturn(i);
-                break;
+            break;
-            case E_INDEX_COPY_RIGHT:
+        case E_INDEX_COPY_RIGHT:
-                generateCopyRight(i);
+            generateCopyRight(i);
-                break;
+            break;
-            case E_INDEX_COPY_LEFT:
+        case E_INDEX_COPY_LEFT:
-                generateCopyLeft(i);
+            generateCopyLeft(i);
-                break;
+            break;
-            case E_ADDRESS_OF:
+        case E_ADDRESS_OF:
-                generateAddressOf(i);
+            generateAddressOf(i);
-                break;
+            break;
-            case E_FUNC_START:
+        case E_FUNC_START:
-                generateFunctionStart(i);
+            generateFunctionStart(i);
-                break;
+            break;
-            default:;
+        case E_FUNC_DEC:
+            generateFunctionDec(i);
+            break;
+        default:;
         }
         i = i->next;
     }
     return -1;
 }
 
+bool isAnActualFunction(TableNode *tn) {
+    FunDecList *fdl = funList;
+    while (fdl != NULL) {
+        printf("%s %s, %s %s\n", getName(fdl->tn), getType(fdl->tn), getName(tn), getType(tn));
+        if (tn == fdl->tn) {
+            return true;
+        }
+        fdl = fdl ->next;
+    }
+    return false;
+}
+
+void align(TableNode *tn) {
+    int size = getPrimSize(getTypeEntry(tn));
+    offset += offset % size;
+}
 CGNode *getNextCG(CGNode *cg) {
     if (cg == NULL) {
         return NULL;
@@ -125,6 +145,7 @@ CGNode *findCG(TableNode *tn) {
 CGNode *addCG(TableNode *tn, int sp) {
     CGNode *cg = calloc(1, sizeof(CGNode));
     cg->tn = tn;
+    align(tn);
     offset += getPrimSize(getTypeEntry(tn));
     cg->address = offset;
     cg->next = cgList;
@@ -132,6 +153,16 @@ CGNode *addCG(TableNode *tn, int sp) {
     return cg;
 }
 
+int generateFunctionDec(Instruction *i) {
+    FunDecList * fd = calloc(1, sizeof(FunDecList));
+    CGNode *cg = addCG(getResult(i),offset);
+//    printf("%d\n", getAddress(cg)+currentsp);
+    offset += 8;
+    fd->tn = getResult(i);
+    fd->next = funList;
+    funList = fd;
+    return 0;
+}
 int generateLabel(Instruction *inst) {
     if (inst == NULL) {
         return -1;
@@ -358,10 +389,10 @@ int generateOr(Instruction *inst) {
 
     int label = label_gen();
 
-    fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\t#start or\n", getAddress(op1CG));
+    fprintf(cg_flag, "\tcmpb\t$0, %d(%%rbp)\t#start or\n", getAddress(op1CG));
     fprintf(cg_flag, "\tjne\t.L%dor2\n", label);
 
-    fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\n", getAddress(op2CG));
+    fprintf(cg_flag, "\tcmpb\t$0, %d(%%rbp)\n", getAddress(op2CG));
     fprintf(cg_flag, "\tje\t.L%dor3\n", label);
 
     fprintf(cg_flag, ".L%dor2:\n", label);
@@ -409,10 +440,10 @@ int generateAnd(Instruction *inst) {
     }
     int label = label_gen();
 
-    fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\t#start and\n", getAddress(op1CG));
+    fprintf(cg_flag, "\tcmpb\t$0, %d(%%rbp)\t#start and\n", getAddress(op1CG));
     fprintf(cg_flag, "\tje\t.L%dor2\n", label);
 
-    fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\n", getAddress(op2CG));
+    fprintf(cg_flag, "\tcmpb\t$0, %d(%%rbp)\n", getAddress(op2CG));
     fprintf(cg_flag, "\tje\t.L%dor2\n", label);
 
     fprintf(cg_flag, "\tmovl\t$1, %%eax\n");
@@ -496,7 +527,23 @@ int generateAssign(Instruction *inst) {
 
     //add option for constant assignment (should be easy)
     if (isConst(op1) == true) {
-        fprintf(cg_flag, "\tmovl\t$%d, %d(%%rbp)\t#constant assign\n", getConst(op1), getAddress(cg));
+        char *movtype;
+        char *reg;
+        TableNode *typetn = getTypeEntry(getResult(inst));
+        if (typetn == integ) {
+            movtype = "movl";
+            reg = "%eax";
+        } else if (typetn == boo) {
+            movtype = "movb";
+            reg = "%al";
+        } else if (typetn == chara) {
+            movtype = "movb";
+            reg = "%al";
+        } else {
+            movtype = "movq";
+            reg = "%rax";
+        }
+        fprintf(cg_flag, "\t%s\t$%d, %d(%%rbp)\t#constant assign\n",movtype, getConst(op1), getAddress(cg));
         return 0;
     }
 
@@ -504,14 +551,35 @@ int generateAssign(Instruction *inst) {
         printdebug("generateAssign failed, %s is not constant but not in CGlist", getName(getTN(op1)));
         return -1;
     }
-
+    if (getAdInfoType(getTN(op1)) != TYPE_FUNCTION_DECLARATION || table_lookup(getAncestor(cur), getName(getTN(op1))) == undefined){
-    fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#assign start\n", getAddress(op1CG));
+        char *movtype;
-    fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#assign end\n", getAddress(cg));
+        char *reg;
+        TableNode *typetn = getTypeEntry(getTN(op1));
+        if (typetn == integ) {
+            movtype = "movl";
+            reg = "%eax";
+        } else if (typetn == boo) {
+            movtype = "movb";
+            reg = "%al";
+        } else if (typetn == chara) {
+            movtype = "movb";
+            reg = "%al";
+        } else {
+            movtype = "movq";
+            reg = "%rax";
+        }
+        fprintf(cg_flag, "\t%s\t%d(%%rbp), %s\t#assign start\n",movtype, getAddress(op1CG), reg);
+        fprintf(cg_flag, "\t%s\t%s, %d(%%rbp)\t#assign end\n", movtype,reg,getAddress(cg));
+    } else {
+        fprintf(cg_flag, "\tmovl\t$%s,%%eax\t#assign function\n", getName(getTN(op1)));
+        fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#assign function end\n", getAddress(cg));
+    }
     return 0;
 }
 
 int generateGoto(Instruction *inst) {
-    return -1;
+    fprintf(cg_flag, "\tjmp\t.L%d\n", getLabel(inst));
+    return 0;
 }
 
 int generateCondGoto(Instruction *inst) {
@@ -519,12 +587,39 @@ int generateCondGoto(Instruction *inst) {
 }
 
 int generateIfTrue(Instruction *inst) {
-    return -1;
+    TNodeOrConst *op1 = getOperand1(inst);
-    // might just be a goto for where to go if something is true, or returning if something is true, or checking if true and writing goto if thats the case
+
+    if (op1 == NULL) {
+        printdebug("%sgenerateIfTrue failed, NULL operand", COLOR_RED);
+        return -1;
+    }
+
+    CGNode *cg = findCG(getTN(op1));
+    if (cg == NULL) {
+        printdebug("generateIfTrue failed, operand not on stack");
+        return -1;
+    }
+
+    fprintf(cg_flag, "\tcmpb\t$0, %d(%%rbp)\t#if true start\n", getAddress(cg));
+    fprintf(cg_flag, "\tjne\t.L%d\t\t#if true end\n", getLabel(inst));
 }
 
 int generateIfFalse(Instruction *inst) {
-    return -1;
+    TNodeOrConst *op1 = getOperand1(inst);
+
+    if (op1 == NULL) {
+        printdebug("%sgenerateIfFalse failed, NULL operand", COLOR_RED);
+        return -1;
+    }
+
+    CGNode *cg = findCG(getTN(op1));
+    if (cg == NULL) {
+        printdebug("generateIfFalse failed, operand not on stack");
+        return -1;
+    }
+
+    fprintf(cg_flag, "\tcmpb\t$0, %d(%%rbp)\t#if false start\n", getAddress(cg));
+    fprintf(cg_flag, "\tje\t.L%d\t\t#if false end\n", getLabel(inst));
 }
 
 int generateLessThan(Instruction *inst) {
@@ -595,10 +690,33 @@ int generateEqualTo(Instruction *inst) {
         printdebug("generateLessThan failed, %s is not initialized/in CG", getName(getTN(op2)));
         return -1;
     }
+        char *movtype;
+        char *reg;
+        char *cmptype;
+        TableNode *typetn = getTypeEntry(getTN(op1));
+        if (typetn == integ) {
+                movtype = "movl";
 
-    fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#equal to start\n", getAddress(op1CG));
+            cmptype = "cmpl";
-    fprintf(cg_flag, "\tcmpl\t%d(%%rbp), %%eax\n", getAddress(op2CG));
+            reg = "%eax";
+        } else if (typetn == boo) {
+            cmptype = "cmpb";
+                movtype = "movb";
+            reg = "%al";
+        } else if (typetn == chara) {
+            cmptype = "cmpb";
+                movtype = "movb";
+            reg = "%al";
+        } else {
+            cmptype = "cmpq";
+                movtype = "movq";
+            reg = "%rax";
+        }
+
+    fprintf(cg_flag, "\t%s\t%d(%%rbp), %s\t#equal to start\n", movtype, getAddress(op1CG), reg);
+    fprintf(cg_flag, "\t%s\t%d(%%rbp), %s\n", cmptype, getAddress(op2CG), reg);
     fprintf(cg_flag, "\tsete\t%%al\n");
+    fprintf(cg_flag, "\tmovb\t$0, %d(%%rbp)\n", getAddress(cg));
     fprintf(cg_flag, "\tmovb\t%%al, %d(%%rbp)\t#equal to end\n", getAddress(cg));
     return 0;
 }
@@ -621,13 +739,21 @@ int generateCall(Instruction *inst) {
         return -1;
     }
 
-    // if (getTN(op2) == NULL) {
+    if (table_lookup(getAncestor(cur),getName(getTN(op1)))!=undefined) {
-    //  printdebug("generateFunctionCall failed, NULL tablenode2");
+        fprintf(cg_flag, "\tcall %s\n", getName(getTN(op1)));
-    //  return -1;
+    } else {
-    //}
+        //    printf("%s\n", getName(getTN(op1)));
-
+        if (findCG(getTN(op1)) == NULL) {
-    fprintf(cg_flag, "\tcall %s\n", getName(getTN(op1)));
+            //printf("generateFunctionCall failed, function not in stack");
-
+            return -1;
+        }
+        fprintf(cg_flag, "\tmovq\t%d(%%rbp), %%rax\t#call %s!\n", getAddress(findCG(getTN(op1))), getName(getTN(op1)));
+        fprintf(cg_flag, "\tcall *%%rax\n");
+    }
+    //if (getTN(op2) == NULL) {
+        //printdebug("generateFunctionCall failed, NULL tablenode2");
+            // return -1;
+            // }
     //now for the return
     CGNode *cg = findCG(getResult(inst));
 
@@ -653,8 +779,11 @@ int generateReturn(Instruction *inst) {
         printdebug("generateReturn failed, trying to return %s not in CGList", getName(getTN(op1)));
         return -1;
     }
-
+    if (table_lookup(getAncestor(cur), getName(getTN(op1))) != undefined) {
-    fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#return %s\n", getAddress(cg), getName(getTN(op1)));
+        fprintf(cg_flag, "\tmovl\t$%s,%%eax\t#return a function\n", getName(getTN(op1)));
+    } else {
+        fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#return %s\n", getAddress(cg), getName(getTN(op1)));
+    }
     fprintf(cg_flag, "\tleave\n");
     fprintf(cg_flag, "\tret\n");
     return 0;
@@ -671,7 +800,7 @@ int generateAddressOf(Instruction *inst) {
 
 int generateParam(Instruction *inst) {
     TNodeOrConst *op1 = getOperand1(inst);
-    fprintf(stderr, "generate param reached\n");
+    //fprintf(stderr, "generate param reached\n");
     if (op1 == NULL) {
         printdebug("generateParam failed, NULL operand");
         return -1;
@@ -703,8 +832,9 @@ int generateParam(Instruction *inst) {
         fprintf(cg_flag, "\tmovl\t%d(%%rbp), %s\t#adding param start\n", getAddress(op1CG), REG6);
         break;
     default:
+        align(getTN(op1));
         offset += getPrimSize(getTypeEntry(getTN(op1)));
-        fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#adding param start\n", getAddress(op1CG)); 
+        fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#adding param start\n", getAddress(op1CG));
         fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#adding param end\n", offset - getPrimSize(getTypeEntry(getTN(op1))));
     }
     return 0;
@@ -723,7 +853,7 @@ int generateFunctionStart(Instruction *inst) {
     fprintf(cg_flag, "%s:\n", getName(funDecTN));
     fprintf(cg_flag, "\tpushq\t%%rbp\n");
     fprintf(cg_flag, "\tmovq\t%%rsp, %%rbp\n");
-    fprintf(cg_flag, "\tsubq\t$%d, %%rsp\n", 128);  // [CHANGE ME] 128 is a placeholder for the stack size
+    fprintf(cg_flag, "\tsubq\t$%d, %%rsp\n", getStackSize());
 
     //now we need to add the CGs of nodes to the CG list by doing assign from the
     // have function declararation node
@@ -737,7 +867,8 @@ int generateFunctionStart(Instruction *inst) {
     TableNode *tnToAdd = getFirstEntry(st);
     if (getAdInfoType(paramTN) != TYPE_RECORD_TYPE) {
       CGNode *paramCG = addCG(tnToAdd, offset);
-      paramOffset += getPrimSize(tnToAdd);
+      int size = getPrimSize(getTypeEntry(tnToAdd));
+      paramOffset += getPrimSize(getTypeEntry(tnToAdd));
       fprintf(cg_flag, "\tmovl\t%%edi, %d(%%rbp)\t#FunctionStart1param end\n", getAddress(paramCG));
     } else {
         int numParams = getRecLength(paramTN);
@@ -763,7 +894,8 @@ int generateFunctionStart(Instruction *inst) {
                 fprintf(cg_flag, "\tmovl\t%s, %d(%%rbp)\t#FunctionStart1param end\n", REG6, getAddress(paramCG));
                 break;
             default:
-                paramOffset += getPrimSize(getTypeEntry(tnToAdd));
+                int size = getPrimSize(getTypeEntry(tnToAdd));
+                paramOffset +=  size;
                 offset += getPrimSize(getTypeEntry(tnToAdd));
                 fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#FunctionStart1Param start\n", paramOffset);
                 fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#FunctionStart1param end\n", getAddress(paramCG));
@@ -774,5 +906,17 @@ int generateFunctionStart(Instruction *inst) {
         }
     }
 
+/*    if (strcmp(getName(funDecTN), "entry") == 0) {
+        if (funList == NULL) {
+            return -1;
+        }
+        TableNode *funDec;
+        while (funList != NULL) {
+            funDec = funList->tn;
+            CGNode *cg = findCG(getResult(inst));
+            fprintf(cg_flag, "\tmovq\t$%s, %d(%%rbp)\t#storing function declaration\n", getName(funDec), getAddress(cg));
+            funList = funList->next;
+        }
+        } */
     return 0;
 }

src/codegen.h

@@ -25,15 +25,22 @@ extern FILE *cg_flag;
 typedef struct CGNode {
     TableNode *tn;
     int address;
-    CGNode *next;
+    struct CGNode *next;
 } CGNode;
 
+typedef struct FunDecList {
+    TableNode *tn;
+    struct FunDecList *next;
+} FunDecList;
+
+bool isAnActualFunction(TableNode *tn);
 int generate();
 CGNode *getNextCG(CGNode *cg);
 int getAddress(CGNode *cg);
 TableNode *getTNofCG(CGNode *cg);
 CGNode *findCG(TableNode *tn);
 CGNode *addCG(TableNode *tn, int sp);
+int generateFunctionDec(Instruction *inst);
 int generateLabel(Instruction *inst);
 int generateAdd(Instruction *inst);
 int generateSub(Instruction *instruction);
@@ -62,7 +69,9 @@ int generateFunctionStart(Instruction *instruction);
 extern int label_count;
 extern Instruction *begin;
 extern Instruction *current;
+extern SymbolTable *top;
 
 extern int offset;
 extern int currentsp;
 extern CGNode *cgList;
+extern FunDecList *funList;

src/grammar.h

@@ -33,7 +33,7 @@ Instruction *current;
 int offset;
 int currentsp;
 CGNode *cgList;
-
+FunDecList *funList;
 Stack *stack;
 Stack *TrueList;
 Stack *FalseList;

src/grammar.y

@@ -613,6 +613,9 @@ compound_statement:
                 emit_label(*l);
                 S_Push(stack, l, 2);
         } expression R_PAREN {
+                emit_conditional_jump(E_IF_X_FALSE, 0, tn_or_const(NODE, $4));
+                Stack * t = S_Peek(FalseList);
+                S_Push(t, current, 1);
                 emit_label(label_gen());
                 emit_backpatch(S_Pop(TrueList), getLabel(current));
         } sblock {
@@ -622,6 +625,7 @@ compound_statement:
                 emit_goto(*(int*)(S_Pop(stack)));
                 emit_label(l);
         }
+        // IF L_PAREN expression R_PAREN THEN sblock ELSE sblock
     |   IF L_PAREN {
                 S_Push(TrueList, S_Init(), 0);
                 S_Push(FalseList, S_Init(), 0);
@@ -681,22 +685,19 @@ compound_statement:
 simple_statement:
         assignable{
             //updating context for reserve/release
-                if(getAdInfoType((TableNode*)$1) == TYPE_ARRAY){
+                if(getAdInfoType((TableNode*)$1) == TYPE_ARRAY || getAdInfoType((TableNode*)$1) == TYPE_FUNCTION_DECLARATION){
+                    PushContext(getTypeEntry((TableNode*)$1));
                     
-                    context = 1;
+                    //printf("pushed %s to context stack in simple statement assignable rule\n",getName(getContextTypeEntry(context_head)));
                 }
-                else if(getAdInfoType((TableNode*)$1) == TYPE_RECORD){
-                    context = 2;
-                } else{
-                    context = 0;
-                }
-                //comparator = $1;
                 S_Push(TrueList, S_Init(), 0);
                 S_Push(FalseList, S_Init(), 0);
         } ASSIGN expression
          {
 // ----------------------------------------------------------------------------
-                emit_label(label_gen());
+                if ( getTypeEntry((TableNode*)$4) == boo ) {
+                        emit_label(label_gen());
+                }
                 emit_backpatch(S_Pop(TrueList), getLabel(current));
                 emit_backpatch(S_Pop(FalseList), getLabel(current));
 // ----------------------------------------------------------------------------
@@ -733,7 +734,10 @@ simple_statement:
             }
             $$ = undefined;
             //resetting context
-            context = 0;
+                if(getAdInfoType((TableNode*)$1) == TYPE_ARRAY || getAdInfoType((TableNode*)$1) == TYPE_FUNCTION_DECLARATION){
+                    PopContext();
+                    printdebug("popped a context off in simplestatement assignable rule\n");
+                }
         }
 
 
@@ -777,9 +781,15 @@ ablock:
     ;
 
 
-
 argument_list:
+
         expression{
+            PopContext();
+            printdebug("popped a context off in argument list\n");
+            incrementArgumentNumber(function_head);
+            TableNode* typeOfArg = getFunctionNumberType(getFunctionType(function_head), getArgumentNumber(function_head));
+            PushContext(typeOfArg);
+            printdebug("pushed %s to context stack\n",getName(typeOfArg));
             TableNode * arg = CreateEntry(cur, getAdInfoType((TableNode*)$1), getTypeEntry((TableNode*)$1), arg_var_gen(), NULL);
             //inside a scope of an array call if line number is -2
             if(getLine(cur)==-2){
@@ -806,6 +816,8 @@ argument_list:
     |   expression
 
         {
+            PopContext();
+            printdebug("popped a context off in argument list (single arg rule)\n");
             TableNode* arg = CreateEntry(cur, getAdInfoType((TableNode*)$1), getTypeEntry((TableNode*)$1), arg_var_gen(), NULL);
             //inside a scope of an array call if line number is -2
             if(getLine(cur)==-2){
@@ -944,8 +956,8 @@ expression:
 // ----------------------------------------------------------------------------
                 uint_least8_t b = 0;
                 emit_assignment(node, tn_or_const(BOOLEAN,&b));
-                emit_label(label_gen());
+                // emit_label(label_gen());
-                emit_backpatch(S_Pop(TrueList), getLabel(current));
+                // emit_backpatch(S_Pop(TrueList), getLabel(current));
                 emit_conditional_jump(E_IF_X_FALSE, 0, tn_or_const(NODE, $1));
                 Stack * t1 = S_Peek(FalseList);
                 if(t1==NULL){
@@ -997,8 +1009,8 @@ expression:
 // ----------------------------------------------------------------------------
                 uint_least8_t b = 1;
                 emit_assignment(node, tn_or_const(BOOLEAN,&b));
-                emit_label(label_gen());
+                // emit_label(label_gen());
-                emit_backpatch(S_Pop(TrueList), getLabel(current));
+                // emit_backpatch(S_Pop(TrueList), getLabel(current));
                 emit_conditional_jump(E_IF_X_TRUE, 0, tn_or_const(NODE, $1));
                 Stack * t1 = S_Peek(TrueList);
                 if(t1==NULL){
@@ -1050,7 +1062,6 @@ expression:
                 // emit_label(label_gen());
                 // emit_backpatch(S_Pop(TrueList), getLabel(current));
                 emit_binary_op(E_LESS_THAN, node, tn_or_const(NODE,$1), tn_or_const(NODE,$3));
-                /*
                 emit_conditional_jump(E_IF_X_TRUE, 0, tn_or_const(NODE, node));
                 Stack * t = S_Peek(TrueList);
                 if(t==NULL){
@@ -1065,6 +1076,7 @@ expression:
                         S_Push(FalseList, t, 1);
                 }
                 S_Push(t, current, 1);
+                /*
                 */
 // ----------------------------------------------------------------------------
             printdebug("less than expression");
@@ -1084,7 +1096,6 @@ expression:
                 TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL);
 // ----------------------------------------------------------------------------
                 emit_binary_op(E_EQUAL_TO, node, tn_or_const(NODE,$1), tn_or_const(NODE,$3));
-                /*
                 emit_conditional_jump(E_IF_X_TRUE, 0, tn_or_const(NODE, node));
                 Stack * t = S_Peek(TrueList);
                 if(t==NULL){
@@ -1099,6 +1110,7 @@ expression:
                         S_Push(FalseList, t, 1);
                 }
                 S_Push(t, current, 1);
+                /*
                 */
                 // emit_label(label_gen());
                 // emit_backpatch(S_Pop(TrueList), getLabel(current));
@@ -1127,7 +1139,7 @@ expression:
         }
 
         // TODO: We need to type check this.
-    |   RESERVE ID {
+    /*|   RESERVE ID {
                         char* temp = temp_var_gen();
                         TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, addr, temp, NULL);
                         TableNode * n = look_up(cur, $2);
@@ -1140,7 +1152,7 @@ expression:
                         emit_reserve(node, tn_or_const(INTEGER, &v));
                         $$ = node;
                      }
-    /*|   RELEASE ID {
+    |   RELEASE ID {
                         TableNode * n = look_up(cur, $2);
                         if(getAdInfoType(n) != TYPE_RECORD){
                                 throw_error(ERROR_TYPE, "Invalid Release expression with object %s of type %s.",
@@ -1151,7 +1163,7 @@ expression:
                         TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, integ, temp, NULL);
                         //emit release needed here
                         $$ = node;
-         }*/
+         }
     |   RESERVE ID {
                  cur = CreateScope(cur, -2,-1);
         } ablock {
@@ -1174,7 +1186,68 @@ expression:
                                 $$=undefined;
                         }
                         cur = getParent(cur);
+        }*/
+    |   RESERVE assignable{
+
+                                if(getTypeEntry((TableNode*)$2) == getContextTypeEntry(context_head)
+                                && (/*getAdInfoType((TableNode*)$2)==TYPE_ARRAY ||*/ getAdInfoType(getTypeEntry((TableNode*)$2)) == TYPE_RECORD)){
+                                char* temp = temp_var_gen();
+                                //does this have integer?
+                                TableNode* node = CreateEntry(cur,TYPE_RECORD, getContextTypeEntry(context_head), temp, NULL);
+                                emit_reserve(node, tn_or_const(NODE,$2));
+                                $$ = node;
+                                }
+                        else if(((getTypeEntry((TableNode*)$2)) == getArrType(getContextTypeEntry(context_head)))
+                                && (getAdInfoType(getContextTypeEntry(context_head)) == TYPE_ARRAY_TYPE)){
+                                char* temp = temp_var_gen();
+                                //does this have integer?
+                                TableNode* node = CreateEntry(cur,TYPE_ARRAY, getContextTypeEntry(context_head), temp, NULL);
+                                emit_reserve(node, tn_or_const(NODE,$2));
+                                $$ = node;
+                                }else{
+                                    //printf("%s on right %s on left\n",getType((TableNode*)$2),getName(getArrType(getContextTypeEntry(context_head))));
+                                    //printf("%s is the name of the left\n",getName(getContextTypeEntry(context_head)));
+                                    $$ = undefined;
+                                }
+    }
+
+        |   RELEASE assignable{
+
+                                if(getTypeEntry((TableNode*)$2) == getContextTypeEntry(context_head)
+                                && (/*getAdInfoType((TableNode*)$2)==TYPE_ARRAY ||*/ getAdInfoType(getTypeEntry((TableNode*)$2)) == TYPE_RECORD)){
+                                char* temp = temp_var_gen();
+                                //does this have integer?
+                                TableNode* node = CreateEntry(cur,TYPE_RECORD, getContextTypeEntry(context_head), temp, NULL);
+                                emit_release((TableNode*)$2);
+                                $$ = node;
+                                }
+                        else if(((getTypeEntry((TableNode*)$2)) == getArrType(getContextTypeEntry(context_head)))
+                                && (getAdInfoType(getContextTypeEntry(context_head)) == TYPE_ARRAY_TYPE)){
+                                char* temp = temp_var_gen();
+                                //does this have integer?
+                                TableNode* node = CreateEntry(cur,TYPE_ARRAY, getContextTypeEntry(context_head), temp, NULL);
+                                emit_release((TableNode*)$2);
+                                $$ = node;
+                                }else{
+                                    $$=undefined;
+                                }
         }
+                        
+/*
+                        TableNode* node = CreateEntry(cur,getAdInfoType((TableNode*)$2), getTypeEntry(), temp, NULL);
+                        int a = S_Size(S_Peek(stack)) + 1;
+                        emit_push_all(S_Peek(stack));
+                        S_Pop(stack);
+                        emit_function_call(node, a, tn_or_const(NODE, $2));
+                        $$ = node;
+                        TableNode * n = look_up(cur, $2);
+                        if(getAdInfoType(n) != TYPE_ARRAY){
+                                throw_error(ERROR_TYPE, "Invalid Reserve expression with object %s of type %s.",
+                                                         getName(n), getType(n));
+                                $$=undefined;
+                        }
+                        */
+/*
     |   RELEASE assignable{
                         char* temp = temp_var_gen();
                         TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, integ, temp, NULL);
@@ -1232,6 +1305,14 @@ assignable:
         }
     |   assignable
         {
+            //TableNode* pass = look_up(cur,$1);
+            //if(pass == undefined){
+            //    throw_error(ERROR_TYPE, "Undefined variable %s", $1);
+            if(getAdInfoType((TableNode*)$1) == TYPE_ARRAY|| getAdInfoType((TableNode*)$1) == TYPE_FUNCTION_DECLARATION){
+                PushFunction(1,(TableNode*)$1);
+                PushContext(getFunctionNumberType(getFunctionType(function_head), getArgumentNumber(function_head)));
+                printdebug("pushed %s to function stack\n",getName((TableNode*)$1));
+            }
             printdebug("%sBeginning rule 2 of assignable.", COLOR_CYAN);
             //Creating a dummy scope where we create entries for all the arguments of a function call
             //Must also consider that we might be in an array access
@@ -1246,16 +1327,17 @@ assignable:
 
             if(getAdInfoType((TableNode*)$1) == TYPE_FUNCTION_DECLARATION){
                 //the function context is created. Pushing the type of the function since that has the information needed
-                PushFunction(1, getTypeEntry((TableNode*)$1));
             }
         
         }
         //we have to consider emmissions in ablocks
         ablock
         {
+            if(getAdInfoType((TableNode*)$1) == TYPE_ARRAY|| getAdInfoType((TableNode*)$1) == TYPE_FUNCTION_DECLARATION){
+                PopFunction();
+            }
             //PopContext();
             //int type = getAdInfoType(look_up(getParent(cur), getName((TableNode*)$1)));
-            PopFunction();
             int type = getAdInfoType(getTypeEntry((TableNode*)$1));
             printdebug("%stype is %d", COLOR_PURPLE, type);
             printdebug("%s", getName((TableNode*)$1));
@@ -1421,8 +1503,10 @@ assignable:
 
                 TableNode* node = CreateEntry(cur,t, type, temp, NULL);
                 // getElementOffset(rec, ID)
-                //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
+                // NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
-                //emit_field_access(char* node, char* record, $3)
+                // emit_field_access(char* node, char* record, $3)
+                int n = getElementOffset(getTypeEntry((TableNode*)$1), $3);
+                emit_field_access(node, tn_or_const(NODE, $1), n);
                 $$=node;
             }else{
                 throw_error(ERROR_TYPE, "Invalid field access %s", $3);
@@ -1430,8 +1514,6 @@ assignable:
             }
             printdebug("[ASSIGNABLE - RULE 3] record = name: %s | field = %s", getName((TableNode*)($1)), getName((TableNode*)$3));
         }
-
-
     ;
 
 

src/intermediate_code.c

@@ -190,7 +190,8 @@ void emit_binary_op(
     Op op,
     TableNode *result,
     TNodeOrConst *arg1,
-    TNodeOrConst *arg2) {
+    TNodeOrConst *arg2
+    ) {
     emit_helper();
     current->opcode = op;
     // TODO: create temp and remove result from param list
@@ -315,6 +316,9 @@ void emit_return(TNodeOrConst *value) {
 void emit_reserve(TableNode *result, TNodeOrConst *size) {
     // this needs to change
     // we need to take a int
+        /*
+    emit_binary_op(E_MUL, result,
+    */
     emit_parameter(size);
     emit_function_call(result, 1, tn_or_const(NODE, look_up(cur, "reserve")));
 }
@@ -345,8 +349,12 @@ void emit_address_of(TableNode *x, TNodeOrConst *y) {
     current->operand1 = y;
 }
 
-void emit_field_access(char *result, char *record, char *field) {
+void emit_field_access(TableNode *result, TNodeOrConst *record, int offset){
     emit_helper();
+    current->opcode = E_DEREF_RIGHT;
+    current->result = result;
+    current->operand1 = record;
+    current->operand2 = tn_or_const(INTEGER, &offset);
 }
 
 void emit_array_access(Op op, TableNode *result, TNodeOrConst *array, TNodeOrConst *index) {
@@ -587,19 +595,22 @@ void emit_as_file(FILE *out_file, Instruction *i) {
                     getName(i->result),
                     get_string(i->operand1));
             break;
-
         case E_DEREF_RIGHT:
             fprintf(out_file,
-                    "%4.d:  %s = *%s\n",
+                    "%4.d:  %s = *((char * )%s + %s)\n",
                     i->index,
                     getName(i->result),
-                    get_string(i->operand1));
+                    get_string(i->operand1),
+                    get_string(i->operand2)
+                    );
+            break;
         case E_DEREF_LEFT:
             fprintf(out_file,
                     "%4.d:  *%s = %s\n",
                     i->index,
                     getName(i->result),
                     get_string(i->operand1));
+            break;
     }
 
     emit_as_file(out_file, i->next);
@@ -615,6 +626,12 @@ TableNode *getTN(TNodeOrConst *tnc) {
 int getConst(TNodeOrConst *tnc) {
     if (tnc->d == INTEGER) {
         return tnc->tnc_union->integer;
+    } else if (tnc->d == CHARACTER) {
+        return tnc->tnc_union->character;
+    } else if (tnc->d == BOOLEAN) {
+        return tnc->tnc_union->Boolean;
+    } else if (tnc->d == ADDRESS) {
+        return 0;
     }
     return -1;
-}
+}

src/intermediate_code.h

@@ -49,7 +49,7 @@ typedef enum {        // these are from page 364
     E_SUB,               // 1
     E_MUL,               // 1
     E_DIV,               // 1
-    E_MOD,               // 1 TODO: Please change to REM
+    E_MOD,               // 1
     E_OR,                // 1
     E_AND,               // 1
     E_NEG,               // 2
@@ -143,7 +143,7 @@ void emit_function_dec(TableNode * name);
 void emit_return(TNodeOrConst *value);
 void emit_reserve(TableNode *result, TNodeOrConst *size);
 void emit_release(TableNode *pointer);
-void emit_field_access(char *result, char *record, char *field);
+void emit_field_access(TableNode *result, TNodeOrConst *record, int offset);
 void emit_array_access(Op op, TableNode *result, TNodeOrConst *array, TNodeOrConst *index);
 void emit_bounds_check(TNodeOrConst *index, TNodeOrConst *arr);
 void emit_goto(int i);

src/lexicalStructure.lex

@@ -58,7 +58,24 @@ SCHAR \\n|\\t|\\\"|[^\"\n\\]
 "->"             { if(tok_flag != NULL) {print_tok(ARROW);}         incr(line_number,column_number,ARROW);          return ARROW; }
 
 {DIGIT}+         {if(tok_flag != NULL){print_tok(C_INTEGER);}incr(line_number,column_number,C_INTEGER);yylval.integ = atoi(yytext)/*words = strdup("integer")*/;return C_INTEGER;}
-'{CHAR}'         {if(tok_flag != NULL){print_tok(C_CHARACTER);}incr(line_number,column_number,C_CHARACTER);char* token = strdup(yytext)/*yylval.tn = chara*/;yylval.letter = token[1];return C_CHARACTER;}
+
+
+'{CHAR}'  {
+    if (tok_flag) print_tok(C_CHARACTER);
+    incr(line_number, column_number, C_CHARACTER);
+    
+    int value;
+    if (strcmp(yytext, "'\\n'") == 0) value = 0x0A;
+    else if (strcmp(yytext, "'\\t'") == 0) value = 0x09;
+    else if (strcmp(yytext, "'\\''") == 0) value = 0x27;
+    else if (strcmp(yytext, "'\\\\'") == 0) value = 0x5C;
+    else value = yytext[1];
+
+    yylval.letter = value;
+    return C_CHARACTER;
+}
+
+
 \"{SCHAR}*\"     {if(tok_flag != NULL){print_tok(C_STRING);}incr(line_number,column_number,C_STRING);int k = strlen(yytext);yytext[k-1] = '\0';yylval.words = strdup(&yytext[1]);return C_STRING;}
 {COMMENT}        {if(tok_flag != NULL){print_tok(COMMENT);}incr(line_number,column_number,COMMENT);/*return COMMENT;*/}
 _{DIGIT}+        {if(tok_flag != NULL){print_tok(ACCESS);}incr(line_number,column_number,ACCESS);yylval.integ = atoi(&yytext[1])/*words = strdup("integer")*/;return ACCESS;}
@@ -80,4 +97,4 @@ _{DIGIT}+        {if(tok_flag != NULL){print_tok(ACCESS);}incr(line_number,colum
 " "              { incr(line_number,column_number,0); }
 .                { incr(line_number,column_number,0); }
 
-%%
+%%

src/symbol_table.c

@@ -57,19 +57,19 @@ Constant_Stack *Push(TableNode *type, void *value, bool isConst) {
     return cs;
 }
 
-Context_stack *PushContext(int context, TableNode *typeToCompare) {
+Context_stack *PushContext(/*int context, */TableNode *typeToCompare) {
-    if (context != 1 && context != 2 && context != 3 && context != 0) {
+    /*if (context != 1 && context != 2 && context != 3 && context != 0) {
         printdebug(
             "invalid context passed in");
         return NULL;
-    }
+    }*/
     if(typeToCompare == NULL) {
         printdebug(
             "passed a NULL reference to PushContext. Invalid.");
         return NULL;
     }
     Context_stack *cs = (Context_stack *)calloc(1,sizeof(Context_stack));
-    cs->con = context;
+    //cs->con = context;
     cs->typeToCompare = typeToCompare;
     if (context_head == NULL) {
         context_head = cs;
@@ -107,7 +107,7 @@ Function_Stack *PushFunction(int arg, TableNode* FunctionType) {
 
 Function_Stack *PopFunction() {
     if (function_head == NULL) {
-        printf("cannot pop from an empty stack. Invalid.\n");
+        printf("cannot pop from an empty stack from popfunction. Invalid.\n");
         return NULL;
     }
     Function_Stack *fs = function_head;
@@ -124,6 +124,78 @@ int getArgumentNumber(Function_Stack *fs) {
     return fs->arg;
 }
 
+int getTotalNumberArguments(TableNode* function) {
+    if (function == NULL) {
+        printdebug(
+            "passed a NULL reference to getTotalNumberArguments. Invalid.");
+        return -1;
+    }
+    if (getAdInfoType(function) != TYPE_FUNCTION_DECLARATION) {
+        printdebug(
+            "passed an invalid reference to getTotalNumberArguments. Invalid.");
+        return -1;
+    }
+    TableNode* functionType = getParameter(getTypeEntry(function));
+    if(functionType != undefined){
+        return -1;
+    }
+    if(getAdInfoType(functionType) != TYPE_RECORD_TYPE){
+        return 1;
+    }else{
+        return getRecLength(functionType);
+    }
+}
+
+Function_Stack* setArgumentNumber(Function_Stack *fs, int arg) {
+    if (fs == NULL) {
+        printdebug(
+            "passed a NULL reference to setArgumentNumber. Invalid.");
+        return NULL;
+    }
+
+    if(arg<getTotalNumberArguments(fs->FunctionType)){
+        //case where invalid argument number is being passed
+        return NULL;
+    }
+    fs->arg = arg;
+    return fs;
+}
+Function_Stack* setFunctionType(Function_Stack *fs, TableNode* functionType) {
+    if (fs == NULL) {
+        printdebug(
+            "passed a NULL reference to setFunctionType. Invalid.");
+        return NULL;
+    }
+    if (functionType == NULL) {
+        printdebug(
+            "passed a NULL reference to setFunctionType. Invalid.");
+        return NULL;
+    }
+    fs->FunctionType = functionType;
+    return fs;
+}
+TableNode* getFunctionType(Function_Stack *fs) {
+    if (fs == NULL) {
+        printdebug(
+            "passed a NULL reference to getFunctionType. Invalid.");
+        return undefined;
+    }
+    TableNode* tn = fs->FunctionType;
+    return tn;
+}
+
+Function_Stack* incrementArgumentNumber(Function_Stack *fs) {
+    if (fs == NULL) {
+        printdebug(
+            "passed a NULL reference to incrementArgumentNumber. Invalid.");
+        return NULL;
+    }
+    int cur=getArgumentNumber(fs);
+    setArgumentNumber(fs, cur+1);
+    //setFunctionType(fs, getFunctionNumberType(getFunctionType(fs), cur+1));
+    return fs;
+}
+
 TableNode* getRecordNumberType(TableNode* record, int arg){
     if(record == NULL){
         //case where NULL is being passed in
@@ -159,12 +231,20 @@ TableNode* getFunctionNumberType(TableNode* function, int arg){
         //case where invalid argument number is being passed
         return undefined;
     }
+    if(getAdInfoType(function) == TYPE_FUNCTION_DECLARATION){
+
     if(getAdInfoType(getParameter(function)) != TYPE_RECORD_TYPE){
         return getParameter(function);
     }else{
         return getRecordNumberType(getParameter(function), arg);
     }
+} else if(getAdInfoType(function) == TYPE_ARRAY_TYPE){
+    return getArrType(function);
+}else{
+    return undefined;
 }
+}
+
 
 TableNode* getFunctionTypeContext(Function_Stack *fs) {
     if (fs == NULL) {
@@ -178,15 +258,15 @@ TableNode* getFunctionTypeContext(Function_Stack *fs) {
 
 Context_stack *PopContext() {
     if (context_head == NULL) {
-        printf("cannot pop from an empty stack. Invalid.\n");
+        printf("cannot pop from an empty stack from popcontext. Invalid.\n");
         return NULL;
     }
     Context_stack *cs = context_head;
     context_head = context_head->next;
-    printf("Popped context off stack: number %d\n", cs->con);
+    //printf("Popped context off stack: number %d\n", cs->con);
     return cs;
 }
-
+/*
 int getContextType(Context_stack *cs) {
     if (cs == NULL) {
         printdebug(
@@ -195,8 +275,7 @@ int getContextType(Context_stack *cs) {
     }
     return cs->con;
 }
-
+*/
-//should be 
 TableNode *getContextTypeEntry(Context_stack *cs) {
     if (cs == NULL) {
         printdebug(
@@ -204,7 +283,7 @@ TableNode *getContextTypeEntry(Context_stack *cs) {
         return undefined;
     }
     TableNode* tn = cs->typeToCompare;
-    return NULL;
+    return tn;
 }
 Constant_Stack *Pop() {
     if (head == NULL) {
@@ -615,7 +694,7 @@ int getRecSize(SymbolTable *tn) {
     }
     return -1;
 }
-int getRecPosition(TableNode* rec, char* id){
+int getRecPosition(TableNode *rec, char *id) {
     if (rec == NULL) {
         printdebug(
             "passed a NULL entry to getRecPosition. Invalid.");
@@ -631,25 +710,25 @@ int getRecPosition(TableNode* rec, char* id){
             "not checking the position of a record -- invalid op");
         return -1;
     }
-    TableNode* cur = getFirstEntry(getRecList(rec));
+    TableNode *cur = getFirstEntry(getRecList(rec));
     int i = 1;
-    while(cur != NULL){
+    while (cur != NULL) {
-        if(strcmp(getName(cur), id) == 0){
+        if (strcmp(getName(cur), id) == 0) {
             return i;
         }
         cur = getNextEntry(cur);
         i++;
     }
-    if (cur == NULL){
+    if (cur == NULL) {
         printdebug(
             "passed an invalid entry to getRecPosition. Invalid.");
         return -1;
-    }else{
+    } else {
-    return i;
+        return i;
     }
 }
 
-int getElementOffset(TableNode *rec, char* id) {
+int getElementOffset(TableNode *rec, char *id) {
     if (rec == NULL) {
         printdebug(
             "passed a NULL entry to getElementOffset. Invalid.");
@@ -665,7 +744,7 @@ int getElementOffset(TableNode *rec, char* id) {
             "not checking the offset of a record -- invalid op");
         return -1;
     }
-    int* offsets = getRecOffsets(rec);
+    int *offsets = getRecOffsets(rec);
     int position = getRecPosition(rec, id);
     if (position == -1) {
         printdebug(
@@ -675,11 +754,11 @@ int getElementOffset(TableNode *rec, char* id) {
     position = position - 1;
     int total_offset = 0;
     int current_position = 1;
-    while(current_position < position+1){
+    while (current_position < position + 1) {
         //adding current element in struct
-        total_offset += offsets[2*current_position];
+        total_offset += offsets[2 * current_position];
         //adding padding between elements
-        total_offset += offsets[2*current_position+1];
+        total_offset += offsets[2 * current_position + 1];
         current_position++;
     }
     //returning the offset of the start of the element
@@ -977,31 +1056,31 @@ SymbolTable *init(SymbolTable *start) {
     chara = (TableNode *)calloc(1, sizeof(TableNode));
     stri = (TableNode *)calloc(1, sizeof(TableNode));
     boo = (TableNode *)calloc(1, sizeof(TableNode));
-    TableNode *reservetype = (TableNode *)calloc(1, sizeof(TableNode));
+    //TableNode *reservetype = (TableNode *)calloc(1, sizeof(TableNode));
-    TableNode *reserve = (TableNode *)calloc(1, sizeof(TableNode));
+    //TableNode *reserve = (TableNode *)calloc(1, sizeof(TableNode));
-    TableNode *releasetype = (TableNode *)calloc(1, sizeof(TableNode));
+    //TableNode *releasetype = (TableNode *)calloc(1, sizeof(TableNode));
-    TableNode *release = (TableNode *)calloc(1, sizeof(TableNode));
+    //TableNode *release = (TableNode *)calloc(1, sizeof(TableNode));
     // TableNode* arr = (TableNode*)malloc(sizeof(SymbolTable));
     start->entries = integ;
     integ->next = addr;
     addr->next = chara;
     chara->next = stri;
     stri->next = boo;
-    boo->next = reservetype;
+    boo->next = NULL;//reservetype;
-    reservetype->next = reserve;
+    //reservetype->next = reserve;
-    reserve->next = releasetype;
+    //reserve->next = releasetype;
-    releasetype->next = release;
+    //releasetype->next = release;
-    release->next = NULL;
+    //release->next = NULL;
 
     integ->theName = "integer";
     addr->theName = "address";
     chara->theName = "character";
     boo->theName = "Boolean";
     stri->theName = "string";
-    reserve->theName = "reserve";
+    //reserve->theName = "reserve";
-    reservetype->theName = "reserve type";
+    //reservetype->theName = "reserve type";
-    releasetype->theName = "release type";
+    //releasetype->theName = "release type";
-    release->theName = "release";
+    //release->theName = "release";
     // arr->theName= "array"
 
     // root TableNode that all are pointing to but not in table
@@ -1068,10 +1147,10 @@ SymbolTable *init(SymbolTable *start) {
     chara->theType = prime;
     stri->theType = arrayprim;
     boo->theType = prime;
-    reserve->theType = reservetype;
+    //reserve->theType = reservetype;
-    reservetype->theType = funtypeprime;
+    //reservetype->theType = funtypeprime;
-    releasetype->theType = funtypeprime;
+    //releasetype->theType = funtypeprime;
-    release->theType = releasetype;
+    //release->theType = releasetype;
 
     // arr->theType=arrayprim;
 
@@ -1085,20 +1164,20 @@ SymbolTable *init(SymbolTable *start) {
     chara->additionalinfo = CreatePrimitiveInfo(SIZE_CHAR);
     stri->additionalinfo = CreateArrayInfo(1, chara);
     boo->additionalinfo = CreatePrimitiveInfo(SIZE_BOOL);
-    reserve->additionalinfo = CreateFunctionDeclarationInfo(0, false, NULL);
+    //reserve->additionalinfo = CreateFunctionDeclarationInfo(0, false, NULL);
-    reservetype->additionalinfo = CreateFunctionTypeInfo(integ, addr);
+    //reservetype->additionalinfo = CreateFunctionTypeInfo(integ, addr);
-    releasetype->additionalinfo = CreateFunctionTypeInfo(addr, integ);
+    //releasetype->additionalinfo = CreateFunctionTypeInfo(addr, integ);
-    release->additionalinfo = CreateFunctionDeclarationInfo(0, false, NULL);
+    //release->additionalinfo = CreateFunctionDeclarationInfo(0, false, NULL);
 
     integ->tag = TYPE_PRIMITIVE_TYPE;  // explicitly set the type for integ
     addr->tag = TYPE_PRIMITIVE_TYPE;   // explicitly set the type for addr
     chara->tag = TYPE_PRIMITIVE_TYPE;  // explicitly set the type for chara
     stri->tag = TYPE_ARRAY_TYPE;       // explicitly set the type for stri
     boo->tag = TYPE_PRIMITIVE_TYPE;    // explicitly set the type for boo
-    reserve->tag = TYPE_FUNCTION_DECLARATION;
+    //reserve->tag = TYPE_FUNCTION_DECLARATION;
-    reservetype->tag = TYPE_FUNCTION_TYPE;
+    //reservetype->tag = TYPE_FUNCTION_TYPE;
-    releasetype->tag = TYPE_FUNCTION_TYPE;
+    //releasetype->tag = TYPE_FUNCTION_TYPE;
-    release->tag = TYPE_FUNCTION_DECLARATION;
+    //release->tag = TYPE_FUNCTION_DECLARATION;
     // addr->additionalinfo = CreatePrimitiveInfo(8);
 
     start->Line_Number = 1;
@@ -1642,7 +1721,7 @@ void print_symbol_table(SymbolTable *table, FILE *file_ptr) {
             if ((getFirstChild(node)) == NULL) {
                 print_symbol_table(getFirstChild(node), file_ptr);
             } else {
-                if (getLine(getFirstChild(node)) < 0) {
+                if (getLine(getFirstChild(node)) < -3) {
                     continue;
                 } else {
                     print_symbol_table(getFirstChild(node), file_ptr);
@@ -1892,3 +1971,28 @@ TableNode *printTableNode(TableNode *tn) {
 
     return tn;
 }
+
+int getStackSize() {
+    int i = 0;
+    TableNode *tn = getFirstEntry(top);
+    while (tn != NULL) {
+        i++;
+        tn = getNextEntry(tn);
+    }
+
+    ListOfTable *lt = getChildren(top);
+    while (lt != NULL) {
+        TableNode *first = lt->table->entries;
+        while (first != NULL) {
+            i++;
+            first = getNextEntry(first);
+        }
+
+        lt = lt->next;
+    }
+
+    i= i * 8;
+    if (i % 16 != 0) i += 8;
+
+    return i;
+}

src/symbol_table.h

@@ -46,7 +46,7 @@ typedef struct Constant_Stack {
 //we can also simply add to the function call stack if we have functions inside functions and then update as needed
 
 typedef struct Context_stack {
-    int con;
+    //int con;
     TableNode *typeToCompare;
     struct Context_stack *next;
 } Context_stack;
@@ -134,14 +134,19 @@ void printdebug_impl(char *file, int line, const char *format, ...);
 
 char *temp_var_gen();
 char *arg_var_gen();
+int getTotalNumberArguments(TableNode* function);
+Function_Stack* incrementArgumentNumber(Function_Stack *fs);
+Function_Stack* setArgumentNumber(Function_Stack *fs, int arg);
 Constant_Stack *Push(TableNode *type, void *value, bool isConst);
-Context_stack *PushContext(int context,TableNode *typeToCompare);
+Context_stack *PushContext(/*int context,*/TableNode *typeToCompare);
 Function_Stack *PushFunction(int arg, TableNode* FunctionType);
 Constant_Stack *Pop();
 Context_stack *PopContext();
+Function_Stack* setFunctionType(Function_Stack *fs, TableNode* functionType);
 Function_Stack *PopFunction();
 TableNode* getFunctionTypeContext(Function_Stack *fs);
-int getContextType(Context_stack *cs);
+TableNode* getFunctionType(Function_Stack *fs);
+//int getContextType(Context_stack *cs);
 Constant_Stack *Print_Stack();
 int getArgumentNumber(Function_Stack *fs);
 AdInfo *CreatePrimitiveInfo(int size);
@@ -199,11 +204,19 @@ TableNode *getFirstEntry(SymbolTable *st);
 TableNode *getNextEntry(TableNode *tn);
 TableNode *printTableNode(TableNode *tn);
 
+TableNode *getContextTypeEntry(Context_stack *cs);
+
+int getElementOffset(TableNode *rec, char* id);
+int getRecPosition(TableNode* rec, char* id);
+int getStackSize();
+
+
 extern int yylex(void);
 extern char *yytext;
 extern int yyleng;
 extern int yychar;
 extern SymbolTable *cur;
+extern SymbolTable *top;
 extern int line_number;
 extern int column_number;
 extern FILE *yyin;
@@ -238,4 +251,4 @@ extern char *COLOR_YELLOW;
 extern char *COLOR_LIGHTBLUE;
 extern char *COLOR_LIGHTPURPLE;
 extern char *COLOR_LIGHTCYAN;
-extern char *COLOR_WHITE;
+extern char *COLOR_WHITE;

tests/given/README.MD

@@ -0,0 +1 @@
+NOTE: slightly modified from originals, please execute with care. :)

tests/given/test/functionValue.alpha

@@ -1,6 +1,6 @@
 (* TEST: [-asc -tc] *)
 (* Type definitions *)
-
+#include "std.alpha"
 (* mapping type *)
 type string2int: string -> integer
 
@@ -9,9 +9,9 @@ type funArray: 1 -> string2int
 
 (* record of functions *)
 type funRec: [ string2int: f; string2int: g ]
-
+type int2int: integer -> integer
 (* function returning function *)
-type integer_2_string2int: integer -> string2int
+type integer_2_int2int: integer -> int2int
 
 (* function returning function *)
 type string2int_2_integer: string2int -> integer
@@ -22,22 +22,23 @@ type iXiXc: [integer: a; integer: b; character: c]
 type iic2b: iXiXc -> Boolean
 
 (* Function declarations using the above type definitions *)
-function a: string2int
+function a: int2int
-function b: integer_2_string2int
+function b: integer_2_int2int
 function c: string2int_2_integer
 
 function d: iic2b
 
 d(x,y,z) := {
     [string: s]
- return 0;
+     return true;
 }
 
 function entry: string2int
 
 a(x) := {
     [string : s]
-    s := x;
+    x:= printInteger(x);
+      
     return 0;
 }
 
@@ -50,7 +51,7 @@ b(x) := {
 c(x) := {
     [string: s]
     s := "Hi!";
-    return x(s);
+    return 3;
 }
 
 
@@ -58,10 +59,11 @@ c(x) := {
    entry is the first function called
  *)
 entry(arg) := {
-  [integer: result; string2int: f; integer: temp]
+  [integer: result; int2int: f; integer: temp]
-  temp := a("Hello");
+  temp := 7;
   f := b(temp);
-  result := c(f);
+  result := f(temp);
+  (*result := c(f);*)
   if (d(1,2,'c'))
   then {
      result := 0;
@@ -70,6 +72,6 @@ entry(arg) := {
      [ Boolean : b]
      result := entry("hello");
   }
-  result := c(f);
+  (*result := c(f);*)
   return result;
 }

tests/programs/array.alpha

@@ -0,0 +1,19 @@
+#include "../../library/std.alpha"
+type main: string -> integer
+function entry: main
+
+(* maybe some other type definitions *)
+
+entry(arg) := {
+    [ string: one_name; string: another_name ]
+    
+    one_name := "a string literal";
+    
+    another_name := reserve another_name(4);
+    another_name(0) := 'C';
+    another_name(1) := 'a';
+    another_name(2) := 'r';
+    another_name(3) := 'l';
+
+    return 0;
+}

tests/programs/factorial.alpha

@@ -0,0 +1,42 @@
+#include "std.alpha"
+
+function entry: string2integer
+function calc: integerXinteger2integer
+
+calc(counter, result) := {
+    
+    if ( counter = 0 ) then {
+        return result;
+    } else {
+        result := result * counter;
+        counter := counter - 1;
+        return calc(counter, result);
+    }
+}
+
+
+
+entry (arg) := {
+    [integer: result; integer: userInput]
+
+    result := printC('E');
+    result := printC('n');
+    result := printC('t');
+    result := printC('e');
+    result := printC('r');
+    result := printC(' ');
+    result := printC('N');
+    result := printC('u');
+    result := printC('m');
+    result := printC('b');
+    result := printC('e');
+    result := printC('r');
+    result := printC(':');
+    result := printC(' ');
+
+    userInput := inI(1);
+    userInput := calc(userInput, 1);
+    result := printI(userInput);
+
+    return 0;
+}

tests/programs/fib.alpha

@@ -1 +1,47 @@
-(* TODO: Prints out fib sequence. *)
+#include "std.alpha"
+
+function entry : string2integer
+function fib : integer2integer
+
+fib(i) := {
+
+    if (i < 1) then {
+        return 0;
+    } else {
+        i := i;
+    }
+
+    if (i < 2) then {
+        return i;
+    } else {
+        i := i;
+    }
+
+    return fib(i-1) + fib(i-2);
+}
+
+entry (arg) := {
+    [ integer: result; integer: input; integer: fibValue]
+
+    result := printC('E');
+    result := printC('n');
+    result := printC('t');
+    result := printC('e');
+    result := printC('r');
+    result := printC(' ');
+    result := printC('N');
+    result := printC('u');
+    result := printC('m');
+    result := printC('b');
+    result := printC('e');
+    result := printC('r');
+    result := printC(':');
+    result := printC(' ');
+
+    input := inI(1);
+    fibValue := fib(input);
+
+    result := printI(fibValue);
+
+    return 0;
+}

tests/programs/helloworld.alpha

@@ -1,11 +1,23 @@
 #include "std.alpha"
 
-entry (arg) := {
+function entry: string2integer
-    [string: str; character: ch; integer: result]
 
-    ch := 'h';
+entry (arg) := {
-    str := "Hello World!";
+    [integer: result]
-    result := printCharacter(ch);
+
+    result := printCharacter('H');
+    result := printCharacter('e');
+    result := printCharacter('l');
+    result := printCharacter('l');
+    result := printCharacter('o');
+    result := printCharacter(' ');
+    result := printCharacter('W');
+    result := printCharacter('o');
+    result := printCharacter('r');
+    result := printCharacter('l');
+    result := printCharacter('d');
+    result := printCharacter('!');
+    result := printCharacter('\n');
 
     return 0;
-}
+}

tests/programs/ll.alpha

@@ -1 +0,0 @@
-(* TODO: creates a linked list and prints out the chain. *)

tests/programs/sp3_if_else_sse.alpha

@@ -0,0 +1,36 @@
+#include "std.alpha"
+type rec: [character: x; integer: y]
+
+type T2: rec -> integer
+
+type main: string -> integer
+function entry: main
+                (*
+function bar: T2
+
+bar (r,s) := {
+    return 0;
+}
+
+                *)
+entry (arg) := {
+ 	[ Boolean:x ; Boolean:y ; Boolean:z ; Boolean:t; integer: c]
+        x := false;
+        y := false;
+        if ( (x | y) | !( y = x ) ) then {
+
+                (*
+                 if ( x<y & !(x=y) ) then {
+                        t := 8;
+                } else {
+                }
+                *)
+
+                z := 1 < 2;
+                c := printBoolean(z);
+        } else {
+                y := false; (* bar('c', 7); *)
+                c := printBoolean(y);
+        }
+	return 0;
+}

tests/sprint1/expected/sp1_include.asc.exp

@@ -0,0 +1,3 @@
+001: #include "alpha.h"
+002: #include "alpha.h"
+003: #include "alpha.h"

tests/sprint1/expected/sp1_include.tok.exp

@@ -0,0 +1,6 @@
+1 1 901 "#include"
+1 10 304 ""alpha.h""
+2 1 901 "#include"
+2 10 304 ""alpha.h""
+3 1 901 "#include"
+3 10 304 ""alpha.h""

tests/sprint2/expected/sp2_carls_mistake.st.exp

@@ -23,6 +23,9 @@ arg                           : 025000 : 001001 : string
 result                        : 025000 : 001001 : integer                           : Primitive Instance                
 w                             : 025000 : 001001 : rec                               : Record Instance                   
 ------------------------------:--------:--------:-----------------------------------:-----------------------------------:
+------------------------------:--------:--------:-----------------------------------:-----------------------------------:
+------------------------------:--------:--------:-----------------------------------:-----------------------------------:
+------------------------------:--------:--------:-----------------------------------:-----------------------------------:
 r                             : 021000 : 001001 : integer                           : Primitive Instance                
 s                             : 021000 : 001001 : integer                           : Primitive Instance                
 ------------------------------:--------:--------:-----------------------------------:-----------------------------------:

tests/sprint2/expected/sp2_llnode.st.exp

@@ -26,6 +26,9 @@ result                        : 068000 : 001001 : integer
 w                             : 068000 : 001001 : rec                               : Record Instance                   
 li                            : 068000 : 001001 : llnode                            : Record Instance                   
 ------------------------------:--------:--------:-----------------------------------:-----------------------------------:
+------------------------------:--------:--------:-----------------------------------:-----------------------------------:
+------------------------------:--------:--------:-----------------------------------:-----------------------------------:
+------------------------------:--------:--------:-----------------------------------:-----------------------------------:
 r                             : 053000 : 001001 : integer                           : Primitive Instance                
 s                             : 053000 : 001001 : integer                           : Primitive Instance                
 ------------------------------:--------:--------:-----------------------------------:-----------------------------------:

tests/sprint2/expected/sp2_llnode_bad.st.exp

@@ -26,6 +26,10 @@ result                        : 069000 : 001001 : integer
 w                             : 069000 : 001001 : rec                               : Record Instance                   
 li                            : 069000 : 001001 : llnode                            : Record Instance                   
 ------------------------------:--------:--------:-----------------------------------:-----------------------------------:
+------------------------------:--------:--------:-----------------------------------:-----------------------------------:
+------------------------------:--------:--------:-----------------------------------:-----------------------------------:
+------------------------------:--------:--------:-----------------------------------:-----------------------------------:
+------------------------------:--------:--------:-----------------------------------:-----------------------------------:
 r                             : 054000 : 001001 : integer                           : Primitive Instance                
 s                             : 054000 : 001001 : integer                           : Primitive Instance                
 ------------------------------:--------:--------:-----------------------------------:-----------------------------------:

tests/sprint2/expected/sp2_sp2_arrayargs.st.exp

@@ -14,3 +14,11 @@ a_of_s                        : 001001 :        : 1 -> string
 one_name                      : 006000 : 001001 : string                            : Array Instance                    
 another_name                  : 006000 : 001001 : string                            : Array Instance                    
 many_names                    : 006000 : 001001 : a_of_s                            : Array Instance                    
+------------------------------:--------:--------:-----------------------------------:-----------------------------------:
+------------------------------:--------:--------:-----------------------------------:-----------------------------------:
+------------------------------:--------:--------:-----------------------------------:-----------------------------------:
+------------------------------:--------:--------:-----------------------------------:-----------------------------------:
+------------------------------:--------:--------:-----------------------------------:-----------------------------------:
+------------------------------:--------:--------:-----------------------------------:-----------------------------------:
+------------------------------:--------:--------:-----------------------------------:-----------------------------------:
+------------------------------:--------:--------:-----------------------------------:-----------------------------------:

tests/sprint2/expected/sp2_valid_assignable_and_mem.st.exp

@@ -9,5 +9,13 @@ reserve type                  : 001001 :        : integer -> address
 reserve                       : 001001 :        : reserve type                      : Function not defined before runtime
 release type                  : 001001 :        : address -> integer                : Type of Function                  
 release                       : 001001 :        : release type                      : Function not defined before runtime
+main                          : 001001 :        : string -> integer                 : Type of Function                  
+entry                         : 001001 :        : main                              : Function Definition that starts at line 7
+rec                           : 001001 :        : Record Type                       : elements-2 size-8 bytes           
+T2                            : 001001 :        : rec -> integer                    : Type of Function                  
 ------------------------------:--------:--------:-----------------------------------:-----------------------------------:
-                              : 000000 : 001001 :                                   : Empty Scope                       
+arg                           : 007000 : 001001 : string                            : Array Instance                    
+w                             : 007000 : 001001 : rec                               : Record Instance                   
+------------------------------:--------:--------:-----------------------------------:-----------------------------------:
+x                             : 004000 : 001001 : integer                           : Primitive Instance                
+y                             : 004000 : 001001 : integer                           : Primitive Instance                

tests/sprint2/test/sp2_valid_assignable_and_mem.alpha

@@ -1,5 +1,5 @@
 (* TEST: [-st] *)
-ype main: string -> integer
+type main: string -> integer
 function entry: main
 
 type rec: [integer: x; integer: y]

tests/sprint3/expected/sp3_and_or_type_check.asc.exp

@@ -57,26 +57,26 @@
      LINE (28:2) ** TYPE ERROR: Undefined variable b
 029: 	b := 1 | b;
      LINE (29:12) ** TYPE ERROR: Invalid type passed to assignable.
-     LINE (29:12) ** TYPE ERROR: Object $t9 of type integer and Object undefined of type undefined must both be Boolean
+     LINE (29:12) ** TYPE ERROR: Object $t11 of type integer and Object undefined of type undefined must both be Boolean
      LINE (29:11) ** TYPE ERROR: Undefined variable b
      LINE (29:2) ** TYPE ERROR: Undefined variable b
 030: 	b := b | 1;
      LINE (30:12) ** TYPE ERROR: Invalid type passed to assignable.
-     LINE (30:12) ** TYPE ERROR: Object undefined of type undefined and Object $t10 of type integer must both be Boolean
+     LINE (30:12) ** TYPE ERROR: Object undefined of type undefined and Object $t13 of type integer must both be Boolean
      LINE (30:7) ** TYPE ERROR: Undefined variable b
      LINE (30:2) ** TYPE ERROR: Undefined variable b
 031: 	b := b & 1;
      LINE (31:12) ** TYPE ERROR: Invalid type passed to assignable.
-     LINE (31:12) ** TYPE ERROR: Object undefined of type undefined and Object $t11 of type integer must both be Boolean
+     LINE (31:12) ** TYPE ERROR: Object undefined of type undefined and Object $t15 of type integer must both be Boolean
      LINE (31:7) ** TYPE ERROR: Undefined variable b
      LINE (31:2) ** TYPE ERROR: Undefined variable b
 032: 	b := 1 & b;
      LINE (32:12) ** TYPE ERROR: Invalid type passed to assignable.
-     LINE (32:12) ** TYPE ERROR: Object $t12 of type integer and Object undefined of type undefined must both be Boolean
+     LINE (32:12) ** TYPE ERROR: Object $t17 of type integer and Object undefined of type undefined must both be Boolean
      LINE (32:11) ** TYPE ERROR: Undefined variable b
      LINE (32:2) ** TYPE ERROR: Undefined variable b
 033: 	b := 1 = 1;
-     LINE (33:12) ** TYPE ERROR: Assignable Assign Expression - Object undefined of type undefined != Object $t15 of type Boolean
+     LINE (33:12) ** TYPE ERROR: Assignable Assign Expression - Object undefined of type undefined != Object $t21 of type Boolean
      LINE (33:12) ** TYPE ERROR: Invalid type passed to assignable.
      LINE (33:2) ** TYPE ERROR: Undefined variable b
 034: 
@@ -84,7 +84,7 @@
 036:     
 037: 	b := 1 = b; 
      LINE (37:12) ** TYPE ERROR: Invalid type passed to assignable.
-     LINE (37:12) ** TYPE ERROR: Object $t16 of type integer and Object undefined of type undefined must both be the same type
+     LINE (37:12) ** TYPE ERROR: Object $t22 of type integer and Object undefined of type undefined must both be the same type
      LINE (37:11) ** TYPE ERROR: Undefined variable b
      LINE (37:2) ** TYPE ERROR: Undefined variable b
 038: 		

tests/sprint3/expected/sp3_arr_reserve.asc.exp

@@ -0,0 +1,10 @@
+001: type main: string -> integer
+002: function entry: main
+003: type t: 3 -> integer
+004: 
+005: 
+006: entry (arg) := {
+007:  	[ t:a]
+008:         a := reserve a(1, 3, 4);
+009: 	return 0;
+010: }

tests/sprint3/expected/sp3_boolean_binary_op_typecheck.asc.exp

@@ -10,8 +10,8 @@
      LINE (8:18) ** TYPE ERROR: Object arr of type address and Object $t2 of type integer must both be the same type
 009:     b1 := 6<7 & arr2=7;
      LINE (9:23) ** TYPE ERROR: Assignable Assign Expression - Object b1 of type Boolean != Object undefined of type undefined
-     LINE (9:23) ** TYPE ERROR: Object $t5 of type Boolean and Object undefined of type undefined must both be Boolean
+     LINE (9:23) ** TYPE ERROR: Object $t6 of type Boolean and Object undefined of type undefined must both be Boolean
-     LINE (9:23) ** TYPE ERROR: Object arr2 of type address and Object $t6 of type integer must both be the same type
+     LINE (9:23) ** TYPE ERROR: Object arr2 of type address and Object $t7 of type integer must both be the same type
 010:     
 011:     return 0;
 012: }

tests/sprint3/expected/sp3_carls_second_mistake.asc.exp

@@ -11,20 +11,17 @@
 011: 
 012:     one_name := "a string literal";
 013:     another_name := reserve another_name(4); (* reserve space for an an array of character, with 4 members *)
-     LINE (13:44) ** TYPE ERROR: Assignable Assign Expression - Object another_name of type string != Object undefined of type undefined
 014:     another_name(0) := 'C';
 015:     another_name(1) := 'a';
 016:     another_name(2) := 'r';
 017:     another_name(3) := 'l';
 018:     many_names := reserve many_names(3);
-     LINE (18:40) ** TYPE ERROR: Assignable Assign Expression - Object many_names of type a_of_s != Object undefined of type undefined
 019:     many_names(0) := one_name;
 020:     many_names(1) := another_name;
 021:     many_names(2) := reserve many_names(2)(6); (* reserve space for an item of the same type as a_of_s(2), an array of character, with 6 members *)
      LINE (21:45) ** SYNTAX ERROR: Incorrect syntax at token ')'
      LINE (21:44) ** SYNTAX ERROR: Incorrect syntax at token '6'
      LINE (21:43) ** SYNTAX ERROR: Incorrect syntax at token '('
-     LINE (21:43) ** TYPE ERROR: Assignable Assign Expression - Object $t20 of type string != Object undefined of type undefined
 022:     many_names(2)(0) := 'P';
 023:     many_names(2)(1) := 'a';
 024:     many_names(2)(2) := 'r';

tests/sprint3/expected/sp3_if_else.asc.exp

@@ -11,15 +11,12 @@
 011: }
 012: 
 013: entry (arg) := {
-014:  	[ integer: result ; rec: w]
+014:  	[ integer: r ; integer: s; Boolean: x]
-015:         if ( result = result ) then {
+015:         (* x := (r < s) & x; *)
-016:                  if ( result < w.y ) then {
+016:         if ( ( r < s ) & (s = r) ) then {
-017:                         result := 8;
+017:                 r := 5;
-018:                 } else {
+018:         } else {
-019:                         result := 9;
+019:                 r := 7;
-020:                 }(*  *)
+020:         }
-021:         } else {
+021: 	return 0;
-022:                 result :=  bar('c', 7);
+022: }
-023:         }
-024: 	return 0;
-025: }

tests/sprint3/expected/sp3_if_else_nested_exp.asc.exp

@@ -0,0 +1,25 @@
+001: type rec: [character: x; integer: y]
+002: 
+003: type T2: rec -> integer
+004: 
+005: type main: string -> integer
+006: function entry: main
+007: function bar: T2
+008: 
+009: bar (r,s) := {
+010:     return 0;
+011: }
+012: 
+013: entry (arg) := {
+014:  	[ integer: x ; integer: y; integer: z;integer: t]
+015: 
+016:         if ( (x = y) < ( z = t ) ) then {
+017:                 if ( (x < y) = ( z < t ) ) then {
+018:                         x := x;
+019:                 } else {
+020:                         x :=  1; (* bar('c', 7); *)
+021:                 }
+022:         } else {
+023:                 return 0;
+024:         }
+025: }

tests/sprint3/expected/sp3_if_else_sse.asc.exp

@@ -0,0 +1,31 @@
+001: type rec: [character: x; integer: y]
+002: 
+003: type T2: rec -> integer
+004: 
+005: type main: string -> integer
+006: function entry: main
+007: function bar: T2
+008: 
+009:                 (*
+010: bar (r,s) := {
+011:     return 0;
+012: }
+013: 
+014:                 *)
+015: entry (arg) := {
+016:  	[ Boolean:x ; Boolean:y ; Boolean:z ; Boolean:t]
+017:         if ( ( x & y ) ) then {
+018: 
+019:                 (*
+020:                  if ( x<y & !(x=y) ) then {
+021:                         t := 8;
+022:                 } else {
+023:                 }
+024:                 *)
+025: 
+026:                 z := x < y;
+027:         } else {
+028:                 y := true; (* bar('c', 7); *)
+029:         }
+030: 	return 0;
+031: }

tests/sprint3/expected/sp3_if_else_sse2.asc.exp

@@ -0,0 +1,34 @@
+001: type rec: [character: x; integer: y]
+002: 
+003: type T2: rec -> integer
+004: 
+005: type main: string -> integer
+006: function entry: main
+007: function bar: T2
+008: 
+009: bar (r,s) := {
+010:     return 0;
+011: }
+012: 
+013: entry (arg) := {
+014:  	[ Boolean:x ; Boolean:y ; Boolean:z ; Boolean:t]
+015:         (* if ( y & (z | t) ) then { *)
+016:         if ( ( x = y ) & ( z < t ) ) then {
+017:                 (* y := z < t; *)
+018:                 t:= 0;
+019:         } else {
+020:                 (* t := z = t; *)
+021:                 z := 1;
+022:         }
+023:         (*
+024:         if ( x & y ) then {
+025:                 t := true;
+026:         } else {
+027:                 y := true;
+028:         }
+029:         *)
+030:         (* } else { *)
+031:         (* } *)
+032:         (* x := x & y; *)
+033: 	return 0;
+034: }

tests/sprint3/expected/sp3_while_nested_bools.asc.exp

@@ -0,0 +1,29 @@
+001: type rec: [character: x; integer: y]
+002: 
+003: type T2: rec -> integer
+004: 
+005: type main: string -> integer
+006: function entry: main
+007: function bar: T2
+008: 
+009: bar (r,s) := {
+010:     return 0;
+011: }
+012: 
+013: entry (arg) := {
+014:  	[ Boolean: x ; Boolean: y; Boolean: z;Boolean: t]
+015:         while ( ((x = y)) < ( z | t ) ) {
+016:                 while ( (x & y) = ( z < t ) ) {
+017:                         y := y;
+018:                 }
+019:                 (*
+020:                 x := x;
+021:                 *)
+022:                 if ( (x = y) = ( z < t ) ) then {
+023:                         x :=  1;
+024:                 } else {
+025:                         x :=  1;
+026:                 }
+027:         }
+028:         return 0;
+029: }

tests/sprint3/expected/sp3_while_sse.asc.exp

@@ -0,0 +1,27 @@
+001: type rec: [character: x; integer: y]
+002: 
+003: type T2: rec -> integer
+004: 
+005: type main: string -> integer
+006: function entry: main
+007: function bar: T2
+008: 
+009: bar (r,s) := {
+010:     return 0;
+011: }
+012: 
+013: entry (arg) := {
+014:  	[ Boolean:x ; Boolean:y ; Boolean:z ; Boolean:t]
+015:         while ( ( x | y ) (* | ( z | t ) *)  ) {
+016:                 (*
+017:                 if ( ( x < y ) & ( z = t ) ) then {
+018:                         y := z < t;
+019:                 } else {
+020:                         t := z = t;
+021:                 }
+022:                 *)
+023:                 y := t < z; (* bar('c', 7); *)
+024:         }
+025:         (* x := x & y; *)
+026: 	return 0;
+027: }

tests/sprint3/test/sp3_arr_reserve.alpha

@@ -1,4 +1,4 @@
-
+(* TEST: [-asc -tc] *)
 type main: string -> integer
 function entry: main
 type t: 3 -> integer

tests/sprint3/test/sp3_if_else.alpha

@@ -13,8 +13,8 @@ bar (r,s) := {
 
 entry (arg) := {
  	[ integer: r ; integer: s; Boolean: x]
-        x := (r < s) & x;
+        (* x := (r < s) & x; *)
-        if ( r < s ) then {
+        if ( ( r < s ) & (s = r) ) then {
                 r := 5;
         } else {
                 r := 7;

tests/sprint3/test/sp3_if_else_nested_exp.alpha

@@ -1,3 +1,4 @@
+(* TEST: [-asc -tc] *)
 type rec: [character: x; integer: y]
 
 type T2: rec -> integer

tests/sprint3/test/sp3_if_else_sse.alpha

@@ -1,3 +1,4 @@
+(* TEST: [-asc -tc] *)
 type rec: [character: x; integer: y]
 
 type T2: rec -> integer

tests/sprint3/test/sp3_if_else_sse2.alpha

@@ -1,3 +1,4 @@
+(* TEST: [-asc -tc] *)
 type rec: [character: x; integer: y]
 
 type T2: rec -> integer

tests/sprint3/test/sp3_while_nested_bools.alpha

@@ -1,3 +1,4 @@
+(* TEST: [-asc -tc] *)
 type rec: [character: x; integer: y]
 
 type T2: rec -> integer

tests/sprint3/test/sp3_while_sse.alpha

@@ -1,3 +1,4 @@
+(* TEST: [-asc -tc] *)
 type rec: [character: x; integer: y]
 
 type T2: rec -> integer

tests/sprint4/expected/sp4_cg_add.asc.exp

@@ -1,10 +1,47 @@
-001: type main: integer -> integer
+001:  
-002: function test: main
+002: type string: 1 -> character
-003: 	
+003: type BooleanXBoolean: [Boolean: x; Boolean: y]
-004: test (a) := {
+004: type characterXcharacter: [character: x; character: y]
-005: 	[integer:x; integer:y]
+005: type integerXinteger: [integer: x; integer: y]
-006: 	y := 1;
+006: 
-007: 	x := 3;
+007: type Boolean2Boolean: Boolean -> Boolean
-008: 	y := x + y;
+008: type integer2integer: integer -> integer
-009: 	return y;
+009: type character2integer: character -> integer
-010: }
+010: type Boolean2integer: Boolean -> integer
+011: type string2integer: string -> integer
+012: type integerXinteger2integer: integerXinteger -> integer
+013: type integerXinteger2Boolean: integerXinteger -> Boolean
+014: type characterXcharacter2Boolean: characterXcharacter -> Boolean
+015: type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+016: type integer2address: integer -> address
+017: type address2integer: address -> integer
+018: type integer2string: integer -> string
+019: type integer2character: integer -> character
+020: type integer2Boolean: integer -> Boolean
+021: 
+022: 
+023: external function printInteger: integer2integer
+024: external function printCharacter: character2integer
+025: external function printBoolean: Boolean2integer
+026: 
+027: external function printS: string2integer
+028: external function printI: integer2integer
+029: external function printC: character2integer
+030: external function printB: Boolean2integer
+031: 
+032: external function inS: integer2string
+033: external function inI: integer2integer
+034: external function inC: integer2character
+035: 
+036: function entry: string2integer
+037: 
+038: entry (arg) := {
+039: 	[integer:x; integer:y; integer: result]
+040: 
+041: 	y := 1;
+042: 	x := 3;
+043: 	y := x + y;
+044: 
+045:     result := printInteger(y);
+046: 	return y;
+047: }

tests/sprint4/expected/sp4_cg_add.ir.exp

@@ -1,8 +1,12 @@
-   1:  func : test
+   1:  func_dec : entry
-   2:  $t0 = 1
+   2:  func : entry
-   3:  y = $t0
+   3:  $t0 = 1
-   4:  $t1 = 3
+   4:  y = $t0
-   5:  x = $t1
+   5:  $t1 = 3
-   6:  $t2 = x + y
+   6:  x = $t1
-   7:  y = $t2
+   7:  $t2 = x + y
-   8:  return : y
+   8:  y = $t2
+   9:  param y 
+  10:  call : printInteger 1
+  11:  result = $t3
+  12:  return : y

tests/sprint4/expected/sp4_cg_add.s.exp

@@ -1,12 +1,26 @@
-	movl	$1, -4(%rbp)	#constant assign
+.globl entry
-	movl	-4(%rbp), %eax	#assign start
+entry:
-	movl	%eax, -8(%rbp)	#assign end
+	pushq	%rbp
-	movl	$3, -12(%rbp)	#constant assign
+	movq	%rsp, %rbp
+	subq	$400, %rsp
+	movl	%edi, -8(%rbp)	#FunctionStart1param end
+	movl	$1, -12(%rbp)	#constant assign
 	movl	-12(%rbp), %eax	#assign start
 	movl	%eax, -16(%rbp)	#assign end
-	movl	-16(%rbp), %eax	#addition start
+	movl	$3, -20(%rbp)	#constant assign
-	movl	-16(%rbp), %eax
-	addl	%edx, %eax
-	movl	%eax, -20(%rbp)	#addition end
 	movl	-20(%rbp), %eax	#assign start
-	movl	%eax, -8(%rbp)	#assign end
+	movl	%eax, -24(%rbp)	#assign end
+
+	movl	-24(%rbp), %eax	#addition start
+	addl	-16(%rbp), %eax
+	movl	%eax, -28(%rbp)	#addition end
+	movl	-28(%rbp), %eax	#assign start
+	movl	%eax, -16(%rbp)	#assign end
+	movl	-16(%rbp), %edi	#adding param start
+	call printInteger
+	movl	%eax, -32(%rbp)	#store return from call
+	movl	-32(%rbp), %eax	#assign start
+	movl	%eax, -36(%rbp)	#assign end
+	movl	-16(%rbp), %eax	#return y
+	leave
+	ret

tests/sprint4/expected/sp4_cg_and.asc.exp

@@ -1,10 +1,50 @@
-001: type main: integer -> integer
+001: 
-002: function test: main
+002: type string: 1 -> character
-003: 
+003: type BooleanXBoolean: [Boolean: x; Boolean: y]
-004: test (a) := {
+004: type characterXcharacter: [character: x; character: y]
-005:         [Boolean:b; Boolean: c; Boolean: d]
+005: type integerXinteger: [integer: x; integer: y]
-006:         c := true;
+006: 
-007:         d := false;
+007: type Boolean2Boolean: Boolean -> Boolean
-008:         d := c & d;
+008: type integer2integer: integer -> integer
-009:         return 1;
+009: type character2integer: character -> integer
-010: }
+010: type Boolean2integer: Boolean -> integer
+011: type string2integer: string -> integer
+012: type integerXinteger2integer: integerXinteger -> integer
+013: type integerXinteger2Boolean: integerXinteger -> Boolean
+014: type characterXcharacter2Boolean: characterXcharacter -> Boolean
+015: type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+016: type integer2address: integer -> address
+017: type address2integer: address -> integer
+018: type integer2string: integer -> string
+019: type integer2character: integer -> character
+020: type integer2Boolean: integer -> Boolean
+021: 
+022: 
+023: external function printInteger: integer2integer
+024: external function printCharacter: character2integer
+025: external function printBoolean: Boolean2integer
+026: 
+027: external function printS: string2integer
+028: external function printI: integer2integer
+029: external function printC: character2integer
+030: external function printB: Boolean2integer
+031: 
+032: external function inS: integer2string
+033: external function inI: integer2integer
+034: external function inC: integer2character
+035: 
+036: function entry: string2integer
+037: 
+038: entry (arg) := {
+039:     [Boolean:b; Boolean: c; Boolean: d; integer: result]
+040: 
+041:     z := true;
+     LINE (41:14) ** TYPE ERROR: Assignable Assign Expression - Object undefined of type undefined != Object $t0 of type Boolean
+     LINE (41:14) ** TYPE ERROR: Invalid type passed to assignable.
+     LINE (41:5) ** TYPE ERROR: Undefined variable z
+042:     d := false;
+043:     d := c & d;
+044: 
+045:     result := printBoolean(d);
+046:     return 1;
+047: }

tests/sprint4/expected/sp4_cg_calls.asc.exp

@@ -0,0 +1,60 @@
+001: 
+002: type string: 1 -> character
+003: type BooleanXBoolean: [Boolean: x; Boolean: y]
+004: type characterXcharacter: [character: x; character: y]
+005: type integerXinteger: [integer: x; integer: y]
+006: 
+007: type Boolean2Boolean: Boolean -> Boolean
+008: type integer2integer: integer -> integer
+009: type character2integer: character -> integer
+010: type Boolean2integer: Boolean -> integer
+011: type string2integer: string -> integer
+012: type integerXinteger2integer: integerXinteger -> integer
+013: type integerXinteger2Boolean: integerXinteger -> Boolean
+014: type characterXcharacter2Boolean: characterXcharacter -> Boolean
+015: type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+016: type integer2address: integer -> address
+017: type address2integer: address -> integer
+018: type integer2string: integer -> string
+019: type integer2character: integer -> character
+020: type integer2Boolean: integer -> Boolean
+021: 
+022: 
+023: external function printInteger: integer2integer
+024: external function printCharacter: character2integer
+025: external function printBoolean: Boolean2integer
+026: 
+027: external function printS: string2integer
+028: external function printI: integer2integer
+029: external function printC: character2integer
+030: external function printB: Boolean2integer
+031: 
+032: external function inS: integer2string
+033: external function inI: integer2integer
+034: external function inC: integer2character
+035: 
+036: function entry: string2integer
+037: 
+038: type rec: [integer: x; integer: y; integer: z; integer: a; integer: b; integer: c; integer: d]
+039: type T2: rec -> integer
+040: type T: integer -> integer
+041: function bar: T2
+042: function ahh: T
+043: 
+044: ahh (a) := {
+045:     a := printInteger(a);
+046:     return -1;
+047: }
+048: 
+049: bar (a, b, c,d,e,f,g) := {
+050:     a :=  printInteger(g);
+051:     return b;
+052: }
+053: 
+054: entry (arg) := {
+055:     [integer:x; integer:y; integer: result; character: a]
+056:     a := 'a';
+057:     x := printCharacter(a);
+058:     result := bar(1,2,3,4,5,6,7);
+059:     return 1;
+060: }

tests/sprint4/expected/sp4_cg_calls.ir.exp

@@ -0,0 +1,39 @@
+   1:  func_dec : entry
+   2:  func_dec : bar
+   3:  func_dec : ahh
+   4:  func : ahh
+   5:  param a 
+   6:  call : printInteger 1
+   7:  a = $t0
+   8:  $t1 = 1
+   9:  $t2 = -$t1
+  10:  return : $t2
+  11:  func : bar
+  12:  param g 
+  13:  call : printInteger 1
+  14:  a = $t3
+  15:  return : b
+  16:  func : entry
+  17:  $t4 = a
+  18:  a = $t4
+  19:  param a 
+  20:  call : printCharacter 1
+  21:  x = $t5
+  22:  $t6 = 1
+  23:  $t7 = 2
+  24:  $t8 = 3
+  25:  $t9 = 4
+  26:  $t10 = 5
+  27:  $t11 = 6
+  28:  $t12 = 7
+  29:  param $t12 
+  30:  param $t11 
+  31:  param $t10 
+  32:  param $t9 
+  33:  param $t8 
+  34:  param $t7 
+  35:  param $t6 
+  36:  call : bar 7
+  37:  result = $t13
+  38:  $t14 = 1
+  39:  return : $t14

tests/sprint4/expected/sp4_cg_calls.s.exp

@@ -0,0 +1,74 @@
+.globl entry
+ahh:
+	pushq	%rbp
+	movq	%rsp, %rbp
+	subq	$576, %rsp
+	movl	%edi, -4(%rbp)	#FunctionStart1param end
+	movl	-4(%rbp), %edi	#adding param start
+	call printInteger
+	movl	%eax, -8(%rbp)	#store return from call
+	movl	-8(%rbp), %eax	#assign start
+	movl	%eax, -4(%rbp)	#assign end
+	movl	$1, -12(%rbp)	#constant assign
+	movl	-12(%rbp), %eax	#negation start
+	negl	%eax
+	movl	%eax, -16(%rbp)	#negation end
+	movl	-16(%rbp), %eax	#return $t2
+	leave
+	ret
+bar:
+	pushq	%rbp
+	movq	%rsp, %rbp
+	subq	$576, %rsp
+	movl	20(%rbp), %eax	#FunctionStart1Param start
+	movl	%eax, -4(%rbp)	#FunctionStart1param end
+	movl	%r9d, -12(%rbp)	#FunctionStart1param end
+	movl	%r8d, -16(%rbp)	#FunctionStart1param end
+	movl	%ecx, -20(%rbp)	#FunctionStart1param end
+	movl	%edx, -24(%rbp)	#FunctionStart1param end
+	movl	%esi, -28(%rbp)	#FunctionStart1param end
+	movl	%edi, -32(%rbp)	#FunctionStart1param end
+	movl	-32(%rbp), %edi	#adding param start
+	call printInteger
+	movl	%eax, -36(%rbp)	#store return from call
+	movl	-36(%rbp), %eax	#assign start
+	movl	%eax, -4(%rbp)	#assign end
+	movl	-12(%rbp), %eax	#return b
+	leave
+	ret
+entry:
+	pushq	%rbp
+	movq	%rsp, %rbp
+	subq	$576, %rsp
+	movl	%edi, -12(%rbp)	#FunctionStart1param end
+	movl	$97, -13(%rbp)	#constant assign
+	movl	-13(%rbp), %eax	#assign start
+	movl	%eax, -14(%rbp)	#assign end
+	movl	-14(%rbp), %edi	#adding param start
+	call printCharacter
+	movl	%eax, -20(%rbp)	#store return from call
+	movl	-20(%rbp), %eax	#assign start
+	movl	%eax, -24(%rbp)	#assign end
+	movl	$1, -28(%rbp)	#constant assign
+	movl	$2, -32(%rbp)	#constant assign
+	movl	$3, -36(%rbp)	#constant assign
+	movl	$4, -40(%rbp)	#constant assign
+	movl	$5, -44(%rbp)	#constant assign
+	movl	$6, -48(%rbp)	#constant assign
+	movl	$7, -52(%rbp)	#constant assign
+	movl	-52(%rbp), %edi	#adding param start
+	movl	-48(%rbp), %esi	#adding param start
+	movl	-44(%rbp), %edx	#adding param start
+	movl	-40(%rbp), %ecx	#adding param start
+	movl	-36(%rbp), %r8d	#adding param start
+	movl	-32(%rbp), %r9d	#adding param start
+	movl	-28(%rbp), %eax	#adding param start
+	movl	%eax, 152(%rbp)	#adding param end
+	call bar
+	movl	%eax, -60(%rbp)	#store return from call
+	movl	-60(%rbp), %eax	#assign start
+	movl	%eax, -64(%rbp)	#assign end
+	movl	$1, -68(%rbp)	#constant assign
+	movl	-68(%rbp), %eax	#return $t14
+	leave
+	ret

tests/sprint4/expected/sp4_cg_div.asc.exp

@@ -1,10 +1,47 @@
-001: type main: integer -> integer
+001: 
-002: function test: main
+002: type string: 1 -> character
-003: 
+003: type BooleanXBoolean: [Boolean: x; Boolean: y]
-004: test (a) := {
+004: type characterXcharacter: [character: x; character: y]
-005:         [integer:x; integer:y]
+005: type integerXinteger: [integer: x; integer: y]
-006:         y := 1;
+006: 
-007:         x := 3;
+007: type Boolean2Boolean: Boolean -> Boolean
-008:         y := x / y;
+008: type integer2integer: integer -> integer
-009:         return y;
+009: type character2integer: character -> integer
-010: }
+010: type Boolean2integer: Boolean -> integer
+011: type string2integer: string -> integer
+012: type integerXinteger2integer: integerXinteger -> integer
+013: type integerXinteger2Boolean: integerXinteger -> Boolean
+014: type characterXcharacter2Boolean: characterXcharacter -> Boolean
+015: type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+016: type integer2address: integer -> address
+017: type address2integer: address -> integer
+018: type integer2string: integer -> string
+019: type integer2character: integer -> character
+020: type integer2Boolean: integer -> Boolean
+021: 
+022: 
+023: external function printInteger: integer2integer
+024: external function printCharacter: character2integer
+025: external function printBoolean: Boolean2integer
+026: 
+027: external function printS: string2integer
+028: external function printI: integer2integer
+029: external function printC: character2integer
+030: external function printB: Boolean2integer
+031: 
+032: external function inS: integer2string
+033: external function inI: integer2integer
+034: external function inC: integer2character
+035: 
+036: function entry: string2integer
+037: 
+038: entry (arg) := {
+039:     [integer:x; integer:y; integer: result]
+040: 
+041:     x := 24;
+042:     y := 3;
+043:     y := x / y;
+044: 
+045:     result := printInteger(y);
+046:     return y;
+047: }

tests/sprint4/expected/sp4_cg_div.ir.exp

@@ -1,8 +1,12 @@
-   1:  func : test
+   1:  func_dec : entry
-   2:  $t0 = 1
+   2:  func : entry
-   3:  y = $t0
+   3:  $t0 = 24
-   4:  $t1 = 3
+   4:  x = $t0
-   5:  x = $t1
+   5:  $t1 = 3
-   6:  $t2 = x / y
+   6:  y = $t1
-   7:  y = $t2
+   7:  $t2 = x / y
-   8:  return : y
+   8:  y = $t2
+   9:  param y 
+  10:  call : printInteger 1
+  11:  result = $t3
+  12:  return : y

tests/sprint4/expected/sp4_cg_div.s.exp

@@ -1,12 +1,26 @@
-	movl	$1, -4(%rbp)	#constant assign
+.globl entry
-	movl	-4(%rbp), %eax	#assign start
+entry:
-	movl	%eax, -8(%rbp)	#assign end
+	pushq	%rbp
-	movl	$3, -12(%rbp)	#constant assign
+	movq	%rsp, %rbp
+	subq	$400, %rsp
+	movl	%edi, -8(%rbp)	#FunctionStart1param end
+	movl	$24, -12(%rbp)	#constant assign
 	movl	-12(%rbp), %eax	#assign start
 	movl	%eax, -16(%rbp)	#assign end
+	movl	$3, -20(%rbp)	#constant assign
+	movl	-20(%rbp), %eax	#assign start
+	movl	%eax, -24(%rbp)	#assign end
 	movl	-16(%rbp), %eax	#division start
 	cltd
-	idivl	-8(%rbp)
+	idivl	-24(%rbp)
-	movl	%eax, -20(%rbp)	#division end
+	movl	%eax, -28(%rbp)	#division end
-	movl	-20(%rbp), %eax	#assign start
+	movl	-28(%rbp), %eax	#assign start
-	movl	%eax, -8(%rbp)	#assign end
+	movl	%eax, -24(%rbp)	#assign end
+	movl	-24(%rbp), %edi	#adding param start
+	call printInteger
+	movl	%eax, -32(%rbp)	#store return from call
+	movl	-32(%rbp), %eax	#assign start
+	movl	%eax, -36(%rbp)	#assign end
+	movl	-24(%rbp), %eax	#return y
+	leave
+	ret

tests/sprint4/expected/sp4_cg_equal_to.asc.exp

@@ -1,10 +1,47 @@
-001: type main: integer -> integer
+001: 
-002: function test: main
+002: type string: 1 -> character
-003: 
+003: type BooleanXBoolean: [Boolean: x; Boolean: y]
-004: test (a) := {
+004: type characterXcharacter: [character: x; character: y]
-005:         [Boolean: b; integer: x; integer: y]
+005: type integerXinteger: [integer: x; integer: y]
-006:         x := 1;
+006: 
-007: 	y := 2;
+007: type Boolean2Boolean: Boolean -> Boolean
-008: 	b := x = y;
+008: type integer2integer: integer -> integer
-009:         return 1;
+009: type character2integer: character -> integer
-010: }
+010: type Boolean2integer: Boolean -> integer
+011: type string2integer: string -> integer
+012: type integerXinteger2integer: integerXinteger -> integer
+013: type integerXinteger2Boolean: integerXinteger -> Boolean
+014: type characterXcharacter2Boolean: characterXcharacter -> Boolean
+015: type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+016: type integer2address: integer -> address
+017: type address2integer: address -> integer
+018: type integer2string: integer -> string
+019: type integer2character: integer -> character
+020: type integer2Boolean: integer -> Boolean
+021: 
+022: 
+023: external function printInteger: integer2integer
+024: external function printCharacter: character2integer
+025: external function printBoolean: Boolean2integer
+026: 
+027: external function printS: string2integer
+028: external function printI: integer2integer
+029: external function printC: character2integer
+030: external function printB: Boolean2integer
+031: 
+032: external function inS: integer2string
+033: external function inI: integer2integer
+034: external function inC: integer2character
+035: 
+036: function entry: string2integer
+037: 
+038: entry (arg) := {
+039:     [Boolean: b; integer: x; integer: y; integer: result]
+040: 
+041:     x := 1;
+042: 	y := 2;
+043: 	b := x = y;
+044:     
+045:     result := printBoolean(b);
+046:     return 1;
+047: }

tests/sprint4/expected/sp4_cg_equal_to.ir.exp

@@ -1,10 +1,16 @@
-   1:  func : test
+   1:  func_dec : entry
-   2:  $t0 = 1
+   2:  func : entry
-   3:  x = $t0
+   3:  $t0 = 1
-   4:  $t1 = 2
+   4:  x = $t0
-   5:  y = $t1
+   5:  $t1 = 2
-   6:  if ( x = y ) GOTO 0
+   6:  y = $t1
-   7:  GOTO : 0
+   7:  $t2 = x == y
-   8:  b = $t2
+   8:  if $t2 True GOTO 1
-   9:  $t3 = 1
+   9:  GOTO : 1
-  10:  return : $t3
+  10:  Label : 1
+  11:  b = $t2
+  12:  param b 
+  13:  call : printBoolean 1
+  14:  result = $t3
+  15:  $t4 = 1
+  16:  return : $t4

tests/sprint4/expected/sp4_cg_equal_to.s.exp

@@ -1,11 +1,32 @@
-	movl	$1, -4(%rbp)	#constant assign
+.globl entry
-	movl	-4(%rbp), %eax	#assign start
+entry:
-	movl	%eax, -8(%rbp)	#assign end
+	pushq	%rbp
-	movl	$2, -12(%rbp)	#constant assign
+	movq	%rsp, %rbp
+	subq	$416, %rsp
+	movl	%edi, -8(%rbp)	#FunctionStart1param end
+	movl	$1, -12(%rbp)	#constant assign
 	movl	-12(%rbp), %eax	#assign start
 	movl	%eax, -16(%rbp)	#assign end
-	movl	-8(%rbp), %eax	#equal to start
+	movl	$2, -20(%rbp)	#constant assign
-	cmpl	-16(%rbp), %eax
+	movl	-20(%rbp), %eax	#assign start
+	movl	%eax, -24(%rbp)	#assign end
+	movl	-16(%rbp), %eax	#equal to start
+	cmpl	-24(%rbp), %eax
 	sete	%al
-	movb	%al, -15(%rbp)	#equal to end
+	movb	$0, -25(%rbp)
-	movl	$1, -20(%rbp)	#constant assign
+	movb	%al, -25(%rbp)	#equal to end
+	cmpb	$0, -25(%rbp)	#if true start
+	jne	.L1		#if true end
+	jmp	.L1
+.L1:
+	movl	-25(%rbp), %eax	#assign start
+	movl	%eax, -26(%rbp)	#assign end
+	movl	-26(%rbp), %edi	#adding param start
+	call printBoolean
+	movl	%eax, -32(%rbp)	#store return from call
+	movl	-32(%rbp), %eax	#assign start
+	movl	%eax, -36(%rbp)	#assign end
+	movl	$1, -40(%rbp)	#constant assign
+	movl	-40(%rbp), %eax	#return $t4
+	leave
+	ret

tests/sprint4/expected/sp4_cg_less_than.asc.exp

@@ -1,10 +1,47 @@
-001: type main: integer -> integer
+001: 
-002: function test: main
+002: type string: 1 -> character
-003: 
+003: type BooleanXBoolean: [Boolean: x; Boolean: y]
-004: test (a) := {
+004: type characterXcharacter: [character: x; character: y]
-005:         [Boolean: b; integer: x; integer: y]
+005: type integerXinteger: [integer: x; integer: y]
-006:         x := 1;
+006: 
-007: 	y := 2;
+007: type Boolean2Boolean: Boolean -> Boolean
-008: 	b := x < y;
+008: type integer2integer: integer -> integer
-009:         return 1;
+009: type character2integer: character -> integer
-010: }
+010: type Boolean2integer: Boolean -> integer
+011: type string2integer: string -> integer
+012: type integerXinteger2integer: integerXinteger -> integer
+013: type integerXinteger2Boolean: integerXinteger -> Boolean
+014: type characterXcharacter2Boolean: characterXcharacter -> Boolean
+015: type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+016: type integer2address: integer -> address
+017: type address2integer: address -> integer
+018: type integer2string: integer -> string
+019: type integer2character: integer -> character
+020: type integer2Boolean: integer -> Boolean
+021: 
+022: 
+023: external function printInteger: integer2integer
+024: external function printCharacter: character2integer
+025: external function printBoolean: Boolean2integer
+026: 
+027: external function printS: string2integer
+028: external function printI: integer2integer
+029: external function printC: character2integer
+030: external function printB: Boolean2integer
+031: 
+032: external function inS: integer2string
+033: external function inI: integer2integer
+034: external function inC: integer2character
+035: 
+036: function entry: string2integer
+037: 
+038: entry (arg) := {
+039:     [Boolean: b; integer: x; integer: y; integer: result]
+040: 
+041:     x := 1;
+042: 	y := 2;
+043: 	b := x < y;
+044: 
+045:     result := printBoolean(b);
+046:     return 1;
+047: }

tests/sprint4/expected/sp4_cg_less_than.ir.exp

@@ -1,10 +1,16 @@
-   1:  func : test
+   1:  func_dec : entry
-   2:  $t0 = 1
+   2:  func : entry
-   3:  x = $t0
+   3:  $t0 = 1
-   4:  $t1 = 2
+   4:  x = $t0
-   5:  y = $t1
+   5:  $t1 = 2
-   6:  if ( x < y ) GOTO 0
+   6:  y = $t1
-   7:  GOTO : 0
+   7:  $t2 = x < y
-   8:  b = $t2
+   8:  if $t2 True GOTO 1
-   9:  $t3 = 1
+   9:  GOTO : 1
-  10:  return : $t3
+  10:  Label : 1
+  11:  b = $t2
+  12:  param b 
+  13:  call : printBoolean 1
+  14:  result = $t3
+  15:  $t4 = 1
+  16:  return : $t4

tests/sprint4/expected/sp4_cg_less_than.s.exp

@@ -1,11 +1,31 @@
-	movl	$1, -4(%rbp)	#constant assign
+.globl entry
-	movl	-4(%rbp), %eax	#assign start
+entry:
-	movl	%eax, -8(%rbp)	#assign end
+	pushq	%rbp
-	movl	$2, -12(%rbp)	#constant assign
+	movq	%rsp, %rbp
+	subq	$416, %rsp
+	movl	%edi, -8(%rbp)	#FunctionStart1param end
+	movl	$1, -12(%rbp)	#constant assign
 	movl	-12(%rbp), %eax	#assign start
 	movl	%eax, -16(%rbp)	#assign end
-	movl	-8(%rbp), %eax	#less than start
+	movl	$2, -20(%rbp)	#constant assign
-	cmpl	-16(%rbp), %eax
+	movl	-20(%rbp), %eax	#assign start
+	movl	%eax, -24(%rbp)	#assign end
+	movl	-16(%rbp), %eax	#less than start
+	cmpl	-24(%rbp), %eax
 	setl	%al
-	movb	%al, -15(%rbp)	#less than end
+	movb	%al, -25(%rbp)	#less than end
-	movl	$1, -20(%rbp)	#constant assign
+	cmpb	$0, -25(%rbp)	#if true start
+	jne	.L1		#if true end
+	jmp	.L1
+.L1:
+	movl	-25(%rbp), %eax	#assign start
+	movl	%eax, -26(%rbp)	#assign end
+	movl	-26(%rbp), %edi	#adding param start
+	call printBoolean
+	movl	%eax, -32(%rbp)	#store return from call
+	movl	-32(%rbp), %eax	#assign start
+	movl	%eax, -36(%rbp)	#assign end
+	movl	$1, -40(%rbp)	#constant assign
+	movl	-40(%rbp), %eax	#return $t4
+	leave
+	ret

tests/sprint4/expected/sp4_cg_mod.asc.exp

@@ -1,10 +1,47 @@
-001: type main: integer -> integer
+001: 
-002: function test: main
+002: type string: 1 -> character
-003: 
+003: type BooleanXBoolean: [Boolean: x; Boolean: y]
-004: test (a) := {
+004: type characterXcharacter: [character: x; character: y]
-005:         [integer:x; integer:y]
+005: type integerXinteger: [integer: x; integer: y]
-006:         y := 1;
+006: 
-007:         x := 3;
+007: type Boolean2Boolean: Boolean -> Boolean
-008:         y := x % y;
+008: type integer2integer: integer -> integer
-009:         return y;
+009: type character2integer: character -> integer
-010: }
+010: type Boolean2integer: Boolean -> integer
+011: type string2integer: string -> integer
+012: type integerXinteger2integer: integerXinteger -> integer
+013: type integerXinteger2Boolean: integerXinteger -> Boolean
+014: type characterXcharacter2Boolean: characterXcharacter -> Boolean
+015: type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+016: type integer2address: integer -> address
+017: type address2integer: address -> integer
+018: type integer2string: integer -> string
+019: type integer2character: integer -> character
+020: type integer2Boolean: integer -> Boolean
+021: 
+022: 
+023: external function printInteger: integer2integer
+024: external function printCharacter: character2integer
+025: external function printBoolean: Boolean2integer
+026: 
+027: external function printS: string2integer
+028: external function printI: integer2integer
+029: external function printC: character2integer
+030: external function printB: Boolean2integer
+031: 
+032: external function inS: integer2string
+033: external function inI: integer2integer
+034: external function inC: integer2character
+035: 
+036: function entry: string2integer
+037: 
+038: entry (arg) := {
+039:     [integer:x; integer:y; integer: result]
+040: 
+041:     x := 4;
+042:     y := 20;
+043:     y := y % x;
+044:     
+045:     result := printInteger(y);
+046:     return y;
+047: }

tests/sprint4/expected/sp4_cg_mod.ir.exp

@@ -1,8 +1,12 @@
-   1:  func : test
+   1:  func_dec : entry
-   2:  $t0 = 1
+   2:  func : entry
-   3:  y = $t0
+   3:  $t0 = 4
-   4:  $t1 = 3
+   4:  x = $t0
-   5:  x = $t1
+   5:  $t1 = 20
-   6:  $t2 = x % y
+   6:  y = $t1
-   7:  y = $t2
+   7:  $t2 = y % x
-   8:  return : y
+   8:  y = $t2
+   9:  param y 
+  10:  call : printInteger 1
+  11:  result = $t3
+  12:  return : y

tests/sprint4/expected/sp4_cg_mod.s.exp

@@ -1,12 +1,26 @@
-	movl	$1, -4(%rbp)	#constant assign
+.globl entry
-	movl	-4(%rbp), %eax	#assign start
+entry:
-	movl	%eax, -8(%rbp)	#assign end
+	pushq	%rbp
-	movl	$3, -12(%rbp)	#constant assign
+	movq	%rsp, %rbp
+	subq	$400, %rsp
+	movl	%edi, -8(%rbp)	#FunctionStart1param end
+	movl	$4, -12(%rbp)	#constant assign
 	movl	-12(%rbp), %eax	#assign start
 	movl	%eax, -16(%rbp)	#assign end
-	movl	-16(%rbp), %eax	#mod start
+	movl	$20, -20(%rbp)	#constant assign
-	cltd
-	idivl	-8(%rbp)
-	movl	%edx, -20(%rbp)	#mod end
 	movl	-20(%rbp), %eax	#assign start
-	movl	%eax, -8(%rbp)	#assign end
+	movl	%eax, -24(%rbp)	#assign end
+	movl	-24(%rbp), %eax	#mod start
+	cltd
+	idivl	-16(%rbp)
+	movl	%edx, -28(%rbp)	#mod end
+	movl	-28(%rbp), %eax	#assign start
+	movl	%eax, -24(%rbp)	#assign end
+	movl	-24(%rbp), %edi	#adding param start
+	call printInteger
+	movl	%eax, -32(%rbp)	#store return from call
+	movl	-32(%rbp), %eax	#assign start
+	movl	%eax, -36(%rbp)	#assign end
+	movl	-24(%rbp), %eax	#return y
+	leave
+	ret

tests/sprint4/expected/sp4_cg_mult.asc.exp

@@ -1,10 +1,47 @@
-001: type main: integer -> integer
+001: 
-002: function test: main
+002: type string: 1 -> character
-003: 
+003: type BooleanXBoolean: [Boolean: x; Boolean: y]
-004: test (a) := {
+004: type characterXcharacter: [character: x; character: y]
-005:         [integer:x; integer:y]
+005: type integerXinteger: [integer: x; integer: y]
-006:         y := 1;
+006: 
-007:         x := 3;
+007: type Boolean2Boolean: Boolean -> Boolean
-008:         y := x * x;
+008: type integer2integer: integer -> integer
-009:         return y;
+009: type character2integer: character -> integer
-010: }
+010: type Boolean2integer: Boolean -> integer
+011: type string2integer: string -> integer
+012: type integerXinteger2integer: integerXinteger -> integer
+013: type integerXinteger2Boolean: integerXinteger -> Boolean
+014: type characterXcharacter2Boolean: characterXcharacter -> Boolean
+015: type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+016: type integer2address: integer -> address
+017: type address2integer: address -> integer
+018: type integer2string: integer -> string
+019: type integer2character: integer -> character
+020: type integer2Boolean: integer -> Boolean
+021: 
+022: 
+023: external function printInteger: integer2integer
+024: external function printCharacter: character2integer
+025: external function printBoolean: Boolean2integer
+026: 
+027: external function printS: string2integer
+028: external function printI: integer2integer
+029: external function printC: character2integer
+030: external function printB: Boolean2integer
+031: 
+032: external function inS: integer2string
+033: external function inI: integer2integer
+034: external function inC: integer2character
+035: 
+036: function entry: string2integer
+037: 
+038: entry (arg) := {
+039:     [integer:x; integer:y; integer: result]
+040: 
+041:     x := 3;
+042:     y := 20;
+043:     y := x * y;
+044:     
+045:     result := printInteger(y);
+046:     return y;
+047: }

tests/sprint4/expected/sp4_cg_mult.ir.exp

@@ -1,8 +1,12 @@
-   1:  func : test
+   1:  func_dec : entry
-   2:  $t0 = 1
+   2:  func : entry
-   3:  y = $t0
+   3:  $t0 = 3
-   4:  $t1 = 3
+   4:  x = $t0
-   5:  x = $t1
+   5:  $t1 = 20
-   6:  $t2 = x * x
+   6:  y = $t1
-   7:  y = $t2
+   7:  $t2 = x * y
-   8:  return : y
+   8:  y = $t2
+   9:  param y 
+  10:  call : printInteger 1
+  11:  result = $t3
+  12:  return : y

tests/sprint4/expected/sp4_cg_mult.s.exp

@@ -1,11 +1,25 @@
-	movl	$1, -4(%rbp)	#constant assign
+.globl entry
-	movl	-4(%rbp), %eax	#assign start
+entry:
-	movl	%eax, -8(%rbp)	#assign end
+	pushq	%rbp
+	movq	%rsp, %rbp
+	subq	$400, %rsp
+	movl	%edi, -8(%rbp)	#FunctionStart1param end
 	movl	$3, -12(%rbp)	#constant assign
 	movl	-12(%rbp), %eax	#assign start
 	movl	%eax, -16(%rbp)	#assign end
-	movl	-16(%rbp), %eax	#multiplication start
+	movl	$20, -20(%rbp)	#constant assign
-	imull	-16(%rbp), %eax
-	movl	%eax, -20(%rbp)	#multiplication end
 	movl	-20(%rbp), %eax	#assign start
-	movl	%eax, -8(%rbp)	#assign end
+	movl	%eax, -24(%rbp)	#assign end
+	movl	-16(%rbp), %eax	#multiplication start
+	imull	-24(%rbp), %eax
+	movl	%eax, -28(%rbp)	#multiplication end
+	movl	-28(%rbp), %eax	#assign start
+	movl	%eax, -24(%rbp)	#assign end
+	movl	-24(%rbp), %edi	#adding param start
+	call printInteger
+	movl	%eax, -32(%rbp)	#store return from call
+	movl	-32(%rbp), %eax	#assign start
+	movl	%eax, -36(%rbp)	#assign end
+	movl	-24(%rbp), %eax	#return y
+	leave
+	ret

tests/sprint4/expected/sp4_cg_neg.asc.exp

@@ -1,9 +1,46 @@
-001: type main: integer -> integer
+001: 
-002: function test: main
+002: type string: 1 -> character
-003: 
+003: type BooleanXBoolean: [Boolean: x; Boolean: y]
-004: test (a) := {
+004: type characterXcharacter: [character: x; character: y]
-005:         [integer:x; integer:y]
+005: type integerXinteger: [integer: x; integer: y]
-006:         x := 3;
+006: 
-007:         y := -x;
+007: type Boolean2Boolean: Boolean -> Boolean
-008:         return y;
+008: type integer2integer: integer -> integer
-009: }
+009: type character2integer: character -> integer
+010: type Boolean2integer: Boolean -> integer
+011: type string2integer: string -> integer
+012: type integerXinteger2integer: integerXinteger -> integer
+013: type integerXinteger2Boolean: integerXinteger -> Boolean
+014: type characterXcharacter2Boolean: characterXcharacter -> Boolean
+015: type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+016: type integer2address: integer -> address
+017: type address2integer: address -> integer
+018: type integer2string: integer -> string
+019: type integer2character: integer -> character
+020: type integer2Boolean: integer -> Boolean
+021: 
+022: 
+023: external function printInteger: integer2integer
+024: external function printCharacter: character2integer
+025: external function printBoolean: Boolean2integer
+026: 
+027: external function printS: string2integer
+028: external function printI: integer2integer
+029: external function printC: character2integer
+030: external function printB: Boolean2integer
+031: 
+032: external function inS: integer2string
+033: external function inI: integer2integer
+034: external function inC: integer2character
+035: 
+036: function entry: string2integer
+037: 
+038: entry (arg) := {
+039:     [integer:x; integer:y; integer: result]
+040:     
+041:     x := 3;
+042:     y := -x;
+043: 
+044:     result := printInteger(y);
+045:     return y;
+046: }

tests/sprint4/expected/sp4_cg_neg.ir.exp

@@ -1,6 +1,10 @@
-   1:  func : test
+   1:  func_dec : entry
-   2:  $t0 = 3
+   2:  func : entry
-   3:  x = $t0
+   3:  $t0 = 3
-   4:  $t1 = -x
+   4:  x = $t0
-   5:  y = $t1
+   5:  $t1 = -x
-   6:  return : y
+   6:  y = $t1
+   7:  param y 
+   8:  call : printInteger 1
+   9:  result = $t2
+  10:  return : y

tests/sprint4/expected/sp4_cg_neg.s.exp

@@ -1,8 +1,22 @@
-	movl	$3, -4(%rbp)	#constant assign
+.globl entry
-	movl	-4(%rbp), %eax	#assign start
+entry:
-	movl	%eax, -8(%rbp)	#assign end
+	pushq	%rbp
-	movl	-8(%rbp), %eax	#negation start
+	movq	%rsp, %rbp
-	negl	%eax
+	subq	$400, %rsp
-	movl	%eax, -12(%rbp)	#negation end
+	movl	%edi, -8(%rbp)	#FunctionStart1param end
+	movl	$3, -12(%rbp)	#constant assign
 	movl	-12(%rbp), %eax	#assign start
 	movl	%eax, -16(%rbp)	#assign end
+	movl	-16(%rbp), %eax	#negation start
+	negl	%eax
+	movl	%eax, -20(%rbp)	#negation end
+	movl	-20(%rbp), %eax	#assign start
+	movl	%eax, -24(%rbp)	#assign end
+	movl	-24(%rbp), %edi	#adding param start
+	call printInteger
+	movl	%eax, -28(%rbp)	#store return from call
+	movl	-28(%rbp), %eax	#assign start
+	movl	%eax, -32(%rbp)	#assign end
+	movl	-24(%rbp), %eax	#return y
+	leave
+	ret

tests/sprint4/expected/sp4_cg_not.asc.exp

@@ -1,9 +1,46 @@
-001: type main: integer -> integer
+001: 
-002: function test: main
+002: type string: 1 -> character
-003: 
+003: type BooleanXBoolean: [Boolean: x; Boolean: y]
-004: test (a) := {
+004: type characterXcharacter: [character: x; character: y]
-005:         [Boolean: c; Boolean: d]
+005: type integerXinteger: [integer: x; integer: y]
-006:         c := true;
+006: 
-007:         d := !c;
+007: type Boolean2Boolean: Boolean -> Boolean
-008:         return 1;
+008: type integer2integer: integer -> integer
-009: }
+009: type character2integer: character -> integer
+010: type Boolean2integer: Boolean -> integer
+011: type string2integer: string -> integer
+012: type integerXinteger2integer: integerXinteger -> integer
+013: type integerXinteger2Boolean: integerXinteger -> Boolean
+014: type characterXcharacter2Boolean: characterXcharacter -> Boolean
+015: type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+016: type integer2address: integer -> address
+017: type address2integer: address -> integer
+018: type integer2string: integer -> string
+019: type integer2character: integer -> character
+020: type integer2Boolean: integer -> Boolean
+021: 
+022: 
+023: external function printInteger: integer2integer
+024: external function printCharacter: character2integer
+025: external function printBoolean: Boolean2integer
+026: 
+027: external function printS: string2integer
+028: external function printI: integer2integer
+029: external function printC: character2integer
+030: external function printB: Boolean2integer
+031: 
+032: external function inS: integer2string
+033: external function inI: integer2integer
+034: external function inC: integer2character
+035: 
+036: function entry: string2integer
+037: 
+038: entry (arg) := {
+039:     [Boolean: c; Boolean: d; integer: result]
+040: 
+041:     c := true;
+042:     d := !c;
+043: 
+044:     result := printBoolean(d);
+045:     return 1;
+046: }

tests/sprint4/expected/sp4_cg_not.ir.exp

@@ -1,7 +1,12 @@
-   1:  func : test
+   1:  func_dec : entry
-   2:  $t0 = true
+   2:  func : entry
-   3:  c = $t0
+   3:  $t0 = true
-   4:  $t1 = !c
+   4:  Label : 1
-   5:  d = $t1
+   5:  c = $t0
-   6:  $t2 = 1
+   6:  Label : 2
-   7:  return : $t2
+   7:  d = $t1
+   8:  param d 
+   9:  call : printBoolean 1
+  10:  result = $t2
+  11:  $t3 = 1
+  12:  return : $t3

tests/sprint4/expected/sp4_cg_not.s.exp

@@ -1,13 +1,20 @@
-	movl	$-1, -1(%rbp)	#constant assign
+.globl entry
-	movl	-1(%rbp), %eax	#assign start
+entry:
-	movl	%eax, -2(%rbp)	#assign end
+	pushq	%rbp
-	movzbl	-2(%rbp), %eax	#not start
+	movq	%rsp, %rbp
-	testl	%eax, %eax
+	subq	$400, %rsp
-	setne	%al
+	movl	%edi, -8(%rbp)	#FunctionStart1param end
-	xorl	$1, %eax
+	movl	$1, -9(%rbp)	#constant assign
-	movzbl	%al, %eax
+.L1:
-	movb	%al, -3(%rbp)
+	movl	-9(%rbp), %eax	#assign start
-	andb	$1, -3(%rbp)	#not end
+	movl	%eax, -10(%rbp)	#assign end
-	movl	-3(%rbp), %eax	#assign start
+.L2:
-	movl	%eax, -4(%rbp)	#assign end
+	movl	-11(%rbp), %edi	#adding param start
-	movl	$1, -8(%rbp)	#constant assign
+	call printBoolean
+	movl	%eax, -18(%rbp)	#store return from call
+	movl	-18(%rbp), %eax	#assign start
+	movl	%eax, -24(%rbp)	#assign end
+	movl	$1, -28(%rbp)	#constant assign
+	movl	-28(%rbp), %eax	#return $t3
+	leave
+	ret

tests/sprint4/expected/sp4_cg_or.asc.exp

@@ -1,10 +1,47 @@
-001: type main: integer -> integer
+001: 
-002: function test: main
+002: type string: 1 -> character
-003: 
+003: type BooleanXBoolean: [Boolean: x; Boolean: y]
-004: test (a) := {
+004: type characterXcharacter: [character: x; character: y]
-005:         [Boolean:b; Boolean: c; Boolean: d]
+005: type integerXinteger: [integer: x; integer: y]
-006:         c := true;
+006: 
-007:         d := false;
+007: type Boolean2Boolean: Boolean -> Boolean
-008:         d := c | d;
+008: type integer2integer: integer -> integer
-009:         return 1;
+009: type character2integer: character -> integer
-010: }
+010: type Boolean2integer: Boolean -> integer
+011: type string2integer: string -> integer
+012: type integerXinteger2integer: integerXinteger -> integer
+013: type integerXinteger2Boolean: integerXinteger -> Boolean
+014: type characterXcharacter2Boolean: characterXcharacter -> Boolean
+015: type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+016: type integer2address: integer -> address
+017: type address2integer: address -> integer
+018: type integer2string: integer -> string
+019: type integer2character: integer -> character
+020: type integer2Boolean: integer -> Boolean
+021: 
+022: 
+023: external function printInteger: integer2integer
+024: external function printCharacter: character2integer
+025: external function printBoolean: Boolean2integer
+026: 
+027: external function printS: string2integer
+028: external function printI: integer2integer
+029: external function printC: character2integer
+030: external function printB: Boolean2integer
+031: 
+032: external function inS: integer2string
+033: external function inI: integer2integer
+034: external function inC: integer2character
+035: 
+036: function entry: string2integer
+037: 
+038: entry (arg) := {
+039:     [Boolean:b; Boolean: c; Boolean: d; integer: result]
+040: 
+041:     c := true;
+042:     d := false;
+043:     d := c | d;
+044: 
+045:     result := printBoolean(d);
+046:     return 1;
+047: }

tests/sprint4/expected/sp4_cg_or.ir.exp

@@ -1,9 +1,22 @@
-   1:  func : test
+   1:  func_dec : entry
-   2:  $t0 = true
+   2:  func : entry
-   3:  c = $t0
+   3:  $t0 = true
-   4:  $t1 = false
+   4:  Label : 1
-   5:  d = $t1
+   5:  c = $t0
-   6:  $t2 = c | d
+   6:  $t1 = false
-   7:  d = $t2
+   7:  Label : 2
-   8:  $t3 = 1
+   8:  d = $t1
-   9:  return : $t3
+   9:  $t2 = true
+  10:  if c True GOTO 4
+  11:  GOTO : 3
+  12:  Label : 3
+  13:  if d True GOTO 4
+  14:  $t2 = false
+  15:  GOTO : 4
+  16:  Label : 4
+  17:  d = $t2
+  18:  param d 
+  19:  call : printBoolean 1
+  20:  result = $t3
+  21:  $t4 = 1
+  22:  return : $t4

tests/sprint4/expected/sp4_cg_or.s.exp

@@ -1,21 +1,35 @@
-	movl	$-1, -1(%rbp)	#constant assign
+.globl entry
-	movl	-1(%rbp), %eax	#assign start
+entry:
-	movl	%eax, -2(%rbp)	#assign end
+	pushq	%rbp
-	movl	$-1, -3(%rbp)	#constant assign
+	movq	%rsp, %rbp
-	movl	-3(%rbp), %eax	#assign start
+	subq	$416, %rsp
-	movl	%eax, -4(%rbp)	#assign end
+	movl	%edi, -8(%rbp)	#FunctionStart1param end
-	cmpl	$0, -2(%rbp)	#start or
-	jne	.L1or2
-	cmpl	$0, -4(%rbp)
-	je	.L1or3
-.L1or2:
-	movl	$1, %eax
-	jmp	.L1or4
-.L1or3:
-	movl	$0, %eax
-.L1or4:
-	movb	%al, -5(%rbp)
-	andb	$1, -5(%rbp)	#or end
-	movl	-5(%rbp), %eax	#assign start
-	movl	%eax, -4(%rbp)	#assign end
 	movl	$1, -9(%rbp)	#constant assign
+.L1:
+	movl	-9(%rbp), %eax	#assign start
+	movl	%eax, -10(%rbp)	#assign end
+	movl	$0, -11(%rbp)	#constant assign
+.L2:
+	movl	-11(%rbp), %eax	#assign start
+	movl	%eax, -12(%rbp)	#assign end
+	movl	$1, -13(%rbp)	#constant assign
+	cmpb	$0, -10(%rbp)	#if true start
+	jne	.L4		#if true end
+	jmp	.L3
+.L3:
+	cmpb	$0, -12(%rbp)	#if true start
+	jne	.L4		#if true end
+	movl	$0, -13(%rbp)	#constant assign
+	jmp	.L4
+.L4:
+	movl	-13(%rbp), %eax	#assign start
+	movl	%eax, -12(%rbp)	#assign end
+	movl	-12(%rbp), %edi	#adding param start
+	call printBoolean
+	movl	%eax, -18(%rbp)	#store return from call
+	movl	-18(%rbp), %eax	#assign start
+	movl	%eax, -24(%rbp)	#assign end
+	movl	$1, -28(%rbp)	#constant assign
+	movl	-28(%rbp), %eax	#return $t4
+	leave
+	ret

tests/sprint4/expected/sp4_cg_sub.asc.exp

@@ -1,10 +1,47 @@
-001: type main: integer -> integer
+001: 
-002: function test: main
+002: type string: 1 -> character
-003: 
+003: type BooleanXBoolean: [Boolean: x; Boolean: y]
-004: test (a) := {
+004: type characterXcharacter: [character: x; character: y]
-005:         [integer:x; integer:y]
+005: type integerXinteger: [integer: x; integer: y]
-006:         y := 1;
+006: 
-007:         x := 3;
+007: type Boolean2Boolean: Boolean -> Boolean
-008:         y := x - y;
+008: type integer2integer: integer -> integer
-009:         return y;
+009: type character2integer: character -> integer
-010: }
+010: type Boolean2integer: Boolean -> integer
+011: type string2integer: string -> integer
+012: type integerXinteger2integer: integerXinteger -> integer
+013: type integerXinteger2Boolean: integerXinteger -> Boolean
+014: type characterXcharacter2Boolean: characterXcharacter -> Boolean
+015: type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+016: type integer2address: integer -> address
+017: type address2integer: address -> integer
+018: type integer2string: integer -> string
+019: type integer2character: integer -> character
+020: type integer2Boolean: integer -> Boolean
+021: 
+022: 
+023: external function printInteger: integer2integer
+024: external function printCharacter: character2integer
+025: external function printBoolean: Boolean2integer
+026: 
+027: external function printS: string2integer
+028: external function printI: integer2integer
+029: external function printC: character2integer
+030: external function printB: Boolean2integer
+031: 
+032: external function inS: integer2string
+033: external function inI: integer2integer
+034: external function inC: integer2character
+035: 
+036: function entry: string2integer
+037: 
+038: entry (arg) := {
+039:     [integer:x; integer:y; integer: result]
+040:     
+041:     y := 1;
+042:     x := 3;
+043:     y := x - y;
+044:     
+045:     result := printInteger(y);
+046:     return y;
+047: }

tests/sprint4/expected/sp4_cg_sub.ir.exp

@@ -1,8 +1,12 @@
-   1:  func : test
+   1:  func_dec : entry
-   2:  $t0 = 1
+   2:  func : entry
-   3:  y = $t0
+   3:  $t0 = 1
-   4:  $t1 = 3
+   4:  y = $t0
-   5:  x = $t1
+   5:  $t1 = 3
-   6:  $t2 = x - y
+   6:  x = $t1
-   7:  y = $t2
+   7:  $t2 = x - y
-   8:  return : y
+   8:  y = $t2
+   9:  param y 
+  10:  call : printInteger 1
+  11:  result = $t3
+  12:  return : y

tests/sprint4/expected/sp4_cg_sub.s.exp

@@ -1,11 +1,25 @@
-	movl	$1, -4(%rbp)	#constant assign
+.globl entry
-	movl	-4(%rbp), %eax	#assign start
+entry:
-	movl	%eax, -8(%rbp)	#assign end
+	pushq	%rbp
-	movl	$3, -12(%rbp)	#constant assign
+	movq	%rsp, %rbp
+	subq	$400, %rsp
+	movl	%edi, -8(%rbp)	#FunctionStart1param end
+	movl	$1, -12(%rbp)	#constant assign
 	movl	-12(%rbp), %eax	#assign start
 	movl	%eax, -16(%rbp)	#assign end
-	movl	-16(%rbp), %eax	#subtraction start
+	movl	$3, -20(%rbp)	#constant assign
-	subl	-8(%rbp), %eax
-	movl	%eax, -20(%rbp)	#subtraction end
 	movl	-20(%rbp), %eax	#assign start
-	movl	%eax, -8(%rbp)	#assign end
+	movl	%eax, -24(%rbp)	#assign end
+	movl	-24(%rbp), %eax	#subtraction start
+	subl	-16(%rbp), %eax
+	movl	%eax, -28(%rbp)	#subtraction end
+	movl	-28(%rbp), %eax	#assign start
+	movl	%eax, -16(%rbp)	#assign end
+	movl	-16(%rbp), %edi	#adding param start
+	call printInteger
+	movl	%eax, -32(%rbp)	#store return from call
+	movl	-32(%rbp), %eax	#assign start
+	movl	%eax, -36(%rbp)	#assign end
+	movl	-16(%rbp), %eax	#return y
+	leave
+	ret

tests/sprint4/test/sp4_cg_add.alpha

@@ -1,7 +1,41 @@
 (* TEST: [-asc -tc -cg -ir] *)
+ 
+type string: 1 -> character
+type BooleanXBoolean: [Boolean: x; Boolean: y]
+type characterXcharacter: [character: x; character: y]
+type integerXinteger: [integer: x; integer: y]
+
+type Boolean2Boolean: Boolean -> Boolean
+type integer2integer: integer -> integer
+type character2integer: character -> integer
+type Boolean2integer: Boolean -> integer
+type string2integer: string -> integer
+type integerXinteger2integer: integerXinteger -> integer
+type integerXinteger2Boolean: integerXinteger -> Boolean
+type characterXcharacter2Boolean: characterXcharacter -> Boolean
+type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+type integer2address: integer -> address
+type address2integer: address -> integer
+type integer2string: integer -> string
+type integer2character: integer -> character
+type integer2Boolean: integer -> Boolean
+
+
+external function printInteger: integer2integer
+external function printCharacter: character2integer
+external function printBoolean: Boolean2integer
+
+external function printS: string2integer
+external function printI: integer2integer
+external function printC: character2integer
+external function printB: Boolean2integer
+
+external function inS: integer2string
+external function inI: integer2integer
+external function inC: integer2character
+
+function entry: string2integer
 
-#include "std.alpha"
-	
 entry (arg) := {
 	[integer:x; integer:y; integer: result]
 

tests/sprint4/test/sp4_cg_and.alpha

@@ -1,6 +1,40 @@
 (* TEST: [-asc -tc -cg -ir] *)
 
-#include "std.alpha"
+type string: 1 -> character
+type BooleanXBoolean: [Boolean: x; Boolean: y]
+type characterXcharacter: [character: x; character: y]
+type integerXinteger: [integer: x; integer: y]
+
+type Boolean2Boolean: Boolean -> Boolean
+type integer2integer: integer -> integer
+type character2integer: character -> integer
+type Boolean2integer: Boolean -> integer
+type string2integer: string -> integer
+type integerXinteger2integer: integerXinteger -> integer
+type integerXinteger2Boolean: integerXinteger -> Boolean
+type characterXcharacter2Boolean: characterXcharacter -> Boolean
+type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+type integer2address: integer -> address
+type address2integer: address -> integer
+type integer2string: integer -> string
+type integer2character: integer -> character
+type integer2Boolean: integer -> Boolean
+
+
+external function printInteger: integer2integer
+external function printCharacter: character2integer
+external function printBoolean: Boolean2integer
+
+external function printS: string2integer
+external function printI: integer2integer
+external function printC: character2integer
+external function printB: Boolean2integer
+
+external function inS: integer2string
+external function inI: integer2integer
+external function inC: integer2character
+
+function entry: string2integer
 
 entry (arg) := {
     [Boolean:b; Boolean: c; Boolean: d; integer: result]

tests/sprint4/test/sp4_cg_calls.alpha

@@ -1,18 +1,44 @@
 (* TEST: [-asc -tc -cg -ir] *)
 
-#include "std.alpha"
-(* Standard Alpha Library - Provided by Carl *)
-
 type string: 1 -> character
+type BooleanXBoolean: [Boolean: x; Boolean: y]
+type characterXcharacter: [character: x; character: y]
+type integerXinteger: [integer: x; integer: y]
+
+type Boolean2Boolean: Boolean -> Boolean
+type integer2integer: integer -> integer
+type character2integer: character -> integer
+type Boolean2integer: Boolean -> integer
+type string2integer: string -> integer
+type integerXinteger2integer: integerXinteger -> integer
+type integerXinteger2Boolean: integerXinteger -> Boolean
+type characterXcharacter2Boolean: characterXcharacter -> Boolean
+type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+type integer2address: integer -> address
+type address2integer: address -> integer
+type integer2string: integer -> string
+type integer2character: integer -> character
+type integer2Boolean: integer -> Boolean
+
+
+external function printInteger: integer2integer
+external function printCharacter: character2integer
+external function printBoolean: Boolean2integer
+
+external function printS: string2integer
+external function printI: integer2integer
+external function printC: character2integer
+external function printB: Boolean2integer
+
+external function inS: integer2string
+external function inI: integer2integer
+external function inC: integer2character
+
 function entry: string2integer
 
-
 type rec: [integer: x; integer: y; integer: z; integer: a; integer: b; integer: c; integer: d]
-
 type T2: rec -> integer
 type T: integer -> integer
-type main: string -> integer
-function entry: main
 function bar: T2
 function ahh: T
 
@@ -27,8 +53,9 @@ bar (a, b, c,d,e,f,g) := {
 }
 
 entry (arg) := {
-    [integer:x; integer:y; integer: result]
+    [integer:x; integer:y; integer: result; character: a]
-
+    a := 'a';
+    x := printCharacter(a);
     result := bar(1,2,3,4,5,6,7);
     return 1;
 }

tests/sprint4/test/sp4_cg_div.alpha

@@ -1,6 +1,40 @@
 (* TEST: [-asc -tc -cg -ir] *)
 
-#include "std.alpha"
+type string: 1 -> character
+type BooleanXBoolean: [Boolean: x; Boolean: y]
+type characterXcharacter: [character: x; character: y]
+type integerXinteger: [integer: x; integer: y]
+
+type Boolean2Boolean: Boolean -> Boolean
+type integer2integer: integer -> integer
+type character2integer: character -> integer
+type Boolean2integer: Boolean -> integer
+type string2integer: string -> integer
+type integerXinteger2integer: integerXinteger -> integer
+type integerXinteger2Boolean: integerXinteger -> Boolean
+type characterXcharacter2Boolean: characterXcharacter -> Boolean
+type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+type integer2address: integer -> address
+type address2integer: address -> integer
+type integer2string: integer -> string
+type integer2character: integer -> character
+type integer2Boolean: integer -> Boolean
+
+
+external function printInteger: integer2integer
+external function printCharacter: character2integer
+external function printBoolean: Boolean2integer
+
+external function printS: string2integer
+external function printI: integer2integer
+external function printC: character2integer
+external function printB: Boolean2integer
+
+external function inS: integer2string
+external function inI: integer2integer
+external function inC: integer2character
+
+function entry: string2integer
 
 entry (arg) := {
     [integer:x; integer:y; integer: result]

tests/sprint4/test/sp4_cg_equal_to.alpha

@@ -1,6 +1,40 @@
 (* TEST: [-asc -tc -cg -ir] *)
 
-#include "std.alpha"
+type string: 1 -> character
+type BooleanXBoolean: [Boolean: x; Boolean: y]
+type characterXcharacter: [character: x; character: y]
+type integerXinteger: [integer: x; integer: y]
+
+type Boolean2Boolean: Boolean -> Boolean
+type integer2integer: integer -> integer
+type character2integer: character -> integer
+type Boolean2integer: Boolean -> integer
+type string2integer: string -> integer
+type integerXinteger2integer: integerXinteger -> integer
+type integerXinteger2Boolean: integerXinteger -> Boolean
+type characterXcharacter2Boolean: characterXcharacter -> Boolean
+type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+type integer2address: integer -> address
+type address2integer: address -> integer
+type integer2string: integer -> string
+type integer2character: integer -> character
+type integer2Boolean: integer -> Boolean
+
+
+external function printInteger: integer2integer
+external function printCharacter: character2integer
+external function printBoolean: Boolean2integer
+
+external function printS: string2integer
+external function printI: integer2integer
+external function printC: character2integer
+external function printB: Boolean2integer
+
+external function inS: integer2string
+external function inI: integer2integer
+external function inC: integer2character
+
+function entry: string2integer
 
 entry (arg) := {
     [Boolean: b; integer: x; integer: y; integer: result]

tests/sprint4/test/sp4_cg_fib.alpha

@@ -1,34 +0,0 @@
-(* TEST: [-asc -tc -cg -ir] *)
-
-#include "std.alpha"
-
-
-type M : string -> integer
-function entry : M
-
-type fib: integer -> integer
-function Fib : fib
-
-Fib(i) := {
-        [ Boolean: a ; Boolean: b ; Boolean: c]
-        if( i = 0 ) then {
-                return 7;
-        } else {
-                i := i;
-        }
-        b := b | (a & c);
-        b := 2 < 3;
-        if(i = 1) then {
-                return 1;
-        } else {
-                return i + Fib(i - 1);
-        }
-}
-
-entry (arg) := {
-        [ integer: x; integer: y ]
-        x := 2;
-        x := Fib(2);
-        y := printInteger(Fib(2));
-        return 1;
-}

tests/sprint4/test/sp4_cg_less_than.alpha

@@ -1,6 +1,40 @@
 (* TEST: [-asc -tc -cg -ir] *)
 
-#include "std.alpha"
+type string: 1 -> character
+type BooleanXBoolean: [Boolean: x; Boolean: y]
+type characterXcharacter: [character: x; character: y]
+type integerXinteger: [integer: x; integer: y]
+
+type Boolean2Boolean: Boolean -> Boolean
+type integer2integer: integer -> integer
+type character2integer: character -> integer
+type Boolean2integer: Boolean -> integer
+type string2integer: string -> integer
+type integerXinteger2integer: integerXinteger -> integer
+type integerXinteger2Boolean: integerXinteger -> Boolean
+type characterXcharacter2Boolean: characterXcharacter -> Boolean
+type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+type integer2address: integer -> address
+type address2integer: address -> integer
+type integer2string: integer -> string
+type integer2character: integer -> character
+type integer2Boolean: integer -> Boolean
+
+
+external function printInteger: integer2integer
+external function printCharacter: character2integer
+external function printBoolean: Boolean2integer
+
+external function printS: string2integer
+external function printI: integer2integer
+external function printC: character2integer
+external function printB: Boolean2integer
+
+external function inS: integer2string
+external function inI: integer2integer
+external function inC: integer2character
+
+function entry: string2integer
 
 entry (arg) := {
     [Boolean: b; integer: x; integer: y; integer: result]

tests/sprint4/test/sp4_cg_mod.alpha

@@ -1,6 +1,40 @@
 (* TEST: [-asc -tc -cg -ir] *)
 
-#include "std.alpha"
+type string: 1 -> character
+type BooleanXBoolean: [Boolean: x; Boolean: y]
+type characterXcharacter: [character: x; character: y]
+type integerXinteger: [integer: x; integer: y]
+
+type Boolean2Boolean: Boolean -> Boolean
+type integer2integer: integer -> integer
+type character2integer: character -> integer
+type Boolean2integer: Boolean -> integer
+type string2integer: string -> integer
+type integerXinteger2integer: integerXinteger -> integer
+type integerXinteger2Boolean: integerXinteger -> Boolean
+type characterXcharacter2Boolean: characterXcharacter -> Boolean
+type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+type integer2address: integer -> address
+type address2integer: address -> integer
+type integer2string: integer -> string
+type integer2character: integer -> character
+type integer2Boolean: integer -> Boolean
+
+
+external function printInteger: integer2integer
+external function printCharacter: character2integer
+external function printBoolean: Boolean2integer
+
+external function printS: string2integer
+external function printI: integer2integer
+external function printC: character2integer
+external function printB: Boolean2integer
+
+external function inS: integer2string
+external function inI: integer2integer
+external function inC: integer2character
+
+function entry: string2integer
 
 entry (arg) := {
     [integer:x; integer:y; integer: result]

tests/sprint4/test/sp4_cg_mult.alpha

@@ -1,6 +1,40 @@
 (* TEST: [-asc -tc -cg -ir] *)
 
-#include "std.alpha"
+type string: 1 -> character
+type BooleanXBoolean: [Boolean: x; Boolean: y]
+type characterXcharacter: [character: x; character: y]
+type integerXinteger: [integer: x; integer: y]
+
+type Boolean2Boolean: Boolean -> Boolean
+type integer2integer: integer -> integer
+type character2integer: character -> integer
+type Boolean2integer: Boolean -> integer
+type string2integer: string -> integer
+type integerXinteger2integer: integerXinteger -> integer
+type integerXinteger2Boolean: integerXinteger -> Boolean
+type characterXcharacter2Boolean: characterXcharacter -> Boolean
+type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+type integer2address: integer -> address
+type address2integer: address -> integer
+type integer2string: integer -> string
+type integer2character: integer -> character
+type integer2Boolean: integer -> Boolean
+
+
+external function printInteger: integer2integer
+external function printCharacter: character2integer
+external function printBoolean: Boolean2integer
+
+external function printS: string2integer
+external function printI: integer2integer
+external function printC: character2integer
+external function printB: Boolean2integer
+
+external function inS: integer2string
+external function inI: integer2integer
+external function inC: integer2character
+
+function entry: string2integer
 
 entry (arg) := {
     [integer:x; integer:y; integer: result]

tests/sprint4/test/sp4_cg_neg.alpha

@@ -1,6 +1,40 @@
 (* TEST: [-asc -tc -cg -ir] *)
 
-#include "std.alpha"
+type string: 1 -> character
+type BooleanXBoolean: [Boolean: x; Boolean: y]
+type characterXcharacter: [character: x; character: y]
+type integerXinteger: [integer: x; integer: y]
+
+type Boolean2Boolean: Boolean -> Boolean
+type integer2integer: integer -> integer
+type character2integer: character -> integer
+type Boolean2integer: Boolean -> integer
+type string2integer: string -> integer
+type integerXinteger2integer: integerXinteger -> integer
+type integerXinteger2Boolean: integerXinteger -> Boolean
+type characterXcharacter2Boolean: characterXcharacter -> Boolean
+type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+type integer2address: integer -> address
+type address2integer: address -> integer
+type integer2string: integer -> string
+type integer2character: integer -> character
+type integer2Boolean: integer -> Boolean
+
+
+external function printInteger: integer2integer
+external function printCharacter: character2integer
+external function printBoolean: Boolean2integer
+
+external function printS: string2integer
+external function printI: integer2integer
+external function printC: character2integer
+external function printB: Boolean2integer
+
+external function inS: integer2string
+external function inI: integer2integer
+external function inC: integer2character
+
+function entry: string2integer
 
 entry (arg) := {
     [integer:x; integer:y; integer: result]

tests/sprint4/test/sp4_cg_not.alpha

@@ -1,6 +1,40 @@
 (* TEST: [-asc -tc -cg -ir] *)
 
-#include "std.alpha"
+type string: 1 -> character
+type BooleanXBoolean: [Boolean: x; Boolean: y]
+type characterXcharacter: [character: x; character: y]
+type integerXinteger: [integer: x; integer: y]
+
+type Boolean2Boolean: Boolean -> Boolean
+type integer2integer: integer -> integer
+type character2integer: character -> integer
+type Boolean2integer: Boolean -> integer
+type string2integer: string -> integer
+type integerXinteger2integer: integerXinteger -> integer
+type integerXinteger2Boolean: integerXinteger -> Boolean
+type characterXcharacter2Boolean: characterXcharacter -> Boolean
+type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+type integer2address: integer -> address
+type address2integer: address -> integer
+type integer2string: integer -> string
+type integer2character: integer -> character
+type integer2Boolean: integer -> Boolean
+
+
+external function printInteger: integer2integer
+external function printCharacter: character2integer
+external function printBoolean: Boolean2integer
+
+external function printS: string2integer
+external function printI: integer2integer
+external function printC: character2integer
+external function printB: Boolean2integer
+
+external function inS: integer2string
+external function inI: integer2integer
+external function inC: integer2character
+
+function entry: string2integer
 
 entry (arg) := {
     [Boolean: c; Boolean: d; integer: result]

tests/sprint4/test/sp4_cg_or.alpha

@@ -1,6 +1,40 @@
 (* TEST: [-asc -tc -cg -ir] *)
 
-#include "std.alpha"
+type string: 1 -> character
+type BooleanXBoolean: [Boolean: x; Boolean: y]
+type characterXcharacter: [character: x; character: y]
+type integerXinteger: [integer: x; integer: y]
+
+type Boolean2Boolean: Boolean -> Boolean
+type integer2integer: integer -> integer
+type character2integer: character -> integer
+type Boolean2integer: Boolean -> integer
+type string2integer: string -> integer
+type integerXinteger2integer: integerXinteger -> integer
+type integerXinteger2Boolean: integerXinteger -> Boolean
+type characterXcharacter2Boolean: characterXcharacter -> Boolean
+type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+type integer2address: integer -> address
+type address2integer: address -> integer
+type integer2string: integer -> string
+type integer2character: integer -> character
+type integer2Boolean: integer -> Boolean
+
+
+external function printInteger: integer2integer
+external function printCharacter: character2integer
+external function printBoolean: Boolean2integer
+
+external function printS: string2integer
+external function printI: integer2integer
+external function printC: character2integer
+external function printB: Boolean2integer
+
+external function inS: integer2string
+external function inI: integer2integer
+external function inC: integer2character
+
+function entry: string2integer
 
 entry (arg) := {
     [Boolean:b; Boolean: c; Boolean: d; integer: result]

tests/sprint4/test/sp4_cg_sub.alpha

@@ -1,6 +1,40 @@
 (* TEST: [-asc -tc -cg -ir] *)
 
-#include "std.alpha"
+type string: 1 -> character
+type BooleanXBoolean: [Boolean: x; Boolean: y]
+type characterXcharacter: [character: x; character: y]
+type integerXinteger: [integer: x; integer: y]
+
+type Boolean2Boolean: Boolean -> Boolean
+type integer2integer: integer -> integer
+type character2integer: character -> integer
+type Boolean2integer: Boolean -> integer
+type string2integer: string -> integer
+type integerXinteger2integer: integerXinteger -> integer
+type integerXinteger2Boolean: integerXinteger -> Boolean
+type characterXcharacter2Boolean: characterXcharacter -> Boolean
+type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+type integer2address: integer -> address
+type address2integer: address -> integer
+type integer2string: integer -> string
+type integer2character: integer -> character
+type integer2Boolean: integer -> Boolean
+
+
+external function printInteger: integer2integer
+external function printCharacter: character2integer
+external function printBoolean: Boolean2integer
+
+external function printS: string2integer
+external function printI: integer2integer
+external function printC: character2integer
+external function printB: Boolean2integer
+
+external function inS: integer2string
+external function inI: integer2integer
+external function inC: integer2character
+
+function entry: string2integer
 
 entry (arg) := {
     [integer:x; integer:y; integer: result]

tests/sprint4/test/sp4_tc_arrays.alpha

@@ -1,27 +0,0 @@
-type string: 1 -> character
-type a_of_s: 1 -> string
-type main: integer -> integer
-function entry: main
-
-(* maybe some other type definitions *)
-
-entry(arg) := {
-    [ string: one_name; string: another_name; a_of_s: many_names ]
-    one_name := "a string literal";
-    another_name := reserve another_name(4); (* reserve space for an an array of character, with 4 members *)
-    another_name(0) := 'C';
-    another_name(1) := 'a';
-    another_name(2) := 'r';
-    another_name(3) := 'l';
-    many_names := reserve many_names(3);
-    many_names(0) := one_name;
-    many_names(1) := another_name;
-    many_names(2) := reserve many_names(2)(6); (* reserve space for an item of the same type as a_of_s(2), an array of character, with 6 members *)
-    many_names(2)(0) := 'P';
-    many_names(2)(1) := 'a';
-    many_names(2)(2) := 'r';
-    many_names(2)(3) := 't';
-    many_names(2)(4) := 'h';
-    many_names(2)(5) := 'o';
-    return 0;
-}