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-02-04 16:23:34 +00:00
parent 63286b4af5
commit a4ab9b9de8
7 changed files with 90 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ase/lsp/eval.c
View File

@ -1,5 +1,5 @@
/* /*
* $Id: eval.c,v 1.2 2005-02-04 16:00:37 bacon Exp $ * $Id: eval.c,v 1.3 2005-02-04 16:23:34 bacon Exp $
*/ */
#include <xp/lisp/lisp.h> #include <xp/lisp/lisp.h>
@ -147,9 +147,9 @@ static xp_lisp_obj_t* eval_cons (xp_lisp_t* lsp, xp_lisp_obj_t* cons)
} }
} }
xp_printf (XP_LISP_TEXT("bad function: ")); xp_printf (XP_TEXT("bad function: "));
xp_lisp_print (lsp, car); xp_lisp_print (lsp, car);
xp_printf (XP_LISP_TEXT("\n")); xp_printf (XP_TEXT("\n"));
lsp->error = XP_LISP_ERR_BAD_FUNC; lsp->error = XP_LISP_ERR_BAD_FUNC;
return XP_NULL; return XP_NULL;
} }

4
ase/lsp/lisp.c
View File

@ -1,5 +1,5 @@
/* /*
* $Id: lisp.c,v 1.2 2005-02-04 16:00:37 bacon Exp $ * $Id: lisp.c,v 1.3 2005-02-04 16:23:34 bacon Exp $
*/ */
#include <xp/lisp/lisp.h> #include <xp/lisp/lisp.h>
@ -22,7 +22,7 @@ xp_lisp_t* xp_lisp_new (xp_size_t mem_ubound, xp_size_t mem_ubound_inc)
//lsp->opt_undef_symbol = 1; //lsp->opt_undef_symbol = 1;
lsp->opt_undef_symbol = 0; lsp->opt_undef_symbol = 0;
lsp->curc = XP_LISP_CHAR_END; lsp->curc = XP_EOF;
lsp->creader = XP_NULL; lsp->creader = XP_NULL;
lsp->creader_extra = XP_NULL; lsp->creader_extra = XP_NULL;
lsp->creader_just_set = 0; lsp->creader_just_set = 0;

18
ase/lsp/memory.c
View File

@ -1,5 +1,5 @@
/* /*
* $Id: memory.c,v 1.2 2005-02-04 16:00:37 bacon Exp $ * $Id: memory.c,v 1.3 2005-02-04 16:23:34 bacon Exp $
*/ */
#include <xp/lisp/memory.h> #include <xp/lisp/memory.h>
@ -53,9 +53,9 @@ xp_lisp_mem_t* xp_lisp_mem_new (xp_size_t ubound, xp_size_t ubound_inc)
// initialize common object pointers // initialize common object pointers
mem->nil = xp_lisp_make_nil (mem); mem->nil = xp_lisp_make_nil (mem);
mem->t = xp_lisp_make_true (mem); mem->t = xp_lisp_make_true (mem);
mem->quote = xp_lisp_make_symbol (mem, XP_LISP_TEXT("quote"), 5); mem->quote = xp_lisp_make_symbol (mem,XP_TEXT("quote"), 5);
mem->lambda = xp_lisp_make_symbol (mem, XP_LISP_TEXT("lambda"), 6); mem->lambda = xp_lisp_make_symbol (mem,XP_TEXT("lambda"), 6);
mem->macro = xp_lisp_make_symbol (mem, XP_LISP_TEXT("macro"), 5); mem->macro = xp_lisp_make_symbol (mem,XP_TEXT("macro"), 5);
if (mem->nil == XP_NULL || if (mem->nil == XP_NULL ||
mem->t == XP_NULL || mem->t == XP_NULL ||
@ -574,7 +574,7 @@ int xp_lisp_comp_symbol (xp_lisp_obj_t* obj, const xp_lisp_char* str)
index++; p++; str++; index++; p++; str++;
} }
return (*str == XP_LISP_CHAR('\0'))? 0: -1; return (*str == XP_CHAR('\0'))? 0: -1;
} }
int xp_lisp_comp_symbol2 (xp_lisp_obj_t* obj, const xp_lisp_char* str, xp_size_t len) int xp_lisp_comp_symbol2 (xp_lisp_obj_t* obj, const xp_lisp_char* str, xp_size_t len)
@ -615,7 +615,7 @@ int xp_lisp_comp_string (xp_lisp_obj_t* obj, const xp_lisp_char* str)
index++; p++; str++; index++; p++; str++;
} }
return (*str == XP_LISP_CHAR('\0'))? 0: -1; return (*str == XP_CHAR('\0'))? 0: -1;
} }
int xp_lisp_comp_string2 (xp_lisp_obj_t* obj, const xp_lisp_char* str, xp_size_t len) int xp_lisp_comp_string2 (xp_lisp_obj_t* obj, const xp_lisp_char* str, xp_size_t len)
@ -642,8 +642,8 @@ int xp_lisp_comp_string2 (xp_lisp_obj_t* obj, const xp_lisp_char* str, xp_size_t
void xp_lisp_copy_string (xp_lisp_char* dst, const xp_lisp_char* str) void xp_lisp_copy_string (xp_lisp_char* dst, const xp_lisp_char* str)
{ {
// the buffer pointed by dst should be big enough to hold str // the buffer pointed by dst should be big enough to hold str
while (*str != XP_LISP_CHAR('\0')) *dst++ = *str++; while (*str != XP_CHAR('\0')) *dst++ = *str++;
*dst = XP_LISP_CHAR('\0'); *dst = XP_CHAR('\0');
} }
void xp_lisp_copy_string2 (xp_lisp_char* dst, const xp_lisp_char* str, xp_size_t len) void xp_lisp_copy_string2 (xp_lisp_char* dst, const xp_lisp_char* str, xp_size_t len)
@ -653,6 +653,6 @@ void xp_lisp_copy_string2 (xp_lisp_char* dst, const xp_lisp_char* str, xp_size_t
*dst++ = *str++; *dst++ = *str++;
len--; len--;
} }
*dst = XP_LISP_CHAR('\0'); *dst = XP_CHAR('\0');
} }

