diff --git a/ase/awk/awk.c b/ase/awk/awk.c
index 202ef44f..e1e03cef 100644
--- a/ase/awk/awk.c
+++ b/ase/awk/awk.c
@@ -1,112 +1,112 @@
/*
- * $Id: awk.c,v 1.82 2006-10-16 08:47:59 bacon Exp $
+ * $Id: awk.c,v 1.83 2006-10-22 11:34:52 bacon Exp $
*/
-#include <xp/awk/awk_i.h>
+#include <sse/awk/awk_i.h>
static void __free_afn (void* awk, void* afn);
-xp_awk_t* xp_awk_open (xp_awk_syscas_t* syscas)
+sse_awk_t* sse_awk_open (sse_awk_syscas_t* syscas)
{
- xp_awk_t* awk;
+ sse_awk_t* awk;
- if (syscas == XP_NULL) return XP_NULL;
+ if (syscas == SSE_NULL) return SSE_NULL;
- if (syscas->malloc == XP_NULL ||
- syscas->free == XP_NULL) return XP_NULL;
+ if (syscas->malloc == SSE_NULL ||
+ syscas->free == SSE_NULL) return SSE_NULL;
- if (syscas->is_upper == XP_NULL ||
- syscas->is_lower == XP_NULL ||
- syscas->is_alpha == XP_NULL ||
- syscas->is_digit == XP_NULL ||
- syscas->is_xdigit == XP_NULL ||
- syscas->is_alnum == XP_NULL ||
- syscas->is_space == XP_NULL ||
- syscas->is_print == XP_NULL ||
- syscas->is_graph == XP_NULL ||
- syscas->is_cntrl == XP_NULL ||
- syscas->is_punct == XP_NULL ||
- syscas->to_upper == XP_NULL ||
- syscas->to_lower == XP_NULL) return XP_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->sprintf == XP_NULL ||
- syscas->dprintf == XP_NULL ||
- syscas->abort == XP_NULL) return XP_NULL;
+ if (syscas->sprintf == SSE_NULL ||
+ syscas->dprintf == SSE_NULL ||
+ syscas->abort == SSE_NULL) return SSE_NULL;
#if defined(_WIN32) && defined(_DEBUG)
- awk = (xp_awk_t*) malloc (xp_sizeof(xp_awk_t));
+ awk = (sse_awk_t*) malloc (sse_sizeof(sse_awk_t));
#else
- awk = (xp_awk_t*) syscas->malloc (
- xp_sizeof(xp_awk_t), syscas->custom_data);
+ awk = (sse_awk_t*) syscas->malloc (
+ sse_sizeof(sse_awk_t), syscas->custom_data);
#endif
- if (awk == XP_NULL) return XP_NULL;
+ if (awk == SSE_NULL) return SSE_NULL;
- /* it uses the built-in xp_awk_memset because awk is not
+ /* it uses the built-in sse_awk_memset because awk is not
* fully initialized yet */
- xp_awk_memset (awk, 0, xp_sizeof(xp_awk_t));
+ sse_awk_memset (awk, 0, sse_sizeof(sse_awk_t));
- if (syscas->memcpy == XP_NULL)
+ if (syscas->memcpy == SSE_NULL)
{
- xp_awk_memcpy (&awk->syscas, syscas, xp_sizeof(awk->syscas));
- awk->syscas.memcpy = xp_awk_memcpy;
+ sse_awk_memcpy (&awk->syscas, syscas, sse_sizeof(awk->syscas));
+ awk->syscas.memcpy = sse_awk_memcpy;
}
- else syscas->memcpy (&awk->syscas, syscas, xp_sizeof(awk->syscas));
- if (syscas->memset == XP_NULL) awk->syscas.memset = xp_awk_memset;
+ else syscas->memcpy (&awk->syscas, syscas, sse_sizeof(awk->syscas));
+ if (syscas->memset == SSE_NULL) awk->syscas.memset = sse_awk_memset;
- if (xp_awk_str_open (&awk->token.name, 128, awk) == XP_NULL)
+ if (sse_awk_str_open (&awk->token.name, 128, awk) == SSE_NULL)
{
- XP_AWK_FREE (awk, awk);
- return XP_NULL;
+ SSE_AWK_FREE (awk, awk);
+ return SSE_NULL;
}
/* TODO: initial map size?? */
- if (xp_awk_map_open (
- &awk->tree.afns, awk, 256, __free_afn, awk) == XP_NULL)
+ if (sse_awk_map_open (
+ &awk->tree.afns, awk, 256, __free_afn, awk) == SSE_NULL)
{
- xp_awk_str_close (&awk->token.name);
- XP_AWK_FREE (awk, awk);
- return XP_NULL;
+ sse_awk_str_close (&awk->token.name);
+ SSE_AWK_FREE (awk, awk);
+ return SSE_NULL;
}
- if (xp_awk_tab_open (&awk->parse.globals, awk) == XP_NULL)
+ if (sse_awk_tab_open (&awk->parse.globals, awk) == SSE_NULL)
{
- xp_awk_str_close (&awk->token.name);
- xp_awk_map_close (&awk->tree.afns);
- XP_AWK_FREE (awk, awk);
- return XP_NULL;
+ sse_awk_str_close (&awk->token.name);
+ sse_awk_map_close (&awk->tree.afns);
+ SSE_AWK_FREE (awk, awk);
+ return SSE_NULL;
}
- if (xp_awk_tab_open (&awk->parse.locals, awk) == XP_NULL)
+ if (sse_awk_tab_open (&awk->parse.locals, awk) == SSE_NULL)
{
- xp_awk_str_close (&awk->token.name);
- xp_awk_map_close (&awk->tree.afns);
- xp_awk_tab_close (&awk->parse.globals);
- XP_AWK_FREE (awk, awk);
- return XP_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;
}
- if (xp_awk_tab_open (&awk->parse.params, awk) == XP_NULL)
+ if (sse_awk_tab_open (&awk->parse.params, awk) == SSE_NULL)
{
- xp_awk_str_close (&awk->token.name);
- xp_awk_map_close (&awk->tree.afns);
- xp_awk_tab_close (&awk->parse.globals);
- xp_awk_tab_close (&awk->parse.locals);
- XP_AWK_FREE (awk, awk);
- return XP_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;
}
awk->option = 0;
- awk->errnum = XP_AWK_ENOERR;
+ awk->errnum = SSE_AWK_ENOERR;
awk->parse.nlocals_max = 0;
awk->parse.nl_semicolon = 0;
awk->tree.nglobals = 0;
awk->tree.nbglobals = 0;
- awk->tree.begin = XP_NULL;
- awk->tree.end = XP_NULL;
- awk->tree.chain = XP_NULL;
- awk->tree.chain_tail = XP_NULL;
+ awk->tree.begin = SSE_NULL;
+ awk->tree.end = SSE_NULL;
+ awk->tree.chain = SSE_NULL;
+ awk->tree.chain_tail = SSE_NULL;
awk->tree.chain_size = 0;
awk->token.prev = 0;
@@ -114,48 +114,48 @@ xp_awk_t* xp_awk_open (xp_awk_syscas_t* syscas)
awk->token.line = 0;
awk->token.column = 0;
- awk->src.ios = XP_NULL;
- awk->src.lex.curc = XP_CHAR_EOF;
+ awk->src.ios = SSE_NULL;
+ awk->src.lex.curc = SSE_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 = XP_NULL;
- awk->bfn.user = XP_NULL;
+ awk->bfn.sys = SSE_NULL;
+ awk->bfn.user = SSE_NULL;
awk->run.count = 0;
- awk->run.ptr = XP_NULL;
+ awk->run.ptr = SSE_NULL;
return awk;
}
-int xp_awk_close (xp_awk_t* awk)
+int sse_awk_close (sse_awk_t* awk)
{
- if (xp_awk_clear (awk) == -1) return -1;
+ if (sse_awk_clear (awk) == -1) return -1;
- xp_awk_assert (awk, awk->run.count == 0 && awk->run.ptr == XP_NULL);
+ sse_awk_assert (awk, awk->run.count == 0 && awk->run.ptr == SSE_NULL);
- xp_awk_map_close (&awk->tree.afns);
- xp_awk_tab_close (&awk->parse.globals);
- xp_awk_tab_close (&awk->parse.locals);
- xp_awk_tab_close (&awk->parse.params);
- xp_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_tab_close (&awk->parse.params);
+ sse_awk_str_close (&awk->token.name);
- /* XP_AWK_ALLOC, XP_AWK_FREE, etc can not be used
+ /* SSE_AWK_ALLOC, SSE_AWK_FREE, etc can not be used
* from the next line onwards */
- XP_AWK_FREE (awk, awk);
+ SSE_AWK_FREE (awk, awk);
return 0;
}
-int xp_awk_clear (xp_awk_t* awk)
+int sse_awk_clear (sse_awk_t* awk)
{
/* you should stop all running instances beforehand */
/* TODO: can i stop all instances??? */
- if (awk->run.ptr != XP_NULL)
+ if (awk->run.ptr != SSE_NULL)
{
- awk->errnum = XP_AWK_ERUNNING;
+ awk->errnum = SSE_AWK_ERUNNING;
return -1;
}
@@ -164,17 +164,17 @@ int xp_awk_clear (xp_awk_t* awk)
awk->bfn.user
*/
- awk->src.ios = XP_NULL;
- awk->src.lex.curc = XP_CHAR_EOF;
+ awk->src.ios = SSE_NULL;
+ awk->src.lex.curc = SSE_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;
- xp_awk_tab_clear (&awk->parse.globals);
- xp_awk_tab_clear (&awk->parse.locals);
- xp_awk_tab_clear (&awk->parse.params);
+ sse_awk_tab_clear (&awk->parse.globals);
+ sse_awk_tab_clear (&awk->parse.locals);
+ sse_awk_tab_clear (&awk->parse.params);
awk->parse.nlocals_max = 0;
awk->parse.depth.loop = 0;
@@ -182,60 +182,60 @@ int xp_awk_clear (xp_awk_t* awk)
/* clear parse trees */
awk->tree.nbglobals = 0;
awk->tree.nglobals = 0;
- xp_awk_map_clear (&awk->tree.afns);
+ sse_awk_map_clear (&awk->tree.afns);
- if (awk->tree.begin != XP_NULL)
+ if (awk->tree.begin != SSE_NULL)
{
- xp_awk_assert (awk, awk->tree.begin->next == XP_NULL);
- xp_awk_clrpt (awk, awk->tree.begin);
- awk->tree.begin = XP_NULL;
+ sse_awk_assert (awk, awk->tree.begin->next == SSE_NULL);
+ sse_awk_clrpt (awk, awk->tree.begin);
+ awk->tree.begin = SSE_NULL;
}
- if (awk->tree.end != XP_NULL)
+ if (awk->tree.end != SSE_NULL)
{
- xp_awk_assert (awk, awk->tree.end->next == XP_NULL);
- xp_awk_clrpt (awk, awk->tree.end);
- awk->tree.end = XP_NULL;
+ sse_awk_assert (awk, awk->tree.end->next == SSE_NULL);
+ sse_awk_clrpt (awk, awk->tree.end);
+ awk->tree.end = SSE_NULL;
}
- while (awk->tree.chain != XP_NULL)
+ while (awk->tree.chain != SSE_NULL)
{
- xp_awk_chain_t* next = awk->tree.chain->next;
- if (awk->tree.chain->pattern != XP_NULL)
- xp_awk_clrpt (awk, awk->tree.chain->pattern);
- if (awk->tree.chain->action != XP_NULL)
- xp_awk_clrpt (awk, awk->tree.chain->action);
- XP_AWK_FREE (awk, awk->tree.chain);
+ 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);
awk->tree.chain = next;
}
- awk->tree.chain_tail = XP_NULL;
+ awk->tree.chain_tail = SSE_NULL;
awk->tree.chain_size = 0;
return 0;
}
-int xp_awk_getopt (xp_awk_t* awk)
+int sse_awk_getopt (sse_awk_t* awk)
{
return awk->option;
}
-void xp_awk_setopt (xp_awk_t* awk, int opt)
+void sse_awk_setopt (sse_awk_t* awk, int opt)
{
awk->option = opt;
}
static void __free_afn (void* owner, void* afn)
{
- xp_awk_afn_t* f = (xp_awk_afn_t*)afn;
+ sse_awk_afn_t* f = (sse_awk_afn_t*)afn;
/* f->name doesn't have to be freed */
- /*XP_AWK_FREE ((xp_awk_t*)owner, f->name);*/
+ /*SSE_AWK_FREE ((sse_awk_t*)owner, f->name);*/
- xp_awk_clrpt ((xp_awk_t*)owner, f->body);
- XP_AWK_FREE ((xp_awk_t*)owner, f);
+ sse_awk_clrpt ((sse_awk_t*)owner, f->body);
+ SSE_AWK_FREE ((sse_awk_t*)owner, f);
}
-xp_size_t xp_awk_getsrcline (xp_awk_t* awk)
+sse_size_t sse_awk_getsrcline (sse_awk_t* awk)
{
return awk->token.line;
}
diff --git a/ase/awk/awk.h b/ase/awk/awk.h
index c4622ca0..1b9a9dbc 100644
--- a/ase/awk/awk.h
+++ b/ase/awk/awk.h
@@ -1,34 +1,34 @@
/*
- * $Id: awk.h,v 1.129 2006-10-16 14:38:43 bacon Exp $
+ * $Id: awk.h,v 1.130 2006-10-22 11:34:52 bacon Exp $
*/
-#ifndef _XP_AWK_AWK_H_
-#define _XP_AWK_AWK_H_
+#ifndef _SSE_AWK_AWK_H_
+#define _SSE_AWK_AWK_H_
-#include <xp/types.h>
-#include <xp/macros.h>
+#include <sse/types.h>
+#include <sse/macros.h>
-typedef struct xp_awk_t xp_awk_t;
-typedef struct xp_awk_run_t xp_awk_run_t;
-typedef struct xp_awk_val_t xp_awk_val_t;
-typedef struct xp_awk_extio_t xp_awk_extio_t;
+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 xp_awk_syscas_t xp_awk_syscas_t;
-typedef struct xp_awk_srcios_t xp_awk_srcios_t;
-typedef struct xp_awk_runios_t xp_awk_runios_t;
-typedef struct xp_awk_runcbs_t xp_awk_runcbs_t;
-typedef struct xp_awk_runarg_t xp_awk_runarg_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 void (*xp_awk_lk_t) (xp_awk_t* awk, void* arg);
-typedef xp_ssize_t (*xp_awk_io_t) (
- int cmd, void* arg, xp_char_t* data, xp_size_t count);
+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);
-struct xp_awk_extio_t
+struct sse_awk_extio_t
{
- xp_awk_run_t* run; /* [IN] */
+ sse_awk_run_t* run; /* [IN] */
int type; /* [IN] console, file, coproc, pipe */
int mode; /* [IN] read, write, etc */
- xp_char_t* name; /* [IN] */
+ sse_char_t* name; /* [IN] */
void* custom_data; /* [IN] */
void* handle; /* [OUT] */
@@ -36,150 +36,150 @@ struct xp_awk_extio_t
/* input buffer */
struct
{
- xp_char_t buf[2048];
- xp_size_t pos;
- xp_size_t len;
- xp_bool_t eof;
+ sse_char_t buf[2048];
+ sse_size_t pos;
+ sse_size_t len;
+ sse_bool_t eof;
} in;
- xp_awk_extio_t* next;
+ sse_awk_extio_t* next;
};
-struct xp_awk_syscas_t
+struct sse_awk_syscas_t
{
/* memory */
- void* (*malloc) (xp_size_t n, void* custom_data);
- void* (*realloc) (void* ptr, xp_size_t n, void* custom_data);
+ void* (*malloc) (sse_size_t n, void* custom_data);
+ void* (*realloc) (void* ptr, sse_size_t n, void* custom_data);
void (*free) (void* ptr, void* custom_data);
/* thread lock */
- xp_awk_lk_t lock;
- xp_awk_lk_t unlock;
+ sse_awk_lk_t lock;
+ sse_awk_lk_t unlock;
/* character class */
- xp_bool_t (*is_upper) (xp_cint_t c);
- xp_bool_t (*is_lower) (xp_cint_t c);
- xp_bool_t (*is_alpha) (xp_cint_t c);
- xp_bool_t (*is_digit) (xp_cint_t c);
- xp_bool_t (*is_xdigit) (xp_cint_t c);
- xp_bool_t (*is_alnum) (xp_cint_t c);
- xp_bool_t (*is_space) (xp_cint_t c);
- xp_bool_t (*is_print) (xp_cint_t c);
- xp_bool_t (*is_graph) (xp_cint_t c);
- xp_bool_t (*is_cntrl) (xp_cint_t c);
- xp_bool_t (*is_punct) (xp_cint_t c);
- xp_cint_t (*to_upper) (xp_cint_t c);
- xp_cint_t (*to_lower) (xp_cint_t c);
+ 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);
/* utilities */
- void* (*memcpy) (void* dst, const void* src, xp_size_t n);
- void* (*memset) (void* dst, int val, xp_size_t n);
+ void* (*memcpy) (void* dst, const void* src, sse_size_t n);
+ void* (*memset) (void* dst, int val, sse_size_t n);
- int (*sprintf) (xp_char_t* buf, xp_size_t size, xp_char_t* fmt, ...);
- int (*dprintf) (xp_char_t* fmt, ...);
+ int (*sprintf) (sse_char_t* buf, sse_size_t size, sse_char_t* fmt, ...);
+ int (*dprintf) (sse_char_t* fmt, ...);
void (*abort) (void);
void* custom_data;
};
-struct xp_awk_srcios_t
+struct sse_awk_srcios_t
{
- xp_awk_io_t in;
- xp_awk_io_t out;
+ sse_awk_io_t in;
+ sse_awk_io_t out;
void* custom_data;
};
-struct xp_awk_runios_t
+struct sse_awk_runios_t
{
- xp_awk_io_t pipe;
- xp_awk_io_t coproc;
- xp_awk_io_t file;
- xp_awk_io_t console;
+ sse_awk_io_t pipe;
+ sse_awk_io_t coproc;
+ sse_awk_io_t file;
+ sse_awk_io_t console;
void* custom_data;
};
-struct xp_awk_runcbs_t
+struct sse_awk_runcbs_t
{
- void (*on_start) (xp_awk_t* awk, void* handle, void* arg);
- void (*on_end) (xp_awk_t* awk, void* handle, int errnum, void* arg);
+ 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* custom_data;
};
-struct xp_awk_runarg_t
+struct sse_awk_runarg_t
{
- const xp_char_t* ptr;
- xp_size_t len;
+ const sse_char_t* ptr;
+ sse_size_t len;
};
/* io function commands */
enum
{
- XP_AWK_IO_OPEN = 0,
- XP_AWK_IO_CLOSE = 1,
- XP_AWK_IO_READ = 2,
- XP_AWK_IO_WRITE = 3,
- XP_AWK_IO_FLUSH = 4,
- XP_AWK_IO_NEXT = 5
+ 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
};
enum
{
- XP_AWK_IO_PIPE_READ = 0,
- XP_AWK_IO_PIPE_WRITE = 1,
+ SSE_AWK_IO_PIPE_READ = 0,
+ SSE_AWK_IO_PIPE_WRITE = 1,
- XP_AWK_IO_FILE_READ = 0,
- XP_AWK_IO_FILE_WRITE = 1,
- XP_AWK_IO_FILE_APPEND = 2,
+ SSE_AWK_IO_FILE_READ = 0,
+ SSE_AWK_IO_FILE_WRITE = 1,
+ SSE_AWK_IO_FILE_APPEND = 2,
- XP_AWK_IO_CONSOLE_READ = 0,
- XP_AWK_IO_CONSOLE_WRITE = 1
+ SSE_AWK_IO_CONSOLE_READ = 0,
+ SSE_AWK_IO_CONSOLE_WRITE = 1
};
/* various options */
-enum xp_awk_option_t
+enum sse_awk_option_t
{
/* allow undeclared variables */
- XP_AWK_IMPLICIT = (1 << 0),
+ SSE_AWK_IMPLICIT = (1 << 0),
- /* variable requires explicit declaration */
- XP_AWK_EXPLICIT = (1 << 1),
+ /* variable requires esselicit declaration */
+ SSE_AWK_ESSELICIT = (1 << 1),
/* a function name should not coincide to be a variable name */
- XP_AWK_UNIQUE = (1 << 2),
+ SSE_AWK_UNIQUE = (1 << 2),
/* allow variable shading */
- XP_AWK_SHADING = (1 << 3),
+ SSE_AWK_SHADING = (1 << 3),
/* support shift operators */
- XP_AWK_SHIFT = (1 << 4),
+ SSE_AWK_SHIFT = (1 << 4),
/* support comments by a hash sign */
- XP_AWK_HASHSIGN = (1 << 5),
+ SSE_AWK_HASHSIGN = (1 << 5),
/* support comments by double slashes */
- XP_AWK_DBLSLASHES = (1 << 6),
+ SSE_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
+ * when this option is on. If this option is off, the same esseression
* is treated as if it is (getline < "abc") ".def". */
- XP_AWK_STRCONCAT = (1 << 7),
+ SSE_AWK_STRCONCAT = (1 << 7),
/* support getline and print */
- XP_AWK_EXTIO = (1 << 8),
+ SSE_AWK_EXTIO = (1 << 8),
/* support blockless patterns */
- XP_AWK_BLOCKLESS = (1 << 9),
+ SSE_AWK_BLOCKLESS = (1 << 9),
/* execution starts from main */
- XP_AWK_RUNMAIN = (1 << 10),
+ SSE_AWK_RUNMAIN = (1 << 10),
/* use 1 as the start index for string operations */
- XP_AWK_STRINDEXONE = (1 << 11),
+ SSE_AWK_STRINDEXONE = (1 << 11),
/* strip off leading and trailing spaces when splitting a record
- * into fields with a regular expression.
+ * into fields with a regular esseression.
*
* Consider the following program.
* BEGIN { FS="[:[:space:]]+"; }
@@ -191,228 +191,228 @@ enum xp_awk_option_t
* The program splits " a b c " into [a], [b], [c] when this
* option is on while into [], [a], [b], [c], [] when it is off.
*/
- XP_AWK_STRIPSPACES = (1 << 12),
+ SSE_AWK_STRIPSPACES = (1 << 12),
/* a newline terminates a statement */
- XP_AWK_NEWLINE = (1 << 13)
+ SSE_AWK_NEWLINE = (1 << 13)
};
/* error code */
enum ant_awk_errnum_t
{
- XP_AWK_ENOERR, /* no error */
- XP_AWK_ENOMEM, /* out of memory */
- XP_AWK_EINVAL, /* invalid parameter */
- XP_AWK_ERUNTIME, /* run-time error */
- XP_AWK_ERUNNING, /* there are running instances */
- XP_AWK_ETOOMANYRUNS, /* too many running instances */
- XP_AWK_ERECURSION, /* recursion too deep */
+ 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 */
- XP_AWK_ESRCINOPEN,
- XP_AWK_ESRCINCLOSE,
- XP_AWK_ESRCINREAD,
+ SSE_AWK_ESRCINOPEN,
+ SSE_AWK_ESRCINCLOSE,
+ SSE_AWK_ESRCINREAD,
- XP_AWK_ESRCOUTOPEN,
- XP_AWK_ESRCOUTCLOSE,
- XP_AWK_ESRCOUTWRITE,
+ SSE_AWK_ESRCOUTOPEN,
+ SSE_AWK_ESRCOUTCLOSE,
+ SSE_AWK_ESRCOUTWRITE,
- XP_AWK_ECONINOPEN,
- XP_AWK_ECONINCLOSE,
- XP_AWK_ECONINNEXT,
- XP_AWK_ECONINDATA,
+ SSE_AWK_ECONINOPEN,
+ SSE_AWK_ECONINCLOSE,
+ SSE_AWK_ECONINNEXT,
+ SSE_AWK_ECONINDATA,
- XP_AWK_ECONOUTOPEN,
- XP_AWK_ECONOUTCLOSE,
- XP_AWK_ECONOUTNEXT,
- XP_AWK_ECONOUTDATA,
+ SSE_AWK_ECONOUTOPEN,
+ SSE_AWK_ECONOUTCLOSE,
+ SSE_AWK_ECONOUTNEXT,
+ SSE_AWK_ECONOUTDATA,
- XP_AWK_ELXCHR, /* lexer came accross an wrong character */
- XP_AWK_ELXUNG, /* lexer failed to unget a character */
+ SSE_AWK_ELXCHR, /* lexer came accross an wrong character */
+ SSE_AWK_ELXUNG, /* lexer failed to unget a character */
- XP_AWK_EENDSRC, /* unexpected end of source */
- XP_AWK_EENDCOMMENT, /* unexpected end of a comment */
- XP_AWK_EENDSTR, /* unexpected end of a string */
- XP_AWK_EENDREX, /* unexpected end of a regular expression */
- XP_AWK_ELBRACE, /* left brace expected */
- XP_AWK_ELPAREN, /* left parenthesis expected */
- XP_AWK_ERPAREN, /* right parenthesis expected */
- XP_AWK_ERBRACK, /* right bracket expected */
- XP_AWK_ECOMMA, /* comma expected */
- XP_AWK_ESEMICOLON, /* semicolon expected */
- XP_AWK_ECOLON, /* colon expected */
- XP_AWK_EIN, /* keyword 'in' is expected */
- XP_AWK_ENOTVAR, /* not a variable name after 'in' */
- XP_AWK_EEXPRESSION, /* expression expected */
+ SSE_AWK_EENDSRC, /* unesseected end of source */
+ SSE_AWK_EENDCOMMENT, /* unesseected end of a comment */
+ SSE_AWK_EENDSTR, /* unesseected end of a string */
+ SSE_AWK_EENDREX, /* unesseected end of a regular esseression */
+ SSE_AWK_ELBRACE, /* left brace esseected */
+ SSE_AWK_ELPAREN, /* left parenthesis esseected */
+ SSE_AWK_ERPAREN, /* right parenthesis esseected */
+ SSE_AWK_ERBRACK, /* right bracket esseected */
+ SSE_AWK_ECOMMA, /* comma esseected */
+ SSE_AWK_ESEMICOLON, /* semicolon esseected */
+ SSE_AWK_ECOLON, /* colon esseected */
+ SSE_AWK_EIN, /* keyword 'in' is esseected */
+ SSE_AWK_ENOTVAR, /* not a variable name after 'in' */
+ SSE_AWK_EESSERESSION, /* esseression esseected */
- XP_AWK_EWHILE, /* keyword 'while' is expected */
- XP_AWK_EASSIGNMENT, /* assignment statement expected */
- XP_AWK_EIDENT, /* identifier expected */
- XP_AWK_EBEGINBLOCK, /* BEGIN requires an action block */
- XP_AWK_EENDBLOCK, /* END requires an action block */
- XP_AWK_EDUPBEGIN, /* duplicate BEGIN */
- XP_AWK_EDUPEND, /* duplicate END */
- XP_AWK_EDUPFUNC, /* duplicate function name */
- XP_AWK_EDUPPARAM, /* duplicate parameter name */
- XP_AWK_EDUPVAR, /* duplicate variable name */
- XP_AWK_EDUPNAME, /* duplicate name - function, variable, etc */
- XP_AWK_EUNDEF, /* undefined identifier */
- XP_AWK_ELVALUE, /* l-value required */
- XP_AWK_ETOOFEWARGS, /* too few arguments */
- XP_AWK_ETOOMANYARGS, /* too many arguments */
- XP_AWK_ETOOMANYGLOBALS, /* too many global variables */
- XP_AWK_ETOOMANYLOCALS, /* too many local variables */
- XP_AWK_ETOOMANYPARAMS, /* too many parameters */
- XP_AWK_EBREAK, /* break outside a loop */
- XP_AWK_ECONTINUE, /* continue outside a loop */
- XP_AWK_ENEXT, /* next illegal in BEGIN or END block */
- XP_AWK_ENEXTFILE, /* nextfile illegal in BEGIN or END block */
- XP_AWK_EGETLINE, /* getline expected */
+ SSE_AWK_EWHILE, /* keyword 'while' is esseected */
+ SSE_AWK_EASSIGNMENT, /* assignment statement esseected */
+ SSE_AWK_EIDENT, /* identifier esseected */
+ 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 esseected */
/* run time error */
- XP_AWK_EDIVBYZERO, /* divide by zero */
- XP_AWK_EOPERAND, /* invalid operand */
- XP_AWK_EPOSIDX, /* wrong position index */
- XP_AWK_ENOSUCHFUNC, /* no such function */
- XP_AWK_ENOTASSIGNABLE, /* value not assignable */
- XP_AWK_ENOTINDEXABLE, /* not indexable variable */
- XP_AWK_ENOTDELETABLE, /* not deletable variable */
- XP_AWK_ENOTREFERENCEABLE, /* not referenceable value */
- XP_AWK_EIDXVALASSMAP, /* indexed value cannot be assigned a map */
- XP_AWK_EPOSVALASSMAP, /* a positional cannot be assigned a map */
- XP_AWK_EMAPTOSCALAR, /* cannot change a map to a scalar value */
- XP_AWK_ESCALARTOMAP, /* cannot change a scalar value to a map */
- XP_AWK_EMAPNOTALLOWED, /* a map is not allowed */
- XP_AWK_EVALTYPE, /* wrong value type */
- XP_AWK_EPIPE, /* pipe operation error */
- XP_AWK_ENEXTCALL, /* next called from BEGIN or END */
- XP_AWK_ENEXTFILECALL, /* nextfile called from BEGIN or END */
- XP_AWK_EIOIMPL, /* wrong implementation of user io handler */
- XP_AWK_ENOSUCHIO, /* no such io name found */
- XP_AWK_EIOHANDLER, /* io handler has returned an error */
- XP_AWK_EINTERNAL, /* internal 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 */
- /* regular expression error */
- XP_AWK_EREXRPAREN, /* a right parenthesis is expected */
- XP_AWK_EREXRBRACKET, /* a right bracket is expected */
- XP_AWK_EREXRBRACE, /* a right brace is expected */
- XP_AWK_EREXCOLON, /* a colon is expected */
- XP_AWK_EREXCRANGE, /* invalid character range */
- XP_AWK_EREXCCLASS, /* invalid character class */
- XP_AWK_EREXBRANGE, /* invalid boundary range */
- XP_AWK_EREXEND, /* unexpected end of the pattern */
- XP_AWK_EREXGARBAGE /* garbage after the pattern */
+ /* regular esseression error */
+ SSE_AWK_EREXRPAREN, /* a right parenthesis is esseected */
+ SSE_AWK_EREXRBRACKET, /* a right bracket is esseected */
+ SSE_AWK_EREXRBRACE, /* a right brace is esseected */
+ SSE_AWK_EREXCOLON, /* a colon is esseected */
+ SSE_AWK_EREXCRANGE, /* invalid character range */
+ SSE_AWK_EREXCCLASS, /* invalid character class */
+ SSE_AWK_EREXBRANGE, /* invalid boundary range */
+ SSE_AWK_EREXEND, /* unesseected end of the pattern */
+ SSE_AWK_EREXGARBAGE /* garbage after the pattern */
};
/* extio types */
enum
{
/* extio types available */
- XP_AWK_EXTIO_PIPE,
- XP_AWK_EXTIO_COPROC,
- XP_AWK_EXTIO_FILE,
- XP_AWK_EXTIO_CONSOLE,
+ SSE_AWK_EXTIO_PIPE,
+ SSE_AWK_EXTIO_COPROC,
+ SSE_AWK_EXTIO_FILE,
+ SSE_AWK_EXTIO_CONSOLE,
/* reserved for internal use only */
- XP_AWK_EXTIO_NUM
+ SSE_AWK_EXTIO_NUM
};
#ifdef __cplusplus
extern "C" {
#endif
-xp_awk_t* xp_awk_open (xp_awk_syscas_t* syscas);
-int xp_awk_close (xp_awk_t* awk);
-int xp_awk_clear (xp_awk_t* awk);
+sse_awk_t* sse_awk_open (sse_awk_syscas_t* syscas);
+int sse_awk_close (sse_awk_t* awk);
+int sse_awk_clear (sse_awk_t* awk);
-int xp_awk_geterrnum (xp_awk_t* awk);
-xp_size_t xp_awk_getsrcline (xp_awk_t* awk);
+int sse_awk_geterrnum (sse_awk_t* awk);
+sse_size_t sse_awk_getsrcline (sse_awk_t* awk);
-int xp_awk_getopt (xp_awk_t* awk);
-void xp_awk_setopt (xp_awk_t* awk, int opt);
+int sse_awk_getopt (sse_awk_t* awk);
+void sse_awk_setopt (sse_awk_t* awk, int opt);
-int xp_awk_parse (xp_awk_t* awk, xp_awk_srcios_t* srcios);
+int sse_awk_parse (sse_awk_t* awk, sse_awk_srcios_t* srcios);
/*
- * xp_awk_run return 0 on success and -1 on failure, generally speaking.
+ * sse_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 XP_NULL), xp_awk_run
+ * When no callback is specified (i.e. runcbs is SSE_NULL), sse_awk_run
* returns -1 on an error and awk->errnum is set accordingly.
- * However, if a callback is specified (i.e. runcbs is not XP_NULL),
- * xp_awk_run returns 0 on both success and failure. Instead, the
+ * 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
* on_end handler of the callback is triggered with the relevant
* error number. The third parameter to on_end denotes this error number.
*/
-int xp_awk_run (xp_awk_t* awk,
- xp_awk_runios_t* runios,
- xp_awk_runcbs_t* runcbs,
- xp_awk_runarg_t* runarg);
+int sse_awk_run (sse_awk_t* awk,
+ sse_awk_runios_t* runios,
+ sse_awk_runcbs_t* runcbs,
+ sse_awk_runarg_t* runarg);
-int xp_awk_stop (xp_awk_t* awk, xp_awk_run_t* run);
-void xp_awk_stopall (xp_awk_t* awk);
+int sse_awk_stop (sse_awk_t* awk, sse_awk_run_t* run);
+void sse_awk_stopall (sse_awk_t* awk);
/* functions to access internal stack structure */
-xp_size_t xp_awk_getnargs (xp_awk_run_t* run);
-xp_awk_val_t* xp_awk_getarg (xp_awk_run_t* run, xp_size_t idx);
-xp_awk_val_t* xp_awk_getglobal (xp_awk_run_t* run, xp_size_t idx);
-int xp_awk_setglobal (xp_awk_run_t* run, xp_size_t idx, xp_awk_val_t* val);
-void xp_awk_setretval (xp_awk_run_t* run, xp_awk_val_t* val);
+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);
-int xp_awk_setconsolename (
- xp_awk_run_t* run, const xp_char_t* name, xp_size_t len);
+int sse_awk_setconsolename (
+ sse_awk_run_t* run, const sse_char_t* name, sse_size_t len);
-int xp_awk_getrunerrnum (xp_awk_run_t* run);
-void xp_awk_setrunerrnum (xp_awk_run_t* run, int errnum);
+int sse_awk_getrunerrnum (sse_awk_run_t* run);
+void sse_awk_setrunerrnum (sse_awk_run_t* run, int errnum);
/* record and field functions */
-int xp_awk_clrrec (xp_awk_run_t* run, xp_bool_t skip_inrec_line);
-int xp_awk_setrec (xp_awk_run_t* run, xp_size_t idx, const xp_char_t* str, xp_size_t len);
+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);
-/* utility functions exported by awk.h */
-xp_long_t xp_awk_strxtolong (
- xp_awk_t* awk, const xp_char_t* str, xp_size_t len,
- int base, const xp_char_t** endptr);
-xp_real_t xp_awk_strxtoreal (
- xp_awk_t* awk, const xp_char_t* str, xp_size_t len,
- const xp_char_t** endptr);
+/* utility functions esseorted 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);
-xp_size_t xp_awk_longtostr (
- xp_long_t value, int radix, const xp_char_t* prefix,
- xp_char_t* buf, xp_size_t size);
+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);
-/* string functions exported by awk.h */
-xp_char_t* xp_awk_strdup (
- xp_awk_t* awk, const xp_char_t* str);
-xp_char_t* xp_awk_strxdup (
- xp_awk_t* awk, const xp_char_t* str, xp_size_t len);
-xp_char_t* xp_awk_strxdup2 (
- xp_awk_t* awk,
- const xp_char_t* str1, xp_size_t len1,
- const xp_char_t* str2, xp_size_t len2);
+/* string functions esseorted 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);
-xp_size_t xp_awk_strlen (const xp_char_t* str);
-xp_size_t xp_awk_strcpy (xp_char_t* buf, const xp_char_t* str);
-xp_size_t xp_awk_strncpy (xp_char_t* buf, const xp_char_t* str, xp_size_t len);
-int xp_awk_strcmp (const xp_char_t* s1, const xp_char_t* s2);
+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);
-int xp_awk_strxncmp (
- const xp_char_t* s1, xp_size_t len1,
- const xp_char_t* s2, xp_size_t len2);
+int sse_awk_strxncmp (
+ const sse_char_t* s1, sse_size_t len1,
+ const sse_char_t* s2, sse_size_t len2);
-int xp_awk_strxncasecmp (
- xp_awk_t* awk,
- const xp_char_t* s1, xp_size_t len1,
- const xp_char_t* s2, xp_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);
-xp_char_t* xp_awk_strxnstr (
- const xp_char_t* str, xp_size_t strsz,
- const xp_char_t* sub, xp_size_t subsz);
+sse_char_t* sse_awk_strxnstr (
+ const sse_char_t* str, sse_size_t strsz,
+ const sse_char_t* sub, sse_size_t subsz);
/* utility functions to convert an error number ot a string */
-const xp_char_t* xp_awk_geterrstr (int errnum);
+const sse_char_t* sse_awk_geterrstr (int errnum);
#ifdef __cplusplus
}
diff --git a/ase/awk/awk_i.h b/ase/awk/awk_i.h
index b0ef472f..f22aa5e2 100644
--- a/ase/awk/awk_i.h
+++ b/ase/awk/awk_i.h
@@ -1,107 +1,107 @@
/*
- * $Id: awk_i.h,v 1.68 2006-10-17 09:36:08 bacon Exp $
+ * $Id: awk_i.h,v 1.69 2006-10-22 11:34:52 bacon Exp $
*/
-#ifndef _XP_AWK_AWKI_H_
-#define _XP_AWK_AWKI_H_
+#ifndef _SSE_AWK_AWKI_H_
+#define _SSE_AWK_AWKI_H_
-typedef struct xp_awk_chain_t xp_awk_chain_t;
-typedef struct xp_awk_tree_t xp_awk_tree_t;
+typedef struct sse_awk_chain_t sse_awk_chain_t;
+typedef struct sse_awk_tree_t sse_awk_tree_t;
-#include <xp/awk/awk.h>
-#include <xp/awk/str.h>
-#include <xp/awk/rex.h>
-#include <xp/awk/map.h>
-#include <xp/awk/tree.h>
-#include <xp/awk/val.h>
-#include <xp/awk/func.h>
-#include <xp/awk/tab.h>
-#include <xp/awk/parse.h>
-#include <xp/awk/run.h>
-#include <xp/awk/extio.h>
-#include <xp/awk/misc.h>
+#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>
#ifdef NDEBUG
- #define xp_awk_assert(awk,expr) ((void)0)
+ #define sse_awk_assert(awk,esser) ((void)0)
#else
- #define xp_awk_assert(awk,expr) (void)((expr) || \
- (xp_awk_abort(awk, XP_TEXT(#expr), XP_TEXT(__FILE__), __LINE__), 0))
+ #define sse_awk_assert(awk,esser) (void)((esser) || \
+ (sse_awk_abort(awk, SSE_TEXT(#esser), SSE_TEXT(__FILE__), __LINE__), 0))
#endif
#ifdef _MSC_VER
#pragma warning (disable: 4996)
#endif
-#define XP_AWK_MAX_GLOBALS 9999
-#define XP_AWK_MAX_LOCALS 9999
-#define XP_AWK_MAX_PARAMS 9999
+#define SSE_AWK_MAX_GLOBALS 9999
+#define SSE_AWK_MAX_LOCALS 9999
+#define SSE_AWK_MAX_PARAMS 9999
#if defined(_WIN32) && defined(_DEBUG)
#define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>
- #define XP_AWK_MALLOC(awk,size) malloc (size)
- #define XP_AWK_REALLOC(awk,ptr,size) realloc (ptr, size)
- #define XP_AWK_FREE(awk,ptr) free (ptr)
+ #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)
#else
- #define XP_AWK_MALLOC(awk,size) \
+ #define SSE_AWK_MALLOC(awk,size) \
(awk)->syscas.malloc (size, (awk)->syscas.custom_data)
- #define XP_AWK_REALLOC(awk,ptr,size) \
+ #define SSE_AWK_REALLOC(awk,ptr,size) \
(awk)->syscas.realloc (ptr, size, (awk)->syscas.custom_data)
- #define XP_AWK_FREE(awk,ptr) \
+ #define SSE_AWK_FREE(awk,ptr) \
(awk)->syscas.free (ptr, (awk)->syscas.custom_data)
#endif
-#define XP_AWK_LOCK(awk) \
+#define SSE_AWK_LOCK(awk) \
do { \
- if ((awk)->syscas.lock != XP_NULL) \
+ if ((awk)->syscas.lock != SSE_NULL) \
(awk)->syscas.lock (awk, (awk)->syscas.custom_data); \
} while (0)
-#define XP_AWK_UNLOCK(awk) \
+#define SSE_AWK_UNLOCK(awk) \
do { \
- if ((awk)->syscas.unlock != XP_NULL) \
+ if ((awk)->syscas.unlock != SSE_NULL) \
(awk)->syscas.unlock (awk, (awk)->syscas.custom_data); \
} while (0)
-#define XP_AWK_ISUPPER(awk,c) (awk)->syscas.is_upper(c)
-#define XP_AWK_ISLOWER(awk,c) (awk)->syscas.is_lower(c)
-#define XP_AWK_ISALPHA(awk,c) (awk)->syscas.is_alpha(c)
-#define XP_AWK_ISDIGIT(awk,c) (awk)->syscas.is_digit(c)
-#define XP_AWK_ISXDIGIT(awk,c) (awk)->syscas.is_xdigit(c)
-#define XP_AWK_ISALNUM(awk,c) (awk)->syscas.is_alnum(c)
-#define XP_AWK_ISSPACE(awk,c) (awk)->syscas.is_space(c)
-#define XP_AWK_ISPRINT(awk,c) (awk)->syscas.is_print(c)
-#define XP_AWK_ISGRAPH(awk,c) (awk)->syscas.is_graph(c)
-#define XP_AWK_ISCNTRL(awk,c) (awk)->syscas.is_cntrl(c)
-#define XP_AWK_ISPUNCT(awk,c) (awk)->syscas.is_punct(c)
-#define XP_AWK_TOUPPER(awk,c) (awk)->syscas.to_upper(c)
-#define XP_AWK_TOLOWER(awk,c) (awk)->syscas.to_lower(c)
+#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 XP_AWK_MEMCPY(awk,dst,src,len) (awk)->syscas.memcpy (dst, src, len)
-#define XP_AWK_MEMSET(awk,dst,val,len) (awk)->syscas.memset (dst, val, len)
+#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)
-struct xp_awk_tree_t
+struct sse_awk_tree_t
{
- xp_size_t nglobals; /* total number of globals */
- xp_size_t nbglobals; /* number of builtin globals */
- xp_awk_map_t afns; /* awk function map */
- xp_awk_nde_t* begin;
- xp_awk_nde_t* end;
- xp_awk_chain_t* chain;
- xp_awk_chain_t* chain_tail;
- xp_size_t chain_size; /* number of nodes in the chain */
+ 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 */
};
-struct xp_awk_t
+struct sse_awk_t
{
- xp_awk_syscas_t syscas;
+ sse_awk_syscas_t syscas;
/* options */
int option;
/* parse tree */
- xp_awk_tree_t tree;
+ sse_awk_tree_t tree;
int state;
/* temporary information that the parser needs */
@@ -115,13 +115,13 @@ struct xp_awk_t
struct
{
- xp_size_t loop;
+ sse_size_t loop;
} depth;
- xp_awk_tab_t globals;
- xp_awk_tab_t locals;
- xp_awk_tab_t params;
- xp_size_t nlocals_max;
+ sse_awk_tab_t globals;
+ sse_awk_tab_t locals;
+ sse_awk_tab_t params;
+ sse_size_t nlocals_max;
int nl_semicolon;
} parse;
@@ -129,23 +129,23 @@ struct xp_awk_t
/* source code management */
struct
{
- xp_awk_srcios_t* ios;
+ sse_awk_srcios_t* ios;
struct
{
- xp_cint_t curc;
- xp_cint_t ungotc[5];
- xp_size_t ungotc_count;
+ sse_cint_t curc;
+ sse_cint_t ungotc[5];
+ sse_size_t ungotc_count;
- xp_size_t line;
- xp_size_t column;
+ sse_size_t line;
+ sse_size_t column;
} lex;
struct
{
- xp_char_t buf[512];
- xp_size_t buf_pos;
- xp_size_t buf_len;
+ sse_char_t buf[512];
+ sse_size_t buf_pos;
+ sse_size_t buf_len;
} shared;
} src;
@@ -154,73 +154,73 @@ struct xp_awk_t
{
int prev;
int type;
- xp_awk_str_t name;
- xp_size_t line;
- xp_size_t column;
+ sse_awk_str_t name;
+ sse_size_t line;
+ sse_size_t column;
} token;
/* builtin functions */
struct
{
- xp_awk_bfn_t* sys;
- xp_awk_bfn_t* user;
+ sse_awk_bfn_t* sys;
+ sse_awk_bfn_t* user;
} bfn;
struct
{
- xp_size_t count;
- xp_awk_run_t* ptr;
+ sse_size_t count;
+ sse_awk_run_t* ptr;
} run;
/* housekeeping */
int errnum;
};
-struct xp_awk_chain_t
+struct sse_awk_chain_t
{
- xp_awk_nde_t* pattern;
- xp_awk_nde_t* action;
- xp_awk_chain_t* next;
+ sse_awk_nde_t* pattern;
+ sse_awk_nde_t* action;
+ sse_awk_chain_t* next;
};
-struct xp_awk_run_t
+struct sse_awk_run_t
{
int id;
- xp_awk_map_t named;
+ sse_awk_map_t named;
void** stack;
- xp_size_t stack_top;
- xp_size_t stack_base;
- xp_size_t stack_limit;
+ sse_size_t stack_top;
+ sse_size_t stack_base;
+ sse_size_t stack_limit;
int exit_level;
- xp_awk_val_int_t* icache[100]; /* TODO: choose the optimal size */
- xp_awk_val_real_t* rcache[100]; /* TODO: choose the optimal size */
- xp_awk_val_ref_t* fcache[100]; /* TODO: choose the optimal size */
- xp_size_t icache_count;
- xp_size_t rcache_count;
- xp_size_t fcache_count;
+ 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;
- xp_awk_nde_blk_t* active_block;
- xp_byte_t* pattern_range_state;
+ sse_awk_nde_blk_t* active_block;
+ sse_byte_t* pattern_range_state;
struct
{
- xp_char_t buf[1024];
- xp_size_t buf_pos;
- xp_size_t buf_len;
- xp_bool_t eof;
+ sse_char_t buf[1024];
+ sse_size_t buf_pos;
+ sse_size_t buf_len;
+ sse_bool_t eof;
- xp_awk_str_t line;
- xp_awk_val_t* d0; /* $0 */
+ sse_awk_str_t line;
+ sse_awk_val_t* d0; /* $0 */
- xp_size_t maxflds;
- xp_size_t nflds; /* NF */
+ sse_size_t maxflds;
+ sse_size_t nflds; /* NF */
struct
{
- xp_char_t* ptr;
- xp_size_t len;
- xp_awk_val_t* val; /* $1 .. $NF */
+ sse_char_t* ptr;
+ sse_size_t len;
+ sse_awk_val_t* val; /* $1 .. $NF */
}* flds;
} inrec;
@@ -230,48 +230,48 @@ struct xp_awk_run_t
void* rs;
void* fs;
int ignorecase;
- xp_size_t fnr;
+ sse_size_t fnr;
struct
{
- xp_char_t* ptr;
- xp_size_t len;
+ sse_char_t* ptr;
+ sse_size_t len;
} convfmt;
struct
{
- xp_char_t* ptr;
- xp_size_t len;
+ sse_char_t* ptr;
+ sse_size_t len;
} ofmt;
struct
{
- xp_char_t* ptr;
- xp_size_t len;
+ sse_char_t* ptr;
+ sse_size_t len;
} ofs;
struct
{
- xp_char_t* ptr;
- xp_size_t len;
+ sse_char_t* ptr;
+ sse_size_t len;
} ors;
struct
{
- xp_char_t* ptr;
- xp_size_t len;
+ sse_char_t* ptr;
+ sse_size_t len;
} subsep;
} global;
/* extio chain */
struct
{
- xp_awk_io_t handler[XP_AWK_EXTIO_NUM];
+ sse_awk_io_t handler[SSE_AWK_EXTIO_NUM];
void* custom_data;
- xp_awk_extio_t* chain;
+ sse_awk_extio_t* chain;
} extio;
int errnum;
- xp_awk_t* awk;
- xp_awk_run_t* prev;
- xp_awk_run_t* next;
+ sse_awk_t* awk;
+ sse_awk_run_t* prev;
+ sse_awk_run_t* next;
};
#endif
diff --git a/ase/awk/err.c b/ase/awk/err.c
index 689ba5ab..3fbc1544 100644
--- a/ase/awk/err.c
+++ b/ase/awk/err.c
@@ -1,124 +1,124 @@
/*
- * $Id: err.c,v 1.42 2006-10-10 07:02:38 bacon Exp $
+ * $Id: err.c,v 1.43 2006-10-22 11:34:53 bacon Exp $
*/
-#include <xp/awk/awk_i.h>
+#include <sse/awk/awk_i.h>
-int xp_awk_geterrnum (xp_awk_t* awk)
+int sse_awk_geterrnum (sse_awk_t* awk)
{
return awk->errnum;
}
-const xp_char_t* xp_awk_geterrstr (int errnum)
+const sse_char_t* sse_awk_geterrstr (int errnum)
{
- static const xp_char_t* __errstr[] =
+ static const sse_char_t* __errstr[] =
{
- XP_T("no error"),
- XP_T("out of memory"),
- XP_T("invalid parameter"),
- XP_T("general run-time error"),
- XP_T("one or more running instances"),
- XP_T("too many running instances"),
- XP_T("recursion too deep"),
+ 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"),
- XP_T("cannot open source input"),
- XP_T("cannot close source input"),
- XP_T("cannot read source input"),
+ SSE_T("cannot open source input"),
+ SSE_T("cannot close source input"),
+ SSE_T("cannot read source input"),
- XP_T("cannot open source output"),
- XP_T("cannot close source output"),
- XP_T("cannot write source output"),
+ SSE_T("cannot open source output"),
+ SSE_T("cannot close source output"),
+ SSE_T("cannot write source output"),
- XP_T("cannot open console for read"),
- XP_T("cannot close console for read"),
- XP_T("cannot switch to next console for read"),
- XP_T("cannot read from console"),
+ 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"),
- XP_T("cannot open console for write"),
- XP_T("cannot close console for write"),
- XP_T("cannot switch to next console for write"),
- XP_T("cannot write to 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"),
- XP_T("invalid character"),
- XP_T("cannot unget character"),
+ SSE_T("invalid character"),
+ SSE_T("cannot unget character"),
- XP_T("unexpected end of source"),
- XP_T("unexpected end of a comment"),
- XP_T("unexpected end of a string"),
- XP_T("unexpected end of a regular expression"),
- XP_T("left brace expected"),
- XP_T("left parenthesis expected"),
- XP_T("right parenthesis expected"),
- XP_T("right bracket expected"),
- XP_T("comma expected"),
- XP_T("semicolon expected"),
- XP_T("colon expected"),
- XP_T("keyword 'in' expected"),
- XP_T("not a variable after 'in'"),
- XP_T("expression expected"),
+ SSE_T("unesseected end of source"),
+ SSE_T("unesseected end of a comment"),
+ SSE_T("unesseected end of a string"),
+ SSE_T("unesseected end of a regular esseression"),
+ SSE_T("left brace esseected"),
+ SSE_T("left parenthesis esseected"),
+ SSE_T("right parenthesis esseected"),
+ SSE_T("right bracket esseected"),
+ SSE_T("comma esseected"),
+ SSE_T("semicolon esseected"),
+ SSE_T("colon esseected"),
+ SSE_T("keyword 'in' esseected"),
+ SSE_T("not a variable after 'in'"),
+ SSE_T("esseression esseected"),
- XP_T("keyword 'while' expected"),
- XP_T("assignment statement expected"),
- XP_T("identifier expected"),
- XP_T("BEGIN requires an action block"),
- XP_T("END requires an action block"),
- XP_T("duplicate BEGIN"),
- XP_T("duplicate END"),
- XP_T("duplicate function name"),
- XP_T("duplicate parameter name"),
- XP_T("duplicate variable name"),
- XP_T("duplicate name"),
- XP_T("undefined identifier"),
- XP_T("l-value required"),
- XP_T("too few arguments"),
- XP_T("too many arguments"),
- XP_T("too many global variables"),
- XP_T("too many local variables"),
- XP_T("too many parameters"),
- XP_T("break outside a loop"),
- XP_T("continue outside a loop"),
- XP_T("next illegal in BEGIN or END block"),
- XP_T("nextfile illegal in BEGIN or END block"),
- XP_T("getline expected"),
+ SSE_T("keyword 'while' esseected"),
+ SSE_T("assignment statement esseected"),
+ SSE_T("identifier esseected"),
+ 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 esseected"),
- XP_T("divide by zero"),
- XP_T("invalid operand"),
- XP_T("wrong position index"),
- XP_T("no such function"),
- XP_T("value not assignable"),
- XP_T("variable not indexable"),
- XP_T("variable not deletable"),
- XP_T("value not referenceable"),
- XP_T("an indexed value cannot be assigned a map"),
- XP_T("a positional value cannot be assigned a map"),
- XP_T("cannot change a map to a scalar value"),
- XP_T("cannot change a scalar value to a map"),
- XP_T("a map is not allowed"),
- XP_T("wrong value type"),
- XP_T("pipe operation error"),
- XP_T("next cannot be called from the BEGIN or END block"),
- XP_T("nextfile cannot be called from the BEGIN or END block"),
- XP_T("wrong implementation of user-defined io handler"),
- XP_T("no such io name found"),
- XP_T("io handler has returned an error"),
- XP_T("internal error that should never have happened"),
+ 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"),
- XP_T("a right parenthesis is expected in the regular expression"),
- XP_T("a right bracket is expected in the regular expression"),
- XP_T("a right brace is expected in the regular expression"),
- XP_T("a colon is expected in the regular expression"),
- XP_T("invalid character range in the regular expression"),
- XP_T("invalid character class in the regular expression"),
- XP_T("invalid boundary range in the regular expression"),
- XP_T("unexpected end of the regular expression"),
- XP_T("garbage after the regular expression")
+ SSE_T("a right parenthesis is esseected in the regular esseression"),
+ SSE_T("a right bracket is esseected in the regular esseression"),
+ SSE_T("a right brace is esseected in the regular esseression"),
+ SSE_T("a colon is esseected in the regular esseression"),
+ SSE_T("invalid character range in the regular esseression"),
+ SSE_T("invalid character class in the regular esseression"),
+ SSE_T("invalid boundary range in the regular esseression"),
+ SSE_T("unesseected end of the regular esseression"),
+ SSE_T("garbage after the regular esseression")
};
- if (errnum >= 0 && errnum < xp_countof(__errstr))
+ if (errnum >= 0 && errnum < sse_countof(__errstr))
{
return __errstr[errnum];
}
- return XP_T("unknown error");
+ return SSE_T("unknown error");
}
diff --git a/ase/awk/extio.c b/ase/awk/extio.c
index 2a067fc1..482cd281 100644
--- a/ase/awk/extio.c
+++ b/ase/awk/extio.c
@@ -1,8 +1,8 @@
/*
- * $Id: extio.c,v 1.54 2006-10-16 14:38:43 bacon Exp $
+ * $Id: extio.c,v 1.55 2006-10-22 11:34:53 bacon Exp $
*/
-#include <xp/awk/awk_i.h>
+#include <sse/awk/awk_i.h>
enum
{
@@ -16,21 +16,21 @@ enum
static int __in_type_map[] =
{
/* the order should match the order of the
- * XP_AWK_IN_XXX values in tree.h */
- XP_AWK_EXTIO_PIPE,
- XP_AWK_EXTIO_COPROC,
- XP_AWK_EXTIO_FILE,
- XP_AWK_EXTIO_CONSOLE
+ * SSE_AWK_IN_XXX values in tree.h */
+ SSE_AWK_EXTIO_PIPE,
+ SSE_AWK_EXTIO_COPROC,
+ SSE_AWK_EXTIO_FILE,
+ SSE_AWK_EXTIO_CONSOLE
};
static int __in_mode_map[] =
{
/* the order should match the order of the
- * XP_AWK_IN_XXX values in tree.h */
- XP_AWK_IO_PIPE_READ,
+ * SSE_AWK_IN_XXX values in tree.h */
+ SSE_AWK_IO_PIPE_READ,
0,
- XP_AWK_IO_FILE_READ,
- XP_AWK_IO_CONSOLE_READ
+ SSE_AWK_IO_FILE_READ,
+ SSE_AWK_IO_CONSOLE_READ
};
static int __in_mask_map[] =
@@ -44,23 +44,23 @@ static int __in_mask_map[] =
static int __out_type_map[] =
{
/* the order should match the order of the
- * XP_AWK_OUT_XXX values in tree.h */
- XP_AWK_EXTIO_PIPE,
- XP_AWK_EXTIO_COPROC,
- XP_AWK_EXTIO_FILE,
- XP_AWK_EXTIO_FILE,
- XP_AWK_EXTIO_CONSOLE
+ * SSE_AWK_OUT_XXX values in tree.h */
+ SSE_AWK_EXTIO_PIPE,
+ SSE_AWK_EXTIO_COPROC,
+ SSE_AWK_EXTIO_FILE,
+ SSE_AWK_EXTIO_FILE,
+ SSE_AWK_EXTIO_CONSOLE
};
static int __out_mode_map[] =
{
/* the order should match the order of the
- * XP_AWK_OUT_XXX values in tree.h */
- XP_AWK_IO_PIPE_WRITE,
+ * SSE_AWK_OUT_XXX values in tree.h */
+ SSE_AWK_IO_PIPE_WRITE,
0,
- XP_AWK_IO_FILE_WRITE,
- XP_AWK_IO_FILE_APPEND,
- XP_AWK_IO_CONSOLE_WRITE
+ SSE_AWK_IO_FILE_WRITE,
+ SSE_AWK_IO_FILE_APPEND,
+ SSE_AWK_IO_CONSOLE_WRITE
};
static int __out_mask_map[] =
@@ -72,24 +72,24 @@ static int __out_mask_map[] =
__MASK_WRITE
};
-int xp_awk_readextio (
- xp_awk_run_t* run, int in_type,
- const xp_char_t* name, xp_awk_str_t* buf)
+int sse_awk_readextio (
+ sse_awk_run_t* run, int in_type,
+ const sse_char_t* name, sse_awk_str_t* buf)
{
- xp_awk_extio_t* p = run->extio.chain;
- xp_awk_io_t handler;
+ sse_awk_extio_t* p = run->extio.chain;
+ sse_awk_io_t handler;
int extio_type, extio_mode, extio_mask, n, ret;
- xp_awk_val_t* rs;
- xp_char_t* rs_ptr;
- xp_size_t rs_len;
- xp_size_t line_len = 0;
+ sse_awk_val_t* rs;
+ sse_char_t* rs_ptr;
+ sse_size_t rs_len;
+ sse_size_t line_len = 0;
- xp_awk_assert (run->awk,
- in_type >= 0 && in_type <= xp_countof(__in_type_map));
- xp_awk_assert (run->awk,
- in_type >= 0 && in_type <= xp_countof(__in_mode_map));
- xp_awk_assert (run->awk,
- in_type >= 0 && in_type <= xp_countof(__in_mask_map));
+ sse_awk_assert (run->awk,
+ in_type >= 0 && in_type <= sse_countof(__in_type_map));
+ sse_awk_assert (run->awk,
+ in_type >= 0 && in_type <= sse_countof(__in_mode_map));
+ sse_awk_assert (run->awk,
+ in_type >= 0 && in_type <= sse_countof(__in_mask_map));
/* translate the in_type into the relevant extio type and mode */
extio_type = __in_type_map[in_type];
@@ -97,62 +97,62 @@ int xp_awk_readextio (
extio_mask = __in_mask_map[in_type];
handler = run->extio.handler[extio_type];
- if (handler == XP_NULL)
+ if (handler == SSE_NULL)
{
/* no io handler provided */
- run->errnum = XP_AWK_EIOIMPL; /* TODO: change the error code */
+ run->errnum = SSE_AWK_EIOIMPL; /* TODO: change the error code */
return -1;
}
- while (p != XP_NULL)
+ while (p != SSE_NULL)
{
if (p->type == (extio_type | extio_mask) &&
- xp_awk_strcmp (p->name,name) == 0) break;
+ sse_awk_strcmp (p->name,name) == 0) break;
p = p->next;
}
- if (p == XP_NULL)
+ if (p == SSE_NULL)
{
- p = (xp_awk_extio_t*) XP_AWK_MALLOC (
- run->awk, xp_sizeof(xp_awk_extio_t));
- if (p == XP_NULL)
+ p = (sse_awk_extio_t*) SSE_AWK_MALLOC (
+ run->awk, sse_sizeof(sse_awk_extio_t));
+ if (p == SSE_NULL)
{
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
- p->name = xp_awk_strdup (run->awk, name);
- if (p->name == XP_NULL)
+ p->name = sse_awk_strdup (run->awk, name);
+ if (p->name == SSE_NULL)
{
- XP_AWK_FREE (run->awk, p);
- run->errnum = XP_AWK_ENOMEM;
+ SSE_AWK_FREE (run->awk, p);
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
p->run = run;
p->type = (extio_type | extio_mask);
p->mode = extio_mode;
- p->handle = XP_NULL;
- p->next = XP_NULL;
+ p->handle = SSE_NULL;
+ p->next = SSE_NULL;
p->custom_data = run->extio.custom_data;
- p->in.buf[0] = XP_T('\0');
+ p->in.buf[0] = SSE_T('\0');
p->in.pos = 0;
p->in.len = 0;
- p->in.eof = xp_false;
+ p->in.eof = sse_false;
- n = handler (XP_AWK_IO_OPEN, p, XP_NULL, 0);
+ n = handler (SSE_AWK_IO_OPEN, p, SSE_NULL, 0);
if (n == -1)
{
- XP_AWK_FREE (run->awk, p->name);
- XP_AWK_FREE (run->awk, p);
+ SSE_AWK_FREE (run->awk, p->name);
+ SSE_AWK_FREE (run->awk, p);
/* TODO: use meaningful error code */
- if (xp_awk_setglobal (
- run, XP_AWK_GLOBAL_ERRNO,
- xp_awk_val_one) == -1) return -1;
+ if (sse_awk_setglobal (
+ run, SSE_AWK_GLOBAL_ERRNO,
+ sse_awk_val_one) == -1) return -1;
- run->errnum = XP_AWK_EIOHANDLER;
+ run->errnum = SSE_AWK_EIOHANDLER;
return -1;
}
@@ -169,29 +169,29 @@ int xp_awk_readextio (
}
/* ready to read a line */
- xp_awk_str_clear (buf);
+ sse_awk_str_clear (buf);
/* get the record separator */
- rs = xp_awk_getglobal (run, XP_AWK_GLOBAL_RS);
- xp_awk_refupval (rs);
+ rs = sse_awk_getglobal (run, SSE_AWK_GLOBAL_RS);
+ sse_awk_refupval (rs);
- if (rs->type == XP_AWK_VAL_NIL)
+ if (rs->type == SSE_AWK_VAL_NIL)
{
- rs_ptr = XP_NULL;
+ rs_ptr = SSE_NULL;
rs_len = 0;
}
- else if (rs->type == XP_AWK_VAL_STR)
+ else if (rs->type == SSE_AWK_VAL_STR)
{
- rs_ptr = ((xp_awk_val_str_t*)rs)->buf;
- rs_len = ((xp_awk_val_str_t*)rs)->len;
+ rs_ptr = ((sse_awk_val_str_t*)rs)->buf;
+ rs_len = ((sse_awk_val_str_t*)rs)->len;
}
else
{
- rs_ptr = xp_awk_valtostr (
- run, rs, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &rs_len);
- if (rs_ptr == XP_NULL)
+ rs_ptr = sse_awk_valtostr (
+ run, rs, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &rs_len);
+ if (rs_ptr == SSE_NULL)
{
- xp_awk_refdownval (run, rs);
+ sse_awk_refdownval (run, rs);
return -1;
}
}
@@ -201,33 +201,33 @@ int xp_awk_readextio (
/* call the io handler */
while (1)
{
- xp_char_t c;
+ sse_char_t c;
if (p->in.pos >= p->in.len)
{
- xp_ssize_t n;
+ sse_ssize_t n;
if (p->in.eof)
{
- if (XP_AWK_STR_LEN(buf) == 0) ret = 0;
+ if (SSE_AWK_STR_LEN(buf) == 0) ret = 0;
break;
}
- n = handler (XP_AWK_IO_READ, p,
- p->in.buf, xp_countof(p->in.buf));
+ n = handler (SSE_AWK_IO_READ, p,
+ p->in.buf, sse_countof(p->in.buf));
if (n == -1)
{
/* handler error. getline should return -1 */
/* TODO: use meaningful error code */
- if (xp_awk_setglobal (
- run, XP_AWK_GLOBAL_ERRNO,
- xp_awk_val_one) == -1)
+ if (sse_awk_setglobal (
+ run, SSE_AWK_GLOBAL_ERRNO,
+ sse_awk_val_one) == -1)
{
ret = -1;
}
else
{
- run->errnum = XP_AWK_EIOHANDLER;
+ run->errnum = SSE_AWK_EIOHANDLER;
ret = -1;
}
break;
@@ -235,8 +235,8 @@ int xp_awk_readextio (
if (n == 0)
{
- p->in.eof = xp_true;
- if (XP_AWK_STR_LEN(buf) == 0) ret = 0;
+ p->in.eof = sse_true;
+ if (SSE_AWK_STR_LEN(buf) == 0) ret = 0;
break;
}
@@ -246,19 +246,19 @@ int xp_awk_readextio (
c = p->in.buf[p->in.pos++];
- if (rs_ptr == XP_NULL)
+ if (rs_ptr == SSE_NULL)
{
/* separate by a new line */
/* TODO: handle different line terminator like \r\n */
- if (c == XP_T('\n')) break;
+ if (c == SSE_T('\n')) break;
}
else if (rs_len == 0)
{
/* separate by a blank line */
/* TODO: handle different line terminator like \r\n */
- if (line_len == 0 && c == XP_T('\n'))
+ if (line_len == 0 && c == SSE_T('\n'))
{
- if (XP_AWK_STR_LEN(buf) <= 0)
+ if (SSE_AWK_STR_LEN(buf) <= 0)
{
/* if the record is empty when a blank
* line is encountered, the line
@@ -271,7 +271,7 @@ int xp_awk_readextio (
* it needs to snip off the line
* terminator of the previous line */
/* TODO: handle different line terminator like \r\n */
- XP_AWK_STR_LEN(buf) -= 1;
+ SSE_AWK_STR_LEN(buf) -= 1;
break;
}
}
@@ -281,16 +281,16 @@ int xp_awk_readextio (
}
else
{
- const xp_char_t* match_ptr;
- xp_size_t match_len;
+ const sse_char_t* match_ptr;
+ sse_size_t match_len;
- xp_awk_assert (run->awk, run->global.rs != XP_NULL);
+ sse_awk_assert (run->awk, run->global.rs != SSE_NULL);
/* TODO: safematchrex */
- n = xp_awk_matchrex (
+ n = sse_awk_matchrex (
run->awk, run->global.rs,
- ((run->global.ignorecase)? XP_AWK_REX_IGNORECASE: 0),
- XP_AWK_STR_BUF(buf), XP_AWK_STR_LEN(buf),
+ ((run->global.ignorecase)? SSE_AWK_REX_IGNORECASE: 0),
+ SSE_AWK_STR_BUF(buf), SSE_AWK_STR_LEN(buf),
&match_ptr, &match_len, &run->errnum);
if (n == -1)
{
@@ -302,58 +302,58 @@ int xp_awk_readextio (
{
/* the match should be found at the end of
* the current buffer */
- xp_awk_assert (run->awk,
- XP_AWK_STR_BUF(buf) + XP_AWK_STR_LEN(buf) ==
+ sse_awk_assert (run->awk,
+ SSE_AWK_STR_BUF(buf) + SSE_AWK_STR_LEN(buf) ==
match_ptr + match_len);
- XP_AWK_STR_LEN(buf) -= match_len;
+ SSE_AWK_STR_LEN(buf) -= match_len;
break;
}
}
- if (xp_awk_str_ccat (buf, c) == (xp_size_t)-1)
+ if (sse_awk_str_ccat (buf, c) == (sse_size_t)-1)
{
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
ret = -1;
break;
}
/* TODO: handle different line terminator like \r\n */
- if (c == XP_T('\n')) line_len = 0;
+ if (c == SSE_T('\n')) line_len = 0;
else line_len = line_len + 1;
}
- if (rs_ptr != XP_NULL && rs->type != XP_AWK_VAL_STR) XP_AWK_FREE (run->awk, rs_ptr);
- xp_awk_refdownval (run, rs);
+ if (rs_ptr != SSE_NULL && rs->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, rs_ptr);
+ sse_awk_refdownval (run, rs);
/* increment NR */
if (ret != -1)
{
- xp_awk_val_t* nr;
- xp_long_t lv;
- xp_real_t rv;
+ sse_awk_val_t* nr;
+ sse_long_t lv;
+ sse_real_t rv;
- nr = xp_awk_getglobal (run, XP_AWK_GLOBAL_NR);
- xp_awk_refupval (nr);
+ nr = sse_awk_getglobal (run, SSE_AWK_GLOBAL_NR);
+ sse_awk_refupval (nr);
- n = xp_awk_valtonum (run, nr, &lv, &rv);
- xp_awk_refdownval (run, nr);
+ n = sse_awk_valtonum (run, nr, &lv, &rv);
+ sse_awk_refdownval (run, nr);
if (n == -1) ret = -1;
else
{
- if (n == 1) lv = (xp_long_t)rv;
+ if (n == 1) lv = (sse_long_t)rv;
- nr = xp_awk_makeintval (run, lv + 1);
- if (nr == XP_NULL)
+ nr = sse_awk_makeintval (run, lv + 1);
+ if (nr == SSE_NULL)
{
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
ret = -1;
}
else
{
- if (xp_awk_setglobal (
- run, XP_AWK_GLOBAL_NR, nr) == -1) ret = -1;
+ if (sse_awk_setglobal (
+ run, SSE_AWK_GLOBAL_NR, nr) == -1) ret = -1;
}
}
}
@@ -361,48 +361,48 @@ int xp_awk_readextio (
return ret;
}
-int xp_awk_writeextio_val (
- xp_awk_run_t* run, int out_type,
- const xp_char_t* name, xp_awk_val_t* v)
+int sse_awk_writeextio_val (
+ sse_awk_run_t* run, int out_type,
+ const sse_char_t* name, sse_awk_val_t* v)
{
- xp_char_t* str;
- xp_size_t len;
+ sse_char_t* str;
+ sse_size_t len;
int n;
- if (v->type == XP_AWK_VAL_STR)
+ if (v->type == SSE_AWK_VAL_STR)
{
- str = ((xp_awk_val_str_t*)v)->buf;
- len = ((xp_awk_val_str_t*)v)->len;
+ str = ((sse_awk_val_str_t*)v)->buf;
+ len = ((sse_awk_val_str_t*)v)->len;
}
else
{
- str = xp_awk_valtostr (
+ str = sse_awk_valtostr (
run, v,
- XP_AWK_VALTOSTR_CLEAR | XP_AWK_VALTOSTR_PRINT,
- XP_NULL, &len);
- if (str == XP_NULL) return -1;
+ SSE_AWK_VALTOSTR_CLEAR | SSE_AWK_VALTOSTR_PRINT,
+ SSE_NULL, &len);
+ if (str == SSE_NULL) return -1;
}
- n = xp_awk_writeextio_str (run, out_type, name, str, len);
+ n = sse_awk_writeextio_str (run, out_type, name, str, len);
- if (v->type != XP_AWK_VAL_STR) XP_AWK_FREE (run->awk, str);
+ if (v->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str);
return n;
}
-int xp_awk_writeextio_str (
- xp_awk_run_t* run, int out_type,
- const xp_char_t* name, xp_char_t* str, xp_size_t len)
+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)
{
- xp_awk_extio_t* p = run->extio.chain;
- xp_awk_io_t handler;
+ sse_awk_extio_t* p = run->extio.chain;
+ sse_awk_io_t handler;
int extio_type, extio_mode, extio_mask, n;
- xp_awk_assert (run->awk,
- out_type >= 0 && out_type <= xp_countof(__out_type_map));
- xp_awk_assert (run->awk,
- out_type >= 0 && out_type <= xp_countof(__out_mode_map));
- xp_awk_assert (run->awk,
- out_type >= 0 && out_type <= xp_countof(__out_mask_map));
+ sse_awk_assert (run->awk,
+ out_type >= 0 && out_type <= sse_countof(__out_type_map));
+ sse_awk_assert (run->awk,
+ out_type >= 0 && out_type <= sse_countof(__out_mode_map));
+ sse_awk_assert (run->awk,
+ out_type >= 0 && out_type <= sse_countof(__out_mask_map));
/* translate the out_type into the relevant extio type and mode */
extio_type = __out_type_map[out_type];
@@ -410,69 +410,69 @@ int xp_awk_writeextio_str (
extio_mask = __out_mask_map[out_type];
handler = run->extio.handler[extio_type];
- if (handler == XP_NULL)
+ if (handler == SSE_NULL)
{
/* no io handler provided */
- run->errnum = XP_AWK_EIOIMPL; /* TODO: change the error code */
+ run->errnum = SSE_AWK_EIOIMPL; /* TODO: change the error code */
return -1;
}
/* look for the corresponding extio for name */
- while (p != XP_NULL)
+ while (p != SSE_NULL)
{
/* the file "1.tmp", in the following code snippets,
* would be opened by the first print statement, but not by
* the second print statement. this is because
- * both XP_AWK_OUT_FILE and XP_AWK_OUT_FILE_APPEND are
- * translated to XP_AWK_EXTIO_FILE and it is used to
+ * both SSE_AWK_OUT_FILE and SSE_AWK_OUT_FILE_APPEND are
+ * translated to SSE_AWK_EXTIO_FILE and it is used to
* keep track of file handles..
*
* print "1111" >> "1.tmp"
* print "1111" > "1.tmp"
*/
if (p->type == (extio_type | extio_mask) &&
- xp_awk_strcmp (p->name, name) == 0) break;
+ sse_awk_strcmp (p->name, name) == 0) break;
p = p->next;
}
/* if there is not corresponding extio for name, create one */
- if (p == XP_NULL)
+ if (p == SSE_NULL)
{
- p = (xp_awk_extio_t*) XP_AWK_MALLOC (
- run->awk, xp_sizeof(xp_awk_extio_t));
- if (p == XP_NULL)
+ p = (sse_awk_extio_t*) SSE_AWK_MALLOC (
+ run->awk, sse_sizeof(sse_awk_extio_t));
+ if (p == SSE_NULL)
{
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
- p->name = xp_awk_strdup (run->awk, name);
- if (p->name == XP_NULL)
+ p->name = sse_awk_strdup (run->awk, name);
+ if (p->name == SSE_NULL)
{
- XP_AWK_FREE (run->awk, p);
- run->errnum = XP_AWK_ENOMEM;
+ SSE_AWK_FREE (run->awk, p);
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
p->run = run;
p->type = (extio_type | extio_mask);
p->mode = extio_mode;
- p->handle = XP_NULL;
- p->next = XP_NULL;
+ p->handle = SSE_NULL;
+ p->next = SSE_NULL;
p->custom_data = run->extio.custom_data;
- n = handler (XP_AWK_IO_OPEN, p, XP_NULL, 0);
+ n = handler (SSE_AWK_IO_OPEN, p, SSE_NULL, 0);
if (n == -1)
{
- XP_AWK_FREE (run->awk, p->name);
- XP_AWK_FREE (run->awk, p);
+ SSE_AWK_FREE (run->awk, p->name);
+ SSE_AWK_FREE (run->awk, p);
/* TODO: use meaningful error code */
- if (xp_awk_setglobal (
- run, XP_AWK_GLOBAL_ERRNO,
- xp_awk_val_one) == -1) return -1;
+ if (sse_awk_setglobal (
+ run, SSE_AWK_GLOBAL_ERRNO,
+ sse_awk_val_one) == -1) return -1;
- run->errnum = XP_AWK_EIOHANDLER;
+ run->errnum = SSE_AWK_EIOHANDLER;
return -1;
}
@@ -491,16 +491,16 @@ int xp_awk_writeextio_str (
/* TODO: if write handler returns less than the request, loop */
if (len > 0)
{
- n = handler (XP_AWK_IO_WRITE, p, str, len);
+ n = handler (SSE_AWK_IO_WRITE, p, str, len);
if (n == -1)
{
/* TODO: use meaningful error code */
- if (xp_awk_setglobal (
- run, XP_AWK_GLOBAL_ERRNO,
- xp_awk_val_one) == -1) return -1;
+ if (sse_awk_setglobal (
+ run, SSE_AWK_GLOBAL_ERRNO,
+ sse_awk_val_one) == -1) return -1;
- run->errnum = XP_AWK_EIOHANDLER;
+ run->errnum = SSE_AWK_EIOHANDLER;
return -1;
}
@@ -511,20 +511,20 @@ int xp_awk_writeextio_str (
}
-int xp_awk_flushextio (
- xp_awk_run_t* run, int out_type, const xp_char_t* name)
+int sse_awk_flushextio (
+ sse_awk_run_t* run, int out_type, const sse_char_t* name)
{
- xp_awk_extio_t* p = run->extio.chain;
- xp_awk_io_t handler;
+ sse_awk_extio_t* p = run->extio.chain;
+ sse_awk_io_t handler;
int extio_type, extio_mode, extio_mask, n;
- xp_bool_t ok = xp_false;
+ sse_bool_t ok = sse_false;
- xp_awk_assert (run->awk,
- out_type >= 0 && out_type <= xp_countof(__out_type_map));
- xp_awk_assert (run->awk,
- out_type >= 0 && out_type <= xp_countof(__out_mode_map));
- xp_awk_assert (run->awk,
- out_type >= 0 && out_type <= xp_countof(__out_mask_map));
+ sse_awk_assert (run->awk,
+ out_type >= 0 && out_type <= sse_countof(__out_type_map));
+ sse_awk_assert (run->awk,
+ out_type >= 0 && out_type <= sse_countof(__out_mode_map));
+ sse_awk_assert (run->awk,
+ out_type >= 0 && out_type <= sse_countof(__out_mask_map));
/* translate the out_type into the relevant extio type and mode */
extio_type = __out_type_map[out_type];
@@ -532,33 +532,33 @@ int xp_awk_flushextio (
extio_mask = __out_mask_map[out_type];
handler = run->extio.handler[extio_type];
- if (handler == XP_NULL)
+ if (handler == SSE_NULL)
{
/* no io handler provided */
- run->errnum = XP_AWK_EIOIMPL; /* TODO: change the error code */
+ run->errnum = SSE_AWK_EIOIMPL; /* TODO: change the error code */
return -1;
}
/* look for the corresponding extio for name */
- while (p != XP_NULL)
+ while (p != SSE_NULL)
{
if (p->type == (extio_type | extio_mask) &&
- (name == XP_NULL || xp_awk_strcmp (p->name, name) == 0))
+ (name == SSE_NULL || sse_awk_strcmp (p->name, name) == 0))
{
- n = handler (XP_AWK_IO_FLUSH, p, XP_NULL, 0);
+ n = handler (SSE_AWK_IO_FLUSH, p, SSE_NULL, 0);
if (n == -1)
{
/* TODO: use meaningful error code */
- if (xp_awk_setglobal (
- run, XP_AWK_GLOBAL_ERRNO,
- xp_awk_val_one) == -1) return -1;
+ if (sse_awk_setglobal (
+ run, SSE_AWK_GLOBAL_ERRNO,
+ sse_awk_val_one) == -1) return -1;
- run->errnum = XP_AWK_EIOHANDLER;
+ run->errnum = SSE_AWK_EIOHANDLER;
return -1;
}
- ok = xp_true;
+ ok = sse_true;
}
p = p->next;
@@ -568,26 +568,26 @@ int xp_awk_flushextio (
/* there is no corresponding extio for name */
/* TODO: use meaningful error code. but is this needed? */
- if (xp_awk_setglobal (
- run, XP_AWK_GLOBAL_ERRNO, xp_awk_val_one) == -1) return -1;
+ if (sse_awk_setglobal (
+ run, SSE_AWK_GLOBAL_ERRNO, sse_awk_val_one) == -1) return -1;
- run->errnum = XP_AWK_ENOSUCHIO;
+ run->errnum = SSE_AWK_ENOSUCHIO;
return -1;
}
-int xp_awk_nextextio_read (
- xp_awk_run_t* run, int in_type, const xp_char_t* name)
+int sse_awk_nextextio_read (
+ sse_awk_run_t* run, int in_type, const sse_char_t* name)
{
- xp_awk_extio_t* p = run->extio.chain;
- xp_awk_io_t handler;
+ sse_awk_extio_t* p = run->extio.chain;
+ sse_awk_io_t handler;
int extio_type, extio_mode, extio_mask, n;
- xp_awk_assert (run->awk,
- in_type >= 0 && in_type <= xp_countof(__in_type_map));
- xp_awk_assert (run->awk,
- in_type >= 0 && in_type <= xp_countof(__in_mode_map));
- xp_awk_assert (run->awk,
- in_type >= 0 && in_type <= xp_countof(__in_mask_map));
+ sse_awk_assert (run->awk,
+ in_type >= 0 && in_type <= sse_countof(__in_type_map));
+ sse_awk_assert (run->awk,
+ in_type >= 0 && in_type <= sse_countof(__in_mode_map));
+ sse_awk_assert (run->awk,
+ in_type >= 0 && in_type <= sse_countof(__in_mask_map));
/* translate the in_type into the relevant extio type and mode */
extio_type = __in_type_map[in_type];
@@ -595,51 +595,51 @@ int xp_awk_nextextio_read (
extio_mask = __in_mask_map[in_type];
handler = run->extio.handler[extio_type];
- if (handler == XP_NULL)
+ if (handler == SSE_NULL)
{
/* no io handler provided */
- run->errnum = XP_AWK_EIOIMPL; /* TODO: change the error code */
+ run->errnum = SSE_AWK_EIOIMPL; /* TODO: change the error code */
return -1;
}
- while (p != XP_NULL)
+ while (p != SSE_NULL)
{
if (p->type == (extio_type | extio_mask) &&
- xp_awk_strcmp (p->name,name) == 0) break;
+ sse_awk_strcmp (p->name,name) == 0) break;
p = p->next;
}
- if (p == XP_NULL)
+ if (p == SSE_NULL)
{
/* something is totally wrong */
- run->errnum = XP_AWK_EINTERNAL;
+ run->errnum = SSE_AWK_EINTERNAL;
return -1;
}
- n = handler (XP_AWK_IO_NEXT, p, XP_NULL, 0);
+ n = handler (SSE_AWK_IO_NEXT, p, SSE_NULL, 0);
if (n == -1)
{
/* TODO: is this errnum correct? */
- run->errnum = XP_AWK_EIOHANDLER;
+ run->errnum = SSE_AWK_EIOHANDLER;
return -1;
}
return n;
}
-int xp_awk_closeextio_read (
- xp_awk_run_t* run, int in_type, const xp_char_t* name)
+int sse_awk_closeextio_read (
+ sse_awk_run_t* run, int in_type, const sse_char_t* name)
{
- xp_awk_extio_t* p = run->extio.chain, * px = XP_NULL;
- xp_awk_io_t handler;
+ sse_awk_extio_t* p = run->extio.chain, * px = SSE_NULL;
+ sse_awk_io_t handler;
int extio_type, extio_mode, extio_mask;
- xp_awk_assert (run->awk,
- in_type >= 0 && in_type <= xp_countof(__in_type_map));
- xp_awk_assert (run->awk,
- in_type >= 0 && in_type <= xp_countof(__in_mode_map));
- xp_awk_assert (run->awk,
- in_type >= 0 && in_type <= xp_countof(__in_mask_map));
+ sse_awk_assert (run->awk,
+ in_type >= 0 && in_type <= sse_countof(__in_type_map));
+ sse_awk_assert (run->awk,
+ in_type >= 0 && in_type <= sse_countof(__in_mode_map));
+ sse_awk_assert (run->awk,
+ in_type >= 0 && in_type <= sse_countof(__in_mask_map));
/* translate the in_type into the relevant extio type and mode */
extio_type = __in_type_map[in_type];
@@ -647,37 +647,37 @@ int xp_awk_closeextio_read (
extio_mask = __in_mask_map[in_type];
handler = run->extio.handler[extio_type];
- if (handler == XP_NULL)
+ if (handler == SSE_NULL)
{
/* no io handler provided */
- run->errnum = XP_AWK_EIOIMPL; /* TODO: change the error code */
+ run->errnum = SSE_AWK_EIOIMPL; /* TODO: change the error code */
return -1;
}
- while (p != XP_NULL)
+ while (p != SSE_NULL)
{
if (p->type == (extio_type | extio_mask) &&
- xp_awk_strcmp (p->name, name) == 0)
+ sse_awk_strcmp (p->name, name) == 0)
{
- xp_awk_io_t handler;
+ sse_awk_io_t handler;
handler = run->extio.handler[p->type & __MASK_CLEAR];
- if (handler != XP_NULL)
+ if (handler != SSE_NULL)
{
- if (handler (XP_AWK_IO_CLOSE, p, XP_NULL, 0) == -1)
+ if (handler (SSE_AWK_IO_CLOSE, p, SSE_NULL, 0) == -1)
{
/* this is not a run-time error.*/
/* TODO: set ERRNO */
- run->errnum = XP_AWK_EIOHANDLER;
+ run->errnum = SSE_AWK_EIOHANDLER;
return -1;
}
}
- if (px != XP_NULL) px->next = p->next;
+ if (px != SSE_NULL) px->next = p->next;
else run->extio.chain = p->next;
- XP_AWK_FREE (run->awk, p->name);
- XP_AWK_FREE (run->awk, p);
+ SSE_AWK_FREE (run->awk, p->name);
+ SSE_AWK_FREE (run->awk, p);
return 0;
}
@@ -686,23 +686,23 @@ int xp_awk_closeextio_read (
}
/* this is not a run-time error */
- run->errnum = XP_AWK_EIOHANDLER;
+ run->errnum = SSE_AWK_EIOHANDLER;
return -1;
}
-int xp_awk_closeextio_write (
- xp_awk_run_t* run, int out_type, const xp_char_t* name)
+int sse_awk_closeextio_write (
+ sse_awk_run_t* run, int out_type, const sse_char_t* name)
{
- xp_awk_extio_t* p = run->extio.chain, * px = XP_NULL;
- xp_awk_io_t handler;
+ sse_awk_extio_t* p = run->extio.chain, * px = SSE_NULL;
+ sse_awk_io_t handler;
int extio_type, extio_mode, extio_mask;
- xp_awk_assert (run->awk,
- out_type >= 0 && out_type <= xp_countof(__out_type_map));
- xp_awk_assert (run->awk,
- out_type >= 0 && out_type <= xp_countof(__out_mode_map));
- xp_awk_assert (run->awk,
- out_type >= 0 && out_type <= xp_countof(__out_mask_map));
+ sse_awk_assert (run->awk,
+ out_type >= 0 && out_type <= sse_countof(__out_type_map));
+ sse_awk_assert (run->awk,
+ out_type >= 0 && out_type <= sse_countof(__out_mode_map));
+ sse_awk_assert (run->awk,
+ out_type >= 0 && out_type <= sse_countof(__out_mask_map));
/* translate the out_type into the relevant extio type and mode */
extio_type = __out_type_map[out_type];
@@ -710,37 +710,37 @@ int xp_awk_closeextio_write (
extio_mask = __out_mask_map[out_type];
handler = run->extio.handler[extio_type];
- if (handler == XP_NULL)
+ if (handler == SSE_NULL)
{
/* no io handler provided */
- run->errnum = XP_AWK_EIOIMPL; /* TODO: change the error code */
+ run->errnum = SSE_AWK_EIOIMPL; /* TODO: change the error code */
return -1;
}
- while (p != XP_NULL)
+ while (p != SSE_NULL)
{
if (p->type == (extio_type | extio_mask) &&
- xp_awk_strcmp (p->name, name) == 0)
+ sse_awk_strcmp (p->name, name) == 0)
{
- xp_awk_io_t handler;
+ sse_awk_io_t handler;
handler = run->extio.handler[p->type & __MASK_CLEAR];
- if (handler != XP_NULL)
+ if (handler != SSE_NULL)
{
- if (handler (XP_AWK_IO_CLOSE, p, XP_NULL, 0) == -1)
+ if (handler (SSE_AWK_IO_CLOSE, p, SSE_NULL, 0) == -1)
{
/* this is not a run-time error.*/
/* TODO: set ERRNO */
- run->errnum = XP_AWK_EIOHANDLER;
+ run->errnum = SSE_AWK_EIOHANDLER;
return -1;
}
}
- if (px != XP_NULL) px->next = p->next;
+ if (px != SSE_NULL) px->next = p->next;
else run->extio.chain = p->next;
- XP_AWK_FREE (run->awk, p->name);
- XP_AWK_FREE (run->awk, p);
+ SSE_AWK_FREE (run->awk, p->name);
+ SSE_AWK_FREE (run->awk, p);
return 0;
}
@@ -750,39 +750,39 @@ int xp_awk_closeextio_write (
/* this is not a run-time error */
/* TODO: set ERRNO */
- run->errnum = XP_AWK_EIOHANDLER;
+ run->errnum = SSE_AWK_EIOHANDLER;
return -1;
}
-int xp_awk_closeextio (xp_awk_run_t* run, const xp_char_t* name)
+int sse_awk_closeextio (sse_awk_run_t* run, const sse_char_t* name)
{
- xp_awk_extio_t* p = run->extio.chain, * px = XP_NULL;
+ sse_awk_extio_t* p = run->extio.chain, * px = SSE_NULL;
- while (p != XP_NULL)
+ while (p != SSE_NULL)
{
/* it handles the first that matches the given name
* regardless of the extio type */
- if (xp_awk_strcmp (p->name, name) == 0)
+ if (sse_awk_strcmp (p->name, name) == 0)
{
- xp_awk_io_t handler;
+ sse_awk_io_t handler;
handler = run->extio.handler[p->type & __MASK_CLEAR];
- if (handler != XP_NULL)
+ if (handler != SSE_NULL)
{
- if (handler (XP_AWK_IO_CLOSE, p, XP_NULL, 0) == -1)
+ if (handler (SSE_AWK_IO_CLOSE, p, SSE_NULL, 0) == -1)
{
/* this is not a run-time error.*/
/* TODO: set ERRNO */
- run->errnum = XP_AWK_EIOHANDLER;
+ run->errnum = SSE_AWK_EIOHANDLER;
return -1;
}
}
- if (px != XP_NULL) px->next = p->next;
+ if (px != SSE_NULL) px->next = p->next;
else run->extio.chain = p->next;
- XP_AWK_FREE (run->awk, p->name);
- XP_AWK_FREE (run->awk, p);
+ SSE_AWK_FREE (run->awk, p->name);
+ SSE_AWK_FREE (run->awk, p);
return 0;
}
@@ -792,25 +792,25 @@ int xp_awk_closeextio (xp_awk_run_t* run, const xp_char_t* name)
/* this is not a run-time error */
/* TODO: set ERRNO */
- run->errnum = XP_AWK_EIOHANDLER;
+ run->errnum = SSE_AWK_EIOHANDLER;
return -1;
}
-void xp_awk_clearextio (xp_awk_run_t* run)
+void sse_awk_clearextio (sse_awk_run_t* run)
{
- xp_awk_extio_t* next;
- xp_awk_io_t handler;
+ sse_awk_extio_t* next;
+ sse_awk_io_t handler;
int n;
- while (run->extio.chain != XP_NULL)
+ while (run->extio.chain != SSE_NULL)
{
handler = run->extio.handler[
run->extio.chain->type & __MASK_CLEAR];
next = run->extio.chain->next;
- if (handler != XP_NULL)
+ if (handler != SSE_NULL)
{
- n = handler (XP_AWK_IO_CLOSE, run->extio.chain, XP_NULL, 0);
+ n = handler (SSE_AWK_IO_CLOSE, run->extio.chain, SSE_NULL, 0);
if (n == -1)
{
/* TODO:
@@ -818,8 +818,8 @@ void xp_awk_clearextio (xp_awk_run_t* run)
}
}
- XP_AWK_FREE (run->awk, run->extio.chain->name);
- XP_AWK_FREE (run->awk, run->extio.chain);
+ SSE_AWK_FREE (run->awk, run->extio.chain->name);
+ SSE_AWK_FREE (run->awk, run->extio.chain);
run->extio.chain = next;
}
diff --git a/ase/awk/extio.h b/ase/awk/extio.h
index 2d9b3ebc..306c8b3e 100644
--- a/ase/awk/extio.h
+++ b/ase/awk/extio.h
@@ -1,48 +1,48 @@
/*
- * $Id: extio.h,v 1.13 2006-09-29 11:18:13 bacon Exp $
+ * $Id: extio.h,v 1.14 2006-10-22 11:34:53 bacon Exp $
*/
-#ifndef _XP_AWK_EXTIO_H_
-#define _XP_AWK_EXTIO_H_
+#ifndef _SSE_AWK_EXTIO_H_
+#define _SSE_AWK_EXTIO_H_
-#ifndef _XP_AWK_AWK_H_
-#error Never include this file directly. Include <xp/awk/awk.h> instead
+#ifndef _SSE_AWK_AWK_H_
+#error Never include this file directly. Include <sse/awk/awk.h> instead
#endif
#ifdef __cplusplus
extern "C"
#endif
-int xp_awk_readextio (
- xp_awk_run_t* run, int in_type,
- const xp_char_t* name, xp_awk_str_t* buf);
+int sse_awk_readextio (
+ sse_awk_run_t* run, int in_type,
+ const sse_char_t* name, sse_awk_str_t* buf);
-int xp_awk_writeextio_val (
- xp_awk_run_t* run, int out_type,
- const xp_char_t* name, xp_awk_val_t* v);
+int sse_awk_writeextio_val (
+ sse_awk_run_t* run, int out_type,
+ const sse_char_t* name, sse_awk_val_t* v);
-int xp_awk_writeextio_str (
- xp_awk_run_t* run, int out_type,
- const xp_char_t* name, xp_char_t* str, xp_size_t len);
+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 xp_awk_flushextio (
- xp_awk_run_t* run, int out_type, const xp_char_t* name);
+int sse_awk_flushextio (
+ sse_awk_run_t* run, int out_type, const sse_char_t* name);
-int xp_awk_nextextio_read (
- xp_awk_run_t* run, int in_type, const xp_char_t* name);
+int sse_awk_nextextio_read (
+ sse_awk_run_t* run, int in_type, const sse_char_t* name);
/* TODO:
-int xp_awk_nextextio_write (
- xp_awk_run_t* run, int out_type, const xp_char_t* name);
+int sse_awk_nextextio_write (
+ sse_awk_run_t* run, int out_type, const sse_char_t* name);
*/
-int xp_awk_closeextio_read (
- xp_awk_run_t* run, int in_type, const xp_char_t* name);
-int xp_awk_closeextio_write (
- xp_awk_run_t* run, int out_type, const xp_char_t* name);
-int xp_awk_closeextio (xp_awk_run_t* run, const xp_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);
-void xp_awk_clearextio (xp_awk_run_t* run);
+void sse_awk_clearextio (sse_awk_run_t* run);
#ifdef __cplusplus
}
diff --git a/ase/awk/func.c b/ase/awk/func.c
index 5352900c..a7a666d6 100644
--- a/ase/awk/func.c
+++ b/ase/awk/func.c
@@ -1,8 +1,8 @@
/*
- * $Id: func.c,v 1.65 2006-10-18 14:02:19 bacon Exp $
+ * $Id: func.c,v 1.66 2006-10-22 11:34:53 bacon Exp $
*/
-#include <xp/awk/awk_i.h>
+#include <sse/awk/awk_i.h>
#ifdef _WIN32
#include <tchar.h>
@@ -12,56 +12,56 @@
#include <math.h>
#endif
-static int __bfn_close (xp_awk_run_t* run);
-static int __bfn_fflush (xp_awk_run_t* run);
-static int __bfn_index (xp_awk_run_t* run);
-static int __bfn_length (xp_awk_run_t* run);
-static int __bfn_substr (xp_awk_run_t* run);
-static int __bfn_split (xp_awk_run_t* run);
-static int __bfn_tolower (xp_awk_run_t* run);
-static int __bfn_toupper (xp_awk_run_t* run);
-static int __bfn_gsub (xp_awk_run_t* run);
-static int __bfn_sub (xp_awk_run_t* run);
-static int __bfn_match (xp_awk_run_t* run);
-static int __bfn_system (xp_awk_run_t* run);
-/*static int __bfn_sin (xp_awk_run_t* run);*/
+static int __bfn_close (sse_awk_run_t* run);
+static int __bfn_fflush (sse_awk_run_t* run);
+static int __bfn_index (sse_awk_run_t* run);
+static int __bfn_length (sse_awk_run_t* run);
+static int __bfn_substr (sse_awk_run_t* run);
+static int __bfn_split (sse_awk_run_t* run);
+static int __bfn_tolower (sse_awk_run_t* run);
+static int __bfn_toupper (sse_awk_run_t* run);
+static int __bfn_gsub (sse_awk_run_t* run);
+static int __bfn_sub (sse_awk_run_t* run);
+static int __bfn_match (sse_awk_run_t* run);
+static int __bfn_system (sse_awk_run_t* run);
+/*static int __bfn_sin (sse_awk_run_t* run);*/
/* TODO: move it under the awk structure... */
-static xp_awk_bfn_t __sys_bfn[] =
+static sse_awk_bfn_t __sys_bfn[] =
{
/* io functions */
- {XP_T("close"), 5, XP_AWK_EXTIO, 1, 1, XP_NULL, __bfn_close},
- {XP_T("fflush"), 6, XP_AWK_EXTIO, 0, 1, XP_NULL, __bfn_fflush},
+ {SSE_T("close"), 5, SSE_AWK_EXTIO, 1, 1, SSE_NULL, __bfn_close},
+ {SSE_T("fflush"), 6, SSE_AWK_EXTIO, 0, 1, SSE_NULL, __bfn_fflush},
/* string functions */
- {XP_T("index"), 5, 0, 2, 2, XP_NULL, __bfn_index},
- {XP_T("substr"), 6, 0, 2, 3, XP_NULL, __bfn_substr},
- {XP_T("length"), 6, 0, 1, 1, XP_NULL, __bfn_length},
- {XP_T("split"), 5, 0, 2, 3, XP_T("vrv"), __bfn_split},
- {XP_T("tolower"), 7, 0, 1, 1, XP_NULL, __bfn_tolower},
- {XP_T("toupper"), 7, 0, 1, 1, XP_NULL, __bfn_toupper},
- {XP_T("gsub"), 4, 0, 2, 3, XP_T("xvr"), __bfn_gsub},
- {XP_T("sub"), 3, 0, 2, 3, XP_T("xvr"), __bfn_sub},
- {XP_T("match"), 5, 0, 2, 2, XP_T("vx"), __bfn_match},
+ {SSE_T("index"), 5, 0, 2, 2, SSE_NULL, __bfn_index},
+ {SSE_T("substr"), 6, 0, 2, 3, SSE_NULL, __bfn_substr},
+ {SSE_T("length"), 6, 0, 1, 1, SSE_NULL, __bfn_length},
+ {SSE_T("split"), 5, 0, 2, 3, SSE_T("vrv"), __bfn_split},
+ {SSE_T("tolower"), 7, 0, 1, 1, SSE_NULL, __bfn_tolower},
+ {SSE_T("toupper"), 7, 0, 1, 1, SSE_NULL, __bfn_toupper},
+ {SSE_T("gsub"), 4, 0, 2, 3, SSE_T("xvr"), __bfn_gsub},
+ {SSE_T("sub"), 3, 0, 2, 3, SSE_T("xvr"), __bfn_sub},
+ {SSE_T("match"), 5, 0, 2, 2, SSE_T("vx"), __bfn_match},
/* TODO: remove these two functions */
- {XP_T("system"), 6, 0, 1, 1, XP_NULL, __bfn_system},
- /*{ XP_T("sin"), 3, 0, 1, 1, XP_NULL, __bfn_sin},*/
+ {SSE_T("system"), 6, 0, 1, 1, SSE_NULL, __bfn_system},
+ /*{ SSE_T("sin"), 3, 0, 1, 1, SSE_NULL, __bfn_sin},*/
- {XP_NULL, 0, 0, 0, 0, XP_NULL, XP_NULL}
+ {SSE_NULL, 0, 0, 0, 0, SSE_NULL, SSE_NULL}
};
-xp_awk_bfn_t* xp_awk_addbfn (
- xp_awk_t* awk, const xp_char_t* name, xp_size_t name_len,
- int when_valid, xp_size_t min_args, xp_size_t max_args,
- const xp_char_t* arg_spec, int (*handler)(xp_awk_run_t*))
+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*))
{
- xp_awk_bfn_t* p;
+ sse_awk_bfn_t* p;
/* TODO: complete this function??? */
- p = (xp_awk_bfn_t*) XP_AWK_MALLOC (awk, xp_sizeof(xp_awk_bfn_t));
- if (p == XP_NULL) return XP_NULL;
+ p = (sse_awk_bfn_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_bfn_t));
+ if (p == SSE_NULL) return SSE_NULL;
/* NOTE: make sure that name is a constant string */
p->name = name;
@@ -78,19 +78,19 @@ xp_awk_bfn_t* xp_awk_addbfn (
return p;
}
-int xp_awk_delbfn (xp_awk_t* awk, const xp_char_t* name, xp_size_t name_len)
+int sse_awk_delbfn (sse_awk_t* awk, const sse_char_t* name, sse_size_t name_len)
{
- xp_awk_bfn_t* p, * pp = XP_NULL;
+ sse_awk_bfn_t* p, * pp = SSE_NULL;
- for (p = awk->bfn.user; p != XP_NULL; p++)
+ for (p = awk->bfn.user; p != SSE_NULL; p++)
{
- if (xp_awk_strxncmp(p->name, p->name_len, name, name_len) == 0)
+ if (sse_awk_strxncmp(p->name, p->name_len, name, name_len) == 0)
{
- if (pp == XP_NULL)
+ if (pp == SSE_NULL)
awk->bfn.user = p->next;
else pp->next = p->next;
- XP_AWK_FREE (awk, p);
+ SSE_AWK_FREE (awk, p);
return 0;
}
@@ -100,74 +100,74 @@ int xp_awk_delbfn (xp_awk_t* awk, const xp_char_t* name, xp_size_t name_len)
return -1;
}
-void xp_awk_clrbfn (xp_awk_t* awk)
+void sse_awk_clrbfn (sse_awk_t* awk)
{
- xp_awk_bfn_t* p, * np;
+ sse_awk_bfn_t* p, * np;
p = awk->bfn.user;
- while (p != XP_NULL)
+ while (p != SSE_NULL)
{
np = p;
- XP_AWK_FREE (awk, p);
+ SSE_AWK_FREE (awk, p);
p = np;
}
- awk->bfn.user = XP_NULL;
+ awk->bfn.user = SSE_NULL;
}
-xp_awk_bfn_t* xp_awk_getbfn (
- xp_awk_t* awk, const xp_char_t* name, xp_size_t name_len)
+sse_awk_bfn_t* sse_awk_getbfn (
+ sse_awk_t* awk, const sse_char_t* name, sse_size_t name_len)
{
- xp_awk_bfn_t* p;
+ sse_awk_bfn_t* p;
- for (p = __sys_bfn; p->name != XP_NULL; p++)
+ for (p = __sys_bfn; p->name != SSE_NULL; p++)
{
if (p->valid != 0 &&
(awk->option & p->valid) == 0) continue;
- if (xp_awk_strxncmp (
+ if (sse_awk_strxncmp (
p->name, p->name_len, name, name_len) == 0) return p;
}
/* TODO: user-added builtin functions... */
- for (p = awk->bfn.user; p != XP_NULL; p = p->next)
+ for (p = awk->bfn.user; p != SSE_NULL; p = p->next)
{
if (p->valid != 0 &&
(awk->option & p->valid) == 0) continue;
- if (xp_awk_strxncmp (
+ if (sse_awk_strxncmp (
p->name, p->name_len, name, name_len) == 0) return p;
}
- return XP_NULL;
+ return SSE_NULL;
}
-static int __bfn_close (xp_awk_run_t* run)
+static int __bfn_close (sse_awk_run_t* run)
{
- xp_size_t nargs;
- xp_awk_val_t* v, * a0;
+ sse_size_t nargs;
+ sse_awk_val_t* v, * a0;
int n;
- xp_char_t* name;
- xp_size_t len;
+ sse_char_t* name;
+ sse_size_t len;
- nargs = xp_awk_getnargs (run);
- xp_awk_assert (run->awk, nargs == 1);
+ nargs = sse_awk_getnargs (run);
+ sse_awk_assert (run->awk, nargs == 1);
/* TODO: support close (xxx, "to"/"from") like gawk */
- a0 = xp_awk_getarg (run, 0);
- xp_awk_assert (run->awk, a0 != XP_NULL);
+ a0 = sse_awk_getarg (run, 0);
+ sse_awk_assert (run->awk, a0 != SSE_NULL);
- if (a0->type == XP_AWK_VAL_STR)
+ if (a0->type == SSE_AWK_VAL_STR)
{
- name = ((xp_awk_val_str_t*)a0)->buf;
- len = ((xp_awk_val_str_t*)a0)->len;
+ name = ((sse_awk_val_str_t*)a0)->buf;
+ len = ((sse_awk_val_str_t*)a0)->len;
}
else
{
- name = xp_awk_valtostr (
- run, a0, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &len);
- if (name == XP_NULL) return -1;
+ name = sse_awk_valtostr (
+ run, a0, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
+ if (name == SSE_NULL) return -1;
}
if (len == 0)
@@ -175,12 +175,12 @@ static int __bfn_close (xp_awk_run_t* run)
/* getline or print doesn't allow an emptry for the
* input or output file name. so close should not allow
* it either.
- * another reason for this is if close is called explicitly
+ * another reason for this is if close is called esselicitly
* with an empty string, it may close the console that uses
* an empty string for its identification because closeextio
* closes any extios that match the name given unlike
* closeextio_read or closeextio_write. */
- if (a0->type != XP_AWK_VAL_STR) XP_AWK_FREE (run->awk, name);
+ if (a0->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, name);
n = -1;
/* TODO: need to set ERRNO??? */
goto skip_close;
@@ -188,52 +188,52 @@ static int __bfn_close (xp_awk_run_t* run)
while (len > 0)
{
- if (name[--len] == XP_T('\0'))
+ if (name[--len] == SSE_T('\0'))
{
/* the name contains a null string.
* make close return -1 */
- if (a0->type != XP_AWK_VAL_STR)
- XP_AWK_FREE (run->awk, name);
+ if (a0->type != SSE_AWK_VAL_STR)
+ SSE_AWK_FREE (run->awk, name);
n = -1;
/* TODO: need to set ERRNO??? */
goto skip_close;
}
}
- n = xp_awk_closeextio (run, name);
- if (n == -1 && run->errnum != XP_AWK_EIOHANDLER)
+ n = sse_awk_closeextio (run, name);
+ if (n == -1 && run->errnum != SSE_AWK_EIOHANDLER)
{
- if (a0->type != XP_AWK_VAL_STR)
- XP_AWK_FREE (run->awk, name);
+ if (a0->type != SSE_AWK_VAL_STR)
+ SSE_AWK_FREE (run->awk, name);
return -1;
}
- if (a0->type != XP_AWK_VAL_STR) XP_AWK_FREE (run->awk, name);
+ if (a0->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, name);
skip_close:
- v = xp_awk_makeintval (run, n);
- if (v == XP_NULL)
+ v = sse_awk_makeintval (run, n);
+ if (v == SSE_NULL)
{
- xp_awk_setrunerrnum (run, XP_AWK_ENOMEM);
+ sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
return -1;
}
- xp_awk_setretval (run, v);
+ sse_awk_setretval (run, v);
return 0;
}
static int __flush_extio (
- xp_awk_run_t* run, int extio, const xp_char_t* name, int n)
+ sse_awk_run_t* run, int extio, const sse_char_t* name, int n)
{
int n2;
- if (run->extio.handler[extio] != XP_NULL)
+ if (run->extio.handler[extio] != SSE_NULL)
{
- n2 = xp_awk_flushextio (run, extio, name);
+ n2 = sse_awk_flushextio (run, extio, name);
if (n2 == -1)
{
- if (run->errnum == XP_AWK_EIOHANDLER) n = -1;
- else if (run->errnum == XP_AWK_ENOSUCHIO)
+ if (run->errnum == SSE_AWK_EIOHANDLER) n = -1;
+ else if (run->errnum == SSE_AWK_ENOSUCHIO)
{
if (n != 0) n = -2;
}
@@ -245,24 +245,24 @@ static int __flush_extio (
return n;
}
-static int __bfn_fflush (xp_awk_run_t* run)
+static int __bfn_fflush (sse_awk_run_t* run)
{
- xp_size_t nargs;
- xp_awk_val_t* a0;
- xp_char_t* str0;
- xp_size_t len0;
+ sse_size_t nargs;
+ sse_awk_val_t* a0;
+ sse_char_t* str0;
+ sse_size_t len0;
int n;
- nargs = xp_awk_getnargs (run);
- xp_awk_assert (run->awk, nargs >= 0 && nargs <= 1);
+ nargs = sse_awk_getnargs (run);
+ sse_awk_assert (run->awk, nargs >= 0 && nargs <= 1);
if (nargs == 0)
{
/* flush the console output */
- n = xp_awk_flushextio (run, XP_AWK_OUT_CONSOLE, XP_T(""));
+ n = sse_awk_flushextio (run, SSE_AWK_OUT_CONSOLE, SSE_T(""));
if (n == -1 &&
- run->errnum != XP_AWK_EIOHANDLER &&
- run->errnum != XP_AWK_ENOSUCHIO)
+ run->errnum != SSE_AWK_EIOHANDLER &&
+ run->errnum != SSE_AWK_ENOSUCHIO)
{
return -1;
}
@@ -271,19 +271,19 @@ static int __bfn_fflush (xp_awk_run_t* run)
}
else
{
- xp_char_t* ptr, * end;
+ sse_char_t* ptr, * end;
- a0 = xp_awk_getarg (run, 0);
- if (a0->type == XP_AWK_VAL_STR)
+ a0 = sse_awk_getarg (run, 0);
+ if (a0->type == SSE_AWK_VAL_STR)
{
- str0 = ((xp_awk_val_str_t*)a0)->buf;
- len0 = ((xp_awk_val_str_t*)a0)->len;
+ str0 = ((sse_awk_val_str_t*)a0)->buf;
+ len0 = ((sse_awk_val_str_t*)a0)->len;
}
else
{
- str0 = xp_awk_valtostr (
- run, a0, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &len0);
- if (str0 == XP_NULL) return -1;
+ str0 = sse_awk_valtostr (
+ run, a0, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len0);
+ if (str0 == SSE_NULL) return -1;
}
@@ -292,10 +292,10 @@ static int __bfn_fflush (xp_awk_run_t* run)
ptr = str0; end = str0 + len0;
while (ptr < end)
{
- if (*ptr == XP_T('\0'))
+ if (*ptr == SSE_T('\0'))
{
- if (a0->type != XP_AWK_VAL_STR)
- XP_AWK_FREE (run->awk, str0);
+ if (a0->type != SSE_AWK_VAL_STR)
+ SSE_AWK_FREE (run->awk, str0);
n = -1;
goto skip_flush;
}
@@ -307,16 +307,16 @@ static int __bfn_fflush (xp_awk_run_t* run)
n = 1;
n = __flush_extio (
- run, XP_AWK_EXTIO_FILE,
- ((len0 == 0)? XP_NULL: str0), 1);
+ run, SSE_AWK_EXTIO_FILE,
+ ((len0 == 0)? SSE_NULL: str0), 1);
if (n == -99) return -1;
n = __flush_extio (
- run, XP_AWK_EXTIO_PIPE,
- ((len0 == 0)? XP_NULL: str0), n);
+ run, SSE_AWK_EXTIO_PIPE,
+ ((len0 == 0)? SSE_NULL: str0), n);
if (n == -99) return -1;
n = __flush_extio (
- run, XP_AWK_EXTIO_COPROC,
- ((len0 == 0)? XP_NULL: str0), n);
+ run, SSE_AWK_EXTIO_COPROC,
+ ((len0 == 0)? SSE_NULL: str0), n);
if (n == -99) return -1;
/* if n remains 1, no ip handlers have been defined for
@@ -325,273 +325,273 @@ static int __bfn_fflush (xp_awk_run_t* run)
* if n is -1, the io handler has returned an error */
if (n != 0) n = -1;
- if (a0->type != XP_AWK_VAL_STR) XP_AWK_FREE (run->awk, str0);
+ if (a0->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str0);
}
skip_flush:
- a0 = xp_awk_makeintval (run, (xp_long_t)n);
- if (a0 == XP_NULL)
+ a0 = sse_awk_makeintval (run, (sse_long_t)n);
+ if (a0 == SSE_NULL)
{
- xp_awk_setrunerrnum (run, XP_AWK_ENOMEM);
+ sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
return -1;
}
- xp_awk_setretval (run, a0);
+ sse_awk_setretval (run, a0);
return 0;
}
-static int __bfn_index (xp_awk_run_t* run)
+static int __bfn_index (sse_awk_run_t* run)
{
- xp_size_t nargs;
- xp_awk_val_t* a0, * a1;
- xp_char_t* str0, * str1, * ptr;
- xp_size_t len0, len1;
- xp_long_t idx;
+ sse_size_t nargs;
+ sse_awk_val_t* a0, * a1;
+ sse_char_t* str0, * str1, * ptr;
+ sse_size_t len0, len1;
+ sse_long_t idx;
- nargs = xp_awk_getnargs (run);
- xp_awk_assert (run->awk, nargs == 2);
+ nargs = sse_awk_getnargs (run);
+ sse_awk_assert (run->awk, nargs == 2);
- a0 = xp_awk_getarg (run, 0);
- a1 = xp_awk_getarg (run, 1);
+ a0 = sse_awk_getarg (run, 0);
+ a1 = sse_awk_getarg (run, 1);
- if (a0->type == XP_AWK_VAL_STR)
+ if (a0->type == SSE_AWK_VAL_STR)
{
- str0 = ((xp_awk_val_str_t*)a0)->buf;
- len0 = ((xp_awk_val_str_t*)a0)->len;
+ str0 = ((sse_awk_val_str_t*)a0)->buf;
+ len0 = ((sse_awk_val_str_t*)a0)->len;
}
else
{
- str0 = xp_awk_valtostr (
- run, a0, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &len0);
- if (str0 == XP_NULL) return -1;
+ str0 = sse_awk_valtostr (
+ run, a0, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len0);
+ if (str0 == SSE_NULL) return -1;
}
- if (a1->type == XP_AWK_VAL_STR)
+ if (a1->type == SSE_AWK_VAL_STR)
{
- str1 = ((xp_awk_val_str_t*)a1)->buf;
- len1 = ((xp_awk_val_str_t*)a1)->len;
+ str1 = ((sse_awk_val_str_t*)a1)->buf;
+ len1 = ((sse_awk_val_str_t*)a1)->len;
}
else
{
- str1 = xp_awk_valtostr (
- run, a1, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &len1);
- if (str1 == XP_NULL)
+ str1 = sse_awk_valtostr (
+ run, a1, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len1);
+ if (str1 == SSE_NULL)
{
- if (a0->type != XP_AWK_VAL_STR)
- XP_AWK_FREE (run->awk, str0);
+ if (a0->type != SSE_AWK_VAL_STR)
+ SSE_AWK_FREE (run->awk, str0);
return -1;
}
}
- ptr = xp_awk_strxnstr (str0, len0, str1, len1);
- idx = (ptr == XP_NULL)? -1: (xp_long_t)(ptr - str0);
+ ptr = sse_awk_strxnstr (str0, len0, str1, len1);
+ idx = (ptr == SSE_NULL)? -1: (sse_long_t)(ptr - str0);
- if (xp_awk_getopt(run->awk) & XP_AWK_STRINDEXONE) idx = idx + 1;
+ if (sse_awk_getopt(run->awk) & SSE_AWK_STRINDEXONE) idx = idx + 1;
- if (a0->type != XP_AWK_VAL_STR) XP_AWK_FREE (run->awk, str0);
- if (a1->type != XP_AWK_VAL_STR) XP_AWK_FREE (run->awk, str1);
+ if (a0->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str0);
+ if (a1->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str1);
- a0 = xp_awk_makeintval (run, idx);
- if (a0 == XP_NULL)
+ a0 = sse_awk_makeintval (run, idx);
+ if (a0 == SSE_NULL)
{
- xp_awk_setrunerrnum (run, XP_AWK_ENOMEM);
+ sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
return -1;
}
- xp_awk_setretval (run, a0);
+ sse_awk_setretval (run, a0);
return 0;
}
-static int __bfn_length (xp_awk_run_t* run)
+static int __bfn_length (sse_awk_run_t* run)
{
- xp_size_t nargs;
- xp_awk_val_t* v;
- xp_char_t* str;
- xp_size_t len;
+ sse_size_t nargs;
+ sse_awk_val_t* v;
+ sse_char_t* str;
+ sse_size_t len;
- nargs = xp_awk_getnargs (run);
- xp_awk_assert (run->awk, nargs == 1);
+ nargs = sse_awk_getnargs (run);
+ sse_awk_assert (run->awk, nargs == 1);
- v = xp_awk_getarg (run, 0);
- if (v->type == XP_AWK_VAL_STR)
+ v = sse_awk_getarg (run, 0);
+ if (v->type == SSE_AWK_VAL_STR)
{
- len = ((xp_awk_val_str_t*)v)->len;
+ len = ((sse_awk_val_str_t*)v)->len;
}
else
{
- str = xp_awk_valtostr (
- run, v, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &len);
- if (str == XP_NULL) return -1;
- XP_AWK_FREE (run->awk, str);
+ str = sse_awk_valtostr (
+ run, v, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
+ if (str == SSE_NULL) return -1;
+ SSE_AWK_FREE (run->awk, str);
}
- v = xp_awk_makeintval (run, len);
- if (v == XP_NULL)
+ v = sse_awk_makeintval (run, len);
+ if (v == SSE_NULL)
{
- xp_awk_setrunerrnum (run, XP_AWK_ENOMEM);
+ sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
return -1;
}
- xp_awk_setretval (run, v);
+ sse_awk_setretval (run, v);
return 0;
}
-static int __bfn_substr (xp_awk_run_t* run)
+static int __bfn_substr (sse_awk_run_t* run)
{
- xp_size_t nargs;
- xp_awk_val_t* a0, * a1, * a2, * r;
- xp_char_t* str;
- xp_size_t len;
- xp_long_t lindex, lcount;
- xp_real_t rindex, rcount;
+ sse_size_t nargs;
+ sse_awk_val_t* a0, * a1, * a2, * r;
+ sse_char_t* str;
+ sse_size_t len;
+ sse_long_t lindex, lcount;
+ sse_real_t rindex, rcount;
int n;
- nargs = xp_awk_getnargs (run);
- xp_awk_assert (run->awk, nargs >= 2 && nargs <= 3);
+ nargs = sse_awk_getnargs (run);
+ sse_awk_assert (run->awk, nargs >= 2 && nargs <= 3);
- a0 = xp_awk_getarg (run, 0);
- a1 = xp_awk_getarg (run, 1);
- a2 = (nargs >= 3)? xp_awk_getarg (run, 2): XP_NULL;
+ a0 = sse_awk_getarg (run, 0);
+ a1 = sse_awk_getarg (run, 1);
+ a2 = (nargs >= 3)? sse_awk_getarg (run, 2): SSE_NULL;
- if (a0->type == XP_AWK_VAL_STR)
+ if (a0->type == SSE_AWK_VAL_STR)
{
- str = ((xp_awk_val_str_t*)a0)->buf;
- len = ((xp_awk_val_str_t*)a0)->len;
+ str = ((sse_awk_val_str_t*)a0)->buf;
+ len = ((sse_awk_val_str_t*)a0)->len;
}
else
{
- str = xp_awk_valtostr (
- run, a0, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &len);
- if (str == XP_NULL) return -1;
+ str = sse_awk_valtostr (
+ run, a0, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
+ if (str == SSE_NULL) return -1;
}
- n = xp_awk_valtonum (run, a1, &lindex, &rindex);
+ n = sse_awk_valtonum (run, a1, &lindex, &rindex);
if (n == -1)
{
- if (a0->type != XP_AWK_VAL_STR) XP_AWK_FREE (run->awk, str);
+ if (a0->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str);
return -1;
}
- if (n == 1) lindex = (xp_long_t)rindex;
+ if (n == 1) lindex = (sse_long_t)rindex;
- if (a2 == XP_NULL) lcount = (xp_long_t)len;
+ if (a2 == SSE_NULL) lcount = (sse_long_t)len;
else
{
- n = xp_awk_valtonum (run, a2, &lcount, &rcount);
+ n = sse_awk_valtonum (run, a2, &lcount, &rcount);
if (n == -1)
{
- if (a0->type != XP_AWK_VAL_STR)
- XP_AWK_FREE (run->awk, str);
+ if (a0->type != SSE_AWK_VAL_STR)
+ SSE_AWK_FREE (run->awk, str);
return -1;
}
- if (n == 1) lcount = (xp_long_t)rcount;
+ if (n == 1) lcount = (sse_long_t)rcount;
}
- if (xp_awk_getopt(run->awk) & XP_AWK_STRINDEXONE) lindex = lindex - 1;
+ if (sse_awk_getopt(run->awk) & SSE_AWK_STRINDEXONE) lindex = lindex - 1;
if (lindex >= len) lindex = len;
else if (lindex < 0) lindex = 0;
if (lcount < 0) lcount = 0;
else if (lcount > len - lindex) lcount = len - lindex;
- r = xp_awk_makestrval (run, &str[lindex], (xp_size_t)lcount);
- if (r == XP_NULL)
+ r = sse_awk_makestrval (run, &str[lindex], (sse_size_t)lcount);
+ if (r == SSE_NULL)
{
- if (a0->type != XP_AWK_VAL_STR) XP_AWK_FREE (run->awk, str);
- xp_awk_setrunerrnum (run, XP_AWK_ENOMEM);
+ if (a0->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str);
+ sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
return -1;
}
- if (a0->type != XP_AWK_VAL_STR) XP_AWK_FREE (run->awk, str);
- xp_awk_setretval (run, r);
+ if (a0->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str);
+ sse_awk_setretval (run, r);
return 0;
}
-static int __bfn_split (xp_awk_run_t* run)
+static int __bfn_split (sse_awk_run_t* run)
{
- xp_size_t nargs;
- xp_awk_val_t* a0, * a1, * a2, * t1, * t2, ** a1_ref;
- xp_char_t* str, * str_free, * p, * tok;
- xp_size_t str_len, str_left, tok_len;
- xp_long_t sta, num;
- xp_char_t key[xp_sizeof(xp_long_t)*8+2];
- xp_size_t key_len;
- xp_char_t* fs_ptr, * fs_free;
- xp_size_t fs_len;
- void* fs_rex = XP_NULL;
- void* fs_rex_free = XP_NULL;
+ sse_size_t nargs;
+ sse_awk_val_t* a0, * a1, * a2, * t1, * t2, ** a1_ref;
+ sse_char_t* str, * str_free, * p, * tok;
+ sse_size_t str_len, str_left, tok_len;
+ sse_long_t sta, num;
+ sse_char_t key[sse_sizeof(sse_long_t)*8+2];
+ sse_size_t key_len;
+ sse_char_t* fs_ptr, * fs_free;
+ sse_size_t fs_len;
+ void* fs_rex = SSE_NULL;
+ void* fs_rex_free = SSE_NULL;
int errnum;
- nargs = xp_awk_getnargs (run);
- xp_awk_assert (run->awk, nargs >= 2 && nargs <= 3);
+ nargs = sse_awk_getnargs (run);
+ sse_awk_assert (run->awk, nargs >= 2 && nargs <= 3);
- a0 = xp_awk_getarg (run, 0);
- a1 = xp_awk_getarg (run, 1);
- a2 = (nargs >= 3)? xp_awk_getarg (run, 2): XP_NULL;
+ a0 = sse_awk_getarg (run, 0);
+ a1 = sse_awk_getarg (run, 1);
+ a2 = (nargs >= 3)? sse_awk_getarg (run, 2): SSE_NULL;
- xp_awk_assert (run->awk, a1->type == XP_AWK_VAL_REF);
+ sse_awk_assert (run->awk, a1->type == SSE_AWK_VAL_REF);
- if (((xp_awk_val_ref_t*)a1)->id >= XP_AWK_VAL_REF_NAMEDIDX &&
- ((xp_awk_val_ref_t*)a1)->id <= XP_AWK_VAL_REF_ARGIDX)
+ if (((sse_awk_val_ref_t*)a1)->id >= SSE_AWK_VAL_REF_NAMEDIDX &&
+ ((sse_awk_val_ref_t*)a1)->id <= SSE_AWK_VAL_REF_ARGIDX)
{
/* an indexed value should not be assigned another map */
- xp_awk_setrunerrnum (run, XP_AWK_EIDXVALASSMAP);
+ sse_awk_setrunerrnum (run, SSE_AWK_EIDXVALASSMAP);
return -1;
}
- if (((xp_awk_val_ref_t*)a1)->id == XP_AWK_VAL_REF_POS)
+ if (((sse_awk_val_ref_t*)a1)->id == SSE_AWK_VAL_REF_POS)
{
/* a positional should not be assigned a map */
- xp_awk_setrunerrnum (run, XP_AWK_EPOSVALASSMAP);
+ sse_awk_setrunerrnum (run, SSE_AWK_EPOSVALASSMAP);
return -1;
}
- a1_ref = (xp_awk_val_t**)((xp_awk_val_ref_t*)a1)->adr;
- if ((*a1_ref)->type != XP_AWK_VAL_NIL &&
- (*a1_ref)->type != XP_AWK_VAL_MAP)
+ a1_ref = (sse_awk_val_t**)((sse_awk_val_ref_t*)a1)->adr;
+ if ((*a1_ref)->type != SSE_AWK_VAL_NIL &&
+ (*a1_ref)->type != SSE_AWK_VAL_MAP)
{
/* cannot change a scalar value to a map */
- xp_awk_setrunerrnum (run, XP_AWK_ESCALARTOMAP);
+ sse_awk_setrunerrnum (run, SSE_AWK_ESCALARTOMAP);
return -1;
}
- if (a0->type == XP_AWK_VAL_STR)
+ if (a0->type == SSE_AWK_VAL_STR)
{
- str = ((xp_awk_val_str_t*)a0)->buf;
- str_len = ((xp_awk_val_str_t*)a0)->len;
- str_free = XP_NULL;
+ str = ((sse_awk_val_str_t*)a0)->buf;
+ str_len = ((sse_awk_val_str_t*)a0)->len;
+ str_free = SSE_NULL;
}
else
{
- str = xp_awk_valtostr (
- run, a0, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &str_len);
- if (str == XP_NULL) return -1;
+ str = sse_awk_valtostr (
+ run, a0, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &str_len);
+ if (str == SSE_NULL) return -1;
str_free = str;
}
- if (a2 == XP_NULL)
+ if (a2 == SSE_NULL)
{
/* get the value from FS */
- t1 = xp_awk_getglobal (run, XP_AWK_GLOBAL_FS);
- if (t1->type == XP_AWK_VAL_NIL)
+ t1 = sse_awk_getglobal (run, SSE_AWK_GLOBAL_FS);
+ if (t1->type == SSE_AWK_VAL_NIL)
{
- fs_ptr = XP_T(" ");
+ fs_ptr = SSE_T(" ");
fs_len = 1;
- fs_free = XP_NULL;
+ fs_free = SSE_NULL;
}
- else if (t1->type == XP_AWK_VAL_STR)
+ else if (t1->type == SSE_AWK_VAL_STR)
{
- fs_ptr = ((xp_awk_val_str_t*)t1)->buf;
- fs_len = ((xp_awk_val_str_t*)t1)->len;
- fs_free = XP_NULL;
+ fs_ptr = ((sse_awk_val_str_t*)t1)->buf;
+ fs_len = ((sse_awk_val_str_t*)t1)->len;
+ fs_free = SSE_NULL;
}
else
{
- fs_ptr = xp_awk_valtostr (
- run, t1, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &fs_len);
- if (fs_ptr == XP_NULL)
+ fs_ptr = sse_awk_valtostr (
+ run, t1, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &fs_len);
+ if (fs_ptr == SSE_NULL)
{
- if (str_free != XP_NULL)
- XP_AWK_FREE (run->awk, str_free);
+ if (str_free != SSE_NULL)
+ SSE_AWK_FREE (run->awk, str_free);
return -1;
}
fs_free = fs_ptr;
@@ -600,25 +600,25 @@ static int __bfn_split (xp_awk_run_t* run)
if (fs_len > 1)
{
fs_rex = run->global.fs;
- fs_rex_free = XP_NULL;
+ fs_rex_free = SSE_NULL;
}
}
else
{
- if (a2->type == XP_AWK_VAL_STR)
+ if (a2->type == SSE_AWK_VAL_STR)
{
- fs_ptr = ((xp_awk_val_str_t*)a2)->buf;
- fs_len = ((xp_awk_val_str_t*)a2)->len;
- fs_free = XP_NULL;
+ fs_ptr = ((sse_awk_val_str_t*)a2)->buf;
+ fs_len = ((sse_awk_val_str_t*)a2)->len;
+ fs_free = SSE_NULL;
}
else
{
- fs_ptr = xp_awk_valtostr (
- run, a2, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &fs_len);
- if (fs_ptr == XP_NULL)
+ fs_ptr = sse_awk_valtostr (
+ run, a2, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &fs_len);
+ if (fs_ptr == SSE_NULL)
{
- if (str_free != XP_NULL)
- XP_AWK_FREE (run->awk, str_free);
+ if (str_free != SSE_NULL)
+ SSE_AWK_FREE (run->awk, str_free);
return -1;
}
fs_free = fs_ptr;
@@ -626,113 +626,113 @@ static int __bfn_split (xp_awk_run_t* run)
if (fs_len > 1)
{
- fs_rex = xp_awk_buildrex (
+ fs_rex = sse_awk_buildrex (
run->awk, fs_ptr, fs_len, &errnum);
- if (fs_rex == XP_NULL)
+ if (fs_rex == SSE_NULL)
{
- if (str_free != XP_NULL)
- XP_AWK_FREE (run->awk, str_free);
- if (fs_free != XP_NULL)
- XP_AWK_FREE (run->awk, fs_free);
- xp_awk_setrunerrnum (run, errnum);
+ if (str_free != SSE_NULL)
+ SSE_AWK_FREE (run->awk, str_free);
+ if (fs_free != SSE_NULL)
+ SSE_AWK_FREE (run->awk, fs_free);
+ sse_awk_setrunerrnum (run, errnum);
return -1;
}
fs_rex_free = fs_rex;
}
}
- t1 = xp_awk_makemapval (run);
- if (t1 == XP_NULL)
+ t1 = sse_awk_makemapval (run);
+ if (t1 == SSE_NULL)
{
- if (str_free != XP_NULL)
- XP_AWK_FREE (run->awk, str_free);
- if (fs_free != XP_NULL)
- XP_AWK_FREE (run->awk, fs_free);
- if (fs_rex_free != XP_NULL)
- xp_awk_freerex (run->awk, fs_rex_free);
- xp_awk_setrunerrnum (run, XP_AWK_ENOMEM);
+ if (str_free != SSE_NULL)
+ SSE_AWK_FREE (run->awk, str_free);
+ if (fs_free != SSE_NULL)
+ SSE_AWK_FREE (run->awk, fs_free);
+ if (fs_rex_free != SSE_NULL)
+ sse_awk_freerex (run->awk, fs_rex_free);
+ sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
return -1;
}
- xp_awk_refdownval (run, *a1_ref);
+ sse_awk_refdownval (run, *a1_ref);
*a1_ref = t1;
- xp_awk_refupval (*a1_ref);
+ sse_awk_refupval (*a1_ref);
p = str; str_left = str_len;
- sta = (xp_awk_getopt(run->awk) & XP_AWK_STRINDEXONE)? 1: 0;
+ sta = (sse_awk_getopt(run->awk) & SSE_AWK_STRINDEXONE)? 1: 0;
num = sta;
- while (p != XP_NULL)
+ while (p != SSE_NULL)
{
if (fs_len <= 1)
{
- p = xp_awk_strxntok (run,
+ p = sse_awk_strxntok (run,
p, str_len, fs_ptr, fs_len, &tok, &tok_len);
}
else
{
- p = xp_awk_strxntokbyrex (run, p, str_len,
+ p = sse_awk_strxntokbyrex (run, p, str_len,
fs_rex, &tok, &tok_len, &errnum);
- if (p == XP_NULL && errnum != XP_AWK_ENOERR)
+ if (p == SSE_NULL && errnum != SSE_AWK_ENOERR)
{
- if (str_free != XP_NULL)
- XP_AWK_FREE (run->awk, str_free);
- if (fs_free != XP_NULL)
- XP_AWK_FREE (run->awk, fs_free);
- if (fs_rex_free != XP_NULL)
- xp_awk_freerex (run->awk, fs_rex_free);
- xp_awk_setrunerrnum (run, errnum);
+ if (str_free != SSE_NULL)
+ SSE_AWK_FREE (run->awk, str_free);
+ if (fs_free != SSE_NULL)
+ SSE_AWK_FREE (run->awk, fs_free);
+ if (fs_rex_free != SSE_NULL)
+ sse_awk_freerex (run->awk, fs_rex_free);
+ sse_awk_setrunerrnum (run, errnum);
return -1;
}
}
- if (num == 0 && p == XP_NULL && tok_len == 0)
+ if (num == 0 && p == SSE_NULL && tok_len == 0)
{
/* no field at all*/
break;
}
- xp_awk_assert (run->awk,
- (tok != XP_NULL && tok_len > 0) || tok_len == 0);
+ sse_awk_assert (run->awk,
+ (tok != SSE_NULL && tok_len > 0) || tok_len == 0);
/* create the field string */
- t2 = xp_awk_makestrval (run, tok, tok_len);
- if (t2 == XP_NULL)
+ t2 = sse_awk_makestrval (run, tok, tok_len);
+ if (t2 == SSE_NULL)
{
- if (str_free != XP_NULL)
- XP_AWK_FREE (run->awk, str_free);
- if (fs_free != XP_NULL)
- XP_AWK_FREE (run->awk, fs_free);
- if (fs_rex_free != XP_NULL)
- xp_awk_freerex (run->awk, fs_rex_free);
- xp_awk_setrunerrnum (run, XP_AWK_ENOMEM);
+ if (str_free != SSE_NULL)
+ SSE_AWK_FREE (run->awk, str_free);
+ if (fs_free != SSE_NULL)
+ SSE_AWK_FREE (run->awk, fs_free);
+ if (fs_rex_free != SSE_NULL)
+ sse_awk_freerex (run->awk, fs_rex_free);
+ sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
return -1;
}
/* put it into the map */
- key_len = xp_awk_longtostr (
- num, 10, XP_NULL, key, xp_countof(key));
- xp_awk_assert (run->awk, key_len != (xp_size_t)-1);
+ key_len = sse_awk_longtostr (
+ num, 10, SSE_NULL, key, sse_countof(key));
+ sse_awk_assert (run->awk, key_len != (sse_size_t)-1);
/* don't forget to update the reference count when you
* handle the assignment-like situation. anyway, it is
* incremented in advance as if the assignment was successful.
* it is decremented if the assignement fails. */
- xp_awk_refupval (t2);
+ sse_awk_refupval (t2);
- if (xp_awk_map_putx (
- ((xp_awk_val_map_t*)t1)->map,
- key, key_len, t2, XP_NULL) == -1)
+ if (sse_awk_map_putx (
+ ((sse_awk_val_map_t*)t1)->map,
+ key, key_len, t2, SSE_NULL) == -1)
{
- xp_awk_refdownval (run, t2);
+ sse_awk_refdownval (run, t2);
- if (str_free != XP_NULL)
- XP_AWK_FREE (run->awk, str_free);
- if (fs_free != XP_NULL)
- XP_AWK_FREE (run->awk, fs_free);
- if (fs_rex_free != XP_NULL)
- xp_awk_freerex (run->awk, fs_rex_free);
- xp_awk_setrunerrnum (run, XP_AWK_ENOMEM);
+ if (str_free != SSE_NULL)
+ SSE_AWK_FREE (run->awk, str_free);
+ if (fs_free != SSE_NULL)
+ SSE_AWK_FREE (run->awk, fs_free);
+ if (fs_rex_free != SSE_NULL)
+ sse_awk_freerex (run->awk, fs_rex_free);
+ sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
return -1;
}
@@ -740,151 +740,151 @@ static int __bfn_split (xp_awk_run_t* run)
str_len = str_left - (p - str);
}
- if (str_free != XP_NULL) XP_AWK_FREE (run->awk, str_free);
- if (fs_free != XP_NULL) XP_AWK_FREE (run->awk, fs_free);
- if (fs_rex_free != XP_NULL) xp_awk_freerex (run->awk, fs_rex_free);
+ if (str_free != SSE_NULL) SSE_AWK_FREE (run->awk, str_free);
+ if (fs_free != SSE_NULL) SSE_AWK_FREE (run->awk, fs_free);
+ if (fs_rex_free != SSE_NULL) sse_awk_freerex (run->awk, fs_rex_free);
if (sta == 1) num--;
- t1 = xp_awk_makeintval (run, num);
- if (t1 == XP_NULL)
+ t1 = sse_awk_makeintval (run, num);
+ if (t1 == SSE_NULL)
{
- xp_awk_setrunerrnum (run, XP_AWK_ENOMEM);
+ sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
return -1;
}
- xp_awk_setretval (run, t1);
+ sse_awk_setretval (run, t1);
return 0;
}
-static int __bfn_tolower (xp_awk_run_t* run)
+static int __bfn_tolower (sse_awk_run_t* run)
{
- xp_size_t nargs;
- xp_char_t* str;
- xp_size_t len, i;
- xp_awk_val_t* a0, * r;
+ sse_size_t nargs;
+ sse_char_t* str;
+ sse_size_t len, i;
+ sse_awk_val_t* a0, * r;
- nargs = xp_awk_getnargs (run);
- xp_awk_assert (run->awk, nargs == 1);
+ nargs = sse_awk_getnargs (run);
+ sse_awk_assert (run->awk, nargs == 1);
- a0 = xp_awk_getarg (run, 0);
+ a0 = sse_awk_getarg (run, 0);
- if (a0->type == XP_AWK_VAL_STR)
+ if (a0->type == SSE_AWK_VAL_STR)
{
- str = ((xp_awk_val_str_t*)a0)->buf;
- len = ((xp_awk_val_str_t*)a0)->len;
+ str = ((sse_awk_val_str_t*)a0)->buf;
+ len = ((sse_awk_val_str_t*)a0)->len;
}
else
{
- str = xp_awk_valtostr (
- run, a0, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &len);
- if (str == XP_NULL) return -1;
+ str = sse_awk_valtostr (
+ run, a0, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
+ if (str == SSE_NULL) return -1;
}
- for (i = 0; i < len; i++) str[i] = XP_AWK_TOLOWER (run->awk, str[i]);
+ for (i = 0; i < len; i++) str[i] = SSE_AWK_TOLOWER (run->awk, str[i]);
- r = xp_awk_makestrval (run, str, len);
- if (r == XP_NULL)
+ r = sse_awk_makestrval (run, str, len);
+ if (r == SSE_NULL)
{
- if (a0->type != XP_AWK_VAL_STR) XP_AWK_FREE (run->awk, str);
- xp_awk_setrunerrnum (run, XP_AWK_ENOMEM);
+ if (a0->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str);
+ sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
return -1;
}
- if (a0->type != XP_AWK_VAL_STR) XP_AWK_FREE (run->awk, str);
- xp_awk_setretval (run, r);
+ if (a0->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str);
+ sse_awk_setretval (run, r);
return 0;
}
-static int __bfn_toupper (xp_awk_run_t* run)
+static int __bfn_toupper (sse_awk_run_t* run)
{
- xp_size_t nargs;
- xp_char_t* str;
- xp_size_t len, i;
- xp_awk_val_t* a0, * r;
+ sse_size_t nargs;
+ sse_char_t* str;
+ sse_size_t len, i;
+ sse_awk_val_t* a0, * r;
- nargs = xp_awk_getnargs (run);
- xp_awk_assert (run->awk, nargs == 1);
+ nargs = sse_awk_getnargs (run);
+ sse_awk_assert (run->awk, nargs == 1);
- a0 = xp_awk_getarg (run, 0);
+ a0 = sse_awk_getarg (run, 0);
- if (a0->type == XP_AWK_VAL_STR)
+ if (a0->type == SSE_AWK_VAL_STR)
{
- str = ((xp_awk_val_str_t*)a0)->buf;
- len = ((xp_awk_val_str_t*)a0)->len;
+ str = ((sse_awk_val_str_t*)a0)->buf;
+ len = ((sse_awk_val_str_t*)a0)->len;
}
else
{
- str = xp_awk_valtostr (
- run, a0, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &len);
- if (str == XP_NULL) return -1;
+ str = sse_awk_valtostr (
+ run, a0, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
+ if (str == SSE_NULL) return -1;
}
- for (i = 0; i < len; i++) str[i] = XP_AWK_TOUPPER (run->awk, str[i]);
+ for (i = 0; i < len; i++) str[i] = SSE_AWK_TOUPPER (run->awk, str[i]);
- r = xp_awk_makestrval (run, str, len);
- if (r == XP_NULL)
+ r = sse_awk_makestrval (run, str, len);
+ if (r == SSE_NULL)
{
- if (a0->type != XP_AWK_VAL_STR) XP_AWK_FREE (run->awk, str);
- xp_awk_setrunerrnum (run, XP_AWK_ENOMEM);
+ if (a0->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str);
+ sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
return -1;
}
- if (a0->type != XP_AWK_VAL_STR) XP_AWK_FREE (run->awk, str);
- xp_awk_setretval (run, r);
+ if (a0->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str);
+ sse_awk_setretval (run, r);
return 0;
}
-static int __substitute (xp_awk_run_t* run, xp_long_t max_count)
+static int __substitute (sse_awk_run_t* run, sse_long_t max_count)
{
- xp_size_t nargs;
- xp_awk_val_t* a0, * a1, * a2, ** a2_ref, * v;
- xp_char_t* a0_ptr, * a1_ptr, * a2_ptr;
- xp_size_t a0_len, a1_len, a2_len;
- xp_char_t* a0_ptr_free = XP_NULL;
- xp_char_t* a1_ptr_free = XP_NULL;
- xp_char_t* a2_ptr_free = XP_NULL;
+ sse_size_t nargs;
+ sse_awk_val_t* a0, * a1, * a2, ** a2_ref, * v;
+ sse_char_t* a0_ptr, * a1_ptr, * a2_ptr;
+ sse_size_t a0_len, a1_len, a2_len;
+ sse_char_t* a0_ptr_free = SSE_NULL;
+ sse_char_t* a1_ptr_free = SSE_NULL;
+ sse_char_t* a2_ptr_free = SSE_NULL;
void* rex;
int opt, n;
- const xp_char_t* cur_ptr, * mat_ptr;
- xp_size_t cur_len, mat_len, i, m;
- xp_awk_str_t new;
- xp_long_t sub_count;
+ const sse_char_t* cur_ptr, * mat_ptr;
+ sse_size_t cur_len, mat_len, i, m;
+ sse_awk_str_t new;
+ sse_long_t sub_count;
- nargs = xp_awk_getnargs (run);
- xp_awk_assert (run->awk, nargs >= 2 && nargs <= 3);
+ nargs = sse_awk_getnargs (run);
+ sse_awk_assert (run->awk, nargs >= 2 && nargs <= 3);
- a0 = xp_awk_getarg (run, 0);
- a1 = xp_awk_getarg (run, 1);
- a2 = (nargs >= 3)? xp_awk_getarg (run, 2): XP_NULL;
+ a0 = sse_awk_getarg (run, 0);
+ a1 = sse_awk_getarg (run, 1);
+ a2 = (nargs >= 3)? sse_awk_getarg (run, 2): SSE_NULL;
- xp_awk_assert (run->awk, a2 == XP_NULL || a2->type == XP_AWK_VAL_REF);
+ sse_awk_assert (run->awk, a2 == SSE_NULL || a2->type == SSE_AWK_VAL_REF);
#define FREE_A_PTRS(awk) \
do { \
- if (a2_ptr_free != XP_NULL) XP_AWK_FREE (awk, a2_ptr_free); \
- if (a1_ptr_free != XP_NULL) XP_AWK_FREE (awk, a1_ptr_free); \
- if (a0_ptr_free != XP_NULL) XP_AWK_FREE (awk, a0_ptr_free); \
+ if (a2_ptr_free != SSE_NULL) SSE_AWK_FREE (awk, a2_ptr_free); \
+ if (a1_ptr_free != SSE_NULL) SSE_AWK_FREE (awk, a1_ptr_free); \
+ if (a0_ptr_free != SSE_NULL) SSE_AWK_FREE (awk, a0_ptr_free); \
} while (0)
#define FREE_A0_REX(awk,rex) \
do { \
- if (a0->type != XP_AWK_VAL_REX) xp_awk_freerex (awk, rex); \
+ if (a0->type != SSE_AWK_VAL_REX) sse_awk_freerex (awk, rex); \
} while (0)
- if (a0->type == XP_AWK_VAL_REX)
+ if (a0->type == SSE_AWK_VAL_REX)
{
- rex = ((xp_awk_val_rex_t*)a0)->code;
+ rex = ((sse_awk_val_rex_t*)a0)->code;
}
- else if (a0->type == XP_AWK_VAL_STR)
+ else if (a0->type == SSE_AWK_VAL_STR)
{
- a0_ptr = ((xp_awk_val_str_t*)a0)->buf;
- a0_len = ((xp_awk_val_str_t*)a0)->len;
+ a0_ptr = ((sse_awk_val_str_t*)a0)->buf;
+ a0_len = ((sse_awk_val_str_t*)a0)->len;
}
else
{
- a0_ptr = xp_awk_valtostr (
- run, a0, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &a0_len);
- if (a0_ptr == XP_NULL)
+ a0_ptr = sse_awk_valtostr (
+ run, a0, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &a0_len);
+ if (a0_ptr == SSE_NULL)
{
FREE_A_PTRS (run->awk);
return -1;
@@ -892,16 +892,16 @@ static int __substitute (xp_awk_run_t* run, xp_long_t max_count)
a0_ptr_free = a0_ptr;
}
- if (a1->type == XP_AWK_VAL_STR)
+ if (a1->type == SSE_AWK_VAL_STR)
{
- a1_ptr = ((xp_awk_val_str_t*)a1)->buf;
- a1_len = ((xp_awk_val_str_t*)a1)->len;
+ a1_ptr = ((sse_awk_val_str_t*)a1)->buf;
+ a1_len = ((sse_awk_val_str_t*)a1)->len;
}
else
{
- a1_ptr = xp_awk_valtostr (
- run, a1, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &a1_len);
- if (a1_ptr == XP_NULL)
+ a1_ptr = sse_awk_valtostr (
+ run, a1, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &a1_len);
+ if (a1_ptr == SSE_NULL)
{
FREE_A_PTRS (run->awk);
return -1;
@@ -909,21 +909,21 @@ static int __substitute (xp_awk_run_t* run, xp_long_t max_count)
a1_ptr_free = a1_ptr;
}
- if (a2 == XP_NULL)
+ if (a2 == SSE_NULL)
{
/* is this correct? any needs to use inrec.d0? */
- a2_ptr = XP_AWK_STR_BUF(&run->inrec.line);
- a2_len = XP_AWK_STR_LEN(&run->inrec.line);
+ a2_ptr = SSE_AWK_STR_BUF(&run->inrec.line);
+ a2_len = SSE_AWK_STR_LEN(&run->inrec.line);
}
- else if (((xp_awk_val_ref_t*)a2)->id == XP_AWK_VAL_REF_POS)
+ else if (((sse_awk_val_ref_t*)a2)->id == SSE_AWK_VAL_REF_POS)
{
- xp_size_t idx;
+ sse_size_t idx;
- idx = (xp_size_t)((xp_awk_val_ref_t*)a2)->adr;
+ idx = (sse_size_t)((sse_awk_val_ref_t*)a2)->adr;
if (idx == 0)
{
- a2_ptr = XP_AWK_STR_BUF(&run->inrec.line);
- a2_len = XP_AWK_STR_LEN(&run->inrec.line);
+ a2_ptr = SSE_AWK_STR_BUF(&run->inrec.line);
+ a2_len = SSE_AWK_STR_LEN(&run->inrec.line);
}
else if (idx <= run->inrec.nflds)
{
@@ -932,32 +932,32 @@ static int __substitute (xp_awk_run_t* run, xp_long_t max_count)
}
else
{
- a2_ptr = XP_T("");
+ a2_ptr = SSE_T("");
a2_len = 0;
}
}
else
{
- a2_ref = (xp_awk_val_t**)((xp_awk_val_ref_t*)a2)->adr;
+ a2_ref = (sse_awk_val_t**)((sse_awk_val_ref_t*)a2)->adr;
- if ((*a2_ref)->type == XP_AWK_VAL_MAP)
+ if ((*a2_ref)->type == SSE_AWK_VAL_MAP)
{
FREE_A_PTRS (run->awk);
/* a map is not allowed as the third parameter */
- xp_awk_setrunerrnum (run, XP_AWK_EMAPNOTALLOWED);
+ sse_awk_setrunerrnum (run, SSE_AWK_EMAPNOTALLOWED);
return -1;
}
- if ((*a2_ref)->type == XP_AWK_VAL_STR)
+ if ((*a2_ref)->type == SSE_AWK_VAL_STR)
{
- a2_ptr = ((xp_awk_val_str_t*)(*a2_ref))->buf;
- a2_len = ((xp_awk_val_str_t*)(*a2_ref))->len;
+ a2_ptr = ((sse_awk_val_str_t*)(*a2_ref))->buf;
+ a2_len = ((sse_awk_val_str_t*)(*a2_ref))->len;
}
else
{
- a2_ptr = xp_awk_valtostr (
- run, *a2_ref, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &a2_len);
- if (a2_ptr == XP_NULL)
+ a2_ptr = sse_awk_valtostr (
+ run, *a2_ref, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &a2_len);
+ if (a2_ptr == SSE_NULL)
{
FREE_A_PTRS (run->awk);
return -1;
@@ -966,25 +966,25 @@ static int __substitute (xp_awk_run_t* run, xp_long_t max_count)
}
}
- if (xp_awk_str_open (&new, a2_len, run->awk) == XP_NULL)
+ if (sse_awk_str_open (&new, a2_len, run->awk) == SSE_NULL)
{
FREE_A_PTRS (run->awk);
- xp_awk_setrunerrnum (run, XP_AWK_ENOMEM);
+ sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
return -1;
}
- if (a0->type != XP_AWK_VAL_REX)
+ if (a0->type != SSE_AWK_VAL_REX)
{
- rex = xp_awk_buildrex (run->awk, a0_ptr, a0_len, &run->errnum);
- if (rex == XP_NULL)
+ rex = sse_awk_buildrex (run->awk, a0_ptr, a0_len, &run->errnum);
+ if (rex == SSE_NULL)
{
- xp_awk_str_close (&new);
+ sse_awk_str_close (&new);
FREE_A_PTRS (run->awk);
return -1;
}
}
- opt = (run->global.ignorecase)? XP_AWK_REX_IGNORECASE: 0;
+ opt = (run->global.ignorecase)? SSE_AWK_REX_IGNORECASE: 0;
cur_ptr = a2_ptr;
cur_len = a2_len;
sub_count = 0;
@@ -993,7 +993,7 @@ static int __substitute (xp_awk_run_t* run, xp_long_t max_count)
{
if (max_count == 0 || sub_count < max_count)
{
- n = xp_awk_matchrex (
+ n = sse_awk_matchrex (
run->awk, rex, opt, cur_ptr, cur_len,
&mat_ptr, &mat_len, &run->errnum);
}
@@ -1002,7 +1002,7 @@ static int __substitute (xp_awk_run_t* run, xp_long_t max_count)
if (n == -1)
{
FREE_A0_REX (run->awk, rex);
- xp_awk_str_close (&new);
+ sse_awk_str_close (&new);
FREE_A_PTRS (run->awk);
return -1;
}
@@ -1010,22 +1010,22 @@ static int __substitute (xp_awk_run_t* run, xp_long_t max_count)
if (n == 0)
{
/* no more match found */
- if (xp_awk_str_ncat (
- &new, cur_ptr, cur_len) == (xp_size_t)-1)
+ if (sse_awk_str_ncat (
+ &new, cur_ptr, cur_len) == (sse_size_t)-1)
{
FREE_A0_REX (run->awk, rex);
- xp_awk_str_close (&new);
+ sse_awk_str_close (&new);
FREE_A_PTRS (run->awk);
return -1;
}
break;
}
- if (xp_awk_str_ncat (
- &new, cur_ptr, mat_ptr - cur_ptr) == (xp_size_t)-1)
+ if (sse_awk_str_ncat (
+ &new, cur_ptr, mat_ptr - cur_ptr) == (sse_size_t)-1)
{
FREE_A0_REX (run->awk, rex);
- xp_awk_str_close (&new);
+ sse_awk_str_close (&new);
FREE_A_PTRS (run->awk);
return -1;
}
@@ -1033,25 +1033,25 @@ static int __substitute (xp_awk_run_t* run, xp_long_t max_count)
for (i = 0; i < a1_len; i++)
{
if ((i+1) < a1_len &&
- a1_ptr[i] == XP_T('\\') &&
- a1_ptr[i+1] == XP_T('&'))
+ a1_ptr[i] == SSE_T('\\') &&
+ a1_ptr[i+1] == SSE_T('&'))
{
- m = xp_awk_str_ccat (&new, XP_T('&'));
+ m = sse_awk_str_ccat (&new, SSE_T('&'));
i++;
}
- else if (a1_ptr[i] == XP_T('&'))
+ else if (a1_ptr[i] == SSE_T('&'))
{
- m = xp_awk_str_ncat (&new, mat_ptr, mat_len);
+ m = sse_awk_str_ncat (&new, mat_ptr, mat_len);
}
else
{
- m = xp_awk_str_ccat (&new, a1_ptr[i]);
+ m = sse_awk_str_ccat (&new, a1_ptr[i]);
}
- if (m == (xp_size_t)-1)
+ if (m == (sse_size_t)-1)
{
FREE_A0_REX (run->awk, rex);
- xp_awk_str_close (&new);
+ sse_awk_str_close (&new);
FREE_A_PTRS (run->awk);
return -1;
}
@@ -1066,207 +1066,207 @@ static int __substitute (xp_awk_run_t* run, xp_long_t max_count)
if (sub_count > 0)
{
- if (a2 == XP_NULL)
+ if (a2 == SSE_NULL)
{
- if (xp_awk_setrec (run, 0,
- XP_AWK_STR_BUF(&new), XP_AWK_STR_LEN(&new)) == -1)
+ if (sse_awk_setrec (run, 0,
+ SSE_AWK_STR_BUF(&new), SSE_AWK_STR_LEN(&new)) == -1)
{
- xp_awk_str_close (&new);
+ sse_awk_str_close (&new);
FREE_A_PTRS (run->awk);
return -1;
}
}
- else if (((xp_awk_val_ref_t*)a2)->id == XP_AWK_VAL_REF_POS)
+ else if (((sse_awk_val_ref_t*)a2)->id == SSE_AWK_VAL_REF_POS)
{
int n;
- n = xp_awk_setrec (
- run, (xp_size_t)((xp_awk_val_ref_t*)a2)->adr,
- XP_AWK_STR_BUF(&new), XP_AWK_STR_LEN(&new));
+ n = sse_awk_setrec (
+ run, (sse_size_t)((sse_awk_val_ref_t*)a2)->adr,
+ SSE_AWK_STR_BUF(&new), SSE_AWK_STR_LEN(&new));
if (n == -1)
{
- xp_awk_str_close (&new);
+ sse_awk_str_close (&new);
FREE_A_PTRS (run->awk);
return -1;
}
}
else
{
- v = xp_awk_makestrval (run,
- XP_AWK_STR_BUF(&new), XP_AWK_STR_LEN(&new));
- if (v == XP_NULL)
+ v = sse_awk_makestrval (run,
+ SSE_AWK_STR_BUF(&new), SSE_AWK_STR_LEN(&new));
+ if (v == SSE_NULL)
{
- xp_awk_str_close (&new);
+ sse_awk_str_close (&new);
FREE_A_PTRS (run->awk);
return -1;
}
- xp_awk_refdownval (run, *a2_ref);
+ sse_awk_refdownval (run, *a2_ref);
*a2_ref = v;
- xp_awk_refupval (*a2_ref);
+ sse_awk_refupval (*a2_ref);
}
}
- xp_awk_str_close (&new);
+ sse_awk_str_close (&new);
FREE_A_PTRS (run->awk);
#undef FREE_A0_REX
#undef FREE_A_PTRS
- v = xp_awk_makeintval (run, sub_count);
- if (v == XP_NULL)
+ v = sse_awk_makeintval (run, sub_count);
+ if (v == SSE_NULL)
{
- xp_awk_setrunerrnum (run, XP_AWK_ENOMEM);
+ sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
return -1;
}
- xp_awk_setretval (run, v);
+ sse_awk_setretval (run, v);
return 0;
}
-static int __bfn_gsub (xp_awk_run_t* run)
+static int __bfn_gsub (sse_awk_run_t* run)
{
return __substitute (run, 0);
}
-static int __bfn_sub (xp_awk_run_t* run)
+static int __bfn_sub (sse_awk_run_t* run)
{
return __substitute (run, 1);
}
-static int __bfn_match (xp_awk_run_t* run)
+static int __bfn_match (sse_awk_run_t* run)
{
- xp_size_t nargs;
- xp_awk_val_t* a0, * a1;
- xp_char_t* str0, * str1;
- xp_size_t len0, len1;
- xp_long_t idx;
+ sse_size_t nargs;
+ sse_awk_val_t* a0, * a1;
+ sse_char_t* str0, * str1;
+ sse_size_t len0, len1;
+ sse_long_t idx;
void* rex;
int opt, n;
- const xp_char_t* mat_ptr;
- xp_size_t mat_len;
+ const sse_char_t* mat_ptr;
+ sse_size_t mat_len;
- nargs = xp_awk_getnargs (run);
- xp_awk_assert (run->awk, nargs == 2);
+ nargs = sse_awk_getnargs (run);
+ sse_awk_assert (run->awk, nargs == 2);
- a0 = xp_awk_getarg (run, 0);
- a1 = xp_awk_getarg (run, 1);
+ a0 = sse_awk_getarg (run, 0);
+ a1 = sse_awk_getarg (run, 1);
- if (a0->type == XP_AWK_VAL_STR)
+ if (a0->type == SSE_AWK_VAL_STR)
{
- str0 = ((xp_awk_val_str_t*)a0)->buf;
- len0 = ((xp_awk_val_str_t*)a0)->len;
+ str0 = ((sse_awk_val_str_t*)a0)->buf;
+ len0 = ((sse_awk_val_str_t*)a0)->len;
}
else
{
- str0 = xp_awk_valtostr (
- run, a0, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &len0);
- if (str0 == XP_NULL) return -1;
+ str0 = sse_awk_valtostr (
+ run, a0, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len0);
+ if (str0 == SSE_NULL) return -1;
}
- if (a1->type == XP_AWK_VAL_REX)
+ if (a1->type == SSE_AWK_VAL_REX)
{
- rex = ((xp_awk_val_rex_t*)a1)->code;
+ rex = ((sse_awk_val_rex_t*)a1)->code;
}
else
{
- if (a1->type == XP_AWK_VAL_STR)
+ if (a1->type == SSE_AWK_VAL_STR)
{
- str1 = ((xp_awk_val_str_t*)a1)->buf;
- len1 = ((xp_awk_val_str_t*)a1)->len;
+ str1 = ((sse_awk_val_str_t*)a1)->buf;
+ len1 = ((sse_awk_val_str_t*)a1)->len;
}
else
{
- str1 = xp_awk_valtostr (
- run, a1, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &len1);
- if (str1 == XP_NULL)
+ str1 = sse_awk_valtostr (
+ run, a1, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len1);
+ if (str1 == SSE_NULL)
{
- if (a0->type != XP_AWK_VAL_STR)
- XP_AWK_FREE (run->awk, str0);
+ if (a0->type != SSE_AWK_VAL_STR)
+ SSE_AWK_FREE (run->awk, str0);
return -1;
}
}
- rex = xp_awk_buildrex (run->awk, str1, len1, &run->errnum);
- if (rex == XP_NULL)
+ rex = sse_awk_buildrex (run->awk, str1, len1, &run->errnum);
+ if (rex == SSE_NULL)
{
- if (a0->type != XP_AWK_VAL_STR)
- XP_AWK_FREE (run->awk, str0);
+ if (a0->type != SSE_AWK_VAL_STR)
+ SSE_AWK_FREE (run->awk, str0);
return -1;
}
- if (a1->type != XP_AWK_VAL_STR) XP_AWK_FREE (run->awk, str1);
+ if (a1->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str1);
}
- opt = (run->global.ignorecase)? XP_AWK_REX_IGNORECASE: 0;
- n = xp_awk_matchrex (
+ opt = (run->global.ignorecase)? SSE_AWK_REX_IGNORECASE: 0;
+ n = sse_awk_matchrex (
run->awk, rex, opt, str0, len0,
&mat_ptr, &mat_len, &run->errnum);
- if (a0->type != XP_AWK_VAL_STR) XP_AWK_FREE (run->awk, str0);
- if (a1->type != XP_AWK_VAL_REX) xp_awk_freerex (run->awk, rex);
+ if (a0->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str0);
+ if (a1->type != SSE_AWK_VAL_REX) sse_awk_freerex (run->awk, rex);
if (n == -1) return -1;
- idx = (n == 0)? -1: (xp_long_t)(mat_ptr - str0);
- if (xp_awk_getopt(run->awk) & XP_AWK_STRINDEXONE) idx = idx + 1;
+ idx = (n == 0)? -1: (sse_long_t)(mat_ptr - str0);
+ if (sse_awk_getopt(run->awk) & SSE_AWK_STRINDEXONE) idx = idx + 1;
- a0 = xp_awk_makeintval (run, idx);
- if (a0 == XP_NULL)
+ a0 = sse_awk_makeintval (run, idx);
+ if (a0 == SSE_NULL)
{
- xp_awk_setrunerrnum (run, XP_AWK_ENOMEM);
+ sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
return -1;
}
- xp_awk_refupval (a0);
+ sse_awk_refupval (a0);
- a1 = xp_awk_makeintval (run,
- ((n == 0)? (xp_long_t)-1: (xp_long_t)mat_len));
- if (a1 == XP_NULL)
+ a1 = sse_awk_makeintval (run,
+ ((n == 0)? (sse_long_t)-1: (sse_long_t)mat_len));
+ if (a1 == SSE_NULL)
{
- xp_awk_refdownval (run, a0);
- xp_awk_setrunerrnum (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, a0);
+ sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
return -1;
}
- xp_awk_refupval (a1);
+ sse_awk_refupval (a1);
- if (xp_awk_setglobal (run, XP_AWK_GLOBAL_RSTART, a0) == -1)
+ if (sse_awk_setglobal (run, SSE_AWK_GLOBAL_RSTART, a0) == -1)
{
- xp_awk_refdownval (run, a1);
- xp_awk_refdownval (run, a0);
+ sse_awk_refdownval (run, a1);
+ sse_awk_refdownval (run, a0);
return -1;
}
- if (xp_awk_setglobal (run, XP_AWK_GLOBAL_RLENGTH, a1) == -1)
+ if (sse_awk_setglobal (run, SSE_AWK_GLOBAL_RLENGTH, a1) == -1)
{
- xp_awk_refdownval (run, a1);
- xp_awk_refdownval (run, a0);
+ sse_awk_refdownval (run, a1);
+ sse_awk_refdownval (run, a0);
return -1;
}
- xp_awk_setretval (run, a0);
+ sse_awk_setretval (run, a0);
- xp_awk_refdownval (run, a1);
- xp_awk_refdownval (run, a0);
+ sse_awk_refdownval (run, a1);
+ sse_awk_refdownval (run, a0);
return 0;
}
-static int __bfn_system (xp_awk_run_t* run)
+static int __bfn_system (sse_awk_run_t* run)
{
- xp_size_t nargs;
- xp_char_t* cmd;
- xp_awk_val_t* v;
+ sse_size_t nargs;
+ sse_char_t* cmd;
+ sse_awk_val_t* v;
int n;
- nargs = xp_awk_getnargs (run);
- xp_awk_assert (run->awk, nargs == 1);
+ nargs = sse_awk_getnargs (run);
+ sse_awk_assert (run->awk, nargs == 1);
- cmd = xp_awk_valtostr (
- run, xp_awk_getarg(run, 0),
- XP_AWK_VALTOSTR_CLEAR, XP_NULL, XP_NULL);
- if (cmd == XP_NULL) return -1;
+ cmd = sse_awk_valtostr (
+ run, sse_awk_getarg(run, 0),
+ SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, SSE_NULL);
+ if (cmd == SSE_NULL) return -1;
#ifdef _WIN32
n = _tsystem (cmd);
@@ -1275,56 +1275,56 @@ static int __bfn_system (xp_awk_run_t* run)
n = -1;
#endif
- XP_AWK_FREE (run->awk, cmd);
+ SSE_AWK_FREE (run->awk, cmd);
- v = xp_awk_makeintval (run, n);
- if (v == XP_NULL)
+ v = sse_awk_makeintval (run, n);
+ if (v == SSE_NULL)
{
- xp_awk_setrunerrnum (run, XP_AWK_ENOMEM);
+ sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
return -1;
}
- xp_awk_setretval (run, v);
+ sse_awk_setretval (run, v);
return 0;
}
/* math functions */
#if 0
-static int __bfn_sin (xp_awk_run_t* run)
+static int __bfn_sin (sse_awk_run_t* run)
{
- xp_size_t nargs;
- xp_awk_val_t* v;
+ sse_size_t nargs;
+ sse_awk_val_t* v;
int n;
- xp_long_t lv;
- xp_real_t rv;
+ sse_long_t lv;
+ sse_real_t rv;
- nargs = xp_awk_getnargs (run);
- xp_awk_assert (run->awk, nargs == 1);
+ nargs = sse_awk_getnargs (run);
+ sse_awk_assert (run->awk, nargs == 1);
- n = xp_awk_valtonum (run, xp_awk_getarg(run, 0), &lv, &rv);
+ n = sse_awk_valtonum (run, sse_awk_getarg(run, 0), &lv, &rv);
if (n == -1)
{
/* wrong value */
return -1;
}
- if (n == 0) rv = (xp_real_t)lv;
+ if (n == 0) rv = (sse_real_t)lv;
-#if (XP_SIZEOF_REAL == XP_SIZEOF_LONG_DOUBLE)
- v = xp_awk_makerealval (run, (xp_real_t)sinl(rv));
-#elif (XP_SIZEOF_REAL == XP_SIZEOF_DOUBLE)
- v = xp_awk_makerealval (run, (xp_real_t)sin(rv));
+#if (SSE_SIZEOF_REAL == SSE_SIZEOF_LONG_DOUBLE)
+ v = sse_awk_makerealval (run, (sse_real_t)sinl(rv));
+#elif (SSE_SIZEOF_REAL == SSE_SIZEOF_DOUBLE)
+ v = sse_awk_makerealval (run, (sse_real_t)sin(rv));
#else
#error unsupported floating-point data type
#endif
- if (v == XP_NULL)
+ if (v == SSE_NULL)
{
- xp_awk_setrunerrnum (run, XP_AWK_ENOMEM);
+ sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
return -1;
}
- xp_awk_setretval (run, v);
+ sse_awk_setretval (run, v);
return 0;
}
#endif
diff --git a/ase/awk/func.h b/ase/awk/func.h
index 30a6071b..79cf83c4 100644
--- a/ase/awk/func.h
+++ b/ase/awk/func.h
@@ -1,39 +1,39 @@
/*
- * $Id: func.h,v 1.12 2006-10-10 07:02:38 bacon Exp $
+ * $Id: func.h,v 1.13 2006-10-22 11:34:53 bacon Exp $
*/
-#ifndef _XP_AWK_FUNC_H_
-#define _XP_AWK_FUNC_H_
+#ifndef _SSE_AWK_FUNC_H_
+#define _SSE_AWK_FUNC_H_
-#ifndef _XP_AWK_AWK_H_
-#error Never include this file directly. Include <xp/awk/awk.h> instead
+#ifndef _SSE_AWK_AWK_H_
+#error Never include this file directly. Include <sse/awk/awk.h> instead
#endif
-typedef struct xp_awk_bfn_t xp_awk_bfn_t;
+typedef struct sse_awk_bfn_t sse_awk_bfn_t;
-struct xp_awk_bfn_t
+struct sse_awk_bfn_t
{
- const xp_char_t* name;
- xp_size_t name_len;
+ const sse_char_t* name;
+ sse_size_t name_len;
int valid; /* the entry is valid when this option is set */
- xp_size_t min_args;
- xp_size_t max_args;
- const xp_char_t* arg_spec;
- int (*handler) (xp_awk_run_t* run);
+ sse_size_t min_args;
+ sse_size_t max_args;
+ const sse_char_t* arg_spec;
+ int (*handler) (sse_awk_run_t* run);
- xp_awk_bfn_t* next;
+ sse_awk_bfn_t* next;
};
enum
{
/* ensure that this matches __sys_bfn in func.c */
- XP_AWK_BFN_CLOSE,
- XP_AWK_BFN_INDEX,
- XP_AWK_BFN_LENGTH,
- XP_AWK_BFN_SYSTEM,
- XP_AWK_BFN_SIN
+ SSE_AWK_BFN_CLOSE,
+ SSE_AWK_BFN_INDEX,
+ SSE_AWK_BFN_LENGTH,
+ SSE_AWK_BFN_SYSTEM,
+ SSE_AWK_BFN_SIN
};
@@ -41,17 +41,17 @@ enum
extern "C" {
#endif
-xp_awk_bfn_t* xp_awk_addbfn (
- xp_awk_t* awk, const xp_char_t* name, xp_size_t name_len,
- int when_valid, xp_size_t min_args, xp_size_t max_args,
- const xp_char_t* arg_spec, int (*handler)(xp_awk_run_t*));
+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*));
-int xp_awk_delbfn (xp_awk_t* awk, const xp_char_t* name, xp_size_t name_len);
+int sse_awk_delbfn (sse_awk_t* awk, const sse_char_t* name, sse_size_t name_len);
-void xp_awk_clrbfn (xp_awk_t* awk);
+void sse_awk_clrbfn (sse_awk_t* awk);
-xp_awk_bfn_t* xp_awk_getbfn (
- xp_awk_t* awk, const xp_char_t* name, xp_size_t name_len);
+sse_awk_bfn_t* sse_awk_getbfn (
+ sse_awk_t* awk, const sse_char_t* name, sse_size_t name_len);
#ifdef __cplusplus
}
diff --git a/ase/awk/jni.c b/ase/awk/jni.c
index 1ce8fbcc..f1e0c189 100644
--- a/ase/awk/jni.c
+++ b/ase/awk/jni.c
@@ -1,16 +1,16 @@
/*
- * $Id: jni.c,v 1.11 2006-10-22 07:05:34 bacon Exp $
+ * $Id: jni.c,v 1.12 2006-10-22 11:34:53 bacon Exp $
*/
-#include <xp/awk/jni.h>
-#include <xp/awk/awk.h>
+#include <sse/awk/jni.h>
+#include <sse/awk/awk.h>
#include <stdlib.h>
#include <string.h>
#include <wctype.h>
#include <wchar.h>
#include <stdio.h>
-#define EXCEPTION_AWK "xpkit/xpj/awk/AwkException"
+#define EXCEPTION_AWK "ssekit/ssej/awk/AwkException"
#define FIELD_AWK "__awk"
enum
@@ -19,16 +19,16 @@ enum
SOURCE_WRITE = 2
};
-/* TODO: what if xp_char_t is xp_mchar_t??? */
+/* TODO: what if sse_char_t is sse_mchar_t??? */
-static xp_ssize_t __read_source (
- int cmd, void* arg, xp_char_t* data, xp_size_t count);
-static xp_ssize_t __write_source (
- int cmd, void* arg, xp_char_t* data, xp_size_t count);
-static xp_ssize_t __process_extio_console (
- int cmd, void* arg, xp_char_t* data, xp_size_t count);
-static xp_ssize_t __process_extio_file (
- int cmd, void* arg, xp_char_t* data, xp_size_t count);
+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);
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 (xp_size_t n, void* custom_data)
+static void* __awk_malloc (sse_size_t n, void* custom_data)
{
return malloc (n);
}
-static void* __awk_realloc (void* ptr, xp_size_t n, void* custom_data)
+static void* __awk_realloc (void* ptr, sse_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_xpkit_xpj_awk_Awk_open (JNIEnv* env, jobject obj)
+JNIESSEORT void JNICALL Java_ssekit_ssej_awk_Awk_open (JNIEnv* env, jobject obj)
{
jclass class;
jfieldID fid;
jthrowable except;
- xp_awk_t* awk;
- xp_awk_syscas_t syscas;
+ sse_awk_t* awk;
+ sse_awk_syscas_t syscas;
int opt;
class = (*env)->GetObjectClass(env, obj);
@@ -103,7 +103,7 @@ JNIEXPORT void JNICALL Java_xpkit_xpj_awk_Awk_open (JNIEnv* env, jobject obj)
syscas.abort = abort;
#endif
- awk = xp_awk_open (&syscas);
+ awk = sse_awk_open (&syscas);
if (awk == NULL)
{
except = (*env)->FindClass (env, EXCEPTION_AWK);
@@ -117,15 +117,15 @@ JNIEXPORT void JNICALL Java_xpkit_xpj_awk_Awk_open (JNIEnv* env, jobject obj)
(*env)->SetLongField (env, obj, fid, (jlong)awk);
- opt = XP_AWK_EXPLICIT | XP_AWK_UNIQUE | XP_AWK_DBLSLASHES |
- XP_AWK_SHADING | XP_AWK_IMPLICIT | XP_AWK_SHIFT |
- XP_AWK_EXTIO | XP_AWK_BLOCKLESS;
- xp_awk_setopt (awk, opt);
+ opt = SSE_AWK_ESSELICIT | 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);
printf ("__awk(native) done => %u, 0x%X\n", awk, awk);
}
-JNIEXPORT void JNICALL Java_xpkit_xpj_awk_Awk_close (JNIEnv* env, jobject obj)
+JNIESSEORT void JNICALL Java_ssekit_ssej_awk_Awk_close (JNIEnv* env, jobject obj)
{
jclass class;
jfieldID fid;
@@ -135,20 +135,20 @@ JNIEXPORT void JNICALL Java_xpkit_xpj_awk_Awk_close (JNIEnv* env, jobject obj)
fid = (*env)->GetFieldID (env, class, FIELD_AWK, "J");
if (fid == 0) return;
- xp_awk_close ((xp_awk_t*) (*env)->GetLongField (env, obj, fid));
+ sse_awk_close ((sse_awk_t*) (*env)->GetLongField (env, obj, fid));
(*env)->SetLongField (env, obj, fid, (jlong)0);
printf ("close (native) done\n");
}
-JNIEXPORT void JNICALL Java_xpkit_xpj_awk_Awk_parse (JNIEnv* env, jobject obj)
+JNIESSEORT void JNICALL Java_ssekit_ssej_awk_Awk_parse (JNIEnv* env, jobject obj)
{
jclass class;
jfieldID fid;
jthrowable except;
- xp_awk_t* awk;
- xp_awk_srcios_t srcios;
+ sse_awk_t* awk;
+ sse_awk_srcios_t srcios;
srcio_data_t srcio_data;
class = (*env)->GetObjectClass (env, obj);
@@ -156,7 +156,7 @@ JNIEXPORT void JNICALL Java_xpkit_xpj_awk_Awk_parse (JNIEnv* env, jobject obj)
fid = (*env)->GetFieldID (env, class, FIELD_AWK, "J");
if (fid == 0) return;
- awk = (xp_awk_t*) (*env)->GetLongField (env, obj, fid);
+ awk = (sse_awk_t*) (*env)->GetLongField (env, obj, fid);
srcio_data.env = env;
srcio_data.obj = obj;
@@ -165,25 +165,25 @@ JNIEXPORT void JNICALL Java_xpkit_xpj_awk_Awk_parse (JNIEnv* env, jobject obj)
srcios.out = __write_source;
srcios.custom_data = &srcio_data;
- if (xp_awk_parse (awk, &srcios) == -1)
+ if (sse_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", xp_awk_getsrcline(awk), xp_awk_geterrstr(xp_awk_geterrnum(awk)));
+printf ("parse error -> line [%d] %S\n", sse_awk_getsrcline(awk), sse_awk_geterrstr(sse_awk_geterrnum(awk)));
return;
}
}
-JNIEXPORT void JNICALL Java_xpkit_xpj_awk_Awk_run (JNIEnv* env, jobject obj)
+JNIESSEORT void JNICALL Java_ssekit_ssej_awk_Awk_run (JNIEnv* env, jobject obj)
{
jclass class;
jfieldID fid;
jthrowable except;
- xp_awk_t* awk;
- xp_awk_runios_t runios;
+ sse_awk_t* awk;
+ sse_awk_runios_t runios;
runio_data_t runio_data;
class = (*env)->GetObjectClass (env, obj);
@@ -191,18 +191,18 @@ JNIEXPORT void JNICALL Java_xpkit_xpj_awk_Awk_run (JNIEnv* env, jobject obj)
fid = (*env)->GetFieldID (env, class, FIELD_AWK, "J");
if (fid == 0) return;
- awk = (xp_awk_t*) (*env)->GetLongField (env, obj, fid);
+ awk = (sse_awk_t*) (*env)->GetLongField (env, obj, fid);
runio_data.env = env;
runio_data.obj = obj;
- runios.pipe = XP_NULL;
- runios.coproc = XP_NULL;
+ runios.pipe = SSE_NULL;
+ runios.coproc = SSE_NULL;
runios.file = __process_extio_file;
runios.console = __process_extio_console;
runios.custom_data = &runio_data;
- if (xp_awk_run (awk, &runios, XP_NULL, XP_NULL) == -1)
+ if (sse_awk_run (awk, &runios, SSE_NULL, SSE_NULL) == -1)
{
except = (*env)->FindClass (env, EXCEPTION_AWK);
if (except == 0) return;
@@ -211,21 +211,21 @@ JNIEXPORT void JNICALL Java_xpkit_xpj_awk_Awk_run (JNIEnv* env, jobject obj)
}
}
-JNIEXPORT void JNICALL Java_xpkit_xpj_awk_Awk_set_1extio (
+JNIESSEORT void JNICALL Java_ssekit_ssej_awk_Awk_set_1extio (
JNIEnv* env, jobject obj, jlong extio, jobject handle)
{
- xp_awk_extio_t* epa = (xp_awk_extio_t*)extio;
+ sse_awk_extio_t* epa = (sse_awk_extio_t*)extio;
epa->handle = (void*)handle;
}
-JNIEXPORT jobject JNICALL Java_xpkit_xpj_awk_Awk_get_1extio (
+JNIESSEORT jobject JNICALL Java_ssekit_ssej_awk_Awk_get_1extio (
JNIEnv* env, jobject obj, jlong extio)
{
- xp_awk_extio_t* epa = (xp_awk_extio_t*)extio;
+ sse_awk_extio_t* epa = (sse_awk_extio_t*)extio;
return (jobject)epa->handle;
}
-static xp_ssize_t __call_java_open_source (JNIEnv* env, jobject obj, int mode)
+static sse_ssize_t __call_java_open_source (JNIEnv* env, jobject obj, int mode)
{
jclass class;
jmethodID mid;
@@ -248,7 +248,7 @@ static xp_ssize_t __call_java_open_source (JNIEnv* env, jobject obj, int mode)
return ret;
}
-static xp_ssize_t __call_java_close_source (JNIEnv* env, jobject obj, int mode)
+static sse_ssize_t __call_java_close_source (JNIEnv* env, jobject obj, int mode)
{
jclass class;
jmethodID mid;
@@ -271,8 +271,8 @@ static xp_ssize_t __call_java_close_source (JNIEnv* env, jobject obj, int mode)
return ret;
}
-static xp_ssize_t __call_java_read_source (
- JNIEnv* env, jobject obj, xp_char_t* buf, xp_size_t size)
+static sse_ssize_t __call_java_read_source (
+ JNIEnv* env, jobject obj, sse_char_t* buf, sse_size_t size)
{
jclass class;
jmethodID mid;
@@ -298,15 +298,15 @@ static xp_ssize_t __call_java_read_source (
}
tmp = (*env)->GetCharArrayElements (env, array, 0);
- for (i = 0; i < ret; i++) buf[i] = (xp_char_t)tmp[i];
+ for (i = 0; i < ret; i++) buf[i] = (sse_char_t)tmp[i];
(*env)->ReleaseCharArrayElements (env, array, tmp, 0);
(*env)->DeleteLocalRef (env, array);
return i;
}
-static xp_ssize_t __call_java_write_source (
- JNIEnv* env, jobject obj, xp_char_t* buf, xp_size_t size)
+static sse_ssize_t __call_java_write_source (
+ JNIEnv* env, jobject obj, sse_char_t* buf, sse_size_t size)
{
jclass class;
jmethodID mid;
@@ -339,8 +339,8 @@ static xp_ssize_t __call_java_write_source (
return ret;
}
-static xp_ssize_t __call_java_open_extio (
- JNIEnv* env, jobject obj, char* meth, xp_awk_extio_t* extio)
+static sse_ssize_t __call_java_open_extio (
+ JNIEnv* env, jobject obj, char* meth, sse_awk_extio_t* extio)
{
jclass class;
jmethodID mid;
@@ -349,7 +349,7 @@ static xp_ssize_t __call_java_open_extio (
class = (*env)->GetObjectClass(env, obj);
- if (extio == XP_NULL)
+ if (extio == SSE_NULL)
{
mid = (*env)->GetMethodID (env, class, meth, "()I");
if (mid == 0) return -1;
@@ -366,7 +366,7 @@ static xp_ssize_t __call_java_open_extio (
if (mid == 0) return -1;
name_str = (*env)->NewString (
- env, extio->name, xp_awk_strlen(extio->name));
+ env, extio->name, sse_awk_strlen(extio->name));
if (name_str == 0) return -1;
ret = (*env)->CallIntMethod (env, obj, mid, name_str);
@@ -377,7 +377,7 @@ static xp_ssize_t __call_java_open_extio (
jmethodID extio_cons;
jobject extio_object;
- extio_class = (*env)->FindClass (env, "xpkit/xpj/awk/Extio");
+ extio_class = (*env)->FindClass (env, "ssekit/ssej/awk/Extio");
if (extio_class == NULL) return -1;
extio_cons = (*env)->GetMethodID (
@@ -385,7 +385,7 @@ static xp_ssize_t __call_java_open_extio (
if (extio_cons == NULL) return -1;
mid = (*env)->GetMethodID (
- env, class, meth, "(Lxpkit/xpj/awk/Extio;)I");
+ env, class, meth, "(Lssekit/ssej/awk/Extio;)I");
if (mid == NULL) return -1;
extio_object = (*env)->NewObject (
@@ -405,8 +405,8 @@ static xp_ssize_t __call_java_open_extio (
return ret;
}
-static xp_ssize_t __call_java_close_extio (
- JNIEnv* env, jobject obj, char* meth, xp_awk_extio_t* extio)
+static sse_ssize_t __call_java_close_extio (
+ JNIEnv* env, jobject obj, char* meth, sse_awk_extio_t* extio)
{
jclass class;
jmethodID mid;
@@ -415,7 +415,7 @@ static xp_ssize_t __call_java_close_extio (
class = (*env)->GetObjectClass(env, obj);
- if (extio == XP_NULL)
+ if (extio == SSE_NULL)
{
mid = (*env)->GetMethodID (env, class, meth, "()I");
if (mid == 0) return -1;
@@ -431,7 +431,7 @@ static xp_ssize_t __call_java_close_extio (
if (mid == 0) return -1;
name_str = (*env)->NewString (
- env, extio->name, xp_awk_strlen(extio->name));
+ env, extio->name, sse_awk_strlen(extio->name));
if (name_str == 0) return -1;
ret = (*env)->CallIntMethod (env, obj, mid, name_str);
@@ -448,8 +448,8 @@ static xp_ssize_t __call_java_close_extio (
return ret;
}
-static xp_ssize_t __call_java_read_extio (
- JNIEnv* env, jobject obj, char* meth, xp_char_t* buf, xp_size_t size)
+static sse_ssize_t __call_java_read_extio (
+ JNIEnv* env, jobject obj, char* meth, sse_char_t* buf, sse_size_t size)
{
jclass class;
jmethodID mid;
@@ -475,20 +475,20 @@ static xp_ssize_t __call_java_read_extio (
}
tmp = (*env)->GetCharArrayElements (env, array, 0);
- for (i = 0; i < ret; i++) buf[i] = (xp_char_t)tmp[i];
+ for (i = 0; i < ret; i++) buf[i] = (sse_char_t)tmp[i];
(*env)->ReleaseCharArrayElements (env, array, tmp, 0);
(*env)->DeleteLocalRef (env, array);
return ret;
}
-static xp_ssize_t __call_java_write_extio (
- JNIEnv* env, jobject obj, char* meth, xp_char_t* data, xp_size_t size)
+static sse_ssize_t __call_java_write_extio (
+ JNIEnv* env, jobject obj, char* meth, sse_char_t* data, sse_size_t size)
{
jclass class;
jmethodID mid;
jcharArray array;
- xp_ssize_t i;
+ sse_ssize_t i;
jchar* tmp;
jint ret;
jthrowable thrown;
@@ -517,22 +517,22 @@ static xp_ssize_t __call_java_write_extio (
return ret;
}
-static xp_ssize_t __read_source (
- int cmd, void* arg, xp_char_t* data, xp_size_t count)
+static sse_ssize_t __read_source (
+ int cmd, void* arg, sse_char_t* data, sse_size_t count)
{
srcio_data_t* srcio_data = (srcio_data_t*)arg;
- if (cmd == XP_AWK_IO_OPEN)
+ if (cmd == SSE_AWK_IO_OPEN)
{
return __call_java_open_source (
srcio_data->env, srcio_data->obj, SOURCE_READ);
}
- else if (cmd == XP_AWK_IO_CLOSE)
+ else if (cmd == SSE_AWK_IO_CLOSE)
{
return __call_java_close_source (
srcio_data->env, srcio_data->obj, SOURCE_READ);
}
- else if (cmd == XP_AWK_IO_READ)
+ else if (cmd == SSE_AWK_IO_READ)
{
return __call_java_read_source (
srcio_data->env, srcio_data->obj, data, count);
@@ -541,22 +541,22 @@ static xp_ssize_t __read_source (
return -1;
}
-static xp_ssize_t __write_source (
- int cmd, void* arg, xp_char_t* data, xp_size_t count)
+static sse_ssize_t __write_source (
+ int cmd, void* arg, sse_char_t* data, sse_size_t count)
{
srcio_data_t* srcio_data = (srcio_data_t*)arg;
- if (cmd == XP_AWK_IO_OPEN)
+ if (cmd == SSE_AWK_IO_OPEN)
{
return __call_java_open_source (
srcio_data->env, srcio_data->obj, SOURCE_WRITE);
}
- else if (cmd == XP_AWK_IO_CLOSE)
+ else if (cmd == SSE_AWK_IO_CLOSE)
{
return __call_java_close_source (
srcio_data->env, srcio_data->obj, SOURCE_WRITE);
}
- else if (cmd == XP_AWK_IO_WRITE)
+ else if (cmd == SSE_AWK_IO_WRITE)
{
return __call_java_write_source (
srcio_data->env, srcio_data->obj, data, count);
@@ -565,45 +565,45 @@ static xp_ssize_t __write_source (
return -1;
}
-static xp_ssize_t __process_extio_console (
- int cmd, void* arg, xp_char_t* data, xp_size_t size)
+static sse_ssize_t __process_extio_console (
+ int cmd, void* arg, sse_char_t* data, sse_size_t size)
{
- xp_awk_extio_t* epa = (xp_awk_extio_t*)arg;
+ sse_awk_extio_t* epa = (sse_awk_extio_t*)arg;
runio_data_t* runio_data = (runio_data_t*)epa->custom_data;
- if (cmd == XP_AWK_IO_OPEN)
+ if (cmd == SSE_AWK_IO_OPEN)
{
return __call_java_open_extio (
runio_data->env, runio_data->obj,
- "open_console", XP_NULL);
+ "open_console", SSE_NULL);
}
- else if (cmd == XP_AWK_IO_CLOSE)
+ else if (cmd == SSE_AWK_IO_CLOSE)
{
return __call_java_close_extio (
runio_data->env, runio_data->obj,
- "close_console", XP_NULL);
+ "close_console", SSE_NULL);
}
- else if (cmd == XP_AWK_IO_READ)
+ else if (cmd == SSE_AWK_IO_READ)
{
return __call_java_read_extio (
runio_data->env, runio_data->obj, "read_console",
data, size);
}
- else if (cmd == XP_AWK_IO_WRITE)
+ else if (cmd == SSE_AWK_IO_WRITE)
{
return __call_java_write_extio (
runio_data->env, runio_data->obj, "write_console",
data, size);
}
#if 0
- else if (cmd == XP_AWK_IO_FLUSH)
+ else if (cmd == SSE_AWK_IO_FLUSH)
{
return __call_java_flush_extio (
runio_data->env, runio_data->obj, "flush_console",
data, size);
}
- else if (cmd == XP_AWK_IO_NEXT)
+ else if (cmd == SSE_AWK_IO_NEXT)
{
return __call_java_next_extio (
runio_data->env, runio_data->obj, "flush_console",
@@ -614,19 +614,19 @@ static xp_ssize_t __process_extio_console (
return -1;
}
-static xp_ssize_t __process_extio_file (
- int cmd, void* arg, xp_char_t* data, xp_size_t size)
+static sse_ssize_t __process_extio_file (
+ int cmd, void* arg, sse_char_t* data, sse_size_t size)
{
- xp_awk_extio_t* epa = (xp_awk_extio_t*)arg;
+ sse_awk_extio_t* epa = (sse_awk_extio_t*)arg;
runio_data_t* runio_data = (runio_data_t*)epa->custom_data;
- if (cmd == XP_AWK_IO_OPEN)
+ if (cmd == SSE_AWK_IO_OPEN)
{
return __call_java_open_extio (
runio_data->env, runio_data->obj,
"open_file", epa);
}
- else if (cmd == XP_AWK_IO_CLOSE)
+ else if (cmd == SSE_AWK_IO_CLOSE)
{
return __call_java_close_extio (
runio_data->env, runio_data->obj,
diff --git a/ase/awk/jni.h b/ase/awk/jni.h
index 54d88166..d05f5890 100644
--- a/ase/awk/jni.h
+++ b/ase/awk/jni.h
@@ -1,9 +1,9 @@
/*
- * $Id: jni.h,v 1.3 2006-08-06 08:15:29 bacon Exp $
+ * $Id: jni.h,v 1.4 2006-10-22 11:34:53 bacon Exp $
*/
-#ifndef _XP_AWK_JNI_H_
-#define _XP_AWK_JNI_H_
+#ifndef _SSE_AWK_JNI_H_
+#define _SSE_AWK_JNI_H_
#include <jni.h>
@@ -11,10 +11,10 @@
extern "C" {
#endif
-JNIEXPORT void JNICALL Java_xpkit_xpj_awk_Awk_open (JNIEnv*, jobject);
-JNIEXPORT void JNICALL Java_xpkit_xpj_awk_Awk_close (JNIEnv*, jobject);
-JNIEXPORT void JNICALL Java_xpkit_xpj_awk_Awk_parse (JNIEnv*, jobject);
-JNIEXPORT void JNICALL Java_xpkit_xpj_awk_Awk_run (JNIEnv*, jobject);
+JNIESSEORT void JNICALL Java_ssekit_ssej_awk_Awk_open (JNIEnv*, jobject);
+JNIESSEORT void JNICALL Java_ssekit_ssej_awk_Awk_close (JNIEnv*, jobject);
+JNIESSEORT void JNICALL Java_ssekit_ssej_awk_Awk_parse (JNIEnv*, jobject);
+JNIESSEORT void JNICALL Java_ssekit_ssej_awk_Awk_run (JNIEnv*, jobject);
#ifdef __cplusplus
}
diff --git a/ase/awk/map.c b/ase/awk/map.c
index dd4dadde..9069d36f 100644
--- a/ase/awk/map.c
+++ b/ase/awk/map.c
@@ -1,70 +1,70 @@
/*
- * $Id: map.c,v 1.26 2006-10-12 04:17:31 bacon Exp $
+ * $Id: map.c,v 1.27 2006-10-22 11:34:53 bacon Exp $
*/
-#include <xp/awk/awk_i.h>
+#include <sse/awk/awk_i.h>
/* TODO: improve the entire map routines.
support automatic bucket resizing and remaping, etc. */
-static xp_size_t __hash (const xp_char_t* key, xp_size_t key_len);
+static sse_size_t __hash (const sse_char_t* key, sse_size_t key_len);
#define FREE_PAIR(map,pair) \
do { \
- XP_AWK_FREE ((map)->awk, (xp_char_t*)(pair)->key); \
- if ((map)->freeval != XP_NULL) \
+ SSE_AWK_FREE ((map)->awk, (sse_char_t*)(pair)->key); \
+ if ((map)->freeval != SSE_NULL) \
(map)->freeval ((map)->owner, (pair)->val); \
- XP_AWK_FREE ((map)->awk, pair); \
+ SSE_AWK_FREE ((map)->awk, pair); \
} while (0)
-xp_awk_map_t* xp_awk_map_open (
- xp_awk_map_t* map, void* owner, xp_size_t capa,
- void(*freeval)(void*,void*), xp_awk_t* awk)
+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)
{
- if (map == XP_NULL)
+ if (map == SSE_NULL)
{
- map = (xp_awk_map_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_awk_map_t));
- if (map == XP_NULL) return XP_NULL;
- map->__dynamic = xp_true;
+ 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;
}
- else map->__dynamic = xp_false;
+ else map->__dynamic = sse_false;
map->awk = awk;
- map->buck = (xp_awk_pair_t**)
- XP_AWK_MALLOC (awk, xp_sizeof(xp_awk_pair_t*) * capa);
- if (map->buck == XP_NULL)
+ map->buck = (sse_awk_pair_t**)
+ SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_pair_t*) * capa);
+ if (map->buck == SSE_NULL)
{
- if (map->__dynamic) XP_AWK_FREE (awk, map);
- return XP_NULL;
+ if (map->__dynamic) SSE_AWK_FREE (awk, map);
+ return SSE_NULL;
}
map->owner = owner;
map->capa = capa;
map->size = 0;
map->freeval = freeval;
- while (capa > 0) map->buck[--capa] = XP_NULL;
+ while (capa > 0) map->buck[--capa] = SSE_NULL;
return map;
}
-void xp_awk_map_close (xp_awk_map_t* map)
+void sse_awk_map_close (sse_awk_map_t* map)
{
- xp_awk_map_clear (map);
- XP_AWK_FREE (map->awk, map->buck);
- if (map->__dynamic) XP_AWK_FREE (map->awk, map);
+ sse_awk_map_clear (map);
+ SSE_AWK_FREE (map->awk, map->buck);
+ if (map->__dynamic) SSE_AWK_FREE (map->awk, map);
}
-void xp_awk_map_clear (xp_awk_map_t* map)
+void sse_awk_map_clear (sse_awk_map_t* map)
{
- xp_size_t i;
- xp_awk_pair_t* pair, * next;
+ sse_size_t i;
+ sse_awk_pair_t* pair, * next;
for (i = 0; i < map->capa; i++)
{
pair = map->buck[i];
- while (pair != XP_NULL)
+ while (pair != SSE_NULL)
{
next = pair->next;
FREE_PAIR (map, pair);
@@ -72,81 +72,81 @@ void xp_awk_map_clear (xp_awk_map_t* map)
pair = next;
}
- map->buck[i] = XP_NULL;
+ map->buck[i] = SSE_NULL;
}
- xp_awk_assert (map->awk, map->size == 0);
+ sse_awk_assert (map->awk, map->size == 0);
}
-xp_awk_pair_t* xp_awk_map_get (
- xp_awk_map_t* map, const xp_char_t* key, xp_size_t key_len)
+sse_awk_pair_t* sse_awk_map_get (
+ sse_awk_map_t* map, const sse_char_t* key, sse_size_t key_len)
{
- xp_awk_pair_t* pair;
- xp_size_t hc;
+ sse_awk_pair_t* pair;
+ sse_size_t hc;
hc = __hash(key,key_len) % map->capa;
pair = map->buck[hc];
- while (pair != XP_NULL)
+ while (pair != SSE_NULL)
{
- if (xp_awk_strxncmp (
+ if (sse_awk_strxncmp (
pair->key, pair->key_len,
key, key_len) == 0) return pair;
pair = pair->next;
}
- return XP_NULL;
+ return SSE_NULL;
}
-xp_awk_pair_t* xp_awk_map_put (
- xp_awk_map_t* map, xp_char_t* key, xp_size_t key_len, void* val)
+sse_awk_pair_t* sse_awk_map_put (
+ sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len, void* val)
{
int n;
- xp_awk_pair_t* px;
+ sse_awk_pair_t* px;
- n = xp_awk_map_putx (map, key, key_len, val, &px);
- if (n < 0) return XP_NULL;
+ n = sse_awk_map_putx (map, key, key_len, val, &px);
+ if (n < 0) return SSE_NULL;
return px;
}
-int xp_awk_map_putx (
- xp_awk_map_t* map, xp_char_t* key, xp_size_t key_len,
- void* val, xp_awk_pair_t** 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)
{
- xp_awk_pair_t* pair;
- xp_size_t hc;
+ sse_awk_pair_t* pair;
+ sse_size_t hc;
hc = __hash(key,key_len) % map->capa;
pair = map->buck[hc];
- while (pair != XP_NULL)
+ while (pair != SSE_NULL)
{
- if (xp_awk_strxncmp (
+ if (sse_awk_strxncmp (
pair->key, pair->key_len, key, key_len) == 0)
{
- if (px != XP_NULL)
- *px = xp_awk_map_setpair (map, pair, val);
+ if (px != SSE_NULL)
+ *px = sse_awk_map_setpair (map, pair, val);
else
- xp_awk_map_setpair (map, pair, val);
+ sse_awk_map_setpair (map, pair, val);
return 0; /* value changed for the existing key */
}
pair = pair->next;
}
- pair = (xp_awk_pair_t*) XP_AWK_MALLOC (
- map->awk, xp_sizeof(xp_awk_pair_t));
- if (pair == XP_NULL) return -1; /* error */
+ pair = (sse_awk_pair_t*) SSE_AWK_MALLOC (
+ map->awk, sse_sizeof(sse_awk_pair_t));
+ if (pair == SSE_NULL) return -1; /* error */
/*pair->key = key;*/
/* duplicate the key if it is new */
- pair->key = xp_awk_strxdup (map->awk, key, key_len);
- if (pair->key == XP_NULL)
+ pair->key = sse_awk_strxdup (map->awk, key, key_len);
+ if (pair->key == SSE_NULL)
{
- XP_AWK_FREE (map->awk, pair);
+ SSE_AWK_FREE (map->awk, pair);
return -1; /* error */
}
@@ -156,51 +156,51 @@ int xp_awk_map_putx (
map->buck[hc] = pair;
map->size++;
- if (px != XP_NULL) *px = pair;
+ if (px != SSE_NULL) *px = pair;
return 1; /* new key added */
}
-xp_awk_pair_t* xp_awk_map_set (
- xp_awk_map_t* map, xp_char_t* key, xp_size_t key_len, void* val)
+sse_awk_pair_t* sse_awk_map_set (
+ sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len, void* val)
{
- xp_awk_pair_t* pair;
- xp_size_t hc;
+ sse_awk_pair_t* pair;
+ sse_size_t hc;
hc = __hash(key,key_len) % map->capa;
pair = map->buck[hc];
- while (pair != XP_NULL)
+ while (pair != SSE_NULL)
{
- if (xp_awk_strxncmp (
+ if (sse_awk_strxncmp (
pair->key, pair->key_len, key, key_len) == 0)
{
- return xp_awk_map_setpair (map, pair, val);
+ return sse_awk_map_setpair (map, pair, val);
}
pair = pair->next;
}
- return XP_NULL;
+ return SSE_NULL;
}
-xp_awk_pair_t* xp_awk_map_getpair (
- xp_awk_map_t* map, const xp_char_t* key, xp_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)
{
- xp_awk_pair_t* pair;
+ sse_awk_pair_t* pair;
- pair = xp_awk_map_get (map, key, key_len);
- if (pair == XP_NULL) return XP_NULL;
+ pair = sse_awk_map_get (map, key, key_len);
+ if (pair == SSE_NULL) return SSE_NULL;
*val = pair->val;
return pair;
}
-xp_awk_pair_t* xp_awk_map_setpair (
- xp_awk_map_t* map, xp_awk_pair_t* pair, void* val)
+sse_awk_pair_t* sse_awk_map_setpair (
+ sse_awk_map_t* map, sse_awk_pair_t* pair, void* val)
{
/* use this function with care */
if (pair->val != val)
{
- if (map->freeval != XP_NULL)
+ if (map->freeval != SSE_NULL)
{
map->freeval (map->owner, pair->val);
}
@@ -210,21 +210,21 @@ xp_awk_pair_t* xp_awk_map_setpair (
return pair;
}
-int xp_awk_map_remove (xp_awk_map_t* map, xp_char_t* key, xp_size_t key_len)
+int sse_awk_map_remove (sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len)
{
- xp_awk_pair_t* pair, * prev;
- xp_size_t hc;
+ sse_awk_pair_t* pair, * prev;
+ sse_size_t hc;
hc = __hash(key,key_len) % map->capa;
pair = map->buck[hc];
- prev = XP_NULL;
+ prev = SSE_NULL;
- while (pair != XP_NULL)
+ while (pair != SSE_NULL)
{
- if (xp_awk_strxncmp (
+ if (sse_awk_strxncmp (
pair->key, pair->key_len, key, key_len) == 0)
{
- if (prev == XP_NULL)
+ if (prev == SSE_NULL)
map->buck[hc] = pair->next;
else prev->next = pair->next;
@@ -241,17 +241,17 @@ int xp_awk_map_remove (xp_awk_map_t* map, xp_char_t* key, xp_size_t key_len)
return -1;
}
-int xp_awk_map_walk (xp_awk_map_t* map,
- int (*walker) (xp_awk_pair_t*,void*), void* arg)
+int sse_awk_map_walk (sse_awk_map_t* map,
+ int (*walker) (sse_awk_pair_t*,void*), void* arg)
{
- xp_size_t i;
- xp_awk_pair_t* pair, * next;
+ sse_size_t i;
+ sse_awk_pair_t* pair, * next;
for (i = 0; i < map->capa; i++)
{
pair = map->buck[i];
- while (pair != XP_NULL)
+ while (pair != SSE_NULL)
{
next = pair->next;
if (walker(pair,arg) == -1) return -1;
@@ -262,15 +262,15 @@ int xp_awk_map_walk (xp_awk_map_t* map,
return 0;
}
-static xp_size_t __hash (const xp_char_t* key, xp_size_t key_len)
+static sse_size_t __hash (const sse_char_t* key, sse_size_t key_len)
{
- xp_size_t n = 0, i;
- const xp_char_t* end = key + key_len;
+ sse_size_t n = 0, i;
+ const sse_char_t* end = key + key_len;
while (key < end)
{
- xp_byte_t* bp = (xp_byte_t*)key;
- for (i = 0; i < xp_sizeof(*key); i++) n = n * 31 + *bp++;
+ sse_byte_t* bp = (sse_byte_t*)key;
+ for (i = 0; i < sse_sizeof(*key); i++) n = n * 31 + *bp++;
key++;
}
diff --git a/ase/awk/map.h b/ase/awk/map.h
index b46134dd..91f127f4 100644
--- a/ase/awk/map.h
+++ b/ase/awk/map.h
@@ -1,71 +1,71 @@
/*
- * $Id: map.h,v 1.15 2006-09-01 03:44:16 bacon Exp $
+ * $Id: map.h,v 1.16 2006-10-22 11:34:53 bacon Exp $
*/
-#ifndef _XP_AWK_MAP_H_
-#define _XP_AWK_MAP_H_
+#ifndef _SSE_AWK_MAP_H_
+#define _SSE_AWK_MAP_H_
-#ifndef _XP_AWK_AWK_H_
-#error Never include this file directly. Include <xp/awk/awk.h> instead
+#ifndef _SSE_AWK_AWK_H_
+#error Never include this file directly. Include <sse/awk/awk.h> instead
#endif
-typedef struct xp_awk_map_t xp_awk_map_t;
-typedef struct xp_awk_pair_t xp_awk_pair_t;
+typedef struct sse_awk_map_t sse_awk_map_t;
+typedef struct sse_awk_pair_t sse_awk_pair_t;
-struct xp_awk_pair_t
+struct sse_awk_pair_t
{
- xp_char_t* key;
- xp_size_t key_len;
+ sse_char_t* key;
+ sse_size_t key_len;
void* val;
- xp_awk_pair_t* next;
+ sse_awk_pair_t* next;
};
-struct xp_awk_map_t
+struct sse_awk_map_t
{
void* owner;
- xp_size_t size;
- xp_size_t capa;
- xp_awk_pair_t** buck;
+ sse_size_t size;
+ sse_size_t capa;
+ sse_awk_pair_t** buck;
void (*freeval) (void*,void*);
- xp_awk_t* awk;
- xp_bool_t __dynamic;
+ sse_awk_t* awk;
+ sse_bool_t __dynamic;
};
#ifdef __cplusplus
extern "C" {
#endif
-xp_awk_map_t* xp_awk_map_open (
- xp_awk_map_t* map, void* owner, xp_size_t capa,
- void(*freeval)(void*,void*), xp_awk_t* awk);
+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);
-void xp_awk_map_close (xp_awk_map_t* map);
+void sse_awk_map_close (sse_awk_map_t* map);
-void xp_awk_map_clear (xp_awk_map_t* map);
+void sse_awk_map_clear (sse_awk_map_t* map);
-xp_awk_pair_t* xp_awk_map_get (
- xp_awk_map_t* map, const xp_char_t* key, xp_size_t key_len);
+sse_awk_pair_t* sse_awk_map_get (
+ sse_awk_map_t* map, const sse_char_t* key, sse_size_t key_len);
-xp_awk_pair_t* xp_awk_map_put (
- xp_awk_map_t* map, xp_char_t* key, xp_size_t key_len, void* val);
+sse_awk_pair_t* sse_awk_map_put (
+ sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len, void* val);
-int xp_awk_map_putx (
- xp_awk_map_t* map, xp_char_t* key, xp_size_t key_len,
- void* val, xp_awk_pair_t** 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);
-xp_awk_pair_t* xp_awk_map_set (
- xp_awk_map_t* map, xp_char_t* key, xp_size_t key_len, void* val);
+sse_awk_pair_t* sse_awk_map_set (
+ sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len, void* val);
-xp_awk_pair_t* xp_awk_map_getpair (
- xp_awk_map_t* map, const xp_char_t* key, xp_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);
-xp_awk_pair_t* xp_awk_map_setpair (
- xp_awk_map_t* map, xp_awk_pair_t* pair, void* val);
+sse_awk_pair_t* sse_awk_map_setpair (
+ sse_awk_map_t* map, sse_awk_pair_t* pair, void* val);
-int xp_awk_map_remove (xp_awk_map_t* map, xp_char_t* key, xp_size_t key_len);
+int sse_awk_map_remove (sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len);
-int xp_awk_map_walk (xp_awk_map_t* map,
- int (*walker)(xp_awk_pair_t*,void*), void* arg);
+int sse_awk_map_walk (sse_awk_map_t* map,
+ int (*walker)(sse_awk_pair_t*,void*), void* arg);
#ifdef __cplusplus
}
diff --git a/ase/awk/misc.c b/ase/awk/misc.c
index 6c0aea81..820e3d21 100644
--- a/ase/awk/misc.c
+++ b/ase/awk/misc.c
@@ -1,66 +1,66 @@
/*
- * $Id: misc.c,v 1.28 2006-10-12 14:36:25 bacon Exp $
+ * $Id: misc.c,v 1.29 2006-10-22 11:34:53 bacon Exp $
*/
-#include <xp/awk/awk_i.h>
+#include <sse/awk/awk_i.h>
-void* xp_awk_memcpy (void* dst, const void* src, xp_size_t n)
+void* sse_awk_memcpy (void* dst, const void* src, sse_size_t n)
{
void* p = dst;
- void* e = (xp_byte_t*)dst + n;
+ void* e = (sse_byte_t*)dst + n;
while (dst < e)
{
- *(xp_byte_t*)dst = *(xp_byte_t*)src;
- dst = (xp_byte_t*)dst + 1;
- src = (xp_byte_t*)src + 1;
+ *(sse_byte_t*)dst = *(sse_byte_t*)src;
+ dst = (sse_byte_t*)dst + 1;
+ src = (sse_byte_t*)src + 1;
}
return p;
}
-void* xp_awk_memset (void* dst, int val, xp_size_t n)
+void* sse_awk_memset (void* dst, int val, sse_size_t n)
{
void* p = dst;
- void* e = (xp_byte_t*)p + n;
+ void* e = (sse_byte_t*)p + n;
while (p < e)
{
- *(xp_byte_t*)p = (xp_byte_t)val;
- p = (xp_byte_t*)p + 1;
+ *(sse_byte_t*)p = (sse_byte_t)val;
+ p = (sse_byte_t*)p + 1;
}
return dst;
}
-xp_long_t xp_awk_strxtolong (
- xp_awk_t* awk, const xp_char_t* str, xp_size_t len,
- int base, const xp_char_t** endptr)
+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)
{
- xp_long_t n = 0;
- const xp_char_t* p;
- const xp_char_t* end;
- xp_size_t rem;
+ sse_long_t n = 0;
+ const sse_char_t* p;
+ const sse_char_t* end;
+ sse_size_t rem;
int digit, negative = 0;
- xp_awk_assert (awk, base < 37);
+ sse_awk_assert (awk, base < 37);
p = str;
end = str + len;
/* strip off leading spaces */
- /*while (XP_AWK_ISSPACE(awk,*p)) p++;*/
+ /*while (SSE_AWK_ISSPACE(awk,*p)) p++;*/
/* check for a sign */
- /*while (*p != XP_T('\0')) */
+ /*while (*p != SSE_T('\0')) */
while (p < end)
{
- if (*p == XP_T('-'))
+ if (*p == SSE_T('-'))
{
negative = ~negative;
p++;
}
- else if (*p == XP_T('+')) p++;
+ else if (*p == SSE_T('+')) p++;
else break;
}
@@ -68,16 +68,16 @@ xp_long_t xp_awk_strxtolong (
rem = end - p;
if (base == 0)
{
- if (rem >= 1 && *p == XP_T('0'))
+ if (rem >= 1 && *p == SSE_T('0'))
{
p++;
if (rem == 1) base = 8;
- else if (*p == XP_T('x') || *p == XP_T('X'))
+ else if (*p == SSE_T('x') || *p == SSE_T('X'))
{
p++; base = 16;
}
- else if (*p == XP_T('b') || *p == XP_T('B'))
+ else if (*p == SSE_T('b') || *p == SSE_T('B'))
{
p++; base = 2;
}
@@ -87,25 +87,25 @@ xp_long_t xp_awk_strxtolong (
}
else if (rem >= 2 && base == 16)
{
- if (*p == XP_T('0') &&
- (*(p+1) == XP_T('x') || *(p+1) == XP_T('X'))) p += 2;
+ if (*p == SSE_T('0') &&
+ (*(p+1) == SSE_T('x') || *(p+1) == SSE_T('X'))) p += 2;
}
else if (rem >= 2 && base == 2)
{
- if (*p == XP_T('0') &&
- (*(p+1) == XP_T('b') || *(p+1) == XP_T('B'))) p += 2;
+ if (*p == SSE_T('0') &&
+ (*(p+1) == SSE_T('b') || *(p+1) == SSE_T('B'))) p += 2;
}
/* process the digits */
- /*while (*p != XP_T('\0'))*/
+ /*while (*p != SSE_T('\0'))*/
while (p < end)
{
- if (*p >= XP_T('0') && *p <= XP_T('9'))
- digit = *p - XP_T('0');
- else if (*p >= XP_T('A') && *p <= XP_T('Z'))
- digit = *p - XP_T('A') + 10;
- else if (*p >= XP_T('a') && *p <= XP_T('z'))
- digit = *p - XP_T('a') + 10;
+ if (*p >= SSE_T('0') && *p <= SSE_T('9'))
+ digit = *p - SSE_T('0');
+ else if (*p >= SSE_T('A') && *p <= SSE_T('Z'))
+ digit = *p - SSE_T('A') + 10;
+ else if (*p >= SSE_T('a') && *p <= SSE_T('z'))
+ digit = *p - SSE_T('a') + 10;
else break;
if (digit >= base) break;
@@ -114,13 +114,13 @@ xp_long_t xp_awk_strxtolong (
p++;
}
- if (endptr != XP_NULL) *endptr = p;
+ if (endptr != SSE_NULL) *endptr = p;
return (negative)? -n: n;
}
/*
- * xp_awk_strtoreal is almost a replica of strtod.
+ * sse_awk_strtoreal is almost a replica of strtod.
*
* strtod.c --
*
@@ -135,57 +135,57 @@ xp_long_t xp_awk_strxtolong (
* notice appear in all copies. The University of California
* makes no representations about the suitability of this
* software for any purpose. It is provided "as is" without
- * express or implied warranty.
+ * esseress or implied warranty.
*/
-#define MAX_EXPONENT 511
+#define MAX_ESSEONENT 511
-xp_real_t xp_awk_strtoreal (xp_awk_t* awk, const xp_char_t* str)
+sse_real_t sse_awk_strtoreal (sse_awk_t* awk, const sse_char_t* str)
{
/*
* Table giving binary powers of 10. Entry is 10^2^i.
- * Used to convert decimal exponents into floating-point numbers.
+ * Used to convert decimal esseonents into floating-point numbers.
*/
- static xp_real_t powers_of_10[] =
+ static sse_real_t powers_of_10[] =
{
10., 100., 1.0e4, 1.0e8, 1.0e16,
1.0e32, 1.0e64, 1.0e128, 1.0e256
};
- xp_real_t fraction, dbl_exp, * d;
- const xp_char_t* p;
- xp_cint_t c;
- int exp = 0; /* Exponent read from "EX" field */
+ sse_real_t fraction, dbl_esse, * d;
+ const sse_char_t* p;
+ sse_cint_t c;
+ int esse = 0; /* Esseonent read from "EX" field */
/*
- * Exponent that derives from the fractional part. Under normal
+ * Esseonent that derives from the fractional part. Under normal
* circumstatnces, it is the negative of the number of digits in F.
* However, if I is very long, the last digits of I get dropped
- * (otherwise a long I with a large negative exponent could cause an
- * unnecessary overflow on I alone). In this case, frac_exp is
+ * (otherwise a long I with a large negative esseonent could cause an
+ * unnecessary overflow on I alone). In this case, frac_esse is
* incremented one for each dropped digit.
*/
- int frac_exp;
+ int frac_esse;
int mant_size; /* Number of digits in mantissa. */
int dec_pt; /* Number of mantissa digits BEFORE decimal point */
- const xp_char_t *pexp; /* Temporarily holds location of exponent in string */
- int negative = 0, exp_negative = 0;
+ const sse_char_t *pesse; /* Temporarily holds location of esseonent in string */
+ int negative = 0, esse_negative = 0;
p = str;
/* strip off leading blanks */
- /*while (XP_AWK_ISSPACE(awk,*p)) p++;*/
+ /*while (SSE_AWK_ISSPACE(awk,*p)) p++;*/
/* check for a sign */
- while (*p != XP_T('\0'))
+ while (*p != SSE_T('\0'))
{
- if (*p == XP_T('-'))
+ if (*p == SSE_T('-'))
{
negative = ~negative;
p++;
}
- else if (*p == XP_T('+')) p++;
+ else if (*p == SSE_T('+')) p++;
else break;
}
@@ -195,9 +195,9 @@ xp_real_t xp_awk_strtoreal (xp_awk_t* awk, const xp_char_t* str)
for (mant_size = 0; ; mant_size++)
{
c = *p;
- if (!XP_AWK_ISDIGIT (awk, c))
+ if (!SSE_AWK_ISDIGIT (awk, c))
{
- if ((c != XP_T('.')) || (dec_pt >= 0)) break;
+ if ((c != SSE_T('.')) || (dec_pt >= 0)) break;
dec_pt = mant_size;
}
p++;
@@ -209,7 +209,7 @@ xp_real_t xp_awk_strtoreal (xp_awk_t* awk, const xp_char_t* str)
* If the mantissa has more than 18 digits, ignore the extras, since
* they can't affect the value anyway.
*/
- pexp = p;
+ pesse = p;
p -= mant_size;
if (dec_pt < 0)
{
@@ -222,19 +222,19 @@ xp_real_t xp_awk_strtoreal (xp_awk_t* awk, const xp_char_t* str)
if (mant_size > 18)
{
- frac_exp = dec_pt - 18;
+ frac_esse = dec_pt - 18;
mant_size = 18;
}
else
{
- frac_exp = dec_pt - mant_size;
+ frac_esse = dec_pt - mant_size;
}
if (mant_size == 0)
{
fraction = 0.0;
/*p = str;*/
- p = pexp;
+ p = pesse;
goto done;
}
else
@@ -245,137 +245,137 @@ xp_real_t xp_awk_strtoreal (xp_awk_t* awk, const xp_char_t* str)
{
c = *p;
p++;
- if (c == XP_T('.'))
+ if (c == SSE_T('.'))
{
c = *p;
p++;
}
- frac1 = 10 * frac1 + (c - XP_T('0'));
+ frac1 = 10 * frac1 + (c - SSE_T('0'));
}
frac2 = 0;
for (; mant_size > 0; mant_size--) {
c = *p;
p++;
- if (c == XP_T('.'))
+ if (c == SSE_T('.'))
{
c = *p;
p++;
}
- frac2 = 10*frac2 + (c - XP_T('0'));
+ frac2 = 10*frac2 + (c - SSE_T('0'));
}
fraction = (1.0e9 * frac1) + frac2;
}
- /* Skim off the exponent */
- p = pexp;
- if ((*p == XP_T('E')) || (*p == XP_T('e')))
+ /* Skim off the esseonent */
+ p = pesse;
+ if ((*p == SSE_T('E')) || (*p == SSE_T('e')))
{
p++;
- if (*p == XP_T('-'))
+ if (*p == SSE_T('-'))
{
- exp_negative = 1;
+ esse_negative = 1;
p++;
}
else
{
- if (*p == XP_T('+')) p++;
- exp_negative = 0;
+ if (*p == SSE_T('+')) p++;
+ esse_negative = 0;
}
- if (!XP_AWK_ISDIGIT (awk, *p))
+ if (!SSE_AWK_ISDIGIT (awk, *p))
{
- /* p = pexp; */
+ /* p = pesse; */
/* goto done; */
- goto no_exp;
+ goto no_esse;
}
- while (XP_AWK_ISDIGIT (awk, *p))
+ while (SSE_AWK_ISDIGIT (awk, *p))
{
- exp = exp * 10 + (*p - XP_T('0'));
+ esse = esse * 10 + (*p - SSE_T('0'));
p++;
}
}
-no_exp:
- if (exp_negative) exp = frac_exp - exp;
- else exp = frac_exp + exp;
+no_esse:
+ if (esse_negative) esse = frac_esse - esse;
+ else esse = frac_esse + esse;
/*
- * Generate a floating-point number that represents the exponent.
- * Do this by processing the exponent one bit at a time to combine
- * many powers of 2 of 10. Then combine the exponent with the
+ * Generate a floating-point number that represents the esseonent.
+ * Do this by processing the esseonent one bit at a time to combine
+ * many powers of 2 of 10. Then combine the esseonent with the
* fraction.
*/
- if (exp < 0)
+ if (esse < 0)
{
- exp_negative = 1;
- exp = -exp;
+ esse_negative = 1;
+ esse = -esse;
}
- else exp_negative = 0;
+ else esse_negative = 0;
- if (exp > MAX_EXPONENT) exp = MAX_EXPONENT;
+ if (esse > MAX_ESSEONENT) esse = MAX_ESSEONENT;
- dbl_exp = 1.0;
+ dbl_esse = 1.0;
- for (d = powers_of_10; exp != 0; exp >>= 1, d++)
+ for (d = powers_of_10; esse != 0; esse >>= 1, d++)
{
- if (exp & 01) dbl_exp *= *d;
+ if (esse & 01) dbl_esse *= *d;
}
- if (exp_negative) fraction /= dbl_exp;
- else fraction *= dbl_exp;
+ if (esse_negative) fraction /= dbl_esse;
+ else fraction *= dbl_esse;
done:
return (negative)? -fraction: fraction;
}
-xp_real_t xp_awk_strxtoreal (
- xp_awk_t* awk, const xp_char_t* str, xp_size_t len,
- const xp_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)
{
/*
* Table giving binary powers of 10. Entry is 10^2^i.
- * Used to convert decimal exponents into floating-point numbers.
+ * Used to convert decimal esseonents into floating-point numbers.
*/
- static xp_real_t powers_of_10[] =
+ static sse_real_t powers_of_10[] =
{
10., 100., 1.0e4, 1.0e8, 1.0e16,
1.0e32, 1.0e64, 1.0e128, 1.0e256
};
- xp_real_t fraction, dbl_exp, * d;
- const xp_char_t* p, * end;
- xp_cint_t c;
- int exp = 0; /* Exponent read from "EX" field */
+ sse_real_t fraction, dbl_esse, * d;
+ const sse_char_t* p, * end;
+ sse_cint_t c;
+ int esse = 0; /* Esseonent read from "EX" field */
/*
- * Exponent that derives from the fractional part. Under normal
+ * Esseonent that derives from the fractional part. Under normal
* circumstatnces, it is the negative of the number of digits in F.
* However, if I is very long, the last digits of I get dropped
- * (otherwise a long I with a large negative exponent could cause an
- * unnecessary overflow on I alone). In this case, frac_exp is
+ * (otherwise a long I with a large negative esseonent could cause an
+ * unnecessary overflow on I alone). In this case, frac_esse is
* incremented one for each dropped digit.
*/
- int frac_exp;
+ int frac_esse;
int mant_size; /* Number of digits in mantissa. */
int dec_pt; /* Number of mantissa digits BEFORE decimal point */
- const xp_char_t *pexp; /* Temporarily holds location of exponent in string */
- int negative = 0, exp_negative = 0;
+ const sse_char_t *pesse; /* Temporarily holds location of esseonent in string */
+ int negative = 0, esse_negative = 0;
p = str;
end = str + len;
/* Strip off leading blanks and check for a sign */
- /*while (XP_AWK_ISSPACE(awk,*p)) p++;*/
+ /*while (SSE_AWK_ISSPACE(awk,*p)) p++;*/
- /*while (*p != XP_T('\0')) */
+ /*while (*p != SSE_T('\0')) */
while (p < end)
{
- if (*p == XP_T('-'))
+ if (*p == SSE_T('-'))
{
negative = ~negative;
p++;
}
- else if (*p == XP_T('+')) p++;
+ else if (*p == SSE_T('+')) p++;
else break;
}
@@ -386,9 +386,9 @@ xp_real_t xp_awk_strxtoreal (
for (mant_size = 0; p < end; mant_size++)
{
c = *p;
- if (!XP_AWK_ISDIGIT (awk, c))
+ if (!SSE_AWK_ISDIGIT (awk, c))
{
- if (c != XP_T('.') || dec_pt >= 0) break;
+ if (c != SSE_T('.') || dec_pt >= 0) break;
dec_pt = mant_size;
}
p++;
@@ -400,7 +400,7 @@ xp_real_t xp_awk_strxtoreal (
* If the mantissa has more than 18 digits, ignore the extras, since
* they can't affect the value anyway.
*/
- pexp = p;
+ pesse = p;
p -= mant_size;
if (dec_pt < 0)
{
@@ -411,21 +411,21 @@ xp_real_t xp_awk_strxtoreal (
mant_size--; /* One of the digits was the point */
}
- if (mant_size > 18) /* TODO: is 18 correct for xp_real_t??? */
+ if (mant_size > 18) /* TODO: is 18 correct for sse_real_t??? */
{
- frac_exp = dec_pt - 18;
+ frac_esse = dec_pt - 18;
mant_size = 18;
}
else
{
- frac_exp = dec_pt - mant_size;
+ frac_esse = dec_pt - mant_size;
}
if (mant_size == 0)
{
fraction = 0.0;
/*p = str;*/
- p = pexp;
+ p = pesse;
goto done;
}
else
@@ -437,121 +437,121 @@ xp_real_t xp_awk_strxtoreal (
{
c = *p;
p++;
- if (c == XP_T('.'))
+ if (c == SSE_T('.'))
{
c = *p;
p++;
}
- frac1 = 10 * frac1 + (c - XP_T('0'));
+ frac1 = 10 * frac1 + (c - SSE_T('0'));
}
frac2 = 0;
for (; mant_size > 0; mant_size--) {
c = *p++;
- if (c == XP_T('.'))
+ if (c == SSE_T('.'))
{
c = *p;
p++;
}
- frac2 = 10 * frac2 + (c - XP_T('0'));
+ frac2 = 10 * frac2 + (c - SSE_T('0'));
}
fraction = (1.0e9 * frac1) + frac2;
}
- /* Skim off the exponent */
- p = pexp;
- if (p < end && (*p == XP_T('E') || *p == XP_T('e')))
+ /* Skim off the esseonent */
+ p = pesse;
+ if (p < end && (*p == SSE_T('E') || *p == SSE_T('e')))
{
p++;
if (p < end)
{
- if (*p == XP_T('-'))
+ if (*p == SSE_T('-'))
{
- exp_negative = 1;
+ esse_negative = 1;
p++;
}
else
{
- if (*p == XP_T('+')) p++;
- exp_negative = 0;
+ if (*p == SSE_T('+')) p++;
+ esse_negative = 0;
}
}
- else exp_negative = 0;
+ else esse_negative = 0;
- if (!(p < end && XP_AWK_ISDIGIT (awk, *p)))
+ if (!(p < end && SSE_AWK_ISDIGIT (awk, *p)))
{
- /*p = pexp;*/
+ /*p = pesse;*/
/*goto done;*/
- goto no_exp;
+ goto no_esse;
}
- while (p < end && XP_AWK_ISDIGIT (awk, *p))
+ while (p < end && SSE_AWK_ISDIGIT (awk, *p))
{
- exp = exp * 10 + (*p - XP_T('0'));
+ esse = esse * 10 + (*p - SSE_T('0'));
p++;
}
}
-no_exp:
- if (exp_negative) exp = frac_exp - exp;
- else exp = frac_exp + exp;
+no_esse:
+ if (esse_negative) esse = frac_esse - esse;
+ else esse = frac_esse + esse;
/*
- * Generate a floating-point number that represents the exponent.
- * Do this by processing the exponent one bit at a time to combine
- * many powers of 2 of 10. Then combine the exponent with the
+ * Generate a floating-point number that represents the esseonent.
+ * Do this by processing the esseonent one bit at a time to combine
+ * many powers of 2 of 10. Then combine the esseonent with the
* fraction.
*/
- if (exp < 0)
+ if (esse < 0)
{
- exp_negative = 1;
- exp = -exp;
+ esse_negative = 1;
+ esse = -esse;
}
- else exp_negative = 0;
+ else esse_negative = 0;
- if (exp > MAX_EXPONENT) exp = MAX_EXPONENT;
+ if (esse > MAX_ESSEONENT) esse = MAX_ESSEONENT;
- dbl_exp = 1.0;
+ dbl_esse = 1.0;
- for (d = powers_of_10; exp != 0; exp >>= 1, d++)
+ for (d = powers_of_10; esse != 0; esse >>= 1, d++)
{
- if (exp & 01) dbl_exp *= *d;
+ if (esse & 01) dbl_esse *= *d;
}
- if (exp_negative) fraction /= dbl_exp;
- else fraction *= dbl_exp;
+ if (esse_negative) fraction /= dbl_esse;
+ else fraction *= dbl_esse;
done:
- if (endptr != XP_NULL) *endptr = p;
+ if (endptr != SSE_NULL) *endptr = p;
return (negative)? -fraction: fraction;
}
-xp_size_t xp_awk_longtostr (
- xp_long_t value, int radix, const xp_char_t* prefix,
- xp_char_t* buf, xp_size_t size)
+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)
{
- xp_long_t t, rem;
- xp_size_t len, ret, i;
- xp_size_t prefix_len;
+ sse_long_t t, rem;
+ sse_size_t len, ret, i;
+ sse_size_t prefix_len;
- prefix_len = (prefix != XP_NULL)? xp_awk_strlen(prefix): 0;
+ prefix_len = (prefix != SSE_NULL)? sse_awk_strlen(prefix): 0;
t = value;
if (t == 0)
{
/* zero */
- if (buf == XP_NULL) return prefix_len + 1;
+ if (buf == SSE_NULL) return prefix_len + 1;
if (size < prefix_len+1)
{
/* buffer too small */
- return (xp_size_t)-1;
+ return (sse_size_t)-1;
}
for (i = 0; i < prefix_len; i++) buf[i] = prefix[i];
- buf[prefix_len] = XP_T('0');
- if (size > prefix_len+1) buf[prefix_len+1] = XP_T('\0');
+ buf[prefix_len] = SSE_T('0');
+ if (size > prefix_len+1) buf[prefix_len+1] = SSE_T('\0');
return 1;
}
@@ -560,14 +560,14 @@ xp_size_t xp_awk_longtostr (
if (t < 0) { t = -t; len++; }
while (t > 0) { len++; t /= radix; }
- if (buf == XP_NULL)
+ if (buf == SSE_NULL)
{
/* if buf is not given, return the number of bytes required */
return len;
}
- if (size < len) return (xp_size_t)-1; /* buffer too small */
- if (size > len) buf[len] = XP_T('\0');
+ if (size < len) return (sse_size_t)-1; /* buffer too small */
+ if (size > len) buf[len] = SSE_T('\0');
ret = len;
t = value;
@@ -577,9 +577,9 @@ xp_size_t xp_awk_longtostr (
{
rem = t % radix;
if (rem >= 10)
- buf[--len] = (xp_char_t)rem + XP_T('a') - 10;
+ buf[--len] = (sse_char_t)rem + SSE_T('a') - 10;
else
- buf[--len] = (xp_char_t)rem + XP_T('0');
+ buf[--len] = (sse_char_t)rem + SSE_T('0');
t /= radix;
}
@@ -590,7 +590,7 @@ xp_size_t xp_awk_longtostr (
buf[i] = prefix[i-1];
len--;
}
- buf[--len] = XP_T('-');
+ buf[--len] = SSE_T('-');
}
else
{
@@ -600,86 +600,86 @@ xp_size_t xp_awk_longtostr (
return ret;
}
-xp_char_t* xp_awk_strdup (xp_awk_t* awk, const xp_char_t* str)
+sse_char_t* sse_awk_strdup (sse_awk_t* awk, const sse_char_t* str)
{
- xp_char_t* tmp;
+ sse_char_t* tmp;
- tmp = (xp_char_t*) XP_AWK_MALLOC (
- awk, (xp_awk_strlen(str) + 1) * xp_sizeof(xp_char_t));
- if (tmp == XP_NULL) return XP_NULL;
+ tmp = (sse_char_t*) SSE_AWK_MALLOC (
+ awk, (sse_awk_strlen(str) + 1) * sse_sizeof(sse_char_t));
+ if (tmp == SSE_NULL) return SSE_NULL;
- xp_awk_strcpy (tmp, str);
+ sse_awk_strcpy (tmp, str);
return tmp;
}
-xp_char_t* xp_awk_strxdup (xp_awk_t* awk, const xp_char_t* str, xp_size_t len)
+sse_char_t* sse_awk_strxdup (sse_awk_t* awk, const sse_char_t* str, sse_size_t len)
{
- xp_char_t* tmp;
+ sse_char_t* tmp;
- tmp = (xp_char_t*) XP_AWK_MALLOC (
- awk, (len + 1) * xp_sizeof(xp_char_t));
- if (tmp == XP_NULL) return XP_NULL;
+ tmp = (sse_char_t*) SSE_AWK_MALLOC (
+ awk, (len + 1) * sse_sizeof(sse_char_t));
+ if (tmp == SSE_NULL) return SSE_NULL;
- xp_awk_strncpy (tmp, str, len);
+ sse_awk_strncpy (tmp, str, len);
return tmp;
}
-xp_char_t* xp_awk_strxdup2 (
- xp_awk_t* awk,
- const xp_char_t* str1, xp_size_t len1,
- const xp_char_t* str2, xp_size_t len2)
+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)
{
- xp_char_t* tmp;
+ sse_char_t* tmp;
- tmp = (xp_char_t*) XP_AWK_MALLOC (
- awk, (len1 + len2 + 1) * xp_sizeof(xp_char_t));
- if (tmp == XP_NULL) return XP_NULL;
+ tmp = (sse_char_t*) SSE_AWK_MALLOC (
+ awk, (len1 + len2 + 1) * sse_sizeof(sse_char_t));
+ if (tmp == SSE_NULL) return SSE_NULL;
- xp_awk_strncpy (tmp, str1, len1);
- xp_awk_strncpy (tmp + len1, str2, len2);
+ sse_awk_strncpy (tmp, str1, len1);
+ sse_awk_strncpy (tmp + len1, str2, len2);
return tmp;
}
-xp_size_t xp_awk_strlen (const xp_char_t* str)
+sse_size_t sse_awk_strlen (const sse_char_t* str)
{
- const xp_char_t* p = str;
- while (*p != XP_T('\0')) p++;
+ const sse_char_t* p = str;
+ while (*p != SSE_T('\0')) p++;
return p - str;
}
-xp_size_t xp_awk_strcpy (xp_char_t* buf, const xp_char_t* str)
+sse_size_t sse_awk_strcpy (sse_char_t* buf, const sse_char_t* str)
{
- xp_char_t* org = buf;
- while ((*buf++ = *str++) != XP_T('\0'));
+ sse_char_t* org = buf;
+ while ((*buf++ = *str++) != SSE_T('\0'));
return buf - org - 1;
}
-xp_size_t xp_awk_strncpy (xp_char_t* buf, const xp_char_t* str, xp_size_t len)
+sse_size_t sse_awk_strncpy (sse_char_t* buf, const sse_char_t* str, sse_size_t len)
{
- const xp_char_t* end = str + len;
+ const sse_char_t* end = str + len;
while (str < end) *buf++ = *str++;
- *buf = XP_T('\0');
+ *buf = SSE_T('\0');
return len;
}
-int xp_awk_strcmp (const xp_char_t* s1, const xp_char_t* s2)
+int sse_awk_strcmp (const sse_char_t* s1, const sse_char_t* s2)
{
while (*s1 == *s2)
{
- if (*s1 == XP_C('\0')) return 0;
+ if (*s1 == SSE_C('\0')) return 0;
s1++, s2++;
}
return (*s1 > *s2)? 1: -1;
}
-int xp_awk_strxncmp (
- const xp_char_t* s1, xp_size_t len1,
- const xp_char_t* s2, xp_size_t len2)
+int sse_awk_strxncmp (
+ const sse_char_t* s1, sse_size_t len1,
+ const sse_char_t* s2, sse_size_t len2)
{
- xp_char_t c1, c2;
- const xp_char_t* end1 = s1 + len1;
- const xp_char_t* end2 = s2 + len2;
+ sse_char_t c1, c2;
+ const sse_char_t* end1 = s1 + len1;
+ const sse_char_t* end2 = s2 + len2;
while (s1 < end1)
{
@@ -697,21 +697,21 @@ int xp_awk_strxncmp (
return (s2 < end2)? -1: 0;
}
-int xp_awk_strxncasecmp (
- xp_awk_t* awk,
- const xp_char_t* s1, xp_size_t len1,
- const xp_char_t* s2, xp_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)
{
- xp_char_t c1, c2;
- const xp_char_t* end1 = s1 + len1;
- const xp_char_t* end2 = s2 + len2;
+ sse_char_t c1, c2;
+ const sse_char_t* end1 = s1 + len1;
+ const sse_char_t* end2 = s2 + len2;
while (s1 < end1)
{
- c1 = XP_AWK_TOUPPER (awk, *s1);
+ c1 = SSE_AWK_TOUPPER (awk, *s1);
if (s2 < end2)
{
- c2 = XP_AWK_TOUPPER (awk, *s2);
+ c2 = SSE_AWK_TOUPPER (awk, *s2);
if (c1 > c2) return 1;
if (c1 < c2) return -1;
}
@@ -722,24 +722,24 @@ int xp_awk_strxncasecmp (
return (s2 < end2)? -1: 0;
}
-xp_char_t* xp_awk_strxnstr (
- const xp_char_t* str, xp_size_t strsz,
- const xp_char_t* sub, xp_size_t subsz)
+sse_char_t* sse_awk_strxnstr (
+ const sse_char_t* str, sse_size_t strsz,
+ const sse_char_t* sub, sse_size_t subsz)
{
- const xp_char_t* end, * subp;
+ const sse_char_t* end, * subp;
- if (subsz == 0) return (xp_char_t*)str;
- if (strsz < subsz) return XP_NULL;
+ if (subsz == 0) return (sse_char_t*)str;
+ if (strsz < subsz) return SSE_NULL;
end = str + strsz - subsz;
subp = sub + subsz;
while (str <= end) {
- const xp_char_t* x = str;
- const xp_char_t* y = sub;
+ const sse_char_t* x = str;
+ const sse_char_t* y = sub;
- while (xp_true) {
- if (y >= subp) return (xp_char_t*)str;
+ while (sse_true) {
+ if (y >= subp) return (sse_char_t*)str;
if (*x != *y) break;
x++; y++;
}
@@ -747,47 +747,47 @@ xp_char_t* xp_awk_strxnstr (
str++;
}
- return XP_NULL;
+ return SSE_NULL;
}
-xp_char_t* xp_awk_strtok (
- xp_awk_run_t* run, const xp_char_t* s,
- const xp_char_t* delim, xp_char_t** tok, xp_size_t* tok_len)
+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)
{
- return xp_awk_strxntok (
- run, s, xp_awk_strlen(s),
- delim, xp_awk_strlen(delim), tok, tok_len);
+ return sse_awk_strxntok (
+ run, s, sse_awk_strlen(s),
+ delim, sse_awk_strlen(delim), tok, tok_len);
}
-xp_char_t* xp_awk_strxtok (
- xp_awk_run_t* run, const xp_char_t* s, xp_size_t len,
- const xp_char_t* delim, xp_char_t** tok, xp_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)
{
- return xp_awk_strxntok (
+ return sse_awk_strxntok (
run, s, len,
- delim, xp_awk_strlen(delim), tok, tok_len);
+ delim, sse_awk_strlen(delim), tok, tok_len);
}
-xp_char_t* xp_awk_strntok (
- xp_awk_run_t* run, const xp_char_t* s,
- const xp_char_t* delim, xp_size_t delim_len,
- xp_char_t** tok, xp_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)
{
- return xp_awk_strxntok (
- run, s, xp_awk_strlen(s),
+ return sse_awk_strxntok (
+ run, s, sse_awk_strlen(s),
delim, delim_len, tok, tok_len);
}
-xp_char_t* xp_awk_strxntok (
- xp_awk_run_t* run, const xp_char_t* s, xp_size_t len,
- const xp_char_t* delim, xp_size_t delim_len,
- xp_char_t** tok, xp_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)
{
- const xp_char_t* p = s, *d;
- const xp_char_t* end = s + len;
- const xp_char_t* sp = XP_NULL, * ep = XP_NULL;
- const xp_char_t* delim_end = delim + delim_len;
- xp_char_t c;
+ const sse_char_t* p = s, *d;
+ const sse_char_t* end = s + len;
+ const sse_char_t* sp = SSE_NULL, * ep = SSE_NULL;
+ const sse_char_t* delim_end = delim + delim_len;
+ sse_char_t c;
int delim_mode;
#define __DELIM_NULL 0
@@ -795,14 +795,14 @@ xp_char_t* xp_awk_strxntok (
#define __DELIM_SPACES 2
#define __DELIM_NOSPACES 3
#define __DELIM_COMPOSITE 4
- if (delim == XP_NULL) delim_mode = __DELIM_NULL;
+ if (delim == SSE_NULL) delim_mode = __DELIM_NULL;
else
{
delim_mode = __DELIM_EMPTY;
for (d = delim; d < delim_end; d++)
{
- if (XP_AWK_ISSPACE(run->awk,*d))
+ if (SSE_AWK_ISSPACE(run->awk,*d))
{
if (delim_mode == __DELIM_EMPTY)
delim_mode = __DELIM_SPACES;
@@ -827,18 +827,18 @@ xp_char_t* xp_awk_strxntok (
if (delim_mode == __DELIM_NULL)
{
- /* when XP_NULL is given as "delim", it trims off the
+ /* when SSE_NULL is given as "delim", it trims off the
* leading and trailing spaces characters off the source
* string "s" eventually. */
- while (p < end && XP_AWK_ISSPACE(run->awk,*p)) p++;
+ while (p < end && SSE_AWK_ISSPACE(run->awk,*p)) p++;
while (p < end)
{
c = *p;
- if (!XP_AWK_ISSPACE(run->awk,c))
+ if (!SSE_AWK_ISSPACE(run->awk,c))
{
- if (sp == XP_NULL) sp = p;
+ if (sp == SSE_NULL) sp = p;
ep = p;
}
p++;
@@ -859,15 +859,15 @@ xp_char_t* xp_awk_strxntok (
/* each token is delimited by space characters. all leading
* and trailing spaces are removed. */
- while (p < end && XP_AWK_ISSPACE(run->awk,*p)) p++;
+ while (p < end && SSE_AWK_ISSPACE(run->awk,*p)) p++;
while (p < end)
{
c = *p;
- if (XP_AWK_ISSPACE(run->awk,c)) break;
- if (sp == XP_NULL) sp = p;
+ if (SSE_AWK_ISSPACE(run->awk,c)) break;
+ if (sp == SSE_NULL) sp = p;
ep = p++;
}
- while (p < end && XP_AWK_ISSPACE(run->awk,*p)) p++;
+ while (p < end && SSE_AWK_ISSPACE(run->awk,*p)) p++;
}
else if (delim_mode == __DELIM_NOSPACES)
{
@@ -877,13 +877,13 @@ xp_char_t* xp_awk_strxntok (
{
while (p < end)
{
- c = XP_AWK_TOUPPER(run->awk, *p);
+ c = SSE_AWK_TOUPPER(run->awk, *p);
for (d = delim; d < delim_end; d++)
{
- if (c == XP_AWK_TOUPPER(run->awk,*d)) goto exit_loop;
+ if (c == SSE_AWK_TOUPPER(run->awk,*d)) goto exit_loop;
}
- if (sp == XP_NULL) sp = p;
+ if (sp == SSE_NULL) sp = p;
ep = p++;
}
}
@@ -897,7 +897,7 @@ xp_char_t* xp_awk_strxntok (
if (c == *d) goto exit_loop;
}
- if (sp == XP_NULL) sp = p;
+ if (sp == SSE_NULL) sp = p;
ep = p++;
}
}
@@ -907,22 +907,22 @@ xp_char_t* xp_awk_strxntok (
/* each token is delimited by one of non-space charaters
* in the delimeter set "delim". however, all space characters
* surrounding the token are removed */
- while (p < end && XP_AWK_ISSPACE(run->awk,*p)) p++;
+ while (p < end && SSE_AWK_ISSPACE(run->awk,*p)) p++;
if (run->global.ignorecase)
{
while (p < end)
{
- c = XP_AWK_TOUPPER(run->awk, *p);
- if (XP_AWK_ISSPACE(run->awk,c))
+ c = SSE_AWK_TOUPPER(run->awk, *p);
+ if (SSE_AWK_ISSPACE(run->awk,c))
{
p++;
continue;
}
for (d = delim; d < delim_end; d++)
{
- if (c == XP_AWK_TOUPPER(run->awk,*d)) goto exit_loop;
+ if (c == SSE_AWK_TOUPPER(run->awk,*d)) goto exit_loop;
}
- if (sp == XP_NULL) sp = p;
+ if (sp == SSE_NULL) sp = p;
ep = p++;
}
}
@@ -931,7 +931,7 @@ xp_char_t* xp_awk_strxntok (
while (p < end)
{
c = *p;
- if (XP_AWK_ISSPACE(run->awk,c))
+ if (SSE_AWK_ISSPACE(run->awk,c))
{
p++;
continue;
@@ -940,76 +940,76 @@ xp_char_t* xp_awk_strxntok (
{
if (c == *d) goto exit_loop;
}
- if (sp == XP_NULL) sp = p;
+ if (sp == SSE_NULL) sp = p;
ep = p++;
}
}
}
exit_loop:
- if (sp == XP_NULL)
+ if (sp == SSE_NULL)
{
- *tok = XP_NULL;
- *tok_len = (xp_size_t)0;
+ *tok = SSE_NULL;
+ *tok_len = (sse_size_t)0;
}
else
{
- *tok = (xp_char_t*)sp;
+ *tok = (sse_char_t*)sp;
*tok_len = ep - sp + 1;
}
- /* if XP_NULL is returned, this function should not be called anymore */
- if (p >= end) return XP_NULL;
+ /* if SSE_NULL is returned, this function should not be called anymore */
+ if (p >= end) return SSE_NULL;
if (delim_mode == __DELIM_EMPTY ||
- delim_mode == __DELIM_SPACES) return (xp_char_t*)p;
- return (xp_char_t*)++p;
+ delim_mode == __DELIM_SPACES) return (sse_char_t*)p;
+ return (sse_char_t*)++p;
}
-xp_char_t* xp_awk_strxntokbyrex (
- xp_awk_run_t* run, const xp_char_t* s, xp_size_t len,
- void* rex, xp_char_t** tok, xp_size_t* tok_len, int* errnum)
+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)
{
int n;
- xp_char_t* match_ptr;
- xp_size_t match_len, i;
- xp_size_t left = len;
- const xp_char_t* ptr = s;
- const xp_char_t* str_ptr = s;
- xp_size_t str_len = len;
+ sse_char_t* match_ptr;
+ sse_size_t match_len, i;
+ sse_size_t left = len;
+ const sse_char_t* ptr = s;
+ const sse_char_t* str_ptr = s;
+ sse_size_t str_len = len;
while (len > 0)
{
- n = xp_awk_matchrex (
+ n = sse_awk_matchrex (
run->awk, rex,
- ((run->global.ignorecase)? XP_AWK_REX_IGNORECASE: 0),
- ptr, left, (const xp_char_t**)&match_ptr, &match_len,
+ ((run->global.ignorecase)? SSE_AWK_REX_IGNORECASE: 0),
+ ptr, left, (const sse_char_t**)&match_ptr, &match_len,
errnum);
- if (n == -1) return XP_NULL;
+ if (n == -1) return SSE_NULL;
if (n == 0)
{
/* no match has been found.
* return the entire string as a token */
- *tok = (xp_char_t*)str_ptr;
+ *tok = (sse_char_t*)str_ptr;
*tok_len = str_len;
- *errnum = XP_AWK_ENOERR;
- return XP_NULL;
+ *errnum = SSE_AWK_ENOERR;
+ return SSE_NULL;
}
- xp_awk_assert (run->awk, n == 1);
+ sse_awk_assert (run->awk, n == 1);
if (match_len == 0)
{
ptr++;
left--;
}
- else if (run->awk->option & XP_AWK_STRIPSPACES)
+ else if (run->awk->option & SSE_AWK_STRIPSPACES)
{
/* match at the beginning of the input string */
if (match_ptr == s)
{
for (i = 0; i < match_len; i++)
{
- if (!XP_AWK_ISSPACE(run->awk, match_ptr[i]))
+ if (!SSE_AWK_ISSPACE(run->awk, match_ptr[i]))
goto exit_loop;
}
@@ -1028,44 +1028,44 @@ xp_char_t* xp_awk_strxntokbyrex (
exit_loop:
if (len == 0)
{
- *tok = (xp_char_t*)str_ptr;
+ *tok = (sse_char_t*)str_ptr;
*tok_len = str_len;
- *errnum = XP_AWK_ENOERR;
- return XP_NULL;
+ *errnum = SSE_AWK_ENOERR;
+ return SSE_NULL;
}
- *tok = (xp_char_t*)str_ptr;
+ *tok = (sse_char_t*)str_ptr;
*tok_len = match_ptr - str_ptr;
for (i = 0; i < match_len; i++)
{
- if (!XP_AWK_ISSPACE(run->awk, match_ptr[i]))
+ if (!SSE_AWK_ISSPACE(run->awk, match_ptr[i]))
{
- *errnum = XP_AWK_ENOERR;
+ *errnum = SSE_AWK_ENOERR;
return match_ptr+match_len;
}
}
- *errnum = XP_AWK_ENOERR;
+ *errnum = SSE_AWK_ENOERR;
- if (run->awk->option & XP_AWK_STRIPSPACES)
+ if (run->awk->option & SSE_AWK_STRIPSPACES)
{
return (match_ptr+match_len >= s+len)?
- XP_NULL: (match_ptr+match_len);
+ SSE_NULL: (match_ptr+match_len);
}
else
{
return (match_ptr+match_len > s+len)?
- XP_NULL: (match_ptr+match_len);
+ SSE_NULL: (match_ptr+match_len);
}
}
-int xp_awk_abort (xp_awk_t* awk,
- const xp_char_t* expr, const xp_char_t* file, int line)
+int sse_awk_abort (sse_awk_t* awk,
+ const sse_char_t* esser, const sse_char_t* file, int line)
{
awk->syscas.dprintf (
- XP_T("ASSERTION FAILURE AT FILE %s, LINE %d\n%s\n"),
- file, line, expr);
+ SSE_T("ASSERTION FAILURE AT FILE %s, LINE %d\n%s\n"),
+ file, line, esser);
awk->syscas.abort ();
return 0;
}
diff --git a/ase/awk/misc.h b/ase/awk/misc.h
index db6b9230..9e860138 100644
--- a/ase/awk/misc.h
+++ b/ase/awk/misc.h
@@ -1,45 +1,45 @@
/*
- * $Id: misc.h,v 1.3 2006-10-12 04:17:31 bacon Exp $
+ * $Id: misc.h,v 1.4 2006-10-22 11:34:53 bacon Exp $
*/
-#ifndef _XP_AWK_MISC_H_
-#define _XP_AWK_MISC_H_
+#ifndef _SSE_AWK_MISC_H_
+#define _SSE_AWK_MISC_H_
-#ifndef _XP_AWK_AWK_H_
-#error Never include this file directly. Include <xp/awk/awk.h> instead
+#ifndef _SSE_AWK_AWK_H_
+#error Never include this file directly. Include <sse/awk/awk.h> instead
#endif
#ifdef __cplusplus
extern "C" {
#endif
-void* xp_awk_memcpy (void* dst, const void* src, xp_size_t n);
-void* xp_awk_memset (void* dst, int val, xp_size_t n);
+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);
-xp_char_t* xp_awk_strtok (
- xp_awk_run_t* run, const xp_char_t* s,
- const xp_char_t* delim, xp_char_t** tok, xp_size_t* tok_len);
+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);
-xp_char_t* xp_awk_strxtok (
- xp_awk_run_t* run, const xp_char_t* s, xp_size_t len,
- const xp_char_t* delim, xp_char_t** tok, xp_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);
-xp_char_t* xp_awk_strntok (
- xp_awk_run_t* run, const xp_char_t* s,
- const xp_char_t* delim, xp_size_t delim_len,
- xp_char_t** tok, xp_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);
-xp_char_t* xp_awk_strxntok (
- xp_awk_run_t* run, const xp_char_t* s, xp_size_t len,
- const xp_char_t* delim, xp_size_t delim_len,
- xp_char_t** tok, xp_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);
-xp_char_t* xp_awk_strxntokbyrex (
- xp_awk_run_t* run, const xp_char_t* s, xp_size_t len,
- void* rex, xp_char_t** tok, xp_size_t* tok_len, int* errnum);
+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);
-int xp_awk_abort (xp_awk_t* awk,
- const xp_char_t* expr, const xp_char_t* file, int line);
+int sse_awk_abort (sse_awk_t* awk,
+ const sse_char_t* esser, const sse_char_t* file, int line);
#ifdef __cplusplus
}
diff --git a/ase/awk/parse.c b/ase/awk/parse.c
index bf472097..7d23dcdf 100644
--- a/ase/awk/parse.c
+++ b/ase/awk/parse.c
@@ -1,8 +1,8 @@
/*
- * $Id: parse.c,v 1.191 2006-10-19 11:08:54 bacon Exp $
+ * $Id: parse.c,v 1.192 2006-10-22 11:34:53 bacon Exp $
*/
-#include <xp/awk/awk_i.h>
+#include <sse/awk/awk_i.h>
enum
{
@@ -17,7 +17,7 @@ enum
TOKEN_MUL_ASSIGN,
TOKEN_DIV_ASSIGN,
TOKEN_MOD_ASSIGN,
- TOKEN_EXP_ASSIGN,
+ TOKEN_ESSE_ASSIGN,
TOKEN_EQ,
TOKEN_NE,
@@ -44,7 +44,7 @@ enum
TOKEN_RSHIFT,
TOKEN_LSHIFT,
TOKEN_IN,
- TOKEN_EXP,
+ TOKEN_ESSE,
TOKEN_LPAREN,
TOKEN_RPAREN,
@@ -120,94 +120,94 @@ struct __binmap_t
int binop;
};
-static xp_awk_t* __parse_progunit (xp_awk_t* awk);
-static xp_awk_t* __collect_globals (xp_awk_t* awk);
-static xp_awk_t* __add_builtin_globals (xp_awk_t* awk);
-static xp_awk_t* __add_global (
- xp_awk_t* awk, const xp_char_t* name, xp_size_t name_len);
-static xp_awk_t* __collect_locals (xp_awk_t* awk, xp_size_t nlocals);
+static sse_awk_t* __parse_progunit (sse_awk_t* awk);
+static sse_awk_t* __collect_globals (sse_awk_t* awk);
+static sse_awk_t* __add_builtin_globals (sse_awk_t* awk);
+static sse_awk_t* __add_global (
+ sse_awk_t* awk, const sse_char_t* name, sse_size_t name_len);
+static sse_awk_t* __collect_locals (sse_awk_t* awk, sse_size_t nlocals);
-static xp_awk_nde_t* __parse_function (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_begin (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_end (xp_awk_t* awk);
-static xp_awk_chain_t* __parse_pattern_block (
- xp_awk_t* awk, xp_awk_nde_t* ptn, xp_bool_t blockless);
+static sse_awk_nde_t* __parse_function (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_begin (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_end (sse_awk_t* awk);
+static sse_awk_chain_t* __parse_pattern_block (
+ sse_awk_t* awk, sse_awk_nde_t* ptn, sse_bool_t blockless);
-static xp_awk_nde_t* __parse_block (xp_awk_t* awk, xp_bool_t is_top);
-static xp_awk_nde_t* __parse_statement (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_statement_nb (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_expression (xp_awk_t* awk);
+static sse_awk_nde_t* __parse_block (sse_awk_t* awk, sse_bool_t is_top);
+static sse_awk_nde_t* __parse_statement (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_statement_nb (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_esseression (sse_awk_t* awk);
-static xp_awk_nde_t* __parse_basic_expr (xp_awk_t* awk);
+static sse_awk_nde_t* __parse_basic_esser (sse_awk_t* awk);
-static xp_awk_nde_t* __parse_binary_expr (
- xp_awk_t* awk, const __binmap_t* binmap,
- xp_awk_nde_t*(*next_level_func)(xp_awk_t*));
+static sse_awk_nde_t* __parse_binary_esser (
+ sse_awk_t* awk, const __binmap_t* binmap,
+ sse_awk_nde_t*(*next_level_func)(sse_awk_t*));
-static xp_awk_nde_t* __parse_logical_or (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_logical_and (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_in (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_regex_match (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_bitwise_or (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_bitwise_or_with_extio (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_bitwise_xor (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_bitwise_and (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_equality (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_relational (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_shift (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_concat (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_additive (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_multiplicative (xp_awk_t* awk);
+static sse_awk_nde_t* __parse_logical_or (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_logical_and (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_in (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_regex_match (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_bitwise_or (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_bitwise_or_with_extio (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_bitwise_xor (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_bitwise_and (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_equality (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_relational (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_shift (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_concat (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_additive (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_multiplicative (sse_awk_t* awk);
-static xp_awk_nde_t* __parse_unary (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_increment (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_primary (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_primary_ident (xp_awk_t* awk);
+static sse_awk_nde_t* __parse_unary (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_increment (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_primary (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_primary_ident (sse_awk_t* awk);
-static xp_awk_nde_t* __parse_hashidx (
- xp_awk_t* awk, xp_char_t* name, xp_size_t name_len);
-static xp_awk_nde_t* __parse_fncall (
- xp_awk_t* awk, xp_char_t* name, xp_size_t name_len, xp_awk_bfn_t* bfn);
-static xp_awk_nde_t* __parse_if (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_while (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_for (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_dowhile (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_break (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_continue (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_return (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_exit (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_next (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_nextfile (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_delete (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_print (xp_awk_t* awk);
-static xp_awk_nde_t* __parse_printf (xp_awk_t* awk);
+static sse_awk_nde_t* __parse_hashidx (
+ sse_awk_t* awk, sse_char_t* name, sse_size_t name_len);
+static sse_awk_nde_t* __parse_fncall (
+ sse_awk_t* awk, sse_char_t* name, sse_size_t name_len, sse_awk_bfn_t* bfn);
+static sse_awk_nde_t* __parse_if (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_while (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_for (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_dowhile (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_break (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_continue (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_return (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_exit (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_next (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_nextfile (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_delete (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_print (sse_awk_t* awk);
+static sse_awk_nde_t* __parse_printf (sse_awk_t* awk);
-static int __get_token (xp_awk_t* awk);
-static int __get_number (xp_awk_t* awk);
-static int __get_charstr (xp_awk_t* awk);
-static int __get_rexstr (xp_awk_t* awk);
+static int __get_token (sse_awk_t* awk);
+static int __get_number (sse_awk_t* awk);
+static int __get_charstr (sse_awk_t* awk);
+static int __get_rexstr (sse_awk_t* awk);
static int __get_string (
- xp_awk_t* awk, xp_char_t end_char,
- xp_char_t esc_char, xp_bool_t keep_esc_char);
-static int __get_char (xp_awk_t* awk);
-static int __unget_char (xp_awk_t* awk, xp_cint_t c);
-static int __skip_spaces (xp_awk_t* awk);
-static int __skip_comment (xp_awk_t* awk);
+ sse_awk_t* awk, sse_char_t end_char,
+ sse_char_t esc_char, sse_bool_t keep_esc_char);
+static int __get_char (sse_awk_t* awk);
+static int __unget_char (sse_awk_t* awk, sse_cint_t c);
+static int __skip_spaces (sse_awk_t* awk);
+static int __skip_comment (sse_awk_t* awk);
static int __classify_ident (
- xp_awk_t* awk, const xp_char_t* name, xp_size_t len);
-static int __assign_to_opcode (xp_awk_t* awk);
-static int __is_plain_var (xp_awk_nde_t* nde);
-static int __is_var (xp_awk_nde_t* nde);
+ sse_awk_t* awk, const sse_char_t* name, sse_size_t len);
+static int __assign_to_opcode (sse_awk_t* awk);
+static int __is_plain_var (sse_awk_nde_t* nde);
+static int __is_var (sse_awk_nde_t* nde);
-static int __deparse (xp_awk_t* awk);
-static int __deparse_func (xp_awk_pair_t* pair, void* arg);
-static int __put_char (xp_awk_t* awk, xp_char_t c);
-static int __flush (xp_awk_t* awk);
+static int __deparse (sse_awk_t* awk);
+static int __deparse_func (sse_awk_pair_t* pair, void* arg);
+static int __put_char (sse_awk_t* awk, sse_char_t c);
+static int __flush (sse_awk_t* awk);
struct __kwent
{
- const xp_char_t* name;
- xp_size_t name_len;
+ const sse_char_t* name;
+ sse_size_t name_len;
int type;
int valid; /* the entry is valid when this option is set */
};
@@ -215,69 +215,69 @@ struct __kwent
static struct __kwent __kwtab[] =
{
/* operators */
- { XP_T("in"), 2, TOKEN_IN, 0 },
+ { SSE_T("in"), 2, TOKEN_IN, 0 },
/* top-level block starters */
- { XP_T("BEGIN"), 5, TOKEN_BEGIN, 0 },
- { XP_T("END"), 3, TOKEN_END, 0 },
- { XP_T("function"), 8, TOKEN_FUNCTION, 0 },
- { XP_T("func"), 4, TOKEN_FUNCTION, 0 },
+ { SSE_T("BEGIN"), 5, TOKEN_BEGIN, 0 },
+ { SSE_T("END"), 3, TOKEN_END, 0 },
+ { SSE_T("function"), 8, TOKEN_FUNCTION, 0 },
+ { SSE_T("func"), 4, TOKEN_FUNCTION, 0 },
/* keywords for variable declaration */
- { XP_T("local"), 5, TOKEN_LOCAL, XP_AWK_EXPLICIT },
- { XP_T("global"), 6, TOKEN_GLOBAL, XP_AWK_EXPLICIT },
+ { SSE_T("local"), 5, TOKEN_LOCAL, SSE_AWK_ESSELICIT },
+ { SSE_T("global"), 6, TOKEN_GLOBAL, SSE_AWK_ESSELICIT },
- /* keywords that start statements excluding expression statements */
- { XP_T("if"), 2, TOKEN_IF, 0 },
- { XP_T("else"), 4, TOKEN_ELSE, 0 },
- { XP_T("while"), 5, TOKEN_WHILE, 0 },
- { XP_T("for"), 3, TOKEN_FOR, 0 },
- { XP_T("do"), 2, TOKEN_DO, 0 },
- { XP_T("break"), 5, TOKEN_BREAK, 0 },
- { XP_T("continue"), 8, TOKEN_CONTINUE, 0 },
- { XP_T("return"), 6, TOKEN_RETURN, 0 },
- { XP_T("exit"), 4, TOKEN_EXIT, 0 },
- { XP_T("next"), 4, TOKEN_NEXT, 0 },
- { XP_T("nextfile"), 8, TOKEN_NEXTFILE, 0 },
- { XP_T("delete"), 6, TOKEN_DELETE, 0 },
- { XP_T("print"), 5, TOKEN_PRINT, XP_AWK_EXTIO },
- { XP_T("printf"), 6, TOKEN_PRINTF, XP_AWK_EXTIO },
+ /* keywords that start statements excluding esseression statements */
+ { SSE_T("if"), 2, TOKEN_IF, 0 },
+ { SSE_T("else"), 4, TOKEN_ELSE, 0 },
+ { SSE_T("while"), 5, TOKEN_WHILE, 0 },
+ { SSE_T("for"), 3, TOKEN_FOR, 0 },
+ { SSE_T("do"), 2, TOKEN_DO, 0 },
+ { SSE_T("break"), 5, TOKEN_BREAK, 0 },
+ { SSE_T("continue"), 8, TOKEN_CONTINUE, 0 },
+ { SSE_T("return"), 6, TOKEN_RETURN, 0 },
+ { SSE_T("exit"), 4, TOKEN_EXIT, 0 },
+ { SSE_T("next"), 4, TOKEN_NEXT, 0 },
+ { SSE_T("nextfile"), 8, TOKEN_NEXTFILE, 0 },
+ { SSE_T("delete"), 6, TOKEN_DELETE, 0 },
+ { SSE_T("print"), 5, TOKEN_PRINT, SSE_AWK_EXTIO },
+ { SSE_T("printf"), 6, TOKEN_PRINTF, SSE_AWK_EXTIO },
- /* keywords that can start an expression */
- { XP_T("getline"), 7, TOKEN_GETLINE, XP_AWK_EXTIO },
+ /* keywords that can start an esseression */
+ { SSE_T("getline"), 7, TOKEN_GETLINE, SSE_AWK_EXTIO },
- { XP_NULL, 0, 0 }
+ { SSE_NULL, 0, 0 }
};
struct __bvent
{
- const xp_char_t* name;
- xp_size_t name_len;
+ const sse_char_t* name;
+ sse_size_t name_len;
int valid;
};
static struct __bvent __bvtab[] =
{
- { XP_T("ARGC"), 4, 0 },
- { XP_T("ARGV"), 4, 0 },
- { XP_T("CONVFMT"), 7, 0 },
- { XP_T("ENVIRON"), 7, 0 },
- { XP_T("ERRNO"), 5, 0 },
- { XP_T("FILENAME"), 8, 0 },
- { XP_T("FNR"), 3, 0 },
- { XP_T("FS"), 2, 0 },
- { XP_T("IGNORECASE"), 10, 0 },
- { XP_T("NF"), 2, 0 },
- { XP_T("NR"), 2, 0 },
- { XP_T("OFMT"), 4, 0 },
- { XP_T("OFS"), 3, 0 },
- { XP_T("ORS"), 3, 0 },
- { XP_T("RS"), 2, 0 },
- { XP_T("RT"), 2, 0 },
- { XP_T("RSTART"), 6, 0 },
- { XP_T("RLENGTH"), 7, 0 },
- { XP_T("SUBSEP"), 6, 0 },
- { XP_NULL, 0, 0 }
+ { SSE_T("ARGC"), 4, 0 },
+ { SSE_T("ARGV"), 4, 0 },
+ { SSE_T("CONVFMT"), 7, 0 },
+ { SSE_T("ENVIRON"), 7, 0 },
+ { SSE_T("ERRNO"), 5, 0 },
+ { SSE_T("FILENAME"), 8, 0 },
+ { SSE_T("FNR"), 3, 0 },
+ { SSE_T("FS"), 2, 0 },
+ { SSE_T("IGNORECASE"), 10, 0 },
+ { SSE_T("NF"), 2, 0 },
+ { SSE_T("NR"), 2, 0 },
+ { SSE_T("OFMT"), 4, 0 },
+ { SSE_T("OFS"), 3, 0 },
+ { SSE_T("ORS"), 3, 0 },
+ { SSE_T("RS"), 2, 0 },
+ { SSE_T("RT"), 2, 0 },
+ { SSE_T("RSTART"), 6, 0 },
+ { SSE_T("RLENGTH"), 7, 0 },
+ { SSE_T("SUBSEP"), 6, 0 },
+ { SSE_NULL, 0, 0 }
};
#define GET_CHAR(awk) \
@@ -297,43 +297,43 @@ static struct __bvent __bvtab[] =
#define ADD_TOKEN_CHAR(awk,c) \
do { \
- if (xp_awk_str_ccat(&(awk)->token.name,(c)) == (xp_size_t)-1) { \
- (awk)->errnum = XP_AWK_ENOMEM; return -1; \
+ if (sse_awk_str_ccat(&(awk)->token.name,(c)) == (sse_size_t)-1) { \
+ (awk)->errnum = SSE_AWK_ENOMEM; return -1; \
} \
} while (0)
#define ADD_TOKEN_STR(awk,str) \
do { \
- if (xp_awk_str_cat(&(awk)->token.name,(str)) == (xp_size_t)-1) { \
- (awk)->errnum = XP_AWK_ENOMEM; return -1; \
+ if (sse_awk_str_cat(&(awk)->token.name,(str)) == (sse_size_t)-1) { \
+ (awk)->errnum = SSE_AWK_ENOMEM; return -1; \
} \
} while (0)
#define MATCH(awk,token_type) ((awk)->token.type == (token_type))
#define PANIC(awk,code) \
- do { (awk)->errnum = (code); return XP_NULL; } while (0)
+ do { (awk)->errnum = (code); return SSE_NULL; } while (0)
-int xp_awk_parse (xp_awk_t* awk, xp_awk_srcios_t* srcios)
+int sse_awk_parse (sse_awk_t* awk, sse_awk_srcios_t* srcios)
{
int n = 0, op;
- xp_awk_assert (awk, srcios != XP_NULL && srcios->in != XP_NULL);
+ sse_awk_assert (awk, srcios != SSE_NULL && srcios->in != SSE_NULL);
- xp_awk_clear (awk);
+ sse_awk_clear (awk);
awk->src.ios = srcios;
op = awk->src.ios->in (
- XP_AWK_IO_OPEN, awk->src.ios->custom_data, XP_NULL, 0);
+ SSE_AWK_IO_OPEN, awk->src.ios->custom_data, SSE_NULL, 0);
if (op == -1)
{
/* cannot open the source file.
* it doesn't even have to call CLOSE */
- awk->errnum = XP_AWK_ESRCINOPEN;
+ awk->errnum = SSE_AWK_ESRCINOPEN;
return -1;
}
- if (__add_builtin_globals (awk) == XP_NULL)
+ if (__add_builtin_globals (awk) == SSE_NULL)
{
n = -1;
goto exit_parse;
@@ -364,7 +364,7 @@ int xp_awk_parse (xp_awk_t* awk, xp_awk_srcios_t* srcios)
if (MATCH(awk,TOKEN_EOF)) break;
if (MATCH(awk,TOKEN_NEWLINE)) continue;
- if (__parse_progunit (awk) == XP_NULL)
+ if (__parse_progunit (awk) == SSE_NULL)
{
n = -1;
goto exit_parse;
@@ -372,9 +372,9 @@ int xp_awk_parse (xp_awk_t* awk, xp_awk_srcios_t* srcios)
}
}
- awk->tree.nglobals = xp_awk_tab_getsize(&awk->parse.globals);
+ awk->tree.nglobals = sse_awk_tab_getsize(&awk->parse.globals);
- if (awk->src.ios->out != XP_NULL)
+ if (awk->src.ios->out != SSE_NULL)
{
if (__deparse (awk) == -1)
{
@@ -385,151 +385,151 @@ int xp_awk_parse (xp_awk_t* awk, xp_awk_srcios_t* srcios)
exit_parse:
if (awk->src.ios->in (
- XP_AWK_IO_CLOSE, awk->src.ios->custom_data, XP_NULL, 0) == -1)
+ SSE_AWK_IO_CLOSE, awk->src.ios->custom_data, SSE_NULL, 0) == -1)
{
if (n != -1)
{
/* this is to keep the earlier error above
* that might be more critical than this */
- awk->errnum = XP_AWK_ESRCINCLOSE;
+ awk->errnum = SSE_AWK_ESRCINCLOSE;
n = -1;
}
}
- if (n == -1) xp_awk_clear (awk);
+ if (n == -1) sse_awk_clear (awk);
return n;
}
-static xp_awk_t* __parse_progunit (xp_awk_t* awk)
+static sse_awk_t* __parse_progunit (sse_awk_t* awk)
{
/*
pattern { action }
function name (parameter-list) { statement }
*/
- xp_awk_assert (awk, awk->parse.depth.loop == 0);
+ sse_awk_assert (awk, awk->parse.depth.loop == 0);
- if ((awk->option & XP_AWK_EXPLICIT) && MATCH(awk,TOKEN_GLOBAL))
+ if ((awk->option & SSE_AWK_ESSELICIT) && MATCH(awk,TOKEN_GLOBAL))
{
- xp_size_t nglobals;
+ sse_size_t nglobals;
awk->parse.id.block = PARSE_GLOBAL;
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
- nglobals = xp_awk_tab_getsize(&awk->parse.globals);
- if (__collect_globals (awk) == XP_NULL)
+ nglobals = sse_awk_tab_getsize(&awk->parse.globals);
+ if (__collect_globals (awk) == SSE_NULL)
{
- xp_awk_tab_remove (
+ sse_awk_tab_remove (
&awk->parse.globals, nglobals,
- xp_awk_tab_getsize(&awk->parse.globals) - nglobals);
- return XP_NULL;
+ sse_awk_tab_getsize(&awk->parse.globals) - nglobals);
+ return SSE_NULL;
}
}
else if (MATCH(awk,TOKEN_FUNCTION))
{
awk->parse.id.block = PARSE_FUNCTION;
- if (__parse_function (awk) == XP_NULL) return XP_NULL;
+ if (__parse_function (awk) == SSE_NULL) return SSE_NULL;
}
else if (MATCH(awk,TOKEN_BEGIN))
{
awk->parse.id.block = PARSE_BEGIN;
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
- if ((awk->option & XP_AWK_BLOCKLESS) &&
+ if ((awk->option & SSE_AWK_BLOCKLESS) &&
(MATCH(awk,TOKEN_NEWLINE) || MATCH(awk,TOKEN_EOF)))
{
/* when the blockless pattern is supported
* BEGIN and { should be located on the same line */
- PANIC (awk, XP_AWK_EBEGINBLOCK);
+ PANIC (awk, SSE_AWK_EBEGINBLOCK);
}
- if (!MATCH(awk,TOKEN_LBRACE)) PANIC (awk, XP_AWK_ELBRACE);
+ if (!MATCH(awk,TOKEN_LBRACE)) PANIC (awk, SSE_AWK_ELBRACE);
awk->parse.id.block = PARSE_BEGIN_BLOCK;
- if (__parse_begin (awk) == XP_NULL) return XP_NULL;
+ if (__parse_begin (awk) == SSE_NULL) return SSE_NULL;
}
else if (MATCH(awk,TOKEN_END))
{
awk->parse.id.block = PARSE_END;
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
- if ((awk->option & XP_AWK_BLOCKLESS) &&
+ if ((awk->option & SSE_AWK_BLOCKLESS) &&
(MATCH(awk,TOKEN_NEWLINE) || MATCH(awk,TOKEN_EOF)))
{
/* when the blockless pattern is supported
* END and { should be located on the same line */
- PANIC (awk, XP_AWK_EENDBLOCK);
+ PANIC (awk, SSE_AWK_EENDBLOCK);
}
- if (!MATCH(awk,TOKEN_LBRACE)) PANIC (awk, XP_AWK_ELBRACE);
+ if (!MATCH(awk,TOKEN_LBRACE)) PANIC (awk, SSE_AWK_ELBRACE);
awk->parse.id.block = PARSE_END_BLOCK;
- if (__parse_end (awk) == XP_NULL) return XP_NULL;
+ if (__parse_end (awk) == SSE_NULL) return SSE_NULL;
}
else if (MATCH(awk,TOKEN_LBRACE))
{
/* patternless block */
awk->parse.id.block = PARSE_ACTION_BLOCK;
if (__parse_pattern_block (
- awk, XP_NULL, xp_false) == XP_NULL) return XP_NULL;
+ awk, SSE_NULL, sse_false) == SSE_NULL) return SSE_NULL;
}
else
{
/*
- expressions
- /regular expression/
+ esseressions
+ /regular esseression/
pattern && pattern
pattern || pattern
!pattern
(pattern)
pattern, pattern
*/
- xp_awk_nde_t* ptn;
+ sse_awk_nde_t* ptn;
awk->parse.id.block = PARSE_PATTERN;
- ptn = __parse_expression (awk);
- if (ptn == XP_NULL) return XP_NULL;
+ ptn = __parse_esseression (awk);
+ if (ptn == SSE_NULL) return SSE_NULL;
- xp_awk_assert (awk, ptn->next == XP_NULL);
+ sse_awk_assert (awk, ptn->next == SSE_NULL);
if (MATCH(awk,TOKEN_COMMA))
{
if (__get_token (awk) == -1)
{
- xp_awk_clrpt (awk, ptn);
- return XP_NULL;
+ sse_awk_clrpt (awk, ptn);
+ return SSE_NULL;
}
- ptn->next = __parse_expression (awk);
- if (ptn->next == XP_NULL)
+ ptn->next = __parse_esseression (awk);
+ if (ptn->next == SSE_NULL)
{
- xp_awk_clrpt (awk, ptn);
- return XP_NULL;
+ sse_awk_clrpt (awk, ptn);
+ return SSE_NULL;
}
}
- if ((awk->option & XP_AWK_BLOCKLESS) &&
+ if ((awk->option & SSE_AWK_BLOCKLESS) &&
(MATCH(awk,TOKEN_NEWLINE) || MATCH(awk,TOKEN_EOF)))
{
/* blockless pattern */
- xp_bool_t newline = MATCH(awk,TOKEN_NEWLINE);
+ sse_bool_t newline = MATCH(awk,TOKEN_NEWLINE);
awk->parse.id.block = PARSE_ACTION_BLOCK;
if (__parse_pattern_block (
- awk, ptn, xp_true) == XP_NULL)
+ awk, ptn, sse_true) == SSE_NULL)
{
- xp_awk_clrpt (awk, ptn);
- return XP_NULL;
+ sse_awk_clrpt (awk, ptn);
+ return SSE_NULL;
}
if (newline)
{
if (__get_token (awk) == -1)
{
- xp_awk_clrpt (awk, ptn);
- return XP_NULL;
+ sse_awk_clrpt (awk, ptn);
+ return SSE_NULL;
}
}
}
@@ -538,16 +538,16 @@ static xp_awk_t* __parse_progunit (xp_awk_t* awk)
/* parse the action block */
if (!MATCH(awk,TOKEN_LBRACE))
{
- xp_awk_clrpt (awk, ptn);
- PANIC (awk, XP_AWK_ELBRACE);
+ sse_awk_clrpt (awk, ptn);
+ PANIC (awk, SSE_AWK_ELBRACE);
}
awk->parse.id.block = PARSE_ACTION_BLOCK;
if (__parse_pattern_block (
- awk, ptn, xp_false) == XP_NULL)
+ awk, ptn, sse_false) == SSE_NULL)
{
- xp_awk_clrpt (awk, ptn);
- return XP_NULL;
+ sse_awk_clrpt (awk, ptn);
+ return SSE_NULL;
}
}
}
@@ -555,74 +555,74 @@ static xp_awk_t* __parse_progunit (xp_awk_t* awk)
return awk;
}
-static xp_awk_nde_t* __parse_function (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_function (sse_awk_t* awk)
{
- xp_char_t* name;
- xp_char_t* name_dup;
- xp_size_t name_len;
- xp_awk_nde_t* body;
- xp_awk_afn_t* afn;
- xp_size_t nargs;
- xp_awk_pair_t* pair;
+ sse_char_t* name;
+ sse_char_t* name_dup;
+ sse_size_t name_len;
+ sse_awk_nde_t* body;
+ sse_awk_afn_t* afn;
+ sse_size_t nargs;
+ sse_awk_pair_t* pair;
int n;
/* eat up the keyword 'function' and get the next token */
- xp_awk_assert (awk, MATCH(awk,TOKEN_FUNCTION));
- if (__get_token(awk) == -1) return XP_NULL;
+ sse_awk_assert (awk, MATCH(awk,TOKEN_FUNCTION));
+ if (__get_token(awk) == -1) return SSE_NULL;
/* match a function name */
if (!MATCH(awk,TOKEN_IDENT))
{
/* cannot find a valid identifier for a function name */
- PANIC (awk, XP_AWK_EIDENT);
+ PANIC (awk, SSE_AWK_EIDENT);
}
- name = XP_AWK_STR_BUF(&awk->token.name);
- name_len = XP_AWK_STR_LEN(&awk->token.name);
- if (xp_awk_map_get(&awk->tree.afns, name, name_len) != XP_NULL)
+ name = SSE_AWK_STR_BUF(&awk->token.name);
+ name_len = SSE_AWK_STR_LEN(&awk->token.name);
+ if (sse_awk_map_get(&awk->tree.afns, name, name_len) != SSE_NULL)
{
/* the function is defined previously */
- PANIC (awk, XP_AWK_EDUPFUNC);
+ PANIC (awk, SSE_AWK_EDUPFUNC);
}
- if (awk->option & XP_AWK_UNIQUE)
+ if (awk->option & SSE_AWK_UNIQUE)
{
/* check if it coincides to be a global variable name */
- if (xp_awk_tab_find (
- &awk->parse.globals, 0, name, name_len) != (xp_size_t)-1)
+ if (sse_awk_tab_find (
+ &awk->parse.globals, 0, name, name_len) != (sse_size_t)-1)
{
- PANIC (awk, XP_AWK_EDUPNAME);
+ PANIC (awk, SSE_AWK_EDUPNAME);
}
}
/* clone the function name before it is overwritten */
- name_dup = xp_awk_strxdup (awk, name, name_len);
- if (name_dup == XP_NULL) PANIC (awk, XP_AWK_ENOMEM);
+ name_dup = sse_awk_strxdup (awk, name, name_len);
+ if (name_dup == SSE_NULL) PANIC (awk, SSE_AWK_ENOMEM);
/* get the next token */
if (__get_token(awk) == -1)
{
- XP_AWK_FREE (awk, name_dup);
- return XP_NULL;
+ SSE_AWK_FREE (awk, name_dup);
+ return SSE_NULL;
}
/* match a left parenthesis */
if (!MATCH(awk,TOKEN_LPAREN))
{
/* a function name is not followed by a left parenthesis */
- XP_AWK_FREE (awk, name_dup);
- PANIC (awk, XP_AWK_ELPAREN);
+ SSE_AWK_FREE (awk, name_dup);
+ PANIC (awk, SSE_AWK_ELPAREN);
}
/* get the next token */
if (__get_token(awk) == -1)
{
- XP_AWK_FREE (awk, name_dup);
- return XP_NULL;
+ SSE_AWK_FREE (awk, name_dup);
+ return SSE_NULL;
}
/* make sure that parameter table is empty */
- xp_awk_assert (awk, xp_awk_tab_getsize(&awk->parse.params) == 0);
+ sse_awk_assert (awk, sse_awk_tab_getsize(&awk->parse.params) == 0);
/* read parameter list */
if (MATCH(awk,TOKEN_RPAREN))
@@ -630,36 +630,36 @@ static xp_awk_nde_t* __parse_function (xp_awk_t* awk)
/* no function parameter found. get the next token */
if (__get_token(awk) == -1)
{
- XP_AWK_FREE (awk, name_dup);
- return XP_NULL;
+ SSE_AWK_FREE (awk, name_dup);
+ return SSE_NULL;
}
}
else
{
while (1)
{
- xp_char_t* param;
- xp_size_t param_len;
+ sse_char_t* param;
+ sse_size_t param_len;
if (!MATCH(awk,TOKEN_IDENT))
{
- XP_AWK_FREE (awk, name_dup);
- xp_awk_tab_clear (&awk->parse.params);
- PANIC (awk, XP_AWK_EIDENT);
+ SSE_AWK_FREE (awk, name_dup);
+ sse_awk_tab_clear (&awk->parse.params);
+ PANIC (awk, SSE_AWK_EIDENT);
}
- param = XP_AWK_STR_BUF(&awk->token.name);
- param_len = XP_AWK_STR_LEN(&awk->token.name);
+ param = SSE_AWK_STR_BUF(&awk->token.name);
+ param_len = SSE_AWK_STR_LEN(&awk->token.name);
- if (awk->option & XP_AWK_UNIQUE)
+ if (awk->option & SSE_AWK_UNIQUE)
{
/* check if a parameter conflicts with a function */
- if (xp_awk_strxncmp (name_dup, name_len, param, param_len) == 0 ||
- xp_awk_map_get (&awk->tree.afns, param, param_len) != XP_NULL)
+ if (sse_awk_strxncmp (name_dup, name_len, param, param_len) == 0 ||
+ sse_awk_map_get (&awk->tree.afns, param, param_len) != SSE_NULL)
{
- XP_AWK_FREE (awk, name_dup);
- xp_awk_tab_clear (&awk->parse.params);
- PANIC (awk, XP_AWK_EDUPNAME);
+ SSE_AWK_FREE (awk, name_dup);
+ sse_awk_tab_clear (&awk->parse.params);
+ PANIC (awk, SSE_AWK_EDUPNAME);
}
/* NOTE: the following is not a conflict
@@ -670,181 +670,181 @@ static xp_awk_nde_t* __parse_function (xp_awk_t* awk)
}
/* check if a parameter conflicts with other parameters */
- if (xp_awk_tab_find (
+ if (sse_awk_tab_find (
&awk->parse.params,
- 0, param, param_len) != (xp_size_t)-1)
+ 0, param, param_len) != (sse_size_t)-1)
{
- XP_AWK_FREE (awk, name_dup);
- xp_awk_tab_clear (&awk->parse.params);
- PANIC (awk, XP_AWK_EDUPPARAM);
+ SSE_AWK_FREE (awk, name_dup);
+ sse_awk_tab_clear (&awk->parse.params);
+ PANIC (awk, SSE_AWK_EDUPPARAM);
}
/* push the parameter to the parameter list */
- if (xp_awk_tab_getsize (
- &awk->parse.params) >= XP_AWK_MAX_PARAMS)
+ if (sse_awk_tab_getsize (
+ &awk->parse.params) >= SSE_AWK_MAX_PARAMS)
{
- XP_AWK_FREE (awk, name_dup);
- xp_awk_tab_clear (&awk->parse.params);
- PANIC (awk, XP_AWK_ETOOMANYPARAMS);
+ SSE_AWK_FREE (awk, name_dup);
+ sse_awk_tab_clear (&awk->parse.params);
+ PANIC (awk, SSE_AWK_ETOOMANYPARAMS);
}
- if (xp_awk_tab_add (
+ if (sse_awk_tab_add (
&awk->parse.params,
- param, param_len) == (xp_size_t)-1)
+ param, param_len) == (sse_size_t)-1)
{
- XP_AWK_FREE (awk, name_dup);
- xp_awk_tab_clear (&awk->parse.params);
- PANIC (awk, XP_AWK_ENOMEM);
+ SSE_AWK_FREE (awk, name_dup);
+ sse_awk_tab_clear (&awk->parse.params);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
if (__get_token (awk) == -1)
{
- XP_AWK_FREE (awk, name_dup);
- xp_awk_tab_clear (&awk->parse.params);
- return XP_NULL;
+ SSE_AWK_FREE (awk, name_dup);
+ sse_awk_tab_clear (&awk->parse.params);
+ return SSE_NULL;
}
if (MATCH(awk,TOKEN_RPAREN)) break;
if (!MATCH(awk,TOKEN_COMMA))
{
- XP_AWK_FREE (awk, name_dup);
- xp_awk_tab_clear (&awk->parse.params);
- PANIC (awk, XP_AWK_ECOMMA);
+ SSE_AWK_FREE (awk, name_dup);
+ sse_awk_tab_clear (&awk->parse.params);
+ PANIC (awk, SSE_AWK_ECOMMA);
}
if (__get_token(awk) == -1)
{
- XP_AWK_FREE (awk, name_dup);
- xp_awk_tab_clear (&awk->parse.params);
- return XP_NULL;
+ SSE_AWK_FREE (awk, name_dup);
+ sse_awk_tab_clear (&awk->parse.params);
+ return SSE_NULL;
}
}
if (__get_token(awk) == -1)
{
- XP_AWK_FREE (awk, name_dup);
- xp_awk_tab_clear (&awk->parse.params);
- return XP_NULL;
+ SSE_AWK_FREE (awk, name_dup);
+ sse_awk_tab_clear (&awk->parse.params);
+ return SSE_NULL;
}
}
/* check if the function body starts with a left brace */
if (!MATCH(awk,TOKEN_LBRACE))
{
- XP_AWK_FREE (awk, name_dup);
- xp_awk_tab_clear (&awk->parse.params);
- PANIC (awk, XP_AWK_ELBRACE);
+ SSE_AWK_FREE (awk, name_dup);
+ sse_awk_tab_clear (&awk->parse.params);
+ PANIC (awk, SSE_AWK_ELBRACE);
}
if (__get_token(awk) == -1)
{
- XP_AWK_FREE (awk, name_dup);
- xp_awk_tab_clear (&awk->parse.params);
- return XP_NULL;
+ SSE_AWK_FREE (awk, name_dup);
+ sse_awk_tab_clear (&awk->parse.params);
+ return SSE_NULL;
}
/* actual function body */
- body = __parse_block (awk, xp_true);
- if (body == XP_NULL)
+ body = __parse_block (awk, sse_true);
+ if (body == SSE_NULL)
{
- XP_AWK_FREE (awk, name_dup);
- xp_awk_tab_clear (&awk->parse.params);
- return XP_NULL;
+ SSE_AWK_FREE (awk, name_dup);
+ sse_awk_tab_clear (&awk->parse.params);
+ return SSE_NULL;
}
/* TODO: study furthur if the parameter names should be saved
* for some reasons */
- nargs = xp_awk_tab_getsize (&awk->parse.params);
+ nargs = sse_awk_tab_getsize (&awk->parse.params);
/* parameter names are not required anymore. clear them */
- xp_awk_tab_clear (&awk->parse.params);
+ sse_awk_tab_clear (&awk->parse.params);
- afn = (xp_awk_afn_t*) XP_AWK_MALLOC (awk, xp_sizeof(xp_awk_afn_t));
- if (afn == XP_NULL)
+ afn = (sse_awk_afn_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_afn_t));
+ if (afn == SSE_NULL)
{
- XP_AWK_FREE (awk, name_dup);
- xp_awk_clrpt (awk, body);
- return XP_NULL;
+ SSE_AWK_FREE (awk, name_dup);
+ sse_awk_clrpt (awk, body);
+ return SSE_NULL;
}
- afn->name = XP_NULL; /* function name set below */
+ afn->name = SSE_NULL; /* function name set below */
afn->name_len = 0;
afn->nargs = nargs;
afn->body = body;
- n = xp_awk_map_putx (&awk->tree.afns, name_dup, name_len, afn, &pair);
+ n = sse_awk_map_putx (&awk->tree.afns, name_dup, name_len, afn, &pair);
if (n < 0)
{
- XP_AWK_FREE (awk, name_dup);
- xp_awk_clrpt (awk, body);
- XP_AWK_FREE (awk, afn);
- PANIC (awk, XP_AWK_ENOMEM);
+ SSE_AWK_FREE (awk, name_dup);
+ sse_awk_clrpt (awk, body);
+ SSE_AWK_FREE (awk, afn);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
/* duplicate functions should have been detected previously */
- xp_awk_assert (awk, n != 0);
+ sse_awk_assert (awk, n != 0);
afn->name = pair->key; /* do some trick to save a string. */
afn->name_len = pair->key_len;
- XP_AWK_FREE (awk, name_dup);
+ SSE_AWK_FREE (awk, name_dup);
return body;
}
-static xp_awk_nde_t* __parse_begin (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_begin (sse_awk_t* awk)
{
- xp_awk_nde_t* nde;
+ sse_awk_nde_t* nde;
- xp_awk_assert (awk, MATCH(awk,TOKEN_LBRACE));
+ sse_awk_assert (awk, MATCH(awk,TOKEN_LBRACE));
- if (__get_token(awk) == -1) return XP_NULL;
- nde = __parse_block(awk, xp_true);
- if (nde == XP_NULL) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
+ nde = __parse_block(awk, sse_true);
+ if (nde == SSE_NULL) return SSE_NULL;
awk->tree.begin = nde;
return nde;
}
-static xp_awk_nde_t* __parse_end (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_end (sse_awk_t* awk)
{
- xp_awk_nde_t* nde;
+ sse_awk_nde_t* nde;
- xp_awk_assert (awk, MATCH(awk,TOKEN_LBRACE));
+ sse_awk_assert (awk, MATCH(awk,TOKEN_LBRACE));
- if (__get_token(awk) == -1) return XP_NULL;
- nde = __parse_block(awk, xp_true);
- if (nde == XP_NULL) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
+ nde = __parse_block(awk, sse_true);
+ if (nde == SSE_NULL) return SSE_NULL;
awk->tree.end = nde;
return nde;
}
-static xp_awk_chain_t* __parse_pattern_block (
- xp_awk_t* awk, xp_awk_nde_t* ptn, xp_bool_t blockless)
+static sse_awk_chain_t* __parse_pattern_block (
+ sse_awk_t* awk, sse_awk_nde_t* ptn, sse_bool_t blockless)
{
- xp_awk_nde_t* nde;
- xp_awk_chain_t* chain;
+ sse_awk_nde_t* nde;
+ sse_awk_chain_t* chain;
- if (blockless) nde = XP_NULL;
+ if (blockless) nde = SSE_NULL;
else
{
- xp_awk_assert (awk, MATCH(awk,TOKEN_LBRACE));
- if (__get_token(awk) == -1) return XP_NULL;
- nde = __parse_block(awk, xp_true);
- if (nde == XP_NULL) return XP_NULL;
+ sse_awk_assert (awk, MATCH(awk,TOKEN_LBRACE));
+ if (__get_token(awk) == -1) return SSE_NULL;
+ nde = __parse_block(awk, sse_true);
+ if (nde == SSE_NULL) return SSE_NULL;
}
- chain = (xp_awk_chain_t*) XP_AWK_MALLOC (awk, xp_sizeof(xp_awk_chain_t));
- if (chain == XP_NULL)
+ chain = (sse_awk_chain_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_chain_t));
+ if (chain == SSE_NULL)
{
- xp_awk_clrpt (awk, nde);
- PANIC (awk, XP_AWK_ENOMEM);
+ sse_awk_clrpt (awk, nde);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
chain->pattern = ptn;
chain->action = nde;
- chain->next = XP_NULL;
+ chain->next = SSE_NULL;
- if (awk->tree.chain == XP_NULL)
+ if (awk->tree.chain == SSE_NULL)
{
awk->tree.chain = chain;
awk->tree.chain_tail = chain;
@@ -860,17 +860,17 @@ static xp_awk_chain_t* __parse_pattern_block (
return chain;
}
-static xp_awk_nde_t* __parse_block (xp_awk_t* awk, xp_bool_t is_top)
+static sse_awk_nde_t* __parse_block (sse_awk_t* awk, sse_bool_t is_top)
{
- xp_awk_nde_t* head, * curr, * nde;
- xp_awk_nde_blk_t* block;
- xp_size_t nlocals, nlocals_max, tmp;
+ sse_awk_nde_t* head, * curr, * nde;
+ sse_awk_nde_blk_t* block;
+ sse_size_t nlocals, nlocals_max, tmp;
- nlocals = xp_awk_tab_getsize(&awk->parse.locals);
+ nlocals = sse_awk_tab_getsize(&awk->parse.locals);
nlocals_max = awk->parse.nlocals_max;
/* local variable declarations */
- if (awk->option & XP_AWK_EXPLICIT)
+ if (awk->option & SSE_AWK_ESSELICIT)
{
while (1)
{
@@ -878,90 +878,90 @@ static xp_awk_nde_t* __parse_block (xp_awk_t* awk, xp_bool_t is_top)
if (__get_token(awk) == -1)
{
- xp_awk_tab_remove (
+ sse_awk_tab_remove (
&awk->parse.locals, nlocals,
- xp_awk_tab_getsize(&awk->parse.locals) - nlocals);
- return XP_NULL;
+ sse_awk_tab_getsize(&awk->parse.locals) - nlocals);
+ return SSE_NULL;
}
- if (__collect_locals(awk, nlocals) == XP_NULL)
+ if (__collect_locals(awk, nlocals) == SSE_NULL)
{
- xp_awk_tab_remove (
+ sse_awk_tab_remove (
&awk->parse.locals, nlocals,
- xp_awk_tab_getsize(&awk->parse.locals) - nlocals);
- return XP_NULL;
+ sse_awk_tab_getsize(&awk->parse.locals) - nlocals);
+ return SSE_NULL;
}
}
}
/* block body */
- head = XP_NULL; curr = XP_NULL;
+ head = SSE_NULL; curr = SSE_NULL;
while (1)
{
if (MATCH(awk,TOKEN_EOF))
{
- xp_awk_tab_remove (
+ sse_awk_tab_remove (
&awk->parse.locals, nlocals,
- xp_awk_tab_getsize(&awk->parse.locals) - nlocals);
- if (head != XP_NULL) xp_awk_clrpt (awk, head);
- PANIC (awk, XP_AWK_EENDSRC);
+ sse_awk_tab_getsize(&awk->parse.locals) - nlocals);
+ if (head != SSE_NULL) sse_awk_clrpt (awk, head);
+ PANIC (awk, SSE_AWK_EENDSRC);
}
if (MATCH(awk,TOKEN_RBRACE))
{
if (__get_token(awk) == -1)
{
- xp_awk_tab_remove (
+ sse_awk_tab_remove (
&awk->parse.locals, nlocals,
- xp_awk_tab_getsize(&awk->parse.locals) - nlocals);
- if (head != XP_NULL) xp_awk_clrpt (awk, head);
- return XP_NULL;
+ sse_awk_tab_getsize(&awk->parse.locals) - nlocals);
+ if (head != SSE_NULL) sse_awk_clrpt (awk, head);
+ return SSE_NULL;
}
break;
}
nde = __parse_statement (awk);
- if (nde == XP_NULL)
+ if (nde == SSE_NULL)
{
- xp_awk_tab_remove (
+ sse_awk_tab_remove (
&awk->parse.locals, nlocals,
- xp_awk_tab_getsize(&awk->parse.locals) - nlocals);
- if (head != XP_NULL) xp_awk_clrpt (awk, head);
- return XP_NULL;
+ sse_awk_tab_getsize(&awk->parse.locals) - nlocals);
+ if (head != SSE_NULL) sse_awk_clrpt (awk, head);
+ return SSE_NULL;
}
/* remove unnecessary statements */
- if (nde->type == XP_AWK_NDE_NULL ||
- (nde->type == XP_AWK_NDE_BLK &&
- ((xp_awk_nde_blk_t*)nde)->body == XP_NULL)) continue;
+ if (nde->type == SSE_AWK_NDE_NULL ||
+ (nde->type == SSE_AWK_NDE_BLK &&
+ ((sse_awk_nde_blk_t*)nde)->body == SSE_NULL)) continue;
- if (curr == XP_NULL) head = nde;
+ if (curr == SSE_NULL) head = nde;
else curr->next = nde;
curr = nde;
}
- block = (xp_awk_nde_blk_t*) XP_AWK_MALLOC (awk, xp_sizeof(xp_awk_nde_blk_t));
- if (block == XP_NULL)
+ block = (sse_awk_nde_blk_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_blk_t));
+ if (block == SSE_NULL)
{
- xp_awk_tab_remove (
+ sse_awk_tab_remove (
&awk->parse.locals, nlocals,
- xp_awk_tab_getsize(&awk->parse.locals) - nlocals);
- xp_awk_clrpt (awk, head);
- PANIC (awk, XP_AWK_ENOMEM);
+ sse_awk_tab_getsize(&awk->parse.locals) - nlocals);
+ sse_awk_clrpt (awk, head);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
- tmp = xp_awk_tab_getsize(&awk->parse.locals);
+ tmp = sse_awk_tab_getsize(&awk->parse.locals);
if (tmp > awk->parse.nlocals_max) awk->parse.nlocals_max = tmp;
- xp_awk_tab_remove (
+ sse_awk_tab_remove (
&awk->parse.locals, nlocals, tmp - nlocals);
/* adjust the number of locals for a block without any statements */
- /* if (head == XP_NULL) tmp = 0; */
+ /* if (head == SSE_NULL) tmp = 0; */
- block->type = XP_AWK_NDE_BLK;
- block->next = XP_NULL;
+ block->type = SSE_AWK_NDE_BLK;
+ block->next = SSE_NULL;
block->body = head;
/* TODO: not only local variables but also nested blocks,
@@ -980,18 +980,18 @@ and merged to top-level block */
block->nlocals = 0;
}
- return (xp_awk_nde_t*)block;
+ return (sse_awk_nde_t*)block;
}
-static xp_awk_t* __add_builtin_globals (xp_awk_t* awk)
+static sse_awk_t* __add_builtin_globals (sse_awk_t* awk)
{
struct __bvent* p = __bvtab;
awk->tree.nbglobals = 0;
- while (p->name != XP_NULL)
+ while (p->name != SSE_NULL)
{
if (__add_global (awk,
- p->name, p->name_len) == XP_NULL) return XP_NULL;
+ p->name, p->name_len) == SSE_NULL) return SSE_NULL;
awk->tree.nbglobals++;
p++;
}
@@ -999,159 +999,159 @@ static xp_awk_t* __add_builtin_globals (xp_awk_t* awk)
return awk;
}
-static xp_awk_t* __add_global (
- xp_awk_t* awk, const xp_char_t* name, xp_size_t len)
+static sse_awk_t* __add_global (
+ sse_awk_t* awk, const sse_char_t* name, sse_size_t len)
{
- if (awk->option & XP_AWK_UNIQUE)
+ if (awk->option & SSE_AWK_UNIQUE)
{
/* check if it conflict with a function name */
- if (xp_awk_map_get(&awk->tree.afns, name, len) != XP_NULL)
+ if (sse_awk_map_get(&awk->tree.afns, name, len) != SSE_NULL)
{
- PANIC (awk, XP_AWK_EDUPNAME);
+ PANIC (awk, SSE_AWK_EDUPNAME);
}
}
/* check if it conflicts with other global variable names */
- if (xp_awk_tab_find (&awk->parse.globals, 0, name, len) != (xp_size_t)-1)
+ if (sse_awk_tab_find (&awk->parse.globals, 0, name, len) != (sse_size_t)-1)
{
- PANIC (awk, XP_AWK_EDUPVAR);
+ PANIC (awk, SSE_AWK_EDUPVAR);
}
- if (xp_awk_tab_getsize(&awk->parse.globals) >= XP_AWK_MAX_GLOBALS)
+ if (sse_awk_tab_getsize(&awk->parse.globals) >= SSE_AWK_MAX_GLOBALS)
{
- PANIC (awk, XP_AWK_ETOOMANYGLOBALS);
+ PANIC (awk, SSE_AWK_ETOOMANYGLOBALS);
}
- if (xp_awk_tab_add (&awk->parse.globals, name, len) == (xp_size_t)-1)
+ if (sse_awk_tab_add (&awk->parse.globals, name, len) == (sse_size_t)-1)
{
- PANIC (awk, XP_AWK_ENOMEM);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
return awk;
}
-static xp_awk_t* __collect_globals (xp_awk_t* awk)
+static sse_awk_t* __collect_globals (sse_awk_t* awk)
{
while (1)
{
if (!MATCH(awk,TOKEN_IDENT))
{
- PANIC (awk, XP_AWK_EIDENT);
+ PANIC (awk, SSE_AWK_EIDENT);
}
if (__add_global (awk,
- XP_AWK_STR_BUF(&awk->token.name),
- XP_AWK_STR_LEN(&awk->token.name)) == XP_NULL) return XP_NULL;
+ SSE_AWK_STR_BUF(&awk->token.name),
+ SSE_AWK_STR_LEN(&awk->token.name)) == SSE_NULL) return SSE_NULL;
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
if (MATCH(awk,TOKEN_SEMICOLON)) break;
if (!MATCH(awk,TOKEN_COMMA))
{
- PANIC (awk, XP_AWK_ECOMMA);
+ PANIC (awk, SSE_AWK_ECOMMA);
}
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
}
/* skip a semicolon */
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
return awk;
}
-static xp_awk_t* __collect_locals (xp_awk_t* awk, xp_size_t nlocals)
+static sse_awk_t* __collect_locals (sse_awk_t* awk, sse_size_t nlocals)
{
- xp_char_t* local;
- xp_size_t local_len;
+ sse_char_t* local;
+ sse_size_t local_len;
while (1)
{
if (!MATCH(awk,TOKEN_IDENT))
{
- PANIC (awk, XP_AWK_EIDENT);
+ PANIC (awk, SSE_AWK_EIDENT);
}
- local = XP_AWK_STR_BUF(&awk->token.name);
- local_len = XP_AWK_STR_LEN(&awk->token.name);
+ local = SSE_AWK_STR_BUF(&awk->token.name);
+ local_len = SSE_AWK_STR_LEN(&awk->token.name);
/* NOTE: it is not checked againt globals names */
- if (awk->option & XP_AWK_UNIQUE)
+ if (awk->option & SSE_AWK_UNIQUE)
{
/* check if it conflict with a function name */
- if (xp_awk_map_get (
- &awk->tree.afns, local, local_len) != XP_NULL)
+ if (sse_awk_map_get (
+ &awk->tree.afns, local, local_len) != SSE_NULL)
{
- PANIC (awk, XP_AWK_EDUPNAME);
+ PANIC (awk, SSE_AWK_EDUPNAME);
}
}
/* check if it conflicts with a paremeter name */
- if (xp_awk_tab_find (&awk->parse.params,
- 0, local, local_len) != (xp_size_t)-1)
+ if (sse_awk_tab_find (&awk->parse.params,
+ 0, local, local_len) != (sse_size_t)-1)
{
- PANIC (awk, XP_AWK_EDUPNAME);
+ PANIC (awk, SSE_AWK_EDUPNAME);
}
/* check if it conflicts with other local variable names */
- if (xp_awk_tab_find (&awk->parse.locals,
- ((awk->option & XP_AWK_SHADING)? nlocals: 0),
- local, local_len) != (xp_size_t)-1)
+ if (sse_awk_tab_find (&awk->parse.locals,
+ ((awk->option & SSE_AWK_SHADING)? nlocals: 0),
+ local, local_len) != (sse_size_t)-1)
{
- PANIC (awk, XP_AWK_EDUPVAR);
+ PANIC (awk, SSE_AWK_EDUPVAR);
}
- if (xp_awk_tab_getsize(&awk->parse.locals) >= XP_AWK_MAX_LOCALS)
+ if (sse_awk_tab_getsize(&awk->parse.locals) >= SSE_AWK_MAX_LOCALS)
{
- PANIC (awk, XP_AWK_ETOOMANYLOCALS);
+ PANIC (awk, SSE_AWK_ETOOMANYLOCALS);
}
- if (xp_awk_tab_add (
- &awk->parse.locals, local, local_len) == (xp_size_t)-1)
+ if (sse_awk_tab_add (
+ &awk->parse.locals, local, local_len) == (sse_size_t)-1)
{
- PANIC (awk, XP_AWK_ENOMEM);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
if (MATCH(awk,TOKEN_SEMICOLON)) break;
- if (!MATCH(awk,TOKEN_COMMA)) PANIC (awk, XP_AWK_ECOMMA);
+ if (!MATCH(awk,TOKEN_COMMA)) PANIC (awk, SSE_AWK_ECOMMA);
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
}
/* skip a semicolon */
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
return awk;
}
-static xp_awk_nde_t* __parse_statement (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_statement (sse_awk_t* awk)
{
- xp_awk_nde_t* nde;
+ sse_awk_nde_t* nde;
if (MATCH(awk,TOKEN_SEMICOLON))
{
/* null statement */
- nde = (xp_awk_nde_t*) XP_AWK_MALLOC (awk, xp_sizeof(xp_awk_nde_t));
- if (nde == XP_NULL) PANIC (awk, XP_AWK_ENOMEM);
+ nde = (sse_awk_nde_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_t));
+ if (nde == SSE_NULL) PANIC (awk, SSE_AWK_ENOMEM);
- nde->type = XP_AWK_NDE_NULL;
- nde->next = XP_NULL;
+ nde->type = SSE_AWK_NDE_NULL;
+ nde->next = SSE_NULL;
if (__get_token(awk) == -1)
{
- XP_AWK_FREE (awk, nde);
- return XP_NULL;
+ SSE_AWK_FREE (awk, nde);
+ return SSE_NULL;
}
}
else if (MATCH(awk,TOKEN_LBRACE))
{
- if (__get_token(awk) == -1) return XP_NULL;
- nde = __parse_block (awk, xp_false);
+ if (__get_token(awk) == -1) return SSE_NULL;
+ nde = __parse_block (awk, sse_false);
}
else
{
@@ -1162,21 +1162,21 @@ awk->parse.nl_semicolon = 0;
return nde;
}
-static xp_awk_nde_t* __parse_statement_nb (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_statement_nb (sse_awk_t* awk)
{
- xp_awk_nde_t* nde;
+ sse_awk_nde_t* nde;
/*
* keywords that don't require any terminating semicolon
*/
if (MATCH(awk,TOKEN_IF))
{
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
return __parse_if (awk);
}
else if (MATCH(awk,TOKEN_WHILE))
{
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
awk->parse.depth.loop++;
nde = __parse_while (awk);
@@ -1186,7 +1186,7 @@ static xp_awk_nde_t* __parse_statement_nb (xp_awk_t* awk)
}
else if (MATCH(awk,TOKEN_FOR))
{
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
awk->parse.depth.loop++;
nde = __parse_for (awk);
@@ -1201,7 +1201,7 @@ awk->parse.nl_semicolon = 1;
*/
if (MATCH(awk,TOKEN_DO))
{
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
awk->parse.depth.loop++;
nde = __parse_dowhile (awk);
@@ -1211,82 +1211,82 @@ awk->parse.nl_semicolon = 1;
}
else if (MATCH(awk,TOKEN_BREAK))
{
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
nde = __parse_break (awk);
}
else if (MATCH(awk,TOKEN_CONTINUE))
{
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
nde = __parse_continue (awk);
}
else if (MATCH(awk,TOKEN_RETURN))
{
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
nde = __parse_return (awk);
}
else if (MATCH(awk,TOKEN_EXIT))
{
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
nde = __parse_exit (awk);
}
else if (MATCH(awk,TOKEN_NEXT))
{
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
nde = __parse_next (awk);
}
else if (MATCH(awk,TOKEN_NEXTFILE))
{
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
nde = __parse_nextfile (awk);
}
else if (MATCH(awk,TOKEN_DELETE))
{
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
nde = __parse_delete (awk);
}
else if (MATCH(awk,TOKEN_PRINT))
{
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
nde = __parse_print (awk);
}
else if (MATCH(awk,TOKEN_PRINTF))
{
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
nde = __parse_printf (awk);
}
else
{
- nde = __parse_expression(awk);
+ nde = __parse_esseression(awk);
}
awk->parse.nl_semicolon = 0;
- if (nde == XP_NULL) return XP_NULL;
+ if (nde == SSE_NULL) return SSE_NULL;
/* check if a statement ends with a semicolon */
if (!MATCH(awk,TOKEN_SEMICOLON))
{
- if (nde != XP_NULL) xp_awk_clrpt (awk, nde);
- PANIC (awk, XP_AWK_ESEMICOLON);
+ if (nde != SSE_NULL) sse_awk_clrpt (awk, nde);
+ PANIC (awk, SSE_AWK_ESEMICOLON);
}
/* eat up the semicolon and read in the next token */
if (__get_token(awk) == -1)
{
- if (nde != XP_NULL) xp_awk_clrpt (awk, nde);
- return XP_NULL;
+ if (nde != SSE_NULL) sse_awk_clrpt (awk, nde);
+ return SSE_NULL;
}
return nde;
}
-static xp_awk_nde_t* __parse_expression (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_esseression (sse_awk_t* awk)
{
- xp_awk_nde_t* x, * y;
- xp_awk_nde_ass_t* nde;
+ sse_awk_nde_t* x, * y;
+ sse_awk_nde_ass_t* nde;
int opcode;
- x = __parse_basic_expr (awk);
- if (x == XP_NULL) return XP_NULL;
+ x = __parse_basic_esser (awk);
+ if (x == SSE_NULL) return SSE_NULL;
opcode = __assign_to_opcode (awk);
if (opcode == -1)
@@ -1295,118 +1295,118 @@ static xp_awk_nde_t* __parse_expression (xp_awk_t* awk)
return x;
}
- xp_awk_assert (awk, x->next == XP_NULL);
- if (!__is_var(x) && x->type != XP_AWK_NDE_POS)
+ sse_awk_assert (awk, x->next == SSE_NULL);
+ if (!__is_var(x) && x->type != SSE_AWK_NDE_POS)
{
- xp_awk_clrpt (awk, x);
- PANIC (awk, XP_AWK_EASSIGNMENT);
+ sse_awk_clrpt (awk, x);
+ PANIC (awk, SSE_AWK_EASSIGNMENT);
}
if (__get_token(awk) == -1)
{
- xp_awk_clrpt (awk, x);
- return XP_NULL;
+ sse_awk_clrpt (awk, x);
+ return SSE_NULL;
}
- y = __parse_basic_expr (awk);
- if (y == XP_NULL)
+ y = __parse_basic_esser (awk);
+ if (y == SSE_NULL)
{
- xp_awk_clrpt (awk, x);
- return XP_NULL;
+ sse_awk_clrpt (awk, x);
+ return SSE_NULL;
}
- nde = (xp_awk_nde_ass_t*) XP_AWK_MALLOC (awk, xp_sizeof(xp_awk_nde_ass_t));
- if (nde == XP_NULL)
+ nde = (sse_awk_nde_ass_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_ass_t));
+ if (nde == SSE_NULL)
{
- xp_awk_clrpt (awk, x);
- xp_awk_clrpt (awk, y);
- PANIC (awk, XP_AWK_ENOMEM);
+ sse_awk_clrpt (awk, x);
+ sse_awk_clrpt (awk, y);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
- nde->type = XP_AWK_NDE_ASS;
- nde->next = XP_NULL;
+ nde->type = SSE_AWK_NDE_ASS;
+ nde->next = SSE_NULL;
nde->opcode = opcode;
nde->left = x;
nde->right = y;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
-static xp_awk_nde_t* __parse_basic_expr (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_basic_esser (sse_awk_t* awk)
{
- xp_awk_nde_t* nde, * n1, * n2;
+ sse_awk_nde_t* nde, * n1, * n2;
nde = __parse_logical_or (awk);
- if (nde == XP_NULL) return XP_NULL;
+ if (nde == SSE_NULL) return SSE_NULL;
if (MATCH(awk,TOKEN_QUEST))
{
- xp_awk_nde_cnd_t* tmp;
+ sse_awk_nde_cnd_t* tmp;
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
- n1 = __parse_basic_expr (awk);
- if (n1 == XP_NULL)
+ n1 = __parse_basic_esser (awk);
+ if (n1 == SSE_NULL)
{
- xp_awk_clrpt (awk, nde);
- return XP_NULL;
+ sse_awk_clrpt (awk, nde);
+ return SSE_NULL;
}
- if (!MATCH(awk,TOKEN_COLON)) PANIC (awk, XP_AWK_ECOLON);
- if (__get_token(awk) == -1) return XP_NULL;
+ if (!MATCH(awk,TOKEN_COLON)) PANIC (awk, SSE_AWK_ECOLON);
+ if (__get_token(awk) == -1) return SSE_NULL;
- n2 = __parse_basic_expr (awk);
- if (n2 == XP_NULL)
+ n2 = __parse_basic_esser (awk);
+ if (n2 == SSE_NULL)
{
- xp_awk_clrpt (awk, nde);
- xp_awk_clrpt (awk, n1);
- return XP_NULL;
+ sse_awk_clrpt (awk, nde);
+ sse_awk_clrpt (awk, n1);
+ return SSE_NULL;
}
- tmp = (xp_awk_nde_cnd_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_awk_nde_cnd_t));
- if (tmp == XP_NULL)
+ tmp = (sse_awk_nde_cnd_t*) SSE_AWK_MALLOC (
+ awk, sse_sizeof(sse_awk_nde_cnd_t));
+ if (tmp == SSE_NULL)
{
- xp_awk_clrpt (awk, nde);
- xp_awk_clrpt (awk, n1);
- xp_awk_clrpt (awk, n2);
- return XP_NULL;
+ sse_awk_clrpt (awk, nde);
+ sse_awk_clrpt (awk, n1);
+ sse_awk_clrpt (awk, n2);
+ return SSE_NULL;
}
- tmp->type = XP_AWK_NDE_CND;
- tmp->next = XP_NULL;
+ tmp->type = SSE_AWK_NDE_CND;
+ tmp->next = SSE_NULL;
tmp->test = nde;
tmp->left = n1;
tmp->right = n2;
- nde = (xp_awk_nde_t*)tmp;
+ nde = (sse_awk_nde_t*)tmp;
}
return nde;
}
-static xp_awk_nde_t* __parse_binary_expr (
- xp_awk_t* awk, const __binmap_t* binmap,
- xp_awk_nde_t*(*next_level_func)(xp_awk_t*))
+static sse_awk_nde_t* __parse_binary_esser (
+ sse_awk_t* awk, const __binmap_t* binmap,
+ sse_awk_nde_t*(*next_level_func)(sse_awk_t*))
{
- xp_awk_nde_exp_t* nde;
- xp_awk_nde_t* left, * right;
+ sse_awk_nde_esse_t* nde;
+ sse_awk_nde_t* left, * right;
int opcode;
left = next_level_func (awk);
- if (left == XP_NULL) return XP_NULL;
+ if (left == SSE_NULL) return SSE_NULL;
while (1)
{
const __binmap_t* p = binmap;
- xp_bool_t matched = xp_false;
+ sse_bool_t matched = sse_false;
while (p->token != TOKEN_EOF)
{
if (MATCH(awk,p->token))
{
opcode = p->binop;
- matched = xp_true;
+ matched = sse_true;
break;
}
p++;
@@ -1415,71 +1415,71 @@ static xp_awk_nde_t* __parse_binary_expr (
if (__get_token(awk) == -1)
{
- xp_awk_clrpt (awk, left);
- return XP_NULL;
+ sse_awk_clrpt (awk, left);
+ return SSE_NULL;
}
right = next_level_func (awk);
- if (right == XP_NULL)
+ if (right == SSE_NULL)
{
- xp_awk_clrpt (awk, left);
- return XP_NULL;
+ sse_awk_clrpt (awk, left);
+ return SSE_NULL;
}
#if 0
/* TODO: enhance constant folding. do it in a better way */
/* TODO: differentiate different types of numbers ... */
- if (left->type == XP_AWK_NDE_INT &&
- right->type == XP_AWK_NDE_INT)
+ if (left->type == SSE_AWK_NDE_INT &&
+ right->type == SSE_AWK_NDE_INT)
{
- xp_long_t l, r;
+ sse_long_t l, r;
- l = ((xp_awk_nde_int_t*)left)->val;
- r = ((xp_awk_nde_int_t*)right)->val;
+ l = ((sse_awk_nde_int_t*)left)->val;
+ r = ((sse_awk_nde_int_t*)right)->val;
/* TODO: more operators */
- if (opcode == XP_AWK_BINOP_PLUS) l += r;
- else if (opcode == XP_AWK_BINOP_MINUS) l -= r;
- else if (opcode == XP_AWK_BINOP_MUL) l *= r;
- else if (opcode == XP_AWK_BINOP_DIV && r != 0) l /= r;
- else if (opcode == XP_AWK_BINOP_MOD && r != 0) l %= r;
+ if (opcode == SSE_AWK_BINOP_PLUS) l += r;
+ else if (opcode == SSE_AWK_BINOP_MINUS) l -= r;
+ else if (opcode == SSE_AWK_BINOP_MUL) l *= r;
+ else if (opcode == SSE_AWK_BINOP_DIV && r != 0) l /= r;
+ else if (opcode == SSE_AWK_BINOP_MOD && r != 0) l %= r;
else goto skip_constant_folding;
- xp_awk_clrpt (awk, right);
- ((xp_awk_nde_int_t*)left)->val = l;
+ sse_awk_clrpt (awk, right);
+ ((sse_awk_nde_int_t*)left)->val = l;
- if (((xp_awk_nde_int_t*)left)->str != XP_NULL)
+ if (((sse_awk_nde_int_t*)left)->str != SSE_NULL)
{
- XP_AWK_FREE (awk, ((xp_awk_nde_int_t*)left)->str);
- ((xp_awk_nde_int_t*)left)->str = XP_NULL;
- ((xp_awk_nde_int_t*)left)->len = 0;
+ SSE_AWK_FREE (awk, ((sse_awk_nde_int_t*)left)->str);
+ ((sse_awk_nde_int_t*)left)->str = SSE_NULL;
+ ((sse_awk_nde_int_t*)left)->len = 0;
}
continue;
}
- else if (left->type == XP_AWK_NDE_REAL &&
- right->type == XP_AWK_NDE_REAL)
+ else if (left->type == SSE_AWK_NDE_REAL &&
+ right->type == SSE_AWK_NDE_REAL)
{
- xp_real_t l, r;
+ sse_real_t l, r;
- l = ((xp_awk_nde_real_t*)left)->val;
- r = ((xp_awk_nde_real_t*)right)->val;
+ l = ((sse_awk_nde_real_t*)left)->val;
+ r = ((sse_awk_nde_real_t*)right)->val;
/* TODO: more operators */
- if (opcode == XP_AWK_BINOP_PLUS) l += r;
- else if (opcode == XP_AWK_BINOP_MINUS) l -= r;
- else if (opcode == XP_AWK_BINOP_MUL) l *= r;
- else if (opcode == XP_AWK_BINOP_DIV) l /= r;
+ if (opcode == SSE_AWK_BINOP_PLUS) l += r;
+ else if (opcode == SSE_AWK_BINOP_MINUS) l -= r;
+ else if (opcode == SSE_AWK_BINOP_MUL) l *= r;
+ else if (opcode == SSE_AWK_BINOP_DIV) l /= r;
else goto skip_constant_folding;
- xp_awk_clrpt (awk, right);
- ((xp_awk_nde_real_t*)left)->val = l;
+ sse_awk_clrpt (awk, right);
+ ((sse_awk_nde_real_t*)left)->val = l;
- if (((xp_awk_nde_real_t*)left)->str != XP_NULL)
+ if (((sse_awk_nde_real_t*)left)->str != SSE_NULL)
{
- XP_AWK_FREE (awk, ((xp_awk_nde_real_t*)left)->str);
- ((xp_awk_nde_real_t*)left)->str = XP_NULL;
- ((xp_awk_nde_real_t*)left)->len = 0;
+ SSE_AWK_FREE (awk, ((sse_awk_nde_real_t*)left)->str);
+ ((sse_awk_nde_real_t*)left)->str = SSE_NULL;
+ ((sse_awk_nde_real_t*)left)->len = 0;
}
continue;
@@ -1488,66 +1488,66 @@ static xp_awk_nde_t* __parse_binary_expr (
skip_constant_folding:
#endif
- nde = (xp_awk_nde_exp_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_awk_nde_exp_t));
- if (nde == XP_NULL)
+ nde = (sse_awk_nde_esse_t*) SSE_AWK_MALLOC (
+ awk, sse_sizeof(sse_awk_nde_esse_t));
+ if (nde == SSE_NULL)
{
- xp_awk_clrpt (awk, right);
- xp_awk_clrpt (awk, left);
- PANIC (awk, XP_AWK_ENOMEM);
+ sse_awk_clrpt (awk, right);
+ sse_awk_clrpt (awk, left);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
- nde->type = XP_AWK_NDE_EXP_BIN;
- nde->next = XP_NULL;
+ nde->type = SSE_AWK_NDE_ESSE_BIN;
+ nde->next = SSE_NULL;
nde->opcode = opcode;
nde->left = left;
nde->right = right;
- left = (xp_awk_nde_t*)nde;
+ left = (sse_awk_nde_t*)nde;
}
return left;
}
-static xp_awk_nde_t* __parse_logical_or (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_logical_or (sse_awk_t* awk)
{
static __binmap_t map[] =
{
- { TOKEN_LOR, XP_AWK_BINOP_LOR },
+ { TOKEN_LOR, SSE_AWK_BINOP_LOR },
{ TOKEN_EOF, 0 }
};
- return __parse_binary_expr (awk, map, __parse_logical_and);
+ return __parse_binary_esser (awk, map, __parse_logical_and);
}
-static xp_awk_nde_t* __parse_logical_and (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_logical_and (sse_awk_t* awk)
{
static __binmap_t map[] =
{
- { TOKEN_LAND, XP_AWK_BINOP_LAND },
+ { TOKEN_LAND, SSE_AWK_BINOP_LAND },
{ TOKEN_EOF, 0 }
};
- return __parse_binary_expr (awk, map, __parse_in);
+ return __parse_binary_esser (awk, map, __parse_in);
}
-static xp_awk_nde_t* __parse_in (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_in (sse_awk_t* awk)
{
/*
static __binmap_t map[] =
{
- { TOKEN_IN, XP_AWK_BINOP_IN },
+ { TOKEN_IN, SSE_AWK_BINOP_IN },
{ TOKEN_EOF, 0 }
};
- return __parse_binary_expr (awk, map, __parse_regex_match);
+ return __parse_binary_esser (awk, map, __parse_regex_match);
*/
- xp_awk_nde_exp_t* nde;
- xp_awk_nde_t* left, * right;
+ sse_awk_nde_esse_t* nde;
+ sse_awk_nde_t* left, * right;
left = __parse_regex_match (awk);
- if (left == XP_NULL) return XP_NULL;
+ if (left == SSE_NULL) return SSE_NULL;
while (1)
{
@@ -1555,60 +1555,60 @@ static xp_awk_nde_t* __parse_in (xp_awk_t* awk)
if (__get_token(awk) == -1)
{
- xp_awk_clrpt (awk, left);
- return XP_NULL;
+ sse_awk_clrpt (awk, left);
+ return SSE_NULL;
}
right = __parse_regex_match (awk);
- if (right == XP_NULL)
+ if (right == SSE_NULL)
{
- xp_awk_clrpt (awk, left);
- return XP_NULL;
+ sse_awk_clrpt (awk, left);
+ return SSE_NULL;
}
if (!__is_plain_var(right))
{
- xp_awk_clrpt (awk, right);
- xp_awk_clrpt (awk, left);
- PANIC (awk, XP_AWK_ENOTVAR);
+ sse_awk_clrpt (awk, right);
+ sse_awk_clrpt (awk, left);
+ PANIC (awk, SSE_AWK_ENOTVAR);
}
- nde = (xp_awk_nde_exp_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_awk_nde_exp_t));
- if (nde == XP_NULL)
+ nde = (sse_awk_nde_esse_t*) SSE_AWK_MALLOC (
+ awk, sse_sizeof(sse_awk_nde_esse_t));
+ if (nde == SSE_NULL)
{
- xp_awk_clrpt (awk, right);
- xp_awk_clrpt (awk, left);
- PANIC (awk, XP_AWK_ENOMEM);
+ sse_awk_clrpt (awk, right);
+ sse_awk_clrpt (awk, left);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
- nde->type = XP_AWK_NDE_EXP_BIN;
- nde->next = XP_NULL;
- nde->opcode = XP_AWK_BINOP_IN;
+ nde->type = SSE_AWK_NDE_ESSE_BIN;
+ nde->next = SSE_NULL;
+ nde->opcode = SSE_AWK_BINOP_IN;
nde->left = left;
nde->right = right;
- left = (xp_awk_nde_t*)nde;
+ left = (sse_awk_nde_t*)nde;
}
return left;
}
-static xp_awk_nde_t* __parse_regex_match (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_regex_match (sse_awk_t* awk)
{
static __binmap_t map[] =
{
- { TOKEN_TILDE, XP_AWK_BINOP_MA },
- { TOKEN_NM, XP_AWK_BINOP_NM },
+ { TOKEN_TILDE, SSE_AWK_BINOP_MA },
+ { TOKEN_NM, SSE_AWK_BINOP_NM },
{ TOKEN_EOF, 0 },
};
- return __parse_binary_expr (awk, map, __parse_bitwise_or);
+ return __parse_binary_esser (awk, map, __parse_bitwise_or);
}
-static xp_awk_nde_t* __parse_bitwise_or (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_bitwise_or (sse_awk_t* awk)
{
- if (awk->option & XP_AWK_EXTIO)
+ if (awk->option & SSE_AWK_EXTIO)
{
return __parse_bitwise_or_with_extio (awk);
}
@@ -1616,47 +1616,47 @@ static xp_awk_nde_t* __parse_bitwise_or (xp_awk_t* awk)
{
static __binmap_t map[] =
{
- { TOKEN_BOR, XP_AWK_BINOP_BOR },
+ { TOKEN_BOR, SSE_AWK_BINOP_BOR },
{ TOKEN_EOF, 0 }
};
- return __parse_binary_expr (awk, map, __parse_bitwise_xor);
+ return __parse_binary_esser (awk, map, __parse_bitwise_xor);
}
}
-static xp_awk_nde_t* __parse_bitwise_or_with_extio (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_bitwise_or_with_extio (sse_awk_t* awk)
{
- xp_awk_nde_t* left, * right;
+ sse_awk_nde_t* left, * right;
left = __parse_bitwise_xor (awk);
- if (left == XP_NULL) return XP_NULL;
+ if (left == SSE_NULL) return SSE_NULL;
while (1)
{
int in_type;
if (MATCH(awk,TOKEN_BOR))
- in_type = XP_AWK_IN_PIPE;
+ in_type = SSE_AWK_IN_PIPE;
else if (MATCH(awk,TOKEN_BORAND))
- in_type = XP_AWK_IN_COPROC;
+ in_type = SSE_AWK_IN_COPROC;
else break;
if (__get_token(awk) == -1)
{
- xp_awk_clrpt (awk, left);
- return XP_NULL;
+ sse_awk_clrpt (awk, left);
+ return SSE_NULL;
}
if (MATCH(awk,TOKEN_GETLINE))
{
- xp_awk_nde_getline_t* nde;
- xp_awk_nde_t* var = XP_NULL;
+ sse_awk_nde_getline_t* nde;
+ sse_awk_nde_t* var = SSE_NULL;
/* piped getline */
if (__get_token(awk) == -1)
{
- xp_awk_clrpt (awk, left);
- return XP_NULL;
+ sse_awk_clrpt (awk, left);
+ return SSE_NULL;
}
/* TODO: is this correct? */
@@ -1666,137 +1666,137 @@ static xp_awk_nde_t* __parse_bitwise_or_with_extio (xp_awk_t* awk)
/* command | getline var */
var = __parse_primary (awk);
- if (var == XP_NULL)
+ if (var == SSE_NULL)
{
- xp_awk_clrpt (awk, left);
- return XP_NULL;
+ sse_awk_clrpt (awk, left);
+ return SSE_NULL;
}
}
- nde = (xp_awk_nde_getline_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_awk_nde_getline_t));
- if (nde == XP_NULL)
+ nde = (sse_awk_nde_getline_t*) SSE_AWK_MALLOC (
+ awk, sse_sizeof(sse_awk_nde_getline_t));
+ if (nde == SSE_NULL)
{
- xp_awk_clrpt (awk, left);
- PANIC (awk, XP_AWK_ENOMEM);
+ sse_awk_clrpt (awk, left);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
- nde->type = XP_AWK_NDE_GETLINE;
- nde->next = XP_NULL;
+ nde->type = SSE_AWK_NDE_GETLINE;
+ nde->next = SSE_NULL;
nde->var = var;
nde->in_type = in_type;
nde->in = left;
- left = (xp_awk_nde_t*)nde;
+ left = (sse_awk_nde_t*)nde;
}
else
{
- xp_awk_nde_exp_t* nde;
+ sse_awk_nde_esse_t* nde;
- if (in_type == XP_AWK_IN_COPROC)
+ if (in_type == SSE_AWK_IN_COPROC)
{
- xp_awk_clrpt (awk, left);
- PANIC (awk, XP_AWK_EGETLINE);
+ sse_awk_clrpt (awk, left);
+ PANIC (awk, SSE_AWK_EGETLINE);
}
right = __parse_bitwise_xor (awk);
- if (right == XP_NULL)
+ if (right == SSE_NULL)
{
- xp_awk_clrpt (awk, left);
- return XP_NULL;
+ sse_awk_clrpt (awk, left);
+ return SSE_NULL;
}
/* TODO: do constant folding */
- nde = (xp_awk_nde_exp_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_awk_nde_exp_t));
- if (nde == XP_NULL)
+ nde = (sse_awk_nde_esse_t*) SSE_AWK_MALLOC (
+ awk, sse_sizeof(sse_awk_nde_esse_t));
+ if (nde == SSE_NULL)
{
- xp_awk_clrpt (awk, right);
- xp_awk_clrpt (awk, left);
- PANIC (awk, XP_AWK_ENOMEM);
+ sse_awk_clrpt (awk, right);
+ sse_awk_clrpt (awk, left);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
- nde->type = XP_AWK_NDE_EXP_BIN;
- nde->next = XP_NULL;
- nde->opcode = XP_AWK_BINOP_BOR;
+ nde->type = SSE_AWK_NDE_ESSE_BIN;
+ nde->next = SSE_NULL;
+ nde->opcode = SSE_AWK_BINOP_BOR;
nde->left = left;
nde->right = right;
- left = (xp_awk_nde_t*)nde;
+ left = (sse_awk_nde_t*)nde;
}
}
return left;
}
-static xp_awk_nde_t* __parse_bitwise_xor (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_bitwise_xor (sse_awk_t* awk)
{
static __binmap_t map[] =
{
- { TOKEN_BXOR, XP_AWK_BINOP_BXOR },
+ { TOKEN_BXOR, SSE_AWK_BINOP_BXOR },
{ TOKEN_EOF, 0 }
};
- return __parse_binary_expr (awk, map, __parse_bitwise_and);
+ return __parse_binary_esser (awk, map, __parse_bitwise_and);
}
-static xp_awk_nde_t* __parse_bitwise_and (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_bitwise_and (sse_awk_t* awk)
{
static __binmap_t map[] =
{
- { TOKEN_BAND, XP_AWK_BINOP_BAND },
+ { TOKEN_BAND, SSE_AWK_BINOP_BAND },
{ TOKEN_EOF, 0 }
};
- return __parse_binary_expr (awk, map, __parse_equality);
+ return __parse_binary_esser (awk, map, __parse_equality);
}
-static xp_awk_nde_t* __parse_equality (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_equality (sse_awk_t* awk)
{
static __binmap_t map[] =
{
- { TOKEN_EQ, XP_AWK_BINOP_EQ },
- { TOKEN_NE, XP_AWK_BINOP_NE },
+ { TOKEN_EQ, SSE_AWK_BINOP_EQ },
+ { TOKEN_NE, SSE_AWK_BINOP_NE },
{ TOKEN_EOF, 0 }
};
- return __parse_binary_expr (awk, map, __parse_relational);
+ return __parse_binary_esser (awk, map, __parse_relational);
}
-static xp_awk_nde_t* __parse_relational (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_relational (sse_awk_t* awk)
{
static __binmap_t map[] =
{
- { TOKEN_GT, XP_AWK_BINOP_GT },
- { TOKEN_GE, XP_AWK_BINOP_GE },
- { TOKEN_LT, XP_AWK_BINOP_LT },
- { TOKEN_LE, XP_AWK_BINOP_LE },
+ { TOKEN_GT, SSE_AWK_BINOP_GT },
+ { TOKEN_GE, SSE_AWK_BINOP_GE },
+ { TOKEN_LT, SSE_AWK_BINOP_LT },
+ { TOKEN_LE, SSE_AWK_BINOP_LE },
{ TOKEN_EOF, 0 }
};
- return __parse_binary_expr (awk, map, __parse_shift);
+ return __parse_binary_esser (awk, map, __parse_shift);
}
-static xp_awk_nde_t* __parse_shift (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_shift (sse_awk_t* awk)
{
static __binmap_t map[] =
{
- { TOKEN_LSHIFT, XP_AWK_BINOP_LSHIFT },
- { TOKEN_RSHIFT, XP_AWK_BINOP_RSHIFT },
+ { TOKEN_LSHIFT, SSE_AWK_BINOP_LSHIFT },
+ { TOKEN_RSHIFT, SSE_AWK_BINOP_RSHIFT },
{ TOKEN_EOF, 0 }
};
- return __parse_binary_expr (awk, map, __parse_concat);
+ return __parse_binary_esser (awk, map, __parse_concat);
}
-static xp_awk_nde_t* __parse_concat (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_concat (sse_awk_t* awk)
{
- xp_awk_nde_exp_t* nde;
- xp_awk_nde_t* left, * right;
+ sse_awk_nde_esse_t* nde;
+ sse_awk_nde_t* left, * right;
left = __parse_additive (awk);
- if (left == XP_NULL) return XP_NULL;
+ if (left == SSE_NULL) return SSE_NULL;
/* TODO: write a better code to do this....
* first of all, is the following check sufficient? */
@@ -1805,117 +1805,117 @@ static xp_awk_nde_t* __parse_concat (xp_awk_t* awk)
awk->token.type >= TOKEN_GETLINE)
{
right = __parse_additive (awk);
- if (right == XP_NULL)
+ if (right == SSE_NULL)
{
- xp_awk_clrpt (awk, left);
- return XP_NULL;
+ sse_awk_clrpt (awk, left);
+ return SSE_NULL;
}
- nde = (xp_awk_nde_exp_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_awk_nde_exp_t));
- if (nde == XP_NULL)
+ nde = (sse_awk_nde_esse_t*) SSE_AWK_MALLOC (
+ awk, sse_sizeof(sse_awk_nde_esse_t));
+ if (nde == SSE_NULL)
{
- xp_awk_clrpt (awk, left);
- xp_awk_clrpt (awk, right);
- PANIC (awk, XP_AWK_ENOMEM);
+ sse_awk_clrpt (awk, left);
+ sse_awk_clrpt (awk, right);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
- nde->type = XP_AWK_NDE_EXP_BIN;
- nde->next = XP_NULL;
- nde->opcode = XP_AWK_BINOP_CONCAT;
+ nde->type = SSE_AWK_NDE_ESSE_BIN;
+ nde->next = SSE_NULL;
+ nde->opcode = SSE_AWK_BINOP_CONCAT;
nde->left = left;
nde->right = right;
- left = (xp_awk_nde_t*)nde;
+ left = (sse_awk_nde_t*)nde;
}
return left;
}
-static xp_awk_nde_t* __parse_additive (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_additive (sse_awk_t* awk)
{
static __binmap_t map[] =
{
- { TOKEN_PLUS, XP_AWK_BINOP_PLUS },
- { TOKEN_MINUS, XP_AWK_BINOP_MINUS },
+ { TOKEN_PLUS, SSE_AWK_BINOP_PLUS },
+ { TOKEN_MINUS, SSE_AWK_BINOP_MINUS },
{ TOKEN_EOF, 0 }
};
- return __parse_binary_expr (awk, map, __parse_multiplicative);
+ return __parse_binary_esser (awk, map, __parse_multiplicative);
}
-static xp_awk_nde_t* __parse_multiplicative (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_multiplicative (sse_awk_t* awk)
{
static __binmap_t map[] =
{
- { TOKEN_MUL, XP_AWK_BINOP_MUL },
- { TOKEN_DIV, XP_AWK_BINOP_DIV },
- { TOKEN_MOD, XP_AWK_BINOP_MOD },
- { TOKEN_EXP, XP_AWK_BINOP_EXP },
+ { TOKEN_MUL, SSE_AWK_BINOP_MUL },
+ { TOKEN_DIV, SSE_AWK_BINOP_DIV },
+ { TOKEN_MOD, SSE_AWK_BINOP_MOD },
+ { TOKEN_ESSE, SSE_AWK_BINOP_ESSE },
{ TOKEN_EOF, 0 }
};
- return __parse_binary_expr (awk, map, __parse_unary);
+ return __parse_binary_esser (awk, map, __parse_unary);
}
-static xp_awk_nde_t* __parse_unary (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_unary (sse_awk_t* awk)
{
- xp_awk_nde_exp_t* nde;
- xp_awk_nde_t* left;
+ sse_awk_nde_esse_t* nde;
+ sse_awk_nde_t* left;
int opcode;
- opcode = (MATCH(awk,TOKEN_PLUS))? XP_AWK_UNROP_PLUS:
- (MATCH(awk,TOKEN_MINUS))? XP_AWK_UNROP_MINUS:
- (MATCH(awk,TOKEN_NOT))? XP_AWK_UNROP_NOT:
- (MATCH(awk,TOKEN_TILDE))? XP_AWK_UNROP_BNOT: -1;
+ opcode = (MATCH(awk,TOKEN_PLUS))? SSE_AWK_UNROP_PLUS:
+ (MATCH(awk,TOKEN_MINUS))? SSE_AWK_UNROP_MINUS:
+ (MATCH(awk,TOKEN_NOT))? SSE_AWK_UNROP_NOT:
+ (MATCH(awk,TOKEN_TILDE))? SSE_AWK_UNROP_BNOT: -1;
if (opcode == -1) return __parse_increment (awk);
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
left = __parse_unary (awk);
- if (left == XP_NULL) return XP_NULL;
+ if (left == SSE_NULL) return SSE_NULL;
- nde = (xp_awk_nde_exp_t*) XP_AWK_MALLOC (awk, xp_sizeof(xp_awk_nde_exp_t));
- if (nde == XP_NULL)
+ nde = (sse_awk_nde_esse_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_esse_t));
+ if (nde == SSE_NULL)
{
- xp_awk_clrpt (awk, left);
- PANIC (awk, XP_AWK_ENOMEM);
+ sse_awk_clrpt (awk, left);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
- nde->type = XP_AWK_NDE_EXP_UNR;
- nde->next = XP_NULL;
+ nde->type = SSE_AWK_NDE_ESSE_UNR;
+ nde->next = SSE_NULL;
nde->opcode = opcode;
nde->left = left;
- nde->right = XP_NULL;
+ nde->right = SSE_NULL;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
-static xp_awk_nde_t* __parse_increment (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_increment (sse_awk_t* awk)
{
- xp_awk_nde_exp_t* nde;
- xp_awk_nde_t* left;
+ sse_awk_nde_esse_t* nde;
+ sse_awk_nde_t* left;
int type, opcode, opcode1, opcode2;
- opcode1 = MATCH(awk,TOKEN_PLUSPLUS)? XP_AWK_INCOP_PLUS:
- MATCH(awk,TOKEN_MINUSMINUS)? XP_AWK_INCOP_MINUS: -1;
+ opcode1 = MATCH(awk,TOKEN_PLUSPLUS)? SSE_AWK_INCOP_PLUS:
+ MATCH(awk,TOKEN_MINUSMINUS)? SSE_AWK_INCOP_MINUS: -1;
if (opcode1 != -1)
{
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
}
left = __parse_primary (awk);
- if (left == XP_NULL) return XP_NULL;
+ if (left == SSE_NULL) return SSE_NULL;
- opcode2 = MATCH(awk,TOKEN_PLUSPLUS)? XP_AWK_INCOP_PLUS:
- MATCH(awk,TOKEN_MINUSMINUS)? XP_AWK_INCOP_MINUS: -1;
+ opcode2 = MATCH(awk,TOKEN_PLUSPLUS)? SSE_AWK_INCOP_PLUS:
+ MATCH(awk,TOKEN_MINUSMINUS)? SSE_AWK_INCOP_MINUS: -1;
if (opcode1 != -1 && opcode2 != -1)
{
- xp_awk_clrpt (awk, left);
- PANIC (awk, XP_AWK_ELVALUE);
+ sse_awk_clrpt (awk, left);
+ PANIC (awk, SSE_AWK_ELVALUE);
}
else if (opcode1 == -1 && opcode2 == -1)
{
@@ -1923,34 +1923,34 @@ static xp_awk_nde_t* __parse_increment (xp_awk_t* awk)
}
else if (opcode1 != -1)
{
- type = XP_AWK_NDE_EXP_INCPRE;
+ type = SSE_AWK_NDE_ESSE_INCPRE;
opcode = opcode1;
}
else if (opcode2 != -1)
{
- type = XP_AWK_NDE_EXP_INCPST;
+ type = SSE_AWK_NDE_ESSE_INCPST;
opcode = opcode2;
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
}
- nde = (xp_awk_nde_exp_t*) XP_AWK_MALLOC (awk, xp_sizeof(xp_awk_nde_exp_t));
- if (nde == XP_NULL)
+ nde = (sse_awk_nde_esse_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_esse_t));
+ if (nde == SSE_NULL)
{
- xp_awk_clrpt (awk, left);
- PANIC (awk, XP_AWK_ENOMEM);
+ sse_awk_clrpt (awk, left);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
nde->type = type;
- nde->next = XP_NULL;
+ nde->next = SSE_NULL;
nde->opcode = opcode;
nde->left = left;
- nde->right = XP_NULL;
+ nde->right = SSE_NULL;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
-static xp_awk_nde_t* __parse_primary (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_primary (sse_awk_t* awk)
{
if (MATCH(awk,TOKEN_IDENT))
{
@@ -1958,214 +1958,214 @@ static xp_awk_nde_t* __parse_primary (xp_awk_t* awk)
}
else if (MATCH(awk,TOKEN_INT))
{
- xp_awk_nde_int_t* nde;
+ sse_awk_nde_int_t* nde;
- nde = (xp_awk_nde_int_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_awk_nde_int_t));
- if (nde == XP_NULL) PANIC (awk, XP_AWK_ENOMEM);
+ nde = (sse_awk_nde_int_t*) SSE_AWK_MALLOC (
+ awk, sse_sizeof(sse_awk_nde_int_t));
+ if (nde == SSE_NULL) PANIC (awk, SSE_AWK_ENOMEM);
- nde->type = XP_AWK_NDE_INT;
- nde->next = XP_NULL;
- nde->val = xp_awk_strxtolong (awk,
- XP_AWK_STR_BUF(&awk->token.name),
- XP_AWK_STR_LEN(&awk->token.name), 0, XP_NULL);
- nde->str = xp_awk_strxdup (awk,
- XP_AWK_STR_BUF(&awk->token.name),
- XP_AWK_STR_LEN(&awk->token.name));
- if (nde->str == XP_NULL)
+ nde->type = SSE_AWK_NDE_INT;
+ nde->next = SSE_NULL;
+ nde->val = sse_awk_strxtolong (awk,
+ SSE_AWK_STR_BUF(&awk->token.name),
+ SSE_AWK_STR_LEN(&awk->token.name), 0, SSE_NULL);
+ nde->str = sse_awk_strxdup (awk,
+ SSE_AWK_STR_BUF(&awk->token.name),
+ SSE_AWK_STR_LEN(&awk->token.name));
+ if (nde->str == SSE_NULL)
{
- XP_AWK_FREE (awk, nde);
- return XP_NULL;
+ SSE_AWK_FREE (awk, nde);
+ return SSE_NULL;
}
- nde->len = XP_AWK_STR_LEN(&awk->token.name);
+ nde->len = SSE_AWK_STR_LEN(&awk->token.name);
- xp_awk_assert (awk,
- XP_AWK_STR_LEN(&awk->token.name) ==
- xp_awk_strlen(XP_AWK_STR_BUF(&awk->token.name)));
+ sse_awk_assert (awk,
+ SSE_AWK_STR_LEN(&awk->token.name) ==
+ sse_awk_strlen(SSE_AWK_STR_BUF(&awk->token.name)));
if (__get_token(awk) == -1)
{
- XP_AWK_FREE (awk, nde->str);
- XP_AWK_FREE (awk, nde);
- return XP_NULL;
+ SSE_AWK_FREE (awk, nde->str);
+ SSE_AWK_FREE (awk, nde);
+ return SSE_NULL;
}
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
else if (MATCH(awk,TOKEN_REAL))
{
- xp_awk_nde_real_t* nde;
+ sse_awk_nde_real_t* nde;
- nde = (xp_awk_nde_real_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_awk_nde_real_t));
- if (nde == XP_NULL) PANIC (awk, XP_AWK_ENOMEM);
+ nde = (sse_awk_nde_real_t*) SSE_AWK_MALLOC (
+ awk, sse_sizeof(sse_awk_nde_real_t));
+ if (nde == SSE_NULL) PANIC (awk, SSE_AWK_ENOMEM);
- nde->type = XP_AWK_NDE_REAL;
- nde->next = XP_NULL;
- nde->val = xp_awk_strxtoreal (awk,
- XP_AWK_STR_BUF(&awk->token.name),
- XP_AWK_STR_LEN(&awk->token.name), XP_NULL);
- nde->str = xp_awk_strxdup (awk,
- XP_AWK_STR_BUF(&awk->token.name),
- XP_AWK_STR_LEN(&awk->token.name));
- if (nde->str == XP_NULL)
+ nde->type = SSE_AWK_NDE_REAL;
+ nde->next = SSE_NULL;
+ nde->val = sse_awk_strxtoreal (awk,
+ SSE_AWK_STR_BUF(&awk->token.name),
+ SSE_AWK_STR_LEN(&awk->token.name), SSE_NULL);
+ nde->str = sse_awk_strxdup (awk,
+ SSE_AWK_STR_BUF(&awk->token.name),
+ SSE_AWK_STR_LEN(&awk->token.name));
+ if (nde->str == SSE_NULL)
{
- XP_AWK_FREE (awk, nde);
- return XP_NULL;
+ SSE_AWK_FREE (awk, nde);
+ return SSE_NULL;
}
- nde->len = XP_AWK_STR_LEN(&awk->token.name);
+ nde->len = SSE_AWK_STR_LEN(&awk->token.name);
- xp_awk_assert (awk,
- XP_AWK_STR_LEN(&awk->token.name) ==
- xp_awk_strlen(XP_AWK_STR_BUF(&awk->token.name)));
+ sse_awk_assert (awk,
+ SSE_AWK_STR_LEN(&awk->token.name) ==
+ sse_awk_strlen(SSE_AWK_STR_BUF(&awk->token.name)));
if (__get_token(awk) == -1)
{
- XP_AWK_FREE (awk, nde->str);
- XP_AWK_FREE (awk, nde);
- return XP_NULL;
+ SSE_AWK_FREE (awk, nde->str);
+ SSE_AWK_FREE (awk, nde);
+ return SSE_NULL;
}
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
else if (MATCH(awk,TOKEN_STR))
{
- xp_awk_nde_str_t* nde;
+ sse_awk_nde_str_t* nde;
- nde = (xp_awk_nde_str_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_awk_nde_str_t));
- if (nde == XP_NULL) PANIC (awk, XP_AWK_ENOMEM);
+ nde = (sse_awk_nde_str_t*) SSE_AWK_MALLOC (
+ awk, sse_sizeof(sse_awk_nde_str_t));
+ if (nde == SSE_NULL) PANIC (awk, SSE_AWK_ENOMEM);
- nde->type = XP_AWK_NDE_STR;
- nde->next = XP_NULL;
- nde->len = XP_AWK_STR_LEN(&awk->token.name);
- nde->buf = xp_awk_strxdup (
- awk, XP_AWK_STR_BUF(&awk->token.name), nde->len);
- if (nde->buf == XP_NULL)
+ nde->type = SSE_AWK_NDE_STR;
+ nde->next = SSE_NULL;
+ nde->len = SSE_AWK_STR_LEN(&awk->token.name);
+ nde->buf = sse_awk_strxdup (
+ awk, SSE_AWK_STR_BUF(&awk->token.name), nde->len);
+ if (nde->buf == SSE_NULL)
{
- XP_AWK_FREE (awk, nde);
- PANIC (awk, XP_AWK_ENOMEM);
+ SSE_AWK_FREE (awk, nde);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
if (__get_token(awk) == -1)
{
- XP_AWK_FREE (awk, nde->buf);
- XP_AWK_FREE (awk, nde);
- return XP_NULL;
+ SSE_AWK_FREE (awk, nde->buf);
+ SSE_AWK_FREE (awk, nde);
+ return SSE_NULL;
}
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
else if (MATCH(awk,TOKEN_DIV))
{
- xp_awk_nde_rex_t* nde;
+ sse_awk_nde_rex_t* nde;
int errnum;
- /* the regular expression is tokenized here because
+ /* the regular esseression is tokenized here because
* of the context-sensitivity of the slash symbol */
SET_TOKEN_TYPE (awk, TOKEN_REX);
- xp_awk_str_clear (&awk->token.name);
- if (__get_rexstr (awk) == -1) return XP_NULL;
- xp_awk_assert (awk, MATCH(awk,TOKEN_REX));
+ sse_awk_str_clear (&awk->token.name);
+ if (__get_rexstr (awk) == -1) return SSE_NULL;
+ sse_awk_assert (awk, MATCH(awk,TOKEN_REX));
- nde = (xp_awk_nde_rex_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_awk_nde_rex_t));
- if (nde == XP_NULL) PANIC (awk, XP_AWK_ENOMEM);
+ nde = (sse_awk_nde_rex_t*) SSE_AWK_MALLOC (
+ awk, sse_sizeof(sse_awk_nde_rex_t));
+ if (nde == SSE_NULL) PANIC (awk, SSE_AWK_ENOMEM);
- nde->type = XP_AWK_NDE_REX;
- nde->next = XP_NULL;
+ nde->type = SSE_AWK_NDE_REX;
+ nde->next = SSE_NULL;
- nde->len = XP_AWK_STR_LEN(&awk->token.name);
- nde->buf = xp_awk_strxdup (
+ nde->len = SSE_AWK_STR_LEN(&awk->token.name);
+ nde->buf = sse_awk_strxdup (
awk,
- XP_AWK_STR_BUF(&awk->token.name),
- XP_AWK_STR_LEN(&awk->token.name));
- if (nde->buf == XP_NULL)
+ SSE_AWK_STR_BUF(&awk->token.name),
+ SSE_AWK_STR_LEN(&awk->token.name));
+ if (nde->buf == SSE_NULL)
{
- XP_AWK_FREE (awk, nde);
- PANIC (awk, XP_AWK_ENOMEM);
+ SSE_AWK_FREE (awk, nde);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
- nde->code = xp_awk_buildrex (
+ nde->code = sse_awk_buildrex (
awk,
- XP_AWK_STR_BUF(&awk->token.name),
- XP_AWK_STR_LEN(&awk->token.name),
+ SSE_AWK_STR_BUF(&awk->token.name),
+ SSE_AWK_STR_LEN(&awk->token.name),
&errnum);
- if (nde->code == XP_NULL)
+ if (nde->code == SSE_NULL)
{
- XP_AWK_FREE (awk, nde->buf);
- XP_AWK_FREE (awk, nde);
+ SSE_AWK_FREE (awk, nde->buf);
+ SSE_AWK_FREE (awk, nde);
PANIC (awk, errnum);
}
if (__get_token(awk) == -1)
{
- XP_AWK_FREE (awk, nde->buf);
- XP_AWK_FREE (awk, nde->code);
- XP_AWK_FREE (awk, nde);
- return XP_NULL;
+ SSE_AWK_FREE (awk, nde->buf);
+ SSE_AWK_FREE (awk, nde->code);
+ SSE_AWK_FREE (awk, nde);
+ return SSE_NULL;
}
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
else if (MATCH(awk,TOKEN_DOLLAR))
{
- xp_awk_nde_pos_t* nde;
- xp_awk_nde_t* prim;
+ sse_awk_nde_pos_t* nde;
+ sse_awk_nde_t* prim;
- if (__get_token(awk)) return XP_NULL;
+ if (__get_token(awk)) return SSE_NULL;
prim = __parse_primary (awk);
- if (prim == XP_NULL) return XP_NULL;
+ if (prim == SSE_NULL) return SSE_NULL;
- nde = (xp_awk_nde_pos_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_awk_nde_pos_t));
- if (nde == XP_NULL)
+ nde = (sse_awk_nde_pos_t*) SSE_AWK_MALLOC (
+ awk, sse_sizeof(sse_awk_nde_pos_t));
+ if (nde == SSE_NULL)
{
- xp_awk_clrpt (awk, prim);
- PANIC (awk, XP_AWK_ENOMEM);
+ sse_awk_clrpt (awk, prim);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
- nde->type = XP_AWK_NDE_POS;
- nde->next = XP_NULL;
+ nde->type = SSE_AWK_NDE_POS;
+ nde->next = SSE_NULL;
nde->val = prim;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
else if (MATCH(awk,TOKEN_LPAREN))
{
- xp_awk_nde_t* nde;
- xp_awk_nde_t* last;
+ sse_awk_nde_t* nde;
+ sse_awk_nde_t* last;
/* eat up the left parenthesis */
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
- /* parse the sub-expression inside the parentheses */
- nde = __parse_expression (awk);
- if (nde == XP_NULL) return XP_NULL;
+ /* parse the sub-esseression inside the parentheses */
+ nde = __parse_esseression (awk);
+ if (nde == SSE_NULL) return SSE_NULL;
- /* parse subsequent expressions separated by a comma, if any */
+ /* parse subsequent esseressions separated by a comma, if any */
last = nde;
- xp_awk_assert (awk, last->next == XP_NULL);
+ sse_awk_assert (awk, last->next == SSE_NULL);
while (MATCH(awk,TOKEN_COMMA))
{
- xp_awk_nde_t* tmp;
+ sse_awk_nde_t* tmp;
if (__get_token(awk) == -1)
{
- xp_awk_clrpt (awk, nde);
- return XP_NULL;
+ sse_awk_clrpt (awk, nde);
+ return SSE_NULL;
}
- tmp = __parse_expression (awk);
- if (tmp == XP_NULL)
+ tmp = __parse_esseression (awk);
+ if (tmp == SSE_NULL)
{
- xp_awk_clrpt (awk, nde);
- return XP_NULL;
+ sse_awk_clrpt (awk, nde);
+ return SSE_NULL;
}
- xp_awk_assert (awk, tmp->next == XP_NULL);
+ sse_awk_assert (awk, tmp->next == SSE_NULL);
last->next = tmp;
last = tmp;
}
@@ -2174,43 +2174,43 @@ static xp_awk_nde_t* __parse_primary (xp_awk_t* awk)
/* check for the closing parenthesis */
if (!MATCH(awk,TOKEN_RPAREN))
{
- xp_awk_clrpt (awk, nde);
- PANIC (awk, XP_AWK_ERPAREN);
+ sse_awk_clrpt (awk, nde);
+ PANIC (awk, SSE_AWK_ERPAREN);
}
if (__get_token(awk) == -1)
{
- xp_awk_clrpt (awk, nde);
- return XP_NULL;
+ sse_awk_clrpt (awk, nde);
+ return SSE_NULL;
}
/* check if it is a chained node */
- if (nde->next != XP_NULL)
+ if (nde->next != SSE_NULL)
{
- /* if so, it is a expression group */
- /* (expr1, expr2, expr2) */
+ /* if so, it is a esseression group */
+ /* (esser1, esser2, esser2) */
- xp_awk_nde_grp_t* tmp;
+ sse_awk_nde_grp_t* tmp;
if (!MATCH(awk,TOKEN_IN))
{
- xp_awk_clrpt (awk, nde);
- PANIC (awk, XP_AWK_EIN);
+ sse_awk_clrpt (awk, nde);
+ PANIC (awk, SSE_AWK_EIN);
}
- tmp = (xp_awk_nde_grp_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_awk_nde_grp_t));
- if (tmp == XP_NULL)
+ tmp = (sse_awk_nde_grp_t*) SSE_AWK_MALLOC (
+ awk, sse_sizeof(sse_awk_nde_grp_t));
+ if (tmp == SSE_NULL)
{
- xp_awk_clrpt (awk, nde);
- PANIC (awk, XP_AWK_ENOMEM);
+ sse_awk_clrpt (awk, nde);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
- tmp->type = XP_AWK_NDE_GRP;
- tmp->next = XP_NULL;
+ tmp->type = SSE_AWK_NDE_GRP;
+ tmp->next = SSE_NULL;
tmp->body = nde;
- nde = (xp_awk_nde_t*)tmp;
+ nde = (sse_awk_nde_t*)tmp;
}
/* ----------------- */
@@ -2218,18 +2218,18 @@ static xp_awk_nde_t* __parse_primary (xp_awk_t* awk)
}
else if (MATCH(awk,TOKEN_GETLINE))
{
- xp_awk_nde_getline_t* nde;
- xp_awk_nde_t* var = XP_NULL;
- xp_awk_nde_t* in = XP_NULL;
+ sse_awk_nde_getline_t* nde;
+ sse_awk_nde_t* var = SSE_NULL;
+ sse_awk_nde_t* in = SSE_NULL;
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
if (MATCH(awk,TOKEN_IDENT))
{
/* getline var */
var = __parse_primary (awk);
- if (var == XP_NULL) return XP_NULL;
+ if (var == SSE_NULL) return SSE_NULL;
}
if (MATCH(awk, TOKEN_LT))
@@ -2237,207 +2237,207 @@ static xp_awk_nde_t* __parse_primary (xp_awk_t* awk)
/* getline [var] < file */
if (__get_token(awk) == -1)
{
- if (var != XP_NULL) xp_awk_clrpt (awk, var);
- return XP_NULL;
+ if (var != SSE_NULL) sse_awk_clrpt (awk, var);
+ return SSE_NULL;
}
/* TODO: is this correct? */
- /*in = __parse_expression (awk);*/
+ /*in = __parse_esseression (awk);*/
in = __parse_primary (awk);
- if (in == XP_NULL)
+ if (in == SSE_NULL)
{
- if (var != XP_NULL) xp_awk_clrpt (awk, var);
- return XP_NULL;
+ if (var != SSE_NULL) sse_awk_clrpt (awk, var);
+ return SSE_NULL;
}
}
- nde = (xp_awk_nde_getline_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_awk_nde_getline_t));
- if (nde == XP_NULL)
+ nde = (sse_awk_nde_getline_t*) SSE_AWK_MALLOC (
+ awk, sse_sizeof(sse_awk_nde_getline_t));
+ if (nde == SSE_NULL)
{
- if (var != XP_NULL) xp_awk_clrpt (awk, var);
- if (in != XP_NULL) xp_awk_clrpt (awk, in);
- PANIC (awk, XP_AWK_ENOMEM);
+ if (var != SSE_NULL) sse_awk_clrpt (awk, var);
+ if (in != SSE_NULL) sse_awk_clrpt (awk, in);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
- nde->type = XP_AWK_NDE_GETLINE;
- nde->next = XP_NULL;
+ nde->type = SSE_AWK_NDE_GETLINE;
+ nde->next = SSE_NULL;
nde->var = var;
- nde->in_type = (in == XP_NULL)?
- XP_AWK_IN_CONSOLE: XP_AWK_IN_FILE;
+ nde->in_type = (in == SSE_NULL)?
+ SSE_AWK_IN_CONSOLE: SSE_AWK_IN_FILE;
nde->in = in;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
- /* valid expression introducer is expected */
- PANIC (awk, XP_AWK_EEXPRESSION);
+ /* valid esseression introducer is esseected */
+ PANIC (awk, SSE_AWK_EESSERESSION);
}
-static xp_awk_nde_t* __parse_primary_ident (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_primary_ident (sse_awk_t* awk)
{
- xp_char_t* name_dup;
- xp_size_t name_len;
- xp_awk_bfn_t* bfn;
+ sse_char_t* name_dup;
+ sse_size_t name_len;
+ sse_awk_bfn_t* bfn;
- xp_awk_assert (awk, MATCH(awk,TOKEN_IDENT));
+ sse_awk_assert (awk, MATCH(awk,TOKEN_IDENT));
- name_dup = xp_awk_strxdup (
+ name_dup = sse_awk_strxdup (
awk,
- XP_AWK_STR_BUF(&awk->token.name),
- XP_AWK_STR_LEN(&awk->token.name));
- if (name_dup == XP_NULL) PANIC (awk, XP_AWK_ENOMEM);
- name_len = XP_AWK_STR_LEN(&awk->token.name);
+ SSE_AWK_STR_BUF(&awk->token.name),
+ SSE_AWK_STR_LEN(&awk->token.name));
+ if (name_dup == SSE_NULL) PANIC (awk, SSE_AWK_ENOMEM);
+ name_len = SSE_AWK_STR_LEN(&awk->token.name);
if (__get_token(awk) == -1)
{
- XP_AWK_FREE (awk, name_dup);
- return XP_NULL;
+ SSE_AWK_FREE (awk, name_dup);
+ return SSE_NULL;
}
/* check if name_dup is a built-in function name */
- bfn = xp_awk_getbfn (awk, name_dup, name_len);
- if (bfn != XP_NULL)
+ bfn = sse_awk_getbfn (awk, name_dup, name_len);
+ if (bfn != SSE_NULL)
{
- xp_awk_nde_t* nde;
+ sse_awk_nde_t* nde;
- XP_AWK_FREE (awk, name_dup);
+ SSE_AWK_FREE (awk, name_dup);
if (!MATCH(awk,TOKEN_LPAREN))
{
/* built-in function should be in the form
* of the function call */
- PANIC (awk, XP_AWK_ELPAREN);
+ PANIC (awk, SSE_AWK_ELPAREN);
}
- nde = __parse_fncall (awk, XP_NULL, 0, bfn);
- return (xp_awk_nde_t*)nde;
+ nde = __parse_fncall (awk, SSE_NULL, 0, bfn);
+ return (sse_awk_nde_t*)nde;
}
/* now we know that name_dup is a normal identifier. */
if (MATCH(awk,TOKEN_LBRACK))
{
- xp_awk_nde_t* nde;
+ sse_awk_nde_t* nde;
nde = __parse_hashidx (awk, name_dup, name_len);
- if (nde == XP_NULL) XP_AWK_FREE (awk, name_dup);
- return (xp_awk_nde_t*)nde;
+ if (nde == SSE_NULL) SSE_AWK_FREE (awk, name_dup);
+ return (sse_awk_nde_t*)nde;
}
else if (MATCH(awk,TOKEN_LPAREN))
{
/* function call */
- xp_awk_nde_t* nde;
- nde = __parse_fncall (awk, name_dup, name_len, XP_NULL);
- if (nde == XP_NULL) XP_AWK_FREE (awk, name_dup);
- return (xp_awk_nde_t*)nde;
+ sse_awk_nde_t* nde;
+ nde = __parse_fncall (awk, name_dup, name_len, SSE_NULL);
+ if (nde == SSE_NULL) SSE_AWK_FREE (awk, name_dup);
+ return (sse_awk_nde_t*)nde;
}
else
{
/* normal variable */
- xp_awk_nde_var_t* nde;
- xp_size_t idxa;
+ sse_awk_nde_var_t* nde;
+ sse_size_t idxa;
- nde = (xp_awk_nde_var_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_awk_nde_var_t));
- if (nde == XP_NULL)
+ nde = (sse_awk_nde_var_t*) SSE_AWK_MALLOC (
+ awk, sse_sizeof(sse_awk_nde_var_t));
+ if (nde == SSE_NULL)
{
- XP_AWK_FREE (awk, name_dup);
- PANIC (awk, XP_AWK_ENOMEM);
+ SSE_AWK_FREE (awk, name_dup);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
/* search the parameter name list */
- idxa = xp_awk_tab_find (
+ idxa = sse_awk_tab_find (
&awk->parse.params, 0, name_dup, name_len);
- if (idxa != (xp_size_t)-1)
+ if (idxa != (sse_size_t)-1)
{
- nde->type = XP_AWK_NDE_ARG;
- nde->next = XP_NULL;
- /*nde->id.name = XP_NULL;*/
+ nde->type = SSE_AWK_NDE_ARG;
+ nde->next = SSE_NULL;
+ /*nde->id.name = SSE_NULL;*/
nde->id.name = name_dup;
nde->id.name_len = name_len;
nde->id.idxa = idxa;
- nde->idx = XP_NULL;
+ nde->idx = SSE_NULL;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
/* search the local variable list */
- idxa = xp_awk_tab_rrfind (
+ idxa = sse_awk_tab_rrfind (
&awk->parse.locals, 0, name_dup, name_len);
- if (idxa != (xp_size_t)-1)
+ if (idxa != (sse_size_t)-1)
{
- nde->type = XP_AWK_NDE_LOCAL;
- nde->next = XP_NULL;
- /*nde->id.name = XP_NULL;*/
+ nde->type = SSE_AWK_NDE_LOCAL;
+ nde->next = SSE_NULL;
+ /*nde->id.name = SSE_NULL;*/
nde->id.name = name_dup;
nde->id.name_len = name_len;
nde->id.idxa = idxa;
- nde->idx = XP_NULL;
+ nde->idx = SSE_NULL;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
/* search the global variable list */
- idxa = xp_awk_tab_rrfind (
+ idxa = sse_awk_tab_rrfind (
&awk->parse.globals, 0, name_dup, name_len);
- if (idxa != (xp_size_t)-1)
+ if (idxa != (sse_size_t)-1)
{
- nde->type = XP_AWK_NDE_GLOBAL;
- nde->next = XP_NULL;
- /*nde->id.name = XP_NULL;*/
+ nde->type = SSE_AWK_NDE_GLOBAL;
+ nde->next = SSE_NULL;
+ /*nde->id.name = SSE_NULL;*/
nde->id.name = name_dup;
nde->id.name_len = name_len;
nde->id.idxa = idxa;
- nde->idx = XP_NULL;
+ nde->idx = SSE_NULL;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
- if (awk->option & XP_AWK_IMPLICIT)
+ if (awk->option & SSE_AWK_IMPLICIT)
{
- nde->type = XP_AWK_NDE_NAMED;
- nde->next = XP_NULL;
+ nde->type = SSE_AWK_NDE_NAMED;
+ nde->next = SSE_NULL;
nde->id.name = name_dup;
nde->id.name_len = name_len;
- nde->id.idxa = (xp_size_t)-1;
- nde->idx = XP_NULL;
+ nde->id.idxa = (sse_size_t)-1;
+ nde->idx = SSE_NULL;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
/* undefined variable */
- XP_AWK_FREE (awk, name_dup);
- XP_AWK_FREE (awk, nde);
- PANIC (awk, XP_AWK_EUNDEF);
+ SSE_AWK_FREE (awk, name_dup);
+ SSE_AWK_FREE (awk, nde);
+ PANIC (awk, SSE_AWK_EUNDEF);
}
}
-static xp_awk_nde_t* __parse_hashidx (
- xp_awk_t* awk, xp_char_t* name, xp_size_t name_len)
+static sse_awk_nde_t* __parse_hashidx (
+ sse_awk_t* awk, sse_char_t* name, sse_size_t name_len)
{
- xp_awk_nde_t* idx, * tmp, * last;
- xp_awk_nde_var_t* nde;
- xp_size_t idxa;
+ sse_awk_nde_t* idx, * tmp, * last;
+ sse_awk_nde_var_t* nde;
+ sse_size_t idxa;
- idx = XP_NULL;
- last = XP_NULL;
+ idx = SSE_NULL;
+ last = SSE_NULL;
do
{
if (__get_token(awk) == -1)
{
- if (idx != XP_NULL) xp_awk_clrpt (awk, idx);
- return XP_NULL;
+ if (idx != SSE_NULL) sse_awk_clrpt (awk, idx);
+ return SSE_NULL;
}
- tmp = __parse_expression (awk);
- if (tmp == XP_NULL)
+ tmp = __parse_esseression (awk);
+ if (tmp == SSE_NULL)
{
- if (idx != XP_NULL) xp_awk_clrpt (awk, idx);
- return XP_NULL;
+ if (idx != SSE_NULL) sse_awk_clrpt (awk, idx);
+ return SSE_NULL;
}
- if (idx == XP_NULL)
+ if (idx == SSE_NULL)
{
- xp_awk_assert (awk, last == XP_NULL);
+ sse_awk_assert (awk, last == SSE_NULL);
idx = tmp; last = tmp;
}
else
@@ -2448,106 +2448,106 @@ static xp_awk_nde_t* __parse_hashidx (
}
while (MATCH(awk,TOKEN_COMMA));
- xp_awk_assert (awk, idx != XP_NULL);
+ sse_awk_assert (awk, idx != SSE_NULL);
if (!MATCH(awk,TOKEN_RBRACK))
{
- xp_awk_clrpt (awk, idx);
- PANIC (awk, XP_AWK_ERBRACK);
+ sse_awk_clrpt (awk, idx);
+ PANIC (awk, SSE_AWK_ERBRACK);
}
if (__get_token(awk) == -1)
{
- xp_awk_clrpt (awk, idx);
- return XP_NULL;
+ sse_awk_clrpt (awk, idx);
+ return SSE_NULL;
}
- nde = (xp_awk_nde_var_t*) XP_AWK_MALLOC (awk, xp_sizeof(xp_awk_nde_var_t));
- if (nde == XP_NULL)
+ nde = (sse_awk_nde_var_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_var_t));
+ if (nde == SSE_NULL)
{
- xp_awk_clrpt (awk, idx);
- PANIC (awk, XP_AWK_ENOMEM);
+ sse_awk_clrpt (awk, idx);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
/* search the parameter name list */
- idxa = xp_awk_tab_find (&awk->parse.params, 0, name, name_len);
- if (idxa != (xp_size_t)-1)
+ idxa = sse_awk_tab_find (&awk->parse.params, 0, name, name_len);
+ if (idxa != (sse_size_t)-1)
{
- nde->type = XP_AWK_NDE_ARGIDX;
- nde->next = XP_NULL;
- /*nde->id.name = XP_NULL; */
+ nde->type = SSE_AWK_NDE_ARGIDX;
+ nde->next = SSE_NULL;
+ /*nde->id.name = SSE_NULL; */
nde->id.name = name;
nde->id.name_len = name_len;
nde->id.idxa = idxa;
nde->idx = idx;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
/* search the local variable list */
- idxa = xp_awk_tab_rrfind(&awk->parse.locals, 0, name, name_len);
- if (idxa != (xp_size_t)-1)
+ idxa = sse_awk_tab_rrfind(&awk->parse.locals, 0, name, name_len);
+ if (idxa != (sse_size_t)-1)
{
- nde->type = XP_AWK_NDE_LOCALIDX;
- nde->next = XP_NULL;
- /*nde->id.name = XP_NULL; */
+ nde->type = SSE_AWK_NDE_LOCALIDX;
+ nde->next = SSE_NULL;
+ /*nde->id.name = SSE_NULL; */
nde->id.name = name;
nde->id.name_len = name_len;
nde->id.idxa = idxa;
nde->idx = idx;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
/* search the global variable list */
- idxa = xp_awk_tab_rrfind(&awk->parse.globals, 0, name, name_len);
- if (idxa != (xp_size_t)-1)
+ idxa = sse_awk_tab_rrfind(&awk->parse.globals, 0, name, name_len);
+ if (idxa != (sse_size_t)-1)
{
- nde->type = XP_AWK_NDE_GLOBALIDX;
- nde->next = XP_NULL;
- /*nde->id.name = XP_NULL;*/
+ nde->type = SSE_AWK_NDE_GLOBALIDX;
+ nde->next = SSE_NULL;
+ /*nde->id.name = SSE_NULL;*/
nde->id.name = name;
nde->id.name_len = name_len;
nde->id.idxa = idxa;
nde->idx = idx;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
- if (awk->option & XP_AWK_IMPLICIT)
+ if (awk->option & SSE_AWK_IMPLICIT)
{
- nde->type = XP_AWK_NDE_NAMEDIDX;
- nde->next = XP_NULL;
+ nde->type = SSE_AWK_NDE_NAMEDIDX;
+ nde->next = SSE_NULL;
nde->id.name = name;
nde->id.name_len = name_len;
- nde->id.idxa = (xp_size_t)-1;
+ nde->id.idxa = (sse_size_t)-1;
nde->idx = idx;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
/* undefined variable */
- xp_awk_clrpt (awk, idx);
- XP_AWK_FREE (awk, nde);
- PANIC (awk, XP_AWK_EUNDEF);
+ sse_awk_clrpt (awk, idx);
+ SSE_AWK_FREE (awk, nde);
+ PANIC (awk, SSE_AWK_EUNDEF);
}
-static xp_awk_nde_t* __parse_fncall (
- xp_awk_t* awk, xp_char_t* name, xp_size_t name_len, xp_awk_bfn_t* bfn)
+static sse_awk_nde_t* __parse_fncall (
+ sse_awk_t* awk, sse_char_t* name, sse_size_t name_len, sse_awk_bfn_t* bfn)
{
- xp_awk_nde_t* head, * curr, * nde;
- xp_awk_nde_call_t* call;
- xp_size_t nargs;
+ sse_awk_nde_t* head, * curr, * nde;
+ sse_awk_nde_call_t* call;
+ sse_size_t nargs;
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
- head = curr = XP_NULL;
+ head = curr = SSE_NULL;
nargs = 0;
if (MATCH(awk,TOKEN_RPAREN))
{
/* no parameters to the function call */
- if (__get_token(awk) == -1) return XP_NULL;
+ if (__get_token(awk) == -1) return SSE_NULL;
}
else
{
@@ -2555,14 +2555,14 @@ static xp_awk_nde_t* __parse_fncall (
while (1)
{
- nde = __parse_expression (awk);
- if (nde == XP_NULL)
+ nde = __parse_esseression (awk);
+ if (nde == SSE_NULL)
{
- if (head != XP_NULL) xp_awk_clrpt (awk, head);
- return XP_NULL;
+ if (head != SSE_NULL) sse_awk_clrpt (awk, head);
+ return SSE_NULL;
}
- if (head == XP_NULL) head = nde;
+ if (head == SSE_NULL) head = nde;
else curr->next = nde;
curr = nde;
@@ -2572,39 +2572,39 @@ static xp_awk_nde_t* __parse_fncall (
{
if (__get_token(awk) == -1)
{
- if (head != XP_NULL)
- xp_awk_clrpt (awk, head);
- return XP_NULL;
+ if (head != SSE_NULL)
+ sse_awk_clrpt (awk, head);
+ return SSE_NULL;
}
break;
}
if (!MATCH(awk,TOKEN_COMMA))
{
- if (head != XP_NULL) xp_awk_clrpt (awk, head);
- PANIC (awk, XP_AWK_ECOMMA);
+ if (head != SSE_NULL) sse_awk_clrpt (awk, head);
+ PANIC (awk, SSE_AWK_ECOMMA);
}
if (__get_token(awk) == -1)
{
- if (head != XP_NULL) xp_awk_clrpt (awk, head);
- return XP_NULL;
+ if (head != SSE_NULL) sse_awk_clrpt (awk, head);
+ return SSE_NULL;
}
}
}
- call = (xp_awk_nde_call_t*) XP_AWK_MALLOC (awk, xp_sizeof(xp_awk_nde_call_t));
- if (call == XP_NULL)
+ call = (sse_awk_nde_call_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_call_t));
+ if (call == SSE_NULL)
{
- if (head != XP_NULL) xp_awk_clrpt (awk, head);
- PANIC (awk, XP_AWK_ENOMEM);
+ if (head != SSE_NULL) sse_awk_clrpt (awk, head);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
- if (bfn != XP_NULL)
+ if (bfn != SSE_NULL)
{
- call->type = XP_AWK_NDE_BFN;
- call->next = XP_NULL;
+ call->type = SSE_AWK_NDE_BFN;
+ call->next = SSE_NULL;
/*call->what.bfn = bfn; */
call->what.bfn.name = bfn->name;
@@ -2619,482 +2619,482 @@ static xp_awk_nde_t* __parse_fncall (
}
else
{
- call->type = XP_AWK_NDE_AFN;
- call->next = XP_NULL;
+ call->type = SSE_AWK_NDE_AFN;
+ call->next = SSE_NULL;
call->what.afn.name = name;
call->what.afn.name_len = name_len;
call->args = head;
call->nargs = nargs;
}
- return (xp_awk_nde_t*)call;
+ return (sse_awk_nde_t*)call;
}
-static xp_awk_nde_t* __parse_if (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_if (sse_awk_t* awk)
{
- xp_awk_nde_t* test;
- xp_awk_nde_t* then_part;
- xp_awk_nde_t* else_part;
- xp_awk_nde_if_t* nde;
+ sse_awk_nde_t* test;
+ sse_awk_nde_t* then_part;
+ sse_awk_nde_t* else_part;
+ sse_awk_nde_if_t* nde;
- if (!MATCH(awk,TOKEN_LPAREN)) PANIC (awk, XP_AWK_ELPAREN);
- if (__get_token(awk) == -1) return XP_NULL;
+ if (!MATCH(awk,TOKEN_LPAREN)) PANIC (awk, SSE_AWK_ELPAREN);
+ if (__get_token(awk) == -1) return SSE_NULL;
- test = __parse_expression (awk);
- if (test == XP_NULL) return XP_NULL;
+ test = __parse_esseression (awk);
+ if (test == SSE_NULL) return SSE_NULL;
if (!MATCH(awk,TOKEN_RPAREN))
{
- xp_awk_clrpt (awk, test);
- PANIC (awk, XP_AWK_ERPAREN);
+ sse_awk_clrpt (awk, test);
+ PANIC (awk, SSE_AWK_ERPAREN);
}
if (__get_token(awk) == -1)
{
- xp_awk_clrpt (awk, test);
- return XP_NULL;
+ sse_awk_clrpt (awk, test);
+ return SSE_NULL;
}
then_part = __parse_statement (awk);
- if (then_part == XP_NULL)
+ if (then_part == SSE_NULL)
{
- xp_awk_clrpt (awk, test);
- return XP_NULL;
+ sse_awk_clrpt (awk, test);
+ return SSE_NULL;
}
if (MATCH(awk,TOKEN_ELSE))
{
if (__get_token(awk) == -1)
{
- xp_awk_clrpt (awk, then_part);
- xp_awk_clrpt (awk, test);
- return XP_NULL;
+ sse_awk_clrpt (awk, then_part);
+ sse_awk_clrpt (awk, test);
+ return SSE_NULL;
}
else_part = __parse_statement (awk);
- if (else_part == XP_NULL)
+ if (else_part == SSE_NULL)
{
- xp_awk_clrpt (awk, then_part);
- xp_awk_clrpt (awk, test);
- return XP_NULL;
+ sse_awk_clrpt (awk, then_part);
+ sse_awk_clrpt (awk, test);
+ return SSE_NULL;
}
}
- else else_part = XP_NULL;
+ else else_part = SSE_NULL;
- nde = (xp_awk_nde_if_t*) XP_AWK_MALLOC (awk, xp_sizeof(xp_awk_nde_if_t));
- if (nde == XP_NULL)
+ nde = (sse_awk_nde_if_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_if_t));
+ if (nde == SSE_NULL)
{
- xp_awk_clrpt (awk, else_part);
- xp_awk_clrpt (awk, then_part);
- xp_awk_clrpt (awk, test);
- PANIC (awk, XP_AWK_ENOMEM);
+ sse_awk_clrpt (awk, else_part);
+ sse_awk_clrpt (awk, then_part);
+ sse_awk_clrpt (awk, test);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
- nde->type = XP_AWK_NDE_IF;
- nde->next = XP_NULL;
+ nde->type = SSE_AWK_NDE_IF;
+ nde->next = SSE_NULL;
nde->test = test;
nde->then_part = then_part;
nde->else_part = else_part;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
-static xp_awk_nde_t* __parse_while (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_while (sse_awk_t* awk)
{
- xp_awk_nde_t* test, * body;
- xp_awk_nde_while_t* nde;
+ sse_awk_nde_t* test, * body;
+ sse_awk_nde_while_t* nde;
- if (!MATCH(awk,TOKEN_LPAREN)) PANIC (awk, XP_AWK_ELPAREN);
- if (__get_token(awk) == -1) return XP_NULL;
+ if (!MATCH(awk,TOKEN_LPAREN)) PANIC (awk, SSE_AWK_ELPAREN);
+ if (__get_token(awk) == -1) return SSE_NULL;
- test = __parse_expression (awk);
- if (test == XP_NULL) return XP_NULL;
+ test = __parse_esseression (awk);
+ if (test == SSE_NULL) return SSE_NULL;
if (!MATCH(awk,TOKEN_RPAREN))
{
- xp_awk_clrpt (awk, test);
- PANIC (awk, XP_AWK_ERPAREN);
+ sse_awk_clrpt (awk, test);
+ PANIC (awk, SSE_AWK_ERPAREN);
}
if (__get_token(awk) == -1)
{
- xp_awk_clrpt (awk, test);
- return XP_NULL;
+ sse_awk_clrpt (awk, test);
+ return SSE_NULL;
}
body = __parse_statement (awk);
- if (body == XP_NULL)
+ if (body == SSE_NULL)
{
- xp_awk_clrpt (awk, test);
- return XP_NULL;
+ sse_awk_clrpt (awk, test);
+ return SSE_NULL;
}
- nde = (xp_awk_nde_while_t*) XP_AWK_MALLOC (awk, xp_sizeof(xp_awk_nde_while_t));
- if (nde == XP_NULL)
+ nde = (sse_awk_nde_while_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_while_t));
+ if (nde == SSE_NULL)
{
- xp_awk_clrpt (awk, body);
- xp_awk_clrpt (awk, test);
- PANIC (awk, XP_AWK_ENOMEM);
+ sse_awk_clrpt (awk, body);
+ sse_awk_clrpt (awk, test);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
- nde->type = XP_AWK_NDE_WHILE;
- nde->next = XP_NULL;
+ nde->type = SSE_AWK_NDE_WHILE;
+ nde->next = SSE_NULL;
nde->test = test;
nde->body = body;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
-static xp_awk_nde_t* __parse_for (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_for (sse_awk_t* awk)
{
- xp_awk_nde_t* init, * test, * incr, * body;
- xp_awk_nde_for_t* nde;
- xp_awk_nde_foreach_t* nde2;
+ sse_awk_nde_t* init, * test, * incr, * body;
+ sse_awk_nde_for_t* nde;
+ sse_awk_nde_foreach_t* nde2;
- if (!MATCH(awk,TOKEN_LPAREN)) PANIC (awk, XP_AWK_ELPAREN);
- if (__get_token(awk) == -1) return XP_NULL;
+ if (!MATCH(awk,TOKEN_LPAREN)) PANIC (awk, SSE_AWK_ELPAREN);
+ if (__get_token(awk) == -1) return SSE_NULL;
- if (MATCH(awk,TOKEN_SEMICOLON)) init = XP_NULL;
+ if (MATCH(awk,TOKEN_SEMICOLON)) init = SSE_NULL;
else
{
/* this line is very ugly. it checks the entire next
- * expression or the first element in the expression
+ * esseression or the first element in the esseression
* is wrapped by a parenthesis */
int no_foreach = MATCH(awk,TOKEN_LPAREN);
- init = __parse_expression (awk);
- if (init == XP_NULL) return XP_NULL;
+ init = __parse_esseression (awk);
+ if (init == SSE_NULL) return SSE_NULL;
- if (!no_foreach && init->type == XP_AWK_NDE_EXP_BIN &&
- ((xp_awk_nde_exp_t*)init)->opcode == XP_AWK_BINOP_IN &&
- __is_plain_var(((xp_awk_nde_exp_t*)init)->left))
+ if (!no_foreach && init->type == SSE_AWK_NDE_ESSE_BIN &&
+ ((sse_awk_nde_esse_t*)init)->opcode == SSE_AWK_BINOP_IN &&
+ __is_plain_var(((sse_awk_nde_esse_t*)init)->left))
{
/* switch to foreach */
if (!MATCH(awk,TOKEN_RPAREN))
{
- xp_awk_clrpt (awk, init);
- PANIC (awk, XP_AWK_ERPAREN);
+ sse_awk_clrpt (awk, init);
+ PANIC (awk, SSE_AWK_ERPAREN);
}
if (__get_token(awk) == -1)
{
- xp_awk_clrpt (awk, init);
- return XP_NULL;
+ sse_awk_clrpt (awk, init);
+ return SSE_NULL;
}
body = __parse_statement (awk);
- if (body == XP_NULL)
+ if (body == SSE_NULL)
{
- xp_awk_clrpt (awk, init);
- return XP_NULL;
+ sse_awk_clrpt (awk, init);
+ return SSE_NULL;
}
- nde2 = (xp_awk_nde_foreach_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_awk_nde_foreach_t));
- if (nde2 == XP_NULL)
+ nde2 = (sse_awk_nde_foreach_t*) SSE_AWK_MALLOC (
+ awk, sse_sizeof(sse_awk_nde_foreach_t));
+ if (nde2 == SSE_NULL)
{
- xp_awk_clrpt (awk, init);
- xp_awk_clrpt (awk, body);
- PANIC (awk, XP_AWK_ENOMEM);
+ sse_awk_clrpt (awk, init);
+ sse_awk_clrpt (awk, body);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
- nde2->type = XP_AWK_NDE_FOREACH;
- nde2->next = XP_NULL;
+ nde2->type = SSE_AWK_NDE_FOREACH;
+ nde2->next = SSE_NULL;
nde2->test = init;
nde2->body = body;
- return (xp_awk_nde_t*)nde2;
+ return (sse_awk_nde_t*)nde2;
}
if (!MATCH(awk,TOKEN_SEMICOLON))
{
- xp_awk_clrpt (awk, init);
- PANIC (awk, XP_AWK_ESEMICOLON);
+ sse_awk_clrpt (awk, init);
+ PANIC (awk, SSE_AWK_ESEMICOLON);
}
}
if (__get_token(awk) == -1)
{
- xp_awk_clrpt (awk, init);
- return XP_NULL;
+ sse_awk_clrpt (awk, init);
+ return SSE_NULL;
}
- if (MATCH(awk,TOKEN_SEMICOLON)) test = XP_NULL;
+ if (MATCH(awk,TOKEN_SEMICOLON)) test = SSE_NULL;
else
{
- test = __parse_expression (awk);
- if (test == XP_NULL)
+ test = __parse_esseression (awk);
+ if (test == SSE_NULL)
{
- xp_awk_clrpt (awk, init);
- return XP_NULL;
+ sse_awk_clrpt (awk, init);
+ return SSE_NULL;
}
if (!MATCH(awk,TOKEN_SEMICOLON))
{
- xp_awk_clrpt (awk, init);
- xp_awk_clrpt (awk, test);
- PANIC (awk, XP_AWK_ESEMICOLON);
+ sse_awk_clrpt (awk, init);
+ sse_awk_clrpt (awk, test);
+ PANIC (awk, SSE_AWK_ESEMICOLON);
}
}
if (__get_token(awk) == -1)
{
- xp_awk_clrpt (awk, init);
- xp_awk_clrpt (awk, test);
- return XP_NULL;
+ sse_awk_clrpt (awk, init);
+ sse_awk_clrpt (awk, test);
+ return SSE_NULL;
}
- if (MATCH(awk,TOKEN_RPAREN)) incr = XP_NULL;
+ if (MATCH(awk,TOKEN_RPAREN)) incr = SSE_NULL;
else
{
- incr = __parse_expression (awk);
- if (incr == XP_NULL)
+ incr = __parse_esseression (awk);
+ if (incr == SSE_NULL)
{
- xp_awk_clrpt (awk, init);
- xp_awk_clrpt (awk, test);
- return XP_NULL;
+ sse_awk_clrpt (awk, init);
+ sse_awk_clrpt (awk, test);
+ return SSE_NULL;
}
if (!MATCH(awk,TOKEN_RPAREN))
{
- xp_awk_clrpt (awk, init);
- xp_awk_clrpt (awk, test);
- xp_awk_clrpt (awk, incr);
- PANIC (awk, XP_AWK_ERPAREN);
+ sse_awk_clrpt (awk, init);
+ sse_awk_clrpt (awk, test);
+ sse_awk_clrpt (awk, incr);
+ PANIC (awk, SSE_AWK_ERPAREN);
}
}
if (__get_token(awk) == -1)
{
- xp_awk_clrpt (awk, init);
- xp_awk_clrpt (awk, test);
- xp_awk_clrpt (awk, incr);
- return XP_NULL;
+ sse_awk_clrpt (awk, init);
+ sse_awk_clrpt (awk, test);
+ sse_awk_clrpt (awk, incr);
+ return SSE_NULL;
}
body = __parse_statement (awk);
- if (body == XP_NULL)
+ if (body == SSE_NULL)
{
- xp_awk_clrpt (awk, init);
- xp_awk_clrpt (awk, test);
- xp_awk_clrpt (awk, incr);
- return XP_NULL;
+ sse_awk_clrpt (awk, init);
+ sse_awk_clrpt (awk, test);
+ sse_awk_clrpt (awk, incr);
+ return SSE_NULL;
}
- nde = (xp_awk_nde_for_t*) XP_AWK_MALLOC (awk, xp_sizeof(xp_awk_nde_for_t));
- if (nde == XP_NULL)
+ nde = (sse_awk_nde_for_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_for_t));
+ if (nde == SSE_NULL)
{
- xp_awk_clrpt (awk, init);
- xp_awk_clrpt (awk, test);
- xp_awk_clrpt (awk, incr);
- xp_awk_clrpt (awk, body);
- PANIC (awk, XP_AWK_ENOMEM);
+ sse_awk_clrpt (awk, init);
+ sse_awk_clrpt (awk, test);
+ sse_awk_clrpt (awk, incr);
+ sse_awk_clrpt (awk, body);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
- nde->type = XP_AWK_NDE_FOR;
- nde->next = XP_NULL;
+ nde->type = SSE_AWK_NDE_FOR;
+ nde->next = SSE_NULL;
nde->init = init;
nde->test = test;
nde->incr = incr;
nde->body = body;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
-static xp_awk_nde_t* __parse_dowhile (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_dowhile (sse_awk_t* awk)
{
- xp_awk_nde_t* test, * body;
- xp_awk_nde_while_t* nde;
+ sse_awk_nde_t* test, * body;
+ sse_awk_nde_while_t* nde;
body = __parse_statement (awk);
- if (body == XP_NULL) return XP_NULL;
+ if (body == SSE_NULL) return SSE_NULL;
if (!MATCH(awk,TOKEN_WHILE))
{
- xp_awk_clrpt (awk, body);
- PANIC (awk, XP_AWK_EWHILE);
+ sse_awk_clrpt (awk, body);
+ PANIC (awk, SSE_AWK_EWHILE);
}
if (__get_token(awk) == -1)
{
- xp_awk_clrpt (awk, body);
- return XP_NULL;
+ sse_awk_clrpt (awk, body);
+ return SSE_NULL;
}
if (!MATCH(awk,TOKEN_LPAREN))
{
- xp_awk_clrpt (awk, body);
- PANIC (awk, XP_AWK_ELPAREN);
+ sse_awk_clrpt (awk, body);
+ PANIC (awk, SSE_AWK_ELPAREN);
}
if (__get_token(awk) == -1)
{
- xp_awk_clrpt (awk, body);
- return XP_NULL;
+ sse_awk_clrpt (awk, body);
+ return SSE_NULL;
}
- test = __parse_expression (awk);
- if (test == XP_NULL)
+ test = __parse_esseression (awk);
+ if (test == SSE_NULL)
{
- xp_awk_clrpt (awk, body);
- return XP_NULL;
+ sse_awk_clrpt (awk, body);
+ return SSE_NULL;
}
if (!MATCH(awk,TOKEN_RPAREN))
{
- xp_awk_clrpt (awk, body);
- xp_awk_clrpt (awk, test);
- PANIC (awk, XP_AWK_ERPAREN);
+ sse_awk_clrpt (awk, body);
+ sse_awk_clrpt (awk, test);
+ PANIC (awk, SSE_AWK_ERPAREN);
}
if (__get_token(awk) == -1)
{
- xp_awk_clrpt (awk, body);
- xp_awk_clrpt (awk, test);
- return XP_NULL;
+ sse_awk_clrpt (awk, body);
+ sse_awk_clrpt (awk, test);
+ return SSE_NULL;
}
- nde = (xp_awk_nde_while_t*) XP_AWK_MALLOC (awk, xp_sizeof(xp_awk_nde_while_t));
- if (nde == XP_NULL)
+ nde = (sse_awk_nde_while_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_while_t));
+ if (nde == SSE_NULL)
{
- xp_awk_clrpt (awk, body);
- xp_awk_clrpt (awk, test);
- PANIC (awk, XP_AWK_ENOMEM);
+ sse_awk_clrpt (awk, body);
+ sse_awk_clrpt (awk, test);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
- nde->type = XP_AWK_NDE_DOWHILE;
- nde->next = XP_NULL;
+ nde->type = SSE_AWK_NDE_DOWHILE;
+ nde->next = SSE_NULL;
nde->test = test;
nde->body = body;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
-static xp_awk_nde_t* __parse_break (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_break (sse_awk_t* awk)
{
- xp_awk_nde_break_t* nde;
+ sse_awk_nde_break_t* nde;
- if (awk->parse.depth.loop <= 0) PANIC (awk, XP_AWK_EBREAK);
+ if (awk->parse.depth.loop <= 0) PANIC (awk, SSE_AWK_EBREAK);
- nde = (xp_awk_nde_break_t*) XP_AWK_MALLOC (awk, xp_sizeof(xp_awk_nde_break_t));
- if (nde == XP_NULL) PANIC (awk, XP_AWK_ENOMEM);
- nde->type = XP_AWK_NDE_BREAK;
- nde->next = XP_NULL;
+ nde = (sse_awk_nde_break_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_break_t));
+ if (nde == SSE_NULL) PANIC (awk, SSE_AWK_ENOMEM);
+ nde->type = SSE_AWK_NDE_BREAK;
+ nde->next = SSE_NULL;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
-static xp_awk_nde_t* __parse_continue (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_continue (sse_awk_t* awk)
{
- xp_awk_nde_continue_t* nde;
+ sse_awk_nde_continue_t* nde;
- if (awk->parse.depth.loop <= 0) PANIC (awk, XP_AWK_ECONTINUE);
+ if (awk->parse.depth.loop <= 0) PANIC (awk, SSE_AWK_ECONTINUE);
- nde = (xp_awk_nde_continue_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_awk_nde_continue_t));
- if (nde == XP_NULL) PANIC (awk, XP_AWK_ENOMEM);
- nde->type = XP_AWK_NDE_CONTINUE;
- nde->next = XP_NULL;
+ nde = (sse_awk_nde_continue_t*) SSE_AWK_MALLOC (
+ awk, sse_sizeof(sse_awk_nde_continue_t));
+ if (nde == SSE_NULL) PANIC (awk, SSE_AWK_ENOMEM);
+ nde->type = SSE_AWK_NDE_CONTINUE;
+ nde->next = SSE_NULL;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
-static xp_awk_nde_t* __parse_return (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_return (sse_awk_t* awk)
{
- xp_awk_nde_return_t* nde;
- xp_awk_nde_t* val;
+ sse_awk_nde_return_t* nde;
+ sse_awk_nde_t* val;
- nde = (xp_awk_nde_return_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_awk_nde_return_t));
- if (nde == XP_NULL) PANIC (awk, XP_AWK_ENOMEM);
- nde->type = XP_AWK_NDE_RETURN;
- nde->next = XP_NULL;
+ nde = (sse_awk_nde_return_t*) SSE_AWK_MALLOC (
+ awk, sse_sizeof(sse_awk_nde_return_t));
+ if (nde == SSE_NULL) PANIC (awk, SSE_AWK_ENOMEM);
+ nde->type = SSE_AWK_NDE_RETURN;
+ nde->next = SSE_NULL;
if (MATCH(awk,TOKEN_SEMICOLON))
{
/* no return value */
- val = XP_NULL;
+ val = SSE_NULL;
}
else
{
- val = __parse_expression (awk);
- if (val == XP_NULL)
+ val = __parse_esseression (awk);
+ if (val == SSE_NULL)
{
- XP_AWK_FREE (awk, nde);
- return XP_NULL;
+ SSE_AWK_FREE (awk, nde);
+ return SSE_NULL;
}
}
nde->val = val;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
-static xp_awk_nde_t* __parse_exit (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_exit (sse_awk_t* awk)
{
- xp_awk_nde_exit_t* nde;
- xp_awk_nde_t* val;
+ sse_awk_nde_exit_t* nde;
+ sse_awk_nde_t* val;
- nde = (xp_awk_nde_exit_t*) XP_AWK_MALLOC (awk, xp_sizeof(xp_awk_nde_exit_t));
- if (nde == XP_NULL) PANIC (awk, XP_AWK_ENOMEM);
- nde->type = XP_AWK_NDE_EXIT;
- nde->next = XP_NULL;
+ nde = (sse_awk_nde_exit_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_exit_t));
+ if (nde == SSE_NULL) PANIC (awk, SSE_AWK_ENOMEM);
+ nde->type = SSE_AWK_NDE_EXIT;
+ nde->next = SSE_NULL;
if (MATCH(awk,TOKEN_SEMICOLON))
{
/* no exit code */
- val = XP_NULL;
+ val = SSE_NULL;
}
else
{
- val = __parse_expression (awk);
- if (val == XP_NULL)
+ val = __parse_esseression (awk);
+ if (val == SSE_NULL)
{
- XP_AWK_FREE (awk, nde);
- return XP_NULL;
+ SSE_AWK_FREE (awk, nde);
+ return SSE_NULL;
}
}
nde->val = val;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
-static xp_awk_nde_t* __parse_delete (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_delete (sse_awk_t* awk)
{
- xp_awk_nde_delete_t* nde;
- xp_awk_nde_t* var;
+ sse_awk_nde_delete_t* nde;
+ sse_awk_nde_t* var;
- if (!MATCH(awk,TOKEN_IDENT)) PANIC (awk, XP_AWK_EIDENT);
+ if (!MATCH(awk,TOKEN_IDENT)) PANIC (awk, SSE_AWK_EIDENT);
var = __parse_primary_ident (awk);
- if (var == XP_NULL) return XP_NULL;
+ if (var == SSE_NULL) return SSE_NULL;
if (!__is_var (var))
{
- /* a normal identifier is expected */
- xp_awk_clrpt (awk, var);
- PANIC (awk, XP_AWK_EIDENT);
+ /* a normal identifier is esseected */
+ sse_awk_clrpt (awk, var);
+ PANIC (awk, SSE_AWK_EIDENT);
}
- nde = (xp_awk_nde_delete_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_awk_nde_delete_t));
- if (nde == XP_NULL) PANIC (awk, XP_AWK_ENOMEM);
+ nde = (sse_awk_nde_delete_t*) SSE_AWK_MALLOC (
+ awk, sse_sizeof(sse_awk_nde_delete_t));
+ if (nde == SSE_NULL) PANIC (awk, SSE_AWK_ENOMEM);
- nde->type = XP_AWK_NDE_DELETE;
- nde->next = XP_NULL;
+ nde->type = SSE_AWK_NDE_DELETE;
+ nde->next = SSE_NULL;
nde->var = var;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
-static xp_awk_nde_t* __parse_print (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_print (sse_awk_t* awk)
{
- xp_awk_nde_print_t* nde;
- xp_awk_nde_t* args = XP_NULL;
- xp_awk_nde_t* args_tail = XP_NULL;
- xp_awk_nde_t* tail_prev = XP_NULL;
- xp_awk_nde_t* out = XP_NULL;
+ sse_awk_nde_print_t* nde;
+ sse_awk_nde_t* args = SSE_NULL;
+ sse_awk_nde_t* args_tail = SSE_NULL;
+ sse_awk_nde_t* tail_prev = SSE_NULL;
+ sse_awk_nde_t* out = SSE_NULL;
int out_type;
if (!MATCH(awk,TOKEN_SEMICOLON) &&
@@ -3103,25 +3103,25 @@ static xp_awk_nde_t* __parse_print (xp_awk_t* awk)
!MATCH(awk,TOKEN_BOR) &&
!MATCH(awk,TOKEN_BORAND))
{
- args = __parse_expression (awk);
- if (args == XP_NULL) return XP_NULL;
+ args = __parse_esseression (awk);
+ if (args == SSE_NULL) return SSE_NULL;
args_tail = args;
- tail_prev = XP_NULL;
+ tail_prev = SSE_NULL;
while (MATCH(awk,TOKEN_COMMA))
{
if (__get_token(awk) == -1)
{
- xp_awk_clrpt (awk, args);
- return XP_NULL;
+ sse_awk_clrpt (awk, args);
+ return SSE_NULL;
}
- args_tail->next = __parse_expression (awk);
- if (args_tail->next == XP_NULL)
+ args_tail->next = __parse_esseression (awk);
+ if (args_tail->next == SSE_NULL)
{
- xp_awk_clrpt (awk, args);
- return XP_NULL;
+ sse_awk_clrpt (awk, args);
+ return SSE_NULL;
}
tail_prev = args_tail;
@@ -3131,140 +3131,140 @@ static xp_awk_nde_t* __parse_print (xp_awk_t* awk)
/* print 1 > 2 would print 1 to the file named 2.
* print (1 > 2) would print (1 > 2) in the console */
if (awk->token.prev != TOKEN_RPAREN &&
- args_tail->type == XP_AWK_NDE_EXP_BIN)
+ args_tail->type == SSE_AWK_NDE_ESSE_BIN)
{
- xp_awk_nde_exp_t* ep = (xp_awk_nde_exp_t*)args_tail;
- if (ep->opcode == XP_AWK_BINOP_GT)
+ sse_awk_nde_esse_t* ep = (sse_awk_nde_esse_t*)args_tail;
+ if (ep->opcode == SSE_AWK_BINOP_GT)
{
- xp_awk_nde_t* tmp = args_tail;
+ sse_awk_nde_t* tmp = args_tail;
- if (tail_prev != XP_NULL)
+ if (tail_prev != SSE_NULL)
tail_prev->next = ep->left;
else args = ep->left;
out = ep->right;
- out_type = XP_AWK_OUT_FILE;
+ out_type = SSE_AWK_OUT_FILE;
- XP_AWK_FREE (awk, tmp);
+ SSE_AWK_FREE (awk, tmp);
}
- else if (ep->opcode == XP_AWK_BINOP_RSHIFT)
+ else if (ep->opcode == SSE_AWK_BINOP_RSHIFT)
{
- xp_awk_nde_t* tmp = args_tail;
+ sse_awk_nde_t* tmp = args_tail;
- if (tail_prev != XP_NULL)
+ if (tail_prev != SSE_NULL)
tail_prev->next = ep->left;
else args = ep->left;
out = ep->right;
- out_type = XP_AWK_OUT_FILE_APPEND;
+ out_type = SSE_AWK_OUT_FILE_APPEND;
- XP_AWK_FREE (awk, tmp);
+ SSE_AWK_FREE (awk, tmp);
}
- else if (ep->opcode == XP_AWK_BINOP_BOR)
+ else if (ep->opcode == SSE_AWK_BINOP_BOR)
{
- xp_awk_nde_t* tmp = args_tail;
+ sse_awk_nde_t* tmp = args_tail;
- if (tail_prev != XP_NULL)
+ if (tail_prev != SSE_NULL)
tail_prev->next = ep->left;
else args = ep->left;
out = ep->right;
- out_type = XP_AWK_OUT_PIPE;
+ out_type = SSE_AWK_OUT_PIPE;
- XP_AWK_FREE (awk, tmp);
+ SSE_AWK_FREE (awk, tmp);
}
}
}
- if (out == XP_NULL)
+ if (out == SSE_NULL)
{
- out_type = MATCH(awk,TOKEN_GT)? XP_AWK_OUT_FILE:
- MATCH(awk,TOKEN_RSHIFT)? XP_AWK_OUT_FILE_APPEND:
- MATCH(awk,TOKEN_BOR)? XP_AWK_OUT_PIPE:
- MATCH(awk,TOKEN_BORAND)? XP_AWK_OUT_COPROC:
- XP_AWK_OUT_CONSOLE;
+ out_type = MATCH(awk,TOKEN_GT)? SSE_AWK_OUT_FILE:
+ MATCH(awk,TOKEN_RSHIFT)? SSE_AWK_OUT_FILE_APPEND:
+ MATCH(awk,TOKEN_BOR)? SSE_AWK_OUT_PIPE:
+ MATCH(awk,TOKEN_BORAND)? SSE_AWK_OUT_COPROC:
+ SSE_AWK_OUT_CONSOLE;
- if (out_type != XP_AWK_OUT_CONSOLE)
+ if (out_type != SSE_AWK_OUT_CONSOLE)
{
if (__get_token(awk) == -1)
{
- if (args != XP_NULL) xp_awk_clrpt (awk, args);
- return XP_NULL;
+ if (args != SSE_NULL) sse_awk_clrpt (awk, args);
+ return SSE_NULL;
}
- out = __parse_expression(awk);
- if (out == XP_NULL)
+ out = __parse_esseression(awk);
+ if (out == SSE_NULL)
{
- if (args != XP_NULL) xp_awk_clrpt (awk, args);
- return XP_NULL;
+ if (args != SSE_NULL) sse_awk_clrpt (awk, args);
+ return SSE_NULL;
}
}
}
- nde = (xp_awk_nde_print_t*) XP_AWK_MALLOC (awk, xp_sizeof(xp_awk_nde_print_t));
- if (nde == XP_NULL)
+ nde = (sse_awk_nde_print_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_print_t));
+ if (nde == SSE_NULL)
{
- if (args != XP_NULL) xp_awk_clrpt (awk, args);
- if (out != XP_NULL) xp_awk_clrpt (awk, out);
- PANIC (awk, XP_AWK_ENOMEM);
+ if (args != SSE_NULL) sse_awk_clrpt (awk, args);
+ if (out != SSE_NULL) sse_awk_clrpt (awk, out);
+ PANIC (awk, SSE_AWK_ENOMEM);
}
- nde->type = XP_AWK_NDE_PRINT;
- nde->next = XP_NULL;
+ nde->type = SSE_AWK_NDE_PRINT;
+ nde->next = SSE_NULL;
nde->args = args;
nde->out_type = out_type;
nde->out = out;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
-static xp_awk_nde_t* __parse_printf (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_printf (sse_awk_t* awk)
{
/* TODO: implement this... */
- return XP_NULL;
+ return SSE_NULL;
}
-static xp_awk_nde_t* __parse_next (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_next (sse_awk_t* awk)
{
- xp_awk_nde_next_t* nde;
+ sse_awk_nde_next_t* nde;
if (awk->parse.id.block == PARSE_BEGIN_BLOCK ||
awk->parse.id.block == PARSE_END_BLOCK)
{
- PANIC (awk, XP_AWK_ENEXT);
+ PANIC (awk, SSE_AWK_ENEXT);
}
- nde = (xp_awk_nde_next_t*) XP_AWK_MALLOC (awk, xp_sizeof(xp_awk_nde_next_t));
- if (nde == XP_NULL) PANIC (awk, XP_AWK_ENOMEM);
- nde->type = XP_AWK_NDE_NEXT;
- nde->next = XP_NULL;
+ nde = (sse_awk_nde_next_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_next_t));
+ if (nde == SSE_NULL) PANIC (awk, SSE_AWK_ENOMEM);
+ nde->type = SSE_AWK_NDE_NEXT;
+ nde->next = SSE_NULL;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
-static xp_awk_nde_t* __parse_nextfile (xp_awk_t* awk)
+static sse_awk_nde_t* __parse_nextfile (sse_awk_t* awk)
{
- xp_awk_nde_nextfile_t* nde;
+ sse_awk_nde_nextfile_t* nde;
if (awk->parse.id.block == PARSE_BEGIN_BLOCK ||
awk->parse.id.block == PARSE_END_BLOCK)
{
- PANIC (awk, XP_AWK_ENEXTFILE);
+ PANIC (awk, SSE_AWK_ENEXTFILE);
}
- nde = (xp_awk_nde_nextfile_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_awk_nde_nextfile_t));
- if (nde == XP_NULL) PANIC (awk, XP_AWK_ENOMEM);
- nde->type = XP_AWK_NDE_NEXTFILE;
- nde->next = XP_NULL;
+ nde = (sse_awk_nde_nextfile_t*) SSE_AWK_MALLOC (
+ awk, sse_sizeof(sse_awk_nde_nextfile_t));
+ if (nde == SSE_NULL) PANIC (awk, SSE_AWK_ENOMEM);
+ nde->type = SSE_AWK_NDE_NEXTFILE;
+ nde->next = SSE_NULL;
- return (xp_awk_nde_t*)nde;
+ return (sse_awk_nde_t*)nde;
}
-static int __get_token (xp_awk_t* awk)
+static int __get_token (sse_awk_t* awk)
{
- xp_cint_t c;
- xp_size_t line;
+ sse_cint_t c;
+ sse_size_t line;
int n;
line = awk->token.line;
@@ -3275,11 +3275,11 @@ static int __get_token (xp_awk_t* awk)
}
while (n == 1);
- xp_awk_str_clear (&awk->token.name);
+ sse_awk_str_clear (&awk->token.name);
awk->token.line = awk->src.lex.line;
awk->token.column = awk->src.lex.column;
- if (line != 0 && (awk->option & XP_AWK_BLOCKLESS) &&
+ if (line != 0 && (awk->option & SSE_AWK_BLOCKLESS) &&
(awk->parse.id.block == PARSE_PATTERN ||
awk->parse.id.block == PARSE_BEGIN ||
awk->parse.id.block == PARSE_END))
@@ -3293,15 +3293,15 @@ static int __get_token (xp_awk_t* awk)
c = awk->src.lex.curc;
- if (c == XP_CHAR_EOF)
+ if (c == SSE_CHAR_EOF)
{
SET_TOKEN_TYPE (awk, TOKEN_EOF);
}
- else if (XP_AWK_ISDIGIT (awk, c) || c == XP_T('.'))
+ else if (SSE_AWK_ISDIGIT (awk, c) || c == SSE_T('.'))
{
if (__get_number (awk) == -1) return -1;
}
- else if (XP_AWK_ISALPHA (awk, c) || c == XP_T('_'))
+ else if (SSE_AWK_ISALPHA (awk, c) || c == SSE_T('_'))
{
int type;
@@ -3311,21 +3311,21 @@ static int __get_token (xp_awk_t* awk)
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- while (XP_AWK_ISALPHA (awk, c) ||
- c == XP_T('_') || XP_AWK_ISDIGIT(awk,c));
+ while (SSE_AWK_ISALPHA (awk, c) ||
+ c == SSE_T('_') || SSE_AWK_ISDIGIT(awk,c));
type = __classify_ident (awk,
- XP_AWK_STR_BUF(&awk->token.name),
- XP_AWK_STR_LEN(&awk->token.name));
+ SSE_AWK_STR_BUF(&awk->token.name),
+ SSE_AWK_STR_LEN(&awk->token.name));
SET_TOKEN_TYPE (awk, type);
}
- else if (c == XP_T('\"'))
+ else if (c == SSE_T('\"'))
{
SET_TOKEN_TYPE (awk, TOKEN_STR);
if (__get_charstr(awk) == -1) return -1;
- while (awk->option & XP_AWK_STRCONCAT)
+ while (awk->option & SSE_AWK_STRCONCAT)
{
do
{
@@ -3335,17 +3335,17 @@ static int __get_token (xp_awk_t* awk)
while (n == 1);
c = awk->src.lex.curc;
- if (c != XP_T('\"')) break;
+ if (c != SSE_T('\"')) break;
if (__get_charstr(awk) == -1) return -1;
}
}
- else if (c == XP_T('='))
+ else if (c == SSE_T('='))
{
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
- if (c == XP_T('='))
+ if (c == SSE_T('='))
{
SET_TOKEN_TYPE (awk, TOKEN_EQ);
ADD_TOKEN_CHAR (awk, c);
@@ -3356,17 +3356,17 @@ static int __get_token (xp_awk_t* awk)
SET_TOKEN_TYPE (awk, TOKEN_ASSIGN);
}
}
- else if (c == XP_T('!'))
+ else if (c == SSE_T('!'))
{
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
- if (c == XP_T('='))
+ if (c == SSE_T('='))
{
SET_TOKEN_TYPE (awk, TOKEN_NE);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- else if (c == XP_T('~'))
+ else if (c == SSE_T('~'))
{
SET_TOKEN_TYPE (awk, TOKEN_NM);
ADD_TOKEN_CHAR (awk, c);
@@ -3377,17 +3377,17 @@ static int __get_token (xp_awk_t* awk)
SET_TOKEN_TYPE (awk, TOKEN_NOT);
}
}
- else if (c == XP_T('>'))
+ else if (c == SSE_T('>'))
{
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
- if ((awk->option & XP_AWK_SHIFT) && c == XP_T('>'))
+ if ((awk->option & SSE_AWK_SHIFT) && c == SSE_T('>'))
{
SET_TOKEN_TYPE (awk, TOKEN_RSHIFT);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- else if (c == XP_T('='))
+ else if (c == SSE_T('='))
{
SET_TOKEN_TYPE (awk, TOKEN_GE);
ADD_TOKEN_CHAR (awk, c);
@@ -3398,18 +3398,18 @@ static int __get_token (xp_awk_t* awk)
SET_TOKEN_TYPE (awk, TOKEN_GT);
}
}
- else if (c == XP_T('<'))
+ else if (c == SSE_T('<'))
{
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
- if ((awk->option & XP_AWK_SHIFT) && c == XP_T('<'))
+ if ((awk->option & SSE_AWK_SHIFT) && c == SSE_T('<'))
{
SET_TOKEN_TYPE (awk, TOKEN_LSHIFT);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- else if (c == XP_T('='))
+ else if (c == SSE_T('='))
{
SET_TOKEN_TYPE (awk, TOKEN_LE);
ADD_TOKEN_CHAR (awk, c);
@@ -3420,17 +3420,17 @@ static int __get_token (xp_awk_t* awk)
SET_TOKEN_TYPE (awk, TOKEN_LT);
}
}
- else if (c == XP_T('|'))
+ else if (c == SSE_T('|'))
{
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
- if (c == XP_T('|'))
+ if (c == SSE_T('|'))
{
SET_TOKEN_TYPE (awk, TOKEN_LOR);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- else if (c == XP_T('&'))
+ else if (c == SSE_T('&'))
{
SET_TOKEN_TYPE (awk, TOKEN_BORAND);
ADD_TOKEN_CHAR (awk, c);
@@ -3441,11 +3441,11 @@ static int __get_token (xp_awk_t* awk)
SET_TOKEN_TYPE (awk, TOKEN_BOR);
}
}
- else if (c == XP_T('&'))
+ else if (c == SSE_T('&'))
{
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
- if (c == XP_T('&'))
+ if (c == SSE_T('&'))
{
SET_TOKEN_TYPE (awk, TOKEN_LAND);
ADD_TOKEN_CHAR (awk, c);
@@ -3456,29 +3456,29 @@ static int __get_token (xp_awk_t* awk)
SET_TOKEN_TYPE (awk, TOKEN_BAND);
}
}
- else if (c == XP_T('~'))
+ else if (c == SSE_T('~'))
{
SET_TOKEN_TYPE (awk, TOKEN_TILDE);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- else if (c == XP_T('^'))
+ else if (c == SSE_T('^'))
{
SET_TOKEN_TYPE (awk, TOKEN_BXOR);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- else if (c == XP_T('+'))
+ else if (c == SSE_T('+'))
{
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
- if (c == XP_T('+'))
+ if (c == SSE_T('+'))
{
SET_TOKEN_TYPE (awk, TOKEN_PLUSPLUS);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- else if (c == XP_T('='))
+ else if (c == SSE_T('='))
{
SET_TOKEN_TYPE (awk, TOKEN_PLUS_ASSIGN);
ADD_TOKEN_CHAR (awk, c);
@@ -3489,17 +3489,17 @@ static int __get_token (xp_awk_t* awk)
SET_TOKEN_TYPE (awk, TOKEN_PLUS);
}
}
- else if (c == XP_T('-'))
+ else if (c == SSE_T('-'))
{
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
- if (c == XP_T('-'))
+ if (c == SSE_T('-'))
{
SET_TOKEN_TYPE (awk, TOKEN_MINUSMINUS);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- else if (c == XP_T('='))
+ else if (c == SSE_T('='))
{
SET_TOKEN_TYPE (awk, TOKEN_MINUS_ASSIGN);
ADD_TOKEN_CHAR (awk, c);
@@ -3510,30 +3510,30 @@ static int __get_token (xp_awk_t* awk)
SET_TOKEN_TYPE (awk, TOKEN_MINUS);
}
}
- else if (c == XP_T('*'))
+ else if (c == SSE_T('*'))
{
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
- if (c == XP_T('='))
+ if (c == SSE_T('='))
{
SET_TOKEN_TYPE (awk, TOKEN_MUL_ASSIGN);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- else if (c == XP_T('*'))
+ else if (c == SSE_T('*'))
{
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
- if (c == XP_T('='))
+ if (c == SSE_T('='))
{
- SET_TOKEN_TYPE (awk, TOKEN_EXP_ASSIGN);
+ SET_TOKEN_TYPE (awk, TOKEN_ESSE_ASSIGN);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
else
{
- SET_TOKEN_TYPE (awk, TOKEN_EXP);
+ SET_TOKEN_TYPE (awk, TOKEN_ESSE);
}
}
else
@@ -3541,12 +3541,12 @@ static int __get_token (xp_awk_t* awk)
SET_TOKEN_TYPE (awk, TOKEN_MUL);
}
}
- else if (c == XP_T('/'))
+ else if (c == SSE_T('/'))
{
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
- if (c == XP_T('='))
+ if (c == SSE_T('='))
{
SET_TOKEN_TYPE (awk, TOKEN_DIV_ASSIGN);
ADD_TOKEN_CHAR (awk, c);
@@ -3557,12 +3557,12 @@ static int __get_token (xp_awk_t* awk)
SET_TOKEN_TYPE (awk, TOKEN_DIV);
}
}
- else if (c == XP_T('%'))
+ else if (c == SSE_T('%'))
{
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
- if (c == XP_T('='))
+ if (c == SSE_T('='))
{
SET_TOKEN_TYPE (awk, TOKEN_MOD_ASSIGN);
ADD_TOKEN_CHAR (awk, c);
@@ -3573,75 +3573,75 @@ static int __get_token (xp_awk_t* awk)
SET_TOKEN_TYPE (awk, TOKEN_MOD);
}
}
- else if (c == XP_T('('))
+ else if (c == SSE_T('('))
{
SET_TOKEN_TYPE (awk, TOKEN_LPAREN);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- else if (c == XP_T(')'))
+ else if (c == SSE_T(')'))
{
SET_TOKEN_TYPE (awk, TOKEN_RPAREN);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- else if (c == XP_T('{'))
+ else if (c == SSE_T('{'))
{
SET_TOKEN_TYPE (awk, TOKEN_LBRACE);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- else if (c == XP_T('}'))
+ else if (c == SSE_T('}'))
{
SET_TOKEN_TYPE (awk, TOKEN_RBRACE);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- else if (c == XP_T('['))
+ else if (c == SSE_T('['))
{
SET_TOKEN_TYPE (awk, TOKEN_LBRACK);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- else if (c == XP_T(']'))
+ else if (c == SSE_T(']'))
{
SET_TOKEN_TYPE (awk, TOKEN_RBRACK);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- else if (c == XP_T('$'))
+ else if (c == SSE_T('$'))
{
SET_TOKEN_TYPE (awk, TOKEN_DOLLAR);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- else if (c == XP_T(','))
+ else if (c == SSE_T(','))
{
SET_TOKEN_TYPE (awk, TOKEN_COMMA);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- else if (c == XP_T('.'))
+ else if (c == SSE_T('.'))
{
SET_TOKEN_TYPE (awk, TOKEN_PERIOD);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- else if (c == XP_T(';') ||
- (c == XP_T('\n') && (awk->option & XP_AWK_NEWLINE)))
+ else if (c == SSE_T(';') ||
+ (c == SSE_T('\n') && (awk->option & SSE_AWK_NEWLINE)))
{
/* TODO: more check on the newline terminator... */
SET_TOKEN_TYPE (awk, TOKEN_SEMICOLON);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- else if (c == XP_T(':'))
+ else if (c == SSE_T(':'))
{
SET_TOKEN_TYPE (awk, TOKEN_COLON);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- else if (c == XP_T('?'))
+ else if (c == SSE_T('?'))
{
SET_TOKEN_TYPE (awk, TOKEN_QUEST);
ADD_TOKEN_CHAR (awk, c);
@@ -3649,29 +3649,29 @@ static int __get_token (xp_awk_t* awk)
}
else
{
- awk->errnum = XP_AWK_ELXCHR;
+ awk->errnum = SSE_AWK_ELXCHR;
return -1;
}
-/*xp_printf (XP_T("token -> [%s]\n"), XP_AWK_STR_BUF(&awk->token.name));*/
+/*sse_printf (SSE_T("token -> [%s]\n"), SSE_AWK_STR_BUF(&awk->token.name));*/
return 0;
}
-static int __get_number (xp_awk_t* awk)
+static int __get_number (sse_awk_t* awk)
{
- xp_cint_t c;
+ sse_cint_t c;
- xp_awk_assert (awk, XP_AWK_STR_LEN(&awk->token.name) == 0);
+ sse_awk_assert (awk, SSE_AWK_STR_LEN(&awk->token.name) == 0);
SET_TOKEN_TYPE (awk, TOKEN_INT);
c = awk->src.lex.curc;
- if (c == XP_T('0'))
+ if (c == SSE_T('0'))
{
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
- if (c == XP_T('x') || c == XP_T('X'))
+ if (c == SSE_T('x') || c == SSE_T('X'))
{
/* hexadecimal number */
do
@@ -3679,11 +3679,11 @@ static int __get_number (xp_awk_t* awk)
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- while (XP_AWK_ISXDIGIT (awk, c));
+ while (SSE_AWK_ISXDIGIT (awk, c));
return 0;
}
- else if (c == XP_T('b') || c == XP_T('B'))
+ else if (c == SSE_T('b') || c == SSE_T('B'))
{
/* binary number */
do
@@ -3691,14 +3691,14 @@ static int __get_number (xp_awk_t* awk)
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- while (c == XP_T('0') || c == XP_T('1'));
+ while (c == SSE_T('0') || c == SSE_T('1'));
return 0;
}
else if (c != '.')
{
/* octal number */
- while (c >= XP_T('0') && c <= XP_T('7'))
+ while (c >= SSE_T('0') && c <= SSE_T('7'))
{
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
@@ -3708,13 +3708,13 @@ static int __get_number (xp_awk_t* awk)
}
}
- while (XP_AWK_ISDIGIT (awk, c))
+ while (SSE_AWK_ISDIGIT (awk, c))
{
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- if (c == XP_T('.'))
+ if (c == SSE_T('.'))
{
/* floating-point number */
SET_TOKEN_TYPE (awk, TOKEN_REAL);
@@ -3722,27 +3722,27 @@ static int __get_number (xp_awk_t* awk)
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
- while (XP_AWK_ISDIGIT (awk, c))
+ while (SSE_AWK_ISDIGIT (awk, c))
{
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
}
- if (c == XP_T('E') || c == XP_T('e'))
+ if (c == SSE_T('E') || c == SSE_T('e'))
{
SET_TOKEN_TYPE (awk, TOKEN_REAL);
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
- if (c == XP_T('+') || c == XP_T('-'))
+ if (c == SSE_T('+') || c == SSE_T('-'))
{
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
}
- while (XP_AWK_ISDIGIT (awk, c))
+ while (SSE_AWK_ISDIGIT (awk, c))
{
ADD_TOKEN_CHAR (awk, c);
GET_CHAR_TO (awk, c);
@@ -3752,20 +3752,20 @@ static int __get_number (xp_awk_t* awk)
return 0;
}
-static int __get_charstr (xp_awk_t* awk)
+static int __get_charstr (sse_awk_t* awk)
{
- if (awk->src.lex.curc != XP_T('\"'))
+ if (awk->src.lex.curc != SSE_T('\"'))
{
/* the starting quote has been consumed before this function
* has been called */
ADD_TOKEN_CHAR (awk, awk->src.lex.curc);
}
- return __get_string (awk, XP_T('\"'), XP_T('\\'), xp_false);
+ return __get_string (awk, SSE_T('\"'), SSE_T('\\'), sse_false);
}
-static int __get_rexstr (xp_awk_t* awk)
+static int __get_rexstr (sse_awk_t* awk)
{
- if (awk->src.lex.curc == XP_T('/'))
+ if (awk->src.lex.curc == SSE_T('/'))
{
/* this part of the function is different from __get_charstr
* because of the way this function is called */
@@ -3775,34 +3775,34 @@ static int __get_rexstr (xp_awk_t* awk)
else
{
ADD_TOKEN_CHAR (awk, awk->src.lex.curc);
- return __get_string (awk, XP_T('/'), XP_T('\\'), xp_true);
+ return __get_string (awk, SSE_T('/'), SSE_T('\\'), sse_true);
}
}
static int __get_string (
- xp_awk_t* awk, xp_char_t end_char,
- xp_char_t esc_char, xp_bool_t keep_esc_char)
+ sse_awk_t* awk, sse_char_t end_char,
+ sse_char_t esc_char, sse_bool_t keep_esc_char)
{
- xp_cint_t c;
+ sse_cint_t c;
int escaped = 0;
int digit_count = 0;
- xp_cint_t c_acc;
+ sse_cint_t c_acc;
while (1)
{
GET_CHAR_TO (awk, c);
- if (c == XP_CHAR_EOF)
+ if (c == SSE_CHAR_EOF)
{
- awk->errnum = XP_AWK_EENDSTR;
+ awk->errnum = SSE_AWK_EENDSTR;
return -1;
}
if (escaped == 3)
{
- if (c >= XP_T('0') && c <= XP_T('7'))
+ if (c >= SSE_T('0') && c <= SSE_T('7'))
{
- c_acc = c_acc * 8 + c - XP_T('0');
+ c_acc = c_acc * 8 + c - SSE_T('0');
digit_count++;
if (digit_count >= escaped)
{
@@ -3819,9 +3819,9 @@ static int __get_string (
}
else if (escaped == 2 || escaped == 4 || escaped == 8)
{
- if (c >= XP_T('0') && c <= XP_T('9'))
+ if (c >= SSE_T('0') && c <= SSE_T('9'))
{
- c_acc = c_acc * 16 + c - XP_T('0');
+ c_acc = c_acc * 16 + c - SSE_T('0');
digit_count++;
if (digit_count >= escaped)
{
@@ -3830,9 +3830,9 @@ static int __get_string (
}
continue;
}
- else if (c >= XP_T('A') && c <= XP_T('F'))
+ else if (c >= SSE_T('A') && c <= SSE_T('F'))
{
- c_acc = c_acc * 16 + c - XP_T('A') + 10;
+ c_acc = c_acc * 16 + c - SSE_T('A') + 10;
digit_count++;
if (digit_count >= escaped)
{
@@ -3841,9 +3841,9 @@ static int __get_string (
}
continue;
}
- else if (c >= XP_T('a') && c <= XP_T('f'))
+ else if (c >= SSE_T('a') && c <= SSE_T('f'))
{
- c_acc = c_acc * 16 + c - XP_T('a') + 10;
+ c_acc = c_acc * 16 + c - SSE_T('a') + 10;
digit_count++;
if (digit_count >= escaped)
{
@@ -3854,10 +3854,10 @@ static int __get_string (
}
else
{
- xp_char_t rc;
+ sse_char_t rc;
- rc = (escaped == 2)? XP_T('x'):
- (escaped == 4)? XP_T('u'): XP_T('U');
+ rc = (escaped == 2)? SSE_T('x'):
+ (escaped == 4)? SSE_T('u'): SSE_T('U');
if (digit_count == 0) ADD_TOKEN_CHAR (awk, rc);
else ADD_TOKEN_CHAR (awk, c_acc);
@@ -3881,36 +3881,36 @@ static int __get_string (
if (escaped == 1)
{
- if (c == XP_T('n')) c = XP_T('\n');
- else if (c == XP_T('r')) c = XP_T('\r');
- else if (c == XP_T('t')) c = XP_T('\t');
- else if (c == XP_T('f')) c = XP_T('\f');
- else if (c == XP_T('b')) c = XP_T('\b');
- else if (c == XP_T('v')) c = XP_T('\v');
- else if (c == XP_T('a')) c = XP_T('\a');
- else if (c >= XP_T('0') && c <= XP_T('7'))
+ if (c == SSE_T('n')) c = SSE_T('\n');
+ else if (c == SSE_T('r')) c = SSE_T('\r');
+ else if (c == SSE_T('t')) c = SSE_T('\t');
+ else if (c == SSE_T('f')) c = SSE_T('\f');
+ else if (c == SSE_T('b')) c = SSE_T('\b');
+ else if (c == SSE_T('v')) c = SSE_T('\v');
+ else if (c == SSE_T('a')) c = SSE_T('\a');
+ else if (c >= SSE_T('0') && c <= SSE_T('7'))
{
escaped = 3;
digit_count = 1;
- c_acc = c - XP_T('0');
+ c_acc = c - SSE_T('0');
continue;
}
- else if (c == XP_T('x'))
+ else if (c == SSE_T('x'))
{
escaped = 2;
digit_count = 0;
c_acc = 0;
continue;
}
- #ifdef XP_CHAR_IS_WCHAR
- else if (c == XP_T('u') && xp_sizeof(xp_char_t) >= 2)
+ #ifdef SSE_CHAR_IS_WCHAR
+ else if (c == SSE_T('u') && sse_sizeof(sse_char_t) >= 2)
{
escaped = 4;
digit_count = 0;
c_acc = 0;
continue;
}
- else if (c == XP_T('U') && xp_sizeof(xp_char_t) >= 4)
+ else if (c == SSE_T('U') && sse_sizeof(sse_char_t) >= 4)
{
escaped = 8;
digit_count = 0;
@@ -3932,10 +3932,10 @@ static int __get_string (
return 0;
}
-static int __get_char (xp_awk_t* awk)
+static int __get_char (sse_awk_t* awk)
{
- xp_ssize_t n;
- /*xp_char_t c;*/
+ sse_ssize_t n;
+ /*sse_char_t c;*/
if (awk->src.lex.ungotc_count > 0)
{
@@ -3946,17 +3946,17 @@ static int __get_char (xp_awk_t* awk)
if (awk->src.shared.buf_pos >= awk->src.shared.buf_len)
{
n = awk->src.ios->in (
- XP_AWK_IO_READ, awk->src.ios->custom_data,
- awk->src.shared.buf, xp_countof(awk->src.shared.buf));
+ SSE_AWK_IO_READ, awk->src.ios->custom_data,
+ awk->src.shared.buf, sse_countof(awk->src.shared.buf));
if (n == -1)
{
- awk->errnum = XP_AWK_ESRCINREAD;
+ awk->errnum = SSE_AWK_ESRCINREAD;
return -1;
}
if (n == 0)
{
- awk->src.lex.curc = XP_CHAR_EOF;
+ awk->src.lex.curc = SSE_CHAR_EOF;
return 0;
}
@@ -3966,7 +3966,7 @@ static int __get_char (xp_awk_t* awk)
awk->src.lex.curc = awk->src.shared.buf[awk->src.shared.buf_pos++];
- if (awk->src.lex.curc == XP_T('\n'))
+ if (awk->src.lex.curc == SSE_T('\n'))
{
awk->src.lex.line++;
awk->src.lex.column = 1;
@@ -3976,11 +3976,11 @@ static int __get_char (xp_awk_t* awk)
return 0;
}
-static int __unget_char (xp_awk_t* awk, xp_cint_t c)
+static int __unget_char (sse_awk_t* awk, sse_cint_t c)
{
- if (awk->src.lex.ungotc_count >= xp_countof(awk->src.lex.ungotc))
+ if (awk->src.lex.ungotc_count >= sse_countof(awk->src.lex.ungotc))
{
- awk->errnum = XP_AWK_ELXUNG;
+ awk->errnum = SSE_AWK_ELXUNG;
return -1;
}
@@ -3988,73 +3988,73 @@ static int __unget_char (xp_awk_t* awk, xp_cint_t c)
return 0;
}
-static int __skip_spaces (xp_awk_t* awk)
+static int __skip_spaces (sse_awk_t* awk)
{
- xp_cint_t c = awk->src.lex.curc;
+ sse_cint_t c = awk->src.lex.curc;
- if (awk->option & XP_AWK_NEWLINE && awk->parse.nl_semicolon)
+ if (awk->option & SSE_AWK_NEWLINE && awk->parse.nl_semicolon)
{
- while (c != XP_T('\n') &&
- XP_AWK_ISSPACE (awk, c)) GET_CHAR_TO (awk, c);
+ while (c != SSE_T('\n') &&
+ SSE_AWK_ISSPACE (awk, c)) GET_CHAR_TO (awk, c);
}
else
{
- while (XP_AWK_ISSPACE (awk, c)) GET_CHAR_TO (awk, c);
+ while (SSE_AWK_ISSPACE (awk, c)) GET_CHAR_TO (awk, c);
}
return 0;
}
-static int __skip_comment (xp_awk_t* awk)
+static int __skip_comment (sse_awk_t* awk)
{
- xp_cint_t c = awk->src.lex.curc;
+ sse_cint_t c = awk->src.lex.curc;
- if ((awk->option & XP_AWK_HASHSIGN) && c == XP_T('#'))
+ if ((awk->option & SSE_AWK_HASHSIGN) && c == SSE_T('#'))
{
do
{
GET_CHAR_TO (awk, c);
}
- while (c != XP_T('\n') && c != XP_CHAR_EOF);
+ while (c != SSE_T('\n') && c != SSE_CHAR_EOF);
GET_CHAR (awk);
return 1; /* comment by # */
}
- if (c != XP_T('/')) return 0; /* not a comment */
+ if (c != SSE_T('/')) return 0; /* not a comment */
GET_CHAR_TO (awk, c);
- if ((awk->option & XP_AWK_DBLSLASHES) && c == XP_T('/'))
+ if ((awk->option & SSE_AWK_DBLSLASHES) && c == SSE_T('/'))
{
do
{
GET_CHAR_TO (awk, c);
}
- while (c != XP_T('\n') && c != XP_CHAR_EOF);
+ while (c != SSE_T('\n') && c != SSE_CHAR_EOF);
GET_CHAR (awk);
return 1; /* comment by // */
}
- else if (c == XP_T('*'))
+ else if (c == SSE_T('*'))
{
do
{
GET_CHAR_TO (awk, c);
- if (c == XP_CHAR_EOF)
+ if (c == SSE_CHAR_EOF)
{
- awk->errnum = XP_AWK_EENDCOMMENT;
+ awk->errnum = SSE_AWK_EENDCOMMENT;
return -1;
}
- if (c == XP_T('*'))
+ if (c == SSE_T('*'))
{
GET_CHAR_TO (awk, c);
- if (c == XP_CHAR_EOF)
+ if (c == SSE_CHAR_EOF)
{
- awk->errnum = XP_AWK_EENDCOMMENT;
+ awk->errnum = SSE_AWK_EENDCOMMENT;
return -1;
}
- if (c == XP_T('/'))
+ if (c == SSE_T('/'))
{
GET_CHAR_TO (awk, c);
break;
@@ -4067,22 +4067,22 @@ static int __skip_comment (xp_awk_t* awk)
}
if (__unget_char(awk,c) == -1) return -1; /* error */
- awk->src.lex.curc = XP_T('/');
+ awk->src.lex.curc = SSE_T('/');
return 0;
}
static int __classify_ident (
- xp_awk_t* awk, const xp_char_t* name, xp_size_t len)
+ sse_awk_t* awk, const sse_char_t* name, sse_size_t len)
{
struct __kwent* kwp;
- for (kwp = __kwtab; kwp->name != XP_NULL; kwp++)
+ for (kwp = __kwtab; kwp->name != SSE_NULL; kwp++)
{
if (kwp->valid != 0 &&
(awk->option & kwp->valid) == 0) continue;
- if (xp_awk_strxncmp (kwp->name, kwp->name_len, name, len) == 0)
+ if (sse_awk_strxncmp (kwp->name, kwp->name_len, name, len) == 0)
{
return kwp->type;
}
@@ -4091,21 +4091,21 @@ static int __classify_ident (
return TOKEN_IDENT;
}
-static int __assign_to_opcode (xp_awk_t* awk)
+static int __assign_to_opcode (sse_awk_t* awk)
{
static int __assop[] =
{
- XP_AWK_ASSOP_NONE,
- XP_AWK_ASSOP_PLUS,
- XP_AWK_ASSOP_MINUS,
- XP_AWK_ASSOP_MUL,
- XP_AWK_ASSOP_DIV,
- XP_AWK_ASSOP_MOD,
- XP_AWK_ASSOP_EXP
+ 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_ESSE
};
if (awk->token.type >= TOKEN_ASSIGN &&
- awk->token.type <= TOKEN_EXP_ASSIGN)
+ awk->token.type <= TOKEN_ESSE_ASSIGN)
{
return __assop[awk->token.type - TOKEN_ASSIGN];
}
@@ -4113,50 +4113,50 @@ static int __assign_to_opcode (xp_awk_t* awk)
return -1;
}
-static int __is_plain_var (xp_awk_nde_t* nde)
+static int __is_plain_var (sse_awk_nde_t* nde)
{
- return nde->type == XP_AWK_NDE_GLOBAL ||
- nde->type == XP_AWK_NDE_LOCAL ||
- nde->type == XP_AWK_NDE_ARG ||
- nde->type == XP_AWK_NDE_NAMED;
+ return nde->type == SSE_AWK_NDE_GLOBAL ||
+ nde->type == SSE_AWK_NDE_LOCAL ||
+ nde->type == SSE_AWK_NDE_ARG ||
+ nde->type == SSE_AWK_NDE_NAMED;
}
-static int __is_var (xp_awk_nde_t* nde)
+static int __is_var (sse_awk_nde_t* nde)
{
- return nde->type == XP_AWK_NDE_GLOBAL ||
- nde->type == XP_AWK_NDE_LOCAL ||
- nde->type == XP_AWK_NDE_ARG ||
- nde->type == XP_AWK_NDE_NAMED ||
- nde->type == XP_AWK_NDE_GLOBALIDX ||
- nde->type == XP_AWK_NDE_LOCALIDX ||
- nde->type == XP_AWK_NDE_ARGIDX ||
- nde->type == XP_AWK_NDE_NAMEDIDX;
+ return nde->type == SSE_AWK_NDE_GLOBAL ||
+ nde->type == SSE_AWK_NDE_LOCAL ||
+ nde->type == SSE_AWK_NDE_ARG ||
+ nde->type == SSE_AWK_NDE_NAMED ||
+ nde->type == SSE_AWK_NDE_GLOBALIDX ||
+ nde->type == SSE_AWK_NDE_LOCALIDX ||
+ nde->type == SSE_AWK_NDE_ARGIDX ||
+ nde->type == SSE_AWK_NDE_NAMEDIDX;
}
struct __deparse_func_t
{
- xp_awk_t* awk;
- xp_char_t* tmp;
- xp_size_t tmp_len;
+ sse_awk_t* awk;
+ sse_char_t* tmp;
+ sse_size_t tmp_len;
};
-static int __deparse (xp_awk_t* awk)
+static int __deparse (sse_awk_t* awk)
{
- xp_awk_chain_t* chain;
- xp_char_t tmp[xp_sizeof(xp_size_t)*8 + 32];
+ sse_awk_chain_t* chain;
+ sse_char_t tmp[sse_sizeof(sse_size_t)*8 + 32];
struct __deparse_func_t df;
int n = 0, op;
- xp_awk_assert (awk, awk->src.ios->out != XP_NULL);
+ sse_awk_assert (awk, awk->src.ios->out != SSE_NULL);
awk->src.shared.buf_len = 0;
awk->src.shared.buf_pos = 0;
op = awk->src.ios->out (
- XP_AWK_IO_OPEN, awk->src.ios->custom_data, XP_NULL, 0);
+ SSE_AWK_IO_OPEN, awk->src.ios->custom_data, SSE_NULL, 0);
if (op == -1)
{
- awk->errnum = XP_AWK_ESRCOUTOPEN;
+ awk->errnum = SSE_AWK_ESRCOUTOPEN;
return -1;
}
@@ -4182,97 +4182,97 @@ static int __deparse (xp_awk_t* awk)
if (awk->tree.nglobals > awk->tree.nbglobals)
{
- xp_size_t i, len;
+ sse_size_t i, len;
- xp_awk_assert (awk, awk->tree.nglobals > 0);
- if (xp_awk_putsrcstr (awk, XP_T("global ")) == -1)
- EXIT_DEPARSE (XP_AWK_ESRCOUTWRITE);
+ sse_awk_assert (awk, awk->tree.nglobals > 0);
+ if (sse_awk_putsrcstr (awk, SSE_T("global ")) == -1)
+ EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
for (i = awk->tree.nbglobals; i < awk->tree.nglobals - 1; i++)
{
- len = xp_awk_longtostr ((xp_long_t)i,
- 10, XP_T("__global"), tmp, xp_countof(tmp));
- xp_awk_assert (awk, len != (xp_size_t)-1);
- if (xp_awk_putsrcstrx (awk, tmp, len) == -1)
- EXIT_DEPARSE (XP_AWK_ESRCOUTWRITE);
- if (xp_awk_putsrcstr (awk, XP_T(", ")) == -1)
- EXIT_DEPARSE (XP_AWK_ESRCOUTWRITE);
+ len = sse_awk_longtostr ((sse_long_t)i,
+ 10, SSE_T("__global"), tmp, sse_countof(tmp));
+ sse_awk_assert (awk, len != (sse_size_t)-1);
+ if (sse_awk_putsrcstrx (awk, tmp, len) == -1)
+ EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
+ if (sse_awk_putsrcstr (awk, SSE_T(", ")) == -1)
+ EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
}
- len = xp_awk_longtostr ((xp_long_t)i,
- 10, XP_T("__global"), tmp, xp_countof(tmp));
- xp_awk_assert (awk, len != (xp_size_t)-1);
- if (xp_awk_putsrcstrx (awk, tmp, len) == -1)
- EXIT_DEPARSE (XP_AWK_ESRCOUTWRITE);
- if (xp_awk_putsrcstr (awk, XP_T(";\n\n")) == -1)
- EXIT_DEPARSE (XP_AWK_ESRCOUTWRITE);
+ len = sse_awk_longtostr ((sse_long_t)i,
+ 10, SSE_T("__global"), tmp, sse_countof(tmp));
+ sse_awk_assert (awk, len != (sse_size_t)-1);
+ if (sse_awk_putsrcstrx (awk, tmp, len) == -1)
+ EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
+ if (sse_awk_putsrcstr (awk, SSE_T(";\n\n")) == -1)
+ EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
}
df.awk = awk;
df.tmp = tmp;
- df.tmp_len = xp_countof(tmp);
+ df.tmp_len = sse_countof(tmp);
- if (xp_awk_map_walk (&awk->tree.afns, __deparse_func, &df) == -1)
+ if (sse_awk_map_walk (&awk->tree.afns, __deparse_func, &df) == -1)
{
- EXIT_DEPARSE (XP_AWK_ESRCOUTWRITE);
+ EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
}
- if (awk->tree.begin != XP_NULL)
+ if (awk->tree.begin != SSE_NULL)
{
- if (xp_awk_putsrcstr (awk, XP_T("BEGIN ")) == -1)
- EXIT_DEPARSE (XP_AWK_ESRCOUTWRITE);
+ if (sse_awk_putsrcstr (awk, SSE_T("BEGIN ")) == -1)
+ EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
- if (xp_awk_prnpt (awk, awk->tree.begin) == -1)
- EXIT_DEPARSE (XP_AWK_ESRCOUTWRITE);
+ if (sse_awk_prnpt (awk, awk->tree.begin) == -1)
+ EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
- if (__put_char (awk, XP_T('\n')) == -1)
- EXIT_DEPARSE (XP_AWK_ESRCOUTWRITE);
+ if (__put_char (awk, SSE_T('\n')) == -1)
+ EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
}
chain = awk->tree.chain;
- while (chain != XP_NULL)
+ while (chain != SSE_NULL)
{
- if (chain->pattern != XP_NULL)
+ if (chain->pattern != SSE_NULL)
{
- if (xp_awk_prnptnpt (awk, chain->pattern) == -1)
- EXIT_DEPARSE (XP_AWK_ESRCOUTWRITE);
+ if (sse_awk_prnptnpt (awk, chain->pattern) == -1)
+ EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
}
- if (chain->action == XP_NULL)
+ if (chain->action == SSE_NULL)
{
/* blockless pattern */
- if (__put_char (awk, XP_T('\n')) == -1)
- EXIT_DEPARSE (XP_AWK_ESRCOUTWRITE);
+ if (__put_char (awk, SSE_T('\n')) == -1)
+ EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
}
else
{
- if (xp_awk_prnpt (awk, chain->action) == -1)
- EXIT_DEPARSE (XP_AWK_ESRCOUTWRITE);
+ if (sse_awk_prnpt (awk, chain->action) == -1)
+ EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
}
- if (__put_char (awk, XP_T('\n')) == -1)
- EXIT_DEPARSE (XP_AWK_ESRCOUTWRITE);
+ if (__put_char (awk, SSE_T('\n')) == -1)
+ EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
chain = chain->next;
}
- if (awk->tree.end != XP_NULL)
+ if (awk->tree.end != SSE_NULL)
{
- if (xp_awk_putsrcstr (awk, XP_T("END ")) == -1)
- EXIT_DEPARSE (XP_AWK_ESRCOUTWRITE);
- if (xp_awk_prnpt (awk, awk->tree.end) == -1)
- EXIT_DEPARSE (XP_AWK_ESRCOUTWRITE);
+ if (sse_awk_putsrcstr (awk, SSE_T("END ")) == -1)
+ EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
+ if (sse_awk_prnpt (awk, awk->tree.end) == -1)
+ EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
}
- if (__flush (awk) == -1) EXIT_DEPARSE (XP_AWK_ESRCOUTWRITE);
+ if (__flush (awk) == -1) EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
exit_deparse:
if (awk->src.ios->out (
- XP_AWK_IO_CLOSE, awk->src.ios->custom_data, XP_NULL, 0) == -1)
+ SSE_AWK_IO_CLOSE, awk->src.ios->custom_data, SSE_NULL, 0) == -1)
{
if (n != -1)
{
- awk->errnum = XP_AWK_ESRCOUTCLOSE;
+ awk->errnum = SSE_AWK_ESRCOUTCLOSE;
n = -1;
}
}
@@ -4280,57 +4280,57 @@ exit_deparse:
return 0;
}
-static int __deparse_func (xp_awk_pair_t* pair, void* arg)
+static int __deparse_func (sse_awk_pair_t* pair, void* arg)
{
struct __deparse_func_t* df = (struct __deparse_func_t*)arg;
- xp_awk_afn_t* afn = (xp_awk_afn_t*)pair->val;
- xp_size_t i, n;
+ sse_awk_afn_t* afn = (sse_awk_afn_t*)pair->val;
+ sse_size_t i, n;
- xp_awk_assert (df->awk, xp_awk_strxncmp (
+ sse_awk_assert (df->awk, sse_awk_strxncmp (
pair->key, pair->key_len, afn->name, afn->name_len) == 0);
- if (xp_awk_putsrcstr (df->awk, XP_T("function ")) == -1) return -1;
- if (xp_awk_putsrcstr (df->awk, afn->name) == -1) return -1;
- if (xp_awk_putsrcstr (df->awk, XP_T(" (")) == -1) return -1;
+ if (sse_awk_putsrcstr (df->awk, SSE_T("function ")) == -1) return -1;
+ if (sse_awk_putsrcstr (df->awk, afn->name) == -1) return -1;
+ if (sse_awk_putsrcstr (df->awk, SSE_T(" (")) == -1) return -1;
for (i = 0; i < afn->nargs; )
{
- n = xp_awk_longtostr (i++, 10,
- XP_T("__param"), df->tmp, df->tmp_len);
- xp_awk_assert (df->awk, n != (xp_size_t)-1);
- if (xp_awk_putsrcstrx (df->awk, df->tmp, n) == -1) return -1;
+ n = sse_awk_longtostr (i++, 10,
+ SSE_T("__param"), df->tmp, df->tmp_len);
+ sse_awk_assert (df->awk, n != (sse_size_t)-1);
+ if (sse_awk_putsrcstrx (df->awk, df->tmp, n) == -1) return -1;
if (i >= afn->nargs) break;
- if (xp_awk_putsrcstr (df->awk, XP_T(", ")) == -1) return -1;
+ if (sse_awk_putsrcstr (df->awk, SSE_T(", ")) == -1) return -1;
}
- if (xp_awk_putsrcstr (df->awk, XP_T(")\n")) == -1) return -1;
+ if (sse_awk_putsrcstr (df->awk, SSE_T(")\n")) == -1) return -1;
- if (xp_awk_prnpt (df->awk, afn->body) == -1) return -1;
- if (xp_awk_putsrcstr (df->awk, XP_T("\n")) == -1) return -1;
+ if (sse_awk_prnpt (df->awk, afn->body) == -1) return -1;
+ if (sse_awk_putsrcstr (df->awk, SSE_T("\n")) == -1) return -1;
return 0;
}
-static int __put_char (xp_awk_t* awk, xp_char_t c)
+static int __put_char (sse_awk_t* awk, sse_char_t c)
{
awk->src.shared.buf[awk->src.shared.buf_len++] = c;
- if (awk->src.shared.buf_len >= xp_countof(awk->src.shared.buf))
+ if (awk->src.shared.buf_len >= sse_countof(awk->src.shared.buf))
{
if (__flush (awk) == -1) return -1;
}
return 0;
}
-static int __flush (xp_awk_t* awk)
+static int __flush (sse_awk_t* awk)
{
- xp_ssize_t n;
+ sse_ssize_t n;
- xp_awk_assert (awk, awk->src.ios->out != XP_NULL);
+ sse_awk_assert (awk, awk->src.ios->out != SSE_NULL);
while (awk->src.shared.buf_pos < awk->src.shared.buf_len)
{
n = awk->src.ios->out (
- XP_AWK_IO_WRITE, awk->src.ios->custom_data,
+ SSE_AWK_IO_WRITE, awk->src.ios->custom_data,
&awk->src.shared.buf[awk->src.shared.buf_pos],
awk->src.shared.buf_len - awk->src.shared.buf_pos);
if (n <= 0) return -1;
@@ -4343,9 +4343,9 @@ static int __flush (xp_awk_t* awk)
return 0;
}
-int xp_awk_putsrcstr (xp_awk_t* awk, const xp_char_t* str)
+int sse_awk_putsrcstr (sse_awk_t* awk, const sse_char_t* str)
{
- while (*str != XP_T('\0'))
+ while (*str != SSE_T('\0'))
{
if (__put_char (awk, *str) == -1) return -1;
str++;
@@ -4354,10 +4354,10 @@ int xp_awk_putsrcstr (xp_awk_t* awk, const xp_char_t* str)
return 0;
}
-int xp_awk_putsrcstrx (
- xp_awk_t* awk, const xp_char_t* str, xp_size_t len)
+int sse_awk_putsrcstrx (
+ sse_awk_t* awk, const sse_char_t* str, sse_size_t len)
{
- const xp_char_t* end = str + len;
+ const sse_char_t* end = str + len;
while (str < end)
{
diff --git a/ase/awk/parse.h b/ase/awk/parse.h
index eb9af3f2..b7ba69e6 100644
--- a/ase/awk/parse.h
+++ b/ase/awk/parse.h
@@ -1,21 +1,21 @@
/*
- * $Id: parse.h,v 1.1 2006-08-21 14:51:32 bacon Exp $
+ * $Id: parse.h,v 1.2 2006-10-22 11:34:53 bacon Exp $
*/
-#ifndef _XP_AWK_PARSE_H_
-#define _XP_AWK_PARSE_H_
+#ifndef _SSE_AWK_PARSE_H_
+#define _SSE_AWK_PARSE_H_
-#ifndef _XP_AWK_AWK_H_
-#error Never include this file directly. Include <xp/awk/awk.h> instead
+#ifndef _SSE_AWK_AWK_H_
+#error Never include this file directly. Include <sse/awk/awk.h> instead
#endif
#ifdef __cplusplus
extern "C" {
#endif
-int xp_awk_putsrcstr (xp_awk_t* awk, const xp_char_t* str);
-int xp_awk_putsrcstrx (
- xp_awk_t* awk, const xp_char_t* str, xp_size_t len);
+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);
#ifdef __cplusplus
}
diff --git a/ase/awk/rec.c b/ase/awk/rec.c
index 749f4b4c..973253c5 100644
--- a/ase/awk/rec.c
+++ b/ase/awk/rec.c
@@ -1,57 +1,57 @@
/*
- * $Id: rec.c,v 1.3 2006-10-12 14:36:25 bacon Exp $
+ * $Id: rec.c,v 1.4 2006-10-22 11:34:53 bacon Exp $
*/
-#include <xp/awk/awk_i.h>
+#include <sse/awk/awk_i.h>
-static int __split_record (xp_awk_run_t* run);
+static int __split_record (sse_awk_run_t* run);
static int __recomp_record_fields (
- xp_awk_run_t* run, xp_size_t lv,
- const xp_char_t* str, xp_size_t len);
+ sse_awk_run_t* run, sse_size_t lv,
+ const sse_char_t* str, sse_size_t len);
-int xp_awk_setrec (
- xp_awk_run_t* run, xp_size_t idx, const xp_char_t* str, xp_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)
{
- xp_awk_val_t* v;
+ sse_awk_val_t* v;
int errnum;
if (idx == 0)
{
- if (str == XP_AWK_STR_BUF(&run->inrec.line) &&
- len == XP_AWK_STR_LEN(&run->inrec.line))
+ if (str == SSE_AWK_STR_BUF(&run->inrec.line) &&
+ len == SSE_AWK_STR_LEN(&run->inrec.line))
{
- if (xp_awk_clrrec (run, xp_true) == -1) return -1;
+ if (sse_awk_clrrec (run, sse_true) == -1) return -1;
}
else
{
- if (xp_awk_clrrec (run, xp_false) == -1) return -1;
+ if (sse_awk_clrrec (run, sse_false) == -1) return -1;
- if (xp_awk_str_ncpy (&run->inrec.line, str, len) == (xp_size_t)-1)
+ if (sse_awk_str_ncpy (&run->inrec.line, str, len) == (sse_size_t)-1)
{
- xp_awk_clrrec (run, xp_false);
- run->errnum = XP_AWK_ENOMEM;
+ sse_awk_clrrec (run, sse_false);
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
}
- v = xp_awk_makestrval (run, str, len);
- if (v == XP_NULL)
+ v = sse_awk_makestrval (run, str, len);
+ if (v == SSE_NULL)
{
- xp_awk_clrrec (run, xp_false);
- run->errnum = XP_AWK_ENOMEM;
+ sse_awk_clrrec (run, sse_false);
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
- xp_awk_assert (run->awk, run->inrec.d0->type == XP_AWK_VAL_NIL);
+ sse_awk_assert (run->awk, run->inrec.d0->type == SSE_AWK_VAL_NIL);
/* d0 should be cleared before the next line is reached
- * as it doesn't call xp_awk_refdownval on run->inrec.d0 */
+ * as it doesn't call sse_awk_refdownval on run->inrec.d0 */
run->inrec.d0 = v;
- xp_awk_refupval (v);
+ sse_awk_refupval (v);
if (__split_record (run) == -1)
{
errnum = run->errnum;
- xp_awk_clrrec (run, xp_false);
+ sse_awk_clrrec (run, sse_false);
run->errnum = errnum;
return -1;
}
@@ -61,210 +61,210 @@ int xp_awk_setrec (
if (__recomp_record_fields (run, idx, str, len) == -1)
{
errnum = run->errnum;
- xp_awk_clrrec (run, xp_false);
+ sse_awk_clrrec (run, sse_false);
run->errnum = errnum;
return -1;
}
/* recompose $0 */
- v = xp_awk_makestrval (run,
- XP_AWK_STR_BUF(&run->inrec.line),
- XP_AWK_STR_LEN(&run->inrec.line));
- if (v == XP_NULL)
+ v = sse_awk_makestrval (run,
+ SSE_AWK_STR_BUF(&run->inrec.line),
+ SSE_AWK_STR_LEN(&run->inrec.line));
+ if (v == SSE_NULL)
{
- xp_awk_clrrec (run, xp_false);
- run->errnum = XP_AWK_ENOMEM;
+ sse_awk_clrrec (run, sse_false);
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
- xp_awk_refdownval (run, run->inrec.d0);
+ sse_awk_refdownval (run, run->inrec.d0);
run->inrec.d0 = v;
- xp_awk_refupval (v);
+ sse_awk_refupval (v);
}
return 0;
}
-static int __split_record (xp_awk_run_t* run)
+static int __split_record (sse_awk_run_t* run)
{
- xp_char_t* p, * tok;
- xp_size_t len, tok_len, nflds;
- xp_awk_val_t* v, * fs;
- xp_char_t* fs_ptr, * fs_free;
- xp_size_t fs_len;
+ 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;
int errnum;
/* inrec should be cleared before __split_record is called */
- xp_awk_assert (run->awk, run->inrec.nflds == 0);
+ sse_awk_assert (run->awk, run->inrec.nflds == 0);
/* get FS */
- fs = xp_awk_getglobal (run, XP_AWK_GLOBAL_FS);
- if (fs->type == XP_AWK_VAL_NIL)
+ fs = sse_awk_getglobal (run, SSE_AWK_GLOBAL_FS);
+ if (fs->type == SSE_AWK_VAL_NIL)
{
- fs_ptr = XP_T(" ");
+ fs_ptr = SSE_T(" ");
fs_len = 1;
- fs_free = XP_NULL;
+ fs_free = SSE_NULL;
}
- else if (fs->type == XP_AWK_VAL_STR)
+ else if (fs->type == SSE_AWK_VAL_STR)
{
- fs_ptr = ((xp_awk_val_str_t*)fs)->buf;
- fs_len = ((xp_awk_val_str_t*)fs)->len;
- fs_free = XP_NULL;
+ fs_ptr = ((sse_awk_val_str_t*)fs)->buf;
+ fs_len = ((sse_awk_val_str_t*)fs)->len;
+ fs_free = SSE_NULL;
}
else
{
- fs_ptr = xp_awk_valtostr (
- run, fs, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &fs_len);
- if (fs_ptr == XP_NULL) return -1;
+ fs_ptr = sse_awk_valtostr (
+ run, fs, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &fs_len);
+ if (fs_ptr == SSE_NULL) return -1;
fs_free = fs_ptr;
}
/* scan the input record to count the fields */
- p = XP_AWK_STR_BUF(&run->inrec.line);
- len = XP_AWK_STR_LEN(&run->inrec.line);
+ p = SSE_AWK_STR_BUF(&run->inrec.line);
+ len = SSE_AWK_STR_LEN(&run->inrec.line);
nflds = 0;
- while (p != XP_NULL)
+ while (p != SSE_NULL)
{
if (fs_len <= 1)
{
- p = xp_awk_strxntok (run,
+ p = sse_awk_strxntok (run,
p, len, fs_ptr, fs_len, &tok, &tok_len);
}
else
{
- p = xp_awk_strxntokbyrex (run, p, len,
+ p = sse_awk_strxntokbyrex (run, p, len,
run->global.fs, &tok, &tok_len, &errnum);
- if (p == XP_NULL && errnum != XP_AWK_ENOERR)
+ if (p == SSE_NULL && errnum != SSE_AWK_ENOERR)
{
- if (fs_free != XP_NULL)
- XP_AWK_FREE (run->awk, fs_free);
+ if (fs_free != SSE_NULL)
+ SSE_AWK_FREE (run->awk, fs_free);
run->errnum = errnum;
return -1;
}
}
- if (nflds == 0 && p == XP_NULL && tok_len == 0)
+ if (nflds == 0 && p == SSE_NULL && tok_len == 0)
{
/* there are no fields. it can just return here
- * as xp_awk_clrrec has been called before this */
- if (fs_free != XP_NULL) XP_AWK_FREE (run->awk, fs_free);
+ * as sse_awk_clrrec has been called before this */
+ if (fs_free != SSE_NULL) SSE_AWK_FREE (run->awk, fs_free);
return 0;
}
- xp_awk_assert (run->awk,
- (tok != XP_NULL && tok_len > 0) || tok_len == 0);
+ sse_awk_assert (run->awk,
+ (tok != SSE_NULL && tok_len > 0) || tok_len == 0);
nflds++;
- len = XP_AWK_STR_LEN(&run->inrec.line) -
- (p - XP_AWK_STR_BUF(&run->inrec.line));
+ len = SSE_AWK_STR_LEN(&run->inrec.line) -
+ (p - SSE_AWK_STR_BUF(&run->inrec.line));
}
/* allocate space */
if (nflds > run->inrec.maxflds)
{
- void* tmp = XP_AWK_MALLOC (
- run->awk, xp_sizeof(*run->inrec.flds) * nflds);
- if (tmp == XP_NULL)
+ void* tmp = SSE_AWK_MALLOC (
+ run->awk, sse_sizeof(*run->inrec.flds) * nflds);
+ if (tmp == SSE_NULL)
{
- if (fs_free != XP_NULL) XP_AWK_FREE (run->awk, fs_free);
- run->errnum = XP_AWK_ENOMEM;
+ if (fs_free != SSE_NULL) SSE_AWK_FREE (run->awk, fs_free);
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
- if (run->inrec.flds != XP_NULL)
- XP_AWK_FREE (run->awk, run->inrec.flds);
+ if (run->inrec.flds != SSE_NULL)
+ SSE_AWK_FREE (run->awk, run->inrec.flds);
run->inrec.flds = tmp;
run->inrec.maxflds = nflds;
}
/* scan again and split it */
- p = XP_AWK_STR_BUF(&run->inrec.line);
- len = XP_AWK_STR_LEN(&run->inrec.line);
+ p = SSE_AWK_STR_BUF(&run->inrec.line);
+ len = SSE_AWK_STR_LEN(&run->inrec.line);
- while (p != XP_NULL)
+ while (p != SSE_NULL)
{
if (fs_len <= 1)
{
- p = xp_awk_strxntok (
+ p = sse_awk_strxntok (
run, p, len, fs_ptr, fs_len, &tok, &tok_len);
}
else
{
- p = xp_awk_strxntokbyrex (run, p, len,
+ p = sse_awk_strxntokbyrex (run, p, len,
run->global.fs, &tok, &tok_len, &errnum);
- if (p == XP_NULL && errnum != XP_AWK_ENOERR)
+ if (p == SSE_NULL && errnum != SSE_AWK_ENOERR)
{
- if (fs_free != XP_NULL)
- XP_AWK_FREE (run->awk, fs_free);
+ if (fs_free != SSE_NULL)
+ SSE_AWK_FREE (run->awk, fs_free);
run->errnum = errnum;
return -1;
}
}
- xp_awk_assert (run->awk,
- (tok != XP_NULL && tok_len > 0) || tok_len == 0);
+ sse_awk_assert (run->awk,
+ (tok != SSE_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 =
- xp_awk_makestrval (run, tok, tok_len);
+ sse_awk_makestrval (run, tok, tok_len);
- if (run->inrec.flds[run->inrec.nflds].val == XP_NULL)
+ if (run->inrec.flds[run->inrec.nflds].val == SSE_NULL)
{
- if (fs_free != XP_NULL) XP_AWK_FREE (run->awk, fs_free);
- run->errnum = XP_AWK_ENOMEM;
+ if (fs_free != SSE_NULL) SSE_AWK_FREE (run->awk, fs_free);
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
- xp_awk_refupval (run->inrec.flds[run->inrec.nflds].val);
+ sse_awk_refupval (run->inrec.flds[run->inrec.nflds].val);
run->inrec.nflds++;
- len = XP_AWK_STR_LEN(&run->inrec.line) -
- (p - XP_AWK_STR_BUF(&run->inrec.line));
+ len = SSE_AWK_STR_LEN(&run->inrec.line) -
+ (p - SSE_AWK_STR_BUF(&run->inrec.line));
}
- if (fs_free != XP_NULL) XP_AWK_FREE (run->awk, fs_free);
+ if (fs_free != SSE_NULL) SSE_AWK_FREE (run->awk, fs_free);
/* set the number of fields */
- v = xp_awk_makeintval (run, (xp_long_t)nflds);
- if (v == XP_NULL)
+ v = sse_awk_makeintval (run, (sse_long_t)nflds);
+ if (v == SSE_NULL)
{
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
- if (xp_awk_setglobal (run, XP_AWK_GLOBAL_NF, v) == -1) return -1;
+ if (sse_awk_setglobal (run, SSE_AWK_GLOBAL_NF, v) == -1) return -1;
- xp_awk_assert (run->awk, nflds == run->inrec.nflds);
+ sse_awk_assert (run->awk, nflds == run->inrec.nflds);
return 0;
}
-int xp_awk_clrrec (xp_awk_run_t* run, xp_bool_t skip_inrec_line)
+int sse_awk_clrrec (sse_awk_run_t* run, sse_bool_t skip_inrec_line)
{
- xp_size_t i;
+ sse_size_t i;
int n = 0;
- if (run->inrec.d0 != xp_awk_val_nil)
+ if (run->inrec.d0 != sse_awk_val_nil)
{
- xp_awk_refdownval (run, run->inrec.d0);
- run->inrec.d0 = xp_awk_val_nil;
+ sse_awk_refdownval (run, run->inrec.d0);
+ run->inrec.d0 = sse_awk_val_nil;
}
if (run->inrec.nflds > 0)
{
- xp_awk_assert (run->awk, run->inrec.flds != XP_NULL);
+ sse_awk_assert (run->awk, run->inrec.flds != SSE_NULL);
for (i = 0; i < run->inrec.nflds; i++)
{
- xp_awk_assert (run->awk,
- run->inrec.flds[i].val != XP_NULL);
- xp_awk_refdownval (run, run->inrec.flds[i].val);
+ sse_awk_assert (run->awk,
+ run->inrec.flds[i].val != SSE_NULL);
+ sse_awk_refdownval (run, run->inrec.flds[i].val);
}
run->inrec.nflds = 0;
- if (xp_awk_setglobal (
- run, XP_AWK_GLOBAL_NF, xp_awk_val_zero) == -1)
+ if (sse_awk_setglobal (
+ run, SSE_AWK_GLOBAL_NF, sse_awk_val_zero) == -1)
{
/* first of all, this should never happen.
* if it happened, it would return an error
@@ -273,23 +273,23 @@ int xp_awk_clrrec (xp_awk_run_t* run, xp_bool_t skip_inrec_line)
}
}
- xp_awk_assert (run->awk, run->inrec.nflds == 0);
- if (!skip_inrec_line) xp_awk_str_clear (&run->inrec.line);
+ sse_awk_assert (run->awk, run->inrec.nflds == 0);
+ if (!skip_inrec_line) sse_awk_str_clear (&run->inrec.line);
return n;
}
static int __recomp_record_fields (
- xp_awk_run_t* run, xp_size_t lv,
- const xp_char_t* str, xp_size_t len)
+ sse_awk_run_t* run, sse_size_t lv,
+ const sse_char_t* str, sse_size_t len)
{
- xp_awk_val_t* v;
- xp_size_t max, i, nflds;
+ sse_awk_val_t* v;
+ sse_size_t max, i, nflds;
/* recomposes the record and the fields when $N has been assigned
* a new value and recomputes NF accordingly */
- xp_awk_assert (run->awk, lv > 0);
+ sse_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 != XP_NULL)
+ if (run->awk->syscas.realloc != SSE_NULL)
{
- tmp = XP_AWK_REALLOC (
+ tmp = SSE_AWK_REALLOC (
run->awk, run->inrec.flds,
- xp_sizeof(*run->inrec.flds) * max);
- if (tmp == XP_NULL)
+ sse_sizeof(*run->inrec.flds) * max);
+ if (tmp == SSE_NULL)
{
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
}
else
{
- tmp = XP_AWK_MALLOC (
- run->awk, xp_sizeof(*run->inrec.flds) * max);
- if (tmp == XP_NULL)
+ tmp = SSE_AWK_MALLOC (
+ run->awk, sse_sizeof(*run->inrec.flds) * max);
+ if (tmp == SSE_NULL)
{
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
- if (run->inrec.flds != XP_NULL)
+ if (run->inrec.flds != SSE_NULL)
{
- XP_AWK_MEMCPY (run->awk, tmp, run->inrec.flds,
- xp_sizeof(*run->inrec.flds) * run->inrec.maxflds);
- XP_AWK_FREE (run->awk, run->inrec.flds);
+ 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);
}
}
@@ -335,107 +335,107 @@ static int __recomp_record_fields (
lv = lv - 1; /* adjust the value to 0-based index */
- xp_awk_str_clear (&run->inrec.line);
+ sse_awk_str_clear (&run->inrec.line);
for (i = 0; i < max; i++)
{
if (i > 0)
{
- if (xp_awk_str_ncat (
+ if (sse_awk_str_ncat (
&run->inrec.line,
run->global.ofs.ptr,
- run->global.ofs.len) == (xp_size_t)-1)
+ run->global.ofs.len) == (sse_size_t)-1)
{
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
}
if (i == lv)
{
- xp_awk_val_t* tmp;
+ sse_awk_val_t* tmp;
run->inrec.flds[i].ptr =
- XP_AWK_STR_BUF(&run->inrec.line) +
- XP_AWK_STR_LEN(&run->inrec.line);
+ SSE_AWK_STR_BUF(&run->inrec.line) +
+ SSE_AWK_STR_LEN(&run->inrec.line);
run->inrec.flds[i].len = len;
- if (xp_awk_str_ncat (
- &run->inrec.line, str, len) == (xp_size_t)-1)
+ if (sse_awk_str_ncat (
+ &run->inrec.line, str, len) == (sse_size_t)-1)
{
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
- tmp = xp_awk_makestrval (run, str,len);
- if (tmp == XP_NULL)
+ tmp = sse_awk_makestrval (run, str,len);
+ if (tmp == SSE_NULL)
{
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
if (i < nflds)
- xp_awk_refdownval (run, run->inrec.flds[i].val);
+ sse_awk_refdownval (run, run->inrec.flds[i].val);
else run->inrec.nflds++;
run->inrec.flds[i].val = tmp;
- xp_awk_refupval (tmp);
+ sse_awk_refupval (tmp);
}
else if (i >= nflds)
{
run->inrec.flds[i].ptr =
- XP_AWK_STR_BUF(&run->inrec.line) +
- XP_AWK_STR_LEN(&run->inrec.line);
+ SSE_AWK_STR_BUF(&run->inrec.line) +
+ SSE_AWK_STR_LEN(&run->inrec.line);
run->inrec.flds[i].len = 0;
- if (xp_awk_str_cat (
- &run->inrec.line, XP_T("")) == (xp_size_t)-1)
+ if (sse_awk_str_cat (
+ &run->inrec.line, SSE_T("")) == (sse_size_t)-1)
{
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
- /* xp_awk_refdownval should not be called over
+ /* sse_awk_refdownval should not be called over
* run->inrec.flds[i].val as it is not initialized
* to any valid values */
- /*xp_awk_refdownval (run, run->inrec.flds[i].val);*/
- run->inrec.flds[i].val = xp_awk_val_zls;
- xp_awk_refupval (xp_awk_val_zls);
+ /*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);
run->inrec.nflds++;
}
else
{
- xp_awk_val_str_t* tmp;
+ sse_awk_val_str_t* tmp;
- tmp = (xp_awk_val_str_t*)run->inrec.flds[i].val;
+ tmp = (sse_awk_val_str_t*)run->inrec.flds[i].val;
run->inrec.flds[i].ptr =
- XP_AWK_STR_BUF(&run->inrec.line) +
- XP_AWK_STR_LEN(&run->inrec.line);
+ SSE_AWK_STR_BUF(&run->inrec.line) +
+ SSE_AWK_STR_LEN(&run->inrec.line);
run->inrec.flds[i].len = tmp->len;
- if (xp_awk_str_ncat (&run->inrec.line,
- tmp->buf, tmp->len) == (xp_size_t)-1)
+ if (sse_awk_str_ncat (&run->inrec.line,
+ tmp->buf, tmp->len) == (sse_size_t)-1)
{
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
}
}
- v = xp_awk_getglobal (run, XP_AWK_GLOBAL_NF);
- xp_awk_assert (run->awk, v->type == XP_AWK_VAL_INT);
- if (((xp_awk_val_int_t*)v)->val != max)
+ 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 = xp_awk_makeintval (run, (xp_long_t)max);
- if (v == XP_NULL)
+ v = sse_awk_makeintval (run, (sse_long_t)max);
+ if (v == SSE_NULL)
{
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
- if (xp_awk_setglobal (
- run, XP_AWK_GLOBAL_NF, v) == -1) return -1;
+ if (sse_awk_setglobal (
+ run, SSE_AWK_GLOBAL_NF, v) == -1) return -1;
}
return 0;
diff --git a/ase/awk/rex.c b/ase/awk/rex.c
index 28592429..fae92a5c 100644
--- a/ase/awk/rex.c
+++ b/ase/awk/rex.c
@@ -1,8 +1,8 @@
/*
- * $Id: rex.c,v 1.36 2006-10-12 14:36:25 bacon Exp $
+ * $Id: rex.c,v 1.37 2006-10-22 11:34:53 bacon Exp $
*/
-#include <xp/awk/awk_i.h>
+#include <sse/awk/awk_i.h>
enum
{
@@ -49,7 +49,7 @@ enum
#define DEF_CODE_CAPA 512
#define BOUND_MIN 0
-#define BOUND_MAX (XP_TYPE_MAX(xp_size_t))
+#define BOUND_MAX (SSE_TYPE_MAX(sse_size_t))
typedef struct __builder_t __builder_t;
typedef struct __matcher_t __matcher_t;
@@ -57,34 +57,34 @@ typedef struct __match_t __match_t;
struct __code_t
{
- /*xp_byte_t cmd;*/
+ /*sse_byte_t cmd;*/
short cmd;
short negate; /* only for CMD_CHARSET */
- xp_size_t lbound;
- xp_size_t ubound;
+ sse_size_t lbound;
+ sse_size_t ubound;
};
struct __builder_t
{
- xp_awk_t* awk;
+ sse_awk_t* awk;
struct
{
- const xp_char_t* ptr;
- const xp_char_t* end;
- const xp_char_t* curp;
+ const sse_char_t* ptr;
+ const sse_char_t* end;
+ const sse_char_t* curp;
struct
{
int type;
- xp_char_t value;
+ sse_char_t value;
} curc;
} ptn;
struct
{
- xp_byte_t* buf;
- xp_size_t size;
- xp_size_t capa;
+ sse_byte_t* buf;
+ sse_size_t size;
+ sse_size_t capa;
} code;
struct
@@ -98,14 +98,14 @@ struct __builder_t
struct __matcher_t
{
- xp_awk_t* awk;
+ sse_awk_t* awk;
struct
{
struct
{
- const xp_char_t* ptr;
- const xp_char_t* end;
+ const sse_char_t* ptr;
+ const sse_char_t* end;
} str;
} match;
@@ -121,17 +121,17 @@ struct __matcher_t
struct __match_t
{
- const xp_char_t* match_ptr;
+ const sse_char_t* match_ptr;
- xp_bool_t matched;
- xp_size_t match_len;
+ sse_bool_t matched;
+ sse_size_t match_len;
- const xp_byte_t* branch;
- const xp_byte_t* branch_end;
+ const sse_byte_t* branch;
+ const sse_byte_t* branch_end;
};
-typedef const xp_byte_t* (*atom_matcher_t) (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat);
+typedef const sse_byte_t* (*atom_matcher_t) (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat);
#define NCHARS_REMAINING(rex) ((rex)->ptn.end - (rex)->ptn.curp)
@@ -155,127 +155,127 @@ static int __build_branch (__builder_t* rex);
static int __build_atom (__builder_t* rex);
static int __build_charset (__builder_t* rex, struct __code_t* cmd);
static int __build_occurrences (__builder_t* rex, struct __code_t* cmd);
-static int __build_cclass (__builder_t* rex, xp_char_t* cc);
+static int __build_cclass (__builder_t* rex, sse_char_t* cc);
static int __build_range (__builder_t* rex, struct __code_t* cmd);
static int __next_char (__builder_t* rex, int level);
-static int __add_code (__builder_t* rex, void* data, xp_size_t len);
+static int __add_code (__builder_t* rex, void* data, sse_size_t len);
#if defined(__sparc) || defined(__sparc__)
-static xp_size_t __get_code (__builder_t* builder, xp_size_t pos)
+static sse_size_t __get_code (__builder_t* builder, sse_size_t pos)
{
- xp_size_t code;
- XP_AWK_MEMCPY (builder->awk,
- &code, &builder->code.buf[pos], xp_sizeof(code));
+ sse_size_t code;
+ SSE_AWK_MEMCPY (builder->awk,
+ &code, &builder->code.buf[pos], sse_sizeof(code));
return code;
}
-static void __set_code (__builder_t* builder, xp_size_t pos, xp_size_t code)
+static void __set_code (__builder_t* builder, sse_size_t pos, sse_size_t code)
{
- XP_AWK_MEMCPY (builder->awk,
- &builder->code.buf[pos], &code, xp_sizeof(code));
+ SSE_AWK_MEMCPY (builder->awk,
+ &builder->code.buf[pos], &code, sse_sizeof(code));
}
#endif
-static xp_bool_t __begin_with (
- const xp_char_t* str, xp_size_t len, const xp_char_t* what);
+static sse_bool_t __begin_with (
+ const sse_char_t* str, sse_size_t len, const sse_char_t* what);
-static const xp_byte_t* __match_pattern (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat);
-static const xp_byte_t* __match_branch (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat);
-static const xp_byte_t* __match_branch_body (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat);
-static const xp_byte_t* __match_branch_body0 (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat);
-static const xp_byte_t* __match_atom (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat);
-static const xp_byte_t* __match_bol (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat);
-static const xp_byte_t* __match_eol (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat);
-static const xp_byte_t* __match_any_char (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat);
-static const xp_byte_t* __match_ord_char (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat);
-static const xp_byte_t* __match_charset (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat);
-static const xp_byte_t* __match_group (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat);
+static const sse_byte_t* __match_pattern (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat);
+static const sse_byte_t* __match_branch (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat);
+static const sse_byte_t* __match_branch_body (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat);
+static const sse_byte_t* __match_branch_body0 (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat);
+static const sse_byte_t* __match_atom (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat);
+static const sse_byte_t* __match_bol (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat);
+static const sse_byte_t* __match_eol (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat);
+static const sse_byte_t* __match_any_char (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat);
+static const sse_byte_t* __match_ord_char (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat);
+static const sse_byte_t* __match_charset (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat);
+static const sse_byte_t* __match_group (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat);
-static const xp_byte_t* __match_occurrences (
- __matcher_t* matcher, xp_size_t si, const xp_byte_t* p,
- xp_size_t lbound, xp_size_t ubound, __match_t* mat);
+static const sse_byte_t* __match_occurrences (
+ __matcher_t* matcher, sse_size_t si, const sse_byte_t* p,
+ sse_size_t lbound, sse_size_t ubound, __match_t* mat);
-static xp_bool_t __test_charset (
- __matcher_t* matcher, const xp_byte_t* p, xp_size_t csc, xp_char_t c);
+static sse_bool_t __test_charset (
+ __matcher_t* matcher, const sse_byte_t* p, sse_size_t csc, sse_char_t c);
-static xp_bool_t __cc_isalnum (xp_awk_t* awk, xp_char_t c);
-static xp_bool_t __cc_isalpha (xp_awk_t* awk, xp_char_t c);
-static xp_bool_t __cc_isblank (xp_awk_t* awk, xp_char_t c);
-static xp_bool_t __cc_iscntrl (xp_awk_t* awk, xp_char_t c);
-static xp_bool_t __cc_isdigit (xp_awk_t* awk, xp_char_t c);
-static xp_bool_t __cc_isgraph (xp_awk_t* awk, xp_char_t c);
-static xp_bool_t __cc_islower (xp_awk_t* awk, xp_char_t c);
-static xp_bool_t __cc_isprint (xp_awk_t* awk, xp_char_t c);
-static xp_bool_t __cc_ispunct (xp_awk_t* awk, xp_char_t c);
-static xp_bool_t __cc_isspace (xp_awk_t* awk, xp_char_t c);
-static xp_bool_t __cc_isupper (xp_awk_t* awk, xp_char_t c);
-static xp_bool_t __cc_isxdigit (xp_awk_t* awk, xp_char_t c);
+static sse_bool_t __cc_isalnum (sse_awk_t* awk, sse_char_t c);
+static sse_bool_t __cc_isalpha (sse_awk_t* awk, sse_char_t c);
+static sse_bool_t __cc_isblank (sse_awk_t* awk, sse_char_t c);
+static sse_bool_t __cc_iscntrl (sse_awk_t* awk, sse_char_t c);
+static sse_bool_t __cc_isdigit (sse_awk_t* awk, sse_char_t c);
+static sse_bool_t __cc_isgraph (sse_awk_t* awk, sse_char_t c);
+static sse_bool_t __cc_islower (sse_awk_t* awk, sse_char_t c);
+static sse_bool_t __cc_isprint (sse_awk_t* awk, sse_char_t c);
+static sse_bool_t __cc_ispunct (sse_awk_t* awk, sse_char_t c);
+static sse_bool_t __cc_isspace (sse_awk_t* awk, sse_char_t c);
+static sse_bool_t __cc_isupper (sse_awk_t* awk, sse_char_t c);
+static sse_bool_t __cc_isxdigit (sse_awk_t* awk, sse_char_t c);
-static const xp_byte_t* __print_pattern (const xp_byte_t* p);
-static const xp_byte_t* __print_branch (const xp_byte_t* p);
-static const xp_byte_t* __print_atom (const xp_byte_t* p);
+static const sse_byte_t* __print_pattern (const sse_byte_t* p);
+static const sse_byte_t* __print_branch (const sse_byte_t* p);
+static const sse_byte_t* __print_atom (const sse_byte_t* p);
struct __char_class_t
{
- const xp_char_t* name;
- xp_size_t name_len;
- xp_bool_t (*func) (xp_awk_t* awk, xp_char_t c);
+ const sse_char_t* name;
+ sse_size_t name_len;
+ sse_bool_t (*func) (sse_awk_t* awk, sse_char_t c);
};
static struct __char_class_t __char_class[] =
{
- { XP_T("alnum"), 5, __cc_isalnum },
- { XP_T("alpha"), 5, __cc_isalpha },
- { XP_T("blank"), 5, __cc_isblank },
- { XP_T("cntrl"), 5, __cc_iscntrl },
- { XP_T("digit"), 5, __cc_isdigit },
- { XP_T("graph"), 5, __cc_isgraph },
- { XP_T("lower"), 5, __cc_islower },
- { XP_T("print"), 5, __cc_isprint },
- { XP_T("punct"), 5, __cc_ispunct },
- { XP_T("space"), 5, __cc_isspace },
- { XP_T("upper"), 5, __cc_isupper },
- { XP_T("xdigit"), 6, __cc_isxdigit },
+ { SSE_T("alnum"), 5, __cc_isalnum },
+ { SSE_T("alpha"), 5, __cc_isalpha },
+ { SSE_T("blank"), 5, __cc_isblank },
+ { SSE_T("cntrl"), 5, __cc_iscntrl },
+ { SSE_T("digit"), 5, __cc_isdigit },
+ { SSE_T("graph"), 5, __cc_isgraph },
+ { SSE_T("lower"), 5, __cc_islower },
+ { SSE_T("print"), 5, __cc_isprint },
+ { SSE_T("punct"), 5, __cc_ispunct },
+ { SSE_T("space"), 5, __cc_isspace },
+ { SSE_T("upper"), 5, __cc_isupper },
+ { SSE_T("xdigit"), 6, __cc_isxdigit },
/*
- { XP_T("arabic"), 6, __cc_isarabic },
- { XP_T("chinese"), 7, __cc_ischinese },
- { XP_T("english"), 7, __cc_isenglish },
- { XP_T("japanese"), 8, __cc_isjapanese },
- { XP_T("korean"), 6, __cc_iskorean },
- { XP_T("thai"), 4, __cc_isthai },
+ { SSE_T("arabic"), 6, __cc_isarabic },
+ { SSE_T("chinese"), 7, __cc_ischinese },
+ { SSE_T("english"), 7, __cc_isenglish },
+ { SSE_T("japanese"), 8, __cc_isjapanese },
+ { SSE_T("korean"), 6, __cc_iskorean },
+ { SSE_T("thai"), 4, __cc_isthai },
*/
- { XP_NULL, 0, XP_NULL }
+ { SSE_NULL, 0, SSE_NULL }
};
-void* xp_awk_buildrex (
- xp_awk_t* awk, const xp_char_t* ptn, xp_size_t len, int* errnum)
+void* sse_awk_buildrex (
+ sse_awk_t* awk, const sse_char_t* ptn, sse_size_t len, int* errnum)
{
__builder_t builder;
builder.awk = awk;
builder.code.capa = DEF_CODE_CAPA;
builder.code.size = 0;
- builder.code.buf = (xp_byte_t*)
- XP_AWK_MALLOC (builder.awk, builder.code.capa);
- if (builder.code.buf == XP_NULL)
+ builder.code.buf = (sse_byte_t*)
+ SSE_AWK_MALLOC (builder.awk, builder.code.capa);
+ if (builder.code.buf == SSE_NULL)
{
- *errnum = XP_AWK_ENOMEM;
- return XP_NULL;
+ *errnum = SSE_AWK_ENOMEM;
+ return SSE_NULL;
}
builder.ptn.ptr = ptn;
@@ -283,7 +283,7 @@ void* xp_awk_buildrex (
builder.ptn.curp = builder.ptn.ptr;
builder.ptn.curc.type = CT_EOF;
- builder.ptn.curc.value = XP_T('\0');
+ builder.ptn.curc.value = SSE_T('\0');
/* TODO: implement the maximum depth
builder.depth.max = awk->max_depth; */
@@ -292,37 +292,37 @@ void* xp_awk_buildrex (
if (__next_char (&builder, LEVEL_TOP) == -1)
{
- if (errnum != XP_NULL) *errnum = builder.errnum;
- XP_AWK_FREE (builder.awk, builder.code.buf);
- return XP_NULL;
+ if (errnum != SSE_NULL) *errnum = builder.errnum;
+ SSE_AWK_FREE (builder.awk, builder.code.buf);
+ return SSE_NULL;
}
if (__build_pattern (&builder) == -1)
{
- if (errnum != XP_NULL) *errnum = builder.errnum;
- XP_AWK_FREE (builder.awk, builder.code.buf);
- return XP_NULL;
+ if (errnum != SSE_NULL) *errnum = builder.errnum;
+ SSE_AWK_FREE (builder.awk, builder.code.buf);
+ return SSE_NULL;
}
if (builder.ptn.curc.type != CT_EOF)
{
- if (errnum != XP_NULL) *errnum = XP_AWK_EREXGARBAGE;
- XP_AWK_FREE (builder.awk, builder.code.buf);
- return XP_NULL;
+ if (errnum != SSE_NULL) *errnum = SSE_AWK_EREXGARBAGE;
+ SSE_AWK_FREE (builder.awk, builder.code.buf);
+ return SSE_NULL;
}
return builder.code.buf;
}
-int xp_awk_matchrex (
- xp_awk_t* awk, void* code, int option,
- const xp_char_t* str, xp_size_t len,
- const xp_char_t** match_ptr, xp_size_t* match_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)
{
__matcher_t matcher;
__match_t mat;
- xp_size_t offset = 0;
- /*const xp_char_t* match_ptr_zero = XP_NULL;*/
+ sse_size_t offset = 0;
+ /*const sse_char_t* match_ptr_zero = SSE_NULL;*/
matcher.awk = awk;
@@ -334,17 +334,17 @@ int xp_awk_matchrex (
matcher.depth.max = awk->max_depth; */
matcher.depth.max = 0;
matcher.depth.cur = 0;
- matcher.ignorecase = (option & XP_AWK_REX_IGNORECASE)? 1: 0;
+ matcher.ignorecase = (option & SSE_AWK_REX_IGNORECASE)? 1: 0;
- mat.matched = xp_false;
+ mat.matched = sse_false;
/* TODO: should it allow an offset here??? */
mat.match_ptr = str + offset;
while (mat.match_ptr < matcher.match.str.end)
{
- if (__match_pattern (&matcher, code, &mat) == XP_NULL)
+ if (__match_pattern (&matcher, code, &mat) == SSE_NULL)
{
- if (errnum != XP_NULL) *errnum = matcher.errnum;
+ if (errnum != SSE_NULL) *errnum = matcher.errnum;
return -1;
}
@@ -353,17 +353,17 @@ int xp_awk_matchrex (
/*
if (mat.match_len == 0)
{
- if (match_ptr_zero == XP_NULL)
+ if (match_ptr_zero == SSE_NULL)
match_ptr_zero = mat.match_ptr;
mat.match_ptr++;
continue;
}
*/
- if (match_ptr != XP_NULL) *match_ptr = mat.match_ptr;
- if (match_len != XP_NULL) *match_len = mat.match_len;
+ if (match_ptr != SSE_NULL) *match_ptr = mat.match_ptr;
+ if (match_len != SSE_NULL) *match_len = mat.match_len;
- /*match_ptr_zero = XP_NULL;*/
+ /*match_ptr_zero = SSE_NULL;*/
break;
}
@@ -371,10 +371,10 @@ int xp_awk_matchrex (
}
/*
- if (match_ptr_zero != XP_NULL)
+ if (match_ptr_zero != SSE_NULL)
{
- if (match_ptr != XP_NULL) *match_ptr = match_ptr_zero;
- if (match_len != XP_NULL) *match_len = 0;
+ if (match_ptr != SSE_NULL) *match_ptr = match_ptr_zero;
+ if (match_len != SSE_NULL) *match_len = 0;
return 1;
}
*/
@@ -382,28 +382,28 @@ int xp_awk_matchrex (
return (mat.matched)? 1: 0;
}
-void xp_awk_freerex (xp_awk_t* awk, void* code)
+void sse_awk_freerex (sse_awk_t* awk, void* code)
{
- xp_awk_assert (awk, code != XP_NULL);
- XP_AWK_FREE (awk, code);
+ sse_awk_assert (awk, code != SSE_NULL);
+ SSE_AWK_FREE (awk, code);
}
-xp_bool_t xp_awk_isemptyrex (xp_awk_t* awk, void* code)
+sse_bool_t sse_awk_isemptyrex (sse_awk_t* awk, void* code)
{
- const xp_byte_t* p = code;
- xp_size_t nb, el;
+ const sse_byte_t* p = code;
+ sse_size_t nb, el;
- xp_awk_assert (awk, p != XP_NULL);
+ sse_awk_assert (awk, p != SSE_NULL);
- nb = *(xp_size_t*)p; p += xp_sizeof(nb);
- el = *(xp_size_t*)p; p += xp_sizeof(el);
+ nb = *(sse_size_t*)p; p += sse_sizeof(nb);
+ el = *(sse_size_t*)p; p += sse_sizeof(el);
- /* an empty regular expression look like:
- * | expression |
+ /* an empty regular esseression look like:
+ * | esseression |
* | header | branch |
* | | branch header |
* | NB(1) | EL(16) | NA(1) | BL(8) | */
- return (nb == 1 && el == xp_sizeof(xp_size_t)*4)? xp_true: xp_false;
+ return (nb == 1 && el == sse_sizeof(sse_size_t)*4)? sse_true: sse_false;
}
static int __build_pattern (__builder_t* builder)
@@ -412,7 +412,7 @@ static int __build_pattern (__builder_t* builder)
if (builder->depth.max > 0 && builder->depth.cur >= builder->depth.max)
{
- builder->errnum = XP_AWK_ERECURSION;
+ builder->errnum = SSE_AWK_ERECURSION;
return -1;
}
@@ -425,9 +425,9 @@ static int __build_pattern (__builder_t* builder)
static int __build_pattern0 (__builder_t* builder)
{
- xp_size_t zero = 0;
- xp_size_t old_size;
- xp_size_t pos_nb, pos_el;
+ sse_size_t zero = 0;
+ sse_size_t old_size;
+ sse_size_t pos_nb, pos_el;
int n;
@@ -435,10 +435,10 @@ static int __build_pattern0 (__builder_t* builder)
/* secure space for header and set the header fields to zero */
pos_nb = builder->code.size;
- ADD_CODE (builder, &zero, xp_sizeof(zero));
+ ADD_CODE (builder, &zero, sse_sizeof(zero));
pos_el = builder->code.size;
- ADD_CODE (builder, &zero, xp_sizeof(zero));
+ ADD_CODE (builder, &zero, sse_sizeof(zero));
/* handle the first branch */
n = __build_branch (builder);
@@ -449,13 +449,13 @@ static int __build_pattern0 (__builder_t* builder)
return 0;
}
- /*CODEAT(builder,pos_nb,xp_size_t) += 1;*/
- SET_CODE (builder, pos_nb, xp_size_t,
- GET_CODE (builder, pos_nb, xp_size_t) + 1);
+ /*CODEAT(builder,pos_nb,sse_size_t) += 1;*/
+ SET_CODE (builder, pos_nb, sse_size_t,
+ GET_CODE (builder, pos_nb, sse_size_t) + 1);
/* handle subsequent branches if any */
while (builder->ptn.curc.type == CT_SPECIAL &&
- builder->ptn.curc.value == XP_T('|'))
+ builder->ptn.curc.value == SSE_T('|'))
{
NEXT_CHAR (builder, LEVEL_TOP);
@@ -469,31 +469,31 @@ static int __build_pattern0 (__builder_t* builder)
break;
}
- /*CODEAT(builder,pos_nb,xp_size_t) += 1;*/
- SET_CODE (builder, pos_nb, xp_size_t,
- GET_CODE (builder, pos_nb, xp_size_t) + 1);
+ /*CODEAT(builder,pos_nb,sse_size_t) += 1;*/
+ SET_CODE (builder, pos_nb, sse_size_t,
+ GET_CODE (builder, pos_nb, sse_size_t) + 1);
}
- /*CODEAT(builder,pos_el,xp_size_t) = builder->code.size - old_size;*/
- SET_CODE (builder, pos_el, xp_size_t, builder->code.size - old_size);
+ /*CODEAT(builder,pos_el,sse_size_t) = builder->code.size - old_size;*/
+ SET_CODE (builder, pos_el, sse_size_t, builder->code.size - old_size);
return 1;
}
static int __build_branch (__builder_t* builder)
{
int n;
- xp_size_t zero = 0;
- xp_size_t old_size;
- xp_size_t pos_na, pos_bl;
+ sse_size_t zero = 0;
+ sse_size_t old_size;
+ sse_size_t pos_na, pos_bl;
struct __code_t* cmd;
old_size = builder->code.size;
pos_na = builder->code.size;
- ADD_CODE (builder, &zero, xp_sizeof(zero));
+ ADD_CODE (builder, &zero, sse_sizeof(zero));
pos_bl = builder->code.size;
- ADD_CODE (builder, &zero, xp_sizeof(zero));
+ ADD_CODE (builder, &zero, sse_sizeof(zero));
while (1)
{
@@ -518,13 +518,13 @@ static int __build_branch (__builder_t* builder)
/* n == 0 no bound character. just continue */
/* n == 1 bound has been applied by build_occurrences */
- /*CODEAT(builder,pos_na,xp_size_t) += 1;*/
- SET_CODE (builder, pos_na, xp_size_t,
- GET_CODE (builder, pos_na, xp_size_t) + 1);
+ /*CODEAT(builder,pos_na,sse_size_t) += 1;*/
+ SET_CODE (builder, pos_na, sse_size_t,
+ GET_CODE (builder, pos_na, sse_size_t) + 1);
}
- /*CODEAT(builder,pos_bl,xp_size_t) = builder->code.size - old_size;*/
- SET_CODE (builder, pos_bl, xp_size_t, builder->code.size - old_size);
+ /*CODEAT(builder,pos_bl,sse_size_t) = builder->code.size - old_size;*/
+ SET_CODE (builder, pos_bl, sse_size_t, builder->code.size - old_size);
return (builder->code.size == old_size)? 0: 1;
}
@@ -537,13 +537,13 @@ static int __build_atom (__builder_t* builder)
if (builder->ptn.curc.type == CT_SPECIAL)
{
- if (builder->ptn.curc.value == XP_T('('))
+ if (builder->ptn.curc.value == SSE_T('('))
{
tmp.cmd = CMD_GROUP;
tmp.negate = 0;
tmp.lbound = 1;
tmp.ubound = 1;
- ADD_CODE (builder, &tmp, xp_sizeof(tmp));
+ ADD_CODE (builder, &tmp, sse_sizeof(tmp));
NEXT_CHAR (builder, LEVEL_TOP);
@@ -551,37 +551,37 @@ static int __build_atom (__builder_t* builder)
if (n == -1) return -1;
if (builder->ptn.curc.type != CT_SPECIAL ||
- builder->ptn.curc.value != XP_T(')'))
+ builder->ptn.curc.value != SSE_T(')'))
{
- builder->errnum = XP_AWK_EREXRPAREN;
+ builder->errnum = SSE_AWK_EREXRPAREN;
return -1;
}
}
- else if (builder->ptn.curc.value == XP_T('^'))
+ else if (builder->ptn.curc.value == SSE_T('^'))
{
tmp.cmd = CMD_BOL;
tmp.negate = 0;
tmp.lbound = 1;
tmp.ubound = 1;
- ADD_CODE (builder, &tmp, xp_sizeof(tmp));
+ ADD_CODE (builder, &tmp, sse_sizeof(tmp));
}
- else if (builder->ptn.curc.value == XP_T('$'))
+ else if (builder->ptn.curc.value == SSE_T('$'))
{
tmp.cmd = CMD_EOL;
tmp.negate = 0;
tmp.lbound = 1;
tmp.ubound = 1;
- ADD_CODE (builder, &tmp, xp_sizeof(tmp));
+ ADD_CODE (builder, &tmp, sse_sizeof(tmp));
}
- else if (builder->ptn.curc.value == XP_T('.'))
+ else if (builder->ptn.curc.value == SSE_T('.'))
{
tmp.cmd = CMD_ANY_CHAR;
tmp.negate = 0;
tmp.lbound = 1;
tmp.ubound = 1;
- ADD_CODE (builder, &tmp, xp_sizeof(tmp));
+ ADD_CODE (builder, &tmp, sse_sizeof(tmp));
}
- else if (builder->ptn.curc.value == XP_T('['))
+ else if (builder->ptn.curc.value == SSE_T('['))
{
struct __code_t* cmd;
@@ -591,19 +591,19 @@ static int __build_atom (__builder_t* builder)
tmp.negate = 0;
tmp.lbound = 1;
tmp.ubound = 1;
- ADD_CODE (builder, &tmp, xp_sizeof(tmp));
+ ADD_CODE (builder, &tmp, sse_sizeof(tmp));
NEXT_CHAR (builder, LEVEL_CHARSET);
n = __build_charset (builder, cmd);
if (n == -1) return -1;
- xp_awk_assert (builder->awk, n != 0);
+ sse_awk_assert (builder->awk, n != 0);
if (builder->ptn.curc.type != CT_SPECIAL ||
- builder->ptn.curc.value != XP_T(']'))
+ builder->ptn.curc.value != SSE_T(']'))
{
- builder->errnum = XP_AWK_EREXRBRACKET;
+ builder->errnum = SSE_AWK_EREXRBRACKET;
return -1;
}
@@ -615,15 +615,15 @@ static int __build_atom (__builder_t* builder)
}
else
{
- xp_awk_assert (builder->awk, builder->ptn.curc.type == CT_NORMAL);
+ sse_awk_assert (builder->awk, builder->ptn.curc.type == CT_NORMAL);
tmp.cmd = CMD_ORD_CHAR;
tmp.negate = 0;
tmp.lbound = 1;
tmp.ubound = 1;
- ADD_CODE (builder, &tmp, xp_sizeof(tmp));
+ ADD_CODE (builder, &tmp, sse_sizeof(tmp));
- ADD_CODE (builder, &builder->ptn.curc.value, xp_sizeof(builder->ptn.curc.value));
+ ADD_CODE (builder, &builder->ptn.curc.value, sse_sizeof(builder->ptn.curc.value));
NEXT_CHAR (builder, LEVEL_TOP);
return 1;
@@ -632,20 +632,20 @@ static int __build_atom (__builder_t* builder)
static int __build_charset (__builder_t* builder, struct __code_t* cmd)
{
- xp_size_t zero = 0;
- xp_size_t old_size;
- xp_size_t pos_csc, pos_csl;
+ sse_size_t zero = 0;
+ sse_size_t old_size;
+ sse_size_t pos_csc, pos_csl;
old_size = builder->code.size;
pos_csc = builder->code.size;
- ADD_CODE (builder, &zero, xp_sizeof(zero));
+ ADD_CODE (builder, &zero, sse_sizeof(zero));
pos_csl = builder->code.size;
- ADD_CODE (builder, &zero, xp_sizeof(zero));
+ ADD_CODE (builder, &zero, sse_sizeof(zero));
if (builder->ptn.curc.type == CT_NORMAL &&
- builder->ptn.curc.value == XP_T('^'))
+ builder->ptn.curc.value == SSE_T('^'))
{
cmd->negate = 1;
NEXT_CHAR (builder, LEVEL_CHARSET);
@@ -653,15 +653,15 @@ static int __build_charset (__builder_t* builder, struct __code_t* cmd)
while (builder->ptn.curc.type == CT_NORMAL)
{
- xp_char_t c0, c1, c2;
+ sse_char_t c0, c1, c2;
int cc = 0;
c1 = builder->ptn.curc.value;
NEXT_CHAR(builder, LEVEL_CHARSET);
- if (c1 == XP_T('[') &&
+ if (c1 == SSE_T('[') &&
builder->ptn.curc.type == CT_NORMAL &&
- builder->ptn.curc.value == XP_T(':'))
+ builder->ptn.curc.value == SSE_T(':'))
{
if (__build_cclass (builder, &c1) == -1) return -1;
cc = cc | 1;
@@ -669,7 +669,7 @@ static int __build_charset (__builder_t* builder, struct __code_t* cmd)
c2 = c1;
if (builder->ptn.curc.type == CT_NORMAL &&
- builder->ptn.curc.value == XP_T('-'))
+ builder->ptn.curc.value == SSE_T('-'))
{
NEXT_CHAR (builder, LEVEL_CHARSET);
@@ -678,9 +678,9 @@ static int __build_charset (__builder_t* builder, struct __code_t* cmd)
c2 = builder->ptn.curc.value;
NEXT_CHAR (builder, LEVEL_CHARSET);
- if (c2 == XP_T('[') &&
+ if (c2 == SSE_T('[') &&
builder->ptn.curc.type == CT_NORMAL &&
- builder->ptn.curc.value == XP_T(':'))
+ builder->ptn.curc.value == SSE_T(':'))
{
if (__build_cclass (builder, &c2) == -1)
{
@@ -699,62 +699,62 @@ static int __build_charset (__builder_t* builder, struct __code_t* cmd)
if (c1 == c2)
{
c0 = CHARSET_ONE;
- ADD_CODE (builder, &c0, xp_sizeof(c0));
- ADD_CODE (builder, &c1, xp_sizeof(c1));
+ ADD_CODE (builder, &c0, sse_sizeof(c0));
+ ADD_CODE (builder, &c1, sse_sizeof(c1));
}
else
{
c0 = CHARSET_RANGE;
- ADD_CODE (builder, &c0, xp_sizeof(c0));
- ADD_CODE (builder, &c1, xp_sizeof(c1));
- ADD_CODE (builder, &c2, xp_sizeof(c2));
+ ADD_CODE (builder, &c0, sse_sizeof(c0));
+ ADD_CODE (builder, &c1, sse_sizeof(c1));
+ ADD_CODE (builder, &c2, sse_sizeof(c2));
}
}
else if (cc == 1)
{
c0 = CHARSET_CLASS;
- ADD_CODE (builder, &c0, xp_sizeof(c0));
- ADD_CODE (builder, &c1, xp_sizeof(c1));
+ ADD_CODE (builder, &c0, sse_sizeof(c0));
+ ADD_CODE (builder, &c1, sse_sizeof(c1));
}
else
{
/* invalid range */
#ifdef DEBUG_REX
-xp_printf (XP_T("__build_charset: invalid character set range\n"));
+sse_printf (SSE_T("__build_charset: invalid character set range\n"));
#endif
- builder->errnum = XP_AWK_EREXCRANGE;
+ builder->errnum = SSE_AWK_EREXCRANGE;
return -1;
}
- /*CODEAT(builder,pos_csc,xp_size_t) += 1;*/
- SET_CODE (builder, pos_csc, xp_size_t,
- GET_CODE (builder, pos_csc, xp_size_t) + 1);
+ /*CODEAT(builder,pos_csc,sse_size_t) += 1;*/
+ SET_CODE (builder, pos_csc, sse_size_t,
+ GET_CODE (builder, pos_csc, sse_size_t) + 1);
}
- /*CODEAT(builder,pos_csl,xp_size_t) = builder->code.size - old_size;*/
- SET_CODE (builder, pos_csl, xp_size_t, builder->code.size - old_size);
+ /*CODEAT(builder,pos_csl,sse_size_t) = builder->code.size - old_size;*/
+ SET_CODE (builder, pos_csl, sse_size_t, builder->code.size - old_size);
return 1;
}
-static int __build_cclass (__builder_t* builder, xp_char_t* cc)
+static int __build_cclass (__builder_t* builder, sse_char_t* cc)
{
const struct __char_class_t* ccp = __char_class;
- xp_size_t len = builder->ptn.end - builder->ptn.curp;
+ sse_size_t len = builder->ptn.end - builder->ptn.curp;
- while (ccp->name != XP_NULL)
+ while (ccp->name != SSE_NULL)
{
if (__begin_with (builder->ptn.curp, len, ccp->name)) break;
ccp++;
}
- if (ccp->name == XP_NULL)
+ if (ccp->name == SSE_NULL)
{
/* wrong class name */
#ifdef DEBUG_REX
-xp_printf (XP_T("__build_cclass: wrong class name\n"));*/
+sse_printf (SSE_T("__build_cclass: wrong class name\n"));*/
#endif
- builder->errnum = XP_AWK_EREXCCLASS;
+ builder->errnum = SSE_AWK_EREXCCLASS;
return -1;
}
@@ -762,12 +762,12 @@ xp_printf (XP_T("__build_cclass: wrong class name\n"));*/
NEXT_CHAR (builder, LEVEL_CHARSET);
if (builder->ptn.curc.type != CT_NORMAL ||
- builder->ptn.curc.value != XP_T(':'))
+ builder->ptn.curc.value != SSE_T(':'))
{
#ifdef BUILD_REX
-xp_printf (XP_T("__build_cclass: a colon(:) expected\n"));
+sse_printf (SSE_T("__build_cclass: a colon(:) esseected\n"));
#endif
- builder->errnum = XP_AWK_EREXCOLON;
+ builder->errnum = SSE_AWK_EREXCOLON;
return -1;
}
@@ -775,18 +775,18 @@ xp_printf (XP_T("__build_cclass: a colon(:) expected\n"));
/* ] happens to be the charset ender ] */
if (builder->ptn.curc.type != CT_SPECIAL ||
- builder->ptn.curc.value != XP_T(']'))
+ builder->ptn.curc.value != SSE_T(']'))
{
#ifdef DEBUG_REX
-xp_printf (XP_T("__build_cclass: ] expected\n"));
+sse_printf (SSE_T("__build_cclass: ] esseected\n"));
#endif
- builder->errnum = XP_AWK_EREXRBRACKET;
+ builder->errnum = SSE_AWK_EREXRBRACKET;
return -1;
}
NEXT_CHAR (builder, LEVEL_CHARSET);
- *cc = (xp_char_t)(ccp - __char_class);
+ *cc = (sse_char_t)(ccp - __char_class);
return 1;
}
@@ -796,7 +796,7 @@ static int __build_occurrences (__builder_t* builder, struct __code_t* cmd)
switch (builder->ptn.curc.value)
{
- case XP_T('+'):
+ case SSE_T('+'):
{
cmd->lbound = 1;
cmd->ubound = BOUND_MAX;
@@ -804,7 +804,7 @@ static int __build_occurrences (__builder_t* builder, struct __code_t* cmd)
return 1;
}
- case XP_T('*'):
+ case SSE_T('*'):
{
cmd->lbound = 0;
cmd->ubound = BOUND_MAX;
@@ -812,7 +812,7 @@ static int __build_occurrences (__builder_t* builder, struct __code_t* cmd)
return 1;
}
- case XP_T('?'):
+ case SSE_T('?'):
{
cmd->lbound = 0;
cmd->ubound = 1;
@@ -820,16 +820,16 @@ static int __build_occurrences (__builder_t* builder, struct __code_t* cmd)
return 1;
}
- case XP_T('{'):
+ case SSE_T('{'):
{
NEXT_CHAR (builder, LEVEL_RANGE);
if (__build_range(builder, cmd) == -1) return -1;
if (builder->ptn.curc.type != CT_SPECIAL ||
- builder->ptn.curc.value != XP_T('}'))
+ builder->ptn.curc.value != SSE_T('}'))
{
- builder->errnum = XP_AWK_EREXRBRACE;
+ builder->errnum = SSE_AWK_EREXRBRACE;
return -1;
}
@@ -843,32 +843,32 @@ static int __build_occurrences (__builder_t* builder, struct __code_t* cmd)
static int __build_range (__builder_t* builder, struct __code_t* cmd)
{
- xp_size_t bound;
+ sse_size_t bound;
/* TODO: should allow white spaces in the range???
what if it is not in the raight format? convert it to ordinary characters?? */
bound = 0;
while (builder->ptn.curc.type == CT_NORMAL &&
- (builder->ptn.curc.value >= XP_T('0') &&
- builder->ptn.curc.value <= XP_T('9')))
+ (builder->ptn.curc.value >= SSE_T('0') &&
+ builder->ptn.curc.value <= SSE_T('9')))
{
- bound = bound * 10 + builder->ptn.curc.value - XP_T('0');
+ bound = bound * 10 + builder->ptn.curc.value - SSE_T('0');
NEXT_CHAR (builder, LEVEL_RANGE);
}
cmd->lbound = bound;
if (builder->ptn.curc.type == CT_SPECIAL &&
- builder->ptn.curc.value == XP_T(','))
+ builder->ptn.curc.value == SSE_T(','))
{
NEXT_CHAR (builder, LEVEL_RANGE);
bound = 0;
while (builder->ptn.curc.type == CT_NORMAL &&
- (builder->ptn.curc.value >= XP_T('0') &&
- builder->ptn.curc.value <= XP_T('9')))
+ (builder->ptn.curc.value >= SSE_T('0') &&
+ builder->ptn.curc.value <= SSE_T('9')))
{
- bound = bound * 10 + builder->ptn.curc.value - XP_T('0');
+ bound = bound * 10 + builder->ptn.curc.value - SSE_T('0');
NEXT_CHAR (builder, LEVEL_RANGE);
}
@@ -879,7 +879,7 @@ what if it is not in the raight format? convert it to ordinary characters?? */
if (cmd->lbound > cmd->ubound)
{
/* invalid occurrences range */
- builder->errnum = XP_AWK_EREXBRANGE;
+ builder->errnum = SSE_AWK_EREXBRANGE;
return -1;
}
@@ -891,18 +891,18 @@ static int __next_char (__builder_t* builder, int level)
if (builder->ptn.curp >= builder->ptn.end)
{
builder->ptn.curc.type = CT_EOF;
- builder->ptn.curc.value = XP_T('\0');
+ builder->ptn.curc.value = SSE_T('\0');
return 0;
}
builder->ptn.curc.type = CT_NORMAL;
builder->ptn.curc.value = *builder->ptn.curp++;
- if (builder->ptn.curc.value == XP_T('\\'))
+ if (builder->ptn.curc.value == SSE_T('\\'))
{
if (builder->ptn.curp >= builder->ptn.end)
{
- builder->errnum = XP_AWK_EREXEND;
+ builder->errnum = SSE_AWK_EREXEND;
return -1;
}
@@ -913,32 +913,32 @@ static int __next_char (__builder_t* builder, int level)
{
if (level == LEVEL_TOP)
{
- if (builder->ptn.curc.value == XP_T('[') ||
- builder->ptn.curc.value == XP_T('|') ||
- builder->ptn.curc.value == XP_T('^') ||
- builder->ptn.curc.value == XP_T('$') ||
- builder->ptn.curc.value == XP_T('{') ||
- builder->ptn.curc.value == XP_T('+') ||
- builder->ptn.curc.value == XP_T('?') ||
- builder->ptn.curc.value == XP_T('*') ||
- builder->ptn.curc.value == XP_T('.') ||
- builder->ptn.curc.value == XP_T('(') ||
- builder->ptn.curc.value == XP_T(')'))
+ if (builder->ptn.curc.value == SSE_T('[') ||
+ builder->ptn.curc.value == SSE_T('|') ||
+ builder->ptn.curc.value == SSE_T('^') ||
+ builder->ptn.curc.value == SSE_T('$') ||
+ builder->ptn.curc.value == SSE_T('{') ||
+ builder->ptn.curc.value == SSE_T('+') ||
+ builder->ptn.curc.value == SSE_T('?') ||
+ builder->ptn.curc.value == SSE_T('*') ||
+ builder->ptn.curc.value == SSE_T('.') ||
+ builder->ptn.curc.value == SSE_T('(') ||
+ builder->ptn.curc.value == SSE_T(')'))
{
builder->ptn.curc.type = CT_SPECIAL;
}
}
else if (level == LEVEL_CHARSET)
{
- if (builder->ptn.curc.value == XP_T(']'))
+ if (builder->ptn.curc.value == SSE_T(']'))
{
builder->ptn.curc.type = CT_SPECIAL;
}
}
else if (level == LEVEL_RANGE)
{
- if (builder->ptn.curc.value == XP_T(',') ||
- builder->ptn.curc.value == XP_T('}'))
+ if (builder->ptn.curc.value == SSE_T(',') ||
+ builder->ptn.curc.value == SSE_T('}'))
{
builder->ptn.curc.type = CT_SPECIAL;
}
@@ -948,40 +948,40 @@ static int __next_char (__builder_t* builder, int level)
return 0;
}
-static int __add_code (__builder_t* builder, void* data, xp_size_t len)
+static int __add_code (__builder_t* builder, void* data, sse_size_t len)
{
if (len > builder->code.capa - builder->code.size)
{
- xp_size_t capa = builder->code.capa * 2;
- xp_byte_t* tmp;
+ sse_size_t capa = builder->code.capa * 2;
+ sse_byte_t* tmp;
if (capa == 0) capa = DEF_CODE_CAPA;
while (len > capa - builder->code.size) { capa = capa * 2; }
- if (builder->awk->syscas.realloc != XP_NULL)
+ if (builder->awk->syscas.realloc != SSE_NULL)
{
- tmp = (xp_byte_t*) XP_AWK_REALLOC (
+ tmp = (sse_byte_t*) SSE_AWK_REALLOC (
builder->awk, builder->code.buf, capa);
- if (tmp == XP_NULL)
+ if (tmp == SSE_NULL)
{
- builder->errnum = XP_AWK_ENOMEM;
+ builder->errnum = SSE_AWK_ENOMEM;
return -1;
}
}
else
{
- tmp = (xp_byte_t*) XP_AWK_MALLOC (builder->awk, capa);
- if (tmp == XP_NULL)
+ tmp = (sse_byte_t*) SSE_AWK_MALLOC (builder->awk, capa);
+ if (tmp == SSE_NULL)
{
- builder->errnum = XP_AWK_ENOMEM;
+ builder->errnum = SSE_AWK_ENOMEM;
return -1;
}
- if (builder->code.buf != XP_NULL)
+ if (builder->code.buf != SSE_NULL)
{
- XP_AWK_MEMCPY (builder->awk, tmp,
+ SSE_AWK_MEMCPY (builder->awk, tmp,
builder->code.buf, builder->code.capa);
- XP_AWK_FREE (builder->awk, builder->code.buf);
+ SSE_AWK_FREE (builder->awk, builder->code.buf);
}
}
@@ -989,45 +989,45 @@ static int __add_code (__builder_t* builder, void* data, xp_size_t len)
builder->code.capa = capa;
}
- XP_AWK_MEMCPY (builder->awk,
+ SSE_AWK_MEMCPY (builder->awk,
&builder->code.buf[builder->code.size], data, len);
builder->code.size += len;
return 0;
}
-static xp_bool_t __begin_with (
- const xp_char_t* str, xp_size_t len, const xp_char_t* what)
+static sse_bool_t __begin_with (
+ const sse_char_t* str, sse_size_t len, const sse_char_t* what)
{
- const xp_char_t* end = str + len;
+ const sse_char_t* end = str + len;
while (str < end)
{
- if (*what == XP_T('\0')) return xp_true;
- if (*what != *str) return xp_false;
+ if (*what == SSE_T('\0')) return sse_true;
+ if (*what != *str) return sse_false;
str++; what++;
}
- if (*what == XP_T('\0')) return xp_true;
- return xp_false;
+ if (*what == SSE_T('\0')) return sse_true;
+ return sse_false;
}
-static const xp_byte_t* __match_pattern (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat)
+static const sse_byte_t* __match_pattern (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
{
- const xp_byte_t* p;
+ const sse_byte_t* p;
__match_t mat2;
- xp_size_t nb, el, i;
+ sse_size_t nb, el, i;
p = base;
- nb = *(xp_size_t*)p; p += xp_sizeof(nb);
- el = *(xp_size_t*)p; p += xp_sizeof(el);
+ nb = *(sse_size_t*)p; p += sse_sizeof(nb);
+ el = *(sse_size_t*)p; p += sse_sizeof(el);
#ifdef BUILD_REX
-xp_printf (XP_T("__match_pattern: NB = %u, EL = %u\n"), (unsigned)nb, (unsigned)el);
+sse_printf (SSE_T("__match_pattern: NB = %u, EL = %u\n"), (unsigned)nb, (unsigned)el);
#endif
- mat->matched = xp_false;
+ mat->matched = sse_false;
mat->match_len = 0;
for (i = 0; i < nb; i++)
@@ -1035,11 +1035,11 @@ xp_printf (XP_T("__match_pattern: NB = %u, EL = %u\n"), (unsigned)nb, (unsigned)
mat2.match_ptr = mat->match_ptr;
p = __match_branch (matcher, p, &mat2);
- if (p == XP_NULL) return XP_NULL;
+ if (p == SSE_NULL) return SSE_NULL;
if (mat2.matched)
{
- mat->matched = xp_true;
+ mat->matched = sse_true;
mat->match_len = mat2.match_len;
break;
}
@@ -1048,32 +1048,32 @@ xp_printf (XP_T("__match_pattern: NB = %u, EL = %u\n"), (unsigned)nb, (unsigned)
return base + el;
}
-static const xp_byte_t* __match_branch (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat)
+static const sse_byte_t* __match_branch (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
{
/*
* branch body (base+sizeof(NA)+sizeof(BL)---+
* BL=base+sizeof(NA) ---------+ |
* base=NA ------+ | |
* | | |
- * |NA(xp_size_t)|BL(xp_size_t)|ATOMS.........|
+ * |NA(sse_size_t)|BL(sse_size_t)|ATOMS.........|
*/
mat->branch = base;
- mat->branch_end = base + *((xp_size_t*)(base+xp_sizeof(xp_size_t)));
+ mat->branch_end = base + *((sse_size_t*)(base+sse_sizeof(sse_size_t)));
return __match_branch_body (
- matcher, base+xp_sizeof(xp_size_t)*2, mat);
+ matcher, base+sse_sizeof(sse_size_t)*2, mat);
}
-static const xp_byte_t* __match_branch_body (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat)
+static const sse_byte_t* __match_branch_body (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
{
- const xp_byte_t* n;
+ const sse_byte_t* n;
if (matcher->depth.max > 0 && matcher->depth.cur >= matcher->depth.max)
{
- matcher->errnum = XP_AWK_ERECURSION;
- return XP_NULL;
+ matcher->errnum = SSE_AWK_ERECURSION;
+ return SSE_NULL;
}
matcher->depth.cur++;
@@ -1083,14 +1083,14 @@ static const xp_byte_t* __match_branch_body (
return n;
}
-static const xp_byte_t* __match_branch_body0 (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat)
+static const sse_byte_t* __match_branch_body0 (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
{
- const xp_byte_t* p;
+ const sse_byte_t* p;
/* __match_t mat2;*/
- xp_size_t match_len = 0;
+ sse_size_t match_len = 0;
- mat->matched = xp_false;
+ mat->matched = sse_false;
mat->match_len = 0;
/* TODO: is mat2 necessary here ? */
@@ -1105,7 +1105,7 @@ static const xp_byte_t* __match_branch_body0 (
while (p < mat->branch_end)
{
p = __match_atom (matcher, p, mat);
- if (p == XP_NULL) return XP_NULL;
+ if (p == SSE_NULL) return SSE_NULL;
if (!mat->matched) break;
@@ -1113,15 +1113,15 @@ static const xp_byte_t* __match_branch_body0 (
match_len += mat->match_len;
#if 0
p = __match_atom (matcher, p, &mat2);
- if (p == XP_NULL) return XP_NULL;
+ if (p == SSE_NULL) return SSE_NULL;
if (!mat2.matched)
{
- mat->matched = xp_false;
+ mat->matched = sse_false;
break; /* stop matching */
}
- mat->matched = xp_true;
+ mat->matched = sse_true;
mat->match_len += mat2.match_len;
mat2.match_ptr = &mat2.match_ptr[mat2.match_len];
@@ -1132,8 +1132,8 @@ static const xp_byte_t* __match_branch_body0 (
return mat->branch_end;
}
-static const xp_byte_t* __match_atom (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat)
+static const sse_byte_t* __match_atom (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
{
static atom_matcher_t matchers[] =
{
@@ -1145,21 +1145,21 @@ static const xp_byte_t* __match_atom (
__match_group
};
- xp_awk_assert (matcher->awk,
+ sse_awk_assert (matcher->awk,
((struct __code_t*)base)->cmd >= 0 &&
- ((struct __code_t*)base)->cmd < xp_countof(matchers));
+ ((struct __code_t*)base)->cmd < sse_countof(matchers));
return matchers[((struct __code_t*)base)->cmd] (matcher, base, mat);
}
-static const xp_byte_t* __match_bol (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat)
+static const sse_byte_t* __match_bol (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
{
- const xp_byte_t* p = base;
+ const sse_byte_t* p = base;
const struct __code_t* cp;
- cp = (const struct __code_t*)p; p += xp_sizeof(*cp);
- xp_awk_assert (matcher->awk, cp->cmd == CMD_BOL);
+ cp = (const struct __code_t*)p; p += sse_sizeof(*cp);
+ sse_awk_assert (matcher->awk, cp->cmd == CMD_BOL);
mat->matched = (mat->match_ptr == matcher->match.str.ptr ||
(cp->lbound == cp->ubound && cp->lbound == 0));
@@ -1168,14 +1168,14 @@ static const xp_byte_t* __match_bol (
return p;
}
-static const xp_byte_t* __match_eol (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat)
+static const sse_byte_t* __match_eol (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
{
- const xp_byte_t* p = base;
+ const sse_byte_t* p = base;
const struct __code_t* cp;
- cp = (const struct __code_t*)p; p += xp_sizeof(*cp);
- xp_awk_assert (matcher->awk, cp->cmd == CMD_EOL);
+ cp = (const struct __code_t*)p; p += sse_sizeof(*cp);
+ sse_awk_assert (matcher->awk, cp->cmd == CMD_EOL);
mat->matched = (mat->match_ptr == matcher->match.str.end ||
(cp->lbound == cp->ubound && cp->lbound == 0));
@@ -1184,20 +1184,20 @@ static const xp_byte_t* __match_eol (
return p;
}
-static const xp_byte_t* __match_any_char (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat)
+static const sse_byte_t* __match_any_char (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
{
- const xp_byte_t* p = base;
+ const sse_byte_t* p = base;
const struct __code_t* cp;
- xp_size_t si = 0, lbound, ubound;
+ sse_size_t si = 0, lbound, ubound;
- cp = (const struct __code_t*)p; p += xp_sizeof(*cp);
- xp_awk_assert (matcher->awk, cp->cmd == CMD_ANY_CHAR);
+ cp = (const struct __code_t*)p; p += sse_sizeof(*cp);
+ sse_awk_assert (matcher->awk, cp->cmd == CMD_ANY_CHAR);
lbound = cp->lbound;
ubound = cp->ubound;
- mat->matched = xp_false;
+ mat->matched = sse_false;
mat->match_len = 0;
/* merge the same consecutive codes */
@@ -1207,11 +1207,11 @@ static const xp_byte_t* __match_any_char (
lbound += ((const struct __code_t*)p)->lbound;
ubound += ((const struct __code_t*)p)->ubound;
- p += xp_sizeof(*cp);
+ p += sse_sizeof(*cp);
}
#ifdef BUILD_REX
-xp_printf (XP_T("__match_any_char: lbound = %u, ubound = %u\n"),
+sse_printf (SSE_T("__match_any_char: lbound = %u, ubound = %u\n"),
(unsigned int)lbound, (unsigned int)ubound);
#endif
@@ -1223,7 +1223,7 @@ xp_printf (XP_T("__match_any_char: lbound = %u, ubound = %u\n"),
}
#ifdef BUILD_REX
-xp_printf (XP_T("__match_any_char: max si = %d\n"), si);
+sse_printf (SSE_T("__match_any_char: max si = %d\n"), si);
#endif
if (si >= lbound && si <= ubound)
{
@@ -1233,22 +1233,22 @@ xp_printf (XP_T("__match_any_char: max si = %d\n"), si);
return p;
}
-static const xp_byte_t* __match_ord_char (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat)
+static const sse_byte_t* __match_ord_char (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
{
- const xp_byte_t* p = base;
+ const sse_byte_t* p = base;
const struct __code_t* cp;
- xp_size_t si = 0, lbound, ubound;
- xp_char_t cc;
+ sse_size_t si = 0, lbound, ubound;
+ sse_char_t cc;
- cp = (const struct __code_t*)p; p += xp_sizeof(*cp);
- xp_awk_assert (matcher->awk, cp->cmd == CMD_ORD_CHAR);
+ cp = (const struct __code_t*)p; p += sse_sizeof(*cp);
+ sse_awk_assert (matcher->awk, cp->cmd == CMD_ORD_CHAR);
lbound = cp->lbound;
ubound = cp->ubound;
- cc = *(xp_char_t*)p; p += xp_sizeof(cc);
- if (matcher->ignorecase) cc = XP_AWK_TOUPPER(matcher->awk, cc);
+ cc = *(sse_char_t*)p; p += sse_sizeof(cc);
+ if (matcher->ignorecase) cc = SSE_AWK_TOUPPER(matcher->awk, cc);
/* merge the same consecutive codes
* for example, a{1,10}a{0,10} is shortened to a{1,20}
@@ -1258,12 +1258,12 @@ static const xp_byte_t* __match_ord_char (
while (p < mat->branch_end &&
cp->cmd == ((const struct __code_t*)p)->cmd)
{
- if (XP_AWK_TOUPPER (matcher->awk, *(xp_char_t*)(p+xp_sizeof(*cp))) != cc) break;
+ if (SSE_AWK_TOUPPER (matcher->awk, *(sse_char_t*)(p+sse_sizeof(*cp))) != cc) break;
lbound += ((const struct __code_t*)p)->lbound;
ubound += ((const struct __code_t*)p)->ubound;
- p += xp_sizeof(*cp) + xp_sizeof(cc);
+ p += sse_sizeof(*cp) + sse_sizeof(cc);
}
}
else
@@ -1271,21 +1271,21 @@ static const xp_byte_t* __match_ord_char (
while (p < mat->branch_end &&
cp->cmd == ((const struct __code_t*)p)->cmd)
{
- if (*(xp_char_t*)(p+xp_sizeof(*cp)) != cc) break;
+ if (*(sse_char_t*)(p+sse_sizeof(*cp)) != cc) break;
lbound += ((const struct __code_t*)p)->lbound;
ubound += ((const struct __code_t*)p)->ubound;
- p += xp_sizeof(*cp) + xp_sizeof(cc);
+ p += sse_sizeof(*cp) + sse_sizeof(cc);
}
}
#ifdef BUILD_REX
-xp_printf (XP_T("__match_ord_char: lbound = %u, ubound = %u\n"),
+sse_printf (SSE_T("__match_ord_char: lbound = %u, ubound = %u\n"),
(unsigned int)lbound, (unsigned int)ubound);*/
#endif
- mat->matched = xp_false;
+ mat->matched = sse_false;
mat->match_len = 0;
/* find the longest match */
@@ -1294,7 +1294,7 @@ xp_printf (XP_T("__match_ord_char: lbound = %u, ubound = %u\n"),
while (si < ubound)
{
if (&mat->match_ptr[si] >= matcher->match.str.end) break;
- if (cc != XP_AWK_TOUPPER (matcher->awk, mat->match_ptr[si])) break;
+ if (cc != SSE_AWK_TOUPPER (matcher->awk, mat->match_ptr[si])) break;
si++;
}
}
@@ -1309,7 +1309,7 @@ xp_printf (XP_T("__match_ord_char: lbound = %u, ubound = %u\n"),
}
#ifdef DEBUG_REX
-xp_printf (XP_T("__match_ord_char: max si = %d, lbound = %u, ubound = %u\n"), si, lbound, ubound);
+sse_printf (SSE_T("__match_ord_char: max si = %d, lbound = %u, ubound = %u\n"), si, lbound, ubound);
#endif
if (si >= lbound && si <= ubound)
@@ -1320,25 +1320,25 @@ xp_printf (XP_T("__match_ord_char: max si = %d, lbound = %u, ubound = %u\n"), si
return p;
}
-static const xp_byte_t* __match_charset (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat)
+static const sse_byte_t* __match_charset (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
{
- const xp_byte_t* p = base;
+ const sse_byte_t* p = base;
const struct __code_t* cp;
- xp_size_t si = 0, lbound, ubound, csc, csl;
- xp_bool_t n;
- xp_char_t c;
+ sse_size_t si = 0, lbound, ubound, csc, csl;
+ sse_bool_t n;
+ sse_char_t c;
- cp = (const struct __code_t*)p; p += xp_sizeof(*cp);
- xp_awk_assert (matcher->awk, cp->cmd == CMD_CHARSET);
+ cp = (const struct __code_t*)p; p += sse_sizeof(*cp);
+ sse_awk_assert (matcher->awk, cp->cmd == CMD_CHARSET);
lbound = cp->lbound;
ubound = cp->ubound;
- csc = *(xp_size_t*)p; p += xp_sizeof(csc);
- csl = *(xp_size_t*)p; p += xp_sizeof(csl);
+ csc = *(sse_size_t*)p; p += sse_sizeof(csc);
+ csl = *(sse_size_t*)p; p += sse_sizeof(csl);
- mat->matched = xp_false;
+ mat->matched = sse_false;
mat->match_len = 0;
while (si < ubound)
@@ -1346,7 +1346,7 @@ static const xp_byte_t* __match_charset (
if (&mat->match_ptr[si] >= matcher->match.str.end) break;
c = mat->match_ptr[si];
- if (matcher->ignorecase) c = XP_AWK_TOUPPER(matcher->awk, c);
+ if (matcher->ignorecase) c = SSE_AWK_TOUPPER(matcher->awk, c);
n = __test_charset (matcher, p, csc, c);
if (cp->negate) n = !n;
@@ -1355,7 +1355,7 @@ static const xp_byte_t* __match_charset (
si++;
}
- p = p + csl - (xp_sizeof(csc) + xp_sizeof(csl));
+ p = p + csl - (sse_sizeof(csc) + sse_sizeof(csl));
if (si >= lbound && si <= ubound)
{
@@ -1365,18 +1365,18 @@ static const xp_byte_t* __match_charset (
return p;
}
-static const xp_byte_t* __match_group (
- __matcher_t* matcher, const xp_byte_t* base, __match_t* mat)
+static const sse_byte_t* __match_group (
+ __matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
{
- const xp_byte_t* p = base;
+ const sse_byte_t* p = base;
const struct __code_t* cp;
__match_t mat2;
- xp_size_t si = 0, grp_len_static[16], * grp_len;
+ sse_size_t si = 0, grp_len_static[16], * grp_len;
- cp = (const struct __code_t*)p; p += xp_sizeof(*cp);
- xp_awk_assert (matcher->awk, cp->cmd == CMD_GROUP);
+ cp = (const struct __code_t*)p; p += sse_sizeof(*cp);
+ sse_awk_assert (matcher->awk, cp->cmd == CMD_GROUP);
- mat->matched = xp_false;
+ mat->matched = sse_false;
mat->match_len = 0;
/*
@@ -1403,18 +1403,18 @@ static const xp_byte_t* __match_group (
* abcabcabcxyz
*/
- if (cp->ubound < xp_countof(grp_len_static))
+ if (cp->ubound < sse_countof(grp_len_static))
{
grp_len = grp_len_static;
}
else
{
- grp_len = (xp_size_t*) XP_AWK_MALLOC (
- matcher->awk, xp_sizeof(xp_size_t) * cp->ubound);
- if (grp_len == XP_NULL)
+ grp_len = (sse_size_t*) SSE_AWK_MALLOC (
+ matcher->awk, sse_sizeof(sse_size_t) * cp->ubound);
+ if (grp_len == SSE_NULL)
{
- matcher->errnum = XP_AWK_ENOMEM;
- return XP_NULL;
+ matcher->errnum = SSE_AWK_ENOMEM;
+ return SSE_NULL;
}
}
@@ -1425,11 +1425,11 @@ static const xp_byte_t* __match_group (
{
if (mat2.match_ptr >= matcher->match.str.end) break;
- if (__match_pattern (matcher, p, &mat2) == XP_NULL)
+ if (__match_pattern (matcher, p, &mat2) == SSE_NULL)
{
if (grp_len != grp_len_static)
- XP_AWK_FREE (matcher->awk, grp_len);
- return XP_NULL;
+ SSE_AWK_FREE (matcher->awk, grp_len);
+ return SSE_NULL;
}
if (!mat2.matched) break;
@@ -1437,48 +1437,48 @@ static const xp_byte_t* __match_group (
mat2.match_ptr += mat2.match_len;
mat2.match_len = 0;
- mat2.matched = xp_false;
+ mat2.matched = sse_false;
si++;
}
/* increment p by the length of the subpattern */
- p += *(xp_size_t*)(p+xp_sizeof(xp_size_t));
+ p += *(sse_size_t*)(p+sse_sizeof(sse_size_t));
/* check the occurrences */
if (si >= cp->lbound && si <= cp->ubound)
{
if (cp->lbound == cp->ubound || p >= mat->branch_end)
{
- mat->matched = xp_true;
+ mat->matched = sse_true;
mat->match_len = grp_len[si];
}
else
{
- xp_awk_assert (matcher->awk, cp->ubound > cp->lbound);
+ sse_awk_assert (matcher->awk, cp->ubound > cp->lbound);
do
{
- const xp_byte_t* tmp;
+ const sse_byte_t* tmp;
mat2.match_ptr = &mat->match_ptr[grp_len[si]];
mat2.branch = mat->branch;
mat2.branch_end = mat->branch_end;
#ifdef DEBUG_REX
-xp_printf (XP_T("__match_group: GROUP si = %d [%s]\n"), si, mat->match_ptr);
+sse_printf (SSE_T("__match_group: GROUP si = %d [%s]\n"), si, mat->match_ptr);
#endif
tmp = __match_branch_body (matcher, p, &mat2);
- if (tmp == XP_NULL)
+ if (tmp == SSE_NULL)
{
if (grp_len != grp_len_static)
- XP_AWK_FREE (matcher->awk, grp_len);
- return XP_NULL;
+ SSE_AWK_FREE (matcher->awk, grp_len);
+ return SSE_NULL;
}
if (mat2.matched)
{
- mat->matched = xp_true;
+ mat->matched = sse_true;
mat->match_len = grp_len[si] + mat2.match_len;
p = tmp;
break;
@@ -1492,15 +1492,15 @@ xp_printf (XP_T("__match_group: GROUP si = %d [%s]\n"), si, mat->match_ptr);
}
- if (grp_len != grp_len_static) XP_AWK_FREE (matcher->awk, grp_len);
+ if (grp_len != grp_len_static) SSE_AWK_FREE (matcher->awk, grp_len);
return p;
}
-static const xp_byte_t* __match_occurrences (
- __matcher_t* matcher, xp_size_t si, const xp_byte_t* p,
- xp_size_t lbound, xp_size_t ubound, __match_t* mat)
+static const sse_byte_t* __match_occurrences (
+ __matcher_t* matcher, sse_size_t si, const sse_byte_t* p,
+ sse_size_t lbound, sse_size_t ubound, __match_t* mat)
{
- xp_awk_assert (matcher->awk, si >= lbound && si <= ubound);
+ sse_awk_assert (matcher->awk, si >= lbound && si <= ubound);
/* the match has been found */
if (lbound == ubound || p >= mat->branch_end)
@@ -1508,7 +1508,7 @@ static const xp_byte_t* __match_occurrences (
/* if the match for fixed occurrences was
* requested or no atoms remain unchecked in
* the branch, the match is returned. */
- mat->matched = xp_true;
+ mat->matched = sse_true;
mat->match_len = si;
}
else
@@ -1553,25 +1553,25 @@ static const xp_byte_t* __match_occurrences (
* lbound in the implementation below, though)
*/
- xp_awk_assert (matcher->awk, ubound > lbound);
+ sse_awk_assert (matcher->awk, ubound > lbound);
do
{
__match_t mat2;
- const xp_byte_t* tmp;
+ const sse_byte_t* tmp;
mat2.match_ptr = &mat->match_ptr[si];
mat2.branch = mat->branch;
mat2.branch_end = mat->branch_end;
#ifdef DEBUG_REX
-xp_printf (XP_T("__match occurrences: si = %d [%s]\n"), si, mat->match_ptr);
+sse_printf (SSE_T("__match occurrences: si = %d [%s]\n"), si, mat->match_ptr);
#endif
tmp = __match_branch_body (matcher, p, &mat2);
if (mat2.matched)
{
- mat->matched = xp_true;
+ mat->matched = sse_true;
mat->match_len = si + mat2.match_len;
p = tmp;
break;
@@ -1586,149 +1586,149 @@ xp_printf (XP_T("__match occurrences: si = %d [%s]\n"), si, mat->match_ptr);
return p;
}
-xp_bool_t __test_charset (
- __matcher_t* matcher, const xp_byte_t* p, xp_size_t csc, xp_char_t c)
+sse_bool_t __test_charset (
+ __matcher_t* matcher, const sse_byte_t* p, sse_size_t csc, sse_char_t c)
{
- xp_size_t i;
+ sse_size_t i;
for (i = 0; i < csc; i++)
{
- xp_char_t c0, c1, c2;
+ sse_char_t c0, c1, c2;
- c0 = *(xp_char_t*)p;
- p += xp_sizeof(c0);
+ c0 = *(sse_char_t*)p;
+ p += sse_sizeof(c0);
if (c0 == CHARSET_ONE)
{
- c1 = *(xp_char_t*)p;
+ c1 = *(sse_char_t*)p;
if (matcher->ignorecase)
- c1 = XP_AWK_TOUPPER(matcher->awk, c1);
- if (c == c1) return xp_true;
+ c1 = SSE_AWK_TOUPPER(matcher->awk, c1);
+ if (c == c1) return sse_true;
}
else if (c0 == CHARSET_RANGE)
{
- c1 = *(xp_char_t*)p;
- p += xp_sizeof(c1);
- c2 = *(xp_char_t*)p;
+ c1 = *(sse_char_t*)p;
+ p += sse_sizeof(c1);
+ c2 = *(sse_char_t*)p;
if (matcher->ignorecase)
{
- c1 = XP_AWK_TOUPPER(matcher->awk, c1);
- c2 = XP_AWK_TOUPPER(matcher->awk, c2);
+ c1 = SSE_AWK_TOUPPER(matcher->awk, c1);
+ c2 = SSE_AWK_TOUPPER(matcher->awk, c2);
}
- if (c >= c1 && c <= c2) return xp_true;
+ if (c >= c1 && c <= c2) return sse_true;
}
else if (c0 == CHARSET_CLASS)
{
- c1 = *(xp_char_t*)p;
+ c1 = *(sse_char_t*)p;
if (__char_class[c1].func (
- matcher->awk, c)) return xp_true;
+ matcher->awk, c)) return sse_true;
}
else
{
- xp_awk_assert (matcher->awk,
+ sse_awk_assert (matcher->awk,
!"should never happen - invalid charset code");
break;
}
- p += xp_sizeof(c1);
+ p += sse_sizeof(c1);
}
- return xp_false;
+ return sse_false;
}
-static xp_bool_t __cc_isalnum (xp_awk_t* awk, xp_char_t c)
+static sse_bool_t __cc_isalnum (sse_awk_t* awk, sse_char_t c)
{
- return XP_AWK_ISALNUM (awk, c);
+ return SSE_AWK_ISALNUM (awk, c);
}
-static xp_bool_t __cc_isalpha (xp_awk_t* awk, xp_char_t c)
+static sse_bool_t __cc_isalpha (sse_awk_t* awk, sse_char_t c)
{
- return XP_AWK_ISALPHA (awk, c);
+ return SSE_AWK_ISALPHA (awk, c);
}
-static xp_bool_t __cc_isblank (xp_awk_t* awk, xp_char_t c)
+static sse_bool_t __cc_isblank (sse_awk_t* awk, sse_char_t c)
{
- return c == XP_T(' ') || c == XP_T('\t');
+ return c == SSE_T(' ') || c == SSE_T('\t');
}
-static xp_bool_t __cc_iscntrl (xp_awk_t* awk, xp_char_t c)
+static sse_bool_t __cc_iscntrl (sse_awk_t* awk, sse_char_t c)
{
- return XP_AWK_ISCNTRL (awk, c);
+ return SSE_AWK_ISCNTRL (awk, c);
}
-static xp_bool_t __cc_isdigit (xp_awk_t* awk, xp_char_t c)
+static sse_bool_t __cc_isdigit (sse_awk_t* awk, sse_char_t c)
{
- return XP_AWK_ISDIGIT (awk, c);
+ return SSE_AWK_ISDIGIT (awk, c);
}
-static xp_bool_t __cc_isgraph (xp_awk_t* awk, xp_char_t c)
+static sse_bool_t __cc_isgraph (sse_awk_t* awk, sse_char_t c)
{
- return XP_AWK_ISGRAPH (awk, c);
+ return SSE_AWK_ISGRAPH (awk, c);
}
-static xp_bool_t __cc_islower (xp_awk_t* awk, xp_char_t c)
+static sse_bool_t __cc_islower (sse_awk_t* awk, sse_char_t c)
{
- return XP_AWK_ISLOWER (awk, c);
+ return SSE_AWK_ISLOWER (awk, c);
}
-static xp_bool_t __cc_isprint (xp_awk_t* awk, xp_char_t c)
+static sse_bool_t __cc_isprint (sse_awk_t* awk, sse_char_t c)
{
- return XP_AWK_ISPRINT (awk, c);
+ return SSE_AWK_ISPRINT (awk, c);
}
-static xp_bool_t __cc_ispunct (xp_awk_t* awk, xp_char_t c)
+static sse_bool_t __cc_ispunct (sse_awk_t* awk, sse_char_t c)
{
- return XP_AWK_ISPUNCT (awk, c);
+ return SSE_AWK_ISPUNCT (awk, c);
}
-static xp_bool_t __cc_isspace (xp_awk_t* awk, xp_char_t c)
+static sse_bool_t __cc_isspace (sse_awk_t* awk, sse_char_t c)
{
- return XP_AWK_ISSPACE (awk, c);
+ return SSE_AWK_ISSPACE (awk, c);
}
-static xp_bool_t __cc_isupper (xp_awk_t* awk, xp_char_t c)
+static sse_bool_t __cc_isupper (sse_awk_t* awk, sse_char_t c)
{
- return XP_AWK_ISUPPER (awk, c);
+ return SSE_AWK_ISUPPER (awk, c);
}
-static xp_bool_t __cc_isxdigit (xp_awk_t* awk, xp_char_t c)
+static sse_bool_t __cc_isxdigit (sse_awk_t* awk, sse_char_t c)
{
- return XP_AWK_ISXDIGIT (awk, c);
+ return SSE_AWK_ISXDIGIT (awk, c);
}
-void xp_awk_printrex (void* rex)
+void sse_awk_printrex (void* rex)
{
__print_pattern (rex);
- xp_printf (XP_T("\n"));
+ sse_printf (SSE_T("\n"));
}
-static const xp_byte_t* __print_pattern (const xp_byte_t* p)
+static const sse_byte_t* __print_pattern (const sse_byte_t* p)
{
- xp_size_t nb, el, i;
+ sse_size_t nb, el, i;
- nb = *(xp_size_t*)p; p += xp_sizeof(nb);
- el = *(xp_size_t*)p; p += xp_sizeof(el);
+ nb = *(sse_size_t*)p; p += sse_sizeof(nb);
+ el = *(sse_size_t*)p; p += sse_sizeof(el);
#ifdef DEBUG_REX
-xp_printf (XP_T("__print_pattern: NB = %u, EL = %u\n"), (unsigned int)nb, (unsigned int)el);
+sse_printf (SSE_T("__print_pattern: NB = %u, EL = %u\n"), (unsigned int)nb, (unsigned int)el);
#endif
for (i = 0; i < nb; i++)
{
- if (i != 0) xp_printf (XP_T("|"));
+ if (i != 0) sse_printf (SSE_T("|"));
p = __print_branch (p);
}
return p;
}
-static const xp_byte_t* __print_branch (const xp_byte_t* p)
+static const sse_byte_t* __print_branch (const sse_byte_t* p)
{
- xp_size_t na, bl, i;
+ sse_size_t na, bl, i;
- na = *(xp_size_t*)p; p += xp_sizeof(na);
- bl = *(xp_size_t*)p; p += xp_sizeof(bl);
+ na = *(sse_size_t*)p; p += sse_sizeof(na);
+ bl = *(sse_size_t*)p; p += sse_sizeof(bl);
#ifdef DEBUG_REX
-xp_printf (XP_T("__print_branch: NA = %u, BL = %u\n"), (unsigned int) na, (unsigned int)bl);
+sse_printf (SSE_T("__print_branch: NA = %u, BL = %u\n"), (unsigned int) na, (unsigned int)bl);
#endif
for (i = 0; i < na; i++)
@@ -1739,97 +1739,97 @@ xp_printf (XP_T("__print_branch: NA = %u, BL = %u\n"), (unsigned int) na, (unsig
return p;
}
-static const xp_byte_t* __print_atom (const xp_byte_t* p)
+static const sse_byte_t* __print_atom (const sse_byte_t* p)
{
const struct __code_t* cp = (const struct __code_t*)p;
if (cp->cmd == CMD_BOL)
{
- xp_printf (XP_T("^"));
- p += xp_sizeof(*cp);
+ sse_printf (SSE_T("^"));
+ p += sse_sizeof(*cp);
}
else if (cp->cmd == CMD_EOL)
{
- xp_printf (XP_T("$"));
- p += xp_sizeof(*cp);
+ sse_printf (SSE_T("$"));
+ p += sse_sizeof(*cp);
}
else if (cp->cmd == CMD_ANY_CHAR)
{
- xp_printf (XP_T("."));
- p += xp_sizeof(*cp);
+ sse_printf (SSE_T("."));
+ p += sse_sizeof(*cp);
}
else if (cp->cmd == CMD_ORD_CHAR)
{
- p += xp_sizeof(*cp);
- xp_printf (XP_T("%c"), *(xp_char_t*)p);
- p += xp_sizeof(xp_char_t);
+ p += sse_sizeof(*cp);
+ sse_printf (SSE_T("%c"), *(sse_char_t*)p);
+ p += sse_sizeof(sse_char_t);
}
else if (cp->cmd == CMD_CHARSET)
{
- xp_size_t csc, csl, i;
+ sse_size_t csc, csl, i;
- p += xp_sizeof(*cp);
- xp_printf (XP_T("["));
- if (cp->negate) xp_printf (XP_T("^"));
+ p += sse_sizeof(*cp);
+ sse_printf (SSE_T("["));
+ if (cp->negate) sse_printf (SSE_T("^"));
- csc = *(xp_size_t*)p; p += xp_sizeof(csc);
- csl = *(xp_size_t*)p; p += xp_sizeof(csl);
+ csc = *(sse_size_t*)p; p += sse_sizeof(csc);
+ csl = *(sse_size_t*)p; p += sse_sizeof(csl);
for (i = 0; i < csc; i++)
{
- xp_char_t c0, c1, c2;
+ sse_char_t c0, c1, c2;
- c0 = *(xp_char_t*)p;
- p += xp_sizeof(c0);
+ c0 = *(sse_char_t*)p;
+ p += sse_sizeof(c0);
if (c0 == CHARSET_ONE)
{
- c1 = *(xp_char_t*)p;
- xp_printf (XP_T("%c"), c1);
+ c1 = *(sse_char_t*)p;
+ sse_printf (SSE_T("%c"), c1);
}
else if (c0 == CHARSET_RANGE)
{
- c1 = *(xp_char_t*)p;
- p += xp_sizeof(c1);
- c2 = *(xp_char_t*)p;
- xp_printf (XP_T("%c-%c"), c1, c2);
+ c1 = *(sse_char_t*)p;
+ p += sse_sizeof(c1);
+ c2 = *(sse_char_t*)p;
+ sse_printf (SSE_T("%c-%c"), c1, c2);
}
else if (c0 == CHARSET_CLASS)
{
- c1 = *(xp_char_t*)p;
- xp_printf (XP_T("[:%s:]"), __char_class[c1].name);
+ c1 = *(sse_char_t*)p;
+ sse_printf (SSE_T("[:%s:]"), __char_class[c1].name);
}
else
{
- xp_printf ("should never happen - invalid charset code\n");
+ sse_printf ("should never happen - invalid charset code\n");
}
- p += xp_sizeof(c1);
+ p += sse_sizeof(c1);
}
- xp_printf (XP_T("]"));
+ sse_printf (SSE_T("]"));
}
else if (cp->cmd == CMD_GROUP)
{
- p += xp_sizeof(*cp);
- xp_printf (XP_T("("));
+ p += sse_sizeof(*cp);
+ sse_printf (SSE_T("("));
p = __print_pattern (p);
- xp_printf (XP_T(")"));
+ sse_printf (SSE_T(")"));
}
else
{
- xp_printf ("should never happen - invalid atom code\n");
+ sse_printf ("should never happen - invalid atom code\n");
}
if (cp->lbound == 0 && cp->ubound == BOUND_MAX)
- xp_printf (XP_T("*"));
+ sse_printf (SSE_T("*"));
else if (cp->lbound == 1 && cp->ubound == BOUND_MAX)
- xp_printf (XP_T("+"));
+ sse_printf (SSE_T("+"));
else if (cp->lbound == 0 && cp->ubound == 1)
- xp_printf (XP_T("?"));
+ sse_printf (SSE_T("?"));
else if (cp->lbound != 1 || cp->ubound != 1)
{
- xp_printf (XP_T("{%lu,%lu}"),
+ sse_printf (SSE_T("{%lu,%lu}"),
(unsigned long)cp->lbound, (unsigned long)cp->ubound);
}
diff --git a/ase/awk/rex.h b/ase/awk/rex.h
index 040e4e11..23e24046 100644
--- a/ase/awk/rex.h
+++ b/ase/awk/rex.h
@@ -1,70 +1,70 @@
/*
- * $Id: rex.h,v 1.18 2006-10-12 04:17:31 bacon Exp $
+ * $Id: rex.h,v 1.19 2006-10-22 11:34:53 bacon Exp $
**/
-#ifndef _XP_AWK_REX_H_
-#define _XP_AWK_REX_H_
+#ifndef _SSE_AWK_REX_H_
+#define _SSE_AWK_REX_H_
-#include <xp/types.h>
-#include <xp/macros.h>
+#include <sse/types.h>
+#include <sse/macros.h>
/*
- * Regular Expression Syntax
- * A regular expression is zero or more branches, separated by '|'.
+ * Regular Esseression Syntax
+ * A regular esseression is zero or more branches, separated by '|'.
* ......
* ......
*
- * Compiled form of a regular expression:
+ * Compiled form of a regular esseression:
*
- * | expression |
+ * | esseression |
* | header | branch | branch | branch |
* | nb | el | na | bl | cmd | arg | cmd | arg | na | bl | cmd | arg | na | bl | cmd |
*
* nb: the number of branches
- * el: the length of a expression including the length of nb and el
+ * el: the length of a esseression including the length of nb and el
* na: the number of atoms
* bl: the length of a branch including the length of na and bl
* cmd: The command and repetition info encoded together.
* Some commands require an argument to follow them but some other don't.
* It is encoded as follows:
*
- * Subexpressions can be nested by having the command "GROUP"
- * and a subexpression as its argument.
+ * Subesseressions can be nested by having the command "GROUP"
+ * and a subesseression as its argument.
*
* Examples:
* a.c -> |1|6|5|ORD_CHAR(no bound)|a|ANY_CHAR(no bound)|ORD_CHAR(no bound)|c|
* 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 XP_AWK_REX_NA(code) (*(xp_size_t*)(code))
+#define SSE_AWK_REX_NA(code) (*(sse_size_t*)(code))
-#define XP_AWK_REX_LEN(code) \
- (*(xp_size_t*)((xp_byte_t*)(code)+xp_sizeof(xp_size_t)))
+#define SSE_AWK_REX_LEN(code) \
+ (*(sse_size_t*)((sse_byte_t*)(code)+sse_sizeof(sse_size_t)))
-enum xp_awk_rex_option_t
+enum sse_awk_rex_option_t
{
- XP_AWK_REX_IGNORECASE = (1 << 0)
+ SSE_AWK_REX_IGNORECASE = (1 << 0)
};
#ifdef __cplusplus
extern "C" {
#endif
-void* xp_awk_buildrex (
- xp_awk_t* awk, const xp_char_t* ptn,
- xp_size_t len, int* errnum);
+void* sse_awk_buildrex (
+ sse_awk_t* awk, const sse_char_t* ptn,
+ sse_size_t len, int* errnum);
-int xp_awk_matchrex (
- xp_awk_t* awk, void* code, int option,
- const xp_char_t* str, xp_size_t len,
- const xp_char_t** match_ptr, xp_size_t* match_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);
-void xp_awk_freerex (xp_awk_t* awk, void* code);
+void sse_awk_freerex (sse_awk_t* awk, void* code);
-xp_bool_t xp_awk_isemptyrex (xp_awk_t* awk, void* code);
+sse_bool_t sse_awk_isemptyrex (sse_awk_t* awk, void* code);
-void xp_awk_printrex (void* code);
+void sse_awk_printrex (void* code);
#ifdef __cplusplus
}
diff --git a/ase/awk/run.c b/ase/awk/run.c
index 511bf46c..b3df33d2 100644
--- a/ase/awk/run.c
+++ b/ase/awk/run.c
@@ -1,8 +1,8 @@
/*
- * $Id: run.c,v 1.239 2006-10-17 09:36:08 bacon Exp $
+ * $Id: run.c,v 1.240 2006-10-22 11:34:53 bacon Exp $
*/
-#include <xp/awk/awk_i.h>
+#include <sse/awk/awk_i.h>
/* TODO: remove this dependency...*/
#include <math.h>
@@ -14,7 +14,7 @@
#define STACK_AT(run,n) ((run)->stack[(run)->stack_base+(n)])
#define STACK_NARGS(run) (STACK_AT(run,3))
#define STACK_ARG(run,n) STACK_AT(run,3+1+(n))
-#define STACK_LOCAL(run,n) STACK_AT(run,3+(xp_size_t)STACK_NARGS(run)+1+(n))
+#define STACK_LOCAL(run,n) STACK_AT(run,3+(sse_size_t)STACK_NARGS(run)+1+(n))
#define STACK_RETVAL(run) STACK_AT(run,2)
#define STACK_GLOBAL(run,n) ((run)->stack[(n)])
#define STACK_RETVAL_GLOBAL(run) ((run)->stack[(run)->awk->tree.nglobals+2])
@@ -31,285 +31,285 @@ enum
};
#define PANIC(run,code) \
- do { (run)->errnum = (code); return XP_NULL; } while (0)
+ do { (run)->errnum = (code); return SSE_NULL; } while (0)
#define PANIC_I(run,code) \
do { (run)->errnum = (code); return -1; } while (0)
-#define DEFAULT_CONVFMT XP_T("%.6g")
-#define DEFAULT_OFMT XP_T("%.6g")
-#define DEFAULT_OFS XP_T(" ")
-#define DEFAULT_ORS XP_T("\n")
-#define DEFAULT_SUBSEP XP_T("\034")
+#define DEFAULT_CONVFMT SSE_T("%.6g")
+#define DEFAULT_OFMT SSE_T("%.6g")
+#define DEFAULT_OFS SSE_T(" ")
+#define DEFAULT_ORS SSE_T("\n")
+#define DEFAULT_SUBSEP SSE_T("\034")
/* the index of a positional variable should be a positive interger
* equal to or less than the maximum value of the type by which
* the index is represented. but it has an extra check against the
- * maximum value of xp_size_t as the reference is represented
- * in a pointer variable of xp_awk_val_ref_t and sizeof(void*) is
- * equal to sizeof(xp_size_t). */
+ * maximum value of sse_size_t as the reference is represented
+ * in a pointer variable of sse_awk_val_ref_t and sizeof(void*) is
+ * equal to sizeof(sse_size_t). */
#define IS_VALID_POSIDX(idx) \
((idx) >= 0 && \
- (idx) < XP_TYPE_MAX(xp_long_t) && \
- (idx) < XP_TYPE_MAX(xp_size_t))
+ (idx) < SSE_TYPE_MAX(sse_long_t) && \
+ (idx) < SSE_TYPE_MAX(sse_size_t))
-static void __add_run (xp_awk_t* awk, xp_awk_run_t* run);
-static void __del_run (xp_awk_t* awk, xp_awk_run_t* run);
+static void __add_run (sse_awk_t* awk, sse_awk_run_t* run);
+static void __del_run (sse_awk_t* awk, sse_awk_run_t* run);
static int __init_run (
- xp_awk_run_t* run, xp_awk_runios_t* runios, int* errnum);
-static void __deinit_run (xp_awk_run_t* run);
+ sse_awk_run_t* run, sse_awk_runios_t* runios, int* errnum);
+static void __deinit_run (sse_awk_run_t* run);
-static int __build_runarg (xp_awk_run_t* run, xp_awk_runarg_t* runarg);
-static int __set_globals_to_default (xp_awk_run_t* run);
+static int __build_runarg (sse_awk_run_t* run, sse_awk_runarg_t* runarg);
+static int __set_globals_to_default (sse_awk_run_t* run);
-static int __run_main (xp_awk_run_t* run, xp_awk_runarg_t* runarg);
-static int __run_pattern_blocks (xp_awk_run_t* run);
+static int __run_main (sse_awk_run_t* run, sse_awk_runarg_t* runarg);
+static int __run_pattern_blocks (sse_awk_run_t* run);
static int __run_pattern_block_chain (
- xp_awk_run_t* run, xp_awk_chain_t* chain);
+ sse_awk_run_t* run, sse_awk_chain_t* chain);
static int __run_pattern_block (
- xp_awk_run_t* run, xp_awk_chain_t* chain, xp_size_t block_no);
-static int __run_block (xp_awk_run_t* run, xp_awk_nde_blk_t* nde);
-static int __run_statement (xp_awk_run_t* run, xp_awk_nde_t* nde);
-static int __run_if (xp_awk_run_t* run, xp_awk_nde_if_t* nde);
-static int __run_while (xp_awk_run_t* run, xp_awk_nde_while_t* nde);
-static int __run_for (xp_awk_run_t* run, xp_awk_nde_for_t* nde);
-static int __run_foreach (xp_awk_run_t* run, xp_awk_nde_foreach_t* nde);
-static int __run_break (xp_awk_run_t* run, xp_awk_nde_break_t* nde);
-static int __run_continue (xp_awk_run_t* run, xp_awk_nde_continue_t* nde);
-static int __run_return (xp_awk_run_t* run, xp_awk_nde_return_t* nde);
-static int __run_exit (xp_awk_run_t* run, xp_awk_nde_exit_t* nde);
-static int __run_next (xp_awk_run_t* run, xp_awk_nde_next_t* nde);
-static int __run_nextfile (xp_awk_run_t* run, xp_awk_nde_nextfile_t* nde);
-static int __run_delete (xp_awk_run_t* run, xp_awk_nde_delete_t* nde);
-static int __run_print (xp_awk_run_t* run, xp_awk_nde_print_t* nde);
+ sse_awk_run_t* run, sse_awk_chain_t* chain, sse_size_t block_no);
+static int __run_block (sse_awk_run_t* run, sse_awk_nde_blk_t* nde);
+static int __run_statement (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static int __run_if (sse_awk_run_t* run, sse_awk_nde_if_t* nde);
+static int __run_while (sse_awk_run_t* run, sse_awk_nde_while_t* nde);
+static int __run_for (sse_awk_run_t* run, sse_awk_nde_for_t* nde);
+static int __run_foreach (sse_awk_run_t* run, sse_awk_nde_foreach_t* nde);
+static int __run_break (sse_awk_run_t* run, sse_awk_nde_break_t* nde);
+static int __run_continue (sse_awk_run_t* run, sse_awk_nde_continue_t* nde);
+static int __run_return (sse_awk_run_t* run, sse_awk_nde_return_t* nde);
+static int __run_exit (sse_awk_run_t* run, sse_awk_nde_exit_t* nde);
+static int __run_next (sse_awk_run_t* run, sse_awk_nde_next_t* nde);
+static int __run_nextfile (sse_awk_run_t* run, sse_awk_nde_nextfile_t* nde);
+static int __run_delete (sse_awk_run_t* run, sse_awk_nde_delete_t* nde);
+static int __run_print (sse_awk_run_t* run, sse_awk_nde_print_t* nde);
-static xp_awk_val_t* __eval_expression (xp_awk_run_t* run, xp_awk_nde_t* nde);
-static xp_awk_val_t* __eval_expression0 (xp_awk_run_t* run, xp_awk_nde_t* nde);
+static sse_awk_val_t* __eval_esseression (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static sse_awk_val_t* __eval_esseression0 (sse_awk_run_t* run, sse_awk_nde_t* nde);
-static xp_awk_val_t* __eval_group (xp_awk_run_t* run, xp_awk_nde_t* nde);
+static sse_awk_val_t* __eval_group (sse_awk_run_t* run, sse_awk_nde_t* nde);
-static xp_awk_val_t* __eval_assignment (
- xp_awk_run_t* run, xp_awk_nde_t* nde);
-static xp_awk_val_t* __do_assignment (
- xp_awk_run_t* run, xp_awk_nde_t* var, xp_awk_val_t* val);
-static xp_awk_val_t* __do_assignment_scalar (
- xp_awk_run_t* run, xp_awk_nde_var_t* var, xp_awk_val_t* val);
-static xp_awk_val_t* __do_assignment_map (
- xp_awk_run_t* run, xp_awk_nde_var_t* var, xp_awk_val_t* val);
-static xp_awk_val_t* __do_assignment_pos (
- xp_awk_run_t* run, xp_awk_nde_pos_t* pos, xp_awk_val_t* val);
+static sse_awk_val_t* __eval_assignment (
+ sse_awk_run_t* run, sse_awk_nde_t* nde);
+static sse_awk_val_t* __do_assignment (
+ sse_awk_run_t* run, sse_awk_nde_t* var, sse_awk_val_t* val);
+static sse_awk_val_t* __do_assignment_scalar (
+ sse_awk_run_t* run, sse_awk_nde_var_t* var, sse_awk_val_t* val);
+static sse_awk_val_t* __do_assignment_map (
+ sse_awk_run_t* run, sse_awk_nde_var_t* var, sse_awk_val_t* val);
+static sse_awk_val_t* __do_assignment_pos (
+ sse_awk_run_t* run, sse_awk_nde_pos_t* pos, sse_awk_val_t* val);
-static xp_awk_val_t* __eval_binary (
- xp_awk_run_t* run, xp_awk_nde_t* nde);
-static xp_awk_val_t* __eval_binop_lor (
- xp_awk_run_t* run, xp_awk_nde_t* left, xp_awk_nde_t* right);
-static xp_awk_val_t* __eval_binop_land (
- xp_awk_run_t* run, xp_awk_nde_t* left, xp_awk_nde_t* right);
-static xp_awk_val_t* __eval_binop_in (
- xp_awk_run_t* run, xp_awk_nde_t* left, xp_awk_nde_t* right);
-static xp_awk_val_t* __eval_binop_bor (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right);
-static xp_awk_val_t* __eval_binop_bxor (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right);
-static xp_awk_val_t* __eval_binop_band (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right);
-static xp_awk_val_t* __eval_binop_eq (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right);
-static xp_awk_val_t* __eval_binop_ne (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right);
-static xp_awk_val_t* __eval_binop_gt (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right);
-static xp_awk_val_t* __eval_binop_ge (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right);
-static xp_awk_val_t* __eval_binop_lt (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right);
-static xp_awk_val_t* __eval_binop_le (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right);
-static xp_awk_val_t* __eval_binop_lshift (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right);
-static xp_awk_val_t* __eval_binop_rshift (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right);
-static xp_awk_val_t* __eval_binop_plus (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right);
-static xp_awk_val_t* __eval_binop_minus (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right);
-static xp_awk_val_t* __eval_binop_mul (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right);
-static xp_awk_val_t* __eval_binop_div (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right);
-static xp_awk_val_t* __eval_binop_mod (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right);
-static xp_awk_val_t* __eval_binop_exp (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right);
-static xp_awk_val_t* __eval_binop_concat (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right);
-static xp_awk_val_t* __eval_binop_ma (
- xp_awk_run_t* run, xp_awk_nde_t* left, xp_awk_nde_t* right);
-static xp_awk_val_t* __eval_binop_nm (
- xp_awk_run_t* run, xp_awk_nde_t* left, xp_awk_nde_t* right);
-static xp_awk_val_t* __eval_binop_match0 (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right, int ret);
+static sse_awk_val_t* __eval_binary (
+ sse_awk_run_t* run, sse_awk_nde_t* nde);
+static sse_awk_val_t* __eval_binop_lor (
+ sse_awk_run_t* run, sse_awk_nde_t* left, sse_awk_nde_t* right);
+static sse_awk_val_t* __eval_binop_land (
+ sse_awk_run_t* run, sse_awk_nde_t* left, sse_awk_nde_t* right);
+static sse_awk_val_t* __eval_binop_in (
+ sse_awk_run_t* run, sse_awk_nde_t* left, sse_awk_nde_t* right);
+static sse_awk_val_t* __eval_binop_bor (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right);
+static sse_awk_val_t* __eval_binop_bxor (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right);
+static sse_awk_val_t* __eval_binop_band (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right);
+static sse_awk_val_t* __eval_binop_eq (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right);
+static sse_awk_val_t* __eval_binop_ne (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right);
+static sse_awk_val_t* __eval_binop_gt (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right);
+static sse_awk_val_t* __eval_binop_ge (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right);
+static sse_awk_val_t* __eval_binop_lt (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right);
+static sse_awk_val_t* __eval_binop_le (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right);
+static sse_awk_val_t* __eval_binop_lshift (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right);
+static sse_awk_val_t* __eval_binop_rshift (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right);
+static sse_awk_val_t* __eval_binop_plus (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right);
+static sse_awk_val_t* __eval_binop_minus (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right);
+static sse_awk_val_t* __eval_binop_mul (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right);
+static sse_awk_val_t* __eval_binop_div (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right);
+static sse_awk_val_t* __eval_binop_mod (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right);
+static sse_awk_val_t* __eval_binop_esse (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right);
+static sse_awk_val_t* __eval_binop_concat (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right);
+static sse_awk_val_t* __eval_binop_ma (
+ sse_awk_run_t* run, sse_awk_nde_t* left, sse_awk_nde_t* right);
+static sse_awk_val_t* __eval_binop_nm (
+ sse_awk_run_t* run, sse_awk_nde_t* left, sse_awk_nde_t* right);
+static sse_awk_val_t* __eval_binop_match0 (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right, int ret);
-static xp_awk_val_t* __eval_unary (xp_awk_run_t* run, xp_awk_nde_t* nde);
-static xp_awk_val_t* __eval_incpre (xp_awk_run_t* run, xp_awk_nde_t* nde);
-static xp_awk_val_t* __eval_incpst (xp_awk_run_t* run, xp_awk_nde_t* nde);
-static xp_awk_val_t* __eval_cnd (xp_awk_run_t* run, xp_awk_nde_t* nde);
+static sse_awk_val_t* __eval_unary (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static sse_awk_val_t* __eval_incpre (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static sse_awk_val_t* __eval_incpst (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static sse_awk_val_t* __eval_cnd (sse_awk_run_t* run, sse_awk_nde_t* nde);
-static xp_awk_val_t* __eval_bfn (xp_awk_run_t* run, xp_awk_nde_t* nde);
-static xp_awk_val_t* __eval_afn (xp_awk_run_t* run, xp_awk_nde_t* nde);
-static xp_awk_val_t* __eval_call (
- xp_awk_run_t* run, xp_awk_nde_t* nde,
- const xp_char_t* bfn_arg_spec, xp_awk_afn_t* afn);
+static sse_awk_val_t* __eval_bfn (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static sse_awk_val_t* __eval_afn (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static sse_awk_val_t* __eval_call (
+ sse_awk_run_t* run, sse_awk_nde_t* nde,
+ const sse_char_t* bfn_arg_spec, sse_awk_afn_t* afn);
static int __get_reference (
- xp_awk_run_t* run, xp_awk_nde_t* nde, xp_awk_val_t*** ref);
-static xp_awk_val_t** __get_reference_indexed (
- xp_awk_run_t* run, xp_awk_nde_var_t* nde, xp_awk_val_t** val);
+ sse_awk_run_t* run, sse_awk_nde_t* nde, sse_awk_val_t*** ref);
+static sse_awk_val_t** __get_reference_indexed (
+ sse_awk_run_t* run, sse_awk_nde_var_t* nde, sse_awk_val_t** val);
-static xp_awk_val_t* __eval_int (xp_awk_run_t* run, xp_awk_nde_t* nde);
-static xp_awk_val_t* __eval_real (xp_awk_run_t* run, xp_awk_nde_t* nde);
-static xp_awk_val_t* __eval_str (xp_awk_run_t* run, xp_awk_nde_t* nde);
-static xp_awk_val_t* __eval_rex (xp_awk_run_t* run, xp_awk_nde_t* nde);
-static xp_awk_val_t* __eval_named (xp_awk_run_t* run, xp_awk_nde_t* nde);
-static xp_awk_val_t* __eval_global (xp_awk_run_t* run, xp_awk_nde_t* nde);
-static xp_awk_val_t* __eval_local (xp_awk_run_t* run, xp_awk_nde_t* nde);
-static xp_awk_val_t* __eval_arg (xp_awk_run_t* run, xp_awk_nde_t* nde);
-static xp_awk_val_t* __eval_namedidx (xp_awk_run_t* run, xp_awk_nde_t* nde);
-static xp_awk_val_t* __eval_globalidx (xp_awk_run_t* run, xp_awk_nde_t* nde);
-static xp_awk_val_t* __eval_localidx (xp_awk_run_t* run, xp_awk_nde_t* nde);
-static xp_awk_val_t* __eval_argidx (xp_awk_run_t* run, xp_awk_nde_t* nde);
-static xp_awk_val_t* __eval_pos (xp_awk_run_t* run, xp_awk_nde_t* nde);
-static xp_awk_val_t* __eval_getline (xp_awk_run_t* run, xp_awk_nde_t* nde);
+static sse_awk_val_t* __eval_int (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static sse_awk_val_t* __eval_real (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static sse_awk_val_t* __eval_str (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static sse_awk_val_t* __eval_rex (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static sse_awk_val_t* __eval_named (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static sse_awk_val_t* __eval_global (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static sse_awk_val_t* __eval_local (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static sse_awk_val_t* __eval_arg (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static sse_awk_val_t* __eval_namedidx (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static sse_awk_val_t* __eval_globalidx (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static sse_awk_val_t* __eval_localidx (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static sse_awk_val_t* __eval_argidx (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static sse_awk_val_t* __eval_pos (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static sse_awk_val_t* __eval_getline (sse_awk_run_t* run, sse_awk_nde_t* nde);
-static int __raw_push (xp_awk_run_t* run, void* val);
+static int __raw_push (sse_awk_run_t* run, void* val);
#define __raw_pop(run) \
do { \
- xp_awk_assert (run->awk, (run)->stack_top > (run)->stack_base); \
+ sse_awk_assert (run->awk, (run)->stack_top > (run)->stack_base); \
(run)->stack_top--; \
} while (0)
-static void __raw_pop_times (xp_awk_run_t* run, xp_size_t times);
+static void __raw_pop_times (sse_awk_run_t* run, sse_size_t times);
-static int __read_record (xp_awk_run_t* run);
-static int __shorten_record (xp_awk_run_t* run, xp_size_t nflds);
+static int __read_record (sse_awk_run_t* run);
+static int __shorten_record (sse_awk_run_t* run, sse_size_t nflds);
-static xp_char_t* __idxnde_to_str (
- xp_awk_run_t* run, xp_awk_nde_t* nde, xp_size_t* len);
+static sse_char_t* __idxnde_to_str (
+ sse_awk_run_t* run, sse_awk_nde_t* nde, sse_size_t* len);
-typedef xp_awk_val_t* (*binop_func_t) (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right);
-typedef xp_awk_val_t* (*eval_expr_t) (xp_awk_run_t* run, xp_awk_nde_t* nde);
+typedef sse_awk_val_t* (*binop_func_t) (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right);
+typedef sse_awk_val_t* (*eval_esser_t) (sse_awk_run_t* run, sse_awk_nde_t* nde);
/* TODO: remove this function */
-static int __printval (xp_awk_pair_t* pair, void* arg)
+static int __printval (sse_awk_pair_t* pair, void* arg)
{
- xp_printf (XP_T("%s = "), (const xp_char_t*)pair->key);
- xp_awk_printval ((xp_awk_val_t*)pair->val);
- xp_printf (XP_T("\n"));
+ sse_printf (SSE_T("%s = "), (const sse_char_t*)pair->key);
+ sse_awk_printval ((sse_awk_val_t*)pair->val);
+ sse_printf (SSE_T("\n"));
return 0;
}
-xp_size_t xp_awk_getnargs (xp_awk_run_t* run)
+sse_size_t sse_awk_getnargs (sse_awk_run_t* run)
{
- return (xp_size_t) STACK_NARGS (run);
+ return (sse_size_t) STACK_NARGS (run);
}
-xp_awk_val_t* xp_awk_getarg (xp_awk_run_t* run, xp_size_t idx)
+sse_awk_val_t* sse_awk_getarg (sse_awk_run_t* run, sse_size_t idx)
{
return STACK_ARG (run, idx);
}
-xp_awk_val_t* xp_awk_getglobal (xp_awk_run_t* run, xp_size_t idx)
+sse_awk_val_t* sse_awk_getglobal (sse_awk_run_t* run, sse_size_t idx)
{
return STACK_GLOBAL (run, idx);
}
-int xp_awk_setglobal (xp_awk_run_t* run, xp_size_t idx, xp_awk_val_t* val)
+int sse_awk_setglobal (sse_awk_run_t* run, sse_size_t idx, sse_awk_val_t* val)
{
- xp_awk_val_t* old = STACK_GLOBAL (run, idx);
- if (old->type == XP_AWK_VAL_MAP)
+ sse_awk_val_t* old = STACK_GLOBAL (run, idx);
+ if (old->type == SSE_AWK_VAL_MAP)
{
/* once a variable becomes an array,
* it cannot be changed to a scalar variable */
- PANIC_I (run, XP_AWK_EMAPTOSCALAR);
+ PANIC_I (run, SSE_AWK_EMAPTOSCALAR);
}
/* TODO: is this correct?? */
- if (val->type == XP_AWK_VAL_MAP &&
- (idx >= XP_AWK_GLOBAL_ARGC && idx <= XP_AWK_GLOBAL_SUBSEP) &&
- idx != XP_AWK_GLOBAL_ARGV)
+ if (val->type == SSE_AWK_VAL_MAP &&
+ (idx >= SSE_AWK_GLOBAL_ARGC && idx <= SSE_AWK_GLOBAL_SUBSEP) &&
+ idx != SSE_AWK_GLOBAL_ARGV)
{
/* TODO: better error code */
- PANIC_I (run, XP_AWK_ESCALARTOMAP);
+ PANIC_I (run, SSE_AWK_ESCALARTOMAP);
}
- if (idx == XP_AWK_GLOBAL_CONVFMT)
+ if (idx == SSE_AWK_GLOBAL_CONVFMT)
{
- xp_char_t* convfmt_ptr;
- xp_size_t convfmt_len;
+ sse_char_t* convfmt_ptr;
+ sse_size_t convfmt_len;
- convfmt_ptr = xp_awk_valtostr (
- run, val, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &convfmt_len);
- if (convfmt_ptr == XP_NULL) return -1;
+ convfmt_ptr = sse_awk_valtostr (
+ run, val, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &convfmt_len);
+ if (convfmt_ptr == SSE_NULL) return -1;
- if (run->global.convfmt.ptr != XP_NULL)
- XP_AWK_FREE (run->awk, run->global.convfmt.ptr);
+ if (run->global.convfmt.ptr != SSE_NULL)
+ SSE_AWK_FREE (run->awk, run->global.convfmt.ptr);
run->global.convfmt.ptr = convfmt_ptr;
run->global.convfmt.len = convfmt_len;
}
- else if (idx == XP_AWK_GLOBAL_FS)
+ else if (idx == SSE_AWK_GLOBAL_FS)
{
- xp_char_t* fs_ptr;
- xp_size_t fs_len;
+ sse_char_t* fs_ptr;
+ sse_size_t fs_len;
- if (val->type == XP_AWK_VAL_STR)
+ if (val->type == SSE_AWK_VAL_STR)
{
- fs_ptr = ((xp_awk_val_str_t*)val)->buf;
- fs_len = ((xp_awk_val_str_t*)val)->len;
+ fs_ptr = ((sse_awk_val_str_t*)val)->buf;
+ fs_len = ((sse_awk_val_str_t*)val)->len;
}
else
{
- /* due to the expression evaluation rule, the
- * regular expression can not be an assigned value */
- xp_awk_assert (run->awk, val->type != XP_AWK_VAL_REX);
+ /* due to the esseression evaluation rule, the
+ * regular esseression can not be an assigned value */
+ sse_awk_assert (run->awk, val->type != SSE_AWK_VAL_REX);
- fs_ptr = xp_awk_valtostr (
- run, val, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &fs_len);
- if (fs_ptr == XP_NULL) return -1;
+ fs_ptr = sse_awk_valtostr (
+ run, val, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &fs_len);
+ if (fs_ptr == SSE_NULL) return -1;
}
if (fs_len > 1)
{
void* rex;
- /* compile the regular expression */
+ /* compile the regular esseression */
/* TODO: use safebuild */
- rex = xp_awk_buildrex (
+ rex = sse_awk_buildrex (
run->awk, fs_ptr, fs_len, &run->errnum);
- if (rex == XP_NULL)
+ if (rex == SSE_NULL)
{
- if (val->type != XP_AWK_VAL_STR)
- XP_AWK_FREE (run->awk, fs_ptr);
+ if (val->type != SSE_AWK_VAL_STR)
+ SSE_AWK_FREE (run->awk, fs_ptr);
return -1;
}
- if (run->global.fs != XP_NULL)
+ if (run->global.fs != SSE_NULL)
{
- xp_awk_freerex (run->awk, run->global.fs);
+ sse_awk_freerex (run->awk, run->global.fs);
}
run->global.fs = rex;
}
- if (val->type != XP_AWK_VAL_STR) XP_AWK_FREE (run->awk, fs_ptr);
+ if (val->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, fs_ptr);
}
- else if (idx == XP_AWK_GLOBAL_IGNORECASE)
+ else if (idx == SSE_AWK_GLOBAL_IGNORECASE)
{
- if ((val->type == XP_AWK_VAL_INT &&
- ((xp_awk_val_int_t*)val)->val == 0) ||
- (val->type == XP_AWK_VAL_REAL &&
- ((xp_awk_val_real_t*)val)->val == 0.0) ||
- (val->type == XP_AWK_VAL_STR &&
- ((xp_awk_val_str_t*)val)->len == 0))
+ if ((val->type == SSE_AWK_VAL_INT &&
+ ((sse_awk_val_int_t*)val)->val == 0) ||
+ (val->type == SSE_AWK_VAL_REAL &&
+ ((sse_awk_val_real_t*)val)->val == 0.0) ||
+ (val->type == SSE_AWK_VAL_STR &&
+ ((sse_awk_val_str_t*)val)->len == 0))
{
run->global.ignorecase = 0;
}
@@ -318,190 +318,190 @@ int xp_awk_setglobal (xp_awk_run_t* run, xp_size_t idx, xp_awk_val_t* val)
run->global.ignorecase = 1;
}
}
- else if (idx == XP_AWK_GLOBAL_NF)
+ else if (idx == SSE_AWK_GLOBAL_NF)
{
int n;
- xp_long_t lv;
- xp_real_t rv;
+ sse_long_t lv;
+ sse_real_t rv;
- n = xp_awk_valtonum (run, val, &lv, &rv);
+ n = sse_awk_valtonum (run, val, &lv, &rv);
if (n == -1) return -1;
- if (n == 1) lv = (xp_long_t)rv;
+ if (n == 1) lv = (sse_long_t)rv;
if (lv < run->inrec.nflds)
{
- if (__shorten_record (run, (xp_size_t)lv) == -1) return -1;
+ if (__shorten_record (run, (sse_size_t)lv) == -1) return -1;
}
}
- else if (idx == XP_AWK_GLOBAL_OFMT)
+ else if (idx == SSE_AWK_GLOBAL_OFMT)
{
- xp_char_t* ofmt_ptr;
- xp_size_t ofmt_len;
+ sse_char_t* ofmt_ptr;
+ sse_size_t ofmt_len;
- ofmt_ptr = xp_awk_valtostr (
- run, val, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &ofmt_len);
- if (ofmt_ptr == XP_NULL) return -1;
+ ofmt_ptr = sse_awk_valtostr (
+ run, val, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &ofmt_len);
+ if (ofmt_ptr == SSE_NULL) return -1;
- if (run->global.ofmt.ptr != XP_NULL)
- XP_AWK_FREE (run->awk, run->global.ofmt.ptr);
+ if (run->global.ofmt.ptr != SSE_NULL)
+ SSE_AWK_FREE (run->awk, run->global.ofmt.ptr);
run->global.ofmt.ptr = ofmt_ptr;
run->global.ofmt.len = ofmt_len;
}
- else if (idx == XP_AWK_GLOBAL_OFS)
+ else if (idx == SSE_AWK_GLOBAL_OFS)
{
- xp_char_t* ofs_ptr;
- xp_size_t ofs_len;
+ sse_char_t* ofs_ptr;
+ sse_size_t ofs_len;
- ofs_ptr = xp_awk_valtostr (
- run, val, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &ofs_len);
- if (ofs_ptr == XP_NULL) return -1;
+ ofs_ptr = sse_awk_valtostr (
+ run, val, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &ofs_len);
+ if (ofs_ptr == SSE_NULL) return -1;
- if (run->global.ofs.ptr != XP_NULL)
- XP_AWK_FREE (run->awk, run->global.ofs.ptr);
+ if (run->global.ofs.ptr != SSE_NULL)
+ SSE_AWK_FREE (run->awk, run->global.ofs.ptr);
run->global.ofs.ptr = ofs_ptr;
run->global.ofs.len = ofs_len;
}
- else if (idx == XP_AWK_GLOBAL_ORS)
+ else if (idx == SSE_AWK_GLOBAL_ORS)
{
- xp_char_t* ors_ptr;
- xp_size_t ors_len;
+ sse_char_t* ors_ptr;
+ sse_size_t ors_len;
- ors_ptr = xp_awk_valtostr (
- run, val, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &ors_len);
- if (ors_ptr == XP_NULL) return -1;
+ ors_ptr = sse_awk_valtostr (
+ run, val, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &ors_len);
+ if (ors_ptr == SSE_NULL) return -1;
- if (run->global.ors.ptr != XP_NULL)
- XP_AWK_FREE (run->awk, run->global.ors.ptr);
+ if (run->global.ors.ptr != SSE_NULL)
+ SSE_AWK_FREE (run->awk, run->global.ors.ptr);
run->global.ors.ptr = ors_ptr;
run->global.ors.len = ors_len;
}
- else if (idx == XP_AWK_GLOBAL_RS)
+ else if (idx == SSE_AWK_GLOBAL_RS)
{
- xp_char_t* rs_ptr;
- xp_size_t rs_len;
+ sse_char_t* rs_ptr;
+ sse_size_t rs_len;
- if (val->type == XP_AWK_VAL_STR)
+ if (val->type == SSE_AWK_VAL_STR)
{
- rs_ptr = ((xp_awk_val_str_t*)val)->buf;
- rs_len = ((xp_awk_val_str_t*)val)->len;
+ rs_ptr = ((sse_awk_val_str_t*)val)->buf;
+ rs_len = ((sse_awk_val_str_t*)val)->len;
}
else
{
- /* due to the expression evaluation rule, the
- * regular expression can not be an assigned value */
- xp_awk_assert (run->awk, val->type != XP_AWK_VAL_REX);
+ /* due to the esseression evaluation rule, the
+ * regular esseression can not be an assigned value */
+ sse_awk_assert (run->awk, val->type != SSE_AWK_VAL_REX);
- rs_ptr = xp_awk_valtostr (
- run, val, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &rs_len);
- if (rs_ptr == XP_NULL) return -1;
+ rs_ptr = sse_awk_valtostr (
+ run, val, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &rs_len);
+ if (rs_ptr == SSE_NULL) return -1;
}
if (rs_len > 1)
{
void* rex;
- /* compile the regular expression */
+ /* compile the regular esseression */
/* TODO: use safebuild */
- rex = xp_awk_buildrex (
+ rex = sse_awk_buildrex (
run->awk, rs_ptr, rs_len, &run->errnum);
- if (rex == XP_NULL)
+ if (rex == SSE_NULL)
{
- if (val->type != XP_AWK_VAL_STR)
- XP_AWK_FREE (run->awk, rs_ptr);
+ if (val->type != SSE_AWK_VAL_STR)
+ SSE_AWK_FREE (run->awk, rs_ptr);
return -1;
}
- if (run->global.rs != XP_NULL)
+ if (run->global.rs != SSE_NULL)
{
- xp_awk_freerex (run->awk, run->global.rs);
+ sse_awk_freerex (run->awk, run->global.rs);
}
run->global.rs = rex;
}
- if (val->type != XP_AWK_VAL_STR) XP_AWK_FREE (run->awk, rs_ptr);
+ if (val->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, rs_ptr);
}
- else if (idx == XP_AWK_GLOBAL_SUBSEP)
+ else if (idx == SSE_AWK_GLOBAL_SUBSEP)
{
- xp_char_t* subsep_ptr;
- xp_size_t subsep_len;
+ sse_char_t* subsep_ptr;
+ sse_size_t subsep_len;
- subsep_ptr = xp_awk_valtostr (
- run, val, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &subsep_len);
- if (subsep_ptr == XP_NULL) return -1;
+ subsep_ptr = sse_awk_valtostr (
+ run, val, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &subsep_len);
+ if (subsep_ptr == SSE_NULL) return -1;
- if (run->global.subsep.ptr != XP_NULL)
- XP_AWK_FREE (run->awk, run->global.subsep.ptr);
+ if (run->global.subsep.ptr != SSE_NULL)
+ SSE_AWK_FREE (run->awk, run->global.subsep.ptr);
run->global.subsep.ptr = subsep_ptr;
run->global.subsep.len = subsep_len;
}
- xp_awk_refdownval (run, old);
+ sse_awk_refdownval (run, old);
STACK_GLOBAL(run,idx) = val;
- xp_awk_refupval (val);
+ sse_awk_refupval (val);
return 0;
}
-void xp_awk_setretval (xp_awk_run_t* run, xp_awk_val_t* val)
+void sse_awk_setretval (sse_awk_run_t* run, sse_awk_val_t* val)
{
- xp_awk_refdownval (run, STACK_RETVAL(run));
+ sse_awk_refdownval (run, STACK_RETVAL(run));
STACK_RETVAL(run) = val;
/* should use the same trick as __run_return_statement */
- xp_awk_refupval (val);
+ sse_awk_refupval (val);
}
-int xp_awk_setconsolename (
- xp_awk_run_t* run, const xp_char_t* name, xp_size_t len)
+int sse_awk_setconsolename (
+ sse_awk_run_t* run, const sse_char_t* name, sse_size_t len)
{
- xp_awk_val_t* tmp;
+ sse_awk_val_t* tmp;
int n;
- if (len == 0) tmp = xp_awk_val_zls;
+ if (len == 0) tmp = sse_awk_val_zls;
else
{
- tmp = xp_awk_makestrval (run, name, len);
- if (tmp == XP_NULL)
+ tmp = sse_awk_makestrval (run, name, len);
+ if (tmp == SSE_NULL)
{
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
}
- xp_awk_refupval (tmp);
- n = xp_awk_setglobal (run, XP_AWK_GLOBAL_FILENAME, tmp);
- xp_awk_refdownval (run, tmp);
+ sse_awk_refupval (tmp);
+ n = sse_awk_setglobal (run, SSE_AWK_GLOBAL_FILENAME, tmp);
+ sse_awk_refdownval (run, tmp);
return n;
}
-int xp_awk_getrunerrnum (xp_awk_run_t* run)
+int sse_awk_getrunerrnum (sse_awk_run_t* run)
{
return run->errnum;
}
-void xp_awk_setrunerrnum (xp_awk_run_t* run, int errnum)
+void sse_awk_setrunerrnum (sse_awk_run_t* run, int errnum)
{
run->errnum = errnum;
}
-int xp_awk_run (xp_awk_t* awk,
- xp_awk_runios_t* runios,
- xp_awk_runcbs_t* runcbs,
- xp_awk_runarg_t* runarg)
+int sse_awk_run (sse_awk_t* awk,
+ sse_awk_runios_t* runios,
+ sse_awk_runcbs_t* runcbs,
+ sse_awk_runarg_t* runarg)
{
- xp_awk_run_t* run;
+ sse_awk_run_t* run;
int n, errnum;
- awk->errnum = XP_AWK_ENOERR;
+ awk->errnum = SSE_AWK_ENOERR;
- run = (xp_awk_run_t*) XP_AWK_MALLOC (awk, xp_sizeof(xp_awk_run_t));
- if (run == XP_NULL)
+ run = (sse_awk_run_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_run_t));
+ if (run == SSE_NULL)
{
- awk->errnum = XP_AWK_ENOMEM;
+ awk->errnum = SSE_AWK_ENOMEM;
return -1;
}
- XP_AWK_MEMSET (awk, run, 0, xp_sizeof(xp_awk_run_t));
+ SSE_AWK_MEMSET (awk, run, 0, sse_sizeof(sse_awk_run_t));
__add_run (awk, run);
@@ -509,11 +509,11 @@ int xp_awk_run (xp_awk_t* awk,
{
awk->errnum = errnum;
__del_run (awk, run);
- XP_AWK_FREE (awk, run);
+ SSE_AWK_FREE (awk, run);
return -1;
}
- if (runcbs != XP_NULL && runcbs->on_start != XP_NULL)
+ if (runcbs != SSE_NULL && runcbs->on_start != SSE_NULL)
{
runcbs->on_start (awk, run, runcbs->custom_data);
}
@@ -523,13 +523,13 @@ int xp_awk_run (xp_awk_t* awk,
{
/* if no callback is specified, awk's error number
* is updated with the run's error number */
- awk->errnum = (runcbs == XP_NULL)? run->errnum: XP_AWK_ERUNTIME;
+ awk->errnum = (runcbs == SSE_NULL)? run->errnum: SSE_AWK_ERUNTIME;
}
- if (runcbs != XP_NULL && runcbs->on_end != XP_NULL)
+ if (runcbs != SSE_NULL && runcbs->on_end != SSE_NULL)
{
runcbs->on_end (awk, run,
- ((n == -1)? run->errnum: XP_AWK_ENOERR),
+ ((n == -1)? run->errnum: SSE_AWK_ENOERR),
runcbs->custom_data);
/* when using callbacks, the function always returns 0 after
@@ -539,100 +539,100 @@ int xp_awk_run (xp_awk_t* awk,
__deinit_run (run);
__del_run (awk, run);
- XP_AWK_FREE (awk, run);
+ SSE_AWK_FREE (awk, run);
return n;
}
-int xp_awk_stop (xp_awk_t* awk, xp_awk_run_t* run)
+int sse_awk_stop (sse_awk_t* awk, sse_awk_run_t* run)
{
- xp_awk_run_t* r;
+ sse_awk_run_t* r;
int n = 0;
- XP_AWK_LOCK (awk);
+ SSE_AWK_LOCK (awk);
/* check if the run handle given is valid */
- for (r = awk->run.ptr; r != XP_NULL; r = r->next)
+ for (r = awk->run.ptr; r != SSE_NULL; r = r->next)
{
if (r == run)
{
- xp_awk_assert (run->awk, r->awk == awk);
+ sse_awk_assert (run->awk, r->awk == awk);
r->exit_level = EXIT_ABORT;
break;
}
}
- if (r == XP_NULL)
+ if (r == SSE_NULL)
{
/* if it is not found in the awk's run list,
* it is not a valid handle */
- awk->errnum = XP_AWK_EINVAL;
+ awk->errnum = SSE_AWK_EINVAL;
n = -1;
}
- XP_AWK_UNLOCK (awk);
+ SSE_AWK_UNLOCK (awk);
return n;
}
-void xp_awk_stopall (xp_awk_t* awk)
+void sse_awk_stopall (sse_awk_t* awk)
{
- xp_awk_run_t* r;
+ sse_awk_run_t* r;
- XP_AWK_LOCK (awk);
+ SSE_AWK_LOCK (awk);
- for (r = awk->run.ptr; r != XP_NULL; r = r->next)
+ for (r = awk->run.ptr; r != SSE_NULL; r = r->next)
{
r->exit_level = EXIT_ABORT;
}
- XP_AWK_UNLOCK (awk);
+ SSE_AWK_UNLOCK (awk);
}
static void __free_namedval (void* run, void* val)
{
- xp_awk_refdownval ((xp_awk_run_t*)run, val);
+ sse_awk_refdownval ((sse_awk_run_t*)run, val);
}
-static void __add_run (xp_awk_t* awk, xp_awk_run_t* run)
+static void __add_run (sse_awk_t* awk, sse_awk_run_t* run)
{
- XP_AWK_LOCK (awk);
+ SSE_AWK_LOCK (awk);
run->awk = awk;
- run->prev = XP_NULL;
+ run->prev = SSE_NULL;
run->next = awk->run.ptr;
- if (run->next != XP_NULL) run->next->prev = run;
+ if (run->next != SSE_NULL) run->next->prev = run;
awk->run.ptr = run;
awk->run.count++;
- XP_AWK_UNLOCK (awk);
+ SSE_AWK_UNLOCK (awk);
}
-static void __del_run (xp_awk_t* awk, xp_awk_run_t* run)
+static void __del_run (sse_awk_t* awk, sse_awk_run_t* run)
{
- XP_AWK_LOCK (awk);
+ SSE_AWK_LOCK (awk);
- xp_awk_assert (run->awk, awk->run.ptr != XP_NULL);
+ sse_awk_assert (run->awk, awk->run.ptr != SSE_NULL);
- if (run->prev == XP_NULL)
+ if (run->prev == SSE_NULL)
{
awk->run.ptr = run->next;
- if (run->next != XP_NULL) run->next->prev = XP_NULL;
+ if (run->next != SSE_NULL) run->next->prev = SSE_NULL;
}
else
{
run->prev->next = run->next;
- if (run->next != XP_NULL) run->next->prev = run->prev;
+ if (run->next != SSE_NULL) run->next->prev = run->prev;
}
- run->awk = XP_NULL;
+ run->awk = SSE_NULL;
awk->run.count--;
- XP_AWK_UNLOCK (awk);
+ SSE_AWK_UNLOCK (awk);
}
-static int __init_run (xp_awk_run_t* run, xp_awk_runios_t* runios, int* errnum)
+static int __init_run (sse_awk_run_t* run, sse_awk_runios_t* runios, int* errnum)
{
- run->stack = XP_NULL;
+ run->stack = SSE_NULL;
run->stack_top = 0;
run->stack_base = 0;
run->stack_limit = 0;
@@ -643,241 +643,241 @@ static int __init_run (xp_awk_run_t* run, xp_awk_runios_t* runios, int* errnum)
run->rcache_count = 0;
run->fcache_count = 0;
- run->errnum = XP_AWK_ENOERR;
+ run->errnum = SSE_AWK_ENOERR;
run->inrec.buf_pos = 0;
run->inrec.buf_len = 0;
- run->inrec.flds = XP_NULL;
+ run->inrec.flds = SSE_NULL;
run->inrec.nflds = 0;
run->inrec.maxflds = 0;
- run->inrec.d0 = xp_awk_val_nil;
- if (xp_awk_str_open (
- &run->inrec.line, DEF_BUF_CAPA, run->awk) == XP_NULL)
+ run->inrec.d0 = sse_awk_val_nil;
+ if (sse_awk_str_open (
+ &run->inrec.line, DEF_BUF_CAPA, run->awk) == SSE_NULL)
{
- *errnum = XP_AWK_ENOMEM;
+ *errnum = SSE_AWK_ENOMEM;
return -1;
}
- if (xp_awk_map_open (&run->named,
- run, DEF_BUF_CAPA, __free_namedval, run->awk) == XP_NULL)
+ if (sse_awk_map_open (&run->named,
+ run, DEF_BUF_CAPA, __free_namedval, run->awk) == SSE_NULL)
{
- xp_awk_str_close (&run->inrec.line);
- *errnum = XP_AWK_ENOMEM;
+ sse_awk_str_close (&run->inrec.line);
+ *errnum = SSE_AWK_ENOMEM;
return -1;
}
- run->pattern_range_state = (xp_byte_t*) XP_AWK_MALLOC (
- run->awk, run->awk->tree.chain_size * xp_sizeof(xp_byte_t));
- if (run->pattern_range_state == XP_NULL)
+ run->pattern_range_state = (sse_byte_t*) SSE_AWK_MALLOC (
+ run->awk, run->awk->tree.chain_size * sse_sizeof(sse_byte_t));
+ if (run->pattern_range_state == SSE_NULL)
{
- xp_awk_map_close (&run->named);
- xp_awk_str_close (&run->inrec.line);
- *errnum = XP_AWK_ENOMEM;
+ sse_awk_map_close (&run->named);
+ sse_awk_str_close (&run->inrec.line);
+ *errnum = SSE_AWK_ENOMEM;
return -1;
}
- XP_AWK_MEMSET (run->awk, run->pattern_range_state, 0,
- run->awk->tree.chain_size * xp_sizeof(xp_byte_t));
+ SSE_AWK_MEMSET (run->awk, run->pattern_range_state, 0,
+ run->awk->tree.chain_size * sse_sizeof(sse_byte_t));
- run->extio.handler[XP_AWK_EXTIO_PIPE] = runios->pipe;
- run->extio.handler[XP_AWK_EXTIO_COPROC] = runios->coproc;
- run->extio.handler[XP_AWK_EXTIO_FILE] = runios->file;
- run->extio.handler[XP_AWK_EXTIO_CONSOLE] = runios->console;
+ run->extio.handler[SSE_AWK_EXTIO_PIPE] = runios->pipe;
+ run->extio.handler[SSE_AWK_EXTIO_COPROC] = runios->coproc;
+ run->extio.handler[SSE_AWK_EXTIO_FILE] = runios->file;
+ run->extio.handler[SSE_AWK_EXTIO_CONSOLE] = runios->console;
run->extio.custom_data = runios->custom_data;
- run->extio.chain = XP_NULL;
+ run->extio.chain = SSE_NULL;
- run->global.rs = XP_NULL;
- run->global.fs = XP_NULL;
+ run->global.rs = SSE_NULL;
+ run->global.fs = SSE_NULL;
run->global.ignorecase = 0;
return 0;
}
-static void __deinit_run (xp_awk_run_t* run)
+static void __deinit_run (sse_awk_run_t* run)
{
- XP_AWK_FREE (run->awk, run->pattern_range_state);
+ SSE_AWK_FREE (run->awk, run->pattern_range_state);
/* close all pending eio's */
/* TODO: what if this operation fails? */
- xp_awk_clearextio (run);
- xp_awk_assert (run->awk, run->extio.chain == XP_NULL);
+ sse_awk_clearextio (run);
+ sse_awk_assert (run->awk, run->extio.chain == SSE_NULL);
- if (run->global.rs != XP_NULL)
+ if (run->global.rs != SSE_NULL)
{
- XP_AWK_FREE (run->awk, run->global.rs);
- run->global.rs = XP_NULL;
+ SSE_AWK_FREE (run->awk, run->global.rs);
+ run->global.rs = SSE_NULL;
}
- if (run->global.fs != XP_NULL)
+ if (run->global.fs != SSE_NULL)
{
- XP_AWK_FREE (run->awk, run->global.fs);
- run->global.fs = XP_NULL;
+ SSE_AWK_FREE (run->awk, run->global.fs);
+ run->global.fs = SSE_NULL;
}
- if (run->global.convfmt.ptr != XP_NULL &&
+ if (run->global.convfmt.ptr != SSE_NULL &&
run->global.convfmt.ptr != DEFAULT_CONVFMT)
{
- XP_AWK_FREE (run->awk, run->global.convfmt.ptr);
- run->global.convfmt.ptr = XP_NULL;
+ SSE_AWK_FREE (run->awk, run->global.convfmt.ptr);
+ run->global.convfmt.ptr = SSE_NULL;
run->global.convfmt.len = 0;
}
- if (run->global.ofmt.ptr != XP_NULL &&
+ if (run->global.ofmt.ptr != SSE_NULL &&
run->global.ofmt.ptr != DEFAULT_OFMT)
{
- XP_AWK_FREE (run->awk, run->global.ofmt.ptr);
- run->global.ofmt.ptr = XP_NULL;
+ SSE_AWK_FREE (run->awk, run->global.ofmt.ptr);
+ run->global.ofmt.ptr = SSE_NULL;
run->global.ofmt.len = 0;
}
- if (run->global.ofs.ptr != XP_NULL &&
+ if (run->global.ofs.ptr != SSE_NULL &&
run->global.ofs.ptr != DEFAULT_OFS)
{
- XP_AWK_FREE (run->awk, run->global.ofs.ptr);
- run->global.ofs.ptr = XP_NULL;
+ SSE_AWK_FREE (run->awk, run->global.ofs.ptr);
+ run->global.ofs.ptr = SSE_NULL;
run->global.ofs.len = 0;
}
- if (run->global.ors.ptr != XP_NULL &&
+ if (run->global.ors.ptr != SSE_NULL &&
run->global.ors.ptr != DEFAULT_ORS)
{
- XP_AWK_FREE (run->awk, run->global.ors.ptr);
- run->global.ors.ptr = XP_NULL;
+ SSE_AWK_FREE (run->awk, run->global.ors.ptr);
+ run->global.ors.ptr = SSE_NULL;
run->global.ors.len = 0;
}
- if (run->global.subsep.ptr != XP_NULL &&
+ if (run->global.subsep.ptr != SSE_NULL &&
run->global.subsep.ptr != DEFAULT_SUBSEP)
{
- XP_AWK_FREE (run->awk, run->global.subsep.ptr);
- run->global.subsep.ptr = XP_NULL;
+ SSE_AWK_FREE (run->awk, run->global.subsep.ptr);
+ run->global.subsep.ptr = SSE_NULL;
run->global.subsep.len = 0;
}
- /* destroy input record. xp_awk_clrrec should be called
+ /* destroy input record. sse_awk_clrrec should be called
* before the run stack has been destroyed because it may try
- * to change the value to XP_AWK_GLOBAL_NF. */
- xp_awk_clrrec (run, xp_false);
- if (run->inrec.flds != XP_NULL)
+ * to change the value to SSE_AWK_GLOBAL_NF. */
+ sse_awk_clrrec (run, sse_false);
+ if (run->inrec.flds != SSE_NULL)
{
- XP_AWK_FREE (run->awk, run->inrec.flds);
- run->inrec.flds = XP_NULL;
+ SSE_AWK_FREE (run->awk, run->inrec.flds);
+ run->inrec.flds = SSE_NULL;
run->inrec.maxflds = 0;
}
- xp_awk_str_close (&run->inrec.line);
+ sse_awk_str_close (&run->inrec.line);
/* destroy run stack */
- if (run->stack != XP_NULL)
+ if (run->stack != SSE_NULL)
{
- xp_awk_assert (run->awk, run->stack_top == 0);
+ sse_awk_assert (run->awk, run->stack_top == 0);
- XP_AWK_FREE (run->awk, run->stack);
- run->stack = XP_NULL;
+ SSE_AWK_FREE (run->awk, run->stack);
+ run->stack = SSE_NULL;
run->stack_top = 0;
run->stack_base = 0;
run->stack_limit = 0;
}
/* destroy named variables */
- xp_awk_map_close (&run->named);
+ sse_awk_map_close (&run->named);
/* destroy values in free list */
while (run->icache_count > 0)
{
- xp_awk_val_int_t* tmp = run->icache[--run->icache_count];
- xp_awk_freeval (run, (xp_awk_val_t*)tmp, xp_false);
+ sse_awk_val_int_t* tmp = run->icache[--run->icache_count];
+ sse_awk_freeval (run, (sse_awk_val_t*)tmp, sse_false);
}
while (run->rcache_count > 0)
{
- xp_awk_val_real_t* tmp = run->rcache[--run->rcache_count];
- xp_awk_freeval (run, (xp_awk_val_t*)tmp, xp_false);
+ sse_awk_val_real_t* tmp = run->rcache[--run->rcache_count];
+ sse_awk_freeval (run, (sse_awk_val_t*)tmp, sse_false);
}
while (run->fcache_count > 0)
{
- xp_awk_val_ref_t* tmp = run->fcache[--run->fcache_count];
- xp_awk_freeval (run, (xp_awk_val_t*)tmp, xp_false);
+ sse_awk_val_ref_t* tmp = run->fcache[--run->fcache_count];
+ sse_awk_freeval (run, (sse_awk_val_t*)tmp, sse_false);
}
}
-static int __build_runarg (xp_awk_run_t* run, xp_awk_runarg_t* runarg)
+static int __build_runarg (sse_awk_run_t* run, sse_awk_runarg_t* runarg)
{
- xp_awk_runarg_t* p = runarg;
- xp_size_t argc;
- xp_awk_val_t* v_argc;
- xp_awk_val_t* v_argv;
- xp_awk_val_t* v_tmp;
- xp_char_t key[xp_sizeof(xp_long_t)*8+2];
- xp_size_t key_len;
+ sse_awk_runarg_t* p = runarg;
+ sse_size_t argc;
+ sse_awk_val_t* v_argc;
+ sse_awk_val_t* v_argv;
+ sse_awk_val_t* v_tmp;
+ sse_char_t key[sse_sizeof(sse_long_t)*8+2];
+ sse_size_t key_len;
- v_argv = xp_awk_makemapval (run);
- if (v_argv == XP_NULL)
+ v_argv = sse_awk_makemapval (run);
+ if (v_argv == SSE_NULL)
{
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
- xp_awk_refupval (v_argv);
+ sse_awk_refupval (v_argv);
- if (runarg == XP_NULL) argc = 0;
+ if (runarg == SSE_NULL) argc = 0;
else
{
- for (argc = 0, p = runarg; p->ptr != XP_NULL; argc++, p++)
+ for (argc = 0, p = runarg; p->ptr != SSE_NULL; argc++, p++)
{
- v_tmp = xp_awk_makestrval (run, p->ptr, p->len);
- if (v_tmp == XP_NULL)
+ v_tmp = sse_awk_makestrval (run, p->ptr, p->len);
+ if (v_tmp == SSE_NULL)
{
- xp_awk_refdownval (run, v_argv);
- run->errnum = XP_AWK_ENOMEM;
+ sse_awk_refdownval (run, v_argv);
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
- key_len = xp_awk_longtostr (
- argc, 10, XP_NULL, key, xp_countof(key));
- xp_awk_assert (run->awk, key_len != (xp_size_t)-1);
+ key_len = sse_awk_longtostr (
+ argc, 10, SSE_NULL, key, sse_countof(key));
+ sse_awk_assert (run->awk, key_len != (sse_size_t)-1);
/* increment reference count of v_tmp in advance as if
* it has successfully been assigned into ARGV. */
- xp_awk_refupval (v_tmp);
+ sse_awk_refupval (v_tmp);
- if (xp_awk_map_putx (
- ((xp_awk_val_map_t*)v_argv)->map,
- key, key_len, v_tmp, XP_NULL) == -1)
+ if (sse_awk_map_putx (
+ ((sse_awk_val_map_t*)v_argv)->map,
+ key, key_len, v_tmp, SSE_NULL) == -1)
{
/* if the assignment operation fails, decrements
* the reference of v_tmp to free it */
- xp_awk_refdownval (run, v_tmp);
+ sse_awk_refdownval (run, v_tmp);
/* the values previously assigned into the
* map will be freeed when v_argv is freed */
- xp_awk_refdownval (run, v_argv);
+ sse_awk_refdownval (run, v_argv);
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
}
}
- v_argc = xp_awk_makeintval (run, (xp_long_t)argc);
- if (v_argc == XP_NULL)
+ v_argc = sse_awk_makeintval (run, (sse_long_t)argc);
+ if (v_argc == SSE_NULL)
{
- xp_awk_refdownval (run, v_argv);
- run->errnum = XP_AWK_ENOMEM;
+ sse_awk_refdownval (run, v_argv);
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
- xp_awk_refupval (v_argc);
+ sse_awk_refupval (v_argc);
- xp_awk_assert (run->awk,
- STACK_GLOBAL(run,XP_AWK_GLOBAL_ARGC) == xp_awk_val_nil);
+ sse_awk_assert (run->awk,
+ STACK_GLOBAL(run,SSE_AWK_GLOBAL_ARGC) == sse_awk_val_nil);
- if (xp_awk_setglobal (run, XP_AWK_GLOBAL_ARGC, v_argc) == -1)
+ if (sse_awk_setglobal (run, SSE_AWK_GLOBAL_ARGC, v_argc) == -1)
{
- xp_awk_refdownval (run, v_argc);
- xp_awk_refdownval (run, v_argv);
+ sse_awk_refdownval (run, v_argc);
+ sse_awk_refdownval (run, v_argv);
return -1;
}
- if (xp_awk_setglobal (run, XP_AWK_GLOBAL_ARGV, v_argv) == -1)
+ if (sse_awk_setglobal (run, SSE_AWK_GLOBAL_ARGV, v_argv) == -1)
{
/* ARGC is assigned nil when ARGV assignment has failed.
* However, this requires preconditions, as follows:
@@ -885,108 +885,108 @@ static int __build_runarg (xp_awk_run_t* run, xp_awk_runarg_t* runarg)
* as it is not a generic-purpose routine.
* 2. ARGC should be nil before __build_runarg is called
* If the restoration fails, nothing can salvage it. */
- xp_awk_setglobal (run, XP_AWK_GLOBAL_ARGC, xp_awk_val_nil);
- xp_awk_refdownval (run, v_argc);
- xp_awk_refdownval (run, v_argv);
+ sse_awk_setglobal (run, SSE_AWK_GLOBAL_ARGC, sse_awk_val_nil);
+ sse_awk_refdownval (run, v_argc);
+ sse_awk_refdownval (run, v_argv);
return -1;
}
- xp_awk_refdownval (run, v_argc);
- xp_awk_refdownval (run, v_argv);
+ sse_awk_refdownval (run, v_argc);
+ sse_awk_refdownval (run, v_argv);
return 0;
}
-static int __update_fnr (xp_awk_run_t* run, xp_size_t fnr)
+static int __update_fnr (sse_awk_run_t* run, sse_size_t fnr)
{
- xp_awk_val_t* tmp;
+ sse_awk_val_t* tmp;
- tmp = xp_awk_makeintval (run, fnr);
- if (tmp == XP_NULL)
+ tmp = sse_awk_makeintval (run, fnr);
+ if (tmp == SSE_NULL)
{
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
- xp_awk_refupval (tmp);
- if (xp_awk_setglobal (run, XP_AWK_GLOBAL_FNR, tmp) == -1)
+ sse_awk_refupval (tmp);
+ if (sse_awk_setglobal (run, SSE_AWK_GLOBAL_FNR, tmp) == -1)
{
- xp_awk_refdownval (run, tmp);
+ sse_awk_refdownval (run, tmp);
return -1;
}
- xp_awk_refdownval (run, tmp);
+ sse_awk_refdownval (run, tmp);
run->global.fnr = fnr;
return 0;
}
-static int __set_globals_to_default (xp_awk_run_t* run)
+static int __set_globals_to_default (sse_awk_run_t* run)
{
struct __gtab_t
{
int idx;
- const xp_char_t* str;
+ const sse_char_t* str;
};
static struct __gtab_t gtab[] =
{
- { XP_AWK_GLOBAL_CONVFMT, DEFAULT_CONVFMT },
- { XP_AWK_GLOBAL_FILENAME, XP_NULL },
- { XP_AWK_GLOBAL_OFMT, DEFAULT_OFMT },
- { XP_AWK_GLOBAL_OFS, DEFAULT_OFS },
- { XP_AWK_GLOBAL_ORS, DEFAULT_ORS },
- { XP_AWK_GLOBAL_SUBSEP, DEFAULT_SUBSEP },
+ { SSE_AWK_GLOBAL_CONVFMT, DEFAULT_CONVFMT },
+ { SSE_AWK_GLOBAL_FILENAME, SSE_NULL },
+ { SSE_AWK_GLOBAL_OFMT, DEFAULT_OFMT },
+ { SSE_AWK_GLOBAL_OFS, DEFAULT_OFS },
+ { SSE_AWK_GLOBAL_ORS, DEFAULT_ORS },
+ { SSE_AWK_GLOBAL_SUBSEP, DEFAULT_SUBSEP },
};
- xp_awk_val_t* tmp;
- xp_size_t i, j;
+ sse_awk_val_t* tmp;
+ sse_size_t i, j;
- for (i = 0; i < xp_countof(gtab); i++)
+ for (i = 0; i < sse_countof(gtab); i++)
{
- if (gtab[i].str == XP_NULL || gtab[i].str[0] == XP_T('\0'))
+ if (gtab[i].str == SSE_NULL || gtab[i].str[0] == SSE_T('\0'))
{
- tmp = xp_awk_val_zls;
+ tmp = sse_awk_val_zls;
}
else
{
- tmp = xp_awk_makestrval0 (run, gtab[i].str);
- if (tmp == XP_NULL)
+ tmp = sse_awk_makestrval0 (run, gtab[i].str);
+ if (tmp == SSE_NULL)
{
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
}
- xp_awk_refupval (tmp);
+ sse_awk_refupval (tmp);
- xp_awk_assert (run->awk,
- STACK_GLOBAL(run,gtab[i].idx) == xp_awk_val_nil);
+ sse_awk_assert (run->awk,
+ STACK_GLOBAL(run,gtab[i].idx) == sse_awk_val_nil);
- if (xp_awk_setglobal (run, gtab[i].idx, tmp) == -1)
+ if (sse_awk_setglobal (run, gtab[i].idx, tmp) == -1)
{
for (j = 0; j < i; j++)
{
- xp_awk_setglobal (
- run, gtab[i].idx, xp_awk_val_nil);
+ sse_awk_setglobal (
+ run, gtab[i].idx, sse_awk_val_nil);
}
- xp_awk_refdownval (run, tmp);
+ sse_awk_refdownval (run, tmp);
return -1;
}
- xp_awk_refdownval (run, tmp);
+ sse_awk_refdownval (run, tmp);
}
return 0;
}
-static int __run_main (xp_awk_run_t* run, xp_awk_runarg_t* runarg)
+static int __run_main (sse_awk_run_t* run, sse_awk_runarg_t* runarg)
{
- xp_size_t nglobals, nargs, i;
- xp_size_t saved_stack_top;
- xp_awk_val_t* v;
+ sse_size_t nglobals, nargs, i;
+ sse_size_t saved_stack_top;
+ sse_awk_val_t* v;
int n;
- xp_awk_assert (run->awk, run->stack_base == 0 && run->stack_top == 0);
+ sse_awk_assert (run->awk, run->stack_base == 0 && run->stack_top == 0);
/* secure space for global variables */
saved_stack_top = run->stack_top;
@@ -996,40 +996,40 @@ static int __run_main (xp_awk_run_t* run, xp_awk_runarg_t* runarg)
while (nglobals > 0)
{
--nglobals;
- if (__raw_push(run,xp_awk_val_nil) == -1)
+ if (__raw_push(run,sse_awk_val_nil) == -1)
{
/* restore the stack_top with the saved value
* instead of calling __raw_pop as many times as
* the successful __raw_push. it is ok because
- * the values pushed so far are all xp_awk_val_nil */
+ * the values pushed so far are all sse_awk_val_nil */
run->stack_top = saved_stack_top;
- PANIC_I (run, XP_AWK_ENOMEM);
+ PANIC_I (run, SSE_AWK_ENOMEM);
}
}
- if (xp_awk_setglobal (run, XP_AWK_GLOBAL_NR, xp_awk_val_zero) == -1)
+ if (sse_awk_setglobal (run, SSE_AWK_GLOBAL_NR, sse_awk_val_zero) == -1)
{
/* it can simply restore the top of the stack this way
* because the values pused onto the stack so far are
- * all xp_awk_val_nils */
+ * all sse_awk_val_nils */
run->stack_top = saved_stack_top;
return -1;
}
- if (xp_awk_setglobal (run, XP_AWK_GLOBAL_NF, xp_awk_val_zero) == -1)
+ if (sse_awk_setglobal (run, SSE_AWK_GLOBAL_NF, sse_awk_val_zero) == -1)
{
/* it can simply restore the top of the stack this way
* because the values pused onto the stack so far are
- * all xp_awk_val_nils and xp_awk_val_zeros */
+ * all sse_awk_val_nils and sse_awk_val_zeros */
run->stack_top = saved_stack_top;
return -1;
}
- if (runarg != XP_NULL && __build_runarg (run, runarg) == -1)
+ if (runarg != SSE_NULL && __build_runarg (run, runarg) == -1)
{
/* it can simply restore the top of the stack this way
* because the values pused onto the stack so far are
- * all xp_awk_val_nils and xp_awk_val_zeros and
+ * all sse_awk_val_nils and sse_awk_val_zeros and
* __build_runarg doesn't push other values than them
* when it has failed */
run->stack_top = saved_stack_top;
@@ -1040,25 +1040,25 @@ static int __run_main (xp_awk_run_t* run, xp_awk_runarg_t* runarg)
n = __update_fnr (run, 0);
if (n == 0) n = __set_globals_to_default (run);
- if (n == 0 && (run->awk->option & XP_AWK_RUNMAIN))
+ if (n == 0 && (run->awk->option & SSE_AWK_RUNMAIN))
{
/* TODO: should the main function be user-specifiable? */
- xp_awk_nde_call_t nde;
+ sse_awk_nde_call_t nde;
- nde.type = XP_AWK_NDE_AFN;
- nde.next = XP_NULL;
- nde.what.afn.name = XP_T("main");
+ nde.type = SSE_AWK_NDE_AFN;
+ nde.next = SSE_NULL;
+ nde.what.afn.name = SSE_T("main");
nde.what.afn.name_len = 4;
- nde.args = XP_NULL;
+ nde.args = SSE_NULL;
nde.nargs = 0;
- v = __eval_afn (run, (xp_awk_nde_t*)&nde);
- if (v == XP_NULL) n = -1;
+ v = __eval_afn (run, (sse_awk_nde_t*)&nde);
+ if (v == SSE_NULL) n = -1;
else
{
/* destroy the return value if necessary */
- xp_awk_refupval (v);
- xp_awk_refdownval (run, v);
+ sse_awk_refupval (v);
+ sse_awk_refdownval (run, v);
}
}
else if (n == 0)
@@ -1070,30 +1070,30 @@ static int __run_main (xp_awk_run_t* run, xp_awk_runarg_t* runarg)
run->stack_top = saved_stack_top;
/* pops off global variables in a decent way */
__raw_pop_times (run, run->awk->tree.nglobals);
- PANIC_I (run, XP_AWK_ENOMEM);
+ PANIC_I (run, SSE_AWK_ENOMEM);
}
if (__raw_push(run,(void*)saved_stack_top) == -1)
{
run->stack_top = saved_stack_top;
__raw_pop_times (run, run->awk->tree.nglobals);
- PANIC_I (run, XP_AWK_ENOMEM);
+ PANIC_I (run, SSE_AWK_ENOMEM);
}
/* secure space for a return value */
- if (__raw_push(run,xp_awk_val_nil) == -1)
+ if (__raw_push(run,sse_awk_val_nil) == -1)
{
run->stack_top = saved_stack_top;
__raw_pop_times (run, run->awk->tree.nglobals);
- PANIC_I (run, XP_AWK_ENOMEM);
+ PANIC_I (run, SSE_AWK_ENOMEM);
}
/* secure space for nargs */
- if (__raw_push(run,xp_awk_val_nil) == -1)
+ if (__raw_push(run,sse_awk_val_nil) == -1)
{
run->stack_top = saved_stack_top;
__raw_pop_times (run, run->awk->tree.nglobals);
- PANIC_I (run, XP_AWK_ENOMEM);
+ PANIC_I (run, SSE_AWK_ENOMEM);
}
run->stack_base = saved_stack_top;
@@ -1104,13 +1104,13 @@ static int __run_main (xp_awk_run_t* run, xp_awk_runarg_t* runarg)
/* stack set up properly. ready to exeucte statement blocks */
if (n == 0 &&
- run->awk->tree.begin != XP_NULL &&
+ run->awk->tree.begin != SSE_NULL &&
run->exit_level != EXIT_ABORT)
{
- xp_awk_nde_blk_t* blk;
+ sse_awk_nde_blk_t* blk;
- blk = (xp_awk_nde_blk_t*)run->awk->tree.begin;
- xp_awk_assert (run->awk, blk->type == XP_AWK_NDE_BLK);
+ blk = (sse_awk_nde_blk_t*)run->awk->tree.begin;
+ sse_awk_assert (run->awk, blk->type == SSE_AWK_NDE_BLK);
run->active_block = blk;
run->exit_level = EXIT_NONE;
@@ -1118,20 +1118,20 @@ static int __run_main (xp_awk_run_t* run, xp_awk_runarg_t* runarg)
}
if (n == 0 &&
- run->awk->tree.chain != XP_NULL &&
+ run->awk->tree.chain != SSE_NULL &&
run->exit_level != EXIT_ABORT)
{
if (__run_pattern_blocks (run) == -1) n = -1;
}
if (n == 0 &&
- run->awk->tree.end != XP_NULL &&
+ run->awk->tree.end != SSE_NULL &&
run->exit_level != EXIT_ABORT)
{
- xp_awk_nde_blk_t* blk;
+ sse_awk_nde_blk_t* blk;
- blk = (xp_awk_nde_blk_t*)run->awk->tree.end;
- xp_awk_assert (run->awk, blk->type == XP_AWK_NDE_BLK);
+ blk = (sse_awk_nde_blk_t*)run->awk->tree.end;
+ sse_awk_assert (run->awk, blk->type == SSE_AWK_NDE_BLK);
run->active_block = blk;
run->exit_level = EXIT_NONE;
@@ -1139,26 +1139,26 @@ static int __run_main (xp_awk_run_t* run, xp_awk_runarg_t* runarg)
}
/* restore stack */
- nargs = (xp_size_t)STACK_NARGS(run);
- xp_awk_assert (run->awk, nargs == 0);
+ nargs = (sse_size_t)STACK_NARGS(run);
+ sse_awk_assert (run->awk, nargs == 0);
for (i = 0; i < nargs; i++)
{
- xp_awk_refdownval (run, STACK_ARG(run,i));
+ sse_awk_refdownval (run, STACK_ARG(run,i));
}
v = STACK_RETVAL(run);
-xp_printf (XP_T("Return Value - "));
-xp_awk_printval (v);
-xp_printf (XP_T("\n"));
+sse_printf (SSE_T("Return Value - "));
+sse_awk_printval (v);
+sse_printf (SSE_T("\n"));
/* the life of the global return value is over here
* unlike the return value of each function */
- /*xp_awk_refdownval_nofree (awk, v);*/
- xp_awk_refdownval (run, v);
+ /*sse_awk_refdownval_nofree (awk, v);*/
+ sse_awk_refdownval (run, v);
run->stack_top =
- (xp_size_t)run->stack[run->stack_base+1];
+ (sse_size_t)run->stack[run->stack_base+1];
run->stack_base =
- (xp_size_t)run->stack[run->stack_base+0];
+ (sse_size_t)run->stack[run->stack_base+0];
}
/* pops off the global variables */
@@ -1166,28 +1166,28 @@ xp_printf (XP_T("\n"));
while (nglobals > 0)
{
--nglobals;
- xp_awk_refdownval (run, STACK_GLOBAL(run,nglobals));
+ sse_awk_refdownval (run, STACK_GLOBAL(run,nglobals));
__raw_pop (run);
}
/* just reset the exit level */
run->exit_level = EXIT_NONE;
-xp_printf (XP_T("-[VARIABLES]------------------------\n"));
-xp_awk_map_walk (&run->named, __printval, XP_NULL);
-xp_printf (XP_T("-[END VARIABLES]--------------------------\n"));
+sse_printf (SSE_T("-[VARIABLES]------------------------\n"));
+sse_awk_map_walk (&run->named, __printval, SSE_NULL);
+sse_printf (SSE_T("-[END VARIABLES]--------------------------\n"));
return n;
}
-static int __run_pattern_blocks (xp_awk_run_t* run)
+static int __run_pattern_blocks (sse_awk_run_t* run)
{
- xp_ssize_t n;
- xp_bool_t need_to_close = xp_false;
+ sse_ssize_t n;
+ sse_bool_t need_to_close = sse_false;
run->inrec.buf_pos = 0;
run->inrec.buf_len = 0;
- run->inrec.eof = xp_false;
+ run->inrec.eof = sse_false;
/* run each pattern block */
while (run->exit_level != EXIT_GLOBAL &&
@@ -1203,14 +1203,14 @@ static int __run_pattern_blocks (xp_awk_run_t* run)
int saved = run->errnum;
/* don't care about the result of input close */
- xp_awk_closeextio_read (
- run, XP_AWK_IN_CONSOLE, XP_T(""));
+ sse_awk_closeextio_read (
+ run, SSE_AWK_IN_CONSOLE, SSE_T(""));
run->errnum = saved;
return -1;
}
- need_to_close = xp_true;
+ need_to_close = sse_true;
if (x == 0) break; /* end of input */
__update_fnr (run, run->global.fnr + 1);
@@ -1219,8 +1219,8 @@ static int __run_pattern_blocks (xp_awk_run_t* run)
{
int saved = run->errnum;
- xp_awk_closeextio_read (
- run, XP_AWK_IN_CONSOLE, XP_T(""));
+ sse_awk_closeextio_read (
+ run, SSE_AWK_IN_CONSOLE, SSE_T(""));
run->errnum = saved;
return -1;
@@ -1230,18 +1230,18 @@ static int __run_pattern_blocks (xp_awk_run_t* run)
/* In case of getline, the code would make getline return -1,
* set ERRNO, make this function return 0 after having checked
* if closextio has returned -1 and errnum has been set to
- * XP_AWK_EIOHANDLER. But this part of the code ends the input for
+ * SSE_AWK_EIOHANDLER. But this part of the code ends the input for
* the implicit pattern-block loop, which is totally different
* from getline. so it returns -1 as long as closeextio returns
* -1 regardless of the value of errnum. */
if (need_to_close)
{
- n = xp_awk_closeextio_read (
- run, XP_AWK_IN_CONSOLE, XP_T(""));
+ n = sse_awk_closeextio_read (
+ run, SSE_AWK_IN_CONSOLE, SSE_T(""));
if (n == -1)
{
- if (run->errnum == XP_AWK_EIOHANDLER)
- PANIC_I (run, XP_AWK_ECONINCLOSE);
+ if (run->errnum == SSE_AWK_EIOHANDLER)
+ PANIC_I (run, SSE_AWK_ECONINCLOSE);
else return -1;
}
}
@@ -1249,12 +1249,12 @@ static int __run_pattern_blocks (xp_awk_run_t* run)
return 0;
}
-static int __run_pattern_block_chain (xp_awk_run_t* run, xp_awk_chain_t* chain)
+static int __run_pattern_block_chain (sse_awk_run_t* run, sse_awk_chain_t* chain)
{
- xp_size_t block_no = 0;
+ sse_size_t block_no = 0;
while (run->exit_level != EXIT_GLOBAL &&
- run->exit_level != EXIT_ABORT && chain != XP_NULL)
+ run->exit_level != EXIT_ABORT && chain != SSE_NULL)
{
if (run->exit_level == EXIT_NEXT)
{
@@ -1272,15 +1272,15 @@ static int __run_pattern_block_chain (xp_awk_run_t* run, xp_awk_chain_t* chain)
}
static int __run_pattern_block (
- xp_awk_run_t* run, xp_awk_chain_t* chain, xp_size_t block_no)
+ sse_awk_run_t* run, sse_awk_chain_t* chain, sse_size_t block_no)
{
- xp_awk_nde_t* ptn;
- xp_awk_nde_blk_t* blk;
+ sse_awk_nde_t* ptn;
+ sse_awk_nde_blk_t* blk;
ptn = chain->pattern;
- blk = (xp_awk_nde_blk_t*)chain->action;
+ blk = (sse_awk_nde_blk_t*)chain->action;
- if (ptn == XP_NULL)
+ if (ptn == SSE_NULL)
{
/* just execute the block */
run->active_block = blk;
@@ -1288,74 +1288,74 @@ static int __run_pattern_block (
}
else
{
- if (ptn->next == XP_NULL)
+ if (ptn->next == SSE_NULL)
{
/* pattern { ... } */
- xp_awk_val_t* v1;
+ sse_awk_val_t* v1;
- v1 = __eval_expression (run, ptn);
- if (v1 == XP_NULL) return -1;
+ v1 = __eval_esseression (run, ptn);
+ if (v1 == SSE_NULL) return -1;
- xp_awk_refupval (v1);
+ sse_awk_refupval (v1);
- if (xp_awk_valtobool (run, v1))
+ if (sse_awk_valtobool (run, v1))
{
run->active_block = blk;
if (__run_block (run, blk) == -1)
{
- xp_awk_refdownval (run, v1);
+ sse_awk_refdownval (run, v1);
return -1;
}
}
- xp_awk_refdownval (run, v1);
+ sse_awk_refdownval (run, v1);
}
else
{
/* pattern, pattern { ... } */
- xp_awk_assert (run->awk, ptn->next->next == XP_NULL);
+ sse_awk_assert (run->awk, ptn->next->next == SSE_NULL);
if (run->pattern_range_state[block_no] == 0)
{
- xp_awk_val_t* v1;
+ sse_awk_val_t* v1;
- v1 = __eval_expression (run, ptn);
- if (v1 == XP_NULL) return -1;
- xp_awk_refupval (v1);
+ v1 = __eval_esseression (run, ptn);
+ if (v1 == SSE_NULL) return -1;
+ sse_awk_refupval (v1);
- if (xp_awk_valtobool (run, v1))
+ if (sse_awk_valtobool (run, v1))
{
run->active_block = blk;
if (__run_block (run, blk) == -1)
{
- xp_awk_refdownval (run, v1);
+ sse_awk_refdownval (run, v1);
return -1;
}
run->pattern_range_state[block_no] = 1;
}
- xp_awk_refdownval (run, v1);
+ sse_awk_refdownval (run, v1);
}
else if (run->pattern_range_state[block_no] == 1)
{
- xp_awk_val_t* v2;
+ sse_awk_val_t* v2;
- v2 = __eval_expression (run, ptn->next);
- if (v2 == XP_NULL) return -1;
- xp_awk_refupval (v2);
+ v2 = __eval_esseression (run, ptn->next);
+ if (v2 == SSE_NULL) return -1;
+ sse_awk_refupval (v2);
run->active_block = blk;
if (__run_block (run, blk) == -1)
{
- xp_awk_refdownval (run, v2);
+ sse_awk_refdownval (run, v2);
return -1;
}
- if (xp_awk_valtobool (run, v2))
+ if (sse_awk_valtobool (run, v2))
run->pattern_range_state[block_no] = 0;
- xp_awk_refdownval (run, v2);
+ sse_awk_refdownval (run, v2);
}
}
}
@@ -1363,63 +1363,63 @@ static int __run_pattern_block (
return 0;
}
-static int __run_block (xp_awk_run_t* run, xp_awk_nde_blk_t* nde)
+static int __run_block (sse_awk_run_t* run, sse_awk_nde_blk_t* nde)
{
- xp_awk_nde_t* p;
- xp_size_t nlocals;
- xp_size_t saved_stack_top;
+ sse_awk_nde_t* p;
+ sse_size_t nlocals;
+ sse_size_t saved_stack_top;
int n = 0;
- if (nde == XP_NULL)
+ if (nde == SSE_NULL)
{
/* blockless pattern - execute print $0*/
- xp_awk_refupval (run->inrec.d0);
+ sse_awk_refupval (run->inrec.d0);
- /*n = xp_awk_writeextio_val (run,
- XP_AWK_OUT_CONSOLE, XP_T(""), run->inrec.d0);*/
- n = xp_awk_writeextio_str (run,
- XP_AWK_OUT_CONSOLE, XP_T(""),
- XP_AWK_STR_BUF(&run->inrec.line),
- XP_AWK_STR_LEN(&run->inrec.line));
+ /*n = sse_awk_writeextio_val (run,
+ SSE_AWK_OUT_CONSOLE, SSE_T(""), run->inrec.d0);*/
+ n = sse_awk_writeextio_str (run,
+ SSE_AWK_OUT_CONSOLE, SSE_T(""),
+ SSE_AWK_STR_BUF(&run->inrec.line),
+ SSE_AWK_STR_LEN(&run->inrec.line));
if (n == -1)
{
- xp_awk_refdownval (run, run->inrec.d0);
+ sse_awk_refdownval (run, run->inrec.d0);
- if (run->errnum == XP_AWK_EIOHANDLER)
- PANIC_I (run, XP_AWK_ECONOUTDATA);
+ if (run->errnum == SSE_AWK_EIOHANDLER)
+ PANIC_I (run, SSE_AWK_ECONOUTDATA);
else return -1;
}
- xp_awk_refdownval (run, run->inrec.d0);
+ sse_awk_refdownval (run, run->inrec.d0);
return 0;
}
- xp_awk_assert (run->awk, nde->type == XP_AWK_NDE_BLK);
+ sse_awk_assert (run->awk, nde->type == SSE_AWK_NDE_BLK);
p = nde->body;
nlocals = nde->nlocals;
-/*xp_printf (XP_T("securing space for local variables nlocals = %d\n"), (int)nlocals);*/
+/*sse_printf (SSE_T("securing space for local variables nlocals = %d\n"), (int)nlocals);*/
saved_stack_top = run->stack_top;
/* secure space for local variables */
while (nlocals > 0)
{
--nlocals;
- if (__raw_push(run,xp_awk_val_nil) == -1)
+ if (__raw_push(run,sse_awk_val_nil) == -1)
{
/* restore stack top */
run->stack_top = saved_stack_top;
return -1;
}
- /* refupval is not required for xp_awk_val_nil */
+ /* refupval is not required for sse_awk_val_nil */
}
-/*xp_printf (XP_T("executing block statements\n"));*/
- while (p != XP_NULL && run->exit_level == EXIT_NONE)
+/*sse_printf (SSE_T("executing block statements\n"));*/
+ while (p != SSE_NULL && run->exit_level == EXIT_NONE)
{
-/*xp_printf (XP_T("running a statement\n"));*/
+/*sse_printf (SSE_T("running a statement\n"));*/
if (__run_statement(run,p) == -1)
{
n = -1;
@@ -1428,129 +1428,129 @@ static int __run_block (xp_awk_run_t* run, xp_awk_nde_blk_t* nde)
p = p->next;
}
-/*xp_printf (XP_T("popping off local variables\n"));*/
+/*sse_printf (SSE_T("popping off local variables\n"));*/
/* pop off local variables */
nlocals = nde->nlocals;
while (nlocals > 0)
{
--nlocals;
- xp_awk_refdownval (run, STACK_LOCAL(run,nlocals));
+ sse_awk_refdownval (run, STACK_LOCAL(run,nlocals));
__raw_pop (run);
}
return n;
}
-static int __run_statement (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static int __run_statement (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
switch (nde->type)
{
- case XP_AWK_NDE_NULL:
+ case SSE_AWK_NDE_NULL:
{
/* do nothing */
break;
}
- case XP_AWK_NDE_BLK:
+ case SSE_AWK_NDE_BLK:
{
if (__run_block (run,
- (xp_awk_nde_blk_t*)nde) == -1) return -1;
+ (sse_awk_nde_blk_t*)nde) == -1) return -1;
break;
}
- case XP_AWK_NDE_IF:
+ case SSE_AWK_NDE_IF:
{
if (__run_if (run,
- (xp_awk_nde_if_t*)nde) == -1) return -1;
+ (sse_awk_nde_if_t*)nde) == -1) return -1;
break;
}
- case XP_AWK_NDE_WHILE:
- case XP_AWK_NDE_DOWHILE:
+ case SSE_AWK_NDE_WHILE:
+ case SSE_AWK_NDE_DOWHILE:
{
if (__run_while (run,
- (xp_awk_nde_while_t*)nde) == -1) return -1;
+ (sse_awk_nde_while_t*)nde) == -1) return -1;
break;
}
- case XP_AWK_NDE_FOR:
+ case SSE_AWK_NDE_FOR:
{
if (__run_for (run,
- (xp_awk_nde_for_t*)nde) == -1) return -1;
+ (sse_awk_nde_for_t*)nde) == -1) return -1;
break;
}
- case XP_AWK_NDE_FOREACH:
+ case SSE_AWK_NDE_FOREACH:
{
if (__run_foreach (run,
- (xp_awk_nde_foreach_t*)nde) == -1) return -1;
+ (sse_awk_nde_foreach_t*)nde) == -1) return -1;
break;
}
- case XP_AWK_NDE_BREAK:
+ case SSE_AWK_NDE_BREAK:
{
if (__run_break (run,
- (xp_awk_nde_break_t*)nde) == -1) return -1;
+ (sse_awk_nde_break_t*)nde) == -1) return -1;
break;
}
- case XP_AWK_NDE_CONTINUE:
+ case SSE_AWK_NDE_CONTINUE:
{
if (__run_continue (run,
- (xp_awk_nde_continue_t*)nde) == -1) return -1;
+ (sse_awk_nde_continue_t*)nde) == -1) return -1;
break;
}
- case XP_AWK_NDE_RETURN:
+ case SSE_AWK_NDE_RETURN:
{
if (__run_return (run,
- (xp_awk_nde_return_t*)nde) == -1) return -1;
+ (sse_awk_nde_return_t*)nde) == -1) return -1;
break;
}
- case XP_AWK_NDE_EXIT:
+ case SSE_AWK_NDE_EXIT:
{
if (__run_exit (run,
- (xp_awk_nde_exit_t*)nde) == -1) return -1;
+ (sse_awk_nde_exit_t*)nde) == -1) return -1;
break;
}
- case XP_AWK_NDE_NEXT:
+ case SSE_AWK_NDE_NEXT:
{
if (__run_next (run,
- (xp_awk_nde_next_t*)nde) == -1) return -1;
+ (sse_awk_nde_next_t*)nde) == -1) return -1;
break;
}
- case XP_AWK_NDE_NEXTFILE:
+ case SSE_AWK_NDE_NEXTFILE:
{
if (__run_nextfile (run,
- (xp_awk_nde_nextfile_t*)nde) == -1) return -1;
+ (sse_awk_nde_nextfile_t*)nde) == -1) return -1;
break;
}
- case XP_AWK_NDE_DELETE:
+ case SSE_AWK_NDE_DELETE:
{
if (__run_delete (run,
- (xp_awk_nde_delete_t*)nde) == -1) return -1;
+ (sse_awk_nde_delete_t*)nde) == -1) return -1;
break;
}
- case XP_AWK_NDE_PRINT:
+ case SSE_AWK_NDE_PRINT:
{
if (__run_print (run,
- (xp_awk_nde_print_t*)nde) == -1) return -1;
+ (sse_awk_nde_print_t*)nde) == -1) return -1;
break;
}
default:
{
- xp_awk_val_t* v;
- v = __eval_expression(run,nde);
- if (v == XP_NULL) return -1;
+ sse_awk_val_t* v;
+ v = __eval_esseression(run,nde);
+ if (v == SSE_NULL) return -1;
- xp_awk_refupval (v);
- xp_awk_refdownval (run, v);
+ sse_awk_refupval (v);
+ sse_awk_refdownval (run, v);
break;
}
@@ -1559,66 +1559,66 @@ static int __run_statement (xp_awk_run_t* run, xp_awk_nde_t* nde)
return 0;
}
-static int __run_if (xp_awk_run_t* run, xp_awk_nde_if_t* nde)
+static int __run_if (sse_awk_run_t* run, sse_awk_nde_if_t* nde)
{
- xp_awk_val_t* test;
+ sse_awk_val_t* test;
int n = 0;
- /* the test expression for the if statement cannot have
- * chained expressions. this should not be allowed by the
+ /* the test esseression for the if statement cannot have
+ * chained esseressions. this should not be allowed by the
* parser first of all */
- xp_awk_assert (run->awk, nde->test->next == XP_NULL);
+ sse_awk_assert (run->awk, nde->test->next == SSE_NULL);
- test = __eval_expression (run, nde->test);
- if (test == XP_NULL) return -1;
+ test = __eval_esseression (run, nde->test);
+ if (test == SSE_NULL) return -1;
- xp_awk_refupval (test);
- if (xp_awk_valtobool (run, test))
+ sse_awk_refupval (test);
+ if (sse_awk_valtobool (run, test))
{
n = __run_statement (run, nde->then_part);
}
- else if (nde->else_part != XP_NULL)
+ else if (nde->else_part != SSE_NULL)
{
n = __run_statement (run, nde->else_part);
}
- xp_awk_refdownval (run, test); /* TODO: is this correct?*/
+ sse_awk_refdownval (run, test); /* TODO: is this correct?*/
return n;
}
-static int __run_while (xp_awk_run_t* run, xp_awk_nde_while_t* nde)
+static int __run_while (sse_awk_run_t* run, sse_awk_nde_while_t* nde)
{
- xp_awk_val_t* test;
+ sse_awk_val_t* test;
- if (nde->type == XP_AWK_NDE_WHILE)
+ if (nde->type == SSE_AWK_NDE_WHILE)
{
- /* no chained expressions are allowed for the test
- * expression of the while statement */
- xp_awk_assert (run->awk, nde->test->next == XP_NULL);
+ /* no chained esseressions are allowed for the test
+ * esseression of the while statement */
+ sse_awk_assert (run->awk, nde->test->next == SSE_NULL);
/* TODO: handle run-time abortion... */
while (1)
{
- test = __eval_expression (run, nde->test);
- if (test == XP_NULL) return -1;
+ test = __eval_esseression (run, nde->test);
+ if (test == SSE_NULL) return -1;
- xp_awk_refupval (test);
+ sse_awk_refupval (test);
- if (xp_awk_valtobool (run, test))
+ if (sse_awk_valtobool (run, test))
{
if (__run_statement(run,nde->body) == -1)
{
- xp_awk_refdownval (run, test);
+ sse_awk_refdownval (run, test);
return -1;
}
}
else
{
- xp_awk_refdownval (run, test);
+ sse_awk_refdownval (run, test);
break;
}
- xp_awk_refdownval (run, test);
+ sse_awk_refdownval (run, test);
if (run->exit_level == EXIT_BREAK)
{
@@ -1632,11 +1632,11 @@ static int __run_while (xp_awk_run_t* run, xp_awk_nde_while_t* nde)
else if (run->exit_level != EXIT_NONE) break;
}
}
- else if (nde->type == XP_AWK_NDE_DOWHILE)
+ else if (nde->type == SSE_AWK_NDE_DOWHILE)
{
- /* no chained expressions are allowed for the test
- * expression of the while statement */
- xp_awk_assert (run->awk, nde->test->next == XP_NULL);
+ /* no chained esseressions are allowed for the test
+ * esseression of the while statement */
+ sse_awk_assert (run->awk, nde->test->next == SSE_NULL);
/* TODO: handle run-time abortion... */
do
@@ -1654,18 +1654,18 @@ static int __run_while (xp_awk_run_t* run, xp_awk_nde_while_t* nde)
}
else if (run->exit_level != EXIT_NONE) break;
- test = __eval_expression (run, nde->test);
- if (test == XP_NULL) return -1;
+ test = __eval_esseression (run, nde->test);
+ if (test == SSE_NULL) return -1;
- xp_awk_refupval (test);
+ sse_awk_refupval (test);
- if (!xp_awk_valtobool (run, test))
+ if (!sse_awk_valtobool (run, test))
{
- xp_awk_refdownval (run, test);
+ sse_awk_refdownval (run, test);
break;
}
- xp_awk_refdownval (run, test);
+ sse_awk_refdownval (run, test);
}
while (1);
}
@@ -1673,49 +1673,49 @@ static int __run_while (xp_awk_run_t* run, xp_awk_nde_while_t* nde)
return 0;
}
-static int __run_for (xp_awk_run_t* run, xp_awk_nde_for_t* nde)
+static int __run_for (sse_awk_run_t* run, sse_awk_nde_for_t* nde)
{
- xp_awk_val_t* val;
+ sse_awk_val_t* val;
- if (nde->init != XP_NULL)
+ if (nde->init != SSE_NULL)
{
- xp_awk_assert (run->awk, nde->init->next == XP_NULL);
- val = __eval_expression(run,nde->init);
- if (val == XP_NULL) return -1;
+ sse_awk_assert (run->awk, nde->init->next == SSE_NULL);
+ val = __eval_esseression(run,nde->init);
+ if (val == SSE_NULL) return -1;
- xp_awk_refupval (val);
- xp_awk_refdownval (run, val);
+ sse_awk_refupval (val);
+ sse_awk_refdownval (run, val);
}
while (1)
{
- if (nde->test != XP_NULL)
+ if (nde->test != SSE_NULL)
{
- xp_awk_val_t* test;
+ sse_awk_val_t* test;
- /* no chained expressions for the test expression of
+ /* no chained esseressions for the test esseression of
* the for statement are allowed */
- xp_awk_assert (run->awk, nde->test->next == XP_NULL);
+ sse_awk_assert (run->awk, nde->test->next == SSE_NULL);
- test = __eval_expression (run, nde->test);
- if (test == XP_NULL) return -1;
+ test = __eval_esseression (run, nde->test);
+ if (test == SSE_NULL) return -1;
- xp_awk_refupval (test);
- if (xp_awk_valtobool (run, test))
+ sse_awk_refupval (test);
+ if (sse_awk_valtobool (run, test))
{
if (__run_statement(run,nde->body) == -1)
{
- xp_awk_refdownval (run, test);
+ sse_awk_refdownval (run, test);
return -1;
}
}
else
{
- xp_awk_refdownval (run, test);
+ sse_awk_refdownval (run, test);
break;
}
- xp_awk_refdownval (run, test);
+ sse_awk_refdownval (run, test);
}
else
{
@@ -1736,14 +1736,14 @@ static int __run_for (xp_awk_run_t* run, xp_awk_nde_for_t* nde)
}
else if (run->exit_level != EXIT_NONE) break;
- if (nde->incr != XP_NULL)
+ if (nde->incr != SSE_NULL)
{
- xp_awk_assert (run->awk, nde->incr->next == XP_NULL);
- val = __eval_expression(run,nde->incr);
- if (val == XP_NULL) return -1;
+ sse_awk_assert (run->awk, nde->incr->next == SSE_NULL);
+ val = __eval_esseression(run,nde->incr);
+ if (val == SSE_NULL) return -1;
- xp_awk_refupval (val);
- xp_awk_refdownval (run, val);
+ sse_awk_refupval (val);
+ sse_awk_refdownval (run, val);
}
}
@@ -1752,167 +1752,167 @@ static int __run_for (xp_awk_run_t* run, xp_awk_nde_for_t* nde)
struct __foreach_walker_t
{
- xp_awk_run_t* run;
- xp_awk_nde_t* var;
- xp_awk_nde_t* body;
+ sse_awk_run_t* run;
+ sse_awk_nde_t* var;
+ sse_awk_nde_t* body;
};
-static int __walk_foreach (xp_awk_pair_t* pair, void* arg)
+static int __walk_foreach (sse_awk_pair_t* pair, void* arg)
{
struct __foreach_walker_t* w = (struct __foreach_walker_t*)arg;
- xp_awk_val_t* str;
+ sse_awk_val_t* str;
- str = (xp_awk_val_t*) xp_awk_makestrval (
- w->run, pair->key, xp_awk_strlen(pair->key));
- if (str == XP_NULL) PANIC_I (w->run, XP_AWK_ENOMEM);
+ str = (sse_awk_val_t*) sse_awk_makestrval (
+ w->run, pair->key, sse_awk_strlen(pair->key));
+ if (str == SSE_NULL) PANIC_I (w->run, SSE_AWK_ENOMEM);
- xp_awk_refupval (str);
- if (__do_assignment (w->run, w->var, str) == XP_NULL)
+ sse_awk_refupval (str);
+ if (__do_assignment (w->run, w->var, str) == SSE_NULL)
{
- xp_awk_refdownval (w->run, str);
+ sse_awk_refdownval (w->run, str);
return -1;
}
if (__run_statement (w->run, w->body) == -1)
{
- xp_awk_refdownval (w->run, str);
+ sse_awk_refdownval (w->run, str);
return -1;
}
- xp_awk_refdownval (w->run, str);
+ sse_awk_refdownval (w->run, str);
return 0;
}
-static int __run_foreach (xp_awk_run_t* run, xp_awk_nde_foreach_t* nde)
+static int __run_foreach (sse_awk_run_t* run, sse_awk_nde_foreach_t* nde)
{
int n;
- xp_awk_nde_exp_t* test;
- xp_awk_val_t* rv;
- xp_awk_map_t* map;
+ sse_awk_nde_esse_t* test;
+ sse_awk_val_t* rv;
+ sse_awk_map_t* map;
struct __foreach_walker_t walker;
- test = (xp_awk_nde_exp_t*)nde->test;
- xp_awk_assert (run->awk, test->type == XP_AWK_NDE_EXP_BIN &&
- test->opcode == XP_AWK_BINOP_IN);
+ test = (sse_awk_nde_esse_t*)nde->test;
+ sse_awk_assert (run->awk, test->type == SSE_AWK_NDE_ESSE_BIN &&
+ test->opcode == SSE_AWK_BINOP_IN);
- /* chained expressions should not be allowed
+ /* chained esseressions should not be allowed
* by the parser first of all */
- xp_awk_assert (run->awk, test->right->next == XP_NULL);
+ sse_awk_assert (run->awk, test->right->next == SSE_NULL);
- rv = __eval_expression (run, test->right);
- if (rv == XP_NULL) return -1;
+ rv = __eval_esseression (run, test->right);
+ if (rv == SSE_NULL) return -1;
- xp_awk_refupval (rv);
- if (rv->type != XP_AWK_VAL_MAP)
+ sse_awk_refupval (rv);
+ if (rv->type != SSE_AWK_VAL_MAP)
{
- xp_awk_refdownval (run, rv);
- PANIC_I (run, XP_AWK_ENOTINDEXABLE);
+ sse_awk_refdownval (run, rv);
+ PANIC_I (run, SSE_AWK_ENOTINDEXABLE);
}
- map = ((xp_awk_val_map_t*)rv)->map;
+ map = ((sse_awk_val_map_t*)rv)->map;
walker.run = run;
walker.var = test->left;
walker.body = nde->body;
- n = xp_awk_map_walk (map, __walk_foreach, &walker);
+ n = sse_awk_map_walk (map, __walk_foreach, &walker);
- xp_awk_refdownval (run, rv);
+ sse_awk_refdownval (run, rv);
return n;
}
-static int __run_break (xp_awk_run_t* run, xp_awk_nde_break_t* nde)
+static int __run_break (sse_awk_run_t* run, sse_awk_nde_break_t* nde)
{
run->exit_level = EXIT_BREAK;
return 0;
}
-static int __run_continue (xp_awk_run_t* run, xp_awk_nde_continue_t* nde)
+static int __run_continue (sse_awk_run_t* run, sse_awk_nde_continue_t* nde)
{
run->exit_level = EXIT_CONTINUE;
return 0;
}
-static int __run_return (xp_awk_run_t* run, xp_awk_nde_return_t* nde)
+static int __run_return (sse_awk_run_t* run, sse_awk_nde_return_t* nde)
{
- if (nde->val != XP_NULL)
+ if (nde->val != SSE_NULL)
{
- xp_awk_val_t* val;
+ sse_awk_val_t* val;
- /* chained expressions should not be allowed
+ /* chained esseressions should not be allowed
* by the parser first of all */
- xp_awk_assert (run->awk, nde->val->next == XP_NULL);
+ sse_awk_assert (run->awk, nde->val->next == SSE_NULL);
-/*xp_printf (XP_T("returning....\n"));*/
- val = __eval_expression (run, nde->val);
- if (val == XP_NULL) return -1;
+/*sse_printf (SSE_T("returning....\n"));*/
+ val = __eval_esseression (run, nde->val);
+ if (val == SSE_NULL) return -1;
- xp_awk_refdownval (run, STACK_RETVAL(run));
+ sse_awk_refdownval (run, STACK_RETVAL(run));
STACK_RETVAL(run) = val;
- xp_awk_refupval (val); /* see __eval_call for the trick */
-/*xp_printf (XP_T("set return value....\n"));*/
+ sse_awk_refupval (val); /* see __eval_call for the trick */
+/*sse_printf (SSE_T("set return value....\n"));*/
}
run->exit_level = EXIT_FUNCTION;
return 0;
}
-static int __run_exit (xp_awk_run_t* run, xp_awk_nde_exit_t* nde)
+static int __run_exit (sse_awk_run_t* run, sse_awk_nde_exit_t* nde)
{
- if (nde->val != XP_NULL)
+ if (nde->val != SSE_NULL)
{
- xp_awk_val_t* val;
+ sse_awk_val_t* val;
- /* chained expressions should not be allowed
+ /* chained esseressions should not be allowed
* by the parser first of all */
- xp_awk_assert (run->awk, nde->val->next == XP_NULL);
+ sse_awk_assert (run->awk, nde->val->next == SSE_NULL);
- val = __eval_expression (run, nde->val);
- if (val == XP_NULL) return -1;
+ val = __eval_esseression (run, nde->val);
+ if (val == SSE_NULL) return -1;
- xp_awk_refdownval (run, STACK_RETVAL_GLOBAL(run));
+ sse_awk_refdownval (run, STACK_RETVAL_GLOBAL(run));
STACK_RETVAL_GLOBAL(run) = val; /* global return value */
- xp_awk_refupval (val);
+ sse_awk_refupval (val);
}
run->exit_level = EXIT_GLOBAL;
return 0;
}
-static int __run_next (xp_awk_run_t* run, xp_awk_nde_next_t* nde)
+static int __run_next (sse_awk_run_t* run, sse_awk_nde_next_t* nde)
{
/* the parser checks if next has been called in the begin/end
* block or whereever inappropriate. so the runtime doesn't
- * check that explicitly */
+ * check that esselicitly */
- if (run->active_block == (xp_awk_nde_blk_t*)run->awk->tree.begin ||
- run->active_block == (xp_awk_nde_blk_t*)run->awk->tree.end)
+ if (run->active_block == (sse_awk_nde_blk_t*)run->awk->tree.begin ||
+ run->active_block == (sse_awk_nde_blk_t*)run->awk->tree.end)
{
- PANIC_I (run, XP_AWK_ENEXTCALL);
+ PANIC_I (run, SSE_AWK_ENEXTCALL);
}
run->exit_level = EXIT_NEXT;
return 0;
}
-static int __run_nextfile (xp_awk_run_t* run, xp_awk_nde_nextfile_t* nde)
+static int __run_nextfile (sse_awk_run_t* run, sse_awk_nde_nextfile_t* nde)
{
/* TODO: some extentions such as nextfile "in/out";
* what about awk -i in1,in2,in3 -o out1,out2,out3 ?
*/
int n;
- if (run->active_block == (xp_awk_nde_blk_t*)run->awk->tree.begin ||
- run->active_block == (xp_awk_nde_blk_t*)run->awk->tree.end)
+ if (run->active_block == (sse_awk_nde_blk_t*)run->awk->tree.begin ||
+ run->active_block == (sse_awk_nde_blk_t*)run->awk->tree.end)
{
- run->errnum = XP_AWK_ENEXTFILECALL;
+ run->errnum = SSE_AWK_ENEXTFILECALL;
return -1;
}
- n = xp_awk_nextextio_read (run, XP_AWK_IN_CONSOLE, XP_T(""));
+ n = sse_awk_nextextio_read (run, SSE_AWK_IN_CONSOLE, SSE_T(""));
if (n == -1)
{
- if (run->errnum == XP_AWK_EIOHANDLER)
- run->errnum = XP_AWK_ECONINNEXT;
+ if (run->errnum == SSE_AWK_EIOHANDLER)
+ run->errnum = SSE_AWK_ECONINNEXT;
return -1;
}
@@ -1930,231 +1930,231 @@ static int __run_nextfile (xp_awk_run_t* run, xp_awk_nde_nextfile_t* nde)
return 0;
}
-static int __run_delete (xp_awk_run_t* run, xp_awk_nde_delete_t* nde)
+static int __run_delete (sse_awk_run_t* run, sse_awk_nde_delete_t* nde)
{
- xp_awk_nde_var_t* var;
+ sse_awk_nde_var_t* var;
- var = (xp_awk_nde_var_t*) nde->var;
+ var = (sse_awk_nde_var_t*) nde->var;
- if (var->type == XP_AWK_NDE_NAMED ||
- var->type == XP_AWK_NDE_NAMEDIDX)
+ if (var->type == SSE_AWK_NDE_NAMED ||
+ var->type == SSE_AWK_NDE_NAMEDIDX)
{
- xp_awk_pair_t* pair;
+ sse_awk_pair_t* pair;
- xp_awk_assert (run->awk, (var->type == XP_AWK_NDE_NAMED &&
- var->idx == XP_NULL) ||
- (var->type == XP_AWK_NDE_NAMEDIDX &&
- var->idx != XP_NULL));
+ sse_awk_assert (run->awk, (var->type == SSE_AWK_NDE_NAMED &&
+ var->idx == SSE_NULL) ||
+ (var->type == SSE_AWK_NDE_NAMEDIDX &&
+ var->idx != SSE_NULL));
- pair = xp_awk_map_get (
+ pair = sse_awk_map_get (
&run->named, var->id.name, var->id.name_len);
- if (pair == XP_NULL)
+ if (pair == SSE_NULL)
{
- xp_awk_val_t* tmp;
+ sse_awk_val_t* tmp;
/* value not set for the named variable.
* create a map and assign it to the variable */
- tmp = xp_awk_makemapval (run);
- if (tmp == XP_NULL) PANIC_I (run, XP_AWK_ENOMEM);
+ tmp = sse_awk_makemapval (run);
+ if (tmp == SSE_NULL) PANIC_I (run, SSE_AWK_ENOMEM);
- if (xp_awk_map_put (&run->named,
- var->id.name, var->id.name_len, tmp) == XP_NULL)
+ if (sse_awk_map_put (&run->named,
+ var->id.name, var->id.name_len, tmp) == SSE_NULL)
{
- xp_awk_refupval (tmp);
- xp_awk_refdownval (run, tmp);
- PANIC_I (run, XP_AWK_ENOMEM);
+ sse_awk_refupval (tmp);
+ sse_awk_refdownval (run, tmp);
+ PANIC_I (run, SSE_AWK_ENOMEM);
}
- xp_awk_refupval (tmp);
+ sse_awk_refupval (tmp);
}
else
{
- xp_awk_val_t* val;
- xp_awk_map_t* map;
+ sse_awk_val_t* val;
+ sse_awk_map_t* map;
- val = (xp_awk_val_t*)pair->val;
- xp_awk_assert (run->awk, val != XP_NULL);
+ val = (sse_awk_val_t*)pair->val;
+ sse_awk_assert (run->awk, val != SSE_NULL);
- if (val->type != XP_AWK_VAL_MAP)
- PANIC_I (run, XP_AWK_ENOTDELETABLE);
+ if (val->type != SSE_AWK_VAL_MAP)
+ PANIC_I (run, SSE_AWK_ENOTDELETABLE);
- map = ((xp_awk_val_map_t*)val)->map;
- if (var->type == XP_AWK_NDE_NAMEDIDX)
+ map = ((sse_awk_val_map_t*)val)->map;
+ if (var->type == SSE_AWK_NDE_NAMEDIDX)
{
- xp_char_t* key;
- xp_size_t key_len;
- xp_awk_val_t* idx;
+ sse_char_t* key;
+ sse_size_t key_len;
+ sse_awk_val_t* idx;
- xp_awk_assert (run->awk, var->idx != XP_NULL);
+ sse_awk_assert (run->awk, var->idx != SSE_NULL);
- idx = __eval_expression (run, var->idx);
- if (idx == XP_NULL) return -1;
+ idx = __eval_esseression (run, var->idx);
+ if (idx == SSE_NULL) return -1;
- xp_awk_refupval (idx);
- key = xp_awk_valtostr (
- run, idx, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &key_len);
- xp_awk_refdownval (run, idx);
+ sse_awk_refupval (idx);
+ key = sse_awk_valtostr (
+ run, idx, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &key_len);
+ sse_awk_refdownval (run, idx);
- if (key == XP_NULL) return -1;
+ if (key == SSE_NULL) return -1;
- xp_awk_map_remove (map, key, key_len);
- XP_AWK_FREE (run->awk, key);
+ sse_awk_map_remove (map, key, key_len);
+ SSE_AWK_FREE (run->awk, key);
}
else
{
- xp_awk_map_clear (map);
+ sse_awk_map_clear (map);
}
}
}
- else if (var->type == XP_AWK_NDE_GLOBAL ||
- var->type == XP_AWK_NDE_LOCAL ||
- var->type == XP_AWK_NDE_ARG ||
- var->type == XP_AWK_NDE_GLOBALIDX ||
- var->type == XP_AWK_NDE_LOCALIDX ||
- var->type == XP_AWK_NDE_ARGIDX)
+ else if (var->type == SSE_AWK_NDE_GLOBAL ||
+ var->type == SSE_AWK_NDE_LOCAL ||
+ var->type == SSE_AWK_NDE_ARG ||
+ var->type == SSE_AWK_NDE_GLOBALIDX ||
+ var->type == SSE_AWK_NDE_LOCALIDX ||
+ var->type == SSE_AWK_NDE_ARGIDX)
{
- xp_awk_val_t* val;
+ sse_awk_val_t* val;
- if (var->type == XP_AWK_NDE_GLOBAL ||
- var->type == XP_AWK_NDE_GLOBALIDX)
+ if (var->type == SSE_AWK_NDE_GLOBAL ||
+ var->type == SSE_AWK_NDE_GLOBALIDX)
val = STACK_GLOBAL (run,var->id.idxa);
- else if (var->type == XP_AWK_NDE_LOCAL ||
- var->type == XP_AWK_NDE_LOCALIDX)
+ else if (var->type == SSE_AWK_NDE_LOCAL ||
+ var->type == SSE_AWK_NDE_LOCALIDX)
val = STACK_LOCAL (run,var->id.idxa);
else val = STACK_ARG (run,var->id.idxa);
- xp_awk_assert (run->awk, val != XP_NULL);
+ sse_awk_assert (run->awk, val != SSE_NULL);
- if (val->type == XP_AWK_VAL_NIL)
+ if (val->type == SSE_AWK_VAL_NIL)
{
- xp_awk_val_t* tmp;
+ sse_awk_val_t* tmp;
/* value not set for the named variable.
* create a map and assign it to the variable */
- tmp = xp_awk_makemapval (run);
- if (tmp == XP_NULL) PANIC_I (run, XP_AWK_ENOMEM);
+ tmp = sse_awk_makemapval (run);
+ if (tmp == SSE_NULL) PANIC_I (run, SSE_AWK_ENOMEM);
/* no need to reduce the reference count of
* the previous value because it was nil. */
- if (var->type == XP_AWK_NDE_GLOBAL ||
- var->type == XP_AWK_NDE_GLOBALIDX)
+ if (var->type == SSE_AWK_NDE_GLOBAL ||
+ var->type == SSE_AWK_NDE_GLOBALIDX)
{
- if (xp_awk_setglobal (
+ if (sse_awk_setglobal (
run, var->id.idxa, tmp) == -1)
{
- xp_awk_refupval (tmp);
- xp_awk_refdownval (run, tmp);
+ sse_awk_refupval (tmp);
+ sse_awk_refdownval (run, tmp);
return -1;
}
}
- else if (var->type == XP_AWK_NDE_LOCAL ||
- var->type == XP_AWK_NDE_LOCALIDX)
+ else if (var->type == SSE_AWK_NDE_LOCAL ||
+ var->type == SSE_AWK_NDE_LOCALIDX)
{
STACK_LOCAL(run,var->id.idxa) = tmp;
- xp_awk_refupval (tmp);
+ sse_awk_refupval (tmp);
}
else
{
STACK_ARG(run,var->id.idxa) = tmp;
- xp_awk_refupval (tmp);
+ sse_awk_refupval (tmp);
}
}
else
{
- xp_awk_map_t* map;
+ sse_awk_map_t* map;
- if (val->type != XP_AWK_VAL_MAP)
- PANIC_I (run, XP_AWK_ENOTDELETABLE);
+ if (val->type != SSE_AWK_VAL_MAP)
+ PANIC_I (run, SSE_AWK_ENOTDELETABLE);
- map = ((xp_awk_val_map_t*)val)->map;
- if (var->type == XP_AWK_NDE_GLOBALIDX ||
- var->type == XP_AWK_NDE_LOCALIDX ||
- var->type == XP_AWK_NDE_ARGIDX)
+ map = ((sse_awk_val_map_t*)val)->map;
+ if (var->type == SSE_AWK_NDE_GLOBALIDX ||
+ var->type == SSE_AWK_NDE_LOCALIDX ||
+ var->type == SSE_AWK_NDE_ARGIDX)
{
- xp_char_t* key;
- xp_size_t key_len;
- xp_awk_val_t* idx;
+ sse_char_t* key;
+ sse_size_t key_len;
+ sse_awk_val_t* idx;
- xp_awk_assert (run->awk, var->idx != XP_NULL);
+ sse_awk_assert (run->awk, var->idx != SSE_NULL);
- idx = __eval_expression (run, var->idx);
- if (idx == XP_NULL) return -1;
+ idx = __eval_esseression (run, var->idx);
+ if (idx == SSE_NULL) return -1;
- xp_awk_refupval (idx);
- key = xp_awk_valtostr (
- run, idx, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &key_len);
- xp_awk_refdownval (run, idx);
+ sse_awk_refupval (idx);
+ key = sse_awk_valtostr (
+ run, idx, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &key_len);
+ sse_awk_refdownval (run, idx);
- if (key == XP_NULL) return -1;
+ if (key == SSE_NULL) return -1;
- xp_awk_map_remove (map, key, key_len);
- XP_AWK_FREE (run->awk, key);
+ sse_awk_map_remove (map, key, key_len);
+ SSE_AWK_FREE (run->awk, key);
}
else
{
- xp_awk_map_clear (map);
+ sse_awk_map_clear (map);
}
}
}
else
{
- xp_awk_assert (run->awk, !"should never happen - wrong variable type for delete");
- PANIC_I (run, XP_AWK_EINTERNAL);
+ sse_awk_assert (run->awk, !"should never happen - wrong variable type for delete");
+ PANIC_I (run, SSE_AWK_EINTERNAL);
}
return 0;
}
-static int __run_print (xp_awk_run_t* run, xp_awk_nde_print_t* nde)
+static int __run_print (sse_awk_run_t* run, sse_awk_nde_print_t* nde)
{
- xp_awk_nde_print_t* p = (xp_awk_nde_print_t*)nde;
- xp_char_t* out = XP_NULL;
- const xp_char_t* dst;
- xp_awk_val_t* v;
- xp_awk_nde_t* np;
+ sse_awk_nde_print_t* p = (sse_awk_nde_print_t*)nde;
+ sse_char_t* out = SSE_NULL;
+ const sse_char_t* dst;
+ sse_awk_val_t* v;
+ sse_awk_nde_t* np;
int n;
- xp_awk_assert (run->awk,
- (p->out_type == XP_AWK_OUT_PIPE && p->out != XP_NULL) ||
- (p->out_type == XP_AWK_OUT_COPROC && p->out != XP_NULL) ||
- (p->out_type == XP_AWK_OUT_FILE && p->out != XP_NULL) ||
- (p->out_type == XP_AWK_OUT_FILE_APPEND && p->out != XP_NULL) ||
- (p->out_type == XP_AWK_OUT_CONSOLE && p->out == XP_NULL));
+ sse_awk_assert (run->awk,
+ (p->out_type == SSE_AWK_OUT_PIPE && p->out != SSE_NULL) ||
+ (p->out_type == SSE_AWK_OUT_COPROC && p->out != SSE_NULL) ||
+ (p->out_type == SSE_AWK_OUT_FILE && p->out != SSE_NULL) ||
+ (p->out_type == SSE_AWK_OUT_FILE_APPEND && p->out != SSE_NULL) ||
+ (p->out_type == SSE_AWK_OUT_CONSOLE && p->out == SSE_NULL));
- if (p->out != XP_NULL)
+ if (p->out != SSE_NULL)
{
- xp_size_t len;
+ sse_size_t len;
- v = __eval_expression (run, p->out);
- if (v == XP_NULL) return -1;
+ v = __eval_esseression (run, p->out);
+ if (v == SSE_NULL) return -1;
- xp_awk_refupval (v);
- out = xp_awk_valtostr (
- run, v, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &len);
- if (out == XP_NULL)
+ sse_awk_refupval (v);
+ out = sse_awk_valtostr (
+ run, v, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
+ if (out == SSE_NULL)
{
- xp_awk_refdownval (run, v);
+ sse_awk_refdownval (run, v);
return -1;
}
- xp_awk_refdownval (run, v);
+ sse_awk_refdownval (run, v);
if (len <= 0)
{
/* the output destination name is empty. */
- XP_AWK_FREE (run->awk, out);
+ SSE_AWK_FREE (run->awk, out);
n = -1;
goto skip_write;
}
while (len > 0)
{
- if (out[--len] == XP_T('\0'))
+ if (out[--len] == SSE_T('\0'))
{
/* the output destination name contains a null
* character. */
- XP_AWK_FREE (run->awk, out);
+ SSE_AWK_FREE (run->awk, out);
n = -1;
goto skip_write;
/* TODO: how to handle error???
@@ -2168,143 +2168,143 @@ static int __run_print (xp_awk_run_t* run, xp_awk_nde_print_t* nde)
}
}
- dst = (out == XP_NULL)? XP_T(""): out;
+ dst = (out == SSE_NULL)? SSE_T(""): out;
- if (p->args == XP_NULL)
+ if (p->args == SSE_NULL)
{
/*
v = run->inrec.d0;
- xp_awk_refupval (v);
- n = xp_awk_writeextio_val (run, p->out_type, dst, v);
- if (n < 0 && run->errnum != XP_AWK_EIOHANDLER)
+ sse_awk_refupval (v);
+ n = sse_awk_writeextio_val (run, p->out_type, dst, v);
+ if (n < 0 && run->errnum != SSE_AWK_EIOHANDLER)
{
- if (out != XP_NULL) XP_AWK_FREE (run->awk, out);
- xp_awk_refdownval (run, v);
+ if (out != SSE_NULL) SSE_AWK_FREE (run->awk, out);
+ sse_awk_refdownval (run, v);
return -1;
}
- xp_awk_refdownval (run, v);
+ sse_awk_refdownval (run, v);
*/
- n = xp_awk_writeextio_str (
+ n = sse_awk_writeextio_str (
run, p->out_type, dst,
- XP_AWK_STR_BUF(&run->inrec.line),
- XP_AWK_STR_LEN(&run->inrec.line));
- if (n < 0 && run->errnum != XP_AWK_EIOHANDLER)
+ SSE_AWK_STR_BUF(&run->inrec.line),
+ SSE_AWK_STR_LEN(&run->inrec.line));
+ if (n < 0 && run->errnum != SSE_AWK_EIOHANDLER)
{
- if (out != XP_NULL) XP_AWK_FREE (run->awk, out);
+ if (out != SSE_NULL) SSE_AWK_FREE (run->awk, out);
return -1;
}
- /* TODO: how to handle n == -1 && errnum == XP_AWK_EIOHANDLER.
+ /* TODO: how to handle n == -1 && errnum == SSE_AWK_EIOHANDLER.
* that is the user handler returned an error... */
}
else
{
- for (np = p->args; np != XP_NULL; np = np->next)
+ for (np = p->args; np != SSE_NULL; np = np->next)
{
if (np != p->args)
{
- n = xp_awk_writeextio_str (
+ n = sse_awk_writeextio_str (
run, p->out_type, dst,
run->global.ofs.ptr,
run->global.ofs.len);
- if (n < 0 && run->errnum != XP_AWK_EIOHANDLER)
+ if (n < 0 && run->errnum != SSE_AWK_EIOHANDLER)
{
- if (out != XP_NULL) XP_AWK_FREE (run->awk, out);
+ if (out != SSE_NULL) SSE_AWK_FREE (run->awk, out);
return -1;
}
}
- v = __eval_expression (run, np);
- if (v == XP_NULL)
+ v = __eval_esseression (run, np);
+ if (v == SSE_NULL)
{
- if (out != XP_NULL) XP_AWK_FREE (run->awk, out);
+ if (out != SSE_NULL) SSE_AWK_FREE (run->awk, out);
return -1;
}
- xp_awk_refupval (v);
+ sse_awk_refupval (v);
- n = xp_awk_writeextio_val (run, p->out_type, dst, v);
- if (n < 0 && run->errnum != XP_AWK_EIOHANDLER)
+ n = sse_awk_writeextio_val (run, p->out_type, dst, v);
+ if (n < 0 && run->errnum != SSE_AWK_EIOHANDLER)
{
- if (out != XP_NULL) XP_AWK_FREE (run->awk, out);
- xp_awk_refdownval (run, v);
+ if (out != SSE_NULL) SSE_AWK_FREE (run->awk, out);
+ sse_awk_refdownval (run, v);
return -1;
}
- xp_awk_refdownval (run, v);
+ sse_awk_refdownval (run, v);
- /* TODO: how to handle n == -1 && run->errnum == XP_AWK_EIOHANDLER.
+ /* TODO: how to handle n == -1 && run->errnum == SSE_AWK_EIOHANDLER.
* that is the user handler returned an error... */
}
}
- n = xp_awk_writeextio_str (
+ n = sse_awk_writeextio_str (
run, p->out_type, dst,
run->global.ors.ptr, run->global.ors.len);
- if (n < 0 && run->errnum != XP_AWK_EIOHANDLER)
+ if (n < 0 && run->errnum != SSE_AWK_EIOHANDLER)
{
- if (out != XP_NULL) XP_AWK_FREE (run->awk, out);
+ if (out != SSE_NULL) SSE_AWK_FREE (run->awk, out);
return -1;
}
- /* TODO: how to handle n == -1 && errnum == XP_AWK_EIOHANDLER.
+ /* TODO: how to handle n == -1 && errnum == SSE_AWK_EIOHANDLER.
* that is the user handler returned an error... */
- if (out != XP_NULL) XP_AWK_FREE (run->awk, out);
+ if (out != SSE_NULL) SSE_AWK_FREE (run->awk, out);
skip_write:
return 0;
}
-static xp_awk_val_t* __eval_expression (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_esseression (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- xp_awk_val_t* v;
+ sse_awk_val_t* v;
int n, errnum;
- v = __eval_expression0 (run, nde);
- if (v == XP_NULL) return XP_NULL;
+ v = __eval_esseression0 (run, nde);
+ if (v == SSE_NULL) return SSE_NULL;
- if (v->type == XP_AWK_VAL_REX)
+ if (v->type == SSE_AWK_VAL_REX)
{
- xp_awk_refupval (v);
+ sse_awk_refupval (v);
- if (run->inrec.d0->type == XP_AWK_VAL_NIL)
+ if (run->inrec.d0->type == SSE_AWK_VAL_NIL)
{
/* the record has never been read.
* probably, this functions has been triggered
* by the statements in the BEGIN block */
- n = xp_awk_isemptyrex (run->awk, ((xp_awk_val_rex_t*)v)->code)? 1: 0;
+ n = sse_awk_isemptyrex (run->awk, ((sse_awk_val_rex_t*)v)->code)? 1: 0;
}
else
{
- xp_awk_assert (run->awk, run->inrec.d0->type == XP_AWK_VAL_STR);
+ sse_awk_assert (run->awk, run->inrec.d0->type == SSE_AWK_VAL_STR);
- n = xp_awk_matchrex (
- ((xp_awk_run_t*)run)->awk,
- ((xp_awk_val_rex_t*)v)->code,
- ((((xp_awk_run_t*)run)->global.ignorecase)? XP_AWK_REX_IGNORECASE: 0),
- ((xp_awk_val_str_t*)run->inrec.d0)->buf,
- ((xp_awk_val_str_t*)run->inrec.d0)->len,
- XP_NULL, XP_NULL, &errnum);
+ n = sse_awk_matchrex (
+ ((sse_awk_run_t*)run)->awk,
+ ((sse_awk_val_rex_t*)v)->code,
+ ((((sse_awk_run_t*)run)->global.ignorecase)? SSE_AWK_REX_IGNORECASE: 0),
+ ((sse_awk_val_str_t*)run->inrec.d0)->buf,
+ ((sse_awk_val_str_t*)run->inrec.d0)->len,
+ SSE_NULL, SSE_NULL, &errnum);
if (n == -1)
{
- xp_awk_refdownval (run, v);
+ sse_awk_refdownval (run, v);
PANIC (run, errnum);
}
}
- xp_awk_refdownval (run, v);
+ sse_awk_refdownval (run, v);
- v = xp_awk_makeintval (run, (n != 0));
- if (v == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ v = sse_awk_makeintval (run, (n != 0));
+ if (v == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
}
return v;
}
-static xp_awk_val_t* __eval_expression0 (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_esseression0 (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- static eval_expr_t __eval_func[] =
+ static eval_esser_t __eval_func[] =
{
/* the order of functions here should match the order
* of node types declared in tree.h */
@@ -2333,357 +2333,357 @@ static xp_awk_val_t* __eval_expression0 (xp_awk_run_t* run, xp_awk_nde_t* nde)
__eval_getline
};
- xp_awk_assert (run->awk, nde->type >= XP_AWK_NDE_GRP &&
- (nde->type - XP_AWK_NDE_GRP) < xp_countof(__eval_func));
+ sse_awk_assert (run->awk, nde->type >= SSE_AWK_NDE_GRP &&
+ (nde->type - SSE_AWK_NDE_GRP) < sse_countof(__eval_func));
- return __eval_func[nde->type-XP_AWK_NDE_GRP] (run, nde);
+ return __eval_func[nde->type-SSE_AWK_NDE_GRP] (run, nde);
}
-static xp_awk_val_t* __eval_group (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_group (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- /* __eval_binop_in evaluates the XP_AWK_NDE_GRP specially.
+ /* __eval_binop_in evaluates the SSE_AWK_NDE_GRP specially.
* so this function should never be reached. */
- xp_awk_assert (run->awk, !"should never happen - NDE_GRP only for in");
- PANIC (run, XP_AWK_EINTERNAL);
- return XP_NULL;
+ sse_awk_assert (run->awk, !"should never happen - NDE_GRP only for in");
+ PANIC (run, SSE_AWK_EINTERNAL);
+ return SSE_NULL;
}
-static xp_awk_val_t* __eval_assignment (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_assignment (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- xp_awk_val_t* val, * ret;
- xp_awk_nde_ass_t* ass = (xp_awk_nde_ass_t*)nde;
+ sse_awk_val_t* val, * ret;
+ sse_awk_nde_ass_t* ass = (sse_awk_nde_ass_t*)nde;
- xp_awk_assert (run->awk, ass->left != XP_NULL && ass->right != XP_NULL);
+ sse_awk_assert (run->awk, ass->left != SSE_NULL && ass->right != SSE_NULL);
- xp_awk_assert (run->awk, ass->right->next == XP_NULL);
- val = __eval_expression (run, ass->right);
- if (val == XP_NULL) return XP_NULL;
+ sse_awk_assert (run->awk, ass->right->next == SSE_NULL);
+ val = __eval_esseression (run, ass->right);
+ if (val == SSE_NULL) return SSE_NULL;
- xp_awk_refupval (val);
+ sse_awk_refupval (val);
- if (ass->opcode != XP_AWK_ASSOP_NONE)
+ if (ass->opcode != SSE_AWK_ASSOP_NONE)
{
- xp_awk_val_t* val2, * tmp;
+ sse_awk_val_t* val2, * tmp;
- xp_awk_assert (run->awk, ass->left->next == XP_NULL);
- val2 = __eval_expression (run, ass->left);
- if (val2 == XP_NULL)
+ sse_awk_assert (run->awk, ass->left->next == SSE_NULL);
+ val2 = __eval_esseression (run, ass->left);
+ if (val2 == SSE_NULL)
{
- xp_awk_refdownval (run, val);
- return XP_NULL;
+ sse_awk_refdownval (run, val);
+ return SSE_NULL;
}
- xp_awk_refupval (val2);
+ sse_awk_refupval (val2);
- if (ass->opcode == XP_AWK_ASSOP_PLUS)
+ if (ass->opcode == SSE_AWK_ASSOP_PLUS)
{
tmp = __eval_binop_plus (run, val2, val);
}
- else if (ass->opcode == XP_AWK_ASSOP_MINUS)
+ else if (ass->opcode == SSE_AWK_ASSOP_MINUS)
{
tmp = __eval_binop_minus (run, val2, val);
}
- else if (ass->opcode == XP_AWK_ASSOP_MUL)
+ else if (ass->opcode == SSE_AWK_ASSOP_MUL)
{
tmp = __eval_binop_mul (run, val2, val);
}
- else if (ass->opcode == XP_AWK_ASSOP_DIV)
+ else if (ass->opcode == SSE_AWK_ASSOP_DIV)
{
tmp = __eval_binop_div (run, val2, val);
}
- else if (ass->opcode == XP_AWK_ASSOP_MOD)
+ else if (ass->opcode == SSE_AWK_ASSOP_MOD)
{
tmp = __eval_binop_mod (run, val2, val);
}
- else if (ass->opcode == XP_AWK_ASSOP_EXP)
+ else if (ass->opcode == SSE_AWK_ASSOP_ESSE)
{
- tmp = __eval_binop_exp (run, val2, val);
+ tmp = __eval_binop_esse (run, val2, val);
}
else
{
- xp_awk_assert (run->awk, !"should never happen - invalid assignment opcode");
- PANIC (run, XP_AWK_EINTERNAL);
+ sse_awk_assert (run->awk, !"should never happen - invalid assignment opcode");
+ PANIC (run, SSE_AWK_EINTERNAL);
}
- if (tmp == XP_NULL)
+ if (tmp == SSE_NULL)
{
- xp_awk_refdownval (run, val);
- xp_awk_refdownval (run, val2);
- return XP_NULL;
+ sse_awk_refdownval (run, val);
+ sse_awk_refdownval (run, val2);
+ return SSE_NULL;
}
- xp_awk_refdownval (run, val);
+ sse_awk_refdownval (run, val);
val = tmp;
- xp_awk_refupval (val);
+ sse_awk_refupval (val);
}
ret = __do_assignment (run, ass->left, val);
- xp_awk_refdownval (run, val);
+ sse_awk_refdownval (run, val);
return ret;
}
-static xp_awk_val_t* __do_assignment (
- xp_awk_run_t* run, xp_awk_nde_t* var, xp_awk_val_t* val)
+static sse_awk_val_t* __do_assignment (
+ sse_awk_run_t* run, sse_awk_nde_t* var, sse_awk_val_t* val)
{
- xp_awk_val_t* ret;
+ sse_awk_val_t* ret;
- if (val->type == XP_AWK_VAL_MAP)
+ if (val->type == SSE_AWK_VAL_MAP)
{
/* a map cannot be assigned to a variable */
- PANIC (run, XP_AWK_ENOTASSIGNABLE);
+ PANIC (run, SSE_AWK_ENOTASSIGNABLE);
}
- if (var->type == XP_AWK_NDE_NAMED ||
- var->type == XP_AWK_NDE_GLOBAL ||
- var->type == XP_AWK_NDE_LOCAL ||
- var->type == XP_AWK_NDE_ARG)
+ if (var->type == SSE_AWK_NDE_NAMED ||
+ var->type == SSE_AWK_NDE_GLOBAL ||
+ var->type == SSE_AWK_NDE_LOCAL ||
+ var->type == SSE_AWK_NDE_ARG)
{
- ret = __do_assignment_scalar (run, (xp_awk_nde_var_t*)var, val);
+ ret = __do_assignment_scalar (run, (sse_awk_nde_var_t*)var, val);
}
- else if (var->type == XP_AWK_NDE_NAMEDIDX ||
- var->type == XP_AWK_NDE_GLOBALIDX ||
- var->type == XP_AWK_NDE_LOCALIDX ||
- var->type == XP_AWK_NDE_ARGIDX)
+ else if (var->type == SSE_AWK_NDE_NAMEDIDX ||
+ var->type == SSE_AWK_NDE_GLOBALIDX ||
+ var->type == SSE_AWK_NDE_LOCALIDX ||
+ var->type == SSE_AWK_NDE_ARGIDX)
{
- ret = __do_assignment_map (run, (xp_awk_nde_var_t*)var, val);
+ ret = __do_assignment_map (run, (sse_awk_nde_var_t*)var, val);
}
- else if (var->type == XP_AWK_NDE_POS)
+ else if (var->type == SSE_AWK_NDE_POS)
{
- ret = __do_assignment_pos (run, (xp_awk_nde_pos_t*)var, val);
+ ret = __do_assignment_pos (run, (sse_awk_nde_pos_t*)var, val);
}
else
{
- xp_awk_assert (run->awk, !"should never happen - invalid variable type");
- PANIC (run, XP_AWK_EINTERNAL);
+ sse_awk_assert (run->awk, !"should never happen - invalid variable type");
+ PANIC (run, SSE_AWK_EINTERNAL);
}
return ret;
}
-static xp_awk_val_t* __do_assignment_scalar (
- xp_awk_run_t* run, xp_awk_nde_var_t* var, xp_awk_val_t* val)
+static sse_awk_val_t* __do_assignment_scalar (
+ sse_awk_run_t* run, sse_awk_nde_var_t* var, sse_awk_val_t* val)
{
- xp_awk_assert (run->awk,
- (var->type == XP_AWK_NDE_NAMED ||
- var->type == XP_AWK_NDE_GLOBAL ||
- var->type == XP_AWK_NDE_LOCAL ||
- var->type == XP_AWK_NDE_ARG) && var->idx == XP_NULL);
+ sse_awk_assert (run->awk,
+ (var->type == SSE_AWK_NDE_NAMED ||
+ var->type == SSE_AWK_NDE_GLOBAL ||
+ var->type == SSE_AWK_NDE_LOCAL ||
+ var->type == SSE_AWK_NDE_ARG) && var->idx == SSE_NULL);
- xp_awk_assert (run->awk, val->type != XP_AWK_VAL_MAP);
+ sse_awk_assert (run->awk, val->type != SSE_AWK_VAL_MAP);
- if (var->type == XP_AWK_NDE_NAMED)
+ if (var->type == SSE_AWK_NDE_NAMED)
{
- xp_awk_pair_t* pair;
+ sse_awk_pair_t* pair;
int n;
- pair = xp_awk_map_get (
+ pair = sse_awk_map_get (
&run->named, var->id.name, var->id.name_len);
- if (pair != XP_NULL &&
- ((xp_awk_val_t*)pair->val)->type == XP_AWK_VAL_MAP)
+ if (pair != SSE_NULL &&
+ ((sse_awk_val_t*)pair->val)->type == SSE_AWK_VAL_MAP)
{
/* once a variable becomes an array,
* it cannot be changed to a scalar variable */
- PANIC (run, XP_AWK_EMAPTOSCALAR);
+ PANIC (run, SSE_AWK_EMAPTOSCALAR);
}
- n = xp_awk_map_putx (&run->named,
- var->id.name, var->id.name_len, val, XP_NULL);
- if (n < 0) PANIC (run, XP_AWK_ENOMEM);
+ n = sse_awk_map_putx (&run->named,
+ var->id.name, var->id.name_len, val, SSE_NULL);
+ if (n < 0) PANIC (run, SSE_AWK_ENOMEM);
- xp_awk_refupval (val);
+ sse_awk_refupval (val);
}
- else if (var->type == XP_AWK_NDE_GLOBAL)
+ else if (var->type == SSE_AWK_NDE_GLOBAL)
{
- if (xp_awk_setglobal (
- run, var->id.idxa, val) == -1) return XP_NULL;
+ if (sse_awk_setglobal (
+ run, var->id.idxa, val) == -1) return SSE_NULL;
}
- else if (var->type == XP_AWK_NDE_LOCAL)
+ else if (var->type == SSE_AWK_NDE_LOCAL)
{
- xp_awk_val_t* old = STACK_LOCAL(run,var->id.idxa);
- if (old->type == XP_AWK_VAL_MAP)
+ sse_awk_val_t* old = STACK_LOCAL(run,var->id.idxa);
+ if (old->type == SSE_AWK_VAL_MAP)
{
/* once the variable becomes an array,
* it cannot be changed to a scalar variable */
- PANIC (run, XP_AWK_EMAPTOSCALAR);
+ PANIC (run, SSE_AWK_EMAPTOSCALAR);
}
- xp_awk_refdownval (run, old);
+ sse_awk_refdownval (run, old);
STACK_LOCAL(run,var->id.idxa) = val;
- xp_awk_refupval (val);
+ sse_awk_refupval (val);
}
- else /* if (var->type == XP_AWK_NDE_ARG) */
+ else /* if (var->type == SSE_AWK_NDE_ARG) */
{
- xp_awk_val_t* old = STACK_ARG(run,var->id.idxa);
- if (old->type == XP_AWK_VAL_MAP)
+ sse_awk_val_t* old = STACK_ARG(run,var->id.idxa);
+ if (old->type == SSE_AWK_VAL_MAP)
{
/* once the variable becomes an array,
* it cannot be changed to a scalar variable */
- PANIC (run, XP_AWK_EMAPTOSCALAR);
+ PANIC (run, SSE_AWK_EMAPTOSCALAR);
}
- xp_awk_refdownval (run, old);
+ sse_awk_refdownval (run, old);
STACK_ARG(run,var->id.idxa) = val;
- xp_awk_refupval (val);
+ sse_awk_refupval (val);
}
return val;
}
-static xp_awk_val_t* __do_assignment_map (
- xp_awk_run_t* run, xp_awk_nde_var_t* var, xp_awk_val_t* val)
+static sse_awk_val_t* __do_assignment_map (
+ sse_awk_run_t* run, sse_awk_nde_var_t* var, sse_awk_val_t* val)
{
- xp_awk_val_map_t* map;
- xp_char_t* str;
- xp_size_t len;
+ sse_awk_val_map_t* map;
+ sse_char_t* str;
+ sse_size_t len;
int n;
- xp_awk_assert (run->awk,
- (var->type == XP_AWK_NDE_NAMEDIDX ||
- var->type == XP_AWK_NDE_GLOBALIDX ||
- var->type == XP_AWK_NDE_LOCALIDX ||
- var->type == XP_AWK_NDE_ARGIDX) && var->idx != XP_NULL);
- xp_awk_assert (run->awk, val->type != XP_AWK_VAL_MAP);
+ sse_awk_assert (run->awk,
+ (var->type == SSE_AWK_NDE_NAMEDIDX ||
+ var->type == SSE_AWK_NDE_GLOBALIDX ||
+ var->type == SSE_AWK_NDE_LOCALIDX ||
+ var->type == SSE_AWK_NDE_ARGIDX) && var->idx != SSE_NULL);
+ sse_awk_assert (run->awk, val->type != SSE_AWK_VAL_MAP);
- if (var->type == XP_AWK_NDE_NAMEDIDX)
+ if (var->type == SSE_AWK_NDE_NAMEDIDX)
{
- xp_awk_pair_t* pair;
- pair = xp_awk_map_get (
+ sse_awk_pair_t* pair;
+ pair = sse_awk_map_get (
&run->named, var->id.name, var->id.name_len);
- map = (pair == XP_NULL)?
- (xp_awk_val_map_t*)xp_awk_val_nil:
- (xp_awk_val_map_t*)pair->val;
+ map = (pair == SSE_NULL)?
+ (sse_awk_val_map_t*)sse_awk_val_nil:
+ (sse_awk_val_map_t*)pair->val;
}
else
{
- map = (var->type == XP_AWK_NDE_GLOBALIDX)?
- (xp_awk_val_map_t*)STACK_GLOBAL(run,var->id.idxa):
- (var->type == XP_AWK_NDE_LOCALIDX)?
- (xp_awk_val_map_t*)STACK_LOCAL(run,var->id.idxa):
- (xp_awk_val_map_t*)STACK_ARG(run,var->id.idxa);
+ map = (var->type == SSE_AWK_NDE_GLOBALIDX)?
+ (sse_awk_val_map_t*)STACK_GLOBAL(run,var->id.idxa):
+ (var->type == SSE_AWK_NDE_LOCALIDX)?
+ (sse_awk_val_map_t*)STACK_LOCAL(run,var->id.idxa):
+ (sse_awk_val_map_t*)STACK_ARG(run,var->id.idxa);
}
- if (map->type == XP_AWK_VAL_NIL)
+ if (map->type == SSE_AWK_VAL_NIL)
{
/* the map is not initialized yet */
- xp_awk_val_t* tmp;
+ sse_awk_val_t* tmp;
- tmp = xp_awk_makemapval (run);
- if (tmp == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ tmp = sse_awk_makemapval (run);
+ if (tmp == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
- if (var->type == XP_AWK_NDE_NAMEDIDX)
+ if (var->type == SSE_AWK_NDE_NAMEDIDX)
{
/* doesn't have to decrease the reference count
* of the previous value here as it is done by
- * xp_awk_map_put */
- if (xp_awk_map_put (&run->named,
- var->id.name, var->id.name_len, tmp) == XP_NULL)
+ * sse_awk_map_put */
+ if (sse_awk_map_put (&run->named,
+ var->id.name, var->id.name_len, tmp) == SSE_NULL)
{
- xp_awk_refupval (tmp);
- xp_awk_refdownval (run, tmp);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refupval (tmp);
+ sse_awk_refdownval (run, tmp);
+ PANIC (run, SSE_AWK_ENOMEM);
}
- xp_awk_refupval (tmp);
+ sse_awk_refupval (tmp);
}
- else if (var->type == XP_AWK_NDE_GLOBALIDX)
+ else if (var->type == SSE_AWK_NDE_GLOBALIDX)
{
- xp_awk_refupval (tmp);
- if (xp_awk_setglobal (run, var->id.idxa, tmp) == -1)
+ sse_awk_refupval (tmp);
+ if (sse_awk_setglobal (run, var->id.idxa, tmp) == -1)
{
- xp_awk_refdownval (run, tmp);
- return XP_NULL;
+ sse_awk_refdownval (run, tmp);
+ return SSE_NULL;
}
- xp_awk_refdownval (run, tmp);
+ sse_awk_refdownval (run, tmp);
}
- else if (var->type == XP_AWK_NDE_LOCALIDX)
+ else if (var->type == SSE_AWK_NDE_LOCALIDX)
{
- xp_awk_refdownval (run, (xp_awk_val_t*)map);
+ sse_awk_refdownval (run, (sse_awk_val_t*)map);
STACK_LOCAL(run,var->id.idxa) = tmp;
- xp_awk_refupval (tmp);
+ sse_awk_refupval (tmp);
}
- else /* if (var->type == XP_AWK_NDE_ARGIDX) */
+ else /* if (var->type == SSE_AWK_NDE_ARGIDX) */
{
- xp_awk_refdownval (run, (xp_awk_val_t*)map);
+ sse_awk_refdownval (run, (sse_awk_val_t*)map);
STACK_ARG(run,var->id.idxa) = tmp;
- xp_awk_refupval (tmp);
+ sse_awk_refupval (tmp);
}
- map = (xp_awk_val_map_t*) tmp;
+ map = (sse_awk_val_map_t*) tmp;
}
- else if (map->type != XP_AWK_VAL_MAP)
+ else if (map->type != SSE_AWK_VAL_MAP)
{
- PANIC (run, XP_AWK_ENOTINDEXABLE);
+ PANIC (run, SSE_AWK_ENOTINDEXABLE);
}
str = __idxnde_to_str (run, var->idx, &len);
- if (str == XP_NULL) return XP_NULL;
+ if (str == SSE_NULL) return SSE_NULL;
/*
-xp_printf (XP_T("**** index str=>%s, map->ref=%d, map->type=%d\n"), str, (int)map->ref, (int)map->type);
+sse_printf (SSE_T("**** index str=>%s, map->ref=%d, map->type=%d\n"), str, (int)map->ref, (int)map->type);
*/
- n = xp_awk_map_putx (map->map, str, len, val, XP_NULL);
+ n = sse_awk_map_putx (map->map, str, len, val, SSE_NULL);
if (n < 0)
{
- XP_AWK_FREE (run->awk, str);
- PANIC (run, XP_AWK_ENOMEM);
+ SSE_AWK_FREE (run->awk, str);
+ PANIC (run, SSE_AWK_ENOMEM);
}
- XP_AWK_FREE (run->awk, str);
- xp_awk_refupval (val);
+ SSE_AWK_FREE (run->awk, str);
+ sse_awk_refupval (val);
return val;
}
-static xp_awk_val_t* __do_assignment_pos (
- xp_awk_run_t* run, xp_awk_nde_pos_t* pos, xp_awk_val_t* val)
+static sse_awk_val_t* __do_assignment_pos (
+ sse_awk_run_t* run, sse_awk_nde_pos_t* pos, sse_awk_val_t* val)
{
- xp_awk_val_t* v;
- xp_long_t lv;
- xp_real_t rv;
- xp_char_t* str;
- xp_size_t len;
+ sse_awk_val_t* v;
+ sse_long_t lv;
+ sse_real_t rv;
+ sse_char_t* str;
+ sse_size_t len;
int n;
- v = __eval_expression (run, pos->val);
- if (v == XP_NULL) return XP_NULL;
+ v = __eval_esseression (run, pos->val);
+ if (v == SSE_NULL) return SSE_NULL;
- xp_awk_refupval (v);
- n = xp_awk_valtonum (run, v, &lv, &rv);
- xp_awk_refdownval (run, v);
+ sse_awk_refupval (v);
+ n = sse_awk_valtonum (run, v, &lv, &rv);
+ sse_awk_refdownval (run, v);
- if (n == -1) PANIC (run, XP_AWK_EPOSIDX);
- if (n == 1) lv = (xp_long_t)rv;
- if (!IS_VALID_POSIDX(lv)) PANIC (run, XP_AWK_EPOSIDX);
+ if (n == -1) PANIC (run, SSE_AWK_EPOSIDX);
+ if (n == 1) lv = (sse_long_t)rv;
+ if (!IS_VALID_POSIDX(lv)) PANIC (run, SSE_AWK_EPOSIDX);
- if (val->type == XP_AWK_VAL_STR)
+ if (val->type == SSE_AWK_VAL_STR)
{
- str = ((xp_awk_val_str_t*)val)->buf;
- len = ((xp_awk_val_str_t*)val)->len;
+ str = ((sse_awk_val_str_t*)val)->buf;
+ len = ((sse_awk_val_str_t*)val)->len;
}
else
{
- str = xp_awk_valtostr (run, val, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &len);
- if (str == XP_NULL) return XP_NULL;
+ str = sse_awk_valtostr (run, val, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
+ if (str == SSE_NULL) return SSE_NULL;
}
- n = xp_awk_setrec (run, (xp_size_t)lv, str, len);
+ n = sse_awk_setrec (run, (sse_size_t)lv, str, len);
- if (val->type != XP_AWK_VAL_STR) XP_AWK_FREE (run->awk, str);
+ if (val->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str);
- if (n == -1) return XP_NULL;
+ if (n == -1) return SSE_NULL;
return (lv == 0)? run->inrec.d0: run->inrec.flds[lv-1].val;
}
-static xp_awk_val_t* __eval_binary (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_binary (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
static binop_func_t __binop_func[] =
{
/* the order of the functions should be inline with
* the operator declaration in run.h */
- XP_NULL, /* __eval_binop_lor */
- XP_NULL, /* __eval_binop_land */
- XP_NULL, /* __eval_binop_in */
+ SSE_NULL, /* __eval_binop_lor */
+ SSE_NULL, /* __eval_binop_land */
+ SSE_NULL, /* __eval_binop_in */
__eval_binop_bor,
__eval_binop_bxor,
@@ -2704,528 +2704,528 @@ static xp_awk_val_t* __eval_binary (xp_awk_run_t* run, xp_awk_nde_t* nde)
__eval_binop_mul,
__eval_binop_div,
__eval_binop_mod,
- __eval_binop_exp,
+ __eval_binop_esse,
__eval_binop_concat,
- XP_NULL, /* __eval_binop_ma */
- XP_NULL /* __eval_binop_nm */
+ SSE_NULL, /* __eval_binop_ma */
+ SSE_NULL /* __eval_binop_nm */
};
- xp_awk_nde_exp_t* exp = (xp_awk_nde_exp_t*)nde;
- xp_awk_val_t* left, * right, * res;
+ sse_awk_nde_esse_t* esse = (sse_awk_nde_esse_t*)nde;
+ sse_awk_val_t* left, * right, * res;
- xp_awk_assert (run->awk, exp->type == XP_AWK_NDE_EXP_BIN);
+ sse_awk_assert (run->awk, esse->type == SSE_AWK_NDE_ESSE_BIN);
- if (exp->opcode == XP_AWK_BINOP_LAND)
+ if (esse->opcode == SSE_AWK_BINOP_LAND)
{
- res = __eval_binop_land (run, exp->left, exp->right);
+ res = __eval_binop_land (run, esse->left, esse->right);
}
- else if (exp->opcode == XP_AWK_BINOP_LOR)
+ else if (esse->opcode == SSE_AWK_BINOP_LOR)
{
- res = __eval_binop_lor (run, exp->left, exp->right);
+ res = __eval_binop_lor (run, esse->left, esse->right);
}
- else if (exp->opcode == XP_AWK_BINOP_IN)
+ else if (esse->opcode == SSE_AWK_BINOP_IN)
{
/* treat the in operator specially */
- res = __eval_binop_in (run, exp->left, exp->right);
+ res = __eval_binop_in (run, esse->left, esse->right);
}
- else if (exp->opcode == XP_AWK_BINOP_NM)
+ else if (esse->opcode == SSE_AWK_BINOP_NM)
{
- res = __eval_binop_nm (run, exp->left, exp->right);
+ res = __eval_binop_nm (run, esse->left, esse->right);
}
- else if (exp->opcode == XP_AWK_BINOP_MA)
+ else if (esse->opcode == SSE_AWK_BINOP_MA)
{
- res = __eval_binop_ma (run, exp->left, exp->right);
+ res = __eval_binop_ma (run, esse->left, esse->right);
}
else
{
- xp_awk_assert (run->awk, exp->left->next == XP_NULL);
- left = __eval_expression (run, exp->left);
- if (left == XP_NULL) return XP_NULL;
+ sse_awk_assert (run->awk, esse->left->next == SSE_NULL);
+ left = __eval_esseression (run, esse->left);
+ if (left == SSE_NULL) return SSE_NULL;
- xp_awk_refupval (left);
+ sse_awk_refupval (left);
- xp_awk_assert (run->awk, exp->right->next == XP_NULL);
- right = __eval_expression (run, exp->right);
- if (right == XP_NULL)
+ sse_awk_assert (run->awk, esse->right->next == SSE_NULL);
+ right = __eval_esseression (run, esse->right);
+ if (right == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- return XP_NULL;
+ sse_awk_refdownval (run, left);
+ return SSE_NULL;
}
- xp_awk_refupval (right);
+ sse_awk_refupval (right);
- xp_awk_assert (run->awk, exp->opcode >= 0 &&
- exp->opcode < xp_countof(__binop_func));
- xp_awk_assert (run->awk, __binop_func[exp->opcode] != XP_NULL);
+ sse_awk_assert (run->awk, esse->opcode >= 0 &&
+ esse->opcode < sse_countof(__binop_func));
+ sse_awk_assert (run->awk, __binop_func[esse->opcode] != SSE_NULL);
- res = __binop_func[exp->opcode] (run, left, right);
+ res = __binop_func[esse->opcode] (run, left, right);
- xp_awk_refdownval (run, left);
- xp_awk_refdownval (run, right);
+ sse_awk_refdownval (run, left);
+ sse_awk_refdownval (run, right);
}
return res;
}
-static xp_awk_val_t* __eval_binop_lor (
- xp_awk_run_t* run, xp_awk_nde_t* left, xp_awk_nde_t* right)
+static sse_awk_val_t* __eval_binop_lor (
+ sse_awk_run_t* run, sse_awk_nde_t* left, sse_awk_nde_t* right)
{
/*
- xp_awk_val_t* res = XP_NULL;
+ sse_awk_val_t* res = SSE_NULL;
- res = xp_awk_makeintval (run,
- xp_awk_valtobool(run left) || xp_awk_valtobool(run,right));
- if (res == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ res = sse_awk_makeintval (run,
+ sse_awk_valtobool(run left) || sse_awk_valtobool(run,right));
+ if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
return res;
*/
/* short-circuit evaluation required special treatment */
- xp_awk_val_t* lv, * rv, * res;
+ sse_awk_val_t* lv, * rv, * res;
- xp_awk_assert (run->awk, left->next == XP_NULL);
- lv = __eval_expression (run, left);
- if (lv == XP_NULL) return XP_NULL;
+ sse_awk_assert (run->awk, left->next == SSE_NULL);
+ lv = __eval_esseression (run, left);
+ if (lv == SSE_NULL) return SSE_NULL;
- xp_awk_refupval (lv);
- if (xp_awk_valtobool (run, lv))
+ sse_awk_refupval (lv);
+ if (sse_awk_valtobool (run, lv))
{
- /*res = xp_awk_makeintval (run, 1);*/
- res = xp_awk_val_one;
+ /*res = sse_awk_makeintval (run, 1);*/
+ res = sse_awk_val_one;
}
else
{
- xp_awk_assert (run->awk, right->next == XP_NULL);
- rv = __eval_expression (run, right);
- if (rv == XP_NULL)
+ sse_awk_assert (run->awk, right->next == SSE_NULL);
+ rv = __eval_esseression (run, right);
+ if (rv == SSE_NULL)
{
- xp_awk_refdownval (run, lv);
- return XP_NULL;
+ sse_awk_refdownval (run, lv);
+ return SSE_NULL;
}
- xp_awk_refupval (rv);
+ sse_awk_refupval (rv);
- /*res = xp_awk_makeintval (run, (xp_awk_valtobool(run,rv)? 1: 0));*/
- res = xp_awk_valtobool(run,rv)? xp_awk_val_one: xp_awk_val_zero;
- xp_awk_refdownval (run, rv);
+ /*res = sse_awk_makeintval (run, (sse_awk_valtobool(run,rv)? 1: 0));*/
+ res = sse_awk_valtobool(run,rv)? sse_awk_val_one: sse_awk_val_zero;
+ sse_awk_refdownval (run, rv);
}
- xp_awk_refdownval (run, lv);
+ sse_awk_refdownval (run, lv);
- /*if (res == XP_NULL) PANIC (run, XP_AWK_ENOMEM);*/
+ /*if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);*/
return res;
}
-static xp_awk_val_t* __eval_binop_land (
- xp_awk_run_t* run, xp_awk_nde_t* left, xp_awk_nde_t* right)
+static sse_awk_val_t* __eval_binop_land (
+ sse_awk_run_t* run, sse_awk_nde_t* left, sse_awk_nde_t* right)
{
/*
- xp_awk_val_t* res = XP_NULL;
+ sse_awk_val_t* res = SSE_NULL;
- res = xp_awk_makeintval (run,
- xp_awk_valtobool(run,left) && xp_awk_valtobool(run,right));
- if (res == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ res = sse_awk_makeintval (run,
+ sse_awk_valtobool(run,left) && sse_awk_valtobool(run,right));
+ if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
return res;
*/
/* short-circuit evaluation required special treatment */
- xp_awk_val_t* lv, * rv, * res;
+ sse_awk_val_t* lv, * rv, * res;
- xp_awk_assert (run->awk, left->next == XP_NULL);
- lv = __eval_expression (run, left);
- if (lv == XP_NULL) return XP_NULL;
+ sse_awk_assert (run->awk, left->next == SSE_NULL);
+ lv = __eval_esseression (run, left);
+ if (lv == SSE_NULL) return SSE_NULL;
- xp_awk_refupval (lv);
- if (!xp_awk_valtobool (run, lv))
+ sse_awk_refupval (lv);
+ if (!sse_awk_valtobool (run, lv))
{
- /*res = xp_awk_makeintval (run, 0);*/
- res = xp_awk_val_zero;
+ /*res = sse_awk_makeintval (run, 0);*/
+ res = sse_awk_val_zero;
}
else
{
- xp_awk_assert (run->awk, right->next == XP_NULL);
- rv = __eval_expression (run, right);
- if (rv == XP_NULL)
+ sse_awk_assert (run->awk, right->next == SSE_NULL);
+ rv = __eval_esseression (run, right);
+ if (rv == SSE_NULL)
{
- xp_awk_refdownval (run, lv);
- return XP_NULL;
+ sse_awk_refdownval (run, lv);
+ return SSE_NULL;
}
- xp_awk_refupval (rv);
+ sse_awk_refupval (rv);
- /*res = xp_awk_makeintval (run, (xp_awk_valtobool(run,rv)? 1: 0));*/
- res = xp_awk_valtobool(run,rv)? xp_awk_val_one: xp_awk_val_zero;
- xp_awk_refdownval (run, rv);
+ /*res = sse_awk_makeintval (run, (sse_awk_valtobool(run,rv)? 1: 0));*/
+ res = sse_awk_valtobool(run,rv)? sse_awk_val_one: sse_awk_val_zero;
+ sse_awk_refdownval (run, rv);
}
- xp_awk_refdownval (run, lv);
+ sse_awk_refdownval (run, lv);
- /*if (res == XP_NULL) PANIC (run, XP_AWK_ENOMEM);*/
+ /*if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);*/
return res;
}
-static xp_awk_val_t* __eval_binop_in (
- xp_awk_run_t* run, xp_awk_nde_t* left, xp_awk_nde_t* right)
+static sse_awk_val_t* __eval_binop_in (
+ sse_awk_run_t* run, sse_awk_nde_t* left, sse_awk_nde_t* right)
{
- xp_awk_val_t* rv;
- xp_char_t* str;
- xp_size_t len;
+ sse_awk_val_t* rv;
+ sse_char_t* str;
+ sse_size_t len;
- if (right->type != XP_AWK_NDE_GLOBAL &&
- right->type != XP_AWK_NDE_LOCAL &&
- right->type != XP_AWK_NDE_ARG &&
- right->type != XP_AWK_NDE_NAMED)
+ if (right->type != SSE_AWK_NDE_GLOBAL &&
+ right->type != SSE_AWK_NDE_LOCAL &&
+ right->type != SSE_AWK_NDE_ARG &&
+ right->type != SSE_AWK_NDE_NAMED)
{
/* the compiler should have handled this case */
- xp_awk_assert (run->awk, !"should never happen - in needs a plain variable");
- PANIC (run, XP_AWK_EINTERNAL);
- return XP_NULL;
+ sse_awk_assert (run->awk, !"should never happen - in needs a plain variable");
+ PANIC (run, SSE_AWK_EINTERNAL);
+ return SSE_NULL;
}
/* evaluate the left-hand side of the operator */
- str = (left->type == XP_AWK_NDE_GRP)?
- __idxnde_to_str (run, ((xp_awk_nde_grp_t*)left)->body, &len):
+ str = (left->type == SSE_AWK_NDE_GRP)?
+ __idxnde_to_str (run, ((sse_awk_nde_grp_t*)left)->body, &len):
__idxnde_to_str (run, left, &len);
- if (str == XP_NULL) return XP_NULL;
+ if (str == SSE_NULL) return SSE_NULL;
/* evaluate the right-hand side of the operator */
- xp_awk_assert (run->awk, right->next == XP_NULL);
- rv = __eval_expression (run, right);
- if (rv == XP_NULL)
+ sse_awk_assert (run->awk, right->next == SSE_NULL);
+ rv = __eval_esseression (run, right);
+ if (rv == SSE_NULL)
{
- XP_AWK_FREE (run->awk, str);
- return XP_NULL;
+ SSE_AWK_FREE (run->awk, str);
+ return SSE_NULL;
}
- xp_awk_refupval (rv);
+ sse_awk_refupval (rv);
- if (rv->type == XP_AWK_VAL_NIL)
+ if (rv->type == SSE_AWK_VAL_NIL)
{
- XP_AWK_FREE (run->awk, str);
- xp_awk_refdownval (run, rv);
- return xp_awk_val_zero;
+ SSE_AWK_FREE (run->awk, str);
+ sse_awk_refdownval (run, rv);
+ return sse_awk_val_zero;
}
- else if (rv->type == XP_AWK_VAL_MAP)
+ else if (rv->type == SSE_AWK_VAL_MAP)
{
- xp_awk_val_t* res;
- xp_awk_map_t* map;
+ sse_awk_val_t* res;
+ sse_awk_map_t* map;
- map = ((xp_awk_val_map_t*)rv)->map;
+ map = ((sse_awk_val_map_t*)rv)->map;
- /*r = (xp_long_t)(xp_awk_map_get (map, str, len) != XP_NULL);
- res = xp_awk_makeintval (run, r);
- if (res == XP_NULL)
+ /*r = (sse_long_t)(sse_awk_map_get (map, str, len) != SSE_NULL);
+ res = sse_awk_makeintval (run, r);
+ if (res == SSE_NULL)
{
- XP_AWK_FREE (run->awk, str);
- xp_awk_refdownval (run, rv);
- PANIC (run, XP_AWK_ENOMEM);
+ SSE_AWK_FREE (run->awk, str);
+ sse_awk_refdownval (run, rv);
+ PANIC (run, SSE_AWK_ENOMEM);
}*/
- res = (xp_awk_map_get (map, str, len) == XP_NULL)?
- xp_awk_val_zero: xp_awk_val_one;
+ res = (sse_awk_map_get (map, str, len) == SSE_NULL)?
+ sse_awk_val_zero: sse_awk_val_one;
- XP_AWK_FREE (run->awk, str);
- xp_awk_refdownval (run, rv);
+ SSE_AWK_FREE (run->awk, str);
+ sse_awk_refdownval (run, rv);
return res;
}
/* need an array */
/* TODO: change the error code to make it clearer */
- PANIC (run, XP_AWK_EOPERAND);
- return XP_NULL;
+ PANIC (run, SSE_AWK_EOPERAND);
+ return SSE_NULL;
}
-static xp_awk_val_t* __eval_binop_bor (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+static sse_awk_val_t* __eval_binop_bor (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
- xp_awk_val_t* res = XP_NULL;
+ sse_awk_val_t* res = SSE_NULL;
- if (left->type == XP_AWK_VAL_INT &&
- right->type == XP_AWK_VAL_INT)
+ if (left->type == SSE_AWK_VAL_INT &&
+ right->type == SSE_AWK_VAL_INT)
{
- xp_long_t r =
- ((xp_awk_val_int_t*)left)->val |
- ((xp_awk_val_int_t*)right)->val;
- res = xp_awk_makeintval (run, r);
+ sse_long_t r =
+ ((sse_awk_val_int_t*)left)->val |
+ ((sse_awk_val_int_t*)right)->val;
+ res = sse_awk_makeintval (run, r);
}
else
{
- PANIC (run, XP_AWK_EOPERAND);
+ PANIC (run, SSE_AWK_EOPERAND);
}
- if (res == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
return res;
}
-static xp_awk_val_t* __eval_binop_bxor (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+static sse_awk_val_t* __eval_binop_bxor (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
- xp_awk_val_t* res = XP_NULL;
+ sse_awk_val_t* res = SSE_NULL;
- if (left->type == XP_AWK_VAL_INT &&
- right->type == XP_AWK_VAL_INT)
+ if (left->type == SSE_AWK_VAL_INT &&
+ right->type == SSE_AWK_VAL_INT)
{
- xp_long_t r =
- ((xp_awk_val_int_t*)left)->val ^
- ((xp_awk_val_int_t*)right)->val;
- res = xp_awk_makeintval (run, r);
+ sse_long_t r =
+ ((sse_awk_val_int_t*)left)->val ^
+ ((sse_awk_val_int_t*)right)->val;
+ res = sse_awk_makeintval (run, r);
}
else
{
- PANIC (run, XP_AWK_EOPERAND);
+ PANIC (run, SSE_AWK_EOPERAND);
}
- if (res == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
return res;
}
-static xp_awk_val_t* __eval_binop_band (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+static sse_awk_val_t* __eval_binop_band (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
- xp_awk_val_t* res = XP_NULL;
+ sse_awk_val_t* res = SSE_NULL;
- if (left->type == XP_AWK_VAL_INT &&
- right->type == XP_AWK_VAL_INT)
+ if (left->type == SSE_AWK_VAL_INT &&
+ right->type == SSE_AWK_VAL_INT)
{
- xp_long_t r =
- ((xp_awk_val_int_t*)left)->val &
- ((xp_awk_val_int_t*)right)->val;
- res = xp_awk_makeintval (run, r);
+ sse_long_t r =
+ ((sse_awk_val_int_t*)left)->val &
+ ((sse_awk_val_int_t*)right)->val;
+ res = sse_awk_makeintval (run, r);
}
else
{
- PANIC (run, XP_AWK_EOPERAND);
+ PANIC (run, SSE_AWK_EOPERAND);
}
- if (res == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
return res;
}
static int __cmp_nil_nil (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
return 0;
}
static int __cmp_nil_int (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
- if (((xp_awk_val_int_t*)right)->val < 0) return 1;
- if (((xp_awk_val_int_t*)right)->val > 0) return -1;
+ if (((sse_awk_val_int_t*)right)->val < 0) return 1;
+ if (((sse_awk_val_int_t*)right)->val > 0) return -1;
return 0;
}
static int __cmp_nil_real (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
- if (((xp_awk_val_real_t*)right)->val < 0) return 1;
- if (((xp_awk_val_real_t*)right)->val > 0) return -1;
+ if (((sse_awk_val_real_t*)right)->val < 0) return 1;
+ if (((sse_awk_val_real_t*)right)->val > 0) return -1;
return 0;
}
static int __cmp_nil_str (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
- return (((xp_awk_val_str_t*)right)->len == 0)? 0: -1;
+ return (((sse_awk_val_str_t*)right)->len == 0)? 0: -1;
}
static int __cmp_int_nil (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
- if (((xp_awk_val_int_t*)left)->val > 0) return 1;
- if (((xp_awk_val_int_t*)left)->val < 0) return -1;
+ if (((sse_awk_val_int_t*)left)->val > 0) return 1;
+ if (((sse_awk_val_int_t*)left)->val < 0) return -1;
return 0;
}
static int __cmp_int_int (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
- if (((xp_awk_val_int_t*)left)->val >
- ((xp_awk_val_int_t*)right)->val) return 1;
- if (((xp_awk_val_int_t*)left)->val <
- ((xp_awk_val_int_t*)right)->val) return -1;
+ if (((sse_awk_val_int_t*)left)->val >
+ ((sse_awk_val_int_t*)right)->val) return 1;
+ if (((sse_awk_val_int_t*)left)->val <
+ ((sse_awk_val_int_t*)right)->val) return -1;
return 0;
}
static int __cmp_int_real (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
- if (((xp_awk_val_int_t*)left)->val >
- ((xp_awk_val_real_t*)right)->val) return 1;
- if (((xp_awk_val_int_t*)left)->val <
- ((xp_awk_val_real_t*)right)->val) return -1;
+ if (((sse_awk_val_int_t*)left)->val >
+ ((sse_awk_val_real_t*)right)->val) return 1;
+ if (((sse_awk_val_int_t*)left)->val <
+ ((sse_awk_val_real_t*)right)->val) return -1;
return 0;
}
static int __cmp_int_str (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
- xp_char_t* str;
- xp_size_t len;
- xp_long_t r;
- xp_real_t rr;
+ sse_char_t* str;
+ sse_size_t len;
+ sse_long_t r;
+ sse_real_t rr;
int n;
- r = xp_awk_strxtolong (run->awk,
- ((xp_awk_val_str_t*)right)->buf,
- ((xp_awk_val_str_t*)right)->len, 0, (const xp_char_t**)&str);
- if (str == ((xp_awk_val_str_t*)right)->buf +
- ((xp_awk_val_str_t*)right)->len)
+ r = sse_awk_strxtolong (run->awk,
+ ((sse_awk_val_str_t*)right)->buf,
+ ((sse_awk_val_str_t*)right)->len, 0, (const sse_char_t**)&str);
+ if (str == ((sse_awk_val_str_t*)right)->buf +
+ ((sse_awk_val_str_t*)right)->len)
{
- if (((xp_awk_val_int_t*)left)->val > r) return 1;
- if (((xp_awk_val_int_t*)left)->val < r) return -1;
+ if (((sse_awk_val_int_t*)left)->val > r) return 1;
+ if (((sse_awk_val_int_t*)left)->val < r) return -1;
return 0;
}
/* TODO: should i do this??? conversion to real and comparision... */
- else if (*str == XP_T('.') || *str == XP_T('E') || *str == XP_T('e'))
+ else if (*str == SSE_T('.') || *str == SSE_T('E') || *str == SSE_T('e'))
{
- rr = xp_awk_strxtoreal (run->awk,
- ((xp_awk_val_str_t*)right)->buf,
- ((xp_awk_val_str_t*)right)->len,
- (const xp_char_t**)&str);
- if (str == ((xp_awk_val_str_t*)right)->buf +
- ((xp_awk_val_str_t*)right)->len)
+ rr = sse_awk_strxtoreal (run->awk,
+ ((sse_awk_val_str_t*)right)->buf,
+ ((sse_awk_val_str_t*)right)->len,
+ (const sse_char_t**)&str);
+ if (str == ((sse_awk_val_str_t*)right)->buf +
+ ((sse_awk_val_str_t*)right)->len)
{
- if (((xp_awk_val_int_t*)left)->val > rr) return 1;
- if (((xp_awk_val_int_t*)left)->val < rr) return -1;
+ if (((sse_awk_val_int_t*)left)->val > rr) return 1;
+ if (((sse_awk_val_int_t*)left)->val < rr) return -1;
return 0;
}
}
- str = xp_awk_valtostr (run, left, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &len);
- if (str == XP_NULL)
+ str = sse_awk_valtostr (run, left, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
+ if (str == SSE_NULL)
{
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
return CMP_ERROR;
}
if (run->global.ignorecase)
{
- n = xp_awk_strxncasecmp (
+ n = sse_awk_strxncasecmp (
run->awk, str, len,
- ((xp_awk_val_str_t*)right)->buf,
- ((xp_awk_val_str_t*)right)->len);
+ ((sse_awk_val_str_t*)right)->buf,
+ ((sse_awk_val_str_t*)right)->len);
}
else
{
- n = xp_awk_strxncmp (
+ n = sse_awk_strxncmp (
str, len,
- ((xp_awk_val_str_t*)right)->buf,
- ((xp_awk_val_str_t*)right)->len);
+ ((sse_awk_val_str_t*)right)->buf,
+ ((sse_awk_val_str_t*)right)->len);
}
- XP_AWK_FREE (run->awk, str);
+ SSE_AWK_FREE (run->awk, str);
return n;
}
static int __cmp_real_nil (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
- if (((xp_awk_val_real_t*)left)->val > 0) return 1;
- if (((xp_awk_val_real_t*)left)->val < 0) return -1;
+ if (((sse_awk_val_real_t*)left)->val > 0) return 1;
+ if (((sse_awk_val_real_t*)left)->val < 0) return -1;
return 0;
}
static int __cmp_real_int (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
- if (((xp_awk_val_real_t*)left)->val >
- ((xp_awk_val_int_t*)right)->val) return 1;
- if (((xp_awk_val_real_t*)left)->val <
- ((xp_awk_val_int_t*)right)->val) return -1;
+ if (((sse_awk_val_real_t*)left)->val >
+ ((sse_awk_val_int_t*)right)->val) return 1;
+ if (((sse_awk_val_real_t*)left)->val <
+ ((sse_awk_val_int_t*)right)->val) return -1;
return 0;
}
static int __cmp_real_real (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
- if (((xp_awk_val_real_t*)left)->val >
- ((xp_awk_val_real_t*)right)->val) return 1;
- if (((xp_awk_val_real_t*)left)->val <
- ((xp_awk_val_real_t*)right)->val) return -1;
+ if (((sse_awk_val_real_t*)left)->val >
+ ((sse_awk_val_real_t*)right)->val) return 1;
+ if (((sse_awk_val_real_t*)left)->val <
+ ((sse_awk_val_real_t*)right)->val) return -1;
return 0;
}
static int __cmp_real_str (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
- xp_char_t* str;
- xp_size_t len;
- xp_real_t rr;
+ sse_char_t* str;
+ sse_size_t len;
+ sse_real_t rr;
int n;
- rr = xp_awk_strxtoreal (run->awk,
- ((xp_awk_val_str_t*)right)->buf,
- ((xp_awk_val_str_t*)right)->len,
- (const xp_char_t**)&str);
- if (str == ((xp_awk_val_str_t*)right)->buf +
- ((xp_awk_val_str_t*)right)->len)
+ rr = sse_awk_strxtoreal (run->awk,
+ ((sse_awk_val_str_t*)right)->buf,
+ ((sse_awk_val_str_t*)right)->len,
+ (const sse_char_t**)&str);
+ if (str == ((sse_awk_val_str_t*)right)->buf +
+ ((sse_awk_val_str_t*)right)->len)
{
- if (((xp_awk_val_real_t*)left)->val > rr) return 1;
- if (((xp_awk_val_real_t*)left)->val < rr) return -1;
+ if (((sse_awk_val_real_t*)left)->val > rr) return 1;
+ if (((sse_awk_val_real_t*)left)->val < rr) return -1;
return 0;
}
- str = xp_awk_valtostr (run, left, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &len);
- if (str == XP_NULL)
+ str = sse_awk_valtostr (run, left, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
+ if (str == SSE_NULL)
{
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
return CMP_ERROR;
}
if (run->global.ignorecase)
{
- n = xp_awk_strxncasecmp (
+ n = sse_awk_strxncasecmp (
run->awk, str, len,
- ((xp_awk_val_str_t*)right)->buf,
- ((xp_awk_val_str_t*)right)->len);
+ ((sse_awk_val_str_t*)right)->buf,
+ ((sse_awk_val_str_t*)right)->len);
}
else
{
- n = xp_awk_strxncmp (
+ n = sse_awk_strxncmp (
str, len,
- ((xp_awk_val_str_t*)right)->buf,
- ((xp_awk_val_str_t*)right)->len);
+ ((sse_awk_val_str_t*)right)->buf,
+ ((sse_awk_val_str_t*)right)->len);
}
- XP_AWK_FREE (run->awk, str);
+ SSE_AWK_FREE (run->awk, str);
return n;
}
static int __cmp_str_nil (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
- return (((xp_awk_val_str_t*)left)->len == 0)? 0: 1;
+ return (((sse_awk_val_str_t*)left)->len == 0)? 0: 1;
}
static int __cmp_str_int (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
return -__cmp_int_str (run, right, left);
}
static int __cmp_str_real (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
return -__cmp_real_str (run, right, left);
}
static int __cmp_str_str (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
int n;
- xp_awk_val_str_t* ls, * rs;
+ sse_awk_val_str_t* ls, * rs;
- ls = (xp_awk_val_str_t*)left;
- rs = (xp_awk_val_str_t*)right;
+ ls = (sse_awk_val_str_t*)left;
+ rs = (sse_awk_val_str_t*)right;
if (run->global.ignorecase)
{
- n = xp_awk_strxncasecmp (run->awk,
+ n = sse_awk_strxncasecmp (run->awk,
ls->buf, ls->len, rs->buf, rs->len);
}
else
{
- n = xp_awk_strxncmp (
+ n = sse_awk_strxncmp (
ls->buf, ls->len, rs->buf, rs->len);
}
@@ -3233,145 +3233,145 @@ static int __cmp_str_str (
}
static int __cmp_val (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
- typedef int (*cmp_val_t) (xp_awk_run_t*, xp_awk_val_t*, xp_awk_val_t*);
+ typedef int (*cmp_val_t) (sse_awk_run_t*, sse_awk_val_t*, sse_awk_val_t*);
static cmp_val_t func[] =
{
/* this table must be synchronized with
- * the XP_AWK_VAL_XXX values in val.h */
+ * the SSE_AWK_VAL_XXX values in val.h */
__cmp_nil_nil, __cmp_nil_int, __cmp_nil_real, __cmp_nil_str,
__cmp_int_nil, __cmp_int_int, __cmp_int_real, __cmp_int_str,
__cmp_real_nil, __cmp_real_int, __cmp_real_real, __cmp_real_str,
__cmp_str_nil, __cmp_str_int, __cmp_str_real, __cmp_str_str,
};
- if (left->type == XP_AWK_VAL_MAP || right->type == XP_AWK_VAL_MAP)
+ if (left->type == SSE_AWK_VAL_MAP || right->type == SSE_AWK_VAL_MAP)
{
/* a map can't be compared againt other values */
- run->errnum = XP_AWK_EOPERAND;
+ run->errnum = SSE_AWK_EOPERAND;
return CMP_ERROR;
}
- xp_awk_assert (run->awk, left->type >= XP_AWK_VAL_NIL &&
- left->type <= XP_AWK_VAL_STR);
- xp_awk_assert (run->awk, right->type >= XP_AWK_VAL_NIL &&
- right->type <= XP_AWK_VAL_STR);
+ sse_awk_assert (run->awk, left->type >= SSE_AWK_VAL_NIL &&
+ left->type <= SSE_AWK_VAL_STR);
+ sse_awk_assert (run->awk, right->type >= SSE_AWK_VAL_NIL &&
+ right->type <= SSE_AWK_VAL_STR);
return func[left->type*4+right->type] (run, left, right);
}
-static xp_awk_val_t* __eval_binop_eq (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+static sse_awk_val_t* __eval_binop_eq (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
int n = __cmp_val (run, left, right);
- if (n == CMP_ERROR) return XP_NULL;
- return (n == 0)? xp_awk_val_one: xp_awk_val_zero;
+ if (n == CMP_ERROR) return SSE_NULL;
+ return (n == 0)? sse_awk_val_one: sse_awk_val_zero;
}
-static xp_awk_val_t* __eval_binop_ne (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+static sse_awk_val_t* __eval_binop_ne (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
int n = __cmp_val (run, left, right);
- if (n == CMP_ERROR) return XP_NULL;
- return (n != 0)? xp_awk_val_one: xp_awk_val_zero;
+ if (n == CMP_ERROR) return SSE_NULL;
+ return (n != 0)? sse_awk_val_one: sse_awk_val_zero;
}
-static xp_awk_val_t* __eval_binop_gt (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+static sse_awk_val_t* __eval_binop_gt (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
int n = __cmp_val (run, left, right);
- if (n == CMP_ERROR) return XP_NULL;
- return (n > 0)? xp_awk_val_one: xp_awk_val_zero;
+ if (n == CMP_ERROR) return SSE_NULL;
+ return (n > 0)? sse_awk_val_one: sse_awk_val_zero;
}
-static xp_awk_val_t* __eval_binop_ge (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+static sse_awk_val_t* __eval_binop_ge (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
int n = __cmp_val (run, left, right);
- if (n == CMP_ERROR) return XP_NULL;
- return (n >= 0)? xp_awk_val_one: xp_awk_val_zero;
+ if (n == CMP_ERROR) return SSE_NULL;
+ return (n >= 0)? sse_awk_val_one: sse_awk_val_zero;
}
-static xp_awk_val_t* __eval_binop_lt (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+static sse_awk_val_t* __eval_binop_lt (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
int n = __cmp_val (run, left, right);
- if (n == CMP_ERROR) return XP_NULL;
- return (n < 0)? xp_awk_val_one: xp_awk_val_zero;
+ if (n == CMP_ERROR) return SSE_NULL;
+ return (n < 0)? sse_awk_val_one: sse_awk_val_zero;
}
-static xp_awk_val_t* __eval_binop_le (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+static sse_awk_val_t* __eval_binop_le (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
int n = __cmp_val (run, left, right);
- if (n == CMP_ERROR) return XP_NULL;
- return (n <= 0)? xp_awk_val_one: xp_awk_val_zero;
+ if (n == CMP_ERROR) return SSE_NULL;
+ return (n <= 0)? sse_awk_val_one: sse_awk_val_zero;
}
-static xp_awk_val_t* __eval_binop_lshift (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+static sse_awk_val_t* __eval_binop_lshift (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
int n1, n2, n3;
- xp_long_t l1, l2;
- xp_real_t r1, r2;
- xp_awk_val_t* res;
+ sse_long_t l1, l2;
+ sse_real_t r1, r2;
+ sse_awk_val_t* res;
- n1 = xp_awk_valtonum (run, left, &l1, &r1);
- n2 = xp_awk_valtonum (run, right, &l2, &r2);
+ n1 = sse_awk_valtonum (run, left, &l1, &r1);
+ n2 = sse_awk_valtonum (run, right, &l2, &r2);
- if (n1 == -1 || n2 == -1) PANIC (run, XP_AWK_EOPERAND);
+ if (n1 == -1 || n2 == -1) PANIC (run, SSE_AWK_EOPERAND);
n3 = n1 + (n2 << 1);
if (n3 == 0)
{
- if (l2 == 0) PANIC (run, XP_AWK_EDIVBYZERO);
- res = xp_awk_makeintval (run, (xp_long_t)l1 << (xp_long_t)l2);
+ if (l2 == 0) PANIC (run, SSE_AWK_EDIVBYZERO);
+ res = sse_awk_makeintval (run, (sse_long_t)l1 << (sse_long_t)l2);
}
- else PANIC (run, XP_AWK_EOPERAND);
+ else PANIC (run, SSE_AWK_EOPERAND);
- if (res == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
return res;
}
-static xp_awk_val_t* __eval_binop_rshift (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+static sse_awk_val_t* __eval_binop_rshift (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
int n1, n2, n3;
- xp_long_t l1, l2;
- xp_real_t r1, r2;
- xp_awk_val_t* res;
+ sse_long_t l1, l2;
+ sse_real_t r1, r2;
+ sse_awk_val_t* res;
- n1 = xp_awk_valtonum (run, left, &l1, &r1);
- n2 = xp_awk_valtonum (run, right, &l2, &r2);
+ n1 = sse_awk_valtonum (run, left, &l1, &r1);
+ n2 = sse_awk_valtonum (run, right, &l2, &r2);
- if (n1 == -1 || n2 == -1) PANIC (run, XP_AWK_EOPERAND);
+ if (n1 == -1 || n2 == -1) PANIC (run, SSE_AWK_EOPERAND);
n3 = n1 + (n2 << 1);
if (n3 == 0)
{
- if (l2 == 0) PANIC (run, XP_AWK_EDIVBYZERO);
- res = xp_awk_makeintval (run, (xp_long_t)l1 >> (xp_long_t)l2);
+ if (l2 == 0) PANIC (run, SSE_AWK_EDIVBYZERO);
+ res = sse_awk_makeintval (run, (sse_long_t)l1 >> (sse_long_t)l2);
}
- else PANIC (run, XP_AWK_EOPERAND);
+ else PANIC (run, SSE_AWK_EOPERAND);
- if (res == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
return res;
}
-static xp_awk_val_t* __eval_binop_plus (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+static sse_awk_val_t* __eval_binop_plus (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
int n1, n2, n3;
- xp_long_t l1, l2;
- xp_real_t r1, r2;
- xp_awk_val_t* res;
+ sse_long_t l1, l2;
+ sse_real_t r1, r2;
+ sse_awk_val_t* res;
- n1 = xp_awk_valtonum (run, left, &l1, &r1);
- n2 = xp_awk_valtonum (run, right, &l2, &r2);
+ n1 = sse_awk_valtonum (run, left, &l1, &r1);
+ n2 = sse_awk_valtonum (run, right, &l2, &r2);
- if (n1 == -1 || n2 == -1) PANIC (run, XP_AWK_EOPERAND);
+ if (n1 == -1 || n2 == -1) PANIC (run, SSE_AWK_EOPERAND);
/*
n1 n2 n3
0 0 = 0
@@ -3380,889 +3380,889 @@ static xp_awk_val_t* __eval_binop_plus (
1 1 = 3
*/
n3 = n1 + (n2 << 1);
- xp_awk_assert (run->awk, n3 >= 0 && n3 <= 3);
- res = (n3 == 0)? xp_awk_makeintval(run,(xp_long_t)l1+(xp_long_t)l2):
- (n3 == 1)? xp_awk_makerealval(run,(xp_real_t)r1+(xp_real_t)l2):
- (n3 == 2)? xp_awk_makerealval(run,(xp_real_t)l1+(xp_real_t)r2):
- xp_awk_makerealval(run,(xp_real_t)r1+(xp_real_t)r2);
+ sse_awk_assert (run->awk, n3 >= 0 && n3 <= 3);
+ res = (n3 == 0)? sse_awk_makeintval(run,(sse_long_t)l1+(sse_long_t)l2):
+ (n3 == 1)? sse_awk_makerealval(run,(sse_real_t)r1+(sse_real_t)l2):
+ (n3 == 2)? sse_awk_makerealval(run,(sse_real_t)l1+(sse_real_t)r2):
+ sse_awk_makerealval(run,(sse_real_t)r1+(sse_real_t)r2);
- if (res == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
return res;
}
-static xp_awk_val_t* __eval_binop_minus (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+static sse_awk_val_t* __eval_binop_minus (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
int n1, n2, n3;
- xp_long_t l1, l2;
- xp_real_t r1, r2;
- xp_awk_val_t* res;
+ sse_long_t l1, l2;
+ sse_real_t r1, r2;
+ sse_awk_val_t* res;
- n1 = xp_awk_valtonum (run, left, &l1, &r1);
- n2 = xp_awk_valtonum (run, right, &l2, &r2);
+ n1 = sse_awk_valtonum (run, left, &l1, &r1);
+ n2 = sse_awk_valtonum (run, right, &l2, &r2);
- if (n1 == -1 || n2 == -1) PANIC (run, XP_AWK_EOPERAND);
+ if (n1 == -1 || n2 == -1) PANIC (run, SSE_AWK_EOPERAND);
n3 = n1 + (n2 << 1);
- xp_awk_assert (run->awk, n3 >= 0 && n3 <= 3);
- res = (n3 == 0)? xp_awk_makeintval(run,(xp_long_t)l1-(xp_long_t)l2):
- (n3 == 1)? xp_awk_makerealval(run,(xp_real_t)r1-(xp_real_t)l2):
- (n3 == 2)? xp_awk_makerealval(run,(xp_real_t)l1-(xp_real_t)r2):
- xp_awk_makerealval(run,(xp_real_t)r1-(xp_real_t)r2);
+ sse_awk_assert (run->awk, n3 >= 0 && n3 <= 3);
+ res = (n3 == 0)? sse_awk_makeintval(run,(sse_long_t)l1-(sse_long_t)l2):
+ (n3 == 1)? sse_awk_makerealval(run,(sse_real_t)r1-(sse_real_t)l2):
+ (n3 == 2)? sse_awk_makerealval(run,(sse_real_t)l1-(sse_real_t)r2):
+ sse_awk_makerealval(run,(sse_real_t)r1-(sse_real_t)r2);
- if (res == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
return res;
}
-static xp_awk_val_t* __eval_binop_mul (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+static sse_awk_val_t* __eval_binop_mul (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
int n1, n2, n3;
- xp_long_t l1, l2;
- xp_real_t r1, r2;
- xp_awk_val_t* res;
+ sse_long_t l1, l2;
+ sse_real_t r1, r2;
+ sse_awk_val_t* res;
- n1 = xp_awk_valtonum (run, left, &l1, &r1);
- n2 = xp_awk_valtonum (run, right, &l2, &r2);
+ n1 = sse_awk_valtonum (run, left, &l1, &r1);
+ n2 = sse_awk_valtonum (run, right, &l2, &r2);
- if (n1 == -1 || n2 == -1) PANIC (run, XP_AWK_EOPERAND);
+ if (n1 == -1 || n2 == -1) PANIC (run, SSE_AWK_EOPERAND);
n3 = n1 + (n2 << 1);
- xp_awk_assert (run->awk, n3 >= 0 && n3 <= 3);
- res = (n3 == 0)? xp_awk_makeintval(run,(xp_long_t)l1*(xp_long_t)l2):
- (n3 == 1)? xp_awk_makerealval(run,(xp_real_t)r1*(xp_real_t)l2):
- (n3 == 2)? xp_awk_makerealval(run,(xp_real_t)l1*(xp_real_t)r2):
- xp_awk_makerealval(run,(xp_real_t)r1*(xp_real_t)r2);
+ sse_awk_assert (run->awk, n3 >= 0 && n3 <= 3);
+ res = (n3 == 0)? sse_awk_makeintval(run,(sse_long_t)l1*(sse_long_t)l2):
+ (n3 == 1)? sse_awk_makerealval(run,(sse_real_t)r1*(sse_real_t)l2):
+ (n3 == 2)? sse_awk_makerealval(run,(sse_real_t)l1*(sse_real_t)r2):
+ sse_awk_makerealval(run,(sse_real_t)r1*(sse_real_t)r2);
- if (res == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
return res;
}
-static xp_awk_val_t* __eval_binop_div (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+static sse_awk_val_t* __eval_binop_div (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
int n1, n2, n3;
- xp_long_t l1, l2;
- xp_real_t r1, r2;
- xp_awk_val_t* res;
+ sse_long_t l1, l2;
+ sse_real_t r1, r2;
+ sse_awk_val_t* res;
- n1 = xp_awk_valtonum (run, left, &l1, &r1);
- n2 = xp_awk_valtonum (run, right, &l2, &r2);
+ n1 = sse_awk_valtonum (run, left, &l1, &r1);
+ n2 = sse_awk_valtonum (run, right, &l2, &r2);
- if (n1 == -1 || n2 == -1) PANIC (run, XP_AWK_EOPERAND);
+ if (n1 == -1 || n2 == -1) PANIC (run, SSE_AWK_EOPERAND);
n3 = n1 + (n2 << 1);
if (n3 == 0)
{
- if (l2 == 0) PANIC (run, XP_AWK_EDIVBYZERO);
- res = xp_awk_makeintval (run, (xp_long_t)l1 / (xp_long_t)l2);
+ if (l2 == 0) PANIC (run, SSE_AWK_EDIVBYZERO);
+ res = sse_awk_makeintval (run, (sse_long_t)l1 / (sse_long_t)l2);
}
else if (n3 == 1)
{
- res = xp_awk_makerealval (run, (xp_real_t)r1 / (xp_real_t)l2);
+ res = sse_awk_makerealval (run, (sse_real_t)r1 / (sse_real_t)l2);
}
else if (n3 == 2)
{
- res = xp_awk_makerealval (run, (xp_real_t)l1 / (xp_real_t)r2);
+ res = sse_awk_makerealval (run, (sse_real_t)l1 / (sse_real_t)r2);
}
else
{
- xp_awk_assert (run->awk, n3 == 3);
- res = xp_awk_makerealval (run, (xp_real_t)r1 / (xp_real_t)r2);
+ sse_awk_assert (run->awk, n3 == 3);
+ res = sse_awk_makerealval (run, (sse_real_t)r1 / (sse_real_t)r2);
}
- if (res == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
return res;
}
-static xp_awk_val_t* __eval_binop_mod (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+static sse_awk_val_t* __eval_binop_mod (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
int n1, n2, n3;
- xp_long_t l1, l2;
- xp_real_t r1, r2;
- xp_awk_val_t* res;
+ sse_long_t l1, l2;
+ sse_real_t r1, r2;
+ sse_awk_val_t* res;
- n1 = xp_awk_valtonum (run, left, &l1, &r1);
- n2 = xp_awk_valtonum (run, right, &l2, &r2);
+ n1 = sse_awk_valtonum (run, left, &l1, &r1);
+ n2 = sse_awk_valtonum (run, right, &l2, &r2);
- if (n1 == -1 || n2 == -1) PANIC (run, XP_AWK_EOPERAND);
+ if (n1 == -1 || n2 == -1) PANIC (run, SSE_AWK_EOPERAND);
n3 = n1 + (n2 << 1);
if (n3 == 0)
{
- if (l2 == 0) PANIC (run, XP_AWK_EDIVBYZERO);
- res = xp_awk_makeintval (run, (xp_long_t)l1 % (xp_long_t)l2);
+ if (l2 == 0) PANIC (run, SSE_AWK_EDIVBYZERO);
+ res = sse_awk_makeintval (run, (sse_long_t)l1 % (sse_long_t)l2);
}
- else PANIC (run, XP_AWK_EOPERAND);
+ else PANIC (run, SSE_AWK_EOPERAND);
- if (res == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
return res;
}
-static xp_awk_val_t* __eval_binop_exp (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+static sse_awk_val_t* __eval_binop_esse (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
int n1, n2, n3;
- xp_long_t l1, l2;
- xp_real_t r1, r2;
- xp_awk_val_t* res;
+ sse_long_t l1, l2;
+ sse_real_t r1, r2;
+ sse_awk_val_t* res;
- n1 = xp_awk_valtonum (run, left, &l1, &r1);
- n2 = xp_awk_valtonum (run, right, &l2, &r2);
+ n1 = sse_awk_valtonum (run, left, &l1, &r1);
+ n2 = sse_awk_valtonum (run, right, &l2, &r2);
- if (n1 == -1 || n2 == -1) PANIC (run, XP_AWK_EOPERAND);
+ if (n1 == -1 || n2 == -1) PANIC (run, SSE_AWK_EOPERAND);
n3 = n1 + (n2 << 1);
if (n3 == 0)
{
- xp_long_t v = 1;
+ sse_long_t v = 1;
while (l2-- > 0) v *= l1;
- res = xp_awk_makeintval (run, v);
+ res = sse_awk_makeintval (run, v);
}
else if (n3 == 1)
{
- /*res = xp_awk_makerealval (
- run, pow((xp_real_t)r1,(xp_real_t)l2));*/
- xp_real_t v = 1.0;
+ /*res = sse_awk_makerealval (
+ run, pow((sse_real_t)r1,(sse_real_t)l2));*/
+ sse_real_t v = 1.0;
while (l2-- > 0) v *= r1;
- res = xp_awk_makerealval (run, v);
+ res = sse_awk_makerealval (run, v);
}
else if (n3 == 2)
{
- res = xp_awk_makerealval (
- run, pow((xp_real_t)l1,(xp_real_t)r2));
+ res = sse_awk_makerealval (
+ run, pow((sse_real_t)l1,(sse_real_t)r2));
}
else
{
- xp_awk_assert (run->awk, n3 == 3);
- res = xp_awk_makerealval (
- run, pow((xp_real_t)r1,(xp_real_t)r2));
+ sse_awk_assert (run->awk, n3 == 3);
+ res = sse_awk_makerealval (
+ run, pow((sse_real_t)r1,(sse_real_t)r2));
}
- if (res == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
return res;
}
-static xp_awk_val_t* __eval_binop_concat (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right)
+static sse_awk_val_t* __eval_binop_concat (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
{
- xp_char_t* strl, * strr;
- xp_size_t strl_len, strr_len;
- xp_awk_val_t* res;
+ sse_char_t* strl, * strr;
+ sse_size_t strl_len, strr_len;
+ sse_awk_val_t* res;
- strl = xp_awk_valtostr (
- run, left, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &strl_len);
- if (strl == XP_NULL) return XP_NULL;
+ strl = sse_awk_valtostr (
+ run, left, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &strl_len);
+ if (strl == SSE_NULL) return SSE_NULL;
- strr = xp_awk_valtostr (
- run, right, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &strr_len);
- if (strr == XP_NULL)
+ strr = sse_awk_valtostr (
+ run, right, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &strr_len);
+ if (strr == SSE_NULL)
{
- XP_AWK_FREE (run->awk, strl);
- return XP_NULL;
+ SSE_AWK_FREE (run->awk, strl);
+ return SSE_NULL;
}
- res = xp_awk_makestrval2 (run, strl, strl_len, strr, strr_len);
- if (res == XP_NULL)
+ res = sse_awk_makestrval2 (run, strl, strl_len, strr, strr_len);
+ if (res == SSE_NULL)
{
- XP_AWK_FREE (run->awk, strl);
- XP_AWK_FREE (run->awk, strr);
- PANIC (run, XP_AWK_ENOMEM);
+ SSE_AWK_FREE (run->awk, strl);
+ SSE_AWK_FREE (run->awk, strr);
+ PANIC (run, SSE_AWK_ENOMEM);
}
- XP_AWK_FREE (run->awk, strl);
- XP_AWK_FREE (run->awk, strr);
+ SSE_AWK_FREE (run->awk, strl);
+ SSE_AWK_FREE (run->awk, strr);
return res;
}
-static xp_awk_val_t* __eval_binop_ma (
- xp_awk_run_t* run, xp_awk_nde_t* left, xp_awk_nde_t* right)
+static sse_awk_val_t* __eval_binop_ma (
+ sse_awk_run_t* run, sse_awk_nde_t* left, sse_awk_nde_t* right)
{
- xp_awk_val_t* lv, * rv, * res;
+ sse_awk_val_t* lv, * rv, * res;
- xp_awk_assert (run->awk, left->next == XP_NULL);
- xp_awk_assert (run->awk, right->next == XP_NULL);
+ sse_awk_assert (run->awk, left->next == SSE_NULL);
+ sse_awk_assert (run->awk, right->next == SSE_NULL);
- lv = __eval_expression (run, left);
- if (lv == XP_NULL)
+ lv = __eval_esseression (run, left);
+ if (lv == SSE_NULL)
{
- return XP_NULL;
+ return SSE_NULL;
}
- xp_awk_refupval (lv);
+ sse_awk_refupval (lv);
- rv = __eval_expression0 (run, right);
- if (rv == XP_NULL)
+ rv = __eval_esseression0 (run, right);
+ if (rv == SSE_NULL)
{
- xp_awk_refdownval (run, lv);
- return XP_NULL;
+ sse_awk_refdownval (run, lv);
+ return SSE_NULL;
}
- xp_awk_refupval (rv);
+ sse_awk_refupval (rv);
res = __eval_binop_match0 (run, lv, rv, 1);
- xp_awk_refdownval (run, lv);
- xp_awk_refdownval (run, rv);
+ sse_awk_refdownval (run, lv);
+ sse_awk_refdownval (run, rv);
return res;
}
-static xp_awk_val_t* __eval_binop_nm (
- xp_awk_run_t* run, xp_awk_nde_t* left, xp_awk_nde_t* right)
+static sse_awk_val_t* __eval_binop_nm (
+ sse_awk_run_t* run, sse_awk_nde_t* left, sse_awk_nde_t* right)
{
- xp_awk_val_t* lv, * rv, * res;
+ sse_awk_val_t* lv, * rv, * res;
- xp_awk_assert (run->awk, left->next == XP_NULL);
- xp_awk_assert (run->awk, right->next == XP_NULL);
+ sse_awk_assert (run->awk, left->next == SSE_NULL);
+ sse_awk_assert (run->awk, right->next == SSE_NULL);
- lv = __eval_expression (run, left);
- if (lv == XP_NULL) return XP_NULL;
+ lv = __eval_esseression (run, left);
+ if (lv == SSE_NULL) return SSE_NULL;
- xp_awk_refupval (lv);
+ sse_awk_refupval (lv);
- rv = __eval_expression0 (run, right);
- if (rv == XP_NULL)
+ rv = __eval_esseression0 (run, right);
+ if (rv == SSE_NULL)
{
- xp_awk_refdownval (run, lv);
- return XP_NULL;
+ sse_awk_refdownval (run, lv);
+ return SSE_NULL;
}
- xp_awk_refupval (rv);
+ sse_awk_refupval (rv);
res = __eval_binop_match0 (run, lv, rv, 0);
- xp_awk_refdownval (run, lv);
- xp_awk_refdownval (run, rv);
+ sse_awk_refdownval (run, lv);
+ sse_awk_refdownval (run, rv);
return res;
}
-static xp_awk_val_t* __eval_binop_match0 (
- xp_awk_run_t* run, xp_awk_val_t* left, xp_awk_val_t* right, int ret)
+static sse_awk_val_t* __eval_binop_match0 (
+ sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right, int ret)
{
- xp_awk_val_t* res;
+ sse_awk_val_t* res;
int n, errnum;
- xp_char_t* str;
- xp_size_t len;
+ sse_char_t* str;
+ sse_size_t len;
void* rex_code;
- if (right->type == XP_AWK_VAL_REX)
+ if (right->type == SSE_AWK_VAL_REX)
{
- rex_code = ((xp_awk_val_rex_t*)right)->code;
+ rex_code = ((sse_awk_val_rex_t*)right)->code;
}
- else if (right->type == XP_AWK_VAL_STR)
+ else if (right->type == SSE_AWK_VAL_STR)
{
- rex_code = xp_awk_buildrex (
+ rex_code = sse_awk_buildrex (
run->awk,
- ((xp_awk_val_str_t*)right)->buf,
- ((xp_awk_val_str_t*)right)->len, &errnum);
- if (rex_code == XP_NULL)
+ ((sse_awk_val_str_t*)right)->buf,
+ ((sse_awk_val_str_t*)right)->len, &errnum);
+ if (rex_code == SSE_NULL)
PANIC (run, errnum);
}
else
{
- str = xp_awk_valtostr (
- run, right, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &len);
- if (str == XP_NULL) return XP_NULL;
+ str = sse_awk_valtostr (
+ run, right, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
+ if (str == SSE_NULL) return SSE_NULL;
- rex_code = xp_awk_buildrex (run->awk, str, len, &errnum);
- if (rex_code == XP_NULL)
+ rex_code = sse_awk_buildrex (run->awk, str, len, &errnum);
+ if (rex_code == SSE_NULL)
{
- XP_AWK_FREE (run->awk, str);
+ SSE_AWK_FREE (run->awk, str);
PANIC (run, errnum);
}
- XP_AWK_FREE (run->awk, str);
+ SSE_AWK_FREE (run->awk, str);
}
- if (left->type == XP_AWK_VAL_STR)
+ if (left->type == SSE_AWK_VAL_STR)
{
- n = xp_awk_matchrex (
+ n = sse_awk_matchrex (
run->awk, rex_code,
- ((run->global.ignorecase)? XP_AWK_REX_IGNORECASE: 0),
- ((xp_awk_val_str_t*)left)->buf,
- ((xp_awk_val_str_t*)left)->len,
- XP_NULL, XP_NULL, &errnum);
+ ((run->global.ignorecase)? SSE_AWK_REX_IGNORECASE: 0),
+ ((sse_awk_val_str_t*)left)->buf,
+ ((sse_awk_val_str_t*)left)->len,
+ SSE_NULL, SSE_NULL, &errnum);
if (n == -1)
{
- if (right->type != XP_AWK_VAL_REX)
- XP_AWK_FREE (run->awk, rex_code);
+ if (right->type != SSE_AWK_VAL_REX)
+ SSE_AWK_FREE (run->awk, rex_code);
PANIC (run, errnum);
}
- res = xp_awk_makeintval (run, (n == ret));
- if (res == XP_NULL)
+ res = sse_awk_makeintval (run, (n == ret));
+ if (res == SSE_NULL)
{
- if (right->type != XP_AWK_VAL_REX)
- XP_AWK_FREE (run->awk, rex_code);
- PANIC (run, XP_AWK_ENOMEM);
+ if (right->type != SSE_AWK_VAL_REX)
+ SSE_AWK_FREE (run->awk, rex_code);
+ PANIC (run, SSE_AWK_ENOMEM);
}
}
else
{
- str = xp_awk_valtostr (
- run, left, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &len);
- if (str == XP_NULL)
+ str = sse_awk_valtostr (
+ run, left, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
+ if (str == SSE_NULL)
{
- if (right->type != XP_AWK_VAL_REX)
- XP_AWK_FREE (run->awk, rex_code);
- return XP_NULL;
+ if (right->type != SSE_AWK_VAL_REX)
+ SSE_AWK_FREE (run->awk, rex_code);
+ return SSE_NULL;
}
- n = xp_awk_matchrex (
+ n = sse_awk_matchrex (
run->awk, rex_code,
- ((run->global.ignorecase)? XP_AWK_REX_IGNORECASE: 0),
- str, len, XP_NULL, XP_NULL, &errnum);
+ ((run->global.ignorecase)? SSE_AWK_REX_IGNORECASE: 0),
+ str, len, SSE_NULL, SSE_NULL, &errnum);
if (n == -1)
{
- XP_AWK_FREE (run->awk, str);
- if (right->type != XP_AWK_VAL_REX)
- XP_AWK_FREE (run->awk, rex_code);
+ SSE_AWK_FREE (run->awk, str);
+ if (right->type != SSE_AWK_VAL_REX)
+ SSE_AWK_FREE (run->awk, rex_code);
PANIC (run, errnum);
}
- res = xp_awk_makeintval (run, (n == ret));
- if (res == XP_NULL)
+ res = sse_awk_makeintval (run, (n == ret));
+ if (res == SSE_NULL)
{
- XP_AWK_FREE (run->awk, str);
- if (right->type != XP_AWK_VAL_REX)
- XP_AWK_FREE (run->awk, rex_code);
- PANIC (run, XP_AWK_ENOMEM);
+ SSE_AWK_FREE (run->awk, str);
+ if (right->type != SSE_AWK_VAL_REX)
+ SSE_AWK_FREE (run->awk, rex_code);
+ PANIC (run, SSE_AWK_ENOMEM);
}
- XP_AWK_FREE (run->awk, str);
+ SSE_AWK_FREE (run->awk, str);
}
- if (right->type != XP_AWK_VAL_REX) XP_AWK_FREE (run->awk, rex_code);
+ if (right->type != SSE_AWK_VAL_REX) SSE_AWK_FREE (run->awk, rex_code);
return res;
}
-static xp_awk_val_t* __eval_unary (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_unary (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- xp_awk_val_t* left, * res = XP_NULL;
- xp_awk_nde_exp_t* exp = (xp_awk_nde_exp_t*)nde;
+ sse_awk_val_t* left, * res = SSE_NULL;
+ sse_awk_nde_esse_t* esse = (sse_awk_nde_esse_t*)nde;
- xp_awk_assert (run->awk, exp->type == XP_AWK_NDE_EXP_UNR);
- xp_awk_assert (run->awk, exp->left != XP_NULL && exp->right == XP_NULL);
+ sse_awk_assert (run->awk, esse->type == SSE_AWK_NDE_ESSE_UNR);
+ sse_awk_assert (run->awk, esse->left != SSE_NULL && esse->right == SSE_NULL);
- xp_awk_assert (run->awk, exp->left->next == XP_NULL);
- left = __eval_expression (run, exp->left);
- if (left == XP_NULL) return XP_NULL;
+ sse_awk_assert (run->awk, esse->left->next == SSE_NULL);
+ left = __eval_esseression (run, esse->left);
+ if (left == SSE_NULL) return SSE_NULL;
- xp_awk_refupval (left);
+ sse_awk_refupval (left);
- if (exp->opcode == XP_AWK_UNROP_PLUS)
+ if (esse->opcode == SSE_AWK_UNROP_PLUS)
{
- if (left->type == XP_AWK_VAL_INT)
+ if (left->type == SSE_AWK_VAL_INT)
{
- xp_long_t r = ((xp_awk_val_int_t*)left)->val;
- res = xp_awk_makeintval (run, r);
+ sse_long_t r = ((sse_awk_val_int_t*)left)->val;
+ res = sse_awk_makeintval (run, r);
}
- else if (left->type == XP_AWK_VAL_REAL)
+ else if (left->type == SSE_AWK_VAL_REAL)
{
- xp_real_t r = ((xp_awk_val_real_t*)left)->val;
- res = xp_awk_makerealval (run, r);
+ sse_real_t r = ((sse_awk_val_real_t*)left)->val;
+ res = sse_awk_makerealval (run, r);
}
else
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_EOPERAND);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_EOPERAND);
}
}
- else if (exp->opcode == XP_AWK_UNROP_MINUS)
+ else if (esse->opcode == SSE_AWK_UNROP_MINUS)
{
- if (left->type == XP_AWK_VAL_INT)
+ if (left->type == SSE_AWK_VAL_INT)
{
- xp_long_t r = ((xp_awk_val_int_t*)left)->val;
- res = xp_awk_makeintval (run, -r);
+ sse_long_t r = ((sse_awk_val_int_t*)left)->val;
+ res = sse_awk_makeintval (run, -r);
}
- else if (left->type == XP_AWK_VAL_REAL)
+ else if (left->type == SSE_AWK_VAL_REAL)
{
- xp_real_t r = ((xp_awk_val_real_t*)left)->val;
- res = xp_awk_makerealval (run, -r);
+ sse_real_t r = ((sse_awk_val_real_t*)left)->val;
+ res = sse_awk_makerealval (run, -r);
}
else
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_EOPERAND);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_EOPERAND);
}
}
- else if (exp->opcode == XP_AWK_UNROP_NOT)
+ else if (esse->opcode == SSE_AWK_UNROP_NOT)
{
- if (left->type == XP_AWK_VAL_INT)
+ if (left->type == SSE_AWK_VAL_INT)
{
- xp_long_t r = ((xp_awk_val_int_t*)left)->val;
- res = xp_awk_makeintval (run, !r);
+ sse_long_t r = ((sse_awk_val_int_t*)left)->val;
+ res = sse_awk_makeintval (run, !r);
}
- else if (left->type == XP_AWK_VAL_REAL)
+ else if (left->type == SSE_AWK_VAL_REAL)
{
- xp_real_t r = ((xp_awk_val_real_t*)left)->val;
- res = xp_awk_makerealval (run, !r);
+ sse_real_t r = ((sse_awk_val_real_t*)left)->val;
+ res = sse_awk_makerealval (run, !r);
}
else
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_EOPERAND);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_EOPERAND);
}
}
- else if (exp->opcode == XP_AWK_UNROP_BNOT)
+ else if (esse->opcode == SSE_AWK_UNROP_BNOT)
{
- if (left->type == XP_AWK_VAL_INT)
+ if (left->type == SSE_AWK_VAL_INT)
{
- xp_long_t r = ((xp_awk_val_int_t*)left)->val;
- res = xp_awk_makeintval (run, ~r);
+ sse_long_t r = ((sse_awk_val_int_t*)left)->val;
+ res = sse_awk_makeintval (run, ~r);
}
else
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_EOPERAND);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_EOPERAND);
}
}
- if (res == XP_NULL)
+ if (res == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_ENOMEM);
}
- xp_awk_refdownval (run, left);
+ sse_awk_refdownval (run, left);
return res;
}
-static xp_awk_val_t* __eval_incpre (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_incpre (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- xp_awk_val_t* left, * res;
- xp_awk_nde_exp_t* exp = (xp_awk_nde_exp_t*)nde;
+ sse_awk_val_t* left, * res;
+ sse_awk_nde_esse_t* esse = (sse_awk_nde_esse_t*)nde;
- xp_awk_assert (run->awk, exp->type == XP_AWK_NDE_EXP_INCPRE);
- xp_awk_assert (run->awk, exp->left != XP_NULL && exp->right == XP_NULL);
+ sse_awk_assert (run->awk, esse->type == SSE_AWK_NDE_ESSE_INCPRE);
+ sse_awk_assert (run->awk, esse->left != SSE_NULL && esse->right == SSE_NULL);
/* this way of checking if the l-value is assignable is
* ugly as it is dependent of the values defined in tree.h.
* but let's keep going this way for the time being. */
- if (exp->left->type < XP_AWK_NDE_NAMED ||
- exp->left->type > XP_AWK_NDE_ARGIDX)
+ if (esse->left->type < SSE_AWK_NDE_NAMED ||
+ esse->left->type > SSE_AWK_NDE_ARGIDX)
{
- PANIC (run, XP_AWK_EOPERAND);
+ PANIC (run, SSE_AWK_EOPERAND);
}
- xp_awk_assert (run->awk, exp->left->next == XP_NULL);
- left = __eval_expression (run, exp->left);
- if (left == XP_NULL) return XP_NULL;
+ sse_awk_assert (run->awk, esse->left->next == SSE_NULL);
+ left = __eval_esseression (run, esse->left);
+ if (left == SSE_NULL) return SSE_NULL;
- xp_awk_refupval (left);
+ sse_awk_refupval (left);
- if (exp->opcode == XP_AWK_INCOP_PLUS)
+ if (esse->opcode == SSE_AWK_INCOP_PLUS)
{
- if (left->type == XP_AWK_VAL_INT)
+ if (left->type == SSE_AWK_VAL_INT)
{
- xp_long_t r = ((xp_awk_val_int_t*)left)->val;
- res = xp_awk_makeintval (run, r + 1);
- if (res == XP_NULL)
+ sse_long_t r = ((sse_awk_val_int_t*)left)->val;
+ res = sse_awk_makeintval (run, r + 1);
+ if (res == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_ENOMEM);
}
}
- else if (left->type == XP_AWK_VAL_REAL)
+ else if (left->type == SSE_AWK_VAL_REAL)
{
- xp_real_t r = ((xp_awk_val_real_t*)left)->val;
- res = xp_awk_makerealval (run, r + 1.0);
- if (res == XP_NULL)
+ sse_real_t r = ((sse_awk_val_real_t*)left)->val;
+ res = sse_awk_makerealval (run, r + 1.0);
+ if (res == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_ENOMEM);
}
}
else
{
- xp_long_t v1;
- xp_real_t v2;
+ sse_long_t v1;
+ sse_real_t v2;
int n;
- n = xp_awk_valtonum (run, left, &v1, &v2);
+ n = sse_awk_valtonum (run, left, &v1, &v2);
if (n == -1)
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_EOPERAND);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_EOPERAND);
}
if (n == 0)
{
- res = xp_awk_makeintval (run, v1 + 1);
+ res = sse_awk_makeintval (run, v1 + 1);
}
else /* if (n == 1) */
{
- xp_awk_assert (run->awk, n == 1);
- res = xp_awk_makerealval (run, v2 + 1.0);
+ sse_awk_assert (run->awk, n == 1);
+ res = sse_awk_makerealval (run, v2 + 1.0);
}
- if (res == XP_NULL)
+ if (res == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_ENOMEM);
}
}
}
- else if (exp->opcode == XP_AWK_INCOP_MINUS)
+ else if (esse->opcode == SSE_AWK_INCOP_MINUS)
{
- if (left->type == XP_AWK_VAL_INT)
+ if (left->type == SSE_AWK_VAL_INT)
{
- xp_long_t r = ((xp_awk_val_int_t*)left)->val;
- res = xp_awk_makeintval (run, r - 1);
- if (res == XP_NULL)
+ sse_long_t r = ((sse_awk_val_int_t*)left)->val;
+ res = sse_awk_makeintval (run, r - 1);
+ if (res == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_ENOMEM);
}
}
- else if (left->type == XP_AWK_VAL_REAL)
+ else if (left->type == SSE_AWK_VAL_REAL)
{
- xp_real_t r = ((xp_awk_val_real_t*)left)->val;
- res = xp_awk_makerealval (run, r - 1.0);
- if (res == XP_NULL)
+ sse_real_t r = ((sse_awk_val_real_t*)left)->val;
+ res = sse_awk_makerealval (run, r - 1.0);
+ if (res == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_ENOMEM);
}
}
else
{
- xp_long_t v1;
- xp_real_t v2;
+ sse_long_t v1;
+ sse_real_t v2;
int n;
- n = xp_awk_valtonum (run, left, &v1, &v2);
+ n = sse_awk_valtonum (run, left, &v1, &v2);
if (n == -1)
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_EOPERAND);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_EOPERAND);
}
if (n == 0)
{
- res = xp_awk_makeintval (run, v1 - 1);
+ res = sse_awk_makeintval (run, v1 - 1);
}
else /* if (n == 1) */
{
- xp_awk_assert (run->awk, n == 1);
- res = xp_awk_makerealval (run, v2 - 1.0);
+ sse_awk_assert (run->awk, n == 1);
+ res = sse_awk_makerealval (run, v2 - 1.0);
}
- if (res == XP_NULL)
+ if (res == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_ENOMEM);
}
}
}
else
{
- xp_awk_assert (run->awk, !"should never happen - invalid opcode");
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_EINTERNAL);
+ sse_awk_assert (run->awk, !"should never happen - invalid opcode");
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_EINTERNAL);
}
- if (__do_assignment (run, exp->left, res) == XP_NULL)
+ if (__do_assignment (run, esse->left, res) == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- return XP_NULL;
+ sse_awk_refdownval (run, left);
+ return SSE_NULL;
}
- xp_awk_refdownval (run, left);
+ sse_awk_refdownval (run, left);
return res;
}
-static xp_awk_val_t* __eval_incpst (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_incpst (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- xp_awk_val_t* left, * res, * res2;
- xp_awk_nde_exp_t* exp = (xp_awk_nde_exp_t*)nde;
+ sse_awk_val_t* left, * res, * res2;
+ sse_awk_nde_esse_t* esse = (sse_awk_nde_esse_t*)nde;
- xp_awk_assert (run->awk, exp->type == XP_AWK_NDE_EXP_INCPST);
- xp_awk_assert (run->awk, exp->left != XP_NULL && exp->right == XP_NULL);
+ sse_awk_assert (run->awk, esse->type == SSE_AWK_NDE_ESSE_INCPST);
+ sse_awk_assert (run->awk, esse->left != SSE_NULL && esse->right == SSE_NULL);
/* this way of checking if the l-value is assignable is
* ugly as it is dependent of the values defined in tree.h.
* but let's keep going this way for the time being. */
- if (exp->left->type < XP_AWK_NDE_NAMED ||
- exp->left->type > XP_AWK_NDE_ARGIDX)
+ if (esse->left->type < SSE_AWK_NDE_NAMED ||
+ esse->left->type > SSE_AWK_NDE_ARGIDX)
{
- PANIC (run, XP_AWK_EOPERAND);
+ PANIC (run, SSE_AWK_EOPERAND);
}
- xp_awk_assert (run->awk, exp->left->next == XP_NULL);
- left = __eval_expression (run, exp->left);
- if (left == XP_NULL) return XP_NULL;
+ sse_awk_assert (run->awk, esse->left->next == SSE_NULL);
+ left = __eval_esseression (run, esse->left);
+ if (left == SSE_NULL) return SSE_NULL;
- xp_awk_refupval (left);
+ sse_awk_refupval (left);
- if (exp->opcode == XP_AWK_INCOP_PLUS)
+ if (esse->opcode == SSE_AWK_INCOP_PLUS)
{
- if (left->type == XP_AWK_VAL_INT)
+ if (left->type == SSE_AWK_VAL_INT)
{
- xp_long_t r = ((xp_awk_val_int_t*)left)->val;
- res = xp_awk_makeintval (run, r);
- if (res == XP_NULL)
+ sse_long_t r = ((sse_awk_val_int_t*)left)->val;
+ res = sse_awk_makeintval (run, r);
+ if (res == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_ENOMEM);
}
- res2 = xp_awk_makeintval (run, r + 1);
- if (res2 == XP_NULL)
+ res2 = sse_awk_makeintval (run, r + 1);
+ if (res2 == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- xp_awk_freeval (run, res, xp_true);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ sse_awk_freeval (run, res, sse_true);
+ PANIC (run, SSE_AWK_ENOMEM);
}
}
- else if (left->type == XP_AWK_VAL_REAL)
+ else if (left->type == SSE_AWK_VAL_REAL)
{
- xp_real_t r = ((xp_awk_val_real_t*)left)->val;
- res = xp_awk_makerealval (run, r);
- if (res == XP_NULL)
+ sse_real_t r = ((sse_awk_val_real_t*)left)->val;
+ res = sse_awk_makerealval (run, r);
+ if (res == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_ENOMEM);
}
- res2 = xp_awk_makerealval (run, r + 1.0);
- if (res2 == XP_NULL)
+ res2 = sse_awk_makerealval (run, r + 1.0);
+ if (res2 == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- xp_awk_freeval (run, res, xp_true);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ sse_awk_freeval (run, res, sse_true);
+ PANIC (run, SSE_AWK_ENOMEM);
}
}
else
{
- xp_long_t v1;
- xp_real_t v2;
+ sse_long_t v1;
+ sse_real_t v2;
int n;
- n = xp_awk_valtonum (run, left, &v1, &v2);
+ n = sse_awk_valtonum (run, left, &v1, &v2);
if (n == -1)
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_EOPERAND);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_EOPERAND);
}
if (n == 0)
{
- res = xp_awk_makeintval (run, v1);
- if (res == XP_NULL)
+ res = sse_awk_makeintval (run, v1);
+ if (res == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_ENOMEM);
}
- res2 = xp_awk_makeintval (run, v1 + 1);
- if (res2 == XP_NULL)
+ res2 = sse_awk_makeintval (run, v1 + 1);
+ if (res2 == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- xp_awk_freeval (run, res, xp_true);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ sse_awk_freeval (run, res, sse_true);
+ PANIC (run, SSE_AWK_ENOMEM);
}
}
else /* if (n == 1) */
{
- xp_awk_assert (run->awk, n == 1);
- res = xp_awk_makerealval (run, v2);
- if (res == XP_NULL)
+ sse_awk_assert (run->awk, n == 1);
+ res = sse_awk_makerealval (run, v2);
+ if (res == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_ENOMEM);
}
- res2 = xp_awk_makerealval (run, v2 + 1.0);
- if (res2 == XP_NULL)
+ res2 = sse_awk_makerealval (run, v2 + 1.0);
+ if (res2 == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- xp_awk_freeval (run, res, xp_true);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ sse_awk_freeval (run, res, sse_true);
+ PANIC (run, SSE_AWK_ENOMEM);
}
}
}
}
- else if (exp->opcode == XP_AWK_INCOP_MINUS)
+ else if (esse->opcode == SSE_AWK_INCOP_MINUS)
{
- if (left->type == XP_AWK_VAL_INT)
+ if (left->type == SSE_AWK_VAL_INT)
{
- xp_long_t r = ((xp_awk_val_int_t*)left)->val;
- res = xp_awk_makeintval (run, r);
- if (res == XP_NULL)
+ sse_long_t r = ((sse_awk_val_int_t*)left)->val;
+ res = sse_awk_makeintval (run, r);
+ if (res == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_ENOMEM);
}
- res2 = xp_awk_makeintval (run, r - 1);
- if (res2 == XP_NULL)
+ res2 = sse_awk_makeintval (run, r - 1);
+ if (res2 == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- xp_awk_freeval (run, res, xp_true);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ sse_awk_freeval (run, res, sse_true);
+ PANIC (run, SSE_AWK_ENOMEM);
}
}
- else if (left->type == XP_AWK_VAL_REAL)
+ else if (left->type == SSE_AWK_VAL_REAL)
{
- xp_real_t r = ((xp_awk_val_real_t*)left)->val;
- res = xp_awk_makerealval (run, r);
- if (res == XP_NULL)
+ sse_real_t r = ((sse_awk_val_real_t*)left)->val;
+ res = sse_awk_makerealval (run, r);
+ if (res == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_ENOMEM);
}
- res2 = xp_awk_makerealval (run, r - 1.0);
- if (res2 == XP_NULL)
+ res2 = sse_awk_makerealval (run, r - 1.0);
+ if (res2 == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- xp_awk_freeval (run, res, xp_true);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ sse_awk_freeval (run, res, sse_true);
+ PANIC (run, SSE_AWK_ENOMEM);
}
}
else
{
- xp_long_t v1;
- xp_real_t v2;
+ sse_long_t v1;
+ sse_real_t v2;
int n;
- n = xp_awk_valtonum (run, left, &v1, &v2);
+ n = sse_awk_valtonum (run, left, &v1, &v2);
if (n == -1)
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_EOPERAND);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_EOPERAND);
}
if (n == 0)
{
- res = xp_awk_makeintval (run, v1);
- if (res == XP_NULL)
+ res = sse_awk_makeintval (run, v1);
+ if (res == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_ENOMEM);
}
- res2 = xp_awk_makeintval (run, v1 - 1);
- if (res2 == XP_NULL)
+ res2 = sse_awk_makeintval (run, v1 - 1);
+ if (res2 == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- xp_awk_freeval (run, res, xp_true);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ sse_awk_freeval (run, res, sse_true);
+ PANIC (run, SSE_AWK_ENOMEM);
}
}
else /* if (n == 1) */
{
- xp_awk_assert (run->awk, n == 1);
- res = xp_awk_makerealval (run, v2);
- if (res == XP_NULL)
+ sse_awk_assert (run->awk, n == 1);
+ res = sse_awk_makerealval (run, v2);
+ if (res == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_ENOMEM);
}
- res2 = xp_awk_makerealval (run, v2 - 1.0);
- if (res2 == XP_NULL)
+ res2 = sse_awk_makerealval (run, v2 - 1.0);
+ if (res2 == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- xp_awk_freeval (run, res, xp_true);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, left);
+ sse_awk_freeval (run, res, sse_true);
+ PANIC (run, SSE_AWK_ENOMEM);
}
}
}
}
else
{
- xp_awk_assert (run->awk, !"should never happen - invalid opcode");
- xp_awk_refdownval (run, left);
- PANIC (run, XP_AWK_EINTERNAL);
+ sse_awk_assert (run->awk, !"should never happen - invalid opcode");
+ sse_awk_refdownval (run, left);
+ PANIC (run, SSE_AWK_EINTERNAL);
}
- if (__do_assignment (run, exp->left, res2) == XP_NULL)
+ if (__do_assignment (run, esse->left, res2) == SSE_NULL)
{
- xp_awk_refdownval (run, left);
- return XP_NULL;
+ sse_awk_refdownval (run, left);
+ return SSE_NULL;
}
- xp_awk_refdownval (run, left);
+ sse_awk_refdownval (run, left);
return res;
}
-static xp_awk_val_t* __eval_cnd (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_cnd (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- xp_awk_val_t* tv, * v;
- xp_awk_nde_cnd_t* cnd = (xp_awk_nde_cnd_t*)nde;
+ sse_awk_val_t* tv, * v;
+ sse_awk_nde_cnd_t* cnd = (sse_awk_nde_cnd_t*)nde;
- xp_awk_assert (run->awk, cnd->test->next == XP_NULL);
- tv = __eval_expression (run, cnd->test);
- if (tv == XP_NULL) return XP_NULL;
+ sse_awk_assert (run->awk, cnd->test->next == SSE_NULL);
+ tv = __eval_esseression (run, cnd->test);
+ if (tv == SSE_NULL) return SSE_NULL;
- xp_awk_refupval (tv);
+ sse_awk_refupval (tv);
- xp_awk_assert (run->awk, cnd->left->next == XP_NULL &&
- cnd->right->next == XP_NULL);
- v = (xp_awk_valtobool (run, tv))?
- __eval_expression (run, cnd->left):
- __eval_expression (run, cnd->right);
+ sse_awk_assert (run->awk, cnd->left->next == SSE_NULL &&
+ cnd->right->next == SSE_NULL);
+ v = (sse_awk_valtobool (run, tv))?
+ __eval_esseression (run, cnd->left):
+ __eval_esseression (run, cnd->right);
- xp_awk_refdownval (run, tv);
+ sse_awk_refdownval (run, tv);
return v;
}
-static xp_awk_val_t* __eval_bfn (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_bfn (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- xp_awk_nde_call_t* call = (xp_awk_nde_call_t*)nde;
+ sse_awk_nde_call_t* call = (sse_awk_nde_call_t*)nde;
/* built-in function */
if (call->nargs < call->what.bfn.min_args)
{
- PANIC (run, XP_AWK_ETOOFEWARGS);
+ PANIC (run, SSE_AWK_ETOOFEWARGS);
}
if (call->nargs > call->what.bfn.max_args)
{
- PANIC (run, XP_AWK_ETOOMANYARGS);
+ PANIC (run, SSE_AWK_ETOOMANYARGS);
}
- return __eval_call (run, nde, call->what.bfn.arg_spec, XP_NULL);
+ return __eval_call (run, nde, call->what.bfn.arg_spec, SSE_NULL);
}
-static xp_awk_val_t* __eval_afn (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_afn (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- xp_awk_nde_call_t* call = (xp_awk_nde_call_t*)nde;
- xp_awk_afn_t* afn;
- xp_awk_pair_t* pair;
+ sse_awk_nde_call_t* call = (sse_awk_nde_call_t*)nde;
+ sse_awk_afn_t* afn;
+ sse_awk_pair_t* pair;
- pair = xp_awk_map_get (&run->awk->tree.afns,
+ pair = sse_awk_map_get (&run->awk->tree.afns,
call->what.afn.name, call->what.afn.name_len);
- if (pair == XP_NULL) PANIC (run, XP_AWK_ENOSUCHFUNC);
+ if (pair == SSE_NULL) PANIC (run, SSE_AWK_ENOSUCHFUNC);
- afn = (xp_awk_afn_t*)pair->val;
- xp_awk_assert (run->awk, afn != XP_NULL);
+ afn = (sse_awk_afn_t*)pair->val;
+ sse_awk_assert (run->awk, afn != SSE_NULL);
if (call->nargs > afn->nargs)
{
/* TODO: is this correct? what if i want to allow arbitarary numbers of arguments? */
- PANIC (run, XP_AWK_ETOOMANYARGS);
+ PANIC (run, SSE_AWK_ETOOMANYARGS);
}
- return __eval_call (run, nde, XP_NULL, afn);
+ return __eval_call (run, nde, SSE_NULL, afn);
}
/* run->stack_base has not been set for this
* stack frame. so STACK_ARG cannot be used */
-/*xp_awk_refdownval (run, STACK_ARG(run,nargs));*/
+/*sse_awk_refdownval (run, STACK_ARG(run,nargs));*/
#define UNWIND_RUN_STACK(run,nargs) \
do { \
while ((nargs) > 0) \
{ \
--(nargs); \
- xp_awk_refdownval ((run), \
+ sse_awk_refdownval ((run), \
(run)->stack[(run)->stack_top-1]); \
__raw_pop (run); \
} \
@@ -4271,15 +4271,15 @@ static xp_awk_val_t* __eval_afn (xp_awk_run_t* run, xp_awk_nde_t* nde)
__raw_pop (run); \
} while (0)
-static xp_awk_val_t* __eval_call (
- xp_awk_run_t* run, xp_awk_nde_t* nde,
- const xp_char_t* bfn_arg_spec, xp_awk_afn_t* afn)
+static sse_awk_val_t* __eval_call (
+ sse_awk_run_t* run, sse_awk_nde_t* nde,
+ const sse_char_t* bfn_arg_spec, sse_awk_afn_t* afn)
{
- xp_awk_nde_call_t* call = (xp_awk_nde_call_t*)nde;
- xp_size_t saved_stack_top;
- xp_size_t nargs, i;
- xp_awk_nde_t* p;
- xp_awk_val_t* v;
+ sse_awk_nde_call_t* call = (sse_awk_nde_call_t*)nde;
+ sse_size_t saved_stack_top;
+ sse_size_t nargs, i;
+ sse_awk_nde_t* p;
+ sse_awk_val_t* v;
int n;
/*
@@ -4322,113 +4322,113 @@ static xp_awk_val_t* __eval_call (
* ---------------------
*/
- xp_awk_assert (run->awk, xp_sizeof(void*) >= xp_sizeof(run->stack_top));
- xp_awk_assert (run->awk, xp_sizeof(void*) >= xp_sizeof(run->stack_base));
+ sse_awk_assert (run->awk, sse_sizeof(void*) >= sse_sizeof(run->stack_top));
+ sse_awk_assert (run->awk, sse_sizeof(void*) >= sse_sizeof(run->stack_base));
saved_stack_top = run->stack_top;
-/*xp_printf (XP_T("setting up function stack frame stack_top = %ld stack_base = %ld\n"), run->stack_top, run->stack_base); */
+/*sse_printf (SSE_T("setting up function stack frame stack_top = %ld stack_base = %ld\n"), run->stack_top, run->stack_base); */
if (__raw_push(run,(void*)run->stack_base) == -1)
{
- PANIC (run, XP_AWK_ENOMEM);
+ PANIC (run, SSE_AWK_ENOMEM);
}
if (__raw_push(run,(void*)saved_stack_top) == -1)
{
__raw_pop (run);
- PANIC (run, XP_AWK_ENOMEM);
+ PANIC (run, SSE_AWK_ENOMEM);
}
/* secure space for a return value. */
- if (__raw_push(run,xp_awk_val_nil) == -1)
+ if (__raw_push(run,sse_awk_val_nil) == -1)
{
__raw_pop (run);
__raw_pop (run);
- PANIC (run, XP_AWK_ENOMEM);
+ PANIC (run, SSE_AWK_ENOMEM);
}
/* secure space for nargs */
- if (__raw_push(run,xp_awk_val_nil) == -1)
+ if (__raw_push(run,sse_awk_val_nil) == -1)
{
__raw_pop (run);
__raw_pop (run);
__raw_pop (run);
- PANIC (run, XP_AWK_ENOMEM);
+ PANIC (run, SSE_AWK_ENOMEM);
}
nargs = 0;
p = call->args;
- while (p != XP_NULL)
+ while (p != SSE_NULL)
{
- xp_awk_assert (run->awk, bfn_arg_spec == XP_NULL ||
- (bfn_arg_spec != XP_NULL &&
- xp_awk_strlen(bfn_arg_spec) > nargs));
+ sse_awk_assert (run->awk, bfn_arg_spec == SSE_NULL ||
+ (bfn_arg_spec != SSE_NULL &&
+ sse_awk_strlen(bfn_arg_spec) > nargs));
- if (bfn_arg_spec != XP_NULL &&
- bfn_arg_spec[nargs] == XP_T('r'))
+ if (bfn_arg_spec != SSE_NULL &&
+ bfn_arg_spec[nargs] == SSE_T('r'))
{
- xp_awk_val_t** ref;
+ sse_awk_val_t** ref;
if (__get_reference (run, p, &ref) == -1)
{
UNWIND_RUN_STACK (run, nargs);
- return XP_NULL;
+ return SSE_NULL;
}
- /* p->type-XP_AWK_NDE_NAMED assumes that the
- * derived value matches XP_AWK_VAL_REF_XXX */
- v = xp_awk_makerefval (
- run, p->type-XP_AWK_NDE_NAMED, ref);
+ /* p->type-SSE_AWK_NDE_NAMED assumes that the
+ * derived value matches SSE_AWK_VAL_REF_XXX */
+ v = sse_awk_makerefval (
+ run, p->type-SSE_AWK_NDE_NAMED, ref);
}
- else if (bfn_arg_spec != XP_NULL &&
- bfn_arg_spec[nargs] == XP_T('x'))
+ else if (bfn_arg_spec != SSE_NULL &&
+ bfn_arg_spec[nargs] == SSE_T('x'))
{
- /* a regular expression is passed to
+ /* a regular esseression is passed to
* the function as it is */
- v = __eval_expression0 (run, p);
+ v = __eval_esseression0 (run, p);
}
else
{
- v = __eval_expression (run, p);
+ v = __eval_esseression (run, p);
}
- if (v == XP_NULL)
+ if (v == SSE_NULL)
{
UNWIND_RUN_STACK (run, nargs);
- return XP_NULL;
+ return SSE_NULL;
}
#if 0
- if (bfn_arg_spec != XP_NULL &&
- bfn_arg_spec[nargs] == XP_T('r'))
+ if (bfn_arg_spec != SSE_NULL &&
+ bfn_arg_spec[nargs] == SSE_T('r'))
{
- xp_awk_val_t** ref;
- xp_awk_val_t* tmp;
+ sse_awk_val_t** ref;
+ sse_awk_val_t* tmp;
ref = __get_reference (run, p);
- if (ref == XP_NULL)
+ if (ref == SSE_NULL)
{
- xp_awk_refupval (v);
- xp_awk_refdownval (run, v);
+ sse_awk_refupval (v);
+ sse_awk_refdownval (run, v);
UNWIND_RUN_STACK (run, nargs);
- return XP_NULL;
+ return SSE_NULL;
}
- /* p->type-XP_AWK_NDE_NAMED assumes that the
- * derived value matches XP_AWK_VAL_REF_XXX */
- tmp = xp_awk_makerefval (
- run, p->type-XP_AWK_NDE_NAMED, ref);
- if (tmp == XP_NULL)
+ /* p->type-SSE_AWK_NDE_NAMED assumes that the
+ * derived value matches SSE_AWK_VAL_REF_XXX */
+ tmp = sse_awk_makerefval (
+ run, p->type-SSE_AWK_NDE_NAMED, ref);
+ if (tmp == SSE_NULL)
{
- xp_awk_refupval (v);
- xp_awk_refdownval (run, v);
+ sse_awk_refupval (v);
+ sse_awk_refdownval (run, v);
UNWIND_RUN_STACK (run, nargs);
- PANIC (run, XP_AWK_ENOMEM);
+ PANIC (run, SSE_AWK_ENOMEM);
}
- xp_awk_refupval (v);
- xp_awk_refdownval (run, v);
+ sse_awk_refupval (v);
+ sse_awk_refdownval (run, v);
v = tmp;
}
@@ -4441,31 +4441,31 @@ static xp_awk_val_t* __eval_call (
* updated yet as it is carried out after the
* successful stack push. so it adds up a reference
* and dereferences it */
- xp_awk_refupval (v);
- xp_awk_refdownval (run, v);
+ sse_awk_refupval (v);
+ sse_awk_refdownval (run, v);
UNWIND_RUN_STACK (run, nargs);
- PANIC (run, XP_AWK_ENOMEM);
+ PANIC (run, SSE_AWK_ENOMEM);
}
- xp_awk_refupval (v);
+ sse_awk_refupval (v);
nargs++;
p = p->next;
}
- xp_awk_assert (run->awk, nargs == call->nargs);
+ sse_awk_assert (run->awk, nargs == call->nargs);
- if (afn != XP_NULL)
+ if (afn != SSE_NULL)
{
/* extra step for normal awk functions */
while (nargs < afn->nargs)
{
/* push as many nils as the number of missing actual arguments */
- if (__raw_push(run,xp_awk_val_nil) == -1)
+ if (__raw_push(run,sse_awk_val_nil) == -1)
{
UNWIND_RUN_STACK (run, nargs);
- PANIC (run, XP_AWK_ENOMEM);
+ PANIC (run, SSE_AWK_ENOMEM);
}
nargs++;
@@ -4475,36 +4475,36 @@ static xp_awk_val_t* __eval_call (
run->stack_base = saved_stack_top;
STACK_NARGS(run) = (void*)nargs;
-/*xp_printf (XP_T("running function body\n")); */
+/*sse_printf (SSE_T("running function body\n")); */
- if (afn != XP_NULL)
+ if (afn != SSE_NULL)
{
/* normal awk function */
- xp_awk_assert (run->awk, afn->body->type == XP_AWK_NDE_BLK);
- n = __run_block(run,(xp_awk_nde_blk_t*)afn->body);
+ sse_awk_assert (run->awk, afn->body->type == SSE_AWK_NDE_BLK);
+ n = __run_block(run,(sse_awk_nde_blk_t*)afn->body);
}
else
{
n = 0;
/* built-in function */
- xp_awk_assert (run->awk, call->nargs >= call->what.bfn.min_args &&
+ sse_awk_assert (run->awk, call->nargs >= call->what.bfn.min_args &&
call->nargs <= call->what.bfn.max_args);
- if (call->what.bfn.handler != XP_NULL)
+ if (call->what.bfn.handler != SSE_NULL)
n = call->what.bfn.handler (run);
}
-/*xp_printf (XP_T("block run complete\n")); */
+/*sse_printf (SSE_T("block run complete\n")); */
/* refdown args in the run.stack */
- nargs = (xp_size_t)STACK_NARGS(run);
-/*xp_printf (XP_T("block run complete nargs = %d\n"), (int)nargs); */
+ nargs = (sse_size_t)STACK_NARGS(run);
+/*sse_printf (SSE_T("block run complete nargs = %d\n"), (int)nargs); */
for (i = 0; i < nargs; i++)
{
- xp_awk_refdownval (run, STACK_ARG(run,i));
+ sse_awk_refdownval (run, STACK_ARG(run,i));
}
-/*xp_printf (XP_T("got return value\n")); */
+/*sse_printf (SSE_T("got return value\n")); */
/* this trick has been mentioned in __run_return.
* adjust the reference count of the return value.
@@ -4512,512 +4512,512 @@ static xp_awk_val_t* __eval_call (
* is decremented to zero because its reference has been incremented
* in __run_return regardless of its reference count. */
v = STACK_RETVAL(run);
- xp_awk_refdownval_nofree (run, v);
+ sse_awk_refdownval_nofree (run, v);
- run->stack_top = (xp_size_t)run->stack[run->stack_base+1];
- run->stack_base = (xp_size_t)run->stack[run->stack_base+0];
+ run->stack_top = (sse_size_t)run->stack[run->stack_base+1];
+ run->stack_base = (sse_size_t)run->stack[run->stack_base+0];
if (run->exit_level == EXIT_FUNCTION) run->exit_level = EXIT_NONE;
-/*xp_printf (XP_T("returning from function stack_top=%ld, stack_base=%ld\n"), run->stack_top, run->stack_base); */
- return (n == -1)? XP_NULL: v;
+/*sse_printf (SSE_T("returning from function stack_top=%ld, stack_base=%ld\n"), run->stack_top, run->stack_base); */
+ return (n == -1)? SSE_NULL: v;
}
static int __get_reference (
- xp_awk_run_t* run, xp_awk_nde_t* nde, xp_awk_val_t*** ref)
+ sse_awk_run_t* run, sse_awk_nde_t* nde, sse_awk_val_t*** ref)
{
- xp_awk_nde_var_t* tgt = (xp_awk_nde_var_t*)nde;
- xp_awk_val_t** tmp;
+ sse_awk_nde_var_t* tgt = (sse_awk_nde_var_t*)nde;
+ sse_awk_val_t** tmp;
/* refer to __eval_indexed for application of a similar concept */
- if (nde->type == XP_AWK_NDE_NAMED)
+ if (nde->type == SSE_AWK_NDE_NAMED)
{
- xp_awk_pair_t* pair;
+ sse_awk_pair_t* pair;
- pair = xp_awk_map_get (
+ pair = sse_awk_map_get (
&run->named, tgt->id.name, tgt->id.name_len);
- if (pair == XP_NULL)
+ if (pair == SSE_NULL)
{
/* it is bad that the named variable has to be
* created in the function named "__get_refernce".
* would there be any better ways to avoid this? */
- pair = xp_awk_map_put (
+ pair = sse_awk_map_put (
&run->named, tgt->id.name,
- tgt->id.name_len, xp_awk_val_nil);
- if (pair == XP_NULL) PANIC_I (run, XP_AWK_ENOMEM);
+ tgt->id.name_len, sse_awk_val_nil);
+ if (pair == SSE_NULL) PANIC_I (run, SSE_AWK_ENOMEM);
}
- *ref = (xp_awk_val_t**)&pair->val;
+ *ref = (sse_awk_val_t**)&pair->val;
return 0;
}
- if (nde->type == XP_AWK_NDE_GLOBAL)
+ if (nde->type == SSE_AWK_NDE_GLOBAL)
{
- *ref = (xp_awk_val_t**)&STACK_GLOBAL(run,tgt->id.idxa);
+ *ref = (sse_awk_val_t**)&STACK_GLOBAL(run,tgt->id.idxa);
return 0;
}
- if (nde->type == XP_AWK_NDE_LOCAL)
+ if (nde->type == SSE_AWK_NDE_LOCAL)
{
- *ref = (xp_awk_val_t**)&STACK_LOCAL(run,tgt->id.idxa);
+ *ref = (sse_awk_val_t**)&STACK_LOCAL(run,tgt->id.idxa);
return 0;
}
- if (nde->type == XP_AWK_NDE_ARG)
+ if (nde->type == SSE_AWK_NDE_ARG)
{
- *ref = (xp_awk_val_t**)&STACK_ARG(run,tgt->id.idxa);
+ *ref = (sse_awk_val_t**)&STACK_ARG(run,tgt->id.idxa);
return 0;
}
- if (nde->type == XP_AWK_NDE_NAMEDIDX)
+ if (nde->type == SSE_AWK_NDE_NAMEDIDX)
{
- xp_awk_pair_t* pair;
+ sse_awk_pair_t* pair;
- pair = xp_awk_map_get (
+ pair = sse_awk_map_get (
&run->named, tgt->id.name, tgt->id.name_len);
- if (pair == XP_NULL)
+ if (pair == SSE_NULL)
{
- pair = xp_awk_map_put (
+ pair = sse_awk_map_put (
&run->named, tgt->id.name,
- tgt->id.name_len, xp_awk_val_nil);
- if (pair == XP_NULL) PANIC_I (run, XP_AWK_ENOMEM);
+ tgt->id.name_len, sse_awk_val_nil);
+ if (pair == SSE_NULL) PANIC_I (run, SSE_AWK_ENOMEM);
}
tmp = __get_reference_indexed (
- run, tgt, (xp_awk_val_t**)&pair->val);
- if (tmp == XP_NULL) return -1;
+ run, tgt, (sse_awk_val_t**)&pair->val);
+ if (tmp == SSE_NULL) return -1;
*ref = tmp;
}
- if (nde->type == XP_AWK_NDE_GLOBALIDX)
+ if (nde->type == SSE_AWK_NDE_GLOBALIDX)
{
tmp = __get_reference_indexed (run, tgt,
- (xp_awk_val_t**)&STACK_GLOBAL(run,tgt->id.idxa));
- if (tmp == XP_NULL) return -1;
+ (sse_awk_val_t**)&STACK_GLOBAL(run,tgt->id.idxa));
+ if (tmp == SSE_NULL) return -1;
*ref = tmp;
}
- if (nde->type == XP_AWK_NDE_LOCALIDX)
+ if (nde->type == SSE_AWK_NDE_LOCALIDX)
{
tmp = __get_reference_indexed (run, tgt,
- (xp_awk_val_t**)&STACK_LOCAL(run,tgt->id.idxa));
- if (tmp == XP_NULL) return -1;
+ (sse_awk_val_t**)&STACK_LOCAL(run,tgt->id.idxa));
+ if (tmp == SSE_NULL) return -1;
*ref = tmp;
}
- if (nde->type == XP_AWK_NDE_ARGIDX)
+ if (nde->type == SSE_AWK_NDE_ARGIDX)
{
tmp = __get_reference_indexed (run, tgt,
- (xp_awk_val_t**)&STACK_ARG(run,tgt->id.idxa));
- if (tmp == XP_NULL) return -1;
+ (sse_awk_val_t**)&STACK_ARG(run,tgt->id.idxa));
+ if (tmp == SSE_NULL) return -1;
*ref = tmp;
}
- if (nde->type == XP_AWK_NDE_POS)
+ if (nde->type == SSE_AWK_NDE_POS)
{
int n;
- xp_long_t lv;
- xp_real_t rv;
- xp_awk_val_t* v;
+ sse_long_t lv;
+ sse_real_t rv;
+ sse_awk_val_t* v;
/* the position number is returned for the positional
* variable unlike other reference types. */
- v = __eval_expression (run, ((xp_awk_nde_pos_t*)nde)->val);
- if (v == XP_NULL) return -1;
+ v = __eval_esseression (run, ((sse_awk_nde_pos_t*)nde)->val);
+ if (v == SSE_NULL) return -1;
- xp_awk_refupval (v);
- n = xp_awk_valtonum (run, v, &lv, &rv);
- xp_awk_refdownval (run, v);
+ sse_awk_refupval (v);
+ n = sse_awk_valtonum (run, v, &lv, &rv);
+ sse_awk_refdownval (run, v);
- if (n == -1) PANIC_I (run, XP_AWK_EPOSIDX);
- if (n == 1) lv = (xp_long_t)rv;
- if (!IS_VALID_POSIDX(lv)) PANIC_I (run, XP_AWK_EPOSIDX);
+ if (n == -1) PANIC_I (run, SSE_AWK_EPOSIDX);
+ if (n == 1) lv = (sse_long_t)rv;
+ if (!IS_VALID_POSIDX(lv)) PANIC_I (run, SSE_AWK_EPOSIDX);
- *ref = (xp_awk_val_t**)((xp_size_t)lv);
+ *ref = (sse_awk_val_t**)((sse_size_t)lv);
return 0;
}
- PANIC_I (run, XP_AWK_ENOTREFERENCEABLE);
+ PANIC_I (run, SSE_AWK_ENOTREFERENCEABLE);
}
-static xp_awk_val_t** __get_reference_indexed (
- xp_awk_run_t* run, xp_awk_nde_var_t* nde, xp_awk_val_t** val)
+static sse_awk_val_t** __get_reference_indexed (
+ sse_awk_run_t* run, sse_awk_nde_var_t* nde, sse_awk_val_t** val)
{
- xp_awk_pair_t* pair;
- xp_char_t* str;
- xp_size_t len;
+ sse_awk_pair_t* pair;
+ sse_char_t* str;
+ sse_size_t len;
- xp_awk_assert (run->awk, val != XP_NULL);
+ sse_awk_assert (run->awk, val != SSE_NULL);
- if ((*val)->type == XP_AWK_VAL_NIL)
+ if ((*val)->type == SSE_AWK_VAL_NIL)
{
- xp_awk_val_t* tmp;
+ sse_awk_val_t* tmp;
- tmp = xp_awk_makemapval (run);
- if (tmp == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ tmp = sse_awk_makemapval (run);
+ if (tmp == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
- xp_awk_refdownval (run, *val);
+ sse_awk_refdownval (run, *val);
*val = tmp;
- xp_awk_refupval ((xp_awk_val_t*)*val);
+ sse_awk_refupval ((sse_awk_val_t*)*val);
}
- else if ((*val)->type != XP_AWK_VAL_MAP)
+ else if ((*val)->type != SSE_AWK_VAL_MAP)
{
- PANIC (run, XP_AWK_ENOTINDEXABLE);
+ PANIC (run, SSE_AWK_ENOTINDEXABLE);
}
- xp_awk_assert (run->awk, nde->idx != XP_NULL);
+ sse_awk_assert (run->awk, nde->idx != SSE_NULL);
str = __idxnde_to_str (run, nde->idx, &len);
- if (str == XP_NULL) return XP_NULL;
+ if (str == SSE_NULL) return SSE_NULL;
- pair = xp_awk_map_get ((*(xp_awk_val_map_t**)val)->map, str, len);
- if (pair == XP_NULL)
+ pair = sse_awk_map_get ((*(sse_awk_val_map_t**)val)->map, str, len);
+ if (pair == SSE_NULL)
{
- pair = xp_awk_map_put (
- (*(xp_awk_val_map_t**)val)->map,
- str, len, xp_awk_val_nil);
- if (pair == XP_NULL)
+ pair = sse_awk_map_put (
+ (*(sse_awk_val_map_t**)val)->map,
+ str, len, sse_awk_val_nil);
+ if (pair == SSE_NULL)
{
- XP_AWK_FREE (run->awk, str);
- PANIC (run, XP_AWK_ENOMEM);
+ SSE_AWK_FREE (run->awk, str);
+ PANIC (run, SSE_AWK_ENOMEM);
}
- xp_awk_refupval (pair->val);
+ sse_awk_refupval (pair->val);
}
- XP_AWK_FREE (run->awk, str);
- return (xp_awk_val_t**)&pair->val;
+ SSE_AWK_FREE (run->awk, str);
+ return (sse_awk_val_t**)&pair->val;
}
-static xp_awk_val_t* __eval_int (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_int (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- xp_awk_val_t* val;
+ sse_awk_val_t* val;
- val = xp_awk_makeintval (run, ((xp_awk_nde_int_t*)nde)->val);
- if (val == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
- ((xp_awk_val_int_t*)val)->nde = (xp_awk_nde_int_t*)nde;
+ val = sse_awk_makeintval (run, ((sse_awk_nde_int_t*)nde)->val);
+ if (val == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
+ ((sse_awk_val_int_t*)val)->nde = (sse_awk_nde_int_t*)nde;
return val;
}
-static xp_awk_val_t* __eval_real (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_real (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- xp_awk_val_t* val;
+ sse_awk_val_t* val;
- val = xp_awk_makerealval (run, ((xp_awk_nde_real_t*)nde)->val);
- if (val == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
- ((xp_awk_val_real_t*)val)->nde = (xp_awk_nde_real_t*)nde;
+ val = sse_awk_makerealval (run, ((sse_awk_nde_real_t*)nde)->val);
+ if (val == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
+ ((sse_awk_val_real_t*)val)->nde = (sse_awk_nde_real_t*)nde;
return val;
}
-static xp_awk_val_t* __eval_str (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_str (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- xp_awk_val_t* val;
+ sse_awk_val_t* val;
- val = xp_awk_makestrval (run,
- ((xp_awk_nde_str_t*)nde)->buf,
- ((xp_awk_nde_str_t*)nde)->len);
- if (val == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ val = sse_awk_makestrval (run,
+ ((sse_awk_nde_str_t*)nde)->buf,
+ ((sse_awk_nde_str_t*)nde)->len);
+ if (val == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
return val;
}
-static xp_awk_val_t* __eval_rex (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_rex (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- xp_awk_val_t* val;
+ sse_awk_val_t* val;
- val = xp_awk_makerexval (run,
- ((xp_awk_nde_rex_t*)nde)->buf,
- ((xp_awk_nde_rex_t*)nde)->len,
- ((xp_awk_nde_rex_t*)nde)->code);
- if (val == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ val = sse_awk_makerexval (run,
+ ((sse_awk_nde_rex_t*)nde)->buf,
+ ((sse_awk_nde_rex_t*)nde)->len,
+ ((sse_awk_nde_rex_t*)nde)->code);
+ if (val == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
return val;
}
-static xp_awk_val_t* __eval_named (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_named (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- xp_awk_pair_t* pair;
+ sse_awk_pair_t* pair;
- pair = xp_awk_map_get (&run->named,
- ((xp_awk_nde_var_t*)nde)->id.name,
- ((xp_awk_nde_var_t*)nde)->id.name_len);
+ pair = sse_awk_map_get (&run->named,
+ ((sse_awk_nde_var_t*)nde)->id.name,
+ ((sse_awk_nde_var_t*)nde)->id.name_len);
- return (pair == XP_NULL)? xp_awk_val_nil: pair->val;
+ return (pair == SSE_NULL)? sse_awk_val_nil: pair->val;
}
-static xp_awk_val_t* __eval_global (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_global (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- return STACK_GLOBAL(run,((xp_awk_nde_var_t*)nde)->id.idxa);
+ return STACK_GLOBAL(run,((sse_awk_nde_var_t*)nde)->id.idxa);
}
-static xp_awk_val_t* __eval_local (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_local (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- return STACK_LOCAL(run,((xp_awk_nde_var_t*)nde)->id.idxa);
+ return STACK_LOCAL(run,((sse_awk_nde_var_t*)nde)->id.idxa);
}
-static xp_awk_val_t* __eval_arg (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_arg (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- return STACK_ARG(run,((xp_awk_nde_var_t*)nde)->id.idxa);
+ return STACK_ARG(run,((sse_awk_nde_var_t*)nde)->id.idxa);
}
-static xp_awk_val_t* __eval_indexed (
- xp_awk_run_t* run, xp_awk_nde_var_t* nde, xp_awk_val_t** val)
+static sse_awk_val_t* __eval_indexed (
+ sse_awk_run_t* run, sse_awk_nde_var_t* nde, sse_awk_val_t** val)
{
- xp_awk_pair_t* pair;
- xp_char_t* str;
- xp_size_t len;
+ sse_awk_pair_t* pair;
+ sse_char_t* str;
+ sse_size_t len;
- xp_awk_assert (run->awk, val != XP_NULL);
+ sse_awk_assert (run->awk, val != SSE_NULL);
- if ((*val)->type == XP_AWK_VAL_NIL)
+ if ((*val)->type == SSE_AWK_VAL_NIL)
{
- xp_awk_val_t* tmp;
+ sse_awk_val_t* tmp;
- tmp = xp_awk_makemapval (run);
- if (tmp == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ tmp = sse_awk_makemapval (run);
+ if (tmp == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
- xp_awk_refdownval (run, *val);
+ sse_awk_refdownval (run, *val);
*val = tmp;
- xp_awk_refupval ((xp_awk_val_t*)*val);
+ sse_awk_refupval ((sse_awk_val_t*)*val);
}
- else if ((*val)->type != XP_AWK_VAL_MAP)
+ else if ((*val)->type != SSE_AWK_VAL_MAP)
{
- PANIC (run, XP_AWK_ENOTINDEXABLE);
+ PANIC (run, SSE_AWK_ENOTINDEXABLE);
}
- xp_awk_assert (run->awk, nde->idx != XP_NULL);
+ sse_awk_assert (run->awk, nde->idx != SSE_NULL);
str = __idxnde_to_str (run, nde->idx, &len);
- if (str == XP_NULL) return XP_NULL;
+ if (str == SSE_NULL) return SSE_NULL;
- pair = xp_awk_map_get ((*(xp_awk_val_map_t**)val)->map, str, len);
- XP_AWK_FREE (run->awk, str);
+ pair = sse_awk_map_get ((*(sse_awk_val_map_t**)val)->map, str, len);
+ SSE_AWK_FREE (run->awk, str);
- return (pair == XP_NULL)? xp_awk_val_nil: (xp_awk_val_t*)pair->val;
+ return (pair == SSE_NULL)? sse_awk_val_nil: (sse_awk_val_t*)pair->val;
}
-static xp_awk_val_t* __eval_namedidx (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_namedidx (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- xp_awk_nde_var_t* tgt = (xp_awk_nde_var_t*)nde;
- xp_awk_pair_t* pair;
+ sse_awk_nde_var_t* tgt = (sse_awk_nde_var_t*)nde;
+ sse_awk_pair_t* pair;
- pair = xp_awk_map_get (&run->named, tgt->id.name, tgt->id.name_len);
- if (pair == XP_NULL)
+ pair = sse_awk_map_get (&run->named, tgt->id.name, tgt->id.name_len);
+ if (pair == SSE_NULL)
{
- pair = xp_awk_map_put (&run->named,
- tgt->id.name, tgt->id.name_len, xp_awk_val_nil);
- if (pair == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ pair = sse_awk_map_put (&run->named,
+ tgt->id.name, tgt->id.name_len, sse_awk_val_nil);
+ if (pair == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
- xp_awk_refupval (pair->val);
+ sse_awk_refupval (pair->val);
}
- return __eval_indexed (run, tgt, (xp_awk_val_t**)&pair->val);
+ return __eval_indexed (run, tgt, (sse_awk_val_t**)&pair->val);
}
-static xp_awk_val_t* __eval_globalidx (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_globalidx (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- return __eval_indexed (run, (xp_awk_nde_var_t*)nde,
- (xp_awk_val_t**)&STACK_GLOBAL(run,((xp_awk_nde_var_t*)nde)->id.idxa));
+ return __eval_indexed (run, (sse_awk_nde_var_t*)nde,
+ (sse_awk_val_t**)&STACK_GLOBAL(run,((sse_awk_nde_var_t*)nde)->id.idxa));
}
-static xp_awk_val_t* __eval_localidx (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_localidx (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- return __eval_indexed (run, (xp_awk_nde_var_t*)nde,
- (xp_awk_val_t**)&STACK_LOCAL(run,((xp_awk_nde_var_t*)nde)->id.idxa));
+ return __eval_indexed (run, (sse_awk_nde_var_t*)nde,
+ (sse_awk_val_t**)&STACK_LOCAL(run,((sse_awk_nde_var_t*)nde)->id.idxa));
}
-static xp_awk_val_t* __eval_argidx (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_argidx (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- return __eval_indexed (run, (xp_awk_nde_var_t*)nde,
- (xp_awk_val_t**)&STACK_ARG(run,((xp_awk_nde_var_t*)nde)->id.idxa));
+ return __eval_indexed (run, (sse_awk_nde_var_t*)nde,
+ (sse_awk_val_t**)&STACK_ARG(run,((sse_awk_nde_var_t*)nde)->id.idxa));
}
-static xp_awk_val_t* __eval_pos (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_pos (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- xp_awk_nde_pos_t* pos = (xp_awk_nde_pos_t*)nde;
- xp_awk_val_t* v;
- xp_long_t lv;
- xp_real_t rv;
+ sse_awk_nde_pos_t* pos = (sse_awk_nde_pos_t*)nde;
+ sse_awk_val_t* v;
+ sse_long_t lv;
+ sse_real_t rv;
int n;
- v = __eval_expression (run, pos->val);
- if (v == XP_NULL) return XP_NULL;
+ v = __eval_esseression (run, pos->val);
+ if (v == SSE_NULL) return SSE_NULL;
- xp_awk_refupval (v);
- n = xp_awk_valtonum (run, v, &lv, &rv);
- xp_awk_refdownval (run, v);
+ sse_awk_refupval (v);
+ n = sse_awk_valtonum (run, v, &lv, &rv);
+ sse_awk_refdownval (run, v);
- if (n == -1) PANIC (run, XP_AWK_EPOSIDX);
- if (n == 1) lv = (xp_long_t)rv;
+ if (n == -1) PANIC (run, SSE_AWK_EPOSIDX);
+ if (n == 1) lv = (sse_long_t)rv;
- if (lv < 0) PANIC (run, XP_AWK_EPOSIDX);
+ if (lv < 0) PANIC (run, SSE_AWK_EPOSIDX);
if (lv == 0) v = run->inrec.d0;
else if (lv > 0 && lv <= run->inrec.nflds)
v = run->inrec.flds[lv-1].val;
- else v = xp_awk_val_zls; /*xp_awk_val_nil;*/
+ else v = sse_awk_val_zls; /*sse_awk_val_nil;*/
return v;
}
-static xp_awk_val_t* __eval_getline (xp_awk_run_t* run, xp_awk_nde_t* nde)
+static sse_awk_val_t* __eval_getline (sse_awk_run_t* run, sse_awk_nde_t* nde)
{
- xp_awk_nde_getline_t* p;
- xp_awk_val_t* v, * res;
- xp_char_t* in = XP_NULL;
- const xp_char_t* dst;
- xp_awk_str_t buf;
+ sse_awk_nde_getline_t* p;
+ sse_awk_val_t* v, * res;
+ sse_char_t* in = SSE_NULL;
+ const sse_char_t* dst;
+ sse_awk_str_t buf;
int n;
- p = (xp_awk_nde_getline_t*)nde;
+ p = (sse_awk_nde_getline_t*)nde;
- xp_awk_assert (run->awk, (p->in_type == XP_AWK_IN_PIPE && p->in != XP_NULL) ||
- (p->in_type == XP_AWK_IN_COPROC && p->in != XP_NULL) ||
- (p->in_type == XP_AWK_IN_FILE && p->in != XP_NULL) ||
- (p->in_type == XP_AWK_IN_CONSOLE && p->in == XP_NULL));
+ sse_awk_assert (run->awk, (p->in_type == SSE_AWK_IN_PIPE && p->in != SSE_NULL) ||
+ (p->in_type == SSE_AWK_IN_COPROC && p->in != SSE_NULL) ||
+ (p->in_type == SSE_AWK_IN_FILE && p->in != SSE_NULL) ||
+ (p->in_type == SSE_AWK_IN_CONSOLE && p->in == SSE_NULL));
- if (p->in != XP_NULL)
+ if (p->in != SSE_NULL)
{
- xp_size_t len;
+ sse_size_t len;
- v = __eval_expression (run, p->in);
- if (v == XP_NULL) return XP_NULL;
+ v = __eval_esseression (run, p->in);
+ if (v == SSE_NULL) return SSE_NULL;
- /* TODO: distinction between v->type == XP_AWK_VAL_STR
- * and v->type != XP_AWK_VAL_STR
+ /* TODO: distinction between v->type == SSE_AWK_VAL_STR
+ * and v->type != SSE_AWK_VAL_STR
* if you use the buffer the v directly when
- * v->type == XP_AWK_VAL_STR, xp_awk_refdownval(v)
+ * v->type == SSE_AWK_VAL_STR, sse_awk_refdownval(v)
* should not be called immediately below */
- xp_awk_refupval (v);
- in = xp_awk_valtostr (
- run, v, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &len);
- if (in == XP_NULL)
+ sse_awk_refupval (v);
+ in = sse_awk_valtostr (
+ run, v, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
+ if (in == SSE_NULL)
{
- xp_awk_refdownval (run, v);
- return XP_NULL;
+ sse_awk_refdownval (run, v);
+ return SSE_NULL;
}
- xp_awk_refdownval (run, v);
+ sse_awk_refdownval (run, v);
if (len <= 0)
{
/* the input source name is empty.
* make getline return -1 */
- XP_AWK_FREE (run->awk, in);
+ SSE_AWK_FREE (run->awk, in);
n = -1;
goto skip_read;
}
while (len > 0)
{
- if (in[--len] == XP_T('\0'))
+ if (in[--len] == SSE_T('\0'))
{
/* the input source name contains a null
* character. make getline return -1 */
/* TODO: set ERRNO */
- XP_AWK_FREE (run->awk, in);
+ SSE_AWK_FREE (run->awk, in);
n = -1;
goto skip_read;
}
}
}
- dst = (in == XP_NULL)? XP_T(""): in;
+ dst = (in == SSE_NULL)? SSE_T(""): in;
/* TODO: optimize the line buffer management */
- if (xp_awk_str_open (&buf, DEF_BUF_CAPA, run->awk) == XP_NULL)
+ if (sse_awk_str_open (&buf, DEF_BUF_CAPA, run->awk) == SSE_NULL)
{
- if (in != XP_NULL) XP_AWK_FREE (run->awk, in);
- PANIC (run, XP_AWK_ENOMEM);
+ if (in != SSE_NULL) SSE_AWK_FREE (run->awk, in);
+ PANIC (run, SSE_AWK_ENOMEM);
}
- n = xp_awk_readextio (run, p->in_type, dst, &buf);
- if (in != XP_NULL) XP_AWK_FREE (run->awk, in);
+ n = sse_awk_readextio (run, p->in_type, dst, &buf);
+ if (in != SSE_NULL) SSE_AWK_FREE (run->awk, in);
if (n < 0)
{
- if (run->errnum != XP_AWK_EIOHANDLER)
+ if (run->errnum != SSE_AWK_EIOHANDLER)
{
- xp_awk_str_close (&buf);
- return XP_NULL;
+ sse_awk_str_close (&buf);
+ return SSE_NULL;
}
- /* if run->errnum == XP_AWK_EIOHANDLER,
+ /* if run->errnum == SSE_AWK_EIOHANDLER,
* make getline return -1 */
n = -1;
}
if (n > 0)
{
- if (p->var == XP_NULL)
+ if (p->var == SSE_NULL)
{
/* set $0 with the input value */
- if (xp_awk_setrec (run, 0,
- XP_AWK_STR_BUF(&buf),
- XP_AWK_STR_LEN(&buf)) == -1)
+ if (sse_awk_setrec (run, 0,
+ SSE_AWK_STR_BUF(&buf),
+ SSE_AWK_STR_LEN(&buf)) == -1)
{
- xp_awk_str_close (&buf);
- return XP_NULL;
+ sse_awk_str_close (&buf);
+ return SSE_NULL;
}
- xp_awk_str_close (&buf);
+ sse_awk_str_close (&buf);
}
else
{
- xp_awk_val_t* v;
+ sse_awk_val_t* v;
- v = xp_awk_makestrval (
- run, XP_AWK_STR_BUF(&buf), XP_AWK_STR_LEN(&buf));
- xp_awk_str_close (&buf);
- if (v == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ v = sse_awk_makestrval (
+ run, SSE_AWK_STR_BUF(&buf), SSE_AWK_STR_LEN(&buf));
+ sse_awk_str_close (&buf);
+ if (v == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
- xp_awk_refupval (v);
- if (__do_assignment(run, p->var, v) == XP_NULL)
+ sse_awk_refupval (v);
+ if (__do_assignment(run, p->var, v) == SSE_NULL)
{
- xp_awk_refdownval (run, v);
- return XP_NULL;
+ sse_awk_refdownval (run, v);
+ return SSE_NULL;
}
- xp_awk_refdownval (run, v);
+ sse_awk_refdownval (run, v);
}
}
else
{
- xp_awk_str_close (&buf);
+ sse_awk_str_close (&buf);
}
skip_read:
- res = xp_awk_makeintval (run, n);
- if (res == XP_NULL) PANIC (run, XP_AWK_ENOMEM);
+ res = sse_awk_makeintval (run, n);
+ if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
return res;
}
-static int __raw_push (xp_awk_run_t* run, void* val)
+static int __raw_push (sse_awk_run_t* run, void* val)
{
if (run->stack_top >= run->stack_limit)
{
void** tmp;
- xp_size_t n;
+ sse_size_t n;
n = run->stack_limit + STACK_INCREMENT;
- if (run->awk->syscas.realloc != XP_NULL)
+ if (run->awk->syscas.realloc != SSE_NULL)
{
- tmp = (void**) XP_AWK_REALLOC (
- run->awk, run->stack, n * xp_sizeof(void*));
- if (tmp == XP_NULL) return -1;
+ tmp = (void**) SSE_AWK_REALLOC (
+ run->awk, run->stack, n * sse_sizeof(void*));
+ if (tmp == SSE_NULL) return -1;
}
else
{
- tmp = (void**) XP_AWK_MALLOC (
- run->awk, n * xp_sizeof(void*));
- if (tmp == XP_NULL) return -1;
- if (run->stack != XP_NULL)
+ tmp = (void**) SSE_AWK_MALLOC (
+ run->awk, n * sse_sizeof(void*));
+ if (tmp == SSE_NULL) return -1;
+ if (run->stack != SSE_NULL)
{
- XP_AWK_MEMCPY (run->awk, tmp, run->stack,
- run->stack_limit * xp_sizeof(void*));
- XP_AWK_FREE (run->awk, run->stack);
+ SSE_AWK_MEMCPY (run->awk, tmp, run->stack,
+ run->stack_limit * sse_sizeof(void*));
+ SSE_AWK_FREE (run->awk, run->stack);
}
}
run->stack = tmp;
@@ -5028,7 +5028,7 @@ static int __raw_push (xp_awk_run_t* run, void* val)
return 0;
}
-static void __raw_pop_times (xp_awk_run_t* run, xp_size_t times)
+static void __raw_pop_times (sse_awk_run_t* run, sse_size_t times)
{
while (times > 0)
{
@@ -5037,206 +5037,206 @@ static void __raw_pop_times (xp_awk_run_t* run, xp_size_t times)
}
}
-static int __read_record (xp_awk_run_t* run)
+static int __read_record (sse_awk_run_t* run)
{
- xp_ssize_t n;
+ sse_ssize_t n;
- if (xp_awk_clrrec (run, xp_false) == -1) return -1;
+ if (sse_awk_clrrec (run, sse_false) == -1) return -1;
- n = xp_awk_readextio (
- run, XP_AWK_IN_CONSOLE, XP_T(""), &run->inrec.line);
+ n = sse_awk_readextio (
+ run, SSE_AWK_IN_CONSOLE, SSE_T(""), &run->inrec.line);
if (n < 0)
{
int errnum = run->errnum;
- xp_awk_clrrec (run, xp_false);
+ sse_awk_clrrec (run, sse_false);
run->errnum =
- (errnum == XP_AWK_EIOHANDLER)?
- XP_AWK_ECONINDATA: errnum;
+ (errnum == SSE_AWK_EIOHANDLER)?
+ SSE_AWK_ECONINDATA: errnum;
return -1;
}
/*
-xp_printf (XP_T("len = %d str=[%s]\n"),
- (int)XP_AWK_STR_LEN(&run->inrec.line),
- XP_AWK_STR_BUF(&run->inrec.line));
+sse_printf (SSE_T("len = %d str=[%s]\n"),
+ (int)SSE_AWK_STR_LEN(&run->inrec.line),
+ SSE_AWK_STR_BUF(&run->inrec.line));
*/
if (n == 0)
{
- xp_awk_assert (run->awk, XP_AWK_STR_LEN(&run->inrec.line) == 0);
+ sse_awk_assert (run->awk, SSE_AWK_STR_LEN(&run->inrec.line) == 0);
return 0;
}
- if (xp_awk_setrec (run, 0,
- XP_AWK_STR_BUF(&run->inrec.line),
- XP_AWK_STR_LEN(&run->inrec.line)) == -1) return -1;
+ if (sse_awk_setrec (run, 0,
+ SSE_AWK_STR_BUF(&run->inrec.line),
+ SSE_AWK_STR_LEN(&run->inrec.line)) == -1) return -1;
return 1;
}
-static int __shorten_record (xp_awk_run_t* run, xp_size_t nflds)
+static int __shorten_record (sse_awk_run_t* run, sse_size_t nflds)
{
- xp_awk_val_t* v;
- xp_char_t* ofs_free = XP_NULL, * ofs;
- xp_size_t ofs_len, i;
- xp_awk_str_t tmp;
+ sse_awk_val_t* v;
+ sse_char_t* ofs_free = SSE_NULL, * ofs;
+ sse_size_t ofs_len, i;
+ sse_awk_str_t tmp;
- xp_awk_assert (run->awk, nflds <= run->inrec.nflds);
+ sse_awk_assert (run->awk, nflds <= run->inrec.nflds);
if (nflds > 1)
{
- v = STACK_GLOBAL(run, XP_AWK_GLOBAL_OFS);
- xp_awk_refupval (v);
+ v = STACK_GLOBAL(run, SSE_AWK_GLOBAL_OFS);
+ sse_awk_refupval (v);
- if (v->type == XP_AWK_VAL_NIL)
+ if (v->type == SSE_AWK_VAL_NIL)
{
/* OFS not set */
- ofs = XP_T(" ");
+ ofs = SSE_T(" ");
ofs_len = 1;
}
- else if (v->type == XP_AWK_VAL_STR)
+ else if (v->type == SSE_AWK_VAL_STR)
{
- ofs = ((xp_awk_val_str_t*)v)->buf;
- ofs_len = ((xp_awk_val_str_t*)v)->len;
+ ofs = ((sse_awk_val_str_t*)v)->buf;
+ ofs_len = ((sse_awk_val_str_t*)v)->len;
}
else
{
- ofs = xp_awk_valtostr (
- run, v, XP_AWK_VALTOSTR_CLEAR, XP_NULL, &ofs_len);
- if (ofs == XP_NULL) return -1;
+ ofs = sse_awk_valtostr (
+ run, v, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &ofs_len);
+ if (ofs == SSE_NULL) return -1;
ofs_free = ofs;
}
}
- if (xp_awk_str_open (&tmp,
- XP_AWK_STR_LEN(&run->inrec.line), run->awk) == XP_NULL)
+ if (sse_awk_str_open (&tmp,
+ SSE_AWK_STR_LEN(&run->inrec.line), run->awk) == SSE_NULL)
{
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
for (i = 0; i < nflds; i++)
{
- if (i > 0 && xp_awk_str_ncat (&tmp, ofs, ofs_len) == (xp_size_t)-1)
+ if (i > 0 && sse_awk_str_ncat (&tmp, ofs, ofs_len) == (sse_size_t)-1)
{
- if (ofs_free != XP_NULL)
- XP_AWK_FREE (run->awk, ofs_free);
- if (nflds > 1) xp_awk_refdownval (run, v);
- run->errnum = XP_AWK_ENOMEM;
+ if (ofs_free != SSE_NULL)
+ SSE_AWK_FREE (run->awk, ofs_free);
+ if (nflds > 1) sse_awk_refdownval (run, v);
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
- if (xp_awk_str_ncat (&tmp,
+ if (sse_awk_str_ncat (&tmp,
run->inrec.flds[i].ptr,
- run->inrec.flds[i].len) == (xp_size_t)-1)
+ run->inrec.flds[i].len) == (sse_size_t)-1)
{
- if (ofs_free != XP_NULL)
- XP_AWK_FREE (run->awk, ofs_free);
- if (nflds > 1) xp_awk_refdownval (run, v);
- run->errnum = XP_AWK_ENOMEM;
+ if (ofs_free != SSE_NULL)
+ SSE_AWK_FREE (run->awk, ofs_free);
+ if (nflds > 1) sse_awk_refdownval (run, v);
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
}
- if (ofs_free != XP_NULL) XP_AWK_FREE (run->awk, ofs_free);
- if (nflds > 1) xp_awk_refdownval (run, v);
+ if (ofs_free != SSE_NULL) SSE_AWK_FREE (run->awk, ofs_free);
+ if (nflds > 1) sse_awk_refdownval (run, v);
- v = (xp_awk_val_t*) xp_awk_makestrval (
- run, XP_AWK_STR_BUF(&tmp), XP_AWK_STR_LEN(&tmp));
- if (v == XP_NULL)
+ v = (sse_awk_val_t*) sse_awk_makestrval (
+ run, SSE_AWK_STR_BUF(&tmp), SSE_AWK_STR_LEN(&tmp));
+ if (v == SSE_NULL)
{
- run->errnum = XP_AWK_ENOMEM;
+ run->errnum = SSE_AWK_ENOMEM;
return -1;
}
- xp_awk_refdownval (run, run->inrec.d0);
+ sse_awk_refdownval (run, run->inrec.d0);
run->inrec.d0 = v;
- xp_awk_refupval (run->inrec.d0);
+ sse_awk_refupval (run->inrec.d0);
- xp_awk_str_swap (&tmp, &run->inrec.line);
- xp_awk_str_close (&tmp);
+ sse_awk_str_swap (&tmp, &run->inrec.line);
+ sse_awk_str_close (&tmp);
for (i = nflds; i < run->inrec.nflds; i++)
{
- xp_awk_refdownval (run, run->inrec.flds[i].val);
+ sse_awk_refdownval (run, run->inrec.flds[i].val);
}
run->inrec.nflds = nflds;
return 0;
}
-static xp_char_t* __idxnde_to_str (
- xp_awk_run_t* run, xp_awk_nde_t* nde, xp_size_t* len)
+static sse_char_t* __idxnde_to_str (
+ sse_awk_run_t* run, sse_awk_nde_t* nde, sse_size_t* len)
{
- xp_char_t* str;
- xp_awk_val_t* idx;
+ sse_char_t* str;
+ sse_awk_val_t* idx;
- xp_awk_assert (run->awk, nde != XP_NULL);
+ sse_awk_assert (run->awk, nde != SSE_NULL);
- if (nde->next == XP_NULL)
+ if (nde->next == SSE_NULL)
{
/* single node index */
- idx = __eval_expression (run, nde);
- if (idx == XP_NULL) return XP_NULL;
+ idx = __eval_esseression (run, nde);
+ if (idx == SSE_NULL) return SSE_NULL;
- xp_awk_refupval (idx);
+ sse_awk_refupval (idx);
- str = xp_awk_valtostr (
- run, idx, XP_AWK_VALTOSTR_CLEAR, XP_NULL, len);
- if (str == XP_NULL)
+ str = sse_awk_valtostr (
+ run, idx, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, len);
+ if (str == SSE_NULL)
{
- xp_awk_refdownval (run, idx);
- return XP_NULL;
+ sse_awk_refdownval (run, idx);
+ return SSE_NULL;
}
- xp_awk_refdownval (run, idx);
+ sse_awk_refdownval (run, idx);
}
else
{
/* multidimensional index */
- xp_awk_str_t idxstr;
+ sse_awk_str_t idxstr;
- if (xp_awk_str_open (
- &idxstr, DEF_BUF_CAPA, run->awk) == XP_NULL)
+ if (sse_awk_str_open (
+ &idxstr, DEF_BUF_CAPA, run->awk) == SSE_NULL)
{
- PANIC (run, XP_AWK_ENOMEM);
+ PANIC (run, SSE_AWK_ENOMEM);
}
- while (nde != XP_NULL)
+ while (nde != SSE_NULL)
{
- idx = __eval_expression (run, nde);
- if (idx == XP_NULL)
+ idx = __eval_esseression (run, nde);
+ if (idx == SSE_NULL)
{
- xp_awk_str_close (&idxstr);
- return XP_NULL;
+ sse_awk_str_close (&idxstr);
+ return SSE_NULL;
}
- xp_awk_refupval (idx);
+ sse_awk_refupval (idx);
- if (XP_AWK_STR_LEN(&idxstr) > 0 &&
- xp_awk_str_ncat (&idxstr,
+ if (SSE_AWK_STR_LEN(&idxstr) > 0 &&
+ sse_awk_str_ncat (&idxstr,
run->global.subsep.ptr,
- run->global.subsep.len) == (xp_size_t)-1)
+ run->global.subsep.len) == (sse_size_t)-1)
{
- xp_awk_refdownval (run, idx);
- xp_awk_str_close (&idxstr);
- PANIC (run, XP_AWK_ENOMEM);
+ sse_awk_refdownval (run, idx);
+ sse_awk_str_close (&idxstr);
+ PANIC (run, SSE_AWK_ENOMEM);
}
- if (xp_awk_valtostr (
- run, idx, 0, &idxstr, XP_NULL) == XP_NULL)
+ if (sse_awk_valtostr (
+ run, idx, 0, &idxstr, SSE_NULL) == SSE_NULL)
{
- xp_awk_refdownval (run, idx);
- xp_awk_str_close (&idxstr);
- return XP_NULL;
+ sse_awk_refdownval (run, idx);
+ sse_awk_str_close (&idxstr);
+ return SSE_NULL;
}
- xp_awk_refdownval (run, idx);
+ sse_awk_refdownval (run, idx);
nde = nde->next;
}
- str = XP_AWK_STR_BUF(&idxstr);
- *len = XP_AWK_STR_LEN(&idxstr);
- xp_awk_str_forfeit (&idxstr);
+ str = SSE_AWK_STR_BUF(&idxstr);
+ *len = SSE_AWK_STR_LEN(&idxstr);
+ sse_awk_str_forfeit (&idxstr);
}
return str;
diff --git a/ase/awk/run.h b/ase/awk/run.h
index 0a554c5c..d80e200f 100644
--- a/ase/awk/run.h
+++ b/ase/awk/run.h
@@ -1,103 +1,103 @@
/*
- * $Id: run.h,v 1.18 2006-10-19 11:08:54 bacon Exp $
+ * $Id: run.h,v 1.19 2006-10-22 11:34:53 bacon Exp $
*/
-#ifndef _XP_AWK_RUN_H_
-#define _XP_AWK_RUN_H_
+#ifndef _SSE_AWK_RUN_H_
+#define _SSE_AWK_RUN_H_
-#ifndef _XP_AWK_AWK_H_
-#error Never include this file directly. Include <xp/awk/awk.h> instead
+#ifndef _SSE_AWK_AWK_H_
+#error Never include this file directly. Include <sse/awk/awk.h> instead
#endif
enum
{
/* if you change this, you have to change __assop_str in tree.c */
- XP_AWK_ASSOP_NONE,
- XP_AWK_ASSOP_PLUS,
- XP_AWK_ASSOP_MINUS,
- XP_AWK_ASSOP_MUL,
- XP_AWK_ASSOP_DIV,
- XP_AWK_ASSOP_MOD,
- XP_AWK_ASSOP_EXP
+ 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_ESSE
};
enum
{
/* if you change this, you have to change
* __binop_str in tree.c and __binop_func in run.c accordingly. */
- XP_AWK_BINOP_LOR,
- XP_AWK_BINOP_LAND,
- XP_AWK_BINOP_IN,
+ SSE_AWK_BINOP_LOR,
+ SSE_AWK_BINOP_LAND,
+ SSE_AWK_BINOP_IN,
- XP_AWK_BINOP_BOR,
- XP_AWK_BINOP_BXOR,
- XP_AWK_BINOP_BAND,
+ SSE_AWK_BINOP_BOR,
+ SSE_AWK_BINOP_BXOR,
+ SSE_AWK_BINOP_BAND,
- XP_AWK_BINOP_EQ,
- XP_AWK_BINOP_NE,
- XP_AWK_BINOP_GT,
- XP_AWK_BINOP_GE,
- XP_AWK_BINOP_LT,
- XP_AWK_BINOP_LE,
+ SSE_AWK_BINOP_EQ,
+ SSE_AWK_BINOP_NE,
+ SSE_AWK_BINOP_GT,
+ SSE_AWK_BINOP_GE,
+ SSE_AWK_BINOP_LT,
+ SSE_AWK_BINOP_LE,
- XP_AWK_BINOP_LSHIFT,
- XP_AWK_BINOP_RSHIFT,
+ SSE_AWK_BINOP_LSHIFT,
+ SSE_AWK_BINOP_RSHIFT,
- XP_AWK_BINOP_PLUS,
- XP_AWK_BINOP_MINUS,
- XP_AWK_BINOP_MUL,
- XP_AWK_BINOP_DIV,
- XP_AWK_BINOP_MOD,
- XP_AWK_BINOP_EXP,
+ SSE_AWK_BINOP_PLUS,
+ SSE_AWK_BINOP_MINUS,
+ SSE_AWK_BINOP_MUL,
+ SSE_AWK_BINOP_DIV,
+ SSE_AWK_BINOP_MOD,
+ SSE_AWK_BINOP_ESSE,
- XP_AWK_BINOP_CONCAT,
- XP_AWK_BINOP_MA,
- XP_AWK_BINOP_NM
+ SSE_AWK_BINOP_CONCAT,
+ SSE_AWK_BINOP_MA,
+ SSE_AWK_BINOP_NM
};
enum
{
/* if you change this, you have to change
* __unrop_str in tree.c accordingly. */
- XP_AWK_UNROP_PLUS,
- XP_AWK_UNROP_MINUS,
- XP_AWK_UNROP_NOT,
- XP_AWK_UNROP_BNOT
+ SSE_AWK_UNROP_PLUS,
+ SSE_AWK_UNROP_MINUS,
+ SSE_AWK_UNROP_NOT,
+ SSE_AWK_UNROP_BNOT
};
enum
{
/* if you change this, you have to change
* __incop_str in tree.c accordingly. */
- XP_AWK_INCOP_PLUS,
- XP_AWK_INCOP_MINUS
+ SSE_AWK_INCOP_PLUS,
+ SSE_AWK_INCOP_MINUS
};
enum
{
/* this table should match __bvtab in parse.c.
- * in addition, xp_awk_setglobal also counts
+ * in addition, sse_awk_setglobal also counts
* on the order of these values */
- XP_AWK_GLOBAL_ARGC,
- XP_AWK_GLOBAL_ARGV,
- XP_AWK_GLOBAL_CONVFMT,
- XP_AWK_GLOBAL_ENVIRON,
- XP_AWK_GLOBAL_ERRNO,
- XP_AWK_GLOBAL_FILENAME,
- XP_AWK_GLOBAL_FNR,
- XP_AWK_GLOBAL_FS,
- XP_AWK_GLOBAL_IGNORECASE,
- XP_AWK_GLOBAL_NF,
- XP_AWK_GLOBAL_NR,
- XP_AWK_GLOBAL_OFMT,
- XP_AWK_GLOBAL_OFS,
- XP_AWK_GLOBAL_ORS,
- XP_AWK_GLOBAL_RS,
- XP_AWK_GLOBAL_RT,
- XP_AWK_GLOBAL_RSTART,
- XP_AWK_GLOBAL_RLENGTH,
- XP_AWK_GLOBAL_SUBSEP
+ 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
};
#endif
diff --git a/ase/awk/str.c b/ase/awk/str.c
index 8b2fcceb..af18f5e1 100644
--- a/ase/awk/str.c
+++ b/ase/awk/str.c
@@ -1,50 +1,50 @@
/*
- * $Id: str.c,v 1.8 2006-10-12 14:36:25 bacon Exp $
+ * $Id: str.c,v 1.9 2006-10-22 11:34:53 bacon Exp $
*/
-#include <xp/awk/awk_i.h>
+#include <sse/awk/awk_i.h>
-xp_awk_str_t* xp_awk_str_open (
- xp_awk_str_t* str, xp_size_t capa, xp_awk_t* awk)
+sse_awk_str_t* sse_awk_str_open (
+ sse_awk_str_t* str, sse_size_t capa, sse_awk_t* awk)
{
- if (str == XP_NULL)
+ if (str == SSE_NULL)
{
- str = (xp_awk_str_t*) XP_AWK_MALLOC (awk, sizeof(xp_awk_str_t));
- if (str == XP_NULL) return XP_NULL;
- str->__dynamic = xp_true;
+ 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;
}
- else str->__dynamic = xp_false;
+ else str->__dynamic = sse_false;
str->awk = awk;
- str->buf = (xp_char_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_char_t) * (capa + 1));
- if (str->buf == XP_NULL)
+ str->buf = (sse_char_t*) SSE_AWK_MALLOC (
+ awk, sse_sizeof(sse_char_t) * (capa + 1));
+ if (str->buf == SSE_NULL)
{
- if (str->__dynamic) XP_AWK_FREE (awk, str);
- return XP_NULL;
+ if (str->__dynamic) SSE_AWK_FREE (awk, str);
+ return SSE_NULL;
}
str->size = 0;
str->capa = capa;
- str->buf[0] = XP_T('\0');
+ str->buf[0] = SSE_T('\0');
return str;
}
-void xp_awk_str_close (xp_awk_str_t* str)
+void sse_awk_str_close (sse_awk_str_t* str)
{
- XP_AWK_FREE (str->awk, str->buf);
- if (str->__dynamic) XP_AWK_FREE (str->awk, str);
+ SSE_AWK_FREE (str->awk, str->buf);
+ if (str->__dynamic) SSE_AWK_FREE (str->awk, str);
}
-void xp_awk_str_forfeit (xp_awk_str_t* str)
+void sse_awk_str_forfeit (sse_awk_str_t* str)
{
- if (str->__dynamic) XP_AWK_FREE (str->awk, str);
+ if (str->__dynamic) SSE_AWK_FREE (str->awk, str);
}
-void xp_awk_str_swap (xp_awk_str_t* str, xp_awk_str_t* str1)
+void sse_awk_str_swap (sse_awk_str_t* str, sse_awk_str_t* str1)
{
- xp_awk_str_t tmp;
+ sse_awk_str_t tmp;
tmp.buf = str->buf;
tmp.size = str->size;
@@ -62,67 +62,67 @@ void xp_awk_str_swap (xp_awk_str_t* str, xp_awk_str_t* str1)
str1->awk = tmp.awk;
}
-xp_size_t xp_awk_str_cpy (xp_awk_str_t* str, const xp_char_t* s)
+sse_size_t sse_awk_str_cpy (sse_awk_str_t* str, const sse_char_t* s)
{
/* TODO: improve it */
- return xp_awk_str_ncpy (str, s, xp_awk_strlen(s));
+ return sse_awk_str_ncpy (str, s, sse_awk_strlen(s));
}
-xp_size_t xp_awk_str_ncpy (xp_awk_str_t* str, const xp_char_t* s, xp_size_t len)
+sse_size_t sse_awk_str_ncpy (sse_awk_str_t* str, const sse_char_t* s, sse_size_t len)
{
- xp_char_t* buf;
+ sse_char_t* buf;
if (len > str->capa)
{
- buf = (xp_char_t*) XP_AWK_MALLOC (
- str->awk, xp_sizeof(xp_char_t) * (len + 1));
- if (buf == XP_NULL) return (xp_size_t)-1;
+ 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;
- XP_AWK_FREE (str->awk, str->buf);
+ SSE_AWK_FREE (str->awk, str->buf);
str->capa = len;
str->buf = buf;
}
- str->size = xp_awk_strncpy (str->buf, s, len);
- str->buf[str->size] = XP_T('\0');
+ str->size = sse_awk_strncpy (str->buf, s, len);
+ str->buf[str->size] = SSE_T('\0');
return str->size;
}
-xp_size_t xp_awk_str_cat (xp_awk_str_t* str, const xp_char_t* s)
+sse_size_t sse_awk_str_cat (sse_awk_str_t* str, const sse_char_t* s)
{
/* TODO: improve it */
- return xp_awk_str_ncat (str, s, xp_awk_strlen(s));
+ return sse_awk_str_ncat (str, s, sse_awk_strlen(s));
}
-xp_size_t xp_awk_str_ncat (xp_awk_str_t* str, const xp_char_t* s, xp_size_t len)
+sse_size_t sse_awk_str_ncat (sse_awk_str_t* str, const sse_char_t* s, sse_size_t len)
{
if (len > str->capa - str->size)
{
- xp_char_t* tmp;
- xp_size_t capa;
+ sse_char_t* tmp;
+ sse_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 != XP_NULL)
+ if (str->awk->syscas.realloc != SSE_NULL)
{
- tmp = (xp_char_t*) XP_AWK_REALLOC (
+ tmp = (sse_char_t*) SSE_AWK_REALLOC (
str->awk, str->buf,
- xp_sizeof(xp_char_t) * (capa + 1));
- if (tmp == XP_NULL) return (xp_size_t)-1;
+ sse_sizeof(sse_char_t) * (capa + 1));
+ if (tmp == SSE_NULL) return (sse_size_t)-1;
}
else
{
- tmp = (xp_char_t*) XP_AWK_MALLOC (
- str->awk, xp_sizeof(xp_char_t) * (capa + 1));
- if (tmp == XP_NULL) return (xp_size_t)-1;
- if (str->buf != XP_NULL)
+ 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)
{
- XP_AWK_MEMCPY (str->awk, tmp, str->buf,
- xp_sizeof(xp_char_t) * (str->capa + 1));
- XP_AWK_FREE (str->awk, str->buf);
+ SSE_AWK_MEMCPY (str->awk, tmp, str->buf,
+ sse_sizeof(sse_char_t) * (str->capa + 1));
+ SSE_AWK_FREE (str->awk, str->buf);
}
}
@@ -130,23 +130,23 @@ xp_size_t xp_awk_str_ncat (xp_awk_str_t* str, const xp_char_t* s, xp_size_t len)
str->buf = tmp;
}
- str->size += xp_awk_strncpy (&str->buf[str->size], s, len);
- str->buf[str->size] = XP_T('\0');
+ str->size += sse_awk_strncpy (&str->buf[str->size], s, len);
+ str->buf[str->size] = SSE_T('\0');
return str->size;
}
-xp_size_t xp_awk_str_ccat (xp_awk_str_t* str, xp_char_t c)
+sse_size_t sse_awk_str_ccat (sse_awk_str_t* str, sse_char_t c)
{
- return xp_awk_str_ncat (str, &c, 1);
+ return sse_awk_str_ncat (str, &c, 1);
}
-xp_size_t xp_awk_str_nccat (xp_awk_str_t* str, xp_char_t c, xp_size_t len)
+sse_size_t sse_awk_str_nccat (sse_awk_str_t* str, sse_char_t c, sse_size_t len)
{
while (len > 0)
{
- if (xp_awk_str_ncat (str, &c, 1) == (xp_size_t)-1)
+ if (sse_awk_str_ncat (str, &c, 1) == (sse_size_t)-1)
{
- return (xp_size_t)-1;
+ return (sse_size_t)-1;
}
len--;
@@ -154,9 +154,9 @@ xp_size_t xp_awk_str_nccat (xp_awk_str_t* str, xp_char_t c, xp_size_t len)
return str->size;
}
-void xp_awk_str_clear (xp_awk_str_t* str)
+void sse_awk_str_clear (sse_awk_str_t* str)
{
str->size = 0;
- str->buf[0] = XP_T('\0');
+ str->buf[0] = SSE_T('\0');
}
diff --git a/ase/awk/str.h b/ase/awk/str.h
index 1d26a90b..7091ff43 100644
--- a/ase/awk/str.h
+++ b/ase/awk/str.h
@@ -1,58 +1,58 @@
/*
- * $Id: str.h,v 1.2 2006-09-10 15:50:34 bacon Exp $
+ * $Id: str.h,v 1.3 2006-10-22 11:34:53 bacon Exp $
*/
-#ifndef _XP_AWK_STR_H_
-#define _XP_AWK_STR_H_
+#ifndef _SSE_AWK_STR_H_
+#define _SSE_AWK_STR_H_
-#ifndef _XP_AWK_AWK_H_
-#error Never include this file directly. Include <xp/awk/awk.h> instead
+#ifndef _SSE_AWK_AWK_H_
+#error Never include this file directly. Include <sse/awk/awk.h> instead
#endif
-#define XP_AWK_STR_LEN(x) ((x)->size)
-#define XP_AWK_STR_SIZE(x) ((x)->size + 1)
-#define XP_AWK_STR_CAPA(x) ((x)->capa)
-#define XP_AWK_STR_BUF(x) ((x)->buf)
-#define XP_AWK_STR_CHAR(x,idx) ((x)->buf[idx])
+#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])
-typedef struct xp_awk_str_t xp_awk_str_t;
+typedef struct sse_awk_str_t sse_awk_str_t;
-struct xp_awk_str_t
+struct sse_awk_str_t
{
- xp_char_t* buf;
- xp_size_t size;
- xp_size_t capa;
- xp_awk_t* awk;
- xp_bool_t __dynamic;
+ sse_char_t* buf;
+ sse_size_t size;
+ sse_size_t capa;
+ sse_awk_t* awk;
+ sse_bool_t __dynamic;
};
#ifdef __cplusplus
extern "C" {
#endif
-xp_awk_str_t* xp_awk_str_open (
- xp_awk_str_t* str, xp_size_t capa, xp_awk_t* awk);
+sse_awk_str_t* sse_awk_str_open (
+ sse_awk_str_t* str, sse_size_t capa, sse_awk_t* awk);
-void xp_awk_str_close (xp_awk_str_t* str);
+void sse_awk_str_close (sse_awk_str_t* str);
-void xp_awk_str_forfeit (xp_awk_str_t* str);
-void xp_awk_str_swap (xp_awk_str_t* str, xp_awk_str_t* str2);
+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);
-xp_size_t xp_awk_str_cpy (xp_awk_str_t* str, const xp_char_t* s);
+sse_size_t sse_awk_str_cpy (sse_awk_str_t* str, const sse_char_t* s);
-xp_size_t xp_awk_str_ncpy (
- xp_awk_str_t* str, const xp_char_t* s, xp_size_t len);
+sse_size_t sse_awk_str_ncpy (
+ sse_awk_str_t* str, const sse_char_t* s, sse_size_t len);
-xp_size_t xp_awk_str_cat (xp_awk_str_t* str, const xp_char_t* s);
+sse_size_t sse_awk_str_cat (sse_awk_str_t* str, const sse_char_t* s);
-xp_size_t xp_awk_str_ncat (
- xp_awk_str_t* str, const xp_char_t* s, xp_size_t len);
+sse_size_t sse_awk_str_ncat (
+ sse_awk_str_t* str, const sse_char_t* s, sse_size_t len);
-xp_size_t xp_awk_str_ccat (xp_awk_str_t* str, xp_char_t c);
+sse_size_t sse_awk_str_ccat (sse_awk_str_t* str, sse_char_t c);
-xp_size_t xp_awk_str_nccat (xp_awk_str_t* str, xp_char_t c, xp_size_t len);
+sse_size_t sse_awk_str_nccat (sse_awk_str_t* str, sse_char_t c, sse_size_t len);
-void xp_awk_str_clear (xp_awk_str_t* str);
+void sse_awk_str_clear (sse_awk_str_t* str);
#ifdef __cplusplus
}
diff --git a/ase/awk/tab.c b/ase/awk/tab.c
index 138f8a7d..f6958452 100644
--- a/ase/awk/tab.c
+++ b/ase/awk/tab.c
@@ -1,89 +1,89 @@
/*
- * $Id: tab.c,v 1.21 2006-10-12 14:36:25 bacon Exp $
+ * $Id: tab.c,v 1.22 2006-10-22 11:34:53 bacon Exp $
*/
-#include <xp/awk/awk_i.h>
+#include <sse/awk/awk_i.h>
-xp_awk_tab_t* xp_awk_tab_open (xp_awk_tab_t* tab, xp_awk_t* awk)
+sse_awk_tab_t* sse_awk_tab_open (sse_awk_tab_t* tab, sse_awk_t* awk)
{
- if (tab == XP_NULL)
+ if (tab == SSE_NULL)
{
- tab = (xp_awk_tab_t*) XP_AWK_MALLOC (
- awk, xp_sizeof(xp_awk_tab_t));
- if (tab == XP_NULL) return XP_NULL;
- tab->__dynamic = xp_true;
+ 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;
}
- else tab->__dynamic = xp_false;
+ else tab->__dynamic = sse_false;
tab->awk = awk;
- tab->buf = XP_NULL;
+ tab->buf = SSE_NULL;
tab->size = 0;
tab->capa = 0;
return tab;
}
-void xp_awk_tab_close (xp_awk_tab_t* tab)
+void sse_awk_tab_close (sse_awk_tab_t* tab)
{
- xp_awk_tab_clear (tab);
- if (tab->buf != XP_NULL)
+ sse_awk_tab_clear (tab);
+ if (tab->buf != SSE_NULL)
{
- XP_AWK_FREE (tab->awk, tab->buf);
- tab->buf = XP_NULL;
+ SSE_AWK_FREE (tab->awk, tab->buf);
+ tab->buf = SSE_NULL;
tab->capa = 0;
}
- if (tab->__dynamic) XP_AWK_FREE (tab->awk, tab);
+ if (tab->__dynamic) SSE_AWK_FREE (tab->awk, tab);
}
-xp_size_t xp_awk_tab_getsize (xp_awk_tab_t* tab)
+sse_size_t sse_awk_tab_getsize (sse_awk_tab_t* tab)
{
return tab->size;
}
-xp_size_t xp_awk_tab_getcapa (xp_awk_tab_t* tab)
+sse_size_t sse_awk_tab_getcapa (sse_awk_tab_t* tab)
{
return tab->capa;
}
-xp_awk_tab_t* xp_awk_tab_setcapa (xp_awk_tab_t* tab, xp_size_t capa)
+sse_awk_tab_t* sse_awk_tab_setcapa (sse_awk_tab_t* tab, sse_size_t capa)
{
void* tmp;
if (tab->size > capa)
{
- xp_awk_tab_remove (tab, capa, tab->size - capa);
- xp_awk_assert (tab->awk, tab->size <= capa);
+ sse_awk_tab_remove (tab, capa, tab->size - capa);
+ sse_awk_assert (tab->awk, tab->size <= capa);
}
if (capa > 0)
{
- if (tab->awk->syscas.realloc != XP_NULL)
+ if (tab->awk->syscas.realloc != SSE_NULL)
{
- tmp = XP_AWK_REALLOC (tab->awk,
- tab->buf, xp_sizeof(*tab->buf) * capa);
- if (tmp == XP_NULL) return XP_NULL;
+ tmp = SSE_AWK_REALLOC (tab->awk,
+ tab->buf, sse_sizeof(*tab->buf) * capa);
+ if (tmp == SSE_NULL) return SSE_NULL;
}
else
{
- tmp = XP_AWK_MALLOC (
- tab->awk, xp_sizeof(*tab->buf) * capa);
- if (tmp == XP_NULL) return XP_NULL;
- if (tab->buf != XP_NULL)
+ tmp = SSE_AWK_MALLOC (
+ tab->awk, sse_sizeof(*tab->buf) * capa);
+ if (tmp == SSE_NULL) return SSE_NULL;
+ if (tab->buf != SSE_NULL)
{
- xp_size_t x;
+ sse_size_t x;
x = (capa > tab->capa)? tab->capa: capa;
- XP_AWK_MEMCPY (
+ SSE_AWK_MEMCPY (
tab->awk, tmp, tab->buf,
- xp_sizeof(*tab->buf) * x);
- XP_AWK_FREE (tab->awk, tab->buf);
+ sse_sizeof(*tab->buf) * x);
+ SSE_AWK_FREE (tab->awk, tab->buf);
}
}
}
else
{
- if (tab->buf != XP_NULL) XP_AWK_FREE (tab->awk, tab->buf);
- tmp = XP_NULL;
+ if (tab->buf != SSE_NULL) SSE_AWK_FREE (tab->awk, tab->buf);
+ tmp = SSE_NULL;
}
tab->buf = tmp;
@@ -92,14 +92,14 @@ xp_awk_tab_t* xp_awk_tab_setcapa (xp_awk_tab_t* tab, xp_size_t capa)
return tab;
}
-void xp_awk_tab_clear (xp_awk_tab_t* tab)
+void sse_awk_tab_clear (sse_awk_tab_t* tab)
{
- xp_size_t i;
+ sse_size_t i;
for (i = 0; i < tab->size; i++)
{
- XP_AWK_FREE (tab->awk, tab->buf[i].name);
- tab->buf[i].name = XP_NULL;
+ SSE_AWK_FREE (tab->awk, tab->buf[i].name);
+ tab->buf[i].name = SSE_NULL;
tab->buf[i].name_len = 0;
}
@@ -107,19 +107,19 @@ void xp_awk_tab_clear (xp_awk_tab_t* tab)
}
-xp_size_t xp_awk_tab_insert (
- xp_awk_tab_t* tab, xp_size_t index,
- const xp_char_t* str, xp_size_t len)
+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)
{
- xp_size_t i;
- xp_char_t* str_dup;
+ sse_size_t i;
+ sse_char_t* str_dup;
- str_dup = xp_awk_strxdup (tab->awk, str, len);
- if (str_dup == XP_NULL) return (xp_size_t)-1;
+ str_dup = sse_awk_strxdup (tab->awk, str, len);
+ if (str_dup == SSE_NULL) return (sse_size_t)-1;
if (index >= tab->capa)
{
- xp_size_t capa;
+ sse_size_t capa;
if (tab->capa <= 0) capa = (index + 1);
else
@@ -127,10 +127,10 @@ xp_size_t xp_awk_tab_insert (
do { capa = tab->capa * 2; } while (index >= capa);
}
- if (xp_awk_tab_setcapa(tab,capa) == XP_NULL)
+ if (sse_awk_tab_setcapa(tab,capa) == SSE_NULL)
{
- XP_AWK_FREE (tab->awk, str_dup);
- return (xp_size_t)-1;
+ SSE_AWK_FREE (tab->awk, str_dup);
+ return (sse_size_t)-1;
}
}
@@ -144,10 +144,10 @@ xp_size_t xp_awk_tab_insert (
return index;
}
-xp_size_t xp_awk_tab_remove (
- xp_awk_tab_t* tab, xp_size_t index, xp_size_t count)
+sse_size_t sse_awk_tab_remove (
+ sse_awk_tab_t* tab, sse_size_t index, sse_size_t count)
{
- xp_size_t i, j, k;
+ sse_size_t i, j, k;
if (index >= tab->size) return 0;
if (count > tab->size - index) count = tab->size - index;
@@ -158,11 +158,11 @@ xp_size_t xp_awk_tab_remove (
while (i < k)
{
- XP_AWK_FREE (tab->awk, tab->buf[i].name);
+ SSE_AWK_FREE (tab->awk, tab->buf[i].name);
if (j >= tab->size)
{
- tab->buf[i].name = XP_NULL;
+ tab->buf[i].name = SSE_NULL;
tab->buf[i].name_len = 0;
i++;
}
@@ -178,60 +178,60 @@ xp_size_t xp_awk_tab_remove (
return count;
}
-xp_size_t xp_awk_tab_add (
- xp_awk_tab_t* tab, const xp_char_t* str, xp_size_t len)
+sse_size_t sse_awk_tab_add (
+ sse_awk_tab_t* tab, const sse_char_t* str, sse_size_t len)
{
- return xp_awk_tab_insert (tab, tab->size, str, len);
+ return sse_awk_tab_insert (tab, tab->size, str, len);
}
-xp_size_t xp_awk_tab_find (
- xp_awk_tab_t* tab, xp_size_t index,
- const xp_char_t* str, xp_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)
{
- xp_size_t i;
+ sse_size_t i;
for (i = index; i < tab->size; i++)
{
- if (xp_awk_strxncmp (
+ if (sse_awk_strxncmp (
tab->buf[i].name, tab->buf[i].name_len,
str, len) == 0) return i;
}
- return (xp_size_t)-1;
+ return (sse_size_t)-1;
}
-xp_size_t xp_awk_tab_rfind (
- xp_awk_tab_t* tab, xp_size_t index,
- const xp_char_t* str, xp_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)
{
- xp_size_t i;
+ sse_size_t i;
- if (index >= tab->size) return (xp_size_t)-1;
+ if (index >= tab->size) return (sse_size_t)-1;
for (i = index + 1; i-- > 0; )
{
- if (xp_awk_strxncmp (
+ if (sse_awk_strxncmp (
tab->buf[i].name, tab->buf[i].name_len,
str, len) == 0) return i;
}
- return (xp_size_t)-1;
+ return (sse_size_t)-1;
}
-xp_size_t xp_awk_tab_rrfind (
- xp_awk_tab_t* tab, xp_size_t index,
- const xp_char_t* str, xp_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)
{
- xp_size_t i;
+ sse_size_t i;
- if (index >= tab->size) return (xp_size_t)-1;
+ if (index >= tab->size) return (sse_size_t)-1;
for (i = tab->size - index; i-- > 0; )
{
- if (xp_awk_strxncmp (
+ if (sse_awk_strxncmp (
tab->buf[i].name, tab->buf[i].name_len,
str, len) == 0) return i;
}
- return (xp_size_t)-1;
+ return (sse_size_t)-1;
}
diff --git a/ase/awk/tab.h b/ase/awk/tab.h
index 2faeee12..0e4dab01 100644
--- a/ase/awk/tab.h
+++ b/ase/awk/tab.h
@@ -1,64 +1,64 @@
/*
- * $Id: tab.h,v 1.12 2006-08-31 15:09:24 bacon Exp $
+ * $Id: tab.h,v 1.13 2006-10-22 11:34:53 bacon Exp $
*/
-#ifndef _XP_AWK_TAB_H_
-#define _XP_AWK_TAB_H_
+#ifndef _SSE_AWK_TAB_H_
+#define _SSE_AWK_TAB_H_
-#ifndef _XP_AWK_AWK_H_
-#error Never include this file directly. Include <xp/awk/awk.h> instead
+#ifndef _SSE_AWK_AWK_H_
+#error Never include this file directly. Include <sse/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 xp_awk_tab_t xp_awk_tab_t;
+typedef struct sse_awk_tab_t sse_awk_tab_t;
-struct xp_awk_tab_t
+struct sse_awk_tab_t
{
struct
{
- xp_char_t* name;
- xp_size_t name_len;
+ sse_char_t* name;
+ sse_size_t name_len;
}* buf;
- xp_size_t size;
- xp_size_t capa;
- xp_awk_t* awk;
- xp_bool_t __dynamic;
+ sse_size_t size;
+ sse_size_t capa;
+ sse_awk_t* awk;
+ sse_bool_t __dynamic;
};
#ifdef __cplusplus
extern "C" {
#endif
-xp_awk_tab_t* xp_awk_tab_open (xp_awk_tab_t* tab, xp_awk_t* awk);
-void xp_awk_tab_close (xp_awk_tab_t* tab);
+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);
-xp_size_t xp_awk_tab_getsize (xp_awk_tab_t* tab);
-xp_size_t xp_awk_tab_getcapa (xp_awk_tab_t* tab);
-xp_awk_tab_t* xp_awk_tab_setcapa (xp_awk_tab_t* tab, xp_size_t capa);
+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);
-void xp_awk_tab_clear (xp_awk_tab_t* tab);
+void sse_awk_tab_clear (sse_awk_tab_t* tab);
-xp_size_t xp_awk_tab_insert (
- xp_awk_tab_t* tab, xp_size_t index,
- const xp_char_t* str, xp_size_t len);
+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);
-xp_size_t xp_awk_tab_remove (
- xp_awk_tab_t* tab, xp_size_t index, xp_size_t count);
+sse_size_t sse_awk_tab_remove (
+ sse_awk_tab_t* tab, sse_size_t index, sse_size_t count);
-xp_size_t xp_awk_tab_add (
- xp_awk_tab_t* tab, const xp_char_t* str, xp_size_t len);
+sse_size_t sse_awk_tab_add (
+ sse_awk_tab_t* tab, const sse_char_t* str, sse_size_t len);
-xp_size_t xp_awk_tab_find (
- xp_awk_tab_t* tab, xp_size_t index,
- const xp_char_t* str, xp_size_t len);
-xp_size_t xp_awk_tab_rfind (
- xp_awk_tab_t* tab, xp_size_t index,
- const xp_char_t* str, xp_size_t len);
-xp_size_t xp_awk_tab_rrfind (
- xp_awk_tab_t* tab, xp_size_t index,
- const xp_char_t* str, xp_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);
#ifdef __cplusplus
}
diff --git a/ase/awk/tree.c b/ase/awk/tree.c
index 4db3c051..9016bb7b 100644
--- a/ase/awk/tree.c
+++ b/ase/awk/tree.c
@@ -1,260 +1,260 @@
/*
- * $Id: tree.c,v 1.80 2006-10-12 14:36:25 bacon Exp $
+ * $Id: tree.c,v 1.81 2006-10-22 11:34:53 bacon Exp $
*/
-#include <xp/awk/awk_i.h>
+#include <sse/awk/awk_i.h>
-static const xp_char_t* __assop_str[] =
+static const sse_char_t* __assop_str[] =
{
- XP_T("="),
- XP_T("+="),
- XP_T("-="),
- XP_T("*="),
- XP_T("/="),
- XP_T("%="),
- XP_T("**=")
+ SSE_T("="),
+ SSE_T("+="),
+ SSE_T("-="),
+ SSE_T("*="),
+ SSE_T("/="),
+ SSE_T("%="),
+ SSE_T("**=")
};
-static const xp_char_t* __binop_str[] =
+static const sse_char_t* __binop_str[] =
{
- XP_T("||"),
- XP_T("&&"),
- XP_T("in"),
+ SSE_T("||"),
+ SSE_T("&&"),
+ SSE_T("in"),
- XP_T("|"),
- XP_T("^"),
- XP_T("&"),
+ SSE_T("|"),
+ SSE_T("^"),
+ SSE_T("&"),
- XP_T("=="),
- XP_T("!="),
- XP_T(">"),
- XP_T(">="),
- XP_T("<"),
- XP_T("<="),
+ SSE_T("=="),
+ SSE_T("!="),
+ SSE_T(">"),
+ SSE_T(">="),
+ SSE_T("<"),
+ SSE_T("<="),
- XP_T("<<"),
- XP_T(">>"),
+ SSE_T("<<"),
+ SSE_T(">>"),
- XP_T("+"),
- XP_T("-"),
- XP_T("*"),
- XP_T("/"),
- XP_T("%"),
- XP_T("**"),
+ SSE_T("+"),
+ SSE_T("-"),
+ SSE_T("*"),
+ SSE_T("/"),
+ SSE_T("%"),
+ SSE_T("**"),
- XP_T(" "),
- XP_T("~"),
- XP_T("!~")
+ SSE_T(" "),
+ SSE_T("~"),
+ SSE_T("!~")
};
-static const xp_char_t* __unrop_str[] =
+static const sse_char_t* __unrop_str[] =
{
- XP_T("+"),
- XP_T("-"),
- XP_T("!"),
- XP_T("~")
+ SSE_T("+"),
+ SSE_T("-"),
+ SSE_T("!"),
+ SSE_T("~")
};
-static const xp_char_t* __incop_str[] =
+static const sse_char_t* __incop_str[] =
{
- XP_T("++"),
- XP_T("--"),
- XP_T("++"),
- XP_T("--")
+ SSE_T("++"),
+ SSE_T("--"),
+ SSE_T("++"),
+ SSE_T("--")
};
-static const xp_char_t* __getline_inop_str[] =
+static const sse_char_t* __getline_inop_str[] =
{
- XP_T("|"),
- XP_T("|&"),
- XP_T("<"),
- XP_T("")
+ SSE_T("|"),
+ SSE_T("|&"),
+ SSE_T("<"),
+ SSE_T("")
};
-static const xp_char_t* __print_outop_str[] =
+static const sse_char_t* __print_outop_str[] =
{
- XP_T("|"),
- XP_T("|&"),
- XP_T(">"),
- XP_T(">>"),
- XP_T("")
+ SSE_T("|"),
+ SSE_T("|&"),
+ SSE_T(">"),
+ SSE_T(">>"),
+ SSE_T("")
};
#define PUT_SRCSTR(awk,str) \
- do { if (xp_awk_putsrcstr (awk, str) == -1) return -1; } while (0)
+ do { if (sse_awk_putsrcstr (awk, str) == -1) return -1; } while (0)
#define PUT_SRCSTRX(awk,str,len) \
- do { if (xp_awk_putsrcstrx (awk, str, len) == -1) return -1; } while (0)
+ do { if (sse_awk_putsrcstrx (awk, str, len) == -1) return -1; } while (0)
#define PRINT_TABS(awk,depth) \
do { if (__print_tabs(awk,depth) == -1) return -1; } while (0)
-#define PRINT_EXPRESSION(awk,nde) \
- do { if (__print_expression(awk,nde) == -1) return -1; } while (0)
+#define PRINT_ESSERESSION(awk,nde) \
+ do { if (__print_esseression(awk,nde) == -1) return -1; } while (0)
-#define PRINT_EXPRESSION_LIST(awk,nde) \
- do { if (__print_expression_list(awk,nde) == -1) return -1; } while (0)
+#define PRINT_ESSERESSION_LIST(awk,nde) \
+ do { if (__print_esseression_list(awk,nde) == -1) return -1; } while (0)
#define PRINT_STATEMENTS(awk,nde,depth) \
do { if (__print_statements(awk,nde,depth) == -1) return -1; } while (0)
-static int __print_tabs (xp_awk_t* awk, int depth);
-static int __print_expression (xp_awk_t* awk, xp_awk_nde_t* nde);
-static int __print_expression_list (xp_awk_t* awk, xp_awk_nde_t* tree);
-static int __print_statements (xp_awk_t* awk, xp_awk_nde_t* tree, int depth);
+static int __print_tabs (sse_awk_t* awk, int depth);
+static int __print_esseression (sse_awk_t* awk, sse_awk_nde_t* nde);
+static int __print_esseression_list (sse_awk_t* awk, sse_awk_nde_t* tree);
+static int __print_statements (sse_awk_t* awk, sse_awk_nde_t* tree, int depth);
-static int __print_tabs (xp_awk_t* awk, int depth)
+static int __print_tabs (sse_awk_t* awk, int depth)
{
while (depth > 0)
{
- PUT_SRCSTR (awk, XP_T("\t"));
+ PUT_SRCSTR (awk, SSE_T("\t"));
depth--;
}
return 0;
}
-static int __print_expression (xp_awk_t* awk, xp_awk_nde_t* nde)
+static int __print_esseression (sse_awk_t* awk, sse_awk_nde_t* nde)
{
switch (nde->type)
{
- case XP_AWK_NDE_GRP:
+ case SSE_AWK_NDE_GRP:
{
- xp_awk_nde_t* p = ((xp_awk_nde_grp_t*)nde)->body;
+ sse_awk_nde_t* p = ((sse_awk_nde_grp_t*)nde)->body;
- PUT_SRCSTR (awk, XP_T("("));
- while (p != XP_NULL)
+ PUT_SRCSTR (awk, SSE_T("("));
+ while (p != SSE_NULL)
{
- PRINT_EXPRESSION (awk, p);
- if (p->next != XP_NULL)
- PUT_SRCSTR (awk, XP_T(","));
+ PRINT_ESSERESSION (awk, p);
+ if (p->next != SSE_NULL)
+ PUT_SRCSTR (awk, SSE_T(","));
p = p->next;
}
- PUT_SRCSTR (awk, XP_T(")"));
+ PUT_SRCSTR (awk, SSE_T(")"));
break;
}
- case XP_AWK_NDE_ASS:
+ case SSE_AWK_NDE_ASS:
{
- xp_awk_nde_ass_t* px = (xp_awk_nde_ass_t*)nde;
+ sse_awk_nde_ass_t* px = (sse_awk_nde_ass_t*)nde;
- PRINT_EXPRESSION (awk, px->left);
- PUT_SRCSTR (awk, XP_T(" "));
+ PRINT_ESSERESSION (awk, px->left);
+ PUT_SRCSTR (awk, SSE_T(" "));
PUT_SRCSTR (awk, __assop_str[px->opcode]);
- PUT_SRCSTR (awk, XP_T(" "));
- PRINT_EXPRESSION (awk, px->right);
+ PUT_SRCSTR (awk, SSE_T(" "));
+ PRINT_ESSERESSION (awk, px->right);
- xp_awk_assert (awk, px->right->next == XP_NULL);
+ sse_awk_assert (awk, px->right->next == SSE_NULL);
break;
}
- case XP_AWK_NDE_EXP_BIN:
+ case SSE_AWK_NDE_ESSE_BIN:
{
- xp_awk_nde_exp_t* px = (xp_awk_nde_exp_t*)nde;
+ sse_awk_nde_esse_t* px = (sse_awk_nde_esse_t*)nde;
- PUT_SRCSTR (awk, XP_T("("));
- PRINT_EXPRESSION (awk, px->left);
- xp_awk_assert (awk, px->left->next == XP_NULL);
+ PUT_SRCSTR (awk, SSE_T("("));
+ PRINT_ESSERESSION (awk, px->left);
+ sse_awk_assert (awk, px->left->next == SSE_NULL);
- PUT_SRCSTR (awk, XP_T(" "));
+ PUT_SRCSTR (awk, SSE_T(" "));
PUT_SRCSTR (awk, __binop_str[px->opcode]);
- PUT_SRCSTR (awk, XP_T(" "));
+ PUT_SRCSTR (awk, SSE_T(" "));
- if (px->right->type == XP_AWK_NDE_ASS)
- PUT_SRCSTR (awk, XP_T("("));
- PRINT_EXPRESSION (awk, px->right);
- if (px->right->type == XP_AWK_NDE_ASS)
- PUT_SRCSTR (awk, XP_T(")"));
- xp_awk_assert (awk, px->right->next == XP_NULL);
- PUT_SRCSTR (awk, XP_T(")"));
+ if (px->right->type == SSE_AWK_NDE_ASS)
+ PUT_SRCSTR (awk, SSE_T("("));
+ PRINT_ESSERESSION (awk, px->right);
+ if (px->right->type == SSE_AWK_NDE_ASS)
+ PUT_SRCSTR (awk, SSE_T(")"));
+ sse_awk_assert (awk, px->right->next == SSE_NULL);
+ PUT_SRCSTR (awk, SSE_T(")"));
break;
}
- case XP_AWK_NDE_EXP_UNR:
+ case SSE_AWK_NDE_ESSE_UNR:
{
- xp_awk_nde_exp_t* px = (xp_awk_nde_exp_t*)nde;
- xp_awk_assert (awk, px->right == XP_NULL);
+ sse_awk_nde_esse_t* px = (sse_awk_nde_esse_t*)nde;
+ sse_awk_assert (awk, px->right == SSE_NULL);
PUT_SRCSTR (awk, __unrop_str[px->opcode]);
- PUT_SRCSTR (awk, XP_T("("));
- PRINT_EXPRESSION (awk, px->left);
- PUT_SRCSTR (awk, XP_T(")"));
+ PUT_SRCSTR (awk, SSE_T("("));
+ PRINT_ESSERESSION (awk, px->left);
+ PUT_SRCSTR (awk, SSE_T(")"));
break;
}
- case XP_AWK_NDE_EXP_INCPRE:
+ case SSE_AWK_NDE_ESSE_INCPRE:
{
- xp_awk_nde_exp_t* px = (xp_awk_nde_exp_t*)nde;
- xp_awk_assert (awk, px->right == XP_NULL);
+ sse_awk_nde_esse_t* px = (sse_awk_nde_esse_t*)nde;
+ sse_awk_assert (awk, px->right == SSE_NULL);
PUT_SRCSTR (awk, __incop_str[px->opcode]);
- PUT_SRCSTR (awk, XP_T("("));
- PRINT_EXPRESSION (awk, px->left);
- PUT_SRCSTR (awk, XP_T(")"));
+ PUT_SRCSTR (awk, SSE_T("("));
+ PRINT_ESSERESSION (awk, px->left);
+ PUT_SRCSTR (awk, SSE_T(")"));
break;
}
- case XP_AWK_NDE_EXP_INCPST:
+ case SSE_AWK_NDE_ESSE_INCPST:
{
- xp_awk_nde_exp_t* px = (xp_awk_nde_exp_t*)nde;
- xp_awk_assert (awk, px->right == XP_NULL);
+ sse_awk_nde_esse_t* px = (sse_awk_nde_esse_t*)nde;
+ sse_awk_assert (awk, px->right == SSE_NULL);
- PUT_SRCSTR (awk, XP_T("("));
- PRINT_EXPRESSION (awk, px->left);
- PUT_SRCSTR (awk, XP_T(")"));
+ PUT_SRCSTR (awk, SSE_T("("));
+ PRINT_ESSERESSION (awk, px->left);
+ PUT_SRCSTR (awk, SSE_T(")"));
PUT_SRCSTR (awk, __incop_str[px->opcode]);
break;
}
- case XP_AWK_NDE_CND:
+ case SSE_AWK_NDE_CND:
{
- xp_awk_nde_cnd_t* px = (xp_awk_nde_cnd_t*)nde;
+ sse_awk_nde_cnd_t* px = (sse_awk_nde_cnd_t*)nde;
- PUT_SRCSTR (awk, XP_T("("));
- PRINT_EXPRESSION (awk, px->test);
- PUT_SRCSTR (awk, XP_T(")?"));
+ PUT_SRCSTR (awk, SSE_T("("));
+ PRINT_ESSERESSION (awk, px->test);
+ PUT_SRCSTR (awk, SSE_T(")?"));
- PRINT_EXPRESSION (awk, px->left);
- PUT_SRCSTR (awk, XP_T(":"));
- PRINT_EXPRESSION (awk, px->right);
+ PRINT_ESSERESSION (awk, px->left);
+ PUT_SRCSTR (awk, SSE_T(":"));
+ PRINT_ESSERESSION (awk, px->right);
break;
}
- case XP_AWK_NDE_INT:
+ case SSE_AWK_NDE_INT:
{
- if (((xp_awk_nde_int_t*)nde)->str == XP_NULL)
+ if (((sse_awk_nde_int_t*)nde)->str == SSE_NULL)
{
- xp_char_t tmp[xp_sizeof(xp_long_t)*8+2];
- xp_size_t n;
+ sse_char_t tmp[sse_sizeof(sse_long_t)*8+2];
+ sse_size_t n;
- n = xp_awk_longtostr (
- ((xp_awk_nde_int_t*)nde)->val,
- 10, XP_NULL, tmp, xp_countof(tmp));
+ n = sse_awk_longtostr (
+ ((sse_awk_nde_int_t*)nde)->val,
+ 10, SSE_NULL, tmp, sse_countof(tmp));
PUT_SRCSTRX (awk, tmp, n);
}
else
{
PUT_SRCSTRX (awk,
- ((xp_awk_nde_int_t*)nde)->str,
- ((xp_awk_nde_int_t*)nde)->len);
+ ((sse_awk_nde_int_t*)nde)->str,
+ ((sse_awk_nde_int_t*)nde)->len);
}
break;
}
- case XP_AWK_NDE_REAL:
+ case SSE_AWK_NDE_REAL:
{
- if (((xp_awk_nde_real_t*)nde)->str == XP_NULL)
+ if (((sse_awk_nde_real_t*)nde)->str == SSE_NULL)
{
- xp_char_t tmp[128];
- #if (XP_SIZEOF_LONG_DOUBLE != 0)
+ sse_char_t tmp[128];
+ #if (SSE_SIZEOF_LONG_DOUBLE != 0)
awk->syscas.sprintf (
- tmp, xp_countof(tmp), XP_T("%Lf"),
- (long double)((xp_awk_nde_real_t*)nde)->val);
- #elif (XP_SIZEOF_DOUBLE != 0)
+ tmp, sse_countof(tmp), SSE_T("%Lf"),
+ (long double)((sse_awk_nde_real_t*)nde)->val);
+ #elif (SSE_SIZEOF_DOUBLE != 0)
awk->syscas.sprintf (
- tmp, xp_countof(tmp), XP_T("%f"),
- (double)((xp_awk_nde_real_t*)nde)->val);
+ tmp, sse_countof(tmp), SSE_T("%f"),
+ (double)((sse_awk_nde_real_t*)nde)->val);
#else
#error unsupported floating-point data type
#endif
@@ -263,245 +263,245 @@ static int __print_expression (xp_awk_t* awk, xp_awk_nde_t* nde)
else
{
PUT_SRCSTRX (awk,
- ((xp_awk_nde_real_t*)nde)->str,
- ((xp_awk_nde_real_t*)nde)->len);
+ ((sse_awk_nde_real_t*)nde)->str,
+ ((sse_awk_nde_real_t*)nde)->len);
}
break;
}
- case XP_AWK_NDE_STR:
+ case SSE_AWK_NDE_STR:
{
/* TODO: ESCAPING */
- PUT_SRCSTR (awk, XP_T("\""));
+ PUT_SRCSTR (awk, SSE_T("\""));
PUT_SRCSTRX (awk,
- ((xp_awk_nde_str_t*)nde)->buf,
- ((xp_awk_nde_str_t*)nde)->len);
- PUT_SRCSTR (awk, XP_T("\""));
+ ((sse_awk_nde_str_t*)nde)->buf,
+ ((sse_awk_nde_str_t*)nde)->len);
+ PUT_SRCSTR (awk, SSE_T("\""));
break;
}
- case XP_AWK_NDE_REX:
+ case SSE_AWK_NDE_REX:
{
/* TODO: buf, len */
- PUT_SRCSTR (awk, XP_T("/"));
+ PUT_SRCSTR (awk, SSE_T("/"));
PUT_SRCSTRX (awk,
- ((xp_awk_nde_rex_t*)nde)->buf,
- ((xp_awk_nde_rex_t*)nde)->len);
- PUT_SRCSTR (awk, XP_T("/"));
+ ((sse_awk_nde_rex_t*)nde)->buf,
+ ((sse_awk_nde_rex_t*)nde)->len);
+ PUT_SRCSTR (awk, SSE_T("/"));
break;
}
- case XP_AWK_NDE_ARG:
+ case SSE_AWK_NDE_ARG:
{
- xp_char_t tmp[xp_sizeof(xp_long_t)*8+2];
- xp_size_t n;
- xp_awk_nde_var_t* px = (xp_awk_nde_var_t*)nde;
- xp_awk_assert (awk, px->id.idxa != (xp_size_t)-1);
+ sse_char_t tmp[sse_sizeof(sse_long_t)*8+2];
+ sse_size_t n;
+ sse_awk_nde_var_t* px = (sse_awk_nde_var_t*)nde;
+ sse_awk_assert (awk, px->id.idxa != (sse_size_t)-1);
- n = xp_awk_longtostr (
- px->id.idxa, 10, XP_NULL, tmp, xp_countof(tmp));
+ n = sse_awk_longtostr (
+ px->id.idxa, 10, SSE_NULL, tmp, sse_countof(tmp));
- PUT_SRCSTR (awk, XP_T("__param"));
+ PUT_SRCSTR (awk, SSE_T("__param"));
PUT_SRCSTRX (awk, tmp, n);
- xp_awk_assert (awk, px->idx == XP_NULL);
+ sse_awk_assert (awk, px->idx == SSE_NULL);
break;
}
- case XP_AWK_NDE_ARGIDX:
+ case SSE_AWK_NDE_ARGIDX:
{
- xp_char_t tmp[xp_sizeof(xp_long_t)*8+2];
- xp_size_t n;
- xp_awk_nde_var_t* px = (xp_awk_nde_var_t*)nde;
- xp_awk_assert (awk, px->id.idxa != (xp_size_t)-1);
- xp_awk_assert (awk, px->idx != XP_NULL);
+ sse_char_t tmp[sse_sizeof(sse_long_t)*8+2];
+ sse_size_t n;
+ sse_awk_nde_var_t* px = (sse_awk_nde_var_t*)nde;
+ sse_awk_assert (awk, px->id.idxa != (sse_size_t)-1);
+ sse_awk_assert (awk, px->idx != SSE_NULL);
- PUT_SRCSTR (awk, XP_T("__param"));
- n = xp_awk_longtostr (
- px->id.idxa, 10, XP_NULL, tmp, xp_countof(tmp));
+ PUT_SRCSTR (awk, SSE_T("__param"));
+ n = sse_awk_longtostr (
+ px->id.idxa, 10, SSE_NULL, tmp, sse_countof(tmp));
PUT_SRCSTRX (awk, tmp, n);
- PUT_SRCSTR (awk, XP_T("["));
- PRINT_EXPRESSION_LIST (awk, px->idx);
- PUT_SRCSTR (awk, XP_T("]"));
+ PUT_SRCSTR (awk, SSE_T("["));
+ PRINT_ESSERESSION_LIST (awk, px->idx);
+ PUT_SRCSTR (awk, SSE_T("]"));
break;
}
- case XP_AWK_NDE_NAMED:
+ case SSE_AWK_NDE_NAMED:
{
- xp_awk_nde_var_t* px = (xp_awk_nde_var_t*)nde;
- xp_awk_assert (awk, px->id.idxa == (xp_size_t)-1);
- xp_awk_assert (awk, px->idx == XP_NULL);
+ sse_awk_nde_var_t* px = (sse_awk_nde_var_t*)nde;
+ sse_awk_assert (awk, px->id.idxa == (sse_size_t)-1);
+ sse_awk_assert (awk, px->idx == SSE_NULL);
PUT_SRCSTRX (awk, px->id.name, px->id.name_len);
break;
}
- case XP_AWK_NDE_NAMEDIDX:
+ case SSE_AWK_NDE_NAMEDIDX:
{
- xp_awk_nde_var_t* px = (xp_awk_nde_var_t*)nde;
- xp_awk_assert (awk, px->id.idxa == (xp_size_t)-1);
- xp_awk_assert (awk, px->idx != XP_NULL);
+ sse_awk_nde_var_t* px = (sse_awk_nde_var_t*)nde;
+ sse_awk_assert (awk, px->id.idxa == (sse_size_t)-1);
+ sse_awk_assert (awk, px->idx != SSE_NULL);
PUT_SRCSTRX (awk, px->id.name, px->id.name_len);
- PUT_SRCSTR (awk, XP_T("["));
- PRINT_EXPRESSION_LIST (awk, px->idx);
- PUT_SRCSTR (awk, XP_T("]"));
+ PUT_SRCSTR (awk, SSE_T("["));
+ PRINT_ESSERESSION_LIST (awk, px->idx);
+ PUT_SRCSTR (awk, SSE_T("]"));
break;
}
- case XP_AWK_NDE_GLOBAL:
+ case SSE_AWK_NDE_GLOBAL:
{
- xp_char_t tmp[xp_sizeof(xp_long_t)*8+2];
- xp_size_t n;
- xp_awk_nde_var_t* px = (xp_awk_nde_var_t*)nde;
+ sse_char_t tmp[sse_sizeof(sse_long_t)*8+2];
+ sse_size_t n;
+ sse_awk_nde_var_t* px = (sse_awk_nde_var_t*)nde;
- if (px->id.idxa != (xp_size_t)-1)
+ if (px->id.idxa != (sse_size_t)-1)
{
- PUT_SRCSTR (awk, XP_T("__global"));
- n = xp_awk_longtostr (
+ PUT_SRCSTR (awk, SSE_T("__global"));
+ n = sse_awk_longtostr (
px->id.idxa, 10,
- XP_NULL, tmp, xp_countof(tmp));
+ SSE_NULL, tmp, sse_countof(tmp));
PUT_SRCSTRX (awk, tmp, n);
}
else
{
PUT_SRCSTRX (awk, px->id.name, px->id.name_len);
}
- xp_awk_assert (awk, px->idx == XP_NULL);
+ sse_awk_assert (awk, px->idx == SSE_NULL);
break;
}
- case XP_AWK_NDE_GLOBALIDX:
+ case SSE_AWK_NDE_GLOBALIDX:
{
- xp_char_t tmp[xp_sizeof(xp_long_t)*8+2];
- xp_size_t n;
- xp_awk_nde_var_t* px = (xp_awk_nde_var_t*)nde;
+ sse_char_t tmp[sse_sizeof(sse_long_t)*8+2];
+ sse_size_t n;
+ sse_awk_nde_var_t* px = (sse_awk_nde_var_t*)nde;
- if (px->id.idxa != (xp_size_t)-1)
+ if (px->id.idxa != (sse_size_t)-1)
{
- PUT_SRCSTR (awk, XP_T("__global"));
- n = xp_awk_longtostr (
+ PUT_SRCSTR (awk, SSE_T("__global"));
+ n = sse_awk_longtostr (
px->id.idxa, 10,
- XP_NULL, tmp, xp_countof(tmp));
+ SSE_NULL, tmp, sse_countof(tmp));
PUT_SRCSTRX (awk, tmp, n);
- PUT_SRCSTR (awk, XP_T("["));
+ PUT_SRCSTR (awk, SSE_T("["));
}
else
{
PUT_SRCSTRX (awk, px->id.name, px->id.name_len);
- PUT_SRCSTR (awk, XP_T("["));
+ PUT_SRCSTR (awk, SSE_T("["));
}
- xp_awk_assert (awk, px->idx != XP_NULL);
- PRINT_EXPRESSION_LIST (awk, px->idx);
- PUT_SRCSTR (awk, XP_T("]"));
+ sse_awk_assert (awk, px->idx != SSE_NULL);
+ PRINT_ESSERESSION_LIST (awk, px->idx);
+ PUT_SRCSTR (awk, SSE_T("]"));
break;
}
- case XP_AWK_NDE_LOCAL:
+ case SSE_AWK_NDE_LOCAL:
{
- xp_char_t tmp[xp_sizeof(xp_long_t)*8+2];
- xp_size_t n;
- xp_awk_nde_var_t* px = (xp_awk_nde_var_t*)nde;
+ sse_char_t tmp[sse_sizeof(sse_long_t)*8+2];
+ sse_size_t n;
+ sse_awk_nde_var_t* px = (sse_awk_nde_var_t*)nde;
- if (px->id.idxa != (xp_size_t)-1)
+ if (px->id.idxa != (sse_size_t)-1)
{
- PUT_SRCSTR (awk, XP_T("__local"));
- n = xp_awk_longtostr (
+ PUT_SRCSTR (awk, SSE_T("__local"));
+ n = sse_awk_longtostr (
px->id.idxa, 10,
- XP_NULL, tmp, xp_countof(tmp));
+ SSE_NULL, tmp, sse_countof(tmp));
PUT_SRCSTRX (awk, tmp, n);
}
else
{
PUT_SRCSTRX (awk, px->id.name, px->id.name_len);
}
- xp_awk_assert (awk, px->idx == XP_NULL);
+ sse_awk_assert (awk, px->idx == SSE_NULL);
break;
}
- case XP_AWK_NDE_LOCALIDX:
+ case SSE_AWK_NDE_LOCALIDX:
{
- xp_char_t tmp[xp_sizeof(xp_long_t)*8+2];
- xp_size_t n;
- xp_awk_nde_var_t* px = (xp_awk_nde_var_t*)nde;
+ sse_char_t tmp[sse_sizeof(sse_long_t)*8+2];
+ sse_size_t n;
+ sse_awk_nde_var_t* px = (sse_awk_nde_var_t*)nde;
- if (px->id.idxa != (xp_size_t)-1)
+ if (px->id.idxa != (sse_size_t)-1)
{
- PUT_SRCSTR (awk, XP_T("__local"));
- n = xp_awk_longtostr (
+ PUT_SRCSTR (awk, SSE_T("__local"));
+ n = sse_awk_longtostr (
px->id.idxa, 10,
- XP_NULL, tmp, xp_countof(tmp));
+ SSE_NULL, tmp, sse_countof(tmp));
PUT_SRCSTRX (awk, tmp, n);
- PUT_SRCSTR (awk, XP_T("["));
+ PUT_SRCSTR (awk, SSE_T("["));
}
else
{
PUT_SRCSTRX (awk, px->id.name, px->id.name_len);
- PUT_SRCSTR (awk, XP_T("["));
+ PUT_SRCSTR (awk, SSE_T("["));
}
- xp_awk_assert (awk, px->idx != XP_NULL);
- PRINT_EXPRESSION_LIST (awk, px->idx);
- PUT_SRCSTR (awk, XP_T("]"));
+ sse_awk_assert (awk, px->idx != SSE_NULL);
+ PRINT_ESSERESSION_LIST (awk, px->idx);
+ PUT_SRCSTR (awk, SSE_T("]"));
break;
}
- case XP_AWK_NDE_POS:
+ case SSE_AWK_NDE_POS:
{
- PUT_SRCSTR (awk, XP_T("$"));
- PRINT_EXPRESSION (awk, ((xp_awk_nde_pos_t*)nde)->val);
+ PUT_SRCSTR (awk, SSE_T("$"));
+ PRINT_ESSERESSION (awk, ((sse_awk_nde_pos_t*)nde)->val);
break;
}
- case XP_AWK_NDE_BFN:
+ case SSE_AWK_NDE_BFN:
{
- xp_awk_nde_call_t* px = (xp_awk_nde_call_t*)nde;
+ sse_awk_nde_call_t* px = (sse_awk_nde_call_t*)nde;
PUT_SRCSTRX (awk,
px->what.bfn.name, px->what.bfn.name_len);
- PUT_SRCSTR (awk, XP_T(" ("));
- PRINT_EXPRESSION_LIST (awk, px->args);
- PUT_SRCSTR (awk, XP_T(")"));
+ PUT_SRCSTR (awk, SSE_T(" ("));
+ PRINT_ESSERESSION_LIST (awk, px->args);
+ PUT_SRCSTR (awk, SSE_T(")"));
break;
}
- case XP_AWK_NDE_AFN:
+ case SSE_AWK_NDE_AFN:
{
/* TODO: use px->what.afn.name_len */
- xp_awk_nde_call_t* px = (xp_awk_nde_call_t*)nde;
+ sse_awk_nde_call_t* px = (sse_awk_nde_call_t*)nde;
PUT_SRCSTRX (awk,
px->what.afn.name, px->what.afn.name_len);
- PUT_SRCSTR (awk, XP_T(" ("));
- PRINT_EXPRESSION_LIST (awk, px->args);
- PUT_SRCSTR (awk, XP_T(")"));
+ PUT_SRCSTR (awk, SSE_T(" ("));
+ PRINT_ESSERESSION_LIST (awk, px->args);
+ PUT_SRCSTR (awk, SSE_T(")"));
break;
}
- case XP_AWK_NDE_GETLINE:
+ case SSE_AWK_NDE_GETLINE:
{
- xp_awk_nde_getline_t* px = (xp_awk_nde_getline_t*)nde;
- if (px->in != XP_NULL &&
- (px->in_type == XP_AWK_IN_PIPE ||
- px->in_type == XP_AWK_IN_COPROC))
+ sse_awk_nde_getline_t* px = (sse_awk_nde_getline_t*)nde;
+ if (px->in != SSE_NULL &&
+ (px->in_type == SSE_AWK_IN_PIPE ||
+ px->in_type == SSE_AWK_IN_COPROC))
{
- PRINT_EXPRESSION (awk, px->in);
- PUT_SRCSTR (awk, XP_T(" "));
+ PRINT_ESSERESSION (awk, px->in);
+ PUT_SRCSTR (awk, SSE_T(" "));
PUT_SRCSTR (awk, __getline_inop_str[px->in_type]);
- PUT_SRCSTR (awk, XP_T(" "));
+ PUT_SRCSTR (awk, SSE_T(" "));
}
- PUT_SRCSTR (awk, XP_T("getline"));
- if (px->var != XP_NULL)
+ PUT_SRCSTR (awk, SSE_T("getline"));
+ if (px->var != SSE_NULL)
{
- PUT_SRCSTR (awk, XP_T(" "));
- PRINT_EXPRESSION (awk, px->var);
+ PUT_SRCSTR (awk, SSE_T(" "));
+ PRINT_ESSERESSION (awk, px->var);
}
- if (px->in != XP_NULL &&
- px->in_type == XP_AWK_IN_FILE)
+ if (px->in != SSE_NULL &&
+ px->in_type == SSE_AWK_IN_FILE)
{
- PUT_SRCSTR (awk, XP_T(" "));
+ PUT_SRCSTR (awk, SSE_T(" "));
PUT_SRCSTR (awk, __getline_inop_str[px->in_type]);
- PUT_SRCSTR (awk, XP_T(" "));
- PRINT_EXPRESSION (awk, px->in);
+ PUT_SRCSTR (awk, SSE_T(" "));
+ PRINT_ESSERESSION (awk, px->in);
}
break;
}
@@ -515,93 +515,93 @@ static int __print_expression (xp_awk_t* awk, xp_awk_nde_t* nde)
return 0;
}
-static int __print_expression_list (xp_awk_t* awk, xp_awk_nde_t* tree)
+static int __print_esseression_list (sse_awk_t* awk, sse_awk_nde_t* tree)
{
- xp_awk_nde_t* p = tree;
+ sse_awk_nde_t* p = tree;
- while (p != XP_NULL)
+ while (p != SSE_NULL)
{
- PRINT_EXPRESSION (awk, p);
+ PRINT_ESSERESSION (awk, p);
p = p->next;
- if (p != XP_NULL) PUT_SRCSTR (awk, XP_T(","));
+ if (p != SSE_NULL) PUT_SRCSTR (awk, SSE_T(","));
}
return 0;
}
-static int __print_statements (xp_awk_t* awk, xp_awk_nde_t* tree, int depth)
+static int __print_statements (sse_awk_t* awk, sse_awk_nde_t* tree, int depth)
{
- xp_awk_nde_t* p = tree;
- xp_size_t i;
+ sse_awk_nde_t* p = tree;
+ sse_size_t i;
- while (p != XP_NULL)
+ while (p != SSE_NULL)
{
switch (p->type)
{
- case XP_AWK_NDE_NULL:
+ case SSE_AWK_NDE_NULL:
{
PRINT_TABS (awk, depth);
- PUT_SRCSTR (awk, XP_T(";\n"));
+ PUT_SRCSTR (awk, SSE_T(";\n"));
break;
}
- case XP_AWK_NDE_BLK:
+ case SSE_AWK_NDE_BLK:
{
- xp_char_t tmp[xp_sizeof(xp_long_t)*8+2];
- xp_size_t n;
- xp_awk_nde_blk_t* px = (xp_awk_nde_blk_t*)p;
+ sse_char_t tmp[sse_sizeof(sse_long_t)*8+2];
+ sse_size_t n;
+ sse_awk_nde_blk_t* px = (sse_awk_nde_blk_t*)p;
PRINT_TABS (awk, depth);
- PUT_SRCSTR (awk, XP_T("{\n"));
+ PUT_SRCSTR (awk, SSE_T("{\n"));
if (px->nlocals > 0)
{
PRINT_TABS (awk, depth + 1);
- PUT_SRCSTR (awk, XP_T("local "));
+ PUT_SRCSTR (awk, SSE_T("local "));
for (i = 0; i < px->nlocals - 1; i++)
{
- PUT_SRCSTR (awk, XP_T("__local"));
- n = xp_awk_longtostr (
- i, 10, XP_NULL, tmp, xp_countof(tmp));
+ PUT_SRCSTR (awk, SSE_T("__local"));
+ n = sse_awk_longtostr (
+ i, 10, SSE_NULL, tmp, sse_countof(tmp));
PUT_SRCSTRX (awk, tmp, n);
- PUT_SRCSTR (awk, XP_T(", "));
+ PUT_SRCSTR (awk, SSE_T(", "));
}
- PUT_SRCSTR (awk, XP_T("__local"));
- n = xp_awk_longtostr (
- i, 10, XP_NULL, tmp, xp_countof(tmp));
+ PUT_SRCSTR (awk, SSE_T("__local"));
+ n = sse_awk_longtostr (
+ i, 10, SSE_NULL, tmp, sse_countof(tmp));
PUT_SRCSTRX (awk, tmp, n);
- PUT_SRCSTR (awk, XP_T(";\n"));
+ PUT_SRCSTR (awk, SSE_T(";\n"));
}
PRINT_STATEMENTS (awk, px->body, depth + 1);
PRINT_TABS (awk, depth);
- PUT_SRCSTR (awk, XP_T("}\n"));
+ PUT_SRCSTR (awk, SSE_T("}\n"));
break;
}
- case XP_AWK_NDE_IF:
+ case SSE_AWK_NDE_IF:
{
- xp_awk_nde_if_t* px = (xp_awk_nde_if_t*)p;
+ sse_awk_nde_if_t* px = (sse_awk_nde_if_t*)p;
PRINT_TABS (awk, depth);
- PUT_SRCSTR (awk, XP_T("if ("));
- PRINT_EXPRESSION (awk, px->test);
- PUT_SRCSTR (awk, XP_T(")\n"));
+ PUT_SRCSTR (awk, SSE_T("if ("));
+ PRINT_ESSERESSION (awk, px->test);
+ PUT_SRCSTR (awk, SSE_T(")\n"));
- xp_awk_assert (awk, px->then_part != XP_NULL);
- if (px->then_part->type == XP_AWK_NDE_BLK)
+ sse_awk_assert (awk, px->then_part != SSE_NULL);
+ if (px->then_part->type == SSE_AWK_NDE_BLK)
PRINT_STATEMENTS (awk, px->then_part, depth);
else
PRINT_STATEMENTS (awk, px->then_part, depth + 1);
- if (px->else_part != XP_NULL)
+ if (px->else_part != SSE_NULL)
{
PRINT_TABS (awk, depth);
- PUT_SRCSTR (awk, XP_T("else\n"));
- if (px->else_part->type == XP_AWK_NDE_BLK)
+ PUT_SRCSTR (awk, SSE_T("else\n"));
+ if (px->else_part->type == SSE_AWK_NDE_BLK)
PRINT_STATEMENTS (awk, px->else_part, depth);
else
PRINT_STATEMENTS (awk, px->else_part, depth + 1);
@@ -609,15 +609,15 @@ static int __print_statements (xp_awk_t* awk, xp_awk_nde_t* tree, int depth)
break;
}
- case XP_AWK_NDE_WHILE:
+ case SSE_AWK_NDE_WHILE:
{
- xp_awk_nde_while_t* px = (xp_awk_nde_while_t*)p;
+ sse_awk_nde_while_t* px = (sse_awk_nde_while_t*)p;
PRINT_TABS (awk, depth);
- PUT_SRCSTR (awk, XP_T("while ("));
- PRINT_EXPRESSION (awk, px->test);
- PUT_SRCSTR (awk, XP_T(")\n"));
- if (px->body->type == XP_AWK_NDE_BLK)
+ PUT_SRCSTR (awk, SSE_T("while ("));
+ PRINT_ESSERESSION (awk, px->test);
+ PUT_SRCSTR (awk, SSE_T(")\n"));
+ if (px->body->type == SSE_AWK_NDE_BLK)
{
PRINT_STATEMENTS (awk, px->body, depth);
}
@@ -628,13 +628,13 @@ static int __print_statements (xp_awk_t* awk, xp_awk_nde_t* tree, int depth)
break;
}
- case XP_AWK_NDE_DOWHILE:
+ case SSE_AWK_NDE_DOWHILE:
{
- xp_awk_nde_while_t* px = (xp_awk_nde_while_t*)p;
+ sse_awk_nde_while_t* px = (sse_awk_nde_while_t*)p;
PRINT_TABS (awk, depth);
- PUT_SRCSTR (awk, XP_T("do\n"));
- if (px->body->type == XP_AWK_NDE_BLK)
+ PUT_SRCSTR (awk, SSE_T("do\n"));
+ if (px->body->type == SSE_AWK_NDE_BLK)
{
PRINT_STATEMENTS (awk, px->body, depth);
}
@@ -644,35 +644,35 @@ static int __print_statements (xp_awk_t* awk, xp_awk_nde_t* tree, int depth)
}
PRINT_TABS (awk, depth);
- PUT_SRCSTR (awk, XP_T("while ("));
- PRINT_EXPRESSION (awk, px->test);
- PUT_SRCSTR (awk, XP_T(");\n"));
+ PUT_SRCSTR (awk, SSE_T("while ("));
+ PRINT_ESSERESSION (awk, px->test);
+ PUT_SRCSTR (awk, SSE_T(");\n"));
break;
}
- case XP_AWK_NDE_FOR:
+ case SSE_AWK_NDE_FOR:
{
- xp_awk_nde_for_t* px = (xp_awk_nde_for_t*)p;
+ sse_awk_nde_for_t* px = (sse_awk_nde_for_t*)p;
PRINT_TABS (awk, depth);
- PUT_SRCSTR (awk, XP_T("for ("));
- if (px->init != XP_NULL)
+ PUT_SRCSTR (awk, SSE_T("for ("));
+ if (px->init != SSE_NULL)
{
- PRINT_EXPRESSION (awk, px->init);
+ PRINT_ESSERESSION (awk, px->init);
}
- PUT_SRCSTR (awk, XP_T("; "));
- if (px->test != XP_NULL)
+ PUT_SRCSTR (awk, SSE_T("; "));
+ if (px->test != SSE_NULL)
{
- PRINT_EXPRESSION (awk, px->test);
+ PRINT_ESSERESSION (awk, px->test);
}
- PUT_SRCSTR (awk, XP_T("; "));
- if (px->incr != XP_NULL)
+ PUT_SRCSTR (awk, SSE_T("; "));
+ if (px->incr != SSE_NULL)
{
- PRINT_EXPRESSION (awk, px->incr);
+ PRINT_ESSERESSION (awk, px->incr);
}
- PUT_SRCSTR (awk, XP_T(")\n"));
+ PUT_SRCSTR (awk, SSE_T(")\n"));
- if (px->body->type == XP_AWK_NDE_BLK)
+ if (px->body->type == SSE_AWK_NDE_BLK)
{
PRINT_STATEMENTS (awk, px->body, depth);
}
@@ -683,15 +683,15 @@ static int __print_statements (xp_awk_t* awk, xp_awk_nde_t* tree, int depth)
break;
}
- case XP_AWK_NDE_FOREACH:
+ case SSE_AWK_NDE_FOREACH:
{
- xp_awk_nde_foreach_t* px = (xp_awk_nde_foreach_t*)p;
+ sse_awk_nde_foreach_t* px = (sse_awk_nde_foreach_t*)p;
PRINT_TABS (awk, depth);
- PUT_SRCSTR (awk, XP_T("for "));
- PRINT_EXPRESSION (awk, px->test);
- PUT_SRCSTR (awk, XP_T("\n"));
- if (px->body->type == XP_AWK_NDE_BLK)
+ PUT_SRCSTR (awk, SSE_T("for "));
+ PRINT_ESSERESSION (awk, px->test);
+ PUT_SRCSTR (awk, SSE_T("\n"));
+ if (px->body->type == SSE_AWK_NDE_BLK)
{
PRINT_STATEMENTS (awk, px->body, depth);
}
@@ -702,110 +702,110 @@ static int __print_statements (xp_awk_t* awk, xp_awk_nde_t* tree, int depth)
break;
}
- case XP_AWK_NDE_BREAK:
+ case SSE_AWK_NDE_BREAK:
{
PRINT_TABS (awk, depth);
- PUT_SRCSTR (awk, XP_T("break;\n"));
+ PUT_SRCSTR (awk, SSE_T("break;\n"));
break;
}
- case XP_AWK_NDE_CONTINUE:
+ case SSE_AWK_NDE_CONTINUE:
{
PRINT_TABS (awk, depth);
- PUT_SRCSTR (awk, XP_T("continue;\n"));
+ PUT_SRCSTR (awk, SSE_T("continue;\n"));
break;
}
- case XP_AWK_NDE_RETURN:
+ case SSE_AWK_NDE_RETURN:
{
PRINT_TABS (awk, depth);
- if (((xp_awk_nde_return_t*)p)->val == XP_NULL)
+ if (((sse_awk_nde_return_t*)p)->val == SSE_NULL)
{
- PUT_SRCSTR (awk, XP_T("return;\n"));
+ PUT_SRCSTR (awk, SSE_T("return;\n"));
}
else
{
- PUT_SRCSTR (awk, XP_T("return "));
- xp_awk_assert (awk, ((xp_awk_nde_return_t*)p)->val->next == XP_NULL);
+ PUT_SRCSTR (awk, SSE_T("return "));
+ sse_awk_assert (awk, ((sse_awk_nde_return_t*)p)->val->next == SSE_NULL);
- PRINT_EXPRESSION (awk, ((xp_awk_nde_return_t*)p)->val);
- PUT_SRCSTR (awk, XP_T(";\n"));
+ PRINT_ESSERESSION (awk, ((sse_awk_nde_return_t*)p)->val);
+ PUT_SRCSTR (awk, SSE_T(";\n"));
}
break;
}
- case XP_AWK_NDE_EXIT:
+ case SSE_AWK_NDE_EXIT:
{
- xp_awk_nde_exit_t* px = (xp_awk_nde_exit_t*)p;
+ sse_awk_nde_exit_t* px = (sse_awk_nde_exit_t*)p;
PRINT_TABS (awk, depth);
- if (px->val == XP_NULL)
+ if (px->val == SSE_NULL)
{
- PUT_SRCSTR (awk, XP_T("exit;\n"));
+ PUT_SRCSTR (awk, SSE_T("exit;\n"));
}
else
{
- PUT_SRCSTR (awk, XP_T("exit "));
- xp_awk_assert (awk, px->val->next == XP_NULL);
- PRINT_EXPRESSION (awk, px->val);
- PUT_SRCSTR (awk, XP_T(";\n"));
+ PUT_SRCSTR (awk, SSE_T("exit "));
+ sse_awk_assert (awk, px->val->next == SSE_NULL);
+ PRINT_ESSERESSION (awk, px->val);
+ PUT_SRCSTR (awk, SSE_T(";\n"));
}
break;
}
- case XP_AWK_NDE_NEXT:
+ case SSE_AWK_NDE_NEXT:
{
PRINT_TABS (awk, depth);
- PUT_SRCSTR (awk, XP_T("next;\n"));
+ PUT_SRCSTR (awk, SSE_T("next;\n"));
break;
}
- case XP_AWK_NDE_NEXTFILE:
+ case SSE_AWK_NDE_NEXTFILE:
{
PRINT_TABS (awk, depth);
- PUT_SRCSTR (awk, XP_T("nextfile;\n"));
+ PUT_SRCSTR (awk, SSE_T("nextfile;\n"));
break;
}
- case XP_AWK_NDE_DELETE:
+ case SSE_AWK_NDE_DELETE:
{
PRINT_TABS (awk, depth);
- PUT_SRCSTR (awk, XP_T("delete "));
- /* TODO: can't use __print_expression??? */
- xp_awk_prnpt (awk, ((xp_awk_nde_delete_t*)p)->var);
+ PUT_SRCSTR (awk, SSE_T("delete "));
+ /* TODO: can't use __print_esseression??? */
+ sse_awk_prnpt (awk, ((sse_awk_nde_delete_t*)p)->var);
break;
}
- case XP_AWK_NDE_PRINT:
+ case SSE_AWK_NDE_PRINT:
{
- xp_awk_nde_print_t* px = (xp_awk_nde_print_t*)p;
+ sse_awk_nde_print_t* px = (sse_awk_nde_print_t*)p;
PRINT_TABS (awk, depth);
- PUT_SRCSTR (awk, XP_T("print"));
- if (px->args != XP_NULL)
+ PUT_SRCSTR (awk, SSE_T("print"));
+ if (px->args != SSE_NULL)
{
- PUT_SRCSTR (awk, XP_T(" "));
- PRINT_EXPRESSION_LIST (awk, px->args);
+ PUT_SRCSTR (awk, SSE_T(" "));
+ PRINT_ESSERESSION_LIST (awk, px->args);
}
- if (px->out != XP_NULL)
+ if (px->out != SSE_NULL)
{
- PUT_SRCSTR (awk, XP_T(" "));
+ PUT_SRCSTR (awk, SSE_T(" "));
PUT_SRCSTR (awk, __print_outop_str[px->out_type]);
- PUT_SRCSTR (awk, XP_T(" "));
- PRINT_EXPRESSION (awk, px->out);
+ PUT_SRCSTR (awk, SSE_T(" "));
+ PRINT_ESSERESSION (awk, px->out);
}
- PUT_SRCSTR (awk, XP_T(";\n"));
+ PUT_SRCSTR (awk, SSE_T(";\n"));
break;
}
default:
{
PRINT_TABS (awk, depth);
- PRINT_EXPRESSION (awk, p);
- PUT_SRCSTR (awk, XP_T(";\n"));
+ PRINT_ESSERESSION (awk, p);
+ PUT_SRCSTR (awk, SSE_T(";\n"));
}
}
@@ -815,297 +815,297 @@ static int __print_statements (xp_awk_t* awk, xp_awk_nde_t* tree, int depth)
return 0;
}
-int xp_awk_prnpt (xp_awk_t* awk, xp_awk_nde_t* tree)
+int sse_awk_prnpt (sse_awk_t* awk, sse_awk_nde_t* tree)
{
return __print_statements (awk, tree, 0);
}
-int xp_awk_prnptnpt (xp_awk_t* awk, xp_awk_nde_t* tree)
+int sse_awk_prnptnpt (sse_awk_t* awk, sse_awk_nde_t* tree)
{
- xp_awk_nde_t* nde = tree;
+ sse_awk_nde_t* nde = tree;
- while (nde != XP_NULL)
+ while (nde != SSE_NULL)
{
- if (__print_expression (awk, nde) == -1) return -1;
- if (nde->next == XP_NULL) break;
+ if (__print_esseression (awk, nde) == -1) return -1;
+ if (nde->next == SSE_NULL) break;
- PUT_SRCSTR (awk, XP_T(","));
+ PUT_SRCSTR (awk, SSE_T(","));
nde = nde->next;
}
return 0;
}
-void xp_awk_clrpt (xp_awk_t* awk, xp_awk_nde_t* tree)
+void sse_awk_clrpt (sse_awk_t* awk, sse_awk_nde_t* tree)
{
- xp_awk_nde_t* p = tree;
- xp_awk_nde_t* next;
+ sse_awk_nde_t* p = tree;
+ sse_awk_nde_t* next;
- while (p != XP_NULL)
+ while (p != SSE_NULL)
{
next = p->next;
switch (p->type)
{
- case XP_AWK_NDE_NULL:
+ case SSE_AWK_NDE_NULL:
{
- XP_AWK_FREE (awk, p);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_BLK:
+ case SSE_AWK_NDE_BLK:
{
- xp_awk_clrpt (awk, ((xp_awk_nde_blk_t*)p)->body);
- XP_AWK_FREE (awk, p);
+ sse_awk_clrpt (awk, ((sse_awk_nde_blk_t*)p)->body);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_IF:
+ case SSE_AWK_NDE_IF:
{
- xp_awk_nde_if_t* px = (xp_awk_nde_if_t*)p;
- xp_awk_clrpt (awk, px->test);
- xp_awk_clrpt (awk, px->then_part);
+ sse_awk_nde_if_t* px = (sse_awk_nde_if_t*)p;
+ sse_awk_clrpt (awk, px->test);
+ sse_awk_clrpt (awk, px->then_part);
- if (px->else_part != XP_NULL)
- xp_awk_clrpt (awk, px->else_part);
- XP_AWK_FREE (awk, p);
+ if (px->else_part != SSE_NULL)
+ sse_awk_clrpt (awk, px->else_part);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_WHILE:
- case XP_AWK_NDE_DOWHILE:
+ case SSE_AWK_NDE_WHILE:
+ case SSE_AWK_NDE_DOWHILE:
{
- xp_awk_clrpt (awk, ((xp_awk_nde_while_t*)p)->test);
- xp_awk_clrpt (awk, ((xp_awk_nde_while_t*)p)->body);
- XP_AWK_FREE (awk, p);
+ sse_awk_clrpt (awk, ((sse_awk_nde_while_t*)p)->test);
+ sse_awk_clrpt (awk, ((sse_awk_nde_while_t*)p)->body);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_FOR:
+ case SSE_AWK_NDE_FOR:
{
- xp_awk_nde_for_t* px = (xp_awk_nde_for_t*)p;
+ sse_awk_nde_for_t* px = (sse_awk_nde_for_t*)p;
- if (px->init != XP_NULL)
- xp_awk_clrpt (awk, px->init);
- if (px->test != XP_NULL)
- xp_awk_clrpt (awk, px->test);
- if (px->incr != XP_NULL)
- xp_awk_clrpt (awk, px->incr);
- xp_awk_clrpt (awk, px->body);
- XP_AWK_FREE (awk, p);
+ if (px->init != SSE_NULL)
+ sse_awk_clrpt (awk, px->init);
+ if (px->test != SSE_NULL)
+ sse_awk_clrpt (awk, px->test);
+ if (px->incr != SSE_NULL)
+ sse_awk_clrpt (awk, px->incr);
+ sse_awk_clrpt (awk, px->body);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_FOREACH:
+ case SSE_AWK_NDE_FOREACH:
{
- xp_awk_clrpt (awk, ((xp_awk_nde_foreach_t*)p)->test);
- xp_awk_clrpt (awk, ((xp_awk_nde_foreach_t*)p)->body);
- XP_AWK_FREE (awk, p);
+ sse_awk_clrpt (awk, ((sse_awk_nde_foreach_t*)p)->test);
+ sse_awk_clrpt (awk, ((sse_awk_nde_foreach_t*)p)->body);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_BREAK:
+ case SSE_AWK_NDE_BREAK:
{
- XP_AWK_FREE (awk, p);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_CONTINUE:
+ case SSE_AWK_NDE_CONTINUE:
{
- XP_AWK_FREE (awk, p);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_RETURN:
+ case SSE_AWK_NDE_RETURN:
{
- xp_awk_nde_return_t* px =
- (xp_awk_nde_return_t*)p;
- if (px->val != XP_NULL)
- xp_awk_clrpt (awk, px->val);
- XP_AWK_FREE (awk, p);
+ sse_awk_nde_return_t* px =
+ (sse_awk_nde_return_t*)p;
+ if (px->val != SSE_NULL)
+ sse_awk_clrpt (awk, px->val);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_EXIT:
+ case SSE_AWK_NDE_EXIT:
{
- if (((xp_awk_nde_exit_t*)p)->val != XP_NULL)
- xp_awk_clrpt (awk, ((xp_awk_nde_exit_t*)p)->val);
- XP_AWK_FREE (awk, p);
+ if (((sse_awk_nde_exit_t*)p)->val != SSE_NULL)
+ sse_awk_clrpt (awk, ((sse_awk_nde_exit_t*)p)->val);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_NEXT:
- case XP_AWK_NDE_NEXTFILE:
+ case SSE_AWK_NDE_NEXT:
+ case SSE_AWK_NDE_NEXTFILE:
{
- XP_AWK_FREE (awk, p);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_DELETE:
+ case SSE_AWK_NDE_DELETE:
{
- xp_awk_clrpt (awk, ((xp_awk_nde_delete_t*)p)->var);
- XP_AWK_FREE (awk, p);
+ sse_awk_clrpt (awk, ((sse_awk_nde_delete_t*)p)->var);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_PRINT:
+ case SSE_AWK_NDE_PRINT:
{
- xp_awk_nde_print_t* px =
- (xp_awk_nde_print_t*)p;
- if (px->args != XP_NULL)
- xp_awk_clrpt (awk, px->args);
- if (px->out != XP_NULL)
- xp_awk_clrpt (awk, px->out);
- XP_AWK_FREE (awk, p);
+ sse_awk_nde_print_t* px =
+ (sse_awk_nde_print_t*)p;
+ if (px->args != SSE_NULL)
+ sse_awk_clrpt (awk, px->args);
+ if (px->out != SSE_NULL)
+ sse_awk_clrpt (awk, px->out);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_GRP:
+ case SSE_AWK_NDE_GRP:
{
- xp_awk_clrpt (awk, ((xp_awk_nde_grp_t*)p)->body);
- XP_AWK_FREE (awk, p);
+ sse_awk_clrpt (awk, ((sse_awk_nde_grp_t*)p)->body);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_ASS:
+ case SSE_AWK_NDE_ASS:
{
- xp_awk_clrpt (awk, ((xp_awk_nde_ass_t*)p)->left);
- xp_awk_clrpt (awk, ((xp_awk_nde_ass_t*)p)->right);
- XP_AWK_FREE (awk, p);
+ sse_awk_clrpt (awk, ((sse_awk_nde_ass_t*)p)->left);
+ sse_awk_clrpt (awk, ((sse_awk_nde_ass_t*)p)->right);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_EXP_BIN:
+ case SSE_AWK_NDE_ESSE_BIN:
{
- xp_awk_nde_exp_t* px = (xp_awk_nde_exp_t*)p;
- xp_awk_assert (awk, px->left->next == XP_NULL);
- xp_awk_assert (awk, px->right->next == XP_NULL);
+ sse_awk_nde_esse_t* px = (sse_awk_nde_esse_t*)p;
+ sse_awk_assert (awk, px->left->next == SSE_NULL);
+ sse_awk_assert (awk, px->right->next == SSE_NULL);
- xp_awk_clrpt (awk, px->left);
- xp_awk_clrpt (awk, px->right);
- XP_AWK_FREE (awk, p);
+ sse_awk_clrpt (awk, px->left);
+ sse_awk_clrpt (awk, px->right);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_EXP_UNR:
- case XP_AWK_NDE_EXP_INCPRE:
- case XP_AWK_NDE_EXP_INCPST:
+ case SSE_AWK_NDE_ESSE_UNR:
+ case SSE_AWK_NDE_ESSE_INCPRE:
+ case SSE_AWK_NDE_ESSE_INCPST:
{
- xp_awk_nde_exp_t* px = (xp_awk_nde_exp_t*)p;
- xp_awk_assert (awk, px->right == XP_NULL);
- xp_awk_clrpt (awk, px->left);
- XP_AWK_FREE (awk, p);
+ sse_awk_nde_esse_t* px = (sse_awk_nde_esse_t*)p;
+ sse_awk_assert (awk, px->right == SSE_NULL);
+ sse_awk_clrpt (awk, px->left);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_CND:
+ case SSE_AWK_NDE_CND:
{
- xp_awk_clrpt (awk, ((xp_awk_nde_cnd_t*)p)->test);
- xp_awk_clrpt (awk, ((xp_awk_nde_cnd_t*)p)->left);
- xp_awk_clrpt (awk, ((xp_awk_nde_cnd_t*)p)->right);
- XP_AWK_FREE (awk, p);
+ sse_awk_clrpt (awk, ((sse_awk_nde_cnd_t*)p)->test);
+ sse_awk_clrpt (awk, ((sse_awk_nde_cnd_t*)p)->left);
+ sse_awk_clrpt (awk, ((sse_awk_nde_cnd_t*)p)->right);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_INT:
+ case SSE_AWK_NDE_INT:
{
- if (((xp_awk_nde_int_t*)p)->str != XP_NULL)
- XP_AWK_FREE (awk, ((xp_awk_nde_int_t*)p)->str);
- XP_AWK_FREE (awk, p);
+ if (((sse_awk_nde_int_t*)p)->str != SSE_NULL)
+ SSE_AWK_FREE (awk, ((sse_awk_nde_int_t*)p)->str);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_REAL:
+ case SSE_AWK_NDE_REAL:
{
- if (((xp_awk_nde_real_t*)p)->str != XP_NULL)
- XP_AWK_FREE (awk, ((xp_awk_nde_real_t*)p)->str);
- XP_AWK_FREE (awk, p);
+ if (((sse_awk_nde_real_t*)p)->str != SSE_NULL)
+ SSE_AWK_FREE (awk, ((sse_awk_nde_real_t*)p)->str);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_STR:
+ case SSE_AWK_NDE_STR:
{
- XP_AWK_FREE (awk, ((xp_awk_nde_str_t*)p)->buf);
- XP_AWK_FREE (awk, p);
+ SSE_AWK_FREE (awk, ((sse_awk_nde_str_t*)p)->buf);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_REX:
+ case SSE_AWK_NDE_REX:
{
- XP_AWK_FREE (awk, ((xp_awk_nde_rex_t*)p)->buf);
- XP_AWK_FREE (awk, ((xp_awk_nde_rex_t*)p)->code);
- XP_AWK_FREE (awk, p);
+ SSE_AWK_FREE (awk, ((sse_awk_nde_rex_t*)p)->buf);
+ SSE_AWK_FREE (awk, ((sse_awk_nde_rex_t*)p)->code);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_NAMED:
- case XP_AWK_NDE_GLOBAL:
- case XP_AWK_NDE_LOCAL:
- case XP_AWK_NDE_ARG:
+ case SSE_AWK_NDE_NAMED:
+ case SSE_AWK_NDE_GLOBAL:
+ case SSE_AWK_NDE_LOCAL:
+ case SSE_AWK_NDE_ARG:
{
- xp_awk_nde_var_t* px = (xp_awk_nde_var_t*)p;
- xp_awk_assert (awk, px->idx == XP_NULL);
- if (px->id.name != XP_NULL)
- XP_AWK_FREE (awk, px->id.name);
- XP_AWK_FREE (awk, p);
+ sse_awk_nde_var_t* px = (sse_awk_nde_var_t*)p;
+ sse_awk_assert (awk, px->idx == SSE_NULL);
+ if (px->id.name != SSE_NULL)
+ SSE_AWK_FREE (awk, px->id.name);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_NAMEDIDX:
- case XP_AWK_NDE_GLOBALIDX:
- case XP_AWK_NDE_LOCALIDX:
- case XP_AWK_NDE_ARGIDX:
+ case SSE_AWK_NDE_NAMEDIDX:
+ case SSE_AWK_NDE_GLOBALIDX:
+ case SSE_AWK_NDE_LOCALIDX:
+ case SSE_AWK_NDE_ARGIDX:
{
- xp_awk_nde_var_t* px = (xp_awk_nde_var_t*)p;
- xp_awk_assert (awk, px->idx != XP_NULL);
- xp_awk_clrpt (awk, px->idx);
- if (px->id.name != XP_NULL)
- XP_AWK_FREE (awk, px->id.name);
- XP_AWK_FREE (awk, p);
+ sse_awk_nde_var_t* px = (sse_awk_nde_var_t*)p;
+ sse_awk_assert (awk, px->idx != SSE_NULL);
+ sse_awk_clrpt (awk, px->idx);
+ if (px->id.name != SSE_NULL)
+ SSE_AWK_FREE (awk, px->id.name);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_POS:
+ case SSE_AWK_NDE_POS:
{
- xp_awk_clrpt (awk, ((xp_awk_nde_pos_t*)p)->val);
- XP_AWK_FREE (awk, p);
+ sse_awk_clrpt (awk, ((sse_awk_nde_pos_t*)p)->val);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_BFN:
+ case SSE_AWK_NDE_BFN:
{
- xp_awk_nde_call_t* px = (xp_awk_nde_call_t*)p;
- /* XP_AWK_FREE (awk, px->what.bfn); */
- xp_awk_clrpt (awk, px->args);
- XP_AWK_FREE (awk, p);
+ sse_awk_nde_call_t* px = (sse_awk_nde_call_t*)p;
+ /* SSE_AWK_FREE (awk, px->what.bfn); */
+ sse_awk_clrpt (awk, px->args);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_AFN:
+ case SSE_AWK_NDE_AFN:
{
- xp_awk_nde_call_t* px = (xp_awk_nde_call_t*)p;
- XP_AWK_FREE (awk, px->what.afn.name);
- xp_awk_clrpt (awk, px->args);
- XP_AWK_FREE (awk, p);
+ sse_awk_nde_call_t* px = (sse_awk_nde_call_t*)p;
+ SSE_AWK_FREE (awk, px->what.afn.name);
+ sse_awk_clrpt (awk, px->args);
+ SSE_AWK_FREE (awk, p);
break;
}
- case XP_AWK_NDE_GETLINE:
+ case SSE_AWK_NDE_GETLINE:
{
- xp_awk_nde_getline_t* px =
- (xp_awk_nde_getline_t*)p;
- if (px->var != XP_NULL)
- xp_awk_clrpt (awk, px->var);
- if (px->in != XP_NULL)
- xp_awk_clrpt (awk, px->in);
- XP_AWK_FREE (awk, p);
+ sse_awk_nde_getline_t* px =
+ (sse_awk_nde_getline_t*)p;
+ if (px->var != SSE_NULL)
+ sse_awk_clrpt (awk, px->var);
+ if (px->in != SSE_NULL)
+ sse_awk_clrpt (awk, px->in);
+ SSE_AWK_FREE (awk, p);
break;
}
default:
{
- xp_awk_assert (awk, !"should never happen - invalid node type");
- XP_AWK_FREE (awk, p);
+ sse_awk_assert (awk, !"should never happen - invalid node type");
+ SSE_AWK_FREE (awk, p);
break;
}
}
diff --git a/ase/awk/tree.h b/ase/awk/tree.h
index d01fb7e3..5c0816f7 100644
--- a/ase/awk/tree.h
+++ b/ase/awk/tree.h
@@ -1,67 +1,67 @@
/*
- * $Id: tree.h,v 1.74 2006-10-10 07:02:38 bacon Exp $
+ * $Id: tree.h,v 1.75 2006-10-22 11:34:53 bacon Exp $
*/
-#ifndef _XP_AWK_TREE_H_
-#define _XP_AWK_TREE_H_
+#ifndef _SSE_AWK_TREE_H_
+#define _SSE_AWK_TREE_H_
-#ifndef _XP_AWK_AWK_H_
-#error Never include this file directly. Include <xp/awk/awk.h> instead
+#ifndef _SSE_AWK_AWK_H_
+#error Never include this file directly. Include <sse/awk/awk.h> instead
#endif
enum
{
- XP_AWK_NDE_NULL,
+ SSE_AWK_NDE_NULL,
/* statement */
- XP_AWK_NDE_BLK,
- XP_AWK_NDE_IF,
- XP_AWK_NDE_WHILE,
- XP_AWK_NDE_DOWHILE,
- XP_AWK_NDE_FOR,
- XP_AWK_NDE_FOREACH,
- XP_AWK_NDE_BREAK,
- XP_AWK_NDE_CONTINUE,
- XP_AWK_NDE_RETURN,
- XP_AWK_NDE_EXIT,
- XP_AWK_NDE_NEXT,
- XP_AWK_NDE_NEXTFILE,
- XP_AWK_NDE_DELETE,
- XP_AWK_NDE_PRINT,
+ 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,
- /* expression */
+ /* esseression */
/* if you change the following values including their order,
- * you should change __eval_func of __eval_expression
+ * you should change __eval_func of __eval_esseression
* in run.c accordingly */
- XP_AWK_NDE_GRP,
- XP_AWK_NDE_ASS,
- XP_AWK_NDE_EXP_BIN,
- XP_AWK_NDE_EXP_UNR,
- XP_AWK_NDE_EXP_INCPRE,
- XP_AWK_NDE_EXP_INCPST,
- XP_AWK_NDE_CND,
- XP_AWK_NDE_BFN,
- XP_AWK_NDE_AFN,
- XP_AWK_NDE_INT,
- XP_AWK_NDE_REAL,
- XP_AWK_NDE_STR,
- XP_AWK_NDE_REX,
+ SSE_AWK_NDE_GRP,
+ SSE_AWK_NDE_ASS,
+ SSE_AWK_NDE_ESSE_BIN,
+ SSE_AWK_NDE_ESSE_UNR,
+ SSE_AWK_NDE_ESSE_INCPRE,
+ SSE_AWK_NDE_ESSE_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,
/* keep this order for the following items otherwise, you may have
* to change __eval_incpre and __eval_incpst in run.c as well as
- * XP_AWK_VAL_REF_XXX in val.h */
- XP_AWK_NDE_NAMED,
- XP_AWK_NDE_GLOBAL,
- XP_AWK_NDE_LOCAL,
- XP_AWK_NDE_ARG,
- XP_AWK_NDE_NAMEDIDX,
- XP_AWK_NDE_GLOBALIDX,
- XP_AWK_NDE_LOCALIDX,
- XP_AWK_NDE_ARGIDX,
- XP_AWK_NDE_POS,
+ * 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,
/* ---------------------------------- */
- XP_AWK_NDE_GETLINE,
+ SSE_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 */
- XP_AWK_IN_PIPE,
- XP_AWK_IN_COPROC,
- XP_AWK_IN_FILE,
- XP_AWK_IN_CONSOLE
+ SSE_AWK_IN_PIPE,
+ SSE_AWK_IN_COPROC,
+ SSE_AWK_IN_FILE,
+ SSE_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 */
- XP_AWK_OUT_PIPE,
- XP_AWK_OUT_COPROC,
- XP_AWK_OUT_FILE,
- XP_AWK_OUT_FILE_APPEND,
- XP_AWK_OUT_CONSOLE
+ SSE_AWK_OUT_PIPE,
+ SSE_AWK_OUT_COPROC,
+ SSE_AWK_OUT_FILE,
+ SSE_AWK_OUT_FILE_APPEND,
+ SSE_AWK_OUT_CONSOLE
};
/* afn (awk function defined with the keyword function) */
-typedef struct xp_awk_afn_t xp_awk_afn_t;
+typedef struct sse_awk_afn_t sse_awk_afn_t;
-typedef struct xp_awk_nde_t xp_awk_nde_t;
+typedef struct sse_awk_nde_t sse_awk_nde_t;
-typedef struct xp_awk_nde_blk_t xp_awk_nde_blk_t;
-typedef struct xp_awk_nde_grp_t xp_awk_nde_grp_t;
-typedef struct xp_awk_nde_ass_t xp_awk_nde_ass_t;
-typedef struct xp_awk_nde_exp_t xp_awk_nde_exp_t;
-typedef struct xp_awk_nde_cnd_t xp_awk_nde_cnd_t;
-typedef struct xp_awk_nde_pos_t xp_awk_nde_pos_t;
-typedef struct xp_awk_nde_int_t xp_awk_nde_int_t;
-typedef struct xp_awk_nde_real_t xp_awk_nde_real_t;
-typedef struct xp_awk_nde_str_t xp_awk_nde_str_t;
-typedef struct xp_awk_nde_rex_t xp_awk_nde_rex_t;
-typedef struct xp_awk_nde_var_t xp_awk_nde_var_t;
-typedef struct xp_awk_nde_call_t xp_awk_nde_call_t;
-typedef struct xp_awk_nde_getline_t xp_awk_nde_getline_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_esse_t sse_awk_nde_esse_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 xp_awk_nde_if_t xp_awk_nde_if_t;
-typedef struct xp_awk_nde_while_t xp_awk_nde_while_t;
-typedef struct xp_awk_nde_for_t xp_awk_nde_for_t;
-typedef struct xp_awk_nde_foreach_t xp_awk_nde_foreach_t;
-typedef struct xp_awk_nde_break_t xp_awk_nde_break_t;
-typedef struct xp_awk_nde_continue_t xp_awk_nde_continue_t;
-typedef struct xp_awk_nde_return_t xp_awk_nde_return_t;
-typedef struct xp_awk_nde_exit_t xp_awk_nde_exit_t;
-typedef struct xp_awk_nde_next_t xp_awk_nde_next_t;
-typedef struct xp_awk_nde_nextfile_t xp_awk_nde_nextfile_t;
-typedef struct xp_awk_nde_delete_t xp_awk_nde_delete_t;
-typedef struct xp_awk_nde_print_t xp_awk_nde_print_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;
-struct xp_awk_afn_t
+struct sse_awk_afn_t
{
- xp_char_t* name;
- xp_size_t name_len;
- xp_size_t nargs;
- xp_awk_nde_t* body;
+ sse_char_t* name;
+ sse_size_t name_len;
+ sse_size_t nargs;
+ sse_awk_nde_t* body;
};
-#define XP_AWK_NDE_HDR \
+#define SSE_AWK_NDE_HDR \
int type; \
- xp_awk_nde_t* next
+ sse_awk_nde_t* next
-struct xp_awk_nde_t
+struct sse_awk_nde_t
{
- XP_AWK_NDE_HDR;
+ SSE_AWK_NDE_HDR;
};
-/* XP_AWK_NDE_BLK - block statement including top-level blocks */
-struct xp_awk_nde_blk_t
+/* SSE_AWK_NDE_BLK - block statement including top-level blocks */
+struct sse_awk_nde_blk_t
{
- XP_AWK_NDE_HDR;
- xp_size_t nlocals;
- xp_awk_nde_t* body;
+ SSE_AWK_NDE_HDR;
+ sse_size_t nlocals;
+ sse_awk_nde_t* body;
};
-/* XP_AWK_NDE_GRP - expression group */
-struct xp_awk_nde_grp_t
+/* SSE_AWK_NDE_GRP - esseression group */
+struct sse_awk_nde_grp_t
{
- XP_AWK_NDE_HDR;
- xp_awk_nde_t* body;
+ SSE_AWK_NDE_HDR;
+ sse_awk_nde_t* body;
};
-/* XP_AWK_NDE_ASS - assignment */
-struct xp_awk_nde_ass_t
+/* SSE_AWK_NDE_ASS - assignment */
+struct sse_awk_nde_ass_t
{
- XP_AWK_NDE_HDR;
+ SSE_AWK_NDE_HDR;
int opcode;
- xp_awk_nde_t* left;
- xp_awk_nde_t* right;
+ sse_awk_nde_t* left;
+ sse_awk_nde_t* right;
};
-/* XP_AWK_NDE_EXP_BIN, XP_AWK_NDE_EXP_UNR,
- * XP_AWK_NDE_EXP_INCPRE, XP_AW_NDE_EXP_INCPST */
-struct xp_awk_nde_exp_t
+/* SSE_AWK_NDE_ESSE_BIN, SSE_AWK_NDE_ESSE_UNR,
+ * SSE_AWK_NDE_ESSE_INCPRE, SSE_AW_NDE_ESSE_INCPST */
+struct sse_awk_nde_esse_t
{
- XP_AWK_NDE_HDR;
+ SSE_AWK_NDE_HDR;
int opcode;
- xp_awk_nde_t* left;
- xp_awk_nde_t* right; /* XP_NULL for UNR, INCPRE, INCPST */
+ sse_awk_nde_t* left;
+ sse_awk_nde_t* right; /* SSE_NULL for UNR, INCPRE, INCPST */
};
-/* XP_AWK_NDE_CND */
-struct xp_awk_nde_cnd_t
+/* SSE_AWK_NDE_CND */
+struct sse_awk_nde_cnd_t
{
- XP_AWK_NDE_HDR;
- xp_awk_nde_t* test;
- xp_awk_nde_t* left;
- xp_awk_nde_t* right;
+ SSE_AWK_NDE_HDR;
+ sse_awk_nde_t* test;
+ sse_awk_nde_t* left;
+ sse_awk_nde_t* right;
};
-/* XP_AWK_NDE_POS - positional - $1, $2, $x, etc */
-struct xp_awk_nde_pos_t
+/* SSE_AWK_NDE_POS - positional - $1, $2, $x, etc */
+struct sse_awk_nde_pos_t
{
- XP_AWK_NDE_HDR;
- xp_awk_nde_t* val;
+ SSE_AWK_NDE_HDR;
+ sse_awk_nde_t* val;
};
-/* XP_AWK_NDE_INT */
-struct xp_awk_nde_int_t
+/* SSE_AWK_NDE_INT */
+struct sse_awk_nde_int_t
{
- XP_AWK_NDE_HDR;
- xp_long_t val;
- xp_char_t* str;
- xp_size_t len;
+ SSE_AWK_NDE_HDR;
+ sse_long_t val;
+ sse_char_t* str;
+ sse_size_t len;
};
-/* XP_AWK_NDE_REAL */
-struct xp_awk_nde_real_t
+/* SSE_AWK_NDE_REAL */
+struct sse_awk_nde_real_t
{
- XP_AWK_NDE_HDR;
- xp_real_t val;
- xp_char_t* str;
- xp_size_t len;
+ SSE_AWK_NDE_HDR;
+ sse_real_t val;
+ sse_char_t* str;
+ sse_size_t len;
};
-/* XP_AWK_NDE_STR */
-struct xp_awk_nde_str_t
+/* SSE_AWK_NDE_STR */
+struct sse_awk_nde_str_t
{
- XP_AWK_NDE_HDR;
- xp_char_t* buf;
- xp_size_t len;
+ SSE_AWK_NDE_HDR;
+ sse_char_t* buf;
+ sse_size_t len;
};
-/* XP_AWK_NDE_REX */
-struct xp_awk_nde_rex_t
+/* SSE_AWK_NDE_REX */
+struct sse_awk_nde_rex_t
{
- XP_AWK_NDE_HDR;
- xp_char_t* buf;
- xp_size_t len;
+ SSE_AWK_NDE_HDR;
+ sse_char_t* buf;
+ sse_size_t len;
void* code;
};
-/* XP_AWK_NDE_NAMED, XP_AWK_NDE_GLOBAL,
- * XP_AWK_NDE_LOCAL, XP_AWK_NDE_ARG
- * XP_AWK_NDE_NAMEDIDX, XP_AWK_NDE_GLOBALIDX,
- * XP_AWK_NDE_LOCALIDX, XP_AWK_NDE_ARGIDX */
-struct xp_awk_nde_var_t
+/* 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
{
- XP_AWK_NDE_HDR;
+ SSE_AWK_NDE_HDR;
struct
{
- xp_char_t* name;
- xp_size_t name_len;
- xp_size_t idxa;
+ sse_char_t* name;
+ sse_size_t name_len;
+ sse_size_t idxa;
} id;
- xp_awk_nde_t* idx; /* XP_NULL for non-XXXXIDX */
+ sse_awk_nde_t* idx; /* SSE_NULL for non-XXXXIDX */
};
-/* XP_AWK_NDE_BFN, XP_AWK_NDE_AFN */
-struct xp_awk_nde_call_t
+/* SSE_AWK_NDE_BFN, SSE_AWK_NDE_AFN */
+struct sse_awk_nde_call_t
{
- XP_AWK_NDE_HDR;
+ SSE_AWK_NDE_HDR;
union
{
struct
{
- xp_char_t* name;
- xp_size_t name_len;
+ sse_char_t* name;
+ sse_size_t name_len;
} afn;
/* minimum information of a built-in function
* needed during run-time. */
struct
{
- const xp_char_t* name;
- xp_size_t name_len;
- xp_size_t min_args;
- xp_size_t max_args;
- const xp_char_t* arg_spec;
- int (*handler) (xp_awk_run_t* awk);
+ 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);
} bfn;
- /* xp_awk_bfn_t* bfn; */
+ /* sse_awk_bfn_t* bfn; */
} what;
- xp_awk_nde_t* args;
- xp_size_t nargs;
+ sse_awk_nde_t* args;
+ sse_size_t nargs;
};
-/* XP_AWK_NDE_GETLINE */
-struct xp_awk_nde_getline_t
+/* SSE_AWK_NDE_GETLINE */
+struct sse_awk_nde_getline_t
{
- XP_AWK_NDE_HDR;
- xp_awk_nde_t* var;
- int in_type; /* XP_AWK_GETLINE_XXX */
- xp_awk_nde_t* in;
+ SSE_AWK_NDE_HDR;
+ sse_awk_nde_t* var;
+ int in_type; /* SSE_AWK_GETLINE_XXX */
+ sse_awk_nde_t* in;
};
-/* XP_AWK_NDE_IF */
-struct xp_awk_nde_if_t
+/* SSE_AWK_NDE_IF */
+struct sse_awk_nde_if_t
{
- XP_AWK_NDE_HDR;
- xp_awk_nde_t* test;
- xp_awk_nde_t* then_part;
- xp_awk_nde_t* else_part; /* optional */
+ SSE_AWK_NDE_HDR;
+ sse_awk_nde_t* test;
+ sse_awk_nde_t* then_part;
+ sse_awk_nde_t* else_part; /* optional */
};
-/* XP_AWK_NDE_WHILE, XP_AWK_NDE_DOWHILE */
-struct xp_awk_nde_while_t
+/* SSE_AWK_NDE_WHILE, SSE_AWK_NDE_DOWHILE */
+struct sse_awk_nde_while_t
{
- XP_AWK_NDE_HDR;
- xp_awk_nde_t* test;
- xp_awk_nde_t* body;
+ SSE_AWK_NDE_HDR;
+ sse_awk_nde_t* test;
+ sse_awk_nde_t* body;
};
-/* XP_AWK_NDE_FOR */
-struct xp_awk_nde_for_t
+/* SSE_AWK_NDE_FOR */
+struct sse_awk_nde_for_t
{
- XP_AWK_NDE_HDR;
- xp_awk_nde_t* init; /* optional */
- xp_awk_nde_t* test; /* optional */
- xp_awk_nde_t* incr; /* optional */
- xp_awk_nde_t* body;
+ 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;
};
-/* XP_AWK_NDE_FOREACH */
-struct xp_awk_nde_foreach_t
+/* SSE_AWK_NDE_FOREACH */
+struct sse_awk_nde_foreach_t
{
- XP_AWK_NDE_HDR;
- xp_awk_nde_t* test;
- xp_awk_nde_t* body;
+ SSE_AWK_NDE_HDR;
+ sse_awk_nde_t* test;
+ sse_awk_nde_t* body;
};
-/* XP_AWK_NDE_BREAK */
-struct xp_awk_nde_break_t
+/* SSE_AWK_NDE_BREAK */
+struct sse_awk_nde_break_t
{
- XP_AWK_NDE_HDR;
+ SSE_AWK_NDE_HDR;
};
-/* XP_AWK_NDE_CONTINUE */
-struct xp_awk_nde_continue_t
+/* SSE_AWK_NDE_CONTINUE */
+struct sse_awk_nde_continue_t
{
- XP_AWK_NDE_HDR;
+ SSE_AWK_NDE_HDR;
};
-/* XP_AWK_NDE_RETURN */
-struct xp_awk_nde_return_t
+/* SSE_AWK_NDE_RETURN */
+struct sse_awk_nde_return_t
{
- XP_AWK_NDE_HDR;
- xp_awk_nde_t* val; /* optional (no return code if XP_NULL) */
+ SSE_AWK_NDE_HDR;
+ sse_awk_nde_t* val; /* optional (no return code if SSE_NULL) */
};
-/* XP_AWK_NDE_EXIT */
-struct xp_awk_nde_exit_t
+/* SSE_AWK_NDE_EXIT */
+struct sse_awk_nde_exit_t
{
- XP_AWK_NDE_HDR;
- xp_awk_nde_t* val; /* optional (no exit code if XP_NULL) */
+ SSE_AWK_NDE_HDR;
+ sse_awk_nde_t* val; /* optional (no exit code if SSE_NULL) */
};
-/* XP_AWK_NDE_NEXT */
-struct xp_awk_nde_next_t
+/* SSE_AWK_NDE_NEXT */
+struct sse_awk_nde_next_t
{
- XP_AWK_NDE_HDR;
+ SSE_AWK_NDE_HDR;
};
-/* XP_AWK_NDE_NEXTFILE */
-struct xp_awk_nde_nextfile_t
+/* SSE_AWK_NDE_NEXTFILE */
+struct sse_awk_nde_nextfile_t
{
- XP_AWK_NDE_HDR;
+ SSE_AWK_NDE_HDR;
};
-/* XP_AWK_NDE_DELETE */
-struct xp_awk_nde_delete_t
+/* SSE_AWK_NDE_DELETE */
+struct sse_awk_nde_delete_t
{
- XP_AWK_NDE_HDR;
- xp_awk_nde_t* var;
+ SSE_AWK_NDE_HDR;
+ sse_awk_nde_t* var;
};
-/* XP_AWK_NDE_PRINT */
-struct xp_awk_nde_print_t
+/* SSE_AWK_NDE_PRINT */
+struct sse_awk_nde_print_t
{
- XP_AWK_NDE_HDR;
- xp_awk_nde_t* args;
- int out_type; /* XP_AWK_OUT_XXX */
- xp_awk_nde_t* out;
+ SSE_AWK_NDE_HDR;
+ sse_awk_nde_t* args;
+ int out_type; /* SSE_AWK_OUT_XXX */
+ sse_awk_nde_t* out;
};
#ifdef __cplusplus
extern "C" {
#endif
-int xp_awk_prnpt (xp_awk_t* awk, xp_awk_nde_t* tree);
-int xp_awk_prnptnpt (xp_awk_t* awk, xp_awk_nde_t* tree);
+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);
-void xp_awk_clrpt (xp_awk_t* awk, xp_awk_nde_t* tree);
+void sse_awk_clrpt (sse_awk_t* awk, sse_awk_nde_t* tree);
#ifdef __cplusplus
}
diff --git a/ase/awk/val.c b/ase/awk/val.c
index be1542da..0b943d70 100644
--- a/ase/awk/val.c
+++ b/ase/awk/val.c
@@ -1,51 +1,51 @@
/*
- * $Id: val.c,v 1.73 2006-10-12 14:36:25 bacon Exp $
+ * $Id: val.c,v 1.74 2006-10-22 11:34:53 bacon Exp $
*/
-#include <xp/awk/awk_i.h>
+#include <sse/awk/awk_i.h>
-static xp_char_t* __str_to_str (
- xp_awk_run_t* run, const xp_char_t* str, xp_size_t str_len,
- int opt, xp_awk_str_t* buf, xp_size_t* len);
-static xp_char_t* __val_int_to_str (
- xp_awk_run_t* run, xp_awk_val_int_t* v,
- int opt, xp_awk_str_t* buf, xp_size_t* len);
-static xp_char_t* __val_real_to_str (
- xp_awk_run_t* run, xp_awk_val_real_t* v,
- int opt, xp_awk_str_t* buf, xp_size_t* len);
+static sse_char_t* __str_to_str (
+ sse_awk_run_t* run, const sse_char_t* str, sse_size_t str_len,
+ int opt, sse_awk_str_t* buf, sse_size_t* len);
+static sse_char_t* __val_int_to_str (
+ sse_awk_run_t* run, sse_awk_val_int_t* v,
+ int opt, sse_awk_str_t* buf, sse_size_t* len);
+static sse_char_t* __val_real_to_str (
+ sse_awk_run_t* run, sse_awk_val_real_t* v,
+ int opt, sse_awk_str_t* buf, sse_size_t* len);
-static xp_awk_val_nil_t __awk_nil = { XP_AWK_VAL_NIL, 0 };
-xp_awk_val_t* xp_awk_val_nil = (xp_awk_val_t*)&__awk_nil;
+static sse_awk_val_nil_t __awk_nil = { SSE_AWK_VAL_NIL, 0 };
+sse_awk_val_t* sse_awk_val_nil = (sse_awk_val_t*)&__awk_nil;
-static xp_awk_val_str_t __awk_zls = { XP_AWK_VAL_STR, 0, XP_T(""), 0 };
-xp_awk_val_t* xp_awk_val_zls = (xp_awk_val_t*)&__awk_zls;
+static sse_awk_val_str_t __awk_zls = { SSE_AWK_VAL_STR, 0, SSE_T(""), 0 };
+sse_awk_val_t* sse_awk_val_zls = (sse_awk_val_t*)&__awk_zls;
-static xp_awk_val_int_t __awk_int[] =
+static sse_awk_val_int_t __awk_int[] =
{
- { XP_AWK_VAL_INT, 0, -1 },
- { XP_AWK_VAL_INT, 0, 0 },
- { XP_AWK_VAL_INT, 0, 1 },
- { XP_AWK_VAL_INT, 0, 2 },
- { XP_AWK_VAL_INT, 0, 3 },
- { XP_AWK_VAL_INT, 0, 4 },
- { XP_AWK_VAL_INT, 0, 5 },
- { XP_AWK_VAL_INT, 0, 6 },
- { XP_AWK_VAL_INT, 0, 7 },
- { XP_AWK_VAL_INT, 0, 8 },
- { XP_AWK_VAL_INT, 0, 9 },
+ { SSE_AWK_VAL_INT, 0, -1 },
+ { SSE_AWK_VAL_INT, 0, 0 },
+ { SSE_AWK_VAL_INT, 0, 1 },
+ { SSE_AWK_VAL_INT, 0, 2 },
+ { SSE_AWK_VAL_INT, 0, 3 },
+ { SSE_AWK_VAL_INT, 0, 4 },
+ { SSE_AWK_VAL_INT, 0, 5 },
+ { SSE_AWK_VAL_INT, 0, 6 },
+ { SSE_AWK_VAL_INT, 0, 7 },
+ { SSE_AWK_VAL_INT, 0, 8 },
+ { SSE_AWK_VAL_INT, 0, 9 },
};
-xp_awk_val_t* xp_awk_val_zero = (xp_awk_val_t*)&__awk_int[1];
-xp_awk_val_t* xp_awk_val_one = (xp_awk_val_t*)&__awk_int[2];
+sse_awk_val_t* sse_awk_val_zero = (sse_awk_val_t*)&__awk_int[1];
+sse_awk_val_t* sse_awk_val_one = (sse_awk_val_t*)&__awk_int[2];
-xp_awk_val_t* xp_awk_makeintval (xp_awk_run_t* run, xp_long_t v)
+sse_awk_val_t* sse_awk_makeintval (sse_awk_run_t* run, sse_long_t v)
{
- xp_awk_val_int_t* val;
+ sse_awk_val_int_t* val;
if (v >= __awk_int[0].val &&
- v <= __awk_int[xp_countof(__awk_int)-1].val)
+ v <= __awk_int[sse_countof(__awk_int)-1].val)
{
- return (xp_awk_val_t*)&__awk_int[v-__awk_int[0].val];
+ return (sse_awk_val_t*)&__awk_int[v-__awk_int[0].val];
}
if (run->icache_count > 0)
@@ -54,23 +54,23 @@ xp_awk_val_t* xp_awk_makeintval (xp_awk_run_t* run, xp_long_t v)
}
else
{
- val = (xp_awk_val_int_t*) XP_AWK_MALLOC (
- run->awk, xp_sizeof(xp_awk_val_int_t));
- if (val == XP_NULL) return XP_NULL;
+ val = (sse_awk_val_int_t*) SSE_AWK_MALLOC (
+ run->awk, sse_sizeof(sse_awk_val_int_t));
+ if (val == SSE_NULL) return SSE_NULL;
}
- val->type = XP_AWK_VAL_INT;
+ val->type = SSE_AWK_VAL_INT;
val->ref = 0;
val->val = v;
- val->nde = XP_NULL;
+ val->nde = SSE_NULL;
-/*xp_printf (XP_T("makeintval => %p\n"), val);*/
- return (xp_awk_val_t*)val;
+/*sse_printf (SSE_T("makeintval => %p\n"), val);*/
+ return (sse_awk_val_t*)val;
}
-xp_awk_val_t* xp_awk_makerealval (xp_awk_run_t* run, xp_real_t v)
+sse_awk_val_t* sse_awk_makerealval (sse_awk_run_t* run, sse_real_t v)
{
- xp_awk_val_real_t* val;
+ sse_awk_val_real_t* val;
if (run->rcache_count > 0)
{
@@ -78,138 +78,138 @@ xp_awk_val_t* xp_awk_makerealval (xp_awk_run_t* run, xp_real_t v)
}
else
{
- val = (xp_awk_val_real_t*) XP_AWK_MALLOC (
- run->awk, xp_sizeof(xp_awk_val_real_t));
- if (val == XP_NULL) return XP_NULL;
+ val = (sse_awk_val_real_t*) SSE_AWK_MALLOC (
+ run->awk, sse_sizeof(sse_awk_val_real_t));
+ if (val == SSE_NULL) return SSE_NULL;
}
- val->type = XP_AWK_VAL_REAL;
+ val->type = SSE_AWK_VAL_REAL;
val->ref = 0;
val->val = v;
- val->nde = XP_NULL;
+ val->nde = SSE_NULL;
-/*xp_printf (XP_T("makerealval => %p\n"), val);*/
- return (xp_awk_val_t*)val;
+/*sse_printf (SSE_T("makerealval => %p\n"), val);*/
+ return (sse_awk_val_t*)val;
}
-xp_awk_val_t* xp_awk_makestrval0 (xp_awk_run_t* run, const xp_char_t* str)
+sse_awk_val_t* sse_awk_makestrval0 (sse_awk_run_t* run, const sse_char_t* str)
{
- return xp_awk_makestrval (run, str, xp_awk_strlen(str));
+ return sse_awk_makestrval (run, str, sse_awk_strlen(str));
}
-xp_awk_val_t* xp_awk_makestrval (
- xp_awk_run_t* run, const xp_char_t* str, xp_size_t len)
+sse_awk_val_t* sse_awk_makestrval (
+ sse_awk_run_t* run, const sse_char_t* str, sse_size_t len)
{
- xp_awk_val_str_t* val;
+ sse_awk_val_str_t* val;
- val = (xp_awk_val_str_t*) XP_AWK_MALLOC (
- run->awk, xp_sizeof(xp_awk_val_str_t));
- if (val == XP_NULL) return XP_NULL;
+ val = (sse_awk_val_str_t*) SSE_AWK_MALLOC (
+ run->awk, sse_sizeof(sse_awk_val_str_t));
+ if (val == SSE_NULL) return SSE_NULL;
- val->type = XP_AWK_VAL_STR;
+ val->type = SSE_AWK_VAL_STR;
val->ref = 0;
val->len = len;
- val->buf = xp_awk_strxdup (run->awk, str, len);
- if (val->buf == XP_NULL)
+ val->buf = sse_awk_strxdup (run->awk, str, len);
+ if (val->buf == SSE_NULL)
{
- XP_AWK_FREE (run->awk, val);
- return XP_NULL;
+ SSE_AWK_FREE (run->awk, val);
+ return SSE_NULL;
}
-/*xp_printf (XP_T("makestrval => %p\n"), val);*/
- return (xp_awk_val_t*)val;
+/*sse_printf (SSE_T("makestrval => %p\n"), val);*/
+ return (sse_awk_val_t*)val;
}
-xp_awk_val_t* xp_awk_makestrval2 (
- xp_awk_run_t* run,
- const xp_char_t* str1, xp_size_t len1,
- const xp_char_t* str2, xp_size_t len2)
+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)
{
- xp_awk_val_str_t* val;
+ sse_awk_val_str_t* val;
- val = (xp_awk_val_str_t*) XP_AWK_MALLOC (
- run->awk, xp_sizeof(xp_awk_val_str_t));
- if (val == XP_NULL) return XP_NULL;
+ val = (sse_awk_val_str_t*) SSE_AWK_MALLOC (
+ run->awk, sse_sizeof(sse_awk_val_str_t));
+ if (val == SSE_NULL) return SSE_NULL;
- val->type = XP_AWK_VAL_STR;
+ val->type = SSE_AWK_VAL_STR;
val->ref = 0;
val->len = len1 + len2;
- val->buf = xp_awk_strxdup2 (run->awk, str1, len1, str2, len2);
- if (val->buf == XP_NULL)
+ val->buf = sse_awk_strxdup2 (run->awk, str1, len1, str2, len2);
+ if (val->buf == SSE_NULL)
{
- XP_AWK_FREE (run->awk, val);
- return XP_NULL;
+ SSE_AWK_FREE (run->awk, val);
+ return SSE_NULL;
}
-/*xp_printf (XP_T("makestrval2 => %p\n"), val);*/
- return (xp_awk_val_t*)val;
+/*sse_printf (SSE_T("makestrval2 => %p\n"), val);*/
+ return (sse_awk_val_t*)val;
}
-xp_awk_val_t* xp_awk_makerexval (
- xp_awk_run_t* run, const xp_char_t* buf, xp_size_t len, void* code)
+sse_awk_val_t* sse_awk_makerexval (
+ sse_awk_run_t* run, const sse_char_t* buf, sse_size_t len, void* code)
{
- xp_awk_val_rex_t* val;
+ sse_awk_val_rex_t* val;
- val = (xp_awk_val_rex_t*) XP_AWK_MALLOC (
- run->awk, xp_sizeof(xp_awk_val_rex_t));
- if (val == XP_NULL) return XP_NULL;
+ val = (sse_awk_val_rex_t*) SSE_AWK_MALLOC (
+ run->awk, sse_sizeof(sse_awk_val_rex_t));
+ if (val == SSE_NULL) return SSE_NULL;
- val->type = XP_AWK_VAL_REX;
+ val->type = SSE_AWK_VAL_REX;
val->ref = 0;
val->len = len;
- val->buf = xp_awk_strxdup (run->awk, buf, len);
- if (val->buf == XP_NULL)
+ val->buf = sse_awk_strxdup (run->awk, buf, len);
+ if (val->buf == SSE_NULL)
{
- XP_AWK_FREE (run->awk, val);
- return XP_NULL;
+ SSE_AWK_FREE (run->awk, val);
+ return SSE_NULL;
}
- val->code = XP_AWK_MALLOC (run->awk, XP_AWK_REX_LEN(code));
- if (val->code == XP_NULL)
+ val->code = SSE_AWK_MALLOC (run->awk, SSE_AWK_REX_LEN(code));
+ if (val->code == SSE_NULL)
{
- XP_AWK_FREE (run->awk, val->buf);
- XP_AWK_FREE (run->awk, val);
- return XP_NULL;
+ SSE_AWK_FREE (run->awk, val->buf);
+ SSE_AWK_FREE (run->awk, val);
+ return SSE_NULL;
}
- XP_AWK_MEMCPY (run->awk, val->code, code, XP_AWK_REX_LEN(code));
- return (xp_awk_val_t*)val;
+ SSE_AWK_MEMCPY (run->awk, val->code, code, SSE_AWK_REX_LEN(code));
+ return (sse_awk_val_t*)val;
}
static void __free_map_val (void* run, void* v)
{
/*
-xp_printf (XP_T("refdown in map free..."));
-xp_awk_printval (v);
-xp_printf (XP_T("\n"));
+sse_printf (SSE_T("refdown in map free..."));
+sse_awk_printval (v);
+sse_printf (SSE_T("\n"));
*/
- xp_awk_refdownval (run, v);
+ sse_awk_refdownval (run, v);
}
-xp_awk_val_t* xp_awk_makemapval (xp_awk_run_t* run)
+sse_awk_val_t* sse_awk_makemapval (sse_awk_run_t* run)
{
- xp_awk_val_map_t* val;
+ sse_awk_val_map_t* val;
- val = (xp_awk_val_map_t*) XP_AWK_MALLOC (
- run->awk, xp_sizeof(xp_awk_val_map_t));
- if (val == XP_NULL) return XP_NULL;
+ val = (sse_awk_val_map_t*) SSE_AWK_MALLOC (
+ run->awk, sse_sizeof(sse_awk_val_map_t));
+ if (val == SSE_NULL) return SSE_NULL;
- val->type = XP_AWK_VAL_MAP;
+ val->type = SSE_AWK_VAL_MAP;
val->ref = 0;
- val->map = xp_awk_map_open (
- XP_NULL, run, 256, __free_map_val, run->awk);
- if (val->map == XP_NULL)
+ val->map = sse_awk_map_open (
+ SSE_NULL, run, 256, __free_map_val, run->awk);
+ if (val->map == SSE_NULL)
{
- XP_AWK_FREE (run->awk, val);
- return XP_NULL;
+ SSE_AWK_FREE (run->awk, val);
+ return SSE_NULL;
}
- return (xp_awk_val_t*)val;
+ return (sse_awk_val_t*)val;
}
-xp_awk_val_t* xp_awk_makerefval (xp_awk_run_t* run, int id, xp_awk_val_t** adr)
+sse_awk_val_t* sse_awk_makerefval (sse_awk_run_t* run, int id, sse_awk_val_t** adr)
{
- xp_awk_val_ref_t* val;
+ sse_awk_val_ref_t* val;
if (run->fcache_count > 0)
{
@@ -217,176 +217,176 @@ xp_awk_val_t* xp_awk_makerefval (xp_awk_run_t* run, int id, xp_awk_val_t** adr)
}
else
{
- val = (xp_awk_val_ref_t*) XP_AWK_MALLOC (
- run->awk, xp_sizeof(xp_awk_val_ref_t));
- if (val == XP_NULL) return XP_NULL;
+ val = (sse_awk_val_ref_t*) SSE_AWK_MALLOC (
+ run->awk, sse_sizeof(sse_awk_val_ref_t));
+ if (val == SSE_NULL) return SSE_NULL;
}
- val->type = XP_AWK_VAL_REF;
+ val->type = SSE_AWK_VAL_REF;
val->ref = 0;
val->id = id;
val->adr = adr;
- return (xp_awk_val_t*)val;
+ return (sse_awk_val_t*)val;
}
-xp_bool_t xp_awk_isbuiltinval (xp_awk_val_t* val)
+sse_bool_t sse_awk_isbuiltinval (sse_awk_val_t* val)
{
- return val == XP_NULL ||
- val == xp_awk_val_nil || val == xp_awk_val_zls ||
- val == xp_awk_val_zero || val == xp_awk_val_one ||
- (val >= (xp_awk_val_t*)&__awk_int[0] &&
- val <= (xp_awk_val_t*)&__awk_int[xp_countof(__awk_int)-1]);
+ return val == SSE_NULL ||
+ val == sse_awk_val_nil || val == sse_awk_val_zls ||
+ val == sse_awk_val_zero || val == sse_awk_val_one ||
+ (val >= (sse_awk_val_t*)&__awk_int[0] &&
+ val <= (sse_awk_val_t*)&__awk_int[sse_countof(__awk_int)-1]);
}
-void xp_awk_freeval (xp_awk_run_t* run, xp_awk_val_t* val, xp_bool_t cache)
+void sse_awk_freeval (sse_awk_run_t* run, sse_awk_val_t* val, sse_bool_t cache)
{
- if (xp_awk_isbuiltinval(val)) return;
+ if (sse_awk_isbuiltinval(val)) return;
-/*xp_printf (XP_T("freeing [cache=%d] ... "), cache);
-xp_awk_printval (val);
-xp_printf (XP_T("\n"));*/
- if (val->type == XP_AWK_VAL_NIL)
+/*sse_printf (SSE_T("freeing [cache=%d] ... "), cache);
+sse_awk_printval (val);
+sse_printf (SSE_T("\n"));*/
+ if (val->type == SSE_AWK_VAL_NIL)
{
- XP_AWK_FREE (run->awk, val);
+ SSE_AWK_FREE (run->awk, val);
}
- else if (val->type == XP_AWK_VAL_INT)
+ else if (val->type == SSE_AWK_VAL_INT)
{
- if (cache == xp_true &&
- run->icache_count < xp_countof(run->icache))
+ if (cache == sse_true &&
+ run->icache_count < sse_countof(run->icache))
{
run->icache[run->icache_count++] =
- (xp_awk_val_int_t*)val;
+ (sse_awk_val_int_t*)val;
}
- else XP_AWK_FREE (run->awk, val);
+ else SSE_AWK_FREE (run->awk, val);
}
- else if (val->type == XP_AWK_VAL_REAL)
+ else if (val->type == SSE_AWK_VAL_REAL)
{
- if (cache == xp_true &&
- run->rcache_count < xp_countof(run->rcache))
+ if (cache == sse_true &&
+ run->rcache_count < sse_countof(run->rcache))
{
run->rcache[run->rcache_count++] =
- (xp_awk_val_real_t*)val;
+ (sse_awk_val_real_t*)val;
}
- else XP_AWK_FREE (run->awk, val);
+ else SSE_AWK_FREE (run->awk, val);
}
- else if (val->type == XP_AWK_VAL_STR)
+ else if (val->type == SSE_AWK_VAL_STR)
{
- XP_AWK_FREE (run->awk, ((xp_awk_val_str_t*)val)->buf);
- XP_AWK_FREE (run->awk, val);
+ SSE_AWK_FREE (run->awk, ((sse_awk_val_str_t*)val)->buf);
+ SSE_AWK_FREE (run->awk, val);
}
- else if (val->type == XP_AWK_VAL_REX)
+ else if (val->type == SSE_AWK_VAL_REX)
{
- XP_AWK_FREE (run->awk, ((xp_awk_val_rex_t*)val)->buf);
- xp_awk_freerex (run->awk, ((xp_awk_val_rex_t*)val)->code);
- XP_AWK_FREE (run->awk, val);
+ SSE_AWK_FREE (run->awk, ((sse_awk_val_rex_t*)val)->buf);
+ sse_awk_freerex (run->awk, ((sse_awk_val_rex_t*)val)->code);
+ SSE_AWK_FREE (run->awk, val);
}
- else if (val->type == XP_AWK_VAL_MAP)
+ else if (val->type == SSE_AWK_VAL_MAP)
{
- xp_awk_map_close (((xp_awk_val_map_t*)val)->map);
- XP_AWK_FREE (run->awk, val);
+ sse_awk_map_close (((sse_awk_val_map_t*)val)->map);
+ SSE_AWK_FREE (run->awk, val);
}
- else if (val->type == XP_AWK_VAL_REF)
+ else if (val->type == SSE_AWK_VAL_REF)
{
- if (cache == xp_true &&
- run->fcache_count < xp_countof(run->fcache))
+ if (cache == sse_true &&
+ run->fcache_count < sse_countof(run->fcache))
{
run->fcache[run->fcache_count++] =
- (xp_awk_val_ref_t*)val;
+ (sse_awk_val_ref_t*)val;
}
- else XP_AWK_FREE (run->awk, val);
+ else SSE_AWK_FREE (run->awk, val);
}
else
{
- xp_awk_assert (run->awk,
+ sse_awk_assert (run->awk,
!"should never happen - invalid value type");
}
}
-void xp_awk_refupval (xp_awk_val_t* val)
+void sse_awk_refupval (sse_awk_val_t* val)
{
- if (xp_awk_isbuiltinval(val)) return;
+ if (sse_awk_isbuiltinval(val)) return;
/*
-xp_printf (XP_T("ref up "));
-xp_awk_printval (val);
-xp_printf (XP_T("\n"));
+sse_printf (SSE_T("ref up "));
+sse_awk_printval (val);
+sse_printf (SSE_T("\n"));
*/
val->ref++;
}
-void xp_awk_refdownval (xp_awk_run_t* run, xp_awk_val_t* val)
+void sse_awk_refdownval (sse_awk_run_t* run, sse_awk_val_t* val)
{
- if (xp_awk_isbuiltinval(val)) return;
+ if (sse_awk_isbuiltinval(val)) return;
/*
-xp_printf (XP_T("%p, %p, %p\n"), xp_awk_val_nil, &__awk_nil, val);
-xp_printf (XP_T("ref down [count=>%d]\n"), (int)val->ref);
-xp_awk_printval (val);
-xp_printf (XP_T("\n"));
+sse_printf (SSE_T("%p, %p, %p\n"), sse_awk_val_nil, &__awk_nil, val);
+sse_printf (SSE_T("ref down [count=>%d]\n"), (int)val->ref);
+sse_awk_printval (val);
+sse_printf (SSE_T("\n"));
*/
- xp_awk_assert (run->awk, val->ref > 0);
+ sse_awk_assert (run->awk, val->ref > 0);
val->ref--;
if (val->ref <= 0)
{
/*
-xp_printf (XP_T("**FREEING ["));
-xp_awk_printval (val);
-xp_printf (XP_T("]\n"));
+sse_printf (SSE_T("**FREEING ["));
+sse_awk_printval (val);
+sse_printf (SSE_T("]\n"));
*/
- xp_awk_freeval(run, val, xp_true);
+ sse_awk_freeval(run, val, sse_true);
}
}
-void xp_awk_refdownval_nofree (xp_awk_run_t* run, xp_awk_val_t* val)
+void sse_awk_refdownval_nofree (sse_awk_run_t* run, sse_awk_val_t* val)
{
- if (xp_awk_isbuiltinval(val)) return;
+ if (sse_awk_isbuiltinval(val)) return;
- xp_awk_assert (run->awk, val->ref > 0);
+ sse_awk_assert (run->awk, val->ref > 0);
val->ref--;
}
-xp_bool_t xp_awk_valtobool (xp_awk_run_t* run, xp_awk_val_t* val)
+sse_bool_t sse_awk_valtobool (sse_awk_run_t* run, sse_awk_val_t* val)
{
- if (val == XP_NULL) return xp_false;
+ if (val == SSE_NULL) return sse_false;
switch (val->type)
{
- case XP_AWK_VAL_NIL:
- return xp_false;
- case XP_AWK_VAL_INT:
- return ((xp_awk_val_int_t*)val)->val != 0;
- case XP_AWK_VAL_REAL:
- return ((xp_awk_val_real_t*)val)->val != 0.0;
- case XP_AWK_VAL_STR:
- return ((xp_awk_val_str_t*)val)->len > 0;
- case XP_AWK_VAL_REX: /* TODO: is this correct? */
- return ((xp_awk_val_rex_t*)val)->len > 0;
- case XP_AWK_VAL_MAP:
- return xp_false; /* TODO: is this correct? */
- case XP_AWK_VAL_REF:
- return xp_false; /* TODO: is this correct? */
+ case SSE_AWK_VAL_NIL:
+ return sse_false;
+ case SSE_AWK_VAL_INT:
+ return ((sse_awk_val_int_t*)val)->val != 0;
+ case SSE_AWK_VAL_REAL:
+ return ((sse_awk_val_real_t*)val)->val != 0.0;
+ case SSE_AWK_VAL_STR:
+ return ((sse_awk_val_str_t*)val)->len > 0;
+ case SSE_AWK_VAL_REX: /* TODO: is this correct? */
+ return ((sse_awk_val_rex_t*)val)->len > 0;
+ case SSE_AWK_VAL_MAP:
+ return sse_false; /* TODO: is this correct? */
+ case SSE_AWK_VAL_REF:
+ return sse_false; /* TODO: is this correct? */
}
- xp_awk_assert (run->awk, !"should never happen - invalid value type");
- return xp_false;
+ sse_awk_assert (run->awk, !"should never happen - invalid value type");
+ return sse_false;
}
-xp_char_t* xp_awk_valtostr (
- xp_awk_run_t* run, xp_awk_val_t* v,
- int opt, xp_awk_str_t* buf, xp_size_t* len)
+sse_char_t* sse_awk_valtostr (
+ sse_awk_run_t* run, sse_awk_val_t* v,
+ int opt, sse_awk_str_t* buf, sse_size_t* len)
{
- if (v->type == XP_AWK_VAL_NIL)
+ if (v->type == SSE_AWK_VAL_NIL)
{
- return __str_to_str (run, XP_T(""), 0, opt, buf, len);
+ return __str_to_str (run, SSE_T(""), 0, opt, buf, len);
}
- if (v->type == XP_AWK_VAL_INT)
+ if (v->type == SSE_AWK_VAL_INT)
{
- xp_awk_val_int_t* vi = (xp_awk_val_int_t*)v;
+ sse_awk_val_int_t* vi = (sse_awk_val_int_t*)v;
/*
- if (vi->nde != XP_NULL && vi->nde->str != XP_NULL)
+ if (vi->nde != SSE_NULL && vi->nde->str != SSE_NULL)
{
return __str_to_str (
run, vi->nde->str, vi->nde->len,
@@ -399,12 +399,12 @@ xp_char_t* xp_awk_valtostr (
/*}*/
}
- if (v->type == XP_AWK_VAL_REAL)
+ if (v->type == SSE_AWK_VAL_REAL)
{
- xp_awk_val_real_t* vr = (xp_awk_val_real_t*)v;
+ sse_awk_val_real_t* vr = (sse_awk_val_real_t*)v;
/*
- if (vr->nde != XP_NULL && vr->nde->str != XP_NULL)
+ if (vr->nde != SSE_NULL && vr->nde->str != SSE_NULL)
{
return __str_to_str (
run, vr->nde->str, vr->nde->len,
@@ -416,9 +416,9 @@ xp_char_t* xp_awk_valtostr (
/*}*/
}
- if (v->type == XP_AWK_VAL_STR)
+ if (v->type == SSE_AWK_VAL_STR)
{
- xp_awk_val_str_t* vs = (xp_awk_val_str_t*)v;
+ sse_awk_val_str_t* vs = (sse_awk_val_str_t*)v;
return __str_to_str (
run, vs->buf, vs->len, opt, buf, len);
@@ -426,83 +426,83 @@ xp_char_t* xp_awk_valtostr (
/* TODO: process more value types */
-xp_printf (XP_T("*** ERROR: WRONG VALUE TYPE [%d] in xp_awk_valtostr v=> %p***\n"), v->type, v);
- run->errnum = XP_AWK_EVALTYPE;
- return XP_NULL;
+sse_printf (SSE_T("*** ERROR: WRONG VALUE TYPE [%d] in sse_awk_valtostr v=> %p***\n"), v->type, v);
+ run->errnum = SSE_AWK_EVALTYPE;
+ return SSE_NULL;
}
-static xp_char_t* __str_to_str (
- xp_awk_run_t* run, const xp_char_t* str, xp_size_t str_len,
- int opt, xp_awk_str_t* buf, xp_size_t* len)
+static sse_char_t* __str_to_str (
+ sse_awk_run_t* run, const sse_char_t* str, sse_size_t str_len,
+ int opt, sse_awk_str_t* buf, sse_size_t* len)
{
- if (buf == XP_NULL)
+ if (buf == SSE_NULL)
{
- xp_char_t* tmp;
- tmp = xp_awk_strxdup (run->awk, str, str_len);
- if (tmp == XP_NULL)
+ sse_char_t* tmp;
+ tmp = sse_awk_strxdup (run->awk, str, str_len);
+ if (tmp == SSE_NULL)
{
- run->errnum = XP_AWK_ENOMEM;
- return XP_NULL;
+ run->errnum = SSE_AWK_ENOMEM;
+ return SSE_NULL;
}
- if (len != XP_NULL) *len = str_len;
+ if (len != SSE_NULL) *len = str_len;
return tmp;
}
else
{
- xp_size_t n;
+ sse_size_t n;
- if (opt & XP_AWK_VALTOSTR_CLEAR) xp_awk_str_clear (buf);
- n = xp_awk_str_ncat (buf, str, str_len);
- if (n == (xp_size_t)-1)
+ if (opt & SSE_AWK_VALTOSTR_CLEAR) sse_awk_str_clear (buf);
+ n = sse_awk_str_ncat (buf, str, str_len);
+ if (n == (sse_size_t)-1)
{
- run->errnum = XP_AWK_ENOMEM;
- return XP_NULL;
+ run->errnum = SSE_AWK_ENOMEM;
+ return SSE_NULL;
}
- if (len != XP_NULL) *len = XP_AWK_STR_LEN(buf);
- return XP_AWK_STR_BUF(buf);
+ if (len != SSE_NULL) *len = SSE_AWK_STR_LEN(buf);
+ return SSE_AWK_STR_BUF(buf);
}
}
-static xp_char_t* __val_int_to_str (
- xp_awk_run_t* run, xp_awk_val_int_t* v,
- int opt, xp_awk_str_t* buf, xp_size_t* len)
+static sse_char_t* __val_int_to_str (
+ sse_awk_run_t* run, sse_awk_val_int_t* v,
+ int opt, sse_awk_str_t* buf, sse_size_t* len)
{
- xp_char_t* tmp;
- xp_long_t t;
- xp_size_t l = 0;
+ sse_char_t* tmp;
+ sse_long_t t;
+ sse_size_t l = 0;
t = v->val;
if (t == 0)
{
/* handle zero */
- if (buf == XP_NULL)
+ if (buf == SSE_NULL)
{
- tmp = XP_AWK_MALLOC (
- run->awk, 2 * xp_sizeof(xp_char_t));
- if (tmp == XP_NULL)
+ tmp = SSE_AWK_MALLOC (
+ run->awk, 2 * sse_sizeof(sse_char_t));
+ if (tmp == SSE_NULL)
{
- run->errnum = XP_AWK_ENOMEM;
- return XP_NULL;
+ run->errnum = SSE_AWK_ENOMEM;
+ return SSE_NULL;
}
- tmp[0] = XP_T('0');
- tmp[1] = XP_T('\0');
- if (len != XP_NULL) *len = 1;
+ tmp[0] = SSE_T('0');
+ tmp[1] = SSE_T('\0');
+ if (len != SSE_NULL) *len = 1;
return tmp;
}
else
{
- if (opt & XP_AWK_VALTOSTR_CLEAR) xp_awk_str_clear (buf);
- if (xp_awk_str_cat (buf, XP_T("0")) == (xp_size_t)-1)
+ if (opt & SSE_AWK_VALTOSTR_CLEAR) sse_awk_str_clear (buf);
+ if (sse_awk_str_cat (buf, SSE_T("0")) == (sse_size_t)-1)
{
- run->errnum = XP_AWK_ENOMEM;
- return XP_NULL;
+ run->errnum = SSE_AWK_ENOMEM;
+ return SSE_NULL;
}
- if (len != XP_NULL) *len = XP_AWK_STR_LEN(buf);
- return XP_AWK_STR_BUF(buf);
+ if (len != SSE_NULL) *len = SSE_AWK_STR_LEN(buf);
+ return SSE_AWK_STR_BUF(buf);
}
}
@@ -510,32 +510,32 @@ static xp_char_t* __val_int_to_str (
if (t < 0) { t = -t; l++; }
while (t > 0) { l++; t /= 10; }
- if (buf == XP_NULL)
+ if (buf == SSE_NULL)
{
- tmp = XP_AWK_MALLOC (
- run->awk, (l + 1) * xp_sizeof(xp_char_t));
- if (tmp == XP_NULL)
+ tmp = SSE_AWK_MALLOC (
+ run->awk, (l + 1) * sse_sizeof(sse_char_t));
+ if (tmp == SSE_NULL)
{
- run->errnum = XP_AWK_ENOMEM;
- return XP_NULL;
+ run->errnum = SSE_AWK_ENOMEM;
+ return SSE_NULL;
}
- tmp[l] = XP_T('\0');
- if (len != XP_NULL) *len = l;
+ tmp[l] = SSE_T('\0');
+ if (len != SSE_NULL) *len = l;
}
else
{
/* clear the buffer */
- if (opt & XP_AWK_VALTOSTR_CLEAR) xp_awk_str_clear (buf);
+ if (opt & SSE_AWK_VALTOSTR_CLEAR) sse_awk_str_clear (buf);
- tmp = XP_AWK_STR_BUF(buf) + XP_AWK_STR_LEN(buf);
+ tmp = SSE_AWK_STR_BUF(buf) + SSE_AWK_STR_LEN(buf);
/* extend the buffer */
- if (xp_awk_str_nccat (
- buf, XP_T(' '), l) == (xp_size_t)-1)
+ if (sse_awk_str_nccat (
+ buf, SSE_T(' '), l) == (sse_size_t)-1)
{
- run->errnum = XP_AWK_ENOMEM;
- return XP_NULL;
+ run->errnum = SSE_AWK_ENOMEM;
+ return SSE_NULL;
}
}
@@ -544,98 +544,98 @@ static xp_char_t* __val_int_to_str (
while (t > 0)
{
- tmp[--l] = (xp_char_t)(t % 10) + XP_T('0');
+ tmp[--l] = (sse_char_t)(t % 10) + SSE_T('0');
t /= 10;
}
- if (v->val < 0) tmp[--l] = XP_T('-');
+ if (v->val < 0) tmp[--l] = SSE_T('-');
- if (buf != XP_NULL)
+ if (buf != SSE_NULL)
{
- tmp = XP_AWK_STR_BUF(buf);
- if (len != XP_NULL) *len = XP_AWK_STR_LEN(buf);
+ tmp = SSE_AWK_STR_BUF(buf);
+ if (len != SSE_NULL) *len = SSE_AWK_STR_LEN(buf);
}
return tmp;
}
-static xp_char_t* __val_real_to_str (
- xp_awk_run_t* run, xp_awk_val_real_t* v,
- int opt, xp_awk_str_t* buf, xp_size_t* len)
+static sse_char_t* __val_real_to_str (
+ sse_awk_run_t* run, sse_awk_val_real_t* v,
+ int opt, sse_awk_str_t* buf, sse_size_t* len)
{
/* TODO: change the code */
- xp_char_t tbuf[256], * tmp;
+ sse_char_t tbuf[256], * tmp;
- tmp = (opt & XP_AWK_VALTOSTR_PRINT)?
+ tmp = (opt & SSE_AWK_VALTOSTR_PRINT)?
run->global.ofmt.ptr: run->global.convfmt.ptr;
/* TODO: need to use awk's own version of sprintf so that it would have
* problems with handling long double or double... */
/* TODO: does it need to check if a null character is included in convfmt??? */
- run->awk->syscas.sprintf (tbuf, xp_countof(tbuf), tmp, (double)v->val);
- if (buf == XP_NULL)
+ run->awk->syscas.sprintf (tbuf, sse_countof(tbuf), tmp, (double)v->val);
+ if (buf == SSE_NULL)
{
- tmp = xp_awk_strdup (run->awk, tbuf);
- if (tmp == XP_NULL)
+ tmp = sse_awk_strdup (run->awk, tbuf);
+ if (tmp == SSE_NULL)
{
- run->errnum = XP_AWK_ENOMEM;
- return XP_NULL;
+ run->errnum = SSE_AWK_ENOMEM;
+ return SSE_NULL;
}
- if (len != XP_NULL) *len = xp_awk_strlen(tmp);
+ if (len != SSE_NULL) *len = sse_awk_strlen(tmp);
}
else
{
- if (opt & XP_AWK_VALTOSTR_CLEAR) xp_awk_str_clear (buf);
+ if (opt & SSE_AWK_VALTOSTR_CLEAR) sse_awk_str_clear (buf);
- if (xp_awk_str_cat (buf, tbuf) == (xp_size_t)-1)
+ if (sse_awk_str_cat (buf, tbuf) == (sse_size_t)-1)
{
- run->errnum = XP_AWK_ENOMEM;
- return XP_NULL;
+ run->errnum = SSE_AWK_ENOMEM;
+ return SSE_NULL;
}
- tmp = XP_AWK_STR_BUF(buf);
- if (len != XP_NULL) *len = XP_AWK_STR_LEN(buf);
+ tmp = SSE_AWK_STR_BUF(buf);
+ if (len != SSE_NULL) *len = SSE_AWK_STR_LEN(buf);
}
return tmp;
}
-int xp_awk_valtonum (
- xp_awk_run_t* run, xp_awk_val_t* v, xp_long_t* l, xp_real_t* r)
+int sse_awk_valtonum (
+ sse_awk_run_t* run, sse_awk_val_t* v, sse_long_t* l, sse_real_t* r)
{
- if (v->type == XP_AWK_VAL_NIL)
+ if (v->type == SSE_AWK_VAL_NIL)
{
*l = 0;
return 0;
}
- if (v->type == XP_AWK_VAL_INT)
+ if (v->type == SSE_AWK_VAL_INT)
{
- *l = ((xp_awk_val_int_t*)v)->val;
+ *l = ((sse_awk_val_int_t*)v)->val;
return 0; /* long */
}
- if (v->type == XP_AWK_VAL_REAL)
+ if (v->type == SSE_AWK_VAL_REAL)
{
- *r = ((xp_awk_val_real_t*)v)->val;
+ *r = ((sse_awk_val_real_t*)v)->val;
return 1; /* real */
}
- if (v->type == XP_AWK_VAL_STR)
+ if (v->type == SSE_AWK_VAL_STR)
{
- const xp_char_t* endptr;
+ const sse_char_t* endptr;
- *l = xp_awk_strxtolong (run->awk,
- ((xp_awk_val_str_t*)v)->buf,
- ((xp_awk_val_str_t*)v)->len, 0, &endptr);
- if (*endptr == XP_T('.') ||
- *endptr == XP_T('E') ||
- *endptr == XP_T('e'))
+ *l = sse_awk_strxtolong (run->awk,
+ ((sse_awk_val_str_t*)v)->buf,
+ ((sse_awk_val_str_t*)v)->len, 0, &endptr);
+ if (*endptr == SSE_T('.') ||
+ *endptr == SSE_T('E') ||
+ *endptr == SSE_T('e'))
{
- *r = xp_awk_strxtoreal (run->awk,
- ((xp_awk_val_str_t*)v)->buf,
- ((xp_awk_val_str_t*)v)->len, XP_NULL);
+ *r = sse_awk_strxtoreal (run->awk,
+ ((sse_awk_val_str_t*)v)->buf,
+ ((sse_awk_val_str_t*)v)->len, SSE_NULL);
/* TODO: need to check if it is a valid number using endptr for strxtoreal? */
return 1; /* real */
}
@@ -643,70 +643,70 @@ int xp_awk_valtonum (
return 0; /* long */
}
-xp_printf (XP_T("*** ERROR: WRONG VALUE TYPE [%d] in xp_awk_valtonum v=> %p***\n"), v->type, v);
- run->errnum = XP_AWK_EVALTYPE;
+sse_printf (SSE_T("*** ERROR: WRONG VALUE TYPE [%d] in sse_awk_valtonum v=> %p***\n"), v->type, v);
+ run->errnum = SSE_AWK_EVALTYPE;
return -1; /* error */
}
-static int __print_pair (xp_awk_pair_t* pair, void* arg)
+static int __print_pair (sse_awk_pair_t* pair, void* arg)
{
- xp_printf (XP_T(" %s=>"), pair->key);
- xp_awk_printval (pair->val);
- xp_printf (XP_T(" "));
+ sse_printf (SSE_T(" %s=>"), pair->key);
+ sse_awk_printval (pair->val);
+ sse_printf (SSE_T(" "));
return 0;
}
-void xp_awk_printval (xp_awk_val_t* val)
+void sse_awk_printval (sse_awk_val_t* val)
{
/* TODO: better value printing...................... */
switch (val->type)
{
- case XP_AWK_VAL_NIL:
- xp_printf (XP_T("nil"));
+ case SSE_AWK_VAL_NIL:
+ sse_printf (SSE_T("nil"));
break;
- case XP_AWK_VAL_INT:
+ case SSE_AWK_VAL_INT:
#if defined(__LCC__)
- xp_printf (XP_T("%lld"),
- (long long)((xp_awk_val_int_t*)val)->val);
+ sse_printf (SSE_T("%lld"),
+ (long long)((sse_awk_val_int_t*)val)->val);
#elif defined(__BORLANDC__) || defined(_MSC_VER)
- xp_printf (XP_T("%I64d"),
- (__int64)((xp_awk_nde_int_t*)val)->val);
+ sse_printf (SSE_T("%I64d"),
+ (__int64)((sse_awk_nde_int_t*)val)->val);
#elif defined(vax) || defined(__vax) || defined(_SCO_DS)
- xp_printf (XP_T("%ld"),
- (long)((xp_awk_val_int_t*)val)->val);
+ sse_printf (SSE_T("%ld"),
+ (long)((sse_awk_val_int_t*)val)->val);
#else
- xp_printf (XP_T("%lld"),
- (long long)((xp_awk_val_int_t*)val)->val);
+ sse_printf (SSE_T("%lld"),
+ (long long)((sse_awk_val_int_t*)val)->val);
#endif
break;
- case XP_AWK_VAL_REAL:
- xp_printf (XP_T("%Lf"),
- (long double)((xp_awk_val_real_t*)val)->val);
+ case SSE_AWK_VAL_REAL:
+ sse_printf (SSE_T("%Lf"),
+ (long double)((sse_awk_val_real_t*)val)->val);
break;
- case XP_AWK_VAL_STR:
- xp_printf (XP_T("%s"), ((xp_awk_val_str_t*)val)->buf);
+ case SSE_AWK_VAL_STR:
+ sse_printf (SSE_T("%s"), ((sse_awk_val_str_t*)val)->buf);
break;
- case XP_AWK_VAL_REX:
- xp_printf (XP_T("REX[%s]"), ((xp_awk_val_rex_t*)val)->buf);
+ case SSE_AWK_VAL_REX:
+ sse_printf (SSE_T("REX[%s]"), ((sse_awk_val_rex_t*)val)->buf);
break;
- case XP_AWK_VAL_MAP:
- xp_printf (XP_T("MAP["));
- xp_awk_map_walk (((xp_awk_val_map_t*)val)->map, __print_pair, XP_NULL);
- xp_printf (XP_T("]"));
+ case SSE_AWK_VAL_MAP:
+ sse_printf (SSE_T("MAP["));
+ sse_awk_map_walk (((sse_awk_val_map_t*)val)->map, __print_pair, SSE_NULL);
+ sse_printf (SSE_T("]"));
break;
- case XP_AWK_VAL_REF:
- xp_printf (XP_T("REF[id=%d,val="), ((xp_awk_val_ref_t*)val)->id);
- xp_awk_printval (*((xp_awk_val_ref_t*)val)->adr);
- xp_printf (XP_T("]"));
+ case SSE_AWK_VAL_REF:
+ sse_printf (SSE_T("REF[id=%d,val="), ((sse_awk_val_ref_t*)val)->id);
+ sse_awk_printval (*((sse_awk_val_ref_t*)val)->adr);
+ sse_printf (SSE_T("]"));
break;
default:
- xp_printf (XP_T("**** INTERNAL ERROR - INVALID VALUE TYPE ****\n"));
+ sse_printf (SSE_T("**** INTERNAL ERROR - INVALID VALUE TYPE ****\n"));
}
}
diff --git a/ase/awk/val.h b/ase/awk/val.h
index 78f4da40..8c7cef62 100644
--- a/ase/awk/val.h
+++ b/ase/awk/val.h
@@ -1,180 +1,180 @@
/*
- * $Id: val.h,v 1.46 2006-10-12 04:17:31 bacon Exp $
+ * $Id: val.h,v 1.47 2006-10-22 11:34:53 bacon Exp $
*/
-#ifndef _XP_AWK_VAL_H_
-#define _XP_AWK_VAL_H_
+#ifndef _SSE_AWK_VAL_H_
+#define _SSE_AWK_VAL_H_
-#ifndef _XP_AWK_AWK_H_
-#error Never include this file directly. Include <xp/awk/awk.h> instead
+#ifndef _SSE_AWK_AWK_H_
+#error Never include this file directly. Include <sse/awk/awk.h> instead
#endif
enum
{
- /* the values between XP_AWK_VAL_NIL and XP_AWK_VAL_STR inclusive
+ /* the values between SSE_AWK_VAL_NIL and SSE_AWK_VAL_STR inclusive
* must be synchronized with an internal table of the __cmp_val
* function in run.c */
- XP_AWK_VAL_NIL = 0,
- XP_AWK_VAL_INT = 1,
- XP_AWK_VAL_REAL = 2,
- XP_AWK_VAL_STR = 3,
+ SSE_AWK_VAL_NIL = 0,
+ SSE_AWK_VAL_INT = 1,
+ SSE_AWK_VAL_REAL = 2,
+ SSE_AWK_VAL_STR = 3,
- XP_AWK_VAL_REX = 4,
- XP_AWK_VAL_MAP = 5,
- XP_AWK_VAL_REF = 6
+ SSE_AWK_VAL_REX = 4,
+ SSE_AWK_VAL_MAP = 5,
+ SSE_AWK_VAL_REF = 6
};
enum
{
/* keep these items in the same order as corresponding items
* in tree.h */
- XP_AWK_VAL_REF_NAMED,
- XP_AWK_VAL_REF_GLOBAL,
- XP_AWK_VAL_REF_LOCAL,
- XP_AWK_VAL_REF_ARG,
- XP_AWK_VAL_REF_NAMEDIDX,
- XP_AWK_VAL_REF_GLOBALIDX,
- XP_AWK_VAL_REF_LOCALIDX,
- XP_AWK_VAL_REF_ARGIDX,
- XP_AWK_VAL_REF_POS
+ 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
};
enum
{
- XP_AWK_VALTOSTR_CLEAR = (1 << 0),
- XP_AWK_VALTOSTR_PRINT = (1 << 1)
+ SSE_AWK_VALTOSTR_CLEAR = (1 << 0),
+ SSE_AWK_VALTOSTR_PRINT = (1 << 1)
};
-typedef struct xp_awk_val_nil_t xp_awk_val_nil_t;
-typedef struct xp_awk_val_int_t xp_awk_val_int_t;
-typedef struct xp_awk_val_real_t xp_awk_val_real_t;
-typedef struct xp_awk_val_str_t xp_awk_val_str_t;
-typedef struct xp_awk_val_rex_t xp_awk_val_rex_t;
-typedef struct xp_awk_val_map_t xp_awk_val_map_t;
-typedef struct xp_awk_val_ref_t xp_awk_val_ref_t;
+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;
-#if XP_SIZEOF_INT == 2
-#define XP_AWK_VAL_HDR \
+#if SSE_SIZEOF_INT == 2
+#define SSE_AWK_VAL_HDR \
unsigned int type: 3; \
unsigned int ref: 13
#else
-#define XP_AWK_VAL_HDR \
+#define SSE_AWK_VAL_HDR \
unsigned int type: 3; \
unsigned int ref: 29
#endif
-struct xp_awk_val_t
+struct sse_awk_val_t
{
- XP_AWK_VAL_HDR;
+ SSE_AWK_VAL_HDR;
};
-/* XP_AWK_VAL_NIL */
-struct xp_awk_val_nil_t
+/* SSE_AWK_VAL_NIL */
+struct sse_awk_val_nil_t
{
- XP_AWK_VAL_HDR;
+ SSE_AWK_VAL_HDR;
};
-/* XP_AWK_VAL_INT */
-struct xp_awk_val_int_t
+/* SSE_AWK_VAL_INT */
+struct sse_awk_val_int_t
{
- XP_AWK_VAL_HDR;
- xp_long_t val;
- xp_awk_nde_int_t* nde;
+ SSE_AWK_VAL_HDR;
+ sse_long_t val;
+ sse_awk_nde_int_t* nde;
};
-/* XP_AWK_VAL_REAL */
-struct xp_awk_val_real_t
+/* SSE_AWK_VAL_REAL */
+struct sse_awk_val_real_t
{
- XP_AWK_VAL_HDR;
- xp_real_t val;
- xp_awk_nde_real_t* nde;
+ SSE_AWK_VAL_HDR;
+ sse_real_t val;
+ sse_awk_nde_real_t* nde;
};
-/* XP_AWK_VAL_STR */
-struct xp_awk_val_str_t
+/* SSE_AWK_VAL_STR */
+struct sse_awk_val_str_t
{
- XP_AWK_VAL_HDR;
- xp_char_t* buf;
- xp_size_t len;
+ SSE_AWK_VAL_HDR;
+ sse_char_t* buf;
+ sse_size_t len;
};
-/* XP_AWK_VAL_REX */
-struct xp_awk_val_rex_t
+/* SSE_AWK_VAL_REX */
+struct sse_awk_val_rex_t
{
- XP_AWK_VAL_HDR;
- xp_char_t* buf;
- xp_size_t len;
+ SSE_AWK_VAL_HDR;
+ sse_char_t* buf;
+ sse_size_t len;
void* code;
};
-/* XP_AWK_VAL_MAP */
-struct xp_awk_val_map_t
+/* SSE_AWK_VAL_MAP */
+struct sse_awk_val_map_t
{
- XP_AWK_VAL_HDR;
+ SSE_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.
*/
- xp_awk_map_t* map;
+ sse_awk_map_t* map;
};
-/* XP_AWK_VAL_REF */
-struct xp_awk_val_ref_t
+/* SSE_AWK_VAL_REF */
+struct sse_awk_val_ref_t
{
- XP_AWK_VAL_HDR;
+ SSE_AWK_VAL_HDR;
int id;
- /* if id is XP_AWK_VAL_REF_POS, adr holds an index of the
+ /* if id is SSE_AWK_VAL_REF_POS, adr holds an index of the
* positionalvariable. Otherwise, adr points to the value
* directly. */
- xp_awk_val_t** adr;
+ sse_awk_val_t** adr;
};
#ifdef __cplusplus
extern "C" {
#endif
-extern xp_awk_val_t* xp_awk_val_nil;
-extern xp_awk_val_t* xp_awk_val_zls;
-extern xp_awk_val_t* xp_awk_val_zero;
-extern xp_awk_val_t* xp_awk_val_one;
+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;
-xp_awk_val_t* xp_awk_makeintval (xp_awk_run_t* run, xp_long_t v);
-xp_awk_val_t* xp_awk_makerealval (xp_awk_run_t* run, xp_real_t v);
+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);
-xp_awk_val_t* xp_awk_makestrval0 (xp_awk_run_t* run, const xp_char_t* str);
-xp_awk_val_t* xp_awk_makestrval (
- xp_awk_run_t* run, const xp_char_t* str, xp_size_t len);
-xp_awk_val_t* xp_awk_makestrval2 (
- xp_awk_run_t* run,
- const xp_char_t* str1, xp_size_t len1,
- const xp_char_t* str2, xp_size_t len2);
+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);
-xp_awk_val_t* xp_awk_makerexval (
- xp_awk_run_t* run, const xp_char_t* buf, xp_size_t len, void* code);
-xp_awk_val_t* xp_awk_makemapval (xp_awk_run_t* run);
-xp_awk_val_t* xp_awk_makerefval (
- xp_awk_run_t* run, int id, xp_awk_val_t** adr);
+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);
-xp_bool_t xp_awk_isbuiltinval (xp_awk_val_t* val);
+sse_bool_t sse_awk_isbuiltinval (sse_awk_val_t* val);
-void xp_awk_freeval (xp_awk_run_t* run, xp_awk_val_t* val, xp_bool_t cache);
-void xp_awk_refupval (xp_awk_val_t* val);
-void xp_awk_refdownval (xp_awk_run_t* run, xp_awk_val_t* val);
-void xp_awk_refdownval_nofree (xp_awk_run_t* run, xp_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);
-xp_bool_t xp_awk_valtobool (
- xp_awk_run_t* run, xp_awk_val_t* val);
+sse_bool_t sse_awk_valtobool (
+ sse_awk_run_t* run, sse_awk_val_t* val);
-xp_char_t* xp_awk_valtostr (
- xp_awk_run_t* run, xp_awk_val_t* val,
- int opt, xp_awk_str_t* buf, xp_size_t* len);
+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);
-int xp_awk_valtonum (
- xp_awk_run_t* run, xp_awk_val_t* v, xp_long_t* l, xp_real_t* r);
+int sse_awk_valtonum (
+ sse_awk_run_t* run, sse_awk_val_t* v, sse_long_t* l, sse_real_t* r);
-void xp_awk_printval (xp_awk_val_t* val);
+void sse_awk_printval (sse_awk_val_t* val);
#ifdef __cplusplus
}