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__)
@ -7,111 +7,111 @@
#define Library
#endif
#include <sse/awk/awk_i.h>
#include <ase/awk/awk_i.h>
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 ||
syscas->free == SSE_NULL) return SSE_NULL;
if (syscas->malloc == ASE_NULL ||
syscas->free == ASE_NULL) return ASE_NULL;
if (syscas->is_upper == SSE_NULL ||
syscas->is_lower == SSE_NULL ||
syscas->is_alpha == SSE_NULL ||
syscas->is_digit == SSE_NULL ||
syscas->is_xdigit == SSE_NULL ||
syscas->is_alnum == SSE_NULL ||
syscas->is_space == SSE_NULL ||
syscas->is_print == SSE_NULL ||
syscas->is_graph == SSE_NULL ||
syscas->is_cntrl == SSE_NULL ||
syscas->is_punct == SSE_NULL ||
syscas->to_upper == SSE_NULL ||
syscas->to_lower == SSE_NULL) return SSE_NULL;
if (syscas->is_upper == ASE_NULL ||
syscas->is_lower == ASE_NULL ||
syscas->is_alpha == ASE_NULL ||
syscas->is_digit == ASE_NULL ||
syscas->is_xdigit == ASE_NULL ||
syscas->is_alnum == ASE_NULL ||
syscas->is_space == ASE_NULL ||
syscas->is_print == ASE_NULL ||
syscas->is_graph == ASE_NULL ||
syscas->is_cntrl == ASE_NULL ||
syscas->is_punct == ASE_NULL ||
syscas->to_upper == ASE_NULL ||
syscas->to_lower == ASE_NULL) return ASE_NULL;
if (syscas->sprintf == SSE_NULL ||
syscas->dprintf == SSE_NULL ||
syscas->abort == SSE_NULL) return SSE_NULL;
if (syscas->sprintf == ASE_NULL ||
syscas->dprintf == ASE_NULL ||
syscas->abort == ASE_NULL) return ASE_NULL;
#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
awk = (sse_awk_t*) syscas->malloc (
sse_sizeof(sse_awk_t), syscas->custom_data);
awk = (ase_awk_t*) syscas->malloc (
ase_sizeof(ase_awk_t), syscas->custom_data);
#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 */
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));
awk->syscas.memcpy = sse_awk_memcpy;
ase_awk_memcpy (&awk->syscas, syscas, ase_sizeof(awk->syscas));
awk->syscas.memcpy = ase_awk_memcpy;
}
else syscas->memcpy (&awk->syscas, syscas, sse_sizeof(awk->syscas));
if (syscas->memset == SSE_NULL) awk->syscas.memset = sse_awk_memset;
else syscas->memcpy (&awk->syscas, syscas, ase_sizeof(awk->syscas));
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);
return SSE_NULL;
ASE_AWK_FREE (awk, awk);
return ASE_NULL;
}
/* TODO: initial map size?? */
if (sse_awk_map_open (
&awk->tree.afns, awk, 256, __free_afn, awk) == SSE_NULL)
if (ase_awk_map_open (
&awk->tree.afns, awk, 256, __free_afn, awk) == ASE_NULL)
{
sse_awk_str_close (&awk->token.name);
SSE_AWK_FREE (awk, awk);
return SSE_NULL;
ase_awk_str_close (&awk->token.name);
ASE_AWK_FREE (awk, awk);
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);
sse_awk_map_close (&awk->tree.afns);
SSE_AWK_FREE (awk, awk);
return SSE_NULL;
ase_awk_str_close (&awk->token.name);
ase_awk_map_close (&awk->tree.afns);
ASE_AWK_FREE (awk, awk);
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);
sse_awk_map_close (&awk->tree.afns);
sse_awk_tab_close (&awk->parse.globals);
SSE_AWK_FREE (awk, awk);
return SSE_NULL;
ase_awk_str_close (&awk->token.name);
ase_awk_map_close (&awk->tree.afns);
ase_awk_tab_close (&awk->parse.globals);
ASE_AWK_FREE (awk, awk);
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);
sse_awk_map_close (&awk->tree.afns);
sse_awk_tab_close (&awk->parse.globals);
sse_awk_tab_close (&awk->parse.locals);
SSE_AWK_FREE (awk, awk);
return SSE_NULL;
ase_awk_str_close (&awk->token.name);
ase_awk_map_close (&awk->tree.afns);
ase_awk_tab_close (&awk->parse.globals);
ase_awk_tab_close (&awk->parse.locals);
ASE_AWK_FREE (awk, awk);
return ASE_NULL;
}
awk->option = 0;
awk->errnum = SSE_AWK_ENOERR;
awk->errnum = ASE_AWK_ENOERR;
awk->parse.nlocals_max = 0;
awk->parse.nl_semicolon = 0;
awk->tree.nglobals = 0;
awk->tree.nbglobals = 0;
awk->tree.begin = SSE_NULL;
awk->tree.end = SSE_NULL;
awk->tree.chain = SSE_NULL;
awk->tree.chain_tail = SSE_NULL;
awk->tree.begin = ASE_NULL;
awk->tree.end = ASE_NULL;
awk->tree.chain = ASE_NULL;
awk->tree.chain_tail = ASE_NULL;
awk->tree.chain_size = 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.column = 0;
awk->src.ios = SSE_NULL;
awk->src.lex.curc = SSE_CHAR_EOF;
awk->src.ios = ASE_NULL;
awk->src.lex.curc = ASE_CHAR_EOF;
awk->src.lex.ungotc_count = 0;
awk->src.lex.line = 1;
awk->src.lex.column = 1;
awk->src.shared.buf_pos = 0;
awk->src.shared.buf_len = 0;
awk->bfn.sys = SSE_NULL;
awk->bfn.user = SSE_NULL;
awk->bfn.sys = ASE_NULL;
awk->bfn.user = ASE_NULL;
awk->run.count = 0;
awk->run.ptr = SSE_NULL;
awk->run.ptr = ASE_NULL;
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);
sse_awk_tab_close (&awk->parse.globals);
sse_awk_tab_close (&awk->parse.locals);
sse_awk_tab_close (&awk->parse.params);
sse_awk_str_close (&awk->token.name);
ase_awk_map_close (&awk->tree.afns);
ase_awk_tab_close (&awk->parse.globals);
ase_awk_tab_close (&awk->parse.locals);
ase_awk_tab_close (&awk->parse.params);
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 */
SSE_AWK_FREE (awk, awk);
ASE_AWK_FREE (awk, awk);
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 */
/* 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;
}
@ -169,17 +169,17 @@ int sse_awk_clear (sse_awk_t* awk)
awk->bfn.user
*/
awk->src.ios = SSE_NULL;
awk->src.lex.curc = SSE_CHAR_EOF;
awk->src.ios = ASE_NULL;
awk->src.lex.curc = ASE_CHAR_EOF;
awk->src.lex.ungotc_count = 0;
awk->src.lex.line = 1;
awk->src.lex.column = 1;
awk->src.shared.buf_pos = 0;
awk->src.shared.buf_len = 0;
sse_awk_tab_clear (&awk->parse.globals);
sse_awk_tab_clear (&awk->parse.locals);
sse_awk_tab_clear (&awk->parse.params);
ase_awk_tab_clear (&awk->parse.globals);
ase_awk_tab_clear (&awk->parse.locals);
ase_awk_tab_clear (&awk->parse.params);
awk->parse.nlocals_max = 0;
awk->parse.depth.loop = 0;
@ -187,60 +187,60 @@ int sse_awk_clear (sse_awk_t* awk)
/* clear parse trees */
awk->tree.nbglobals = 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);
sse_awk_clrpt (awk, awk->tree.begin);
awk->tree.begin = SSE_NULL;
ase_awk_assert (awk, awk->tree.begin->next == ASE_NULL);
ase_awk_clrpt (awk, awk->tree.begin);
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);
sse_awk_clrpt (awk, awk->tree.end);
awk->tree.end = SSE_NULL;
ase_awk_assert (awk, awk->tree.end->next == ASE_NULL);
ase_awk_clrpt (awk, awk->tree.end);
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;
if (awk->tree.chain->pattern != SSE_NULL)
sse_awk_clrpt (awk, awk->tree.chain->pattern);
if (awk->tree.chain->action != SSE_NULL)
sse_awk_clrpt (awk, awk->tree.chain->action);
SSE_AWK_FREE (awk, awk->tree.chain);
ase_awk_chain_t* next = awk->tree.chain->next;
if (awk->tree.chain->pattern != ASE_NULL)
ase_awk_clrpt (awk, awk->tree.chain->pattern);
if (awk->tree.chain->action != ASE_NULL)
ase_awk_clrpt (awk, awk->tree.chain->action);
ASE_AWK_FREE (awk, awk->tree.chain);
awk->tree.chain = next;
}
awk->tree.chain_tail = SSE_NULL;
awk->tree.chain_tail = ASE_NULL;
awk->tree.chain_size = 0;
return 0;
}
int sse_awk_getopt (sse_awk_t* awk)
int ase_awk_getopt (ase_awk_t* awk)
{
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;
}
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 */
/*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);
SSE_AWK_FREE ((sse_awk_t*)owner, f);
ase_awk_clrpt ((ase_awk_t*)owner, f->body);
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;
}

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

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_
#define _SSE_AWK_AWKI_H_
#ifndef _ASE_AWK_AWKI_H_
#define _ASE_AWK_AWKI_H_
typedef struct sse_awk_chain_t sse_awk_chain_t;
typedef struct sse_awk_tree_t sse_awk_tree_t;
typedef struct ase_awk_chain_t ase_awk_chain_t;
typedef struct ase_awk_tree_t ase_awk_tree_t;
#include <sse/awk/awk.h>
#include <sse/awk/str.h>
#include <sse/awk/rex.h>
#include <sse/awk/map.h>
#include <sse/awk/tree.h>
#include <sse/awk/val.h>
#include <sse/awk/func.h>
#include <sse/awk/tab.h>
#include <sse/awk/parse.h>
#include <sse/awk/run.h>
#include <sse/awk/extio.h>
#include <sse/awk/misc.h>
#include <ase/awk/awk.h>
#include <ase/awk/str.h>
#include <ase/awk/rex.h>
#include <ase/awk/map.h>
#include <ase/awk/tree.h>
#include <ase/awk/val.h>
#include <ase/awk/func.h>
#include <ase/awk/tab.h>
#include <ase/awk/parse.h>
#include <ase/awk/run.h>
#include <ase/awk/extio.h>
#include <ase/awk/misc.h>
#ifdef NDEBUG
#define sse_awk_assert(awk,expr) ((void)0)
#define ase_awk_assert(awk,expr) ((void)0)
#else
#define sse_awk_assert(awk,expr) (void)((expr) || \
(sse_awk_abort(awk, SSE_T(#expr), SSE_T(__FILE__), __LINE__), 0))
#define ase_awk_assert(awk,expr) (void)((expr) || \
(ase_awk_abort(awk, ASE_T(#expr), ASE_T(__FILE__), __LINE__), 0))
#endif
#ifdef _MSC_VER
#pragma warning (disable: 4996)
#endif
#define SSE_AWK_MAX_GLOBALS 9999
#define SSE_AWK_MAX_LOCALS 9999
#define SSE_AWK_MAX_PARAMS 9999
#define ASE_AWK_MAX_GLOBALS 9999
#define ASE_AWK_MAX_LOCALS 9999
#define ASE_AWK_MAX_PARAMS 9999
#if defined(_WIN32) && defined(_DEBUG)
#define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>
#define SSE_AWK_MALLOC(awk,size) malloc (size)
#define SSE_AWK_REALLOC(awk,ptr,size) realloc (ptr, size)
#define SSE_AWK_FREE(awk,ptr) free (ptr)
#define ASE_AWK_MALLOC(awk,size) malloc (size)
#define ASE_AWK_REALLOC(awk,ptr,size) realloc (ptr, size)
#define ASE_AWK_FREE(awk,ptr) free (ptr)
#else
#define SSE_AWK_MALLOC(awk,size) \
#define ASE_AWK_MALLOC(awk,size) \
(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)
#define SSE_AWK_FREE(awk,ptr) \
#define ASE_AWK_FREE(awk,ptr) \
(awk)->syscas.free (ptr, (awk)->syscas.custom_data)
#endif
#define SSE_AWK_LOCK(awk) \
#define ASE_AWK_LOCK(awk) \
do { \
if ((awk)->syscas.lock != SSE_NULL) \
if ((awk)->syscas.lock != ASE_NULL) \
(awk)->syscas.lock (awk, (awk)->syscas.custom_data); \
} while (0)
#define SSE_AWK_UNLOCK(awk) \
#define ASE_AWK_UNLOCK(awk) \
do { \
if ((awk)->syscas.unlock != SSE_NULL) \
if ((awk)->syscas.unlock != ASE_NULL) \
(awk)->syscas.unlock (awk, (awk)->syscas.custom_data); \
} while (0)
#define SSE_AWK_ISUPPER(awk,c) (awk)->syscas.is_upper(c)
#define SSE_AWK_ISLOWER(awk,c) (awk)->syscas.is_lower(c)
#define SSE_AWK_ISALPHA(awk,c) (awk)->syscas.is_alpha(c)
#define SSE_AWK_ISDIGIT(awk,c) (awk)->syscas.is_digit(c)
#define SSE_AWK_ISXDIGIT(awk,c) (awk)->syscas.is_xdigit(c)
#define SSE_AWK_ISALNUM(awk,c) (awk)->syscas.is_alnum(c)
#define SSE_AWK_ISSPACE(awk,c) (awk)->syscas.is_space(c)
#define SSE_AWK_ISPRINT(awk,c) (awk)->syscas.is_print(c)
#define SSE_AWK_ISGRAPH(awk,c) (awk)->syscas.is_graph(c)
#define SSE_AWK_ISCNTRL(awk,c) (awk)->syscas.is_cntrl(c)
#define SSE_AWK_ISPUNCT(awk,c) (awk)->syscas.is_punct(c)
#define SSE_AWK_TOUPPER(awk,c) (awk)->syscas.to_upper(c)
#define SSE_AWK_TOLOWER(awk,c) (awk)->syscas.to_lower(c)
#define ASE_AWK_ISUPPER(awk,c) (awk)->syscas.is_upper(c)
#define ASE_AWK_ISLOWER(awk,c) (awk)->syscas.is_lower(c)
#define ASE_AWK_ISALPHA(awk,c) (awk)->syscas.is_alpha(c)
#define ASE_AWK_ISDIGIT(awk,c) (awk)->syscas.is_digit(c)
#define ASE_AWK_ISXDIGIT(awk,c) (awk)->syscas.is_xdigit(c)
#define ASE_AWK_ISALNUM(awk,c) (awk)->syscas.is_alnum(c)
#define ASE_AWK_ISSPACE(awk,c) (awk)->syscas.is_space(c)
#define ASE_AWK_ISPRINT(awk,c) (awk)->syscas.is_print(c)
#define ASE_AWK_ISGRAPH(awk,c) (awk)->syscas.is_graph(c)
#define ASE_AWK_ISCNTRL(awk,c) (awk)->syscas.is_cntrl(c)
#define ASE_AWK_ISPUNCT(awk,c) (awk)->syscas.is_punct(c)
#define ASE_AWK_TOUPPER(awk,c) (awk)->syscas.to_upper(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 SSE_AWK_MEMSET(awk,dst,val,len) (awk)->syscas.memset (dst, val, len)
#define ASE_AWK_MEMCPY(awk,dst,src,len) (awk)->syscas.memcpy (dst, src, 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 */
sse_size_t nbglobals; /* number of builtin globals */
sse_awk_map_t afns; /* awk function map */
sse_awk_nde_t* begin;
sse_awk_nde_t* end;
sse_awk_chain_t* chain;
sse_awk_chain_t* chain_tail;
sse_size_t chain_size; /* number of nodes in the chain */
ase_size_t nglobals; /* total number of globals */
ase_size_t nbglobals; /* number of builtin globals */
ase_awk_map_t afns; /* awk function map */
ase_awk_nde_t* begin;
ase_awk_nde_t* end;
ase_awk_chain_t* chain;
ase_awk_chain_t* chain_tail;
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 */
int option;
/* parse tree */
sse_awk_tree_t tree;
ase_awk_tree_t tree;
int state;
/* temporary information that the parser needs */
@ -115,13 +115,13 @@ struct sse_awk_t
struct
{
sse_size_t loop;
ase_size_t loop;
} depth;
sse_awk_tab_t globals;
sse_awk_tab_t locals;
sse_awk_tab_t params;
sse_size_t nlocals_max;
ase_awk_tab_t globals;
ase_awk_tab_t locals;
ase_awk_tab_t params;
ase_size_t nlocals_max;
int nl_semicolon;
} parse;
@ -129,23 +129,23 @@ struct sse_awk_t
/* source code management */
struct
{
sse_awk_srcios_t* ios;
ase_awk_srcios_t* ios;
struct
{
sse_cint_t curc;
sse_cint_t ungotc[5];
sse_size_t ungotc_count;
ase_cint_t curc;
ase_cint_t ungotc[5];
ase_size_t ungotc_count;
sse_size_t line;
sse_size_t column;
ase_size_t line;
ase_size_t column;
} lex;
struct
{
sse_char_t buf[512];
sse_size_t buf_pos;
sse_size_t buf_len;
ase_char_t buf[512];
ase_size_t buf_pos;
ase_size_t buf_len;
} shared;
} src;
@ -154,73 +154,73 @@ struct sse_awk_t
{
int prev;
int type;
sse_awk_str_t name;
sse_size_t line;
sse_size_t column;
ase_awk_str_t name;
ase_size_t line;
ase_size_t column;
} token;
/* builtin functions */
struct
{
sse_awk_bfn_t* sys;
sse_awk_bfn_t* user;
ase_awk_bfn_t* sys;
ase_awk_bfn_t* user;
} bfn;
struct
{
sse_size_t count;
sse_awk_run_t* ptr;
ase_size_t count;
ase_awk_run_t* ptr;
} run;
/* housekeeping */
int errnum;
};
struct sse_awk_chain_t
struct ase_awk_chain_t
{
sse_awk_nde_t* pattern;
sse_awk_nde_t* action;
sse_awk_chain_t* next;
ase_awk_nde_t* pattern;
ase_awk_nde_t* action;
ase_awk_chain_t* next;
};
struct sse_awk_run_t
struct ase_awk_run_t
{
int id;
sse_awk_map_t named;
ase_awk_map_t named;
void** stack;
sse_size_t stack_top;
sse_size_t stack_base;
sse_size_t stack_limit;
ase_size_t stack_top;
ase_size_t stack_base;
ase_size_t stack_limit;
int exit_level;
sse_awk_val_int_t* icache[100]; /* TODO: choose the optimal size */
sse_awk_val_real_t* rcache[100]; /* TODO: choose the optimal size */
sse_awk_val_ref_t* fcache[100]; /* TODO: choose the optimal size */
sse_size_t icache_count;
sse_size_t rcache_count;
sse_size_t fcache_count;
ase_awk_val_int_t* icache[100]; /* TODO: choose the optimal size */
ase_awk_val_real_t* rcache[100]; /* TODO: choose the optimal size */
ase_awk_val_ref_t* fcache[100]; /* TODO: choose the optimal size */
ase_size_t icache_count;
ase_size_t rcache_count;
ase_size_t fcache_count;
sse_awk_nde_blk_t* active_block;
sse_byte_t* pattern_range_state;
ase_awk_nde_blk_t* active_block;
ase_byte_t* pattern_range_state;
struct
{
sse_char_t buf[1024];
sse_size_t buf_pos;
sse_size_t buf_len;
sse_bool_t eof;
ase_char_t buf[1024];
ase_size_t buf_pos;
ase_size_t buf_len;
ase_bool_t eof;
sse_awk_str_t line;
sse_awk_val_t* d0; /* $0 */
ase_awk_str_t line;
ase_awk_val_t* d0; /* $0 */
sse_size_t maxflds;
sse_size_t nflds; /* NF */
ase_size_t maxflds;
ase_size_t nflds; /* NF */
struct
{
sse_char_t* ptr;
sse_size_t len;
sse_awk_val_t* val; /* $1 .. $NF */
ase_char_t* ptr;
ase_size_t len;
ase_awk_val_t* val; /* $1 .. $NF */
}* flds;
} inrec;
@ -230,48 +230,48 @@ struct sse_awk_run_t
void* rs;
void* fs;
int ignorecase;
sse_size_t fnr;
ase_size_t fnr;
struct
{
sse_char_t* ptr;
sse_size_t len;
ase_char_t* ptr;
ase_size_t len;
} convfmt;
struct
{
sse_char_t* ptr;
sse_size_t len;
ase_char_t* ptr;
ase_size_t len;
} ofmt;
struct
{
sse_char_t* ptr;
sse_size_t len;
ase_char_t* ptr;
ase_size_t len;
} ofs;
struct
{
sse_char_t* ptr;
sse_size_t len;
ase_char_t* ptr;
ase_size_t len;
} ors;
struct
{
sse_char_t* ptr;
sse_size_t len;
ase_char_t* ptr;
ase_size_t len;
} subsep;
} global;
/* extio chain */
struct
{
sse_awk_io_t handler[SSE_AWK_EXTIO_NUM];
ase_awk_io_t handler[ASE_AWK_EXTIO_NUM];
void* custom_data;
sse_awk_extio_t* chain;
ase_awk_extio_t* chain;
} extio;
int errnum;
sse_awk_t* awk;
sse_awk_run_t* prev;
sse_awk_run_t* next;
ase_awk_t* awk;
ase_awk_run_t* prev;
ase_awk_run_t* next;
};
#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;
}
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"),
SSE_T("out of memory"),
SSE_T("invalid parameter"),
SSE_T("general run-time error"),
SSE_T("one or more running instances"),
SSE_T("too many running instances"),
SSE_T("recursion too deep"),
ASE_T("no error"),
ASE_T("out of memory"),
ASE_T("invalid parameter"),
ASE_T("general run-time error"),
ASE_T("one or more running instances"),
ASE_T("too many running instances"),
ASE_T("recursion too deep"),
SSE_T("cannot open source input"),
SSE_T("cannot close source input"),
SSE_T("cannot read source input"),
ASE_T("cannot open source input"),
ASE_T("cannot close source input"),
ASE_T("cannot read source input"),
SSE_T("cannot open source output"),
SSE_T("cannot close source output"),
SSE_T("cannot write source output"),
ASE_T("cannot open source output"),
ASE_T("cannot close source output"),
ASE_T("cannot write source output"),
SSE_T("cannot open console for read"),
SSE_T("cannot close console for read"),
SSE_T("cannot switch to next console for read"),
SSE_T("cannot read from console"),
ASE_T("cannot open console for read"),
ASE_T("cannot close console for read"),
ASE_T("cannot switch to next console for read"),
ASE_T("cannot read from console"),
SSE_T("cannot open console for write"),
SSE_T("cannot close console for write"),
SSE_T("cannot switch to next console for write"),
SSE_T("cannot write to console"),
ASE_T("cannot open console for write"),
ASE_T("cannot close console for write"),
ASE_T("cannot switch to next console for write"),
ASE_T("cannot write to console"),
SSE_T("invalid character"),
SSE_T("cannot unget character"),
ASE_T("invalid character"),
ASE_T("cannot unget character"),
SSE_T("unexpected end of source"),
SSE_T("unexpected end of a comment"),
SSE_T("unexpected end of a string"),
SSE_T("unexpected end of a regular expression"),
SSE_T("left brace expected"),
SSE_T("left parenthesis expected"),
SSE_T("right parenthesis expected"),
SSE_T("right bracket expected"),
SSE_T("comma expected"),
SSE_T("semicolon expected"),
SSE_T("colon expected"),
SSE_T("keyword 'in' expected"),
SSE_T("not a variable after 'in'"),
SSE_T("expression expected"),
ASE_T("unexpected end of source"),
ASE_T("unexpected end of a comment"),
ASE_T("unexpected end of a string"),
ASE_T("unexpected end of a regular expression"),
ASE_T("left brace expected"),
ASE_T("left parenthesis expected"),
ASE_T("right parenthesis expected"),
ASE_T("right bracket expected"),
ASE_T("comma expected"),
ASE_T("semicolon expected"),
ASE_T("colon expected"),
ASE_T("keyword 'in' expected"),
ASE_T("not a variable after 'in'"),
ASE_T("expression expected"),
SSE_T("keyword 'while' expected"),
SSE_T("assignment statement expected"),
SSE_T("identifier expected"),
SSE_T("BEGIN requires an action block"),
SSE_T("END requires an action block"),
SSE_T("duplicate BEGIN"),
SSE_T("duplicate END"),
SSE_T("duplicate function name"),
SSE_T("duplicate parameter name"),
SSE_T("duplicate variable name"),
SSE_T("duplicate name"),
SSE_T("undefined identifier"),
SSE_T("l-value required"),
SSE_T("too few arguments"),
SSE_T("too many arguments"),
SSE_T("too many global variables"),
SSE_T("too many local variables"),
SSE_T("too many parameters"),
SSE_T("break outside a loop"),
SSE_T("continue outside a loop"),
SSE_T("next illegal in BEGIN or END block"),
SSE_T("nextfile illegal in BEGIN or END block"),
SSE_T("getline expected"),
ASE_T("keyword 'while' expected"),
ASE_T("assignment statement expected"),
ASE_T("identifier expected"),
ASE_T("BEGIN requires an action block"),
ASE_T("END requires an action block"),
ASE_T("duplicate BEGIN"),
ASE_T("duplicate END"),
ASE_T("duplicate function name"),
ASE_T("duplicate parameter name"),
ASE_T("duplicate variable name"),
ASE_T("duplicate name"),
ASE_T("undefined identifier"),
ASE_T("l-value required"),
ASE_T("too few arguments"),
ASE_T("too many arguments"),
ASE_T("too many global variables"),
ASE_T("too many local variables"),
ASE_T("too many parameters"),
ASE_T("break outside a loop"),
ASE_T("continue outside a loop"),
ASE_T("next illegal in BEGIN or END block"),
ASE_T("nextfile illegal in BEGIN or END block"),
ASE_T("getline expected"),
SSE_T("divide by zero"),
SSE_T("invalid operand"),
SSE_T("wrong position index"),
SSE_T("no such function"),
SSE_T("value not assignable"),
SSE_T("variable not indexable"),
SSE_T("variable not deletable"),
SSE_T("value not referenceable"),
SSE_T("an indexed value cannot be assigned a map"),
SSE_T("a positional value cannot be assigned a map"),
SSE_T("cannot change a map to a scalar value"),
SSE_T("cannot change a scalar value to a map"),
SSE_T("a map is not allowed"),
SSE_T("wrong value type"),
SSE_T("pipe operation error"),
SSE_T("next cannot be called from the BEGIN or END block"),
SSE_T("nextfile cannot be called from the BEGIN or END block"),
SSE_T("wrong implementation of user-defined io handler"),
SSE_T("no such io name found"),
SSE_T("io handler has returned an error"),
SSE_T("internal error that should never have happened"),
ASE_T("divide by zero"),
ASE_T("invalid operand"),
ASE_T("wrong position index"),
ASE_T("no such function"),
ASE_T("value not assignable"),
ASE_T("variable not indexable"),
ASE_T("variable not deletable"),
ASE_T("value not referenceable"),
ASE_T("an indexed value cannot be assigned a map"),
ASE_T("a positional value cannot be assigned a map"),
ASE_T("cannot change a map to a scalar value"),
ASE_T("cannot change a scalar value to a map"),
ASE_T("a map is not allowed"),
ASE_T("wrong value type"),
ASE_T("pipe operation error"),
ASE_T("next cannot be called from the BEGIN or END block"),
ASE_T("nextfile cannot be called from the BEGIN or END block"),
ASE_T("wrong implementation of user-defined io handler"),
ASE_T("no such io name found"),
ASE_T("io handler has returned an error"),
ASE_T("internal error that should never have happened"),
SSE_T("a right parenthesis is expected in the regular expression"),
SSE_T("a right bracket is expected in the regular expression"),
SSE_T("a right brace is expected in the regular expression"),
SSE_T("a colon is expected in the regular expression"),
SSE_T("invalid character range in the regular expression"),
SSE_T("invalid character class in the regular expression"),
SSE_T("invalid boundary range in the regular expression"),
SSE_T("unexpected end of the regular expression"),
SSE_T("garbage after the regular expression")
ASE_T("a right parenthesis is expected in the regular expression"),
ASE_T("a right bracket is expected in the regular expression"),
ASE_T("a right brace is expected in the regular expression"),
ASE_T("a colon is expected in the regular expression"),
ASE_T("invalid character range in the regular expression"),
ASE_T("invalid character class in the regular expression"),
ASE_T("invalid boundary range in the regular expression"),
ASE_T("unexpected end of 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 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_
#define _SSE_AWK_EXTIO_H_
#ifndef _ASE_AWK_EXTIO_H_
#define _ASE_AWK_EXTIO_H_
#ifndef _SSE_AWK_AWK_H_
#error Never include this file directly. Include <sse/awk/awk.h> instead
#ifndef _ASE_AWK_AWK_H_
#error Never include this file directly. Include <ase/awk/awk.h> instead
#endif
#ifdef __cplusplus
extern "C"
#endif
int sse_awk_readextio (
sse_awk_run_t* run, int in_type,
const sse_char_t* name, sse_awk_str_t* buf);
int ase_awk_readextio (
ase_awk_run_t* run, int in_type,
const ase_char_t* name, ase_awk_str_t* buf);
int sse_awk_writeextio_val (
sse_awk_run_t* run, int out_type,
const sse_char_t* name, sse_awk_val_t* v);
int ase_awk_writeextio_val (
ase_awk_run_t* run, int out_type,
const ase_char_t* name, ase_awk_val_t* v);
int sse_awk_writeextio_str (
sse_awk_run_t* run, int out_type,
const sse_char_t* name, sse_char_t* str, sse_size_t len);
int ase_awk_writeextio_str (
ase_awk_run_t* run, int out_type,
const ase_char_t* name, ase_char_t* str, ase_size_t len);
int sse_awk_flushextio (
sse_awk_run_t* run, int out_type, const sse_char_t* name);
int ase_awk_flushextio (
ase_awk_run_t* run, int out_type, const ase_char_t* name);
int sse_awk_nextextio_read (
sse_awk_run_t* run, int in_type, const sse_char_t* name);
int ase_awk_nextextio_read (
ase_awk_run_t* run, int in_type, const ase_char_t* name);
/* TODO:
int sse_awk_nextextio_write (
sse_awk_run_t* run, int out_type, const sse_char_t* name);
int ase_awk_nextextio_write (
ase_awk_run_t* run, int out_type, const ase_char_t* name);
*/
int sse_awk_closeextio_read (
sse_awk_run_t* run, int in_type, const sse_char_t* name);
int sse_awk_closeextio_write (
sse_awk_run_t* run, int out_type, const sse_char_t* name);
int sse_awk_closeextio (sse_awk_run_t* run, const sse_char_t* name);
int ase_awk_closeextio_read (
ase_awk_run_t* run, int in_type, const ase_char_t* name);
int ase_awk_closeextio_write (
ase_awk_run_t* run, int out_type, const ase_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
}

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_
#define _SSE_AWK_FUNC_H_
#ifndef _ASE_AWK_FUNC_H_
#define _ASE_AWK_FUNC_H_
#ifndef _SSE_AWK_AWK_H_
#error Never include this file directly. Include <sse/awk/awk.h> instead
#ifndef _ASE_AWK_AWK_H_
#error Never include this file directly. Include <ase/awk/awk.h> instead
#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;
sse_size_t name_len;
const ase_char_t* name;
ase_size_t name_len;
int valid; /* the entry is valid when this option is set */
sse_size_t min_args;
sse_size_t max_args;
const sse_char_t* arg_spec;
int (*handler) (sse_awk_run_t* run);
ase_size_t min_args;
ase_size_t max_args;
const ase_char_t* arg_spec;
int (*handler) (ase_awk_run_t* run);
sse_awk_bfn_t* next;
ase_awk_bfn_t* next;
};
enum
{
/* ensure that this matches __sys_bfn in func.c */
SSE_AWK_BFN_CLOSE,
SSE_AWK_BFN_INDEX,
SSE_AWK_BFN_LENGTH,
SSE_AWK_BFN_SYSTEM,
SSE_AWK_BFN_SIN
ASE_AWK_BFN_CLOSE,
ASE_AWK_BFN_INDEX,
ASE_AWK_BFN_LENGTH,
ASE_AWK_BFN_SYSTEM,
ASE_AWK_BFN_SIN
};
@ -41,17 +41,17 @@ enum
extern "C" {
#endif
sse_awk_bfn_t* sse_awk_addbfn (
sse_awk_t* awk, const sse_char_t* name, sse_size_t name_len,
int when_valid, sse_size_t min_args, sse_size_t max_args,
const sse_char_t* arg_spec, int (*handler)(sse_awk_run_t*));
ase_awk_bfn_t* ase_awk_addbfn (
ase_awk_t* awk, const ase_char_t* name, ase_size_t name_len,
int when_valid, ase_size_t min_args, ase_size_t max_args,
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 (
sse_awk_t* awk, const sse_char_t* name, sse_size_t name_len);
ase_awk_bfn_t* ase_awk_getbfn (
ase_awk_t* awk, const ase_char_t* name, ase_size_t name_len);
#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 <sse/awk/awk.h>
#include <ase/awk/jni.h>
#include <ase/awk/awk.h>
#include <stdlib.h>
#include <string.h>
#include <wctype.h>
#include <wchar.h>
#include <stdio.h>
#define EXCEPTION_AWK "sse/awk/AwkException"
#define EXCEPTION_AWK "ase/awk/AwkException"
#define FIELD_AWK "__awk"
enum
@ -19,16 +19,16 @@ enum
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 (
int cmd, void* arg, sse_char_t* data, sse_size_t count);
static sse_ssize_t __write_source (
int cmd, void* arg, sse_char_t* data, sse_size_t count);
static sse_ssize_t __process_extio_console (
int cmd, void* arg, sse_char_t* data, sse_size_t count);
static sse_ssize_t __process_extio_file (
int cmd, void* arg, sse_char_t* data, sse_size_t count);
static ase_ssize_t __read_source (
int cmd, void* arg, ase_char_t* data, ase_size_t count);
static ase_ssize_t __write_source (
int cmd, void* arg, ase_char_t* data, ase_size_t count);
static ase_ssize_t __process_extio_console (
int cmd, void* arg, ase_char_t* data, ase_size_t count);
static ase_ssize_t __process_extio_file (
int cmd, void* arg, ase_char_t* data, ase_size_t count);
typedef struct srcio_data_t srcio_data_t;
typedef struct runio_data_t runio_data_t;
@ -45,12 +45,12 @@ struct runio_data_t
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);
}
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);
}
@ -60,13 +60,13 @@ static void __awk_free (void* ptr, void* custom_data)
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;
jfieldID fid;
jthrowable except;
sse_awk_t* awk;
sse_awk_syscas_t syscas;
ase_awk_t* awk;
ase_awk_syscas_t syscas;
int opt;
class = (*env)->GetObjectClass(env, obj);
@ -103,7 +103,7 @@ JNIEXPORT void JNICALL Java_sse_awk_Awk_open (JNIEnv* env, jobject obj)
syscas.abort = abort;
#endif
awk = sse_awk_open (&syscas);
awk = ase_awk_open (&syscas);
if (awk == NULL)
{
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);
opt = SSE_AWK_EXPLICIT | SSE_AWK_UNIQUE | SSE_AWK_DBLSLASHES |
SSE_AWK_SHADING | SSE_AWK_IMPLICIT | SSE_AWK_SHIFT |
SSE_AWK_EXTIO | SSE_AWK_BLOCKLESS;
sse_awk_setopt (awk, opt);
opt = ASE_AWK_EXPLICIT | ASE_AWK_UNIQUE | ASE_AWK_DBLSLASHES |
ASE_AWK_SHADING | ASE_AWK_IMPLICIT | ASE_AWK_SHIFT |
ASE_AWK_EXTIO | ASE_AWK_BLOCKLESS;
ase_awk_setopt (awk, opt);
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;
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");
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);
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;
jfieldID fid;
jthrowable except;
sse_awk_t* awk;
sse_awk_srcios_t srcios;
ase_awk_t* awk;
ase_awk_srcios_t srcios;
srcio_data_t srcio_data;
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");
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.obj = obj;
@ -165,25 +165,25 @@ JNIEXPORT void JNICALL Java_sse_awk_Awk_parse (JNIEnv* env, jobject obj)
srcios.out = __write_source;
srcios.custom_data = &srcio_data;
if (sse_awk_parse (awk, &srcios) == -1)
if (ase_awk_parse (awk, &srcios) == -1)
{
printf ("parse error.......\n");
except = (*env)->FindClass (env, EXCEPTION_AWK);
if (except == 0) return;
(*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;
}
}
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;
jfieldID fid;
jthrowable except;
sse_awk_t* awk;
sse_awk_runios_t runios;
ase_awk_t* awk;
ase_awk_runios_t runios;
runio_data_t runio_data;
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");
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.obj = obj;
runios.pipe = SSE_NULL;
runios.coproc = SSE_NULL;
runios.pipe = ASE_NULL;
runios.coproc = ASE_NULL;
runios.file = __process_extio_file;
runios.console = __process_extio_console;
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);
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)
{
sse_awk_extio_t* epa = (sse_awk_extio_t*)extio;
ase_awk_extio_t* epa = (ase_awk_extio_t*)extio;
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)
{
sse_awk_extio_t* epa = (sse_awk_extio_t*)extio;
ase_awk_extio_t* epa = (ase_awk_extio_t*)extio;
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;
jmethodID mid;
@ -248,7 +248,7 @@ static sse_ssize_t __call_java_open_source (JNIEnv* env, jobject obj, int mode)
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;
jmethodID mid;
@ -271,8 +271,8 @@ static sse_ssize_t __call_java_close_source (JNIEnv* env, jobject obj, int mode)
return ret;
}
static sse_ssize_t __call_java_read_source (
JNIEnv* env, jobject obj, sse_char_t* buf, sse_size_t size)
static ase_ssize_t __call_java_read_source (
JNIEnv* env, jobject obj, ase_char_t* buf, ase_size_t size)
{
jclass class;
jmethodID mid;
@ -298,15 +298,15 @@ static sse_ssize_t __call_java_read_source (
}
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)->DeleteLocalRef (env, array);
return i;
}
static sse_ssize_t __call_java_write_source (
JNIEnv* env, jobject obj, sse_char_t* buf, sse_size_t size)
static ase_ssize_t __call_java_write_source (
JNIEnv* env, jobject obj, ase_char_t* buf, ase_size_t size)
{
jclass class;
jmethodID mid;
@ -339,8 +339,8 @@ static sse_ssize_t __call_java_write_source (
return ret;
}
static sse_ssize_t __call_java_open_extio (
JNIEnv* env, jobject obj, char* meth, sse_awk_extio_t* extio)
static ase_ssize_t __call_java_open_extio (
JNIEnv* env, jobject obj, char* meth, ase_awk_extio_t* extio)
{
jclass class;
jmethodID mid;
@ -349,7 +349,7 @@ static sse_ssize_t __call_java_open_extio (
class = (*env)->GetObjectClass(env, obj);
if (extio == SSE_NULL)
if (extio == ASE_NULL)
{
mid = (*env)->GetMethodID (env, class, meth, "()I");
if (mid == 0) return -1;
@ -366,7 +366,7 @@ static sse_ssize_t __call_java_open_extio (
if (mid == 0) return -1;
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;
ret = (*env)->CallIntMethod (env, obj, mid, name_str);
@ -405,8 +405,8 @@ static sse_ssize_t __call_java_open_extio (
return ret;
}
static sse_ssize_t __call_java_close_extio (
JNIEnv* env, jobject obj, char* meth, sse_awk_extio_t* extio)
static ase_ssize_t __call_java_close_extio (
JNIEnv* env, jobject obj, char* meth, ase_awk_extio_t* extio)
{
jclass class;
jmethodID mid;
@ -415,7 +415,7 @@ static sse_ssize_t __call_java_close_extio (
class = (*env)->GetObjectClass(env, obj);
if (extio == SSE_NULL)
if (extio == ASE_NULL)
{
mid = (*env)->GetMethodID (env, class, meth, "()I");
if (mid == 0) return -1;
@ -431,7 +431,7 @@ static sse_ssize_t __call_java_close_extio (
if (mid == 0) return -1;
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;
ret = (*env)->CallIntMethod (env, obj, mid, name_str);
@ -448,8 +448,8 @@ static sse_ssize_t __call_java_close_extio (
return ret;
}
static sse_ssize_t __call_java_read_extio (
JNIEnv* env, jobject obj, char* meth, sse_char_t* buf, sse_size_t size)
static ase_ssize_t __call_java_read_extio (
JNIEnv* env, jobject obj, char* meth, ase_char_t* buf, ase_size_t size)
{
jclass class;
jmethodID mid;
@ -475,20 +475,20 @@ static sse_ssize_t __call_java_read_extio (
}
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)->DeleteLocalRef (env, array);
return ret;
}
static sse_ssize_t __call_java_write_extio (
JNIEnv* env, jobject obj, char* meth, sse_char_t* data, sse_size_t size)
static ase_ssize_t __call_java_write_extio (
JNIEnv* env, jobject obj, char* meth, ase_char_t* data, ase_size_t size)
{
jclass class;
jmethodID mid;
jcharArray array;
sse_ssize_t i;
ase_ssize_t i;
jchar* tmp;
jint ret;
jthrowable thrown;
@ -517,22 +517,22 @@ static sse_ssize_t __call_java_write_extio (
return ret;
}
static sse_ssize_t __read_source (
int cmd, void* arg, sse_char_t* data, sse_size_t count)
static ase_ssize_t __read_source (
int cmd, void* arg, ase_char_t* data, ase_size_t count)
{
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 (
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 (
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 (
srcio_data->env, srcio_data->obj, data, count);
@ -541,22 +541,22 @@ static sse_ssize_t __read_source (
return -1;
}
static sse_ssize_t __write_source (
int cmd, void* arg, sse_char_t* data, sse_size_t count)
static ase_ssize_t __write_source (
int cmd, void* arg, ase_char_t* data, ase_size_t count)
{
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 (
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 (
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 (
srcio_data->env, srcio_data->obj, data, count);
@ -565,45 +565,45 @@ static sse_ssize_t __write_source (
return -1;
}
static sse_ssize_t __process_extio_console (
int cmd, void* arg, sse_char_t* data, sse_size_t size)
static ase_ssize_t __process_extio_console (
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;
if (cmd == SSE_AWK_IO_OPEN)
if (cmd == ASE_AWK_IO_OPEN)
{
return __call_java_open_extio (
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 (
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 (
runio_data->env, runio_data->obj, "read_console",
data, size);
}
else if (cmd == SSE_AWK_IO_WRITE)
else if (cmd == ASE_AWK_IO_WRITE)
{
return __call_java_write_extio (
runio_data->env, runio_data->obj, "write_console",
data, size);
}
#if 0
else if (cmd == SSE_AWK_IO_FLUSH)
else if (cmd == ASE_AWK_IO_FLUSH)
{
return __call_java_flush_extio (
runio_data->env, runio_data->obj, "flush_console",
data, size);
}
else if (cmd == SSE_AWK_IO_NEXT)
else if (cmd == ASE_AWK_IO_NEXT)
{
return __call_java_next_extio (
runio_data->env, runio_data->obj, "flush_console",
@ -614,19 +614,19 @@ static sse_ssize_t __process_extio_console (
return -1;
}
static sse_ssize_t __process_extio_file (
int cmd, void* arg, sse_char_t* data, sse_size_t size)
static ase_ssize_t __process_extio_file (
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;
if (cmd == SSE_AWK_IO_OPEN)
if (cmd == ASE_AWK_IO_OPEN)
{
return __call_java_open_extio (
runio_data->env, runio_data->obj,
"open_file", epa);
}
else if (cmd == SSE_AWK_IO_CLOSE)
else if (cmd == ASE_AWK_IO_CLOSE)
{
return __call_java_close_extio (
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_
#define _SSE_AWK_JNI_H_
#ifndef _ASE_AWK_JNI_H_
#define _ASE_AWK_JNI_H_
#include <jni.h>
@ -11,10 +11,10 @@
extern "C" {
#endif
JNIEXPORT void JNICALL Java_sse_awk_Awk_open (JNIEnv*, jobject);
JNIEXPORT void JNICALL Java_sse_awk_Awk_close (JNIEnv*, jobject);
JNIEXPORT void JNICALL Java_sse_awk_Awk_parse (JNIEnv*, jobject);
JNIEXPORT void JNICALL Java_sse_awk_Awk_run (JNIEnv*, jobject);
JNIEXPORT void JNICALL Java_ase_awk_Awk_open (JNIEnv*, jobject);
JNIEXPORT void JNICALL Java_ase_awk_Awk_close (JNIEnv*, jobject);
JNIEXPORT void JNICALL Java_ase_awk_Awk_parse (JNIEnv*, jobject);
JNIEXPORT void JNICALL Java_ase_awk_Awk_run (JNIEnv*, jobject);
#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.
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) \
do { \
SSE_AWK_FREE ((map)->awk, (sse_char_t*)(pair)->key); \
if ((map)->freeval != SSE_NULL) \
ASE_AWK_FREE ((map)->awk, (ase_char_t*)(pair)->key); \
if ((map)->freeval != ASE_NULL) \
(map)->freeval ((map)->owner, (pair)->val); \
SSE_AWK_FREE ((map)->awk, pair); \
ASE_AWK_FREE ((map)->awk, pair); \
} while (0)
sse_awk_map_t* sse_awk_map_open (
sse_awk_map_t* map, void* owner, sse_size_t capa,
void(*freeval)(void*,void*), sse_awk_t* awk)
ase_awk_map_t* ase_awk_map_open (
ase_awk_map_t* map, void* owner, ase_size_t capa,
void(*freeval)(void*,void*), ase_awk_t* awk)
{
if (map == SSE_NULL)
if (map == ASE_NULL)
{
map = (sse_awk_map_t*) SSE_AWK_MALLOC (
awk, sse_sizeof(sse_awk_map_t));
if (map == SSE_NULL) return SSE_NULL;
map->__dynamic = sse_true;
map = (ase_awk_map_t*) ASE_AWK_MALLOC (
awk, ase_sizeof(ase_awk_map_t));
if (map == ASE_NULL) return ASE_NULL;
map->__dynamic = ase_true;
}
else map->__dynamic = sse_false;
else map->__dynamic = ase_false;
map->awk = awk;
map->buck = (sse_awk_pair_t**)
SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_pair_t*) * capa);
if (map->buck == SSE_NULL)
map->buck = (ase_awk_pair_t**)
ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_pair_t*) * capa);
if (map->buck == ASE_NULL)
{
if (map->__dynamic) SSE_AWK_FREE (awk, map);
return SSE_NULL;
if (map->__dynamic) ASE_AWK_FREE (awk, map);
return ASE_NULL;
}
map->owner = owner;
map->capa = capa;
map->size = 0;
map->freeval = freeval;
while (capa > 0) map->buck[--capa] = SSE_NULL;
while (capa > 0) map->buck[--capa] = ASE_NULL;
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);
SSE_AWK_FREE (map->awk, map->buck);
if (map->__dynamic) SSE_AWK_FREE (map->awk, map);
ase_awk_map_clear (map);
ASE_AWK_FREE (map->awk, map->buck);
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;
sse_awk_pair_t* pair, * next;
ase_size_t i;
ase_awk_pair_t* pair, * next;
for (i = 0; i < map->capa; i++)
{
pair = map->buck[i];
while (pair != SSE_NULL)
while (pair != ASE_NULL)
{
next = pair->next;
FREE_PAIR (map, pair);
@ -72,81 +72,81 @@ void sse_awk_map_clear (sse_awk_map_t* map)
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 (
sse_awk_map_t* map, const sse_char_t* key, sse_size_t key_len)
ase_awk_pair_t* ase_awk_map_get (
ase_awk_map_t* map, const ase_char_t* key, ase_size_t key_len)
{
sse_awk_pair_t* pair;
sse_size_t hc;
ase_awk_pair_t* pair;
ase_size_t hc;
hc = __hash(key,key_len) % map->capa;
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) return pair;
pair = pair->next;
}
return SSE_NULL;
return ASE_NULL;
}
sse_awk_pair_t* sse_awk_map_put (
sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len, void* val)
ase_awk_pair_t* ase_awk_map_put (
ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len, void* val)
{
int n;
sse_awk_pair_t* px;
ase_awk_pair_t* px;
n = sse_awk_map_putx (map, key, key_len, val, &px);
if (n < 0) return SSE_NULL;
n = ase_awk_map_putx (map, key, key_len, val, &px);
if (n < 0) return ASE_NULL;
return px;
}
int sse_awk_map_putx (
sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len,
void* val, sse_awk_pair_t** px)
int ase_awk_map_putx (
ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len,
void* val, ase_awk_pair_t** px)
{
sse_awk_pair_t* pair;
sse_size_t hc;
ase_awk_pair_t* pair;
ase_size_t hc;
hc = __hash(key,key_len) % map->capa;
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)
{
if (px != SSE_NULL)
*px = sse_awk_map_setpair (map, pair, val);
if (px != ASE_NULL)
*px = ase_awk_map_setpair (map, pair, val);
else
sse_awk_map_setpair (map, pair, val);
ase_awk_map_setpair (map, pair, val);
return 0; /* value changed for the existing key */
}
pair = pair->next;
}
pair = (sse_awk_pair_t*) SSE_AWK_MALLOC (
map->awk, sse_sizeof(sse_awk_pair_t));
if (pair == SSE_NULL) return -1; /* error */
pair = (ase_awk_pair_t*) ASE_AWK_MALLOC (
map->awk, ase_sizeof(ase_awk_pair_t));
if (pair == ASE_NULL) return -1; /* error */
/*pair->key = key;*/
/* duplicate the key if it is new */
pair->key = sse_awk_strxdup (map->awk, key, key_len);
if (pair->key == SSE_NULL)
pair->key = ase_awk_strxdup (map->awk, key, key_len);
if (pair->key == ASE_NULL)
{
SSE_AWK_FREE (map->awk, pair);
ASE_AWK_FREE (map->awk, pair);
return -1; /* error */
}
@ -156,51 +156,51 @@ int sse_awk_map_putx (
map->buck[hc] = pair;
map->size++;
if (px != SSE_NULL) *px = pair;
if (px != ASE_NULL) *px = pair;
return 1; /* new key added */
}
sse_awk_pair_t* sse_awk_map_set (
sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len, void* val)
ase_awk_pair_t* ase_awk_map_set (
ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len, void* val)
{
sse_awk_pair_t* pair;
sse_size_t hc;
ase_awk_pair_t* pair;
ase_size_t hc;
hc = __hash(key,key_len) % map->capa;
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)
{
return sse_awk_map_setpair (map, pair, val);
return ase_awk_map_setpair (map, pair, val);
}
pair = pair->next;
}
return SSE_NULL;
return ASE_NULL;
}
sse_awk_pair_t* sse_awk_map_getpair (
sse_awk_map_t* map, const sse_char_t* key, sse_size_t key_len, void** val)
ase_awk_pair_t* ase_awk_map_getpair (
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);
if (pair == SSE_NULL) return SSE_NULL;
pair = ase_awk_map_get (map, key, key_len);
if (pair == ASE_NULL) return ASE_NULL;
*val = pair->val;
return pair;
}
sse_awk_pair_t* sse_awk_map_setpair (
sse_awk_map_t* map, sse_awk_pair_t* pair, void* val)
ase_awk_pair_t* ase_awk_map_setpair (
ase_awk_map_t* map, ase_awk_pair_t* pair, void* val)
{
/* use this function with care */
if (pair->val != val)
{
if (map->freeval != SSE_NULL)
if (map->freeval != ASE_NULL)
{
map->freeval (map->owner, pair->val);
}
@ -210,21 +210,21 @@ sse_awk_pair_t* sse_awk_map_setpair (
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;
sse_size_t hc;
ase_awk_pair_t* pair, * prev;
ase_size_t hc;
hc = __hash(key,key_len) % map->capa;
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)
{
if (prev == SSE_NULL)
if (prev == ASE_NULL)
map->buck[hc] = 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;
}
int sse_awk_map_walk (sse_awk_map_t* map,
int (*walker) (sse_awk_pair_t*,void*), void* arg)
int ase_awk_map_walk (ase_awk_map_t* map,
int (*walker) (ase_awk_pair_t*,void*), void* arg)
{
sse_size_t i;
sse_awk_pair_t* pair, * next;
ase_size_t i;
ase_awk_pair_t* pair, * next;
for (i = 0; i < map->capa; i++)
{
pair = map->buck[i];
while (pair != SSE_NULL)
while (pair != ASE_NULL)
{
next = pair->next;
if (walker(pair,arg) == -1) return -1;
@ -262,15 +262,15 @@ int sse_awk_map_walk (sse_awk_map_t* map,
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;
const sse_char_t* end = key + key_len;
ase_size_t n = 0, i;
const ase_char_t* end = key + key_len;
while (key < end)
{
sse_byte_t* bp = (sse_byte_t*)key;
for (i = 0; i < sse_sizeof(*key); i++) n = n * 31 + *bp++;
ase_byte_t* bp = (ase_byte_t*)key;
for (i = 0; i < ase_sizeof(*key); i++) n = n * 31 + *bp++;
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_
#define _SSE_AWK_MAP_H_
#ifndef _ASE_AWK_MAP_H_
#define _ASE_AWK_MAP_H_
#ifndef _SSE_AWK_AWK_H_
#error Never include this file directly. Include <sse/awk/awk.h> instead
#ifndef _ASE_AWK_AWK_H_
#error Never include this file directly. Include <ase/awk/awk.h> instead
#endif
typedef struct sse_awk_map_t sse_awk_map_t;
typedef struct sse_awk_pair_t sse_awk_pair_t;
typedef struct ase_awk_map_t ase_awk_map_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;
sse_size_t key_len;
ase_char_t* key;
ase_size_t key_len;
void* val;
sse_awk_pair_t* next;
ase_awk_pair_t* next;
};
struct sse_awk_map_t
struct ase_awk_map_t
{
void* owner;
sse_size_t size;
sse_size_t capa;
sse_awk_pair_t** buck;
ase_size_t size;
ase_size_t capa;
ase_awk_pair_t** buck;
void (*freeval) (void*,void*);
sse_awk_t* awk;
sse_bool_t __dynamic;
ase_awk_t* awk;
ase_bool_t __dynamic;
};
#ifdef __cplusplus
extern "C" {
#endif
sse_awk_map_t* sse_awk_map_open (
sse_awk_map_t* map, void* owner, sse_size_t capa,
void(*freeval)(void*,void*), sse_awk_t* awk);
ase_awk_map_t* ase_awk_map_open (
ase_awk_map_t* map, void* owner, ase_size_t capa,
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 (
sse_awk_map_t* map, const sse_char_t* key, sse_size_t key_len);
ase_awk_pair_t* ase_awk_map_get (
ase_awk_map_t* map, const ase_char_t* key, ase_size_t key_len);
sse_awk_pair_t* sse_awk_map_put (
sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len, void* val);
ase_awk_pair_t* ase_awk_map_put (
ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len, void* val);
int sse_awk_map_putx (
sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len,
void* val, sse_awk_pair_t** px);
int ase_awk_map_putx (
ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len,
void* val, ase_awk_pair_t** px);
sse_awk_pair_t* sse_awk_map_set (
sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len, void* val);
ase_awk_pair_t* ase_awk_map_set (
ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len, void* val);
sse_awk_pair_t* sse_awk_map_getpair (
sse_awk_map_t* map, const sse_char_t* key, sse_size_t key_len, void** val);
ase_awk_pair_t* ase_awk_map_getpair (
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 (
sse_awk_map_t* map, sse_awk_pair_t* pair, void* val);
ase_awk_pair_t* ase_awk_map_setpair (
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 (*walker)(sse_awk_pair_t*,void*), void* arg);
int ase_awk_map_walk (ase_awk_map_t* map,
int (*walker)(ase_awk_pair_t*,void*), void* arg);
#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_
#define _SSE_AWK_MISC_H_
#ifndef _ASE_AWK_MISC_H_
#define _ASE_AWK_MISC_H_
#ifndef _SSE_AWK_AWK_H_
#error Never include this file directly. Include <sse/awk/awk.h> instead
#ifndef _ASE_AWK_AWK_H_
#error Never include this file directly. Include <ase/awk/awk.h> instead
#endif
#ifdef __cplusplus
extern "C" {
#endif
void* sse_awk_memcpy (void* dst, const void* src, sse_size_t n);
void* sse_awk_memset (void* dst, int val, sse_size_t n);
void* ase_awk_memcpy (void* dst, const void* src, ase_size_t n);
void* ase_awk_memset (void* dst, int val, ase_size_t n);
sse_char_t* sse_awk_strtok (
sse_awk_run_t* run, const sse_char_t* s,
const sse_char_t* delim, sse_char_t** tok, sse_size_t* tok_len);
ase_char_t* ase_awk_strtok (
ase_awk_run_t* run, const ase_char_t* s,
const ase_char_t* delim, ase_char_t** tok, ase_size_t* tok_len);
sse_char_t* sse_awk_strxtok (
sse_awk_run_t* run, const sse_char_t* s, sse_size_t len,
const sse_char_t* delim, sse_char_t** tok, sse_size_t* tok_len);
ase_char_t* ase_awk_strxtok (
ase_awk_run_t* run, const ase_char_t* s, ase_size_t len,
const ase_char_t* delim, ase_char_t** tok, ase_size_t* tok_len);
sse_char_t* sse_awk_strntok (
sse_awk_run_t* run, const sse_char_t* s,
const sse_char_t* delim, sse_size_t delim_len,
sse_char_t** tok, sse_size_t* tok_len);
ase_char_t* ase_awk_strntok (
ase_awk_run_t* run, const ase_char_t* s,
const ase_char_t* delim, ase_size_t delim_len,
ase_char_t** tok, ase_size_t* tok_len);
sse_char_t* sse_awk_strxntok (
sse_awk_run_t* run, const sse_char_t* s, sse_size_t len,
const sse_char_t* delim, sse_size_t delim_len,
sse_char_t** tok, sse_size_t* tok_len);
ase_char_t* ase_awk_strxntok (
ase_awk_run_t* run, const ase_char_t* s, ase_size_t len,
const ase_char_t* delim, ase_size_t delim_len,
ase_char_t** tok, ase_size_t* tok_len);
sse_char_t* sse_awk_strxntokbyrex (
sse_awk_run_t* run, const sse_char_t* s, sse_size_t len,
void* rex, sse_char_t** tok, sse_size_t* tok_len, int* errnum);
ase_char_t* ase_awk_strxntokbyrex (
ase_awk_run_t* run, const ase_char_t* s, ase_size_t len,
void* rex, ase_char_t** tok, ase_size_t* tok_len, int* errnum);
int sse_awk_abort (sse_awk_t* awk,
const sse_char_t* expr, const sse_char_t* file, int line);
int ase_awk_abort (ase_awk_t* awk,
const ase_char_t* expr, const ase_char_t* file, int line);
#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_
#define _SSE_AWK_PARSE_H_
#ifndef _ASE_AWK_PARSE_H_
#define _ASE_AWK_PARSE_H_
#ifndef _SSE_AWK_AWK_H_
#error Never include this file directly. Include <sse/awk/awk.h> instead
#ifndef _ASE_AWK_AWK_H_
#error Never include this file directly. Include <ase/awk/awk.h> instead
#endif
#ifdef __cplusplus
extern "C" {
#endif
int sse_awk_putsrcstr (sse_awk_t* awk, const sse_char_t* str);
int sse_awk_putsrcstrx (
sse_awk_t* awk, const sse_char_t* str, sse_size_t len);
int ase_awk_putsrcstr (ase_awk_t* awk, const ase_char_t* str);
int ase_awk_putsrcstrx (
ase_awk_t* awk, const ase_char_t* str, ase_size_t len);
#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 (
sse_awk_run_t* run, sse_size_t lv,
const sse_char_t* str, sse_size_t len);
ase_awk_run_t* run, ase_size_t lv,
const ase_char_t* str, ase_size_t len);
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)
{
sse_awk_val_t* v;
ase_awk_val_t* v;
int errnum;
if (idx == 0)
{
if (str == SSE_AWK_STR_BUF(&run->inrec.line) &&
len == SSE_AWK_STR_LEN(&run->inrec.line))
if (str == ASE_AWK_STR_BUF(&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
{
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);
run->errnum = SSE_AWK_ENOMEM;
ase_awk_clrrec (run, ase_false);
run->errnum = ASE_AWK_ENOMEM;
return -1;
}
}
v = sse_awk_makestrval (run, str, len);
if (v == SSE_NULL)
v = ase_awk_makestrval (run, str, len);
if (v == ASE_NULL)
{
sse_awk_clrrec (run, sse_false);
run->errnum = SSE_AWK_ENOMEM;
ase_awk_clrrec (run, ase_false);
run->errnum = ASE_AWK_ENOMEM;
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
* 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;
sse_awk_refupval (v);
ase_awk_refupval (v);
if (__split_record (run) == -1)
{
errnum = run->errnum;
sse_awk_clrrec (run, sse_false);
ase_awk_clrrec (run, ase_false);
run->errnum = errnum;
return -1;
}
@ -61,210 +61,210 @@ int sse_awk_setrec (
if (__recomp_record_fields (run, idx, str, len) == -1)
{
errnum = run->errnum;
sse_awk_clrrec (run, sse_false);
ase_awk_clrrec (run, ase_false);
run->errnum = errnum;
return -1;
}
/* recompose $0 */
v = sse_awk_makestrval (run,
SSE_AWK_STR_BUF(&run->inrec.line),
SSE_AWK_STR_LEN(&run->inrec.line));
if (v == SSE_NULL)
v = ase_awk_makestrval (run,
ASE_AWK_STR_BUF(&run->inrec.line),
ASE_AWK_STR_LEN(&run->inrec.line));
if (v == ASE_NULL)
{
sse_awk_clrrec (run, sse_false);
run->errnum = SSE_AWK_ENOMEM;
ase_awk_clrrec (run, ase_false);
run->errnum = ASE_AWK_ENOMEM;
return -1;
}
sse_awk_refdownval (run, run->inrec.d0);
ase_awk_refdownval (run, run->inrec.d0);
run->inrec.d0 = v;
sse_awk_refupval (v);
ase_awk_refupval (v);
}
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;
sse_size_t len, tok_len, nflds;
sse_awk_val_t* v, * fs;
sse_char_t* fs_ptr, * fs_free;
sse_size_t fs_len;
ase_char_t* p, * tok;
ase_size_t len, tok_len, nflds;
ase_awk_val_t* v, * fs;
ase_char_t* fs_ptr, * fs_free;
ase_size_t fs_len;
int errnum;
/* 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 */
fs = sse_awk_getglobal (run, SSE_AWK_GLOBAL_FS);
if (fs->type == SSE_AWK_VAL_NIL)
fs = ase_awk_getglobal (run, ASE_AWK_GLOBAL_FS);
if (fs->type == ASE_AWK_VAL_NIL)
{
fs_ptr = SSE_T(" ");
fs_ptr = ASE_T(" ");
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_len = ((sse_awk_val_str_t*)fs)->len;
fs_free = SSE_NULL;
fs_ptr = ((ase_awk_val_str_t*)fs)->buf;
fs_len = ((ase_awk_val_str_t*)fs)->len;
fs_free = ASE_NULL;
}
else
{
fs_ptr = sse_awk_valtostr (
run, fs, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &fs_len);
if (fs_ptr == SSE_NULL) return -1;
fs_ptr = ase_awk_valtostr (
run, fs, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &fs_len);
if (fs_ptr == ASE_NULL) return -1;
fs_free = fs_ptr;
}
/* scan the input record to count the fields */
p = SSE_AWK_STR_BUF(&run->inrec.line);
len = SSE_AWK_STR_LEN(&run->inrec.line);
p = ASE_AWK_STR_BUF(&run->inrec.line);
len = ASE_AWK_STR_LEN(&run->inrec.line);
nflds = 0;
while (p != SSE_NULL)
while (p != ASE_NULL)
{
if (fs_len <= 1)
{
p = sse_awk_strxntok (run,
p = ase_awk_strxntok (run,
p, len, fs_ptr, fs_len, &tok, &tok_len);
}
else
{
p = sse_awk_strxntokbyrex (run, p, len,
p = ase_awk_strxntokbyrex (run, p, len,
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)
SSE_AWK_FREE (run->awk, fs_free);
if (fs_free != ASE_NULL)
ASE_AWK_FREE (run->awk, fs_free);
run->errnum = errnum;
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
* as sse_awk_clrrec has been called before this */
if (fs_free != SSE_NULL) SSE_AWK_FREE (run->awk, fs_free);
* as ase_awk_clrrec has been called before this */
if (fs_free != ASE_NULL) ASE_AWK_FREE (run->awk, fs_free);
return 0;
}
sse_awk_assert (run->awk,
(tok != SSE_NULL && tok_len > 0) || tok_len == 0);
ase_awk_assert (run->awk,
(tok != ASE_NULL && tok_len > 0) || tok_len == 0);
nflds++;
len = SSE_AWK_STR_LEN(&run->inrec.line) -
(p - SSE_AWK_STR_BUF(&run->inrec.line));
len = ASE_AWK_STR_LEN(&run->inrec.line) -
(p - ASE_AWK_STR_BUF(&run->inrec.line));
}
/* allocate space */
if (nflds > run->inrec.maxflds)
{
void* tmp = SSE_AWK_MALLOC (
run->awk, sse_sizeof(*run->inrec.flds) * nflds);
if (tmp == SSE_NULL)
void* tmp = ASE_AWK_MALLOC (
run->awk, ase_sizeof(*run->inrec.flds) * nflds);
if (tmp == ASE_NULL)
{
if (fs_free != SSE_NULL) SSE_AWK_FREE (run->awk, fs_free);
run->errnum = SSE_AWK_ENOMEM;
if (fs_free != ASE_NULL) ASE_AWK_FREE (run->awk, fs_free);
run->errnum = ASE_AWK_ENOMEM;
return -1;
}
if (run->inrec.flds != SSE_NULL)
SSE_AWK_FREE (run->awk, run->inrec.flds);
if (run->inrec.flds != ASE_NULL)
ASE_AWK_FREE (run->awk, run->inrec.flds);
run->inrec.flds = tmp;
run->inrec.maxflds = nflds;
}
/* scan again and split it */
p = SSE_AWK_STR_BUF(&run->inrec.line);
len = SSE_AWK_STR_LEN(&run->inrec.line);
p = ASE_AWK_STR_BUF(&run->inrec.line);
len = ASE_AWK_STR_LEN(&run->inrec.line);
while (p != SSE_NULL)
while (p != ASE_NULL)
{
if (fs_len <= 1)
{
p = sse_awk_strxntok (
p = ase_awk_strxntok (
run, p, len, fs_ptr, fs_len, &tok, &tok_len);
}
else
{
p = sse_awk_strxntokbyrex (run, p, len,
p = ase_awk_strxntokbyrex (run, p, len,
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)
SSE_AWK_FREE (run->awk, fs_free);
if (fs_free != ASE_NULL)
ASE_AWK_FREE (run->awk, fs_free);
run->errnum = errnum;
return -1;
}
}
sse_awk_assert (run->awk,
(tok != SSE_NULL && tok_len > 0) || tok_len == 0);
ase_awk_assert (run->awk,
(tok != ASE_NULL && tok_len > 0) || tok_len == 0);
run->inrec.flds[run->inrec.nflds].ptr = tok;
run->inrec.flds[run->inrec.nflds].len = tok_len;
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);
run->errnum = SSE_AWK_ENOMEM;
if (fs_free != ASE_NULL) ASE_AWK_FREE (run->awk, fs_free);
run->errnum = ASE_AWK_ENOMEM;
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++;
len = SSE_AWK_STR_LEN(&run->inrec.line) -
(p - SSE_AWK_STR_BUF(&run->inrec.line));
len = ASE_AWK_STR_LEN(&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 */
v = sse_awk_makeintval (run, (sse_long_t)nflds);
if (v == SSE_NULL)
v = ase_awk_makeintval (run, (ase_long_t)nflds);
if (v == ASE_NULL)
{
run->errnum = SSE_AWK_ENOMEM;
run->errnum = ASE_AWK_ENOMEM;
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;
}
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;
if (run->inrec.d0 != sse_awk_val_nil)
if (run->inrec.d0 != ase_awk_val_nil)
{
sse_awk_refdownval (run, run->inrec.d0);
run->inrec.d0 = sse_awk_val_nil;
ase_awk_refdownval (run, run->inrec.d0);
run->inrec.d0 = ase_awk_val_nil;
}
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++)
{
sse_awk_assert (run->awk,
run->inrec.flds[i].val != SSE_NULL);
sse_awk_refdownval (run, run->inrec.flds[i].val);
ase_awk_assert (run->awk,
run->inrec.flds[i].val != ASE_NULL);
ase_awk_refdownval (run, run->inrec.flds[i].val);
}
run->inrec.nflds = 0;
if (sse_awk_setglobal (
run, SSE_AWK_GLOBAL_NF, sse_awk_val_zero) == -1)
if (ase_awk_setglobal (
run, ASE_AWK_GLOBAL_NF, ase_awk_val_zero) == -1)
{
/* first of all, this should never happen.
* 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);
if (!skip_inrec_line) sse_awk_str_clear (&run->inrec.line);
ase_awk_assert (run->awk, run->inrec.nflds == 0);
if (!skip_inrec_line) ase_awk_str_clear (&run->inrec.line);
return n;
}
static int __recomp_record_fields (
sse_awk_run_t* run, sse_size_t lv,
const sse_char_t* str, sse_size_t len)
ase_awk_run_t* run, ase_size_t lv,
const ase_char_t* str, ase_size_t len)
{
sse_awk_val_t* v;
sse_size_t max, i, nflds;
ase_awk_val_t* v;
ase_size_t max, i, nflds;
/* recomposes the record and the fields when $N has been assigned
* 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;
nflds = run->inrec.nflds;
@ -301,31 +301,31 @@ static int __recomp_record_fields (
* number of fields that the current record can hold,
* 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,
sse_sizeof(*run->inrec.flds) * max);
if (tmp == SSE_NULL)
ase_sizeof(*run->inrec.flds) * max);
if (tmp == ASE_NULL)
{
run->errnum = SSE_AWK_ENOMEM;
run->errnum = ASE_AWK_ENOMEM;
return -1;
}
}
else
{
tmp = SSE_AWK_MALLOC (
run->awk, sse_sizeof(*run->inrec.flds) * max);
if (tmp == SSE_NULL)
tmp = ASE_AWK_MALLOC (
run->awk, ase_sizeof(*run->inrec.flds) * max);
if (tmp == ASE_NULL)
{
run->errnum = SSE_AWK_ENOMEM;
run->errnum = ASE_AWK_ENOMEM;
return -1;
}
if (run->inrec.flds != SSE_NULL)
if (run->inrec.flds != ASE_NULL)
{
SSE_AWK_MEMCPY (run->awk, tmp, run->inrec.flds,
sse_sizeof(*run->inrec.flds) * run->inrec.maxflds);
SSE_AWK_FREE (run->awk, run->inrec.flds);
ASE_AWK_MEMCPY (run->awk, tmp, run->inrec.flds,
ase_sizeof(*run->inrec.flds) * run->inrec.maxflds);
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 */
sse_awk_str_clear (&run->inrec.line);
ase_awk_str_clear (&run->inrec.line);
for (i = 0; i < max; i++)
{
if (i > 0)
{
if (sse_awk_str_ncat (
if (ase_awk_str_ncat (
&run->inrec.line,
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;
}
}
if (i == lv)
{
sse_awk_val_t* tmp;
ase_awk_val_t* tmp;
run->inrec.flds[i].ptr =
SSE_AWK_STR_BUF(&run->inrec.line) +
SSE_AWK_STR_LEN(&run->inrec.line);
ASE_AWK_STR_BUF(&run->inrec.line) +
ASE_AWK_STR_LEN(&run->inrec.line);
run->inrec.flds[i].len = len;
if (sse_awk_str_ncat (
&run->inrec.line, str, len) == (sse_size_t)-1)
if (ase_awk_str_ncat (
&run->inrec.line, str, len) == (ase_size_t)-1)
{
run->errnum = SSE_AWK_ENOMEM;
run->errnum = ASE_AWK_ENOMEM;
return -1;
}
tmp = sse_awk_makestrval (run, str,len);
if (tmp == SSE_NULL)
tmp = ase_awk_makestrval (run, str,len);
if (tmp == ASE_NULL)
{
run->errnum = SSE_AWK_ENOMEM;
run->errnum = ASE_AWK_ENOMEM;
return -1;
}
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++;
run->inrec.flds[i].val = tmp;
sse_awk_refupval (tmp);
ase_awk_refupval (tmp);
}
else if (i >= nflds)
{
run->inrec.flds[i].ptr =
SSE_AWK_STR_BUF(&run->inrec.line) +
SSE_AWK_STR_LEN(&run->inrec.line);
ASE_AWK_STR_BUF(&run->inrec.line) +
ASE_AWK_STR_LEN(&run->inrec.line);
run->inrec.flds[i].len = 0;
if (sse_awk_str_cat (
&run->inrec.line, SSE_T("")) == (sse_size_t)-1)
if (ase_awk_str_cat (
&run->inrec.line, ASE_T("")) == (ase_size_t)-1)
{
run->errnum = SSE_AWK_ENOMEM;
run->errnum = ASE_AWK_ENOMEM;
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
* to any valid values */
/*sse_awk_refdownval (run, run->inrec.flds[i].val);*/
run->inrec.flds[i].val = sse_awk_val_zls;
sse_awk_refupval (sse_awk_val_zls);
/*ase_awk_refdownval (run, run->inrec.flds[i].val);*/
run->inrec.flds[i].val = ase_awk_val_zls;
ase_awk_refupval (ase_awk_val_zls);
run->inrec.nflds++;
}
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 =
SSE_AWK_STR_BUF(&run->inrec.line) +
SSE_AWK_STR_LEN(&run->inrec.line);
ASE_AWK_STR_BUF(&run->inrec.line) +
ASE_AWK_STR_LEN(&run->inrec.line);
run->inrec.flds[i].len = tmp->len;
if (sse_awk_str_ncat (&run->inrec.line,
tmp->buf, tmp->len) == (sse_size_t)-1)
if (ase_awk_str_ncat (&run->inrec.line,
tmp->buf, tmp->len) == (ase_size_t)-1)
{
run->errnum = SSE_AWK_ENOMEM;
run->errnum = ASE_AWK_ENOMEM;
return -1;
}
}
}
v = sse_awk_getglobal (run, SSE_AWK_GLOBAL_NF);
sse_awk_assert (run->awk, v->type == SSE_AWK_VAL_INT);
if (((sse_awk_val_int_t*)v)->val != max)
v = ase_awk_getglobal (run, ASE_AWK_GLOBAL_NF);
ase_awk_assert (run->awk, v->type == ASE_AWK_VAL_INT);
if (((ase_awk_val_int_t*)v)->val != max)
{
v = sse_awk_makeintval (run, (sse_long_t)max);
if (v == SSE_NULL)
v = ase_awk_makeintval (run, (ase_long_t)max);
if (v == ASE_NULL)
{
run->errnum = SSE_AWK_ENOMEM;
run->errnum = ASE_AWK_ENOMEM;
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;
}
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_
#define _SSE_AWK_REX_H_
#ifndef _ASE_AWK_REX_H_
#define _ASE_AWK_REX_H_
#include <sse/types.h>
#include <sse/macros.h>
#include <ase/types.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|
*/
#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) \
(*(sse_size_t*)((sse_byte_t*)(code)+sse_sizeof(sse_size_t)))
#define ASE_AWK_REX_LEN(code) \
(*(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
extern "C" {
#endif
void* sse_awk_buildrex (
sse_awk_t* awk, const sse_char_t* ptn,
sse_size_t len, int* errnum);
void* ase_awk_buildrex (
ase_awk_t* awk, const ase_char_t* ptn,
ase_size_t len, int* errnum);
int sse_awk_matchrex (
sse_awk_t* awk, void* code, int option,
const sse_char_t* str, sse_size_t len,
const sse_char_t** match_ptr, sse_size_t* match_len, int* errnum);
int ase_awk_matchrex (
ase_awk_t* awk, void* code, int option,
const ase_char_t* str, ase_size_t len,
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
}

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_
#define _SSE_AWK_RUN_H_
#ifndef _ASE_AWK_RUN_H_
#define _ASE_AWK_RUN_H_
#ifndef _SSE_AWK_AWK_H_
#error Never include this file directly. Include <sse/awk/awk.h> instead
#ifndef _ASE_AWK_AWK_H_
#error Never include this file directly. Include <ase/awk/awk.h> instead
#endif
enum
{
/* if you change this, you have to change __assop_str in tree.c */
SSE_AWK_ASSOP_NONE,
SSE_AWK_ASSOP_PLUS,
SSE_AWK_ASSOP_MINUS,
SSE_AWK_ASSOP_MUL,
SSE_AWK_ASSOP_DIV,
SSE_AWK_ASSOP_MOD,
SSE_AWK_ASSOP_EXP
ASE_AWK_ASSOP_NONE,
ASE_AWK_ASSOP_PLUS,
ASE_AWK_ASSOP_MINUS,
ASE_AWK_ASSOP_MUL,
ASE_AWK_ASSOP_DIV,
ASE_AWK_ASSOP_MOD,
ASE_AWK_ASSOP_EXP
};
enum
{
/* if you change this, you have to change
* __binop_str in tree.c and __binop_func in run.c accordingly. */
SSE_AWK_BINOP_LOR,
SSE_AWK_BINOP_LAND,
SSE_AWK_BINOP_IN,
ASE_AWK_BINOP_LOR,
ASE_AWK_BINOP_LAND,
ASE_AWK_BINOP_IN,
SSE_AWK_BINOP_BOR,
SSE_AWK_BINOP_BXOR,
SSE_AWK_BINOP_BAND,
ASE_AWK_BINOP_BOR,
ASE_AWK_BINOP_BXOR,
ASE_AWK_BINOP_BAND,
SSE_AWK_BINOP_EQ,
SSE_AWK_BINOP_NE,
SSE_AWK_BINOP_GT,
SSE_AWK_BINOP_GE,
SSE_AWK_BINOP_LT,
SSE_AWK_BINOP_LE,
ASE_AWK_BINOP_EQ,
ASE_AWK_BINOP_NE,
ASE_AWK_BINOP_GT,
ASE_AWK_BINOP_GE,
ASE_AWK_BINOP_LT,
ASE_AWK_BINOP_LE,
SSE_AWK_BINOP_LSHIFT,
SSE_AWK_BINOP_RSHIFT,
ASE_AWK_BINOP_LSHIFT,
ASE_AWK_BINOP_RSHIFT,
SSE_AWK_BINOP_PLUS,
SSE_AWK_BINOP_MINUS,
SSE_AWK_BINOP_MUL,
SSE_AWK_BINOP_DIV,
SSE_AWK_BINOP_MOD,
SSE_AWK_BINOP_EXP,
ASE_AWK_BINOP_PLUS,
ASE_AWK_BINOP_MINUS,
ASE_AWK_BINOP_MUL,
ASE_AWK_BINOP_DIV,
ASE_AWK_BINOP_MOD,
ASE_AWK_BINOP_EXP,
SSE_AWK_BINOP_CONCAT,
SSE_AWK_BINOP_MA,
SSE_AWK_BINOP_NM
ASE_AWK_BINOP_CONCAT,
ASE_AWK_BINOP_MA,
ASE_AWK_BINOP_NM
};
enum
{
/* if you change this, you have to change
* __unrop_str in tree.c accordingly. */
SSE_AWK_UNROP_PLUS,
SSE_AWK_UNROP_MINUS,
SSE_AWK_UNROP_NOT,
SSE_AWK_UNROP_BNOT
ASE_AWK_UNROP_PLUS,
ASE_AWK_UNROP_MINUS,
ASE_AWK_UNROP_NOT,
ASE_AWK_UNROP_BNOT
};
enum
{
/* if you change this, you have to change
* __incop_str in tree.c accordingly. */
SSE_AWK_INCOP_PLUS,
SSE_AWK_INCOP_MINUS
ASE_AWK_INCOP_PLUS,
ASE_AWK_INCOP_MINUS
};
enum
{
/* 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 */
SSE_AWK_GLOBAL_ARGC,
SSE_AWK_GLOBAL_ARGV,
SSE_AWK_GLOBAL_CONVFMT,
SSE_AWK_GLOBAL_ENVIRON,
SSE_AWK_GLOBAL_ERRNO,
SSE_AWK_GLOBAL_FILENAME,
SSE_AWK_GLOBAL_FNR,
SSE_AWK_GLOBAL_FS,
SSE_AWK_GLOBAL_IGNORECASE,
SSE_AWK_GLOBAL_NF,
SSE_AWK_GLOBAL_NR,
SSE_AWK_GLOBAL_OFMT,
SSE_AWK_GLOBAL_OFS,
SSE_AWK_GLOBAL_ORS,
SSE_AWK_GLOBAL_RS,
SSE_AWK_GLOBAL_RT,
SSE_AWK_GLOBAL_RSTART,
SSE_AWK_GLOBAL_RLENGTH,
SSE_AWK_GLOBAL_SUBSEP
ASE_AWK_GLOBAL_ARGC,
ASE_AWK_GLOBAL_ARGV,
ASE_AWK_GLOBAL_CONVFMT,
ASE_AWK_GLOBAL_ENVIRON,
ASE_AWK_GLOBAL_ERRNO,
ASE_AWK_GLOBAL_FILENAME,
ASE_AWK_GLOBAL_FNR,
ASE_AWK_GLOBAL_FS,
ASE_AWK_GLOBAL_IGNORECASE,
ASE_AWK_GLOBAL_NF,
ASE_AWK_GLOBAL_NR,
ASE_AWK_GLOBAL_OFMT,
ASE_AWK_GLOBAL_OFS,
ASE_AWK_GLOBAL_ORS,
ASE_AWK_GLOBAL_RS,
ASE_AWK_GLOBAL_RT,
ASE_AWK_GLOBAL_RSTART,
ASE_AWK_GLOBAL_RLENGTH,
ASE_AWK_GLOBAL_SUBSEP
};
#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 (
sse_awk_str_t* str, sse_size_t capa, sse_awk_t* awk)
ase_awk_str_t* ase_awk_str_open (
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*)
SSE_AWK_MALLOC (awk, sizeof(sse_awk_str_t));
if (str == SSE_NULL) return SSE_NULL;
str->__dynamic = sse_true;
str = (ase_awk_str_t*)
ASE_AWK_MALLOC (awk, sizeof(ase_awk_str_t));
if (str == ASE_NULL) return ASE_NULL;
str->__dynamic = ase_true;
}
else str->__dynamic = sse_false;
else str->__dynamic = ase_false;
str->awk = awk;
str->buf = (sse_char_t*) SSE_AWK_MALLOC (
awk, sse_sizeof(sse_char_t) * (capa + 1));
if (str->buf == SSE_NULL)
str->buf = (ase_char_t*) ASE_AWK_MALLOC (
awk, ase_sizeof(ase_char_t) * (capa + 1));
if (str->buf == ASE_NULL)
{
if (str->__dynamic) SSE_AWK_FREE (awk, str);
return SSE_NULL;
if (str->__dynamic) ASE_AWK_FREE (awk, str);
return ASE_NULL;
}
str->size = 0;
str->capa = capa;
str->buf[0] = SSE_T('\0');
str->buf[0] = ASE_T('\0');
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);
if (str->__dynamic) SSE_AWK_FREE (str->awk, str);
ASE_AWK_FREE (str->awk, str->buf);
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.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;
}
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 */
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 (
sse_awk_str_t* str, const sse_char_t* s, sse_size_t len)
ase_size_t ase_awk_str_ncpy (
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)
{
buf = (sse_char_t*) SSE_AWK_MALLOC (
str->awk, sse_sizeof(sse_char_t) * (len + 1));
if (buf == SSE_NULL) return (sse_size_t)-1;
buf = (ase_char_t*) ASE_AWK_MALLOC (
str->awk, ase_sizeof(ase_char_t) * (len + 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->buf = buf;
}
str->size = sse_awk_strncpy (str->buf, s, len);
str->buf[str->size] = SSE_T('\0');
str->size = ase_awk_strncpy (str->buf, s, len);
str->buf[str->size] = ASE_T('\0');
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 */
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 (
sse_awk_str_t* str, const sse_char_t* s, sse_size_t len)
ase_size_t ase_awk_str_ncat (
ase_awk_str_t* str, const ase_char_t* s, ase_size_t len)
{
if (len > str->capa - str->size)
{
sse_char_t* tmp;
sse_size_t capa;
ase_char_t* tmp;
ase_size_t capa;
capa = str->size + len;
/* double the capa if necessary for concatenation */
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,
sse_sizeof(sse_char_t) * (capa + 1));
if (tmp == SSE_NULL) return (sse_size_t)-1;
ase_sizeof(ase_char_t) * (capa + 1));
if (tmp == ASE_NULL) return (ase_size_t)-1;
}
else
{
tmp = (sse_char_t*) SSE_AWK_MALLOC (
str->awk, sse_sizeof(sse_char_t) * (capa + 1));
if (tmp == SSE_NULL) return (sse_size_t)-1;
if (str->buf != SSE_NULL)
tmp = (ase_char_t*) ASE_AWK_MALLOC (
str->awk, ase_sizeof(ase_char_t) * (capa + 1));
if (tmp == ASE_NULL) return (ase_size_t)-1;
if (str->buf != ASE_NULL)
{
SSE_AWK_MEMCPY (str->awk, tmp, str->buf,
sse_sizeof(sse_char_t) * (str->capa + 1));
SSE_AWK_FREE (str->awk, str->buf);
ASE_AWK_MEMCPY (str->awk, tmp, str->buf,
ase_sizeof(ase_char_t) * (str->capa + 1));
ASE_AWK_FREE (str->awk, str->buf);
}
}
@ -133,23 +133,23 @@ sse_size_t sse_awk_str_ncat (
str->buf = tmp;
}
str->size += sse_awk_strncpy (&str->buf[str->size], s, len);
str->buf[str->size] = SSE_T('\0');
str->size += ase_awk_strncpy (&str->buf[str->size], s, len);
str->buf[str->size] = ASE_T('\0');
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)
{
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--;
@ -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;
}
void sse_awk_str_clear (sse_awk_str_t* str)
void ase_awk_str_clear (ase_awk_str_t* str)
{
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_
#define _SSE_AWK_STR_H_
#ifndef _ASE_AWK_STR_H_
#define _ASE_AWK_STR_H_
#ifndef _SSE_AWK_AWK_H_
#error Never include this file directly. Include <sse/awk/awk.h> instead
#ifndef _ASE_AWK_AWK_H_
#error Never include this file directly. Include <ase/awk/awk.h> instead
#endif
#define SSE_AWK_STR_LEN(x) ((x)->size)
#define SSE_AWK_STR_SIZE(x) ((x)->size + 1)
#define SSE_AWK_STR_CAPA(x) ((x)->capa)
#define SSE_AWK_STR_BUF(x) ((x)->buf)
#define SSE_AWK_STR_CHAR(x,idx) ((x)->buf[idx])
#define ASE_AWK_STR_LEN(x) ((x)->size)
#define ASE_AWK_STR_SIZE(x) ((x)->size + 1)
#define ASE_AWK_STR_CAPA(x) ((x)->capa)
#define ASE_AWK_STR_BUF(x) ((x)->buf)
#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;
sse_size_t size;
sse_size_t capa;
sse_awk_t* awk;
sse_bool_t __dynamic;
ase_char_t* buf;
ase_size_t size;
ase_size_t capa;
ase_awk_t* awk;
ase_bool_t __dynamic;
};
#ifdef __cplusplus
extern "C" {
#endif
sse_awk_str_t* sse_awk_str_open (
sse_awk_str_t* str, sse_size_t capa, sse_awk_t* awk);
ase_awk_str_t* ase_awk_str_open (
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 sse_awk_str_swap (sse_awk_str_t* str, sse_awk_str_t* str2);
void ase_awk_str_forfeit (ase_awk_str_t* str);
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 (
sse_awk_str_t* str, const sse_char_t* s, sse_size_t len);
ase_size_t ase_awk_str_ncpy (
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 (
sse_awk_str_t* str, const sse_char_t* s, sse_size_t len);
ase_size_t ase_awk_str_ncat (
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
}

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 (
awk, sse_sizeof(sse_awk_tab_t));
if (tab == SSE_NULL) return SSE_NULL;
tab->__dynamic = sse_true;
tab = (ase_awk_tab_t*) ASE_AWK_MALLOC (
awk, ase_sizeof(ase_awk_tab_t));
if (tab == ASE_NULL) return ASE_NULL;
tab->__dynamic = ase_true;
}
else tab->__dynamic = sse_false;
else tab->__dynamic = ase_false;
tab->awk = awk;
tab->buf = SSE_NULL;
tab->buf = ASE_NULL;
tab->size = 0;
tab->capa = 0;
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);
if (tab->buf != SSE_NULL)
ase_awk_tab_clear (tab);
if (tab->buf != ASE_NULL)
{
SSE_AWK_FREE (tab->awk, tab->buf);
tab->buf = SSE_NULL;
ASE_AWK_FREE (tab->awk, tab->buf);
tab->buf = ASE_NULL;
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;
}
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;
}
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;
if (tab->size > capa)
{
sse_awk_tab_remove (tab, capa, tab->size - capa);
sse_awk_assert (tab->awk, tab->size <= capa);
ase_awk_tab_remove (tab, capa, tab->size - capa);
ase_awk_assert (tab->awk, tab->size <= capa);
}
if (capa > 0)
{
if (tab->awk->syscas.realloc != SSE_NULL)
if (tab->awk->syscas.realloc != ASE_NULL)
{
tmp = SSE_AWK_REALLOC (tab->awk,
tab->buf, sse_sizeof(*tab->buf) * capa);
if (tmp == SSE_NULL) return SSE_NULL;
tmp = ASE_AWK_REALLOC (tab->awk,
tab->buf, ase_sizeof(*tab->buf) * capa);
if (tmp == ASE_NULL) return ASE_NULL;
}
else
{
tmp = SSE_AWK_MALLOC (
tab->awk, sse_sizeof(*tab->buf) * capa);
if (tmp == SSE_NULL) return SSE_NULL;
if (tab->buf != SSE_NULL)
tmp = ASE_AWK_MALLOC (
tab->awk, ase_sizeof(*tab->buf) * capa);
if (tmp == ASE_NULL) return ASE_NULL;
if (tab->buf != ASE_NULL)
{
sse_size_t x;
ase_size_t x;
x = (capa > tab->capa)? tab->capa: capa;
SSE_AWK_MEMCPY (
ASE_AWK_MEMCPY (
tab->awk, tmp, tab->buf,
sse_sizeof(*tab->buf) * x);
SSE_AWK_FREE (tab->awk, tab->buf);
ase_sizeof(*tab->buf) * x);
ASE_AWK_FREE (tab->awk, tab->buf);
}
}
}
else
{
if (tab->buf != SSE_NULL) SSE_AWK_FREE (tab->awk, tab->buf);
tmp = SSE_NULL;
if (tab->buf != ASE_NULL) ASE_AWK_FREE (tab->awk, tab->buf);
tmp = ASE_NULL;
}
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;
}
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++)
{
SSE_AWK_FREE (tab->awk, tab->buf[i].name);
tab->buf[i].name = SSE_NULL;
ASE_AWK_FREE (tab->awk, tab->buf[i].name);
tab->buf[i].name = ASE_NULL;
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 (
sse_awk_tab_t* tab, sse_size_t index,
const sse_char_t* str, sse_size_t len)
ase_size_t ase_awk_tab_insert (
ase_awk_tab_t* tab, ase_size_t index,
const ase_char_t* str, ase_size_t len)
{
sse_size_t i;
sse_char_t* str_dup;
ase_size_t i;
ase_char_t* str_dup;
str_dup = sse_awk_strxdup (tab->awk, str, len);
if (str_dup == SSE_NULL) return (sse_size_t)-1;
str_dup = ase_awk_strxdup (tab->awk, str, len);
if (str_dup == ASE_NULL) return (ase_size_t)-1;
if (index >= tab->capa)
{
sse_size_t capa;
ase_size_t capa;
if (tab->capa <= 0) capa = (index + 1);
else
@ -127,10 +127,10 @@ sse_size_t sse_awk_tab_insert (
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);
return (sse_size_t)-1;
ASE_AWK_FREE (tab->awk, str_dup);
return (ase_size_t)-1;
}
}
@ -144,10 +144,10 @@ sse_size_t sse_awk_tab_insert (
return index;
}
sse_size_t sse_awk_tab_remove (
sse_awk_tab_t* tab, sse_size_t index, sse_size_t count)
ase_size_t ase_awk_tab_remove (
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 (count > tab->size - index) count = tab->size - index;
@ -158,11 +158,11 @@ sse_size_t sse_awk_tab_remove (
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)
{
tab->buf[i].name = SSE_NULL;
tab->buf[i].name = ASE_NULL;
tab->buf[i].name_len = 0;
i++;
}
@ -178,60 +178,60 @@ sse_size_t sse_awk_tab_remove (
return count;
}
sse_size_t sse_awk_tab_add (
sse_awk_tab_t* tab, const sse_char_t* str, sse_size_t len)
ase_size_t ase_awk_tab_add (
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 (
sse_awk_tab_t* tab, sse_size_t index,
const sse_char_t* str, sse_size_t len)
ase_size_t ase_awk_tab_find (
ase_awk_tab_t* tab, ase_size_t index,
const ase_char_t* str, ase_size_t len)
{
sse_size_t i;
ase_size_t 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,
str, len) == 0) return i;
}
return (sse_size_t)-1;
return (ase_size_t)-1;
}
sse_size_t sse_awk_tab_rfind (
sse_awk_tab_t* tab, sse_size_t index,
const sse_char_t* str, sse_size_t len)
ase_size_t ase_awk_tab_rfind (
ase_awk_tab_t* tab, ase_size_t index,
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; )
{
if (sse_awk_strxncmp (
if (ase_awk_strxncmp (
tab->buf[i].name, tab->buf[i].name_len,
str, len) == 0) return i;
}
return (sse_size_t)-1;
return (ase_size_t)-1;
}
sse_size_t sse_awk_tab_rrfind (
sse_awk_tab_t* tab, sse_size_t index,
const sse_char_t* str, sse_size_t len)
ase_size_t ase_awk_tab_rrfind (
ase_awk_tab_t* tab, ase_size_t index,
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; )
{
if (sse_awk_strxncmp (
if (ase_awk_strxncmp (
tab->buf[i].name, tab->buf[i].name_len,
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_
#define _SSE_AWK_TAB_H_
#ifndef _ASE_AWK_TAB_H_
#define _ASE_AWK_TAB_H_
#ifndef _SSE_AWK_AWK_H_
#error Never include this file directly. Include <sse/awk/awk.h> instead
#ifndef _ASE_AWK_AWK_H_
#error Never include this file directly. Include <ase/awk/awk.h> instead
#endif
/* TODO: you have to turn this into a hash 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
{
sse_char_t* name;
sse_size_t name_len;
ase_char_t* name;
ase_size_t name_len;
}* buf;
sse_size_t size;
sse_size_t capa;
sse_awk_t* awk;
sse_bool_t __dynamic;
ase_size_t size;
ase_size_t capa;
ase_awk_t* awk;
ase_bool_t __dynamic;
};
#ifdef __cplusplus
extern "C" {
#endif
sse_awk_tab_t* sse_awk_tab_open (sse_awk_tab_t* tab, sse_awk_t* awk);
void sse_awk_tab_close (sse_awk_tab_t* tab);
ase_awk_tab_t* ase_awk_tab_open (ase_awk_tab_t* tab, ase_awk_t* awk);
void ase_awk_tab_close (ase_awk_tab_t* tab);
sse_size_t sse_awk_tab_getsize (sse_awk_tab_t* tab);
sse_size_t sse_awk_tab_getcapa (sse_awk_tab_t* tab);
sse_awk_tab_t* sse_awk_tab_setcapa (sse_awk_tab_t* tab, sse_size_t capa);
ase_size_t ase_awk_tab_getsize (ase_awk_tab_t* tab);
ase_size_t ase_awk_tab_getcapa (ase_awk_tab_t* tab);
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 (
sse_awk_tab_t* tab, sse_size_t index,
const sse_char_t* str, sse_size_t len);
ase_size_t ase_awk_tab_insert (
ase_awk_tab_t* tab, ase_size_t index,
const ase_char_t* str, ase_size_t len);
sse_size_t sse_awk_tab_remove (
sse_awk_tab_t* tab, sse_size_t index, sse_size_t count);
ase_size_t ase_awk_tab_remove (
ase_awk_tab_t* tab, ase_size_t index, ase_size_t count);
sse_size_t sse_awk_tab_add (
sse_awk_tab_t* tab, const sse_char_t* str, sse_size_t len);
ase_size_t ase_awk_tab_add (
ase_awk_tab_t* tab, const ase_char_t* str, ase_size_t len);
sse_size_t sse_awk_tab_find (
sse_awk_tab_t* tab, sse_size_t index,
const sse_char_t* str, sse_size_t len);
sse_size_t sse_awk_tab_rfind (
sse_awk_tab_t* tab, sse_size_t index,
const sse_char_t* str, sse_size_t len);
sse_size_t sse_awk_tab_rrfind (
sse_awk_tab_t* tab, sse_size_t index,
const sse_char_t* str, sse_size_t len);
ase_size_t ase_awk_tab_find (
ase_awk_tab_t* tab, ase_size_t index,
const ase_char_t* str, ase_size_t len);
ase_size_t ase_awk_tab_rfind (
ase_awk_tab_t* tab, ase_size_t index,
const ase_char_t* str, ase_size_t len);
ase_size_t ase_awk_tab_rrfind (
ase_awk_tab_t* tab, ase_size_t index,
const ase_char_t* str, ase_size_t len);
#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_
#define _SSE_AWK_TREE_H_
#ifndef _ASE_AWK_TREE_H_
#define _ASE_AWK_TREE_H_
#ifndef _SSE_AWK_AWK_H_
#error Never include this file directly. Include <sse/awk/awk.h> instead
#ifndef _ASE_AWK_AWK_H_
#error Never include this file directly. Include <ase/awk/awk.h> instead
#endif
enum
{
SSE_AWK_NDE_NULL,
ASE_AWK_NDE_NULL,
/* statement */
SSE_AWK_NDE_BLK,
SSE_AWK_NDE_IF,
SSE_AWK_NDE_WHILE,
SSE_AWK_NDE_DOWHILE,
SSE_AWK_NDE_FOR,
SSE_AWK_NDE_FOREACH,
SSE_AWK_NDE_BREAK,
SSE_AWK_NDE_CONTINUE,
SSE_AWK_NDE_RETURN,
SSE_AWK_NDE_EXIT,
SSE_AWK_NDE_NEXT,
SSE_AWK_NDE_NEXTFILE,
SSE_AWK_NDE_DELETE,
SSE_AWK_NDE_PRINT,
ASE_AWK_NDE_BLK,
ASE_AWK_NDE_IF,
ASE_AWK_NDE_WHILE,
ASE_AWK_NDE_DOWHILE,
ASE_AWK_NDE_FOR,
ASE_AWK_NDE_FOREACH,
ASE_AWK_NDE_BREAK,
ASE_AWK_NDE_CONTINUE,
ASE_AWK_NDE_RETURN,
ASE_AWK_NDE_EXIT,
ASE_AWK_NDE_NEXT,
ASE_AWK_NDE_NEXTFILE,
ASE_AWK_NDE_DELETE,
ASE_AWK_NDE_PRINT,
/* expression */
/* if you change the following values including their order,
* you should change __eval_func of __eval_expression
* in run.c accordingly */
SSE_AWK_NDE_GRP,
SSE_AWK_NDE_ASS,
SSE_AWK_NDE_EXP_BIN,
SSE_AWK_NDE_EXP_UNR,
SSE_AWK_NDE_EXP_INCPRE,
SSE_AWK_NDE_EXP_INCPST,
SSE_AWK_NDE_CND,
SSE_AWK_NDE_BFN,
SSE_AWK_NDE_AFN,
SSE_AWK_NDE_INT,
SSE_AWK_NDE_REAL,
SSE_AWK_NDE_STR,
SSE_AWK_NDE_REX,
ASE_AWK_NDE_GRP,
ASE_AWK_NDE_ASS,
ASE_AWK_NDE_EXP_BIN,
ASE_AWK_NDE_EXP_UNR,
ASE_AWK_NDE_EXP_INCPRE,
ASE_AWK_NDE_EXP_INCPST,
ASE_AWK_NDE_CND,
ASE_AWK_NDE_BFN,
ASE_AWK_NDE_AFN,
ASE_AWK_NDE_INT,
ASE_AWK_NDE_REAL,
ASE_AWK_NDE_STR,
ASE_AWK_NDE_REX,
/* keep this order for the following items otherwise, you may have
* to change __eval_incpre and __eval_incpst in run.c as well as
* SSE_AWK_VAL_REF_XXX in val.h */
SSE_AWK_NDE_NAMED,
SSE_AWK_NDE_GLOBAL,
SSE_AWK_NDE_LOCAL,
SSE_AWK_NDE_ARG,
SSE_AWK_NDE_NAMEDIDX,
SSE_AWK_NDE_GLOBALIDX,
SSE_AWK_NDE_LOCALIDX,
SSE_AWK_NDE_ARGIDX,
SSE_AWK_NDE_POS,
* ASE_AWK_VAL_REF_XXX in val.h */
ASE_AWK_NDE_NAMED,
ASE_AWK_NDE_GLOBAL,
ASE_AWK_NDE_LOCAL,
ASE_AWK_NDE_ARG,
ASE_AWK_NDE_NAMEDIDX,
ASE_AWK_NDE_GLOBALIDX,
ASE_AWK_NDE_LOCALIDX,
ASE_AWK_NDE_ARGIDX,
ASE_AWK_NDE_POS,
/* ---------------------------------- */
SSE_AWK_NDE_GETLINE,
ASE_AWK_NDE_GETLINE,
};
enum
@ -69,10 +69,10 @@ enum
/* the order of these values match
* __in_type_map and __in_opt_map in extio.c */
SSE_AWK_IN_PIPE,
SSE_AWK_IN_COPROC,
SSE_AWK_IN_FILE,
SSE_AWK_IN_CONSOLE
ASE_AWK_IN_PIPE,
ASE_AWK_IN_COPROC,
ASE_AWK_IN_FILE,
ASE_AWK_IN_CONSOLE
};
enum
@ -80,298 +80,298 @@ enum
/* the order of these values match
* __out_type_map and __out_opt_map in extio.c */
SSE_AWK_OUT_PIPE,
SSE_AWK_OUT_COPROC,
SSE_AWK_OUT_FILE,
SSE_AWK_OUT_FILE_APPEND,
SSE_AWK_OUT_CONSOLE
ASE_AWK_OUT_PIPE,
ASE_AWK_OUT_COPROC,
ASE_AWK_OUT_FILE,
ASE_AWK_OUT_FILE_APPEND,
ASE_AWK_OUT_CONSOLE
};
/* 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 sse_awk_nde_grp_t sse_awk_nde_grp_t;
typedef struct sse_awk_nde_ass_t sse_awk_nde_ass_t;
typedef struct sse_awk_nde_exp_t sse_awk_nde_exp_t;
typedef struct sse_awk_nde_cnd_t sse_awk_nde_cnd_t;
typedef struct sse_awk_nde_pos_t sse_awk_nde_pos_t;
typedef struct sse_awk_nde_int_t sse_awk_nde_int_t;
typedef struct sse_awk_nde_real_t sse_awk_nde_real_t;
typedef struct sse_awk_nde_str_t sse_awk_nde_str_t;
typedef struct sse_awk_nde_rex_t sse_awk_nde_rex_t;
typedef struct sse_awk_nde_var_t sse_awk_nde_var_t;
typedef struct sse_awk_nde_call_t sse_awk_nde_call_t;
typedef struct sse_awk_nde_getline_t sse_awk_nde_getline_t;
typedef struct ase_awk_nde_blk_t ase_awk_nde_blk_t;
typedef struct ase_awk_nde_grp_t ase_awk_nde_grp_t;
typedef struct ase_awk_nde_ass_t ase_awk_nde_ass_t;
typedef struct ase_awk_nde_exp_t ase_awk_nde_exp_t;
typedef struct ase_awk_nde_cnd_t ase_awk_nde_cnd_t;
typedef struct ase_awk_nde_pos_t ase_awk_nde_pos_t;
typedef struct ase_awk_nde_int_t ase_awk_nde_int_t;
typedef struct ase_awk_nde_real_t ase_awk_nde_real_t;
typedef struct ase_awk_nde_str_t ase_awk_nde_str_t;
typedef struct ase_awk_nde_rex_t ase_awk_nde_rex_t;
typedef struct ase_awk_nde_var_t ase_awk_nde_var_t;
typedef struct ase_awk_nde_call_t ase_awk_nde_call_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 sse_awk_nde_while_t sse_awk_nde_while_t;
typedef struct sse_awk_nde_for_t sse_awk_nde_for_t;
typedef struct sse_awk_nde_foreach_t sse_awk_nde_foreach_t;
typedef struct sse_awk_nde_break_t sse_awk_nde_break_t;
typedef struct sse_awk_nde_continue_t sse_awk_nde_continue_t;
typedef struct sse_awk_nde_return_t sse_awk_nde_return_t;
typedef struct sse_awk_nde_exit_t sse_awk_nde_exit_t;
typedef struct sse_awk_nde_next_t sse_awk_nde_next_t;
typedef struct sse_awk_nde_nextfile_t sse_awk_nde_nextfile_t;
typedef struct sse_awk_nde_delete_t sse_awk_nde_delete_t;
typedef struct sse_awk_nde_print_t sse_awk_nde_print_t;
typedef struct ase_awk_nde_if_t ase_awk_nde_if_t;
typedef struct ase_awk_nde_while_t ase_awk_nde_while_t;
typedef struct ase_awk_nde_for_t ase_awk_nde_for_t;
typedef struct ase_awk_nde_foreach_t ase_awk_nde_foreach_t;
typedef struct ase_awk_nde_break_t ase_awk_nde_break_t;
typedef struct ase_awk_nde_continue_t ase_awk_nde_continue_t;
typedef struct ase_awk_nde_return_t ase_awk_nde_return_t;
typedef struct ase_awk_nde_exit_t ase_awk_nde_exit_t;
typedef struct ase_awk_nde_next_t ase_awk_nde_next_t;
typedef struct ase_awk_nde_nextfile_t ase_awk_nde_nextfile_t;
typedef struct ase_awk_nde_delete_t ase_awk_nde_delete_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;
sse_size_t name_len;
sse_size_t nargs;
sse_awk_nde_t* body;
ase_char_t* name;
ase_size_t name_len;
ase_size_t nargs;
ase_awk_nde_t* body;
};
#define SSE_AWK_NDE_HDR \
#define ASE_AWK_NDE_HDR \
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 */
struct sse_awk_nde_blk_t
/* ASE_AWK_NDE_BLK - block statement including top-level blocks */
struct ase_awk_nde_blk_t
{
SSE_AWK_NDE_HDR;
sse_size_t nlocals;
sse_awk_nde_t* body;
ASE_AWK_NDE_HDR;
ase_size_t nlocals;
ase_awk_nde_t* body;
};
/* SSE_AWK_NDE_GRP - expression group */
struct sse_awk_nde_grp_t
/* ASE_AWK_NDE_GRP - expression group */
struct ase_awk_nde_grp_t
{
SSE_AWK_NDE_HDR;
sse_awk_nde_t* body;
ASE_AWK_NDE_HDR;
ase_awk_nde_t* body;
};
/* SSE_AWK_NDE_ASS - assignment */
struct sse_awk_nde_ass_t
/* ASE_AWK_NDE_ASS - assignment */
struct ase_awk_nde_ass_t
{
SSE_AWK_NDE_HDR;
ASE_AWK_NDE_HDR;
int opcode;
sse_awk_nde_t* left;
sse_awk_nde_t* right;
ase_awk_nde_t* left;
ase_awk_nde_t* right;
};
/* SSE_AWK_NDE_EXP_BIN, SSE_AWK_NDE_EXP_UNR,
* SSE_AWK_NDE_EXP_INCPRE, SSE_AW_NDE_EXP_INCPST */
struct sse_awk_nde_exp_t
/* ASE_AWK_NDE_EXP_BIN, ASE_AWK_NDE_EXP_UNR,
* ASE_AWK_NDE_EXP_INCPRE, ASE_AW_NDE_EXP_INCPST */
struct ase_awk_nde_exp_t
{
SSE_AWK_NDE_HDR;
ASE_AWK_NDE_HDR;
int opcode;
sse_awk_nde_t* left;
sse_awk_nde_t* right; /* SSE_NULL for UNR, INCPRE, INCPST */
ase_awk_nde_t* left;
ase_awk_nde_t* right; /* ASE_NULL for UNR, INCPRE, INCPST */
};
/* SSE_AWK_NDE_CND */
struct sse_awk_nde_cnd_t
/* ASE_AWK_NDE_CND */
struct ase_awk_nde_cnd_t
{
SSE_AWK_NDE_HDR;
sse_awk_nde_t* test;
sse_awk_nde_t* left;
sse_awk_nde_t* right;
ASE_AWK_NDE_HDR;
ase_awk_nde_t* test;
ase_awk_nde_t* left;
ase_awk_nde_t* right;
};
/* SSE_AWK_NDE_POS - positional - $1, $2, $x, etc */
struct sse_awk_nde_pos_t
/* ASE_AWK_NDE_POS - positional - $1, $2, $x, etc */
struct ase_awk_nde_pos_t
{
SSE_AWK_NDE_HDR;
sse_awk_nde_t* val;
ASE_AWK_NDE_HDR;
ase_awk_nde_t* val;
};
/* SSE_AWK_NDE_INT */
struct sse_awk_nde_int_t
/* ASE_AWK_NDE_INT */
struct ase_awk_nde_int_t
{
SSE_AWK_NDE_HDR;
sse_long_t val;
sse_char_t* str;
sse_size_t len;
ASE_AWK_NDE_HDR;
ase_long_t val;
ase_char_t* str;
ase_size_t len;
};
/* SSE_AWK_NDE_REAL */
struct sse_awk_nde_real_t
/* ASE_AWK_NDE_REAL */
struct ase_awk_nde_real_t
{
SSE_AWK_NDE_HDR;
sse_real_t val;
sse_char_t* str;
sse_size_t len;
ASE_AWK_NDE_HDR;
ase_real_t val;
ase_char_t* str;
ase_size_t len;
};
/* SSE_AWK_NDE_STR */
struct sse_awk_nde_str_t
/* ASE_AWK_NDE_STR */
struct ase_awk_nde_str_t
{
SSE_AWK_NDE_HDR;
sse_char_t* buf;
sse_size_t len;
ASE_AWK_NDE_HDR;
ase_char_t* buf;
ase_size_t len;
};
/* SSE_AWK_NDE_REX */
struct sse_awk_nde_rex_t
/* ASE_AWK_NDE_REX */
struct ase_awk_nde_rex_t
{
SSE_AWK_NDE_HDR;
sse_char_t* buf;
sse_size_t len;
ASE_AWK_NDE_HDR;
ase_char_t* buf;
ase_size_t len;
void* code;
};
/* SSE_AWK_NDE_NAMED, SSE_AWK_NDE_GLOBAL,
* SSE_AWK_NDE_LOCAL, SSE_AWK_NDE_ARG
* SSE_AWK_NDE_NAMEDIDX, SSE_AWK_NDE_GLOBALIDX,
* SSE_AWK_NDE_LOCALIDX, SSE_AWK_NDE_ARGIDX */
struct sse_awk_nde_var_t
/* ASE_AWK_NDE_NAMED, ASE_AWK_NDE_GLOBAL,
* ASE_AWK_NDE_LOCAL, ASE_AWK_NDE_ARG
* ASE_AWK_NDE_NAMEDIDX, ASE_AWK_NDE_GLOBALIDX,
* ASE_AWK_NDE_LOCALIDX, ASE_AWK_NDE_ARGIDX */
struct ase_awk_nde_var_t
{
SSE_AWK_NDE_HDR;
ASE_AWK_NDE_HDR;
struct
{
sse_char_t* name;
sse_size_t name_len;
sse_size_t idxa;
ase_char_t* name;
ase_size_t name_len;
ase_size_t idxa;
} 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 */
struct sse_awk_nde_call_t
/* ASE_AWK_NDE_BFN, ASE_AWK_NDE_AFN */
struct ase_awk_nde_call_t
{
SSE_AWK_NDE_HDR;
ASE_AWK_NDE_HDR;
union
{
struct
{
sse_char_t* name;
sse_size_t name_len;
ase_char_t* name;
ase_size_t name_len;
} afn;
/* minimum information of a built-in function
* needed during run-time. */
struct
{
const sse_char_t* name;
sse_size_t name_len;
sse_size_t min_args;
sse_size_t max_args;
const sse_char_t* arg_spec;
int (*handler) (sse_awk_run_t* awk);
const ase_char_t* name;
ase_size_t name_len;
ase_size_t min_args;
ase_size_t max_args;
const ase_char_t* arg_spec;
int (*handler) (ase_awk_run_t* awk);
} bfn;
/* sse_awk_bfn_t* bfn; */
/* ase_awk_bfn_t* bfn; */
} what;
sse_awk_nde_t* args;
sse_size_t nargs;
ase_awk_nde_t* args;
ase_size_t nargs;
};
/* SSE_AWK_NDE_GETLINE */
struct sse_awk_nde_getline_t
/* ASE_AWK_NDE_GETLINE */
struct ase_awk_nde_getline_t
{
SSE_AWK_NDE_HDR;
sse_awk_nde_t* var;
int in_type; /* SSE_AWK_GETLINE_XXX */
sse_awk_nde_t* in;
ASE_AWK_NDE_HDR;
ase_awk_nde_t* var;
int in_type; /* ASE_AWK_GETLINE_XXX */
ase_awk_nde_t* in;
};
/* SSE_AWK_NDE_IF */
struct sse_awk_nde_if_t
/* ASE_AWK_NDE_IF */
struct ase_awk_nde_if_t
{
SSE_AWK_NDE_HDR;
sse_awk_nde_t* test;
sse_awk_nde_t* then_part;
sse_awk_nde_t* else_part; /* optional */
ASE_AWK_NDE_HDR;
ase_awk_nde_t* test;
ase_awk_nde_t* then_part;
ase_awk_nde_t* else_part; /* optional */
};
/* SSE_AWK_NDE_WHILE, SSE_AWK_NDE_DOWHILE */
struct sse_awk_nde_while_t
/* ASE_AWK_NDE_WHILE, ASE_AWK_NDE_DOWHILE */
struct ase_awk_nde_while_t
{
SSE_AWK_NDE_HDR;
sse_awk_nde_t* test;
sse_awk_nde_t* body;
ASE_AWK_NDE_HDR;
ase_awk_nde_t* test;
ase_awk_nde_t* body;
};
/* SSE_AWK_NDE_FOR */
struct sse_awk_nde_for_t
/* ASE_AWK_NDE_FOR */
struct ase_awk_nde_for_t
{
SSE_AWK_NDE_HDR;
sse_awk_nde_t* init; /* optional */
sse_awk_nde_t* test; /* optional */
sse_awk_nde_t* incr; /* optional */
sse_awk_nde_t* body;
ASE_AWK_NDE_HDR;
ase_awk_nde_t* init; /* optional */
ase_awk_nde_t* test; /* optional */
ase_awk_nde_t* incr; /* optional */
ase_awk_nde_t* body;
};
/* SSE_AWK_NDE_FOREACH */
struct sse_awk_nde_foreach_t
/* ASE_AWK_NDE_FOREACH */
struct ase_awk_nde_foreach_t
{
SSE_AWK_NDE_HDR;
sse_awk_nde_t* test;
sse_awk_nde_t* body;
ASE_AWK_NDE_HDR;
ase_awk_nde_t* test;
ase_awk_nde_t* body;
};
/* SSE_AWK_NDE_BREAK */
struct sse_awk_nde_break_t
/* ASE_AWK_NDE_BREAK */
struct ase_awk_nde_break_t
{
SSE_AWK_NDE_HDR;
ASE_AWK_NDE_HDR;
};
/* SSE_AWK_NDE_CONTINUE */
struct sse_awk_nde_continue_t
/* ASE_AWK_NDE_CONTINUE */
struct ase_awk_nde_continue_t
{
SSE_AWK_NDE_HDR;
ASE_AWK_NDE_HDR;
};
/* SSE_AWK_NDE_RETURN */
struct sse_awk_nde_return_t
/* ASE_AWK_NDE_RETURN */
struct ase_awk_nde_return_t
{
SSE_AWK_NDE_HDR;
sse_awk_nde_t* val; /* optional (no return code if SSE_NULL) */
ASE_AWK_NDE_HDR;
ase_awk_nde_t* val; /* optional (no return code if ASE_NULL) */
};
/* SSE_AWK_NDE_EXIT */
struct sse_awk_nde_exit_t
/* ASE_AWK_NDE_EXIT */
struct ase_awk_nde_exit_t
{
SSE_AWK_NDE_HDR;
sse_awk_nde_t* val; /* optional (no exit code if SSE_NULL) */
ASE_AWK_NDE_HDR;
ase_awk_nde_t* val; /* optional (no exit code if ASE_NULL) */
};
/* SSE_AWK_NDE_NEXT */
struct sse_awk_nde_next_t
/* ASE_AWK_NDE_NEXT */
struct ase_awk_nde_next_t
{
SSE_AWK_NDE_HDR;
ASE_AWK_NDE_HDR;
};
/* SSE_AWK_NDE_NEXTFILE */
struct sse_awk_nde_nextfile_t
/* ASE_AWK_NDE_NEXTFILE */
struct ase_awk_nde_nextfile_t
{
SSE_AWK_NDE_HDR;
ASE_AWK_NDE_HDR;
};
/* SSE_AWK_NDE_DELETE */
struct sse_awk_nde_delete_t
/* ASE_AWK_NDE_DELETE */
struct ase_awk_nde_delete_t
{
SSE_AWK_NDE_HDR;
sse_awk_nde_t* var;
ASE_AWK_NDE_HDR;
ase_awk_nde_t* var;
};
/* SSE_AWK_NDE_PRINT */
struct sse_awk_nde_print_t
/* ASE_AWK_NDE_PRINT */
struct ase_awk_nde_print_t
{
SSE_AWK_NDE_HDR;
sse_awk_nde_t* args;
int out_type; /* SSE_AWK_OUT_XXX */
sse_awk_nde_t* out;
ASE_AWK_NDE_HDR;
ase_awk_nde_t* args;
int out_type; /* ASE_AWK_OUT_XXX */
ase_awk_nde_t* out;
};
#ifdef __cplusplus
extern "C" {
#endif
int sse_awk_prnpt (sse_awk_t* awk, sse_awk_nde_t* tree);
int sse_awk_prnptnpt (sse_awk_t* awk, sse_awk_nde_t* tree);
int ase_awk_prnpt (ase_awk_t* awk, ase_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
}

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_
#define _SSE_AWK_VAL_H_
#ifndef _ASE_AWK_VAL_H_
#define _ASE_AWK_VAL_H_
#ifndef _SSE_AWK_AWK_H_
#error Never include this file directly. Include <sse/awk/awk.h> instead
#ifndef _ASE_AWK_AWK_H_
#error Never include this file directly. Include <ase/awk/awk.h> instead
#endif
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
* function in run.c */
SSE_AWK_VAL_NIL = 0,
SSE_AWK_VAL_INT = 1,
SSE_AWK_VAL_REAL = 2,
SSE_AWK_VAL_STR = 3,
ASE_AWK_VAL_NIL = 0,
ASE_AWK_VAL_INT = 1,
ASE_AWK_VAL_REAL = 2,
ASE_AWK_VAL_STR = 3,
SSE_AWK_VAL_REX = 4,
SSE_AWK_VAL_MAP = 5,
SSE_AWK_VAL_REF = 6
ASE_AWK_VAL_REX = 4,
ASE_AWK_VAL_MAP = 5,
ASE_AWK_VAL_REF = 6
};
enum
{
/* keep these items in the same order as corresponding items
* in tree.h */
SSE_AWK_VAL_REF_NAMED,
SSE_AWK_VAL_REF_GLOBAL,
SSE_AWK_VAL_REF_LOCAL,
SSE_AWK_VAL_REF_ARG,
SSE_AWK_VAL_REF_NAMEDIDX,
SSE_AWK_VAL_REF_GLOBALIDX,
SSE_AWK_VAL_REF_LOCALIDX,
SSE_AWK_VAL_REF_ARGIDX,
SSE_AWK_VAL_REF_POS
ASE_AWK_VAL_REF_NAMED,
ASE_AWK_VAL_REF_GLOBAL,
ASE_AWK_VAL_REF_LOCAL,
ASE_AWK_VAL_REF_ARG,
ASE_AWK_VAL_REF_NAMEDIDX,
ASE_AWK_VAL_REF_GLOBALIDX,
ASE_AWK_VAL_REF_LOCALIDX,
ASE_AWK_VAL_REF_ARGIDX,
ASE_AWK_VAL_REF_POS
};
enum
{
SSE_AWK_VALTOSTR_CLEAR = (1 << 0),
SSE_AWK_VALTOSTR_PRINT = (1 << 1)
ASE_AWK_VALTOSTR_CLEAR = (1 << 0),
ASE_AWK_VALTOSTR_PRINT = (1 << 1)
};
typedef struct sse_awk_val_nil_t sse_awk_val_nil_t;
typedef struct sse_awk_val_int_t sse_awk_val_int_t;
typedef struct sse_awk_val_real_t sse_awk_val_real_t;
typedef struct sse_awk_val_str_t sse_awk_val_str_t;
typedef struct sse_awk_val_rex_t sse_awk_val_rex_t;
typedef struct sse_awk_val_map_t sse_awk_val_map_t;
typedef struct sse_awk_val_ref_t sse_awk_val_ref_t;
typedef struct ase_awk_val_nil_t ase_awk_val_nil_t;
typedef struct ase_awk_val_int_t ase_awk_val_int_t;
typedef struct ase_awk_val_real_t ase_awk_val_real_t;
typedef struct ase_awk_val_str_t ase_awk_val_str_t;
typedef struct ase_awk_val_rex_t ase_awk_val_rex_t;
typedef struct ase_awk_val_map_t ase_awk_val_map_t;
typedef struct ase_awk_val_ref_t ase_awk_val_ref_t;
#if SSE_SIZEOF_INT == 2
#define SSE_AWK_VAL_HDR \
#if ASE_SIZEOF_INT == 2
#define ASE_AWK_VAL_HDR \
unsigned int type: 3; \
unsigned int ref: 13
#else
#define SSE_AWK_VAL_HDR \
#define ASE_AWK_VAL_HDR \
unsigned int type: 3; \
unsigned int ref: 29
#endif
struct sse_awk_val_t
struct ase_awk_val_t
{
SSE_AWK_VAL_HDR;
ASE_AWK_VAL_HDR;
};
/* SSE_AWK_VAL_NIL */
struct sse_awk_val_nil_t
/* ASE_AWK_VAL_NIL */
struct ase_awk_val_nil_t
{
SSE_AWK_VAL_HDR;
ASE_AWK_VAL_HDR;
};
/* SSE_AWK_VAL_INT */
struct sse_awk_val_int_t
/* ASE_AWK_VAL_INT */
struct ase_awk_val_int_t
{
SSE_AWK_VAL_HDR;
sse_long_t val;
sse_awk_nde_int_t* nde;
ASE_AWK_VAL_HDR;
ase_long_t val;
ase_awk_nde_int_t* nde;
};
/* SSE_AWK_VAL_REAL */
struct sse_awk_val_real_t
/* ASE_AWK_VAL_REAL */
struct ase_awk_val_real_t
{
SSE_AWK_VAL_HDR;
sse_real_t val;
sse_awk_nde_real_t* nde;
ASE_AWK_VAL_HDR;
ase_real_t val;
ase_awk_nde_real_t* nde;
};
/* SSE_AWK_VAL_STR */
struct sse_awk_val_str_t
/* ASE_AWK_VAL_STR */
struct ase_awk_val_str_t
{
SSE_AWK_VAL_HDR;
sse_char_t* buf;
sse_size_t len;
ASE_AWK_VAL_HDR;
ase_char_t* buf;
ase_size_t len;
};
/* SSE_AWK_VAL_REX */
struct sse_awk_val_rex_t
/* ASE_AWK_VAL_REX */
struct ase_awk_val_rex_t
{
SSE_AWK_VAL_HDR;
sse_char_t* buf;
sse_size_t len;
ASE_AWK_VAL_HDR;
ase_char_t* buf;
ase_size_t len;
void* code;
};
/* SSE_AWK_VAL_MAP */
struct sse_awk_val_map_t
/* ASE_AWK_VAL_MAP */
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
* integers switch to map dynamically once the
* non-integral index is seen.
*/
sse_awk_map_t* map;
ase_awk_map_t* map;
};
/* SSE_AWK_VAL_REF */
struct sse_awk_val_ref_t
/* ASE_AWK_VAL_REF */
struct ase_awk_val_ref_t
{
SSE_AWK_VAL_HDR;
ASE_AWK_VAL_HDR;
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
* directly. */
sse_awk_val_t** adr;
ase_awk_val_t** adr;
};
#ifdef __cplusplus
extern "C" {
#endif
extern sse_awk_val_t* sse_awk_val_nil;
extern sse_awk_val_t* sse_awk_val_zls;
extern sse_awk_val_t* sse_awk_val_zero;
extern sse_awk_val_t* sse_awk_val_one;
extern ase_awk_val_t* ase_awk_val_nil;
extern ase_awk_val_t* ase_awk_val_zls;
extern ase_awk_val_t* ase_awk_val_zero;
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);
sse_awk_val_t* sse_awk_makerealval (sse_awk_run_t* run, sse_real_t v);
ase_awk_val_t* ase_awk_makeintval (ase_awk_run_t* run, ase_long_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);
sse_awk_val_t* sse_awk_makestrval (
sse_awk_run_t* run, const sse_char_t* str, sse_size_t len);
sse_awk_val_t* sse_awk_makestrval2 (
sse_awk_run_t* run,
const sse_char_t* str1, sse_size_t len1,
const sse_char_t* str2, sse_size_t len2);
ase_awk_val_t* ase_awk_makestrval0 (ase_awk_run_t* run, const ase_char_t* str);
ase_awk_val_t* ase_awk_makestrval (
ase_awk_run_t* run, const ase_char_t* str, ase_size_t len);
ase_awk_val_t* ase_awk_makestrval2 (
ase_awk_run_t* run,
const ase_char_t* str1, ase_size_t len1,
const ase_char_t* str2, ase_size_t len2);
sse_awk_val_t* sse_awk_makerexval (
sse_awk_run_t* run, const sse_char_t* buf, sse_size_t len, void* code);
sse_awk_val_t* sse_awk_makemapval (sse_awk_run_t* run);
sse_awk_val_t* sse_awk_makerefval (
sse_awk_run_t* run, int id, sse_awk_val_t** adr);
ase_awk_val_t* ase_awk_makerexval (
ase_awk_run_t* run, const ase_char_t* buf, ase_size_t len, void* code);
ase_awk_val_t* ase_awk_makemapval (ase_awk_run_t* run);
ase_awk_val_t* ase_awk_makerefval (
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 sse_awk_refupval (sse_awk_val_t* val);
void sse_awk_refdownval (sse_awk_run_t* run, sse_awk_val_t* val);
void sse_awk_refdownval_nofree (sse_awk_run_t* run, sse_awk_val_t* val);
void ase_awk_freeval (ase_awk_run_t* run, ase_awk_val_t* val, ase_bool_t cache);
void ase_awk_refupval (ase_awk_val_t* val);
void ase_awk_refdownval (ase_awk_run_t* run, ase_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 (
sse_awk_run_t* run, sse_awk_val_t* val);
ase_bool_t ase_awk_valtobool (
ase_awk_run_t* run, ase_awk_val_t* val);
sse_char_t* sse_awk_valtostr (
sse_awk_run_t* run, sse_awk_val_t* val,
int opt, sse_awk_str_t* buf, sse_size_t* len);
ase_char_t* ase_awk_valtostr (
ase_awk_run_t* run, ase_awk_val_t* val,
int opt, ase_awk_str_t* buf, ase_size_t* len);
int sse_awk_valtonum (
sse_awk_run_t* run, sse_awk_val_t* v, sse_long_t* l, sse_real_t* r);
int ase_awk_valtonum (
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
}