luisgulo/gambas-source-code
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Make the compiler more clever when deciding if an identifier is a reserved keyword or not. Some optimizations in the compiler parser.

Browse Source 
[INTERPRETER]
* OPT: Put less code in the main interpreter loop because it became too big again with gcc 12.

[COMPILER]
* OPT: Some optimizations in the parser.
* NEW: Make the compiler more clever when deciding if an identifier is a reserved keyword or not.
This commit is contained in:
Benoît Minisini 2022-12-04 20:00:04 +01:00
parent c1687958b3
commit 7a238f4c76
11 changed files with 411 additions and 384 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
main/gbc/gbc_class.c
View File

@ -58,8 +58,8 @@ void CLASS_create(CLASS **result)
ARRAY_create(&class->structure);
ARRAY_create(&class->names);
TABLE_create(&class->table, sizeof(CLASS_SYMBOL), TF_IGNORE_CASE);
TABLE_create(&class->string, sizeof(SYMBOL), TF_NORMAL);
TABLE_create_inc(&class->table, sizeof(CLASS_SYMBOL), TF_IGNORE_CASE, 1024);
TABLE_create_inc(&class->string, sizeof(SYMBOL), TF_NORMAL, 1024);
CLEAR(&func);
TYPE_clear(&func.type);

69
main/gbc/gbc_read.c
View File

@ -48,7 +48,6 @@
#include "gbc_read.h"
//#define DEBUG
//#define BIG_COMMENT 1
static bool is_init = FALSE;
static COMPILE *comp;
@ -76,10 +75,11 @@ enum
GOTO_STRING,
GOTO_IDENT,
GOTO_QUOTED_IDENT,
GOTO_NUMBER,
GOTO_ERROR,
GOTO_SHARP,
GOTO_OTHER
GOTO_NUMBER,
GOTO_NUMBER_OR_OPERATOR,
GOTO_OPERATOR
};
static void READ_init(void)
@ -116,8 +116,10 @@ static void READ_init(void)
first_car[i] = GOTO_NUMBER;
else if (i >= 127)
first_car[i] = GOTO_ERROR;
else if (i == '+' || i == '-' || i == '&')
first_car[i] = GOTO_NUMBER_OR_OPERATOR;
else
first_car[i] = GOTO_OTHER;
first_car[i] = GOTO_OPERATOR;
}
is_init = TRUE;
@ -383,7 +385,7 @@ static unsigned char next_char(void)
static void add_pattern_no_dump(int type, int index)
{
comp->pattern[comp->pattern_count] = PATTERN_make(type, index);
comp->pattern[comp->pattern_count] = _last_pattern = PATTERN_make(type, index);
comp->pattern_pos[comp->pattern_count] = source_ptr - _line_start;
comp->pattern_count++;
}
@ -461,7 +463,7 @@ static void jump_to_next_prep(void)
}
}
static void add_newline()
INLINE static void add_newline()
{
int action = PREP_CONTINUE;
@ -757,10 +759,11 @@ void READ_do(void)
&&__STRING,
&&__IDENT,
&&__QUOTED_IDENT,
&&__NUMBER,
&&__ERROR,
&&__SHARP,
&&__OTHER
&&__NUMBER,
&&__NUMBER_OR_OPERATOR,
&&__OPERATOR
};
unsigned char car;
@ -835,12 +838,6 @@ void READ_do(void)
_begin_line = FALSE;
continue;
__NUMBER:
add_number();
_begin_line = FALSE;
continue;
__SHARP:
if (_begin_line)
@ -853,37 +850,27 @@ void READ_do(void)
continue;
}
else
goto __OTHER;
goto __OPERATOR;
__OTHER:
#if BIG_COMMENT
if (car == '/' && get_char_offset(1) == '*')
{
for(;;)
{
source_ptr++;
car = get_char();
if (car == 0)
break;
if (car == '*' && get_char_offset(1) == '/')
{
source_ptr += 2;
break;
}
if (car == '\n')
add_newline();
}
__NUMBER_OR_OPERATOR:
_begin_line = FALSE;
continue;
}
#endif
if (add_number())
add_operator();
goto __OPERATOR;
_begin_line = FALSE;
continue;
__NUMBER:
add_number();
_begin_line = FALSE;
continue;
__OPERATOR:
add_operator();
_begin_line = FALSE;
continue;
}
__BREAK:

2
main/gbx/gbx_api.c
View File

@ -2186,7 +2186,7 @@ int GB_CountArray(void *data)
void *GB_Add(void *pdata)
{
return ARRAY_add_void_size(pdata);
return ARRAY_add_void_size((char **)pdata);
}
char *GB_NewZeroString(char *src)

201
main/gbx/gbx_exec_loop.c
View File

