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-10-24 04:10:12 +00:00
parent 8e41e6086a
commit 2b04c6af3e
29 changed files with 7734 additions and 7734 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

224
ase/awk/awk.c
View File

@ -1,5 +1,5 @@
/* /*
* $Id: awk.c,v 1.85 2006-10-23 14:44:42 bacon Exp $ * $Id: awk.c,v 1.86 2006-10-24 04:10:12 bacon Exp $
*/ */
#if defined(__BORLANDC__) #if defined(__BORLANDC__)
@ -7,111 +7,111 @@
#define Library #define Library
#endif #endif
#include <sse/awk/awk_i.h> #include <ase/awk/awk_i.h>
static void __free_afn (void* awk, void* afn); static void __free_afn (void* awk, void* afn);
sse_awk_t* sse_awk_open (const sse_awk_syscas_t* syscas) ase_awk_t* ase_awk_open (const ase_awk_syscas_t* syscas)
{ {
sse_awk_t* awk; ase_awk_t* awk;
if (syscas == SSE_NULL) return SSE_NULL; if (syscas == ASE_NULL) return ASE_NULL;
if (syscas->malloc == SSE_NULL || if (syscas->malloc == ASE_NULL ||
syscas->free == SSE_NULL) return SSE_NULL; syscas->free == ASE_NULL) return ASE_NULL;
if (syscas->is_upper == SSE_NULL || if (syscas->is_upper == ASE_NULL ||
syscas->is_lower == SSE_NULL || syscas->is_lower == ASE_NULL ||
syscas->is_alpha == SSE_NULL || syscas->is_alpha == ASE_NULL ||
syscas->is_digit == SSE_NULL || syscas->is_digit == ASE_NULL ||
syscas->is_xdigit == SSE_NULL || syscas->is_xdigit == ASE_NULL ||
syscas->is_alnum == SSE_NULL || syscas->is_alnum == ASE_NULL ||
syscas->is_space == SSE_NULL || syscas->is_space == ASE_NULL ||
syscas->is_print == SSE_NULL || syscas->is_print == ASE_NULL ||
syscas->is_graph == SSE_NULL || syscas->is_graph == ASE_NULL ||
syscas->is_cntrl == SSE_NULL || syscas->is_cntrl == ASE_NULL ||
syscas->is_punct == SSE_NULL || syscas->is_punct == ASE_NULL ||
syscas->to_upper == SSE_NULL || syscas->to_upper == ASE_NULL ||
syscas->to_lower == SSE_NULL) return SSE_NULL; syscas->to_lower == ASE_NULL) return ASE_NULL;
if (syscas->sprintf == SSE_NULL || if (syscas->sprintf == ASE_NULL ||
syscas->dprintf == SSE_NULL || syscas->dprintf == ASE_NULL ||
syscas->abort == SSE_NULL) return SSE_NULL; syscas->abort == ASE_NULL) return ASE_NULL;
#if defined(_WIN32) && defined(_DEBUG) #if defined(_WIN32) && defined(_DEBUG)
awk = (sse_awk_t*) malloc (sse_sizeof(sse_awk_t)); awk = (ase_awk_t*) malloc (ase_sizeof(ase_awk_t));
#else #else
awk = (sse_awk_t*) syscas->malloc ( awk = (ase_awk_t*) syscas->malloc (
sse_sizeof(sse_awk_t), syscas->custom_data); ase_sizeof(ase_awk_t), syscas->custom_data);
#endif #endif
if (awk == SSE_NULL) return SSE_NULL; if (awk == ASE_NULL) return ASE_NULL;
/* it uses the built-in sse_awk_memset because awk is not /* it uses the built-in ase_awk_memset because awk is not
* fully initialized yet */ * fully initialized yet */
sse_awk_memset (awk, 0, sse_sizeof(sse_awk_t)); ase_awk_memset (awk, 0, ase_sizeof(ase_awk_t));
if (syscas->memcpy == SSE_NULL) if (syscas->memcpy == ASE_NULL)
{ {
sse_awk_memcpy (&awk->syscas, syscas, sse_sizeof(awk->syscas)); ase_awk_memcpy (&awk->syscas, syscas, ase_sizeof(awk->syscas));
awk->syscas.memcpy = sse_awk_memcpy; awk->syscas.memcpy = ase_awk_memcpy;
} }
else syscas->memcpy (&awk->syscas, syscas, sse_sizeof(awk->syscas)); else syscas->memcpy (&awk->syscas, syscas, ase_sizeof(awk->syscas));
if (syscas->memset == SSE_NULL) awk->syscas.memset = sse_awk_memset; if (syscas->memset == ASE_NULL) awk->syscas.memset = ase_awk_memset;
if (sse_awk_str_open (&awk->token.name, 128, awk) == SSE_NULL) if (ase_awk_str_open (&awk->token.name, 128, awk) == ASE_NULL)
{ {
SSE_AWK_FREE (awk, awk); ASE_AWK_FREE (awk, awk);
return SSE_NULL; return ASE_NULL;
} }
/* TODO: initial map size?? */ /* TODO: initial map size?? */
if (sse_awk_map_open ( if (ase_awk_map_open (
&awk->tree.afns, awk, 256, __free_afn, awk) == SSE_NULL) &awk->tree.afns, awk, 256, __free_afn, awk) == ASE_NULL)
{ {
sse_awk_str_close (&awk->token.name); ase_awk_str_close (&awk->token.name);
SSE_AWK_FREE (awk, awk); ASE_AWK_FREE (awk, awk);
return SSE_NULL; return ASE_NULL;
} }
if (sse_awk_tab_open (&awk->parse.globals, awk) == SSE_NULL) if (ase_awk_tab_open (&awk->parse.globals, awk) == ASE_NULL)
{ {
sse_awk_str_close (&awk->token.name); ase_awk_str_close (&awk->token.name);
sse_awk_map_close (&awk->tree.afns); ase_awk_map_close (&awk->tree.afns);
SSE_AWK_FREE (awk, awk); ASE_AWK_FREE (awk, awk);
return SSE_NULL; return ASE_NULL;
} }
if (sse_awk_tab_open (&awk->parse.locals, awk) == SSE_NULL) if (ase_awk_tab_open (&awk->parse.locals, awk) == ASE_NULL)
{ {
sse_awk_str_close (&awk->token.name); ase_awk_str_close (&awk->token.name);
sse_awk_map_close (&awk->tree.afns); ase_awk_map_close (&awk->tree.afns);
sse_awk_tab_close (&awk->parse.globals); ase_awk_tab_close (&awk->parse.globals);
SSE_AWK_FREE (awk, awk); ASE_AWK_FREE (awk, awk);
return SSE_NULL; return ASE_NULL;
} }
if (sse_awk_tab_open (&awk->parse.params, awk) == SSE_NULL) if (ase_awk_tab_open (&awk->parse.params, awk) == ASE_NULL)
{ {
sse_awk_str_close (&awk->token.name); ase_awk_str_close (&awk->token.name);
sse_awk_map_close (&awk->tree.afns); ase_awk_map_close (&awk->tree.afns);
sse_awk_tab_close (&awk->parse.globals); ase_awk_tab_close (&awk->parse.globals);
sse_awk_tab_close (&awk->parse.locals); ase_awk_tab_close (&awk->parse.locals);
SSE_AWK_FREE (awk, awk); ASE_AWK_FREE (awk, awk);
return SSE_NULL; return ASE_NULL;
} }
awk->option = 0; awk->option = 0;
awk->errnum = SSE_AWK_ENOERR; awk->errnum = ASE_AWK_ENOERR;
awk->parse.nlocals_max = 0; awk->parse.nlocals_max = 0;
awk->parse.nl_semicolon = 0; awk->parse.nl_semicolon = 0;
awk->tree.nglobals = 0; awk->tree.nglobals = 0;
awk->tree.nbglobals = 0; awk->tree.nbglobals = 0;
awk->tree.begin = SSE_NULL; awk->tree.begin = ASE_NULL;
awk->tree.end = SSE_NULL; awk->tree.end = ASE_NULL;
awk->tree.chain = SSE_NULL; awk->tree.chain = ASE_NULL;
awk->tree.chain_tail = SSE_NULL; awk->tree.chain_tail = ASE_NULL;
awk->tree.chain_size = 0; awk->tree.chain_size = 0;
awk->token.prev = 0; awk->token.prev = 0;
@ -119,48 +119,48 @@ sse_awk_t* sse_awk_open (const sse_awk_syscas_t* syscas)
awk->token.line = 0; awk->token.line = 0;
awk->token.column = 0; awk->token.column = 0;
awk->src.ios = SSE_NULL; awk->src.ios = ASE_NULL;
awk->src.lex.curc = SSE_CHAR_EOF; awk->src.lex.curc = ASE_CHAR_EOF;
awk->src.lex.ungotc_count = 0; awk->src.lex.ungotc_count = 0;
awk->src.lex.line = 1; awk->src.lex.line = 1;
awk->src.lex.column = 1; awk->src.lex.column = 1;
awk->src.shared.buf_pos = 0; awk->src.shared.buf_pos = 0;
awk->src.shared.buf_len = 0; awk->src.shared.buf_len = 0;
awk->bfn.sys = SSE_NULL; awk->bfn.sys = ASE_NULL;
awk->bfn.user = SSE_NULL; awk->bfn.user = ASE_NULL;
awk->run.count = 0; awk->run.count = 0;
awk->run.ptr = SSE_NULL; awk->run.ptr = ASE_NULL;
return awk; return awk;
} }
int sse_awk_close (sse_awk_t* awk) int ase_awk_close (ase_awk_t* awk)
{ {
if (sse_awk_clear (awk) == -1) return -1; if (ase_awk_clear (awk) == -1) return -1;
sse_awk_assert (awk, awk->run.count == 0 && awk->run.ptr == SSE_NULL); ase_awk_assert (awk, awk->run.count == 0 && awk->run.ptr == ASE_NULL);
sse_awk_map_close (&awk->tree.afns); ase_awk_map_close (&awk->tree.afns);
sse_awk_tab_close (&awk->parse.globals); ase_awk_tab_close (&awk->parse.globals);
sse_awk_tab_close (&awk->parse.locals); ase_awk_tab_close (&awk->parse.locals);
sse_awk_tab_close (&awk->parse.params); ase_awk_tab_close (&awk->parse.params);
sse_awk_str_close (&awk->token.name); ase_awk_str_close (&awk->token.name);
/* SSE_AWK_ALLOC, SSE_AWK_FREE, etc can not be used /* ASE_AWK_ALLOC, ASE_AWK_FREE, etc can not be used
* from the next line onwards */ * from the next line onwards */
SSE_AWK_FREE (awk, awk); ASE_AWK_FREE (awk, awk);
return 0; return 0;
} }
int sse_awk_clear (sse_awk_t* awk) int ase_awk_clear (ase_awk_t* awk)
{ {
/* you should stop all running instances beforehand */ /* you should stop all running instances beforehand */
/* TODO: can i stop all instances??? */ /* TODO: can i stop all instances??? */
if (awk->run.ptr != SSE_NULL) if (awk->run.ptr != ASE_NULL)
{ {
awk->errnum = SSE_AWK_ERUNNING; awk->errnum = ASE_AWK_ERUNNING;
return -1; return -1;
} }
@ -169,17 +169,17 @@ int sse_awk_clear (sse_awk_t* awk)
awk->bfn.user awk->bfn.user
*/ */
awk->src.ios = SSE_NULL; awk->src.ios = ASE_NULL;
awk->src.lex.curc = SSE_CHAR_EOF; awk->src.lex.curc = ASE_CHAR_EOF;
awk->src.lex.ungotc_count = 0; awk->src.lex.ungotc_count = 0;
awk->src.lex.line = 1; awk->src.lex.line = 1;
awk->src.lex.column = 1; awk->src.lex.column = 1;
awk->src.shared.buf_pos = 0; awk->src.shared.buf_pos = 0;
awk->src.shared.buf_len = 0; awk->src.shared.buf_len = 0;
sse_awk_tab_clear (&awk->parse.globals); ase_awk_tab_clear (&awk->parse.globals);
sse_awk_tab_clear (&awk->parse.locals); ase_awk_tab_clear (&awk->parse.locals);
sse_awk_tab_clear (&awk->parse.params); ase_awk_tab_clear (&awk->parse.params);
awk->parse.nlocals_max = 0; awk->parse.nlocals_max = 0;
awk->parse.depth.loop = 0; awk->parse.depth.loop = 0;
@ -187,60 +187,60 @@ int sse_awk_clear (sse_awk_t* awk)
/* clear parse trees */ /* clear parse trees */
awk->tree.nbglobals = 0; awk->tree.nbglobals = 0;
awk->tree.nglobals = 0; awk->tree.nglobals = 0;
sse_awk_map_clear (&awk->tree.afns); ase_awk_map_clear (&awk->tree.afns);
if (awk->tree.begin != SSE_NULL) if (awk->tree.begin != ASE_NULL)
{ {
sse_awk_assert (awk, awk->tree.begin->next == SSE_NULL); ase_awk_assert (awk, awk->tree.begin->next == ASE_NULL);
sse_awk_clrpt (awk, awk->tree.begin); ase_awk_clrpt (awk, awk->tree.begin);
awk->tree.begin = SSE_NULL; awk->tree.begin = ASE_NULL;
} }
if (awk->tree.end != SSE_NULL) if (awk->tree.end != ASE_NULL)
{ {
sse_awk_assert (awk, awk->tree.end->next == SSE_NULL); ase_awk_assert (awk, awk->tree.end->next == ASE_NULL);
sse_awk_clrpt (awk, awk->tree.end); ase_awk_clrpt (awk, awk->tree.end);
awk->tree.end = SSE_NULL; awk->tree.end = ASE_NULL;
} }
while (awk->tree.chain != SSE_NULL) while (awk->tree.chain != ASE_NULL)
{ {
sse_awk_chain_t* next = awk->tree.chain->next; ase_awk_chain_t* next = awk->tree.chain->next;
if (awk->tree.chain->pattern != SSE_NULL) if (awk->tree.chain->pattern != ASE_NULL)
sse_awk_clrpt (awk, awk->tree.chain->pattern); ase_awk_clrpt (awk, awk->tree.chain->pattern);
if (awk->tree.chain->action != SSE_NULL) if (awk->tree.chain->action != ASE_NULL)
sse_awk_clrpt (awk, awk->tree.chain->action); ase_awk_clrpt (awk, awk->tree.chain->action);
SSE_AWK_FREE (awk, awk->tree.chain); ASE_AWK_FREE (awk, awk->tree.chain);
awk->tree.chain = next; awk->tree.chain = next;
} }
awk->tree.chain_tail = SSE_NULL; awk->tree.chain_tail = ASE_NULL;
awk->tree.chain_size = 0; awk->tree.chain_size = 0;
return 0; return 0;
} }
int sse_awk_getopt (sse_awk_t* awk) int ase_awk_getopt (ase_awk_t* awk)
{ {
return awk->option; return awk->option;
} }
void sse_awk_setopt (sse_awk_t* awk, int opt) void ase_awk_setopt (ase_awk_t* awk, int opt)
{ {
awk->option = opt; awk->option = opt;
} }
static void __free_afn (void* owner, void* afn) static void __free_afn (void* owner, void* afn)
{ {
sse_awk_afn_t* f = (sse_awk_afn_t*)afn; ase_awk_afn_t* f = (ase_awk_afn_t*)afn;
/* f->name doesn't have to be freed */ /* f->name doesn't have to be freed */
/*SSE_AWK_FREE ((sse_awk_t*)owner, f->name);*/ /*ASE_AWK_FREE ((ase_awk_t*)owner, f->name);*/
sse_awk_clrpt ((sse_awk_t*)owner, f->body); ase_awk_clrpt ((ase_awk_t*)owner, f->body);
SSE_AWK_FREE ((sse_awk_t*)owner, f); ASE_AWK_FREE ((ase_awk_t*)owner, f);
} }
sse_size_t sse_awk_getsrcline (sse_awk_t* awk) ase_size_t ase_awk_getsrcline (ase_awk_t* awk)
{ {
return awk->token.line; return awk->token.line;
} }

488
ase/awk/awk.h
View File

