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 2006-05-06 12:52:36 +00:00
parent e3b6a4adcc
commit dee681b939
10 changed files with 482 additions and 446 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

94
ase/awk/err.c
View File

@ -1,5 +1,5 @@
/* /*
* $Id: err.c,v 1.17 2006-04-30 15:50:38 bacon Exp $ * $Id: err.c,v 1.18 2006-05-06 12:52:36 bacon Exp $
*/ */
#include <xp/awk/awk_i.h> #include <xp/awk/awk_i.h>
@ -13,63 +13,63 @@ const xp_char_t* xp_awk_geterrstr (xp_awk_t* awk)
{ {
static const xp_char_t* __errstr[] = static const xp_char_t* __errstr[] =
{ {
XP_TEXT("no error"), XP_T("no error"),
XP_TEXT("out of memory"), XP_T("out of memory"),
XP_TEXT("no source io handler set"), XP_T("no source io handler set"),
XP_TEXT("cannot open source input"), XP_T("cannot open source input"),
XP_TEXT("cannot close source input"), XP_T("cannot close source input"),
XP_TEXT("cannot switch to next source input"), XP_T("cannot switch to next source input"),
XP_TEXT("cannot read source input"), XP_T("cannot read source input"),
XP_TEXT("cannot open text input"), XP_T("cannot open text input"),
XP_TEXT("cannot close text input"), XP_T("cannot close text input"),
XP_TEXT("cannot switch to next text input"), XP_T("cannot switch to next text input"),
XP_TEXT("cannot read text input"), XP_T("cannot read text input"),
XP_TEXT("invalid character"), XP_T("invalid character"),
XP_TEXT("cannot unget character"), XP_T("cannot unget character"),
XP_TEXT("unexpected end of source"), XP_T("unexpected end of source"),
XP_TEXT("unexpected end of a string"), XP_T("unexpected end of a string"),
XP_TEXT("unexpected end of a regular expression"), XP_T("unexpected end of a regular expression"),
XP_TEXT("left brace expected"), XP_T("left brace expected"),
XP_TEXT("left parenthesis expected"), XP_T("left parenthesis expected"),
XP_TEXT("right parenthesis expected"), XP_T("right parenthesis expected"),
XP_TEXT("right bracket expected"), XP_T("right bracket expected"),
XP_TEXT("comma expected"), XP_T("comma expected"),
XP_TEXT("semicolon expected"), XP_T("semicolon expected"),
XP_TEXT("colon expected"), XP_T("colon expected"),
XP_TEXT("keyword 'in' expected"), XP_T("keyword 'in' expected"),
XP_TEXT("not a variable after 'in'"), XP_T("not a variable after 'in'"),
XP_TEXT("expression expected"), XP_T("expression expected"),
XP_TEXT("keyword 'while' expected"), XP_T("keyword 'while' expected"),
XP_TEXT("assignment statement expected"), XP_T("assignment statement expected"),
XP_TEXT("identifier expected"), XP_T("identifier expected"),
XP_TEXT("duplicate BEGIN"), XP_T("duplicate BEGIN"),
XP_TEXT("duplicate END"), XP_T("duplicate END"),
XP_TEXT("duplicate function name"), XP_T("duplicate function name"),
XP_TEXT("duplicate parameter name"), XP_T("duplicate parameter name"),
XP_TEXT("duplicate variable name"), XP_T("duplicate variable name"),
XP_TEXT("duplicate name"), XP_T("duplicate name"),
XP_TEXT("undefined identifier"), XP_T("undefined identifier"),
XP_TEXT("l-value required"), XP_T("l-value required"),
XP_TEXT("too many arguments"), XP_T("too many arguments"),
XP_TEXT("divide by zero"), XP_T("divide by zero"),
XP_TEXT("invalid operand"), XP_T("invalid operand"),
XP_TEXT("no such function"), XP_T("no such function"),
XP_TEXT("value not assignable"), XP_T("value not assignable"),
XP_TEXT("value not indexable"), XP_T("value not indexable"),
XP_TEXT("wrong index value"), XP_T("wrong index value"),
XP_TEXT("internal error that should never have happened") XP_T("internal error that should never have happened")
}; };
if (awk->errnum >= 0 && awk->errnum < xp_countof(__errstr)) { if (awk->errnum >= 0 && awk->errnum < xp_countof(__errstr)) {
return __errstr[awk->errnum]; return __errstr[awk->errnum];
} }
return XP_TEXT("unknown error"); return XP_T("unknown error");
} }

4
ase/awk/map.c
View File

