psuh

tests/programs/fib.alpha

@@ -1 +1,30 @@
-(* TODO *)
+(* TEST: [-asc -tc -cg -ir] *)
+
+#include "std.alpha"
+
+function entry : string2integer
+function Fib : integer2integer
+
+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/programs/io.alpha

@@ -5,6 +5,8 @@ function entry: string2integer
 entry (arg) := {
     [integer: x; string: s; character: c; integer: result]
 
+    result := printS("hello world");
+
     s := inS(1);
     result := printS(s);
 

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,16 @@
-   1:  func : test
+   1:  func_dec : entry
-   2:  $t0 = 1
+   2:  func : entry
-   3:  y = $t0
+   3:  $t0 = 1
-   4:  $t1 = 3
+   4:  Label : 1
-   5:  x = $t1
+   5:  y = $t0
-   6:  $t2 = x + y
+   6:  $t1 = 3
-   7:  y = $t2
+   7:  Label : 2
-   8:  return : y
+   8:  x = $t1
+   9:  $t2 = x + y
+  10:  Label : 3
+  11:  y = $t2
+  12:  param y 
+  13:  call : printInteger 1
+  14:  Label : 4
+  15:  result = $t3
+  16:  return : y

tests/sprint4/expected/sp4_cg_add.s.exp

@@ -1,12 +1,30 @@
-	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	$128, %rsp
+	movl	%edi, -8(%rbp)	#FunctionStart1param end
+	movl	$1, -12(%rbp)	#constant assign
+.L1:
 	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
+.L2:
-	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
+.L3:
+	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
+.L4:
+	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: 
+039: type rec: [integer: x; integer: y; integer: z; integer: a; integer: b; integer: c; integer: d]
+040: type T2: rec -> integer
+041: type T: integer -> integer
+042: function bar: T2
+043: function ahh: T
+044: 
+045: ahh (a) := {
+046:     a := printInteger(a);
+047:     return -1;
+048: }
+049: 
+050: bar (a, b, c,d,e,f,g) := {
+051:     a :=  printInteger(g);
+052:     return b;
+053: }
+054: 
+055: entry (arg) := {
+056:     [integer:x; integer:y; integer: result]
+057: 
+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,37 @@
+   1:  func_dec : entry
+   2:  func_dec : bar
+   3:  func_dec : ahh
+   4:  func : ahh
+   5:  param a 
+   6:  call : printInteger 1
+   7:  Label : 1
+   8:  a = $t0
+   9:  $t1 = 1
+  10:  $t2 = -$t1
+  11:  return : $t2
+  12:  func : bar
+  13:  param g 
+  14:  call : printInteger 1
+  15:  Label : 2
+  16:  a = $t3
+  17:  return : b
+  18:  func : entry
+  19:  $t4 = 1
+  20:  $t5 = 2
+  21:  $t6 = 3
+  22:  $t7 = 4
+  23:  $t8 = 5
+  24:  $t9 = 6
+  25:  $t10 = 7
+  26:  param $t10 
+  27:  param $t9 
+  28:  param $t8 
+  29:  param $t7 
+  30:  param $t6 
+  31:  param $t5 
+  32:  param $t4 
+  33:  call : bar 7
+  34:  Label : 3
+  35:  result = $t11
+  36:  $t12 = 1
+  37:  return : $t12

tests/sprint4/expected/sp4_cg_calls.s.exp

@@ -0,0 +1,69 @@
+.globl entry
+ahh:
+	pushq	%rbp
+	movq	%rsp, %rbp
+	subq	$128, %rsp
+	movl	%edi, -4(%rbp)	#FunctionStart1param end
+	movl	-4(%rbp), %edi	#adding param start
+	call printInteger
+	movl	%eax, -8(%rbp)	#store return from call
+.L1:
+	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	$128, %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
+.L2:
+	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	$128, %rsp
+	movl	%edi, -8(%rbp)	#FunctionStart1param end
+	movl	$1, -12(%rbp)	#constant assign
+	movl	$2, -16(%rbp)	#constant assign
+	movl	$3, -20(%rbp)	#constant assign
+	movl	$4, -24(%rbp)	#constant assign
+	movl	$5, -28(%rbp)	#constant assign
+	movl	$6, -32(%rbp)	#constant assign
+	movl	$7, -36(%rbp)	#constant assign
+	movl	-36(%rbp), %edi	#adding param start
+	movl	-32(%rbp), %esi	#adding param start
+	movl	-28(%rbp), %edx	#adding param start
+	movl	-24(%rbp), %ecx	#adding param start
+	movl	-20(%rbp), %r8d	#adding param start
+	movl	-16(%rbp), %r9d	#adding param start
+	movl	-12(%rbp), %eax	#adding param start
+	movl	%eax, 88(%rbp)	#adding param end
+	call bar
+	movl	%eax, -44(%rbp)	#store return from call
+.L3:
+	movl	-44(%rbp), %eax	#assign start
+	movl	%eax, -48(%rbp)	#assign end
+	movl	$1, -52(%rbp)	#constant assign
+	movl	-52(%rbp), %eax	#return $t12
+	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,16 @@
-   1:  func : test
+   1:  func_dec : entry
-   2:  $t0 = 1
+   2:  func : entry
-   3:  y = $t0
+   3:  $t0 = 24
-   4:  $t1 = 3
+   4:  Label : 1
-   5:  x = $t1
+   5:  x = $t0
-   6:  $t2 = x / y
+   6:  $t1 = 3
-   7:  y = $t2
+   7:  Label : 2
-   8:  return : y
+   8:  y = $t1
+   9:  $t2 = x / y
+  10:  Label : 3
+  11:  y = $t2
+  12:  param y 
+  13:  call : printInteger 1
+  14:  Label : 4
+  15:  result = $t3
+  16:  return : y

tests/sprint4/expected/sp4_cg_div.s.exp

@@ -1,12 +1,30 @@
-	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	$128, %rsp
+	movl	%edi, -8(%rbp)	#FunctionStart1param end
+	movl	$24, -12(%rbp)	#constant assign
+.L1:
 	movl	-12(%rbp), %eax	#assign start
 	movl	%eax, -16(%rbp)	#assign end
+	movl	$3, -20(%rbp)	#constant assign
+.L2:
+	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
+.L3:
-	movl	%eax, -8(%rbp)	#assign 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
+.L4:
+	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,17 @@
-   1:  func : test
+   1:  func_dec : entry
-   2:  $t0 = 1
+   2:  func : entry
-   3:  x = $t0
+   3:  $t0 = 1
-   4:  $t1 = 2
+   4:  Label : 1
-   5:  y = $t1
+   5:  x = $t0
-   6:  if ( x = y ) GOTO 0
+   6:  $t1 = 2
-   7:  GOTO : 0
+   7:  Label : 2
-   8:  b = $t2
+   8:  y = $t1
-   9:  $t3 = 1
+   9:  $t2 = x == y
-  10:  return : $t3
+  10:  Label : 3
+  11:  b = $t2
+  12:  param b 
+  13:  call : printBoolean 1
+  14:  Label : 4
+  15:  result = $t3
+  16:  $t4 = 1
+  17:  return : $t4

tests/sprint4/expected/sp4_cg_equal_to.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	$128, %rsp
+	movl	%edi, -8(%rbp)	#FunctionStart1param end
+	movl	$1, -12(%rbp)	#constant assign
+.L1:
 	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
+.L2:
+	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	%al, -25(%rbp)	#equal to end
-	movl	$1, -20(%rbp)	#constant assign
+.L3:
+	movl	-25(%rbp), %eax	#assign start
+	movl	%eax, -26(%rbp)	#assign end
+	movl	-26(%rbp), %edi	#adding param start
+	call printBoolean
+	movl	%eax, -30(%rbp)	#store return from call
+.L4:
+	movl	-30(%rbp), %eax	#assign start
+	movl	%eax, -34(%rbp)	#assign end
+	movl	$1, -38(%rbp)	#constant assign
+	movl	-38(%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,17 @@
-   1:  func : test
+   1:  func_dec : entry
-   2:  $t0 = 1
+   2:  func : entry
-   3:  x = $t0
+   3:  $t0 = 1
-   4:  $t1 = 2
+   4:  Label : 1
-   5:  y = $t1
+   5:  x = $t0
-   6:  if ( x < y ) GOTO 0
+   6:  $t1 = 2
-   7:  GOTO : 0
+   7:  Label : 2
-   8:  b = $t2
+   8:  y = $t1
-   9:  $t3 = 1
+   9:  $t2 = x < y
-  10:  return : $t3
+  10:  Label : 3
+  11:  b = $t2
+  12:  param b 
+  13:  call : printBoolean 1
+  14:  Label : 4
+  15:  result = $t3
+  16:  $t4 = 1
+  17:  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	$128, %rsp
+	movl	%edi, -8(%rbp)	#FunctionStart1param end
+	movl	$1, -12(%rbp)	#constant assign
+.L1:
 	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
+.L2:
+	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
+.L3:
+	movl	-25(%rbp), %eax	#assign start
+	movl	%eax, -26(%rbp)	#assign end
+	movl	-26(%rbp), %edi	#adding param start
+	call printBoolean
+	movl	%eax, -30(%rbp)	#store return from call
+.L4:
+	movl	-30(%rbp), %eax	#assign start
+	movl	%eax, -34(%rbp)	#assign end
+	movl	$1, -38(%rbp)	#constant assign
+	movl	-38(%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,16 @@
-   1:  func : test
+   1:  func_dec : entry
-   2:  $t0 = 1
+   2:  func : entry
-   3:  y = $t0
+   3:  $t0 = 4
-   4:  $t1 = 3
+   4:  Label : 1
-   5:  x = $t1
+   5:  x = $t0
-   6:  $t2 = x % y
+   6:  $t1 = 20
-   7:  y = $t2
+   7:  Label : 2
-   8:  return : y
+   8:  y = $t1
+   9:  $t2 = y % x
+  10:  Label : 3
+  11:  y = $t2
+  12:  param y 
+  13:  call : printInteger 1
+  14:  Label : 4
+  15:  result = $t3
+  16:  return : y

tests/sprint4/expected/sp4_cg_mod.s.exp

@@ -1,12 +1,30 @@
-	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	$128, %rsp
+	movl	%edi, -8(%rbp)	#FunctionStart1param end
+	movl	$4, -12(%rbp)	#constant assign
+.L1:
 	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
+.L2:
-	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
+.L3:
+	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
+.L4:
+	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,16 @@
-   1:  func : test
+   1:  func_dec : entry
-   2:  $t0 = 1
+   2:  func : entry
-   3:  y = $t0
+   3:  $t0 = 3
-   4:  $t1 = 3
+   4:  Label : 1
-   5:  x = $t1
+   5:  x = $t0
-   6:  $t2 = x * x
+   6:  $t1 = 20
-   7:  y = $t2
+   7:  Label : 2
-   8:  return : y
+   8:  y = $t1
+   9:  $t2 = x * y
+  10:  Label : 3
+  11:  y = $t2
+  12:  param y 
+  13:  call : printInteger 1
+  14:  Label : 4
+  15:  result = $t3
+  16:  return : y

tests/sprint4/expected/sp4_cg_mult.s.exp

@@ -1,11 +1,29 @@
-	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	$128, %rsp
+	movl	%edi, -8(%rbp)	#FunctionStart1param end
 	movl	$3, -12(%rbp)	#constant assign
+.L1:
 	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
+.L2:
-	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
+.L3:
+	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
+.L4:
+	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,13 @@
-   1:  func : test
+   1:  func_dec : entry
-   2:  $t0 = 3
+   2:  func : entry
-   3:  x = $t0
+   3:  $t0 = 3
-   4:  $t1 = -x
+   4:  Label : 1
-   5:  y = $t1
+   5:  x = $t0
-   6:  return : y
+   6:  $t1 = -x
+   7:  Label : 2
+   8:  y = $t1
+   9:  param y 
+  10:  call : printInteger 1
+  11:  Label : 3
+  12:  result = $t2
+  13:  return : y

tests/sprint4/expected/sp4_cg_neg.s.exp

@@ -1,8 +1,25 @@
-	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	$128, %rsp
-	movl	%eax, -12(%rbp)	#negation end
+	movl	%edi, -8(%rbp)	#FunctionStart1param end
+	movl	$3, -12(%rbp)	#constant assign
+.L1:
 	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
+.L2:
+	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
+.L3:
+	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,13 @@
-   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:  Label : 3
+  11:  result = $t2
+  12:  $t3 = 1
+  13:  return : $t3

tests/sprint4/expected/sp4_cg_not.s.exp

@@ -1,13 +1,21 @@
-	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	$128, %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, -15(%rbp)	#store return from call
+.L3:
+	movl	-15(%rbp), %eax	#assign start
+	movl	%eax, -19(%rbp)	#assign end
+	movl	$1, -23(%rbp)	#constant assign
+	movl	-23(%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,24 @@
-   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:  Label : 3
+  11:  if c True GOTO 5
+  12:  GOTO : 4
+  13:  Label : 4
+  14:  if d True GOTO 5
+  15:  $t2 = false
+  16:  GOTO : 5
+  17:  Label : 5
+  18:  d = $t2
+  19:  param d 
+  20:  call : printBoolean 1
+  21:  Label : 6
+  22:  result = $t3
+  23:  $t4 = 1
+  24:  return : $t4

tests/sprint4/expected/sp4_cg_or.s.exp

@@ -1,21 +1,31 @@
-	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	$128, %rsp
-	movl	%eax, -4(%rbp)	#assign end
+	movl	%edi, -8(%rbp)	#FunctionStart1param end
-	cmpl	$0, -2(%rbp)	#start or
+	movl	$-1, -9(%rbp)	#constant assign
-	jne	.L1or2
+.L1:
-	cmpl	$0, -4(%rbp)
+	movl	-9(%rbp), %eax	#assign start
-	je	.L1or3
+	movl	%eax, -10(%rbp)	#assign end
-.L1or2:
+	movl	$-1, -11(%rbp)	#constant assign
-	movl	$1, %eax
+.L2:
-	jmp	.L1or4
+	movl	-11(%rbp), %eax	#assign start
-.L1or3:
+	movl	%eax, -12(%rbp)	#assign end
-	movl	$0, %eax
+	movl	$-1, -13(%rbp)	#constant assign
-.L1or4:
+.L3:
-	movb	%al, -5(%rbp)
+.L4:
-	andb	$1, -5(%rbp)	#or end
+	movl	$-1, -13(%rbp)	#constant assign
-	movl	-5(%rbp), %eax	#assign start
+.L5:
-	movl	%eax, -4(%rbp)	#assign end
+	movl	-13(%rbp), %eax	#assign start
-	movl	$1, -9(%rbp)	#constant assign
+	movl	%eax, -12(%rbp)	#assign end
+	movl	-12(%rbp), %edi	#adding param start
+	call printBoolean
+	movl	%eax, -17(%rbp)	#store return from call
+.L6:
+	movl	-17(%rbp), %eax	#assign start
+	movl	%eax, -21(%rbp)	#assign end
+	movl	$1, -25(%rbp)	#constant assign
+	movl	-25(%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,16 @@
-   1:  func : test
+   1:  func_dec : entry
-   2:  $t0 = 1
+   2:  func : entry
-   3:  y = $t0
+   3:  $t0 = 1
-   4:  $t1 = 3
+   4:  Label : 1
-   5:  x = $t1
+   5:  y = $t0
-   6:  $t2 = x - y
+   6:  $t1 = 3
-   7:  y = $t2
+   7:  Label : 2
-   8:  return : y
+   8:  x = $t1
+   9:  $t2 = x - y
+  10:  Label : 3
+  11:  y = $t2
+  12:  param y 
+  13:  call : printInteger 1
+  14:  Label : 4
+  15:  result = $t3
+  16:  return : y

tests/sprint4/expected/sp4_cg_sub.s.exp

@@ -1,11 +1,29 @@
-	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	$128, %rsp
+	movl	%edi, -8(%rbp)	#FunctionStart1param end
+	movl	$1, -12(%rbp)	#constant assign
+.L1:
 	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
+.L2:
-	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
+.L3:
+	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
+.L4:
+	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,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_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,45 @@
 (* 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
 

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]