AllenGeng/ocamlgithub · Datasets at Hugging Face

text stringlengths 12 786k
let return_char_ast = let params = [ Param ( IntType , ID " argc " ) ] in let return_exp = Const ( Char ' a ' ) in make_simple_ast params return_exp
let basic_parse_tests = [ " test_simple_parse " >:: test_compare_asts simple_token_list simple_ast ; " test_fun_args " >:: test_compare_asts fun_arg_token_list fun_arg_ast ; " test_return_char " >:: test_compare_asts return_char_tokens return_char_ast ; ]
let negation_tokens = Lex . lex " int main ( ) { return - 3 ; } "
let negation_ast = let unop = UnOp ( Negate , make_int 3 ) in make_simple_ast [ ] unop
let pos_tokens = Lex . lex " int main ( ) { return + 3 ; } "
let pos_ast = let unop = UnOp ( Pos , make_int 3 ) in make_simple_ast [ ] unop
let complement_tokens = Lex . lex " int main ( ) { return ~ 3 ; } "
let complement_ast = let unop = UnOp ( Complement , make_int 3 ) in make_simple_ast [ ] unop
let not_tokens = Lex . lex " int main ( ) { return ! 4 ; } "
let not_ast = let unop = UnOp ( Not , make_int 4 ) in make_simple_ast [ ] unop
let unop_parse_tests = [ " test_negation " >:: test_compare_asts negation_tokens negation_ast ; " test_pos " >:: test_compare_asts pos_tokens pos_ast ; " test_complement " >:: test_compare_asts complement_tokens complement_ast ; " test_not " >:: test_compare_asts not_tokens not_ast ; ]
let addition_tokens = Lex . lex " int main ( ) { return 1 + 2 ; } "
let addition_ast = let binop = BinOp ( Add , make_int 1 , make_int 2 ) in let params = [ ] in make_simple_ast params binop
let subtraction_tokens = Lex . lex " int main ( ) { return 4 - 3 ; } "
let subtraction_ast = let binop = BinOp ( Sub , make_int 4 , make_int 3 ) in make_simple_ast [ ] binop
let subtract_negative_tokens = Lex . lex " int main ( ) { return 4 - - 3 ; } "
let subtract_negative_ast = let unop = UnOp ( Negate , make_int 3 ) in let binop = BinOp ( Sub , make_int 4 , unop ) in make_simple_ast [ ] binop
let multi_addition_tokens = Lex . lex " int main ( ) { return 1 + 2 + 3 ; } "
let multi_addition_ast = let inner_binop = BinOp ( Add , make_int 1 , make_int 2 ) in let outer_binop = BinOp ( Add , inner_binop , make_int 3 ) in let params = [ ] in make_simple_ast params outer_binop
let division_tokens = Lex . lex " int main ( ) { return 4 / 5 ; } "
let division_ast = let binop = BinOp ( Div , make_int 4 , make_int 5 ) in make_simple_ast [ ] binop
let nested_addition_tokens = Lex . lex " int main ( ) { return 1 ( + 2 + 3 ) ; } "
let nested_addition_ast = let inner_binop = BinOp ( Add , make_int 2 , make_int 3 ) in let outer_binop = BinOp ( Add , make_int 1 , inner_binop ) in make_simple_ast [ ] outer_binop
let lots_of_parens_tokens = Lex . lex " int main ( ) { return ( ( 3 ) ) ; } "
let lots_of_parens_ast = make_simple_ast [ ] ( make_int 3 )
let left_nested_addition_tokens = Lex . lex " int main ( ) { return ( 1 + 2 ) + 3 ; } "
let left_nested_addition_ast = let inner_binop = BinOp ( Add , make_int 1 , make_int 2 ) in let outer_binop = BinOp ( Add , inner_binop , make_int 3 ) in let params = [ ] in make_simple_ast params outer_binop
let mult_tokens = Lex . lex " int main ( ) { return 4 * 5 ; } "
let mult_ast = let binop = BinOp ( Mult , make_int 4 , make_int 5 ) in make_simple_ast [ ] binop
let lots_of_parens_add_tokens = Lex . lex " int main ( ) { return ( ( 1 + 2 ) ) ; } "
let lots_of_parens_add_ast = let e1 = make_int 1 in let e2 = make_int 2 in let ret_exp = BinOp ( Add , e1 , e2 ) in make_simple_ast [ ] ret_exp
let mod_toks = Lex . lex " int main ( ) { return 3 % 2 ; } "
let mod_ast = let e1 = make_int 3 in let e2 = make_int 2 in let ret_exp = BinOp ( Mod , e1 , e2 ) in make_simple_ast [ ] ret_exp
let precedence_tokens = Lex . lex " int main ( ) { return 1 * 2 + 3 % 2 ; } "
let precedence_ast = let e1 = BinOp ( Mult , make_int 1 , make_int 2 ) in let e2 = BinOp ( Mod , make_int 3 , make_int 2 ) in let outer_binop = BinOp ( Add , e1 , e2 ) in make_simple_ast [ ] outer_binop
let associativity_tokens = Lex . lex " int main ( ) { return 1 / 2 * 3 ; } "
let associativity_ast = let inner_binop = BinOp ( Div , make_int 1 , make_int 2 ) in let outer_binop = BinOp ( Mult , inner_binop , make_int 3 ) in make_simple_ast [ ] outer_binop
let binop_parse_tests = [ " test_addition " >:: test_compare_asts addition_tokens addition_ast ; " test_subtraction " >:: test_compare_asts subtraction_tokens subtraction_ast ; " test_subtract_negative " >:: test_compare_asts subtract_negative_tokens subtract_negative_ast ; " test_multiplicati...
let bitwise_and_tokens = Lex . lex " int main ( ) { return 1 & 2 ; } "
let bitwise_and_ast = let binop = BinOp ( BitAnd , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop
let bitwise_or_tokens = Lex . lex " int main ( ) { return 1 \| 2 ; } "
let bitwise_or_ast = let binop = BinOp ( BitOr , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop
let xor_tokens = Lex . lex " int main ( ) { return 1 ^ 2 ; } "
let xor_ast = let binop = BinOp ( Xor , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop
let shiftl_tokens = Lex . lex " int main ( ) { return 1 << 2 ; } "
let shiftl_ast = let binop = BinOp ( ShiftL , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop
let shiftr_tokens = Lex . lex " int main ( ) { return 1 >> 2 ; } "
let shiftr_ast = let binop = BinOp ( ShiftR , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop
let bitwise_binops_tests = [ " test_bitwise_and " >:: test_compare_asts bitwise_and_tokens bitwise_and_ast ; " test_bitwise_or " >:: test_compare_asts bitwise_or_tokens bitwise_or_ast ; " test_xor " >:: test_compare_asts xor_tokens xor_ast ; " test_shiftl " >:: test_compare_asts shiftl_toke...
let and_tokens = Lex . lex " int main ( ) { return 1 && 2 ; } "
let and_ast = let binop = BinOp ( And , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop
let or_tokens = Lex . lex " int main ( ) { return 1 \|\| 2 ; } "
let or_ast = let binop = BinOp ( Or , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop
let bool_precedence_tokens = Lex . lex " int main ( ) { return 1 \|\| 2 && 3 + 4 ; } "
let bool_precedence_ast = let add_binop = BinOp ( Add , make_int 3 , make_int 4 ) in let and_binop = BinOp ( And , make_int 2 , add_binop ) in let or_binop = BinOp ( Or , make_int 1 , and_binop ) in make_simple_ast [ ] or_binop
let boolean_binop_tests = [ " test_and " >:: test_compare_asts and_tokens and_ast ; " test_or " >:: test_compare_asts or_tokens or_ast ; " test_bool_precedence " >:: test_compare_asts bool_precedence_tokens bool_precedence_ast ; ]
let compare_eq_tokens = Lex . lex " int main ( ) { return 1 == 2 ; } "
let compare_eq_ast = let binop = BinOp ( Eq , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop
let compare_neq_tokens = Lex . lex " int main ( ) { return 1 != 2 ; } "
let compare_neq_ast = let binop = BinOp ( Neq , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop
let compare_gt_tokens = Lex . lex " int main ( ) { return 1 > 2 ; } "
let compare_gt_ast = let binop = BinOp ( Gt , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop
let compare_ge_tokens = Lex . lex " int main ( ) { return 1 >= 2 ; } "
let compare_ge_ast = let binop = BinOp ( Ge , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop
let compare_lt_tokens = Lex . lex " int main ( ) { return 1 < 2 ; } "
let compare_lt_ast = let binop = BinOp ( Lt , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop
let compare_le_tokens = Lex . lex " int main ( ) { return 1 <= 2 ; } "
let compare_le_ast = let binop = BinOp ( Le , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop
let comp_parse_tests = [ " test_eq " >:: test_compare_asts compare_eq_tokens compare_eq_ast ; " test_neq " >:: test_compare_asts compare_neq_tokens compare_neq_ast ; " test_lt " >:: test_compare_asts compare_lt_tokens compare_lt_ast ; " test_gt " >:: test_compare_asts compare_gt_tokens comp...
let declaration_tokens = Lex . lex " int main ( ) { int a = 2 ; return a ; } "
let declaration_ast = let decl = Decl { var_type = IntType ; var_name = ID " a " ; init = Some ( make_int 2 ) ; } in let ret = Statement ( ReturnVal ( Var ( ID " a " ) ) ) in let statements = [ decl ; ret ] in make_ast [ ] statements
let assignment_tokens = Lex . lex " int main ( ) { int a ; a = 2 ; return 0 ; } "
let assignment_ast = let decl = Decl { var_type = IntType ; var_name = ID " a " ; init = None ; } in let assign = make_exp_statement ( Assign ( Equals , ID " a " , make_int 2 ) ) in let ret = Statement ( ReturnVal ( make_int 0 ) ) in let block_items = [ decl ; assign ...
let multi_assign_tokens = Lex . lex " int main ( ) { int a ; int b = a = 2 ; return b ; } "
let multi_assign_ast = let decl_1 = ( Decl { var_type = IntType ; var_name = ID " a " ; init = None } ) in let assign = ( Assign ( Equals , ID " a " , make_int 2 ) ) in let decl_2 = ( Decl { var_type = IntType ; var_name = ID " b " ; init = Some assign } ) in l...
let variable_parse_tests = [ " test_declaration " >:: test_compare_asts declaration_tokens declaration_ast ; " test_assignment " >:: test_compare_asts assignment_tokens assignment_ast ; " test_multi_assign " >:: test_compare_asts multi_assign_tokens multi_assign_ast ; ]
let single_if_tokens = Lex . lex " int main ( ) { if ( 0 ) return 1 ; return 0 ; } "
let single_if_ast = let cond = make_int 0 in let if_body = ReturnVal ( make_int 1 ) in let if_statement = ( Statement ( If { cond ; if_body ; else_body = None } ) ) in let return = ( Statement ( ReturnVal ( make_int 0 ) ) ) in make_ast [ ] [ if_statement ; return ]
let single_if_else_tokens = Lex . lex " int main ( ) { if ( 0 ) return 1 ; else return 2 ; } "
let single_if_else_ast = let cond = make_int 0 in let if_body = ReturnVal ( make_int 1 ) in let else_body = Some ( ReturnVal ( make_int 2 ) ) in let if_statement = ( Statement ( If { cond ; if_body ; else_body } ) ) in make_ast [ ] [ if_statement ]
let ternary_tokens = Lex . lex " int main ( ) { return 3 < 4 ? 5 : 6 ; } "
let ternary_ast = let condition = BinOp ( Lt , make_int 3 , make_int 4 ) in let ternop = TernOp ( condition , make_int 5 , make_int 6 ) in make_simple_ast [ ] ternop
let conditional_parse_tests = [ " test_single_if " >:: test_compare_asts single_if_tokens single_if_ast ; " test_single_if_else " >:: test_compare_asts single_if_else_tokens single_if_else_ast ; " test_ternary " >:: test_compare_asts ternary_tokens ternary_ast ]
let for_tokens = Lex . lex " int main ( ) { for ( 1 ; 1 ; 1 ) { 1 ; } } "
let for_ast = let const = make_int 1 in let for_loop = ( Statement ( For { init = Some const ; cond = const ; post = Some const ; body = Block [ make_exp_statement const ] } ) ) in make_ast [ ] [ for_loop ]
let for_compound_tokens = Lex . lex " int main ( ) { int a ; for ( a = 0 ; a < 5 ; a = a + 1 ) { 1 + 1 ; if ( a < 5 ) { return 3 ; } } } "
let for_compound_ast = let decl = Decl { var_type = IntType ; var_name = ID " a " ; init = None } in let init = Assign ( Equals , ID " a " , make_int 0 ) in let post = Assign ( Equals , ID " a " , BinOp ( Add , Var ( ID " a " ) , make_int 1 ) ) in let cond =...
let for_declaration_tokens = Lex . lex " int main ( ) { for ( int a ; 1 ; 1 ) { 1 ; } } "
let for_decl_ast = let const = make_int 1 in let decl = { var_type = IntType ; var_name = ID " a " ; init = None } in let for_loop = Statement ( ForDecl { init = decl ; cond = const ; post = Some const ; body = Block [ make_exp_statement const ] } ) in make_ast [ ] [ for_...
let single_for_tokens = Lex . lex " int main ( ) { for ( 1 ; 1 ; 1 ) if ( 1 ) 1 ; } "
let single_for_ast = let const = make_int 1 in let if_statement = If { cond = const ; if_body = Exp ( Some const ) ; else_body = None } in let for_loop = For { init = Some const ; cond = const ; post = Some const ; body = if_statement } in make_ast [ ] [ Statement for_loop ]
let for_parse_tests = [ " test_for " >:: test_compare_asts for_tokens for_ast ; " test_for_compound " >:: test_compare_asts for_compound_tokens for_compound_ast ; " test_for_declaration " >:: test_compare_asts for_declaration_tokens for_decl_ast ; " test_single_for " >:: test_compare_asts s...
let while_tokens = Lex . lex " int main ( ) { while ( 1 ) 2 ; } "
let while_ast = let cond = make_int 1 in let body = Exp ( Some ( make_int 2 ) ) in let while_statement = Statement ( While { cond ; body } ) in make_ast [ ] [ while_statement ]
let while_block_tokens = Lex . lex " int main ( ) { while ( 1 ) { 2 ; } } "
let while_block_ast = let cond = make_int 1 in let body = make_exp_statement ( make_int 2 ) in let while_statement = Statement ( While { cond ; body = Block [ body ] } ) in make_ast [ ] [ while_statement ]
let do_while_tokens = Lex . lex " int main ( ) { do 2 ; while ( 1 ) ; } "
let do_while_ast = let cond = make_int 1 in let body = Exp ( Some ( make_int 2 ) ) in let do_while_statement = Statement ( DoWhile { body ; cond } ) in make_ast [ ] [ do_while_statement ]
let do_while_block_tokens = Lex . lex " int main ( ) { do { 2 ; } while ( 1 ) ; } "
let do_while_block_ast = let cond = make_int 1 in let body = make_exp_statement ( make_int 2 ) in let do_while_statement = Statement ( DoWhile { body = Block [ body ] ; cond } ) in make_ast [ ] [ do_while_statement ]

let return_char_ast = let params = [ Param ( IntType , ID " argc " ) ] in let return_exp = Const ( Char ' a ' ) in make_simple_ast params return_exp

let basic_parse_tests = [ " test_simple_parse " >:: test_compare_asts simple_token_list simple_ast ; " test_fun_args " >:: test_compare_asts fun_arg_token_list fun_arg_ast ; " test_return_char " >:: test_compare_asts return_char_tokens return_char_ast ; ]

let negation_tokens = Lex . lex " int main ( ) { return - 3 ; } "

let negation_ast = let unop = UnOp ( Negate , make_int 3 ) in make_simple_ast [ ] unop

let pos_tokens = Lex . lex " int main ( ) { return + 3 ; } "

let pos_ast = let unop = UnOp ( Pos , make_int 3 ) in make_simple_ast [ ] unop

let complement_tokens = Lex . lex " int main ( ) { return ~ 3 ; } "

let complement_ast = let unop = UnOp ( Complement , make_int 3 ) in make_simple_ast [ ] unop

let not_tokens = Lex . lex " int main ( ) { return ! 4 ; } "

let not_ast = let unop = UnOp ( Not , make_int 4 ) in make_simple_ast [ ] unop

let unop_parse_tests = [ " test_negation " >:: test_compare_asts negation_tokens negation_ast ; " test_pos " >:: test_compare_asts pos_tokens pos_ast ; " test_complement " >:: test_compare_asts complement_tokens complement_ast ; " test_not " >:: test_compare_asts not_tokens not_ast ; ]

let addition_tokens = Lex . lex " int main ( ) { return 1 + 2 ; } "

let addition_ast = let binop = BinOp ( Add , make_int 1 , make_int 2 ) in let params = [ ] in make_simple_ast params binop

let subtraction_tokens = Lex . lex " int main ( ) { return 4 - 3 ; } "

let subtraction_ast = let binop = BinOp ( Sub , make_int 4 , make_int 3 ) in make_simple_ast [ ] binop

let subtract_negative_tokens = Lex . lex " int main ( ) { return 4 - - 3 ; } "

let subtract_negative_ast = let unop = UnOp ( Negate , make_int 3 ) in let binop = BinOp ( Sub , make_int 4 , unop ) in make_simple_ast [ ] binop

let multi_addition_tokens = Lex . lex " int main ( ) { return 1 + 2 + 3 ; } "

let multi_addition_ast = let inner_binop = BinOp ( Add , make_int 1 , make_int 2 ) in let outer_binop = BinOp ( Add , inner_binop , make_int 3 ) in let params = [ ] in make_simple_ast params outer_binop

let division_tokens = Lex . lex " int main ( ) { return 4 / 5 ; } "

let division_ast = let binop = BinOp ( Div , make_int 4 , make_int 5 ) in make_simple_ast [ ] binop

let nested_addition_tokens = Lex . lex " int main ( ) { return 1 ( + 2 + 3 ) ; } "

let nested_addition_ast = let inner_binop = BinOp ( Add , make_int 2 , make_int 3 ) in let outer_binop = BinOp ( Add , make_int 1 , inner_binop ) in make_simple_ast [ ] outer_binop

let lots_of_parens_tokens = Lex . lex " int main ( ) { return ( ( 3 ) ) ; } "

let lots_of_parens_ast = make_simple_ast [ ] ( make_int 3 )

let left_nested_addition_tokens = Lex . lex " int main ( ) { return ( 1 + 2 ) + 3 ; } "

let left_nested_addition_ast = let inner_binop = BinOp ( Add , make_int 1 , make_int 2 ) in let outer_binop = BinOp ( Add , inner_binop , make_int 3 ) in let params = [ ] in make_simple_ast params outer_binop

let mult_tokens = Lex . lex " int main ( ) { return 4 * 5 ; } "

let mult_ast = let binop = BinOp ( Mult , make_int 4 , make_int 5 ) in make_simple_ast [ ] binop

let lots_of_parens_add_tokens = Lex . lex " int main ( ) { return ( ( 1 + 2 ) ) ; } "

let lots_of_parens_add_ast = let e1 = make_int 1 in let e2 = make_int 2 in let ret_exp = BinOp ( Add , e1 , e2 ) in make_simple_ast [ ] ret_exp

let mod_toks = Lex . lex " int main ( ) { return 3 % 2 ; } "

let mod_ast = let e1 = make_int 3 in let e2 = make_int 2 in let ret_exp = BinOp ( Mod , e1 , e2 ) in make_simple_ast [ ] ret_exp

let precedence_tokens = Lex . lex " int main ( ) { return 1 * 2 + 3 % 2 ; } "

let precedence_ast = let e1 = BinOp ( Mult , make_int 1 , make_int 2 ) in let e2 = BinOp ( Mod , make_int 3 , make_int 2 ) in let outer_binop = BinOp ( Add , e1 , e2 ) in make_simple_ast [ ] outer_binop

let associativity_tokens = Lex . lex " int main ( ) { return 1 / 2 * 3 ; } "

let associativity_ast = let inner_binop = BinOp ( Div , make_int 1 , make_int 2 ) in let outer_binop = BinOp ( Mult , inner_binop , make_int 3 ) in make_simple_ast [ ] outer_binop

let binop_parse_tests = [ " test_addition " >:: test_compare_asts addition_tokens addition_ast ; " test_subtraction " >:: test_compare_asts subtraction_tokens subtraction_ast ; " test_subtract_negative " >:: test_compare_asts subtract_negative_tokens subtract_negative_ast ; " test_multiplicati...

let bitwise_and_tokens = Lex . lex " int main ( ) { return 1 & 2 ; } "

let bitwise_and_ast = let binop = BinOp ( BitAnd , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop

let bitwise_or_tokens = Lex . lex " int main ( ) { return 1 | 2 ; } "

let bitwise_or_ast = let binop = BinOp ( BitOr , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop

let xor_tokens = Lex . lex " int main ( ) { return 1 ^ 2 ; } "

let xor_ast = let binop = BinOp ( Xor , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop

let shiftl_tokens = Lex . lex " int main ( ) { return 1 << 2 ; } "

let shiftl_ast = let binop = BinOp ( ShiftL , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop

let shiftr_tokens = Lex . lex " int main ( ) { return 1 >> 2 ; } "

let shiftr_ast = let binop = BinOp ( ShiftR , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop

let bitwise_binops_tests = [ " test_bitwise_and " >:: test_compare_asts bitwise_and_tokens bitwise_and_ast ; " test_bitwise_or " >:: test_compare_asts bitwise_or_tokens bitwise_or_ast ; " test_xor " >:: test_compare_asts xor_tokens xor_ast ; " test_shiftl " >:: test_compare_asts shiftl_toke...

let and_tokens = Lex . lex " int main ( ) { return 1 && 2 ; } "

let and_ast = let binop = BinOp ( And , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop

let or_tokens = Lex . lex " int main ( ) { return 1 || 2 ; } "

let or_ast = let binop = BinOp ( Or , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop

let bool_precedence_tokens = Lex . lex " int main ( ) { return 1 || 2 && 3 + 4 ; } "

let bool_precedence_ast = let add_binop = BinOp ( Add , make_int 3 , make_int 4 ) in let and_binop = BinOp ( And , make_int 2 , add_binop ) in let or_binop = BinOp ( Or , make_int 1 , and_binop ) in make_simple_ast [ ] or_binop

let boolean_binop_tests = [ " test_and " >:: test_compare_asts and_tokens and_ast ; " test_or " >:: test_compare_asts or_tokens or_ast ; " test_bool_precedence " >:: test_compare_asts bool_precedence_tokens bool_precedence_ast ; ]

let compare_eq_tokens = Lex . lex " int main ( ) { return 1 == 2 ; } "

let compare_eq_ast = let binop = BinOp ( Eq , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop

let compare_neq_tokens = Lex . lex " int main ( ) { return 1 != 2 ; } "

let compare_neq_ast = let binop = BinOp ( Neq , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop

let compare_gt_tokens = Lex . lex " int main ( ) { return 1 > 2 ; } "

let compare_gt_ast = let binop = BinOp ( Gt , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop

let compare_ge_tokens = Lex . lex " int main ( ) { return 1 >= 2 ; } "

let compare_ge_ast = let binop = BinOp ( Ge , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop

let compare_lt_tokens = Lex . lex " int main ( ) { return 1 < 2 ; } "

let compare_lt_ast = let binop = BinOp ( Lt , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop

let compare_le_tokens = Lex . lex " int main ( ) { return 1 <= 2 ; } "

let compare_le_ast = let binop = BinOp ( Le , make_int 1 , make_int 2 ) in make_simple_ast [ ] binop

let comp_parse_tests = [ " test_eq " >:: test_compare_asts compare_eq_tokens compare_eq_ast ; " test_neq " >:: test_compare_asts compare_neq_tokens compare_neq_ast ; " test_lt " >:: test_compare_asts compare_lt_tokens compare_lt_ast ; " test_gt " >:: test_compare_asts compare_gt_tokens comp...

let declaration_tokens = Lex . lex " int main ( ) { int a = 2 ; return a ; } "

let declaration_ast = let decl = Decl { var_type = IntType ; var_name = ID " a " ; init = Some ( make_int 2 ) ; } in let ret = Statement ( ReturnVal ( Var ( ID " a " ) ) ) in let statements = [ decl ; ret ] in make_ast [ ] statements

let assignment_tokens = Lex . lex " int main ( ) { int a ; a = 2 ; return 0 ; } "

let assignment_ast = let decl = Decl { var_type = IntType ; var_name = ID " a " ; init = None ; } in let assign = make_exp_statement ( Assign ( Equals , ID " a " , make_int 2 ) ) in let ret = Statement ( ReturnVal ( make_int 0 ) ) in let block_items = [ decl ; assign ...

let multi_assign_tokens = Lex . lex " int main ( ) { int a ; int b = a = 2 ; return b ; } "

let multi_assign_ast = let decl_1 = ( Decl { var_type = IntType ; var_name = ID " a " ; init = None } ) in let assign = ( Assign ( Equals , ID " a " , make_int 2 ) ) in let decl_2 = ( Decl { var_type = IntType ; var_name = ID " b " ; init = Some assign } ) in l...

let variable_parse_tests = [ " test_declaration " >:: test_compare_asts declaration_tokens declaration_ast ; " test_assignment " >:: test_compare_asts assignment_tokens assignment_ast ; " test_multi_assign " >:: test_compare_asts multi_assign_tokens multi_assign_ast ; ]

let single_if_tokens = Lex . lex " int main ( ) { if ( 0 ) return 1 ; return 0 ; } "

let single_if_ast = let cond = make_int 0 in let if_body = ReturnVal ( make_int 1 ) in let if_statement = ( Statement ( If { cond ; if_body ; else_body = None } ) ) in let return = ( Statement ( ReturnVal ( make_int 0 ) ) ) in make_ast [ ] [ if_statement ; return ]

let single_if_else_tokens = Lex . lex " int main ( ) { if ( 0 ) return 1 ; else return 2 ; } "

let single_if_else_ast = let cond = make_int 0 in let if_body = ReturnVal ( make_int 1 ) in let else_body = Some ( ReturnVal ( make_int 2 ) ) in let if_statement = ( Statement ( If { cond ; if_body ; else_body } ) ) in make_ast [ ] [ if_statement ]

let ternary_tokens = Lex . lex " int main ( ) { return 3 < 4 ? 5 : 6 ; } "

let ternary_ast = let condition = BinOp ( Lt , make_int 3 , make_int 4 ) in let ternop = TernOp ( condition , make_int 5 , make_int 6 ) in make_simple_ast [ ] ternop

let conditional_parse_tests = [ " test_single_if " >:: test_compare_asts single_if_tokens single_if_ast ; " test_single_if_else " >:: test_compare_asts single_if_else_tokens single_if_else_ast ; " test_ternary " >:: test_compare_asts ternary_tokens ternary_ast ]

let for_tokens = Lex . lex " int main ( ) { for ( 1 ; 1 ; 1 ) { 1 ; } } "

let for_ast = let const = make_int 1 in let for_loop = ( Statement ( For { init = Some const ; cond = const ; post = Some const ; body = Block [ make_exp_statement const ] } ) ) in make_ast [ ] [ for_loop ]

let for_compound_tokens = Lex . lex " int main ( ) { int a ; for ( a = 0 ; a < 5 ; a = a + 1 ) { 1 + 1 ; if ( a < 5 ) { return 3 ; } } } "

let for_compound_ast = let decl = Decl { var_type = IntType ; var_name = ID " a " ; init = None } in let init = Assign ( Equals , ID " a " , make_int 0 ) in let post = Assign ( Equals , ID " a " , BinOp ( Add , Var ( ID " a " ) , make_int 1 ) ) in let cond =...

let for_declaration_tokens = Lex . lex " int main ( ) { for ( int a ; 1 ; 1 ) { 1 ; } } "

let for_decl_ast = let const = make_int 1 in let decl = { var_type = IntType ; var_name = ID " a " ; init = None } in let for_loop = Statement ( ForDecl { init = decl ; cond = const ; post = Some const ; body = Block [ make_exp_statement const ] } ) in make_ast [ ] [ for_...

let single_for_tokens = Lex . lex " int main ( ) { for ( 1 ; 1 ; 1 ) if ( 1 ) 1 ; } "

let single_for_ast = let const = make_int 1 in let if_statement = If { cond = const ; if_body = Exp ( Some const ) ; else_body = None } in let for_loop = For { init = Some const ; cond = const ; post = Some const ; body = if_statement } in make_ast [ ] [ Statement for_loop ]

let for_parse_tests = [ " test_for " >:: test_compare_asts for_tokens for_ast ; " test_for_compound " >:: test_compare_asts for_compound_tokens for_compound_ast ; " test_for_declaration " >:: test_compare_asts for_declaration_tokens for_decl_ast ; " test_single_for " >:: test_compare_asts s...

let while_tokens = Lex . lex " int main ( ) { while ( 1 ) 2 ; } "

let while_ast = let cond = make_int 1 in let body = Exp ( Some ( make_int 2 ) ) in let while_statement = Statement ( While { cond ; body } ) in make_ast [ ] [ while_statement ]

let while_block_tokens = Lex . lex " int main ( ) { while ( 1 ) { 2 ; } } "

let while_block_ast = let cond = make_int 1 in let body = make_exp_statement ( make_int 2 ) in let while_statement = Statement ( While { cond ; body = Block [ body ] } ) in make_ast [ ] [ while_statement ]

let do_while_tokens = Lex . lex " int main ( ) { do 2 ; while ( 1 ) ; } "

let do_while_ast = let cond = make_int 1 in let body = Exp ( Some ( make_int 2 ) ) in let do_while_statement = Statement ( DoWhile { body ; cond } ) in make_ast [ ] [ do_while_statement ]

let do_while_block_tokens = Lex . lex " int main ( ) { do { 2 ; } while ( 1 ) ; } "

let do_while_block_ast = let cond = make_int 1 in let body = make_exp_statement ( make_int 2 ) in let do_while_statement = Statement ( DoWhile { body = Block [ body ] ; cond } ) in make_ast [ ] [ do_while_statement ]