hyung-hwan/qse
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

*** empty log message ***

Browse Source
This commit is contained in:
hyung-hwan 2005-06-08 16:05:41 +00:00
parent f3dc7b12d6
commit 8a69307e57
13 changed files with 203 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
ase/stx/misc.h
View File

@ -1,5 +1,5 @@
/* /*
* $Id: misc.h,v 1.5 2005-06-08 16:00:51 bacon Exp $ * $Id: misc.h,v 1.6 2005-06-08 16:05:41 bacon Exp $
*/ */
#ifndef _XP_STX_MISC_H_ #ifndef _XP_STX_MISC_H_
@ -31,21 +31,6 @@
#include <xp/bas/assert.h> #include <xp/bas/assert.h>
#include <xp/bas/stdarg.h> #include <xp/bas/stdarg.h>
#include <xp/bas/ctype.h> #include <xp/bas/ctype.h>
/*
#define xp_assert xp_assert
#define xp_malloc xp_malloc
#define xp_realloc xp_realloc
#define xp_free xp_free
#define xp_va_list xp_va_list
#define xp_va_start xp_va_start
#define xp_va_end xp_va_end
#define xp_va_arg xp_va_arg
#define xp_isspace xp_isspace
#define xp_isdigit xp_isdigit
#define xp_isalpha xp_isalpha
#define xp_isalnum xp_isalnum
*/
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus

80
ase/stx/object.c
View File

