dali/bacnet_stack
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed missing exports in bacnet/basic header files. (#996)

Browse Source 
* Fixed missing exports in bacnet/basic header files.

* Refactor uBASIC for unique namespace and project define overrides.
This commit is contained in:
Steve Karg
2025-05-19 13:44:52 -05:00
committed by GitHub
parent bfb7bf0c1b
commit 62bf8274f7
16 changed files with 1153 additions and 1106 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ports/stm32f4xx/ubasic-port.c
+5 -5
View File
@@ -29,7 +29,7 @@
#include "bacnet/wp.h" #include "bacnet/wp.h"
#include "led.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 * @brief Write a buffer to the serial port
* @param msg Pointer to the buffer to write * @param msg Pointer to the buffer to write
@@ -444,7 +444,7 @@ static void bacnet_write_property(
uint16_t object_type, uint16_t object_type,
uint32_t instance, uint32_t instance,
uint32_t property_id, uint32_t property_id,
VARIABLE_TYPE value) UBASIC_VARIABLE_TYPE value)
{ {
BACNET_BINARY_PV value_binary = BINARY_INACTIVE; BACNET_BINARY_PV value_binary = BINARY_INACTIVE;
@@ -522,10 +522,10 @@ static void bacnet_write_property(
* @param property_id Property ID * @param property_id Property ID
* @return Property value * @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) 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; float value_float = 0.0;
BACNET_BINARY_PV value_binary = BINARY_INACTIVE; 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) #if defined(UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR)
data->random_uint32 = random_uint32; data->random_uint32 = random_uint32;
#endif #endif
#if defined(UBASIC_SCRIPT_PRINT_TO_SERIAL) #if defined(UBASIC_SCRIPT_HAVE_PRINT_TO_SERIAL)
data->serial_write = serial_write; data->serial_write = serial_write;
#endif #endif
#if defined(UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL) #if defined(UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL)
src/bacnet/basic/client/bac-data.h
+9
View File
@@ -26,28 +26,37 @@ struct bacnet_status_flags_t {
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
BACNET_STACK_EXPORT
void bacnet_data_init(void); void bacnet_data_init(void);
BACNET_STACK_EXPORT
void bacnet_data_task(void); void bacnet_data_task(void);
BACNET_STACK_EXPORT
void bacnet_data_poll_seconds_set(unsigned int seconds); void bacnet_data_poll_seconds_set(unsigned int seconds);
BACNET_STACK_EXPORT
unsigned int bacnet_data_poll_seconds(void); unsigned int bacnet_data_poll_seconds(void);
BACNET_STACK_EXPORT
void bacnet_data_value_save( void bacnet_data_value_save(
uint32_t device_instance, uint32_t device_instance,
BACNET_READ_PROPERTY_DATA *rp_data, BACNET_READ_PROPERTY_DATA *rp_data,
BACNET_APPLICATION_DATA_VALUE *value); BACNET_APPLICATION_DATA_VALUE *value);
BACNET_STACK_EXPORT
bool bacnet_data_object_add( bool bacnet_data_object_add(
uint32_t device_id, uint32_t device_id,
BACNET_OBJECT_TYPE object_type, BACNET_OBJECT_TYPE object_type,
uint32_t object_instance); uint32_t object_instance);
BACNET_STACK_EXPORT
bool bacnet_data_analog_present_value( bool bacnet_data_analog_present_value(
uint32_t device_id, uint32_t device_id,
BACNET_OBJECT_TYPE object_type, BACNET_OBJECT_TYPE object_type,
uint32_t object_instance, uint32_t object_instance,
float *float_value); float *float_value);
BACNET_STACK_EXPORT
bool bacnet_data_multistate_present_value( bool bacnet_data_multistate_present_value(
uint32_t device_id, uint32_t device_id,
uint16_t object_type, uint16_t object_type,
uint32_t object_instance, uint32_t object_instance,
uint32_t *unsigned_value); uint32_t *unsigned_value);
BACNET_STACK_EXPORT
bool bacnet_data_binary_present_value( bool bacnet_data_binary_present_value(
uint32_t device_id, uint32_t device_id,
uint16_t object_type, uint16_t object_type,
src/bacnet/basic/client/bac-discover.h
+39 -2
View File
@@ -40,30 +40,42 @@ typedef bool (*bacnet_discover_device_callback)(
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
BACNET_STACK_EXPORT
void bacnet_discover_cleanup(void); void bacnet_discover_cleanup(void);
BACNET_STACK_EXPORT
int bacnet_discover_device_count(void); int bacnet_discover_device_count(void);
BACNET_STACK_EXPORT
uint32_t bacnet_discover_device_instance(unsigned index); uint32_t bacnet_discover_device_instance(unsigned index);
BACNET_STACK_EXPORT
int bacnet_discover_device_object_count(uint32_t device_id); int bacnet_discover_device_object_count(uint32_t device_id);
BACNET_STACK_EXPORT
bool bacnet_discover_device_object_identifier( bool bacnet_discover_device_object_identifier(
uint32_t device_id, unsigned index, BACNET_OBJECT_ID *object_id); 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); unsigned long bacnet_discover_device_elapsed_milliseconds(uint32_t device_id);
BACNET_STACK_EXPORT
size_t bacnet_discover_device_memory(uint32_t device_id); size_t bacnet_discover_device_memory(uint32_t device_id);
BACNET_STACK_EXPORT
unsigned int bacnet_discover_object_property_count( unsigned int bacnet_discover_object_property_count(
uint32_t device_id, uint32_t device_id,
BACNET_OBJECT_TYPE object_type, BACNET_OBJECT_TYPE object_type,
uint32_t object_instance); uint32_t object_instance);
BACNET_STACK_EXPORT
bool bacnet_discover_object_property_identifier( bool bacnet_discover_object_property_identifier(
uint32_t device_id, uint32_t device_id,
BACNET_OBJECT_TYPE object_type, BACNET_OBJECT_TYPE object_type,
uint32_t object_instance, uint32_t object_instance,
unsigned index, unsigned index,
uint32_t *property_id); uint32_t *property_id);
BACNET_STACK_EXPORT
bool bacnet_discover_property_value( bool bacnet_discover_property_value(
uint32_t device_id, uint32_t device_id,
BACNET_OBJECT_TYPE object_type, BACNET_OBJECT_TYPE object_type,
uint32_t object_instance, uint32_t object_instance,
BACNET_PROPERTY_ID object_property, BACNET_PROPERTY_ID object_property,
BACNET_APPLICATION_DATA_VALUE *value); BACNET_APPLICATION_DATA_VALUE *value);
BACNET_STACK_EXPORT
bool bacnet_discover_property_name( bool bacnet_discover_property_name(
uint32_t device_id, uint32_t device_id,
BACNET_OBJECT_TYPE object_type, BACNET_OBJECT_TYPE object_type,
@@ -72,34 +84,59 @@ bool bacnet_discover_property_name(
char *buffer, char *buffer,
size_t buffer_len, size_t buffer_len,
const char *default_string); const char *default_string);
BACNET_STACK_EXPORT
bool bacnet_discover_device_object_property_iterate( bool bacnet_discover_device_object_property_iterate(
uint32_t device_id, uint32_t device_id,
BACNET_OBJECT_TYPE object_type, BACNET_OBJECT_TYPE object_type,
uint32_t object_instance, uint32_t object_instance,
bacnet_discover_device_callback callback, bacnet_discover_device_callback callback,
void *context); void *context);
BACNET_STACK_EXPORT
bool bacnet_discover_device_object_iterate( bool bacnet_discover_device_object_iterate(
uint32_t device_id, uint32_t device_id,
bacnet_discover_device_callback callback, bacnet_discover_device_callback callback,
void *context); void *context);
BACNET_STACK_EXPORT
bool bacnet_discover_device_iterate( bool bacnet_discover_device_iterate(
bacnet_discover_device_callback callback, void *context); bacnet_discover_device_callback callback, void *context);
BACNET_STACK_EXPORT
void bacnet_discover_task(void); void bacnet_discover_task(void);
BACNET_STACK_EXPORT
void bacnet_discover_dnet_set(uint16_t dnet); void bacnet_discover_dnet_set(uint16_t dnet);
BACNET_STACK_EXPORT
uint16_t bacnet_discover_dnet(void); 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); void bacnet_discover_vendor_id_set(uint16_t vendor_id);
BACNET_STACK_EXPORT
uint16_t bacnet_discover_vendor_id(void); 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); void bacnet_discover_seconds_set(unsigned int seconds);
BACNET_STACK_EXPORT
unsigned int bacnet_discover_seconds(void); unsigned int bacnet_discover_seconds(void);
BACNET_STACK_EXPORT
void bacnet_discover_read_process_milliseconds_set(unsigned long milliseconds); void bacnet_discover_read_process_milliseconds_set(unsigned long milliseconds);
BACNET_STACK_EXPORT
unsigned long bacnet_discover_read_process_milliseconds(void); unsigned long bacnet_discover_read_process_milliseconds(void);
BACNET_STACK_EXPORT
void bacnet_discover_device_add( void bacnet_discover_device_add(
uint32_t device_instance, uint32_t device_instance,
unsigned max_apdu, unsigned max_apdu,
int segmentation, int segmentation,
uint16_t vendor_id); uint16_t vendor_id);
BACNET_STACK_EXPORT
void bacnet_discover_init(void); void bacnet_discover_init(void);
#ifdef __cplusplus #ifdef __cplusplus
src/bacnet/basic/client/bac-rw.h
+15
View File
@@ -46,16 +46,22 @@ typedef void (*bacnet_read_write_device_callback_t)(
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
BACNET_STACK_EXPORT
void bacnet_read_write_init(void); void bacnet_read_write_init(void);
BACNET_STACK_EXPORT
void bacnet_read_write_task(void); void bacnet_read_write_task(void);
BACNET_STACK_EXPORT
bool bacnet_read_write_idle(void); bool bacnet_read_write_idle(void);
BACNET_STACK_EXPORT
bool bacnet_read_write_busy(void); bool bacnet_read_write_busy(void);
BACNET_STACK_EXPORT
bool bacnet_read_property_queue( bool bacnet_read_property_queue(
uint32_t device_id, uint32_t device_id,
BACNET_OBJECT_TYPE object_type, BACNET_OBJECT_TYPE object_type,
uint32_t object_instance, uint32_t object_instance,
BACNET_PROPERTY_ID object_property, BACNET_PROPERTY_ID object_property,
uint32_t array_index); uint32_t array_index);
BACNET_STACK_EXPORT
bool bacnet_write_property_real_queue( bool bacnet_write_property_real_queue(
uint32_t device_id, uint32_t device_id,
BACNET_OBJECT_TYPE object_type, BACNET_OBJECT_TYPE object_type,
@@ -64,6 +70,7 @@ bool bacnet_write_property_real_queue(
float value, float value,
uint8_t priority, uint8_t priority,
uint32_t array_index); uint32_t array_index);
BACNET_STACK_EXPORT
bool bacnet_write_property_null_queue( bool bacnet_write_property_null_queue(
uint32_t device_id, uint32_t device_id,
BACNET_OBJECT_TYPE object_type, BACNET_OBJECT_TYPE object_type,
@@ -71,6 +78,7 @@ bool bacnet_write_property_null_queue(
BACNET_PROPERTY_ID object_property, BACNET_PROPERTY_ID object_property,
uint8_t priority, uint8_t priority,
uint32_t array_index); uint32_t array_index);
BACNET_STACK_EXPORT
bool bacnet_write_property_enumerated_queue( bool bacnet_write_property_enumerated_queue(
uint32_t device_id, uint32_t device_id,
BACNET_OBJECT_TYPE object_type, BACNET_OBJECT_TYPE object_type,
@@ -79,6 +87,7 @@ bool bacnet_write_property_enumerated_queue(
unsigned int value, unsigned int value,
uint8_t priority, uint8_t priority,
uint32_t array_index); uint32_t array_index);
BACNET_STACK_EXPORT
bool bacnet_write_property_unsigned_queue( bool bacnet_write_property_unsigned_queue(
uint32_t device_id, uint32_t device_id,
BACNET_OBJECT_TYPE object_type, BACNET_OBJECT_TYPE object_type,
@@ -87,6 +96,7 @@ bool bacnet_write_property_unsigned_queue(
unsigned int value, unsigned int value,
uint8_t priority, uint8_t priority,
uint32_t array_index); uint32_t array_index);
BACNET_STACK_EXPORT
bool bacnet_write_property_signed_queue( bool bacnet_write_property_signed_queue(
uint32_t device_id, uint32_t device_id,
BACNET_OBJECT_TYPE object_type, BACNET_OBJECT_TYPE object_type,
@@ -95,6 +105,7 @@ bool bacnet_write_property_signed_queue(
signed int value, signed int value,
uint8_t priority, uint8_t priority,
uint32_t array_index); uint32_t array_index);
BACNET_STACK_EXPORT
bool bacnet_write_property_boolean_queue( bool bacnet_write_property_boolean_queue(
uint32_t device_id, uint32_t device_id,
BACNET_OBJECT_TYPE object_type, BACNET_OBJECT_TYPE object_type,
@@ -103,11 +114,15 @@ bool bacnet_write_property_boolean_queue(
bool value, bool value,
uint8_t priority, uint8_t priority,
uint32_t array_index); uint32_t array_index);
BACNET_STACK_EXPORT
void bacnet_read_write_value_callback_set( void bacnet_read_write_value_callback_set(
bacnet_read_write_value_callback_t callback); bacnet_read_write_value_callback_t callback);
BACNET_STACK_EXPORT
void bacnet_read_write_device_callback_set( void bacnet_read_write_device_callback_set(
bacnet_read_write_device_callback_t callback); bacnet_read_write_device_callback_t callback);
BACNET_STACK_EXPORT
void bacnet_read_write_vendor_id_filter_set(uint16_t vendor_id); void bacnet_read_write_vendor_id_filter_set(uint16_t vendor_id);
BACNET_STACK_EXPORT
uint16_t bacnet_read_write_vendor_id_filter(void); uint16_t bacnet_read_write_vendor_id_filter(void);
#ifdef __cplusplus #ifdef __cplusplus
src/bacnet/basic/client/bac-task.h
+2
View File
@@ -15,7 +15,9 @@
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
BACNET_STACK_EXPORT
void bacnet_task_init(void); void bacnet_task_init(void);
BACNET_STACK_EXPORT
void bacnet_task(void); void bacnet_task(void);
#ifdef __cplusplus #ifdef __cplusplus
src/bacnet/basic/program/ubasic/config.h
+80 -113
View File
@@ -33,150 +33,117 @@
#include <string.h> #include <string.h>
#include <ctype.h> #include <ctype.h>
#include <stdio.h> #include <stdio.h>
#include "bacnet/bacdef.h"
/* 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
/* Microcontroller related functionality */ /* Microcontroller related functionality */
#undef UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR #if !( \
#undef UBASIC_SCRIPT_HAVE_PWM_CHANNELS defined(UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR) || \
#undef UBASIC_SCRIPT_HAVE_GPIO defined(UBASIC_SCRIPT_HAVE_PWM_CHANNELS) || \
#undef UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS defined(UBASIC_SCRIPT_HAVE_GPIO_CHANNELS) || \
#undef UBASIC_SCRIPT_HAVE_SLEEP defined(UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS) || \
#undef UBASIC_SCRIPT_HAVE_HARDWARE_EVENTS defined(UBASIC_SCRIPT_HAVE_SLEEP) || \
#undef UBASIC_SCRIPT_PRINT_TO_SERIAL defined(UBASIC_SCRIPT_HAVE_HARDWARE_EVENTS) || \
#undef UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL defined(UBASIC_SCRIPT_HAVE_PRINT_TO_SERIAL) || \
#undef UBASIC_SCRIPT_HAVE_ANALOG_READ defined(UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL) || \
#undef UBASIC_SCRIPT_HAVE_STORE_VARS_IN_FLASH defined(UBASIC_SCRIPT_HAVE_ANALOG_READ) || \
#undef UBASIC_SCRIPT_HAVE_BACNET 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 * 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 */ /* 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: /* defines the representation of floating point numbers as fixed points:
this is to allow UBASIC to run on Cortex M0 processors which do not this is to allow UBASIC to run on Cortex M0 processors which do not
support Floating Point Arithmetic in hardware (they emulate it which support Floating Point Arithmetic in hardware (they emulate it which
consumes lots of memory) */ consumes lots of memory) */
#define VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8 #ifndef UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10
#undef UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8
/* This many one-letter variables UBASIC supports */ #define UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8
#define MAX_VARNUM 26 #endif
/* 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)
#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 #define FIXEDPT_BITS 32
#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8)
#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8)
#define FIXEDPT_WBITS 24 #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 #define FIXEDPT_WBITS 22
#else #else
#error "Only 24.8 and 22.10 floats are currently supported" #error "Only 24.8 and 22.10 floats are currently supported"
#endif #endif
#include "fixedptc.h" #include "fixedptc.h"
#endif #endif
#elif defined(UBASIC_VARIABLE_STORAGE_INT16)
#elif defined(VARIABLE_STORAGE_INT16) #define UBASIC_VARIABLE_TYPE int16_t
#if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \
#define VARIABLE_TYPE int16_t defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10)
#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \
defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10)
#error "Fixed Point Floats are Supported for 32bit Storage Only!" #error "Fixed Point Floats are Supported for 32bit Storage Only!"
#endif #endif
#else #else
#error "Only INT32 and INT16 variable types are supported." #error "Only INT32 and INT16 variable types are supported."
#endif #endif
#define UBASIC_STATEMENT_SIZE (64) #ifndef UBASIC_STATEMENT_SIZE
#define UBASIC_STATEMENT_SIZE 64
#endif
#define MAX_STRINGLEN 40 #ifndef UBASIC_STRINGLEN_MAX
#define MAX_LABEL_LEN 10 #define UBASIC_STRINGLEN_MAX 40
#endif
#if defined(VARIABLE_TYPE_STRING) #ifndef UBASIC_LABEL_LEN_MAX
#define MAX_STRINGVARLEN 64 #define UBASIC_LABEL_LEN_MAX 10
#define MAX_BUFFERLEN 256 #endif
#define MAX_SVARNUM 26
#if defined(UBASIC_VARIABLE_TYPE_STRING)
#define UBASIC_STRING_BUFFER_LEN_MAX 256
#define UBASIC_STRING_VAR_LEN_MAX 26
#endif #endif
#endif /* #ifndef _CONFIG_H_ */ #endif /* #ifndef _CONFIG_H_ */
src/bacnet/basic/program/ubasic/platform.h
-46
View File
@@ -1,46 +0,0 @@
/**
* @file
* @author Steve Karg <skarg@users.sourceforge.net>
* @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 <stddef.h>
#include <string.h>
#include <limits.h>
#include <math.h>
#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
src/bacnet/basic/program/ubasic/tokenizer.c
+145 -142
View File
@@ -35,191 +35,189 @@
#include "config.h" #include "config.h"
#include "tokenizer.h" #include "tokenizer.h"
#define MAX_NUMLEN 8
struct keyword_token { struct keyword_token {
const char *keyword; const char *keyword;
uint8_t token; uint8_t token;
}; };
static const struct keyword_token keywords[] = { static const struct keyword_token keywords[] = {
#if defined(VARIABLE_TYPE_STRING) #if defined(UBASIC_VARIABLE_TYPE_STRING)
/* new string-related statements and functions */ /* new string-related statements and functions */
{ "left$", TOKENIZER_LEFT_STR }, { "left$", UBASIC_TOKENIZER_LEFT_STR },
{ "right$", TOKENIZER_RIGHT_STR }, { "right$", UBASIC_TOKENIZER_RIGHT_STR },
{ "mid$", TOKENIZER_MID_STR }, { "mid$", UBASIC_TOKENIZER_MID_STR },
{ "str$", TOKENIZER_STR_STR }, { "str$", UBASIC_TOKENIZER_STR_STR },
{ "chr$", TOKENIZER_CHR_STR }, { "chr$", UBASIC_TOKENIZER_CHR_STR },
{ "val", TOKENIZER_VAL }, { "val", UBASIC_TOKENIZER_VAL },
{ "len", TOKENIZER_LEN }, { "len", UBASIC_TOKENIZER_LEN },
{ "instr", TOKENIZER_INSTR }, { "instr", UBASIC_TOKENIZER_INSTR },
{ "asc", TOKENIZER_ASC }, { "asc", UBASIC_TOKENIZER_ASC },
#endif #endif
/* end of string additions */ /* end of string additions */
{ "let ", TOKENIZER_LET }, { "let ", UBASIC_TOKENIZER_LET },
{ "println ", TOKENIZER_PRINTLN }, { "println ", UBASIC_TOKENIZER_PRINTLN },
{ "print ", TOKENIZER_PRINT }, { "print ", UBASIC_TOKENIZER_PRINT },
{ "if", TOKENIZER_IF }, { "if", UBASIC_TOKENIZER_IF },
{ "then", TOKENIZER_THEN }, { "then", UBASIC_TOKENIZER_THEN },
{ "else", TOKENIZER_ELSE }, { "else", UBASIC_TOKENIZER_ELSE },
{ "endif", TOKENIZER_ENDIF }, { "endif", UBASIC_TOKENIZER_ENDIF },
#if defined(UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS) #if defined(UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS)
{ "toc", TOKENIZER_TOC }, { "toc", UBASIC_TOKENIZER_TOC },
#endif #endif
#if defined(UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL) #if defined(UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL)
{ "input", TOKENIZER_INPUT }, { "input", UBASIC_TOKENIZER_INPUT },
#endif #endif
{ "for ", TOKENIZER_FOR }, { "for ", UBASIC_TOKENIZER_FOR },
{ "to ", TOKENIZER_TO }, { "to ", UBASIC_TOKENIZER_TO },
{ "next ", TOKENIZER_NEXT }, { "next ", UBASIC_TOKENIZER_NEXT },
{ "step ", TOKENIZER_STEP }, { "step ", UBASIC_TOKENIZER_STEP },
{ "while", TOKENIZER_WHILE }, { "while", UBASIC_TOKENIZER_WHILE },
{ "endwhile", TOKENIZER_ENDWHILE }, { "endwhile", UBASIC_TOKENIZER_ENDWHILE },
{ "goto ", TOKENIZER_GOTO }, { "goto ", UBASIC_TOKENIZER_GOTO },
{ "gosub ", TOKENIZER_GOSUB }, { "gosub ", UBASIC_TOKENIZER_GOSUB },
{ "return", TOKENIZER_RETURN }, { "return", UBASIC_TOKENIZER_RETURN },
{ "end", TOKENIZER_END }, { "end", UBASIC_TOKENIZER_END },
#if defined(UBASIC_SCRIPT_HAVE_SLEEP) #if defined(UBASIC_SCRIPT_HAVE_SLEEP)
{ "sleep", TOKENIZER_SLEEP }, { "sleep", UBASIC_TOKENIZER_SLEEP },
#endif #endif
#if defined(VARIABLE_TYPE_ARRAY) #if defined(UBASIC_VARIABLE_TYPE_ARRAY)
{ "dim ", TOKENIZER_DIM }, { "dim ", UBASIC_TOKENIZER_DIM },
#endif #endif
#if defined(UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS) #if defined(UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS)
{ "tic", TOKENIZER_TIC }, { "tic", UBASIC_TOKENIZER_TIC },
#endif #endif
#if defined(UBASIC_SCRIPT_HAVE_HARDWARE_EVENTS) #if defined(UBASIC_SCRIPT_HAVE_HARDWARE_EVENTS)
{ "flag", TOKENIZER_HWE }, { "flag", UBASIC_TOKENIZER_HWE },
#endif #endif
#if defined(UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR) #if defined(UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR)
{ "ran", TOKENIZER_RAN }, { "ran", UBASIC_TOKENIZER_RAN },
#endif #endif
#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ #if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \
defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10)
{ "sqrt", TOKENIZER_SQRT }, { "sqrt", UBASIC_TOKENIZER_SQRT },
{ "sin", TOKENIZER_SIN }, { "sin", UBASIC_TOKENIZER_SIN },
{ "cos", TOKENIZER_COS }, { "cos", UBASIC_TOKENIZER_COS },
{ "tan", TOKENIZER_TAN }, { "tan", UBASIC_TOKENIZER_TAN },
{ "exp", TOKENIZER_EXP }, { "exp", UBASIC_TOKENIZER_EXP },
{ "ln", TOKENIZER_LN }, { "ln", UBASIC_TOKENIZER_LN },
#if defined(UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR) #if defined(UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR)
{ "uniform", TOKENIZER_UNIFORM }, { "uniform", UBASIC_TOKENIZER_UNIFORM },
#endif #endif
{ "abs", TOKENIZER_ABS }, { "abs", UBASIC_TOKENIZER_ABS },
{ "floor", TOKENIZER_FLOOR }, { "floor", UBASIC_TOKENIZER_FLOOR },
{ "ceil", TOKENIZER_CEIL }, { "ceil", UBASIC_TOKENIZER_CEIL },
{ "round", TOKENIZER_ROUND }, { "round", UBASIC_TOKENIZER_ROUND },
{ "pow", TOKENIZER_POWER }, { "pow", UBASIC_TOKENIZER_POWER },
{ "avgw", TOKENIZER_AVERAGEW }, { "avgw", UBASIC_TOKENIZER_AVERAGEW },
#endif #endif
#if defined(UBASIC_SCRIPT_HAVE_GPIO_CHANNELS) #if defined(UBASIC_SCRIPT_HAVE_GPIO_CHANNELS)
{ "pinmode", TOKENIZER_PINMODE }, { "pinmode", UBASIC_TOKENIZER_PINMODE },
{ "dread", TOKENIZER_DREAD }, { "dread", UBASIC_TOKENIZER_DREAD },
{ "dwrite", TOKENIZER_DWRITE }, { "dwrite", UBASIC_TOKENIZER_DWRITE },
#endif #endif
#ifdef UBASIC_SCRIPT_HAVE_PWM_CHANNELS #ifdef UBASIC_SCRIPT_HAVE_PWM_CHANNELS
{ "awrite_conf", TOKENIZER_PWMCONF }, { "awrite_conf", UBASIC_TOKENIZER_PWMCONF },
{ "awrite", TOKENIZER_PWM }, { "awrite", UBASIC_TOKENIZER_PWM },
#endif #endif
#if defined(UBASIC_SCRIPT_HAVE_ANALOG_READ) #if defined(UBASIC_SCRIPT_HAVE_ANALOG_READ)
{ "aread_conf", TOKENIZER_AREADCONF }, { "aread_conf", UBASIC_TOKENIZER_AREADCONF },
{ "aread", TOKENIZER_AREAD }, { "aread", UBASIC_TOKENIZER_AREAD },
#endif #endif
{ "hex ", TOKENIZER_PRINT_HEX }, { "hex ", UBASIC_TOKENIZER_PRINT_HEX },
{ "dec ", TOKENIZER_PRINT_DEC }, { "dec ", UBASIC_TOKENIZER_PRINT_DEC },
{ ":", TOKENIZER_COLON }, { ":", UBASIC_TOKENIZER_COLON },
#if defined(UBASIC_SCRIPT_HAVE_STORE_VARS_IN_FLASH) #if defined(UBASIC_SCRIPT_HAVE_STORE_VARS_IN_FLASH)
{ "store", TOKENIZER_STORE }, { "store", UBASIC_TOKENIZER_STORE },
{ "recall", TOKENIZER_RECALL }, { "recall", UBASIC_TOKENIZER_RECALL },
#endif #endif
#if defined(UBASIC_SCRIPT_HAVE_BACNET) #if defined(UBASIC_SCRIPT_HAVE_BACNET)
{ "bac_create", TOKENIZER_BACNET_CREATE_OBJECT }, { "bac_create", UBASIC_TOKENIZER_BACNET_CREATE_OBJECT },
{ "bac_read", TOKENIZER_BACNET_READ_PROPERTY }, { "bac_read", UBASIC_TOKENIZER_BACNET_READ_PROPERTY },
{ "bac_write", TOKENIZER_BACNET_WRITE_PROPERTY }, { "bac_write", UBASIC_TOKENIZER_BACNET_WRITE_PROPERTY },
#endif #endif
{ "clear", TOKENIZER_CLEAR }, { "clear", UBASIC_TOKENIZER_CLEAR },
{ NULL, TOKENIZER_ERROR } { NULL, UBASIC_TOKENIZER_ERROR }
}; };
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
static uint8_t 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) { if (offset) {
*offset = 1; *offset = 1;
} }
if ((*tree->ptr == '\n') || (*tree->ptr == ';')) { if ((*tree->ptr == '\n') || (*tree->ptr == ';')) {
return TOKENIZER_EOL; return UBASIC_TOKENIZER_EOL;
} else if (*tree->ptr == ',') { } else if (*tree->ptr == ',') {
return TOKENIZER_COMMA; return UBASIC_TOKENIZER_COMMA;
} else if (*tree->ptr == '+') { } else if (*tree->ptr == '+') {
return TOKENIZER_PLUS; return UBASIC_TOKENIZER_PLUS;
} else if (*tree->ptr == '-') { } else if (*tree->ptr == '-') {
return TOKENIZER_MINUS; return UBASIC_TOKENIZER_MINUS;
} else if (*tree->ptr == '&') { } else if (*tree->ptr == '&') {
if (*(tree->ptr + 1) == '&') { if (*(tree->ptr + 1) == '&') {
if (offset) { if (offset) {
*offset += 1; *offset += 1;
} }
return TOKENIZER_LAND; return UBASIC_TOKENIZER_LAND;
} }
return TOKENIZER_AND; return UBASIC_TOKENIZER_AND;
} else if (*tree->ptr == '|') { } else if (*tree->ptr == '|') {
if (*(tree->ptr + 1) == '|') { if (*(tree->ptr + 1) == '|') {
if (offset) { if (offset) {
*offset += 1; *offset += 1;
} }
return TOKENIZER_LOR; return UBASIC_TOKENIZER_LOR;
} }
return TOKENIZER_OR; return UBASIC_TOKENIZER_OR;
} else if (*tree->ptr == '*') { } else if (*tree->ptr == '*') {
return TOKENIZER_ASTR; return UBASIC_TOKENIZER_ASTR;
} else if (*tree->ptr == '!') { } else if (*tree->ptr == '!') {
return TOKENIZER_LNOT; return UBASIC_TOKENIZER_LNOT;
} else if (*tree->ptr == '~') { } else if (*tree->ptr == '~') {
return TOKENIZER_NOT; return UBASIC_TOKENIZER_NOT;
} else if (*tree->ptr == '/') { } else if (*tree->ptr == '/') {
return TOKENIZER_SLASH; return UBASIC_TOKENIZER_SLASH;
} else if (*tree->ptr == '%') { } else if (*tree->ptr == '%') {
return TOKENIZER_MOD; return UBASIC_TOKENIZER_MOD;
} else if (*tree->ptr == '(') { } else if (*tree->ptr == '(') {
return TOKENIZER_LEFTPAREN; return UBASIC_TOKENIZER_LEFTPAREN;
} else if (*tree->ptr == ')') { } else if (*tree->ptr == ')') {
return TOKENIZER_RIGHTPAREN; return UBASIC_TOKENIZER_RIGHTPAREN;
} else if (*tree->ptr == '<') { } else if (*tree->ptr == '<') {
if (tree->ptr[1] == '=') { if (tree->ptr[1] == '=') {
if (offset) { if (offset) {
*offset += 1; *offset += 1;
} }
return TOKENIZER_LE; return UBASIC_TOKENIZER_LE;
} else if (tree->ptr[1] == '>') { } else if (tree->ptr[1] == '>') {
if (offset) { if (offset) {
*offset += 1; *offset += 1;
} }
return TOKENIZER_NE; return UBASIC_TOKENIZER_NE;
} }
return TOKENIZER_LT; return UBASIC_TOKENIZER_LT;
} else if (*tree->ptr == '>') { } else if (*tree->ptr == '>') {
if (tree->ptr[1] == '=') { if (tree->ptr[1] == '=') {
if (offset) { if (offset) {
*offset += 1; *offset += 1;
} }
return TOKENIZER_GE; return UBASIC_TOKENIZER_GE;
} }
return TOKENIZER_GT; return UBASIC_TOKENIZER_GT;
} else if (*tree->ptr == '=') { } else if (*tree->ptr == '=') {
if (tree->ptr[1] == '=') { if (tree->ptr[1] == '=') {
if (offset) { if (offset) {
*offset += 1; *offset += 1;
} }
} }
return TOKENIZER_EQ; return UBASIC_TOKENIZER_EQ;
} }
return 0; 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; const struct keyword_token *kt;
uint8_t i, j; uint8_t i, j;
@@ -230,7 +228,7 @@ static uint8_t tokenizer_next_token(struct tokenizer_data *tree)
} }
if (*tree->ptr == 0) { if (*tree->ptr == 0) {
return TOKENIZER_ENDOFINPUT; return UBASIC_TOKENIZER_ENDOFINPUT;
} }
uint8_t have_decdot = 0, i_dot = 0; uint8_t have_decdot = 0, i_dot = 0;
@@ -251,7 +249,7 @@ static uint8_t tokenizer_next_token(struct tokenizer_data *tree)
tree->nextptr++; tree->nextptr++;
continue; continue;
} }
return TOKENIZER_INT; return UBASIC_TOKENIZER_INT;
} }
} else if ( } else if (
(tree->ptr[0] == '0') && (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') { while (*tree->nextptr == '0' || *tree->nextptr == '1') {
tree->nextptr++; tree->nextptr++;
} }
return TOKENIZER_INT; return UBASIC_TOKENIZER_INT;
} else if (isdigit(*tree->ptr) || (*tree->ptr == '.')) { } else if (isdigit(*tree->ptr) || (*tree->ptr == '.')) {
/* is it FLOAT (digits with at most one decimal point) */ /* is it FLOAT (digits with at most one decimal point) */
/* is it DEC (digits without decimal point which ends in d,D,L,l) */ /* 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++; tree->nextptr++;
have_decdot++; have_decdot++;
if (have_decdot > 1) { if (have_decdot > 1) {
return TOKENIZER_ERROR; return UBASIC_TOKENIZER_ERROR;
} }
continue; continue;
} }
if (*tree->nextptr == 'd' || *tree->nextptr == 'D' || if (*tree->nextptr == 'd' || *tree->nextptr == 'D' ||
*tree->nextptr == 'l' || *tree->nextptr == 'L') { *tree->nextptr == 'l' || *tree->nextptr == 'L') {
return TOKENIZER_INT; return UBASIC_TOKENIZER_INT;
} }
#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ #if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \
defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10)
if (i_dot) { if (i_dot) {
return TOKENIZER_FLOAT; return UBASIC_TOKENIZER_FLOAT;
} }
#endif #endif
return TOKENIZER_NUMBER; return UBASIC_TOKENIZER_NUMBER;
} }
} else if ((j = singlechar_or_operator(tree, &i))) { } else if ((j = singlechar_or_operator(tree, &i))) {
tree->nextptr = tree->ptr + i; tree->nextptr = tree->ptr + i;
return j; return j;
} }
#if defined(VARIABLE_TYPE_STRING) #if defined(UBASIC_VARIABLE_TYPE_STRING)
else if ( else if (
(*tree->ptr == '"' || *tree->ptr == '\'') && (*tree->ptr == '"' || *tree->ptr == '\'') &&
(*(tree->ptr - 1) != '\\')) { (*(tree->ptr - 1) != '\\')) {
@@ -312,13 +310,13 @@ static uint8_t tokenizer_next_token(struct tokenizer_data *tree)
++tree->nextptr; ++tree->nextptr;
if ((*tree->nextptr == '\0') || (*tree->nextptr == '\n') || if ((*tree->nextptr == '\0') || (*tree->nextptr == '\n') ||
(*tree->nextptr == ';')) { (*tree->nextptr == ';')) {
return TOKENIZER_ERROR; return UBASIC_TOKENIZER_ERROR;
} }
} while (*tree->nextptr != i || *(tree->nextptr - 1) == '\\'); } while (*tree->nextptr != i || *(tree->nextptr - 1) == '\\');
++tree->nextptr; ++tree->nextptr;
return TOKENIZER_STRING; return UBASIC_TOKENIZER_STRING;
} }
#endif #endif
else { else {
@@ -364,34 +362,34 @@ static uint8_t tokenizer_next_token(struct tokenizer_data *tree)
} }
if (j > 0 || i > 1) { if (j > 0 || i > 1) {
return TOKENIZER_LABEL; return UBASIC_TOKENIZER_LABEL;
} }
if (i == 1) { if (i == 1) {
#if defined(VARIABLE_TYPE_STRING) #if defined(UBASIC_VARIABLE_TYPE_STRING)
if (*(tree->ptr + 1) == '$') { if (*(tree->ptr + 1) == '$') {
tree->nextptr++; tree->nextptr++;
return TOKENIZER_STRINGVARIABLE; return UBASIC_TOKENIZER_STRINGVARIABLE;
} }
#endif #endif
#if defined(VARIABLE_TYPE_ARRAY) #if defined(UBASIC_VARIABLE_TYPE_ARRAY)
if (*(tree->ptr + 1) == '@') { if (*(tree->ptr + 1) == '@') {
tree->nextptr++; tree->nextptr++;
return TOKENIZER_ARRAYVARIABLE; return UBASIC_TOKENIZER_ARRAYVARIABLE;
} }
#endif #endif
return TOKENIZER_VARIABLE; return UBASIC_TOKENIZER_VARIABLE;
} }
break; break;
} }
} }
return TOKENIZER_ERROR; return UBASIC_TOKENIZER_ERROR;
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
#if defined(VARIABLE_TYPE_STRING) #if defined(UBASIC_VARIABLE_TYPE_STRING)
int8_t tokenizer_stringlookahead(struct tokenizer_data *tree) int8_t tokenizer_stringlookahead(struct ubasic_tokenizer *tree)
{ {
/* return 1 (true) if next 'defining' token is string not integer */ /* return 1 (true) if next 'defining' token is string not integer */
const char *saveptr = tree->ptr; const char *saveptr = tree->ptr;
@@ -400,20 +398,23 @@ int8_t tokenizer_stringlookahead(struct tokenizer_data *tree)
int8_t si = -1; int8_t si = -1;
while (si == -1) { while (si == -1) {
if (token == TOKENIZER_EOL || token == TOKENIZER_ENDOFINPUT) { if (token == UBASIC_TOKENIZER_EOL ||
token == UBASIC_TOKENIZER_ENDOFINPUT) {
si = 0; si = 0;
} else if ( } else if (
token == TOKENIZER_NUMBER || token == TOKENIZER_VARIABLE || token == UBASIC_TOKENIZER_NUMBER ||
token == TOKENIZER_FLOAT) { token == UBASIC_TOKENIZER_VARIABLE ||
token == UBASIC_TOKENIZER_FLOAT) {
si = 0; /* number or numeric var */ si = 0; /* number or numeric var */
} else if (token == TOKENIZER_PLUS) { } else if (token == UBASIC_TOKENIZER_PLUS) {
/* do nothing */ /* do nothing */
} else if (token == TOKENIZER_STRING) { } else if (token == UBASIC_TOKENIZER_STRING) {
si = 1; si = 1;
} else if ( } else if (
token >= TOKENIZER_STRINGVARIABLE && token <= TOKENIZER_CHR_STR) { token >= UBASIC_TOKENIZER_STRINGVARIABLE &&
token <= UBASIC_TOKENIZER_CHR_STR) {
si = 1; si = 1;
} else if (token > TOKENIZER_CHR_STR) { } else if (token > UBASIC_TOKENIZER_CHR_STR) {
si = 0; /* numeric function */ si = 0; /* numeric function */
} }
@@ -425,19 +426,19 @@ int8_t tokenizer_stringlookahead(struct tokenizer_data *tree)
} }
#endif #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->ptr = program;
tree->prog = program; tree->prog = program;
tree->current_token = tokenizer_next_token(tree); 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; return tree->current_token;
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
void tokenizer_next(struct tokenizer_data *tree) void tokenizer_next(struct ubasic_tokenizer *tree)
{ {
if (tokenizer_finished(tree)) { if (tokenizer_finished(tree)) {
return; 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; const char *c = tree->ptr;
VARIABLE_TYPE rval = 0; UBASIC_VARIABLE_TYPE rval = 0;
while (1) { while (1) {
if (*c < '0' || *c > '9') { if (*c < '0' || *c > '9') {
@@ -472,10 +473,10 @@ VARIABLE_TYPE tokenizer_num(struct tokenizer_data *tree)
return rval; return rval;
} }
VARIABLE_TYPE tokenizer_int(struct tokenizer_data *tree) UBASIC_VARIABLE_TYPE tokenizer_int(struct ubasic_tokenizer *tree)
{ {
const char *c = tree->ptr; const char *c = tree->ptr;
VARIABLE_TYPE rval = 0; UBASIC_VARIABLE_TYPE rval = 0;
if ((*c == '0') && (*(c + 1) == 'x' || *(c + 1) == 'X')) { if ((*c == '0') && (*(c + 1) == 'x' || *(c + 1) == 'X')) {
c += 2; c += 2;
while (1) { while (1) {
@@ -518,25 +519,25 @@ VARIABLE_TYPE tokenizer_int(struct tokenizer_data *tree)
return tokenizer_num(tree); return tokenizer_num(tree);
} }
#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ #if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \
defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) 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( return str_fixedpt(
tree->ptr, tree->nextptr - tree->ptr, FIXEDPT_FBITS >> 1); tree->ptr, tree->nextptr - tree->ptr, FIXEDPT_FBITS >> 1);
} }
#endif #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; const char *string_end;
char quote_char; char quote_char;
uint8_t string_len; uint8_t string_len;
if (tokenizer_token(tree) != TOKENIZER_STRING) { if (tokenizer_token(tree) != UBASIC_TOKENIZER_STRING) {
return; return;
} }
quote_char = *tree->ptr; quote_char = *tree->ptr;
@@ -564,12 +565,12 @@ void tokenizer_string(struct tokenizer_data *tree, char *dest, uint8_t len)
} }
#endif #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; const char *string_end = tree->nextptr;
uint8_t string_len; uint8_t string_len;
if (tokenizer_token(tree) != TOKENIZER_LABEL) { if (tokenizer_token(tree) != UBASIC_TOKENIZER_LABEL) {
return; 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')) { if ((*tree->ptr >= 'a' && *tree->ptr <= 'z')) {
return (((uint8_t)*tree->ptr) - 'a'); 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); 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->ptr = (tree->prog + offset);
tree->current_token = tokenizer_next_token(tree); tree->current_token = tokenizer_next_token(tree);
while ((tree->current_token == TOKENIZER_EOL) && while ((tree->current_token == UBASIC_TOKENIZER_EOL) &&
!tokenizer_finished(tree)) { !tokenizer_finished(tree)) {
tokenizer_next(tree); tokenizer_next(tree);
} }
return; return;
} }
const char *tokenizer_name(VARIABLE_TYPE token) const char *tokenizer_name(UBASIC_VARIABLE_TYPE token)
{ {
const struct keyword_token *kt; const struct keyword_token *kt;
src/bacnet/basic/program/ubasic/tokenizer.h
+118 -118
View File
@@ -36,176 +36,176 @@
* *
* SPDX-License-Identifier: BSD-3-Clause * SPDX-License-Identifier: BSD-3-Clause
*/ */
#ifndef __TOKENIZER_H__ #ifndef _UBASIC_TOKENIZER_H__
#define __TOKENIZER_H__ #define _UBASIC_TOKENIZER_H__
#include <stdbool.h> #include <stdbool.h>
#include <stdint.h> #include <stdint.h>
#include "config.h" #include "config.h"
enum { enum {
/*0*/ TOKENIZER_ERROR, /*0*/ UBASIC_TOKENIZER_ERROR,
/*1*/ TOKENIZER_ENDOFINPUT, /*1*/ UBASIC_TOKENIZER_ENDOFINPUT,
/*2*/ TOKENIZER_NUMBER, /*2*/ UBASIC_TOKENIZER_NUMBER,
#if defined(VARIABLE_TYPE_STRING) #if defined(UBASIC_VARIABLE_TYPE_STRING)
/*3*/ TOKENIZER_STRING, /*3*/ UBASIC_TOKENIZER_STRING,
#endif #endif
/*4*/ TOKENIZER_VARIABLE, /*4*/ UBASIC_TOKENIZER_VARIABLE,
#if defined(VARIABLE_TYPE_STRING) #if defined(UBASIC_VARIABLE_TYPE_STRING)
/* string additions - must be here and in this order */ /* string additions - must be here and in this order */
/*5*/ TOKENIZER_STRINGVARIABLE, /*5*/ UBASIC_TOKENIZER_STRINGVARIABLE,
/*6*/ TOKENIZER_PRINT_STR, /*6*/ UBASIC_TOKENIZER_PRINT_STR,
/*7*/ TOKENIZER_LEFT_STR, /*7*/ UBASIC_TOKENIZER_LEFT_STR,
/*8*/ TOKENIZER_RIGHT_STR, /*8*/ UBASIC_TOKENIZER_RIGHT_STR,
/*9*/ TOKENIZER_MID_STR, /*9*/ UBASIC_TOKENIZER_MID_STR,
/*10*/ TOKENIZER_STR_STR, /*10*/ UBASIC_TOKENIZER_STR_STR,
/*11*/ TOKENIZER_CHR_STR, /*11*/ UBASIC_TOKENIZER_CHR_STR,
/*12*/ TOKENIZER_VAL, /*12*/ UBASIC_TOKENIZER_VAL,
/*13*/ TOKENIZER_LEN, /*13*/ UBASIC_TOKENIZER_LEN,
/*14*/ TOKENIZER_INSTR, /*14*/ UBASIC_TOKENIZER_INSTR,
/*15*/ TOKENIZER_ASC, /*15*/ UBASIC_TOKENIZER_ASC,
#endif #endif
/*16*/ TOKENIZER_LET, /*16*/ UBASIC_TOKENIZER_LET,
/*17*/ TOKENIZER_PRINTLN, /*17*/ UBASIC_TOKENIZER_PRINTLN,
/*18*/ TOKENIZER_PRINT, /*18*/ UBASIC_TOKENIZER_PRINT,
/*19*/ TOKENIZER_IF, /*19*/ UBASIC_TOKENIZER_IF,
/*20*/ TOKENIZER_THEN, /*20*/ UBASIC_TOKENIZER_THEN,
/*21*/ TOKENIZER_ELSE, /*21*/ UBASIC_TOKENIZER_ELSE,
/*22*/ TOKENIZER_ENDIF, /*22*/ UBASIC_TOKENIZER_ENDIF,
/*23*/ TOKENIZER_FOR, /*23*/ UBASIC_TOKENIZER_FOR,
/*24*/ TOKENIZER_TO, /*24*/ UBASIC_TOKENIZER_TO,
/*25*/ TOKENIZER_NEXT, /*25*/ UBASIC_TOKENIZER_NEXT,
/*26*/ TOKENIZER_STEP, /*26*/ UBASIC_TOKENIZER_STEP,
/*27*/ TOKENIZER_WHILE, /*27*/ UBASIC_TOKENIZER_WHILE,
/*28*/ TOKENIZER_ENDWHILE, /*28*/ UBASIC_TOKENIZER_ENDWHILE,
/*29*/ TOKENIZER_GOTO, /*29*/ UBASIC_TOKENIZER_GOTO,
/*30*/ TOKENIZER_GOSUB, /*30*/ UBASIC_TOKENIZER_GOSUB,
/*31*/ TOKENIZER_RETURN, /*31*/ UBASIC_TOKENIZER_RETURN,
/*32*/ TOKENIZER_END, /*32*/ UBASIC_TOKENIZER_END,
/*33*/ TOKENIZER_COMMA, /*33*/ UBASIC_TOKENIZER_COMMA,
/*34*/ TOKENIZER_PLUS, /*34*/ UBASIC_TOKENIZER_PLUS,
/*35*/ TOKENIZER_MINUS, /*35*/ UBASIC_TOKENIZER_MINUS,
/*36*/ TOKENIZER_AND, /*36*/ UBASIC_TOKENIZER_AND,
/*37*/ TOKENIZER_OR, /*37*/ UBASIC_TOKENIZER_OR,
/*38*/ TOKENIZER_ASTR, /*38*/ UBASIC_TOKENIZER_ASTR,
/*39*/ TOKENIZER_SLASH, /*39*/ UBASIC_TOKENIZER_SLASH,
/*40*/ TOKENIZER_MOD, /*40*/ UBASIC_TOKENIZER_MOD,
/*41*/ TOKENIZER_LEFTPAREN, /*41*/ UBASIC_TOKENIZER_LEFTPAREN,
/*42*/ TOKENIZER_RIGHTPAREN, /*42*/ UBASIC_TOKENIZER_RIGHTPAREN,
/*43*/ TOKENIZER_LT, /*43*/ UBASIC_TOKENIZER_LT,
/*44*/ TOKENIZER_GT, /*44*/ UBASIC_TOKENIZER_GT,
/*45*/ TOKENIZER_EQ, /*45*/ UBASIC_TOKENIZER_EQ,
/*46*/ TOKENIZER_EOL, /*46*/ UBASIC_TOKENIZER_EOL,
/* */ /* */
/* Plus : Start */ /* Plus : Start */
/* */ /* */
/*47*/ TOKENIZER_NE, /*47*/ UBASIC_TOKENIZER_NE,
/*48*/ TOKENIZER_GE, /*48*/ UBASIC_TOKENIZER_GE,
/*49*/ TOKENIZER_LE, /*49*/ UBASIC_TOKENIZER_LE,
/*50*/ TOKENIZER_LAND, /*50*/ UBASIC_TOKENIZER_LAND,
/*51*/ TOKENIZER_LOR, /*51*/ UBASIC_TOKENIZER_LOR,
/*52*/ TOKENIZER_LNOT, /*52*/ UBASIC_TOKENIZER_LNOT,
/*53*/ TOKENIZER_NOT, /*53*/ UBASIC_TOKENIZER_NOT,
/*54*/ TOKENIZER_PRINT_HEX, /*54*/ UBASIC_TOKENIZER_PRINT_HEX,
/*55*/ TOKENIZER_PRINT_DEC, /*55*/ UBASIC_TOKENIZER_PRINT_DEC,
#if defined(UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL) #if defined(UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL)
/*56*/ TOKENIZER_INPUT, /*56*/ UBASIC_TOKENIZER_INPUT,
#endif #endif
#if defined(UBASIC_SCRIPT_HAVE_SLEEP) #if defined(UBASIC_SCRIPT_HAVE_SLEEP)
/*57*/ TOKENIZER_SLEEP, /*57*/ UBASIC_TOKENIZER_SLEEP,
#endif #endif
#if defined(UBASIC_SCRIPT_HAVE_GPIO_CHANNELS) #if defined(UBASIC_SCRIPT_HAVE_GPIO_CHANNELS)
/*58*/ TOKENIZER_PINMODE, /*58*/ UBASIC_TOKENIZER_PINMODE,
/*59*/ TOKENIZER_DREAD, /*59*/ UBASIC_TOKENIZER_DREAD,
/*60*/ TOKENIZER_DWRITE, /*60*/ UBASIC_TOKENIZER_DWRITE,
#endif #endif
#if defined(VARIABLE_TYPE_ARRAY) #if defined(UBASIC_VARIABLE_TYPE_ARRAY)
/*61*/ TOKENIZER_DIM, /*61*/ UBASIC_TOKENIZER_DIM,
/*62*/ TOKENIZER_ARRAYVARIABLE, /*62*/ UBASIC_TOKENIZER_ARRAYVARIABLE,
#endif #endif
#if defined(UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR) #if defined(UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR)
/*63*/ TOKENIZER_RAN, /*63*/ UBASIC_TOKENIZER_RAN,
#if defined(UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS) #if defined(UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS)
/*64*/ TOKENIZER_TIC, /*64*/ UBASIC_TOKENIZER_TIC,
/*65*/ TOKENIZER_TOC, /*65*/ UBASIC_TOKENIZER_TOC,
#endif #endif
#endif #endif
#if defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \ #if defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_24_8) || \
defined(VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10) defined(UBASIC_VARIABLE_TYPE_FLOAT_AS_FIXEDPT_22_10)
/*66*/ TOKENIZER_INT, /*66*/ UBASIC_TOKENIZER_INT,
/*67*/ TOKENIZER_FLOAT, /*67*/ UBASIC_TOKENIZER_FLOAT,
/*68*/ TOKENIZER_SQRT, /*68*/ UBASIC_TOKENIZER_SQRT,
/*69*/ TOKENIZER_SIN, /*69*/ UBASIC_TOKENIZER_SIN,
/*70*/ TOKENIZER_COS, /*70*/ UBASIC_TOKENIZER_COS,
/*71*/ TOKENIZER_TAN, /*71*/ UBASIC_TOKENIZER_TAN,
/*72*/ TOKENIZER_EXP, /*72*/ UBASIC_TOKENIZER_EXP,
/*73*/ TOKENIZER_LN, /*73*/ UBASIC_TOKENIZER_LN,
#if defined(UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR) #if defined(UBASIC_SCRIPT_HAVE_RANDOM_NUMBER_GENERATOR)
/*74*/ TOKENIZER_UNIFORM, /*74*/ UBASIC_TOKENIZER_UNIFORM,
#endif #endif
/*75*/ TOKENIZER_ABS, /*75*/ UBASIC_TOKENIZER_ABS,
/*76*/ TOKENIZER_FLOOR, /*76*/ UBASIC_TOKENIZER_FLOOR,
/*77*/ TOKENIZER_CEIL, /*77*/ UBASIC_TOKENIZER_CEIL,
/*78*/ TOKENIZER_ROUND, /*78*/ UBASIC_TOKENIZER_ROUND,
/*79*/ TOKENIZER_POWER, /*79*/ UBASIC_TOKENIZER_POWER,
/*80*/ TOKENIZER_AVERAGEW, /*80*/ UBASIC_TOKENIZER_AVERAGEW,
#endif #endif
#if defined(UBASIC_SCRIPT_HAVE_HARDWARE_EVENTS) #if defined(UBASIC_SCRIPT_HAVE_HARDWARE_EVENTS)
/*81*/ TOKENIZER_HWE, /*81*/ UBASIC_TOKENIZER_HWE,
#endif #endif
#if defined(UBASIC_SCRIPT_HAVE_PWM_CHANNELS) #if defined(UBASIC_SCRIPT_HAVE_PWM_CHANNELS)
/*82*/ TOKENIZER_PWMCONF, /*82*/ UBASIC_TOKENIZER_PWMCONF,
/*83*/ TOKENIZER_PWM, /*83*/ UBASIC_TOKENIZER_PWM,
#endif #endif
#if defined(UBASIC_SCRIPT_HAVE_ANALOG_READ) #if defined(UBASIC_SCRIPT_HAVE_ANALOG_READ)
/*84*/ TOKENIZER_AREADCONF, /*84*/ UBASIC_TOKENIZER_AREADCONF,
/*85*/ TOKENIZER_AREAD, /*85*/ UBASIC_TOKENIZER_AREAD,
#endif #endif
/*86*/ TOKENIZER_LABEL, /*86*/ UBASIC_TOKENIZER_LABEL,
/*87*/ TOKENIZER_COLON, /*87*/ UBASIC_TOKENIZER_COLON,
#if defined(UBASIC_SCRIPT_HAVE_STORE_VARS_IN_FLASH) #if defined(UBASIC_SCRIPT_HAVE_STORE_VARS_IN_FLASH)
/*88*/ TOKENIZER_STORE, /*88*/ UBASIC_TOKENIZER_STORE,
/*89*/ TOKENIZER_RECALL, /*89*/ UBASIC_TOKENIZER_RECALL,
#endif #endif
#if defined(UBASIC_SCRIPT_HAVE_BACNET) #if defined(UBASIC_SCRIPT_HAVE_BACNET)
/*90*/ TOKENIZER_BACNET_CREATE_OBJECT, /*90*/ UBASIC_TOKENIZER_BACNET_CREATE_OBJECT,
/*91*/ TOKENIZER_BACNET_READ_PROPERTY, /*91*/ UBASIC_TOKENIZER_BACNET_READ_PROPERTY,
/*92*/ TOKENIZER_BACNET_WRITE_PROPERTY, /*92*/ UBASIC_TOKENIZER_BACNET_WRITE_PROPERTY,
#endif #endif
/*93*/ TOKENIZER_CLEAR, /*93*/ UBASIC_TOKENIZER_CLEAR,
/* */ /* */
/* Plus: End */ /* Plus: End */
/* */ /* */
}; };
struct tokenizer_data { struct ubasic_tokenizer {
const char *ptr; const char *ptr;
const char *nextptr; const char *nextptr;
const char *prog; const char *prog;
uint8_t current_token; uint8_t current_token;
}; };
void tokenizer_init(struct tokenizer_data *data, const char *program); void tokenizer_init(struct ubasic_tokenizer *data, const char *program);
void tokenizer_next(struct tokenizer_data *data); void tokenizer_next(struct ubasic_tokenizer *data);
uint8_t tokenizer_token(struct tokenizer_data *data); uint8_t tokenizer_token(struct ubasic_tokenizer *data);
VARIABLE_TYPE tokenizer_num(struct tokenizer_data *data); UBASIC_VARIABLE_TYPE tokenizer_num(struct ubasic_tokenizer *data);
VARIABLE_TYPE tokenizer_int(struct tokenizer_data *data); UBASIC_VARIABLE_TYPE tokenizer_int(struct ubasic_tokenizer *data);
#ifdef FIXEDPT_FBITS #ifdef FIXEDPT_FBITS
VARIABLE_TYPE tokenizer_float(struct tokenizer_data *data); UBASIC_VARIABLE_TYPE tokenizer_float(struct ubasic_tokenizer *data);
#endif #endif
uint8_t tokenizer_variable_num(struct tokenizer_data *data); uint8_t tokenizer_variable_num(struct ubasic_tokenizer *data);
bool tokenizer_finished(struct tokenizer_data *data); bool tokenizer_finished(struct ubasic_tokenizer *data);
#if defined(VARIABLE_TYPE_STRING) #if defined(UBASIC_VARIABLE_TYPE_STRING)
void tokenizer_string(struct tokenizer_data *data, char *dest, uint8_t len); void tokenizer_string(struct ubasic_tokenizer *data, char *dest, uint8_t len);
int8_t tokenizer_stringlookahead(struct tokenizer_data *data); int8_t tokenizer_stringlookahead(struct ubasic_tokenizer *data);
#endif #endif
void tokenizer_label(struct tokenizer_data *data, char *dest, uint8_t len); void tokenizer_label(struct ubasic_tokenizer *data, char *dest, uint8_t len);
uint16_t tokenizer_save_offset(struct tokenizer_data *data); uint16_t tokenizer_save_offset(struct ubasic_tokenizer *data);
void tokenizer_jump_offset(struct tokenizer_data *data, uint16_t offset); 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
src/bacnet/basic/program/ubasic/ubasic.c
+659 -642
View File
File diff suppressed because it is too large Load Diff
src/bacnet/basic/program/ubasic/ubasic.h
+58 -31
View File
@@ -45,7 +45,6 @@
#include <stdarg.h> #include <stdarg.h>
#include <stdio.h> #include <stdio.h>
#include "config.h" #include "config.h"
#include "platform.h"
#include "tokenizer.h" #include "tokenizer.h"
/* define a status structure with bit fields */ /* define a status structure with bit fields */
@@ -63,24 +62,31 @@ typedef union {
} bit; } bit;
} UBASIC_STATUS; } 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 { struct ubasic_for_state {
uint16_t line_after_for; uint16_t line_after_for;
uint8_t for_variable; uint8_t for_variable;
VARIABLE_TYPE to; UBASIC_VARIABLE_TYPE to;
VARIABLE_TYPE step; 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 { struct ubasic_while_state {
uint16_t line_while; uint16_t line_while;
int16_t line_after_endwhile; int16_t line_after_endwhile;
}; };
#define MAX_GOSUB_STACK_DEPTH 10 #ifndef UBASIC_GOSUB_STACK_DEPTH
#define MAX_IF_STACK_DEPTH 4 #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 { enum {
UBASIC_RECALL_STORE_TYPE_VARIABLE = 0, UBASIC_RECALL_STORE_TYPE_VARIABLE = 0,
@@ -103,37 +109,37 @@ struct ubasic_mstimer {
struct ubasic_data { struct ubasic_data {
UBASIC_STATUS status; UBASIC_STATUS status;
uint8_t input_how; uint8_t input_how;
struct tokenizer_data tree; struct ubasic_tokenizer tree;
#if defined(VARIABLE_TYPE_ARRAY) #if defined(UBASIC_VARIABLE_TYPE_ARRAY)
VARIABLE_TYPE arrays_data[VARIABLE_TYPE_ARRAY]; UBASIC_VARIABLE_TYPE arrays_data[UBASIC_VARIABLE_TYPE_ARRAY];
int16_t free_arrayptr; int16_t free_arrayptr;
int16_t arrayvariable[MAX_VARNUM]; int16_t arrayvariable[UBASIC_VARNUM_MAX];
#endif #endif
const char *program_ptr; 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; 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; 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; 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; 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) #if defined(UBASIC_SCRIPT_HAVE_STORE_VARS_IN_FLASH)
uint8_t varnum; uint8_t varnum;
#endif #endif
#if defined(VARIABLE_TYPE_STRING) #if defined(UBASIC_VARIABLE_TYPE_STRING)
char stringstack[MAX_BUFFERLEN]; char stringstack[UBASIC_STRING_BUFFER_LEN_MAX];
int16_t freebufptr; int16_t freebufptr;
int16_t stringvariables[MAX_SVARNUM]; int16_t stringvariables[UBASIC_STRING_VAR_LEN_MAX];
#endif #endif
#if defined(UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL) #if defined(UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL)
@@ -141,8 +147,8 @@ struct ubasic_data {
uint8_t input_type; uint8_t input_type;
char statement[UBASIC_STATEMENT_SIZE]; char statement[UBASIC_STATEMENT_SIZE];
#endif #endif
#if defined(VARIABLE_TYPE_ARRAY) #if defined(UBASIC_VARIABLE_TYPE_ARRAY)
VARIABLE_TYPE input_array_index; UBASIC_VARIABLE_TYPE input_array_index;
#endif #endif
#if defined(UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS) #if defined(UBASIC_SCRIPT_HAVE_TICTOC_CHANNELS)
uint32_t tic_toc_timer[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) #if defined(UBASIC_SCRIPT_HAVE_INPUT_FROM_SERIAL)
int (*ubasic_getc)(void); int (*ubasic_getc)(void);
#endif #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); void (*serial_write)(const char *buffer, uint16_t n);
#endif #endif
#if defined(UBASIC_SCRIPT_HAVE_BACNET) #if defined(UBASIC_SCRIPT_HAVE_BACNET)
@@ -199,43 +205,64 @@ struct ubasic_data {
uint16_t object_type, uint16_t object_type,
uint32_t instance, uint32_t instance,
uint32_t property_id, uint32_t property_id,
VARIABLE_TYPE value); UBASIC_VARIABLE_TYPE value);
VARIABLE_TYPE(*bacnet_read_property) UBASIC_VARIABLE_TYPE(*bacnet_read_property)
(uint16_t object_type, uint32_t instance, uint32_t property_id); (uint16_t object_type, uint32_t instance, uint32_t property_id);
#endif #endif
}; };
BACNET_STACK_EXPORT
void ubasic_load_program(struct ubasic_data *data, const char *program); void ubasic_load_program(struct ubasic_data *data, const char *program);
BACNET_STACK_EXPORT
void ubasic_clear_variables(struct ubasic_data *data); void ubasic_clear_variables(struct ubasic_data *data);
BACNET_STACK_EXPORT
int32_t ubasic_run_program(struct ubasic_data *data); int32_t ubasic_run_program(struct ubasic_data *data);
BACNET_STACK_EXPORT
uint8_t ubasic_execute_statement(struct ubasic_data *data, char *statement); uint8_t ubasic_execute_statement(struct ubasic_data *data, char *statement);
BACNET_STACK_EXPORT
uint8_t ubasic_finished(struct ubasic_data *data); uint8_t ubasic_finished(struct ubasic_data *data);
BACNET_STACK_EXPORT
uint8_t ubasic_waiting_for_input(struct ubasic_data *data); uint8_t ubasic_waiting_for_input(struct ubasic_data *data);
BACNET_STACK_EXPORT
uint8_t ubasic_getline(struct ubasic_data *data, int ch); uint8_t ubasic_getline(struct ubasic_data *data, int ch);
BACNET_STACK_EXPORT
int ubasic_printf(struct ubasic_data *data, const char *format, ...); int ubasic_printf(struct ubasic_data *data, const char *format, ...);
BACNET_STACK_EXPORT
int ubasic_getc(struct ubasic_data *data); 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( 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( void ubasic_dim_arrayvariable(
struct ubasic_data *data, char variable, int16_t size); struct ubasic_data *data, char variable, int16_t size);
BACNET_STACK_EXPORT
void ubasic_set_arrayvariable( void ubasic_set_arrayvariable(
struct ubasic_data *data, char variable, uint16_t idx, VARIABLE_TYPE value); struct ubasic_data *data,
VARIABLE_TYPE 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); ubasic_get_arrayvariable(struct ubasic_data *data, char variable, uint16_t idx);
#endif #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); int16_t ubasic_get_stringvariable(struct ubasic_data *data, uint8_t varnum);
BACNET_STACK_EXPORT
void ubasic_set_stringvariable( void ubasic_set_stringvariable(
struct ubasic_data *data, uint8_t varnum, int16_t size); struct ubasic_data *data, uint8_t varnum, int16_t size);
#endif #endif
/* API to interface and initialize the ported hardware drivers */ /* API to interface and initialize the ported hardware drivers */
BACNET_STACK_EXPORT
void ubasic_port_init(struct ubasic_data *data); void ubasic_port_init(struct ubasic_data *data);
#endif /* __UBASIC_H__ */ #endif /* __UBASIC_H__ */
src/bacnet/basic/server/bacnet_basic.h
+8
View File
@@ -39,18 +39,26 @@ typedef void (*bacnet_basic_store_callback)(
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
BACNET_STACK_EXPORT
void bacnet_basic_init(void); void bacnet_basic_init(void);
BACNET_STACK_EXPORT
void bacnet_basic_init_callback_set( void bacnet_basic_init_callback_set(
bacnet_basic_callback callback, void *context); bacnet_basic_callback callback, void *context);
BACNET_STACK_EXPORT
void bacnet_basic_task(void); void bacnet_basic_task(void);
BACNET_STACK_EXPORT
void bacnet_basic_task_callback_set( void bacnet_basic_task_callback_set(
bacnet_basic_callback callback, void *context); bacnet_basic_callback callback, void *context);
BACNET_STACK_EXPORT
void bacnet_basic_task_object_timer_set(unsigned long milliseconds); void bacnet_basic_task_object_timer_set(unsigned long milliseconds);
BACNET_STACK_EXPORT
void bacnet_basic_store_callback_set(bacnet_basic_store_callback callback); void bacnet_basic_store_callback_set(bacnet_basic_store_callback callback);
BACNET_STACK_EXPORT
unsigned long bacnet_basic_uptime_seconds(void); unsigned long bacnet_basic_uptime_seconds(void);
BACNET_STACK_EXPORT
unsigned long bacnet_basic_packet_count(void); unsigned long bacnet_basic_packet_count(void);
#ifdef __cplusplus #ifdef __cplusplus
src/bacnet/basic/server/bacnet_port.h
+2
View File
@@ -18,7 +18,9 @@
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
BACNET_STACK_EXPORT
bool bacnet_port_init(void); bool bacnet_port_init(void);
BACNET_STACK_EXPORT
void bacnet_port_task(void); void bacnet_port_task(void);
#ifdef __cplusplus #ifdef __cplusplus
src/bacnet/basic/server/bacnet_port_ipv4.h
+3
View File
@@ -19,9 +19,12 @@
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
BACNET_STACK_EXPORT
void bacnet_port_ipv4_foreign_device_init( void bacnet_port_ipv4_foreign_device_init(
const uint16_t ttl_seconds, const BACNET_IP_ADDRESS *bbmd_address); const uint16_t ttl_seconds, const BACNET_IP_ADDRESS *bbmd_address);
BACNET_STACK_EXPORT
void bacnet_port_ipv4_task(uint16_t elapsed_seconds); void bacnet_port_ipv4_task(uint16_t elapsed_seconds);
BACNET_STACK_EXPORT
bool bacnet_port_ipv4_init(void); bool bacnet_port_ipv4_init(void);
#ifdef __cplusplus #ifdef __cplusplus
src/bacnet/basic/server/bacnet_port_ipv6.h
+3
View File
@@ -19,9 +19,12 @@
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
BACNET_STACK_EXPORT
void bacnet_port_ipv6_foreign_device_init( void bacnet_port_ipv6_foreign_device_init(
const uint16_t ttl_seconds, const BACNET_IP6_ADDRESS *bbmd_address); const uint16_t ttl_seconds, const BACNET_IP6_ADDRESS *bbmd_address);
BACNET_STACK_EXPORT
void bacnet_port_ipv6_task(uint16_t elapsed_seconds); void bacnet_port_ipv6_task(uint16_t elapsed_seconds);
BACNET_STACK_EXPORT
bool bacnet_port_ipv6_init(void); bool bacnet_port_ipv6_init(void);
#ifdef __cplusplus #ifdef __cplusplus
test/bacnet/basic/program/ubasic/src/main.c
+7 -7
View File
@@ -111,7 +111,7 @@ struct test_bacnet_object {
uint16_t object_type; uint16_t object_type;
uint32_t object_instance; uint32_t object_instance;
uint32_t property_id; uint32_t property_id;
VARIABLE_TYPE property_value; UBASIC_VARIABLE_TYPE property_value;
char *object_name; char *object_name;
}; };
static struct test_bacnet_object Test_BACnet_Object[5]; static struct test_bacnet_object Test_BACnet_Object[5];
@@ -130,7 +130,7 @@ static void bacnet_write_property(
uint16_t object_type, uint16_t object_type,
uint32_t instance, uint32_t instance,
uint32_t property_id, uint32_t property_id,
VARIABLE_TYPE value) UBASIC_VARIABLE_TYPE value)
{ {
if (instance < ARRAY_SIZE(Test_BACnet_Object)) { if (instance < ARRAY_SIZE(Test_BACnet_Object)) {
Test_BACnet_Object[instance].object_type = object_type; 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) uint16_t object_type, uint32_t instance, uint32_t property_id)
{ {
if (instance < ARRAY_SIZE(Test_BACnet_Object)) { if (instance < ARRAY_SIZE(Test_BACnet_Object)) {
@@ -191,7 +191,7 @@ static void test_ubasic_gpio(void)
"next i;" "next i;"
"println 'average x y=', a, z;" "println 'average x y=', a, z;"
"end;"; "end;";
VARIABLE_TYPE value = 0; UBASIC_VARIABLE_TYPE value = 0;
data.mstimer_now = tick_now; data.mstimer_now = tick_now;
data.serial_write = serial_write; data.serial_write = serial_write;
data.gpio_config = gpio_config; data.gpio_config = gpio_config;
@@ -244,7 +244,7 @@ static void test_ubasic_bacnet(void)
"a = bac_read(0, 1, 85);" "a = bac_read(0, 1, 85);"
"println 'bac_read 0, 1, 85 = ' a;" "println 'bac_read 0, 1, 85 = ' a;"
"end;"; "end;";
VARIABLE_TYPE value = 0; UBASIC_VARIABLE_TYPE value = 0;
data.mstimer_now = tick_now; data.mstimer_now = tick_now;
data.serial_write = serial_write; data.serial_write = serial_write;
data.bacnet_create_object = bacnet_create_object; data.bacnet_create_object = bacnet_create_object;
@@ -326,7 +326,7 @@ static void test_ubasic_math(void)
"println 'x^3=' w;" "println 'x^3=' w;"
"end;"; "end;";
VARIABLE_TYPE value = 0, xvalue = 0, arrayvalue[5]; UBASIC_VARIABLE_TYPE value = 0, xvalue = 0, arrayvalue[5];
unsigned i; unsigned i;
int32_t value_int = 0; int32_t value_int = 0;
int32_t value_frac = 0; int32_t value_frac = 0;
@@ -408,7 +408,7 @@ static void test_ubasic(void)
":l1 " ":l1 "
" println 'subroutine';" " println 'subroutine';"
"return;"; "return;";
VARIABLE_TYPE value = 0; UBASIC_VARIABLE_TYPE value = 0;
int32_t value_int = 0; int32_t value_int = 0;
ubasic_load_program(&data, program); ubasic_load_program(&data, program);