scarlett/compiler-the-translators
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'side_branch' into Extra_tweaks

Browse Source
This commit is contained in:
Moroseui
2025-05-06 23:05:01 -04:00
committed by GitHub
parent 0662bea9c3 05a1a671b6
commit 0e0e3699d4
96 changed files with 2743 additions and 554 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
README.MD
View File

@ -1,17 +1,83 @@
# The Translators α Compiler
#### Members: Annie Slenker, Meyer Simon, Partho Bhattacharya, & Scarlett Kadan
## Lexical Analyzer
* **Undefined Behavior:**
* Spaces are not required between tokens. For instance, an INTEGER and an ID are valid even if there is no space between them
## Alpha Compiler Flags & Expected Results:
### -tok
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"
```
## Syntax Analyzer
* *Incomplete*
## Symbol Table
* *TODO: Create diagram.*
* Added an `#include` token to stop syntax errors from being reported on certain alpha files.

4
genx.sh
View File

@ -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

61
library/alphastdio.c Normal file
View File

@ -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;
}

23
library/boundscheck.c Normal file
View File

@ -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);
}

112
library/boundscheck.s Normal file
View File

@ -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

15
library/std.alpha
View File

@ -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

273
library/std.s Normal file
View File

@ -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

296
src/codegen.c
View File