@ -1,5 +1,5 @@
/* /*
* $Id: map.c,v 1.18 2006-05-03 16:07:24 bacon Exp $ * $Id: map.c,v 1.19 2006-05-06 12:52:36 bacon Exp $
*/ */
#include <xp/awk/awk_i.h> #include <xp/awk/awk_i.h>
@ -252,7 +252,7 @@ static xp_size_t __hash (const xp_char_t* key)
{ {
xp_size_t n = 0, i; xp_size_t n = 0, i;
while (*key != XP_CHAR('\0')) while (*key != XP_T('\0'))
{ {
xp_byte_t* bp = (xp_byte_t*)key; xp_byte_t* bp = (xp_byte_t*)key;
for (i = 0; i < xp_sizeof(*key); i++) n = n * 31 + *bp++; for (i = 0; i < xp_sizeof(*key); i++) n = n * 31 + *bp++;

60
ase/awk/misc.c
View File

@ -1,5 +1,5 @@
/* /*
* $Id: misc.c,v 1.6 2006-04-26 15:49:33 bacon Exp $ * $Id: misc.c,v 1.7 2006-05-06 12:52:36 bacon Exp $
*/ */
#include <xp/awk/awk_i.h> #include <xp/awk/awk_i.h>
@ -20,27 +20,27 @@ xp_long_t xp_awk_strtolong (
p = str; while (xp_isspace(*p)) p++; p = str; while (xp_isspace(*p)) p++;
while (*p != XP_CHAR('\0')) while (*p != XP_T('\0'))
{ {
if (*p == XP_CHAR('-')) if (*p == XP_T('-'))
{ {
negative = ~negative; negative = ~negative;
p++; p++;
} }
else if (*p == XP_CHAR('+')) p++; else if (*p == XP_T('+')) p++;
else break; else break;
} }
if (base == 0) if (base == 0)
{ {
if (*p == XP_CHAR('0')) if (*p == XP_T('0'))
{ {
p++; p++;
if (*p == XP_CHAR('x') || *p == XP_CHAR('X')) if (*p == XP_T('x') || *p == XP_T('X'))
{ {
p++; base = 16; p++; base = 16;
} }
else if (*p == XP_CHAR('b') || *p == XP_CHAR('B')) else if (*p == XP_T('b') || *p == XP_T('B'))
{ {
p++; base = 2; p++; base = 2;
} }
@ -50,23 +50,23 @@ xp_long_t xp_awk_strtolong (
} }
else if (base == 16) else if (base == 16)
{ {
if (*p == XP_CHAR('0') && if (*p == XP_T('0') &&
(*(p+1) == XP_CHAR('x') || *(p+1) == XP_CHAR('X'))) p += 2; (*(p+1) == XP_T('x') || *(p+1) == XP_T('X'))) p += 2;
} }
else if (base == 2) else if (base == 2)
{ {
if (*p == XP_CHAR('0') && if (*p == XP_T('0') &&
(*(p+1) == XP_CHAR('b') || *(p+1) == XP_CHAR('B'))) p += 2; (*(p+1) == XP_T('b') || *(p+1) == XP_T('B'))) p += 2;
} }
while (*p != XP_CHAR('\0')) while (*p != XP_T('\0'))
{ {
if (*p >= XP_CHAR('0') && *p <= XP_CHAR('9')) if (*p >= XP_T('0') && *p <= XP_T('9'))
digit = *p - XP_CHAR('0'); digit = *p - XP_T('0');
else if (*p >= XP_CHAR('A') && *p <= XP_CHAR('Z')) else if (*p >= XP_T('A') && *p <= XP_T('Z'))
digit = *p - XP_CHAR('A') + 10; digit = *p - XP_T('A') + 10;
else if (*p >= XP_CHAR('a') && *p <= XP_CHAR('z')) else if (*p >= XP_T('a') && *p <= XP_T('z'))
digit = *p - XP_CHAR('a') + 10; digit = *p - XP_T('a') + 10;
else break; else break;
if (digit >= base) break; if (digit >= base) break;
@ -137,14 +137,14 @@ xp_real_t xp_awk_strtoreal (const xp_char_t* str)
/* Strip off leading blanks and check for a sign */ /* Strip off leading blanks and check for a sign */
while (xp_isspace(*p)) p++; while (xp_isspace(*p)) p++;
while (*p != XP_CHAR('\0')) while (*p != XP_T('\0'))
{ {
if (*p == XP_CHAR('-')) if (*p == XP_T('-'))
{ {
sign = ~sign; sign = ~sign;
p++; p++;
} }
else if (*p == XP_CHAR('+')) p++; else if (*p == XP_T('+')) p++;
else break; else break;
} }
@ -154,7 +154,7 @@ xp_real_t xp_awk_strtoreal (const xp_char_t* str)
for (mantSize = 0; ; mantSize++) { for (mantSize = 0; ; mantSize++) {
c = *p; c = *p;
if (!xp_isdigit(c)) { if (!xp_isdigit(c)) {
if ((c != XP_CHAR('.')) || (decPt >= 0)) break; if ((c != XP_T('.')) || (decPt >= 0)) break;
decPt = mantSize; decPt = mantSize;
} }
p++; p++;
@ -201,40 +201,40 @@ xp_real_t xp_awk_strtoreal (const xp_char_t* str)
{ {
c = *p; c = *p;
p++; p++;
if (c == XP_CHAR('.')) if (c == XP_T('.'))
{ {
c = *p; c = *p;
p++; p++;
} }
frac1 = 10 * frac1 + (c - XP_CHAR('0')); frac1 = 10 * frac1 + (c - XP_T('0'));
} }
frac2 = 0; frac2 = 0;
for (; mantSize > 0; mantSize -= 1) { for (; mantSize > 0; mantSize -= 1) {
c = *p; c = *p;
p++; p++;
if (c == XP_CHAR('.')) if (c == XP_T('.'))
{ {
c = *p; c = *p;
p++; p++;
} }
frac2 = 10*frac2 + (c - XP_CHAR('0')); frac2 = 10*frac2 + (c - XP_T('0'));
} }
fraction = (1.0e9 * frac1) + frac2; fraction = (1.0e9 * frac1) + frac2;
} }
/* Skim off the exponent */ /* Skim off the exponent */
p = pExp; p = pExp;
if ((*p == XP_CHAR('E')) || (*p == XP_CHAR('e'))) if ((*p == XP_T('E')) || (*p == XP_T('e')))
{ {
p++; p++;
if (*p == XP_CHAR('-')) if (*p == XP_T('-'))
{ {
expSign = 1; expSign = 1;
p++; p++;
} }
else else
{ {
if (*p == XP_CHAR('+')) p++; if (*p == XP_T('+')) p++;
expSign = 0; expSign = 0;
} }
if (!xp_isdigit(*p)) if (!xp_isdigit(*p))
@ -244,7 +244,7 @@ xp_real_t xp_awk_strtoreal (const xp_char_t* str)
} }
while (xp_isdigit(*p)) while (xp_isdigit(*p))
{ {
exp = exp * 10 + (*p - XP_CHAR('0')); exp = exp * 10 + (*p - XP_T('0'));
p++; p++;
} }
} }

298
ase/awk/parse.c
View File

@ -1,5 +1,5 @@
/* /*
* $Id: parse.c,v 1.100 2006-05-02 15:43:10 bacon Exp $ * $Id: parse.c,v 1.101 2006-05-06 12:52:36 bacon Exp $
*/ */
#include <xp/awk/awk_i.h> #include <xp/awk/awk_i.h>
@ -173,28 +173,28 @@ struct __kwent
static struct __kwent __kwtab[] = static struct __kwent __kwtab[] =
{ {
{ XP_TEXT("BEGIN"), TOKEN_BEGIN, 0 }, { XP_T("BEGIN"), TOKEN_BEGIN, 0 },
{ XP_TEXT("END"), TOKEN_END, 0 }, { XP_T("END"), TOKEN_END, 0 },
{ XP_TEXT("function"), TOKEN_FUNCTION, 0 }, { XP_T("function"), TOKEN_FUNCTION, 0 },
{ XP_TEXT("func"), TOKEN_FUNCTION, 0 }, { XP_T("func"), TOKEN_FUNCTION, 0 },
{ XP_TEXT("if"), TOKEN_IF, 0 }, { XP_T("if"), TOKEN_IF, 0 },
{ XP_TEXT("else"), TOKEN_ELSE, 0 }, { XP_T("else"), TOKEN_ELSE, 0 },
{ XP_TEXT("while"), TOKEN_WHILE, 0 }, { XP_T("while"), TOKEN_WHILE, 0 },
{ XP_TEXT("for"), TOKEN_FOR, 0 }, { XP_T("for"), TOKEN_FOR, 0 },
{ XP_TEXT("do"), TOKEN_DO, 0 }, { XP_T("do"), TOKEN_DO, 0 },
{ XP_TEXT("break"), TOKEN_BREAK, 0 }, { XP_T("break"), TOKEN_BREAK, 0 },
{ XP_TEXT("continue"), TOKEN_CONTINUE, 0 }, { XP_T("continue"), TOKEN_CONTINUE, 0 },
{ XP_TEXT("return"), TOKEN_RETURN, 0 }, { XP_T("return"), TOKEN_RETURN, 0 },
{ XP_TEXT("exit"), TOKEN_EXIT, 0 }, { XP_T("exit"), TOKEN_EXIT, 0 },
{ XP_TEXT("delete"), TOKEN_DELETE, 0 }, { XP_T("delete"), TOKEN_DELETE, 0 },
{ XP_TEXT("next"), TOKEN_NEXT, 0 }, { XP_T("next"), TOKEN_NEXT, 0 },
{ XP_TEXT("nextfile"), TOKEN_NEXTFILE, 0 }, { XP_T("nextfile"), TOKEN_NEXTFILE, 0 },
{ XP_TEXT("local"), TOKEN_LOCAL, XP_AWK_EXPLICIT }, { XP_T("local"), TOKEN_LOCAL, XP_AWK_EXPLICIT },
{ XP_TEXT("global"), TOKEN_GLOBAL, XP_AWK_EXPLICIT }, { XP_T("global"), TOKEN_GLOBAL, XP_AWK_EXPLICIT },
{ XP_TEXT("in"), TOKEN_IN, 0 }, { XP_T("in"), TOKEN_IN, 0 },
{ XP_NULL, 0, 0 } { XP_NULL, 0, 0 }
}; };
@ -202,27 +202,27 @@ static struct __kwent __kwtab[] =
/* TODO: /* TODO:
static struct __kwent __bvtab[] = static struct __kwent __bvtab[] =
{ {
{ XP_TEXT("ARGC"), TOKEN_ARGC, 0 }, { XP_T("ARGC"), TOKEN_ARGC, 0 },
{ XP_TEXT("ARGIND"), TOKEN_ARGIND, 0 }, { XP_T("ARGIND"), TOKEN_ARGIND, 0 },
{ XP_TEXT("ARGV"), TOKEN_ARGV, 0 }, { XP_T("ARGV"), TOKEN_ARGV, 0 },
{ XP_TEXT("CONVFMT"), TOKEN_CONVFMT, 0 }, { XP_T("CONVFMT"), TOKEN_CONVFMT, 0 },
{ XP_TEXT("FIELDWIDTHS"), TOKEN_FIELDWIDTHS, 0 }, { XP_T("FIELDWIDTHS"), TOKEN_FIELDWIDTHS, 0 },
{ XP_TEXT("ENVIRON"), TOKEN_ENVIRON, 0 }, { XP_T("ENVIRON"), TOKEN_ENVIRON, 0 },
{ XP_TEXT("ERRNO"), TOKEN_ERRNO, 0 }, { XP_T("ERRNO"), TOKEN_ERRNO, 0 },
{ XP_TEXT("FILENAME"), TOKEN_FILENAME, 0 }, { XP_T("FILENAME"), TOKEN_FILENAME, 0 },
{ XP_TEXT("FNR"), TOKEN_FNR, 0 }, { XP_T("FNR"), TOKEN_FNR, 0 },
{ XP_TEXT("FS"), TOKEN_FS, 0 }, { XP_T("FS"), TOKEN_FS, 0 },
{ XP_TEXT("IGNORECASE"), TOKEN_IGNORECASE, 0 }, { XP_T("IGNORECASE"), TOKEN_IGNORECASE, 0 },
{ XP_TEXT("NF"), TOKEN_NF, 0 }, { XP_T("NF"), TOKEN_NF, 0 },
{ XP_TEXT("NR"), TOKEN_NR, 0 }, { XP_T("NR"), TOKEN_NR, 0 },
{ XP_TEXT("OFMT"), TOKEN_OFMT, 0 }, { XP_T("OFMT"), TOKEN_OFMT, 0 },
{ XP_TEXT("OFS"), TOKEN_OFS, 0 }, { XP_T("OFS"), TOKEN_OFS, 0 },
{ XP_TEXT("ORS"), TOKEN_ORS, 0 }, { XP_T("ORS"), TOKEN_ORS, 0 },
{ XP_TEXT("RS"), TOKEN_RS, 0 }, { XP_T("RS"), TOKEN_RS, 0 },
{ XP_TEXT("RT"), TOKEN_RT, 0 }, { XP_T("RT"), TOKEN_RT, 0 },
{ XP_TEXT("RSTART"), TOKEN_RSTART, 0 }, { XP_T("RSTART"), TOKEN_RSTART, 0 },
{ XP_TEXT("RLENGTH"), TOKEN_RLENGTH, 0 }, { XP_T("RLENGTH"), TOKEN_RLENGTH, 0 },
{ XP_TEXT("SUBSEP"), TOKEN_SUBSEP, 0 }, { XP_T("SUBSEP"), TOKEN_SUBSEP, 0 },
{ XP_NULL, 0, 0 } { XP_NULL, 0, 0 }
}; };
*/ */
@ -273,16 +273,16 @@ static int __dump_func (xp_awk_pair_t* pair, void* arg)
xp_size_t i; xp_size_t i;
xp_assert (xp_strcmp(pair->key, func->name) == 0); xp_assert (xp_strcmp(pair->key, func->name) == 0);
xp_printf (XP_TEXT("function %s ("), func->name); xp_printf (XP_T("function %s ("), func->name);
for (i = 0; i < func->nargs; ) for (i = 0; i < func->nargs; )
{ {
xp_printf (XP_TEXT("__arg%lu"), (unsigned long)i++); xp_printf (XP_T("__arg%lu"), (unsigned long)i++);
if (i >= func->nargs) break; if (i >= func->nargs) break;
xp_printf (XP_TEXT(", ")); xp_printf (XP_T(", "));
} }
xp_printf (XP_TEXT(")\n")); xp_printf (XP_T(")\n"));
xp_awk_prnpt (func->body); xp_awk_prnpt (func->body);
xp_printf (XP_TEXT("\n")); xp_printf (XP_T("\n"));
return 0; return 0;
} }
@ -295,21 +295,21 @@ static void __dump (xp_awk_t* awk)
{ {
xp_size_t i; xp_size_t i;
xp_printf (XP_TEXT("global ")); xp_printf (XP_T("global "));
for (i = 0; i < awk->tree.nglobals - 1; i++) for (i = 0; i < awk->tree.nglobals - 1; i++)
{ {
xp_printf (XP_TEXT("__global%lu, "), (unsigned long)i); xp_printf (XP_T("__global%lu, "), (unsigned long)i);
} }
xp_printf (XP_TEXT("__global%lu;\n\n"), (unsigned long)i); xp_printf (XP_T("__global%lu;\n\n"), (unsigned long)i);
} }
xp_awk_map_walk (&awk->tree.funcs, __dump_func, XP_NULL); xp_awk_map_walk (&awk->tree.funcs, __dump_func, XP_NULL);
if (awk->tree.begin != XP_NULL) if (awk->tree.begin != XP_NULL)
{ {
xp_printf (XP_TEXT("BEGIN ")); xp_printf (XP_T("BEGIN "));
xp_awk_prnpt (awk->tree.begin); xp_awk_prnpt (awk->tree.begin);
xp_printf (XP_TEXT("\n")); xp_printf (XP_T("\n"));
} }
chain = awk->tree.chain; chain = awk->tree.chain;
@ -317,13 +317,13 @@ static void __dump (xp_awk_t* awk)
{ {
if (chain->pattern != XP_NULL) xp_awk_prnpt (chain->pattern); if (chain->pattern != XP_NULL) xp_awk_prnpt (chain->pattern);
if (chain->action != XP_NULL) xp_awk_prnpt (chain->action); if (chain->action != XP_NULL) xp_awk_prnpt (chain->action);
xp_printf (XP_TEXT("\n")); xp_printf (XP_T("\n"));
chain = chain->next; chain = chain->next;
} }
if (awk->tree.end != XP_NULL) if (awk->tree.end != XP_NULL)
{ {
xp_printf (XP_TEXT("END ")); xp_printf (XP_T("END "));
xp_awk_prnpt (awk->tree.end); xp_awk_prnpt (awk->tree.end);
} }
} }
@ -356,7 +356,7 @@ int xp_awk_parse (xp_awk_t* awk)
} }
awk->tree.nglobals = xp_awk_tab_getsize(&awk->parse.globals); awk->tree.nglobals = xp_awk_tab_getsize(&awk->parse.globals);
xp_printf (XP_TEXT("-----------------------------\n")); xp_printf (XP_T("-----------------------------\n"));
__dump (awk); __dump (awk);
return 0; return 0;
@ -422,7 +422,7 @@ static xp_awk_t* __parse_progunit (xp_awk_t* awk)
{ {
/* { print $0; } */ /* { print $0; } */
/* TODO: XXXX */ /* TODO: XXXX */
xp_printf (XP_TEXT("BLOCKLESS NOT IMPLEMENTED....\n")); xp_printf (XP_T("BLOCKLESS NOT IMPLEMENTED....\n"));
PANIC (awk, XP_AWK_EINTERNAL); PANIC (awk, XP_AWK_EINTERNAL);
} }
} }
@ -2562,7 +2562,7 @@ static int __get_token (xp_awk_t* awk)
{ {
if (__get_number(awk) == -1) return -1; if (__get_number(awk) == -1) return -1;
} }
else if (xp_isalpha(c) || c == XP_CHAR('_')) else if (xp_isalpha(c) || c == XP_T('_'))
{ {
/* identifier */ /* identifier */
do do
@ -2570,11 +2570,11 @@ static int __get_token (xp_awk_t* awk)
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
while (xp_isalpha(c) || c == XP_CHAR('_') || xp_isdigit(c)); while (xp_isalpha(c) || c == XP_T('_') || xp_isdigit(c));
SET_TOKEN_TYPE (awk, __classify_ident(awk,XP_STR_BUF(&awk->token.name))); SET_TOKEN_TYPE (awk, __classify_ident(awk,XP_STR_BUF(&awk->token.name)));
} }
else if (c == XP_CHAR('\"')) else if (c == XP_T('\"'))
{ {
SET_TOKEN_TYPE (awk, TOKEN_STR); SET_TOKEN_TYPE (awk, TOKEN_STR);
@ -2589,187 +2589,187 @@ static int __get_token (xp_awk_t* awk)
while (n == 1); while (n == 1);
c = awk->lex.curc; c = awk->lex.curc;
if (c != XP_CHAR('\"')) break; if (c != XP_T('\"')) break;
if (__get_string(awk) == -1) return -1; if (__get_string(awk) == -1) return -1;
} }
} }
else if (c == XP_CHAR('=')) else if (c == XP_T('='))
{ {
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
if (c == XP_CHAR('=')) if (c == XP_T('='))
{ {
SET_TOKEN_TYPE (awk, TOKEN_EQ); SET_TOKEN_TYPE (awk, TOKEN_EQ);
ADD_TOKEN_STR (awk, XP_TEXT("==")); ADD_TOKEN_STR (awk, XP_T("=="));
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else else
{ {
SET_TOKEN_TYPE (awk, TOKEN_ASSIGN); SET_TOKEN_TYPE (awk, TOKEN_ASSIGN);
ADD_TOKEN_STR (awk, XP_TEXT("=")); ADD_TOKEN_STR (awk, XP_T("="));
} }
} }
else if (c == XP_CHAR('!')) else if (c == XP_T('!'))
{ {
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
if (c == XP_CHAR('=')) if (c == XP_T('='))
{ {
SET_TOKEN_TYPE (awk, TOKEN_NE); SET_TOKEN_TYPE (awk, TOKEN_NE);
ADD_TOKEN_STR (awk, XP_TEXT("!=")); ADD_TOKEN_STR (awk, XP_T("!="));
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else if (c == XP_CHAR('~')) else if (c == XP_T('~'))
{ {
SET_TOKEN_TYPE (awk, TOKEN_NM); SET_TOKEN_TYPE (awk, TOKEN_NM);
ADD_TOKEN_STR (awk, XP_TEXT("!~")); ADD_TOKEN_STR (awk, XP_T("!~"));
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else else
{ {
SET_TOKEN_TYPE (awk, TOKEN_NOT); SET_TOKEN_TYPE (awk, TOKEN_NOT);
ADD_TOKEN_STR (awk, XP_TEXT("!")); ADD_TOKEN_STR (awk, XP_T("!"));
} }
} }
else if (c == XP_CHAR('>')) else if (c == XP_T('>'))
{ {
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
if ((awk->opt.parse & XP_AWK_SHIFT) && c == XP_CHAR('>')) if ((awk->opt.parse & XP_AWK_SHIFT) && c == XP_T('>'))
{ {
SET_TOKEN_TYPE (awk, TOKEN_RSHIFT); SET_TOKEN_TYPE (awk, TOKEN_RSHIFT);
ADD_TOKEN_STR (awk, XP_TEXT(">>")); ADD_TOKEN_STR (awk, XP_T(">>"));
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else if (c == XP_CHAR('=')) else if (c == XP_T('='))
{ {
SET_TOKEN_TYPE (awk, TOKEN_GE); SET_TOKEN_TYPE (awk, TOKEN_GE);
ADD_TOKEN_STR (awk, XP_TEXT(">=")); ADD_TOKEN_STR (awk, XP_T(">="));
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else else
{ {
SET_TOKEN_TYPE (awk, TOKEN_GT); SET_TOKEN_TYPE (awk, TOKEN_GT);
ADD_TOKEN_STR (awk, XP_TEXT(">")); ADD_TOKEN_STR (awk, XP_T(">"));
} }
} }
else if (c == XP_CHAR('<')) else if (c == XP_T('<'))
{ {
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
if ((awk->opt.parse & XP_AWK_SHIFT) && c == XP_CHAR('<')) if ((awk->opt.parse & XP_AWK_SHIFT) && c == XP_T('<'))
{ {
SET_TOKEN_TYPE (awk, TOKEN_LSHIFT); SET_TOKEN_TYPE (awk, TOKEN_LSHIFT);
ADD_TOKEN_STR (awk, XP_TEXT("<<")); ADD_TOKEN_STR (awk, XP_T("<<"));
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else if (c == XP_CHAR('=')) else if (c == XP_T('='))
{ {
SET_TOKEN_TYPE (awk, TOKEN_LE); SET_TOKEN_TYPE (awk, TOKEN_LE);
ADD_TOKEN_STR (awk, XP_TEXT("<=")); ADD_TOKEN_STR (awk, XP_T("<="));
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else else
{ {
SET_TOKEN_TYPE (awk, TOKEN_LT); SET_TOKEN_TYPE (awk, TOKEN_LT);
ADD_TOKEN_STR (awk, XP_TEXT("<")); ADD_TOKEN_STR (awk, XP_T("<"));
} }
} }
else if (c == XP_CHAR('|')) else if (c == XP_T('|'))
{ {
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
if (c == XP_CHAR('|')) if (c == XP_T('|'))
{ {
SET_TOKEN_TYPE (awk, TOKEN_LOR); SET_TOKEN_TYPE (awk, TOKEN_LOR);
ADD_TOKEN_STR (awk, XP_TEXT("||")); ADD_TOKEN_STR (awk, XP_T("||"));
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else else
{ {
SET_TOKEN_TYPE (awk, TOKEN_BOR); SET_TOKEN_TYPE (awk, TOKEN_BOR);
ADD_TOKEN_STR (awk, XP_TEXT("|")); ADD_TOKEN_STR (awk, XP_T("|"));
} }
} }
else if (c == XP_CHAR('&')) else if (c == XP_T('&'))
{ {
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
if (c == XP_CHAR('&')) if (c == XP_T('&'))
{ {
SET_TOKEN_TYPE (awk, TOKEN_LAND); SET_TOKEN_TYPE (awk, TOKEN_LAND);
ADD_TOKEN_STR (awk, XP_TEXT("&&")); ADD_TOKEN_STR (awk, XP_T("&&"));
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else else
{ {
SET_TOKEN_TYPE (awk, TOKEN_BAND); SET_TOKEN_TYPE (awk, TOKEN_BAND);
ADD_TOKEN_STR (awk, XP_TEXT("&")); ADD_TOKEN_STR (awk, XP_T("&"));
} }
} }
else if (c == XP_CHAR('~')) else if (c == XP_T('~'))
{ {
SET_TOKEN_TYPE (awk, TOKEN_TILDE); SET_TOKEN_TYPE (awk, TOKEN_TILDE);
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else if (c == XP_CHAR('^')) else if (c == XP_T('^'))
{ {
SET_TOKEN_TYPE (awk, TOKEN_BXOR); SET_TOKEN_TYPE (awk, TOKEN_BXOR);
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else if (c == XP_CHAR('+')) else if (c == XP_T('+'))
{ {
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
if (c == XP_CHAR('+')) if (c == XP_T('+'))
{ {
SET_TOKEN_TYPE (awk, TOKEN_PLUSPLUS); SET_TOKEN_TYPE (awk, TOKEN_PLUSPLUS);
ADD_TOKEN_STR (awk, XP_TEXT("++")); ADD_TOKEN_STR (awk, XP_T("++"));
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else if (c == XP_CHAR('=')) else if (c == XP_T('='))
{ {
SET_TOKEN_TYPE (awk, TOKEN_PLUS_ASSIGN); SET_TOKEN_TYPE (awk, TOKEN_PLUS_ASSIGN);
ADD_TOKEN_STR (awk, XP_TEXT("+=")); ADD_TOKEN_STR (awk, XP_T("+="));
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else else
{ {
SET_TOKEN_TYPE (awk, TOKEN_PLUS); SET_TOKEN_TYPE (awk, TOKEN_PLUS);
ADD_TOKEN_STR (awk, XP_TEXT("+")); ADD_TOKEN_STR (awk, XP_T("+"));
} }
} }
else if (c == XP_CHAR('-')) else if (c == XP_T('-'))
{ {
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
if (c == XP_CHAR('-')) if (c == XP_T('-'))
{ {
SET_TOKEN_TYPE (awk, TOKEN_MINUSMINUS); SET_TOKEN_TYPE (awk, TOKEN_MINUSMINUS);
ADD_TOKEN_STR (awk, XP_TEXT("--")); ADD_TOKEN_STR (awk, XP_T("--"));
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else if (c == XP_CHAR('=')) else if (c == XP_T('='))
{ {
SET_TOKEN_TYPE (awk, TOKEN_MINUS_ASSIGN); SET_TOKEN_TYPE (awk, TOKEN_MINUS_ASSIGN);
ADD_TOKEN_STR (awk, XP_TEXT("-=")); ADD_TOKEN_STR (awk, XP_T("-="));
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else else
{ {
SET_TOKEN_TYPE (awk, TOKEN_MINUS); SET_TOKEN_TYPE (awk, TOKEN_MINUS);
ADD_TOKEN_STR (awk, XP_TEXT("-")); ADD_TOKEN_STR (awk, XP_T("-"));
} }
} }
else if (c == XP_CHAR('*')) else if (c == XP_T('*'))
{ {
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
if (c == XP_CHAR('=')) if (c == XP_T('='))
{ {
SET_TOKEN_TYPE (awk, TOKEN_MUL_ASSIGN); SET_TOKEN_TYPE (awk, TOKEN_MUL_ASSIGN);
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else if (c == XP_CHAR('*')) else if (c == XP_T('*'))
{ {
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
if (c == XP_CHAR('=')) if (c == XP_T('='))
{ {
SET_TOKEN_TYPE (awk, TOKEN_EXP_ASSIGN); SET_TOKEN_TYPE (awk, TOKEN_EXP_ASSIGN);
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
@ -2787,11 +2787,11 @@ static int __get_token (xp_awk_t* awk)
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
} }
} }
else if (c == XP_CHAR('/')) else if (c == XP_T('/'))
{ {
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
if (c == XP_CHAR('=')) if (c == XP_T('='))
{ {
SET_TOKEN_TYPE (awk, TOKEN_DIV_ASSIGN); SET_TOKEN_TYPE (awk, TOKEN_DIV_ASSIGN);
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
@ -2803,11 +2803,11 @@ static int __get_token (xp_awk_t* awk)
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
} }
} }
else if (c == XP_CHAR('%')) else if (c == XP_T('%'))
{ {
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
if (c == XP_CHAR('=')) if (c == XP_T('='))
{ {
SET_TOKEN_TYPE (awk, TOKEN_MOD_ASSIGN); SET_TOKEN_TYPE (awk, TOKEN_MOD_ASSIGN);
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
@ -2819,73 +2819,73 @@ static int __get_token (xp_awk_t* awk)
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
} }
} }
else if (c == XP_CHAR('(')) else if (c == XP_T('('))
{ {
SET_TOKEN_TYPE (awk, TOKEN_LPAREN); SET_TOKEN_TYPE (awk, TOKEN_LPAREN);
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else if (c == XP_CHAR(')')) else if (c == XP_T(')'))
{ {
SET_TOKEN_TYPE (awk, TOKEN_RPAREN); SET_TOKEN_TYPE (awk, TOKEN_RPAREN);
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else if (c == XP_CHAR('{')) else if (c == XP_T('{'))
{ {
SET_TOKEN_TYPE (awk, TOKEN_LBRACE); SET_TOKEN_TYPE (awk, TOKEN_LBRACE);
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else if (c == XP_CHAR('}')) else if (c == XP_T('}'))
{ {
SET_TOKEN_TYPE (awk, TOKEN_RBRACE); SET_TOKEN_TYPE (awk, TOKEN_RBRACE);
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else if (c == XP_CHAR('[')) else if (c == XP_T('['))
{ {
SET_TOKEN_TYPE (awk, TOKEN_LBRACK); SET_TOKEN_TYPE (awk, TOKEN_LBRACK);
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else if (c == XP_CHAR(']')) else if (c == XP_T(']'))
{ {
SET_TOKEN_TYPE (awk, TOKEN_RBRACK); SET_TOKEN_TYPE (awk, TOKEN_RBRACK);
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else if (c == XP_CHAR('$')) else if (c == XP_T('$'))
{ {
SET_TOKEN_TYPE (awk, TOKEN_DOLLAR); SET_TOKEN_TYPE (awk, TOKEN_DOLLAR);
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else if (c == XP_CHAR(',')) else if (c == XP_T(','))
{ {
SET_TOKEN_TYPE (awk, TOKEN_COMMA); SET_TOKEN_TYPE (awk, TOKEN_COMMA);
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else if (c == XP_CHAR('.')) else if (c == XP_T('.'))
{ {
SET_TOKEN_TYPE (awk, TOKEN_PERIOD); SET_TOKEN_TYPE (awk, TOKEN_PERIOD);
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else if (c == XP_CHAR(';')) else if (c == XP_T(';'))
{ {
SET_TOKEN_TYPE (awk, TOKEN_SEMICOLON); SET_TOKEN_TYPE (awk, TOKEN_SEMICOLON);
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else if (c == XP_CHAR(':')) else if (c == XP_T(':'))
{ {
SET_TOKEN_TYPE (awk, TOKEN_COLON); SET_TOKEN_TYPE (awk, TOKEN_COLON);
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
else if (c == XP_CHAR('?')) else if (c == XP_T('?'))
{ {
SET_TOKEN_TYPE (awk, TOKEN_QUEST); SET_TOKEN_TYPE (awk, TOKEN_QUEST);
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
@ -2897,7 +2897,7 @@ static int __get_token (xp_awk_t* awk)
return -1; return -1;
} }
xp_printf (XP_TEXT("token -> [%s]\n"), XP_STR_BUF(&awk->token.name)); xp_printf (XP_T("token -> [%s]\n"), XP_STR_BUF(&awk->token.name));
return 0; return 0;
} }
@ -2910,12 +2910,12 @@ static int __get_number (xp_awk_t* awk)
c = awk->lex.curc; c = awk->lex.curc;
if (c == XP_CHAR('0')) if (c == XP_T('0'))
{ {
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
if (c == XP_CHAR('x') || c == XP_CHAR('X')) if (c == XP_T('x') || c == XP_T('X'))
{ {
/* hexadecimal number */ /* hexadecimal number */
do do
@ -2927,7 +2927,7 @@ static int __get_number (xp_awk_t* awk)
return 0; return 0;
} }
else if (c == XP_CHAR('b') || c == XP_CHAR('B')) else if (c == XP_T('b') || c == XP_T('B'))
{ {
/* binary number */ /* binary number */
do do
@ -2935,14 +2935,14 @@ static int __get_number (xp_awk_t* awk)
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
while (c == XP_CHAR('0') || c == XP_CHAR('1')); while (c == XP_T('0') || c == XP_T('1'));
return 0; return 0;
} }
else if (c != '.') else if (c != '.')
{ {
/* octal number */ /* octal number */
while (c >= XP_CHAR('0') && c <= XP_CHAR('7')) while (c >= XP_T('0') && c <= XP_T('7'))
{ {
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
@ -2958,7 +2958,7 @@ static int __get_number (xp_awk_t* awk)
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
} }
if (c == XP_CHAR('.')) if (c == XP_T('.'))
{ {
/* floating-point number */ /* floating-point number */
SET_TOKEN_TYPE (awk, TOKEN_REAL); SET_TOKEN_TYPE (awk, TOKEN_REAL);
@ -2973,14 +2973,14 @@ static int __get_number (xp_awk_t* awk)
} }
} }
if (c == XP_CHAR('E') || c == XP_CHAR('e')) if (c == XP_T('E') || c == XP_T('e'))
{ {
SET_TOKEN_TYPE (awk, TOKEN_REAL); SET_TOKEN_TYPE (awk, TOKEN_REAL);
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
if (c == XP_CHAR('+') || c == XP_CHAR('-')) if (c == XP_T('+') || c == XP_T('-'))
{ {
ADD_TOKEN_CHAR (awk, c); ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
@ -3010,13 +3010,13 @@ static int __get_string (xp_awk_t* awk)
return -1; return -1;
} }
if (escaped == xp_false && c == XP_CHAR('\"')) if (escaped == xp_false && c == XP_T('\"'))
{ {
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
break; break;
} }
if (escaped == xp_false && c == XP_CHAR('\\')) if (escaped == xp_false && c == XP_T('\\'))
{ {
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
escaped = xp_true; escaped = xp_true;
@ -3025,9 +3025,9 @@ static int __get_string (xp_awk_t* awk)
if (escaped == xp_true) if (escaped == xp_true)
{ {
if (c == XP_CHAR('n')) c = XP_CHAR('\n'); if (c == XP_T('n')) c = XP_T('\n');
else if (c == XP_CHAR('r')) c = XP_CHAR('\r'); else if (c == XP_T('r')) c = XP_T('\r');
else if (c == XP_CHAR('t')) c = XP_CHAR('\t'); else if (c == XP_T('t')) c = XP_T('\t');
/* TODO: more escape characters */ /* TODO: more escape characters */
escaped = xp_false; escaped = xp_false;
} }
@ -3056,13 +3056,13 @@ static int __get_regex (xp_awk_t* awk)
return -1; return -1;
} }
if (escaped == xp_false && c == XP_CHAR('/')) if (escaped == xp_false && c == XP_T('/'))
{ {
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
break; break;
} }
if (escaped == xp_false && c == XP_CHAR('\\')) if (escaped == xp_false && c == XP_T('\\'))
{ {
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
escaped = xp_true; escaped = xp_true;
@ -3071,9 +3071,9 @@ static int __get_regex (xp_awk_t* awk)
if (escaped == xp_true) if (escaped == xp_true)
{ {
if (c == XP_CHAR('n')) c = XP_CHAR('\n'); if (c == XP_T('n')) c = XP_T('\n');
else if (c == XP_CHAR('r')) c = XP_CHAR('\r'); else if (c == XP_T('r')) c = XP_T('\r');
else if (c == XP_CHAR('t')) c = XP_CHAR('\t'); else if (c == XP_T('t')) c = XP_T('\t');
/* TODO: more escape characters */ /* TODO: more escape characters */
escaped = xp_false; escaped = xp_false;
} }
@ -3130,7 +3130,7 @@ static int __skip_comment (xp_awk_t* awk)
{ {
xp_cint_t c = awk->lex.curc; xp_cint_t c = awk->lex.curc;
if ((awk->opt.parse & XP_AWK_HASHSIGN) && c == XP_CHAR('#')) if ((awk->opt.parse & XP_AWK_HASHSIGN) && c == XP_T('#'))
{ {
do do
{ {
@ -3142,10 +3142,10 @@ static int __skip_comment (xp_awk_t* awk)
return 1; /* comment by # */ return 1; /* comment by # */
} }
if (c != XP_CHAR('/')) return 0; /* not a comment */ if (c != XP_T('/')) return 0; /* not a comment */
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
if ((awk->opt.parse & XP_AWK_DBLSLASHES) && c == XP_CHAR('/')) if ((awk->opt.parse & XP_AWK_DBLSLASHES) && c == XP_T('/'))
{ {
do do
{ {
@ -3156,15 +3156,15 @@ static int __skip_comment (xp_awk_t* awk)
GET_CHAR (awk); GET_CHAR (awk);
return 1; /* comment by // */ return 1; /* comment by // */
} }
else if (c == XP_CHAR('*')) else if (c == XP_T('*'))
{ {
do do
{ {
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
if (c == XP_CHAR('*')) if (c == XP_T('*'))
{ {
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
if (c == XP_CHAR('/')) if (c == XP_T('/'))
{ {
GET_CHAR_TO (awk, c); GET_CHAR_TO (awk, c);
break; break;
@ -3177,7 +3177,7 @@ static int __skip_comment (xp_awk_t* awk)
} }
if (__unget_char(awk,c) == -1) return -1; /* error */ if (__unget_char(awk,c) == -1) return -1; /* error */
awk->lex.curc = XP_CHAR('/'); awk->lex.curc = XP_T('/');
return 0; return 0;
} }

88
ase/awk/run.c
View File

@ -1,5 +1,5 @@
/* /*
* $Id: run.c,v 1.85 2006-05-04 15:59:43 bacon Exp $ * $Id: run.c,v 1.86 2006-05-06 12:52:36 bacon Exp $
*/ */
#include <xp/awk/awk_i.h> #include <xp/awk/awk_i.h>
@ -148,9 +148,9 @@ typedef xp_awk_val_t* (*eval_expr_t) (xp_awk_run_t* run, xp_awk_nde_t* nde);
/* TODO: remove this function */ /* TODO: remove this function */
static int __printval (xp_awk_pair_t* pair, void* arg) static int __printval (xp_awk_pair_t* pair, void* arg)
{ {
xp_printf (XP_TEXT("%s = "), (const xp_char_t*)pair->key); xp_printf (XP_T("%s = "), (const xp_char_t*)pair->key);
xp_awk_printval ((xp_awk_val_t*)pair->val); xp_awk_printval ((xp_awk_val_t*)pair->val);
xp_printf (XP_TEXT("\n")); xp_printf (XP_T("\n"));
return 0; return 0;
} }
@ -294,11 +294,11 @@ static int __run_main (xp_awk_run_t* run)
/* TODO: should the main function be user-specifiable? */ /* TODO: should the main function be user-specifiable? */
static xp_char_t m_a_i_n[] = static xp_char_t m_a_i_n[] =
{ {
XP_CHAR('m'), XP_T('m'),
XP_CHAR('a'), XP_T('a'),
XP_CHAR('i'), XP_T('i'),
XP_CHAR('n'), XP_T('n'),
XP_CHAR('\0') XP_T('\0')
}; };
static xp_awk_nde_call_t nde = static xp_awk_nde_call_t nde =
{ {
@ -395,9 +395,9 @@ static int __run_main (xp_awk_run_t* run)
} }
v = STACK_RETVAL(run); v = STACK_RETVAL(run);
xp_printf (XP_TEXT("Return Value - ")); xp_printf (XP_T("Return Value - "));
xp_awk_printval (v); xp_awk_printval (v);
xp_printf (XP_TEXT("\n")); xp_printf (XP_T("\n"));
/* the life of the global return value is over here /* the life of the global return value is over here
* unlike the return value of each function */ * unlike the return value of each function */
/*xp_awk_refdownval_nofree (awk, v);*/ /*xp_awk_refdownval_nofree (awk, v);*/
@ -421,9 +421,9 @@ xp_printf (XP_TEXT("\n"));
/* just reset the exit level */ /* just reset the exit level */
run->exit_level = EXIT_NONE; run->exit_level = EXIT_NONE;
xp_printf (XP_TEXT("-[VARIABLES]------------------------\n")); xp_printf (XP_T("-[VARIABLES]------------------------\n"));
xp_awk_map_walk (&run->named, __printval, XP_NULL); xp_awk_map_walk (&run->named, __printval, XP_NULL);
xp_printf (XP_TEXT("-[END VARIABLES]--------------------------\n")); xp_printf (XP_T("-[END VARIABLES]--------------------------\n"));
return n; return n;
} }
@ -464,7 +464,7 @@ static int __run_pattern_blocks (xp_awk_run_t* run)
/* for each block { run it } /* for each block { run it }
* handle according if next and nextfile has been called * handle according if next and nextfile has been called
*/ */
xp_printf (XP_TEXT("**** line [%s]\n"), XP_STR_BUF(&run->input.line)); xp_printf (XP_T("**** line [%s]\n"), XP_STR_BUF(&run->input.line));
} }
n = run->txtio (XP_AWK_INPUT_CLOSE, run->txtio_arg, XP_NULL, 0); n = run->txtio (XP_AWK_INPUT_CLOSE, run->txtio_arg, XP_NULL, 0);
@ -485,7 +485,7 @@ static int __run_block (xp_awk_run_t* run, xp_awk_nde_blk_t* nde)
p = nde->body; p = nde->body;
nlocals = nde->nlocals; nlocals = nde->nlocals;
/*xp_printf (XP_TEXT("securing space for local variables nlocals = %d\n"), nlocals);*/ /*xp_printf (XP_T("securing space for local variables nlocals = %d\n"), nlocals);*/
saved_stack_top = run->stack_top; saved_stack_top = run->stack_top;
/* secure space for local variables */ /* secure space for local variables */
@ -502,10 +502,10 @@ static int __run_block (xp_awk_run_t* run, xp_awk_nde_blk_t* nde)
/* refupval is not required for xp_awk_val_nil */ /* refupval is not required for xp_awk_val_nil */
} }
/*xp_printf (XP_TEXT("executing block statements\n"));*/ /*xp_printf (XP_T("executing block statements\n"));*/
while (p != XP_NULL && run->exit_level == EXIT_NONE) while (p != XP_NULL && run->exit_level == EXIT_NONE)
{ {
/*xp_printf (XP_TEXT("running a statement\n"));*/ /*xp_printf (XP_T("running a statement\n"));*/
if (__run_statement(run,p) == -1) if (__run_statement(run,p) == -1)
{ {
n = -1; n = -1;
@ -514,7 +514,7 @@ static int __run_block (xp_awk_run_t* run, xp_awk_nde_blk_t* nde)
p = p->next; p = p->next;
} }
/*xp_printf (XP_TEXT("popping off local variables\n"));*/ /*xp_printf (XP_T("popping off local variables\n"));*/
/* pop off local variables */ /* pop off local variables */
nlocals = nde->nlocals; nlocals = nde->nlocals;
while (nlocals > 0) while (nlocals > 0)
@ -852,7 +852,7 @@ static int __run_return_statement (xp_awk_run_t* run, xp_awk_nde_return_t* nde)
if (nde->val != XP_NULL) if (nde->val != XP_NULL)
{ {
xp_awk_val_t* val; xp_awk_val_t* val;
/*xp_printf (XP_TEXT("returning....\n"));*/ /*xp_printf (XP_T("returning....\n"));*/
val = __eval_expression(run, nde->val); val = __eval_expression(run, nde->val);
if (val == XP_NULL) return -1; if (val == XP_NULL) return -1;
@ -860,7 +860,7 @@ static int __run_return_statement (xp_awk_run_t* run, xp_awk_nde_return_t* nde)
STACK_RETVAL(run) = val; STACK_RETVAL(run) = val;
xp_awk_refupval (val); /* see __eval_call for the trick */ xp_awk_refupval (val); /* see __eval_call for the trick */
/*xp_printf (XP_TEXT("set return value....\n"));*/ /*xp_printf (XP_T("set return value....\n"));*/
} }
run->exit_level = EXIT_FUNCTION; run->exit_level = EXIT_FUNCTION;
@ -889,7 +889,7 @@ static int __run_exit_statement (xp_awk_run_t* run, xp_awk_nde_exit_t* nde)
static int __run_next_statement (xp_awk_run_t* run, xp_awk_nde_next_t* nde) static int __run_next_statement (xp_awk_run_t* run, xp_awk_nde_next_t* nde)
{ {
/* TODO */ /* TODO */
xp_printf (XP_TEXT("**** next NOT IMPLEMENTED...\n")); xp_printf (XP_T("**** next NOT IMPLEMENTED...\n"));
return -1; return -1;
} }
@ -1070,7 +1070,7 @@ static xp_awk_val_t* __do_assignment (
else if (var->type == XP_AWK_NDE_POS) else if (var->type == XP_AWK_NDE_POS)
{ {
/* TODO: */ /* TODO: */
xp_printf (XP_TEXT("XP_AWK_NDE_POS not implemented\n")); xp_printf (XP_T("XP_AWK_NDE_POS not implemented\n"));
PANIC (run, XP_AWK_EINTERNAL); PANIC (run, XP_AWK_EINTERNAL);
} }
else else
@ -1164,7 +1164,7 @@ static xp_awk_val_t* __do_assignment_map (
if (str == XP_NULL) return XP_NULL; if (str == XP_NULL) return XP_NULL;
/* /*
xp_printf (XP_TEXT("**** index str=>%s, map->ref=%d, map->type=%d\n"), str, map->ref, map->type); xp_printf (XP_T("**** index str=>%s, map->ref=%d, map->type=%d\n"), str, map->ref, map->type);
*/ */
n = xp_awk_map_putx (map->map, str, val, XP_NULL); n = xp_awk_map_putx (map->map, str, val, XP_NULL);
if (n < 0) if (n < 0)
@ -2023,7 +2023,7 @@ static xp_awk_val_t* __eval_binop_ma (
xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right) xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
{ {
/* TODO: ... */ /* TODO: ... */
xp_printf (XP_TEXT("eval_binop_ma not implemented yet...\n")); xp_printf (XP_T("eval_binop_ma not implemented yet...\n"));
PANIC (run, XP_AWK_EINTERNAL); PANIC (run, XP_AWK_EINTERNAL);
return XP_NULL; return XP_NULL;
} }
@ -2371,7 +2371,7 @@ static xp_awk_val_t* __eval_call (xp_awk_run_t* run, xp_awk_nde_t* nde)
xp_awk_nde_call_t* call = (xp_awk_nde_call_t*)nde; xp_awk_nde_call_t* call = (xp_awk_nde_call_t*)nde;
int n; int n;
/*xp_printf (XP_TEXT(".....__eval_call\n"));*/ /*xp_printf (XP_T(".....__eval_call\n"));*/
pair = xp_awk_map_get (&run->tree->funcs, call->name); pair = xp_awk_map_get (&run->tree->funcs, call->name);
if (pair == XP_NULL) PANIC (run, XP_AWK_ENOSUCHFUNC); if (pair == XP_NULL) PANIC (run, XP_AWK_ENOSUCHFUNC);
@ -2429,7 +2429,7 @@ static xp_awk_val_t* __eval_call (xp_awk_run_t* run, xp_awk_nde_t* nde)
saved_stack_top = run->stack_top; saved_stack_top = run->stack_top;
/*xp_printf (XP_TEXT("setting up function stack frame stack_top = %ld stack_base = %ld\n"), run->stack_top, run->stack_base); */ /*xp_printf (XP_T("setting up function stack frame stack_top = %ld stack_base = %ld\n"), run->stack_top, run->stack_base); */
if (__raw_push(run,(void*)run->stack_base) == -1) if (__raw_push(run,(void*)run->stack_base) == -1)
{ {
PANIC (run, XP_AWK_ENOMEM); PANIC (run, XP_AWK_ENOMEM);
@ -2533,21 +2533,21 @@ static xp_awk_val_t* __eval_call (xp_awk_run_t* run, xp_awk_nde_t* nde)
run->stack_base = saved_stack_top; run->stack_base = saved_stack_top;
STACK_NARGS(run) = (void*)nargs; STACK_NARGS(run) = (void*)nargs;
/*xp_printf (XP_TEXT("running function body\n")); */ /*xp_printf (XP_T("running function body\n")); */
xp_assert (func->body->type == XP_AWK_NDE_BLK); xp_assert (func->body->type == XP_AWK_NDE_BLK);
n = __run_block(run,(xp_awk_nde_blk_t*)func->body); n = __run_block(run,(xp_awk_nde_blk_t*)func->body);
/*xp_printf (XP_TEXT("block run complete\n")); */ /*xp_printf (XP_T("block run complete\n")); */
/* refdown args in the run.stack */ /* refdown args in the run.stack */
nargs = (xp_size_t)STACK_NARGS(run); nargs = (xp_size_t)STACK_NARGS(run);
/*xp_printf (XP_TEXT("block run complete nargs = %d\n"), nargs); */ /*xp_printf (XP_T("block run complete nargs = %d\n"), nargs); */
for (i = 0; i < nargs; i++) for (i = 0; i < nargs; i++)
{ {
xp_awk_refdownval (run, STACK_ARG(run,i)); xp_awk_refdownval (run, STACK_ARG(run,i));
} }
/*xp_printf (XP_TEXT("got return value\n")); */ /*xp_printf (XP_T("got return value\n")); */
/* this is the trick mentioned in __run_return_statement. /* this is the trick mentioned in __run_return_statement.
* adjust the reference count of the return value. * adjust the reference count of the return value.
@ -2565,7 +2565,7 @@ static xp_awk_val_t* __eval_call (xp_awk_run_t* run, xp_awk_nde_t* nde)
run->exit_level = EXIT_NONE; run->exit_level = EXIT_NONE;
} }
/*xp_printf (XP_TEXT("returning from function stack_top=%ld, stack_base=%ld\n"), run->stack_top, run->stack_base); */ /*xp_printf (XP_T("returning from function stack_top=%ld, stack_base=%ld\n"), run->stack_top, run->stack_base); */
return (n == -1)? XP_NULL: v; return (n == -1)? XP_NULL: v;
} }
@ -2600,7 +2600,7 @@ static xp_awk_val_t* __eval_str (xp_awk_run_t* run, xp_awk_nde_t* nde)
static xp_awk_val_t* __eval_rex (xp_awk_run_t* run, xp_awk_nde_t* nde) static xp_awk_val_t* __eval_rex (xp_awk_run_t* run, xp_awk_nde_t* nde)
{ {
/* TODO */ /* TODO */
xp_printf (XP_TEXT("eval_rex not implemented yet...\n")); xp_printf (XP_T("eval_rex not implemented yet...\n"));
PANIC (run, XP_AWK_EINTERNAL); PANIC (run, XP_AWK_EINTERNAL);
return XP_NULL; return XP_NULL;
} }
@ -2689,7 +2689,7 @@ static xp_awk_val_t* __eval_argidx (xp_awk_run_t* run, xp_awk_nde_t* nde)
static xp_awk_val_t* __eval_pos (xp_awk_run_t* run, xp_awk_nde_t* nde) static xp_awk_val_t* __eval_pos (xp_awk_run_t* run, xp_awk_nde_t* nde)
{ {
/* TODO: */ /* TODO: */
xp_printf (XP_TEXT("eval_pos not competed....\n")); xp_printf (XP_T("eval_pos not competed....\n"));
return XP_NULL; return XP_NULL;
} }
@ -2763,7 +2763,7 @@ static int __read_text_input (xp_awk_run_t* run)
/* TODO: use LF instead of this hard coded value */ /* TODO: use LF instead of this hard coded value */
/* any better way to tell line terminating with newlines? /* any better way to tell line terminating with newlines?
* line with new line characters removed or retained? */ * line with new line characters removed or retained? */
if (c == XP_CHAR('\n')) break; if (c == XP_T('\n')) break;
} }
return 1; return 1;
@ -2796,9 +2796,9 @@ static int __val_to_num (xp_awk_val_t* v, xp_long_t* l, xp_real_t* r)
/* don't care about val->len */ /* don't care about val->len */
*l = xp_awk_strtolong (((xp_awk_val_str_t*)v)->buf, 0, &endptr); *l = xp_awk_strtolong (((xp_awk_val_str_t*)v)->buf, 0, &endptr);
if (*endptr == XP_CHAR('.') || if (*endptr == XP_T('.') ||
*endptr == XP_CHAR('E') || *endptr == XP_T('E') ||
*endptr == XP_CHAR('e')) *endptr == XP_T('e'))
{ {
*r = xp_awk_strtoreal (((xp_awk_val_str_t*)v)->buf); *r = xp_awk_strtoreal (((xp_awk_val_str_t*)v)->buf);
return 1; /* real */ return 1; /* real */
@ -2831,13 +2831,13 @@ static xp_char_t* __val_to_str (xp_awk_val_t* v, int* errnum, xp_str_t* buf)
return XP_NULL; return XP_NULL;
} }
tmp[0] = XP_CHAR('0'); tmp[0] = XP_T('0');
tmp[1] = XP_CHAR('\0'); tmp[1] = XP_T('\0');
return tmp; return tmp;
} }
else else
{ {
if (xp_str_cat (buf, XP_TEXT("0")) == (xp_size_t)-1) if (xp_str_cat (buf, XP_T("0")) == (xp_size_t)-1)
{ {
*errnum = XP_AWK_ENOMEM; *errnum = XP_AWK_ENOMEM;
return XP_NULL; return XP_NULL;
@ -2860,7 +2860,7 @@ static xp_char_t* __val_to_str (xp_awk_val_t* v, int* errnum, xp_str_t* buf)
return XP_NULL; return XP_NULL;
} }
tmp[len] = XP_CHAR('\0'); tmp[len] = XP_T('\0');
} }
else else
{ {
@ -2869,7 +2869,7 @@ static xp_char_t* __val_to_str (xp_awk_val_t* v, int* errnum, xp_str_t* buf)
/* extend the buffer */ /* extend the buffer */
if (xp_str_nccat ( if (xp_str_nccat (
buf, XP_CHAR(' '), len) == (xp_size_t)-1) buf, XP_T(' '), len) == (xp_size_t)-1)
{ {
*errnum = XP_AWK_ENOMEM; *errnum = XP_AWK_ENOMEM;
return XP_NULL; return XP_NULL;
@ -2881,11 +2881,11 @@ static xp_char_t* __val_to_str (xp_awk_val_t* v, int* errnum, xp_str_t* buf)
while (t > 0) while (t > 0)
{ {
tmp[--len] = (xp_char_t)(t % 10) + XP_CHAR('0'); tmp[--len] = (xp_char_t)(t % 10) + XP_T('0');
t /= 10; t /= 10;
} }
if (((xp_awk_val_int_t*)v)->val < 0) tmp[--len] = XP_CHAR('-'); if (((xp_awk_val_int_t*)v)->val < 0) tmp[--len] = XP_T('-');
/*return (buf == XP_NULL) tmp: XP_STR_BUF(buf);*/ /*return (buf == XP_NULL) tmp: XP_STR_BUF(buf);*/
return tmp; return tmp;
@ -2974,7 +2974,7 @@ static xp_char_t* __idxnde_to_str (xp_awk_run_t* run, xp_awk_nde_t* nde)
/* TODO: configurable index seperator */ /* TODO: configurable index seperator */
if (XP_STR_LEN(&idxstr) > 0 && if (XP_STR_LEN(&idxstr) > 0 &&
xp_str_cat (&idxstr, XP_TEXT(",")) == (xp_size_t)-1) xp_str_cat (&idxstr, XP_T(",")) == (xp_size_t)-1)
{ {
xp_awk_refdownval (run, idx); xp_awk_refdownval (run, idx);
xp_str_close (&idxstr); xp_str_close (&idxstr);

56
ase/awk/sa.c
View File

@ -1,5 +1,5 @@
/* /*
* $Id: sa.c,v 1.20 2006-05-04 15:59:43 bacon Exp $ * $Id: sa.c,v 1.21 2006-05-06 12:52:36 bacon Exp $
*/ */
#include <xp/awk/awk_i.h> #include <xp/awk/awk_i.h>
@ -11,7 +11,7 @@ static xp_char_t* __adjust_format (const xp_char_t* format);
xp_size_t xp_strlen (const xp_char_t* str) xp_size_t xp_strlen (const xp_char_t* str)
{ {
const xp_char_t* p = str; const xp_char_t* p = str;
while (*p != XP_CHAR('\0')) p++; while (*p != XP_T('\0')) p++;
return p - str; return p - str;
} }
@ -56,7 +56,7 @@ xp_char_t* xp_strxdup2 (
xp_size_t xp_strcpy (xp_char_t* buf, const xp_char_t* str) xp_size_t xp_strcpy (xp_char_t* buf, const xp_char_t* str)
{ {
xp_char_t* org = buf; xp_char_t* org = buf;
while ((*buf++ = *str++) != XP_CHAR('\0')); while ((*buf++ = *str++) != XP_T('\0'));
return buf - org - 1; return buf - org - 1;
} }
@ -64,13 +64,13 @@ xp_size_t xp_strncpy (xp_char_t* buf, const xp_char_t* str, xp_size_t len)
{ {
const xp_char_t* end = str + len; const xp_char_t* end = str + len;
while (str < end) *buf++ = *str++; while (str < end) *buf++ = *str++;
*buf = XP_CHAR('\0'); *buf = XP_T('\0');
return len; return len;
} }
int xp_strcmp (const xp_char_t* s1, const xp_char_t* s2) int xp_strcmp (const xp_char_t* s1, const xp_char_t* s2)
{ {
while (*s1 == *s2 && *s2 != XP_CHAR('\0')) s1++, s2++; while (*s1 == *s2 && *s2 != XP_T('\0')) s1++, s2++;
if (*s1 > *s2) return 1; if (*s1 > *s2) return 1;
else if (*s1 < *s2) return -1; else if (*s1 < *s2) return -1;
return 0; return 0;
@ -165,7 +165,7 @@ xp_str_t* xp_str_open (xp_str_t* str, xp_size_t capa)
str->size = 0; str->size = 0;
str->capa = capa; str->capa = capa;
str->buf[0] = XP_CHAR('\0'); str->buf[0] = XP_T('\0');
return str; return str;
} }
@ -191,7 +191,7 @@ static xp_size_t __strncpy (xp_char_t* buf, const xp_char_t* str, xp_size_t len)
{ {
const xp_char_t* end = str + len; const xp_char_t* end = str + len;
while (str < end) *buf++ = *str++; while (str < end) *buf++ = *str++;
*buf = XP_CHAR('\0'); *buf = XP_T('\0');
return len; return len;
} }
@ -216,7 +216,7 @@ xp_size_t xp_str_ncat (xp_str_t* str, const xp_char_t* s, xp_size_t len)
} }
str->size += __strncpy (&str->buf[str->size], s, len); str->size += __strncpy (&str->buf[str->size], s, len);
str->buf[str->size] = XP_CHAR('\0'); str->buf[str->size] = XP_T('\0');
return str->size; return str->size;
} }
@ -242,7 +242,7 @@ xp_size_t xp_str_nccat (xp_str_t* str, xp_char_t c, xp_size_t len)
void xp_str_clear (xp_str_t* str) void xp_str_clear (xp_str_t* str)
{ {
str->size = 0; str->size = 0;
str->buf[0] = XP_CHAR('\0'); str->buf[0] = XP_T('\0');
} }
@ -268,15 +268,15 @@ static xp_char_t* __adjust_format (const xp_char_t* format)
if (xp_str_open (&str, 256) == XP_NULL) return XP_NULL; if (xp_str_open (&str, 256) == XP_NULL) return XP_NULL;
while (*fp != XP_CHAR('\0')) while (*fp != XP_T('\0'))
{ {
while (*fp != XP_CHAR('\0') && *fp != XP_CHAR('%')) while (*fp != XP_T('\0') && *fp != XP_T('%'))
{ {
ADDC (str, *fp++); ADDC (str, *fp++);
} }
if (*fp == XP_CHAR('\0')) break; if (*fp == XP_T('\0')) break;
xp_assert (*fp == XP_CHAR('%')); xp_assert (*fp == XP_T('%'));
ch = *fp++; ch = *fp++;
ADDC (str, ch); /* add % */ ADDC (str, ch); /* add % */
@ -286,12 +286,12 @@ static xp_char_t* __adjust_format (const xp_char_t* format)
/* flags */ /* flags */
for (;;) for (;;)
{ {
if (ch == XP_CHAR(' ') || ch == XP_CHAR('+') || if (ch == XP_T(' ') || ch == XP_T('+') ||
ch == XP_CHAR('-') || ch == XP_CHAR('#')) ch == XP_T('-') || ch == XP_T('#'))
{ {
ADDC (str, ch); ADDC (str, ch);
} }
else if (ch == XP_CHAR('0')) else if (ch == XP_T('0'))
{ {
ADDC (str, ch); ADDC (str, ch);
ch = *fp++; ch = *fp++;
@ -303,7 +303,7 @@ static xp_char_t* __adjust_format (const xp_char_t* format)
} }
/* check the width */ /* check the width */
if (ch == XP_CHAR('*')) ADDC (str, ch); if (ch == XP_T('*')) ADDC (str, ch);
else else
{ {
while (xp_isdigit(ch)) while (xp_isdigit(ch))
@ -314,12 +314,12 @@ static xp_char_t* __adjust_format (const xp_char_t* format)
} }
/* precision */ /* precision */
if (ch == XP_CHAR('.')) if (ch == XP_T('.'))
{ {
ADDC (str, ch); ADDC (str, ch);
ch = *fp++; ch = *fp++;
if (ch == XP_CHAR('*')) ADDC (str, ch); if (ch == XP_T('*')) ADDC (str, ch);
else else
{ {
while (xp_isdigit(ch)) while (xp_isdigit(ch))
@ -333,8 +333,8 @@ static xp_char_t* __adjust_format (const xp_char_t* format)
/* modifier */ /* modifier */
for (modifier = 0;;) for (modifier = 0;;)
{ {
if (ch == XP_CHAR('h')) modifier = MOD_SHORT; if (ch == XP_T('h')) modifier = MOD_SHORT;
else if (ch == XP_CHAR('l')) else if (ch == XP_T('l'))
{ {
modifier = (modifier == MOD_LONG)? MOD_LONGLONG: MOD_LONG; modifier = (modifier == MOD_LONG)? MOD_LONGLONG: MOD_LONG;
} }
@ -344,15 +344,15 @@ static xp_char_t* __adjust_format (const xp_char_t* format)
/* type */ /* type */
if (ch == XP_CHAR('%')) ADDC (str, ch); if (ch == XP_T('%')) ADDC (str, ch);
else if (ch == XP_CHAR('c') || ch == XP_CHAR('s')) else if (ch == XP_T('c') || ch == XP_T('s'))
{ {
#if !defined(XP_CHAR_IS_MCHAR) && !defined(_WIN32) #if !defined(XP_CHAR_IS_MCHAR) && !defined(_WIN32)
ADDC (str, 'l'); ADDC (str, 'l');
#endif #endif
ADDC (str, ch); ADDC (str, ch);
} }
else if (ch == XP_CHAR('C') || ch == XP_CHAR('S')) else if (ch == XP_T('C') || ch == XP_T('S'))
{ {
#ifdef _WIN32 #ifdef _WIN32
ADDC (str, ch); ADDC (str, ch);
@ -363,9 +363,9 @@ static xp_char_t* __adjust_format (const xp_char_t* format)
ADDC (str, xp_tolower(ch)); ADDC (str, xp_tolower(ch));
#endif #endif
} }
else if (ch == XP_CHAR('d') || ch == XP_CHAR('i') || else if (ch == XP_T('d') || ch == XP_T('i') ||
ch == XP_CHAR('o') || ch == XP_CHAR('u') || ch == XP_T('o') || ch == XP_T('u') ||
ch == XP_CHAR('x') || ch == XP_CHAR('X')) ch == XP_T('x') || ch == XP_T('X'))
{ {
if (modifier == MOD_SHORT) if (modifier == MOD_SHORT)
{ {
@ -388,7 +388,7 @@ static xp_char_t* __adjust_format (const xp_char_t* format)
} }
ADDC (str, ch); ADDC (str, ch);
} }
else if (ch == XP_CHAR('\0')) break; else if (ch == XP_T('\0')) break;
else ADDC (str, ch); else ADDC (str, ch);
} }

236
ase/awk/tree.c
View File

@ -1,5 +1,5 @@
/* /*
* $Id: tree.c,v 1.46 2006-05-02 15:43:11 bacon Exp $ * $Id: tree.c,v 1.47 2006-05-06 12:52:36 bacon Exp $
*/ */
#include <xp/awk/awk_i.h> #include <xp/awk/awk_i.h>
@ -12,60 +12,60 @@
static const xp_char_t* __assop_str[] = static const xp_char_t* __assop_str[] =
{ {
XP_TEXT("="), XP_T("="),
XP_TEXT("+="), XP_T("+="),
XP_TEXT("-="), XP_T("-="),
XP_TEXT("*="), XP_T("*="),
XP_TEXT("/="), XP_T("/="),
XP_TEXT("%="), XP_T("%="),
XP_TEXT("**=") XP_T("**=")
}; };
static const xp_char_t* __binop_str[] = static const xp_char_t* __binop_str[] =
{ {
XP_TEXT("||"), XP_T("||"),
XP_TEXT("&&"), XP_T("&&"),
XP_TEXT("in"), XP_T("in"),
XP_TEXT("|"), XP_T("|"),
XP_TEXT("^"), XP_T("^"),
XP_TEXT("&"), XP_T("&"),
XP_TEXT("=="), XP_T("=="),
XP_TEXT("!="), XP_T("!="),
XP_TEXT(">"), XP_T(">"),
XP_TEXT(">="), XP_T(">="),
XP_TEXT("<"), XP_T("<"),
XP_TEXT("<="), XP_T("<="),
XP_TEXT("<<"), XP_T("<<"),
XP_TEXT(">>"), XP_T(">>"),
XP_TEXT("+"), XP_T("+"),
XP_TEXT("-"), XP_T("-"),
XP_TEXT("*"), XP_T("*"),
XP_TEXT("/"), XP_T("/"),
XP_TEXT("%"), XP_T("%"),
XP_TEXT("**"), XP_T("**"),
XP_TEXT("~"), XP_T("~"),
XP_TEXT("!~") XP_T("!~")
}; };
static const xp_char_t* __unrop_str[] = static const xp_char_t* __unrop_str[] =
{ {
XP_TEXT("+"), XP_T("+"),
XP_TEXT("-"), XP_T("-"),
XP_TEXT("!"), XP_T("!"),
XP_TEXT("~") XP_T("~")
}; };
static const xp_char_t* __incop_str[] = static const xp_char_t* __incop_str[] =
{ {
XP_TEXT("++"), XP_T("++"),
XP_TEXT("--"), XP_T("--"),
XP_TEXT("++"), XP_T("++"),
XP_TEXT("--") XP_T("--")
}; };
static void __print_tabs (int depth); static void __print_tabs (int depth);
@ -76,7 +76,7 @@ static void __print_statements (xp_awk_nde_t* tree, int depth);
static void __print_tabs (int depth) static void __print_tabs (int depth)
{ {
int i; int i;
for (i = 0; i < depth; i++) xp_printf (XP_TEXT("\t")); for (i = 0; i < depth; i++) xp_printf (XP_T("\t"));
} }
static int __print_expression (xp_awk_nde_t* nde) static int __print_expression (xp_awk_nde_t* nde)
@ -87,149 +87,149 @@ static int __print_expression (xp_awk_nde_t* nde)
{ {
xp_awk_nde_t* p = ((xp_awk_nde_grp_t*)nde)->body; xp_awk_nde_t* p = ((xp_awk_nde_grp_t*)nde)->body;
xp_printf (XP_TEXT("(")); xp_printf (XP_T("("));
while (p != XP_NULL) { while (p != XP_NULL) {
__print_expression (p); __print_expression (p);
if (p->next != XP_NULL) xp_printf (XP_TEXT(",")); if (p->next != XP_NULL) xp_printf (XP_T(","));
p = p->next; p = p->next;
} }
xp_printf (XP_TEXT(")")); xp_printf (XP_T(")"));
} }
break; break;
case XP_AWK_NDE_ASS: case XP_AWK_NDE_ASS:
if (__print_expression (((xp_awk_nde_ass_t*)nde)->left) == -1) return -1; if (__print_expression (((xp_awk_nde_ass_t*)nde)->left) == -1) return -1;
xp_printf (XP_TEXT(" %s "), xp_printf (XP_T(" %s "),
__assop_str[((xp_awk_nde_exp_t*)nde)->opcode]); __assop_str[((xp_awk_nde_exp_t*)nde)->opcode]);
if (__print_expression (((xp_awk_nde_ass_t*)nde)->right) == -1) return -1; if (__print_expression (((xp_awk_nde_ass_t*)nde)->right) == -1) return -1;
xp_assert ((((xp_awk_nde_ass_t*)nde)->right)->next == XP_NULL); xp_assert ((((xp_awk_nde_ass_t*)nde)->right)->next == XP_NULL);
break; break;
case XP_AWK_NDE_EXP_BIN: case XP_AWK_NDE_EXP_BIN:
xp_printf (XP_TEXT("(")); xp_printf (XP_T("("));
if (__print_expression(((xp_awk_nde_exp_t*)nde)->left) == -1) if (__print_expression(((xp_awk_nde_exp_t*)nde)->left) == -1)
return -1; return -1;
xp_assert ((((xp_awk_nde_exp_t*)nde)->left)->next == XP_NULL); xp_assert ((((xp_awk_nde_exp_t*)nde)->left)->next == XP_NULL);
xp_printf (XP_TEXT(" %s "), xp_printf (XP_T(" %s "),
__binop_str[((xp_awk_nde_exp_t*)nde)->opcode]); __binop_str[((xp_awk_nde_exp_t*)nde)->opcode]);
if (((xp_awk_nde_exp_t*)nde)->right->type == XP_AWK_NDE_ASS) if (((xp_awk_nde_exp_t*)nde)->right->type == XP_AWK_NDE_ASS)
xp_printf (XP_TEXT("(")); xp_printf (XP_T("("));
if (__print_expression (((xp_awk_nde_exp_t*)nde)->right) == -1) if (__print_expression (((xp_awk_nde_exp_t*)nde)->right) == -1)
return -1; return -1;
if (((xp_awk_nde_exp_t*)nde)->right->type == XP_AWK_NDE_ASS) if (((xp_awk_nde_exp_t*)nde)->right->type == XP_AWK_NDE_ASS)
xp_printf (XP_TEXT(")")); xp_printf (XP_T(")"));
xp_assert ((((xp_awk_nde_exp_t*)nde)->right)->next == XP_NULL); xp_assert ((((xp_awk_nde_exp_t*)nde)->right)->next == XP_NULL);
xp_printf (XP_TEXT(")")); xp_printf (XP_T(")"));
break; break;
case XP_AWK_NDE_EXP_UNR: case XP_AWK_NDE_EXP_UNR:
xp_assert (((xp_awk_nde_exp_t*)nde)->right == XP_NULL); xp_assert (((xp_awk_nde_exp_t*)nde)->right == XP_NULL);
xp_printf (XP_TEXT("%s("), xp_printf (XP_T("%s("),
__unrop_str[((xp_awk_nde_exp_t*)nde)->opcode]); __unrop_str[((xp_awk_nde_exp_t*)nde)->opcode]);
if (__print_expression (((xp_awk_nde_exp_t*)nde)->left) == -1) if (__print_expression (((xp_awk_nde_exp_t*)nde)->left) == -1)
return -1; return -1;
xp_printf (XP_TEXT(")")); xp_printf (XP_T(")"));
break; break;
case XP_AWK_NDE_EXP_INCPRE: case XP_AWK_NDE_EXP_INCPRE:
xp_assert (((xp_awk_nde_exp_t*)nde)->right == XP_NULL); xp_assert (((xp_awk_nde_exp_t*)nde)->right == XP_NULL);
xp_printf (XP_TEXT("%s("), xp_printf (XP_T("%s("),
__incop_str[((xp_awk_nde_exp_t*)nde)->opcode]); __incop_str[((xp_awk_nde_exp_t*)nde)->opcode]);
if (__print_expression (((xp_awk_nde_exp_t*)nde)->left) == -1) if (__print_expression (((xp_awk_nde_exp_t*)nde)->left) == -1)
return -1; return -1;
xp_printf (XP_TEXT(")")); xp_printf (XP_T(")"));
break; break;
case XP_AWK_NDE_EXP_INCPST: case XP_AWK_NDE_EXP_INCPST:
xp_assert (((xp_awk_nde_exp_t*)nde)->right == XP_NULL); xp_assert (((xp_awk_nde_exp_t*)nde)->right == XP_NULL);
xp_printf (XP_TEXT("(")); xp_printf (XP_T("("));
if (__print_expression (((xp_awk_nde_exp_t*)nde)->left) == -1) if (__print_expression (((xp_awk_nde_exp_t*)nde)->left) == -1)
return -1; return -1;
xp_printf (XP_TEXT(")%s"), xp_printf (XP_T(")%s"),
__incop_str[((xp_awk_nde_exp_t*)nde)->opcode]); __incop_str[((xp_awk_nde_exp_t*)nde)->opcode]);
break; break;
case XP_AWK_NDE_CND: case XP_AWK_NDE_CND:
xp_printf (XP_TEXT("(")); xp_printf (XP_T("("));
if (__print_expression(((xp_awk_nde_cnd_t*)nde)->test) == -1) if (__print_expression(((xp_awk_nde_cnd_t*)nde)->test) == -1)
return -1; return -1;
xp_printf (XP_TEXT(")?")); xp_printf (XP_T(")?"));
if (__print_expression(((xp_awk_nde_cnd_t*)nde)->left) == -1) if (__print_expression(((xp_awk_nde_cnd_t*)nde)->left) == -1)
return -1; return -1;
xp_printf (XP_TEXT(":")); xp_printf (XP_T(":"));
if (__print_expression(((xp_awk_nde_cnd_t*)nde)->right) == -1) if (__print_expression(((xp_awk_nde_cnd_t*)nde)->right) == -1)
return -1; return -1;
break; break;
case XP_AWK_NDE_INT: case XP_AWK_NDE_INT:
#if defined(__LCC__) #if defined(__LCC__)
xp_printf (XP_TEXT("%lld"), (long long)((xp_awk_nde_int_t*)nde)->val); xp_printf (XP_T("%lld"), (long long)((xp_awk_nde_int_t*)nde)->val);
#elif defined(__BORLANDC__) || defined(_MSC_VER) #elif defined(__BORLANDC__) || defined(_MSC_VER)
xp_printf (XP_TEXT("%I64d"), (__int64)((xp_awk_nde_int_t*)nde)->val); xp_printf (XP_T("%I64d"), (__int64)((xp_awk_nde_int_t*)nde)->val);
#elif defined(vax) || defined(__vax) || defined(_SCO_DS) #elif defined(vax) || defined(__vax) || defined(_SCO_DS)
xp_printf (XP_TEXT("%ld"), (long)((xp_awk_nde_int_t*)nde)->val); xp_printf (XP_T("%ld"), (long)((xp_awk_nde_int_t*)nde)->val);
#else #else
xp_printf (XP_TEXT("%lld"), (long long)((xp_awk_nde_int_t*)nde)->val); xp_printf (XP_T("%lld"), (long long)((xp_awk_nde_int_t*)nde)->val);
#endif #endif
break; break;
case XP_AWK_NDE_REAL: case XP_AWK_NDE_REAL:
xp_printf (XP_TEXT("%Lf"), (long double)((xp_awk_nde_real_t*)nde)->val); xp_printf (XP_T("%Lf"), (long double)((xp_awk_nde_real_t*)nde)->val);
break; break;
case XP_AWK_NDE_STR: case XP_AWK_NDE_STR:
/* TODO: buf, len */ /* TODO: buf, len */
xp_printf (XP_TEXT("\"%s\""), ((xp_awk_nde_str_t*)nde)->buf); xp_printf (XP_T("\"%s\""), ((xp_awk_nde_str_t*)nde)->buf);
break; break;
case XP_AWK_NDE_REX: case XP_AWK_NDE_REX:
/* TODO: buf, len */ /* TODO: buf, len */
xp_printf (XP_TEXT("/%s/"), ((xp_awk_nde_rex_t*)nde)->buf); xp_printf (XP_T("/%s/"), ((xp_awk_nde_rex_t*)nde)->buf);
break; break;
case XP_AWK_NDE_ARG: case XP_AWK_NDE_ARG:
xp_assert (((xp_awk_nde_var_t*)nde)->id.idxa != (xp_size_t)-1); xp_assert (((xp_awk_nde_var_t*)nde)->id.idxa != (xp_size_t)-1);
xp_printf (XP_TEXT("__arg%lu"), xp_printf (XP_T("__arg%lu"),
(unsigned long)((xp_awk_nde_var_t*)nde)->id.idxa); (unsigned long)((xp_awk_nde_var_t*)nde)->id.idxa);
xp_assert (((xp_awk_nde_var_t*)nde)->idx == XP_NULL); xp_assert (((xp_awk_nde_var_t*)nde)->idx == XP_NULL);
break; break;
case XP_AWK_NDE_ARGIDX: case XP_AWK_NDE_ARGIDX:
xp_assert (((xp_awk_nde_var_t*)nde)->id.idxa != (xp_size_t)-1); xp_assert (((xp_awk_nde_var_t*)nde)->id.idxa != (xp_size_t)-1);
xp_printf (XP_TEXT("__arg%lu["), xp_printf (XP_T("__arg%lu["),
(unsigned long)((xp_awk_nde_var_t*)nde)->id.idxa); (unsigned long)((xp_awk_nde_var_t*)nde)->id.idxa);
xp_assert (((xp_awk_nde_var_t*)nde)->idx != XP_NULL); xp_assert (((xp_awk_nde_var_t*)nde)->idx != XP_NULL);
__print_expression_list (((xp_awk_nde_var_t*)nde)->idx); __print_expression_list (((xp_awk_nde_var_t*)nde)->idx);
xp_printf (XP_TEXT("]")); xp_printf (XP_T("]"));
break; break;
case XP_AWK_NDE_NAMED: case XP_AWK_NDE_NAMED:
xp_assert (((xp_awk_nde_var_t*)nde)->id.idxa == (xp_size_t)-1); xp_assert (((xp_awk_nde_var_t*)nde)->id.idxa == (xp_size_t)-1);
xp_printf (XP_TEXT("%s"), ((xp_awk_nde_var_t*)nde)->id.name); xp_printf (XP_T("%s"), ((xp_awk_nde_var_t*)nde)->id.name);
xp_assert (((xp_awk_nde_var_t*)nde)->idx == XP_NULL); xp_assert (((xp_awk_nde_var_t*)nde)->idx == XP_NULL);
break; break;
case XP_AWK_NDE_NAMEDIDX: case XP_AWK_NDE_NAMEDIDX:
xp_assert (((xp_awk_nde_var_t*)nde)->id.idxa == (xp_size_t)-1); xp_assert (((xp_awk_nde_var_t*)nde)->id.idxa == (xp_size_t)-1);
xp_printf (XP_TEXT("%s["), ((xp_awk_nde_var_t*)nde)->id.name); xp_printf (XP_T("%s["), ((xp_awk_nde_var_t*)nde)->id.name);
xp_assert (((xp_awk_nde_var_t*)nde)->idx != XP_NULL); xp_assert (((xp_awk_nde_var_t*)nde)->idx != XP_NULL);
__print_expression_list (((xp_awk_nde_var_t*)nde)->idx); __print_expression_list (((xp_awk_nde_var_t*)nde)->idx);
xp_printf (XP_TEXT("]")); xp_printf (XP_T("]"));
break; break;
case XP_AWK_NDE_GLOBAL: case XP_AWK_NDE_GLOBAL:
if (((xp_awk_nde_var_t*)nde)->id.idxa != (xp_size_t)-1) if (((xp_awk_nde_var_t*)nde)->id.idxa != (xp_size_t)-1)
{ {
xp_printf (XP_TEXT("__global%lu"), xp_printf (XP_T("__global%lu"),
(unsigned long)((xp_awk_nde_var_t*)nde)->id.idxa); (unsigned long)((xp_awk_nde_var_t*)nde)->id.idxa);
} }
else else
{ {
xp_printf (XP_TEXT("%s"), ((xp_awk_nde_var_t*)nde)->id.name); xp_printf (XP_T("%s"), ((xp_awk_nde_var_t*)nde)->id.name);
} }
xp_assert (((xp_awk_nde_var_t*)nde)->idx == XP_NULL); xp_assert (((xp_awk_nde_var_t*)nde)->idx == XP_NULL);
break; break;
@ -237,27 +237,27 @@ static int __print_expression (xp_awk_nde_t* nde)
case XP_AWK_NDE_GLOBALIDX: case XP_AWK_NDE_GLOBALIDX:
if (((xp_awk_nde_var_t*)nde)->id.idxa != (xp_size_t)-1) if (((xp_awk_nde_var_t*)nde)->id.idxa != (xp_size_t)-1)
{ {
xp_printf (XP_TEXT("__global%lu["), xp_printf (XP_T("__global%lu["),
(unsigned long)((xp_awk_nde_var_t*)nde)->id.idxa); (unsigned long)((xp_awk_nde_var_t*)nde)->id.idxa);
} }
else else
{ {
xp_printf (XP_TEXT("%s["), ((xp_awk_nde_var_t*)nde)->id.name); xp_printf (XP_T("%s["), ((xp_awk_nde_var_t*)nde)->id.name);
} }
xp_assert (((xp_awk_nde_var_t*)nde)->idx != XP_NULL); xp_assert (((xp_awk_nde_var_t*)nde)->idx != XP_NULL);
__print_expression_list (((xp_awk_nde_var_t*)nde)->idx); __print_expression_list (((xp_awk_nde_var_t*)nde)->idx);
xp_printf (XP_TEXT("]")); xp_printf (XP_T("]"));
break; break;
case XP_AWK_NDE_LOCAL: case XP_AWK_NDE_LOCAL:
if (((xp_awk_nde_var_t*)nde)->id.idxa != (xp_size_t)-1) if (((xp_awk_nde_var_t*)nde)->id.idxa != (xp_size_t)-1)
{ {
xp_printf (XP_TEXT("__local%lu"), xp_printf (XP_T("__local%lu"),
(unsigned long)((xp_awk_nde_var_t*)nde)->id.idxa); (unsigned long)((xp_awk_nde_var_t*)nde)->id.idxa);
} }
else else
{ {
xp_printf (XP_TEXT("%s"), ((xp_awk_nde_var_t*)nde)->id.name); xp_printf (XP_T("%s"), ((xp_awk_nde_var_t*)nde)->id.name);
} }
xp_assert (((xp_awk_nde_var_t*)nde)->idx == XP_NULL); xp_assert (((xp_awk_nde_var_t*)nde)->idx == XP_NULL);
break; break;
@ -265,27 +265,27 @@ static int __print_expression (xp_awk_nde_t* nde)
case XP_AWK_NDE_LOCALIDX: case XP_AWK_NDE_LOCALIDX:
if (((xp_awk_nde_var_t*)nde)->id.idxa != (xp_size_t)-1) if (((xp_awk_nde_var_t*)nde)->id.idxa != (xp_size_t)-1)
{ {
xp_printf (XP_TEXT("__local%lu["), xp_printf (XP_T("__local%lu["),
(unsigned long)((xp_awk_nde_var_t*)nde)->id.idxa); (unsigned long)((xp_awk_nde_var_t*)nde)->id.idxa);
} }
else else
{ {
xp_printf (XP_TEXT("%s["), ((xp_awk_nde_var_t*)nde)->id.name); xp_printf (XP_T("%s["), ((xp_awk_nde_var_t*)nde)->id.name);
} }
xp_assert (((xp_awk_nde_var_t*)nde)->idx != XP_NULL); xp_assert (((xp_awk_nde_var_t*)nde)->idx != XP_NULL);
__print_expression_list (((xp_awk_nde_var_t*)nde)->idx); __print_expression_list (((xp_awk_nde_var_t*)nde)->idx);
xp_printf (XP_TEXT("]")); xp_printf (XP_T("]"));
break; break;
case XP_AWK_NDE_POS: case XP_AWK_NDE_POS:
xp_printf (XP_TEXT("$")); xp_printf (XP_T("$"));
__print_expression (((xp_awk_nde_pos_t*)nde)->val); __print_expression (((xp_awk_nde_pos_t*)nde)->val);
break; break;
case XP_AWK_NDE_CALL: case XP_AWK_NDE_CALL:
xp_printf (XP_TEXT("%s ("), ((xp_awk_nde_call_t*)nde)->name); xp_printf (XP_T("%s ("), ((xp_awk_nde_call_t*)nde)->name);
if (__print_expression_list (((xp_awk_nde_call_t*)nde)->args) == -1) return -1; if (__print_expression_list (((xp_awk_nde_call_t*)nde)->args) == -1) return -1;
xp_printf (XP_TEXT(")")); xp_printf (XP_T(")"));
break; break;
default: default:
@ -303,7 +303,7 @@ static int __print_expression_list (xp_awk_nde_t* tree)
{ {
if (__print_expression(p) == -1) return -1; if (__print_expression(p) == -1) return -1;
p = p->next; p = p->next;
if (p != XP_NULL) xp_printf (XP_TEXT(",")); if (p != XP_NULL) xp_printf (XP_T(","));
} }
return 0; return 0;
@ -321,35 +321,35 @@ static void __print_statements (xp_awk_nde_t* tree, int depth)
{ {
case XP_AWK_NDE_NULL: case XP_AWK_NDE_NULL:
__print_tabs (depth); __print_tabs (depth);
xp_printf (XP_TEXT(";\n")); xp_printf (XP_T(";\n"));
break; break;
case XP_AWK_NDE_BLK: case XP_AWK_NDE_BLK:
__print_tabs (depth); __print_tabs (depth);
xp_printf (XP_TEXT("{\n")); xp_printf (XP_T("{\n"));
if (((xp_awk_nde_blk_t*)p)->nlocals > 0) if (((xp_awk_nde_blk_t*)p)->nlocals > 0)
{ {
__print_tabs (depth + 1); __print_tabs (depth + 1);
xp_printf (XP_TEXT("local ")); xp_printf (XP_T("local "));
for (i = 0; i < ((xp_awk_nde_blk_t*)p)->nlocals - 1; i++) for (i = 0; i < ((xp_awk_nde_blk_t*)p)->nlocals - 1; i++)
{ {
xp_printf (XP_TEXT("__local%lu, "), (unsigned long)i); xp_printf (XP_T("__local%lu, "), (unsigned long)i);
} }
xp_printf (XP_TEXT("__local%lu;\n"), (unsigned long)i); xp_printf (XP_T("__local%lu;\n"), (unsigned long)i);
} }
__print_statements (((xp_awk_nde_blk_t*)p)->body, depth + 1); __print_statements (((xp_awk_nde_blk_t*)p)->body, depth + 1);
__print_tabs (depth); __print_tabs (depth);
xp_printf (XP_TEXT("}\n")); xp_printf (XP_T("}\n"));
break; break;
case XP_AWK_NDE_IF: case XP_AWK_NDE_IF:
__print_tabs (depth); __print_tabs (depth);
xp_printf (XP_TEXT("if (")); xp_printf (XP_T("if ("));
__print_expression (((xp_awk_nde_if_t*)p)->test); __print_expression (((xp_awk_nde_if_t*)p)->test);
xp_printf (XP_TEXT(")\n")); xp_printf (XP_T(")\n"));
xp_assert (((xp_awk_nde_if_t*)p)->then_part != XP_NULL); xp_assert (((xp_awk_nde_if_t*)p)->then_part != XP_NULL);
if (((xp_awk_nde_if_t*)p)->then_part->type == XP_AWK_NDE_BLK) if (((xp_awk_nde_if_t*)p)->then_part->type == XP_AWK_NDE_BLK)
@ -360,7 +360,7 @@ static void __print_statements (xp_awk_nde_t* tree, int depth)
if (((xp_awk_nde_if_t*)p)->else_part != XP_NULL) if (((xp_awk_nde_if_t*)p)->else_part != XP_NULL)
{ {
__print_tabs (depth); __print_tabs (depth);
xp_printf (XP_TEXT("else\n")); xp_printf (XP_T("else\n"));
if (((xp_awk_nde_if_t*)p)->else_part->type == XP_AWK_NDE_BLK) if (((xp_awk_nde_if_t*)p)->else_part->type == XP_AWK_NDE_BLK)
__print_statements (((xp_awk_nde_if_t*)p)->else_part, depth); __print_statements (((xp_awk_nde_if_t*)p)->else_part, depth);
else else
@ -369,9 +369,9 @@ static void __print_statements (xp_awk_nde_t* tree, int depth)
break; break;
case XP_AWK_NDE_WHILE: case XP_AWK_NDE_WHILE:
__print_tabs (depth); __print_tabs (depth);
xp_printf (XP_TEXT("while (")); xp_printf (XP_T("while ("));
__print_expression (((xp_awk_nde_while_t*)p)->test); __print_expression (((xp_awk_nde_while_t*)p)->test);
xp_printf (XP_TEXT(")\n")); xp_printf (XP_T(")\n"));
if (((xp_awk_nde_while_t*)p)->body->type == XP_AWK_NDE_BLK) if (((xp_awk_nde_while_t*)p)->body->type == XP_AWK_NDE_BLK)
{ {
__print_statements (((xp_awk_nde_while_t*)p)->body, depth); __print_statements (((xp_awk_nde_while_t*)p)->body, depth);
@ -384,7 +384,7 @@ static void __print_statements (xp_awk_nde_t* tree, int depth)
case XP_AWK_NDE_DOWHILE: case XP_AWK_NDE_DOWHILE:
__print_tabs (depth); __print_tabs (depth);
xp_printf (XP_TEXT("do\n")); xp_printf (XP_T("do\n"));
if (((xp_awk_nde_while_t*)p)->body->type == XP_AWK_NDE_BLK) if (((xp_awk_nde_while_t*)p)->body->type == XP_AWK_NDE_BLK)
{ {
__print_statements (((xp_awk_nde_while_t*)p)->body, depth); __print_statements (((xp_awk_nde_while_t*)p)->body, depth);
@ -395,29 +395,29 @@ static void __print_statements (xp_awk_nde_t* tree, int depth)
} }
__print_tabs (depth); __print_tabs (depth);
xp_printf (XP_TEXT("while (")); xp_printf (XP_T("while ("));
__print_expression (((xp_awk_nde_while_t*)p)->test); __print_expression (((xp_awk_nde_while_t*)p)->test);
xp_printf (XP_TEXT(");\n")); xp_printf (XP_T(");\n"));
break; break;
case XP_AWK_NDE_FOR: case XP_AWK_NDE_FOR:
__print_tabs (depth); __print_tabs (depth);
xp_printf (XP_TEXT("for (")); xp_printf (XP_T("for ("));
if (((xp_awk_nde_for_t*)p)->init != XP_NULL) if (((xp_awk_nde_for_t*)p)->init != XP_NULL)
{ {
__print_expression (((xp_awk_nde_for_t*)p)->init); __print_expression (((xp_awk_nde_for_t*)p)->init);
} }
xp_printf (XP_TEXT("; ")); xp_printf (XP_T("; "));
if (((xp_awk_nde_for_t*)p)->test != XP_NULL) if (((xp_awk_nde_for_t*)p)->test != XP_NULL)
{ {
__print_expression (((xp_awk_nde_for_t*)p)->test); __print_expression (((xp_awk_nde_for_t*)p)->test);
} }
xp_printf (XP_TEXT("; ")); xp_printf (XP_T("; "));
if (((xp_awk_nde_for_t*)p)->incr != XP_NULL) if (((xp_awk_nde_for_t*)p)->incr != XP_NULL)
{ {
__print_expression (((xp_awk_nde_for_t*)p)->incr); __print_expression (((xp_awk_nde_for_t*)p)->incr);
} }
xp_printf (XP_TEXT(")\n")); xp_printf (XP_T(")\n"));
if (((xp_awk_nde_for_t*)p)->body->type == XP_AWK_NDE_BLK) if (((xp_awk_nde_for_t*)p)->body->type == XP_AWK_NDE_BLK)
{ {
@ -431,9 +431,9 @@ static void __print_statements (xp_awk_nde_t* tree, int depth)
case XP_AWK_NDE_FOREACH: case XP_AWK_NDE_FOREACH:
__print_tabs (depth); __print_tabs (depth);
xp_printf (XP_TEXT("for ")); xp_printf (XP_T("for "));
__print_expression (((xp_awk_nde_foreach_t*)p)->test); __print_expression (((xp_awk_nde_foreach_t*)p)->test);
xp_printf (XP_TEXT("\n")); xp_printf (XP_T("\n"));
if (((xp_awk_nde_foreach_t*)p)->body->type == XP_AWK_NDE_BLK) if (((xp_awk_nde_foreach_t*)p)->body->type == XP_AWK_NDE_BLK)
{ {
__print_statements (((xp_awk_nde_foreach_t*)p)->body, depth); __print_statements (((xp_awk_nde_foreach_t*)p)->body, depth);
@ -446,32 +446,32 @@ static void __print_statements (xp_awk_nde_t* tree, int depth)
case XP_AWK_NDE_BREAK: case XP_AWK_NDE_BREAK:
__print_tabs (depth); __print_tabs (depth);
xp_printf (XP_TEXT("break;\n")); xp_printf (XP_T("break;\n"));
break; break;
case XP_AWK_NDE_CONTINUE: case XP_AWK_NDE_CONTINUE:
__print_tabs (depth); __print_tabs (depth);
xp_printf (XP_TEXT("continue;\n")); xp_printf (XP_T("continue;\n"));
break; break;
case XP_AWK_NDE_RETURN: case XP_AWK_NDE_RETURN:
__print_tabs (depth); __print_tabs (depth);
if (((xp_awk_nde_return_t*)p)->val == XP_NULL) if (((xp_awk_nde_return_t*)p)->val == XP_NULL)
{ {
xp_printf (XP_TEXT("return;\n")); xp_printf (XP_T("return;\n"));
} }
else else
{ {
xp_printf (XP_TEXT("return ")); xp_printf (XP_T("return "));
xp_assert (((xp_awk_nde_return_t*)p)->val->next == XP_NULL); xp_assert (((xp_awk_nde_return_t*)p)->val->next == XP_NULL);
if (__print_expression(((xp_awk_nde_return_t*)p)->val) == 0) if (__print_expression(((xp_awk_nde_return_t*)p)->val) == 0)
{ {
xp_printf (XP_TEXT(";\n")); xp_printf (XP_T(";\n"));
} }
else else
{ {
xp_awk_nde_return_t* x = (xp_awk_nde_return_t*)p; xp_awk_nde_return_t* x = (xp_awk_nde_return_t*)p;
xp_printf (XP_TEXT("***INTERNAL ERROR: unknown nde type - %d\n"), x->type); xp_printf (XP_T("***INTERNAL ERROR: unknown nde type - %d\n"), x->type);
} }
} }
break; break;
@ -481,43 +481,43 @@ static void __print_statements (xp_awk_nde_t* tree, int depth)
if (((xp_awk_nde_exit_t*)p)->val == XP_NULL) if (((xp_awk_nde_exit_t*)p)->val == XP_NULL)
{ {
xp_printf (XP_TEXT("exit;\n")); xp_printf (XP_T("exit;\n"));
} }
else else
{ {
xp_printf (XP_TEXT("exit ")); xp_printf (XP_T("exit "));
xp_assert (((xp_awk_nde_exit_t*)p)->val->next == XP_NULL); xp_assert (((xp_awk_nde_exit_t*)p)->val->next == XP_NULL);
if (__print_expression(((xp_awk_nde_exit_t*)p)->val) == 0) if (__print_expression(((xp_awk_nde_exit_t*)p)->val) == 0)
{ {
xp_printf (XP_TEXT(";\n")); xp_printf (XP_T(";\n"));
} }
else else
{ {
xp_awk_nde_exit_t* x = (xp_awk_nde_exit_t*)p; xp_awk_nde_exit_t* x = (xp_awk_nde_exit_t*)p;
xp_printf (XP_TEXT("***INTERNAL ERROR: unknown nde type - %d\n"), x->type); xp_printf (XP_T("***INTERNAL ERROR: unknown nde type - %d\n"), x->type);
} }
} }
break; break;
case XP_AWK_NDE_NEXT: case XP_AWK_NDE_NEXT:
__print_tabs (depth); __print_tabs (depth);
xp_printf (XP_TEXT("next;\n")); xp_printf (XP_T("next;\n"));
break; break;
case XP_AWK_NDE_NEXTFILE: case XP_AWK_NDE_NEXTFILE:
__print_tabs (depth); __print_tabs (depth);
xp_printf (XP_TEXT("nextfile;\n")); xp_printf (XP_T("nextfile;\n"));
break; break;
default: default:
__print_tabs (depth); __print_tabs (depth);
if (__print_expression(p) == 0) if (__print_expression(p) == 0)
{ {
xp_printf (XP_TEXT(";\n")); xp_printf (XP_T(";\n"));
} }
else else
{ {
xp_printf (XP_TEXT("***INTERNAL ERROR: unknown type - %d\n"), p->type); xp_printf (XP_T("***INTERNAL ERROR: unknown type - %d\n"), p->type);
} }
} }

50
ase/awk/val.c
View File

@ -1,5 +1,5 @@
/* /*
* $Id: val.c,v 1.28 2006-04-30 17:10:30 bacon Exp $ * $Id: val.c,v 1.29 2006-05-06 12:52:36 bacon Exp $
*/ */
#include <xp/awk/awk_i.h> #include <xp/awk/awk_i.h>
@ -144,9 +144,9 @@ xp_awk_val_t* xp_awk_makerexval (const xp_char_t* str, xp_size_t len)
static void __free_map_val (void* run, void* v) static void __free_map_val (void* run, void* v)
{ {
/* /*
xp_printf (XP_TEXT("refdown in map free...")); xp_printf (XP_T("refdown in map free..."));
xp_awk_printval (v); xp_awk_printval (v);
xp_printf (XP_TEXT("\n")); xp_printf (XP_T("\n"));
*/ */
xp_awk_refdownval (run, v); xp_awk_refdownval (run, v);
} }
@ -182,9 +182,9 @@ void xp_awk_freeval (xp_awk_run_t* run, xp_awk_val_t* val, xp_bool_t cache)
{ {
if (xp_awk_isbuiltinval(val)) return; if (xp_awk_isbuiltinval(val)) return;
xp_printf (XP_TEXT("freeing [cache=%d] ... "), cache); xp_printf (XP_T("freeing [cache=%d] ... "), cache);
xp_awk_printval (val); xp_awk_printval (val);
xp_printf (XP_TEXT("\n")); xp_printf (XP_T("\n"));
switch (val->type) switch (val->type)
{ {
case XP_AWK_VAL_NIL: case XP_AWK_VAL_NIL:
@ -235,9 +235,9 @@ void xp_awk_refupval (xp_awk_val_t* val)
{ {
if (xp_awk_isbuiltinval(val)) return; if (xp_awk_isbuiltinval(val)) return;
/* /*
xp_printf (XP_TEXT("ref up ")); xp_printf (XP_T("ref up "));
xp_awk_printval (val); xp_awk_printval (val);
xp_printf (XP_TEXT("\n")); xp_printf (XP_T("\n"));
*/ */
val->ref++; val->ref++;
} }
@ -247,10 +247,10 @@ void xp_awk_refdownval (xp_awk_run_t* run, xp_awk_val_t* val)
if (xp_awk_isbuiltinval(val)) return; if (xp_awk_isbuiltinval(val)) return;
/* /*
xp_printf (XP_TEXT("%p, %p, %p\n"), xp_awk_val_nil, &__awk_nil, val); xp_printf (XP_T("%p, %p, %p\n"), xp_awk_val_nil, &__awk_nil, val);
xp_printf (XP_TEXT("ref down [count=>%d]\n"), (int)val->ref); xp_printf (XP_T("ref down [count=>%d]\n"), (int)val->ref);
xp_awk_printval (val); xp_awk_printval (val);
xp_printf (XP_TEXT("\n")); xp_printf (XP_T("\n"));
*/ */
xp_assert (val->ref > 0); xp_assert (val->ref > 0);
@ -258,9 +258,9 @@ xp_printf (XP_TEXT("\n"));
if (val->ref <= 0) if (val->ref <= 0)
{ {
/* /*
xp_printf (XP_TEXT("**FREEING ")); xp_printf (XP_T("**FREEING "));
xp_awk_printval (val); xp_awk_printval (val);
xp_printf (XP_TEXT("\n")); xp_printf (XP_T("\n"));
*/ */
xp_awk_freeval(run, val, xp_true); xp_awk_freeval(run, val, xp_true);
} }
@ -323,9 +323,9 @@ xp_bool_t xp_awk_boolval (xp_awk_val_t* val)
static int __print_pair (xp_awk_pair_t* pair, void* arg) static int __print_pair (xp_awk_pair_t* pair, void* arg)
{ {
xp_printf (XP_TEXT(" %s=>"), pair->key); xp_printf (XP_T(" %s=>"), pair->key);
xp_awk_printval (pair->val); xp_awk_printval (pair->val);
xp_printf (XP_TEXT(" ")); xp_printf (XP_T(" "));
return 0; return 0;
} }
@ -335,46 +335,46 @@ void xp_awk_printval (xp_awk_val_t* val)
switch (val->type) switch (val->type)
{ {
case XP_AWK_VAL_NIL: case XP_AWK_VAL_NIL:
xp_printf (XP_TEXT("nil")); xp_printf (XP_T("nil"));
break; break;
case XP_AWK_VAL_INT: case XP_AWK_VAL_INT:
#if defined(__LCC__) #if defined(__LCC__)
xp_printf (XP_TEXT("%lld"), xp_printf (XP_T("%lld"),
(long long)((xp_awk_val_int_t*)val)->val); (long long)((xp_awk_val_int_t*)val)->val);
#elif defined(__BORLANDC__) || defined(_MSC_VER) #elif defined(__BORLANDC__) || defined(_MSC_VER)
xp_printf (XP_TEXT("%I64d"), xp_printf (XP_T("%I64d"),
(__int64)((xp_awk_nde_int_t*)val)->val); (__int64)((xp_awk_nde_int_t*)val)->val);
#elif defined(vax) || defined(__vax) || defined(_SCO_DS) #elif defined(vax) || defined(__vax) || defined(_SCO_DS)
xp_printf (XP_TEXT("%ld"), xp_printf (XP_T("%ld"),
(long)((xp_awk_val_int_t*)val)->val); (long)((xp_awk_val_int_t*)val)->val);
#else #else
xp_printf (XP_TEXT("%lld"), xp_printf (XP_T("%lld"),
(long long)((xp_awk_val_int_t*)val)->val); (long long)((xp_awk_val_int_t*)val)->val);
#endif #endif
break; break;
case XP_AWK_VAL_REAL: case XP_AWK_VAL_REAL:
xp_printf (XP_TEXT("%Lf"), xp_printf (XP_T("%Lf"),
(long double)((xp_awk_val_real_t*)val)->val); (long double)((xp_awk_val_real_t*)val)->val);
break; break;
case XP_AWK_VAL_STR: case XP_AWK_VAL_STR:
xp_printf (XP_TEXT("%s"), ((xp_awk_val_str_t*)val)->buf); xp_printf (XP_T("%s"), ((xp_awk_val_str_t*)val)->buf);
break; break;
case XP_AWK_VAL_REX: case XP_AWK_VAL_REX:
xp_printf (XP_TEXT("REX[%s]"), ((xp_awk_val_rex_t*)val)->buf); xp_printf (XP_T("REX[%s]"), ((xp_awk_val_rex_t*)val)->buf);
break; break;
case XP_AWK_VAL_MAP: case XP_AWK_VAL_MAP:
xp_printf (XP_TEXT("MAP[")); xp_printf (XP_T("MAP["));
xp_awk_map_walk (((xp_awk_val_map_t*)val)->map, __print_pair, XP_NULL); xp_awk_map_walk (((xp_awk_val_map_t*)val)->map, __print_pair, XP_NULL);
xp_printf (XP_TEXT("]")); xp_printf (XP_T("]"));
break; break;
default: default:
xp_assert (!"should never happen - invalid value type"); xp_assert (!"should never happen - invalid value type");
xp_printf (XP_TEXT("**** INTERNAL ERROR - INVALID VALUE TYPE ****\n")); xp_printf (XP_T("**** INTERNAL ERROR - INVALID VALUE TYPE ****\n"));
} }
} }

32
ase/macros.h
View File

@ -1,5 +1,5 @@
/* /*
* $Id: macros.h,v 1.31 2006-04-03 10:40:26 bacon Exp $ * $Id: macros.h,v 1.32 2006-05-06 12:52:36 bacon Exp $
*/ */
#ifndef _XP_MACROS_H_ #ifndef _XP_MACROS_H_
@ -59,28 +59,56 @@
} \ } \
} while (0); } while (0);
/* obsolete */
#define XP_MQUOTE(val) #val #define XP_MQUOTE(val) #val
#define XP_MCHAR(ch) ((xp_mchar_t)ch) #define XP_MCHAR(ch) ((xp_mchar_t)ch)
#define XP_MTEXT(txt) ((const xp_mchar_t*)txt) #define XP_MTEXT(txt) ((const xp_mchar_t*)txt)
/* new short form */
#define XP_MQ(val) #val
#define XP_MC(ch) ((xp_mchar_t)ch)
#define XP_MS(str) ((const xp_mchar_t*)str)
#define XP_MT(txt) (txt)
/* TODO: if the compiler doesn't have the built-in wchar_t support /* TODO: if the compiler doesn't have the built-in wchar_t support
* XP_WCHAR & XP_WTEXT must be defined differently. * XP_WCHAR & XP_WTEXT must be defined differently.
#define XP_WCHAR(ch) ((xp_wchar_t)ch) #define XP_WCHAR(ch) ((xp_wchar_t)ch)
#define XP_WTEXT(txt) don't know yet... may have to call a function? #define XP_WTEXT(txt) don't know yet... may have to call a function?
*/ */
/* obsolete */
#define XP_WQUOTE(val) ((const xp_char_t*)L###val) #define XP_WQUOTE(val) ((const xp_char_t*)L###val)
#define XP_WCHAR(ch) ((xp_wchar_t)L##ch) #define XP_WCHAR(ch) ((xp_wchar_t)L##ch)
#define XP_WTEXT(txt) ((const xp_wchar_t*)L##txt) #define XP_WTEXT(txt) ((const xp_wchar_t*)L##txt)
/* new short form */
#define XP_WQ(val) ((const xp_char_t*)L###val)
#define XP_WC(ch) ((xp_wchar_t)L##ch)
#define XP_WS(str) ((const xp_wchar_t*)L##str)
#define XP_WT(txt) (L##txt)
#if defined(XP_CHAR_IS_MCHAR) #if defined(XP_CHAR_IS_MCHAR)
/* obsolete */
#define XP_CHAR(ch) XP_MCHAR(ch) #define XP_CHAR(ch) XP_MCHAR(ch)
#define XP_TEXT(txt) XP_MTEXT(txt) #define XP_TEXT(txt) XP_MTEXT(txt)
#define XP_QUOTE(val) XP_MQUOTE(val) #define XP_QUOTE(val) XP_MQUOTE(val)
/* new short form */
#define XP_C(ch) XP_MC(ch)
#define XP_S(str) XP_MS(str)
#define XP_T(txt) XP_MT(txt)
#define XP_Q(val) XP_MQ(val)
#else #else
/* obsolete */
#define XP_CHAR(ch) XP_WCHAR(ch) #define XP_CHAR(ch) XP_WCHAR(ch)
#define XP_TEXT(txt) XP_WTEXT(txt) #define XP_TEXT(txt) XP_WTEXT(txt)
#define XP_QUOTE(val) XP_WQUOTE(val) #define XP_QUOTE(val) XP_WQUOTE(val)
/* new short form */
#define XP_C(ch) XP_WC(ch)
#define XP_S(str) XP_WS(str)
#define XP_T(txt) XP_WT(txt)
#define XP_Q(val) XP_WQ(val)
#endif #endif
#endif #endif

10
ase/types.h
View File

@ -1,5 +1,5 @@
/* /*
* $Id: types.h,v 1.45 2006-04-30 17:35:37 bacon Exp $ * $Id: types.h,v 1.46 2006-05-06 12:52:36 bacon Exp $
*/ */
#ifndef _XP_TYPES_H_ #ifndef _XP_TYPES_H_
@ -208,6 +208,12 @@ typedef xp_uint_t xp_word_t;
typedef char xp_mchar_t; typedef char xp_mchar_t;
typedef int xp_mcint_t; typedef int xp_mcint_t;
#ifdef __cplusplus
/* C++ */
typedef wchar_t xp_wchar_t;
typedef wchar_t xp_wcint_t;
#else
/* C */
#if defined(_WIN32) #if defined(_WIN32)
typedef unsigned short xp_wchar_t; typedef unsigned short xp_wchar_t;
typedef unsigned short xp_wcint_t; typedef unsigned short xp_wcint_t;
@ -222,6 +228,8 @@ typedef int xp_mcint_t;
typedef int xp_wcint_t; typedef int xp_wcint_t;
#endif #endif
#endif
#if defined(_WIN32) && (defined(UNICODE)||defined(_UNICODE)) #if defined(_WIN32) && (defined(UNICODE)||defined(_UNICODE))
#define XP_CHAR_IS_WCHAR #define XP_CHAR_IS_WCHAR
typedef xp_wchar_t xp_char_t; typedef xp_wchar_t xp_char_t;