58
ase/lsp/print.c
View File

@ -1,5 +1,5 @@
/* /*
* $Id: print.c,v 1.2 2005-02-04 16:00:37 bacon Exp $ * $Id: print.c,v 1.3 2005-02-04 16:23:34 bacon Exp $
*/ */
#include <xp/lisp/lisp.h> #include <xp/lisp/lisp.h>
@ -8,52 +8,52 @@ void xp_lisp_print_debug (xp_lisp_obj_t* obj)
{ {
switch (XP_LISP_TYPE(obj)) { switch (XP_LISP_TYPE(obj)) {
case XP_LISP_OBJ_NIL: case XP_LISP_OBJ_NIL:
xp_printf ( XP_LISP_TEXT("nil")); xp_printf (XP_TEXT("nil"));
break; break;
case XP_LISP_OBJ_TRUE: case XP_LISP_OBJ_TRUE:
xp_printf ( XP_LISP_TEXT("t")); xp_printf (XP_TEXT("t"));
break; break;
case XP_LISP_OBJ_INT: case XP_LISP_OBJ_INT:
xp_printf ( XP_LISP_TEXT("%d"), XP_LISP_IVALUE(obj)); xp_printf (XP_TEXT("%d"), XP_LISP_IVALUE(obj));
break; break;
case XP_LISP_OBJ_FLOAT: case XP_LISP_OBJ_FLOAT:
xp_printf ( XP_LISP_TEXT("%f"), XP_LISP_FVALUE(obj)); xp_printf (XP_TEXT("%f"), XP_LISP_FVALUE(obj));
break; break;
case XP_LISP_OBJ_SYMBOL: case XP_LISP_OBJ_SYMBOL:
xp_printf ( XP_LISP_TEXT("%s"), XP_LISP_SYMVALUE(obj)); xp_printf (XP_TEXT("%s"), XP_LISP_SYMVALUE(obj));
break; break;
case XP_LISP_OBJ_STRING: case XP_LISP_OBJ_STRING:
xp_printf ( XP_LISP_TEXT("%s"), XP_LISP_STRVALUE(obj)); xp_printf (XP_TEXT("%s"), XP_LISP_STRVALUE(obj));
break; break;
case XP_LISP_OBJ_CONS: case XP_LISP_OBJ_CONS:
{ {
xp_lisp_obj_t* p = obj; xp_lisp_obj_t* p = obj;
xp_printf ( XP_LISP_TEXT("(")); xp_printf (XP_TEXT("("));
do { do {
xp_lisp_print_debug (XP_LISP_CAR(p)); xp_lisp_print_debug (XP_LISP_CAR(p));
p = XP_LISP_CDR(p); p = XP_LISP_CDR(p);
if (XP_LISP_TYPE(p) != XP_LISP_OBJ_NIL) { if (XP_LISP_TYPE(p) != XP_LISP_OBJ_NIL) {
xp_printf ( XP_LISP_TEXT(" ")); xp_printf (XP_TEXT(" "));
if (XP_LISP_TYPE(p) != XP_LISP_OBJ_CONS) { if (XP_LISP_TYPE(p) != XP_LISP_OBJ_CONS) {
xp_printf ( XP_LISP_TEXT(". ")); xp_printf (XP_TEXT(". "));
xp_lisp_print_debug (p); xp_lisp_print_debug (p);
} }
} }
} while (XP_LISP_TYPE(p) != XP_LISP_OBJ_NIL && XP_LISP_TYPE(p) == XP_LISP_OBJ_CONS); } while (XP_LISP_TYPE(p) != XP_LISP_OBJ_NIL && XP_LISP_TYPE(p) == XP_LISP_OBJ_CONS);
xp_printf ( XP_LISP_TEXT(")")); xp_printf (XP_TEXT(")"));
} }
break; break;
case XP_LISP_OBJ_FUNC: case XP_LISP_OBJ_FUNC:
xp_printf ( XP_LISP_TEXT("func")); xp_printf (XP_TEXT("func"));
break; break;
case XP_LISP_OBJ_MACRO: case XP_LISP_OBJ_MACRO:
xp_printf (XP_LISP_TEXT("macro")); xp_printf (XP_TEXT("macro"));
break; break;
case XP_LISP_OBJ_PRIM: case XP_LISP_OBJ_PRIM:
xp_printf (XP_LISP_TEXT("prim")); xp_printf (XP_TEXT("prim"));
break; break;
default: default:
xp_printf (XP_LISP_TEXT("unknown object type: %d"), XP_LISP_TYPE(obj)); xp_printf (XP_TEXT("unknown object type: %d"), XP_LISP_TYPE(obj));
} }
} }
@ -61,53 +61,53 @@ void xp_lisp_print (xp_lisp_t* lsp, xp_lisp_obj_t* obj)
{ {
switch (XP_LISP_TYPE(obj)) { switch (XP_LISP_TYPE(obj)) {
case XP_LISP_OBJ_NIL: case XP_LISP_OBJ_NIL:
xp_fprintf (lsp->outstream, XP_LISP_TEXT("nil")); xp_fprintf (lsp->outstream,XP_TEXT("nil"));
break; break;
case XP_LISP_OBJ_TRUE: case XP_LISP_OBJ_TRUE:
xp_fprintf (lsp->outstream, XP_LISP_TEXT("t")); xp_fprintf (lsp->outstream,XP_TEXT("t"));
break; break;
case XP_LISP_OBJ_INT: case XP_LISP_OBJ_INT:
xp_fprintf (lsp->outstream, XP_LISP_TEXT("%d"), XP_LISP_IVALUE(obj)); xp_fprintf (lsp->outstream,XP_TEXT("%d"), XP_LISP_IVALUE(obj));
break; break;
case XP_LISP_OBJ_FLOAT: case XP_LISP_OBJ_FLOAT:
xp_fprintf (lsp->outstream, XP_LISP_TEXT("%f"), XP_LISP_FVALUE(obj)); xp_fprintf (lsp->outstream,XP_TEXT("%f"), XP_LISP_FVALUE(obj));
break; break;
case XP_LISP_OBJ_SYMBOL: case XP_LISP_OBJ_SYMBOL:
xp_fprintf (lsp->outstream, XP_LISP_TEXT("%s"), XP_LISP_SYMVALUE(obj)); xp_fprintf (lsp->outstream,XP_TEXT("%s"), XP_LISP_SYMVALUE(obj));
break; break;
case XP_LISP_OBJ_STRING: case XP_LISP_OBJ_STRING:
xp_fprintf (lsp->outstream, XP_LISP_TEXT("\"%s\""), XP_LISP_STRVALUE(obj)); xp_fprintf (lsp->outstream,XP_TEXT("\"%s\""), XP_LISP_STRVALUE(obj));
break; break;
case XP_LISP_OBJ_CONS: case XP_LISP_OBJ_CONS:
{ {
xp_lisp_obj_t* p = obj; xp_lisp_obj_t* p = obj;
xp_fprintf (lsp->outstream, XP_LISP_TEXT("(")); xp_fprintf (lsp->outstream,XP_TEXT("("));
do { do {
xp_lisp_print (lsp, XP_LISP_CAR(p)); xp_lisp_print (lsp, XP_LISP_CAR(p));
p = XP_LISP_CDR(p); p = XP_LISP_CDR(p);
if (p != lsp->mem->nil) { if (p != lsp->mem->nil) {
xp_fprintf (lsp->outstream, XP_LISP_TEXT(" ")); xp_fprintf (lsp->outstream,XP_TEXT(" "));
if (XP_LISP_TYPE(p) != XP_LISP_OBJ_CONS) { if (XP_LISP_TYPE(p) != XP_LISP_OBJ_CONS) {
xp_fprintf (lsp->outstream, XP_LISP_TEXT(". ")); xp_fprintf (lsp->outstream,XP_TEXT(". "));
xp_lisp_print (lsp, p); xp_lisp_print (lsp, p);
} }
} }
} while (p != lsp->mem->nil && XP_LISP_TYPE(p) == XP_LISP_OBJ_CONS); } while (p != lsp->mem->nil && XP_LISP_TYPE(p) == XP_LISP_OBJ_CONS);
xp_fprintf (lsp->outstream, XP_LISP_TEXT(")")); xp_fprintf (lsp->outstream,XP_TEXT(")"));
} }
break; break;
case XP_LISP_OBJ_FUNC: case XP_LISP_OBJ_FUNC:
xp_fprintf (lsp->outstream, XP_LISP_TEXT("func")); xp_fprintf (lsp->outstream,XP_TEXT("func"));
break; break;
case XP_LISP_OBJ_MACRO: case XP_LISP_OBJ_MACRO:
xp_fprintf (lsp->outstream, XP_LISP_TEXT("macro")); xp_fprintf (lsp->outstream,XP_TEXT("macro"));
break; break;
case XP_LISP_OBJ_PRIM: case XP_LISP_OBJ_PRIM:
xp_fprintf (lsp->outstream, XP_LISP_TEXT("prim")); xp_fprintf (lsp->outstream,XP_TEXT("prim"));
break; break;
default: default:
xp_fprintf (lsp->outstream, xp_fprintf (lsp->outstream,
XP_LISP_TEXT("unknown object type: %d"), XP_LISP_TYPE(obj)); XP_TEXT("unknown object type: %d"), XP_LISP_TYPE(obj));
} }
} }