@ -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:
generateLabel(i);
break;
case E_ADD:
generateAdd(i);
break;
case E_SUB:
generateSub(i);
break;
case E_MUL:
generateMult(i);
break;
case E_DIV:
generateDiv(i);
break;
case E_MOD:
generateMod(i);
break;
case E_OR:
generateOr(i);
break;
case E_AND:
generateAnd(i);
break;
case E_NEG:
generateNeg(i);
break;
case E_NOT:
generateNot(i);
break;
case E_ASSIGN:
generateAssign(i);
break;
case E_GOTO:
generateGoto(i);
break;
case E_IF_X_TRUE:
generateIfTrue(i);
break;
case E_IF_X_FALSE:
generateIfFalse(i);
break;
case E_LESS_THAN:
generateLessThan(i);
break;
case E_EQUAL_TO:
generateEqualTo(i);
break;
case E_CALL:
generateCall(i);
break;
case E_PARAM:
generateParam(i);
break;
case E_RETURN:
generateReturn(i);
break;
case E_INDEX_COPY_RIGHT:
generateCopyRight(i);
break;
case E_INDEX_COPY_LEFT:
generateCopyLeft(i);
break;
case E_ADDRESS_OF:
generateAddressOf(i);
break;
case E_FUNC_START:
generateFunctionStart(i);
break;
default:;
case E_LABEL:
generateLabel(i);
break;
case E_ADD:
generateAdd(i);
break;
case E_SUB:
generateSub(i);
break;
case E_MUL:
generateMult(i);
break;
case E_DIV:
generateDiv(i);
break;
case E_MOD:
generateMod(i);
break;
case E_OR:
generateOr(i);
break;
case E_AND:
generateAnd(i);
break;
case E_NEG:
generateNeg(i);
break;
case E_NOT:
generateNot(i);
break;
case E_ASSIGN:
generateAssign(i);
break;
case E_GOTO:
generateGoto(i);
break;
case E_IF_X_TRUE:
generateIfTrue(i);
break;
case E_IF_X_FALSE:
generateIfFalse(i);
break;
case E_LESS_THAN:
generateLessThan(i);
break;
case E_EQUAL_TO:
generateEqualTo(i);
break;
case E_CALL:
generateCall(i);
break;
case E_PARAM:
generateParam(i);
break;
case E_RETURN:
generateReturn(i);
break;
case E_INDEX_COPY_RIGHT:
generateCopyRight(i);
break;
case E_INDEX_COPY_LEFT:
generateCopyLeft(i);
break;
case E_ADDRESS_OF:
generateAddressOf(i);
break;
case E_FUNC_START:
generateFunctionStart(i);
break;
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");
@ -504,14 +535,35 @@ int generateAssign(Instruction *inst) {
printdebug("generateAssign failed, %s is not constant but not in CGlist", getName(getTN(op1)));
return -1;
}
fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#assign start\n", getAddress(op1CG));
fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#assign end\n", getAddress(cg));
if (getAdInfoType(getTN(op1)) != TYPE_FUNCTION_DECLARATION || table_lookup(getAncestor(cur), getName(getTN(op1))) == undefined){
char *movtype;
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 +571,39 @@ int generateCondGoto(Instruction *inst) {
}
int generateIfTrue(Instruction *inst) {
return -1;
// 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
TNodeOrConst *op1 = getOperand1(inst);
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, "\tcmpl\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) {
@ -599,6 +678,7 @@ int generateEqualTo(Instruction *inst) {
fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#equal to start\n", getAddress(op1CG));
fprintf(cg_flag, "\tcmpl\t%d(%%rbp), %%eax\n", getAddress(op2CG));
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 +701,21 @@ int generateCall(Instruction *inst) {
return -1;
}
// if (getTN(op2) == NULL) {
// printdebug("generateFunctionCall failed, NULL tablenode2");
// return -1;
//}
fprintf(cg_flag, "\tcall %s\n", getName(getTN(op1)));
if (table_lookup(getAncestor(cur),getName(getTN(op1)))!=undefined) {
fprintf(cg_flag, "\tcall %s\n", getName(getTN(op1)));
} else {
// printf("%s\n", getName(getTN(op1)));
if (findCG(getTN(op1)) == NULL) {
//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 +741,11 @@ int generateReturn(Instruction *inst) {
printdebug("generateReturn failed, trying to return %s not in CGList", getName(getTN(op1)));
return -1;
}
fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#return %s\n", getAddress(cg), getName(getTN(op1)));
if (table_lookup(getAncestor(cur), getName(getTN(op1))) != undefined) {
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 +762,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,6 +794,7 @@ 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%%eax, %d(%%rbp)\t#adding param end\n", offset - getPrimSize(getTypeEntry(getTN(op1))));
@ -723,7 +815,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 +829,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 +856,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 +868,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;
}

11
src/codegen.h
View File

@ -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;

2
src/grammar.h
View File

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

28
src/grammar.y
View File

@ -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);
@ -690,7 +694,9 @@ simple_statement:
} 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));
// ----------------------------------------------------------------------------
@ -949,8 +955,8 @@ expression:
// ----------------------------------------------------------------------------
uint_least8_t b = 0;
emit_assignment(node, tn_or_const(BOOLEAN,&b));
emit_label(label_gen());
emit_backpatch(S_Pop(TrueList), getLabel(current));
// emit_label(label_gen());
// 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){
@ -1002,8 +1008,8 @@ expression:
// ----------------------------------------------------------------------------
uint_least8_t b = 1;
emit_assignment(node, tn_or_const(BOOLEAN,&b));
emit_label(label_gen());
emit_backpatch(S_Pop(TrueList), getLabel(current));
// emit_label(label_gen());
// 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){
@ -1055,7 +1061,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){
@ -1070,6 +1075,7 @@ expression:
S_Push(FalseList, t, 1);
}
S_Push(t, current, 1);
/*
*/
// ----------------------------------------------------------------------------
printdebug("less than expression");
@ -1089,7 +1095,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){
@ -1104,6 +1109,7 @@ expression:
S_Push(FalseList, t, 1);
}
S_Push(t, current, 1);
/*
*/
// emit_label(label_gen());
// emit_backpatch(S_Pop(TrueList), getLabel(current));
@ -1494,8 +1500,10 @@ assignable:
TableNode* node = CreateEntry(cur,t, type, temp, NULL);
// getElementOffset(rec, ID)
//NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
//emit_field_access(char* node, char* record, $3)
// NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
// 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);
@ -1503,8 +1511,6 @@ assignable:
}
printdebug("[ASSIGNABLE - RULE 3] record = name: %s | field = %s", getName((TableNode*)($1)), getName((TableNode*)$3));
}
;

2
src/intermediate_code.h
View File

@ -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

19
src/lexicalStructure.lex
View File

@ -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;}

51
src/symbol_table.c
View File

