1195 lines
39 KiB
NASM
1195 lines
39 KiB
NASM
.importonce
|
|
|
|
// The MIT License (MIT)
|
|
//
|
|
// Copyright (c) 2015 Michał Taszycki
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in all
|
|
// copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
// SOFTWARE.
|
|
|
|
.const _64SPEC_VERSION_MAJOR = 0
|
|
.const _64SPEC_VERSION_MINOR = 5
|
|
.const _64SPEC_VERSION_PATCH = 0
|
|
|
|
.function _64spec_version() {
|
|
.return "" + _64SPEC_VERSION_MAJOR + '.' + _64SPEC_VERSION_MINOR + '.' + _64SPEC_VERSION_PATCH
|
|
}
|
|
|
|
.const _TEXT_COLOR = $0286
|
|
.const _BORDER = $d020
|
|
.const _BACKGROUND = $d021
|
|
.const _CHROUT = $ffd2
|
|
.const _CHKOUT = $FFC9
|
|
.const _PLOT = $fff0
|
|
.const _SETLFS = $FFBA
|
|
.const _OPEN = $FFC0
|
|
.const _CLOSE = $FFC3
|
|
.const _SETNAM = $FFBD
|
|
.const _CLRCHN = $FFCC
|
|
.const _CLRSCR = $e544
|
|
.const _PRINTWORD = $bdcd
|
|
.const _CR=13
|
|
.const _CLS = 147
|
|
.const _UPPERCASE = 142
|
|
.const _LOWERCASE = 14
|
|
|
|
|
|
.struct _64SPEC_CONFIG {
|
|
print_header,
|
|
clear_screen_at_initialization,
|
|
change_character_set,
|
|
on_exit,
|
|
success_color,
|
|
failure_color,
|
|
change_text_color,
|
|
change_text_color_on_final_result,
|
|
change_text_color_on_immediate_result,
|
|
text_color,
|
|
revert_to_initial_text_color,
|
|
change_background_color,
|
|
change_background_color_on_final_result,
|
|
background_color,
|
|
change_border_color,
|
|
border_color,
|
|
change_border_color_on_final_result,
|
|
print_immediate_result,
|
|
immediate_result_success_character,
|
|
immediate_result_failure_character,
|
|
print_final_results,
|
|
write_final_results_to_file,
|
|
result_file_name,
|
|
assertion_passed_subroutine,
|
|
assertion_failed_subroutine,
|
|
result_all_passed_message,
|
|
result_some_passed_message,
|
|
result_all_failed_message,
|
|
print_configuration,
|
|
print_command_line_options,
|
|
print_context_description,
|
|
print_example_description,
|
|
change_context_description_text_color,
|
|
change_example_description_text_color,
|
|
print_context_results,
|
|
print_example_results,
|
|
|
|
_use_custom_result_all_passed_message,
|
|
_use_custom_result_some_passed_message,
|
|
_use_custom_result_all_failed_message,
|
|
_use_custom_assertion_passed_subroutine,
|
|
_use_custom_assertion_failed_subroutine
|
|
}
|
|
|
|
// Default configuration
|
|
.const _64SPEC = _64SPEC_CONFIG()
|
|
.eval config_64spec("print_header", true)
|
|
.eval config_64spec("clear_screen_at_initialization", true)
|
|
.eval config_64spec("change_character_set", "lowercase")
|
|
.eval config_64spec("on_exit", "rts")
|
|
|
|
.eval config_64spec("success_color", GREEN)
|
|
.eval config_64spec("failure_color", RED)
|
|
|
|
.eval config_64spec("change_text_color", true)
|
|
.eval config_64spec("change_text_color_on_immediate_result", true)
|
|
.eval config_64spec("change_text_color_on_final_result", true)
|
|
.eval config_64spec("text_color", DARK_GRAY)
|
|
.eval config_64spec("revert_to_initial_text_color", false)
|
|
|
|
.eval config_64spec("change_background_color", true)
|
|
.eval config_64spec("change_background_color_on_final_result", false)
|
|
.eval config_64spec("background_color", BLACK)
|
|
|
|
.eval config_64spec("change_border_color", true)
|
|
.eval config_64spec("change_border_color_on_final_result", true)
|
|
.eval config_64spec("border_color", BLACK)
|
|
|
|
.eval config_64spec("print_context_description", true)
|
|
.eval config_64spec("print_example_description", true)
|
|
// TODO: Fix color printing when screen scrolls, and change defaults to true.
|
|
.eval config_64spec("change_context_description_text_color", false)
|
|
.eval config_64spec("change_example_description_text_color", false)
|
|
.eval config_64spec("print_context_results", false)
|
|
.eval config_64spec("print_example_results", false)
|
|
|
|
.eval config_64spec("print_immediate_result", true)
|
|
.eval config_64spec("immediate_result_success_character", "default")
|
|
.eval config_64spec("immediate_result_failure_character", "default")
|
|
.eval config_64spec("print_final_results", true)
|
|
.eval config_64spec("write_final_results_to_file", false)
|
|
.eval config_64spec("result_file_name", "result.txt")
|
|
|
|
|
|
.eval config_64spec("print_configuration", false)
|
|
.eval config_64spec("print_command_line_options", false)
|
|
|
|
// Overridable addresses. Set at initialization time.
|
|
.eval config_64spec("assertion_passed_subroutine", "default")
|
|
.eval config_64spec("assertion_failed_subroutine", "default")
|
|
.eval config_64spec("result_all_passed_message", "default")
|
|
.eval config_64spec("result_some_passed_message", "default")
|
|
.eval config_64spec("result_all_failed_message", "default")
|
|
|
|
// Custom memory markers.
|
|
// Some labels cannot be resolved in the first pass and we can't use them in .if statements.
|
|
// Therefore additional boolean variables are used to signify if user customized an address.
|
|
.eval _64SPEC.set("_use_custom_result_all_passed_message", false)
|
|
.eval _64SPEC.set("_use_custom_result_some_passed_message", false)
|
|
.eval _64SPEC.set("_use_custom_result_all_failed_message", false)
|
|
.eval _64SPEC.set("_use_custom_assertion_passed_subroutine", false)
|
|
.eval _64SPEC.set("_use_custom_assertion_failed_subroutine", false)
|
|
|
|
.function config_64spec(key, value) {
|
|
.if (validate_boolean_option("print_header", key, value)) .return
|
|
.if (validate_boolean_option("clear_screen_at_initialization", key, value)) .return
|
|
.if (validate_boolean_option("change_text_color", key, value)) .return
|
|
.if (validate_boolean_option("change_text_color_on_immediate_result", key, value)) .return
|
|
.if (validate_boolean_option("change_text_color_on_final_result", key, value)) .return
|
|
.if (validate_boolean_option("revert_to_initial_text_color", key, value)) .return
|
|
.if (validate_boolean_option("change_background_color", key, value)) .return
|
|
.if (validate_boolean_option("change_background_color_on_final_result", key, value)) .return
|
|
.if (validate_boolean_option("change_border_color", key, value)) .return
|
|
.if (validate_boolean_option("change_border_color_on_final_result", key, value)) .return
|
|
.if (validate_boolean_option("print_immediate_result", key, value)) .return
|
|
.if (validate_boolean_option("print_final_results", key, value)) .return
|
|
.if (validate_boolean_option("write_final_results_to_file", key, value)) .return
|
|
.if (validate_boolean_option("print_configuration", key, value)) .return
|
|
.if (validate_boolean_option("print_command_line_options", key, value)) .return
|
|
.if (validate_boolean_option("print_context_description", key, value)) .return
|
|
.if (validate_boolean_option("print_example_description", key, value)) .return
|
|
.if (validate_boolean_option("change_context_description_text_color", key, value)) .return
|
|
.if (validate_boolean_option("change_example_description_text_color", key, value)) .return
|
|
.if (validate_boolean_option("print_context_results", key, value)) .return
|
|
.if (validate_boolean_option("print_example_results", key, value)) .return
|
|
|
|
.if (validate_color_option("success_color", key, value)) .return
|
|
.if (validate_color_option("failure_color", key, value)) .return
|
|
.if (validate_color_option("text_color", key, value)) .return
|
|
.if (validate_color_option("background_color", key, value)) .return
|
|
.if (validate_color_option("border_color", key, value)) .return
|
|
|
|
.if (validate_character_option("immediate_result_success_character", key, value)) .return
|
|
.if (validate_character_option("immediate_result_failure_character", key, value)) .return
|
|
|
|
.if (validate_non_empty_string_option("result_file_name", key, value)) .return
|
|
|
|
.if (validate_set_option("change_character_set", List().add(
|
|
_64SPEC_SET_OPTION("\"lowercase\"", "lowercase"),
|
|
_64SPEC_SET_OPTION("\"uppercase\"", "uppercase"),
|
|
_64SPEC_SET_OPTION("false", false)
|
|
), key, value)) .return
|
|
|
|
.if (validate_set_option("on_exit", List().add(
|
|
_64SPEC_SET_OPTION("\"rts\"", "rts"),
|
|
_64SPEC_SET_OPTION("\"loop\"", "loop"),
|
|
_64SPEC_SET_OPTION("\"jam\"", "jam")
|
|
), key, value)) .return
|
|
|
|
.if (mark_custom_memory_address_option("assertion_passed_subroutine", key, value)) .return
|
|
.if (mark_custom_memory_address_option("assertion_failed_subroutine", key, value)) .return
|
|
.if (mark_custom_memory_address_option("result_all_passed_message", key, value)) .return
|
|
.if (mark_custom_memory_address_option("result_some_passed_message", key, value)) .return
|
|
.if (mark_custom_memory_address_option("result_all_failed_message", key, value)) .return
|
|
|
|
.error "Unrecognized _64SPEC configuration option - \"" + key + "\""
|
|
}
|
|
.function mark_custom_memory_address_option(expected_key, key, value) {
|
|
.if (key != expected_key) .return false
|
|
|
|
.eval _64SPEC.set("_use_custom_" + expected_key, true)
|
|
.eval _64SPEC.set(key, value)
|
|
.return true
|
|
}
|
|
.function validate_color_option(expected_key, key, value) {
|
|
.if (key != expected_key) .return false
|
|
|
|
.if(value < 0 || value > 15) {
|
|
.error "_64SPEC configuration option - \"" + expected_key + "\" has to be a valid color index in a range [0..15]."
|
|
}
|
|
|
|
.eval _64SPEC.set(key, value)
|
|
.return true
|
|
}
|
|
.function validate_boolean_option(expected_key, key, value) {
|
|
.if (key != expected_key) .return false
|
|
|
|
.if (value != true && value != false) {
|
|
.error "_64SPEC configuration option - \"" + expected_key + "\" has to be either be true or false."
|
|
}
|
|
|
|
.eval _64SPEC.set(key, value)
|
|
.return true
|
|
}
|
|
|
|
.function validate_non_empty_string_option(expected_key, key, value) {
|
|
.if (key != expected_key) .return false
|
|
|
|
.if (value == "") {
|
|
.error "_64SPEC configuration option - \"" + expected_key + "\" cannot be an empty string."
|
|
}
|
|
|
|
.eval _64SPEC.set(key, value)
|
|
.return true
|
|
}
|
|
|
|
.function validate_character_option(expected_key, key, value) {
|
|
.if (key != expected_key) .return false
|
|
|
|
.if (value != "default" && [value < 0 || value > 255]) {
|
|
.error "_64SPEC configuration option - \"" + expected_key + "\" has to be a one byte value representing PETSCII character or \"default\"."
|
|
}
|
|
|
|
.eval _64SPEC.set(key, value)
|
|
.return true
|
|
}
|
|
.struct _64SPEC_SET_OPTION {name, value}
|
|
.function validate_set_option(expected_key, allowed_values, key, value) {
|
|
.if (key != expected_key) .return false
|
|
|
|
.var options_string = ""
|
|
.for (var i = 0; i < allowed_values.size(); i++) {
|
|
.eval options_string += allowed_values.get(i).name
|
|
.if (i < allowed_values.size() - 1) {
|
|
.eval options_string += ", "
|
|
}
|
|
.if (value == allowed_values.get(i).value) {
|
|
.eval _64SPEC.set(key, value)
|
|
.return true
|
|
}
|
|
}
|
|
|
|
.error "_64SPEC configuration option - \"" + expected_key + "\" has to be a one of: " + options_string
|
|
}
|
|
|
|
.macro init_spec() {
|
|
|
|
.if (cmdLineVars.containsKey("on_exit")) {
|
|
.eval _64SPEC.set("on_exit", cmdLineVars.get("on_exit"))
|
|
}
|
|
.if (cmdLineVars.containsKey("write_final_results_to_file")) {
|
|
.eval _64SPEC.set("write_final_results_to_file", cmdLineVars.get("write_final_results_to_file").asBoolean())
|
|
}
|
|
.if (cmdLineVars.containsKey("result_file_name")) {
|
|
.eval _64SPEC.set("result_file_name", cmdLineVars.get("result_file_name"))
|
|
}
|
|
|
|
.if (_64SPEC.immediate_result_failure_character == "default") {
|
|
.eval _64SPEC.set("immediate_result_failure_character", [_64SPEC.change_character_set == "lowercase"] ? _64spec_scr_to_pet('x') : _64spec_scr_to_pet('x'))
|
|
}
|
|
.if (_64SPEC.immediate_result_success_character == "default") {
|
|
.eval _64SPEC.set("immediate_result_success_character", [_64SPEC.change_character_set == "lowercase"] ? _64spec_scr_to_pet('.') : _64spec_scr_to_pet('.'))
|
|
}
|
|
|
|
.if (_64SPEC.print_configuration) {
|
|
.print "64Spec Configuration:"
|
|
.for (var i = 0;i < _64SPEC.getNoOfFields(); i++) {
|
|
.print " " + _64SPEC.getFieldNames().get(i) + " = " +_64SPEC.get(i)
|
|
}
|
|
}
|
|
|
|
.if (_64SPEC.print_command_line_options) {
|
|
.print "Command Line Options:"
|
|
.for (var i = 0;i < cmdLineVars.keys().size(); i++) {
|
|
.var key = cmdLineVars.keys().get(i)
|
|
.print " " + key + " = " + cmdLineVars.get(key)
|
|
}
|
|
}
|
|
|
|
:BasicUpstart2(tests_init)
|
|
|
|
.pc = * "Tests Data"
|
|
_version_major:
|
|
.byte _64SPEC_VERSION_MAJOR
|
|
_version_minor:
|
|
.byte _64SPEC_VERSION_MINOR
|
|
_version_patch:
|
|
.byte _64SPEC_VERSION_PATCH
|
|
_total_assertions_count:
|
|
.word 0
|
|
_passed_assertions_count:
|
|
.word 0
|
|
_final_tests_result:
|
|
.word 0
|
|
_stored_a:
|
|
.byte 0
|
|
_stored_x:
|
|
.byte 0
|
|
_stored_y:
|
|
.byte 0
|
|
_stored_p:
|
|
.byte 0
|
|
_initial_text_color:
|
|
.if (_64SPEC.change_text_color && _64SPEC.revert_to_initial_text_color) {
|
|
.byte 0
|
|
}
|
|
_header:
|
|
.if (_64SPEC.print_header) {
|
|
.var lines = List()
|
|
.if (_64SPEC.change_character_set == "lowercase") {
|
|
.eval lines.add("****** 64spec v" + _64spec_version() + " ******")
|
|
.eval lines.add("Testing Framework by Michal Taszycki")
|
|
.eval lines.add("Docs at http://64bites.com/64spec")
|
|
} else {
|
|
.eval lines.add("****** 64spec v" + _64spec_version() + " ******")
|
|
.eval lines.add("testing framework by michal taszycki")
|
|
.eval lines.add("docs at http://64bites.com/64spec")
|
|
}
|
|
.byte _CR
|
|
.for (var i = 0; i < lines.size(); i++) {
|
|
.fill [40 - lines.get(i).size()] / 2, ' '
|
|
:_64spec_pet_text(lines.get(i))
|
|
.byte _CR
|
|
.byte _CR
|
|
}
|
|
.byte 0
|
|
}
|
|
|
|
.if(!_64SPEC._use_custom_result_all_failed_message) {
|
|
.eval _64SPEC.set("result_all_failed_message", *)
|
|
.if (_64SPEC.change_character_set == "lowercase") {
|
|
:_64spec_pet_text("All Tests FAILED: ")
|
|
} else {
|
|
:_64spec_pet_text("all tests failed: ")
|
|
}
|
|
.byte 0
|
|
}
|
|
.if(!_64SPEC._use_custom_result_some_passed_message) {
|
|
.eval _64SPEC.set("result_some_passed_message", *)
|
|
.if (_64SPEC.change_character_set == "lowercase") {
|
|
:_64spec_pet_text("Some tests PASSED: ")
|
|
} else {
|
|
:_64spec_pet_text("some tests passed: ")
|
|
}
|
|
.byte 0
|
|
}
|
|
.if(!_64SPEC._use_custom_result_all_passed_message) {
|
|
.eval _64SPEC.set("result_all_passed_message", *)
|
|
.if (_64SPEC.change_character_set == "lowercase") {
|
|
:_64spec_pet_text("All tests PASSED: ")
|
|
} else {
|
|
:_64spec_pet_text("all tests passed: ")
|
|
}
|
|
.byte 0
|
|
}
|
|
_last_context:
|
|
.if (_64SPEC.print_context_description) {
|
|
.word 0 // text pointer
|
|
.word 0 // cursor position
|
|
.word 0 // total assertions count
|
|
.word 0 // passed assertions count
|
|
.byte 0 // tests result
|
|
}
|
|
_last_example:
|
|
.if (_64SPEC.print_example_description) {
|
|
.word 0 // text pointer
|
|
.word 0 // cursor position
|
|
.word 0 // total assertions count
|
|
.word 0 // passed assertions count
|
|
.byte 0 // tests result
|
|
}
|
|
_description_data:
|
|
.if (_64SPEC.print_context_description || _64SPEC.print_example_description) {
|
|
.word 0 // cursor position
|
|
.byte 0 // flags - 7 cleared - first context, 6 cleared - first example
|
|
}
|
|
|
|
.pc = * "Tests Subroutines"
|
|
.if(!_64SPEC._use_custom_assertion_passed_subroutine) {
|
|
.eval _64SPEC.set("assertion_passed_subroutine", *)
|
|
:_assertion_passed()
|
|
rts
|
|
}
|
|
.if(!_64SPEC._use_custom_assertion_failed_subroutine) {
|
|
.eval _64SPEC.set("assertion_failed_subroutine", *)
|
|
:_assertion_failed()
|
|
rts
|
|
}
|
|
_print_string:
|
|
:_print_string($ffff)
|
|
rts
|
|
.pc = * "Test Initialization"
|
|
tests_init:
|
|
.if (_64SPEC.clear_screen_at_initialization) {
|
|
:_print_char #_CLS
|
|
}
|
|
.if (_64SPEC.change_character_set != false) {
|
|
:_print_char #[[_64SPEC.change_character_set == "lowercase"] ? _LOWERCASE : _UPPERCASE]
|
|
}
|
|
.if (_64SPEC.change_text_color && _64SPEC.revert_to_initial_text_color) {
|
|
:_64spec_mov _TEXT_COLOR; _initial_text_color
|
|
}
|
|
:_set_text_color #_64SPEC.text_color
|
|
.if (_64SPEC.change_background_color) {
|
|
:_64spec_mov #_64SPEC.background_color; _BACKGROUND
|
|
}
|
|
.if (_64SPEC.change_border_color) {
|
|
:_64spec_mov #_64SPEC.border_color; _BORDER
|
|
}
|
|
.if (_64SPEC.print_header) {
|
|
:_print_string #sfspec._header
|
|
}
|
|
:_reset_tests_result(sfspec._total_assertions_count)
|
|
|
|
.pc = * "Specification"
|
|
specification:
|
|
}
|
|
|
|
.macro finish_spec() {
|
|
.pc = * "Spec Results Rendering"
|
|
:_finalize_last_context()
|
|
:_finalize_last_example()
|
|
:render_results()
|
|
.if (_64SPEC.revert_to_initial_text_color) {
|
|
:_set_text_color sfspec._initial_text_color
|
|
} else {
|
|
:_set_text_color #_64SPEC.text_color
|
|
}
|
|
.if (_64SPEC.on_exit == "rts") {
|
|
rts
|
|
} else .if (_64SPEC.on_exit == "loop") {
|
|
end:
|
|
jmp end
|
|
} else /* jam */ {
|
|
.byte $02
|
|
}
|
|
}
|
|
|
|
.macro _assertion_failed() {
|
|
:_64spec_inc16 sfspec._total_assertions_count
|
|
.if (_64SPEC.print_context_description) {
|
|
:_64spec_inc16 sfspec._last_context + 4
|
|
}
|
|
.if (_64SPEC.print_example_description) {
|
|
:_64spec_inc16 sfspec._last_example + 4
|
|
}
|
|
.if (_64SPEC.print_immediate_result) {
|
|
.if (_64SPEC.change_text_color_on_immediate_result) {
|
|
:_set_text_color #_64SPEC.failure_color
|
|
}
|
|
:_print_char #_64SPEC.immediate_result_failure_character
|
|
}
|
|
}
|
|
|
|
.macro _assertion_passed() {
|
|
:_64spec_inc16 sfspec._passed_assertions_count
|
|
:_64spec_inc16 sfspec._total_assertions_count
|
|
.if (_64SPEC.print_context_description) {
|
|
:_64spec_inc16 sfspec._last_context + 4
|
|
:_64spec_inc16 sfspec._last_context + 6
|
|
}
|
|
.if (_64SPEC.print_example_description) {
|
|
:_64spec_inc16 sfspec._last_example + 4
|
|
:_64spec_inc16 sfspec._last_example + 6
|
|
}
|
|
.if (_64SPEC.print_immediate_result) {
|
|
.if (_64SPEC.change_text_color_on_immediate_result) {
|
|
:_set_text_color #_64SPEC.success_color
|
|
}
|
|
:_print_char #_64SPEC.immediate_result_success_character
|
|
}
|
|
}
|
|
.macro _reset_tests_result(base_address) {
|
|
.var total_assertions_count = base_address
|
|
.var passed_assertions_count = base_address + 2
|
|
:_64spec_mov16 #$0000; total_assertions_count
|
|
:_64spec_mov16 #$0000; passed_assertions_count
|
|
}
|
|
.macro _calculate_tests_result(base_address) {
|
|
.var total_assertions_count = base_address
|
|
.var passed_assertions_count = base_address + 2
|
|
.var final_tests_result = base_address + 4
|
|
|
|
lda total_assertions_count
|
|
cmp passed_assertions_count
|
|
bne !fail+
|
|
lda total_assertions_count + 1
|
|
cmp passed_assertions_count + 1
|
|
bne !fail+
|
|
!pass:
|
|
// We are "overflowing" with success
|
|
lda #%01000000
|
|
sta final_tests_result
|
|
jmp !end+
|
|
!fail:
|
|
lda passed_assertions_count
|
|
bne !incomplete_fail+
|
|
lda passed_assertions_count + 1
|
|
bne !incomplete_fail+
|
|
!complete_fail:
|
|
// We are "not overflowing" with success
|
|
lda #%00000000
|
|
sta final_tests_result
|
|
jmp !end+
|
|
!incomplete_fail:
|
|
// This is "MInor" failure
|
|
lda #%10000000
|
|
sta final_tests_result
|
|
!end:
|
|
}
|
|
|
|
.macro render_results() {
|
|
:_calculate_tests_result(sfspec._total_assertions_count)
|
|
:_set_screen_colors()
|
|
:_change_text_color_on_final_result()
|
|
.if (_64SPEC.print_final_results) {
|
|
:_print_final_results()
|
|
}
|
|
.if (_64SPEC.write_final_results_to_file) {
|
|
:_write_final_results_to_file()
|
|
}
|
|
}
|
|
|
|
.macro _write_final_results_to_file() {
|
|
:_64spec_open_file_for_writing(_64SPEC.result_file_name, 13)
|
|
:_64spec_set_file_output(13)
|
|
:_print_final_results()
|
|
:_64spec_close_file(13)
|
|
:_64spec_set_screen_output()
|
|
}
|
|
|
|
.macro _change_text_color_on_final_result() {
|
|
.if (_64SPEC.change_text_color_on_final_result) {
|
|
bit sfspec._final_tests_result
|
|
bvs success
|
|
failure:
|
|
:_set_text_color #_64SPEC.failure_color
|
|
jmp end
|
|
success:
|
|
:_set_text_color #_64SPEC.success_color
|
|
end:
|
|
} else {
|
|
:_set_text_color #_64SPEC.text_color
|
|
}
|
|
}
|
|
|
|
.macro _set_screen_colors() {
|
|
.if ([_64SPEC.change_border_color && _64SPEC.change_border_color_on_final_result] || [_64SPEC.change_background_color && _64SPEC.change_background_color_on_final_result]) {
|
|
bit sfspec._final_tests_result
|
|
bvs success
|
|
failure:
|
|
lda #_64SPEC.failure_color
|
|
jmp end
|
|
success:
|
|
lda #_64SPEC.success_color
|
|
end:
|
|
.if (_64SPEC.change_border_color && _64SPEC.change_border_color_on_final_result) {
|
|
sta _BORDER
|
|
}
|
|
.if (_64SPEC.change_background_color && _64SPEC.change_background_color_on_final_result) {
|
|
sta _BACKGROUND
|
|
}
|
|
}
|
|
}
|
|
|
|
.macro _print_result_numbers(base_address) {
|
|
.var total_assertions_count = base_address
|
|
.var passed_assertions_count = base_address + 2
|
|
:_print_char #'('
|
|
:_print_int16 passed_assertions_count
|
|
:_print_char #'/'
|
|
:_print_int16 total_assertions_count
|
|
:_print_char #')'
|
|
:_print_char #_CR
|
|
}
|
|
|
|
.macro _print_final_results() {
|
|
:_print_char #_CR
|
|
bit sfspec._final_tests_result
|
|
bvs success
|
|
bmi partial_failure
|
|
failure:
|
|
:_print_string #_64SPEC.result_all_failed_message
|
|
jmp end
|
|
partial_failure:
|
|
:_print_string #_64SPEC.result_some_passed_message
|
|
jmp end
|
|
success:
|
|
:_print_string #_64SPEC.result_all_passed_message
|
|
end:
|
|
:_print_result_numbers(sfspec._total_assertions_count)
|
|
}
|
|
|
|
// Assertions
|
|
.pseudocommand assert_i_cleared pass_subroutine; fail_subroutine {
|
|
:assert_i_set _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine); _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine)
|
|
}
|
|
|
|
.pseudocommand assert_i_set pass_subroutine; fail_subroutine {
|
|
:assert_p_has_masked_bits_set #%00000100; _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine); _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine)
|
|
}
|
|
|
|
.pseudocommand assert_d_cleared pass_subroutine; fail_subroutine {
|
|
:assert_d_set _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine); _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine)
|
|
}
|
|
|
|
.pseudocommand assert_d_set pass_subroutine; fail_subroutine {
|
|
:assert_p_has_masked_bits_set #%00001000; _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine); _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine)
|
|
}
|
|
|
|
.pseudocommand assert_p_has_masked_bits_cleared mask; pass_subroutine; fail_subroutine {
|
|
:assert_masked_bits_cleared sfspec._stored_p; mask; pass_subroutine; fail_subroutine
|
|
}
|
|
.pseudocommand assert_p_has_masked_bits_set mask; pass_subroutine; fail_subroutine {
|
|
:assert_masked_bits_set sfspec._stored_p; mask; pass_subroutine; fail_subroutine
|
|
}
|
|
.pseudocommand assert_masked_bits_cleared actual; mask; pass_subroutine; fail_subroutine {
|
|
:_store_state()
|
|
lda actual
|
|
eor $ff
|
|
and mask
|
|
bne pass_or_fail.fail
|
|
pass_or_fail: :_pass_or_fail pass_subroutine; fail_subroutine
|
|
:_restore_state()
|
|
}
|
|
.pseudocommand assert_masked_bits_set actual; mask; pass_subroutine; fail_subroutine {
|
|
:_store_state()
|
|
lda actual
|
|
and mask
|
|
cmp mask
|
|
bne pass_or_fail.fail
|
|
pass_or_fail: :_pass_or_fail pass_subroutine; fail_subroutine
|
|
:_restore_state()
|
|
}
|
|
.pseudocommand assert_p_equal expected; pass_subroutine; fail_subroutine {
|
|
:assert_equal sfspec._stored_p; expected; pass_subroutine; fail_subroutine
|
|
}
|
|
|
|
.pseudocommand assert_v_cleared pass_subroutine; fail_subroutine {
|
|
:assert_v_set _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine); _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine)
|
|
}
|
|
|
|
.pseudocommand assert_v_set pass_subroutine; fail_subroutine {
|
|
:assert_p_has_masked_bits_set #%01000000; pass_subroutine; fail_subroutine
|
|
}
|
|
|
|
.pseudocommand assert_n_cleared pass_subroutine; fail_subroutine {
|
|
:assert_n_set _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine); _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine)
|
|
}
|
|
|
|
.pseudocommand assert_n_set pass_subroutine; fail_subroutine {
|
|
|
|
:assert_p_has_masked_bits_set #%10000000; pass_subroutine; fail_subroutine
|
|
}
|
|
.pseudocommand assert_c_cleared pass_subroutine; fail_subroutine {
|
|
:assert_c_set _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine); _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine)
|
|
}
|
|
|
|
.pseudocommand assert_c_set pass_subroutine; fail_subroutine {
|
|
:assert_p_has_masked_bits_set #%00000001; pass_subroutine; fail_subroutine
|
|
}
|
|
|
|
.pseudocommand assert_z_cleared pass_subroutine; fail_subroutine {
|
|
:assert_z_set _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine); _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine)
|
|
}
|
|
|
|
.pseudocommand assert_z_set pass_subroutine; fail_subroutine {
|
|
:assert_p_has_masked_bits_set #%00000010; pass_subroutine; fail_subroutine
|
|
}
|
|
|
|
.pseudocommand assert_y_not_zero pass_subroutine; fail_subroutine {
|
|
:assert_y_zero _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine); _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine)
|
|
}
|
|
|
|
.pseudocommand assert_y_zero pass_subroutine; fail_subroutine {
|
|
:assert_y_equal #0; pass_subroutine; fail_subroutine
|
|
}
|
|
|
|
.pseudocommand assert_y_not_equal expected; pass_subroutine; fail_subroutine {
|
|
:assert_y_equal expected; _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine); _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine)
|
|
}
|
|
|
|
.pseudocommand assert_y_equal expected; pass_subroutine; fail_subroutine {
|
|
:assert_equal sfspec._stored_y; expected; pass_subroutine; fail_subroutine
|
|
}
|
|
|
|
.pseudocommand assert_x_not_zero pass_subroutine; fail_subroutine {
|
|
:assert_x_zero _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine); _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine)
|
|
}
|
|
|
|
.pseudocommand assert_x_zero pass_subroutine; fail_subroutine {
|
|
:assert_x_equal #0; pass_subroutine; fail_subroutine
|
|
}
|
|
|
|
.pseudocommand assert_x_not_equal expected; pass_subroutine; fail_subroutine {
|
|
:assert_x_equal expected; _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine); _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine)
|
|
}
|
|
.pseudocommand assert_x_equal expected; pass_subroutine; fail_subroutine {
|
|
:assert_equal sfspec._stored_x; expected; pass_subroutine; fail_subroutine
|
|
}
|
|
|
|
.pseudocommand assert_a_not_zero pass_subroutine; fail_subroutine {
|
|
:assert_a_zero _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine); _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine)
|
|
}
|
|
|
|
.pseudocommand assert_a_zero pass_subroutine; fail_subroutine {
|
|
:assert_a_equal #0; pass_subroutine; fail_subroutine
|
|
}
|
|
|
|
.pseudocommand assert_a_not_equal expected; pass_subroutine; fail_subroutine {
|
|
:assert_a_equal expected; _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine); _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine)
|
|
}
|
|
|
|
.pseudocommand assert_a_equal expected; pass_subroutine; fail_subroutine {
|
|
:assert_equal sfspec._stored_a; expected; pass_subroutine; fail_subroutine
|
|
}
|
|
|
|
.pseudocommand assert_not_equal actual; expected; pass_subroutine; fail_subroutine {
|
|
:assert_equal actual; expected;_given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine); _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine)
|
|
}
|
|
.pseudocommand assert_not_equal16 actual; expected; pass_subroutine; fail_subroutine {
|
|
:assert_equal16 actual; expected; _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine); _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine)
|
|
}
|
|
.pseudocommand assert_not_equal24 actual; expected; pass_subroutine; fail_subroutine {
|
|
:assert_equal24 actual; expected; _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine); _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine)
|
|
}
|
|
.pseudocommand assert_not_equal32 actual; expected; pass_subroutine; fail_subroutine {
|
|
:assert_equal32 actual; expected; _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine); _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine)
|
|
}
|
|
|
|
.macro assert_bytes_not_equal(bytes_count, actual, expected, pass_subroutine, fail_subroutine) {
|
|
:assert_bytes_equal(bytes_count, actual, expected, _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine), _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine))
|
|
}
|
|
.pseudocommand assert_bytes_not_equal bytes_count; actual; expected; pass_subroutine; fail_subroutine {
|
|
:assert_bytes_equal bytes_count; actual; expected; _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine); _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine)
|
|
}
|
|
|
|
.pseudocommand assert_equal actual; expected; pass_subroutine; fail_subroutine {
|
|
:_assert_equal _bits_to_bytes(8); actual; expected; pass_subroutine; fail_subroutine
|
|
}
|
|
.pseudocommand assert_equal16 actual; expected; pass_subroutine; fail_subroutine {
|
|
:_assert_equal _bits_to_bytes(16); actual; expected; pass_subroutine; fail_subroutine
|
|
}
|
|
.pseudocommand assert_equal24 actual; expected; pass_subroutine; fail_subroutine {
|
|
:_assert_equal _bits_to_bytes(24); actual; expected; pass_subroutine; fail_subroutine
|
|
}
|
|
.pseudocommand assert_equal32 actual; expected; pass_subroutine; fail_subroutine {
|
|
:_assert_equal _bits_to_bytes(32); actual; expected; pass_subroutine; fail_subroutine
|
|
}
|
|
|
|
|
|
.pseudocommand _assert_equal bytes_count; actual; expected; pass_subroutine; fail_subroutine {
|
|
:_store_state()
|
|
.for (var byte_id = 0; byte_id < bytes_count.getValue(); byte_id++) {
|
|
lda _64spec_extract_byte_argument(actual, byte_id)
|
|
cmp _64spec_extract_byte_argument(expected, byte_id)
|
|
bne pass_or_fail.fail
|
|
}
|
|
pass_or_fail: :_pass_or_fail pass_subroutine; fail_subroutine
|
|
:_restore_state()
|
|
}
|
|
|
|
.pseudocommand assert_unsigned_greater_or_equal actual; expected; pass_subroutine; fail_subroutine {
|
|
:assert_unsigned_less actual; expected; _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine); _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine)
|
|
}
|
|
|
|
.pseudocommand assert_unsigned_less actual; expected; pass_subroutine; fail_subroutine {
|
|
:_store_state()
|
|
lda actual
|
|
cmp expected
|
|
bcs pass_or_fail.fail
|
|
pass_or_fail: :_pass_or_fail pass_subroutine; fail_subroutine
|
|
:_restore_state()
|
|
}
|
|
|
|
.pseudocommand assert_unsigned_less_or_equal actual; expected; pass_subroutine; fail_subroutine {
|
|
:assert_unsigned_greater actual; expected; _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine); _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine)
|
|
}
|
|
|
|
.pseudocommand assert_unsigned_greater actual; expected; pass_subroutine; fail_subroutine {
|
|
:_store_state()
|
|
lda actual
|
|
cmp expected
|
|
bcc pass_or_fail.fail
|
|
beq pass_or_fail.fail
|
|
pass_or_fail: :_pass_or_fail pass_subroutine; fail_subroutine
|
|
:_restore_state()
|
|
}
|
|
|
|
.macro _store_state() {
|
|
php
|
|
sta sfspec._stored_a
|
|
stx sfspec._stored_x
|
|
sty sfspec._stored_y
|
|
pla
|
|
sta sfspec._stored_p
|
|
}
|
|
|
|
.macro _restore_state() {
|
|
lda sfspec._stored_p
|
|
pha
|
|
ldy sfspec._stored_y
|
|
ldx sfspec._stored_x
|
|
lda sfspec._stored_a
|
|
plp // restore p
|
|
}
|
|
|
|
.pseudocommand assert_bytes_equal bytes_count; actual; expected; pass_subroutine; fail_subroutine {
|
|
// TODO: remove pages and remainder branches
|
|
.var remainder = mod(bytes_count.getValue(), 256)
|
|
.var offset = bytes_count.getValue() - remainder
|
|
.var pages = offset / 256
|
|
ldy #pages
|
|
beq !end+
|
|
loopy:
|
|
ldx #0
|
|
loopx:
|
|
.label actual_hi = * + 2
|
|
lda actual.getValue(), X
|
|
.label expected_hi = * + 2
|
|
cmp expected.getValue(), X
|
|
bne pass_or_fail.fail
|
|
inx
|
|
bne loopx
|
|
inc actual_hi
|
|
inc expected_hi
|
|
dey
|
|
bne loopy
|
|
!end:
|
|
ldy #remainder
|
|
beq !end+
|
|
ldx #0
|
|
loop:
|
|
lda offset + actual.getValue(), X
|
|
cmp offset + expected.getValue(), X
|
|
bne pass_or_fail.fail
|
|
inx
|
|
cpx #remainder
|
|
bne loop
|
|
!end:
|
|
pass_or_fail: :_pass_or_fail pass_subroutine; fail_subroutine
|
|
}
|
|
.pseudocommand assert_pass pass_subroutine; fail_subroutine {
|
|
:_store_state()
|
|
jsr _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine)
|
|
:_restore_state()
|
|
}
|
|
|
|
.pseudocommand assert_fail pass_subroutine; fail_subroutine {
|
|
:_store_state()
|
|
jsr _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine)
|
|
:_restore_state()
|
|
}
|
|
|
|
.pseudocommand _pass_or_fail pass_subroutine; fail_subroutine {
|
|
pass:
|
|
jsr _given_or_default(pass_subroutine, _64SPEC.assertion_passed_subroutine)
|
|
jmp end
|
|
fail:
|
|
jsr _given_or_default(fail_subroutine, _64SPEC.assertion_failed_subroutine)
|
|
end:
|
|
}
|
|
|
|
.macro describe(subject) {
|
|
.if (_64SPEC.print_context_description) {
|
|
jmp end_text
|
|
text:
|
|
.if (_64SPEC.print_immediate_result || _64SPEC.print_example_description) {
|
|
.byte _CR
|
|
}
|
|
:_64spec_pet_text(subject)
|
|
.byte ' '
|
|
.byte 0
|
|
scoring:
|
|
.text " "
|
|
.byte _CR
|
|
.byte 0
|
|
end_text:
|
|
:_finalize_last_context()
|
|
:_finalize_last_example()
|
|
lda sfspec._description_data + 2
|
|
ora #%10000000
|
|
sta sfspec._description_data + 2
|
|
:_64spec_mov16 #text; sfspec._last_context
|
|
:_64spec_kernal_plot_get sfspec._last_context + 2; sfspec._last_context + 3
|
|
:_set_text_color #_64SPEC.text_color
|
|
:_print_string #text
|
|
:_print_string #scoring
|
|
}
|
|
}
|
|
|
|
.macro _finalize_last_context() {
|
|
.if (_64SPEC.print_context_description ) {
|
|
.if (_64SPEC.change_context_description_text_color) {
|
|
:_calculate_tests_result(sfspec._last_context + 4)
|
|
|
|
bit sfspec._last_context + 8
|
|
bvs pass
|
|
fail:
|
|
:_set_text_color #_64SPEC.failure_color
|
|
jmp end_color
|
|
pass:
|
|
:_set_text_color #_64SPEC.success_color
|
|
end_color:
|
|
}
|
|
.if (_64SPEC.change_context_description_text_color || _64SPEC.print_context_results) {
|
|
bit sfspec._description_data + 2
|
|
bvc end
|
|
:_64spec_kernal_plot_get sfspec._description_data; sfspec._description_data + 1
|
|
:_64spec_kernal_plot_set sfspec._last_context + 2; sfspec._last_context + 3
|
|
:_print_string sfspec._last_context
|
|
:_print_result_numbers(sfspec._last_context + 4)
|
|
|
|
:_64spec_kernal_plot_set sfspec._description_data; sfspec._description_data + 1
|
|
:_reset_tests_result(sfspec._last_context + 4)
|
|
end:
|
|
}
|
|
}
|
|
}
|
|
|
|
.macro it(description) {
|
|
.if (_64SPEC.print_example_description) {
|
|
jmp end_text
|
|
text:
|
|
.if (_64SPEC.print_immediate_result) {
|
|
.byte _CR
|
|
}
|
|
.byte ' '
|
|
:_64spec_pet_text(description)
|
|
.byte ' '
|
|
.byte 0
|
|
scoring:
|
|
.text " "
|
|
.byte _CR
|
|
.byte 0
|
|
end_text:
|
|
:_finalize_last_example()
|
|
lda sfspec._description_data + 2
|
|
ora #%01000000
|
|
sta sfspec._description_data + 2
|
|
:_64spec_mov16 #text; sfspec._last_example
|
|
:_64spec_kernal_plot_get sfspec._last_example + 2; sfspec._last_example + 3
|
|
:_set_text_color #_64SPEC.text_color
|
|
:_print_string #text
|
|
:_print_string #scoring
|
|
}
|
|
}
|
|
|
|
.macro _finalize_last_example() {
|
|
.if (_64SPEC.print_example_description) {
|
|
.if (_64SPEC.change_example_description_text_color) {
|
|
:_calculate_tests_result(sfspec._last_example + 4)
|
|
bit sfspec._last_example + 8
|
|
bvs pass
|
|
fail:
|
|
:_set_text_color #_64SPEC.failure_color
|
|
jmp end_color
|
|
pass:
|
|
:_set_text_color #_64SPEC.success_color
|
|
end_color:
|
|
}
|
|
.if (_64SPEC.change_example_description_text_color || _64SPEC.print_example_results) {
|
|
bit sfspec._description_data + 2
|
|
bvc end
|
|
:_64spec_kernal_plot_get sfspec._description_data; sfspec._description_data + 1
|
|
:_64spec_kernal_plot_set sfspec._last_example + 2; sfspec._last_example + 3
|
|
:_print_string sfspec._last_example
|
|
:_print_result_numbers(sfspec._last_example + 4)
|
|
:_64spec_kernal_plot_set sfspec._description_data; sfspec._description_data + 1
|
|
:_reset_tests_result(sfspec._last_example + 4)
|
|
end:
|
|
}
|
|
}
|
|
}
|
|
|
|
// helper functions
|
|
|
|
.function _given_or_default(given, default) {
|
|
.if (given.getType() == AT_NONE) {
|
|
.return CmdArgument(AT_ABSOLUTE, default)
|
|
} else {
|
|
.return given
|
|
}
|
|
}
|
|
.function _64spec_extract_byte_argument(arg, byte_id) {
|
|
.if (arg.getType()==AT_IMMEDIATE) {
|
|
.return CmdArgument(arg.getType(), _extract_byte(arg.getValue(), byte_id))
|
|
} else {
|
|
.return CmdArgument(arg.getType(), arg.getValue() + byte_id)
|
|
}
|
|
}
|
|
|
|
.function _extract_byte(value, byte_id) {
|
|
.var bits = _bytes_to_bits(byte_id)
|
|
.eval value = value >> bits
|
|
.return value & $ff
|
|
}
|
|
.function _bytes_to_bits(bytes) {
|
|
.return bytes * 8
|
|
}
|
|
|
|
.function _bits_to_bytes(bits) {
|
|
.return bits / 8
|
|
}
|
|
|
|
.pseudocommand _print_string string {
|
|
:_64spec_mov16 string; sfspec._print_string.string_address
|
|
jsr sfspec._print_string
|
|
}
|
|
.macro _print_string(string) {
|
|
ldy #0
|
|
loop:
|
|
.label string_address = * + 1
|
|
lda string, Y
|
|
beq end
|
|
jsr _CHROUT
|
|
iny
|
|
jmp loop
|
|
end:
|
|
}
|
|
|
|
.pseudocommand _print_char char {
|
|
lda char
|
|
jsr _CHROUT
|
|
}
|
|
|
|
.pseudocommand _print_int8 value {
|
|
ldx value
|
|
lda #0
|
|
jsr _PRINTWORD
|
|
}
|
|
|
|
.pseudocommand _print_int16 value {
|
|
ldx _64spec_extract_byte_argument(value, 0)
|
|
lda _64spec_extract_byte_argument(value, 1)
|
|
jsr _PRINTWORD
|
|
}
|
|
|
|
|
|
.pseudocommand _set_text_color color {
|
|
.if (_64SPEC.change_text_color) {
|
|
:_64spec_mov color; _TEXT_COLOR
|
|
}
|
|
}
|
|
|
|
.pseudocommand _64spec_mov source; destination {
|
|
:_64spec__mov _bits_to_bytes(8); source; destination
|
|
}
|
|
|
|
.pseudocommand _64spec_mov16 source; destination {
|
|
:_64spec__mov _bits_to_bytes(16); source; destination
|
|
}
|
|
|
|
.pseudocommand _64spec__mov bytes_count; source; destination {
|
|
.for (var i = 0; i < bytes_count.getValue(); i++) {
|
|
lda _64spec_extract_byte_argument(source, i)
|
|
sta _64spec_extract_byte_argument(destination, i)
|
|
}
|
|
}
|
|
|
|
.pseudocommand _64spec_inc16 arg {
|
|
:_64spec__inc _bits_to_bytes(16); arg
|
|
}
|
|
|
|
.pseudocommand _64spec__inc bytes;arg {
|
|
.for (var byte_id = 0;byte_id < bytes.getValue(); byte_id++) {
|
|
inc _64spec_extract_byte_argument(arg, byte_id)
|
|
bne end
|
|
}
|
|
end:
|
|
}
|
|
.macro _64spec_pet_text(string) {
|
|
.fill string.size(), _64spec_scr_to_pet(string.charAt(i))
|
|
}
|
|
|
|
.function _64spec_scr_to_pet(screencode) {
|
|
.var result = screencode
|
|
.if (screencode < 32) {
|
|
.return result + 64
|
|
}
|
|
.if (screencode < 64) {
|
|
.return result
|
|
}
|
|
.if (screencode < 95) {
|
|
.return result + 128
|
|
}
|
|
.if (screencode == 95) { // underscore
|
|
.return 164
|
|
}
|
|
.if (screencode < 128) {
|
|
.return result + 64
|
|
}
|
|
.if (screencode < 160) {
|
|
.return result - 128
|
|
}
|
|
.if (screencode < 224) {
|
|
.return result - 64
|
|
}
|
|
.return result
|
|
}
|
|
|
|
.macro _64spec_open_file_for_writing(string, logical_file_number) {
|
|
jmp end_filename
|
|
filename:
|
|
:_64spec_pet_text(string)
|
|
:_64spec_pet_text(",p,w")
|
|
end_filename:
|
|
|
|
:_64spec_kernal_setnam #[end_filename - filename]; #filename
|
|
:_64spec_kernal_setlfs #logical_file_number; #8; #2
|
|
:_64spec_kernal_open
|
|
}
|
|
|
|
.macro _64spec_close_file(logical_file_number) {
|
|
lda #logical_file_number
|
|
jsr _CLOSE
|
|
}
|
|
|
|
.macro _64spec_set_file_output(logical_file_number) {
|
|
ldx #logical_file_number
|
|
jsr _CHKOUT
|
|
}
|
|
|
|
.macro _64spec_set_screen_output() {
|
|
jsr _CLRCHN
|
|
}
|
|
|
|
|
|
.pseudocommand _64spec_kernal_setnam length; string_address {
|
|
lda length
|
|
ldx _64spec_extract_byte_argument(string_address, 0)
|
|
ldy _64spec_extract_byte_argument(string_address, 1)
|
|
jsr _SETNAM
|
|
}
|
|
.pseudocommand _64spec_kernal_setlfs logical_file_number; device_number; command {
|
|
lda logical_file_number
|
|
ldx device_number
|
|
ldy command
|
|
jsr _SETLFS
|
|
}
|
|
|
|
|
|
.pseudocommand _64spec_kernal_open {
|
|
jsr _OPEN
|
|
}
|
|
|
|
.pseudocommand _64spec_kernal_plot_get column; row {
|
|
sec
|
|
jsr _PLOT
|
|
.if (column.getType() != AT_NONE) {
|
|
stx row
|
|
}
|
|
.if (row.getType() != AT_NONE) {
|
|
sty column
|
|
}
|
|
}
|
|
.pseudocommand _64spec_kernal_plot_set column; row {
|
|
clc
|
|
ldx row
|
|
ldy column
|
|
jsr _PLOT
|
|
}
|