76
ase/lsp/read.c
View File

@ -1,5 +1,5 @@
/* /*
* $Id: read.c,v 1.2 2005-02-04 16:00:37 bacon Exp $ * $Id: read.c,v 1.3 2005-02-04 16:23:34 bacon Exp $
*/ */
#include <xp/lisp/lisp.h> #include <xp/lisp/lisp.h>
@ -11,12 +11,12 @@
#define IS_ALNUM(x) xp_isalnum(x) #define IS_ALNUM(x) xp_isalnum(x)
#define IS_IDENT(c) \ #define IS_IDENT(c) \
((c) == XP_LISP_CHAR('+') || (c) == XP_LISP_CHAR('-') || \ ((c) == XP_CHAR('+') || (c) == XP_CHAR('-') || \
(c) == XP_LISP_CHAR('*') || (c) == XP_LISP_CHAR('/') || \ (c) == XP_CHAR('*') || (c) == XP_CHAR('/') || \
(c) == XP_LISP_CHAR('%') || (c) == XP_LISP_CHAR('&') || \ (c) == XP_CHAR('%') || (c) == XP_CHAR('&') || \
(c) == XP_LISP_CHAR('<') || (c) == XP_LISP_CHAR('>') || \ (c) == XP_CHAR('<') || (c) == XP_CHAR('>') || \
(c) == XP_LISP_CHAR('=') || (c) == XP_LISP_CHAR('_') || \ (c) == XP_CHAR('=') || (c) == XP_CHAR('_') || \
(c) == XP_LISP_CHAR('?')) (c) == XP_CHAR('?'))
#define TOKEN_CLEAR(lsp) xp_lisp_token_clear (lsp->token) #define TOKEN_CLEAR(lsp) xp_lisp_token_clear (lsp->token)
#define TOKEN_TYPE(lsp) lsp->token->type #define TOKEN_TYPE(lsp) lsp->token->type
@ -142,8 +142,8 @@ static xp_lisp_obj_t* read_obj (xp_lisp_t* lsp)
return obj; return obj;
case TOKEN_IDENT: case TOKEN_IDENT:
xp_lisp_assert (lsp->mem->nil != XP_NULL && lsp->mem->t != XP_NULL); xp_lisp_assert (lsp->mem->nil != XP_NULL && lsp->mem->t != XP_NULL);
if (TOKEN_COMPARE(lsp, XP_LISP_TEXT("nil")) == 0) obj = lsp->mem->nil; if (TOKEN_COMPARE(lsp,XP_TEXT("nil")) == 0) obj = lsp->mem->nil;
else if (TOKEN_COMPARE(lsp, XP_LISP_TEXT("t")) == 0) obj = lsp->mem->t; else if (TOKEN_COMPARE(lsp,XP_TEXT("t")) == 0) obj = lsp->mem->t;
else { else {
obj = xp_lisp_make_symbol ( obj = xp_lisp_make_symbol (
lsp->mem, TOKEN_SVALUE(lsp), TOKEN_SLENGTH(lsp)); lsp->mem, TOKEN_SVALUE(lsp), TOKEN_SLENGTH(lsp));
@ -264,43 +264,43 @@ static int read_token (xp_lisp_t* lsp)
while (IS_SPACE(lsp->curc)) NEXT_CHAR (lsp); while (IS_SPACE(lsp->curc)) NEXT_CHAR (lsp);
// skip the comments here // skip the comments here
if (lsp->curc == XP_LISP_CHAR(';')) { if (lsp->curc == XP_CHAR(';')) {
do { do {
NEXT_CHAR (lsp); NEXT_CHAR (lsp);
} while (lsp->curc != XP_LISP_CHAR('\n') && lsp->curc != XP_LISP_CHAR_END); } while (lsp->curc != XP_CHAR('\n') && lsp->curc != XP_EOF);
} }
else break; else break;
} }
if (lsp->curc == XP_LISP_CHAR_END) { if (lsp->curc == XP_EOF) {
TOKEN_TYPE(lsp) = TOKEN_END; TOKEN_TYPE(lsp) = TOKEN_END;
return 0; return 0;
} }
else if (lsp->curc == XP_LISP_CHAR('(')) { else if (lsp->curc == XP_CHAR('(')) {
TOKEN_ADD_CHAR (lsp, lsp->curc); TOKEN_ADD_CHAR (lsp, lsp->curc);
TOKEN_TYPE(lsp) = TOKEN_LPAREN; TOKEN_TYPE(lsp) = TOKEN_LPAREN;
NEXT_CHAR (lsp); NEXT_CHAR (lsp);
return 0; return 0;
} }
else if (lsp->curc == XP_LISP_CHAR(')')) { else if (lsp->curc == XP_CHAR(')')) {
TOKEN_ADD_CHAR (lsp, lsp->curc); TOKEN_ADD_CHAR (lsp, lsp->curc);
TOKEN_TYPE(lsp) = TOKEN_RPAREN; TOKEN_TYPE(lsp) = TOKEN_RPAREN;
NEXT_CHAR (lsp); NEXT_CHAR (lsp);
return 0; return 0;
} }
else if (lsp->curc == XP_LISP_CHAR('\'')) { else if (lsp->curc == XP_CHAR('\'')) {
TOKEN_ADD_CHAR (lsp, lsp->curc); TOKEN_ADD_CHAR (lsp, lsp->curc);
TOKEN_TYPE(lsp) = TOKEN_QUOTE; TOKEN_TYPE(lsp) = TOKEN_QUOTE;
NEXT_CHAR (lsp); NEXT_CHAR (lsp);
return 0; return 0;
} }
else if (lsp->curc == XP_LISP_CHAR('.')) { else if (lsp->curc == XP_CHAR('.')) {
TOKEN_ADD_CHAR (lsp, lsp->curc); TOKEN_ADD_CHAR (lsp, lsp->curc);
TOKEN_TYPE(lsp) = TOKEN_DOT; TOKEN_TYPE(lsp) = TOKEN_DOT;
NEXT_CHAR (lsp); NEXT_CHAR (lsp);
return 0; return 0;
} }
else if (lsp->curc == XP_LISP_CHAR('-')) { else if (lsp->curc == XP_CHAR('-')) {
TOKEN_ADD_CHAR (lsp, lsp->curc); TOKEN_ADD_CHAR (lsp, lsp->curc);
NEXT_CHAR (lsp); NEXT_CHAR (lsp);
return (IS_DIGIT(lsp->curc))? return (IS_DIGIT(lsp->curc))?
@ -312,7 +312,7 @@ static int read_token (xp_lisp_t* lsp)
else if (IS_ALPHA(lsp->curc) || IS_IDENT(lsp->curc)) { else if (IS_ALPHA(lsp->curc) || IS_IDENT(lsp->curc)) {
return read_ident (lsp); return read_ident (lsp);
} }
else if (lsp->curc == XP_LISP_CHAR('\"')) { else if (lsp->curc == XP_CHAR('\"')) {
NEXT_CHAR (lsp); NEXT_CHAR (lsp);
return read_string (lsp); return read_string (lsp);
} }
@ -326,7 +326,7 @@ static int read_number (xp_lisp_t* lsp, int negative)
{ {
do { do {
TOKEN_IVALUE(lsp) = TOKEN_IVALUE(lsp) =
TOKEN_IVALUE(lsp) * 10 + lsp->curc - XP_LISP_CHAR('0'); TOKEN_IVALUE(lsp) * 10 + lsp->curc - XP_CHAR('0');
TOKEN_ADD_CHAR (lsp, lsp->curc); TOKEN_ADD_CHAR (lsp, lsp->curc);
NEXT_CHAR (lsp); NEXT_CHAR (lsp);
} while (IS_DIGIT(lsp->curc)); } while (IS_DIGIT(lsp->curc));
@ -355,7 +355,7 @@ static int read_string (xp_lisp_t* lsp)
xp_lisp_cint code = 0; xp_lisp_cint code = 0;
do { do {
if (lsp->curc == XP_LISP_CHAR_END) { if (lsp->curc == XP_EOF) {
TOKEN_TYPE(lsp) = TOKEN_UNTERM_STRING; TOKEN_TYPE(lsp) = TOKEN_UNTERM_STRING;
return 0; return 0;
} }
@ -369,34 +369,34 @@ static int read_string (xp_lisp_t* lsp)
} }
else if (escaped == 1) { else if (escaped == 1) {
/* backslash + character */ /* backslash + character */
if (lsp->curc == XP_LISP_CHAR('a')) if (lsp->curc == XP_CHAR('a'))
lsp->curc = XP_LISP_CHAR('\a'); lsp->curc = XP_CHAR('\a');
else if (lsp->curc == XP_LISP_CHAR('b')) else if (lsp->curc == XP_CHAR('b'))
lsp->curc = XP_LISP_CHAR('\b'); lsp->curc = XP_CHAR('\b');
else if (lsp->curc == XP_LISP_CHAR('f')) else if (lsp->curc == XP_CHAR('f'))
lsp->curc = XP_LISP_CHAR('\f'); lsp->curc = XP_CHAR('\f');
else if (lsp->curc == XP_LISP_CHAR('n')) else if (lsp->curc == XP_CHAR('n'))
lsp->curc = XP_LISP_CHAR('\n'); lsp->curc = XP_CHAR('\n');
else if (lsp->curc == XP_LISP_CHAR('r')) else if (lsp->curc == XP_CHAR('r'))
lsp->curc = XP_LISP_CHAR('\r'); lsp->curc = XP_CHAR('\r');
else if (lsp->curc == XP_LISP_CHAR('t')) else if (lsp->curc == XP_CHAR('t'))
lsp->curc = XP_LISP_CHAR('\t'); lsp->curc = XP_CHAR('\t');
else if (lsp->curc == XP_LISP_CHAR('v')) else if (lsp->curc == XP_CHAR('v'))
lsp->curc = XP_LISP_CHAR('\v'); lsp->curc = XP_CHAR('\v');
else if (lsp->curc == XP_LISP_CHAR('0')) { else if (lsp->curc == XP_CHAR('0')) {
escaped = 2; escaped = 2;
code = 0; code = 0;
NEXT_CHAR (lsp); NEXT_CHAR (lsp);
continue; continue;
} }
else if (lsp->curc == XP_LISP_CHAR('x')) { else if (lsp->curc == XP_CHAR('x')) {
escaped = 3; escaped = 3;
code = 0; code = 0;
NEXT_CHAR (lsp); NEXT_CHAR (lsp);
continue; continue;
} }
} }
else if (lsp->curc == XP_LISP_CHAR('\\')) { else if (lsp->curc == XP_CHAR('\\')) {
escaped = 1; escaped = 1;
NEXT_CHAR (lsp); NEXT_CHAR (lsp);
continue; continue;
@ -404,7 +404,7 @@ static int read_string (xp_lisp_t* lsp)
TOKEN_ADD_CHAR (lsp, lsp->curc); TOKEN_ADD_CHAR (lsp, lsp->curc);
NEXT_CHAR (lsp); NEXT_CHAR (lsp);
} while (lsp->curc != XP_LISP_CHAR('\"')); } while (lsp->curc != XP_CHAR('\"'));
TOKEN_TYPE(lsp) = TOKEN_STRING; TOKEN_TYPE(lsp) = TOKEN_STRING;
NEXT_CHAR (lsp); NEXT_CHAR (lsp);

12
ase/lsp/token.c
View File

@ -1,5 +1,5 @@
/* /*
* $Id: token.c,v 1.2 2005-02-04 16:00:37 bacon Exp $ * $Id: token.c,v 1.3 2005-02-04 16:23:34 bacon Exp $
*/ */
#include "token.h" #include "token.h"
@ -25,7 +25,7 @@ xp_lisp_token_t* xp_lisp_token_new (xp_size_t capacity)
token->size = 0; token->size = 0;
token->capacity = capacity; token->capacity = capacity;
token->buffer[0] = XP_LISP_CHAR('\0'); token->buffer[0] = XP_CHAR('\0');
return token; return token;
} }
@ -48,7 +48,7 @@ int xp_lisp_token_addc (xp_lisp_token_t* token, xp_lisp_cint c)
} }
token->buffer[token->size++] = c; token->buffer[token->size++] = c;
token->buffer[token->size] = XP_LISP_CHAR('\0'); token->buffer[token->size] = XP_CHAR('\0');
return 0; return 0;
} }
@ -58,7 +58,7 @@ void xp_lisp_token_clear (xp_lisp_token_t* token)
token->fvalue = .0; token->fvalue = .0;
token->size = 0; token->size = 0;
token->buffer[0] = XP_LISP_CHAR('\0'); token->buffer[0] = XP_CHAR('\0');
} }
xp_lisp_char* xp_lisp_token_transfer (xp_lisp_token_t* token, xp_size_t capacity) xp_lisp_char* xp_lisp_token_transfer (xp_lisp_token_t* token, xp_size_t capacity)
@ -72,7 +72,7 @@ xp_lisp_char* xp_lisp_token_transfer (xp_lisp_token_t* token, xp_size_t capacity
token->buffer = new_buffer; token->buffer = new_buffer;
token->size = 0; token->size = 0;
token->capacity = capacity; token->capacity = capacity;
token->buffer[0] = XP_LISP_CHAR('\0'); token->buffer[0] = XP_CHAR('\0');
return old_buffer; return old_buffer;
} }
@ -88,5 +88,5 @@ int xp_lisp_token_compare (xp_lisp_token_t* token, const xp_lisp_char* str)
index++; p++; str++; index++; p++; str++;
} }
return (*str == XP_LISP_CHAR('\0'))? 0: -1; return (*str == XP_CHAR('\0'))? 0: -1;
} }

13
ase/lsp/types.h
View File

@ -1,5 +1,5 @@
/* /*
* $Id: types.h,v 1.2 2005-02-04 16:00:37 bacon Exp $ * $Id: types.h,v 1.3 2005-02-04 16:23:34 bacon Exp $
*/ */
#ifndef _XP_LISP_TYPES_H_ #ifndef _XP_LISP_TYPES_H_
@ -10,14 +10,7 @@
typedef xp_char_t xp_lisp_char; typedef xp_char_t xp_lisp_char;
typedef xp_cint_t xp_lisp_cint; typedef xp_cint_t xp_lisp_cint;
typedef int xp_lisp_int; typedef xp_long_t xp_lisp_int;
typedef float xp_lisp_float; typedef xp_real_t xp_lisp_float;
#define XP_LISP_CHAR(x) XP_CHAR(x)
#define XP_LISP_TEXT(x) XP_TEXT(x)
#define XP_LISP_CHAR_END XP_EOF
#define xp_lisp_ensure(x) XP_ENSURE(x)
#define xp_lisp_assert(x) XP_ASSERT(x)
#endif #endif