diff --git a/ports/stm32f4xx/ubasic-port.c b/ports/stm32f4xx/ubasic-port.c index 11b9315b..4b859a74 100644 --- a/ports/stm32f4xx/ubasic-port.c +++ b/ports/stm32f4xx/ubasic-port.c @@ -29,7 +29,7 @@ #include "bacnet/wp.h" #include "led.h" -#if defined(UBASIC_SCRIPT_PRINT_TO_SERIAL) +#if defined(UBASIC_SCRIPT_HAVE_PRINT_TO_SERIAL) /** * @brief Write a buffer to the serial port * @param msg Pointer to the buffer to write @@ -444,7 +444,7 @@ static void bacnet_write_property( uint16_t object_type, uint32_t instance, uint32_t property_id, - VARIABLE_TYPE value) + UBASIC_VARIABLE_TYPE value) { BACNET_BINARY_PV value_binary = BINARY_INACTIVE; @@ -522,10 +522,10 @@ static void bacnet_write_property( * @param property_id Property ID * @return Property value */ -static VARIABLE_TYPE bacnet_read_property( +static UBASIC_VARIABLE_TYPE bacnet_read_property( uint16_t object_type, uint32_t instance, uint32_t property_id) { - VARIABLE_TYPE value = 0; + UBASIC_VARIABLE_TYPE value = 0; float value_float = 0.0; BACNET_BINARY_PV value_binary = BINARY_INACTIVE; @@ -630,7 +630,7 @@ void ubasic_port_init(struct ubasic_data *data) #if defined(UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR) data->random_uint32 = random_uint32; #endif -#if defined(UBASIC_SCRIPT_PRINT_TO_SERIAL) +#if defined(UBASIC_SCRIPT_HAVE_PRINT_TO_SERIAL) data->serial_write = serial_write; #endif #if defined(UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL) diff --git a/src/bacnet/basic/client/bac-data.h b/src/bacnet/basic/client/bac-data.h index 4359b620..300ba07f 100644 --- a/src/bacnet/basic/client/bac-data.h +++ b/src/bacnet/basic/client/bac-data.h @@ -26,28 +26,37 @@ struct bacnet_status_flags_t { extern "C" { #endif /* __cplusplus */ +BACNET_STACK_EXPORT void bacnet_data_init(void); +BACNET_STACK_EXPORT void bacnet_data_task(void); +BACNET_STACK_EXPORT void bacnet_data_poll_seconds_set(unsigned int seconds); +BACNET_STACK_EXPORT unsigned int bacnet_data_poll_seconds(void); +BACNET_STACK_EXPORT void bacnet_data_value_save( uint32_t device_instance, BACNET_READ_PROPERTY_DATA *rp_data, BACNET_APPLICATION_DATA_VALUE *value); +BACNET_STACK_EXPORT bool bacnet_data_object_add( uint32_t device_id, BACNET_OBJECT_TYPE object_type, uint32_t object_instance); +BACNET_STACK_EXPORT bool bacnet_data_analog_present_value( uint32_t device_id, BACNET_OBJECT_TYPE object_type, uint32_t object_instance, float *float_value); +BACNET_STACK_EXPORT bool bacnet_data_multistate_present_value( uint32_t device_id, uint16_t object_type, uint32_t object_instance, uint32_t *unsigned_value); +BACNET_STACK_EXPORT bool bacnet_data_binary_present_value( uint32_t device_id, uint16_t object_type, diff --git a/src/bacnet/basic/client/bac-discover.h b/src/bacnet/basic/client/bac-discover.h index c0e76fe8..808d1b88 100644 --- a/src/bacnet/basic/client/bac-discover.h +++ b/src/bacnet/basic/client/bac-discover.h @@ -40,30 +40,42 @@ typedef bool (*bacnet_discover_device_callback)( extern "C" { #endif /* __cplusplus */ +BACNET_STACK_EXPORT void bacnet_discover_cleanup(void); + +BACNET_STACK_EXPORT int bacnet_discover_device_count(void); +BACNET_STACK_EXPORT uint32_t bacnet_discover_device_instance(unsigned index); +BACNET_STACK_EXPORT int bacnet_discover_device_object_count(uint32_t device_id); +BACNET_STACK_EXPORT bool bacnet_discover_device_object_identifier( uint32_t device_id, unsigned index, BACNET_OBJECT_ID *object_id); +BACNET_STACK_EXPORT unsigned long bacnet_discover_device_elapsed_milliseconds(uint32_t device_id); +BACNET_STACK_EXPORT size_t bacnet_discover_device_memory(uint32_t device_id); +BACNET_STACK_EXPORT unsigned int bacnet_discover_object_property_count( uint32_t device_id, BACNET_OBJECT_TYPE object_type, uint32_t object_instance); +BACNET_STACK_EXPORT bool bacnet_discover_object_property_identifier( uint32_t device_id, BACNET_OBJECT_TYPE object_type, uint32_t object_instance, unsigned index, uint32_t *property_id); +BACNET_STACK_EXPORT bool bacnet_discover_property_value( uint32_t device_id, BACNET_OBJECT_TYPE object_type, uint32_t object_instance, BACNET_PROPERTY_ID object_property, BACNET_APPLICATION_DATA_VALUE *value); +BACNET_STACK_EXPORT bool bacnet_discover_property_name( uint32_t device_id, BACNET_OBJECT_TYPE object_type, @@ -72,34 +84,59 @@ bool bacnet_discover_property_name( char *buffer, size_t buffer_len, const char *default_string); + +BACNET_STACK_EXPORT bool bacnet_discover_device_object_property_iterate( uint32_t device_id, BACNET_OBJECT_TYPE object_type, uint32_t object_instance, bacnet_discover_device_callback callback, void *context); +BACNET_STACK_EXPORT bool bacnet_discover_device_object_iterate( uint32_t device_id, bacnet_discover_device_callback callback, void *context); +BACNET_STACK_EXPORT bool bacnet_discover_device_iterate( bacnet_discover_device_callback callback, void *context); + +BACNET_STACK_EXPORT void bacnet_discover_task(void); + +BACNET_STACK_EXPORT void bacnet_discover_dnet_set(uint16_t dnet); +BACNET_STACK_EXPORT uint16_t bacnet_discover_dnet(void); -void bacnet_discover_dest_set(const BACNET_ADDRESS *dest); -const BACNET_ADDRESS *bacnet_discover_dest(void); + +BACNET_STACK_EXPORT void bacnet_discover_vendor_id_set(uint16_t vendor_id); +BACNET_STACK_EXPORT uint16_t bacnet_discover_vendor_id(void); + +BACNET_STACK_EXPORT +void bacnet_discover_dest_set(const BACNET_ADDRESS *dest); +BACNET_STACK_EXPORT +const BACNET_ADDRESS *bacnet_discover_dest(void); + +BACNET_STACK_EXPORT void bacnet_discover_seconds_set(unsigned int seconds); +BACNET_STACK_EXPORT unsigned int bacnet_discover_seconds(void); + +BACNET_STACK_EXPORT void bacnet_discover_read_process_milliseconds_set(unsigned long milliseconds); +BACNET_STACK_EXPORT unsigned long bacnet_discover_read_process_milliseconds(void); + +BACNET_STACK_EXPORT void bacnet_discover_device_add( uint32_t device_instance, unsigned max_apdu, int segmentation, uint16_t vendor_id); + +BACNET_STACK_EXPORT void bacnet_discover_init(void); #ifdef __cplusplus diff --git a/src/bacnet/basic/client/bac-rw.h b/src/bacnet/basic/client/bac-rw.h index 6baeca98..da0f299c 100644 --- a/src/bacnet/basic/client/bac-rw.h +++ b/src/bacnet/basic/client/bac-rw.h @@ -46,16 +46,22 @@ typedef void (*bacnet_read_write_device_callback_t)( extern "C" { #endif /* __cplusplus */ +BACNET_STACK_EXPORT void bacnet_read_write_init(void); +BACNET_STACK_EXPORT void bacnet_read_write_task(void); +BACNET_STACK_EXPORT bool bacnet_read_write_idle(void); +BACNET_STACK_EXPORT bool bacnet_read_write_busy(void); +BACNET_STACK_EXPORT bool bacnet_read_property_queue( uint32_t device_id, BACNET_OBJECT_TYPE object_type, uint32_t object_instance, BACNET_PROPERTY_ID object_property, uint32_t array_index); +BACNET_STACK_EXPORT bool bacnet_write_property_real_queue( uint32_t device_id, BACNET_OBJECT_TYPE object_type, @@ -64,6 +70,7 @@ bool bacnet_write_property_real_queue( float value, uint8_t priority, uint32_t array_index); +BACNET_STACK_EXPORT bool bacnet_write_property_null_queue( uint32_t device_id, BACNET_OBJECT_TYPE object_type, @@ -71,6 +78,7 @@ bool bacnet_write_property_null_queue( BACNET_PROPERTY_ID object_property, uint8_t priority, uint32_t array_index); +BACNET_STACK_EXPORT bool bacnet_write_property_enumerated_queue( uint32_t device_id, BACNET_OBJECT_TYPE object_type, @@ -79,6 +87,7 @@ bool bacnet_write_property_enumerated_queue( unsigned int value, uint8_t priority, uint32_t array_index); +BACNET_STACK_EXPORT bool bacnet_write_property_unsigned_queue( uint32_t device_id, BACNET_OBJECT_TYPE object_type, @@ -87,6 +96,7 @@ bool bacnet_write_property_unsigned_queue( unsigned int value, uint8_t priority, uint32_t array_index); +BACNET_STACK_EXPORT bool bacnet_write_property_signed_queue( uint32_t device_id, BACNET_OBJECT_TYPE object_type, @@ -95,6 +105,7 @@ bool bacnet_write_property_signed_queue( signed int value, uint8_t priority, uint32_t array_index); +BACNET_STACK_EXPORT bool bacnet_write_property_boolean_queue( uint32_t device_id, BACNET_OBJECT_TYPE object_type, @@ -103,11 +114,15 @@ bool bacnet_write_property_boolean_queue( bool value, uint8_t priority, uint32_t array_index); +BACNET_STACK_EXPORT void bacnet_read_write_value_callback_set( bacnet_read_write_value_callback_t callback); +BACNET_STACK_EXPORT void bacnet_read_write_device_callback_set( bacnet_read_write_device_callback_t callback); +BACNET_STACK_EXPORT void bacnet_read_write_vendor_id_filter_set(uint16_t vendor_id); +BACNET_STACK_EXPORT uint16_t bacnet_read_write_vendor_id_filter(void); #ifdef __cplusplus diff --git a/src/bacnet/basic/client/bac-task.h b/src/bacnet/basic/client/bac-task.h index 131f5ae0..c17a9feb 100644 --- a/src/bacnet/basic/client/bac-task.h +++ b/src/bacnet/basic/client/bac-task.h @@ -15,7 +15,9 @@ extern "C" { #endif /* __cplusplus */ +BACNET_STACK_EXPORT void bacnet_task_init(void); +BACNET_STACK_EXPORT void bacnet_task(void); #ifdef __cplusplus diff --git a/src/bacnet/basic/program/ubasic/config.h b/src/bacnet/basic/program/ubasic/config.h index 4da5e214..2f5d3528 100644 --- a/src/bacnet/basic/program/ubasic/config.h +++ b/src/bacnet/basic/program/ubasic/config.h @@ -33,150 +33,117 @@ #include #include #include - -/* Undef it all */ - -/* Storage and arithmetic */ -#undef VARIABLE_STORAGE_INT16 -#undef VARIABLE_STORAGE_INT32 -#undef VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8 -#undef VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10 -#undef VARIABLE_TYPE_STRING -#undef VARIABLE_TYPE_ARRAY -#undef UBASIC_SCRIPT_HAVE_DEMO_SCRIPTS +#include "bacnet/bacdef.h" /* Microcontroller related functionality */ -#undef UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR -#undef UBASIC_SCRIPT_HAVE_PWM_CHANNELS -#undef UBASIC_SCRIPT_HAVE_GPIO -#undef UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS -#undef UBASIC_SCRIPT_HAVE_SLEEP -#undef UBASIC_SCRIPT_HAVE_HARDWARE_EVENTS -#undef UBASIC_SCRIPT_PRINT_TO_SERIAL -#undef UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL -#undef UBASIC_SCRIPT_HAVE_ANALOG_READ -#undef UBASIC_SCRIPT_HAVE_STORE_VARS_IN_FLASH -#undef UBASIC_SCRIPT_HAVE_BACNET +#if !( \ + defined(UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR) || \ + defined(UBASIC_SCRIPT_HAVE_PWM_CHANNELS) || \ + defined(UBASIC_SCRIPT_HAVE_GPIO_CHANNELS) || \ + defined(UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS) || \ + defined(UBASIC_SCRIPT_HAVE_SLEEP) || \ + defined(UBASIC_SCRIPT_HAVE_HARDWARE_EVENTS) || \ + defined(UBASIC_SCRIPT_HAVE_PRINT_TO_SERIAL) || \ + defined(UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL) || \ + defined(UBASIC_SCRIPT_HAVE_ANALOG_READ) || \ + defined(UBASIC_SCRIPT_HAVE_STORE_VARS_IN_FLASH) || \ + defined(UBASIC_SCRIPT_HAVE_BACNET) || \ + defined(UBASIC_SCRIPT_HAVE_STRING_VARIABLES)) +#define UBASIC_SCRIPT_HAVE_ALL +#endif + +#if defined(UBASIC_SCRIPT_HAVE_ALL) +#define UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR +#define UBASIC_SCRIPT_HAVE_PWM_CHANNELS 4 +#define UBASIC_SCRIPT_HAVE_GPIO_CHANNELS +#define UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS 8 +#define UBASIC_SCRIPT_HAVE_SLEEP +#define UBASIC_SCRIPT_HAVE_HARDWARE_EVENTS +#define UBASIC_SCRIPT_HAVE_PRINT_TO_SERIAL +#define UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL +#define UBASIC_SCRIPT_HAVE_ANALOG_READ +#define UBASIC_SCRIPT_HAVE_STORE_VARS_IN_FLASH +#define UBASIC_SCRIPT_HAVE_BACNET +#define UBASIC_SCRIPT_HAVE_STRING_VARIABLES +#endif /** * * UBASIC-PLUS: Start * */ + +/* This many one-letter variables UBASIC supports */ +#ifndef UBASIC_VARNUM_MAX +#define UBASIC_VARNUM_MAX 26 +#endif + +/* have numeric arrays and set their storage to this many UBASIC_VARIABLE_TYPE + * entries + */ +#ifndef UBASIC_VARIABLE_TYPE_ARRAY +#define UBASIC_VARIABLE_TYPE_ARRAY 64 +#endif + +/* have strings and related functions */ +#ifdef UBASIC_SCRIPT_HAVE_STRING_VARIABLES +#define UBASIC_VARIABLE_TYPE_STRING +#endif + /* default storage for all numeric values */ -#define VARIABLE_STORAGE_INT32 +#ifndef UBASIC_VARIABLE_STORAGE_INT16 +#undef UBASIC_VARIABLE_STORAGE_INT32 +#define UBASIC_VARIABLE_STORAGE_INT32 +#endif /* defines the representation of floating point numbers as fixed points: this is to allow UBASIC to run on Cortex M0 processors which do not support Floating Point Arithmetic in hardware (they emulate it which consumes lots of memory) */ -#define VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8 - -/* This many one-letter variables UBASIC supports */ -#define MAX_VARNUM 26 - -/* have numeric arrays and set their storage to this many VARIABLE_TYPE entries - */ -#define VARIABLE_TYPE_ARRAY 64 - -/* have strings and related functions */ -#define VARIABLE_TYPE_STRING - -/* can go to sleep: leave UBASIC for other stuff while waiting for timer to - * expire */ -#define UBASIC_SCRIPT_HAVE_SLEEP - -/* have microcontroller support for PWM: specify how many channels */ -#define UBASIC_SCRIPT_HAVE_PWM_CHANNELS (4) - -/* have internal timer channels available through rlab-like toc(ch) functions */ -#define UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS (8) - -/* support for random number generator by micro-controller */ -#define UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR - -/* support for direct access to pin inputs and outputs */ -#define UBASIC_SCRIPT_HAVE_GPIO_CHANNELS - -/* support flags in BASIC that change on hardware events: - for STM32F0XX nucleo and discovery boards - source of the events is push-button -*/ -#define UBASIC_SCRIPT_HAVE_HARDWARE_EVENTS - -/* have a standard print to serial console function */ -#define UBASIC_SCRIPT_PRINT_TO_SERIAL - -/* how is input function supported ? */ -#define UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL - -/* support for analog inputs */ -#define UBASIC_SCRIPT_HAVE_ANALOG_READ - -/* support for BACnet objects and ReadProperty and WriteProperty (internal) */ -#define UBASIC_SCRIPT_HAVE_BACNET - -/* Demo scripts are huge. Do we need them? */ -#define UBASIC_SCRIPT_HAVE_DEMO_SCRIPTS - -/* support for storing/recalling variables in/from flash memory */ -#define UBASIC_SCRIPT_HAVE_STORE_VARS_IN_FLASH -/** - * - * UBASIC-PLUS: End - * - */ - -/* - * Selectively load header files based on the ocnfiguration above. - * Remember MC Hammer: - * CAN'T TOUCH THIS! - * - */ -#if defined(VARIABLE_STORAGE_INT32) - -#define VARIABLE_TYPE int32_t - -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#ifndef UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10 +#undef UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8 +#define UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8 +#endif +#if defined(UBASIC_VARIABLE_STORAGE_INT32) +#define UBASIC_VARIABLE_TYPE int32_t +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) #define FIXEDPT_BITS 32 - -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) #define FIXEDPT_WBITS 24 -#elif defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#elif defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) #define FIXEDPT_WBITS 22 #else #error "Only 24.8 and 22.10 floats are currently supported" #endif - #include "fixedptc.h" - #endif - -#elif defined(VARIABLE_STORAGE_INT16) - -#define VARIABLE_TYPE int16_t -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#elif defined(UBASIC_VARIABLE_STORAGE_INT16) +#define UBASIC_VARIABLE_TYPE int16_t +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) #error "Fixed Point Floats are Supported for 32bit Storage Only!" #endif - #else - #error "Only INT32 and INT16 variable types are supported." - #endif -#define UBASIC_STATEMENT_SIZE (64) +#ifndef UBASIC_STATEMENT_SIZE +#define UBASIC_STATEMENT_SIZE 64 +#endif -#define MAX_STRINGLEN 40 -#define MAX_LABEL_LEN 10 +#ifndef UBASIC_STRINGLEN_MAX +#define UBASIC_STRINGLEN_MAX 40 +#endif -#if defined(VARIABLE_TYPE_STRING) -#define MAX_STRINGVARLEN 64 -#define MAX_BUFFERLEN 256 -#define MAX_SVARNUM 26 +#ifndef UBASIC_LABEL_LEN_MAX +#define UBASIC_LABEL_LEN_MAX 10 +#endif + +#if defined(UBASIC_VARIABLE_TYPE_STRING) +#define UBASIC_STRING_BUFFER_LEN_MAX 256 +#define UBASIC_STRING_VAR_LEN_MAX 26 #endif #endif /* #ifndef _CONFIG_H_ */ diff --git a/src/bacnet/basic/program/ubasic/platform.h b/src/bacnet/basic/program/ubasic/platform.h deleted file mode 100644 index d5224a0e..00000000 --- a/src/bacnet/basic/program/ubasic/platform.h +++ /dev/null @@ -1,46 +0,0 @@ -/** - * @file - * @author Steve Karg - * @date 2025 - * @brief Platform libc and compiler abstraction layer - * @details This libc and compiler abstraction layer assists with differences - * between compiler and libc versions, capabilities, and C standards. - * @copyright SPDX-License-Identifier: MIT - */ -#ifndef UBASIC_PLATFORM_H -#define UBASIC_PLATFORM_H -#include -#include -#include -#include - -#ifndef INT_MAX -#define INT_MAX (~0U >> 1U) -#endif - -#ifndef NOMINMAX -#ifndef max -#define max(a, b) (((a) > (b)) ? (a) : (b)) -#endif -#ifndef min -#define min(a, b) (((a) < (b)) ? (a) : (b)) -#endif -#endif - -#ifndef islessgreater -#define islessgreater(x, y) ((x) < (y) || (x) > (y)) -#endif - -#ifndef isgreaterequal -#define isgreaterequal(x, y) ((x) > (y) || !islessgreater((x), (y))) -#endif - -#ifndef islessequal -#define islessequal(x, y) ((x) < (y) || !islessgreater((x), (y))) -#endif - -#ifndef ARRAY_SIZE -#define ARRAY_SIZE(array) ((size_t)(sizeof(array) / sizeof((array)[0]))) -#endif - -#endif diff --git a/src/bacnet/basic/program/ubasic/tokenizer.c b/src/bacnet/basic/program/ubasic/tokenizer.c index 17163589..43232350 100644 --- a/src/bacnet/basic/program/ubasic/tokenizer.c +++ b/src/bacnet/basic/program/ubasic/tokenizer.c @@ -35,191 +35,189 @@ #include "config.h" #include "tokenizer.h" -#define MAX_NUMLEN 8 - struct keyword_token { const char *keyword; uint8_t token; }; static const struct keyword_token keywords[] = { -#if defined(VARIABLE_TYPE_STRING) +#if defined(UBASIC_VARIABLE_TYPE_STRING) /* new string-related statements and functions */ - { "left$", TOKENIZER_LEFT_STR }, - { "right$", TOKENIZER_RIGHT_STR }, - { "mid$", TOKENIZER_MID_STR }, - { "str$", TOKENIZER_STR_STR }, - { "chr$", TOKENIZER_CHR_STR }, - { "val", TOKENIZER_VAL }, - { "len", TOKENIZER_LEN }, - { "instr", TOKENIZER_INSTR }, - { "asc", TOKENIZER_ASC }, + { "left$", UBASIC_TOKENIZER_LEFT_STR }, + { "right$", UBASIC_TOKENIZER_RIGHT_STR }, + { "mid$", UBASIC_TOKENIZER_MID_STR }, + { "str$", UBASIC_TOKENIZER_STR_STR }, + { "chr$", UBASIC_TOKENIZER_CHR_STR }, + { "val", UBASIC_TOKENIZER_VAL }, + { "len", UBASIC_TOKENIZER_LEN }, + { "instr", UBASIC_TOKENIZER_INSTR }, + { "asc", UBASIC_TOKENIZER_ASC }, #endif /* end of string additions */ - { "let ", TOKENIZER_LET }, - { "println ", TOKENIZER_PRINTLN }, - { "print ", TOKENIZER_PRINT }, - { "if", TOKENIZER_IF }, - { "then", TOKENIZER_THEN }, - { "else", TOKENIZER_ELSE }, - { "endif", TOKENIZER_ENDIF }, + { "let ", UBASIC_TOKENIZER_LET }, + { "println ", UBASIC_TOKENIZER_PRINTLN }, + { "print ", UBASIC_TOKENIZER_PRINT }, + { "if", UBASIC_TOKENIZER_IF }, + { "then", UBASIC_TOKENIZER_THEN }, + { "else", UBASIC_TOKENIZER_ELSE }, + { "endif", UBASIC_TOKENIZER_ENDIF }, #if defined(UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS) - { "toc", TOKENIZER_TOC }, + { "toc", UBASIC_TOKENIZER_TOC }, #endif #if defined(UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL) - { "input", TOKENIZER_INPUT }, + { "input", UBASIC_TOKENIZER_INPUT }, #endif - { "for ", TOKENIZER_FOR }, - { "to ", TOKENIZER_TO }, - { "next ", TOKENIZER_NEXT }, - { "step ", TOKENIZER_STEP }, - { "while", TOKENIZER_WHILE }, - { "endwhile", TOKENIZER_ENDWHILE }, - { "goto ", TOKENIZER_GOTO }, - { "gosub ", TOKENIZER_GOSUB }, - { "return", TOKENIZER_RETURN }, - { "end", TOKENIZER_END }, + { "for ", UBASIC_TOKENIZER_FOR }, + { "to ", UBASIC_TOKENIZER_TO }, + { "next ", UBASIC_TOKENIZER_NEXT }, + { "step ", UBASIC_TOKENIZER_STEP }, + { "while", UBASIC_TOKENIZER_WHILE }, + { "endwhile", UBASIC_TOKENIZER_ENDWHILE }, + { "goto ", UBASIC_TOKENIZER_GOTO }, + { "gosub ", UBASIC_TOKENIZER_GOSUB }, + { "return", UBASIC_TOKENIZER_RETURN }, + { "end", UBASIC_TOKENIZER_END }, #if defined(UBASIC_SCRIPT_HAVE_SLEEP) - { "sleep", TOKENIZER_SLEEP }, + { "sleep", UBASIC_TOKENIZER_SLEEP }, #endif -#if defined(VARIABLE_TYPE_ARRAY) - { "dim ", TOKENIZER_DIM }, +#if defined(UBASIC_VARIABLE_TYPE_ARRAY) + { "dim ", UBASIC_TOKENIZER_DIM }, #endif #if defined(UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS) - { "tic", TOKENIZER_TIC }, + { "tic", UBASIC_TOKENIZER_TIC }, #endif #if defined(UBASIC_SCRIPT_HAVE_HARDWARE_EVENTS) - { "flag", TOKENIZER_HWE }, + { "flag", UBASIC_TOKENIZER_HWE }, #endif #if defined(UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR) - { "ran", TOKENIZER_RAN }, + { "ran", UBASIC_TOKENIZER_RAN }, #endif -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) - { "sqrt", TOKENIZER_SQRT }, - { "sin", TOKENIZER_SIN }, - { "cos", TOKENIZER_COS }, - { "tan", TOKENIZER_TAN }, - { "exp", TOKENIZER_EXP }, - { "ln", TOKENIZER_LN }, +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) + { "sqrt", UBASIC_TOKENIZER_SQRT }, + { "sin", UBASIC_TOKENIZER_SIN }, + { "cos", UBASIC_TOKENIZER_COS }, + { "tan", UBASIC_TOKENIZER_TAN }, + { "exp", UBASIC_TOKENIZER_EXP }, + { "ln", UBASIC_TOKENIZER_LN }, #if defined(UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR) - { "uniform", TOKENIZER_UNIFORM }, + { "uniform", UBASIC_TOKENIZER_UNIFORM }, #endif - { "abs", TOKENIZER_ABS }, - { "floor", TOKENIZER_FLOOR }, - { "ceil", TOKENIZER_CEIL }, - { "round", TOKENIZER_ROUND }, - { "pow", TOKENIZER_POWER }, - { "avgw", TOKENIZER_AVERAGEW }, + { "abs", UBASIC_TOKENIZER_ABS }, + { "floor", UBASIC_TOKENIZER_FLOOR }, + { "ceil", UBASIC_TOKENIZER_CEIL }, + { "round", UBASIC_TOKENIZER_ROUND }, + { "pow", UBASIC_TOKENIZER_POWER }, + { "avgw", UBASIC_TOKENIZER_AVERAGEW }, #endif #if defined(UBASIC_SCRIPT_HAVE_GPIO_CHANNELS) - { "pinmode", TOKENIZER_PINMODE }, - { "dread", TOKENIZER_DREAD }, - { "dwrite", TOKENIZER_DWRITE }, + { "pinmode", UBASIC_TOKENIZER_PINMODE }, + { "dread", UBASIC_TOKENIZER_DREAD }, + { "dwrite", UBASIC_TOKENIZER_DWRITE }, #endif #ifdef UBASIC_SCRIPT_HAVE_PWM_CHANNELS - { "awrite_conf", TOKENIZER_PWMCONF }, - { "awrite", TOKENIZER_PWM }, + { "awrite_conf", UBASIC_TOKENIZER_PWMCONF }, + { "awrite", UBASIC_TOKENIZER_PWM }, #endif #if defined(UBASIC_SCRIPT_HAVE_ANALOG_READ) - { "aread_conf", TOKENIZER_AREADCONF }, - { "aread", TOKENIZER_AREAD }, + { "aread_conf", UBASIC_TOKENIZER_AREADCONF }, + { "aread", UBASIC_TOKENIZER_AREAD }, #endif - { "hex ", TOKENIZER_PRINT_HEX }, - { "dec ", TOKENIZER_PRINT_DEC }, - { ":", TOKENIZER_COLON }, + { "hex ", UBASIC_TOKENIZER_PRINT_HEX }, + { "dec ", UBASIC_TOKENIZER_PRINT_DEC }, + { ":", UBASIC_TOKENIZER_COLON }, #if defined(UBASIC_SCRIPT_HAVE_STORE_VARS_IN_FLASH) - { "store", TOKENIZER_STORE }, - { "recall", TOKENIZER_RECALL }, + { "store", UBASIC_TOKENIZER_STORE }, + { "recall", UBASIC_TOKENIZER_RECALL }, #endif #if defined(UBASIC_SCRIPT_HAVE_BACNET) - { "bac_create", TOKENIZER_BACNET_CREATE_OBJECT }, - { "bac_read", TOKENIZER_BACNET_READ_PROPERTY }, - { "bac_write", TOKENIZER_BACNET_WRITE_PROPERTY }, + { "bac_create", UBASIC_TOKENIZER_BACNET_CREATE_OBJECT }, + { "bac_read", UBASIC_TOKENIZER_BACNET_READ_PROPERTY }, + { "bac_write", UBASIC_TOKENIZER_BACNET_WRITE_PROPERTY }, #endif - { "clear", TOKENIZER_CLEAR }, - { NULL, TOKENIZER_ERROR } + { "clear", UBASIC_TOKENIZER_CLEAR }, + { NULL, UBASIC_TOKENIZER_ERROR } }; /*---------------------------------------------------------------------------*/ static uint8_t -singlechar_or_operator(struct tokenizer_data *tree, uint8_t *offset) +singlechar_or_operator(struct ubasic_tokenizer *tree, uint8_t *offset) { if (offset) { *offset = 1; } if ((*tree->ptr == '\n') || (*tree->ptr == ';')) { - return TOKENIZER_EOL; + return UBASIC_TOKENIZER_EOL; } else if (*tree->ptr == ',') { - return TOKENIZER_COMMA; + return UBASIC_TOKENIZER_COMMA; } else if (*tree->ptr == '+') { - return TOKENIZER_PLUS; + return UBASIC_TOKENIZER_PLUS; } else if (*tree->ptr == '-') { - return TOKENIZER_MINUS; + return UBASIC_TOKENIZER_MINUS; } else if (*tree->ptr == '&') { if (*(tree->ptr + 1) == '&') { if (offset) { *offset += 1; } - return TOKENIZER_LAND; + return UBASIC_TOKENIZER_LAND; } - return TOKENIZER_AND; + return UBASIC_TOKENIZER_AND; } else if (*tree->ptr == '|') { if (*(tree->ptr + 1) == '|') { if (offset) { *offset += 1; } - return TOKENIZER_LOR; + return UBASIC_TOKENIZER_LOR; } - return TOKENIZER_OR; + return UBASIC_TOKENIZER_OR; } else if (*tree->ptr == '*') { - return TOKENIZER_ASTR; + return UBASIC_TOKENIZER_ASTR; } else if (*tree->ptr == '!') { - return TOKENIZER_LNOT; + return UBASIC_TOKENIZER_LNOT; } else if (*tree->ptr == '~') { - return TOKENIZER_NOT; + return UBASIC_TOKENIZER_NOT; } else if (*tree->ptr == '/') { - return TOKENIZER_SLASH; + return UBASIC_TOKENIZER_SLASH; } else if (*tree->ptr == '%') { - return TOKENIZER_MOD; + return UBASIC_TOKENIZER_MOD; } else if (*tree->ptr == '(') { - return TOKENIZER_LEFTPAREN; + return UBASIC_TOKENIZER_LEFTPAREN; } else if (*tree->ptr == ')') { - return TOKENIZER_RIGHTPAREN; + return UBASIC_TOKENIZER_RIGHTPAREN; } else if (*tree->ptr == '<') { if (tree->ptr[1] == '=') { if (offset) { *offset += 1; } - return TOKENIZER_LE; + return UBASIC_TOKENIZER_LE; } else if (tree->ptr[1] == '>') { if (offset) { *offset += 1; } - return TOKENIZER_NE; + return UBASIC_TOKENIZER_NE; } - return TOKENIZER_LT; + return UBASIC_TOKENIZER_LT; } else if (*tree->ptr == '>') { if (tree->ptr[1] == '=') { if (offset) { *offset += 1; } - return TOKENIZER_GE; + return UBASIC_TOKENIZER_GE; } - return TOKENIZER_GT; + return UBASIC_TOKENIZER_GT; } else if (*tree->ptr == '=') { if (tree->ptr[1] == '=') { if (offset) { *offset += 1; } } - return TOKENIZER_EQ; + return UBASIC_TOKENIZER_EQ; } return 0; } /*---------------------------------------------------------------------------*/ -static uint8_t tokenizer_next_token(struct tokenizer_data *tree) +static uint8_t tokenizer_next_token(struct ubasic_tokenizer *tree) { const struct keyword_token *kt; uint8_t i, j; @@ -230,7 +228,7 @@ static uint8_t tokenizer_next_token(struct tokenizer_data *tree) } if (*tree->ptr == 0) { - return TOKENIZER_ENDOFINPUT; + return UBASIC_TOKENIZER_ENDOFINPUT; } uint8_t have_decdot = 0, i_dot = 0; @@ -251,7 +249,7 @@ static uint8_t tokenizer_next_token(struct tokenizer_data *tree) tree->nextptr++; continue; } - return TOKENIZER_INT; + return UBASIC_TOKENIZER_INT; } } else if ( (tree->ptr[0] == '0') && @@ -261,7 +259,7 @@ static uint8_t tokenizer_next_token(struct tokenizer_data *tree) while (*tree->nextptr == '0' || *tree->nextptr == '1') { tree->nextptr++; } - return TOKENIZER_INT; + return UBASIC_TOKENIZER_INT; } else if (isdigit(*tree->ptr) || (*tree->ptr == '.')) { /* is it FLOAT (digits with at most one decimal point) */ /* is it DEC (digits without decimal point which ends in d,D,L,l) */ @@ -280,29 +278,29 @@ static uint8_t tokenizer_next_token(struct tokenizer_data *tree) tree->nextptr++; have_decdot++; if (have_decdot > 1) { - return TOKENIZER_ERROR; + return UBASIC_TOKENIZER_ERROR; } continue; } if (*tree->nextptr == 'd' || *tree->nextptr == 'D' || *tree->nextptr == 'l' || *tree->nextptr == 'L') { - return TOKENIZER_INT; + return UBASIC_TOKENIZER_INT; } -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) if (i_dot) { - return TOKENIZER_FLOAT; + return UBASIC_TOKENIZER_FLOAT; } #endif - return TOKENIZER_NUMBER; + return UBASIC_TOKENIZER_NUMBER; } } else if ((j = singlechar_or_operator(tree, &i))) { tree->nextptr = tree->ptr + i; return j; } -#if defined(VARIABLE_TYPE_STRING) +#if defined(UBASIC_VARIABLE_TYPE_STRING) else if ( (*tree->ptr == '"' || *tree->ptr == '\'') && (*(tree->ptr - 1) != '\\')) { @@ -312,13 +310,13 @@ static uint8_t tokenizer_next_token(struct tokenizer_data *tree) ++tree->nextptr; if ((*tree->nextptr == '\0') || (*tree->nextptr == '\n') || (*tree->nextptr == ';')) { - return TOKENIZER_ERROR; + return UBASIC_TOKENIZER_ERROR; } } while (*tree->nextptr != i || *(tree->nextptr - 1) == '\\'); ++tree->nextptr; - return TOKENIZER_STRING; + return UBASIC_TOKENIZER_STRING; } #endif else { @@ -364,34 +362,34 @@ static uint8_t tokenizer_next_token(struct tokenizer_data *tree) } if (j > 0 || i > 1) { - return TOKENIZER_LABEL; + return UBASIC_TOKENIZER_LABEL; } if (i == 1) { -#if defined(VARIABLE_TYPE_STRING) +#if defined(UBASIC_VARIABLE_TYPE_STRING) if (*(tree->ptr + 1) == '$') { tree->nextptr++; - return TOKENIZER_STRINGVARIABLE; + return UBASIC_TOKENIZER_STRINGVARIABLE; } #endif -#if defined(VARIABLE_TYPE_ARRAY) +#if defined(UBASIC_VARIABLE_TYPE_ARRAY) if (*(tree->ptr + 1) == '@') { tree->nextptr++; - return TOKENIZER_ARRAYVARIABLE; + return UBASIC_TOKENIZER_ARRAYVARIABLE; } #endif - return TOKENIZER_VARIABLE; + return UBASIC_TOKENIZER_VARIABLE; } break; } } - return TOKENIZER_ERROR; + return UBASIC_TOKENIZER_ERROR; } /*---------------------------------------------------------------------------*/ -#if defined(VARIABLE_TYPE_STRING) -int8_t tokenizer_stringlookahead(struct tokenizer_data *tree) +#if defined(UBASIC_VARIABLE_TYPE_STRING) +int8_t tokenizer_stringlookahead(struct ubasic_tokenizer *tree) { /* return 1 (true) if next 'defining' token is string not integer */ const char *saveptr = tree->ptr; @@ -400,20 +398,23 @@ int8_t tokenizer_stringlookahead(struct tokenizer_data *tree) int8_t si = -1; while (si == -1) { - if (token == TOKENIZER_EOL || token == TOKENIZER_ENDOFINPUT) { + if (token == UBASIC_TOKENIZER_EOL || + token == UBASIC_TOKENIZER_ENDOFINPUT) { si = 0; } else if ( - token == TOKENIZER_NUMBER || token == TOKENIZER_VARIABLE || - token == TOKENIZER_FLOAT) { + token == UBASIC_TOKENIZER_NUMBER || + token == UBASIC_TOKENIZER_VARIABLE || + token == UBASIC_TOKENIZER_FLOAT) { si = 0; /* number or numeric var */ - } else if (token == TOKENIZER_PLUS) { + } else if (token == UBASIC_TOKENIZER_PLUS) { /* do nothing */ - } else if (token == TOKENIZER_STRING) { + } else if (token == UBASIC_TOKENIZER_STRING) { si = 1; } else if ( - token >= TOKENIZER_STRINGVARIABLE && token <= TOKENIZER_CHR_STR) { + token >= UBASIC_TOKENIZER_STRINGVARIABLE && + token <= UBASIC_TOKENIZER_CHR_STR) { si = 1; - } else if (token > TOKENIZER_CHR_STR) { + } else if (token > UBASIC_TOKENIZER_CHR_STR) { si = 0; /* numeric function */ } @@ -425,19 +426,19 @@ int8_t tokenizer_stringlookahead(struct tokenizer_data *tree) } #endif /*---------------------------------------------------------------------------*/ -void tokenizer_init(struct tokenizer_data *tree, const char *program) +void tokenizer_init(struct ubasic_tokenizer *tree, const char *program) { tree->ptr = program; tree->prog = program; tree->current_token = tokenizer_next_token(tree); } /*---------------------------------------------------------------------------*/ -uint8_t tokenizer_token(struct tokenizer_data *tree) +uint8_t tokenizer_token(struct ubasic_tokenizer *tree) { return tree->current_token; } /*---------------------------------------------------------------------------*/ -void tokenizer_next(struct tokenizer_data *tree) +void tokenizer_next(struct ubasic_tokenizer *tree) { if (tokenizer_finished(tree)) { return; @@ -454,10 +455,10 @@ void tokenizer_next(struct tokenizer_data *tree) } /*---------------------------------------------------------------------------*/ -VARIABLE_TYPE tokenizer_num(struct tokenizer_data *tree) +UBASIC_VARIABLE_TYPE tokenizer_num(struct ubasic_tokenizer *tree) { const char *c = tree->ptr; - VARIABLE_TYPE rval = 0; + UBASIC_VARIABLE_TYPE rval = 0; while (1) { if (*c < '0' || *c > '9') { @@ -472,10 +473,10 @@ VARIABLE_TYPE tokenizer_num(struct tokenizer_data *tree) return rval; } -VARIABLE_TYPE tokenizer_int(struct tokenizer_data *tree) +UBASIC_VARIABLE_TYPE tokenizer_int(struct ubasic_tokenizer *tree) { const char *c = tree->ptr; - VARIABLE_TYPE rval = 0; + UBASIC_VARIABLE_TYPE rval = 0; if ((*c == '0') && (*(c + 1) == 'x' || *(c + 1) == 'X')) { c += 2; while (1) { @@ -518,25 +519,25 @@ VARIABLE_TYPE tokenizer_int(struct tokenizer_data *tree) return tokenizer_num(tree); } -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) /*---------------------------------------------------------------------------*/ -VARIABLE_TYPE tokenizer_float(struct tokenizer_data *tree) +UBASIC_VARIABLE_TYPE tokenizer_float(struct ubasic_tokenizer *tree) { return str_fixedpt( tree->ptr, tree->nextptr - tree->ptr, FIXEDPT_FBITS >> 1); } #endif -#if defined(VARIABLE_TYPE_STRING) +#if defined(UBASIC_VARIABLE_TYPE_STRING) /*---------------------------------------------------------------------------*/ -void tokenizer_string(struct tokenizer_data *tree, char *dest, uint8_t len) +void tokenizer_string(struct ubasic_tokenizer *tree, char *dest, uint8_t len) { const char *string_end; char quote_char; uint8_t string_len; - if (tokenizer_token(tree) != TOKENIZER_STRING) { + if (tokenizer_token(tree) != UBASIC_TOKENIZER_STRING) { return; } quote_char = *tree->ptr; @@ -564,12 +565,12 @@ void tokenizer_string(struct tokenizer_data *tree, char *dest, uint8_t len) } #endif -void tokenizer_label(struct tokenizer_data *tree, char *dest, uint8_t len) +void tokenizer_label(struct ubasic_tokenizer *tree, char *dest, uint8_t len) { const char *string_end = tree->nextptr; uint8_t string_len; - if (tokenizer_token(tree) != TOKENIZER_LABEL) { + if (tokenizer_token(tree) != UBASIC_TOKENIZER_LABEL) { return; } @@ -593,13 +594,15 @@ void tokenizer_label(struct tokenizer_data *tree, char *dest, uint8_t len) } /*---------------------------------------------------------------------------*/ -bool tokenizer_finished(struct tokenizer_data *tree) +bool tokenizer_finished(struct ubasic_tokenizer *tree) { - return ((*tree->ptr == 0) || (tree->current_token == TOKENIZER_ENDOFINPUT)); + return ( + (*tree->ptr == 0) || + (tree->current_token == UBASIC_TOKENIZER_ENDOFINPUT)); } /*---------------------------------------------------------------------------*/ -uint8_t tokenizer_variable_num(struct tokenizer_data *tree) +uint8_t tokenizer_variable_num(struct ubasic_tokenizer *tree) { if ((*tree->ptr >= 'a' && *tree->ptr <= 'z')) { return (((uint8_t)*tree->ptr) - 'a'); @@ -613,23 +616,23 @@ uint8_t tokenizer_variable_num(struct tokenizer_data *tree) } /*---------------------------------------------------------------------------*/ -uint16_t tokenizer_save_offset(struct tokenizer_data *tree) +uint16_t tokenizer_save_offset(struct ubasic_tokenizer *tree) { return (tree->ptr - tree->prog); } -void tokenizer_jump_offset(struct tokenizer_data *tree, uint16_t offset) +void tokenizer_jump_offset(struct ubasic_tokenizer *tree, uint16_t offset) { tree->ptr = (tree->prog + offset); tree->current_token = tokenizer_next_token(tree); - while ((tree->current_token == TOKENIZER_EOL) && + while ((tree->current_token == UBASIC_TOKENIZER_EOL) && !tokenizer_finished(tree)) { tokenizer_next(tree); } return; } -const char *tokenizer_name(VARIABLE_TYPE token) +const char *tokenizer_name(UBASIC_VARIABLE_TYPE token) { const struct keyword_token *kt; diff --git a/src/bacnet/basic/program/ubasic/tokenizer.h b/src/bacnet/basic/program/ubasic/tokenizer.h index a111cae0..f665cb7f 100644 --- a/src/bacnet/basic/program/ubasic/tokenizer.h +++ b/src/bacnet/basic/program/ubasic/tokenizer.h @@ -36,176 +36,176 @@ * * SPDX-License-Identifier: BSD-3-Clause */ -#ifndef __TOKENIZER_H__ -#define __TOKENIZER_H__ +#ifndef _UBASIC_TOKENIZER_H__ +#define _UBASIC_TOKENIZER_H__ #include #include #include "config.h" enum { - /*0*/ TOKENIZER_ERROR, - /*1*/ TOKENIZER_ENDOFINPUT, - /*2*/ TOKENIZER_NUMBER, -#if defined(VARIABLE_TYPE_STRING) - /*3*/ TOKENIZER_STRING, + /*0*/ UBASIC_TOKENIZER_ERROR, + /*1*/ UBASIC_TOKENIZER_ENDOFINPUT, + /*2*/ UBASIC_TOKENIZER_NUMBER, +#if defined(UBASIC_VARIABLE_TYPE_STRING) + /*3*/ UBASIC_TOKENIZER_STRING, #endif - /*4*/ TOKENIZER_VARIABLE, -#if defined(VARIABLE_TYPE_STRING) + /*4*/ UBASIC_TOKENIZER_VARIABLE, +#if defined(UBASIC_VARIABLE_TYPE_STRING) /* string additions - must be here and in this order */ - /*5*/ TOKENIZER_STRINGVARIABLE, - /*6*/ TOKENIZER_PRINT_STR, - /*7*/ TOKENIZER_LEFT_STR, - /*8*/ TOKENIZER_RIGHT_STR, - /*9*/ TOKENIZER_MID_STR, - /*10*/ TOKENIZER_STR_STR, - /*11*/ TOKENIZER_CHR_STR, - /*12*/ TOKENIZER_VAL, - /*13*/ TOKENIZER_LEN, - /*14*/ TOKENIZER_INSTR, - /*15*/ TOKENIZER_ASC, + /*5*/ UBASIC_TOKENIZER_STRINGVARIABLE, + /*6*/ UBASIC_TOKENIZER_PRINT_STR, + /*7*/ UBASIC_TOKENIZER_LEFT_STR, + /*8*/ UBASIC_TOKENIZER_RIGHT_STR, + /*9*/ UBASIC_TOKENIZER_MID_STR, + /*10*/ UBASIC_TOKENIZER_STR_STR, + /*11*/ UBASIC_TOKENIZER_CHR_STR, + /*12*/ UBASIC_TOKENIZER_VAL, + /*13*/ UBASIC_TOKENIZER_LEN, + /*14*/ UBASIC_TOKENIZER_INSTR, + /*15*/ UBASIC_TOKENIZER_ASC, #endif - /*16*/ TOKENIZER_LET, - /*17*/ TOKENIZER_PRINTLN, - /*18*/ TOKENIZER_PRINT, - /*19*/ TOKENIZER_IF, - /*20*/ TOKENIZER_THEN, - /*21*/ TOKENIZER_ELSE, - /*22*/ TOKENIZER_ENDIF, - /*23*/ TOKENIZER_FOR, - /*24*/ TOKENIZER_TO, - /*25*/ TOKENIZER_NEXT, - /*26*/ TOKENIZER_STEP, - /*27*/ TOKENIZER_WHILE, - /*28*/ TOKENIZER_ENDWHILE, - /*29*/ TOKENIZER_GOTO, - /*30*/ TOKENIZER_GOSUB, - /*31*/ TOKENIZER_RETURN, - /*32*/ TOKENIZER_END, - /*33*/ TOKENIZER_COMMA, - /*34*/ TOKENIZER_PLUS, - /*35*/ TOKENIZER_MINUS, - /*36*/ TOKENIZER_AND, - /*37*/ TOKENIZER_OR, - /*38*/ TOKENIZER_ASTR, - /*39*/ TOKENIZER_SLASH, - /*40*/ TOKENIZER_MOD, - /*41*/ TOKENIZER_LEFTPAREN, - /*42*/ TOKENIZER_RIGHTPAREN, - /*43*/ TOKENIZER_LT, - /*44*/ TOKENIZER_GT, - /*45*/ TOKENIZER_EQ, - /*46*/ TOKENIZER_EOL, + /*16*/ UBASIC_TOKENIZER_LET, + /*17*/ UBASIC_TOKENIZER_PRINTLN, + /*18*/ UBASIC_TOKENIZER_PRINT, + /*19*/ UBASIC_TOKENIZER_IF, + /*20*/ UBASIC_TOKENIZER_THEN, + /*21*/ UBASIC_TOKENIZER_ELSE, + /*22*/ UBASIC_TOKENIZER_ENDIF, + /*23*/ UBASIC_TOKENIZER_FOR, + /*24*/ UBASIC_TOKENIZER_TO, + /*25*/ UBASIC_TOKENIZER_NEXT, + /*26*/ UBASIC_TOKENIZER_STEP, + /*27*/ UBASIC_TOKENIZER_WHILE, + /*28*/ UBASIC_TOKENIZER_ENDWHILE, + /*29*/ UBASIC_TOKENIZER_GOTO, + /*30*/ UBASIC_TOKENIZER_GOSUB, + /*31*/ UBASIC_TOKENIZER_RETURN, + /*32*/ UBASIC_TOKENIZER_END, + /*33*/ UBASIC_TOKENIZER_COMMA, + /*34*/ UBASIC_TOKENIZER_PLUS, + /*35*/ UBASIC_TOKENIZER_MINUS, + /*36*/ UBASIC_TOKENIZER_AND, + /*37*/ UBASIC_TOKENIZER_OR, + /*38*/ UBASIC_TOKENIZER_ASTR, + /*39*/ UBASIC_TOKENIZER_SLASH, + /*40*/ UBASIC_TOKENIZER_MOD, + /*41*/ UBASIC_TOKENIZER_LEFTPAREN, + /*42*/ UBASIC_TOKENIZER_RIGHTPAREN, + /*43*/ UBASIC_TOKENIZER_LT, + /*44*/ UBASIC_TOKENIZER_GT, + /*45*/ UBASIC_TOKENIZER_EQ, + /*46*/ UBASIC_TOKENIZER_EOL, /* */ /* Plus : Start */ /* */ - /*47*/ TOKENIZER_NE, - /*48*/ TOKENIZER_GE, - /*49*/ TOKENIZER_LE, - /*50*/ TOKENIZER_LAND, - /*51*/ TOKENIZER_LOR, - /*52*/ TOKENIZER_LNOT, - /*53*/ TOKENIZER_NOT, - /*54*/ TOKENIZER_PRINT_HEX, - /*55*/ TOKENIZER_PRINT_DEC, + /*47*/ UBASIC_TOKENIZER_NE, + /*48*/ UBASIC_TOKENIZER_GE, + /*49*/ UBASIC_TOKENIZER_LE, + /*50*/ UBASIC_TOKENIZER_LAND, + /*51*/ UBASIC_TOKENIZER_LOR, + /*52*/ UBASIC_TOKENIZER_LNOT, + /*53*/ UBASIC_TOKENIZER_NOT, + /*54*/ UBASIC_TOKENIZER_PRINT_HEX, + /*55*/ UBASIC_TOKENIZER_PRINT_DEC, #if defined(UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL) - /*56*/ TOKENIZER_INPUT, + /*56*/ UBASIC_TOKENIZER_INPUT, #endif #if defined(UBASIC_SCRIPT_HAVE_SLEEP) - /*57*/ TOKENIZER_SLEEP, + /*57*/ UBASIC_TOKENIZER_SLEEP, #endif #if defined(UBASIC_SCRIPT_HAVE_GPIO_CHANNELS) - /*58*/ TOKENIZER_PINMODE, - /*59*/ TOKENIZER_DREAD, - /*60*/ TOKENIZER_DWRITE, + /*58*/ UBASIC_TOKENIZER_PINMODE, + /*59*/ UBASIC_TOKENIZER_DREAD, + /*60*/ UBASIC_TOKENIZER_DWRITE, #endif -#if defined(VARIABLE_TYPE_ARRAY) - /*61*/ TOKENIZER_DIM, - /*62*/ TOKENIZER_ARRAYVARIABLE, +#if defined(UBASIC_VARIABLE_TYPE_ARRAY) + /*61*/ UBASIC_TOKENIZER_DIM, + /*62*/ UBASIC_TOKENIZER_ARRAYVARIABLE, #endif #if defined(UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR) - /*63*/ TOKENIZER_RAN, + /*63*/ UBASIC_TOKENIZER_RAN, #if defined(UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS) - /*64*/ TOKENIZER_TIC, - /*65*/ TOKENIZER_TOC, + /*64*/ UBASIC_TOKENIZER_TIC, + /*65*/ UBASIC_TOKENIZER_TOC, #endif #endif -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) - /*66*/ TOKENIZER_INT, - /*67*/ TOKENIZER_FLOAT, - /*68*/ TOKENIZER_SQRT, - /*69*/ TOKENIZER_SIN, - /*70*/ TOKENIZER_COS, - /*71*/ TOKENIZER_TAN, - /*72*/ TOKENIZER_EXP, - /*73*/ TOKENIZER_LN, +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) + /*66*/ UBASIC_TOKENIZER_INT, + /*67*/ UBASIC_TOKENIZER_FLOAT, + /*68*/ UBASIC_TOKENIZER_SQRT, + /*69*/ UBASIC_TOKENIZER_SIN, + /*70*/ UBASIC_TOKENIZER_COS, + /*71*/ UBASIC_TOKENIZER_TAN, + /*72*/ UBASIC_TOKENIZER_EXP, + /*73*/ UBASIC_TOKENIZER_LN, #if defined(UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR) - /*74*/ TOKENIZER_UNIFORM, + /*74*/ UBASIC_TOKENIZER_UNIFORM, #endif - /*75*/ TOKENIZER_ABS, - /*76*/ TOKENIZER_FLOOR, - /*77*/ TOKENIZER_CEIL, - /*78*/ TOKENIZER_ROUND, - /*79*/ TOKENIZER_POWER, - /*80*/ TOKENIZER_AVERAGEW, + /*75*/ UBASIC_TOKENIZER_ABS, + /*76*/ UBASIC_TOKENIZER_FLOOR, + /*77*/ UBASIC_TOKENIZER_CEIL, + /*78*/ UBASIC_TOKENIZER_ROUND, + /*79*/ UBASIC_TOKENIZER_POWER, + /*80*/ UBASIC_TOKENIZER_AVERAGEW, #endif #if defined(UBASIC_SCRIPT_HAVE_HARDWARE_EVENTS) - /*81*/ TOKENIZER_HWE, + /*81*/ UBASIC_TOKENIZER_HWE, #endif #if defined(UBASIC_SCRIPT_HAVE_PWM_CHANNELS) - /*82*/ TOKENIZER_PWMCONF, - /*83*/ TOKENIZER_PWM, + /*82*/ UBASIC_TOKENIZER_PWMCONF, + /*83*/ UBASIC_TOKENIZER_PWM, #endif #if defined(UBASIC_SCRIPT_HAVE_ANALOG_READ) - /*84*/ TOKENIZER_AREADCONF, - /*85*/ TOKENIZER_AREAD, + /*84*/ UBASIC_TOKENIZER_AREADCONF, + /*85*/ UBASIC_TOKENIZER_AREAD, #endif - /*86*/ TOKENIZER_LABEL, - /*87*/ TOKENIZER_COLON, + /*86*/ UBASIC_TOKENIZER_LABEL, + /*87*/ UBASIC_TOKENIZER_COLON, #if defined(UBASIC_SCRIPT_HAVE_STORE_VARS_IN_FLASH) - /*88*/ TOKENIZER_STORE, - /*89*/ TOKENIZER_RECALL, + /*88*/ UBASIC_TOKENIZER_STORE, + /*89*/ UBASIC_TOKENIZER_RECALL, #endif #if defined(UBASIC_SCRIPT_HAVE_BACNET) - /*90*/ TOKENIZER_BACNET_CREATE_OBJECT, - /*91*/ TOKENIZER_BACNET_READ_PROPERTY, - /*92*/ TOKENIZER_BACNET_WRITE_PROPERTY, + /*90*/ UBASIC_TOKENIZER_BACNET_CREATE_OBJECT, + /*91*/ UBASIC_TOKENIZER_BACNET_READ_PROPERTY, + /*92*/ UBASIC_TOKENIZER_BACNET_WRITE_PROPERTY, #endif - /*93*/ TOKENIZER_CLEAR, + /*93*/ UBASIC_TOKENIZER_CLEAR, /* */ /* Plus: End */ /* */ }; -struct tokenizer_data { +struct ubasic_tokenizer { const char *ptr; const char *nextptr; const char *prog; uint8_t current_token; }; -void tokenizer_init(struct tokenizer_data *data, const char *program); -void tokenizer_next(struct tokenizer_data *data); -uint8_t tokenizer_token(struct tokenizer_data *data); -VARIABLE_TYPE tokenizer_num(struct tokenizer_data *data); -VARIABLE_TYPE tokenizer_int(struct tokenizer_data *data); +void tokenizer_init(struct ubasic_tokenizer *data, const char *program); +void tokenizer_next(struct ubasic_tokenizer *data); +uint8_t tokenizer_token(struct ubasic_tokenizer *data); +UBASIC_VARIABLE_TYPE tokenizer_num(struct ubasic_tokenizer *data); +UBASIC_VARIABLE_TYPE tokenizer_int(struct ubasic_tokenizer *data); #ifdef FIXEDPT_FBITS -VARIABLE_TYPE tokenizer_float(struct tokenizer_data *data); +UBASIC_VARIABLE_TYPE tokenizer_float(struct ubasic_tokenizer *data); #endif -uint8_t tokenizer_variable_num(struct tokenizer_data *data); -bool tokenizer_finished(struct tokenizer_data *data); +uint8_t tokenizer_variable_num(struct ubasic_tokenizer *data); +bool tokenizer_finished(struct ubasic_tokenizer *data); -#if defined(VARIABLE_TYPE_STRING) -void tokenizer_string(struct tokenizer_data *data, char *dest, uint8_t len); -int8_t tokenizer_stringlookahead(struct tokenizer_data *data); +#if defined(UBASIC_VARIABLE_TYPE_STRING) +void tokenizer_string(struct ubasic_tokenizer *data, char *dest, uint8_t len); +int8_t tokenizer_stringlookahead(struct ubasic_tokenizer *data); #endif -void tokenizer_label(struct tokenizer_data *data, char *dest, uint8_t len); -uint16_t tokenizer_save_offset(struct tokenizer_data *data); -void tokenizer_jump_offset(struct tokenizer_data *data, uint16_t offset); +void tokenizer_label(struct ubasic_tokenizer *data, char *dest, uint8_t len); +uint16_t tokenizer_save_offset(struct ubasic_tokenizer *data); +void tokenizer_jump_offset(struct ubasic_tokenizer *data, uint16_t offset); -const char *tokenizer_name(VARIABLE_TYPE token); +const char *tokenizer_name(UBASIC_VARIABLE_TYPE token); -#endif /* __TOKENIZER_H__ */ +#endif diff --git a/src/bacnet/basic/program/ubasic/ubasic.c b/src/bacnet/basic/program/ubasic/ubasic.c index 784761f4..a711a1df 100644 --- a/src/bacnet/basic/program/ubasic/ubasic.c +++ b/src/bacnet/basic/program/ubasic/ubasic.c @@ -38,26 +38,26 @@ #include "ubasic.h" #include "tokenizer.h" -#if defined(VARIABLE_TYPE_STRING) +#if defined(UBASIC_VARIABLE_TYPE_STRING) static int16_t sexpr(struct ubasic_data *data); static int16_t scpy(struct ubasic_data *data, char *); static int16_t sconcat(struct ubasic_data *data, char *, char *); static int16_t sleft(struct ubasic_data *data, char *, int16_t); static int16_t sright(struct ubasic_data *data, char *, int16_t); static int16_t smid(struct ubasic_data *data, char *, int16_t, int16_t); -static int16_t sstr(struct ubasic_data *data, VARIABLE_TYPE j); -static int16_t schr(struct ubasic_data *data, VARIABLE_TYPE j); +static int16_t sstr(struct ubasic_data *data, UBASIC_VARIABLE_TYPE j); +static int16_t schr(struct ubasic_data *data, UBASIC_VARIABLE_TYPE j); static uint8_t sinstr(uint16_t, char *, char *); static char *strptr(struct ubasic_data *data, int16_t size) { return ((char *)((data->stringstack) + (size) + 1)); } #endif -static VARIABLE_TYPE relation(struct ubasic_data *data); +static UBASIC_VARIABLE_TYPE relation(struct ubasic_data *data); static void subsequent_statement(struct ubasic_data *data); static void statement(struct ubasic_data *data); #if defined(UBASIC_SCRIPT_HAVE_STORE_VARS_IN_FLASH) -static VARIABLE_TYPE recall_statement(struct ubasic_data *data); +static UBASIC_VARIABLE_TYPE recall_statement(struct ubasic_data *data); #endif /*---------------------------------------------------------------------------*/ @@ -305,19 +305,19 @@ static void bacnet_write_property( uint16_t object_type, uint32_t instance, uint32_t property_id, - VARIABLE_TYPE value) + UBASIC_VARIABLE_TYPE value) { if (data->bacnet_write_property) { data->bacnet_write_property(object_type, instance, property_id, value); } } -static VARIABLE_TYPE bacnet_read_property( +static UBASIC_VARIABLE_TYPE bacnet_read_property( struct ubasic_data *data, uint16_t object_type, uint32_t instance, uint32_t property_id) { - VARIABLE_TYPE value = 0; + UBASIC_VARIABLE_TYPE value = 0; if (data->bacnet_read_property) { value = data->bacnet_read_property(object_type, instance, property_id); @@ -328,7 +328,7 @@ static VARIABLE_TYPE bacnet_read_property( #endif /*---------------------------------------------------------------------------*/ -#if defined(UBASIC_SCRIPT_PRINT_TO_SERIAL) +#if defined(UBASIC_SCRIPT_HAVE_PRINT_TO_SERIAL) static void serial_write(struct ubasic_data *data, const char *buffer, uint16_t n) { @@ -339,7 +339,7 @@ serial_write(struct ubasic_data *data, const char *buffer, uint16_t n) #endif static void serial_write_string(struct ubasic_data *data, const char *msg) { -#if defined(UBASIC_SCRIPT_PRINT_TO_SERIAL) +#if defined(UBASIC_SCRIPT_HAVE_PRINT_TO_SERIAL) serial_write(data, msg, strlen(msg)); #endif } @@ -359,7 +359,7 @@ int ubasic_printf(struct ubasic_data *data, const char *format, ...) va_start(ap, format); length = vsnprintf(buffer, sizeof(buffer), format, ap); -#if defined(UBASIC_SCRIPT_PRINT_TO_SERIAL) +#if defined(UBASIC_SCRIPT_HAVE_PRINT_TO_SERIAL) serial_write(data, buffer, length); #endif va_end(ap); @@ -381,23 +381,23 @@ int ubasic_getc(struct ubasic_data *data) void ubasic_clear_variables(struct ubasic_data *data) { int16_t i; - for (i = 0; i < MAX_VARNUM; i++) { + for (i = 0; i < UBASIC_VARNUM_MAX; i++) { data->variables[i] = 0; -#if defined(VARIABLE_TYPE_ARRAY) +#if defined(UBASIC_VARIABLE_TYPE_ARRAY) data->arrayvariable[i] = -1; #endif } -#if defined(VARIABLE_TYPE_ARRAY) +#if defined(UBASIC_VARIABLE_TYPE_ARRAY) data->free_arrayptr = 0; - for (i = 0; i < VARIABLE_TYPE_ARRAY; i++) { + for (i = 0; i < UBASIC_VARIABLE_TYPE_ARRAY; i++) { data->arrays_data[i] = 0; } #endif -#if defined(VARIABLE_TYPE_STRING) +#if defined(UBASIC_VARIABLE_TYPE_STRING) data->freebufptr = 0; - for (i = 0; i < MAX_SVARNUM; i++) { + for (i = 0; i < UBASIC_STRING_VAR_LEN_MAX; i++) { data->stringvariables[i] = -1; } #endif @@ -405,30 +405,31 @@ void ubasic_clear_variables(struct ubasic_data *data) /*---------------------------------------------------------------------------*/ -static void -ubasic_set_varnum(struct ubasic_data *data, uint8_t varnum, VARIABLE_TYPE value) +static void ubasic_set_varnum( + struct ubasic_data *data, uint8_t varnum, UBASIC_VARIABLE_TYPE value) { - if (varnum < MAX_VARNUM) { + if (varnum < UBASIC_VARNUM_MAX) { data->variables[varnum] = value; } } -static VARIABLE_TYPE ubasic_get_varnum(struct ubasic_data *data, uint8_t varnum) +static UBASIC_VARIABLE_TYPE +ubasic_get_varnum(struct ubasic_data *data, uint8_t varnum) { - if (varnum < MAX_VARNUM) { + if (varnum < UBASIC_VARNUM_MAX) { return data->variables[varnum]; } return 0; } -#if defined(VARIABLE_TYPE_ARRAY) +#if defined(UBASIC_VARIABLE_TYPE_ARRAY) /** * @brief Allocate an array variable * @param data Pointer to the ubasic data structure * @param varnum The variable number * @param newsize The new size of the array * @note - * array additions: works only for VARIABLE_TYPE 32bit + * array additions: works only for UBASIC_VARIABLE_TYPE 32bit * array storage: * 1st entry: [ 31:16 , 15:0] * varnum size @@ -441,14 +442,14 @@ static void ubasic_dim_arrayvarnum( int16_t oldsize; int16_t current_location; - if (varnum >= MAX_VARNUM) { + if (varnum >= UBASIC_VARNUM_MAX) { return; } _attach_at_the_end: current_location = data->arrayvariable[varnum]; if (current_location == -1) { /* does the array fit in the available memory? */ - if ((data->free_arrayptr + newsize + 1) < VARIABLE_TYPE_ARRAY) { + if ((data->free_arrayptr + newsize + 1) < UBASIC_VARIABLE_TYPE_ARRAY) { current_location = data->free_arrayptr; data->arrayvariable[varnum] = current_location; data->arrays_data[current_location] = (varnum << 16) | newsize; @@ -466,7 +467,7 @@ _attach_at_the_end: /* if this is the last array in arrays_data, just modify the boundary */ if (current_location + oldsize + 1 == data->free_arrayptr) { if ((data->free_arrayptr - current_location + newsize) < - VARIABLE_TYPE_ARRAY) { + UBASIC_VARIABLE_TYPE_ARRAY) { data->arrays_data[current_location] = (varnum << 16) | newsize; data->free_arrayptr += (newsize - oldsize); data->arrays_data[data->free_arrayptr] = 0; @@ -504,18 +505,21 @@ _attach_at_the_end: } static void ubasic_set_arrayvarnum( - struct ubasic_data *data, uint8_t varnum, uint16_t idx, VARIABLE_TYPE value) + struct ubasic_data *data, + uint8_t varnum, + uint16_t idx, + UBASIC_VARIABLE_TYPE value) { int16_t array; - if (varnum >= MAX_VARNUM) { + if (varnum >= UBASIC_VARNUM_MAX) { return; } array = data->arrayvariable[varnum]; if (array < 0) { return; } - if (array >= VARIABLE_TYPE_ARRAY) { + if (array >= UBASIC_VARIABLE_TYPE_ARRAY) { return; } uint16_t size = (uint16_t)data->arrays_data[array]; @@ -526,26 +530,26 @@ static void ubasic_set_arrayvarnum( data->arrays_data[array + idx] = value; } -static VARIABLE_TYPE +static UBASIC_VARIABLE_TYPE ubasic_get_arrayvarnum(struct ubasic_data *data, uint8_t varnum, uint16_t idx) { int16_t array; - if (varnum >= MAX_VARNUM) { + if (varnum >= UBASIC_VARNUM_MAX) { return -1; } array = data->arrayvariable[varnum]; if (array < 0) { return -1; } - if (array >= VARIABLE_TYPE_ARRAY) { + if (array >= UBASIC_VARIABLE_TYPE_ARRAY) { return -1; } uint16_t size = (uint16_t)data->arrays_data[array]; if ((size < idx) || (idx < 1)) { return -1; } - return (VARIABLE_TYPE)data->arrays_data[array + idx]; + return (UBASIC_VARIABLE_TYPE)data->arrays_data[array + idx]; } #endif @@ -564,11 +568,12 @@ void ubasic_load_program(struct ubasic_data *data, const char *program) } } /*---------------------------------------------------------------------------*/ -static void token_error_print(struct ubasic_data *data, VARIABLE_TYPE token) +static void +token_error_print(struct ubasic_data *data, UBASIC_VARIABLE_TYPE token) { char msg[32]; const char *name; - struct tokenizer_data *tree = &data->tree; + struct ubasic_tokenizer *tree = &data->tree; serial_write_string(data, "Err"); name = tokenizer_name(token); @@ -583,9 +588,9 @@ static void token_error_print(struct ubasic_data *data, VARIABLE_TYPE token) } /*---------------------------------------------------------------------------*/ -static uint8_t accept(struct ubasic_data *data, VARIABLE_TYPE token) +static uint8_t accept(struct ubasic_data *data, UBASIC_VARIABLE_TYPE token) { - struct tokenizer_data *tree = &data->tree; + struct ubasic_tokenizer *tree = &data->tree; if (token != tokenizer_token(tree)) { token_error_print(data, token); @@ -597,20 +602,20 @@ static uint8_t accept(struct ubasic_data *data, VARIABLE_TYPE token) } /*---------------------------------------------------------------------------*/ -static void accept_cr(struct tokenizer_data *tree) +static void accept_cr(struct ubasic_tokenizer *tree) { - while ((tokenizer_token(tree) != TOKENIZER_EOL) && - (tokenizer_token(tree) != TOKENIZER_ERROR) && - (tokenizer_token(tree) != TOKENIZER_ENDOFINPUT)) { + while ((tokenizer_token(tree) != UBASIC_TOKENIZER_EOL) && + (tokenizer_token(tree) != UBASIC_TOKENIZER_ERROR) && + (tokenizer_token(tree) != UBASIC_TOKENIZER_ENDOFINPUT)) { tokenizer_next(tree); } - if (tokenizer_token(tree) == TOKENIZER_EOL) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_EOL) { tokenizer_next(tree); } } -#if defined(VARIABLE_TYPE_STRING) +#if defined(UBASIC_VARIABLE_TYPE_STRING) /*---------------------------------------------------------------------------*/ static uint8_t string_space_check(struct ubasic_data *data, uint16_t l) @@ -618,7 +623,7 @@ static uint8_t string_space_check(struct ubasic_data *data, uint16_t l) /* returns true if not enough room for new string */ uint8_t i; i = - ((MAX_BUFFERLEN - data->freebufptr) <= + ((UBASIC_STRING_BUFFER_LEN_MAX - data->freebufptr) <= (l + 2)); /* +2 to play it safe */ if (i) { data->status.bit.isRunning = 0; @@ -814,7 +819,7 @@ static int16_t smid( /*---------------------------------------------------------------------------*/ static int16_t sstr( struct ubasic_data *data, - VARIABLE_TYPE j) /* return the integer j as a string */ + UBASIC_VARIABLE_TYPE j) /* return the integer j as a string */ { int16_t bp = data->freebufptr; int16_t rp = bp; @@ -837,7 +842,7 @@ static int16_t sstr( /*---------------------------------------------------------------------------*/ static int16_t schr( struct ubasic_data *data, - VARIABLE_TYPE j) /* return the character whose ASCII code is j */ + UBASIC_VARIABLE_TYPE j) /* return the character whose ASCII code is j */ { int16_t bp = data->freebufptr; int16_t rp = bp; @@ -877,90 +882,90 @@ static int16_t sfactor(struct ubasic_data *data) { /* string form of factor */ int16_t r = 0, s = 0; - char tmpstring[MAX_STRINGLEN]; - VARIABLE_TYPE i, j; - struct tokenizer_data *tree = &data->tree; + char tmpstring[UBASIC_STRINGLEN_MAX]; + UBASIC_VARIABLE_TYPE i, j; + struct ubasic_tokenizer *tree = &data->tree; switch (tokenizer_token(tree)) { - case TOKENIZER_LEFTPAREN: - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_LEFTPAREN: + accept(data, UBASIC_TOKENIZER_LEFTPAREN); r = sexpr(data); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; - case TOKENIZER_STRING: - tokenizer_string(tree, tmpstring, MAX_STRINGLEN); + case UBASIC_TOKENIZER_STRING: + tokenizer_string(tree, tmpstring, UBASIC_STRINGLEN_MAX); r = scpy(data, tmpstring); - accept(data, TOKENIZER_STRING); + accept(data, UBASIC_TOKENIZER_STRING); break; - case TOKENIZER_LEFT_STR: - accept(data, TOKENIZER_LEFT_STR); - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_LEFT_STR: + accept(data, UBASIC_TOKENIZER_LEFT_STR); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); s = sexpr(data); - accept(data, TOKENIZER_COMMA); + accept(data, UBASIC_TOKENIZER_COMMA); i = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) i = fixedpt_toint(i); #endif r = sleft(data, strptr(data, s), i); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; - case TOKENIZER_RIGHT_STR: - accept(data, TOKENIZER_RIGHT_STR); - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_RIGHT_STR: + accept(data, UBASIC_TOKENIZER_RIGHT_STR); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); s = sexpr(data); - accept(data, TOKENIZER_COMMA); + accept(data, UBASIC_TOKENIZER_COMMA); i = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) i = fixedpt_toint(i); #endif r = sright(data, strptr(data, s), i); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; - case TOKENIZER_MID_STR: - accept(data, TOKENIZER_MID_STR); - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_MID_STR: + accept(data, UBASIC_TOKENIZER_MID_STR); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); s = sexpr(data); - accept(data, TOKENIZER_COMMA); + accept(data, UBASIC_TOKENIZER_COMMA); i = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) i = fixedpt_toint(i); #endif - if (tokenizer_token(tree) == TOKENIZER_COMMA) { - accept(data, TOKENIZER_COMMA); + if (tokenizer_token(tree) == UBASIC_TOKENIZER_COMMA) { + accept(data, UBASIC_TOKENIZER_COMMA); j = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) j = fixedpt_toint(j); #endif } else { j = 999; /* ensure we get all of it */ } r = smid(data, strptr(data, s), i, j); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; - case TOKENIZER_STR_STR: - accept(data, TOKENIZER_STR_STR); + case UBASIC_TOKENIZER_STR_STR: + accept(data, UBASIC_TOKENIZER_STR_STR); j = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) j = fixedpt_toint(j); #endif r = sstr(data, j); break; - case TOKENIZER_CHR_STR: - accept(data, TOKENIZER_CHR_STR); + case UBASIC_TOKENIZER_CHR_STR: + accept(data, UBASIC_TOKENIZER_CHR_STR); j = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) j = fixedpt_toint(j); #endif if (j < 0 || j > 255) { @@ -971,7 +976,7 @@ static int16_t sfactor(struct ubasic_data *data) default: r = ubasic_get_stringvariable(data, tokenizer_variable_num(tree)); - accept(data, TOKENIZER_STRINGVARIABLE); + accept(data, UBASIC_TOKENIZER_STRINGVARIABLE); } return r; @@ -984,7 +989,7 @@ static int16_t sexpr(struct ubasic_data *data) /* string form of expr */ int16_t s1, s2; s1 = sfactor(data); uint8_t op = tokenizer_token(&data->tree); - while (op == TOKENIZER_PLUS) { + while (op == UBASIC_TOKENIZER_PLUS) { tokenizer_next(&data->tree); s2 = sfactor(data); s1 = sconcat(data, strptr(data, s1), strptr(data, s2)); @@ -1001,7 +1006,7 @@ slogexpr(struct ubasic_data *data) /* string logical expression */ s1 = sexpr(data); uint8_t op = tokenizer_token(&data->tree); tokenizer_next(&data->tree); - if (op == TOKENIZER_EQ) { + if (op == UBASIC_TOKENIZER_EQ) { s2 = sexpr(data); r = (strcmp(strptr(data, s1), strptr(data, s2)) == 0); } @@ -1011,44 +1016,44 @@ slogexpr(struct ubasic_data *data) /* string logical expression */ #endif /*---------------------------------------------------------------------------*/ -static VARIABLE_TYPE varfactor(struct ubasic_data *data) +static UBASIC_VARIABLE_TYPE varfactor(struct ubasic_data *data) { - VARIABLE_TYPE r; - struct tokenizer_data *tree = &data->tree; + UBASIC_VARIABLE_TYPE r; + struct ubasic_tokenizer *tree = &data->tree; r = ubasic_get_varnum(data, tokenizer_variable_num(tree)); - accept(data, TOKENIZER_VARIABLE); + accept(data, UBASIC_TOKENIZER_VARIABLE); return r; } /*---------------------------------------------------------------------------*/ -static VARIABLE_TYPE factor(struct ubasic_data *data) +static UBASIC_VARIABLE_TYPE factor(struct ubasic_data *data) { - VARIABLE_TYPE r; - VARIABLE_TYPE i, j, k; -#if defined(VARIABLE_TYPE_ARRAY) + UBASIC_VARIABLE_TYPE r; + UBASIC_VARIABLE_TYPE i, j, k; +#if defined(UBASIC_VARIABLE_TYPE_ARRAY) uint8_t varnum; #endif -#if defined(VARIABLE_TYPE_STRING) +#if defined(UBASIC_VARIABLE_TYPE_STRING) int16_t s, s1; #endif - struct tokenizer_data *tree = &data->tree; + struct ubasic_tokenizer *tree = &data->tree; switch (tokenizer_token(tree)) { -#if defined(VARIABLE_TYPE_STRING) - case TOKENIZER_LEN: - accept(data, TOKENIZER_LEN); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_STRING) + case UBASIC_TOKENIZER_LEN: + accept(data, UBASIC_TOKENIZER_LEN); +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) r = fixedpt_fromint(strlen(strptr(data, sexpr(data)))); #else r = strlen(strptr(data, sexpr(data))); #endif break; - case TOKENIZER_VAL: - accept(data, TOKENIZER_VAL); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) + case UBASIC_TOKENIZER_VAL: + accept(data, UBASIC_TOKENIZER_VAL); +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) s1 = sexpr(data); r = str_fixedpt(strptr(data, s1), strlen(strptr(data, s1)), 3); #else @@ -1056,88 +1061,88 @@ static VARIABLE_TYPE factor(struct ubasic_data *data) #endif break; - case TOKENIZER_ASC: - accept(data, TOKENIZER_ASC); + case UBASIC_TOKENIZER_ASC: + accept(data, UBASIC_TOKENIZER_ASC); s = sexpr(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) r = fixedpt_fromint(*strptr(data, s)); #else r = *strptr(data, s); #endif break; - case TOKENIZER_INSTR: - accept(data, TOKENIZER_INSTR); - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_INSTR: + accept(data, UBASIC_TOKENIZER_INSTR); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); j = 1; - if (tokenizer_token(tree) == TOKENIZER_NUMBER) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_NUMBER) { j = tokenizer_num(tree); - accept(data, TOKENIZER_NUMBER); - accept(data, TOKENIZER_COMMA); + accept(data, UBASIC_TOKENIZER_NUMBER); + accept(data, UBASIC_TOKENIZER_COMMA); } if (j < 1) { return 0; } s = sexpr(data); - accept(data, TOKENIZER_COMMA); + accept(data, UBASIC_TOKENIZER_COMMA); s1 = sexpr(data); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); r = sinstr(j, strptr(data, s), strptr(data, s1)); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) r = fixedpt_fromint(r); #endif break; #endif - case TOKENIZER_MINUS: - accept(data, TOKENIZER_MINUS); + case UBASIC_TOKENIZER_MINUS: + accept(data, UBASIC_TOKENIZER_MINUS); r = -factor(data); break; - case TOKENIZER_LNOT: - accept(data, TOKENIZER_LNOT); + case UBASIC_TOKENIZER_LNOT: + accept(data, UBASIC_TOKENIZER_LNOT); r = !relation(data); break; - case TOKENIZER_NOT: - accept(data, TOKENIZER_LNOT); + case UBASIC_TOKENIZER_NOT: + accept(data, UBASIC_TOKENIZER_LNOT); r = ~relation(data); break; #if defined(UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS) - case TOKENIZER_TOC: - accept(data, TOKENIZER_TOC); - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_TOC: + accept(data, UBASIC_TOKENIZER_TOC); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); r = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) r = fixedpt_toint(r); #endif r = timer_toc(data, r); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) r = fixedpt_fromint(r); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); #endif break; #endif #if defined(UBASIC_SCRIPT_HAVE_HARDWARE_EVENTS) - case TOKENIZER_HWE: - accept(data, TOKENIZER_HWE); - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_HWE: + accept(data, UBASIC_TOKENIZER_HWE); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); r = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) r = fixedpt_toint(r); #endif if (r) { if (hw_event(data, r - 1)) { hw_event_clear(data, r - 1); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) r = FIXEDPT_ONE; #else r = 1; @@ -1146,15 +1151,15 @@ static VARIABLE_TYPE factor(struct ubasic_data *data) r = 0; } } - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; #endif /* #if defined(UBASIC_SCRIPT_HAVE_HARDWARE_EVENTS) */ #if defined(UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR) - case TOKENIZER_RAN: - accept(data, TOKENIZER_RAN); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) + case UBASIC_TOKENIZER_RAN: + accept(data, UBASIC_TOKENIZER_RAN); +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) r = random_uint32(data, FIXEDPT_WBITS); r = fixedpt_fromint(r); #else @@ -1164,143 +1169,143 @@ static VARIABLE_TYPE factor(struct ubasic_data *data) break; #endif - case TOKENIZER_ABS: - accept(data, TOKENIZER_ABS); - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_ABS: + accept(data, UBASIC_TOKENIZER_ABS); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); r = relation(data); r = fixedpt_abs(r); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) - case TOKENIZER_AVERAGEW: - accept(data, TOKENIZER_AVERAGEW); - accept(data, TOKENIZER_LEFTPAREN); +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) + case UBASIC_TOKENIZER_AVERAGEW: + accept(data, UBASIC_TOKENIZER_AVERAGEW); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); /* latest_reading */ i = relation(data); - accept(data, TOKENIZER_COMMA); + accept(data, UBASIC_TOKENIZER_COMMA); /* previous_average */ j = relation(data); - accept(data, TOKENIZER_COMMA); + accept(data, UBASIC_TOKENIZER_COMMA); /* nsamples */ k = relation(data); r = fixedpt_averagew(i, j, k); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; - case TOKENIZER_POWER: - accept(data, TOKENIZER_POWER); - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_POWER: + accept(data, UBASIC_TOKENIZER_POWER); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); /* argument: */ i = relation(data); - accept(data, TOKENIZER_COMMA); + accept(data, UBASIC_TOKENIZER_COMMA); /* exponent */ j = relation(data); r = fixedpt_pow(i, j); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; - case TOKENIZER_FLOAT: + case UBASIC_TOKENIZER_FLOAT: r = tokenizer_float(tree); /* 24.8 decimal number */ - accept(data, TOKENIZER_FLOAT); + accept(data, UBASIC_TOKENIZER_FLOAT); break; - case TOKENIZER_SQRT: - accept(data, TOKENIZER_SQRT); - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_SQRT: + accept(data, UBASIC_TOKENIZER_SQRT); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); r = fixedpt_sqrt(relation(data)); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; - case TOKENIZER_SIN: - accept(data, TOKENIZER_SIN); - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_SIN: + accept(data, UBASIC_TOKENIZER_SIN); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); r = fixedpt_sin(relation(data)); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; - case TOKENIZER_COS: - accept(data, TOKENIZER_COS); - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_COS: + accept(data, UBASIC_TOKENIZER_COS); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); r = fixedpt_cos(relation(data)); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; - case TOKENIZER_TAN: - accept(data, TOKENIZER_TAN); - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_TAN: + accept(data, UBASIC_TOKENIZER_TAN); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); r = fixedpt_tan(relation(data)); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; - case TOKENIZER_EXP: - accept(data, TOKENIZER_EXP); - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_EXP: + accept(data, UBASIC_TOKENIZER_EXP); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); r = fixedpt_exp(relation(data)); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; - case TOKENIZER_LN: - accept(data, TOKENIZER_LN); - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_LN: + accept(data, UBASIC_TOKENIZER_LN); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); r = fixedpt_ln(relation(data)); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; #if defined(UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR) - case TOKENIZER_UNIFORM: - accept(data, TOKENIZER_UNIFORM); + case UBASIC_TOKENIZER_UNIFORM: + accept(data, UBASIC_TOKENIZER_UNIFORM); r = random_uint32(data, FIXEDPT_FBITS) & FIXEDPT_FMASK; break; #endif - case TOKENIZER_FLOOR: - accept(data, TOKENIZER_FLOOR); - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_FLOOR: + accept(data, UBASIC_TOKENIZER_FLOOR); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); r = relation(data); r = fixedpt_floor(r); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; - case TOKENIZER_CEIL: - accept(data, TOKENIZER_CEIL); - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_CEIL: + accept(data, UBASIC_TOKENIZER_CEIL); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); r = relation(data); r = fixedpt_ceil(r); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; - case TOKENIZER_ROUND: - accept(data, TOKENIZER_ROUND); - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_ROUND: + accept(data, UBASIC_TOKENIZER_ROUND); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); r = relation(data); r = fixedpt_round(r); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; -#endif /* #if defined(VARIABLE_TYPE_FLOAT_AS ... */ +#endif /* #if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS ... */ - case TOKENIZER_INT: + case UBASIC_TOKENIZER_INT: r = tokenizer_int(tree); - accept(data, TOKENIZER_INT); + accept(data, UBASIC_TOKENIZER_INT); break; - case TOKENIZER_NUMBER: + case UBASIC_TOKENIZER_NUMBER: r = tokenizer_num(tree); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) r = fixedpt_fromint(r); #endif - accept(data, TOKENIZER_NUMBER); + accept(data, UBASIC_TOKENIZER_NUMBER); break; #ifdef UBASIC_SCRIPT_HAVE_PWM_CHANNELS - case TOKENIZER_PWM: - accept(data, TOKENIZER_PWM); - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_PWM: + accept(data, UBASIC_TOKENIZER_PWM); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); /* single argument: channel */ j = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) j = fixedpt_toint(j); #endif if (data->pwm_read) { @@ -1308,46 +1313,46 @@ static VARIABLE_TYPE factor(struct ubasic_data *data) } else { r = 0; } -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) r = fixedpt_fromint(r); #endif - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; #endif #if defined(UBASIC_SCRIPT_HAVE_ANALOG_READ) - case TOKENIZER_AREAD: - accept(data, TOKENIZER_AREAD); - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_AREAD: + accept(data, UBASIC_TOKENIZER_AREAD); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); /* single argument: channel as hex value */ j = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) j = fixedpt_toint(j); #endif r = adc_read(data, (uint8_t)j); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) r = fixedpt_fromint(r); #endif - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; #endif - case TOKENIZER_LEFTPAREN: - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_LEFTPAREN: + accept(data, UBASIC_TOKENIZER_LEFTPAREN); r = relation(data); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; -#if defined(VARIABLE_TYPE_ARRAY) - case TOKENIZER_ARRAYVARIABLE: +#if defined(UBASIC_VARIABLE_TYPE_ARRAY) + case UBASIC_TOKENIZER_ARRAYVARIABLE: varnum = tokenizer_variable_num(tree); - accept(data, TOKENIZER_ARRAYVARIABLE); + accept(data, UBASIC_TOKENIZER_ARRAYVARIABLE); j = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) j = fixedpt_toint(j); #endif r = ubasic_get_arrayvarnum(data, varnum, (uint16_t)j); @@ -1355,47 +1360,47 @@ static VARIABLE_TYPE factor(struct ubasic_data *data) #endif #if defined(UBASIC_SCRIPT_HAVE_GPIO_CHANNELS) - case TOKENIZER_DREAD: - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_DREAD: + accept(data, UBASIC_TOKENIZER_LEFTPAREN); r = relation(data); r = gpio_read(data, (uint8_t)r); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; #endif #if defined(UBASIC_SCRIPT_HAVE_STORE_VARS_IN_FLASH) - case TOKENIZER_RECALL: + case UBASIC_TOKENIZER_RECALL: r = recall_statement(data); break; #endif #if defined(UBASIC_SCRIPT_HAVE_BACNET) - case TOKENIZER_BACNET_READ_PROPERTY: - accept(data, TOKENIZER_BACNET_READ_PROPERTY); - accept(data, TOKENIZER_LEFTPAREN); + case UBASIC_TOKENIZER_BACNET_READ_PROPERTY: + accept(data, UBASIC_TOKENIZER_BACNET_READ_PROPERTY); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); /* first argument: object type 0..1023 */ j = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) j = fixedpt_toint(j); #endif - accept(data, TOKENIZER_COMMA); + accept(data, UBASIC_TOKENIZER_COMMA); i = relation(data); /* second argument: instance 0..4194303 */ -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) i = fixedpt_toint(i); #endif - accept(data, TOKENIZER_COMMA); + accept(data, UBASIC_TOKENIZER_COMMA); /* property */ /* second argument: property 0..4194303 */ k = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) k = fixedpt_toint(k); #endif r = bacnet_read_property( data, (uint16_t)j, (uint32_t)i, (uint32_t)k); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); break; #endif default: @@ -1408,43 +1413,43 @@ static VARIABLE_TYPE factor(struct ubasic_data *data) /*---------------------------------------------------------------------------*/ -static VARIABLE_TYPE term(struct ubasic_data *data) +static UBASIC_VARIABLE_TYPE term(struct ubasic_data *data) { - VARIABLE_TYPE f1, f2; - struct tokenizer_data *tree = &data->tree; + UBASIC_VARIABLE_TYPE f1, f2; + struct ubasic_tokenizer *tree = &data->tree; -#if defined(VARIABLE_TYPE_STRING) +#if defined(UBASIC_VARIABLE_TYPE_STRING) if (tokenizer_stringlookahead(tree)) { f1 = slogexpr(data); } else #endif { f1 = factor(data); - VARIABLE_TYPE op = tokenizer_token(tree); - while (op == TOKENIZER_ASTR || op == TOKENIZER_SLASH || - op == TOKENIZER_MOD) { + UBASIC_VARIABLE_TYPE op = tokenizer_token(tree); + while (op == UBASIC_TOKENIZER_ASTR || op == UBASIC_TOKENIZER_SLASH || + op == UBASIC_TOKENIZER_MOD) { tokenizer_next(tree); f2 = factor(data); switch (op) { - case TOKENIZER_ASTR: -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) + case UBASIC_TOKENIZER_ASTR: +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) f1 = fixedpt_xmul(f1, f2); #else f1 = f1 * f2; #endif break; - case TOKENIZER_SLASH: -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) + case UBASIC_TOKENIZER_SLASH: +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) f1 = fixedpt_xdiv(f1, f2); #else f1 = f1 / f2; #endif break; - case TOKENIZER_MOD: + case UBASIC_TOKENIZER_MOD: f1 = f1 % f2; break; default: @@ -1456,68 +1461,69 @@ static VARIABLE_TYPE term(struct ubasic_data *data) return f1; } /*---------------------------------------------------------------------------*/ -static VARIABLE_TYPE relation(struct ubasic_data *data) +static UBASIC_VARIABLE_TYPE relation(struct ubasic_data *data) { - VARIABLE_TYPE r1, r2; + UBASIC_VARIABLE_TYPE r1, r2; - r1 = (VARIABLE_TYPE)term(data); + r1 = (UBASIC_VARIABLE_TYPE)term(data); - VARIABLE_TYPE op = tokenizer_token(&data->tree); + UBASIC_VARIABLE_TYPE op = tokenizer_token(&data->tree); - while (op == TOKENIZER_LT || op == TOKENIZER_LE || op == TOKENIZER_GT || - op == TOKENIZER_GE || op == TOKENIZER_EQ || op == TOKENIZER_NE || - op == TOKENIZER_LAND || op == TOKENIZER_LOR || - op == TOKENIZER_PLUS || op == TOKENIZER_MINUS || - op == TOKENIZER_AND || op == TOKENIZER_OR) { + while (op == UBASIC_TOKENIZER_LT || op == UBASIC_TOKENIZER_LE || + op == UBASIC_TOKENIZER_GT || op == UBASIC_TOKENIZER_GE || + op == UBASIC_TOKENIZER_EQ || op == UBASIC_TOKENIZER_NE || + op == UBASIC_TOKENIZER_LAND || op == UBASIC_TOKENIZER_LOR || + op == UBASIC_TOKENIZER_PLUS || op == UBASIC_TOKENIZER_MINUS || + op == UBASIC_TOKENIZER_AND || op == UBASIC_TOKENIZER_OR) { tokenizer_next(&data->tree); - r2 = (VARIABLE_TYPE)term(data); + r2 = (UBASIC_VARIABLE_TYPE)term(data); switch (op) { - case TOKENIZER_LE: + case UBASIC_TOKENIZER_LE: r1 = (r1 <= r2); break; - case TOKENIZER_LT: + case UBASIC_TOKENIZER_LT: r1 = (r1 < r2); break; - case TOKENIZER_GT: + case UBASIC_TOKENIZER_GT: r1 = (r1 > r2); break; - case TOKENIZER_GE: + case UBASIC_TOKENIZER_GE: r1 = (r1 >= r2); break; - case TOKENIZER_EQ: + case UBASIC_TOKENIZER_EQ: r1 = (r1 == r2); break; - case TOKENIZER_NE: + case UBASIC_TOKENIZER_NE: r1 = (r1 != r2); break; - case TOKENIZER_LAND: + case UBASIC_TOKENIZER_LAND: r1 = (r1 && r2); break; - case TOKENIZER_LOR: + case UBASIC_TOKENIZER_LOR: r1 = (r1 || r2); break; - case TOKENIZER_PLUS: + case UBASIC_TOKENIZER_PLUS: r1 = r1 + r2; break; - case TOKENIZER_MINUS: + case UBASIC_TOKENIZER_MINUS: r1 = r1 - r2; break; - case TOKENIZER_AND: + case UBASIC_TOKENIZER_AND: r1 = ((int32_t)r1) & ((int32_t)r2); break; - case TOKENIZER_OR: + case UBASIC_TOKENIZER_OR: r1 = ((int32_t)r1) | ((int32_t)r2); break; @@ -1533,27 +1539,27 @@ static VARIABLE_TYPE relation(struct ubasic_data *data) /* TODO: error handling? */ static uint8_t jump_label(struct ubasic_data *data, char *label) { - char currLabel[MAX_LABEL_LEN] = { '\0' }; - struct tokenizer_data *tree = &data->tree; + char currLabel[UBASIC_LABEL_LEN_MAX] = { '\0' }; + struct ubasic_tokenizer *tree = &data->tree; tokenizer_init(tree, data->program_ptr); - while (tokenizer_token(tree) != TOKENIZER_ENDOFINPUT) { + while (tokenizer_token(tree) != UBASIC_TOKENIZER_ENDOFINPUT) { tokenizer_next(tree); - if (tokenizer_token(tree) == TOKENIZER_COLON) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_COLON) { tokenizer_next(tree); - if (tokenizer_token(tree) == TOKENIZER_LABEL) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_LABEL) { tokenizer_label(tree, currLabel, sizeof(currLabel)); if (strcmp(label, currLabel) == 0) { - accept(data, TOKENIZER_LABEL); + accept(data, UBASIC_TOKENIZER_LABEL); return 1; } } } } - if (tokenizer_token(tree) == TOKENIZER_ENDOFINPUT) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_ENDOFINPUT) { return 0; } @@ -1562,19 +1568,19 @@ static uint8_t jump_label(struct ubasic_data *data, char *label) static void gosub_statement(struct ubasic_data *data) { - char tmpstring[MAX_STRINGLEN]; - struct tokenizer_data *tree = &data->tree; + char tmpstring[UBASIC_STRINGLEN_MAX]; + struct ubasic_tokenizer *tree = &data->tree; - accept(data, TOKENIZER_GOSUB); - if (tokenizer_token(tree) == TOKENIZER_LABEL) { + accept(data, UBASIC_TOKENIZER_GOSUB); + if (tokenizer_token(tree) == UBASIC_TOKENIZER_LABEL) { /* copy label */ - tokenizer_label(tree, tmpstring, MAX_STRINGLEN); + tokenizer_label(tree, tmpstring, UBASIC_STRINGLEN_MAX); tokenizer_next(tree); /* check for the end of line */ - while (tokenizer_token(tree) == TOKENIZER_EOL) { + while (tokenizer_token(tree) == UBASIC_TOKENIZER_EOL) { tokenizer_next(tree); } - if (data->gosub_stack_ptr < MAX_GOSUB_STACK_DEPTH) { + if (data->gosub_stack_ptr < UBASIC_GOSUB_STACK_DEPTH) { data->gosub_stack[data->gosub_stack_ptr] = tokenizer_save_offset(tree); data->gosub_stack_ptr++; @@ -1583,42 +1589,42 @@ static void gosub_statement(struct ubasic_data *data) } } - token_error_print(data, TOKENIZER_GOSUB); + token_error_print(data, UBASIC_TOKENIZER_GOSUB); data->status.bit.isRunning = 0; data->status.bit.Error = 1; } static void return_statement(struct ubasic_data *data) { - struct tokenizer_data *tree = &data->tree; + struct ubasic_tokenizer *tree = &data->tree; - accept(data, TOKENIZER_RETURN); + accept(data, UBASIC_TOKENIZER_RETURN); if (data->gosub_stack_ptr > 0) { data->gosub_stack_ptr--; /* jump_line(gosub_stack[gosub_stack_ptr]); */ tokenizer_jump_offset(tree, data->gosub_stack[data->gosub_stack_ptr]); return; } - token_error_print(data, TOKENIZER_RETURN); + token_error_print(data, UBASIC_TOKENIZER_RETURN); data->status.bit.isRunning = 0; data->status.bit.Error = 1; } static void goto_statement(struct ubasic_data *data) { - char tmpstring[MAX_STRINGLEN]; - struct tokenizer_data *tree = &data->tree; + char tmpstring[UBASIC_STRINGLEN_MAX]; + struct ubasic_tokenizer *tree = &data->tree; - accept(data, TOKENIZER_GOTO); + accept(data, UBASIC_TOKENIZER_GOTO); - if (tokenizer_token(tree) == TOKENIZER_LABEL) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_LABEL) { tokenizer_label(tree, tmpstring, sizeof(tmpstring)); tokenizer_next(tree); jump_label(data, tmpstring); return; } - token_error_print(data, TOKENIZER_GOTO); + token_error_print(data, UBASIC_TOKENIZER_GOTO); data->status.bit.isRunning = 0; data->status.bit.Error = 1; } @@ -1627,25 +1633,25 @@ static void goto_statement(struct ubasic_data *data) #ifdef UBASIC_SCRIPT_HAVE_PWM_CHANNELS static void pwm_statement(struct ubasic_data *data) { - VARIABLE_TYPE j, r; - struct tokenizer_data *tree = &data->tree; + UBASIC_VARIABLE_TYPE j, r; + struct ubasic_tokenizer *tree = &data->tree; - accept(data, TOKENIZER_PWM); - accept(data, TOKENIZER_LEFTPAREN); + accept(data, UBASIC_TOKENIZER_PWM); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); /* first argument: channel */ j = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) j = fixedpt_toint(j); #endif - accept(data, TOKENIZER_COMMA); + accept(data, UBASIC_TOKENIZER_COMMA); /* second argument: duty cycle */ r = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) r = fixedpt_toint(r); #endif - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); if (data->pwm_write) { data->pwm_write((uint8_t)j, (int32_t)r); } @@ -1656,28 +1662,28 @@ static void pwm_statement(struct ubasic_data *data) static void pwmconf_statement(struct ubasic_data *data) { - VARIABLE_TYPE j, r; - struct tokenizer_data *tree = &data->tree; + UBASIC_VARIABLE_TYPE j, r; + struct ubasic_tokenizer *tree = &data->tree; - accept(data, TOKENIZER_PWMCONF); - accept(data, TOKENIZER_LEFTPAREN); + accept(data, UBASIC_TOKENIZER_PWMCONF); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); /* first argument: prescaler 0... */ j = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) j = fixedpt_toint(j); #endif - accept(data, TOKENIZER_COMMA); + accept(data, UBASIC_TOKENIZER_COMMA); r = relation(data); /* second argument: period */ -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) r = fixedpt_toint(r); #endif if (data->pwm_config) { data->pwm_config((uint16_t)j, (uint16_t)r); } - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); accept_cr(tree); } @@ -1686,29 +1692,29 @@ static void pwmconf_statement(struct ubasic_data *data) #if defined(UBASIC_SCRIPT_HAVE_ANALOG_READ) static void areadconf_statement(struct ubasic_data *data) { - VARIABLE_TYPE j, r; - struct tokenizer_data *tree = &data->tree; + UBASIC_VARIABLE_TYPE j, r; + struct ubasic_tokenizer *tree = &data->tree; - accept(data, TOKENIZER_AREADCONF); - accept(data, TOKENIZER_LEFTPAREN); + accept(data, UBASIC_TOKENIZER_AREADCONF); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); /* first argument: sampletime 0...7 on STM32 */ j = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) j = fixedpt_toint(j); #endif if (j < 0) { j = 0; } - accept(data, TOKENIZER_COMMA); + accept(data, UBASIC_TOKENIZER_COMMA); r = relation(data); /* second argument: number of analog sample to average from */ -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) r = fixedpt_toint(r); #endif adc_config(data, (uint8_t)j, (uint8_t)r); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); accept_cr(tree); } #endif @@ -1716,35 +1722,35 @@ static void areadconf_statement(struct ubasic_data *data) #if defined(UBASIC_SCRIPT_HAVE_GPIO_CHANNELS) static void pinmode_statement(struct ubasic_data *data) { - VARIABLE_TYPE i, j, r; - struct tokenizer_data *tree = &data->tree; + UBASIC_VARIABLE_TYPE i, j, r; + struct ubasic_tokenizer *tree = &data->tree; - accept(data, TOKENIZER_PINMODE); - accept(data, TOKENIZER_LEFTPAREN); + accept(data, UBASIC_TOKENIZER_PINMODE); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); /* channel */ i = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) i = fixedpt_toint(i); #endif - accept(data, TOKENIZER_COMMA); + accept(data, UBASIC_TOKENIZER_COMMA); /* mode */ j = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) j = fixedpt_toint(j); #endif - accept(data, TOKENIZER_COMMA); + accept(data, UBASIC_TOKENIZER_COMMA); /* speed */ r = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) r = fixedpt_toint(r); #endif if (data->gpio_config) { data->gpio_config((uint8_t)i, (int8_t)j, (int8_t)r); } - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); accept_cr(tree); return; @@ -1752,26 +1758,26 @@ static void pinmode_statement(struct ubasic_data *data) static void dwrite_statement(struct ubasic_data *data) { - VARIABLE_TYPE j, r; - struct tokenizer_data *tree = &data->tree; + UBASIC_VARIABLE_TYPE j, r; + struct ubasic_tokenizer *tree = &data->tree; - accept(data, TOKENIZER_DWRITE); - accept(data, TOKENIZER_LEFTPAREN); + accept(data, UBASIC_TOKENIZER_DWRITE); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); j = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) j = fixedpt_toint(j); #endif - accept(data, TOKENIZER_COMMA); + accept(data, UBASIC_TOKENIZER_COMMA); r = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) r = fixedpt_toint(r); #endif if (data->gpio_write) { data->gpio_write((uint8_t)j, (uint8_t)r); } - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); accept_cr(tree); return; @@ -1782,65 +1788,65 @@ static void dwrite_statement(struct ubasic_data *data) #if defined(UBASIC_SCRIPT_HAVE_BACNET) static void bac_create_statement(struct ubasic_data *data) { - VARIABLE_TYPE id, t, s; - struct tokenizer_data *tree = &data->tree; + UBASIC_VARIABLE_TYPE id, t, s; + struct ubasic_tokenizer *tree = &data->tree; - accept(data, TOKENIZER_BACNET_CREATE_OBJECT); - accept(data, TOKENIZER_LEFTPAREN); + accept(data, UBASIC_TOKENIZER_BACNET_CREATE_OBJECT); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); /* first argument: object type 0..128 */ t = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) t = fixedpt_toint(t); #endif - accept(data, TOKENIZER_COMMA); + accept(data, UBASIC_TOKENIZER_COMMA); id = relation(data); /* second argument: instance 0..4194303 */ -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) id = fixedpt_toint(id); #endif - accept(data, TOKENIZER_COMMA); + accept(data, UBASIC_TOKENIZER_COMMA); /* object name */ s = sexpr(data); bacnet_create_object(data, (uint16_t)t, (uint32_t)id, strptr(data, s)); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); accept_cr(tree); } static void bac_write_statement(struct ubasic_data *data) { - VARIABLE_TYPE t, id, p, v; - struct tokenizer_data *tree = &data->tree; + UBASIC_VARIABLE_TYPE t, id, p, v; + struct ubasic_tokenizer *tree = &data->tree; - accept(data, TOKENIZER_BACNET_WRITE_PROPERTY); - accept(data, TOKENIZER_LEFTPAREN); + accept(data, UBASIC_TOKENIZER_BACNET_WRITE_PROPERTY); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); /* first argument: object type 0..128 */ t = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) t = fixedpt_toint(t); #endif - accept(data, TOKENIZER_COMMA); + accept(data, UBASIC_TOKENIZER_COMMA); id = relation(data); /* second argument: instance 0..4194303 */ -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) id = fixedpt_toint(id); #endif - accept(data, TOKENIZER_COMMA); + accept(data, UBASIC_TOKENIZER_COMMA); /* property */ p = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) p = fixedpt_toint(p); #endif - accept(data, TOKENIZER_COMMA); + accept(data, UBASIC_TOKENIZER_COMMA); /* value */ v = relation(data); bacnet_write_property( data, (uint16_t)t, (uint32_t)id, (uint32_t)p, (int32_t)v); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); accept_cr(tree); } #endif @@ -1850,34 +1856,34 @@ static void bac_write_statement(struct ubasic_data *data) static void print_statement(struct ubasic_data *data, uint8_t println) { uint8_t print_how = 0; /*0-xp, 1-hex, 2-oct, 3-dec, 4-bin*/ - char tmpstring[MAX_STRINGLEN]; - struct tokenizer_data *tree = &data->tree; + char tmpstring[UBASIC_STRINGLEN_MAX]; + struct ubasic_tokenizer *tree = &data->tree; /* string additions */ if (println) { - accept(data, TOKENIZER_PRINTLN); + accept(data, UBASIC_TOKENIZER_PRINTLN); } else { - accept(data, TOKENIZER_PRINT); + accept(data, UBASIC_TOKENIZER_PRINT); } do { - if (tokenizer_token(tree) == TOKENIZER_PRINT_HEX) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_PRINT_HEX) { tokenizer_next(tree); print_how = 1; - } else if (tokenizer_token(tree) == TOKENIZER_PRINT_DEC) { + } else if (tokenizer_token(tree) == UBASIC_TOKENIZER_PRINT_DEC) { tokenizer_next(tree); print_how = 2; } -#if defined(VARIABLE_TYPE_STRING) - if (tokenizer_token(tree) == TOKENIZER_STRING) { - tokenizer_string(tree, tmpstring, MAX_STRINGLEN); +#if defined(UBASIC_VARIABLE_TYPE_STRING) + if (tokenizer_token(tree) == UBASIC_TOKENIZER_STRING) { + tokenizer_string(tree, tmpstring, UBASIC_STRINGLEN_MAX); tokenizer_next(tree); } else #endif - if (tokenizer_token(tree) == TOKENIZER_COMMA) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_COMMA) { sprintf(tmpstring, " "); tokenizer_next(tree); } else { -#if defined(VARIABLE_TYPE_STRING) +#if defined(UBASIC_VARIABLE_TYPE_STRING) if (tokenizer_stringlookahead(tree)) { sprintf(tmpstring, "%s", strptr(data, sexpr(data))); } else @@ -1888,8 +1894,8 @@ static void print_statement(struct ubasic_data *data, uint8_t println) } else if (print_how == 2) { sprintf(tmpstring, "%ld", (long)relation(data)); } else { -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) fixedpt_str(relation(data), tmpstring, FIXEDPT_FBITS / 3); #else sprintf(tmpstring, "%ld", relation(data)); @@ -1899,8 +1905,8 @@ static void print_statement(struct ubasic_data *data, uint8_t println) /* end of string additions */ } serial_write_string(data, tmpstring); - } while (tokenizer_token(tree) != TOKENIZER_EOL && - tokenizer_token(tree) != TOKENIZER_ENDOFINPUT); + } while (tokenizer_token(tree) != UBASIC_TOKENIZER_EOL && + tokenizer_token(tree) != UBASIC_TOKENIZER_ENDOFINPUT); /* printf("\n"); */ if (println) { @@ -1913,12 +1919,12 @@ static void print_statement(struct ubasic_data *data, uint8_t println) static void endif_statement(struct ubasic_data *data) { if (data->if_stack_ptr > 0) { - accept(data, TOKENIZER_ENDIF); - accept(data, TOKENIZER_EOL); + accept(data, UBASIC_TOKENIZER_ENDIF); + accept(data, UBASIC_TOKENIZER_EOL); data->if_stack_ptr--; return; } - token_error_print(data, TOKENIZER_IF); + token_error_print(data, UBASIC_TOKENIZER_IF); data->status.bit.isRunning = 0; data->status.bit.Error = 1; return; @@ -1927,32 +1933,32 @@ static void endif_statement(struct ubasic_data *data) static void if_statement(struct ubasic_data *data) { int8_t else_cntr, endif_cntr, f_nt, f_sl; - struct tokenizer_data *tree = &data->tree; + struct ubasic_tokenizer *tree = &data->tree; - accept(data, TOKENIZER_IF); + accept(data, UBASIC_TOKENIZER_IF); - VARIABLE_TYPE r = relation(data); + UBASIC_VARIABLE_TYPE r = relation(data); - if (accept(data, TOKENIZER_THEN)) { - token_error_print(data, TOKENIZER_IF); + if (accept(data, UBASIC_TOKENIZER_THEN)) { + token_error_print(data, UBASIC_TOKENIZER_IF); data->status.bit.isRunning = 0; data->status.bit.Error = 1; return; } - if (tokenizer_token(tree) == TOKENIZER_EOL) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_EOL) { /* Multi-line IF-Statement */ /* CR after then -> multiline IF-Statement */ - if (data->if_stack_ptr < MAX_IF_STACK_DEPTH) { + if (data->if_stack_ptr < UBASIC_IF_THEN_STACK_DEPTH) { data->if_stack[data->if_stack_ptr] = r; data->if_stack_ptr++; } else { - token_error_print(data, TOKENIZER_IF); + token_error_print(data, UBASIC_TOKENIZER_IF); data->status.bit.isRunning = 0; data->status.bit.Error = 1; return; } - accept(data, TOKENIZER_EOL); + accept(data, UBASIC_TOKENIZER_EOL); if (r) { return; } else { @@ -1961,52 +1967,54 @@ static void if_statement(struct ubasic_data *data) f_nt = f_sl = 0; /* f_nt flag for additional next token, f_fs flag single line */ - while (((tokenizer_token(tree) != TOKENIZER_ELSE && - tokenizer_token(tree) != TOKENIZER_ENDIF) || + while (((tokenizer_token(tree) != UBASIC_TOKENIZER_ELSE && + tokenizer_token(tree) != UBASIC_TOKENIZER_ENDIF) || else_cntr || endif_cntr) && - tokenizer_token(tree) != TOKENIZER_ENDOFINPUT) { + tokenizer_token(tree) != UBASIC_TOKENIZER_ENDOFINPUT) { f_nt = 0; /* nested if */ - if (tokenizer_token(tree) == TOKENIZER_IF) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_IF) { else_cntr += 1; endif_cntr += 1; f_sl = 0; } - if (tokenizer_token(tree) == TOKENIZER_THEN) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_THEN) { f_nt = 1; tokenizer_next(tree); - if (tokenizer_token(tree) != TOKENIZER_EOL) { + if (tokenizer_token(tree) != UBASIC_TOKENIZER_EOL) { f_sl = 1; } } - if (tokenizer_token(tree) == TOKENIZER_ELSE) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_ELSE) { else_cntr--; if (else_cntr < 0) { - token_error_print(data, TOKENIZER_IF); + token_error_print(data, UBASIC_TOKENIZER_IF); data->status.bit.isRunning = 0; data->status.bit.Error = 1; return; } } - if (!f_sl && (tokenizer_token(tree) == TOKENIZER_ENDIF)) { + if (!f_sl && + (tokenizer_token(tree) == UBASIC_TOKENIZER_ENDIF)) { endif_cntr--; if (endif_cntr != else_cntr) { else_cntr--; } } else { - if (f_sl && (tokenizer_token(tree) == TOKENIZER_EOL)) { + if (f_sl && + (tokenizer_token(tree) == UBASIC_TOKENIZER_EOL)) { f_sl = 0; endif_cntr--; if (endif_cntr != else_cntr) { else_cntr--; } } else { - if (tokenizer_token(tree) == TOKENIZER_ENDIF) { - token_error_print(data, TOKENIZER_IF); + if (tokenizer_token(tree) == UBASIC_TOKENIZER_ENDIF) { + token_error_print(data, UBASIC_TOKENIZER_IF); data->status.bit.isRunning = 0; data->status.bit.Error = 1; return; @@ -2018,7 +2026,7 @@ static void if_statement(struct ubasic_data *data) } } - if (tokenizer_token(tree) == TOKENIZER_ELSE) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_ELSE) { return; } } @@ -2030,11 +2038,11 @@ static void if_statement(struct ubasic_data *data) } else { do { tokenizer_next(tree); - } while (tokenizer_token(tree) != TOKENIZER_ELSE && - tokenizer_token(tree) != TOKENIZER_EOL && - tokenizer_token(tree) != TOKENIZER_ENDOFINPUT); - if (tokenizer_token(tree) == TOKENIZER_ELSE) { - accept(data, TOKENIZER_ELSE); + } while (tokenizer_token(tree) != UBASIC_TOKENIZER_ELSE && + tokenizer_token(tree) != UBASIC_TOKENIZER_EOL && + tokenizer_token(tree) != UBASIC_TOKENIZER_ENDOFINPUT); + if (tokenizer_token(tree) == UBASIC_TOKENIZER_ELSE) { + accept(data, UBASIC_TOKENIZER_ELSE); tokenizer_next(tree); statement(data); } else { @@ -2046,53 +2054,56 @@ static void if_statement(struct ubasic_data *data) static void else_statement(struct ubasic_data *data) { - VARIABLE_TYPE r = 0; + UBASIC_VARIABLE_TYPE r = 0; uint8_t endif_cntr, f_nt; - struct tokenizer_data *tree = &data->tree; + struct ubasic_tokenizer *tree = &data->tree; - accept(data, TOKENIZER_ELSE); + accept(data, UBASIC_TOKENIZER_ELSE); if (data->if_stack_ptr > 0) { r = data->if_stack[data->if_stack_ptr - 1]; } else { - token_error_print(data, TOKENIZER_ELSE); + token_error_print(data, UBASIC_TOKENIZER_ELSE); data->status.bit.isRunning = 0; data->status.bit.Error = 1; return; } - if (tokenizer_token(tree) == TOKENIZER_EOL) { - accept(data, TOKENIZER_EOL); + if (tokenizer_token(tree) == UBASIC_TOKENIZER_EOL) { + accept(data, UBASIC_TOKENIZER_EOL); if (!r) { return; } else { endif_cntr = 0; - while (((tokenizer_token(tree) != TOKENIZER_ENDIF) || endif_cntr) && - tokenizer_token(tree) != TOKENIZER_ENDOFINPUT) { + while (((tokenizer_token(tree) != UBASIC_TOKENIZER_ENDIF) || + endif_cntr) && + tokenizer_token(tree) != UBASIC_TOKENIZER_ENDOFINPUT) { f_nt = 0; - if (tokenizer_token(tree) == TOKENIZER_IF) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_IF) { endif_cntr += 1; } - if (tokenizer_token(tree) == TOKENIZER_THEN) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_THEN) { tokenizer_next(tree); /* then followed by CR -> multi line */ - if (tokenizer_token(tree) == TOKENIZER_EOL) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_EOL) { f_nt = 1; } else { /* single line */ endif_cntr--; - while (tokenizer_token(tree) != TOKENIZER_ENDIF && - tokenizer_token(tree) != TOKENIZER_EOL && - tokenizer_token(tree) != TOKENIZER_ENDOFINPUT) { + while (tokenizer_token(tree) != + UBASIC_TOKENIZER_ENDIF && + tokenizer_token(tree) != UBASIC_TOKENIZER_EOL && + tokenizer_token(tree) != + UBASIC_TOKENIZER_ENDOFINPUT) { tokenizer_next(tree); } - if (tokenizer_token(tree) == TOKENIZER_ENDIF) { - token_error_print(data, TOKENIZER_ELSE); + if (tokenizer_token(tree) == UBASIC_TOKENIZER_ENDIF) { + token_error_print(data, UBASIC_TOKENIZER_ELSE); data->status.bit.isRunning = 0; data->status.bit.Error = 1; return; } } } - if (tokenizer_token(tree) == TOKENIZER_ENDIF) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_ENDIF) { endif_cntr--; } if (!f_nt) { @@ -2103,7 +2114,7 @@ static void else_statement(struct ubasic_data *data) endif_statement(data); return; } - token_error_print(data, TOKENIZER_ELSE); + token_error_print(data, UBASIC_TOKENIZER_ELSE); data->status.bit.isRunning = 0; data->status.bit.Error = 1; return; @@ -2113,38 +2124,38 @@ static void else_statement(struct ubasic_data *data) static void let_statement(struct ubasic_data *data) { uint8_t varnum; - struct tokenizer_data *tree = &data->tree; + struct ubasic_tokenizer *tree = &data->tree; - if (tokenizer_token(tree) == TOKENIZER_VARIABLE) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_VARIABLE) { varnum = tokenizer_variable_num(tree); - accept(data, TOKENIZER_VARIABLE); - if (!accept(data, TOKENIZER_EQ)) { + accept(data, UBASIC_TOKENIZER_VARIABLE); + if (!accept(data, UBASIC_TOKENIZER_EQ)) { ubasic_set_varnum(data, varnum, relation(data)); } } -#if defined(VARIABLE_TYPE_STRING) +#if defined(UBASIC_VARIABLE_TYPE_STRING) /* string additions here */ - else if (tokenizer_token(tree) == TOKENIZER_STRINGVARIABLE) { + else if (tokenizer_token(tree) == UBASIC_TOKENIZER_STRINGVARIABLE) { varnum = tokenizer_variable_num(tree); - accept(data, TOKENIZER_STRINGVARIABLE); - if (!accept(data, TOKENIZER_EQ)) { + accept(data, UBASIC_TOKENIZER_STRINGVARIABLE); + if (!accept(data, UBASIC_TOKENIZER_EQ)) { ubasic_set_stringvariable(data, varnum, sexpr(data)); } } /* end of string additions */ #endif -#if defined(VARIABLE_TYPE_ARRAY) - else if (tokenizer_token(tree) == TOKENIZER_ARRAYVARIABLE) { +#if defined(UBASIC_VARIABLE_TYPE_ARRAY) + else if (tokenizer_token(tree) == UBASIC_TOKENIZER_ARRAYVARIABLE) { varnum = tokenizer_variable_num(tree); - accept(data, TOKENIZER_ARRAYVARIABLE); - accept(data, TOKENIZER_LEFTPAREN); - VARIABLE_TYPE idx = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) + accept(data, UBASIC_TOKENIZER_ARRAYVARIABLE); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); + UBASIC_VARIABLE_TYPE idx = relation(data); +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) idx = fixedpt_toint(idx); #endif - accept(data, TOKENIZER_RIGHTPAREN); - if (!accept(data, TOKENIZER_EQ)) { + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); + if (!accept(data, UBASIC_TOKENIZER_EQ)) { ubasic_set_arrayvarnum(data, varnum, (uint16_t)idx, relation(data)); } } @@ -2153,27 +2164,27 @@ static void let_statement(struct ubasic_data *data) accept_cr(tree); } -#if defined(VARIABLE_TYPE_ARRAY) +#if defined(UBASIC_VARIABLE_TYPE_ARRAY) static void dim_statement(struct ubasic_data *data) { - VARIABLE_TYPE size = 0; - struct tokenizer_data *tree = &data->tree; + UBASIC_VARIABLE_TYPE size = 0; + struct ubasic_tokenizer *tree = &data->tree; - accept(data, TOKENIZER_DIM); + accept(data, UBASIC_TOKENIZER_DIM); uint8_t varnum = tokenizer_variable_num(tree); - accept(data, TOKENIZER_ARRAYVARIABLE); + accept(data, UBASIC_TOKENIZER_ARRAYVARIABLE); - /* accept(data, TOKENIZER_LEFTPAREN); */ + /* accept(data, UBASIC_TOKENIZER_LEFTPAREN); */ size = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) size = fixedpt_toint(size); #endif ubasic_dim_arrayvarnum(data, varnum, size); - /* accept(data, TOKENIZER_RIGHTPAREN); */ + /* accept(data, UBASIC_TOKENIZER_RIGHTPAREN); */ accept_cr(tree); /* end of array additions */ @@ -2183,14 +2194,14 @@ static void dim_statement(struct ubasic_data *data) /*---------------------------------------------------------------------------*/ static void next_statement(struct ubasic_data *data) { - struct tokenizer_data *tree = &data->tree; + struct ubasic_tokenizer *tree = &data->tree; - accept(data, TOKENIZER_NEXT); + accept(data, UBASIC_TOKENIZER_NEXT); uint8_t var = tokenizer_variable_num(tree); - accept(data, TOKENIZER_VARIABLE); + accept(data, UBASIC_TOKENIZER_VARIABLE); if (data->for_stack_ptr > 0 && var == data->for_stack[data->for_stack_ptr - 1].for_variable) { - VARIABLE_TYPE value = ubasic_get_varnum(data, var) + + UBASIC_VARIABLE_TYPE value = ubasic_get_varnum(data, var) + data->for_stack[data->for_stack_ptr - 1].step; ubasic_set_varnum(data, var, value); @@ -2208,7 +2219,7 @@ static void next_statement(struct ubasic_data *data) return; } - token_error_print(data, TOKENIZER_FOR); + token_error_print(data, UBASIC_TOKENIZER_FOR); data->status.bit.isRunning = 0; data->status.bit.Error = 1; } @@ -2218,30 +2229,30 @@ static void next_statement(struct ubasic_data *data) static void for_statement(struct ubasic_data *data) { uint8_t for_variable; - VARIABLE_TYPE to; - struct tokenizer_data *tree = &data->tree; + UBASIC_VARIABLE_TYPE to; + struct ubasic_tokenizer *tree = &data->tree; - accept(data, TOKENIZER_FOR); + accept(data, UBASIC_TOKENIZER_FOR); for_variable = tokenizer_variable_num(tree); - accept(data, TOKENIZER_VARIABLE); - accept(data, TOKENIZER_EQ); + accept(data, UBASIC_TOKENIZER_VARIABLE); + accept(data, UBASIC_TOKENIZER_EQ); ubasic_set_varnum(data, for_variable, relation(data)); - accept(data, TOKENIZER_TO); + accept(data, UBASIC_TOKENIZER_TO); to = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) - VARIABLE_TYPE step = FIXEDPT_ONE; +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) + UBASIC_VARIABLE_TYPE step = FIXEDPT_ONE; #else - VARIABLE_TYPE step = 1; + UBASIC_VARIABLE_TYPE step = 1; #endif - if (tokenizer_token(tree) == TOKENIZER_STEP) { - accept(data, TOKENIZER_STEP); + if (tokenizer_token(tree) == UBASIC_TOKENIZER_STEP) { + accept(data, UBASIC_TOKENIZER_STEP); step = relation(data); } accept_cr(tree); - if (data->for_stack_ptr < MAX_FOR_STACK_DEPTH) { + if (data->for_stack_ptr < UBASIC_FOR_LOOP_STACK_DEPTH) { /* for_stack[for_stack_ptr].line_after_for = tokenizer_line_number(); */ data->for_stack[data->for_stack_ptr].line_after_for = tokenizer_save_offset(tree); @@ -2252,7 +2263,7 @@ static void for_statement(struct ubasic_data *data) return; } - token_error_print(data, TOKENIZER_FOR); + token_error_print(data, UBASIC_TOKENIZER_FOR); data->status.bit.isRunning = 0; data->status.bit.Error = 1; } @@ -2261,7 +2272,7 @@ static void for_statement(struct ubasic_data *data) static void end_statement(struct ubasic_data *data) { - accept(data, TOKENIZER_END); + accept(data, UBASIC_TOKENIZER_END); data->status.bit.isRunning = 0; data->status.bit.Error = 0; } @@ -2269,14 +2280,14 @@ static void end_statement(struct ubasic_data *data) #if defined(UBASIC_SCRIPT_HAVE_SLEEP) static void sleep_statement(struct ubasic_data *data) { - VARIABLE_TYPE r; - struct tokenizer_data *tree = &data->tree; + UBASIC_VARIABLE_TYPE r; + struct ubasic_tokenizer *tree = &data->tree; - accept(data, TOKENIZER_SLEEP); - VARIABLE_TYPE f = relation(data); + accept(data, UBASIC_TOKENIZER_SLEEP); + UBASIC_VARIABLE_TYPE f = relation(data); if (f > 0) { -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) r = fixedpt_toint(f * 1000); #else r = (uint32_t)f; @@ -2293,17 +2304,17 @@ static void sleep_statement(struct ubasic_data *data) #if defined(UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS) static void tic_statement(struct ubasic_data *data) { - struct tokenizer_data *tree = &data->tree; + struct ubasic_tokenizer *tree = &data->tree; - accept(data, TOKENIZER_TIC); - accept(data, TOKENIZER_LEFTPAREN); - VARIABLE_TYPE f = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) + accept(data, UBASIC_TOKENIZER_TIC); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); + UBASIC_VARIABLE_TYPE f = relation(data); +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) f = fixedpt_toint(f); #endif timer_tic(data, f); - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); accept_cr(tree); } #endif @@ -2311,44 +2322,44 @@ static void tic_statement(struct ubasic_data *data) #if defined(UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL) static void input_statement_wait(struct ubasic_data *data) { - struct tokenizer_data *tree = &data->tree; + struct ubasic_tokenizer *tree = &data->tree; data->input_how = 0; - accept(data, TOKENIZER_INPUT); - if (tokenizer_token(tree) == TOKENIZER_PRINT_HEX) { + accept(data, UBASIC_TOKENIZER_INPUT); + if (tokenizer_token(tree) == UBASIC_TOKENIZER_PRINT_HEX) { tokenizer_next(tree); data->input_how = 1; - } else if (tokenizer_token(tree) == TOKENIZER_PRINT_DEC) { + } else if (tokenizer_token(tree) == UBASIC_TOKENIZER_PRINT_DEC) { tokenizer_next(tree); data->input_how = 2; } - if (tokenizer_token(tree) == TOKENIZER_VARIABLE) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_VARIABLE) { data->input_varnum = tokenizer_variable_num(tree); - accept(data, TOKENIZER_VARIABLE); + accept(data, UBASIC_TOKENIZER_VARIABLE); data->input_type = 0; } -#if defined(VARIABLE_TYPE_STRING) +#if defined(UBASIC_VARIABLE_TYPE_STRING) /* string additions here */ - else if (tokenizer_token(tree) == TOKENIZER_STRINGVARIABLE) { + else if (tokenizer_token(tree) == UBASIC_TOKENIZER_STRINGVARIABLE) { data->input_varnum = tokenizer_variable_num(tree); - accept(data, TOKENIZER_STRINGVARIABLE); + accept(data, UBASIC_TOKENIZER_STRINGVARIABLE); data->input_type = 1; } /* end of string additions */ #endif -#if defined(VARIABLE_TYPE_ARRAY) - else if (tokenizer_token(tree) == TOKENIZER_ARRAYVARIABLE) { +#if defined(UBASIC_VARIABLE_TYPE_ARRAY) + else if (tokenizer_token(tree) == UBASIC_TOKENIZER_ARRAYVARIABLE) { data->input_varnum = tokenizer_variable_num(tree); - accept(data, TOKENIZER_ARRAYVARIABLE); + accept(data, UBASIC_TOKENIZER_ARRAYVARIABLE); - accept(data, TOKENIZER_LEFTPAREN); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); data->input_array_index = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) data->input_array_index = fixedpt_toint(data->input_array_index); #endif - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); data->input_type = 2; } #endif @@ -2357,11 +2368,11 @@ static void input_statement_wait(struct ubasic_data *data) /* CR */ /* or */ /* , timeout */ - if (tokenizer_token(tree) == TOKENIZER_COMMA) { - accept(data, TOKENIZER_COMMA); - VARIABLE_TYPE r = relation(data); -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) + if (tokenizer_token(tree) == UBASIC_TOKENIZER_COMMA) { + accept(data, UBASIC_TOKENIZER_COMMA); + UBASIC_VARIABLE_TYPE r = relation(data); +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) r = fixedpt_toint(r); #endif if (r > 0) { @@ -2380,19 +2391,19 @@ static void serial_getline_completed(struct ubasic_data *data) /* otherwise leave the variable content unchanged. */ if (strlen(data->statement) > 0) { if ((data->input_type == 0) -#if defined(VARIABLE_TYPE_ARRAY) +#if defined(UBASIC_VARIABLE_TYPE_ARRAY) || (data->input_type == 2) #endif ) { - VARIABLE_TYPE r; + UBASIC_VARIABLE_TYPE r; if ((data->input_how == 1) || (data->input_how == 2)) { r = atoi(data->statement); } else { /* process number */ -#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ - defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) +#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ + defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) r = str_fixedpt( - data->statement, MAX_STRINGLEN, FIXEDPT_FBITS >> 1); + data->statement, UBASIC_STRINGLEN_MAX, FIXEDPT_FBITS >> 1); #else r = atoi(data->statement); #endif @@ -2401,14 +2412,14 @@ static void serial_getline_completed(struct ubasic_data *data) if (data->input_type == 0) { ubasic_set_varnum(data, data->input_varnum, r); } -#if defined(VARIABLE_TYPE_ARRAY) +#if defined(UBASIC_VARIABLE_TYPE_ARRAY) else if (data->input_type == 2) { ubasic_set_arrayvarnum( data, data->input_varnum, data->input_array_index, r); } #endif } -#if defined(VARIABLE_TYPE_STRING) +#if defined(UBASIC_VARIABLE_TYPE_STRING) else if (data->input_type == 1) { ubasic_set_stringvariable( data, data->input_varnum, scpy(data, data->statement)); @@ -2423,16 +2434,16 @@ static void serial_getline_completed(struct ubasic_data *data) /*---------------------------------------------------------------------------*/ static void while_statement(struct ubasic_data *data) { - VARIABLE_TYPE r; + UBASIC_VARIABLE_TYPE r; int8_t while_cntr; uint16_t while_offset; - struct tokenizer_data *tree = &data->tree; + struct ubasic_tokenizer *tree = &data->tree; /* this is where we jump to after 'endwhile' */ while_offset = tokenizer_save_offset(tree); - accept(data, TOKENIZER_WHILE); - if (data->while_stack_ptr == MAX_WHILE_STACK_DEPTH) { - token_error_print(data, TOKENIZER_WHILE); + accept(data, UBASIC_TOKENIZER_WHILE); + if (data->while_stack_ptr == UBASIC_WHILE_LOOP_STACK_DEPTH) { + token_error_print(data, UBASIC_TOKENIZER_WHILE); data->status.bit.isRunning = 0; data->status.bit.Error = 1; } @@ -2450,7 +2461,7 @@ static void while_statement(struct ubasic_data *data) r = relation(data); if (data->while_stack_ptr == 0) { - token_error_print(data, TOKENIZER_WHILE); + token_error_print(data, UBASIC_TOKENIZER_WHILE); data->status.bit.isRunning = 0; data->status.bit.Error = 1; return; @@ -2471,19 +2482,20 @@ static void while_statement(struct ubasic_data *data) /* first time the loop is entered the condition is not satisfied, */ /* so we gobble the lines until we reach the matching endwhile */ while_cntr = 0; - while ((tokenizer_token(tree) != TOKENIZER_ENDWHILE || while_cntr) && - (tokenizer_token(tree) != TOKENIZER_ENDOFINPUT)) { - if (tokenizer_token(tree) == TOKENIZER_WHILE) { + while ((tokenizer_token(tree) != UBASIC_TOKENIZER_ENDWHILE || + while_cntr) && + (tokenizer_token(tree) != UBASIC_TOKENIZER_ENDOFINPUT)) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_WHILE) { while_cntr += 1; } - if (tokenizer_token(tree) == TOKENIZER_ENDWHILE) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_ENDWHILE) { while_cntr -= 1; } tokenizer_next(tree); } data->while_stack_ptr--; - accept(data, TOKENIZER_ENDWHILE); - accept(data, TOKENIZER_EOL); + accept(data, UBASIC_TOKENIZER_ENDWHILE); + accept(data, UBASIC_TOKENIZER_EOL); } return; @@ -2491,9 +2503,9 @@ static void while_statement(struct ubasic_data *data) /*---------------------------------------------------------------------------*/ static void endwhile_statement(struct ubasic_data *data) { - struct tokenizer_data *tree = &data->tree; + struct ubasic_tokenizer *tree = &data->tree; - accept(data, TOKENIZER_ENDWHILE); + accept(data, UBASIC_TOKENIZER_ENDWHILE); if (data->while_stack_ptr > 0) { /* jump_line(while_stack[while_stack_ptr-1]); */ if (data->while_stack[data->while_stack_ptr - 1].line_after_endwhile == @@ -2505,7 +2517,7 @@ static void endwhile_statement(struct ubasic_data *data) tree, data->while_stack[data->while_stack_ptr - 1].line_while); return; } - token_error_print(data, TOKENIZER_FOR); + token_error_print(data, UBASIC_TOKENIZER_FOR); data->status.bit.isRunning = 0; data->status.bit.Error = 1; } @@ -2513,31 +2525,31 @@ static void endwhile_statement(struct ubasic_data *data) #if defined(UBASIC_SCRIPT_HAVE_STORE_VARS_IN_FLASH) -static VARIABLE_TYPE recall_statement(struct ubasic_data *data) +static UBASIC_VARIABLE_TYPE recall_statement(struct ubasic_data *data) { - VARIABLE_TYPE rval = 0; + UBASIC_VARIABLE_TYPE rval = 0; uint8_t *dataptr; uint8_t *datalen; uint8_t var_type; - struct tokenizer_data *tree = &data->tree; + struct ubasic_tokenizer *tree = &data->tree; - accept(data, TOKENIZER_RECALL); - accept(data, TOKENIZER_LEFTPAREN); - if (tokenizer_token(tree) == TOKENIZER_VARIABLE) { + accept(data, UBASIC_TOKENIZER_RECALL); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); + if (tokenizer_token(tree) == UBASIC_TOKENIZER_VARIABLE) { var_type = UBASIC_RECALL_STORE_TYPE_VARIABLE; data->varnum = tokenizer_variable_num(tree); - accept(data, TOKENIZER_VARIABLE); + accept(data, UBASIC_TOKENIZER_VARIABLE); dataptr = (uint8_t *)&data->variables[data->varnum]; datalen = (uint8_t *)&rval; variable_read(data, data->varnum, var_type, dataptr, datalen); rval >>= 2; } -#if defined(VARIABLE_TYPE_STRING) - else if (tokenizer_token(tree) == TOKENIZER_STRINGVARIABLE) { +#if defined(UBASIC_VARIABLE_TYPE_STRING) + else if (tokenizer_token(tree) == UBASIC_TOKENIZER_STRINGVARIABLE) { var_type = UBASIC_RECALL_STORE_TYPE_STRING; data->varnum = tokenizer_variable_num(tree); - accept(data, TOKENIZER_STRINGVARIABLE); - char dummy_s[MAX_STRINGLEN] = { 0 }; + accept(data, UBASIC_TOKENIZER_STRINGVARIABLE); + char dummy_s[UBASIC_STRINGLEN_MAX] = { 0 }; dataptr = (uint8_t *)dummy_s; datalen = (uint8_t *)&rval; variable_read(data, data->varnum, var_type, dataptr, datalen); @@ -2549,12 +2561,12 @@ static VARIABLE_TYPE recall_statement(struct ubasic_data *data) clear_stringstack(data); } #endif -#if defined(VARIABLE_TYPE_ARRAY) - else if (tokenizer_token(tree) == TOKENIZER_ARRAYVARIABLE) { +#if defined(UBASIC_VARIABLE_TYPE_ARRAY) + else if (tokenizer_token(tree) == UBASIC_TOKENIZER_ARRAYVARIABLE) { var_type = UBASIC_RECALL_STORE_TYPE_ARRAY; data->varnum = tokenizer_variable_num(tree); - accept(data, TOKENIZER_ARRAYVARIABLE); - VARIABLE_TYPE dummy_a[VARIABLE_TYPE_ARRAY + 1]; + accept(data, UBASIC_TOKENIZER_ARRAYVARIABLE); + UBASIC_VARIABLE_TYPE dummy_a[UBASIC_VARIABLE_TYPE_ARRAY + 1]; dataptr = (uint8_t *)dummy_a; datalen = (uint8_t *)&rval; variable_read(data, data->varnum, 2, dataptr, datalen); @@ -2567,42 +2579,42 @@ static VARIABLE_TYPE recall_statement(struct ubasic_data *data) } } #endif - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); return rval; } static void store_statement(struct ubasic_data *data) { - struct tokenizer_data *tree = &data->tree; + struct ubasic_tokenizer *tree = &data->tree; uint8_t *dataptr; uint8_t datalen; uint8_t var_type; - accept(data, TOKENIZER_STORE); - accept(data, TOKENIZER_LEFTPAREN); + accept(data, UBASIC_TOKENIZER_STORE); + accept(data, UBASIC_TOKENIZER_LEFTPAREN); - if (tokenizer_token(tree) == TOKENIZER_VARIABLE) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_VARIABLE) { var_type = UBASIC_RECALL_STORE_TYPE_VARIABLE; data->varnum = tokenizer_variable_num(tree); - accept(data, TOKENIZER_VARIABLE); + accept(data, UBASIC_TOKENIZER_VARIABLE); dataptr = (uint8_t *)&data->variables[data->varnum]; variable_write(data, data->varnum, var_type, 4, dataptr); } -#if defined(VARIABLE_TYPE_STRING) - else if (tokenizer_token(tree) == TOKENIZER_STRINGVARIABLE) { +#if defined(UBASIC_VARIABLE_TYPE_STRING) + else if (tokenizer_token(tree) == UBASIC_TOKENIZER_STRINGVARIABLE) { var_type = UBASIC_RECALL_STORE_TYPE_STRING; data->varnum = tokenizer_variable_num(tree); - accept(data, TOKENIZER_STRINGVARIABLE); + accept(data, UBASIC_TOKENIZER_STRINGVARIABLE); dataptr = (uint8_t *)strptr(data, data->stringvariables[data->varnum]); datalen = strlen((char *)dataptr); variable_write(data, data->varnum, var_type, datalen, dataptr); } #endif -#if defined(VARIABLE_TYPE_ARRAY) - else if (tokenizer_token(tree) == TOKENIZER_ARRAYVARIABLE) { +#if defined(UBASIC_VARIABLE_TYPE_ARRAY) + else if (tokenizer_token(tree) == UBASIC_TOKENIZER_ARRAYVARIABLE) { var_type = UBASIC_RECALL_STORE_TYPE_ARRAY; data->varnum = tokenizer_variable_num(tree); - accept(data, TOKENIZER_ARRAYVARIABLE); + accept(data, UBASIC_TOKENIZER_ARRAYVARIABLE); datalen = 4 * (data->arrays_data[data->arrayvariable[data->varnum]] & 0x0000ffff); dataptr = @@ -2610,7 +2622,7 @@ static void store_statement(struct ubasic_data *data) variable_write(data, data->varnum, var_type, datalen, dataptr); } #endif - accept(data, TOKENIZER_RIGHTPAREN); + accept(data, UBASIC_TOKENIZER_RIGHTPAREN); accept_cr(tree); } /*---------------------------------------------------------------------------*/ @@ -2619,153 +2631,154 @@ static void store_statement(struct ubasic_data *data) /*---------------------------------------------------------------------------*/ static void statement(struct ubasic_data *data) { - struct tokenizer_data *tree = &data->tree; + struct ubasic_tokenizer *tree = &data->tree; uint8_t println = 0; - VARIABLE_TYPE token; + UBASIC_VARIABLE_TYPE token; if (data->status.bit.Error) { return; } token = tokenizer_token(tree); switch (token) { - case TOKENIZER_EOL: - accept(data, TOKENIZER_EOL); + case UBASIC_TOKENIZER_EOL: + accept(data, UBASIC_TOKENIZER_EOL); break; - case TOKENIZER_PRINTLN: + case UBASIC_TOKENIZER_PRINTLN: println = 1; - case TOKENIZER_PRINT: + case UBASIC_TOKENIZER_PRINT: print_statement(data, println); break; - case TOKENIZER_IF: + case UBASIC_TOKENIZER_IF: if_statement(data); break; - case TOKENIZER_ELSE: + case UBASIC_TOKENIZER_ELSE: else_statement(data); break; - case TOKENIZER_ENDIF: + case UBASIC_TOKENIZER_ENDIF: endif_statement(data); break; - case TOKENIZER_GOTO: + case UBASIC_TOKENIZER_GOTO: goto_statement(data); break; - case TOKENIZER_GOSUB: + case UBASIC_TOKENIZER_GOSUB: gosub_statement(data); break; - case TOKENIZER_RETURN: + case UBASIC_TOKENIZER_RETURN: return_statement(data); break; - case TOKENIZER_FOR: + case UBASIC_TOKENIZER_FOR: for_statement(data); break; - case TOKENIZER_NEXT: + case UBASIC_TOKENIZER_NEXT: next_statement(data); break; - case TOKENIZER_WHILE: + case UBASIC_TOKENIZER_WHILE: while_statement(data); break; - case TOKENIZER_ENDWHILE: + case UBASIC_TOKENIZER_ENDWHILE: endwhile_statement(data); break; - case TOKENIZER_END: + case UBASIC_TOKENIZER_END: end_statement(data); break; - case TOKENIZER_LET: - accept(data, TOKENIZER_LET); /* Fall through: Nothing to do! */ - case TOKENIZER_VARIABLE: -#if defined(VARIABLE_TYPE_STRING) + case UBASIC_TOKENIZER_LET: + accept( + data, UBASIC_TOKENIZER_LET); /* Fall through: Nothing to do! */ + case UBASIC_TOKENIZER_VARIABLE: +#if defined(UBASIC_VARIABLE_TYPE_STRING) /* string addition */ - case TOKENIZER_STRINGVARIABLE: + case UBASIC_TOKENIZER_STRINGVARIABLE: /* end of string addition */ #endif -#if defined(VARIABLE_TYPE_ARRAY) - case TOKENIZER_ARRAYVARIABLE: +#if defined(UBASIC_VARIABLE_TYPE_ARRAY) + case UBASIC_TOKENIZER_ARRAYVARIABLE: #endif let_statement(data); break; #if defined(UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL) - case TOKENIZER_INPUT: + case UBASIC_TOKENIZER_INPUT: input_statement_wait(data); break; #endif #if defined(UBASIC_SCRIPT_HAVE_SLEEP) - case TOKENIZER_SLEEP: + case UBASIC_TOKENIZER_SLEEP: sleep_statement(data); break; #endif -#if defined(VARIABLE_TYPE_ARRAY) - case TOKENIZER_DIM: +#if defined(UBASIC_VARIABLE_TYPE_ARRAY) + case UBASIC_TOKENIZER_DIM: dim_statement(data); break; #endif #if defined(UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS) - case TOKENIZER_TIC: + case UBASIC_TOKENIZER_TIC: tic_statement(data); break; #endif #ifdef UBASIC_SCRIPT_HAVE_PWM_CHANNELS - case TOKENIZER_PWM: + case UBASIC_TOKENIZER_PWM: pwm_statement(data); break; - case TOKENIZER_PWMCONF: + case UBASIC_TOKENIZER_PWMCONF: pwmconf_statement(data); break; #endif #if defined(UBASIC_SCRIPT_HAVE_ANALOG_READ) - case TOKENIZER_AREADCONF: + case UBASIC_TOKENIZER_AREADCONF: areadconf_statement(data); break; #endif #if defined(UBASIC_SCRIPT_HAVE_GPIO_CHANNELS) - case TOKENIZER_PINMODE: + case UBASIC_TOKENIZER_PINMODE: pinmode_statement(data); break; - case TOKENIZER_DWRITE: + case UBASIC_TOKENIZER_DWRITE: dwrite_statement(data); break; #endif /* UBASIC_SCRIPT_HAVE_GPIO_CHANNELS */ #if defined(UBASIC_SCRIPT_HAVE_BACNET) - case TOKENIZER_BACNET_CREATE_OBJECT: + case UBASIC_TOKENIZER_BACNET_CREATE_OBJECT: bac_create_statement(data); break; - case TOKENIZER_BACNET_WRITE_PROPERTY: + case UBASIC_TOKENIZER_BACNET_WRITE_PROPERTY: bac_write_statement(data); break; #endif #if defined(UBASIC_SCRIPT_HAVE_STORE_VARS_IN_FLASH) - case TOKENIZER_STORE: + case UBASIC_TOKENIZER_STORE: store_statement(data); break; - case TOKENIZER_RECALL: + case UBASIC_TOKENIZER_RECALL: recall_statement(data); break; #endif /* UBASIC_SCRIPT_HAVE_STORE_VARS_IN_FLASH */ - case TOKENIZER_CLEAR: + case UBASIC_TOKENIZER_CLEAR: ubasic_clear_variables(data); accept_cr(tree); break; @@ -2779,12 +2792,12 @@ static void statement(struct ubasic_data *data) /*---------------------------------------------------------------------------*/ static void subsequent_statement(struct ubasic_data *data) { - struct tokenizer_data *tree = &data->tree; + struct ubasic_tokenizer *tree = &data->tree; while (1) { - if (tokenizer_token(tree) == TOKENIZER_COLON) { - accept(data, TOKENIZER_COLON); - if (accept(data, TOKENIZER_LABEL)) { + if (tokenizer_token(tree) == UBASIC_TOKENIZER_COLON) { + accept(data, UBASIC_TOKENIZER_COLON); + if (accept(data, UBASIC_TOKENIZER_LABEL)) { return; } continue; @@ -2798,7 +2811,7 @@ static void subsequent_statement(struct ubasic_data *data) /*---------------------------------------------------------------------------*/ static bool ubasic_program_finished(struct ubasic_data *data) { - struct tokenizer_data *tree = &data->tree; + struct ubasic_tokenizer *tree = &data->tree; if (data->status.bit.isRunning) { return tokenizer_finished(tree); @@ -2840,7 +2853,7 @@ int32_t ubasic_run_program(struct ubasic_data *data) serial_getline_completed(data); } #endif -#if defined(VARIABLE_TYPE_STRING) +#if defined(UBASIC_VARIABLE_TYPE_STRING) /* string additions */ clear_stringstack(data); /* end of string additions */ @@ -2859,14 +2872,14 @@ int32_t ubasic_run_program(struct ubasic_data *data) /*---------------------------------------------------------------------------*/ uint8_t ubasic_execute_statement(struct ubasic_data *data, char *stmt) { - struct tokenizer_data *tree = &data->tree; + struct ubasic_tokenizer *tree = &data->tree; data->status.byte = 0; data->program_ptr = stmt; data->for_stack_ptr = data->gosub_stack_ptr = 0; tokenizer_init(tree, stmt); do { -#if defined(VARIABLE_TYPE_STRING) +#if defined(UBASIC_VARIABLE_TYPE_STRING) clear_stringstack(data); #endif @@ -3005,7 +3018,7 @@ uint8_t ubasic_finished(struct ubasic_data *data) /*---------------------------------------------------------------------------*/ void ubasic_set_variable( - struct ubasic_data *data, char variable, VARIABLE_TYPE value) + struct ubasic_data *data, char variable, UBASIC_VARIABLE_TYPE value) { if (isupper(variable)) { uint8_t varnum = variable - 'A'; @@ -3016,7 +3029,8 @@ void ubasic_set_variable( } } -VARIABLE_TYPE ubasic_get_variable(struct ubasic_data *data, char variable) +UBASIC_VARIABLE_TYPE +ubasic_get_variable(struct ubasic_data *data, char variable) { if (isupper(variable)) { uint8_t varnum = variable - 'A'; @@ -3028,7 +3042,7 @@ VARIABLE_TYPE ubasic_get_variable(struct ubasic_data *data, char variable) return 0; } -#if defined(VARIABLE_TYPE_STRING) +#if defined(UBASIC_VARIABLE_TYPE_STRING) /* */ /* string additions */ /* */ @@ -3036,14 +3050,14 @@ VARIABLE_TYPE ubasic_get_variable(struct ubasic_data *data, char variable) void ubasic_set_stringvariable( struct ubasic_data *data, uint8_t svarnum, int16_t svalue) { - if (svarnum < MAX_SVARNUM) { + if (svarnum < UBASIC_STRING_VAR_LEN_MAX) { /* was it previously allocated? */ if (data->stringvariables[svarnum] > -1) { *(data->stringstack + data->stringvariables[svarnum]) = 0; } data->stringvariables[svarnum] = svalue; - if ((svalue >= 0) && (svalue < MAX_BUFFERLEN)) { + if ((svalue >= 0) && (svalue < UBASIC_STRING_BUFFER_LEN_MAX)) { *(data->stringstack + svalue) = svarnum + 1; } #if defined(UBASIC_DEBUG_STRINGVARIABLES) @@ -3061,7 +3075,7 @@ void ubasic_set_stringvariable( int16_t ubasic_get_stringvariable(struct ubasic_data *data, uint8_t varnum) { - if (varnum < MAX_SVARNUM) { + if (varnum < UBASIC_STRING_VAR_LEN_MAX) { #if defined(UBASIC_DEBUG_STRINGVARIABLES) serial_write_string(data, "get_stringvar:"); char msg[12]; @@ -3081,7 +3095,7 @@ int16_t ubasic_get_stringvariable(struct ubasic_data *data, uint8_t varnum) /* */ #endif -#if defined(VARIABLE_TYPE_ARRAY) +#if defined(UBASIC_VARIABLE_TYPE_ARRAY) /** * @brief DIM an array variable * @param data - ubasic data structure @@ -3108,7 +3122,10 @@ void ubasic_dim_arrayvariable( * @param value - value to set */ void ubasic_set_arrayvariable( - struct ubasic_data *data, char variable, uint16_t idx, VARIABLE_TYPE value) + struct ubasic_data *data, + char variable, + uint16_t idx, + UBASIC_VARIABLE_TYPE value) { if (isupper(variable)) { uint8_t varnum = variable - 'A'; @@ -3126,10 +3143,10 @@ void ubasic_set_arrayvariable( * @param idx - index 1..N of the array * @param value - value to get */ -VARIABLE_TYPE +UBASIC_VARIABLE_TYPE ubasic_get_arrayvariable(struct ubasic_data *data, char variable, uint16_t idx) { - VARIABLE_TYPE value = 0; + UBASIC_VARIABLE_TYPE value = 0; if (isupper(variable)) { uint8_t varnum = variable - 'A'; diff --git a/src/bacnet/basic/program/ubasic/ubasic.h b/src/bacnet/basic/program/ubasic/ubasic.h index f36aa3c4..28261859 100644 --- a/src/bacnet/basic/program/ubasic/ubasic.h +++ b/src/bacnet/basic/program/ubasic/ubasic.h @@ -45,7 +45,6 @@ #include #include #include "config.h" -#include "platform.h" #include "tokenizer.h" /* define a status structure with bit fields */ @@ -63,24 +62,31 @@ typedef union { } bit; } UBASIC_STATUS; -#define MAX_FOR_STACK_DEPTH 4 +#ifndef UBASIC_FOR_LOOP_STACK_DEPTH +#define UBASIC_FOR_LOOP_STACK_DEPTH 4 +#endif struct ubasic_for_state { uint16_t line_after_for; uint8_t for_variable; - VARIABLE_TYPE to; - VARIABLE_TYPE step; + UBASIC_VARIABLE_TYPE to; + UBASIC_VARIABLE_TYPE step; }; -#define MAX_WHILE_STACK_DEPTH 4 +#ifndef UBASIC_WHILE_LOOP_STACK_DEPTH +#define UBASIC_WHILE_LOOP_STACK_DEPTH 4 +#endif struct ubasic_while_state { uint16_t line_while; int16_t line_after_endwhile; }; -#define MAX_GOSUB_STACK_DEPTH 10 -#define MAX_IF_STACK_DEPTH 4 +#ifndef UBASIC_GOSUB_STACK_DEPTH +#define UBASIC_GOSUB_STACK_DEPTH 10 +#endif -#define UBASIC_SERIAL_INPUT_MS 50 +#ifndef UBASIC_IF_THEN_STACK_DEPTH +#define UBASIC_IF_THEN_STACK_DEPTH 4 +#endif enum { UBASIC_RECALL_STORE_TYPE_VARIABLE = 0, @@ -103,37 +109,37 @@ struct ubasic_mstimer { struct ubasic_data { UBASIC_STATUS status; uint8_t input_how; - struct tokenizer_data tree; + struct ubasic_tokenizer tree; -#if defined(VARIABLE_TYPE_ARRAY) - VARIABLE_TYPE arrays_data[VARIABLE_TYPE_ARRAY]; +#if defined(UBASIC_VARIABLE_TYPE_ARRAY) + UBASIC_VARIABLE_TYPE arrays_data[UBASIC_VARIABLE_TYPE_ARRAY]; int16_t free_arrayptr; - int16_t arrayvariable[MAX_VARNUM]; + int16_t arrayvariable[UBASIC_VARNUM_MAX]; #endif const char *program_ptr; - uint16_t gosub_stack[MAX_GOSUB_STACK_DEPTH]; + uint16_t gosub_stack[UBASIC_GOSUB_STACK_DEPTH]; uint8_t gosub_stack_ptr; - struct ubasic_for_state for_stack[MAX_FOR_STACK_DEPTH]; + struct ubasic_for_state for_stack[UBASIC_FOR_LOOP_STACK_DEPTH]; uint8_t for_stack_ptr; - int16_t if_stack[MAX_IF_STACK_DEPTH]; + int16_t if_stack[UBASIC_IF_THEN_STACK_DEPTH]; uint8_t if_stack_ptr; - struct ubasic_while_state while_stack[MAX_WHILE_STACK_DEPTH]; + struct ubasic_while_state while_stack[UBASIC_WHILE_LOOP_STACK_DEPTH]; uint8_t while_stack_ptr; - VARIABLE_TYPE variables[MAX_VARNUM]; + UBASIC_VARIABLE_TYPE variables[UBASIC_VARNUM_MAX]; #if defined(UBASIC_SCRIPT_HAVE_STORE_VARS_IN_FLASH) uint8_t varnum; #endif -#if defined(VARIABLE_TYPE_STRING) - char stringstack[MAX_BUFFERLEN]; +#if defined(UBASIC_VARIABLE_TYPE_STRING) + char stringstack[UBASIC_STRING_BUFFER_LEN_MAX]; int16_t freebufptr; - int16_t stringvariables[MAX_SVARNUM]; + int16_t stringvariables[UBASIC_STRING_VAR_LEN_MAX]; #endif #if defined(UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL) @@ -141,8 +147,8 @@ struct ubasic_data { uint8_t input_type; char statement[UBASIC_STATEMENT_SIZE]; #endif -#if defined(VARIABLE_TYPE_ARRAY) - VARIABLE_TYPE input_array_index; +#if defined(UBASIC_VARIABLE_TYPE_ARRAY) + UBASIC_VARIABLE_TYPE input_array_index; #endif #if defined(UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS) uint32_t tic_toc_timer[UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS]; @@ -189,7 +195,7 @@ struct ubasic_data { #if defined(UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL) int (*ubasic_getc)(void); #endif -#if defined(UBASIC_SCRIPT_PRINT_TO_SERIAL) +#if defined(UBASIC_SCRIPT_HAVE_PRINT_TO_SERIAL) void (*serial_write)(const char *buffer, uint16_t n); #endif #if defined(UBASIC_SCRIPT_HAVE_BACNET) @@ -199,43 +205,64 @@ struct ubasic_data { uint16_t object_type, uint32_t instance, uint32_t property_id, - VARIABLE_TYPE value); - VARIABLE_TYPE(*bacnet_read_property) + UBASIC_VARIABLE_TYPE value); + UBASIC_VARIABLE_TYPE(*bacnet_read_property) (uint16_t object_type, uint32_t instance, uint32_t property_id); #endif }; +BACNET_STACK_EXPORT void ubasic_load_program(struct ubasic_data *data, const char *program); +BACNET_STACK_EXPORT void ubasic_clear_variables(struct ubasic_data *data); +BACNET_STACK_EXPORT int32_t ubasic_run_program(struct ubasic_data *data); +BACNET_STACK_EXPORT uint8_t ubasic_execute_statement(struct ubasic_data *data, char *statement); +BACNET_STACK_EXPORT uint8_t ubasic_finished(struct ubasic_data *data); +BACNET_STACK_EXPORT uint8_t ubasic_waiting_for_input(struct ubasic_data *data); +BACNET_STACK_EXPORT uint8_t ubasic_getline(struct ubasic_data *data, int ch); +BACNET_STACK_EXPORT int ubasic_printf(struct ubasic_data *data, const char *format, ...); +BACNET_STACK_EXPORT int ubasic_getc(struct ubasic_data *data); -VARIABLE_TYPE ubasic_get_variable(struct ubasic_data *data, char variable); +BACNET_STACK_EXPORT +UBASIC_VARIABLE_TYPE +ubasic_get_variable(struct ubasic_data *data, char variable); +BACNET_STACK_EXPORT void ubasic_set_variable( - struct ubasic_data *data, char variable, VARIABLE_TYPE value); + struct ubasic_data *data, char variable, UBASIC_VARIABLE_TYPE value); -#if defined(VARIABLE_TYPE_ARRAY) +#if defined(UBASIC_VARIABLE_TYPE_ARRAY) +BACNET_STACK_EXPORT void ubasic_dim_arrayvariable( struct ubasic_data *data, char variable, int16_t size); +BACNET_STACK_EXPORT void ubasic_set_arrayvariable( - struct ubasic_data *data, char variable, uint16_t idx, VARIABLE_TYPE value); -VARIABLE_TYPE + struct ubasic_data *data, + char variable, + uint16_t idx, + UBASIC_VARIABLE_TYPE value); +BACNET_STACK_EXPORT +UBASIC_VARIABLE_TYPE ubasic_get_arrayvariable(struct ubasic_data *data, char variable, uint16_t idx); #endif -#if defined(VARIABLE_TYPE_STRING) +#if defined(UBASIC_VARIABLE_TYPE_STRING) +BACNET_STACK_EXPORT int16_t ubasic_get_stringvariable(struct ubasic_data *data, uint8_t varnum); +BACNET_STACK_EXPORT void ubasic_set_stringvariable( struct ubasic_data *data, uint8_t varnum, int16_t size); #endif /* API to interface and initialize the ported hardware drivers */ +BACNET_STACK_EXPORT void ubasic_port_init(struct ubasic_data *data); #endif /* __UBASIC_H__ */ diff --git a/src/bacnet/basic/server/bacnet_basic.h b/src/bacnet/basic/server/bacnet_basic.h index 84a6b0aa..37a5786e 100644 --- a/src/bacnet/basic/server/bacnet_basic.h +++ b/src/bacnet/basic/server/bacnet_basic.h @@ -39,18 +39,26 @@ typedef void (*bacnet_basic_store_callback)( extern "C" { #endif /* __cplusplus */ +BACNET_STACK_EXPORT void bacnet_basic_init(void); +BACNET_STACK_EXPORT void bacnet_basic_init_callback_set( bacnet_basic_callback callback, void *context); +BACNET_STACK_EXPORT void bacnet_basic_task(void); +BACNET_STACK_EXPORT void bacnet_basic_task_callback_set( bacnet_basic_callback callback, void *context); +BACNET_STACK_EXPORT void bacnet_basic_task_object_timer_set(unsigned long milliseconds); +BACNET_STACK_EXPORT void bacnet_basic_store_callback_set(bacnet_basic_store_callback callback); +BACNET_STACK_EXPORT unsigned long bacnet_basic_uptime_seconds(void); +BACNET_STACK_EXPORT unsigned long bacnet_basic_packet_count(void); #ifdef __cplusplus diff --git a/src/bacnet/basic/server/bacnet_port.h b/src/bacnet/basic/server/bacnet_port.h index a8d70f09..6911ecce 100644 --- a/src/bacnet/basic/server/bacnet_port.h +++ b/src/bacnet/basic/server/bacnet_port.h @@ -18,7 +18,9 @@ extern "C" { #endif /* __cplusplus */ +BACNET_STACK_EXPORT bool bacnet_port_init(void); +BACNET_STACK_EXPORT void bacnet_port_task(void); #ifdef __cplusplus diff --git a/src/bacnet/basic/server/bacnet_port_ipv4.h b/src/bacnet/basic/server/bacnet_port_ipv4.h index 0a1debe5..88ab680d 100644 --- a/src/bacnet/basic/server/bacnet_port_ipv4.h +++ b/src/bacnet/basic/server/bacnet_port_ipv4.h @@ -19,9 +19,12 @@ extern "C" { #endif /* __cplusplus */ +BACNET_STACK_EXPORT void bacnet_port_ipv4_foreign_device_init( const uint16_t ttl_seconds, const BACNET_IP_ADDRESS *bbmd_address); +BACNET_STACK_EXPORT void bacnet_port_ipv4_task(uint16_t elapsed_seconds); +BACNET_STACK_EXPORT bool bacnet_port_ipv4_init(void); #ifdef __cplusplus diff --git a/src/bacnet/basic/server/bacnet_port_ipv6.h b/src/bacnet/basic/server/bacnet_port_ipv6.h index 9952c9f4..9c341a72 100644 --- a/src/bacnet/basic/server/bacnet_port_ipv6.h +++ b/src/bacnet/basic/server/bacnet_port_ipv6.h @@ -19,9 +19,12 @@ extern "C" { #endif /* __cplusplus */ +BACNET_STACK_EXPORT void bacnet_port_ipv6_foreign_device_init( const uint16_t ttl_seconds, const BACNET_IP6_ADDRESS *bbmd_address); +BACNET_STACK_EXPORT void bacnet_port_ipv6_task(uint16_t elapsed_seconds); +BACNET_STACK_EXPORT bool bacnet_port_ipv6_init(void); #ifdef __cplusplus diff --git a/test/bacnet/basic/program/ubasic/src/main.c b/test/bacnet/basic/program/ubasic/src/main.c index 7d4b6266..95bc8f62 100644 --- a/test/bacnet/basic/program/ubasic/src/main.c +++ b/test/bacnet/basic/program/ubasic/src/main.c @@ -111,7 +111,7 @@ struct test_bacnet_object { uint16_t object_type; uint32_t object_instance; uint32_t property_id; - VARIABLE_TYPE property_value; + UBASIC_VARIABLE_TYPE property_value; char *object_name; }; static struct test_bacnet_object Test_BACnet_Object[5]; @@ -130,7 +130,7 @@ static void bacnet_write_property( uint16_t object_type, uint32_t instance, uint32_t property_id, - VARIABLE_TYPE value) + UBASIC_VARIABLE_TYPE value) { if (instance < ARRAY_SIZE(Test_BACnet_Object)) { Test_BACnet_Object[instance].object_type = object_type; @@ -140,7 +140,7 @@ static void bacnet_write_property( } } -static VARIABLE_TYPE bacnet_read_property( +static UBASIC_VARIABLE_TYPE bacnet_read_property( uint16_t object_type, uint32_t instance, uint32_t property_id) { if (instance < ARRAY_SIZE(Test_BACnet_Object)) { @@ -191,7 +191,7 @@ static void test_ubasic_gpio(void) "next i;" "println 'average x y=', a, z;" "end;"; - VARIABLE_TYPE value = 0; + UBASIC_VARIABLE_TYPE value = 0; data.mstimer_now = tick_now; data.serial_write = serial_write; data.gpio_config = gpio_config; @@ -244,7 +244,7 @@ static void test_ubasic_bacnet(void) "a = bac_read(0, 1, 85);" "println 'bac_read 0, 1, 85 = ' a;" "end;"; - VARIABLE_TYPE value = 0; + UBASIC_VARIABLE_TYPE value = 0; data.mstimer_now = tick_now; data.serial_write = serial_write; data.bacnet_create_object = bacnet_create_object; @@ -326,7 +326,7 @@ static void test_ubasic_math(void) "println 'x^3=' w;" "end;"; - VARIABLE_TYPE value = 0, xvalue = 0, arrayvalue[5]; + UBASIC_VARIABLE_TYPE value = 0, xvalue = 0, arrayvalue[5]; unsigned i; int32_t value_int = 0; int32_t value_frac = 0; @@ -408,7 +408,7 @@ static void test_ubasic(void) ":l1 " " println 'subroutine';" "return;"; - VARIABLE_TYPE value = 0; + UBASIC_VARIABLE_TYPE value = 0; int32_t value_int = 0; ubasic_load_program(&data, program);