@ -1,5 +1,5 @@
/* /*
* $Id: object.c,v 1.23 2005-05-23 15:51:03 bacon Exp $ * $Id: object.c,v 1.24 2005-06-08 16:00:51 bacon Exp $
*/ */
#include <xp/stx/object.h> #include <xp/stx/object.h>
@ -9,19 +9,19 @@
#include <xp/stx/misc.h> #include <xp/stx/misc.h>
/* n: number of instance variables */ /* n: number of instance variables */
xp_stx_word_t xp_stx_alloc_word_object (xp_stx_t* stx, xp_stx_word_t n) xp_word_t xp_stx_alloc_word_object (xp_stx_t* stx, xp_word_t n)
{ {
xp_stx_word_t idx; xp_word_t idx;
xp_stx_word_object_t* obj; xp_stx_word_object_t* obj;
/* bytes to allocidxed = /* bytes to allocidxed =
* number of instance variables * word_size * number of instance variables * word_size
*/ */
idx = xp_stx_memory_alloc (&stx->memory, idx = xp_stx_memory_alloc (&stx->memory,
n * xp_sizeof(xp_stx_word_t) + xp_sizeof(xp_stx_object_t)); n * xp_sizeof(xp_word_t) + xp_sizeof(xp_stx_object_t));
if (idx >= stx->memory.capacity) return idx; /* failed */ if (idx >= stx->memory.capacity) return idx; /* failed */
xp_stx_assert (stx->nil == XP_STX_NIL); xp_assert (stx->nil == XP_STX_NIL);
/* /*
XP_STX_CLASS(stx,idx) = stx->nil; XP_STX_CLASS(stx,idx) = stx->nil;
@ -37,16 +37,16 @@ xp_stx_word_t xp_stx_alloc_word_object (xp_stx_t* stx, xp_stx_word_t n)
} }
/* n: number of bytes */ /* n: number of bytes */
xp_stx_word_t xp_stx_alloc_byte_object (xp_stx_t* stx, xp_stx_word_t n) xp_word_t xp_stx_alloc_byte_object (xp_stx_t* stx, xp_word_t n)
{ {
xp_stx_word_t idx; xp_word_t idx;
xp_stx_byte_object_t* obj; xp_stx_byte_object_t* obj;
idx = xp_stx_memory_alloc ( idx = xp_stx_memory_alloc (
&stx->memory, n + xp_sizeof(xp_stx_object_t)); &stx->memory, n + xp_sizeof(xp_stx_object_t));
if (idx >= stx->memory.capacity) return idx; /* failed */ if (idx >= stx->memory.capacity) return idx; /* failed */
xp_stx_assert (stx->nil == XP_STX_NIL); xp_assert (stx->nil == XP_STX_NIL);
/* /*
XP_STX_CLASS(stx,idx) = stx->nil; XP_STX_CLASS(stx,idx) = stx->nil;
@ -61,84 +61,84 @@ xp_stx_word_t xp_stx_alloc_byte_object (xp_stx_t* stx, xp_stx_word_t n)
return idx; return idx;
} }
xp_stx_word_t xp_stx_alloc_char_object ( xp_word_t xp_stx_alloc_char_object (
xp_stx_t* stx, const xp_stx_char_t* str) xp_stx_t* stx, const xp_char_t* str)
{ {
return xp_stx_alloc_char_objectx (stx, str, xp_stx_strlen(str)); return xp_stx_alloc_char_objectx (stx, str, xp_stx_strlen(str));
} }
xp_stx_word_t xp_stx_alloc_char_objectx ( xp_word_t xp_stx_alloc_char_objectx (
xp_stx_t* stx, const xp_stx_char_t* str, xp_stx_word_t n) xp_stx_t* stx, const xp_char_t* str, xp_word_t n)
{ {
xp_stx_word_t idx; xp_word_t idx;
xp_stx_char_object_t* obj; xp_stx_char_object_t* obj;
idx = xp_stx_memory_alloc (&stx->memory, idx = xp_stx_memory_alloc (&stx->memory,
(n + 1) * xp_sizeof(xp_stx_char_t) + xp_sizeof(xp_stx_object_t)); (n + 1) * xp_sizeof(xp_char_t) + xp_sizeof(xp_stx_object_t));
if (idx >= stx->memory.capacity) return idx; /* failed */ if (idx >= stx->memory.capacity) return idx; /* failed */
xp_stx_assert (stx->nil == XP_STX_NIL); xp_assert (stx->nil == XP_STX_NIL);
/* /*
XP_STX_CLASS(stx,idx) = stx->nil; XP_STX_CLASS(stx,idx) = stx->nil;
XP_STX_ACCESS(stx,idx) = (n << 2) | XP_STX_CHAR_INDEXED; XP_STX_ACCESS(stx,idx) = (n << 2) | XP_CHAR_INDEXED;
XP_STX_CHARAT(stx,idx,n) = XP_STX_CHAR('\0'); XP_STX_CHARAT(stx,idx,n) = XP_CHAR('\0');
while (n-- > 0) XP_STX_CHARAT(stx,idx,n) = str[n]; while (n-- > 0) XP_STX_CHARAT(stx,idx,n) = str[n];
*/ */
obj = XP_STX_CHAR_OBJECT(stx,idx); obj = XP_CHAR_OBJECT(stx,idx);
obj->header.class = stx->nil; obj->header.class = stx->nil;
obj->header.access = (n << 2) | XP_STX_CHAR_INDEXED; obj->header.access = (n << 2) | XP_CHAR_INDEXED;
obj->data[n] = XP_STX_CHAR('\0'); obj->data[n] = XP_CHAR('\0');
while (n-- > 0) obj->data[n] = str[n]; while (n-- > 0) obj->data[n] = str[n];
return idx; return idx;
} }
xp_stx_word_t xp_stx_allocn_char_object (xp_stx_t* stx, ...) xp_word_t xp_stx_allocn_char_object (xp_stx_t* stx, ...)
{ {
xp_stx_word_t idx, n = 0; xp_word_t idx, n = 0;
const xp_stx_char_t* p; const xp_char_t* p;
xp_stx_va_list ap; xp_va_list ap;
xp_stx_char_object_t* obj; xp_stx_char_object_t* obj;
xp_stx_va_start (ap, stx); xp_va_start (ap, stx);
while ((p = xp_stx_va_arg(ap, const xp_stx_char_t*)) != XP_NULL) { while ((p = xp_va_arg(ap, const xp_char_t*)) != XP_NULL) {
n += xp_stx_strlen(p); n += xp_stx_strlen(p);
} }
xp_stx_va_end (ap); xp_va_end (ap);
idx = xp_stx_memory_alloc (&stx->memory, idx = xp_stx_memory_alloc (&stx->memory,
(n + 1) * xp_sizeof(xp_stx_char_t) + xp_sizeof(xp_stx_object_t)); (n + 1) * xp_sizeof(xp_char_t) + xp_sizeof(xp_stx_object_t));
if (idx >= stx->memory.capacity) return idx; /* failed */ if (idx >= stx->memory.capacity) return idx; /* failed */
xp_stx_assert (stx->nil == XP_STX_NIL); xp_assert (stx->nil == XP_STX_NIL);
/* /*
XP_STX_CLASS(stx,idx) = stx->nil; XP_STX_CLASS(stx,idx) = stx->nil;
XP_STX_ACCESS(stx,idx) = (n << 2) | XP_STX_CHAR_INDEXED; XP_STX_ACCESS(stx,idx) = (n << 2) | XP_CHAR_INDEXED;
XP_STX_CHARAT(stx,idx,n) = XP_STX_CHAR('\0'); XP_STX_CHARAT(stx,idx,n) = XP_CHAR('\0');
*/ */
obj = XP_STX_CHAR_OBJECT(stx,idx); obj = XP_CHAR_OBJECT(stx,idx);
obj->header.class = stx->nil; obj->header.class = stx->nil;
obj->header.access = (n << 2) | XP_STX_CHAR_INDEXED; obj->header.access = (n << 2) | XP_CHAR_INDEXED;
obj->data[n] = XP_STX_CHAR('\0'); obj->data[n] = XP_CHAR('\0');
xp_stx_va_start (ap, stx); xp_va_start (ap, stx);
n = 0; n = 0;
while ((p = xp_stx_va_arg(ap, const xp_stx_char_t*)) != XP_NULL) { while ((p = xp_va_arg(ap, const xp_char_t*)) != XP_NULL) {
while (*p != XP_STX_CHAR('\0')) { while (*p != XP_CHAR('\0')) {
/*XP_STX_CHARAT(stx,idx,n++) = *p++;*/ /*XP_STX_CHARAT(stx,idx,n++) = *p++;*/
obj->data[n++] = *p++; obj->data[n++] = *p++;
} }
} }
xp_stx_va_end (ap); xp_va_end (ap);
return idx; return idx;
} }
xp_stx_word_t xp_stx_hash_char_object (xp_stx_t* stx, xp_stx_word_t idx) xp_word_t xp_stx_hash_char_object (xp_stx_t* stx, xp_word_t idx)
{ {
xp_stx_assert (XP_STX_TYPE(stx,idx) == XP_STX_CHAR_INDEXED); xp_assert (XP_STX_TYPE(stx,idx) == XP_CHAR_INDEXED);
return xp_stx_strxhash ( return xp_stx_strxhash (
XP_STX_DATA(stx,idx), XP_STX_SIZE(stx,idx)); XP_STX_DATA(stx,idx), XP_STX_SIZE(stx,idx));
} }

20
ase/stx/object.h
View File

@ -1,5 +1,5 @@
/* /*
* $Id: object.h,v 1.17 2005-05-23 15:51:03 bacon Exp $ * $Id: object.h,v 1.18 2005-06-08 16:00:51 bacon Exp $
*/ */
#ifndef _XP_STX_OBJECT_H_ #ifndef _XP_STX_OBJECT_H_
@ -15,17 +15,17 @@
extern "C" { extern "C" {
#endif #endif
xp_stx_word_t xp_stx_alloc_word_object (xp_stx_t* stx, xp_stx_word_t n); xp_word_t xp_stx_alloc_word_object (xp_stx_t* stx, xp_word_t n);
xp_stx_word_t xp_stx_alloc_byte_object (xp_stx_t* stx, xp_stx_word_t n); xp_word_t xp_stx_alloc_byte_object (xp_stx_t* stx, xp_word_t n);
xp_stx_word_t xp_stx_alloc_char_object ( xp_word_t xp_stx_alloc_char_object (
xp_stx_t* stx, const xp_stx_char_t* str); xp_stx_t* stx, const xp_char_t* str);
xp_stx_word_t xp_stx_alloc_char_objectx ( xp_word_t xp_stx_alloc_char_objectx (
xp_stx_t* stx, const xp_stx_char_t* str, xp_stx_word_t n); xp_stx_t* stx, const xp_char_t* str, xp_word_t n);
xp_stx_word_t xp_stx_allocn_char_object (xp_stx_t* stx, ...); xp_word_t xp_stx_allocn_char_object (xp_stx_t* stx, ...);
xp_stx_word_t xp_stx_hash_char_object (xp_stx_t* stx, xp_stx_word_t idx); xp_word_t xp_stx_hash_char_object (xp_stx_t* stx, xp_word_t idx);
int xp_stx_lookup_global ( int xp_stx_lookup_global (
xp_stx_t* stx, xp_stx_word_t key, xp_stx_word_t* value); xp_stx_t* stx, xp_word_t key, xp_word_t* value);
#ifdef __cplusplus #ifdef __cplusplus
} }

88
ase/stx/parser.c
View File

@ -1,5 +1,5 @@
/* /*
* $Id: parser.c,v 1.23 2005-06-08 15:49:35 bacon Exp $ * $Id: parser.c,v 1.24 2005-06-08 16:00:51 bacon Exp $
*/ */
#include <xp/stx/parser.h> #include <xp/stx/parser.h>
@ -8,7 +8,7 @@
static int __parse_method ( static int __parse_method (
xp_stx_parser_t* parser, xp_stx_parser_t* parser,
xp_stx_word_t method_class, void* input); xp_word_t method_class, void* input);
static int __parse_message_pattern (xp_stx_parser_t* parser); static int __parse_message_pattern (xp_stx_parser_t* parser);
static int __parse_temporaries (xp_stx_parser_t* parser); static int __parse_temporaries (xp_stx_parser_t* parser);
static int __parse_statements (xp_stx_parser_t* parser); static int __parse_statements (xp_stx_parser_t* parser);
@ -30,21 +30,21 @@ xp_stx_parser_t* xp_stx_parser_open (xp_stx_parser_t* parser, xp_stx_t* stx)
{ {
if (parser == XP_NULL) { if (parser == XP_NULL) {
parser = (xp_stx_parser_t*) parser = (xp_stx_parser_t*)
xp_stx_malloc (xp_sizeof(xp_stx_parser_t)); xp_malloc (xp_sizeof(xp_stx_parser_t));
if (parser == XP_NULL) return XP_NULL; if (parser == XP_NULL) return XP_NULL;
parser->__malloced = xp_true; parser->__malloced = xp_true;
} }
else parser->__malloced = xp_false; else parser->__malloced = xp_false;
if (xp_stx_token_open (&parser->token, 256) == XP_NULL) { if (xp_stx_token_open (&parser->token, 256) == XP_NULL) {
if (parser->__malloced) xp_stx_free (parser); if (parser->__malloced) xp_free (parser);
return XP_NULL; return XP_NULL;
} }
parser->stx = stx; parser->stx = stx;
parser->error_code = XP_STX_PARSER_ERROR_NONE; parser->error_code = XP_STX_PARSER_ERROR_NONE;
parser->curc = XP_STX_CHAR_EOF; parser->curc = XP_CHAR_EOF;
parser->ungotc_count = 0; parser->ungotc_count = 0;
parser->input_owner = XP_NULL; parser->input_owner = XP_NULL;
@ -55,7 +55,7 @@ xp_stx_parser_t* xp_stx_parser_open (xp_stx_parser_t* parser, xp_stx_t* stx)
void xp_stx_parser_close (xp_stx_parser_t* parser) void xp_stx_parser_close (xp_stx_parser_t* parser)
{ {
xp_stx_token_close (&parser->token); xp_stx_token_close (&parser->token);
if (parser->__malloced) xp_stx_free (parser); if (parser->__malloced) xp_free (parser);
} }
#define GET_CHAR(parser) \ #define GET_CHAR(parser) \
@ -73,7 +73,7 @@ void xp_stx_parser_close (xp_stx_parser_t* parser)
} while (0) } while (0)
int xp_stx_parser_parse_method ( int xp_stx_parser_parse_method (
xp_stx_parser_t* parser, xp_stx_word_t method_class, void* input) xp_stx_parser_t* parser, xp_word_t method_class, void* input)
{ {
int n; int n;
@ -90,7 +90,7 @@ int xp_stx_parser_parse_method (
} }
static int __parse_method ( static int __parse_method (
xp_stx_parser_t* parser, xp_stx_word_t method_class, void* input) xp_stx_parser_t* parser, xp_word_t method_class, void* input)
{ {
/* /*
* <method definition> ::= * <method definition> ::=
@ -124,7 +124,7 @@ static int __parse_message_pattern (xp_stx_parser_t* parser)
} }
else if (parser->token.type == XP_STX_TOKEN_KEYWORD) { else if (parser->token.type == XP_STX_TOKEN_KEYWORD) {
/* keyword pattern */ /* keyword pattern */
xp_stx_char_t* selector; xp_char_t* selector;
} }
else { else {
parser->error_code = XP_STX_PARSER_ERROR_MESSAGE_SELECTOR; parser->error_code = XP_STX_PARSER_ERROR_MESSAGE_SELECTOR;
@ -160,14 +160,14 @@ static inline xp_bool_t __is_binary_char (xp_cint_t c)
*/ */
return return
c == XP_STX_CHAR('!') || c == XP_STX_CHAR('%') || c == XP_CHAR('!') || c == XP_CHAR('%') ||
c == XP_STX_CHAR('&') || c == XP_STX_CHAR('*') || c == XP_CHAR('&') || c == XP_CHAR('*') ||
c == XP_STX_CHAR('+') || c == XP_STX_CHAR(',') || c == XP_CHAR('+') || c == XP_CHAR(',') ||
c == XP_STX_CHAR('/') || c == XP_STX_CHAR('<') || c == XP_CHAR('/') || c == XP_CHAR('<') ||
c == XP_STX_CHAR('=') || c == XP_STX_CHAR('>') || c == XP_CHAR('=') || c == XP_CHAR('>') ||
c == XP_STX_CHAR('?') || c == XP_STX_CHAR('@') || c == XP_CHAR('?') || c == XP_CHAR('@') ||
c == XP_STX_CHAR('\\') || c == XP_STX_CHAR('|') || c == XP_CHAR('\\') || c == XP_CHAR('|') ||
c == XP_STX_CHAR('~') || c == XP_STX_CHAR('-'); c == XP_CHAR('~') || c == XP_CHAR('-');
} }
static int __get_token (xp_stx_parser_t* parser) static int __get_token (xp_stx_parser_t* parser)
@ -176,7 +176,7 @@ static int __get_token (xp_stx_parser_t* parser)
do { do {
if (__skip_spaces(parser) == -1) return -1; if (__skip_spaces(parser) == -1) return -1;
if (parser->curc == XP_STX_CHAR('"')) { if (parser->curc == XP_CHAR('"')) {
GET_CHAR (parser); GET_CHAR (parser);
if (__skip_comment(parser) == -1) return -1; if (__skip_comment(parser) == -1) return -1;
} }
@ -186,56 +186,56 @@ static int __get_token (xp_stx_parser_t* parser)
c = parser->curc; c = parser->curc;
xp_stx_token_clear (&parser->token); xp_stx_token_clear (&parser->token);
if (c == XP_STX_CHAR_EOF) { if (c == XP_CHAR_EOF) {
parser->token.type = XP_STX_TOKEN_END; parser->token.type = XP_STX_TOKEN_END;
} }
else if (xp_stx_isalpha(c)) { else if (xp_isalpha(c)) {
if (__get_ident(parser) == -1) return -1; if (__get_ident(parser) == -1) return -1;
} }
else if (xp_stx_isdigit(c)) { else if (xp_isdigit(c)) {
if (__get_numlit(parser, xp_false) == -1) return -1; if (__get_numlit(parser, xp_false) == -1) return -1;
} }
else if (c == XP_STX_CHAR('$')) { else if (c == XP_CHAR('$')) {
GET_CHAR (parser); GET_CHAR (parser);
if (__get_charlit(parser) == -1) return -1; if (__get_charlit(parser) == -1) return -1;
} }
else if (c == XP_STX_CHAR('\'')) { else if (c == XP_CHAR('\'')) {
GET_CHAR (parser); GET_CHAR (parser);
if (__get_strlit(parser) == -1) return -1; if (__get_strlit(parser) == -1) return -1;
} }
else if (c == XP_STX_CHAR(':')) { else if (c == XP_CHAR(':')) {
parser->token.type = XP_STX_TOKEN_COLON; parser->token.type = XP_STX_TOKEN_COLON;
ADD_TOKEN_CHAR(parser, c); ADD_TOKEN_CHAR(parser, c);
GET_CHAR (parser); GET_CHAR (parser);
c = parser->curc; c = parser->curc;
if (c == XP_STX_CHAR('=')) { if (c == XP_CHAR('=')) {
parser->token.type = XP_STX_TOKEN_ASSIGN; parser->token.type = XP_STX_TOKEN_ASSIGN;
ADD_TOKEN_CHAR(parser, c); ADD_TOKEN_CHAR(parser, c);
GET_CHAR (parser); GET_CHAR (parser);
} }
} }
else if (c == XP_STX_CHAR('^')) { else if (c == XP_CHAR('^')) {
parser->token.type = XP_STX_TOKEN_RETURN; parser->token.type = XP_STX_TOKEN_RETURN;
ADD_TOKEN_CHAR(parser, c); ADD_TOKEN_CHAR(parser, c);
GET_CHAR (parser); GET_CHAR (parser);
} }
else if (c == XP_STX_CHAR('|')) { else if (c == XP_CHAR('|')) {
parser->token.type = XP_STX_TOKEN_BAR; parser->token.type = XP_STX_TOKEN_BAR;
ADD_TOKEN_CHAR(parser, c); ADD_TOKEN_CHAR(parser, c);
GET_CHAR (parser); GET_CHAR (parser);
} }
else if (c == XP_STX_CHAR('[')) { else if (c == XP_CHAR('[')) {
parser->token.type = XP_STX_TOKEN_LBRACKET; parser->token.type = XP_STX_TOKEN_LBRACKET;
ADD_TOKEN_CHAR(parser, c); ADD_TOKEN_CHAR(parser, c);
GET_CHAR (parser); GET_CHAR (parser);
} }
else if (c == XP_STX_CHAR(']')) { else if (c == XP_CHAR(']')) {
parser->token.type = XP_STX_TOKEN_RBRACKET; parser->token.type = XP_STX_TOKEN_RBRACKET;
ADD_TOKEN_CHAR(parser, c); ADD_TOKEN_CHAR(parser, c);
GET_CHAR (parser); GET_CHAR (parser);
} }
else if (c == XP_STX_CHAR('.')) { else if (c == XP_CHAR('.')) {
parser->token.type = XP_STX_TOKEN_PERIOD; parser->token.type = XP_STX_TOKEN_PERIOD;
ADD_TOKEN_CHAR(parser, c); ADD_TOKEN_CHAR(parser, c);
GET_CHAR (parser); GET_CHAR (parser);
@ -265,9 +265,9 @@ static int __get_ident (xp_stx_parser_t* parser)
ADD_TOKEN_CHAR(parser, c); ADD_TOKEN_CHAR(parser, c);
GET_CHAR (parser); GET_CHAR (parser);
c = parser->curc; c = parser->curc;
} while (xp_stx_isalnum(c)); } while (xp_isalnum(c));
if (c == XP_STX_CHAR(':')) { if (c == XP_CHAR(':')) {
parser->token.type = XP_STX_TOKEN_KEYWORD; parser->token.type = XP_STX_TOKEN_KEYWORD;
GET_CHAR (parser); GET_CHAR (parser);
} }
@ -302,7 +302,7 @@ static int __get_numlit (xp_stx_parser_t* parser, xp_bool_t negated)
ADD_TOKEN_CHAR(parser, c); ADD_TOKEN_CHAR(parser, c);
GET_CHAR (parser); GET_CHAR (parser);
c = parser->curc; c = parser->curc;
} while (xp_stx_isalnum(c)); } while (xp_isalnum(c));
/* TODO; more */ /* TODO; more */
return 0; return 0;
@ -316,7 +316,7 @@ static int __get_charlit (xp_stx_parser_t* parser)
*/ */
xp_cint_t c = parser->curc; /* even a new-line or white space would be taken */ xp_cint_t c = parser->curc; /* even a new-line or white space would be taken */
if (c == XP_STX_CHAR_EOF) { if (c == XP_CHAR_EOF) {
parser->error_code = XP_STX_PARSER_ERROR_CHARLIT; parser->error_code = XP_STX_PARSER_ERROR_CHARLIT;
return -1; return -1;
} }
@ -346,15 +346,15 @@ static int __get_strlit (xp_stx_parser_t* parser)
GET_CHAR (parser); GET_CHAR (parser);
c = parser->curc; c = parser->curc;
if (c == XP_STX_CHAR_EOF) { if (c == XP_CHAR_EOF) {
parser->error_code = XP_STX_PARSER_ERROR_STRLIT; parser->error_code = XP_STX_PARSER_ERROR_STRLIT;
return -1; return -1;
} }
} while (c != XP_STX_CHAR('\'')); } while (c != XP_CHAR('\''));
GET_CHAR (parser); GET_CHAR (parser);
c = parser->curc; c = parser->curc;
} while (c == XP_STX_CHAR('\'')); } while (c == XP_CHAR('\''));
return 0; return 0;
} }
@ -369,9 +369,9 @@ static int __get_binary (xp_stx_parser_t* parser)
ADD_TOKEN_CHAR (parser, c); ADD_TOKEN_CHAR (parser, c);
if (c == XP_STX_CHAR('<')) { if (c == XP_CHAR('<')) {
/* /*
const xp_stx_char_t* p = XP_TEXT("primitive:"); const xp_char_t* p = XP_TEXT("primitive:");
do { do {
GET_CHAR (parser); GET_CHAR (parser);
@ -380,10 +380,10 @@ static int __get_binary (xp_stx_parser_t* parser)
} while (*c) } while (*c)
*/ */
} }
else if (c == XP_STX_CHAR('-')) { else if (c == XP_CHAR('-')) {
GET_CHAR (parser); GET_CHAR (parser);
c = parser->curc; c = parser->curc;
if (xp_stx_isdigit(c)) return __get_numlit(parser,xp_true); if (xp_isdigit(c)) return __get_numlit(parser,xp_true);
} }
else { else {
GET_CHAR (parser); GET_CHAR (parser);
@ -401,13 +401,13 @@ static int __get_binary (xp_stx_parser_t* parser)
static int __skip_spaces (xp_stx_parser_t* parser) static int __skip_spaces (xp_stx_parser_t* parser)
{ {
while (xp_stx_isspace(parser->curc)) GET_CHAR (parser); while (xp_isspace(parser->curc)) GET_CHAR (parser);
return 0; return 0;
} }
static int __skip_comment (xp_stx_parser_t* parser) static int __skip_comment (xp_stx_parser_t* parser)
{ {
while (parser->curc != XP_STX_CHAR('"')) GET_CHAR (parser); while (parser->curc != XP_CHAR('"')) GET_CHAR (parser);
GET_CHAR (parser); GET_CHAR (parser);
return 0; return 0;
} }
@ -448,7 +448,7 @@ static int __open_input (xp_stx_parser_t* parser, void* input)
} }
parser->error_code = XP_STX_PARSER_ERROR_NONE; parser->error_code = XP_STX_PARSER_ERROR_NONE;
parser->curc = XP_STX_CHAR_EOF; parser->curc = XP_CHAR_EOF;
parser->ungotc_count = 0; parser->ungotc_count = 0;
return 0; return 0;
} }