@ -694,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.");
@ -710,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){
if(strcmp(getName(cur), id) == 0){
while (cur != NULL) {
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{
return i;
} else {
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.");
@ -744,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(
@ -754,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
@ -1721,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);
@ -1971,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;
}

7
src/symbol_table.h
View File

@ -203,13 +203,20 @@ ListOfTable *getRestOfChildren(ListOfTable *lt);
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;

1
tests/given/README.MD Normal file
View File

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

26
tests/given/test/functionValue.alpha
View File

@ -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 b: integer_2_string2int
function a: int2int
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]
temp := a("Hello");
[integer: result; int2int: f; integer: temp]
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;
}

20
tests/programs/array.alpha Normal file
View File

@ -0,0 +1,20 @@
#include "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;
}

42
tests/programs/factorial.alpha Normal file
View File

@ -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;
}

48
tests/programs/fib.alpha
View File

@ -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;
}

22
tests/programs/helloworld.alpha
View File

@ -1,11 +1,23 @@
#include "std.alpha"
entry (arg) := {
[string: str; character: ch; integer: result]
function entry: string2integer
ch := 'h';
str := "Hello World!";
result := printCharacter(ch);
entry (arg) := {
[integer: result]
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;
}

1
tests/programs/ll.alpha
View File

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

36
tests/programs/sp3_if_else_sse.alpha Normal file
View File

@ -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 := true;
y := true;
if ( x | y ) then {
(*
if ( x<y & !(x=y) ) then {
t := 8;
} else {
}
*)
z := 1 < 2;
c := printBoolean(true);
} else {
y := false; (* bar('c', 7); *)
c := printBoolean(false);
}
return 0;
}

3
tests/sprint1/expected/sp1_include.asc.exp Normal file
View File

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

6
tests/sprint1/expected/sp1_include.tok.exp Normal file
View File

@ -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""

3
tests/sprint2/expected/sp2_carls_mistake.st.exp
View File

@ -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
------------------------------:--------:--------:-----------------------------------:-----------------------------------:

3
tests/sprint2/expected/sp2_llnode.st.exp
View File

@ -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
------------------------------:--------:--------:-----------------------------------:-----------------------------------:

4
tests/sprint2/expected/sp2_llnode_bad.st.exp
View File

@ -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
------------------------------:--------:--------:-----------------------------------:-----------------------------------:

8
tests/sprint2/expected/sp2_sp2_arrayargs.st.exp
View File

@ -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
------------------------------:--------:--------:-----------------------------------:-----------------------------------:
------------------------------:--------:--------:-----------------------------------:-----------------------------------:
------------------------------:--------:--------:-----------------------------------:-----------------------------------:
------------------------------:--------:--------:-----------------------------------:-----------------------------------:
------------------------------:--------:--------:-----------------------------------:-----------------------------------:
------------------------------:--------:--------:-----------------------------------:-----------------------------------:
------------------------------:--------:--------:-----------------------------------:-----------------------------------:
------------------------------:--------:--------:-----------------------------------:-----------------------------------:

10
tests/sprint2/expected/sp2_valid_assignable_and_mem.st.exp
View File

@ -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

2
tests/sprint2/test/sp2_valid_assignable_and_mem.alpha
View File

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

12
tests/sprint3/expected/sp3_and_or_type_check.asc.exp
View File

@ -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:

10
tests/sprint3/expected/sp3_arr_reserve.asc.exp Normal file
View File

@ -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: }

4
tests/sprint3/expected/sp3_boolean_binary_op_typecheck.asc.exp
View File

@ -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 arr2 of type address and Object $t6 of type integer must both be the same type
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 $t7 of type integer must both be the same type
010:
011: return 0;
012: }

3
tests/sprint3/expected/sp3_carls_second_mistake.asc.exp
View File

@ -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';

21
tests/sprint3/expected/sp3_if_else.asc.exp
View File

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

25
tests/sprint3/expected/sp3_if_else_nested_exp.asc.exp Normal file
View File

@ -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: }

31
tests/sprint3/expected/sp3_if_else_sse.asc.exp Normal file
View File

@ -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: }

34
tests/sprint3/expected/sp3_if_else_sse2.asc.exp Normal file
View File

@ -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: }

29
tests/sprint3/expected/sp3_while_nested_bools.asc.exp Normal file
View File

@ -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: }

27
tests/sprint3/expected/sp3_while_sse.asc.exp Normal file
View File

@ -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: }