@ -1,34 +1,34 @@
/* /*
* $Id: awk.h,v 1.132 2006-10-23 14:44:42 bacon Exp $ * $Id: awk.h,v 1.133 2006-10-24 04:10:12 bacon Exp $
*/ */
#ifndef _SSE_AWK_AWK_H_ #ifndef _ASE_AWK_AWK_H_
#define _SSE_AWK_AWK_H_ #define _ASE_AWK_AWK_H_
#include <sse/types.h> #include <ase/types.h>
#include <sse/macros.h> #include <ase/macros.h>
typedef struct sse_awk_t sse_awk_t; typedef struct ase_awk_t ase_awk_t;
typedef struct sse_awk_run_t sse_awk_run_t; typedef struct ase_awk_run_t ase_awk_run_t;
typedef struct sse_awk_val_t sse_awk_val_t; typedef struct ase_awk_val_t ase_awk_val_t;
typedef struct sse_awk_extio_t sse_awk_extio_t; typedef struct ase_awk_extio_t ase_awk_extio_t;
typedef struct sse_awk_syscas_t sse_awk_syscas_t; typedef struct ase_awk_syscas_t ase_awk_syscas_t;
typedef struct sse_awk_srcios_t sse_awk_srcios_t; typedef struct ase_awk_srcios_t ase_awk_srcios_t;
typedef struct sse_awk_runios_t sse_awk_runios_t; typedef struct ase_awk_runios_t ase_awk_runios_t;
typedef struct sse_awk_runcbs_t sse_awk_runcbs_t; typedef struct ase_awk_runcbs_t ase_awk_runcbs_t;
typedef struct sse_awk_runarg_t sse_awk_runarg_t; typedef struct ase_awk_runarg_t ase_awk_runarg_t;
typedef void (*sse_awk_lk_t) (sse_awk_t* awk, void* arg); typedef void (*ase_awk_lk_t) (ase_awk_t* awk, void* arg);
typedef sse_ssize_t (*sse_awk_io_t) ( typedef ase_ssize_t (*ase_awk_io_t) (
int cmd, void* arg, sse_char_t* data, sse_size_t count); int cmd, void* arg, ase_char_t* data, ase_size_t count);
struct sse_awk_extio_t struct ase_awk_extio_t
{ {
sse_awk_run_t* run; /* [IN] */ ase_awk_run_t* run; /* [IN] */
int type; /* [IN] console, file, coproc, pipe */ int type; /* [IN] console, file, coproc, pipe */
int mode; /* [IN] read, write, etc */ int mode; /* [IN] read, write, etc */
sse_char_t* name; /* [IN] */ ase_char_t* name; /* [IN] */
void* custom_data; /* [IN] */ void* custom_data; /* [IN] */
void* handle; /* [OUT] */ void* handle; /* [OUT] */
@ -36,147 +36,147 @@ struct sse_awk_extio_t
/* input buffer */ /* input buffer */
struct struct
{ {
sse_char_t buf[2048]; ase_char_t buf[2048];
sse_size_t pos; ase_size_t pos;
sse_size_t len; ase_size_t len;
sse_bool_t eof; ase_bool_t eof;
} in; } in;
sse_awk_extio_t* next; ase_awk_extio_t* next;
}; };
struct sse_awk_syscas_t struct ase_awk_syscas_t
{ {
/* memory */ /* memory */
void* (*malloc) (sse_size_t n, void* custom_data); void* (*malloc) (ase_size_t n, void* custom_data);
void* (*realloc) (void* ptr, sse_size_t n, void* custom_data); void* (*realloc) (void* ptr, ase_size_t n, void* custom_data);
void (*free) (void* ptr, void* custom_data); void (*free) (void* ptr, void* custom_data);
/* thread lock */ /* thread lock */
sse_awk_lk_t lock; ase_awk_lk_t lock;
sse_awk_lk_t unlock; ase_awk_lk_t unlock;
/* character class */ /* character class */
sse_bool_t (*is_upper) (sse_cint_t c); ase_bool_t (*is_upper) (ase_cint_t c);
sse_bool_t (*is_lower) (sse_cint_t c); ase_bool_t (*is_lower) (ase_cint_t c);
sse_bool_t (*is_alpha) (sse_cint_t c); ase_bool_t (*is_alpha) (ase_cint_t c);
sse_bool_t (*is_digit) (sse_cint_t c); ase_bool_t (*is_digit) (ase_cint_t c);
sse_bool_t (*is_xdigit) (sse_cint_t c); ase_bool_t (*is_xdigit) (ase_cint_t c);
sse_bool_t (*is_alnum) (sse_cint_t c); ase_bool_t (*is_alnum) (ase_cint_t c);
sse_bool_t (*is_space) (sse_cint_t c); ase_bool_t (*is_space) (ase_cint_t c);
sse_bool_t (*is_print) (sse_cint_t c); ase_bool_t (*is_print) (ase_cint_t c);
sse_bool_t (*is_graph) (sse_cint_t c); ase_bool_t (*is_graph) (ase_cint_t c);
sse_bool_t (*is_cntrl) (sse_cint_t c); ase_bool_t (*is_cntrl) (ase_cint_t c);
sse_bool_t (*is_punct) (sse_cint_t c); ase_bool_t (*is_punct) (ase_cint_t c);
sse_cint_t (*to_upper) (sse_cint_t c); ase_cint_t (*to_upper) (ase_cint_t c);
sse_cint_t (*to_lower) (sse_cint_t c); ase_cint_t (*to_lower) (ase_cint_t c);
/* utilities */ /* utilities */
void* (*memcpy) (void* dst, const void* src, sse_size_t n); void* (*memcpy) (void* dst, const void* src, ase_size_t n);
void* (*memset) (void* dst, int val, sse_size_t n); void* (*memset) (void* dst, int val, ase_size_t n);
int (*sprintf) (sse_char_t* buf, sse_size_t size, sse_char_t* fmt, ...); int (*sprintf) (ase_char_t* buf, ase_size_t size, ase_char_t* fmt, ...);
int (*dprintf) (sse_char_t* fmt, ...); int (*dprintf) (ase_char_t* fmt, ...);
void (*abort) (void); void (*abort) (void);
void* custom_data; void* custom_data;
}; };
struct sse_awk_srcios_t struct ase_awk_srcios_t
{ {
sse_awk_io_t in; ase_awk_io_t in;
sse_awk_io_t out; ase_awk_io_t out;
void* custom_data; void* custom_data;
}; };
struct sse_awk_runios_t struct ase_awk_runios_t
{ {
sse_awk_io_t pipe; ase_awk_io_t pipe;
sse_awk_io_t coproc; ase_awk_io_t coproc;
sse_awk_io_t file; ase_awk_io_t file;
sse_awk_io_t console; ase_awk_io_t console;
void* custom_data; void* custom_data;
}; };
struct sse_awk_runcbs_t struct ase_awk_runcbs_t
{ {
void (*on_start) (sse_awk_t* awk, void* handle, void* arg); void (*on_start) (ase_awk_t* awk, void* handle, void* arg);
void (*on_end) (sse_awk_t* awk, void* handle, int errnum, void* arg); void (*on_end) (ase_awk_t* awk, void* handle, int errnum, void* arg);
void* custom_data; void* custom_data;
}; };
struct sse_awk_runarg_t struct ase_awk_runarg_t
{ {
const sse_char_t* ptr; const ase_char_t* ptr;
sse_size_t len; ase_size_t len;
}; };
/* io function commands */ /* io function commands */
enum enum
{ {
SSE_AWK_IO_OPEN = 0, ASE_AWK_IO_OPEN = 0,
SSE_AWK_IO_CLOSE = 1, ASE_AWK_IO_CLOSE = 1,
SSE_AWK_IO_READ = 2, ASE_AWK_IO_READ = 2,
SSE_AWK_IO_WRITE = 3, ASE_AWK_IO_WRITE = 3,
SSE_AWK_IO_FLUSH = 4, ASE_AWK_IO_FLUSH = 4,
SSE_AWK_IO_NEXT = 5 ASE_AWK_IO_NEXT = 5
}; };
enum enum
{ {
SSE_AWK_IO_PIPE_READ = 0, ASE_AWK_IO_PIPE_READ = 0,
SSE_AWK_IO_PIPE_WRITE = 1, ASE_AWK_IO_PIPE_WRITE = 1,
SSE_AWK_IO_FILE_READ = 0, ASE_AWK_IO_FILE_READ = 0,
SSE_AWK_IO_FILE_WRITE = 1, ASE_AWK_IO_FILE_WRITE = 1,
SSE_AWK_IO_FILE_APPEND = 2, ASE_AWK_IO_FILE_APPEND = 2,
SSE_AWK_IO_CONSOLE_READ = 0, ASE_AWK_IO_CONSOLE_READ = 0,
SSE_AWK_IO_CONSOLE_WRITE = 1 ASE_AWK_IO_CONSOLE_WRITE = 1
}; };
/* various options */ /* various options */
enum enum
{ {
/* allow undeclared variables */ /* allow undeclared variables */
SSE_AWK_IMPLICIT = (1 << 0), ASE_AWK_IMPLICIT = (1 << 0),
/* variable requires explicit declaration */ /* variable requires explicit declaration */
SSE_AWK_EXPLICIT = (1 << 1), ASE_AWK_EXPLICIT = (1 << 1),
/* a function name should not coincide to be a variable name */ /* a function name should not coincide to be a variable name */
SSE_AWK_UNIQUE = (1 << 2), ASE_AWK_UNIQUE = (1 << 2),
/* allow variable shading */ /* allow variable shading */
SSE_AWK_SHADING = (1 << 3), ASE_AWK_SHADING = (1 << 3),
/* support shift operators */ /* support shift operators */
SSE_AWK_SHIFT = (1 << 4), ASE_AWK_SHIFT = (1 << 4),
/* support comments by a hash sign */ /* support comments by a hash sign */
SSE_AWK_HASHSIGN = (1 << 5), ASE_AWK_HASHSIGN = (1 << 5),
/* support comments by double slashes */ /* support comments by double slashes */
SSE_AWK_DBLSLASHES = (1 << 6), ASE_AWK_DBLSLASHES = (1 << 6),
/* support string concatenation in tokenization. /* support string concatenation in tokenization.
* this option can change the behavior of a certain construct. * this option can change the behavior of a certain construct.
* getline < "abc" ".def" is treated as if it is getline < "abc.def" * getline < "abc" ".def" is treated as if it is getline < "abc.def"
* when this option is on. If this option is off, the same expression * when this option is on. If this option is off, the same expression
* is treated as if it is (getline < "abc") ".def". */ * is treated as if it is (getline < "abc") ".def". */
SSE_AWK_STRCONCAT = (1 << 7), ASE_AWK_STRCONCAT = (1 << 7),
/* support getline and print */ /* support getline and print */
SSE_AWK_EXTIO = (1 << 8), ASE_AWK_EXTIO = (1 << 8),
/* support blockless patterns */ /* support blockless patterns */
SSE_AWK_BLOCKLESS = (1 << 9), ASE_AWK_BLOCKLESS = (1 << 9),
/* execution starts from main */ /* execution starts from main */
SSE_AWK_RUNMAIN = (1 << 10), ASE_AWK_RUNMAIN = (1 << 10),
/* use 1 as the start index for string operations */ /* use 1 as the start index for string operations */
SSE_AWK_STRINDEXONE = (1 << 11), ASE_AWK_STRINDEXONE = (1 << 11),
/* strip off leading and trailing spaces when splitting a record /* strip off leading and trailing spaces when splitting a record
* into fields with a regular expression. * into fields with a regular expression.
@ -191,228 +191,228 @@ enum
* The program splits " a b c " into [a], [b], [c] when this * The program splits " a b c " into [a], [b], [c] when this
* option is on while into [], [a], [b], [c], [] when it is off. * option is on while into [], [a], [b], [c], [] when it is off.
*/ */
SSE_AWK_STRIPSPACES = (1 << 12), ASE_AWK_STRIPSPACES = (1 << 12),
/* a newline terminates a statement */ /* a newline terminates a statement */
SSE_AWK_NEWLINE = (1 << 13) ASE_AWK_NEWLINE = (1 << 13)
}; };
/* error code */ /* error code */
enum enum
{ {
SSE_AWK_ENOERR, /* no error */ ASE_AWK_ENOERR, /* no error */
SSE_AWK_ENOMEM, /* out of memory */ ASE_AWK_ENOMEM, /* out of memory */
SSE_AWK_EINVAL, /* invalid parameter */ ASE_AWK_EINVAL, /* invalid parameter */
SSE_AWK_ERUNTIME, /* run-time error */ ASE_AWK_ERUNTIME, /* run-time error */
SSE_AWK_ERUNNING, /* there are running instances */ ASE_AWK_ERUNNING, /* there are running instances */
SSE_AWK_ETOOMANYRUNS, /* too many running instances */ ASE_AWK_ETOOMANYRUNS, /* too many running instances */
SSE_AWK_ERECURSION, /* recursion too deep */ ASE_AWK_ERECURSION, /* recursion too deep */
SSE_AWK_ESRCINOPEN, ASE_AWK_ESRCINOPEN,
SSE_AWK_ESRCINCLOSE, ASE_AWK_ESRCINCLOSE,
SSE_AWK_ESRCINREAD, ASE_AWK_ESRCINREAD,
SSE_AWK_ESRCOUTOPEN, ASE_AWK_ESRCOUTOPEN,
SSE_AWK_ESRCOUTCLOSE, ASE_AWK_ESRCOUTCLOSE,
SSE_AWK_ESRCOUTWRITE, ASE_AWK_ESRCOUTWRITE,
SSE_AWK_ECONINOPEN, ASE_AWK_ECONINOPEN,
SSE_AWK_ECONINCLOSE, ASE_AWK_ECONINCLOSE,
SSE_AWK_ECONINNEXT, ASE_AWK_ECONINNEXT,
SSE_AWK_ECONINDATA, ASE_AWK_ECONINDATA,
SSE_AWK_ECONOUTOPEN, ASE_AWK_ECONOUTOPEN,
SSE_AWK_ECONOUTCLOSE, ASE_AWK_ECONOUTCLOSE,
SSE_AWK_ECONOUTNEXT, ASE_AWK_ECONOUTNEXT,
SSE_AWK_ECONOUTDATA, ASE_AWK_ECONOUTDATA,
SSE_AWK_ELXCHR, /* lexer came accross an wrong character */ ASE_AWK_ELXCHR, /* lexer came accross an wrong character */
SSE_AWK_ELXUNG, /* lexer failed to unget a character */ ASE_AWK_ELXUNG, /* lexer failed to unget a character */
SSE_AWK_EENDSRC, /* unexpected end of source */ ASE_AWK_EENDSRC, /* unexpected end of source */
SSE_AWK_EENDCOMMENT, /* unexpected end of a comment */ ASE_AWK_EENDCOMMENT, /* unexpected end of a comment */
SSE_AWK_EENDSTR, /* unexpected end of a string */ ASE_AWK_EENDSTR, /* unexpected end of a string */
SSE_AWK_EENDREX, /* unexpected end of a regular expression */ ASE_AWK_EENDREX, /* unexpected end of a regular expression */
SSE_AWK_ELBRACE, /* left brace expected */ ASE_AWK_ELBRACE, /* left brace expected */
SSE_AWK_ELPAREN, /* left parenthesis expected */ ASE_AWK_ELPAREN, /* left parenthesis expected */
SSE_AWK_ERPAREN, /* right parenthesis expected */ ASE_AWK_ERPAREN, /* right parenthesis expected */
SSE_AWK_ERBRACK, /* right bracket expected */ ASE_AWK_ERBRACK, /* right bracket expected */
SSE_AWK_ECOMMA, /* comma expected */ ASE_AWK_ECOMMA, /* comma expected */
SSE_AWK_ESEMICOLON, /* semicolon expected */ ASE_AWK_ESEMICOLON, /* semicolon expected */
SSE_AWK_ECOLON, /* colon expected */ ASE_AWK_ECOLON, /* colon expected */
SSE_AWK_EIN, /* keyword 'in' is expected */ ASE_AWK_EIN, /* keyword 'in' is expected */
SSE_AWK_ENOTVAR, /* not a variable name after 'in' */ ASE_AWK_ENOTVAR, /* not a variable name after 'in' */
SSE_AWK_EEXPRESSION, /* expression expected */ ASE_AWK_EEXPRESSION, /* expression expected */
SSE_AWK_EWHILE, /* keyword 'while' is expected */ ASE_AWK_EWHILE, /* keyword 'while' is expected */
SSE_AWK_EASSIGNMENT, /* assignment statement expected */ ASE_AWK_EASSIGNMENT, /* assignment statement expected */
SSE_AWK_EIDENT, /* identifier expected */ ASE_AWK_EIDENT, /* identifier expected */
SSE_AWK_EBEGINBLOCK, /* BEGIN requires an action block */ ASE_AWK_EBEGINBLOCK, /* BEGIN requires an action block */
SSE_AWK_EENDBLOCK, /* END requires an action block */ ASE_AWK_EENDBLOCK, /* END requires an action block */
SSE_AWK_EDUPBEGIN, /* duplicate BEGIN */ ASE_AWK_EDUPBEGIN, /* duplicate BEGIN */
SSE_AWK_EDUPEND, /* duplicate END */ ASE_AWK_EDUPEND, /* duplicate END */
SSE_AWK_EDUPFUNC, /* duplicate function name */ ASE_AWK_EDUPFUNC, /* duplicate function name */
SSE_AWK_EDUPPARAM, /* duplicate parameter name */ ASE_AWK_EDUPPARAM, /* duplicate parameter name */
SSE_AWK_EDUPVAR, /* duplicate variable name */ ASE_AWK_EDUPVAR, /* duplicate variable name */
SSE_AWK_EDUPNAME, /* duplicate name - function, variable, etc */ ASE_AWK_EDUPNAME, /* duplicate name - function, variable, etc */
SSE_AWK_EUNDEF, /* undefined identifier */ ASE_AWK_EUNDEF, /* undefined identifier */
SSE_AWK_ELVALUE, /* l-value required */ ASE_AWK_ELVALUE, /* l-value required */
SSE_AWK_ETOOFEWARGS, /* too few arguments */ ASE_AWK_ETOOFEWARGS, /* too few arguments */
SSE_AWK_ETOOMANYARGS, /* too many arguments */ ASE_AWK_ETOOMANYARGS, /* too many arguments */
SSE_AWK_ETOOMANYGLOBALS, /* too many global variables */ ASE_AWK_ETOOMANYGLOBALS, /* too many global variables */
SSE_AWK_ETOOMANYLOCALS, /* too many local variables */ ASE_AWK_ETOOMANYLOCALS, /* too many local variables */
SSE_AWK_ETOOMANYPARAMS, /* too many parameters */ ASE_AWK_ETOOMANYPARAMS, /* too many parameters */
SSE_AWK_EBREAK, /* break outside a loop */ ASE_AWK_EBREAK, /* break outside a loop */
SSE_AWK_ECONTINUE, /* continue outside a loop */ ASE_AWK_ECONTINUE, /* continue outside a loop */
SSE_AWK_ENEXT, /* next illegal in BEGIN or END block */ ASE_AWK_ENEXT, /* next illegal in BEGIN or END block */
SSE_AWK_ENEXTFILE, /* nextfile illegal in BEGIN or END block */ ASE_AWK_ENEXTFILE, /* nextfile illegal in BEGIN or END block */
SSE_AWK_EGETLINE, /* getline expected */ ASE_AWK_EGETLINE, /* getline expected */
/* run time error */ /* run time error */
SSE_AWK_EDIVBYZERO, /* divide by zero */ ASE_AWK_EDIVBYZERO, /* divide by zero */
SSE_AWK_EOPERAND, /* invalid operand */ ASE_AWK_EOPERAND, /* invalid operand */
SSE_AWK_EPOSIDX, /* wrong position index */ ASE_AWK_EPOSIDX, /* wrong position index */
SSE_AWK_ENOSUCHFUNC, /* no such function */ ASE_AWK_ENOSUCHFUNC, /* no such function */
SSE_AWK_ENOTASSIGNABLE, /* value not assignable */ ASE_AWK_ENOTASSIGNABLE, /* value not assignable */
SSE_AWK_ENOTINDEXABLE, /* not indexable variable */ ASE_AWK_ENOTINDEXABLE, /* not indexable variable */
SSE_AWK_ENOTDELETABLE, /* not deletable variable */ ASE_AWK_ENOTDELETABLE, /* not deletable variable */
SSE_AWK_ENOTREFERENCEABLE, /* not referenceable value */ ASE_AWK_ENOTREFERENCEABLE, /* not referenceable value */
SSE_AWK_EIDXVALASSMAP, /* indexed value cannot be assigned a map */ ASE_AWK_EIDXVALASSMAP, /* indexed value cannot be assigned a map */
SSE_AWK_EPOSVALASSMAP, /* a positional cannot be assigned a map */ ASE_AWK_EPOSVALASSMAP, /* a positional cannot be assigned a map */
SSE_AWK_EMAPTOSCALAR, /* cannot change a map to a scalar value */ ASE_AWK_EMAPTOSCALAR, /* cannot change a map to a scalar value */
SSE_AWK_ESCALARTOMAP, /* cannot change a scalar value to a map */ ASE_AWK_ESCALARTOMAP, /* cannot change a scalar value to a map */
SSE_AWK_EMAPNOTALLOWED, /* a map is not allowed */ ASE_AWK_EMAPNOTALLOWED, /* a map is not allowed */
SSE_AWK_EVALTYPE, /* wrong value type */ ASE_AWK_EVALTYPE, /* wrong value type */
SSE_AWK_EPIPE, /* pipe operation error */ ASE_AWK_EPIPE, /* pipe operation error */
SSE_AWK_ENEXTCALL, /* next called from BEGIN or END */ ASE_AWK_ENEXTCALL, /* next called from BEGIN or END */
SSE_AWK_ENEXTFILECALL, /* nextfile called from BEGIN or END */ ASE_AWK_ENEXTFILECALL, /* nextfile called from BEGIN or END */
SSE_AWK_EIOIMPL, /* wrong implementation of user io handler */ ASE_AWK_EIOIMPL, /* wrong implementation of user io handler */
SSE_AWK_ENOSUCHIO, /* no such io name found */ ASE_AWK_ENOSUCHIO, /* no such io name found */
SSE_AWK_EIOHANDLER, /* io handler has returned an error */ ASE_AWK_EIOHANDLER, /* io handler has returned an error */
SSE_AWK_EINTERNAL, /* internal error */ ASE_AWK_EINTERNAL, /* internal error */
/* regular expression error */ /* regular expression error */
SSE_AWK_EREXRPAREN, /* a right parenthesis is expected */ ASE_AWK_EREXRPAREN, /* a right parenthesis is expected */
SSE_AWK_EREXRBRACKET, /* a right bracket is expected */ ASE_AWK_EREXRBRACKET, /* a right bracket is expected */
SSE_AWK_EREXRBRACE, /* a right brace is expected */ ASE_AWK_EREXRBRACE, /* a right brace is expected */
SSE_AWK_EREXCOLON, /* a colon is expected */ ASE_AWK_EREXCOLON, /* a colon is expected */
SSE_AWK_EREXCRANGE, /* invalid character range */ ASE_AWK_EREXCRANGE, /* invalid character range */
SSE_AWK_EREXCCLASS, /* invalid character class */ ASE_AWK_EREXCCLASS, /* invalid character class */
SSE_AWK_EREXBRANGE, /* invalid boundary range */ ASE_AWK_EREXBRANGE, /* invalid boundary range */
SSE_AWK_EREXEND, /* unexpected end of the pattern */ ASE_AWK_EREXEND, /* unexpected end of the pattern */
SSE_AWK_EREXGARBAGE /* garbage after the pattern */ ASE_AWK_EREXGARBAGE /* garbage after the pattern */
}; };
/* extio types */ /* extio types */
enum enum
{ {
/* extio types available */ /* extio types available */
SSE_AWK_EXTIO_PIPE, ASE_AWK_EXTIO_PIPE,
SSE_AWK_EXTIO_COPROC, ASE_AWK_EXTIO_COPROC,
SSE_AWK_EXTIO_FILE, ASE_AWK_EXTIO_FILE,
SSE_AWK_EXTIO_CONSOLE, ASE_AWK_EXTIO_CONSOLE,
/* reserved for internal use only */ /* reserved for internal use only */
SSE_AWK_EXTIO_NUM ASE_AWK_EXTIO_NUM
}; };
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
sse_awk_t* sse_awk_open (const sse_awk_syscas_t* syscas); ase_awk_t* ase_awk_open (const ase_awk_syscas_t* syscas);
int sse_awk_close (sse_awk_t* awk); int ase_awk_close (ase_awk_t* awk);
int sse_awk_clear (sse_awk_t* awk); int ase_awk_clear (ase_awk_t* awk);
int sse_awk_geterrnum (sse_awk_t* awk); int ase_awk_geterrnum (ase_awk_t* awk);
sse_size_t sse_awk_getsrcline (sse_awk_t* awk); ase_size_t ase_awk_getsrcline (ase_awk_t* awk);
int sse_awk_getopt (sse_awk_t* awk); int ase_awk_getopt (ase_awk_t* awk);
void sse_awk_setopt (sse_awk_t* awk, int opt); void ase_awk_setopt (ase_awk_t* awk, int opt);
int sse_awk_parse (sse_awk_t* awk, sse_awk_srcios_t* srcios); int ase_awk_parse (ase_awk_t* awk, ase_awk_srcios_t* srcios);
/* /*
* sse_awk_run return 0 on success and -1 on failure, generally speaking. * ase_awk_run return 0 on success and -1 on failure, generally speaking.
* A runtime context is required for it to start running the program. * A runtime context is required for it to start running the program.
* Once the runtime context is created, the program starts to run. * Once the runtime context is created, the program starts to run.
* The context creation failure is reported by the return value -1 of * The context creation failure is reported by the return value -1 of
* this function. however, the runtime error after the context creation * this function. however, the runtime error after the context creation
* is reported differently depending on the use of the callback. * is reported differently depending on the use of the callback.
* When no callback is specified (i.e. runcbs is SSE_NULL), sse_awk_run * When no callback is specified (i.e. runcbs is ASE_NULL), ase_awk_run
* returns -1 on an error and awk->errnum is set accordingly. * returns -1 on an error and awk->errnum is set accordingly.
* However, if a callback is specified (i.e. runcbs is not SSE_NULL), * However, if a callback is specified (i.e. runcbs is not ASE_NULL),
* sse_awk_run returns 0 on both success and failure. Instead, the * ase_awk_run returns 0 on both success and failure. Instead, the
* on_end handler of the callback is triggered with the relevant * on_end handler of the callback is triggered with the relevant
* error number. The third parameter to on_end denotes this error number. * error number. The third parameter to on_end denotes this error number.
*/ */
int sse_awk_run (sse_awk_t* awk, int ase_awk_run (ase_awk_t* awk,
sse_awk_runios_t* runios, ase_awk_runios_t* runios,
sse_awk_runcbs_t* runcbs, ase_awk_runcbs_t* runcbs,
sse_awk_runarg_t* runarg); ase_awk_runarg_t* runarg);
int sse_awk_stop (sse_awk_t* awk, sse_awk_run_t* run); int ase_awk_stop (ase_awk_t* awk, ase_awk_run_t* run);
void sse_awk_stopall (sse_awk_t* awk); void ase_awk_stopall (ase_awk_t* awk);
/* functions to access internal stack structure */ /* functions to access internal stack structure */
sse_size_t sse_awk_getnargs (sse_awk_run_t* run); ase_size_t ase_awk_getnargs (ase_awk_run_t* run);
sse_awk_val_t* sse_awk_getarg (sse_awk_run_t* run, sse_size_t idx); ase_awk_val_t* ase_awk_getarg (ase_awk_run_t* run, ase_size_t idx);
sse_awk_val_t* sse_awk_getglobal (sse_awk_run_t* run, sse_size_t idx); ase_awk_val_t* ase_awk_getglobal (ase_awk_run_t* run, ase_size_t idx);
int sse_awk_setglobal (sse_awk_run_t* run, sse_size_t idx, sse_awk_val_t* val); int ase_awk_setglobal (ase_awk_run_t* run, ase_size_t idx, ase_awk_val_t* val);
void sse_awk_setretval (sse_awk_run_t* run, sse_awk_val_t* val); void ase_awk_setretval (ase_awk_run_t* run, ase_awk_val_t* val);
int sse_awk_setconsolename ( int ase_awk_setconsolename (
sse_awk_run_t* run, const sse_char_t* name, sse_size_t len); ase_awk_run_t* run, const ase_char_t* name, ase_size_t len);
int sse_awk_getrunerrnum (sse_awk_run_t* run); int ase_awk_getrunerrnum (ase_awk_run_t* run);
void sse_awk_setrunerrnum (sse_awk_run_t* run, int errnum); void ase_awk_setrunerrnum (ase_awk_run_t* run, int errnum);
/* record and field functions */ /* record and field functions */
int sse_awk_clrrec (sse_awk_run_t* run, sse_bool_t skip_inrec_line); int ase_awk_clrrec (ase_awk_run_t* run, ase_bool_t skip_inrec_line);
int sse_awk_setrec (sse_awk_run_t* run, sse_size_t idx, const sse_char_t* str, sse_size_t len); int ase_awk_setrec (ase_awk_run_t* run, ase_size_t idx, const ase_char_t* str, ase_size_t len);
/* utility functions exported by awk.h */ /* utility functions exported by awk.h */
sse_long_t sse_awk_strxtolong ( ase_long_t ase_awk_strxtolong (
sse_awk_t* awk, const sse_char_t* str, sse_size_t len, ase_awk_t* awk, const ase_char_t* str, ase_size_t len,
int base, const sse_char_t** endptr); int base, const ase_char_t** endptr);
sse_real_t sse_awk_strxtoreal ( ase_real_t ase_awk_strxtoreal (
sse_awk_t* awk, const sse_char_t* str, sse_size_t len, ase_awk_t* awk, const ase_char_t* str, ase_size_t len,
const sse_char_t** endptr); const ase_char_t** endptr);
sse_size_t sse_awk_longtostr ( ase_size_t ase_awk_longtostr (
sse_long_t value, int radix, const sse_char_t* prefix, ase_long_t value, int radix, const ase_char_t* prefix,
sse_char_t* buf, sse_size_t size); ase_char_t* buf, ase_size_t size);
/* string functions exported by awk.h */ /* string functions exported by awk.h */
sse_char_t* sse_awk_strdup ( ase_char_t* ase_awk_strdup (
sse_awk_t* awk, const sse_char_t* str); ase_awk_t* awk, const ase_char_t* str);
sse_char_t* sse_awk_strxdup ( ase_char_t* ase_awk_strxdup (
sse_awk_t* awk, const sse_char_t* str, sse_size_t len); ase_awk_t* awk, const ase_char_t* str, ase_size_t len);
sse_char_t* sse_awk_strxdup2 ( ase_char_t* ase_awk_strxdup2 (
sse_awk_t* awk, ase_awk_t* awk,
const sse_char_t* str1, sse_size_t len1, const ase_char_t* str1, ase_size_t len1,
const sse_char_t* str2, sse_size_t len2); const ase_char_t* str2, ase_size_t len2);
sse_size_t sse_awk_strlen (const sse_char_t* str); ase_size_t ase_awk_strlen (const ase_char_t* str);
sse_size_t sse_awk_strcpy (sse_char_t* buf, const sse_char_t* str); ase_size_t ase_awk_strcpy (ase_char_t* buf, const ase_char_t* str);
sse_size_t sse_awk_strncpy (sse_char_t* buf, const sse_char_t* str, sse_size_t len); ase_size_t ase_awk_strncpy (ase_char_t* buf, const ase_char_t* str, ase_size_t len);
int sse_awk_strcmp (const sse_char_t* s1, const sse_char_t* s2); int ase_awk_strcmp (const ase_char_t* s1, const ase_char_t* s2);
int sse_awk_strxncmp ( int ase_awk_strxncmp (
const sse_char_t* s1, sse_size_t len1, const ase_char_t* s1, ase_size_t len1,
const sse_char_t* s2, sse_size_t len2); const ase_char_t* s2, ase_size_t len2);
int sse_awk_strxncasecmp ( int ase_awk_strxncasecmp (
sse_awk_t* awk, ase_awk_t* awk,
const sse_char_t* s1, sse_size_t len1, const ase_char_t* s1, ase_size_t len1,
const sse_char_t* s2, sse_size_t len2); const ase_char_t* s2, ase_size_t len2);
sse_char_t* sse_awk_strxnstr ( ase_char_t* ase_awk_strxnstr (
const sse_char_t* str, sse_size_t strsz, const ase_char_t* str, ase_size_t strsz,
const sse_char_t* sub, sse_size_t subsz); const ase_char_t* sub, ase_size_t subsz);
/* utility functions to convert an error number ot a string */ /* utility functions to convert an error number ot a string */
const sse_char_t* sse_awk_geterrstr (int errnum); const ase_char_t* ase_awk_geterrstr (int errnum);
#ifdef __cplusplus #ifdef __cplusplus
} }

250
ase/awk/awk_i.h
View File