8
ase/stx/parser.h
View File

@ -1,5 +1,5 @@
/* /*
* $Id: parser.h,v 1.13 2005-06-08 03:19:31 bacon Exp $ * $Id: parser.h,v 1.14 2005-06-08 16:00:51 bacon Exp $
*/ */
#ifndef _XP_STX_PARSER_H_ #ifndef _XP_STX_PARSER_H_
@ -44,8 +44,8 @@ struct xp_stx_parser_t
int error_code; int error_code;
xp_stx_token_t token; xp_stx_token_t token;
xp_stx_cint_t curc; xp_cint_t curc;
xp_stx_cint_t ungotc[5]; xp_cint_t ungotc[5];
xp_size_t ungotc_count; xp_size_t ungotc_count;
void* input_owner; void* input_owner;
@ -62,7 +62,7 @@ xp_stx_parser_t* xp_stx_parser_open (xp_stx_parser_t* parser, xp_stx_t* stx);
void xp_stx_parser_close (xp_stx_parser_t* parser); void xp_stx_parser_close (xp_stx_parser_t* parser);
int xp_stx_parser_parse_method ( int xp_stx_parser_parse_method (
xp_stx_parser_t* parser, xp_stx_word_t method_class, void* input); xp_stx_parser_t* parser, xp_word_t method_class, void* input);
#ifdef __cplusplus #ifdef __cplusplus
} }