@ -352,6 +352,103 @@ NOINLINE static void _push_me(ushort code)
PUSH();
}
NOINLINE static bool _push_misc(ushort code)
{
static const void *_jump[] =
{ &&__PUSH_NULL, &&__PUSH_VOID, &&__PUSH_FALSE, &&__PUSH_TRUE, &&__PUSH_LAST, &&__PUSH_STRING, &&__PUSH_PINF, &&__PUSH_MINF, &&__PUSH_COMPLEX,
&&__PUSH_VARGS, &&__PUSH_DROP_VARGS, &&__JIT_RETURN, &&__PUSH_END_VARGS };
//, &&__POP_LAST };
goto *_jump[GET_UX()];
__PUSH_NULL:
VALUE_null(SP);
SP++;
return FALSE;
__PUSH_VOID:
SP->type = T_VOID;
SP++;
return FALSE;
__PUSH_FALSE:
SP->type = T_BOOLEAN;
SP->_integer.value = 0;
SP++;
return FALSE;
__PUSH_TRUE:
SP->type = T_BOOLEAN;
SP->_integer.value = -1;
SP++;
return FALSE;
__PUSH_LAST:
SP->type = T_OBJECT;
SP->_object.object = EVENT_Last;
OBJECT_REF_CHECK(EVENT_Last);
SP++;
return FALSE;
__PUSH_STRING:
SP->type = T_CSTRING;
SP->_string.addr = ""; // NULL
SP->_string.start = SP->_string.len = 0;
SP++;
return FALSE;
__PUSH_PINF:
SP->type = T_FLOAT;
SP->_float.value = INFINITY;
SP++;
return FALSE;
__PUSH_MINF:
SP->type = T_FLOAT;
SP->_float.value = -INFINITY;
SP++;
return FALSE;
__PUSH_COMPLEX:
EXEC_push_complex();
return FALSE;
__PUSH_VARGS:
EXEC_push_vargs();
return FALSE;
__PUSH_DROP_VARGS:
EXEC_drop_vargs();
return FALSE;
__JIT_RETURN:
return TRUE;
__PUSH_END_VARGS:
EXEC_end_vargs();
return FALSE;
/*__POP_LAST:
VALUE_conv(&SP[-1], T_OBJECT);
OBJECT_UNREF(EVENT_Last);
SP--;
EVENT_Last = SP->_object.object;
goto _NEXT;*/
}
void EXEC_loop(void)
{
static const void *jump_table[256] =
@ -748,7 +845,6 @@ _PUSH_LOCAL:
*SP = BP[GET_XX()];
PUSH();
goto _NEXT;
_PUSH_LOCAL_NOREF:
@ -762,7 +858,6 @@ _PUSH_PARAM:
*SP = PP[GET_XX()];
PUSH();
goto _NEXT;
_PUSH_PARAM_NOREF:
@ -786,13 +881,6 @@ _PUSH_UNKNOWN:
/*-----------------------------------------------*/
/*_PUSH_SPECIAL:
EXEC_push_special();
goto _NEXT;*/
/*-----------------------------------------------*/
_PUSH_EVENT:
/*
@ -930,101 +1018,10 @@ _PUSH_ME:
_PUSH_MISC:
{
static const void *_jump[] =
{ &&__PUSH_NULL, &&__PUSH_VOID, &&__PUSH_FALSE, &&__PUSH_TRUE, &&__PUSH_LAST, &&__PUSH_STRING, &&__PUSH_PINF, &&__PUSH_MINF, &&__PUSH_COMPLEX,
&&__PUSH_VARGS, &&__PUSH_DROP_VARGS, &&__JIT_RETURN, &&__PUSH_END_VARGS };
//, &&__POP_LAST };
goto *_jump[GET_UX()];
__PUSH_NULL:
VALUE_null(SP);
SP++;
goto _NEXT;
__PUSH_VOID:
SP->type = T_VOID;
SP++;
goto _NEXT;
__PUSH_FALSE:
SP->type = T_BOOLEAN;
SP->_integer.value = 0;
SP++;
goto _NEXT;
__PUSH_TRUE:
SP->type = T_BOOLEAN;
SP->_integer.value = -1;
SP++;
goto _NEXT;
__PUSH_LAST:
SP->type = T_OBJECT;
SP->_object.object = EVENT_Last;
OBJECT_REF_CHECK(EVENT_Last);
SP++;
goto _NEXT;
__PUSH_STRING:
SP->type = T_CSTRING;
SP->_string.addr = ""; // NULL
SP->_string.start = SP->_string.len = 0;
SP++;
goto _NEXT;
__PUSH_PINF:
SP->type = T_FLOAT;
SP->_float.value = INFINITY;
SP++;
goto _NEXT;
__PUSH_MINF:
SP->type = T_FLOAT;
SP->_float.value = -INFINITY;
SP++;
goto _NEXT;
__PUSH_COMPLEX:
EXEC_push_complex();
goto _NEXT;
__PUSH_VARGS:
EXEC_push_vargs();
goto _NEXT;
__PUSH_DROP_VARGS:
EXEC_drop_vargs();
goto _NEXT;
__JIT_RETURN:
if (_push_misc(code))
return;
__PUSH_END_VARGS:
EXEC_end_vargs();
goto _NEXT;
goto _NEXT;
/*__POP_LAST:
VALUE_conv(&SP[-1], T_OBJECT);
OBJECT_UNREF(EVENT_Last);
SP--;
EVENT_Last = SP->_object.object;
goto _NEXT;*/
}
/*-----------------------------------------------*/

32
main/share/gb_array.h
View File