@ -1,107 +1,107 @@
/* /*
* $Id: awk_i.h,v 1.71 2006-10-23 14:44:42 bacon Exp $ * $Id: awk_i.h,v 1.72 2006-10-24 04:10:12 bacon Exp $
*/ */
#ifndef _SSE_AWK_AWKI_H_ #ifndef _ASE_AWK_AWKI_H_
#define _SSE_AWK_AWKI_H_ #define _ASE_AWK_AWKI_H_
typedef struct sse_awk_chain_t sse_awk_chain_t; typedef struct ase_awk_chain_t ase_awk_chain_t;
typedef struct sse_awk_tree_t sse_awk_tree_t; typedef struct ase_awk_tree_t ase_awk_tree_t;
#include <sse/awk/awk.h> #include <ase/awk/awk.h>
#include <sse/awk/str.h> #include <ase/awk/str.h>
#include <sse/awk/rex.h> #include <ase/awk/rex.h>
#include <sse/awk/map.h> #include <ase/awk/map.h>
#include <sse/awk/tree.h> #include <ase/awk/tree.h>
#include <sse/awk/val.h> #include <ase/awk/val.h>
#include <sse/awk/func.h> #include <ase/awk/func.h>
#include <sse/awk/tab.h> #include <ase/awk/tab.h>
#include <sse/awk/parse.h> #include <ase/awk/parse.h>
#include <sse/awk/run.h> #include <ase/awk/run.h>
#include <sse/awk/extio.h> #include <ase/awk/extio.h>
#include <sse/awk/misc.h> #include <ase/awk/misc.h>
#ifdef NDEBUG #ifdef NDEBUG
#define sse_awk_assert(awk,expr) ((void)0) #define ase_awk_assert(awk,expr) ((void)0)
#else #else
#define sse_awk_assert(awk,expr) (void)((expr) || \ #define ase_awk_assert(awk,expr) (void)((expr) || \
(sse_awk_abort(awk, SSE_T(#expr), SSE_T(__FILE__), __LINE__), 0)) (ase_awk_abort(awk, ASE_T(#expr), ASE_T(__FILE__), __LINE__), 0))
#endif #endif
#ifdef _MSC_VER #ifdef _MSC_VER
#pragma warning (disable: 4996) #pragma warning (disable: 4996)
#endif #endif
#define SSE_AWK_MAX_GLOBALS 9999 #define ASE_AWK_MAX_GLOBALS 9999
#define SSE_AWK_MAX_LOCALS 9999 #define ASE_AWK_MAX_LOCALS 9999
#define SSE_AWK_MAX_PARAMS 9999 #define ASE_AWK_MAX_PARAMS 9999
#if defined(_WIN32) && defined(_DEBUG) #if defined(_WIN32) && defined(_DEBUG)
#define _CRTDBG_MAP_ALLOC #define _CRTDBG_MAP_ALLOC
#include <crtdbg.h> #include <crtdbg.h>
#define SSE_AWK_MALLOC(awk,size) malloc (size) #define ASE_AWK_MALLOC(awk,size) malloc (size)
#define SSE_AWK_REALLOC(awk,ptr,size) realloc (ptr, size) #define ASE_AWK_REALLOC(awk,ptr,size) realloc (ptr, size)
#define SSE_AWK_FREE(awk,ptr) free (ptr) #define ASE_AWK_FREE(awk,ptr) free (ptr)
#else #else
#define SSE_AWK_MALLOC(awk,size) \ #define ASE_AWK_MALLOC(awk,size) \
(awk)->syscas.malloc (size, (awk)->syscas.custom_data) (awk)->syscas.malloc (size, (awk)->syscas.custom_data)
#define SSE_AWK_REALLOC(awk,ptr,size) \ #define ASE_AWK_REALLOC(awk,ptr,size) \
(awk)->syscas.realloc (ptr, size, (awk)->syscas.custom_data) (awk)->syscas.realloc (ptr, size, (awk)->syscas.custom_data)
#define SSE_AWK_FREE(awk,ptr) \ #define ASE_AWK_FREE(awk,ptr) \
(awk)->syscas.free (ptr, (awk)->syscas.custom_data) (awk)->syscas.free (ptr, (awk)->syscas.custom_data)
#endif #endif
#define SSE_AWK_LOCK(awk) \ #define ASE_AWK_LOCK(awk) \
do { \ do { \
if ((awk)->syscas.lock != SSE_NULL) \ if ((awk)->syscas.lock != ASE_NULL) \
(awk)->syscas.lock (awk, (awk)->syscas.custom_data); \ (awk)->syscas.lock (awk, (awk)->syscas.custom_data); \
} while (0) } while (0)
#define SSE_AWK_UNLOCK(awk) \ #define ASE_AWK_UNLOCK(awk) \
do { \ do { \
if ((awk)->syscas.unlock != SSE_NULL) \ if ((awk)->syscas.unlock != ASE_NULL) \
(awk)->syscas.unlock (awk, (awk)->syscas.custom_data); \ (awk)->syscas.unlock (awk, (awk)->syscas.custom_data); \
} while (0) } while (0)
#define SSE_AWK_ISUPPER(awk,c) (awk)->syscas.is_upper(c) #define ASE_AWK_ISUPPER(awk,c) (awk)->syscas.is_upper(c)
#define SSE_AWK_ISLOWER(awk,c) (awk)->syscas.is_lower(c) #define ASE_AWK_ISLOWER(awk,c) (awk)->syscas.is_lower(c)
#define SSE_AWK_ISALPHA(awk,c) (awk)->syscas.is_alpha(c) #define ASE_AWK_ISALPHA(awk,c) (awk)->syscas.is_alpha(c)
#define SSE_AWK_ISDIGIT(awk,c) (awk)->syscas.is_digit(c) #define ASE_AWK_ISDIGIT(awk,c) (awk)->syscas.is_digit(c)
#define SSE_AWK_ISXDIGIT(awk,c) (awk)->syscas.is_xdigit(c) #define ASE_AWK_ISXDIGIT(awk,c) (awk)->syscas.is_xdigit(c)
#define SSE_AWK_ISALNUM(awk,c) (awk)->syscas.is_alnum(c) #define ASE_AWK_ISALNUM(awk,c) (awk)->syscas.is_alnum(c)
#define SSE_AWK_ISSPACE(awk,c) (awk)->syscas.is_space(c) #define ASE_AWK_ISSPACE(awk,c) (awk)->syscas.is_space(c)
#define SSE_AWK_ISPRINT(awk,c) (awk)->syscas.is_print(c) #define ASE_AWK_ISPRINT(awk,c) (awk)->syscas.is_print(c)
#define SSE_AWK_ISGRAPH(awk,c) (awk)->syscas.is_graph(c) #define ASE_AWK_ISGRAPH(awk,c) (awk)->syscas.is_graph(c)
#define SSE_AWK_ISCNTRL(awk,c) (awk)->syscas.is_cntrl(c) #define ASE_AWK_ISCNTRL(awk,c) (awk)->syscas.is_cntrl(c)
#define SSE_AWK_ISPUNCT(awk,c) (awk)->syscas.is_punct(c) #define ASE_AWK_ISPUNCT(awk,c) (awk)->syscas.is_punct(c)
#define SSE_AWK_TOUPPER(awk,c) (awk)->syscas.to_upper(c) #define ASE_AWK_TOUPPER(awk,c) (awk)->syscas.to_upper(c)
#define SSE_AWK_TOLOWER(awk,c) (awk)->syscas.to_lower(c) #define ASE_AWK_TOLOWER(awk,c) (awk)->syscas.to_lower(c)
#define SSE_AWK_MEMCPY(awk,dst,src,len) (awk)->syscas.memcpy (dst, src, len) #define ASE_AWK_MEMCPY(awk,dst,src,len) (awk)->syscas.memcpy (dst, src, len)
#define SSE_AWK_MEMSET(awk,dst,val,len) (awk)->syscas.memset (dst, val, len) #define ASE_AWK_MEMSET(awk,dst,val,len) (awk)->syscas.memset (dst, val, len)
struct sse_awk_tree_t struct ase_awk_tree_t
{ {
sse_size_t nglobals; /* total number of globals */ ase_size_t nglobals; /* total number of globals */
sse_size_t nbglobals; /* number of builtin globals */ ase_size_t nbglobals; /* number of builtin globals */
sse_awk_map_t afns; /* awk function map */ ase_awk_map_t afns; /* awk function map */
sse_awk_nde_t* begin; ase_awk_nde_t* begin;
sse_awk_nde_t* end; ase_awk_nde_t* end;
sse_awk_chain_t* chain; ase_awk_chain_t* chain;
sse_awk_chain_t* chain_tail; ase_awk_chain_t* chain_tail;
sse_size_t chain_size; /* number of nodes in the chain */ ase_size_t chain_size; /* number of nodes in the chain */
}; };
struct sse_awk_t struct ase_awk_t
{ {
sse_awk_syscas_t syscas; ase_awk_syscas_t syscas;
/* options */ /* options */
int option; int option;
/* parse tree */ /* parse tree */
sse_awk_tree_t tree; ase_awk_tree_t tree;
int state; int state;
/* temporary information that the parser needs */ /* temporary information that the parser needs */
@ -115,13 +115,13 @@ struct sse_awk_t
struct struct
{ {
sse_size_t loop; ase_size_t loop;
} depth; } depth;
sse_awk_tab_t globals; ase_awk_tab_t globals;
sse_awk_tab_t locals; ase_awk_tab_t locals;
sse_awk_tab_t params; ase_awk_tab_t params;
sse_size_t nlocals_max; ase_size_t nlocals_max;
int nl_semicolon; int nl_semicolon;
} parse; } parse;
@ -129,23 +129,23 @@ struct sse_awk_t
/* source code management */ /* source code management */
struct struct
{ {
sse_awk_srcios_t* ios; ase_awk_srcios_t* ios;
struct struct
{ {
sse_cint_t curc; ase_cint_t curc;
sse_cint_t ungotc[5]; ase_cint_t ungotc[5];
sse_size_t ungotc_count; ase_size_t ungotc_count;
sse_size_t line; ase_size_t line;
sse_size_t column; ase_size_t column;
} lex; } lex;
struct struct
{ {
sse_char_t buf[512]; ase_char_t buf[512];
sse_size_t buf_pos; ase_size_t buf_pos;
sse_size_t buf_len; ase_size_t buf_len;
} shared; } shared;
} src; } src;
@ -154,73 +154,73 @@ struct sse_awk_t
{ {
int prev; int prev;
int type; int type;
sse_awk_str_t name; ase_awk_str_t name;
sse_size_t line; ase_size_t line;
sse_size_t column; ase_size_t column;
} token; } token;
/* builtin functions */ /* builtin functions */
struct struct
{ {
sse_awk_bfn_t* sys; ase_awk_bfn_t* sys;
sse_awk_bfn_t* user; ase_awk_bfn_t* user;
} bfn; } bfn;
struct struct
{ {
sse_size_t count; ase_size_t count;
sse_awk_run_t* ptr; ase_awk_run_t* ptr;
} run; } run;
/* housekeeping */ /* housekeeping */
int errnum; int errnum;
}; };
struct sse_awk_chain_t struct ase_awk_chain_t
{ {
sse_awk_nde_t* pattern; ase_awk_nde_t* pattern;
sse_awk_nde_t* action; ase_awk_nde_t* action;
sse_awk_chain_t* next; ase_awk_chain_t* next;
}; };
struct sse_awk_run_t struct ase_awk_run_t
{ {
int id; int id;
sse_awk_map_t named; ase_awk_map_t named;
void** stack; void** stack;
sse_size_t stack_top; ase_size_t stack_top;
sse_size_t stack_base; ase_size_t stack_base;
sse_size_t stack_limit; ase_size_t stack_limit;
int exit_level; int exit_level;
sse_awk_val_int_t* icache[100]; /* TODO: choose the optimal size */ ase_awk_val_int_t* icache[100]; /* TODO: choose the optimal size */
sse_awk_val_real_t* rcache[100]; /* TODO: choose the optimal size */ ase_awk_val_real_t* rcache[100]; /* TODO: choose the optimal size */
sse_awk_val_ref_t* fcache[100]; /* TODO: choose the optimal size */ ase_awk_val_ref_t* fcache[100]; /* TODO: choose the optimal size */
sse_size_t icache_count; ase_size_t icache_count;
sse_size_t rcache_count; ase_size_t rcache_count;
sse_size_t fcache_count; ase_size_t fcache_count;
sse_awk_nde_blk_t* active_block; ase_awk_nde_blk_t* active_block;
sse_byte_t* pattern_range_state; ase_byte_t* pattern_range_state;
struct struct
{ {
sse_char_t buf[1024]; ase_char_t buf[1024];
sse_size_t buf_pos; ase_size_t buf_pos;
sse_size_t buf_len; ase_size_t buf_len;
sse_bool_t eof; ase_bool_t eof;
sse_awk_str_t line; ase_awk_str_t line;
sse_awk_val_t* d0; /* $0 */ ase_awk_val_t* d0; /* $0 */
sse_size_t maxflds; ase_size_t maxflds;
sse_size_t nflds; /* NF */ ase_size_t nflds; /* NF */
struct struct
{ {
sse_char_t* ptr; ase_char_t* ptr;
sse_size_t len; ase_size_t len;
sse_awk_val_t* val; /* $1 .. $NF */ ase_awk_val_t* val; /* $1 .. $NF */
}* flds; }* flds;
} inrec; } inrec;
@ -230,48 +230,48 @@ struct sse_awk_run_t
void* rs; void* rs;
void* fs; void* fs;
int ignorecase; int ignorecase;
sse_size_t fnr; ase_size_t fnr;
struct struct
{ {
sse_char_t* ptr; ase_char_t* ptr;
sse_size_t len; ase_size_t len;
} convfmt; } convfmt;
struct struct
{ {
sse_char_t* ptr; ase_char_t* ptr;
sse_size_t len; ase_size_t len;
} ofmt; } ofmt;
struct struct
{ {
sse_char_t* ptr; ase_char_t* ptr;
sse_size_t len; ase_size_t len;
} ofs; } ofs;
struct struct
{ {
sse_char_t* ptr; ase_char_t* ptr;
sse_size_t len; ase_size_t len;
} ors; } ors;
struct struct
{ {
sse_char_t* ptr; ase_char_t* ptr;
sse_size_t len; ase_size_t len;
} subsep; } subsep;
} global; } global;
/* extio chain */ /* extio chain */
struct struct
{ {
sse_awk_io_t handler[SSE_AWK_EXTIO_NUM]; ase_awk_io_t handler[ASE_AWK_EXTIO_NUM];
void* custom_data; void* custom_data;
sse_awk_extio_t* chain; ase_awk_extio_t* chain;
} extio; } extio;
int errnum; int errnum;
sse_awk_t* awk; ase_awk_t* awk;
sse_awk_run_t* prev; ase_awk_run_t* prev;
sse_awk_run_t* next; ase_awk_run_t* next;
}; };
#endif #endif

194
ase/awk/err.c
View File

@ -1,124 +1,124 @@
/* /*
* $Id: err.c,v 1.44 2006-10-22 12:39:29 bacon Exp $ * $Id: err.c,v 1.45 2006-10-24 04:10:12 bacon Exp $
*/ */
#include <sse/awk/awk_i.h> #include <ase/awk/awk_i.h>
int sse_awk_geterrnum (sse_awk_t* awk) int ase_awk_geterrnum (ase_awk_t* awk)
{ {
return awk->errnum; return awk->errnum;
} }
const sse_char_t* sse_awk_geterrstr (int errnum) const ase_char_t* ase_awk_geterrstr (int errnum)
{ {
static const sse_char_t* __errstr[] = static const ase_char_t* __errstr[] =
{ {
SSE_T("no error"), ASE_T("no error"),
SSE_T("out of memory"), ASE_T("out of memory"),
SSE_T("invalid parameter"), ASE_T("invalid parameter"),
SSE_T("general run-time error"), ASE_T("general run-time error"),
SSE_T("one or more running instances"), ASE_T("one or more running instances"),
SSE_T("too many running instances"), ASE_T("too many running instances"),
SSE_T("recursion too deep"), ASE_T("recursion too deep"),
SSE_T("cannot open source input"), ASE_T("cannot open source input"),
SSE_T("cannot close source input"), ASE_T("cannot close source input"),
SSE_T("cannot read source input"), ASE_T("cannot read source input"),
SSE_T("cannot open source output"), ASE_T("cannot open source output"),
SSE_T("cannot close source output"), ASE_T("cannot close source output"),
SSE_T("cannot write source output"), ASE_T("cannot write source output"),
SSE_T("cannot open console for read"), ASE_T("cannot open console for read"),
SSE_T("cannot close console for read"), ASE_T("cannot close console for read"),
SSE_T("cannot switch to next console for read"), ASE_T("cannot switch to next console for read"),
SSE_T("cannot read from console"), ASE_T("cannot read from console"),
SSE_T("cannot open console for write"), ASE_T("cannot open console for write"),
SSE_T("cannot close console for write"), ASE_T("cannot close console for write"),
SSE_T("cannot switch to next console for write"), ASE_T("cannot switch to next console for write"),
SSE_T("cannot write to console"), ASE_T("cannot write to console"),
SSE_T("invalid character"), ASE_T("invalid character"),
SSE_T("cannot unget character"), ASE_T("cannot unget character"),
SSE_T("unexpected end of source"), ASE_T("unexpected end of source"),
SSE_T("unexpected end of a comment"), ASE_T("unexpected end of a comment"),
SSE_T("unexpected end of a string"), ASE_T("unexpected end of a string"),
SSE_T("unexpected end of a regular expression"), ASE_T("unexpected end of a regular expression"),
SSE_T("left brace expected"), ASE_T("left brace expected"),
SSE_T("left parenthesis expected"), ASE_T("left parenthesis expected"),
SSE_T("right parenthesis expected"), ASE_T("right parenthesis expected"),
SSE_T("right bracket expected"), ASE_T("right bracket expected"),
SSE_T("comma expected"), ASE_T("comma expected"),
SSE_T("semicolon expected"), ASE_T("semicolon expected"),
SSE_T("colon expected"), ASE_T("colon expected"),
SSE_T("keyword 'in' expected"), ASE_T("keyword 'in' expected"),
SSE_T("not a variable after 'in'"), ASE_T("not a variable after 'in'"),
SSE_T("expression expected"), ASE_T("expression expected"),
SSE_T("keyword 'while' expected"), ASE_T("keyword 'while' expected"),
SSE_T("assignment statement expected"), ASE_T("assignment statement expected"),
SSE_T("identifier expected"), ASE_T("identifier expected"),
SSE_T("BEGIN requires an action block"), ASE_T("BEGIN requires an action block"),
SSE_T("END requires an action block"), ASE_T("END requires an action block"),
SSE_T("duplicate BEGIN"), ASE_T("duplicate BEGIN"),
SSE_T("duplicate END"), ASE_T("duplicate END"),
SSE_T("duplicate function name"), ASE_T("duplicate function name"),
SSE_T("duplicate parameter name"), ASE_T("duplicate parameter name"),
SSE_T("duplicate variable name"), ASE_T("duplicate variable name"),
SSE_T("duplicate name"), ASE_T("duplicate name"),
SSE_T("undefined identifier"), ASE_T("undefined identifier"),
SSE_T("l-value required"), ASE_T("l-value required"),
SSE_T("too few arguments"), ASE_T("too few arguments"),
SSE_T("too many arguments"), ASE_T("too many arguments"),
SSE_T("too many global variables"), ASE_T("too many global variables"),
SSE_T("too many local variables"), ASE_T("too many local variables"),
SSE_T("too many parameters"), ASE_T("too many parameters"),
SSE_T("break outside a loop"), ASE_T("break outside a loop"),
SSE_T("continue outside a loop"), ASE_T("continue outside a loop"),
SSE_T("next illegal in BEGIN or END block"), ASE_T("next illegal in BEGIN or END block"),
SSE_T("nextfile illegal in BEGIN or END block"), ASE_T("nextfile illegal in BEGIN or END block"),
SSE_T("getline expected"), ASE_T("getline expected"),
SSE_T("divide by zero"), ASE_T("divide by zero"),
SSE_T("invalid operand"), ASE_T("invalid operand"),
SSE_T("wrong position index"), ASE_T("wrong position index"),
SSE_T("no such function"), ASE_T("no such function"),
SSE_T("value not assignable"), ASE_T("value not assignable"),
SSE_T("variable not indexable"), ASE_T("variable not indexable"),
SSE_T("variable not deletable"), ASE_T("variable not deletable"),
SSE_T("value not referenceable"), ASE_T("value not referenceable"),
SSE_T("an indexed value cannot be assigned a map"), ASE_T("an indexed value cannot be assigned a map"),
SSE_T("a positional value cannot be assigned a map"), ASE_T("a positional value cannot be assigned a map"),
SSE_T("cannot change a map to a scalar value"), ASE_T("cannot change a map to a scalar value"),
SSE_T("cannot change a scalar value to a map"), ASE_T("cannot change a scalar value to a map"),
SSE_T("a map is not allowed"), ASE_T("a map is not allowed"),
SSE_T("wrong value type"), ASE_T("wrong value type"),
SSE_T("pipe operation error"), ASE_T("pipe operation error"),
SSE_T("next cannot be called from the BEGIN or END block"), ASE_T("next cannot be called from the BEGIN or END block"),
SSE_T("nextfile cannot be called from the BEGIN or END block"), ASE_T("nextfile cannot be called from the BEGIN or END block"),
SSE_T("wrong implementation of user-defined io handler"), ASE_T("wrong implementation of user-defined io handler"),
SSE_T("no such io name found"), ASE_T("no such io name found"),
SSE_T("io handler has returned an error"), ASE_T("io handler has returned an error"),
SSE_T("internal error that should never have happened"), ASE_T("internal error that should never have happened"),
SSE_T("a right parenthesis is expected in the regular expression"), ASE_T("a right parenthesis is expected in the regular expression"),
SSE_T("a right bracket is expected in the regular expression"), ASE_T("a right bracket is expected in the regular expression"),
SSE_T("a right brace is expected in the regular expression"), ASE_T("a right brace is expected in the regular expression"),
SSE_T("a colon is expected in the regular expression"), ASE_T("a colon is expected in the regular expression"),
SSE_T("invalid character range in the regular expression"), ASE_T("invalid character range in the regular expression"),
SSE_T("invalid character class in the regular expression"), ASE_T("invalid character class in the regular expression"),
SSE_T("invalid boundary range in the regular expression"), ASE_T("invalid boundary range in the regular expression"),
SSE_T("unexpected end of the regular expression"), ASE_T("unexpected end of the regular expression"),
SSE_T("garbage after the regular expression") ASE_T("garbage after the regular expression")
}; };
if (errnum >= 0 && errnum < sse_countof(__errstr)) if (errnum >= 0 && errnum < ase_countof(__errstr))
{ {
return __errstr[errnum]; return __errstr[errnum];
} }
return SSE_T("unknown error"); return ASE_T("unknown error");
} }

552
ase/awk/extio.c
View File

File diff suppressed because it is too large Load Diff

52
ase/awk/extio.h
View File

@ -1,48 +1,48 @@
/* /*
* $Id: extio.h,v 1.14 2006-10-22 11:34:53 bacon Exp $ * $Id: extio.h,v 1.15 2006-10-24 04:10:12 bacon Exp $
*/ */
#ifndef _SSE_AWK_EXTIO_H_ #ifndef _ASE_AWK_EXTIO_H_
#define _SSE_AWK_EXTIO_H_ #define _ASE_AWK_EXTIO_H_
#ifndef _SSE_AWK_AWK_H_ #ifndef _ASE_AWK_AWK_H_
#error Never include this file directly. Include <sse/awk/awk.h> instead #error Never include this file directly. Include <ase/awk/awk.h> instead
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" extern "C"
#endif #endif
int sse_awk_readextio ( int ase_awk_readextio (
sse_awk_run_t* run, int in_type, ase_awk_run_t* run, int in_type,
const sse_char_t* name, sse_awk_str_t* buf); const ase_char_t* name, ase_awk_str_t* buf);
int sse_awk_writeextio_val ( int ase_awk_writeextio_val (
sse_awk_run_t* run, int out_type, ase_awk_run_t* run, int out_type,
const sse_char_t* name, sse_awk_val_t* v); const ase_char_t* name, ase_awk_val_t* v);
int sse_awk_writeextio_str ( int ase_awk_writeextio_str (
sse_awk_run_t* run, int out_type, ase_awk_run_t* run, int out_type,
const sse_char_t* name, sse_char_t* str, sse_size_t len); const ase_char_t* name, ase_char_t* str, ase_size_t len);
int sse_awk_flushextio ( int ase_awk_flushextio (
sse_awk_run_t* run, int out_type, const sse_char_t* name); ase_awk_run_t* run, int out_type, const ase_char_t* name);
int sse_awk_nextextio_read ( int ase_awk_nextextio_read (
sse_awk_run_t* run, int in_type, const sse_char_t* name); ase_awk_run_t* run, int in_type, const ase_char_t* name);
/* TODO: /* TODO:
int sse_awk_nextextio_write ( int ase_awk_nextextio_write (
sse_awk_run_t* run, int out_type, const sse_char_t* name); ase_awk_run_t* run, int out_type, const ase_char_t* name);
*/ */
int sse_awk_closeextio_read ( int ase_awk_closeextio_read (
sse_awk_run_t* run, int in_type, const sse_char_t* name); ase_awk_run_t* run, int in_type, const ase_char_t* name);
int sse_awk_closeextio_write ( int ase_awk_closeextio_write (
sse_awk_run_t* run, int out_type, const sse_char_t* name); ase_awk_run_t* run, int out_type, const ase_char_t* name);
int sse_awk_closeextio (sse_awk_run_t* run, const sse_char_t* name); int ase_awk_closeextio (ase_awk_run_t* run, const ase_char_t* name);
void sse_awk_clearextio (sse_awk_run_t* run); void ase_awk_clearextio (ase_awk_run_t* run);
#ifdef __cplusplus #ifdef __cplusplus
} }

1114
ase/awk/func.c
View File

File diff suppressed because it is too large Load Diff

54
ase/awk/func.h
View File

@ -1,39 +1,39 @@
/* /*
* $Id: func.h,v 1.13 2006-10-22 11:34:53 bacon Exp $ * $Id: func.h,v 1.14 2006-10-24 04:10:12 bacon Exp $
*/ */
#ifndef _SSE_AWK_FUNC_H_ #ifndef _ASE_AWK_FUNC_H_
#define _SSE_AWK_FUNC_H_ #define _ASE_AWK_FUNC_H_
#ifndef _SSE_AWK_AWK_H_ #ifndef _ASE_AWK_AWK_H_
#error Never include this file directly. Include <sse/awk/awk.h> instead #error Never include this file directly. Include <ase/awk/awk.h> instead
#endif #endif
typedef struct sse_awk_bfn_t sse_awk_bfn_t; typedef struct ase_awk_bfn_t ase_awk_bfn_t;
struct sse_awk_bfn_t struct ase_awk_bfn_t
{ {
const sse_char_t* name; const ase_char_t* name;
sse_size_t name_len; ase_size_t name_len;
int valid; /* the entry is valid when this option is set */ int valid; /* the entry is valid when this option is set */
sse_size_t min_args; ase_size_t min_args;
sse_size_t max_args; ase_size_t max_args;
const sse_char_t* arg_spec; const ase_char_t* arg_spec;
int (*handler) (sse_awk_run_t* run); int (*handler) (ase_awk_run_t* run);
sse_awk_bfn_t* next; ase_awk_bfn_t* next;
}; };
enum enum
{ {
/* ensure that this matches __sys_bfn in func.c */ /* ensure that this matches __sys_bfn in func.c */
SSE_AWK_BFN_CLOSE, ASE_AWK_BFN_CLOSE,
SSE_AWK_BFN_INDEX, ASE_AWK_BFN_INDEX,
SSE_AWK_BFN_LENGTH, ASE_AWK_BFN_LENGTH,
SSE_AWK_BFN_SYSTEM, ASE_AWK_BFN_SYSTEM,
SSE_AWK_BFN_SIN ASE_AWK_BFN_SIN
}; };
@ -41,17 +41,17 @@ enum
extern "C" { extern "C" {
#endif #endif
sse_awk_bfn_t* sse_awk_addbfn ( ase_awk_bfn_t* ase_awk_addbfn (
sse_awk_t* awk, const sse_char_t* name, sse_size_t name_len, ase_awk_t* awk, const ase_char_t* name, ase_size_t name_len,
int when_valid, sse_size_t min_args, sse_size_t max_args, int when_valid, ase_size_t min_args, ase_size_t max_args,
const sse_char_t* arg_spec, int (*handler)(sse_awk_run_t*)); const ase_char_t* arg_spec, int (*handler)(ase_awk_run_t*));
int sse_awk_delbfn (sse_awk_t* awk, const sse_char_t* name, sse_size_t name_len); int ase_awk_delbfn (ase_awk_t* awk, const ase_char_t* name, ase_size_t name_len);
void sse_awk_clrbfn (sse_awk_t* awk); void ase_awk_clrbfn (ase_awk_t* awk);
sse_awk_bfn_t* sse_awk_getbfn ( ase_awk_bfn_t* ase_awk_getbfn (
sse_awk_t* awk, const sse_char_t* name, sse_size_t name_len); ase_awk_t* awk, const ase_char_t* name, ase_size_t name_len);
#ifdef __cplusplus #ifdef __cplusplus
} }

178
ase/awk/jni.c
View File