10
ase/stx/stx.c
View File

@ -1,22 +1,22 @@
/* /*
* $Id: stx.c,v 1.29 2005-05-25 16:44:05 bacon Exp $ * $Id: stx.c,v 1.30 2005-06-08 16:00:51 bacon Exp $
*/ */
#include <xp/stx/stx.h> #include <xp/stx/stx.h>
#include <xp/stx/memory.h> #include <xp/stx/memory.h>
#include <xp/stx/misc.h> #include <xp/stx/misc.h>
xp_stx_t* xp_stx_open (xp_stx_t* stx, xp_stx_word_t capacity) xp_stx_t* xp_stx_open (xp_stx_t* stx, xp_word_t capacity)
{ {
if (stx == XP_NULL) { if (stx == XP_NULL) {
stx = (xp_stx_t*)xp_stx_malloc (xp_sizeof(stx)); stx = (xp_stx_t*)xp_malloc (xp_sizeof(stx));
if (stx == XP_NULL) return XP_NULL; if (stx == XP_NULL) return XP_NULL;
stx->__malloced = xp_true; stx->__malloced = xp_true;
} }
else stx->__malloced = xp_false; else stx->__malloced = xp_false;
if (xp_stx_memory_open (&stx->memory, capacity) == XP_NULL) { if (xp_stx_memory_open (&stx->memory, capacity) == XP_NULL) {
if (stx->__malloced) xp_stx_free (stx); if (stx->__malloced) xp_free (stx);
return XP_NULL; return XP_NULL;
} }
@ -43,6 +43,6 @@ xp_stx_t* xp_stx_open (xp_stx_t* stx, xp_stx_word_t capacity)
void xp_stx_close (xp_stx_t* stx) void xp_stx_close (xp_stx_t* stx)
{ {
xp_stx_memory_close (&stx->memory); xp_stx_memory_close (&stx->memory);
if (stx->__malloced) xp_stx_free (stx); if (stx->__malloced) xp_free (stx);
} }

17
ase/stx/stx.h
View File

@ -1,5 +1,5 @@
/* /*
* $Id: stx.h,v 1.25 2005-06-08 15:49:35 bacon Exp $ * $Id: stx.h,v 1.26 2005-06-08 16:00:51 bacon Exp $
*/ */
#ifndef _XP_STX_STX_H_ #ifndef _XP_STX_STX_H_
@ -8,11 +8,6 @@
#include <xp/types.h> #include <xp/types.h>
#include <xp/macros.h> #include <xp/macros.h>
typedef xp_byte_t xp_byte_t;
typedef xp_char_t xp_char_t;
typedef xp_cint_t xp_stx_cint_t;
typedef xp_word_t xp_word_t;
typedef struct xp_stx_objhdr_t xp_stx_objhdr_t; typedef struct xp_stx_objhdr_t xp_stx_objhdr_t;
typedef struct xp_stx_object_t xp_stx_object_t; typedef struct xp_stx_object_t xp_stx_object_t;
typedef struct xp_stx_word_object_t xp_stx_word_object_t; typedef struct xp_stx_word_object_t xp_stx_word_object_t;
@ -21,10 +16,6 @@ typedef struct xp_stx_char_object_t xp_stx_char_object_t;
typedef struct xp_stx_memory_t xp_stx_memory_t; typedef struct xp_stx_memory_t xp_stx_memory_t;
typedef struct xp_stx_t xp_stx_t; typedef struct xp_stx_t xp_stx_t;
#define XP_STX_CHAR(x) XP_CHAR(x)
#define XP_STX_TEXT(x) XP_TEXT(x)
#define XP_STX_CHAR_EOF XP_CHAR_EOF
/* common object structure */ /* common object structure */
struct xp_stx_objhdr_t struct xp_stx_objhdr_t
{ {
@ -90,8 +81,6 @@ struct xp_stx_t
xp_bool_t __wantabort; /* TODO: make it a function pointer */ xp_bool_t __wantabort; /* TODO: make it a function pointer */
}; };
typedef xp_stx_cint_t (*xp_stx_getc_t) (void*);
#define XP_STX_NIL 0 #define XP_STX_NIL 0
#define XP_STX_TRUE 1 #define XP_STX_TRUE 1
#define XP_STX_FALSE 2 #define XP_STX_FALSE 2
@ -105,13 +94,13 @@ typedef xp_stx_cint_t (*xp_stx_getc_t) (void*);
#define XP_STX_SIZE(stx,idx) (XP_STX_ACCESS(stx,idx) >> 0x02) #define XP_STX_SIZE(stx,idx) (XP_STX_ACCESS(stx,idx) >> 0x02)
#define XP_STX_WORD_INDEXED (0x00) #define XP_STX_WORD_INDEXED (0x00)
#define XP_STX_BYTE_INDEXED (0x01) #define XP_STX_BYTE_INDEXED (0x01)
#define XP_STX_CHAR_INDEXED (0x02) #define XP_CHAR_INDEXED (0x02)
#define XP_STX_WORD_OBJECT(stx,idx) \ #define XP_STX_WORD_OBJECT(stx,idx) \
((xp_stx_word_object_t*)XP_STX_OBJECT(stx,idx)) ((xp_stx_word_object_t*)XP_STX_OBJECT(stx,idx))
#define XP_STX_BYTE_OBJECT(stx,idx) \ #define XP_STX_BYTE_OBJECT(stx,idx) \
((xp_stx_byte_object_t*)XP_STX_OBJECT(stx,idx)) ((xp_stx_byte_object_t*)XP_STX_OBJECT(stx,idx))
#define XP_STX_CHAR_OBJECT(stx,idx) \ #define XP_CHAR_OBJECT(stx,idx) \
((xp_stx_char_object_t*)XP_STX_OBJECT(stx,idx)) ((xp_stx_char_object_t*)XP_STX_OBJECT(stx,idx))
#define XP_STX_WORDAT(stx,idx,n) \ #define XP_STX_WORDAT(stx,idx,n) \

38
ase/stx/symbol.c
View File

@ -1,14 +1,14 @@
/* /*
* $Id: symbol.c,v 1.8 2005-05-29 16:51:16 bacon Exp $ * $Id: symbol.c,v 1.9 2005-06-08 16:00:51 bacon Exp $
*/ */
#include <xp/stx/symbol.h> #include <xp/stx/symbol.h>
#include <xp/stx/object.h> #include <xp/stx/object.h>
#include <xp/stx/misc.h> #include <xp/stx/misc.h>
xp_stx_word_t xp_stx_new_symlink (xp_stx_t* stx, xp_stx_word_t sym) xp_word_t xp_stx_new_symlink (xp_stx_t* stx, xp_word_t sym)
{ {
xp_stx_word_t x; xp_word_t x;
x = xp_stx_alloc_word_object (stx, XP_STX_SYMLINK_SIZE); x = xp_stx_alloc_word_object (stx, XP_STX_SYMLINK_SIZE);
XP_STX_CLASS(stx,x) = stx->class_symlink; XP_STX_CLASS(stx,x) = stx->class_symlink;
@ -18,9 +18,9 @@ xp_stx_word_t xp_stx_new_symlink (xp_stx_t* stx, xp_stx_word_t sym)
return x; return x;
} }
xp_stx_word_t xp_stx_new_symbol (xp_stx_t* stx, const xp_stx_char_t* name) xp_word_t xp_stx_new_symbol (xp_stx_t* stx, const xp_char_t* name)
{ {
xp_stx_word_t x, hash, table, link, next; xp_word_t x, hash, table, link, next;
table = stx->symbol_table; table = stx->symbol_table;
hash = xp_stx_strhash(name) % XP_STX_SIZE(stx,table); hash = xp_stx_strhash(name) % XP_STX_SIZE(stx,table);
@ -34,7 +34,7 @@ xp_stx_word_t xp_stx_new_symbol (xp_stx_t* stx, const xp_stx_char_t* name)
else { else {
do { do {
x = XP_STX_WORDAT(stx,link,XP_STX_SYMLINK_SYMBOL); x = XP_STX_WORDAT(stx,link,XP_STX_SYMLINK_SYMBOL);
xp_stx_assert (XP_STX_CLASS(stx,x) == stx->class_symbol); xp_assert (XP_STX_CLASS(stx,x) == stx->class_symbol);
if (xp_stx_strxcmp ( if (xp_stx_strxcmp (
&XP_STX_CHARAT(stx,x,0), &XP_STX_CHARAT(stx,x,0),
@ -56,10 +56,10 @@ xp_stx_word_t xp_stx_new_symbol (xp_stx_t* stx, const xp_stx_char_t* name)
return x; return x;
} }
xp_stx_word_t xp_stx_new_symbolx ( xp_word_t xp_stx_new_symbolx (
xp_stx_t* stx, const xp_stx_char_t* name, xp_stx_word_t len) xp_stx_t* stx, const xp_char_t* name, xp_word_t len)
{ {
xp_stx_word_t x, hash, table, link, next; xp_word_t x, hash, table, link, next;
table = stx->symbol_table; table = stx->symbol_table;
hash = xp_stx_strhash(name) % XP_STX_SIZE(stx,table); hash = xp_stx_strhash(name) % XP_STX_SIZE(stx,table);
@ -73,7 +73,7 @@ xp_stx_word_t xp_stx_new_symbolx (
else { else {
do { do {
x = XP_STX_WORDAT(stx,link,XP_STX_SYMLINK_SYMBOL); x = XP_STX_WORDAT(stx,link,XP_STX_SYMLINK_SYMBOL);
xp_stx_assert (XP_STX_CLASS(stx,x) == stx->class_symbol); xp_assert (XP_STX_CLASS(stx,x) == stx->class_symbol);
if (xp_stx_strxcmp ( if (xp_stx_strxcmp (
&XP_STX_CHARAT(stx,x,0), &XP_STX_CHARAT(stx,x,0),
@ -95,11 +95,11 @@ xp_stx_word_t xp_stx_new_symbolx (
return x; return x;
} }
xp_stx_word_t xp_stx_new_symbol_pp ( xp_word_t xp_stx_new_symbol_pp (
xp_stx_t* stx, const xp_stx_char_t* name, xp_stx_t* stx, const xp_char_t* name,
const xp_stx_char_t* prefix, const xp_stx_char_t* postfix) const xp_char_t* prefix, const xp_char_t* postfix)
{ {
xp_stx_word_t x, hash, table, link, next; xp_word_t x, hash, table, link, next;
table = stx->symbol_table; table = stx->symbol_table;
hash = xp_stx_strhash(name) % XP_STX_SIZE(stx,table); hash = xp_stx_strhash(name) % XP_STX_SIZE(stx,table);
@ -113,7 +113,7 @@ xp_stx_word_t xp_stx_new_symbol_pp (
else { else {
do { do {
x = XP_STX_WORDAT(stx,link,XP_STX_SYMLINK_SYMBOL); x = XP_STX_WORDAT(stx,link,XP_STX_SYMLINK_SYMBOL);
xp_stx_assert (XP_STX_CLASS(stx,x) == stx->class_symbol); xp_assert (XP_STX_CLASS(stx,x) == stx->class_symbol);
if (xp_stx_strxcmp ( if (xp_stx_strxcmp (
&XP_STX_CHARAT(stx,x,0), &XP_STX_CHARAT(stx,x,0),
@ -137,11 +137,11 @@ xp_stx_word_t xp_stx_new_symbol_pp (
} }
void xp_stx_traverse_symbol_table ( void xp_stx_traverse_symbol_table (
xp_stx_t* stx, void (*func) (xp_stx_t*,xp_stx_word_t)) xp_stx_t* stx, void (*func) (xp_stx_t*,xp_word_t))
{ {
xp_stx_word_t link; xp_word_t link;
xp_stx_word_t size; xp_word_t size;
xp_stx_word_t table; xp_word_t table;
table = stx->symbol_table; table = stx->symbol_table;
size = XP_STX_SIZE(stx,table); size = XP_STX_SIZE(stx,table);

24
ase/stx/symbol.h
View File

@ -1,5 +1,5 @@
/* /*
* $Id: symbol.h,v 1.5 2005-05-23 15:51:03 bacon Exp $ * $Id: symbol.h,v 1.6 2005-06-08 16:00:51 bacon Exp $
*/ */
#ifndef _XP_STX_SYMBOL_H_ #ifndef _XP_STX_SYMBOL_H_
@ -14,8 +14,8 @@
struct xp_stx_symlink_t struct xp_stx_symlink_t
{ {
xp_stx_objhdr_t header; xp_stx_objhdr_t header;
xp_stx_word_t link; xp_word_t link;
xp_stx_word_t symbol; xp_word_t symbol;
}; };
typedef struct xp_stx_symlink_t xp_stx_symlink_t; typedef struct xp_stx_symlink_t xp_stx_symlink_t;
@ -24,18 +24,18 @@ typedef struct xp_stx_symlink_t xp_stx_symlink_t;
extern "C" { extern "C" {
#endif #endif
xp_stx_word_t xp_stx_new_symbol_link (xp_stx_t* stx, xp_stx_word_t sym); xp_word_t xp_stx_new_symbol_link (xp_stx_t* stx, xp_word_t sym);
xp_stx_word_t xp_stx_new_symbol ( xp_word_t xp_stx_new_symbol (
xp_stx_t* stx, const xp_stx_char_t* name); xp_stx_t* stx, const xp_char_t* name);
xp_stx_word_t xp_stx_new_symbolx ( xp_word_t xp_stx_new_symbolx (
xp_stx_t* stx, const xp_stx_char_t* name, xp_stx_word_t len); xp_stx_t* stx, const xp_char_t* name, xp_word_t len);
xp_stx_word_t xp_stx_new_symbol_pp ( xp_word_t xp_stx_new_symbol_pp (
xp_stx_t* stx, const xp_stx_char_t* name, xp_stx_t* stx, const xp_char_t* name,
const xp_stx_char_t* prefix, const xp_stx_char_t* postfix); const xp_char_t* prefix, const xp_char_t* postfix);
void xp_stx_traverse_symbol_table ( void xp_stx_traverse_symbol_table (
xp_stx_t* stx, void (*func) (xp_stx_t*,xp_stx_word_t)); xp_stx_t* stx, void (*func) (xp_stx_t*,xp_word_t));
#ifdef __cplusplus #ifdef __cplusplus
} }

48
ase/stx/token.c
View File

@ -1,27 +1,27 @@
/* /*
* $Id: token.c,v 1.4 2005-05-30 15:01:01 bacon Exp $ * $Id: token.c,v 1.5 2005-06-08 16:00:51 bacon Exp $
*/ */
#include <xp/stx/token.h> #include <xp/stx/token.h>
#include <xp/stx/misc.h> #include <xp/stx/misc.h>
xp_stx_token_t* xp_stx_token_open ( xp_stx_token_t* xp_stx_token_open (
xp_stx_token_t* token, xp_stx_word_t capacity) xp_stx_token_t* token, xp_word_t capacity)
{ {
xp_stx_assert (capacity > 0); xp_assert (capacity > 0);
if (token == XP_NULL) { if (token == XP_NULL) {
token = (xp_stx_token_t*) token = (xp_stx_token_t*)
xp_stx_malloc (xp_sizeof(xp_stx_token_t)); xp_malloc (xp_sizeof(xp_stx_token_t));
if (token == XP_NULL) return XP_NULL; if (token == XP_NULL) return XP_NULL;
token->__malloced = xp_true; token->__malloced = xp_true;
} }
else token->__malloced = xp_false; else token->__malloced = xp_false;
token->buffer = (xp_stx_char_t*) token->buffer = (xp_char_t*)
xp_stx_malloc ((capacity + 1) * xp_sizeof(xp_stx_char_t)); xp_malloc ((capacity + 1) * xp_sizeof(xp_char_t));
if (token->buffer == XP_NULL) { if (token->buffer == XP_NULL) {
if (token->__malloced) xp_stx_free (token); if (token->__malloced) xp_free (token);
return XP_NULL; return XP_NULL;
} }
@ -32,30 +32,30 @@ xp_stx_token_t* xp_stx_token_open (
token->size = 0; token->size = 0;
token->capacity = capacity; token->capacity = capacity;
token->buffer[0] = XP_STX_CHAR('\0'); token->buffer[0] = XP_CHAR('\0');
return token; return token;
} }
void xp_stx_token_close (xp_stx_token_t* token) void xp_stx_token_close (xp_stx_token_t* token)
{ {
xp_stx_free (token->buffer); xp_free (token->buffer);
if (token->__malloced) xp_stx_free (token); if (token->__malloced) xp_free (token);
} }
int xp_stx_token_addc (xp_stx_token_t* token, xp_stx_cint_t c) int xp_stx_token_addc (xp_stx_token_t* token, xp_cint_t c)
{ {
if (token->size >= token->capacity) { if (token->size >= token->capacity) {
/* double the capacity. */ /* double the capacity. */
xp_stx_char_t* space = (xp_stx_char_t*)xp_stx_realloc ( xp_char_t* space = (xp_char_t*)xp_realloc (
token->buffer, (token->capacity * 2 + 1) * xp_sizeof(xp_stx_char_t)); token->buffer, (token->capacity * 2 + 1) * xp_sizeof(xp_char_t));
if (space == XP_NULL) return -1; if (space == XP_NULL) return -1;
token->buffer = space; token->buffer = space;
token->capacity = token->capacity * 2; token->capacity = token->capacity * 2;
} }
token->buffer[token->size++] = c; token->buffer[token->size++] = c;
token->buffer[token->size] = XP_STX_CHAR('\0'); token->buffer[token->size] = XP_CHAR('\0');
return 0; return 0;
} }
@ -67,30 +67,30 @@ void xp_stx_token_clear (xp_stx_token_t* token)
*/ */
token->size = 0; token->size = 0;
token->buffer[0] = XP_STX_CHAR('\0'); token->buffer[0] = XP_CHAR('\0');
} }
xp_stx_char_t* xp_stx_token_yield (xp_stx_token_t* token, xp_stx_word_t capacity) xp_char_t* xp_stx_token_yield (xp_stx_token_t* token, xp_word_t capacity)
{ {
xp_stx_char_t* old_buffer, * new_buffer; xp_char_t* old_buffer, * new_buffer;
new_buffer = (xp_stx_char_t*) new_buffer = (xp_char_t*)
xp_stx_malloc((capacity + 1) * xp_sizeof(xp_stx_char_t)); xp_malloc((capacity + 1) * xp_sizeof(xp_char_t));
if (new_buffer == XP_NULL) return XP_NULL; if (new_buffer == XP_NULL) return XP_NULL;
old_buffer = token->buffer; old_buffer = token->buffer;
token->buffer = new_buffer; token->buffer = new_buffer;
token->size = 0; token->size = 0;
token->capacity = capacity; token->capacity = capacity;
token->buffer[0] = XP_STX_CHAR('\0'); token->buffer[0] = XP_CHAR('\0');
return old_buffer; return old_buffer;
} }
int xp_stx_token_compare (xp_stx_token_t* token, const xp_stx_char_t* str) int xp_stx_token_compare (xp_stx_token_t* token, const xp_char_t* str)
{ {
xp_stx_char_t* p = token->buffer; xp_char_t* p = token->buffer;
xp_stx_word_t index = 0; xp_word_t index = 0;
while (index < token->size) { while (index < token->size) {
if (*p > *str) return 1; if (*p > *str) return 1;
@ -98,5 +98,5 @@ int xp_stx_token_compare (xp_stx_token_t* token, const xp_stx_char_t* str)
index++; p++; str++; index++; p++; str++;
} }
return (*str == XP_STX_CHAR('\0'))? 0: -1; return (*str == XP_CHAR('\0'))? 0: -1;
} }

16
ase/stx/token.h
View File

@ -1,5 +1,5 @@
/* /*
* $Id: token.h,v 1.8 2005-06-08 15:49:35 bacon Exp $ * $Id: token.h,v 1.9 2005-06-08 16:00:51 bacon Exp $
*/ */
#ifndef _XP_STX_TOKEN_H_ #ifndef _XP_STX_TOKEN_H_
@ -35,9 +35,9 @@ struct xp_stx_token_t
xp_stx_real_t fvalue; xp_stx_real_t fvalue;
*/ */
xp_stx_word_t capacity; xp_word_t capacity;
xp_stx_word_t size; xp_word_t size;
xp_stx_char_t* buffer; xp_char_t* buffer;
xp_bool_t __malloced; xp_bool_t __malloced;
}; };
@ -49,13 +49,13 @@ extern "C" {
#endif #endif
xp_stx_token_t* xp_stx_token_open ( xp_stx_token_t* xp_stx_token_open (
xp_stx_token_t* token, xp_stx_word_t capacity); xp_stx_token_t* token, xp_word_t capacity);
void xp_stx_token_close (xp_stx_token_t* token); void xp_stx_token_close (xp_stx_token_t* token);
int xp_stx_token_addc (xp_stx_token_t* token, xp_stx_cint_t c); int xp_stx_token_addc (xp_stx_token_t* token, xp_cint_t c);
void xp_stx_token_clear (xp_stx_token_t* token); void xp_stx_token_clear (xp_stx_token_t* token);
xp_stx_char_t* xp_stx_token_yield (xp_stx_token_t* token, xp_stx_word_t capacity); xp_char_t* xp_stx_token_yield (xp_stx_token_t* token, xp_word_t capacity);
int xp_stx_token_compare (xp_stx_token_t* token, const xp_stx_char_t* str); int xp_stx_token_compare (xp_stx_token_t* token, const xp_char_t* str);
#ifdef __cplusplus #ifdef __cplusplus
} }

12
ase/test/stx/parser.c
View File

@ -16,7 +16,7 @@
struct ss_t struct ss_t
{ {
const xp_stx_char_t* text; const xp_char_t* text;
xp_size_t index; xp_size_t index;
}; };
@ -27,7 +27,7 @@ int ss_func (int cmd, void* owner, void* arg)
if (cmd == XP_STX_PARSER_INPUT_OPEN) { if (cmd == XP_STX_PARSER_INPUT_OPEN) {
ss_t* ss = *(ss_t**)owner; ss_t* ss = *(ss_t**)owner;
ss->text = (const xp_stx_char_t*)arg; ss->text = (const xp_char_t*)arg;
ss->index = 0; ss->index = 0;
return 0; return 0;
} }
@ -38,8 +38,8 @@ int ss_func (int cmd, void* owner, void* arg)
else if (cmd == XP_STX_PARSER_INPUT_CONSUME) { else if (cmd == XP_STX_PARSER_INPUT_CONSUME) {
ss_t* ss = (ss_t*)owner; ss_t* ss = (ss_t*)owner;
xp_cint_t* c = (xp_cint_t*)arg; xp_cint_t* c = (xp_cint_t*)arg;
if (ss->text[ss->index] == XP_STX_CHAR('\0')) { if (ss->text[ss->index] == XP_CHAR('\0')) {
*c = XP_STX_CHAR_EOF; *c = XP_CHAR_EOF;
} }
else *c = ss->text[ss->index++]; else *c = ss->text[ss->index++];
return 0; return 0;
@ -78,7 +78,7 @@ int stdio_func (int cmd, void* owner, void* arg)
xp_cint_t t = xp_fgetc (p->stdio); xp_cint_t t = xp_fgetc (p->stdio);
if (t == XP_CHAR_EOF) { if (t == XP_CHAR_EOF) {
if (xp_ferror (p->stdio)) return -1; if (xp_ferror (p->stdio)) return -1;
*c = XP_STX_CHAR_EOF; *c = XP_CHAR_EOF;
} }
else *c = t; else *c = t;
return 0; return 0;
@ -92,7 +92,7 @@ int stdio_func (int cmd, void* owner, void* arg)
int xp_main (int argc, xp_char_t* argv[]) int xp_main (int argc, xp_char_t* argv[])
{ {
xp_stx_parser_t parser; xp_stx_parser_t parser;
xp_stx_word_t i; xp_word_t i;
#ifdef __linux #ifdef __linux
mtrace (); mtrace ();

54
ase/test/stx/stx.c
View File

@ -15,22 +15,22 @@
#include <xp/stx/class.h> #include <xp/stx/class.h>
#include <xp/stx/hash.h> #include <xp/stx/hash.h>
void print_symbol_names (xp_stx_t* stx, xp_stx_word_t sym) void print_symbol_names (xp_stx_t* stx, xp_word_t sym)
{ {
xp_printf (XP_TEXT("%lu [%s]\n"), (unsigned long)sym, &XP_STX_CHARAT(stx,sym,0)); xp_printf (XP_TEXT("%lu [%s]\n"), (unsigned long)sym, &XP_STX_CHARAT(stx,sym,0));
} }
void print_symbol_names_2 (xp_stx_t* stx, xp_stx_word_t idx) void print_symbol_names_2 (xp_stx_t* stx, xp_word_t idx)
{ {
xp_stx_word_t key = XP_STX_WORDAT(stx,idx,XP_STX_PAIRLINK_KEY); xp_word_t key = XP_STX_WORDAT(stx,idx,XP_STX_PAIRLINK_KEY);
xp_stx_word_t value = XP_STX_WORDAT(stx,idx,XP_STX_PAIRLINK_VALUE); xp_word_t value = XP_STX_WORDAT(stx,idx,XP_STX_PAIRLINK_VALUE);
xp_printf (XP_TEXT("%lu [%s] %lu\n"), xp_printf (XP_TEXT("%lu [%s] %lu\n"),
(unsigned long)key, &XP_STX_CHARAT(stx,key,0), (unsigned long)value); (unsigned long)key, &XP_STX_CHARAT(stx,key,0), (unsigned long)value);
} }
void print_superclasses (xp_stx_t* stx, const xp_char_t* name) void print_superclasses (xp_stx_t* stx, const xp_char_t* name)
{ {
xp_stx_word_t n; xp_word_t n;
xp_stx_class_t* obj; xp_stx_class_t* obj;
n = xp_stx_lookup_class (stx, name); n = xp_stx_lookup_class (stx, name);
@ -47,7 +47,7 @@ void print_superclasses (xp_stx_t* stx, const xp_char_t* name)
void print_metaclass_superclasses (xp_stx_t* stx, const xp_char_t* name) void print_metaclass_superclasses (xp_stx_t* stx, const xp_char_t* name)
{ {
xp_stx_word_t n, x; xp_word_t n, x;
xp_stx_metaclass_t* obj; xp_stx_metaclass_t* obj;
xp_stx_class_t* xobj; xp_stx_class_t* xobj;
@ -76,7 +76,7 @@ void print_metaclass_superclasses (xp_stx_t* stx, const xp_char_t* name)
} }
} }
void print_class_name (xp_stx_t* stx, xp_stx_word_t class, int tabs) void print_class_name (xp_stx_t* stx, xp_word_t class, int tabs)
{ {
xp_stx_class_t* xobj; xp_stx_class_t* xobj;
xobj = (xp_stx_class_t*)XP_STX_WORD_OBJECT(stx,class); xobj = (xp_stx_class_t*)XP_STX_WORD_OBJECT(stx,class);
@ -88,7 +88,7 @@ void print_class_name (xp_stx_t* stx, xp_stx_word_t class, int tabs)
(unsigned long)class); (unsigned long)class);
} }
void print_metaclass_name (xp_stx_t* stx, xp_stx_word_t class, int tabs) void print_metaclass_name (xp_stx_t* stx, xp_word_t class, int tabs)
{ {
xp_stx_metaclass_t* obj; xp_stx_metaclass_t* obj;
xp_stx_class_t* xobj; xp_stx_class_t* xobj;
@ -103,7 +103,7 @@ void print_metaclass_name (xp_stx_t* stx, xp_stx_word_t class, int tabs)
(unsigned long)class); (unsigned long)class);
} }
void print_subclass_names (xp_stx_t* stx, xp_stx_word_t class, int tabs) void print_subclass_names (xp_stx_t* stx, xp_word_t class, int tabs)
{ {
xp_stx_class_t* obj; xp_stx_class_t* obj;
@ -116,7 +116,7 @@ void print_subclass_names (xp_stx_t* stx, xp_stx_word_t class, int tabs)
} }
if (obj->subclasses != stx->nil) { if (obj->subclasses != stx->nil) {
xp_stx_word_t count = XP_STX_SIZE(stx, obj->subclasses); xp_word_t count = XP_STX_SIZE(stx, obj->subclasses);
while (count-- > 0) { while (count-- > 0) {
print_subclass_names (stx, print_subclass_names (stx,
XP_STX_WORDAT(stx,obj->subclasses,count), tabs + 1); XP_STX_WORDAT(stx,obj->subclasses,count), tabs + 1);
@ -126,7 +126,7 @@ void print_subclass_names (xp_stx_t* stx, xp_stx_word_t class, int tabs)
void print_subclasses (xp_stx_t* stx, const xp_char_t* name) void print_subclasses (xp_stx_t* stx, const xp_char_t* name)
{ {
xp_stx_word_t class; xp_word_t class;
class = xp_stx_lookup_class (stx, name); class = xp_stx_lookup_class (stx, name);
xp_printf (XP_TEXT("== NORMAL == \n")); xp_printf (XP_TEXT("== NORMAL == \n"));
print_subclass_names (stx, class, 0); print_subclass_names (stx, class, 0);
@ -137,7 +137,7 @@ void print_subclasses (xp_stx_t* stx, const xp_char_t* name)
int xp_main (int argc, xp_char_t* argv[]) int xp_main (int argc, xp_char_t* argv[])
{ {
xp_stx_t stx; xp_stx_t stx;
xp_stx_word_t i; xp_word_t i;
#ifndef _DOS #ifndef _DOS
if (xp_setlocale () == -1) { if (xp_setlocale () == -1) {
@ -173,33 +173,33 @@ int xp_main (int argc, xp_char_t* argv[])
xp_stx_hash_traverse (&stx, stx.smalltalk, print_symbol_names_2); xp_stx_hash_traverse (&stx, stx.smalltalk, print_symbol_names_2);
xp_printf (XP_TEXT("-------------\n")); xp_printf (XP_TEXT("-------------\n"));
print_superclasses (&stx, XP_STX_TEXT("Array")); print_superclasses (&stx, XP_TEXT("Array"));
xp_printf (XP_TEXT("-------------\n")); xp_printf (XP_TEXT("-------------\n"));
print_metaclass_superclasses (&stx, XP_STX_TEXT("Array")); print_metaclass_superclasses (&stx, XP_TEXT("Array"));
xp_printf (XP_TEXT("-------------\n")); xp_printf (XP_TEXT("-------------\n"));
print_superclasses (&stx, XP_STX_TEXT("False")); print_superclasses (&stx, XP_TEXT("False"));
xp_printf (XP_TEXT("-------------\n")); xp_printf (XP_TEXT("-------------\n"));
print_metaclass_superclasses (&stx, XP_STX_TEXT("False")); print_metaclass_superclasses (&stx, XP_TEXT("False"));
xp_printf (XP_TEXT("-------------\n")); xp_printf (XP_TEXT("-------------\n"));
print_superclasses (&stx, XP_STX_TEXT("Metaclass")); print_superclasses (&stx, XP_TEXT("Metaclass"));
xp_printf (XP_TEXT("-------------\n")); xp_printf (XP_TEXT("-------------\n"));
print_metaclass_superclasses (&stx, XP_STX_TEXT("Metaclass")); print_metaclass_superclasses (&stx, XP_TEXT("Metaclass"));
xp_printf (XP_TEXT("-------------\n")); xp_printf (XP_TEXT("-------------\n"));
print_superclasses (&stx, XP_STX_TEXT("Class")); print_superclasses (&stx, XP_TEXT("Class"));
xp_printf (XP_TEXT("-------------\n")); xp_printf (XP_TEXT("-------------\n"));
print_metaclass_superclasses (&stx, XP_STX_TEXT("Class")); print_metaclass_superclasses (&stx, XP_TEXT("Class"));
xp_printf (XP_TEXT("-------------\n")); xp_printf (XP_TEXT("-------------\n"));
print_subclasses (&stx, XP_STX_TEXT("Object")); print_subclasses (&stx, XP_TEXT("Object"));
xp_printf (XP_TEXT("-------------\n")); xp_printf (XP_TEXT("-------------\n"));
#if 0 #if 0
{ {
xp_stx_word_t method_name; xp_word_t method_name;
xp_stx_word_t main_class; xp_word_t main_class;
xp_stx_word_t method, context; xp_word_t method, context;
method_name = xp_stx_new_symbol (&stx,XP_STX_TEXT("main")); method_name = xp_stx_new_symbol (&stx,XP_TEXT("main"));
main_class = xp_stx_lookup_class (&stx,argv[1]); main_class = xp_stx_lookup_class (&stx,argv[1]);
if (main_class == stx.nil) { if (main_class == stx.nil) {
@ -211,7 +211,7 @@ int xp_main (int argc, xp_char_t* argv[])
method = xp_stx_alloc_byte_object (&stx,100); method = xp_stx_alloc_byte_object (&stx,100);
XP_STX_CLASS(&stx,method) = stx.class_method; XP_STX_CLASS(&stx,method) = stx.class_method;
*/ */
method = xp_stx_instantiate (&stx, XP_STX_TEXT("Method")); method = xp_stx_instantiate (&stx, XP_TEXT("Method"));
XP_STX_BYTEAT(&stx,method,0) = PUSH_OBJECT; XP_STX_BYTEAT(&stx,method,0) = PUSH_OBJECT;
XP_STX_BYTEAT(&stx,method,1) = main_class; XP_STX_BYTEAT(&stx,method,1) = main_class;
@ -222,7 +222,7 @@ int xp_main (int argc, xp_char_t* argv[])
/* /*
context = xp_stx_new_context (&stx, method, stx.nil, stx.nil); context = xp_stx_new_context (&stx, method, stx.nil, stx.nil);
*/ */
context = xp_stx_instantiate (&stx, XP_STX_TEXT("Context")); context = xp_stx_instantiate (&stx, XP_TEXT("Context"));
xp_stx_run_context (&stx, context); xp_stx_run_context (&stx, context);
} }
#endif #endif