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 "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)
src/bacnet/basic/client/bac-data.h
+9
View File
@@ -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,
src/bacnet/basic/client/bac-discover.h
+39 -2
View File
@@ -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
src/bacnet/basic/client/bac-rw.h
+15
View File
@@ -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
src/bacnet/basic/client/bac-task.h
+2
View File
@@ -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
src/bacnet/basic/program/ubasic/config.h
+80 -113
View File
@@ -33,150 +33,117 @@
#include <string.h>
#include <ctype.h>
#include <stdio.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
#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_ */
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 "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;
src/bacnet/basic/program/ubasic/tokenizer.h
+118 -118
View File
@@ -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 <stdbool.h>
#include <stdint.h>
#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
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 <stdio.h>
#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__ */
src/bacnet/basic/server/bacnet_basic.h
+8
View File
@@ -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
src/bacnet/basic/server/bacnet_port.h
+2
View File
@@ -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
src/bacnet/basic/server/bacnet_port_ipv4.h
+3
View File
@@ -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
src/bacnet/basic/server/bacnet_port_ipv6.h
+3
View File
@@ -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
test/bacnet/basic/program/ubasic/src/main.c
+7 -7
View File
@@ -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);