├── .gitignore ├── LICENSE ├── README.md ├── compiler.py ├── errors └── .gitignore ├── grammar_specs └── grammar_with_action_symbols.txt ├── input ├── fibonacci.c ├── input_hard.c ├── input_hello_world.c ├── input_simple.c └── input_test.c ├── interpreter ├── tester_Linux.out ├── tester_Mac.out └── tester_Windows.exe ├── modules ├── code_gen.py ├── cparser.py ├── scanner.py └── semantic_analyser.py ├── output └── .gitignore ├── run_tests.py └── tests ├── T01 ├── input.txt └── semantic_errors.txt ├── T02 ├── input.txt └── semantic_errors.txt ├── T03 ├── input.txt └── semantic_errors.txt ├── T04 ├── input.txt └── semantic_errors.txt ├── T05 ├── input.txt └── semantic_errors.txt ├── T06 ├── input.txt ├── parse_tree.txt └── syntax_errors.txt ├── T07 ├── input.txt ├── parse_tree.txt └── syntax_errors.txt ├── T08 ├── input.txt ├── parse_tree.txt └── syntax_errors.txt ├── T09 ├── input.txt ├── parse_tree.txt └── syntax_errors.txt ├── T10 ├── input.txt ├── parse_tree.txt └── syntax_errors.txt ├── T11 ├── input.txt ├── parse_tree.txt └── syntax_errors.txt ├── T12 ├── input.txt ├── lexical_errors.txt ├── symbol_table.txt └── tokens.txt ├── T13 ├── input.txt ├── lexical_errors.txt ├── symbol_table.txt └── tokens.txt ├── TS14 ├── input.txt ├── lexical_errors.txt ├── symbol_table.txt └── tokens.txt ├── TS15 ├── input.txt ├── lexical_errors.txt ├── symbol_table.txt └── tokens.txt ├── TS16 ├── input.txt ├── lexical_errors.txt ├── symbol_table.txt └── tokens.txt ├── TS17 ├── input.txt ├── lexical_errors.txt ├── symbol_table.txt └── tokens.txt ├── TX18 ├── input.txt ├── parse_tree.txt └── syntax_errors.txt ├── TX19 ├── input.txt ├── parse_tree.txt └── syntax_errors.txt ├── TX20 ├── input.txt ├── parse_tree.txt └── syntax_errors.txt ├── TX21 ├── input.txt ├── parse_tree.txt └── syntax_errors.txt ├── TX22 ├── input.txt ├── parse_tree.txt └── syntax_errors.txt ├── TX23 ├── input.txt ├── parse_tree.txt └── syntax_errors.txt ├── TX24 ├── input.txt ├── parse_tree.txt └── syntax_errors.txt ├── TX25 ├── input.txt ├── parse_tree.txt └── syntax_errors.txt ├── TX26 ├── input.txt ├── parse_tree.txt └── syntax_errors.txt ├── TX27 ├── input.txt ├── parse_tree.txt └── syntax_errors.txt ├── TXX28 ├── input.txt └── output.txt ├── TXX29 ├── input.txt └── output.txt ├── TXX30 ├── input.txt └── output.txt ├── TXX31 ├── input.txt └── output.txt ├── TXX32 ├── input.txt └── output.txt ├── TXX33 ├── input.txt └── output.txt ├── TXX34 ├── input.txt └── output.txt ├── TXX35 ├── input.txt └── output.txt ├── TXX36 ├── input.txt └── output.txt ├── TXX37 ├── input.txt └── output.txt └── TXX38 ├── input.txt └── output.txt /.gitignore: -------------------------------------------------------------------------------- 1 | **/.vscode/ 2 | **/__pycache__/ 3 | *.pdf 4 | *.docx 5 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 Hyper5phere 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Simple C Compiler written in Python 2 | 3 | Simple C Compiler supports a subset of C programming language. Most notably it has only integer typed variables. Nevertheless, it is a fully functional C compiler front-end for generating intermediate representation (IR) three address codes from a C source file. Furthermore, an interpreter program [1] for the three address "assembly" code is provided for all major platforms (Windows, Linux and Mac) to execute the programs with ease. 4 | 5 | As the name hints, it is also simple to use! Only one python module needed to start using it! 6 | 7 | This compiler implementation is also part of a [blog post about designing and implementing compilers](https://medium.com/@pasi_pyrro/how-to-write-your-own-c-compiler-from-scratch-with-python-90ab84ffe071), you might wanna check it out! 8 | 9 | ## Requirements 10 | All major operating systems (Windows, Linux and Mac) should be supported. 11 | 12 | Make sure Python 3.6 or newer interpreter is installed on your system. Then install the ``anytree`` package with pip 13 | 14 | ```bash 15 | 16 | pip install anytree 17 | ``` 18 | 19 | ## Installation and Testing 20 | 21 | For testing the compiler here is a simple test program that prints the 15 first odd numbers 22 | ```c 23 | /* 24 | * Simple example source code 25 | * 26 | * prints N odd numbers 27 | */ 28 | 29 | void main(void) { 30 | /* all variables need to be declared first */ 31 | int i; 32 | int j; 33 | int m; 34 | int N; 35 | 36 | /* ...and then assigned to */ 37 | i = 1; 38 | j = 1; 39 | m = 0-1; // syntax only supports binary operations, this is how we get -1 40 | 41 | N = 15; // change me to increase number of odd numbers 42 | 43 | while (i < N * 2 + 1) { 44 | j = m * j; 45 | if (j < 0) { 46 | output(i); 47 | } else { 48 | // do nothing, the syntax does not support if without else :^) 49 | } 50 | i = i + 1; 51 | } 52 | } 53 | ``` 54 | 55 | To compile and run it, type 56 | ```bash 57 | git clone https://github.com/Hyper5phere/simple-c-compiler.git 58 | cd simple-c-compiler 59 | python compiler.py input/input_simple.c --run 60 | ``` 61 | 62 | To see all input arguments type 63 | ```bash 64 | python compiler.py --help 65 | ``` 66 | 67 | All output of the compiler is stored in the ``./output`` folder and all the input examples can be found from ``./input`` folder. Additionally errors are logged in the ``./errors`` folder if ``--error-files`` input flag is used. 68 | 69 | 70 | ## Possible Future Improvements 71 | Language support for 72 | - arrays 73 | - recursion 74 | - string types 75 | - nested functions (not really C though) 76 | 77 | ## References 78 | [1] The interpreter program has been implemented by Romina Jafarian, at Computer Engineering Department of Sharif 79 | University of Technology (Tehran) in Fall 2017. 80 | -------------------------------------------------------------------------------- /compiler.py: -------------------------------------------------------------------------------- 1 | import os 2 | import sys 3 | import time 4 | import argparse 5 | import platform 6 | import subprocess as sp 7 | 8 | script_dir = os.path.dirname(os.path.abspath(__file__)) 9 | sys.path.insert(0, os.path.join(script_dir, "modules")) 10 | 11 | from cparser import Parser 12 | from scanner import Scanner, SymbolTableManager 13 | from semantic_analyser import SemanticAnalyser 14 | from code_gen import CodeGen, MemoryManager 15 | 16 | 17 | # Maximal virtual memory for compiled program process (in bytes). 18 | MAX_VIRTUAL_MEMORY = 50 * 1024 * 1024 # 50 MB 19 | 20 | def limit_virtual_memory(): 21 | import resource 22 | resource.setrlimit(resource.RLIMIT_AS, (MAX_VIRTUAL_MEMORY, MAX_VIRTUAL_MEMORY)) 23 | 24 | 25 | def compile(args): 26 | print("Compiling", args.source_file) 27 | SymbolTableManager.init() 28 | MemoryManager.init() 29 | parser = Parser(args.source_file) 30 | start = time.time() 31 | parser.parse() 32 | stop = time.time() - start 33 | print(f"Compilation took {stop:.6f} s") 34 | if not SymbolTableManager.error_flag: 35 | print("Compilation successful!") 36 | else: 37 | print("Compilation failed due to the following errors:\n") 38 | print(parser.scanner.lexical_errors) 39 | print(parser.syntax_errors) 40 | print(parser.semantic_analyzer.semantic_errors) 41 | if args.abstract_syntax_tree: 42 | parser.save_parse_tree() 43 | if args.symbol_table: 44 | parser.scanner.save_symbol_table() 45 | if args.tokens: 46 | parser.scanner.save_tokens() 47 | if args.error_files: 48 | parser.save_syntax_errors() 49 | parser.scanner.save_lexical_errors() 50 | parser.semantic_analyzer.save_semantic_errors() 51 | parser.code_generator.save_output() 52 | if args.run and not SymbolTableManager.error_flag: 53 | print("Executing compiled program") 54 | plat = platform.system() 55 | if plat == "Windows": 56 | tester_file = os.path.join(script_dir, "interpreter", "tester_Windows.exe") 57 | elif plat == "Linux": 58 | tester_file = os.path.join(script_dir, "interpreter", "tester_Linux.out") 59 | elif plat == "Darwin": 60 | tester_file = os.path.join(script_dir, "interpreter", "tester_Mac.out") 61 | else: 62 | raise RuntimeError("Unsupported operating system for code execution!") 63 | output_file = os.path.join(script_dir, "output", "output.txt") 64 | output_dir = os.path.dirname(output_file) 65 | if os.path.exists(output_file): 66 | preexec_fn = limit_virtual_memory if plat == "Linux" else None 67 | stderr = sp.PIPE if not args.verbose else None 68 | start = time.time() 69 | try: 70 | tester_output = sp.check_output(tester_file, cwd=output_dir, 71 | stderr=stderr, timeout=10, 72 | preexec_fn=preexec_fn).decode("utf-8") 73 | except sp.TimeoutExpired: 74 | print("RuntimeError: Execution timed out!") 75 | else: 76 | if not args.verbose: 77 | tester_output = "\n".join([line.replace("PRINT", "").strip() 78 | for line in tester_output.splitlines() 79 | if line.startswith("PRINT")]) 80 | stop = time.time() - start 81 | print(f"Execution took {stop:.6f} s") 82 | print("Program output:") 83 | print(tester_output) 84 | 85 | 86 | if __name__ == "__main__": 87 | parser = argparse.ArgumentParser(description='Simple C Compiler written in Python') 88 | parser.add_argument("source_file", help="Path to C source file.") 89 | parser.add_argument('-r', '--run', action='store_true', help='Run the output program after compilation.') 90 | parser.add_argument('-v', '--verbose', action='store_true', help='Print all used three address codes.') 91 | parser.add_argument('-ef', '--error-files', action='store_true', help='Save compilation errors to text files.') 92 | parser.add_argument('-ast', '--abstract-syntax-tree', action='store_true', help='Save abstract syntax tree into a text file.') 93 | parser.add_argument('-st', '--symbol-table', action='store_true', help='Save symbol table into a text file.') 94 | parser.add_argument('-t', '--tokens', action='store_true', help='Save lexed tokens into a text file.') 95 | args = parser.parse_args() 96 | if not os.path.isabs(args.source_file): 97 | args.source_file = os.path.abspath(script_dir) 98 | args = parser.parse_args() 99 | compile(args) 100 | -------------------------------------------------------------------------------- /errors/.gitignore: -------------------------------------------------------------------------------- 1 | # Ignore everything in this directory 2 | * 3 | # Except this file 4 | !.gitignore -------------------------------------------------------------------------------- /grammar_specs/grammar_with_action_symbols.txt: -------------------------------------------------------------------------------- 1 | Program -> Declaration-list 2 | Declaration-list -> Declaration Declaration-list | EPSILON 3 | Declaration -> Declaration-initial Declaration-prime 4 | Declaration-initial -> #SA_SAVE_MAIN #SA_SAVE_TYPE Type-specifier #SA_SAVE_MAIN #SA_ASSIGN_TYPE ID 5 | Declaration-prime -> #SA_ASSIGN_FUN_ROLE Fun-declaration-prime | #SA_ASSIGN_VAR_ROLE #SA_MAIN_POP Var-declaration-prime 6 | Var-declaration-prime -> #SA_ASSIGN_LENGTH ; | [ #SA_ASSIGN_LENGTH NUM ] ; 7 | Fun-declaration-prime -> ( #SA_INC_SCOPE #SA_SAVE_MAIN Params #SA_ASSIGN_FUN_ATTRS ) #SA_MAIN_CHECK Compound-stmt #CG_CALC_STACKFRAME_SIZE #CG_RETURN_SEQ_CALLEE #SA_DEC_SCOPE 8 | Type-specifier -> int | void 9 | Params -> #SA_SAVE_TYPE #SA_SAVE_PARAM int #SA_ASSIGN_TYPE ID #SA_ASSIGN_PARAM_ROLE Param-prime Param-list | void Param-list-void-abtar 10 | Param-list-void-abtar -> ID Param-prime Param-list | EPSILON 11 | Param-list -> , #SA_SAVE_PARAM Param Param-list | EPSILON 12 | Param -> Declaration-initial #SA_ASSIGN_PARAM_ROLE Param-prime 13 | Param-prime -> #SA_ASSIGN_LENGTH [ ] | #SA_ASSIGN_LENGTH EPSILON 14 | Compound-stmt -> { Declaration-list Statement-list } 15 | Statement-list -> Statement Statement-list | EPSILON 16 | Statement -> Expression-stmt | Compound-stmt | Selection-stmt | Iteration-stmt | Return-stmt | Switch-stmt 17 | Expression-stmt -> Expression #CG_CLOSE_STMT ; | #SA_CHECK_WHILE #CG_CONT_JP continue ; | #SA_CHECK_BREAK #CG_BREAK_JP_SAVE break ; | ; 18 | Selection-stmt -> if ( Expression ) #CG_SAVE Statement else #CG_ELSE Statement #CG_IF_ELSE 19 | Iteration-stmt -> #SA_PUSH_WHILE while #CG_LABEL #CG_INIT_WHILE_STACKS ( Expression ) #CG_SAVE Statement #CG_WHILE #SA_POP_WHILE 20 | Return-stmt -> return Return-stmt-prime #CG_SET_RETVAL #CG_RETURN_SEQ_CALLEE 21 | Return-stmt-prime -> ; | Expression ; 22 | Switch-stmt -> #SA_PUSH_SWITCH switch ( Expression ) { Case-stmts Default-stmt } #SA_POP_SWITCH 23 | Case-stmts -> Case-stmt Case-stmts | EPSILON 24 | Case-stmt -> case NUM : Statement-list 25 | Default-stmt -> default : Statement-list | EPSILON 26 | Expression -> Simple-expression-zegond | #SA_CHECK_DECL #SA_SAVE_FUN #SA_SAVE_TYPE_CHECK #CG_PUSH_ID ID B 27 | B -> = Expression #SA_TYPE_CHECK #CG_ASSIGN | #SA_INDEX_ARRAY [ Expression ] #SA_INDEX_ARRAY_POP H | Simple-expression-prime 28 | H -> = Expression #SA_TYPE_CHECK #CG_ASSIGN | G D C 29 | Simple-expression-zegond -> Additive-expression-zegond C 30 | Simple-expression-prime -> Additive-expression-prime C 31 | C -> #CG_SAVE_OP Relop Additive-expression #SA_TYPE_CHECK #CG_RELOP | EPSILON 32 | Relop -> < | == 33 | Additive-expression -> Term D 34 | Additive-expression-prime -> Term-prime D 35 | Additive-expression-zegond -> Term-zegond D 36 | D -> #CG_SAVE_OP Addop Term #SA_TYPE_CHECK #CG_ADDOP D | EPSILON 37 | Addop -> + | - 38 | Term -> Factor G 39 | Term-prime -> Factor-prime G 40 | Term-zegond -> Factor-zegond G 41 | G -> * Factor #SA_TYPE_CHECK #CG_MULT G | EPSILON 42 | Factor -> ( Expression ) | #SA_CHECK_DECL #SA_SAVE_FUN #SA_SAVE_TYPE_CHECK #CG_PUSH_ID ID Var-call-prime | #SA_SAVE_TYPE_CHECK #CG_PUSH_CONST NUM 43 | Var-call-prime -> #SA_PUSH_ARG_STACK ( Args #SA_CHECK_ARGS ) #CG_CALL_SEQ_CALLER #SA_POP_ARG_STACK | Var-prime 44 | Var-prime -> #SA_INDEX_ARRAY [ Expression ] #SA_INDEX_ARRAY_POP | EPSILON 45 | Factor-prime -> #SA_PUSH_ARG_STACK ( Args #SA_CHECK_ARGS ) #CG_CALL_SEQ_CALLER #SA_POP_ARG_STACK | EPSILON 46 | Factor-zegond -> ( Expression ) | #SA_SAVE_TYPE_CHECK #CG_PUSH_CONST NUM 47 | Args -> Arg-list | EPSILON 48 | Arg-list -> #SA_SAVE_ARG Expression Arg-list-prime 49 | Arg-list-prime -> , #SA_SAVE_ARG Expression Arg-list-prime | EPSILON -------------------------------------------------------------------------------- /input/fibonacci.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Example source code 3 | * 4 | * prints N numbers from Fibonacci sequence 5 | */ 6 | 7 | void main(void) { 8 | int i; 9 | int N; 10 | int a; 11 | int b; 12 | int tmp; 13 | 14 | i = 0; 15 | a = 0; 16 | b = 1; 17 | tmp = 0; 18 | 19 | N = 20; // how many numbers to print? 20 | 21 | output(0); // always print the first number 22 | 23 | while (i < N) { 24 | output(a + b); 25 | tmp = b; 26 | b = a + tmp; 27 | a = tmp; 28 | i = i + 1; 29 | } 30 | } -------------------------------------------------------------------------------- /input/input_hard.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Hard example source code 3 | * 4 | * prints N length sequence of sums of i first odd numbers 5 | * where i is the index of the sum in the sequence 6 | */ 7 | 8 | int abs(int a) { 9 | if (a < 0) { 10 | return 0-a; 11 | } else { 12 | return a; 13 | } 14 | } 15 | 16 | int isMultiplier(int a, int b) { 17 | int i; 18 | int step; 19 | int flag; 20 | 21 | if (b == 0) { 22 | return 0; 23 | } else { 24 | i = 1; 25 | flag = 0; 26 | } 27 | 28 | if (a < 0) { 29 | if (b < 0) { 30 | i = 1; 31 | } else { 32 | i = 0-1; 33 | } 34 | } else { 35 | if (b < 0) { 36 | i = 0-1; 37 | } else { 38 | i = 1; 39 | } 40 | } 41 | 42 | step = i; 43 | i = i - abs(i); 44 | while (abs(i) < abs(a) + 1) { 45 | if (i * b == a) { 46 | flag = 1; 47 | break; 48 | } else { 49 | i = i + step; 50 | continue; 51 | } 52 | } 53 | return flag; 54 | 55 | } 56 | 57 | 58 | void main(void) { 59 | int i; 60 | int j; 61 | int sum; 62 | int N; 63 | 64 | i = 1; 65 | j = 1; 66 | 67 | N = 5; // change me to increase length of sequence 68 | 69 | while (i < N * 2 + 1) { 70 | sum = 0; 71 | j = 0; 72 | while (j < i) { 73 | j = j + 1; 74 | if (isMultiplier(j, 2)) { 75 | sum = sum + 0; 76 | } else { 77 | sum = sum + j; 78 | } 79 | } 80 | output(sum); 81 | i = i + 2; 82 | 83 | } 84 | 85 | } 86 | -------------------------------------------------------------------------------- /input/input_hello_world.c: -------------------------------------------------------------------------------- 1 | /* I forgot to implement strings so this 2 | should do for a "hello world program" */ 3 | void main(void) { 4 | output(1234); 5 | } -------------------------------------------------------------------------------- /input/input_simple.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Simple example source code 3 | * 4 | * prints N odd numbers 5 | */ 6 | 7 | void main(void) { 8 | /* all variables need to be declared first */ 9 | int i; 10 | int j; 11 | int m; 12 | int N; 13 | 14 | /* ...and then assigned to */ 15 | i = 1; 16 | j = 1; 17 | m = 0-1; // syntax only supports binary operations, this is how we get -1 18 | 19 | N = 15; // change me to increase number of odd numbers 20 | 21 | while (i < N * 2 + 1) { 22 | j = m * j; 23 | if (j < 0) { 24 | output(i); 25 | } else { 26 | // do nothing, the syntax does not support if without else :^) 27 | } 28 | i = i + 1; 29 | } 30 | } -------------------------------------------------------------------------------- /input/input_test.c: -------------------------------------------------------------------------------- 1 | void main(void) { 2 | int i; 3 | i = 0; 4 | while (i < 10) { 5 | output(i); 6 | i = i + 1; 7 | } 8 | } -------------------------------------------------------------------------------- /interpreter/tester_Linux.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Hyper5phere/simple-c-compiler/4fa3d71c21b52f3fbfc875444207896d33ddafae/interpreter/tester_Linux.out -------------------------------------------------------------------------------- /interpreter/tester_Mac.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Hyper5phere/simple-c-compiler/4fa3d71c21b52f3fbfc875444207896d33ddafae/interpreter/tester_Mac.out -------------------------------------------------------------------------------- /interpreter/tester_Windows.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Hyper5phere/simple-c-compiler/4fa3d71c21b52f3fbfc875444207896d33ddafae/interpreter/tester_Windows.exe -------------------------------------------------------------------------------- /modules/scanner.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Scanner module of the Simple C Compiler 3 | 4 | Author: Pasi Pyrrö 5 | Date: 20 March 2020 6 | ''' 7 | 8 | import os 9 | 10 | script_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) 11 | 12 | class SymbolTableManager(object): 13 | ''' Manages the symbol table of the compiler 14 | which is used across modules ''' 15 | _global_funcs = [{ 16 | "lexim": "output", 17 | "scope": 0, 18 | "type": "void", 19 | "role": "function", 20 | "arity": 1, 21 | "params": ["int"] 22 | }] 23 | 24 | @classmethod 25 | def init(cls): 26 | cls.scope_stack = [0] 27 | cls.temp_stack = [0] 28 | cls.arg_list_stack = [] 29 | cls.symbol_table = cls._global_funcs.copy() 30 | cls.declaration_flag = False 31 | cls.error_flag = False 32 | 33 | @classmethod 34 | def scope(cls): 35 | return len(cls.scope_stack) - 1 36 | 37 | @classmethod 38 | def insert(cls, lexim): 39 | cls.symbol_table.append({"lexim" : lexim, "scope" : cls.scope()}) 40 | 41 | @classmethod 42 | def _exists(cls, lexim, scope): 43 | for row in cls.symbol_table: 44 | if row["lexim"] == lexim and row["scope"] == scope: 45 | return True 46 | return False 47 | 48 | @classmethod 49 | def findrow(cls, value, attr="lexim"): 50 | for i in range(len(cls.symbol_table) - 1, -1, -1): 51 | row = cls.symbol_table[i] 52 | if row[attr] == value: 53 | return row 54 | return None 55 | 56 | @classmethod 57 | def findrow_idx(cls, value, attr="lexim"): 58 | for i in range(len(cls.symbol_table) - 1, -1, -1): 59 | row = cls.symbol_table[i] 60 | if row[attr] == value: 61 | return i 62 | return None 63 | 64 | @classmethod 65 | def install_id(cls, lexim): 66 | if not cls.declaration_flag: 67 | i = cls.findrow_idx(lexim) 68 | if i is not None: 69 | return i 70 | return len(cls.symbol_table) 71 | 72 | @classmethod 73 | def get_enclosing_fun(cls, level=1): 74 | try: 75 | return cls.symbol_table[cls.scope_stack[-level] - 1] 76 | except IndexError: 77 | return None 78 | 79 | 80 | char_to_col = { # abbreviations in DFA 81 | "WHITESPACE" : 0, # w 82 | "DIGIT" : 1, # d 83 | "LETTER" : 2, # l 84 | "*" : 3, # * 85 | "=" : 4, # = 86 | "SYMBOL" : 5, # s 87 | "/" : 6, # / 88 | "\n" : 7, # \n 89 | "OTHER" : 8 # o (Anything else, only valid inside comment block) 90 | } 91 | 92 | state_to_token = { 93 | 1 : "WHITESPACE", 94 | 3 : "NUM", 95 | 6 : "ID_OR_KEYWORD", 96 | 10 : "SYMBOL", 97 | 11 : "SYMBOL", 98 | 12 : "SYMBOL", 99 | 16 : "COMMENT", 100 | 18 : "COMMENT", 101 | 19 : "WHITESPACE", 102 | 21 : "SYMBOL", 103 | } 104 | 105 | state_to_error_message = { 106 | 4 : "illegal number", 107 | 8 : "unmatched */", 108 | 20 : "invalid input", 109 | 22 : "invalid input" 110 | } 111 | 112 | token_dfa = ( 113 | # Input character types 114 | # w d l * = s / \n o 115 | # 0 1 2 3 4 5 6 7 8 116 | ( 1, 2, 5, 7, 9, 12, 13, 19, 20), # State 0 (initial state) 117 | ( 1, None, None, None, None, None, None, 1, None), # State 1 (whitespace) 118 | ( 3, 2, 4, 3, 3, 3, 3, 3, 4), # State 2 119 | (None, None, None, None, None, None, None, None, None), # State 3 (number) 120 | (None, None, None, None, None, None, None, None, None), # State 4 (illegal number) 121 | ( 6, 5, 5, 6, 6, 6, 6, 6, 20), # State 5 122 | (None, None, None, None, None, None, None, None, None), # State 6 (id or keyword) 123 | ( 21, 21, 21, 21, 21, 21, 8, 21, 20), # State 7 124 | (None, None, None, None, None, None, None, None, None), # State 8 (unmatched */) 125 | ( 11, 11, 11, 11, 10, 11, 11, 11, 20), # State 9 126 | (None, None, None, None, None, None, None, None, None), # State 10 (symbol ==) 127 | (None, None, None, None, None, None, None, None, None), # State 11 (symbol =) 128 | (None, None, None, None, None, None, None, None, None), # State 12 (symbol) 129 | ( 22, 22, 22, 14, 22, 22, 17, 22, 22), # State 13 130 | ( 14, 14, 14, 15, 14, 14, 14, 14, 14), # State 14 131 | ( 14, 14, 14, 15, 14, 14, 16, 14, 14), # State 15 132 | (None, None, None, None, None, None, None, None, None), # State 16 (/* comment */) 133 | ( 17, 17, 17, 17, 17, 17, 17, 18, 17), # State 17 134 | (None, None, None, None, None, None, None, None, None), # State 18 (// comment\n) 135 | ( 19, None, None, None, None, None, None, 19, None), # State 19 (newline + whitespace) 136 | (None, None, None, None, None, None, None, None, None), # State 20 (invalid input) 137 | (None, None, None, None, None, None, None, None, None), # State 21 (symbol *) 138 | (None, None, None, None, None, None, None, None, None), # State 22 (invalid comment) 139 | ) 140 | 141 | F = {1, 3, 6, 10, 11, 12, 16, 18, 19, 20, 21} # all accepting states 142 | Fstar = {3, 6, 11, 21} # accepting states that require the last character to be returned to the input stream 143 | unclosed_comment_states = {14, 15, 17} 144 | 145 | whitespaces = {' ', '\r', '\t', '\v', '\f'} # \n excluded as it has special meaning in one line comments 146 | 147 | 148 | class Scanner(object): 149 | ''' Lexical analyzer object which tokenizes input source file 150 | according to C minus lexical specification ''' 151 | 152 | def __init__(self, input_file, chunk_size=8192, max_state_size=float("inf")): 153 | assert chunk_size >= 16, "Minimum supported chunk size is 16!" 154 | if not os.path.isabs(input_file): 155 | input_file = os.path.join(script_dir, input_file) 156 | self.input_file = input_file 157 | self.line_number = 1 158 | self.first_line = 1 159 | self._lexical_errors = [] 160 | self.tokens = {} # access tokens by line number 161 | self.tokens[self.line_number] = [] 162 | self.max_state_size = max_state_size # how many lines of tokens we want to keep in memory (default: unlimited) 163 | 164 | self.tokens_file = os.path.join(script_dir, "output", "tokens.txt") 165 | self.symbol_file = os.path.join(script_dir, "output", "symbol_table.txt") 166 | 167 | self.errors_file = os.path.join(script_dir, "errors", "lexical_errors.txt") 168 | 169 | self.chunk_size = chunk_size 170 | self.file_pointer = 0 171 | self.max_unclosed_comment_size = 15 172 | self.input = "" 173 | self.read_input() 174 | 175 | # lexical specification 176 | self._symbols = {',', ';', ':', '[', ']', '(', ')', '{', '}', '+', '-', '<'} # = and * excluded 177 | self.letters = {chr(i) for i in range(65, 91)} | {chr(i) for i in range(97, 123)} 178 | self.digits = {str(i) for i in range(0, 10)} 179 | self.symbols = self._symbols | {"*", "="} 180 | keywords = [ 181 | "if", # 0 182 | "else", # 1 183 | "void", # 2 184 | "int", # 3 185 | "while", # 4 186 | "break", # 5 187 | "continue", # 6 188 | "switch", # 7 189 | "default", # 8 190 | "case", # 9 191 | "return" # 10 192 | ] 193 | self.identifiers = keywords 194 | self.keywords = set(keywords) 195 | 196 | 197 | @property 198 | def lexical_errors(self): 199 | lexical_errors = [] 200 | if self._lexical_errors: 201 | for lineno, lexim, error in self._lexical_errors: 202 | lexical_errors.append(f"#{lineno} : Lexical Error! '{lexim}' rejected, reason: {error}.\n") 203 | else: 204 | lexical_errors.append("There is no lexical errors.\n") 205 | return "".join(lexical_errors) 206 | 207 | 208 | def save_lexical_errors(self): 209 | if self.max_state_size > 0: 210 | with open(self.errors_file, "w") as f: 211 | f.write(self.lexical_errors) 212 | 213 | 214 | def id_to_lexim(self, token_id): 215 | return SymbolTableManager.symbol_table[token_id]['lexim'] 216 | 217 | 218 | def token_to_str(self, token): 219 | if token[0] == "ID": 220 | return f"({token[0]}, {self.id_to_lexim(token[1])})" 221 | else: 222 | return "({}, {})".format(*token) 223 | 224 | 225 | def read_input(self): 226 | with open(self.input_file, "rb") as f: 227 | f.seek(self.file_pointer) 228 | chunk = f.read(self.chunk_size) 229 | if not chunk: 230 | raise EOFError 231 | self.input += chunk.decode() 232 | self.file_pointer += self.chunk_size 233 | 234 | 235 | def _resolve_dfa_table_column(self, input_char): 236 | if input_char in whitespaces: 237 | return char_to_col["WHITESPACE"] 238 | if input_char in self.letters: 239 | return char_to_col["LETTER"] 240 | if input_char in self.digits: 241 | return char_to_col["DIGIT"] 242 | if input_char in self._symbols: 243 | return char_to_col["SYMBOL"] 244 | try: 245 | return char_to_col[input_char] 246 | except KeyError: 247 | return char_to_col["OTHER"] 248 | 249 | 250 | def save_symbol_table(self): 251 | with open(self.symbol_file, "w") as f: 252 | for i, symbol in enumerate(self.identifiers): 253 | f.write(f"{i+1}.\t{symbol}\n") 254 | 255 | 256 | def save_tokens(self): 257 | if self.max_state_size > 0: 258 | with open(self.tokens_file, "w") as f: 259 | for lineno, tokens in self.tokens.items(): 260 | if tokens: 261 | f.write(f"{lineno}.\t{' '.join([f'({t}, {l})' for t, l in tokens])}\n") 262 | 263 | 264 | def _switch_line(self, num_lines): 265 | if num_lines > 0: 266 | for i in range(num_lines): 267 | self.tokens[self.line_number + i + 1] = [] 268 | self.line_number += num_lines 269 | # remove leading whitespace from next line 270 | # (expect newlines as we need them for line number calculations) 271 | self.input = self.input.lstrip(" ").lstrip("\t") 272 | 273 | 274 | def update_symbol_table(self, lexim): 275 | symbol_id = SymbolTableManager.install_id(lexim) 276 | if symbol_id == len(SymbolTableManager.symbol_table): 277 | SymbolTableManager.insert(lexim) 278 | return symbol_id 279 | 280 | 281 | def get_next_token(self): 282 | save_state = None 283 | error_occurred = False 284 | input_ended = False 285 | s = 0 # initial state 286 | 287 | if len(self.tokens.keys()) > self.max_state_size: 288 | self.tokens.pop(self.first_line, None) 289 | self.first_line += 1 290 | 291 | if len(self._lexical_errors) > self.max_state_size: 292 | self._lexical_errors.pop(0) 293 | 294 | while True: # Loop until we find valid token 295 | if not self.input or input_ended: 296 | try: 297 | self.read_input() 298 | except EOFError: 299 | if s in unclosed_comment_states: 300 | mucs = self.max_unclosed_comment_size 301 | err_token = self.input[:mucs] 302 | if len(self.input) > len(err_token): 303 | err_token = err_token + " ..." 304 | SymbolTableManager.error_flag = True 305 | self._lexical_errors.append((self.line_number, err_token, "unclosed comment")) 306 | self.line_number += self.input.count("\n") 307 | self.input = "" 308 | return ("EOF", "$") 309 | 310 | token_candidates = [] 311 | error_occurred = False 312 | input_ended = False 313 | 314 | s = 0 if save_state is None else save_state 315 | save_state = None 316 | 317 | # traverse the dfa as long as we can with the remaining input 318 | for i in range(len(self.input) + 1): 319 | try: 320 | a = self.input[i] 321 | except IndexError: 322 | a = self.input[-1] 323 | col = self._resolve_dfa_table_column(a) 324 | next_s = token_dfa[s][col] 325 | 326 | if s in state_to_error_message: # are we in an error state? 327 | if s == 22: 328 | i -= 1 # this is a lookahead error state (invalid comment) 329 | lexim, error = self.input[:i], state_to_error_message[s] 330 | if self.max_state_size > 0: 331 | SymbolTableManager.error_flag = True 332 | self._lexical_errors.append((self.line_number, lexim, error)) 333 | else: 334 | print(f"Lexical Error in line {self.line_number}: {error} '{lexim}'") 335 | self.input = self.input[i:] # skip invalid token (panic mode) 336 | error_occurred = True 337 | break 338 | 339 | if s in F: # are we in an accepting state? 340 | if s in Fstar: 341 | token_candidates.append((s, self.input[:i-1])) 342 | else: 343 | token_candidates.append((s, self.input[:i])) 344 | 345 | if next_s is None: # can we continue traversing dfa? 346 | break 347 | elif i >= len(self.input): # do we have enough input to do so? 348 | # this only occurs for large files or small chunk size 349 | if next_s not in F: 350 | save_state = next_s 351 | input_ended = True 352 | break 353 | 354 | s = next_s 355 | 356 | if error_occurred or input_ended: 357 | continue 358 | 359 | if token_candidates: 360 | max_token = token_candidates[-1] # pick maximal munch 361 | state, lexim = max_token 362 | self.input = self.input[len(lexim):] # advance in the input 363 | token = state_to_token[state] 364 | 365 | if token == "WHITESPACE" or token == "COMMENT": # these will not be returned 366 | self._switch_line(lexim.count("\n")) # update line number etc 367 | continue # proceed to next token 368 | 369 | if token == "ID_OR_KEYWORD": # distinguish between ids and keywords 370 | token = "KEYWORD" if lexim in self.keywords else "ID" 371 | 372 | if self.max_state_size > 0: 373 | self.tokens[self.line_number].append((token, lexim)) # save tokens later for printing 374 | 375 | if token == "ID": 376 | if lexim not in self.identifiers: 377 | self.identifiers.append(lexim) 378 | lexim = self.update_symbol_table(lexim) 379 | 380 | return (token, lexim) 381 | else: 382 | print(f"[Panic Mode] Dropping '{self.input[:1]}' from line {self.line_number}") 383 | self.input = self.input[1:] 384 | 385 | 386 | def main(input_path): 387 | import time 388 | scanner = Scanner(input_path) 389 | start = time.time() 390 | token = scanner.get_next_token() 391 | while token[0] != "EOF": 392 | token = scanner.get_next_token() 393 | stop = time.time() - start 394 | print(f"Scanning took {stop:.6f} s") 395 | scanner.save_symbol_table() 396 | scanner.save_lexical_errors() 397 | scanner.save_tokens() 398 | 399 | 400 | if __name__ == "__main__": 401 | SymbolTableManager.init() 402 | input_path = os.path.join(script_dir, "input/input_simple.c") 403 | main(input_path) -------------------------------------------------------------------------------- /modules/semantic_analyser.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Semantic Analyser module of the Simple C Compiler 3 | 4 | Author: Pasi Pyrrö 5 | Date: 16 March 2020 6 | ''' 7 | 8 | import os 9 | from scanner import SymbolTableManager 10 | from code_gen import MemoryManager 11 | 12 | script_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) 13 | 14 | class SemanticAnalyser(object): 15 | def __init__(self): 16 | 17 | # routines 18 | self.semantic_checks = { 19 | "#SA_INC_SCOPE" : self.inc_scope_routine, 20 | "#SA_DEC_SCOPE" : self.dec_scope_routine, 21 | 22 | "#SA_SAVE_MAIN" : self.save_main_routine, 23 | "#SA_MAIN_POP" : self.pop_main_routine, 24 | "#SA_MAIN_CHECK" : self.check_main_routine, 25 | 26 | "#SA_SAVE_TYPE" : self.save_type_routine, 27 | "#SA_ASSIGN_TYPE" : self.assign_type_routine, 28 | "#SA_ASSIGN_FUN_ROLE" : self.assign_fun_role_routine, 29 | "#SA_ASSIGN_VAR_ROLE" : self.assign_var_role_routine, 30 | "#SA_ASSIGN_PARAM_ROLE" : self.assign_param_role_routine, 31 | "#SA_ASSIGN_LENGTH" : self.assign_length_routine, 32 | "#SA_SAVE_PARAM" : self.save_param_routine, 33 | "#SA_ASSIGN_FUN_ATTRS" : self.assign_fun_attrs_routine, 34 | 35 | "#SA_CHECK_DECL" : self.check_declaration_routine, 36 | 37 | "#SA_SAVE_FUN" : self.save_fun_routine, 38 | "#SA_CHECK_ARGS" : self.check_args_routine, 39 | 40 | "#SA_PUSH_ARG_STACK" : self.push_arg_stack_routine, 41 | "#SA_SAVE_ARG" : self.save_arg_routine, 42 | "#SA_POP_ARG_STACK" : self.pop_arg_stack_routine, 43 | 44 | 45 | "#SA_PUSH_WHILE" : self.push_while_routine, 46 | "#SA_CHECK_WHILE" : self.check_while_routine, 47 | "#SA_POP_WHILE" : self.pop_while_routine, 48 | 49 | "#SA_PUSH_SWITCH" : self.push_switch_routine, 50 | "#SA_CHECK_BREAK" : self.check_break_routine, 51 | "#SA_POP_SWITCH" : self.pop_switch_routine, 52 | 53 | "#SA_SAVE_TYPE_CHECK" : self.save_type_check_routine, 54 | "#SA_INDEX_ARRAY" : self.index_array_routine, 55 | "#SA_INDEX_ARRAY_POP" : self.index_array_pop_routine, 56 | "#SA_TYPE_CHECK" : self.type_check_routine, 57 | } 58 | 59 | # associated stacks 60 | self.semantic_stacks = { 61 | "main_check" : [], 62 | "type_assign" : [], 63 | "type_check" : [], 64 | "fun_check" : [], 65 | } 66 | 67 | # flags 68 | self.main_found = False 69 | self.main_not_last = False 70 | 71 | # counters 72 | self.arity_counter = 0 73 | self.while_counter = 0 74 | self.switch_counter = 0 75 | 76 | # lists 77 | self.fun_param_list = [] 78 | self.fun_arg_list = [] 79 | self._semantic_errors = [] 80 | 81 | self.semantic_error_file = os.path.join(script_dir, "errors", "semantic_errors.txt") 82 | 83 | 84 | @property 85 | def scope(self): 86 | return len(SymbolTableManager.scope_stack) - 1 87 | 88 | 89 | @property 90 | def semantic_errors(self): 91 | semantic_errors = [] 92 | if self._semantic_errors: 93 | for lineno, error in self._semantic_errors: 94 | semantic_errors.append(f"#{lineno} : Semantic Error! {error}\n") 95 | else: 96 | semantic_errors.append("The input program is semantically correct.\n") 97 | return "".join(semantic_errors) 98 | 99 | 100 | def _get_lexim(self, token): 101 | if token[0] == "ID": 102 | return SymbolTableManager.symbol_table[token[1]]['lexim'] 103 | else: 104 | return token[1] 105 | 106 | 107 | def save_semantic_errors(self): 108 | with open(self.semantic_error_file, "w") as f: 109 | f.write(self.semantic_errors) 110 | 111 | 112 | ''' semantic routines start here ''' 113 | 114 | 115 | def inc_scope_routine(self, input_token, line_number): 116 | SymbolTableManager.scope_stack.append(len(SymbolTableManager.symbol_table)) 117 | 118 | 119 | def dec_scope_routine(self, input_token, line_number): 120 | scope_start_idx = SymbolTableManager.scope_stack.pop() 121 | SymbolTableManager.symbol_table = SymbolTableManager.symbol_table[:scope_start_idx] 122 | 123 | 124 | def save_main_routine(self, input_token, line_number): 125 | self.semantic_stacks["main_check"].append(self._get_lexim(input_token)) 126 | 127 | 128 | def pop_main_routine(self, input_token, line_number): 129 | self.semantic_stacks["main_check"] = self.semantic_stacks["main_check"][:-2] 130 | 131 | 132 | def save_type_routine(self, input_token, line_number): 133 | SymbolTableManager.declaration_flag = True 134 | self.semantic_stacks["type_assign"].append(input_token[1]) 135 | 136 | 137 | def assign_type_routine(self, input_token, line_number): 138 | if input_token[0] == "ID" and self.semantic_stacks["type_assign"]: 139 | symbol_idx = input_token[1] 140 | SymbolTableManager.symbol_table[symbol_idx]["type"] = self.semantic_stacks["type_assign"].pop() 141 | self.semantic_stacks["type_assign"].append(symbol_idx) 142 | SymbolTableManager.declaration_flag = False 143 | 144 | 145 | def assign_fun_role_routine(self, input_token, line_number): 146 | if self.semantic_stacks["type_assign"]: 147 | symbol_idx = self.semantic_stacks["type_assign"][-1] 148 | SymbolTableManager.symbol_table[symbol_idx]["role"] = "function" 149 | SymbolTableManager.symbol_table[symbol_idx]["address"] = MemoryManager.pb_index 150 | 151 | 152 | def assign_param_role_routine(self, input_token, line_number): 153 | self.assign_var_role_routine(input_token, line_number, "param") 154 | 155 | 156 | def assign_var_role_routine(self, input_token, line_number, role="local_var"): 157 | if self.semantic_stacks["type_assign"]: 158 | symbol_idx = self.semantic_stacks["type_assign"][-1] 159 | symbol_row = SymbolTableManager.symbol_table[symbol_idx] 160 | symbol_row["role"] = role 161 | if self.scope == 0: 162 | symbol_row["role"] = "global_var" 163 | if symbol_row["type"] == "void": 164 | SymbolTableManager.error_flag = True 165 | self._semantic_errors.append((line_number, "Illegal type of void for '{}'.".format(symbol_row["lexim"]))) 166 | symbol_row.pop("type") # void types are not considered to be defined 167 | if input_token[1] == "[": 168 | symbol_row["type"] = "array" 169 | 170 | 171 | def assign_length_routine(self, input_token, line_number): 172 | if self.semantic_stacks["type_assign"]: 173 | symbol_idx = self.semantic_stacks["type_assign"].pop() 174 | symbol_row = SymbolTableManager.symbol_table[symbol_idx] 175 | if input_token[0] == "NUM": 176 | symbol_row["arity"] = int(input_token[1]) 177 | if symbol_row["role"] == "param": 178 | symbol_row["offset"] = MemoryManager.get_param_offset() 179 | else: 180 | symbol_row["address"] = MemoryManager.get_static(int(input_token[1])) 181 | else: 182 | SymbolTableManager.symbol_table[symbol_idx]["arity"] = 1 183 | if symbol_row["role"] == "param": 184 | symbol_row["offset"] = MemoryManager.get_param_offset() 185 | else: 186 | symbol_row["address"] = MemoryManager.get_static() 187 | 188 | if input_token[1] == "[" and self.fun_param_list: 189 | self.fun_param_list[-1] = "array" 190 | 191 | 192 | def save_param_routine(self, input_token, line_number): 193 | self.fun_param_list.append(input_token[1]) 194 | 195 | 196 | def push_arg_stack_routine(self, input_token, line_number): 197 | SymbolTableManager.arg_list_stack.append([]) 198 | 199 | 200 | def pop_arg_stack_routine(self, input_token, line_number): 201 | if len(SymbolTableManager.arg_list_stack) > 1: 202 | SymbolTableManager.arg_list_stack.pop() 203 | 204 | 205 | def save_arg_routine(self, input_token, line_number): 206 | if input_token[0] == "ID": 207 | SymbolTableManager.arg_list_stack[-1].append(SymbolTableManager.symbol_table[input_token[1]].get("type")) 208 | else: 209 | SymbolTableManager.arg_list_stack[-1].append("int") 210 | 211 | 212 | def assign_fun_attrs_routine(self, input_token, line_number): 213 | if self.semantic_stacks["type_assign"]: 214 | symbol_idx = self.semantic_stacks["type_assign"].pop() 215 | params = self.fun_param_list 216 | SymbolTableManager.symbol_table[symbol_idx]["arity"] = len(params) 217 | SymbolTableManager.symbol_table[symbol_idx]["params"] = params 218 | self.fun_param_list = [] 219 | SymbolTableManager.temp_stack.append(0) # init temp counter for this function 220 | 221 | 222 | def check_main_routine(self, input_token, line_number): 223 | main_signature = ("void", "main", "void") 224 | try: 225 | top_three = tuple(self.semantic_stacks["main_check"][-3:]) 226 | self.semantic_stacks["main_check"] = self.semantic_stacks["main_check"][:-3] 227 | 228 | if not self.main_found: 229 | self.main_found = (top_three == main_signature and self.scope == 1) 230 | # check whether main is the last global function definition 231 | elif not self.main_not_last and self.main_found and self.scope == 1: 232 | self.main_not_last = True 233 | 234 | except IndexError: 235 | pass 236 | 237 | 238 | def check_declaration_routine(self, input_token, line_number): 239 | if "type" not in SymbolTableManager.symbol_table[input_token[1]]: 240 | lexim = self._get_lexim(input_token) 241 | SymbolTableManager.error_flag = True 242 | self._semantic_errors.append((line_number, f"'{lexim}' is not defined.")) 243 | 244 | 245 | def save_fun_routine(self, input_token, line_number): 246 | if SymbolTableManager.symbol_table[input_token[1]].get("role") == "function": 247 | self.semantic_stacks["fun_check"].append(input_token[1]) 248 | 249 | 250 | def check_args_routine(self, input_token, line_number): 251 | if self.semantic_stacks["fun_check"]: 252 | fun_id = self.semantic_stacks["fun_check"].pop() 253 | lexim = SymbolTableManager.symbol_table[fun_id]["lexim"] 254 | args = SymbolTableManager.arg_list_stack[-1] 255 | if args is not None: 256 | self.semantic_stacks["type_check"] = self.semantic_stacks["type_check"][:len(args)] 257 | if SymbolTableManager.symbol_table[fun_id]["arity"] != len(args): 258 | SymbolTableManager.error_flag = True 259 | self._semantic_errors.append((line_number, f"Mismatch in numbers of arguments of '{lexim}'.")) 260 | else: 261 | params = SymbolTableManager.symbol_table[fun_id]["params"] 262 | i = 1 263 | for param, arg in zip(params, args): 264 | if param != arg and arg is not None: 265 | SymbolTableManager.error_flag = True 266 | self._semantic_errors.append((line_number, f"Mismatch in type of argument {i} of '{lexim}'. Expected '{param}' but got '{arg}' instead.")) 267 | i += 1 268 | 269 | 270 | def push_while_routine(self, input_token, line_number): 271 | self.while_counter += 1 272 | 273 | 274 | def check_while_routine(self, input_token, line_number): 275 | if self.while_counter <= 0: 276 | SymbolTableManager.error_flag = True 277 | self._semantic_errors.append((line_number, f"No 'while' found for 'continue'")) 278 | 279 | 280 | def pop_while_routine(self, input_token, line_number): 281 | self.while_counter -= 1 282 | 283 | 284 | def push_switch_routine(self, input_token, line_number): 285 | self.switch_counter += 1 286 | 287 | 288 | def check_break_routine(self, input_token, line_number): 289 | if self.while_counter <= 0 and self.switch_counter <= 0: 290 | SymbolTableManager.error_flag = True 291 | self._semantic_errors.append((line_number, "No 'while' or 'switch' found for 'break'.")) 292 | 293 | 294 | def pop_switch_routine(self, input_token, line_number): 295 | self.switch_counter -= 1 296 | 297 | 298 | def save_type_check_routine(self, input_token, line_number): 299 | if input_token[0] == "ID": 300 | operand_type = SymbolTableManager.symbol_table[input_token[1]].get("type") 301 | else: 302 | operand_type = "int" 303 | self.semantic_stacks["type_check"].append(operand_type) 304 | 305 | 306 | def index_array_routine(self, input_token, line_number): 307 | if self.semantic_stacks["type_check"]: 308 | self.semantic_stacks["type_check"][-1] = "int" 309 | 310 | 311 | def index_array_pop_routine(self, input_token, line_number): 312 | if self.semantic_stacks["type_check"]: 313 | self.semantic_stacks["type_check"].pop() 314 | 315 | 316 | def type_check_routine(self, input_token, line_number): 317 | try: 318 | operand_b_type = self.semantic_stacks["type_check"].pop() 319 | operand_a_type = self.semantic_stacks["type_check"].pop() 320 | if operand_b_type is not None and operand_a_type is not None: 321 | if operand_a_type == "array": 322 | SymbolTableManager.error_flag = True 323 | self._semantic_errors.append((line_number, 324 | f"Type mismatch in operands, Got '{operand_a_type}' instead of 'int'.")) 325 | elif operand_a_type != operand_b_type: 326 | SymbolTableManager.error_flag = True 327 | self._semantic_errors.append((line_number, 328 | f"Type mismatch in operands, Got '{operand_b_type}' instead of '{operand_a_type}'.")) 329 | else: 330 | self.semantic_stacks["type_check"].append(operand_a_type) 331 | except IndexError: 332 | pass 333 | 334 | 335 | ''' semantic routines end here ''' 336 | 337 | 338 | def semantic_check(self, action_symbol, input_token, line_number): 339 | try: 340 | self.semantic_checks[action_symbol](input_token, line_number) 341 | except Exception as e: 342 | print(f"{line_number} : Error in semantic routine {action_symbol}:", str(e)) 343 | 344 | 345 | def eof_check(self, line_number): 346 | if not self.main_found or self.main_not_last: 347 | SymbolTableManager.error_flag = True 348 | self._semantic_errors.append((line_number, "main function not found!")) 349 | -------------------------------------------------------------------------------- /output/.gitignore: -------------------------------------------------------------------------------- 1 | # Ignore everything in this directory 2 | * 3 | # Except this file 4 | !.gitignore -------------------------------------------------------------------------------- /run_tests.py: -------------------------------------------------------------------------------- 1 | import os 2 | import sys 3 | 4 | script_dir = os.path.dirname(os.path.realpath(__file__)) 5 | sys.path.insert(0, os.path.join(script_dir, "modules")) 6 | 7 | import difflib 8 | import argparse 9 | import platform 10 | from subprocess import check_output, PIPE, TimeoutExpired 11 | from cparser import main as parse 12 | from scanner import main as scan 13 | 14 | ''' 15 | Expected folder structure for automatic testing 16 | 17 | project_root 18 | ├── input.txt 19 | ├── scanner.py 20 | ├── parser.py 21 | ├── run_tests.py 22 | └── tests 23 | ├── T1 24 | │ ├── input.txt 25 | │ ├── parse_tree.txt 26 | │ └── syntax_errors.txt 27 | ├── T2 28 | │ ├── input.txt 29 | │ ├── parse_tree.txt 30 | │ └── syntax_errors.txt 31 | 32 | . 33 | . 34 | . 35 | 36 | └── TN 37 | ├── input.txt 38 | ├── parse_tree.txt 39 | └── syntax_errors.txt 40 | ''' 41 | 42 | parser = argparse.ArgumentParser(description='Automatic test case runner for Compilers course exercises.') 43 | parser.add_argument('-v', '--verbose', action='store_true', help='Print difference info between actual and model output.') 44 | parser.add_argument('--from-test', type=int, default=0, help='Test number to start from') 45 | parser.add_argument('--to-test', type=int, default=None, help='Test number to stop to') 46 | args = parser.parse_args() 47 | 48 | test_dir = os.path.join(script_dir, "tests") 49 | 50 | passes = 0 51 | tests = 0 52 | i = 0 53 | 54 | def check_diff(test_case, test_file, model_answer, output): 55 | if model_answer != output: 56 | if args.verbose: 57 | diff = difflib.ndiff(model_answer.splitlines(keepends=True), 58 | output.splitlines(keepends=True)) 59 | print("".join(diff), end="") 60 | print("\n======") 61 | if test_file: 62 | print(f"{test_case}: {test_file} output differs from model output!") 63 | else: 64 | print(f"{test_case}: Tester output differs from model output!") 65 | print("------") 66 | return True 67 | return False 68 | 69 | 70 | for test_case in sorted(os.listdir(test_dir)): 71 | if args.to_test and i >= args.to_test: 72 | break 73 | if i < args.from_test - 1: 74 | i += 1 75 | continue 76 | test_case_dir = os.path.join(test_dir, test_case) 77 | output_dir = os.path.join(script_dir, "output") 78 | test_files = list(os.listdir(test_case_dir)) 79 | input_file = os.path.join(test_case_dir, test_files.pop(test_files.index("input.txt"))) 80 | 81 | try: 82 | if test_case.startswith("TS"): 83 | scan(input_file) 84 | else: 85 | parse(input_file) 86 | except Exception as e: 87 | # raise e 88 | print("Execution failed:", str(e)) 89 | fail = True 90 | else: 91 | fail = False 92 | 93 | if not fail: 94 | if test_case.startswith("TXX"): 95 | plat = platform.system() 96 | if plat == "Windows": 97 | tester_file = os.path.join(script_dir, "interpreter", "tester_Windows.exe") 98 | elif plat == "Linux": 99 | tester_file = os.path.join(script_dir, "interpreter", "tester_Linux.out") 100 | elif plat == "Darwin": 101 | tester_file = os.path.join(script_dir, "interpreter", "tester_Mac.out") 102 | else: 103 | raise RuntimeError("Unsupported operating system for code execution!") 104 | model_output_file = os.path.join(test_case_dir, "output.txt") 105 | output_file = os.path.join(script_dir, "output", "output.txt") 106 | if not os.path.exists(output_file): 107 | fail = True 108 | else: 109 | with open(model_output_file, "r", encoding="utf-8") as f: 110 | model_output = f.read() 111 | 112 | with open(output_file, "r", encoding="utf-8") as f: 113 | output = f.read() 114 | try: 115 | model_tester_output = check_output(tester_file, cwd=test_case_dir, stderr=PIPE, timeout=5).decode("utf-8") 116 | tester_output = check_output(tester_file, cwd=output_dir, stderr=PIPE, timeout=5).decode("utf-8") 117 | except TimeoutExpired: 118 | print(f"{test_case}: Tester program execution timed out!") 119 | fail = True 120 | else: 121 | model_tester_output = "\n".join([line for line in model_tester_output.splitlines() 122 | if line.startswith("PRINT")]) 123 | tester_output = "\n".join([line for line in tester_output.splitlines() 124 | if line.startswith("PRINT")]) 125 | 126 | fail = check_diff(test_case, None, model_tester_output.strip(), tester_output.strip()) 127 | else: 128 | for test_file in test_files: 129 | model_answer_file = os.path.join(test_case_dir, test_file) 130 | if "error" in test_file: 131 | output_file = os.path.join(script_dir, "errors", test_file) 132 | else: 133 | output_file = os.path.join(script_dir, "output", test_file) 134 | if not os.path.exists(output_file): 135 | open(output_file, "a").close() 136 | 137 | with open(model_answer_file, "r", encoding="utf-8") as f: 138 | model_answer = f.read().lower().strip() 139 | 140 | with open(output_file, "r", encoding="utf-8") as f: 141 | output = f.read().lower().strip() 142 | 143 | fail = fail or check_diff(test_case, test_file, model_answer, output) 144 | 145 | if fail: 146 | print(f"{test_case} failed!") 147 | else: 148 | print(f"{test_case} passed.") 149 | passes += 1 150 | 151 | tests += 1 152 | i += 1 153 | 154 | print("------") 155 | print(f"{passes}/{tests} test cases passed.") 156 | -------------------------------------------------------------------------------- /tests/T01/input.txt: -------------------------------------------------------------------------------- 1 | int count; 2 | int result[50]; 3 | 4 | 5 | int f(int a, int result[]) { 6 | count = count + 1; 7 | if(result[a - 1]){ 8 | return result[a - 1]; 9 | } else { 10 | if (a == 1) { 11 | result[a - 1] = 1; 12 | return 1; 13 | } else if (a == 2){ 14 | result[a - 1] = 1; 15 | return 1; 16 | } else { 17 | result[a - 1] = f(a - 2, result) + f(a - 1, result); 18 | return result[a - 1]; 19 | } 20 | } 21 | } 22 | 23 | void main(void) { 24 | int i; 25 | i = 0; 26 | while (i < 50) { 27 | result[i] = 0; 28 | i = i + 1; 29 | } 30 | count = 0; 31 | output(f(40, result)); 32 | output(count); 33 | } -------------------------------------------------------------------------------- /tests/T01/semantic_errors.txt: -------------------------------------------------------------------------------- 1 | The input program is semantically correct. 2 | -------------------------------------------------------------------------------- /tests/T02/input.txt: -------------------------------------------------------------------------------- 1 | int count; 2 | int result[50]; 3 | 4 | 5 | int f(int a, int result[]) { 6 | count = count + 1; 7 | if(result[a - 1]){ 8 | return result[a - 1]; 9 | } else { 10 | if (a == 1) { 11 | result[a - 1] = 1; 12 | return 1; 13 | } else if (a == 2){ 14 | result[a - 1] = 1; 15 | return 1; 16 | } else { 17 | result[a - 1] = f(a - 2, result) + f(a - 1, result); 18 | return result[a - 1]; 19 | } 20 | } 21 | } 22 | 23 | void man ( void ) { 24 | int i; 25 | i = 0; 26 | while (i < 50) { 27 | result[i] = 0; 28 | i = i + 1; 29 | } 30 | count = 0; 31 | output(f(40, result)); 32 | output(count); 33 | } -------------------------------------------------------------------------------- /tests/T02/semantic_errors.txt: -------------------------------------------------------------------------------- 1 | #33 : Semantic Error! main function not found! 2 | -------------------------------------------------------------------------------- /tests/T03/input.txt: -------------------------------------------------------------------------------- 1 | int cou; 2 | int result[50]; 3 | 4 | 5 | int f(int a, int result[]) { 6 | count = count + 1; 7 | if(result[a - 1]){ 8 | return result[a - 1]; 9 | } else { 10 | if (a == 1) { 11 | result[a - 1] = 1; 12 | return 1; 13 | } else if (a == 2){ 14 | result[a - 1] = 1; 15 | return 1; 16 | } else { 17 | result[a - 1] = f(a - 2, result) + f(a - 1, 50); 18 | return result[a - 1]; 19 | } 20 | } 21 | } 22 | 23 | void main(void) { 24 | int i; 25 | i = 0; 26 | while (i < 50) { 27 | result[i] = 0; 28 | i = i + result; 29 | } 30 | count = 0; 31 | output(f(40, result)); 32 | output(count); 33 | } -------------------------------------------------------------------------------- /tests/T03/semantic_errors.txt: -------------------------------------------------------------------------------- 1 | #6 : Semantic Error! 'count' is not defined. 2 | #6 : Semantic Error! 'count' is not defined. 3 | #17 : Semantic Error! Mismatch in type of argument 2 of 'f'. Expected 'array' but got 'int' instead. 4 | #28 : Semantic Error! Type mismatch in operands, Got 'array' instead of 'int'. 5 | #30 : Semantic Error! 'count' is not defined. 6 | #32 : Semantic Error! 'count' is not defined. 7 | -------------------------------------------------------------------------------- /tests/T04/input.txt: -------------------------------------------------------------------------------- 1 | int count; 2 | int result[50]; 3 | 4 | 5 | int f(int a, int result[]) { 6 | count = count + 1; 7 | if(result[a - 1]){ 8 | return result[a - 1]; 9 | } else { 10 | if (a == 1) { 11 | result[a - 1] = 1; 12 | return 1; 13 | } else if (a == 2){ 14 | result[a - 1] = 1; 15 | return 1; 16 | } else { 17 | result[a - 1] = f(a - 2, result) + f(a - 1, result); 18 | return result[a - 1]; 19 | } 20 | } 21 | } 22 | 23 | void main ( void ) { 24 | int i; 25 | void j; 26 | i = 0; 27 | break; 28 | while (i < 50) { 29 | result[i] = 0; 30 | i = i + 1; 31 | } 32 | count = 0; 33 | output(f(40)); 34 | output(count); 35 | } -------------------------------------------------------------------------------- /tests/T04/semantic_errors.txt: -------------------------------------------------------------------------------- 1 | #25 : Semantic Error! Illegal type of void for 'j'. 2 | #27 : Semantic Error! No 'while' or 'switch' found for 'break'. 3 | #33 : Semantic Error! Mismatch in numbers of arguments of 'f'. 4 | -------------------------------------------------------------------------------- /tests/T05/input.txt: -------------------------------------------------------------------------------- 1 | void f(int a, int result[]) { 2 | count = a; /* count not defined? */ 3 | } 4 | 5 | int count; 6 | int result[50]; 7 | 8 | int main ( void ) { 9 | int i; 10 | void a; 11 | i = result; /* type mismatch? */ 12 | count = f(i, result); /* function returns void */ 13 | f(i + a, i * result); /* what are the types of the arguments? */ 14 | if (a == f(i, result)) { /* void types match in comparison? */ 15 | continue; /* not inside while although properly nested */ 16 | } else { 17 | return 0;} 18 | } 19 | -------------------------------------------------------------------------------- /tests/T05/semantic_errors.txt: -------------------------------------------------------------------------------- 1 | #2 : Semantic Error! 'count' is not defined. 2 | #10 : Semantic Error! Illegal type of void for 'a'. 3 | #11 : Semantic Error! Type mismatch in operands, Got 'array' instead of 'int'. 4 | #12 : Semantic Error! Type mismatch in operands, Got 'void' instead of 'int'. 5 | #13 : Semantic Error! 'a' is not defined. 6 | #13 : Semantic Error! Type mismatch in operands, Got 'array' instead of 'int'. 7 | #13 : Semantic Error! Mismatch in type of argument 2 of 'f'. Expected 'array' but got 'int' instead. 8 | #14 : Semantic Error! 'a' is not defined. 9 | #15 : Semantic Error! No 'while' found for 'continue' 10 | #19 : Semantic Error! main function not found! 11 | -------------------------------------------------------------------------------- /tests/T06/input.txt: -------------------------------------------------------------------------------- 1 | /*sample 6*/ 2 | void main(void{ 3 | int prod; 4 | int i; 5 | prod = 1; 6 | i = 1; 7 | } 8 | -------------------------------------------------------------------------------- /tests/T06/parse_tree.txt: -------------------------------------------------------------------------------- 1 | Program 2 | └── Declaration-list 3 | └── Declaration 4 | ├── Declaration-initial 5 | │ ├── Type-specifier 6 | │ │ └── (KEYWORD, void) 7 | │ └── (ID, main) 8 | └── Declaration-prime 9 | └── Fun-declaration-prime 10 | ├── (SYMBOL, () 11 | └── Params 12 | ├── (KEYWORD, void) 13 | └── Param-list-void-abtar 14 | └── (ID, prod) 15 | -------------------------------------------------------------------------------- /tests/T06/syntax_errors.txt: -------------------------------------------------------------------------------- 1 | #2 : Syntax Error! Illegal "{" 2 | #3 : Syntax Error! Illegal "int" 3 | #3 : Syntax Error! Illegal ";" 4 | #4 : Syntax Error! Illegal "int" 5 | #4 : Syntax Error! Illegal "ID" 6 | #4 : Syntax Error! Illegal ";" 7 | #5 : Syntax Error! Illegal "ID" 8 | #5 : Syntax Error! Illegal "=" 9 | #5 : Syntax Error! Illegal "NUM" 10 | #5 : Syntax Error! Illegal ";" 11 | #6 : Syntax Error! Illegal "ID" 12 | #6 : Syntax Error! Illegal "=" 13 | #6 : Syntax Error! Illegal "NUM" 14 | #6 : Syntax Error! Illegal ";" 15 | #7 : Syntax Error! Illegal "}" 16 | #8 : Syntax Error! Unexpected EndOfFile 17 | -------------------------------------------------------------------------------- /tests/T07/input.txt: -------------------------------------------------------------------------------- 1 | /*sample 5*/ 2 | int f(int a){ 3 | return a * a; 4 | } 5 | void main(void){ 6 | int a; 7 | int b; 8 | b =1; 9 | if (b < 5) { 10 | a = f(b); 11 | } 12 | else{ 13 | a = 4; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /tests/T07/parse_tree.txt: -------------------------------------------------------------------------------- 1 | Program 2 | └── Declaration-list 3 | ├── Declaration 4 | │ ├── Declaration-initial 5 | │ │ ├── Type-specifier 6 | │ │ │ └── (KEYWORD, int) 7 | │ │ └── (ID, f) 8 | │ └── Declaration-prime 9 | │ └── Fun-declaration-prime 10 | │ ├── (SYMBOL, () 11 | │ ├── Params 12 | │ │ ├── (KEYWORD, int) 13 | │ │ ├── (ID, a) 14 | │ │ ├── Param-prime 15 | │ │ │ └── epsilon 16 | │ │ └── Param-list 17 | │ │ └── epsilon 18 | │ ├── (SYMBOL, )) 19 | │ └── Compound-stmt 20 | │ ├── (SYMBOL, {) 21 | │ ├── Declaration-list 22 | │ │ └── epsilon 23 | │ ├── Statement-list 24 | │ │ ├── Statement 25 | │ │ │ └── Return-stmt 26 | │ │ │ ├── (KEYWORD, return) 27 | │ │ │ └── Return-stmt-prime 28 | │ │ │ ├── Expression 29 | │ │ │ │ ├── (ID, a) 30 | │ │ │ │ └── B 31 | │ │ │ │ └── Simple-expression-prime 32 | │ │ │ │ ├── Additive-expression-prime 33 | │ │ │ │ │ ├── Term-prime 34 | │ │ │ │ │ │ ├── Factor-prime 35 | │ │ │ │ │ │ │ └── epsilon 36 | │ │ │ │ │ │ └── G 37 | │ │ │ │ │ │ ├── (SYMBOL, *) 38 | │ │ │ │ │ │ ├── Factor 39 | │ │ │ │ │ │ │ ├── (ID, a) 40 | │ │ │ │ │ │ │ └── Var-call-prime 41 | │ │ │ │ │ │ │ └── Var-prime 42 | │ │ │ │ │ │ │ └── epsilon 43 | │ │ │ │ │ │ └── G 44 | │ │ │ │ │ │ └── epsilon 45 | │ │ │ │ │ └── D 46 | │ │ │ │ │ └── epsilon 47 | │ │ │ │ └── C 48 | │ │ │ │ └── epsilon 49 | │ │ │ └── (SYMBOL, ;) 50 | │ │ └── Statement-list 51 | │ │ └── epsilon 52 | │ └── (SYMBOL, }) 53 | └── Declaration-list 54 | ├── Declaration 55 | │ ├── Declaration-initial 56 | │ │ ├── Type-specifier 57 | │ │ │ └── (KEYWORD, void) 58 | │ │ └── (ID, main) 59 | │ └── Declaration-prime 60 | │ └── Fun-declaration-prime 61 | │ ├── (SYMBOL, () 62 | │ ├── Params 63 | │ │ ├── (KEYWORD, void) 64 | │ │ └── Param-list-void-abtar 65 | │ │ └── epsilon 66 | │ ├── (SYMBOL, )) 67 | │ └── Compound-stmt 68 | │ ├── (SYMBOL, {) 69 | │ ├── Declaration-list 70 | │ │ ├── Declaration 71 | │ │ │ ├── Declaration-initial 72 | │ │ │ │ ├── Type-specifier 73 | │ │ │ │ │ └── (KEYWORD, int) 74 | │ │ │ │ └── (ID, a) 75 | │ │ │ └── Declaration-prime 76 | │ │ │ └── Var-declaration-prime 77 | │ │ │ └── (SYMBOL, ;) 78 | │ │ └── Declaration-list 79 | │ │ ├── Declaration 80 | │ │ │ ├── Declaration-initial 81 | │ │ │ │ ├── Type-specifier 82 | │ │ │ │ │ └── (KEYWORD, int) 83 | │ │ │ │ └── (ID, b) 84 | │ │ │ └── Declaration-prime 85 | │ │ │ └── Var-declaration-prime 86 | │ │ │ └── (SYMBOL, ;) 87 | │ │ └── Declaration-list 88 | │ │ └── epsilon 89 | │ ├── Statement-list 90 | │ │ ├── Statement 91 | │ │ │ └── Expression-stmt 92 | │ │ │ ├── Expression 93 | │ │ │ │ ├── (ID, b) 94 | │ │ │ │ └── B 95 | │ │ │ │ ├── (SYMBOL, =) 96 | │ │ │ │ └── Expression 97 | │ │ │ │ └── Simple-expression-zegond 98 | │ │ │ │ ├── Additive-expression-zegond 99 | │ │ │ │ │ ├── Term-zegond 100 | │ │ │ │ │ │ ├── Factor-zegond 101 | │ │ │ │ │ │ │ └── (NUM, 1) 102 | │ │ │ │ │ │ └── G 103 | │ │ │ │ │ │ └── epsilon 104 | │ │ │ │ │ └── D 105 | │ │ │ │ │ └── epsilon 106 | │ │ │ │ └── C 107 | │ │ │ │ └── epsilon 108 | │ │ │ └── (SYMBOL, ;) 109 | │ │ └── Statement-list 110 | │ │ ├── Statement 111 | │ │ │ └── Selection-stmt 112 | │ │ │ ├── (KEYWORD, if) 113 | │ │ │ ├── (SYMBOL, () 114 | │ │ │ ├── Expression 115 | │ │ │ │ ├── (ID, b) 116 | │ │ │ │ └── B 117 | │ │ │ │ └── Simple-expression-prime 118 | │ │ │ │ ├── Additive-expression-prime 119 | │ │ │ │ │ ├── Term-prime 120 | │ │ │ │ │ │ ├── Factor-prime 121 | │ │ │ │ │ │ │ └── epsilon 122 | │ │ │ │ │ │ └── G 123 | │ │ │ │ │ │ └── epsilon 124 | │ │ │ │ │ └── D 125 | │ │ │ │ │ └── epsilon 126 | │ │ │ │ └── C 127 | │ │ │ │ ├── Relop 128 | │ │ │ │ │ └── (SYMBOL, <) 129 | │ │ │ │ └── Additive-expression 130 | │ │ │ │ ├── Term 131 | │ │ │ │ │ ├── Factor 132 | │ │ │ │ │ │ └── (NUM, 5) 133 | │ │ │ │ │ └── G 134 | │ │ │ │ │ └── epsilon 135 | │ │ │ │ └── D 136 | │ │ │ │ └── epsilon 137 | │ │ │ ├── (SYMBOL, )) 138 | │ │ │ ├── Statement 139 | │ │ │ │ └── Compound-stmt 140 | │ │ │ │ ├── (SYMBOL, {) 141 | │ │ │ │ ├── Declaration-list 142 | │ │ │ │ │ └── epsilon 143 | │ │ │ │ ├── Statement-list 144 | │ │ │ │ │ ├── Statement 145 | │ │ │ │ │ │ └── Expression-stmt 146 | │ │ │ │ │ │ ├── Expression 147 | │ │ │ │ │ │ │ ├── (ID, a) 148 | │ │ │ │ │ │ │ └── B 149 | │ │ │ │ │ │ │ ├── (SYMBOL, =) 150 | │ │ │ │ │ │ │ └── Expression 151 | │ │ │ │ │ │ │ ├── (ID, f) 152 | │ │ │ │ │ │ │ └── B 153 | │ │ │ │ │ │ │ └── Simple-expression-prime 154 | │ │ │ │ │ │ │ ├── Additive-expression-prime 155 | │ │ │ │ │ │ │ │ ├── Term-prime 156 | │ │ │ │ │ │ │ │ │ ├── Factor-prime 157 | │ │ │ │ │ │ │ │ │ │ ├── (SYMBOL, () 158 | │ │ │ │ │ │ │ │ │ │ ├── Args 159 | │ │ │ │ │ │ │ │ │ │ │ └── Arg-list 160 | │ │ │ │ │ │ │ │ │ │ │ ├── Expression 161 | │ │ │ │ │ │ │ │ │ │ │ │ ├── (ID, b) 162 | │ │ │ │ │ │ │ │ │ │ │ │ └── B 163 | │ │ │ │ │ │ │ │ │ │ │ │ └── Simple-expression-prime 164 | │ │ │ │ │ │ │ │ │ │ │ │ ├── Additive-expression-prime 165 | │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Term-prime 166 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Factor-prime 167 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 168 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── G 169 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 170 | │ │ │ │ │ │ │ │ │ │ │ │ │ └── D 171 | │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 172 | │ │ │ │ │ │ │ │ │ │ │ │ └── C 173 | │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 174 | │ │ │ │ │ │ │ │ │ │ │ └── Arg-list-prime 175 | │ │ │ │ │ │ │ │ │ │ │ └── epsilon 176 | │ │ │ │ │ │ │ │ │ │ └── (SYMBOL, )) 177 | │ │ │ │ │ │ │ │ │ └── G 178 | │ │ │ │ │ │ │ │ │ └── epsilon 179 | │ │ │ │ │ │ │ │ └── D 180 | │ │ │ │ │ │ │ │ └── epsilon 181 | │ │ │ │ │ │ │ └── C 182 | │ │ │ │ │ │ │ └── epsilon 183 | │ │ │ │ │ │ └── (SYMBOL, ;) 184 | │ │ │ │ │ └── Statement-list 185 | │ │ │ │ │ └── epsilon 186 | │ │ │ │ └── (SYMBOL, }) 187 | │ │ │ ├── (KEYWORD, else) 188 | │ │ │ └── Statement 189 | │ │ │ └── Compound-stmt 190 | │ │ │ ├── (SYMBOL, {) 191 | │ │ │ ├── Declaration-list 192 | │ │ │ │ └── epsilon 193 | │ │ │ ├── Statement-list 194 | │ │ │ │ ├── Statement 195 | │ │ │ │ │ └── Expression-stmt 196 | │ │ │ │ │ ├── Expression 197 | │ │ │ │ │ │ ├── (ID, a) 198 | │ │ │ │ │ │ └── B 199 | │ │ │ │ │ │ ├── (SYMBOL, =) 200 | │ │ │ │ │ │ └── Expression 201 | │ │ │ │ │ │ └── Simple-expression-zegond 202 | │ │ │ │ │ │ ├── Additive-expression-zegond 203 | │ │ │ │ │ │ │ ├── Term-zegond 204 | │ │ │ │ │ │ │ │ ├── Factor-zegond 205 | │ │ │ │ │ │ │ │ │ └── (NUM, 4) 206 | │ │ │ │ │ │ │ │ └── G 207 | │ │ │ │ │ │ │ │ └── epsilon 208 | │ │ │ │ │ │ │ └── D 209 | │ │ │ │ │ │ │ └── epsilon 210 | │ │ │ │ │ │ └── C 211 | │ │ │ │ │ │ └── epsilon 212 | │ │ │ │ │ └── (SYMBOL, ;) 213 | │ │ │ │ └── Statement-list 214 | │ │ │ │ └── epsilon 215 | │ │ │ └── (SYMBOL, }) 216 | │ │ └── Statement-list 217 | │ │ └── epsilon 218 | │ └── (SYMBOL, }) 219 | └── Declaration-list 220 | └── epsilon 221 | -------------------------------------------------------------------------------- /tests/T07/syntax_errors.txt: -------------------------------------------------------------------------------- 1 | There is no syntax error. 2 | -------------------------------------------------------------------------------- /tests/T08/input.txt: -------------------------------------------------------------------------------- 1 | /*sample 4*/ 2 | void main(){ 3 | int a; 4 | int b; 5 | a = b + 1; 6 | } 7 | -------------------------------------------------------------------------------- /tests/T08/parse_tree.txt: -------------------------------------------------------------------------------- 1 | Program 2 | └── Declaration-list 3 | ├── Declaration 4 | │ ├── Declaration-initial 5 | │ │ ├── Type-specifier 6 | │ │ │ └── (KEYWORD, void) 7 | │ │ └── (ID, main) 8 | │ └── Declaration-prime 9 | │ └── Fun-declaration-prime 10 | │ ├── (SYMBOL, () 11 | │ ├── (SYMBOL, )) 12 | │ └── Compound-stmt 13 | │ ├── (SYMBOL, {) 14 | │ ├── Declaration-list 15 | │ │ ├── Declaration 16 | │ │ │ ├── Declaration-initial 17 | │ │ │ │ ├── Type-specifier 18 | │ │ │ │ │ └── (KEYWORD, int) 19 | │ │ │ │ └── (ID, a) 20 | │ │ │ └── Declaration-prime 21 | │ │ │ └── Var-declaration-prime 22 | │ │ │ └── (SYMBOL, ;) 23 | │ │ └── Declaration-list 24 | │ │ ├── Declaration 25 | │ │ │ ├── Declaration-initial 26 | │ │ │ │ ├── Type-specifier 27 | │ │ │ │ │ └── (KEYWORD, int) 28 | │ │ │ │ └── (ID, b) 29 | │ │ │ └── Declaration-prime 30 | │ │ │ └── Var-declaration-prime 31 | │ │ │ └── (SYMBOL, ;) 32 | │ │ └── Declaration-list 33 | │ │ └── epsilon 34 | │ ├── Statement-list 35 | │ │ ├── Statement 36 | │ │ │ └── Expression-stmt 37 | │ │ │ ├── Expression 38 | │ │ │ │ ├── (ID, a) 39 | │ │ │ │ └── B 40 | │ │ │ │ ├── (SYMBOL, =) 41 | │ │ │ │ └── Expression 42 | │ │ │ │ ├── (ID, b) 43 | │ │ │ │ └── B 44 | │ │ │ │ └── Simple-expression-prime 45 | │ │ │ │ ├── Additive-expression-prime 46 | │ │ │ │ │ ├── Term-prime 47 | │ │ │ │ │ │ ├── Factor-prime 48 | │ │ │ │ │ │ │ └── epsilon 49 | │ │ │ │ │ │ └── G 50 | │ │ │ │ │ │ └── epsilon 51 | │ │ │ │ │ └── D 52 | │ │ │ │ │ ├── Addop 53 | │ │ │ │ │ │ └── (SYMBOL, +) 54 | │ │ │ │ │ ├── Term 55 | │ │ │ │ │ │ ├── Factor 56 | │ │ │ │ │ │ │ └── (NUM, 1) 57 | │ │ │ │ │ │ └── G 58 | │ │ │ │ │ │ └── epsilon 59 | │ │ │ │ │ └── D 60 | │ │ │ │ │ └── epsilon 61 | │ │ │ │ └── C 62 | │ │ │ │ └── epsilon 63 | │ │ │ └── (SYMBOL, ;) 64 | │ │ └── Statement-list 65 | │ │ └── epsilon 66 | │ └── (SYMBOL, }) 67 | └── Declaration-list 68 | └── epsilon 69 | -------------------------------------------------------------------------------- /tests/T08/syntax_errors.txt: -------------------------------------------------------------------------------- 1 | #2 : Syntax Error! Missing "void" 2 | -------------------------------------------------------------------------------- /tests/T09/input.txt: -------------------------------------------------------------------------------- 1 | /*sample 3*/ 2 | void main (void) { 3 | int a; 4 | int b; 5 | b = 1; 6 | a = 2; 7 | switch (a){ 8 | case 2: 9 | b = b + 1; 10 | case 3: 11 | b = b + 2; 12 | return; 13 | case 4: 14 | { 15 | a = 5; 16 | b = a * 123; 17 | break;} 18 | default: 19 | b = b - 1; 20 | } 21 | return; 22 | } 23 | -------------------------------------------------------------------------------- /tests/T09/syntax_errors.txt: -------------------------------------------------------------------------------- 1 | There is no syntax error. 2 | -------------------------------------------------------------------------------- /tests/T10/input.txt: -------------------------------------------------------------------------------- 1 | /*sample 2*/ 2 | void main(void){ 3 | int prod; 4 | int i; 5 | prod = 1; 6 | i = 1; 7 | while(i < 7){ 8 | prod = i * prod ; 9 | i = i + 2; 10 | } 11 | output(prod); 12 | return; 13 | 14 | } 15 | -------------------------------------------------------------------------------- /tests/T10/parse_tree.txt: -------------------------------------------------------------------------------- 1 | Program 2 | └── Declaration-list 3 | ├── Declaration 4 | │ ├── Declaration-initial 5 | │ │ ├── Type-specifier 6 | │ │ │ └── (KEYWORD, void) 7 | │ │ └── (ID, main) 8 | │ └── Declaration-prime 9 | │ └── Fun-declaration-prime 10 | │ ├── (SYMBOL, () 11 | │ ├── Params 12 | │ │ ├── (KEYWORD, void) 13 | │ │ └── Param-list-void-abtar 14 | │ │ └── epsilon 15 | │ ├── (SYMBOL, )) 16 | │ └── Compound-stmt 17 | │ ├── (SYMBOL, {) 18 | │ ├── Declaration-list 19 | │ │ ├── Declaration 20 | │ │ │ ├── Declaration-initial 21 | │ │ │ │ ├── Type-specifier 22 | │ │ │ │ │ └── (KEYWORD, int) 23 | │ │ │ │ └── (ID, prod) 24 | │ │ │ └── Declaration-prime 25 | │ │ │ └── Var-declaration-prime 26 | │ │ │ └── (SYMBOL, ;) 27 | │ │ └── Declaration-list 28 | │ │ ├── Declaration 29 | │ │ │ ├── Declaration-initial 30 | │ │ │ │ ├── Type-specifier 31 | │ │ │ │ │ └── (KEYWORD, int) 32 | │ │ │ │ └── (ID, i) 33 | │ │ │ └── Declaration-prime 34 | │ │ │ └── Var-declaration-prime 35 | │ │ │ └── (SYMBOL, ;) 36 | │ │ └── Declaration-list 37 | │ │ └── epsilon 38 | │ ├── Statement-list 39 | │ │ ├── Statement 40 | │ │ │ └── Expression-stmt 41 | │ │ │ ├── Expression 42 | │ │ │ │ ├── (ID, prod) 43 | │ │ │ │ └── B 44 | │ │ │ │ ├── (SYMBOL, =) 45 | │ │ │ │ └── Expression 46 | │ │ │ │ └── Simple-expression-zegond 47 | │ │ │ │ ├── Additive-expression-zegond 48 | │ │ │ │ │ ├── Term-zegond 49 | │ │ │ │ │ │ ├── Factor-zegond 50 | │ │ │ │ │ │ │ └── (NUM, 1) 51 | │ │ │ │ │ │ └── G 52 | │ │ │ │ │ │ └── epsilon 53 | │ │ │ │ │ └── D 54 | │ │ │ │ │ └── epsilon 55 | │ │ │ │ └── C 56 | │ │ │ │ └── epsilon 57 | │ │ │ └── (SYMBOL, ;) 58 | │ │ └── Statement-list 59 | │ │ ├── Statement 60 | │ │ │ └── Expression-stmt 61 | │ │ │ ├── Expression 62 | │ │ │ │ ├── (ID, i) 63 | │ │ │ │ └── B 64 | │ │ │ │ ├── (SYMBOL, =) 65 | │ │ │ │ └── Expression 66 | │ │ │ │ └── Simple-expression-zegond 67 | │ │ │ │ ├── Additive-expression-zegond 68 | │ │ │ │ │ ├── Term-zegond 69 | │ │ │ │ │ │ ├── Factor-zegond 70 | │ │ │ │ │ │ │ └── (NUM, 1) 71 | │ │ │ │ │ │ └── G 72 | │ │ │ │ │ │ └── epsilon 73 | │ │ │ │ │ └── D 74 | │ │ │ │ │ └── epsilon 75 | │ │ │ │ └── C 76 | │ │ │ │ └── epsilon 77 | │ │ │ └── (SYMBOL, ;) 78 | │ │ └── Statement-list 79 | │ │ ├── Statement 80 | │ │ │ └── Iteration-stmt 81 | │ │ │ ├── (KEYWORD, while) 82 | │ │ │ ├── (SYMBOL, () 83 | │ │ │ ├── Expression 84 | │ │ │ │ ├── (ID, i) 85 | │ │ │ │ └── B 86 | │ │ │ │ └── Simple-expression-prime 87 | │ │ │ │ ├── Additive-expression-prime 88 | │ │ │ │ │ ├── Term-prime 89 | │ │ │ │ │ │ ├── Factor-prime 90 | │ │ │ │ │ │ │ └── epsilon 91 | │ │ │ │ │ │ └── G 92 | │ │ │ │ │ │ └── epsilon 93 | │ │ │ │ │ └── D 94 | │ │ │ │ │ └── epsilon 95 | │ │ │ │ └── C 96 | │ │ │ │ ├── Relop 97 | │ │ │ │ │ └── (SYMBOL, <) 98 | │ │ │ │ └── Additive-expression 99 | │ │ │ │ ├── Term 100 | │ │ │ │ │ ├── Factor 101 | │ │ │ │ │ │ └── (NUM, 7) 102 | │ │ │ │ │ └── G 103 | │ │ │ │ │ └── epsilon 104 | │ │ │ │ └── D 105 | │ │ │ │ └── epsilon 106 | │ │ │ ├── (SYMBOL, )) 107 | │ │ │ └── Statement 108 | │ │ │ └── Compound-stmt 109 | │ │ │ ├── (SYMBOL, {) 110 | │ │ │ ├── Declaration-list 111 | │ │ │ │ └── epsilon 112 | │ │ │ ├── Statement-list 113 | │ │ │ │ ├── Statement 114 | │ │ │ │ │ └── Expression-stmt 115 | │ │ │ │ │ ├── Expression 116 | │ │ │ │ │ │ ├── (ID, prod) 117 | │ │ │ │ │ │ └── B 118 | │ │ │ │ │ │ ├── (SYMBOL, =) 119 | │ │ │ │ │ │ └── Expression 120 | │ │ │ │ │ │ ├── (ID, i) 121 | │ │ │ │ │ │ └── B 122 | │ │ │ │ │ │ └── Simple-expression-prime 123 | │ │ │ │ │ │ ├── Additive-expression-prime 124 | │ │ │ │ │ │ │ ├── Term-prime 125 | │ │ │ │ │ │ │ │ ├── Factor-prime 126 | │ │ │ │ │ │ │ │ │ └── epsilon 127 | │ │ │ │ │ │ │ │ └── G 128 | │ │ │ │ │ │ │ │ ├── (SYMBOL, *) 129 | │ │ │ │ │ │ │ │ ├── Factor 130 | │ │ │ │ │ │ │ │ │ ├── (ID, prod) 131 | │ │ │ │ │ │ │ │ │ └── Var-call-prime 132 | │ │ │ │ │ │ │ │ │ └── Var-prime 133 | │ │ │ │ │ │ │ │ │ └── epsilon 134 | │ │ │ │ │ │ │ │ └── G 135 | │ │ │ │ │ │ │ │ └── epsilon 136 | │ │ │ │ │ │ │ └── D 137 | │ │ │ │ │ │ │ └── epsilon 138 | │ │ │ │ │ │ └── C 139 | │ │ │ │ │ │ └── epsilon 140 | │ │ │ │ │ └── (SYMBOL, ;) 141 | │ │ │ │ └── Statement-list 142 | │ │ │ │ ├── Statement 143 | │ │ │ │ │ └── Expression-stmt 144 | │ │ │ │ │ ├── Expression 145 | │ │ │ │ │ │ ├── (ID, i) 146 | │ │ │ │ │ │ └── B 147 | │ │ │ │ │ │ ├── (SYMBOL, =) 148 | │ │ │ │ │ │ └── Expression 149 | │ │ │ │ │ │ ├── (ID, i) 150 | │ │ │ │ │ │ └── B 151 | │ │ │ │ │ │ └── Simple-expression-prime 152 | │ │ │ │ │ │ ├── Additive-expression-prime 153 | │ │ │ │ │ │ │ ├── Term-prime 154 | │ │ │ │ │ │ │ │ ├── Factor-prime 155 | │ │ │ │ │ │ │ │ │ └── epsilon 156 | │ │ │ │ │ │ │ │ └── G 157 | │ │ │ │ │ │ │ │ └── epsilon 158 | │ │ │ │ │ │ │ └── D 159 | │ │ │ │ │ │ │ ├── Addop 160 | │ │ │ │ │ │ │ │ └── (SYMBOL, +) 161 | │ │ │ │ │ │ │ ├── Term 162 | │ │ │ │ │ │ │ │ ├── Factor 163 | │ │ │ │ │ │ │ │ │ └── (NUM, 2) 164 | │ │ │ │ │ │ │ │ └── G 165 | │ │ │ │ │ │ │ │ └── epsilon 166 | │ │ │ │ │ │ │ └── D 167 | │ │ │ │ │ │ │ └── epsilon 168 | │ │ │ │ │ │ └── C 169 | │ │ │ │ │ │ └── epsilon 170 | │ │ │ │ │ └── (SYMBOL, ;) 171 | │ │ │ │ └── Statement-list 172 | │ │ │ │ └── epsilon 173 | │ │ │ └── (SYMBOL, }) 174 | │ │ └── Statement-list 175 | │ │ ├── Statement 176 | │ │ │ └── Expression-stmt 177 | │ │ │ ├── Expression 178 | │ │ │ │ ├── (ID, output) 179 | │ │ │ │ └── B 180 | │ │ │ │ └── Simple-expression-prime 181 | │ │ │ │ ├── Additive-expression-prime 182 | │ │ │ │ │ ├── Term-prime 183 | │ │ │ │ │ │ ├── Factor-prime 184 | │ │ │ │ │ │ │ ├── (SYMBOL, () 185 | │ │ │ │ │ │ │ ├── Args 186 | │ │ │ │ │ │ │ │ └── Arg-list 187 | │ │ │ │ │ │ │ │ ├── Expression 188 | │ │ │ │ │ │ │ │ │ ├── (ID, prod) 189 | │ │ │ │ │ │ │ │ │ └── B 190 | │ │ │ │ │ │ │ │ │ └── Simple-expression-prime 191 | │ │ │ │ │ │ │ │ │ ├── Additive-expression-prime 192 | │ │ │ │ │ │ │ │ │ │ ├── Term-prime 193 | │ │ │ │ │ │ │ │ │ │ │ ├── Factor-prime 194 | │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 195 | │ │ │ │ │ │ │ │ │ │ │ └── G 196 | │ │ │ │ │ │ │ │ │ │ │ └── epsilon 197 | │ │ │ │ │ │ │ │ │ │ └── D 198 | │ │ │ │ │ │ │ │ │ │ └── epsilon 199 | │ │ │ │ │ │ │ │ │ └── C 200 | │ │ │ │ │ │ │ │ │ └── epsilon 201 | │ │ │ │ │ │ │ │ └── Arg-list-prime 202 | │ │ │ │ │ │ │ │ └── epsilon 203 | │ │ │ │ │ │ │ └── (SYMBOL, )) 204 | │ │ │ │ │ │ └── G 205 | │ │ │ │ │ │ └── epsilon 206 | │ │ │ │ │ └── D 207 | │ │ │ │ │ └── epsilon 208 | │ │ │ │ └── C 209 | │ │ │ │ └── epsilon 210 | │ │ │ └── (SYMBOL, ;) 211 | │ │ └── Statement-list 212 | │ │ ├── Statement 213 | │ │ │ └── Return-stmt 214 | │ │ │ ├── (KEYWORD, return) 215 | │ │ │ └── Return-stmt-prime 216 | │ │ │ └── (SYMBOL, ;) 217 | │ │ └── Statement-list 218 | │ │ └── epsilon 219 | │ └── (SYMBOL, }) 220 | └── Declaration-list 221 | └── epsilon 222 | -------------------------------------------------------------------------------- /tests/T10/syntax_errors.txt: -------------------------------------------------------------------------------- 1 | There is no syntax error. 2 | -------------------------------------------------------------------------------- /tests/T11/input.txt: -------------------------------------------------------------------------------- 1 | /* sample 1 */ 2 | void main(void){ 3 | int a; 4 | int b; 5 | a = b + 1; 6 | } 7 | -------------------------------------------------------------------------------- /tests/T11/parse_tree.txt: -------------------------------------------------------------------------------- 1 | Program 2 | └── Declaration-list 3 | ├── Declaration 4 | │ ├── Declaration-initial 5 | │ │ ├── Type-specifier 6 | │ │ │ └── (KEYWORD, void) 7 | │ │ └── (ID, main) 8 | │ └── Declaration-prime 9 | │ └── Fun-declaration-prime 10 | │ ├── (SYMBOL, () 11 | │ ├── Params 12 | │ │ ├── (KEYWORD, void) 13 | │ │ └── Param-list-void-abtar 14 | │ │ └── epsilon 15 | │ ├── (SYMBOL, )) 16 | │ └── Compound-stmt 17 | │ ├── (SYMBOL, {) 18 | │ ├── Declaration-list 19 | │ │ ├── Declaration 20 | │ │ │ ├── Declaration-initial 21 | │ │ │ │ ├── Type-specifier 22 | │ │ │ │ │ └── (KEYWORD, int) 23 | │ │ │ │ └── (ID, a) 24 | │ │ │ └── Declaration-prime 25 | │ │ │ └── Var-declaration-prime 26 | │ │ │ └── (SYMBOL, ;) 27 | │ │ └── Declaration-list 28 | │ │ ├── Declaration 29 | │ │ │ ├── Declaration-initial 30 | │ │ │ │ ├── Type-specifier 31 | │ │ │ │ │ └── (KEYWORD, int) 32 | │ │ │ │ └── (ID, b) 33 | │ │ │ └── Declaration-prime 34 | │ │ │ └── Var-declaration-prime 35 | │ │ │ └── (SYMBOL, ;) 36 | │ │ └── Declaration-list 37 | │ │ └── epsilon 38 | │ ├── Statement-list 39 | │ │ ├── Statement 40 | │ │ │ └── Expression-stmt 41 | │ │ │ ├── Expression 42 | │ │ │ │ ├── (ID, a) 43 | │ │ │ │ └── B 44 | │ │ │ │ ├── (SYMBOL, =) 45 | │ │ │ │ └── Expression 46 | │ │ │ │ ├── (ID, b) 47 | │ │ │ │ └── B 48 | │ │ │ │ └── Simple-expression-prime 49 | │ │ │ │ ├── Additive-expression-prime 50 | │ │ │ │ │ ├── Term-prime 51 | │ │ │ │ │ │ ├── Factor-prime 52 | │ │ │ │ │ │ │ └── epsilon 53 | │ │ │ │ │ │ └── G 54 | │ │ │ │ │ │ └── epsilon 55 | │ │ │ │ │ └── D 56 | │ │ │ │ │ ├── Addop 57 | │ │ │ │ │ │ └── (SYMBOL, +) 58 | │ │ │ │ │ ├── Term 59 | │ │ │ │ │ │ ├── Factor 60 | │ │ │ │ │ │ │ └── (NUM, 1) 61 | │ │ │ │ │ │ └── G 62 | │ │ │ │ │ │ └── epsilon 63 | │ │ │ │ │ └── D 64 | │ │ │ │ │ └── epsilon 65 | │ │ │ │ └── C 66 | │ │ │ │ └── epsilon 67 | │ │ │ └── (SYMBOL, ;) 68 | │ │ └── Statement-list 69 | │ │ └── epsilon 70 | │ └── (SYMBOL, }) 71 | └── Declaration-list 72 | └── epsilon 73 | -------------------------------------------------------------------------------- /tests/T11/syntax_errors.txt: -------------------------------------------------------------------------------- 1 | There is no syntax error. 2 | -------------------------------------------------------------------------------- /tests/T12/input.txt: -------------------------------------------------------------------------------- 1 | int f(int a){ 2 | return a * a * a; 3 | } 4 | void main(void){ 5 | int a; 6 | int b; 7 | a = 8; 8 | if (b < 5) { 9 | a = f(a); 10 | } 11 | else{ 12 | a = 4; 13 | } 14 | 15 | continue; 16 | } -------------------------------------------------------------------------------- /tests/T12/lexical_errors.txt: -------------------------------------------------------------------------------- 1 | There is no lexical errors. -------------------------------------------------------------------------------- /tests/T12/symbol_table.txt: -------------------------------------------------------------------------------- 1 | 1. if 2 | 2. else 3 | 3. void 4 | 4. int 5 | 5. while 6 | 6. break 7 | 7. continue 8 | 8. switch 9 | 9. default 10 | 10. case 11 | 11. return 12 | 12. f 13 | 13. a 14 | 14. main 15 | 15. b 16 | -------------------------------------------------------------------------------- /tests/T12/tokens.txt: -------------------------------------------------------------------------------- 1 | 1. (KEYWORD, int) (ID, f) (SYMBOL, () (KEYWORD, int) (ID, a) (SYMBOL, )) (SYMBOL, {) 2 | 2. (KEYWORD, return) (ID, a) (SYMBOL, *) (ID, a) (SYMBOL, *) (ID, a) (SYMBOL, ;) 3 | 3. (SYMBOL, }) 4 | 4. (KEYWORD, void) (ID, main) (SYMBOL, () (KEYWORD, void) (SYMBOL, )) (SYMBOL, {) 5 | 5. (KEYWORD, int) (ID, a) (SYMBOL, ;) 6 | 6. (KEYWORD, int) (ID, b) (SYMBOL, ;) 7 | 7. (ID, a) (SYMBOL, =) (NUM, 8) (SYMBOL, ;) 8 | 8. (KEYWORD, if) (SYMBOL, () (ID, b) (SYMBOL, <) (NUM, 5) (SYMBOL, )) (SYMBOL, {) 9 | 9. (ID, a) (SYMBOL, =) (ID, f) (SYMBOL, () (ID, a) (SYMBOL, )) (SYMBOL, ;) 10 | 10. (SYMBOL, }) 11 | 11. (KEYWORD, else) (SYMBOL, {) 12 | 12. (ID, a) (SYMBOL, =) (NUM, 4) (SYMBOL, ;) 13 | 13. (SYMBOL, }) 14 | 15. (KEYWORD, continue) (SYMBOL, ;) 15 | 16. (SYMBOL, }) 16 | -------------------------------------------------------------------------------- /tests/T13/input.txt: -------------------------------------------------------------------------------- 1 | /* test case */ 2 | void main(void){ 3 | int prod; 4 | int i; 5 | prod = 1; 6 | i = 1; 7 | while(i < 7){ 8 | prod = i * prod ; 9 | i = i + 2; 10 | } 11 | output(prod); 12 | return; 13 | 14 | } 15 | -------------------------------------------------------------------------------- /tests/T13/lexical_errors.txt: -------------------------------------------------------------------------------- 1 | There is no lexical errors. -------------------------------------------------------------------------------- /tests/T13/symbol_table.txt: -------------------------------------------------------------------------------- 1 | 1. if 2 | 2. else 3 | 3. void 4 | 4. int 5 | 5. while 6 | 6. break 7 | 7. continue 8 | 8. switch 9 | 9. default 10 | 10. case 11 | 11. return 12 | 12. main 13 | 13. prod 14 | 14. i 15 | 15. output 16 | -------------------------------------------------------------------------------- /tests/T13/tokens.txt: -------------------------------------------------------------------------------- 1 | 2. (KEYWORD, void) (ID, main) (SYMBOL, () (KEYWORD, void) (SYMBOL, )) (SYMBOL, {) 2 | 3. (KEYWORD, int) (ID, prod) (SYMBOL, ;) 3 | 4. (KEYWORD, int) (ID, i) (SYMBOL, ;) 4 | 5. (ID, prod) (SYMBOL, =) (NUM, 1) (SYMBOL, ;) 5 | 6. (ID, i) (SYMBOL, =) (NUM, 1) (SYMBOL, ;) 6 | 7. (KEYWORD, while) (SYMBOL, () (ID, i) (SYMBOL, <) (NUM, 7) (SYMBOL, )) (SYMBOL, {) 7 | 8. (ID, prod) (SYMBOL, =) (ID, i) (SYMBOL, *) (ID, prod) (SYMBOL, ;) 8 | 9. (ID, i) (SYMBOL, =) (ID, i) (SYMBOL, +) (NUM, 2) (SYMBOL, ;) 9 | 10. (SYMBOL, }) 10 | 11. (ID, output) (SYMBOL, () (ID, prod) (SYMBOL, )) (SYMBOL, ;) 11 | 12. (KEYWORD, return) (SYMBOL, ;) 12 | 14. (SYMBOL, }) 13 | -------------------------------------------------------------------------------- /tests/TS14/input.txt: -------------------------------------------------------------------------------- 1 | vod min(voi){ 2 | switch (arr[2xefg]){ 3 | case 2abcd: 4 | b = b + 1; 5 | case 3: 6 | b = b + 2; 7 | return; 8 | case 4: 9 | { 10 | #x = 5; 11 | b = u * 123; 12 | break;} 13 | default: 14 | b = b - 1; 15 | } 16 | return; 17 | } 18 | -------------------------------------------------------------------------------- /tests/TS14/lexical_errors.txt: -------------------------------------------------------------------------------- 1 | #2 : Lexical Error! '2x' rejected, reason: illegal number. 2 | #3 : Lexical Error! '2a' rejected, reason: illegal number. 3 | #10 : Lexical Error! '#' rejected, reason: invalid input. 4 | -------------------------------------------------------------------------------- /tests/TS14/symbol_table.txt: -------------------------------------------------------------------------------- 1 | 1. if 2 | 2. else 3 | 3. void 4 | 4. int 5 | 5. while 6 | 6. break 7 | 7. continue 8 | 8. switch 9 | 9. default 10 | 10. case 11 | 11. return 12 | 12. vod 13 | 13. min 14 | 14. voi 15 | 15. arr 16 | 16. efg 17 | 17. bcd 18 | 18. b 19 | 19. x 20 | 20. u 21 | -------------------------------------------------------------------------------- /tests/TS14/tokens.txt: -------------------------------------------------------------------------------- 1 | 1. (ID, vod) (ID, min) (SYMBOL, () (ID, voi) (SYMBOL, )) (SYMBOL, {) 2 | 2. (KEYWORD, switch) (SYMBOL, () (ID, arr) (SYMBOL, [) (ID, efg) (SYMBOL, ]) (SYMBOL, )) (SYMBOL, {) 3 | 3. (KEYWORD, case) (ID, bcd) (SYMBOL, :) 4 | 4. (ID, b) (SYMBOL, =) (ID, b) (SYMBOL, +) (NUM, 1) (SYMBOL, ;) 5 | 5. (KEYWORD, case) (NUM, 3) (SYMBOL, :) 6 | 6. (ID, b) (SYMBOL, =) (ID, b) (SYMBOL, +) (NUM, 2) (SYMBOL, ;) 7 | 7. (KEYWORD, return) (SYMBOL, ;) 8 | 8. (KEYWORD, case) (NUM, 4) (SYMBOL, :) 9 | 9. (SYMBOL, {) 10 | 10. (ID, x) (SYMBOL, =) (NUM, 5) (SYMBOL, ;) 11 | 11. (ID, b) (SYMBOL, =) (ID, u) (SYMBOL, *) (NUM, 123) (SYMBOL, ;) 12 | 12. (KEYWORD, break) (SYMBOL, ;) (SYMBOL, }) 13 | 13. (KEYWORD, default) (SYMBOL, :) 14 | 14. (ID, b) (SYMBOL, =) (ID, b) (SYMBOL, -) (NUM, 1) (SYMBOL, ;) 15 | 15. (SYMBOL, }) 16 | 16. (KEYWORD, return) (SYMBOL, ;) 17 | 17. (SYMBOL, }) 18 | -------------------------------------------------------------------------------- /tests/TS15/input.txt: -------------------------------------------------------------------------------- 1 | void min(void){ 2 | switch (arr[g]){ 3 | case 2: 4 | b = b + 1; */ 5 | case 3: 6 | b = b + 2; 7 | return; 8 | case 4: 9 | { 10 | x = 5; 11 | b = u * 123; 12 | break;} 13 | default:/*this is wrong * 14 | b = b - 1; 15 | } 16 | return; 17 | } 18 | -------------------------------------------------------------------------------- /tests/TS15/lexical_errors.txt: -------------------------------------------------------------------------------- 1 | #4 : Lexical Error! '*/' rejected, reason: Unmatched */. 2 | #13 : Lexical Error! '/*this is wrong ...' rejected, reason: unclosed comment. 3 | -------------------------------------------------------------------------------- /tests/TS15/symbol_table.txt: -------------------------------------------------------------------------------- 1 | 1. if 2 | 2. else 3 | 3. void 4 | 4. int 5 | 5. while 6 | 6. break 7 | 7. continue 8 | 8. switch 9 | 9. default 10 | 10. case 11 | 11. return 12 | 12. min 13 | 13. arr 14 | 14. g 15 | 15. b 16 | 16. x 17 | 17. u 18 | -------------------------------------------------------------------------------- /tests/TS15/tokens.txt: -------------------------------------------------------------------------------- 1 | 1. (KEYWORD, void) (ID, min) (SYMBOL, () (KEYWORD, void) (SYMBOL, )) (SYMBOL, {) 2 | 2. (KEYWORD, switch) (SYMBOL, () (ID, arr) (SYMBOL, [) (ID, g) (SYMBOL, ]) (SYMBOL, )) (SYMBOL, {) 3 | 3. (KEYWORD, case) (NUM, 2) (SYMBOL, :) 4 | 4. (ID, b) (SYMBOL, =) (ID, b) (SYMBOL, +) (NUM, 1) (SYMBOL, ;) 5 | 5. (KEYWORD, case) (NUM, 3) (SYMBOL, :) 6 | 6. (ID, b) (SYMBOL, =) (ID, b) (SYMBOL, +) (NUM, 2) (SYMBOL, ;) 7 | 7. (KEYWORD, return) (SYMBOL, ;) 8 | 8. (KEYWORD, case) (NUM, 4) (SYMBOL, :) 9 | 9. (SYMBOL, {) 10 | 10. (ID, x) (SYMBOL, =) (NUM, 5) (SYMBOL, ;) 11 | 11. (ID, b) (SYMBOL, =) (ID, u) (SYMBOL, *) (NUM, 123) (SYMBOL, ;) 12 | 12. (KEYWORD, break) (SYMBOL, ;) (SYMBOL, }) 13 | 13. (KEYWORD, default) (SYMBOL, :) 14 | -------------------------------------------------------------------------------- /tests/TS16/input.txt: -------------------------------------------------------------------------------- 1 | void (main) void { 2 | int a = 0; 3 | // comment1 4 | a = 2 + 2; 5 | a = a - 3; 6 | cde = a; 7 | if (b /* comment2 */ == 3) { 8 | a = 3; 9 | cd!e = 7; 10 | } 11 | else 12 | { 13 | b = a < cde; 14 | {cde = @2; 15 | }} 16 | return; 17 | } 18 | -------------------------------------------------------------------------------- /tests/TS16/lexical_errors.txt: -------------------------------------------------------------------------------- 1 | #9 : Lexical Error! 'cd!' rejected, reason: invalid input. 2 | #14 : Lexical Error! '@' rejected, reason: invalid input. 3 | -------------------------------------------------------------------------------- /tests/TS16/symbol_table.txt: -------------------------------------------------------------------------------- 1 | 1. if 2 | 2. else 3 | 3. void 4 | 4. int 5 | 5. while 6 | 6. break 7 | 7. continue 8 | 8. switch 9 | 9. default 10 | 10. case 11 | 11. return 12 | 12. main 13 | 13. a 14 | 14. cde 15 | 15. b 16 | 16. e 17 | -------------------------------------------------------------------------------- /tests/TS16/tokens.txt: -------------------------------------------------------------------------------- 1 | 1. (KEYWORD, void) (SYMBOL, () (ID, main) (SYMBOL, )) (KEYWORD, void) (SYMBOL, {) 2 | 2. (KEYWORD, int) (ID, a) (SYMBOL, =) (NUM, 0) (SYMBOL, ;) 3 | 4. (ID, a) (SYMBOL, =) (NUM, 2) (SYMBOL, +) (NUM, 2) (SYMBOL, ;) 4 | 5. (ID, a) (SYMBOL, =) (ID, a) (SYMBOL, -) (NUM, 3) (SYMBOL, ;) 5 | 6. (ID, cde) (SYMBOL, =) (ID, a) (SYMBOL, ;) 6 | 7. (KEYWORD, if) (SYMBOL, () (ID, b) (SYMBOL, ==) (NUM, 3) (SYMBOL, )) (SYMBOL, {) 7 | 8. (ID, a) (SYMBOL, =) (NUM, 3) (SYMBOL, ;) 8 | 9. (ID, e) (SYMBOL, =) (NUM, 7) (SYMBOL, ;) 9 | 10. (SYMBOL, }) 10 | 11. (KEYWORD, else) 11 | 12. (SYMBOL, {) 12 | 13. (ID, b) (SYMBOL, =) (ID, a) (SYMBOL, <) (ID, cde) (SYMBOL, ;) 13 | 14. (SYMBOL, {) (ID, cde) (SYMBOL, =) (NUM, 2) (SYMBOL, ;) 14 | 15. (SYMBOL, }) (SYMBOL, }) 15 | 16. (KEYWORD, return) (SYMBOL, ;) 16 | 17. (SYMBOL, }) 17 | -------------------------------------------------------------------------------- /tests/TS17/input.txt: -------------------------------------------------------------------------------- 1 | int b; 2 | int foo(int d, int e){ 3 | int f; 4 | f = foo(d); 5 | b = e + f; 6 | whi$le(d < 0){ 7 | f = f + d; 8 | d = d - 1; 9 | if (d == 5) 10 | break; 11 | else d = 1dst; 12 | } 13 | //comment1 14 | return f + b; 15 | } 16 | int arr[3]; 17 | void main(void){ 18 | int a; 19 | a = 3 + 11; 20 | b = 5 * a + foo(a, a); 21 | arr[1] = b + 3; 22 | arr[2] = foo(arr[0], arr[1]); 23 | if (b /*comment2*/ == 3){ 24 | arr[0] = 7; 25 | } 26 | else 27 | { 28 | switch (arr[2]){ 29 | case 2: 30 | b = b + 1; 31 | case 3: 32 | b = b + 2; 33 | return; 34 | case : 35 | { 36 | u = 5; 37 | b = u * 123; 38 | break;} 39 | default: 40 | b = b - 1; 41 | } 42 | } 43 | return; 44 | } 45 | -------------------------------------------------------------------------------- /tests/TS17/lexical_errors.txt: -------------------------------------------------------------------------------- 1 | #6 : Lexical Error! 'whi$' rejected, reason: invalid input. 2 | #11 : Lexical Error! '1d' rejected, reason: illegal number. 3 | -------------------------------------------------------------------------------- /tests/TS17/symbol_table.txt: -------------------------------------------------------------------------------- 1 | 1. if 2 | 2. else 3 | 3. void 4 | 4. int 5 | 5. while 6 | 6. break 7 | 7. continue 8 | 8. switch 9 | 9. default 10 | 10. case 11 | 11. return 12 | 12. b 13 | 13. foo 14 | 14. d 15 | 15. e 16 | 16. f 17 | 17. le 18 | 18. st 19 | 19. arr 20 | 20. main 21 | 21. a 22 | 22. u 23 | -------------------------------------------------------------------------------- /tests/TS17/tokens.txt: -------------------------------------------------------------------------------- 1 | 1. (KEYWORD, int) (ID, b) (SYMBOL, ;) 2 | 2. (KEYWORD, int) (ID, foo) (SYMBOL, () (KEYWORD, int) (ID, d) (SYMBOL, ,) (KEYWORD, int) (ID, e) (SYMBOL, )) (SYMBOL, {) 3 | 3. (KEYWORD, int) (ID, f) (SYMBOL, ;) 4 | 4. (ID, f) (SYMBOL, =) (ID, foo) (SYMBOL, () (ID, d) (SYMBOL, )) (SYMBOL, ;) 5 | 5. (ID, b) (SYMBOL, =) (ID, e) (SYMBOL, +) (ID, f) (SYMBOL, ;) 6 | 6. (ID, le) (SYMBOL, () (ID, d) (SYMBOL, <) (NUM, 0) (SYMBOL, )) (SYMBOL, {) 7 | 7. (ID, f) (SYMBOL, =) (ID, f) (SYMBOL, +) (ID, d) (SYMBOL, ;) 8 | 8. (ID, d) (SYMBOL, =) (ID, d) (SYMBOL, -) (NUM, 1) (SYMBOL, ;) 9 | 9. (KEYWORD, if) (SYMBOL, () (ID, d) (SYMBOL, ==) (NUM, 5) (SYMBOL, )) 10 | 10. (KEYWORD, break) (SYMBOL, ;) 11 | 11. (KEYWORD, else) (ID, d) (SYMBOL, =) (ID, st) (SYMBOL, ;) 12 | 12. (SYMBOL, }) 13 | 14. (KEYWORD, return) (ID, f) (SYMBOL, +) (ID, b) (SYMBOL, ;) 14 | 15. (SYMBOL, }) 15 | 16. (KEYWORD, int) (ID, arr) (SYMBOL, [) (NUM, 3) (SYMBOL, ]) (SYMBOL, ;) 16 | 17. (KEYWORD, void) (ID, main) (SYMBOL, () (KEYWORD, void) (SYMBOL, )) (SYMBOL, {) 17 | 18. (KEYWORD, int) (ID, a) (SYMBOL, ;) 18 | 19. (ID, a) (SYMBOL, =) (NUM, 3) (SYMBOL, +) (NUM, 11) (SYMBOL, ;) 19 | 20. (ID, b) (SYMBOL, =) (NUM, 5) (SYMBOL, *) (ID, a) (SYMBOL, +) (ID, foo) (SYMBOL, () (ID, a) (SYMBOL, ,) (ID, a) (SYMBOL, )) (SYMBOL, ;) 20 | 21. (ID, arr) (SYMBOL, [) (NUM, 1) (SYMBOL, ]) (SYMBOL, =) (ID, b) (SYMBOL, +) (NUM, 3) (SYMBOL, ;) 21 | 22. (ID, arr) (SYMBOL, [) (NUM, 2) (SYMBOL, ]) (SYMBOL, =) (ID, foo) (SYMBOL, () (ID, arr) (SYMBOL, [) (NUM, 0) (SYMBOL, ]) (SYMBOL, ,) (ID, arr) (SYMBOL, [) (NUM, 1) (SYMBOL, ]) (SYMBOL, )) (SYMBOL, ;) 22 | 23. (KEYWORD, if) (SYMBOL, () (ID, b) (SYMBOL, ==) (NUM, 3) (SYMBOL, )) (SYMBOL, {) 23 | 24. (ID, arr) (SYMBOL, [) (NUM, 0) (SYMBOL, ]) (SYMBOL, =) (NUM, 7) (SYMBOL, ;) 24 | 25. (SYMBOL, }) 25 | 26. (KEYWORD, else) 26 | 27. (SYMBOL, {) 27 | 28. (KEYWORD, switch) (SYMBOL, () (ID, arr) (SYMBOL, [) (NUM, 2) (SYMBOL, ]) (SYMBOL, )) (SYMBOL, {) 28 | 29. (KEYWORD, case) (NUM, 2) (SYMBOL, :) 29 | 30. (ID, b) (SYMBOL, =) (ID, b) (SYMBOL, +) (NUM, 1) (SYMBOL, ;) 30 | 31. (KEYWORD, case) (NUM, 3) (SYMBOL, :) 31 | 32. (ID, b) (SYMBOL, =) (ID, b) (SYMBOL, +) (NUM, 2) (SYMBOL, ;) 32 | 33. (KEYWORD, return) (SYMBOL, ;) 33 | 34. (KEYWORD, case) (SYMBOL, :) 34 | 35. (SYMBOL, {) 35 | 36. (ID, u) (SYMBOL, =) (NUM, 5) (SYMBOL, ;) 36 | 37. (ID, b) (SYMBOL, =) (ID, u) (SYMBOL, *) (NUM, 123) (SYMBOL, ;) 37 | 38. (KEYWORD, break) (SYMBOL, ;) (SYMBOL, }) 38 | 39. (KEYWORD, default) (SYMBOL, :) 39 | 40. (ID, b) (SYMBOL, =) (ID, b) (SYMBOL, -) (NUM, 1) (SYMBOL, ;) 40 | 41. (SYMBOL, }) 41 | 42. (SYMBOL, }) 42 | 43. (KEYWORD, return) (SYMBOL, ;) 43 | 44. (SYMBOL, }) 44 | -------------------------------------------------------------------------------- /tests/TX18/input.txt: -------------------------------------------------------------------------------- 1 | /* test case 2*/ 2 | void main(void){ 3 | int a; 4 | int b; 5 | a = 10 * 2 + 3 * (1 < 0); 6 | b = (a == 5) * 4 + 3; 7 | output(a); 8 | output(b); 9 | } 10 | -------------------------------------------------------------------------------- /tests/TX18/parse_tree.txt: -------------------------------------------------------------------------------- 1 | Program 2 | └── Declaration-list 3 | ├── Declaration 4 | │ ├── Declaration-initial 5 | │ │ ├── Type-specifier 6 | │ │ │ └── (KEYWORD, void) 7 | │ │ └── (ID, main) 8 | │ └── Declaration-prime 9 | │ └── Fun-declaration-prime 10 | │ ├── (SYMBOL, () 11 | │ ├── Params 12 | │ │ ├── (KEYWORD, void) 13 | │ │ └── Param-list-void-abtar 14 | │ │ └── epsilon 15 | │ ├── (SYMBOL, )) 16 | │ └── Compound-stmt 17 | │ ├── (SYMBOL, {) 18 | │ ├── Declaration-list 19 | │ │ ├── Declaration 20 | │ │ │ ├── Declaration-initial 21 | │ │ │ │ ├── Type-specifier 22 | │ │ │ │ │ └── (KEYWORD, int) 23 | │ │ │ │ └── (ID, a) 24 | │ │ │ └── Declaration-prime 25 | │ │ │ └── Var-declaration-prime 26 | │ │ │ └── (SYMBOL, ;) 27 | │ │ └── Declaration-list 28 | │ │ ├── Declaration 29 | │ │ │ ├── Declaration-initial 30 | │ │ │ │ ├── Type-specifier 31 | │ │ │ │ │ └── (KEYWORD, int) 32 | │ │ │ │ └── (ID, b) 33 | │ │ │ └── Declaration-prime 34 | │ │ │ └── Var-declaration-prime 35 | │ │ │ └── (SYMBOL, ;) 36 | │ │ └── Declaration-list 37 | │ │ └── epsilon 38 | │ ├── Statement-list 39 | │ │ ├── Statement 40 | │ │ │ └── Expression-stmt 41 | │ │ │ ├── Expression 42 | │ │ │ │ ├── (ID, a) 43 | │ │ │ │ └── B 44 | │ │ │ │ ├── (SYMBOL, =) 45 | │ │ │ │ └── Expression 46 | │ │ │ │ └── Simple-expression-zegond 47 | │ │ │ │ ├── Additive-expression-zegond 48 | │ │ │ │ │ ├── Term-zegond 49 | │ │ │ │ │ │ ├── Factor-zegond 50 | │ │ │ │ │ │ │ └── (NUM, 10) 51 | │ │ │ │ │ │ └── G 52 | │ │ │ │ │ │ ├── (SYMBOL, *) 53 | │ │ │ │ │ │ ├── Factor 54 | │ │ │ │ │ │ │ └── (NUM, 2) 55 | │ │ │ │ │ │ └── G 56 | │ │ │ │ │ │ └── epsilon 57 | │ │ │ │ │ └── D 58 | │ │ │ │ │ ├── Addop 59 | │ │ │ │ │ │ └── (SYMBOL, +) 60 | │ │ │ │ │ ├── Term 61 | │ │ │ │ │ │ ├── Factor 62 | │ │ │ │ │ │ │ └── (NUM, 3) 63 | │ │ │ │ │ │ └── G 64 | │ │ │ │ │ │ ├── (SYMBOL, *) 65 | │ │ │ │ │ │ ├── Factor 66 | │ │ │ │ │ │ │ ├── (SYMBOL, () 67 | │ │ │ │ │ │ │ ├── Expression 68 | │ │ │ │ │ │ │ │ └── Simple-expression-zegond 69 | │ │ │ │ │ │ │ │ ├── Additive-expression-zegond 70 | │ │ │ │ │ │ │ │ │ ├── Term-zegond 71 | │ │ │ │ │ │ │ │ │ │ ├── Factor-zegond 72 | │ │ │ │ │ │ │ │ │ │ │ └── (NUM, 1) 73 | │ │ │ │ │ │ │ │ │ │ └── G 74 | │ │ │ │ │ │ │ │ │ │ └── epsilon 75 | │ │ │ │ │ │ │ │ │ └── D 76 | │ │ │ │ │ │ │ │ │ └── epsilon 77 | │ │ │ │ │ │ │ │ └── C 78 | │ │ │ │ │ │ │ │ ├── Relop 79 | │ │ │ │ │ │ │ │ │ └── (SYMBOL, <) 80 | │ │ │ │ │ │ │ │ └── Additive-expression 81 | │ │ │ │ │ │ │ │ ├── Term 82 | │ │ │ │ │ │ │ │ │ ├── Factor 83 | │ │ │ │ │ │ │ │ │ │ └── (NUM, 0) 84 | │ │ │ │ │ │ │ │ │ └── G 85 | │ │ │ │ │ │ │ │ │ └── epsilon 86 | │ │ │ │ │ │ │ │ └── D 87 | │ │ │ │ │ │ │ │ └── epsilon 88 | │ │ │ │ │ │ │ └── (SYMBOL, )) 89 | │ │ │ │ │ │ └── G 90 | │ │ │ │ │ │ └── epsilon 91 | │ │ │ │ │ └── D 92 | │ │ │ │ │ └── epsilon 93 | │ │ │ │ └── C 94 | │ │ │ │ └── epsilon 95 | │ │ │ └── (SYMBOL, ;) 96 | │ │ └── Statement-list 97 | │ │ ├── Statement 98 | │ │ │ └── Expression-stmt 99 | │ │ │ ├── Expression 100 | │ │ │ │ ├── (ID, b) 101 | │ │ │ │ └── B 102 | │ │ │ │ ├── (SYMBOL, =) 103 | │ │ │ │ └── Expression 104 | │ │ │ │ └── Simple-expression-zegond 105 | │ │ │ │ ├── Additive-expression-zegond 106 | │ │ │ │ │ ├── Term-zegond 107 | │ │ │ │ │ │ ├── Factor-zegond 108 | │ │ │ │ │ │ │ ├── (SYMBOL, () 109 | │ │ │ │ │ │ │ ├── Expression 110 | │ │ │ │ │ │ │ │ ├── (ID, a) 111 | │ │ │ │ │ │ │ │ └── B 112 | │ │ │ │ │ │ │ │ └── Simple-expression-prime 113 | │ │ │ │ │ │ │ │ ├── Additive-expression-prime 114 | │ │ │ │ │ │ │ │ │ ├── Term-prime 115 | │ │ │ │ │ │ │ │ │ │ ├── Factor-prime 116 | │ │ │ │ │ │ │ │ │ │ │ └── epsilon 117 | │ │ │ │ │ │ │ │ │ │ └── G 118 | │ │ │ │ │ │ │ │ │ │ └── epsilon 119 | │ │ │ │ │ │ │ │ │ └── D 120 | │ │ │ │ │ │ │ │ │ └── epsilon 121 | │ │ │ │ │ │ │ │ └── C 122 | │ │ │ │ │ │ │ │ ├── Relop 123 | │ │ │ │ │ │ │ │ │ └── (SYMBOL, ==) 124 | │ │ │ │ │ │ │ │ └── Additive-expression 125 | │ │ │ │ │ │ │ │ ├── Term 126 | │ │ │ │ │ │ │ │ │ ├── Factor 127 | │ │ │ │ │ │ │ │ │ │ └── (NUM, 5) 128 | │ │ │ │ │ │ │ │ │ └── G 129 | │ │ │ │ │ │ │ │ │ └── epsilon 130 | │ │ │ │ │ │ │ │ └── D 131 | │ │ │ │ │ │ │ │ └── epsilon 132 | │ │ │ │ │ │ │ └── (SYMBOL, )) 133 | │ │ │ │ │ │ └── G 134 | │ │ │ │ │ │ ├── (SYMBOL, *) 135 | │ │ │ │ │ │ ├── Factor 136 | │ │ │ │ │ │ │ └── (NUM, 4) 137 | │ │ │ │ │ │ └── G 138 | │ │ │ │ │ │ └── epsilon 139 | │ │ │ │ │ └── D 140 | │ │ │ │ │ ├── Addop 141 | │ │ │ │ │ │ └── (SYMBOL, +) 142 | │ │ │ │ │ ├── Term 143 | │ │ │ │ │ │ ├── Factor 144 | │ │ │ │ │ │ │ └── (NUM, 3) 145 | │ │ │ │ │ │ └── G 146 | │ │ │ │ │ │ └── epsilon 147 | │ │ │ │ │ └── D 148 | │ │ │ │ │ └── epsilon 149 | │ │ │ │ └── C 150 | │ │ │ │ └── epsilon 151 | │ │ │ └── (SYMBOL, ;) 152 | │ │ └── Statement-list 153 | │ │ ├── Statement 154 | │ │ │ └── Expression-stmt 155 | │ │ │ ├── Expression 156 | │ │ │ │ ├── (ID, output) 157 | │ │ │ │ └── B 158 | │ │ │ │ └── Simple-expression-prime 159 | │ │ │ │ ├── Additive-expression-prime 160 | │ │ │ │ │ ├── Term-prime 161 | │ │ │ │ │ │ ├── Factor-prime 162 | │ │ │ │ │ │ │ ├── (SYMBOL, () 163 | │ │ │ │ │ │ │ ├── Args 164 | │ │ │ │ │ │ │ │ └── Arg-list 165 | │ │ │ │ │ │ │ │ ├── Expression 166 | │ │ │ │ │ │ │ │ │ ├── (ID, a) 167 | │ │ │ │ │ │ │ │ │ └── B 168 | │ │ │ │ │ │ │ │ │ └── Simple-expression-prime 169 | │ │ │ │ │ │ │ │ │ ├── Additive-expression-prime 170 | │ │ │ │ │ │ │ │ │ │ ├── Term-prime 171 | │ │ │ │ │ │ │ │ │ │ │ ├── Factor-prime 172 | │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 173 | │ │ │ │ │ │ │ │ │ │ │ └── G 174 | │ │ │ │ │ │ │ │ │ │ │ └── epsilon 175 | │ │ │ │ │ │ │ │ │ │ └── D 176 | │ │ │ │ │ │ │ │ │ │ └── epsilon 177 | │ │ │ │ │ │ │ │ │ └── C 178 | │ │ │ │ │ │ │ │ │ └── epsilon 179 | │ │ │ │ │ │ │ │ └── Arg-list-prime 180 | │ │ │ │ │ │ │ │ └── epsilon 181 | │ │ │ │ │ │ │ └── (SYMBOL, )) 182 | │ │ │ │ │ │ └── G 183 | │ │ │ │ │ │ └── epsilon 184 | │ │ │ │ │ └── D 185 | │ │ │ │ │ └── epsilon 186 | │ │ │ │ └── C 187 | │ │ │ │ └── epsilon 188 | │ │ │ └── (SYMBOL, ;) 189 | │ │ └── Statement-list 190 | │ │ ├── Statement 191 | │ │ │ └── Expression-stmt 192 | │ │ │ ├── Expression 193 | │ │ │ │ ├── (ID, output) 194 | │ │ │ │ └── B 195 | │ │ │ │ └── Simple-expression-prime 196 | │ │ │ │ ├── Additive-expression-prime 197 | │ │ │ │ │ ├── Term-prime 198 | │ │ │ │ │ │ ├── Factor-prime 199 | │ │ │ │ │ │ │ ├── (SYMBOL, () 200 | │ │ │ │ │ │ │ ├── Args 201 | │ │ │ │ │ │ │ │ └── Arg-list 202 | │ │ │ │ │ │ │ │ ├── Expression 203 | │ │ │ │ │ │ │ │ │ ├── (ID, b) 204 | │ │ │ │ │ │ │ │ │ └── B 205 | │ │ │ │ │ │ │ │ │ └── Simple-expression-prime 206 | │ │ │ │ │ │ │ │ │ ├── Additive-expression-prime 207 | │ │ │ │ │ │ │ │ │ │ ├── Term-prime 208 | │ │ │ │ │ │ │ │ │ │ │ ├── Factor-prime 209 | │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 210 | │ │ │ │ │ │ │ │ │ │ │ └── G 211 | │ │ │ │ │ │ │ │ │ │ │ └── epsilon 212 | │ │ │ │ │ │ │ │ │ │ └── D 213 | │ │ │ │ │ │ │ │ │ │ └── epsilon 214 | │ │ │ │ │ │ │ │ │ └── C 215 | │ │ │ │ │ │ │ │ │ └── epsilon 216 | │ │ │ │ │ │ │ │ └── Arg-list-prime 217 | │ │ │ │ │ │ │ │ └── epsilon 218 | │ │ │ │ │ │ │ └── (SYMBOL, )) 219 | │ │ │ │ │ │ └── G 220 | │ │ │ │ │ │ └── epsilon 221 | │ │ │ │ │ └── D 222 | │ │ │ │ │ └── epsilon 223 | │ │ │ │ └── C 224 | │ │ │ │ └── epsilon 225 | │ │ │ └── (SYMBOL, ;) 226 | │ │ └── Statement-list 227 | │ │ └── epsilon 228 | │ └── (SYMBOL, }) 229 | └── Declaration-list 230 | └── epsilon 231 | -------------------------------------------------------------------------------- /tests/TX18/syntax_errors.txt: -------------------------------------------------------------------------------- 1 | There is no syntax error. 2 | -------------------------------------------------------------------------------- /tests/TX19/input.txt: -------------------------------------------------------------------------------- 1 | /* test case 3*/ 2 | int foo(int x){ 3 | if (x < 0){ 4 | output(x); 5 | return 1; 6 | } 7 | else { 8 | output(x); 9 | return x + 2; 10 | } 11 | } 12 | void main(void){ 13 | int i; 14 | i= foo(0); 15 | output(i); 16 | i=foo(10); 17 | output(i); 18 | } 19 | -------------------------------------------------------------------------------- /tests/TX19/syntax_errors.txt: -------------------------------------------------------------------------------- 1 | There is no syntax error. 2 | -------------------------------------------------------------------------------- /tests/TX20/input.txt: -------------------------------------------------------------------------------- 1 | /* test case 4*/ 2 | int foo(int a, int b){ 3 | int bar(int a){ 4 | return a + 2; 5 | } 6 | return a + bar(b); 7 | } 8 | void main(void){ 9 | output(foo(1, 10)); 10 | } 11 | -------------------------------------------------------------------------------- /tests/TX20/parse_tree.txt: -------------------------------------------------------------------------------- 1 | Program 2 | └── Declaration-list 3 | ├── Declaration 4 | │ ├── Declaration-initial 5 | │ │ ├── Type-specifier 6 | │ │ │ └── (KEYWORD, int) 7 | │ │ └── (ID, foo) 8 | │ └── Declaration-prime 9 | │ └── Fun-declaration-prime 10 | │ ├── (SYMBOL, () 11 | │ ├── Params 12 | │ │ ├── (KEYWORD, int) 13 | │ │ ├── (ID, a) 14 | │ │ ├── Param-prime 15 | │ │ │ └── epsilon 16 | │ │ └── Param-list 17 | │ │ ├── (SYMBOL, ,) 18 | │ │ ├── Param 19 | │ │ │ ├── Declaration-initial 20 | │ │ │ │ ├── Type-specifier 21 | │ │ │ │ │ └── (KEYWORD, int) 22 | │ │ │ │ └── (ID, b) 23 | │ │ │ └── Param-prime 24 | │ │ │ └── epsilon 25 | │ │ └── Param-list 26 | │ │ └── epsilon 27 | │ ├── (SYMBOL, )) 28 | │ └── Compound-stmt 29 | │ ├── (SYMBOL, {) 30 | │ ├── Declaration-list 31 | │ │ ├── Declaration 32 | │ │ │ ├── Declaration-initial 33 | │ │ │ │ ├── Type-specifier 34 | │ │ │ │ │ └── (KEYWORD, int) 35 | │ │ │ │ └── (ID, bar) 36 | │ │ │ └── Declaration-prime 37 | │ │ │ └── Fun-declaration-prime 38 | │ │ │ ├── (SYMBOL, () 39 | │ │ │ ├── Params 40 | │ │ │ │ ├── (KEYWORD, int) 41 | │ │ │ │ ├── (ID, a) 42 | │ │ │ │ ├── Param-prime 43 | │ │ │ │ │ └── epsilon 44 | │ │ │ │ └── Param-list 45 | │ │ │ │ └── epsilon 46 | │ │ │ ├── (SYMBOL, )) 47 | │ │ │ └── Compound-stmt 48 | │ │ │ ├── (SYMBOL, {) 49 | │ │ │ ├── Declaration-list 50 | │ │ │ │ └── epsilon 51 | │ │ │ ├── Statement-list 52 | │ │ │ │ ├── Statement 53 | │ │ │ │ │ └── Return-stmt 54 | │ │ │ │ │ ├── (KEYWORD, return) 55 | │ │ │ │ │ └── Return-stmt-prime 56 | │ │ │ │ │ ├── Expression 57 | │ │ │ │ │ │ ├── (ID, a) 58 | │ │ │ │ │ │ └── B 59 | │ │ │ │ │ │ └── Simple-expression-prime 60 | │ │ │ │ │ │ ├── Additive-expression-prime 61 | │ │ │ │ │ │ │ ├── Term-prime 62 | │ │ │ │ │ │ │ │ ├── Factor-prime 63 | │ │ │ │ │ │ │ │ │ └── epsilon 64 | │ │ │ │ │ │ │ │ └── G 65 | │ │ │ │ │ │ │ │ └── epsilon 66 | │ │ │ │ │ │ │ └── D 67 | │ │ │ │ │ │ │ ├── Addop 68 | │ │ │ │ │ │ │ │ └── (SYMBOL, +) 69 | │ │ │ │ │ │ │ ├── Term 70 | │ │ │ │ │ │ │ │ ├── Factor 71 | │ │ │ │ │ │ │ │ │ └── (NUM, 2) 72 | │ │ │ │ │ │ │ │ └── G 73 | │ │ │ │ │ │ │ │ └── epsilon 74 | │ │ │ │ │ │ │ └── D 75 | │ │ │ │ │ │ │ └── epsilon 76 | │ │ │ │ │ │ └── C 77 | │ │ │ │ │ │ └── epsilon 78 | │ │ │ │ │ └── (SYMBOL, ;) 79 | │ │ │ │ └── Statement-list 80 | │ │ │ │ └── epsilon 81 | │ │ │ └── (SYMBOL, }) 82 | │ │ └── Declaration-list 83 | │ │ └── epsilon 84 | │ ├── Statement-list 85 | │ │ ├── Statement 86 | │ │ │ └── Return-stmt 87 | │ │ │ ├── (KEYWORD, return) 88 | │ │ │ └── Return-stmt-prime 89 | │ │ │ ├── Expression 90 | │ │ │ │ ├── (ID, a) 91 | │ │ │ │ └── B 92 | │ │ │ │ └── Simple-expression-prime 93 | │ │ │ │ ├── Additive-expression-prime 94 | │ │ │ │ │ ├── Term-prime 95 | │ │ │ │ │ │ ├── Factor-prime 96 | │ │ │ │ │ │ │ └── epsilon 97 | │ │ │ │ │ │ └── G 98 | │ │ │ │ │ │ └── epsilon 99 | │ │ │ │ │ └── D 100 | │ │ │ │ │ ├── Addop 101 | │ │ │ │ │ │ └── (SYMBOL, +) 102 | │ │ │ │ │ ├── Term 103 | │ │ │ │ │ │ ├── Factor 104 | │ │ │ │ │ │ │ ├── (ID, bar) 105 | │ │ │ │ │ │ │ └── Var-call-prime 106 | │ │ │ │ │ │ │ ├── (SYMBOL, () 107 | │ │ │ │ │ │ │ ├── Args 108 | │ │ │ │ │ │ │ │ └── Arg-list 109 | │ │ │ │ │ │ │ │ ├── Expression 110 | │ │ │ │ │ │ │ │ │ ├── (ID, b) 111 | │ │ │ │ │ │ │ │ │ └── B 112 | │ │ │ │ │ │ │ │ │ └── Simple-expression-prime 113 | │ │ │ │ │ │ │ │ │ ├── Additive-expression-prime 114 | │ │ │ │ │ │ │ │ │ │ ├── Term-prime 115 | │ │ │ │ │ │ │ │ │ │ │ ├── Factor-prime 116 | │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 117 | │ │ │ │ │ │ │ │ │ │ │ └── G 118 | │ │ │ │ │ │ │ │ │ │ │ └── epsilon 119 | │ │ │ │ │ │ │ │ │ │ └── D 120 | │ │ │ │ │ │ │ │ │ │ └── epsilon 121 | │ │ │ │ │ │ │ │ │ └── C 122 | │ │ │ │ │ │ │ │ │ └── epsilon 123 | │ │ │ │ │ │ │ │ └── Arg-list-prime 124 | │ │ │ │ │ │ │ │ └── epsilon 125 | │ │ │ │ │ │ │ └── (SYMBOL, )) 126 | │ │ │ │ │ │ └── G 127 | │ │ │ │ │ │ └── epsilon 128 | │ │ │ │ │ └── D 129 | │ │ │ │ │ └── epsilon 130 | │ │ │ │ └── C 131 | │ │ │ │ └── epsilon 132 | │ │ │ └── (SYMBOL, ;) 133 | │ │ └── Statement-list 134 | │ │ └── epsilon 135 | │ └── (SYMBOL, }) 136 | └── Declaration-list 137 | ├── Declaration 138 | │ ├── Declaration-initial 139 | │ │ ├── Type-specifier 140 | │ │ │ └── (KEYWORD, void) 141 | │ │ └── (ID, main) 142 | │ └── Declaration-prime 143 | │ └── Fun-declaration-prime 144 | │ ├── (SYMBOL, () 145 | │ ├── Params 146 | │ │ ├── (KEYWORD, void) 147 | │ │ └── Param-list-void-abtar 148 | │ │ └── epsilon 149 | │ ├── (SYMBOL, )) 150 | │ └── Compound-stmt 151 | │ ├── (SYMBOL, {) 152 | │ ├── Declaration-list 153 | │ │ └── epsilon 154 | │ ├── Statement-list 155 | │ │ ├── Statement 156 | │ │ │ └── Expression-stmt 157 | │ │ │ ├── Expression 158 | │ │ │ │ ├── (ID, output) 159 | │ │ │ │ └── B 160 | │ │ │ │ └── Simple-expression-prime 161 | │ │ │ │ ├── Additive-expression-prime 162 | │ │ │ │ │ ├── Term-prime 163 | │ │ │ │ │ │ ├── Factor-prime 164 | │ │ │ │ │ │ │ ├── (SYMBOL, () 165 | │ │ │ │ │ │ │ ├── Args 166 | │ │ │ │ │ │ │ │ └── Arg-list 167 | │ │ │ │ │ │ │ │ ├── Expression 168 | │ │ │ │ │ │ │ │ │ ├── (ID, foo) 169 | │ │ │ │ │ │ │ │ │ └── B 170 | │ │ │ │ │ │ │ │ │ └── Simple-expression-prime 171 | │ │ │ │ │ │ │ │ │ ├── Additive-expression-prime 172 | │ │ │ │ │ │ │ │ │ │ ├── Term-prime 173 | │ │ │ │ │ │ │ │ │ │ │ ├── Factor-prime 174 | │ │ │ │ │ │ │ │ │ │ │ │ ├── (SYMBOL, () 175 | │ │ │ │ │ │ │ │ │ │ │ │ ├── Args 176 | │ │ │ │ │ │ │ │ │ │ │ │ │ └── Arg-list 177 | │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Expression 178 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── Simple-expression-zegond 179 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Additive-expression-zegond 180 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Term-zegond 181 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Factor-zegond 182 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── (NUM, 1) 183 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── G 184 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 185 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── D 186 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 187 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── C 188 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 189 | │ │ │ │ │ │ │ │ │ │ │ │ │ └── Arg-list-prime 190 | │ │ │ │ │ │ │ │ │ │ │ │ │ ├── (SYMBOL, ,) 191 | │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Expression 192 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── Simple-expression-zegond 193 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Additive-expression-zegond 194 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Term-zegond 195 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Factor-zegond 196 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── (NUM, 10) 197 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── G 198 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 199 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── D 200 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 201 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── C 202 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 203 | │ │ │ │ │ │ │ │ │ │ │ │ │ └── Arg-list-prime 204 | │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 205 | │ │ │ │ │ │ │ │ │ │ │ │ └── (SYMBOL, )) 206 | │ │ │ │ │ │ │ │ │ │ │ └── G 207 | │ │ │ │ │ │ │ │ │ │ │ └── epsilon 208 | │ │ │ │ │ │ │ │ │ │ └── D 209 | │ │ │ │ │ │ │ │ │ │ └── epsilon 210 | │ │ │ │ │ │ │ │ │ └── C 211 | │ │ │ │ │ │ │ │ │ └── epsilon 212 | │ │ │ │ │ │ │ │ └── Arg-list-prime 213 | │ │ │ │ │ │ │ │ └── epsilon 214 | │ │ │ │ │ │ │ └── (SYMBOL, )) 215 | │ │ │ │ │ │ └── G 216 | │ │ │ │ │ │ └── epsilon 217 | │ │ │ │ │ └── D 218 | │ │ │ │ │ └── epsilon 219 | │ │ │ │ └── C 220 | │ │ │ │ └── epsilon 221 | │ │ │ └── (SYMBOL, ;) 222 | │ │ └── Statement-list 223 | │ │ └── epsilon 224 | │ └── (SYMBOL, }) 225 | └── Declaration-list 226 | └── epsilon 227 | -------------------------------------------------------------------------------- /tests/TX20/syntax_errors.txt: -------------------------------------------------------------------------------- 1 | There is no syntax error. 2 | -------------------------------------------------------------------------------- /tests/TX21/input.txt: -------------------------------------------------------------------------------- 1 | /* test case 5*/ 2 | int f(int a) { 3 | void g(int b) { 4 | output(b); 5 | f(b - 1); 6 | } 7 | if (a == 1) { 8 | output(a); 9 | return 0; 10 | } else { 11 | g(a); 12 | } 13 | 14 | 15 | } 16 | 17 | 18 | void main(void) { 19 | f(10); 20 | } 21 | -------------------------------------------------------------------------------- /tests/TX21/syntax_errors.txt: -------------------------------------------------------------------------------- 1 | There is no syntax error. 2 | -------------------------------------------------------------------------------- /tests/TX22/input.txt: -------------------------------------------------------------------------------- 1 | /* test case 6*/ 2 | void foo(int x){ 3 | 4 | switch(x){ 5 | case 0: 6 | { int a; } 7 | case 1: 8 | {output(2); 9 | break;} 10 | case 3: 11 | output(3); 12 | break; 13 | deflt: 14 | output(4); 15 | } 16 | } 17 | void main ( void ) 18 | 19 | { 20 | } 21 | 22 | -------------------------------------------------------------------------------- /tests/TX22/parse_tree.txt: -------------------------------------------------------------------------------- 1 | Program 2 | └── Declaration-list 3 | ├── Declaration 4 | │ ├── Declaration-initial 5 | │ │ ├── Type-specifier 6 | │ │ │ └── (KEYWORD, void) 7 | │ │ └── (ID, foo) 8 | │ └── Declaration-prime 9 | │ └── Fun-declaration-prime 10 | │ ├── (SYMBOL, () 11 | │ ├── Params 12 | │ │ ├── (KEYWORD, int) 13 | │ │ ├── (ID, x) 14 | │ │ ├── Param-prime 15 | │ │ │ └── epsilon 16 | │ │ └── Param-list 17 | │ │ └── epsilon 18 | │ ├── (SYMBOL, )) 19 | │ └── Compound-stmt 20 | │ ├── (SYMBOL, {) 21 | │ ├── Declaration-list 22 | │ │ └── epsilon 23 | │ ├── Statement-list 24 | │ │ ├── Statement 25 | │ │ │ └── Switch-stmt 26 | │ │ │ ├── (KEYWORD, switch) 27 | │ │ │ ├── (SYMBOL, () 28 | │ │ │ ├── Expression 29 | │ │ │ │ ├── (ID, x) 30 | │ │ │ │ └── B 31 | │ │ │ │ └── Simple-expression-prime 32 | │ │ │ │ ├── Additive-expression-prime 33 | │ │ │ │ │ ├── Term-prime 34 | │ │ │ │ │ │ ├── Factor-prime 35 | │ │ │ │ │ │ │ └── epsilon 36 | │ │ │ │ │ │ └── G 37 | │ │ │ │ │ │ └── epsilon 38 | │ │ │ │ │ └── D 39 | │ │ │ │ │ └── epsilon 40 | │ │ │ │ └── C 41 | │ │ │ │ └── epsilon 42 | │ │ │ ├── (SYMBOL, )) 43 | │ │ │ ├── (SYMBOL, {) 44 | │ │ │ ├── Case-stmts 45 | │ │ │ │ ├── Case-stmt 46 | │ │ │ │ │ ├── (KEYWORD, case) 47 | │ │ │ │ │ ├── (NUM, 0) 48 | │ │ │ │ │ ├── (SYMBOL, :) 49 | │ │ │ │ │ └── Statement-list 50 | │ │ │ │ │ ├── Statement 51 | │ │ │ │ │ │ └── Compound-stmt 52 | │ │ │ │ │ │ ├── (SYMBOL, {) 53 | │ │ │ │ │ │ ├── Declaration-list 54 | │ │ │ │ │ │ │ ├── Declaration 55 | │ │ │ │ │ │ │ │ ├── Declaration-initial 56 | │ │ │ │ │ │ │ │ │ ├── Type-specifier 57 | │ │ │ │ │ │ │ │ │ │ └── (KEYWORD, int) 58 | │ │ │ │ │ │ │ │ │ └── (ID, a) 59 | │ │ │ │ │ │ │ │ └── Declaration-prime 60 | │ │ │ │ │ │ │ │ └── Var-declaration-prime 61 | │ │ │ │ │ │ │ │ └── (SYMBOL, ;) 62 | │ │ │ │ │ │ │ └── Declaration-list 63 | │ │ │ │ │ │ │ └── epsilon 64 | │ │ │ │ │ │ ├── Statement-list 65 | │ │ │ │ │ │ │ └── epsilon 66 | │ │ │ │ │ │ └── (SYMBOL, }) 67 | │ │ │ │ │ └── Statement-list 68 | │ │ │ │ │ └── epsilon 69 | │ │ │ │ └── Case-stmts 70 | │ │ │ │ ├── Case-stmt 71 | │ │ │ │ │ ├── (KEYWORD, case) 72 | │ │ │ │ │ ├── (NUM, 1) 73 | │ │ │ │ │ ├── (SYMBOL, :) 74 | │ │ │ │ │ └── Statement-list 75 | │ │ │ │ │ ├── Statement 76 | │ │ │ │ │ │ └── Compound-stmt 77 | │ │ │ │ │ │ ├── (SYMBOL, {) 78 | │ │ │ │ │ │ ├── Declaration-list 79 | │ │ │ │ │ │ │ └── epsilon 80 | │ │ │ │ │ │ ├── Statement-list 81 | │ │ │ │ │ │ │ ├── Statement 82 | │ │ │ │ │ │ │ │ └── Expression-stmt 83 | │ │ │ │ │ │ │ │ ├── Expression 84 | │ │ │ │ │ │ │ │ │ ├── (ID, output) 85 | │ │ │ │ │ │ │ │ │ └── B 86 | │ │ │ │ │ │ │ │ │ └── Simple-expression-prime 87 | │ │ │ │ │ │ │ │ │ ├── Additive-expression-prime 88 | │ │ │ │ │ │ │ │ │ │ ├── Term-prime 89 | │ │ │ │ │ │ │ │ │ │ │ ├── Factor-prime 90 | │ │ │ │ │ │ │ │ │ │ │ │ ├── (SYMBOL, () 91 | │ │ │ │ │ │ │ │ │ │ │ │ ├── Args 92 | │ │ │ │ │ │ │ │ │ │ │ │ │ └── Arg-list 93 | │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Expression 94 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── Simple-expression-zegond 95 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Additive-expression-zegond 96 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Term-zegond 97 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Factor-zegond 98 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── (NUM, 2) 99 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── G 100 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 101 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── D 102 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 103 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── C 104 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 105 | │ │ │ │ │ │ │ │ │ │ │ │ │ └── Arg-list-prime 106 | │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 107 | │ │ │ │ │ │ │ │ │ │ │ │ └── (SYMBOL, )) 108 | │ │ │ │ │ │ │ │ │ │ │ └── G 109 | │ │ │ │ │ │ │ │ │ │ │ └── epsilon 110 | │ │ │ │ │ │ │ │ │ │ └── D 111 | │ │ │ │ │ │ │ │ │ │ └── epsilon 112 | │ │ │ │ │ │ │ │ │ └── C 113 | │ │ │ │ │ │ │ │ │ └── epsilon 114 | │ │ │ │ │ │ │ │ └── (SYMBOL, ;) 115 | │ │ │ │ │ │ │ └── Statement-list 116 | │ │ │ │ │ │ │ ├── Statement 117 | │ │ │ │ │ │ │ │ └── Expression-stmt 118 | │ │ │ │ │ │ │ │ ├── (KEYWORD, break) 119 | │ │ │ │ │ │ │ │ └── (SYMBOL, ;) 120 | │ │ │ │ │ │ │ └── Statement-list 121 | │ │ │ │ │ │ │ └── epsilon 122 | │ │ │ │ │ │ └── (SYMBOL, }) 123 | │ │ │ │ │ └── Statement-list 124 | │ │ │ │ │ └── epsilon 125 | │ │ │ │ └── Case-stmts 126 | │ │ │ │ ├── Case-stmt 127 | │ │ │ │ │ ├── (KEYWORD, case) 128 | │ │ │ │ │ ├── (NUM, 3) 129 | │ │ │ │ │ ├── (SYMBOL, :) 130 | │ │ │ │ │ └── Statement-list 131 | │ │ │ │ │ ├── Statement 132 | │ │ │ │ │ │ └── Expression-stmt 133 | │ │ │ │ │ │ ├── Expression 134 | │ │ │ │ │ │ │ ├── (ID, output) 135 | │ │ │ │ │ │ │ └── B 136 | │ │ │ │ │ │ │ └── Simple-expression-prime 137 | │ │ │ │ │ │ │ ├── Additive-expression-prime 138 | │ │ │ │ │ │ │ │ ├── Term-prime 139 | │ │ │ │ │ │ │ │ │ ├── Factor-prime 140 | │ │ │ │ │ │ │ │ │ │ ├── (SYMBOL, () 141 | │ │ │ │ │ │ │ │ │ │ ├── Args 142 | │ │ │ │ │ │ │ │ │ │ │ └── Arg-list 143 | │ │ │ │ │ │ │ │ │ │ │ ├── Expression 144 | │ │ │ │ │ │ │ │ │ │ │ │ └── Simple-expression-zegond 145 | │ │ │ │ │ │ │ │ │ │ │ │ ├── Additive-expression-zegond 146 | │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Term-zegond 147 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Factor-zegond 148 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── (NUM, 3) 149 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── G 150 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 151 | │ │ │ │ │ │ │ │ │ │ │ │ │ └── D 152 | │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 153 | │ │ │ │ │ │ │ │ │ │ │ │ └── C 154 | │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 155 | │ │ │ │ │ │ │ │ │ │ │ └── Arg-list-prime 156 | │ │ │ │ │ │ │ │ │ │ │ └── epsilon 157 | │ │ │ │ │ │ │ │ │ │ └── (SYMBOL, )) 158 | │ │ │ │ │ │ │ │ │ └── G 159 | │ │ │ │ │ │ │ │ │ └── epsilon 160 | │ │ │ │ │ │ │ │ └── D 161 | │ │ │ │ │ │ │ │ └── epsilon 162 | │ │ │ │ │ │ │ └── C 163 | │ │ │ │ │ │ │ └── epsilon 164 | │ │ │ │ │ │ └── (SYMBOL, ;) 165 | │ │ │ │ │ └── Statement-list 166 | │ │ │ │ │ ├── Statement 167 | │ │ │ │ │ │ └── Expression-stmt 168 | │ │ │ │ │ │ ├── (KEYWORD, break) 169 | │ │ │ │ │ │ └── (SYMBOL, ;) 170 | │ │ │ │ │ └── Statement-list 171 | │ │ │ │ │ ├── Statement 172 | │ │ │ │ │ │ └── Expression-stmt 173 | │ │ │ │ │ │ ├── Expression 174 | │ │ │ │ │ │ │ ├── (ID, deflt) 175 | │ │ │ │ │ │ │ └── B 176 | │ │ │ │ │ │ │ └── Simple-expression-prime 177 | │ │ │ │ │ │ │ ├── Additive-expression-prime 178 | │ │ │ │ │ │ │ │ ├── Term-prime 179 | │ │ │ │ │ │ │ │ │ ├── Factor-prime 180 | │ │ │ │ │ │ │ │ │ │ ├── (SYMBOL, () 181 | │ │ │ │ │ │ │ │ │ │ ├── Args 182 | │ │ │ │ │ │ │ │ │ │ │ └── Arg-list 183 | │ │ │ │ │ │ │ │ │ │ │ ├── Expression 184 | │ │ │ │ │ │ │ │ │ │ │ │ └── Simple-expression-zegond 185 | │ │ │ │ │ │ │ │ │ │ │ │ ├── Additive-expression-zegond 186 | │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Term-zegond 187 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Factor-zegond 188 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── (NUM, 4) 189 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── G 190 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 191 | │ │ │ │ │ │ │ │ │ │ │ │ │ └── D 192 | │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 193 | │ │ │ │ │ │ │ │ │ │ │ │ └── C 194 | │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 195 | │ │ │ │ │ │ │ │ │ │ │ └── Arg-list-prime 196 | │ │ │ │ │ │ │ │ │ │ │ └── epsilon 197 | │ │ │ │ │ │ │ │ │ │ └── (SYMBOL, )) 198 | │ │ │ │ │ │ │ │ │ └── G 199 | │ │ │ │ │ │ │ │ │ └── epsilon 200 | │ │ │ │ │ │ │ │ └── D 201 | │ │ │ │ │ │ │ │ └── epsilon 202 | │ │ │ │ │ │ │ └── C 203 | │ │ │ │ │ │ │ └── epsilon 204 | │ │ │ │ │ │ └── (SYMBOL, ;) 205 | │ │ │ │ │ └── Statement-list 206 | │ │ │ │ │ └── epsilon 207 | │ │ │ │ └── Case-stmts 208 | │ │ │ │ └── epsilon 209 | │ │ │ ├── Default-stmt 210 | │ │ │ │ └── epsilon 211 | │ │ │ └── (SYMBOL, }) 212 | │ │ └── Statement-list 213 | │ │ └── epsilon 214 | │ └── (SYMBOL, }) 215 | └── Declaration-list 216 | ├── Declaration 217 | │ ├── Declaration-initial 218 | │ │ ├── Type-specifier 219 | │ │ │ └── (KEYWORD, void) 220 | │ │ └── (ID, main) 221 | │ └── Declaration-prime 222 | │ └── Fun-declaration-prime 223 | │ ├── (SYMBOL, () 224 | │ ├── Params 225 | │ │ ├── (KEYWORD, void) 226 | │ │ └── Param-list-void-abtar 227 | │ │ └── epsilon 228 | │ ├── (SYMBOL, )) 229 | │ └── Compound-stmt 230 | │ ├── (SYMBOL, {) 231 | │ ├── Declaration-list 232 | │ │ └── epsilon 233 | │ ├── Statement-list 234 | │ │ └── epsilon 235 | │ └── (SYMBOL, }) 236 | └── Declaration-list 237 | └── epsilon 238 | -------------------------------------------------------------------------------- /tests/TX22/syntax_errors.txt: -------------------------------------------------------------------------------- 1 | #13 : Syntax Error! Illegal ":" 2 | #14 : Syntax Error! Illegal "ID" 3 | -------------------------------------------------------------------------------- /tests/TX23/input.txt: -------------------------------------------------------------------------------- 1 | int foo(int x){ 2 | int a; 3 | a = 10; 4 | output(x); 5 | if(a < x) { 6 | return(1); 7 | } 8 | { 9 | return(2); 10 | } 11 | } 12 | void main ( void ) 13 | { 14 | int i; 15 | i = foo (4); 16 | output (i); 17 | } 18 | 19 | -------------------------------------------------------------------------------- /tests/TX23/syntax_errors.txt: -------------------------------------------------------------------------------- 1 | #8 : Syntax Error! Missing "else" 2 | -------------------------------------------------------------------------------- /tests/TX24/input.txt: -------------------------------------------------------------------------------- 1 | /* test case 8*/ 2 | int fact ( int n ) 3 | { 4 | int f; 5 | if ( n = 1 )f = 1; 6 | else 7 | f = n * * factorial ( n - 1 ); 8 | return f; 9 | } 10 | void main ( void ) 11 | { 12 | output ( factorial (3) ); 13 | } 14 | 15 | -------------------------------------------------------------------------------- /tests/TX24/parse_tree.txt: -------------------------------------------------------------------------------- 1 | Program 2 | └── Declaration-list 3 | ├── Declaration 4 | │ ├── Declaration-initial 5 | │ │ ├── Type-specifier 6 | │ │ │ └── (KEYWORD, int) 7 | │ │ └── (ID, fact) 8 | │ └── Declaration-prime 9 | │ └── Fun-declaration-prime 10 | │ ├── (SYMBOL, () 11 | │ ├── Params 12 | │ │ ├── (KEYWORD, int) 13 | │ │ ├── (ID, n) 14 | │ │ ├── Param-prime 15 | │ │ │ └── epsilon 16 | │ │ └── Param-list 17 | │ │ └── epsilon 18 | │ ├── (SYMBOL, )) 19 | │ └── Compound-stmt 20 | │ ├── (SYMBOL, {) 21 | │ ├── Declaration-list 22 | │ │ ├── Declaration 23 | │ │ │ ├── Declaration-initial 24 | │ │ │ │ ├── Type-specifier 25 | │ │ │ │ │ └── (KEYWORD, int) 26 | │ │ │ │ └── (ID, f) 27 | │ │ │ └── Declaration-prime 28 | │ │ │ └── Var-declaration-prime 29 | │ │ │ └── (SYMBOL, ;) 30 | │ │ └── Declaration-list 31 | │ │ └── epsilon 32 | │ ├── Statement-list 33 | │ │ ├── Statement 34 | │ │ │ └── Selection-stmt 35 | │ │ │ ├── (KEYWORD, if) 36 | │ │ │ ├── (SYMBOL, () 37 | │ │ │ ├── Expression 38 | │ │ │ │ ├── (ID, n) 39 | │ │ │ │ └── B 40 | │ │ │ │ ├── (SYMBOL, =) 41 | │ │ │ │ └── Expression 42 | │ │ │ │ └── Simple-expression-zegond 43 | │ │ │ │ ├── Additive-expression-zegond 44 | │ │ │ │ │ ├── Term-zegond 45 | │ │ │ │ │ │ ├── Factor-zegond 46 | │ │ │ │ │ │ │ └── (NUM, 1) 47 | │ │ │ │ │ │ └── G 48 | │ │ │ │ │ │ └── epsilon 49 | │ │ │ │ │ └── D 50 | │ │ │ │ │ └── epsilon 51 | │ │ │ │ └── C 52 | │ │ │ │ └── epsilon 53 | │ │ │ ├── (SYMBOL, )) 54 | │ │ │ ├── Statement 55 | │ │ │ │ └── Expression-stmt 56 | │ │ │ │ ├── Expression 57 | │ │ │ │ │ ├── (ID, f) 58 | │ │ │ │ │ └── B 59 | │ │ │ │ │ ├── (SYMBOL, =) 60 | │ │ │ │ │ └── Expression 61 | │ │ │ │ │ └── Simple-expression-zegond 62 | │ │ │ │ │ ├── Additive-expression-zegond 63 | │ │ │ │ │ │ ├── Term-zegond 64 | │ │ │ │ │ │ │ ├── Factor-zegond 65 | │ │ │ │ │ │ │ │ └── (NUM, 1) 66 | │ │ │ │ │ │ │ └── G 67 | │ │ │ │ │ │ │ └── epsilon 68 | │ │ │ │ │ │ └── D 69 | │ │ │ │ │ │ └── epsilon 70 | │ │ │ │ │ └── C 71 | │ │ │ │ │ └── epsilon 72 | │ │ │ │ └── (SYMBOL, ;) 73 | │ │ │ ├── (KEYWORD, else) 74 | │ │ │ └── Statement 75 | │ │ │ └── Expression-stmt 76 | │ │ │ ├── Expression 77 | │ │ │ │ ├── (ID, f) 78 | │ │ │ │ └── B 79 | │ │ │ │ ├── (SYMBOL, =) 80 | │ │ │ │ └── Expression 81 | │ │ │ │ ├── (ID, n) 82 | │ │ │ │ └── B 83 | │ │ │ │ └── Simple-expression-prime 84 | │ │ │ │ ├── Additive-expression-prime 85 | │ │ │ │ │ ├── Term-prime 86 | │ │ │ │ │ │ ├── Factor-prime 87 | │ │ │ │ │ │ │ └── epsilon 88 | │ │ │ │ │ │ └── G 89 | │ │ │ │ │ │ ├── (SYMBOL, *) 90 | │ │ │ │ │ │ └── G 91 | │ │ │ │ │ │ ├── (SYMBOL, *) 92 | │ │ │ │ │ │ ├── Factor 93 | │ │ │ │ │ │ │ ├── (ID, factorial) 94 | │ │ │ │ │ │ │ └── Var-call-prime 95 | │ │ │ │ │ │ │ ├── (SYMBOL, () 96 | │ │ │ │ │ │ │ ├── Args 97 | │ │ │ │ │ │ │ │ └── Arg-list 98 | │ │ │ │ │ │ │ │ ├── Expression 99 | │ │ │ │ │ │ │ │ │ ├── (ID, n) 100 | │ │ │ │ │ │ │ │ │ └── B 101 | │ │ │ │ │ │ │ │ │ └── Simple-expression-prime 102 | │ │ │ │ │ │ │ │ │ ├── Additive-expression-prime 103 | │ │ │ │ │ │ │ │ │ │ ├── Term-prime 104 | │ │ │ │ │ │ │ │ │ │ │ ├── Factor-prime 105 | │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 106 | │ │ │ │ │ │ │ │ │ │ │ └── G 107 | │ │ │ │ │ │ │ │ │ │ │ └── epsilon 108 | │ │ │ │ │ │ │ │ │ │ └── D 109 | │ │ │ │ │ │ │ │ │ │ ├── Addop 110 | │ │ │ │ │ │ │ │ │ │ │ └── (SYMBOL, -) 111 | │ │ │ │ │ │ │ │ │ │ ├── Term 112 | │ │ │ │ │ │ │ │ │ │ │ ├── Factor 113 | │ │ │ │ │ │ │ │ │ │ │ │ └── (NUM, 1) 114 | │ │ │ │ │ │ │ │ │ │ │ └── G 115 | │ │ │ │ │ │ │ │ │ │ │ └── epsilon 116 | │ │ │ │ │ │ │ │ │ │ └── D 117 | │ │ │ │ │ │ │ │ │ │ └── epsilon 118 | │ │ │ │ │ │ │ │ │ └── C 119 | │ │ │ │ │ │ │ │ │ └── epsilon 120 | │ │ │ │ │ │ │ │ └── Arg-list-prime 121 | │ │ │ │ │ │ │ │ └── epsilon 122 | │ │ │ │ │ │ │ └── (SYMBOL, )) 123 | │ │ │ │ │ │ └── G 124 | │ │ │ │ │ │ └── epsilon 125 | │ │ │ │ │ └── D 126 | │ │ │ │ │ └── epsilon 127 | │ │ │ │ └── C 128 | │ │ │ │ └── epsilon 129 | │ │ │ └── (SYMBOL, ;) 130 | │ │ └── Statement-list 131 | │ │ ├── Statement 132 | │ │ │ └── Return-stmt 133 | │ │ │ ├── (KEYWORD, return) 134 | │ │ │ └── Return-stmt-prime 135 | │ │ │ ├── Expression 136 | │ │ │ │ ├── (ID, f) 137 | │ │ │ │ └── B 138 | │ │ │ │ └── Simple-expression-prime 139 | │ │ │ │ ├── Additive-expression-prime 140 | │ │ │ │ │ ├── Term-prime 141 | │ │ │ │ │ │ ├── Factor-prime 142 | │ │ │ │ │ │ │ └── epsilon 143 | │ │ │ │ │ │ └── G 144 | │ │ │ │ │ │ └── epsilon 145 | │ │ │ │ │ └── D 146 | │ │ │ │ │ └── epsilon 147 | │ │ │ │ └── C 148 | │ │ │ │ └── epsilon 149 | │ │ │ └── (SYMBOL, ;) 150 | │ │ └── Statement-list 151 | │ │ └── epsilon 152 | │ └── (SYMBOL, }) 153 | └── Declaration-list 154 | ├── Declaration 155 | │ ├── Declaration-initial 156 | │ │ ├── Type-specifier 157 | │ │ │ └── (KEYWORD, void) 158 | │ │ └── (ID, main) 159 | │ └── Declaration-prime 160 | │ └── Fun-declaration-prime 161 | │ ├── (SYMBOL, () 162 | │ ├── Params 163 | │ │ ├── (KEYWORD, void) 164 | │ │ └── Param-list-void-abtar 165 | │ │ └── epsilon 166 | │ ├── (SYMBOL, )) 167 | │ └── Compound-stmt 168 | │ ├── (SYMBOL, {) 169 | │ ├── Declaration-list 170 | │ │ └── epsilon 171 | │ ├── Statement-list 172 | │ │ ├── Statement 173 | │ │ │ └── Expression-stmt 174 | │ │ │ ├── Expression 175 | │ │ │ │ ├── (ID, output) 176 | │ │ │ │ └── B 177 | │ │ │ │ └── Simple-expression-prime 178 | │ │ │ │ ├── Additive-expression-prime 179 | │ │ │ │ │ ├── Term-prime 180 | │ │ │ │ │ │ ├── Factor-prime 181 | │ │ │ │ │ │ │ ├── (SYMBOL, () 182 | │ │ │ │ │ │ │ ├── Args 183 | │ │ │ │ │ │ │ │ └── Arg-list 184 | │ │ │ │ │ │ │ │ ├── Expression 185 | │ │ │ │ │ │ │ │ │ ├── (ID, factorial) 186 | │ │ │ │ │ │ │ │ │ └── B 187 | │ │ │ │ │ │ │ │ │ └── Simple-expression-prime 188 | │ │ │ │ │ │ │ │ │ ├── Additive-expression-prime 189 | │ │ │ │ │ │ │ │ │ │ ├── Term-prime 190 | │ │ │ │ │ │ │ │ │ │ │ ├── Factor-prime 191 | │ │ │ │ │ │ │ │ │ │ │ │ ├── (SYMBOL, () 192 | │ │ │ │ │ │ │ │ │ │ │ │ ├── Args 193 | │ │ │ │ │ │ │ │ │ │ │ │ │ └── Arg-list 194 | │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Expression 195 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── Simple-expression-zegond 196 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Additive-expression-zegond 197 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Term-zegond 198 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ├── Factor-zegond 199 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── (NUM, 3) 200 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── G 201 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 202 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── D 203 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 204 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── C 205 | │ │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 206 | │ │ │ │ │ │ │ │ │ │ │ │ │ └── Arg-list-prime 207 | │ │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 208 | │ │ │ │ │ │ │ │ │ │ │ │ └── (SYMBOL, )) 209 | │ │ │ │ │ │ │ │ │ │ │ └── G 210 | │ │ │ │ │ │ │ │ │ │ │ └── epsilon 211 | │ │ │ │ │ │ │ │ │ │ └── D 212 | │ │ │ │ │ │ │ │ │ │ └── epsilon 213 | │ │ │ │ │ │ │ │ │ └── C 214 | │ │ │ │ │ │ │ │ │ └── epsilon 215 | │ │ │ │ │ │ │ │ └── Arg-list-prime 216 | │ │ │ │ │ │ │ │ └── epsilon 217 | │ │ │ │ │ │ │ └── (SYMBOL, )) 218 | │ │ │ │ │ │ └── G 219 | │ │ │ │ │ │ └── epsilon 220 | │ │ │ │ │ └── D 221 | │ │ │ │ │ └── epsilon 222 | │ │ │ │ └── C 223 | │ │ │ │ └── epsilon 224 | │ │ │ └── (SYMBOL, ;) 225 | │ │ └── Statement-list 226 | │ │ └── epsilon 227 | │ └── (SYMBOL, }) 228 | └── Declaration-list 229 | └── epsilon 230 | -------------------------------------------------------------------------------- /tests/TX24/syntax_errors.txt: -------------------------------------------------------------------------------- 1 | #7 : Syntax Error! Missing "NUM" 2 | -------------------------------------------------------------------------------- /tests/TX25/input.txt: -------------------------------------------------------------------------------- 1 | int f(int a) { 2 | void g(int b) { 3 | output(b); 4 | f(b - 1); 5 | } 6 | if (a == ) { 7 | output(a); 8 | return 0; 9 | } else { 10 | g(a); 11 | } 12 | 13 | } 14 | 15 | 16 | void main(void) { 17 | f(10); 18 | } 19 | -------------------------------------------------------------------------------- /tests/TX25/syntax_errors.txt: -------------------------------------------------------------------------------- 1 | #6 : Syntax Error! Missing "NUM" 2 | -------------------------------------------------------------------------------- /tests/TX26/input.txt: -------------------------------------------------------------------------------- 1 | int count; 2 | int result[50]; 3 | 4 | 5 | int f(int a, int result[]) { 6 | count = count + 1; 7 | if(result[a - 1]){ 8 | return result[a - 1]; 9 | } else { 10 | if (a == 1) { 11 | result[a - 1] = 1; 12 | return 1; 13 | } else if (a == 2){ 14 | result[a - 1] = 1; 15 | return 1; 16 | } else { 17 | result[a - 1] = f(a - 2, result) + f(a - 1, result); 18 | return result[a - 1)]; 19 | } 20 | } 21 | } 22 | 23 | void main(void) { 24 | int i; 25 | i = 0; 26 | while (i < 50) { 27 | result[i] = 0; ; 28 | i = i + 1; 29 | } 30 | count = 0; 31 | output(f(40, result)); 32 | output(count); 33 | } 34 | -------------------------------------------------------------------------------- /tests/TX26/syntax_errors.txt: -------------------------------------------------------------------------------- 1 | #18 : Syntax Error! Missing "]" 2 | #18 : Syntax Error! Missing ";" 3 | #18 : Syntax Error! Illegal ")" 4 | #18 : Syntax Error! Illegal "]" 5 | -------------------------------------------------------------------------------- /tests/TX27/input.txt: -------------------------------------------------------------------------------- 1 | /* test case 1*/ 2 | void main(void){ 3 | int prod; 4 | int i; 5 | prod = 1; 6 | i = 1; 7 | while(i < 7){ 8 | prod = i * prod ; 9 | i = i + 2; 10 | } 11 | output(prod); 12 | return; 13 | 14 | } 15 | -------------------------------------------------------------------------------- /tests/TX27/parse_tree.txt: -------------------------------------------------------------------------------- 1 | Program 2 | └── Declaration-list 3 | ├── Declaration 4 | │ ├── Declaration-initial 5 | │ │ ├── Type-specifier 6 | │ │ │ └── (KEYWORD, void) 7 | │ │ └── (ID, main) 8 | │ └── Declaration-prime 9 | │ └── Fun-declaration-prime 10 | │ ├── (SYMBOL, () 11 | │ ├── Params 12 | │ │ ├── (KEYWORD, void) 13 | │ │ └── Param-list-void-abtar 14 | │ │ └── epsilon 15 | │ ├── (SYMBOL, )) 16 | │ └── Compound-stmt 17 | │ ├── (SYMBOL, {) 18 | │ ├── Declaration-list 19 | │ │ ├── Declaration 20 | │ │ │ ├── Declaration-initial 21 | │ │ │ │ ├── Type-specifier 22 | │ │ │ │ │ └── (KEYWORD, int) 23 | │ │ │ │ └── (ID, prod) 24 | │ │ │ └── Declaration-prime 25 | │ │ │ └── Var-declaration-prime 26 | │ │ │ └── (SYMBOL, ;) 27 | │ │ └── Declaration-list 28 | │ │ ├── Declaration 29 | │ │ │ ├── Declaration-initial 30 | │ │ │ │ ├── Type-specifier 31 | │ │ │ │ │ └── (KEYWORD, int) 32 | │ │ │ │ └── (ID, i) 33 | │ │ │ └── Declaration-prime 34 | │ │ │ └── Var-declaration-prime 35 | │ │ │ └── (SYMBOL, ;) 36 | │ │ └── Declaration-list 37 | │ │ └── epsilon 38 | │ ├── Statement-list 39 | │ │ ├── Statement 40 | │ │ │ └── Expression-stmt 41 | │ │ │ ├── Expression 42 | │ │ │ │ ├── (ID, prod) 43 | │ │ │ │ └── B 44 | │ │ │ │ ├── (SYMBOL, =) 45 | │ │ │ │ └── Expression 46 | │ │ │ │ └── Simple-expression-zegond 47 | │ │ │ │ ├── Additive-expression-zegond 48 | │ │ │ │ │ ├── Term-zegond 49 | │ │ │ │ │ │ ├── Factor-zegond 50 | │ │ │ │ │ │ │ └── (NUM, 1) 51 | │ │ │ │ │ │ └── G 52 | │ │ │ │ │ │ └── epsilon 53 | │ │ │ │ │ └── D 54 | │ │ │ │ │ └── epsilon 55 | │ │ │ │ └── C 56 | │ │ │ │ └── epsilon 57 | │ │ │ └── (SYMBOL, ;) 58 | │ │ └── Statement-list 59 | │ │ ├── Statement 60 | │ │ │ └── Expression-stmt 61 | │ │ │ ├── Expression 62 | │ │ │ │ ├── (ID, i) 63 | │ │ │ │ └── B 64 | │ │ │ │ ├── (SYMBOL, =) 65 | │ │ │ │ └── Expression 66 | │ │ │ │ └── Simple-expression-zegond 67 | │ │ │ │ ├── Additive-expression-zegond 68 | │ │ │ │ │ ├── Term-zegond 69 | │ │ │ │ │ │ ├── Factor-zegond 70 | │ │ │ │ │ │ │ └── (NUM, 1) 71 | │ │ │ │ │ │ └── G 72 | │ │ │ │ │ │ └── epsilon 73 | │ │ │ │ │ └── D 74 | │ │ │ │ │ └── epsilon 75 | │ │ │ │ └── C 76 | │ │ │ │ └── epsilon 77 | │ │ │ └── (SYMBOL, ;) 78 | │ │ └── Statement-list 79 | │ │ ├── Statement 80 | │ │ │ └── Iteration-stmt 81 | │ │ │ ├── (KEYWORD, while) 82 | │ │ │ ├── (SYMBOL, () 83 | │ │ │ ├── Expression 84 | │ │ │ │ ├── (ID, i) 85 | │ │ │ │ └── B 86 | │ │ │ │ └── Simple-expression-prime 87 | │ │ │ │ ├── Additive-expression-prime 88 | │ │ │ │ │ ├── Term-prime 89 | │ │ │ │ │ │ ├── Factor-prime 90 | │ │ │ │ │ │ │ └── epsilon 91 | │ │ │ │ │ │ └── G 92 | │ │ │ │ │ │ └── epsilon 93 | │ │ │ │ │ └── D 94 | │ │ │ │ │ └── epsilon 95 | │ │ │ │ └── C 96 | │ │ │ │ ├── Relop 97 | │ │ │ │ │ └── (SYMBOL, <) 98 | │ │ │ │ └── Additive-expression 99 | │ │ │ │ ├── Term 100 | │ │ │ │ │ ├── Factor 101 | │ │ │ │ │ │ └── (NUM, 7) 102 | │ │ │ │ │ └── G 103 | │ │ │ │ │ └── epsilon 104 | │ │ │ │ └── D 105 | │ │ │ │ └── epsilon 106 | │ │ │ ├── (SYMBOL, )) 107 | │ │ │ └── Statement 108 | │ │ │ └── Compound-stmt 109 | │ │ │ ├── (SYMBOL, {) 110 | │ │ │ ├── Declaration-list 111 | │ │ │ │ └── epsilon 112 | │ │ │ ├── Statement-list 113 | │ │ │ │ ├── Statement 114 | │ │ │ │ │ └── Expression-stmt 115 | │ │ │ │ │ ├── Expression 116 | │ │ │ │ │ │ ├── (ID, prod) 117 | │ │ │ │ │ │ └── B 118 | │ │ │ │ │ │ ├── (SYMBOL, =) 119 | │ │ │ │ │ │ └── Expression 120 | │ │ │ │ │ │ ├── (ID, i) 121 | │ │ │ │ │ │ └── B 122 | │ │ │ │ │ │ └── Simple-expression-prime 123 | │ │ │ │ │ │ ├── Additive-expression-prime 124 | │ │ │ │ │ │ │ ├── Term-prime 125 | │ │ │ │ │ │ │ │ ├── Factor-prime 126 | │ │ │ │ │ │ │ │ │ └── epsilon 127 | │ │ │ │ │ │ │ │ └── G 128 | │ │ │ │ │ │ │ │ ├── (SYMBOL, *) 129 | │ │ │ │ │ │ │ │ ├── Factor 130 | │ │ │ │ │ │ │ │ │ ├── (ID, prod) 131 | │ │ │ │ │ │ │ │ │ └── Var-call-prime 132 | │ │ │ │ │ │ │ │ │ └── Var-prime 133 | │ │ │ │ │ │ │ │ │ └── epsilon 134 | │ │ │ │ │ │ │ │ └── G 135 | │ │ │ │ │ │ │ │ └── epsilon 136 | │ │ │ │ │ │ │ └── D 137 | │ │ │ │ │ │ │ └── epsilon 138 | │ │ │ │ │ │ └── C 139 | │ │ │ │ │ │ └── epsilon 140 | │ │ │ │ │ └── (SYMBOL, ;) 141 | │ │ │ │ └── Statement-list 142 | │ │ │ │ ├── Statement 143 | │ │ │ │ │ └── Expression-stmt 144 | │ │ │ │ │ ├── Expression 145 | │ │ │ │ │ │ ├── (ID, i) 146 | │ │ │ │ │ │ └── B 147 | │ │ │ │ │ │ ├── (SYMBOL, =) 148 | │ │ │ │ │ │ └── Expression 149 | │ │ │ │ │ │ ├── (ID, i) 150 | │ │ │ │ │ │ └── B 151 | │ │ │ │ │ │ └── Simple-expression-prime 152 | │ │ │ │ │ │ ├── Additive-expression-prime 153 | │ │ │ │ │ │ │ ├── Term-prime 154 | │ │ │ │ │ │ │ │ ├── Factor-prime 155 | │ │ │ │ │ │ │ │ │ └── epsilon 156 | │ │ │ │ │ │ │ │ └── G 157 | │ │ │ │ │ │ │ │ └── epsilon 158 | │ │ │ │ │ │ │ └── D 159 | │ │ │ │ │ │ │ ├── Addop 160 | │ │ │ │ │ │ │ │ └── (SYMBOL, +) 161 | │ │ │ │ │ │ │ ├── Term 162 | │ │ │ │ │ │ │ │ ├── Factor 163 | │ │ │ │ │ │ │ │ │ └── (NUM, 2) 164 | │ │ │ │ │ │ │ │ └── G 165 | │ │ │ │ │ │ │ │ └── epsilon 166 | │ │ │ │ │ │ │ └── D 167 | │ │ │ │ │ │ │ └── epsilon 168 | │ │ │ │ │ │ └── C 169 | │ │ │ │ │ │ └── epsilon 170 | │ │ │ │ │ └── (SYMBOL, ;) 171 | │ │ │ │ └── Statement-list 172 | │ │ │ │ └── epsilon 173 | │ │ │ └── (SYMBOL, }) 174 | │ │ └── Statement-list 175 | │ │ ├── Statement 176 | │ │ │ └── Expression-stmt 177 | │ │ │ ├── Expression 178 | │ │ │ │ ├── (ID, output) 179 | │ │ │ │ └── B 180 | │ │ │ │ └── Simple-expression-prime 181 | │ │ │ │ ├── Additive-expression-prime 182 | │ │ │ │ │ ├── Term-prime 183 | │ │ │ │ │ │ ├── Factor-prime 184 | │ │ │ │ │ │ │ ├── (SYMBOL, () 185 | │ │ │ │ │ │ │ ├── Args 186 | │ │ │ │ │ │ │ │ └── Arg-list 187 | │ │ │ │ │ │ │ │ ├── Expression 188 | │ │ │ │ │ │ │ │ │ ├── (ID, prod) 189 | │ │ │ │ │ │ │ │ │ └── B 190 | │ │ │ │ │ │ │ │ │ └── Simple-expression-prime 191 | │ │ │ │ │ │ │ │ │ ├── Additive-expression-prime 192 | │ │ │ │ │ │ │ │ │ │ ├── Term-prime 193 | │ │ │ │ │ │ │ │ │ │ │ ├── Factor-prime 194 | │ │ │ │ │ │ │ │ │ │ │ │ └── epsilon 195 | │ │ │ │ │ │ │ │ │ │ │ └── G 196 | │ │ │ │ │ │ │ │ │ │ │ └── epsilon 197 | │ │ │ │ │ │ │ │ │ │ └── D 198 | │ │ │ │ │ │ │ │ │ │ └── epsilon 199 | │ │ │ │ │ │ │ │ │ └── C 200 | │ │ │ │ │ │ │ │ │ └── epsilon 201 | │ │ │ │ │ │ │ │ └── Arg-list-prime 202 | │ │ │ │ │ │ │ │ └── epsilon 203 | │ │ │ │ │ │ │ └── (SYMBOL, )) 204 | │ │ │ │ │ │ └── G 205 | │ │ │ │ │ │ └── epsilon 206 | │ │ │ │ │ └── D 207 | │ │ │ │ │ └── epsilon 208 | │ │ │ │ └── C 209 | │ │ │ │ └── epsilon 210 | │ │ │ └── (SYMBOL, ;) 211 | │ │ └── Statement-list 212 | │ │ ├── Statement 213 | │ │ │ └── Return-stmt 214 | │ │ │ ├── (KEYWORD, return) 215 | │ │ │ └── Return-stmt-prime 216 | │ │ │ └── (SYMBOL, ;) 217 | │ │ └── Statement-list 218 | │ │ └── epsilon 219 | │ └── (SYMBOL, }) 220 | └── Declaration-list 221 | └── epsilon 222 | -------------------------------------------------------------------------------- /tests/TX27/syntax_errors.txt: -------------------------------------------------------------------------------- 1 | There is no syntax error. 2 | -------------------------------------------------------------------------------- /tests/TXX28/input.txt: -------------------------------------------------------------------------------- 1 | /*===== nested functions =====*/ 2 | int foo(int a, int b){ 3 | int bar(int a){ 4 | return a + 2; 5 | } 6 | return a + bar(b); 7 | } 8 | void main(void){ 9 | output(foo(1, 10)); 10 | } 11 | -------------------------------------------------------------------------------- /tests/TXX28/output.txt: -------------------------------------------------------------------------------- 1 | 0 (ASSIGN, #0, 500, ) 2 | 1 (JP, 20, , ) 3 | 2 (ASSIGN, #0, 504, ) 4 | 3 (ASSIGN, #0, 508, ) 5 | 4 (ASSIGN, #0, 516, ) 6 | 5 (ASSIGN, #0, 520, ) 7 | 6 (JP, 13, , ) 8 | 7 (ASSIGN, #0, 524, ) 9 | 8 (ASSIGN, #0, 528, ) 10 | 9 (ASSIGN, #0, 536, ) 11 | 10 (ADD, 536, #2, 1000) 12 | 11 (ASSIGN, 1000, 524, ) 13 | 12 (JP, @528, , ) 14 | 13 (ASSIGN, 520, 536, ) 15 | 14 (ASSIGN, #16, 528, ) 16 | 15 (JP, 10, , ) 17 | 16 (ASSIGN, 524, 1004, ) 18 | 17 (ADD, 516, 1004, 1008) 19 | 18 (ASSIGN, 1008, 504, ) 20 | 19 (JP, @508, , ) 21 | 20 (ASSIGN, #0, 540, ) 22 | 21 (ASSIGN, #29, 544, ) 23 | 22 (ASSIGN, #1, 516, ) 24 | 23 (ASSIGN, #10, 520, ) 25 | 24 (ASSIGN, #26, 508, ) 26 | 25 (JP, 6, , ) 27 | 26 (ASSIGN, 504, 1012, ) 28 | 27 (ASSIGN, 1012, 500, ) 29 | 28 (PRINT, 500, , ) 30 | -------------------------------------------------------------------------------- /tests/TXX29/input.txt: -------------------------------------------------------------------------------- 1 | /*=== recursive factorial ====*/ 2 | int factorial ( int n ) 3 | { 4 | int f; 5 | if ( n == 1 )f = 1; 6 | else 7 | f = n * factorial ( n - 1 ); 8 | return f; 9 | } 10 | void main ( void ) 11 | { 12 | output ( factorial (3) ); 13 | } 14 | 15 | -------------------------------------------------------------------------------- /tests/TXX29/output.txt: -------------------------------------------------------------------------------- 1 | 0 (ASSIGN, #83, 1508) 2 | 1 (ASSIGN, #0, 1504) 3 | 2 (ASSIGN, #2000, 1500) 4 | 3 (JP, 62) 5 | 4 (ASSIGN, 1500, 500) 6 | 5 (ADD, 500, #-2000, 500) 7 | 6 (ASSIGN, #1, 504) 8 | 7 (EQ, @500, 504, 508) 9 | 8 (JPF, 508, 14) 10 | 9 (ASSIGN, 1500, 500) 11 | 10 (ADD, 500, #-1988, 500) 12 | 11 (ASSIGN, #1, 504) 13 | 12 (ASSIGN, 504, @500) 14 | 13 (JP, 51) 15 | 14 (ASSIGN, 1500, 500) 16 | 15 (ADD, 500, #-1988, 500) 17 | 16 (ASSIGN, 1500, 504) 18 | 17 (ADD, 504, #-2000, 504) 19 | 18 (ASSIGN, 1500, 512) 20 | 19 (SUB, 512, #1000, 512) 21 | 20 (ASSIGN, 508, @512) 22 | 21 (ASSIGN, 1500, 512) 23 | 22 (SUB, 512, #1004, 512) 24 | 23 (ASSIGN, 500, @512) 25 | 24 (ASSIGN, 1500, 512) 26 | 25 (SUB, 512, #1008, 512) 27 | 26 (ASSIGN, 504, @512) 28 | 27 (ASSIGN, 1500, 512) 29 | 28 (ADD, 512, #-2000, 512) 30 | 29 (ASSIGN, #1, 516) 31 | 30 (SUB, @512, 516, 520) 32 | 31 (ASSIGN, 1500, 512) 33 | 32 (ASSIGN, 520, @512) 34 | 33 (ADD, 1500, #2000, 1500) 35 | 34 (ASSIGN, 1500, 512) 36 | 35 (ADD, 512, #-1996, 512) 37 | 36 (ASSIGN, #38, @512) 38 | 37 (JP, 4) 39 | 38 (ASSIGN, 1504, 512) 40 | 39 (SUB, 1500, #2000, 1500) 41 | 40 (ASSIGN, 1500, 516) 42 | 41 (SUB, 516, #1000, 516) 43 | 42 (ASSIGN, @516, 508) 44 | 43 (ASSIGN, 1500, 516) 45 | 44 (SUB, 516, #1004, 516) 46 | 45 (ASSIGN, @516, 500) 47 | 46 (ASSIGN, 1500, 516) 48 | 47 (SUB, 516, #1008, 516) 49 | 48 (ASSIGN, @516, 504) 50 | 49 (MULT, 512, @504, 516) 51 | 50 (ASSIGN, 516, @500) 52 | 51 (ASSIGN, 1500, 500) 53 | 52 (ADD, 500, #-1988, 500) 54 | 53 (ASSIGN, @500, 1504) 55 | 54 (ASSIGN, 1500, 500) 56 | 55 (ADD, 500, #-1996, 500) 57 | 56 (ASSIGN, @500, 500) 58 | 57 (JP, @500) 59 | 58 (ASSIGN, 1500, 500) 60 | 59 (ADD, 500, #-1996, 500) 61 | 60 (ASSIGN, @500, 500) 62 | 61 (JP, @500) 63 | 62 (ASSIGN, #3, 500) 64 | 63 (ASSIGN, 1500, 504) 65 | 64 (ASSIGN, 500, @504) 66 | 65 (ADD, 1500, #2000, 1500) 67 | 66 (ASSIGN, 1500, 500) 68 | 67 (ADD, 500, #-1996, 500) 69 | 68 (ASSIGN, #70, @500) 70 | 69 (JP, 4) 71 | 70 (ASSIGN, 1504, 500) 72 | 71 (SUB, 1500, #2000, 1500) 73 | 72 (ASSIGN, 1500, 504) 74 | 73 (ASSIGN, 500, @504) 75 | 74 (ADD, 1500, #2000, 1500) 76 | 75 (ASSIGN, 1500, 500) 77 | 76 (ADD, 500, #-1996, 500) 78 | 77 (ASSIGN, #79, @500) 79 | 78 (ASSIGN, 1500, 500) 80 | 79 (ADD, 500, #-2000, 500) 81 | 80 (PRINT, @500) 82 | 81 (ASSIGN, 1504, 500) 83 | 82 (SUB, 1500, #2000, 1500) 84 | 83 (ADD, 1500, 1500, 1500) 85 | -------------------------------------------------------------------------------- /tests/TXX30/input.txt: -------------------------------------------------------------------------------- 1 | /* test case */ 2 | void main(void){ 3 | int prod; 4 | int i; 5 | prod = 1; 6 | i = 1; 7 | while(i < 7){ 8 | prod = i * prod ; 9 | i = i + 2; 10 | } 11 | output(prod); 12 | return; 13 | 14 | } 15 | -------------------------------------------------------------------------------- /tests/TXX30/output.txt: -------------------------------------------------------------------------------- 1 | 0 (ASSIGN, #0, 500, ) 2 | 1 (ASSIGN, #0, 504, ) 3 | 2 (ASSIGN, #19, 508, ) 4 | 3 (ASSIGN, #0, 516, ) 5 | 4 (ASSIGN, #0, 520, ) 6 | 5 (ASSIGN, #1, 516, ) 7 | 6 (ASSIGN, #1, 520, ) 8 | 7 (JP, 9, , ) 9 | 8 (JP, 16, , ) 10 | 9 (LT, 520, #7, 1000) 11 | 10 (JPF, 1000, 16, ) 12 | 11 (MULT, 516, 520, 1004) 13 | 12 (ASSIGN, 1004, 516, ) 14 | 13 (ADD, 520, #2, 1008) 15 | 14 (ASSIGN, 1008, 520, ) 16 | 15 (JP, 9, , ) 17 | 16 (ASSIGN, 516, 500, ) 18 | 17 (PRINT, 500, , ) 19 | 18 (JP, @508, , ) 20 | -------------------------------------------------------------------------------- /tests/TXX31/input.txt: -------------------------------------------------------------------------------- 1 | /*==== expressions/relop =====*/ 2 | void main(void){ 3 | int a; 4 | int b; 5 | a = 10 * 2 + 3 * (1 < 0); 6 | b = (a == 5) * 4 + 3; 7 | output(a); 8 | output(b); 9 | } 10 | -------------------------------------------------------------------------------- /tests/TXX31/output.txt: -------------------------------------------------------------------------------- 1 | 0 (ASSIGN, #0, 500, ) 2 | 1 (ASSIGN, #0, 504, ) 3 | 2 (ASSIGN, #18, 508, ) 4 | 3 (ASSIGN, #0, 516, ) 5 | 4 (ASSIGN, #0, 520, ) 6 | 5 (MULT, #2, #10, 1000) 7 | 6 (LT, #1, #0, 1004) 8 | 7 (MULT, 1004, #3, 1008) 9 | 8 (ADD, 1000, 1008, 1012) 10 | 9 (ASSIGN, 1012, 516, ) 11 | 10 (EQ, 516, #5, 1016) 12 | 11 (MULT, #4, 1016, 1020) 13 | 12 (ADD, 1020, #3, 1024) 14 | 13 (ASSIGN, 1024, 520, ) 15 | 14 (ASSIGN, 516, 500, ) 16 | 15 (PRINT, 500, , ) 17 | 16 (ASSIGN, 520, 500, ) 18 | 17 (PRINT, 500, , ) 19 | -------------------------------------------------------------------------------- /tests/TXX32/input.txt: -------------------------------------------------------------------------------- 1 | /*===== if else =====*/ 2 | int foo(int x){ 3 | if (x < 0){ 4 | output(x); 5 | return 1; 6 | } 7 | else { 8 | output(x); 9 | return x + 2; 10 | } 11 | } 12 | void main(void){ 13 | int i; 14 | i= foo(0); 15 | output(i); 16 | i=foo(10); 17 | output(i); 18 | } 19 | -------------------------------------------------------------------------------- /tests/TXX32/output.txt: -------------------------------------------------------------------------------- 1 | 0 (ASSIGN, #0, 500, ) 2 | 1 (JP, 17, , ) 3 | 2 (ASSIGN, #0, 504, ) 4 | 3 (ASSIGN, #0, 508, ) 5 | 4 (ASSIGN, #0, 516, ) 6 | 5 (LT, 516, #0, 1000) 7 | 6 (JPF, 1000, 12, ) 8 | 7 (ASSIGN, 516, 500, ) 9 | 8 (PRINT, 500, , ) 10 | 9 (ASSIGN, #1, 504, ) 11 | 10 (JP, @508, , ) 12 | 11 (JP, 17, , ) 13 | 12 (ASSIGN, 516, 500, ) 14 | 13 (PRINT, 500, , ) 15 | 14 (ADD, 516, #2, 1004) 16 | 15 (ASSIGN, 1004, 504, ) 17 | 16 (JP, @508, , ) 18 | 17 (ASSIGN, #0, 520, ) 19 | 18 (ASSIGN, #34, 524, ) 20 | 19 (ASSIGN, #0, 532, ) 21 | 20 (ASSIGN, #0, 516, ) 22 | 21 (ASSIGN, #23, 508, ) 23 | 22 (JP, 5, , ) 24 | 23 (ASSIGN, 504, 1008, ) 25 | 24 (ASSIGN, 1008, 532, ) 26 | 25 (ASSIGN, 532, 500, ) 27 | 26 (PRINT, 500, , ) 28 | 27 (ASSIGN, #10, 516, ) 29 | 28 (ASSIGN, #30, 508, ) 30 | 29 (JP, 5, , ) 31 | 30 (ASSIGN, 504, 1012, ) 32 | 31 (ASSIGN, 1012, 532, ) 33 | 32 (ASSIGN, 532, 500, ) 34 | 33 (PRINT, 500, , ) 35 | -------------------------------------------------------------------------------- /tests/TXX33/input.txt: -------------------------------------------------------------------------------- 1 | int a; 2 | int b; 3 | 4 | void main(void) { 5 | int c; 6 | int d; 7 | a = c = 1; 8 | d = b = 3; 9 | output(a); 10 | output(b); 11 | c = a * 17 < 15 + 3; 12 | output(c); 13 | output(d < 3); 14 | output(d - 8 < 3); 15 | output(1 * 2); 16 | 17 | 18 | } 19 | -------------------------------------------------------------------------------- /tests/TXX33/output.txt: -------------------------------------------------------------------------------- 1 | 0 (ASSIGN, #0, 500, ) 2 | 1 (ASSIGN, #0, 504, ) 3 | 2 (ASSIGN, #0, 508, ) 4 | 3 (ASSIGN, #0, 512, ) 5 | 4 (ASSIGN, #31, 516, ) 6 | 5 (ASSIGN, #0, 524, ) 7 | 6 (ASSIGN, #0, 528, ) 8 | 7 (ASSIGN, #1, 524, ) 9 | 8 (ASSIGN, 524, 504, ) 10 | 9 (ASSIGN, #3, 508, ) 11 | 10 (ASSIGN, 508, 528, ) 12 | 11 (ASSIGN, 504, 500, ) 13 | 12 (PRINT, 500, , ) 14 | 13 (ASSIGN, 508, 500, ) 15 | 14 (PRINT, 500, , ) 16 | 15 (MULT, #17, 504, 1000) 17 | 16 (ADD, #15, #3, 1004) 18 | 17 (LT, 1000, 1004, 1008) 19 | 18 (ASSIGN, 1008, 524, ) 20 | 19 (ASSIGN, 524, 500, ) 21 | 20 (PRINT, 500, , ) 22 | 21 (LT, 528, #3, 1012) 23 | 22 (ASSIGN, 1012, 500, ) 24 | 23 (PRINT, 500, , ) 25 | 24 (SUB, 528, #8, 1016) 26 | 25 (LT, 1016, #3, 1020) 27 | 26 (ASSIGN, 1020, 500, ) 28 | 27 (PRINT, 500, , ) 29 | 28 (MULT, #2, #1, 1024) 30 | 29 (ASSIGN, 1024, 500, ) 31 | 30 (PRINT, 500, , ) 32 | -------------------------------------------------------------------------------- /tests/TXX34/input.txt: -------------------------------------------------------------------------------- 1 | /*==== return in conditionals =====*/ 2 | int foo(int x){ 3 | int a; 4 | a = 10; 5 | output(x); 6 | if(a < x){ 7 | return(1); 8 | } 9 | else { 10 | return(2); 11 | } 12 | } 13 | void main ( void ) 14 | { 15 | int i; 16 | i = foo (4) ; 17 | output (i); 18 | } 19 | 20 | -------------------------------------------------------------------------------- /tests/TXX34/output.txt: -------------------------------------------------------------------------------- 1 | 0 (ASSIGN, #0, 500, ) 2 | 1 (JP, 16, , ) 3 | 2 (ASSIGN, #0, 504, ) 4 | 3 (ASSIGN, #0, 508, ) 5 | 4 (ASSIGN, #0, 516, ) 6 | 5 (ASSIGN, #0, 520, ) 7 | 6 (ASSIGN, #10, 520, ) 8 | 7 (ASSIGN, 516, 500, ) 9 | 8 (PRINT, 500, , ) 10 | 9 (LT, 520, 516, 1000) 11 | 10 (JPF, 1000, 14, ) 12 | 11 (ASSIGN, #1, 504, ) 13 | 12 (JP, @508, , ) 14 | 13 (JP, 16, , ) 15 | 14 (ASSIGN, #2, 504, ) 16 | 15 (JP, @508, , ) 17 | 16 (ASSIGN, #0, 524, ) 18 | 17 (ASSIGN, #26, 528, ) 19 | 18 (ASSIGN, #0, 536, ) 20 | 19 (ASSIGN, #4, 516, ) 21 | 20 (ASSIGN, #22, 508, ) 22 | 21 (JP, 5, , ) 23 | 22 (ASSIGN, 504, 1004, ) 24 | 23 (ASSIGN, 1004, 536, ) 25 | 24 (ASSIGN, 536, 500, ) 26 | 25 (PRINT, 500, , ) 27 | -------------------------------------------------------------------------------- /tests/TXX35/input.txt: -------------------------------------------------------------------------------- 1 | /*===== switch case =====*/ 2 | void foo(int x){ 3 | switch(x){ 4 | case 0: 5 | output(1); 6 | case 1: 7 | output(2); 8 | break; 9 | case 3: 10 | output(3); 11 | break; 12 | default: 13 | output(4); 14 | } 15 | } 16 | void main ( void ) 17 | { 18 | foo (3) ; 19 | } 20 | 21 | -------------------------------------------------------------------------------- /tests/TXX35/output.txt: -------------------------------------------------------------------------------- 1 | 0 (ASSIGN, #0, 500, ) 2 | 1 (JP, 24, , ) 3 | 2 (ASSIGN, #0, 504, ) 4 | 3 (ASSIGN, #0, 508, ) 5 | 4 (ASSIGN, #0, 516, ) 6 | 5 (JP, 7, , ) 7 | 6 (JP, 23, , ) 8 | 7 (EQ, #0, 516, 1000) 9 | 8 (JPF, 1000, 11, ) 10 | 9 (ASSIGN, #1, 500, ) 11 | 10 (PRINT, 500, , ) 12 | 11 (EQ, #1, 516, 1004) 13 | 12 (JPF, 1004, 16, ) 14 | 13 (ASSIGN, #2, 500, ) 15 | 14 (PRINT, 500, , ) 16 | 15 (JP, 6, , ) 17 | 16 (EQ, #3, 516, 1008) 18 | 17 (JPF, 1008, 21, ) 19 | 18 (ASSIGN, #3, 500, ) 20 | 19 (PRINT, 500, , ) 21 | 20 (JP, 6, , ) 22 | 21 (ASSIGN, #4, 500, ) 23 | 22 (PRINT, 500, , ) 24 | 23 (JP, @508, , ) 25 | 24 (ASSIGN, #0, 520, ) 26 | 25 (ASSIGN, #29, 524, ) 27 | 26 (ASSIGN, #3, 516, ) 28 | 27 (ASSIGN, #29, 508, ) 29 | 28 (JP, 5, , ) 30 | -------------------------------------------------------------------------------- /tests/TXX36/input.txt: -------------------------------------------------------------------------------- 1 | /*=== Hard == */ 2 | int abs(int a) { 3 | if (a < 0) { 4 | return 0-a; 5 | } else { 6 | return a; 7 | } 8 | } 9 | 10 | int isMultiplier(int a, int b) { 11 | int i; 12 | int step; 13 | int flag; 14 | 15 | if (b == 0) { 16 | return 0; 17 | } else { 18 | i = 1; 19 | flag = 0; 20 | } 21 | 22 | if (a < 0) { 23 | if (b < 0) { 24 | i = 1; 25 | } else { 26 | i = 0-1; 27 | } 28 | } else { 29 | if (b < 0) { 30 | i = 0-1; 31 | } else { 32 | i = 1; 33 | } 34 | } 35 | 36 | step = i; 37 | i = i - abs(i); 38 | while (abs(i) < abs(a) + 1) { 39 | if (i * b == a) { 40 | flag = 1; 41 | break; 42 | } else { 43 | i = i + step; 44 | continue; 45 | } 46 | } 47 | return flag; 48 | 49 | } 50 | 51 | 52 | void main(void) { 53 | int i; 54 | int j; 55 | int sum; 56 | i = 1; 57 | j = 1; 58 | while (i < 11) { 59 | sum = 0; 60 | j = 0; 61 | while (j < i) { 62 | j = j + 1; 63 | if (isMultiplier(j, 2)) { 64 | sum = sum + 0; 65 | } else { 66 | sum = sum + j; 67 | } 68 | } 69 | output(sum); 70 | i = i + 1; 71 | 72 | } 73 | 74 | } 75 | -------------------------------------------------------------------------------- /tests/TXX36/output.txt: -------------------------------------------------------------------------------- 1 | 0 (ASSIGN, #0, 500, ) 2 | 1 (JP, 13, , ) 3 | 2 (ASSIGN, #0, 504, ) 4 | 3 (ASSIGN, #0, 508, ) 5 | 4 (ASSIGN, #0, 516, ) 6 | 5 (LT, 516, #0, 1000) 7 | 6 (JPF, 1000, 11, ) 8 | 7 (SUB, #0, 516, 1004) 9 | 8 (ASSIGN, 1004, 504, ) 10 | 9 (JP, @508, , ) 11 | 10 (JP, 13, , ) 12 | 11 (ASSIGN, 516, 504, ) 13 | 12 (JP, @508, , ) 14 | 13 (JP, 75, , ) 15 | 14 (ASSIGN, #0, 520, ) 16 | 15 (ASSIGN, #0, 524, ) 17 | 16 (ASSIGN, #0, 532, ) 18 | 17 (ASSIGN, #0, 536, ) 19 | 18 (ASSIGN, #0, 540, ) 20 | 19 (ASSIGN, #0, 544, ) 21 | 20 (ASSIGN, #0, 548, ) 22 | 21 (EQ, 536, #0, 1008) 23 | 22 (JPF, 1008, 26, ) 24 | 23 (ASSIGN, #0, 520, ) 25 | 24 (JP, @524, , ) 26 | 25 (JP, 28, , ) 27 | 26 (ASSIGN, #1, 540, ) 28 | 27 (ASSIGN, #0, 548, ) 29 | 28 (LT, 532, #0, 1012) 30 | 29 (JPF, 1012, 37, ) 31 | 30 (LT, 536, #0, 1016) 32 | 31 (JPF, 1016, 34, ) 33 | 32 (ASSIGN, #1, 540, ) 34 | 33 (JP, 36, , ) 35 | 34 (SUB, #0, #1, 1020) 36 | 35 (ASSIGN, 1020, 540, ) 37 | 36 (JP, 43, , ) 38 | 37 (LT, 536, #0, 1024) 39 | 38 (JPF, 1024, 42, ) 40 | 39 (SUB, #0, #1, 1028) 41 | 40 (ASSIGN, 1028, 540, ) 42 | 41 (JP, 43, , ) 43 | 42 (ASSIGN, #1, 540, ) 44 | 43 (ASSIGN, 540, 544, ) 45 | 44 (ASSIGN, 540, 516, ) 46 | 45 (ASSIGN, #47, 508, ) 47 | 46 (JP, 5, , ) 48 | 47 (ASSIGN, 504, 1032, ) 49 | 48 (SUB, 540, 1032, 1036) 50 | 49 (ASSIGN, 1036, 540, ) 51 | 50 (JP, 52, , ) 52 | 51 (JP, 73, , ) 53 | 52 (ASSIGN, 540, 516, ) 54 | 53 (ASSIGN, #55, 508, ) 55 | 54 (JP, 5, , ) 56 | 55 (ASSIGN, 504, 1040, ) 57 | 56 (ASSIGN, 532, 516, ) 58 | 57 (ASSIGN, #59, 508, ) 59 | 58 (JP, 5, , ) 60 | 59 (ASSIGN, 504, 1044, ) 61 | 60 (ADD, 1044, #1, 1048) 62 | 61 (LT, 1040, 1048, 1052) 63 | 62 (JPF, 1052, 73, ) 64 | 63 (MULT, 536, 540, 1056) 65 | 64 (EQ, 1056, 532, 1060) 66 | 65 (JPF, 1060, 69, ) 67 | 66 (ASSIGN, #1, 548, ) 68 | 67 (JP, 51, , ) 69 | 68 (JP, 72, , ) 70 | 69 (ADD, 540, 544, 1064) 71 | 70 (ASSIGN, 1064, 540, ) 72 | 71 (JP, 52, , ) 73 | 72 (JP, 52, , ) 74 | 73 (ASSIGN, 548, 520, ) 75 | 74 (JP, @524, , ) 76 | 75 (ASSIGN, #0, 552, ) 77 | 76 (ASSIGN, #111, 556, ) 78 | 77 (ASSIGN, #0, 564, ) 79 | 78 (ASSIGN, #0, 568, ) 80 | 79 (ASSIGN, #0, 572, ) 81 | 80 (ASSIGN, #1, 564, ) 82 | 81 (ASSIGN, #1, 568, ) 83 | 82 (JP, 84, , ) 84 | 83 (JP, 111, , ) 85 | 84 (LT, 564, #11, 1068) 86 | 85 (JPF, 1068, 111, ) 87 | 86 (ASSIGN, #0, 572, ) 88 | 87 (ASSIGN, #0, 568, ) 89 | 88 (JP, 90, , ) 90 | 89 (JP, 106, , ) 91 | 90 (LT, 568, 564, 1072) 92 | 91 (JPF, 1072, 106, ) 93 | 92 (ADD, 568, #1, 1076) 94 | 93 (ASSIGN, 1076, 568, ) 95 | 94 (ASSIGN, 568, 532, ) 96 | 95 (ASSIGN, #2, 536, ) 97 | 96 (ASSIGN, #98, 524, ) 98 | 97 (JP, 18, , ) 99 | 98 (ASSIGN, 520, 1080, ) 100 | 99 (JPF, 1080, 103, ) 101 | 100 (ADD, 572, #0, 1084) 102 | 101 (ASSIGN, 1084, 572, ) 103 | 102 (JP, 105, , ) 104 | 103 (ADD, 572, 568, 1088) 105 | 104 (ASSIGN, 1088, 572, ) 106 | 105 (JP, 90, , ) 107 | 106 (ASSIGN, 572, 500, ) 108 | 107 (PRINT, 500, , ) 109 | 108 (ADD, 564, #1, 1092) 110 | 109 (ASSIGN, 1092, 564, ) 111 | 110 (JP, 84, , ) 112 | -------------------------------------------------------------------------------- /tests/TXX37/input.txt: -------------------------------------------------------------------------------- 1 | void printArray(int A[], int size) 2 | { 3 | int i; 4 | i = 0; 5 | while(i < size){ 6 | output(A[i]); 7 | i = i + 1; 8 | } 9 | } 10 | 11 | void main(void) 12 | { 13 | int arr[20]; 14 | int arrsize; 15 | int i; 16 | int j; 17 | arrsize = 20; 18 | i = 0; 19 | while(i < arrsize){ 20 | j = 0; 21 | arr[i] = 2; 22 | while (j < i) { 23 | arr[i] = arr[i] * 2; 24 | j = j + 1; 25 | } 26 | i = i + 1; 27 | } 28 | 29 | printArray(arr, arrsize); 30 | } 31 | -------------------------------------------------------------------------------- /tests/TXX37/output.txt: -------------------------------------------------------------------------------- 1 | 0 (ASSIGN, #0, 500, ) 2 | 1 (JP, 20, , ) 3 | 2 (ASSIGN, #0, 504, ) 4 | 3 (ASSIGN, #0, 508, ) 5 | 4 (ASSIGN, #0, 516, ) 6 | 5 (ASSIGN, #0, 520, ) 7 | 6 (ASSIGN, #0, 524, ) 8 | 7 (ASSIGN, #0, 524, ) 9 | 8 (JP, 10, , ) 10 | 9 (JP, 19, , ) 11 | 10 (LT, 524, 520, 1000) 12 | 11 (JPF, 1000, 19, ) 13 | 12 (MULT, #4, 524, 1004) 14 | 13 (ADD, 1004, 516, 1008) 15 | 14 (ASSIGN, @1008, 500, ) 16 | 15 (PRINT, 500, , ) 17 | 16 (ADD, 524, #1, 1012) 18 | 17 (ASSIGN, 1012, 524, ) 19 | 18 (JP, 10, , ) 20 | 19 (JP, @508, , ) 21 | 20 (ASSIGN, #0, 528, ) 22 | 21 (ASSIGN, #76, 532, ) 23 | 22 (ASSIGN, #540, 620, ) 24 | 23 (ASSIGN, #0, 540, ) 25 | 24 (ASSIGN, #0, 544, ) 26 | 25 (ASSIGN, #0, 548, ) 27 | 26 (ASSIGN, #0, 552, ) 28 | 27 (ASSIGN, #0, 556, ) 29 | 28 (ASSIGN, #0, 560, ) 30 | 29 (ASSIGN, #0, 564, ) 31 | 30 (ASSIGN, #0, 568, ) 32 | 31 (ASSIGN, #0, 572, ) 33 | 32 (ASSIGN, #0, 576, ) 34 | 33 (ASSIGN, #0, 580, ) 35 | 34 (ASSIGN, #0, 584, ) 36 | 35 (ASSIGN, #0, 588, ) 37 | 36 (ASSIGN, #0, 592, ) 38 | 37 (ASSIGN, #0, 596, ) 39 | 38 (ASSIGN, #0, 600, ) 40 | 39 (ASSIGN, #0, 604, ) 41 | 40 (ASSIGN, #0, 608, ) 42 | 41 (ASSIGN, #0, 612, ) 43 | 42 (ASSIGN, #0, 616, ) 44 | 43 (ASSIGN, #0, 624, ) 45 | 44 (ASSIGN, #0, 628, ) 46 | 45 (ASSIGN, #0, 632, ) 47 | 46 (ASSIGN, #20, 624, ) 48 | 47 (ASSIGN, #0, 628, ) 49 | 48 (JP, 50, , ) 50 | 49 (JP, 72, , ) 51 | 50 (LT, 628, 624, 1016) 52 | 51 (JPF, 1016, 72, ) 53 | 52 (ASSIGN, #0, 632, ) 54 | 53 (MULT, #4, 628, 1020) 55 | 54 (ADD, 1020, 620, 1024) 56 | 55 (ASSIGN, #2, @1024, ) 57 | 56 (JP, 58, , ) 58 | 57 (JP, 69, , ) 59 | 58 (LT, 632, 628, 1028) 60 | 59 (JPF, 1028, 69, ) 61 | 60 (MULT, #4, 628, 1032) 62 | 61 (ADD, 1032, 620, 1036) 63 | 62 (MULT, #4, 628, 1040) 64 | 63 (ADD, 1040, 620, 1044) 65 | 64 (MULT, #2, @1044, 1048) 66 | 65 (ASSIGN, 1048, @1036, ) 67 | 66 (ADD, 632, #1, 1052) 68 | 67 (ASSIGN, 1052, 632, ) 69 | 68 (JP, 58, , ) 70 | 69 (ADD, 628, #1, 1056) 71 | 70 (ASSIGN, 1056, 628, ) 72 | 71 (JP, 50, , ) 73 | 72 (ASSIGN, 620, 516, ) 74 | 73 (ASSIGN, 624, 520, ) 75 | 74 (ASSIGN, #76, 508, ) 76 | 75 (JP, 6, , ) 77 | -------------------------------------------------------------------------------- /tests/TXX38/input.txt: -------------------------------------------------------------------------------- 1 | void main(void) 2 | { 3 | int i; int j; 4 | int a; int N; 5 | i = 0-1; 6 | a = 1; 7 | j = 1; 8 | N = 50; // prints this many even numbers xd 9 | while (j < 2 * N + 1) { 10 | a = a * i; 11 | if (a < 0) { 12 | } else { 13 | output(j); 14 | } 15 | j = j + 1; 16 | } 17 | } 18 | 19 | -------------------------------------------------------------------------------- /tests/TXX38/output.txt: -------------------------------------------------------------------------------- 1 | 0 (ASSIGN, #1, 500, ) 2 | 1 (PRINT, 500, , ) 3 | --------------------------------------------------------------------------------