@ -36,15 +36,17 @@ typedef
typedef
int (*ARRAY_COMP_FUNC)(const void *, const void *);
#define DATA_TO_ARRAY(data) ((ARRAY *)(data) - 1)
#define ARRAY_TO_DATA(array) ((char *)((ARRAY *)(array) + 1))
#define DATA_TO_ARRAY(_data) ((ARRAY *)(_data) - 1)
#define ARRAY_TO_DATA(_array) ((char *)((ARRAY *)(_array) + 1))
#define ARRAY_create(data) ARRAY_create_with_size((data), sizeof(**(data)), 32)
#define ARRAY_create_inc(data, inc) ARRAY_create_with_size((data), sizeof(**(data)), (inc))
#define ARRAY_create(_data) ARRAY_create_with_size((_data), sizeof(**(_data)), 32)
#define ARRAY_create_inc(_data, _inc) ARRAY_create_with_size((_data), sizeof(**(_data)), (_inc))
void ARRAY_create_with_size(void *p_data, size_t size, uint inc);
void ARRAY_delete(void *p_data);
#define ARRAY_set_inc(_data, _inc) (DATA_TO_ARRAY(_data)->inc = _inc)
#define ARRAY_size(_data) (DATA_TO_ARRAY(_data)->size)
#define ARRAY_count(_data) ((_data) ? DATA_TO_ARRAY(_data)->count : 0)
@ -74,6 +76,28 @@ void *ARRAY_add_data_one(void *p_data, bool zero);
ptr; \
})
#define ARRAY_add_data_one(_pdata, _zero) \
({ \
ARRAY *__array = DATA_TO_ARRAY(*(_pdata)); \
int size = __array->size; \
char *ptr; \
int old_count = __array->count; \
\
__array->count++; \
\
if (__array->count <= __array->max) \
{ \
ptr = (char *)*(_pdata) + size * old_count; \
} \
else \
{ \
ARRAY_realloc(_pdata); \
ptr = (char *)*(_pdata) + size * old_count; \
} \
if (_zero) memset(ptr, 0, size); \
(void *)ptr; \
})
#define ARRAY_add(_pdata) ARRAY_add_one(_pdata, FALSE)
#define ARRAY_add_void(_pdata) ARRAY_add_one(_pdata, TRUE)
#define ARRAY_add_size(_pdata) ARRAY_add_data_one(_pdata, FALSE)

32
main/share/gb_array_temp.h
View File