2
tests/sprint3/test/sp3_arr_reserve.alpha
View File

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

4
tests/sprint3/test/sp3_if_else.alpha
View File

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

1
tests/sprint3/test/sp3_if_else_nested_exp.alpha
View File

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

1
tests/sprint3/test/sp3_if_else_sse.alpha
View File

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

1
tests/sprint3/test/sp3_if_else_sse2.alpha
View File

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

1
tests/sprint3/test/sp3_while_nested_bools.alpha
View File

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

1
tests/sprint3/test/sp3_while_sse.alpha
View File

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

57
tests/sprint4/expected/sp4_cg_add.asc.exp
View File

@ -1,10 +1,47 @@
001: type main: integer -> integer
002: function test: main
003:
004: test (a) := {
005: [integer:x; integer:y]
006: y := 1;
007: x := 3;
008: y := x + y;
009: return y;
010: }
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: 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: }

20
tests/sprint4/expected/sp4_cg_add.ir.exp
View File

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

32
tests/sprint4/expected/sp4_cg_add.s.exp
View File

@ -1,12 +1,26 @@
movl $1, -4(%rbp) #constant assign
movl -4(%rbp), %eax #assign start
movl %eax, -8(%rbp) #assign end
movl $3, -12(%rbp) #constant assign
.globl entry
entry:
pushq %rbp
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 -16(%rbp), %eax
addl %edx, %eax
movl %eax, -20(%rbp) #addition end
movl $3, -20(%rbp) #constant assign
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

60
tests/sprint4/expected/sp4_cg_and.asc.exp
View File

@ -1,10 +1,50 @@
001: type main: integer -> integer
002: function test: main
003:
004: test (a) := {
005: [Boolean:b; Boolean: c; Boolean: d]
006: c := true;
007: d := false;
008: d := c & d;
009: return 1;
010: }
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: 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: }

60
tests/sprint4/expected/sp4_cg_calls.asc.exp Normal file
View File

@ -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: }

39
tests/sprint4/expected/sp4_cg_calls.ir.exp Normal file
View File

@ -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

74
tests/sprint4/expected/sp4_cg_calls.s.exp Normal file
View File

@ -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

57
tests/sprint4/expected/sp4_cg_div.asc.exp
View File

@ -1,10 +1,47 @@
001: type main: integer -> integer
002: function test: main
003:
004: test (a) := {
005: [integer:x; integer:y]
006: y := 1;
007: x := 3;
008: y := x / y;
009: return y;
010: }
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: 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: }

20
tests/sprint4/expected/sp4_cg_div.ir.exp
View File

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

30
tests/sprint4/expected/sp4_cg_div.s.exp
View File

@ -1,12 +1,26 @@
movl $1, -4(%rbp) #constant assign
movl -4(%rbp), %eax #assign start
movl %eax, -8(%rbp) #assign end
movl $3, -12(%rbp) #constant assign
.globl entry
entry:
pushq %rbp
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)
movl %eax, -20(%rbp) #division end
movl -20(%rbp), %eax #assign start
movl %eax, -8(%rbp) #assign end
idivl -24(%rbp)
movl %eax, -28(%rbp) #division 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

57
tests/sprint4/expected/sp4_cg_equal_to.asc.exp
View File

@ -1,10 +1,47 @@
001: type main: integer -> integer
002: function test: main
003:
004: test (a) := {
005: [Boolean: b; integer: x; integer: y]
006: x := 1;
007: y := 2;
008: b := x = y;
009: return 1;
010: }
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: 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: }

26
tests/sprint4/expected/sp4_cg_equal_to.ir.exp
View File

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

37
tests/sprint4/expected/sp4_cg_equal_to.s.exp
View File

@ -1,11 +1,32 @@
movl $1, -4(%rbp) #constant assign
movl -4(%rbp), %eax #assign start
movl %eax, -8(%rbp) #assign end
movl $2, -12(%rbp) #constant assign
.globl entry
entry:
pushq %rbp
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
cmpl -16(%rbp), %eax
movl $2, -20(%rbp) #constant assign
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
movl $1, -20(%rbp) #constant assign
movb $0, -25(%rbp)
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

57
tests/sprint4/expected/sp4_cg_less_than.asc.exp
View File

