├── .gitattributes ├── .github ├── FUNDING.yml └── workflows │ ├── build_ghpages.yml │ ├── nightly_release.yml │ ├── release.yml │ └── test.yml ├── .gitignore ├── .gitignore.ghpages ├── Cargo.toml ├── LICENSE.txt ├── README.md ├── README_PKG.txt ├── build_ghpages.ps1 ├── build_wasm.ps1 ├── examples ├── basic.asm └── nes_colors.asm ├── mkpkg_win64.ps1 ├── run_local_server.bat ├── rustfmt.toml ├── src ├── asm │ ├── decls │ │ ├── bank.rs │ │ ├── bankdef.rs │ │ ├── function.rs │ │ ├── mod.rs │ │ ├── ruledef.rs │ │ └── symbol.rs │ ├── defs │ │ ├── addr.rs │ │ ├── align.rs │ │ ├── bankdef.rs │ │ ├── data_block.rs │ │ ├── function.rs │ │ ├── instruction.rs │ │ ├── mod.rs │ │ ├── res.rs │ │ ├── ruledef.rs │ │ ├── ruledef_map.rs │ │ └── symbol.rs │ ├── matcher │ │ └── mod.rs │ ├── mod.rs │ ├── output │ │ └── mod.rs │ ├── parser │ │ ├── directive.rs │ │ ├── directive_addr.rs │ │ ├── directive_align.rs │ │ ├── directive_assert.rs │ │ ├── directive_bank.rs │ │ ├── directive_bankdef.rs │ │ ├── directive_bits.rs │ │ ├── directive_const.rs │ │ ├── directive_data.rs │ │ ├── directive_fn.rs │ │ ├── directive_if.rs │ │ ├── directive_include.rs │ │ ├── directive_labelalign.rs │ │ ├── directive_noemit.rs │ │ ├── directive_once.rs │ │ ├── directive_res.rs │ │ ├── directive_ruledef.rs │ │ ├── fields.rs │ │ ├── instruction.rs │ │ ├── mod.rs │ │ └── symbol.rs │ └── resolver │ │ ├── addr.rs │ │ ├── align.rs │ │ ├── assert.rs │ │ ├── constant.rs │ │ ├── data_block.rs │ │ ├── directive_if.rs │ │ ├── eval.rs │ │ ├── eval_asm.rs │ │ ├── eval_fn.rs │ │ ├── instruction.rs │ │ ├── iter.rs │ │ ├── label.rs │ │ ├── mod.rs │ │ └── res.rs ├── build.rs ├── diagn │ ├── mod.rs │ ├── report.rs │ └── span.rs ├── driver.rs ├── expr │ ├── builtin_fn.rs │ ├── eval.rs │ ├── expression.rs │ ├── inspect.rs │ ├── mod.rs │ └── parser.rs ├── lib.rs ├── main.rs ├── syntax │ ├── excerpt.rs │ ├── mod.rs │ ├── token.rs │ └── walker.rs ├── test │ ├── examples.rs │ ├── excerpt.rs │ ├── expr.rs │ ├── file.rs │ ├── file_navigation.rs │ ├── lib.rs │ └── mod.rs ├── usage_help.md ├── util │ ├── bigint.rs │ ├── bitvec.rs │ ├── bitvec_format.rs │ ├── char_counter.rs │ ├── file_navigation.rs │ ├── fileserver.rs │ ├── item_ref.rs │ ├── mod.rs │ ├── overlap_checker.rs │ ├── string_styler.rs │ ├── symbol_format.rs │ ├── symbol_manager.rs │ └── windows_console.rs └── webasm │ └── mod.rs ├── std ├── cpu │ └── 6502.asm └── platform │ └── nes │ ├── constants.asm │ ├── cpu.asm │ └── ines_nrom.asm ├── tests ├── addr │ ├── err_larger_than_usize.asm │ ├── ok_arithmetic.asm │ ├── ok_esoteric_bits.asm │ ├── ok_giant_bank_addr.asm │ ├── ok_insert_zeroes1.asm │ ├── ok_insert_zeroes2.asm │ └── ok_simple.asm ├── addr_backwards │ ├── err_non_writable_under_range.asm │ ├── err_overwrite.asm │ ├── err_res_overwrite1.asm │ ├── err_res_overwrite2.asm │ ├── err_under_range.asm │ ├── ok_no_overwrite1.asm │ ├── ok_no_overwrite2.asm │ └── ok_non_writable.asm ├── align │ ├── err_invalid_large.asm │ ├── err_invalid_negative.asm │ ├── err_invalid_zero.asm │ ├── err_unaligned_addr.asm │ ├── ok_arithmetic.asm │ ├── ok_double1.asm │ ├── ok_double2.asm │ ├── ok_esoteric_bits.asm │ ├── ok_forward_ref.asm │ └── ok_simple.asm ├── assert │ ├── err_addr_convergence.asm │ ├── err_constant.asm │ ├── err_constant_deferred.asm │ ├── err_expected_bool.asm │ ├── err_simple.asm │ ├── err_unknown_symbol.asm │ ├── ok_addr_convergence.asm │ ├── ok_constant.asm │ ├── ok_constant_deferred.asm │ └── ok_simple.asm ├── bank_bits │ ├── err_deprecated.asm │ ├── err_misaligned.asm │ ├── ok_bits_24.asm │ ├── ok_bits_3.asm │ ├── ok_negatives.asm │ └── ok_simple.asm ├── bank_default │ ├── err_data_in_default_bank.asm │ ├── err_label_in_default_bank.asm │ ├── err_res_in_default_bank.asm │ ├── ok_constant_in_default_bank.asm │ └── ok_simple.asm ├── bank_fill │ ├── ok_empty_a.asm │ ├── ok_empty_b.asm │ ├── ok_empty_both.asm │ ├── ok_full.asm │ └── ok_some_data.asm ├── bank_labelalign │ ├── err_deprecated.asm │ ├── err_misaligned.asm │ ├── ok_one_bank.asm │ └── ok_two_banks.asm ├── bank_overlap │ ├── err_addr1.asm │ ├── err_addr_zero1.asm │ ├── err_addr_zero2.asm │ ├── err_both_infinite.asm │ ├── ok_addr1.asm │ ├── ok_addr2.asm │ ├── ok_addr_zero1.asm │ ├── ok_addr_zero2.asm │ └── ok_addr_zero3.asm ├── bank_simple │ ├── err_address_ctx.asm │ ├── err_constants_unresolved1.asm │ ├── err_constants_unresolved2.asm │ ├── err_duplicate.asm │ ├── err_field_syntax.asm │ ├── err_invalid1.asm │ ├── err_invalid2.asm │ ├── err_non_writable1.asm │ ├── err_non_writable2.asm │ ├── err_overflow1.asm │ ├── err_overflow2.asm │ ├── err_unknown_bank.asm │ ├── err_unknown_field.asm │ ├── ok_constants.asm │ ├── ok_constants_outoforder.asm │ ├── ok_empty1.asm │ ├── ok_empty2.asm │ ├── ok_empty3.asm │ ├── ok_one_bank.asm │ └── ok_two_banks.asm ├── comment │ ├── 1.asm │ ├── 2.asm │ ├── 3.asm │ ├── 4.asm │ ├── 5.asm │ ├── 6.asm │ ├── 7.asm │ └── 8.asm ├── data_deferred │ ├── err_larger.asm │ ├── ok_arithmetic.asm │ ├── ok_label.asm │ └── ok_simple.asm ├── data_simple │ ├── err_expected_expr.asm │ ├── err_expected_line_break.asm │ ├── err_invalid_d0x8.asm │ ├── err_out_of_range1.asm │ ├── err_out_of_range2.asm │ ├── err_out_of_range_constant.asm │ ├── err_out_of_range_d0.asm │ ├── err_out_of_range_decimal1.asm │ ├── err_out_of_range_decimal2.asm │ ├── err_out_of_range_negative.asm │ ├── err_out_of_range_slice.asm │ ├── err_out_of_range_string.asm │ ├── err_wrong_type.asm │ ├── ok_constant.asm │ ├── ok_simple.asm │ └── ok_strings.asm ├── data_unsized │ ├── err_unsized_arithmetic.asm │ ├── err_unsized_constant.asm │ ├── err_unsized_constant_forward_ref.asm │ ├── err_unsized_decimal.asm │ ├── err_unsized_decimal2.asm │ ├── err_unsized_label_forward_ref.asm │ ├── ok_constant.asm │ ├── ok_forward_ref.asm │ ├── ok_label_forward_ref.asm │ ├── ok_simple.asm │ └── ok_string_mixed.asm ├── driver │ ├── err_color_invalid │ │ └── main.asm │ ├── err_color_invalid_empty │ │ └── main.asm │ ├── err_define_invalid │ │ └── main.asm │ ├── err_define_invalid_name │ │ └── main.asm │ ├── err_define_invalid_value │ │ └── main.asm │ ├── err_define_no_declaration │ │ └── main.asm │ ├── err_define_unused │ │ └── main.asm │ ├── err_format_annotated_invalid_base │ │ └── main.asm │ ├── err_format_expected_string │ │ └── main.asm │ ├── err_format_invalid_arg │ │ └── main.asm │ ├── err_format_invalid_arg_multiple │ │ └── main.asm │ ├── err_format_invalid_value │ │ └── main.asm │ ├── err_format_malformed_string │ │ └── main.asm │ ├── err_format_unknown │ │ └── main.asm │ ├── err_iters_0 │ │ └── main.asm │ ├── err_iters_invalid │ │ └── main.asm │ ├── err_overwrite │ │ └── main.asm │ ├── ok_color_off │ │ ├── main.asm │ │ └── main.bin │ ├── ok_color_on │ │ ├── main.asm │ │ └── main.bin │ ├── ok_define_if1 │ │ ├── err_no_define.asm │ │ ├── include.asm │ │ ├── ok_variant0.asm │ │ ├── ok_variant1.asm │ │ ├── ok_variant2.asm │ │ ├── ok_variant3.asm │ │ ├── out_variant0.txt │ │ ├── out_variant1.txt │ │ ├── out_variant2.txt │ │ └── out_variant3.txt │ ├── ok_define_if2 │ │ ├── include.asm │ │ ├── ok_variant_false.asm │ │ ├── ok_variant_novalue.asm │ │ ├── ok_variant_omitted.asm │ │ ├── ok_variant_true.asm │ │ ├── out_variant_false.txt │ │ ├── out_variant_novalue.txt │ │ ├── out_variant_omitted.txt │ │ └── out_variant_true.txt │ ├── ok_define_nested │ │ ├── main.asm │ │ └── out.txt │ ├── ok_define_simple_novalue │ │ ├── main.asm │ │ └── out.txt │ ├── ok_define_simple_value │ │ ├── main.asm │ │ └── out.txt │ ├── ok_format_annotated │ │ ├── main.asm │ │ └── out.txt │ ├── ok_format_annotated_args │ │ ├── main.asm │ │ └── out.txt │ ├── ok_format_intelhex │ │ ├── main.asm │ │ └── out.txt │ ├── ok_format_intelhex_blocks1 │ │ ├── main.asm │ │ └── out.txt │ ├── ok_format_intelhex_blocks2 │ │ ├── main.asm │ │ └── out.txt │ ├── ok_format_list │ │ ├── main.asm │ │ └── out.txt │ ├── ok_format_list_custom1 │ │ ├── main.asm │ │ └── out.txt │ ├── ok_format_list_custom2 │ │ ├── main.asm │ │ └── out.txt │ ├── ok_format_multiple │ │ ├── main.asm │ │ ├── main.bin │ │ ├── main.txt │ │ └── symbols.txt │ ├── ok_format_symbol │ │ ├── main.asm │ │ └── out.txt │ ├── ok_format_symbol_noemit │ │ ├── main.asm │ │ └── out.txt │ ├── ok_iters_1 │ │ ├── main.asm │ │ └── main.bin │ ├── ok_iters_3 │ │ ├── main.asm │ │ └── main.bin │ ├── ok_no_output_filename │ │ ├── main.asm │ │ └── main.bin │ └── ok_simple │ │ ├── main.asm │ │ └── out.bin ├── expr_asm │ ├── err_arg_expect_brace.asm │ ├── err_arg_expect_ident.asm │ ├── err_arg_local_deep_no_braces.asm │ ├── err_arg_local_no_braces1.asm │ ├── err_arg_local_no_braces2.asm │ ├── err_arg_no_braces.asm │ ├── err_infinite_recursion.asm │ ├── err_inner_error.asm │ ├── err_invalid.asm │ ├── err_label_convergence.asm │ ├── err_multiple_failed.asm │ ├── err_multiple_matches.asm │ ├── err_no_match.asm │ ├── err_pc_misaligned.asm │ ├── err_subrule_morph_no_match1.asm │ ├── err_subrule_morph_no_match2.asm │ ├── err_subrule_no_match1.asm │ ├── err_subrule_no_match2.asm │ ├── err_subrule_subst_unknown.asm │ ├── err_subrule_subst_unused.asm │ ├── err_unsized.asm │ ├── ok_arg.asm │ ├── ok_arg_across_ruledefs.asm │ ├── ok_arg_assert.asm │ ├── ok_arg_concat.asm │ ├── ok_arg_constant.asm │ ├── ok_arg_constant_hierarchy.asm │ ├── ok_arg_constant_hierarchy_dependent.asm │ ├── ok_arg_inner_expr.asm │ ├── ok_arg_inner_expr_precedence.asm │ ├── ok_arg_label.asm │ ├── ok_arg_label_deferred.asm │ ├── ok_arg_local.asm │ ├── ok_arg_local_deep.asm │ ├── ok_arg_local_precedence.asm │ ├── ok_arg_multiline.asm │ ├── ok_arg_repeat.asm │ ├── ok_args.asm │ ├── ok_args_whitespace.asm │ ├── ok_empty.asm │ ├── ok_label_convergence.asm │ ├── ok_label_forwardref.asm │ ├── ok_label_shadowing.asm │ ├── ok_label_simple.asm │ ├── ok_pc.asm │ ├── ok_ruledef_forward_ref.asm │ ├── ok_simple.asm │ ├── ok_simple_multiline.asm │ ├── ok_subrule.asm │ ├── ok_subrule_morph.asm │ └── ok_subrule_multiline.asm ├── expr_slice │ ├── ok_const.asm │ ├── ok_const_local.asm │ ├── ok_deferred.asm │ └── ok_var_local.asm ├── fn_builtin_le │ ├── err_not_a_multiple1.asm │ ├── err_not_a_multiple2.asm │ ├── err_not_a_multiple3.asm │ ├── err_unsized1.asm │ ├── err_unsized2.asm │ ├── err_unsized3.asm │ ├── ok_inside_rule.asm │ ├── ok_simple.asm │ └── ok_statically_unknown.asm ├── fn_builtin_sizeof │ ├── err_unsized.asm │ └── ok_simple.asm ├── fn_simple │ ├── err_argument_type.asm │ ├── err_duplicate.asm │ ├── err_infinite_recursion.asm │ ├── err_result_size_larger.asm │ ├── err_unknown_arg1.asm │ ├── err_unknown_arg2.asm │ ├── err_unknown_function.asm │ ├── err_wrong_args.asm │ ├── ok_args.asm │ ├── ok_constant.asm │ ├── ok_many_functions.asm │ ├── ok_ruledef.asm │ ├── ok_simple_multiline.asm │ ├── ok_simple_oneliner.asm │ └── ok_symbol_nesting.asm ├── fuzz │ ├── crash1.asm │ ├── crash2.asm │ ├── crash3.asm │ ├── crash4.asm │ ├── crash5.asm │ └── crash6.asm ├── if │ ├── err_erased_constant.asm │ ├── err_inner_error.asm │ ├── err_unresolved1.asm │ ├── err_unresolved2.asm │ ├── err_unresolved3.asm │ ├── ok_elif_false.asm │ ├── ok_elif_inner_constant1.asm │ ├── ok_elif_inner_constant2.asm │ ├── ok_elif_multiple1.asm │ ├── ok_elif_multiple2.asm │ ├── ok_elif_true1.asm │ ├── ok_elif_true2.asm │ ├── ok_else_false.asm │ ├── ok_else_true.asm │ ├── ok_simple_false.asm │ ├── ok_simple_false_expr.asm │ ├── ok_simple_inner_constant1.asm │ ├── ok_simple_inner_constant2.asm │ ├── ok_simple_inner_error.asm │ ├── ok_simple_nested.asm │ ├── ok_simple_true.asm │ ├── ok_simple_true_expr.asm │ ├── ok_subruledef.asm │ ├── ruledef1 │ │ ├── conditional.asm │ │ ├── err_duplicate.asm │ │ ├── err_unknown.asm │ │ ├── ok_deferred_false.asm │ │ ├── ok_deferred_true.asm │ │ ├── ok_simple_false.asm │ │ └── ok_simple_true.asm │ └── subruledef1 │ │ ├── conditional.asm │ │ ├── ok_false_false.asm │ │ ├── ok_false_true.asm │ │ ├── ok_true_false.asm │ │ └── ok_true_true.asm ├── incbin │ ├── data1.bin │ ├── err_end_after_eof.asm │ ├── err_expected.asm │ ├── err_file_not_found.asm │ ├── err_start_after_eof.asm │ ├── err_too_few_arguments.asm │ ├── err_too_many_args.asm │ ├── err_wrong_usage.asm │ ├── inner │ │ ├── data1.bin │ │ └── rule.asm │ ├── ok_constant.asm │ ├── ok_constant_forward_ref.asm │ ├── ok_ruledef_context.asm │ ├── ok_simple.asm │ ├── ok_start.asm │ └── ok_start_size.asm ├── incbinstr │ ├── data1.txt │ ├── data2.txt │ ├── data3.txt │ ├── data4.txt │ ├── err_end_after_eof.asm │ ├── err_expected.asm │ ├── err_file_not_found.asm │ ├── err_invalid_char.asm │ ├── err_start_after_eof.asm │ ├── err_too_few_args.asm │ ├── err_too_many_args.asm │ ├── err_wrong_usage.asm │ ├── ok_constant_forward_ref.asm │ ├── ok_simple_data1.asm │ ├── ok_simple_data2.asm │ ├── ok_simple_data3.asm │ ├── ok_start.asm │ └── ok_start_size.asm ├── inchexstr │ ├── data1.txt │ ├── data2.txt │ ├── data3.txt │ ├── data4.txt │ ├── err_end_after_eof.asm │ ├── err_expected.asm │ ├── err_file_not_found.asm │ ├── err_invalid_char.asm │ ├── err_start_after_eof.asm │ ├── err_too_few_args.asm │ ├── err_too_many_args.asm │ ├── err_wrong_usage.asm │ ├── ok_constant_forward_ref.asm │ ├── ok_simple_data1.asm │ ├── ok_simple_data2.asm │ ├── ok_simple_data3.asm │ ├── ok_start.asm │ └── ok_start_size.asm ├── include_directory │ ├── code │ │ ├── code1.asm │ │ ├── code2.asm │ │ ├── code4.asm │ │ └── code5.asm │ ├── code3.asm │ ├── cpu │ │ └── cpu.asm │ ├── err_out_of_root.asm │ ├── ok_nested.asm │ ├── ok_path_normalization.asm │ ├── ok_simple_code1.asm │ ├── ok_simple_code3.asm │ ├── ok_simple_code4.asm │ └── ok_simple_code5.asm ├── include_recursive │ ├── err_recursive1.asm │ ├── err_recursive2.asm │ ├── err_recursive3.asm │ ├── recursive1.asm │ ├── recursive2.asm │ ├── recursive3.asm │ └── recursive4.asm ├── include_simple │ ├── code1.asm │ ├── code2.asm │ ├── cpu.asm │ ├── err_file_not_found.asm │ ├── err_file_not_found_root.asm │ ├── err_no_ruledef.asm │ ├── err_no_ruledef_mixed.asm │ ├── err_no_ruledef_multiple.asm │ ├── ok_multiple.asm │ ├── ok_multiple_deep.asm │ └── ok_simple.asm ├── include_std │ ├── err_file_not_found.asm │ ├── err_wrong_prefix.asm │ ├── ok_cpu_6502.asm │ └── ok_nes_cpu.asm ├── issue111 │ └── ok.asm ├── issue113 │ └── 1.asm ├── issue115 │ ├── ok1.asm │ └── ok2.asm ├── issue125 │ └── ok.asm ├── issue157 │ └── err_infinite_recursion.asm ├── issue168 │ └── ok.asm ├── issue169 │ ├── err1.asm │ └── err2.asm ├── issue170 │ ├── err.asm │ └── ok.asm ├── issue171 │ └── ok.asm ├── issue173 │ └── ok.asm ├── issue174 │ └── ok.asm ├── issue177 │ ├── inc1.asm │ ├── inc2.asm │ └── main.asm ├── issue181 │ └── ok.asm ├── issue193 │ └── ok.asm ├── issue203 │ └── ok.asm ├── issue204 │ └── ok.asm ├── issue205 │ └── err.asm ├── issue210 │ ├── main.asm │ └── out.txt ├── issue213 │ └── ok.asm ├── issue216 │ └── ok.asm ├── issue47 │ ├── 1.asm │ ├── 2.asm │ ├── 3.asm │ ├── 4.asm │ └── 5.asm ├── issue64 │ ├── 1.asm │ └── 2.asm ├── issue65 │ └── ok.asm ├── issue67 │ ├── 1.asm │ └── 2.asm ├── issue69 │ ├── 1.asm │ ├── 2.asm │ ├── 3.asm │ ├── 4.asm │ └── 5.asm ├── issue72 │ └── 1.asm ├── issue77 │ ├── 1.asm │ ├── 10.asm │ ├── 2.asm │ ├── 3.asm │ ├── 4.asm │ ├── 5.asm │ ├── 6.asm │ ├── 7.asm │ ├── 8.asm │ └── 9.asm ├── issue88 │ ├── 1.asm │ └── 2.asm ├── issue91 │ └── 1.asm ├── issue97 │ └── ok.asm ├── number_styles │ ├── err_invalid_digits_bin.asm │ ├── err_invalid_digits_hex1.asm │ ├── err_invalid_digits_hex2.asm │ ├── err_whitespace1.asm │ ├── err_whitespace2.asm │ ├── ok_patterns.asm │ └── ok_simple.asm ├── once │ ├── 1.asm │ └── once.asm ├── res │ ├── err_invalid_large.asm │ ├── err_invalid_negative.asm │ ├── ok_arithmetic.asm │ ├── ok_bits3.asm │ ├── ok_labels.asm │ ├── ok_multiple1.asm │ ├── ok_multiple2.asm │ ├── ok_one.asm │ └── ok_zero.asm ├── rule_arg_complex │ ├── err_malformed_expr.asm │ ├── err_unknown_symbol.asm │ └── ok_arithmetic.asm ├── rule_arg_forward_ref │ ├── ok_constant.asm │ └── ok_label.asm ├── rule_arg_glued │ ├── err_one_param.asm │ ├── err_symbol_unknown.asm │ ├── err_two_params.asm │ ├── ok_one_param.asm │ ├── ok_one_param_symbol.asm │ ├── ok_reinterpret.asm │ ├── ok_two_params.asm │ └── ok_two_params_symbol.asm ├── rule_arg_simple │ ├── err_missing_arg1.asm │ ├── err_missing_arg2.asm │ ├── err_unknown_in_encoding.asm │ ├── err_unknown_symbol1.asm │ ├── err_unknown_symbol2.asm │ ├── err_unsized.asm │ ├── err_unsized_no_opcode.asm │ ├── ok_lookahead.asm │ ├── ok_parameter_at_start.asm │ ├── ok_sliced_internally_long.asm │ ├── ok_sliced_internally_short.asm │ ├── ok_two_args.asm │ ├── ok_unsized.asm │ └── ok_unsized_no_opcode.asm ├── rule_arg_typed │ ├── err_i1.asm │ ├── err_i32.asm │ ├── err_i8.asm │ ├── err_s8.asm │ ├── err_strings.asm │ ├── err_u8.asm │ ├── err_u8_constant.asm │ ├── err_u8_constant_forward_ref.asm │ ├── ok_i1.asm │ ├── ok_i32.asm │ ├── ok_i8.asm │ ├── ok_s8.asm │ ├── ok_strings.asm │ ├── ok_u8.asm │ ├── ok_u8_constant.asm │ └── ok_u8_constant_forward_ref.asm ├── rule_assert │ ├── err_args_too_few.asm │ ├── err_args_too_many.asm │ ├── err_condition_wrong_type.asm │ ├── err_forward_ref.asm │ ├── err_message.asm │ ├── err_message_wrong_type.asm │ ├── err_simple.asm │ ├── ok_forward_ref.asm │ ├── ok_message.asm │ └── ok_simple.asm ├── rule_cascading │ └── ok.asm ├── rule_cascading_convergence │ ├── err_all.asm │ ├── err_some.asm │ └── ok.asm ├── rule_cascading_forward_ref │ ├── ok_multiple1.asm │ ├── ok_multiple2.asm │ ├── ok_single1.asm │ ├── ok_single2.asm │ ├── ok_single3.asm │ └── ok_single4.asm ├── rule_cascading_size │ ├── err_all_same.asm │ ├── ok_all_same.asm │ ├── ok_large_to_small.asm │ └── ok_small_to_large.asm ├── rule_empty │ ├── err_after_token.asm │ ├── err_before_token.asm │ ├── err_double.asm │ ├── err_in_ruledef.asm │ └── ok.asm ├── rule_multiple │ ├── err_multiple.asm │ ├── ok_match_priority.asm │ ├── ok_match_priority_forward_ref.asm │ └── ok_multiple.asm ├── rule_nested_ambiguous │ ├── err_no_match1.asm │ ├── ok1.asm │ └── ok2.asm ├── rule_nested_arg │ ├── err_missing_arg.asm │ ├── err_no_inner_match.asm │ ├── err_unknown_symbol.asm │ └── ok.asm ├── rule_nested_simple │ ├── err_missing_arg1.asm │ ├── err_missing_arg2.asm │ ├── err_missing_arg3.asm │ ├── err_missing_comma.asm │ ├── err_no_inner_match.asm │ ├── err_subruledef_at_toplevel.asm │ ├── err_unknown_subruledef.asm │ ├── err_unknown_symbol.asm │ └── ok.asm ├── rule_simple │ ├── err_duplicate.asm │ ├── err_encoding_type.asm │ ├── err_expected_identifier.asm │ ├── err_no_line_break.asm │ ├── err_punctuation_whitespace.asm │ ├── err_unknown.asm │ ├── err_whitespace.asm │ ├── ok_long_instr.asm │ ├── ok_one_instr.asm │ ├── ok_punctuation.asm │ ├── ok_two_instrs.asm │ └── ok_two_ruledefs.asm ├── string_encoding │ ├── err_expected.asm │ ├── err_expected_concat.asm │ ├── err_too_few_args.asm │ ├── err_too_many_args.asm │ └── ok.asm ├── symbol_builtin │ ├── ok_dollar.asm │ ├── ok_dollar_multiple.asm │ ├── ok_dollar_pc_isolated.asm │ └── ok_dollar_pc_mixed.asm ├── symbol_constant_outoforder │ ├── err_cascading_instr1.asm │ ├── err_cascading_instr2.asm │ ├── err_cyclical.asm │ ├── err_cyclical_allzero.asm │ ├── err_unknown_y.asm │ ├── err_unknown_z.asm │ ├── ok_cascading_instr1.asm │ ├── ok_cascading_instr2.asm │ ├── ok_xy.asm │ └── ok_xyz.asm ├── symbol_constant_simple │ ├── err_duplicate.asm │ ├── err_literal_const_invalid_attrb.asm │ ├── ok_arithmetic.asm │ ├── ok_dependent.asm │ ├── ok_literal.asm │ ├── ok_literal_const.asm │ ├── ok_literal_const_noemit.asm │ ├── ok_nested.asm │ └── ok_nested_const.asm ├── symbol_label_nested │ ├── err_local_missing_colon.asm │ ├── err_local_outside.asm │ ├── err_skip_level1.asm │ ├── err_skip_level2.asm │ ├── err_skip_level3.asm │ ├── err_unknown_global.asm │ ├── err_unknown_local.asm │ ├── err_unknown_local_fully_qualified.asm │ ├── ok_forward_ref.asm │ ├── ok_fully_qualified_ref.asm │ ├── ok_fully_qualified_ref_deep.asm │ ├── ok_locals.asm │ ├── ok_locals2.asm │ ├── ok_up_ref1.asm │ └── ok_up_ref2.asm ├── symbol_label_simple │ ├── err_duplicate.asm │ ├── ok_multiple.asm │ └── ok_single.asm └── tokenizer │ └── ok_keyword_disambiguation.asm └── web ├── codemirror ├── codemirror.css ├── codemirror.js └── z80.js ├── index.html └── main.js /.gitattributes: -------------------------------------------------------------------------------- 1 | web/* linguist-vendored 2 | web/codemirror/* linguist-vendored -------------------------------------------------------------------------------- /.github/FUNDING.yml: -------------------------------------------------------------------------------- 1 | github: hlorenzi 2 | patreon: hlorenzi 3 | ko_fi: hlorenzi -------------------------------------------------------------------------------- /.github/workflows/test.yml: -------------------------------------------------------------------------------- 1 | name: Test Build 2 | 3 | on: [push, pull_request] 4 | 5 | jobs: 6 | build: 7 | 8 | runs-on: ubuntu-latest 9 | 10 | steps: 11 | - uses: actions/checkout@v2 12 | - name: Build 13 | run: cargo build --verbose 14 | - name: Run tests 15 | run: cargo test --verbose -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | /pkg/ 3 | /.pkgtemp/ 4 | /.vscode/ 5 | /Cargo.lock 6 | /test.asm 7 | /test_output_mismatch 8 | 9 | /web/customasm.wasm -------------------------------------------------------------------------------- /.gitignore.ghpages: -------------------------------------------------------------------------------- 1 | /target/ 2 | /pkg/ 3 | /.pkgtemp/ 4 | /.vscode/ 5 | /Cargo.lock -------------------------------------------------------------------------------- /README_PKG.txt: -------------------------------------------------------------------------------- 1 | Downloaded from: 2 | 3 | https://github.com/hlorenzi/customasm 4 | 5 | Check the following page for documentation 6 | and a how-to-start guide: 7 | 8 | https://github.com/hlorenzi/customasm/wiki -------------------------------------------------------------------------------- /build_wasm.ps1: -------------------------------------------------------------------------------- 1 | # Build wasm binary 2 | cargo build --lib --target wasm32-unknown-unknown --release 3 | 4 | # Copy to web folder 5 | Copy-Item -Path "./target/wasm32-unknown-unknown/release/customasm.wasm" -Destination "./web/customasm.wasm" 6 | 7 | -------------------------------------------------------------------------------- /examples/basic.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | load r1, {value: i8} => 0x11 @ value 4 | load r2, {value: i8} => 0x12 @ value 5 | load r3, {value: i8} => 0x13 @ value 6 | add r1, r2 => 0x21 7 | sub r3, {value: i8} => 0x33 @ value 8 | jnz {address: u16} => 0x40 @ address 9 | ret => 0x50 10 | } 11 | 12 | 13 | multiply3x4: 14 | load r1, 0 15 | load r2, 3 16 | load r3, 4 17 | 18 | .loop: 19 | add r1, r2 20 | sub r3, 1 21 | jnz .loop 22 | 23 | ret -------------------------------------------------------------------------------- /run_local_server.bat: -------------------------------------------------------------------------------- 1 | where /q http-server 2 | 3 | IF ERRORLEVEL 1 (npm i -g http-server) 4 | 5 | http-server -p 80 -------------------------------------------------------------------------------- /rustfmt.toml: -------------------------------------------------------------------------------- 1 | unstable_features = true 2 | brace_style = "AlwaysNextLine" 3 | control_brace_style = "AlwaysNextLine" 4 | blank_lines_lower_bound = 0 5 | blank_lines_upper_bound = 2 -------------------------------------------------------------------------------- /src/asm/decls/bank.rs: -------------------------------------------------------------------------------- 1 | use crate::*; 2 | 3 | 4 | pub fn collect( 5 | report: &mut diagn::Report, 6 | ast: &mut asm::AstTopLevel, 7 | decls: &mut asm::ItemDecls) 8 | -> Result<(), ()> 9 | { 10 | for any_node in &mut ast.nodes 11 | { 12 | let asm::AstAny::DirectiveBank(ref mut node) = any_node 13 | else { continue }; 14 | 15 | if node.item_ref.is_some() 16 | { 17 | continue; 18 | } 19 | 20 | 21 | let item_ref = decls.bankdefs.get_by_name_global( 22 | report, 23 | node.name_span, 24 | &node.name)?; 25 | 26 | node.item_ref = Some(item_ref); 27 | } 28 | 29 | 30 | Ok(()) 31 | } -------------------------------------------------------------------------------- /src/asm/parser/directive_addr.rs: -------------------------------------------------------------------------------- 1 | use crate::*; 2 | 3 | 4 | #[derive(Clone, Debug)] 5 | pub struct AstDirectiveAddr 6 | { 7 | pub header_span: diagn::Span, 8 | pub expr: expr::Expr, 9 | 10 | pub item_ref: Option>, 11 | } 12 | 13 | 14 | pub fn parse( 15 | report: &mut diagn::Report, 16 | walker: &mut syntax::Walker, 17 | header_span: diagn::Span) 18 | -> Result 19 | { 20 | let expr = expr::parse(report, walker)?; 21 | 22 | walker.expect_linebreak(report)?; 23 | 24 | Ok(AstDirectiveAddr { 25 | header_span, 26 | expr, 27 | 28 | item_ref: None, 29 | }) 30 | } -------------------------------------------------------------------------------- /src/asm/parser/directive_align.rs: -------------------------------------------------------------------------------- 1 | use crate::*; 2 | 3 | 4 | #[derive(Clone, Debug)] 5 | pub struct AstDirectiveAlign 6 | { 7 | pub header_span: diagn::Span, 8 | pub expr: expr::Expr, 9 | 10 | pub item_ref: Option>, 11 | } 12 | 13 | 14 | pub fn parse( 15 | report: &mut diagn::Report, 16 | walker: &mut syntax::Walker, 17 | header_span: diagn::Span) 18 | -> Result 19 | { 20 | let expr = expr::parse(report, walker)?; 21 | 22 | walker.expect_linebreak(report)?; 23 | 24 | Ok(AstDirectiveAlign { 25 | header_span, 26 | expr, 27 | 28 | item_ref: None, 29 | }) 30 | } -------------------------------------------------------------------------------- /src/asm/parser/directive_assert.rs: -------------------------------------------------------------------------------- 1 | use crate::*; 2 | 3 | 4 | #[derive(Clone, Debug)] 5 | pub struct AstDirectiveAssert 6 | { 7 | pub header_span: diagn::Span, 8 | pub condition_expr: expr::Expr, 9 | } 10 | 11 | 12 | pub fn parse( 13 | report: &mut diagn::Report, 14 | walker: &mut syntax::Walker, 15 | header_span: diagn::Span) 16 | -> Result 17 | { 18 | let expr = expr::parse(report, walker)?; 19 | 20 | walker.expect_linebreak(report)?; 21 | 22 | Ok(AstDirectiveAssert { 23 | header_span, 24 | condition_expr: expr, 25 | }) 26 | } -------------------------------------------------------------------------------- /src/asm/parser/directive_bits.rs: -------------------------------------------------------------------------------- 1 | use crate::*; 2 | 3 | 4 | #[derive(Clone, Debug)] 5 | pub struct AstDirectiveBits 6 | { 7 | pub header_span: diagn::Span, 8 | pub expr: expr::Expr, 9 | } 10 | 11 | 12 | pub fn parse( 13 | report: &mut diagn::Report, 14 | _walker: &mut syntax::Walker, 15 | header_span: diagn::Span) 16 | -> Result 17 | { 18 | report.error_span( 19 | "standalone `#bits` is deprecated; use it inside a `#bankdef`", 20 | header_span); 21 | 22 | Err(()) 23 | } -------------------------------------------------------------------------------- /src/asm/parser/directive_labelalign.rs: -------------------------------------------------------------------------------- 1 | use crate::*; 2 | 3 | 4 | #[derive(Clone, Debug)] 5 | pub struct AstDirectiveLabelAlign 6 | { 7 | pub header_span: diagn::Span, 8 | pub expr: expr::Expr, 9 | } 10 | 11 | 12 | pub fn parse( 13 | report: &mut diagn::Report, 14 | _walker: &mut syntax::Walker, 15 | header_span: diagn::Span) 16 | -> Result 17 | { 18 | report.error_span( 19 | "standalone `#labelalign` is deprecated; use it inside a `#bankdef`", 20 | header_span); 21 | 22 | Err(()) 23 | } -------------------------------------------------------------------------------- /src/asm/parser/directive_noemit.rs: -------------------------------------------------------------------------------- 1 | use crate::*; 2 | 3 | 4 | #[derive(Clone, Debug)] 5 | pub struct AstDirectiveNoEmit 6 | { 7 | pub header_span: diagn::Span, 8 | pub status: bool, 9 | } 10 | 11 | 12 | pub fn parse( 13 | report: &mut diagn::Report, 14 | _walker: &mut syntax::Walker, 15 | header_span: diagn::Span) 16 | -> Result 17 | { 18 | report.error_span( 19 | "`#noemit` is deprecated; use `#const(noemit)` at each constant declaration", 20 | header_span); 21 | 22 | Err(()) 23 | } -------------------------------------------------------------------------------- /src/asm/parser/directive_once.rs: -------------------------------------------------------------------------------- 1 | use crate::*; 2 | 3 | 4 | #[derive(Clone, Debug)] 5 | pub struct AstDirectiveOnce 6 | { 7 | pub header_span: diagn::Span, 8 | } 9 | 10 | 11 | pub fn parse( 12 | report: &mut diagn::Report, 13 | walker: &mut syntax::Walker, 14 | header_span: diagn::Span) 15 | -> Result 16 | { 17 | walker.expect_linebreak(report)?; 18 | 19 | Ok(AstDirectiveOnce { 20 | header_span, 21 | }) 22 | } -------------------------------------------------------------------------------- /src/asm/parser/directive_res.rs: -------------------------------------------------------------------------------- 1 | use crate::*; 2 | 3 | 4 | #[derive(Clone, Debug)] 5 | pub struct AstDirectiveRes 6 | { 7 | pub header_span: diagn::Span, 8 | pub expr: expr::Expr, 9 | 10 | pub item_ref: Option>, 11 | } 12 | 13 | 14 | pub fn parse( 15 | report: &mut diagn::Report, 16 | walker: &mut syntax::Walker, 17 | header_span: diagn::Span) 18 | -> Result 19 | { 20 | let expr = expr::parse(report, walker)?; 21 | 22 | walker.expect_linebreak(report)?; 23 | 24 | Ok(AstDirectiveRes { 25 | header_span, 26 | expr, 27 | 28 | item_ref: None, 29 | }) 30 | } -------------------------------------------------------------------------------- /src/asm/parser/instruction.rs: -------------------------------------------------------------------------------- 1 | use crate::*; 2 | 3 | 4 | #[derive(Clone, Debug)] 5 | pub struct AstInstruction 6 | { 7 | pub span: diagn::Span, 8 | pub src: String, 9 | 10 | pub item_ref: Option>, 11 | } 12 | 13 | 14 | pub fn parse( 15 | report: &mut diagn::Report, 16 | walker: &mut syntax::Walker) 17 | -> Result 18 | { 19 | walker.skip_ignorable(); 20 | 21 | let line = walker.advance_until_linebreak(); 22 | 23 | walker.expect_linebreak(report)?; 24 | 25 | Ok(AstInstruction { 26 | span: line.get_full_span(), 27 | src: line.get_full_excerpt().to_string(), 28 | 29 | item_ref: None, 30 | }) 31 | } -------------------------------------------------------------------------------- /src/diagn/mod.rs: -------------------------------------------------------------------------------- 1 | mod span; 2 | pub use self::span::Span; 3 | 4 | mod report; 5 | pub use self::report::{ 6 | Report, 7 | Message, 8 | MessageKind, 9 | }; -------------------------------------------------------------------------------- /src/main.rs: -------------------------------------------------------------------------------- 1 | use customasm::*; 2 | 3 | 4 | // generated by build script 5 | include!(concat!(env!("OUT_DIR"), "/std_files.rs")); 6 | 7 | 8 | pub mod driver; 9 | 10 | 11 | fn main() 12 | { 13 | let args: Vec = std::env::args().collect(); 14 | 15 | let mut fileserver = util::FileServerReal::new(); 16 | fileserver.add_std_files(STD_FILES); 17 | 18 | let maybe_result = driver::drive_from_commandline( 19 | &args, 20 | &mut fileserver); 21 | 22 | if let Err(()) = maybe_result 23 | { 24 | std::process::exit(1); 25 | } 26 | } -------------------------------------------------------------------------------- /src/syntax/mod.rs: -------------------------------------------------------------------------------- 1 | mod token; 2 | pub use self::token::{ 3 | Token, 4 | TokenKind, 5 | decide_next_token, 6 | is_whitespace, 7 | }; 8 | 9 | mod walker; 10 | pub use self::walker::Walker; 11 | 12 | mod excerpt; 13 | pub use self::excerpt::{ 14 | unescape_string, 15 | excerpt_as_string_contents, 16 | excerpt_as_usize, 17 | excerpt_as_bigint, 18 | }; -------------------------------------------------------------------------------- /src/util/windows_console.rs: -------------------------------------------------------------------------------- 1 | // From: https://github.com/ogham/rust-ansi-term/blob/master/src/windows.rs 2 | 3 | 4 | #[cfg(not(windows))] 5 | pub fn enable_windows_ansi_support() 6 | { 7 | 8 | } 9 | 10 | 11 | #[cfg(windows)] 12 | pub fn enable_windows_ansi_support() 13 | { 14 | #[link(name = "kernel32")] 15 | extern 16 | { 17 | fn GetStdHandle(handle: u64) -> *const i32; 18 | fn SetConsoleMode(handle: *const i32, mode: u32) -> bool; 19 | } 20 | 21 | unsafe 22 | { SetConsoleMode(GetStdHandle(-11i32 as u64), 7); } 23 | } -------------------------------------------------------------------------------- /std/platform/nes/constants.asm: -------------------------------------------------------------------------------- 1 | PPU_CTRL = 0x2000 2 | PPU_MASK = 0x2001 3 | PPU_STATUS = 0x2002 4 | PPU_ADDR = 0x2006 5 | PPU_DATA = 0x2007 6 | APU_DMC = 0x4010 7 | APU_FRMCNTR = 0x4017 8 | 9 | PPU_CTRL_NMI = 0b10000000 10 | 11 | PPU_MASK_LEFTBKG = 0b00000010 12 | PPU_MASK_LEFTSPR = 0b00000100 13 | PPU_MASK_SHOWBKG = 0b00001000 14 | PPU_MASK_SHOWSPR = 0b00010000 15 | 16 | VRAM_PALETTE = 0x3f00 -------------------------------------------------------------------------------- /std/platform/nes/cpu.asm: -------------------------------------------------------------------------------- 1 | #include "/cpu/6502.asm" -------------------------------------------------------------------------------- /tests/addr/err_larger_than_usize.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | #addr 0x1_0000_0000_0000_0000 ; error: supported range 8 | ld $ -------------------------------------------------------------------------------- /tests/addr/ok_arithmetic.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | ld $ ; = 0x5500 8 | #addr 0x02 + 0x02 ; = 0x0000 9 | ld $ ; = 0x5504 -------------------------------------------------------------------------------- /tests/addr/ok_esoteric_bits.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | #bankdef test { #bits 3, #addr 0, #outp 0 } 8 | 9 | #d3 $ ; = 0b000 10 | #addr 0b010 ; = 0b000 11 | label: 12 | #addr 0b100 ; = 0b000_000 13 | #d3 $ ; = 0b100 14 | #d3 label ; = 0b010 -------------------------------------------------------------------------------- /tests/addr/ok_giant_bank_addr.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | #bankdef test { #addr 0x1_0000_0000_0000_0000, #outp 0 } 8 | 9 | #ruledef test2 10 | { 11 | ld2 {x} => 0x55 @ x`128 12 | } 13 | 14 | ld2 $ ; = 0x55_0000_0000_0000_0001_0000_0000_0000_0000 15 | #addr 0x1_0000_0000_0000_0020 ; = 0x00_0000_0000_0000_0000_0000_0000_0000 16 | ld2 $ ; = 0x55_0000_0000_0000_0001_0000_0000_0000_0020 -------------------------------------------------------------------------------- /tests/addr/ok_insert_zeroes1.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | ld $ ; = 0x5500 8 | #addr 0x03 ; = 0x00 9 | #addr 0x04 ; = 0x00 10 | ld $ ; = 0x5504 -------------------------------------------------------------------------------- /tests/addr/ok_insert_zeroes2.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | ld $ ; = 0x5500 8 | #addr 0x04 ; = 0x0000 9 | #addr 0x06 ; = 0x0000 10 | ld $ ; = 0x5506 -------------------------------------------------------------------------------- /tests/addr/ok_simple.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | ld $ ; = 0x5500 8 | #addr 0x02 9 | ld $ ; = 0x5502 -------------------------------------------------------------------------------- /tests/addr_backwards/err_non_writable_under_range.asm: -------------------------------------------------------------------------------- 1 | #bankdef non_writable { #addr 0, #size 10 } 2 | #res 1 3 | #res 1 4 | #res 1 5 | #res 1 6 | #addr -1 ; error: bank range -------------------------------------------------------------------------------- /tests/addr_backwards/err_overwrite.asm: -------------------------------------------------------------------------------- 1 | #d8 0 2 | #d8 1 3 | #d8 2 4 | #d8 3 5 | #addr 0x1 6 | #d8 4 ; error: overlap / note:_:2: with -------------------------------------------------------------------------------- /tests/addr_backwards/err_res_overwrite1.asm: -------------------------------------------------------------------------------- 1 | #d8 0 2 | #d8 1 3 | #d8 2 4 | #addr 0x1 5 | #res 1 ; error: overlap / note:_:2: overlaps with 6 | #res 1 -------------------------------------------------------------------------------- /tests/addr_backwards/err_res_overwrite2.asm: -------------------------------------------------------------------------------- 1 | #res 2 2 | #res 1 3 | #addr 0x1 4 | #res 1 ; error: overlap / note:_:1: overlaps with 5 | #res 2 -------------------------------------------------------------------------------- /tests/addr_backwards/err_under_range.asm: -------------------------------------------------------------------------------- 1 | #addr -1 ; error: bank range -------------------------------------------------------------------------------- /tests/addr_backwards/ok_no_overwrite1.asm: -------------------------------------------------------------------------------- 1 | #d8 0 ; = 0x00 2 | #addr 0 -------------------------------------------------------------------------------- /tests/addr_backwards/ok_no_overwrite2.asm: -------------------------------------------------------------------------------- 1 | #d8 0 ; = 0x00 2 | #d8 1 ; = 0x01 3 | #d8 2 ; = 0x02 4 | #addr 0x1 -------------------------------------------------------------------------------- /tests/addr_backwards/ok_non_writable.asm: -------------------------------------------------------------------------------- 1 | #bankdef non_writable { #addr 0, #size 10 } 2 | #res 1 3 | #res 1 4 | #res 1 5 | #res 1 6 | #addr 0x2 -------------------------------------------------------------------------------- /tests/align/err_invalid_large.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | #align 0x1_0000_0000_0000_0000 ; error: supported range -------------------------------------------------------------------------------- /tests/align/err_invalid_negative.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | #align -1 ; error: supported range -------------------------------------------------------------------------------- /tests/align/err_invalid_zero.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | #align 0 ; error: invalid -------------------------------------------------------------------------------- /tests/align/err_unaligned_addr.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | ld $ 8 | #align 3 9 | ld $ ; error: failed / note:_:3: within / error: not aligned / note: 6 more bits -------------------------------------------------------------------------------- /tests/align/ok_arithmetic.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | ld $ ; = 0x5500 8 | #align 16 + 16 ; = 0x0000 9 | ld $ ; = 0x5504 -------------------------------------------------------------------------------- /tests/align/ok_double1.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | ld $ ; = 0x5500 8 | #align 24 ; = 0x00 9 | #align 32 ; = 0x00 10 | ld $ ; = 0x5504 -------------------------------------------------------------------------------- /tests/align/ok_double2.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | ld $ ; = 0x5500 8 | #align 32 ; = 0x0000 9 | #align 24 ; = 0x0000 10 | ld $ ; = 0x5506 -------------------------------------------------------------------------------- /tests/align/ok_esoteric_bits.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | #bankdef test { #bits 3, #addr 0, #outp 0 } 8 | 9 | #d3 $ ; = 0b000 10 | #align 6 ; = 0b000 11 | label: 12 | #align 12 ; = 0b000_000 13 | #d3 $ ; = 0b100 14 | #d3 label ; = 0b010 -------------------------------------------------------------------------------- /tests/align/ok_forward_ref.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | ld $ ; = 0x5500 8 | #align x ; = 0x0000 9 | ld $ ; = 0x5504 10 | x = 32 -------------------------------------------------------------------------------- /tests/align/ok_simple.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | ld $ ; = 0x5500 8 | #align 8 9 | ld $ ; = 0x5502 -------------------------------------------------------------------------------- /tests/assert/err_addr_convergence.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x <= 0x8) 6 | 0x11 @ x`16 7 | } 8 | 9 | ld {x} => 10 | { 11 | assert(x > 0x8) 12 | 0x22 @ x`8 13 | } 14 | } 15 | 16 | #assert $ == 0x0 17 | 18 | ld label 19 | ld label 20 | label: 21 | 22 | #assert label == 0x4 ; error: assertion 23 | 24 | ld label 25 | ld label 26 | 27 | #assert $ == 0x8 ; error: assertion -------------------------------------------------------------------------------- /tests/assert/err_constant.asm: -------------------------------------------------------------------------------- 1 | x = 0xff 2 | #d x 3 | #assert x == 0xee ; error: assertion -------------------------------------------------------------------------------- /tests/assert/err_constant_deferred.asm: -------------------------------------------------------------------------------- 1 | #d x 2 | #assert x == 0xee ; error: assertion 3 | x = 0xff -------------------------------------------------------------------------------- /tests/assert/err_expected_bool.asm: -------------------------------------------------------------------------------- 1 | #d 0xff 2 | #assert 1 + 1 ; error: expected boolean -------------------------------------------------------------------------------- /tests/assert/err_simple.asm: -------------------------------------------------------------------------------- 1 | #d 0xff 2 | #assert 1 + 1 == 5 ; error: assertion -------------------------------------------------------------------------------- /tests/assert/err_unknown_symbol.asm: -------------------------------------------------------------------------------- 1 | #assert x ; error: unknown symbol -------------------------------------------------------------------------------- /tests/assert/ok_addr_convergence.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x <= 0x8) 6 | 0x11 @ x`16 7 | } 8 | 9 | ld {x} => 10 | { 11 | assert(x > 0x8) 12 | 0x22 @ x`8 13 | } 14 | } 15 | 16 | #assert $ == 0x0 17 | 18 | ld label ; = 0x110006 19 | ld label ; = 0x110006 20 | label: 21 | 22 | #assert label == 0x6 23 | 24 | ld label ; = 0x110006 25 | ld label ; = 0x110006 26 | 27 | #assert $ == 0xc -------------------------------------------------------------------------------- /tests/assert/ok_constant.asm: -------------------------------------------------------------------------------- 1 | x = 0xff 2 | #d x ; = 0xff 3 | #assert x == 0xff -------------------------------------------------------------------------------- /tests/assert/ok_constant_deferred.asm: -------------------------------------------------------------------------------- 1 | #d x ; = 0xff 2 | #assert x == 0xff 3 | x = 0xff -------------------------------------------------------------------------------- /tests/assert/ok_simple.asm: -------------------------------------------------------------------------------- 1 | #d 0xff ; = 0xff 2 | #assert 1 + 1 == 2 -------------------------------------------------------------------------------- /tests/bank_bits/err_deprecated.asm: -------------------------------------------------------------------------------- 1 | #bits 3 ; error: deprecated 2 | 3 | #ruledef 4 | { 5 | ld {x: u3} => 0b111 @ x 6 | } 7 | 8 | ld 0 9 | label: 10 | ld 5 -------------------------------------------------------------------------------- /tests/bank_bits/err_misaligned.asm: -------------------------------------------------------------------------------- 1 | #bankdef a 2 | { 3 | #bits 3 4 | #outp 0 5 | } 6 | 7 | label1: 8 | #d 0b111 9 | label2: 10 | #d 0b101_011 11 | label3: 12 | #d 0b1 13 | label4: ; error: not aligned / note: needs 2 more bits -------------------------------------------------------------------------------- /tests/bank_bits/ok_bits_24.asm: -------------------------------------------------------------------------------- 1 | #bankdef a 2 | { 3 | #bits 24 4 | #outp 0 5 | } 6 | 7 | #ruledef 8 | { 9 | ld {x: u16} => 0x55 @ x 10 | } 11 | 12 | ld 0 ; = 0x550000 13 | label: 14 | ld 0x1234 ; = 0x551234 15 | ld label ; = 0x550001 16 | ld $ ; = 0x550003 -------------------------------------------------------------------------------- /tests/bank_bits/ok_bits_3.asm: -------------------------------------------------------------------------------- 1 | #bankdef a 2 | { 3 | #bits 3 4 | #outp 0 5 | } 6 | 7 | #ruledef 8 | { 9 | ld {x: u3} => 0b111 @ x 10 | } 11 | 12 | ld 0 ; = 0b111_000 13 | label: 14 | ld 5 ; = 0b111_101 15 | ld 7 ; = 0b111_111 16 | ld $ ; = 0b111_110 17 | ld label ; = 0b111_010 -------------------------------------------------------------------------------- /tests/bank_bits/ok_negatives.asm: -------------------------------------------------------------------------------- 1 | #bankdef bits8 2 | { 3 | #bits 8 4 | #addr 0x0 5 | #size 0x8 6 | #outp 0x0 7 | } 8 | 9 | #bankdef bits16 10 | { 11 | #bits 16 12 | #addr 0x0 13 | #size 0x8 14 | #outp 8 * 0x8 15 | } 16 | 17 | 18 | #bank bits8 19 | #d8 -1 20 | #res 1 21 | #d8 -1 22 | #bank bits16 23 | #d16 -1 24 | #res 1 25 | #d16 -1 26 | #bank bits8 27 | #res 1 28 | #d8 -1 29 | ; = 0xff00ff00ff000000_ffff0000ffff -------------------------------------------------------------------------------- /tests/bank_bits/ok_simple.asm: -------------------------------------------------------------------------------- 1 | #bankdef bits8 2 | { 3 | #bits 8 4 | #addr 0x0 5 | #size 0x8 6 | #outp 0x0 7 | } 8 | 9 | #bankdef bits16 10 | { 11 | #bits 16 12 | #addr 0x0 13 | #size 0x8 14 | #outp 8 * 0x8 15 | } 16 | 17 | 18 | #bank bits8 19 | #d8 0, 1, 2, 3, $ 20 | #bank bits16 21 | #d16 0, 1, $ 22 | ; = 0x0001020304000000_000000010002 -------------------------------------------------------------------------------- /tests/bank_default/err_data_in_default_bank.asm: -------------------------------------------------------------------------------- 1 | #d8 1, 2, 3, 4 ; error: default bank 2 | #bankdef a_new_bank {} -------------------------------------------------------------------------------- /tests/bank_default/err_label_in_default_bank.asm: -------------------------------------------------------------------------------- 1 | label: ; error: default bank 2 | #bankdef a_new_bank {} -------------------------------------------------------------------------------- /tests/bank_default/err_res_in_default_bank.asm: -------------------------------------------------------------------------------- 1 | #res 4 ; error: default bank 2 | #bankdef a_new_bank {} -------------------------------------------------------------------------------- /tests/bank_default/ok_constant_in_default_bank.asm: -------------------------------------------------------------------------------- 1 | x = 0x25 2 | #bankdef a_new_bank {} 3 | ; = 0x -------------------------------------------------------------------------------- /tests/bank_default/ok_simple.asm: -------------------------------------------------------------------------------- 1 | #d8 1, 2, 3, 4 ; = 0x01020304 -------------------------------------------------------------------------------- /tests/bank_fill/ok_empty_a.asm: -------------------------------------------------------------------------------- 1 | #bankdef a 2 | { 3 | #bits 8 4 | #addr 0x0 5 | #size 0x4 6 | #outp 0x0 7 | #fill 8 | } 9 | 10 | #bankdef b 11 | { 12 | #bits 8 13 | #addr 0x0 14 | #size 0x4 15 | #outp 8 * 0x4 16 | #fill 17 | } 18 | 19 | 20 | #bank b 21 | #d8 4, 3, $ 22 | ; = 0x00000000_04030200 -------------------------------------------------------------------------------- /tests/bank_fill/ok_empty_b.asm: -------------------------------------------------------------------------------- 1 | #bankdef a 2 | { 3 | #bits 8 4 | #addr 0x0 5 | #size 0x4 6 | #outp 0x0 7 | #fill 8 | } 9 | 10 | #bankdef b 11 | { 12 | #bits 8 13 | #addr 0x0 14 | #size 0x4 15 | #outp 8 * 0x4 16 | #fill 17 | } 18 | 19 | 20 | #bank a 21 | #d8 0, 1, $ 22 | ; = 0x00010200_00000000 -------------------------------------------------------------------------------- /tests/bank_fill/ok_empty_both.asm: -------------------------------------------------------------------------------- 1 | #bankdef a 2 | { 3 | #bits 8 4 | #addr 0x0 5 | #size 0x4 6 | #outp 0x0 7 | #fill 8 | } 9 | 10 | #bankdef b 11 | { 12 | #bits 8 13 | #addr 0x0 14 | #size 0x4 15 | #outp 8 * 0x4 16 | #fill 17 | } 18 | 19 | 20 | ; empty banks 21 | ; = 0x00000000_00000000 -------------------------------------------------------------------------------- /tests/bank_fill/ok_full.asm: -------------------------------------------------------------------------------- 1 | #bankdef a 2 | { 3 | #bits 8 4 | #addr 0x0 5 | #size 0x4 6 | #outp 0x0 7 | #fill 8 | } 9 | 10 | #bankdef b 11 | { 12 | #bits 8 13 | #addr 0x0 14 | #size 0x4 15 | #outp 8 * 0x4 16 | #fill 17 | } 18 | 19 | 20 | #bank a 21 | #d8 0, 1, 2, $ 22 | #bank b 23 | #d8 6, 5, 4, $ 24 | ; = 0x00010203_06050403 -------------------------------------------------------------------------------- /tests/bank_fill/ok_some_data.asm: -------------------------------------------------------------------------------- 1 | #bankdef a 2 | { 3 | #bits 8 4 | #addr 0x0 5 | #size 0x4 6 | #outp 0x0 7 | #fill 8 | } 9 | 10 | #bankdef b 11 | { 12 | #bits 8 13 | #addr 0x0 14 | #size 0x4 15 | #outp 8 * 0x4 16 | #fill 17 | } 18 | 19 | 20 | #bank a 21 | #d8 0, 1, $ 22 | #bank b 23 | #d8 4, 3, $ 24 | ; = 0x00010200_04030200 -------------------------------------------------------------------------------- /tests/bank_labelalign/err_deprecated.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | #labelalign 32 ; error: deprecated 8 | ld $ 9 | label: 10 | ld $ 11 | .sublabel: 12 | ld $ -------------------------------------------------------------------------------- /tests/bank_labelalign/err_misaligned.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | #bankdef a 7 | { 8 | #addr 0 9 | #outp 0 10 | #labelalign 25 11 | } 12 | 13 | ld $ 14 | label: ; error: not aligned / note: needs 7 more bits 15 | ld $ -------------------------------------------------------------------------------- /tests/bank_labelalign/ok_one_bank.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | #bankdef a 7 | { 8 | #addr 0 9 | #outp 0 10 | #labelalign 32 11 | } 12 | 13 | ld $ ; = 0x5500 14 | label: ; = 0x0000 15 | ld $ ; = 0x5504 -------------------------------------------------------------------------------- /tests/bank_labelalign/ok_two_banks.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | #bankdef a 7 | { 8 | #addr 0 9 | #size 8 10 | #outp 0 11 | #labelalign 32 12 | } 13 | 14 | #bankdef b 15 | { 16 | #addr 0 17 | #outp 8 * 8 18 | #labelalign 64 19 | } 20 | 21 | #bank a 22 | ld $ 23 | label1: 24 | ld $ 25 | 26 | #bank b 27 | ld $ 28 | label2: 29 | ld $ 30 | 31 | ; = 0x5500000055040000_55000000000000005508 -------------------------------------------------------------------------------- /tests/bank_overlap/err_addr1.asm: -------------------------------------------------------------------------------- 1 | #bankdef a { #addr 0x20, #addr_end 0x31, #outp 8 * 0x00 } ; error: overlaps / note:_:2: defined here 2 | #bankdef b { #addr 0x40, #addr_end 0x50, #outp 8 * 0x10 } -------------------------------------------------------------------------------- /tests/bank_overlap/err_addr_zero1.asm: -------------------------------------------------------------------------------- 1 | #bankdef a { #size 0x11, #outp 8 * 0x00 } ; error: overlaps / note:_:2: defined here 2 | #bankdef b { #size 0x10, #outp 8 * 0x10 } -------------------------------------------------------------------------------- /tests/bank_overlap/err_addr_zero2.asm: -------------------------------------------------------------------------------- 1 | #bankdef a { #size 0x10, #outp 8 * 0x10 } ; error: overlaps / note:_:2: defined here 2 | #bankdef b { #size 0x11, #outp 8 * 0x00 } -------------------------------------------------------------------------------- /tests/bank_overlap/err_both_infinite.asm: -------------------------------------------------------------------------------- 1 | #bankdef a { #outp 8 * 0x00 } ; error: overlaps / note:_:2: defined here 2 | #bankdef b { #outp 8 * 0x10 } -------------------------------------------------------------------------------- /tests/bank_overlap/ok_addr1.asm: -------------------------------------------------------------------------------- 1 | #bankdef a { #addr 0x20, #size 0x10, #outp 8 * 0x00 } 2 | #bankdef b { #addr 0x20, #size 0x10, #outp 8 * 0x10 } 3 | ; = 0x -------------------------------------------------------------------------------- /tests/bank_overlap/ok_addr2.asm: -------------------------------------------------------------------------------- 1 | #bankdef a { #addr 0x20, #addr_end 0x30, #outp 8 * 0x00 } 2 | #bankdef b { #addr 0x40, #addr_end 0x50, #outp 8 * 0x10 } 3 | ; = 0x -------------------------------------------------------------------------------- /tests/bank_overlap/ok_addr_zero1.asm: -------------------------------------------------------------------------------- 1 | #bankdef a { #size 0x10, #outp 8 * 0x00 } 2 | #bankdef b { #size 0x10, #outp 8 * 0x10 } 3 | ; = 0x -------------------------------------------------------------------------------- /tests/bank_overlap/ok_addr_zero2.asm: -------------------------------------------------------------------------------- 1 | #bankdef a { #size 0x10, #outp 8 * 0x10 } 2 | #bankdef b { #size 0x10, #outp 8 * 0x00 } 3 | ; = 0x -------------------------------------------------------------------------------- /tests/bank_overlap/ok_addr_zero3.asm: -------------------------------------------------------------------------------- 1 | #bankdef a { #size 0x11, #outp 8 * 0x10 } 2 | #bankdef b { #size 0x10, #outp 8 * 0x00 } 3 | ; = 0x -------------------------------------------------------------------------------- /tests/bank_simple/err_address_ctx.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | loop => 0x5555 @ $`16 4 | } 5 | 6 | OUTPUT = 8 * 0x0000 7 | 8 | #bankdef test 9 | { 10 | #addr $ ; error: cannot get address 11 | #outp OUTPUT 12 | } 13 | 14 | loop -------------------------------------------------------------------------------- /tests/bank_simple/err_constants_unresolved1.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | loop => 0x5555 @ $`16 4 | } 5 | 6 | ADDR_START = $ 7 | OUTPUT = 8 * 0x0000 8 | 9 | #bankdef test 10 | { 11 | #addr ADDR_START ; error: unresolved 12 | #outp OUTPUT 13 | } 14 | 15 | loop -------------------------------------------------------------------------------- /tests/bank_simple/err_constants_unresolved2.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | loop => 0x5555 @ $`16 4 | } 5 | 6 | ADDR_START = 0x8000 | ADDR2 7 | ADDR2 = $ 8 | OUTPUT = 8 * 0x0000 9 | 10 | #bankdef test 11 | { 12 | #addr ADDR_START ; error: unresolved 13 | #outp OUTPUT 14 | } 15 | 16 | loop -------------------------------------------------------------------------------- /tests/bank_simple/err_duplicate.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | loop => 0x5555 @ $`16 4 | } 5 | 6 | #bankdef a { #addr 0x8000 } 7 | #bankdef a { #addr 0x8000 } ; error: duplicate / note:_:6: first -------------------------------------------------------------------------------- /tests/bank_simple/err_field_syntax.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | loop => 0x5555 @ $`16 4 | } 5 | 6 | #bankdef a { #size 0x10 #outp 8 * 0x10 } ; error: expected -------------------------------------------------------------------------------- /tests/bank_simple/err_invalid1.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | loop => 0x5555 @ $`16 4 | } 5 | 6 | #bankdef a { #outp -0x8000 } ; error: supported range -------------------------------------------------------------------------------- /tests/bank_simple/err_invalid2.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | loop => 0x5555 @ $`16 4 | } 5 | 6 | #bankdef a { #outp 0xffff_ffff_ffff_ffff_ffff_ffff_ffff_ffff_ffff } ; error: supported range -------------------------------------------------------------------------------- /tests/bank_simple/err_non_writable1.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | loop => 0x5555 @ $`16 4 | } 5 | 6 | 7 | #bankdef test { #addr 0x8000 } 8 | loop ; error: non-writable / note:_:7: no `outp` defined -------------------------------------------------------------------------------- /tests/bank_simple/err_non_writable2.asm: -------------------------------------------------------------------------------- 1 | #bankdef test { #addr 0x8000 } 2 | #d 0x88 ; error: non-writable / note:_:1: no `outp` defined -------------------------------------------------------------------------------- /tests/bank_simple/err_overflow1.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | loop => 0x5555 @ $`16 4 | } 5 | 6 | 7 | #bankdef test 8 | { 9 | #addr 0x8000 10 | #size 0x0008 11 | #outp 0x0000 12 | } 13 | 14 | loop 15 | loop 16 | loop ; error: out of range for bank / note:_:7: defined here 17 | loop -------------------------------------------------------------------------------- /tests/bank_simple/err_overflow2.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | loop => 0x5555 @ $`16 4 | } 5 | 6 | 7 | #bankdef a 8 | { 9 | #addr 0xaa00 10 | #size 0x0010 11 | #outp 8 * 0x0000 12 | } 13 | 14 | #bankdef b 15 | { 16 | #addr 0xbb00 17 | #size 0x0010 18 | #outp 8 * 0x0010 19 | } 20 | 21 | loop 22 | loop 23 | #bank a 24 | loop 25 | loop 26 | #bank b 27 | loop 28 | loop 29 | #bank a 30 | loop 31 | loop 32 | loop ; error: out of range for bank / note:_:7: defined here -------------------------------------------------------------------------------- /tests/bank_simple/err_unknown_bank.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | loop => 0x5555 @ $`16 4 | } 5 | 6 | #bankdef a { #addr 0x8000 } 7 | #bank c ; error: unknown -------------------------------------------------------------------------------- /tests/bank_simple/err_unknown_field.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | loop => 0x5555 @ $`16 4 | } 5 | 6 | #bankdef a { #unk 0x0000 } ; error: invalid field -------------------------------------------------------------------------------- /tests/bank_simple/ok_constants.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | loop => 0x5555 @ $`16 4 | } 5 | 6 | 7 | ADDR_START = 0x8000 8 | OUTPUT = 8 * 0x0000 9 | 10 | #bankdef test 11 | { 12 | #addr ADDR_START 13 | #outp OUTPUT 14 | } 15 | 16 | 17 | loop ; = 0x55558000 18 | loop ; = 0x55558004 19 | loop ; = 0x55558008 20 | loop ; = 0x5555800c 21 | loop ; = 0x55558010 22 | loop ; = 0x55558014 23 | loop ; = 0x55558018 24 | loop ; = 0x5555801c -------------------------------------------------------------------------------- /tests/bank_simple/ok_constants_outoforder.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | loop => 0x5555 @ $`16 4 | } 5 | 6 | 7 | ADDR_START = ADDR1 @ ADDR2 8 | ADDR1 = (8 * X)`8 9 | 10 | #bankdef test 11 | { 12 | #addr ADDR_START 13 | #outp OUTPUT 14 | } 15 | 16 | OUTPUT = 8 * 0x0000 17 | X = 0x10 18 | ADDR2 = 0x00 19 | 20 | 21 | loop ; = 0x55558000 22 | loop ; = 0x55558004 23 | loop ; = 0x55558008 24 | loop ; = 0x5555800c 25 | loop ; = 0x55558010 26 | loop ; = 0x55558014 27 | loop ; = 0x55558018 28 | loop ; = 0x5555801c -------------------------------------------------------------------------------- /tests/bank_simple/ok_empty1.asm: -------------------------------------------------------------------------------- 1 | #bankdef test { #addr 0x8000 } ; = 0x -------------------------------------------------------------------------------- /tests/bank_simple/ok_empty2.asm: -------------------------------------------------------------------------------- 1 | #bankdef test { #addr 0x8000, #size 0x10 } ; = 0x -------------------------------------------------------------------------------- /tests/bank_simple/ok_empty3.asm: -------------------------------------------------------------------------------- 1 | #bankdef test { #addr 0x8000 + 0x2000, #size 0x10 * 8 } ; = 0x -------------------------------------------------------------------------------- /tests/bank_simple/ok_one_bank.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | loop => 0x5555 @ $`16 4 | } 5 | 6 | 7 | #bankdef test 8 | { 9 | #addr 0x8000 10 | #outp 8 * 0x0000 11 | } 12 | 13 | loop ; = 0x55558000 14 | loop ; = 0x55558004 15 | loop ; = 0x55558008 16 | loop ; = 0x5555800c 17 | loop ; = 0x55558010 18 | loop ; = 0x55558014 19 | loop ; = 0x55558018 20 | loop ; = 0x5555801c -------------------------------------------------------------------------------- /tests/bank_simple/ok_two_banks.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | loop => 0x5555 @ $`16 4 | } 5 | 6 | 7 | #bankdef a 8 | { 9 | #addr 0xaa00 10 | #size 0x0010 11 | #outp 8 * 0x0000 12 | } 13 | 14 | #bankdef b 15 | { 16 | #addr 0xbb00 17 | #size 0x0010 18 | #outp 8 * 0x0010 19 | } 20 | 21 | loop 22 | loop 23 | #bank a 24 | loop 25 | loop 26 | #bank b 27 | loop 28 | loop 29 | #bank a 30 | loop 31 | loop 32 | ; = 0x5555aa00 33 | ; = 0x5555aa04 34 | ; = 0x5555aa08 35 | ; = 0x5555aa0c 36 | ; = 0x5555bb00 37 | ; = 0x5555bb04 38 | ; = 0x5555bb08 39 | ; = 0x5555bb0c -------------------------------------------------------------------------------- /tests/comment/1.asm: -------------------------------------------------------------------------------- 1 | ; = 0x00 2 | #d8 0, ; 1, 2, 3 -------------------------------------------------------------------------------- /tests/comment/2.asm: -------------------------------------------------------------------------------- 1 | ; = 0x000203 2 | #d8 0, ;* 1, *; 2, 3 -------------------------------------------------------------------------------- /tests/comment/3.asm: -------------------------------------------------------------------------------- 1 | ; = 0x000203 2 | #d8 0 ;* 3 | #d8 1, comment 4 | *; 5 | #d8 2, 3 -------------------------------------------------------------------------------- /tests/comment/4.asm: -------------------------------------------------------------------------------- 1 | ; = 0x0003 2 | #d8 0 ;* 3 | ;* #d8 1, comment 4 | *; 5 | #d8 2, comment *; 6 | #d8 3 -------------------------------------------------------------------------------- /tests/comment/5.asm: -------------------------------------------------------------------------------- 1 | #d8 0 ;* ; error: expected line break 2 | ;* #d8 1, comment 3 | *; 4 | #d8 2, comment *; #d8 3 -------------------------------------------------------------------------------- /tests/comment/6.asm: -------------------------------------------------------------------------------- 1 | ; = 0x00 2 | #d8 0 ;**; -------------------------------------------------------------------------------- /tests/comment/7.asm: -------------------------------------------------------------------------------- 1 | #d8 12 ;** ; = 0x0c -------------------------------------------------------------------------------- /tests/comment/8.asm: -------------------------------------------------------------------------------- 1 | #d8 12 ;* ; = 0x0c -------------------------------------------------------------------------------- /tests/data_deferred/err_larger.asm: -------------------------------------------------------------------------------- 1 | #d8 x ; error: out of range / note: got size 16 2 | x = 0x5555 -------------------------------------------------------------------------------- /tests/data_deferred/ok_arithmetic.asm: -------------------------------------------------------------------------------- 1 | #d16 x ; = 0x0055 2 | #d16 x - 0x5 ; = 0x0050 3 | x = 0x55 -------------------------------------------------------------------------------- /tests/data_deferred/ok_label.asm: -------------------------------------------------------------------------------- 1 | #d16 x ; = 0x0055 2 | label: 3 | #d16 label`16 ; = 0x0002 4 | x = 0x55 -------------------------------------------------------------------------------- /tests/data_deferred/ok_simple.asm: -------------------------------------------------------------------------------- 1 | #d16 x ; = 0x0055 2 | x = 0x55 -------------------------------------------------------------------------------- /tests/data_simple/err_expected_expr.asm: -------------------------------------------------------------------------------- 1 | #d8 ; error: expected expression -------------------------------------------------------------------------------- /tests/data_simple/err_expected_line_break.asm: -------------------------------------------------------------------------------- 1 | #d8 0x00 0xff ; error: expected line break -------------------------------------------------------------------------------- /tests/data_simple/err_invalid_d0x8.asm: -------------------------------------------------------------------------------- 1 | #d0x8 0x0 ; error: unknown directive -------------------------------------------------------------------------------- /tests/data_simple/err_out_of_range1.asm: -------------------------------------------------------------------------------- 1 | #d8 0x100 ; error: out of range / note: got size 12 -------------------------------------------------------------------------------- /tests/data_simple/err_out_of_range2.asm: -------------------------------------------------------------------------------- 1 | #d8 0x00, 0xff, 0x100 ; error: out of range / note: got size 12 -------------------------------------------------------------------------------- /tests/data_simple/err_out_of_range_constant.asm: -------------------------------------------------------------------------------- 1 | x = 0x5555 2 | #d8 x ; error: out of range / note: got size 16 -------------------------------------------------------------------------------- /tests/data_simple/err_out_of_range_d0.asm: -------------------------------------------------------------------------------- 1 | #d0 0x0 ; error: out of range / note: got size 4 -------------------------------------------------------------------------------- /tests/data_simple/err_out_of_range_decimal1.asm: -------------------------------------------------------------------------------- 1 | #d8 256 ; error: out of range / note: got size 9 -------------------------------------------------------------------------------- /tests/data_simple/err_out_of_range_decimal2.asm: -------------------------------------------------------------------------------- 1 | #d8 0, 255, 256 ; error: out of range / note: got size 9 -------------------------------------------------------------------------------- /tests/data_simple/err_out_of_range_negative.asm: -------------------------------------------------------------------------------- 1 | #d8 -129 ; error: out of range / note: got size 9 -------------------------------------------------------------------------------- /tests/data_simple/err_out_of_range_slice.asm: -------------------------------------------------------------------------------- 1 | #d8 0x00`16 ; error: out of range / note: got size 16 -------------------------------------------------------------------------------- /tests/data_simple/err_out_of_range_string.asm: -------------------------------------------------------------------------------- 1 | #d8 "abc" ; error: out of range / note: got size 24 -------------------------------------------------------------------------------- /tests/data_simple/err_wrong_type.asm: -------------------------------------------------------------------------------- 1 | #d8 2 > 1 ; error: expected integer -------------------------------------------------------------------------------- /tests/data_simple/ok_constant.asm: -------------------------------------------------------------------------------- 1 | x = 0x5 2 | #d16 x ; = 0x0005 3 | 4 | y = 0x66 5 | z = 0x777 6 | #d16 y ; = 0x0066 7 | #d16 z ; = 0x0777 8 | 9 | w = 0x8888 10 | #d16 w ; = 0x8888 -------------------------------------------------------------------------------- /tests/data_simple/ok_strings.asm: -------------------------------------------------------------------------------- 1 | #d8 "a" ; = 0x61 2 | #d16 "b" ; = 0x0062 3 | #d16 "ab" ; = 0x6162 -------------------------------------------------------------------------------- /tests/data_unsized/err_unsized_arithmetic.asm: -------------------------------------------------------------------------------- 1 | #d 0x12 + 0x34 ; error: definite size -------------------------------------------------------------------------------- /tests/data_unsized/err_unsized_constant.asm: -------------------------------------------------------------------------------- 1 | x = 10 2 | #d x ; error: definite size -------------------------------------------------------------------------------- /tests/data_unsized/err_unsized_constant_forward_ref.asm: -------------------------------------------------------------------------------- 1 | #d x ; error: definite size 2 | x = 10 -------------------------------------------------------------------------------- /tests/data_unsized/err_unsized_decimal.asm: -------------------------------------------------------------------------------- 1 | #d 10 ; error: definite size -------------------------------------------------------------------------------- /tests/data_unsized/err_unsized_decimal2.asm: -------------------------------------------------------------------------------- 1 | #d 0x12, 10 ; error: definite size -------------------------------------------------------------------------------- /tests/data_unsized/err_unsized_label_forward_ref.asm: -------------------------------------------------------------------------------- 1 | #d label ; error: definite size 2 | label: -------------------------------------------------------------------------------- /tests/data_unsized/ok_constant.asm: -------------------------------------------------------------------------------- 1 | x = 0x1234 2 | #d x, 0x56, x ; = 0x1234561234 -------------------------------------------------------------------------------- /tests/data_unsized/ok_forward_ref.asm: -------------------------------------------------------------------------------- 1 | #d x, 0x56, x ; = 0x1234561234 2 | #d x, 0x56, x ; = 0x1234561234 3 | x = 0x1234 -------------------------------------------------------------------------------- /tests/data_unsized/ok_label_forward_ref.asm: -------------------------------------------------------------------------------- 1 | #d x ; = 0x55 2 | label: 3 | #d16 label`16 ; = 0x0001 4 | x = 0x55 -------------------------------------------------------------------------------- /tests/data_unsized/ok_simple.asm: -------------------------------------------------------------------------------- 1 | #d 0x00 ; = 0x00 2 | #d 0x0000 ; = 0x0000 3 | #d 0x12 ; = 0x12 4 | #d 0x1234 ; = 0x1234 5 | #d 10`16 ; = 0x000a 6 | #d (0x12 + 0x34)`16 ; = 0x0046 7 | #d 0x12, 0x345, 0x6, 0x789a ; = 0x123456789a -------------------------------------------------------------------------------- /tests/data_unsized/ok_string_mixed.asm: -------------------------------------------------------------------------------- 1 | #d "ABC", 0xff ; = 0x414243ff -------------------------------------------------------------------------------- /tests/driver/err_color_invalid/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | 9 | ; command: main.asm --color 10 | ; error: invalid argument for `--color` -------------------------------------------------------------------------------- /tests/driver/err_color_invalid_empty/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | 9 | ; command: main.asm --color=x 10 | ; error: invalid argument for `--color` -------------------------------------------------------------------------------- /tests/driver/err_define_invalid/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: u8} => 0x55 @ x 4 | } 5 | 6 | val = 0 7 | ld val 8 | 9 | ; command: main.asm -o out.bin -dval=abc=123 10 | ; error: invalid define argument `val=abc=123` -------------------------------------------------------------------------------- /tests/driver/err_define_invalid_name/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: u8} => 0x55 @ x 4 | } 5 | 6 | val = 0 7 | ld val 8 | 9 | ; command: main.asm -o out.bin -d123=123 10 | ; error: unused define `123` -------------------------------------------------------------------------------- /tests/driver/err_define_invalid_value/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: u8} => 0x55 @ x 4 | } 5 | 6 | val = 0 7 | ld val 8 | 9 | ; command: main.asm -o out.bin -dval=abc 10 | ; error: invalid value for define `val` -------------------------------------------------------------------------------- /tests/driver/err_define_no_declaration/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: u8} => 0x55 @ x 4 | } 5 | 6 | ld val ; error: failed / note:_:3: within / error: unknown symbol `val` 7 | 8 | ; command: main.asm -o out.bin -dval -------------------------------------------------------------------------------- /tests/driver/err_define_unused/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: u8} => 0x55 @ x 4 | } 5 | 6 | val = 0 7 | ld val 8 | 9 | ; command: main.asm -o out.bin -dvalue=0x55 10 | ; error: unused define `value` -------------------------------------------------------------------------------- /tests/driver/err_format_annotated_invalid_base/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | 9 | ; command: main.asm -f annotated,group:4,base:3 -o out.txt 10 | ; error: invalid format argument `annotated,base -------------------------------------------------------------------------------- /tests/driver/err_format_expected_string/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | #d "hello, world!" 9 | #d "hello, world!" 10 | #d "hello, world!" 11 | #d "hello, world!" 12 | 13 | ; command: main.asm -f list,base:16,between:20 -o out.txt 14 | ; error: invalid format argument `list,between -------------------------------------------------------------------------------- /tests/driver/err_format_invalid_arg/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | 9 | ; command: main.asm -f annotated,group:2,unknown:32 -o out.txt 10 | ; error: unknown format argument `annotated,unknown` -------------------------------------------------------------------------------- /tests/driver/err_format_invalid_arg_multiple/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | 9 | ; command: main.asm -f annotated,unknown1:64,group:2,unknown2:32 -o out.txt 10 | ; error: unknown format argument `annotated,unknown1` 11 | ; error: unknown format argument `annotated,unknown2` -------------------------------------------------------------------------------- /tests/driver/err_format_invalid_value/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | 9 | ; command: main.asm -f annotated,group:2,base:8:16 -o out.txt 10 | ; error: invalid format argument `annotated,base -------------------------------------------------------------------------------- /tests/driver/err_format_malformed_string/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | #d "hello, world!" 9 | #d "hello, world!" 10 | #d "hello, world!" 11 | #d "hello, world!" 12 | 13 | ; command: main.asm -f list,base:16,between:"20 -o out.txt 14 | ; error: invalid format argument `list,between -------------------------------------------------------------------------------- /tests/driver/err_format_unknown/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | 9 | ; command: main.asm -f unknown -o out.txt 10 | ; error: unknown format -------------------------------------------------------------------------------- /tests/driver/err_iters_0/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | 9 | ; command: main.asm -t 0 10 | ; error: invalid argument for `--iters` -------------------------------------------------------------------------------- /tests/driver/err_iters_invalid/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | 9 | ; command: main.asm -t x 10 | ; error: invalid argument for `--iters` -------------------------------------------------------------------------------- /tests/driver/err_overwrite/main.asm: -------------------------------------------------------------------------------- 1 | ; command: main.bin 2 | ; error: safe output filename -------------------------------------------------------------------------------- /tests/driver/ok_color_off/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | 9 | ; command: main.asm --color=off 10 | ; output: main.bin -------------------------------------------------------------------------------- /tests/driver/ok_color_off/main.bin: -------------------------------------------------------------------------------- 1 | UU -------------------------------------------------------------------------------- /tests/driver/ok_color_on/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | 9 | ; command: main.asm --color=on 10 | ; output: main.bin -------------------------------------------------------------------------------- /tests/driver/ok_color_on/main.bin: -------------------------------------------------------------------------------- 1 | UU -------------------------------------------------------------------------------- /tests/driver/ok_define_if1/err_no_define.asm: -------------------------------------------------------------------------------- 1 | #include "include.asm" ; error:include.asm:5: invalid argument types 2 | 3 | ; command: err_no_define.asm -o out.bin -------------------------------------------------------------------------------- /tests/driver/ok_define_if1/include.asm: -------------------------------------------------------------------------------- 1 | #d 0xaa 2 | 3 | variant = {} 4 | 5 | #if variant == 0 6 | { 7 | #d 0x00 8 | } 9 | #elif variant == 1 10 | { 11 | #d 0x11 12 | } 13 | #elif variant == 2 14 | { 15 | #d 0x22 16 | } 17 | 18 | #d 0xff -------------------------------------------------------------------------------- /tests/driver/ok_define_if1/ok_variant0.asm: -------------------------------------------------------------------------------- 1 | #include "include.asm" 2 | 3 | ; command: ok_variant0.asm -fhexstr -o out_variant0.txt -dvariant=0 4 | ; output: out_variant0.txt -------------------------------------------------------------------------------- /tests/driver/ok_define_if1/ok_variant1.asm: -------------------------------------------------------------------------------- 1 | #include "include.asm" 2 | 3 | ; command: ok_variant1.asm -fhexstr -o out_variant1.txt -dvariant=1 4 | ; output: out_variant1.txt -------------------------------------------------------------------------------- /tests/driver/ok_define_if1/ok_variant2.asm: -------------------------------------------------------------------------------- 1 | #include "include.asm" 2 | 3 | ; command: ok_variant2.asm -fhexstr -o out_variant2.txt -dvariant=2 4 | ; output: out_variant2.txt -------------------------------------------------------------------------------- /tests/driver/ok_define_if1/ok_variant3.asm: -------------------------------------------------------------------------------- 1 | #include "include.asm" 2 | 3 | ; command: ok_variant3.asm -fhexstr -o out_variant3.txt -dvariant=555 4 | ; output: out_variant3.txt -------------------------------------------------------------------------------- /tests/driver/ok_define_if1/out_variant0.txt: -------------------------------------------------------------------------------- 1 | aa00ff -------------------------------------------------------------------------------- /tests/driver/ok_define_if1/out_variant1.txt: -------------------------------------------------------------------------------- 1 | aa11ff -------------------------------------------------------------------------------- /tests/driver/ok_define_if1/out_variant2.txt: -------------------------------------------------------------------------------- 1 | aa22ff -------------------------------------------------------------------------------- /tests/driver/ok_define_if1/out_variant3.txt: -------------------------------------------------------------------------------- 1 | aaff -------------------------------------------------------------------------------- /tests/driver/ok_define_if2/include.asm: -------------------------------------------------------------------------------- 1 | #d 0xaa 2 | 3 | variant = false 4 | 5 | #if variant 6 | { 7 | #d 0x11 8 | } 9 | 10 | #d 0xff -------------------------------------------------------------------------------- /tests/driver/ok_define_if2/ok_variant_false.asm: -------------------------------------------------------------------------------- 1 | #include "include.asm" 2 | 3 | ; command: ok_variant_false.asm -fhexstr -o out_variant_false.txt -dvariant=false 4 | ; output: out_variant_false.txt -------------------------------------------------------------------------------- /tests/driver/ok_define_if2/ok_variant_novalue.asm: -------------------------------------------------------------------------------- 1 | #include "include.asm" 2 | 3 | ; command: ok_variant_novalue.asm -fhexstr -o out_variant_novalue.txt -dvariant 4 | ; output: out_variant_novalue.txt -------------------------------------------------------------------------------- /tests/driver/ok_define_if2/ok_variant_omitted.asm: -------------------------------------------------------------------------------- 1 | #include "include.asm" 2 | 3 | ; command: ok_variant_omitted.asm -fhexstr -o out_variant_omitted.txt 4 | ; output: out_variant_omitted.txt -------------------------------------------------------------------------------- /tests/driver/ok_define_if2/ok_variant_true.asm: -------------------------------------------------------------------------------- 1 | #include "include.asm" 2 | 3 | ; command: ok_variant_true.asm -fhexstr -o out_variant_true.txt -dvariant=true 4 | ; output: out_variant_true.txt -------------------------------------------------------------------------------- /tests/driver/ok_define_if2/out_variant_false.txt: -------------------------------------------------------------------------------- 1 | aaff -------------------------------------------------------------------------------- /tests/driver/ok_define_if2/out_variant_novalue.txt: -------------------------------------------------------------------------------- 1 | aa11ff -------------------------------------------------------------------------------- /tests/driver/ok_define_if2/out_variant_omitted.txt: -------------------------------------------------------------------------------- 1 | aaff -------------------------------------------------------------------------------- /tests/driver/ok_define_if2/out_variant_true.txt: -------------------------------------------------------------------------------- 1 | aa11ff -------------------------------------------------------------------------------- /tests/driver/ok_define_nested/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: u8} => 0x55 @ x 4 | } 5 | 6 | val1 = 0 7 | .val1 = 0 8 | ..val1 = 0 9 | ..val2 = 0 10 | val2 = 0 11 | ld val1 12 | ld val1.val1 13 | ld val1.val1.val1 14 | ld val1.val1.val2 15 | ld val2 16 | 17 | ; command: main.asm -fhexstr -o out.txt -dval1=0x55 -dval1.val1.val1=0x61 --define val1.val1.val2=0x62 18 | ; output: out.txt -------------------------------------------------------------------------------- /tests/driver/ok_define_nested/out.txt: -------------------------------------------------------------------------------- 1 | 55555500556155625500 -------------------------------------------------------------------------------- /tests/driver/ok_define_simple_novalue/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: u8} => 0x55 @ x 4 | } 5 | 6 | val1 = 0 7 | val2 = {} 8 | ld val1 ? 1 : 0 9 | ld val2 ? 1 : 0 10 | 11 | ; command: main.asm -fhexstr -o out.txt -dval1 --define val2 12 | ; output: out.txt -------------------------------------------------------------------------------- /tests/driver/ok_define_simple_novalue/out.txt: -------------------------------------------------------------------------------- 1 | 55015501 -------------------------------------------------------------------------------- /tests/driver/ok_define_simple_value/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: i8} => 0x55 @ x 4 | } 5 | 6 | val1 = 0 7 | val2 = {} 8 | val3 = false 9 | val4 = 1 10 | ld val1 11 | ld val2 12 | ld val3 13 | ld val4 14 | 15 | ; command: main.asm -fhexstr -o out.txt -dval1=85 --define val2=0x55 -dval3=-1 --define=val4=0xff 16 | ; output: out.txt -------------------------------------------------------------------------------- /tests/driver/ok_define_simple_value/out.txt: -------------------------------------------------------------------------------- 1 | 5555555555ff55ff -------------------------------------------------------------------------------- /tests/driver/ok_format_annotated/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | 9 | ; command: main.asm -f annotated -o out.txt 10 | ; output: out.txt -------------------------------------------------------------------------------- /tests/driver/ok_format_annotated/out.txt: -------------------------------------------------------------------------------- 1 | outp | addr | data (base 16) 2 | 3 | 0:0 | 0 | 55 ; halt 4 | 1:0 | 1 | 55 ; halt 5 | -------------------------------------------------------------------------------- /tests/driver/ok_format_annotated_args/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | halt 9 | halt 10 | 11 | ; command: main.asm -f annotated,base:8,group:4 -o out.txt 12 | ; output: out.txt -------------------------------------------------------------------------------- /tests/driver/ok_format_annotated_args/out.txt: -------------------------------------------------------------------------------- 1 | outp | addr | data (base 8) 2 | 3 | 0:0 | 0 | 252 ; halt 4 | 0:8 | 1 | 252 ; halt 5 | 1:4 | 2 | 252 ; halt 6 | 2:0 | 3 | 252 ; halt 7 | -------------------------------------------------------------------------------- /tests/driver/ok_format_intelhex/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | #d "hello, world!" 9 | #d "hello, world!" 10 | #d "hello, world!" 11 | #d "hello, world!" 12 | 13 | ; command: main.asm -f intelhex -o out.txt 14 | ; output: out.txt -------------------------------------------------------------------------------- /tests/driver/ok_format_intelhex/out.txt: -------------------------------------------------------------------------------- 1 | :20000000555568656C6C6F2C20776F726C642168656C6C6F2C20776F726C642168656C6C3F 2 | :160020006F2C20776F726C642168656C6C6F2C20776F726C64211D 3 | :00000001FF -------------------------------------------------------------------------------- /tests/driver/ok_format_intelhex_blocks1/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | #d64 0 7 | halt 8 | #d8 0 9 | halt 10 | 11 | #addr 0x200 12 | #d "hello" 13 | 14 | ; command: main.asm -f intelhex -o out.txt 15 | ; output: out.txt -------------------------------------------------------------------------------- /tests/driver/ok_format_intelhex_blocks1/out.txt: -------------------------------------------------------------------------------- 1 | :0B00000000000000000000005500554B 2 | :0502000068656C6C6FE5 3 | :00000001FF -------------------------------------------------------------------------------- /tests/driver/ok_format_intelhex_blocks2/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | #addr 0x100 7 | 8 | #d64 0 9 | halt 10 | #d8 0 11 | halt 12 | 13 | #addr 0x200 14 | label1: 15 | #d "hello" 16 | #d256 0 17 | 18 | #addr 0x400 19 | #d "world" 20 | label2: 21 | #d64 0 22 | 23 | #addr 0x600 24 | label3: 25 | 26 | ; command: main.asm -f intelhex -o out.txt 27 | ; output: out.txt -------------------------------------------------------------------------------- /tests/driver/ok_format_intelhex_blocks2/out.txt: -------------------------------------------------------------------------------- 1 | :0B01000000000000000000005500554A 2 | :2002000068656C6C6F000000000000000000000000000000000000000000000000000000CA 3 | :050220000000000000D9 4 | :0D040000776F726C640000000000000000C7 5 | :00000001FF -------------------------------------------------------------------------------- /tests/driver/ok_format_list/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | #d "hello, world!" 9 | #d "hello, world!" 10 | #d "hello, world!" 11 | #d "hello, world!" 12 | 13 | ; command: main.asm -f list -o out.txt 14 | ; output: out.txt -------------------------------------------------------------------------------- /tests/driver/ok_format_list/out.txt: -------------------------------------------------------------------------------- 1 | 555568656c6c6f2c20776f726c642168656c6c6f2c20776f726c642168656c6c6f2c20776f726c642168656c6c6f2c20776f726c6421 -------------------------------------------------------------------------------- /tests/driver/ok_format_list_custom1/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | #d "hello, world!" 9 | #d "hello, world!" 10 | #d "hello, world!" 11 | #d "hello, world!" 12 | 13 | ; command: main.asm -f list,base:16,group:2,before:"begin\x20data\n",after:"\nend\x20data",between:"\x20" -o out.txt 14 | ; output: out.txt -------------------------------------------------------------------------------- /tests/driver/ok_format_list_custom1/out.txt: -------------------------------------------------------------------------------- 1 | begin data 2 | 55 55 68 65 6c 6c 6f 2c 20 77 6f 72 6c 64 21 68 65 6c 6c 6f 2c 20 77 6f 72 6c 64 21 68 65 6c 6c 6f 2c 20 77 6f 72 6c 64 21 68 65 6c 6c 6f 2c 20 77 6f 72 6c 64 21 3 | end data -------------------------------------------------------------------------------- /tests/driver/ok_format_list_custom2/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | #d "hello, world!" 9 | #d "hello, world!" 10 | #d "hello, world!" 11 | #d "hello, world!" 12 | 13 | ; command: main.asm -f list,base:16,group:2,group2:16,before:"begin\n\t",after:"\nend",between:"\x20",between2:"\n\t" -o out.txt 14 | ; output: out.txt -------------------------------------------------------------------------------- /tests/driver/ok_format_list_custom2/out.txt: -------------------------------------------------------------------------------- 1 | begin 2 | 55 55 68 65 6c 6c 6f 2c 20 77 6f 72 6c 64 21 68 3 | 65 6c 6c 6f 2c 20 77 6f 72 6c 64 21 68 65 6c 6c 4 | 6f 2c 20 77 6f 72 6c 64 21 68 65 6c 6c 6f 2c 20 5 | 77 6f 72 6c 64 21 6 | end -------------------------------------------------------------------------------- /tests/driver/ok_format_multiple/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | start: 7 | halt 8 | loop: 9 | halt 10 | .inner: 11 | halt 12 | 13 | ; command: main.asm -f annotated,base:8,group:4 -- -f symbols -o symbols.txt -- -f binary 14 | ; output: main.txt 15 | ; output: symbols.txt 16 | ; output: main.bin -------------------------------------------------------------------------------- /tests/driver/ok_format_multiple/main.bin: -------------------------------------------------------------------------------- 1 | UUU -------------------------------------------------------------------------------- /tests/driver/ok_format_multiple/main.txt: -------------------------------------------------------------------------------- 1 | outp | addr | data (base 8) 2 | 3 | 0:0 | 0 | ; start: 4 | 0:0 | 0 | 252 ; halt 5 | 0:8 | 1 | ; loop: 6 | 0:8 | 1 | 252 ; halt 7 | 1:4 | 2 | ; .inner: 8 | 1:4 | 2 | 252 ; halt 9 | -------------------------------------------------------------------------------- /tests/driver/ok_format_multiple/symbols.txt: -------------------------------------------------------------------------------- 1 | start = 0x0 2 | loop = 0x1 3 | loop.inner = 0x2 4 | -------------------------------------------------------------------------------- /tests/driver/ok_format_symbol/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | start: 7 | halt 8 | loop: 9 | halt 10 | .inner: 11 | halt 12 | 13 | ; command: main.asm -f symbols -o out.txt 14 | ; output: out.txt -------------------------------------------------------------------------------- /tests/driver/ok_format_symbol/out.txt: -------------------------------------------------------------------------------- 1 | start = 0x0 2 | loop = 0x1 3 | loop.inner = 0x2 4 | -------------------------------------------------------------------------------- /tests/driver/ok_format_symbol_noemit/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: u8} => 0x55 @ x 4 | } 5 | 6 | #fn add1(x) => x + 1 7 | 8 | start: 9 | x1 = add1(0x10) 10 | ld x1 11 | 12 | #const x2 = 0x11 13 | ld x2 14 | 15 | #const(noemit) x3 = 0x11 16 | ld x3 17 | 18 | loop: 19 | #const y1 = 0x22 20 | ld y1 21 | 22 | #const y2 = 0x22 23 | ld y2 24 | 25 | #const(noemit) y3 = 0x22 26 | ld y3 27 | 28 | .inner: 29 | .z1 = 0x33 30 | ld .z1 31 | 32 | #const .z2 = 0x33 33 | ld .z2 34 | 35 | #const(noemit) .z3 = 0x33 36 | ld .z3 37 | 38 | ; command: main.asm -f symbols -o out.txt 39 | ; output: out.txt -------------------------------------------------------------------------------- /tests/driver/ok_format_symbol_noemit/out.txt: -------------------------------------------------------------------------------- 1 | start = 0x0 2 | x1 = 0x11 3 | x2 = 0x11 4 | loop = 0x6 5 | y1 = 0x22 6 | y2 = 0x22 7 | y3.inner = 0xc 8 | y3.z1 = 0x33 9 | y3.z2 = 0x33 10 | -------------------------------------------------------------------------------- /tests/driver/ok_iters_1/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | 9 | ; command: main.asm -t 1 10 | ; output: main.bin -------------------------------------------------------------------------------- /tests/driver/ok_iters_1/main.bin: -------------------------------------------------------------------------------- 1 | UU -------------------------------------------------------------------------------- /tests/driver/ok_iters_3/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | 9 | ; command: main.asm --iters=3 10 | ; output: main.bin -------------------------------------------------------------------------------- /tests/driver/ok_iters_3/main.bin: -------------------------------------------------------------------------------- 1 | UU -------------------------------------------------------------------------------- /tests/driver/ok_no_output_filename/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | 9 | ; command: main.asm 10 | ; output: main.bin -------------------------------------------------------------------------------- /tests/driver/ok_no_output_filename/main.bin: -------------------------------------------------------------------------------- 1 | UU -------------------------------------------------------------------------------- /tests/driver/ok_simple/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | halt 8 | 9 | ; command: main.asm -o out.bin 10 | ; output: out.bin -------------------------------------------------------------------------------- /tests/driver/ok_simple/out.bin: -------------------------------------------------------------------------------- 1 | UU -------------------------------------------------------------------------------- /tests/expr_asm/err_arg_expect_brace.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8}, {y: i8} => x @ y 4 | test {x}, {y} => asm { emit {x, y} } 5 | } 6 | 7 | test 0x12, 0x34 ; error: failed / note:_:4: within / error:_:4: expected `}` -------------------------------------------------------------------------------- /tests/expr_asm/err_arg_expect_ident.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => x 4 | test {x} => asm { emit {} } 5 | } 6 | 7 | test 0x12 ; error: failed / note:_:4: within / error:_:4: expected identifier -------------------------------------------------------------------------------- /tests/expr_asm/err_arg_local_deep_no_braces.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => x 4 | 5 | test2 {x} => { 6 | y = 0x10 + x 7 | asm { emit y } 8 | } 9 | 10 | test1 {x} => { 11 | y = 0x10 + x 12 | asm { test2 {y} } 13 | } 14 | } 15 | 16 | test1 2 ; error: failed / note:_:10: within / note:_:12: test2 :y / error:_:12: failed / note:_:5: within / error:_:7: failed / note:_:3: within / error:_:7: unknown -------------------------------------------------------------------------------- /tests/expr_asm/err_arg_local_no_braces1.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => x 4 | test {x} => { 5 | asm { emit {x} + x } 6 | } 7 | } 8 | 9 | test 2 ; error: failed / note:_:4: within / note:_:5: emit 2 + x / error:_:5: failed / note:_:3: within / error:_:5: unknown symbol `x` -------------------------------------------------------------------------------- /tests/expr_asm/err_arg_local_no_braces2.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => x 4 | test {x} => { 5 | y = 0x10 6 | asm { emit {x} + y } 7 | } 8 | } 9 | 10 | test 2 ; error: failed / note:_:4: within / note:_:6: emit 2 + y / error:_:6: failed / note:_:3: within / error:_:6: unknown symbol `y` -------------------------------------------------------------------------------- /tests/expr_asm/err_arg_no_braces.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => x 4 | test {x} => asm { emit x } 5 | } 6 | 7 | test 0x12 ; error: failed / note:_:4: within / error:_:4: failed / note:_:3: within / error:_:4: unknown -------------------------------------------------------------------------------- /tests/expr_asm/err_infinite_recursion.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | test {x} => asm { test {x} } 4 | } 5 | 6 | test 0x12 ; error: failed / note:_:3: within / error:_:3: failed / note:_:3: test 0x12 / error:_:3: recursion -------------------------------------------------------------------------------- /tests/expr_asm/err_inner_error.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x} => x / 0 4 | test {x} => asm { emit {x} } 5 | } 6 | 7 | test 12 ; error: failed / note:_:4: within / note:_:4: emit 12 / error:_:4: failed / note:_:3: within / error:_:3: zero -------------------------------------------------------------------------------- /tests/expr_asm/err_invalid.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | hlt => 0x12 4 | stop => asm { 5 | hlt 6 | #d 0x34 7 | hlt 8 | } 9 | } 10 | 11 | stop ; error: failed / note:_:4: within / error:_:6: invalid 12 | stop 13 | hlt -------------------------------------------------------------------------------- /tests/expr_asm/err_label_convergence.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x <= 0x8) 6 | 0x11 @ x`16 7 | } 8 | 9 | ld {x} => 10 | { 11 | assert(x > 0x8) 12 | 0x22 @ x`8 13 | } 14 | 15 | test => asm { 16 | ld label 17 | ld label 18 | ld label 19 | label: 20 | } 21 | } 22 | 23 | test ; error: failed / note:_:15: within / error:_:15: did not converge 24 | -------------------------------------------------------------------------------- /tests/expr_asm/err_multiple_failed.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => { 4 | assert(x < 0x10) 5 | x 6 | } 7 | emit {x: i8} => { 8 | assert(x >= 0x10 && x < 0x20) 9 | x 10 | } 11 | test {x} => asm { emit {x} } 12 | } 13 | 14 | test 0x30 ; error: failed / note:_:11: within / error:_:11: failed / note:_:11: emit 0x30 / note:_:3: within / error:_:4: assertion / note:_:7: within / error:_:8: assertion -------------------------------------------------------------------------------- /tests/expr_asm/err_multiple_matches.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => x 4 | emit {x: i8} => x 5 | test {x} => asm { emit {x} } 6 | } 7 | 8 | test 0x12 ; error: failed / note:_:5: within / note:_:5: emit 0x12 / error:_:5: multiple / note:_:3: match / note:_:4: match -------------------------------------------------------------------------------- /tests/expr_asm/err_no_match.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | test {x} => asm { unknown {x} } 4 | } 5 | 6 | test 0x12 ; error: failed / note:_:3: within / note:_:3: unknown 0x12 / error:_:3: no match -------------------------------------------------------------------------------- /tests/expr_asm/err_pc_misaligned.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | ld {addr: u8} => 0xee @ addr 4 | test => asm { 5 | ld 0x11 6 | ld 0x22 7 | ld $ 8 | ld 0x33 9 | } 10 | } 11 | 12 | #d 0xf 13 | test ; error: failed / note:_:4: within / error:_:7: failed / note:_:3: within / error:_:7: not aligned / note: 4 more bits -------------------------------------------------------------------------------- /tests/expr_asm/err_subrule_morph_no_match1.asm: -------------------------------------------------------------------------------- 1 | #subruledef reg 2 | { 3 | a => 0xaa 4 | b => 0xbb 5 | } 6 | 7 | #ruledef reg2 8 | { 9 | a => 0xaa 10 | b => 0xbb 11 | c => 0xcc 12 | } 13 | 14 | #ruledef 15 | { 16 | emit {r: reg} => r 17 | test {r: reg2} => asm { emit {r} } 18 | } 19 | 20 | test a 21 | test b 22 | test c 23 | emit a 24 | emit b 25 | emit c ; error: no match -------------------------------------------------------------------------------- /tests/expr_asm/err_subrule_morph_no_match2.asm: -------------------------------------------------------------------------------- 1 | #subruledef reg 2 | { 3 | a => 0xaa 4 | b => 0xbb 5 | } 6 | 7 | #ruledef reg2 8 | { 9 | a => 0xaa 10 | b => 0xbb 11 | c => 0xcc 12 | } 13 | 14 | #ruledef 15 | { 16 | emit {r: reg} => r 17 | test {r: reg2} => asm { emit {r} } 18 | } 19 | 20 | test a 21 | test b 22 | test c ; error: failed / note:_:17: within / note:_:17: emit c / error:_:17: no match -------------------------------------------------------------------------------- /tests/expr_asm/err_subrule_no_match1.asm: -------------------------------------------------------------------------------- 1 | #subruledef reg 2 | { 3 | a => 0xaa 4 | b => 0xbb 5 | } 6 | 7 | #ruledef 8 | { 9 | emit {r: reg} => r 10 | test {r: reg} => asm { emit {r} } 11 | } 12 | 13 | 14 | test c ; error: no match -------------------------------------------------------------------------------- /tests/expr_asm/err_subrule_no_match2.asm: -------------------------------------------------------------------------------- 1 | #ruledef reg 2 | { 3 | a => 0xaa 4 | b => 0xbb 5 | } 6 | 7 | #ruledef 8 | { 9 | emit {r: reg} => r 10 | test {r: reg} => asm { emit {r} } 11 | } 12 | 13 | 14 | test 0x12 ; error: no match -------------------------------------------------------------------------------- /tests/expr_asm/err_subrule_subst_unknown.asm: -------------------------------------------------------------------------------- 1 | #subruledef reg 2 | { 3 | a => 0xaa 4 | b => 0xbb 5 | } 6 | 7 | #ruledef 8 | { 9 | emit {r: reg} => r 10 | test {r: reg} => asm { emit {x} } 11 | } 12 | 13 | test a ; error: failed / note:_:10: within / error:_:10: unknown -------------------------------------------------------------------------------- /tests/expr_asm/err_subrule_subst_unused.asm: -------------------------------------------------------------------------------- 1 | #subruledef reg 2 | { 3 | a => 0xaa 4 | b => 0xbb 5 | } 6 | 7 | #ruledef 8 | { 9 | emit {r: reg} => r 10 | test {r: reg} => asm { emit r } 11 | } 12 | 13 | test a ; error: failed / note:_:10: within / error:_:10: no match -------------------------------------------------------------------------------- /tests/expr_asm/err_unsized.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x} => x 4 | test {x} => asm { emit {x} } 5 | } 6 | 7 | test 12 ; error: failed / note:_:4: within / note:_:4: emit 12 / error:_:4: failed / error:_:3: definite size -------------------------------------------------------------------------------- /tests/expr_asm/ok_arg.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => x 4 | test {x} => asm { emit {x} } 5 | } 6 | 7 | emit 0x12 ; = 0x12 8 | test 0x12 ; = 0x12 9 | test 0x10 + 2 ; = 0x12 -------------------------------------------------------------------------------- /tests/expr_asm/ok_arg_across_ruledefs.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | test {x} => asm { emit {x} } 4 | } 5 | 6 | #ruledef 7 | { 8 | emit {x: i8} => x 9 | } 10 | 11 | emit 0x12 ; = 0x12 12 | test 0x12 ; = 0x12 -------------------------------------------------------------------------------- /tests/expr_asm/ok_arg_assert.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => 4 | { 5 | assert(x < 0x10) 6 | 0x11 @ x 7 | } 8 | emit {x: i8} => 9 | { 10 | assert(x >= 0x10) 11 | 0x22 @ x 12 | } 13 | test {x} => asm { emit {x} } 14 | } 15 | 16 | emit 0x08 ; = 0x1108 17 | emit 0x12 ; = 0x2212 18 | test 0x08 ; = 0x1108 19 | test 0x12 ; = 0x2212 -------------------------------------------------------------------------------- /tests/expr_asm/ok_arg_concat.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => x 4 | test {x} => asm { emit {x} } @ asm { emit 0xff } 5 | } 6 | 7 | emit 0x12 ; = 0x12 8 | test 0x12 ; = 0x12ff 9 | test 0x10 + 2 ; = 0x12ff -------------------------------------------------------------------------------- /tests/expr_asm/ok_arg_constant.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => x 4 | test {x} => { 5 | asm { emit {x} + y } 6 | } 7 | } 8 | 9 | test 2 ; = 0x12 10 | y = 0x10 -------------------------------------------------------------------------------- /tests/expr_asm/ok_arg_constant_hierarchy.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => x 4 | test {x} => { 5 | asm { emit {x} + y.z } 6 | } 7 | } 8 | 9 | test 2 ; = 0x22 10 | y: 11 | .z = 0x20 -------------------------------------------------------------------------------- /tests/expr_asm/ok_arg_constant_hierarchy_dependent.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => x 4 | test {x} => { 5 | asm { emit {x} + y.z } 6 | } 7 | } 8 | 9 | test 2 ; = 0x23 10 | y: 11 | .z = y + 0x20 -------------------------------------------------------------------------------- /tests/expr_asm/ok_arg_inner_expr.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => x 4 | test {x} => asm { emit {x} + 0x10 } 5 | } 6 | 7 | test 2 ; = 0x12 8 | test 1 + 1 ; = 0x12 -------------------------------------------------------------------------------- /tests/expr_asm/ok_arg_inner_expr_precedence.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => x 4 | test {x} => asm { emit {x} * 0x10 } 5 | } 6 | 7 | test 3 ; = 0x30 8 | test 1 + 2 ; = 0x21 9 | test 1 + 2 + 3 ; = 0x33 -------------------------------------------------------------------------------- /tests/expr_asm/ok_arg_label.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => x 4 | test {x} => { 5 | asm { emit {x} + y } 6 | } 7 | } 8 | 9 | y: 10 | test 2 ; = 0x02 -------------------------------------------------------------------------------- /tests/expr_asm/ok_arg_label_deferred.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => x 4 | test {x} => { 5 | asm { emit {x} + y } 6 | } 7 | } 8 | 9 | test 2 ; = 0x03 10 | y: -------------------------------------------------------------------------------- /tests/expr_asm/ok_arg_local.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => x 4 | test {x} => { 5 | y = 0x10 6 | asm { emit {x} + {y} } 7 | } 8 | } 9 | 10 | test 2 ; = 0x12 -------------------------------------------------------------------------------- /tests/expr_asm/ok_arg_local_deep.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => x 4 | 5 | test2 {x} => { 6 | y = 0x10 + x 7 | asm { emit {y} } 8 | } 9 | 10 | test1 {x} => { 11 | y = 0x10 + x 12 | asm { test2 {y} } 13 | } 14 | } 15 | 16 | test1 2 ; = 0x22 -------------------------------------------------------------------------------- /tests/expr_asm/ok_arg_local_precedence.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => x 4 | test {x} => { 5 | y = x 6 | asm { emit {y} * 0x10 } 7 | } 8 | } 9 | 10 | test 3 ; = 0x30 11 | test 1 + 2 ; = 0x30 12 | test 1 + 2 + 3 ; = 0x60 -------------------------------------------------------------------------------- /tests/expr_asm/ok_arg_multiline.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => 0x11 @ x 4 | test {x} => asm { 5 | emit {x} 6 | emit 0xff 7 | emit {x} 8 | } 9 | } 10 | 11 | test 0x12 ; = 0x1112_11ff_1112 12 | test 0x10 + 2 ; = 0x1112_11ff_1112 -------------------------------------------------------------------------------- /tests/expr_asm/ok_arg_repeat.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8} => 0x11 @ x 4 | load {x: i8} => 0x22 @ x 5 | test {x} => asm { 6 | emit {x} 7 | emit 0xff 8 | load {x} 9 | } 10 | } 11 | 12 | test 0x12 ; = 0x1112_11ff_2212 -------------------------------------------------------------------------------- /tests/expr_asm/ok_args.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8}, {y: i8} => x @ y 4 | test {x}, {y} => asm { emit {x}, {y} } 5 | } 6 | 7 | test 0x12, 0x34 ; = 0x1234 8 | test 0x10 + 2, 0x30 + 4 ; = 0x1234 -------------------------------------------------------------------------------- /tests/expr_asm/ok_args_whitespace.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: i8}, {y: i8} => x @ y 4 | test {x}, {y} => asm { emit { x }, { y } } 5 | } 6 | 7 | test 0x12, 0x34 ; = 0x1234 8 | test 0x10 + 2, 0x30 + 4 ; = 0x1234 -------------------------------------------------------------------------------- /tests/expr_asm/ok_empty.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | hlt => 0x12 @ asm {} 4 | abort => 0x34 @ asm { } 5 | stop => 0x56 @ asm { 6 | 7 | } 8 | } 9 | 10 | hlt ; = 0x12 11 | hlt ; = 0x12 12 | abort ; = 0x34 13 | abort ; = 0x34 14 | stop ; = 0x56 15 | stop ; = 0x56 -------------------------------------------------------------------------------- /tests/expr_asm/ok_label_convergence.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x <= 0x8) 6 | 0x11 @ x`16 7 | } 8 | 9 | ld {x} => 10 | { 11 | assert(x > 0x8) 12 | 0x22 @ x`8 13 | } 14 | 15 | test => asm { 16 | ld label 17 | ld label 18 | label: 19 | } 20 | } 21 | 22 | test ; = 0x110006_110006 23 | -------------------------------------------------------------------------------- /tests/expr_asm/ok_label_forwardref.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | jmp {addr: u8} => 0xee @ addr 4 | loop => asm { 5 | jmp 0x11 6 | jmp label 7 | label: 8 | jmp 0x22 9 | jmp 0x33 10 | } 11 | } 12 | 13 | loop ; = 0xee11_ee04_ee22_ee33 -------------------------------------------------------------------------------- /tests/expr_asm/ok_label_shadowing.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | jmp {addr: u8} => 0xee @ addr 4 | loop => asm { 5 | jmp 0x11 6 | label: 7 | jmp 0x22 8 | jmp label 9 | jmp 0x33 10 | } 11 | } 12 | 13 | label: 14 | loop ; = 0xee11_ee22_ee02_ee33 -------------------------------------------------------------------------------- /tests/expr_asm/ok_label_simple.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | jmp {addr: u8} => 0xee @ addr 4 | loop => asm { 5 | jmp 0x11 6 | label: 7 | jmp 0x22 8 | jmp label 9 | jmp 0x33 10 | } 11 | } 12 | 13 | loop ; = 0xee11_ee22_ee02_ee33 -------------------------------------------------------------------------------- /tests/expr_asm/ok_pc.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | ld {addr: u8} => 0xee @ addr 4 | test => asm { 5 | ld 0x11 6 | ld 0x22 7 | ld $ 8 | ld 0x33 9 | ld $ 10 | ld 0x44 11 | } 12 | } 13 | 14 | test ; = 0xee11_ee22_ee04_ee33_ee08_ee44 -------------------------------------------------------------------------------- /tests/expr_asm/ok_ruledef_forward_ref.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | test {x} => asm { emit {x} } 4 | } 5 | 6 | test 0x12 ; = 0x12 7 | 8 | #ruledef 9 | { 10 | emit {x: i8} => x 11 | } -------------------------------------------------------------------------------- /tests/expr_asm/ok_simple.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | hlt => 0x12 4 | stop => asm { hlt } 5 | } 6 | 7 | stop ; = 0x12 8 | stop ; = 0x12 9 | hlt ; = 0x12 -------------------------------------------------------------------------------- /tests/expr_asm/ok_simple_multiline.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | hlt => 0x12 4 | stop => asm { 5 | hlt 6 | hlt 7 | hlt 8 | } 9 | } 10 | 11 | stop ; = 0x121212 12 | stop ; = 0x121212 13 | hlt ; = 0x12 -------------------------------------------------------------------------------- /tests/expr_asm/ok_subrule.asm: -------------------------------------------------------------------------------- 1 | #subruledef reg 2 | { 3 | a => 0xaa 4 | b => 0xbb 5 | } 6 | 7 | #ruledef 8 | { 9 | emit {r: reg} => r`8 10 | test {r: reg} => asm { emit {r} } 11 | } 12 | 13 | 14 | emit a ; = 0xaa 15 | emit b ; = 0xbb 16 | test a ; = 0xaa 17 | test b ; = 0xbb -------------------------------------------------------------------------------- /tests/expr_asm/ok_subrule_morph.asm: -------------------------------------------------------------------------------- 1 | #subruledef reg 2 | { 3 | a => 0xaa 4 | b => 0xbb 5 | } 6 | 7 | #ruledef reg2 8 | { 9 | a => 0xaa 10 | b => 0xbb 11 | c => 0xcc 12 | } 13 | 14 | #ruledef 15 | { 16 | emit {r: reg} => r 17 | test {r: reg2} => asm { emit {r} } 18 | } 19 | 20 | test a ; = 0xaa 21 | test b ; = 0xbb 22 | emit a ; = 0xaa 23 | emit b ; = 0xbb -------------------------------------------------------------------------------- /tests/expr_asm/ok_subrule_multiline.asm: -------------------------------------------------------------------------------- 1 | #subruledef reg 2 | { 3 | a => 0xaa 4 | b => 0xbb 5 | } 6 | 7 | #ruledef 8 | { 9 | emit {r: reg} => r`8 10 | test {r: reg} => asm { 11 | emit {r} 12 | emit b 13 | emit {r} 14 | } 15 | } 16 | 17 | test a ; = 0xaabbaa -------------------------------------------------------------------------------- /tests/expr_slice/ok_const.asm: -------------------------------------------------------------------------------- 1 | size = 4 + 4 2 | 3 | #ruledef test 4 | { 5 | ld {x} => { 6 | 0x55 @ x`size @ 0x44 7 | } 8 | } 9 | 10 | ld 0x33 ; = 0x553344 -------------------------------------------------------------------------------- /tests/expr_slice/ok_const_local.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => { 4 | size = 4 + 4 5 | 0x55 @ x`size @ 0x44 6 | } 7 | } 8 | 9 | ld 0x33 ; = 0x553344 -------------------------------------------------------------------------------- /tests/expr_slice/ok_deferred.asm: -------------------------------------------------------------------------------- 1 | #d 0xffff`(16 / size) ; = 0xff 2 | size = 2 -------------------------------------------------------------------------------- /tests/expr_slice/ok_var_local.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {size}, {x} => { 4 | 0x55 @ x`size @ 0x44 5 | } 6 | } 7 | 8 | ld 8, 0x33 ; = 0x553344 9 | ld 16, 0x33 ; = 0x55003344 10 | ld 16 + 16, 0x33 ; = 0x550000003344 11 | label: 12 | ld label + 3, 0x33 ; = 0x55003344 -------------------------------------------------------------------------------- /tests/fn_builtin_le/err_not_a_multiple1.asm: -------------------------------------------------------------------------------- 1 | #d le(0x1) ; error: failed / error: size multiple / note: size 4 -------------------------------------------------------------------------------- /tests/fn_builtin_le/err_not_a_multiple2.asm: -------------------------------------------------------------------------------- 1 | #d le(0x123) ; error: failed / error: size multiple / note: size 12 -------------------------------------------------------------------------------- /tests/fn_builtin_le/err_not_a_multiple3.asm: -------------------------------------------------------------------------------- 1 | #d le(0x12345) ; error: failed / error: size multiple / note: size 20 -------------------------------------------------------------------------------- /tests/fn_builtin_le/err_unsized1.asm: -------------------------------------------------------------------------------- 1 | #d le(0) ; error: failed / error: definite size -------------------------------------------------------------------------------- /tests/fn_builtin_le/err_unsized2.asm: -------------------------------------------------------------------------------- 1 | #d le(-1) ; error: failed / error: definite size -------------------------------------------------------------------------------- /tests/fn_builtin_le/err_unsized3.asm: -------------------------------------------------------------------------------- 1 | #d le(-0x01) ; error: failed / error: definite size -------------------------------------------------------------------------------- /tests/fn_builtin_le/ok_inside_rule.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | ld {addr: u16} => 0xaa @ le(addr) 4 | } 5 | 6 | ld 0 ; = 0xaa0000 7 | ld 12 ; = 0xaa0c00 8 | ld 0xff ; = 0xaaff00 9 | ld 0x1234 ; = 0xaa3412 -------------------------------------------------------------------------------- /tests/fn_builtin_le/ok_simple.asm: -------------------------------------------------------------------------------- 1 | #d le(0x00) ; = 0x00 2 | #d le(0x01) ; = 0x01 3 | #d le(0x80) ; = 0x80 4 | #d le(0xff) ; = 0xff 5 | #d le(0x00ff) ; = 0xff00 6 | #d le(0x0000ff) ; = 0xff0000 7 | #d le(0x00ff00) ; = 0x00ff00 8 | #d le(0x000000ff) ; = 0xff000000 9 | #d le(0xff000000) ; = 0x000000ff 10 | #d le(le(0x000000ff)) ; = 0x000000ff 11 | #d le(le(le(0x000000ff))) ; = 0xff000000 12 | #d le(0x0123) ; = 0x2301 13 | #d le(0x1234) ; = 0x3412 14 | #d le(0x123456) ; = 0x563412 15 | #d le(0x12345678) ; = 0x78563412 16 | #d le(0x123456789a) ; = 0x9a78563412 17 | #d le(0xffeeddccbbaa) ; = 0xaabbccddeeff 18 | #d le(le(0xffeeddccbbaa)) ; = 0xffeeddccbbaa 19 | #d le(le(le(0xffeeddccbbaa))) ; = 0xaabbccddeeff 20 | #d le(1234`16) ; = 0xd204 -------------------------------------------------------------------------------- /tests/fn_builtin_le/ok_statically_unknown.asm: -------------------------------------------------------------------------------- 1 | #d le(x`32) ; = 0x12000000 2 | #addr 0x12 3 | x: -------------------------------------------------------------------------------- /tests/fn_builtin_sizeof/err_unsized.asm: -------------------------------------------------------------------------------- 1 | #d sizeof(123) ; error: failed / error: definite size -------------------------------------------------------------------------------- /tests/fn_builtin_sizeof/ok_simple.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => { 4 | (sizeof(x) > 8 ? 0xff : 0x00) @ x @ sizeof(x)`8 5 | } 6 | } 7 | 8 | ld 0`0 ; = 0x00__00 9 | ld 0x0 ; = 0x00_0_04 10 | ld 0x00 ; = 0x00_00_08 11 | ld 0x12 ; = 0x00_12_08 12 | ld 0xff ; = 0x00_ff_08 13 | ld 0x100 ; = 0xff_100_0c 14 | ld 0x0100 ; = 0xff_0100_10 15 | ld 0x0000 ; = 0xff_0000_10 16 | ld 0xeeeee ; = 0xff_eeeee_14 17 | 18 | #d8 sizeof(0x1234) ; = 0x10 19 | #d8 sizeof("hello") ; = 0x28 -------------------------------------------------------------------------------- /tests/fn_simple/err_argument_type.asm: -------------------------------------------------------------------------------- 1 | #fn add1(value) => value + 1 2 | 3 | #d8 add1(2 > 1) ; error: failed / error: failed / note:_:1: within / error:_:1: argument types -------------------------------------------------------------------------------- /tests/fn_simple/err_duplicate.asm: -------------------------------------------------------------------------------- 1 | #fn add1(value) => value + 1 2 | #fn add1(value) => value + 1 ; error: duplicate / note:_:1: first declared -------------------------------------------------------------------------------- /tests/fn_simple/err_infinite_recursion.asm: -------------------------------------------------------------------------------- 1 | #fn recursive(value) => recursive(value) 2 | 3 | #d8 recursive(0) ; error: failed / error: failed / note:_:1: within / error:_:1: failed / error:_:1: recursion depth 4 | #d8 recursive(-2) 5 | #d8 recursive(2) -------------------------------------------------------------------------------- /tests/fn_simple/err_result_size_larger.asm: -------------------------------------------------------------------------------- 1 | #fn add1(value) => value + 1 2 | 3 | #d8 add1(0xffff) ; error: out of range / note: got size 17 -------------------------------------------------------------------------------- /tests/fn_simple/err_unknown_arg1.asm: -------------------------------------------------------------------------------- 1 | #fn add1(value) => xxxx + 1 2 | 3 | #d8 add1(0) ; error: failed / error: failed / note:_:1: within / error:_:1: unknown 4 | #d8 add1(-2) 5 | #d8 add1(2) 6 | #d8 add1(0xffff) -------------------------------------------------------------------------------- /tests/fn_simple/err_unknown_arg2.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | #fn add1(value) => xxxx + 1 7 | 8 | ld add1(0) ; error: failed / note:_:3: within / error: failed / note:_:6: within / error:_:6: unknown 9 | ld add1(-2) 10 | ld add1(2) 11 | ld add1(0xffff) -------------------------------------------------------------------------------- /tests/fn_simple/err_unknown_function.asm: -------------------------------------------------------------------------------- 1 | #fn add1(value) => value + 1 2 | 3 | #d8 xxxx(0) ; error: failed / error: unknown -------------------------------------------------------------------------------- /tests/fn_simple/err_wrong_args.asm: -------------------------------------------------------------------------------- 1 | #fn add(value1, value2, value3) => 2 | { 3 | value1 + value2 + value3 4 | } 5 | 6 | #d8 add(0) ; error: failed / error: expected 3 arguments 7 | #d8 add(0, 1) 8 | #d8 add(0, 1, 2, 3) -------------------------------------------------------------------------------- /tests/fn_simple/ok_args.asm: -------------------------------------------------------------------------------- 1 | #fn add(value1, value2, value3) => 2 | { 3 | value1 + value2 + value3 4 | } 5 | 6 | #d8 add(0, 1, 0) ; = 0x01 7 | #d8 add(4, -2, -3) ; = 0xff 8 | #d8 add(2, 3, 4) ; = 0x09 -------------------------------------------------------------------------------- /tests/fn_simple/ok_constant.asm: -------------------------------------------------------------------------------- 1 | #fn add_to_x(value) => value + x 2 | 3 | #d8 add_to_x(0) ; = 0x05 4 | #d8 add_to_x(-2) ; = 0x03 5 | #d8 add_to_x(-7) ; = 0xfe 6 | #d8 add_to_x(2) ; = 0x07 7 | 8 | x = 5 -------------------------------------------------------------------------------- /tests/fn_simple/ok_many_functions.asm: -------------------------------------------------------------------------------- 1 | #fn add1(value) => value + 1 2 | #fn add2(value) => add1(add1(value)) 3 | 4 | #d8 add2(0) ; = 0x02 5 | #d8 add2(-3) ; = 0xff 6 | #d8 add2(2) ; = 0x04 -------------------------------------------------------------------------------- /tests/fn_simple/ok_ruledef.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ add1(x)`8 4 | } 5 | 6 | #fn add1(value) => value + 1 7 | 8 | ld 0 ; = 0x5501 9 | ld -2 ; = 0x55ff 10 | ld 2 ; = 0x5503 11 | ld 0x100 ; = 0x5501 -------------------------------------------------------------------------------- /tests/fn_simple/ok_simple_multiline.asm: -------------------------------------------------------------------------------- 1 | #fn add1(value) => 2 | { 3 | value + 1 4 | } 5 | 6 | #d8 add1(0) ; = 0x01 7 | #d8 add1(-2) ; = 0xff 8 | #d8 add1(2) ; = 0x03 -------------------------------------------------------------------------------- /tests/fn_simple/ok_simple_oneliner.asm: -------------------------------------------------------------------------------- 1 | #fn add1(value) => value + 1 2 | 3 | #d8 add1(0) ; = 0x01 4 | #d8 add1(-2) ; = 0xff 5 | #d8 add1(2) ; = 0x03 -------------------------------------------------------------------------------- /tests/fn_simple/ok_symbol_nesting.asm: -------------------------------------------------------------------------------- 1 | functions: 2 | #fn add1(value) => value + 1 3 | 4 | data: 5 | #d8 add1(0) ; = 0x01 6 | #d8 add1(-2) ; = 0xff 7 | #d8 add1(2) ; = 0x03 -------------------------------------------------------------------------------- /tests/fuzz/crash1.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | ld {value} e => 0x55 @ value 4 | } 5 | 6 | ld {value ; error: no match -------------------------------------------------------------------------------- /tests/fuzz/crash2.asm: -------------------------------------------------------------------------------- 1 | r = asm{ 2 | } 3 | ; = 0x 4 | -------------------------------------------------------------------------------- /tests/fuzz/crash3.asm: -------------------------------------------------------------------------------- 1 | i = 55555555 << 5555555555555 ; error: out of supported range -------------------------------------------------------------------------------- /tests/if/err_erased_constant.asm: -------------------------------------------------------------------------------- 1 | x = y ; error: unknown symbol `y` 2 | 3 | #if false 4 | { 5 | y = 0x12 6 | } 7 | 8 | #d x -------------------------------------------------------------------------------- /tests/if/err_inner_error.asm: -------------------------------------------------------------------------------- 1 | x = 0 2 | 3 | #if true 4 | { 5 | y = 1 / 0 ; error: division by zero 6 | #d y 7 | } 8 | 9 | #d x -------------------------------------------------------------------------------- /tests/if/err_unresolved1.asm: -------------------------------------------------------------------------------- 1 | #d 0xab 2 | 3 | #if x ; error: unresolved condition / error: unknown symbol `x` 4 | { 5 | #d 0xcd 6 | } 7 | 8 | #d 0xef -------------------------------------------------------------------------------- /tests/if/err_unresolved2.asm: -------------------------------------------------------------------------------- 1 | #d 0xab 2 | 3 | x = x 4 | 5 | #if x ; error: unresolved condition / error: unresolved symbol `x` 6 | { 7 | #d 0xcd 8 | } 9 | 10 | #d 0xef -------------------------------------------------------------------------------- /tests/if/err_unresolved3.asm: -------------------------------------------------------------------------------- 1 | #d 0xab 2 | 3 | x = 0 4 | 5 | #if x == y ; error: unresolved condition / error: unknown symbol `y` 6 | { 7 | y = 0 8 | 9 | #d 0xcd 10 | } 11 | 12 | #d 0xef -------------------------------------------------------------------------------- /tests/if/ok_elif_false.asm: -------------------------------------------------------------------------------- 1 | #d 0xab ; = 0xab 2 | 3 | #if false 4 | { 5 | #d 0xcc 6 | } 7 | #elif false 8 | { 9 | #d 0xdd 10 | } 11 | #else 12 | { 13 | #d 0xee ; = 0xee 14 | } 15 | 16 | #d 0xff ; = 0xff -------------------------------------------------------------------------------- /tests/if/ok_elif_inner_constant1.asm: -------------------------------------------------------------------------------- 1 | #d 0xab ; = 0xab 2 | 3 | x = y 4 | 5 | #if false 6 | { 7 | y = 0x11 8 | } 9 | #elif true 10 | { 11 | y = 0x22 12 | } 13 | #else 14 | { 15 | y = 0x33 16 | } 17 | 18 | #d y ; = 0x22 -------------------------------------------------------------------------------- /tests/if/ok_elif_inner_constant2.asm: -------------------------------------------------------------------------------- 1 | #d 0xab ; = 0xab 2 | 3 | x = y 4 | 5 | #if false 6 | { 7 | y = 0x11 8 | } 9 | #elif false 10 | { 11 | y = 0x22 12 | } 13 | #elif true 14 | { 15 | y = 0x33 16 | } 17 | #elif true 18 | { 19 | y = 0x44 20 | } 21 | #else 22 | { 23 | y = 0x55 24 | } 25 | 26 | #d y ; = 0x33 -------------------------------------------------------------------------------- /tests/if/ok_elif_multiple1.asm: -------------------------------------------------------------------------------- 1 | #d 0xab ; = 0xab 2 | 3 | #if false 4 | { 5 | #d 0x00 6 | } 7 | #elif false 8 | { 9 | #d 0x11 10 | } 11 | #elif true 12 | { 13 | #d 0x22 ; = 0x22 14 | } 15 | #elif true 16 | { 17 | #d 0x33 18 | } 19 | #else 20 | { 21 | #d 0x44 22 | } 23 | 24 | #d 0xff ; = 0xff -------------------------------------------------------------------------------- /tests/if/ok_elif_multiple2.asm: -------------------------------------------------------------------------------- 1 | #d 0xab ; = 0xab 2 | 3 | #if false 4 | { 5 | #d 0x00 6 | } 7 | #elif false 8 | { 9 | #d 0x11 10 | } 11 | #elif false 12 | { 13 | #d 0x22 14 | } 15 | #elif true 16 | { 17 | #d 0x33 ; = 0x33 18 | } 19 | #else 20 | { 21 | #d 0x44 22 | } 23 | 24 | #d 0xff ; = 0xff -------------------------------------------------------------------------------- /tests/if/ok_elif_true1.asm: -------------------------------------------------------------------------------- 1 | #d 0xab ; = 0xab 2 | 3 | #if true 4 | { 5 | #d 0xcc ; = 0xcc 6 | } 7 | #elif true 8 | { 9 | #d 0xdd 10 | } 11 | #else 12 | { 13 | #d 0xee 14 | } 15 | 16 | #d 0xff ; = 0xff -------------------------------------------------------------------------------- /tests/if/ok_elif_true2.asm: -------------------------------------------------------------------------------- 1 | #d 0xab ; = 0xab 2 | 3 | #if false 4 | { 5 | #d 0xcc 6 | } 7 | #elif true 8 | { 9 | #d 0xdd ; = 0xdd 10 | } 11 | #else 12 | { 13 | #d 0xee 14 | } 15 | 16 | #d 0xff ; = 0xff -------------------------------------------------------------------------------- /tests/if/ok_else_false.asm: -------------------------------------------------------------------------------- 1 | #d 0xab ; = 0xab 2 | 3 | #if false 4 | { 5 | #d 0xcc 6 | } 7 | #else 8 | { 9 | #d 0xdd ; = 0xdd 10 | } 11 | 12 | #d 0xef ; = 0xef -------------------------------------------------------------------------------- /tests/if/ok_else_true.asm: -------------------------------------------------------------------------------- 1 | #d 0xab ; = 0xab 2 | 3 | #if true 4 | { 5 | #d 0xcc ; = 0xcc 6 | } 7 | #else 8 | { 9 | #d 0xdd 10 | } 11 | 12 | #d 0xef ; = 0xef -------------------------------------------------------------------------------- /tests/if/ok_simple_false.asm: -------------------------------------------------------------------------------- 1 | #d 0xab ; = 0xab 2 | 3 | #if false 4 | { 5 | #d 0xcd 6 | } 7 | 8 | #d 0xef ; = 0xef -------------------------------------------------------------------------------- /tests/if/ok_simple_false_expr.asm: -------------------------------------------------------------------------------- 1 | #d 0xab ; = 0xab 2 | 3 | #if 1 + 2 == 4 4 | { 5 | #d 0xcd 6 | } 7 | 8 | #d 0xef ; = 0xef -------------------------------------------------------------------------------- /tests/if/ok_simple_inner_constant1.asm: -------------------------------------------------------------------------------- 1 | #d 0xab ; = 0xab 2 | 3 | #if true 4 | { 5 | x = 0xcd 6 | } 7 | 8 | #d x ; = 0xcd -------------------------------------------------------------------------------- /tests/if/ok_simple_inner_constant2.asm: -------------------------------------------------------------------------------- 1 | #d 0xab ; = 0xab 2 | 3 | x = y 4 | 5 | #if true 6 | { 7 | y = 0xcd 8 | } 9 | 10 | #if false 11 | { 12 | y = 0xef 13 | } 14 | 15 | #d y ; = 0xcd -------------------------------------------------------------------------------- /tests/if/ok_simple_inner_error.asm: -------------------------------------------------------------------------------- 1 | x = 0 2 | 3 | #if false 4 | { 5 | y = 1 / 0 6 | #d y 7 | } 8 | 9 | #d x -------------------------------------------------------------------------------- /tests/if/ok_simple_nested.asm: -------------------------------------------------------------------------------- 1 | #d 0xab ; = 0xab 2 | 3 | #if true 4 | { 5 | #d 0xcd ; = 0xcd 6 | 7 | #if false 8 | { 9 | #d 0x88 10 | 11 | #if true 12 | { 13 | #d 0x77 14 | } 15 | } 16 | 17 | #if true 18 | { 19 | #d 0x66 ; = 0x66 20 | 21 | #if false 22 | { 23 | #d 0x55 24 | } 25 | 26 | #if true 27 | { 28 | #d 0x44 ; = 0x44 29 | } 30 | } 31 | } 32 | 33 | #d 0xef ; = 0xef -------------------------------------------------------------------------------- /tests/if/ok_simple_true.asm: -------------------------------------------------------------------------------- 1 | #d 0xab ; = 0xab 2 | 3 | #if true 4 | { 5 | #d 0xcd ; = 0xcd 6 | } 7 | 8 | #d 0xef ; = 0xef -------------------------------------------------------------------------------- /tests/if/ok_simple_true_expr.asm: -------------------------------------------------------------------------------- 1 | #d 0xab ; = 0xab 2 | 3 | #if 1 + 2 == 3 4 | { 5 | #d 0xcd ; = 0xcd 6 | } 7 | 8 | #d 0xef ; = 0xef -------------------------------------------------------------------------------- /tests/if/ok_subruledef.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: subtest} => 0x11 @ x 4 | } 5 | 6 | 7 | #if x 8 | { 9 | #subruledef subtest 10 | { 11 | {x: u8} => 0xaa @ x 12 | } 13 | } 14 | #else 15 | { 16 | #subruledef subtest 17 | { 18 | {x: u8} => 0xbb @ x 19 | } 20 | } 21 | 22 | 23 | x = true 24 | ld 0x55 ; = 0x11aa55 -------------------------------------------------------------------------------- /tests/if/ruledef1/conditional.asm: -------------------------------------------------------------------------------- 1 | #if x 2 | { 3 | #ruledef test 4 | { 5 | halt => 0x11 6 | } 7 | } 8 | #else 9 | { 10 | #ruledef test 11 | { 12 | halt => 0x22 13 | } 14 | } -------------------------------------------------------------------------------- /tests/if/ruledef1/err_duplicate.asm: -------------------------------------------------------------------------------- 1 | x = true 2 | 3 | #include "conditional.asm" 4 | #include "conditional.asm" ; error:conditional.asm:3: duplicate / note:conditional.asm:3: declared here 5 | 6 | halt -------------------------------------------------------------------------------- /tests/if/ruledef1/err_unknown.asm: -------------------------------------------------------------------------------- 1 | #include "conditional.asm" ; error:conditional.asm:1: unresolved condition / error:conditional.asm:1: unknown symbol `x` 2 | 3 | halt -------------------------------------------------------------------------------- /tests/if/ruledef1/ok_deferred_false.asm: -------------------------------------------------------------------------------- 1 | #include "conditional.asm" 2 | 3 | halt ; = 0x22 4 | 5 | x = false -------------------------------------------------------------------------------- /tests/if/ruledef1/ok_deferred_true.asm: -------------------------------------------------------------------------------- 1 | #include "conditional.asm" 2 | 3 | halt ; = 0x11 4 | 5 | x = true -------------------------------------------------------------------------------- /tests/if/ruledef1/ok_simple_false.asm: -------------------------------------------------------------------------------- 1 | x = false 2 | 3 | #include "conditional.asm" 4 | 5 | halt ; = 0x22 -------------------------------------------------------------------------------- /tests/if/ruledef1/ok_simple_true.asm: -------------------------------------------------------------------------------- 1 | x = true 2 | 3 | #include "conditional.asm" 4 | 5 | halt ; = 0x11 -------------------------------------------------------------------------------- /tests/if/subruledef1/conditional.asm: -------------------------------------------------------------------------------- 1 | #if x 2 | { 3 | #ruledef test 4 | { 5 | ld {x: subtest} => 0x11 @ x 6 | } 7 | } 8 | #else 9 | { 10 | #ruledef test 11 | { 12 | ld {x: subtest} => 0x22 @ x 13 | } 14 | } 15 | 16 | 17 | #if y 18 | { 19 | #subruledef subtest 20 | { 21 | {x: u8} => 0xaa @ x 22 | } 23 | } 24 | #else 25 | { 26 | #subruledef subtest 27 | { 28 | {x: u8} => 0xbb @ x 29 | } 30 | } -------------------------------------------------------------------------------- /tests/if/subruledef1/ok_false_false.asm: -------------------------------------------------------------------------------- 1 | x = false 2 | y = false 3 | 4 | #include "conditional.asm" 5 | 6 | ld 0x55 ; = 0x22bb55 -------------------------------------------------------------------------------- /tests/if/subruledef1/ok_false_true.asm: -------------------------------------------------------------------------------- 1 | x = false 2 | y = true 3 | 4 | #include "conditional.asm" 5 | 6 | ld 0x55 ; = 0x22aa55 -------------------------------------------------------------------------------- /tests/if/subruledef1/ok_true_false.asm: -------------------------------------------------------------------------------- 1 | x = true 2 | y = false 3 | 4 | #include "conditional.asm" 5 | 6 | ld 0x55 ; = 0x11bb55 -------------------------------------------------------------------------------- /tests/if/subruledef1/ok_true_true.asm: -------------------------------------------------------------------------------- 1 | x = true 2 | y = true 3 | 4 | #include "conditional.asm" 5 | 6 | ld 0x55 ; = 0x11aa55 -------------------------------------------------------------------------------- /tests/incbin/data1.bin: -------------------------------------------------------------------------------- 1 | hello -------------------------------------------------------------------------------- /tests/incbin/err_end_after_eof.asm: -------------------------------------------------------------------------------- 1 | #d incbin("data1.bin",2,4) ; error: failed / error: ends after EOF (2 + 4 > 5) 2 | -------------------------------------------------------------------------------- /tests/incbin/err_expected.asm: -------------------------------------------------------------------------------- 1 | #d incbin("unk" @ 0xffff) ; error: failed / error: expected string -------------------------------------------------------------------------------- /tests/incbin/err_file_not_found.asm: -------------------------------------------------------------------------------- 1 | #d incbin("unk") ; error: failed / error: not found -------------------------------------------------------------------------------- /tests/incbin/err_start_after_eof.asm: -------------------------------------------------------------------------------- 1 | #d incbin("data1.bin",5) ; error: failed / error: starts after EOF (5 >= 5) 2 | -------------------------------------------------------------------------------- /tests/incbin/err_too_few_arguments.asm: -------------------------------------------------------------------------------- 1 | #d incbin() ; error: failed / error: expected 1 to 3 arguments 2 | -------------------------------------------------------------------------------- /tests/incbin/err_too_many_args.asm: -------------------------------------------------------------------------------- 1 | #d incbin("data1.bin", 1, 2, 3) ; error: failed / error: expected 1 to 3 arguments 2 | -------------------------------------------------------------------------------- /tests/incbin/err_wrong_usage.asm: -------------------------------------------------------------------------------- 1 | #d incbin("data1.bin", "data2.bin") ; error: failed / error: expected non-negative integer 2 | -------------------------------------------------------------------------------- /tests/incbin/inner/data1.bin: -------------------------------------------------------------------------------- 1 | goodbye -------------------------------------------------------------------------------- /tests/incbin/inner/rule.asm: -------------------------------------------------------------------------------- 1 | #ruledef uses_incbin 2 | { 3 | hlt => incbin("data1.bin") 4 | ld {x} => x 5 | st {x} => incbin(x) 6 | } -------------------------------------------------------------------------------- /tests/incbin/ok_constant.asm: -------------------------------------------------------------------------------- 1 | x = "data1.bin" 2 | #d incbin(x) ; = 0x68656c6c6f -------------------------------------------------------------------------------- /tests/incbin/ok_constant_forward_ref.asm: -------------------------------------------------------------------------------- 1 | #d x ; = 0x64617461312e62696e 2 | #d incbin(x) ; = 0x68656c6c6f 3 | x = "data1.bin" -------------------------------------------------------------------------------- /tests/incbin/ok_ruledef_context.asm: -------------------------------------------------------------------------------- 1 | #include "inner/rule.asm" 2 | 3 | #d incbin("data1.bin") ; = 0x68656c6c6f 4 | hlt ; = 0x676f6f64627965 5 | ld incbin("data1.bin") ; = 0x68656c6c6f 6 | st "data1.bin" ; = 0x676f6f64627965 -------------------------------------------------------------------------------- /tests/incbin/ok_simple.asm: -------------------------------------------------------------------------------- 1 | #d incbin("data1.bin") ; = 0x68656c6c6f -------------------------------------------------------------------------------- /tests/incbin/ok_start.asm: -------------------------------------------------------------------------------- 1 | #d incbin("data1.bin",1) ; = 0x656c6c6f 2 | -------------------------------------------------------------------------------- /tests/incbin/ok_start_size.asm: -------------------------------------------------------------------------------- 1 | #d incbin("data1.bin",2,2) ; = 0x6c6c 2 | -------------------------------------------------------------------------------- /tests/incbinstr/data1.txt: -------------------------------------------------------------------------------- 1 | 0001_1000 -------------------------------------------------------------------------------- /tests/incbinstr/data2.txt: -------------------------------------------------------------------------------- 1 | 101 -------------------------------------------------------------------------------- /tests/incbinstr/data3.txt: -------------------------------------------------------------------------------- 1 | 0101 2 | 1010 3 | 1 1 1 1 4 | 0101 5 | 1010 -------------------------------------------------------------------------------- /tests/incbinstr/data4.txt: -------------------------------------------------------------------------------- 1 | 0b1101 -------------------------------------------------------------------------------- /tests/incbinstr/err_end_after_eof.asm: -------------------------------------------------------------------------------- 1 | #d incbinstr("data1.txt",4,8) ; error: failed / error: ends after EOF (4 + 8 > 8) 2 | -------------------------------------------------------------------------------- /tests/incbinstr/err_expected.asm: -------------------------------------------------------------------------------- 1 | #d incbinstr("unk" @ 0xffff) ; error: failed / error: expected string -------------------------------------------------------------------------------- /tests/incbinstr/err_file_not_found.asm: -------------------------------------------------------------------------------- 1 | #d incbinstr("unk") ; error: failed / error: file not found -------------------------------------------------------------------------------- /tests/incbinstr/err_invalid_char.asm: -------------------------------------------------------------------------------- 1 | #d incbinstr("data4.txt") ; error: failed / error: invalid character -------------------------------------------------------------------------------- /tests/incbinstr/err_start_after_eof.asm: -------------------------------------------------------------------------------- 1 | #d incbinstr("data1.txt",8) ; error: failed / error: starts after EOF (8 >= 8) 2 | -------------------------------------------------------------------------------- /tests/incbinstr/err_too_few_args.asm: -------------------------------------------------------------------------------- 1 | #d incbinstr() ; error: failed / error: expected 1 to 3 arguments 2 | -------------------------------------------------------------------------------- /tests/incbinstr/err_too_many_args.asm: -------------------------------------------------------------------------------- 1 | #d incbinstr("data1.txt",0,1,2) ; error: failed / error: expected 1 to 3 arguments 2 | -------------------------------------------------------------------------------- /tests/incbinstr/err_wrong_usage.asm: -------------------------------------------------------------------------------- 1 | #d incbinstr("data1.txt", "data2.txt") ; error: failed / error: expected non-negative integer 2 | -------------------------------------------------------------------------------- /tests/incbinstr/ok_constant_forward_ref.asm: -------------------------------------------------------------------------------- 1 | #d x ; = 0x64617461312e747874 2 | #d incbinstr(x) ; = 0x18 3 | x = "data1.txt" -------------------------------------------------------------------------------- /tests/incbinstr/ok_simple_data1.asm: -------------------------------------------------------------------------------- 1 | #d incbinstr("data1.txt") ; = 0x18 -------------------------------------------------------------------------------- /tests/incbinstr/ok_simple_data2.asm: -------------------------------------------------------------------------------- 1 | #d incbinstr("data2.txt") ; = 0b101 -------------------------------------------------------------------------------- /tests/incbinstr/ok_simple_data3.asm: -------------------------------------------------------------------------------- 1 | #d incbinstr("data3.txt") ; = 0x5af5a -------------------------------------------------------------------------------- /tests/incbinstr/ok_start.asm: -------------------------------------------------------------------------------- 1 | #d incbinstr("data3.txt",4) ; =0xaf5a 2 | -------------------------------------------------------------------------------- /tests/incbinstr/ok_start_size.asm: -------------------------------------------------------------------------------- 1 | #d incbinstr("data3.txt",8,8) ; =0xf5 2 | -------------------------------------------------------------------------------- /tests/inchexstr/data1.txt: -------------------------------------------------------------------------------- 1 | 0180 -------------------------------------------------------------------------------- /tests/inchexstr/data2.txt: -------------------------------------------------------------------------------- 1 | 5 -------------------------------------------------------------------------------- /tests/inchexstr/data3.txt: -------------------------------------------------------------------------------- 1 | 00_00 2 | 5a 5a 3 | f 4 | 5a 5a 5 | 00_00 -------------------------------------------------------------------------------- /tests/inchexstr/data4.txt: -------------------------------------------------------------------------------- 1 | 0x5a5a -------------------------------------------------------------------------------- /tests/inchexstr/err_end_after_eof.asm: -------------------------------------------------------------------------------- 1 | #d inchexstr("data1.txt",2,4) ; error: failed / error: ends after EOF (2 + 4 > 4) 2 | -------------------------------------------------------------------------------- /tests/inchexstr/err_expected.asm: -------------------------------------------------------------------------------- 1 | #d inchexstr("unk" @ 0xffff) ; error: failed / error: expected string -------------------------------------------------------------------------------- /tests/inchexstr/err_file_not_found.asm: -------------------------------------------------------------------------------- 1 | #d inchexstr("unk") ; error: failed / error: not found -------------------------------------------------------------------------------- /tests/inchexstr/err_invalid_char.asm: -------------------------------------------------------------------------------- 1 | #d inchexstr("data4.txt") ; error: failed / error: invalid character -------------------------------------------------------------------------------- /tests/inchexstr/err_start_after_eof.asm: -------------------------------------------------------------------------------- 1 | #d inchexstr("data1.txt",4) ; error: failed / error: starts after EOF (4 >= 4) 2 | -------------------------------------------------------------------------------- /tests/inchexstr/err_too_few_args.asm: -------------------------------------------------------------------------------- 1 | #d inchexstr() ; error: failed / error: expected 1 to 3 arguments 2 | -------------------------------------------------------------------------------- /tests/inchexstr/err_too_many_args.asm: -------------------------------------------------------------------------------- 1 | #d inchexstr("data1.txt",0,1,2) ; error: failed / error: expected 1 to 3 arguments 2 | -------------------------------------------------------------------------------- /tests/inchexstr/err_wrong_usage.asm: -------------------------------------------------------------------------------- 1 | #d inchexstr("data1.txt", "data2.txt") ; error: failed / error: expected non-negative integer 2 | -------------------------------------------------------------------------------- /tests/inchexstr/ok_constant_forward_ref.asm: -------------------------------------------------------------------------------- 1 | #d x ; = 0x64617461312e747874 2 | #d inchexstr(x) ; = 0x0180 3 | x = "data1.txt" -------------------------------------------------------------------------------- /tests/inchexstr/ok_simple_data1.asm: -------------------------------------------------------------------------------- 1 | #d inchexstr("data1.txt") ; = 0x0180 -------------------------------------------------------------------------------- /tests/inchexstr/ok_simple_data2.asm: -------------------------------------------------------------------------------- 1 | #d inchexstr("data2.txt") ; = 0x5 -------------------------------------------------------------------------------- /tests/inchexstr/ok_simple_data3.asm: -------------------------------------------------------------------------------- 1 | #d inchexstr("data3.txt") ; = 0x00005a5af5a5a0000 -------------------------------------------------------------------------------- /tests/inchexstr/ok_start.asm: -------------------------------------------------------------------------------- 1 | #d inchexstr("data3.txt",4) ; =0x5a5af5a5a0000 2 | -------------------------------------------------------------------------------- /tests/inchexstr/ok_start_size.asm: -------------------------------------------------------------------------------- 1 | #d inchexstr("data3.txt",8,2) ; =0xf5 2 | -------------------------------------------------------------------------------- /tests/include_directory/code/code1.asm: -------------------------------------------------------------------------------- 1 | halt -------------------------------------------------------------------------------- /tests/include_directory/code/code2.asm: -------------------------------------------------------------------------------- 1 | #include "code1.asm" -------------------------------------------------------------------------------- /tests/include_directory/code/code4.asm: -------------------------------------------------------------------------------- 1 | #include "../code3.asm" -------------------------------------------------------------------------------- /tests/include_directory/code/code5.asm: -------------------------------------------------------------------------------- 1 | #include "/code3.asm" -------------------------------------------------------------------------------- /tests/include_directory/code3.asm: -------------------------------------------------------------------------------- 1 | #include "code/code1.asm" -------------------------------------------------------------------------------- /tests/include_directory/cpu/cpu.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } -------------------------------------------------------------------------------- /tests/include_directory/err_out_of_root.asm: -------------------------------------------------------------------------------- 1 | #include "../cpu.asm" ; error: out of project directory -------------------------------------------------------------------------------- /tests/include_directory/ok_nested.asm: -------------------------------------------------------------------------------- 1 | #include "cpu/cpu.asm" 2 | #include "code/code2.asm" 3 | ; = 0x55 -------------------------------------------------------------------------------- /tests/include_directory/ok_path_normalization.asm: -------------------------------------------------------------------------------- 1 | #include "./cpu/./cpu.asm" 2 | #include "././code///code1.asm" 3 | #include "/code/code1.asm/" 4 | #include "code/../unk/../code/unk/unk/../../code1.asm" 5 | #include ".\\code\\\\code1.asm" 6 | ; = 0x55555555 -------------------------------------------------------------------------------- /tests/include_directory/ok_simple_code1.asm: -------------------------------------------------------------------------------- 1 | #include "cpu/cpu.asm" 2 | #include "code/code1.asm" 3 | ; = 0x55 -------------------------------------------------------------------------------- /tests/include_directory/ok_simple_code3.asm: -------------------------------------------------------------------------------- 1 | #include "cpu/cpu.asm" 2 | #include "code3.asm" 3 | ; = 0x55 -------------------------------------------------------------------------------- /tests/include_directory/ok_simple_code4.asm: -------------------------------------------------------------------------------- 1 | #include "cpu/cpu.asm" 2 | #include "code/code4.asm" 3 | ; = 0x55 -------------------------------------------------------------------------------- /tests/include_directory/ok_simple_code5.asm: -------------------------------------------------------------------------------- 1 | #include "cpu/cpu.asm" 2 | #include "code/code5.asm" 3 | ; = 0x55 -------------------------------------------------------------------------------- /tests/include_recursive/err_recursive1.asm: -------------------------------------------------------------------------------- 1 | #include "recursive1.asm" 2 | ; error: recursive1.asm:1: recursive -------------------------------------------------------------------------------- /tests/include_recursive/err_recursive2.asm: -------------------------------------------------------------------------------- 1 | #include "recursive2.asm" 2 | ; error: recursive3.asm:1: recursive -------------------------------------------------------------------------------- /tests/include_recursive/err_recursive3.asm: -------------------------------------------------------------------------------- 1 | #include "recursive4.asm" 2 | ; error: recursive3.asm:1: recursive -------------------------------------------------------------------------------- /tests/include_recursive/recursive1.asm: -------------------------------------------------------------------------------- 1 | #include "recursive1.asm" -------------------------------------------------------------------------------- /tests/include_recursive/recursive2.asm: -------------------------------------------------------------------------------- 1 | #include "recursive3.asm" -------------------------------------------------------------------------------- /tests/include_recursive/recursive3.asm: -------------------------------------------------------------------------------- 1 | #include "recursive2.asm" -------------------------------------------------------------------------------- /tests/include_recursive/recursive4.asm: -------------------------------------------------------------------------------- 1 | #include "recursive2.asm" -------------------------------------------------------------------------------- /tests/include_simple/code1.asm: -------------------------------------------------------------------------------- 1 | halt 2 | halt 3 | halt 4 | #d8 0xaa, 0x55, 0xaa -------------------------------------------------------------------------------- /tests/include_simple/code2.asm: -------------------------------------------------------------------------------- 1 | #include "code1.asm" -------------------------------------------------------------------------------- /tests/include_simple/cpu.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } -------------------------------------------------------------------------------- /tests/include_simple/err_file_not_found.asm: -------------------------------------------------------------------------------- 1 | #include "unk.asm" ; error: not found -------------------------------------------------------------------------------- /tests/include_simple/err_file_not_found_root.asm: -------------------------------------------------------------------------------- 1 | #include "/unk.asm" ; error: not found -------------------------------------------------------------------------------- /tests/include_simple/err_no_ruledef.asm: -------------------------------------------------------------------------------- 1 | #include "code1.asm" 2 | ; error: code1.asm:1: no match 3 | ; error: code1.asm:2: no match 4 | ; error: code1.asm:3: no match -------------------------------------------------------------------------------- /tests/include_simple/err_no_ruledef_mixed.asm: -------------------------------------------------------------------------------- 1 | halt ; error: no match 2 | #include "code1.asm" 3 | halt ; error: no match 4 | ; error: code1.asm:1: no match 5 | ; error: code1.asm:2: no match 6 | ; error: code1.asm:3: no match -------------------------------------------------------------------------------- /tests/include_simple/err_no_ruledef_multiple.asm: -------------------------------------------------------------------------------- 1 | #include "code1.asm" 2 | #include "code2.asm" 3 | ; error: code1.asm:1: no match 4 | ; error: code1.asm:2: no match 5 | ; error: code1.asm:3: no match 6 | ; error: code1.asm:1: no match 7 | ; error: code1.asm:2: no match 8 | ; error: code1.asm:3: no match -------------------------------------------------------------------------------- /tests/include_simple/ok_multiple.asm: -------------------------------------------------------------------------------- 1 | #include "cpu.asm" 2 | #include "code1.asm" 3 | ; = 0x555555aa55aa -------------------------------------------------------------------------------- /tests/include_simple/ok_multiple_deep.asm: -------------------------------------------------------------------------------- 1 | #include "cpu.asm" 2 | #include "code2.asm" 3 | ; = 0x555555aa55aa -------------------------------------------------------------------------------- /tests/include_simple/ok_simple.asm: -------------------------------------------------------------------------------- 1 | #include "cpu.asm" 2 | halt ; = 0x55 -------------------------------------------------------------------------------- /tests/include_std/err_file_not_found.asm: -------------------------------------------------------------------------------- 1 | #include "/cpu/unknown.asm" ; error: not found 2 | hlt 3 | hlt 4 | hlt -------------------------------------------------------------------------------- /tests/include_std/err_wrong_prefix.asm: -------------------------------------------------------------------------------- 1 | #include "std/cpu/6502.asm" ; error: not found 2 | sei 3 | clc 4 | lda #0x55 5 | rts -------------------------------------------------------------------------------- /tests/include_std/ok_cpu_6502.asm: -------------------------------------------------------------------------------- 1 | #include "/cpu/6502.asm" 2 | sei ; = 0x78 3 | clc ; = 0x18 4 | lda #0x55 ; = 0xa955 5 | rts ; = 0x60 -------------------------------------------------------------------------------- /tests/include_std/ok_nes_cpu.asm: -------------------------------------------------------------------------------- 1 | #include "/platform/nes/cpu.asm" 2 | sei ; = 0x78 3 | clc ; = 0x18 4 | lda #0x55 ; = 0xa955 5 | rts ; = 0x60 -------------------------------------------------------------------------------- /tests/issue111/ok.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | sub.neg {a: u8} {b: u8} {r: u8} {j: u8} => a @ b @ r @ j 4 | 5 | jmp {j: u8} => asm { sub.neg Z Z+1 T {j} } 6 | } 7 | 8 | jmp main ; = 0x08090410_00000000_00000000_00000001 9 | 10 | T: 11 | #d32 0 12 | 13 | Z: 14 | #d32 0 15 | #d32 1 16 | 17 | main: -------------------------------------------------------------------------------- /tests/issue113/1.asm: -------------------------------------------------------------------------------- 1 | #d3 "test" ; error: out of range / note: got size 32 2 | #d8 "ü" -------------------------------------------------------------------------------- /tests/issue115/ok1.asm: -------------------------------------------------------------------------------- 1 | #bankdef a 2 | { 3 | bits = 4 4 | outp = 0 5 | } 6 | 7 | #ruledef 8 | { 9 | jmp {addr: u4} => addr 10 | 11 | asmjmp {addr: u4} => asm { 12 | jmp {addr} 13 | } 14 | 15 | op => asm { 16 | jmp $ 17 | asmjmp $ 18 | jmp $ 19 | } 20 | } 21 | 22 | op ; = 0x012 23 | op ; = 0x345 -------------------------------------------------------------------------------- /tests/issue115/ok2.asm: -------------------------------------------------------------------------------- 1 | #bankdef a 2 | { 3 | bits = 4 4 | outp = 0 5 | } 6 | 7 | #ruledef 8 | { 9 | jmp {addr: u4} => addr 10 | 11 | asmjmp {addr: u4} => asm { 12 | jmp {addr} 13 | jmp $ 14 | } 15 | 16 | op => asm { 17 | jmp $ 18 | asmjmp $ 19 | jmp $ 20 | } 21 | } 22 | 23 | op ; = 0x0123 24 | #d asm { 25 | op ; = 0x4567 26 | op ; = 0x89ab 27 | } 28 | op ; = 0xcdef -------------------------------------------------------------------------------- /tests/issue125/ok.asm: -------------------------------------------------------------------------------- 1 | #subruledef register 2 | { 3 | j => 0x0a 4 | ij => 0x0b 5 | } 6 | 7 | #ruledef 8 | { 9 | ld {r: register}, {addr: u8} => 0x01 @ r @ addr 10 | ldi {r: register}, {value: u8} => 0x02 @ r @ value 11 | } 12 | 13 | ld j, 0x55 ; = 0x010a55 14 | ldi j, 0x55 ; = 0x020a55 15 | ld ij, 0x55 ; = 0x010b55 16 | ldi ij, 0x55 ; = 0x020b55 -------------------------------------------------------------------------------- /tests/issue157/err_infinite_recursion.asm: -------------------------------------------------------------------------------- 1 | #ruledef { 2 | a {a} => { 3 | assert(a == 0) 4 | 0`1 5 | } 6 | a {a} => { 7 | 1`1 @ asm { 8 | a ({a}-1) 9 | } 10 | } 11 | } 12 | a 3 ; error: failed / note:_:6: within / note:_:8: a (3-1) / error:_:8: failed / note:_:8: a ((((((((((((3-1)-1)-1)-1)-1)-1)-1)-1)-1)-1)-1)-1) / error:_:7: recursion -------------------------------------------------------------------------------- /tests/issue168/ok.asm: -------------------------------------------------------------------------------- 1 | HEADER_SIZE = 0x34 2 | #bankdef header {#addr 0, #size HEADER_SIZE, #outp 0} 3 | ; = 0x -------------------------------------------------------------------------------- /tests/issue169/err1.asm: -------------------------------------------------------------------------------- 1 | #subruledef subtest 2 | { 3 | {x: s32} => 4 | { 5 | assert(x > 0) 6 | assert(x < 10) 7 | x 8 | } 9 | } 10 | #ruledef test 11 | { 12 | test {s: s32} => s 13 | testasm {a: subtest} => asm{test {a}} 14 | } 15 | 16 | testasm 121 ; error: failed / note:_:13: within / note:_:3: within / error:_:6: assertion -------------------------------------------------------------------------------- /tests/issue169/err2.asm: -------------------------------------------------------------------------------- 1 | #subruledef cpu6502_reladdr 2 | { 3 | {addr: u16} => 4 | { 5 | reladdr = addr - $ - 2 6 | assert(reladdr <= 0x7f) 7 | assert(reladdr >= !0x7f) 8 | reladdr`8 9 | } 10 | } 11 | 12 | #ruledef cpu6502 13 | { 14 | bcc {addr: cpu6502_reladdr} => 0x90 @ addr 15 | } 16 | 17 | #ruledef cpu6502_macro 18 | { 19 | bccmacro {addr: cpu6502_reladdr} => asm{bcc {addr}} 20 | } 21 | 22 | bcc 120 23 | bccmacro 16384 ; error: failed / note:_:19: within / note:_:3: within / error:_:6: assertion 24 | bcc 120 -------------------------------------------------------------------------------- /tests/issue170/err.asm: -------------------------------------------------------------------------------- 1 | #subruledef reg 2 | { 3 | x{val: u4} => val`4 4 | } 5 | 6 | #ruledef test 7 | { 8 | test {imm: u8} => imm 9 | testasm {R1: reg}, {R2: reg} => asm{test ({R1} @ {R2})} 10 | } 11 | 12 | testasm x0, x1 ; error: failed / note:_:9: within / note:_:9: test (x0 @ x1) / error:_:9: failed / note:_:8: within / error:_:9: unknown symbol `x0` -------------------------------------------------------------------------------- /tests/issue170/ok.asm: -------------------------------------------------------------------------------- 1 | #subruledef reg 2 | { 3 | x{val: u4} => val`4 4 | } 5 | 6 | #ruledef test 7 | { 8 | test {imm: u8} => imm 9 | testasm {R1: reg}, {R2: reg} => { 10 | temp = (R1 @ R2) 11 | asm{test {temp}} 12 | } 13 | } 14 | 15 | testasm x0, x1 ; = 0x01 -------------------------------------------------------------------------------- /tests/issue171/ok.asm: -------------------------------------------------------------------------------- 1 | X=1 2 | #if X==1 3 | { 4 | #subruledef test 5 | { 6 | {a: i32} => a 7 | } 8 | } 9 | #else 10 | { 11 | #subruledef test 12 | { 13 | {a: i16} => a 14 | } 15 | } 16 | 17 | #ruledef 18 | { 19 | test {X: test} => X 20 | } 21 | 22 | test 0x12345678 ; = 0x12345678 -------------------------------------------------------------------------------- /tests/issue173/ok.asm: -------------------------------------------------------------------------------- 1 | #subruledef reg 2 | { 3 | r0 => 0x0 4 | } 5 | 6 | #ruledef 7 | { 8 | movh {rd: reg}, {imm: i16} => 9 | 0xff @ rd @ 0x0 @ imm 10 | 11 | mov1 %{rd: reg}, {imm: i16} => asm { 12 | movh {rd}, {imm} 13 | } 14 | 15 | mov2 % {rd: reg}, {imm: i16} => asm { 16 | movh {rd}, {imm} 17 | } 18 | 19 | mov3 %{rd: reg}, ${imm: i16} => asm { 20 | movh {rd}, {imm} 21 | } 22 | 23 | mov4 % {rd: reg}, ${imm: i16} => asm { 24 | movh {rd}, {imm} 25 | } 26 | } 27 | 28 | mov1 %r0, 0x1234 ; = 0xff001234 29 | mov2 % r0, 0x1234 ; = 0xff001234 30 | mov3 %r0, $0x1234 ; = 0xff001234 31 | mov4 % r0, $0x1234 ; = 0xff001234 -------------------------------------------------------------------------------- /tests/issue174/ok.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | test8_be a, {val: i8} => val 4 | test32_be a, {val: i32} => val 5 | test8_le a, {val: i8} => le(val) 6 | test32_le a, {val: i32} => le(val) 7 | } 8 | 9 | test8_be a, 0x0f ; = 0x0f 10 | test8_be a, -0x0f ; = 0xf1 11 | 12 | test32_be a, 0x0f ; = 0x00_00_00_0f 13 | test32_be a, -0x0f ; = 0xff_ff_ff_f1 14 | 15 | test8_le a, 0x0f ; = 0x0f 16 | test8_le a, -0x0f ; = 0xf1 17 | 18 | test32_le a, 0x0f ; = 0x0f_00_00_00 19 | test32_le a, -0x0f ; = 0xf1_ff_ff_ff -------------------------------------------------------------------------------- /tests/issue177/inc1.asm: -------------------------------------------------------------------------------- 1 | #once 2 | #d 0x0001 -------------------------------------------------------------------------------- /tests/issue177/inc2.asm: -------------------------------------------------------------------------------- 1 | #once 2 | #d 0x0002 3 | #include "inc1.asm" -------------------------------------------------------------------------------- /tests/issue177/main.asm: -------------------------------------------------------------------------------- 1 | #d 0x0000 2 | #include "inc1.asm" 3 | #include "inc2.asm" 4 | #d 0x0003 5 | 6 | ; = 0x0000 7 | ; = 0x0001 8 | ; = 0x0002 9 | ; = 0x0003 -------------------------------------------------------------------------------- /tests/issue181/ok.asm: -------------------------------------------------------------------------------- 1 | #subruledef SELECT 2 | { 3 | C => 0xc 4 | } 5 | 6 | #ruledef 7 | { 8 | A{sel:SELECT} => 0x1 @ sel 9 | AB{sel:SELECT} => 0x2 @ sel 10 | ABB{sel:SELECT} => 0x3 @ sel 11 | ABBB{sel:SELECT} => 0x4 @ sel 12 | } 13 | 14 | AC ; = 0x1c 15 | ABC ; = 0x2c 16 | ABBC ; = 0x3c 17 | ABBBC ; = 0x4c -------------------------------------------------------------------------------- /tests/issue193/ok.asm: -------------------------------------------------------------------------------- 1 | #ruledef mode 2 | { 3 | eq => 0xff 4 | } 5 | 6 | #ruledef 7 | { 8 | b{m: mode} => m 9 | j{m: mode} => asm { b{m} } 10 | } 11 | 12 | jeq ; = 0xff -------------------------------------------------------------------------------- /tests/issue203/ok.asm: -------------------------------------------------------------------------------- 1 | #subruledef foo 2 | { 3 | add => 0xaa 4 | sub => 0xbb 5 | } 6 | 7 | #ruledef Bar 8 | { 9 | {f: foo}d => f 10 | } 11 | 12 | addd ; = 0xaa 13 | add d ; = 0xaa 14 | subd ; = 0xbb 15 | sub d ; = 0xbb -------------------------------------------------------------------------------- /tests/issue204/ok.asm: -------------------------------------------------------------------------------- 1 | #ruledef foo 2 | { 3 | f{e:u4} => e 4 | f{e:u4}+{m:foo} => e @ m 5 | } 6 | 7 | #ruledef bar 8 | { 9 | |{f:foo}| => 0xa @ f 10 | ){f:foo}( => 0xb @ f 11 | ]{f:foo}[ => 0xc @ f 12 | ({f:foo}) => 0xd @ f 13 | [{f:foo}] => 0xe @ f 14 | } 15 | 16 | f1+f2+f3+f4 ; = 0x1234 17 | |f1+f2+f3+f4| ; = 0xa1234 18 | )f1+f2+f3+f4( ; = 0xb1234 19 | ]f1+f2+f3+f4[ ; = 0xc1234 20 | (f1+f2+f3+f4) ; = 0xd1234 21 | [f1+f2+f3+f4] ; = 0xe1234 -------------------------------------------------------------------------------- /tests/issue205/err.asm: -------------------------------------------------------------------------------- 1 | #subruledef foo 2 | { 3 | f{i:u4} => i 4 | } 5 | 6 | 7 | #ruledef bar 8 | { 9 | [{f:foo}] => 0xa @ f 10 | [{i:u4}] => 0xb @ i 11 | } 12 | 13 | 14 | foo: 15 | bar: 16 | [f10] 17 | [bar] 18 | [foo] ; error: failed / note:_:9: within / note:_:3: within / error: unknown symbol `oo` -------------------------------------------------------------------------------- /tests/issue210/main.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | nop => 0x00 4 | ldi sp, {value: i8} => 0x08 @ value 5 | } 6 | 7 | nop 8 | ldi sp, 0xff 9 | nop 10 | 11 | ; command: main.asm -f intelhex -o out.txt 12 | ; output: out.txt -------------------------------------------------------------------------------- /tests/issue210/out.txt: -------------------------------------------------------------------------------- 1 | :040000000008FF00F5 2 | :00000001FF -------------------------------------------------------------------------------- /tests/issue213/ok.asm: -------------------------------------------------------------------------------- 1 | #bankdef bank { 2 | #addr 1 3 | #outp 0 4 | } 5 | 6 | #d8 0 ; = 0x00 7 | 8 | #align 32 ; = 0x00_00 9 | #d8 1 ; = 0x01 -------------------------------------------------------------------------------- /tests/issue216/ok.asm: -------------------------------------------------------------------------------- 1 | #subruledef acc { 2 | a => 0xaa 3 | b => 0xbb 4 | } 5 | 6 | #subruledef paropts { 7 | {} => 0x00 8 | FOO => 0x01 9 | } 10 | 11 | #ruledef { 12 | abs {reg: acc} {p: paropts} => 0xee @ reg @ p 13 | } 14 | 15 | abs a FOO ; = 0xeeaa01 16 | abs a ; = 0xeeaa00 -------------------------------------------------------------------------------- /tests/issue47/1.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | ld {addr} => 0x00 @ addr`8 4 | ld x => 0xff 5 | } 6 | 7 | ld 0x11 ; = 0x0011 8 | ld x ; = 0xff -------------------------------------------------------------------------------- /tests/issue47/2.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | ld x => 0xff 4 | ld {addr} => 0x00 @ addr`8 5 | } 6 | 7 | ld 0x11 ; = 0x0011 8 | ld x ; = 0xff -------------------------------------------------------------------------------- /tests/issue47/3.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | ld {addr} => 0x00 @ addr`8 4 | ld x => 0xff @ 0x22 5 | } 6 | 7 | ld 0x11 ; = 0x0011 8 | ld x ; = 0xff22 -------------------------------------------------------------------------------- /tests/issue47/4.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | ld ({addr}) => 0x00 @ addr`8 4 | ld ({addr}, x) => 0xff @ addr`8 5 | } 6 | 7 | ld (0x11) ; = 0x0011 8 | ld (0x22, x) ; = 0xff22 -------------------------------------------------------------------------------- /tests/issue47/5.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | ld ({addr}) => 0x00 @ addr`8 4 | ld ({addr}, x) => 0xff @ addr`8 5 | } 6 | 7 | ld (0x11) 8 | ld (0x22), x) ; error: no match -------------------------------------------------------------------------------- /tests/issue64/1.asm: -------------------------------------------------------------------------------- 1 | #subruledef REG { 2 | my_reg => 0xA 3 | } 4 | #ruledef { 5 | test {Addr: u16} => 0x1 @ Addr 6 | test {register: REG} + {Imm: u16} => register`4 @ Imm 7 | } 8 | 9 | test 1 ; = 0x10001 10 | test 1 + 1 ; = 0x10002 11 | test my_reg + 1 ; = 0xa0001 -------------------------------------------------------------------------------- /tests/issue64/2.asm: -------------------------------------------------------------------------------- 1 | #subruledef REG { 2 | my_reg => 0xA 3 | } 4 | #ruledef { 5 | test {Addr: u16} => 0x1 @ Addr 6 | test {register: REG} + {Imm: u16} => register`4 @ Imm_Unknown 7 | } 8 | 9 | test my_reg + 1 ; error: failed / note:_:6: within / error:_:6: unknown -------------------------------------------------------------------------------- /tests/issue65/ok.asm: -------------------------------------------------------------------------------- 1 | #bankdef a 2 | { 3 | bits = 16 4 | outp = 0 5 | } 6 | 7 | #d16 5 8 | #d16 7 9 | #addr 6 10 | #d16 4 11 | ; = 0x0005_0007_0000_0000_0000_0000_0004 -------------------------------------------------------------------------------- /tests/issue67/1.asm: -------------------------------------------------------------------------------- 1 | #subruledef Reg 2 | { 3 | x => 0x00 4 | y => 0xff 5 | } 6 | 7 | #ruledef 8 | { 9 | add {r: Reg} => 10 | { 11 | assert((r & 0xff) != 0xff) 12 | r 13 | } 14 | } 15 | 16 | add x 17 | add y ; error: failed / note:_:9: within / error:_:11: assertion -------------------------------------------------------------------------------- /tests/issue67/2.asm: -------------------------------------------------------------------------------- 1 | #subruledef Reg 2 | { 3 | x => 0x00 4 | y => 0xff 5 | } 6 | 7 | #ruledef 8 | { 9 | add {r: Reg} => 10 | { 11 | assert(r != 0xff) 12 | r 13 | } 14 | } 15 | 16 | add x 17 | add y ; error: failed / note:_:9: within / error:_:11: assertion -------------------------------------------------------------------------------- /tests/issue69/1.asm: -------------------------------------------------------------------------------- 1 | #subruledef opcode 2 | { 3 | A => 0x1 4 | B => 0x2 5 | C => 0x3 6 | } 7 | 8 | #subruledef condition 9 | { 10 | X => 0xa 11 | Y => 0xb 12 | Z => 0xc 13 | {} => 0xa ; empty pattern, default to X 14 | } 15 | 16 | #subruledef instruction 17 | { 18 | {opc: opcode}{cnd: condition} => opc @ cnd 19 | } 20 | 21 | #ruledef 22 | { 23 | {ins: instruction} {val: u8} => ins @ val 24 | } 25 | 26 | A 0x33 ; = 0x1a33 27 | B 0x33 ; = 0x2a33 28 | C 0x33 ; = 0x3a33 29 | AX 0x33 ; = 0x1a33 30 | AY 0x33 ; = 0x1b33 31 | AZ 0x33 ; = 0x1c33 32 | BX 0x33 ; = 0x2a33 33 | BY 0x33 ; = 0x2b33 34 | BZ 0x33 ; = 0x2c33 35 | CX 0x33 ; = 0x3a33 36 | CY 0x33 ; = 0x3b33 37 | CZ 0x33 ; = 0x3c33 -------------------------------------------------------------------------------- /tests/issue69/2.asm: -------------------------------------------------------------------------------- 1 | #subruledef opcode 2 | { 3 | A => 0x1 4 | B => 0x2 5 | C => 0x3 6 | } 7 | 8 | #subruledef condition 9 | { 10 | X => 0xa 11 | Y => 0xb 12 | Z => 0xc 13 | } 14 | 15 | #subruledef instruction 16 | { 17 | {opc: opcode} => opc @ 0xa 18 | {opc: opcode}{cnd: condition} => opc @ cnd 19 | } 20 | 21 | #ruledef 22 | { 23 | {ins: instruction} {val: u8} => ins @ val 24 | } 25 | 26 | A 0x33 ; = 0x1a33 27 | B 0x33 ; = 0x2a33 28 | C 0x33 ; = 0x3a33 29 | AX 0x33 ; = 0x1a33 30 | AY 0x33 ; = 0x1b33 31 | AZ 0x33 ; = 0x1c33 32 | BX 0x33 ; = 0x2a33 33 | BY 0x33 ; = 0x2b33 34 | BZ 0x33 ; = 0x2c33 35 | CX 0x33 ; = 0x3a33 36 | CY 0x33 ; = 0x3b33 37 | CZ 0x33 ; = 0x3c33 -------------------------------------------------------------------------------- /tests/issue69/5.asm: -------------------------------------------------------------------------------- 1 | #subruledef big_endian 2 | { 3 | PUSH {rlist: u8} => 0b1101010 @ 0b0 @ rlist 4 | PUSH {rlist: u8}, LR => 0b1101010 @ 0b1 @ rlist 5 | } 6 | 7 | #ruledef little_endian 8 | { 9 | {val: big_endian} => val[7:0] @ val[15:8] 10 | } 11 | 12 | PUSH 0b00001111 ; = 0x0fd4 13 | PUSH 0b00001111, LR ; = 0x0fd5 -------------------------------------------------------------------------------- /tests/issue72/1.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | ld {value} => 0x00 @ value`8 4 | ld ({addr}) => 0xff @ addr`16 5 | } 6 | 7 | ld 0x00 ; = 0x0000 8 | ld (0x1234) ; = 0xff1234 9 | ld ((0x1234)) ; = 0xff1234 10 | ld 0x11 + 0x11 ; = 0x0022 11 | ld (0x11) + 0x11 ; = 0x0022 12 | ld ((0x11) + 0x11) ; = 0xff0022 -------------------------------------------------------------------------------- /tests/issue77/1.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | test {value:i32} => value[31:16] @ 0x00 @ value 4 | } 5 | 6 | test 0 ; = 0x0000_00_00000000 -------------------------------------------------------------------------------- /tests/issue77/10.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | test {value:i32} => value[31:16] @ 0x00 @ value 4 | } 5 | 6 | test -349678887 ; = 0xeb28_00_eb2852d9 -------------------------------------------------------------------------------- /tests/issue77/2.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | test {value:i32} => value[31:16] @ 0x00 @ value 4 | } 5 | 6 | test -0x7fff_ffff ; = 0x8000_00_80000001 -------------------------------------------------------------------------------- /tests/issue77/3.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | test {value:i32} => value[31:16] @ 0x00 @ value 4 | } 5 | 6 | test -0x0eee_eeee ; = 0xf111_00_f1111112 -------------------------------------------------------------------------------- /tests/issue77/4.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | test {value:i32} => value[31:16] @ 0x00 @ value 4 | } 5 | 6 | test -0x0000_0001 ; = 0xffff_00_ffffffff -------------------------------------------------------------------------------- /tests/issue77/5.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | test {value:i32} => value[31:16] @ 0x00 @ value 4 | } 5 | 6 | test -0x0000_0002 ; = 0xffff_00_fffffffe -------------------------------------------------------------------------------- /tests/issue77/6.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | test {value:i32} => value[31:16] @ 0x00 @ value 4 | } 5 | 6 | test -0x0001_0000 ; = 0xffff_00_ffff0000 -------------------------------------------------------------------------------- /tests/issue77/7.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | test {value:i32} => value[31:16] @ 0x00 @ value 4 | } 5 | 6 | test -0x0000_1000 ; = 0xffff_00_fffff000 -------------------------------------------------------------------------------- /tests/issue77/8.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | test {value:i32} => value[31:16] @ 0x00 @ value 4 | } 5 | 6 | test -0x1000_0000 ; = 0xf000_00_f0000000 -------------------------------------------------------------------------------- /tests/issue77/9.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | test {value:i32} => value[31:16] @ 0x00 @ value 4 | } 5 | 6 | test -0x1000_1000 ; = 0xefff_00_effff000 -------------------------------------------------------------------------------- /tests/issue88/1.asm: -------------------------------------------------------------------------------- 1 | #subruledef reg { 2 | ax => 0x0 3 | bx => 0x1 4 | cx => 0x2 5 | } 6 | 7 | #subruledef memaccess { 8 | {o: s8}(%{r: reg}) => 0x00 @ r @ o 9 | } 10 | 11 | #subruledef arg { 12 | {m: memaccess} => 0x00 @ m 13 | %{r: reg} => 0x01 @ r 14 | } 15 | 16 | #ruledef { 17 | mov {a: arg}, {a2: arg} => 0x10 @ a @ a2 18 | } 19 | 20 | mov (%ax), %bx ; error: no match -------------------------------------------------------------------------------- /tests/issue88/2.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | mov {x: s8} ax => 0x10 @ x 4 | } 5 | 6 | mov ax ; error: no match -------------------------------------------------------------------------------- /tests/issue91/1.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | halt => 0x01 4 | [ld] => 0x02 5 | } 6 | 7 | halt ; = 0x01 8 | [ld] ; = 0x02 -------------------------------------------------------------------------------- /tests/issue97/ok.asm: -------------------------------------------------------------------------------- 1 | #subruledef sub 2 | { 3 | {a: u8} => a 4 | } 5 | 6 | #ruledef 7 | { 8 | test {a: sub} ({b: u8}) => 0x11 @ a @ b 9 | test {a: sub} {b: u8}) => 0x22 @ a @ b 10 | 11 | test2 {a: u8}({b: u8}) => 0x33 @ a @ b 12 | } 13 | 14 | test 0 (0) ; = 0x110000 15 | test 0 0) ; = 0x220000 16 | 17 | test (0) (0) ; = 0x110000 18 | test (ascii("\0")) (0) ; = 0x110000 19 | 20 | x = 0xee 21 | test x (0) ; = 0x11ee00 22 | test (x) (0) ; = 0x11ee00 23 | 24 | 25 | test2 1(2) ; = 0x330102 26 | test2 (1)(2) ; = 0x330102 27 | test2 (ascii("a"))(2) ; = 0x336102 28 | test2 x(2) ; = 0x33ee02 29 | test2 (x)(2) ; = 0x33ee02 -------------------------------------------------------------------------------- /tests/number_styles/err_invalid_digits_bin.asm: -------------------------------------------------------------------------------- 1 | #d %r01 ; error: expected expression -------------------------------------------------------------------------------- /tests/number_styles/err_invalid_digits_hex1.asm: -------------------------------------------------------------------------------- 1 | #d $0x123abc ; error: expected line break -------------------------------------------------------------------------------- /tests/number_styles/err_invalid_digits_hex2.asm: -------------------------------------------------------------------------------- 1 | #d $cdefg ; error: expected line break -------------------------------------------------------------------------------- /tests/number_styles/err_whitespace1.asm: -------------------------------------------------------------------------------- 1 | #d4 0b1101 $0x1000 ; error: expected line break -------------------------------------------------------------------------------- /tests/number_styles/err_whitespace2.asm: -------------------------------------------------------------------------------- 1 | #d4 0b1101 %0b1000 ; error: expected line break -------------------------------------------------------------------------------- /tests/number_styles/ok_patterns.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld $reg => $11 4 | ld %reg => $22 5 | } 6 | 7 | ld $reg ; = 0x11 8 | ld %reg ; = 0x22 -------------------------------------------------------------------------------- /tests/once/1.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | emit {x: u8} => x 4 | } 5 | 6 | #include "once.asm" ; = 0xcd 7 | #include "once.asm" 8 | #include "once.asm" 9 | emit $ ; = 0x01 -------------------------------------------------------------------------------- /tests/once/once.asm: -------------------------------------------------------------------------------- 1 | #once 2 | #d8 0xcd -------------------------------------------------------------------------------- /tests/res/err_invalid_large.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | #res 0x1_0000_0000 ; error: supported range -------------------------------------------------------------------------------- /tests/res/err_invalid_negative.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | #res -1 ; error: supported range -------------------------------------------------------------------------------- /tests/res/ok_arithmetic.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | ld $ ; = 0x5500 8 | #res 1 + 2 ; = 0x000000 9 | ld $ ; = 0x5505 -------------------------------------------------------------------------------- /tests/res/ok_bits3.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | #bankdef test 7 | { 8 | #bits 3 9 | #addr 0 10 | #outp 0 11 | } 12 | 13 | #d3 $ ; = 0b000 14 | #res 2 ; = 0b000_000 15 | label: 16 | #res 3 ; = 0b000_000_000 17 | #d3 $ ; = 0b110 18 | #d3 label ; = 0b011 -------------------------------------------------------------------------------- /tests/res/ok_labels.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | ld $ ; = 0x5500 8 | var1: #res 2 ; = 0x0000 9 | var2: #res 3 ; = 0x000000 10 | ld $ ; = 0x5507 11 | ld var1 ; = 0x5502 12 | ld var2 ; = 0x5504 -------------------------------------------------------------------------------- /tests/res/ok_multiple1.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | ld $ ; = 0x5500 8 | #res 2 ; = 0x0000 9 | #res 3 ; = 0x000000 10 | ld $ ; = 0x5507 -------------------------------------------------------------------------------- /tests/res/ok_multiple2.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | ld $ ; = 0x5500 8 | #res 2 ; = 0x0000 9 | label: 10 | #res 3 ; = 0x000000 11 | ld $ ; = 0x5507 12 | ld label ; = 0x5504 -------------------------------------------------------------------------------- /tests/res/ok_one.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | ld $ ; = 0x5500 8 | #res 1 ; = 0x00 9 | ld $ ; = 0x5503 -------------------------------------------------------------------------------- /tests/res/ok_zero.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | ld $ ; = 0x5500 8 | #res 0 9 | ld $ ; = 0x5502 -------------------------------------------------------------------------------- /tests/rule_arg_complex/err_malformed_expr.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | ld 1 + + 1 ; error: no match -------------------------------------------------------------------------------- /tests/rule_arg_complex/err_unknown_symbol.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | ld (3 + x) * 5 ; error: failed / note:_:3: within / error: unknown -------------------------------------------------------------------------------- /tests/rule_arg_complex/ok_arithmetic.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | ld 1 + 1 ; = 0x5502 7 | ld (1 + 1) ; = 0x5502 8 | ld 3 + 4 * 5 ; = 0x5517 9 | ld (3 + 4) * 5 ; = 0x5523 -------------------------------------------------------------------------------- /tests/rule_arg_forward_ref/ok_constant.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | ld var ; = 0x5511 7 | var = 0x11 -------------------------------------------------------------------------------- /tests/rule_arg_forward_ref/ok_label.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | ld label ; = 0x5502 7 | label: -------------------------------------------------------------------------------- /tests/rule_arg_glued/err_one_param.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld r{x} => 0x55 @ x`8 4 | } 5 | 6 | ld 0 ; error: no match -------------------------------------------------------------------------------- /tests/rule_arg_glued/err_symbol_unknown.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld r{x} => 0x55 @ x`8 4 | } 5 | 6 | x = 0x12 7 | ld ry ; error: failed / note:_:3: within / error: unknown -------------------------------------------------------------------------------- /tests/rule_arg_glued/err_two_params.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld r{x}, {y} => 0x55 @ x`8 @ y`8 4 | } 5 | 6 | ld 0, 0x12 ; error: no match -------------------------------------------------------------------------------- /tests/rule_arg_glued/ok_one_param.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld r{x} => 0x55 @ x`8 4 | } 5 | 6 | ld r0 ; = 0x5500 7 | ld r(0) ; = 0x5500 8 | ld r 0 ; = 0x5500 9 | ld r12 ; = 0x550c 10 | ld r(6 + 6) ; = 0x550c 11 | ld r 6 + 6 ; = 0x550c 12 | ld r6 + 6 ; = 0x550c 13 | ld r257 ; = 0x5501 14 | ld r 0xff ; = 0x55ff 15 | ld r0xff ; = 0x55ff 16 | ld r0x123 ; = 0x5523 -------------------------------------------------------------------------------- /tests/rule_arg_glued/ok_one_param_symbol.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld r{x} => 0x55 @ x`8 4 | } 5 | 6 | x = 0x12 7 | ld rx ; = 0x5512 8 | ld r x + 6 ; = 0x5518 9 | ld r(x + 6) ; = 0x5518 10 | ld rx + 6 ; = 0x5518 -------------------------------------------------------------------------------- /tests/rule_arg_glued/ok_reinterpret.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld %{x} => 0x55 @ x`8 4 | ld ${x} => 0x66 @ x`8 5 | } 6 | 7 | ld %0 ; = 0x5500 8 | ld %(0) ; = 0x5500 9 | ld % 0 ; = 0x5500 10 | ld %12 ; = 0x550c 11 | ld %(6 + 6) ; = 0x550c 12 | ld % 6 + 6 ; = 0x550c 13 | ld %6 + 6 ; = 0x550c 14 | ld %257 ; = 0x5501 15 | ld % 0xff ; = 0x55ff 16 | ld %0xff ; = 0x55ff 17 | ld %0x123 ; = 0x5523 18 | 19 | ld $0 ; = 0x6600 20 | ld $(0) ; = 0x6600 21 | ld $ 0 ; = 0x6600 22 | ld $12 ; = 0x660c 23 | ld $(6 + 6) ; = 0x660c 24 | ld $ 6 + 6 ; = 0x660c 25 | ld $6 + 6 ; = 0x660c 26 | ld $257 ; = 0x6601 27 | ld $ 0xff ; = 0x66ff 28 | ld $0xff ; = 0x66ff 29 | ld $0x123 ; = 0x6623 -------------------------------------------------------------------------------- /tests/rule_arg_glued/ok_two_params.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld r{x}, {y} => 0x55 @ x`8 @ y`8 4 | } 5 | 6 | ld r0, 0x12 ; = 0x550012 7 | ld r(0), 0x12 ; = 0x550012 8 | ld r 0, 0x34 ; = 0x550034 9 | ld r 6 + 6, 0x12 ; = 0x550c12 10 | ld r(6 + 6), 0x12 ; = 0x550c12 11 | ld r6 + 6, 0x12 ; = 0x550c12 12 | ld r257, 0x102 ; = 0x550102 13 | ld r 0xff, 0x12 ; = 0x55ff12 14 | ld r0xff, 0x12 ; = 0x55ff12 15 | ld r0x123, 0x12 ; = 0x552312 -------------------------------------------------------------------------------- /tests/rule_arg_glued/ok_two_params_symbol.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld r{x}, {y} => 0x55 @ x`8 @ y`8 4 | } 5 | 6 | x = 0x12 7 | ld rx, x ; = 0x551212 8 | ld r x + 6, x ; = 0x551812 9 | ld r(x + 6), x ; = 0x551812 10 | ld rx + 6, x ; = 0x551812 -------------------------------------------------------------------------------- /tests/rule_arg_simple/err_missing_arg1.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | ld ; error: no match -------------------------------------------------------------------------------- /tests/rule_arg_simple/err_missing_arg2.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x}, {y} => 0x55 @ x`8 @ y`8 4 | } 5 | 6 | ld 0x11, ; error: no match -------------------------------------------------------------------------------- /tests/rule_arg_simple/err_unknown_in_encoding.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => y 4 | } 5 | 6 | ld 0x11 ; error: failed / note:_:3: within / error:_:3: unknown -------------------------------------------------------------------------------- /tests/rule_arg_simple/err_unknown_symbol1.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | ld x ; error: failed / note:_:3: within / error: unknown -------------------------------------------------------------------------------- /tests/rule_arg_simple/err_unknown_symbol2.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x}, {y} => 0x55 @ x`8 @ y`8 4 | } 5 | 6 | ld 0x11, x ; error: failed / note:_:3: within / error: unknown -------------------------------------------------------------------------------- /tests/rule_arg_simple/err_unsized.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x 4 | } 5 | 6 | ld 123 ; error: failed / note:_:3: within / error:_:3: concatenation -------------------------------------------------------------------------------- /tests/rule_arg_simple/err_unsized_no_opcode.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => x 4 | } 5 | 6 | ld 123 ; error: failed / error:_:3: definite size -------------------------------------------------------------------------------- /tests/rule_arg_simple/ok_lookahead.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x}, {y} => 0x55 @ x`8 @ y`8 4 | } 5 | 6 | ld { {}, 0x1 }, 0x2 ; = 0x550102 7 | ld { {}, 0x11 }, 0x22 ; = 0x551122 8 | ld { {}, 0x111 }, { {}, 0x222 } ; = 0x551122 -------------------------------------------------------------------------------- /tests/rule_arg_simple/ok_parameter_at_start.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | {x} => 0xaa @ x 4 | {x} ld => 0xbb @ x 5 | } 6 | 7 | 0x11 ; = 0xaa11 8 | 0x1122 ; = 0xaa1122 9 | 0x112233 ; = 0xaa112233 10 | 0x11 ld ; = 0xbb11 11 | 0x1122 ld ; = 0xbb1122 12 | 0x112233 ld ; = 0xbb112233 -------------------------------------------------------------------------------- /tests/rule_arg_simple/ok_sliced_internally_long.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x[7:0] 4 | } 5 | 6 | ld 0 ; = 0x5500 7 | ld 12 ; = 0x550c 8 | ld 0xff ; = 0x55ff 9 | ld 0x123 ; = 0x5523 -------------------------------------------------------------------------------- /tests/rule_arg_simple/ok_sliced_internally_short.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | ld 0 ; = 0x5500 7 | ld 12 ; = 0x550c 8 | ld 0xff ; = 0x55ff 9 | ld 0x123 ; = 0x5523 -------------------------------------------------------------------------------- /tests/rule_arg_simple/ok_two_args.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x}, {y} => 0x55 @ x`8 @ y`8 4 | } 5 | 6 | ld 0x1, 0x2 ; = 0x550102 7 | ld 0x11, 0x22 ; = 0x551122 8 | ld 0x111, 0x222 ; = 0x551122 -------------------------------------------------------------------------------- /tests/rule_arg_simple/ok_unsized.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x 4 | } 5 | 6 | ld 0x11 ; = 0x5511 7 | ld 0x1122 ; = 0x551122 8 | ld 0x112233 ; = 0x55112233 -------------------------------------------------------------------------------- /tests/rule_arg_simple/ok_unsized_no_opcode.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => x 4 | } 5 | 6 | ld 0x11 ; = 0x11 7 | ld 0x1122 ; = 0x1122 8 | ld 0x112233 ; = 0x112233 -------------------------------------------------------------------------------- /tests/rule_arg_typed/err_i1.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld1 {x: i1} => 0x55 @ 0b000 @ x 4 | } 5 | 6 | ld1 2 ; error: failed / note:_:3: within / error: out of range 7 | ld1 -2 ; error: failed / note:_:3: within / error: out of range -------------------------------------------------------------------------------- /tests/rule_arg_typed/err_i32.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld32 {x: i32} => 0x55 @ x 4 | } 5 | 6 | ld32 1 << 32 ; error: failed / note:_:3: within / error: out of range -------------------------------------------------------------------------------- /tests/rule_arg_typed/err_i8.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: i8} => 0x55 @ x 4 | } 5 | 6 | ld 256 ; error: failed / note:_:3: within / error: out of range 7 | ld 0x100 ; error: failed / note:_:3: within / error: out of range 8 | ld -129 ; error: failed / note:_:3: within / error: out of range 9 | ld !0x80 ; error: failed / note:_:3: within / error: out of range -------------------------------------------------------------------------------- /tests/rule_arg_typed/err_s8.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: s8} => 0x55 @ x 4 | } 5 | 6 | ld 128 ; error: failed / note:_:3: within / error: out of range 7 | ld 0x80 ; error: failed / note:_:3: within / error: out of range 8 | ld -129 ; error: failed / note:_:3: within / error: out of range 9 | ld !0x80 ; error: failed / note:_:3: within / error: out of range -------------------------------------------------------------------------------- /tests/rule_arg_typed/err_strings.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld1 {x: i8} => 0xaa @ x 4 | ld2 {x: s8} => 0xbb @ x 5 | ld3 {x: u8} => 0xcc @ x 6 | } 7 | 8 | ld1 "abc" ; error: failed / note:_:3: within / error: out of range 9 | ld2 "ã" ; error: failed / note:_:4: within / error: out of range 10 | ld3 "ü" ; error: failed / note:_:5: within / error: out of range -------------------------------------------------------------------------------- /tests/rule_arg_typed/err_u8.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: u8} => 0x55 @ x 4 | } 5 | 6 | ld 0x123 ; error: failed / note:_:3: within / error: out of range 7 | ld 256 ; error: failed / note:_:3: within / error: out of range 8 | ld -1 ; error: failed / note:_:3: within / error: out of range 9 | ld -0x1 ; error: failed / note:_:3: within / error: out of range -------------------------------------------------------------------------------- /tests/rule_arg_typed/err_u8_constant.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: u8} => 0x55 @ x 4 | } 5 | 6 | x = 0x100 7 | ld x ; error: failed / note:_:3: within / error: out of range -------------------------------------------------------------------------------- /tests/rule_arg_typed/err_u8_constant_forward_ref.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: u8} => 0x55 @ x 4 | } 5 | 6 | ld x ; error: failed / note:_:3: within / error: out of range 7 | x = 0x100 -------------------------------------------------------------------------------- /tests/rule_arg_typed/ok_i1.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld1 {x: i1} => 0x55 @ 0b000 @ x 4 | } 5 | 6 | ld1 0 ; = 0x550 7 | ld1 1 ; = 0x551 8 | ld1 -1 ; = 0x551 -------------------------------------------------------------------------------- /tests/rule_arg_typed/ok_i32.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld32 {x: i32} => 0x55 @ x 4 | } 5 | 6 | ld32 0 ; = 0x5500000000 7 | ld32 0xabcde ; = 0x55000abcde 8 | ld32 -1 ; = 0x55ffffffff -------------------------------------------------------------------------------- /tests/rule_arg_typed/ok_i8.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: i8} => 0x55 @ x 4 | } 5 | 6 | ld 0 ; = 0x5500 7 | ld 12 ; = 0x550c 8 | ld 6 * 2 ; = 0x550c 9 | ld 0xc ; = 0x550c 10 | ld 0x001 ; = 0x5501 11 | ld 0xff ; = 0x55ff 12 | ld 255 ; = 0x55ff 13 | ld -1 ; = 0x55ff 14 | ld -0x1 ; = 0x55ff 15 | ld -128 ; = 0x5580 16 | ld !0x7f ; = 0x5580 -------------------------------------------------------------------------------- /tests/rule_arg_typed/ok_s8.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: s8} => 0x55 @ x 4 | } 5 | 6 | ld 0 ; = 0x5500 7 | ld 12 ; = 0x550c 8 | ld 6 * 2 ; = 0x550c 9 | ld 0xc ; = 0x550c 10 | ld 0x001 ; = 0x5501 11 | ld 0x7f ; = 0x557f 12 | ld 127 ; = 0x557f 13 | ld -1 ; = 0x55ff 14 | ld -0x1 ; = 0x55ff 15 | ld -128 ; = 0x5580 16 | ld !0x7f ; = 0x5580 -------------------------------------------------------------------------------- /tests/rule_arg_typed/ok_strings.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld1 {x: i8} => 0xaa @ x 4 | ld2 {x: s8} => 0xbb @ x 5 | ld3 {x: u16} => 0xcc @ x 6 | } 7 | 8 | ld1 "a" ; = 0xaa61 9 | ld2 "b" ; = 0xbb62 10 | ld3 "c" ; = 0xcc0063 -------------------------------------------------------------------------------- /tests/rule_arg_typed/ok_u8.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: u8} => 0x55 @ x 4 | } 5 | 6 | ld 0 ; = 0x5500 7 | ld 12 ; = 0x550c 8 | ld 6 * 2 ; = 0x550c 9 | ld 0xc ; = 0x550c 10 | ld 0xff ; = 0x55ff 11 | ld 255 ; = 0x55ff 12 | ld 0x001 ; = 0x5501 -------------------------------------------------------------------------------- /tests/rule_arg_typed/ok_u8_constant.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: u8} => 0x55 @ x 4 | } 5 | 6 | x = 0xff 7 | ld x ; = 0x55ff -------------------------------------------------------------------------------- /tests/rule_arg_typed/ok_u8_constant_forward_ref.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: u8} => 0x55 @ x 4 | } 5 | 6 | ld x ; = 0x55ff 7 | x = 0xff -------------------------------------------------------------------------------- /tests/rule_assert/err_args_too_few.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert() 6 | 0x55 @ x`8 7 | } 8 | } 9 | 10 | ld 0x15 ; error: failed / note:_:3: within / error:_:5: expected 1 to 2 arguments -------------------------------------------------------------------------------- /tests/rule_assert/err_args_too_many.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x < 0x10, "your custom message!", "another message!") 6 | 0x55 @ x`8 7 | } 8 | } 9 | 10 | ld 0x15 ; error: failed / note:_:3: within / error:_:5: expected 1 to 2 arguments -------------------------------------------------------------------------------- /tests/rule_assert/err_condition_wrong_type.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert("your custom message!", x < 0x10) 6 | 0x55 @ x`8 7 | } 8 | } 9 | 10 | ld 0x15 ; error: failed / note:_:3: within / error:_:5: expected boolean -------------------------------------------------------------------------------- /tests/rule_assert/err_forward_ref.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x < 0x10) 6 | 0x55 @ x`8 7 | } 8 | } 9 | 10 | ld var ; error: failed / note:_:3: within / error:_:5: assertion 11 | var = 0x15 -------------------------------------------------------------------------------- /tests/rule_assert/err_message.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x < 0x10, "your custom message!") 6 | 0x55 @ x`8 7 | } 8 | } 9 | 10 | ld 0x15 ; error: failed / note:_:3: within / error:_:5: your custom message! -------------------------------------------------------------------------------- /tests/rule_assert/err_message_wrong_type.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x < 0x10, 0x1234) 6 | 0x55 @ x`8 7 | } 8 | } 9 | 10 | ld 0x15 ; error: failed / note:_:3: within / error:_:5: expected string -------------------------------------------------------------------------------- /tests/rule_assert/err_simple.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x < 0x10) 6 | 0x55 @ x`8 7 | } 8 | } 9 | 10 | ld 0x15 ; error: failed / note:_:3: within / error:_:5: assertion -------------------------------------------------------------------------------- /tests/rule_assert/ok_forward_ref.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x < 0x10) 6 | 0x55 @ x`8 7 | } 8 | } 9 | 10 | ld var ; = 0x5505 11 | var = 0x5 -------------------------------------------------------------------------------- /tests/rule_assert/ok_message.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x < 0x10, "your custom message!") 6 | 0x55 @ x`8 7 | } 8 | } 9 | 10 | ld 0x5 ; = 0x5505 11 | ld -0x20 ; = 0x55e0 -------------------------------------------------------------------------------- /tests/rule_assert/ok_simple.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x < 0x10) 6 | 0x55 @ x`8 7 | } 8 | } 9 | 10 | ld 0x5 ; = 0x5505 11 | ld -0x20 ; = 0x55e0 -------------------------------------------------------------------------------- /tests/rule_cascading/ok.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x < 0x10) 6 | 0x110 @ x`4 7 | } 8 | 9 | ld {x} => 10 | { 11 | assert(x >= 0x10 && x < 0x100) 12 | 0x22 @ x`8 13 | } 14 | 15 | ld {x} => 16 | { 17 | assert(x >= 0x100) 18 | 0x33 @ x`16 19 | } 20 | } 21 | 22 | ld 0x5 ; = 0x1105 23 | ld 0x15 ; = 0x2215 24 | ld 0x215 ; = 0x330215 25 | ld 0x43215 ; = 0x333215 -------------------------------------------------------------------------------- /tests/rule_cascading_convergence/err_all.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x <= 0x8) 6 | 0x11 @ x`16 7 | } 8 | 9 | ld {x} => 10 | { 11 | assert(x > 0x8) 12 | 0x22 @ x`8 13 | } 14 | } 15 | 16 | ld label ; error: converge 17 | ld label ; error: converge 18 | ld label ; error: converge 19 | label: ; error: converge -------------------------------------------------------------------------------- /tests/rule_cascading_convergence/err_some.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x <= 0x8) 6 | 0x11 @ x`16 7 | } 8 | 9 | ld {x} => 10 | { 11 | assert(x > 0x8) 12 | 0x22 @ x`8 13 | } 14 | } 15 | 16 | ld label ; error: converge 17 | ld 0x4 18 | ld label ; error: converge 19 | label: ; error: converge -------------------------------------------------------------------------------- /tests/rule_cascading_convergence/ok.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x <= 0x8) 6 | 0x11 @ x`16 7 | } 8 | 9 | ld {x} => 10 | { 11 | assert(x > 0x8) 12 | 0x22 @ x`8 13 | } 14 | } 15 | 16 | ld label ; = 0x110006 17 | ld label ; = 0x110006 18 | label: -------------------------------------------------------------------------------- /tests/rule_cascading_forward_ref/ok_multiple1.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x < 0x10) 6 | 0x110 @ x`4 7 | } 8 | 9 | ld {x} => 10 | { 11 | assert(x >= 0x10 && x < 0x100) 12 | 0x22 @ x`8 13 | } 14 | 15 | ld {x} => 16 | { 17 | assert(x >= 0x100) 18 | 0x33 @ x`16 19 | } 20 | } 21 | 22 | ld var ; = 0x1105 23 | ld var ; = 0x1105 24 | ld var ; = 0x1105 25 | var = 0x5 -------------------------------------------------------------------------------- /tests/rule_cascading_forward_ref/ok_multiple2.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x < 0x10) 6 | 0x110 @ x`4 7 | } 8 | 9 | ld {x} => 10 | { 11 | assert(x >= 0x10 && x < 0x100) 12 | 0x22 @ x`8 13 | } 14 | 15 | ld {x} => 16 | { 17 | assert(x >= 0x100) 18 | 0x33 @ x`16 19 | } 20 | } 21 | 22 | ld var ; = 0x330215 23 | ld var ; = 0x330215 24 | ld var ; = 0x330215 25 | var = 0x215 -------------------------------------------------------------------------------- /tests/rule_cascading_forward_ref/ok_single1.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x < 0x10) 6 | 0x110 @ x`4 7 | } 8 | 9 | ld {x} => 10 | { 11 | assert(x >= 0x10 && x < 0x100) 12 | 0x22 @ x`8 13 | } 14 | 15 | ld {x} => 16 | { 17 | assert(x >= 0x100) 18 | 0x33 @ x`16 19 | } 20 | } 21 | 22 | ld var ; = 0x1105 23 | var = 0x5 -------------------------------------------------------------------------------- /tests/rule_cascading_forward_ref/ok_single2.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x < 0x10) 6 | 0x110 @ x`4 7 | } 8 | 9 | ld {x} => 10 | { 11 | assert(x >= 0x10 && x < 0x100) 12 | 0x22 @ x`8 13 | } 14 | 15 | ld {x} => 16 | { 17 | assert(x >= 0x100) 18 | 0x33 @ x`16 19 | } 20 | } 21 | 22 | ld var ; = 0x2215 23 | var = 0x15 -------------------------------------------------------------------------------- /tests/rule_cascading_forward_ref/ok_single3.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x < 0x10) 6 | 0x110 @ x`4 7 | } 8 | 9 | ld {x} => 10 | { 11 | assert(x >= 0x10 && x < 0x100) 12 | 0x22 @ x`8 13 | } 14 | 15 | ld {x} => 16 | { 17 | assert(x >= 0x100) 18 | 0x33 @ x`16 19 | } 20 | } 21 | 22 | ld var ; = 0x330215 23 | var = 0x215 -------------------------------------------------------------------------------- /tests/rule_cascading_forward_ref/ok_single4.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x < 0x10) 6 | 0x110 @ x`4 7 | } 8 | 9 | ld {x} => 10 | { 11 | assert(x >= 0x10 && x < 0x100) 12 | 0x22 @ x`8 13 | } 14 | 15 | ld {x} => 16 | { 17 | assert(x >= 0x100) 18 | 0x33 @ x`16 19 | } 20 | } 21 | 22 | ld var ; = 0x333215 23 | var = 0x43215 -------------------------------------------------------------------------------- /tests/rule_cascading_size/err_all_same.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: u8} => 4 | { 5 | 0x11 @ x`24 6 | } 7 | 8 | ld {x: u16} => 9 | { 10 | 0x22 @ x`24 11 | } 12 | 13 | ld {x: u24} => 14 | { 15 | 0x33 @ x`24 16 | } 17 | } 18 | 19 | ld 0x215 ; error: multiple / note:_:8: match / note:_:13: match 20 | ld 0x15 ; error: multiple / note:_:3: match / note:_:8: match / note:_:13: match 21 | -------------------------------------------------------------------------------- /tests/rule_cascading_size/ok_all_same.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: u8} => 4 | { 5 | 0x11 @ x`24 6 | } 7 | 8 | ld {x: u16} => 9 | { 10 | 0x22 @ x`24 11 | } 12 | 13 | ld {x: u24} => 14 | { 15 | 0x33 @ x`24 16 | } 17 | } 18 | 19 | ld 0x43215 ; = 0x33043215 -------------------------------------------------------------------------------- /tests/rule_cascading_size/ok_large_to_small.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: u8} => 4 | { 5 | 0x11 @ x`24 6 | } 7 | 8 | ld {x: u16} => 9 | { 10 | 0x22 @ x`16 11 | } 12 | 13 | ld {x: u24} => 14 | { 15 | 0x33 @ x`8 16 | } 17 | } 18 | 19 | ld 0x5 ; = 0x3305 20 | ld 0x15 ; = 0x3315 21 | ld 0x215 ; = 0x3315 22 | ld 0x43215 ; = 0x3315 -------------------------------------------------------------------------------- /tests/rule_cascading_size/ok_small_to_large.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x: u8} => 4 | { 5 | 0x11 @ x`8 6 | } 7 | 8 | ld {x: u16} => 9 | { 10 | 0x22 @ x`16 11 | } 12 | 13 | ld {x: u24} => 14 | { 15 | 0x33 @ x`24 16 | } 17 | } 18 | 19 | ld 0x5 ; = 0x1105 20 | ld 0x15 ; = 0x1115 21 | ld 0x215 ; = 0x220215 22 | ld 0x43215 ; = 0x33043215 -------------------------------------------------------------------------------- /tests/rule_empty/err_after_token.asm: -------------------------------------------------------------------------------- 1 | #subruledef 2 | { 3 | ld {} => 0xff ; error: expected identifier 4 | } -------------------------------------------------------------------------------- /tests/rule_empty/err_before_token.asm: -------------------------------------------------------------------------------- 1 | #subruledef 2 | { 3 | {} ld => 0xff ; error: expected `=>` 4 | } -------------------------------------------------------------------------------- /tests/rule_empty/err_double.asm: -------------------------------------------------------------------------------- 1 | #subruledef 2 | { 3 | {}{} => 0xff ; error: expected `=>` 4 | } -------------------------------------------------------------------------------- /tests/rule_empty/err_in_ruledef.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | {} => 0xff ; error: expected identifier 4 | } -------------------------------------------------------------------------------- /tests/rule_empty/ok.asm: -------------------------------------------------------------------------------- 1 | #subruledef reg 2 | { 3 | {} => 0x00 4 | a, => 0xaa 5 | b, => 0xbb 6 | c, => 0xcc 7 | } 8 | 9 | #ruledef 10 | { 11 | load {r: reg} {val: u8} => 0x55 @ r @ val 12 | } 13 | 14 | load 0x11 ; = 0x550011 15 | load a, 0x11 ; = 0x55aa11 16 | load b, 0x11 ; = 0x55bb11 17 | load c, 0x11 ; = 0x55cc11 -------------------------------------------------------------------------------- /tests/rule_multiple/err_multiple.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | halt => 0x66 5 | } 6 | 7 | halt ; error: multiple / note:_:3: match / note:_:4: match -------------------------------------------------------------------------------- /tests/rule_multiple/ok_match_priority.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {val} => 0x00 @ val`8 4 | ld x => 0xff @ 0x00 5 | } 6 | 7 | x = 0x55 8 | ld x ; = 0xff00 -------------------------------------------------------------------------------- /tests/rule_multiple/ok_match_priority_forward_ref.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {val} => 0x00 @ val`8 4 | ld x => 0xff @ 0x00 5 | } 6 | 7 | ld x ; = 0xff00 8 | x = 0x55 -------------------------------------------------------------------------------- /tests/rule_multiple/ok_multiple.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {val} => 0x00 @ val`8 4 | ld x => 0xff @ 0x00 5 | } 6 | 7 | ld 0x55 ; = 0x0055 8 | ld x ; = 0xff00 -------------------------------------------------------------------------------- /tests/rule_nested_ambiguous/err_no_match1.asm: -------------------------------------------------------------------------------- 1 | #subruledef inner 2 | { 3 | {x} => 0x11 @ x`8 4 | {x}$ => 0x22 @ x`8 5 | } 6 | 7 | #ruledef test 8 | { 9 | ld {x: inner}$ => 0x55 @ x`16 10 | } 11 | 12 | ld 0xaa ; error: no match -------------------------------------------------------------------------------- /tests/rule_nested_ambiguous/ok1.asm: -------------------------------------------------------------------------------- 1 | #subruledef inner 2 | { 3 | {x} => 0x11 @ x`8 4 | {x}$ => 0x22 @ x`8 5 | } 6 | 7 | #ruledef test 8 | { 9 | ld {x: inner}$ => 0x55 @ x`16 10 | } 11 | 12 | ld 0xaa$ ; = 0x5511aa 13 | ld 0xaa$$ ; = 0x5522aa 14 | ld 0x99 + 0x11$ ; = 0x5511aa 15 | ld 0x99 + 0x11$$ ; = 0x5522aa 16 | ld (0x99 + 0x11)$ ; = 0x5511aa 17 | ld (0x99 + 0x11)$$ ; = 0x5522aa -------------------------------------------------------------------------------- /tests/rule_nested_ambiguous/ok2.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | move to {x: u8} if {y: u8} => 0x55 @ x @ y 4 | } 5 | 6 | input: 7 | .input: 8 | move to input if 0xaa ; = 0x5500aa 9 | move to .input if 0xaa ; = 0x5500aa -------------------------------------------------------------------------------- /tests/rule_nested_arg/err_missing_arg.asm: -------------------------------------------------------------------------------- 1 | #subruledef inner 2 | { 3 | {x} => 0x11 @ x`8 4 | &{x} => 0x22 @ x`8 5 | ({x}+) => 0x33 @ x`8 6 | } 7 | 8 | #ruledef test 9 | { 10 | ld {x: inner} => 0x55 @ x`16 11 | } 12 | 13 | ld ; error: no match -------------------------------------------------------------------------------- /tests/rule_nested_arg/err_no_inner_match.asm: -------------------------------------------------------------------------------- 1 | #subruledef inner 2 | { 3 | {x} => 0x11 @ x`8 4 | &{x} => 0x22 @ x`8 5 | ({x}+) => 0x33 @ x`8 6 | } 7 | 8 | #ruledef test 9 | { 10 | ld {x: inner} => 0x55 @ x`16 11 | } 12 | 13 | ld 0xaa+; error: no match -------------------------------------------------------------------------------- /tests/rule_nested_arg/err_unknown_symbol.asm: -------------------------------------------------------------------------------- 1 | #subruledef inner 2 | { 3 | {x} => 0x11 @ x`8 4 | &{x} => 0x22 @ x`8 5 | ({x}+) => 0x33 @ x`8 6 | } 7 | 8 | #ruledef test 9 | { 10 | ld {x: inner} => 0x55 @ x`16 11 | } 12 | 13 | ld x ; error: failed / note:_:10: within / note:_:3: within / error: unknown -------------------------------------------------------------------------------- /tests/rule_nested_arg/ok.asm: -------------------------------------------------------------------------------- 1 | #subruledef inner 2 | { 3 | {x} => 0x11 @ x`8 4 | &{x} => 0x22 @ x`8 5 | ({x}+) => 0x33 @ x`8 6 | } 7 | 8 | #ruledef test 9 | { 10 | ld {x: inner} => 0x55 @ x`16 11 | } 12 | 13 | ld 0xaa ; = 0x5511aa 14 | ld &0xaa ; = 0x5522aa 15 | ld & 0xaa ; = 0x5522aa 16 | ld 0xaa & 0xaa ; = 0x5511aa 17 | ld (0xaa+) ; = 0x5533aa 18 | ld (0xaa) ; = 0x5511aa -------------------------------------------------------------------------------- /tests/rule_nested_simple/err_missing_arg1.asm: -------------------------------------------------------------------------------- 1 | #subruledef inner 2 | { 3 | a => 0x11 4 | b => 0x22 5 | c.w => 0x33 6 | } 7 | 8 | #ruledef test 9 | { 10 | ld {reg: inner}, {x} => 0x55 @ reg`8 @ x`8 11 | } 12 | 13 | ld ; error: no match -------------------------------------------------------------------------------- /tests/rule_nested_simple/err_missing_arg2.asm: -------------------------------------------------------------------------------- 1 | #subruledef inner 2 | { 3 | a => 0x11 4 | b => 0x22 5 | c.w => 0x33 6 | } 7 | 8 | #ruledef test 9 | { 10 | ld {reg: inner}, {x} => 0x55 @ reg`8 @ x`8 11 | } 12 | 13 | ld 0xaa; error: no match -------------------------------------------------------------------------------- /tests/rule_nested_simple/err_missing_arg3.asm: -------------------------------------------------------------------------------- 1 | #subruledef inner 2 | { 3 | a => 0x11 4 | b => 0x22 5 | c.w => 0x33 6 | } 7 | 8 | #ruledef test 9 | { 10 | ld {reg: inner}, {x} => 0x55 @ reg`8 @ x`8 11 | } 12 | 13 | ld a; error: no match -------------------------------------------------------------------------------- /tests/rule_nested_simple/err_missing_comma.asm: -------------------------------------------------------------------------------- 1 | #subruledef inner 2 | { 3 | a => 0x11 4 | b => 0x22 5 | c.w => 0x33 6 | } 7 | 8 | #ruledef test 9 | { 10 | ld {reg: inner}, {x} => 0x55 @ reg`8 @ x`8 11 | } 12 | 13 | ld a 0xaa; error: no match -------------------------------------------------------------------------------- /tests/rule_nested_simple/err_no_inner_match.asm: -------------------------------------------------------------------------------- 1 | #subruledef inner 2 | { 3 | a => 0x11 4 | b => 0x22 5 | c.w => 0x33 6 | } 7 | 8 | #ruledef test 9 | { 10 | ld {reg: inner}, {x} => 0x55 @ reg`8 @ x`8 11 | } 12 | 13 | ld c, 0xaa ; error: no match -------------------------------------------------------------------------------- /tests/rule_nested_simple/err_subruledef_at_toplevel.asm: -------------------------------------------------------------------------------- 1 | #subruledef inner 2 | { 3 | a => 0x11 4 | } 5 | 6 | #ruledef test 7 | { 8 | ld {reg: inner} => 0x55 @ reg`8 9 | } 10 | 11 | ld a 12 | a ; error: no match -------------------------------------------------------------------------------- /tests/rule_nested_simple/err_unknown_subruledef.asm: -------------------------------------------------------------------------------- 1 | #subruledef inner 2 | { 3 | a => 0x11 4 | } 5 | 6 | #ruledef test 7 | { 8 | ld {reg: unk} => 0x55 @ reg`8 ; error: unknown 9 | } -------------------------------------------------------------------------------- /tests/rule_nested_simple/err_unknown_symbol.asm: -------------------------------------------------------------------------------- 1 | #subruledef inner 2 | { 3 | a => 0x11 4 | b => 0x22 5 | c.w => 0x33 6 | } 7 | 8 | #ruledef test 9 | { 10 | ld {reg: inner}, {x} => 0x55 @ reg`8 @ x`8 11 | } 12 | 13 | ld a, x ; error: failed / note:_:10: within / error: unknown -------------------------------------------------------------------------------- /tests/rule_nested_simple/ok.asm: -------------------------------------------------------------------------------- 1 | #subruledef inner 2 | { 3 | a => 0x11 4 | b => 0x22 5 | c.w => 0x33 6 | } 7 | 8 | #ruledef test 9 | { 10 | ld {reg: inner}, {x} => 0x55 @ reg`8 @ x`8 11 | } 12 | 13 | ld a, 0xaa ; = 0x5511aa 14 | ld b, 0xaa ; = 0x5522aa 15 | ld c.w, 0xaa ; = 0x5533aa -------------------------------------------------------------------------------- /tests/rule_simple/err_duplicate.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | nop => 0xaa 5 | } 6 | 7 | 8 | #ruledef test ; error: duplicate / note:_:1: first 9 | { 10 | halt => 0x55 11 | } -------------------------------------------------------------------------------- /tests/rule_simple/err_encoding_type.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | test => 1 > 2 4 | } 5 | 6 | test ; error: failed / error:_:3: expected integer -------------------------------------------------------------------------------- /tests/rule_simple/err_expected_identifier.asm: -------------------------------------------------------------------------------- 1 | #ruledef "test" ; error: expected 2 | { 3 | halt => 0x55 4 | } -------------------------------------------------------------------------------- /tests/rule_simple/err_no_line_break.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | nop => 0xaa 5 | } 6 | 7 | halt 8 | nop 9 | halt nop ; error: no match 10 | halt 11 | nop -------------------------------------------------------------------------------- /tests/rule_simple/err_punctuation_whitespace.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | test*(x->$) => 0x55 4 | } 5 | 6 | t e s t * ( x - > $ ) ; error: no match -------------------------------------------------------------------------------- /tests/rule_simple/err_unknown.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt 7 | unk ; error: no match 8 | halt 9 | unk ; error: no match 10 | halt 11 | unk ; error: no match 12 | halt -------------------------------------------------------------------------------- /tests/rule_simple/err_whitespace.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | h a l t ; error: no match -------------------------------------------------------------------------------- /tests/rule_simple/ok_long_instr.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | a.really.long.instruction => 0x55 4 | } 5 | 6 | a.really.long.instruction ; = 0x55 7 | a.really.long.instruction ; = 0x55 8 | 9 | A.Really.Long.Instruction ; = 0x55 -------------------------------------------------------------------------------- /tests/rule_simple/ok_one_instr.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | } 5 | 6 | halt ; = 0x55 7 | halt ; = 0x55 8 | 9 | HaLt ; = 0x55 -------------------------------------------------------------------------------- /tests/rule_simple/ok_punctuation.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | test*(x->$) => 0x55 4 | } 5 | 6 | test*(x->$) ; = 0x55 -------------------------------------------------------------------------------- /tests/rule_simple/ok_two_instrs.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | halt => 0x55 4 | nop => 0xaa 5 | } 6 | 7 | halt ; = 0x55 8 | nop ; = 0xaa 9 | halt ; = 0x55 10 | nop ; = 0xaa -------------------------------------------------------------------------------- /tests/rule_simple/ok_two_ruledefs.asm: -------------------------------------------------------------------------------- 1 | #ruledef 2 | { 3 | halt => 0x55 4 | } 5 | 6 | #ruledef 7 | { 8 | nop => 0xaa 9 | } 10 | 11 | halt ; = 0x55 12 | nop ; = 0xaa 13 | halt ; = 0x55 14 | nop ; = 0xaa -------------------------------------------------------------------------------- /tests/string_encoding/err_expected.asm: -------------------------------------------------------------------------------- 1 | #d utf8(0x1234) ; error: failed / error: expected string -------------------------------------------------------------------------------- /tests/string_encoding/err_expected_concat.asm: -------------------------------------------------------------------------------- 1 | #d utf8("abc" @ "def") ; error: failed / error: expected string -------------------------------------------------------------------------------- /tests/string_encoding/err_too_few_args.asm: -------------------------------------------------------------------------------- 1 | #d utf8() ; error: failed / error: expected 1 argument -------------------------------------------------------------------------------- /tests/string_encoding/err_too_many_args.asm: -------------------------------------------------------------------------------- 1 | #d utf8("abc", "def") ; error: failed / error: expected 1 argument -------------------------------------------------------------------------------- /tests/symbol_builtin/ok_dollar.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | ld $ ; = 0x5500 -------------------------------------------------------------------------------- /tests/symbol_builtin/ok_dollar_multiple.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | ld $ ; = 0x5500 8 | ld $ ; = 0x5502 9 | ld $ ; = 0x5504 10 | ld $ ; = 0x5506 -------------------------------------------------------------------------------- /tests/symbol_builtin/ok_dollar_pc_isolated.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | ld $ ; = 0x5500 8 | ld pc ; = 0x5502 9 | ld $ ; = 0x5504 10 | ld pc ; = 0x5506 -------------------------------------------------------------------------------- /tests/symbol_builtin/ok_dollar_pc_mixed.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | ld $ + $ ; = 0x5500 8 | ld $ + pc ; = 0x5504 9 | ld pc + $ ; = 0x5508 -------------------------------------------------------------------------------- /tests/symbol_constant_outoforder/err_cascading_instr1.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x <= 0x8) 6 | 0x11 @ x`16 7 | } 8 | 9 | ld {x} => 10 | { 11 | assert(x > 0x8) 12 | 0x22 @ x`8 13 | } 14 | } 15 | 16 | x = y ; error: converge 17 | ld x ; error: converge 18 | ld x ; error: converge 19 | label: ; error: converge 20 | y = label + 3 ; error: converge -------------------------------------------------------------------------------- /tests/symbol_constant_outoforder/err_cascading_instr2.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x <= 0x8) 6 | 0x11 @ x`16 7 | } 8 | 9 | ld {x} => 10 | { 11 | assert(x > 0x8) 12 | 0x22 @ x`8 13 | } 14 | } 15 | 16 | ld x 17 | ld x 18 | x = y ; error: converge 19 | label: 20 | y = label + 3 -------------------------------------------------------------------------------- /tests/symbol_constant_outoforder/err_cyclical.asm: -------------------------------------------------------------------------------- 1 | x = y + 1 ; error: unresolved 2 | y = z + 1 3 | z = x + 1 4 | 5 | #d8 x 6 | #d8 y -------------------------------------------------------------------------------- /tests/symbol_constant_outoforder/err_cyclical_allzero.asm: -------------------------------------------------------------------------------- 1 | x = y ; error: unresolved 2 | y = x 3 | 4 | #d8 x 5 | #d8 y -------------------------------------------------------------------------------- /tests/symbol_constant_outoforder/err_unknown_y.asm: -------------------------------------------------------------------------------- 1 | x = y + y ; error: unknown 2 | 3 | #d8 x -------------------------------------------------------------------------------- /tests/symbol_constant_outoforder/err_unknown_z.asm: -------------------------------------------------------------------------------- 1 | x = y + y 2 | y = z + z ; error: unknown 3 | 4 | #d8 x 5 | #d8 y -------------------------------------------------------------------------------- /tests/symbol_constant_outoforder/ok_cascading_instr1.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x <= 0x8) 6 | 0x11 @ x`16 7 | } 8 | 9 | ld {x} => 10 | { 11 | assert(x > 0x8) 12 | 0x22 @ x`8 13 | } 14 | } 15 | 16 | x1 = y1 + y1 17 | ld x1 ; = 0x2210 18 | ld x1 ; = 0x2210 19 | y1 = 8 20 | 21 | ld x2 ; = 0x110002 22 | ld x2 ; = 0x110002 23 | x2 = y2 + y2 24 | y2 = 1 -------------------------------------------------------------------------------- /tests/symbol_constant_outoforder/ok_cascading_instr2.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 4 | { 5 | assert(x <= 0x8) 6 | 0x11 @ x`16 7 | } 8 | 9 | ld {x} => 10 | { 11 | assert(x > 0x8) 12 | 0x22 @ x`8 13 | } 14 | } 15 | 16 | x = y 17 | ld x ; = 0x110006 18 | ld x ; = 0x110006 19 | y = label 20 | label: -------------------------------------------------------------------------------- /tests/symbol_constant_outoforder/ok_xy.asm: -------------------------------------------------------------------------------- 1 | x = y + y 2 | y = 1 3 | 4 | #d8 x ; = 0x02 5 | #d8 y ; = 0x01 -------------------------------------------------------------------------------- /tests/symbol_constant_outoforder/ok_xyz.asm: -------------------------------------------------------------------------------- 1 | x = y + y 2 | y = z + z 3 | z = 1 4 | 5 | #d8 x ; = 0x04 6 | #d8 y ; = 0x02 7 | #d8 z ; = 0x01 -------------------------------------------------------------------------------- /tests/symbol_constant_simple/err_duplicate.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | val1 = 2 * 2 8 | val2 = val1 + val1 9 | ld val1 10 | ld val2 11 | val1 = 8 ; error: duplicate / note:_:7: first -------------------------------------------------------------------------------- /tests/symbol_constant_simple/err_literal_const_invalid_attrb.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | #const(invalid) val = 0xaa ; error: invalid attribute 8 | ld val -------------------------------------------------------------------------------- /tests/symbol_constant_simple/ok_arithmetic.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | val = 1 + 1 8 | ld val ; = 0x5502 -------------------------------------------------------------------------------- /tests/symbol_constant_simple/ok_dependent.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | val1 = 2 * 2 8 | val2 = val1 + val1 9 | ld val1 ; = 0x5504 10 | ld val2 ; = 0x5508 -------------------------------------------------------------------------------- /tests/symbol_constant_simple/ok_literal.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | val = 0xaa 8 | ld val ; = 0x55aa -------------------------------------------------------------------------------- /tests/symbol_constant_simple/ok_literal_const.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | #const val = 0xaa 8 | ld val ; = 0x55aa -------------------------------------------------------------------------------- /tests/symbol_constant_simple/ok_literal_const_noemit.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | #const(noemit) val = 0xaa 8 | ld val ; = 0x55aa -------------------------------------------------------------------------------- /tests/symbol_constant_simple/ok_nested.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x}, {y}, {z} => 0x55 @ x`8 @ y`8 @ z`8 4 | } 5 | 6 | 7 | x = 0x11 8 | .y = 0x22 9 | ..z = 0x33 10 | ld x, .y, ..z ; = 0x55112233 11 | ld x, x.y, x.y.z ; = 0x55112233 -------------------------------------------------------------------------------- /tests/symbol_constant_simple/ok_nested_const.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x}, {y}, {z} => 0x55 @ x`8 @ y`8 @ z`8 4 | } 5 | 6 | 7 | #const x = 0x11 8 | #const .y = 0x22 9 | #const ..z = 0x33 10 | ld x, .y, ..z ; = 0x55112233 11 | ld x, x.y, x.y.z ; = 0x55112233 -------------------------------------------------------------------------------- /tests/symbol_label_nested/err_local_missing_colon.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | global1: 8 | .local1: 9 | ..local2 ; error: expected 10 | ld global1.local1 -------------------------------------------------------------------------------- /tests/symbol_label_nested/err_local_outside.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | global1: 8 | .local1: 9 | global2: 10 | ld .local1 ; error: failed / note:_:3: within / error: unknown -------------------------------------------------------------------------------- /tests/symbol_label_nested/err_skip_level1.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | .local1: ; error: nesting level 8 | ld .local1 -------------------------------------------------------------------------------- /tests/symbol_label_nested/err_skip_level2.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | global1: 8 | ..local1: ; error: nesting level 9 | ld ..local1 -------------------------------------------------------------------------------- /tests/symbol_label_nested/err_skip_level3.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | global1: 8 | ld ..local2 9 | ..local2: ; error: nesting level -------------------------------------------------------------------------------- /tests/symbol_label_nested/err_unknown_global.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | global1: 8 | .local1: 9 | ld global2.local1 ; error: failed / note:_:3: within / error: unknown -------------------------------------------------------------------------------- /tests/symbol_label_nested/err_unknown_local.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | global1: 8 | .local1: 9 | ld .local3 ; error: failed / note:_:3: within / error: unknown -------------------------------------------------------------------------------- /tests/symbol_label_nested/err_unknown_local_fully_qualified.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | global1: 8 | .local1: 9 | ld global1.local3 ; error: failed / note:_:3: within / error: unknown -------------------------------------------------------------------------------- /tests/symbol_label_nested/ok_forward_ref.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | global1: 8 | .local1: 9 | ld ..local2 ; = 0x5502 10 | ..local2: -------------------------------------------------------------------------------- /tests/symbol_label_nested/ok_fully_qualified_ref.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | ; multiple sections of one level, externally referenced 7 | 8 | global1: 9 | ld global1 ; = 0x5500 10 | .local1: 11 | ld .local1 ; = 0x5502 12 | .local2: 13 | ld .local2 ; = 0x5504 14 | global2: 15 | ld global1 ; = 0x5500 16 | ld global2 ; = 0x5506 17 | .local1: 18 | ld global1.local1 ; = 0x5502 19 | ld global2.local1 ; = 0x550a 20 | ld .local1 ; = 0x550a 21 | .local2: 22 | ld global1.local1 ; = 0x5502 23 | ld global1.local2 ; = 0x5504 24 | ld global2.local1 ; = 0x550a 25 | ld global2.local2 ; = 0x5510 26 | ld .local1 ; = 0x550a 27 | ld .local2 ; = 0x5510 -------------------------------------------------------------------------------- /tests/symbol_label_nested/ok_locals.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | ; one level of nesting 7 | 8 | global1: 9 | ld global1 ; = 0x5500 10 | .local1: 11 | ld .local1 ; = 0x5502 12 | .local2: 13 | ld .local1 ; = 0x5502 14 | ld .local2 ; = 0x5504 -------------------------------------------------------------------------------- /tests/symbol_label_nested/ok_locals2.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | ; multiple sections of one level 7 | 8 | global1: 9 | ld global1 ; = 0x5500 10 | .local1: 11 | ld .local1 ; = 0x5502 12 | .local2: 13 | ld .local1 ; = 0x5502 14 | ld .local2 ; = 0x5504 15 | global2: 16 | ld global1 ; = 0x5500 17 | ld global2 ; = 0x5508 18 | .local1: 19 | ld .local1 ; = 0x550c 20 | .local2: 21 | ld .local1 ; = 0x550c 22 | ld .local2 ; = 0x550e -------------------------------------------------------------------------------- /tests/symbol_label_nested/ok_up_ref1.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | ; going back multiple levels 7 | 8 | global1: 9 | .local1_1: 10 | ..local2_1: 11 | ...local3_1: 12 | ld global1 ; = 0x5500 13 | ld .local1_1 ; = 0x5500 14 | ld ..local2_1 ; = 0x5500 15 | ld ...local3_1 ; = 0x5500 16 | global2: 17 | ld global2 ; = 0x5508 -------------------------------------------------------------------------------- /tests/symbol_label_nested/ok_up_ref2.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | ; referencing symbols at levels above 7 | 8 | global1: 9 | .local1_1: 10 | ..local2_1: 11 | ...local3_1: 12 | ld global1 ; = 0x5500 13 | ld .local1_1 ; = 0x5500 14 | ld ..local2_1 ; = 0x5500 15 | ld ...local3_1 ; = 0x5500 16 | ..local2_2: 17 | ...local3_1: 18 | ld global1 ; = 0x5500 19 | ld .local1_1 ; = 0x5500 20 | ld ..local2_1 ; = 0x5500 21 | ld ...local3_1 ; = 0x5508 22 | ld ..local2_2 ; = 0x5508 23 | ld ...local3_1 ; = 0x5508 24 | ld ..local2_1.local3_1 ; = 0x5500 -------------------------------------------------------------------------------- /tests/symbol_label_simple/err_duplicate.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | label: 8 | ld label 9 | label: ; error: duplicate / note:_:7: first 10 | ld label -------------------------------------------------------------------------------- /tests/symbol_label_simple/ok_multiple.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | label1: 8 | ld label1 ; = 0x5500 9 | label2: 10 | ld label1 ; = 0x5500 11 | ld label2 ; = 0x5502 -------------------------------------------------------------------------------- /tests/symbol_label_simple/ok_single.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld {x} => 0x55 @ x`8 4 | } 5 | 6 | 7 | label: 8 | ld label ; = 0x5500 -------------------------------------------------------------------------------- /tests/tokenizer/ok_keyword_disambiguation.asm: -------------------------------------------------------------------------------- 1 | #ruledef test 2 | { 3 | ld asm asmx {asmx} => 0x11 @ asmx 4 | ld true truex {truex} => 0x22 @ truex 5 | ld false falsex {falsex} => 0x33 @ falsex 6 | } 7 | 8 | ld asm asmx 0xff ; = 0x11ff 9 | ld true truex 0xff ; = 0x22ff 10 | ld false falsex 0xff ; = 0x33ff --------------------------------------------------------------------------------