@ -58,6 +58,7 @@ void ARRAY_delete(void *p_data)
*data = NULL;
}
static inline ARRAY *array_realloc(ARRAY *array)
{
ARRAY *new_array;
@ -68,6 +69,7 @@ static inline ARRAY *array_realloc(ARRAY *array)
return new_array;
}
void *ARRAY_add_data(void *p_data, uint num, bool zero)
{
void **data = (void **)p_data;
@ -93,25 +95,17 @@ void *ARRAY_add_data(void *p_data, uint num, bool zero)
return ptr;
}
void ARRAY_realloc(void *p_data) //, bool zero)
void ARRAY_realloc(void *p_data)
{
void **data = (void **)p_data;
ARRAY *array = DATA_TO_ARRAY(*data);
/*array->max = array->inc + ((array->count + array->inc) / array->inc) * array->inc;
new_array = array;
REALLOC(&new_array, sizeof(ARRAY) + array->max * size);*/
*data = ARRAY_TO_DATA(array_realloc(array));
//fprintf(stderr, "ARRAY_realloc: %p (%d) -> %p (%d) [%d]\n", array, old_max, new_array, new_array->max, size);
/*if (zero)
{
//fprintf(stderr, "ARRAY_realloc: memset(%p, 0, %d)\n", ARRAY_TO_DATA(new_array) + old_max * size, (new_array->max - old_max) * size);
memset(ARRAY_TO_DATA(new_array) + old_max * size, 0, (new_array->max - old_max) * size);
}*/
}
void *ARRAY_add_data_one(void *p_data, bool zero)
/*void *ARRAY_add_data_one(void *p_data, bool zero)
{
void **data = (void **)p_data;
register ARRAY *array = DATA_TO_ARRAY(*data);
@ -122,20 +116,16 @@ void *ARRAY_add_data_one(void *p_data, bool zero)
if (array->count > array->max)
{
/*array->max = ((array->count + array->inc - 1) / array->inc) * array->inc;
new_array = array;
REALLOC(&new_array, sizeof(ARRAY) + array->max * size);*/
array = array_realloc(array);
*data = ARRAY_TO_DATA(array);
}
ptr = (char *)array + sizeof(ARRAY) + size * (array->count - 1);
if (zero) memset(ptr, 0, size);
return ptr;
}
}*/
void ARRAY_remove_last(void *p_data)
@ -149,14 +139,6 @@ void ARRAY_remove_last(void *p_data)
array->count--;
}
#if 0
void *ARRAY_get(void *data, int pos)
{
ARRAY *array = DATA_TO_ARRAY(data);
return (char *)data + array->size * pos;
}
#endif
void *ARRAY_insert_many(void *p_data, int pos, uint count)
{

15
main/share/gb_reserved.h
View File

@ -74,6 +74,19 @@ enum {
RST_READ
};
enum {
RSJ_OTHER,
RSJ_ME,
RSJ_CLASS,
RSJ_STRUCT,
RSJ_SUB,
RSJ_CONST,
RSJ_READ,
RSJ_DATATYPE,
RSJ_OPTIONAL,
RSJ_BYREF
};
#define RES_is_operator(value) (COMP_res_info[value].flag & RSF_OP)
#define RES_is_type(value) (COMP_res_info[value].flag & RSF_TYPE)
#define RES_is_assignment(value) (COMP_res_info[value].flag & RSF_ASGN)
@ -95,6 +108,8 @@ enum {
#define RES_is_preprocessor(value) (COMP_res_info[value].flag & RSF_PREP)
#define RES_is_identifier(value) (isalpha(*COMP_res_info[value].name))
typedef
enum {
RS_NONE,

386
main/share/gb_reserved_keyword.h
View File

@ -28,203 +28,203 @@ COMP_INFO COMP_res_info[] =
{
{ "" },
{ "Boolean", RSF_TYPE, T_BOOLEAN, 8 },
{ "Byte", RSF_TYPE, T_BYTE, 8 },
{ "Date", RSF_TYPE, T_DATE, 8 },
{ "Single", RSF_TYPE, T_SINGLE, 8 },
{ "Float", RSF_TYPE, T_FLOAT, 8 },
{ "Integer", RSF_TYPE, T_INTEGER, 8 },
{ "Long", RSF_TYPE, T_LONG, 8 },
{ "Short", RSF_TYPE, T_SHORT, 8 },
{ "String", RSF_TYPE, T_STRING, 8 },
{ "Variant", RSF_TYPE, T_VARIANT, 8 },
{ "Object", RSF_TYPE, T_OBJECT, 8 },
{ "Pointer", RSF_TYPE, T_POINTER, 8 },
{ "Class", RSF_CLASS|RSF_AS, 0, 2 },
{ "Function", RSF_IDENT, 0, 4 },
{ "Struct", RSF_PREV, 0, 3 },
{ "Const", RSF_IDENT, 0, 5 },
{ "Private", RSF_IDENT|RSF_PUB, },
{ "Public", RSF_IDENT|RSF_PUB, },
{ "Static", RSF_PUB },
{ "Fast", RSF_PUB },
{ "Unsafe", RSF_PUB },
{ "Property", RSF_IDENT },
{ "Event", RSF_IDENT|RSF_EVENT },
{ "Inherits", RSF_CLASS|RSF_AS },
{ "Implements" },
{ "Export" },
{ "As", RSF_AS },
{ "Of" },
{ "Dim", RSF_IDENT, },
{ "New", RSF_AS , 0, 1 },
{ "Procedure", RSF_IDENT, 0, 4 },
{ "Sub", RSF_IDENT, 0, 4 },
{ "Return" },
{ "Optional" },
{ "Output" },
{ "Do" },
{ "Loop" },
{ "While" },
{ "Until" },
{ "Repeat" },
{ "Wend" },
{ "If" },
{ "Then" },
{ "Else" },
{ "Endif" },
{ "End" },
{ "For" },
{ "To" },
{ "DownTo" },
{ "From" },
{ "Step" },
{ "Next" },
{ "Select" },
{ "Case" },
{ "Exit" },
{ "Break" },
{ "Continue" },
{ "Goto" },
{ "GoSub" },
{ "On" },
{ "Me", 0, 0, 1 },
{ "Last", 0, 0, 1 },
{ "Try" },
{ "Finally" },
{ "Catch" },
{ "With" },
{ "True" },
{ "False" },
{ "Swap" },
{ "Null" },
{ "Extern", RSF_IDENT, 0, 5 },
{ "Each" },
{ "In" },
{ "Default" },
{ "Stop" },
{ "Quit" },
{ "Raise", RSF_IDENT|RSF_EVENT },
{ "Error" },
{ "Super", 0, 0, 1 },
{ "Enum", 0, 0, 6 },
{ "Let" },
{ "+Inf" },
{ "-Inf" },
{ "Use" },
{ "Boolean", RSF_TYPE, T_BOOLEAN, RSJ_DATATYPE },
{ "Byte", RSF_TYPE, T_BYTE, RSJ_DATATYPE },
{ "Date", RSF_TYPE, T_DATE, RSJ_DATATYPE },
{ "Single", RSF_TYPE, T_SINGLE, RSJ_DATATYPE },
{ "Float", RSF_TYPE, T_FLOAT, RSJ_DATATYPE },
{ "Integer", RSF_TYPE, T_INTEGER, RSJ_DATATYPE },
{ "Long", RSF_TYPE, T_LONG, RSJ_DATATYPE },
{ "Short", RSF_TYPE, T_SHORT, RSJ_DATATYPE },
{ "String", RSF_TYPE, T_STRING, RSJ_DATATYPE },
{ "Variant", RSF_TYPE, T_VARIANT, RSJ_DATATYPE },
{ "Object", RSF_TYPE, T_OBJECT, RSJ_DATATYPE },
{ "Pointer", RSF_TYPE, T_POINTER, RSJ_DATATYPE },
{ "Class", RSF_CLASS|RSF_AS, 0, RSJ_CLASS },
{ "Function", RSF_IDENT, 0, RSJ_SUB },
{ "Struct", RSF_PREV, 0, RSJ_STRUCT },
{ "Const", RSF_IDENT, 0, RSJ_CONST },
{ "Private", RSF_IDENT|RSF_PUB, },
{ "Public", RSF_IDENT|RSF_PUB, },
{ "Static", RSF_PUB },
{ "Fast", RSF_PUB },
{ "Unsafe", RSF_PUB },
{ "Property", RSF_IDENT },
{ "Event", RSF_IDENT|RSF_EVENT },
{ "Inherits", RSF_CLASS|RSF_AS },
{ "Implements" },
{ "Export" },
{ "As", RSF_AS },
{ "Of" },
{ "Dim", RSF_IDENT, },
{ "New", RSF_AS , 0, RSJ_ME },
{ "Procedure", RSF_IDENT, 0, RSJ_SUB },
{ "Sub", RSF_IDENT, 0, RSJ_SUB },
{ "Return" },
{ "Optional", 0, 0, RSJ_OPTIONAL },
{ "Output" },
{ "Do" },
{ "Loop" },
{ "While" },
{ "Until" },
{ "Repeat" },
{ "Wend" },
{ "If" },
{ "Then" },
{ "Else" },
{ "Endif" },
{ "End" },
{ "For" },
{ "To" },
{ "DownTo" },
{ "From" },
{ "Step" },
{ "Next" },
{ "Select" },
{ "Case" },
{ "Exit" },
{ "Break" },
{ "Continue" },
{ "Goto" },
{ "GoSub" },
{ "On" },
{ "Me", 0, 0, RSJ_ME },
{ "Last", 0, 0, RSJ_ME },
{ "Try" },
{ "Finally" },
{ "Catch" },
{ "With" },
{ "True", 0, 0, RSJ_ME },
{ "False", 0, 0, RSJ_ME },
{ "Swap" },
{ "Null", 0, 0, RSJ_ME },
{ "Extern", RSF_IDENT, 0, RSJ_CONST },
{ "Each" },
{ "In" },
{ "Default" },
{ "Stop" },
{ "Quit" },
{ "Raise", RSF_IDENT|RSF_EVENT },
{ "Error" },
{ "Super", 0, 0, RSJ_ME },
{ "Enum", 0, 0, RSJ_CONST },
{ "Let" },
{ "+Inf" },
{ "-Inf" },
{ "Use" },
{ "Print" },
{ "Input" },
{ "Read", RSF_PREV, 0, 7 },
{ "Peek", },
{ "Write", RSF_PREV, 0, 7 },
{ "Open" },
{ "Close" },
{ "Seek" },
{ "Append" },
{ "Create" },
{ "Binary" },
{ "Line" },
{ "Flush" },
{ "Exec" },
{ "Shell" },
{ "Wait" },
{ "Sleep" },
{ "Kill" },
{ "Move" },
{ "Copy" },
{ "Inc" },
{ "Dec" },
{ "Mkdir" },
{ "Rmdir" },
{ "Watch" },
{ "Link" },
{ "Lock" },
{ "Unlock" },
{ "Library" },
{ "Debug" },
{ "Assert" },
{ "Pipe" },
{ "Randomize" },
{ "ByRef" },
{ "Memory" },
{ "Chmod" },
{ "Chown" },
{ "Chgrp" },
{ "Print" },
{ "Input" },
{ "Read", RSF_PREV, 0, RSJ_READ },
{ "Peek", },
{ "Write", RSF_PREV, 0, RSJ_READ },
{ "Open" },
{ "Close" },
{ "Seek" },
{ "Append" },
{ "Create" },
{ "Binary" },
{ "Line" },
{ "Flush" },
{ "Exec" },
{ "Shell" },
{ "Wait" },
{ "Sleep" },
{ "Kill" },
{ "Move" },
{ "Copy" },
{ "Inc" },
{ "Dec" },
{ "Mkdir" },
{ "Rmdir" },
{ "Watch" },
{ "Link" },
{ "Lock" },
{ "Unlock" },
{ "Library" },
{ "Debug" },
{ "Assert" },
{ "Pipe" },
{ "Randomize" },
{ "ByRef", 0, 0, RSJ_BYREF },
{ "Memory" },
{ "Chmod" },
{ "Chown" },
{ "Chgrp" },
{ "#If", RSF_PREP, },
{ "#Else", RSF_PREP, },
{ "#Endif", RSF_PREP, },
{ "#Const", RSF_PREP, },
{ "#Line", RSF_PREP, },
{ "#Include", RSF_PREP, },
{ "#Script", RSF_PREP, },
{ "#If", RSF_PREP, },
{ "#Else", RSF_PREP, },
{ "#Endif", RSF_PREP, },
{ "#Const", RSF_PREP, },
{ "#Line", RSF_PREP, },
{ "#Include", RSF_PREP, },
{ "#Script", RSF_PREP, },
{ ":", RSF_NONE, OP_COLON, 0, 0, T_OBJECT }, // Use for the immediate collection syntax
{ ";" },
{ "," },
{ "..." },
{ "#" },
{ "@" },
{ "?" },
{ "{" },
{ "}" },
{ "=", RSF_OP2S, OP_EQUAL, 0, 4, T_BOOLEAN, C_EQ },
{ "==", RSF_OP2S, OP_NEAR, 0, 4, T_BOOLEAN, C_NEAR },
{ "(", RSF_OPP, OP_LBRA, 0, 12 },
{ ")", },
{ ".", RSF_OP2|RSF_POINT, OP_PT, 0, 20, T_VARIANT },
{ "!", RSF_OP2|RSF_POINT, OP_EXCL, 0, 20, T_VARIANT },
{ "+", RSF_OP2, OP_PLUS, 0, 5, RST_ADD, C_ADD },
{ "-", RSF_OP2, OP_MINUS, 0, 5, RST_ADD, C_SUB },
{ "*", RSF_OP2, OP_STAR, 0, 6, RST_ADD, C_MUL },
{ "/", RSF_OP2, OP_SLASH, 0, 6, T_FLOAT, C_DIV },
{ "^", RSF_OP2S, OP_FLEX, 0, 7, T_FLOAT, C_POW },
{ "&", RSF_OPN, OP_AMP, 0, 9, T_STRING, C_CAT },
{ "&/", RSF_OPN, OP_FILE, 0, 8, T_STRING, C_FILE },
{ ">", RSF_OP2S, OP_GT, 0, 4, T_BOOLEAN, C_GT },
{ "<", RSF_OP2S, OP_LT, 0, 4, T_BOOLEAN, C_LT },
{ ">=", RSF_OP2S, OP_GE, 0, 4, T_BOOLEAN, C_GE },
{ "<=", RSF_OP2S, OP_LE, 0, 4, T_BOOLEAN, C_LE },
{ "<>", RSF_OP2S, OP_NE, 0, 4, T_BOOLEAN, C_NE },
{ "[", RSF_OPP, OP_LSQR, 0, 12, RST_GET },
{ "]", RSF_NONE, OP_RSQR, 0, 0, T_OBJECT }, // Use for the immediate array syntax
{ "And", RSF_OP2SM, OP_AND, 0, 2, RST_AND, C_AND },
{ "Or", RSF_OP2SM, OP_OR, 0, 2, RST_AND, C_OR },
{ "Not", RSF_OP1, OP_NOT, 0, 10, RST_NOT, C_NOT },
{ "Xor", RSF_OP2SM, OP_XOR, 0, 2, RST_AND, C_XOR },
{ "Shl", RSF_OP2, OP_SHL, 0, 2, RST_BCLR, C_BCLR, 5 },
{ "Asl", RSF_OP2, OP_SHL, 0, 2, RST_BCLR, C_BCLR, 5 },
{ "Shr", RSF_OP2, OP_SHL, 0, 2, RST_BCLR, C_BCLR, 6 },
{ "Asr", RSF_OP2, OP_SHL, 0, 2, RST_BCLR, C_BCLR, 6 },
{ "Rol", RSF_OP2, OP_SHL, 0, 2, RST_BCLR, C_BCLR, 7 },
{ "Ror", RSF_OP2, OP_SHL, 0, 2, RST_BCLR, C_BCLR, 8 },
{ "Lsl", RSF_OP2, OP_SHL, 0, 2, RST_BCLR, C_BCLR, 9 },
{ "Lsr", RSF_OP2, OP_SHL, 0, 2, RST_BCLR, C_BCLR, 10 },
{ "\\", RSF_OP2S, OP_DIV, 0, 6, T_INTEGER, C_QUO },
{ "Div", RSF_OP2S, OP_DIV, 0, 6, T_INTEGER, C_QUO },
{ "%", RSF_OP2S, OP_MOD, 0, 6, RST_MOD, C_REM },
{ "Mod", RSF_OP2S, OP_MOD, 0, 6, RST_MOD, C_REM },
{ "Is", RSF_OP2|RSF_AS|RSF_NOT, OP_IS, 0, 11, T_BOOLEAN, C_IS, 0 },
{ "", RSF_OP2|RSF_AS, OP_IS, 0, 11, T_BOOLEAN, C_IS, 1 },
{ "Like", RSF_OP2S|RSF_NOT, OP_LIKE, 0, 4, T_BOOLEAN, C_LIKE, 0 },
{ "", RSF_OP2S, OP_LIKE, 0, 4, T_BOOLEAN, C_LIKE, 4 }, // NOT LIKE
{ "Begins", RSF_OP2S|RSF_NOT, OP_LIKE, 0, 4, T_BOOLEAN, C_LIKE, 1 },
{ "", RSF_OP2S, OP_LIKE, 0, 4, T_BOOLEAN, C_LIKE, 5 }, // NOT BEGINS
{ "Ends", RSF_OP2S|RSF_NOT, OP_LIKE, 0, 4, T_BOOLEAN, C_LIKE, 2 },
{ "", RSF_OP2S, OP_LIKE, 0, 4, T_BOOLEAN, C_LIKE, 6 }, // NOT ENDS
{ "Match", RSF_OP2S|RSF_NOT, OP_LIKE, 0, 4, T_BOOLEAN, C_LIKE, 3 },
{ "", RSF_OP2S, OP_LIKE, 0, 4, T_BOOLEAN, C_LIKE, 7 }, // NOT MATCH
{ ":", RSF_NONE, OP_COLON, 0, 0, T_OBJECT }, // Use for the immediate collection syntax
{ ";" },
{ "," },
{ "..." },
{ "#" },
{ "@" },
{ "?" },
{ "{" },
{ "}" },
{ "=", RSF_OP2S, OP_EQUAL, 0, 4, T_BOOLEAN, C_EQ },
{ "==", RSF_OP2S, OP_NEAR, 0, 4, T_BOOLEAN, C_NEAR },
{ "(", RSF_OPP, OP_LBRA, 0, 12 },
{ ")", },
{ ".", RSF_OP2|RSF_POINT, OP_PT, 0, 20, T_VARIANT },
{ "!", RSF_OP2|RSF_POINT, OP_EXCL, 0, 20, T_VARIANT },
{ "+", RSF_OP2, OP_PLUS, 0, 5, RST_ADD, C_ADD },
{ "-", RSF_OP2, OP_MINUS, 0, 5, RST_ADD, C_SUB },
{ "*", RSF_OP2, OP_STAR, 0, 6, RST_ADD, C_MUL },
{ "/", RSF_OP2, OP_SLASH, 0, 6, T_FLOAT, C_DIV },
{ "^", RSF_OP2S, OP_FLEX, 0, 7, T_FLOAT, C_POW },
{ "&", RSF_OPN, OP_AMP, 0, 9, T_STRING, C_CAT },
{ "&/", RSF_OPN, OP_FILE, 0, 8, T_STRING, C_FILE },
{ ">", RSF_OP2S, OP_GT, 0, 4, T_BOOLEAN, C_GT },
{ "<", RSF_OP2S, OP_LT, 0, 4, T_BOOLEAN, C_LT },
{ ">=", RSF_OP2S, OP_GE, 0, 4, T_BOOLEAN, C_GE },
{ "<=", RSF_OP2S, OP_LE, 0, 4, T_BOOLEAN, C_LE },
{ "<>", RSF_OP2S, OP_NE, 0, 4, T_BOOLEAN, C_NE },
{ "[", RSF_OPP, OP_LSQR, 0, 12, RST_GET },
{ "]", RSF_NONE, OP_RSQR, 0, 0, T_OBJECT }, // Use for the immediate array syntax
{ "And", RSF_OP2SM, OP_AND, 0, 2, RST_AND, C_AND },
{ "Or", RSF_OP2SM, OP_OR, 0, 2, RST_AND, C_OR },
{ "Not", RSF_OP1, OP_NOT, 0, 10, RST_NOT, C_NOT },
{ "Xor", RSF_OP2SM, OP_XOR, 0, 2, RST_AND, C_XOR },
{ "Shl", RSF_OP2, OP_SHL, 0, 2, RST_BCLR, C_BCLR, 5 },
{ "Asl", RSF_OP2, OP_SHL, 0, 2, RST_BCLR, C_BCLR, 5 },
{ "Shr", RSF_OP2, OP_SHL, 0, 2, RST_BCLR, C_BCLR, 6 },
{ "Asr", RSF_OP2, OP_SHL, 0, 2, RST_BCLR, C_BCLR, 6 },
{ "Rol", RSF_OP2, OP_SHL, 0, 2, RST_BCLR, C_BCLR, 7 },
{ "Ror", RSF_OP2, OP_SHL, 0, 2, RST_BCLR, C_BCLR, 8 },
{ "Lsl", RSF_OP2, OP_SHL, 0, 2, RST_BCLR, C_BCLR, 9 },
{ "Lsr", RSF_OP2, OP_SHL, 0, 2, RST_BCLR, C_BCLR, 10 },
{ "\\", RSF_OP2S, OP_DIV, 0, 6, T_INTEGER, C_QUO },
{ "Div", RSF_OP2S, OP_DIV, 0, 6, T_INTEGER, C_QUO },
{ "%", RSF_OP2S, OP_MOD, 0, 6, RST_MOD, C_REM },
{ "Mod", RSF_OP2S, OP_MOD, 0, 6, RST_MOD, C_REM },
{ "Is", RSF_OP2|RSF_AS|RSF_NOT, OP_IS, 0, 11, T_BOOLEAN, C_IS, 0 },
{ "", RSF_OP2|RSF_AS, OP_IS, 0, 11, T_BOOLEAN, C_IS, 1 },
{ "Like", RSF_OP2S|RSF_NOT, OP_LIKE, 0, 4, T_BOOLEAN, C_LIKE, 0 },
{ "", RSF_OP2S, OP_LIKE, 0, 4, T_BOOLEAN, C_LIKE, 4 }, // NOT LIKE
{ "Begins", RSF_OP2S|RSF_NOT, OP_LIKE, 0, 4, T_BOOLEAN, C_LIKE, 1 },
{ "", RSF_OP2S, OP_LIKE, 0, 4, T_BOOLEAN, C_LIKE, 5 }, // NOT BEGINS
{ "Ends", RSF_OP2S|RSF_NOT, OP_LIKE, 0, 4, T_BOOLEAN, C_LIKE, 2 },
{ "", RSF_OP2S, OP_LIKE, 0, 4, T_BOOLEAN, C_LIKE, 6 }, // NOT ENDS
{ "Match", RSF_OP2S|RSF_NOT, OP_LIKE, 0, 4, T_BOOLEAN, C_LIKE, 3 },
{ "", RSF_OP2S, OP_LIKE, 0, 4, T_BOOLEAN, C_LIKE, 7 }, // NOT MATCH
{ "+=", RSF_ASGN, RS_PLUS },
{ "-=", RSF_ASGN, RS_MINUS },
{ "*=", RSF_ASGN, RS_STAR },
{ "/=", RSF_ASGN, RS_SLASH },
{ "\\=", RSF_ASGN, RS_BSLASH },
{ "%=", RSF_ASGN, RS_PERCENT },
{ "&=", RSF_ASGN, RS_AMP },
{ "&/=", RSF_ASGN, RS_FILE },
{ "^=", RSF_ASGN, RS_FLEX },
{ "+=", RSF_ASGN, RS_PLUS },
{ "-=", RSF_ASGN, RS_MINUS },
{ "*=", RSF_ASGN, RS_STAR },
{ "/=", RSF_ASGN, RS_SLASH },
{ "\\=", RSF_ASGN, RS_BSLASH },
{ "%=", RSF_ASGN, RS_PERCENT },
{ "&=", RSF_ASGN, RS_AMP },
{ "&/=", RSF_ASGN, RS_FILE },
{ "^=", RSF_ASGN, RS_FLEX },
{ NULL }
};

1
main/share/gb_table.h
View File

@ -63,6 +63,7 @@ void TABLE_create_static(TABLE *table, size_t size, TABLE_FLAG flag);
void TABLE_delete_static(TABLE *table);
void TABLE_create(TABLE **result, size_t size, TABLE_FLAG flag);
void TABLE_create_inc(TABLE **result, size_t size, TABLE_FLAG flag, uint inc);
void TABLE_create_from(TABLE **result, size_t size, const char *sym_list[], TABLE_FLAG flag);
void TABLE_delete(TABLE **table);

8
main/share/gb_table_temp.h
View File

@ -338,6 +338,14 @@ void TABLE_create(TABLE **result, size_t size, TABLE_FLAG flag)
}
void TABLE_create_inc(TABLE **result, size_t size, TABLE_FLAG flag, uint inc)
{
TABLE_create(result, size, flag);
ARRAY_set_inc((*result)->symbol, inc);
ARRAY_set_inc((*result)->sort, inc);
}
void TABLE_create_from(TABLE **result, size_t size, const char *sym_list[], TABLE_FLAG flag)
{
TABLE *table;

45
main/share/gbc_read_temp.h
View File

@ -221,7 +221,7 @@ static void add_identifier()
PATTERN last_pattern, last_last_pattern;
bool not_first;
bool can_be_reserved;
bool last_identifier, last_type, last_class, last_pub, last_point, last_excl;
bool last_next_ident, last_type, last_class, last_pub, last_point, last_excl;
#ifdef __EVAL_READ_C
bool exist = TRUE;
#endif
@ -310,26 +310,27 @@ static void add_identifier()
if (can_be_reserved)
{
//fprintf(stderr, "can_be_reserved: %.*s\n", len, start);
index = RESERVED_find_word(start, len);
can_be_reserved = (index >= 0);
}
if (can_be_reserved)
{
static void *jump[] = {
&&__OTHERS, &&__ME_NEW_LAST_SUPER, &&__CLASS, &&__STRUCT, &&__SUB_PROCEDURE_FUNCTION, &&__CONST_EXTERN, &&__ENUM, &&__READ, &&__DATATYPE
&&__OTHERS, &&__ME_NEW_LAST_SUPER, &&__CLASS, &&__STRUCT, &&__SUB_PROCEDURE_FUNCTION, &&__CONST_EXTERN_ENUM, &&__READ,
&&__DATATYPE, &&__OPTIONAL, &&__BYREF
};
last_identifier = (flag & RSF_IDENT) != 0;
last_next_ident = (flag & RSF_IDENT) != 0;
last_pub = (flag & RSF_PUB) != 0;
//fprintf(stderr, "read_switch = %d\n", RES_get_read_switch(index));
goto *jump[RES_get_read_switch(index)];
do
{
__ME_NEW_LAST_SUPER:
can_be_reserved = !last_identifier;
can_be_reserved = !last_next_ident;
break;
__CLASS:
@ -344,16 +345,12 @@ static void add_identifier()
can_be_reserved = canres_car[car] && (_begin_line || last_pub || PATTERN_is(last_pattern, RS_END));
break;
__CONST_EXTERN:
can_be_reserved = canres_car[car] && (_begin_line || last_pub);
break;
__ENUM:
__CONST_EXTERN_ENUM:
can_be_reserved = canres_car[car] && (_begin_line || last_pub);
break;
__READ:
can_be_reserved = canres_car[car] && (!last_identifier || PATTERN_is(last_pattern, RS_PROPERTY));
can_be_reserved = canres_car[car] && (!last_next_ident || PATTERN_is(last_pattern, RS_PROPERTY));
break;
__DATATYPE:
@ -372,11 +369,27 @@ static void add_identifier()
}
break;
__OTHERS:
if (last_type || last_identifier || (PATTERN_is(last_pattern, RS_LBRA) && car == ')' && PATTERN_is_reserved(get_last_last_pattern())))
__OPTIONAL:
if (!(PATTERN_is(last_pattern, RS_LBRA) || PATTERN_is(last_pattern, RS_COMMA) || PATTERN_is(last_pattern, RS_EXPORT)))
can_be_reserved = FALSE;
break;
__BYREF:
if (!(PATTERN_is(last_pattern, RS_LBRA) || PATTERN_is(last_pattern, RS_COMMA) || PATTERN_is(last_pattern, RS_OPTIONAL)))
can_be_reserved = FALSE;
break;
__OTHERS:
if (!canres_car[car])
can_be_reserved = FALSE;
else if (last_type || last_next_ident || (PATTERN_is(last_pattern, RS_LBRA) && car == ')' && PATTERN_is_reserved(get_last_last_pattern())))
can_be_reserved = FALSE;
else if (PATTERN_is(last_pattern, RS_EQUAL))
{
can_be_reserved = (index >= RS_COLON || index == RS_NEW || index == RS_OPEN || index == RS_CLOSE || index == RS_SHELL || index == RS_EXEC || index == RS_RAISE || index == RS_PIPE || index == RS_LOCK || index == RS_MEMORY || index == RS_READ || index == RS_PEEK);
}
else if (!_begin_line && !last_type && index < RS_P_IF && PATTERN_is_reserved(last_pattern) && !RES_is_identifier(PATTERN_index(last_pattern)) && !PATTERN_is(last_pattern, RS_RBRA) && !PATTERN_is(last_pattern, RS_RSQR))
can_be_reserved = FALSE;
else
can_be_reserved = canres_car[car];
break;
}
while (0);