@ -1,10 +1,47 @@
001: type main: integer -> integer
002: function test: main
003:
004: test (a) := {
005: [Boolean: b; integer: x; integer: y]
006: x := 1;
007: y := 2;
008: b := x < y;
009: return 1;
010: }
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: 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: }

26
tests/sprint4/expected/sp4_cg_less_than.ir.exp
View File

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

36
tests/sprint4/expected/sp4_cg_less_than.s.exp
View File

@ -1,11 +1,31 @@
movl $1, -4(%rbp) #constant assign
movl -4(%rbp), %eax #assign start
movl %eax, -8(%rbp) #assign end
movl $2, -12(%rbp) #constant assign
.globl entry
entry:
pushq %rbp
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
cmpl -16(%rbp), %eax
movl $2, -20(%rbp) #constant assign
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
movl $1, -20(%rbp) #constant assign
movb %al, -25(%rbp) #less than 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

57
tests/sprint4/expected/sp4_cg_mod.asc.exp
View File

@ -1,10 +1,47 @@
001: type main: integer -> integer
002: function test: main
003:
004: test (a) := {
005: [integer:x; integer:y]
006: y := 1;
007: x := 3;
008: y := x % y;
009: return y;
010: }
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: 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: }

20
tests/sprint4/expected/sp4_cg_mod.ir.exp
View File

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

32
tests/sprint4/expected/sp4_cg_mod.s.exp
View File

@ -1,12 +1,26 @@
movl $1, -4(%rbp) #constant assign
movl -4(%rbp), %eax #assign start
movl %eax, -8(%rbp) #assign end
movl $3, -12(%rbp) #constant assign
.globl entry
entry:
pushq %rbp
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
cltd
idivl -8(%rbp)
movl %edx, -20(%rbp) #mod end
movl $20, -20(%rbp) #constant assign
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

57
tests/sprint4/expected/sp4_cg_mult.asc.exp
View File

@ -1,10 +1,47 @@
001: type main: integer -> integer
002: function test: main
003:
004: test (a) := {
005: [integer:x; integer:y]
006: y := 1;
007: x := 3;
008: y := x * x;
009: return y;
010: }
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: 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: }

20
tests/sprint4/expected/sp4_cg_mult.ir.exp
View File

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

28
tests/sprint4/expected/sp4_cg_mult.s.exp
View File

@ -1,11 +1,25 @@
movl $1, -4(%rbp) #constant assign
movl -4(%rbp), %eax #assign start
movl %eax, -8(%rbp) #assign end
.globl entry
entry:
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
imull -16(%rbp), %eax
movl %eax, -20(%rbp) #multiplication end
movl $20, -20(%rbp) #constant assign
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

55
tests/sprint4/expected/sp4_cg_neg.asc.exp
View File

@ -1,9 +1,46 @@
001: type main: integer -> integer
002: function test: main
003:
004: test (a) := {
005: [integer:x; integer:y]
006: x := 3;
007: y := -x;
008: return y;
009: }
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: 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: }

16
tests/sprint4/expected/sp4_cg_neg.ir.exp
View File

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

26
tests/sprint4/expected/sp4_cg_neg.s.exp
View File

@ -1,8 +1,22 @@
movl $3, -4(%rbp) #constant assign
movl -4(%rbp), %eax #assign start
movl %eax, -8(%rbp) #assign end
movl -8(%rbp), %eax #negation start
negl %eax
movl %eax, -12(%rbp) #negation end
.globl entry
entry:
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 #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

55
tests/sprint4/expected/sp4_cg_not.asc.exp
View File

@ -1,9 +1,46 @@
001: type main: integer -> integer
002: function test: main
003:
004: test (a) := {
005: [Boolean: c; Boolean: d]
006: c := true;
007: d := !c;
008: return 1;
009: }
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: 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: }

19
tests/sprint4/expected/sp4_cg_not.ir.exp
View File

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

33
tests/sprint4/expected/sp4_cg_not.s.exp
View File