@ -1,16 +1,16 @@
/* /*
* $Id: jni.c,v 1.14 2006-10-22 12:39:29 bacon Exp $ * $Id: jni.c,v 1.15 2006-10-24 04:10:12 bacon Exp $
*/ */
#include <sse/awk/jni.h> #include <ase/awk/jni.h>
#include <sse/awk/awk.h> #include <ase/awk/awk.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <wctype.h> #include <wctype.h>
#include <wchar.h> #include <wchar.h>
#include <stdio.h> #include <stdio.h>
#define EXCEPTION_AWK "sse/awk/AwkException" #define EXCEPTION_AWK "ase/awk/AwkException"
#define FIELD_AWK "__awk" #define FIELD_AWK "__awk"
enum enum
@ -19,16 +19,16 @@ enum
SOURCE_WRITE = 2 SOURCE_WRITE = 2
}; };
/* TODO: what if sse_char_t is sse_mchar_t??? */ /* TODO: what if ase_char_t is ase_mchar_t??? */
static sse_ssize_t __read_source ( static ase_ssize_t __read_source (
int cmd, void* arg, sse_char_t* data, sse_size_t count); int cmd, void* arg, ase_char_t* data, ase_size_t count);
static sse_ssize_t __write_source ( static ase_ssize_t __write_source (
int cmd, void* arg, sse_char_t* data, sse_size_t count); int cmd, void* arg, ase_char_t* data, ase_size_t count);
static sse_ssize_t __process_extio_console ( static ase_ssize_t __process_extio_console (
int cmd, void* arg, sse_char_t* data, sse_size_t count); int cmd, void* arg, ase_char_t* data, ase_size_t count);
static sse_ssize_t __process_extio_file ( static ase_ssize_t __process_extio_file (
int cmd, void* arg, sse_char_t* data, sse_size_t count); int cmd, void* arg, ase_char_t* data, ase_size_t count);
typedef struct srcio_data_t srcio_data_t; typedef struct srcio_data_t srcio_data_t;
typedef struct runio_data_t runio_data_t; typedef struct runio_data_t runio_data_t;
@ -45,12 +45,12 @@ struct runio_data_t
jobject obj; jobject obj;
}; };
static void* __awk_malloc (sse_size_t n, void* custom_data) static void* __awk_malloc (ase_size_t n, void* custom_data)
{ {
return malloc (n); return malloc (n);
} }
static void* __awk_realloc (void* ptr, sse_size_t n, void* custom_data) static void* __awk_realloc (void* ptr, ase_size_t n, void* custom_data)
{ {
return realloc (ptr, n); return realloc (ptr, n);
} }
@ -60,13 +60,13 @@ static void __awk_free (void* ptr, void* custom_data)
free (ptr); free (ptr);
} }
JNIEXPORT void JNICALL Java_sse_awk_Awk_open (JNIEnv* env, jobject obj) JNIEXPORT void JNICALL Java_ase_awk_Awk_open (JNIEnv* env, jobject obj)
{ {
jclass class; jclass class;
jfieldID fid; jfieldID fid;
jthrowable except; jthrowable except;
sse_awk_t* awk; ase_awk_t* awk;
sse_awk_syscas_t syscas; ase_awk_syscas_t syscas;
int opt; int opt;
class = (*env)->GetObjectClass(env, obj); class = (*env)->GetObjectClass(env, obj);
@ -103,7 +103,7 @@ JNIEXPORT void JNICALL Java_sse_awk_Awk_open (JNIEnv* env, jobject obj)
syscas.abort = abort; syscas.abort = abort;
#endif #endif
awk = sse_awk_open (&syscas); awk = ase_awk_open (&syscas);
if (awk == NULL) if (awk == NULL)
{ {
except = (*env)->FindClass (env, EXCEPTION_AWK); except = (*env)->FindClass (env, EXCEPTION_AWK);
@ -117,15 +117,15 @@ JNIEXPORT void JNICALL Java_sse_awk_Awk_open (JNIEnv* env, jobject obj)
(*env)->SetLongField (env, obj, fid, (jlong)awk); (*env)->SetLongField (env, obj, fid, (jlong)awk);
opt = SSE_AWK_EXPLICIT | SSE_AWK_UNIQUE | SSE_AWK_DBLSLASHES | opt = ASE_AWK_EXPLICIT | ASE_AWK_UNIQUE | ASE_AWK_DBLSLASHES |
SSE_AWK_SHADING | SSE_AWK_IMPLICIT | SSE_AWK_SHIFT | ASE_AWK_SHADING | ASE_AWK_IMPLICIT | ASE_AWK_SHIFT |
SSE_AWK_EXTIO | SSE_AWK_BLOCKLESS; ASE_AWK_EXTIO | ASE_AWK_BLOCKLESS;
sse_awk_setopt (awk, opt); ase_awk_setopt (awk, opt);
printf ("__awk(native) done => %u, 0x%X\n", awk, awk); printf ("__awk(native) done => %u, 0x%X\n", awk, awk);
} }
JNIEXPORT void JNICALL Java_sse_awk_Awk_close (JNIEnv* env, jobject obj) JNIEXPORT void JNICALL Java_ase_awk_Awk_close (JNIEnv* env, jobject obj)
{ {
jclass class; jclass class;
jfieldID fid; jfieldID fid;
@ -135,20 +135,20 @@ JNIEXPORT void JNICALL Java_sse_awk_Awk_close (JNIEnv* env, jobject obj)
fid = (*env)->GetFieldID (env, class, FIELD_AWK, "J"); fid = (*env)->GetFieldID (env, class, FIELD_AWK, "J");
if (fid == 0) return; if (fid == 0) return;
sse_awk_close ((sse_awk_t*) (*env)->GetLongField (env, obj, fid)); ase_awk_close ((ase_awk_t*) (*env)->GetLongField (env, obj, fid));
(*env)->SetLongField (env, obj, fid, (jlong)0); (*env)->SetLongField (env, obj, fid, (jlong)0);
printf ("close (native) done\n"); printf ("close (native) done\n");
} }
JNIEXPORT void JNICALL Java_sse_awk_Awk_parse (JNIEnv* env, jobject obj) JNIEXPORT void JNICALL Java_ase_awk_Awk_parse (JNIEnv* env, jobject obj)
{ {
jclass class; jclass class;
jfieldID fid; jfieldID fid;
jthrowable except; jthrowable except;
sse_awk_t* awk; ase_awk_t* awk;
sse_awk_srcios_t srcios; ase_awk_srcios_t srcios;
srcio_data_t srcio_data; srcio_data_t srcio_data;
class = (*env)->GetObjectClass (env, obj); class = (*env)->GetObjectClass (env, obj);
@ -156,7 +156,7 @@ JNIEXPORT void JNICALL Java_sse_awk_Awk_parse (JNIEnv* env, jobject obj)
fid = (*env)->GetFieldID (env, class, FIELD_AWK, "J"); fid = (*env)->GetFieldID (env, class, FIELD_AWK, "J");
if (fid == 0) return; if (fid == 0) return;
awk = (sse_awk_t*) (*env)->GetLongField (env, obj, fid); awk = (ase_awk_t*) (*env)->GetLongField (env, obj, fid);
srcio_data.env = env; srcio_data.env = env;
srcio_data.obj = obj; srcio_data.obj = obj;
@ -165,25 +165,25 @@ JNIEXPORT void JNICALL Java_sse_awk_Awk_parse (JNIEnv* env, jobject obj)
srcios.out = __write_source; srcios.out = __write_source;
srcios.custom_data = &srcio_data; srcios.custom_data = &srcio_data;
if (sse_awk_parse (awk, &srcios) == -1) if (ase_awk_parse (awk, &srcios) == -1)
{ {
printf ("parse error.......\n"); printf ("parse error.......\n");
except = (*env)->FindClass (env, EXCEPTION_AWK); except = (*env)->FindClass (env, EXCEPTION_AWK);
if (except == 0) return; if (except == 0) return;
(*env)->ThrowNew (env, except, "Parse Error ..."); (*env)->ThrowNew (env, except, "Parse Error ...");
printf ("parse error -> line [%d] %S\n", sse_awk_getsrcline(awk), sse_awk_geterrstr(sse_awk_geterrnum(awk))); printf ("parse error -> line [%d] %S\n", ase_awk_getsrcline(awk), ase_awk_geterrstr(ase_awk_geterrnum(awk)));
return; return;
} }
} }
JNIEXPORT void JNICALL Java_sse_awk_Awk_run (JNIEnv* env, jobject obj) JNIEXPORT void JNICALL Java_ase_awk_Awk_run (JNIEnv* env, jobject obj)
{ {
jclass class; jclass class;
jfieldID fid; jfieldID fid;
jthrowable except; jthrowable except;
sse_awk_t* awk; ase_awk_t* awk;
sse_awk_runios_t runios; ase_awk_runios_t runios;
runio_data_t runio_data; runio_data_t runio_data;
class = (*env)->GetObjectClass (env, obj); class = (*env)->GetObjectClass (env, obj);
@ -191,18 +191,18 @@ JNIEXPORT void JNICALL Java_sse_awk_Awk_run (JNIEnv* env, jobject obj)
fid = (*env)->GetFieldID (env, class, FIELD_AWK, "J"); fid = (*env)->GetFieldID (env, class, FIELD_AWK, "J");
if (fid == 0) return; if (fid == 0) return;
awk = (sse_awk_t*) (*env)->GetLongField (env, obj, fid); awk = (ase_awk_t*) (*env)->GetLongField (env, obj, fid);
runio_data.env = env; runio_data.env = env;
runio_data.obj = obj; runio_data.obj = obj;
runios.pipe = SSE_NULL; runios.pipe = ASE_NULL;
runios.coproc = SSE_NULL; runios.coproc = ASE_NULL;
runios.file = __process_extio_file; runios.file = __process_extio_file;
runios.console = __process_extio_console; runios.console = __process_extio_console;
runios.custom_data = &runio_data; runios.custom_data = &runio_data;
if (sse_awk_run (awk, &runios, SSE_NULL, SSE_NULL) == -1) if (ase_awk_run (awk, &runios, ASE_NULL, ASE_NULL) == -1)
{ {
except = (*env)->FindClass (env, EXCEPTION_AWK); except = (*env)->FindClass (env, EXCEPTION_AWK);
if (except == 0) return; if (except == 0) return;
@ -211,21 +211,21 @@ JNIEXPORT void JNICALL Java_sse_awk_Awk_run (JNIEnv* env, jobject obj)
} }
} }
JNIEXPORT void JNICALL Java_sse_awk_Awk_set_1extio ( JNIEXPORT void JNICALL Java_ase_awk_Awk_set_1extio (
JNIEnv* env, jobject obj, jlong extio, jobject handle) JNIEnv* env, jobject obj, jlong extio, jobject handle)
{ {
sse_awk_extio_t* epa = (sse_awk_extio_t*)extio; ase_awk_extio_t* epa = (ase_awk_extio_t*)extio;
epa->handle = (void*)handle; epa->handle = (void*)handle;
} }
JNIEXPORT jobject JNICALL Java_sse_awk_Awk_get_1extio ( JNIEXPORT jobject JNICALL Java_ase_awk_Awk_get_1extio (
JNIEnv* env, jobject obj, jlong extio) JNIEnv* env, jobject obj, jlong extio)
{ {
sse_awk_extio_t* epa = (sse_awk_extio_t*)extio; ase_awk_extio_t* epa = (ase_awk_extio_t*)extio;
return (jobject)epa->handle; return (jobject)epa->handle;
} }
static sse_ssize_t __call_java_open_source (JNIEnv* env, jobject obj, int mode) static ase_ssize_t __call_java_open_source (JNIEnv* env, jobject obj, int mode)
{ {
jclass class; jclass class;
jmethodID mid; jmethodID mid;
@ -248,7 +248,7 @@ static sse_ssize_t __call_java_open_source (JNIEnv* env, jobject obj, int mode)
return ret; return ret;
} }
static sse_ssize_t __call_java_close_source (JNIEnv* env, jobject obj, int mode) static ase_ssize_t __call_java_close_source (JNIEnv* env, jobject obj, int mode)
{ {
jclass class; jclass class;
jmethodID mid; jmethodID mid;
@ -271,8 +271,8 @@ static sse_ssize_t __call_java_close_source (JNIEnv* env, jobject obj, int mode)
return ret; return ret;
} }
static sse_ssize_t __call_java_read_source ( static ase_ssize_t __call_java_read_source (
JNIEnv* env, jobject obj, sse_char_t* buf, sse_size_t size) JNIEnv* env, jobject obj, ase_char_t* buf, ase_size_t size)
{ {
jclass class; jclass class;
jmethodID mid; jmethodID mid;
@ -298,15 +298,15 @@ static sse_ssize_t __call_java_read_source (
} }
tmp = (*env)->GetCharArrayElements (env, array, 0); tmp = (*env)->GetCharArrayElements (env, array, 0);
for (i = 0; i < ret; i++) buf[i] = (sse_char_t)tmp[i]; for (i = 0; i < ret; i++) buf[i] = (ase_char_t)tmp[i];
(*env)->ReleaseCharArrayElements (env, array, tmp, 0); (*env)->ReleaseCharArrayElements (env, array, tmp, 0);
(*env)->DeleteLocalRef (env, array); (*env)->DeleteLocalRef (env, array);
return i; return i;
} }
static sse_ssize_t __call_java_write_source ( static ase_ssize_t __call_java_write_source (
JNIEnv* env, jobject obj, sse_char_t* buf, sse_size_t size) JNIEnv* env, jobject obj, ase_char_t* buf, ase_size_t size)
{ {
jclass class; jclass class;
jmethodID mid; jmethodID mid;
@ -339,8 +339,8 @@ static sse_ssize_t __call_java_write_source (
return ret; return ret;
} }
static sse_ssize_t __call_java_open_extio ( static ase_ssize_t __call_java_open_extio (
JNIEnv* env, jobject obj, char* meth, sse_awk_extio_t* extio) JNIEnv* env, jobject obj, char* meth, ase_awk_extio_t* extio)
{ {
jclass class; jclass class;
jmethodID mid; jmethodID mid;
@ -349,7 +349,7 @@ static sse_ssize_t __call_java_open_extio (
class = (*env)->GetObjectClass(env, obj); class = (*env)->GetObjectClass(env, obj);
if (extio == SSE_NULL) if (extio == ASE_NULL)
{ {
mid = (*env)->GetMethodID (env, class, meth, "()I"); mid = (*env)->GetMethodID (env, class, meth, "()I");
if (mid == 0) return -1; if (mid == 0) return -1;
@ -366,7 +366,7 @@ static sse_ssize_t __call_java_open_extio (
if (mid == 0) return -1; if (mid == 0) return -1;
name_str = (*env)->NewString ( name_str = (*env)->NewString (
env, extio->name, sse_awk_strlen(extio->name)); env, extio->name, ase_awk_strlen(extio->name));
if (name_str == 0) return -1; if (name_str == 0) return -1;
ret = (*env)->CallIntMethod (env, obj, mid, name_str); ret = (*env)->CallIntMethod (env, obj, mid, name_str);
@ -405,8 +405,8 @@ static sse_ssize_t __call_java_open_extio (
return ret; return ret;
} }
static sse_ssize_t __call_java_close_extio ( static ase_ssize_t __call_java_close_extio (
JNIEnv* env, jobject obj, char* meth, sse_awk_extio_t* extio) JNIEnv* env, jobject obj, char* meth, ase_awk_extio_t* extio)
{ {
jclass class; jclass class;
jmethodID mid; jmethodID mid;
@ -415,7 +415,7 @@ static sse_ssize_t __call_java_close_extio (
class = (*env)->GetObjectClass(env, obj); class = (*env)->GetObjectClass(env, obj);
if (extio == SSE_NULL) if (extio == ASE_NULL)
{ {
mid = (*env)->GetMethodID (env, class, meth, "()I"); mid = (*env)->GetMethodID (env, class, meth, "()I");
if (mid == 0) return -1; if (mid == 0) return -1;
@ -431,7 +431,7 @@ static sse_ssize_t __call_java_close_extio (
if (mid == 0) return -1; if (mid == 0) return -1;
name_str = (*env)->NewString ( name_str = (*env)->NewString (
env, extio->name, sse_awk_strlen(extio->name)); env, extio->name, ase_awk_strlen(extio->name));
if (name_str == 0) return -1; if (name_str == 0) return -1;
ret = (*env)->CallIntMethod (env, obj, mid, name_str); ret = (*env)->CallIntMethod (env, obj, mid, name_str);
@ -448,8 +448,8 @@ static sse_ssize_t __call_java_close_extio (
return ret; return ret;
} }
static sse_ssize_t __call_java_read_extio ( static ase_ssize_t __call_java_read_extio (
JNIEnv* env, jobject obj, char* meth, sse_char_t* buf, sse_size_t size) JNIEnv* env, jobject obj, char* meth, ase_char_t* buf, ase_size_t size)
{ {
jclass class; jclass class;
jmethodID mid; jmethodID mid;
@ -475,20 +475,20 @@ static sse_ssize_t __call_java_read_extio (
} }
tmp = (*env)->GetCharArrayElements (env, array, 0); tmp = (*env)->GetCharArrayElements (env, array, 0);
for (i = 0; i < ret; i++) buf[i] = (sse_char_t)tmp[i]; for (i = 0; i < ret; i++) buf[i] = (ase_char_t)tmp[i];
(*env)->ReleaseCharArrayElements (env, array, tmp, 0); (*env)->ReleaseCharArrayElements (env, array, tmp, 0);
(*env)->DeleteLocalRef (env, array); (*env)->DeleteLocalRef (env, array);
return ret; return ret;
} }
static sse_ssize_t __call_java_write_extio ( static ase_ssize_t __call_java_write_extio (
JNIEnv* env, jobject obj, char* meth, sse_char_t* data, sse_size_t size) JNIEnv* env, jobject obj, char* meth, ase_char_t* data, ase_size_t size)
{ {
jclass class; jclass class;
jmethodID mid; jmethodID mid;
jcharArray array; jcharArray array;
sse_ssize_t i; ase_ssize_t i;
jchar* tmp; jchar* tmp;
jint ret; jint ret;
jthrowable thrown; jthrowable thrown;
@ -517,22 +517,22 @@ static sse_ssize_t __call_java_write_extio (
return ret; return ret;
} }
static sse_ssize_t __read_source ( static ase_ssize_t __read_source (
int cmd, void* arg, sse_char_t* data, sse_size_t count) int cmd, void* arg, ase_char_t* data, ase_size_t count)
{ {
srcio_data_t* srcio_data = (srcio_data_t*)arg; srcio_data_t* srcio_data = (srcio_data_t*)arg;
if (cmd == SSE_AWK_IO_OPEN) if (cmd == ASE_AWK_IO_OPEN)
{ {
return __call_java_open_source ( return __call_java_open_source (
srcio_data->env, srcio_data->obj, SOURCE_READ); srcio_data->env, srcio_data->obj, SOURCE_READ);
} }
else if (cmd == SSE_AWK_IO_CLOSE) else if (cmd == ASE_AWK_IO_CLOSE)
{ {
return __call_java_close_source ( return __call_java_close_source (
srcio_data->env, srcio_data->obj, SOURCE_READ); srcio_data->env, srcio_data->obj, SOURCE_READ);
} }
else if (cmd == SSE_AWK_IO_READ) else if (cmd == ASE_AWK_IO_READ)
{ {
return __call_java_read_source ( return __call_java_read_source (
srcio_data->env, srcio_data->obj, data, count); srcio_data->env, srcio_data->obj, data, count);
@ -541,22 +541,22 @@ static sse_ssize_t __read_source (
return -1; return -1;
} }
static sse_ssize_t __write_source ( static ase_ssize_t __write_source (
int cmd, void* arg, sse_char_t* data, sse_size_t count) int cmd, void* arg, ase_char_t* data, ase_size_t count)
{ {
srcio_data_t* srcio_data = (srcio_data_t*)arg; srcio_data_t* srcio_data = (srcio_data_t*)arg;
if (cmd == SSE_AWK_IO_OPEN) if (cmd == ASE_AWK_IO_OPEN)
{ {
return __call_java_open_source ( return __call_java_open_source (
srcio_data->env, srcio_data->obj, SOURCE_WRITE); srcio_data->env, srcio_data->obj, SOURCE_WRITE);
} }
else if (cmd == SSE_AWK_IO_CLOSE) else if (cmd == ASE_AWK_IO_CLOSE)
{ {
return __call_java_close_source ( return __call_java_close_source (
srcio_data->env, srcio_data->obj, SOURCE_WRITE); srcio_data->env, srcio_data->obj, SOURCE_WRITE);
} }
else if (cmd == SSE_AWK_IO_WRITE) else if (cmd == ASE_AWK_IO_WRITE)
{ {
return __call_java_write_source ( return __call_java_write_source (
srcio_data->env, srcio_data->obj, data, count); srcio_data->env, srcio_data->obj, data, count);
@ -565,45 +565,45 @@ static sse_ssize_t __write_source (
return -1; return -1;
} }
static sse_ssize_t __process_extio_console ( static ase_ssize_t __process_extio_console (
int cmd, void* arg, sse_char_t* data, sse_size_t size) int cmd, void* arg, ase_char_t* data, ase_size_t size)
{ {
sse_awk_extio_t* epa = (sse_awk_extio_t*)arg; ase_awk_extio_t* epa = (ase_awk_extio_t*)arg;
runio_data_t* runio_data = (runio_data_t*)epa->custom_data; runio_data_t* runio_data = (runio_data_t*)epa->custom_data;
if (cmd == SSE_AWK_IO_OPEN) if (cmd == ASE_AWK_IO_OPEN)
{ {
return __call_java_open_extio ( return __call_java_open_extio (
runio_data->env, runio_data->obj, runio_data->env, runio_data->obj,
"open_console", SSE_NULL); "open_console", ASE_NULL);
} }
else if (cmd == SSE_AWK_IO_CLOSE) else if (cmd == ASE_AWK_IO_CLOSE)
{ {
return __call_java_close_extio ( return __call_java_close_extio (
runio_data->env, runio_data->obj, runio_data->env, runio_data->obj,
"close_console", SSE_NULL); "close_console", ASE_NULL);
} }
else if (cmd == SSE_AWK_IO_READ) else if (cmd == ASE_AWK_IO_READ)
{ {
return __call_java_read_extio ( return __call_java_read_extio (
runio_data->env, runio_data->obj, "read_console", runio_data->env, runio_data->obj, "read_console",
data, size); data, size);
} }
else if (cmd == SSE_AWK_IO_WRITE) else if (cmd == ASE_AWK_IO_WRITE)
{ {
return __call_java_write_extio ( return __call_java_write_extio (
runio_data->env, runio_data->obj, "write_console", runio_data->env, runio_data->obj, "write_console",
data, size); data, size);
} }
#if 0 #if 0
else if (cmd == SSE_AWK_IO_FLUSH) else if (cmd == ASE_AWK_IO_FLUSH)
{ {
return __call_java_flush_extio ( return __call_java_flush_extio (
runio_data->env, runio_data->obj, "flush_console", runio_data->env, runio_data->obj, "flush_console",
data, size); data, size);
} }
else if (cmd == SSE_AWK_IO_NEXT) else if (cmd == ASE_AWK_IO_NEXT)
{ {
return __call_java_next_extio ( return __call_java_next_extio (
runio_data->env, runio_data->obj, "flush_console", runio_data->env, runio_data->obj, "flush_console",
@ -614,19 +614,19 @@ static sse_ssize_t __process_extio_console (
return -1; return -1;
} }
static sse_ssize_t __process_extio_file ( static ase_ssize_t __process_extio_file (
int cmd, void* arg, sse_char_t* data, sse_size_t size) int cmd, void* arg, ase_char_t* data, ase_size_t size)
{ {
sse_awk_extio_t* epa = (sse_awk_extio_t*)arg; ase_awk_extio_t* epa = (ase_awk_extio_t*)arg;
runio_data_t* runio_data = (runio_data_t*)epa->custom_data; runio_data_t* runio_data = (runio_data_t*)epa->custom_data;
if (cmd == SSE_AWK_IO_OPEN) if (cmd == ASE_AWK_IO_OPEN)
{ {
return __call_java_open_extio ( return __call_java_open_extio (
runio_data->env, runio_data->obj, runio_data->env, runio_data->obj,
"open_file", epa); "open_file", epa);
} }
else if (cmd == SSE_AWK_IO_CLOSE) else if (cmd == ASE_AWK_IO_CLOSE)
{ {
return __call_java_close_extio ( return __call_java_close_extio (
runio_data->env, runio_data->obj, runio_data->env, runio_data->obj,

14
ase/awk/jni.h
View File

@ -1,9 +1,9 @@
/* /*
* $Id: jni.h,v 1.6 2006-10-22 12:39:29 bacon Exp $ * $Id: jni.h,v 1.7 2006-10-24 04:10:12 bacon Exp $
*/ */
#ifndef _SSE_AWK_JNI_H_ #ifndef _ASE_AWK_JNI_H_
#define _SSE_AWK_JNI_H_ #define _ASE_AWK_JNI_H_
#include <jni.h> #include <jni.h>
@ -11,10 +11,10 @@
extern "C" { extern "C" {
#endif #endif
JNIEXPORT void JNICALL Java_sse_awk_Awk_open (JNIEnv*, jobject); JNIEXPORT void JNICALL Java_ase_awk_Awk_open (JNIEnv*, jobject);
JNIEXPORT void JNICALL Java_sse_awk_Awk_close (JNIEnv*, jobject); JNIEXPORT void JNICALL Java_ase_awk_Awk_close (JNIEnv*, jobject);
JNIEXPORT void JNICALL Java_sse_awk_Awk_parse (JNIEnv*, jobject); JNIEXPORT void JNICALL Java_ase_awk_Awk_parse (JNIEnv*, jobject);
JNIEXPORT void JNICALL Java_sse_awk_Awk_run (JNIEnv*, jobject); JNIEXPORT void JNICALL Java_ase_awk_Awk_run (JNIEnv*, jobject);
#ifdef __cplusplus #ifdef __cplusplus
} }

186
ase/awk/map.c
View File

@ -1,70 +1,70 @@
/* /*
* $Id: map.c,v 1.27 2006-10-22 11:34:53 bacon Exp $ * $Id: map.c,v 1.28 2006-10-24 04:10:12 bacon Exp $
*/ */
#include <sse/awk/awk_i.h> #include <ase/awk/awk_i.h>
/* TODO: improve the entire map routines. /* TODO: improve the entire map routines.
support automatic bucket resizing and remaping, etc. */ support automatic bucket resizing and remaping, etc. */
static sse_size_t __hash (const sse_char_t* key, sse_size_t key_len); static ase_size_t __hash (const ase_char_t* key, ase_size_t key_len);
#define FREE_PAIR(map,pair) \ #define FREE_PAIR(map,pair) \
do { \ do { \
SSE_AWK_FREE ((map)->awk, (sse_char_t*)(pair)->key); \ ASE_AWK_FREE ((map)->awk, (ase_char_t*)(pair)->key); \
if ((map)->freeval != SSE_NULL) \ if ((map)->freeval != ASE_NULL) \
(map)->freeval ((map)->owner, (pair)->val); \ (map)->freeval ((map)->owner, (pair)->val); \
SSE_AWK_FREE ((map)->awk, pair); \ ASE_AWK_FREE ((map)->awk, pair); \
} while (0) } while (0)
sse_awk_map_t* sse_awk_map_open ( ase_awk_map_t* ase_awk_map_open (
sse_awk_map_t* map, void* owner, sse_size_t capa, ase_awk_map_t* map, void* owner, ase_size_t capa,
void(*freeval)(void*,void*), sse_awk_t* awk) void(*freeval)(void*,void*), ase_awk_t* awk)
{ {
if (map == SSE_NULL) if (map == ASE_NULL)
{ {
map = (sse_awk_map_t*) SSE_AWK_MALLOC ( map = (ase_awk_map_t*) ASE_AWK_MALLOC (
awk, sse_sizeof(sse_awk_map_t)); awk, ase_sizeof(ase_awk_map_t));
if (map == SSE_NULL) return SSE_NULL; if (map == ASE_NULL) return ASE_NULL;
map->__dynamic = sse_true; map->__dynamic = ase_true;
} }
else map->__dynamic = sse_false; else map->__dynamic = ase_false;
map->awk = awk; map->awk = awk;
map->buck = (sse_awk_pair_t**) map->buck = (ase_awk_pair_t**)
SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_pair_t*) * capa); ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_pair_t*) * capa);
if (map->buck == SSE_NULL) if (map->buck == ASE_NULL)
{ {
if (map->__dynamic) SSE_AWK_FREE (awk, map); if (map->__dynamic) ASE_AWK_FREE (awk, map);
return SSE_NULL; return ASE_NULL;
} }
map->owner = owner; map->owner = owner;
map->capa = capa; map->capa = capa;
map->size = 0; map->size = 0;
map->freeval = freeval; map->freeval = freeval;
while (capa > 0) map->buck[--capa] = SSE_NULL; while (capa > 0) map->buck[--capa] = ASE_NULL;
return map; return map;
} }
void sse_awk_map_close (sse_awk_map_t* map) void ase_awk_map_close (ase_awk_map_t* map)
{ {
sse_awk_map_clear (map); ase_awk_map_clear (map);
SSE_AWK_FREE (map->awk, map->buck); ASE_AWK_FREE (map->awk, map->buck);
if (map->__dynamic) SSE_AWK_FREE (map->awk, map); if (map->__dynamic) ASE_AWK_FREE (map->awk, map);
} }
void sse_awk_map_clear (sse_awk_map_t* map) void ase_awk_map_clear (ase_awk_map_t* map)
{ {
sse_size_t i; ase_size_t i;
sse_awk_pair_t* pair, * next; ase_awk_pair_t* pair, * next;
for (i = 0; i < map->capa; i++) for (i = 0; i < map->capa; i++)
{ {
pair = map->buck[i]; pair = map->buck[i];
while (pair != SSE_NULL) while (pair != ASE_NULL)
{ {
next = pair->next; next = pair->next;
FREE_PAIR (map, pair); FREE_PAIR (map, pair);
@ -72,81 +72,81 @@ void sse_awk_map_clear (sse_awk_map_t* map)
pair = next; pair = next;
} }
map->buck[i] = SSE_NULL; map->buck[i] = ASE_NULL;
} }
sse_awk_assert (map->awk, map->size == 0); ase_awk_assert (map->awk, map->size == 0);
} }
sse_awk_pair_t* sse_awk_map_get ( ase_awk_pair_t* ase_awk_map_get (
sse_awk_map_t* map, const sse_char_t* key, sse_size_t key_len) ase_awk_map_t* map, const ase_char_t* key, ase_size_t key_len)
{ {
sse_awk_pair_t* pair; ase_awk_pair_t* pair;
sse_size_t hc; ase_size_t hc;
hc = __hash(key,key_len) % map->capa; hc = __hash(key,key_len) % map->capa;
pair = map->buck[hc]; pair = map->buck[hc];
while (pair != SSE_NULL) while (pair != ASE_NULL)
{ {
if (sse_awk_strxncmp ( if (ase_awk_strxncmp (
pair->key, pair->key_len, pair->key, pair->key_len,
key, key_len) == 0) return pair; key, key_len) == 0) return pair;
pair = pair->next; pair = pair->next;
} }
return SSE_NULL; return ASE_NULL;
} }
sse_awk_pair_t* sse_awk_map_put ( ase_awk_pair_t* ase_awk_map_put (
sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len, void* val) ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len, void* val)
{ {
int n; int n;
sse_awk_pair_t* px; ase_awk_pair_t* px;
n = sse_awk_map_putx (map, key, key_len, val, &px); n = ase_awk_map_putx (map, key, key_len, val, &px);
if (n < 0) return SSE_NULL; if (n < 0) return ASE_NULL;
return px; return px;
} }
int sse_awk_map_putx ( int ase_awk_map_putx (
sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len, ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len,
void* val, sse_awk_pair_t** px) void* val, ase_awk_pair_t** px)
{ {
sse_awk_pair_t* pair; ase_awk_pair_t* pair;
sse_size_t hc; ase_size_t hc;
hc = __hash(key,key_len) % map->capa; hc = __hash(key,key_len) % map->capa;
pair = map->buck[hc]; pair = map->buck[hc];
while (pair != SSE_NULL) while (pair != ASE_NULL)
{ {
if (sse_awk_strxncmp ( if (ase_awk_strxncmp (
pair->key, pair->key_len, key, key_len) == 0) pair->key, pair->key_len, key, key_len) == 0)
{ {
if (px != SSE_NULL) if (px != ASE_NULL)
*px = sse_awk_map_setpair (map, pair, val); *px = ase_awk_map_setpair (map, pair, val);
else else
sse_awk_map_setpair (map, pair, val); ase_awk_map_setpair (map, pair, val);
return 0; /* value changed for the existing key */ return 0; /* value changed for the existing key */
} }
pair = pair->next; pair = pair->next;
} }
pair = (sse_awk_pair_t*) SSE_AWK_MALLOC ( pair = (ase_awk_pair_t*) ASE_AWK_MALLOC (
map->awk, sse_sizeof(sse_awk_pair_t)); map->awk, ase_sizeof(ase_awk_pair_t));
if (pair == SSE_NULL) return -1; /* error */ if (pair == ASE_NULL) return -1; /* error */
/*pair->key = key;*/ /*pair->key = key;*/
/* duplicate the key if it is new */ /* duplicate the key if it is new */
pair->key = sse_awk_strxdup (map->awk, key, key_len); pair->key = ase_awk_strxdup (map->awk, key, key_len);
if (pair->key == SSE_NULL) if (pair->key == ASE_NULL)
{ {
SSE_AWK_FREE (map->awk, pair); ASE_AWK_FREE (map->awk, pair);
return -1; /* error */ return -1; /* error */
} }
@ -156,51 +156,51 @@ int sse_awk_map_putx (
map->buck[hc] = pair; map->buck[hc] = pair;
map->size++; map->size++;
if (px != SSE_NULL) *px = pair; if (px != ASE_NULL) *px = pair;
return 1; /* new key added */ return 1; /* new key added */
} }
sse_awk_pair_t* sse_awk_map_set ( ase_awk_pair_t* ase_awk_map_set (
sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len, void* val) ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len, void* val)
{ {
sse_awk_pair_t* pair; ase_awk_pair_t* pair;
sse_size_t hc; ase_size_t hc;
hc = __hash(key,key_len) % map->capa; hc = __hash(key,key_len) % map->capa;
pair = map->buck[hc]; pair = map->buck[hc];
while (pair != SSE_NULL) while (pair != ASE_NULL)
{ {
if (sse_awk_strxncmp ( if (ase_awk_strxncmp (
pair->key, pair->key_len, key, key_len) == 0) pair->key, pair->key_len, key, key_len) == 0)
{ {
return sse_awk_map_setpair (map, pair, val); return ase_awk_map_setpair (map, pair, val);
} }
pair = pair->next; pair = pair->next;
} }
return SSE_NULL; return ASE_NULL;
} }
sse_awk_pair_t* sse_awk_map_getpair ( ase_awk_pair_t* ase_awk_map_getpair (
sse_awk_map_t* map, const sse_char_t* key, sse_size_t key_len, void** val) ase_awk_map_t* map, const ase_char_t* key, ase_size_t key_len, void** val)
{ {
sse_awk_pair_t* pair; ase_awk_pair_t* pair;
pair = sse_awk_map_get (map, key, key_len); pair = ase_awk_map_get (map, key, key_len);
if (pair == SSE_NULL) return SSE_NULL; if (pair == ASE_NULL) return ASE_NULL;
*val = pair->val; *val = pair->val;
return pair; return pair;
} }
sse_awk_pair_t* sse_awk_map_setpair ( ase_awk_pair_t* ase_awk_map_setpair (
sse_awk_map_t* map, sse_awk_pair_t* pair, void* val) ase_awk_map_t* map, ase_awk_pair_t* pair, void* val)
{ {
/* use this function with care */ /* use this function with care */
if (pair->val != val) if (pair->val != val)
{ {
if (map->freeval != SSE_NULL) if (map->freeval != ASE_NULL)
{ {
map->freeval (map->owner, pair->val); map->freeval (map->owner, pair->val);
} }
@ -210,21 +210,21 @@ sse_awk_pair_t* sse_awk_map_setpair (
return pair; return pair;
} }
int sse_awk_map_remove (sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len) int ase_awk_map_remove (ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len)
{ {
sse_awk_pair_t* pair, * prev; ase_awk_pair_t* pair, * prev;
sse_size_t hc; ase_size_t hc;
hc = __hash(key,key_len) % map->capa; hc = __hash(key,key_len) % map->capa;
pair = map->buck[hc]; pair = map->buck[hc];
prev = SSE_NULL; prev = ASE_NULL;
while (pair != SSE_NULL) while (pair != ASE_NULL)
{ {
if (sse_awk_strxncmp ( if (ase_awk_strxncmp (
pair->key, pair->key_len, key, key_len) == 0) pair->key, pair->key_len, key, key_len) == 0)
{ {
if (prev == SSE_NULL) if (prev == ASE_NULL)
map->buck[hc] = pair->next; map->buck[hc] = pair->next;
else prev->next = pair->next; else prev->next = pair->next;
@ -241,17 +241,17 @@ int sse_awk_map_remove (sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len)
return -1; return -1;
} }
int sse_awk_map_walk (sse_awk_map_t* map, int ase_awk_map_walk (ase_awk_map_t* map,
int (*walker) (sse_awk_pair_t*,void*), void* arg) int (*walker) (ase_awk_pair_t*,void*), void* arg)
{ {
sse_size_t i; ase_size_t i;
sse_awk_pair_t* pair, * next; ase_awk_pair_t* pair, * next;
for (i = 0; i < map->capa; i++) for (i = 0; i < map->capa; i++)
{ {
pair = map->buck[i]; pair = map->buck[i];
while (pair != SSE_NULL) while (pair != ASE_NULL)
{ {
next = pair->next; next = pair->next;
if (walker(pair,arg) == -1) return -1; if (walker(pair,arg) == -1) return -1;
@ -262,15 +262,15 @@ int sse_awk_map_walk (sse_awk_map_t* map,
return 0; return 0;
} }
static sse_size_t __hash (const sse_char_t* key, sse_size_t key_len) static ase_size_t __hash (const ase_char_t* key, ase_size_t key_len)
{ {
sse_size_t n = 0, i; ase_size_t n = 0, i;
const sse_char_t* end = key + key_len; const ase_char_t* end = key + key_len;
while (key < end) while (key < end)
{ {
sse_byte_t* bp = (sse_byte_t*)key; ase_byte_t* bp = (ase_byte_t*)key;
for (i = 0; i < sse_sizeof(*key); i++) n = n * 31 + *bp++; for (i = 0; i < ase_sizeof(*key); i++) n = n * 31 + *bp++;
key++; key++;
} }

76
ase/awk/map.h
View File

@ -1,71 +1,71 @@
/* /*
* $Id: map.h,v 1.16 2006-10-22 11:34:53 bacon Exp $ * $Id: map.h,v 1.17 2006-10-24 04:10:12 bacon Exp $
*/ */
#ifndef _SSE_AWK_MAP_H_ #ifndef _ASE_AWK_MAP_H_
#define _SSE_AWK_MAP_H_ #define _ASE_AWK_MAP_H_
#ifndef _SSE_AWK_AWK_H_ #ifndef _ASE_AWK_AWK_H_
#error Never include this file directly. Include <sse/awk/awk.h> instead #error Never include this file directly. Include <ase/awk/awk.h> instead
#endif #endif
typedef struct sse_awk_map_t sse_awk_map_t; typedef struct ase_awk_map_t ase_awk_map_t;
typedef struct sse_awk_pair_t sse_awk_pair_t; typedef struct ase_awk_pair_t ase_awk_pair_t;
struct sse_awk_pair_t struct ase_awk_pair_t
{ {
sse_char_t* key; ase_char_t* key;
sse_size_t key_len; ase_size_t key_len;
void* val; void* val;
sse_awk_pair_t* next; ase_awk_pair_t* next;
}; };
struct sse_awk_map_t struct ase_awk_map_t
{ {
void* owner; void* owner;
sse_size_t size; ase_size_t size;
sse_size_t capa; ase_size_t capa;
sse_awk_pair_t** buck; ase_awk_pair_t** buck;
void (*freeval) (void*,void*); void (*freeval) (void*,void*);
sse_awk_t* awk; ase_awk_t* awk;
sse_bool_t __dynamic; ase_bool_t __dynamic;
}; };
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
sse_awk_map_t* sse_awk_map_open ( ase_awk_map_t* ase_awk_map_open (
sse_awk_map_t* map, void* owner, sse_size_t capa, ase_awk_map_t* map, void* owner, ase_size_t capa,
void(*freeval)(void*,void*), sse_awk_t* awk); void(*freeval)(void*,void*), ase_awk_t* awk);
void sse_awk_map_close (sse_awk_map_t* map); void ase_awk_map_close (ase_awk_map_t* map);
void sse_awk_map_clear (sse_awk_map_t* map); void ase_awk_map_clear (ase_awk_map_t* map);
sse_awk_pair_t* sse_awk_map_get ( ase_awk_pair_t* ase_awk_map_get (
sse_awk_map_t* map, const sse_char_t* key, sse_size_t key_len); ase_awk_map_t* map, const ase_char_t* key, ase_size_t key_len);
sse_awk_pair_t* sse_awk_map_put ( ase_awk_pair_t* ase_awk_map_put (
sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len, void* val); ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len, void* val);
int sse_awk_map_putx ( int ase_awk_map_putx (
sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len, ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len,
void* val, sse_awk_pair_t** px); void* val, ase_awk_pair_t** px);
sse_awk_pair_t* sse_awk_map_set ( ase_awk_pair_t* ase_awk_map_set (
sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len, void* val); ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len, void* val);
sse_awk_pair_t* sse_awk_map_getpair ( ase_awk_pair_t* ase_awk_map_getpair (
sse_awk_map_t* map, const sse_char_t* key, sse_size_t key_len, void** val); ase_awk_map_t* map, const ase_char_t* key, ase_size_t key_len, void** val);
sse_awk_pair_t* sse_awk_map_setpair ( ase_awk_pair_t* ase_awk_map_setpair (
sse_awk_map_t* map, sse_awk_pair_t* pair, void* val); ase_awk_map_t* map, ase_awk_pair_t* pair, void* val);
int sse_awk_map_remove (sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len); int ase_awk_map_remove (ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len);
int sse_awk_map_walk (sse_awk_map_t* map, int ase_awk_map_walk (ase_awk_map_t* map,
int (*walker)(sse_awk_pair_t*,void*), void* arg); int (*walker)(ase_awk_pair_t*,void*), void* arg);
#ifdef __cplusplus #ifdef __cplusplus
} }

500
ase/awk/misc.c
View File

File diff suppressed because it is too large Load Diff

52
ase/awk/misc.h
View File

@ -1,45 +1,45 @@
/* /*
* $Id: misc.h,v 1.6 2006-10-23 14:44:43 bacon Exp $ * $Id: misc.h,v 1.7 2006-10-24 04:10:12 bacon Exp $
*/ */
#ifndef _SSE_AWK_MISC_H_ #ifndef _ASE_AWK_MISC_H_
#define _SSE_AWK_MISC_H_ #define _ASE_AWK_MISC_H_
#ifndef _SSE_AWK_AWK_H_ #ifndef _ASE_AWK_AWK_H_
#error Never include this file directly. Include <sse/awk/awk.h> instead #error Never include this file directly. Include <ase/awk/awk.h> instead
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
void* sse_awk_memcpy (void* dst, const void* src, sse_size_t n); void* ase_awk_memcpy (void* dst, const void* src, ase_size_t n);
void* sse_awk_memset (void* dst, int val, sse_size_t n); void* ase_awk_memset (void* dst, int val, ase_size_t n);
sse_char_t* sse_awk_strtok ( ase_char_t* ase_awk_strtok (
sse_awk_run_t* run, const sse_char_t* s, ase_awk_run_t* run, const ase_char_t* s,
const sse_char_t* delim, sse_char_t** tok, sse_size_t* tok_len); const ase_char_t* delim, ase_char_t** tok, ase_size_t* tok_len);
sse_char_t* sse_awk_strxtok ( ase_char_t* ase_awk_strxtok (
sse_awk_run_t* run, const sse_char_t* s, sse_size_t len, ase_awk_run_t* run, const ase_char_t* s, ase_size_t len,
const sse_char_t* delim, sse_char_t** tok, sse_size_t* tok_len); const ase_char_t* delim, ase_char_t** tok, ase_size_t* tok_len);
sse_char_t* sse_awk_strntok ( ase_char_t* ase_awk_strntok (
sse_awk_run_t* run, const sse_char_t* s, ase_awk_run_t* run, const ase_char_t* s,
const sse_char_t* delim, sse_size_t delim_len, const ase_char_t* delim, ase_size_t delim_len,
sse_char_t** tok, sse_size_t* tok_len); ase_char_t** tok, ase_size_t* tok_len);
sse_char_t* sse_awk_strxntok ( ase_char_t* ase_awk_strxntok (
sse_awk_run_t* run, const sse_char_t* s, sse_size_t len, ase_awk_run_t* run, const ase_char_t* s, ase_size_t len,
const sse_char_t* delim, sse_size_t delim_len, const ase_char_t* delim, ase_size_t delim_len,
sse_char_t** tok, sse_size_t* tok_len); ase_char_t** tok, ase_size_t* tok_len);
sse_char_t* sse_awk_strxntokbyrex ( ase_char_t* ase_awk_strxntokbyrex (
sse_awk_run_t* run, const sse_char_t* s, sse_size_t len, ase_awk_run_t* run, const ase_char_t* s, ase_size_t len,
void* rex, sse_char_t** tok, sse_size_t* tok_len, int* errnum); void* rex, ase_char_t** tok, ase_size_t* tok_len, int* errnum);
int sse_awk_abort (sse_awk_t* awk, int ase_awk_abort (ase_awk_t* awk,
const sse_char_t* expr, const sse_char_t* file, int line); const ase_char_t* expr, const ase_char_t* file, int line);
#ifdef __cplusplus #ifdef __cplusplus
} }

2984
ase/awk/parse.c
View File

File diff suppressed because it is too large Load Diff

16
ase/awk/parse.h
View File

@ -1,21 +1,21 @@
/* /*
* $Id: parse.h,v 1.2 2006-10-22 11:34:53 bacon Exp $ * $Id: parse.h,v 1.3 2006-10-24 04:10:12 bacon Exp $
*/ */
#ifndef _SSE_AWK_PARSE_H_ #ifndef _ASE_AWK_PARSE_H_
#define _SSE_AWK_PARSE_H_ #define _ASE_AWK_PARSE_H_
#ifndef _SSE_AWK_AWK_H_ #ifndef _ASE_AWK_AWK_H_
#error Never include this file directly. Include <sse/awk/awk.h> instead #error Never include this file directly. Include <ase/awk/awk.h> instead
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
int sse_awk_putsrcstr (sse_awk_t* awk, const sse_char_t* str); int ase_awk_putsrcstr (ase_awk_t* awk, const ase_char_t* str);
int sse_awk_putsrcstrx ( int ase_awk_putsrcstrx (
sse_awk_t* awk, const sse_char_t* str, sse_size_t len); ase_awk_t* awk, const ase_char_t* str, ase_size_t len);
#ifdef __cplusplus #ifdef __cplusplus
} }

330
ase/awk/rec.c
View File

@ -1,57 +1,57 @@
/* /*
* $Id: rec.c,v 1.4 2006-10-22 11:34:53 bacon Exp $ * $Id: rec.c,v 1.5 2006-10-24 04:10:12 bacon Exp $
*/ */
#include <sse/awk/awk_i.h> #include <ase/awk/awk_i.h>
static int __split_record (sse_awk_run_t* run); static int __split_record (ase_awk_run_t* run);
static int __recomp_record_fields ( static int __recomp_record_fields (
sse_awk_run_t* run, sse_size_t lv, ase_awk_run_t* run, ase_size_t lv,
const sse_char_t* str, sse_size_t len); const ase_char_t* str, ase_size_t len);
int sse_awk_setrec ( int ase_awk_setrec (
sse_awk_run_t* run, sse_size_t idx, const sse_char_t* str, sse_size_t len) ase_awk_run_t* run, ase_size_t idx, const ase_char_t* str, ase_size_t len)
{ {
sse_awk_val_t* v; ase_awk_val_t* v;
int errnum; int errnum;
if (idx == 0) if (idx == 0)
{ {
if (str == SSE_AWK_STR_BUF(&run->inrec.line) && if (str == ASE_AWK_STR_BUF(&run->inrec.line) &&
len == SSE_AWK_STR_LEN(&run->inrec.line)) len == ASE_AWK_STR_LEN(&run->inrec.line))
{ {
if (sse_awk_clrrec (run, sse_true) == -1) return -1; if (ase_awk_clrrec (run, ase_true) == -1) return -1;
} }
else else
{ {
if (sse_awk_clrrec (run, sse_false) == -1) return -1; if (ase_awk_clrrec (run, ase_false) == -1) return -1;
if (sse_awk_str_ncpy (&run->inrec.line, str, len) == (sse_size_t)-1) if (ase_awk_str_ncpy (&run->inrec.line, str, len) == (ase_size_t)-1)
{ {
sse_awk_clrrec (run, sse_false); ase_awk_clrrec (run, ase_false);
run->errnum = SSE_AWK_ENOMEM; run->errnum = ASE_AWK_ENOMEM;
return -1; return -1;
} }
} }
v = sse_awk_makestrval (run, str, len); v = ase_awk_makestrval (run, str, len);
if (v == SSE_NULL) if (v == ASE_NULL)
{ {
sse_awk_clrrec (run, sse_false); ase_awk_clrrec (run, ase_false);
run->errnum = SSE_AWK_ENOMEM; run->errnum = ASE_AWK_ENOMEM;
return -1; return -1;
} }
sse_awk_assert (run->awk, run->inrec.d0->type == SSE_AWK_VAL_NIL); ase_awk_assert (run->awk, run->inrec.d0->type == ASE_AWK_VAL_NIL);
/* d0 should be cleared before the next line is reached /* d0 should be cleared before the next line is reached
* as it doesn't call sse_awk_refdownval on run->inrec.d0 */ * as it doesn't call ase_awk_refdownval on run->inrec.d0 */
run->inrec.d0 = v; run->inrec.d0 = v;
sse_awk_refupval (v); ase_awk_refupval (v);
if (__split_record (run) == -1) if (__split_record (run) == -1)
{ {
errnum = run->errnum; errnum = run->errnum;
sse_awk_clrrec (run, sse_false); ase_awk_clrrec (run, ase_false);
run->errnum = errnum; run->errnum = errnum;
return -1; return -1;
} }
@ -61,210 +61,210 @@ int sse_awk_setrec (
if (__recomp_record_fields (run, idx, str, len) == -1) if (__recomp_record_fields (run, idx, str, len) == -1)
{ {
errnum = run->errnum; errnum = run->errnum;
sse_awk_clrrec (run, sse_false); ase_awk_clrrec (run, ase_false);
run->errnum = errnum; run->errnum = errnum;
return -1; return -1;
} }
/* recompose $0 */ /* recompose $0 */
v = sse_awk_makestrval (run, v = ase_awk_makestrval (run,
SSE_AWK_STR_BUF(&run->inrec.line), ASE_AWK_STR_BUF(&run->inrec.line),
SSE_AWK_STR_LEN(&run->inrec.line)); ASE_AWK_STR_LEN(&run->inrec.line));
if (v == SSE_NULL) if (v == ASE_NULL)
{ {
sse_awk_clrrec (run, sse_false); ase_awk_clrrec (run, ase_false);
run->errnum = SSE_AWK_ENOMEM; run->errnum = ASE_AWK_ENOMEM;
return -1; return -1;
} }
sse_awk_refdownval (run, run->inrec.d0); ase_awk_refdownval (run, run->inrec.d0);
run->inrec.d0 = v; run->inrec.d0 = v;
sse_awk_refupval (v); ase_awk_refupval (v);
} }
return 0; return 0;
} }
static int __split_record (sse_awk_run_t* run) static int __split_record (ase_awk_run_t* run)
{ {
sse_char_t* p, * tok; ase_char_t* p, * tok;
sse_size_t len, tok_len, nflds; ase_size_t len, tok_len, nflds;
sse_awk_val_t* v, * fs; ase_awk_val_t* v, * fs;
sse_char_t* fs_ptr, * fs_free; ase_char_t* fs_ptr, * fs_free;
sse_size_t fs_len; ase_size_t fs_len;
int errnum; int errnum;
/* inrec should be cleared before __split_record is called */ /* inrec should be cleared before __split_record is called */
sse_awk_assert (run->awk, run->inrec.nflds == 0); ase_awk_assert (run->awk, run->inrec.nflds == 0);
/* get FS */ /* get FS */
fs = sse_awk_getglobal (run, SSE_AWK_GLOBAL_FS); fs = ase_awk_getglobal (run, ASE_AWK_GLOBAL_FS);
if (fs->type == SSE_AWK_VAL_NIL) if (fs->type == ASE_AWK_VAL_NIL)
{ {
fs_ptr = SSE_T(" "); fs_ptr = ASE_T(" ");
fs_len = 1; fs_len = 1;
fs_free = SSE_NULL; fs_free = ASE_NULL;
} }
else if (fs->type == SSE_AWK_VAL_STR) else if (fs->type == ASE_AWK_VAL_STR)
{ {
fs_ptr = ((sse_awk_val_str_t*)fs)->buf; fs_ptr = ((ase_awk_val_str_t*)fs)->buf;
fs_len = ((sse_awk_val_str_t*)fs)->len; fs_len = ((ase_awk_val_str_t*)fs)->len;
fs_free = SSE_NULL; fs_free = ASE_NULL;
} }
else else
{ {
fs_ptr = sse_awk_valtostr ( fs_ptr = ase_awk_valtostr (
run, fs, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &fs_len); run, fs, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &fs_len);
if (fs_ptr == SSE_NULL) return -1; if (fs_ptr == ASE_NULL) return -1;
fs_free = fs_ptr; fs_free = fs_ptr;
} }
/* scan the input record to count the fields */ /* scan the input record to count the fields */
p = SSE_AWK_STR_BUF(&run->inrec.line); p = ASE_AWK_STR_BUF(&run->inrec.line);
len = SSE_AWK_STR_LEN(&run->inrec.line); len = ASE_AWK_STR_LEN(&run->inrec.line);
nflds = 0; nflds = 0;
while (p != SSE_NULL) while (p != ASE_NULL)
{ {
if (fs_len <= 1) if (fs_len <= 1)
{ {
p = sse_awk_strxntok (run, p = ase_awk_strxntok (run,
p, len, fs_ptr, fs_len, &tok, &tok_len); p, len, fs_ptr, fs_len, &tok, &tok_len);
} }
else else
{ {
p = sse_awk_strxntokbyrex (run, p, len, p = ase_awk_strxntokbyrex (run, p, len,
run->global.fs, &tok, &tok_len, &errnum); run->global.fs, &tok, &tok_len, &errnum);
if (p == SSE_NULL && errnum != SSE_AWK_ENOERR) if (p == ASE_NULL && errnum != ASE_AWK_ENOERR)
{ {
if (fs_free != SSE_NULL) if (fs_free != ASE_NULL)
SSE_AWK_FREE (run->awk, fs_free); ASE_AWK_FREE (run->awk, fs_free);
run->errnum = errnum; run->errnum = errnum;
return -1; return -1;
} }
} }
if (nflds == 0 && p == SSE_NULL && tok_len == 0) if (nflds == 0 && p == ASE_NULL && tok_len == 0)
{ {
/* there are no fields. it can just return here /* there are no fields. it can just return here
* as sse_awk_clrrec has been called before this */ * as ase_awk_clrrec has been called before this */
if (fs_free != SSE_NULL) SSE_AWK_FREE (run->awk, fs_free); if (fs_free != ASE_NULL) ASE_AWK_FREE (run->awk, fs_free);
return 0; return 0;
} }
sse_awk_assert (run->awk, ase_awk_assert (run->awk,
(tok != SSE_NULL && tok_len > 0) || tok_len == 0); (tok != ASE_NULL && tok_len > 0) || tok_len == 0);
nflds++; nflds++;
len = SSE_AWK_STR_LEN(&run->inrec.line) - len = ASE_AWK_STR_LEN(&run->inrec.line) -
(p - SSE_AWK_STR_BUF(&run->inrec.line)); (p - ASE_AWK_STR_BUF(&run->inrec.line));
} }
/* allocate space */ /* allocate space */
if (nflds > run->inrec.maxflds) if (nflds > run->inrec.maxflds)
{ {
void* tmp = SSE_AWK_MALLOC ( void* tmp = ASE_AWK_MALLOC (
run->awk, sse_sizeof(*run->inrec.flds) * nflds); run->awk, ase_sizeof(*run->inrec.flds) * nflds);
if (tmp == SSE_NULL) if (tmp == ASE_NULL)
{ {
if (fs_free != SSE_NULL) SSE_AWK_FREE (run->awk, fs_free); if (fs_free != ASE_NULL) ASE_AWK_FREE (run->awk, fs_free);
run->errnum = SSE_AWK_ENOMEM; run->errnum = ASE_AWK_ENOMEM;
return -1; return -1;
} }
if (run->inrec.flds != SSE_NULL) if (run->inrec.flds != ASE_NULL)
SSE_AWK_FREE (run->awk, run->inrec.flds); ASE_AWK_FREE (run->awk, run->inrec.flds);
run->inrec.flds = tmp; run->inrec.flds = tmp;
run->inrec.maxflds = nflds; run->inrec.maxflds = nflds;
} }
/* scan again and split it */ /* scan again and split it */
p = SSE_AWK_STR_BUF(&run->inrec.line); p = ASE_AWK_STR_BUF(&run->inrec.line);
len = SSE_AWK_STR_LEN(&run->inrec.line); len = ASE_AWK_STR_LEN(&run->inrec.line);
while (p != SSE_NULL) while (p != ASE_NULL)
{ {
if (fs_len <= 1) if (fs_len <= 1)
{ {
p = sse_awk_strxntok ( p = ase_awk_strxntok (
run, p, len, fs_ptr, fs_len, &tok, &tok_len); run, p, len, fs_ptr, fs_len, &tok, &tok_len);
} }
else else
{ {
p = sse_awk_strxntokbyrex (run, p, len, p = ase_awk_strxntokbyrex (run, p, len,
run->global.fs, &tok, &tok_len, &errnum); run->global.fs, &tok, &tok_len, &errnum);
if (p == SSE_NULL && errnum != SSE_AWK_ENOERR) if (p == ASE_NULL && errnum != ASE_AWK_ENOERR)
{ {
if (fs_free != SSE_NULL) if (fs_free != ASE_NULL)
SSE_AWK_FREE (run->awk, fs_free); ASE_AWK_FREE (run->awk, fs_free);
run->errnum = errnum; run->errnum = errnum;
return -1; return -1;
} }
} }
sse_awk_assert (run->awk, ase_awk_assert (run->awk,
(tok != SSE_NULL && tok_len > 0) || tok_len == 0); (tok != ASE_NULL && tok_len > 0) || tok_len == 0);
run->inrec.flds[run->inrec.nflds].ptr = tok; run->inrec.flds[run->inrec.nflds].ptr = tok;
run->inrec.flds[run->inrec.nflds].len = tok_len; run->inrec.flds[run->inrec.nflds].len = tok_len;
run->inrec.flds[run->inrec.nflds].val = run->inrec.flds[run->inrec.nflds].val =
sse_awk_makestrval (run, tok, tok_len); ase_awk_makestrval (run, tok, tok_len);
if (run->inrec.flds[run->inrec.nflds].val == SSE_NULL) if (run->inrec.flds[run->inrec.nflds].val == ASE_NULL)
{ {
if (fs_free != SSE_NULL) SSE_AWK_FREE (run->awk, fs_free); if (fs_free != ASE_NULL) ASE_AWK_FREE (run->awk, fs_free);
run->errnum = SSE_AWK_ENOMEM; run->errnum = ASE_AWK_ENOMEM;
return -1; return -1;
} }
sse_awk_refupval (run->inrec.flds[run->inrec.nflds].val); ase_awk_refupval (run->inrec.flds[run->inrec.nflds].val);
run->inrec.nflds++; run->inrec.nflds++;
len = SSE_AWK_STR_LEN(&run->inrec.line) - len = ASE_AWK_STR_LEN(&run->inrec.line) -
(p - SSE_AWK_STR_BUF(&run->inrec.line)); (p - ASE_AWK_STR_BUF(&run->inrec.line));
} }
if (fs_free != SSE_NULL) SSE_AWK_FREE (run->awk, fs_free); if (fs_free != ASE_NULL) ASE_AWK_FREE (run->awk, fs_free);
/* set the number of fields */ /* set the number of fields */
v = sse_awk_makeintval (run, (sse_long_t)nflds); v = ase_awk_makeintval (run, (ase_long_t)nflds);
if (v == SSE_NULL) if (v == ASE_NULL)
{ {
run->errnum = SSE_AWK_ENOMEM; run->errnum = ASE_AWK_ENOMEM;
return -1; return -1;
} }
if (sse_awk_setglobal (run, SSE_AWK_GLOBAL_NF, v) == -1) return -1; if (ase_awk_setglobal (run, ASE_AWK_GLOBAL_NF, v) == -1) return -1;
sse_awk_assert (run->awk, nflds == run->inrec.nflds); ase_awk_assert (run->awk, nflds == run->inrec.nflds);
return 0; return 0;
} }
int sse_awk_clrrec (sse_awk_run_t* run, sse_bool_t skip_inrec_line) int ase_awk_clrrec (ase_awk_run_t* run, ase_bool_t skip_inrec_line)
{ {
sse_size_t i; ase_size_t i;
int n = 0; int n = 0;
if (run->inrec.d0 != sse_awk_val_nil) if (run->inrec.d0 != ase_awk_val_nil)
{ {
sse_awk_refdownval (run, run->inrec.d0); ase_awk_refdownval (run, run->inrec.d0);
run->inrec.d0 = sse_awk_val_nil; run->inrec.d0 = ase_awk_val_nil;
} }
if (run->inrec.nflds > 0) if (run->inrec.nflds > 0)
{ {
sse_awk_assert (run->awk, run->inrec.flds != SSE_NULL); ase_awk_assert (run->awk, run->inrec.flds != ASE_NULL);
for (i = 0; i < run->inrec.nflds; i++) for (i = 0; i < run->inrec.nflds; i++)
{ {
sse_awk_assert (run->awk, ase_awk_assert (run->awk,
run->inrec.flds[i].val != SSE_NULL); run->inrec.flds[i].val != ASE_NULL);
sse_awk_refdownval (run, run->inrec.flds[i].val); ase_awk_refdownval (run, run->inrec.flds[i].val);
} }
run->inrec.nflds = 0; run->inrec.nflds = 0;
if (sse_awk_setglobal ( if (ase_awk_setglobal (
run, SSE_AWK_GLOBAL_NF, sse_awk_val_zero) == -1) run, ASE_AWK_GLOBAL_NF, ase_awk_val_zero) == -1)
{ {
/* first of all, this should never happen. /* first of all, this should never happen.
* if it happened, it would return an error * if it happened, it would return an error
@ -273,23 +273,23 @@ int sse_awk_clrrec (sse_awk_run_t* run, sse_bool_t skip_inrec_line)
} }
} }
sse_awk_assert (run->awk, run->inrec.nflds == 0); ase_awk_assert (run->awk, run->inrec.nflds == 0);
if (!skip_inrec_line) sse_awk_str_clear (&run->inrec.line); if (!skip_inrec_line) ase_awk_str_clear (&run->inrec.line);
return n; return n;
} }
static int __recomp_record_fields ( static int __recomp_record_fields (
sse_awk_run_t* run, sse_size_t lv, ase_awk_run_t* run, ase_size_t lv,
const sse_char_t* str, sse_size_t len) const ase_char_t* str, ase_size_t len)
{ {
sse_awk_val_t* v; ase_awk_val_t* v;
sse_size_t max, i, nflds; ase_size_t max, i, nflds;
/* recomposes the record and the fields when $N has been assigned /* recomposes the record and the fields when $N has been assigned
* a new value and recomputes NF accordingly */ * a new value and recomputes NF accordingly */
sse_awk_assert (run->awk, lv > 0); ase_awk_assert (run->awk, lv > 0);
max = (lv > run->inrec.nflds)? lv: run->inrec.nflds; max = (lv > run->inrec.nflds)? lv: run->inrec.nflds;
nflds = run->inrec.nflds; nflds = run->inrec.nflds;
@ -301,31 +301,31 @@ static int __recomp_record_fields (
* number of fields that the current record can hold, * number of fields that the current record can hold,
* the field spaces are resized */ * the field spaces are resized */
if (run->awk->syscas.realloc != SSE_NULL) if (run->awk->syscas.realloc != ASE_NULL)
{ {
tmp = SSE_AWK_REALLOC ( tmp = ASE_AWK_REALLOC (
run->awk, run->inrec.flds, run->awk, run->inrec.flds,
sse_sizeof(*run->inrec.flds) * max); ase_sizeof(*run->inrec.flds) * max);
if (tmp == SSE_NULL) if (tmp == ASE_NULL)
{ {
run->errnum = SSE_AWK_ENOMEM; run->errnum = ASE_AWK_ENOMEM;
return -1; return -1;
} }
} }
else else
{ {
tmp = SSE_AWK_MALLOC ( tmp = ASE_AWK_MALLOC (
run->awk, sse_sizeof(*run->inrec.flds) * max); run->awk, ase_sizeof(*run->inrec.flds) * max);
if (tmp == SSE_NULL) if (tmp == ASE_NULL)
{ {
run->errnum = SSE_AWK_ENOMEM; run->errnum = ASE_AWK_ENOMEM;
return -1; return -1;
} }
if (run->inrec.flds != SSE_NULL) if (run->inrec.flds != ASE_NULL)
{ {
SSE_AWK_MEMCPY (run->awk, tmp, run->inrec.flds, ASE_AWK_MEMCPY (run->awk, tmp, run->inrec.flds,
sse_sizeof(*run->inrec.flds) * run->inrec.maxflds); ase_sizeof(*run->inrec.flds) * run->inrec.maxflds);
SSE_AWK_FREE (run->awk, run->inrec.flds); ASE_AWK_FREE (run->awk, run->inrec.flds);
} }
} }
@ -335,107 +335,107 @@ static int __recomp_record_fields (
lv = lv - 1; /* adjust the value to 0-based index */ lv = lv - 1; /* adjust the value to 0-based index */
sse_awk_str_clear (&run->inrec.line); ase_awk_str_clear (&run->inrec.line);
for (i = 0; i < max; i++) for (i = 0; i < max; i++)
{ {
if (i > 0) if (i > 0)
{ {
if (sse_awk_str_ncat ( if (ase_awk_str_ncat (
&run->inrec.line, &run->inrec.line,
run->global.ofs.ptr, run->global.ofs.ptr,
run->global.ofs.len) == (sse_size_t)-1) run->global.ofs.len) == (ase_size_t)-1)
{ {
run->errnum = SSE_AWK_ENOMEM; run->errnum = ASE_AWK_ENOMEM;
return -1; return -1;
} }
} }
if (i == lv) if (i == lv)
{ {
sse_awk_val_t* tmp; ase_awk_val_t* tmp;
run->inrec.flds[i].ptr = run->inrec.flds[i].ptr =
SSE_AWK_STR_BUF(&run->inrec.line) + ASE_AWK_STR_BUF(&run->inrec.line) +
SSE_AWK_STR_LEN(&run->inrec.line); ASE_AWK_STR_LEN(&run->inrec.line);
run->inrec.flds[i].len = len; run->inrec.flds[i].len = len;
if (sse_awk_str_ncat ( if (ase_awk_str_ncat (
&run->inrec.line, str, len) == (sse_size_t)-1) &run->inrec.line, str, len) == (ase_size_t)-1)
{ {
run->errnum = SSE_AWK_ENOMEM; run->errnum = ASE_AWK_ENOMEM;
return -1; return -1;
} }
tmp = sse_awk_makestrval (run, str,len); tmp = ase_awk_makestrval (run, str,len);
if (tmp == SSE_NULL) if (tmp == ASE_NULL)
{ {
run->errnum = SSE_AWK_ENOMEM; run->errnum = ASE_AWK_ENOMEM;
return -1; return -1;
} }
if (i < nflds) if (i < nflds)
sse_awk_refdownval (run, run->inrec.flds[i].val); ase_awk_refdownval (run, run->inrec.flds[i].val);
else run->inrec.nflds++; else run->inrec.nflds++;
run->inrec.flds[i].val = tmp; run->inrec.flds[i].val = tmp;
sse_awk_refupval (tmp); ase_awk_refupval (tmp);
} }
else if (i >= nflds) else if (i >= nflds)
{ {
run->inrec.flds[i].ptr = run->inrec.flds[i].ptr =
SSE_AWK_STR_BUF(&run->inrec.line) + ASE_AWK_STR_BUF(&run->inrec.line) +
SSE_AWK_STR_LEN(&run->inrec.line); ASE_AWK_STR_LEN(&run->inrec.line);
run->inrec.flds[i].len = 0; run->inrec.flds[i].len = 0;
if (sse_awk_str_cat ( if (ase_awk_str_cat (
&run->inrec.line, SSE_T("")) == (sse_size_t)-1) &run->inrec.line, ASE_T("")) == (ase_size_t)-1)
{ {
run->errnum = SSE_AWK_ENOMEM; run->errnum = ASE_AWK_ENOMEM;
return -1; return -1;
} }
/* sse_awk_refdownval should not be called over /* ase_awk_refdownval should not be called over
* run->inrec.flds[i].val as it is not initialized * run->inrec.flds[i].val as it is not initialized
* to any valid values */ * to any valid values */
/*sse_awk_refdownval (run, run->inrec.flds[i].val);*/ /*ase_awk_refdownval (run, run->inrec.flds[i].val);*/
run->inrec.flds[i].val = sse_awk_val_zls; run->inrec.flds[i].val = ase_awk_val_zls;
sse_awk_refupval (sse_awk_val_zls); ase_awk_refupval (ase_awk_val_zls);
run->inrec.nflds++; run->inrec.nflds++;
} }
else else
{ {
sse_awk_val_str_t* tmp; ase_awk_val_str_t* tmp;
tmp = (sse_awk_val_str_t*)run->inrec.flds[i].val; tmp = (ase_awk_val_str_t*)run->inrec.flds[i].val;
run->inrec.flds[i].ptr = run->inrec.flds[i].ptr =
SSE_AWK_STR_BUF(&run->inrec.line) + ASE_AWK_STR_BUF(&run->inrec.line) +
SSE_AWK_STR_LEN(&run->inrec.line); ASE_AWK_STR_LEN(&run->inrec.line);
run->inrec.flds[i].len = tmp->len; run->inrec.flds[i].len = tmp->len;
if (sse_awk_str_ncat (&run->inrec.line, if (ase_awk_str_ncat (&run->inrec.line,
tmp->buf, tmp->len) == (sse_size_t)-1) tmp->buf, tmp->len) == (ase_size_t)-1)
{ {
run->errnum = SSE_AWK_ENOMEM; run->errnum = ASE_AWK_ENOMEM;
return -1; return -1;
} }
} }
} }
v = sse_awk_getglobal (run, SSE_AWK_GLOBAL_NF); v = ase_awk_getglobal (run, ASE_AWK_GLOBAL_NF);
sse_awk_assert (run->awk, v->type == SSE_AWK_VAL_INT); ase_awk_assert (run->awk, v->type == ASE_AWK_VAL_INT);
if (((sse_awk_val_int_t*)v)->val != max) if (((ase_awk_val_int_t*)v)->val != max)
{ {
v = sse_awk_makeintval (run, (sse_long_t)max); v = ase_awk_makeintval (run, (ase_long_t)max);
if (v == SSE_NULL) if (v == ASE_NULL)
{ {
run->errnum = SSE_AWK_ENOMEM; run->errnum = ASE_AWK_ENOMEM;
return -1; return -1;
} }
if (sse_awk_setglobal ( if (ase_awk_setglobal (
run, SSE_AWK_GLOBAL_NF, v) == -1) return -1; run, ASE_AWK_GLOBAL_NF, v) == -1) return -1;
} }
return 0; return 0;

980
ase/awk/rex.c
View File

File diff suppressed because it is too large Load Diff

40
ase/awk/rex.h
View File

@ -1,12 +1,12 @@
/* /*
* $Id: rex.h,v 1.20 2006-10-22 12:39:29 bacon Exp $ * $Id: rex.h,v 1.21 2006-10-24 04:10:12 bacon Exp $
**/ **/
#ifndef _SSE_AWK_REX_H_ #ifndef _ASE_AWK_REX_H_
#define _SSE_AWK_REX_H_ #define _ASE_AWK_REX_H_
#include <sse/types.h> #include <ase/types.h>
#include <sse/macros.h> #include <ase/macros.h>
/* /*
@ -37,34 +37,34 @@
* ab|xy -> |2|10|4|ORD_CHAR(no bound)|a|ORD_CHAR(no bound)|b|4|ORD_CHAR(no bound)|x|ORD_CHAR(no bound)|y| * ab|xy -> |2|10|4|ORD_CHAR(no bound)|a|ORD_CHAR(no bound)|b|4|ORD_CHAR(no bound)|x|ORD_CHAR(no bound)|y|
*/ */
#define SSE_AWK_REX_NA(code) (*(sse_size_t*)(code)) #define ASE_AWK_REX_NA(code) (*(ase_size_t*)(code))
#define SSE_AWK_REX_LEN(code) \ #define ASE_AWK_REX_LEN(code) \
(*(sse_size_t*)((sse_byte_t*)(code)+sse_sizeof(sse_size_t))) (*(ase_size_t*)((ase_byte_t*)(code)+ase_sizeof(ase_size_t)))
enum sse_awk_rex_option_t enum ase_awk_rex_option_t
{ {
SSE_AWK_REX_IGNORECASE = (1 << 0) ASE_AWK_REX_IGNORECASE = (1 << 0)
}; };
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
void* sse_awk_buildrex ( void* ase_awk_buildrex (
sse_awk_t* awk, const sse_char_t* ptn, ase_awk_t* awk, const ase_char_t* ptn,
sse_size_t len, int* errnum); ase_size_t len, int* errnum);
int sse_awk_matchrex ( int ase_awk_matchrex (
sse_awk_t* awk, void* code, int option, ase_awk_t* awk, void* code, int option,
const sse_char_t* str, sse_size_t len, const ase_char_t* str, ase_size_t len,
const sse_char_t** match_ptr, sse_size_t* match_len, int* errnum); const ase_char_t** match_ptr, ase_size_t* match_len, int* errnum);
void sse_awk_freerex (sse_awk_t* awk, void* code); void ase_awk_freerex (ase_awk_t* awk, void* code);
sse_bool_t sse_awk_isemptyrex (sse_awk_t* awk, void* code); ase_bool_t ase_awk_isemptyrex (ase_awk_t* awk, void* code);
void sse_awk_printrex (void* code); void ase_awk_printrex (void* code);
#ifdef __cplusplus #ifdef __cplusplus
} }

4358
ase/awk/run.c
View File

File diff suppressed because it is too large Load Diff

122
ase/awk/run.h
View File

@ -1,103 +1,103 @@
/* /*
* $Id: run.h,v 1.20 2006-10-22 12:39:30 bacon Exp $ * $Id: run.h,v 1.21 2006-10-24 04:10:12 bacon Exp $
*/ */
#ifndef _SSE_AWK_RUN_H_ #ifndef _ASE_AWK_RUN_H_
#define _SSE_AWK_RUN_H_ #define _ASE_AWK_RUN_H_
#ifndef _SSE_AWK_AWK_H_ #ifndef _ASE_AWK_AWK_H_
#error Never include this file directly. Include <sse/awk/awk.h> instead #error Never include this file directly. Include <ase/awk/awk.h> instead
#endif #endif
enum enum
{ {
/* if you change this, you have to change __assop_str in tree.c */ /* if you change this, you have to change __assop_str in tree.c */
SSE_AWK_ASSOP_NONE, ASE_AWK_ASSOP_NONE,
SSE_AWK_ASSOP_PLUS, ASE_AWK_ASSOP_PLUS,
SSE_AWK_ASSOP_MINUS, ASE_AWK_ASSOP_MINUS,
SSE_AWK_ASSOP_MUL, ASE_AWK_ASSOP_MUL,
SSE_AWK_ASSOP_DIV, ASE_AWK_ASSOP_DIV,
SSE_AWK_ASSOP_MOD, ASE_AWK_ASSOP_MOD,
SSE_AWK_ASSOP_EXP ASE_AWK_ASSOP_EXP
}; };
enum enum
{ {
/* if you change this, you have to change /* if you change this, you have to change
* __binop_str in tree.c and __binop_func in run.c accordingly. */ * __binop_str in tree.c and __binop_func in run.c accordingly. */
SSE_AWK_BINOP_LOR, ASE_AWK_BINOP_LOR,
SSE_AWK_BINOP_LAND, ASE_AWK_BINOP_LAND,
SSE_AWK_BINOP_IN, ASE_AWK_BINOP_IN,
SSE_AWK_BINOP_BOR, ASE_AWK_BINOP_BOR,
SSE_AWK_BINOP_BXOR, ASE_AWK_BINOP_BXOR,
SSE_AWK_BINOP_BAND, ASE_AWK_BINOP_BAND,
SSE_AWK_BINOP_EQ, ASE_AWK_BINOP_EQ,
SSE_AWK_BINOP_NE, ASE_AWK_BINOP_NE,
SSE_AWK_BINOP_GT, ASE_AWK_BINOP_GT,
SSE_AWK_BINOP_GE, ASE_AWK_BINOP_GE,
SSE_AWK_BINOP_LT, ASE_AWK_BINOP_LT,
SSE_AWK_BINOP_LE, ASE_AWK_BINOP_LE,
SSE_AWK_BINOP_LSHIFT, ASE_AWK_BINOP_LSHIFT,
SSE_AWK_BINOP_RSHIFT, ASE_AWK_BINOP_RSHIFT,
SSE_AWK_BINOP_PLUS, ASE_AWK_BINOP_PLUS,
SSE_AWK_BINOP_MINUS, ASE_AWK_BINOP_MINUS,
SSE_AWK_BINOP_MUL, ASE_AWK_BINOP_MUL,
SSE_AWK_BINOP_DIV, ASE_AWK_BINOP_DIV,
SSE_AWK_BINOP_MOD, ASE_AWK_BINOP_MOD,
SSE_AWK_BINOP_EXP, ASE_AWK_BINOP_EXP,
SSE_AWK_BINOP_CONCAT, ASE_AWK_BINOP_CONCAT,
SSE_AWK_BINOP_MA, ASE_AWK_BINOP_MA,
SSE_AWK_BINOP_NM ASE_AWK_BINOP_NM
}; };
enum enum
{ {
/* if you change this, you have to change /* if you change this, you have to change
* __unrop_str in tree.c accordingly. */ * __unrop_str in tree.c accordingly. */
SSE_AWK_UNROP_PLUS, ASE_AWK_UNROP_PLUS,
SSE_AWK_UNROP_MINUS, ASE_AWK_UNROP_MINUS,
SSE_AWK_UNROP_NOT, ASE_AWK_UNROP_NOT,
SSE_AWK_UNROP_BNOT ASE_AWK_UNROP_BNOT
}; };
enum enum
{ {
/* if you change this, you have to change /* if you change this, you have to change
* __incop_str in tree.c accordingly. */ * __incop_str in tree.c accordingly. */
SSE_AWK_INCOP_PLUS, ASE_AWK_INCOP_PLUS,
SSE_AWK_INCOP_MINUS ASE_AWK_INCOP_MINUS
}; };
enum enum
{ {
/* this table should match __bvtab in parse.c. /* this table should match __bvtab in parse.c.
* in addition, sse_awk_setglobal also counts * in addition, ase_awk_setglobal also counts
* on the order of these values */ * on the order of these values */
SSE_AWK_GLOBAL_ARGC, ASE_AWK_GLOBAL_ARGC,
SSE_AWK_GLOBAL_ARGV, ASE_AWK_GLOBAL_ARGV,
SSE_AWK_GLOBAL_CONVFMT, ASE_AWK_GLOBAL_CONVFMT,
SSE_AWK_GLOBAL_ENVIRON, ASE_AWK_GLOBAL_ENVIRON,
SSE_AWK_GLOBAL_ERRNO, ASE_AWK_GLOBAL_ERRNO,
SSE_AWK_GLOBAL_FILENAME, ASE_AWK_GLOBAL_FILENAME,
SSE_AWK_GLOBAL_FNR, ASE_AWK_GLOBAL_FNR,
SSE_AWK_GLOBAL_FS, ASE_AWK_GLOBAL_FS,
SSE_AWK_GLOBAL_IGNORECASE, ASE_AWK_GLOBAL_IGNORECASE,
SSE_AWK_GLOBAL_NF, ASE_AWK_GLOBAL_NF,
SSE_AWK_GLOBAL_NR, ASE_AWK_GLOBAL_NR,
SSE_AWK_GLOBAL_OFMT, ASE_AWK_GLOBAL_OFMT,
SSE_AWK_GLOBAL_OFS, ASE_AWK_GLOBAL_OFS,
SSE_AWK_GLOBAL_ORS, ASE_AWK_GLOBAL_ORS,
SSE_AWK_GLOBAL_RS, ASE_AWK_GLOBAL_RS,
SSE_AWK_GLOBAL_RT, ASE_AWK_GLOBAL_RT,
SSE_AWK_GLOBAL_RSTART, ASE_AWK_GLOBAL_RSTART,
SSE_AWK_GLOBAL_RLENGTH, ASE_AWK_GLOBAL_RLENGTH,
SSE_AWK_GLOBAL_SUBSEP ASE_AWK_GLOBAL_SUBSEP
}; };
#endif #endif

120
ase/awk/str.c
View File

@ -1,51 +1,51 @@
/* /*
* $Id: str.c,v 1.10 2006-10-22 12:52:50 bacon Exp $ * $Id: str.c,v 1.11 2006-10-24 04:10:12 bacon Exp $
*/ */
#include <sse/awk/awk_i.h> #include <ase/awk/awk_i.h>
sse_awk_str_t* sse_awk_str_open ( ase_awk_str_t* ase_awk_str_open (
sse_awk_str_t* str, sse_size_t capa, sse_awk_t* awk) ase_awk_str_t* str, ase_size_t capa, ase_awk_t* awk)
{ {
if (str == SSE_NULL) if (str == ASE_NULL)
{ {
str = (sse_awk_str_t*) str = (ase_awk_str_t*)
SSE_AWK_MALLOC (awk, sizeof(sse_awk_str_t)); ASE_AWK_MALLOC (awk, sizeof(ase_awk_str_t));
if (str == SSE_NULL) return SSE_NULL; if (str == ASE_NULL) return ASE_NULL;
str->__dynamic = sse_true; str->__dynamic = ase_true;
} }
else str->__dynamic = sse_false; else str->__dynamic = ase_false;
str->awk = awk; str->awk = awk;
str->buf = (sse_char_t*) SSE_AWK_MALLOC ( str->buf = (ase_char_t*) ASE_AWK_MALLOC (
awk, sse_sizeof(sse_char_t) * (capa + 1)); awk, ase_sizeof(ase_char_t) * (capa + 1));
if (str->buf == SSE_NULL) if (str->buf == ASE_NULL)
{ {
if (str->__dynamic) SSE_AWK_FREE (awk, str); if (str->__dynamic) ASE_AWK_FREE (awk, str);
return SSE_NULL; return ASE_NULL;
} }
str->size = 0; str->size = 0;
str->capa = capa; str->capa = capa;
str->buf[0] = SSE_T('\0'); str->buf[0] = ASE_T('\0');
return str; return str;
} }
void sse_awk_str_close (sse_awk_str_t* str) void ase_awk_str_close (ase_awk_str_t* str)
{ {
SSE_AWK_FREE (str->awk, str->buf); ASE_AWK_FREE (str->awk, str->buf);
if (str->__dynamic) SSE_AWK_FREE (str->awk, str); if (str->__dynamic) ASE_AWK_FREE (str->awk, str);
} }
void sse_awk_str_forfeit (sse_awk_str_t* str) void ase_awk_str_forfeit (ase_awk_str_t* str)
{ {
if (str->__dynamic) SSE_AWK_FREE (str->awk, str); if (str->__dynamic) ASE_AWK_FREE (str->awk, str);
} }
void sse_awk_str_swap (sse_awk_str_t* str, sse_awk_str_t* str1) void ase_awk_str_swap (ase_awk_str_t* str, ase_awk_str_t* str1)
{ {
sse_awk_str_t tmp; ase_awk_str_t tmp;
tmp.buf = str->buf; tmp.buf = str->buf;
tmp.size = str->size; tmp.size = str->size;
@ -63,69 +63,69 @@ void sse_awk_str_swap (sse_awk_str_t* str, sse_awk_str_t* str1)
str1->awk = tmp.awk; str1->awk = tmp.awk;
} }
sse_size_t sse_awk_str_cpy (sse_awk_str_t* str, const sse_char_t* s) ase_size_t ase_awk_str_cpy (ase_awk_str_t* str, const ase_char_t* s)
{ {
/* TODO: improve it */ /* TODO: improve it */
return sse_awk_str_ncpy (str, s, sse_awk_strlen(s)); return ase_awk_str_ncpy (str, s, ase_awk_strlen(s));
} }
sse_size_t sse_awk_str_ncpy ( ase_size_t ase_awk_str_ncpy (
sse_awk_str_t* str, const sse_char_t* s, sse_size_t len) ase_awk_str_t* str, const ase_char_t* s, ase_size_t len)
{ {
sse_char_t* buf; ase_char_t* buf;
if (len > str->capa) if (len > str->capa)
{ {
buf = (sse_char_t*) SSE_AWK_MALLOC ( buf = (ase_char_t*) ASE_AWK_MALLOC (
str->awk, sse_sizeof(sse_char_t) * (len + 1)); str->awk, ase_sizeof(ase_char_t) * (len + 1));
if (buf == SSE_NULL) return (sse_size_t)-1; if (buf == ASE_NULL) return (ase_size_t)-1;
SSE_AWK_FREE (str->awk, str->buf); ASE_AWK_FREE (str->awk, str->buf);
str->capa = len; str->capa = len;
str->buf = buf; str->buf = buf;
} }
str->size = sse_awk_strncpy (str->buf, s, len); str->size = ase_awk_strncpy (str->buf, s, len);
str->buf[str->size] = SSE_T('\0'); str->buf[str->size] = ASE_T('\0');
return str->size; return str->size;
} }
sse_size_t sse_awk_str_cat (sse_awk_str_t* str, const sse_char_t* s) ase_size_t ase_awk_str_cat (ase_awk_str_t* str, const ase_char_t* s)
{ {
/* TODO: improve it */ /* TODO: improve it */
return sse_awk_str_ncat (str, s, sse_awk_strlen(s)); return ase_awk_str_ncat (str, s, ase_awk_strlen(s));
} }
sse_size_t sse_awk_str_ncat ( ase_size_t ase_awk_str_ncat (
sse_awk_str_t* str, const sse_char_t* s, sse_size_t len) ase_awk_str_t* str, const ase_char_t* s, ase_size_t len)
{ {
if (len > str->capa - str->size) if (len > str->capa - str->size)
{ {
sse_char_t* tmp; ase_char_t* tmp;
sse_size_t capa; ase_size_t capa;
capa = str->size + len; capa = str->size + len;
/* double the capa if necessary for concatenation */ /* double the capa if necessary for concatenation */
if (capa < str->capa * 2) capa = str->capa * 2; if (capa < str->capa * 2) capa = str->capa * 2;
if (str->awk->syscas.realloc != SSE_NULL) if (str->awk->syscas.realloc != ASE_NULL)
{ {
tmp = (sse_char_t*) SSE_AWK_REALLOC ( tmp = (ase_char_t*) ASE_AWK_REALLOC (
str->awk, str->buf, str->awk, str->buf,
sse_sizeof(sse_char_t) * (capa + 1)); ase_sizeof(ase_char_t) * (capa + 1));
if (tmp == SSE_NULL) return (sse_size_t)-1; if (tmp == ASE_NULL) return (ase_size_t)-1;
} }
else else
{ {
tmp = (sse_char_t*) SSE_AWK_MALLOC ( tmp = (ase_char_t*) ASE_AWK_MALLOC (
str->awk, sse_sizeof(sse_char_t) * (capa + 1)); str->awk, ase_sizeof(ase_char_t) * (capa + 1));
if (tmp == SSE_NULL) return (sse_size_t)-1; if (tmp == ASE_NULL) return (ase_size_t)-1;
if (str->buf != SSE_NULL) if (str->buf != ASE_NULL)
{ {
SSE_AWK_MEMCPY (str->awk, tmp, str->buf, ASE_AWK_MEMCPY (str->awk, tmp, str->buf,
sse_sizeof(sse_char_t) * (str->capa + 1)); ase_sizeof(ase_char_t) * (str->capa + 1));
SSE_AWK_FREE (str->awk, str->buf); ASE_AWK_FREE (str->awk, str->buf);
} }
} }
@ -133,23 +133,23 @@ sse_size_t sse_awk_str_ncat (
str->buf = tmp; str->buf = tmp;
} }
str->size += sse_awk_strncpy (&str->buf[str->size], s, len); str->size += ase_awk_strncpy (&str->buf[str->size], s, len);
str->buf[str->size] = SSE_T('\0'); str->buf[str->size] = ASE_T('\0');
return str->size; return str->size;
} }
sse_size_t sse_awk_str_ccat (sse_awk_str_t* str, sse_char_t c) ase_size_t ase_awk_str_ccat (ase_awk_str_t* str, ase_char_t c)
{ {
return sse_awk_str_ncat (str, &c, 1); return ase_awk_str_ncat (str, &c, 1);
} }
sse_size_t sse_awk_str_nccat (sse_awk_str_t* str, sse_char_t c, sse_size_t len) ase_size_t ase_awk_str_nccat (ase_awk_str_t* str, ase_char_t c, ase_size_t len)
{ {
while (len > 0) while (len > 0)
{ {
if (sse_awk_str_ncat (str, &c, 1) == (sse_size_t)-1) if (ase_awk_str_ncat (str, &c, 1) == (ase_size_t)-1)
{ {
return (sse_size_t)-1; return (ase_size_t)-1;
} }
len--; len--;
@ -157,9 +157,9 @@ sse_size_t sse_awk_str_nccat (sse_awk_str_t* str, sse_char_t c, sse_size_t len)
return str->size; return str->size;
} }
void sse_awk_str_clear (sse_awk_str_t* str) void ase_awk_str_clear (ase_awk_str_t* str)
{ {
str->size = 0; str->size = 0;
str->buf[0] = SSE_T('\0'); str->buf[0] = ASE_T('\0');
} }

62
ase/awk/str.h
View File

@ -1,58 +1,58 @@
/* /*
* $Id: str.h,v 1.3 2006-10-22 11:34:53 bacon Exp $ * $Id: str.h,v 1.4 2006-10-24 04:10:12 bacon Exp $
*/ */
#ifndef _SSE_AWK_STR_H_ #ifndef _ASE_AWK_STR_H_
#define _SSE_AWK_STR_H_ #define _ASE_AWK_STR_H_
#ifndef _SSE_AWK_AWK_H_ #ifndef _ASE_AWK_AWK_H_
#error Never include this file directly. Include <sse/awk/awk.h> instead #error Never include this file directly. Include <ase/awk/awk.h> instead
#endif #endif
#define SSE_AWK_STR_LEN(x) ((x)->size) #define ASE_AWK_STR_LEN(x) ((x)->size)
#define SSE_AWK_STR_SIZE(x) ((x)->size + 1) #define ASE_AWK_STR_SIZE(x) ((x)->size + 1)
#define SSE_AWK_STR_CAPA(x) ((x)->capa) #define ASE_AWK_STR_CAPA(x) ((x)->capa)
#define SSE_AWK_STR_BUF(x) ((x)->buf) #define ASE_AWK_STR_BUF(x) ((x)->buf)
#define SSE_AWK_STR_CHAR(x,idx) ((x)->buf[idx]) #define ASE_AWK_STR_CHAR(x,idx) ((x)->buf[idx])
typedef struct sse_awk_str_t sse_awk_str_t; typedef struct ase_awk_str_t ase_awk_str_t;
struct sse_awk_str_t struct ase_awk_str_t
{ {
sse_char_t* buf; ase_char_t* buf;
sse_size_t size; ase_size_t size;
sse_size_t capa; ase_size_t capa;
sse_awk_t* awk; ase_awk_t* awk;
sse_bool_t __dynamic; ase_bool_t __dynamic;
}; };
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
sse_awk_str_t* sse_awk_str_open ( ase_awk_str_t* ase_awk_str_open (
sse_awk_str_t* str, sse_size_t capa, sse_awk_t* awk); ase_awk_str_t* str, ase_size_t capa, ase_awk_t* awk);
void sse_awk_str_close (sse_awk_str_t* str); void ase_awk_str_close (ase_awk_str_t* str);
void sse_awk_str_forfeit (sse_awk_str_t* str); void ase_awk_str_forfeit (ase_awk_str_t* str);
void sse_awk_str_swap (sse_awk_str_t* str, sse_awk_str_t* str2); void ase_awk_str_swap (ase_awk_str_t* str, ase_awk_str_t* str2);
sse_size_t sse_awk_str_cpy (sse_awk_str_t* str, const sse_char_t* s); ase_size_t ase_awk_str_cpy (ase_awk_str_t* str, const ase_char_t* s);
sse_size_t sse_awk_str_ncpy ( ase_size_t ase_awk_str_ncpy (
sse_awk_str_t* str, const sse_char_t* s, sse_size_t len); ase_awk_str_t* str, const ase_char_t* s, ase_size_t len);
sse_size_t sse_awk_str_cat (sse_awk_str_t* str, const sse_char_t* s); ase_size_t ase_awk_str_cat (ase_awk_str_t* str, const ase_char_t* s);
sse_size_t sse_awk_str_ncat ( ase_size_t ase_awk_str_ncat (
sse_awk_str_t* str, const sse_char_t* s, sse_size_t len); ase_awk_str_t* str, const ase_char_t* s, ase_size_t len);
sse_size_t sse_awk_str_ccat (sse_awk_str_t* str, sse_char_t c); ase_size_t ase_awk_str_ccat (ase_awk_str_t* str, ase_char_t c);
sse_size_t sse_awk_str_nccat (sse_awk_str_t* str, sse_char_t c, sse_size_t len); ase_size_t ase_awk_str_nccat (ase_awk_str_t* str, ase_char_t c, ase_size_t len);
void sse_awk_str_clear (sse_awk_str_t* str); void ase_awk_str_clear (ase_awk_str_t* str);
#ifdef __cplusplus #ifdef __cplusplus
} }

156
ase/awk/tab.c
View File

@ -1,89 +1,89 @@
/* /*
* $Id: tab.c,v 1.22 2006-10-22 11:34:53 bacon Exp $ * $Id: tab.c,v 1.23 2006-10-24 04:10:12 bacon Exp $
*/ */
#include <sse/awk/awk_i.h> #include <ase/awk/awk_i.h>
sse_awk_tab_t* sse_awk_tab_open (sse_awk_tab_t* tab, sse_awk_t* awk) ase_awk_tab_t* ase_awk_tab_open (ase_awk_tab_t* tab, ase_awk_t* awk)
{ {
if (tab == SSE_NULL) if (tab == ASE_NULL)
{ {
tab = (sse_awk_tab_t*) SSE_AWK_MALLOC ( tab = (ase_awk_tab_t*) ASE_AWK_MALLOC (
awk, sse_sizeof(sse_awk_tab_t)); awk, ase_sizeof(ase_awk_tab_t));
if (tab == SSE_NULL) return SSE_NULL; if (tab == ASE_NULL) return ASE_NULL;
tab->__dynamic = sse_true; tab->__dynamic = ase_true;
} }
else tab->__dynamic = sse_false; else tab->__dynamic = ase_false;
tab->awk = awk; tab->awk = awk;
tab->buf = SSE_NULL; tab->buf = ASE_NULL;
tab->size = 0; tab->size = 0;
tab->capa = 0; tab->capa = 0;
return tab; return tab;
} }
void sse_awk_tab_close (sse_awk_tab_t* tab) void ase_awk_tab_close (ase_awk_tab_t* tab)
{ {
sse_awk_tab_clear (tab); ase_awk_tab_clear (tab);
if (tab->buf != SSE_NULL) if (tab->buf != ASE_NULL)
{ {
SSE_AWK_FREE (tab->awk, tab->buf); ASE_AWK_FREE (tab->awk, tab->buf);
tab->buf = SSE_NULL; tab->buf = ASE_NULL;
tab->capa = 0; tab->capa = 0;
} }
if (tab->__dynamic) SSE_AWK_FREE (tab->awk, tab); if (tab->__dynamic) ASE_AWK_FREE (tab->awk, tab);
} }
sse_size_t sse_awk_tab_getsize (sse_awk_tab_t* tab) ase_size_t ase_awk_tab_getsize (ase_awk_tab_t* tab)
{ {
return tab->size; return tab->size;
} }
sse_size_t sse_awk_tab_getcapa (sse_awk_tab_t* tab) ase_size_t ase_awk_tab_getcapa (ase_awk_tab_t* tab)
{ {
return tab->capa; return tab->capa;
} }
sse_awk_tab_t* sse_awk_tab_setcapa (sse_awk_tab_t* tab, sse_size_t capa) ase_awk_tab_t* ase_awk_tab_setcapa (ase_awk_tab_t* tab, ase_size_t capa)
{ {
void* tmp; void* tmp;
if (tab->size > capa) if (tab->size > capa)
{ {
sse_awk_tab_remove (tab, capa, tab->size - capa); ase_awk_tab_remove (tab, capa, tab->size - capa);
sse_awk_assert (tab->awk, tab->size <= capa); ase_awk_assert (tab->awk, tab->size <= capa);
} }
if (capa > 0) if (capa > 0)
{ {
if (tab->awk->syscas.realloc != SSE_NULL) if (tab->awk->syscas.realloc != ASE_NULL)
{ {
tmp = SSE_AWK_REALLOC (tab->awk, tmp = ASE_AWK_REALLOC (tab->awk,
tab->buf, sse_sizeof(*tab->buf) * capa); tab->buf, ase_sizeof(*tab->buf) * capa);
if (tmp == SSE_NULL) return SSE_NULL; if (tmp == ASE_NULL) return ASE_NULL;
} }
else else
{ {
tmp = SSE_AWK_MALLOC ( tmp = ASE_AWK_MALLOC (
tab->awk, sse_sizeof(*tab->buf) * capa); tab->awk, ase_sizeof(*tab->buf) * capa);
if (tmp == SSE_NULL) return SSE_NULL; if (tmp == ASE_NULL) return ASE_NULL;
if (tab->buf != SSE_NULL) if (tab->buf != ASE_NULL)
{ {
sse_size_t x; ase_size_t x;
x = (capa > tab->capa)? tab->capa: capa; x = (capa > tab->capa)? tab->capa: capa;
SSE_AWK_MEMCPY ( ASE_AWK_MEMCPY (
tab->awk, tmp, tab->buf, tab->awk, tmp, tab->buf,
sse_sizeof(*tab->buf) * x); ase_sizeof(*tab->buf) * x);
SSE_AWK_FREE (tab->awk, tab->buf); ASE_AWK_FREE (tab->awk, tab->buf);
} }
} }
} }
else else
{ {
if (tab->buf != SSE_NULL) SSE_AWK_FREE (tab->awk, tab->buf); if (tab->buf != ASE_NULL) ASE_AWK_FREE (tab->awk, tab->buf);
tmp = SSE_NULL; tmp = ASE_NULL;
} }
tab->buf = tmp; tab->buf = tmp;
@ -92,14 +92,14 @@ sse_awk_tab_t* sse_awk_tab_setcapa (sse_awk_tab_t* tab, sse_size_t capa)
return tab; return tab;
} }
void sse_awk_tab_clear (sse_awk_tab_t* tab) void ase_awk_tab_clear (ase_awk_tab_t* tab)
{ {
sse_size_t i; ase_size_t i;
for (i = 0; i < tab->size; i++) for (i = 0; i < tab->size; i++)
{ {
SSE_AWK_FREE (tab->awk, tab->buf[i].name); ASE_AWK_FREE (tab->awk, tab->buf[i].name);
tab->buf[i].name = SSE_NULL; tab->buf[i].name = ASE_NULL;
tab->buf[i].name_len = 0; tab->buf[i].name_len = 0;
} }
@ -107,19 +107,19 @@ void sse_awk_tab_clear (sse_awk_tab_t* tab)
} }
sse_size_t sse_awk_tab_insert ( ase_size_t ase_awk_tab_insert (
sse_awk_tab_t* tab, sse_size_t index, ase_awk_tab_t* tab, ase_size_t index,
const sse_char_t* str, sse_size_t len) const ase_char_t* str, ase_size_t len)
{ {
sse_size_t i; ase_size_t i;
sse_char_t* str_dup; ase_char_t* str_dup;
str_dup = sse_awk_strxdup (tab->awk, str, len); str_dup = ase_awk_strxdup (tab->awk, str, len);
if (str_dup == SSE_NULL) return (sse_size_t)-1; if (str_dup == ASE_NULL) return (ase_size_t)-1;
if (index >= tab->capa) if (index >= tab->capa)
{ {
sse_size_t capa; ase_size_t capa;
if (tab->capa <= 0) capa = (index + 1); if (tab->capa <= 0) capa = (index + 1);
else else
@ -127,10 +127,10 @@ sse_size_t sse_awk_tab_insert (
do { capa = tab->capa * 2; } while (index >= capa); do { capa = tab->capa * 2; } while (index >= capa);
} }
if (sse_awk_tab_setcapa(tab,capa) == SSE_NULL) if (ase_awk_tab_setcapa(tab,capa) == ASE_NULL)
{ {
SSE_AWK_FREE (tab->awk, str_dup); ASE_AWK_FREE (tab->awk, str_dup);
return (sse_size_t)-1; return (ase_size_t)-1;
} }
} }
@ -144,10 +144,10 @@ sse_size_t sse_awk_tab_insert (
return index; return index;
} }
sse_size_t sse_awk_tab_remove ( ase_size_t ase_awk_tab_remove (
sse_awk_tab_t* tab, sse_size_t index, sse_size_t count) ase_awk_tab_t* tab, ase_size_t index, ase_size_t count)
{ {
sse_size_t i, j, k; ase_size_t i, j, k;
if (index >= tab->size) return 0; if (index >= tab->size) return 0;
if (count > tab->size - index) count = tab->size - index; if (count > tab->size - index) count = tab->size - index;
@ -158,11 +158,11 @@ sse_size_t sse_awk_tab_remove (
while (i < k) while (i < k)
{ {
SSE_AWK_FREE (tab->awk, tab->buf[i].name); ASE_AWK_FREE (tab->awk, tab->buf[i].name);
if (j >= tab->size) if (j >= tab->size)
{ {
tab->buf[i].name = SSE_NULL; tab->buf[i].name = ASE_NULL;
tab->buf[i].name_len = 0; tab->buf[i].name_len = 0;
i++; i++;
} }
@ -178,60 +178,60 @@ sse_size_t sse_awk_tab_remove (
return count; return count;
} }
sse_size_t sse_awk_tab_add ( ase_size_t ase_awk_tab_add (
sse_awk_tab_t* tab, const sse_char_t* str, sse_size_t len) ase_awk_tab_t* tab, const ase_char_t* str, ase_size_t len)
{ {
return sse_awk_tab_insert (tab, tab->size, str, len); return ase_awk_tab_insert (tab, tab->size, str, len);
} }
sse_size_t sse_awk_tab_find ( ase_size_t ase_awk_tab_find (
sse_awk_tab_t* tab, sse_size_t index, ase_awk_tab_t* tab, ase_size_t index,
const sse_char_t* str, sse_size_t len) const ase_char_t* str, ase_size_t len)
{ {
sse_size_t i; ase_size_t i;
for (i = index; i < tab->size; i++) for (i = index; i < tab->size; i++)
{ {
if (sse_awk_strxncmp ( if (ase_awk_strxncmp (
tab->buf[i].name, tab->buf[i].name_len, tab->buf[i].name, tab->buf[i].name_len,
str, len) == 0) return i; str, len) == 0) return i;
} }
return (sse_size_t)-1; return (ase_size_t)-1;
} }
sse_size_t sse_awk_tab_rfind ( ase_size_t ase_awk_tab_rfind (
sse_awk_tab_t* tab, sse_size_t index, ase_awk_tab_t* tab, ase_size_t index,
const sse_char_t* str, sse_size_t len) const ase_char_t* str, ase_size_t len)
{ {
sse_size_t i; ase_size_t i;
if (index >= tab->size) return (sse_size_t)-1; if (index >= tab->size) return (ase_size_t)-1;
for (i = index + 1; i-- > 0; ) for (i = index + 1; i-- > 0; )
{ {
if (sse_awk_strxncmp ( if (ase_awk_strxncmp (
tab->buf[i].name, tab->buf[i].name_len, tab->buf[i].name, tab->buf[i].name_len,
str, len) == 0) return i; str, len) == 0) return i;
} }
return (sse_size_t)-1; return (ase_size_t)-1;
} }
sse_size_t sse_awk_tab_rrfind ( ase_size_t ase_awk_tab_rrfind (
sse_awk_tab_t* tab, sse_size_t index, ase_awk_tab_t* tab, ase_size_t index,
const sse_char_t* str, sse_size_t len) const ase_char_t* str, ase_size_t len)
{ {
sse_size_t i; ase_size_t i;
if (index >= tab->size) return (sse_size_t)-1; if (index >= tab->size) return (ase_size_t)-1;
for (i = tab->size - index; i-- > 0; ) for (i = tab->size - index; i-- > 0; )
{ {
if (sse_awk_strxncmp ( if (ase_awk_strxncmp (
tab->buf[i].name, tab->buf[i].name_len, tab->buf[i].name, tab->buf[i].name_len,
str, len) == 0) return i; str, len) == 0) return i;
} }
return (sse_size_t)-1; return (ase_size_t)-1;
} }

70
ase/awk/tab.h
View File

@ -1,64 +1,64 @@
/* /*
* $Id: tab.h,v 1.13 2006-10-22 11:34:53 bacon Exp $ * $Id: tab.h,v 1.14 2006-10-24 04:10:12 bacon Exp $
*/ */
#ifndef _SSE_AWK_TAB_H_ #ifndef _ASE_AWK_TAB_H_
#define _SSE_AWK_TAB_H_ #define _ASE_AWK_TAB_H_
#ifndef _SSE_AWK_AWK_H_ #ifndef _ASE_AWK_AWK_H_
#error Never include this file directly. Include <sse/awk/awk.h> instead #error Never include this file directly. Include <ase/awk/awk.h> instead
#endif #endif
/* TODO: you have to turn this into a hash table. /* TODO: you have to turn this into a hash table.
as of now, this is an arrayed table. */ as of now, this is an arrayed table. */
typedef struct sse_awk_tab_t sse_awk_tab_t; typedef struct ase_awk_tab_t ase_awk_tab_t;
struct sse_awk_tab_t struct ase_awk_tab_t
{ {
struct struct
{ {
sse_char_t* name; ase_char_t* name;
sse_size_t name_len; ase_size_t name_len;
}* buf; }* buf;
sse_size_t size; ase_size_t size;
sse_size_t capa; ase_size_t capa;
sse_awk_t* awk; ase_awk_t* awk;
sse_bool_t __dynamic; ase_bool_t __dynamic;
}; };
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
sse_awk_tab_t* sse_awk_tab_open (sse_awk_tab_t* tab, sse_awk_t* awk); ase_awk_tab_t* ase_awk_tab_open (ase_awk_tab_t* tab, ase_awk_t* awk);
void sse_awk_tab_close (sse_awk_tab_t* tab); void ase_awk_tab_close (ase_awk_tab_t* tab);
sse_size_t sse_awk_tab_getsize (sse_awk_tab_t* tab); ase_size_t ase_awk_tab_getsize (ase_awk_tab_t* tab);
sse_size_t sse_awk_tab_getcapa (sse_awk_tab_t* tab); ase_size_t ase_awk_tab_getcapa (ase_awk_tab_t* tab);
sse_awk_tab_t* sse_awk_tab_setcapa (sse_awk_tab_t* tab, sse_size_t capa); ase_awk_tab_t* ase_awk_tab_setcapa (ase_awk_tab_t* tab, ase_size_t capa);
void sse_awk_tab_clear (sse_awk_tab_t* tab); void ase_awk_tab_clear (ase_awk_tab_t* tab);
sse_size_t sse_awk_tab_insert ( ase_size_t ase_awk_tab_insert (
sse_awk_tab_t* tab, sse_size_t index, ase_awk_tab_t* tab, ase_size_t index,
const sse_char_t* str, sse_size_t len); const ase_char_t* str, ase_size_t len);
sse_size_t sse_awk_tab_remove ( ase_size_t ase_awk_tab_remove (
sse_awk_tab_t* tab, sse_size_t index, sse_size_t count); ase_awk_tab_t* tab, ase_size_t index, ase_size_t count);
sse_size_t sse_awk_tab_add ( ase_size_t ase_awk_tab_add (
sse_awk_tab_t* tab, const sse_char_t* str, sse_size_t len); ase_awk_tab_t* tab, const ase_char_t* str, ase_size_t len);
sse_size_t sse_awk_tab_find ( ase_size_t ase_awk_tab_find (
sse_awk_tab_t* tab, sse_size_t index, ase_awk_tab_t* tab, ase_size_t index,
const sse_char_t* str, sse_size_t len); const ase_char_t* str, ase_size_t len);
sse_size_t sse_awk_tab_rfind ( ase_size_t ase_awk_tab_rfind (
sse_awk_tab_t* tab, sse_size_t index, ase_awk_tab_t* tab, ase_size_t index,
const sse_char_t* str, sse_size_t len); const ase_char_t* str, ase_size_t len);
sse_size_t sse_awk_tab_rrfind ( ase_size_t ase_awk_tab_rrfind (
sse_awk_tab_t* tab, sse_size_t index, ase_awk_tab_t* tab, ase_size_t index,
const sse_char_t* str, sse_size_t len); const ase_char_t* str, ase_size_t len);
#ifdef __cplusplus #ifdef __cplusplus
} }

964
ase/awk/tree.c
View File

File diff suppressed because it is too large Load Diff

454
ase/awk/tree.h
View File

@ -1,67 +1,67 @@
/* /*
* $Id: tree.h,v 1.76 2006-10-22 12:39:30 bacon Exp $ * $Id: tree.h,v 1.77 2006-10-24 04:10:12 bacon Exp $
*/ */
#ifndef _SSE_AWK_TREE_H_ #ifndef _ASE_AWK_TREE_H_
#define _SSE_AWK_TREE_H_ #define _ASE_AWK_TREE_H_
#ifndef _SSE_AWK_AWK_H_ #ifndef _ASE_AWK_AWK_H_
#error Never include this file directly. Include <sse/awk/awk.h> instead #error Never include this file directly. Include <ase/awk/awk.h> instead
#endif #endif
enum enum
{ {
SSE_AWK_NDE_NULL, ASE_AWK_NDE_NULL,
/* statement */ /* statement */
SSE_AWK_NDE_BLK, ASE_AWK_NDE_BLK,
SSE_AWK_NDE_IF, ASE_AWK_NDE_IF,
SSE_AWK_NDE_WHILE, ASE_AWK_NDE_WHILE,
SSE_AWK_NDE_DOWHILE, ASE_AWK_NDE_DOWHILE,
SSE_AWK_NDE_FOR, ASE_AWK_NDE_FOR,
SSE_AWK_NDE_FOREACH, ASE_AWK_NDE_FOREACH,
SSE_AWK_NDE_BREAK, ASE_AWK_NDE_BREAK,
SSE_AWK_NDE_CONTINUE, ASE_AWK_NDE_CONTINUE,
SSE_AWK_NDE_RETURN, ASE_AWK_NDE_RETURN,
SSE_AWK_NDE_EXIT, ASE_AWK_NDE_EXIT,
SSE_AWK_NDE_NEXT, ASE_AWK_NDE_NEXT,
SSE_AWK_NDE_NEXTFILE, ASE_AWK_NDE_NEXTFILE,
SSE_AWK_NDE_DELETE, ASE_AWK_NDE_DELETE,
SSE_AWK_NDE_PRINT, ASE_AWK_NDE_PRINT,
/* expression */ /* expression */
/* if you change the following values including their order, /* if you change the following values including their order,
* you should change __eval_func of __eval_expression * you should change __eval_func of __eval_expression
* in run.c accordingly */ * in run.c accordingly */
SSE_AWK_NDE_GRP, ASE_AWK_NDE_GRP,
SSE_AWK_NDE_ASS, ASE_AWK_NDE_ASS,
SSE_AWK_NDE_EXP_BIN, ASE_AWK_NDE_EXP_BIN,
SSE_AWK_NDE_EXP_UNR, ASE_AWK_NDE_EXP_UNR,
SSE_AWK_NDE_EXP_INCPRE, ASE_AWK_NDE_EXP_INCPRE,
SSE_AWK_NDE_EXP_INCPST, ASE_AWK_NDE_EXP_INCPST,
SSE_AWK_NDE_CND, ASE_AWK_NDE_CND,
SSE_AWK_NDE_BFN, ASE_AWK_NDE_BFN,
SSE_AWK_NDE_AFN, ASE_AWK_NDE_AFN,
SSE_AWK_NDE_INT, ASE_AWK_NDE_INT,
SSE_AWK_NDE_REAL, ASE_AWK_NDE_REAL,
SSE_AWK_NDE_STR, ASE_AWK_NDE_STR,
SSE_AWK_NDE_REX, ASE_AWK_NDE_REX,
/* keep this order for the following items otherwise, you may have /* keep this order for the following items otherwise, you may have
* to change __eval_incpre and __eval_incpst in run.c as well as * to change __eval_incpre and __eval_incpst in run.c as well as
* SSE_AWK_VAL_REF_XXX in val.h */ * ASE_AWK_VAL_REF_XXX in val.h */
SSE_AWK_NDE_NAMED, ASE_AWK_NDE_NAMED,
SSE_AWK_NDE_GLOBAL, ASE_AWK_NDE_GLOBAL,
SSE_AWK_NDE_LOCAL, ASE_AWK_NDE_LOCAL,
SSE_AWK_NDE_ARG, ASE_AWK_NDE_ARG,
SSE_AWK_NDE_NAMEDIDX, ASE_AWK_NDE_NAMEDIDX,
SSE_AWK_NDE_GLOBALIDX, ASE_AWK_NDE_GLOBALIDX,
SSE_AWK_NDE_LOCALIDX, ASE_AWK_NDE_LOCALIDX,
SSE_AWK_NDE_ARGIDX, ASE_AWK_NDE_ARGIDX,
SSE_AWK_NDE_POS, ASE_AWK_NDE_POS,
/* ---------------------------------- */ /* ---------------------------------- */
SSE_AWK_NDE_GETLINE, ASE_AWK_NDE_GETLINE,
}; };
enum enum
@ -69,10 +69,10 @@ enum
/* the order of these values match /* the order of these values match
* __in_type_map and __in_opt_map in extio.c */ * __in_type_map and __in_opt_map in extio.c */
SSE_AWK_IN_PIPE, ASE_AWK_IN_PIPE,
SSE_AWK_IN_COPROC, ASE_AWK_IN_COPROC,
SSE_AWK_IN_FILE, ASE_AWK_IN_FILE,
SSE_AWK_IN_CONSOLE ASE_AWK_IN_CONSOLE
}; };
enum enum
@ -80,298 +80,298 @@ enum
/* the order of these values match /* the order of these values match
* __out_type_map and __out_opt_map in extio.c */ * __out_type_map and __out_opt_map in extio.c */
SSE_AWK_OUT_PIPE, ASE_AWK_OUT_PIPE,
SSE_AWK_OUT_COPROC, ASE_AWK_OUT_COPROC,
SSE_AWK_OUT_FILE, ASE_AWK_OUT_FILE,
SSE_AWK_OUT_FILE_APPEND, ASE_AWK_OUT_FILE_APPEND,
SSE_AWK_OUT_CONSOLE ASE_AWK_OUT_CONSOLE
}; };
/* afn (awk function defined with the keyword function) */ /* afn (awk function defined with the keyword function) */
typedef struct sse_awk_afn_t sse_awk_afn_t; typedef struct ase_awk_afn_t ase_awk_afn_t;
typedef struct sse_awk_nde_t sse_awk_nde_t; typedef struct ase_awk_nde_t ase_awk_nde_t;
typedef struct sse_awk_nde_blk_t sse_awk_nde_blk_t; typedef struct ase_awk_nde_blk_t ase_awk_nde_blk_t;
typedef struct sse_awk_nde_grp_t sse_awk_nde_grp_t; typedef struct ase_awk_nde_grp_t ase_awk_nde_grp_t;
typedef struct sse_awk_nde_ass_t sse_awk_nde_ass_t; typedef struct ase_awk_nde_ass_t ase_awk_nde_ass_t;
typedef struct sse_awk_nde_exp_t sse_awk_nde_exp_t; typedef struct ase_awk_nde_exp_t ase_awk_nde_exp_t;
typedef struct sse_awk_nde_cnd_t sse_awk_nde_cnd_t; typedef struct ase_awk_nde_cnd_t ase_awk_nde_cnd_t;
typedef struct sse_awk_nde_pos_t sse_awk_nde_pos_t; typedef struct ase_awk_nde_pos_t ase_awk_nde_pos_t;
typedef struct sse_awk_nde_int_t sse_awk_nde_int_t; typedef struct ase_awk_nde_int_t ase_awk_nde_int_t;
typedef struct sse_awk_nde_real_t sse_awk_nde_real_t; typedef struct ase_awk_nde_real_t ase_awk_nde_real_t;
typedef struct sse_awk_nde_str_t sse_awk_nde_str_t; typedef struct ase_awk_nde_str_t ase_awk_nde_str_t;
typedef struct sse_awk_nde_rex_t sse_awk_nde_rex_t; typedef struct ase_awk_nde_rex_t ase_awk_nde_rex_t;
typedef struct sse_awk_nde_var_t sse_awk_nde_var_t; typedef struct ase_awk_nde_var_t ase_awk_nde_var_t;
typedef struct sse_awk_nde_call_t sse_awk_nde_call_t; typedef struct ase_awk_nde_call_t ase_awk_nde_call_t;
typedef struct sse_awk_nde_getline_t sse_awk_nde_getline_t; typedef struct ase_awk_nde_getline_t ase_awk_nde_getline_t;
typedef struct sse_awk_nde_if_t sse_awk_nde_if_t; typedef struct ase_awk_nde_if_t ase_awk_nde_if_t;
typedef struct sse_awk_nde_while_t sse_awk_nde_while_t; typedef struct ase_awk_nde_while_t ase_awk_nde_while_t;
typedef struct sse_awk_nde_for_t sse_awk_nde_for_t; typedef struct ase_awk_nde_for_t ase_awk_nde_for_t;
typedef struct sse_awk_nde_foreach_t sse_awk_nde_foreach_t; typedef struct ase_awk_nde_foreach_t ase_awk_nde_foreach_t;
typedef struct sse_awk_nde_break_t sse_awk_nde_break_t; typedef struct ase_awk_nde_break_t ase_awk_nde_break_t;
typedef struct sse_awk_nde_continue_t sse_awk_nde_continue_t; typedef struct ase_awk_nde_continue_t ase_awk_nde_continue_t;
typedef struct sse_awk_nde_return_t sse_awk_nde_return_t; typedef struct ase_awk_nde_return_t ase_awk_nde_return_t;
typedef struct sse_awk_nde_exit_t sse_awk_nde_exit_t; typedef struct ase_awk_nde_exit_t ase_awk_nde_exit_t;
typedef struct sse_awk_nde_next_t sse_awk_nde_next_t; typedef struct ase_awk_nde_next_t ase_awk_nde_next_t;
typedef struct sse_awk_nde_nextfile_t sse_awk_nde_nextfile_t; typedef struct ase_awk_nde_nextfile_t ase_awk_nde_nextfile_t;
typedef struct sse_awk_nde_delete_t sse_awk_nde_delete_t; typedef struct ase_awk_nde_delete_t ase_awk_nde_delete_t;
typedef struct sse_awk_nde_print_t sse_awk_nde_print_t; typedef struct ase_awk_nde_print_t ase_awk_nde_print_t;
struct sse_awk_afn_t struct ase_awk_afn_t
{ {
sse_char_t* name; ase_char_t* name;
sse_size_t name_len; ase_size_t name_len;
sse_size_t nargs; ase_size_t nargs;
sse_awk_nde_t* body; ase_awk_nde_t* body;
}; };
#define SSE_AWK_NDE_HDR \ #define ASE_AWK_NDE_HDR \
int type; \ int type; \
sse_awk_nde_t* next ase_awk_nde_t* next
struct sse_awk_nde_t struct ase_awk_nde_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
}; };
/* SSE_AWK_NDE_BLK - block statement including top-level blocks */ /* ASE_AWK_NDE_BLK - block statement including top-level blocks */
struct sse_awk_nde_blk_t struct ase_awk_nde_blk_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
sse_size_t nlocals; ase_size_t nlocals;
sse_awk_nde_t* body; ase_awk_nde_t* body;
}; };
/* SSE_AWK_NDE_GRP - expression group */ /* ASE_AWK_NDE_GRP - expression group */
struct sse_awk_nde_grp_t struct ase_awk_nde_grp_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
sse_awk_nde_t* body; ase_awk_nde_t* body;
}; };
/* SSE_AWK_NDE_ASS - assignment */ /* ASE_AWK_NDE_ASS - assignment */
struct sse_awk_nde_ass_t struct ase_awk_nde_ass_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
int opcode; int opcode;
sse_awk_nde_t* left; ase_awk_nde_t* left;
sse_awk_nde_t* right; ase_awk_nde_t* right;
}; };
/* SSE_AWK_NDE_EXP_BIN, SSE_AWK_NDE_EXP_UNR, /* ASE_AWK_NDE_EXP_BIN, ASE_AWK_NDE_EXP_UNR,
* SSE_AWK_NDE_EXP_INCPRE, SSE_AW_NDE_EXP_INCPST */ * ASE_AWK_NDE_EXP_INCPRE, ASE_AW_NDE_EXP_INCPST */
struct sse_awk_nde_exp_t struct ase_awk_nde_exp_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
int opcode; int opcode;
sse_awk_nde_t* left; ase_awk_nde_t* left;
sse_awk_nde_t* right; /* SSE_NULL for UNR, INCPRE, INCPST */ ase_awk_nde_t* right; /* ASE_NULL for UNR, INCPRE, INCPST */
}; };
/* SSE_AWK_NDE_CND */ /* ASE_AWK_NDE_CND */
struct sse_awk_nde_cnd_t struct ase_awk_nde_cnd_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
sse_awk_nde_t* test; ase_awk_nde_t* test;
sse_awk_nde_t* left; ase_awk_nde_t* left;
sse_awk_nde_t* right; ase_awk_nde_t* right;
}; };
/* SSE_AWK_NDE_POS - positional - $1, $2, $x, etc */ /* ASE_AWK_NDE_POS - positional - $1, $2, $x, etc */
struct sse_awk_nde_pos_t struct ase_awk_nde_pos_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
sse_awk_nde_t* val; ase_awk_nde_t* val;
}; };
/* SSE_AWK_NDE_INT */ /* ASE_AWK_NDE_INT */
struct sse_awk_nde_int_t struct ase_awk_nde_int_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
sse_long_t val; ase_long_t val;
sse_char_t* str; ase_char_t* str;
sse_size_t len; ase_size_t len;
}; };
/* SSE_AWK_NDE_REAL */ /* ASE_AWK_NDE_REAL */
struct sse_awk_nde_real_t struct ase_awk_nde_real_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
sse_real_t val; ase_real_t val;
sse_char_t* str; ase_char_t* str;
sse_size_t len; ase_size_t len;
}; };
/* SSE_AWK_NDE_STR */ /* ASE_AWK_NDE_STR */
struct sse_awk_nde_str_t struct ase_awk_nde_str_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
sse_char_t* buf; ase_char_t* buf;
sse_size_t len; ase_size_t len;
}; };
/* SSE_AWK_NDE_REX */ /* ASE_AWK_NDE_REX */
struct sse_awk_nde_rex_t struct ase_awk_nde_rex_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
sse_char_t* buf; ase_char_t* buf;
sse_size_t len; ase_size_t len;
void* code; void* code;
}; };
/* SSE_AWK_NDE_NAMED, SSE_AWK_NDE_GLOBAL, /* ASE_AWK_NDE_NAMED, ASE_AWK_NDE_GLOBAL,
* SSE_AWK_NDE_LOCAL, SSE_AWK_NDE_ARG * ASE_AWK_NDE_LOCAL, ASE_AWK_NDE_ARG
* SSE_AWK_NDE_NAMEDIDX, SSE_AWK_NDE_GLOBALIDX, * ASE_AWK_NDE_NAMEDIDX, ASE_AWK_NDE_GLOBALIDX,
* SSE_AWK_NDE_LOCALIDX, SSE_AWK_NDE_ARGIDX */ * ASE_AWK_NDE_LOCALIDX, ASE_AWK_NDE_ARGIDX */
struct sse_awk_nde_var_t struct ase_awk_nde_var_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
struct struct
{ {
sse_char_t* name; ase_char_t* name;
sse_size_t name_len; ase_size_t name_len;
sse_size_t idxa; ase_size_t idxa;
} id; } id;
sse_awk_nde_t* idx; /* SSE_NULL for non-XXXXIDX */ ase_awk_nde_t* idx; /* ASE_NULL for non-XXXXIDX */
}; };
/* SSE_AWK_NDE_BFN, SSE_AWK_NDE_AFN */ /* ASE_AWK_NDE_BFN, ASE_AWK_NDE_AFN */
struct sse_awk_nde_call_t struct ase_awk_nde_call_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
union union
{ {
struct struct
{ {
sse_char_t* name; ase_char_t* name;
sse_size_t name_len; ase_size_t name_len;
} afn; } afn;
/* minimum information of a built-in function /* minimum information of a built-in function
* needed during run-time. */ * needed during run-time. */
struct struct
{ {
const sse_char_t* name; const ase_char_t* name;
sse_size_t name_len; ase_size_t name_len;
sse_size_t min_args; ase_size_t min_args;
sse_size_t max_args; ase_size_t max_args;
const sse_char_t* arg_spec; const ase_char_t* arg_spec;
int (*handler) (sse_awk_run_t* awk); int (*handler) (ase_awk_run_t* awk);
} bfn; } bfn;
/* sse_awk_bfn_t* bfn; */ /* ase_awk_bfn_t* bfn; */
} what; } what;
sse_awk_nde_t* args; ase_awk_nde_t* args;
sse_size_t nargs; ase_size_t nargs;
}; };
/* SSE_AWK_NDE_GETLINE */ /* ASE_AWK_NDE_GETLINE */
struct sse_awk_nde_getline_t struct ase_awk_nde_getline_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
sse_awk_nde_t* var; ase_awk_nde_t* var;
int in_type; /* SSE_AWK_GETLINE_XXX */ int in_type; /* ASE_AWK_GETLINE_XXX */
sse_awk_nde_t* in; ase_awk_nde_t* in;
}; };
/* SSE_AWK_NDE_IF */ /* ASE_AWK_NDE_IF */
struct sse_awk_nde_if_t struct ase_awk_nde_if_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
sse_awk_nde_t* test; ase_awk_nde_t* test;
sse_awk_nde_t* then_part; ase_awk_nde_t* then_part;
sse_awk_nde_t* else_part; /* optional */ ase_awk_nde_t* else_part; /* optional */
}; };
/* SSE_AWK_NDE_WHILE, SSE_AWK_NDE_DOWHILE */ /* ASE_AWK_NDE_WHILE, ASE_AWK_NDE_DOWHILE */
struct sse_awk_nde_while_t struct ase_awk_nde_while_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
sse_awk_nde_t* test; ase_awk_nde_t* test;
sse_awk_nde_t* body; ase_awk_nde_t* body;
}; };
/* SSE_AWK_NDE_FOR */ /* ASE_AWK_NDE_FOR */
struct sse_awk_nde_for_t struct ase_awk_nde_for_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
sse_awk_nde_t* init; /* optional */ ase_awk_nde_t* init; /* optional */
sse_awk_nde_t* test; /* optional */ ase_awk_nde_t* test; /* optional */
sse_awk_nde_t* incr; /* optional */ ase_awk_nde_t* incr; /* optional */
sse_awk_nde_t* body; ase_awk_nde_t* body;
}; };
/* SSE_AWK_NDE_FOREACH */ /* ASE_AWK_NDE_FOREACH */
struct sse_awk_nde_foreach_t struct ase_awk_nde_foreach_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
sse_awk_nde_t* test; ase_awk_nde_t* test;
sse_awk_nde_t* body; ase_awk_nde_t* body;
}; };
/* SSE_AWK_NDE_BREAK */ /* ASE_AWK_NDE_BREAK */
struct sse_awk_nde_break_t struct ase_awk_nde_break_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
}; };
/* SSE_AWK_NDE_CONTINUE */ /* ASE_AWK_NDE_CONTINUE */
struct sse_awk_nde_continue_t struct ase_awk_nde_continue_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
}; };
/* SSE_AWK_NDE_RETURN */ /* ASE_AWK_NDE_RETURN */
struct sse_awk_nde_return_t struct ase_awk_nde_return_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
sse_awk_nde_t* val; /* optional (no return code if SSE_NULL) */ ase_awk_nde_t* val; /* optional (no return code if ASE_NULL) */
}; };
/* SSE_AWK_NDE_EXIT */ /* ASE_AWK_NDE_EXIT */
struct sse_awk_nde_exit_t struct ase_awk_nde_exit_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
sse_awk_nde_t* val; /* optional (no exit code if SSE_NULL) */ ase_awk_nde_t* val; /* optional (no exit code if ASE_NULL) */
}; };
/* SSE_AWK_NDE_NEXT */ /* ASE_AWK_NDE_NEXT */
struct sse_awk_nde_next_t struct ase_awk_nde_next_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
}; };
/* SSE_AWK_NDE_NEXTFILE */ /* ASE_AWK_NDE_NEXTFILE */
struct sse_awk_nde_nextfile_t struct ase_awk_nde_nextfile_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
}; };
/* SSE_AWK_NDE_DELETE */ /* ASE_AWK_NDE_DELETE */
struct sse_awk_nde_delete_t struct ase_awk_nde_delete_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
sse_awk_nde_t* var; ase_awk_nde_t* var;
}; };
/* SSE_AWK_NDE_PRINT */ /* ASE_AWK_NDE_PRINT */
struct sse_awk_nde_print_t struct ase_awk_nde_print_t
{ {
SSE_AWK_NDE_HDR; ASE_AWK_NDE_HDR;
sse_awk_nde_t* args; ase_awk_nde_t* args;
int out_type; /* SSE_AWK_OUT_XXX */ int out_type; /* ASE_AWK_OUT_XXX */
sse_awk_nde_t* out; ase_awk_nde_t* out;
}; };
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
int sse_awk_prnpt (sse_awk_t* awk, sse_awk_nde_t* tree); int ase_awk_prnpt (ase_awk_t* awk, ase_awk_nde_t* tree);
int sse_awk_prnptnpt (sse_awk_t* awk, sse_awk_nde_t* tree); int ase_awk_prnptnpt (ase_awk_t* awk, ase_awk_nde_t* tree);
void sse_awk_clrpt (sse_awk_t* awk, sse_awk_nde_t* tree); void ase_awk_clrpt (ase_awk_t* awk, ase_awk_nde_t* tree);
#ifdef __cplusplus #ifdef __cplusplus
} }