@ -1,13 +1,20 @@
movl $-1, -1(%rbp) #constant assign
movl -1(%rbp), %eax #assign start
movl %eax, -2(%rbp) #assign end
movzbl -2(%rbp), %eax #not start
testl %eax, %eax
setne %al
xorl $1, %eax
movzbl %al, %eax
movb %al, -3(%rbp)
andb $1, -3(%rbp) #not end
movl -3(%rbp), %eax #assign start
movl %eax, -4(%rbp) #assign end
movl $1, -8(%rbp) #constant assign
.globl entry
entry:
pushq %rbp
movq %rsp, %rbp
subq $400, %rsp
movl %edi, -8(%rbp) #FunctionStart1param end
movl $1, -9(%rbp) #constant assign
.L1:
movl -9(%rbp), %eax #assign start
movl %eax, -10(%rbp) #assign end
.L2:
movl -11(%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 $t3
leave
ret

57
tests/sprint4/expected/sp4_cg_or.asc.exp
View File

@ -1,10 +1,47 @@
001: type main: integer -> integer
002: function test: main
003:
004: test (a) := {
005: [Boolean:b; Boolean: c; Boolean: d]
006: c := true;
007: d := false;
008: d := c | d;
009: return 1;
010: }
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: 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: }

31
tests/sprint4/expected/sp4_cg_or.ir.exp
View File

@ -1,9 +1,22 @@
1: func : test
2: $t0 = true
3: c = $t0
4: $t1 = false
5: d = $t1
6: $t2 = c | d
7: d = $t2
8: $t3 = 1
9: return : $t3
1: func_dec : entry
2: func : entry
3: $t0 = true
4: Label : 1
5: c = $t0
6: $t1 = false
7: Label : 2
8: d = $t1
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

54
tests/sprint4/expected/sp4_cg_or.s.exp
View File

@ -1,21 +1,35 @@
movl $-1, -1(%rbp) #constant assign
movl -1(%rbp), %eax #assign start
movl %eax, -2(%rbp) #assign end
movl $-1, -3(%rbp) #constant assign
movl -3(%rbp), %eax #assign start
movl %eax, -4(%rbp) #assign 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
.globl entry
entry:
pushq %rbp
movq %rsp, %rbp
subq $416, %rsp
movl %edi, -8(%rbp) #FunctionStart1param 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

57
tests/sprint4/expected/sp4_cg_sub.asc.exp
View File

@ -1,10 +1,47 @@
001: type main: integer -> integer
002: function test: main
003:
004: test (a) := {
005: [integer:x; integer:y]
006: y := 1;
007: x := 3;
008: y := x - y;
009: return y;
010: }
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: 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: }

20
tests/sprint4/expected/sp4_cg_sub.ir.exp
View File

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

30
tests/sprint4/expected/sp4_cg_sub.s.exp
View File

@ -1,11 +1,25 @@
movl $1, -4(%rbp) #constant assign
movl -4(%rbp), %eax #assign start
movl %eax, -8(%rbp) #assign end
movl $3, -12(%rbp) #constant assign
.globl entry
entry:
pushq %rbp
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
subl -8(%rbp), %eax
movl %eax, -20(%rbp) #subtraction end
movl $3, -20(%rbp) #constant assign
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

36
tests/sprint4/test/sp4_cg_add.alpha
View File

@ -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]

36
tests/sprint4/test/sp4_cg_and.alpha
View File

@ -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]

45
tests/sprint4/test/sp4_cg_calls.alpha
View File

@ -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;
}

36
tests/sprint4/test/sp4_cg_div.alpha
View File

@ -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]

36
tests/sprint4/test/sp4_cg_equal_to.alpha
View File

@ -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]

34
tests/sprint4/test/sp4_cg_fib.alpha
View File

@ -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;
}

36
tests/sprint4/test/sp4_cg_less_than.alpha
View File

@ -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]

36
tests/sprint4/test/sp4_cg_mod.alpha
View File

@ -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]

36
tests/sprint4/test/sp4_cg_mult.alpha
View File

@ -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]

36
tests/sprint4/test/sp4_cg_neg.alpha
View File

@ -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]

36
tests/sprint4/test/sp4_cg_not.alpha
View File

@ -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]

36
tests/sprint4/test/sp4_cg_or.alpha
View File

@ -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]

36
tests/sprint4/test/sp4_cg_sub.alpha
View File

@ -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]

27
tests/sprint4/test/sp4_tc_arrays.alpha
View File

@ -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;
}