680
ase/awk/val.c
View File

File diff suppressed because it is too large Load Diff

198
ase/awk/val.h
View File

@ -1,180 +1,180 @@
/* /*
* $Id: val.h,v 1.47 2006-10-22 11:34:53 bacon Exp $ * $Id: val.h,v 1.48 2006-10-24 04:10:12 bacon Exp $
*/ */
#ifndef _SSE_AWK_VAL_H_ #ifndef _ASE_AWK_VAL_H_
#define _SSE_AWK_VAL_H_ #define _ASE_AWK_VAL_H_
#ifndef _SSE_AWK_AWK_H_ #ifndef _ASE_AWK_AWK_H_
#error Never include this file directly. Include <sse/awk/awk.h> instead #error Never include this file directly. Include <ase/awk/awk.h> instead
#endif #endif
enum enum
{ {
/* the values between SSE_AWK_VAL_NIL and SSE_AWK_VAL_STR inclusive /* the values between ASE_AWK_VAL_NIL and ASE_AWK_VAL_STR inclusive
* must be synchronized with an internal table of the __cmp_val * must be synchronized with an internal table of the __cmp_val
* function in run.c */ * function in run.c */
SSE_AWK_VAL_NIL = 0, ASE_AWK_VAL_NIL = 0,
SSE_AWK_VAL_INT = 1, ASE_AWK_VAL_INT = 1,
SSE_AWK_VAL_REAL = 2, ASE_AWK_VAL_REAL = 2,
SSE_AWK_VAL_STR = 3, ASE_AWK_VAL_STR = 3,
SSE_AWK_VAL_REX = 4, ASE_AWK_VAL_REX = 4,
SSE_AWK_VAL_MAP = 5, ASE_AWK_VAL_MAP = 5,
SSE_AWK_VAL_REF = 6 ASE_AWK_VAL_REF = 6
}; };
enum enum
{ {
/* keep these items in the same order as corresponding items /* keep these items in the same order as corresponding items
* in tree.h */ * in tree.h */
SSE_AWK_VAL_REF_NAMED, ASE_AWK_VAL_REF_NAMED,
SSE_AWK_VAL_REF_GLOBAL, ASE_AWK_VAL_REF_GLOBAL,
SSE_AWK_VAL_REF_LOCAL, ASE_AWK_VAL_REF_LOCAL,
SSE_AWK_VAL_REF_ARG, ASE_AWK_VAL_REF_ARG,
SSE_AWK_VAL_REF_NAMEDIDX, ASE_AWK_VAL_REF_NAMEDIDX,
SSE_AWK_VAL_REF_GLOBALIDX, ASE_AWK_VAL_REF_GLOBALIDX,
SSE_AWK_VAL_REF_LOCALIDX, ASE_AWK_VAL_REF_LOCALIDX,
SSE_AWK_VAL_REF_ARGIDX, ASE_AWK_VAL_REF_ARGIDX,
SSE_AWK_VAL_REF_POS ASE_AWK_VAL_REF_POS
}; };
enum enum
{ {
SSE_AWK_VALTOSTR_CLEAR = (1 << 0), ASE_AWK_VALTOSTR_CLEAR = (1 << 0),
SSE_AWK_VALTOSTR_PRINT = (1 << 1) ASE_AWK_VALTOSTR_PRINT = (1 << 1)
}; };
typedef struct sse_awk_val_nil_t sse_awk_val_nil_t; typedef struct ase_awk_val_nil_t ase_awk_val_nil_t;
typedef struct sse_awk_val_int_t sse_awk_val_int_t; typedef struct ase_awk_val_int_t ase_awk_val_int_t;
typedef struct sse_awk_val_real_t sse_awk_val_real_t; typedef struct ase_awk_val_real_t ase_awk_val_real_t;
typedef struct sse_awk_val_str_t sse_awk_val_str_t; typedef struct ase_awk_val_str_t ase_awk_val_str_t;
typedef struct sse_awk_val_rex_t sse_awk_val_rex_t; typedef struct ase_awk_val_rex_t ase_awk_val_rex_t;
typedef struct sse_awk_val_map_t sse_awk_val_map_t; typedef struct ase_awk_val_map_t ase_awk_val_map_t;
typedef struct sse_awk_val_ref_t sse_awk_val_ref_t; typedef struct ase_awk_val_ref_t ase_awk_val_ref_t;
#if SSE_SIZEOF_INT == 2 #if ASE_SIZEOF_INT == 2
#define SSE_AWK_VAL_HDR \ #define ASE_AWK_VAL_HDR \
unsigned int type: 3; \ unsigned int type: 3; \
unsigned int ref: 13 unsigned int ref: 13
#else #else
#define SSE_AWK_VAL_HDR \ #define ASE_AWK_VAL_HDR \
unsigned int type: 3; \ unsigned int type: 3; \
unsigned int ref: 29 unsigned int ref: 29
#endif #endif
struct sse_awk_val_t struct ase_awk_val_t
{ {
SSE_AWK_VAL_HDR; ASE_AWK_VAL_HDR;
}; };
/* SSE_AWK_VAL_NIL */ /* ASE_AWK_VAL_NIL */
struct sse_awk_val_nil_t struct ase_awk_val_nil_t
{ {
SSE_AWK_VAL_HDR; ASE_AWK_VAL_HDR;
}; };
/* SSE_AWK_VAL_INT */ /* ASE_AWK_VAL_INT */
struct sse_awk_val_int_t struct ase_awk_val_int_t
{ {
SSE_AWK_VAL_HDR; ASE_AWK_VAL_HDR;
sse_long_t val; ase_long_t val;
sse_awk_nde_int_t* nde; ase_awk_nde_int_t* nde;
}; };
/* SSE_AWK_VAL_REAL */ /* ASE_AWK_VAL_REAL */
struct sse_awk_val_real_t struct ase_awk_val_real_t
{ {
SSE_AWK_VAL_HDR; ASE_AWK_VAL_HDR;
sse_real_t val; ase_real_t val;
sse_awk_nde_real_t* nde; ase_awk_nde_real_t* nde;
}; };
/* SSE_AWK_VAL_STR */ /* ASE_AWK_VAL_STR */
struct sse_awk_val_str_t struct ase_awk_val_str_t
{ {
SSE_AWK_VAL_HDR; ASE_AWK_VAL_HDR;
sse_char_t* buf; ase_char_t* buf;
sse_size_t len; ase_size_t len;
}; };
/* SSE_AWK_VAL_REX */ /* ASE_AWK_VAL_REX */
struct sse_awk_val_rex_t struct ase_awk_val_rex_t
{ {
SSE_AWK_VAL_HDR; ASE_AWK_VAL_HDR;
sse_char_t* buf; ase_char_t* buf;
sse_size_t len; ase_size_t len;
void* code; void* code;
}; };
/* SSE_AWK_VAL_MAP */ /* ASE_AWK_VAL_MAP */
struct sse_awk_val_map_t struct ase_awk_val_map_t
{ {
SSE_AWK_VAL_HDR; ASE_AWK_VAL_HDR;
/* TODO: make val_map to array if the indices used are all /* TODO: make val_map to array if the indices used are all
* integers switch to map dynamically once the * integers switch to map dynamically once the
* non-integral index is seen. * non-integral index is seen.
*/ */
sse_awk_map_t* map; ase_awk_map_t* map;
}; };
/* SSE_AWK_VAL_REF */ /* ASE_AWK_VAL_REF */
struct sse_awk_val_ref_t struct ase_awk_val_ref_t
{ {
SSE_AWK_VAL_HDR; ASE_AWK_VAL_HDR;
int id; int id;
/* if id is SSE_AWK_VAL_REF_POS, adr holds an index of the /* if id is ASE_AWK_VAL_REF_POS, adr holds an index of the
* positionalvariable. Otherwise, adr points to the value * positionalvariable. Otherwise, adr points to the value
* directly. */ * directly. */
sse_awk_val_t** adr; ase_awk_val_t** adr;
}; };
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
extern sse_awk_val_t* sse_awk_val_nil; extern ase_awk_val_t* ase_awk_val_nil;
extern sse_awk_val_t* sse_awk_val_zls; extern ase_awk_val_t* ase_awk_val_zls;
extern sse_awk_val_t* sse_awk_val_zero; extern ase_awk_val_t* ase_awk_val_zero;
extern sse_awk_val_t* sse_awk_val_one; extern ase_awk_val_t* ase_awk_val_one;
sse_awk_val_t* sse_awk_makeintval (sse_awk_run_t* run, sse_long_t v); ase_awk_val_t* ase_awk_makeintval (ase_awk_run_t* run, ase_long_t v);
sse_awk_val_t* sse_awk_makerealval (sse_awk_run_t* run, sse_real_t v); ase_awk_val_t* ase_awk_makerealval (ase_awk_run_t* run, ase_real_t v);
sse_awk_val_t* sse_awk_makestrval0 (sse_awk_run_t* run, const sse_char_t* str); ase_awk_val_t* ase_awk_makestrval0 (ase_awk_run_t* run, const ase_char_t* str);
sse_awk_val_t* sse_awk_makestrval ( ase_awk_val_t* ase_awk_makestrval (
sse_awk_run_t* run, const sse_char_t* str, sse_size_t len); ase_awk_run_t* run, const ase_char_t* str, ase_size_t len);
sse_awk_val_t* sse_awk_makestrval2 ( ase_awk_val_t* ase_awk_makestrval2 (
sse_awk_run_t* run, ase_awk_run_t* run,
const sse_char_t* str1, sse_size_t len1, const ase_char_t* str1, ase_size_t len1,
const sse_char_t* str2, sse_size_t len2); const ase_char_t* str2, ase_size_t len2);
sse_awk_val_t* sse_awk_makerexval ( ase_awk_val_t* ase_awk_makerexval (
sse_awk_run_t* run, const sse_char_t* buf, sse_size_t len, void* code); ase_awk_run_t* run, const ase_char_t* buf, ase_size_t len, void* code);
sse_awk_val_t* sse_awk_makemapval (sse_awk_run_t* run); ase_awk_val_t* ase_awk_makemapval (ase_awk_run_t* run);
sse_awk_val_t* sse_awk_makerefval ( ase_awk_val_t* ase_awk_makerefval (
sse_awk_run_t* run, int id, sse_awk_val_t** adr); ase_awk_run_t* run, int id, ase_awk_val_t** adr);
sse_bool_t sse_awk_isbuiltinval (sse_awk_val_t* val); ase_bool_t ase_awk_isbuiltinval (ase_awk_val_t* val);
void sse_awk_freeval (sse_awk_run_t* run, sse_awk_val_t* val, sse_bool_t cache); void ase_awk_freeval (ase_awk_run_t* run, ase_awk_val_t* val, ase_bool_t cache);
void sse_awk_refupval (sse_awk_val_t* val); void ase_awk_refupval (ase_awk_val_t* val);
void sse_awk_refdownval (sse_awk_run_t* run, sse_awk_val_t* val); void ase_awk_refdownval (ase_awk_run_t* run, ase_awk_val_t* val);
void sse_awk_refdownval_nofree (sse_awk_run_t* run, sse_awk_val_t* val); void ase_awk_refdownval_nofree (ase_awk_run_t* run, ase_awk_val_t* val);
sse_bool_t sse_awk_valtobool ( ase_bool_t ase_awk_valtobool (
sse_awk_run_t* run, sse_awk_val_t* val); ase_awk_run_t* run, ase_awk_val_t* val);
sse_char_t* sse_awk_valtostr ( ase_char_t* ase_awk_valtostr (
sse_awk_run_t* run, sse_awk_val_t* val, ase_awk_run_t* run, ase_awk_val_t* val,
int opt, sse_awk_str_t* buf, sse_size_t* len); int opt, ase_awk_str_t* buf, ase_size_t* len);
int sse_awk_valtonum ( int ase_awk_valtonum (
sse_awk_run_t* run, sse_awk_val_t* v, sse_long_t* l, sse_real_t* r); ase_awk_run_t* run, ase_awk_val_t* v, ase_long_t* l, ase_real_t* r);
void sse_awk_printval (sse_awk_val_t* val); void ase_awk_printval (ase_awk_val_t* val);
#ifdef __cplusplus #ifdef __cplusplus
} }