diff --git a/ase/awk/awk.c b/ase/awk/awk.c
index 37bbe233..2e46ce15 100644
--- a/ase/awk/awk.c
+++ b/ase/awk/awk.c
@@ -1,5 +1,5 @@
 /* 
- * $Id: awk.c,v 1.85 2006-10-23 14:44:42 bacon Exp $ 
+ * $Id: awk.c,v 1.86 2006-10-24 04:10:12 bacon Exp $ 
  */
 
 #if defined(__BORLANDC__)
@@ -7,111 +7,111 @@
 #define Library
 #endif
 
-#include <sse/awk/awk_i.h>
+#include <ase/awk/awk_i.h>
 
 static void __free_afn (void* awk, void* afn);
 
-sse_awk_t* sse_awk_open (const sse_awk_syscas_t* syscas)
+ase_awk_t* ase_awk_open (const ase_awk_syscas_t* syscas)
 {
-	sse_awk_t* awk;
+	ase_awk_t* awk;
 
-	if (syscas == SSE_NULL) return SSE_NULL;
+	if (syscas == ASE_NULL) return ASE_NULL;
 
-	if (syscas->malloc == SSE_NULL || 
-	    syscas->free == SSE_NULL) return SSE_NULL;
+	if (syscas->malloc == ASE_NULL || 
+	    syscas->free == ASE_NULL) return ASE_NULL;
 
-	if (syscas->is_upper  == SSE_NULL ||
-	    syscas->is_lower  == SSE_NULL ||
-	    syscas->is_alpha  == SSE_NULL ||
-	    syscas->is_digit  == SSE_NULL ||
-	    syscas->is_xdigit == SSE_NULL ||
-	    syscas->is_alnum  == SSE_NULL ||
-	    syscas->is_space  == SSE_NULL ||
-	    syscas->is_print  == SSE_NULL ||
-	    syscas->is_graph  == SSE_NULL ||
-	    syscas->is_cntrl  == SSE_NULL ||
-	    syscas->is_punct  == SSE_NULL ||
-	    syscas->to_upper  == SSE_NULL ||
-	    syscas->to_lower  == SSE_NULL) return SSE_NULL;
+	if (syscas->is_upper  == ASE_NULL ||
+	    syscas->is_lower  == ASE_NULL ||
+	    syscas->is_alpha  == ASE_NULL ||
+	    syscas->is_digit  == ASE_NULL ||
+	    syscas->is_xdigit == ASE_NULL ||
+	    syscas->is_alnum  == ASE_NULL ||
+	    syscas->is_space  == ASE_NULL ||
+	    syscas->is_print  == ASE_NULL ||
+	    syscas->is_graph  == ASE_NULL ||
+	    syscas->is_cntrl  == ASE_NULL ||
+	    syscas->is_punct  == ASE_NULL ||
+	    syscas->to_upper  == ASE_NULL ||
+	    syscas->to_lower  == ASE_NULL) return ASE_NULL;
 
-	if (syscas->sprintf == SSE_NULL || 
-	    syscas->dprintf == SSE_NULL || 
-	    syscas->abort == SSE_NULL) return SSE_NULL;
+	if (syscas->sprintf == ASE_NULL || 
+	    syscas->dprintf == ASE_NULL || 
+	    syscas->abort == ASE_NULL) return ASE_NULL;
 
 #if defined(_WIN32) && defined(_DEBUG)
-	awk = (sse_awk_t*) malloc (sse_sizeof(sse_awk_t));
+	awk = (ase_awk_t*) malloc (ase_sizeof(ase_awk_t));
 #else
-	awk = (sse_awk_t*) syscas->malloc (
-		sse_sizeof(sse_awk_t), syscas->custom_data);
+	awk = (ase_awk_t*) syscas->malloc (
+		ase_sizeof(ase_awk_t), syscas->custom_data);
 #endif
-	if (awk == SSE_NULL) return SSE_NULL;
+	if (awk == ASE_NULL) return ASE_NULL;
 
-	/* it uses the built-in sse_awk_memset because awk is not 
+	/* it uses the built-in ase_awk_memset because awk is not 
 	 * fully initialized yet */
-	sse_awk_memset (awk, 0, sse_sizeof(sse_awk_t));
+	ase_awk_memset (awk, 0, ase_sizeof(ase_awk_t));
 
-	if (syscas->memcpy == SSE_NULL)
+	if (syscas->memcpy == ASE_NULL)
 	{
-		sse_awk_memcpy (&awk->syscas, syscas, sse_sizeof(awk->syscas));
-		awk->syscas.memcpy = sse_awk_memcpy;
+		ase_awk_memcpy (&awk->syscas, syscas, ase_sizeof(awk->syscas));
+		awk->syscas.memcpy = ase_awk_memcpy;
 	}
-	else syscas->memcpy (&awk->syscas, syscas, sse_sizeof(awk->syscas));
-	if (syscas->memset == SSE_NULL) awk->syscas.memset = sse_awk_memset;
+	else syscas->memcpy (&awk->syscas, syscas, ase_sizeof(awk->syscas));
+	if (syscas->memset == ASE_NULL) awk->syscas.memset = ase_awk_memset;
 
-	if (sse_awk_str_open (&awk->token.name, 128, awk) == SSE_NULL) 
+	if (ase_awk_str_open (&awk->token.name, 128, awk) == ASE_NULL) 
 	{
-		SSE_AWK_FREE (awk, awk);
-		return SSE_NULL;	
+		ASE_AWK_FREE (awk, awk);
+		return ASE_NULL;	
 	}
 
 	/* TODO: initial map size?? */
-	if (sse_awk_map_open (
-		&awk->tree.afns, awk, 256, __free_afn, awk) == SSE_NULL) 
+	if (ase_awk_map_open (
+		&awk->tree.afns, awk, 256, __free_afn, awk) == ASE_NULL) 
 	{
-		sse_awk_str_close (&awk->token.name);
-		SSE_AWK_FREE (awk, awk);
-		return SSE_NULL;	
+		ase_awk_str_close (&awk->token.name);
+		ASE_AWK_FREE (awk, awk);
+		return ASE_NULL;	
 	}
 
-	if (sse_awk_tab_open (&awk->parse.globals, awk) == SSE_NULL) 
+	if (ase_awk_tab_open (&awk->parse.globals, awk) == ASE_NULL) 
 	{
-		sse_awk_str_close (&awk->token.name);
-		sse_awk_map_close (&awk->tree.afns);
-		SSE_AWK_FREE (awk, awk);
-		return SSE_NULL;	
+		ase_awk_str_close (&awk->token.name);
+		ase_awk_map_close (&awk->tree.afns);
+		ASE_AWK_FREE (awk, awk);
+		return ASE_NULL;	
 	}
 
-	if (sse_awk_tab_open (&awk->parse.locals, awk) == SSE_NULL) 
+	if (ase_awk_tab_open (&awk->parse.locals, awk) == ASE_NULL) 
 	{
-		sse_awk_str_close (&awk->token.name);
-		sse_awk_map_close (&awk->tree.afns);
-		sse_awk_tab_close (&awk->parse.globals);
-		SSE_AWK_FREE (awk, awk);
-		return SSE_NULL;	
+		ase_awk_str_close (&awk->token.name);
+		ase_awk_map_close (&awk->tree.afns);
+		ase_awk_tab_close (&awk->parse.globals);
+		ASE_AWK_FREE (awk, awk);
+		return ASE_NULL;	
 	}
 
-	if (sse_awk_tab_open (&awk->parse.params, awk) == SSE_NULL) 
+	if (ase_awk_tab_open (&awk->parse.params, awk) == ASE_NULL) 
 	{
-		sse_awk_str_close (&awk->token.name);
-		sse_awk_map_close (&awk->tree.afns);
-		sse_awk_tab_close (&awk->parse.globals);
-		sse_awk_tab_close (&awk->parse.locals);
-		SSE_AWK_FREE (awk, awk);
-		return SSE_NULL;	
+		ase_awk_str_close (&awk->token.name);
+		ase_awk_map_close (&awk->tree.afns);
+		ase_awk_tab_close (&awk->parse.globals);
+		ase_awk_tab_close (&awk->parse.locals);
+		ASE_AWK_FREE (awk, awk);
+		return ASE_NULL;	
 	}
 
 	awk->option = 0;
-	awk->errnum = SSE_AWK_ENOERR;
+	awk->errnum = ASE_AWK_ENOERR;
 
 	awk->parse.nlocals_max = 0;
 	awk->parse.nl_semicolon = 0;
 
 	awk->tree.nglobals = 0;
 	awk->tree.nbglobals = 0;
-	awk->tree.begin = SSE_NULL;
-	awk->tree.end = SSE_NULL;
-	awk->tree.chain = SSE_NULL;
-	awk->tree.chain_tail = SSE_NULL;
+	awk->tree.begin = ASE_NULL;
+	awk->tree.end = ASE_NULL;
+	awk->tree.chain = ASE_NULL;
+	awk->tree.chain_tail = ASE_NULL;
 	awk->tree.chain_size = 0;
 
 	awk->token.prev = 0;
@@ -119,48 +119,48 @@ sse_awk_t* sse_awk_open (const sse_awk_syscas_t* syscas)
 	awk->token.line = 0;
 	awk->token.column = 0;
 
-	awk->src.ios = SSE_NULL;
-	awk->src.lex.curc = SSE_CHAR_EOF;
+	awk->src.ios = ASE_NULL;
+	awk->src.lex.curc = ASE_CHAR_EOF;
 	awk->src.lex.ungotc_count = 0;
 	awk->src.lex.line = 1;
 	awk->src.lex.column = 1;
 	awk->src.shared.buf_pos = 0;
 	awk->src.shared.buf_len = 0;
 
-	awk->bfn.sys = SSE_NULL;
-	awk->bfn.user = SSE_NULL;
+	awk->bfn.sys = ASE_NULL;
+	awk->bfn.user = ASE_NULL;
 
 	awk->run.count = 0;
-	awk->run.ptr = SSE_NULL;
+	awk->run.ptr = ASE_NULL;
 
 	return awk;
 }
 
-int sse_awk_close (sse_awk_t* awk)
+int ase_awk_close (ase_awk_t* awk)
 {
-	if (sse_awk_clear (awk) == -1) return -1;
+	if (ase_awk_clear (awk) == -1) return -1;
 
-	sse_awk_assert (awk, awk->run.count == 0 && awk->run.ptr == SSE_NULL);
+	ase_awk_assert (awk, awk->run.count == 0 && awk->run.ptr == ASE_NULL);
 
-	sse_awk_map_close (&awk->tree.afns);
-	sse_awk_tab_close (&awk->parse.globals);
-	sse_awk_tab_close (&awk->parse.locals);
-	sse_awk_tab_close (&awk->parse.params);
-	sse_awk_str_close (&awk->token.name);
+	ase_awk_map_close (&awk->tree.afns);
+	ase_awk_tab_close (&awk->parse.globals);
+	ase_awk_tab_close (&awk->parse.locals);
+	ase_awk_tab_close (&awk->parse.params);
+	ase_awk_str_close (&awk->token.name);
 
-	/* SSE_AWK_ALLOC, SSE_AWK_FREE, etc can not be used 
+	/* ASE_AWK_ALLOC, ASE_AWK_FREE, etc can not be used 
 	 * from the next line onwards */
-	SSE_AWK_FREE (awk, awk);
+	ASE_AWK_FREE (awk, awk);
 	return 0;
 }
 
-int sse_awk_clear (sse_awk_t* awk)
+int ase_awk_clear (ase_awk_t* awk)
 {
 	/* you should stop all running instances beforehand */
 /* TODO: can i stop all instances??? */
-	if (awk->run.ptr != SSE_NULL)
+	if (awk->run.ptr != ASE_NULL)
 	{
-		awk->errnum = SSE_AWK_ERUNNING;
+		awk->errnum = ASE_AWK_ERUNNING;
 		return -1;
 	}
 
@@ -169,17 +169,17 @@ int sse_awk_clear (sse_awk_t* awk)
 	awk->bfn.user
 */
 
-	awk->src.ios = SSE_NULL;
-	awk->src.lex.curc = SSE_CHAR_EOF;
+	awk->src.ios = ASE_NULL;
+	awk->src.lex.curc = ASE_CHAR_EOF;
 	awk->src.lex.ungotc_count = 0;
 	awk->src.lex.line = 1;
 	awk->src.lex.column = 1;
 	awk->src.shared.buf_pos = 0;
 	awk->src.shared.buf_len = 0;
 
-	sse_awk_tab_clear (&awk->parse.globals);
-	sse_awk_tab_clear (&awk->parse.locals);
-	sse_awk_tab_clear (&awk->parse.params);
+	ase_awk_tab_clear (&awk->parse.globals);
+	ase_awk_tab_clear (&awk->parse.locals);
+	ase_awk_tab_clear (&awk->parse.params);
 
 	awk->parse.nlocals_max = 0; 
 	awk->parse.depth.loop = 0;
@@ -187,60 +187,60 @@ int sse_awk_clear (sse_awk_t* awk)
 	/* clear parse trees */	
 	awk->tree.nbglobals = 0;
 	awk->tree.nglobals = 0;	
-	sse_awk_map_clear (&awk->tree.afns);
+	ase_awk_map_clear (&awk->tree.afns);
 
-	if (awk->tree.begin != SSE_NULL) 
+	if (awk->tree.begin != ASE_NULL) 
 	{
-		sse_awk_assert (awk, awk->tree.begin->next == SSE_NULL);
-		sse_awk_clrpt (awk, awk->tree.begin);
-		awk->tree.begin = SSE_NULL;
+		ase_awk_assert (awk, awk->tree.begin->next == ASE_NULL);
+		ase_awk_clrpt (awk, awk->tree.begin);
+		awk->tree.begin = ASE_NULL;
 	}
 
-	if (awk->tree.end != SSE_NULL) 
+	if (awk->tree.end != ASE_NULL) 
 	{
-		sse_awk_assert (awk, awk->tree.end->next == SSE_NULL);
-		sse_awk_clrpt (awk, awk->tree.end);
-		awk->tree.end = SSE_NULL;
+		ase_awk_assert (awk, awk->tree.end->next == ASE_NULL);
+		ase_awk_clrpt (awk, awk->tree.end);
+		awk->tree.end = ASE_NULL;
 	}
 
-	while (awk->tree.chain != SSE_NULL) 
+	while (awk->tree.chain != ASE_NULL) 
 	{
-		sse_awk_chain_t* next = awk->tree.chain->next;
-		if (awk->tree.chain->pattern != SSE_NULL)
-			sse_awk_clrpt (awk, awk->tree.chain->pattern);
-		if (awk->tree.chain->action != SSE_NULL)
-			sse_awk_clrpt (awk, awk->tree.chain->action);
-		SSE_AWK_FREE (awk, awk->tree.chain);
+		ase_awk_chain_t* next = awk->tree.chain->next;
+		if (awk->tree.chain->pattern != ASE_NULL)
+			ase_awk_clrpt (awk, awk->tree.chain->pattern);
+		if (awk->tree.chain->action != ASE_NULL)
+			ase_awk_clrpt (awk, awk->tree.chain->action);
+		ASE_AWK_FREE (awk, awk->tree.chain);
 		awk->tree.chain = next;
 	}
 
-	awk->tree.chain_tail = SSE_NULL;	
+	awk->tree.chain_tail = ASE_NULL;	
 	awk->tree.chain_size = 0;
 	return 0;
 }
 
-int sse_awk_getopt (sse_awk_t* awk)
+int ase_awk_getopt (ase_awk_t* awk)
 {
 	return awk->option;
 }
 
-void sse_awk_setopt (sse_awk_t* awk, int opt)
+void ase_awk_setopt (ase_awk_t* awk, int opt)
 {
 	awk->option = opt;
 }
 
 static void __free_afn (void* owner, void* afn)
 {
-	sse_awk_afn_t* f = (sse_awk_afn_t*)afn;
+	ase_awk_afn_t* f = (ase_awk_afn_t*)afn;
 
 	/* f->name doesn't have to be freed */
-	/*SSE_AWK_FREE ((sse_awk_t*)owner, f->name);*/
+	/*ASE_AWK_FREE ((ase_awk_t*)owner, f->name);*/
 
-	sse_awk_clrpt ((sse_awk_t*)owner, f->body);
-	SSE_AWK_FREE ((sse_awk_t*)owner, f);
+	ase_awk_clrpt ((ase_awk_t*)owner, f->body);
+	ASE_AWK_FREE ((ase_awk_t*)owner, f);
 }
 
-sse_size_t sse_awk_getsrcline (sse_awk_t* awk)
+ase_size_t ase_awk_getsrcline (ase_awk_t* awk)
 {
 	return awk->token.line;
 }
diff --git a/ase/awk/awk.h b/ase/awk/awk.h
index beb21dcb..75476764 100644
--- a/ase/awk/awk.h
+++ b/ase/awk/awk.h
@@ -1,34 +1,34 @@
 /* 
- * $Id: awk.h,v 1.132 2006-10-23 14:44:42 bacon Exp $
+ * $Id: awk.h,v 1.133 2006-10-24 04:10:12 bacon Exp $
  */
 
-#ifndef _SSE_AWK_AWK_H_
-#define _SSE_AWK_AWK_H_
+#ifndef _ASE_AWK_AWK_H_
+#define _ASE_AWK_AWK_H_
 
-#include <sse/types.h>
-#include <sse/macros.h>
+#include <ase/types.h>
+#include <ase/macros.h>
 
-typedef struct sse_awk_t sse_awk_t;
-typedef struct sse_awk_run_t sse_awk_run_t;
-typedef struct sse_awk_val_t sse_awk_val_t;
-typedef struct sse_awk_extio_t sse_awk_extio_t;
+typedef struct ase_awk_t ase_awk_t;
+typedef struct ase_awk_run_t ase_awk_run_t;
+typedef struct ase_awk_val_t ase_awk_val_t;
+typedef struct ase_awk_extio_t ase_awk_extio_t;
 
-typedef struct sse_awk_syscas_t sse_awk_syscas_t;
-typedef struct sse_awk_srcios_t sse_awk_srcios_t;
-typedef struct sse_awk_runios_t sse_awk_runios_t;
-typedef struct sse_awk_runcbs_t sse_awk_runcbs_t;
-typedef struct sse_awk_runarg_t sse_awk_runarg_t;
+typedef struct ase_awk_syscas_t ase_awk_syscas_t;
+typedef struct ase_awk_srcios_t ase_awk_srcios_t;
+typedef struct ase_awk_runios_t ase_awk_runios_t;
+typedef struct ase_awk_runcbs_t ase_awk_runcbs_t;
+typedef struct ase_awk_runarg_t ase_awk_runarg_t;
 
-typedef void (*sse_awk_lk_t) (sse_awk_t* awk, void* arg);
-typedef sse_ssize_t (*sse_awk_io_t) (
-	int cmd, void* arg, sse_char_t* data, sse_size_t count);
+typedef void (*ase_awk_lk_t) (ase_awk_t* awk, void* arg);
+typedef ase_ssize_t (*ase_awk_io_t) (
+	int cmd, void* arg, ase_char_t* data, ase_size_t count);
 
-struct sse_awk_extio_t 
+struct ase_awk_extio_t 
 {
-	sse_awk_run_t* run; /* [IN] */
+	ase_awk_run_t* run; /* [IN] */
 	int type;          /* [IN] console, file, coproc, pipe */
 	int mode;          /* [IN] read, write, etc */
-	sse_char_t* name;   /* [IN] */
+	ase_char_t* name;   /* [IN] */
 	void* custom_data; /* [IN] */
 
 	void* handle;      /* [OUT] */
@@ -36,147 +36,147 @@ struct sse_awk_extio_t
 	/* input buffer */
 	struct
 	{
-		sse_char_t buf[2048];
-		sse_size_t pos;
-		sse_size_t len;
-		sse_bool_t eof;
+		ase_char_t buf[2048];
+		ase_size_t pos;
+		ase_size_t len;
+		ase_bool_t eof;
 	} in;
 
-	sse_awk_extio_t* next;
+	ase_awk_extio_t* next;
 };
 
-struct sse_awk_syscas_t
+struct ase_awk_syscas_t
 {
 	/* memory */
-	void* (*malloc) (sse_size_t n, void* custom_data);
-	void* (*realloc) (void* ptr, sse_size_t n, void* custom_data);
+	void* (*malloc) (ase_size_t n, void* custom_data);
+	void* (*realloc) (void* ptr, ase_size_t n, void* custom_data);
 	void  (*free) (void* ptr, void* custom_data);
 
 	/* thread lock */
-	sse_awk_lk_t lock;
-	sse_awk_lk_t unlock;
+	ase_awk_lk_t lock;
+	ase_awk_lk_t unlock;
 
 	/* character class */
-	sse_bool_t (*is_upper)  (sse_cint_t c);
-	sse_bool_t (*is_lower)  (sse_cint_t c);
-	sse_bool_t (*is_alpha)  (sse_cint_t c);
-	sse_bool_t (*is_digit)  (sse_cint_t c);
-	sse_bool_t (*is_xdigit) (sse_cint_t c);
-	sse_bool_t (*is_alnum)  (sse_cint_t c);
-	sse_bool_t (*is_space)  (sse_cint_t c);
-	sse_bool_t (*is_print)  (sse_cint_t c);
-	sse_bool_t (*is_graph)  (sse_cint_t c);
-	sse_bool_t (*is_cntrl)  (sse_cint_t c);
-	sse_bool_t (*is_punct)  (sse_cint_t c);
-	sse_cint_t (*to_upper)  (sse_cint_t c);
-	sse_cint_t (*to_lower)  (sse_cint_t c);
+	ase_bool_t (*is_upper)  (ase_cint_t c);
+	ase_bool_t (*is_lower)  (ase_cint_t c);
+	ase_bool_t (*is_alpha)  (ase_cint_t c);
+	ase_bool_t (*is_digit)  (ase_cint_t c);
+	ase_bool_t (*is_xdigit) (ase_cint_t c);
+	ase_bool_t (*is_alnum)  (ase_cint_t c);
+	ase_bool_t (*is_space)  (ase_cint_t c);
+	ase_bool_t (*is_print)  (ase_cint_t c);
+	ase_bool_t (*is_graph)  (ase_cint_t c);
+	ase_bool_t (*is_cntrl)  (ase_cint_t c);
+	ase_bool_t (*is_punct)  (ase_cint_t c);
+	ase_cint_t (*to_upper)  (ase_cint_t c);
+	ase_cint_t (*to_lower)  (ase_cint_t c);
 
 	/* utilities */
-	void* (*memcpy)  (void* dst, const void* src, sse_size_t n);
-	void* (*memset)  (void* dst, int val, sse_size_t n);
+	void* (*memcpy)  (void* dst, const void* src, ase_size_t n);
+	void* (*memset)  (void* dst, int val, ase_size_t n);
 
-	int (*sprintf) (sse_char_t* buf, sse_size_t size, sse_char_t* fmt, ...);
-	int (*dprintf) (sse_char_t* fmt, ...);
+	int (*sprintf) (ase_char_t* buf, ase_size_t size, ase_char_t* fmt, ...);
+	int (*dprintf) (ase_char_t* fmt, ...);
 	void (*abort) (void);
 
 	void* custom_data;
 };
 
-struct sse_awk_srcios_t
+struct ase_awk_srcios_t
 {
-	sse_awk_io_t in;
-	sse_awk_io_t out;
+	ase_awk_io_t in;
+	ase_awk_io_t out;
 	void* custom_data;
 };
 
-struct sse_awk_runios_t
+struct ase_awk_runios_t
 {
-	sse_awk_io_t pipe;
-	sse_awk_io_t coproc;
-	sse_awk_io_t file;
-	sse_awk_io_t console;
+	ase_awk_io_t pipe;
+	ase_awk_io_t coproc;
+	ase_awk_io_t file;
+	ase_awk_io_t console;
 	void* custom_data;
 };
 
-struct sse_awk_runcbs_t
+struct ase_awk_runcbs_t
 {
-	void (*on_start) (sse_awk_t* awk, void* handle, void* arg);
-	void (*on_end) (sse_awk_t* awk, void* handle, int errnum, void* arg);
+	void (*on_start) (ase_awk_t* awk, void* handle, void* arg);
+	void (*on_end) (ase_awk_t* awk, void* handle, int errnum, void* arg);
 	void* custom_data;
 };
 
-struct sse_awk_runarg_t
+struct ase_awk_runarg_t
 {
-	const sse_char_t* ptr;
-	sse_size_t len;
+	const ase_char_t* ptr;
+	ase_size_t len;
 };
 
 /* io function commands */
 enum 
 {
-	SSE_AWK_IO_OPEN   = 0,
-	SSE_AWK_IO_CLOSE  = 1,
-	SSE_AWK_IO_READ   = 2,
-	SSE_AWK_IO_WRITE  = 3,
-	SSE_AWK_IO_FLUSH  = 4,
-	SSE_AWK_IO_NEXT   = 5  
+	ASE_AWK_IO_OPEN   = 0,
+	ASE_AWK_IO_CLOSE  = 1,
+	ASE_AWK_IO_READ   = 2,
+	ASE_AWK_IO_WRITE  = 3,
+	ASE_AWK_IO_FLUSH  = 4,
+	ASE_AWK_IO_NEXT   = 5  
 };
 
 enum
 {
-	SSE_AWK_IO_PIPE_READ      = 0,
-	SSE_AWK_IO_PIPE_WRITE     = 1,
+	ASE_AWK_IO_PIPE_READ      = 0,
+	ASE_AWK_IO_PIPE_WRITE     = 1,
 
-	SSE_AWK_IO_FILE_READ      = 0,
-	SSE_AWK_IO_FILE_WRITE     = 1,
-	SSE_AWK_IO_FILE_APPEND    = 2,
+	ASE_AWK_IO_FILE_READ      = 0,
+	ASE_AWK_IO_FILE_WRITE     = 1,
+	ASE_AWK_IO_FILE_APPEND    = 2,
 
-	SSE_AWK_IO_CONSOLE_READ   = 0,
-	SSE_AWK_IO_CONSOLE_WRITE  = 1
+	ASE_AWK_IO_CONSOLE_READ   = 0,
+	ASE_AWK_IO_CONSOLE_WRITE  = 1
 };
 
 /* various options */
 enum 
 { 
 	/* allow undeclared variables */
-	SSE_AWK_IMPLICIT    = (1 << 0),
+	ASE_AWK_IMPLICIT    = (1 << 0),
 
 	/* variable requires explicit declaration */
-	SSE_AWK_EXPLICIT    = (1 << 1), 
+	ASE_AWK_EXPLICIT    = (1 << 1), 
 
 	/* a function name should not coincide to be a variable name */
-	SSE_AWK_UNIQUE      = (1 << 2),
+	ASE_AWK_UNIQUE      = (1 << 2),
 
 	/* allow variable shading */
-	SSE_AWK_SHADING     = (1 << 3), 
+	ASE_AWK_SHADING     = (1 << 3), 
 
 	/* support shift operators */
-	SSE_AWK_SHIFT       = (1 << 4), 
+	ASE_AWK_SHIFT       = (1 << 4), 
 
 	/* support comments by a hash sign */
-	SSE_AWK_HASHSIGN    = (1 << 5), 
+	ASE_AWK_HASHSIGN    = (1 << 5), 
 
 	/* support comments by double slashes */
-	SSE_AWK_DBLSLASHES  = (1 << 6), 
+	ASE_AWK_DBLSLASHES  = (1 << 6), 
 
 	/* support string concatenation in tokenization.
 	 * this option can change the behavior of a certain construct.
 	 * getline < "abc" ".def" is treated as if it is getline < "abc.def" 
 	 * when this option is on. If this option is off, the same expression
 	 * is treated as if it is (getline < "abc") ".def". */
-	SSE_AWK_STRCONCAT   = (1 << 7), 
+	ASE_AWK_STRCONCAT   = (1 << 7), 
 
 	/* support getline and print */
-	SSE_AWK_EXTIO       = (1 << 8), 
+	ASE_AWK_EXTIO       = (1 << 8), 
 
 	/* support blockless patterns */
-	SSE_AWK_BLOCKLESS   = (1 << 9), 
+	ASE_AWK_BLOCKLESS   = (1 << 9), 
 
  	/* execution starts from main */
-	SSE_AWK_RUNMAIN     = (1 << 10),
+	ASE_AWK_RUNMAIN     = (1 << 10),
 
 	/* use 1 as the start index for string operations */
-	SSE_AWK_STRINDEXONE = (1 << 11),
+	ASE_AWK_STRINDEXONE = (1 << 11),
 
 	/* strip off leading and trailing spaces when splitting a record
 	 * into fields with a regular expression.
@@ -191,228 +191,228 @@ enum
 	 * The program splits " a b c " into [a], [b], [c] when this
 	 * option is on while into [], [a], [b], [c], [] when it is off.
 	 */
-	SSE_AWK_STRIPSPACES = (1 << 12),
+	ASE_AWK_STRIPSPACES = (1 << 12),
 
 	/* a newline terminates a statement */
-	SSE_AWK_NEWLINE = (1 << 13)
+	ASE_AWK_NEWLINE = (1 << 13)
 };
 
 /* error code */
 enum 
 {
-	SSE_AWK_ENOERR,         /* no error */
-	SSE_AWK_ENOMEM,         /* out of memory */
-	SSE_AWK_EINVAL,         /* invalid parameter */
-	SSE_AWK_ERUNTIME,       /* run-time error */
-	SSE_AWK_ERUNNING,       /* there are running instances */
-	SSE_AWK_ETOOMANYRUNS,   /* too many running instances */
-	SSE_AWK_ERECURSION,     /* recursion too deep */
+	ASE_AWK_ENOERR,         /* no error */
+	ASE_AWK_ENOMEM,         /* out of memory */
+	ASE_AWK_EINVAL,         /* invalid parameter */
+	ASE_AWK_ERUNTIME,       /* run-time error */
+	ASE_AWK_ERUNNING,       /* there are running instances */
+	ASE_AWK_ETOOMANYRUNS,   /* too many running instances */
+	ASE_AWK_ERECURSION,     /* recursion too deep */
 
-	SSE_AWK_ESRCINOPEN,
-	SSE_AWK_ESRCINCLOSE,
-	SSE_AWK_ESRCINREAD, 
+	ASE_AWK_ESRCINOPEN,
+	ASE_AWK_ESRCINCLOSE,
+	ASE_AWK_ESRCINREAD, 
 
-	SSE_AWK_ESRCOUTOPEN,
-	SSE_AWK_ESRCOUTCLOSE,
-	SSE_AWK_ESRCOUTWRITE,
+	ASE_AWK_ESRCOUTOPEN,
+	ASE_AWK_ESRCOUTCLOSE,
+	ASE_AWK_ESRCOUTWRITE,
 
-	SSE_AWK_ECONINOPEN,
-	SSE_AWK_ECONINCLOSE,
-	SSE_AWK_ECONINNEXT,
-	SSE_AWK_ECONINDATA, 
+	ASE_AWK_ECONINOPEN,
+	ASE_AWK_ECONINCLOSE,
+	ASE_AWK_ECONINNEXT,
+	ASE_AWK_ECONINDATA, 
 
-	SSE_AWK_ECONOUTOPEN,
-	SSE_AWK_ECONOUTCLOSE,
-	SSE_AWK_ECONOUTNEXT,
-	SSE_AWK_ECONOUTDATA,
+	ASE_AWK_ECONOUTOPEN,
+	ASE_AWK_ECONOUTCLOSE,
+	ASE_AWK_ECONOUTNEXT,
+	ASE_AWK_ECONOUTDATA,
 
-	SSE_AWK_ELXCHR,         /* lexer came accross an wrong character */
-	SSE_AWK_ELXUNG,         /* lexer failed to unget a character */
+	ASE_AWK_ELXCHR,         /* lexer came accross an wrong character */
+	ASE_AWK_ELXUNG,         /* lexer failed to unget a character */
 
-	SSE_AWK_EENDSRC,        /* unexpected end of source */
-	SSE_AWK_EENDCOMMENT,    /* unexpected end of a comment */
-	SSE_AWK_EENDSTR,        /* unexpected end of a string */
-	SSE_AWK_EENDREX,        /* unexpected end of a regular expression */
-	SSE_AWK_ELBRACE,        /* left brace expected */
-	SSE_AWK_ELPAREN,        /* left parenthesis expected */
-	SSE_AWK_ERPAREN,        /* right parenthesis expected */
-	SSE_AWK_ERBRACK,        /* right bracket expected */
-	SSE_AWK_ECOMMA,         /* comma expected */
-	SSE_AWK_ESEMICOLON,     /* semicolon expected */
-	SSE_AWK_ECOLON,         /* colon expected */
-	SSE_AWK_EIN,            /* keyword 'in' is expected */
-	SSE_AWK_ENOTVAR,        /* not a variable name after 'in' */
-	SSE_AWK_EEXPRESSION,    /* expression expected */
+	ASE_AWK_EENDSRC,        /* unexpected end of source */
+	ASE_AWK_EENDCOMMENT,    /* unexpected end of a comment */
+	ASE_AWK_EENDSTR,        /* unexpected end of a string */
+	ASE_AWK_EENDREX,        /* unexpected end of a regular expression */
+	ASE_AWK_ELBRACE,        /* left brace expected */
+	ASE_AWK_ELPAREN,        /* left parenthesis expected */
+	ASE_AWK_ERPAREN,        /* right parenthesis expected */
+	ASE_AWK_ERBRACK,        /* right bracket expected */
+	ASE_AWK_ECOMMA,         /* comma expected */
+	ASE_AWK_ESEMICOLON,     /* semicolon expected */
+	ASE_AWK_ECOLON,         /* colon expected */
+	ASE_AWK_EIN,            /* keyword 'in' is expected */
+	ASE_AWK_ENOTVAR,        /* not a variable name after 'in' */
+	ASE_AWK_EEXPRESSION,    /* expression expected */
 
-	SSE_AWK_EWHILE,         /* keyword 'while' is expected */
-	SSE_AWK_EASSIGNMENT,    /* assignment statement expected */
-	SSE_AWK_EIDENT,         /* identifier expected */
-	SSE_AWK_EBEGINBLOCK,    /* BEGIN requires an action block */
-	SSE_AWK_EENDBLOCK,      /* END requires an action block */
-	SSE_AWK_EDUPBEGIN,      /* duplicate BEGIN */
-	SSE_AWK_EDUPEND,        /* duplicate END */
-	SSE_AWK_EDUPFUNC,       /* duplicate function name */
-	SSE_AWK_EDUPPARAM,      /* duplicate parameter name */
-	SSE_AWK_EDUPVAR,        /* duplicate variable name */
-	SSE_AWK_EDUPNAME,       /* duplicate name - function, variable, etc */
-	SSE_AWK_EUNDEF,         /* undefined identifier */
-	SSE_AWK_ELVALUE,        /* l-value required */
-	SSE_AWK_ETOOFEWARGS,    /* too few arguments */
-	SSE_AWK_ETOOMANYARGS,   /* too many arguments */
-	SSE_AWK_ETOOMANYGLOBALS, /* too many global variables */
-	SSE_AWK_ETOOMANYLOCALS, /* too many local variables */
-	SSE_AWK_ETOOMANYPARAMS, /* too many parameters */
-	SSE_AWK_EBREAK,         /* break outside a loop */
-	SSE_AWK_ECONTINUE,      /* continue outside a loop */
-	SSE_AWK_ENEXT,          /* next illegal in BEGIN or END block */
-	SSE_AWK_ENEXTFILE,      /* nextfile illegal in BEGIN or END block */
-	SSE_AWK_EGETLINE,       /* getline expected */
+	ASE_AWK_EWHILE,         /* keyword 'while' is expected */
+	ASE_AWK_EASSIGNMENT,    /* assignment statement expected */
+	ASE_AWK_EIDENT,         /* identifier expected */
+	ASE_AWK_EBEGINBLOCK,    /* BEGIN requires an action block */
+	ASE_AWK_EENDBLOCK,      /* END requires an action block */
+	ASE_AWK_EDUPBEGIN,      /* duplicate BEGIN */
+	ASE_AWK_EDUPEND,        /* duplicate END */
+	ASE_AWK_EDUPFUNC,       /* duplicate function name */
+	ASE_AWK_EDUPPARAM,      /* duplicate parameter name */
+	ASE_AWK_EDUPVAR,        /* duplicate variable name */
+	ASE_AWK_EDUPNAME,       /* duplicate name - function, variable, etc */
+	ASE_AWK_EUNDEF,         /* undefined identifier */
+	ASE_AWK_ELVALUE,        /* l-value required */
+	ASE_AWK_ETOOFEWARGS,    /* too few arguments */
+	ASE_AWK_ETOOMANYARGS,   /* too many arguments */
+	ASE_AWK_ETOOMANYGLOBALS, /* too many global variables */
+	ASE_AWK_ETOOMANYLOCALS, /* too many local variables */
+	ASE_AWK_ETOOMANYPARAMS, /* too many parameters */
+	ASE_AWK_EBREAK,         /* break outside a loop */
+	ASE_AWK_ECONTINUE,      /* continue outside a loop */
+	ASE_AWK_ENEXT,          /* next illegal in BEGIN or END block */
+	ASE_AWK_ENEXTFILE,      /* nextfile illegal in BEGIN or END block */
+	ASE_AWK_EGETLINE,       /* getline expected */
 
 	/* run time error */
-	SSE_AWK_EDIVBYZERO,        /* divide by zero */
-	SSE_AWK_EOPERAND,          /* invalid operand */
-	SSE_AWK_EPOSIDX,           /* wrong position index */
-	SSE_AWK_ENOSUCHFUNC,       /* no such function */
-	SSE_AWK_ENOTASSIGNABLE,    /* value not assignable */
-	SSE_AWK_ENOTINDEXABLE,     /* not indexable variable */
-	SSE_AWK_ENOTDELETABLE,     /* not deletable variable */
-	SSE_AWK_ENOTREFERENCEABLE, /* not referenceable value */
-	SSE_AWK_EIDXVALASSMAP,     /* indexed value cannot be assigned a map */
-	SSE_AWK_EPOSVALASSMAP,     /* a positional cannot be assigned a map */
-	SSE_AWK_EMAPTOSCALAR,      /* cannot change a map to a scalar value */
-	SSE_AWK_ESCALARTOMAP,      /* cannot change a scalar value to a map */
-	SSE_AWK_EMAPNOTALLOWED,    /* a map is not allowed */
-	SSE_AWK_EVALTYPE,          /* wrong value type */
-	SSE_AWK_EPIPE,             /* pipe operation error */
-	SSE_AWK_ENEXTCALL,         /* next called from BEGIN or END */
-	SSE_AWK_ENEXTFILECALL,     /* nextfile called from BEGIN or END */
-	SSE_AWK_EIOIMPL,           /* wrong implementation of user io handler */
-	SSE_AWK_ENOSUCHIO,         /* no such io name found */
-	SSE_AWK_EIOHANDLER,        /* io handler has returned an error */
-	SSE_AWK_EINTERNAL,         /* internal error */
+	ASE_AWK_EDIVBYZERO,        /* divide by zero */
+	ASE_AWK_EOPERAND,          /* invalid operand */
+	ASE_AWK_EPOSIDX,           /* wrong position index */
+	ASE_AWK_ENOSUCHFUNC,       /* no such function */
+	ASE_AWK_ENOTASSIGNABLE,    /* value not assignable */
+	ASE_AWK_ENOTINDEXABLE,     /* not indexable variable */
+	ASE_AWK_ENOTDELETABLE,     /* not deletable variable */
+	ASE_AWK_ENOTREFERENCEABLE, /* not referenceable value */
+	ASE_AWK_EIDXVALASSMAP,     /* indexed value cannot be assigned a map */
+	ASE_AWK_EPOSVALASSMAP,     /* a positional cannot be assigned a map */
+	ASE_AWK_EMAPTOSCALAR,      /* cannot change a map to a scalar value */
+	ASE_AWK_ESCALARTOMAP,      /* cannot change a scalar value to a map */
+	ASE_AWK_EMAPNOTALLOWED,    /* a map is not allowed */
+	ASE_AWK_EVALTYPE,          /* wrong value type */
+	ASE_AWK_EPIPE,             /* pipe operation error */
+	ASE_AWK_ENEXTCALL,         /* next called from BEGIN or END */
+	ASE_AWK_ENEXTFILECALL,     /* nextfile called from BEGIN or END */
+	ASE_AWK_EIOIMPL,           /* wrong implementation of user io handler */
+	ASE_AWK_ENOSUCHIO,         /* no such io name found */
+	ASE_AWK_EIOHANDLER,        /* io handler has returned an error */
+	ASE_AWK_EINTERNAL,         /* internal error */
 
 	/* regular expression error */
-	SSE_AWK_EREXRPAREN,       /* a right parenthesis is expected */
-	SSE_AWK_EREXRBRACKET,     /* a right bracket is expected */
-	SSE_AWK_EREXRBRACE,       /* a right brace is expected */
-	SSE_AWK_EREXCOLON,        /* a colon is expected */
-	SSE_AWK_EREXCRANGE,       /* invalid character range */
-	SSE_AWK_EREXCCLASS,       /* invalid character class */
-	SSE_AWK_EREXBRANGE,       /* invalid boundary range */
-	SSE_AWK_EREXEND,          /* unexpected end of the pattern */
-	SSE_AWK_EREXGARBAGE       /* garbage after the pattern */
+	ASE_AWK_EREXRPAREN,       /* a right parenthesis is expected */
+	ASE_AWK_EREXRBRACKET,     /* a right bracket is expected */
+	ASE_AWK_EREXRBRACE,       /* a right brace is expected */
+	ASE_AWK_EREXCOLON,        /* a colon is expected */
+	ASE_AWK_EREXCRANGE,       /* invalid character range */
+	ASE_AWK_EREXCCLASS,       /* invalid character class */
+	ASE_AWK_EREXBRANGE,       /* invalid boundary range */
+	ASE_AWK_EREXEND,          /* unexpected end of the pattern */
+	ASE_AWK_EREXGARBAGE       /* garbage after the pattern */
 };
 
 /* extio types */
 enum
 {
 	/* extio types available */
-	SSE_AWK_EXTIO_PIPE,
-	SSE_AWK_EXTIO_COPROC,
-	SSE_AWK_EXTIO_FILE,
-	SSE_AWK_EXTIO_CONSOLE,
+	ASE_AWK_EXTIO_PIPE,
+	ASE_AWK_EXTIO_COPROC,
+	ASE_AWK_EXTIO_FILE,
+	ASE_AWK_EXTIO_CONSOLE,
 
 	/* reserved for internal use only */
-	SSE_AWK_EXTIO_NUM
+	ASE_AWK_EXTIO_NUM
 };
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-sse_awk_t* sse_awk_open (const sse_awk_syscas_t* syscas);
-int sse_awk_close (sse_awk_t* awk);
-int sse_awk_clear (sse_awk_t* awk);
+ase_awk_t* ase_awk_open (const ase_awk_syscas_t* syscas);
+int ase_awk_close (ase_awk_t* awk);
+int ase_awk_clear (ase_awk_t* awk);
 
-int sse_awk_geterrnum (sse_awk_t* awk);
-sse_size_t sse_awk_getsrcline (sse_awk_t* awk);
+int ase_awk_geterrnum (ase_awk_t* awk);
+ase_size_t ase_awk_getsrcline (ase_awk_t* awk);
 
-int sse_awk_getopt (sse_awk_t* awk);
-void sse_awk_setopt (sse_awk_t* awk, int opt);
+int ase_awk_getopt (ase_awk_t* awk);
+void ase_awk_setopt (ase_awk_t* awk, int opt);
 
-int sse_awk_parse (sse_awk_t* awk, sse_awk_srcios_t* srcios);
+int ase_awk_parse (ase_awk_t* awk, ase_awk_srcios_t* srcios);
 
 /*
- * sse_awk_run return 0 on success and -1 on failure, generally speaking.
+ * ase_awk_run return 0 on success and -1 on failure, generally speaking.
  *  A runtime context is required for it to start running the program.
  *  Once the runtime context is created, the program starts to run.
  *  The context creation failure is reported by the return value -1 of
  *  this function. however, the runtime error after the context creation
  *  is reported differently depending on the use of the callback.
- *  When no callback is specified (i.e. runcbs is SSE_NULL), sse_awk_run
+ *  When no callback is specified (i.e. runcbs is ASE_NULL), ase_awk_run
  *  returns -1 on an error and awk->errnum is set accordingly.
- *  However, if a callback is specified (i.e. runcbs is not SSE_NULL),
- *  sse_awk_run returns 0 on both success and failure. Instead, the 
+ *  However, if a callback is specified (i.e. runcbs is not ASE_NULL),
+ *  ase_awk_run returns 0 on both success and failure. Instead, the 
  *  on_end handler of the callback is triggered with the relevant 
  *  error number. The third parameter to on_end denotes this error number.
  */
-int sse_awk_run (sse_awk_t* awk, 
-	sse_awk_runios_t* runios, 
-	sse_awk_runcbs_t* runcbs, 
-	sse_awk_runarg_t* runarg);
+int ase_awk_run (ase_awk_t* awk, 
+	ase_awk_runios_t* runios, 
+	ase_awk_runcbs_t* runcbs, 
+	ase_awk_runarg_t* runarg);
 
-int sse_awk_stop (sse_awk_t* awk, sse_awk_run_t* run);
-void sse_awk_stopall (sse_awk_t* awk);
+int ase_awk_stop (ase_awk_t* awk, ase_awk_run_t* run);
+void ase_awk_stopall (ase_awk_t* awk);
 
 /* functions to access internal stack structure */
-sse_size_t sse_awk_getnargs (sse_awk_run_t* run);
-sse_awk_val_t* sse_awk_getarg (sse_awk_run_t* run, sse_size_t idx);
-sse_awk_val_t* sse_awk_getglobal (sse_awk_run_t* run, sse_size_t idx);
-int sse_awk_setglobal (sse_awk_run_t* run, sse_size_t idx, sse_awk_val_t* val);
-void sse_awk_setretval (sse_awk_run_t* run, sse_awk_val_t* val);
+ase_size_t ase_awk_getnargs (ase_awk_run_t* run);
+ase_awk_val_t* ase_awk_getarg (ase_awk_run_t* run, ase_size_t idx);
+ase_awk_val_t* ase_awk_getglobal (ase_awk_run_t* run, ase_size_t idx);
+int ase_awk_setglobal (ase_awk_run_t* run, ase_size_t idx, ase_awk_val_t* val);
+void ase_awk_setretval (ase_awk_run_t* run, ase_awk_val_t* val);
 
-int sse_awk_setconsolename (
-	sse_awk_run_t* run, const sse_char_t* name, sse_size_t len);
+int ase_awk_setconsolename (
+	ase_awk_run_t* run, const ase_char_t* name, ase_size_t len);
 
-int sse_awk_getrunerrnum (sse_awk_run_t* run);
-void sse_awk_setrunerrnum (sse_awk_run_t* run, int errnum);
+int ase_awk_getrunerrnum (ase_awk_run_t* run);
+void ase_awk_setrunerrnum (ase_awk_run_t* run, int errnum);
 
 /* record and field functions */
-int sse_awk_clrrec (sse_awk_run_t* run, sse_bool_t skip_inrec_line);
-int sse_awk_setrec (sse_awk_run_t* run, sse_size_t idx, const sse_char_t* str, sse_size_t len);
+int ase_awk_clrrec (ase_awk_run_t* run, ase_bool_t skip_inrec_line);
+int ase_awk_setrec (ase_awk_run_t* run, ase_size_t idx, const ase_char_t* str, ase_size_t len);
 
 /* utility functions exported by awk.h */
-sse_long_t sse_awk_strxtolong (
-	sse_awk_t* awk, const sse_char_t* str, sse_size_t len,
-	int base, const sse_char_t** endptr);
-sse_real_t sse_awk_strxtoreal (
-	sse_awk_t* awk, const sse_char_t* str, sse_size_t len, 
-	const sse_char_t** endptr);
+ase_long_t ase_awk_strxtolong (
+	ase_awk_t* awk, const ase_char_t* str, ase_size_t len,
+	int base, const ase_char_t** endptr);
+ase_real_t ase_awk_strxtoreal (
+	ase_awk_t* awk, const ase_char_t* str, ase_size_t len, 
+	const ase_char_t** endptr);
 
-sse_size_t sse_awk_longtostr (
-	sse_long_t value, int radix, const sse_char_t* prefix,
-	sse_char_t* buf, sse_size_t size);
+ase_size_t ase_awk_longtostr (
+	ase_long_t value, int radix, const ase_char_t* prefix,
+	ase_char_t* buf, ase_size_t size);
 
 /* string functions exported by awk.h */
-sse_char_t* sse_awk_strdup (
-	sse_awk_t* awk, const sse_char_t* str);
-sse_char_t* sse_awk_strxdup (
-	sse_awk_t* awk, const sse_char_t* str, sse_size_t len);
-sse_char_t* sse_awk_strxdup2 (
-	sse_awk_t* awk,
-	const sse_char_t* str1, sse_size_t len1,
-	const sse_char_t* str2, sse_size_t len2);
+ase_char_t* ase_awk_strdup (
+	ase_awk_t* awk, const ase_char_t* str);
+ase_char_t* ase_awk_strxdup (
+	ase_awk_t* awk, const ase_char_t* str, ase_size_t len);
+ase_char_t* ase_awk_strxdup2 (
+	ase_awk_t* awk,
+	const ase_char_t* str1, ase_size_t len1,
+	const ase_char_t* str2, ase_size_t len2);
 
-sse_size_t sse_awk_strlen (const sse_char_t* str);
-sse_size_t sse_awk_strcpy (sse_char_t* buf, const sse_char_t* str);
-sse_size_t sse_awk_strncpy (sse_char_t* buf, const sse_char_t* str, sse_size_t len);
-int sse_awk_strcmp (const sse_char_t* s1, const sse_char_t* s2);
+ase_size_t ase_awk_strlen (const ase_char_t* str);
+ase_size_t ase_awk_strcpy (ase_char_t* buf, const ase_char_t* str);
+ase_size_t ase_awk_strncpy (ase_char_t* buf, const ase_char_t* str, ase_size_t len);
+int ase_awk_strcmp (const ase_char_t* s1, const ase_char_t* s2);
 
-int sse_awk_strxncmp (
-	const sse_char_t* s1, sse_size_t len1, 
-	const sse_char_t* s2, sse_size_t len2);
+int ase_awk_strxncmp (
+	const ase_char_t* s1, ase_size_t len1, 
+	const ase_char_t* s2, ase_size_t len2);
 
-int sse_awk_strxncasecmp (
-	sse_awk_t* awk,
-	const sse_char_t* s1, sse_size_t len1, 
-	const sse_char_t* s2, sse_size_t len2);
+int ase_awk_strxncasecmp (
+	ase_awk_t* awk,
+	const ase_char_t* s1, ase_size_t len1, 
+	const ase_char_t* s2, ase_size_t len2);
 
-sse_char_t* sse_awk_strxnstr (
-	const sse_char_t* str, sse_size_t strsz, 
-	const sse_char_t* sub, sse_size_t subsz);
+ase_char_t* ase_awk_strxnstr (
+	const ase_char_t* str, ase_size_t strsz, 
+	const ase_char_t* sub, ase_size_t subsz);
 
 /* utility functions to convert an error number ot a string */
-const sse_char_t* sse_awk_geterrstr (int errnum);
+const ase_char_t* ase_awk_geterrstr (int errnum);
 
 #ifdef __cplusplus
 }
diff --git a/ase/awk/awk_i.h b/ase/awk/awk_i.h
index b2f2bce6..87782635 100644
--- a/ase/awk/awk_i.h
+++ b/ase/awk/awk_i.h
@@ -1,107 +1,107 @@
 /*
- * $Id: awk_i.h,v 1.71 2006-10-23 14:44:42 bacon Exp $
+ * $Id: awk_i.h,v 1.72 2006-10-24 04:10:12 bacon Exp $
  */
 
-#ifndef _SSE_AWK_AWKI_H_
-#define _SSE_AWK_AWKI_H_
+#ifndef _ASE_AWK_AWKI_H_
+#define _ASE_AWK_AWKI_H_
 
-typedef struct sse_awk_chain_t sse_awk_chain_t;
-typedef struct sse_awk_tree_t sse_awk_tree_t;
+typedef struct ase_awk_chain_t ase_awk_chain_t;
+typedef struct ase_awk_tree_t ase_awk_tree_t;
 
-#include <sse/awk/awk.h>
-#include <sse/awk/str.h>
-#include <sse/awk/rex.h>
-#include <sse/awk/map.h>
-#include <sse/awk/tree.h>
-#include <sse/awk/val.h>
-#include <sse/awk/func.h>
-#include <sse/awk/tab.h>
-#include <sse/awk/parse.h>
-#include <sse/awk/run.h>
-#include <sse/awk/extio.h>
-#include <sse/awk/misc.h>
+#include <ase/awk/awk.h>
+#include <ase/awk/str.h>
+#include <ase/awk/rex.h>
+#include <ase/awk/map.h>
+#include <ase/awk/tree.h>
+#include <ase/awk/val.h>
+#include <ase/awk/func.h>
+#include <ase/awk/tab.h>
+#include <ase/awk/parse.h>
+#include <ase/awk/run.h>
+#include <ase/awk/extio.h>
+#include <ase/awk/misc.h>
 
 #ifdef NDEBUG
-	#define sse_awk_assert(awk,expr) ((void)0)
+	#define ase_awk_assert(awk,expr) ((void)0)
 #else
-	#define sse_awk_assert(awk,expr) (void)((expr) || \
-		(sse_awk_abort(awk, SSE_T(#expr), SSE_T(__FILE__), __LINE__), 0))
+	#define ase_awk_assert(awk,expr) (void)((expr) || \
+		(ase_awk_abort(awk, ASE_T(#expr), ASE_T(__FILE__), __LINE__), 0))
 #endif
 
 #ifdef _MSC_VER
 #pragma warning (disable: 4996)
 #endif
 
-#define SSE_AWK_MAX_GLOBALS 9999
-#define SSE_AWK_MAX_LOCALS  9999
-#define SSE_AWK_MAX_PARAMS  9999
+#define ASE_AWK_MAX_GLOBALS 9999
+#define ASE_AWK_MAX_LOCALS  9999
+#define ASE_AWK_MAX_PARAMS  9999
 
 #if defined(_WIN32) && defined(_DEBUG)
 	#define _CRTDBG_MAP_ALLOC
 	#include <crtdbg.h>
 
-	#define SSE_AWK_MALLOC(awk,size) malloc (size)
-	#define SSE_AWK_REALLOC(awk,ptr,size) realloc (ptr, size)
-	#define SSE_AWK_FREE(awk,ptr) free (ptr)
+	#define ASE_AWK_MALLOC(awk,size) malloc (size)
+	#define ASE_AWK_REALLOC(awk,ptr,size) realloc (ptr, size)
+	#define ASE_AWK_FREE(awk,ptr) free (ptr)
 #else
-	#define SSE_AWK_MALLOC(awk,size) \
+	#define ASE_AWK_MALLOC(awk,size) \
 		(awk)->syscas.malloc (size, (awk)->syscas.custom_data)
-	#define SSE_AWK_REALLOC(awk,ptr,size) \
+	#define ASE_AWK_REALLOC(awk,ptr,size) \
 		(awk)->syscas.realloc (ptr, size, (awk)->syscas.custom_data)
-	#define SSE_AWK_FREE(awk,ptr) \
+	#define ASE_AWK_FREE(awk,ptr) \
 		(awk)->syscas.free (ptr, (awk)->syscas.custom_data)
 #endif
 
-#define SSE_AWK_LOCK(awk) \
+#define ASE_AWK_LOCK(awk) \
 	do { \
-		if ((awk)->syscas.lock != SSE_NULL) \
+		if ((awk)->syscas.lock != ASE_NULL) \
 			(awk)->syscas.lock (awk, (awk)->syscas.custom_data); \
 	} while (0) 
 
-#define SSE_AWK_UNLOCK(awk) \
+#define ASE_AWK_UNLOCK(awk) \
 	do { \
-		if ((awk)->syscas.unlock != SSE_NULL) \
+		if ((awk)->syscas.unlock != ASE_NULL) \
 			(awk)->syscas.unlock (awk, (awk)->syscas.custom_data); \
 	} while (0) 
 
-#define SSE_AWK_ISUPPER(awk,c)  (awk)->syscas.is_upper(c)
-#define SSE_AWK_ISLOWER(awk,c)  (awk)->syscas.is_lower(c)
-#define SSE_AWK_ISALPHA(awk,c)  (awk)->syscas.is_alpha(c)
-#define SSE_AWK_ISDIGIT(awk,c)  (awk)->syscas.is_digit(c)
-#define SSE_AWK_ISXDIGIT(awk,c) (awk)->syscas.is_xdigit(c)
-#define SSE_AWK_ISALNUM(awk,c)  (awk)->syscas.is_alnum(c)
-#define SSE_AWK_ISSPACE(awk,c)  (awk)->syscas.is_space(c)
-#define SSE_AWK_ISPRINT(awk,c)  (awk)->syscas.is_print(c)
-#define SSE_AWK_ISGRAPH(awk,c)  (awk)->syscas.is_graph(c)
-#define SSE_AWK_ISCNTRL(awk,c)  (awk)->syscas.is_cntrl(c)
-#define SSE_AWK_ISPUNCT(awk,c)  (awk)->syscas.is_punct(c)
-#define SSE_AWK_TOUPPER(awk,c)  (awk)->syscas.to_upper(c)
-#define SSE_AWK_TOLOWER(awk,c)  (awk)->syscas.to_lower(c)
+#define ASE_AWK_ISUPPER(awk,c)  (awk)->syscas.is_upper(c)
+#define ASE_AWK_ISLOWER(awk,c)  (awk)->syscas.is_lower(c)
+#define ASE_AWK_ISALPHA(awk,c)  (awk)->syscas.is_alpha(c)
+#define ASE_AWK_ISDIGIT(awk,c)  (awk)->syscas.is_digit(c)
+#define ASE_AWK_ISXDIGIT(awk,c) (awk)->syscas.is_xdigit(c)
+#define ASE_AWK_ISALNUM(awk,c)  (awk)->syscas.is_alnum(c)
+#define ASE_AWK_ISSPACE(awk,c)  (awk)->syscas.is_space(c)
+#define ASE_AWK_ISPRINT(awk,c)  (awk)->syscas.is_print(c)
+#define ASE_AWK_ISGRAPH(awk,c)  (awk)->syscas.is_graph(c)
+#define ASE_AWK_ISCNTRL(awk,c)  (awk)->syscas.is_cntrl(c)
+#define ASE_AWK_ISPUNCT(awk,c)  (awk)->syscas.is_punct(c)
+#define ASE_AWK_TOUPPER(awk,c)  (awk)->syscas.to_upper(c)
+#define ASE_AWK_TOLOWER(awk,c)  (awk)->syscas.to_lower(c)
 
-#define SSE_AWK_MEMCPY(awk,dst,src,len) (awk)->syscas.memcpy (dst, src, len)
-#define SSE_AWK_MEMSET(awk,dst,val,len) (awk)->syscas.memset (dst, val, len)
+#define ASE_AWK_MEMCPY(awk,dst,src,len) (awk)->syscas.memcpy (dst, src, len)
+#define ASE_AWK_MEMSET(awk,dst,val,len) (awk)->syscas.memset (dst, val, len)
 
-struct sse_awk_tree_t
+struct ase_awk_tree_t
 {
-	sse_size_t nglobals; /* total number of globals */
-	sse_size_t nbglobals; /* number of builtin globals */
-	sse_awk_map_t afns; /* awk function map */
-	sse_awk_nde_t* begin;
-	sse_awk_nde_t* end;
-	sse_awk_chain_t* chain;
-	sse_awk_chain_t* chain_tail;
-	sse_size_t chain_size; /* number of nodes in the chain */
+	ase_size_t nglobals; /* total number of globals */
+	ase_size_t nbglobals; /* number of builtin globals */
+	ase_awk_map_t afns; /* awk function map */
+	ase_awk_nde_t* begin;
+	ase_awk_nde_t* end;
+	ase_awk_chain_t* chain;
+	ase_awk_chain_t* chain_tail;
+	ase_size_t chain_size; /* number of nodes in the chain */
 };
 
-struct sse_awk_t
+struct ase_awk_t
 {
-	sse_awk_syscas_t syscas;
+	ase_awk_syscas_t syscas;
 
 	/* options */
 	int option;
 
 	/* parse tree */
-	sse_awk_tree_t tree;
+	ase_awk_tree_t tree;
 	int state;
 
 	/* temporary information that the parser needs */
@@ -115,13 +115,13 @@ struct sse_awk_t
 
 		struct
 		{
-			sse_size_t loop;
+			ase_size_t loop;
 		} depth;
 
-		sse_awk_tab_t globals;
-		sse_awk_tab_t locals;
-		sse_awk_tab_t params;
-		sse_size_t nlocals_max;
+		ase_awk_tab_t globals;
+		ase_awk_tab_t locals;
+		ase_awk_tab_t params;
+		ase_size_t nlocals_max;
 
 		int nl_semicolon;
 	} parse;
@@ -129,23 +129,23 @@ struct sse_awk_t
 	/* source code management */
 	struct
 	{
-		sse_awk_srcios_t* ios;
+		ase_awk_srcios_t* ios;
 
 		struct
 		{
-			sse_cint_t curc;
-			sse_cint_t ungotc[5];
-			sse_size_t ungotc_count;
+			ase_cint_t curc;
+			ase_cint_t ungotc[5];
+			ase_size_t ungotc_count;
 
-			sse_size_t line;
-			sse_size_t column;
+			ase_size_t line;
+			ase_size_t column;
 		} lex;
 
 		struct
 		{
-			sse_char_t buf[512];
-			sse_size_t buf_pos;
-			sse_size_t buf_len;
+			ase_char_t buf[512];
+			ase_size_t buf_pos;
+			ase_size_t buf_len;
 		} shared;	
 	} src;
 
@@ -154,73 +154,73 @@ struct sse_awk_t
 	{
 		int          prev;
 		int          type;
-		sse_awk_str_t name;
-		sse_size_t    line;
-		sse_size_t    column;
+		ase_awk_str_t name;
+		ase_size_t    line;
+		ase_size_t    column;
 	} token;
 
 	/* builtin functions */
 	struct
 	{
-		sse_awk_bfn_t* sys;
-		sse_awk_bfn_t* user;
+		ase_awk_bfn_t* sys;
+		ase_awk_bfn_t* user;
 	} bfn;
 
 	struct
 	{
-		sse_size_t count;
-		sse_awk_run_t* ptr;
+		ase_size_t count;
+		ase_awk_run_t* ptr;
 	} run;
 
 	/* housekeeping */
 	int errnum;
 };
 
-struct sse_awk_chain_t
+struct ase_awk_chain_t
 {
-	sse_awk_nde_t* pattern;
-	sse_awk_nde_t* action;
-	sse_awk_chain_t* next;	
+	ase_awk_nde_t* pattern;
+	ase_awk_nde_t* action;
+	ase_awk_chain_t* next;	
 };
 
-struct sse_awk_run_t
+struct ase_awk_run_t
 {
 	int id;
-	sse_awk_map_t named;
+	ase_awk_map_t named;
 
 	void** stack;
-	sse_size_t stack_top;
-	sse_size_t stack_base;
-	sse_size_t stack_limit;
+	ase_size_t stack_top;
+	ase_size_t stack_base;
+	ase_size_t stack_limit;
 	int exit_level;
 
-	sse_awk_val_int_t* icache[100]; /* TODO: choose the optimal size  */
-	sse_awk_val_real_t* rcache[100]; /* TODO: choose the optimal size  */
-	sse_awk_val_ref_t* fcache[100]; /* TODO: choose the optimal size */
-	sse_size_t icache_count;
-	sse_size_t rcache_count;
-	sse_size_t fcache_count;
+	ase_awk_val_int_t* icache[100]; /* TODO: choose the optimal size  */
+	ase_awk_val_real_t* rcache[100]; /* TODO: choose the optimal size  */
+	ase_awk_val_ref_t* fcache[100]; /* TODO: choose the optimal size */
+	ase_size_t icache_count;
+	ase_size_t rcache_count;
+	ase_size_t fcache_count;
 
-	sse_awk_nde_blk_t* active_block;
-	sse_byte_t* pattern_range_state;
+	ase_awk_nde_blk_t* active_block;
+	ase_byte_t* pattern_range_state;
 
 	struct
 	{
-		sse_char_t buf[1024];
-		sse_size_t buf_pos;
-		sse_size_t buf_len;
-		sse_bool_t eof;
+		ase_char_t buf[1024];
+		ase_size_t buf_pos;
+		ase_size_t buf_len;
+		ase_bool_t eof;
 
-		sse_awk_str_t line;
-		sse_awk_val_t* d0; /* $0 */
+		ase_awk_str_t line;
+		ase_awk_val_t* d0; /* $0 */
 
-		sse_size_t maxflds;
-		sse_size_t nflds; /* NF */
+		ase_size_t maxflds;
+		ase_size_t nflds; /* NF */
 		struct
 		{
-			sse_char_t*    ptr;
-			sse_size_t     len;
-			sse_awk_val_t* val; /* $1 .. $NF */
+			ase_char_t*    ptr;
+			ase_size_t     len;
+			ase_awk_val_t* val; /* $1 .. $NF */
 		}* flds;
 
 	} inrec;
@@ -230,48 +230,48 @@ struct sse_awk_run_t
 		void* rs;
 		void* fs;
 		int ignorecase;
-		sse_size_t fnr;
+		ase_size_t fnr;
 
 		struct 
 		{
-			sse_char_t* ptr;
-			sse_size_t len;
+			ase_char_t* ptr;
+			ase_size_t len;
 		} convfmt;
 		struct
 		{
-			sse_char_t* ptr;
-			sse_size_t len;
+			ase_char_t* ptr;
+			ase_size_t len;
 		} ofmt;
 		struct
 		{
-			sse_char_t* ptr;
-			sse_size_t len;
+			ase_char_t* ptr;
+			ase_size_t len;
 		} ofs;
 		struct
 		{
-			sse_char_t* ptr;
-			sse_size_t len;
+			ase_char_t* ptr;
+			ase_size_t len;
 		} ors;
 		struct
 		{
-			sse_char_t* ptr;
-			sse_size_t len;
+			ase_char_t* ptr;
+			ase_size_t len;
 		} subsep;
 	} global;
 
 	/* extio chain */
 	struct
 	{
-		sse_awk_io_t handler[SSE_AWK_EXTIO_NUM];
+		ase_awk_io_t handler[ASE_AWK_EXTIO_NUM];
 		void* custom_data;
-		sse_awk_extio_t* chain;
+		ase_awk_extio_t* chain;
 	} extio;
 
 	int errnum;
 
-	sse_awk_t* awk;
-	sse_awk_run_t* prev;
-	sse_awk_run_t* next;
+	ase_awk_t* awk;
+	ase_awk_run_t* prev;
+	ase_awk_run_t* next;
 };
 
 #endif
diff --git a/ase/awk/err.c b/ase/awk/err.c
index 47c229cb..f1158fb1 100644
--- a/ase/awk/err.c
+++ b/ase/awk/err.c
@@ -1,124 +1,124 @@
 /*
- * $Id: err.c,v 1.44 2006-10-22 12:39:29 bacon Exp $
+ * $Id: err.c,v 1.45 2006-10-24 04:10:12 bacon Exp $
  */
 
-#include <sse/awk/awk_i.h>
+#include <ase/awk/awk_i.h>
 
-int sse_awk_geterrnum (sse_awk_t* awk)
+int ase_awk_geterrnum (ase_awk_t* awk)
 {
 	return awk->errnum;
 }
 
-const sse_char_t* sse_awk_geterrstr (int errnum)
+const ase_char_t* ase_awk_geterrstr (int errnum)
 {
-	static const sse_char_t* __errstr[] =
+	static const ase_char_t* __errstr[] =
  	{
-		SSE_T("no error"),
-		SSE_T("out of memory"),
-		SSE_T("invalid parameter"),
-		SSE_T("general run-time error"),
-		SSE_T("one or more running instances"),
-		SSE_T("too many running instances"),
-		SSE_T("recursion too deep"),
+		ASE_T("no error"),
+		ASE_T("out of memory"),
+		ASE_T("invalid parameter"),
+		ASE_T("general run-time error"),
+		ASE_T("one or more running instances"),
+		ASE_T("too many running instances"),
+		ASE_T("recursion too deep"),
 
-		SSE_T("cannot open source input"),
-		SSE_T("cannot close source input"),
-		SSE_T("cannot read source input"),
+		ASE_T("cannot open source input"),
+		ASE_T("cannot close source input"),
+		ASE_T("cannot read source input"),
 
-		SSE_T("cannot open source output"),
-		SSE_T("cannot close source output"),
-		SSE_T("cannot write source output"),
+		ASE_T("cannot open source output"),
+		ASE_T("cannot close source output"),
+		ASE_T("cannot write source output"),
 
-		SSE_T("cannot open console for read"),
-		SSE_T("cannot close console for read"),
-		SSE_T("cannot switch to next console for read"),
-		SSE_T("cannot read from console"),
+		ASE_T("cannot open console for read"),
+		ASE_T("cannot close console for read"),
+		ASE_T("cannot switch to next console for read"),
+		ASE_T("cannot read from console"),
 
-		SSE_T("cannot open console for write"),
-		SSE_T("cannot close console for write"),
-		SSE_T("cannot switch to next console for write"),
-		SSE_T("cannot write to console"),
+		ASE_T("cannot open console for write"),
+		ASE_T("cannot close console for write"),
+		ASE_T("cannot switch to next console for write"),
+		ASE_T("cannot write to console"),
 
-		SSE_T("invalid character"),
-		SSE_T("cannot unget character"),
+		ASE_T("invalid character"),
+		ASE_T("cannot unget character"),
 
-		SSE_T("unexpected end of source"),
-		SSE_T("unexpected end of a comment"),
-		SSE_T("unexpected end of a string"),
-		SSE_T("unexpected end of a regular expression"),
-		SSE_T("left brace expected"),
-		SSE_T("left parenthesis expected"),
-		SSE_T("right parenthesis expected"),
-		SSE_T("right bracket expected"),
-		SSE_T("comma expected"),
-		SSE_T("semicolon expected"),
-		SSE_T("colon expected"),
-		SSE_T("keyword 'in' expected"),
-		SSE_T("not a variable after 'in'"),
-		SSE_T("expression expected"),
+		ASE_T("unexpected end of source"),
+		ASE_T("unexpected end of a comment"),
+		ASE_T("unexpected end of a string"),
+		ASE_T("unexpected end of a regular expression"),
+		ASE_T("left brace expected"),
+		ASE_T("left parenthesis expected"),
+		ASE_T("right parenthesis expected"),
+		ASE_T("right bracket expected"),
+		ASE_T("comma expected"),
+		ASE_T("semicolon expected"),
+		ASE_T("colon expected"),
+		ASE_T("keyword 'in' expected"),
+		ASE_T("not a variable after 'in'"),
+		ASE_T("expression expected"),
 
-		SSE_T("keyword 'while' expected"),
-		SSE_T("assignment statement expected"),
-		SSE_T("identifier expected"),
-		SSE_T("BEGIN requires an action block"),
-		SSE_T("END requires an action block"),
-		SSE_T("duplicate BEGIN"),
-		SSE_T("duplicate END"),
-		SSE_T("duplicate function name"),
-		SSE_T("duplicate parameter name"),
-		SSE_T("duplicate variable name"),
-		SSE_T("duplicate name"),
-		SSE_T("undefined identifier"),
-		SSE_T("l-value required"),
-		SSE_T("too few arguments"),
-		SSE_T("too many arguments"),
-		SSE_T("too many global variables"),
-		SSE_T("too many local variables"),
-		SSE_T("too many parameters"),
-		SSE_T("break outside a loop"),
-		SSE_T("continue outside a loop"),
-		SSE_T("next illegal in BEGIN or END block"),
-		SSE_T("nextfile illegal in BEGIN or END block"),
-		SSE_T("getline expected"),
+		ASE_T("keyword 'while' expected"),
+		ASE_T("assignment statement expected"),
+		ASE_T("identifier expected"),
+		ASE_T("BEGIN requires an action block"),
+		ASE_T("END requires an action block"),
+		ASE_T("duplicate BEGIN"),
+		ASE_T("duplicate END"),
+		ASE_T("duplicate function name"),
+		ASE_T("duplicate parameter name"),
+		ASE_T("duplicate variable name"),
+		ASE_T("duplicate name"),
+		ASE_T("undefined identifier"),
+		ASE_T("l-value required"),
+		ASE_T("too few arguments"),
+		ASE_T("too many arguments"),
+		ASE_T("too many global variables"),
+		ASE_T("too many local variables"),
+		ASE_T("too many parameters"),
+		ASE_T("break outside a loop"),
+		ASE_T("continue outside a loop"),
+		ASE_T("next illegal in BEGIN or END block"),
+		ASE_T("nextfile illegal in BEGIN or END block"),
+		ASE_T("getline expected"),
 
-		SSE_T("divide by zero"),
-		SSE_T("invalid operand"),
-		SSE_T("wrong position index"),
-		SSE_T("no such function"),
-		SSE_T("value not assignable"),
-		SSE_T("variable not indexable"),
-		SSE_T("variable not deletable"),
-		SSE_T("value not referenceable"),
-		SSE_T("an indexed value cannot be assigned a map"),
-		SSE_T("a positional value cannot be assigned a map"),
-		SSE_T("cannot change a map to a scalar value"),
-		SSE_T("cannot change a scalar value to a map"),
-		SSE_T("a map is not allowed"),
-		SSE_T("wrong value type"),
-		SSE_T("pipe operation error"),
-		SSE_T("next cannot be called from the BEGIN or END block"),
-		SSE_T("nextfile cannot be called from the BEGIN or END block"),
-		SSE_T("wrong implementation of user-defined io handler"),
-		SSE_T("no such io name found"),
-		SSE_T("io handler has returned an error"),
-		SSE_T("internal error that should never have happened"),
+		ASE_T("divide by zero"),
+		ASE_T("invalid operand"),
+		ASE_T("wrong position index"),
+		ASE_T("no such function"),
+		ASE_T("value not assignable"),
+		ASE_T("variable not indexable"),
+		ASE_T("variable not deletable"),
+		ASE_T("value not referenceable"),
+		ASE_T("an indexed value cannot be assigned a map"),
+		ASE_T("a positional value cannot be assigned a map"),
+		ASE_T("cannot change a map to a scalar value"),
+		ASE_T("cannot change a scalar value to a map"),
+		ASE_T("a map is not allowed"),
+		ASE_T("wrong value type"),
+		ASE_T("pipe operation error"),
+		ASE_T("next cannot be called from the BEGIN or END block"),
+		ASE_T("nextfile cannot be called from the BEGIN or END block"),
+		ASE_T("wrong implementation of user-defined io handler"),
+		ASE_T("no such io name found"),
+		ASE_T("io handler has returned an error"),
+		ASE_T("internal error that should never have happened"),
 
-		SSE_T("a right parenthesis is expected in the regular expression"),
-		SSE_T("a right bracket is expected in the regular expression"),
-		SSE_T("a right brace is expected in the regular expression"),
-		SSE_T("a colon is expected in the regular expression"),
-		SSE_T("invalid character range in the regular expression"),
-		SSE_T("invalid character class in the regular expression"),
-		SSE_T("invalid boundary range in the regular expression"),
-		SSE_T("unexpected end of the regular expression"),
-		SSE_T("garbage after the regular expression")
+		ASE_T("a right parenthesis is expected in the regular expression"),
+		ASE_T("a right bracket is expected in the regular expression"),
+		ASE_T("a right brace is expected in the regular expression"),
+		ASE_T("a colon is expected in the regular expression"),
+		ASE_T("invalid character range in the regular expression"),
+		ASE_T("invalid character class in the regular expression"),
+		ASE_T("invalid boundary range in the regular expression"),
+		ASE_T("unexpected end of the regular expression"),
+		ASE_T("garbage after the regular expression")
 	};
 
-	if (errnum >= 0 && errnum < sse_countof(__errstr)) 
+	if (errnum >= 0 && errnum < ase_countof(__errstr)) 
 	{
 		return __errstr[errnum];
 	}
 
-	return SSE_T("unknown error");
+	return ASE_T("unknown error");
 }
 
diff --git a/ase/awk/extio.c b/ase/awk/extio.c
index 482cd281..8e87795a 100644
--- a/ase/awk/extio.c
+++ b/ase/awk/extio.c
@@ -1,8 +1,8 @@
 /*
- * $Id: extio.c,v 1.55 2006-10-22 11:34:53 bacon Exp $
+ * $Id: extio.c,v 1.56 2006-10-24 04:10:12 bacon Exp $
  */
 
-#include <sse/awk/awk_i.h>
+#include <ase/awk/awk_i.h>
 
 enum
 {
@@ -16,21 +16,21 @@ enum
 static int __in_type_map[] =
 {
 	/* the order should match the order of the 
-	 * SSE_AWK_IN_XXX values in tree.h */
-	SSE_AWK_EXTIO_PIPE,
-	SSE_AWK_EXTIO_COPROC,
-	SSE_AWK_EXTIO_FILE,
-	SSE_AWK_EXTIO_CONSOLE
+	 * ASE_AWK_IN_XXX values in tree.h */
+	ASE_AWK_EXTIO_PIPE,
+	ASE_AWK_EXTIO_COPROC,
+	ASE_AWK_EXTIO_FILE,
+	ASE_AWK_EXTIO_CONSOLE
 };
 
 static int __in_mode_map[] =
 {
 	/* the order should match the order of the 
-	 * SSE_AWK_IN_XXX values in tree.h */
-	SSE_AWK_IO_PIPE_READ,
+	 * ASE_AWK_IN_XXX values in tree.h */
+	ASE_AWK_IO_PIPE_READ,
 	0,
-	SSE_AWK_IO_FILE_READ,
-	SSE_AWK_IO_CONSOLE_READ
+	ASE_AWK_IO_FILE_READ,
+	ASE_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 
-	 * 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
+	 * ASE_AWK_OUT_XXX values in tree.h */
+	ASE_AWK_EXTIO_PIPE,
+	ASE_AWK_EXTIO_COPROC,
+	ASE_AWK_EXTIO_FILE,
+	ASE_AWK_EXTIO_FILE,
+	ASE_AWK_EXTIO_CONSOLE
 };
 
 static int __out_mode_map[] =
 {
 	/* the order should match the order of the 
-	 * SSE_AWK_OUT_XXX values in tree.h */
-	SSE_AWK_IO_PIPE_WRITE,
+	 * ASE_AWK_OUT_XXX values in tree.h */
+	ASE_AWK_IO_PIPE_WRITE,
 	0,
-	SSE_AWK_IO_FILE_WRITE,
-	SSE_AWK_IO_FILE_APPEND,
-	SSE_AWK_IO_CONSOLE_WRITE
+	ASE_AWK_IO_FILE_WRITE,
+	ASE_AWK_IO_FILE_APPEND,
+	ASE_AWK_IO_CONSOLE_WRITE
 };
 
 static int __out_mask_map[] =
@@ -72,24 +72,24 @@ static int __out_mask_map[] =
 	__MASK_WRITE
 };
 
-int sse_awk_readextio (
-	sse_awk_run_t* run, int in_type,
-	const sse_char_t* name, sse_awk_str_t* buf)
+int ase_awk_readextio (
+	ase_awk_run_t* run, int in_type,
+	const ase_char_t* name, ase_awk_str_t* buf)
 {
-	sse_awk_extio_t* p = run->extio.chain;
-	sse_awk_io_t handler;
+	ase_awk_extio_t* p = run->extio.chain;
+	ase_awk_io_t handler;
 	int extio_type, extio_mode, extio_mask, n, ret;
-	sse_awk_val_t* rs;
-	sse_char_t* rs_ptr;
-	sse_size_t rs_len;
-	sse_size_t line_len = 0;
+	ase_awk_val_t* rs;
+	ase_char_t* rs_ptr;
+	ase_size_t rs_len;
+	ase_size_t line_len = 0;
 
-	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));
+	ase_awk_assert (run->awk,
+		in_type >= 0 && in_type <= ase_countof(__in_type_map));
+	ase_awk_assert (run->awk,
+		in_type >= 0 && in_type <= ase_countof(__in_mode_map));
+	ase_awk_assert (run->awk,
+		in_type >= 0 && in_type <= ase_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 sse_awk_readextio (
 	extio_mask = __in_mask_map[in_type];
 
 	handler = run->extio.handler[extio_type];
-	if (handler == SSE_NULL)
+	if (handler == ASE_NULL)
 	{
 		/* no io handler provided */
-		run->errnum = SSE_AWK_EIOIMPL; /* TODO: change the error code */
+		run->errnum = ASE_AWK_EIOIMPL; /* TODO: change the error code */
 		return -1;
 	}
 
-	while (p != SSE_NULL)
+	while (p != ASE_NULL)
 	{
 		if (p->type == (extio_type | extio_mask) &&
-		    sse_awk_strcmp (p->name,name) == 0) break;
+		    ase_awk_strcmp (p->name,name) == 0) break;
 		p = p->next;
 	}
 
-	if (p == SSE_NULL)
+	if (p == ASE_NULL)
 	{
-		p = (sse_awk_extio_t*) SSE_AWK_MALLOC (
-			run->awk, sse_sizeof(sse_awk_extio_t));
-		if (p == SSE_NULL)
+		p = (ase_awk_extio_t*) ASE_AWK_MALLOC (
+			run->awk, ase_sizeof(ase_awk_extio_t));
+		if (p == ASE_NULL)
 		{
-			run->errnum = SSE_AWK_ENOMEM;
+			run->errnum = ASE_AWK_ENOMEM;
 			return -1;
 		}
 
-		p->name = sse_awk_strdup (run->awk, name);
-		if (p->name == SSE_NULL)
+		p->name = ase_awk_strdup (run->awk, name);
+		if (p->name == ASE_NULL)
 		{
-			SSE_AWK_FREE (run->awk, p);
-			run->errnum = SSE_AWK_ENOMEM;
+			ASE_AWK_FREE (run->awk, p);
+			run->errnum = ASE_AWK_ENOMEM;
 			return -1;
 		}
 
 		p->run = run;
 		p->type = (extio_type | extio_mask);
 		p->mode = extio_mode;
-		p->handle = SSE_NULL;
-		p->next = SSE_NULL;
+		p->handle = ASE_NULL;
+		p->next = ASE_NULL;
 		p->custom_data = run->extio.custom_data;
 
-		p->in.buf[0] = SSE_T('\0');
+		p->in.buf[0] = ASE_T('\0');
 		p->in.pos = 0;
 		p->in.len = 0;
-		p->in.eof = sse_false;
+		p->in.eof = ase_false;
 
-		n = handler (SSE_AWK_IO_OPEN, p, SSE_NULL, 0);
+		n = handler (ASE_AWK_IO_OPEN, p, ASE_NULL, 0);
 		if (n == -1)
 		{
-			SSE_AWK_FREE (run->awk, p->name);
-			SSE_AWK_FREE (run->awk, p);
+			ASE_AWK_FREE (run->awk, p->name);
+			ASE_AWK_FREE (run->awk, p);
 				
 			/* TODO: use meaningful error code */
-			if (sse_awk_setglobal (
-				run, SSE_AWK_GLOBAL_ERRNO, 
-				sse_awk_val_one) == -1) return -1;
+			if (ase_awk_setglobal (
+				run, ASE_AWK_GLOBAL_ERRNO, 
+				ase_awk_val_one) == -1) return -1;
 
-			run->errnum = SSE_AWK_EIOHANDLER;
+			run->errnum = ASE_AWK_EIOHANDLER;
 			return -1;
 		}
 
@@ -169,29 +169,29 @@ int sse_awk_readextio (
 	}
 
 	/* ready to read a line */
-	sse_awk_str_clear (buf);
+	ase_awk_str_clear (buf);
 
 	/* get the record separator */
-	rs = sse_awk_getglobal (run, SSE_AWK_GLOBAL_RS);
-	sse_awk_refupval (rs);
+	rs = ase_awk_getglobal (run, ASE_AWK_GLOBAL_RS);
+	ase_awk_refupval (rs);
 
-	if (rs->type == SSE_AWK_VAL_NIL)
+	if (rs->type == ASE_AWK_VAL_NIL)
 	{
-		rs_ptr = SSE_NULL;
+		rs_ptr = ASE_NULL;
 		rs_len = 0;
 	}
-	else if (rs->type == SSE_AWK_VAL_STR)
+	else if (rs->type == ASE_AWK_VAL_STR)
 	{
-		rs_ptr = ((sse_awk_val_str_t*)rs)->buf;
-		rs_len = ((sse_awk_val_str_t*)rs)->len;
+		rs_ptr = ((ase_awk_val_str_t*)rs)->buf;
+		rs_len = ((ase_awk_val_str_t*)rs)->len;
 	}
 	else 
 	{
-		rs_ptr = sse_awk_valtostr (
-			run, rs, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &rs_len);
-		if (rs_ptr == SSE_NULL)
+		rs_ptr = ase_awk_valtostr (
+			run, rs, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &rs_len);
+		if (rs_ptr == ASE_NULL)
 		{
-			sse_awk_refdownval (run, rs);
+			ase_awk_refdownval (run, rs);
 			return -1;
 		}
 	}
@@ -201,33 +201,33 @@ int sse_awk_readextio (
 	/* call the io handler */
 	while (1)
 	{
-		sse_char_t c;
+		ase_char_t c;
 
 		if (p->in.pos >= p->in.len)
 		{
-			sse_ssize_t n;
+			ase_ssize_t n;
 
 			if (p->in.eof)
 			{
-				if (SSE_AWK_STR_LEN(buf) == 0) ret = 0;
+				if (ASE_AWK_STR_LEN(buf) == 0) ret = 0;
 				break;
 			}
 
-			n = handler (SSE_AWK_IO_READ, p, 
-				p->in.buf, sse_countof(p->in.buf));
+			n = handler (ASE_AWK_IO_READ, p, 
+				p->in.buf, ase_countof(p->in.buf));
 			if (n == -1) 
 			{
 				/* handler error. getline should return -1 */
 				/* TODO: use meaningful error code */
-				if (sse_awk_setglobal (
-					run, SSE_AWK_GLOBAL_ERRNO, 
-					sse_awk_val_one) == -1) 
+				if (ase_awk_setglobal (
+					run, ASE_AWK_GLOBAL_ERRNO, 
+					ase_awk_val_one) == -1) 
 				{
 					ret = -1;
 				}
 				else
 				{
-					run->errnum = SSE_AWK_EIOHANDLER;
+					run->errnum = ASE_AWK_EIOHANDLER;
 					ret = -1;
 				}
 				break;
@@ -235,8 +235,8 @@ int sse_awk_readextio (
 
 			if (n == 0) 
 			{
-				p->in.eof = sse_true;
-				if (SSE_AWK_STR_LEN(buf) == 0) ret = 0;
+				p->in.eof = ase_true;
+				if (ASE_AWK_STR_LEN(buf) == 0) ret = 0;
 				break;
 			}
 
@@ -246,19 +246,19 @@ int sse_awk_readextio (
 
 		c = p->in.buf[p->in.pos++];
 
-		if (rs_ptr == SSE_NULL)
+		if (rs_ptr == ASE_NULL)
 		{
 			/* separate by a new line */
 			/* TODO: handle different line terminator like \r\n */
-			if (c == SSE_T('\n')) break;
+			if (c == ASE_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 == SSE_T('\n'))
+			if (line_len == 0 && c == ASE_T('\n'))
 			{
-				if (SSE_AWK_STR_LEN(buf) <= 0) 
+				if (ASE_AWK_STR_LEN(buf) <= 0) 
 				{
 					/* if the record is empty when a blank 
 					 * line is encountered, the line 
@@ -271,7 +271,7 @@ int sse_awk_readextio (
 				 * it needs to snip off the line 
 				 * terminator of the previous line */
 				/* TODO: handle different line terminator like \r\n */
-				SSE_AWK_STR_LEN(buf) -= 1;
+				ASE_AWK_STR_LEN(buf) -= 1;
 				break;
 			}
 		}
@@ -281,16 +281,16 @@ int sse_awk_readextio (
 		}
 		else
 		{
-			const sse_char_t* match_ptr;
-			sse_size_t match_len;
+			const ase_char_t* match_ptr;
+			ase_size_t match_len;
 
-			sse_awk_assert (run->awk, run->global.rs != SSE_NULL);
+			ase_awk_assert (run->awk, run->global.rs != ASE_NULL);
 
 			/* TODO: safematchrex */
-			n = sse_awk_matchrex (
+			n = ase_awk_matchrex (
 				run->awk, run->global.rs, 
-				((run->global.ignorecase)? SSE_AWK_REX_IGNORECASE: 0),
-				SSE_AWK_STR_BUF(buf), SSE_AWK_STR_LEN(buf), 
+				((run->global.ignorecase)? ASE_AWK_REX_IGNORECASE: 0),
+				ASE_AWK_STR_BUF(buf), ASE_AWK_STR_LEN(buf), 
 				&match_ptr, &match_len, &run->errnum);
 			if (n == -1)
 			{
@@ -302,58 +302,58 @@ int sse_awk_readextio (
 			{
 				/* the match should be found at the end of
 				 * the current buffer */
-				sse_awk_assert (run->awk,
-					SSE_AWK_STR_BUF(buf) + SSE_AWK_STR_LEN(buf) ==
+				ase_awk_assert (run->awk,
+					ASE_AWK_STR_BUF(buf) + ASE_AWK_STR_LEN(buf) ==
 					match_ptr + match_len);
 
-				SSE_AWK_STR_LEN(buf) -= match_len;
+				ASE_AWK_STR_LEN(buf) -= match_len;
 				break;
 			}
 		}
 
-		if (sse_awk_str_ccat (buf, c) == (sse_size_t)-1)
+		if (ase_awk_str_ccat (buf, c) == (ase_size_t)-1)
 		{
-			run->errnum = SSE_AWK_ENOMEM;
+			run->errnum = ASE_AWK_ENOMEM;
 			ret = -1;
 			break;
 		}
 
 		/* TODO: handle different line terminator like \r\n */
-		if (c == SSE_T('\n')) line_len = 0;
+		if (c == ASE_T('\n')) line_len = 0;
 		else line_len = line_len + 1;
 	}
 
-	if (rs_ptr != SSE_NULL && rs->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, rs_ptr);
-	sse_awk_refdownval (run, rs);
+	if (rs_ptr != ASE_NULL && rs->type != ASE_AWK_VAL_STR) ASE_AWK_FREE (run->awk, rs_ptr);
+	ase_awk_refdownval (run, rs);
 
 	/* increment NR */
 	if (ret != -1)
 	{
-		sse_awk_val_t* nr;
-		sse_long_t lv;
-		sse_real_t rv;
+		ase_awk_val_t* nr;
+		ase_long_t lv;
+		ase_real_t rv;
 
-		nr = sse_awk_getglobal (run, SSE_AWK_GLOBAL_NR);
-		sse_awk_refupval (nr);
+		nr = ase_awk_getglobal (run, ASE_AWK_GLOBAL_NR);
+		ase_awk_refupval (nr);
 
-		n = sse_awk_valtonum (run, nr, &lv, &rv);
-		sse_awk_refdownval (run, nr);
+		n = ase_awk_valtonum (run, nr, &lv, &rv);
+		ase_awk_refdownval (run, nr);
 
 		if (n == -1) ret = -1;
 		else
 		{
-			if (n == 1) lv = (sse_long_t)rv;
+			if (n == 1) lv = (ase_long_t)rv;
 
-			nr = sse_awk_makeintval (run, lv + 1);
-			if (nr == SSE_NULL) 
+			nr = ase_awk_makeintval (run, lv + 1);
+			if (nr == ASE_NULL) 
 			{
-				run->errnum = SSE_AWK_ENOMEM;
+				run->errnum = ASE_AWK_ENOMEM;
 				ret = -1;
 			}
 			else 
 			{
-				if (sse_awk_setglobal (
-					run, SSE_AWK_GLOBAL_NR, nr) == -1) ret = -1;
+				if (ase_awk_setglobal (
+					run, ASE_AWK_GLOBAL_NR, nr) == -1) ret = -1;
 			}
 		}
 	}
@@ -361,48 +361,48 @@ int sse_awk_readextio (
 	return ret;
 }
 
-int sse_awk_writeextio_val (
-	sse_awk_run_t* run, int out_type, 
-	const sse_char_t* name, sse_awk_val_t* v)
+int ase_awk_writeextio_val (
+	ase_awk_run_t* run, int out_type, 
+	const ase_char_t* name, ase_awk_val_t* v)
 {
-	sse_char_t* str;
-	sse_size_t len;
+	ase_char_t* str;
+	ase_size_t len;
 	int n;
 
-	if (v->type == SSE_AWK_VAL_STR)
+	if (v->type == ASE_AWK_VAL_STR)
 	{
-		str = ((sse_awk_val_str_t*)v)->buf;
-		len = ((sse_awk_val_str_t*)v)->len;
+		str = ((ase_awk_val_str_t*)v)->buf;
+		len = ((ase_awk_val_str_t*)v)->len;
 	}
 	else
 	{
-		str = sse_awk_valtostr (
+		str = ase_awk_valtostr (
 			run, v, 
-			SSE_AWK_VALTOSTR_CLEAR | SSE_AWK_VALTOSTR_PRINT, 
-			SSE_NULL, &len);
-		if (str == SSE_NULL) return -1;
+			ASE_AWK_VALTOSTR_CLEAR | ASE_AWK_VALTOSTR_PRINT, 
+			ASE_NULL, &len);
+		if (str == ASE_NULL) return -1;
 	}
 
-	n = sse_awk_writeextio_str (run, out_type, name, str, len);
+	n = ase_awk_writeextio_str (run, out_type, name, str, len);
 
-	if (v->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str);
+	if (v->type != ASE_AWK_VAL_STR) ASE_AWK_FREE (run->awk, str);
 	return n;
 }
 
-int sse_awk_writeextio_str (
-	sse_awk_run_t* run, int out_type, 
-	const sse_char_t* name, sse_char_t* str, sse_size_t len)
+int ase_awk_writeextio_str (
+	ase_awk_run_t* run, int out_type, 
+	const ase_char_t* name, ase_char_t* str, ase_size_t len)
 {
-	sse_awk_extio_t* p = run->extio.chain;
-	sse_awk_io_t handler;
+	ase_awk_extio_t* p = run->extio.chain;
+	ase_awk_io_t handler;
 	int extio_type, extio_mode, extio_mask, n;
 
-	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));
+	ase_awk_assert (run->awk, 
+		out_type >= 0 && out_type <= ase_countof(__out_type_map));
+	ase_awk_assert (run->awk,
+		out_type >= 0 && out_type <= ase_countof(__out_mode_map));
+	ase_awk_assert (run->awk,
+		out_type >= 0 && out_type <= ase_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 sse_awk_writeextio_str (
 	extio_mask = __out_mask_map[out_type];
 
 	handler = run->extio.handler[extio_type];
-	if (handler == SSE_NULL)
+	if (handler == ASE_NULL)
 	{
 		/* no io handler provided */
-		run->errnum = SSE_AWK_EIOIMPL; /* TODO: change the error code */
+		run->errnum = ASE_AWK_EIOIMPL; /* TODO: change the error code */
 		return -1;
 	}
 
 	/* look for the corresponding extio for name */
-	while (p != SSE_NULL)
+	while (p != ASE_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 SSE_AWK_OUT_FILE and SSE_AWK_OUT_FILE_APPEND are
-		 * translated to SSE_AWK_EXTIO_FILE and it is used to
+		 * both ASE_AWK_OUT_FILE and ASE_AWK_OUT_FILE_APPEND are
+		 * translated to ASE_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) && 
-		    sse_awk_strcmp (p->name, name) == 0) break;
+		    ase_awk_strcmp (p->name, name) == 0) break;
 		p = p->next;
 	}
 
 	/* if there is not corresponding extio for name, create one */
-	if (p == SSE_NULL)
+	if (p == ASE_NULL)
 	{
-		p = (sse_awk_extio_t*) SSE_AWK_MALLOC (
-			run->awk, sse_sizeof(sse_awk_extio_t));
-		if (p == SSE_NULL)
+		p = (ase_awk_extio_t*) ASE_AWK_MALLOC (
+			run->awk, ase_sizeof(ase_awk_extio_t));
+		if (p == ASE_NULL)
 		{
-			run->errnum = SSE_AWK_ENOMEM;
+			run->errnum = ASE_AWK_ENOMEM;
 			return -1;
 		}
 
-		p->name = sse_awk_strdup (run->awk, name);
-		if (p->name == SSE_NULL)
+		p->name = ase_awk_strdup (run->awk, name);
+		if (p->name == ASE_NULL)
 		{
-			SSE_AWK_FREE (run->awk, p);
-			run->errnum = SSE_AWK_ENOMEM;
+			ASE_AWK_FREE (run->awk, p);
+			run->errnum = ASE_AWK_ENOMEM;
 			return -1;
 		}
 
 		p->run = run;
 		p->type = (extio_type | extio_mask);
 		p->mode = extio_mode;
-		p->handle = SSE_NULL;
-		p->next = SSE_NULL;
+		p->handle = ASE_NULL;
+		p->next = ASE_NULL;
 		p->custom_data = run->extio.custom_data;
 
-		n = handler (SSE_AWK_IO_OPEN, p, SSE_NULL, 0);
+		n = handler (ASE_AWK_IO_OPEN, p, ASE_NULL, 0);
 		if (n == -1)
 		{
-			SSE_AWK_FREE (run->awk, p->name);
-			SSE_AWK_FREE (run->awk, p);
+			ASE_AWK_FREE (run->awk, p->name);
+			ASE_AWK_FREE (run->awk, p);
 				
 			/* TODO: use meaningful error code */
-			if (sse_awk_setglobal (
-				run, SSE_AWK_GLOBAL_ERRNO, 
-				sse_awk_val_one) == -1) return -1;
+			if (ase_awk_setglobal (
+				run, ASE_AWK_GLOBAL_ERRNO, 
+				ase_awk_val_one) == -1) return -1;
 
-			run->errnum = SSE_AWK_EIOHANDLER;
+			run->errnum = ASE_AWK_EIOHANDLER;
 			return -1;
 		}
 
@@ -491,16 +491,16 @@ int sse_awk_writeextio_str (
 /* TODO: if write handler returns less than the request, loop */
 	if (len > 0)
 	{
-		n = handler (SSE_AWK_IO_WRITE, p, str, len);
+		n = handler (ASE_AWK_IO_WRITE, p, str, len);
 
 		if (n == -1) 
 		{
 			/* TODO: use meaningful error code */
-			if (sse_awk_setglobal (
-				run, SSE_AWK_GLOBAL_ERRNO, 
-				sse_awk_val_one) == -1) return -1;
+			if (ase_awk_setglobal (
+				run, ASE_AWK_GLOBAL_ERRNO, 
+				ase_awk_val_one) == -1) return -1;
 
-			run->errnum = SSE_AWK_EIOHANDLER;
+			run->errnum = ASE_AWK_EIOHANDLER;
 			return -1;
 		}
 
@@ -511,20 +511,20 @@ int sse_awk_writeextio_str (
 }
 
 
-int sse_awk_flushextio (
-	sse_awk_run_t* run, int out_type, const sse_char_t* name)
+int ase_awk_flushextio (
+	ase_awk_run_t* run, int out_type, const ase_char_t* name)
 {
-	sse_awk_extio_t* p = run->extio.chain;
-	sse_awk_io_t handler;
+	ase_awk_extio_t* p = run->extio.chain;
+	ase_awk_io_t handler;
 	int extio_type, extio_mode, extio_mask, n;
-	sse_bool_t ok = sse_false;
+	ase_bool_t ok = ase_false;
 
-	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));
+	ase_awk_assert (run->awk,
+		out_type >= 0 && out_type <= ase_countof(__out_type_map));
+	ase_awk_assert (run->awk,
+		out_type >= 0 && out_type <= ase_countof(__out_mode_map));
+	ase_awk_assert (run->awk,
+		out_type >= 0 && out_type <= ase_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 sse_awk_flushextio (
 	extio_mask = __out_mask_map[out_type];
 
 	handler = run->extio.handler[extio_type];
-	if (handler == SSE_NULL)
+	if (handler == ASE_NULL)
 	{
 		/* no io handler provided */
-		run->errnum = SSE_AWK_EIOIMPL; /* TODO: change the error code */
+		run->errnum = ASE_AWK_EIOIMPL; /* TODO: change the error code */
 		return -1;
 	}
 
 	/* look for the corresponding extio for name */
-	while (p != SSE_NULL)
+	while (p != ASE_NULL)
 	{
 		if (p->type == (extio_type | extio_mask) && 
-		    (name == SSE_NULL || sse_awk_strcmp (p->name, name) == 0)) 
+		    (name == ASE_NULL || ase_awk_strcmp (p->name, name) == 0)) 
 		{
-			n = handler (SSE_AWK_IO_FLUSH, p, SSE_NULL, 0);
+			n = handler (ASE_AWK_IO_FLUSH, p, ASE_NULL, 0);
 
 			if (n == -1) 
 			{
 				/* TODO: use meaningful error code */
-				if (sse_awk_setglobal (
-					run, SSE_AWK_GLOBAL_ERRNO, 
-					sse_awk_val_one) == -1) return -1;
+				if (ase_awk_setglobal (
+					run, ASE_AWK_GLOBAL_ERRNO, 
+					ase_awk_val_one) == -1) return -1;
 
-				run->errnum = SSE_AWK_EIOHANDLER;
+				run->errnum = ASE_AWK_EIOHANDLER;
 				return -1;
 			}
 
-			ok = sse_true;
+			ok = ase_true;
 		}
 
 		p = p->next;
@@ -568,26 +568,26 @@ int sse_awk_flushextio (
 
 	/* there is no corresponding extio for name */
 	/* TODO: use meaningful error code. but is this needed? */
-	if (sse_awk_setglobal (
-		run, SSE_AWK_GLOBAL_ERRNO, sse_awk_val_one) == -1) return -1;
+	if (ase_awk_setglobal (
+		run, ASE_AWK_GLOBAL_ERRNO, ase_awk_val_one) == -1) return -1;
 
-	run->errnum = SSE_AWK_ENOSUCHIO;
+	run->errnum = ASE_AWK_ENOSUCHIO;
 	return -1;
 }
 
-int sse_awk_nextextio_read (
-	sse_awk_run_t* run, int in_type, const sse_char_t* name)
+int ase_awk_nextextio_read (
+	ase_awk_run_t* run, int in_type, const ase_char_t* name)
 {
-	sse_awk_extio_t* p = run->extio.chain;
-	sse_awk_io_t handler;
+	ase_awk_extio_t* p = run->extio.chain;
+	ase_awk_io_t handler;
 	int extio_type, extio_mode, extio_mask, n;
 
-	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));
+	ase_awk_assert (run->awk,
+		in_type >= 0 && in_type <= ase_countof(__in_type_map));
+	ase_awk_assert (run->awk,
+		in_type >= 0 && in_type <= ase_countof(__in_mode_map));
+	ase_awk_assert (run->awk,
+		in_type >= 0 && in_type <= ase_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 sse_awk_nextextio_read (
 	extio_mask = __in_mask_map[in_type];
 
 	handler = run->extio.handler[extio_type];
-	if (handler == SSE_NULL)
+	if (handler == ASE_NULL)
 	{
 		/* no io handler provided */
-		run->errnum = SSE_AWK_EIOIMPL; /* TODO: change the error code */
+		run->errnum = ASE_AWK_EIOIMPL; /* TODO: change the error code */
 		return -1;
 	}
 
-	while (p != SSE_NULL)
+	while (p != ASE_NULL)
 	{
 		if (p->type == (extio_type | extio_mask) &&
-		    sse_awk_strcmp (p->name,name) == 0) break;
+		    ase_awk_strcmp (p->name,name) == 0) break;
 		p = p->next;
 	}
 
-	if (p == SSE_NULL)
+	if (p == ASE_NULL)
 	{
 		/* something is totally wrong */
-		run->errnum = SSE_AWK_EINTERNAL;
+		run->errnum = ASE_AWK_EINTERNAL;
 		return -1;
 	}
 
-	n = handler (SSE_AWK_IO_NEXT, p, SSE_NULL, 0);
+	n = handler (ASE_AWK_IO_NEXT, p, ASE_NULL, 0);
 	if (n == -1)
 	{
 		/* TODO: is this errnum correct? */
-		run->errnum = SSE_AWK_EIOHANDLER;
+		run->errnum = ASE_AWK_EIOHANDLER;
 		return -1;
 	}
 
 	return n;
 }
 
-int sse_awk_closeextio_read (
-	sse_awk_run_t* run, int in_type, const sse_char_t* name)
+int ase_awk_closeextio_read (
+	ase_awk_run_t* run, int in_type, const ase_char_t* name)
 {
-	sse_awk_extio_t* p = run->extio.chain, * px = SSE_NULL;
-	sse_awk_io_t handler;
+	ase_awk_extio_t* p = run->extio.chain, * px = ASE_NULL;
+	ase_awk_io_t handler;
 	int extio_type, extio_mode, extio_mask;
 
-	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));
+	ase_awk_assert (run->awk,
+		in_type >= 0 && in_type <= ase_countof(__in_type_map));
+	ase_awk_assert (run->awk,
+		in_type >= 0 && in_type <= ase_countof(__in_mode_map));
+	ase_awk_assert (run->awk,
+		in_type >= 0 && in_type <= ase_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 sse_awk_closeextio_read (
 	extio_mask = __in_mask_map[in_type];
 
 	handler = run->extio.handler[extio_type];
-	if (handler == SSE_NULL)
+	if (handler == ASE_NULL)
 	{
 		/* no io handler provided */
-		run->errnum = SSE_AWK_EIOIMPL; /* TODO: change the error code */
+		run->errnum = ASE_AWK_EIOIMPL; /* TODO: change the error code */
 		return -1;
 	}
 
-	while (p != SSE_NULL)
+	while (p != ASE_NULL)
 	{
 		if (p->type == (extio_type | extio_mask) &&
-		    sse_awk_strcmp (p->name, name) == 0) 
+		    ase_awk_strcmp (p->name, name) == 0) 
 		{
-			sse_awk_io_t handler;
+			ase_awk_io_t handler;
 		       
 			handler = run->extio.handler[p->type & __MASK_CLEAR];
-			if (handler != SSE_NULL)
+			if (handler != ASE_NULL)
 			{
-				if (handler (SSE_AWK_IO_CLOSE, p, SSE_NULL, 0) == -1)
+				if (handler (ASE_AWK_IO_CLOSE, p, ASE_NULL, 0) == -1)
 				{
 					/* this is not a run-time error.*/
 					/* TODO: set ERRNO */
-					run->errnum = SSE_AWK_EIOHANDLER;
+					run->errnum = ASE_AWK_EIOHANDLER;
 					return -1;
 				}
 			}
 
-			if (px != SSE_NULL) px->next = p->next;
+			if (px != ASE_NULL) px->next = p->next;
 			else run->extio.chain = p->next;
 
-			SSE_AWK_FREE (run->awk, p->name);
-			SSE_AWK_FREE (run->awk, p);
+			ASE_AWK_FREE (run->awk, p->name);
+			ASE_AWK_FREE (run->awk, p);
 			return 0;
 		}
 
@@ -686,23 +686,23 @@ int sse_awk_closeextio_read (
 	}
 
 	/* this is not a run-time error */
-	run->errnum = SSE_AWK_EIOHANDLER;
+	run->errnum = ASE_AWK_EIOHANDLER;
 	return -1;
 }
 
-int sse_awk_closeextio_write (
-	sse_awk_run_t* run, int out_type, const sse_char_t* name)
+int ase_awk_closeextio_write (
+	ase_awk_run_t* run, int out_type, const ase_char_t* name)
 {
-	sse_awk_extio_t* p = run->extio.chain, * px = SSE_NULL;
-	sse_awk_io_t handler;
+	ase_awk_extio_t* p = run->extio.chain, * px = ASE_NULL;
+	ase_awk_io_t handler;
 	int extio_type, extio_mode, extio_mask;
 
-	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));
+	ase_awk_assert (run->awk,
+		out_type >= 0 && out_type <= ase_countof(__out_type_map));
+	ase_awk_assert (run->awk,
+		out_type >= 0 && out_type <= ase_countof(__out_mode_map));
+	ase_awk_assert (run->awk,
+		out_type >= 0 && out_type <= ase_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 sse_awk_closeextio_write (
 	extio_mask = __out_mask_map[out_type];
 
 	handler = run->extio.handler[extio_type];
-	if (handler == SSE_NULL)
+	if (handler == ASE_NULL)
 	{
 		/* no io handler provided */
-		run->errnum = SSE_AWK_EIOIMPL; /* TODO: change the error code */
+		run->errnum = ASE_AWK_EIOIMPL; /* TODO: change the error code */
 		return -1;
 	}
 
-	while (p != SSE_NULL)
+	while (p != ASE_NULL)
 	{
 		if (p->type == (extio_type | extio_mask) &&
-		    sse_awk_strcmp (p->name, name) == 0) 
+		    ase_awk_strcmp (p->name, name) == 0) 
 		{
-			sse_awk_io_t handler;
+			ase_awk_io_t handler;
 		       
 			handler = run->extio.handler[p->type & __MASK_CLEAR];
-			if (handler != SSE_NULL)
+			if (handler != ASE_NULL)
 			{
-				if (handler (SSE_AWK_IO_CLOSE, p, SSE_NULL, 0) == -1)
+				if (handler (ASE_AWK_IO_CLOSE, p, ASE_NULL, 0) == -1)
 				{
 					/* this is not a run-time error.*/
 					/* TODO: set ERRNO */
-					run->errnum = SSE_AWK_EIOHANDLER;
+					run->errnum = ASE_AWK_EIOHANDLER;
 					return -1;
 				}
 			}
 
-			if (px != SSE_NULL) px->next = p->next;
+			if (px != ASE_NULL) px->next = p->next;
 			else run->extio.chain = p->next;
 
-			SSE_AWK_FREE (run->awk, p->name);
-			SSE_AWK_FREE (run->awk, p);
+			ASE_AWK_FREE (run->awk, p->name);
+			ASE_AWK_FREE (run->awk, p);
 			return 0;
 		}
 
@@ -750,39 +750,39 @@ int sse_awk_closeextio_write (
 
 	/* this is not a run-time error */
 	/* TODO: set ERRNO */
-	run->errnum = SSE_AWK_EIOHANDLER;
+	run->errnum = ASE_AWK_EIOHANDLER;
 	return -1;
 }
 
-int sse_awk_closeextio (sse_awk_run_t* run, const sse_char_t* name)
+int ase_awk_closeextio (ase_awk_run_t* run, const ase_char_t* name)
 {
-	sse_awk_extio_t* p = run->extio.chain, * px = SSE_NULL;
+	ase_awk_extio_t* p = run->extio.chain, * px = ASE_NULL;
 
-	while (p != SSE_NULL)
+	while (p != ASE_NULL)
 	{
 		 /* it handles the first that matches the given name
 		  * regardless of the extio type */
-		if (sse_awk_strcmp (p->name, name) == 0) 
+		if (ase_awk_strcmp (p->name, name) == 0) 
 		{
-			sse_awk_io_t handler;
+			ase_awk_io_t handler;
 		       
 			handler = run->extio.handler[p->type & __MASK_CLEAR];
-			if (handler != SSE_NULL)
+			if (handler != ASE_NULL)
 			{
-				if (handler (SSE_AWK_IO_CLOSE, p, SSE_NULL, 0) == -1)
+				if (handler (ASE_AWK_IO_CLOSE, p, ASE_NULL, 0) == -1)
 				{
 					/* this is not a run-time error.*/
 					/* TODO: set ERRNO */
-					run->errnum = SSE_AWK_EIOHANDLER;
+					run->errnum = ASE_AWK_EIOHANDLER;
 					return -1;
 				}
 			}
 
-			if (px != SSE_NULL) px->next = p->next;
+			if (px != ASE_NULL) px->next = p->next;
 			else run->extio.chain = p->next;
 
-			SSE_AWK_FREE (run->awk, p->name);
-			SSE_AWK_FREE (run->awk, p);
+			ASE_AWK_FREE (run->awk, p->name);
+			ASE_AWK_FREE (run->awk, p);
 			return 0;
 		}
 
@@ -792,25 +792,25 @@ int sse_awk_closeextio (sse_awk_run_t* run, const sse_char_t* name)
 
 	/* this is not a run-time error */
 	/* TODO: set ERRNO */
-	run->errnum = SSE_AWK_EIOHANDLER;
+	run->errnum = ASE_AWK_EIOHANDLER;
 	return -1;
 }
 
-void sse_awk_clearextio (sse_awk_run_t* run)
+void ase_awk_clearextio (ase_awk_run_t* run)
 {
-	sse_awk_extio_t* next;
-	sse_awk_io_t handler;
+	ase_awk_extio_t* next;
+	ase_awk_io_t handler;
 	int n;
 
-	while (run->extio.chain != SSE_NULL)
+	while (run->extio.chain != ASE_NULL)
 	{
 		handler = run->extio.handler[
 			run->extio.chain->type & __MASK_CLEAR];
 		next = run->extio.chain->next;
 
-		if (handler != SSE_NULL)
+		if (handler != ASE_NULL)
 		{
-			n = handler (SSE_AWK_IO_CLOSE, run->extio.chain, SSE_NULL, 0);
+			n = handler (ASE_AWK_IO_CLOSE, run->extio.chain, ASE_NULL, 0);
 			if (n == -1)
 			{
 				/* TODO: 
@@ -818,8 +818,8 @@ void sse_awk_clearextio (sse_awk_run_t* run)
 			}
 		}
 
-		SSE_AWK_FREE (run->awk, run->extio.chain->name);
-		SSE_AWK_FREE (run->awk, run->extio.chain);
+		ASE_AWK_FREE (run->awk, run->extio.chain->name);
+		ASE_AWK_FREE (run->awk, run->extio.chain);
 
 		run->extio.chain = next;
 	}
diff --git a/ase/awk/extio.h b/ase/awk/extio.h
index 306c8b3e..f5c345ef 100644
--- a/ase/awk/extio.h
+++ b/ase/awk/extio.h
@@ -1,48 +1,48 @@
 /*
- * $Id: extio.h,v 1.14 2006-10-22 11:34:53 bacon Exp $
+ * $Id: extio.h,v 1.15 2006-10-24 04:10:12 bacon Exp $
  */
 
-#ifndef _SSE_AWK_EXTIO_H_
-#define _SSE_AWK_EXTIO_H_
+#ifndef _ASE_AWK_EXTIO_H_
+#define _ASE_AWK_EXTIO_H_
 
-#ifndef _SSE_AWK_AWK_H_
-#error Never include this file directly. Include <sse/awk/awk.h> instead
+#ifndef _ASE_AWK_AWK_H_
+#error Never include this file directly. Include <ase/awk/awk.h> instead
 #endif
 
 #ifdef __cplusplus
 extern "C"
 #endif
 
-int sse_awk_readextio (
-	sse_awk_run_t* run, int in_type, 
-	const sse_char_t* name, sse_awk_str_t* buf);
+int ase_awk_readextio (
+	ase_awk_run_t* run, int in_type, 
+	const ase_char_t* name, ase_awk_str_t* buf);
 
-int sse_awk_writeextio_val (
-	sse_awk_run_t* run, int out_type, 
-	const sse_char_t* name, sse_awk_val_t* v);
+int ase_awk_writeextio_val (
+	ase_awk_run_t* run, int out_type, 
+	const ase_char_t* name, ase_awk_val_t* v);
 
-int sse_awk_writeextio_str (
-	sse_awk_run_t* run, int out_type, 
-	const sse_char_t* name, sse_char_t* str, sse_size_t len);
+int ase_awk_writeextio_str (
+	ase_awk_run_t* run, int out_type, 
+	const ase_char_t* name, ase_char_t* str, ase_size_t len);
 
-int sse_awk_flushextio (
-	sse_awk_run_t* run, int out_type, const sse_char_t* name);
+int ase_awk_flushextio (
+	ase_awk_run_t* run, int out_type, const ase_char_t* name);
 
-int sse_awk_nextextio_read (
-	sse_awk_run_t* run, int in_type, const sse_char_t* name);
+int ase_awk_nextextio_read (
+	ase_awk_run_t* run, int in_type, const ase_char_t* name);
 
 /* TODO:
-int sse_awk_nextextio_write (
-	sse_awk_run_t* run, int out_type, const sse_char_t* name);
+int ase_awk_nextextio_write (
+	ase_awk_run_t* run, int out_type, const ase_char_t* name);
 */
 
-int sse_awk_closeextio_read (
-	sse_awk_run_t* run, int in_type, const sse_char_t* name);
-int sse_awk_closeextio_write (
-	sse_awk_run_t* run, int out_type, const sse_char_t* name);
-int sse_awk_closeextio (sse_awk_run_t* run, const sse_char_t* name);
+int ase_awk_closeextio_read (
+	ase_awk_run_t* run, int in_type, const ase_char_t* name);
+int ase_awk_closeextio_write (
+	ase_awk_run_t* run, int out_type, const ase_char_t* name);
+int ase_awk_closeextio (ase_awk_run_t* run, const ase_char_t* name);
 
-void sse_awk_clearextio (sse_awk_run_t* run);
+void ase_awk_clearextio (ase_awk_run_t* run);
 
 #ifdef __cplusplus
 }
diff --git a/ase/awk/func.c b/ase/awk/func.c
index 7e11fcb9..e3cb718c 100644
--- a/ase/awk/func.c
+++ b/ase/awk/func.c
@@ -1,8 +1,8 @@
 /*
- * $Id: func.c,v 1.67 2006-10-22 12:39:29 bacon Exp $
+ * $Id: func.c,v 1.68 2006-10-24 04:10:12 bacon Exp $
  */
 
-#include <sse/awk/awk_i.h>
+#include <ase/awk/awk_i.h>
 
 #ifdef _WIN32
 	#include <tchar.h>
@@ -12,56 +12,56 @@
 	#include <math.h>
 #endif
 
-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);*/
+static int __bfn_close   (ase_awk_run_t* run);
+static int __bfn_fflush  (ase_awk_run_t* run);
+static int __bfn_index   (ase_awk_run_t* run);
+static int __bfn_length  (ase_awk_run_t* run);
+static int __bfn_substr  (ase_awk_run_t* run);
+static int __bfn_split   (ase_awk_run_t* run);
+static int __bfn_tolower (ase_awk_run_t* run);
+static int __bfn_toupper (ase_awk_run_t* run);
+static int __bfn_gsub    (ase_awk_run_t* run);
+static int __bfn_sub     (ase_awk_run_t* run);
+static int __bfn_match   (ase_awk_run_t* run);
+static int __bfn_system  (ase_awk_run_t* run);
+/*static int __bfn_sin   (ase_awk_run_t* run);*/
 
 /* TODO: move it under the awk structure... */
-static sse_awk_bfn_t __sys_bfn[] = 
+static ase_awk_bfn_t __sys_bfn[] = 
 {
 	/* io functions */
-	{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},
+	{ASE_T("close"),   5, ASE_AWK_EXTIO, 1,  1,  ASE_NULL,     __bfn_close},
+	{ASE_T("fflush"),  6, ASE_AWK_EXTIO, 0,  1,  ASE_NULL,     __bfn_fflush},
 
 	/* string functions */
-	{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},
+	{ASE_T("index"),   5, 0,            2,  2,  ASE_NULL,     __bfn_index},
+	{ASE_T("substr"),  6, 0,            2,  3,  ASE_NULL,     __bfn_substr},
+	{ASE_T("length"),  6, 0,            1,  1,  ASE_NULL,     __bfn_length},
+	{ASE_T("split"),   5, 0,            2,  3,  ASE_T("vrv"), __bfn_split},
+	{ASE_T("tolower"), 7, 0,            1,  1,  ASE_NULL,     __bfn_tolower},
+	{ASE_T("toupper"), 7, 0,            1,  1,  ASE_NULL,     __bfn_toupper},
+	{ASE_T("gsub"),    4, 0,            2,  3,  ASE_T("xvr"), __bfn_gsub},
+	{ASE_T("sub"),     3, 0,            2,  3,  ASE_T("xvr"), __bfn_sub},
+	{ASE_T("match"),   5, 0,            2,  2,  ASE_T("vx"),  __bfn_match},
 
 	/* TODO: remove these two functions */
-	{SSE_T("system"),  6, 0,            1,  1,  SSE_NULL,     __bfn_system},
-	/*{ SSE_T("sin"),     3, 0,            1,  1,  SSE_NULL,   __bfn_sin},*/
+	{ASE_T("system"),  6, 0,            1,  1,  ASE_NULL,     __bfn_system},
+	/*{ ASE_T("sin"),     3, 0,            1,  1,  ASE_NULL,   __bfn_sin},*/
 
-	{SSE_NULL,         0, 0,            0,  0,  SSE_NULL,     SSE_NULL}
+	{ASE_NULL,         0, 0,            0,  0,  ASE_NULL,     ASE_NULL}
 };
 
-sse_awk_bfn_t* sse_awk_addbfn (
-	sse_awk_t* awk, const sse_char_t* name, sse_size_t name_len, 
-	int when_valid, sse_size_t min_args, sse_size_t max_args, 
-	const sse_char_t* arg_spec, int (*handler)(sse_awk_run_t*))
+ase_awk_bfn_t* ase_awk_addbfn (
+	ase_awk_t* awk, const ase_char_t* name, ase_size_t name_len, 
+	int when_valid, ase_size_t min_args, ase_size_t max_args, 
+	const ase_char_t* arg_spec, int (*handler)(ase_awk_run_t*))
 {
-	sse_awk_bfn_t* p;
+	ase_awk_bfn_t* p;
 
 /* TODO: complete this function??? */
 
-	p = (sse_awk_bfn_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_bfn_t));
-	if (p == SSE_NULL) return SSE_NULL;
+	p = (ase_awk_bfn_t*) ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_bfn_t));
+	if (p == ASE_NULL) return ASE_NULL;
 
 	/* NOTE: make sure that name is a constant string */
 	p->name = name;  
@@ -78,19 +78,19 @@ sse_awk_bfn_t* sse_awk_addbfn (
 	return p;
 }
 
-int sse_awk_delbfn (sse_awk_t* awk, const sse_char_t* name, sse_size_t name_len)
+int ase_awk_delbfn (ase_awk_t* awk, const ase_char_t* name, ase_size_t name_len)
 {
-	sse_awk_bfn_t* p, * pp = SSE_NULL;
+	ase_awk_bfn_t* p, * pp = ASE_NULL;
 
-	for (p = awk->bfn.user; p != SSE_NULL; p++)
+	for (p = awk->bfn.user; p != ASE_NULL; p++)
 	{
-		if (sse_awk_strxncmp(p->name, p->name_len, name, name_len) == 0)
+		if (ase_awk_strxncmp(p->name, p->name_len, name, name_len) == 0)
 		{
-			if (pp == SSE_NULL)
+			if (pp == ASE_NULL)
 				awk->bfn.user = p->next;
 			else pp->next = p->next;
 
-			SSE_AWK_FREE (awk, p);
+			ASE_AWK_FREE (awk, p);
 			return 0;
 		}
 
@@ -100,74 +100,74 @@ int sse_awk_delbfn (sse_awk_t* awk, const sse_char_t* name, sse_size_t name_len)
 	return -1;
 }
 
-void sse_awk_clrbfn (sse_awk_t* awk)
+void ase_awk_clrbfn (ase_awk_t* awk)
 {
-	sse_awk_bfn_t* p, * np;
+	ase_awk_bfn_t* p, * np;
 
 	p = awk->bfn.user;
-	while (p != SSE_NULL)
+	while (p != ASE_NULL)
 	{
 		np = p;
-		SSE_AWK_FREE (awk, p);
+		ASE_AWK_FREE (awk, p);
 		p = np;
 	}
 
-	awk->bfn.user = SSE_NULL;
+	awk->bfn.user = ASE_NULL;
 }
 
-sse_awk_bfn_t* sse_awk_getbfn (
-	sse_awk_t* awk, const sse_char_t* name, sse_size_t name_len)
+ase_awk_bfn_t* ase_awk_getbfn (
+	ase_awk_t* awk, const ase_char_t* name, ase_size_t name_len)
 {
-	sse_awk_bfn_t* p;
+	ase_awk_bfn_t* p;
 
-	for (p = __sys_bfn; p->name != SSE_NULL; p++)
+	for (p = __sys_bfn; p->name != ASE_NULL; p++)
 	{
 		if (p->valid != 0 && 
 		    (awk->option & p->valid) == 0) continue;
 
-		if (sse_awk_strxncmp (
+		if (ase_awk_strxncmp (
 			p->name, p->name_len, name, name_len) == 0) return p;
 	}
 
 /* TODO: user-added builtin functions... */
-	for (p = awk->bfn.user; p != SSE_NULL; p = p->next)
+	for (p = awk->bfn.user; p != ASE_NULL; p = p->next)
 	{
 		if (p->valid != 0 && 
 		    (awk->option & p->valid) == 0) continue;
 
-		if (sse_awk_strxncmp (
+		if (ase_awk_strxncmp (
 			p->name, p->name_len, name, name_len) == 0) return p;
 	}
 
-	return SSE_NULL;
+	return ASE_NULL;
 }
 
-static int __bfn_close (sse_awk_run_t* run)
+static int __bfn_close (ase_awk_run_t* run)
 {
-	sse_size_t nargs;
-	sse_awk_val_t* v, * a0;
+	ase_size_t nargs;
+	ase_awk_val_t* v, * a0;
 	int n;
 
-	sse_char_t* name;
-	sse_size_t len;
+	ase_char_t* name;
+	ase_size_t len;
        
-	nargs = sse_awk_getnargs (run);
-	sse_awk_assert (run->awk, nargs == 1);
+	nargs = ase_awk_getnargs (run);
+	ase_awk_assert (run->awk, nargs == 1);
 /* TODO: support close (xxx, "to"/"from") like gawk */
 
-	a0 = sse_awk_getarg (run, 0);
-	sse_awk_assert (run->awk, a0 != SSE_NULL);
+	a0 = ase_awk_getarg (run, 0);
+	ase_awk_assert (run->awk, a0 != ASE_NULL);
 
-	if (a0->type == SSE_AWK_VAL_STR)
+	if (a0->type == ASE_AWK_VAL_STR)
 	{
-		name = ((sse_awk_val_str_t*)a0)->buf;
-		len = ((sse_awk_val_str_t*)a0)->len;
+		name = ((ase_awk_val_str_t*)a0)->buf;
+		len = ((ase_awk_val_str_t*)a0)->len;
 	}
 	else
 	{
-		name = sse_awk_valtostr (
-			run, a0, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
-		if (name == SSE_NULL) return -1;
+		name = ase_awk_valtostr (
+			run, a0, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &len);
+		if (name == ASE_NULL) return -1;
 	}
 
 	if (len == 0)
@@ -180,7 +180,7 @@ static int __bfn_close (sse_awk_run_t* run)
 		 * 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 != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, name);
+		if (a0->type != ASE_AWK_VAL_STR) ASE_AWK_FREE (run->awk, name);
 		n = -1;
 		/* TODO: need to set ERRNO??? */
 		goto skip_close;
@@ -188,52 +188,52 @@ static int __bfn_close (sse_awk_run_t* run)
 
 	while (len > 0)
 	{
-		if (name[--len] == SSE_T('\0'))
+		if (name[--len] == ASE_T('\0'))
 		{
 			/* the name contains a null string. 
 			 * make close return -1 */
-			if (a0->type != SSE_AWK_VAL_STR) 
-				SSE_AWK_FREE (run->awk, name);
+			if (a0->type != ASE_AWK_VAL_STR) 
+				ASE_AWK_FREE (run->awk, name);
 			n = -1;
 			/* TODO: need to set ERRNO??? */
 			goto skip_close;
 		}
 	}	
 
-	n = sse_awk_closeextio (run, name);
-	if (n == -1 && run->errnum != SSE_AWK_EIOHANDLER)
+	n = ase_awk_closeextio (run, name);
+	if (n == -1 && run->errnum != ASE_AWK_EIOHANDLER)
 	{
-		if (a0->type != SSE_AWK_VAL_STR) 
-			SSE_AWK_FREE (run->awk, name);
+		if (a0->type != ASE_AWK_VAL_STR) 
+			ASE_AWK_FREE (run->awk, name);
 		return -1;
 	}
 
-	if (a0->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, name);
+	if (a0->type != ASE_AWK_VAL_STR) ASE_AWK_FREE (run->awk, name);
 
 skip_close:
-	v = sse_awk_makeintval (run, n);
-	if (v == SSE_NULL)
+	v = ase_awk_makeintval (run, n);
+	if (v == ASE_NULL)
 	{
-		sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
+		ase_awk_setrunerrnum (run, ASE_AWK_ENOMEM);
 		return -1;
 	}
 
-	sse_awk_setretval (run, v);
+	ase_awk_setretval (run, v);
 	return 0;
 }
 
 static int __flush_extio (
-	sse_awk_run_t* run, int extio, const sse_char_t* name, int n)
+	ase_awk_run_t* run, int extio, const ase_char_t* name, int n)
 {
 	int n2;
 
-	if (run->extio.handler[extio] != SSE_NULL)
+	if (run->extio.handler[extio] != ASE_NULL)
 	{
-		n2 = sse_awk_flushextio (run, extio, name);
+		n2 = ase_awk_flushextio (run, extio, name);
 		if (n2 == -1)
 		{
-			if (run->errnum == SSE_AWK_EIOHANDLER) n = -1;
-			else if (run->errnum == SSE_AWK_ENOSUCHIO) 
+			if (run->errnum == ASE_AWK_EIOHANDLER) n = -1;
+			else if (run->errnum == ASE_AWK_ENOSUCHIO) 
 			{
 				if (n != 0) n = -2;
 			}
@@ -245,24 +245,24 @@ static int __flush_extio (
 	return n;
 }
 
-static int __bfn_fflush (sse_awk_run_t* run)
+static int __bfn_fflush (ase_awk_run_t* run)
 {
-	sse_size_t nargs;
-	sse_awk_val_t* a0;
-	sse_char_t* str0;
-	sse_size_t len0;
+	ase_size_t nargs;
+	ase_awk_val_t* a0;
+	ase_char_t* str0;
+	ase_size_t len0;
 	int n;
        
-	nargs = sse_awk_getnargs (run);
-	sse_awk_assert (run->awk, nargs >= 0 && nargs <= 1);
+	nargs = ase_awk_getnargs (run);
+	ase_awk_assert (run->awk, nargs >= 0 && nargs <= 1);
 
 	if (nargs == 0)
 	{
 		/* flush the console output */
-		n = sse_awk_flushextio (run, SSE_AWK_OUT_CONSOLE, SSE_T(""));
+		n = ase_awk_flushextio (run, ASE_AWK_OUT_CONSOLE, ASE_T(""));
 		if (n == -1 && 
-		    run->errnum != SSE_AWK_EIOHANDLER && 
-		    run->errnum != SSE_AWK_ENOSUCHIO)
+		    run->errnum != ASE_AWK_EIOHANDLER && 
+		    run->errnum != ASE_AWK_ENOSUCHIO)
 		{
 			return -1;
 		}
@@ -271,19 +271,19 @@ static int __bfn_fflush (sse_awk_run_t* run)
 	}
 	else
 	{
-		sse_char_t* ptr, * end;
+		ase_char_t* ptr, * end;
 
-		a0 = sse_awk_getarg (run, 0);
-		if (a0->type == SSE_AWK_VAL_STR)
+		a0 = ase_awk_getarg (run, 0);
+		if (a0->type == ASE_AWK_VAL_STR)
 		{
-			str0 = ((sse_awk_val_str_t*)a0)->buf;
-			len0 = ((sse_awk_val_str_t*)a0)->len;
+			str0 = ((ase_awk_val_str_t*)a0)->buf;
+			len0 = ((ase_awk_val_str_t*)a0)->len;
 		}
 		else
 		{
-			str0 = sse_awk_valtostr (
-				run, a0, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len0);
-			if (str0 == SSE_NULL) return -1;
+			str0 = ase_awk_valtostr (
+				run, a0, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &len0);
+			if (str0 == ASE_NULL) return -1;
 
 		}
 
@@ -292,10 +292,10 @@ static int __bfn_fflush (sse_awk_run_t* run)
 		ptr = str0; end = str0 + len0;
 		while (ptr < end)
 		{
-			if (*ptr == SSE_T('\0')) 
+			if (*ptr == ASE_T('\0')) 
 			{
-				if (a0->type != SSE_AWK_VAL_STR) 
-					SSE_AWK_FREE (run->awk, str0);
+				if (a0->type != ASE_AWK_VAL_STR) 
+					ASE_AWK_FREE (run->awk, str0);
 				n = -1;
 				goto skip_flush;
 			}
@@ -307,16 +307,16 @@ static int __bfn_fflush (sse_awk_run_t* run)
 		n = 1;
 
 		n = __flush_extio (
-			run, SSE_AWK_EXTIO_FILE, 
-			((len0 == 0)? SSE_NULL: str0), 1);
+			run, ASE_AWK_EXTIO_FILE, 
+			((len0 == 0)? ASE_NULL: str0), 1);
 		if (n == -99) return -1;
 		n = __flush_extio (
-			run, SSE_AWK_EXTIO_PIPE,
-			((len0 == 0)? SSE_NULL: str0), n);
+			run, ASE_AWK_EXTIO_PIPE,
+			((len0 == 0)? ASE_NULL: str0), n);
 		if (n == -99) return -1;
 		n = __flush_extio (
-			run, SSE_AWK_EXTIO_COPROC,
-			((len0 == 0)? SSE_NULL: str0), n);
+			run, ASE_AWK_EXTIO_COPROC,
+			((len0 == 0)? ASE_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 (sse_awk_run_t* run)
 		 * if n is -1, the io handler has returned an error */
 		if (n != 0) n = -1;
 
-		if (a0->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str0);
+		if (a0->type != ASE_AWK_VAL_STR) ASE_AWK_FREE (run->awk, str0);
 	}
 
 skip_flush:
-	a0 = sse_awk_makeintval (run, (sse_long_t)n);
-	if (a0 == SSE_NULL)
+	a0 = ase_awk_makeintval (run, (ase_long_t)n);
+	if (a0 == ASE_NULL)
 	{
-		sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
+		ase_awk_setrunerrnum (run, ASE_AWK_ENOMEM);
 		return -1;
 	}
 
-	sse_awk_setretval (run, a0);
+	ase_awk_setretval (run, a0);
 	return 0;
 }
 
-static int __bfn_index (sse_awk_run_t* run)
+static int __bfn_index (ase_awk_run_t* run)
 {
-	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;
+	ase_size_t nargs;
+	ase_awk_val_t* a0, * a1;
+	ase_char_t* str0, * str1, * ptr;
+	ase_size_t len0, len1;
+	ase_long_t idx;
 
-	nargs = sse_awk_getnargs (run);
-	sse_awk_assert (run->awk, nargs == 2);
+	nargs = ase_awk_getnargs (run);
+	ase_awk_assert (run->awk, nargs == 2);
 	
-	a0 = sse_awk_getarg (run, 0);
-	a1 = sse_awk_getarg (run, 1);
+	a0 = ase_awk_getarg (run, 0);
+	a1 = ase_awk_getarg (run, 1);
 
-	if (a0->type == SSE_AWK_VAL_STR)
+	if (a0->type == ASE_AWK_VAL_STR)
 	{
-		str0 = ((sse_awk_val_str_t*)a0)->buf;
-		len0 = ((sse_awk_val_str_t*)a0)->len;
+		str0 = ((ase_awk_val_str_t*)a0)->buf;
+		len0 = ((ase_awk_val_str_t*)a0)->len;
 	}
 	else
 	{
-		str0 = sse_awk_valtostr (
-			run, a0, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len0);
-		if (str0 == SSE_NULL) return -1;
+		str0 = ase_awk_valtostr (
+			run, a0, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &len0);
+		if (str0 == ASE_NULL) return -1;
 	}
 
-	if (a1->type == SSE_AWK_VAL_STR)
+	if (a1->type == ASE_AWK_VAL_STR)
 	{
-		str1 = ((sse_awk_val_str_t*)a1)->buf;
-		len1 = ((sse_awk_val_str_t*)a1)->len;
+		str1 = ((ase_awk_val_str_t*)a1)->buf;
+		len1 = ((ase_awk_val_str_t*)a1)->len;
 	}
 	else
 	{
-		str1 = sse_awk_valtostr (
-			run, a1, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len1);
-		if (str1 == SSE_NULL)
+		str1 = ase_awk_valtostr (
+			run, a1, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &len1);
+		if (str1 == ASE_NULL)
 		{
-			if (a0->type != SSE_AWK_VAL_STR) 
-				SSE_AWK_FREE (run->awk, str0);
+			if (a0->type != ASE_AWK_VAL_STR) 
+				ASE_AWK_FREE (run->awk, str0);
 			return -1;
 		}
 	}
 
-	ptr = sse_awk_strxnstr (str0, len0, str1, len1);
-	idx = (ptr == SSE_NULL)? -1: (sse_long_t)(ptr - str0);
+	ptr = ase_awk_strxnstr (str0, len0, str1, len1);
+	idx = (ptr == ASE_NULL)? -1: (ase_long_t)(ptr - str0);
 
-	if (sse_awk_getopt(run->awk) & SSE_AWK_STRINDEXONE) idx = idx + 1;
+	if (ase_awk_getopt(run->awk) & ASE_AWK_STRINDEXONE) idx = idx + 1;
 
-	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);
+	if (a0->type != ASE_AWK_VAL_STR) ASE_AWK_FREE (run->awk, str0);
+	if (a1->type != ASE_AWK_VAL_STR) ASE_AWK_FREE (run->awk, str1);
 
-	a0 = sse_awk_makeintval (run, idx);
-	if (a0 == SSE_NULL)
+	a0 = ase_awk_makeintval (run, idx);
+	if (a0 == ASE_NULL)
 	{
-		sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
+		ase_awk_setrunerrnum (run, ASE_AWK_ENOMEM);
 		return -1;
 	}
 
-	sse_awk_setretval (run, a0);
+	ase_awk_setretval (run, a0);
 	return 0;
 }
 
-static int __bfn_length (sse_awk_run_t* run)
+static int __bfn_length (ase_awk_run_t* run)
 {
-	sse_size_t nargs;
-	sse_awk_val_t* v;
-	sse_char_t* str;
-	sse_size_t len;
+	ase_size_t nargs;
+	ase_awk_val_t* v;
+	ase_char_t* str;
+	ase_size_t len;
 
-	nargs = sse_awk_getnargs (run);
-	sse_awk_assert (run->awk, nargs == 1);
+	nargs = ase_awk_getnargs (run);
+	ase_awk_assert (run->awk, nargs == 1);
 	
-	v = sse_awk_getarg (run, 0);
-	if (v->type == SSE_AWK_VAL_STR)
+	v = ase_awk_getarg (run, 0);
+	if (v->type == ASE_AWK_VAL_STR)
 	{
-		len = ((sse_awk_val_str_t*)v)->len;
+		len = ((ase_awk_val_str_t*)v)->len;
 	}
 	else
 	{
-		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);
+		str = ase_awk_valtostr (
+			run, v, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &len);
+		if (str == ASE_NULL) return -1;
+		ASE_AWK_FREE (run->awk, str);
 	}
 
-	v = sse_awk_makeintval (run, len);
-	if (v == SSE_NULL)
+	v = ase_awk_makeintval (run, len);
+	if (v == ASE_NULL)
 	{
-		sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
+		ase_awk_setrunerrnum (run, ASE_AWK_ENOMEM);
 		return -1;
 	}
 
-	sse_awk_setretval (run, v);
+	ase_awk_setretval (run, v);
 	return 0;
 }
 
-static int __bfn_substr (sse_awk_run_t* run)
+static int __bfn_substr (ase_awk_run_t* run)
 {
-	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;
+	ase_size_t nargs;
+	ase_awk_val_t* a0, * a1, * a2, * r;
+	ase_char_t* str;
+	ase_size_t len;
+	ase_long_t lindex, lcount;
+	ase_real_t rindex, rcount;
 	int n;
 
-	nargs = sse_awk_getnargs (run);
-	sse_awk_assert (run->awk, nargs >= 2 && nargs <= 3);
+	nargs = ase_awk_getnargs (run);
+	ase_awk_assert (run->awk, nargs >= 2 && nargs <= 3);
 
-	a0 = sse_awk_getarg (run, 0);
-	a1 = sse_awk_getarg (run, 1);
-	a2 = (nargs >= 3)? sse_awk_getarg (run, 2): SSE_NULL;
+	a0 = ase_awk_getarg (run, 0);
+	a1 = ase_awk_getarg (run, 1);
+	a2 = (nargs >= 3)? ase_awk_getarg (run, 2): ASE_NULL;
 
-	if (a0->type == SSE_AWK_VAL_STR)
+	if (a0->type == ASE_AWK_VAL_STR)
 	{
-		str = ((sse_awk_val_str_t*)a0)->buf;
-		len = ((sse_awk_val_str_t*)a0)->len;
+		str = ((ase_awk_val_str_t*)a0)->buf;
+		len = ((ase_awk_val_str_t*)a0)->len;
 	}
 	else 
 	{
-		str = sse_awk_valtostr (
-			run, a0, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
-		if (str == SSE_NULL) return -1;
+		str = ase_awk_valtostr (
+			run, a0, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &len);
+		if (str == ASE_NULL) return -1;
 	}
 
-	n = sse_awk_valtonum (run, a1, &lindex, &rindex);
+	n = ase_awk_valtonum (run, a1, &lindex, &rindex);
 	if (n == -1) 
 	{
-		if (a0->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str);
+		if (a0->type != ASE_AWK_VAL_STR) ASE_AWK_FREE (run->awk, str);
 		return -1;
 	}
-	if (n == 1) lindex = (sse_long_t)rindex;
+	if (n == 1) lindex = (ase_long_t)rindex;
 
-	if (a2 == SSE_NULL) lcount = (sse_long_t)len;
+	if (a2 == ASE_NULL) lcount = (ase_long_t)len;
 	else 
 	{
-		n = sse_awk_valtonum (run, a2, &lcount, &rcount);
+		n = ase_awk_valtonum (run, a2, &lcount, &rcount);
 		if (n == -1) 
 		{
-			if (a0->type != SSE_AWK_VAL_STR) 
-				SSE_AWK_FREE (run->awk, str);
+			if (a0->type != ASE_AWK_VAL_STR) 
+				ASE_AWK_FREE (run->awk, str);
 			return -1;
 		}
-		if (n == 1) lcount = (sse_long_t)rcount;
+		if (n == 1) lcount = (ase_long_t)rcount;
 	}
 
-	if (sse_awk_getopt(run->awk) & SSE_AWK_STRINDEXONE) lindex = lindex - 1;
+	if (ase_awk_getopt(run->awk) & ASE_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 = sse_awk_makestrval (run, &str[lindex], (sse_size_t)lcount);
-	if (r == SSE_NULL)
+	r = ase_awk_makestrval (run, &str[lindex], (ase_size_t)lcount);
+	if (r == ASE_NULL)
 	{
-		if (a0->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str);
-		sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
+		if (a0->type != ASE_AWK_VAL_STR) ASE_AWK_FREE (run->awk, str);
+		ase_awk_setrunerrnum (run, ASE_AWK_ENOMEM);
 		return -1;
 	}
 
-	if (a0->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str);
-	sse_awk_setretval (run, r);
+	if (a0->type != ASE_AWK_VAL_STR) ASE_AWK_FREE (run->awk, str);
+	ase_awk_setretval (run, r);
 	return 0;
 }
 
-static int __bfn_split (sse_awk_run_t* run)
+static int __bfn_split (ase_awk_run_t* run)
 {
-	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;
+	ase_size_t nargs;
+	ase_awk_val_t* a0, * a1, * a2, * t1, * t2, ** a1_ref;
+	ase_char_t* str, * str_free, * p, * tok;
+	ase_size_t str_len, str_left, tok_len;
+	ase_long_t sta, num;
+	ase_char_t key[ase_sizeof(ase_long_t)*8+2];
+	ase_size_t key_len;
+	ase_char_t* fs_ptr, * fs_free;
+	ase_size_t fs_len;
+	void* fs_rex = ASE_NULL; 
+	void* fs_rex_free = ASE_NULL;
 	int errnum;
 
-	nargs = sse_awk_getnargs (run);
-	sse_awk_assert (run->awk, nargs >= 2 && nargs <= 3);
+	nargs = ase_awk_getnargs (run);
+	ase_awk_assert (run->awk, nargs >= 2 && nargs <= 3);
 
-	a0 = sse_awk_getarg (run, 0);
-	a1 = sse_awk_getarg (run, 1);
-	a2 = (nargs >= 3)? sse_awk_getarg (run, 2): SSE_NULL;
+	a0 = ase_awk_getarg (run, 0);
+	a1 = ase_awk_getarg (run, 1);
+	a2 = (nargs >= 3)? ase_awk_getarg (run, 2): ASE_NULL;
 
-	sse_awk_assert (run->awk, a1->type == SSE_AWK_VAL_REF);
+	ase_awk_assert (run->awk, a1->type == ASE_AWK_VAL_REF);
 
-	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)
+	if (((ase_awk_val_ref_t*)a1)->id >= ASE_AWK_VAL_REF_NAMEDIDX &&
+	    ((ase_awk_val_ref_t*)a1)->id <= ASE_AWK_VAL_REF_ARGIDX)
 	{
 		/* an indexed value should not be assigned another map */
-		sse_awk_setrunerrnum (run, SSE_AWK_EIDXVALASSMAP);
+		ase_awk_setrunerrnum (run, ASE_AWK_EIDXVALASSMAP);
 		return -1;
 	}
 
-	if (((sse_awk_val_ref_t*)a1)->id == SSE_AWK_VAL_REF_POS)
+	if (((ase_awk_val_ref_t*)a1)->id == ASE_AWK_VAL_REF_POS)
 	{
 		/* a positional should not be assigned a map */
-		sse_awk_setrunerrnum (run, SSE_AWK_EPOSVALASSMAP);
+		ase_awk_setrunerrnum (run, ASE_AWK_EPOSVALASSMAP);
 		return -1;
 	}
 
-	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)
+	a1_ref = (ase_awk_val_t**)((ase_awk_val_ref_t*)a1)->adr;
+	if ((*a1_ref)->type != ASE_AWK_VAL_NIL &&
+	    (*a1_ref)->type != ASE_AWK_VAL_MAP)
 	{
 		/* cannot change a scalar value to a map */
-		sse_awk_setrunerrnum (run, SSE_AWK_ESCALARTOMAP);
+		ase_awk_setrunerrnum (run, ASE_AWK_ESCALARTOMAP);
 		return -1;
 	}
 
-	if (a0->type == SSE_AWK_VAL_STR)
+	if (a0->type == ASE_AWK_VAL_STR)
 	{
-		str = ((sse_awk_val_str_t*)a0)->buf;
-		str_len = ((sse_awk_val_str_t*)a0)->len;
-		str_free = SSE_NULL;
+		str = ((ase_awk_val_str_t*)a0)->buf;
+		str_len = ((ase_awk_val_str_t*)a0)->len;
+		str_free = ASE_NULL;
 	}
 	else 
 	{
-		str = sse_awk_valtostr (
-			run, a0, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &str_len);
-		if (str == SSE_NULL) return -1;
+		str = ase_awk_valtostr (
+			run, a0, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &str_len);
+		if (str == ASE_NULL) return -1;
 		str_free = str;
 	}
 
-	if (a2 == SSE_NULL)
+	if (a2 == ASE_NULL)
 	{
 		/* get the value from FS */
-		t1 = sse_awk_getglobal (run, SSE_AWK_GLOBAL_FS);
-		if (t1->type == SSE_AWK_VAL_NIL)
+		t1 = ase_awk_getglobal (run, ASE_AWK_GLOBAL_FS);
+		if (t1->type == ASE_AWK_VAL_NIL)
 		{
-			fs_ptr = SSE_T(" ");
+			fs_ptr = ASE_T(" ");
 			fs_len = 1;
-			fs_free = SSE_NULL;
+			fs_free = ASE_NULL;
 		}
-		else if (t1->type == SSE_AWK_VAL_STR)
+		else if (t1->type == ASE_AWK_VAL_STR)
 		{
-			fs_ptr = ((sse_awk_val_str_t*)t1)->buf;
-			fs_len = ((sse_awk_val_str_t*)t1)->len;
-			fs_free = SSE_NULL;
+			fs_ptr = ((ase_awk_val_str_t*)t1)->buf;
+			fs_len = ((ase_awk_val_str_t*)t1)->len;
+			fs_free = ASE_NULL;
 		}
 		else
 		{
-			fs_ptr = sse_awk_valtostr (
-				run, t1, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &fs_len);
-			if (fs_ptr == SSE_NULL)
+			fs_ptr = ase_awk_valtostr (
+				run, t1, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &fs_len);
+			if (fs_ptr == ASE_NULL)
 			{
-				if (str_free != SSE_NULL) 
-					SSE_AWK_FREE (run->awk, str_free);
+				if (str_free != ASE_NULL) 
+					ASE_AWK_FREE (run->awk, str_free);
 				return -1;
 			}
 			fs_free = fs_ptr;
@@ -600,25 +600,25 @@ static int __bfn_split (sse_awk_run_t* run)
 		if (fs_len > 1) 
 		{
 			fs_rex = run->global.fs;
-			fs_rex_free = SSE_NULL;
+			fs_rex_free = ASE_NULL;
 		}
 	}
 	else
 	{
-		if (a2->type == SSE_AWK_VAL_STR)
+		if (a2->type == ASE_AWK_VAL_STR)
 		{
-			fs_ptr = ((sse_awk_val_str_t*)a2)->buf;
-			fs_len = ((sse_awk_val_str_t*)a2)->len;
-			fs_free = SSE_NULL;
+			fs_ptr = ((ase_awk_val_str_t*)a2)->buf;
+			fs_len = ((ase_awk_val_str_t*)a2)->len;
+			fs_free = ASE_NULL;
 		}
 		else
 		{
-			fs_ptr = sse_awk_valtostr (
-				run, a2, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &fs_len);
-			if (fs_ptr == SSE_NULL)
+			fs_ptr = ase_awk_valtostr (
+				run, a2, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &fs_len);
+			if (fs_ptr == ASE_NULL)
 			{
-				if (str_free != SSE_NULL) 
-					SSE_AWK_FREE (run->awk, str_free);
+				if (str_free != ASE_NULL) 
+					ASE_AWK_FREE (run->awk, str_free);
 				return -1;
 			}
 			fs_free = fs_ptr;
@@ -626,113 +626,113 @@ static int __bfn_split (sse_awk_run_t* run)
 
 		if (fs_len > 1) 
 		{
-			fs_rex = sse_awk_buildrex (
+			fs_rex = ase_awk_buildrex (
 				run->awk, fs_ptr, fs_len, &errnum);
-			if (fs_rex == SSE_NULL)
+			if (fs_rex == ASE_NULL)
 			{
-				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);
+				if (str_free != ASE_NULL) 
+					ASE_AWK_FREE (run->awk, str_free);
+				if (fs_free != ASE_NULL) 
+					ASE_AWK_FREE (run->awk, fs_free);
+				ase_awk_setrunerrnum (run, errnum);
 				return -1;
 			}
 			fs_rex_free = fs_rex;
 		}
 	}
 
-	t1 = sse_awk_makemapval (run);
-	if (t1 == SSE_NULL)
+	t1 = ase_awk_makemapval (run);
+	if (t1 == ASE_NULL)
 	{
-		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);
+		if (str_free != ASE_NULL) 
+			ASE_AWK_FREE (run->awk, str_free);
+		if (fs_free != ASE_NULL) 
+			ASE_AWK_FREE (run->awk, fs_free);
+		if (fs_rex_free != ASE_NULL) 
+			ase_awk_freerex (run->awk, fs_rex_free);
+		ase_awk_setrunerrnum (run, ASE_AWK_ENOMEM);
 		return -1;
 	}
 
-	sse_awk_refdownval (run, *a1_ref);
+	ase_awk_refdownval (run, *a1_ref);
 	*a1_ref = t1;
-	sse_awk_refupval (*a1_ref);
+	ase_awk_refupval (*a1_ref);
 
 	p = str; str_left = str_len; 
-	sta = (sse_awk_getopt(run->awk) & SSE_AWK_STRINDEXONE)? 1: 0;
+	sta = (ase_awk_getopt(run->awk) & ASE_AWK_STRINDEXONE)? 1: 0;
 	num = sta;
 
-	while (p != SSE_NULL)
+	while (p != ASE_NULL)
 	{
 		if (fs_len <= 1)
 		{
-			p = sse_awk_strxntok (run, 
+			p = ase_awk_strxntok (run, 
 				p, str_len, fs_ptr, fs_len, &tok, &tok_len);
 		}
 		else
 		{
-			p = sse_awk_strxntokbyrex (run, p, str_len, 
+			p = ase_awk_strxntokbyrex (run, p, str_len, 
 				fs_rex, &tok, &tok_len, &errnum); 
-			if (p == SSE_NULL && errnum != SSE_AWK_ENOERR)
+			if (p == ASE_NULL && errnum != ASE_AWK_ENOERR)
 			{
-				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);
+				if (str_free != ASE_NULL) 
+					ASE_AWK_FREE (run->awk, str_free);
+				if (fs_free != ASE_NULL) 
+					ASE_AWK_FREE (run->awk, fs_free);
+				if (fs_rex_free != ASE_NULL) 
+					ase_awk_freerex (run->awk, fs_rex_free);
+				ase_awk_setrunerrnum (run, errnum);
 				return -1;
 			}
 		}
 
-		if (num == 0 && p == SSE_NULL && tok_len == 0) 
+		if (num == 0 && p == ASE_NULL && tok_len == 0) 
 		{
 			/* no field at all*/
 			break; 
 		}	
 
-		sse_awk_assert (run->awk, 
-			(tok != SSE_NULL && tok_len > 0) || tok_len == 0);
+		ase_awk_assert (run->awk, 
+			(tok != ASE_NULL && tok_len > 0) || tok_len == 0);
 
 		/* create the field string */
-		t2 = sse_awk_makestrval (run, tok, tok_len);
-		if (t2 == SSE_NULL)
+		t2 = ase_awk_makestrval (run, tok, tok_len);
+		if (t2 == ASE_NULL)
 		{
-			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);
+			if (str_free != ASE_NULL)
+				ASE_AWK_FREE (run->awk, str_free);
+			if (fs_free != ASE_NULL)
+				ASE_AWK_FREE (run->awk, fs_free);
+			if (fs_rex_free != ASE_NULL)
+				ase_awk_freerex (run->awk, fs_rex_free);
+			ase_awk_setrunerrnum (run, ASE_AWK_ENOMEM);
 			return -1;
 		}
 
 		/* put it into the map */
-		key_len = sse_awk_longtostr (
-			num, 10, SSE_NULL, key, sse_countof(key));
-		sse_awk_assert (run->awk, key_len != (sse_size_t)-1);
+		key_len = ase_awk_longtostr (
+			num, 10, ASE_NULL, key, ase_countof(key));
+		ase_awk_assert (run->awk, key_len != (ase_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. */
-		sse_awk_refupval (t2);
+		ase_awk_refupval (t2);
 
-		if (sse_awk_map_putx (
-			((sse_awk_val_map_t*)t1)->map, 
-			key, key_len, t2, SSE_NULL) == -1)
+		if (ase_awk_map_putx (
+			((ase_awk_val_map_t*)t1)->map, 
+			key, key_len, t2, ASE_NULL) == -1)
 		{
-			sse_awk_refdownval (run, t2);
+			ase_awk_refdownval (run, t2);
 
-			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);
+			if (str_free != ASE_NULL) 
+				ASE_AWK_FREE (run->awk, str_free);
+			if (fs_free != ASE_NULL) 
+				ASE_AWK_FREE (run->awk, fs_free);
+			if (fs_rex_free != ASE_NULL)
+				ase_awk_freerex (run->awk, fs_rex_free);
+			ase_awk_setrunerrnum (run, ASE_AWK_ENOMEM);
 			return -1;
 		}
 
@@ -740,151 +740,151 @@ static int __bfn_split (sse_awk_run_t* run)
 		str_len = str_left - (p - str);
 	}
 
-	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 (str_free != ASE_NULL) ASE_AWK_FREE (run->awk, str_free);
+	if (fs_free != ASE_NULL) ASE_AWK_FREE (run->awk, fs_free);
+	if (fs_rex_free != ASE_NULL) ase_awk_freerex (run->awk, fs_rex_free);
 
 	if (sta == 1) num--;
 
-	t1 = sse_awk_makeintval (run, num);
-	if (t1 == SSE_NULL)
+	t1 = ase_awk_makeintval (run, num);
+	if (t1 == ASE_NULL)
 	{
-		sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
+		ase_awk_setrunerrnum (run, ASE_AWK_ENOMEM);
 		return -1;
 	}
 
-	sse_awk_setretval (run, t1);
+	ase_awk_setretval (run, t1);
 	return 0;
 }
 
-static int __bfn_tolower (sse_awk_run_t* run)
+static int __bfn_tolower (ase_awk_run_t* run)
 {
-	sse_size_t nargs;
-	sse_char_t* str;
-	sse_size_t len, i;
-	sse_awk_val_t* a0, * r;
+	ase_size_t nargs;
+	ase_char_t* str;
+	ase_size_t len, i;
+	ase_awk_val_t* a0, * r;
 
-	nargs = sse_awk_getnargs (run);
-	sse_awk_assert (run->awk, nargs == 1);
+	nargs = ase_awk_getnargs (run);
+	ase_awk_assert (run->awk, nargs == 1);
 
-	a0 = sse_awk_getarg (run, 0);
+	a0 = ase_awk_getarg (run, 0);
 
-	if (a0->type == SSE_AWK_VAL_STR)
+	if (a0->type == ASE_AWK_VAL_STR)
 	{
-		str = ((sse_awk_val_str_t*)a0)->buf;
-		len = ((sse_awk_val_str_t*)a0)->len;
+		str = ((ase_awk_val_str_t*)a0)->buf;
+		len = ((ase_awk_val_str_t*)a0)->len;
 	}
 	else 
 	{
-		str = sse_awk_valtostr (
-			run, a0, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
-		if (str == SSE_NULL) return -1;
+		str = ase_awk_valtostr (
+			run, a0, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &len);
+		if (str == ASE_NULL) return -1;
 	}
 
-	for (i = 0; i < len; i++) str[i] = SSE_AWK_TOLOWER (run->awk, str[i]);	
+	for (i = 0; i < len; i++) str[i] = ASE_AWK_TOLOWER (run->awk, str[i]);	
 
-	r = sse_awk_makestrval (run, str, len);
-	if (r == SSE_NULL)
+	r = ase_awk_makestrval (run, str, len);
+	if (r == ASE_NULL)
 	{
-		if (a0->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str);
-		sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
+		if (a0->type != ASE_AWK_VAL_STR) ASE_AWK_FREE (run->awk, str);
+		ase_awk_setrunerrnum (run, ASE_AWK_ENOMEM);
 		return -1;
 	}
 
-	if (a0->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str);
-	sse_awk_setretval (run, r);
+	if (a0->type != ASE_AWK_VAL_STR) ASE_AWK_FREE (run->awk, str);
+	ase_awk_setretval (run, r);
 	return 0;
 }
 
-static int __bfn_toupper (sse_awk_run_t* run)
+static int __bfn_toupper (ase_awk_run_t* run)
 {
-	sse_size_t nargs;
-	sse_char_t* str;
-	sse_size_t len, i;
-	sse_awk_val_t* a0, * r;
+	ase_size_t nargs;
+	ase_char_t* str;
+	ase_size_t len, i;
+	ase_awk_val_t* a0, * r;
 
-	nargs = sse_awk_getnargs (run);
-	sse_awk_assert (run->awk, nargs == 1);
+	nargs = ase_awk_getnargs (run);
+	ase_awk_assert (run->awk, nargs == 1);
 
-	a0 = sse_awk_getarg (run, 0);
+	a0 = ase_awk_getarg (run, 0);
 
-	if (a0->type == SSE_AWK_VAL_STR)
+	if (a0->type == ASE_AWK_VAL_STR)
 	{
-		str = ((sse_awk_val_str_t*)a0)->buf;
-		len = ((sse_awk_val_str_t*)a0)->len;
+		str = ((ase_awk_val_str_t*)a0)->buf;
+		len = ((ase_awk_val_str_t*)a0)->len;
 	}
 	else 
 	{
-		str = sse_awk_valtostr (
-			run, a0, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
-		if (str == SSE_NULL) return -1;
+		str = ase_awk_valtostr (
+			run, a0, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &len);
+		if (str == ASE_NULL) return -1;
 	}
 
-	for (i = 0; i < len; i++) str[i] = SSE_AWK_TOUPPER (run->awk, str[i]);	
+	for (i = 0; i < len; i++) str[i] = ASE_AWK_TOUPPER (run->awk, str[i]);	
 
-	r = sse_awk_makestrval (run, str, len);
-	if (r == SSE_NULL)
+	r = ase_awk_makestrval (run, str, len);
+	if (r == ASE_NULL)
 	{
-		if (a0->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str);
-		sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
+		if (a0->type != ASE_AWK_VAL_STR) ASE_AWK_FREE (run->awk, str);
+		ase_awk_setrunerrnum (run, ASE_AWK_ENOMEM);
 		return -1;
 	}
 
-	if (a0->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str);
-	sse_awk_setretval (run, r);
+	if (a0->type != ASE_AWK_VAL_STR) ASE_AWK_FREE (run->awk, str);
+	ase_awk_setretval (run, r);
 	return 0;
 }
 
-static int __substitute (sse_awk_run_t* run, sse_long_t max_count)
+static int __substitute (ase_awk_run_t* run, ase_long_t max_count)
 {
-	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;
+	ase_size_t nargs;
+	ase_awk_val_t* a0, * a1, * a2, ** a2_ref, * v;
+	ase_char_t* a0_ptr, * a1_ptr, * a2_ptr;
+	ase_size_t a0_len, a1_len, a2_len;
+	ase_char_t* a0_ptr_free = ASE_NULL;
+	ase_char_t* a1_ptr_free = ASE_NULL;
+	ase_char_t* a2_ptr_free = ASE_NULL;
 	void* rex;
 	int opt, n;
-	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;
+	const ase_char_t* cur_ptr, * mat_ptr;
+	ase_size_t cur_len, mat_len, i, m;
+	ase_awk_str_t new;
+	ase_long_t sub_count;
 
-	nargs = sse_awk_getnargs (run);
-	sse_awk_assert (run->awk, nargs >= 2 && nargs <= 3);
+	nargs = ase_awk_getnargs (run);
+	ase_awk_assert (run->awk, nargs >= 2 && nargs <= 3);
 
-	a0 = sse_awk_getarg (run, 0);
-	a1 = sse_awk_getarg (run, 1);
-	a2 = (nargs >= 3)? sse_awk_getarg (run, 2): SSE_NULL;
+	a0 = ase_awk_getarg (run, 0);
+	a1 = ase_awk_getarg (run, 1);
+	a2 = (nargs >= 3)? ase_awk_getarg (run, 2): ASE_NULL;
 
-	sse_awk_assert (run->awk, a2 == SSE_NULL || a2->type == SSE_AWK_VAL_REF);
+	ase_awk_assert (run->awk, a2 == ASE_NULL || a2->type == ASE_AWK_VAL_REF);
 
 #define FREE_A_PTRS(awk) \
 	do { \
-		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); \
+		if (a2_ptr_free != ASE_NULL) ASE_AWK_FREE (awk, a2_ptr_free); \
+		if (a1_ptr_free != ASE_NULL) ASE_AWK_FREE (awk, a1_ptr_free); \
+		if (a0_ptr_free != ASE_NULL) ASE_AWK_FREE (awk, a0_ptr_free); \
 	} while (0)
 #define FREE_A0_REX(awk,rex) \
 	do { \
-		if (a0->type != SSE_AWK_VAL_REX) sse_awk_freerex (awk, rex); \
+		if (a0->type != ASE_AWK_VAL_REX) ase_awk_freerex (awk, rex); \
 	} while (0)
 
-	if (a0->type == SSE_AWK_VAL_REX)
+	if (a0->type == ASE_AWK_VAL_REX)
 	{
-		rex = ((sse_awk_val_rex_t*)a0)->code;
+		rex = ((ase_awk_val_rex_t*)a0)->code;
 	}
-	else if (a0->type == SSE_AWK_VAL_STR)
+	else if (a0->type == ASE_AWK_VAL_STR)
 	{
-		a0_ptr = ((sse_awk_val_str_t*)a0)->buf;
-		a0_len = ((sse_awk_val_str_t*)a0)->len;
+		a0_ptr = ((ase_awk_val_str_t*)a0)->buf;
+		a0_len = ((ase_awk_val_str_t*)a0)->len;
 	}
 	else
 	{
-		a0_ptr = sse_awk_valtostr (
-			run, a0, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &a0_len);
-		if (a0_ptr == SSE_NULL) 
+		a0_ptr = ase_awk_valtostr (
+			run, a0, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &a0_len);
+		if (a0_ptr == ASE_NULL) 
 		{
 			FREE_A_PTRS (run->awk);
 			return -1;
@@ -892,16 +892,16 @@ static int __substitute (sse_awk_run_t* run, sse_long_t max_count)
 		a0_ptr_free = a0_ptr;
 	}
 
-	if (a1->type == SSE_AWK_VAL_STR)
+	if (a1->type == ASE_AWK_VAL_STR)
 	{
-		a1_ptr = ((sse_awk_val_str_t*)a1)->buf;
-		a1_len = ((sse_awk_val_str_t*)a1)->len;
+		a1_ptr = ((ase_awk_val_str_t*)a1)->buf;
+		a1_len = ((ase_awk_val_str_t*)a1)->len;
 	}
 	else
 	{
-		a1_ptr = sse_awk_valtostr (
-			run, a1, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &a1_len);
-		if (a1_ptr == SSE_NULL) 
+		a1_ptr = ase_awk_valtostr (
+			run, a1, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &a1_len);
+		if (a1_ptr == ASE_NULL) 
 		{
 			FREE_A_PTRS (run->awk);
 			return -1;
@@ -909,21 +909,21 @@ static int __substitute (sse_awk_run_t* run, sse_long_t max_count)
 		a1_ptr_free = a1_ptr;
 	}
 
-	if (a2 == SSE_NULL)
+	if (a2 == ASE_NULL)
 	{
 		/* is this correct? any needs to use inrec.d0? */
-		a2_ptr = SSE_AWK_STR_BUF(&run->inrec.line);
-		a2_len = SSE_AWK_STR_LEN(&run->inrec.line);
+		a2_ptr = ASE_AWK_STR_BUF(&run->inrec.line);
+		a2_len = ASE_AWK_STR_LEN(&run->inrec.line);
 	}
-	else if (((sse_awk_val_ref_t*)a2)->id == SSE_AWK_VAL_REF_POS)
+	else if (((ase_awk_val_ref_t*)a2)->id == ASE_AWK_VAL_REF_POS)
 	{
-		sse_size_t idx;
+		ase_size_t idx;
 	       
-		idx = (sse_size_t)((sse_awk_val_ref_t*)a2)->adr;
+		idx = (ase_size_t)((ase_awk_val_ref_t*)a2)->adr;
 		if (idx == 0)
 		{
-			a2_ptr = SSE_AWK_STR_BUF(&run->inrec.line);
-			a2_len = SSE_AWK_STR_LEN(&run->inrec.line);
+			a2_ptr = ASE_AWK_STR_BUF(&run->inrec.line);
+			a2_len = ASE_AWK_STR_LEN(&run->inrec.line);
 		}
 		else if (idx <= run->inrec.nflds)
 		{
@@ -932,32 +932,32 @@ static int __substitute (sse_awk_run_t* run, sse_long_t max_count)
 		}
 		else
 		{
-			a2_ptr = SSE_T("");
+			a2_ptr = ASE_T("");
 			a2_len = 0;
 		}
 	}
 	else
 	{
-		a2_ref = (sse_awk_val_t**)((sse_awk_val_ref_t*)a2)->adr;
+		a2_ref = (ase_awk_val_t**)((ase_awk_val_ref_t*)a2)->adr;
 
-		if ((*a2_ref)->type == SSE_AWK_VAL_MAP)
+		if ((*a2_ref)->type == ASE_AWK_VAL_MAP)
 		{
 			FREE_A_PTRS (run->awk);
 			/* a map is not allowed as the third parameter */
-			sse_awk_setrunerrnum (run, SSE_AWK_EMAPNOTALLOWED);
+			ase_awk_setrunerrnum (run, ASE_AWK_EMAPNOTALLOWED);
 			return -1;
 		}
 
-		if ((*a2_ref)->type == SSE_AWK_VAL_STR)
+		if ((*a2_ref)->type == ASE_AWK_VAL_STR)
 		{
-			a2_ptr = ((sse_awk_val_str_t*)(*a2_ref))->buf;
-			a2_len = ((sse_awk_val_str_t*)(*a2_ref))->len;
+			a2_ptr = ((ase_awk_val_str_t*)(*a2_ref))->buf;
+			a2_len = ((ase_awk_val_str_t*)(*a2_ref))->len;
 		}
 		else
 		{
-			a2_ptr = sse_awk_valtostr (
-				run, *a2_ref, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &a2_len);
-			if (a2_ptr == SSE_NULL) 
+			a2_ptr = ase_awk_valtostr (
+				run, *a2_ref, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &a2_len);
+			if (a2_ptr == ASE_NULL) 
 			{
 				FREE_A_PTRS (run->awk);
 				return -1;
@@ -966,25 +966,25 @@ static int __substitute (sse_awk_run_t* run, sse_long_t max_count)
 		}
 	}
 
-	if (sse_awk_str_open (&new, a2_len, run->awk) == SSE_NULL)
+	if (ase_awk_str_open (&new, a2_len, run->awk) == ASE_NULL)
 	{
 		FREE_A_PTRS (run->awk);
-		sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
+		ase_awk_setrunerrnum (run, ASE_AWK_ENOMEM);
 		return -1;
 	}
 
-	if (a0->type != SSE_AWK_VAL_REX)
+	if (a0->type != ASE_AWK_VAL_REX)
 	{
-		rex = sse_awk_buildrex (run->awk, a0_ptr, a0_len, &run->errnum);
-		if (rex == SSE_NULL)
+		rex = ase_awk_buildrex (run->awk, a0_ptr, a0_len, &run->errnum);
+		if (rex == ASE_NULL)
 		{
-			sse_awk_str_close (&new);
+			ase_awk_str_close (&new);
 			FREE_A_PTRS (run->awk);
 			return -1;
 		}
 	}
 
-	opt = (run->global.ignorecase)? SSE_AWK_REX_IGNORECASE: 0;
+	opt = (run->global.ignorecase)? ASE_AWK_REX_IGNORECASE: 0;
 	cur_ptr = a2_ptr;
 	cur_len = a2_len;
 	sub_count = 0;
@@ -993,7 +993,7 @@ static int __substitute (sse_awk_run_t* run, sse_long_t max_count)
 	{
 		if (max_count == 0 || sub_count < max_count)
 		{
-			n = sse_awk_matchrex (
+			n = ase_awk_matchrex (
 				run->awk, rex, opt, cur_ptr, cur_len,
 				&mat_ptr, &mat_len, &run->errnum);
 		}
@@ -1002,7 +1002,7 @@ static int __substitute (sse_awk_run_t* run, sse_long_t max_count)
 		if (n == -1)
 		{
 			FREE_A0_REX (run->awk, rex);
-			sse_awk_str_close (&new);
+			ase_awk_str_close (&new);
 			FREE_A_PTRS (run->awk);
 			return -1;
 		}
@@ -1010,22 +1010,22 @@ static int __substitute (sse_awk_run_t* run, sse_long_t max_count)
 		if (n == 0) 
 		{ 
 			/* no more match found */
-			if (sse_awk_str_ncat (
-				&new, cur_ptr, cur_len) == (sse_size_t)-1)
+			if (ase_awk_str_ncat (
+				&new, cur_ptr, cur_len) == (ase_size_t)-1)
 			{
 				FREE_A0_REX (run->awk, rex);
-				sse_awk_str_close (&new);
+				ase_awk_str_close (&new);
 				FREE_A_PTRS (run->awk);
 				return -1;
 			}
 			break;
 		}
 
-		if (sse_awk_str_ncat (
-			&new, cur_ptr, mat_ptr - cur_ptr) == (sse_size_t)-1)
+		if (ase_awk_str_ncat (
+			&new, cur_ptr, mat_ptr - cur_ptr) == (ase_size_t)-1)
 		{
 			FREE_A0_REX (run->awk, rex);
-			sse_awk_str_close (&new);
+			ase_awk_str_close (&new);
 			FREE_A_PTRS (run->awk);
 			return -1;
 		}
@@ -1033,25 +1033,25 @@ static int __substitute (sse_awk_run_t* run, sse_long_t max_count)
 		for (i = 0; i < a1_len; i++)
 		{
 			if ((i+1) < a1_len && 
-			    a1_ptr[i] == SSE_T('\\') && 
-			    a1_ptr[i+1] == SSE_T('&'))
+			    a1_ptr[i] == ASE_T('\\') && 
+			    a1_ptr[i+1] == ASE_T('&'))
 			{
-				m = sse_awk_str_ccat (&new, SSE_T('&'));
+				m = ase_awk_str_ccat (&new, ASE_T('&'));
 				i++;
 			}
-			else if (a1_ptr[i] == SSE_T('&'))
+			else if (a1_ptr[i] == ASE_T('&'))
 			{
-				m = sse_awk_str_ncat (&new, mat_ptr, mat_len);
+				m = ase_awk_str_ncat (&new, mat_ptr, mat_len);
 			}
 			else 
 			{
-				m = sse_awk_str_ccat (&new, a1_ptr[i]);
+				m = ase_awk_str_ccat (&new, a1_ptr[i]);
 			}
 
-			if (m == (sse_size_t)-1)
+			if (m == (ase_size_t)-1)
 			{
 				FREE_A0_REX (run->awk, rex);
-				sse_awk_str_close (&new);
+				ase_awk_str_close (&new);
 				FREE_A_PTRS (run->awk);
 				return -1;
 			}
@@ -1066,207 +1066,207 @@ static int __substitute (sse_awk_run_t* run, sse_long_t max_count)
 
 	if (sub_count > 0)
 	{
-		if (a2 == SSE_NULL)
+		if (a2 == ASE_NULL)
 		{
-			if (sse_awk_setrec (run, 0,
-				SSE_AWK_STR_BUF(&new), SSE_AWK_STR_LEN(&new)) == -1)
+			if (ase_awk_setrec (run, 0,
+				ASE_AWK_STR_BUF(&new), ASE_AWK_STR_LEN(&new)) == -1)
 			{
-				sse_awk_str_close (&new);
+				ase_awk_str_close (&new);
 				FREE_A_PTRS (run->awk);
 				return -1;
 			}
 		}
-		else if (((sse_awk_val_ref_t*)a2)->id == SSE_AWK_VAL_REF_POS)
+		else if (((ase_awk_val_ref_t*)a2)->id == ASE_AWK_VAL_REF_POS)
 		{
 			int n;
 
-			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));
+			n = ase_awk_setrec (
+				run, (ase_size_t)((ase_awk_val_ref_t*)a2)->adr,
+				ASE_AWK_STR_BUF(&new), ASE_AWK_STR_LEN(&new));
 
 			if (n == -1)
 			{
-				sse_awk_str_close (&new);
+				ase_awk_str_close (&new);
 				FREE_A_PTRS (run->awk);
 				return -1;
 			}
 		}
 		else
 		{
-			v = sse_awk_makestrval (run,
-				SSE_AWK_STR_BUF(&new), SSE_AWK_STR_LEN(&new));
-			if (v == SSE_NULL)
+			v = ase_awk_makestrval (run,
+				ASE_AWK_STR_BUF(&new), ASE_AWK_STR_LEN(&new));
+			if (v == ASE_NULL)
 			{
-				sse_awk_str_close (&new);
+				ase_awk_str_close (&new);
 				FREE_A_PTRS (run->awk);
 				return -1;
 			}
 
-			sse_awk_refdownval (run, *a2_ref);
+			ase_awk_refdownval (run, *a2_ref);
 			*a2_ref = v;
-			sse_awk_refupval (*a2_ref);
+			ase_awk_refupval (*a2_ref);
 		}
 	}
 
-	sse_awk_str_close (&new);
+	ase_awk_str_close (&new);
 	FREE_A_PTRS (run->awk);
 
 #undef FREE_A0_REX
 #undef FREE_A_PTRS
 
-	v = sse_awk_makeintval (run, sub_count);
-	if (v == SSE_NULL)
+	v = ase_awk_makeintval (run, sub_count);
+	if (v == ASE_NULL)
 	{
-		sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
+		ase_awk_setrunerrnum (run, ASE_AWK_ENOMEM);
 		return -1;
 	}
 
-	sse_awk_setretval (run, v);
+	ase_awk_setretval (run, v);
 	return 0;
 }
 
-static int __bfn_gsub (sse_awk_run_t* run)
+static int __bfn_gsub (ase_awk_run_t* run)
 {
 	return __substitute (run, 0);
 }
 
-static int __bfn_sub (sse_awk_run_t* run)
+static int __bfn_sub (ase_awk_run_t* run)
 {
 	return __substitute (run, 1);
 }
 
-static int __bfn_match (sse_awk_run_t* run)
+static int __bfn_match (ase_awk_run_t* run)
 {
-	sse_size_t nargs;
-	sse_awk_val_t* a0, * a1;
-	sse_char_t* str0, * str1;
-	sse_size_t len0, len1;
-	sse_long_t idx;
+	ase_size_t nargs;
+	ase_awk_val_t* a0, * a1;
+	ase_char_t* str0, * str1;
+	ase_size_t len0, len1;
+	ase_long_t idx;
 	void* rex;
 	int opt, n;
-	const sse_char_t* mat_ptr;
-	sse_size_t mat_len;
+	const ase_char_t* mat_ptr;
+	ase_size_t mat_len;
 
-	nargs = sse_awk_getnargs (run);
-	sse_awk_assert (run->awk, nargs == 2);
+	nargs = ase_awk_getnargs (run);
+	ase_awk_assert (run->awk, nargs == 2);
 	
-	a0 = sse_awk_getarg (run, 0);
-	a1 = sse_awk_getarg (run, 1);
+	a0 = ase_awk_getarg (run, 0);
+	a1 = ase_awk_getarg (run, 1);
 
-	if (a0->type == SSE_AWK_VAL_STR)
+	if (a0->type == ASE_AWK_VAL_STR)
 	{
-		str0 = ((sse_awk_val_str_t*)a0)->buf;
-		len0 = ((sse_awk_val_str_t*)a0)->len;
+		str0 = ((ase_awk_val_str_t*)a0)->buf;
+		len0 = ((ase_awk_val_str_t*)a0)->len;
 	}
 	else
 	{
-		str0 = sse_awk_valtostr (
-			run, a0, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len0);
-		if (str0 == SSE_NULL) return -1;
+		str0 = ase_awk_valtostr (
+			run, a0, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &len0);
+		if (str0 == ASE_NULL) return -1;
 	}
 
-	if (a1->type == SSE_AWK_VAL_REX)
+	if (a1->type == ASE_AWK_VAL_REX)
 	{
-		rex = ((sse_awk_val_rex_t*)a1)->code;
+		rex = ((ase_awk_val_rex_t*)a1)->code;
 	}
 	else 
 	{
-		if (a1->type == SSE_AWK_VAL_STR)
+		if (a1->type == ASE_AWK_VAL_STR)
 		{
-			str1 = ((sse_awk_val_str_t*)a1)->buf;
-			len1 = ((sse_awk_val_str_t*)a1)->len;
+			str1 = ((ase_awk_val_str_t*)a1)->buf;
+			len1 = ((ase_awk_val_str_t*)a1)->len;
 		}
 		else
 		{
-			str1 = sse_awk_valtostr (
-				run, a1, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len1);
-			if (str1 == SSE_NULL)
+			str1 = ase_awk_valtostr (
+				run, a1, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &len1);
+			if (str1 == ASE_NULL)
 			{
-				if (a0->type != SSE_AWK_VAL_STR) 
-					SSE_AWK_FREE (run->awk, str0);
+				if (a0->type != ASE_AWK_VAL_STR) 
+					ASE_AWK_FREE (run->awk, str0);
 				return -1;
 			}
 		}
 
-		rex = sse_awk_buildrex (run->awk, str1, len1, &run->errnum);
-		if (rex == SSE_NULL)
+		rex = ase_awk_buildrex (run->awk, str1, len1, &run->errnum);
+		if (rex == ASE_NULL)
 		{
-			if (a0->type != SSE_AWK_VAL_STR) 
-				SSE_AWK_FREE (run->awk, str0);
+			if (a0->type != ASE_AWK_VAL_STR) 
+				ASE_AWK_FREE (run->awk, str0);
 			return -1;
 		}
 
-		if (a1->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str1);
+		if (a1->type != ASE_AWK_VAL_STR) ASE_AWK_FREE (run->awk, str1);
 	}
 
-	opt = (run->global.ignorecase)? SSE_AWK_REX_IGNORECASE: 0;
-	n = sse_awk_matchrex (
+	opt = (run->global.ignorecase)? ASE_AWK_REX_IGNORECASE: 0;
+	n = ase_awk_matchrex (
 		run->awk, rex, opt, str0, len0,
 		&mat_ptr, &mat_len, &run->errnum);
 
-	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 (a0->type != ASE_AWK_VAL_STR) ASE_AWK_FREE (run->awk, str0);
+	if (a1->type != ASE_AWK_VAL_REX) ase_awk_freerex (run->awk, rex);
 
 	if (n == -1) return -1;
 
-	idx = (n == 0)? -1: (sse_long_t)(mat_ptr - str0);
-	if (sse_awk_getopt(run->awk) & SSE_AWK_STRINDEXONE) idx = idx + 1;
+	idx = (n == 0)? -1: (ase_long_t)(mat_ptr - str0);
+	if (ase_awk_getopt(run->awk) & ASE_AWK_STRINDEXONE) idx = idx + 1;
 
-	a0 = sse_awk_makeintval (run, idx);
-	if (a0 == SSE_NULL)
+	a0 = ase_awk_makeintval (run, idx);
+	if (a0 == ASE_NULL)
 	{
-		sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
+		ase_awk_setrunerrnum (run, ASE_AWK_ENOMEM);
 		return -1;
 	}
 
-	sse_awk_refupval (a0);
+	ase_awk_refupval (a0);
 
-	a1 = sse_awk_makeintval (run, 
-		((n == 0)? (sse_long_t)-1: (sse_long_t)mat_len));
-	if (a1 == SSE_NULL)
+	a1 = ase_awk_makeintval (run, 
+		((n == 0)? (ase_long_t)-1: (ase_long_t)mat_len));
+	if (a1 == ASE_NULL)
 	{
-		sse_awk_refdownval (run, a0);
-		sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
+		ase_awk_refdownval (run, a0);
+		ase_awk_setrunerrnum (run, ASE_AWK_ENOMEM);
 		return -1;
 	}
 
-	sse_awk_refupval (a1);
+	ase_awk_refupval (a1);
 
-	if (sse_awk_setglobal (run, SSE_AWK_GLOBAL_RSTART, a0) == -1)
+	if (ase_awk_setglobal (run, ASE_AWK_GLOBAL_RSTART, a0) == -1)
 	{
-		sse_awk_refdownval (run, a1);
-		sse_awk_refdownval (run, a0);
+		ase_awk_refdownval (run, a1);
+		ase_awk_refdownval (run, a0);
 		return -1;
 	}
 
-	if (sse_awk_setglobal (run, SSE_AWK_GLOBAL_RLENGTH, a1) == -1)
+	if (ase_awk_setglobal (run, ASE_AWK_GLOBAL_RLENGTH, a1) == -1)
 	{
-		sse_awk_refdownval (run, a1);
-		sse_awk_refdownval (run, a0);
+		ase_awk_refdownval (run, a1);
+		ase_awk_refdownval (run, a0);
 		return -1;
 	}
 
-	sse_awk_setretval (run, a0);
+	ase_awk_setretval (run, a0);
 
-	sse_awk_refdownval (run, a1);
-	sse_awk_refdownval (run, a0);
+	ase_awk_refdownval (run, a1);
+	ase_awk_refdownval (run, a0);
 	return 0;
 }
 
-static int __bfn_system (sse_awk_run_t* run)
+static int __bfn_system (ase_awk_run_t* run)
 {
-	sse_size_t nargs;
-	sse_char_t* cmd;
-	sse_awk_val_t* v;
+	ase_size_t nargs;
+	ase_char_t* cmd;
+	ase_awk_val_t* v;
 	int n;
        
-	nargs = sse_awk_getnargs (run);
-	sse_awk_assert (run->awk, nargs == 1);
+	nargs = ase_awk_getnargs (run);
+	ase_awk_assert (run->awk, nargs == 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;
+	cmd = ase_awk_valtostr (
+		run, ase_awk_getarg(run, 0), 
+		ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, ASE_NULL);
+	if (cmd == ASE_NULL) return -1;
 
 #ifdef _WIN32
 	n = _tsystem (cmd);
@@ -1275,56 +1275,56 @@ static int __bfn_system (sse_awk_run_t* run)
 	n = -1;
 #endif
 
-	SSE_AWK_FREE (run->awk, cmd);
+	ASE_AWK_FREE (run->awk, cmd);
 
-	v = sse_awk_makeintval (run, n);
-	if (v == SSE_NULL)
+	v = ase_awk_makeintval (run, n);
+	if (v == ASE_NULL)
 	{
-		sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
+		ase_awk_setrunerrnum (run, ASE_AWK_ENOMEM);
 		return -1;
 	}
 
-	sse_awk_setretval (run, v);
+	ase_awk_setretval (run, v);
 	return 0;
 }
 
 /* math functions */
 #if 0
-static int __bfn_sin (sse_awk_run_t* run)
+static int __bfn_sin (ase_awk_run_t* run)
 {
-	sse_size_t nargs;
-	sse_awk_val_t* v;
+	ase_size_t nargs;
+	ase_awk_val_t* v;
 	int n;
-	sse_long_t lv;
-	sse_real_t rv;
+	ase_long_t lv;
+	ase_real_t rv;
        
-	nargs = sse_awk_getnargs (run);
-	sse_awk_assert (run->awk, nargs == 1);
+	nargs = ase_awk_getnargs (run);
+	ase_awk_assert (run->awk, nargs == 1);
 
-	n = sse_awk_valtonum (run, sse_awk_getarg(run, 0), &lv, &rv);
+	n = ase_awk_valtonum (run, ase_awk_getarg(run, 0), &lv, &rv);
 	if (n == -1)
 	{
 		/* wrong value */
 		return  -1;
 	}
 
-	if (n == 0) rv = (sse_real_t)lv;
+	if (n == 0) rv = (ase_real_t)lv;
 
-#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));
+#if (ASE_SIZEOF_REAL == ASE_SIZEOF_LONG_DOUBLE) 
+	v = ase_awk_makerealval (run, (ase_real_t)sinl(rv));
+#elif (ASE_SIZEOF_REAL == ASE_SIZEOF_DOUBLE)
+	v = ase_awk_makerealval (run, (ase_real_t)sin(rv));
 #else
 	#error unsupported floating-point data type
 #endif
 
-	if (v == SSE_NULL)
+	if (v == ASE_NULL)
 	{
-		sse_awk_setrunerrnum (run, SSE_AWK_ENOMEM);
+		ase_awk_setrunerrnum (run, ASE_AWK_ENOMEM);
 		return -1;
 	}
 
-	sse_awk_setretval (run, v);
+	ase_awk_setretval (run, v);
 	return 0;
 }
 #endif
diff --git a/ase/awk/func.h b/ase/awk/func.h
index 79cf83c4..c77cafc9 100644
--- a/ase/awk/func.h
+++ b/ase/awk/func.h
@@ -1,39 +1,39 @@
 /*
- * $Id: func.h,v 1.13 2006-10-22 11:34:53 bacon Exp $
+ * $Id: func.h,v 1.14 2006-10-24 04:10:12 bacon Exp $
  */
 
-#ifndef _SSE_AWK_FUNC_H_
-#define _SSE_AWK_FUNC_H_
+#ifndef _ASE_AWK_FUNC_H_
+#define _ASE_AWK_FUNC_H_
 
-#ifndef _SSE_AWK_AWK_H_
-#error Never include this file directly. Include <sse/awk/awk.h> instead
+#ifndef _ASE_AWK_AWK_H_
+#error Never include this file directly. Include <ase/awk/awk.h> instead
 #endif
 
-typedef struct sse_awk_bfn_t sse_awk_bfn_t;
+typedef struct ase_awk_bfn_t ase_awk_bfn_t;
 
-struct sse_awk_bfn_t
+struct ase_awk_bfn_t
 {
-	const sse_char_t* name; 
-	sse_size_t name_len;
+	const ase_char_t* name; 
+	ase_size_t name_len;
 	int valid; /* the entry is valid when this option is set */
 
-	sse_size_t min_args;
-	sse_size_t max_args;
-	const sse_char_t* arg_spec;
-	int (*handler) (sse_awk_run_t* run);
+	ase_size_t min_args;
+	ase_size_t max_args;
+	const ase_char_t* arg_spec;
+	int (*handler) (ase_awk_run_t* run);
 
-	sse_awk_bfn_t* next;
+	ase_awk_bfn_t* next;
 };
 
 enum
 {
 	/* ensure that this matches __sys_bfn in func.c */
 
-	SSE_AWK_BFN_CLOSE,
-	SSE_AWK_BFN_INDEX,
-	SSE_AWK_BFN_LENGTH,
-	SSE_AWK_BFN_SYSTEM,
-	SSE_AWK_BFN_SIN
+	ASE_AWK_BFN_CLOSE,
+	ASE_AWK_BFN_INDEX,
+	ASE_AWK_BFN_LENGTH,
+	ASE_AWK_BFN_SYSTEM,
+	ASE_AWK_BFN_SIN
 };
 
 
@@ -41,17 +41,17 @@ enum
 extern "C" {
 #endif
 
-sse_awk_bfn_t* sse_awk_addbfn (
-	sse_awk_t* awk, const sse_char_t* name, sse_size_t name_len, 
-	int when_valid, sse_size_t min_args, sse_size_t max_args, 
-	const sse_char_t* arg_spec, int (*handler)(sse_awk_run_t*));
+ase_awk_bfn_t* ase_awk_addbfn (
+	ase_awk_t* awk, const ase_char_t* name, ase_size_t name_len, 
+	int when_valid, ase_size_t min_args, ase_size_t max_args, 
+	const ase_char_t* arg_spec, int (*handler)(ase_awk_run_t*));
 
-int sse_awk_delbfn (sse_awk_t* awk, const sse_char_t* name, sse_size_t name_len);
+int ase_awk_delbfn (ase_awk_t* awk, const ase_char_t* name, ase_size_t name_len);
 
-void sse_awk_clrbfn (sse_awk_t* awk);
+void ase_awk_clrbfn (ase_awk_t* awk);
 
-sse_awk_bfn_t* sse_awk_getbfn (
-	sse_awk_t* awk, const sse_char_t* name, sse_size_t name_len);
+ase_awk_bfn_t* ase_awk_getbfn (
+	ase_awk_t* awk, const ase_char_t* name, ase_size_t name_len);
 
 #ifdef __cplusplus
 }
diff --git a/ase/awk/jni.c b/ase/awk/jni.c
index eb8233a4..bf48e8cb 100644
--- a/ase/awk/jni.c
+++ b/ase/awk/jni.c
@@ -1,16 +1,16 @@
 /*
- * $Id: jni.c,v 1.14 2006-10-22 12:39:29 bacon Exp $
+ * $Id: jni.c,v 1.15 2006-10-24 04:10:12 bacon Exp $
  */
 
-#include <sse/awk/jni.h>
-#include <sse/awk/awk.h>
+#include <ase/awk/jni.h>
+#include <ase/awk/awk.h>
 #include <stdlib.h>
 #include <string.h>
 #include <wctype.h>
 #include <wchar.h>
 #include <stdio.h>
 
-#define EXCEPTION_AWK "sse/awk/AwkException"
+#define EXCEPTION_AWK "ase/awk/AwkException"
 #define FIELD_AWK     "__awk"
 
 enum
@@ -19,16 +19,16 @@ enum
 	SOURCE_WRITE = 2
 };
 
-/* TODO: what if sse_char_t is sse_mchar_t??? */
+/* TODO: what if ase_char_t is ase_mchar_t??? */
 
-static sse_ssize_t __read_source (
-	int cmd, void* arg, sse_char_t* data, sse_size_t count);
-static sse_ssize_t __write_source (
-	int cmd, void* arg, sse_char_t* data, sse_size_t count);
-static sse_ssize_t __process_extio_console (
-	int cmd, void* arg, sse_char_t* data, sse_size_t count);
-static sse_ssize_t __process_extio_file (
-	int cmd, void* arg, sse_char_t* data, sse_size_t count);
+static ase_ssize_t __read_source (
+	int cmd, void* arg, ase_char_t* data, ase_size_t count);
+static ase_ssize_t __write_source (
+	int cmd, void* arg, ase_char_t* data, ase_size_t count);
+static ase_ssize_t __process_extio_console (
+	int cmd, void* arg, ase_char_t* data, ase_size_t count);
+static ase_ssize_t __process_extio_file (
+	int cmd, void* arg, ase_char_t* data, ase_size_t count);
 
 typedef struct srcio_data_t srcio_data_t;
 typedef struct runio_data_t runio_data_t;
@@ -45,12 +45,12 @@ struct runio_data_t
 	jobject obj;
 };
 
-static void* __awk_malloc (sse_size_t n, void* custom_data)
+static void* __awk_malloc (ase_size_t n, void* custom_data)
 {
 	return malloc (n);
 }
 
-static void* __awk_realloc (void* ptr, sse_size_t n, void* custom_data)
+static void* __awk_realloc (void* ptr, ase_size_t n, void* custom_data)
 {
 	return realloc (ptr, n);
 }
@@ -60,13 +60,13 @@ static void __awk_free (void* ptr, void* custom_data)
 	free (ptr);
 }
 
-JNIEXPORT void JNICALL Java_sse_awk_Awk_open (JNIEnv* env, jobject obj)
+JNIEXPORT void JNICALL Java_ase_awk_Awk_open (JNIEnv* env, jobject obj)
 {
 	jclass class; 
 	jfieldID fid;
 	jthrowable except;
-	sse_awk_t* awk;
-	sse_awk_syscas_t syscas;
+	ase_awk_t* awk;
+	ase_awk_syscas_t syscas;
 	int opt;
 	
 	class = (*env)->GetObjectClass(env, obj);
@@ -103,7 +103,7 @@ JNIEXPORT void JNICALL Java_sse_awk_Awk_open (JNIEnv* env, jobject obj)
 	syscas.abort = abort;
 #endif
 
-	awk = sse_awk_open (&syscas);
+	awk = ase_awk_open (&syscas);
 	if (awk == NULL)
 	{
 		except = (*env)->FindClass (env, EXCEPTION_AWK);
@@ -117,15 +117,15 @@ JNIEXPORT void JNICALL Java_sse_awk_Awk_open (JNIEnv* env, jobject obj)
 
 	(*env)->SetLongField (env, obj, fid, (jlong)awk);
 
-	opt = SSE_AWK_EXPLICIT | SSE_AWK_UNIQUE | SSE_AWK_DBLSLASHES |
-		SSE_AWK_SHADING | SSE_AWK_IMPLICIT | SSE_AWK_SHIFT | 
-		SSE_AWK_EXTIO | SSE_AWK_BLOCKLESS;
-	sse_awk_setopt (awk, opt);
+	opt = ASE_AWK_EXPLICIT | ASE_AWK_UNIQUE | ASE_AWK_DBLSLASHES |
+		ASE_AWK_SHADING | ASE_AWK_IMPLICIT | ASE_AWK_SHIFT | 
+		ASE_AWK_EXTIO | ASE_AWK_BLOCKLESS;
+	ase_awk_setopt (awk, opt);
 
 printf ("__awk(native) done => %u, 0x%X\n", awk, awk);
 }
 
-JNIEXPORT void JNICALL Java_sse_awk_Awk_close (JNIEnv* env, jobject obj)
+JNIEXPORT void JNICALL Java_ase_awk_Awk_close (JNIEnv* env, jobject obj)
 {
 	jclass class; 
 	jfieldID fid;
@@ -135,20 +135,20 @@ JNIEXPORT void JNICALL Java_sse_awk_Awk_close (JNIEnv* env, jobject obj)
 	fid = (*env)->GetFieldID (env, class, FIELD_AWK, "J");
 	if (fid == 0) return;
 
-	sse_awk_close ((sse_awk_t*) (*env)->GetLongField (env, obj, fid));
+	ase_awk_close ((ase_awk_t*) (*env)->GetLongField (env, obj, fid));
 	(*env)->SetLongField (env, obj, fid, (jlong)0);
 
 printf ("close (native) done\n");
 }
 
-JNIEXPORT void JNICALL Java_sse_awk_Awk_parse (JNIEnv* env, jobject obj)
+JNIEXPORT void JNICALL Java_ase_awk_Awk_parse (JNIEnv* env, jobject obj)
 {
 	jclass class;
 	jfieldID fid;
 	jthrowable except;
 
-	sse_awk_t* awk;
-	sse_awk_srcios_t srcios;
+	ase_awk_t* awk;
+	ase_awk_srcios_t srcios;
 	srcio_data_t srcio_data;
 
 	class = (*env)->GetObjectClass (env, obj);
@@ -156,7 +156,7 @@ JNIEXPORT void JNICALL Java_sse_awk_Awk_parse (JNIEnv* env, jobject obj)
 	fid = (*env)->GetFieldID (env, class, FIELD_AWK, "J");
 	if (fid == 0) return;
 
-	awk = (sse_awk_t*) (*env)->GetLongField (env, obj, fid);
+	awk = (ase_awk_t*) (*env)->GetLongField (env, obj, fid);
 
 	srcio_data.env = env;
 	srcio_data.obj = obj;
@@ -165,25 +165,25 @@ JNIEXPORT void JNICALL Java_sse_awk_Awk_parse (JNIEnv* env, jobject obj)
 	srcios.out = __write_source;
 	srcios.custom_data = &srcio_data;
 
-	if (sse_awk_parse (awk, &srcios) == -1)
+	if (ase_awk_parse (awk, &srcios) == -1)
 	{
 printf ("parse error.......\n");
 		except = (*env)->FindClass (env, EXCEPTION_AWK);
 		if (except == 0) return;
 		(*env)->ThrowNew (env, except, "Parse Error ...");
-printf ("parse error -> line [%d] %S\n", sse_awk_getsrcline(awk), sse_awk_geterrstr(sse_awk_geterrnum(awk)));
+printf ("parse error -> line [%d] %S\n", ase_awk_getsrcline(awk), ase_awk_geterrstr(ase_awk_geterrnum(awk)));
 		return;
 	}
 }
 
-JNIEXPORT void JNICALL Java_sse_awk_Awk_run (JNIEnv* env, jobject obj)
+JNIEXPORT void JNICALL Java_ase_awk_Awk_run (JNIEnv* env, jobject obj)
 {
 	jclass class;
 	jfieldID fid;
 	jthrowable except;
 
-	sse_awk_t* awk;
-	sse_awk_runios_t runios;
+	ase_awk_t* awk;
+	ase_awk_runios_t runios;
 	runio_data_t runio_data;
 
 	class = (*env)->GetObjectClass (env, obj);
@@ -191,18 +191,18 @@ JNIEXPORT void JNICALL Java_sse_awk_Awk_run (JNIEnv* env, jobject obj)
 	fid = (*env)->GetFieldID (env, class, FIELD_AWK, "J");
 	if (fid == 0) return;
 
-	awk = (sse_awk_t*) (*env)->GetLongField (env, obj, fid);
+	awk = (ase_awk_t*) (*env)->GetLongField (env, obj, fid);
 
 	runio_data.env = env;
 	runio_data.obj = obj;
 
-	runios.pipe = SSE_NULL;
-	runios.coproc = SSE_NULL;
+	runios.pipe = ASE_NULL;
+	runios.coproc = ASE_NULL;
 	runios.file = __process_extio_file;
 	runios.console = __process_extio_console;
 	runios.custom_data = &runio_data;
 
-	if (sse_awk_run (awk, &runios, SSE_NULL, SSE_NULL) == -1)
+	if (ase_awk_run (awk, &runios, ASE_NULL, ASE_NULL) == -1)
 	{
 		except = (*env)->FindClass (env, EXCEPTION_AWK);
 		if (except == 0) return;
@@ -211,21 +211,21 @@ JNIEXPORT void JNICALL Java_sse_awk_Awk_run (JNIEnv* env, jobject obj)
 	}
 }
 
-JNIEXPORT void JNICALL Java_sse_awk_Awk_set_1extio (
+JNIEXPORT void JNICALL Java_ase_awk_Awk_set_1extio (
 	JNIEnv* env, jobject obj, jlong extio, jobject handle)
 {
-	sse_awk_extio_t* epa = (sse_awk_extio_t*)extio;
+	ase_awk_extio_t* epa = (ase_awk_extio_t*)extio;
 	epa->handle = (void*)handle;
 }
 
-JNIEXPORT jobject JNICALL Java_sse_awk_Awk_get_1extio (
+JNIEXPORT jobject JNICALL Java_ase_awk_Awk_get_1extio (
 	JNIEnv* env, jobject obj, jlong extio)
 {
-	sse_awk_extio_t* epa = (sse_awk_extio_t*)extio;
+	ase_awk_extio_t* epa = (ase_awk_extio_t*)extio;
 	return (jobject)epa->handle;
 }
 
-static sse_ssize_t __call_java_open_source (JNIEnv* env, jobject obj, int mode)
+static ase_ssize_t __call_java_open_source (JNIEnv* env, jobject obj, int mode)
 {
 	jclass class; 
 	jmethodID mid;
@@ -248,7 +248,7 @@ static sse_ssize_t __call_java_open_source (JNIEnv* env, jobject obj, int mode)
 	return ret;
 }
 
-static sse_ssize_t __call_java_close_source (JNIEnv* env, jobject obj, int mode)
+static ase_ssize_t __call_java_close_source (JNIEnv* env, jobject obj, int mode)
 {
 	jclass class; 
 	jmethodID mid;
@@ -271,8 +271,8 @@ static sse_ssize_t __call_java_close_source (JNIEnv* env, jobject obj, int mode)
 	return ret;
 }
 
-static sse_ssize_t __call_java_read_source (
-	JNIEnv* env, jobject obj, sse_char_t* buf, sse_size_t size)
+static ase_ssize_t __call_java_read_source (
+	JNIEnv* env, jobject obj, ase_char_t* buf, ase_size_t size)
 {
 	jclass class; 
 	jmethodID mid;
@@ -298,15 +298,15 @@ static sse_ssize_t __call_java_read_source (
 	}
 
 	tmp = (*env)->GetCharArrayElements (env, array, 0);
-	for (i = 0; i < ret; i++) buf[i] = (sse_char_t)tmp[i]; 
+	for (i = 0; i < ret; i++) buf[i] = (ase_char_t)tmp[i]; 
 	(*env)->ReleaseCharArrayElements (env, array, tmp, 0);
 
 	(*env)->DeleteLocalRef (env, array);
 	return i;
 }
 
-static sse_ssize_t __call_java_write_source (
-	JNIEnv* env, jobject obj, sse_char_t* buf, sse_size_t size)
+static ase_ssize_t __call_java_write_source (
+	JNIEnv* env, jobject obj, ase_char_t* buf, ase_size_t size)
 {
 	jclass class; 
 	jmethodID mid;
@@ -339,8 +339,8 @@ static sse_ssize_t __call_java_write_source (
 	return ret;
 }
 
-static sse_ssize_t __call_java_open_extio (
-	JNIEnv* env, jobject obj, char* meth, sse_awk_extio_t* extio)
+static ase_ssize_t __call_java_open_extio (
+	JNIEnv* env, jobject obj, char* meth, ase_awk_extio_t* extio)
 {
 	jclass class; 
 	jmethodID mid;
@@ -349,7 +349,7 @@ static sse_ssize_t __call_java_open_extio (
 	
 	class = (*env)->GetObjectClass(env, obj);
 
-	if (extio == SSE_NULL)
+	if (extio == ASE_NULL)
 	{
 		mid = (*env)->GetMethodID (env, class, meth, "()I");
 		if (mid == 0) return -1;
@@ -366,7 +366,7 @@ static sse_ssize_t __call_java_open_extio (
 		if (mid == 0) return -1;
 
 		name_str = (*env)->NewString (
-			env, extio->name, sse_awk_strlen(extio->name));
+			env, extio->name, ase_awk_strlen(extio->name));
 		if (name_str == 0) return -1;
 
 		ret = (*env)->CallIntMethod (env, obj, mid, name_str);
@@ -405,8 +405,8 @@ static sse_ssize_t __call_java_open_extio (
 	return ret;
 }
 
-static sse_ssize_t __call_java_close_extio (
-	JNIEnv* env, jobject obj, char* meth, sse_awk_extio_t* extio)
+static ase_ssize_t __call_java_close_extio (
+	JNIEnv* env, jobject obj, char* meth, ase_awk_extio_t* extio)
 {
 	jclass class; 
 	jmethodID mid;
@@ -415,7 +415,7 @@ static sse_ssize_t __call_java_close_extio (
 	
 	class = (*env)->GetObjectClass(env, obj);
 
-	if (extio == SSE_NULL)
+	if (extio == ASE_NULL)
 	{
 		mid = (*env)->GetMethodID (env, class, meth, "()I");
 		if (mid == 0) return -1;
@@ -431,7 +431,7 @@ static sse_ssize_t __call_java_close_extio (
 		if (mid == 0) return -1;
 
 		name_str = (*env)->NewString (
-			env, extio->name, sse_awk_strlen(extio->name));
+			env, extio->name, ase_awk_strlen(extio->name));
 		if (name_str == 0) return -1;
 
 		ret = (*env)->CallIntMethod (env, obj, mid, name_str);
@@ -448,8 +448,8 @@ static sse_ssize_t __call_java_close_extio (
 	return ret;
 }
 
-static sse_ssize_t __call_java_read_extio (
-	JNIEnv* env, jobject obj, char* meth, sse_char_t* buf, sse_size_t size)
+static ase_ssize_t __call_java_read_extio (
+	JNIEnv* env, jobject obj, char* meth, ase_char_t* buf, ase_size_t size)
 {
 	jclass class; 
 	jmethodID mid;
@@ -475,20 +475,20 @@ static sse_ssize_t __call_java_read_extio (
 	}
 
 	tmp = (*env)->GetCharArrayElements (env, array, 0);
-	for (i = 0; i < ret; i++) buf[i] = (sse_char_t)tmp[i]; 
+	for (i = 0; i < ret; i++) buf[i] = (ase_char_t)tmp[i]; 
 	(*env)->ReleaseCharArrayElements (env, array, tmp, 0);
 
 	(*env)->DeleteLocalRef (env, array);
 	return ret;
 }
 
-static sse_ssize_t __call_java_write_extio (
-	JNIEnv* env, jobject obj, char* meth, sse_char_t* data, sse_size_t size)
+static ase_ssize_t __call_java_write_extio (
+	JNIEnv* env, jobject obj, char* meth, ase_char_t* data, ase_size_t size)
 {
 	jclass class; 
 	jmethodID mid;
 	jcharArray array;
-	sse_ssize_t i;
+	ase_ssize_t i;
 	jchar* tmp;
 	jint ret;
 	jthrowable thrown;
@@ -517,22 +517,22 @@ static sse_ssize_t __call_java_write_extio (
 	return ret;
 }
 
-static sse_ssize_t __read_source (
-	int cmd, void* arg, sse_char_t* data, sse_size_t count)
+static ase_ssize_t __read_source (
+	int cmd, void* arg, ase_char_t* data, ase_size_t count)
 {
 	srcio_data_t* srcio_data = (srcio_data_t*)arg;
 
-	if (cmd == SSE_AWK_IO_OPEN) 
+	if (cmd == ASE_AWK_IO_OPEN) 
 	{
 		return __call_java_open_source (
 			srcio_data->env, srcio_data->obj, SOURCE_READ);
 	}
-	else if (cmd == SSE_AWK_IO_CLOSE)
+	else if (cmd == ASE_AWK_IO_CLOSE)
 	{
 		return __call_java_close_source (
 			srcio_data->env, srcio_data->obj, SOURCE_READ);
 	}
-	else if (cmd == SSE_AWK_IO_READ)
+	else if (cmd == ASE_AWK_IO_READ)
 	{
 		return __call_java_read_source (
 			srcio_data->env, srcio_data->obj, data, count);
@@ -541,22 +541,22 @@ static sse_ssize_t __read_source (
 	return -1;
 }
 
-static sse_ssize_t __write_source (
-	int cmd, void* arg, sse_char_t* data, sse_size_t count)
+static ase_ssize_t __write_source (
+	int cmd, void* arg, ase_char_t* data, ase_size_t count)
 {
 	srcio_data_t* srcio_data = (srcio_data_t*)arg;
 
-	if (cmd == SSE_AWK_IO_OPEN) 
+	if (cmd == ASE_AWK_IO_OPEN) 
 	{
 		return __call_java_open_source (
 			srcio_data->env, srcio_data->obj, SOURCE_WRITE);
 	}
-	else if (cmd == SSE_AWK_IO_CLOSE)
+	else if (cmd == ASE_AWK_IO_CLOSE)
 	{
 		return __call_java_close_source (
 			srcio_data->env, srcio_data->obj, SOURCE_WRITE);
 	}
-	else if (cmd == SSE_AWK_IO_WRITE)
+	else if (cmd == ASE_AWK_IO_WRITE)
 	{
 		return __call_java_write_source (
 			srcio_data->env, srcio_data->obj, data, count);
@@ -565,45 +565,45 @@ static sse_ssize_t __write_source (
 	return -1;
 }
 
-static sse_ssize_t __process_extio_console (
-	int cmd, void* arg, sse_char_t* data, sse_size_t size)
+static ase_ssize_t __process_extio_console (
+	int cmd, void* arg, ase_char_t* data, ase_size_t size)
 {
-	sse_awk_extio_t* epa = (sse_awk_extio_t*)arg;
+	ase_awk_extio_t* epa = (ase_awk_extio_t*)arg;
 	runio_data_t* runio_data = (runio_data_t*)epa->custom_data;
 
-	if (cmd == SSE_AWK_IO_OPEN)
+	if (cmd == ASE_AWK_IO_OPEN)
 	{
 		return __call_java_open_extio (
 			runio_data->env, runio_data->obj, 
-			"open_console", SSE_NULL);
+			"open_console", ASE_NULL);
 	}
-	else if (cmd == SSE_AWK_IO_CLOSE)
+	else if (cmd == ASE_AWK_IO_CLOSE)
 	{
 		return __call_java_close_extio (
 			runio_data->env, runio_data->obj, 
-			"close_console", SSE_NULL);
+			"close_console", ASE_NULL);
 	}
 
-	else if (cmd == SSE_AWK_IO_READ)
+	else if (cmd == ASE_AWK_IO_READ)
 	{
 		return __call_java_read_extio (
 			runio_data->env, runio_data->obj, "read_console",
 			data, size);
 	}
-	else if (cmd == SSE_AWK_IO_WRITE)
+	else if (cmd == ASE_AWK_IO_WRITE)
 	{
 		return __call_java_write_extio (
 			runio_data->env, runio_data->obj, "write_console",
 			data, size);
 	}
 #if 0
-	else if (cmd == SSE_AWK_IO_FLUSH)
+	else if (cmd == ASE_AWK_IO_FLUSH)
 	{
 		return __call_java_flush_extio (
 			runio_data->env, runio_data->obj, "flush_console",
 			data, size);
 	}
-	else if (cmd == SSE_AWK_IO_NEXT)
+	else if (cmd == ASE_AWK_IO_NEXT)
 	{
 		return __call_java_next_extio (
 			runio_data->env, runio_data->obj, "flush_console",
@@ -614,19 +614,19 @@ static sse_ssize_t __process_extio_console (
 	return -1;
 }
 
-static sse_ssize_t __process_extio_file (
-	int cmd, void* arg, sse_char_t* data, sse_size_t size)
+static ase_ssize_t __process_extio_file (
+	int cmd, void* arg, ase_char_t* data, ase_size_t size)
 {
-	sse_awk_extio_t* epa = (sse_awk_extio_t*)arg;
+	ase_awk_extio_t* epa = (ase_awk_extio_t*)arg;
 	runio_data_t* runio_data = (runio_data_t*)epa->custom_data;
 
-	if (cmd == SSE_AWK_IO_OPEN)
+	if (cmd == ASE_AWK_IO_OPEN)
 	{
 		return __call_java_open_extio (
 			runio_data->env, runio_data->obj, 
 			"open_file", epa);
 	}
-	else if (cmd == SSE_AWK_IO_CLOSE)
+	else if (cmd == ASE_AWK_IO_CLOSE)
 	{
 		return __call_java_close_extio (
 			runio_data->env, runio_data->obj, 
diff --git a/ase/awk/jni.h b/ase/awk/jni.h
index f55ede7b..e65644ff 100644
--- a/ase/awk/jni.h
+++ b/ase/awk/jni.h
@@ -1,9 +1,9 @@
 /*
- * $Id: jni.h,v 1.6 2006-10-22 12:39:29 bacon Exp $
+ * $Id: jni.h,v 1.7 2006-10-24 04:10:12 bacon Exp $
  */
 
-#ifndef _SSE_AWK_JNI_H_
-#define _SSE_AWK_JNI_H_
+#ifndef _ASE_AWK_JNI_H_
+#define _ASE_AWK_JNI_H_
 
 #include <jni.h>
 
@@ -11,10 +11,10 @@
 extern "C" {
 #endif
 
-JNIEXPORT void JNICALL Java_sse_awk_Awk_open (JNIEnv*, jobject);
-JNIEXPORT void JNICALL Java_sse_awk_Awk_close (JNIEnv*, jobject);
-JNIEXPORT void JNICALL Java_sse_awk_Awk_parse (JNIEnv*, jobject);
-JNIEXPORT void JNICALL Java_sse_awk_Awk_run (JNIEnv*, jobject);
+JNIEXPORT void JNICALL Java_ase_awk_Awk_open (JNIEnv*, jobject);
+JNIEXPORT void JNICALL Java_ase_awk_Awk_close (JNIEnv*, jobject);
+JNIEXPORT void JNICALL Java_ase_awk_Awk_parse (JNIEnv*, jobject);
+JNIEXPORT void JNICALL Java_ase_awk_Awk_run (JNIEnv*, jobject);
 
 #ifdef __cplusplus
 }
diff --git a/ase/awk/map.c b/ase/awk/map.c
index 9069d36f..30bb73fb 100644
--- a/ase/awk/map.c
+++ b/ase/awk/map.c
@@ -1,70 +1,70 @@
 /*
- * $Id: map.c,v 1.27 2006-10-22 11:34:53 bacon Exp $
+ * $Id: map.c,v 1.28 2006-10-24 04:10:12 bacon Exp $
  */
 
-#include <sse/awk/awk_i.h>
+#include <ase/awk/awk_i.h>
 
 /* TODO: improve the entire map routines.
          support automatic bucket resizing and remaping, etc. */
 
-static sse_size_t __hash (const sse_char_t* key, sse_size_t key_len);
+static ase_size_t __hash (const ase_char_t* key, ase_size_t key_len);
 
 #define FREE_PAIR(map,pair) \
 	do { \
-		SSE_AWK_FREE ((map)->awk, (sse_char_t*)(pair)->key); \
-		if ((map)->freeval != SSE_NULL) \
+		ASE_AWK_FREE ((map)->awk, (ase_char_t*)(pair)->key); \
+		if ((map)->freeval != ASE_NULL) \
 			(map)->freeval ((map)->owner, (pair)->val); \
-		SSE_AWK_FREE ((map)->awk, pair); \
+		ASE_AWK_FREE ((map)->awk, pair); \
 	} while (0)
 
-sse_awk_map_t* sse_awk_map_open (
-	sse_awk_map_t* map, void* owner, sse_size_t capa, 
-	void(*freeval)(void*,void*), sse_awk_t* awk)
+ase_awk_map_t* ase_awk_map_open (
+	ase_awk_map_t* map, void* owner, ase_size_t capa, 
+	void(*freeval)(void*,void*), ase_awk_t* awk)
 {
-	if (map == SSE_NULL) 
+	if (map == ASE_NULL) 
 	{
-		map = (sse_awk_map_t*) SSE_AWK_MALLOC (
-			awk, sse_sizeof(sse_awk_map_t));
-		if (map == SSE_NULL) return SSE_NULL;
-		map->__dynamic = sse_true;
+		map = (ase_awk_map_t*) ASE_AWK_MALLOC (
+			awk, ase_sizeof(ase_awk_map_t));
+		if (map == ASE_NULL) return ASE_NULL;
+		map->__dynamic = ase_true;
 	}
-	else map->__dynamic = sse_false;
+	else map->__dynamic = ase_false;
 
 	map->awk = awk;
-	map->buck = (sse_awk_pair_t**) 
-		SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_pair_t*) * capa);
-	if (map->buck == SSE_NULL) 
+	map->buck = (ase_awk_pair_t**) 
+		ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_pair_t*) * capa);
+	if (map->buck == ASE_NULL) 
 	{
-		if (map->__dynamic) SSE_AWK_FREE (awk, map);
-		return SSE_NULL;	
+		if (map->__dynamic) ASE_AWK_FREE (awk, map);
+		return ASE_NULL;	
 	}
 
 	map->owner = owner;
 	map->capa = capa;
 	map->size = 0;
 	map->freeval = freeval;
-	while (capa > 0) map->buck[--capa] = SSE_NULL;
+	while (capa > 0) map->buck[--capa] = ASE_NULL;
 
 	return map;
 }
 
-void sse_awk_map_close (sse_awk_map_t* map)
+void ase_awk_map_close (ase_awk_map_t* map)
 {
-	sse_awk_map_clear (map);
-	SSE_AWK_FREE (map->awk, map->buck);
-	if (map->__dynamic) SSE_AWK_FREE (map->awk, map);
+	ase_awk_map_clear (map);
+	ASE_AWK_FREE (map->awk, map->buck);
+	if (map->__dynamic) ASE_AWK_FREE (map->awk, map);
 }
 
-void sse_awk_map_clear (sse_awk_map_t* map)
+void ase_awk_map_clear (ase_awk_map_t* map)
 {
-	sse_size_t i;
-	sse_awk_pair_t* pair, * next;
+	ase_size_t i;
+	ase_awk_pair_t* pair, * next;
 
 	for (i = 0; i < map->capa; i++) 
 	{
 		pair = map->buck[i];
 
-		while (pair != SSE_NULL) 
+		while (pair != ASE_NULL) 
 		{
 			next = pair->next;
 			FREE_PAIR (map, pair);
@@ -72,81 +72,81 @@ void sse_awk_map_clear (sse_awk_map_t* map)
 			pair = next;
 		}
 
-		map->buck[i] = SSE_NULL;
+		map->buck[i] = ASE_NULL;
 	}
 
-	sse_awk_assert (map->awk, map->size == 0);
+	ase_awk_assert (map->awk, map->size == 0);
 }
 
-sse_awk_pair_t* sse_awk_map_get (
-	sse_awk_map_t* map, const sse_char_t* key, sse_size_t key_len)
+ase_awk_pair_t* ase_awk_map_get (
+	ase_awk_map_t* map, const ase_char_t* key, ase_size_t key_len)
 {
-	sse_awk_pair_t* pair;
-	sse_size_t hc;
+	ase_awk_pair_t* pair;
+	ase_size_t hc;
 
 	hc = __hash(key,key_len) % map->capa;
 	pair = map->buck[hc];
 
-	while (pair != SSE_NULL) 
+	while (pair != ASE_NULL) 
 	{
 
-		if (sse_awk_strxncmp (
+		if (ase_awk_strxncmp (
 			pair->key, pair->key_len, 
 			key, key_len) == 0) return pair;
 
 		pair = pair->next;
 	}
 
-	return SSE_NULL;
+	return ASE_NULL;
 }
 
-sse_awk_pair_t* sse_awk_map_put (
-	sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len, void* val)
+ase_awk_pair_t* ase_awk_map_put (
+	ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len, void* val)
 {
 	int n;
-	sse_awk_pair_t* px;
+	ase_awk_pair_t* px;
 
-	n = sse_awk_map_putx (map, key, key_len, val, &px);
-	if (n < 0) return SSE_NULL;
+	n = ase_awk_map_putx (map, key, key_len, val, &px);
+	if (n < 0) return ASE_NULL;
 	return px;
 }
 
-int sse_awk_map_putx (
-	sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len, 
-	void* val, sse_awk_pair_t** px)
+int ase_awk_map_putx (
+	ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len, 
+	void* val, ase_awk_pair_t** px)
 {
-	sse_awk_pair_t* pair;
-	sse_size_t hc;
+	ase_awk_pair_t* pair;
+	ase_size_t hc;
 
 	hc = __hash(key,key_len) % map->capa;
 	pair = map->buck[hc];
 
-	while (pair != SSE_NULL) 
+	while (pair != ASE_NULL) 
 	{
-		if (sse_awk_strxncmp (
+		if (ase_awk_strxncmp (
 			pair->key, pair->key_len, key, key_len) == 0) 
 		{
-			if (px != SSE_NULL)
-				*px = sse_awk_map_setpair (map, pair, val);
+			if (px != ASE_NULL)
+				*px = ase_awk_map_setpair (map, pair, val);
 			else
-				sse_awk_map_setpair (map, pair, val);
+				ase_awk_map_setpair (map, pair, val);
 
 			return 0; /* value changed for the existing key */
 		}
 		pair = pair->next;
 	}
 
-	pair = (sse_awk_pair_t*) SSE_AWK_MALLOC (
-		map->awk, sse_sizeof(sse_awk_pair_t));
-	if (pair == SSE_NULL) return -1; /* error */
+	pair = (ase_awk_pair_t*) ASE_AWK_MALLOC (
+		map->awk, ase_sizeof(ase_awk_pair_t));
+	if (pair == ASE_NULL) return -1; /* error */
 
 	/*pair->key = key;*/ 
 
 	/* duplicate the key if it is new */
-	pair->key = sse_awk_strxdup (map->awk, key, key_len);
-	if (pair->key == SSE_NULL)
+	pair->key = ase_awk_strxdup (map->awk, key, key_len);
+	if (pair->key == ASE_NULL)
 	{
-		SSE_AWK_FREE (map->awk, pair);
+		ASE_AWK_FREE (map->awk, pair);
 		return -1; /* error */
 	}
 
@@ -156,51 +156,51 @@ int sse_awk_map_putx (
 	map->buck[hc] = pair;
 	map->size++;
 
-	if (px != SSE_NULL) *px = pair;
+	if (px != ASE_NULL) *px = pair;
 	return 1; /* new key added */
 }
 
-sse_awk_pair_t* sse_awk_map_set (
-	sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len, void* val)
+ase_awk_pair_t* ase_awk_map_set (
+	ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len, void* val)
 {
-	sse_awk_pair_t* pair;
-	sse_size_t hc;
+	ase_awk_pair_t* pair;
+	ase_size_t hc;
 
 	hc = __hash(key,key_len) % map->capa;
 	pair = map->buck[hc];
 
-	while (pair != SSE_NULL) 
+	while (pair != ASE_NULL) 
 	{
-		if (sse_awk_strxncmp (
+		if (ase_awk_strxncmp (
 			pair->key, pair->key_len, key, key_len) == 0) 
 		{
-			return sse_awk_map_setpair (map, pair, val);
+			return ase_awk_map_setpair (map, pair, val);
 		}
 		pair = pair->next;
 	}
 
-	return SSE_NULL;
+	return ASE_NULL;
 }
 
-sse_awk_pair_t* sse_awk_map_getpair (
-	sse_awk_map_t* map, const sse_char_t* key, sse_size_t key_len, void** val)
+ase_awk_pair_t* ase_awk_map_getpair (
+	ase_awk_map_t* map, const ase_char_t* key, ase_size_t key_len, void** val)
 {
-	sse_awk_pair_t* pair;
+	ase_awk_pair_t* pair;
 
-	pair = sse_awk_map_get (map, key, key_len);
-	if (pair == SSE_NULL) return SSE_NULL; 
+	pair = ase_awk_map_get (map, key, key_len);
+	if (pair == ASE_NULL) return ASE_NULL; 
 	*val = pair->val;
 
 	return pair;
 }
 
-sse_awk_pair_t* sse_awk_map_setpair (
-	sse_awk_map_t* map, sse_awk_pair_t* pair, void* val)
+ase_awk_pair_t* ase_awk_map_setpair (
+	ase_awk_map_t* map, ase_awk_pair_t* pair, void* val)
 {
 	/* use this function with care */
 	if (pair->val != val) 
 	{
-		if (map->freeval != SSE_NULL) 
+		if (map->freeval != ASE_NULL) 
 		{
 			map->freeval (map->owner, pair->val);
 		}
@@ -210,21 +210,21 @@ sse_awk_pair_t* sse_awk_map_setpair (
 	return pair;
 }
 
-int sse_awk_map_remove (sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len)
+int ase_awk_map_remove (ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len)
 {
-	sse_awk_pair_t* pair, * prev;
-	sse_size_t hc;
+	ase_awk_pair_t* pair, * prev;
+	ase_size_t hc;
 
 	hc = __hash(key,key_len) % map->capa;
 	pair = map->buck[hc];
-	prev = SSE_NULL;
+	prev = ASE_NULL;
 
-	while (pair != SSE_NULL) 
+	while (pair != ASE_NULL) 
 	{
-		if (sse_awk_strxncmp (
+		if (ase_awk_strxncmp (
 			pair->key, pair->key_len, key, key_len) == 0) 
 		{
-			if (prev == SSE_NULL) 
+			if (prev == ASE_NULL) 
 				map->buck[hc] = pair->next;
 			else prev->next = pair->next;
 
@@ -241,17 +241,17 @@ int sse_awk_map_remove (sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len)
 	return -1;
 }
 
-int sse_awk_map_walk (sse_awk_map_t* map, 
-	int (*walker) (sse_awk_pair_t*,void*), void* arg)
+int ase_awk_map_walk (ase_awk_map_t* map, 
+	int (*walker) (ase_awk_pair_t*,void*), void* arg)
 {
-	sse_size_t i;
-	sse_awk_pair_t* pair, * next;
+	ase_size_t i;
+	ase_awk_pair_t* pair, * next;
 
 	for (i = 0; i < map->capa; i++) 
 	{
 		pair = map->buck[i];
 
-		while (pair != SSE_NULL) 
+		while (pair != ASE_NULL) 
 		{
 			next = pair->next;
 			if (walker(pair,arg) == -1) return -1;
@@ -262,15 +262,15 @@ int sse_awk_map_walk (sse_awk_map_t* map,
 	return 0;
 }
 
-static sse_size_t __hash (const sse_char_t* key, sse_size_t key_len)
+static ase_size_t __hash (const ase_char_t* key, ase_size_t key_len)
 {
-	sse_size_t n = 0, i;
-	const sse_char_t* end = key + key_len;
+	ase_size_t n = 0, i;
+	const ase_char_t* end = key + key_len;
 
 	while (key < end)
 	{
-		sse_byte_t* bp = (sse_byte_t*)key;
-		for (i = 0; i < sse_sizeof(*key); i++) n = n * 31 + *bp++;
+		ase_byte_t* bp = (ase_byte_t*)key;
+		for (i = 0; i < ase_sizeof(*key); i++) n = n * 31 + *bp++;
 		key++;
 	}	
 
diff --git a/ase/awk/map.h b/ase/awk/map.h
index 91f127f4..dc864cc9 100644
--- a/ase/awk/map.h
+++ b/ase/awk/map.h
@@ -1,71 +1,71 @@
 /*
- * $Id: map.h,v 1.16 2006-10-22 11:34:53 bacon Exp $
+ * $Id: map.h,v 1.17 2006-10-24 04:10:12 bacon Exp $
  */
 
-#ifndef _SSE_AWK_MAP_H_
-#define _SSE_AWK_MAP_H_
+#ifndef _ASE_AWK_MAP_H_
+#define _ASE_AWK_MAP_H_
 
-#ifndef _SSE_AWK_AWK_H_
-#error Never include this file directly. Include <sse/awk/awk.h> instead
+#ifndef _ASE_AWK_AWK_H_
+#error Never include this file directly. Include <ase/awk/awk.h> instead
 #endif
 
-typedef struct sse_awk_map_t sse_awk_map_t;
-typedef struct sse_awk_pair_t sse_awk_pair_t;
+typedef struct ase_awk_map_t ase_awk_map_t;
+typedef struct ase_awk_pair_t ase_awk_pair_t;
 
-struct sse_awk_pair_t
+struct ase_awk_pair_t
 {
-	sse_char_t* key;
-	sse_size_t key_len;
+	ase_char_t* key;
+	ase_size_t key_len;
 	void* val;
-	sse_awk_pair_t* next;
+	ase_awk_pair_t* next;
 };
 
-struct sse_awk_map_t
+struct ase_awk_map_t
 {
 	void* owner;
-	sse_size_t size;
-	sse_size_t capa;
-	sse_awk_pair_t** buck;
+	ase_size_t size;
+	ase_size_t capa;
+	ase_awk_pair_t** buck;
 	void (*freeval) (void*,void*);
-	sse_awk_t* awk;
-	sse_bool_t __dynamic;
+	ase_awk_t* awk;
+	ase_bool_t __dynamic;
 };
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-sse_awk_map_t* sse_awk_map_open (
-	sse_awk_map_t* map, void* owner, sse_size_t capa, 
-	void(*freeval)(void*,void*), sse_awk_t* awk);
+ase_awk_map_t* ase_awk_map_open (
+	ase_awk_map_t* map, void* owner, ase_size_t capa, 
+	void(*freeval)(void*,void*), ase_awk_t* awk);
 
-void sse_awk_map_close (sse_awk_map_t* map);
+void ase_awk_map_close (ase_awk_map_t* map);
 
-void sse_awk_map_clear (sse_awk_map_t* map);
+void ase_awk_map_clear (ase_awk_map_t* map);
 
-sse_awk_pair_t* sse_awk_map_get (
-	sse_awk_map_t* map, const sse_char_t* key, sse_size_t key_len);
+ase_awk_pair_t* ase_awk_map_get (
+	ase_awk_map_t* map, const ase_char_t* key, ase_size_t key_len);
 
-sse_awk_pair_t* sse_awk_map_put (
-	sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len, void* val);
+ase_awk_pair_t* ase_awk_map_put (
+	ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len, void* val);
 
-int sse_awk_map_putx (
-	sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len,
-	void* val, sse_awk_pair_t** px);
+int ase_awk_map_putx (
+	ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len,
+	void* val, ase_awk_pair_t** px);
 
-sse_awk_pair_t* sse_awk_map_set (
-	sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len, void* val);
+ase_awk_pair_t* ase_awk_map_set (
+	ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len, void* val);
 
-sse_awk_pair_t* sse_awk_map_getpair (
-	sse_awk_map_t* map, const sse_char_t* key, sse_size_t key_len, void** val);
+ase_awk_pair_t* ase_awk_map_getpair (
+	ase_awk_map_t* map, const ase_char_t* key, ase_size_t key_len, void** val);
 
-sse_awk_pair_t* sse_awk_map_setpair (
-	sse_awk_map_t* map, sse_awk_pair_t* pair, void* val);
+ase_awk_pair_t* ase_awk_map_setpair (
+	ase_awk_map_t* map, ase_awk_pair_t* pair, void* val);
 
-int sse_awk_map_remove (sse_awk_map_t* map, sse_char_t* key, sse_size_t key_len);
+int ase_awk_map_remove (ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len);
 
-int sse_awk_map_walk (sse_awk_map_t* map, 
-	int (*walker)(sse_awk_pair_t*,void*), void* arg);
+int ase_awk_map_walk (ase_awk_map_t* map, 
+	int (*walker)(ase_awk_pair_t*,void*), void* arg);
 
 #ifdef __cplusplus
 }
diff --git a/ase/awk/misc.c b/ase/awk/misc.c
index 62ed59b9..edc1ef9e 100644
--- a/ase/awk/misc.c
+++ b/ase/awk/misc.c
@@ -1,66 +1,66 @@
 /*
- * $Id: misc.c,v 1.30 2006-10-22 12:39:29 bacon Exp $
+ * $Id: misc.c,v 1.31 2006-10-24 04:10:12 bacon Exp $
  */
 
-#include <sse/awk/awk_i.h>
+#include <ase/awk/awk_i.h>
 
-void* sse_awk_memcpy  (void* dst, const void* src, sse_size_t n)
+void* ase_awk_memcpy  (void* dst, const void* src, ase_size_t n)
 {
 	void* p = dst;
-	void* e = (sse_byte_t*)dst + n;
+	void* e = (ase_byte_t*)dst + n;
 
 	while (dst < e) 
 	{
-		*(sse_byte_t*)dst = *(sse_byte_t*)src;
-		dst = (sse_byte_t*)dst + 1;
-		src = (sse_byte_t*)src + 1;
+		*(ase_byte_t*)dst = *(ase_byte_t*)src;
+		dst = (ase_byte_t*)dst + 1;
+		src = (ase_byte_t*)src + 1;
 	}
 
 	return p;
 }
 
-void* sse_awk_memset (void* dst, int val, sse_size_t n)
+void* ase_awk_memset (void* dst, int val, ase_size_t n)
 {
 	void* p = dst;
-	void* e = (sse_byte_t*)p + n;
+	void* e = (ase_byte_t*)p + n;
 
 	while (p < e) 
 	{
-		*(sse_byte_t*)p = (sse_byte_t)val;
-		p = (sse_byte_t*)p + 1;
+		*(ase_byte_t*)p = (ase_byte_t)val;
+		p = (ase_byte_t*)p + 1;
 	}
 
 	return dst;
 }
 
-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)
+ase_long_t ase_awk_strxtolong (
+	ase_awk_t* awk, const ase_char_t* str, ase_size_t len,
+	int base, const ase_char_t** endptr)
 {
-	sse_long_t n = 0;
-	const sse_char_t* p;
-	const sse_char_t* end;
-	sse_size_t rem;
+	ase_long_t n = 0;
+	const ase_char_t* p;
+	const ase_char_t* end;
+	ase_size_t rem;
 	int digit, negative = 0;
 
-	sse_awk_assert (awk, base < 37); 
+	ase_awk_assert (awk, base < 37); 
 
 	p = str; 
 	end = str + len;
 	
 	/* strip off leading spaces */
-	/*while (SSE_AWK_ISSPACE(awk,*p)) p++;*/
+	/*while (ASE_AWK_ISSPACE(awk,*p)) p++;*/
 
 	/* check for a sign */
-	/*while (*p != SSE_T('\0')) */
+	/*while (*p != ASE_T('\0')) */
 	while (p < end)
 	{
-		if (*p == SSE_T('-')) 
+		if (*p == ASE_T('-')) 
 		{
 			negative = ~negative;
 			p++;
 		}
-		else if (*p == SSE_T('+')) p++;
+		else if (*p == ASE_T('+')) p++;
 		else break;
 	}
 
@@ -68,16 +68,16 @@ sse_long_t sse_awk_strxtolong (
 	rem = end - p;
 	if (base == 0) 
 	{
-		if (rem >= 1 && *p == SSE_T('0')) 
+		if (rem >= 1 && *p == ASE_T('0')) 
 		{
 			p++;
 
 			if (rem == 1) base = 8;
-			else if (*p == SSE_T('x') || *p == SSE_T('X'))
+			else if (*p == ASE_T('x') || *p == ASE_T('X'))
 			{
 				p++; base = 16;
 			} 
-			else if (*p == SSE_T('b') || *p == SSE_T('B'))
+			else if (*p == ASE_T('b') || *p == ASE_T('B'))
 			{
 				p++; base = 2;
 			}
@@ -87,25 +87,25 @@ sse_long_t sse_awk_strxtolong (
 	} 
 	else if (rem >= 2 && base == 16)
 	{
-		if (*p == SSE_T('0') && 
-		    (*(p+1) == SSE_T('x') || *(p+1) == SSE_T('X'))) p += 2; 
+		if (*p == ASE_T('0') && 
+		    (*(p+1) == ASE_T('x') || *(p+1) == ASE_T('X'))) p += 2; 
 	}
 	else if (rem >= 2 && base == 2)
 	{
-		if (*p == SSE_T('0') && 
-		    (*(p+1) == SSE_T('b') || *(p+1) == SSE_T('B'))) p += 2; 
+		if (*p == ASE_T('0') && 
+		    (*(p+1) == ASE_T('b') || *(p+1) == ASE_T('B'))) p += 2; 
 	}
 
 	/* process the digits */
-	/*while (*p != SSE_T('\0'))*/
+	/*while (*p != ASE_T('\0'))*/
 	while (p < end)
 	{
-		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;
+		if (*p >= ASE_T('0') && *p <= ASE_T('9'))
+			digit = *p - ASE_T('0');
+		else if (*p >= ASE_T('A') && *p <= ASE_T('Z'))
+			digit = *p - ASE_T('A') + 10;
+		else if (*p >= ASE_T('a') && *p <= ASE_T('z'))
+			digit = *p - ASE_T('a') + 10;
 		else break;
 
 		if (digit >= base) break;
@@ -114,13 +114,13 @@ sse_long_t sse_awk_strxtolong (
 		p++;
 	}
 
-	if (endptr != SSE_NULL) *endptr = p;
+	if (endptr != ASE_NULL) *endptr = p;
 	return (negative)? -n: n;
 }
 
 
 /*
- * sse_awk_strtoreal is almost a replica of strtod.
+ * ase_awk_strtoreal is almost a replica of strtod.
  *
  * strtod.c --
  *
@@ -140,21 +140,21 @@ sse_long_t sse_awk_strxtolong (
 
 #define MAX_EXPONENT 511
 
-sse_real_t sse_awk_strtoreal (sse_awk_t* awk, const sse_char_t* str)
+ase_real_t ase_awk_strtoreal (ase_awk_t* awk, const ase_char_t* str)
 {
 	/* 
 	 * Table giving binary powers of 10. Entry is 10^2^i.  
 	 * Used to convert decimal exponents into floating-point numbers.
 	 */ 
-	static sse_real_t powers_of_10[] = 
+	static ase_real_t powers_of_10[] = 
 	{
 		10.,    100.,   1.0e4,   1.0e8,   1.0e16,
 		1.0e32, 1.0e64, 1.0e128, 1.0e256
 	};
 
-	sse_real_t fraction, dbl_exp, * d;
-	const sse_char_t* p;
-	sse_cint_t c;
+	ase_real_t fraction, dbl_exp, * d;
+	const ase_char_t* p;
+	ase_cint_t c;
 	int exp = 0;		/* Esseonent read from "EX" field */
 
 	/* 
@@ -169,23 +169,23 @@ sse_real_t sse_awk_strtoreal (sse_awk_t* awk, const sse_char_t* str)
 	int frac_exp;
 	int mant_size; /* Number of digits in mantissa. */
 	int dec_pt;    /* Number of mantissa digits BEFORE decimal point */
-	const sse_char_t *pexp;  /* Temporarily holds location of exponent in string */
+	const ase_char_t *pexp;  /* Temporarily holds location of exponent in string */
 	int negative = 0, exp_negative = 0;
 
 	p = str;
 
 	/* strip off leading blanks */ 
-	/*while (SSE_AWK_ISSPACE(awk,*p)) p++;*/
+	/*while (ASE_AWK_ISSPACE(awk,*p)) p++;*/
 
 	/* check for a sign */
-	while (*p != SSE_T('\0')) 
+	while (*p != ASE_T('\0')) 
 	{
-		if (*p == SSE_T('-')) 
+		if (*p == ASE_T('-')) 
 		{
 			negative = ~negative;
 			p++;
 		}
-		else if (*p == SSE_T('+')) p++;
+		else if (*p == ASE_T('+')) p++;
 		else break;
 	}
 
@@ -195,9 +195,9 @@ sse_real_t sse_awk_strtoreal (sse_awk_t* awk, const sse_char_t* str)
 	for (mant_size = 0; ; mant_size++) 
 	{
 		c = *p;
-		if (!SSE_AWK_ISDIGIT (awk, c)) 
+		if (!ASE_AWK_ISDIGIT (awk, c)) 
 		{
-			if ((c != SSE_T('.')) || (dec_pt >= 0)) break;
+			if ((c != ASE_T('.')) || (dec_pt >= 0)) break;
 			dec_pt = mant_size;
 		}
 		p++;
@@ -245,51 +245,51 @@ sse_real_t sse_awk_strtoreal (sse_awk_t* awk, const sse_char_t* str)
 		{
 			c = *p;
 			p++;
-			if (c == SSE_T('.')) 
+			if (c == ASE_T('.')) 
 			{
 				c = *p;
 				p++;
 			}
-			frac1 = 10 * frac1 + (c - SSE_T('0'));
+			frac1 = 10 * frac1 + (c - ASE_T('0'));
 		}
 		frac2 = 0;
 		for (; mant_size > 0; mant_size--) {
 			c = *p;
 			p++;
-			if (c == SSE_T('.')) 
+			if (c == ASE_T('.')) 
 			{
 				c = *p;
 				p++;
 			}
-			frac2 = 10*frac2 + (c - SSE_T('0'));
+			frac2 = 10*frac2 + (c - ASE_T('0'));
 		}
 		fraction = (1.0e9 * frac1) + frac2;
 	}
 
 	/* Skim off the exponent */
 	p = pexp;
-	if ((*p == SSE_T('E')) || (*p == SSE_T('e'))) 
+	if ((*p == ASE_T('E')) || (*p == ASE_T('e'))) 
 	{
 		p++;
-		if (*p == SSE_T('-')) 
+		if (*p == ASE_T('-')) 
 		{
 			exp_negative = 1;
 			p++;
 		} 
 		else 
 		{
-			if (*p == SSE_T('+')) p++;
+			if (*p == ASE_T('+')) p++;
 			exp_negative = 0;
 		}
-		if (!SSE_AWK_ISDIGIT (awk, *p)) 
+		if (!ASE_AWK_ISDIGIT (awk, *p)) 
 		{
 			/* p = pexp; */
 			/* goto done; */
 			goto no_exp;
 		}
-		while (SSE_AWK_ISDIGIT (awk, *p)) 
+		while (ASE_AWK_ISDIGIT (awk, *p)) 
 		{
-			exp = exp * 10 + (*p - SSE_T('0'));
+			exp = exp * 10 + (*p - ASE_T('0'));
 			p++;
 		}
 	}
@@ -327,23 +327,23 @@ done:
 	return (negative)? -fraction: fraction;
 }
 
-sse_real_t sse_awk_strxtoreal (
-	sse_awk_t* awk, const sse_char_t* str, sse_size_t len, 
-	const sse_char_t** endptr)
+ase_real_t ase_awk_strxtoreal (
+	ase_awk_t* awk, const ase_char_t* str, ase_size_t len, 
+	const ase_char_t** endptr)
 {
 	/* 
 	 * Table giving binary powers of 10. Entry is 10^2^i.  
 	 * Used to convert decimal exponents into floating-point numbers.
 	 */ 
-	static sse_real_t powers_of_10[] = 
+	static ase_real_t powers_of_10[] = 
 	{
 		10.,    100.,   1.0e4,   1.0e8,   1.0e16,
 		1.0e32, 1.0e64, 1.0e128, 1.0e256
 	};
 
-	sse_real_t fraction, dbl_exp, * d;
-	const sse_char_t* p, * end;
-	sse_cint_t c;
+	ase_real_t fraction, dbl_exp, * d;
+	const ase_char_t* p, * end;
+	ase_cint_t c;
 	int exp = 0; /* Esseonent read from "EX" field */
 
 	/* 
@@ -358,24 +358,24 @@ sse_real_t sse_awk_strxtoreal (
 	int frac_exp;
 	int mant_size; /* Number of digits in mantissa. */
 	int dec_pt;    /* Number of mantissa digits BEFORE decimal point */
-	const sse_char_t *pexp;  /* Temporarily holds location of exponent in string */
+	const ase_char_t *pexp;  /* Temporarily holds location of exponent in string */
 	int negative = 0, exp_negative = 0;
 
 	p = str;
 	end = str + len;
 
 	/* Strip off leading blanks and check for a sign */
-	/*while (SSE_AWK_ISSPACE(awk,*p)) p++;*/
+	/*while (ASE_AWK_ISSPACE(awk,*p)) p++;*/
 
-	/*while (*p != SSE_T('\0')) */
+	/*while (*p != ASE_T('\0')) */
 	while (p < end)
 	{
-		if (*p == SSE_T('-')) 
+		if (*p == ASE_T('-')) 
 		{
 			negative = ~negative;
 			p++;
 		}
-		else if (*p == SSE_T('+')) p++;
+		else if (*p == ASE_T('+')) p++;
 		else break;
 	}
 
@@ -386,9 +386,9 @@ sse_real_t sse_awk_strxtoreal (
 	for (mant_size = 0; p < end; mant_size++) 
 	{
 		c = *p;
-		if (!SSE_AWK_ISDIGIT (awk, c)) 
+		if (!ASE_AWK_ISDIGIT (awk, c)) 
 		{
-			if (c != SSE_T('.') || dec_pt >= 0) break;
+			if (c != ASE_T('.') || dec_pt >= 0) break;
 			dec_pt = mant_size;
 		}
 		p++;
@@ -411,7 +411,7 @@ sse_real_t sse_awk_strxtoreal (
 		mant_size--;	/* One of the digits was the point */
 	}
 
-	if (mant_size > 18)  /* TODO: is 18 correct for sse_real_t??? */
+	if (mant_size > 18)  /* TODO: is 18 correct for ase_real_t??? */
 	{
 		frac_exp = dec_pt - 18;
 		mant_size = 18;
@@ -437,58 +437,58 @@ sse_real_t sse_awk_strxtoreal (
 		{
 			c = *p;
 			p++;
-			if (c == SSE_T('.')) 
+			if (c == ASE_T('.')) 
 			{
 				c = *p;
 				p++;
 			}
-			frac1 = 10 * frac1 + (c - SSE_T('0'));
+			frac1 = 10 * frac1 + (c - ASE_T('0'));
 		}
 
 		frac2 = 0;
 		for (; mant_size > 0; mant_size--) {
 			c = *p++;
-			if (c == SSE_T('.')) 
+			if (c == ASE_T('.')) 
 			{
 				c = *p;
 				p++;
 			}
-			frac2 = 10 * frac2 + (c - SSE_T('0'));
+			frac2 = 10 * frac2 + (c - ASE_T('0'));
 		}
 		fraction = (1.0e9 * frac1) + frac2;
 	}
 
 	/* Skim off the exponent */
 	p = pexp;
-	if (p < end && (*p == SSE_T('E') || *p == SSE_T('e'))) 
+	if (p < end && (*p == ASE_T('E') || *p == ASE_T('e'))) 
 	{
 		p++;
 
 		if (p < end) 
 		{
-			if (*p == SSE_T('-')) 
+			if (*p == ASE_T('-')) 
 			{
 				exp_negative = 1;
 				p++;
 			} 
 			else 
 			{
-				if (*p == SSE_T('+')) p++;
+				if (*p == ASE_T('+')) p++;
 				exp_negative = 0;
 			}
 		}
 		else exp_negative = 0;
 
-		if (!(p < end && SSE_AWK_ISDIGIT (awk, *p))) 
+		if (!(p < end && ASE_AWK_ISDIGIT (awk, *p))) 
 		{
 			/*p = pexp;*/
 			/*goto done;*/
 			goto no_exp;
 		}
 
-		while (p < end && SSE_AWK_ISDIGIT (awk, *p)) 
+		while (p < end && ASE_AWK_ISDIGIT (awk, *p)) 
 		{
-			exp = exp * 10 + (*p - SSE_T('0'));
+			exp = exp * 10 + (*p - ASE_T('0'));
 			p++;
 		}
 	}
@@ -523,35 +523,35 @@ no_exp:
 	else fraction *= dbl_exp;
 
 done:
-	if (endptr != SSE_NULL) *endptr = p;
+	if (endptr != ASE_NULL) *endptr = p;
 	return (negative)? -fraction: fraction;
 }
 
-sse_size_t sse_awk_longtostr (
-	sse_long_t value, int radix, const sse_char_t* prefix, 
-	sse_char_t* buf, sse_size_t size)
+ase_size_t ase_awk_longtostr (
+	ase_long_t value, int radix, const ase_char_t* prefix, 
+	ase_char_t* buf, ase_size_t size)
 {
-	sse_long_t t, rem;
-	sse_size_t len, ret, i;
-	sse_size_t prefix_len;
+	ase_long_t t, rem;
+	ase_size_t len, ret, i;
+	ase_size_t prefix_len;
 
-	prefix_len = (prefix != SSE_NULL)? sse_awk_strlen(prefix): 0;
+	prefix_len = (prefix != ASE_NULL)? ase_awk_strlen(prefix): 0;
 
 	t = value;
 	if (t == 0)
 	{
 		/* zero */
-		if (buf == SSE_NULL) return prefix_len + 1;
+		if (buf == ASE_NULL) return prefix_len + 1;
 
 		if (size < prefix_len+1) 
 		{
 			/* buffer too small */
-			return (sse_size_t)-1;
+			return (ase_size_t)-1;
 		}
 
 		for (i = 0; i < prefix_len; i++) buf[i] = prefix[i];
-		buf[prefix_len] = SSE_T('0');
-		if (size > prefix_len+1) buf[prefix_len+1] = SSE_T('\0');
+		buf[prefix_len] = ASE_T('0');
+		if (size > prefix_len+1) buf[prefix_len+1] = ASE_T('\0');
 		return 1;
 	}
 
@@ -560,14 +560,14 @@ sse_size_t sse_awk_longtostr (
 	if (t < 0) { t = -t; len++; }
 	while (t > 0) { len++; t /= radix; }
 
-	if (buf == SSE_NULL)
+	if (buf == ASE_NULL)
 	{
 		/* if buf is not given, return the number of bytes required */
 		return len;
 	}
 
-	if (size < len) return (sse_size_t)-1; /* buffer too small */
-	if (size > len) buf[len] = SSE_T('\0');
+	if (size < len) return (ase_size_t)-1; /* buffer too small */
+	if (size > len) buf[len] = ASE_T('\0');
 	ret = len;
 
 	t = value;
@@ -577,9 +577,9 @@ sse_size_t sse_awk_longtostr (
 	{
 		rem = t % radix;
 		if (rem >= 10)
-			buf[--len] = (sse_char_t)rem + SSE_T('a') - 10;
+			buf[--len] = (ase_char_t)rem + ASE_T('a') - 10;
 		else
-			buf[--len] = (sse_char_t)rem + SSE_T('0');
+			buf[--len] = (ase_char_t)rem + ASE_T('0');
 		t /= radix;
 	}
 
@@ -590,7 +590,7 @@ sse_size_t sse_awk_longtostr (
 			buf[i] = prefix[i-1];
 			len--;
 		}
-		buf[--len] = SSE_T('-');
+		buf[--len] = ASE_T('-');
 	}
 	else
 	{
@@ -600,86 +600,86 @@ sse_size_t sse_awk_longtostr (
 	return ret;
 }
 
-sse_char_t* sse_awk_strdup (sse_awk_t* awk, const sse_char_t* str)
+ase_char_t* ase_awk_strdup (ase_awk_t* awk, const ase_char_t* str)
 {
-	sse_char_t* tmp;
+	ase_char_t* tmp;
 
-	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;
+	tmp = (ase_char_t*) ASE_AWK_MALLOC (
+		awk, (ase_awk_strlen(str) + 1) * ase_sizeof(ase_char_t));
+	if (tmp == ASE_NULL) return ASE_NULL;
 
-	sse_awk_strcpy (tmp, str);
+	ase_awk_strcpy (tmp, str);
 	return tmp;
 }
 
-sse_char_t* sse_awk_strxdup (sse_awk_t* awk, const sse_char_t* str, sse_size_t len)
+ase_char_t* ase_awk_strxdup (ase_awk_t* awk, const ase_char_t* str, ase_size_t len)
 {
-	sse_char_t* tmp;
+	ase_char_t* tmp;
 
-	tmp = (sse_char_t*) SSE_AWK_MALLOC (
-		awk, (len + 1) * sse_sizeof(sse_char_t));
-	if (tmp == SSE_NULL) return SSE_NULL;
+	tmp = (ase_char_t*) ASE_AWK_MALLOC (
+		awk, (len + 1) * ase_sizeof(ase_char_t));
+	if (tmp == ASE_NULL) return ASE_NULL;
 
-	sse_awk_strncpy (tmp, str, len);
+	ase_awk_strncpy (tmp, str, len);
 	return tmp;
 }
 
-sse_char_t* sse_awk_strxdup2 (
-	sse_awk_t* awk,
-	const sse_char_t* str1, sse_size_t len1,
-	const sse_char_t* str2, sse_size_t len2)
+ase_char_t* ase_awk_strxdup2 (
+	ase_awk_t* awk,
+	const ase_char_t* str1, ase_size_t len1,
+	const ase_char_t* str2, ase_size_t len2)
 {
-	sse_char_t* tmp;
+	ase_char_t* tmp;
 
-	tmp = (sse_char_t*) SSE_AWK_MALLOC (
-		awk, (len1 + len2 + 1) * sse_sizeof(sse_char_t));
-	if (tmp == SSE_NULL) return SSE_NULL;
+	tmp = (ase_char_t*) ASE_AWK_MALLOC (
+		awk, (len1 + len2 + 1) * ase_sizeof(ase_char_t));
+	if (tmp == ASE_NULL) return ASE_NULL;
 
-	sse_awk_strncpy (tmp, str1, len1);
-	sse_awk_strncpy (tmp + len1, str2, len2);
+	ase_awk_strncpy (tmp, str1, len1);
+	ase_awk_strncpy (tmp + len1, str2, len2);
 	return tmp;
 }
 
-sse_size_t sse_awk_strlen (const sse_char_t* str)
+ase_size_t ase_awk_strlen (const ase_char_t* str)
 {
-	const sse_char_t* p = str;
-	while (*p != SSE_T('\0')) p++;
+	const ase_char_t* p = str;
+	while (*p != ASE_T('\0')) p++;
 	return p - str;
 }
 
-sse_size_t sse_awk_strcpy (sse_char_t* buf, const sse_char_t* str)
+ase_size_t ase_awk_strcpy (ase_char_t* buf, const ase_char_t* str)
 {
-	sse_char_t* org = buf;
-	while ((*buf++ = *str++) != SSE_T('\0'));
+	ase_char_t* org = buf;
+	while ((*buf++ = *str++) != ASE_T('\0'));
 	return buf - org - 1;
 }
 
-sse_size_t sse_awk_strncpy (sse_char_t* buf, const sse_char_t* str, sse_size_t len)
+ase_size_t ase_awk_strncpy (ase_char_t* buf, const ase_char_t* str, ase_size_t len)
 {
-	const sse_char_t* end = str + len;
+	const ase_char_t* end = str + len;
 	while (str < end) *buf++ = *str++;
-	*buf = SSE_T('\0');
+	*buf = ASE_T('\0');
 	return len;
 }
 
-int sse_awk_strcmp (const sse_char_t* s1, const sse_char_t* s2)
+int ase_awk_strcmp (const ase_char_t* s1, const ase_char_t* s2)
 {
 	while (*s1 == *s2) 
 	{
-		if (*s1 == SSE_C('\0')) return 0;
+		if (*s1 == ASE_C('\0')) return 0;
 		s1++, s2++;
 	}
 
 	return (*s1 > *s2)? 1: -1;
 }
 
-int sse_awk_strxncmp (
-	const sse_char_t* s1, sse_size_t len1, 
-	const sse_char_t* s2, sse_size_t len2)
+int ase_awk_strxncmp (
+	const ase_char_t* s1, ase_size_t len1, 
+	const ase_char_t* s2, ase_size_t len2)
 {
-	sse_char_t c1, c2;
-	const sse_char_t* end1 = s1 + len1;
-	const sse_char_t* end2 = s2 + len2;
+	ase_char_t c1, c2;
+	const ase_char_t* end1 = s1 + len1;
+	const ase_char_t* end2 = s2 + len2;
 
 	while (s1 < end1)
 	{
@@ -697,21 +697,21 @@ int sse_awk_strxncmp (
 	return (s2 < end2)? -1: 0;
 }
 
-int sse_awk_strxncasecmp (
-	sse_awk_t* awk,
-	const sse_char_t* s1, sse_size_t len1, 
-	const sse_char_t* s2, sse_size_t len2)
+int ase_awk_strxncasecmp (
+	ase_awk_t* awk,
+	const ase_char_t* s1, ase_size_t len1, 
+	const ase_char_t* s2, ase_size_t len2)
 {
-	sse_char_t c1, c2;
-	const sse_char_t* end1 = s1 + len1;
-	const sse_char_t* end2 = s2 + len2;
+	ase_char_t c1, c2;
+	const ase_char_t* end1 = s1 + len1;
+	const ase_char_t* end2 = s2 + len2;
 
 	while (s1 < end1)
 	{
-		c1 = SSE_AWK_TOUPPER (awk, *s1); 
+		c1 = ASE_AWK_TOUPPER (awk, *s1); 
 		if (s2 < end2) 
 		{
-			c2 = SSE_AWK_TOUPPER (awk, *s2);
+			c2 = ASE_AWK_TOUPPER (awk, *s2);
 			if (c1 > c2) return 1;
 			if (c1 < c2) return -1;
 		}
@@ -722,24 +722,24 @@ int sse_awk_strxncasecmp (
 	return (s2 < end2)? -1: 0;
 }
 
-sse_char_t* sse_awk_strxnstr (
-	const sse_char_t* str, sse_size_t strsz, 
-	const sse_char_t* sub, sse_size_t subsz)
+ase_char_t* ase_awk_strxnstr (
+	const ase_char_t* str, ase_size_t strsz, 
+	const ase_char_t* sub, ase_size_t subsz)
 {
-	const sse_char_t* end, * subp;
+	const ase_char_t* end, * subp;
 
-	if (subsz == 0) return (sse_char_t*)str;
-	if (strsz < subsz) return SSE_NULL;
+	if (subsz == 0) return (ase_char_t*)str;
+	if (strsz < subsz) return ASE_NULL;
 	
 	end = str + strsz - subsz;
 	subp = sub + subsz;
 
 	while (str <= end) {
-		const sse_char_t* x = str;
-		const sse_char_t* y = sub;
+		const ase_char_t* x = str;
+		const ase_char_t* y = sub;
 
-		while (sse_true) {
-			if (y >= subp) return (sse_char_t*)str;
+		while (ase_true) {
+			if (y >= subp) return (ase_char_t*)str;
 			if (*x != *y) break;
 			x++; y++;
 		}	
@@ -747,47 +747,47 @@ sse_char_t* sse_awk_strxnstr (
 		str++;
 	}
 		
-	return SSE_NULL;
+	return ASE_NULL;
 }
 
-sse_char_t* sse_awk_strtok (
-	sse_awk_run_t* run, const sse_char_t* s, 
-	const sse_char_t* delim, sse_char_t** tok, sse_size_t* tok_len)
+ase_char_t* ase_awk_strtok (
+	ase_awk_run_t* run, const ase_char_t* s, 
+	const ase_char_t* delim, ase_char_t** tok, ase_size_t* tok_len)
 {
-	return sse_awk_strxntok (
-		run, s, sse_awk_strlen(s), 
-		delim, sse_awk_strlen(delim), tok, tok_len);
+	return ase_awk_strxntok (
+		run, s, ase_awk_strlen(s), 
+		delim, ase_awk_strlen(delim), tok, tok_len);
 }
 
-sse_char_t* sse_awk_strxtok (
-	sse_awk_run_t* run, const sse_char_t* s, sse_size_t len,
-	const sse_char_t* delim, sse_char_t** tok, sse_size_t* tok_len)
+ase_char_t* ase_awk_strxtok (
+	ase_awk_run_t* run, const ase_char_t* s, ase_size_t len,
+	const ase_char_t* delim, ase_char_t** tok, ase_size_t* tok_len)
 {
-	return sse_awk_strxntok (
+	return ase_awk_strxntok (
 		run, s, len, 
-		delim, sse_awk_strlen(delim), tok, tok_len);
+		delim, ase_awk_strlen(delim), tok, tok_len);
 }
 
-sse_char_t* sse_awk_strntok (
-	sse_awk_run_t* run, const sse_char_t* s, 
-	const sse_char_t* delim, sse_size_t delim_len,
-	sse_char_t** tok, sse_size_t* tok_len)
+ase_char_t* ase_awk_strntok (
+	ase_awk_run_t* run, const ase_char_t* s, 
+	const ase_char_t* delim, ase_size_t delim_len,
+	ase_char_t** tok, ase_size_t* tok_len)
 {
-	return sse_awk_strxntok (
-		run, s, sse_awk_strlen(s), 
+	return ase_awk_strxntok (
+		run, s, ase_awk_strlen(s), 
 		delim, delim_len, tok, tok_len);
 }
 
-sse_char_t* sse_awk_strxntok (
-	sse_awk_run_t* run, const sse_char_t* s, sse_size_t len,
-	const sse_char_t* delim, sse_size_t delim_len, 
-	sse_char_t** tok, sse_size_t* tok_len)
+ase_char_t* ase_awk_strxntok (
+	ase_awk_run_t* run, const ase_char_t* s, ase_size_t len,
+	const ase_char_t* delim, ase_size_t delim_len, 
+	ase_char_t** tok, ase_size_t* tok_len)
 {
-	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; 
+	const ase_char_t* p = s, *d;
+	const ase_char_t* end = s + len;	
+	const ase_char_t* sp = ASE_NULL, * ep = ASE_NULL;
+	const ase_char_t* delim_end = delim + delim_len;
+	ase_char_t c; 
 	int delim_mode;
 
 #define __DELIM_NULL      0
@@ -795,14 +795,14 @@ sse_char_t* sse_awk_strxntok (
 #define __DELIM_SPACES    2
 #define __DELIM_NOSPACES  3
 #define __DELIM_COMPOSITE 4
-	if (delim == SSE_NULL) delim_mode = __DELIM_NULL;
+	if (delim == ASE_NULL) delim_mode = __DELIM_NULL;
 	else 
 	{
 		delim_mode = __DELIM_EMPTY;
 
 		for (d = delim; d < delim_end; d++) 
 		{
-			if (SSE_AWK_ISSPACE(run->awk,*d)) 
+			if (ASE_AWK_ISSPACE(run->awk,*d)) 
 			{
 				if (delim_mode == __DELIM_EMPTY)
 					delim_mode = __DELIM_SPACES;
@@ -827,18 +827,18 @@ sse_char_t* sse_awk_strxntok (
 	
 	if (delim_mode == __DELIM_NULL) 
 	{ 
-		/* when SSE_NULL is given as "delim", it trims off the 
+		/* when ASE_NULL is given as "delim", it trims off the 
 		 * leading and trailing spaces characters off the source
 		 * string "s" eventually. */
 
-		while (p < end && SSE_AWK_ISSPACE(run->awk,*p)) p++;
+		while (p < end && ASE_AWK_ISSPACE(run->awk,*p)) p++;
 		while (p < end) 
 		{
 			c = *p;
 
-			if (!SSE_AWK_ISSPACE(run->awk,c)) 
+			if (!ASE_AWK_ISSPACE(run->awk,c)) 
 			{
-				if (sp == SSE_NULL) sp = p;
+				if (sp == ASE_NULL) sp = p;
 				ep = p;
 			}
 			p++;
@@ -859,15 +859,15 @@ sse_char_t* sse_awk_strxntok (
 		/* each token is delimited by space characters. all leading
 		 * and trailing spaces are removed. */
 
-		while (p < end && SSE_AWK_ISSPACE(run->awk,*p)) p++;
+		while (p < end && ASE_AWK_ISSPACE(run->awk,*p)) p++;
 		while (p < end) 
 		{
 			c = *p;
-			if (SSE_AWK_ISSPACE(run->awk,c)) break;
-			if (sp == SSE_NULL) sp = p;
+			if (ASE_AWK_ISSPACE(run->awk,c)) break;
+			if (sp == ASE_NULL) sp = p;
 			ep = p++;
 		}
-		while (p < end && SSE_AWK_ISSPACE(run->awk,*p)) p++;
+		while (p < end && ASE_AWK_ISSPACE(run->awk,*p)) p++;
 	}
 	else if (delim_mode == __DELIM_NOSPACES)
 	{
@@ -877,13 +877,13 @@ sse_char_t* sse_awk_strxntok (
 		{
 			while (p < end) 
 			{
-				c = SSE_AWK_TOUPPER(run->awk, *p);
+				c = ASE_AWK_TOUPPER(run->awk, *p);
 				for (d = delim; d < delim_end; d++) 
 				{
-					if (c == SSE_AWK_TOUPPER(run->awk,*d)) goto exit_loop;
+					if (c == ASE_AWK_TOUPPER(run->awk,*d)) goto exit_loop;
 				}
 
-				if (sp == SSE_NULL) sp = p;
+				if (sp == ASE_NULL) sp = p;
 				ep = p++;
 			}
 		}
@@ -897,7 +897,7 @@ sse_char_t* sse_awk_strxntok (
 					if (c == *d) goto exit_loop;
 				}
 
-				if (sp == SSE_NULL) sp = p;
+				if (sp == ASE_NULL) sp = p;
 				ep = p++;
 			}
 		}
@@ -907,22 +907,22 @@ sse_char_t* sse_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 && SSE_AWK_ISSPACE(run->awk,*p)) p++;
+		while (p < end && ASE_AWK_ISSPACE(run->awk,*p)) p++;
 		if (run->global.ignorecase)
 		{
 			while (p < end) 
 			{
-				c = SSE_AWK_TOUPPER(run->awk, *p);
-				if (SSE_AWK_ISSPACE(run->awk,c)) 
+				c = ASE_AWK_TOUPPER(run->awk, *p);
+				if (ASE_AWK_ISSPACE(run->awk,c)) 
 				{
 					p++;
 					continue;
 				}
 				for (d = delim; d < delim_end; d++) 
 				{
-					if (c == SSE_AWK_TOUPPER(run->awk,*d)) goto exit_loop;
+					if (c == ASE_AWK_TOUPPER(run->awk,*d)) goto exit_loop;
 				}
-				if (sp == SSE_NULL) sp = p;
+				if (sp == ASE_NULL) sp = p;
 				ep = p++;
 			}
 		}
@@ -931,7 +931,7 @@ sse_char_t* sse_awk_strxntok (
 			while (p < end) 
 			{
 				c = *p;
-				if (SSE_AWK_ISSPACE(run->awk,c)) 
+				if (ASE_AWK_ISSPACE(run->awk,c)) 
 				{
 					p++;
 					continue;
@@ -940,76 +940,76 @@ sse_char_t* sse_awk_strxntok (
 				{
 					if (c == *d) goto exit_loop;
 				}
-				if (sp == SSE_NULL) sp = p;
+				if (sp == ASE_NULL) sp = p;
 				ep = p++;
 			}
 		}
 	}
 
 exit_loop:
-	if (sp == SSE_NULL) 
+	if (sp == ASE_NULL) 
 	{
-		*tok = SSE_NULL;
-		*tok_len = (sse_size_t)0;
+		*tok = ASE_NULL;
+		*tok_len = (ase_size_t)0;
 	}
 	else 
 	{
-		*tok = (sse_char_t*)sp;
+		*tok = (ase_char_t*)sp;
 		*tok_len = ep - sp + 1;
 	}
 
-	/* if SSE_NULL is returned, this function should not be called anymore */
-	if (p >= end) return SSE_NULL;
+	/* if ASE_NULL is returned, this function should not be called anymore */
+	if (p >= end) return ASE_NULL;
 	if (delim_mode == __DELIM_EMPTY || 
-	    delim_mode == __DELIM_SPACES) return (sse_char_t*)p;
-	return (sse_char_t*)++p;
+	    delim_mode == __DELIM_SPACES) return (ase_char_t*)p;
+	return (ase_char_t*)++p;
 }
 
-sse_char_t* sse_awk_strxntokbyrex (
-	sse_awk_run_t* run, const sse_char_t* s, sse_size_t len,
-	void* rex, sse_char_t** tok, sse_size_t* tok_len, int* errnum)
+ase_char_t* ase_awk_strxntokbyrex (
+	ase_awk_run_t* run, const ase_char_t* s, ase_size_t len,
+	void* rex, ase_char_t** tok, ase_size_t* tok_len, int* errnum)
 {
 	int n;
-	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;
+	ase_char_t* match_ptr;
+	ase_size_t match_len, i;
+	ase_size_t left = len;
+	const ase_char_t* ptr = s;
+	const ase_char_t* str_ptr = s;
+	ase_size_t str_len = len;
 
 	while (len > 0)
 	{
-		n = sse_awk_matchrex (
+		n = ase_awk_matchrex (
 			run->awk, rex, 
-			((run->global.ignorecase)? SSE_AWK_REX_IGNORECASE: 0),
-			ptr, left, (const sse_char_t**)&match_ptr, &match_len, 
+			((run->global.ignorecase)? ASE_AWK_REX_IGNORECASE: 0),
+			ptr, left, (const ase_char_t**)&match_ptr, &match_len, 
 			errnum);
-		if (n == -1) return SSE_NULL;
+		if (n == -1) return ASE_NULL;
 		if (n == 0)
 		{
 			/* no match has been found. 
 			 * return the entire string as a token */
-			*tok = (sse_char_t*)str_ptr;
+			*tok = (ase_char_t*)str_ptr;
 			*tok_len = str_len;
-			*errnum = SSE_AWK_ENOERR;
-			return SSE_NULL; 
+			*errnum = ASE_AWK_ENOERR;
+			return ASE_NULL; 
 		}
 
-		sse_awk_assert (run->awk, n == 1);
+		ase_awk_assert (run->awk, n == 1);
 
 		if (match_len == 0)
 		{
 			ptr++;
 			left--;
 		}
-		else if (run->awk->option & SSE_AWK_STRIPSPACES)
+		else if (run->awk->option & ASE_AWK_STRIPSPACES)
 		{
 			/* match at the beginning of the input string */
 			if (match_ptr == s) 
 			{
 				for (i = 0; i < match_len; i++)
 				{
-					if (!SSE_AWK_ISSPACE(run->awk, match_ptr[i]))
+					if (!ASE_AWK_ISSPACE(run->awk, match_ptr[i]))
 						goto exit_loop;
 				}
 
@@ -1028,43 +1028,43 @@ sse_char_t* sse_awk_strxntokbyrex (
 exit_loop:
 	if (len == 0)
 	{
-		*tok = (sse_char_t*)str_ptr;
+		*tok = (ase_char_t*)str_ptr;
 		*tok_len = str_len;
-		*errnum = SSE_AWK_ENOERR;
-		return SSE_NULL; 
+		*errnum = ASE_AWK_ENOERR;
+		return ASE_NULL; 
 	}
 
-	*tok = (sse_char_t*)str_ptr;
+	*tok = (ase_char_t*)str_ptr;
 	*tok_len = match_ptr - str_ptr;
 
 	for (i = 0; i < match_len; i++)
 	{
-		if (!SSE_AWK_ISSPACE(run->awk, match_ptr[i]))
+		if (!ASE_AWK_ISSPACE(run->awk, match_ptr[i]))
 		{
-			*errnum = SSE_AWK_ENOERR;
+			*errnum = ASE_AWK_ENOERR;
 			return match_ptr+match_len;
 		}
 	}
 
-	*errnum = SSE_AWK_ENOERR;
+	*errnum = ASE_AWK_ENOERR;
 
-	if (run->awk->option & SSE_AWK_STRIPSPACES)
+	if (run->awk->option & ASE_AWK_STRIPSPACES)
 	{
 		return (match_ptr+match_len >= s+len)? 
-			SSE_NULL: (match_ptr+match_len);
+			ASE_NULL: (match_ptr+match_len);
 	}
 	else
 	{
 		return (match_ptr+match_len > s+len)? 
-			SSE_NULL: (match_ptr+match_len);
+			ASE_NULL: (match_ptr+match_len);
 	}
 }
 
-int sse_awk_abort (sse_awk_t* awk, 
-	const sse_char_t* expr, const sse_char_t* file, int line)
+int ase_awk_abort (ase_awk_t* awk, 
+	const ase_char_t* expr, const ase_char_t* file, int line)
 {
 	awk->syscas.dprintf (
-		SSE_T("ASSERTION FAILURE AT FILE %s, LINE %d\n%s\n"),
+		ASE_T("ASSERTION FAILURE AT FILE %s, LINE %d\n%s\n"),
 		file, line, expr);
 	awk->syscas.abort ();
 	return 0;
diff --git a/ase/awk/misc.h b/ase/awk/misc.h
index f34ac186..4e5d03cc 100644
--- a/ase/awk/misc.h
+++ b/ase/awk/misc.h
@@ -1,45 +1,45 @@
 /*
- * $Id: misc.h,v 1.6 2006-10-23 14:44:43 bacon Exp $
+ * $Id: misc.h,v 1.7 2006-10-24 04:10:12 bacon Exp $
  */
 
-#ifndef _SSE_AWK_MISC_H_
-#define _SSE_AWK_MISC_H_
+#ifndef _ASE_AWK_MISC_H_
+#define _ASE_AWK_MISC_H_
 
-#ifndef _SSE_AWK_AWK_H_
-#error Never include this file directly. Include <sse/awk/awk.h> instead
+#ifndef _ASE_AWK_AWK_H_
+#error Never include this file directly. Include <ase/awk/awk.h> instead
 #endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-void* sse_awk_memcpy (void* dst, const void* src, sse_size_t n);
-void* sse_awk_memset (void* dst, int val, sse_size_t n);
+void* ase_awk_memcpy (void* dst, const void* src, ase_size_t n);
+void* ase_awk_memset (void* dst, int val, ase_size_t n);
 
-sse_char_t* sse_awk_strtok (
-	sse_awk_run_t* run, const sse_char_t* s, 
-	const sse_char_t* delim, sse_char_t** tok, sse_size_t* tok_len);
+ase_char_t* ase_awk_strtok (
+	ase_awk_run_t* run, const ase_char_t* s, 
+	const ase_char_t* delim, ase_char_t** tok, ase_size_t* tok_len);
 
-sse_char_t* sse_awk_strxtok (
-	sse_awk_run_t* run, const sse_char_t* s, sse_size_t len,
-	const sse_char_t* delim, sse_char_t** tok, sse_size_t* tok_len);
+ase_char_t* ase_awk_strxtok (
+	ase_awk_run_t* run, const ase_char_t* s, ase_size_t len,
+	const ase_char_t* delim, ase_char_t** tok, ase_size_t* tok_len);
 
-sse_char_t* sse_awk_strntok (
-	sse_awk_run_t* run, const sse_char_t* s, 
-	const sse_char_t* delim, sse_size_t delim_len,
-	sse_char_t** tok, sse_size_t* tok_len);
+ase_char_t* ase_awk_strntok (
+	ase_awk_run_t* run, const ase_char_t* s, 
+	const ase_char_t* delim, ase_size_t delim_len,
+	ase_char_t** tok, ase_size_t* tok_len);
 
-sse_char_t* sse_awk_strxntok (
-	sse_awk_run_t* run, const sse_char_t* s, sse_size_t len,
-	const sse_char_t* delim, sse_size_t delim_len,
-	sse_char_t** tok, sse_size_t* tok_len);
+ase_char_t* ase_awk_strxntok (
+	ase_awk_run_t* run, const ase_char_t* s, ase_size_t len,
+	const ase_char_t* delim, ase_size_t delim_len,
+	ase_char_t** tok, ase_size_t* tok_len);
 
-sse_char_t* sse_awk_strxntokbyrex (
-	sse_awk_run_t* run, const sse_char_t* s, sse_size_t len,
-	void* rex, sse_char_t** tok, sse_size_t* tok_len, int* errnum);
+ase_char_t* ase_awk_strxntokbyrex (
+	ase_awk_run_t* run, const ase_char_t* s, ase_size_t len,
+	void* rex, ase_char_t** tok, ase_size_t* tok_len, int* errnum);
 
-int sse_awk_abort (sse_awk_t* awk, 
-	const sse_char_t* expr, const sse_char_t* file, int line);
+int ase_awk_abort (ase_awk_t* awk, 
+	const ase_char_t* expr, const ase_char_t* file, int line);
 
 #ifdef __cplusplus
 }
diff --git a/ase/awk/parse.c b/ase/awk/parse.c
index 6e8c87b4..7a7804b7 100644
--- a/ase/awk/parse.c
+++ b/ase/awk/parse.c
@@ -1,8 +1,8 @@
 /*
- * $Id: parse.c,v 1.193 2006-10-22 12:39:29 bacon Exp $
+ * $Id: parse.c,v 1.194 2006-10-24 04:10:12 bacon Exp $
  */
 
-#include <sse/awk/awk_i.h>
+#include <ase/awk/awk_i.h>
 
 enum
 {
@@ -120,94 +120,94 @@ struct __binmap_t
 	int binop;
 };
 
-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 ase_awk_t* __parse_progunit (ase_awk_t* awk);
+static ase_awk_t* __collect_globals (ase_awk_t* awk);
+static ase_awk_t* __add_builtin_globals (ase_awk_t* awk);
+static ase_awk_t* __add_global (
+	ase_awk_t* awk, const ase_char_t* name, ase_size_t name_len);
+static ase_awk_t* __collect_locals (ase_awk_t* awk, ase_size_t nlocals);
 
-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 ase_awk_nde_t* __parse_function (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_begin (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_end (ase_awk_t* awk);
+static ase_awk_chain_t* __parse_pattern_block (
+	ase_awk_t* awk, ase_awk_nde_t* ptn, ase_bool_t blockless);
 
-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_expression (sse_awk_t* awk);
+static ase_awk_nde_t* __parse_block (ase_awk_t* awk, ase_bool_t is_top);
+static ase_awk_nde_t* __parse_statement (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_statement_nb (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_expression (ase_awk_t* awk);
 
-static sse_awk_nde_t* __parse_basic_expr (sse_awk_t* awk);
+static ase_awk_nde_t* __parse_basic_expr (ase_awk_t* awk);
 
-static sse_awk_nde_t* __parse_binary_expr (
-	sse_awk_t* awk, const __binmap_t* binmap,
-	sse_awk_nde_t*(*next_level_func)(sse_awk_t*));
+static ase_awk_nde_t* __parse_binary_expr (
+	ase_awk_t* awk, const __binmap_t* binmap,
+	ase_awk_nde_t*(*next_level_func)(ase_awk_t*));
 
-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 ase_awk_nde_t* __parse_logical_or (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_logical_and (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_in (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_regex_match (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_bitwise_or (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_bitwise_or_with_extio (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_bitwise_xor (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_bitwise_and (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_equality (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_relational (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_shift (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_concat (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_additive (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_multiplicative (ase_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 ase_awk_nde_t* __parse_unary (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_increment (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_primary (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_primary_ident (ase_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 ase_awk_nde_t* __parse_hashidx (
+	ase_awk_t* awk, ase_char_t* name, ase_size_t name_len);
+static ase_awk_nde_t* __parse_fncall (
+	ase_awk_t* awk, ase_char_t* name, ase_size_t name_len, ase_awk_bfn_t* bfn);
+static ase_awk_nde_t* __parse_if (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_while (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_for (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_dowhile (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_break (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_continue (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_return (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_exit (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_next (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_nextfile (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_delete (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_print (ase_awk_t* awk);
+static ase_awk_nde_t* __parse_printf (ase_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_token (ase_awk_t* awk);
+static int __get_number (ase_awk_t* awk);
+static int __get_charstr (ase_awk_t* awk);
+static int __get_rexstr (ase_awk_t* awk);
 static int __get_string (
-	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);
+	ase_awk_t* awk, ase_char_t end_char,
+	ase_char_t esc_char, ase_bool_t keep_esc_char);
+static int __get_char (ase_awk_t* awk);
+static int __unget_char (ase_awk_t* awk, ase_cint_t c);
+static int __skip_spaces (ase_awk_t* awk);
+static int __skip_comment (ase_awk_t* awk);
 static int __classify_ident (
-	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);
+	ase_awk_t* awk, const ase_char_t* name, ase_size_t len);
+static int __assign_to_opcode (ase_awk_t* awk);
+static int __is_plain_var (ase_awk_nde_t* nde);
+static int __is_var (ase_awk_nde_t* nde);
 
-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);
+static int __deparse (ase_awk_t* awk);
+static int __deparse_func (ase_awk_pair_t* pair, void* arg);
+static int __put_char (ase_awk_t* awk, ase_char_t c);
+static int __flush (ase_awk_t* awk);
 
 struct __kwent 
 { 
-	const sse_char_t* name; 
-	sse_size_t name_len;
+	const ase_char_t* name; 
+	ase_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 */
-	{ SSE_T("in"),       2, TOKEN_IN,       0 },
+	{ ASE_T("in"),       2, TOKEN_IN,       0 },
 
 	/* top-level block starters */
-	{ 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 },
+	{ ASE_T("BEGIN"),    5, TOKEN_BEGIN,    0 },
+	{ ASE_T("END"),      3, TOKEN_END,      0 },
+	{ ASE_T("function"), 8, TOKEN_FUNCTION, 0 },
+	{ ASE_T("func"),     4, TOKEN_FUNCTION, 0 },
 
 	/* keywords for variable declaration */
-	{ SSE_T("local"),    5, TOKEN_LOCAL,    SSE_AWK_EXPLICIT },
-	{ SSE_T("global"),   6, TOKEN_GLOBAL,   SSE_AWK_EXPLICIT },
+	{ ASE_T("local"),    5, TOKEN_LOCAL,    ASE_AWK_EXPLICIT },
+	{ ASE_T("global"),   6, TOKEN_GLOBAL,   ASE_AWK_EXPLICIT },
 
 	/* keywords that start statements excluding expression 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 },
+	{ ASE_T("if"),       2, TOKEN_IF,       0 },
+	{ ASE_T("else"),     4, TOKEN_ELSE,     0 },
+	{ ASE_T("while"),    5, TOKEN_WHILE,    0 },
+	{ ASE_T("for"),      3, TOKEN_FOR,      0 },
+	{ ASE_T("do"),       2, TOKEN_DO,       0 },
+	{ ASE_T("break"),    5, TOKEN_BREAK,    0 },
+	{ ASE_T("continue"), 8, TOKEN_CONTINUE, 0 },
+	{ ASE_T("return"),   6, TOKEN_RETURN,   0 },
+	{ ASE_T("exit"),     4, TOKEN_EXIT,     0 },
+	{ ASE_T("next"),     4, TOKEN_NEXT,     0 },
+	{ ASE_T("nextfile"), 8, TOKEN_NEXTFILE, 0 },
+	{ ASE_T("delete"),   6, TOKEN_DELETE,   0 },
+	{ ASE_T("print"),    5, TOKEN_PRINT,    ASE_AWK_EXTIO },
+	{ ASE_T("printf"),   6, TOKEN_PRINTF,   ASE_AWK_EXTIO },
 
 	/* keywords that can start an expression */
-	{ SSE_T("getline"),  7, TOKEN_GETLINE,  SSE_AWK_EXTIO },
+	{ ASE_T("getline"),  7, TOKEN_GETLINE,  ASE_AWK_EXTIO },
 
-	{ SSE_NULL,          0,              0 }
+	{ ASE_NULL,          0,              0 }
 };
 
 struct __bvent
 {
-	const sse_char_t* name;
-	sse_size_t name_len;
+	const ase_char_t* name;
+	ase_size_t name_len;
 	int valid;
 };
 
 static struct __bvent __bvtab[] =
 {
-	{ 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 }
+	{ ASE_T("ARGC"),         4, 0 },
+	{ ASE_T("ARGV"),         4, 0 },
+	{ ASE_T("CONVFMT"),      7, 0 },
+	{ ASE_T("ENVIRON"),      7, 0 },
+	{ ASE_T("ERRNO"),        5, 0 },
+	{ ASE_T("FILENAME"),     8, 0 },
+	{ ASE_T("FNR"),          3, 0 },
+	{ ASE_T("FS"),           2, 0 },
+	{ ASE_T("IGNORECASE"),  10, 0 },
+	{ ASE_T("NF"),           2, 0 },
+	{ ASE_T("NR"),           2, 0 },
+	{ ASE_T("OFMT"),         4, 0 },
+	{ ASE_T("OFS"),          3, 0 },
+	{ ASE_T("ORS"),          3, 0 },
+	{ ASE_T("RS"),           2, 0 },
+	{ ASE_T("RT"),           2, 0 },
+	{ ASE_T("RSTART"),       6, 0 },
+	{ ASE_T("RLENGTH"),      7, 0 },
+	{ ASE_T("SUBSEP"),       6, 0 },
+	{ ASE_NULL,              0, 0 }
 };
 
 #define GET_CHAR(awk) \
@@ -297,43 +297,43 @@ static struct __bvent __bvtab[] =
 
 #define ADD_TOKEN_CHAR(awk,c) \
 	do { \
-		if (sse_awk_str_ccat(&(awk)->token.name,(c)) == (sse_size_t)-1) { \
-			(awk)->errnum = SSE_AWK_ENOMEM; return -1; \
+		if (ase_awk_str_ccat(&(awk)->token.name,(c)) == (ase_size_t)-1) { \
+			(awk)->errnum = ASE_AWK_ENOMEM; return -1; \
 		} \
 	} while (0)
 
 #define ADD_TOKEN_STR(awk,str) \
 	do { \
-		if (sse_awk_str_cat(&(awk)->token.name,(str)) == (sse_size_t)-1) { \
-			(awk)->errnum = SSE_AWK_ENOMEM; return -1; \
+		if (ase_awk_str_cat(&(awk)->token.name,(str)) == (ase_size_t)-1) { \
+			(awk)->errnum = ASE_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 SSE_NULL; } while (0)
+	do { (awk)->errnum = (code); return ASE_NULL; } while (0)
 
-int sse_awk_parse (sse_awk_t* awk, sse_awk_srcios_t* srcios)
+int ase_awk_parse (ase_awk_t* awk, ase_awk_srcios_t* srcios)
 {
 	int n = 0, op;
 
-	sse_awk_assert (awk, srcios != SSE_NULL && srcios->in != SSE_NULL);
+	ase_awk_assert (awk, srcios != ASE_NULL && srcios->in != ASE_NULL);
 
-	sse_awk_clear (awk);
+	ase_awk_clear (awk);
 	awk->src.ios = srcios;
 
 	op = awk->src.ios->in (
-		SSE_AWK_IO_OPEN, awk->src.ios->custom_data, SSE_NULL, 0);
+		ASE_AWK_IO_OPEN, awk->src.ios->custom_data, ASE_NULL, 0);
 	if (op == -1)
 	{
 		/* cannot open the source file.
 		 * it doesn't even have to call CLOSE */
-		awk->errnum = SSE_AWK_ESRCINOPEN;
+		awk->errnum = ASE_AWK_ESRCINOPEN;
 		return -1;
 	}
 
-	if (__add_builtin_globals (awk) == SSE_NULL) 
+	if (__add_builtin_globals (awk) == ASE_NULL) 
 	{
 		n = -1;
 		goto exit_parse;
@@ -364,7 +364,7 @@ int sse_awk_parse (sse_awk_t* awk, sse_awk_srcios_t* srcios)
 			if (MATCH(awk,TOKEN_EOF)) break;
 			if (MATCH(awk,TOKEN_NEWLINE)) continue;
 
-			if (__parse_progunit (awk) == SSE_NULL) 
+			if (__parse_progunit (awk) == ASE_NULL) 
 			{
 				n = -1;
 				goto exit_parse;
@@ -372,9 +372,9 @@ int sse_awk_parse (sse_awk_t* awk, sse_awk_srcios_t* srcios)
 		}
 	}
 
-	awk->tree.nglobals = sse_awk_tab_getsize(&awk->parse.globals);
+	awk->tree.nglobals = ase_awk_tab_getsize(&awk->parse.globals);
 
-	if (awk->src.ios->out != SSE_NULL) 
+	if (awk->src.ios->out != ASE_NULL) 
 	{
 		if (__deparse (awk) == -1) 
 		{
@@ -385,94 +385,94 @@ int sse_awk_parse (sse_awk_t* awk, sse_awk_srcios_t* srcios)
 
 exit_parse:
 	if (awk->src.ios->in (
-		SSE_AWK_IO_CLOSE, awk->src.ios->custom_data, SSE_NULL, 0) == -1)
+		ASE_AWK_IO_CLOSE, awk->src.ios->custom_data, ASE_NULL, 0) == -1)
 	{
 		if (n != -1)
 		{
 			/* this is to keep the earlier error above
 			 * that might be more critical than this */
-			awk->errnum = SSE_AWK_ESRCINCLOSE;
+			awk->errnum = ASE_AWK_ESRCINCLOSE;
 			n = -1;
 		}
 	}
 
-	if (n == -1) sse_awk_clear (awk);
+	if (n == -1) ase_awk_clear (awk);
 	return n;
 }
 
-static sse_awk_t* __parse_progunit (sse_awk_t* awk)
+static ase_awk_t* __parse_progunit (ase_awk_t* awk)
 {
 	/*
 	pattern { action }
 	function name (parameter-list) { statement }
 	*/
 
-	sse_awk_assert (awk, awk->parse.depth.loop == 0);
+	ase_awk_assert (awk, awk->parse.depth.loop == 0);
 
-	if ((awk->option & SSE_AWK_EXPLICIT) && MATCH(awk,TOKEN_GLOBAL)) 
+	if ((awk->option & ASE_AWK_EXPLICIT) && MATCH(awk,TOKEN_GLOBAL)) 
 	{
-		sse_size_t nglobals;
+		ase_size_t nglobals;
 
 		awk->parse.id.block = PARSE_GLOBAL;
 
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 
-		nglobals = sse_awk_tab_getsize(&awk->parse.globals);
-		if (__collect_globals (awk) == SSE_NULL) 
+		nglobals = ase_awk_tab_getsize(&awk->parse.globals);
+		if (__collect_globals (awk) == ASE_NULL) 
 		{
-			sse_awk_tab_remove (
+			ase_awk_tab_remove (
 				&awk->parse.globals, nglobals, 
-				sse_awk_tab_getsize(&awk->parse.globals) - nglobals);
-			return SSE_NULL;
+				ase_awk_tab_getsize(&awk->parse.globals) - nglobals);
+			return ASE_NULL;
 		}
 	}
 	else if (MATCH(awk,TOKEN_FUNCTION)) 
 	{
 		awk->parse.id.block = PARSE_FUNCTION;
-		if (__parse_function (awk) == SSE_NULL) return SSE_NULL;
+		if (__parse_function (awk) == ASE_NULL) return ASE_NULL;
 	}
 	else if (MATCH(awk,TOKEN_BEGIN)) 
 	{
 		awk->parse.id.block = PARSE_BEGIN;
-		if (__get_token(awk) == -1) return SSE_NULL; 
+		if (__get_token(awk) == -1) return ASE_NULL; 
 
-		if ((awk->option & SSE_AWK_BLOCKLESS) &&
+		if ((awk->option & ASE_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, SSE_AWK_EBEGINBLOCK);
+			PANIC (awk, ASE_AWK_EBEGINBLOCK);
 		}
 
-		if (!MATCH(awk,TOKEN_LBRACE)) PANIC (awk, SSE_AWK_ELBRACE);
+		if (!MATCH(awk,TOKEN_LBRACE)) PANIC (awk, ASE_AWK_ELBRACE);
 
 		awk->parse.id.block = PARSE_BEGIN_BLOCK;
-		if (__parse_begin (awk) == SSE_NULL) return SSE_NULL;
+		if (__parse_begin (awk) == ASE_NULL) return ASE_NULL;
 	}
 	else if (MATCH(awk,TOKEN_END)) 
 	{
 		awk->parse.id.block = PARSE_END;
-		if (__get_token(awk) == -1) return SSE_NULL; 
+		if (__get_token(awk) == -1) return ASE_NULL; 
 
-		if ((awk->option & SSE_AWK_BLOCKLESS) &&
+		if ((awk->option & ASE_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, SSE_AWK_EENDBLOCK);
+			PANIC (awk, ASE_AWK_EENDBLOCK);
 		}
 
-		if (!MATCH(awk,TOKEN_LBRACE)) PANIC (awk, SSE_AWK_ELBRACE);
+		if (!MATCH(awk,TOKEN_LBRACE)) PANIC (awk, ASE_AWK_ELBRACE);
 
 		awk->parse.id.block = PARSE_END_BLOCK;
-		if (__parse_end (awk) == SSE_NULL) return SSE_NULL;
+		if (__parse_end (awk) == ASE_NULL) return ASE_NULL;
 	}
 	else if (MATCH(awk,TOKEN_LBRACE))
 	{
 		/* patternless block */
 		awk->parse.id.block = PARSE_ACTION_BLOCK;
 		if (__parse_pattern_block (
-			awk, SSE_NULL, sse_false) == SSE_NULL) return SSE_NULL;
+			awk, ASE_NULL, ase_false) == ASE_NULL) return ASE_NULL;
 	}
 	else
 	{
@@ -485,51 +485,51 @@ static sse_awk_t* __parse_progunit (sse_awk_t* awk)
 		(pattern)
 		pattern, pattern
 		*/
-		sse_awk_nde_t* ptn;
+		ase_awk_nde_t* ptn;
 
 		awk->parse.id.block = PARSE_PATTERN;
 
 		ptn = __parse_expression (awk);
-		if (ptn == SSE_NULL) return SSE_NULL;
+		if (ptn == ASE_NULL) return ASE_NULL;
 
-		sse_awk_assert (awk, ptn->next == SSE_NULL);
+		ase_awk_assert (awk, ptn->next == ASE_NULL);
 
 		if (MATCH(awk,TOKEN_COMMA))
 		{
 			if (__get_token (awk) == -1) 
 			{
-				sse_awk_clrpt (awk, ptn);
-				return SSE_NULL;
+				ase_awk_clrpt (awk, ptn);
+				return ASE_NULL;
 			}	
 
 			ptn->next = __parse_expression (awk);
-			if (ptn->next == SSE_NULL) 
+			if (ptn->next == ASE_NULL) 
 			{
-				sse_awk_clrpt (awk, ptn);
-				return SSE_NULL;
+				ase_awk_clrpt (awk, ptn);
+				return ASE_NULL;
 			}
 		}
 
-		if ((awk->option & SSE_AWK_BLOCKLESS) &&
+		if ((awk->option & ASE_AWK_BLOCKLESS) &&
 		    (MATCH(awk,TOKEN_NEWLINE) || MATCH(awk,TOKEN_EOF)))
 		{
 			/* blockless pattern */
-			sse_bool_t newline = MATCH(awk,TOKEN_NEWLINE);
+			ase_bool_t newline = MATCH(awk,TOKEN_NEWLINE);
 
 			awk->parse.id.block = PARSE_ACTION_BLOCK;
 			if (__parse_pattern_block (
-				awk, ptn, sse_true) == SSE_NULL) 
+				awk, ptn, ase_true) == ASE_NULL) 
 			{
-				sse_awk_clrpt (awk, ptn);
-				return SSE_NULL;	
+				ase_awk_clrpt (awk, ptn);
+				return ASE_NULL;	
 			}
 
 			if (newline)
 			{
 				if (__get_token (awk) == -1) 
 				{
-					sse_awk_clrpt (awk, ptn);
-					return SSE_NULL;
+					ase_awk_clrpt (awk, ptn);
+					return ASE_NULL;
 				}	
 			}
 		}
@@ -538,16 +538,16 @@ static sse_awk_t* __parse_progunit (sse_awk_t* awk)
 			/* parse the action block */
 			if (!MATCH(awk,TOKEN_LBRACE))
 			{
-				sse_awk_clrpt (awk, ptn);
-				PANIC (awk, SSE_AWK_ELBRACE);
+				ase_awk_clrpt (awk, ptn);
+				PANIC (awk, ASE_AWK_ELBRACE);
 			}
 
 			awk->parse.id.block = PARSE_ACTION_BLOCK;
 			if (__parse_pattern_block (
-				awk, ptn, sse_false) == SSE_NULL) 
+				awk, ptn, ase_false) == ASE_NULL) 
 			{
-				sse_awk_clrpt (awk, ptn);
-				return SSE_NULL;	
+				ase_awk_clrpt (awk, ptn);
+				return ASE_NULL;	
 			}
 		}
 	}
@@ -555,74 +555,74 @@ static sse_awk_t* __parse_progunit (sse_awk_t* awk)
 	return awk;
 }
 
-static sse_awk_nde_t* __parse_function (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_function (ase_awk_t* awk)
 {
-	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;
+	ase_char_t* name;
+	ase_char_t* name_dup;
+	ase_size_t name_len;
+	ase_awk_nde_t* body;
+	ase_awk_afn_t* afn;
+	ase_size_t nargs;
+	ase_awk_pair_t* pair;
 	int n;
 
 	/* eat up the keyword 'function' and get the next token */
-	sse_awk_assert (awk, MATCH(awk,TOKEN_FUNCTION));
-	if (__get_token(awk) == -1) return SSE_NULL;  
+	ase_awk_assert (awk, MATCH(awk,TOKEN_FUNCTION));
+	if (__get_token(awk) == -1) return ASE_NULL;  
 
 	/* match a function name */
 	if (!MATCH(awk,TOKEN_IDENT)) 
 	{
 		/* cannot find a valid identifier for a function name */
-		PANIC (awk, SSE_AWK_EIDENT);
+		PANIC (awk, ASE_AWK_EIDENT);
 	}
 
-	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) 
+	name = ASE_AWK_STR_BUF(&awk->token.name);
+	name_len = ASE_AWK_STR_LEN(&awk->token.name);
+	if (ase_awk_map_get(&awk->tree.afns, name, name_len) != ASE_NULL) 
 	{
 		/* the function is defined previously */
-		PANIC (awk, SSE_AWK_EDUPFUNC);
+		PANIC (awk, ASE_AWK_EDUPFUNC);
 	}
 
-	if (awk->option & SSE_AWK_UNIQUE) 
+	if (awk->option & ASE_AWK_UNIQUE) 
 	{
 		/* check if it coincides to be a global variable name */
-		if (sse_awk_tab_find (
-			&awk->parse.globals, 0, name, name_len) != (sse_size_t)-1) 
+		if (ase_awk_tab_find (
+			&awk->parse.globals, 0, name, name_len) != (ase_size_t)-1) 
 		{
-			PANIC (awk, SSE_AWK_EDUPNAME);
+			PANIC (awk, ASE_AWK_EDUPNAME);
 		}
 	}
 
 	/* clone the function name before it is overwritten */
-	name_dup = sse_awk_strxdup (awk, name, name_len);
-	if (name_dup == SSE_NULL) PANIC (awk, SSE_AWK_ENOMEM);
+	name_dup = ase_awk_strxdup (awk, name, name_len);
+	if (name_dup == ASE_NULL) PANIC (awk, ASE_AWK_ENOMEM);
 
 	/* get the next token */
 	if (__get_token(awk) == -1) 
 	{
-		SSE_AWK_FREE (awk, name_dup);
-		return SSE_NULL;  
+		ASE_AWK_FREE (awk, name_dup);
+		return ASE_NULL;  
 	}
 
 	/* match a left parenthesis */
 	if (!MATCH(awk,TOKEN_LPAREN)) 
 	{
 		/* a function name is not followed by a left parenthesis */
-		SSE_AWK_FREE (awk, name_dup);
-		PANIC (awk, SSE_AWK_ELPAREN);
+		ASE_AWK_FREE (awk, name_dup);
+		PANIC (awk, ASE_AWK_ELPAREN);
 	}	
 
 	/* get the next token */
 	if (__get_token(awk) == -1) 
 	{
-		SSE_AWK_FREE (awk, name_dup);
-		return SSE_NULL;
+		ASE_AWK_FREE (awk, name_dup);
+		return ASE_NULL;
 	}
 
 	/* make sure that parameter table is empty */
-	sse_awk_assert (awk, sse_awk_tab_getsize(&awk->parse.params) == 0);
+	ase_awk_assert (awk, ase_awk_tab_getsize(&awk->parse.params) == 0);
 
 	/* read parameter list */
 	if (MATCH(awk,TOKEN_RPAREN)) 
@@ -630,36 +630,36 @@ static sse_awk_nde_t* __parse_function (sse_awk_t* awk)
 		/* no function parameter found. get the next token */
 		if (__get_token(awk) == -1) 
 		{
-			SSE_AWK_FREE (awk, name_dup);
-			return SSE_NULL;
+			ASE_AWK_FREE (awk, name_dup);
+			return ASE_NULL;
 		}
 	}
 	else 
 	{
 		while (1) 
 		{
-			sse_char_t* param;
-			sse_size_t param_len;
+			ase_char_t* param;
+			ase_size_t param_len;
 
 			if (!MATCH(awk,TOKEN_IDENT)) 
 			{
-				SSE_AWK_FREE (awk, name_dup);
-				sse_awk_tab_clear (&awk->parse.params);
-				PANIC (awk, SSE_AWK_EIDENT);
+				ASE_AWK_FREE (awk, name_dup);
+				ase_awk_tab_clear (&awk->parse.params);
+				PANIC (awk, ASE_AWK_EIDENT);
 			}
 
-			param = SSE_AWK_STR_BUF(&awk->token.name);
-			param_len = SSE_AWK_STR_LEN(&awk->token.name);
+			param = ASE_AWK_STR_BUF(&awk->token.name);
+			param_len = ASE_AWK_STR_LEN(&awk->token.name);
 
-			if (awk->option & SSE_AWK_UNIQUE) 
+			if (awk->option & ASE_AWK_UNIQUE) 
 			{
 				/* check if a parameter conflicts with a function */
-				if (sse_awk_strxncmp (name_dup, name_len, param, param_len) == 0 ||
-				    sse_awk_map_get (&awk->tree.afns, param, param_len) != SSE_NULL) 
+				if (ase_awk_strxncmp (name_dup, name_len, param, param_len) == 0 ||
+				    ase_awk_map_get (&awk->tree.afns, param, param_len) != ASE_NULL) 
 				{
-					SSE_AWK_FREE (awk, name_dup);
-					sse_awk_tab_clear (&awk->parse.params);
-					PANIC (awk, SSE_AWK_EDUPNAME);
+					ASE_AWK_FREE (awk, name_dup);
+					ase_awk_tab_clear (&awk->parse.params);
+					PANIC (awk, ASE_AWK_EDUPNAME);
 				}
 
 				/* NOTE: the following is not a conflict
@@ -670,181 +670,181 @@ static sse_awk_nde_t* __parse_function (sse_awk_t* awk)
 			}
 
 			/* check if a parameter conflicts with other parameters */
-			if (sse_awk_tab_find (
+			if (ase_awk_tab_find (
 				&awk->parse.params, 
-				0, param, param_len) != (sse_size_t)-1) 
+				0, param, param_len) != (ase_size_t)-1) 
 			{
-				SSE_AWK_FREE (awk, name_dup);
-				sse_awk_tab_clear (&awk->parse.params);
-				PANIC (awk, SSE_AWK_EDUPPARAM);
+				ASE_AWK_FREE (awk, name_dup);
+				ase_awk_tab_clear (&awk->parse.params);
+				PANIC (awk, ASE_AWK_EDUPPARAM);
 			}
 
 			/* push the parameter to the parameter list */
-			if (sse_awk_tab_getsize (
-				&awk->parse.params) >= SSE_AWK_MAX_PARAMS)
+			if (ase_awk_tab_getsize (
+				&awk->parse.params) >= ASE_AWK_MAX_PARAMS)
 			{
-				SSE_AWK_FREE (awk, name_dup);
-				sse_awk_tab_clear (&awk->parse.params);
-				PANIC (awk, SSE_AWK_ETOOMANYPARAMS);
+				ASE_AWK_FREE (awk, name_dup);
+				ase_awk_tab_clear (&awk->parse.params);
+				PANIC (awk, ASE_AWK_ETOOMANYPARAMS);
 			}
 
-			if (sse_awk_tab_add (
+			if (ase_awk_tab_add (
 				&awk->parse.params, 
-				param, param_len) == (sse_size_t)-1) 
+				param, param_len) == (ase_size_t)-1) 
 			{
-				SSE_AWK_FREE (awk, name_dup);
-				sse_awk_tab_clear (&awk->parse.params);
-				PANIC (awk, SSE_AWK_ENOMEM);
+				ASE_AWK_FREE (awk, name_dup);
+				ase_awk_tab_clear (&awk->parse.params);
+				PANIC (awk, ASE_AWK_ENOMEM);
 			}	
 
 			if (__get_token (awk) == -1) 
 			{
-				SSE_AWK_FREE (awk, name_dup);
-				sse_awk_tab_clear (&awk->parse.params);
-				return SSE_NULL;
+				ASE_AWK_FREE (awk, name_dup);
+				ase_awk_tab_clear (&awk->parse.params);
+				return ASE_NULL;
 			}	
 
 			if (MATCH(awk,TOKEN_RPAREN)) break;
 
 			if (!MATCH(awk,TOKEN_COMMA)) 
 			{
-				SSE_AWK_FREE (awk, name_dup);
-				sse_awk_tab_clear (&awk->parse.params);
-				PANIC (awk, SSE_AWK_ECOMMA);
+				ASE_AWK_FREE (awk, name_dup);
+				ase_awk_tab_clear (&awk->parse.params);
+				PANIC (awk, ASE_AWK_ECOMMA);
 			}
 
 			if (__get_token(awk) == -1) 
 			{
-				SSE_AWK_FREE (awk, name_dup);
-				sse_awk_tab_clear (&awk->parse.params);
-				return SSE_NULL;
+				ASE_AWK_FREE (awk, name_dup);
+				ase_awk_tab_clear (&awk->parse.params);
+				return ASE_NULL;
 			}
 		}
 
 		if (__get_token(awk) == -1) 
 		{
-			SSE_AWK_FREE (awk, name_dup);
-			sse_awk_tab_clear (&awk->parse.params);
-			return SSE_NULL;
+			ASE_AWK_FREE (awk, name_dup);
+			ase_awk_tab_clear (&awk->parse.params);
+			return ASE_NULL;
 		}
 	}
 
 	/* check if the function body starts with a left brace */
 	if (!MATCH(awk,TOKEN_LBRACE)) 
 	{
-		SSE_AWK_FREE (awk, name_dup);
-		sse_awk_tab_clear (&awk->parse.params);
-		PANIC (awk, SSE_AWK_ELBRACE);
+		ASE_AWK_FREE (awk, name_dup);
+		ase_awk_tab_clear (&awk->parse.params);
+		PANIC (awk, ASE_AWK_ELBRACE);
 	}
 	if (__get_token(awk) == -1) 
 	{
-		SSE_AWK_FREE (awk, name_dup);
-		sse_awk_tab_clear (&awk->parse.params);
-		return SSE_NULL; 
+		ASE_AWK_FREE (awk, name_dup);
+		ase_awk_tab_clear (&awk->parse.params);
+		return ASE_NULL; 
 	}
 
 	/* actual function body */
-	body = __parse_block (awk, sse_true);
-	if (body == SSE_NULL) 
+	body = __parse_block (awk, ase_true);
+	if (body == ASE_NULL) 
 	{
-		SSE_AWK_FREE (awk, name_dup);
-		sse_awk_tab_clear (&awk->parse.params);
-		return SSE_NULL;
+		ASE_AWK_FREE (awk, name_dup);
+		ase_awk_tab_clear (&awk->parse.params);
+		return ASE_NULL;
 	}
 
 	/* TODO: study furthur if the parameter names should be saved 
 	 *       for some reasons */
-	nargs = sse_awk_tab_getsize (&awk->parse.params);
+	nargs = ase_awk_tab_getsize (&awk->parse.params);
 	/* parameter names are not required anymore. clear them */
-	sse_awk_tab_clear (&awk->parse.params);
+	ase_awk_tab_clear (&awk->parse.params);
 
-	afn = (sse_awk_afn_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_afn_t));
-	if (afn == SSE_NULL) 
+	afn = (ase_awk_afn_t*) ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_afn_t));
+	if (afn == ASE_NULL) 
 	{
-		SSE_AWK_FREE (awk, name_dup);
-		sse_awk_clrpt (awk, body);
-		return SSE_NULL;
+		ASE_AWK_FREE (awk, name_dup);
+		ase_awk_clrpt (awk, body);
+		return ASE_NULL;
 	}
 
-	afn->name = SSE_NULL; /* function name set below */
+	afn->name = ASE_NULL; /* function name set below */
 	afn->name_len = 0;
 	afn->nargs = nargs;
 	afn->body  = body;
 
-	n = sse_awk_map_putx (&awk->tree.afns, name_dup, name_len, afn, &pair);
+	n = ase_awk_map_putx (&awk->tree.afns, name_dup, name_len, afn, &pair);
 	if (n < 0)
 	{
-		SSE_AWK_FREE (awk, name_dup);
-		sse_awk_clrpt (awk, body);
-		SSE_AWK_FREE (awk, afn);
-		PANIC (awk, SSE_AWK_ENOMEM);
+		ASE_AWK_FREE (awk, name_dup);
+		ase_awk_clrpt (awk, body);
+		ASE_AWK_FREE (awk, afn);
+		PANIC (awk, ASE_AWK_ENOMEM);
 	}
 
 	/* duplicate functions should have been detected previously */
-	sse_awk_assert (awk, n != 0); 
+	ase_awk_assert (awk, n != 0); 
 
 	afn->name = pair->key; /* do some trick to save a string.  */
 	afn->name_len = pair->key_len;
-	SSE_AWK_FREE (awk, name_dup);
+	ASE_AWK_FREE (awk, name_dup);
 
 	return body;
 }
 
-static sse_awk_nde_t* __parse_begin (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_begin (ase_awk_t* awk)
 {
-	sse_awk_nde_t* nde;
+	ase_awk_nde_t* nde;
 
-	sse_awk_assert (awk, MATCH(awk,TOKEN_LBRACE));
+	ase_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;
+	if (__get_token(awk) == -1) return ASE_NULL; 
+	nde = __parse_block(awk, ase_true);
+	if (nde == ASE_NULL) return ASE_NULL;
 
 	awk->tree.begin = nde;
 	return nde;
 }
 
-static sse_awk_nde_t* __parse_end (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_end (ase_awk_t* awk)
 {
-	sse_awk_nde_t* nde;
+	ase_awk_nde_t* nde;
 
-	sse_awk_assert (awk, MATCH(awk,TOKEN_LBRACE));
+	ase_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;
+	if (__get_token(awk) == -1) return ASE_NULL; 
+	nde = __parse_block(awk, ase_true);
+	if (nde == ASE_NULL) return ASE_NULL;
 
 	awk->tree.end = nde;
 	return nde;
 }
 
-static sse_awk_chain_t* __parse_pattern_block (
-	sse_awk_t* awk, sse_awk_nde_t* ptn, sse_bool_t blockless)
+static ase_awk_chain_t* __parse_pattern_block (
+	ase_awk_t* awk, ase_awk_nde_t* ptn, ase_bool_t blockless)
 {
-	sse_awk_nde_t* nde;
-	sse_awk_chain_t* chain;
+	ase_awk_nde_t* nde;
+	ase_awk_chain_t* chain;
 
-	if (blockless) nde = SSE_NULL;
+	if (blockless) nde = ASE_NULL;
 	else
 	{
-		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;
+		ase_awk_assert (awk, MATCH(awk,TOKEN_LBRACE));
+		if (__get_token(awk) == -1) return ASE_NULL; 
+		nde = __parse_block(awk, ase_true);
+		if (nde == ASE_NULL) return ASE_NULL;
 	}
 
-	chain = (sse_awk_chain_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_chain_t));
-	if (chain == SSE_NULL) 
+	chain = (ase_awk_chain_t*) ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_chain_t));
+	if (chain == ASE_NULL) 
 	{
-		sse_awk_clrpt (awk, nde);
-		PANIC (awk, SSE_AWK_ENOMEM);
+		ase_awk_clrpt (awk, nde);
+		PANIC (awk, ASE_AWK_ENOMEM);
 	}
 
 	chain->pattern = ptn;
 	chain->action = nde;
-	chain->next = SSE_NULL;
+	chain->next = ASE_NULL;
 
-	if (awk->tree.chain == SSE_NULL) 
+	if (awk->tree.chain == ASE_NULL) 
 	{
 		awk->tree.chain = chain;
 		awk->tree.chain_tail = chain;
@@ -860,17 +860,17 @@ static sse_awk_chain_t* __parse_pattern_block (
 	return chain;
 }
 
-static sse_awk_nde_t* __parse_block (sse_awk_t* awk, sse_bool_t is_top) 
+static ase_awk_nde_t* __parse_block (ase_awk_t* awk, ase_bool_t is_top) 
 {
-	sse_awk_nde_t* head, * curr, * nde;
-	sse_awk_nde_blk_t* block;
-	sse_size_t nlocals, nlocals_max, tmp;
+	ase_awk_nde_t* head, * curr, * nde;
+	ase_awk_nde_blk_t* block;
+	ase_size_t nlocals, nlocals_max, tmp;
 
-	nlocals = sse_awk_tab_getsize(&awk->parse.locals);
+	nlocals = ase_awk_tab_getsize(&awk->parse.locals);
 	nlocals_max = awk->parse.nlocals_max;
 
 	/* local variable declarations */
-	if (awk->option & SSE_AWK_EXPLICIT) 
+	if (awk->option & ASE_AWK_EXPLICIT) 
 	{
 		while (1) 
 		{
@@ -878,90 +878,90 @@ static sse_awk_nde_t* __parse_block (sse_awk_t* awk, sse_bool_t is_top)
 
 			if (__get_token(awk) == -1) 
 			{
-				sse_awk_tab_remove (
+				ase_awk_tab_remove (
 					&awk->parse.locals, nlocals, 
-					sse_awk_tab_getsize(&awk->parse.locals) - nlocals);
-				return SSE_NULL;
+					ase_awk_tab_getsize(&awk->parse.locals) - nlocals);
+				return ASE_NULL;
 			}
 
-			if (__collect_locals(awk, nlocals) == SSE_NULL)
+			if (__collect_locals(awk, nlocals) == ASE_NULL)
 			{
-				sse_awk_tab_remove (
+				ase_awk_tab_remove (
 					&awk->parse.locals, nlocals, 
-					sse_awk_tab_getsize(&awk->parse.locals) - nlocals);
-				return SSE_NULL;
+					ase_awk_tab_getsize(&awk->parse.locals) - nlocals);
+				return ASE_NULL;
 			}
 		}
 	}
 
 	/* block body */
-	head = SSE_NULL; curr = SSE_NULL;
+	head = ASE_NULL; curr = ASE_NULL;
 
 	while (1) 
 	{
 		if (MATCH(awk,TOKEN_EOF)) 
 		{
-			sse_awk_tab_remove (
+			ase_awk_tab_remove (
 				&awk->parse.locals, nlocals, 
-				sse_awk_tab_getsize(&awk->parse.locals) - nlocals);
-			if (head != SSE_NULL) sse_awk_clrpt (awk, head);
-			PANIC (awk, SSE_AWK_EENDSRC);
+				ase_awk_tab_getsize(&awk->parse.locals) - nlocals);
+			if (head != ASE_NULL) ase_awk_clrpt (awk, head);
+			PANIC (awk, ASE_AWK_EENDSRC);
 		}
 
 		if (MATCH(awk,TOKEN_RBRACE)) 
 		{
 			if (__get_token(awk) == -1) 
 			{
-				sse_awk_tab_remove (
+				ase_awk_tab_remove (
 					&awk->parse.locals, nlocals, 
-					sse_awk_tab_getsize(&awk->parse.locals) - nlocals);
-				if (head != SSE_NULL) sse_awk_clrpt (awk, head);
-				return SSE_NULL; 
+					ase_awk_tab_getsize(&awk->parse.locals) - nlocals);
+				if (head != ASE_NULL) ase_awk_clrpt (awk, head);
+				return ASE_NULL; 
 			}
 			break;
 		}
 
 		nde = __parse_statement (awk);
-		if (nde == SSE_NULL) 
+		if (nde == ASE_NULL) 
 		{
-			sse_awk_tab_remove (
+			ase_awk_tab_remove (
 				&awk->parse.locals, nlocals, 
-				sse_awk_tab_getsize(&awk->parse.locals) - nlocals);
-			if (head != SSE_NULL) sse_awk_clrpt (awk, head);
-			return SSE_NULL;
+				ase_awk_tab_getsize(&awk->parse.locals) - nlocals);
+			if (head != ASE_NULL) ase_awk_clrpt (awk, head);
+			return ASE_NULL;
 		}
 
 		/* remove unnecessary statements */
-		if (nde->type == SSE_AWK_NDE_NULL ||
-		    (nde->type == SSE_AWK_NDE_BLK && 
-		     ((sse_awk_nde_blk_t*)nde)->body == SSE_NULL)) continue;
+		if (nde->type == ASE_AWK_NDE_NULL ||
+		    (nde->type == ASE_AWK_NDE_BLK && 
+		     ((ase_awk_nde_blk_t*)nde)->body == ASE_NULL)) continue;
 			
-		if (curr == SSE_NULL) head = nde;
+		if (curr == ASE_NULL) head = nde;
 		else curr->next = nde;	
 		curr = nde;
 	}
 
-	block = (sse_awk_nde_blk_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_blk_t));
-	if (block == SSE_NULL) 
+	block = (ase_awk_nde_blk_t*) ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_nde_blk_t));
+	if (block == ASE_NULL) 
 	{
-		sse_awk_tab_remove (
+		ase_awk_tab_remove (
 			&awk->parse.locals, nlocals, 
-			sse_awk_tab_getsize(&awk->parse.locals) - nlocals);
-		sse_awk_clrpt (awk, head);
-		PANIC (awk, SSE_AWK_ENOMEM);
+			ase_awk_tab_getsize(&awk->parse.locals) - nlocals);
+		ase_awk_clrpt (awk, head);
+		PANIC (awk, ASE_AWK_ENOMEM);
 	}
 
-	tmp = sse_awk_tab_getsize(&awk->parse.locals);
+	tmp = ase_awk_tab_getsize(&awk->parse.locals);
 	if (tmp > awk->parse.nlocals_max) awk->parse.nlocals_max = tmp;
 
-	sse_awk_tab_remove (
+	ase_awk_tab_remove (
 		&awk->parse.locals, nlocals, tmp - nlocals);
 
 	/* adjust the number of locals for a block without any statements */
-	/* if (head == SSE_NULL) tmp = 0; */
+	/* if (head == ASE_NULL) tmp = 0; */
 
-	block->type = SSE_AWK_NDE_BLK;
-	block->next = SSE_NULL;
+	block->type = ASE_AWK_NDE_BLK;
+	block->next = ASE_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 (sse_awk_nde_t*)block;
+	return (ase_awk_nde_t*)block;
 }
 
-static sse_awk_t* __add_builtin_globals (sse_awk_t* awk)
+static ase_awk_t* __add_builtin_globals (ase_awk_t* awk)
 {
 	struct __bvent* p = __bvtab;
 
 	awk->tree.nbglobals = 0;
-	while (p->name != SSE_NULL)
+	while (p->name != ASE_NULL)
 	{
 		if (__add_global (awk, 
-			p->name, p->name_len) == SSE_NULL) return SSE_NULL;
+			p->name, p->name_len) == ASE_NULL) return ASE_NULL;
 		awk->tree.nbglobals++;
 		p++;
 	}
@@ -999,159 +999,159 @@ static sse_awk_t* __add_builtin_globals (sse_awk_t* awk)
 	return awk;
 }
 
-static sse_awk_t* __add_global (
-	sse_awk_t* awk, const sse_char_t* name, sse_size_t len)
+static ase_awk_t* __add_global (
+	ase_awk_t* awk, const ase_char_t* name, ase_size_t len)
 {
-	if (awk->option & SSE_AWK_UNIQUE) 
+	if (awk->option & ASE_AWK_UNIQUE) 
 	{
 		/* check if it conflict with a function name */
-		if (sse_awk_map_get(&awk->tree.afns, name, len) != SSE_NULL) 
+		if (ase_awk_map_get(&awk->tree.afns, name, len) != ASE_NULL) 
 		{
-			PANIC (awk, SSE_AWK_EDUPNAME);
+			PANIC (awk, ASE_AWK_EDUPNAME);
 		}
 	}
 
 	/* check if it conflicts with other global variable names */
-	if (sse_awk_tab_find (&awk->parse.globals, 0, name, len) != (sse_size_t)-1) 
+	if (ase_awk_tab_find (&awk->parse.globals, 0, name, len) != (ase_size_t)-1) 
 	{ 
-		PANIC (awk, SSE_AWK_EDUPVAR);
+		PANIC (awk, ASE_AWK_EDUPVAR);
 	}
 
-	if (sse_awk_tab_getsize(&awk->parse.globals) >= SSE_AWK_MAX_GLOBALS)
+	if (ase_awk_tab_getsize(&awk->parse.globals) >= ASE_AWK_MAX_GLOBALS)
 	{
-		PANIC (awk, SSE_AWK_ETOOMANYGLOBALS);
+		PANIC (awk, ASE_AWK_ETOOMANYGLOBALS);
 	}
 
-	if (sse_awk_tab_add (&awk->parse.globals, name, len) == (sse_size_t)-1) 
+	if (ase_awk_tab_add (&awk->parse.globals, name, len) == (ase_size_t)-1) 
 	{
-		PANIC (awk, SSE_AWK_ENOMEM);
+		PANIC (awk, ASE_AWK_ENOMEM);
 	}
 
 	return awk;
 }
 
-static sse_awk_t* __collect_globals (sse_awk_t* awk)
+static ase_awk_t* __collect_globals (ase_awk_t* awk)
 {
 	while (1) 
 	{
 		if (!MATCH(awk,TOKEN_IDENT)) 
 		{
-			PANIC (awk, SSE_AWK_EIDENT);
+			PANIC (awk, ASE_AWK_EIDENT);
 		}
 
 		if (__add_global (awk,
-			SSE_AWK_STR_BUF(&awk->token.name),
-			SSE_AWK_STR_LEN(&awk->token.name)) == SSE_NULL) return SSE_NULL;
+			ASE_AWK_STR_BUF(&awk->token.name),
+			ASE_AWK_STR_LEN(&awk->token.name)) == ASE_NULL) return ASE_NULL;
 
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 
 		if (MATCH(awk,TOKEN_SEMICOLON)) break;
 
 		if (!MATCH(awk,TOKEN_COMMA)) 
 		{
-			PANIC (awk, SSE_AWK_ECOMMA);
+			PANIC (awk, ASE_AWK_ECOMMA);
 		}
 
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 	}
 
 	/* skip a semicolon */
-	if (__get_token(awk) == -1) return SSE_NULL;
+	if (__get_token(awk) == -1) return ASE_NULL;
 
 	return awk;
 }
 
-static sse_awk_t* __collect_locals (sse_awk_t* awk, sse_size_t nlocals)
+static ase_awk_t* __collect_locals (ase_awk_t* awk, ase_size_t nlocals)
 {
-	sse_char_t* local;
-	sse_size_t local_len;
+	ase_char_t* local;
+	ase_size_t local_len;
 
 	while (1) 
 	{
 		if (!MATCH(awk,TOKEN_IDENT)) 
 		{
-			PANIC (awk, SSE_AWK_EIDENT);
+			PANIC (awk, ASE_AWK_EIDENT);
 		}
 
-		local = SSE_AWK_STR_BUF(&awk->token.name);
-		local_len = SSE_AWK_STR_LEN(&awk->token.name);
+		local = ASE_AWK_STR_BUF(&awk->token.name);
+		local_len = ASE_AWK_STR_LEN(&awk->token.name);
 
 		/* NOTE: it is not checked againt globals names */
 
-		if (awk->option & SSE_AWK_UNIQUE) 
+		if (awk->option & ASE_AWK_UNIQUE) 
 		{
 			/* check if it conflict with a function name */
-			if (sse_awk_map_get (
-				&awk->tree.afns, local, local_len) != SSE_NULL) 
+			if (ase_awk_map_get (
+				&awk->tree.afns, local, local_len) != ASE_NULL) 
 			{
-				PANIC (awk, SSE_AWK_EDUPNAME);
+				PANIC (awk, ASE_AWK_EDUPNAME);
 			}
 		}
 
 		/* check if it conflicts with a paremeter name */
-		if (sse_awk_tab_find (&awk->parse.params,
-			0, local, local_len) != (sse_size_t)-1) 
+		if (ase_awk_tab_find (&awk->parse.params,
+			0, local, local_len) != (ase_size_t)-1) 
 		{
-			PANIC (awk, SSE_AWK_EDUPNAME);
+			PANIC (awk, ASE_AWK_EDUPNAME);
 		}
 
 		/* check if it conflicts with other local variable names */
-		if (sse_awk_tab_find (&awk->parse.locals, 
-			((awk->option & SSE_AWK_SHADING)? nlocals: 0),
-			local, local_len) != (sse_size_t)-1)
+		if (ase_awk_tab_find (&awk->parse.locals, 
+			((awk->option & ASE_AWK_SHADING)? nlocals: 0),
+			local, local_len) != (ase_size_t)-1)
 		{
-			PANIC (awk, SSE_AWK_EDUPVAR);	
+			PANIC (awk, ASE_AWK_EDUPVAR);	
 		}
 
-		if (sse_awk_tab_getsize(&awk->parse.locals) >= SSE_AWK_MAX_LOCALS)
+		if (ase_awk_tab_getsize(&awk->parse.locals) >= ASE_AWK_MAX_LOCALS)
 		{
-			PANIC (awk, SSE_AWK_ETOOMANYLOCALS);
+			PANIC (awk, ASE_AWK_ETOOMANYLOCALS);
 		}
 
-		if (sse_awk_tab_add (
-			&awk->parse.locals, local, local_len) == (sse_size_t)-1) 
+		if (ase_awk_tab_add (
+			&awk->parse.locals, local, local_len) == (ase_size_t)-1) 
 		{
-			PANIC (awk, SSE_AWK_ENOMEM);
+			PANIC (awk, ASE_AWK_ENOMEM);
 		}
 
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 
 		if (MATCH(awk,TOKEN_SEMICOLON)) break;
 
-		if (!MATCH(awk,TOKEN_COMMA)) PANIC (awk, SSE_AWK_ECOMMA);
+		if (!MATCH(awk,TOKEN_COMMA)) PANIC (awk, ASE_AWK_ECOMMA);
 
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 	}
 
 	/* skip a semicolon */
-	if (__get_token(awk) == -1) return SSE_NULL;
+	if (__get_token(awk) == -1) return ASE_NULL;
 
 	return awk;
 }
 
-static sse_awk_nde_t* __parse_statement (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_statement (ase_awk_t* awk)
 {
-	sse_awk_nde_t* nde;
+	ase_awk_nde_t* nde;
 
 	if (MATCH(awk,TOKEN_SEMICOLON)) 
 	{
 		/* null statement */	
-		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 = (ase_awk_nde_t*) ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_nde_t));
+		if (nde == ASE_NULL) PANIC (awk, ASE_AWK_ENOMEM);
 
-		nde->type = SSE_AWK_NDE_NULL;
-		nde->next = SSE_NULL;
+		nde->type = ASE_AWK_NDE_NULL;
+		nde->next = ASE_NULL;
 
 		if (__get_token(awk) == -1) 
 		{
-			SSE_AWK_FREE (awk, nde);
-			return SSE_NULL;
+			ASE_AWK_FREE (awk, nde);
+			return ASE_NULL;
 		}
 	}
 	else if (MATCH(awk,TOKEN_LBRACE)) 
 	{
-		if (__get_token(awk) == -1) return SSE_NULL; 
-		nde = __parse_block (awk, sse_false);
+		if (__get_token(awk) == -1) return ASE_NULL; 
+		nde = __parse_block (awk, ase_false);
 	}
 	else 
 	{
@@ -1162,21 +1162,21 @@ awk->parse.nl_semicolon = 0;
 	return nde;
 }
 
-static sse_awk_nde_t* __parse_statement_nb (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_statement_nb (ase_awk_t* awk)
 {
-	sse_awk_nde_t* nde;
+	ase_awk_nde_t* nde;
 
 	/* 
 	 * keywords that don't require any terminating semicolon 
 	 */
 	if (MATCH(awk,TOKEN_IF)) 
 	{
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 		return __parse_if (awk);
 	}
 	else if (MATCH(awk,TOKEN_WHILE)) 
 	{
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 		
 		awk->parse.depth.loop++;
 		nde = __parse_while (awk);
@@ -1186,7 +1186,7 @@ static sse_awk_nde_t* __parse_statement_nb (sse_awk_t* awk)
 	}
 	else if (MATCH(awk,TOKEN_FOR)) 
 	{
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_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 SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 
 		awk->parse.depth.loop++;
 		nde = __parse_dowhile (awk);
@@ -1211,47 +1211,47 @@ awk->parse.nl_semicolon = 1;
 	}
 	else if (MATCH(awk,TOKEN_BREAK)) 
 	{
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 		nde = __parse_break (awk);
 	}
 	else if (MATCH(awk,TOKEN_CONTINUE)) 
 	{
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 		nde = __parse_continue (awk);
 	}
 	else if (MATCH(awk,TOKEN_RETURN)) 
 	{
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 		nde = __parse_return (awk);
 	}
 	else if (MATCH(awk,TOKEN_EXIT)) 
 	{
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 		nde = __parse_exit (awk);
 	}
 	else if (MATCH(awk,TOKEN_NEXT)) 
 	{
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 		nde = __parse_next (awk);
 	}
 	else if (MATCH(awk,TOKEN_NEXTFILE)) 
 	{
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 		nde = __parse_nextfile (awk);
 	}
 	else if (MATCH(awk,TOKEN_DELETE)) 
 	{
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 		nde = __parse_delete (awk);
 	}
 	else if (MATCH(awk,TOKEN_PRINT))
 	{
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 		nde = __parse_print (awk);
 	}
 	else if (MATCH(awk,TOKEN_PRINTF))
 	{
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 		nde = __parse_printf (awk);
 	}
 	else 
@@ -1260,33 +1260,33 @@ awk->parse.nl_semicolon = 1;
 	}
 
 awk->parse.nl_semicolon = 0;
-	if (nde == SSE_NULL) return SSE_NULL;
+	if (nde == ASE_NULL) return ASE_NULL;
 
 	/* check if a statement ends with a semicolon */
 	if (!MATCH(awk,TOKEN_SEMICOLON)) 
 	{
-		if (nde != SSE_NULL) sse_awk_clrpt (awk, nde);
-		PANIC (awk, SSE_AWK_ESEMICOLON);
+		if (nde != ASE_NULL) ase_awk_clrpt (awk, nde);
+		PANIC (awk, ASE_AWK_ESEMICOLON);
 	}
 
 	/* eat up the semicolon and read in the next token */
 	if (__get_token(awk) == -1) 
 	{
-		if (nde != SSE_NULL) sse_awk_clrpt (awk, nde);
-		return SSE_NULL;
+		if (nde != ASE_NULL) ase_awk_clrpt (awk, nde);
+		return ASE_NULL;
 	}
 
 	return nde;
 }
 
-static sse_awk_nde_t* __parse_expression (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_expression (ase_awk_t* awk)
 {
-	sse_awk_nde_t* x, * y;
-	sse_awk_nde_ass_t* nde;
+	ase_awk_nde_t* x, * y;
+	ase_awk_nde_ass_t* nde;
 	int opcode;
 
 	x = __parse_basic_expr (awk);
-	if (x == SSE_NULL) return SSE_NULL;
+	if (x == ASE_NULL) return ASE_NULL;
 
 	opcode = __assign_to_opcode (awk);
 	if (opcode == -1) 
@@ -1295,118 +1295,118 @@ static sse_awk_nde_t* __parse_expression (sse_awk_t* awk)
 		return x;
 	}
 
-	sse_awk_assert (awk, x->next == SSE_NULL);
-	if (!__is_var(x) && x->type != SSE_AWK_NDE_POS) 
+	ase_awk_assert (awk, x->next == ASE_NULL);
+	if (!__is_var(x) && x->type != ASE_AWK_NDE_POS) 
 	{
-		sse_awk_clrpt (awk, x);
-		PANIC (awk, SSE_AWK_EASSIGNMENT);
+		ase_awk_clrpt (awk, x);
+		PANIC (awk, ASE_AWK_EASSIGNMENT);
 	}
 
 	if (__get_token(awk) == -1) 
 	{
-		sse_awk_clrpt (awk, x);
-		return SSE_NULL;
+		ase_awk_clrpt (awk, x);
+		return ASE_NULL;
 	}
 
 	y = __parse_basic_expr (awk);
-	if (y == SSE_NULL) 
+	if (y == ASE_NULL) 
 	{
-		sse_awk_clrpt (awk, x);
-		return SSE_NULL;
+		ase_awk_clrpt (awk, x);
+		return ASE_NULL;
 	}
 
-	nde = (sse_awk_nde_ass_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_ass_t));
-	if (nde == SSE_NULL) 
+	nde = (ase_awk_nde_ass_t*) ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_nde_ass_t));
+	if (nde == ASE_NULL) 
 	{
-		sse_awk_clrpt (awk, x);
-		sse_awk_clrpt (awk, y);
-		PANIC (awk, SSE_AWK_ENOMEM);
+		ase_awk_clrpt (awk, x);
+		ase_awk_clrpt (awk, y);
+		PANIC (awk, ASE_AWK_ENOMEM);
 	}
 
-	nde->type = SSE_AWK_NDE_ASS;
-	nde->next = SSE_NULL;
+	nde->type = ASE_AWK_NDE_ASS;
+	nde->next = ASE_NULL;
 	nde->opcode = opcode;
 	nde->left = x;
 	nde->right = y;
 
-	return (sse_awk_nde_t*)nde;
+	return (ase_awk_nde_t*)nde;
 }
 
-static sse_awk_nde_t* __parse_basic_expr (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_basic_expr (ase_awk_t* awk)
 {
-	sse_awk_nde_t* nde, * n1, * n2;
+	ase_awk_nde_t* nde, * n1, * n2;
 	
 	nde = __parse_logical_or (awk);
-	if (nde == SSE_NULL) return SSE_NULL;
+	if (nde == ASE_NULL) return ASE_NULL;
 
 	if (MATCH(awk,TOKEN_QUEST))
 	{ 
-		sse_awk_nde_cnd_t* tmp;
+		ase_awk_nde_cnd_t* tmp;
 
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 
 		n1 = __parse_basic_expr (awk);
-		if (n1 == SSE_NULL) 
+		if (n1 == ASE_NULL) 
 		{
-			sse_awk_clrpt (awk, nde);
-			return SSE_NULL;
+			ase_awk_clrpt (awk, nde);
+			return ASE_NULL;
 		}
 
-		if (!MATCH(awk,TOKEN_COLON)) PANIC (awk, SSE_AWK_ECOLON);
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (!MATCH(awk,TOKEN_COLON)) PANIC (awk, ASE_AWK_ECOLON);
+		if (__get_token(awk) == -1) return ASE_NULL;
 
 		n2 = __parse_basic_expr (awk);
-		if (n2 == SSE_NULL)
+		if (n2 == ASE_NULL)
 		{
-			sse_awk_clrpt (awk, nde);
-			sse_awk_clrpt (awk, n1);
-			return SSE_NULL;
+			ase_awk_clrpt (awk, nde);
+			ase_awk_clrpt (awk, n1);
+			return ASE_NULL;
 		}
 
-		tmp = (sse_awk_nde_cnd_t*) SSE_AWK_MALLOC (
-			awk, sse_sizeof(sse_awk_nde_cnd_t));
-		if (tmp == SSE_NULL)
+		tmp = (ase_awk_nde_cnd_t*) ASE_AWK_MALLOC (
+			awk, ase_sizeof(ase_awk_nde_cnd_t));
+		if (tmp == ASE_NULL)
 		{
-			sse_awk_clrpt (awk, nde);
-			sse_awk_clrpt (awk, n1);
-			sse_awk_clrpt (awk, n2);
-			return SSE_NULL;
+			ase_awk_clrpt (awk, nde);
+			ase_awk_clrpt (awk, n1);
+			ase_awk_clrpt (awk, n2);
+			return ASE_NULL;
 		}
 
-		tmp->type = SSE_AWK_NDE_CND;
-		tmp->next = SSE_NULL;
+		tmp->type = ASE_AWK_NDE_CND;
+		tmp->next = ASE_NULL;
 		tmp->test = nde;
 		tmp->left = n1;
 		tmp->right = n2;
 
-		nde = (sse_awk_nde_t*)tmp;
+		nde = (ase_awk_nde_t*)tmp;
 	}
 
 	return nde;
 }
 
-static sse_awk_nde_t* __parse_binary_expr (
-	sse_awk_t* awk, const __binmap_t* binmap,
-	sse_awk_nde_t*(*next_level_func)(sse_awk_t*))
+static ase_awk_nde_t* __parse_binary_expr (
+	ase_awk_t* awk, const __binmap_t* binmap,
+	ase_awk_nde_t*(*next_level_func)(ase_awk_t*))
 {
-	sse_awk_nde_exp_t* nde;
-	sse_awk_nde_t* left, * right;
+	ase_awk_nde_exp_t* nde;
+	ase_awk_nde_t* left, * right;
 	int opcode;
 
 	left = next_level_func (awk);
-	if (left == SSE_NULL) return SSE_NULL;
+	if (left == ASE_NULL) return ASE_NULL;
 	
 	while (1) 
 	{
 		const __binmap_t* p = binmap;
-		sse_bool_t matched = sse_false;
+		ase_bool_t matched = ase_false;
 
 		while (p->token != TOKEN_EOF)
 		{
 			if (MATCH(awk,p->token)) 
 			{
 				opcode = p->binop;
-				matched = sse_true;
+				matched = ase_true;
 				break;
 			}
 			p++;
@@ -1415,71 +1415,71 @@ static sse_awk_nde_t* __parse_binary_expr (
 
 		if (__get_token(awk) == -1) 
 		{
-			sse_awk_clrpt (awk, left);
-			return SSE_NULL; 
+			ase_awk_clrpt (awk, left);
+			return ASE_NULL; 
 		}
 
 		right = next_level_func (awk);
-		if (right == SSE_NULL) 
+		if (right == ASE_NULL) 
 		{
-			sse_awk_clrpt (awk, left);
-			return SSE_NULL;
+			ase_awk_clrpt (awk, left);
+			return ASE_NULL;
 		}
 
 #if 0
 		/* TODO: enhance constant folding. do it in a better way */
 		/* TODO: differentiate different types of numbers ... */
-		if (left->type == SSE_AWK_NDE_INT && 
-		    right->type == SSE_AWK_NDE_INT) 
+		if (left->type == ASE_AWK_NDE_INT && 
+		    right->type == ASE_AWK_NDE_INT) 
 		{
-			sse_long_t l, r;
+			ase_long_t l, r;
 
-			l = ((sse_awk_nde_int_t*)left)->val; 
-			r = ((sse_awk_nde_int_t*)right)->val; 
+			l = ((ase_awk_nde_int_t*)left)->val; 
+			r = ((ase_awk_nde_int_t*)right)->val; 
 
 			/* TODO: more operators */
-			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;
+			if (opcode == ASE_AWK_BINOP_PLUS) l += r;
+			else if (opcode == ASE_AWK_BINOP_MINUS) l -= r;
+			else if (opcode == ASE_AWK_BINOP_MUL) l *= r;
+			else if (opcode == ASE_AWK_BINOP_DIV && r != 0) l /= r;
+			else if (opcode == ASE_AWK_BINOP_MOD && r != 0) l %= r;
 			else goto skip_constant_folding;
 
-			sse_awk_clrpt (awk, right);
-			((sse_awk_nde_int_t*)left)->val = l;
+			ase_awk_clrpt (awk, right);
+			((ase_awk_nde_int_t*)left)->val = l;
 
-			if (((sse_awk_nde_int_t*)left)->str != SSE_NULL)
+			if (((ase_awk_nde_int_t*)left)->str != ASE_NULL)
 			{
-				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;
+				ASE_AWK_FREE (awk, ((ase_awk_nde_int_t*)left)->str);
+				((ase_awk_nde_int_t*)left)->str = ASE_NULL;
+				((ase_awk_nde_int_t*)left)->len = 0;
 			}
 
 			continue;
 		} 
-		else if (left->type == SSE_AWK_NDE_REAL && 
-		         right->type == SSE_AWK_NDE_REAL) 
+		else if (left->type == ASE_AWK_NDE_REAL && 
+		         right->type == ASE_AWK_NDE_REAL) 
 		{
-			sse_real_t l, r;
+			ase_real_t l, r;
 
-			l = ((sse_awk_nde_real_t*)left)->val; 
-			r = ((sse_awk_nde_real_t*)right)->val; 
+			l = ((ase_awk_nde_real_t*)left)->val; 
+			r = ((ase_awk_nde_real_t*)right)->val; 
 
 			/* TODO: more operators */
-			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;
+			if (opcode == ASE_AWK_BINOP_PLUS) l += r;
+			else if (opcode == ASE_AWK_BINOP_MINUS) l -= r;
+			else if (opcode == ASE_AWK_BINOP_MUL) l *= r;
+			else if (opcode == ASE_AWK_BINOP_DIV) l /= r;
 			else goto skip_constant_folding;
 
-			sse_awk_clrpt (awk, right);
-			((sse_awk_nde_real_t*)left)->val = l;
+			ase_awk_clrpt (awk, right);
+			((ase_awk_nde_real_t*)left)->val = l;
 
-			if (((sse_awk_nde_real_t*)left)->str != SSE_NULL)
+			if (((ase_awk_nde_real_t*)left)->str != ASE_NULL)
 			{
-				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;
+				ASE_AWK_FREE (awk, ((ase_awk_nde_real_t*)left)->str);
+				((ase_awk_nde_real_t*)left)->str = ASE_NULL;
+				((ase_awk_nde_real_t*)left)->len = 0;
 			}
 
 			continue;
@@ -1488,66 +1488,66 @@ static sse_awk_nde_t* __parse_binary_expr (
 
 	skip_constant_folding:
 #endif
-		nde = (sse_awk_nde_exp_t*) SSE_AWK_MALLOC (
-			awk, sse_sizeof(sse_awk_nde_exp_t));
-		if (nde == SSE_NULL) 
+		nde = (ase_awk_nde_exp_t*) ASE_AWK_MALLOC (
+			awk, ase_sizeof(ase_awk_nde_exp_t));
+		if (nde == ASE_NULL) 
 		{
-			sse_awk_clrpt (awk, right);
-			sse_awk_clrpt (awk, left);
-			PANIC (awk, SSE_AWK_ENOMEM);
+			ase_awk_clrpt (awk, right);
+			ase_awk_clrpt (awk, left);
+			PANIC (awk, ASE_AWK_ENOMEM);
 		}
 
-		nde->type = SSE_AWK_NDE_EXP_BIN;
-		nde->next = SSE_NULL;
+		nde->type = ASE_AWK_NDE_EXP_BIN;
+		nde->next = ASE_NULL;
 		nde->opcode = opcode; 
 		nde->left = left;
 		nde->right = right;
 
-		left = (sse_awk_nde_t*)nde;
+		left = (ase_awk_nde_t*)nde;
 	}
 
 	return left;
 }
 
-static sse_awk_nde_t* __parse_logical_or (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_logical_or (ase_awk_t* awk)
 {
 	static __binmap_t map[] = 
 	{
-		{ TOKEN_LOR, SSE_AWK_BINOP_LOR },
+		{ TOKEN_LOR, ASE_AWK_BINOP_LOR },
 		{ TOKEN_EOF, 0 }
 	};
 
 	return __parse_binary_expr (awk, map, __parse_logical_and);
 }
 
-static sse_awk_nde_t* __parse_logical_and (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_logical_and (ase_awk_t* awk)
 {
 	static __binmap_t map[] = 
 	{
-		{ TOKEN_LAND, SSE_AWK_BINOP_LAND },
+		{ TOKEN_LAND, ASE_AWK_BINOP_LAND },
 		{ TOKEN_EOF,  0 }
 	};
 
 	return __parse_binary_expr (awk, map, __parse_in);
 }
 
-static sse_awk_nde_t* __parse_in (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_in (ase_awk_t* awk)
 {
 	/* 
 	static __binmap_t map[] =
 	{
-		{ TOKEN_IN, SSE_AWK_BINOP_IN },
+		{ TOKEN_IN, ASE_AWK_BINOP_IN },
 		{ TOKEN_EOF, 0 }
 	};
 
 	return __parse_binary_expr (awk, map, __parse_regex_match);
 	*/
 
-	sse_awk_nde_exp_t* nde;
-	sse_awk_nde_t* left, * right;
+	ase_awk_nde_exp_t* nde;
+	ase_awk_nde_t* left, * right;
 
 	left = __parse_regex_match (awk);
-	if (left == SSE_NULL) return SSE_NULL;
+	if (left == ASE_NULL) return ASE_NULL;
 
 	while (1)
 	{
@@ -1555,60 +1555,60 @@ static sse_awk_nde_t* __parse_in (sse_awk_t* awk)
 
 		if (__get_token(awk) == -1) 
 		{
-			sse_awk_clrpt (awk, left);
-			return SSE_NULL; 
+			ase_awk_clrpt (awk, left);
+			return ASE_NULL; 
 		}
 
 		right = __parse_regex_match (awk);
-		if (right == SSE_NULL) 
+		if (right == ASE_NULL) 
 		{
-			sse_awk_clrpt (awk, left);
-			return SSE_NULL;
+			ase_awk_clrpt (awk, left);
+			return ASE_NULL;
 		}
 
 		if (!__is_plain_var(right))
 		{
-			sse_awk_clrpt (awk, right);
-			sse_awk_clrpt (awk, left);
-			PANIC (awk, SSE_AWK_ENOTVAR);
+			ase_awk_clrpt (awk, right);
+			ase_awk_clrpt (awk, left);
+			PANIC (awk, ASE_AWK_ENOTVAR);
 		}
 
-		nde = (sse_awk_nde_exp_t*) SSE_AWK_MALLOC (
-			awk, sse_sizeof(sse_awk_nde_exp_t));
-		if (nde == SSE_NULL) 
+		nde = (ase_awk_nde_exp_t*) ASE_AWK_MALLOC (
+			awk, ase_sizeof(ase_awk_nde_exp_t));
+		if (nde == ASE_NULL) 
 		{
-			sse_awk_clrpt (awk, right);
-			sse_awk_clrpt (awk, left);
-			PANIC (awk, SSE_AWK_ENOMEM);
+			ase_awk_clrpt (awk, right);
+			ase_awk_clrpt (awk, left);
+			PANIC (awk, ASE_AWK_ENOMEM);
 		}
 
-		nde->type = SSE_AWK_NDE_EXP_BIN;
-		nde->next = SSE_NULL;
-		nde->opcode = SSE_AWK_BINOP_IN; 
+		nde->type = ASE_AWK_NDE_EXP_BIN;
+		nde->next = ASE_NULL;
+		nde->opcode = ASE_AWK_BINOP_IN; 
 		nde->left = left;
 		nde->right = right;
 
-		left = (sse_awk_nde_t*)nde;
+		left = (ase_awk_nde_t*)nde;
 	}
 
 	return left;
 }
 
-static sse_awk_nde_t* __parse_regex_match (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_regex_match (ase_awk_t* awk)
 {
 	static __binmap_t map[] =
 	{
-		{ TOKEN_TILDE, SSE_AWK_BINOP_MA },
-		{ TOKEN_NM,    SSE_AWK_BINOP_NM },
+		{ TOKEN_TILDE, ASE_AWK_BINOP_MA },
+		{ TOKEN_NM,    ASE_AWK_BINOP_NM },
 		{ TOKEN_EOF,   0 },
 	};
 
 	return __parse_binary_expr (awk, map, __parse_bitwise_or);
 }
 
-static sse_awk_nde_t* __parse_bitwise_or (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_bitwise_or (ase_awk_t* awk)
 {
-	if (awk->option & SSE_AWK_EXTIO)
+	if (awk->option & ASE_AWK_EXTIO)
 	{
 		return __parse_bitwise_or_with_extio (awk);
 	}
@@ -1616,7 +1616,7 @@ static sse_awk_nde_t* __parse_bitwise_or (sse_awk_t* awk)
 	{
 		static __binmap_t map[] = 
 		{
-			{ TOKEN_BOR, SSE_AWK_BINOP_BOR },
+			{ TOKEN_BOR, ASE_AWK_BINOP_BOR },
 			{ TOKEN_EOF, 0 }
 		};
 
@@ -1624,39 +1624,39 @@ 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 ase_awk_nde_t* __parse_bitwise_or_with_extio (ase_awk_t* awk)
 {
-	sse_awk_nde_t* left, * right;
+	ase_awk_nde_t* left, * right;
 
 	left = __parse_bitwise_xor (awk);
-	if (left == SSE_NULL) return SSE_NULL;
+	if (left == ASE_NULL) return ASE_NULL;
 
 	while (1)
 	{
 		int in_type;
 
 		if (MATCH(awk,TOKEN_BOR)) 
-			in_type = SSE_AWK_IN_PIPE;
+			in_type = ASE_AWK_IN_PIPE;
 		else if (MATCH(awk,TOKEN_BORAND)) 
-			in_type = SSE_AWK_IN_COPROC;
+			in_type = ASE_AWK_IN_COPROC;
 		else break;
 		
 		if (__get_token(awk) == -1)
 		{
-			sse_awk_clrpt (awk, left);
-			return SSE_NULL;
+			ase_awk_clrpt (awk, left);
+			return ASE_NULL;
 		}
 
 		if (MATCH(awk,TOKEN_GETLINE))
 		{
-			sse_awk_nde_getline_t* nde;
-			sse_awk_nde_t* var = SSE_NULL;
+			ase_awk_nde_getline_t* nde;
+			ase_awk_nde_t* var = ASE_NULL;
 
 			/* piped getline */
 			if (__get_token(awk) == -1)
 			{
-				sse_awk_clrpt (awk, left);
-				return SSE_NULL;
+				ase_awk_clrpt (awk, left);
+				return ASE_NULL;
 			}
 
 			/* TODO: is this correct? */
@@ -1666,137 +1666,137 @@ static sse_awk_nde_t* __parse_bitwise_or_with_extio (sse_awk_t* awk)
 				/* command | getline var */
 
 				var = __parse_primary (awk);
-				if (var == SSE_NULL) 
+				if (var == ASE_NULL) 
 				{
-					sse_awk_clrpt (awk, left);
-					return SSE_NULL;
+					ase_awk_clrpt (awk, left);
+					return ASE_NULL;
 				}
 			}
 
-			nde = (sse_awk_nde_getline_t*) SSE_AWK_MALLOC (
-				awk, sse_sizeof(sse_awk_nde_getline_t));
-			if (nde == SSE_NULL)
+			nde = (ase_awk_nde_getline_t*) ASE_AWK_MALLOC (
+				awk, ase_sizeof(ase_awk_nde_getline_t));
+			if (nde == ASE_NULL)
 			{
-				sse_awk_clrpt (awk, left);
-				PANIC (awk, SSE_AWK_ENOMEM);
+				ase_awk_clrpt (awk, left);
+				PANIC (awk, ASE_AWK_ENOMEM);
 			}
 
-			nde->type = SSE_AWK_NDE_GETLINE;
-			nde->next = SSE_NULL;
+			nde->type = ASE_AWK_NDE_GETLINE;
+			nde->next = ASE_NULL;
 			nde->var = var;
 			nde->in_type = in_type;
 			nde->in = left;
 
-			left = (sse_awk_nde_t*)nde;
+			left = (ase_awk_nde_t*)nde;
 		}
 		else
 		{
-			sse_awk_nde_exp_t* nde;
+			ase_awk_nde_exp_t* nde;
 
-			if (in_type == SSE_AWK_IN_COPROC)
+			if (in_type == ASE_AWK_IN_COPROC)
 			{
-				sse_awk_clrpt (awk, left);
-				PANIC (awk, SSE_AWK_EGETLINE);
+				ase_awk_clrpt (awk, left);
+				PANIC (awk, ASE_AWK_EGETLINE);
 			}
 
 			right = __parse_bitwise_xor (awk);
-			if (right == SSE_NULL)
+			if (right == ASE_NULL)
 			{
-				sse_awk_clrpt (awk, left);
-				return SSE_NULL;
+				ase_awk_clrpt (awk, left);
+				return ASE_NULL;
 			}
 
 			/* TODO: do constant folding */
 
-			nde = (sse_awk_nde_exp_t*) SSE_AWK_MALLOC (
-				awk, sse_sizeof(sse_awk_nde_exp_t));
-			if (nde == SSE_NULL)
+			nde = (ase_awk_nde_exp_t*) ASE_AWK_MALLOC (
+				awk, ase_sizeof(ase_awk_nde_exp_t));
+			if (nde == ASE_NULL)
 			{
-				sse_awk_clrpt (awk, right);
-				sse_awk_clrpt (awk, left);
-				PANIC (awk, SSE_AWK_ENOMEM);
+				ase_awk_clrpt (awk, right);
+				ase_awk_clrpt (awk, left);
+				PANIC (awk, ASE_AWK_ENOMEM);
 			}
 
-			nde->type = SSE_AWK_NDE_EXP_BIN;
-			nde->next = SSE_NULL;
-			nde->opcode = SSE_AWK_BINOP_BOR;
+			nde->type = ASE_AWK_NDE_EXP_BIN;
+			nde->next = ASE_NULL;
+			nde->opcode = ASE_AWK_BINOP_BOR;
 			nde->left = left;
 			nde->right = right;
 
-			left = (sse_awk_nde_t*)nde;
+			left = (ase_awk_nde_t*)nde;
 		}
 	}
 
 	return left;
 }
 
-static sse_awk_nde_t* __parse_bitwise_xor (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_bitwise_xor (ase_awk_t* awk)
 {
 	static __binmap_t map[] = 
 	{
-		{ TOKEN_BXOR, SSE_AWK_BINOP_BXOR },
+		{ TOKEN_BXOR, ASE_AWK_BINOP_BXOR },
 		{ TOKEN_EOF,  0 }
 	};
 
 	return __parse_binary_expr (awk, map, __parse_bitwise_and);
 }
 
-static sse_awk_nde_t* __parse_bitwise_and (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_bitwise_and (ase_awk_t* awk)
 {
 	static __binmap_t map[] = 
 	{
-		{ TOKEN_BAND, SSE_AWK_BINOP_BAND },
+		{ TOKEN_BAND, ASE_AWK_BINOP_BAND },
 		{ TOKEN_EOF,  0 }
 	};
 
 	return __parse_binary_expr (awk, map, __parse_equality);
 }
 
-static sse_awk_nde_t* __parse_equality (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_equality (ase_awk_t* awk)
 {
 	static __binmap_t map[] = 
 	{
-		{ TOKEN_EQ, SSE_AWK_BINOP_EQ },
-		{ TOKEN_NE, SSE_AWK_BINOP_NE },
+		{ TOKEN_EQ, ASE_AWK_BINOP_EQ },
+		{ TOKEN_NE, ASE_AWK_BINOP_NE },
 		{ TOKEN_EOF, 0 }
 	};
 
 	return __parse_binary_expr (awk, map, __parse_relational);
 }
 
-static sse_awk_nde_t* __parse_relational (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_relational (ase_awk_t* awk)
 {
 	static __binmap_t map[] = 
 	{
-		{ 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_GT, ASE_AWK_BINOP_GT },
+		{ TOKEN_GE, ASE_AWK_BINOP_GE },
+		{ TOKEN_LT, ASE_AWK_BINOP_LT },
+		{ TOKEN_LE, ASE_AWK_BINOP_LE },
 		{ TOKEN_EOF, 0 }
 	};
 
 	return __parse_binary_expr (awk, map, __parse_shift);
 }
 
-static sse_awk_nde_t* __parse_shift (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_shift (ase_awk_t* awk)
 {
 	static __binmap_t map[] = 
 	{
-		{ TOKEN_LSHIFT, SSE_AWK_BINOP_LSHIFT },
-		{ TOKEN_RSHIFT, SSE_AWK_BINOP_RSHIFT },
+		{ TOKEN_LSHIFT, ASE_AWK_BINOP_LSHIFT },
+		{ TOKEN_RSHIFT, ASE_AWK_BINOP_RSHIFT },
 		{ TOKEN_EOF, 0 }
 	};
 
 	return __parse_binary_expr (awk, map, __parse_concat);
 }
 
-static sse_awk_nde_t* __parse_concat (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_concat (ase_awk_t* awk)
 {
-	sse_awk_nde_exp_t* nde;
-	sse_awk_nde_t* left, * right;
+	ase_awk_nde_exp_t* nde;
+	ase_awk_nde_t* left, * right;
 
 	left = __parse_additive (awk);
-	if (left == SSE_NULL) return SSE_NULL;
+	if (left == ASE_NULL) return ASE_NULL;
 
 	/* TODO: write a better code to do this.... 
 	 *       first of all, is the following check sufficient? */
@@ -1805,117 +1805,117 @@ static sse_awk_nde_t* __parse_concat (sse_awk_t* awk)
 	       awk->token.type >= TOKEN_GETLINE)
 	{
 		right = __parse_additive (awk);
-		if (right == SSE_NULL) 
+		if (right == ASE_NULL) 
 		{
-			sse_awk_clrpt (awk, left);
-			return SSE_NULL;
+			ase_awk_clrpt (awk, left);
+			return ASE_NULL;
 		}
 
-		nde = (sse_awk_nde_exp_t*) SSE_AWK_MALLOC (
-			awk, sse_sizeof(sse_awk_nde_exp_t));
-		if (nde == SSE_NULL)
+		nde = (ase_awk_nde_exp_t*) ASE_AWK_MALLOC (
+			awk, ase_sizeof(ase_awk_nde_exp_t));
+		if (nde == ASE_NULL)
 		{
-			sse_awk_clrpt (awk, left);
-			sse_awk_clrpt (awk, right);
-			PANIC (awk, SSE_AWK_ENOMEM);
+			ase_awk_clrpt (awk, left);
+			ase_awk_clrpt (awk, right);
+			PANIC (awk, ASE_AWK_ENOMEM);
 		}
 
-		nde->type = SSE_AWK_NDE_EXP_BIN;
-		nde->next = SSE_NULL;
-		nde->opcode = SSE_AWK_BINOP_CONCAT;
+		nde->type = ASE_AWK_NDE_EXP_BIN;
+		nde->next = ASE_NULL;
+		nde->opcode = ASE_AWK_BINOP_CONCAT;
 		nde->left = left;
 		nde->right = right;
 		
-		left = (sse_awk_nde_t*)nde;
+		left = (ase_awk_nde_t*)nde;
 	}
 
 	return left;
 }
 
-static sse_awk_nde_t* __parse_additive (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_additive (ase_awk_t* awk)
 {
 	static __binmap_t map[] = 
 	{
-		{ TOKEN_PLUS, SSE_AWK_BINOP_PLUS },
-		{ TOKEN_MINUS, SSE_AWK_BINOP_MINUS },
+		{ TOKEN_PLUS, ASE_AWK_BINOP_PLUS },
+		{ TOKEN_MINUS, ASE_AWK_BINOP_MINUS },
 		{ TOKEN_EOF, 0 }
 	};
 
 	return __parse_binary_expr (awk, map, __parse_multiplicative);
 }
 
-static sse_awk_nde_t* __parse_multiplicative (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_multiplicative (ase_awk_t* awk)
 {
 	static __binmap_t map[] = 
 	{
-		{ TOKEN_MUL, SSE_AWK_BINOP_MUL },
-		{ TOKEN_DIV, SSE_AWK_BINOP_DIV },
-		{ TOKEN_MOD, SSE_AWK_BINOP_MOD },
-		{ TOKEN_EXP, SSE_AWK_BINOP_EXP },
+		{ TOKEN_MUL, ASE_AWK_BINOP_MUL },
+		{ TOKEN_DIV, ASE_AWK_BINOP_DIV },
+		{ TOKEN_MOD, ASE_AWK_BINOP_MOD },
+		{ TOKEN_EXP, ASE_AWK_BINOP_EXP },
 		{ TOKEN_EOF, 0 }
 	};
 
 	return __parse_binary_expr (awk, map, __parse_unary);
 }
 
-static sse_awk_nde_t* __parse_unary (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_unary (ase_awk_t* awk)
 {
-	sse_awk_nde_exp_t* nde; 
-	sse_awk_nde_t* left;
+	ase_awk_nde_exp_t* nde; 
+	ase_awk_nde_t* left;
 	int opcode;
 
-	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;
+	opcode = (MATCH(awk,TOKEN_PLUS))?  ASE_AWK_UNROP_PLUS:
+	         (MATCH(awk,TOKEN_MINUS))? ASE_AWK_UNROP_MINUS:
+	         (MATCH(awk,TOKEN_NOT))?   ASE_AWK_UNROP_NOT:
+	         (MATCH(awk,TOKEN_TILDE))? ASE_AWK_UNROP_BNOT: -1;
 
 	if (opcode == -1) return __parse_increment (awk);
 
-	if (__get_token(awk) == -1) return SSE_NULL;
+	if (__get_token(awk) == -1) return ASE_NULL;
 
 	left = __parse_unary (awk);
-	if (left == SSE_NULL) return SSE_NULL;
+	if (left == ASE_NULL) return ASE_NULL;
 
-	nde = (sse_awk_nde_exp_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_exp_t));
-	if (nde == SSE_NULL)
+	nde = (ase_awk_nde_exp_t*) ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_nde_exp_t));
+	if (nde == ASE_NULL)
 	{
-		sse_awk_clrpt (awk, left);
-		PANIC (awk, SSE_AWK_ENOMEM);
+		ase_awk_clrpt (awk, left);
+		PANIC (awk, ASE_AWK_ENOMEM);
 	}
 
-	nde->type = SSE_AWK_NDE_EXP_UNR;
-	nde->next = SSE_NULL;
+	nde->type = ASE_AWK_NDE_EXP_UNR;
+	nde->next = ASE_NULL;
 	nde->opcode = opcode;
 	nde->left = left;
-	nde->right = SSE_NULL;
+	nde->right = ASE_NULL;
 
-	return (sse_awk_nde_t*)nde;
+	return (ase_awk_nde_t*)nde;
 }
 
-static sse_awk_nde_t* __parse_increment (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_increment (ase_awk_t* awk)
 {
-	sse_awk_nde_exp_t* nde;
-	sse_awk_nde_t* left;
+	ase_awk_nde_exp_t* nde;
+	ase_awk_nde_t* left;
 	int type, opcode, opcode1, opcode2;
 
-	opcode1 = MATCH(awk,TOKEN_PLUSPLUS)? SSE_AWK_INCOP_PLUS:
-	          MATCH(awk,TOKEN_MINUSMINUS)? SSE_AWK_INCOP_MINUS: -1;
+	opcode1 = MATCH(awk,TOKEN_PLUSPLUS)? ASE_AWK_INCOP_PLUS:
+	          MATCH(awk,TOKEN_MINUSMINUS)? ASE_AWK_INCOP_MINUS: -1;
 
 	if (opcode1 != -1)
 	{
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 	}
 
 	left = __parse_primary (awk);
-	if (left == SSE_NULL) return SSE_NULL;
+	if (left == ASE_NULL) return ASE_NULL;
 
-	opcode2 = MATCH(awk,TOKEN_PLUSPLUS)? SSE_AWK_INCOP_PLUS:
-	          MATCH(awk,TOKEN_MINUSMINUS)? SSE_AWK_INCOP_MINUS: -1;
+	opcode2 = MATCH(awk,TOKEN_PLUSPLUS)? ASE_AWK_INCOP_PLUS:
+	          MATCH(awk,TOKEN_MINUSMINUS)? ASE_AWK_INCOP_MINUS: -1;
 
 	if (opcode1 != -1 && opcode2 != -1)
 	{
-		sse_awk_clrpt (awk, left);
-		PANIC (awk, SSE_AWK_ELVALUE);
+		ase_awk_clrpt (awk, left);
+		PANIC (awk, ASE_AWK_ELVALUE);
 	}
 	else if (opcode1 == -1 && opcode2 == -1)
 	{
@@ -1923,34 +1923,34 @@ static sse_awk_nde_t* __parse_increment (sse_awk_t* awk)
 	}
 	else if (opcode1 != -1) 
 	{
-		type = SSE_AWK_NDE_EXP_INCPRE;
+		type = ASE_AWK_NDE_EXP_INCPRE;
 		opcode = opcode1;
 	}
 	else if (opcode2 != -1) 
 	{
-		type = SSE_AWK_NDE_EXP_INCPST;
+		type = ASE_AWK_NDE_EXP_INCPST;
 		opcode = opcode2;
 
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 	}
 
-	nde = (sse_awk_nde_exp_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_exp_t));
-	if (nde == SSE_NULL)
+	nde = (ase_awk_nde_exp_t*) ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_nde_exp_t));
+	if (nde == ASE_NULL)
 	{
-		sse_awk_clrpt (awk, left);
-		PANIC (awk, SSE_AWK_ENOMEM);
+		ase_awk_clrpt (awk, left);
+		PANIC (awk, ASE_AWK_ENOMEM);
 	}
 
 	nde->type = type;
-	nde->next = SSE_NULL;
+	nde->next = ASE_NULL;
 	nde->opcode = opcode;
 	nde->left = left;
-	nde->right = SSE_NULL;
+	nde->right = ASE_NULL;
 
-	return (sse_awk_nde_t*)nde;
+	return (ase_awk_nde_t*)nde;
 }
 
-static sse_awk_nde_t* __parse_primary (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_primary (ase_awk_t* awk)
 {
 	if (MATCH(awk,TOKEN_IDENT))  
 	{
@@ -1958,214 +1958,214 @@ static sse_awk_nde_t* __parse_primary (sse_awk_t* awk)
 	}
 	else if (MATCH(awk,TOKEN_INT)) 
 	{
-		sse_awk_nde_int_t* nde;
+		ase_awk_nde_int_t* nde;
 
-		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 = (ase_awk_nde_int_t*) ASE_AWK_MALLOC (
+			awk, ase_sizeof(ase_awk_nde_int_t));
+		if (nde == ASE_NULL) PANIC (awk, ASE_AWK_ENOMEM);
 
-		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)
+		nde->type = ASE_AWK_NDE_INT;
+		nde->next = ASE_NULL;
+		nde->val = ase_awk_strxtolong (awk, 
+			ASE_AWK_STR_BUF(&awk->token.name), 
+			ASE_AWK_STR_LEN(&awk->token.name), 0, ASE_NULL);
+		nde->str = ase_awk_strxdup (awk,
+			ASE_AWK_STR_BUF(&awk->token.name),
+			ASE_AWK_STR_LEN(&awk->token.name));
+		if (nde->str == ASE_NULL)
 		{
-			SSE_AWK_FREE (awk, nde);
-			return SSE_NULL;			
+			ASE_AWK_FREE (awk, nde);
+			return ASE_NULL;			
 		}
-		nde->len = SSE_AWK_STR_LEN(&awk->token.name);
+		nde->len = ASE_AWK_STR_LEN(&awk->token.name);
 
-		sse_awk_assert (awk, 
-			SSE_AWK_STR_LEN(&awk->token.name) ==
-			sse_awk_strlen(SSE_AWK_STR_BUF(&awk->token.name)));
+		ase_awk_assert (awk, 
+			ASE_AWK_STR_LEN(&awk->token.name) ==
+			ase_awk_strlen(ASE_AWK_STR_BUF(&awk->token.name)));
 
 		if (__get_token(awk) == -1) 
 		{
-			SSE_AWK_FREE (awk, nde->str);
-			SSE_AWK_FREE (awk, nde);
-			return SSE_NULL;			
+			ASE_AWK_FREE (awk, nde->str);
+			ASE_AWK_FREE (awk, nde);
+			return ASE_NULL;			
 		}
 
-		return (sse_awk_nde_t*)nde;
+		return (ase_awk_nde_t*)nde;
 	}
 	else if (MATCH(awk,TOKEN_REAL)) 
 	{
-		sse_awk_nde_real_t* nde;
+		ase_awk_nde_real_t* nde;
 
-		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 = (ase_awk_nde_real_t*) ASE_AWK_MALLOC (
+			awk, ase_sizeof(ase_awk_nde_real_t));
+		if (nde == ASE_NULL) PANIC (awk, ASE_AWK_ENOMEM);
 
-		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)
+		nde->type = ASE_AWK_NDE_REAL;
+		nde->next = ASE_NULL;
+		nde->val = ase_awk_strxtoreal (awk, 
+			ASE_AWK_STR_BUF(&awk->token.name), 
+			ASE_AWK_STR_LEN(&awk->token.name), ASE_NULL);
+		nde->str = ase_awk_strxdup (awk,
+			ASE_AWK_STR_BUF(&awk->token.name),
+			ASE_AWK_STR_LEN(&awk->token.name));
+		if (nde->str == ASE_NULL)
 		{
-			SSE_AWK_FREE (awk, nde);
-			return SSE_NULL;			
+			ASE_AWK_FREE (awk, nde);
+			return ASE_NULL;			
 		}
-		nde->len = SSE_AWK_STR_LEN(&awk->token.name);
+		nde->len = ASE_AWK_STR_LEN(&awk->token.name);
 
-		sse_awk_assert (awk, 
-			SSE_AWK_STR_LEN(&awk->token.name) ==
-			sse_awk_strlen(SSE_AWK_STR_BUF(&awk->token.name)));
+		ase_awk_assert (awk, 
+			ASE_AWK_STR_LEN(&awk->token.name) ==
+			ase_awk_strlen(ASE_AWK_STR_BUF(&awk->token.name)));
 
 		if (__get_token(awk) == -1) 
 		{
-			SSE_AWK_FREE (awk, nde->str);
-			SSE_AWK_FREE (awk, nde);
-			return SSE_NULL;			
+			ASE_AWK_FREE (awk, nde->str);
+			ASE_AWK_FREE (awk, nde);
+			return ASE_NULL;			
 		}
 
-		return (sse_awk_nde_t*)nde;
+		return (ase_awk_nde_t*)nde;
 	}
 	else if (MATCH(awk,TOKEN_STR))  
 	{
-		sse_awk_nde_str_t* nde;
+		ase_awk_nde_str_t* nde;
 
-		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 = (ase_awk_nde_str_t*) ASE_AWK_MALLOC (
+			awk, ase_sizeof(ase_awk_nde_str_t));
+		if (nde == ASE_NULL) PANIC (awk, ASE_AWK_ENOMEM);
 
-		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) 
+		nde->type = ASE_AWK_NDE_STR;
+		nde->next = ASE_NULL;
+		nde->len = ASE_AWK_STR_LEN(&awk->token.name);
+		nde->buf = ase_awk_strxdup (
+			awk, ASE_AWK_STR_BUF(&awk->token.name), nde->len);
+		if (nde->buf == ASE_NULL) 
 		{
-			SSE_AWK_FREE (awk, nde);
-			PANIC (awk, SSE_AWK_ENOMEM);
+			ASE_AWK_FREE (awk, nde);
+			PANIC (awk, ASE_AWK_ENOMEM);
 		}
 
 		if (__get_token(awk) == -1) 
 		{
-			SSE_AWK_FREE (awk, nde->buf);
-			SSE_AWK_FREE (awk, nde);
-			return SSE_NULL;			
+			ASE_AWK_FREE (awk, nde->buf);
+			ASE_AWK_FREE (awk, nde);
+			return ASE_NULL;			
 		}
 
-		return (sse_awk_nde_t*)nde;
+		return (ase_awk_nde_t*)nde;
 	}
 	else if (MATCH(awk,TOKEN_DIV))
 	{
-		sse_awk_nde_rex_t* nde;
+		ase_awk_nde_rex_t* nde;
 		int errnum;
 
 		/* the regular expression is tokenized here because 
 		 * of the context-sensitivity of the slash symbol */
 		SET_TOKEN_TYPE (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));
+		ase_awk_str_clear (&awk->token.name);
+		if (__get_rexstr (awk) == -1) return ASE_NULL;
+		ase_awk_assert (awk, MATCH(awk,TOKEN_REX));
 
-		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 = (ase_awk_nde_rex_t*) ASE_AWK_MALLOC (
+			awk, ase_sizeof(ase_awk_nde_rex_t));
+		if (nde == ASE_NULL) PANIC (awk, ASE_AWK_ENOMEM);
 
-		nde->type = SSE_AWK_NDE_REX;
-		nde->next = SSE_NULL;
+		nde->type = ASE_AWK_NDE_REX;
+		nde->next = ASE_NULL;
 
-		nde->len = SSE_AWK_STR_LEN(&awk->token.name);
-		nde->buf = sse_awk_strxdup (
+		nde->len = ASE_AWK_STR_LEN(&awk->token.name);
+		nde->buf = ase_awk_strxdup (
 			awk,
-			SSE_AWK_STR_BUF(&awk->token.name),
-			SSE_AWK_STR_LEN(&awk->token.name));
-		if (nde->buf == SSE_NULL)
+			ASE_AWK_STR_BUF(&awk->token.name),
+			ASE_AWK_STR_LEN(&awk->token.name));
+		if (nde->buf == ASE_NULL)
 		{
-			SSE_AWK_FREE (awk, nde);
-			PANIC (awk, SSE_AWK_ENOMEM);
+			ASE_AWK_FREE (awk, nde);
+			PANIC (awk, ASE_AWK_ENOMEM);
 		}
 
-		nde->code = sse_awk_buildrex (
+		nde->code = ase_awk_buildrex (
 			awk,
-			SSE_AWK_STR_BUF(&awk->token.name), 
-			SSE_AWK_STR_LEN(&awk->token.name), 
+			ASE_AWK_STR_BUF(&awk->token.name), 
+			ASE_AWK_STR_LEN(&awk->token.name), 
 			&errnum);
-		if (nde->code == SSE_NULL)
+		if (nde->code == ASE_NULL)
 		{
-			SSE_AWK_FREE (awk, nde->buf);
-			SSE_AWK_FREE (awk, nde);
+			ASE_AWK_FREE (awk, nde->buf);
+			ASE_AWK_FREE (awk, nde);
 			PANIC (awk, errnum);
 		}
 
 		if (__get_token(awk) == -1) 
 		{
-			SSE_AWK_FREE (awk, nde->buf);
-			SSE_AWK_FREE (awk, nde->code);
-			SSE_AWK_FREE (awk, nde);
-			return SSE_NULL;			
+			ASE_AWK_FREE (awk, nde->buf);
+			ASE_AWK_FREE (awk, nde->code);
+			ASE_AWK_FREE (awk, nde);
+			return ASE_NULL;			
 		}
 
-		return (sse_awk_nde_t*)nde;
+		return (ase_awk_nde_t*)nde;
 	}
 	else if (MATCH(awk,TOKEN_DOLLAR)) 
 	{
-		sse_awk_nde_pos_t* nde;
-		sse_awk_nde_t* prim;
+		ase_awk_nde_pos_t* nde;
+		ase_awk_nde_t* prim;
 
-		if (__get_token(awk)) return SSE_NULL;
+		if (__get_token(awk)) return ASE_NULL;
 		
 		prim = __parse_primary (awk);
-		if (prim == SSE_NULL) return SSE_NULL;
+		if (prim == ASE_NULL) return ASE_NULL;
 
-		nde = (sse_awk_nde_pos_t*) SSE_AWK_MALLOC (
-			awk, sse_sizeof(sse_awk_nde_pos_t));
-		if (nde == SSE_NULL) 
+		nde = (ase_awk_nde_pos_t*) ASE_AWK_MALLOC (
+			awk, ase_sizeof(ase_awk_nde_pos_t));
+		if (nde == ASE_NULL) 
 		{
-			sse_awk_clrpt (awk, prim);
-			PANIC (awk, SSE_AWK_ENOMEM);
+			ase_awk_clrpt (awk, prim);
+			PANIC (awk, ASE_AWK_ENOMEM);
 		}
 
-		nde->type = SSE_AWK_NDE_POS;
-		nde->next = SSE_NULL;
+		nde->type = ASE_AWK_NDE_POS;
+		nde->next = ASE_NULL;
 		nde->val = prim;
 
-		return (sse_awk_nde_t*)nde;
+		return (ase_awk_nde_t*)nde;
 	}
 	else if (MATCH(awk,TOKEN_LPAREN)) 
 	{
-		sse_awk_nde_t* nde;
-		sse_awk_nde_t* last;
+		ase_awk_nde_t* nde;
+		ase_awk_nde_t* last;
 
 		/* eat up the left parenthesis */
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 
 		/* parse the sub-expression inside the parentheses */
 		nde = __parse_expression (awk);
-		if (nde == SSE_NULL) return SSE_NULL;
+		if (nde == ASE_NULL) return ASE_NULL;
 
 		/* parse subsequent expressions separated by a comma, if any */
 		last = nde;
-		sse_awk_assert (awk, last->next == SSE_NULL);
+		ase_awk_assert (awk, last->next == ASE_NULL);
 
 		while (MATCH(awk,TOKEN_COMMA))
 		{
-			sse_awk_nde_t* tmp;
+			ase_awk_nde_t* tmp;
 
 			if (__get_token(awk) == -1) 
 			{
-				sse_awk_clrpt (awk, nde);
-				return SSE_NULL;
+				ase_awk_clrpt (awk, nde);
+				return ASE_NULL;
 			}	
 
 			tmp = __parse_expression (awk);
-			if (tmp == SSE_NULL) 
+			if (tmp == ASE_NULL) 
 			{
-				sse_awk_clrpt (awk, nde);
-				return SSE_NULL;
+				ase_awk_clrpt (awk, nde);
+				return ASE_NULL;
 			}
 
-			sse_awk_assert (awk, tmp->next == SSE_NULL);
+			ase_awk_assert (awk, tmp->next == ASE_NULL);
 			last->next = tmp;
 			last = tmp;
 		} 
@@ -2174,43 +2174,43 @@ static sse_awk_nde_t* __parse_primary (sse_awk_t* awk)
 		/* check for the closing parenthesis */
 		if (!MATCH(awk,TOKEN_RPAREN)) 
 		{
-			sse_awk_clrpt (awk, nde);
-			PANIC (awk, SSE_AWK_ERPAREN);
+			ase_awk_clrpt (awk, nde);
+			PANIC (awk, ASE_AWK_ERPAREN);
 		}
 
 		if (__get_token(awk) == -1) 
 		{
-			sse_awk_clrpt (awk, nde);
-			return SSE_NULL;
+			ase_awk_clrpt (awk, nde);
+			return ASE_NULL;
 		}
 
 		/* check if it is a chained node */
-		if (nde->next != SSE_NULL)
+		if (nde->next != ASE_NULL)
 		{
 			/* if so, it is a expression group */
 			/* (expr1, expr2, expr2) */
 
-			sse_awk_nde_grp_t* tmp;
+			ase_awk_nde_grp_t* tmp;
 
 			if (!MATCH(awk,TOKEN_IN))
 			{
-				sse_awk_clrpt (awk, nde);
-				PANIC (awk, SSE_AWK_EIN);
+				ase_awk_clrpt (awk, nde);
+				PANIC (awk, ASE_AWK_EIN);
 			}
 
-			tmp = (sse_awk_nde_grp_t*) SSE_AWK_MALLOC (
-				awk, sse_sizeof(sse_awk_nde_grp_t));
-			if (tmp == SSE_NULL)
+			tmp = (ase_awk_nde_grp_t*) ASE_AWK_MALLOC (
+				awk, ase_sizeof(ase_awk_nde_grp_t));
+			if (tmp == ASE_NULL)
 			{
-				sse_awk_clrpt (awk, nde);
-				PANIC (awk, SSE_AWK_ENOMEM);
+				ase_awk_clrpt (awk, nde);
+				PANIC (awk, ASE_AWK_ENOMEM);
 			}	
 
-			tmp->type = SSE_AWK_NDE_GRP;
-			tmp->next = SSE_NULL;
+			tmp->type = ASE_AWK_NDE_GRP;
+			tmp->next = ASE_NULL;
 			tmp->body = nde;		
 
-			nde = (sse_awk_nde_t*)tmp;
+			nde = (ase_awk_nde_t*)tmp;
 		}
 		/* ----------------- */
 
@@ -2218,18 +2218,18 @@ static sse_awk_nde_t* __parse_primary (sse_awk_t* awk)
 	}
 	else if (MATCH(awk,TOKEN_GETLINE)) 
 	{
-		sse_awk_nde_getline_t* nde;
-		sse_awk_nde_t* var = SSE_NULL;
-		sse_awk_nde_t* in = SSE_NULL;
+		ase_awk_nde_getline_t* nde;
+		ase_awk_nde_t* var = ASE_NULL;
+		ase_awk_nde_t* in = ASE_NULL;
 
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 
 		if (MATCH(awk,TOKEN_IDENT))
 		{
 			/* getline var */
 			
 			var = __parse_primary (awk);
-			if (var == SSE_NULL) return SSE_NULL;
+			if (var == ASE_NULL) return ASE_NULL;
 		}
 
 		if (MATCH(awk, TOKEN_LT))
@@ -2237,207 +2237,207 @@ static sse_awk_nde_t* __parse_primary (sse_awk_t* awk)
 			/* getline [var] < file */
 			if (__get_token(awk) == -1)
 			{
-				if (var != SSE_NULL) sse_awk_clrpt (awk, var);
-				return SSE_NULL;
+				if (var != ASE_NULL) ase_awk_clrpt (awk, var);
+				return ASE_NULL;
 			}
 
 			/* TODO: is this correct? */
 			/*in = __parse_expression (awk);*/
 			in = __parse_primary (awk);
-			if (in == SSE_NULL)
+			if (in == ASE_NULL)
 			{
-				if (var != SSE_NULL) sse_awk_clrpt (awk, var);
-				return SSE_NULL;
+				if (var != ASE_NULL) ase_awk_clrpt (awk, var);
+				return ASE_NULL;
 			}
 		}
 
-		nde = (sse_awk_nde_getline_t*) SSE_AWK_MALLOC (
-			awk, sse_sizeof(sse_awk_nde_getline_t));
-		if (nde == SSE_NULL)
+		nde = (ase_awk_nde_getline_t*) ASE_AWK_MALLOC (
+			awk, ase_sizeof(ase_awk_nde_getline_t));
+		if (nde == ASE_NULL)
 		{
-			if (var != SSE_NULL) sse_awk_clrpt (awk, var);
-			if (in != SSE_NULL) sse_awk_clrpt (awk, in);
-			PANIC (awk, SSE_AWK_ENOMEM);
+			if (var != ASE_NULL) ase_awk_clrpt (awk, var);
+			if (in != ASE_NULL) ase_awk_clrpt (awk, in);
+			PANIC (awk, ASE_AWK_ENOMEM);
 		}
 
-		nde->type = SSE_AWK_NDE_GETLINE;
-		nde->next = SSE_NULL;
+		nde->type = ASE_AWK_NDE_GETLINE;
+		nde->next = ASE_NULL;
 		nde->var = var;
-		nde->in_type = (in == SSE_NULL)? 
-			SSE_AWK_IN_CONSOLE: SSE_AWK_IN_FILE;
+		nde->in_type = (in == ASE_NULL)? 
+			ASE_AWK_IN_CONSOLE: ASE_AWK_IN_FILE;
 		nde->in = in;
 
-		return (sse_awk_nde_t*)nde;
+		return (ase_awk_nde_t*)nde;
 	}
 
 	/* valid expression introducer is expected */
-	PANIC (awk, SSE_AWK_EEXPRESSION);
+	PANIC (awk, ASE_AWK_EEXPRESSION);
 }
 
-static sse_awk_nde_t* __parse_primary_ident (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_primary_ident (ase_awk_t* awk)
 {
-	sse_char_t* name_dup;
-	sse_size_t name_len;
-	sse_awk_bfn_t* bfn;
+	ase_char_t* name_dup;
+	ase_size_t name_len;
+	ase_awk_bfn_t* bfn;
 
-	sse_awk_assert (awk, MATCH(awk,TOKEN_IDENT));
+	ase_awk_assert (awk, MATCH(awk,TOKEN_IDENT));
 
-	name_dup = sse_awk_strxdup (
+	name_dup = ase_awk_strxdup (
 		awk, 
-		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);
+		ASE_AWK_STR_BUF(&awk->token.name), 
+		ASE_AWK_STR_LEN(&awk->token.name));
+	if (name_dup == ASE_NULL) PANIC (awk, ASE_AWK_ENOMEM);
+	name_len = ASE_AWK_STR_LEN(&awk->token.name);
 
 	if (__get_token(awk) == -1) 
 	{
-		SSE_AWK_FREE (awk, name_dup);
-		return SSE_NULL;			
+		ASE_AWK_FREE (awk, name_dup);
+		return ASE_NULL;			
 	}
 
 	/* check if name_dup is a built-in function name */
-	bfn = sse_awk_getbfn (awk, name_dup, name_len);
-	if (bfn != SSE_NULL)
+	bfn = ase_awk_getbfn (awk, name_dup, name_len);
+	if (bfn != ASE_NULL)
 	{
-		sse_awk_nde_t* nde;
+		ase_awk_nde_t* nde;
 
-		SSE_AWK_FREE (awk, name_dup);
+		ASE_AWK_FREE (awk, name_dup);
 		if (!MATCH(awk,TOKEN_LPAREN))
 		{
 			/* built-in function should be in the form 
 		 	 * of the function call */
-			PANIC (awk, SSE_AWK_ELPAREN);
+			PANIC (awk, ASE_AWK_ELPAREN);
 		}
 
-		nde = __parse_fncall (awk, SSE_NULL, 0, bfn);
-		return (sse_awk_nde_t*)nde;
+		nde = __parse_fncall (awk, ASE_NULL, 0, bfn);
+		return (ase_awk_nde_t*)nde;
 	}
 
 	/* now we know that name_dup is a normal identifier. */
 	if (MATCH(awk,TOKEN_LBRACK)) 
 	{
-		sse_awk_nde_t* nde;
+		ase_awk_nde_t* nde;
 		nde = __parse_hashidx (awk, name_dup, name_len);
-		if (nde == SSE_NULL) SSE_AWK_FREE (awk, name_dup);
-		return (sse_awk_nde_t*)nde;
+		if (nde == ASE_NULL) ASE_AWK_FREE (awk, name_dup);
+		return (ase_awk_nde_t*)nde;
 	}
 	else if (MATCH(awk,TOKEN_LPAREN)) 
 	{
 		/* function call */
-		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;
+		ase_awk_nde_t* nde;
+		nde = __parse_fncall (awk, name_dup, name_len, ASE_NULL);
+		if (nde == ASE_NULL) ASE_AWK_FREE (awk, name_dup);
+		return (ase_awk_nde_t*)nde;
 	}	
 	else 
 	{
 		/* normal variable */
-		sse_awk_nde_var_t* nde;
-		sse_size_t idxa;
+		ase_awk_nde_var_t* nde;
+		ase_size_t idxa;
 
-		nde = (sse_awk_nde_var_t*) SSE_AWK_MALLOC (
-			awk, sse_sizeof(sse_awk_nde_var_t));
-		if (nde == SSE_NULL) 
+		nde = (ase_awk_nde_var_t*) ASE_AWK_MALLOC (
+			awk, ase_sizeof(ase_awk_nde_var_t));
+		if (nde == ASE_NULL) 
 		{
-			SSE_AWK_FREE (awk, name_dup);
-			PANIC (awk, SSE_AWK_ENOMEM);
+			ASE_AWK_FREE (awk, name_dup);
+			PANIC (awk, ASE_AWK_ENOMEM);
 		}
 
 		/* search the parameter name list */
-		idxa = sse_awk_tab_find (
+		idxa = ase_awk_tab_find (
 			&awk->parse.params, 0, name_dup, name_len);
-		if (idxa != (sse_size_t)-1) 
+		if (idxa != (ase_size_t)-1) 
 		{
-			nde->type = SSE_AWK_NDE_ARG;
-			nde->next = SSE_NULL;
-			/*nde->id.name = SSE_NULL;*/
+			nde->type = ASE_AWK_NDE_ARG;
+			nde->next = ASE_NULL;
+			/*nde->id.name = ASE_NULL;*/
 			nde->id.name = name_dup;
 			nde->id.name_len = name_len;
 			nde->id.idxa = idxa;
-			nde->idx = SSE_NULL;
+			nde->idx = ASE_NULL;
 
-			return (sse_awk_nde_t*)nde;
+			return (ase_awk_nde_t*)nde;
 		}
 
 		/* search the local variable list */
-		idxa = sse_awk_tab_rrfind (
+		idxa = ase_awk_tab_rrfind (
 			&awk->parse.locals, 0, name_dup, name_len);
-		if (idxa != (sse_size_t)-1) 
+		if (idxa != (ase_size_t)-1) 
 		{
-			nde->type = SSE_AWK_NDE_LOCAL;
-			nde->next = SSE_NULL;
-			/*nde->id.name = SSE_NULL;*/
+			nde->type = ASE_AWK_NDE_LOCAL;
+			nde->next = ASE_NULL;
+			/*nde->id.name = ASE_NULL;*/
 			nde->id.name = name_dup;
 			nde->id.name_len = name_len;
 			nde->id.idxa = idxa;
-			nde->idx = SSE_NULL;
+			nde->idx = ASE_NULL;
 
-			return (sse_awk_nde_t*)nde;
+			return (ase_awk_nde_t*)nde;
 		}
 
 		/* search the global variable list */
-		idxa = sse_awk_tab_rrfind (
+		idxa = ase_awk_tab_rrfind (
 			&awk->parse.globals, 0, name_dup, name_len);
-		if (idxa != (sse_size_t)-1) 
+		if (idxa != (ase_size_t)-1) 
 		{
-			nde->type = SSE_AWK_NDE_GLOBAL;
-			nde->next = SSE_NULL;
-			/*nde->id.name = SSE_NULL;*/
+			nde->type = ASE_AWK_NDE_GLOBAL;
+			nde->next = ASE_NULL;
+			/*nde->id.name = ASE_NULL;*/
 			nde->id.name = name_dup;
 			nde->id.name_len = name_len;
 			nde->id.idxa = idxa;
-			nde->idx = SSE_NULL;
+			nde->idx = ASE_NULL;
 
-			return (sse_awk_nde_t*)nde;
+			return (ase_awk_nde_t*)nde;
 		}
 
-		if (awk->option & SSE_AWK_IMPLICIT) 
+		if (awk->option & ASE_AWK_IMPLICIT) 
 		{
-			nde->type = SSE_AWK_NDE_NAMED;
-			nde->next = SSE_NULL;
+			nde->type = ASE_AWK_NDE_NAMED;
+			nde->next = ASE_NULL;
 			nde->id.name = name_dup;
 			nde->id.name_len = name_len;
-			nde->id.idxa = (sse_size_t)-1;
-			nde->idx = SSE_NULL;
+			nde->id.idxa = (ase_size_t)-1;
+			nde->idx = ASE_NULL;
 
-			return (sse_awk_nde_t*)nde;
+			return (ase_awk_nde_t*)nde;
 		}
 
 		/* undefined variable */
-		SSE_AWK_FREE (awk, name_dup);
-		SSE_AWK_FREE (awk, nde);
-		PANIC (awk, SSE_AWK_EUNDEF);
+		ASE_AWK_FREE (awk, name_dup);
+		ASE_AWK_FREE (awk, nde);
+		PANIC (awk, ASE_AWK_EUNDEF);
 	}
 }
 
-static sse_awk_nde_t* __parse_hashidx (
-	sse_awk_t* awk, sse_char_t* name, sse_size_t name_len)
+static ase_awk_nde_t* __parse_hashidx (
+	ase_awk_t* awk, ase_char_t* name, ase_size_t name_len)
 {
-	sse_awk_nde_t* idx, * tmp, * last;
-	sse_awk_nde_var_t* nde;
-	sse_size_t idxa;
+	ase_awk_nde_t* idx, * tmp, * last;
+	ase_awk_nde_var_t* nde;
+	ase_size_t idxa;
 
-	idx = SSE_NULL;
-	last = SSE_NULL;
+	idx = ASE_NULL;
+	last = ASE_NULL;
 
 	do
 	{
 		if (__get_token(awk) == -1) 
 		{
-			if (idx != SSE_NULL) sse_awk_clrpt (awk, idx);
-			return SSE_NULL;
+			if (idx != ASE_NULL) ase_awk_clrpt (awk, idx);
+			return ASE_NULL;
 		}
 
 		tmp = __parse_expression (awk);
-		if (tmp == SSE_NULL) 
+		if (tmp == ASE_NULL) 
 		{
-			if (idx != SSE_NULL) sse_awk_clrpt (awk, idx);
-			return SSE_NULL;
+			if (idx != ASE_NULL) ase_awk_clrpt (awk, idx);
+			return ASE_NULL;
 		}
 
-		if (idx == SSE_NULL)
+		if (idx == ASE_NULL)
 		{
-			sse_awk_assert (awk, last == SSE_NULL);
+			ase_awk_assert (awk, last == ASE_NULL);
 			idx = tmp; last = tmp;
 		}
 		else
@@ -2448,106 +2448,106 @@ static sse_awk_nde_t* __parse_hashidx (
 	}
 	while (MATCH(awk,TOKEN_COMMA));
 
-	sse_awk_assert (awk, idx != SSE_NULL);
+	ase_awk_assert (awk, idx != ASE_NULL);
 
 	if (!MATCH(awk,TOKEN_RBRACK)) 
 	{
-		sse_awk_clrpt (awk, idx);
-		PANIC (awk, SSE_AWK_ERBRACK);
+		ase_awk_clrpt (awk, idx);
+		PANIC (awk, ASE_AWK_ERBRACK);
 	}
 
 	if (__get_token(awk) == -1) 
 	{
-		sse_awk_clrpt (awk, idx);
-		return SSE_NULL;
+		ase_awk_clrpt (awk, idx);
+		return ASE_NULL;
 	}
 
-	nde = (sse_awk_nde_var_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_var_t));
-	if (nde == SSE_NULL) 
+	nde = (ase_awk_nde_var_t*) ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_nde_var_t));
+	if (nde == ASE_NULL) 
 	{
-		sse_awk_clrpt (awk, idx);
-		PANIC (awk, SSE_AWK_ENOMEM);
+		ase_awk_clrpt (awk, idx);
+		PANIC (awk, ASE_AWK_ENOMEM);
 	}
 
 	/* search the parameter name list */
-	idxa = sse_awk_tab_find (&awk->parse.params, 0, name, name_len);
-	if (idxa != (sse_size_t)-1) 
+	idxa = ase_awk_tab_find (&awk->parse.params, 0, name, name_len);
+	if (idxa != (ase_size_t)-1) 
 	{
-		nde->type = SSE_AWK_NDE_ARGIDX;
-		nde->next = SSE_NULL;
-		/*nde->id.name = SSE_NULL; */
+		nde->type = ASE_AWK_NDE_ARGIDX;
+		nde->next = ASE_NULL;
+		/*nde->id.name = ASE_NULL; */
 		nde->id.name = name;
 		nde->id.name_len = name_len;
 		nde->id.idxa = idxa;
 		nde->idx = idx;
 
-		return (sse_awk_nde_t*)nde;
+		return (ase_awk_nde_t*)nde;
 	}
 
 	/* search the local variable list */
-	idxa = sse_awk_tab_rrfind(&awk->parse.locals, 0, name, name_len);
-	if (idxa != (sse_size_t)-1) 
+	idxa = ase_awk_tab_rrfind(&awk->parse.locals, 0, name, name_len);
+	if (idxa != (ase_size_t)-1) 
 	{
-		nde->type = SSE_AWK_NDE_LOCALIDX;
-		nde->next = SSE_NULL;
-		/*nde->id.name = SSE_NULL; */
+		nde->type = ASE_AWK_NDE_LOCALIDX;
+		nde->next = ASE_NULL;
+		/*nde->id.name = ASE_NULL; */
 		nde->id.name = name;
 		nde->id.name_len = name_len;
 		nde->id.idxa = idxa;
 		nde->idx = idx;
 
-		return (sse_awk_nde_t*)nde;
+		return (ase_awk_nde_t*)nde;
 	}
 
 	/* search the global variable list */
-	idxa = sse_awk_tab_rrfind(&awk->parse.globals, 0, name, name_len);
-	if (idxa != (sse_size_t)-1) 
+	idxa = ase_awk_tab_rrfind(&awk->parse.globals, 0, name, name_len);
+	if (idxa != (ase_size_t)-1) 
 	{
-		nde->type = SSE_AWK_NDE_GLOBALIDX;
-		nde->next = SSE_NULL;
-		/*nde->id.name = SSE_NULL;*/
+		nde->type = ASE_AWK_NDE_GLOBALIDX;
+		nde->next = ASE_NULL;
+		/*nde->id.name = ASE_NULL;*/
 		nde->id.name = name;
 		nde->id.name_len = name_len;
 		nde->id.idxa = idxa;
 		nde->idx = idx;
 
-		return (sse_awk_nde_t*)nde;
+		return (ase_awk_nde_t*)nde;
 	}
 
-	if (awk->option & SSE_AWK_IMPLICIT) 
+	if (awk->option & ASE_AWK_IMPLICIT) 
 	{
-		nde->type = SSE_AWK_NDE_NAMEDIDX;
-		nde->next = SSE_NULL;
+		nde->type = ASE_AWK_NDE_NAMEDIDX;
+		nde->next = ASE_NULL;
 		nde->id.name = name;
 		nde->id.name_len = name_len;
-		nde->id.idxa = (sse_size_t)-1;
+		nde->id.idxa = (ase_size_t)-1;
 		nde->idx = idx;
 
-		return (sse_awk_nde_t*)nde;
+		return (ase_awk_nde_t*)nde;
 	}
 
 	/* undefined variable */
-	sse_awk_clrpt (awk, idx);
-	SSE_AWK_FREE (awk, nde);
-	PANIC (awk, SSE_AWK_EUNDEF);
+	ase_awk_clrpt (awk, idx);
+	ASE_AWK_FREE (awk, nde);
+	PANIC (awk, ASE_AWK_EUNDEF);
 }
 
-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 ase_awk_nde_t* __parse_fncall (
+	ase_awk_t* awk, ase_char_t* name, ase_size_t name_len, ase_awk_bfn_t* bfn)
 {
-	sse_awk_nde_t* head, * curr, * nde;
-	sse_awk_nde_call_t* call;
-	sse_size_t nargs;
+	ase_awk_nde_t* head, * curr, * nde;
+	ase_awk_nde_call_t* call;
+	ase_size_t nargs;
 
-	if (__get_token(awk) == -1) return SSE_NULL;
+	if (__get_token(awk) == -1) return ASE_NULL;
 	
-	head = curr = SSE_NULL;
+	head = curr = ASE_NULL;
 	nargs = 0;
 
 	if (MATCH(awk,TOKEN_RPAREN)) 
 	{
 		/* no parameters to the function call */
-		if (__get_token(awk) == -1) return SSE_NULL;
+		if (__get_token(awk) == -1) return ASE_NULL;
 	}
 	else 
 	{
@@ -2556,13 +2556,13 @@ static sse_awk_nde_t* __parse_fncall (
 		while (1) 
 		{
 			nde = __parse_expression (awk);
-			if (nde == SSE_NULL) 
+			if (nde == ASE_NULL) 
 			{
-				if (head != SSE_NULL) sse_awk_clrpt (awk, head);
-				return SSE_NULL;
+				if (head != ASE_NULL) ase_awk_clrpt (awk, head);
+				return ASE_NULL;
 			}
 	
-			if (head == SSE_NULL) head = nde;
+			if (head == ASE_NULL) head = nde;
 			else curr->next = nde;
 			curr = nde;
 
@@ -2572,39 +2572,39 @@ static sse_awk_nde_t* __parse_fncall (
 			{
 				if (__get_token(awk) == -1) 
 				{
-					if (head != SSE_NULL) 
-						sse_awk_clrpt (awk, head);
-					return SSE_NULL;
+					if (head != ASE_NULL) 
+						ase_awk_clrpt (awk, head);
+					return ASE_NULL;
 				}
 				break;
 			}
 
 			if (!MATCH(awk,TOKEN_COMMA)) 
 			{
-				if (head != SSE_NULL) sse_awk_clrpt (awk, head);
-				PANIC (awk, SSE_AWK_ECOMMA);	
+				if (head != ASE_NULL) ase_awk_clrpt (awk, head);
+				PANIC (awk, ASE_AWK_ECOMMA);	
 			}
 
 			if (__get_token(awk) == -1) 
 			{
-				if (head != SSE_NULL) sse_awk_clrpt (awk, head);
-				return SSE_NULL;
+				if (head != ASE_NULL) ase_awk_clrpt (awk, head);
+				return ASE_NULL;
 			}
 		}
 
 	}
 
-	call = (sse_awk_nde_call_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_call_t));
-	if (call == SSE_NULL) 
+	call = (ase_awk_nde_call_t*) ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_nde_call_t));
+	if (call == ASE_NULL) 
 	{
-		if (head != SSE_NULL) sse_awk_clrpt (awk, head);
-		PANIC (awk, SSE_AWK_ENOMEM);
+		if (head != ASE_NULL) ase_awk_clrpt (awk, head);
+		PANIC (awk, ASE_AWK_ENOMEM);
 	}
 
-	if (bfn != SSE_NULL)
+	if (bfn != ASE_NULL)
 	{
-		call->type = SSE_AWK_NDE_BFN;
-		call->next = SSE_NULL;
+		call->type = ASE_AWK_NDE_BFN;
+		call->next = ASE_NULL;
 
 		/*call->what.bfn = bfn; */
 		call->what.bfn.name     = bfn->name;
@@ -2619,142 +2619,142 @@ static sse_awk_nde_t* __parse_fncall (
 	}
 	else
 	{
-		call->type = SSE_AWK_NDE_AFN;
-		call->next = SSE_NULL;
+		call->type = ASE_AWK_NDE_AFN;
+		call->next = ASE_NULL;
 		call->what.afn.name = name; 
 		call->what.afn.name_len = name_len;
 		call->args = head;
 		call->nargs = nargs;
 	}
 
-	return (sse_awk_nde_t*)call;
+	return (ase_awk_nde_t*)call;
 }
 
-static sse_awk_nde_t* __parse_if (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_if (ase_awk_t* awk)
 {
-	sse_awk_nde_t* test;
-	sse_awk_nde_t* then_part;
-	sse_awk_nde_t* else_part;
-	sse_awk_nde_if_t* nde;
+	ase_awk_nde_t* test;
+	ase_awk_nde_t* then_part;
+	ase_awk_nde_t* else_part;
+	ase_awk_nde_if_t* nde;
 
-	if (!MATCH(awk,TOKEN_LPAREN)) PANIC (awk, SSE_AWK_ELPAREN);
-	if (__get_token(awk) == -1) return SSE_NULL;
+	if (!MATCH(awk,TOKEN_LPAREN)) PANIC (awk, ASE_AWK_ELPAREN);
+	if (__get_token(awk) == -1) return ASE_NULL;
 
 	test = __parse_expression (awk);
-	if (test == SSE_NULL) return SSE_NULL;
+	if (test == ASE_NULL) return ASE_NULL;
 
 	if (!MATCH(awk,TOKEN_RPAREN)) 
 	{
-		sse_awk_clrpt (awk, test);
-		PANIC (awk, SSE_AWK_ERPAREN);
+		ase_awk_clrpt (awk, test);
+		PANIC (awk, ASE_AWK_ERPAREN);
 	}
 
 	if (__get_token(awk) == -1) 
 	{
-		sse_awk_clrpt (awk, test);
-		return SSE_NULL;
+		ase_awk_clrpt (awk, test);
+		return ASE_NULL;
 	}
 
 	then_part = __parse_statement (awk);
-	if (then_part == SSE_NULL) 
+	if (then_part == ASE_NULL) 
 	{
-		sse_awk_clrpt (awk, test);
-		return SSE_NULL;
+		ase_awk_clrpt (awk, test);
+		return ASE_NULL;
 	}
 
 	if (MATCH(awk,TOKEN_ELSE)) 
 	{
 		if (__get_token(awk) == -1) 
 		{
-			sse_awk_clrpt (awk, then_part);
-			sse_awk_clrpt (awk, test);
-			return SSE_NULL;
+			ase_awk_clrpt (awk, then_part);
+			ase_awk_clrpt (awk, test);
+			return ASE_NULL;
 		}
 
 		else_part = __parse_statement (awk);
-		if (else_part == SSE_NULL) 
+		if (else_part == ASE_NULL) 
 		{
-			sse_awk_clrpt (awk, then_part);
-			sse_awk_clrpt (awk, test);
-			return SSE_NULL;
+			ase_awk_clrpt (awk, then_part);
+			ase_awk_clrpt (awk, test);
+			return ASE_NULL;
 		}
 	}
-	else else_part = SSE_NULL;
+	else else_part = ASE_NULL;
 
-	nde = (sse_awk_nde_if_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_if_t));
-	if (nde == SSE_NULL) 
+	nde = (ase_awk_nde_if_t*) ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_nde_if_t));
+	if (nde == ASE_NULL) 
 	{
-		sse_awk_clrpt (awk, else_part);
-		sse_awk_clrpt (awk, then_part);
-		sse_awk_clrpt (awk, test);
-		PANIC (awk, SSE_AWK_ENOMEM);
+		ase_awk_clrpt (awk, else_part);
+		ase_awk_clrpt (awk, then_part);
+		ase_awk_clrpt (awk, test);
+		PANIC (awk, ASE_AWK_ENOMEM);
 	}
 
-	nde->type = SSE_AWK_NDE_IF;
-	nde->next = SSE_NULL;
+	nde->type = ASE_AWK_NDE_IF;
+	nde->next = ASE_NULL;
 	nde->test = test;
 	nde->then_part = then_part;
 	nde->else_part = else_part;
 
-	return (sse_awk_nde_t*)nde;
+	return (ase_awk_nde_t*)nde;
 }
 
-static sse_awk_nde_t* __parse_while (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_while (ase_awk_t* awk)
 {
-	sse_awk_nde_t* test, * body;
-	sse_awk_nde_while_t* nde;
+	ase_awk_nde_t* test, * body;
+	ase_awk_nde_while_t* nde;
 
-	if (!MATCH(awk,TOKEN_LPAREN)) PANIC (awk, SSE_AWK_ELPAREN);
-	if (__get_token(awk) == -1) return SSE_NULL;
+	if (!MATCH(awk,TOKEN_LPAREN)) PANIC (awk, ASE_AWK_ELPAREN);
+	if (__get_token(awk) == -1) return ASE_NULL;
 
 	test = __parse_expression (awk);
-	if (test == SSE_NULL) return SSE_NULL;
+	if (test == ASE_NULL) return ASE_NULL;
 
 	if (!MATCH(awk,TOKEN_RPAREN)) 
 	{
-		sse_awk_clrpt (awk, test);
-		PANIC (awk, SSE_AWK_ERPAREN);
+		ase_awk_clrpt (awk, test);
+		PANIC (awk, ASE_AWK_ERPAREN);
 	}
 
 	if (__get_token(awk) == -1) 
 	{
-		sse_awk_clrpt (awk, test);
-		return SSE_NULL;
+		ase_awk_clrpt (awk, test);
+		return ASE_NULL;
 	}
 
 	body = __parse_statement (awk);
-	if (body == SSE_NULL) 
+	if (body == ASE_NULL) 
 	{
-		sse_awk_clrpt (awk, test);
-		return SSE_NULL;
+		ase_awk_clrpt (awk, test);
+		return ASE_NULL;
 	}
 
-	nde = (sse_awk_nde_while_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_while_t));
-	if (nde == SSE_NULL) 
+	nde = (ase_awk_nde_while_t*) ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_nde_while_t));
+	if (nde == ASE_NULL) 
 	{
-		sse_awk_clrpt (awk, body);
-		sse_awk_clrpt (awk, test);
-		PANIC (awk, SSE_AWK_ENOMEM);
+		ase_awk_clrpt (awk, body);
+		ase_awk_clrpt (awk, test);
+		PANIC (awk, ASE_AWK_ENOMEM);
 	}
 
-	nde->type = SSE_AWK_NDE_WHILE;
-	nde->next = SSE_NULL;
+	nde->type = ASE_AWK_NDE_WHILE;
+	nde->next = ASE_NULL;
 	nde->test = test;
 	nde->body = body;
 
-	return (sse_awk_nde_t*)nde;
+	return (ase_awk_nde_t*)nde;
 }
 
-static sse_awk_nde_t* __parse_for (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_for (ase_awk_t* awk)
 {
-	sse_awk_nde_t* init, * test, * incr, * body;
-	sse_awk_nde_for_t* nde; 
-	sse_awk_nde_foreach_t* nde2;
+	ase_awk_nde_t* init, * test, * incr, * body;
+	ase_awk_nde_for_t* nde; 
+	ase_awk_nde_foreach_t* nde2;
 
-	if (!MATCH(awk,TOKEN_LPAREN)) PANIC (awk, SSE_AWK_ELPAREN);
-	if (__get_token(awk) == -1) return SSE_NULL;
+	if (!MATCH(awk,TOKEN_LPAREN)) PANIC (awk, ASE_AWK_ELPAREN);
+	if (__get_token(awk) == -1) return ASE_NULL;
 		
-	if (MATCH(awk,TOKEN_SEMICOLON)) init = SSE_NULL;
+	if (MATCH(awk,TOKEN_SEMICOLON)) init = ASE_NULL;
 	else 
 	{
 		/* this line is very ugly. it checks the entire next 
@@ -2763,338 +2763,338 @@ static sse_awk_nde_t* __parse_for (sse_awk_t* awk)
 		int no_foreach = MATCH(awk,TOKEN_LPAREN);
 
 		init = __parse_expression (awk);
-		if (init == SSE_NULL) return SSE_NULL;
+		if (init == ASE_NULL) return ASE_NULL;
 
-		if (!no_foreach && init->type == SSE_AWK_NDE_EXP_BIN &&
-		    ((sse_awk_nde_exp_t*)init)->opcode == SSE_AWK_BINOP_IN &&
-		    __is_plain_var(((sse_awk_nde_exp_t*)init)->left))
+		if (!no_foreach && init->type == ASE_AWK_NDE_EXP_BIN &&
+		    ((ase_awk_nde_exp_t*)init)->opcode == ASE_AWK_BINOP_IN &&
+		    __is_plain_var(((ase_awk_nde_exp_t*)init)->left))
 		{	
 			/* switch to foreach */
 			
 			if (!MATCH(awk,TOKEN_RPAREN))
 			{
-				sse_awk_clrpt (awk, init);
-				PANIC (awk, SSE_AWK_ERPAREN);
+				ase_awk_clrpt (awk, init);
+				PANIC (awk, ASE_AWK_ERPAREN);
 			}
 
 			if (__get_token(awk) == -1) 
 			{
-				sse_awk_clrpt (awk, init);
-				return SSE_NULL;
+				ase_awk_clrpt (awk, init);
+				return ASE_NULL;
 
 			}	
 			
 			body = __parse_statement (awk);
-			if (body == SSE_NULL) 
+			if (body == ASE_NULL) 
 			{
-				sse_awk_clrpt (awk, init);
-				return SSE_NULL;
+				ase_awk_clrpt (awk, init);
+				return ASE_NULL;
 			}
 
-			nde2 = (sse_awk_nde_foreach_t*) SSE_AWK_MALLOC (
-				awk, sse_sizeof(sse_awk_nde_foreach_t));
-			if (nde2 == SSE_NULL)
+			nde2 = (ase_awk_nde_foreach_t*) ASE_AWK_MALLOC (
+				awk, ase_sizeof(ase_awk_nde_foreach_t));
+			if (nde2 == ASE_NULL)
 			{
-				sse_awk_clrpt (awk, init);
-				sse_awk_clrpt (awk, body);
-				PANIC (awk, SSE_AWK_ENOMEM);
+				ase_awk_clrpt (awk, init);
+				ase_awk_clrpt (awk, body);
+				PANIC (awk, ASE_AWK_ENOMEM);
 			}
 
-			nde2->type = SSE_AWK_NDE_FOREACH;
-			nde2->next = SSE_NULL;
+			nde2->type = ASE_AWK_NDE_FOREACH;
+			nde2->next = ASE_NULL;
 			nde2->test = init;
 			nde2->body = body;
 
-			return (sse_awk_nde_t*)nde2;
+			return (ase_awk_nde_t*)nde2;
 		}
 
 		if (!MATCH(awk,TOKEN_SEMICOLON)) 
 		{
-			sse_awk_clrpt (awk, init);
-			PANIC (awk, SSE_AWK_ESEMICOLON);
+			ase_awk_clrpt (awk, init);
+			PANIC (awk, ASE_AWK_ESEMICOLON);
 		}
 	}
 
 	if (__get_token(awk) == -1) 
 	{
-		sse_awk_clrpt (awk, init);
-		return SSE_NULL;
+		ase_awk_clrpt (awk, init);
+		return ASE_NULL;
 	}
 
-	if (MATCH(awk,TOKEN_SEMICOLON)) test = SSE_NULL;
+	if (MATCH(awk,TOKEN_SEMICOLON)) test = ASE_NULL;
 	else 
 	{
 		test = __parse_expression (awk);
-		if (test == SSE_NULL) 
+		if (test == ASE_NULL) 
 		{
-			sse_awk_clrpt (awk, init);
-			return SSE_NULL;
+			ase_awk_clrpt (awk, init);
+			return ASE_NULL;
 		}
 
 		if (!MATCH(awk,TOKEN_SEMICOLON)) 
 		{
-			sse_awk_clrpt (awk, init);
-			sse_awk_clrpt (awk, test);
-			PANIC (awk, SSE_AWK_ESEMICOLON);
+			ase_awk_clrpt (awk, init);
+			ase_awk_clrpt (awk, test);
+			PANIC (awk, ASE_AWK_ESEMICOLON);
 		}
 	}
 
 	if (__get_token(awk) == -1) 
 	{
-		sse_awk_clrpt (awk, init);
-		sse_awk_clrpt (awk, test);
-		return SSE_NULL;
+		ase_awk_clrpt (awk, init);
+		ase_awk_clrpt (awk, test);
+		return ASE_NULL;
 	}
 	
-	if (MATCH(awk,TOKEN_RPAREN)) incr = SSE_NULL;
+	if (MATCH(awk,TOKEN_RPAREN)) incr = ASE_NULL;
 	else 
 	{
 		incr = __parse_expression (awk);
-		if (incr == SSE_NULL) 
+		if (incr == ASE_NULL) 
 		{
-			sse_awk_clrpt (awk, init);
-			sse_awk_clrpt (awk, test);
-			return SSE_NULL;
+			ase_awk_clrpt (awk, init);
+			ase_awk_clrpt (awk, test);
+			return ASE_NULL;
 		}
 
 		if (!MATCH(awk,TOKEN_RPAREN)) 
 		{
-			sse_awk_clrpt (awk, init);
-			sse_awk_clrpt (awk, test);
-			sse_awk_clrpt (awk, incr);
-			PANIC (awk, SSE_AWK_ERPAREN);
+			ase_awk_clrpt (awk, init);
+			ase_awk_clrpt (awk, test);
+			ase_awk_clrpt (awk, incr);
+			PANIC (awk, ASE_AWK_ERPAREN);
 		}
 	}
 
 	if (__get_token(awk) == -1) 
 	{
-		sse_awk_clrpt (awk, init);
-		sse_awk_clrpt (awk, test);
-		sse_awk_clrpt (awk, incr);
-		return SSE_NULL;
+		ase_awk_clrpt (awk, init);
+		ase_awk_clrpt (awk, test);
+		ase_awk_clrpt (awk, incr);
+		return ASE_NULL;
 	}
 
 	body = __parse_statement (awk);
-	if (body == SSE_NULL) 
+	if (body == ASE_NULL) 
 	{
-		sse_awk_clrpt (awk, init);
-		sse_awk_clrpt (awk, test);
-		sse_awk_clrpt (awk, incr);
-		return SSE_NULL;
+		ase_awk_clrpt (awk, init);
+		ase_awk_clrpt (awk, test);
+		ase_awk_clrpt (awk, incr);
+		return ASE_NULL;
 	}
 
-	nde = (sse_awk_nde_for_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_for_t));
-	if (nde == SSE_NULL) 
+	nde = (ase_awk_nde_for_t*) ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_nde_for_t));
+	if (nde == ASE_NULL) 
 	{
-		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);
+		ase_awk_clrpt (awk, init);
+		ase_awk_clrpt (awk, test);
+		ase_awk_clrpt (awk, incr);
+		ase_awk_clrpt (awk, body);
+		PANIC (awk, ASE_AWK_ENOMEM);
 	}
 
-	nde->type = SSE_AWK_NDE_FOR;
-	nde->next = SSE_NULL;
+	nde->type = ASE_AWK_NDE_FOR;
+	nde->next = ASE_NULL;
 	nde->init = init;
 	nde->test = test;
 	nde->incr = incr;
 	nde->body = body;
 
-	return (sse_awk_nde_t*)nde;
+	return (ase_awk_nde_t*)nde;
 }
 
-static sse_awk_nde_t* __parse_dowhile (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_dowhile (ase_awk_t* awk)
 {
-	sse_awk_nde_t* test, * body;
-	sse_awk_nde_while_t* nde;
+	ase_awk_nde_t* test, * body;
+	ase_awk_nde_while_t* nde;
 
 	body = __parse_statement (awk);
-	if (body == SSE_NULL) return SSE_NULL;
+	if (body == ASE_NULL) return ASE_NULL;
 
 	if (!MATCH(awk,TOKEN_WHILE)) 
 	{
-		sse_awk_clrpt (awk, body);
-		PANIC (awk, SSE_AWK_EWHILE);
+		ase_awk_clrpt (awk, body);
+		PANIC (awk, ASE_AWK_EWHILE);
 	}
 
 	if (__get_token(awk) == -1) 
 	{
-		sse_awk_clrpt (awk, body);
-		return SSE_NULL;
+		ase_awk_clrpt (awk, body);
+		return ASE_NULL;
 	}
 
 	if (!MATCH(awk,TOKEN_LPAREN)) 
 	{
-		sse_awk_clrpt (awk, body);
-		PANIC (awk, SSE_AWK_ELPAREN);
+		ase_awk_clrpt (awk, body);
+		PANIC (awk, ASE_AWK_ELPAREN);
 	}
 
 	if (__get_token(awk) == -1) 
 	{
-		sse_awk_clrpt (awk, body);
-		return SSE_NULL;
+		ase_awk_clrpt (awk, body);
+		return ASE_NULL;
 	}
 
 	test = __parse_expression (awk);
-	if (test == SSE_NULL) 
+	if (test == ASE_NULL) 
 	{
-		sse_awk_clrpt (awk, body);
-		return SSE_NULL;
+		ase_awk_clrpt (awk, body);
+		return ASE_NULL;
 	}
 
 	if (!MATCH(awk,TOKEN_RPAREN)) 
 	{
-		sse_awk_clrpt (awk, body);
-		sse_awk_clrpt (awk, test);
-		PANIC (awk, SSE_AWK_ERPAREN);
+		ase_awk_clrpt (awk, body);
+		ase_awk_clrpt (awk, test);
+		PANIC (awk, ASE_AWK_ERPAREN);
 	}
 
 	if (__get_token(awk) == -1) 
 	{
-		sse_awk_clrpt (awk, body);
-		sse_awk_clrpt (awk, test);
-		return SSE_NULL;
+		ase_awk_clrpt (awk, body);
+		ase_awk_clrpt (awk, test);
+		return ASE_NULL;
 	}
 	
-	nde = (sse_awk_nde_while_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_while_t));
-	if (nde == SSE_NULL) 
+	nde = (ase_awk_nde_while_t*) ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_nde_while_t));
+	if (nde == ASE_NULL) 
 	{
-		sse_awk_clrpt (awk, body);
-		sse_awk_clrpt (awk, test);
-		PANIC (awk, SSE_AWK_ENOMEM);
+		ase_awk_clrpt (awk, body);
+		ase_awk_clrpt (awk, test);
+		PANIC (awk, ASE_AWK_ENOMEM);
 	}
 
-	nde->type = SSE_AWK_NDE_DOWHILE;
-	nde->next = SSE_NULL;
+	nde->type = ASE_AWK_NDE_DOWHILE;
+	nde->next = ASE_NULL;
 	nde->test = test;
 	nde->body = body;
 
-	return (sse_awk_nde_t*)nde;
+	return (ase_awk_nde_t*)nde;
 }
 
-static sse_awk_nde_t* __parse_break (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_break (ase_awk_t* awk)
 {
-	sse_awk_nde_break_t* nde;
+	ase_awk_nde_break_t* nde;
 
-	if (awk->parse.depth.loop <= 0) PANIC (awk, SSE_AWK_EBREAK);
+	if (awk->parse.depth.loop <= 0) PANIC (awk, ASE_AWK_EBREAK);
 
-	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;
+	nde = (ase_awk_nde_break_t*) ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_nde_break_t));
+	if (nde == ASE_NULL) PANIC (awk, ASE_AWK_ENOMEM);
+	nde->type = ASE_AWK_NDE_BREAK;
+	nde->next = ASE_NULL;
 	
-	return (sse_awk_nde_t*)nde;
+	return (ase_awk_nde_t*)nde;
 }
 
-static sse_awk_nde_t* __parse_continue (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_continue (ase_awk_t* awk)
 {
-	sse_awk_nde_continue_t* nde;
+	ase_awk_nde_continue_t* nde;
 
-	if (awk->parse.depth.loop <= 0) PANIC (awk, SSE_AWK_ECONTINUE);
+	if (awk->parse.depth.loop <= 0) PANIC (awk, ASE_AWK_ECONTINUE);
 
-	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;
+	nde = (ase_awk_nde_continue_t*) ASE_AWK_MALLOC (
+		awk, ase_sizeof(ase_awk_nde_continue_t));
+	if (nde == ASE_NULL) PANIC (awk, ASE_AWK_ENOMEM);
+	nde->type = ASE_AWK_NDE_CONTINUE;
+	nde->next = ASE_NULL;
 	
-	return (sse_awk_nde_t*)nde;
+	return (ase_awk_nde_t*)nde;
 }
 
-static sse_awk_nde_t* __parse_return (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_return (ase_awk_t* awk)
 {
-	sse_awk_nde_return_t* nde;
-	sse_awk_nde_t* val;
+	ase_awk_nde_return_t* nde;
+	ase_awk_nde_t* val;
 
-	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;
+	nde = (ase_awk_nde_return_t*) ASE_AWK_MALLOC (
+		awk, ase_sizeof(ase_awk_nde_return_t));
+	if (nde == ASE_NULL) PANIC (awk, ASE_AWK_ENOMEM);
+	nde->type = ASE_AWK_NDE_RETURN;
+	nde->next = ASE_NULL;
 
 	if (MATCH(awk,TOKEN_SEMICOLON)) 
 	{
 		/* no return value */
-		val = SSE_NULL;
+		val = ASE_NULL;
 	}
 	else 
 	{
 		val = __parse_expression (awk);
-		if (val == SSE_NULL) 
+		if (val == ASE_NULL) 
 		{
-			SSE_AWK_FREE (awk, nde);
-			return SSE_NULL;
+			ASE_AWK_FREE (awk, nde);
+			return ASE_NULL;
 		}
 	}
 
 	nde->val = val;
-	return (sse_awk_nde_t*)nde;
+	return (ase_awk_nde_t*)nde;
 }
 
-static sse_awk_nde_t* __parse_exit (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_exit (ase_awk_t* awk)
 {
-	sse_awk_nde_exit_t* nde;
-	sse_awk_nde_t* val;
+	ase_awk_nde_exit_t* nde;
+	ase_awk_nde_t* val;
 
-	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;
+	nde = (ase_awk_nde_exit_t*) ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_nde_exit_t));
+	if (nde == ASE_NULL) PANIC (awk, ASE_AWK_ENOMEM);
+	nde->type = ASE_AWK_NDE_EXIT;
+	nde->next = ASE_NULL;
 
 	if (MATCH(awk,TOKEN_SEMICOLON)) 
 	{
 		/* no exit code */
-		val = SSE_NULL;
+		val = ASE_NULL;
 	}
 	else 
 	{
 		val = __parse_expression (awk);
-		if (val == SSE_NULL) 
+		if (val == ASE_NULL) 
 		{
-			SSE_AWK_FREE (awk, nde);
-			return SSE_NULL;
+			ASE_AWK_FREE (awk, nde);
+			return ASE_NULL;
 		}
 	}
 
 	nde->val = val;
-	return (sse_awk_nde_t*)nde;
+	return (ase_awk_nde_t*)nde;
 }
 
-static sse_awk_nde_t* __parse_delete (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_delete (ase_awk_t* awk)
 {
-	sse_awk_nde_delete_t* nde;
-	sse_awk_nde_t* var;
+	ase_awk_nde_delete_t* nde;
+	ase_awk_nde_t* var;
 
-	if (!MATCH(awk,TOKEN_IDENT)) PANIC (awk, SSE_AWK_EIDENT);
+	if (!MATCH(awk,TOKEN_IDENT)) PANIC (awk, ASE_AWK_EIDENT);
 
 	var = __parse_primary_ident (awk);
-	if (var == SSE_NULL) return SSE_NULL;
+	if (var == ASE_NULL) return ASE_NULL;
 
 	if (!__is_var (var))
 	{
 		/* a normal identifier is expected */
-		sse_awk_clrpt (awk, var);
-		PANIC (awk, SSE_AWK_EIDENT);
+		ase_awk_clrpt (awk, var);
+		PANIC (awk, ASE_AWK_EIDENT);
 	}
 
-	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 = (ase_awk_nde_delete_t*) ASE_AWK_MALLOC (
+		awk, ase_sizeof(ase_awk_nde_delete_t));
+	if (nde == ASE_NULL) PANIC (awk, ASE_AWK_ENOMEM);
 
-	nde->type = SSE_AWK_NDE_DELETE;
-	nde->next = SSE_NULL;
+	nde->type = ASE_AWK_NDE_DELETE;
+	nde->next = ASE_NULL;
 	nde->var = var;
 
-	return (sse_awk_nde_t*)nde;
+	return (ase_awk_nde_t*)nde;
 }
 
-static sse_awk_nde_t* __parse_print (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_print (ase_awk_t* awk)
 {
-	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;
+	ase_awk_nde_print_t* nde;
+	ase_awk_nde_t* args = ASE_NULL; 
+	ase_awk_nde_t* args_tail = ASE_NULL;
+	ase_awk_nde_t* tail_prev = ASE_NULL;
+	ase_awk_nde_t* out = ASE_NULL;
 	int out_type;
 
 	if (!MATCH(awk,TOKEN_SEMICOLON) &&
@@ -3104,24 +3104,24 @@ static sse_awk_nde_t* __parse_print (sse_awk_t* awk)
 	    !MATCH(awk,TOKEN_BORAND)) 
 	{
 		args = __parse_expression (awk);
-		if (args == SSE_NULL) return SSE_NULL;
+		if (args == ASE_NULL) return ASE_NULL;
 
 		args_tail = args;
-		tail_prev = SSE_NULL;
+		tail_prev = ASE_NULL;
 
 		while (MATCH(awk,TOKEN_COMMA))
 		{
 			if (__get_token(awk) == -1)
 			{
-				sse_awk_clrpt (awk, args);
-				return SSE_NULL;
+				ase_awk_clrpt (awk, args);
+				return ASE_NULL;
 			}
 
 			args_tail->next = __parse_expression (awk);
-			if (args_tail->next == SSE_NULL)
+			if (args_tail->next == ASE_NULL)
 			{
-				sse_awk_clrpt (awk, args);
-				return SSE_NULL;
+				ase_awk_clrpt (awk, args);
+				return ASE_NULL;
 			}
 
 			tail_prev = args_tail;
@@ -3131,140 +3131,140 @@ static sse_awk_nde_t* __parse_print (sse_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 == SSE_AWK_NDE_EXP_BIN)
+		    args_tail->type == ASE_AWK_NDE_EXP_BIN)
 		{
-			sse_awk_nde_exp_t* ep = (sse_awk_nde_exp_t*)args_tail;
-			if (ep->opcode == SSE_AWK_BINOP_GT)
+			ase_awk_nde_exp_t* ep = (ase_awk_nde_exp_t*)args_tail;
+			if (ep->opcode == ASE_AWK_BINOP_GT)
 			{
-				sse_awk_nde_t* tmp = args_tail;
+				ase_awk_nde_t* tmp = args_tail;
 
-				if (tail_prev != SSE_NULL) 
+				if (tail_prev != ASE_NULL) 
 					tail_prev->next = ep->left;
 				else args = ep->left;
 
 				out = ep->right;
-				out_type = SSE_AWK_OUT_FILE;
+				out_type = ASE_AWK_OUT_FILE;
 
-				SSE_AWK_FREE (awk, tmp);
+				ASE_AWK_FREE (awk, tmp);
 			}
-			else if (ep->opcode == SSE_AWK_BINOP_RSHIFT)
+			else if (ep->opcode == ASE_AWK_BINOP_RSHIFT)
 			{
-				sse_awk_nde_t* tmp = args_tail;
+				ase_awk_nde_t* tmp = args_tail;
 
-				if (tail_prev != SSE_NULL) 
+				if (tail_prev != ASE_NULL) 
 					tail_prev->next = ep->left;
 				else args = ep->left;
 
 				out = ep->right;
-				out_type = SSE_AWK_OUT_FILE_APPEND;
+				out_type = ASE_AWK_OUT_FILE_APPEND;
 
-				SSE_AWK_FREE (awk, tmp);
+				ASE_AWK_FREE (awk, tmp);
 			}
-			else if (ep->opcode == SSE_AWK_BINOP_BOR)
+			else if (ep->opcode == ASE_AWK_BINOP_BOR)
 			{
-				sse_awk_nde_t* tmp = args_tail;
+				ase_awk_nde_t* tmp = args_tail;
 
-				if (tail_prev != SSE_NULL) 
+				if (tail_prev != ASE_NULL) 
 					tail_prev->next = ep->left;
 				else args = ep->left;
 
 				out = ep->right;
-				out_type = SSE_AWK_OUT_PIPE;
+				out_type = ASE_AWK_OUT_PIPE;
 
-				SSE_AWK_FREE (awk, tmp);
+				ASE_AWK_FREE (awk, tmp);
 			}
 		}
 	}
 
-	if (out == SSE_NULL)
+	if (out == ASE_NULL)
 	{
-		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;
+		out_type = MATCH(awk,TOKEN_GT)?     ASE_AWK_OUT_FILE:
+		           MATCH(awk,TOKEN_RSHIFT)? ASE_AWK_OUT_FILE_APPEND:
+		           MATCH(awk,TOKEN_BOR)?    ASE_AWK_OUT_PIPE:
+		           MATCH(awk,TOKEN_BORAND)? ASE_AWK_OUT_COPROC:
+		                                    ASE_AWK_OUT_CONSOLE;
 
-		if (out_type != SSE_AWK_OUT_CONSOLE)
+		if (out_type != ASE_AWK_OUT_CONSOLE)
 		{
 			if (__get_token(awk) == -1)
 			{
-				if (args != SSE_NULL) sse_awk_clrpt (awk, args);
-				return SSE_NULL;
+				if (args != ASE_NULL) ase_awk_clrpt (awk, args);
+				return ASE_NULL;
 			}
 
 			out = __parse_expression(awk);
-			if (out == SSE_NULL)
+			if (out == ASE_NULL)
 			{
-				if (args != SSE_NULL) sse_awk_clrpt (awk, args);
-				return SSE_NULL;
+				if (args != ASE_NULL) ase_awk_clrpt (awk, args);
+				return ASE_NULL;
 			}
 		}
 	}
 
-	nde = (sse_awk_nde_print_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_nde_print_t));
-	if (nde == SSE_NULL) 
+	nde = (ase_awk_nde_print_t*) ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_nde_print_t));
+	if (nde == ASE_NULL) 
 	{
-		if (args != SSE_NULL) sse_awk_clrpt (awk, args);
-		if (out != SSE_NULL) sse_awk_clrpt (awk, out);
-		PANIC (awk, SSE_AWK_ENOMEM);
+		if (args != ASE_NULL) ase_awk_clrpt (awk, args);
+		if (out != ASE_NULL) ase_awk_clrpt (awk, out);
+		PANIC (awk, ASE_AWK_ENOMEM);
 	}
 
-	nde->type = SSE_AWK_NDE_PRINT;
-	nde->next = SSE_NULL;
+	nde->type = ASE_AWK_NDE_PRINT;
+	nde->next = ASE_NULL;
 	nde->args = args;
 	nde->out_type = out_type;
 	nde->out = out;
 
-	return (sse_awk_nde_t*)nde;
+	return (ase_awk_nde_t*)nde;
 }
 
-static sse_awk_nde_t* __parse_printf (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_printf (ase_awk_t* awk)
 {
 	/* TODO: implement this... */
-	return SSE_NULL;
+	return ASE_NULL;
 }
 
-static sse_awk_nde_t* __parse_next (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_next (ase_awk_t* awk)
 {
-	sse_awk_nde_next_t* nde;
+	ase_awk_nde_next_t* nde;
 
 	if (awk->parse.id.block == PARSE_BEGIN_BLOCK ||
 	    awk->parse.id.block == PARSE_END_BLOCK)
 	{
-		PANIC (awk, SSE_AWK_ENEXT);
+		PANIC (awk, ASE_AWK_ENEXT);
 	}
 
-	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;
+	nde = (ase_awk_nde_next_t*) ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_nde_next_t));
+	if (nde == ASE_NULL) PANIC (awk, ASE_AWK_ENOMEM);
+	nde->type = ASE_AWK_NDE_NEXT;
+	nde->next = ASE_NULL;
 	
-	return (sse_awk_nde_t*)nde;
+	return (ase_awk_nde_t*)nde;
 }
 
-static sse_awk_nde_t* __parse_nextfile (sse_awk_t* awk)
+static ase_awk_nde_t* __parse_nextfile (ase_awk_t* awk)
 {
-	sse_awk_nde_nextfile_t* nde;
+	ase_awk_nde_nextfile_t* nde;
 
 	if (awk->parse.id.block == PARSE_BEGIN_BLOCK ||
 	    awk->parse.id.block == PARSE_END_BLOCK)
 	{
-		PANIC (awk, SSE_AWK_ENEXTFILE);
+		PANIC (awk, ASE_AWK_ENEXTFILE);
 	}
 
-	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;
+	nde = (ase_awk_nde_nextfile_t*) ASE_AWK_MALLOC (
+		awk, ase_sizeof(ase_awk_nde_nextfile_t));
+	if (nde == ASE_NULL) PANIC (awk, ASE_AWK_ENOMEM);
+	nde->type = ASE_AWK_NDE_NEXTFILE;
+	nde->next = ASE_NULL;
 	
-	return (sse_awk_nde_t*)nde;
+	return (ase_awk_nde_t*)nde;
 }
 
-static int __get_token (sse_awk_t* awk)
+static int __get_token (ase_awk_t* awk)
 {
-	sse_cint_t c;
-	sse_size_t line;
+	ase_cint_t c;
+	ase_size_t line;
 	int n;
 
 	line = awk->token.line;
@@ -3275,11 +3275,11 @@ static int __get_token (sse_awk_t* awk)
 	} 
 	while (n == 1);
 
-	sse_awk_str_clear (&awk->token.name);
+	ase_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 & SSE_AWK_BLOCKLESS) &&
+	if (line != 0 && (awk->option & ASE_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 (sse_awk_t* awk)
 
 	c = awk->src.lex.curc;
 
-	if (c == SSE_CHAR_EOF) 
+	if (c == ASE_CHAR_EOF) 
 	{
 		SET_TOKEN_TYPE (awk, TOKEN_EOF);
 	}	
-	else if (SSE_AWK_ISDIGIT (awk, c) || c == SSE_T('.'))
+	else if (ASE_AWK_ISDIGIT (awk, c) || c == ASE_T('.'))
 	{
 		if (__get_number (awk) == -1) return -1;
 	}
-	else if (SSE_AWK_ISALPHA (awk, c) || c == SSE_T('_')) 
+	else if (ASE_AWK_ISALPHA (awk, c) || c == ASE_T('_')) 
 	{
 		int type;
 
@@ -3311,21 +3311,21 @@ static int __get_token (sse_awk_t* awk)
 			ADD_TOKEN_CHAR (awk, c);
 			GET_CHAR_TO (awk, c);
 		} 
-		while (SSE_AWK_ISALPHA (awk, c) || 
-		       c == SSE_T('_') || SSE_AWK_ISDIGIT(awk,c));
+		while (ASE_AWK_ISALPHA (awk, c) || 
+		       c == ASE_T('_') || ASE_AWK_ISDIGIT(awk,c));
 
 		type = __classify_ident (awk, 
-			SSE_AWK_STR_BUF(&awk->token.name), 
-			SSE_AWK_STR_LEN(&awk->token.name));
+			ASE_AWK_STR_BUF(&awk->token.name), 
+			ASE_AWK_STR_LEN(&awk->token.name));
 		SET_TOKEN_TYPE (awk, type);
 	}
-	else if (c == SSE_T('\"')) 
+	else if (c == ASE_T('\"')) 
 	{
 		SET_TOKEN_TYPE (awk, TOKEN_STR);
 
 		if (__get_charstr(awk) == -1) return -1;
 
-		while (awk->option & SSE_AWK_STRCONCAT) 
+		while (awk->option & ASE_AWK_STRCONCAT) 
 		{
 			do 
 			{
@@ -3335,17 +3335,17 @@ static int __get_token (sse_awk_t* awk)
 			while (n == 1);
 
 			c = awk->src.lex.curc;
-			if (c != SSE_T('\"')) break;
+			if (c != ASE_T('\"')) break;
 
 			if (__get_charstr(awk) == -1) return -1;
 		}
 
 	}
-	else if (c == SSE_T('=')) 
+	else if (c == ASE_T('=')) 
 	{
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
-		if (c == SSE_T('=')) 
+		if (c == ASE_T('=')) 
 		{
 			SET_TOKEN_TYPE (awk, TOKEN_EQ);
 			ADD_TOKEN_CHAR (awk, c);
@@ -3356,17 +3356,17 @@ static int __get_token (sse_awk_t* awk)
 			SET_TOKEN_TYPE (awk, TOKEN_ASSIGN);
 		}
 	}
-	else if (c == SSE_T('!')) 
+	else if (c == ASE_T('!')) 
 	{
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
-		if (c == SSE_T('=')) 
+		if (c == ASE_T('=')) 
 		{
 			SET_TOKEN_TYPE (awk, TOKEN_NE);
 			ADD_TOKEN_CHAR (awk, c);
 			GET_CHAR_TO (awk, c);
 		}
-		else if (c == SSE_T('~'))
+		else if (c == ASE_T('~'))
 		{
 			SET_TOKEN_TYPE (awk, TOKEN_NM);
 			ADD_TOKEN_CHAR (awk, c);
@@ -3377,17 +3377,17 @@ static int __get_token (sse_awk_t* awk)
 			SET_TOKEN_TYPE (awk, TOKEN_NOT);
 		}
 	}
-	else if (c == SSE_T('>')) 
+	else if (c == ASE_T('>')) 
 	{
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
-		if ((awk->option & SSE_AWK_SHIFT) && c == SSE_T('>')) 
+		if ((awk->option & ASE_AWK_SHIFT) && c == ASE_T('>')) 
 		{
 			SET_TOKEN_TYPE (awk, TOKEN_RSHIFT);
 			ADD_TOKEN_CHAR (awk, c);
 			GET_CHAR_TO (awk, c);
 		}
-		else if (c == SSE_T('=')) 
+		else if (c == ASE_T('=')) 
 		{
 			SET_TOKEN_TYPE (awk, TOKEN_GE);
 			ADD_TOKEN_CHAR (awk, c);
@@ -3398,18 +3398,18 @@ static int __get_token (sse_awk_t* awk)
 			SET_TOKEN_TYPE (awk, TOKEN_GT);
 		}
 	}
-	else if (c == SSE_T('<')) 
+	else if (c == ASE_T('<')) 
 	{
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
 
-		if ((awk->option & SSE_AWK_SHIFT) && c == SSE_T('<')) 
+		if ((awk->option & ASE_AWK_SHIFT) && c == ASE_T('<')) 
 		{
 			SET_TOKEN_TYPE (awk, TOKEN_LSHIFT);
 			ADD_TOKEN_CHAR (awk, c);
 			GET_CHAR_TO (awk, c);
 		}
-		else if (c == SSE_T('=')) 
+		else if (c == ASE_T('=')) 
 		{
 			SET_TOKEN_TYPE (awk, TOKEN_LE);
 			ADD_TOKEN_CHAR (awk, c);
@@ -3420,17 +3420,17 @@ static int __get_token (sse_awk_t* awk)
 			SET_TOKEN_TYPE (awk, TOKEN_LT);
 		}
 	}
-	else if (c == SSE_T('|'))
+	else if (c == ASE_T('|'))
 	{
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
-		if (c == SSE_T('|'))
+		if (c == ASE_T('|'))
 		{
 			SET_TOKEN_TYPE (awk, TOKEN_LOR);
 			ADD_TOKEN_CHAR (awk, c);
 			GET_CHAR_TO (awk, c);
 		}
-		else if (c == SSE_T('&'))
+		else if (c == ASE_T('&'))
 		{
 			SET_TOKEN_TYPE (awk, TOKEN_BORAND);
 			ADD_TOKEN_CHAR (awk, c);
@@ -3441,11 +3441,11 @@ static int __get_token (sse_awk_t* awk)
 			SET_TOKEN_TYPE (awk, TOKEN_BOR);
 		}
 	}
-	else if (c == SSE_T('&'))
+	else if (c == ASE_T('&'))
 	{
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
-		if (c == SSE_T('&'))
+		if (c == ASE_T('&'))
 		{
 			SET_TOKEN_TYPE (awk, TOKEN_LAND);
 			ADD_TOKEN_CHAR (awk, c);
@@ -3456,29 +3456,29 @@ static int __get_token (sse_awk_t* awk)
 			SET_TOKEN_TYPE (awk, TOKEN_BAND);
 		}
 	}
-	else if (c == SSE_T('~'))
+	else if (c == ASE_T('~'))
 	{
 		SET_TOKEN_TYPE (awk, TOKEN_TILDE);
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
 	}
-	else if (c == SSE_T('^'))
+	else if (c == ASE_T('^'))
 	{
 		SET_TOKEN_TYPE (awk, TOKEN_BXOR);
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
 	}
-	else if (c == SSE_T('+')) 
+	else if (c == ASE_T('+')) 
 	{
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
-		if (c == SSE_T('+')) 
+		if (c == ASE_T('+')) 
 		{
 			SET_TOKEN_TYPE (awk, TOKEN_PLUSPLUS);
 			ADD_TOKEN_CHAR (awk, c);
 			GET_CHAR_TO (awk, c);
 		}
-		else if (c == SSE_T('=')) 
+		else if (c == ASE_T('=')) 
 		{
 			SET_TOKEN_TYPE (awk, TOKEN_PLUS_ASSIGN);
 			ADD_TOKEN_CHAR (awk, c);
@@ -3489,17 +3489,17 @@ static int __get_token (sse_awk_t* awk)
 			SET_TOKEN_TYPE (awk, TOKEN_PLUS);
 		}
 	}
-	else if (c == SSE_T('-')) 
+	else if (c == ASE_T('-')) 
 	{
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
-		if (c == SSE_T('-')) 
+		if (c == ASE_T('-')) 
 		{
 			SET_TOKEN_TYPE (awk, TOKEN_MINUSMINUS);
 			ADD_TOKEN_CHAR (awk, c);
 			GET_CHAR_TO (awk, c);
 		}
-		else if (c == SSE_T('=')) 
+		else if (c == ASE_T('=')) 
 		{
 			SET_TOKEN_TYPE (awk, TOKEN_MINUS_ASSIGN);
 			ADD_TOKEN_CHAR (awk, c);
@@ -3510,22 +3510,22 @@ static int __get_token (sse_awk_t* awk)
 			SET_TOKEN_TYPE (awk, TOKEN_MINUS);
 		}
 	}
-	else if (c == SSE_T('*')) 
+	else if (c == ASE_T('*')) 
 	{
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
 
-		if (c == SSE_T('='))
+		if (c == ASE_T('='))
 		{
 			SET_TOKEN_TYPE (awk, TOKEN_MUL_ASSIGN);
 			ADD_TOKEN_CHAR (awk, c);
 			GET_CHAR_TO (awk, c);
 		}
-		else if (c == SSE_T('*'))
+		else if (c == ASE_T('*'))
 		{
 			ADD_TOKEN_CHAR (awk, c);
 			GET_CHAR_TO (awk, c);
-			if (c == SSE_T('='))
+			if (c == ASE_T('='))
 			{
 				SET_TOKEN_TYPE (awk, TOKEN_EXP_ASSIGN);
 				ADD_TOKEN_CHAR (awk, c);
@@ -3541,12 +3541,12 @@ static int __get_token (sse_awk_t* awk)
 			SET_TOKEN_TYPE (awk, TOKEN_MUL);
 		}
 	}
-	else if (c == SSE_T('/')) 
+	else if (c == ASE_T('/')) 
 	{
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
 
-		if (c == SSE_T('='))
+		if (c == ASE_T('='))
 		{
 			SET_TOKEN_TYPE (awk, TOKEN_DIV_ASSIGN);
 			ADD_TOKEN_CHAR (awk, c);
@@ -3557,12 +3557,12 @@ static int __get_token (sse_awk_t* awk)
 			SET_TOKEN_TYPE (awk, TOKEN_DIV);
 		}
 	}
-	else if (c == SSE_T('%')) 
+	else if (c == ASE_T('%')) 
 	{
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
 
-		if (c == SSE_T('='))
+		if (c == ASE_T('='))
 		{
 			SET_TOKEN_TYPE (awk, TOKEN_MOD_ASSIGN);
 			ADD_TOKEN_CHAR (awk, c);
@@ -3573,75 +3573,75 @@ static int __get_token (sse_awk_t* awk)
 			SET_TOKEN_TYPE (awk, TOKEN_MOD);
 		}
 	}
-	else if (c == SSE_T('(')) 
+	else if (c == ASE_T('(')) 
 	{
 		SET_TOKEN_TYPE (awk, TOKEN_LPAREN);
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
 	}
-	else if (c == SSE_T(')')) 
+	else if (c == ASE_T(')')) 
 	{
 		SET_TOKEN_TYPE (awk, TOKEN_RPAREN);
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
 	}
-	else if (c == SSE_T('{')) 
+	else if (c == ASE_T('{')) 
 	{
 		SET_TOKEN_TYPE (awk, TOKEN_LBRACE);
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
 	}
-	else if (c == SSE_T('}')) 
+	else if (c == ASE_T('}')) 
 	{
 		SET_TOKEN_TYPE (awk, TOKEN_RBRACE);
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
 	}
-	else if (c == SSE_T('[')) 
+	else if (c == ASE_T('[')) 
 	{
 		SET_TOKEN_TYPE (awk, TOKEN_LBRACK);
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
 	}
-	else if (c == SSE_T(']')) 
+	else if (c == ASE_T(']')) 
 	{
 		SET_TOKEN_TYPE (awk, TOKEN_RBRACK);
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
 	}
-	else if (c == SSE_T('$')) 
+	else if (c == ASE_T('$')) 
 	{
 		SET_TOKEN_TYPE (awk, TOKEN_DOLLAR);
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
 	}
-	else if (c == SSE_T(',')) 
+	else if (c == ASE_T(',')) 
 	{
 		SET_TOKEN_TYPE (awk, TOKEN_COMMA);
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
 	}
-	else if (c == SSE_T('.'))
+	else if (c == ASE_T('.'))
 	{
 		SET_TOKEN_TYPE (awk, TOKEN_PERIOD);
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
 	}
-	else if (c == SSE_T(';') || 
-	         (c == SSE_T('\n') && (awk->option & SSE_AWK_NEWLINE))) 
+	else if (c == ASE_T(';') || 
+	         (c == ASE_T('\n') && (awk->option & ASE_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 == SSE_T(':'))
+	else if (c == ASE_T(':'))
 	{
 		SET_TOKEN_TYPE (awk, TOKEN_COLON);
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
 	}
-	else if (c == SSE_T('?'))
+	else if (c == ASE_T('?'))
 	{
 		SET_TOKEN_TYPE (awk, TOKEN_QUEST);
 		ADD_TOKEN_CHAR (awk, c);
@@ -3649,29 +3649,29 @@ static int __get_token (sse_awk_t* awk)
 	}
 	else 
 	{
-		awk->errnum = SSE_AWK_ELXCHR;
+		awk->errnum = ASE_AWK_ELXCHR;
 		return -1;
 	}
 
-/*xp_printf (SSE_T("token -> [%s]\n"), SSE_AWK_STR_BUF(&awk->token.name));*/
+/*xp_printf (ASE_T("token -> [%s]\n"), ASE_AWK_STR_BUF(&awk->token.name));*/
 	return 0;
 }
 
-static int __get_number (sse_awk_t* awk)
+static int __get_number (ase_awk_t* awk)
 {
-	sse_cint_t c;
+	ase_cint_t c;
 
-	sse_awk_assert (awk, SSE_AWK_STR_LEN(&awk->token.name) == 0);
+	ase_awk_assert (awk, ASE_AWK_STR_LEN(&awk->token.name) == 0);
 	SET_TOKEN_TYPE (awk, TOKEN_INT);
 
 	c = awk->src.lex.curc;
 
-	if (c == SSE_T('0'))
+	if (c == ASE_T('0'))
 	{
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
 
-		if (c == SSE_T('x') || c == SSE_T('X'))
+		if (c == ASE_T('x') || c == ASE_T('X'))
 		{
 			/* hexadecimal number */
 			do 
@@ -3679,11 +3679,11 @@ static int __get_number (sse_awk_t* awk)
 				ADD_TOKEN_CHAR (awk, c);
 				GET_CHAR_TO (awk, c);
 			} 
-			while (SSE_AWK_ISXDIGIT (awk, c));
+			while (ASE_AWK_ISXDIGIT (awk, c));
 
 			return 0;
 		}
-		else if (c == SSE_T('b') || c == SSE_T('B'))
+		else if (c == ASE_T('b') || c == ASE_T('B'))
 		{
 			/* binary number */
 			do
@@ -3691,14 +3691,14 @@ static int __get_number (sse_awk_t* awk)
 				ADD_TOKEN_CHAR (awk, c);
 				GET_CHAR_TO (awk, c);
 			} 
-			while (c == SSE_T('0') || c == SSE_T('1'));
+			while (c == ASE_T('0') || c == ASE_T('1'));
 
 			return 0;
 		}
 		else if (c != '.')
 		{
 			/* octal number */
-			while (c >= SSE_T('0') && c <= SSE_T('7'))
+			while (c >= ASE_T('0') && c <= ASE_T('7'))
 			{
 				ADD_TOKEN_CHAR (awk, c);
 				GET_CHAR_TO (awk, c);
@@ -3708,13 +3708,13 @@ static int __get_number (sse_awk_t* awk)
 		}
 	}
 
-	while (SSE_AWK_ISDIGIT (awk, c)) 
+	while (ASE_AWK_ISDIGIT (awk, c)) 
 	{
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
 	} 
 
-	if (c == SSE_T('.'))
+	if (c == ASE_T('.'))
 	{
 		/* floating-point number */
 		SET_TOKEN_TYPE (awk, TOKEN_REAL);
@@ -3722,27 +3722,27 @@ static int __get_number (sse_awk_t* awk)
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
 
-		while (SSE_AWK_ISDIGIT (awk, c))
+		while (ASE_AWK_ISDIGIT (awk, c))
 		{
 			ADD_TOKEN_CHAR (awk, c);
 			GET_CHAR_TO (awk, c);
 		}
 	}
 
-	if (c == SSE_T('E') || c == SSE_T('e'))
+	if (c == ASE_T('E') || c == ASE_T('e'))
 	{
 		SET_TOKEN_TYPE (awk, TOKEN_REAL);
 
 		ADD_TOKEN_CHAR (awk, c);
 		GET_CHAR_TO (awk, c);
 
-		if (c == SSE_T('+') || c == SSE_T('-'))
+		if (c == ASE_T('+') || c == ASE_T('-'))
 		{
 			ADD_TOKEN_CHAR (awk, c);
 			GET_CHAR_TO (awk, c);
 		}
 
-		while (SSE_AWK_ISDIGIT (awk, c))
+		while (ASE_AWK_ISDIGIT (awk, c))
 		{
 			ADD_TOKEN_CHAR (awk, c);
 			GET_CHAR_TO (awk, c);
@@ -3752,20 +3752,20 @@ static int __get_number (sse_awk_t* awk)
 	return 0;
 }
 
-static int __get_charstr (sse_awk_t* awk)
+static int __get_charstr (ase_awk_t* awk)
 {
-	if (awk->src.lex.curc != SSE_T('\"')) 
+	if (awk->src.lex.curc != ASE_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, SSE_T('\"'), SSE_T('\\'), sse_false);
+	return __get_string (awk, ASE_T('\"'), ASE_T('\\'), ase_false);
 }
 
-static int __get_rexstr (sse_awk_t* awk)
+static int __get_rexstr (ase_awk_t* awk)
 {
-	if (awk->src.lex.curc == SSE_T('/')) 
+	if (awk->src.lex.curc == ASE_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 (sse_awk_t* awk)
 	else 
 	{
 		ADD_TOKEN_CHAR (awk, awk->src.lex.curc);
-		return __get_string (awk, SSE_T('/'), SSE_T('\\'), sse_true);
+		return __get_string (awk, ASE_T('/'), ASE_T('\\'), ase_true);
 	}
 }
 
 static int __get_string (
-	sse_awk_t* awk, sse_char_t end_char, 
-	sse_char_t esc_char, sse_bool_t keep_esc_char)
+	ase_awk_t* awk, ase_char_t end_char, 
+	ase_char_t esc_char, ase_bool_t keep_esc_char)
 {
-	sse_cint_t c;
+	ase_cint_t c;
 	int escaped = 0;
 	int digit_count = 0;
-	sse_cint_t c_acc;
+	ase_cint_t c_acc;
 
 	while (1)
 	{
 		GET_CHAR_TO (awk, c);
 
-		if (c == SSE_CHAR_EOF)
+		if (c == ASE_CHAR_EOF)
 		{
-			awk->errnum = SSE_AWK_EENDSTR;
+			awk->errnum = ASE_AWK_EENDSTR;
 			return -1;
 		}
 
 		if (escaped == 3)
 		{
-			if (c >= SSE_T('0') && c <= SSE_T('7'))
+			if (c >= ASE_T('0') && c <= ASE_T('7'))
 			{
-				c_acc = c_acc * 8 + c - SSE_T('0');
+				c_acc = c_acc * 8 + c - ASE_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 >= SSE_T('0') && c <= SSE_T('9'))
+			if (c >= ASE_T('0') && c <= ASE_T('9'))
 			{
-				c_acc = c_acc * 16 + c - SSE_T('0');
+				c_acc = c_acc * 16 + c - ASE_T('0');
 				digit_count++;
 				if (digit_count >= escaped) 
 				{
@@ -3830,9 +3830,9 @@ static int __get_string (
 				}
 				continue;
 			}
-			else if (c >= SSE_T('A') && c <= SSE_T('F'))
+			else if (c >= ASE_T('A') && c <= ASE_T('F'))
 			{
-				c_acc = c_acc * 16 + c - SSE_T('A') + 10;
+				c_acc = c_acc * 16 + c - ASE_T('A') + 10;
 				digit_count++;
 				if (digit_count >= escaped) 
 				{
@@ -3841,9 +3841,9 @@ static int __get_string (
 				}
 				continue;
 			}
-			else if (c >= SSE_T('a') && c <= SSE_T('f'))
+			else if (c >= ASE_T('a') && c <= ASE_T('f'))
 			{
-				c_acc = c_acc * 16 + c - SSE_T('a') + 10;
+				c_acc = c_acc * 16 + c - ASE_T('a') + 10;
 				digit_count++;
 				if (digit_count >= escaped) 
 				{
@@ -3854,10 +3854,10 @@ static int __get_string (
 			}
 			else
 			{
-				sse_char_t rc;
+				ase_char_t rc;
 
-				rc = (escaped == 2)? SSE_T('x'):
-				     (escaped == 4)? SSE_T('u'): SSE_T('U');
+				rc = (escaped == 2)? ASE_T('x'):
+				     (escaped == 4)? ASE_T('u'): ASE_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 == 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')) 
+			if (c == ASE_T('n')) c = ASE_T('\n');
+			else if (c == ASE_T('r')) c = ASE_T('\r');
+			else if (c == ASE_T('t')) c = ASE_T('\t');
+			else if (c == ASE_T('f')) c = ASE_T('\f');
+			else if (c == ASE_T('b')) c = ASE_T('\b');
+			else if (c == ASE_T('v')) c = ASE_T('\v');
+			else if (c == ASE_T('a')) c = ASE_T('\a');
+			else if (c >= ASE_T('0') && c <= ASE_T('7')) 
 			{
 				escaped = 3;
 				digit_count = 1;
-				c_acc = c - SSE_T('0');
+				c_acc = c - ASE_T('0');
 				continue;
 			}
-			else if (c == SSE_T('x')) 
+			else if (c == ASE_T('x')) 
 			{
 				escaped = 2;
 				digit_count = 0;
 				c_acc = 0;
 				continue;
 			}
-		#ifdef SSE_CHAR_IS_WCHAR
-			else if (c == SSE_T('u') && sse_sizeof(sse_char_t) >= 2) 
+		#ifdef ASE_CHAR_IS_WCHAR
+			else if (c == ASE_T('u') && ase_sizeof(ase_char_t) >= 2) 
 			{
 				escaped = 4;
 				digit_count = 0;
 				c_acc = 0;
 				continue;
 			}
-			else if (c == SSE_T('U') && sse_sizeof(sse_char_t) >= 4) 
+			else if (c == ASE_T('U') && ase_sizeof(ase_char_t) >= 4) 
 			{
 				escaped = 8;
 				digit_count = 0;
@@ -3932,10 +3932,10 @@ static int __get_string (
 	return 0;
 }
 
-static int __get_char (sse_awk_t* awk)
+static int __get_char (ase_awk_t* awk)
 {
-	sse_ssize_t n;
-	/*sse_char_t c;*/
+	ase_ssize_t n;
+	/*ase_char_t c;*/
 
 	if (awk->src.lex.ungotc_count > 0) 
 	{
@@ -3946,17 +3946,17 @@ static int __get_char (sse_awk_t* awk)
 	if (awk->src.shared.buf_pos >= awk->src.shared.buf_len)
 	{
 		n = awk->src.ios->in (
-			SSE_AWK_IO_READ, awk->src.ios->custom_data,
-			awk->src.shared.buf, sse_countof(awk->src.shared.buf));
+			ASE_AWK_IO_READ, awk->src.ios->custom_data,
+			awk->src.shared.buf, ase_countof(awk->src.shared.buf));
 		if (n == -1)
 		{
-			awk->errnum = SSE_AWK_ESRCINREAD;
+			awk->errnum = ASE_AWK_ESRCINREAD;
 			return -1;
 		}
 
 		if (n == 0) 
 		{
-			awk->src.lex.curc = SSE_CHAR_EOF;
+			awk->src.lex.curc = ASE_CHAR_EOF;
 			return 0;
 		}
 
@@ -3966,7 +3966,7 @@ static int __get_char (sse_awk_t* awk)
 
 	awk->src.lex.curc = awk->src.shared.buf[awk->src.shared.buf_pos++];
 
-	if (awk->src.lex.curc == SSE_T('\n'))
+	if (awk->src.lex.curc == ASE_T('\n'))
 	{
 		awk->src.lex.line++;
 		awk->src.lex.column = 1;
@@ -3976,11 +3976,11 @@ static int __get_char (sse_awk_t* awk)
 	return 0;
 }
 
-static int __unget_char (sse_awk_t* awk, sse_cint_t c)
+static int __unget_char (ase_awk_t* awk, ase_cint_t c)
 {
-	if (awk->src.lex.ungotc_count >= sse_countof(awk->src.lex.ungotc)) 
+	if (awk->src.lex.ungotc_count >= ase_countof(awk->src.lex.ungotc)) 
 	{
-		awk->errnum = SSE_AWK_ELXUNG;
+		awk->errnum = ASE_AWK_ELXUNG;
 		return -1;
 	}
 
@@ -3988,73 +3988,73 @@ static int __unget_char (sse_awk_t* awk, sse_cint_t c)
 	return 0;
 }
 
-static int __skip_spaces (sse_awk_t* awk)
+static int __skip_spaces (ase_awk_t* awk)
 {
-	sse_cint_t c = awk->src.lex.curc;
+	ase_cint_t c = awk->src.lex.curc;
 
-	if (awk->option & SSE_AWK_NEWLINE && awk->parse.nl_semicolon)
+	if (awk->option & ASE_AWK_NEWLINE && awk->parse.nl_semicolon)
 	{
-		while (c != SSE_T('\n') &&
-		       SSE_AWK_ISSPACE (awk, c)) GET_CHAR_TO (awk, c);
+		while (c != ASE_T('\n') &&
+		       ASE_AWK_ISSPACE (awk, c)) GET_CHAR_TO (awk, c);
 	}
 	else
 	{
-		while (SSE_AWK_ISSPACE (awk, c)) GET_CHAR_TO (awk, c);
+		while (ASE_AWK_ISSPACE (awk, c)) GET_CHAR_TO (awk, c);
 	}
 	return 0;
 }
 
-static int __skip_comment (sse_awk_t* awk)
+static int __skip_comment (ase_awk_t* awk)
 {
-	sse_cint_t c = awk->src.lex.curc;
+	ase_cint_t c = awk->src.lex.curc;
 
-	if ((awk->option & SSE_AWK_HASHSIGN) && c == SSE_T('#'))
+	if ((awk->option & ASE_AWK_HASHSIGN) && c == ASE_T('#'))
 	{
 		do 
 		{ 
 			GET_CHAR_TO (awk, c);
 		} 
-		while (c != SSE_T('\n') && c != SSE_CHAR_EOF);
+		while (c != ASE_T('\n') && c != ASE_CHAR_EOF);
 
 		GET_CHAR (awk);
 		return 1; /* comment by # */
 	}
 
-	if (c != SSE_T('/')) return 0; /* not a comment */
+	if (c != ASE_T('/')) return 0; /* not a comment */
 	GET_CHAR_TO (awk, c);
 
-	if ((awk->option & SSE_AWK_DBLSLASHES) && c == SSE_T('/')) 
+	if ((awk->option & ASE_AWK_DBLSLASHES) && c == ASE_T('/')) 
 	{
 		do 
 		{ 
 			GET_CHAR_TO (awk, c);
 		} 
-		while (c != SSE_T('\n') && c != SSE_CHAR_EOF);
+		while (c != ASE_T('\n') && c != ASE_CHAR_EOF);
 
 		GET_CHAR (awk);
 		return 1; /* comment by // */
 	}
-	else if (c == SSE_T('*')) 
+	else if (c == ASE_T('*')) 
 	{
 		do 
 		{
 			GET_CHAR_TO (awk, c);
-			if (c == SSE_CHAR_EOF)
+			if (c == ASE_CHAR_EOF)
 			{
-				awk->errnum = SSE_AWK_EENDCOMMENT;
+				awk->errnum = ASE_AWK_EENDCOMMENT;
 				return -1;
 			}
 
-			if (c == SSE_T('*')) 
+			if (c == ASE_T('*')) 
 			{
 				GET_CHAR_TO (awk, c);
-				if (c == SSE_CHAR_EOF)
+				if (c == ASE_CHAR_EOF)
 				{
-					awk->errnum = SSE_AWK_EENDCOMMENT;
+					awk->errnum = ASE_AWK_EENDCOMMENT;
 					return -1;
 				}
 
-				if (c == SSE_T('/')) 
+				if (c == ASE_T('/')) 
 				{
 					GET_CHAR_TO (awk, c);
 					break;
@@ -4067,22 +4067,22 @@ static int __skip_comment (sse_awk_t* awk)
 	}
 
 	if (__unget_char(awk,c) == -1) return -1; /* error */
-	awk->src.lex.curc = SSE_T('/');
+	awk->src.lex.curc = ASE_T('/');
 
 	return 0;
 }
 
 static int __classify_ident (
-	sse_awk_t* awk, const sse_char_t* name, sse_size_t len)
+	ase_awk_t* awk, const ase_char_t* name, ase_size_t len)
 {
 	struct __kwent* kwp;
 
-	for (kwp = __kwtab; kwp->name != SSE_NULL; kwp++) 
+	for (kwp = __kwtab; kwp->name != ASE_NULL; kwp++) 
 	{
 		if (kwp->valid != 0 && 
 		    (awk->option & kwp->valid) == 0) continue;
 
-		if (sse_awk_strxncmp (kwp->name, kwp->name_len, name, len) == 0) 
+		if (ase_awk_strxncmp (kwp->name, kwp->name_len, name, len) == 0) 
 		{
 			return kwp->type;
 		}
@@ -4091,17 +4091,17 @@ static int __classify_ident (
 	return TOKEN_IDENT;
 }
 
-static int __assign_to_opcode (sse_awk_t* awk)
+static int __assign_to_opcode (ase_awk_t* awk)
 {
 	static int __assop[] =
 	{
-		SSE_AWK_ASSOP_NONE,
-		SSE_AWK_ASSOP_PLUS,
-		SSE_AWK_ASSOP_MINUS,
-		SSE_AWK_ASSOP_MUL,
-		SSE_AWK_ASSOP_DIV,
-		SSE_AWK_ASSOP_MOD,
-		SSE_AWK_ASSOP_EXP
+		ASE_AWK_ASSOP_NONE,
+		ASE_AWK_ASSOP_PLUS,
+		ASE_AWK_ASSOP_MINUS,
+		ASE_AWK_ASSOP_MUL,
+		ASE_AWK_ASSOP_DIV,
+		ASE_AWK_ASSOP_MOD,
+		ASE_AWK_ASSOP_EXP
 	};
 
 	if (awk->token.type >= TOKEN_ASSIGN &&
@@ -4113,50 +4113,50 @@ static int __assign_to_opcode (sse_awk_t* awk)
 	return -1;
 }
 
-static int __is_plain_var (sse_awk_nde_t* nde)
+static int __is_plain_var (ase_awk_nde_t* nde)
 {
-	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;
+	return nde->type == ASE_AWK_NDE_GLOBAL ||
+	       nde->type == ASE_AWK_NDE_LOCAL ||
+	       nde->type == ASE_AWK_NDE_ARG ||
+	       nde->type == ASE_AWK_NDE_NAMED;
 }
 
-static int __is_var (sse_awk_nde_t* nde)
+static int __is_var (ase_awk_nde_t* nde)
 {
-	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;
+	return nde->type == ASE_AWK_NDE_GLOBAL ||
+	       nde->type == ASE_AWK_NDE_LOCAL ||
+	       nde->type == ASE_AWK_NDE_ARG ||
+	       nde->type == ASE_AWK_NDE_NAMED ||
+	       nde->type == ASE_AWK_NDE_GLOBALIDX ||
+	       nde->type == ASE_AWK_NDE_LOCALIDX ||
+	       nde->type == ASE_AWK_NDE_ARGIDX ||
+	       nde->type == ASE_AWK_NDE_NAMEDIDX;
 }
 
 struct __deparse_func_t 
 {
-	sse_awk_t* awk;
-	sse_char_t* tmp;
-	sse_size_t tmp_len;
+	ase_awk_t* awk;
+	ase_char_t* tmp;
+	ase_size_t tmp_len;
 };
 
-static int __deparse (sse_awk_t* awk)
+static int __deparse (ase_awk_t* awk)
 {
-	sse_awk_chain_t* chain;
-	sse_char_t tmp[sse_sizeof(sse_size_t)*8 + 32];
+	ase_awk_chain_t* chain;
+	ase_char_t tmp[ase_sizeof(ase_size_t)*8 + 32];
 	struct __deparse_func_t df;
 	int n = 0, op;
 
-	sse_awk_assert (awk, awk->src.ios->out != SSE_NULL);
+	ase_awk_assert (awk, awk->src.ios->out != ASE_NULL);
 
 	awk->src.shared.buf_len = 0;
 	awk->src.shared.buf_pos = 0;
 
 	op = awk->src.ios->out (
-		SSE_AWK_IO_OPEN, awk->src.ios->custom_data, SSE_NULL, 0);
+		ASE_AWK_IO_OPEN, awk->src.ios->custom_data, ASE_NULL, 0);
 	if (op == -1)
 	{
-		awk->errnum = SSE_AWK_ESRCOUTOPEN;
+		awk->errnum = ASE_AWK_ESRCOUTOPEN;
 		return -1;
 	}
 
@@ -4182,97 +4182,97 @@ static int __deparse (sse_awk_t* awk)
 
 	if (awk->tree.nglobals > awk->tree.nbglobals) 
 	{
-		sse_size_t i, len;
+		ase_size_t i, len;
 
-		sse_awk_assert (awk, awk->tree.nglobals > 0);
-		if (sse_awk_putsrcstr (awk, SSE_T("global ")) == -1)
-			EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
+		ase_awk_assert (awk, awk->tree.nglobals > 0);
+		if (ase_awk_putsrcstr (awk, ASE_T("global ")) == -1)
+			EXIT_DEPARSE (ASE_AWK_ESRCOUTWRITE);
 
 		for (i = awk->tree.nbglobals; i < awk->tree.nglobals - 1; i++) 
 		{
-			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 = ase_awk_longtostr ((ase_long_t)i, 
+				10, ASE_T("__global"), tmp, ase_countof(tmp));
+			ase_awk_assert (awk, len != (ase_size_t)-1);
+			if (ase_awk_putsrcstrx (awk, tmp, len) == -1)
+				EXIT_DEPARSE (ASE_AWK_ESRCOUTWRITE);
+			if (ase_awk_putsrcstr (awk, ASE_T(", ")) == -1)
+				EXIT_DEPARSE (ASE_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);
+		len = ase_awk_longtostr ((ase_long_t)i, 
+			10, ASE_T("__global"), tmp, ase_countof(tmp));
+		ase_awk_assert (awk, len != (ase_size_t)-1);
+		if (ase_awk_putsrcstrx (awk, tmp, len) == -1)
+			EXIT_DEPARSE (ASE_AWK_ESRCOUTWRITE);
+		if (ase_awk_putsrcstr (awk, ASE_T(";\n\n")) == -1)
+			EXIT_DEPARSE (ASE_AWK_ESRCOUTWRITE);
 	}
 
 	df.awk = awk;
 	df.tmp = tmp;
-	df.tmp_len = sse_countof(tmp);
+	df.tmp_len = ase_countof(tmp);
 
-	if (sse_awk_map_walk (&awk->tree.afns, __deparse_func, &df) == -1) 
+	if (ase_awk_map_walk (&awk->tree.afns, __deparse_func, &df) == -1) 
 	{
-		EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
+		EXIT_DEPARSE (ASE_AWK_ESRCOUTWRITE);
 	}
 
-	if (awk->tree.begin != SSE_NULL) 
+	if (awk->tree.begin != ASE_NULL) 
 	{
-		if (sse_awk_putsrcstr (awk, SSE_T("BEGIN ")) == -1)
-			EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
+		if (ase_awk_putsrcstr (awk, ASE_T("BEGIN ")) == -1)
+			EXIT_DEPARSE (ASE_AWK_ESRCOUTWRITE);
 
-		if (sse_awk_prnpt (awk, awk->tree.begin) == -1)
-			EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
+		if (ase_awk_prnpt (awk, awk->tree.begin) == -1)
+			EXIT_DEPARSE (ASE_AWK_ESRCOUTWRITE);
 
-		if (__put_char (awk, SSE_T('\n')) == -1)
-			EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
+		if (__put_char (awk, ASE_T('\n')) == -1)
+			EXIT_DEPARSE (ASE_AWK_ESRCOUTWRITE);
 	}
 
 	chain = awk->tree.chain;
-	while (chain != SSE_NULL) 
+	while (chain != ASE_NULL) 
 	{
-		if (chain->pattern != SSE_NULL) 
+		if (chain->pattern != ASE_NULL) 
 		{
-			if (sse_awk_prnptnpt (awk, chain->pattern) == -1)
-				EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
+			if (ase_awk_prnptnpt (awk, chain->pattern) == -1)
+				EXIT_DEPARSE (ASE_AWK_ESRCOUTWRITE);
 		}
 
-		if (chain->action == SSE_NULL) 
+		if (chain->action == ASE_NULL) 
 		{
 			/* blockless pattern */
-			if (__put_char (awk, SSE_T('\n')) == -1)
-				EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
+			if (__put_char (awk, ASE_T('\n')) == -1)
+				EXIT_DEPARSE (ASE_AWK_ESRCOUTWRITE);
 		}
 		else 
 		{
-			if (sse_awk_prnpt (awk, chain->action) == -1)
-				EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
+			if (ase_awk_prnpt (awk, chain->action) == -1)
+				EXIT_DEPARSE (ASE_AWK_ESRCOUTWRITE);
 		}
 
-		if (__put_char (awk, SSE_T('\n')) == -1)
-			EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
+		if (__put_char (awk, ASE_T('\n')) == -1)
+			EXIT_DEPARSE (ASE_AWK_ESRCOUTWRITE);
 
 		chain = chain->next;	
 	}
 
-	if (awk->tree.end != SSE_NULL) 
+	if (awk->tree.end != ASE_NULL) 
 	{
-		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 (ase_awk_putsrcstr (awk, ASE_T("END ")) == -1)
+			EXIT_DEPARSE (ASE_AWK_ESRCOUTWRITE);
+		if (ase_awk_prnpt (awk, awk->tree.end) == -1)
+			EXIT_DEPARSE (ASE_AWK_ESRCOUTWRITE);
 	}
 
-	if (__flush (awk) == -1) EXIT_DEPARSE (SSE_AWK_ESRCOUTWRITE);
+	if (__flush (awk) == -1) EXIT_DEPARSE (ASE_AWK_ESRCOUTWRITE);
 
 exit_deparse:
 	if (awk->src.ios->out (
-		SSE_AWK_IO_CLOSE, awk->src.ios->custom_data, SSE_NULL, 0) == -1)
+		ASE_AWK_IO_CLOSE, awk->src.ios->custom_data, ASE_NULL, 0) == -1)
 	{
 		if (n != -1)
 		{
-			awk->errnum = SSE_AWK_ESRCOUTCLOSE;
+			awk->errnum = ASE_AWK_ESRCOUTCLOSE;
 			n = -1;
 		}
 	}
@@ -4280,57 +4280,57 @@ exit_deparse:
 	return 0;
 }
 
-static int __deparse_func (sse_awk_pair_t* pair, void* arg)
+static int __deparse_func (ase_awk_pair_t* pair, void* arg)
 {
 	struct __deparse_func_t* df = (struct __deparse_func_t*)arg;
-	sse_awk_afn_t* afn = (sse_awk_afn_t*)pair->val;
-	sse_size_t i, n;
+	ase_awk_afn_t* afn = (ase_awk_afn_t*)pair->val;
+	ase_size_t i, n;
 
-	sse_awk_assert (df->awk, sse_awk_strxncmp (
+	ase_awk_assert (df->awk, ase_awk_strxncmp (
 		pair->key, pair->key_len, afn->name, afn->name_len) == 0);
 
-	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;
+	if (ase_awk_putsrcstr (df->awk, ASE_T("function ")) == -1) return -1;
+	if (ase_awk_putsrcstr (df->awk, afn->name) == -1) return -1;
+	if (ase_awk_putsrcstr (df->awk, ASE_T(" (")) == -1) return -1;
 
 	for (i = 0; i < afn->nargs; ) 
 	{
-		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;
+		n = ase_awk_longtostr (i++, 10, 
+			ASE_T("__param"), df->tmp, df->tmp_len);
+		ase_awk_assert (df->awk, n != (ase_size_t)-1);
+		if (ase_awk_putsrcstrx (df->awk, df->tmp, n) == -1) return -1;
 		if (i >= afn->nargs) break;
-		if (sse_awk_putsrcstr (df->awk, SSE_T(", ")) == -1) return -1;
+		if (ase_awk_putsrcstr (df->awk, ASE_T(", ")) == -1) return -1;
 	}
 
-	if (sse_awk_putsrcstr (df->awk, SSE_T(")\n")) == -1) return -1;
+	if (ase_awk_putsrcstr (df->awk, ASE_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;
+	if (ase_awk_prnpt (df->awk, afn->body) == -1) return -1;
+	if (ase_awk_putsrcstr (df->awk, ASE_T("\n")) == -1) return -1;
 
 	return 0;
 }
 
-static int __put_char (sse_awk_t* awk, sse_char_t c)
+static int __put_char (ase_awk_t* awk, ase_char_t c)
 {
 	awk->src.shared.buf[awk->src.shared.buf_len++] = c;
-	if (awk->src.shared.buf_len >= sse_countof(awk->src.shared.buf))
+	if (awk->src.shared.buf_len >= ase_countof(awk->src.shared.buf))
 	{
 		if (__flush (awk) == -1) return -1;
 	}
 	return 0;
 }
 
-static int __flush (sse_awk_t* awk)
+static int __flush (ase_awk_t* awk)
 {
-	sse_ssize_t n;
+	ase_ssize_t n;
 
-	sse_awk_assert (awk, awk->src.ios->out != SSE_NULL);
+	ase_awk_assert (awk, awk->src.ios->out != ASE_NULL);
 
 	while (awk->src.shared.buf_pos < awk->src.shared.buf_len)
 	{
 		n = awk->src.ios->out (
-			SSE_AWK_IO_WRITE, awk->src.ios->custom_data,
+			ASE_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 (sse_awk_t* awk)
 	return 0;
 }
 
-int sse_awk_putsrcstr (sse_awk_t* awk, const sse_char_t* str)
+int ase_awk_putsrcstr (ase_awk_t* awk, const ase_char_t* str)
 {
-	while (*str != SSE_T('\0'))
+	while (*str != ASE_T('\0'))
 	{
 		if (__put_char (awk, *str) == -1) return -1;
 		str++;
@@ -4354,10 +4354,10 @@ int sse_awk_putsrcstr (sse_awk_t* awk, const sse_char_t* str)
 	return 0;
 }
 
-int sse_awk_putsrcstrx (
-	sse_awk_t* awk, const sse_char_t* str, sse_size_t len)
+int ase_awk_putsrcstrx (
+	ase_awk_t* awk, const ase_char_t* str, ase_size_t len)
 {
-	const sse_char_t* end = str + len;
+	const ase_char_t* end = str + len;
 
 	while (str < end)
 	{
diff --git a/ase/awk/parse.h b/ase/awk/parse.h
index b7ba69e6..4fe44e22 100644
--- a/ase/awk/parse.h
+++ b/ase/awk/parse.h
@@ -1,21 +1,21 @@
 /*
- * $Id: parse.h,v 1.2 2006-10-22 11:34:53 bacon Exp $
+ * $Id: parse.h,v 1.3 2006-10-24 04:10:12 bacon Exp $
  */
 
-#ifndef _SSE_AWK_PARSE_H_
-#define _SSE_AWK_PARSE_H_
+#ifndef _ASE_AWK_PARSE_H_
+#define _ASE_AWK_PARSE_H_
 
-#ifndef _SSE_AWK_AWK_H_
-#error Never include this file directly. Include <sse/awk/awk.h> instead
+#ifndef _ASE_AWK_AWK_H_
+#error Never include this file directly. Include <ase/awk/awk.h> instead
 #endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-int sse_awk_putsrcstr (sse_awk_t* awk, const sse_char_t* str);
-int sse_awk_putsrcstrx (
-	sse_awk_t* awk, const sse_char_t* str, sse_size_t len);
+int ase_awk_putsrcstr (ase_awk_t* awk, const ase_char_t* str);
+int ase_awk_putsrcstrx (
+	ase_awk_t* awk, const ase_char_t* str, ase_size_t len);
 
 #ifdef __cplusplus
 }
diff --git a/ase/awk/rec.c b/ase/awk/rec.c
index 973253c5..3d9e9613 100644
--- a/ase/awk/rec.c
+++ b/ase/awk/rec.c
@@ -1,57 +1,57 @@
 /*
- * $Id: rec.c,v 1.4 2006-10-22 11:34:53 bacon Exp $
+ * $Id: rec.c,v 1.5 2006-10-24 04:10:12 bacon Exp $
  */
 
-#include <sse/awk/awk_i.h>
+#include <ase/awk/awk_i.h>
 
-static int __split_record (sse_awk_run_t* run);
+static int __split_record (ase_awk_run_t* run);
 static int __recomp_record_fields (
-	sse_awk_run_t* run, sse_size_t lv, 
-	const sse_char_t* str, sse_size_t len);
+	ase_awk_run_t* run, ase_size_t lv, 
+	const ase_char_t* str, ase_size_t len);
 
-int sse_awk_setrec (
-	sse_awk_run_t* run, sse_size_t idx, const sse_char_t* str, sse_size_t len)
+int ase_awk_setrec (
+	ase_awk_run_t* run, ase_size_t idx, const ase_char_t* str, ase_size_t len)
 {
-	sse_awk_val_t* v;
+	ase_awk_val_t* v;
 	int errnum;
 
 	if (idx == 0)
 	{
-		if (str == SSE_AWK_STR_BUF(&run->inrec.line) &&
-		    len == SSE_AWK_STR_LEN(&run->inrec.line))
+		if (str == ASE_AWK_STR_BUF(&run->inrec.line) &&
+		    len == ASE_AWK_STR_LEN(&run->inrec.line))
 		{
-			if (sse_awk_clrrec (run, sse_true) == -1) return -1;
+			if (ase_awk_clrrec (run, ase_true) == -1) return -1;
 		}
 		else
 		{
-			if (sse_awk_clrrec (run, sse_false) == -1) return -1;
+			if (ase_awk_clrrec (run, ase_false) == -1) return -1;
 
-			if (sse_awk_str_ncpy (&run->inrec.line, str, len) == (sse_size_t)-1)
+			if (ase_awk_str_ncpy (&run->inrec.line, str, len) == (ase_size_t)-1)
 			{
-				sse_awk_clrrec (run, sse_false);
-				run->errnum = SSE_AWK_ENOMEM;
+				ase_awk_clrrec (run, ase_false);
+				run->errnum = ASE_AWK_ENOMEM;
 				return -1;
 			}
 		}
 
-		v = sse_awk_makestrval (run, str, len);
-		if (v == SSE_NULL)
+		v = ase_awk_makestrval (run, str, len);
+		if (v == ASE_NULL)
 		{
-			sse_awk_clrrec (run, sse_false);
-			run->errnum = SSE_AWK_ENOMEM;
+			ase_awk_clrrec (run, ase_false);
+			run->errnum = ASE_AWK_ENOMEM;
 			return -1;
 		}
 
-		sse_awk_assert (run->awk, run->inrec.d0->type == SSE_AWK_VAL_NIL);
+		ase_awk_assert (run->awk, run->inrec.d0->type == ASE_AWK_VAL_NIL);
 		/* d0 should be cleared before the next line is reached
-		 * as it doesn't call sse_awk_refdownval on run->inrec.d0 */
+		 * as it doesn't call ase_awk_refdownval on run->inrec.d0 */
 		run->inrec.d0 = v;
-		sse_awk_refupval (v);
+		ase_awk_refupval (v);
 
 		if (__split_record (run) == -1) 
 		{
 			errnum = run->errnum;
-			sse_awk_clrrec (run, sse_false);
+			ase_awk_clrrec (run, ase_false);
 			run->errnum = errnum;
 			return -1;
 		}
@@ -61,210 +61,210 @@ int sse_awk_setrec (
 		if (__recomp_record_fields (run, idx, str, len) == -1)
 		{
 			errnum = run->errnum;
-			sse_awk_clrrec (run, sse_false);
+			ase_awk_clrrec (run, ase_false);
 			run->errnum = errnum;
 			return -1;
 		}
 	
 		/* recompose $0 */
-		v = sse_awk_makestrval (run,
-			SSE_AWK_STR_BUF(&run->inrec.line), 
-			SSE_AWK_STR_LEN(&run->inrec.line));
-		if (v == SSE_NULL)
+		v = ase_awk_makestrval (run,
+			ASE_AWK_STR_BUF(&run->inrec.line), 
+			ASE_AWK_STR_LEN(&run->inrec.line));
+		if (v == ASE_NULL)
 		{
-			sse_awk_clrrec (run, sse_false);
-			run->errnum = SSE_AWK_ENOMEM;
+			ase_awk_clrrec (run, ase_false);
+			run->errnum = ASE_AWK_ENOMEM;
 			return -1;
 		}
 
-		sse_awk_refdownval (run, run->inrec.d0);
+		ase_awk_refdownval (run, run->inrec.d0);
 		run->inrec.d0 = v;
-		sse_awk_refupval (v);
+		ase_awk_refupval (v);
 	}
 
 	return 0;
 }
 
-static int __split_record (sse_awk_run_t* run)
+static int __split_record (ase_awk_run_t* run)
 {
-	sse_char_t* p, * tok;
-	sse_size_t len, tok_len, nflds;
-	sse_awk_val_t* v, * fs;
-	sse_char_t* fs_ptr, * fs_free;
-	sse_size_t fs_len;
+	ase_char_t* p, * tok;
+	ase_size_t len, tok_len, nflds;
+	ase_awk_val_t* v, * fs;
+	ase_char_t* fs_ptr, * fs_free;
+	ase_size_t fs_len;
 	int errnum;
        
 	/* inrec should be cleared before __split_record is called */
-	sse_awk_assert (run->awk, run->inrec.nflds == 0);
+	ase_awk_assert (run->awk, run->inrec.nflds == 0);
 
 	/* get FS */
-	fs = sse_awk_getglobal (run, SSE_AWK_GLOBAL_FS);
-	if (fs->type == SSE_AWK_VAL_NIL)
+	fs = ase_awk_getglobal (run, ASE_AWK_GLOBAL_FS);
+	if (fs->type == ASE_AWK_VAL_NIL)
 	{
-		fs_ptr = SSE_T(" ");
+		fs_ptr = ASE_T(" ");
 		fs_len = 1;
-		fs_free = SSE_NULL;
+		fs_free = ASE_NULL;
 	}
-	else if (fs->type == SSE_AWK_VAL_STR)
+	else if (fs->type == ASE_AWK_VAL_STR)
 	{
-		fs_ptr = ((sse_awk_val_str_t*)fs)->buf;
-		fs_len = ((sse_awk_val_str_t*)fs)->len;
-		fs_free = SSE_NULL;
+		fs_ptr = ((ase_awk_val_str_t*)fs)->buf;
+		fs_len = ((ase_awk_val_str_t*)fs)->len;
+		fs_free = ASE_NULL;
 	}
 	else 
 	{
-		fs_ptr = sse_awk_valtostr (
-			run, fs, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &fs_len);
-		if (fs_ptr == SSE_NULL) return -1;
+		fs_ptr = ase_awk_valtostr (
+			run, fs, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &fs_len);
+		if (fs_ptr == ASE_NULL) return -1;
 		fs_free = fs_ptr;
 	}
 
 	/* scan the input record to count the fields */
-	p = SSE_AWK_STR_BUF(&run->inrec.line);
-	len = SSE_AWK_STR_LEN(&run->inrec.line);
+	p = ASE_AWK_STR_BUF(&run->inrec.line);
+	len = ASE_AWK_STR_LEN(&run->inrec.line);
 
 	nflds = 0;
-	while (p != SSE_NULL)
+	while (p != ASE_NULL)
 	{
 		if (fs_len <= 1)
 		{
-			p = sse_awk_strxntok (run,
+			p = ase_awk_strxntok (run,
 				p, len, fs_ptr, fs_len, &tok, &tok_len);
 		}
 		else
 		{
-			p = sse_awk_strxntokbyrex (run, p, len, 
+			p = ase_awk_strxntokbyrex (run, p, len, 
 				run->global.fs, &tok, &tok_len, &errnum); 
-			if (p == SSE_NULL && errnum != SSE_AWK_ENOERR)
+			if (p == ASE_NULL && errnum != ASE_AWK_ENOERR)
 			{
-				if (fs_free != SSE_NULL) 
-					SSE_AWK_FREE (run->awk, fs_free);
+				if (fs_free != ASE_NULL) 
+					ASE_AWK_FREE (run->awk, fs_free);
 				run->errnum = errnum;
 				return -1;
 			}
 		}
 
-		if (nflds == 0 && p == SSE_NULL && tok_len == 0)
+		if (nflds == 0 && p == ASE_NULL && tok_len == 0)
 		{
 			/* there are no fields. it can just return here
-			 * as sse_awk_clrrec has been called before this */
-			if (fs_free != SSE_NULL) SSE_AWK_FREE (run->awk, fs_free);
+			 * as ase_awk_clrrec has been called before this */
+			if (fs_free != ASE_NULL) ASE_AWK_FREE (run->awk, fs_free);
 			return 0;
 		}
 
-		sse_awk_assert (run->awk,
-			(tok != SSE_NULL && tok_len > 0) || tok_len == 0);
+		ase_awk_assert (run->awk,
+			(tok != ASE_NULL && tok_len > 0) || tok_len == 0);
 
 		nflds++;
-		len = SSE_AWK_STR_LEN(&run->inrec.line) - 
-			(p - SSE_AWK_STR_BUF(&run->inrec.line));
+		len = ASE_AWK_STR_LEN(&run->inrec.line) - 
+			(p - ASE_AWK_STR_BUF(&run->inrec.line));
 	}
 
 	/* allocate space */
 	if (nflds > run->inrec.maxflds)
 	{
-		void* tmp = SSE_AWK_MALLOC (
-			run->awk, sse_sizeof(*run->inrec.flds) * nflds);
-		if (tmp == SSE_NULL) 
+		void* tmp = ASE_AWK_MALLOC (
+			run->awk, ase_sizeof(*run->inrec.flds) * nflds);
+		if (tmp == ASE_NULL) 
 		{
-			if (fs_free != SSE_NULL) SSE_AWK_FREE (run->awk, fs_free);
-			run->errnum = SSE_AWK_ENOMEM;
+			if (fs_free != ASE_NULL) ASE_AWK_FREE (run->awk, fs_free);
+			run->errnum = ASE_AWK_ENOMEM;
 			return -1;
 		}
 
-		if (run->inrec.flds != SSE_NULL) 
-			SSE_AWK_FREE (run->awk, run->inrec.flds);
+		if (run->inrec.flds != ASE_NULL) 
+			ASE_AWK_FREE (run->awk, run->inrec.flds);
 		run->inrec.flds = tmp;
 		run->inrec.maxflds = nflds;
 	}
 
 	/* scan again and split it */
-	p = SSE_AWK_STR_BUF(&run->inrec.line);
-	len = SSE_AWK_STR_LEN(&run->inrec.line);
+	p = ASE_AWK_STR_BUF(&run->inrec.line);
+	len = ASE_AWK_STR_LEN(&run->inrec.line);
 
-	while (p != SSE_NULL)
+	while (p != ASE_NULL)
 	{
 		if (fs_len <= 1)
 		{
-			p = sse_awk_strxntok (
+			p = ase_awk_strxntok (
 				run, p, len, fs_ptr, fs_len, &tok, &tok_len);
 		}
 		else
 		{
-			p = sse_awk_strxntokbyrex (run, p, len, 
+			p = ase_awk_strxntokbyrex (run, p, len, 
 				run->global.fs, &tok, &tok_len, &errnum); 
-			if (p == SSE_NULL && errnum != SSE_AWK_ENOERR)
+			if (p == ASE_NULL && errnum != ASE_AWK_ENOERR)
 			{
-				if (fs_free != SSE_NULL) 
-					SSE_AWK_FREE (run->awk, fs_free);
+				if (fs_free != ASE_NULL) 
+					ASE_AWK_FREE (run->awk, fs_free);
 				run->errnum = errnum;
 				return -1;
 			}
 		}
 
-		sse_awk_assert (run->awk,
-			(tok != SSE_NULL && tok_len > 0) || tok_len == 0);
+		ase_awk_assert (run->awk,
+			(tok != ASE_NULL && tok_len > 0) || tok_len == 0);
 
 		run->inrec.flds[run->inrec.nflds].ptr = tok;
 		run->inrec.flds[run->inrec.nflds].len = tok_len;
 		run->inrec.flds[run->inrec.nflds].val = 
-			sse_awk_makestrval (run, tok, tok_len);
+			ase_awk_makestrval (run, tok, tok_len);
 
-		if (run->inrec.flds[run->inrec.nflds].val == SSE_NULL)
+		if (run->inrec.flds[run->inrec.nflds].val == ASE_NULL)
 		{
-			if (fs_free != SSE_NULL) SSE_AWK_FREE (run->awk, fs_free);
-			run->errnum = SSE_AWK_ENOMEM;
+			if (fs_free != ASE_NULL) ASE_AWK_FREE (run->awk, fs_free);
+			run->errnum = ASE_AWK_ENOMEM;
 			return -1;
 		}
 
-		sse_awk_refupval (run->inrec.flds[run->inrec.nflds].val);
+		ase_awk_refupval (run->inrec.flds[run->inrec.nflds].val);
 		run->inrec.nflds++;
 
-		len = SSE_AWK_STR_LEN(&run->inrec.line) - 
-			(p - SSE_AWK_STR_BUF(&run->inrec.line));
+		len = ASE_AWK_STR_LEN(&run->inrec.line) - 
+			(p - ASE_AWK_STR_BUF(&run->inrec.line));
 	}
 
-	if (fs_free != SSE_NULL) SSE_AWK_FREE (run->awk, fs_free);
+	if (fs_free != ASE_NULL) ASE_AWK_FREE (run->awk, fs_free);
 
 	/* set the number of fields */
-	v = sse_awk_makeintval (run, (sse_long_t)nflds);
-	if (v == SSE_NULL) 
+	v = ase_awk_makeintval (run, (ase_long_t)nflds);
+	if (v == ASE_NULL) 
 	{
-		run->errnum = SSE_AWK_ENOMEM;
+		run->errnum = ASE_AWK_ENOMEM;
 		return -1;
 	}
 
-	if (sse_awk_setglobal (run, SSE_AWK_GLOBAL_NF, v) == -1) return -1;
+	if (ase_awk_setglobal (run, ASE_AWK_GLOBAL_NF, v) == -1) return -1;
 
-	sse_awk_assert (run->awk, nflds == run->inrec.nflds);
+	ase_awk_assert (run->awk, nflds == run->inrec.nflds);
 	return 0;
 }
 
-int sse_awk_clrrec (sse_awk_run_t* run, sse_bool_t skip_inrec_line)
+int ase_awk_clrrec (ase_awk_run_t* run, ase_bool_t skip_inrec_line)
 {
-	sse_size_t i;
+	ase_size_t i;
 	int n = 0;
 
-	if (run->inrec.d0 != sse_awk_val_nil)
+	if (run->inrec.d0 != ase_awk_val_nil)
 	{
-		sse_awk_refdownval (run, run->inrec.d0);
-		run->inrec.d0 = sse_awk_val_nil;
+		ase_awk_refdownval (run, run->inrec.d0);
+		run->inrec.d0 = ase_awk_val_nil;
 	}
 
 	if (run->inrec.nflds > 0)
 	{
-		sse_awk_assert (run->awk, run->inrec.flds != SSE_NULL);
+		ase_awk_assert (run->awk, run->inrec.flds != ASE_NULL);
 
 		for (i = 0; i < run->inrec.nflds; i++) 
 		{
-			sse_awk_assert (run->awk,
-				run->inrec.flds[i].val != SSE_NULL);
-			sse_awk_refdownval (run, run->inrec.flds[i].val);
+			ase_awk_assert (run->awk,
+				run->inrec.flds[i].val != ASE_NULL);
+			ase_awk_refdownval (run, run->inrec.flds[i].val);
 		}
 		run->inrec.nflds = 0;
 
-		if (sse_awk_setglobal (
-			run, SSE_AWK_GLOBAL_NF, sse_awk_val_zero) == -1)
+		if (ase_awk_setglobal (
+			run, ASE_AWK_GLOBAL_NF, ase_awk_val_zero) == -1)
 		{
 			/* first of all, this should never happen. 
 			 * if it happened, it would return an error
@@ -273,23 +273,23 @@ int sse_awk_clrrec (sse_awk_run_t* run, sse_bool_t skip_inrec_line)
 		}
 	}
 
-	sse_awk_assert (run->awk, run->inrec.nflds == 0);
-	if (!skip_inrec_line) sse_awk_str_clear (&run->inrec.line);
+	ase_awk_assert (run->awk, run->inrec.nflds == 0);
+	if (!skip_inrec_line) ase_awk_str_clear (&run->inrec.line);
 
 	return n;
 }
 
 static int __recomp_record_fields (
-	sse_awk_run_t* run, sse_size_t lv, 
-	const sse_char_t* str, sse_size_t len)
+	ase_awk_run_t* run, ase_size_t lv, 
+	const ase_char_t* str, ase_size_t len)
 {
-	sse_awk_val_t* v;
-	sse_size_t max, i, nflds;
+	ase_awk_val_t* v;
+	ase_size_t max, i, nflds;
 
 	/* recomposes the record and the fields when $N has been assigned 
 	 * a new value and recomputes NF accordingly */
 
-	sse_awk_assert (run->awk, lv > 0);
+	ase_awk_assert (run->awk, lv > 0);
 	max = (lv > run->inrec.nflds)? lv: run->inrec.nflds;
 
 	nflds = run->inrec.nflds;
@@ -301,31 +301,31 @@ static int __recomp_record_fields (
 		 * number of fields that the current record can hold,
 		 * the field spaces are resized */
 
-		if (run->awk->syscas.realloc != SSE_NULL)
+		if (run->awk->syscas.realloc != ASE_NULL)
 		{
-			tmp = SSE_AWK_REALLOC (
+			tmp = ASE_AWK_REALLOC (
 				run->awk, run->inrec.flds, 
-				sse_sizeof(*run->inrec.flds) * max);
-			if (tmp == SSE_NULL) 
+				ase_sizeof(*run->inrec.flds) * max);
+			if (tmp == ASE_NULL) 
 			{
-				run->errnum = SSE_AWK_ENOMEM;
+				run->errnum = ASE_AWK_ENOMEM;
 				return -1;
 			}
 		}
 		else
 		{
-			tmp = SSE_AWK_MALLOC (
-				run->awk, sse_sizeof(*run->inrec.flds) * max);
-			if (tmp == SSE_NULL)
+			tmp = ASE_AWK_MALLOC (
+				run->awk, ase_sizeof(*run->inrec.flds) * max);
+			if (tmp == ASE_NULL)
 			{
-				run->errnum = SSE_AWK_ENOMEM;
+				run->errnum = ASE_AWK_ENOMEM;
 				return -1;
 			}
-			if (run->inrec.flds != SSE_NULL)
+			if (run->inrec.flds != ASE_NULL)
 			{
-				SSE_AWK_MEMCPY (run->awk, tmp, run->inrec.flds, 
-					sse_sizeof(*run->inrec.flds) * run->inrec.maxflds);
-				SSE_AWK_FREE (run->awk, run->inrec.flds);
+				ASE_AWK_MEMCPY (run->awk, tmp, run->inrec.flds, 
+					ase_sizeof(*run->inrec.flds) * run->inrec.maxflds);
+				ASE_AWK_FREE (run->awk, run->inrec.flds);
 			}
 		}
 
@@ -335,107 +335,107 @@ static int __recomp_record_fields (
 
 	lv = lv - 1; /* adjust the value to 0-based index */
 
-	sse_awk_str_clear (&run->inrec.line);
+	ase_awk_str_clear (&run->inrec.line);
 
 	for (i = 0; i < max; i++)
 	{
 		if (i > 0)
 		{
-			if (sse_awk_str_ncat (
+			if (ase_awk_str_ncat (
 				&run->inrec.line, 
 				run->global.ofs.ptr, 
-				run->global.ofs.len) == (sse_size_t)-1) 
+				run->global.ofs.len) == (ase_size_t)-1) 
 			{
-				run->errnum = SSE_AWK_ENOMEM;
+				run->errnum = ASE_AWK_ENOMEM;
 				return -1;
 			}
 		}
 
 		if (i == lv)
 		{
-			sse_awk_val_t* tmp;
+			ase_awk_val_t* tmp;
 
 			run->inrec.flds[i].ptr = 
-				SSE_AWK_STR_BUF(&run->inrec.line) +
-				SSE_AWK_STR_LEN(&run->inrec.line);
+				ASE_AWK_STR_BUF(&run->inrec.line) +
+				ASE_AWK_STR_LEN(&run->inrec.line);
 			run->inrec.flds[i].len = len;
 
-			if (sse_awk_str_ncat (
-				&run->inrec.line, str, len) == (sse_size_t)-1)
+			if (ase_awk_str_ncat (
+				&run->inrec.line, str, len) == (ase_size_t)-1)
 			{
-				run->errnum = SSE_AWK_ENOMEM;
+				run->errnum = ASE_AWK_ENOMEM;
 				return -1;
 			}
 
-			tmp = sse_awk_makestrval (run, str,len);
-			if (tmp == SSE_NULL) 
+			tmp = ase_awk_makestrval (run, str,len);
+			if (tmp == ASE_NULL) 
 			{
-				run->errnum = SSE_AWK_ENOMEM;
+				run->errnum = ASE_AWK_ENOMEM;
 				return -1;
 			}
 
 			if (i < nflds)
-				sse_awk_refdownval (run, run->inrec.flds[i].val);
+				ase_awk_refdownval (run, run->inrec.flds[i].val);
 			else run->inrec.nflds++;
 
 			run->inrec.flds[i].val = tmp;
-			sse_awk_refupval (tmp);
+			ase_awk_refupval (tmp);
 		}
 		else if (i >= nflds)
 		{
 			run->inrec.flds[i].ptr = 
-				SSE_AWK_STR_BUF(&run->inrec.line) +
-				SSE_AWK_STR_LEN(&run->inrec.line);
+				ASE_AWK_STR_BUF(&run->inrec.line) +
+				ASE_AWK_STR_LEN(&run->inrec.line);
 			run->inrec.flds[i].len = 0;
 
-			if (sse_awk_str_cat (
-				&run->inrec.line, SSE_T("")) == (sse_size_t)-1)
+			if (ase_awk_str_cat (
+				&run->inrec.line, ASE_T("")) == (ase_size_t)-1)
 			{
-				run->errnum = SSE_AWK_ENOMEM;
+				run->errnum = ASE_AWK_ENOMEM;
 				return -1;
 			}
 
-			/* sse_awk_refdownval should not be called over 
+			/* ase_awk_refdownval should not be called over 
 			 * run->inrec.flds[i].val as it is not initialized
 			 * to any valid values */
-			/*sse_awk_refdownval (run, run->inrec.flds[i].val);*/
-			run->inrec.flds[i].val = sse_awk_val_zls;
-			sse_awk_refupval (sse_awk_val_zls);
+			/*ase_awk_refdownval (run, run->inrec.flds[i].val);*/
+			run->inrec.flds[i].val = ase_awk_val_zls;
+			ase_awk_refupval (ase_awk_val_zls);
 			run->inrec.nflds++;
 		}
 		else
 		{
-			sse_awk_val_str_t* tmp;
+			ase_awk_val_str_t* tmp;
 
-			tmp = (sse_awk_val_str_t*)run->inrec.flds[i].val;
+			tmp = (ase_awk_val_str_t*)run->inrec.flds[i].val;
 
 			run->inrec.flds[i].ptr = 
-				SSE_AWK_STR_BUF(&run->inrec.line) +
-				SSE_AWK_STR_LEN(&run->inrec.line);
+				ASE_AWK_STR_BUF(&run->inrec.line) +
+				ASE_AWK_STR_LEN(&run->inrec.line);
 			run->inrec.flds[i].len = tmp->len;
 
-			if (sse_awk_str_ncat (&run->inrec.line, 
-				tmp->buf, tmp->len) == (sse_size_t)-1)
+			if (ase_awk_str_ncat (&run->inrec.line, 
+				tmp->buf, tmp->len) == (ase_size_t)-1)
 			{
-				run->errnum = SSE_AWK_ENOMEM;
+				run->errnum = ASE_AWK_ENOMEM;
 				return -1;
 			}
 		}
 	}
 
-	v = sse_awk_getglobal (run, SSE_AWK_GLOBAL_NF);
-	sse_awk_assert (run->awk, v->type == SSE_AWK_VAL_INT);
-	if (((sse_awk_val_int_t*)v)->val != max)
+	v = ase_awk_getglobal (run, ASE_AWK_GLOBAL_NF);
+	ase_awk_assert (run->awk, v->type == ASE_AWK_VAL_INT);
+	if (((ase_awk_val_int_t*)v)->val != max)
 	{
-		v = sse_awk_makeintval (run, (sse_long_t)max);
-		if (v == SSE_NULL) 
+		v = ase_awk_makeintval (run, (ase_long_t)max);
+		if (v == ASE_NULL) 
 		{
-			run->errnum = SSE_AWK_ENOMEM;
+			run->errnum = ASE_AWK_ENOMEM;
 			return -1;
 		}
 
-		if (sse_awk_setglobal (
-			run, SSE_AWK_GLOBAL_NF, v) == -1) return -1;
+		if (ase_awk_setglobal (
+			run, ASE_AWK_GLOBAL_NF, v) == -1) return -1;
 	}
 
 	return 0;
diff --git a/ase/awk/rex.c b/ase/awk/rex.c
index 0659047d..2ab560ae 100644
--- a/ase/awk/rex.c
+++ b/ase/awk/rex.c
@@ -1,8 +1,8 @@
 /*
- * $Id: rex.c,v 1.38 2006-10-22 12:39:29 bacon Exp $
+ * $Id: rex.c,v 1.39 2006-10-24 04:10:12 bacon Exp $
  */
 
-#include <sse/awk/awk_i.h>
+#include <ase/awk/awk_i.h>
 
 enum
 {
@@ -49,7 +49,7 @@ enum
 
 #define DEF_CODE_CAPA 512
 #define BOUND_MIN 0
-#define BOUND_MAX (SSE_TYPE_MAX(sse_size_t))
+#define BOUND_MAX (ASE_TYPE_MAX(ase_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
 {
-	/*sse_byte_t cmd;*/
+	/*ase_byte_t cmd;*/
 	short cmd;
 	short negate; /* only for CMD_CHARSET */
-	sse_size_t lbound;
-	sse_size_t ubound;
+	ase_size_t lbound;
+	ase_size_t ubound;
 };
 
 struct __builder_t
 {
-	sse_awk_t* awk;
+	ase_awk_t* awk;
 
 	struct
 	{
-		const sse_char_t* ptr;
-		const sse_char_t* end;
-		const sse_char_t* curp;
+		const ase_char_t* ptr;
+		const ase_char_t* end;
+		const ase_char_t* curp;
 		struct
 		{
 			int type;
-			sse_char_t value;
+			ase_char_t value;
 		} curc;
 	} ptn;
 
 	struct
 	{
-		sse_byte_t* buf;
-		sse_size_t  size;
-		sse_size_t  capa;
+		ase_byte_t* buf;
+		ase_size_t  size;
+		ase_size_t  capa;
 	} code;	
 
 	struct
@@ -98,14 +98,14 @@ struct __builder_t
 
 struct __matcher_t
 {
-	sse_awk_t* awk;
+	ase_awk_t* awk;
 
 	struct
 	{
 		struct
 		{
-			const sse_char_t* ptr;
-			const sse_char_t* end;
+			const ase_char_t* ptr;
+			const ase_char_t* end;
 		} str;
 	} match;
 
@@ -121,17 +121,17 @@ struct __matcher_t
 
 struct __match_t
 {
-	const sse_char_t* match_ptr;
+	const ase_char_t* match_ptr;
 
-	sse_bool_t matched;
-	sse_size_t match_len;
+	ase_bool_t matched;
+	ase_size_t match_len;
 
-	const sse_byte_t* branch;
-	const sse_byte_t* branch_end;
+	const ase_byte_t* branch;
+	const ase_byte_t* branch_end;
 };
 
-typedef const sse_byte_t* (*atom_matcher_t) (
-	__matcher_t* matcher, const sse_byte_t* base, __match_t* mat);
+typedef const ase_byte_t* (*atom_matcher_t) (
+	__matcher_t* matcher, const ase_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, sse_char_t* cc);
+static int __build_cclass (__builder_t* rex, ase_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, sse_size_t len);
+static int __add_code (__builder_t* rex, void* data, ase_size_t len);
 
 #if defined(__sparc) || defined(__sparc__)
 
-static sse_size_t __get_code (__builder_t* builder, sse_size_t pos)
+static ase_size_t __get_code (__builder_t* builder, ase_size_t pos)
 {
-	sse_size_t code;
-	SSE_AWK_MEMCPY (builder->awk, 
-		&code, &builder->code.buf[pos], sse_sizeof(code));
+	ase_size_t code;
+	ASE_AWK_MEMCPY (builder->awk, 
+		&code, &builder->code.buf[pos], ase_sizeof(code));
 	return code;
 }
 
-static void __set_code (__builder_t* builder, sse_size_t pos, sse_size_t code)
+static void __set_code (__builder_t* builder, ase_size_t pos, ase_size_t code)
 {
-	SSE_AWK_MEMCPY (builder->awk, 
-		&builder->code.buf[pos], &code, sse_sizeof(code));
+	ASE_AWK_MEMCPY (builder->awk, 
+		&builder->code.buf[pos], &code, ase_sizeof(code));
 }
 
 #endif
 
-static sse_bool_t __begin_with (
-	const sse_char_t* str, sse_size_t len, const sse_char_t* what);
+static ase_bool_t __begin_with (
+	const ase_char_t* str, ase_size_t len, const ase_char_t* what);
 
-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 ase_byte_t* __match_pattern (
+	__matcher_t* matcher, const ase_byte_t* base, __match_t* mat);
+static const ase_byte_t* __match_branch (
+	__matcher_t* matcher, const ase_byte_t* base, __match_t* mat);
+static const ase_byte_t* __match_branch_body (
+	__matcher_t* matcher, const ase_byte_t* base, __match_t* mat);
+static const ase_byte_t* __match_branch_body0 (
+	__matcher_t* matcher, const ase_byte_t* base, __match_t* mat);
+static const ase_byte_t* __match_atom (
+	__matcher_t* matcher, const ase_byte_t* base, __match_t* mat);
+static const ase_byte_t* __match_bol (
+	__matcher_t* matcher, const ase_byte_t* base, __match_t* mat);
+static const ase_byte_t* __match_eol (
+	__matcher_t* matcher, const ase_byte_t* base, __match_t* mat);
+static const ase_byte_t* __match_any_char (
+	__matcher_t* matcher, const ase_byte_t* base, __match_t* mat);
+static const ase_byte_t* __match_ord_char (
+	__matcher_t* matcher, const ase_byte_t* base, __match_t* mat);
+static const ase_byte_t* __match_charset (
+	__matcher_t* matcher, const ase_byte_t* base, __match_t* mat);
+static const ase_byte_t* __match_group (
+	__matcher_t* matcher, const ase_byte_t* base, __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 const ase_byte_t* __match_occurrences (
+	__matcher_t* matcher, ase_size_t si, const ase_byte_t* p,
+	ase_size_t lbound, ase_size_t ubound, __match_t* mat);
 
-static sse_bool_t __test_charset (
-	__matcher_t* matcher, const sse_byte_t* p, sse_size_t csc, sse_char_t c);
+static ase_bool_t __test_charset (
+	__matcher_t* matcher, const ase_byte_t* p, ase_size_t csc, ase_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 ase_bool_t __cc_isalnum (ase_awk_t* awk, ase_char_t c);
+static ase_bool_t __cc_isalpha (ase_awk_t* awk, ase_char_t c);
+static ase_bool_t __cc_isblank (ase_awk_t* awk, ase_char_t c);
+static ase_bool_t __cc_iscntrl (ase_awk_t* awk, ase_char_t c);
+static ase_bool_t __cc_isdigit (ase_awk_t* awk, ase_char_t c);
+static ase_bool_t __cc_isgraph (ase_awk_t* awk, ase_char_t c);
+static ase_bool_t __cc_islower (ase_awk_t* awk, ase_char_t c);
+static ase_bool_t __cc_isprint (ase_awk_t* awk, ase_char_t c);
+static ase_bool_t __cc_ispunct (ase_awk_t* awk, ase_char_t c);
+static ase_bool_t __cc_isspace (ase_awk_t* awk, ase_char_t c);
+static ase_bool_t __cc_isupper (ase_awk_t* awk, ase_char_t c);
+static ase_bool_t __cc_isxdigit (ase_awk_t* awk, ase_char_t c);
 
-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);
+static const ase_byte_t* __print_pattern (const ase_byte_t* p);
+static const ase_byte_t* __print_branch (const ase_byte_t* p);
+static const ase_byte_t* __print_atom (const ase_byte_t* p);
 
 struct __char_class_t
 {
-	const sse_char_t* name;
-	sse_size_t name_len;
-	sse_bool_t (*func) (sse_awk_t* awk, sse_char_t c);
+	const ase_char_t* name;
+	ase_size_t name_len;
+	ase_bool_t (*func) (ase_awk_t* awk, ase_char_t c);
 }; 
 
 static struct __char_class_t __char_class[] =
 {
-	{ 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 },
+	{ ASE_T("alnum"),  5, __cc_isalnum },
+	{ ASE_T("alpha"),  5, __cc_isalpha },
+	{ ASE_T("blank"),  5, __cc_isblank },
+	{ ASE_T("cntrl"),  5, __cc_iscntrl },
+	{ ASE_T("digit"),  5, __cc_isdigit },
+	{ ASE_T("graph"),  5, __cc_isgraph },
+	{ ASE_T("lower"),  5, __cc_islower },
+	{ ASE_T("print"),  5, __cc_isprint },
+	{ ASE_T("punct"),  5, __cc_ispunct },
+	{ ASE_T("space"),  5, __cc_isspace },
+	{ ASE_T("upper"),  5, __cc_isupper },
+	{ ASE_T("xdigit"), 6, __cc_isxdigit },
 
 	/*
-	{ 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 }, 
+	{ ASE_T("arabic"),   6, __cc_isarabic },
+	{ ASE_T("chinese"),  7, __cc_ischinese },
+	{ ASE_T("english"),  7, __cc_isenglish },
+	{ ASE_T("japanese"), 8, __cc_isjapanese },
+	{ ASE_T("korean"),   6, __cc_iskorean }, 
+	{ ASE_T("thai"),     4, __cc_isthai }, 
 	*/
 
-	{ SSE_NULL,        0, SSE_NULL }
+	{ ASE_NULL,        0, ASE_NULL }
 };
 
-void* sse_awk_buildrex (
-	sse_awk_t* awk, const sse_char_t* ptn, sse_size_t len, int* errnum)
+void* ase_awk_buildrex (
+	ase_awk_t* awk, const ase_char_t* ptn, ase_size_t len, int* errnum)
 {
 	__builder_t builder;
 
 	builder.awk = awk;
 	builder.code.capa = DEF_CODE_CAPA;
 	builder.code.size = 0;
-	builder.code.buf = (sse_byte_t*) 
-		SSE_AWK_MALLOC (builder.awk, builder.code.capa);
-	if (builder.code.buf == SSE_NULL) 
+	builder.code.buf = (ase_byte_t*) 
+		ASE_AWK_MALLOC (builder.awk, builder.code.capa);
+	if (builder.code.buf == ASE_NULL) 
 	{
-		*errnum = SSE_AWK_ENOMEM;
-		return SSE_NULL;
+		*errnum = ASE_AWK_ENOMEM;
+		return ASE_NULL;
 	}
 
 	builder.ptn.ptr = ptn;
@@ -283,7 +283,7 @@ void* sse_awk_buildrex (
 	builder.ptn.curp = builder.ptn.ptr;
 
 	builder.ptn.curc.type = CT_EOF;
-	builder.ptn.curc.value = SSE_T('\0');
+	builder.ptn.curc.value = ASE_T('\0');
 
 /* TODO: implement the maximum depth 
 	builder.depth.max = awk->max_depth; */
@@ -292,37 +292,37 @@ void* sse_awk_buildrex (
 
 	if (__next_char (&builder, LEVEL_TOP) == -1) 
 	{
-		if (errnum != SSE_NULL) *errnum = builder.errnum;
-		SSE_AWK_FREE (builder.awk, builder.code.buf);
-		return SSE_NULL;
+		if (errnum != ASE_NULL) *errnum = builder.errnum;
+		ASE_AWK_FREE (builder.awk, builder.code.buf);
+		return ASE_NULL;
 	}
 
 	if (__build_pattern (&builder) == -1) 
 	{
-		if (errnum != SSE_NULL) *errnum = builder.errnum;
-		SSE_AWK_FREE (builder.awk, builder.code.buf);
-		return SSE_NULL;
+		if (errnum != ASE_NULL) *errnum = builder.errnum;
+		ASE_AWK_FREE (builder.awk, builder.code.buf);
+		return ASE_NULL;
 	}
 
 	if (builder.ptn.curc.type != CT_EOF)
 	{
-		if (errnum != SSE_NULL) *errnum = SSE_AWK_EREXGARBAGE;
-		SSE_AWK_FREE (builder.awk, builder.code.buf);
-		return SSE_NULL;
+		if (errnum != ASE_NULL) *errnum = ASE_AWK_EREXGARBAGE;
+		ASE_AWK_FREE (builder.awk, builder.code.buf);
+		return ASE_NULL;
 	}
 
 	return builder.code.buf;
 }
 
-int sse_awk_matchrex (
-	sse_awk_t* awk, void* code, int option,
-	const sse_char_t* str, sse_size_t len, 
-	const sse_char_t** match_ptr, sse_size_t* match_len, int* errnum)
+int ase_awk_matchrex (
+	ase_awk_t* awk, void* code, int option,
+	const ase_char_t* str, ase_size_t len, 
+	const ase_char_t** match_ptr, ase_size_t* match_len, int* errnum)
 {
 	__matcher_t matcher;
 	__match_t mat;
-	sse_size_t offset = 0;
-	/*const sse_char_t* match_ptr_zero = SSE_NULL;*/
+	ase_size_t offset = 0;
+	/*const ase_char_t* match_ptr_zero = ASE_NULL;*/
 
 	matcher.awk = awk;
 
@@ -334,17 +334,17 @@ int sse_awk_matchrex (
 	matcher.depth.max = awk->max_depth; */
 	matcher.depth.max = 0;
 	matcher.depth.cur = 0;
-	matcher.ignorecase = (option & SSE_AWK_REX_IGNORECASE)? 1: 0;
+	matcher.ignorecase = (option & ASE_AWK_REX_IGNORECASE)? 1: 0;
 
-	mat.matched = sse_false;
+	mat.matched = ase_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) == SSE_NULL) 
+		if (__match_pattern (&matcher, code, &mat) == ASE_NULL) 
 		{
-			if (errnum != SSE_NULL) *errnum = matcher.errnum;
+			if (errnum != ASE_NULL) *errnum = matcher.errnum;
 			return -1;
 		}
 
@@ -353,17 +353,17 @@ int sse_awk_matchrex (
 			/*
 			if (mat.match_len == 0)
 			{
-				if (match_ptr_zero == SSE_NULL)
+				if (match_ptr_zero == ASE_NULL)
 					match_ptr_zero = mat.match_ptr;
 				mat.match_ptr++;
 				continue;
 			}
 			*/
 
-			if (match_ptr != SSE_NULL) *match_ptr = mat.match_ptr;
-			if (match_len != SSE_NULL) *match_len = mat.match_len;
+			if (match_ptr != ASE_NULL) *match_ptr = mat.match_ptr;
+			if (match_len != ASE_NULL) *match_len = mat.match_len;
 
-			/*match_ptr_zero = SSE_NULL;*/
+			/*match_ptr_zero = ASE_NULL;*/
 			break;
 		}
 
@@ -371,10 +371,10 @@ int sse_awk_matchrex (
 	}
 
 	/*
-	if (match_ptr_zero != SSE_NULL) 
+	if (match_ptr_zero != ASE_NULL) 
 	{
-		if (match_ptr != SSE_NULL) *match_ptr = match_ptr_zero;
-		if (match_len != SSE_NULL) *match_len = 0;
+		if (match_ptr != ASE_NULL) *match_ptr = match_ptr_zero;
+		if (match_len != ASE_NULL) *match_len = 0;
 		return 1;
 	}
 	*/
@@ -382,28 +382,28 @@ int sse_awk_matchrex (
 	return (mat.matched)? 1: 0;
 }
 
-void sse_awk_freerex (sse_awk_t* awk, void* code)
+void ase_awk_freerex (ase_awk_t* awk, void* code)
 {
-	sse_awk_assert (awk, code != SSE_NULL);
-	SSE_AWK_FREE (awk, code);
+	ase_awk_assert (awk, code != ASE_NULL);
+	ASE_AWK_FREE (awk, code);
 }
 
-sse_bool_t sse_awk_isemptyrex (sse_awk_t* awk, void* code)
+ase_bool_t ase_awk_isemptyrex (ase_awk_t* awk, void* code)
 {
-	const sse_byte_t* p = code;
-	sse_size_t nb, el;
+	const ase_byte_t* p = code;
+	ase_size_t nb, el;
 
-	sse_awk_assert (awk, p != SSE_NULL);
+	ase_awk_assert (awk, p != ASE_NULL);
 
-	nb = *(sse_size_t*)p; p += sse_sizeof(nb);
-	el = *(sse_size_t*)p; p += sse_sizeof(el);
+	nb = *(ase_size_t*)p; p += ase_sizeof(nb);
+	el = *(ase_size_t*)p; p += ase_sizeof(el);
 
 	/* an empty regular expression look like:
 	 *  | expression                     | 
 	 *  | header         | branch        |
 	 *  |                | branch header |
 	 *  | NB(1) | EL(16) | NA(1) | BL(8) | */
-	return (nb == 1 && el == sse_sizeof(sse_size_t)*4)? sse_true: sse_false;
+	return (nb == 1 && el == ase_sizeof(ase_size_t)*4)? ase_true: ase_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 = SSE_AWK_ERECURSION;
+		builder->errnum = ASE_AWK_ERECURSION;
 		return -1;
 	}
 
@@ -425,9 +425,9 @@ static int __build_pattern (__builder_t* builder)
 
 static int __build_pattern0 (__builder_t* builder)
 {
-	sse_size_t zero = 0;
-	sse_size_t old_size;
-	sse_size_t pos_nb, pos_el;
+	ase_size_t zero = 0;
+	ase_size_t old_size;
+	ase_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, sse_sizeof(zero));
+	ADD_CODE (builder, &zero, ase_sizeof(zero));
 
 	pos_el = builder->code.size;
-	ADD_CODE (builder, &zero, sse_sizeof(zero));
+	ADD_CODE (builder, &zero, ase_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,sse_size_t) += 1;*/
-	SET_CODE (builder, pos_nb, sse_size_t,
-		GET_CODE (builder, pos_nb, sse_size_t) + 1);
+	/*CODEAT(builder,pos_nb,ase_size_t) += 1;*/
+	SET_CODE (builder, pos_nb, ase_size_t,
+		GET_CODE (builder, pos_nb, ase_size_t) + 1);
 
 	/* handle subsequent branches if any */
 	while (builder->ptn.curc.type == CT_SPECIAL && 
-	       builder->ptn.curc.value == SSE_T('|'))
+	       builder->ptn.curc.value == ASE_T('|'))
 	{
 		NEXT_CHAR (builder, LEVEL_TOP);
 
@@ -469,31 +469,31 @@ static int __build_pattern0 (__builder_t* builder)
 			break;
 		}
 
-		/*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_nb,ase_size_t) += 1;*/
+		SET_CODE (builder, pos_nb, ase_size_t, 
+			GET_CODE (builder, pos_nb, ase_size_t) + 1);
 	}
 
-	/*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);
+	/*CODEAT(builder,pos_el,ase_size_t) = builder->code.size - old_size;*/
+	SET_CODE (builder, pos_el, ase_size_t, builder->code.size - old_size);
 	return 1;
 }
 
 static int __build_branch (__builder_t* builder)
 {
 	int n;
-	sse_size_t zero = 0;
-	sse_size_t old_size;
-	sse_size_t pos_na, pos_bl;
+	ase_size_t zero = 0;
+	ase_size_t old_size;
+	ase_size_t pos_na, pos_bl;
 	struct __code_t* cmd;
 
 	old_size = builder->code.size;
 
 	pos_na = builder->code.size;
-	ADD_CODE (builder, &zero, sse_sizeof(zero));
+	ADD_CODE (builder, &zero, ase_sizeof(zero));
 
 	pos_bl = builder->code.size;
-	ADD_CODE (builder, &zero, sse_sizeof(zero));
+	ADD_CODE (builder, &zero, ase_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,sse_size_t) += 1;*/
-		SET_CODE (builder, pos_na, sse_size_t,
-			GET_CODE (builder, pos_na, sse_size_t) + 1);
+		/*CODEAT(builder,pos_na,ase_size_t) += 1;*/
+		SET_CODE (builder, pos_na, ase_size_t,
+			GET_CODE (builder, pos_na, ase_size_t) + 1);
 	}
 
-	/*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);
+	/*CODEAT(builder,pos_bl,ase_size_t) = builder->code.size - old_size;*/
+	SET_CODE (builder, pos_bl, ase_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 == SSE_T('('))
+		if (builder->ptn.curc.value == ASE_T('('))
 		{
 			tmp.cmd = CMD_GROUP;
 			tmp.negate = 0;
 			tmp.lbound = 1;
 			tmp.ubound = 1;
-			ADD_CODE (builder, &tmp, sse_sizeof(tmp));
+			ADD_CODE (builder, &tmp, ase_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 != SSE_T(')')) 
+			    builder->ptn.curc.value != ASE_T(')')) 
 			{
-				builder->errnum = SSE_AWK_EREXRPAREN;
+				builder->errnum = ASE_AWK_EREXRPAREN;
 				return -1;
 			}
 		}
-		else if (builder->ptn.curc.value == SSE_T('^'))
+		else if (builder->ptn.curc.value == ASE_T('^'))
 		{
 			tmp.cmd = CMD_BOL;
 			tmp.negate = 0;
 			tmp.lbound = 1;
 			tmp.ubound = 1;
-			ADD_CODE (builder, &tmp, sse_sizeof(tmp));
+			ADD_CODE (builder, &tmp, ase_sizeof(tmp));
 		}
-		else if (builder->ptn.curc.value == SSE_T('$'))
+		else if (builder->ptn.curc.value == ASE_T('$'))
 		{
 			tmp.cmd = CMD_EOL;
 			tmp.negate = 0;
 			tmp.lbound = 1;
 			tmp.ubound = 1;
-			ADD_CODE (builder, &tmp, sse_sizeof(tmp));
+			ADD_CODE (builder, &tmp, ase_sizeof(tmp));
 		}
-		else if (builder->ptn.curc.value == SSE_T('.'))
+		else if (builder->ptn.curc.value == ASE_T('.'))
 		{
 			tmp.cmd = CMD_ANY_CHAR;
 			tmp.negate = 0;
 			tmp.lbound = 1;
 			tmp.ubound = 1;
-			ADD_CODE (builder, &tmp, sse_sizeof(tmp));
+			ADD_CODE (builder, &tmp, ase_sizeof(tmp));
 		}
-		else if (builder->ptn.curc.value == SSE_T('['))
+		else if (builder->ptn.curc.value == ASE_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, sse_sizeof(tmp));
+			ADD_CODE (builder, &tmp, ase_sizeof(tmp));
 
 			NEXT_CHAR (builder, LEVEL_CHARSET);
 
 			n = __build_charset (builder, cmd);
 			if (n == -1) return -1;
 
-			sse_awk_assert (builder->awk, n != 0);
+			ase_awk_assert (builder->awk, n != 0);
 
 			if (builder->ptn.curc.type != CT_SPECIAL ||
-			    builder->ptn.curc.value != SSE_T(']'))
+			    builder->ptn.curc.value != ASE_T(']'))
 			{
-				builder->errnum = SSE_AWK_EREXRBRACKET;
+				builder->errnum = ASE_AWK_EREXRBRACKET;
 				return -1;
 			}
 
@@ -615,15 +615,15 @@ static int __build_atom (__builder_t* builder)
 	}
 	else 
 	{
-		sse_awk_assert (builder->awk, builder->ptn.curc.type == CT_NORMAL);
+		ase_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, sse_sizeof(tmp));
+		ADD_CODE (builder, &tmp, ase_sizeof(tmp));
 
-		ADD_CODE (builder, &builder->ptn.curc.value, sse_sizeof(builder->ptn.curc.value));
+		ADD_CODE (builder, &builder->ptn.curc.value, ase_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)
 {
-	sse_size_t zero = 0;
-	sse_size_t old_size;
-	sse_size_t pos_csc, pos_csl;
+	ase_size_t zero = 0;
+	ase_size_t old_size;
+	ase_size_t pos_csc, pos_csl;
 
 	old_size = builder->code.size;
 
 	pos_csc = builder->code.size;
-	ADD_CODE (builder, &zero, sse_sizeof(zero));
+	ADD_CODE (builder, &zero, ase_sizeof(zero));
 
 	pos_csl = builder->code.size;
-	ADD_CODE (builder, &zero, sse_sizeof(zero));
+	ADD_CODE (builder, &zero, ase_sizeof(zero));
 
 	if (builder->ptn.curc.type == CT_NORMAL &&
-	    builder->ptn.curc.value == SSE_T('^')) 
+	    builder->ptn.curc.value == ASE_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)
 	{
-		sse_char_t c0, c1, c2;
+		ase_char_t c0, c1, c2;
 		int cc = 0;
 
 		c1 = builder->ptn.curc.value;
 		NEXT_CHAR(builder, LEVEL_CHARSET);
 
-		if (c1 == SSE_T('[') &&
+		if (c1 == ASE_T('[') &&
 		    builder->ptn.curc.type == CT_NORMAL &&
-		    builder->ptn.curc.value == SSE_T(':'))
+		    builder->ptn.curc.value == ASE_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 == SSE_T('-'))
+		    builder->ptn.curc.value == ASE_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 == SSE_T('[') &&
+				if (c2 == ASE_T('[') &&
 				    builder->ptn.curc.type == CT_NORMAL &&
-				    builder->ptn.curc.value == SSE_T(':'))
+				    builder->ptn.curc.value == ASE_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, sse_sizeof(c0));
-				ADD_CODE (builder, &c1, sse_sizeof(c1));
+				ADD_CODE (builder, &c0, ase_sizeof(c0));
+				ADD_CODE (builder, &c1, ase_sizeof(c1));
 			}
 			else
 			{
 				c0 = CHARSET_RANGE;
-				ADD_CODE (builder, &c0, sse_sizeof(c0));
-				ADD_CODE (builder, &c1, sse_sizeof(c1));
-				ADD_CODE (builder, &c2, sse_sizeof(c2));
+				ADD_CODE (builder, &c0, ase_sizeof(c0));
+				ADD_CODE (builder, &c1, ase_sizeof(c1));
+				ADD_CODE (builder, &c2, ase_sizeof(c2));
 			}
 		}
 		else if (cc == 1)
 		{
 			c0 = CHARSET_CLASS;
-			ADD_CODE (builder, &c0, sse_sizeof(c0));
-			ADD_CODE (builder, &c1, sse_sizeof(c1));
+			ADD_CODE (builder, &c0, ase_sizeof(c0));
+			ADD_CODE (builder, &c1, ase_sizeof(c1));
 		}
 		else
 		{
 			/* invalid range */
 #ifdef DEBUG_REX
-xp_printf (SSE_T("__build_charset: invalid character set range\n"));
+xp_printf (ASE_T("__build_charset: invalid character set range\n"));
 #endif
-			builder->errnum = SSE_AWK_EREXCRANGE;
+			builder->errnum = ASE_AWK_EREXCRANGE;
 			return -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_csc,ase_size_t) += 1;*/
+		SET_CODE (builder, pos_csc, ase_size_t,
+			GET_CODE (builder, pos_csc, ase_size_t) + 1);
 	}
 
-	/*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);
+	/*CODEAT(builder,pos_csl,ase_size_t) = builder->code.size - old_size;*/
+	SET_CODE (builder, pos_csl, ase_size_t, builder->code.size - old_size);
 
 	return 1;
 }
 
-static int __build_cclass (__builder_t* builder, sse_char_t* cc)
+static int __build_cclass (__builder_t* builder, ase_char_t* cc)
 {
 	const struct __char_class_t* ccp = __char_class;
-	sse_size_t len = builder->ptn.end - builder->ptn.curp;
+	ase_size_t len = builder->ptn.end - builder->ptn.curp;
 
-	while (ccp->name != SSE_NULL)
+	while (ccp->name != ASE_NULL)
 	{
 		if (__begin_with (builder->ptn.curp, len, ccp->name)) break;
 		ccp++;
 	}
 
-	if (ccp->name == SSE_NULL)
+	if (ccp->name == ASE_NULL)
 	{
 		/* wrong class name */
 #ifdef DEBUG_REX
-xp_printf (SSE_T("__build_cclass: wrong class name\n"));*/
+xp_printf (ASE_T("__build_cclass: wrong class name\n"));*/
 #endif
-		builder->errnum = SSE_AWK_EREXCCLASS;
+		builder->errnum = ASE_AWK_EREXCCLASS;
 		return -1;
 	}
 
@@ -762,12 +762,12 @@ xp_printf (SSE_T("__build_cclass: wrong class name\n"));*/
 
 	NEXT_CHAR (builder, LEVEL_CHARSET);
 	if (builder->ptn.curc.type != CT_NORMAL ||
-	    builder->ptn.curc.value != SSE_T(':'))
+	    builder->ptn.curc.value != ASE_T(':'))
 	{
 #ifdef BUILD_REX
-xp_printf (SSE_T("__build_cclass: a colon(:) expected\n"));
+xp_printf (ASE_T("__build_cclass: a colon(:) expected\n"));
 #endif
-		builder->errnum = SSE_AWK_EREXCOLON;
+		builder->errnum = ASE_AWK_EREXCOLON;
 		return -1;
 	}
 
@@ -775,18 +775,18 @@ xp_printf (SSE_T("__build_cclass: a colon(:) expected\n"));
 	
 	/* ] happens to be the charset ender ] */
 	if (builder->ptn.curc.type != CT_SPECIAL ||
-	    builder->ptn.curc.value != SSE_T(']'))
+	    builder->ptn.curc.value != ASE_T(']'))
 	{
 #ifdef DEBUG_REX
-xp_printf (SSE_T("__build_cclass: ] expected\n"));
+xp_printf (ASE_T("__build_cclass: ] expected\n"));
 #endif
-		builder->errnum = SSE_AWK_EREXRBRACKET;	
+		builder->errnum = ASE_AWK_EREXRBRACKET;	
 		return -1;
 	}
 
 	NEXT_CHAR (builder, LEVEL_CHARSET);
 
-	*cc = (sse_char_t)(ccp - __char_class);
+	*cc = (ase_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 SSE_T('+'):
+		case ASE_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 SSE_T('*'):
+		case ASE_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 SSE_T('?'):
+		case ASE_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 SSE_T('{'):
+		case ASE_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 != SSE_T('}')) 
+			    builder->ptn.curc.value != ASE_T('}')) 
 			{
-				builder->errnum = SSE_AWK_EREXRBRACE;
+				builder->errnum = ASE_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)
 {
-	sse_size_t bound;
+	ase_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 >= SSE_T('0') && 
-	        builder->ptn.curc.value <= SSE_T('9')))
+	       (builder->ptn.curc.value >= ASE_T('0') && 
+	        builder->ptn.curc.value <= ASE_T('9')))
 	{
-		bound = bound * 10 + builder->ptn.curc.value - SSE_T('0');
+		bound = bound * 10 + builder->ptn.curc.value - ASE_T('0');
 		NEXT_CHAR (builder, LEVEL_RANGE);
 	}
 
 	cmd->lbound = bound;
 
 	if (builder->ptn.curc.type == CT_SPECIAL &&
-	    builder->ptn.curc.value == SSE_T(',')) 
+	    builder->ptn.curc.value == ASE_T(',')) 
 	{
 		NEXT_CHAR (builder, LEVEL_RANGE);
 
 		bound = 0;
 		while (builder->ptn.curc.type == CT_NORMAL &&
-		       (builder->ptn.curc.value >= SSE_T('0') && 
-		        builder->ptn.curc.value <= SSE_T('9')))
+		       (builder->ptn.curc.value >= ASE_T('0') && 
+		        builder->ptn.curc.value <= ASE_T('9')))
 		{
-			bound = bound * 10 + builder->ptn.curc.value - SSE_T('0');
+			bound = bound * 10 + builder->ptn.curc.value - ASE_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 = SSE_AWK_EREXBRANGE;
+		builder->errnum = ASE_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 = SSE_T('\0');
+		builder->ptn.curc.value = ASE_T('\0');
 		return 0;
 	}
 
 	builder->ptn.curc.type = CT_NORMAL;
 	builder->ptn.curc.value = *builder->ptn.curp++;
 
-	if (builder->ptn.curc.value == SSE_T('\\'))
+	if (builder->ptn.curc.value == ASE_T('\\'))
 	{	       
 		if (builder->ptn.curp >= builder->ptn.end)
 		{
-			builder->errnum = SSE_AWK_EREXEND;
+			builder->errnum = ASE_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 == 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(')')) 
+			if (builder->ptn.curc.value == ASE_T('[') ||
+			    builder->ptn.curc.value == ASE_T('|') ||
+			    builder->ptn.curc.value == ASE_T('^') ||
+			    builder->ptn.curc.value == ASE_T('$') ||
+			    builder->ptn.curc.value == ASE_T('{') ||
+			    builder->ptn.curc.value == ASE_T('+') ||
+			    builder->ptn.curc.value == ASE_T('?') ||
+			    builder->ptn.curc.value == ASE_T('*') ||
+			    builder->ptn.curc.value == ASE_T('.') ||
+			    builder->ptn.curc.value == ASE_T('(') ||
+			    builder->ptn.curc.value == ASE_T(')')) 
 			{
 				builder->ptn.curc.type = CT_SPECIAL;
 			}
 		}
 		else if (level == LEVEL_CHARSET)
 		{
-			if (builder->ptn.curc.value == SSE_T(']')) 
+			if (builder->ptn.curc.value == ASE_T(']')) 
 			{
 				builder->ptn.curc.type = CT_SPECIAL;
 			}
 		}
 		else if (level == LEVEL_RANGE)
 		{
-			if (builder->ptn.curc.value == SSE_T(',') ||
-			    builder->ptn.curc.value == SSE_T('}')) 
+			if (builder->ptn.curc.value == ASE_T(',') ||
+			    builder->ptn.curc.value == ASE_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, sse_size_t len)
+static int __add_code (__builder_t* builder, void* data, ase_size_t len)
 {
 	if (len > builder->code.capa - builder->code.size)
 	{
-		sse_size_t capa = builder->code.capa * 2;
-		sse_byte_t* tmp;
+		ase_size_t capa = builder->code.capa * 2;
+		ase_byte_t* tmp;
 		
 		if (capa == 0) capa = DEF_CODE_CAPA;
 		while (len > capa - builder->code.size) { capa = capa * 2; }
 
-		if (builder->awk->syscas.realloc != SSE_NULL)
+		if (builder->awk->syscas.realloc != ASE_NULL)
 		{
-			tmp = (sse_byte_t*) SSE_AWK_REALLOC (
+			tmp = (ase_byte_t*) ASE_AWK_REALLOC (
 				builder->awk, builder->code.buf, capa);
-			if (tmp == SSE_NULL)
+			if (tmp == ASE_NULL)
 			{
-				builder->errnum = SSE_AWK_ENOMEM;
+				builder->errnum = ASE_AWK_ENOMEM;
 				return -1;
 			}
 		}
 		else
 		{
-			tmp = (sse_byte_t*) SSE_AWK_MALLOC (builder->awk, capa);
-			if (tmp == SSE_NULL)
+			tmp = (ase_byte_t*) ASE_AWK_MALLOC (builder->awk, capa);
+			if (tmp == ASE_NULL)
 			{
-				builder->errnum = SSE_AWK_ENOMEM;
+				builder->errnum = ASE_AWK_ENOMEM;
 				return -1;
 			}
 
-			if (builder->code.buf != SSE_NULL)
+			if (builder->code.buf != ASE_NULL)
 			{
-				SSE_AWK_MEMCPY (builder->awk, tmp, 
+				ASE_AWK_MEMCPY (builder->awk, tmp, 
 					builder->code.buf, builder->code.capa);
-				SSE_AWK_FREE (builder->awk, builder->code.buf);
+				ASE_AWK_FREE (builder->awk, builder->code.buf);
 			}
 		}
 
@@ -989,45 +989,45 @@ static int __add_code (__builder_t* builder, void* data, sse_size_t len)
 		builder->code.capa = capa;
 	}
 
-	SSE_AWK_MEMCPY (builder->awk, 
+	ASE_AWK_MEMCPY (builder->awk, 
 		&builder->code.buf[builder->code.size], data, len);
 	builder->code.size += len;
 
 	return 0;
 }
 
-static sse_bool_t __begin_with (
-	const sse_char_t* str, sse_size_t len, const sse_char_t* what)
+static ase_bool_t __begin_with (
+	const ase_char_t* str, ase_size_t len, const ase_char_t* what)
 {
-	const sse_char_t* end = str + len;
+	const ase_char_t* end = str + len;
 
 	while (str < end)
 	{
-		if (*what == SSE_T('\0')) return sse_true;
-		if (*what != *str) return sse_false;
+		if (*what == ASE_T('\0')) return ase_true;
+		if (*what != *str) return ase_false;
 
 		str++; what++;
 	}
 
-	if (*what == SSE_T('\0')) return sse_true;
-	return sse_false;
+	if (*what == ASE_T('\0')) return ase_true;
+	return ase_false;
 }
 
-static const sse_byte_t* __match_pattern (
-	__matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
+static const ase_byte_t* __match_pattern (
+	__matcher_t* matcher, const ase_byte_t* base, __match_t* mat)
 {
-	const sse_byte_t* p;
+	const ase_byte_t* p;
 	__match_t mat2;
-	sse_size_t nb, el, i;
+	ase_size_t nb, el, i;
 
 	p = base;
-	nb = *(sse_size_t*)p; p += sse_sizeof(nb);
-	el = *(sse_size_t*)p; p += sse_sizeof(el);
+	nb = *(ase_size_t*)p; p += ase_sizeof(nb);
+	el = *(ase_size_t*)p; p += ase_sizeof(el);
 
 #ifdef BUILD_REX
-xp_printf (SSE_T("__match_pattern: NB = %u, EL = %u\n"), (unsigned)nb, (unsigned)el);
+xp_printf (ASE_T("__match_pattern: NB = %u, EL = %u\n"), (unsigned)nb, (unsigned)el);
 #endif
-	mat->matched = sse_false;
+	mat->matched = ase_false;
 	mat->match_len = 0;
 
 	for (i = 0; i < nb; i++)
@@ -1035,11 +1035,11 @@ xp_printf (SSE_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 == SSE_NULL) return SSE_NULL;
+		if (p == ASE_NULL) return ASE_NULL;
 
 		if (mat2.matched)
 		{
-			mat->matched = sse_true;
+			mat->matched = ase_true;
 			mat->match_len = mat2.match_len;
 			break;
 		}
@@ -1048,32 +1048,32 @@ xp_printf (SSE_T("__match_pattern: NB = %u, EL = %u\n"), (unsigned)nb, (unsigned
 	return base + el;
 }
 
-static const sse_byte_t* __match_branch (
-	__matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
+static const ase_byte_t* __match_branch (
+	__matcher_t* matcher, const ase_byte_t* base, __match_t* mat)
 {
 	/*
 	 * branch body (base+sizeof(NA)+sizeof(BL)---+
 	 * BL=base+sizeof(NA) ---------+             |
 	 * base=NA ------+             |             |
 	 *               |             |             |
-	 *               |NA(sse_size_t)|BL(sse_size_t)|ATOMS.........|
+	 *               |NA(ase_size_t)|BL(ase_size_t)|ATOMS.........|
 	 */
 	mat->branch = base;
-	mat->branch_end = base + *((sse_size_t*)(base+sse_sizeof(sse_size_t)));
+	mat->branch_end = base + *((ase_size_t*)(base+ase_sizeof(ase_size_t)));
 
 	return __match_branch_body (
-		matcher, base+sse_sizeof(sse_size_t)*2, mat);
+		matcher, base+ase_sizeof(ase_size_t)*2, mat);
 }
 
-static const sse_byte_t* __match_branch_body (
-	__matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
+static const ase_byte_t* __match_branch_body (
+	__matcher_t* matcher, const ase_byte_t* base, __match_t* mat)
 {
-	const sse_byte_t* n;
+	const ase_byte_t* n;
 
 	if (matcher->depth.max > 0 && matcher->depth.cur >= matcher->depth.max)
 	{
-		matcher->errnum = SSE_AWK_ERECURSION;
-		return SSE_NULL;
+		matcher->errnum = ASE_AWK_ERECURSION;
+		return ASE_NULL;
 	}
 
 	matcher->depth.cur++;
@@ -1083,14 +1083,14 @@ static const sse_byte_t* __match_branch_body (
 	return n;
 }
 
-static const sse_byte_t* __match_branch_body0 (
-	__matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
+static const ase_byte_t* __match_branch_body0 (
+	__matcher_t* matcher, const ase_byte_t* base, __match_t* mat)
 {
-	const sse_byte_t* p;
+	const ase_byte_t* p;
 /*	__match_t mat2;*/
-	sse_size_t match_len = 0;
+	ase_size_t match_len = 0;
 
-	mat->matched = sse_false;
+	mat->matched = ase_false;
 	mat->match_len = 0;
 
 /* TODO: is mat2 necessary here ? */
@@ -1105,7 +1105,7 @@ static const sse_byte_t* __match_branch_body0 (
 	while (p < mat->branch_end)
 	{
 		p = __match_atom (matcher, p, mat);
-		if (p == SSE_NULL) return SSE_NULL;
+		if (p == ASE_NULL) return ASE_NULL;
 
 		if (!mat->matched) break;
 
@@ -1113,15 +1113,15 @@ static const sse_byte_t* __match_branch_body0 (
 		match_len += mat->match_len;
 #if 0
 		p = __match_atom (matcher, p, &mat2);
-		if (p == SSE_NULL) return SSE_NULL;
+		if (p == ASE_NULL) return ASE_NULL;
 
 		if (!mat2.matched) 
 		{
-			mat->matched = sse_false;
+			mat->matched = ase_false;
 			break; /* stop matching */
 		}
 
-		mat->matched = sse_true;
+		mat->matched = ase_true;
 		mat->match_len += mat2.match_len;
 
 		mat2.match_ptr = &mat2.match_ptr[mat2.match_len];
@@ -1132,8 +1132,8 @@ static const sse_byte_t* __match_branch_body0 (
 	return mat->branch_end;
 }
 
-static const sse_byte_t* __match_atom (
-	__matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
+static const ase_byte_t* __match_atom (
+	__matcher_t* matcher, const ase_byte_t* base, __match_t* mat)
 {
 	static atom_matcher_t matchers[] =
 	{
@@ -1145,21 +1145,21 @@ static const sse_byte_t* __match_atom (
 		__match_group
 	};
        
-	sse_awk_assert (matcher->awk, 
+	ase_awk_assert (matcher->awk, 
 		((struct __code_t*)base)->cmd >= 0 && 
-		((struct __code_t*)base)->cmd < sse_countof(matchers));
+		((struct __code_t*)base)->cmd < ase_countof(matchers));
 
 	return matchers[((struct __code_t*)base)->cmd] (matcher, base, mat);
 }
 
-static const sse_byte_t* __match_bol (
-	__matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
+static const ase_byte_t* __match_bol (
+	__matcher_t* matcher, const ase_byte_t* base, __match_t* mat)
 {
-	const sse_byte_t* p = base;
+	const ase_byte_t* p = base;
 	const struct __code_t* cp;
 
-	cp = (const struct __code_t*)p; p += sse_sizeof(*cp);
-	sse_awk_assert (matcher->awk, cp->cmd == CMD_BOL);
+	cp = (const struct __code_t*)p; p += ase_sizeof(*cp);
+	ase_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 sse_byte_t* __match_bol (
 	return p;
 }
 
-static const sse_byte_t* __match_eol (
-	__matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
+static const ase_byte_t* __match_eol (
+	__matcher_t* matcher, const ase_byte_t* base, __match_t* mat)
 {
-	const sse_byte_t* p = base;
+	const ase_byte_t* p = base;
 	const struct __code_t* cp;
 
-	cp = (const struct __code_t*)p; p += sse_sizeof(*cp);
-	sse_awk_assert (matcher->awk, cp->cmd == CMD_EOL);
+	cp = (const struct __code_t*)p; p += ase_sizeof(*cp);
+	ase_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 sse_byte_t* __match_eol (
 	return p;
 }
 
-static const sse_byte_t* __match_any_char (
-	__matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
+static const ase_byte_t* __match_any_char (
+	__matcher_t* matcher, const ase_byte_t* base, __match_t* mat)
 {
-	const sse_byte_t* p = base;
+	const ase_byte_t* p = base;
 	const struct __code_t* cp;
-	sse_size_t si = 0, lbound, ubound;
+	ase_size_t si = 0, lbound, ubound;
 
-	cp = (const struct __code_t*)p; p += sse_sizeof(*cp);
-	sse_awk_assert (matcher->awk, cp->cmd == CMD_ANY_CHAR);
+	cp = (const struct __code_t*)p; p += ase_sizeof(*cp);
+	ase_awk_assert (matcher->awk, cp->cmd == CMD_ANY_CHAR);
 
 	lbound = cp->lbound;
 	ubound = cp->ubound;
 
-	mat->matched = sse_false;
+	mat->matched = ase_false;
 	mat->match_len = 0;
 
 	/* merge the same consecutive codes */
@@ -1207,11 +1207,11 @@ static const sse_byte_t* __match_any_char (
 		lbound += ((const struct __code_t*)p)->lbound;
 		ubound += ((const struct __code_t*)p)->ubound;
 
-		p += sse_sizeof(*cp);
+		p += ase_sizeof(*cp);
 	}
 
 #ifdef BUILD_REX
-xp_printf (SSE_T("__match_any_char: lbound = %u, ubound = %u\n"), 
+xp_printf (ASE_T("__match_any_char: lbound = %u, ubound = %u\n"), 
       (unsigned int)lbound, (unsigned int)ubound);
 #endif
 
@@ -1223,7 +1223,7 @@ xp_printf (SSE_T("__match_any_char: lbound = %u, ubound = %u\n"),
 	}
 
 #ifdef BUILD_REX
-xp_printf (SSE_T("__match_any_char: max si = %d\n"), si);
+xp_printf (ASE_T("__match_any_char: max si = %d\n"), si);
 #endif
 	if (si >= lbound && si <= ubound)
 	{
@@ -1233,22 +1233,22 @@ xp_printf (SSE_T("__match_any_char: max si = %d\n"), si);
 	return p;
 }
 
-static const sse_byte_t* __match_ord_char (
-	__matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
+static const ase_byte_t* __match_ord_char (
+	__matcher_t* matcher, const ase_byte_t* base, __match_t* mat)
 {
-	const sse_byte_t* p = base;
+	const ase_byte_t* p = base;
 	const struct __code_t* cp;
-	sse_size_t si = 0, lbound, ubound;
-	sse_char_t cc;
+	ase_size_t si = 0, lbound, ubound;
+	ase_char_t cc;
 
-	cp = (const struct __code_t*)p; p += sse_sizeof(*cp);
-	sse_awk_assert (matcher->awk, cp->cmd == CMD_ORD_CHAR);
+	cp = (const struct __code_t*)p; p += ase_sizeof(*cp);
+	ase_awk_assert (matcher->awk, cp->cmd == CMD_ORD_CHAR);
 
 	lbound = cp->lbound; 
 	ubound = cp->ubound;
 
-	cc = *(sse_char_t*)p; p += sse_sizeof(cc);
-	if (matcher->ignorecase) cc = SSE_AWK_TOUPPER(matcher->awk, cc);
+	cc = *(ase_char_t*)p; p += ase_sizeof(cc);
+	if (matcher->ignorecase) cc = ASE_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 sse_byte_t* __match_ord_char (
 		while (p < mat->branch_end &&
 		       cp->cmd == ((const struct __code_t*)p)->cmd)
 		{
-			if (SSE_AWK_TOUPPER (matcher->awk, *(sse_char_t*)(p+sse_sizeof(*cp))) != cc) break;
+			if (ASE_AWK_TOUPPER (matcher->awk, *(ase_char_t*)(p+ase_sizeof(*cp))) != cc) break;
 
 			lbound += ((const struct __code_t*)p)->lbound;
 			ubound += ((const struct __code_t*)p)->ubound;
 
-			p += sse_sizeof(*cp) + sse_sizeof(cc);
+			p += ase_sizeof(*cp) + ase_sizeof(cc);
 		}
 	}
 	else
@@ -1271,21 +1271,21 @@ static const sse_byte_t* __match_ord_char (
 		while (p < mat->branch_end &&
 		       cp->cmd == ((const struct __code_t*)p)->cmd)
 		{
-			if (*(sse_char_t*)(p+sse_sizeof(*cp)) != cc) break;
+			if (*(ase_char_t*)(p+ase_sizeof(*cp)) != cc) break;
 
 			lbound += ((const struct __code_t*)p)->lbound;
 			ubound += ((const struct __code_t*)p)->ubound;
 
-			p += sse_sizeof(*cp) + sse_sizeof(cc);
+			p += ase_sizeof(*cp) + ase_sizeof(cc);
 		}
 	}
 	
 #ifdef BUILD_REX
-xp_printf (SSE_T("__match_ord_char: lbound = %u, ubound = %u\n"), 
+xp_printf (ASE_T("__match_ord_char: lbound = %u, ubound = %u\n"), 
   (unsigned int)lbound, (unsigned int)ubound);*/
 #endif
 
-	mat->matched = sse_false;
+	mat->matched = ase_false;
 	mat->match_len = 0;
 
 	/* find the longest match */
@@ -1294,7 +1294,7 @@ xp_printf (SSE_T("__match_ord_char: lbound = %u, ubound = %u\n"),
 		while (si < ubound)
 		{
 			if (&mat->match_ptr[si] >= matcher->match.str.end) break;
-			if (cc != SSE_AWK_TOUPPER (matcher->awk, mat->match_ptr[si])) break;
+			if (cc != ASE_AWK_TOUPPER (matcher->awk, mat->match_ptr[si])) break;
 			si++;
 		}
 	}
@@ -1309,7 +1309,7 @@ xp_printf (SSE_T("__match_ord_char: lbound = %u, ubound = %u\n"),
 	}
 
 #ifdef DEBUG_REX
-xp_printf (SSE_T("__match_ord_char: max si = %d, lbound = %u, ubound = %u\n"), si, lbound, ubound);
+xp_printf (ASE_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 (SSE_T("__match_ord_char: max si = %d, lbound = %u, ubound = %u\n"), s
 	return p;
 }
 
-static const sse_byte_t* __match_charset (
-	__matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
+static const ase_byte_t* __match_charset (
+	__matcher_t* matcher, const ase_byte_t* base, __match_t* mat)
 {
-	const sse_byte_t* p = base;
+	const ase_byte_t* p = base;
 	const struct __code_t* cp;
-	sse_size_t si = 0, lbound, ubound, csc, csl;
-	sse_bool_t n;
-	sse_char_t c;
+	ase_size_t si = 0, lbound, ubound, csc, csl;
+	ase_bool_t n;
+	ase_char_t c;
 
-	cp = (const struct __code_t*)p; p += sse_sizeof(*cp);
-	sse_awk_assert (matcher->awk, cp->cmd == CMD_CHARSET);
+	cp = (const struct __code_t*)p; p += ase_sizeof(*cp);
+	ase_awk_assert (matcher->awk, cp->cmd == CMD_CHARSET);
 
 	lbound = cp->lbound;
 	ubound = cp->ubound;
 
-	csc = *(sse_size_t*)p; p += sse_sizeof(csc);
-	csl = *(sse_size_t*)p; p += sse_sizeof(csl);
+	csc = *(ase_size_t*)p; p += ase_sizeof(csc);
+	csl = *(ase_size_t*)p; p += ase_sizeof(csl);
 
-	mat->matched = sse_false;
+	mat->matched = ase_false;
 	mat->match_len = 0;
 
 	while (si < ubound)
@@ -1346,7 +1346,7 @@ static const sse_byte_t* __match_charset (
 		if (&mat->match_ptr[si] >= matcher->match.str.end) break;
 
 		c = mat->match_ptr[si];
-		if (matcher->ignorecase) c = SSE_AWK_TOUPPER(matcher->awk, c);
+		if (matcher->ignorecase) c = ASE_AWK_TOUPPER(matcher->awk, c);
 
 		n = __test_charset (matcher, p, csc, c);
 		if (cp->negate) n = !n;
@@ -1355,7 +1355,7 @@ static const sse_byte_t* __match_charset (
 		si++;
 	}
 
-	p = p + csl - (sse_sizeof(csc) + sse_sizeof(csl));
+	p = p + csl - (ase_sizeof(csc) + ase_sizeof(csl));
 
 	if (si >= lbound && si <= ubound)
 	{
@@ -1365,18 +1365,18 @@ static const sse_byte_t* __match_charset (
 	return p;
 }
 
-static const sse_byte_t* __match_group (
-	__matcher_t* matcher, const sse_byte_t* base, __match_t* mat)
+static const ase_byte_t* __match_group (
+	__matcher_t* matcher, const ase_byte_t* base, __match_t* mat)
 {
-	const sse_byte_t* p = base;
+	const ase_byte_t* p = base;
 	const struct __code_t* cp;
 	__match_t mat2;
-	sse_size_t si = 0, grp_len_static[16], * grp_len;
+	ase_size_t si = 0, grp_len_static[16], * grp_len;
 
-	cp = (const struct __code_t*)p; p += sse_sizeof(*cp);
-	sse_awk_assert (matcher->awk, cp->cmd == CMD_GROUP);
+	cp = (const struct __code_t*)p; p += ase_sizeof(*cp);
+	ase_awk_assert (matcher->awk, cp->cmd == CMD_GROUP);
 
-	mat->matched = sse_false;
+	mat->matched = ase_false;
 	mat->match_len = 0;
 	
 	/* 
@@ -1403,18 +1403,18 @@ static const sse_byte_t* __match_group (
 	 *                     abcabcabcxyz
 	 */
 
-	if (cp->ubound < sse_countof(grp_len_static))
+	if (cp->ubound < ase_countof(grp_len_static))
 	{
 		grp_len = grp_len_static;
 	}
 	else 
 	{
-		grp_len = (sse_size_t*) SSE_AWK_MALLOC (
-			matcher->awk, sse_sizeof(sse_size_t) * cp->ubound);
-		if (grp_len == SSE_NULL)
+		grp_len = (ase_size_t*) ASE_AWK_MALLOC (
+			matcher->awk, ase_sizeof(ase_size_t) * cp->ubound);
+		if (grp_len == ASE_NULL)
 		{
-			matcher->errnum = SSE_AWK_ENOMEM;
-			return SSE_NULL;
+			matcher->errnum = ASE_AWK_ENOMEM;
+			return ASE_NULL;
 		}
 	}
 
@@ -1425,11 +1425,11 @@ static const sse_byte_t* __match_group (
 	{
 		if (mat2.match_ptr >= matcher->match.str.end) break;
 
-		if (__match_pattern (matcher, p, &mat2) == SSE_NULL) 
+		if (__match_pattern (matcher, p, &mat2) == ASE_NULL) 
 		{
 			if (grp_len != grp_len_static) 
-				SSE_AWK_FREE (matcher->awk, grp_len);
-			return SSE_NULL;
+				ASE_AWK_FREE (matcher->awk, grp_len);
+			return ASE_NULL;
 		}
 		if (!mat2.matched) break;
 
@@ -1437,48 +1437,48 @@ static const sse_byte_t* __match_group (
 
 		mat2.match_ptr += mat2.match_len;
 		mat2.match_len = 0;
-		mat2.matched = sse_false;
+		mat2.matched = ase_false;
 
 		si++;
 	}
 
 	/* increment p by the length of the subpattern */
-	p += *(sse_size_t*)(p+sse_sizeof(sse_size_t));
+	p += *(ase_size_t*)(p+ase_sizeof(ase_size_t));
 
 	/* check the occurrences */
 	if (si >= cp->lbound && si <= cp->ubound)
 	{
 		if (cp->lbound == cp->ubound || p >= mat->branch_end)
 		{
-			mat->matched = sse_true;
+			mat->matched = ase_true;
 			mat->match_len = grp_len[si];
 		}
 		else 
 		{
-			sse_awk_assert (matcher->awk, cp->ubound > cp->lbound);
+			ase_awk_assert (matcher->awk, cp->ubound > cp->lbound);
 
 			do
 			{
-				const sse_byte_t* tmp;
+				const ase_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 (SSE_T("__match_group: GROUP si = %d [%s]\n"), si, mat->match_ptr);
+xp_printf (ASE_T("__match_group: GROUP si = %d [%s]\n"), si, mat->match_ptr);
 #endif
 				tmp = __match_branch_body (matcher, p, &mat2);
-				if (tmp == SSE_NULL)
+				if (tmp == ASE_NULL)
 				{
 					if (grp_len != grp_len_static) 
-						SSE_AWK_FREE (matcher->awk, grp_len);
-					return SSE_NULL;
+						ASE_AWK_FREE (matcher->awk, grp_len);
+					return ASE_NULL;
 				}
 
 				if (mat2.matched)
 				{
-					mat->matched = sse_true;
+					mat->matched = ase_true;
 					mat->match_len = grp_len[si] + mat2.match_len;
 					p = tmp;
 					break;
@@ -1492,15 +1492,15 @@ xp_printf (SSE_T("__match_group: GROUP si = %d [%s]\n"), si, mat->match_ptr);
 
 	}
 
-	if (grp_len != grp_len_static) SSE_AWK_FREE (matcher->awk, grp_len);
+	if (grp_len != grp_len_static) ASE_AWK_FREE (matcher->awk, grp_len);
 	return p;
 }
 
-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 const ase_byte_t* __match_occurrences (
+	__matcher_t* matcher, ase_size_t si, const ase_byte_t* p,
+	ase_size_t lbound, ase_size_t ubound, __match_t* mat)
 {
-	sse_awk_assert (matcher->awk, si >= lbound && si <= ubound);
+	ase_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 sse_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 = sse_true;
+		mat->matched = ase_true;
 		mat->match_len = si;
 	}
 	else 
@@ -1553,25 +1553,25 @@ static const sse_byte_t* __match_occurrences (
 		 * lbound in the implementation below, though)
 		 */
 
-		sse_awk_assert (matcher->awk, ubound > lbound);
+		ase_awk_assert (matcher->awk, ubound > lbound);
 
 		do
 		{
 			__match_t mat2;
-			const sse_byte_t* tmp;
+			const ase_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 (SSE_T("__match occurrences: si = %d [%s]\n"), si, mat->match_ptr);
+xp_printf (ASE_T("__match occurrences: si = %d [%s]\n"), si, mat->match_ptr);
 #endif
 			tmp = __match_branch_body (matcher, p, &mat2);
 
 			if (mat2.matched)
 			{
-				mat->matched = sse_true;
+				mat->matched = ase_true;
 				mat->match_len = si + mat2.match_len;
 				p = tmp;
 				break;
@@ -1586,149 +1586,149 @@ xp_printf (SSE_T("__match occurrences: si = %d [%s]\n"), si, mat->match_ptr);
 	return p;
 }
 
-sse_bool_t __test_charset (
-	__matcher_t* matcher, const sse_byte_t* p, sse_size_t csc, sse_char_t c)
+ase_bool_t __test_charset (
+	__matcher_t* matcher, const ase_byte_t* p, ase_size_t csc, ase_char_t c)
 {
-	sse_size_t i;
+	ase_size_t i;
 
 	for (i = 0; i < csc; i++)
 	{
-		sse_char_t c0, c1, c2;
+		ase_char_t c0, c1, c2;
 
-		c0 = *(sse_char_t*)p;
-		p += sse_sizeof(c0);
+		c0 = *(ase_char_t*)p;
+		p += ase_sizeof(c0);
 		if (c0 == CHARSET_ONE)
 		{
-			c1 = *(sse_char_t*)p;
+			c1 = *(ase_char_t*)p;
 			if (matcher->ignorecase) 
-				c1 = SSE_AWK_TOUPPER(matcher->awk, c1);
-			if (c == c1) return sse_true;
+				c1 = ASE_AWK_TOUPPER(matcher->awk, c1);
+			if (c == c1) return ase_true;
 		}
 		else if (c0 == CHARSET_RANGE)
 		{
-			c1 = *(sse_char_t*)p;
-			p += sse_sizeof(c1);
-			c2 = *(sse_char_t*)p;
+			c1 = *(ase_char_t*)p;
+			p += ase_sizeof(c1);
+			c2 = *(ase_char_t*)p;
 
 			if (matcher->ignorecase) 
 			{
-				c1 = SSE_AWK_TOUPPER(matcher->awk, c1);
-				c2 = SSE_AWK_TOUPPER(matcher->awk, c2);
+				c1 = ASE_AWK_TOUPPER(matcher->awk, c1);
+				c2 = ASE_AWK_TOUPPER(matcher->awk, c2);
 			}
-			if (c >= c1 && c <= c2) return sse_true;
+			if (c >= c1 && c <= c2) return ase_true;
 		}
 		else if (c0 == CHARSET_CLASS)
 		{
-			c1 = *(sse_char_t*)p;
+			c1 = *(ase_char_t*)p;
 			if (__char_class[c1].func (
-				matcher->awk, c)) return sse_true;
+				matcher->awk, c)) return ase_true;
 		}
 		else
 		{
-			sse_awk_assert (matcher->awk,
+			ase_awk_assert (matcher->awk,
 				!"should never happen - invalid charset code");
 			break;
 		}
 
-		p += sse_sizeof(c1);
+		p += ase_sizeof(c1);
 	}
 
-	return sse_false;
+	return ase_false;
 }
 
-static sse_bool_t __cc_isalnum (sse_awk_t* awk, sse_char_t c)
+static ase_bool_t __cc_isalnum (ase_awk_t* awk, ase_char_t c)
 {
-	return SSE_AWK_ISALNUM (awk, c);
+	return ASE_AWK_ISALNUM (awk, c);
 }
 
-static sse_bool_t __cc_isalpha (sse_awk_t* awk, sse_char_t c)
+static ase_bool_t __cc_isalpha (ase_awk_t* awk, ase_char_t c)
 {
-	return SSE_AWK_ISALPHA (awk, c);
+	return ASE_AWK_ISALPHA (awk, c);
 }
 
-static sse_bool_t __cc_isblank (sse_awk_t* awk, sse_char_t c)
+static ase_bool_t __cc_isblank (ase_awk_t* awk, ase_char_t c)
 {
-	return c == SSE_T(' ') || c == SSE_T('\t');
+	return c == ASE_T(' ') || c == ASE_T('\t');
 }
 
-static sse_bool_t __cc_iscntrl (sse_awk_t* awk, sse_char_t c)
+static ase_bool_t __cc_iscntrl (ase_awk_t* awk, ase_char_t c)
 {
-	return SSE_AWK_ISCNTRL (awk, c);
+	return ASE_AWK_ISCNTRL (awk, c);
 }
 
-static sse_bool_t __cc_isdigit (sse_awk_t* awk, sse_char_t c)
+static ase_bool_t __cc_isdigit (ase_awk_t* awk, ase_char_t c)
 {
-	return SSE_AWK_ISDIGIT (awk, c);
+	return ASE_AWK_ISDIGIT (awk, c);
 }
 
-static sse_bool_t __cc_isgraph (sse_awk_t* awk, sse_char_t c)
+static ase_bool_t __cc_isgraph (ase_awk_t* awk, ase_char_t c)
 {
-	return SSE_AWK_ISGRAPH (awk, c);
+	return ASE_AWK_ISGRAPH (awk, c);
 }
 
-static sse_bool_t __cc_islower (sse_awk_t* awk, sse_char_t c)
+static ase_bool_t __cc_islower (ase_awk_t* awk, ase_char_t c)
 {
-	return SSE_AWK_ISLOWER (awk, c);
+	return ASE_AWK_ISLOWER (awk, c);
 }
 
-static sse_bool_t __cc_isprint (sse_awk_t* awk, sse_char_t c)
+static ase_bool_t __cc_isprint (ase_awk_t* awk, ase_char_t c)
 {
-	return SSE_AWK_ISPRINT (awk, c);
+	return ASE_AWK_ISPRINT (awk, c);
 }
 
-static sse_bool_t __cc_ispunct (sse_awk_t* awk, sse_char_t c)
+static ase_bool_t __cc_ispunct (ase_awk_t* awk, ase_char_t c)
 {
-	return SSE_AWK_ISPUNCT (awk, c);
+	return ASE_AWK_ISPUNCT (awk, c);
 }
 
-static sse_bool_t __cc_isspace (sse_awk_t* awk, sse_char_t c)
+static ase_bool_t __cc_isspace (ase_awk_t* awk, ase_char_t c)
 {
-	return SSE_AWK_ISSPACE (awk, c);
+	return ASE_AWK_ISSPACE (awk, c);
 }
 
-static sse_bool_t __cc_isupper (sse_awk_t* awk, sse_char_t c)
+static ase_bool_t __cc_isupper (ase_awk_t* awk, ase_char_t c)
 {
-	return SSE_AWK_ISUPPER (awk, c);
+	return ASE_AWK_ISUPPER (awk, c);
 }
 
-static sse_bool_t __cc_isxdigit (sse_awk_t* awk, sse_char_t c)
+static ase_bool_t __cc_isxdigit (ase_awk_t* awk, ase_char_t c)
 {
-	return SSE_AWK_ISXDIGIT (awk, c);
+	return ASE_AWK_ISXDIGIT (awk, c);
 }
 
-void sse_awk_printrex (void* rex)
+void ase_awk_printrex (void* rex)
 {
 	__print_pattern (rex);
-	xp_printf (SSE_T("\n"));
+	xp_printf (ASE_T("\n"));
 }
 
-static const sse_byte_t* __print_pattern (const sse_byte_t* p)
+static const ase_byte_t* __print_pattern (const ase_byte_t* p)
 {
-	sse_size_t nb, el, i;
+	ase_size_t nb, el, i;
 
-	nb = *(sse_size_t*)p; p += sse_sizeof(nb);
-	el = *(sse_size_t*)p; p += sse_sizeof(el);
+	nb = *(ase_size_t*)p; p += ase_sizeof(nb);
+	el = *(ase_size_t*)p; p += ase_sizeof(el);
 #ifdef DEBUG_REX
-xp_printf (SSE_T("__print_pattern: NB = %u, EL = %u\n"), (unsigned int)nb, (unsigned int)el);
+xp_printf (ASE_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 (SSE_T("|"));
+		if (i != 0) xp_printf (ASE_T("|"));
 		p = __print_branch (p);
 	}
 
 	return p;
 }
 
-static const sse_byte_t* __print_branch (const sse_byte_t* p)
+static const ase_byte_t* __print_branch (const ase_byte_t* p)
 {
-	sse_size_t na, bl, i;
+	ase_size_t na, bl, i;
 
-	na = *(sse_size_t*)p; p += sse_sizeof(na);
-	bl = *(sse_size_t*)p; p += sse_sizeof(bl);
+	na = *(ase_size_t*)p; p += ase_sizeof(na);
+	bl = *(ase_size_t*)p; p += ase_sizeof(bl);
 #ifdef DEBUG_REX
-xp_printf (SSE_T("__print_branch: NA = %u, BL = %u\n"), (unsigned int) na, (unsigned int)bl);
+xp_printf (ASE_T("__print_branch: NA = %u, BL = %u\n"), (unsigned int) na, (unsigned int)bl);
 #endif
 
 	for (i = 0; i < na; i++)
@@ -1739,82 +1739,82 @@ xp_printf (SSE_T("__print_branch: NA = %u, BL = %u\n"), (unsigned int) na, (unsi
 	return p;
 }
 
-static const sse_byte_t* __print_atom (const sse_byte_t* p)
+static const ase_byte_t* __print_atom (const ase_byte_t* p)
 {
 	const struct __code_t* cp = (const struct __code_t*)p;
 
 	if (cp->cmd == CMD_BOL)
 	{
-		xp_printf (SSE_T("^"));
-		p += sse_sizeof(*cp);
+		xp_printf (ASE_T("^"));
+		p += ase_sizeof(*cp);
 	}
 	else if (cp->cmd == CMD_EOL)
 	{
-		xp_printf (SSE_T("$"));
-		p += sse_sizeof(*cp);
+		xp_printf (ASE_T("$"));
+		p += ase_sizeof(*cp);
 	}
 	else if (cp->cmd == CMD_ANY_CHAR) 
 	{
-		xp_printf (SSE_T("."));
-		p += sse_sizeof(*cp);
+		xp_printf (ASE_T("."));
+		p += ase_sizeof(*cp);
 	}
 	else if (cp->cmd == CMD_ORD_CHAR) 
 	{
-		p += sse_sizeof(*cp);
-		xp_printf (SSE_T("%c"), *(sse_char_t*)p);
-		p += sse_sizeof(sse_char_t);
+		p += ase_sizeof(*cp);
+		xp_printf (ASE_T("%c"), *(ase_char_t*)p);
+		p += ase_sizeof(ase_char_t);
 	}
 	else if (cp->cmd == CMD_CHARSET)
 	{
-		sse_size_t csc, csl, i;
+		ase_size_t csc, csl, i;
 
-		p += sse_sizeof(*cp);
-		xp_printf (SSE_T("["));
-		if (cp->negate) xp_printf (SSE_T("^"));
+		p += ase_sizeof(*cp);
+		xp_printf (ASE_T("["));
+		if (cp->negate) xp_printf (ASE_T("^"));
 
-		csc = *(sse_size_t*)p; p += sse_sizeof(csc);
-		csl = *(sse_size_t*)p; p += sse_sizeof(csl);
+		csc = *(ase_size_t*)p; p += ase_sizeof(csc);
+		csl = *(ase_size_t*)p; p += ase_sizeof(csl);
 
 		for (i = 0; i < csc; i++)
 		{
-			sse_char_t c0, c1, c2;
+			ase_char_t c0, c1, c2;
 
-			c0 = *(sse_char_t*)p;
-			p += sse_sizeof(c0);
+			c0 = *(ase_char_t*)p;
+			p += ase_sizeof(c0);
 
 			if (c0 == CHARSET_ONE)
 			{
-				c1 = *(sse_char_t*)p;
-				xp_printf (SSE_T("%c"), c1);
+				c1 = *(ase_char_t*)p;
+				xp_printf (ASE_T("%c"), c1);
 			}
 			else if (c0 == CHARSET_RANGE)
 			{
-				c1 = *(sse_char_t*)p;
-				p += sse_sizeof(c1);
-				c2 = *(sse_char_t*)p;
-				xp_printf (SSE_T("%c-%c"), c1, c2);
+				c1 = *(ase_char_t*)p;
+				p += ase_sizeof(c1);
+				c2 = *(ase_char_t*)p;
+				xp_printf (ASE_T("%c-%c"), c1, c2);
 			}
 			else if (c0 == CHARSET_CLASS)
 			{
-				c1 = *(sse_char_t*)p;
-				xp_printf (SSE_T("[:%s:]"), __char_class[c1].name);
+				c1 = *(ase_char_t*)p;
+				xp_printf (ASE_T("[:%s:]"), __char_class[c1].name);
 			}
 			else
 			{
 				xp_printf ("should never happen - invalid charset code\n");
 			}
 
-			p += sse_sizeof(c1);
+			p += ase_sizeof(c1);
 		}
 
-		xp_printf (SSE_T("]"));
+		xp_printf (ASE_T("]"));
 	}
 	else if (cp->cmd == CMD_GROUP)
 	{
-		p += sse_sizeof(*cp);
-		xp_printf (SSE_T("("));
+		p += ase_sizeof(*cp);
+		xp_printf (ASE_T("("));
 		p = __print_pattern (p);
-		xp_printf (SSE_T(")"));
+		xp_printf (ASE_T(")"));
 	}
 	else 
 	{
@@ -1822,14 +1822,14 @@ static const sse_byte_t* __print_atom (const sse_byte_t* p)
 	}
 
 	if (cp->lbound == 0 && cp->ubound == BOUND_MAX)
-		xp_printf (SSE_T("*"));
+		xp_printf (ASE_T("*"));
 	else if (cp->lbound == 1 && cp->ubound == BOUND_MAX)
-		xp_printf (SSE_T("+"));
+		xp_printf (ASE_T("+"));
 	else if (cp->lbound == 0 && cp->ubound == 1)
-		xp_printf (SSE_T("?"));
+		xp_printf (ASE_T("?"));
 	else if (cp->lbound != 1 || cp->ubound != 1)
 	{
-		xp_printf (SSE_T("{%lu,%lu}"), 
+		xp_printf (ASE_T("{%lu,%lu}"), 
 			(unsigned long)cp->lbound, (unsigned long)cp->ubound);
 	}
 
diff --git a/ase/awk/rex.h b/ase/awk/rex.h
index e592b084..138f5e3c 100644
--- a/ase/awk/rex.h
+++ b/ase/awk/rex.h
@@ -1,12 +1,12 @@
 /*
- * $Id: rex.h,v 1.20 2006-10-22 12:39:29 bacon Exp $
+ * $Id: rex.h,v 1.21 2006-10-24 04:10:12 bacon Exp $
  **/
 
-#ifndef _SSE_AWK_REX_H_
-#define _SSE_AWK_REX_H_
+#ifndef _ASE_AWK_REX_H_
+#define _ASE_AWK_REX_H_
 
-#include <sse/types.h>
-#include <sse/macros.h>
+#include <ase/types.h>
+#include <ase/macros.h>
 
 
 /*
@@ -37,34 +37,34 @@
  *   ab|xy -> |2|10|4|ORD_CHAR(no bound)|a|ORD_CHAR(no bound)|b|4|ORD_CHAR(no bound)|x|ORD_CHAR(no bound)|y|
  */
 
-#define SSE_AWK_REX_NA(code) (*(sse_size_t*)(code))
+#define ASE_AWK_REX_NA(code) (*(ase_size_t*)(code))
 
-#define SSE_AWK_REX_LEN(code) \
-	(*(sse_size_t*)((sse_byte_t*)(code)+sse_sizeof(sse_size_t)))
+#define ASE_AWK_REX_LEN(code) \
+	(*(ase_size_t*)((ase_byte_t*)(code)+ase_sizeof(ase_size_t)))
 
-enum sse_awk_rex_option_t
+enum ase_awk_rex_option_t
 {
-	SSE_AWK_REX_IGNORECASE = (1 << 0)
+	ASE_AWK_REX_IGNORECASE = (1 << 0)
 };
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-void* sse_awk_buildrex (
-	sse_awk_t* awk, const sse_char_t* ptn, 
-	sse_size_t len, int* errnum);
+void* ase_awk_buildrex (
+	ase_awk_t* awk, const ase_char_t* ptn, 
+	ase_size_t len, int* errnum);
 
-int sse_awk_matchrex (
-	sse_awk_t* awk, void* code, int option,
-	const sse_char_t* str, sse_size_t len, 
-	const sse_char_t** match_ptr, sse_size_t* match_len, int* errnum);
+int ase_awk_matchrex (
+	ase_awk_t* awk, void* code, int option,
+	const ase_char_t* str, ase_size_t len, 
+	const ase_char_t** match_ptr, ase_size_t* match_len, int* errnum);
 
-void sse_awk_freerex (sse_awk_t* awk, void* code);
+void ase_awk_freerex (ase_awk_t* awk, void* code);
 
-sse_bool_t sse_awk_isemptyrex (sse_awk_t* awk, void* code);
+ase_bool_t ase_awk_isemptyrex (ase_awk_t* awk, void* code);
 
-void sse_awk_printrex (void* code);
+void ase_awk_printrex (void* code);
 
 #ifdef __cplusplus
 }
diff --git a/ase/awk/run.c b/ase/awk/run.c
index 638e8f75..0c315933 100644
--- a/ase/awk/run.c
+++ b/ase/awk/run.c
@@ -1,8 +1,8 @@
 /*
- * $Id: run.c,v 1.242 2006-10-22 14:17:40 bacon Exp $
+ * $Id: run.c,v 1.243 2006-10-24 04:10:12 bacon Exp $
  */
 
-#include <sse/awk/awk_i.h>
+#include <ase/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+(sse_size_t)STACK_NARGS(run)+1+(n))
+#define STACK_LOCAL(run,n) STACK_AT(run,3+(ase_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,251 +31,251 @@ enum
 };
 
 #define PANIC(run,code) \
-	do { (run)->errnum = (code); return SSE_NULL; } while (0)
+	do { (run)->errnum = (code); return ASE_NULL; } while (0)
 
 #define PANIC_I(run,code) \
 	do { (run)->errnum = (code); return -1; } while (0)
 
-#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")
+#define DEFAULT_CONVFMT ASE_T("%.6g")
+#define DEFAULT_OFMT ASE_T("%.6g")
+#define DEFAULT_OFS ASE_T(" ")
+#define DEFAULT_ORS ASE_T("\n")
+#define DEFAULT_SUBSEP ASE_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 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). */
+ * maximum value of ase_size_t as the reference is represented
+ * in a pointer variable of ase_awk_val_ref_t and sizeof(void*) is
+ * equal to sizeof(ase_size_t). */
 #define IS_VALID_POSIDX(idx) \
 	((idx) >= 0 && \
-	 (idx) < SSE_TYPE_MAX(sse_long_t) && \
-	 (idx) < SSE_TYPE_MAX(sse_size_t))
+	 (idx) < ASE_TYPE_MAX(ase_long_t) && \
+	 (idx) < ASE_TYPE_MAX(ase_size_t))
 
-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 void __add_run (ase_awk_t* awk, ase_awk_run_t* run);
+static void __del_run (ase_awk_t* awk, ase_awk_run_t* run);
 
 static int __init_run (
-	sse_awk_run_t* run, sse_awk_runios_t* runios, int* errnum);
-static void __deinit_run (sse_awk_run_t* run);
+	ase_awk_run_t* run, ase_awk_runios_t* runios, int* errnum);
+static void __deinit_run (ase_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 __build_runarg (ase_awk_run_t* run, ase_awk_runarg_t* runarg);
+static int __set_globals_to_default (ase_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_main (ase_awk_run_t* run, ase_awk_runarg_t* runarg);
+static int __run_pattern_blocks  (ase_awk_run_t* run);
 static int __run_pattern_block_chain (
-	sse_awk_run_t* run, sse_awk_chain_t* chain);
+	ase_awk_run_t* run, ase_awk_chain_t* chain);
 static int __run_pattern_block (
-	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);
+	ase_awk_run_t* run, ase_awk_chain_t* chain, ase_size_t block_no);
+static int __run_block (ase_awk_run_t* run, ase_awk_nde_blk_t* nde);
+static int __run_statement (ase_awk_run_t* run, ase_awk_nde_t* nde);
+static int __run_if (ase_awk_run_t* run, ase_awk_nde_if_t* nde);
+static int __run_while (ase_awk_run_t* run, ase_awk_nde_while_t* nde);
+static int __run_for (ase_awk_run_t* run, ase_awk_nde_for_t* nde);
+static int __run_foreach (ase_awk_run_t* run, ase_awk_nde_foreach_t* nde);
+static int __run_break (ase_awk_run_t* run, ase_awk_nde_break_t* nde);
+static int __run_continue (ase_awk_run_t* run, ase_awk_nde_continue_t* nde);
+static int __run_return (ase_awk_run_t* run, ase_awk_nde_return_t* nde);
+static int __run_exit (ase_awk_run_t* run, ase_awk_nde_exit_t* nde);
+static int __run_next (ase_awk_run_t* run, ase_awk_nde_next_t* nde);
+static int __run_nextfile (ase_awk_run_t* run, ase_awk_nde_nextfile_t* nde);
+static int __run_delete (ase_awk_run_t* run, ase_awk_nde_delete_t* nde);
+static int __run_print (ase_awk_run_t* run, ase_awk_nde_print_t* nde);
 
-static sse_awk_val_t* __eval_expression (sse_awk_run_t* run, sse_awk_nde_t* nde);
-static sse_awk_val_t* __eval_expression0 (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static ase_awk_val_t* __eval_expression (ase_awk_run_t* run, ase_awk_nde_t* nde);
+static ase_awk_val_t* __eval_expression0 (ase_awk_run_t* run, ase_awk_nde_t* nde);
 
-static sse_awk_val_t* __eval_group (sse_awk_run_t* run, sse_awk_nde_t* nde);
+static ase_awk_val_t* __eval_group (ase_awk_run_t* run, ase_awk_nde_t* nde);
 
-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 ase_awk_val_t* __eval_assignment (
+	ase_awk_run_t* run, ase_awk_nde_t* nde);
+static ase_awk_val_t* __do_assignment (
+	ase_awk_run_t* run, ase_awk_nde_t* var, ase_awk_val_t* val);
+static ase_awk_val_t* __do_assignment_scalar (
+	ase_awk_run_t* run, ase_awk_nde_var_t* var, ase_awk_val_t* val);
+static ase_awk_val_t* __do_assignment_map (
+	ase_awk_run_t* run, ase_awk_nde_var_t* var, ase_awk_val_t* val);
+static ase_awk_val_t* __do_assignment_pos (
+	ase_awk_run_t* run, ase_awk_nde_pos_t* pos, ase_awk_val_t* val);
 
-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_exp (
-	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 ase_awk_val_t* __eval_binary (
+	ase_awk_run_t* run, ase_awk_nde_t* nde);
+static ase_awk_val_t* __eval_binop_lor (
+	ase_awk_run_t* run, ase_awk_nde_t* left, ase_awk_nde_t* right);
+static ase_awk_val_t* __eval_binop_land (
+	ase_awk_run_t* run, ase_awk_nde_t* left, ase_awk_nde_t* right);
+static ase_awk_val_t* __eval_binop_in (
+	ase_awk_run_t* run, ase_awk_nde_t* left, ase_awk_nde_t* right);
+static ase_awk_val_t* __eval_binop_bor (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right);
+static ase_awk_val_t* __eval_binop_bxor (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right);
+static ase_awk_val_t* __eval_binop_band (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right);
+static ase_awk_val_t* __eval_binop_eq (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right);
+static ase_awk_val_t* __eval_binop_ne (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right);
+static ase_awk_val_t* __eval_binop_gt (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right);
+static ase_awk_val_t* __eval_binop_ge (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right);
+static ase_awk_val_t* __eval_binop_lt (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right);
+static ase_awk_val_t* __eval_binop_le (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right);
+static ase_awk_val_t* __eval_binop_lshift (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right);
+static ase_awk_val_t* __eval_binop_rshift (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right);
+static ase_awk_val_t* __eval_binop_plus (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right);
+static ase_awk_val_t* __eval_binop_minus (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right);
+static ase_awk_val_t* __eval_binop_mul (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right);
+static ase_awk_val_t* __eval_binop_div (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right);
+static ase_awk_val_t* __eval_binop_mod (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right);
+static ase_awk_val_t* __eval_binop_exp (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right);
+static ase_awk_val_t* __eval_binop_concat (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right);
+static ase_awk_val_t* __eval_binop_ma (
+	ase_awk_run_t* run, ase_awk_nde_t* left, ase_awk_nde_t* right);
+static ase_awk_val_t* __eval_binop_nm (
+	ase_awk_run_t* run, ase_awk_nde_t* left, ase_awk_nde_t* right);
+static ase_awk_val_t* __eval_binop_match0 (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right, int ret);
 
-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 ase_awk_val_t* __eval_unary (ase_awk_run_t* run, ase_awk_nde_t* nde);
+static ase_awk_val_t* __eval_incpre (ase_awk_run_t* run, ase_awk_nde_t* nde);
+static ase_awk_val_t* __eval_incpst (ase_awk_run_t* run, ase_awk_nde_t* nde);
+static ase_awk_val_t* __eval_cnd (ase_awk_run_t* run, ase_awk_nde_t* nde);
 
-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 ase_awk_val_t* __eval_bfn (ase_awk_run_t* run, ase_awk_nde_t* nde);
+static ase_awk_val_t* __eval_afn (ase_awk_run_t* run, ase_awk_nde_t* nde);
+static ase_awk_val_t* __eval_call (
+	ase_awk_run_t* run, ase_awk_nde_t* nde, 
+	const ase_char_t* bfn_arg_spec, ase_awk_afn_t* afn);
 
 static int __get_reference (
-	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);
+	ase_awk_run_t* run, ase_awk_nde_t* nde, ase_awk_val_t*** ref);
+static ase_awk_val_t** __get_reference_indexed (
+	ase_awk_run_t* run, ase_awk_nde_var_t* nde, ase_awk_val_t** val);
 
-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 ase_awk_val_t* __eval_int (ase_awk_run_t* run, ase_awk_nde_t* nde);
+static ase_awk_val_t* __eval_real (ase_awk_run_t* run, ase_awk_nde_t* nde);
+static ase_awk_val_t* __eval_str (ase_awk_run_t* run, ase_awk_nde_t* nde);
+static ase_awk_val_t* __eval_rex (ase_awk_run_t* run, ase_awk_nde_t* nde);
+static ase_awk_val_t* __eval_named (ase_awk_run_t* run, ase_awk_nde_t* nde);
+static ase_awk_val_t* __eval_global (ase_awk_run_t* run, ase_awk_nde_t* nde);
+static ase_awk_val_t* __eval_local (ase_awk_run_t* run, ase_awk_nde_t* nde);
+static ase_awk_val_t* __eval_arg (ase_awk_run_t* run, ase_awk_nde_t* nde);
+static ase_awk_val_t* __eval_namedidx (ase_awk_run_t* run, ase_awk_nde_t* nde);
+static ase_awk_val_t* __eval_globalidx (ase_awk_run_t* run, ase_awk_nde_t* nde);
+static ase_awk_val_t* __eval_localidx (ase_awk_run_t* run, ase_awk_nde_t* nde);
+static ase_awk_val_t* __eval_argidx (ase_awk_run_t* run, ase_awk_nde_t* nde);
+static ase_awk_val_t* __eval_pos (ase_awk_run_t* run, ase_awk_nde_t* nde);
+static ase_awk_val_t* __eval_getline (ase_awk_run_t* run, ase_awk_nde_t* nde);
 
-static int __raw_push (sse_awk_run_t* run, void* val);
+static int __raw_push (ase_awk_run_t* run, void* val);
 #define __raw_pop(run) \
 	do { \
-		sse_awk_assert (run->awk, (run)->stack_top > (run)->stack_base); \
+		ase_awk_assert (run->awk, (run)->stack_top > (run)->stack_base); \
 		(run)->stack_top--; \
 	} while (0)
-static void __raw_pop_times (sse_awk_run_t* run, sse_size_t times);
+static void __raw_pop_times (ase_awk_run_t* run, ase_size_t times);
 
-static int __read_record (sse_awk_run_t* run);
-static int __shorten_record (sse_awk_run_t* run, sse_size_t nflds);
+static int __read_record (ase_awk_run_t* run);
+static int __shorten_record (ase_awk_run_t* run, ase_size_t nflds);
 
-static sse_char_t* __idxnde_to_str (
-	sse_awk_run_t* run, sse_awk_nde_t* nde, sse_size_t* len);
+static ase_char_t* __idxnde_to_str (
+	ase_awk_run_t* run, ase_awk_nde_t* nde, ase_size_t* len);
 
-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_expr_t) (sse_awk_run_t* run, sse_awk_nde_t* nde);
+typedef ase_awk_val_t* (*binop_func_t) (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right);
+typedef ase_awk_val_t* (*eval_expr_t) (ase_awk_run_t* run, ase_awk_nde_t* nde);
 
 /* TODO: remove this function */
-static int __printval (sse_awk_pair_t* pair, void* arg)
+static int __printval (ase_awk_pair_t* pair, void* arg)
 {
-	xp_printf (SSE_T("%s = "), (const sse_char_t*)pair->key);
-	sse_awk_printval ((sse_awk_val_t*)pair->val);
-	xp_printf (SSE_T("\n"));
+	xp_printf (ASE_T("%s = "), (const ase_char_t*)pair->key);
+	ase_awk_printval ((ase_awk_val_t*)pair->val);
+	xp_printf (ASE_T("\n"));
 	return 0;
 }
 
-sse_size_t sse_awk_getnargs (sse_awk_run_t* run)
+ase_size_t ase_awk_getnargs (ase_awk_run_t* run)
 {
-	return (sse_size_t) STACK_NARGS (run);
+	return (ase_size_t) STACK_NARGS (run);
 }
 
-sse_awk_val_t* sse_awk_getarg (sse_awk_run_t* run, sse_size_t idx)
+ase_awk_val_t* ase_awk_getarg (ase_awk_run_t* run, ase_size_t idx)
 {
 	return STACK_ARG (run, idx);
 }
 
-sse_awk_val_t* sse_awk_getglobal (sse_awk_run_t* run, sse_size_t idx)
+ase_awk_val_t* ase_awk_getglobal (ase_awk_run_t* run, ase_size_t idx)
 {
 	return STACK_GLOBAL (run, idx);
 }
 
-int sse_awk_setglobal (sse_awk_run_t* run, sse_size_t idx, sse_awk_val_t* val)
+int ase_awk_setglobal (ase_awk_run_t* run, ase_size_t idx, ase_awk_val_t* val)
 {
-	sse_awk_val_t* old = STACK_GLOBAL (run, idx);
-	if (old->type == SSE_AWK_VAL_MAP)
+	ase_awk_val_t* old = STACK_GLOBAL (run, idx);
+	if (old->type == ASE_AWK_VAL_MAP)
 	{	
 		/* once a variable becomes an array,
 		 * it cannot be changed to a scalar variable */
-		PANIC_I (run, SSE_AWK_EMAPTOSCALAR);
+		PANIC_I (run, ASE_AWK_EMAPTOSCALAR);
 	}
 
 /* TODO: is this correct?? */
-	if (val->type == SSE_AWK_VAL_MAP &&
-	    (idx >= SSE_AWK_GLOBAL_ARGC && idx <= SSE_AWK_GLOBAL_SUBSEP) &&
-	    idx != SSE_AWK_GLOBAL_ARGV)
+	if (val->type == ASE_AWK_VAL_MAP &&
+	    (idx >= ASE_AWK_GLOBAL_ARGC && idx <= ASE_AWK_GLOBAL_SUBSEP) &&
+	    idx != ASE_AWK_GLOBAL_ARGV)
 	{
 		/* TODO: better error code */
-		PANIC_I (run, SSE_AWK_ESCALARTOMAP);
+		PANIC_I (run, ASE_AWK_ESCALARTOMAP);
 	}
 
-	if (idx == SSE_AWK_GLOBAL_CONVFMT)
+	if (idx == ASE_AWK_GLOBAL_CONVFMT)
 	{
-		sse_char_t* convfmt_ptr;
-		sse_size_t convfmt_len;
+		ase_char_t* convfmt_ptr;
+		ase_size_t convfmt_len;
 
-		convfmt_ptr = sse_awk_valtostr (
-			run, val, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &convfmt_len);
-		if (convfmt_ptr == SSE_NULL) return  -1;
+		convfmt_ptr = ase_awk_valtostr (
+			run, val, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &convfmt_len);
+		if (convfmt_ptr == ASE_NULL) return  -1;
 
-		if (run->global.convfmt.ptr != SSE_NULL)
-			SSE_AWK_FREE (run->awk, run->global.convfmt.ptr);
+		if (run->global.convfmt.ptr != ASE_NULL)
+			ASE_AWK_FREE (run->awk, run->global.convfmt.ptr);
 		run->global.convfmt.ptr = convfmt_ptr;
 		run->global.convfmt.len = convfmt_len;
 	}
-	else if (idx == SSE_AWK_GLOBAL_FS)
+	else if (idx == ASE_AWK_GLOBAL_FS)
 	{
-		sse_char_t* fs_ptr;
-		sse_size_t fs_len;
+		ase_char_t* fs_ptr;
+		ase_size_t fs_len;
 
-		if (val->type == SSE_AWK_VAL_STR)
+		if (val->type == ASE_AWK_VAL_STR)
 		{
-			fs_ptr = ((sse_awk_val_str_t*)val)->buf;
-			fs_len = ((sse_awk_val_str_t*)val)->len;
+			fs_ptr = ((ase_awk_val_str_t*)val)->buf;
+			fs_len = ((ase_awk_val_str_t*)val)->len;
 		}
 		else
 		{
 			/* due to the expression evaluation rule, the 
 			 * regular expression can not be an assigned value */
-			sse_awk_assert (run->awk, val->type != SSE_AWK_VAL_REX);
+			ase_awk_assert (run->awk, val->type != ASE_AWK_VAL_REX);
 
-			fs_ptr = sse_awk_valtostr (
-				run, val, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &fs_len);
-			if (fs_ptr == SSE_NULL) return -1;
+			fs_ptr = ase_awk_valtostr (
+				run, val, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &fs_len);
+			if (fs_ptr == ASE_NULL) return -1;
 		}
 
 		if (fs_len > 1)
@@ -284,32 +284,32 @@ int sse_awk_setglobal (sse_awk_run_t* run, sse_size_t idx, sse_awk_val_t* val)
 
 			/* compile the regular expression */
 			/* TODO: use safebuild */
-			rex = sse_awk_buildrex (
+			rex = ase_awk_buildrex (
 				run->awk, fs_ptr, fs_len, &run->errnum);
-			if (rex == SSE_NULL)
+			if (rex == ASE_NULL)
 			{
-				if (val->type != SSE_AWK_VAL_STR) 
-					SSE_AWK_FREE (run->awk, fs_ptr);
+				if (val->type != ASE_AWK_VAL_STR) 
+					ASE_AWK_FREE (run->awk, fs_ptr);
 				return -1;
 			}
 
-			if (run->global.fs != SSE_NULL) 
+			if (run->global.fs != ASE_NULL) 
 			{
-				sse_awk_freerex (run->awk, run->global.fs);
+				ase_awk_freerex (run->awk, run->global.fs);
 			}
 			run->global.fs = rex;
 		}
 
-		if (val->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, fs_ptr);
+		if (val->type != ASE_AWK_VAL_STR) ASE_AWK_FREE (run->awk, fs_ptr);
 	}
-	else if (idx == SSE_AWK_GLOBAL_IGNORECASE)
+	else if (idx == ASE_AWK_GLOBAL_IGNORECASE)
 	{
-		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))
+		if ((val->type == ASE_AWK_VAL_INT &&
+		     ((ase_awk_val_int_t*)val)->val == 0) ||
+		    (val->type == ASE_AWK_VAL_REAL &&
+		     ((ase_awk_val_real_t*)val)->val == 0.0) ||
+		    (val->type == ASE_AWK_VAL_STR &&
+		     ((ase_awk_val_str_t*)val)->len == 0))
 		{
 			run->global.ignorecase = 0;
 		}
@@ -318,82 +318,82 @@ int sse_awk_setglobal (sse_awk_run_t* run, sse_size_t idx, sse_awk_val_t* val)
 			run->global.ignorecase = 1;
 		}
 	}
-	else if (idx == SSE_AWK_GLOBAL_NF)
+	else if (idx == ASE_AWK_GLOBAL_NF)
 	{
 		int n;
-		sse_long_t lv;
-		sse_real_t rv;
+		ase_long_t lv;
+		ase_real_t rv;
 
-		n = sse_awk_valtonum (run, val, &lv, &rv);
+		n = ase_awk_valtonum (run, val, &lv, &rv);
 		if (n == -1) return -1;
-		if (n == 1) lv = (sse_long_t)rv;
+		if (n == 1) lv = (ase_long_t)rv;
 
 		if (lv < run->inrec.nflds)
 		{
-			if (__shorten_record (run, (sse_size_t)lv) == -1) return -1;
+			if (__shorten_record (run, (ase_size_t)lv) == -1) return -1;
 		}
 	}
-	else if (idx == SSE_AWK_GLOBAL_OFMT)
+	else if (idx == ASE_AWK_GLOBAL_OFMT)
 	{
-		sse_char_t* ofmt_ptr;
-		sse_size_t ofmt_len;
+		ase_char_t* ofmt_ptr;
+		ase_size_t ofmt_len;
 
-		ofmt_ptr = sse_awk_valtostr (
-			run, val, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &ofmt_len);
-		if (ofmt_ptr == SSE_NULL) return  -1;
+		ofmt_ptr = ase_awk_valtostr (
+			run, val, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &ofmt_len);
+		if (ofmt_ptr == ASE_NULL) return  -1;
 
-		if (run->global.ofmt.ptr != SSE_NULL)
-			SSE_AWK_FREE (run->awk, run->global.ofmt.ptr);
+		if (run->global.ofmt.ptr != ASE_NULL)
+			ASE_AWK_FREE (run->awk, run->global.ofmt.ptr);
 		run->global.ofmt.ptr = ofmt_ptr;
 		run->global.ofmt.len = ofmt_len;
 	}
-	else if (idx == SSE_AWK_GLOBAL_OFS)
+	else if (idx == ASE_AWK_GLOBAL_OFS)
 	{	
-		sse_char_t* ofs_ptr;
-		sse_size_t ofs_len;
+		ase_char_t* ofs_ptr;
+		ase_size_t ofs_len;
 
-		ofs_ptr = sse_awk_valtostr (
-			run, val, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &ofs_len);
-		if (ofs_ptr == SSE_NULL) return  -1;
+		ofs_ptr = ase_awk_valtostr (
+			run, val, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &ofs_len);
+		if (ofs_ptr == ASE_NULL) return  -1;
 
-		if (run->global.ofs.ptr != SSE_NULL)
-			SSE_AWK_FREE (run->awk, run->global.ofs.ptr);
+		if (run->global.ofs.ptr != ASE_NULL)
+			ASE_AWK_FREE (run->awk, run->global.ofs.ptr);
 		run->global.ofs.ptr = ofs_ptr;
 		run->global.ofs.len = ofs_len;
 	}
-	else if (idx == SSE_AWK_GLOBAL_ORS)
+	else if (idx == ASE_AWK_GLOBAL_ORS)
 	{	
-		sse_char_t* ors_ptr;
-		sse_size_t ors_len;
+		ase_char_t* ors_ptr;
+		ase_size_t ors_len;
 
-		ors_ptr = sse_awk_valtostr (
-			run, val, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &ors_len);
-		if (ors_ptr == SSE_NULL) return  -1;
+		ors_ptr = ase_awk_valtostr (
+			run, val, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &ors_len);
+		if (ors_ptr == ASE_NULL) return  -1;
 
-		if (run->global.ors.ptr != SSE_NULL)
-			SSE_AWK_FREE (run->awk, run->global.ors.ptr);
+		if (run->global.ors.ptr != ASE_NULL)
+			ASE_AWK_FREE (run->awk, run->global.ors.ptr);
 		run->global.ors.ptr = ors_ptr;
 		run->global.ors.len = ors_len;
 	}
-	else if (idx == SSE_AWK_GLOBAL_RS)
+	else if (idx == ASE_AWK_GLOBAL_RS)
 	{
-		sse_char_t* rs_ptr;
-		sse_size_t rs_len;
+		ase_char_t* rs_ptr;
+		ase_size_t rs_len;
 
-		if (val->type == SSE_AWK_VAL_STR)
+		if (val->type == ASE_AWK_VAL_STR)
 		{
-			rs_ptr = ((sse_awk_val_str_t*)val)->buf;
-			rs_len = ((sse_awk_val_str_t*)val)->len;
+			rs_ptr = ((ase_awk_val_str_t*)val)->buf;
+			rs_len = ((ase_awk_val_str_t*)val)->len;
 		}
 		else
 		{
 			/* due to the expression evaluation rule, the 
 			 * regular expression can not be an assigned value */
-			sse_awk_assert (run->awk, val->type != SSE_AWK_VAL_REX);
+			ase_awk_assert (run->awk, val->type != ASE_AWK_VAL_REX);
 
-			rs_ptr = sse_awk_valtostr (
-				run, val, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &rs_len);
-			if (rs_ptr == SSE_NULL) return -1;
+			rs_ptr = ase_awk_valtostr (
+				run, val, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &rs_len);
+			if (rs_ptr == ASE_NULL) return -1;
 		}
 
 		if (rs_len > 1)
@@ -402,106 +402,106 @@ int sse_awk_setglobal (sse_awk_run_t* run, sse_size_t idx, sse_awk_val_t* val)
 
 			/* compile the regular expression */
 			/* TODO: use safebuild */
-			rex = sse_awk_buildrex (
+			rex = ase_awk_buildrex (
 				run->awk, rs_ptr, rs_len, &run->errnum);
-			if (rex == SSE_NULL)
+			if (rex == ASE_NULL)
 			{
-				if (val->type != SSE_AWK_VAL_STR) 
-					SSE_AWK_FREE (run->awk, rs_ptr);
+				if (val->type != ASE_AWK_VAL_STR) 
+					ASE_AWK_FREE (run->awk, rs_ptr);
 				return -1;
 			}
 
-			if (run->global.rs != SSE_NULL) 
+			if (run->global.rs != ASE_NULL) 
 			{
-				sse_awk_freerex (run->awk, run->global.rs);
+				ase_awk_freerex (run->awk, run->global.rs);
 			}
 			run->global.rs = rex;
 		}
 
-		if (val->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, rs_ptr);
+		if (val->type != ASE_AWK_VAL_STR) ASE_AWK_FREE (run->awk, rs_ptr);
 	}
-	else if (idx == SSE_AWK_GLOBAL_SUBSEP)
+	else if (idx == ASE_AWK_GLOBAL_SUBSEP)
 	{
-		sse_char_t* subsep_ptr;
-		sse_size_t subsep_len;
+		ase_char_t* subsep_ptr;
+		ase_size_t subsep_len;
 
-		subsep_ptr = sse_awk_valtostr (
-			run, val, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &subsep_len);
-		if (subsep_ptr == SSE_NULL) return  -1;
+		subsep_ptr = ase_awk_valtostr (
+			run, val, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &subsep_len);
+		if (subsep_ptr == ASE_NULL) return  -1;
 
-		if (run->global.subsep.ptr != SSE_NULL)
-			SSE_AWK_FREE (run->awk, run->global.subsep.ptr);
+		if (run->global.subsep.ptr != ASE_NULL)
+			ASE_AWK_FREE (run->awk, run->global.subsep.ptr);
 		run->global.subsep.ptr = subsep_ptr;
 		run->global.subsep.len = subsep_len;
 	}
 
-	sse_awk_refdownval (run, old);
+	ase_awk_refdownval (run, old);
 	STACK_GLOBAL(run,idx) = val;
-	sse_awk_refupval (val);
+	ase_awk_refupval (val);
 
 	return 0;
 }
 
-void sse_awk_setretval (sse_awk_run_t* run, sse_awk_val_t* val)
+void ase_awk_setretval (ase_awk_run_t* run, ase_awk_val_t* val)
 {
-	sse_awk_refdownval (run, STACK_RETVAL(run));
+	ase_awk_refdownval (run, STACK_RETVAL(run));
 	STACK_RETVAL(run) = val;
 	/* should use the same trick as __run_return_statement */
-	sse_awk_refupval (val); 
+	ase_awk_refupval (val); 
 }
 
-int sse_awk_setconsolename (
-	sse_awk_run_t* run, const sse_char_t* name, sse_size_t len)
+int ase_awk_setconsolename (
+	ase_awk_run_t* run, const ase_char_t* name, ase_size_t len)
 {
-	sse_awk_val_t* tmp;
+	ase_awk_val_t* tmp;
 	int n;
 
-	if (len == 0) tmp = sse_awk_val_zls;
+	if (len == 0) tmp = ase_awk_val_zls;
 	else
 	{
-		tmp = sse_awk_makestrval (run, name, len);
-		if (tmp == SSE_NULL)
+		tmp = ase_awk_makestrval (run, name, len);
+		if (tmp == ASE_NULL)
 		{
-			run->errnum = SSE_AWK_ENOMEM;
+			run->errnum = ASE_AWK_ENOMEM;
 			return -1;
 		}
 	}
 
-	sse_awk_refupval (tmp);
-	n = sse_awk_setglobal (run, SSE_AWK_GLOBAL_FILENAME, tmp);
-	sse_awk_refdownval (run, tmp);
+	ase_awk_refupval (tmp);
+	n = ase_awk_setglobal (run, ASE_AWK_GLOBAL_FILENAME, tmp);
+	ase_awk_refdownval (run, tmp);
 
 	return n;
 }
 
-int sse_awk_getrunerrnum (sse_awk_run_t* run)
+int ase_awk_getrunerrnum (ase_awk_run_t* run)
 {
 	return run->errnum;
 }
 
-void sse_awk_setrunerrnum (sse_awk_run_t* run, int errnum)
+void ase_awk_setrunerrnum (ase_awk_run_t* run, int errnum)
 {
 	run->errnum = errnum;
 }
 
-int sse_awk_run (sse_awk_t* awk, 
-	sse_awk_runios_t* runios, 
-	sse_awk_runcbs_t* runcbs, 
-	sse_awk_runarg_t* runarg)
+int ase_awk_run (ase_awk_t* awk, 
+	ase_awk_runios_t* runios, 
+	ase_awk_runcbs_t* runcbs, 
+	ase_awk_runarg_t* runarg)
 {
-	sse_awk_run_t* run;
+	ase_awk_run_t* run;
 	int n, errnum;
 
-	awk->errnum = SSE_AWK_ENOERR;
+	awk->errnum = ASE_AWK_ENOERR;
 
-	run = (sse_awk_run_t*) SSE_AWK_MALLOC (awk, sse_sizeof(sse_awk_run_t));
-	if (run == SSE_NULL)
+	run = (ase_awk_run_t*) ASE_AWK_MALLOC (awk, ase_sizeof(ase_awk_run_t));
+	if (run == ASE_NULL)
 	{
-		awk->errnum = SSE_AWK_ENOMEM;
+		awk->errnum = ASE_AWK_ENOMEM;
 		return -1;
 	}
 
-	SSE_AWK_MEMSET (awk, run, 0, sse_sizeof(sse_awk_run_t));
+	ASE_AWK_MEMSET (awk, run, 0, ase_sizeof(ase_awk_run_t));
 
 	__add_run (awk, run);
 
@@ -509,11 +509,11 @@ int sse_awk_run (sse_awk_t* awk,
 	{
 		awk->errnum = errnum;
 		__del_run (awk, run);
-		SSE_AWK_FREE (awk, run);
+		ASE_AWK_FREE (awk, run);
 		return -1;
 	}
 
-	if (runcbs != SSE_NULL && runcbs->on_start != SSE_NULL) 
+	if (runcbs != ASE_NULL && runcbs->on_start != ASE_NULL) 
 	{
 		runcbs->on_start (awk, run, runcbs->custom_data);
 	}
@@ -523,13 +523,13 @@ int sse_awk_run (sse_awk_t* awk,
 	{
 		/* if no callback is specified, awk's error number 
 		 * is updated with the run's error number */
-		awk->errnum = (runcbs == SSE_NULL)? run->errnum: SSE_AWK_ERUNTIME;
+		awk->errnum = (runcbs == ASE_NULL)? run->errnum: ASE_AWK_ERUNTIME;
 	}
 
-	if (runcbs != SSE_NULL && runcbs->on_end != SSE_NULL) 
+	if (runcbs != ASE_NULL && runcbs->on_end != ASE_NULL) 
 	{
 		runcbs->on_end (awk, run, 
-			((n == -1)? run->errnum: SSE_AWK_ENOERR), 
+			((n == -1)? run->errnum: ASE_AWK_ENOERR), 
 			runcbs->custom_data);
 
 		/* when using callbacks, the function always returns 0 after
@@ -539,100 +539,100 @@ int sse_awk_run (sse_awk_t* awk,
 
 	__deinit_run (run);
 	__del_run (awk, run);
-	SSE_AWK_FREE (awk, run);
+	ASE_AWK_FREE (awk, run);
 	return n;
 }
 
-int sse_awk_stop (sse_awk_t* awk, sse_awk_run_t* run)
+int ase_awk_stop (ase_awk_t* awk, ase_awk_run_t* run)
 {
-	sse_awk_run_t* r;
+	ase_awk_run_t* r;
 	int n = 0;
 
-	SSE_AWK_LOCK (awk);
+	ASE_AWK_LOCK (awk);
 
 	/* check if the run handle given is valid */
-	for (r = awk->run.ptr; r != SSE_NULL; r = r->next)
+	for (r = awk->run.ptr; r != ASE_NULL; r = r->next)
 	{
 		if (r == run)
 		{
-			sse_awk_assert (run->awk, r->awk == awk);
+			ase_awk_assert (run->awk, r->awk == awk);
 			r->exit_level = EXIT_ABORT;
 			break;
 		}
 	}
 
-	if (r == SSE_NULL)
+	if (r == ASE_NULL)
 	{
 		/* if it is not found in the awk's run list, 
 		 * it is not a valid handle */
-		awk->errnum = SSE_AWK_EINVAL;
+		awk->errnum = ASE_AWK_EINVAL;
 		n = -1;
 	}
 
-	SSE_AWK_UNLOCK (awk);
+	ASE_AWK_UNLOCK (awk);
 
 	return n;
 }
 
-void sse_awk_stopall (sse_awk_t* awk)
+void ase_awk_stopall (ase_awk_t* awk)
 {
-	sse_awk_run_t* r;
+	ase_awk_run_t* r;
 
-	SSE_AWK_LOCK (awk);
+	ASE_AWK_LOCK (awk);
 
-	for (r = awk->run.ptr; r != SSE_NULL; r = r->next)
+	for (r = awk->run.ptr; r != ASE_NULL; r = r->next)
 	{
 		r->exit_level = EXIT_ABORT;
 	}
 
-	SSE_AWK_UNLOCK (awk);
+	ASE_AWK_UNLOCK (awk);
 }
 
 static void __free_namedval (void* run, void* val)
 {
-	sse_awk_refdownval ((sse_awk_run_t*)run, val);
+	ase_awk_refdownval ((ase_awk_run_t*)run, val);
 }
 
-static void __add_run (sse_awk_t* awk, sse_awk_run_t* run)
+static void __add_run (ase_awk_t* awk, ase_awk_run_t* run)
 {
-	SSE_AWK_LOCK (awk);
+	ASE_AWK_LOCK (awk);
 
 	run->awk = awk;
-	run->prev = SSE_NULL;
+	run->prev = ASE_NULL;
 	run->next = awk->run.ptr;
-	if (run->next != SSE_NULL) run->next->prev = run;
+	if (run->next != ASE_NULL) run->next->prev = run;
 	awk->run.ptr = run;
 	awk->run.count++;
 
-	SSE_AWK_UNLOCK (awk);
+	ASE_AWK_UNLOCK (awk);
 }
 
-static void __del_run (sse_awk_t* awk, sse_awk_run_t* run)
+static void __del_run (ase_awk_t* awk, ase_awk_run_t* run)
 {
-	SSE_AWK_LOCK (awk);
+	ASE_AWK_LOCK (awk);
 
-	sse_awk_assert (run->awk, awk->run.ptr != SSE_NULL);
+	ase_awk_assert (run->awk, awk->run.ptr != ASE_NULL);
 
-	if (run->prev == SSE_NULL)
+	if (run->prev == ASE_NULL)
 	{
 		awk->run.ptr = run->next;
-		if (run->next != SSE_NULL) run->next->prev = SSE_NULL;
+		if (run->next != ASE_NULL) run->next->prev = ASE_NULL;
 	}
 	else
 	{
 		run->prev->next = run->next;
-		if (run->next != SSE_NULL) run->next->prev = run->prev;
+		if (run->next != ASE_NULL) run->next->prev = run->prev;
 	}
 
-	run->awk = SSE_NULL;
+	run->awk = ASE_NULL;
 	awk->run.count--;
 
-	SSE_AWK_UNLOCK (awk);
+	ASE_AWK_UNLOCK (awk);
 }
 
-static int __init_run (sse_awk_run_t* run, sse_awk_runios_t* runios, int* errnum)
+static int __init_run (ase_awk_run_t* run, ase_awk_runios_t* runios, int* errnum)
 {
-	run->stack = SSE_NULL;
+	run->stack = ASE_NULL;
 	run->stack_top = 0;
 	run->stack_base = 0;
 	run->stack_limit = 0;
@@ -643,241 +643,241 @@ static int __init_run (sse_awk_run_t* run, sse_awk_runios_t* runios, int* errnum
 	run->rcache_count = 0;
 	run->fcache_count = 0;
 
-	run->errnum = SSE_AWK_ENOERR;
+	run->errnum = ASE_AWK_ENOERR;
 
 	run->inrec.buf_pos = 0;
 	run->inrec.buf_len = 0;
-	run->inrec.flds = SSE_NULL;
+	run->inrec.flds = ASE_NULL;
 	run->inrec.nflds = 0;
 	run->inrec.maxflds = 0;
-	run->inrec.d0 = sse_awk_val_nil;
-	if (sse_awk_str_open (
-		&run->inrec.line, DEF_BUF_CAPA, run->awk) == SSE_NULL)
+	run->inrec.d0 = ase_awk_val_nil;
+	if (ase_awk_str_open (
+		&run->inrec.line, DEF_BUF_CAPA, run->awk) == ASE_NULL)
 	{
-		*errnum = SSE_AWK_ENOMEM; 
+		*errnum = ASE_AWK_ENOMEM; 
 		return -1;
 	}
 
-	if (sse_awk_map_open (&run->named, 
-		run, DEF_BUF_CAPA, __free_namedval, run->awk) == SSE_NULL) 
+	if (ase_awk_map_open (&run->named, 
+		run, DEF_BUF_CAPA, __free_namedval, run->awk) == ASE_NULL) 
 	{
-		sse_awk_str_close (&run->inrec.line);
-		*errnum = SSE_AWK_ENOMEM; 
+		ase_awk_str_close (&run->inrec.line);
+		*errnum = ASE_AWK_ENOMEM; 
 		return -1;
 	}
 
-	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)
+	run->pattern_range_state = (ase_byte_t*) ASE_AWK_MALLOC (
+		run->awk, run->awk->tree.chain_size * ase_sizeof(ase_byte_t));
+	if (run->pattern_range_state == ASE_NULL)
 	{
-		sse_awk_map_close (&run->named);
-		sse_awk_str_close (&run->inrec.line);
-		*errnum = SSE_AWK_ENOMEM; 
+		ase_awk_map_close (&run->named);
+		ase_awk_str_close (&run->inrec.line);
+		*errnum = ASE_AWK_ENOMEM; 
 		return -1;
 	}
 
-	SSE_AWK_MEMSET (run->awk, run->pattern_range_state, 0, 
-		run->awk->tree.chain_size * sse_sizeof(sse_byte_t));
+	ASE_AWK_MEMSET (run->awk, run->pattern_range_state, 0, 
+		run->awk->tree.chain_size * ase_sizeof(ase_byte_t));
 
-	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.handler[ASE_AWK_EXTIO_PIPE] = runios->pipe;
+	run->extio.handler[ASE_AWK_EXTIO_COPROC] = runios->coproc;
+	run->extio.handler[ASE_AWK_EXTIO_FILE] = runios->file;
+	run->extio.handler[ASE_AWK_EXTIO_CONSOLE] = runios->console;
 	run->extio.custom_data = runios->custom_data;
-	run->extio.chain = SSE_NULL;
+	run->extio.chain = ASE_NULL;
 
-	run->global.rs = SSE_NULL;
-	run->global.fs = SSE_NULL;
+	run->global.rs = ASE_NULL;
+	run->global.fs = ASE_NULL;
 	run->global.ignorecase = 0;
 
 	return 0;
 }
 
-static void __deinit_run (sse_awk_run_t* run)
+static void __deinit_run (ase_awk_run_t* run)
 {
-	SSE_AWK_FREE (run->awk, run->pattern_range_state);
+	ASE_AWK_FREE (run->awk, run->pattern_range_state);
 
 	/* close all pending eio's */
 	/* TODO: what if this operation fails? */
-	sse_awk_clearextio (run);
-	sse_awk_assert (run->awk, run->extio.chain == SSE_NULL);
+	ase_awk_clearextio (run);
+	ase_awk_assert (run->awk, run->extio.chain == ASE_NULL);
 
-	if (run->global.rs != SSE_NULL) 
+	if (run->global.rs != ASE_NULL) 
 	{
-		SSE_AWK_FREE (run->awk, run->global.rs);
-		run->global.rs = SSE_NULL;
+		ASE_AWK_FREE (run->awk, run->global.rs);
+		run->global.rs = ASE_NULL;
 	}
-	if (run->global.fs != SSE_NULL)
+	if (run->global.fs != ASE_NULL)
 	{
-		SSE_AWK_FREE (run->awk, run->global.fs);
-		run->global.fs = SSE_NULL;
+		ASE_AWK_FREE (run->awk, run->global.fs);
+		run->global.fs = ASE_NULL;
 	}
 
-	if (run->global.convfmt.ptr != SSE_NULL &&
+	if (run->global.convfmt.ptr != ASE_NULL &&
 	    run->global.convfmt.ptr != DEFAULT_CONVFMT)
 	{
-		SSE_AWK_FREE (run->awk, run->global.convfmt.ptr);
-		run->global.convfmt.ptr = SSE_NULL;
+		ASE_AWK_FREE (run->awk, run->global.convfmt.ptr);
+		run->global.convfmt.ptr = ASE_NULL;
 		run->global.convfmt.len = 0;
 	}
 
-	if (run->global.ofmt.ptr != SSE_NULL && 
+	if (run->global.ofmt.ptr != ASE_NULL && 
 	    run->global.ofmt.ptr != DEFAULT_OFMT)
 	{
-		SSE_AWK_FREE (run->awk, run->global.ofmt.ptr);
-		run->global.ofmt.ptr = SSE_NULL;
+		ASE_AWK_FREE (run->awk, run->global.ofmt.ptr);
+		run->global.ofmt.ptr = ASE_NULL;
 		run->global.ofmt.len = 0;
 	}
 
-	if (run->global.ofs.ptr != SSE_NULL && 
+	if (run->global.ofs.ptr != ASE_NULL && 
 	    run->global.ofs.ptr != DEFAULT_OFS)
 	{
-		SSE_AWK_FREE (run->awk, run->global.ofs.ptr);
-		run->global.ofs.ptr = SSE_NULL;
+		ASE_AWK_FREE (run->awk, run->global.ofs.ptr);
+		run->global.ofs.ptr = ASE_NULL;
 		run->global.ofs.len = 0;
 	}
 
-	if (run->global.ors.ptr != SSE_NULL && 
+	if (run->global.ors.ptr != ASE_NULL && 
 	    run->global.ors.ptr != DEFAULT_ORS)
 	{
-		SSE_AWK_FREE (run->awk, run->global.ors.ptr);
-		run->global.ors.ptr = SSE_NULL;
+		ASE_AWK_FREE (run->awk, run->global.ors.ptr);
+		run->global.ors.ptr = ASE_NULL;
 		run->global.ors.len = 0;
 	}
 
-	if (run->global.subsep.ptr != SSE_NULL && 
+	if (run->global.subsep.ptr != ASE_NULL && 
 	    run->global.subsep.ptr != DEFAULT_SUBSEP)
 	{
-		SSE_AWK_FREE (run->awk, run->global.subsep.ptr);
-		run->global.subsep.ptr = SSE_NULL;
+		ASE_AWK_FREE (run->awk, run->global.subsep.ptr);
+		run->global.subsep.ptr = ASE_NULL;
 		run->global.subsep.len = 0;
 	}
 
-	/* destroy input record. sse_awk_clrrec should be called
+	/* destroy input record. ase_awk_clrrec should be called
 	 * before the run stack has been destroyed because it may try
-	 * to change the value to SSE_AWK_GLOBAL_NF. */
-	sse_awk_clrrec (run, sse_false);  
-	if (run->inrec.flds != SSE_NULL) 
+	 * to change the value to ASE_AWK_GLOBAL_NF. */
+	ase_awk_clrrec (run, ase_false);  
+	if (run->inrec.flds != ASE_NULL) 
 	{
-		SSE_AWK_FREE (run->awk, run->inrec.flds);
-		run->inrec.flds = SSE_NULL;
+		ASE_AWK_FREE (run->awk, run->inrec.flds);
+		run->inrec.flds = ASE_NULL;
 		run->inrec.maxflds = 0;
 	}
-	sse_awk_str_close (&run->inrec.line);
+	ase_awk_str_close (&run->inrec.line);
 
 	/* destroy run stack */
-	if (run->stack != SSE_NULL)
+	if (run->stack != ASE_NULL)
 	{
-		sse_awk_assert (run->awk, run->stack_top == 0);
+		ase_awk_assert (run->awk, run->stack_top == 0);
 
-		SSE_AWK_FREE (run->awk, run->stack);
-		run->stack = SSE_NULL;
+		ASE_AWK_FREE (run->awk, run->stack);
+		run->stack = ASE_NULL;
 		run->stack_top = 0;
 		run->stack_base = 0;
 		run->stack_limit = 0;
 	}
 
 	/* destroy named variables */
-	sse_awk_map_close (&run->named);
+	ase_awk_map_close (&run->named);
 
 	/* destroy values in free list */
 	while (run->icache_count > 0)
 	{
-		sse_awk_val_int_t* tmp = run->icache[--run->icache_count];
-		sse_awk_freeval (run, (sse_awk_val_t*)tmp, sse_false);
+		ase_awk_val_int_t* tmp = run->icache[--run->icache_count];
+		ase_awk_freeval (run, (ase_awk_val_t*)tmp, ase_false);
 	}
 
 	while (run->rcache_count > 0)
 	{
-		sse_awk_val_real_t* tmp = run->rcache[--run->rcache_count];
-		sse_awk_freeval (run, (sse_awk_val_t*)tmp, sse_false);
+		ase_awk_val_real_t* tmp = run->rcache[--run->rcache_count];
+		ase_awk_freeval (run, (ase_awk_val_t*)tmp, ase_false);
 	}
 
 	while (run->fcache_count > 0)
 	{
-		sse_awk_val_ref_t* tmp = run->fcache[--run->fcache_count];
-		sse_awk_freeval (run, (sse_awk_val_t*)tmp, sse_false);
+		ase_awk_val_ref_t* tmp = run->fcache[--run->fcache_count];
+		ase_awk_freeval (run, (ase_awk_val_t*)tmp, ase_false);
 	}
 }
 
-static int __build_runarg (sse_awk_run_t* run, sse_awk_runarg_t* runarg)
+static int __build_runarg (ase_awk_run_t* run, ase_awk_runarg_t* runarg)
 {
-	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;
+	ase_awk_runarg_t* p = runarg;
+	ase_size_t argc;
+	ase_awk_val_t* v_argc;
+	ase_awk_val_t* v_argv;
+	ase_awk_val_t* v_tmp;
+	ase_char_t key[ase_sizeof(ase_long_t)*8+2];
+	ase_size_t key_len;
 
-	v_argv = sse_awk_makemapval (run);
-	if (v_argv == SSE_NULL)
+	v_argv = ase_awk_makemapval (run);
+	if (v_argv == ASE_NULL)
 	{
-		run->errnum = SSE_AWK_ENOMEM;
+		run->errnum = ASE_AWK_ENOMEM;
 		return -1;
 	}
-	sse_awk_refupval (v_argv);
+	ase_awk_refupval (v_argv);
 
-	if (runarg == SSE_NULL) argc = 0;
+	if (runarg == ASE_NULL) argc = 0;
 	else
 	{
-		for (argc = 0, p = runarg; p->ptr != SSE_NULL; argc++, p++)
+		for (argc = 0, p = runarg; p->ptr != ASE_NULL; argc++, p++)
 		{
-			v_tmp = sse_awk_makestrval (run, p->ptr, p->len);
-			if (v_tmp == SSE_NULL)
+			v_tmp = ase_awk_makestrval (run, p->ptr, p->len);
+			if (v_tmp == ASE_NULL)
 			{
-				sse_awk_refdownval (run, v_argv);
-				run->errnum = SSE_AWK_ENOMEM;
+				ase_awk_refdownval (run, v_argv);
+				run->errnum = ASE_AWK_ENOMEM;
 				return -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);
+			key_len = ase_awk_longtostr (
+				argc, 10, ASE_NULL, key, ase_countof(key));
+			ase_awk_assert (run->awk, key_len != (ase_size_t)-1);
 
 			/* increment reference count of v_tmp in advance as if 
 			 * it has successfully been assigned into ARGV. */
-			sse_awk_refupval (v_tmp);
+			ase_awk_refupval (v_tmp);
 
-			if (sse_awk_map_putx (
-				((sse_awk_val_map_t*)v_argv)->map,
-				key, key_len, v_tmp, SSE_NULL) == -1)
+			if (ase_awk_map_putx (
+				((ase_awk_val_map_t*)v_argv)->map,
+				key, key_len, v_tmp, ASE_NULL) == -1)
 			{
 				/* if the assignment operation fails, decrements
 				 * the reference of v_tmp to free it */
-				sse_awk_refdownval (run, v_tmp);
+				ase_awk_refdownval (run, v_tmp);
 
 				/* the values previously assigned into the
 				 * map will be freeed when v_argv is freed */
-				sse_awk_refdownval (run, v_argv);
+				ase_awk_refdownval (run, v_argv);
 
-				run->errnum = SSE_AWK_ENOMEM;
+				run->errnum = ASE_AWK_ENOMEM;
 				return -1;
 			}
 		}
 	}
 
-	v_argc = sse_awk_makeintval (run, (sse_long_t)argc);
-	if (v_argc == SSE_NULL)
+	v_argc = ase_awk_makeintval (run, (ase_long_t)argc);
+	if (v_argc == ASE_NULL)
 	{
-		sse_awk_refdownval (run, v_argv);
-		run->errnum = SSE_AWK_ENOMEM;
+		ase_awk_refdownval (run, v_argv);
+		run->errnum = ASE_AWK_ENOMEM;
 		return -1;
 	}
 
-	sse_awk_refupval (v_argc);
+	ase_awk_refupval (v_argc);
 
-	sse_awk_assert (run->awk, 
-		STACK_GLOBAL(run,SSE_AWK_GLOBAL_ARGC) == sse_awk_val_nil);
+	ase_awk_assert (run->awk, 
+		STACK_GLOBAL(run,ASE_AWK_GLOBAL_ARGC) == ase_awk_val_nil);
 
-	if (sse_awk_setglobal (run, SSE_AWK_GLOBAL_ARGC, v_argc) == -1) 
+	if (ase_awk_setglobal (run, ASE_AWK_GLOBAL_ARGC, v_argc) == -1) 
 	{
-		sse_awk_refdownval (run, v_argc);
-		sse_awk_refdownval (run, v_argv);
+		ase_awk_refdownval (run, v_argc);
+		ase_awk_refdownval (run, v_argv);
 		return -1;
 	}
 
-	if (sse_awk_setglobal (run, SSE_AWK_GLOBAL_ARGV, v_argv) == -1)
+	if (ase_awk_setglobal (run, ASE_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 (sse_awk_run_t* run, sse_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. */
-		sse_awk_setglobal (run, SSE_AWK_GLOBAL_ARGC, sse_awk_val_nil);
-		sse_awk_refdownval (run, v_argc);
-		sse_awk_refdownval (run, v_argv);
+		ase_awk_setglobal (run, ASE_AWK_GLOBAL_ARGC, ase_awk_val_nil);
+		ase_awk_refdownval (run, v_argc);
+		ase_awk_refdownval (run, v_argv);
 		return -1;
 	}
 
-	sse_awk_refdownval (run, v_argc);
-	sse_awk_refdownval (run, v_argv);
+	ase_awk_refdownval (run, v_argc);
+	ase_awk_refdownval (run, v_argv);
 	return 0;
 }
 
-static int __update_fnr (sse_awk_run_t* run, sse_size_t fnr)
+static int __update_fnr (ase_awk_run_t* run, ase_size_t fnr)
 {
-	sse_awk_val_t* tmp;
+	ase_awk_val_t* tmp;
 
-	tmp = sse_awk_makeintval (run, fnr);
-	if (tmp == SSE_NULL)
+	tmp = ase_awk_makeintval (run, fnr);
+	if (tmp == ASE_NULL)
 	{
-		run->errnum = SSE_AWK_ENOMEM;
+		run->errnum = ASE_AWK_ENOMEM;
 		return -1;
 	}
 
-	sse_awk_refupval (tmp);
-	if (sse_awk_setglobal (run, SSE_AWK_GLOBAL_FNR, tmp) == -1)
+	ase_awk_refupval (tmp);
+	if (ase_awk_setglobal (run, ASE_AWK_GLOBAL_FNR, tmp) == -1)
 	{
-		sse_awk_refdownval (run, tmp);
+		ase_awk_refdownval (run, tmp);
 		return -1;
 	}
 
-	sse_awk_refdownval (run, tmp);
+	ase_awk_refdownval (run, tmp);
 	run->global.fnr = fnr;
 	return 0;
 }
 
-static int __set_globals_to_default (sse_awk_run_t* run)
+static int __set_globals_to_default (ase_awk_run_t* run)
 {
 	struct __gtab_t
 	{
 		int idx;
-		const sse_char_t* str;
+		const ase_char_t* str;
 	};
        
 	static struct __gtab_t gtab[] =
 	{
-		{ 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 },
+		{ ASE_AWK_GLOBAL_CONVFMT,  DEFAULT_CONVFMT },
+		{ ASE_AWK_GLOBAL_FILENAME, ASE_NULL },
+		{ ASE_AWK_GLOBAL_OFMT,     DEFAULT_OFMT },
+		{ ASE_AWK_GLOBAL_OFS,      DEFAULT_OFS },
+		{ ASE_AWK_GLOBAL_ORS,      DEFAULT_ORS },
+		{ ASE_AWK_GLOBAL_SUBSEP,   DEFAULT_SUBSEP },
 	};
 
-	sse_awk_val_t* tmp;
-	sse_size_t i, j;
+	ase_awk_val_t* tmp;
+	ase_size_t i, j;
 
-	for (i = 0; i < sse_countof(gtab); i++)
+	for (i = 0; i < ase_countof(gtab); i++)
 	{
-		if (gtab[i].str == SSE_NULL || gtab[i].str[0] == SSE_T('\0'))
+		if (gtab[i].str == ASE_NULL || gtab[i].str[0] == ASE_T('\0'))
 		{
-			tmp = sse_awk_val_zls;
+			tmp = ase_awk_val_zls;
 		}
 		else 
 		{
-			tmp = sse_awk_makestrval0 (run, gtab[i].str);
-			if (tmp == SSE_NULL)
+			tmp = ase_awk_makestrval0 (run, gtab[i].str);
+			if (tmp == ASE_NULL)
 			{
-				run->errnum = SSE_AWK_ENOMEM;
+				run->errnum = ASE_AWK_ENOMEM;
 				return -1;
 			}
 		}
 		
-		sse_awk_refupval (tmp);
+		ase_awk_refupval (tmp);
 
-		sse_awk_assert (run->awk, 
-			STACK_GLOBAL(run,gtab[i].idx) == sse_awk_val_nil);
+		ase_awk_assert (run->awk, 
+			STACK_GLOBAL(run,gtab[i].idx) == ase_awk_val_nil);
 
-		if (sse_awk_setglobal (run, gtab[i].idx, tmp) == -1)
+		if (ase_awk_setglobal (run, gtab[i].idx, tmp) == -1)
 		{
 			for (j = 0; j < i; j++)
 			{
-				sse_awk_setglobal (
-					run, gtab[i].idx, sse_awk_val_nil);
+				ase_awk_setglobal (
+					run, gtab[i].idx, ase_awk_val_nil);
 			}
 
-			sse_awk_refdownval (run, tmp);
+			ase_awk_refdownval (run, tmp);
 			return -1;
 		}
 
-		sse_awk_refdownval (run, tmp);
+		ase_awk_refdownval (run, tmp);
 	}
 
 	return 0;
 }
 
-static int __run_main (sse_awk_run_t* run, sse_awk_runarg_t* runarg)
+static int __run_main (ase_awk_run_t* run, ase_awk_runarg_t* runarg)
 {
-	sse_size_t nglobals, nargs, i;
-	sse_size_t saved_stack_top;
-	sse_awk_val_t* v;
+	ase_size_t nglobals, nargs, i;
+	ase_size_t saved_stack_top;
+	ase_awk_val_t* v;
 	int n;
 
-	sse_awk_assert (run->awk, run->stack_base == 0 && run->stack_top == 0);
+	ase_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 (sse_awk_run_t* run, sse_awk_runarg_t* runarg)
 	while (nglobals > 0)
 	{
 		--nglobals;
-		if (__raw_push(run,sse_awk_val_nil) == -1)
+		if (__raw_push(run,ase_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 sse_awk_val_nil */
+			 * the values pushed so far are all ase_awk_val_nil */
 			run->stack_top = saved_stack_top;
-			PANIC_I (run, SSE_AWK_ENOMEM);
+			PANIC_I (run, ASE_AWK_ENOMEM);
 		}
 	}	
 
-	if (sse_awk_setglobal (run, SSE_AWK_GLOBAL_NR, sse_awk_val_zero) == -1)
+	if (ase_awk_setglobal (run, ASE_AWK_GLOBAL_NR, ase_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 sse_awk_val_nils */
+		 * all ase_awk_val_nils */
 		run->stack_top = saved_stack_top;
 		return -1;
 	}
 
-	if (sse_awk_setglobal (run, SSE_AWK_GLOBAL_NF, sse_awk_val_zero) == -1)
+	if (ase_awk_setglobal (run, ASE_AWK_GLOBAL_NF, ase_awk_val_zero) == -1)
 	{
 		/* it can simply restore the top of the stack this way
 		 * because the values pused onto the stack so far are
-		 * all sse_awk_val_nils  and sse_awk_val_zeros */
+		 * all ase_awk_val_nils  and ase_awk_val_zeros */
 		run->stack_top = saved_stack_top;
 		return -1;
 	}
 	
-	if (runarg != SSE_NULL && __build_runarg (run, runarg) == -1)
+	if (runarg != ASE_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 sse_awk_val_nils and sse_awk_val_zeros and 
+		 * all ase_awk_val_nils and ase_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 (sse_awk_run_t* run, sse_awk_runarg_t* runarg)
 
 	n = __update_fnr (run, 0);
 	if (n == 0) n = __set_globals_to_default (run);
-	if (n == 0 && (run->awk->option & SSE_AWK_RUNMAIN))
+	if (n == 0 && (run->awk->option & ASE_AWK_RUNMAIN))
 	{
 /* TODO: should the main function be user-specifiable? */
-		sse_awk_nde_call_t nde;
+		ase_awk_nde_call_t nde;
 
-		nde.type = SSE_AWK_NDE_AFN;
-		nde.next = SSE_NULL;
-		nde.what.afn.name = SSE_T("main");
+		nde.type = ASE_AWK_NDE_AFN;
+		nde.next = ASE_NULL;
+		nde.what.afn.name = ASE_T("main");
 		nde.what.afn.name_len = 4;
-		nde.args = SSE_NULL;
+		nde.args = ASE_NULL;
 		nde.nargs = 0;
 
-		v = __eval_afn (run, (sse_awk_nde_t*)&nde);
-		if (v == SSE_NULL) n = -1;
+		v = __eval_afn (run, (ase_awk_nde_t*)&nde);
+		if (v == ASE_NULL) n = -1;
 		else
 		{
 			/* destroy the return value if necessary */
-			sse_awk_refupval (v);
-			sse_awk_refdownval (run, v);
+			ase_awk_refupval (v);
+			ase_awk_refdownval (run, v);
 		}
 	}
 	else if (n == 0)
@@ -1070,30 +1070,30 @@ static int __run_main (sse_awk_run_t* run, sse_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, SSE_AWK_ENOMEM);
+			PANIC_I (run, ASE_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, SSE_AWK_ENOMEM);
+			PANIC_I (run, ASE_AWK_ENOMEM);
 		}
 	
 		/* secure space for a return value */
-		if (__raw_push(run,sse_awk_val_nil) == -1)
+		if (__raw_push(run,ase_awk_val_nil) == -1)
 		{
 			run->stack_top = saved_stack_top;
 			__raw_pop_times (run, run->awk->tree.nglobals);
-			PANIC_I (run, SSE_AWK_ENOMEM);
+			PANIC_I (run, ASE_AWK_ENOMEM);
 		}
 	
 		/* secure space for nargs */
-		if (__raw_push(run,sse_awk_val_nil) == -1)
+		if (__raw_push(run,ase_awk_val_nil) == -1)
 		{
 			run->stack_top = saved_stack_top;
 			__raw_pop_times (run, run->awk->tree.nglobals);
-			PANIC_I (run, SSE_AWK_ENOMEM);
+			PANIC_I (run, ASE_AWK_ENOMEM);
 		}
 	
 		run->stack_base = saved_stack_top;
@@ -1104,13 +1104,13 @@ static int __run_main (sse_awk_run_t* run, sse_awk_runarg_t* runarg)
 	
 		/* stack set up properly. ready to exeucte statement blocks */
 		if (n == 0 && 
-		    run->awk->tree.begin != SSE_NULL && 
+		    run->awk->tree.begin != ASE_NULL && 
 		    run->exit_level != EXIT_ABORT)
 		{
-			sse_awk_nde_blk_t* blk;
+			ase_awk_nde_blk_t* blk;
 
-			blk = (sse_awk_nde_blk_t*)run->awk->tree.begin;
-			sse_awk_assert (run->awk, blk->type == SSE_AWK_NDE_BLK);
+			blk = (ase_awk_nde_blk_t*)run->awk->tree.begin;
+			ase_awk_assert (run->awk, blk->type == ASE_AWK_NDE_BLK);
 
 			run->active_block = blk;
 			run->exit_level = EXIT_NONE;
@@ -1118,20 +1118,20 @@ static int __run_main (sse_awk_run_t* run, sse_awk_runarg_t* runarg)
 		}
 
 		if (n == 0 && 
-		    run->awk->tree.chain != SSE_NULL && 
+		    run->awk->tree.chain != ASE_NULL && 
 		    run->exit_level != EXIT_ABORT)
 		{
 			if (__run_pattern_blocks (run) == -1) n = -1;
 		}
 
 		if (n == 0 && 
-		    run->awk->tree.end != SSE_NULL && 
+		    run->awk->tree.end != ASE_NULL && 
 		    run->exit_level != EXIT_ABORT) 
 		{
-			sse_awk_nde_blk_t* blk;
+			ase_awk_nde_blk_t* blk;
 
-			blk = (sse_awk_nde_blk_t*)run->awk->tree.end;
-			sse_awk_assert (run->awk, blk->type == SSE_AWK_NDE_BLK);
+			blk = (ase_awk_nde_blk_t*)run->awk->tree.end;
+			ase_awk_assert (run->awk, blk->type == ASE_AWK_NDE_BLK);
 
 			run->active_block = blk;
 			run->exit_level = EXIT_NONE;
@@ -1139,26 +1139,26 @@ static int __run_main (sse_awk_run_t* run, sse_awk_runarg_t* runarg)
 		}
 
 		/* restore stack */
-		nargs = (sse_size_t)STACK_NARGS(run);
-		sse_awk_assert (run->awk, nargs == 0);
+		nargs = (ase_size_t)STACK_NARGS(run);
+		ase_awk_assert (run->awk, nargs == 0);
 		for (i = 0; i < nargs; i++)
 		{
-			sse_awk_refdownval (run, STACK_ARG(run,i));
+			ase_awk_refdownval (run, STACK_ARG(run,i));
 		}
 
 		v = STACK_RETVAL(run);
-xp_printf (SSE_T("Return Value - "));
-sse_awk_printval (v);
-xp_printf (SSE_T("\n"));
+xp_printf (ASE_T("Return Value - "));
+ase_awk_printval (v);
+xp_printf (ASE_T("\n"));
 		/* the life of the global return value is over here
 		 * unlike the return value of each function */
-		/*sse_awk_refdownval_nofree (awk, v);*/
-		sse_awk_refdownval (run, v);
+		/*ase_awk_refdownval_nofree (awk, v);*/
+		ase_awk_refdownval (run, v);
 
 		run->stack_top = 
-			(sse_size_t)run->stack[run->stack_base+1];
+			(ase_size_t)run->stack[run->stack_base+1];
 		run->stack_base = 
-			(sse_size_t)run->stack[run->stack_base+0];
+			(ase_size_t)run->stack[run->stack_base+0];
 	}
 
 	/* pops off the global variables */
@@ -1166,28 +1166,28 @@ xp_printf (SSE_T("\n"));
 	while (nglobals > 0)
 	{
 		--nglobals;
-		sse_awk_refdownval (run, STACK_GLOBAL(run,nglobals));
+		ase_awk_refdownval (run, STACK_GLOBAL(run,nglobals));
 		__raw_pop (run);
 	}
 
 	/* just reset the exit level */
 	run->exit_level = EXIT_NONE;
 
-xp_printf (SSE_T("-[VARIABLES]------------------------\n"));
-sse_awk_map_walk (&run->named, __printval, SSE_NULL);
-xp_printf (SSE_T("-[END VARIABLES]--------------------------\n"));
+xp_printf (ASE_T("-[VARIABLES]------------------------\n"));
+ase_awk_map_walk (&run->named, __printval, ASE_NULL);
+xp_printf (ASE_T("-[END VARIABLES]--------------------------\n"));
 
 	return n;
 }
 
-static int __run_pattern_blocks (sse_awk_run_t* run)
+static int __run_pattern_blocks (ase_awk_run_t* run)
 {
-	sse_ssize_t n;
-	sse_bool_t need_to_close = sse_false;
+	ase_ssize_t n;
+	ase_bool_t need_to_close = ase_false;
 
 	run->inrec.buf_pos = 0;
 	run->inrec.buf_len = 0;
-	run->inrec.eof = sse_false;
+	run->inrec.eof = ase_false;
 
 	/* run each pattern block */
 	while (run->exit_level != EXIT_GLOBAL &&
@@ -1203,14 +1203,14 @@ static int __run_pattern_blocks (sse_awk_run_t* run)
 			int saved = run->errnum;
 
 			/* don't care about the result of input close */
-			sse_awk_closeextio_read (
-				run, SSE_AWK_IN_CONSOLE, SSE_T(""));
+			ase_awk_closeextio_read (
+				run, ASE_AWK_IN_CONSOLE, ASE_T(""));
 
 			run->errnum = saved;
 			return -1;
 		}
 
-		need_to_close = sse_true;
+		need_to_close = ase_true;
 		if (x == 0) break; /* end of input */
 
 		__update_fnr (run, run->global.fnr + 1);
@@ -1219,8 +1219,8 @@ static int __run_pattern_blocks (sse_awk_run_t* run)
 		{
 			int saved = run->errnum;
 
-			sse_awk_closeextio_read (
-				run, SSE_AWK_IN_CONSOLE, SSE_T(""));
+			ase_awk_closeextio_read (
+				run, ASE_AWK_IN_CONSOLE, ASE_T(""));
 
 			run->errnum = saved;
 			return -1;
@@ -1230,18 +1230,18 @@ static int __run_pattern_blocks (sse_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 
-	 * SSE_AWK_EIOHANDLER. But this part of the code ends the input for 
+	 * ASE_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 = sse_awk_closeextio_read (
-			run, SSE_AWK_IN_CONSOLE, SSE_T(""));
+		n = ase_awk_closeextio_read (
+			run, ASE_AWK_IN_CONSOLE, ASE_T(""));
 		if (n == -1) 
 		{
-			if (run->errnum == SSE_AWK_EIOHANDLER)
-				PANIC_I (run, SSE_AWK_ECONINCLOSE);
+			if (run->errnum == ASE_AWK_EIOHANDLER)
+				PANIC_I (run, ASE_AWK_ECONINCLOSE);
 			else return -1;
 		}
 	}
@@ -1249,12 +1249,12 @@ static int __run_pattern_blocks (sse_awk_run_t* run)
 	return 0;
 }
 
-static int __run_pattern_block_chain (sse_awk_run_t* run, sse_awk_chain_t* chain)
+static int __run_pattern_block_chain (ase_awk_run_t* run, ase_awk_chain_t* chain)
 {
-	sse_size_t block_no = 0;
+	ase_size_t block_no = 0;
 
 	while (run->exit_level != EXIT_GLOBAL &&
-	       run->exit_level != EXIT_ABORT && chain != SSE_NULL)
+	       run->exit_level != EXIT_ABORT && chain != ASE_NULL)
 	{
 		if (run->exit_level == EXIT_NEXT)
 		{
@@ -1272,15 +1272,15 @@ static int __run_pattern_block_chain (sse_awk_run_t* run, sse_awk_chain_t* chain
 }
 
 static int __run_pattern_block (
-	sse_awk_run_t* run, sse_awk_chain_t* chain, sse_size_t block_no)
+	ase_awk_run_t* run, ase_awk_chain_t* chain, ase_size_t block_no)
 {
-	sse_awk_nde_t* ptn;
-	sse_awk_nde_blk_t* blk;
+	ase_awk_nde_t* ptn;
+	ase_awk_nde_blk_t* blk;
 
 	ptn = chain->pattern;
-	blk = (sse_awk_nde_blk_t*)chain->action;
+	blk = (ase_awk_nde_blk_t*)chain->action;
 
-	if (ptn == SSE_NULL)
+	if (ptn == ASE_NULL)
 	{
 		/* just execute the block */
 		run->active_block = blk;
@@ -1288,74 +1288,74 @@ static int __run_pattern_block (
 	}
 	else
 	{
-		if (ptn->next == SSE_NULL)
+		if (ptn->next == ASE_NULL)
 		{
 			/* pattern { ... } */
-			sse_awk_val_t* v1;
+			ase_awk_val_t* v1;
 
 			v1 = __eval_expression (run, ptn);
-			if (v1 == SSE_NULL) return -1;
+			if (v1 == ASE_NULL) return -1;
 
-			sse_awk_refupval (v1);
+			ase_awk_refupval (v1);
 
-			if (sse_awk_valtobool (run, v1))
+			if (ase_awk_valtobool (run, v1))
 			{
 				run->active_block = blk;
 				if (__run_block (run, blk) == -1) 
 				{
-					sse_awk_refdownval (run, v1);
+					ase_awk_refdownval (run, v1);
 					return -1;
 				}
 			}
 
-			sse_awk_refdownval (run, v1);
+			ase_awk_refdownval (run, v1);
 		}
 		else
 		{
 			/* pattern, pattern { ... } */
-			sse_awk_assert (run->awk, ptn->next->next == SSE_NULL);
+			ase_awk_assert (run->awk, ptn->next->next == ASE_NULL);
 
 			if (run->pattern_range_state[block_no] == 0)
 			{
-				sse_awk_val_t* v1;
+				ase_awk_val_t* v1;
 
 				v1 = __eval_expression (run, ptn);
-				if (v1 == SSE_NULL) return -1;
-				sse_awk_refupval (v1);
+				if (v1 == ASE_NULL) return -1;
+				ase_awk_refupval (v1);
 
-				if (sse_awk_valtobool (run, v1))
+				if (ase_awk_valtobool (run, v1))
 				{
 					run->active_block = blk;
 					if (__run_block (run, blk) == -1) 
 					{
-						sse_awk_refdownval (run, v1);
+						ase_awk_refdownval (run, v1);
 						return -1;
 					}
 
 					run->pattern_range_state[block_no] = 1;
 				}
 
-				sse_awk_refdownval (run, v1);
+				ase_awk_refdownval (run, v1);
 			}
 			else if (run->pattern_range_state[block_no] == 1)
 			{
-				sse_awk_val_t* v2;
+				ase_awk_val_t* v2;
 
 				v2 = __eval_expression (run, ptn->next);
-				if (v2 == SSE_NULL) return -1;
-				sse_awk_refupval (v2);
+				if (v2 == ASE_NULL) return -1;
+				ase_awk_refupval (v2);
 
 				run->active_block = blk;
 				if (__run_block (run, blk) == -1) 
 				{
-					sse_awk_refdownval (run, v2);
+					ase_awk_refdownval (run, v2);
 					return -1;
 				}
 
-				if (sse_awk_valtobool (run, v2)) 
+				if (ase_awk_valtobool (run, v2)) 
 					run->pattern_range_state[block_no] = 0;
 
-				sse_awk_refdownval (run, v2);
+				ase_awk_refdownval (run, v2);
 			}
 		}
 	}
@@ -1363,63 +1363,63 @@ static int __run_pattern_block (
 	return 0;
 }
 
-static int __run_block (sse_awk_run_t* run, sse_awk_nde_blk_t* nde)
+static int __run_block (ase_awk_run_t* run, ase_awk_nde_blk_t* nde)
 {
-	sse_awk_nde_t* p;
-	sse_size_t nlocals;
-	sse_size_t saved_stack_top;
+	ase_awk_nde_t* p;
+	ase_size_t nlocals;
+	ase_size_t saved_stack_top;
 	int n = 0;
 
-	if (nde == SSE_NULL)
+	if (nde == ASE_NULL)
 	{
 		/* blockless pattern - execute print $0*/
-		sse_awk_refupval (run->inrec.d0);
+		ase_awk_refupval (run->inrec.d0);
 
-		/*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));
+		/*n = ase_awk_writeextio_val (run, 
+			ASE_AWK_OUT_CONSOLE, ASE_T(""), run->inrec.d0);*/
+		n = ase_awk_writeextio_str (run, 
+			ASE_AWK_OUT_CONSOLE, ASE_T(""),
+			ASE_AWK_STR_BUF(&run->inrec.line),
+			ASE_AWK_STR_LEN(&run->inrec.line));
 		if (n == -1)
 		{
-			sse_awk_refdownval (run, run->inrec.d0);
+			ase_awk_refdownval (run, run->inrec.d0);
 
-			if (run->errnum == SSE_AWK_EIOHANDLER)
-				PANIC_I (run, SSE_AWK_ECONOUTDATA);
+			if (run->errnum == ASE_AWK_EIOHANDLER)
+				PANIC_I (run, ASE_AWK_ECONOUTDATA);
 			else return -1;
 		}
 
-		sse_awk_refdownval (run, run->inrec.d0);
+		ase_awk_refdownval (run, run->inrec.d0);
 		return 0;
 	}
 
-	sse_awk_assert (run->awk, nde->type == SSE_AWK_NDE_BLK);
+	ase_awk_assert (run->awk, nde->type == ASE_AWK_NDE_BLK);
 
 	p = nde->body;
 	nlocals = nde->nlocals;
 
-/*xp_printf (SSE_T("securing space for local variables nlocals = %d\n"), (int)nlocals);*/
+/*xp_printf (ASE_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,sse_awk_val_nil) == -1)
+		if (__raw_push(run,ase_awk_val_nil) == -1)
 		{
 			/* restore stack top */
 			run->stack_top = saved_stack_top;
 			return -1;
 		}
 
-		/* refupval is not required for sse_awk_val_nil */
+		/* refupval is not required for ase_awk_val_nil */
 	}
 
-/*xp_printf (SSE_T("executing block statements\n"));*/
-	while (p != SSE_NULL && run->exit_level == EXIT_NONE) 
+/*xp_printf (ASE_T("executing block statements\n"));*/
+	while (p != ASE_NULL && run->exit_level == EXIT_NONE) 
 	{
-/*xp_printf (SSE_T("running a statement\n"));*/
+/*xp_printf (ASE_T("running a statement\n"));*/
 		if (__run_statement(run,p) == -1) 
 		{
 			n = -1;
@@ -1428,129 +1428,129 @@ static int __run_block (sse_awk_run_t* run, sse_awk_nde_blk_t* nde)
 		p = p->next;
 	}
 
-/*xp_printf (SSE_T("popping off local variables\n"));*/
+/*xp_printf (ASE_T("popping off local variables\n"));*/
 	/* pop off local variables */
 	nlocals = nde->nlocals;
 	while (nlocals > 0)
 	{
 		--nlocals;
-		sse_awk_refdownval (run, STACK_LOCAL(run,nlocals));
+		ase_awk_refdownval (run, STACK_LOCAL(run,nlocals));
 		__raw_pop (run);
 	}
 
 	return n;
 }
 
-static int __run_statement (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static int __run_statement (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
 	switch (nde->type) 
 	{
-		case SSE_AWK_NDE_NULL:
+		case ASE_AWK_NDE_NULL:
 		{
 			/* do nothing */
 			break;
 		}
 
-		case SSE_AWK_NDE_BLK:
+		case ASE_AWK_NDE_BLK:
 		{
 			if (__run_block (run, 
-				(sse_awk_nde_blk_t*)nde) == -1) return -1;
+				(ase_awk_nde_blk_t*)nde) == -1) return -1;
 			break;
 		}
 
-		case SSE_AWK_NDE_IF:
+		case ASE_AWK_NDE_IF:
 		{
 			if (__run_if (run, 
-				(sse_awk_nde_if_t*)nde) == -1) return -1;	
+				(ase_awk_nde_if_t*)nde) == -1) return -1;	
 			break;
 		}
 
-		case SSE_AWK_NDE_WHILE:
-		case SSE_AWK_NDE_DOWHILE:
+		case ASE_AWK_NDE_WHILE:
+		case ASE_AWK_NDE_DOWHILE:
 		{
 			if (__run_while (run, 
-				(sse_awk_nde_while_t*)nde) == -1) return -1;
+				(ase_awk_nde_while_t*)nde) == -1) return -1;
 			break;
 		}
 
-		case SSE_AWK_NDE_FOR:
+		case ASE_AWK_NDE_FOR:
 		{
 			if (__run_for (run, 
-				(sse_awk_nde_for_t*)nde) == -1) return -1;
+				(ase_awk_nde_for_t*)nde) == -1) return -1;
 			break;
 		}
 
-		case SSE_AWK_NDE_FOREACH:
+		case ASE_AWK_NDE_FOREACH:
 		{
 			if (__run_foreach (run, 
-				(sse_awk_nde_foreach_t*)nde) == -1) return -1;
+				(ase_awk_nde_foreach_t*)nde) == -1) return -1;
 			break;
 		}
 
-		case SSE_AWK_NDE_BREAK:
+		case ASE_AWK_NDE_BREAK:
 		{
 			if (__run_break (run, 
-				(sse_awk_nde_break_t*)nde) == -1) return -1;
+				(ase_awk_nde_break_t*)nde) == -1) return -1;
 			break;
 		}
 
-		case SSE_AWK_NDE_CONTINUE:
+		case ASE_AWK_NDE_CONTINUE:
 		{
 			if (__run_continue (run, 
-				(sse_awk_nde_continue_t*)nde) == -1) return -1;
+				(ase_awk_nde_continue_t*)nde) == -1) return -1;
 			break;
 		}
 
-		case SSE_AWK_NDE_RETURN:
+		case ASE_AWK_NDE_RETURN:
 		{
 			if (__run_return (run, 
-				(sse_awk_nde_return_t*)nde) == -1) return -1;
+				(ase_awk_nde_return_t*)nde) == -1) return -1;
 			break;
 		}
 
-		case SSE_AWK_NDE_EXIT:
+		case ASE_AWK_NDE_EXIT:
 		{
 			if (__run_exit (run, 
-				(sse_awk_nde_exit_t*)nde) == -1) return -1;
+				(ase_awk_nde_exit_t*)nde) == -1) return -1;
 			break;
 		}
 
-		case SSE_AWK_NDE_NEXT:
+		case ASE_AWK_NDE_NEXT:
 		{
 			if (__run_next (run, 
-				(sse_awk_nde_next_t*)nde) == -1) return -1;
+				(ase_awk_nde_next_t*)nde) == -1) return -1;
 			break;
 		}
 
-		case SSE_AWK_NDE_NEXTFILE:
+		case ASE_AWK_NDE_NEXTFILE:
 		{
 			if (__run_nextfile (run, 
-				(sse_awk_nde_nextfile_t*)nde) == -1) return -1;
+				(ase_awk_nde_nextfile_t*)nde) == -1) return -1;
 			break;
 		}
 
-		case SSE_AWK_NDE_DELETE:
+		case ASE_AWK_NDE_DELETE:
 		{
 			if (__run_delete (run, 
-				(sse_awk_nde_delete_t*)nde) == -1) return -1;
+				(ase_awk_nde_delete_t*)nde) == -1) return -1;
 			break;
 		}
 
-		case SSE_AWK_NDE_PRINT:
+		case ASE_AWK_NDE_PRINT:
 		{
 			if (__run_print (run, 
-				(sse_awk_nde_print_t*)nde) == -1) return -1;
+				(ase_awk_nde_print_t*)nde) == -1) return -1;
 			break;
 		}
 
 		default:
 		{
-			sse_awk_val_t* v;
+			ase_awk_val_t* v;
 			v = __eval_expression(run,nde);
-			if (v == SSE_NULL) return -1;
+			if (v == ASE_NULL) return -1;
 
-			sse_awk_refupval (v);
-			sse_awk_refdownval (run, v);
+			ase_awk_refupval (v);
+			ase_awk_refdownval (run, v);
 
 			break;
 		}
@@ -1559,66 +1559,66 @@ static int __run_statement (sse_awk_run_t* run, sse_awk_nde_t* nde)
 	return 0;
 }
 
-static int __run_if (sse_awk_run_t* run, sse_awk_nde_if_t* nde)
+static int __run_if (ase_awk_run_t* run, ase_awk_nde_if_t* nde)
 {
-	sse_awk_val_t* test;
+	ase_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
 	 * parser first of all */
-	sse_awk_assert (run->awk, nde->test->next == SSE_NULL);
+	ase_awk_assert (run->awk, nde->test->next == ASE_NULL);
 
 	test = __eval_expression (run, nde->test);
-	if (test == SSE_NULL) return -1;
+	if (test == ASE_NULL) return -1;
 
-	sse_awk_refupval (test);
-	if (sse_awk_valtobool (run, test))
+	ase_awk_refupval (test);
+	if (ase_awk_valtobool (run, test))
 	{
 		n = __run_statement (run, nde->then_part);
 	}
-	else if (nde->else_part != SSE_NULL)
+	else if (nde->else_part != ASE_NULL)
 	{
 		n = __run_statement (run, nde->else_part);
 	}
 
-	sse_awk_refdownval (run, test); /* TODO: is this correct?*/
+	ase_awk_refdownval (run, test); /* TODO: is this correct?*/
 	return n;
 }
 
-static int __run_while (sse_awk_run_t* run, sse_awk_nde_while_t* nde)
+static int __run_while (ase_awk_run_t* run, ase_awk_nde_while_t* nde)
 {
-	sse_awk_val_t* test;
+	ase_awk_val_t* test;
 
-	if (nde->type == SSE_AWK_NDE_WHILE)
+	if (nde->type == ASE_AWK_NDE_WHILE)
 	{
 		/* no chained expressions are allowed for the test 
 		 * expression of the while statement */
-		sse_awk_assert (run->awk, nde->test->next == SSE_NULL);
+		ase_awk_assert (run->awk, nde->test->next == ASE_NULL);
 
 		/* TODO: handle run-time abortion... */
 		while (1)
 		{
 			test = __eval_expression (run, nde->test);
-			if (test == SSE_NULL) return -1;
+			if (test == ASE_NULL) return -1;
 
-			sse_awk_refupval (test);
+			ase_awk_refupval (test);
 
-			if (sse_awk_valtobool (run, test))
+			if (ase_awk_valtobool (run, test))
 			{
 				if (__run_statement(run,nde->body) == -1)
 				{
-					sse_awk_refdownval (run, test);
+					ase_awk_refdownval (run, test);
 					return -1;
 				}
 			}
 			else
 			{
-				sse_awk_refdownval (run, test);
+				ase_awk_refdownval (run, test);
 				break;
 			}
 
-			sse_awk_refdownval (run, test);
+			ase_awk_refdownval (run, test);
 
 			if (run->exit_level == EXIT_BREAK)
 			{	
@@ -1632,11 +1632,11 @@ static int __run_while (sse_awk_run_t* run, sse_awk_nde_while_t* nde)
 			else if (run->exit_level != EXIT_NONE) break;
 		}
 	}
-	else if (nde->type == SSE_AWK_NDE_DOWHILE)
+	else if (nde->type == ASE_AWK_NDE_DOWHILE)
 	{
 		/* no chained expressions are allowed for the test 
 		 * expression of the while statement */
-		sse_awk_assert (run->awk, nde->test->next == SSE_NULL);
+		ase_awk_assert (run->awk, nde->test->next == ASE_NULL);
 
 		/* TODO: handle run-time abortion... */
 		do
@@ -1655,17 +1655,17 @@ static int __run_while (sse_awk_run_t* run, sse_awk_nde_while_t* nde)
 			else if (run->exit_level != EXIT_NONE) break;
 
 			test = __eval_expression (run, nde->test);
-			if (test == SSE_NULL) return -1;
+			if (test == ASE_NULL) return -1;
 
-			sse_awk_refupval (test);
+			ase_awk_refupval (test);
 
-			if (!sse_awk_valtobool (run, test))
+			if (!ase_awk_valtobool (run, test))
 			{
-				sse_awk_refdownval (run, test);
+				ase_awk_refdownval (run, test);
 				break;
 			}
 
-			sse_awk_refdownval (run, test);
+			ase_awk_refdownval (run, test);
 		}
 		while (1);
 	}
@@ -1673,49 +1673,49 @@ static int __run_while (sse_awk_run_t* run, sse_awk_nde_while_t* nde)
 	return 0;
 }
 
-static int __run_for (sse_awk_run_t* run, sse_awk_nde_for_t* nde)
+static int __run_for (ase_awk_run_t* run, ase_awk_nde_for_t* nde)
 {
-	sse_awk_val_t* val;
+	ase_awk_val_t* val;
 
-	if (nde->init != SSE_NULL)
+	if (nde->init != ASE_NULL)
 	{
-		sse_awk_assert (run->awk, nde->init->next == SSE_NULL);
+		ase_awk_assert (run->awk, nde->init->next == ASE_NULL);
 		val = __eval_expression(run,nde->init);
-		if (val == SSE_NULL) return -1;
+		if (val == ASE_NULL) return -1;
 
-		sse_awk_refupval (val);
-		sse_awk_refdownval (run, val);
+		ase_awk_refupval (val);
+		ase_awk_refdownval (run, val);
 	}
 
 	while (1)
 	{
-		if (nde->test != SSE_NULL)
+		if (nde->test != ASE_NULL)
 		{
-			sse_awk_val_t* test;
+			ase_awk_val_t* test;
 
 			/* no chained expressions for the test expression of
 			 * the for statement are allowed */
-			sse_awk_assert (run->awk, nde->test->next == SSE_NULL);
+			ase_awk_assert (run->awk, nde->test->next == ASE_NULL);
 
 			test = __eval_expression (run, nde->test);
-			if (test == SSE_NULL) return -1;
+			if (test == ASE_NULL) return -1;
 
-			sse_awk_refupval (test);
-			if (sse_awk_valtobool (run, test))
+			ase_awk_refupval (test);
+			if (ase_awk_valtobool (run, test))
 			{
 				if (__run_statement(run,nde->body) == -1)
 				{
-					sse_awk_refdownval (run, test);
+					ase_awk_refdownval (run, test);
 					return -1;
 				}
 			}
 			else
 			{
-				sse_awk_refdownval (run, test);
+				ase_awk_refdownval (run, test);
 				break;
 			}
 
-			sse_awk_refdownval (run, test);
+			ase_awk_refdownval (run, test);
 		}	
 		else
 		{
@@ -1736,14 +1736,14 @@ static int __run_for (sse_awk_run_t* run, sse_awk_nde_for_t* nde)
 		}
 		else if (run->exit_level != EXIT_NONE) break;
 
-		if (nde->incr != SSE_NULL)
+		if (nde->incr != ASE_NULL)
 		{
-			sse_awk_assert (run->awk, nde->incr->next == SSE_NULL);
+			ase_awk_assert (run->awk, nde->incr->next == ASE_NULL);
 			val = __eval_expression(run,nde->incr);
-			if (val == SSE_NULL) return -1;
+			if (val == ASE_NULL) return -1;
 
-			sse_awk_refupval (val);
-			sse_awk_refdownval (run, val);
+			ase_awk_refupval (val);
+			ase_awk_refdownval (run, val);
 		}
 	}
 
@@ -1752,167 +1752,167 @@ static int __run_for (sse_awk_run_t* run, sse_awk_nde_for_t* nde)
 
 struct __foreach_walker_t
 {
-	sse_awk_run_t* run;
-	sse_awk_nde_t* var;
-	sse_awk_nde_t* body;
+	ase_awk_run_t* run;
+	ase_awk_nde_t* var;
+	ase_awk_nde_t* body;
 };
 
-static int __walk_foreach (sse_awk_pair_t* pair, void* arg)
+static int __walk_foreach (ase_awk_pair_t* pair, void* arg)
 {
 	struct __foreach_walker_t* w = (struct __foreach_walker_t*)arg;
-	sse_awk_val_t* str;
+	ase_awk_val_t* str;
 
-	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);
+	str = (ase_awk_val_t*) ase_awk_makestrval (
+		w->run, pair->key, ase_awk_strlen(pair->key));
+	if (str == ASE_NULL) PANIC_I (w->run, ASE_AWK_ENOMEM);
 
-	sse_awk_refupval (str);
-	if (__do_assignment (w->run, w->var, str) == SSE_NULL)
+	ase_awk_refupval (str);
+	if (__do_assignment (w->run, w->var, str) == ASE_NULL)
 	{
-		sse_awk_refdownval (w->run, str);
+		ase_awk_refdownval (w->run, str);
 		return -1;
 	}
 
 	if (__run_statement (w->run, w->body) == -1)
 	{
-		sse_awk_refdownval (w->run, str);
+		ase_awk_refdownval (w->run, str);
 		return -1;
 	}
 	
-	sse_awk_refdownval (w->run, str);
+	ase_awk_refdownval (w->run, str);
 	return 0;
 }
 
-static int __run_foreach (sse_awk_run_t* run, sse_awk_nde_foreach_t* nde)
+static int __run_foreach (ase_awk_run_t* run, ase_awk_nde_foreach_t* nde)
 {
 	int n;
-	sse_awk_nde_exp_t* test;
-	sse_awk_val_t* rv;
-	sse_awk_map_t* map;
+	ase_awk_nde_exp_t* test;
+	ase_awk_val_t* rv;
+	ase_awk_map_t* map;
 	struct __foreach_walker_t walker;
 
-	test = (sse_awk_nde_exp_t*)nde->test;
-	sse_awk_assert (run->awk, test->type == SSE_AWK_NDE_EXP_BIN && 
-	           test->opcode == SSE_AWK_BINOP_IN);
+	test = (ase_awk_nde_exp_t*)nde->test;
+	ase_awk_assert (run->awk, test->type == ASE_AWK_NDE_EXP_BIN && 
+	           test->opcode == ASE_AWK_BINOP_IN);
 
 	/* chained expressions should not be allowed 
 	 * by the parser first of all */
-	sse_awk_assert (run->awk, test->right->next == SSE_NULL); 
+	ase_awk_assert (run->awk, test->right->next == ASE_NULL); 
 
 	rv = __eval_expression (run, test->right);
-	if (rv == SSE_NULL) return -1;
+	if (rv == ASE_NULL) return -1;
 
-	sse_awk_refupval (rv);
-	if (rv->type != SSE_AWK_VAL_MAP)
+	ase_awk_refupval (rv);
+	if (rv->type != ASE_AWK_VAL_MAP)
 	{
-		sse_awk_refdownval (run, rv);
-		PANIC_I (run, SSE_AWK_ENOTINDEXABLE);
+		ase_awk_refdownval (run, rv);
+		PANIC_I (run, ASE_AWK_ENOTINDEXABLE);
 	}
-	map = ((sse_awk_val_map_t*)rv)->map;
+	map = ((ase_awk_val_map_t*)rv)->map;
 
 	walker.run = run;
 	walker.var = test->left;
 	walker.body = nde->body;
-	n = sse_awk_map_walk (map, __walk_foreach, &walker);
+	n = ase_awk_map_walk (map, __walk_foreach, &walker);
 
-	sse_awk_refdownval (run, rv);
+	ase_awk_refdownval (run, rv);
 	return n;
 }
 
-static int __run_break (sse_awk_run_t* run, sse_awk_nde_break_t* nde)
+static int __run_break (ase_awk_run_t* run, ase_awk_nde_break_t* nde)
 {
 	run->exit_level = EXIT_BREAK;
 	return 0;
 }
 
-static int __run_continue (sse_awk_run_t* run, sse_awk_nde_continue_t* nde)
+static int __run_continue (ase_awk_run_t* run, ase_awk_nde_continue_t* nde)
 {
 	run->exit_level = EXIT_CONTINUE;
 	return 0;
 }
 
-static int __run_return (sse_awk_run_t* run, sse_awk_nde_return_t* nde)
+static int __run_return (ase_awk_run_t* run, ase_awk_nde_return_t* nde)
 {
-	if (nde->val != SSE_NULL)
+	if (nde->val != ASE_NULL)
 	{
-		sse_awk_val_t* val;
+		ase_awk_val_t* val;
 
 		/* chained expressions should not be allowed 
 		 * by the parser first of all */
-		sse_awk_assert (run->awk, nde->val->next == SSE_NULL); 
+		ase_awk_assert (run->awk, nde->val->next == ASE_NULL); 
 
-/*xp_printf (SSE_T("returning....\n"));*/
+/*xp_printf (ASE_T("returning....\n"));*/
 		val = __eval_expression (run, nde->val);
-		if (val == SSE_NULL) return -1;
+		if (val == ASE_NULL) return -1;
 
-		sse_awk_refdownval (run, STACK_RETVAL(run));
+		ase_awk_refdownval (run, STACK_RETVAL(run));
 		STACK_RETVAL(run) = val;
-		sse_awk_refupval (val); /* see __eval_call for the trick */
-/*xp_printf (SSE_T("set return value....\n"));*/
+		ase_awk_refupval (val); /* see __eval_call for the trick */
+/*xp_printf (ASE_T("set return value....\n"));*/
 	}
 	
 	run->exit_level = EXIT_FUNCTION;
 	return 0;
 }
 
-static int __run_exit (sse_awk_run_t* run, sse_awk_nde_exit_t* nde)
+static int __run_exit (ase_awk_run_t* run, ase_awk_nde_exit_t* nde)
 {
-	if (nde->val != SSE_NULL)
+	if (nde->val != ASE_NULL)
 	{
-		sse_awk_val_t* val;
+		ase_awk_val_t* val;
 
 		/* chained expressions should not be allowed 
 		 * by the parser first of all */
-		sse_awk_assert (run->awk, nde->val->next == SSE_NULL); 
+		ase_awk_assert (run->awk, nde->val->next == ASE_NULL); 
 
 		val = __eval_expression (run, nde->val);
-		if (val == SSE_NULL) return -1;
+		if (val == ASE_NULL) return -1;
 
-		sse_awk_refdownval (run, STACK_RETVAL_GLOBAL(run));
+		ase_awk_refdownval (run, STACK_RETVAL_GLOBAL(run));
 		STACK_RETVAL_GLOBAL(run) = val; /* global return value */
 
-		sse_awk_refupval (val);
+		ase_awk_refupval (val);
 	}
 
 	run->exit_level = EXIT_GLOBAL;
 	return 0;
 }
 
-static int __run_next (sse_awk_run_t* run, sse_awk_nde_next_t* nde)
+static int __run_next (ase_awk_run_t* run, ase_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 */
 
-	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)
+	if  (run->active_block == (ase_awk_nde_blk_t*)run->awk->tree.begin ||
+	     run->active_block == (ase_awk_nde_blk_t*)run->awk->tree.end)
 	{
-		PANIC_I (run, SSE_AWK_ENEXTCALL);
+		PANIC_I (run, ASE_AWK_ENEXTCALL);
 	}
 
 	run->exit_level = EXIT_NEXT;
 	return 0;
 }
 
-static int __run_nextfile (sse_awk_run_t* run, sse_awk_nde_nextfile_t* nde)
+static int __run_nextfile (ase_awk_run_t* run, ase_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 == (sse_awk_nde_blk_t*)run->awk->tree.begin ||
-	     run->active_block == (sse_awk_nde_blk_t*)run->awk->tree.end)
+	if  (run->active_block == (ase_awk_nde_blk_t*)run->awk->tree.begin ||
+	     run->active_block == (ase_awk_nde_blk_t*)run->awk->tree.end)
 	{
-		run->errnum = SSE_AWK_ENEXTFILECALL;
+		run->errnum = ASE_AWK_ENEXTFILECALL;
 		return -1;
 	}
 
-	n = sse_awk_nextextio_read (run, SSE_AWK_IN_CONSOLE, SSE_T(""));
+	n = ase_awk_nextextio_read (run, ASE_AWK_IN_CONSOLE, ASE_T(""));
 	if (n == -1)
 	{
-		if (run->errnum == SSE_AWK_EIOHANDLER)
-			run->errnum = SSE_AWK_ECONINNEXT;
+		if (run->errnum == ASE_AWK_EIOHANDLER)
+			run->errnum = ASE_AWK_ECONINNEXT;
 		return -1;
 	}
 
@@ -1930,231 +1930,231 @@ static int __run_nextfile (sse_awk_run_t* run, sse_awk_nde_nextfile_t* nde)
 	return 0;
 }
 
-static int __run_delete (sse_awk_run_t* run, sse_awk_nde_delete_t* nde)
+static int __run_delete (ase_awk_run_t* run, ase_awk_nde_delete_t* nde)
 {
-	sse_awk_nde_var_t* var;
+	ase_awk_nde_var_t* var;
 
-	var = (sse_awk_nde_var_t*) nde->var;
+	var = (ase_awk_nde_var_t*) nde->var;
 
-	if (var->type == SSE_AWK_NDE_NAMED ||
-	    var->type == SSE_AWK_NDE_NAMEDIDX)
+	if (var->type == ASE_AWK_NDE_NAMED ||
+	    var->type == ASE_AWK_NDE_NAMEDIDX)
 	{
-		sse_awk_pair_t* pair;
+		ase_awk_pair_t* pair;
 
-		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));
+		ase_awk_assert (run->awk, (var->type == ASE_AWK_NDE_NAMED && 
+		            var->idx == ASE_NULL) ||
+		           (var->type == ASE_AWK_NDE_NAMEDIDX && 
+		            var->idx != ASE_NULL));
 
-		pair = sse_awk_map_get (
+		pair = ase_awk_map_get (
 			&run->named, var->id.name, var->id.name_len);
-		if (pair == SSE_NULL)
+		if (pair == ASE_NULL)
 		{
-			sse_awk_val_t* tmp;
+			ase_awk_val_t* tmp;
 
 			/* value not set for the named variable. 
 			 * create a map and assign it to the variable */
 
-			tmp = sse_awk_makemapval (run);
-			if (tmp == SSE_NULL) PANIC_I (run, SSE_AWK_ENOMEM);
+			tmp = ase_awk_makemapval (run);
+			if (tmp == ASE_NULL) PANIC_I (run, ASE_AWK_ENOMEM);
 
-			if (sse_awk_map_put (&run->named, 
-				var->id.name, var->id.name_len, tmp) == SSE_NULL)
+			if (ase_awk_map_put (&run->named, 
+				var->id.name, var->id.name_len, tmp) == ASE_NULL)
 			{
-				sse_awk_refupval (tmp);
-				sse_awk_refdownval (run, tmp);
-				PANIC_I (run, SSE_AWK_ENOMEM);		
+				ase_awk_refupval (tmp);
+				ase_awk_refdownval (run, tmp);
+				PANIC_I (run, ASE_AWK_ENOMEM);		
 			}
 
-			sse_awk_refupval (tmp);
+			ase_awk_refupval (tmp);
 		}
 		else
 		{
-			sse_awk_val_t* val;
-			sse_awk_map_t* map;
+			ase_awk_val_t* val;
+			ase_awk_map_t* map;
 
-			val = (sse_awk_val_t*)pair->val;
-			sse_awk_assert (run->awk, val != SSE_NULL);
+			val = (ase_awk_val_t*)pair->val;
+			ase_awk_assert (run->awk, val != ASE_NULL);
 
-			if (val->type != SSE_AWK_VAL_MAP)
-				PANIC_I (run, SSE_AWK_ENOTDELETABLE);
+			if (val->type != ASE_AWK_VAL_MAP)
+				PANIC_I (run, ASE_AWK_ENOTDELETABLE);
 
-			map = ((sse_awk_val_map_t*)val)->map;
-			if (var->type == SSE_AWK_NDE_NAMEDIDX)
+			map = ((ase_awk_val_map_t*)val)->map;
+			if (var->type == ASE_AWK_NDE_NAMEDIDX)
 			{
-				sse_char_t* key;
-				sse_size_t key_len;
-				sse_awk_val_t* idx;
+				ase_char_t* key;
+				ase_size_t key_len;
+				ase_awk_val_t* idx;
 
-				sse_awk_assert (run->awk, var->idx != SSE_NULL);
+				ase_awk_assert (run->awk, var->idx != ASE_NULL);
 
 				idx = __eval_expression (run, var->idx);
-				if (idx == SSE_NULL) return -1;
+				if (idx == ASE_NULL) return -1;
 
-				sse_awk_refupval (idx);
-				key = sse_awk_valtostr (
-					run, idx, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &key_len);
-				sse_awk_refdownval (run, idx);
+				ase_awk_refupval (idx);
+				key = ase_awk_valtostr (
+					run, idx, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &key_len);
+				ase_awk_refdownval (run, idx);
 
-				if (key == SSE_NULL) return -1;
+				if (key == ASE_NULL) return -1;
 
-				sse_awk_map_remove (map, key, key_len);
-				SSE_AWK_FREE (run->awk, key);
+				ase_awk_map_remove (map, key, key_len);
+				ASE_AWK_FREE (run->awk, key);
 			}
 			else
 			{
-				sse_awk_map_clear (map);
+				ase_awk_map_clear (map);
 			}
 		}
 	}
-	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)
+	else if (var->type == ASE_AWK_NDE_GLOBAL ||
+	         var->type == ASE_AWK_NDE_LOCAL ||
+	         var->type == ASE_AWK_NDE_ARG ||
+	         var->type == ASE_AWK_NDE_GLOBALIDX ||
+	         var->type == ASE_AWK_NDE_LOCALIDX ||
+	         var->type == ASE_AWK_NDE_ARGIDX)
 	{
-		sse_awk_val_t* val;
+		ase_awk_val_t* val;
 
-		if (var->type == SSE_AWK_NDE_GLOBAL ||
-		    var->type == SSE_AWK_NDE_GLOBALIDX)
+		if (var->type == ASE_AWK_NDE_GLOBAL ||
+		    var->type == ASE_AWK_NDE_GLOBALIDX)
 			val = STACK_GLOBAL (run,var->id.idxa);
-		else if (var->type == SSE_AWK_NDE_LOCAL ||
-		         var->type == SSE_AWK_NDE_LOCALIDX)
+		else if (var->type == ASE_AWK_NDE_LOCAL ||
+		         var->type == ASE_AWK_NDE_LOCALIDX)
 			val = STACK_LOCAL (run,var->id.idxa);
 		else val = STACK_ARG (run,var->id.idxa);
 
-		sse_awk_assert (run->awk, val != SSE_NULL);
+		ase_awk_assert (run->awk, val != ASE_NULL);
 
-		if (val->type == SSE_AWK_VAL_NIL)
+		if (val->type == ASE_AWK_VAL_NIL)
 		{
-			sse_awk_val_t* tmp;
+			ase_awk_val_t* tmp;
 
 			/* value not set for the named variable. 
 			 * create a map and assign it to the variable */
 
-			tmp = sse_awk_makemapval (run);
-			if (tmp == SSE_NULL) PANIC_I (run, SSE_AWK_ENOMEM);
+			tmp = ase_awk_makemapval (run);
+			if (tmp == ASE_NULL) PANIC_I (run, ASE_AWK_ENOMEM);
 
 			/* no need to reduce the reference count of
 			 * the previous value because it was nil. */
-			if (var->type == SSE_AWK_NDE_GLOBAL ||
-			    var->type == SSE_AWK_NDE_GLOBALIDX)
+			if (var->type == ASE_AWK_NDE_GLOBAL ||
+			    var->type == ASE_AWK_NDE_GLOBALIDX)
 			{
-				if (sse_awk_setglobal (
+				if (ase_awk_setglobal (
 					run, var->id.idxa, tmp) == -1)
 				{
-					sse_awk_refupval (tmp);
-					sse_awk_refdownval (run, tmp);
+					ase_awk_refupval (tmp);
+					ase_awk_refdownval (run, tmp);
 					return -1;
 				}
 			}
-			else if (var->type == SSE_AWK_NDE_LOCAL ||
-			         var->type == SSE_AWK_NDE_LOCALIDX)
+			else if (var->type == ASE_AWK_NDE_LOCAL ||
+			         var->type == ASE_AWK_NDE_LOCALIDX)
 			{
 				STACK_LOCAL(run,var->id.idxa) = tmp;
-				sse_awk_refupval (tmp);
+				ase_awk_refupval (tmp);
 			}
 			else 
 			{
 				STACK_ARG(run,var->id.idxa) = tmp;
-				sse_awk_refupval (tmp);
+				ase_awk_refupval (tmp);
 			}
 		}
 		else
 		{
-			sse_awk_map_t* map;
+			ase_awk_map_t* map;
 
-			if (val->type != SSE_AWK_VAL_MAP)
-				PANIC_I (run, SSE_AWK_ENOTDELETABLE);
+			if (val->type != ASE_AWK_VAL_MAP)
+				PANIC_I (run, ASE_AWK_ENOTDELETABLE);
 
-			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)
+			map = ((ase_awk_val_map_t*)val)->map;
+			if (var->type == ASE_AWK_NDE_GLOBALIDX ||
+			    var->type == ASE_AWK_NDE_LOCALIDX ||
+			    var->type == ASE_AWK_NDE_ARGIDX)
 			{
-				sse_char_t* key;
-				sse_size_t key_len;
-				sse_awk_val_t* idx;
+				ase_char_t* key;
+				ase_size_t key_len;
+				ase_awk_val_t* idx;
 
-				sse_awk_assert (run->awk, var->idx != SSE_NULL);
+				ase_awk_assert (run->awk, var->idx != ASE_NULL);
 
 				idx = __eval_expression (run, var->idx);
-				if (idx == SSE_NULL) return -1;
+				if (idx == ASE_NULL) return -1;
 
-				sse_awk_refupval (idx);
-				key = sse_awk_valtostr (
-					run, idx, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &key_len);
-				sse_awk_refdownval (run, idx);
+				ase_awk_refupval (idx);
+				key = ase_awk_valtostr (
+					run, idx, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &key_len);
+				ase_awk_refdownval (run, idx);
 
-				if (key == SSE_NULL) return -1;
+				if (key == ASE_NULL) return -1;
 
-				sse_awk_map_remove (map, key, key_len);
-				SSE_AWK_FREE (run->awk, key);
+				ase_awk_map_remove (map, key, key_len);
+				ASE_AWK_FREE (run->awk, key);
 			}
 			else
 			{
-				sse_awk_map_clear (map);
+				ase_awk_map_clear (map);
 			}
 		}
 	}
 	else
 	{
-		sse_awk_assert (run->awk, !"should never happen - wrong variable type for delete");
-		PANIC_I (run, SSE_AWK_EINTERNAL);
+		ase_awk_assert (run->awk, !"should never happen - wrong variable type for delete");
+		PANIC_I (run, ASE_AWK_EINTERNAL);
 	}
 
 	return 0;
 }
 
-static int __run_print (sse_awk_run_t* run, sse_awk_nde_print_t* nde)
+static int __run_print (ase_awk_run_t* run, ase_awk_nde_print_t* nde)
 {
-	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;
+	ase_awk_nde_print_t* p = (ase_awk_nde_print_t*)nde;
+	ase_char_t* out = ASE_NULL;
+	const ase_char_t* dst;
+	ase_awk_val_t* v;
+	ase_awk_nde_t* np;
 	int n;
 
-	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));
+	ase_awk_assert (run->awk, 
+		(p->out_type == ASE_AWK_OUT_PIPE && p->out != ASE_NULL) ||
+		(p->out_type == ASE_AWK_OUT_COPROC && p->out != ASE_NULL) ||
+		(p->out_type == ASE_AWK_OUT_FILE && p->out != ASE_NULL) ||
+		(p->out_type == ASE_AWK_OUT_FILE_APPEND && p->out != ASE_NULL) ||
+		(p->out_type == ASE_AWK_OUT_CONSOLE && p->out == ASE_NULL));
 
-	if (p->out != SSE_NULL)
+	if (p->out != ASE_NULL)
 	{
-		sse_size_t len;
+		ase_size_t len;
 
 		v = __eval_expression (run, p->out);
-		if (v == SSE_NULL) return -1;
+		if (v == ASE_NULL) return -1;
 
-		sse_awk_refupval (v);
-		out = sse_awk_valtostr (
-			run, v, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
-		if (out == SSE_NULL) 
+		ase_awk_refupval (v);
+		out = ase_awk_valtostr (
+			run, v, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &len);
+		if (out == ASE_NULL) 
 		{
-			sse_awk_refdownval (run, v);
+			ase_awk_refdownval (run, v);
 			return -1;
 		}
-		sse_awk_refdownval (run, v);
+		ase_awk_refdownval (run, v);
 
 		if (len <= 0) 
 		{
 			/* the output destination name is empty. */
-			SSE_AWK_FREE (run->awk, out);
+			ASE_AWK_FREE (run->awk, out);
 			n = -1;
 			goto skip_write;
 		}
 
 		while (len > 0)
 		{
-			if (out[--len] == SSE_T('\0'))
+			if (out[--len] == ASE_T('\0'))
 			{
 				/* the output destination name contains a null 
 				 * character. */
-				SSE_AWK_FREE (run->awk, out);
+				ASE_AWK_FREE (run->awk, out);
 				n = -1;
 				goto skip_write;
 				/* TODO: how to handle error???
@@ -2168,141 +2168,141 @@ static int __run_print (sse_awk_run_t* run, sse_awk_nde_print_t* nde)
 		}
 	}
 
-	dst = (out == SSE_NULL)? SSE_T(""): out;
+	dst = (out == ASE_NULL)? ASE_T(""): out;
 
-	if (p->args == SSE_NULL)
+	if (p->args == ASE_NULL)
 	{
 		/*
 		v = run->inrec.d0;
-		sse_awk_refupval (v);
-		n = sse_awk_writeextio_val (run, p->out_type, dst, v);
-		if (n < 0 && run->errnum != SSE_AWK_EIOHANDLER) 
+		ase_awk_refupval (v);
+		n = ase_awk_writeextio_val (run, p->out_type, dst, v);
+		if (n < 0 && run->errnum != ASE_AWK_EIOHANDLER) 
 		{
-			if (out != SSE_NULL) SSE_AWK_FREE (run->awk, out);
-			sse_awk_refdownval (run, v);
+			if (out != ASE_NULL) ASE_AWK_FREE (run->awk, out);
+			ase_awk_refdownval (run, v);
 			return -1;
 		}
-		sse_awk_refdownval (run, v);
+		ase_awk_refdownval (run, v);
 		*/
-		n = sse_awk_writeextio_str (
+		n = ase_awk_writeextio_str (
 			run, p->out_type, dst,
-			SSE_AWK_STR_BUF(&run->inrec.line),
-			SSE_AWK_STR_LEN(&run->inrec.line));
-		if (n < 0 && run->errnum != SSE_AWK_EIOHANDLER) 
+			ASE_AWK_STR_BUF(&run->inrec.line),
+			ASE_AWK_STR_LEN(&run->inrec.line));
+		if (n < 0 && run->errnum != ASE_AWK_EIOHANDLER) 
 		{
-			if (out != SSE_NULL) SSE_AWK_FREE (run->awk, out);
+			if (out != ASE_NULL) ASE_AWK_FREE (run->awk, out);
 			return -1;
 		}
-		/* TODO: how to handle n == -1 && errnum == SSE_AWK_EIOHANDLER. 
+		/* TODO: how to handle n == -1 && errnum == ASE_AWK_EIOHANDLER. 
 		 * that is the user handler returned an error... */
 	}
 	else
 	{
-		for (np = p->args; np != SSE_NULL; np = np->next)
+		for (np = p->args; np != ASE_NULL; np = np->next)
 		{
 			if (np != p->args)
 			{
-				n = sse_awk_writeextio_str (
+				n = ase_awk_writeextio_str (
 					run, p->out_type, dst, 
 					run->global.ofs.ptr, 
 					run->global.ofs.len);
-				if (n < 0 && run->errnum != SSE_AWK_EIOHANDLER) 
+				if (n < 0 && run->errnum != ASE_AWK_EIOHANDLER) 
 				{
-					if (out != SSE_NULL) SSE_AWK_FREE (run->awk, out);
+					if (out != ASE_NULL) ASE_AWK_FREE (run->awk, out);
 					return -1;
 				}
 			}
 
 			v = __eval_expression (run, np);
-			if (v == SSE_NULL) 
+			if (v == ASE_NULL) 
 			{
-				if (out != SSE_NULL) SSE_AWK_FREE (run->awk, out);
+				if (out != ASE_NULL) ASE_AWK_FREE (run->awk, out);
 				return -1;
 			}
-			sse_awk_refupval (v);
+			ase_awk_refupval (v);
 
-			n = sse_awk_writeextio_val (run, p->out_type, dst, v);
-			if (n < 0 && run->errnum != SSE_AWK_EIOHANDLER) 
+			n = ase_awk_writeextio_val (run, p->out_type, dst, v);
+			if (n < 0 && run->errnum != ASE_AWK_EIOHANDLER) 
 			{
-				if (out != SSE_NULL) SSE_AWK_FREE (run->awk, out);
-				sse_awk_refdownval (run, v);
+				if (out != ASE_NULL) ASE_AWK_FREE (run->awk, out);
+				ase_awk_refdownval (run, v);
 				return -1;
 			}
 
-			sse_awk_refdownval (run, v);
+			ase_awk_refdownval (run, v);
 
 
-			/* TODO: how to handle n == -1 && run->errnum == SSE_AWK_EIOHANDLER. 
+			/* TODO: how to handle n == -1 && run->errnum == ASE_AWK_EIOHANDLER. 
 			 * that is the user handler returned an error... */
 		}
 	}
 
-	n = sse_awk_writeextio_str (
+	n = ase_awk_writeextio_str (
 		run, p->out_type, dst, 
 		run->global.ors.ptr, run->global.ors.len);
-	if (n < 0 && run->errnum != SSE_AWK_EIOHANDLER)
+	if (n < 0 && run->errnum != ASE_AWK_EIOHANDLER)
 	{
-		if (out != SSE_NULL) SSE_AWK_FREE (run->awk, out);
+		if (out != ASE_NULL) ASE_AWK_FREE (run->awk, out);
 		return -1;
 	}
 
-	/* TODO: how to handle n == -1 && errnum == SSE_AWK_EIOHANDLER.
+	/* TODO: how to handle n == -1 && errnum == ASE_AWK_EIOHANDLER.
 	 * that is the user handler returned an error... */
 
-	if (out != SSE_NULL) SSE_AWK_FREE (run->awk, out);
+	if (out != ASE_NULL) ASE_AWK_FREE (run->awk, out);
 
 skip_write:
 	return 0;
 }
 
-static sse_awk_val_t* __eval_expression (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_expression (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	sse_awk_val_t* v;
+	ase_awk_val_t* v;
 	int n, errnum;
 
 	v = __eval_expression0 (run, nde);
-	if (v == SSE_NULL) return SSE_NULL;
+	if (v == ASE_NULL) return ASE_NULL;
 
-	if (v->type == SSE_AWK_VAL_REX)
+	if (v->type == ASE_AWK_VAL_REX)
 	{
-		sse_awk_refupval (v);
+		ase_awk_refupval (v);
 
-		if (run->inrec.d0->type == SSE_AWK_VAL_NIL)
+		if (run->inrec.d0->type == ASE_AWK_VAL_NIL)
 		{
 			/* the record has never been read. 
 			 * probably, this functions has been triggered
 			 * by the statements in the BEGIN block */
-			n = sse_awk_isemptyrex (run->awk, ((sse_awk_val_rex_t*)v)->code)? 1: 0;
+			n = ase_awk_isemptyrex (run->awk, ((ase_awk_val_rex_t*)v)->code)? 1: 0;
 		}
 		else
 		{
-			sse_awk_assert (run->awk, run->inrec.d0->type == SSE_AWK_VAL_STR);
+			ase_awk_assert (run->awk, run->inrec.d0->type == ASE_AWK_VAL_STR);
 
-			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);
+			n = ase_awk_matchrex (
+				((ase_awk_run_t*)run)->awk, 
+				((ase_awk_val_rex_t*)v)->code,
+				((((ase_awk_run_t*)run)->global.ignorecase)? ASE_AWK_REX_IGNORECASE: 0),
+				((ase_awk_val_str_t*)run->inrec.d0)->buf,
+				((ase_awk_val_str_t*)run->inrec.d0)->len,
+				ASE_NULL, ASE_NULL, &errnum);
 	
 			if (n == -1) 
 			{
-				sse_awk_refdownval (run, v);
+				ase_awk_refdownval (run, v);
 				PANIC (run, errnum);
 			}
 		}
 
-		sse_awk_refdownval (run, v);
+		ase_awk_refdownval (run, v);
 
-		v = sse_awk_makeintval (run, (n != 0));
-		if (v == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
+		v = ase_awk_makeintval (run, (n != 0));
+		if (v == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 	}
 
 	return v;
 }
 
-static sse_awk_val_t* __eval_expression0 (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_expression0 (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
 	static eval_expr_t __eval_func[] =
 	{
@@ -2333,357 +2333,357 @@ static sse_awk_val_t* __eval_expression0 (sse_awk_run_t* run, sse_awk_nde_t* nde
 		__eval_getline
 	};
 
-	sse_awk_assert (run->awk, nde->type >= SSE_AWK_NDE_GRP &&
-		(nde->type - SSE_AWK_NDE_GRP) < sse_countof(__eval_func));
+	ase_awk_assert (run->awk, nde->type >= ASE_AWK_NDE_GRP &&
+		(nde->type - ASE_AWK_NDE_GRP) < ase_countof(__eval_func));
 
-	return __eval_func[nde->type-SSE_AWK_NDE_GRP] (run, nde);
+	return __eval_func[nde->type-ASE_AWK_NDE_GRP] (run, nde);
 }
 
-static sse_awk_val_t* __eval_group (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_group (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	/* __eval_binop_in evaluates the SSE_AWK_NDE_GRP specially.
+	/* __eval_binop_in evaluates the ASE_AWK_NDE_GRP specially.
 	 * so this function should never be reached. */
-	sse_awk_assert (run->awk, !"should never happen - NDE_GRP only for in");
-	PANIC (run, SSE_AWK_EINTERNAL);
-	return SSE_NULL;
+	ase_awk_assert (run->awk, !"should never happen - NDE_GRP only for in");
+	PANIC (run, ASE_AWK_EINTERNAL);
+	return ASE_NULL;
 }
 
-static sse_awk_val_t* __eval_assignment (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_assignment (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	sse_awk_val_t* val, * ret;
-	sse_awk_nde_ass_t* ass = (sse_awk_nde_ass_t*)nde;
+	ase_awk_val_t* val, * ret;
+	ase_awk_nde_ass_t* ass = (ase_awk_nde_ass_t*)nde;
 
-	sse_awk_assert (run->awk, ass->left != SSE_NULL && ass->right != SSE_NULL);
+	ase_awk_assert (run->awk, ass->left != ASE_NULL && ass->right != ASE_NULL);
 
-	sse_awk_assert (run->awk, ass->right->next == SSE_NULL);
+	ase_awk_assert (run->awk, ass->right->next == ASE_NULL);
 	val = __eval_expression (run, ass->right);
-	if (val == SSE_NULL) return SSE_NULL;
+	if (val == ASE_NULL) return ASE_NULL;
 
-	sse_awk_refupval (val);
+	ase_awk_refupval (val);
 
-	if (ass->opcode != SSE_AWK_ASSOP_NONE)
+	if (ass->opcode != ASE_AWK_ASSOP_NONE)
 	{
-		sse_awk_val_t* val2, * tmp;
+		ase_awk_val_t* val2, * tmp;
 
-		sse_awk_assert (run->awk, ass->left->next == SSE_NULL);
+		ase_awk_assert (run->awk, ass->left->next == ASE_NULL);
 		val2 = __eval_expression (run, ass->left);
-		if (val2 == SSE_NULL)
+		if (val2 == ASE_NULL)
 		{
-			sse_awk_refdownval (run, val);
-			return SSE_NULL;
+			ase_awk_refdownval (run, val);
+			return ASE_NULL;
 		}
 
-		sse_awk_refupval (val2);
+		ase_awk_refupval (val2);
 
-		if (ass->opcode == SSE_AWK_ASSOP_PLUS)
+		if (ass->opcode == ASE_AWK_ASSOP_PLUS)
 		{
 			tmp = __eval_binop_plus (run, val2, val);
 		}
-		else if (ass->opcode == SSE_AWK_ASSOP_MINUS)
+		else if (ass->opcode == ASE_AWK_ASSOP_MINUS)
 		{
 			tmp = __eval_binop_minus (run, val2, val);
 		}
-		else if (ass->opcode == SSE_AWK_ASSOP_MUL)
+		else if (ass->opcode == ASE_AWK_ASSOP_MUL)
 		{
 			tmp = __eval_binop_mul (run, val2, val);
 		}
-		else if (ass->opcode == SSE_AWK_ASSOP_DIV)
+		else if (ass->opcode == ASE_AWK_ASSOP_DIV)
 		{
 			tmp = __eval_binop_div (run, val2, val);
 		}
-		else if (ass->opcode == SSE_AWK_ASSOP_MOD)
+		else if (ass->opcode == ASE_AWK_ASSOP_MOD)
 		{
 			tmp = __eval_binop_mod (run, val2, val);
 		}
-		else if (ass->opcode == SSE_AWK_ASSOP_EXP)
+		else if (ass->opcode == ASE_AWK_ASSOP_EXP)
 		{
 			tmp = __eval_binop_exp (run, val2, val);
 		}
 		else
 		{
-			sse_awk_assert (run->awk, !"should never happen - invalid assignment opcode");
-			PANIC (run, SSE_AWK_EINTERNAL);
+			ase_awk_assert (run->awk, !"should never happen - invalid assignment opcode");
+			PANIC (run, ASE_AWK_EINTERNAL);
 		}
 
-		if (tmp == SSE_NULL)
+		if (tmp == ASE_NULL)
 		{
-			sse_awk_refdownval (run, val);
-			sse_awk_refdownval (run, val2);
-			return SSE_NULL;
+			ase_awk_refdownval (run, val);
+			ase_awk_refdownval (run, val2);
+			return ASE_NULL;
 		}
 
-		sse_awk_refdownval (run, val);
+		ase_awk_refdownval (run, val);
 		val = tmp;
-		sse_awk_refupval (val);
+		ase_awk_refupval (val);
 	}
 
 	ret = __do_assignment (run, ass->left, val);
-	sse_awk_refdownval (run, val);
+	ase_awk_refdownval (run, val);
 
 	return ret;
 }
 
-static sse_awk_val_t* __do_assignment (
-	sse_awk_run_t* run, sse_awk_nde_t* var, sse_awk_val_t* val)
+static ase_awk_val_t* __do_assignment (
+	ase_awk_run_t* run, ase_awk_nde_t* var, ase_awk_val_t* val)
 {
-	sse_awk_val_t* ret;
+	ase_awk_val_t* ret;
 
-	if (val->type == SSE_AWK_VAL_MAP)
+	if (val->type == ASE_AWK_VAL_MAP)
 	{
 		/* a map cannot be assigned to a variable */
-		PANIC (run, SSE_AWK_ENOTASSIGNABLE);
+		PANIC (run, ASE_AWK_ENOTASSIGNABLE);
 	}
 
-	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) 
+	if (var->type == ASE_AWK_NDE_NAMED ||
+	    var->type == ASE_AWK_NDE_GLOBAL ||
+	    var->type == ASE_AWK_NDE_LOCAL ||
+	    var->type == ASE_AWK_NDE_ARG) 
 	{
-		ret = __do_assignment_scalar (run, (sse_awk_nde_var_t*)var, val);
+		ret = __do_assignment_scalar (run, (ase_awk_nde_var_t*)var, val);
 	}
-	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) 
+	else if (var->type == ASE_AWK_NDE_NAMEDIDX ||
+	         var->type == ASE_AWK_NDE_GLOBALIDX ||
+	         var->type == ASE_AWK_NDE_LOCALIDX ||
+	         var->type == ASE_AWK_NDE_ARGIDX) 
 	{
-		ret = __do_assignment_map (run, (sse_awk_nde_var_t*)var, val);
+		ret = __do_assignment_map (run, (ase_awk_nde_var_t*)var, val);
 	}
-	else if (var->type == SSE_AWK_NDE_POS)
+	else if (var->type == ASE_AWK_NDE_POS)
 	{
-		ret = __do_assignment_pos (run, (sse_awk_nde_pos_t*)var, val);
+		ret = __do_assignment_pos (run, (ase_awk_nde_pos_t*)var, val);
 	}
 	else
 	{
-		sse_awk_assert (run->awk, !"should never happen - invalid variable type");
-		PANIC (run, SSE_AWK_EINTERNAL);
+		ase_awk_assert (run->awk, !"should never happen - invalid variable type");
+		PANIC (run, ASE_AWK_EINTERNAL);
 	}
 
 	return ret;
 }
 
-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 ase_awk_val_t* __do_assignment_scalar (
+	ase_awk_run_t* run, ase_awk_nde_var_t* var, ase_awk_val_t* val)
 {
-	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);
+	ase_awk_assert (run->awk, 
+		(var->type == ASE_AWK_NDE_NAMED ||
+		 var->type == ASE_AWK_NDE_GLOBAL ||
+		 var->type == ASE_AWK_NDE_LOCAL ||
+		 var->type == ASE_AWK_NDE_ARG) && var->idx == ASE_NULL);
 
-	sse_awk_assert (run->awk, val->type != SSE_AWK_VAL_MAP);
+	ase_awk_assert (run->awk, val->type != ASE_AWK_VAL_MAP);
 
-	if (var->type == SSE_AWK_NDE_NAMED) 
+	if (var->type == ASE_AWK_NDE_NAMED) 
 	{
-		sse_awk_pair_t* pair;
+		ase_awk_pair_t* pair;
 		int n;
 
-		pair = sse_awk_map_get (
+		pair = ase_awk_map_get (
 			&run->named, var->id.name, var->id.name_len);
-		if (pair != SSE_NULL && 
-		    ((sse_awk_val_t*)pair->val)->type == SSE_AWK_VAL_MAP)
+		if (pair != ASE_NULL && 
+		    ((ase_awk_val_t*)pair->val)->type == ASE_AWK_VAL_MAP)
 		{
 			/* once a variable becomes an array,
 			 * it cannot be changed to a scalar variable */
-			PANIC (run, SSE_AWK_EMAPTOSCALAR);
+			PANIC (run, ASE_AWK_EMAPTOSCALAR);
 		}
 
-		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);
+		n = ase_awk_map_putx (&run->named, 
+			var->id.name, var->id.name_len, val, ASE_NULL);
+		if (n < 0) PANIC (run, ASE_AWK_ENOMEM);
 
-		sse_awk_refupval (val);
+		ase_awk_refupval (val);
 	}
-	else if (var->type == SSE_AWK_NDE_GLOBAL) 
+	else if (var->type == ASE_AWK_NDE_GLOBAL) 
 	{
-		if (sse_awk_setglobal (
-			run, var->id.idxa, val) == -1) return SSE_NULL;
+		if (ase_awk_setglobal (
+			run, var->id.idxa, val) == -1) return ASE_NULL;
 	}
-	else if (var->type == SSE_AWK_NDE_LOCAL) 
+	else if (var->type == ASE_AWK_NDE_LOCAL) 
 	{
-		sse_awk_val_t* old = STACK_LOCAL(run,var->id.idxa);
-		if (old->type == SSE_AWK_VAL_MAP)
+		ase_awk_val_t* old = STACK_LOCAL(run,var->id.idxa);
+		if (old->type == ASE_AWK_VAL_MAP)
 		{	
 			/* once the variable becomes an array,
 			 * it cannot be changed to a scalar variable */
-			PANIC (run, SSE_AWK_EMAPTOSCALAR);
+			PANIC (run, ASE_AWK_EMAPTOSCALAR);
 		}
 
-		sse_awk_refdownval (run, old);
+		ase_awk_refdownval (run, old);
 		STACK_LOCAL(run,var->id.idxa) = val;
-		sse_awk_refupval (val);
+		ase_awk_refupval (val);
 	}
-	else /* if (var->type == SSE_AWK_NDE_ARG) */
+	else /* if (var->type == ASE_AWK_NDE_ARG) */
 	{
-		sse_awk_val_t* old = STACK_ARG(run,var->id.idxa);
-		if (old->type == SSE_AWK_VAL_MAP)
+		ase_awk_val_t* old = STACK_ARG(run,var->id.idxa);
+		if (old->type == ASE_AWK_VAL_MAP)
 		{	
 			/* once the variable becomes an array,
 			 * it cannot be changed to a scalar variable */
-			PANIC (run, SSE_AWK_EMAPTOSCALAR);
+			PANIC (run, ASE_AWK_EMAPTOSCALAR);
 		}
 
-		sse_awk_refdownval (run, old);
+		ase_awk_refdownval (run, old);
 		STACK_ARG(run,var->id.idxa) = val;
-		sse_awk_refupval (val);
+		ase_awk_refupval (val);
 	}
 
 	return 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 ase_awk_val_t* __do_assignment_map (
+	ase_awk_run_t* run, ase_awk_nde_var_t* var, ase_awk_val_t* val)
 {
-	sse_awk_val_map_t* map;
-	sse_char_t* str;
-	sse_size_t len;
+	ase_awk_val_map_t* map;
+	ase_char_t* str;
+	ase_size_t len;
 	int n;
 
-	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);
+	ase_awk_assert (run->awk, 
+		(var->type == ASE_AWK_NDE_NAMEDIDX ||
+		 var->type == ASE_AWK_NDE_GLOBALIDX ||
+		 var->type == ASE_AWK_NDE_LOCALIDX ||
+		 var->type == ASE_AWK_NDE_ARGIDX) && var->idx != ASE_NULL);
+	ase_awk_assert (run->awk, val->type != ASE_AWK_VAL_MAP);
 
-	if (var->type == SSE_AWK_NDE_NAMEDIDX)
+	if (var->type == ASE_AWK_NDE_NAMEDIDX)
 	{
-		sse_awk_pair_t* pair;
-		pair = sse_awk_map_get (
+		ase_awk_pair_t* pair;
+		pair = ase_awk_map_get (
 			&run->named, var->id.name, var->id.name_len);
-		map = (pair == SSE_NULL)? 
-			(sse_awk_val_map_t*)sse_awk_val_nil: 
-			(sse_awk_val_map_t*)pair->val;
+		map = (pair == ASE_NULL)? 
+			(ase_awk_val_map_t*)ase_awk_val_nil: 
+			(ase_awk_val_map_t*)pair->val;
 	}
 	else
 	{
-		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);
+		map = (var->type == ASE_AWK_NDE_GLOBALIDX)? 
+		      	(ase_awk_val_map_t*)STACK_GLOBAL(run,var->id.idxa):
+		      (var->type == ASE_AWK_NDE_LOCALIDX)? 
+		      	(ase_awk_val_map_t*)STACK_LOCAL(run,var->id.idxa):
+		      	(ase_awk_val_map_t*)STACK_ARG(run,var->id.idxa);
 	}
 
-	if (map->type == SSE_AWK_VAL_NIL)
+	if (map->type == ASE_AWK_VAL_NIL)
 	{
 		/* the map is not initialized yet */
-		sse_awk_val_t* tmp;
+		ase_awk_val_t* tmp;
 
-		tmp = sse_awk_makemapval (run);
-		if (tmp == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
+		tmp = ase_awk_makemapval (run);
+		if (tmp == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 
-		if (var->type == SSE_AWK_NDE_NAMEDIDX)
+		if (var->type == ASE_AWK_NDE_NAMEDIDX)
 		{
 			/* doesn't have to decrease the reference count 
 			 * of the previous value here as it is done by 
-			 * sse_awk_map_put */
-			if (sse_awk_map_put (&run->named, 
-				var->id.name, var->id.name_len, tmp) == SSE_NULL)
+			 * ase_awk_map_put */
+			if (ase_awk_map_put (&run->named, 
+				var->id.name, var->id.name_len, tmp) == ASE_NULL)
 			{
-				sse_awk_refupval (tmp);
-				sse_awk_refdownval (run, tmp);
-				PANIC (run, SSE_AWK_ENOMEM);		
+				ase_awk_refupval (tmp);
+				ase_awk_refdownval (run, tmp);
+				PANIC (run, ASE_AWK_ENOMEM);		
 			}
 
-			sse_awk_refupval (tmp);
+			ase_awk_refupval (tmp);
 		}
-		else if (var->type == SSE_AWK_NDE_GLOBALIDX)
+		else if (var->type == ASE_AWK_NDE_GLOBALIDX)
 		{
-			sse_awk_refupval (tmp);
-			if (sse_awk_setglobal (run, var->id.idxa, tmp) == -1)
+			ase_awk_refupval (tmp);
+			if (ase_awk_setglobal (run, var->id.idxa, tmp) == -1)
 			{
-				sse_awk_refdownval (run, tmp);
-				return SSE_NULL;
+				ase_awk_refdownval (run, tmp);
+				return ASE_NULL;
 			}
-			sse_awk_refdownval (run, tmp);
+			ase_awk_refdownval (run, tmp);
 		}
-		else if (var->type == SSE_AWK_NDE_LOCALIDX)
+		else if (var->type == ASE_AWK_NDE_LOCALIDX)
 		{
-			sse_awk_refdownval (run, (sse_awk_val_t*)map);
+			ase_awk_refdownval (run, (ase_awk_val_t*)map);
 			STACK_LOCAL(run,var->id.idxa) = tmp;
-			sse_awk_refupval (tmp);
+			ase_awk_refupval (tmp);
 		}
-		else /* if (var->type == SSE_AWK_NDE_ARGIDX) */
+		else /* if (var->type == ASE_AWK_NDE_ARGIDX) */
 		{
-			sse_awk_refdownval (run, (sse_awk_val_t*)map);
+			ase_awk_refdownval (run, (ase_awk_val_t*)map);
 			STACK_ARG(run,var->id.idxa) = tmp;
-			sse_awk_refupval (tmp);
+			ase_awk_refupval (tmp);
 		}
 
-		map = (sse_awk_val_map_t*) tmp;
+		map = (ase_awk_val_map_t*) tmp;
 	}
-	else if (map->type != SSE_AWK_VAL_MAP)
+	else if (map->type != ASE_AWK_VAL_MAP)
 	{
-		PANIC (run, SSE_AWK_ENOTINDEXABLE);
+		PANIC (run, ASE_AWK_ENOTINDEXABLE);
 	}
 
 	str = __idxnde_to_str (run, var->idx, &len);
-	if (str == SSE_NULL) return SSE_NULL;
+	if (str == ASE_NULL) return ASE_NULL;
 
 /*
-xp_printf (SSE_T("**** index str=>%s, map->ref=%d, map->type=%d\n"), str, (int)map->ref, (int)map->type);
+xp_printf (ASE_T("**** index str=>%s, map->ref=%d, map->type=%d\n"), str, (int)map->ref, (int)map->type);
 */
-	n = sse_awk_map_putx (map->map, str, len, val, SSE_NULL);
+	n = ase_awk_map_putx (map->map, str, len, val, ASE_NULL);
 	if (n < 0)
 	{
-		SSE_AWK_FREE (run->awk, str);
-		PANIC (run, SSE_AWK_ENOMEM);
+		ASE_AWK_FREE (run->awk, str);
+		PANIC (run, ASE_AWK_ENOMEM);
 	}
 
-	SSE_AWK_FREE (run->awk, str);
-	sse_awk_refupval (val);
+	ASE_AWK_FREE (run->awk, str);
+	ase_awk_refupval (val);
 	return 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 ase_awk_val_t* __do_assignment_pos (
+	ase_awk_run_t* run, ase_awk_nde_pos_t* pos, ase_awk_val_t* val)
 {
-	sse_awk_val_t* v;
-	sse_long_t lv;
-	sse_real_t rv;
-	sse_char_t* str;
-	sse_size_t len;
+	ase_awk_val_t* v;
+	ase_long_t lv;
+	ase_real_t rv;
+	ase_char_t* str;
+	ase_size_t len;
 	int n;
 
 	v = __eval_expression (run, pos->val);
-	if (v == SSE_NULL) return SSE_NULL;
+	if (v == ASE_NULL) return ASE_NULL;
 
-	sse_awk_refupval (v);
-	n = sse_awk_valtonum (run, v, &lv, &rv);
-	sse_awk_refdownval (run, v);
+	ase_awk_refupval (v);
+	n = ase_awk_valtonum (run, v, &lv, &rv);
+	ase_awk_refdownval (run, v);
 
-	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 (n == -1) PANIC (run, ASE_AWK_EPOSIDX); 
+	if (n == 1) lv = (ase_long_t)rv;
+	if (!IS_VALID_POSIDX(lv)) PANIC (run, ASE_AWK_EPOSIDX);
 
-	if (val->type == SSE_AWK_VAL_STR)
+	if (val->type == ASE_AWK_VAL_STR)
 	{
-		str = ((sse_awk_val_str_t*)val)->buf;
-		len = ((sse_awk_val_str_t*)val)->len;
+		str = ((ase_awk_val_str_t*)val)->buf;
+		len = ((ase_awk_val_str_t*)val)->len;
 	}
 	else
 	{
-		str = sse_awk_valtostr (run, val, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
-		if (str == SSE_NULL) return SSE_NULL;
+		str = ase_awk_valtostr (run, val, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &len);
+		if (str == ASE_NULL) return ASE_NULL;
 	}
 	
-	n = sse_awk_setrec (run, (sse_size_t)lv, str, len);
+	n = ase_awk_setrec (run, (ase_size_t)lv, str, len);
 
-	if (val->type != SSE_AWK_VAL_STR) SSE_AWK_FREE (run->awk, str);
+	if (val->type != ASE_AWK_VAL_STR) ASE_AWK_FREE (run->awk, str);
 
-	if (n == -1) return SSE_NULL;
+	if (n == -1) return ASE_NULL;
 	return (lv == 0)? run->inrec.d0: run->inrec.flds[lv-1].val;
 }
 
-static sse_awk_val_t* __eval_binary (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_binary (ase_awk_run_t* run, ase_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 */
 
-		SSE_NULL, /* __eval_binop_lor */
-		SSE_NULL, /* __eval_binop_land */
-		SSE_NULL, /* __eval_binop_in */
+		ASE_NULL, /* __eval_binop_lor */
+		ASE_NULL, /* __eval_binop_land */
+		ASE_NULL, /* __eval_binop_in */
 
 		__eval_binop_bor,
 		__eval_binop_bxor,
@@ -2707,525 +2707,525 @@ static sse_awk_val_t* __eval_binary (sse_awk_run_t* run, sse_awk_nde_t* nde)
 		__eval_binop_exp,
 
 		__eval_binop_concat,
-		SSE_NULL, /* __eval_binop_ma */
-		SSE_NULL  /* __eval_binop_nm */
+		ASE_NULL, /* __eval_binop_ma */
+		ASE_NULL  /* __eval_binop_nm */
 	};
 
-	sse_awk_nde_exp_t* exp = (sse_awk_nde_exp_t*)nde;
-	sse_awk_val_t* left, * right, * res;
+	ase_awk_nde_exp_t* exp = (ase_awk_nde_exp_t*)nde;
+	ase_awk_val_t* left, * right, * res;
 
-	sse_awk_assert (run->awk, exp->type == SSE_AWK_NDE_EXP_BIN);
+	ase_awk_assert (run->awk, exp->type == ASE_AWK_NDE_EXP_BIN);
 
-	if (exp->opcode == SSE_AWK_BINOP_LAND)
+	if (exp->opcode == ASE_AWK_BINOP_LAND)
 	{
 		res = __eval_binop_land (run, exp->left, exp->right);
 	}
-	else if (exp->opcode == SSE_AWK_BINOP_LOR)
+	else if (exp->opcode == ASE_AWK_BINOP_LOR)
 	{
 		res = __eval_binop_lor (run, exp->left, exp->right);
 	}
-	else if (exp->opcode == SSE_AWK_BINOP_IN)
+	else if (exp->opcode == ASE_AWK_BINOP_IN)
 	{
 		/* treat the in operator specially */
 		res = __eval_binop_in (run, exp->left, exp->right);
 	}
-	else if (exp->opcode == SSE_AWK_BINOP_NM)
+	else if (exp->opcode == ASE_AWK_BINOP_NM)
 	{
 		res = __eval_binop_nm (run, exp->left, exp->right);
 	}
-	else if (exp->opcode == SSE_AWK_BINOP_MA)
+	else if (exp->opcode == ASE_AWK_BINOP_MA)
 	{
 		res = __eval_binop_ma (run, exp->left, exp->right);
 	}
 	else
 	{
-		sse_awk_assert (run->awk, exp->left->next == SSE_NULL);
+		ase_awk_assert (run->awk, exp->left->next == ASE_NULL);
 		left = __eval_expression (run, exp->left);
-		if (left == SSE_NULL) return SSE_NULL;
+		if (left == ASE_NULL) return ASE_NULL;
 
-		sse_awk_refupval (left);
+		ase_awk_refupval (left);
 
-		sse_awk_assert (run->awk, exp->right->next == SSE_NULL);
+		ase_awk_assert (run->awk, exp->right->next == ASE_NULL);
 		right = __eval_expression (run, exp->right);
-		if (right == SSE_NULL) 
+		if (right == ASE_NULL) 
 		{
-			sse_awk_refdownval (run, left);
-			return SSE_NULL;
+			ase_awk_refdownval (run, left);
+			return ASE_NULL;
 		}
 
-		sse_awk_refupval (right);
+		ase_awk_refupval (right);
 
-		sse_awk_assert (run->awk, exp->opcode >= 0 && 
-			exp->opcode < sse_countof(__binop_func));
-		sse_awk_assert (run->awk, __binop_func[exp->opcode] != SSE_NULL);
+		ase_awk_assert (run->awk, exp->opcode >= 0 && 
+			exp->opcode < ase_countof(__binop_func));
+		ase_awk_assert (run->awk, __binop_func[exp->opcode] != ASE_NULL);
 
 		res = __binop_func[exp->opcode] (run, left, right);
 
-		sse_awk_refdownval (run, left);
-		sse_awk_refdownval (run, right);
+		ase_awk_refdownval (run, left);
+		ase_awk_refdownval (run, right);
 	}
 
 	return res;
 }
 
-static sse_awk_val_t* __eval_binop_lor (
-	sse_awk_run_t* run, sse_awk_nde_t* left, sse_awk_nde_t* right)
+static ase_awk_val_t* __eval_binop_lor (
+	ase_awk_run_t* run, ase_awk_nde_t* left, ase_awk_nde_t* right)
 {
 	/*
-	sse_awk_val_t* res = SSE_NULL;
+	ase_awk_val_t* res = ASE_NULL;
 
-	res = sse_awk_makeintval (run, 
-		sse_awk_valtobool(run left) || sse_awk_valtobool(run,right));
-	if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
+	res = ase_awk_makeintval (run, 
+		ase_awk_valtobool(run left) || ase_awk_valtobool(run,right));
+	if (res == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 
 	return res;
 	*/
 
 	/* short-circuit evaluation required special treatment */
-	sse_awk_val_t* lv, * rv, * res;
+	ase_awk_val_t* lv, * rv, * res;
 
-	sse_awk_assert (run->awk, left->next == SSE_NULL);
+	ase_awk_assert (run->awk, left->next == ASE_NULL);
 	lv = __eval_expression (run, left);
-	if (lv == SSE_NULL) return SSE_NULL;
+	if (lv == ASE_NULL) return ASE_NULL;
 
-	sse_awk_refupval (lv);
-	if (sse_awk_valtobool (run, lv)) 
+	ase_awk_refupval (lv);
+	if (ase_awk_valtobool (run, lv)) 
 	{
-		/*res = sse_awk_makeintval (run, 1);*/
-		res = sse_awk_val_one;
+		/*res = ase_awk_makeintval (run, 1);*/
+		res = ase_awk_val_one;
 	}
 	else
 	{
-		sse_awk_assert (run->awk, right->next == SSE_NULL);
+		ase_awk_assert (run->awk, right->next == ASE_NULL);
 		rv = __eval_expression (run, right);
-		if (rv == SSE_NULL)
+		if (rv == ASE_NULL)
 		{
-			sse_awk_refdownval (run, lv);
-			return SSE_NULL;
+			ase_awk_refdownval (run, lv);
+			return ASE_NULL;
 		}
-		sse_awk_refupval (rv);
+		ase_awk_refupval (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);
+		/*res = ase_awk_makeintval (run, (ase_awk_valtobool(run,rv)? 1: 0));*/
+		res = ase_awk_valtobool(run,rv)? ase_awk_val_one: ase_awk_val_zero;
+		ase_awk_refdownval (run, rv);
 	}
 
-	sse_awk_refdownval (run, lv);
+	ase_awk_refdownval (run, lv);
 
-	/*if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);*/
+	/*if (res == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);*/
 	return res;
 }
 
-static sse_awk_val_t* __eval_binop_land (
-	sse_awk_run_t* run, sse_awk_nde_t* left, sse_awk_nde_t* right)
+static ase_awk_val_t* __eval_binop_land (
+	ase_awk_run_t* run, ase_awk_nde_t* left, ase_awk_nde_t* right)
 {
 	/*
-	sse_awk_val_t* res = SSE_NULL;
+	ase_awk_val_t* res = ASE_NULL;
 
-	res = sse_awk_makeintval (run, 
-		sse_awk_valtobool(run,left) && sse_awk_valtobool(run,right));
-	if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
+	res = ase_awk_makeintval (run, 
+		ase_awk_valtobool(run,left) && ase_awk_valtobool(run,right));
+	if (res == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 
 	return res;
 	*/
 
 	/* short-circuit evaluation required special treatment */
-	sse_awk_val_t* lv, * rv, * res;
+	ase_awk_val_t* lv, * rv, * res;
 
-	sse_awk_assert (run->awk, left->next == SSE_NULL);
+	ase_awk_assert (run->awk, left->next == ASE_NULL);
 	lv = __eval_expression (run, left);
-	if (lv == SSE_NULL) return SSE_NULL;
+	if (lv == ASE_NULL) return ASE_NULL;
 
-	sse_awk_refupval (lv);
-	if (!sse_awk_valtobool (run, lv)) 
+	ase_awk_refupval (lv);
+	if (!ase_awk_valtobool (run, lv)) 
 	{
-		/*res = sse_awk_makeintval (run, 0);*/
-		res = sse_awk_val_zero;
+		/*res = ase_awk_makeintval (run, 0);*/
+		res = ase_awk_val_zero;
 	}
 	else
 	{
-		sse_awk_assert (run->awk, right->next == SSE_NULL);
+		ase_awk_assert (run->awk, right->next == ASE_NULL);
 		rv = __eval_expression (run, right);
-		if (rv == SSE_NULL)
+		if (rv == ASE_NULL)
 		{
-			sse_awk_refdownval (run, lv);
-			return SSE_NULL;
+			ase_awk_refdownval (run, lv);
+			return ASE_NULL;
 		}
-		sse_awk_refupval (rv);
+		ase_awk_refupval (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);
+		/*res = ase_awk_makeintval (run, (ase_awk_valtobool(run,rv)? 1: 0));*/
+		res = ase_awk_valtobool(run,rv)? ase_awk_val_one: ase_awk_val_zero;
+		ase_awk_refdownval (run, rv);
 	}
 
-	sse_awk_refdownval (run, lv);
+	ase_awk_refdownval (run, lv);
 
-	/*if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);*/
+	/*if (res == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);*/
 	return res;
 }
 
-static sse_awk_val_t* __eval_binop_in (
-	sse_awk_run_t* run, sse_awk_nde_t* left, sse_awk_nde_t* right)
+static ase_awk_val_t* __eval_binop_in (
+	ase_awk_run_t* run, ase_awk_nde_t* left, ase_awk_nde_t* right)
 {
-	sse_awk_val_t* rv;
-	sse_char_t* str;
-	sse_size_t len;
+	ase_awk_val_t* rv;
+	ase_char_t* str;
+	ase_size_t len;
 
-	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)
+	if (right->type != ASE_AWK_NDE_GLOBAL &&
+	    right->type != ASE_AWK_NDE_LOCAL &&
+	    right->type != ASE_AWK_NDE_ARG &&
+	    right->type != ASE_AWK_NDE_NAMED)
 	{
 		/* the compiler should have handled this case */
-		sse_awk_assert (run->awk, !"should never happen - in needs a plain variable");
-		PANIC (run, SSE_AWK_EINTERNAL);
-		return SSE_NULL;
+		ase_awk_assert (run->awk, !"should never happen - in needs a plain variable");
+		PANIC (run, ASE_AWK_EINTERNAL);
+		return ASE_NULL;
 	}
 
 	/* evaluate the left-hand side of the operator */
-	str = (left->type == SSE_AWK_NDE_GRP)?
-		__idxnde_to_str (run, ((sse_awk_nde_grp_t*)left)->body, &len):
+	str = (left->type == ASE_AWK_NDE_GRP)?
+		__idxnde_to_str (run, ((ase_awk_nde_grp_t*)left)->body, &len):
 		__idxnde_to_str (run, left, &len);
-	if (str == SSE_NULL) return SSE_NULL;
+	if (str == ASE_NULL) return ASE_NULL;
 
 	/* evaluate the right-hand side of the operator */
-	sse_awk_assert (run->awk, right->next == SSE_NULL);
+	ase_awk_assert (run->awk, right->next == ASE_NULL);
 	rv = __eval_expression (run, right);
-	if (rv == SSE_NULL) 
+	if (rv == ASE_NULL) 
 	{
-		SSE_AWK_FREE (run->awk, str);
-		return SSE_NULL;
+		ASE_AWK_FREE (run->awk, str);
+		return ASE_NULL;
 	}
 
-	sse_awk_refupval (rv);
+	ase_awk_refupval (rv);
 
-	if (rv->type == SSE_AWK_VAL_NIL)
+	if (rv->type == ASE_AWK_VAL_NIL)
 	{
-		SSE_AWK_FREE (run->awk, str);
-		sse_awk_refdownval (run, rv);
-		return sse_awk_val_zero;
+		ASE_AWK_FREE (run->awk, str);
+		ase_awk_refdownval (run, rv);
+		return ase_awk_val_zero;
 	}
-	else if (rv->type == SSE_AWK_VAL_MAP)
+	else if (rv->type == ASE_AWK_VAL_MAP)
 	{
-		sse_awk_val_t* res;
-		sse_awk_map_t* map;
+		ase_awk_val_t* res;
+		ase_awk_map_t* map;
 
-		map = ((sse_awk_val_map_t*)rv)->map;
+		map = ((ase_awk_val_map_t*)rv)->map;
 
-		/*r = (sse_long_t)(sse_awk_map_get (map, str, len) != SSE_NULL);
-		res = sse_awk_makeintval (run, r);
-		if (res == SSE_NULL) 
+		/*r = (ase_long_t)(ase_awk_map_get (map, str, len) != ASE_NULL);
+		res = ase_awk_makeintval (run, r);
+		if (res == ASE_NULL) 
 		{
-			SSE_AWK_FREE (run->awk, str);
-			sse_awk_refdownval (run, rv);
-			PANIC (run, SSE_AWK_ENOMEM);
+			ASE_AWK_FREE (run->awk, str);
+			ase_awk_refdownval (run, rv);
+			PANIC (run, ASE_AWK_ENOMEM);
 		}*/
-		res = (sse_awk_map_get (map, str, len) == SSE_NULL)? 
-			sse_awk_val_zero: sse_awk_val_one;
+		res = (ase_awk_map_get (map, str, len) == ASE_NULL)? 
+			ase_awk_val_zero: ase_awk_val_one;
 
-		SSE_AWK_FREE (run->awk, str);
-		sse_awk_refdownval (run, rv);
+		ASE_AWK_FREE (run->awk, str);
+		ase_awk_refdownval (run, rv);
 		return res;
 	}
 
 	/* need an array */
 	/* TODO: change the error code to make it clearer */
-	PANIC (run, SSE_AWK_EOPERAND); 
-	return SSE_NULL;
+	PANIC (run, ASE_AWK_EOPERAND); 
+	return ASE_NULL;
 }
 
-static sse_awk_val_t* __eval_binop_bor (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+static ase_awk_val_t* __eval_binop_bor (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
-	sse_awk_val_t* res = SSE_NULL;
+	ase_awk_val_t* res = ASE_NULL;
 
-	if (left->type == SSE_AWK_VAL_INT &&
-	    right->type == SSE_AWK_VAL_INT)
+	if (left->type == ASE_AWK_VAL_INT &&
+	    right->type == ASE_AWK_VAL_INT)
 	{
-		sse_long_t r = 
-			((sse_awk_val_int_t*)left)->val | 
-			((sse_awk_val_int_t*)right)->val;
-		res = sse_awk_makeintval (run, r);
+		ase_long_t r = 
+			((ase_awk_val_int_t*)left)->val | 
+			((ase_awk_val_int_t*)right)->val;
+		res = ase_awk_makeintval (run, r);
 	}
 	else
 	{
-		PANIC (run, SSE_AWK_EOPERAND);
+		PANIC (run, ASE_AWK_EOPERAND);
 	}
 
-	if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
+	if (res == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 	return res;
 }
 
-static sse_awk_val_t* __eval_binop_bxor (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+static ase_awk_val_t* __eval_binop_bxor (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
-	sse_awk_val_t* res = SSE_NULL;
+	ase_awk_val_t* res = ASE_NULL;
 
-	if (left->type == SSE_AWK_VAL_INT &&
-	    right->type == SSE_AWK_VAL_INT)
+	if (left->type == ASE_AWK_VAL_INT &&
+	    right->type == ASE_AWK_VAL_INT)
 	{
-		sse_long_t r = 
-			((sse_awk_val_int_t*)left)->val ^ 
-			((sse_awk_val_int_t*)right)->val;
-		res = sse_awk_makeintval (run, r);
+		ase_long_t r = 
+			((ase_awk_val_int_t*)left)->val ^ 
+			((ase_awk_val_int_t*)right)->val;
+		res = ase_awk_makeintval (run, r);
 	}
 	else
 	{
-		PANIC (run, SSE_AWK_EOPERAND);
+		PANIC (run, ASE_AWK_EOPERAND);
 	}
 
-	if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
+	if (res == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 	return res;
 }
 
-static sse_awk_val_t* __eval_binop_band (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+static ase_awk_val_t* __eval_binop_band (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
-	sse_awk_val_t* res = SSE_NULL;
+	ase_awk_val_t* res = ASE_NULL;
 
-	if (left->type == SSE_AWK_VAL_INT &&
-	    right->type == SSE_AWK_VAL_INT)
+	if (left->type == ASE_AWK_VAL_INT &&
+	    right->type == ASE_AWK_VAL_INT)
 	{
-		sse_long_t r = 
-			((sse_awk_val_int_t*)left)->val &
-			((sse_awk_val_int_t*)right)->val;
-		res = sse_awk_makeintval (run, r);
+		ase_long_t r = 
+			((ase_awk_val_int_t*)left)->val &
+			((ase_awk_val_int_t*)right)->val;
+		res = ase_awk_makeintval (run, r);
 	}
 	else
 	{
-		PANIC (run, SSE_AWK_EOPERAND);
+		PANIC (run, ASE_AWK_EOPERAND);
 	}
 
-	if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
+	if (res == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 	return res;
 }
 
 static int __cmp_nil_nil (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
 	return 0;
 }
 
 static int __cmp_nil_int (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
-	if (((sse_awk_val_int_t*)right)->val < 0) return 1;
-	if (((sse_awk_val_int_t*)right)->val > 0) return -1;
+	if (((ase_awk_val_int_t*)right)->val < 0) return 1;
+	if (((ase_awk_val_int_t*)right)->val > 0) return -1;
 	return 0;
 }
 
 static int __cmp_nil_real (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
-	if (((sse_awk_val_real_t*)right)->val < 0) return 1;
-	if (((sse_awk_val_real_t*)right)->val > 0) return -1;
+	if (((ase_awk_val_real_t*)right)->val < 0) return 1;
+	if (((ase_awk_val_real_t*)right)->val > 0) return -1;
 	return 0;
 }
 
 static int __cmp_nil_str (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
-	return (((sse_awk_val_str_t*)right)->len == 0)? 0: -1;
+	return (((ase_awk_val_str_t*)right)->len == 0)? 0: -1;
 }
 
 static int __cmp_int_nil (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
-	if (((sse_awk_val_int_t*)left)->val > 0) return 1;
-	if (((sse_awk_val_int_t*)left)->val < 0) return -1;
+	if (((ase_awk_val_int_t*)left)->val > 0) return 1;
+	if (((ase_awk_val_int_t*)left)->val < 0) return -1;
 	return 0;
 }
 
 static int __cmp_int_int (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
-	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;
+	if (((ase_awk_val_int_t*)left)->val > 
+	    ((ase_awk_val_int_t*)right)->val) return 1;
+	if (((ase_awk_val_int_t*)left)->val < 
+	    ((ase_awk_val_int_t*)right)->val) return -1;
 	return 0;
 }
 
 static int __cmp_int_real (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
-	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;
+	if (((ase_awk_val_int_t*)left)->val > 
+	    ((ase_awk_val_real_t*)right)->val) return 1;
+	if (((ase_awk_val_int_t*)left)->val < 
+	    ((ase_awk_val_real_t*)right)->val) return -1;
 	return 0;
 }
 
 static int __cmp_int_str (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
-	sse_char_t* str;
-	sse_size_t len;
-	sse_long_t r;
-	sse_real_t rr;
+	ase_char_t* str;
+	ase_size_t len;
+	ase_long_t r;
+	ase_real_t rr;
 	int n;
 
-	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)
+	r = ase_awk_strxtolong (run->awk, 
+		((ase_awk_val_str_t*)right)->buf,
+		((ase_awk_val_str_t*)right)->len, 0, (const ase_char_t**)&str);
+	if (str == ((ase_awk_val_str_t*)right)->buf + 
+		   ((ase_awk_val_str_t*)right)->len)
 	{
-		if (((sse_awk_val_int_t*)left)->val > r) return 1;
-		if (((sse_awk_val_int_t*)left)->val < r) return -1;
+		if (((ase_awk_val_int_t*)left)->val > r) return 1;
+		if (((ase_awk_val_int_t*)left)->val < r) return -1;
 		return 0;
 	}
 /* TODO: should i do this???  conversion to real and comparision... */
-	else if (*str == SSE_T('.') || *str == SSE_T('E') || *str == SSE_T('e'))
+	else if (*str == ASE_T('.') || *str == ASE_T('E') || *str == ASE_T('e'))
 	{
-		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)
+		rr = ase_awk_strxtoreal (run->awk,
+			((ase_awk_val_str_t*)right)->buf,
+			((ase_awk_val_str_t*)right)->len, 
+			(const ase_char_t**)&str);
+		if (str == ((ase_awk_val_str_t*)right)->buf + 
+			   ((ase_awk_val_str_t*)right)->len)
 		{
-			if (((sse_awk_val_int_t*)left)->val > rr) return 1;
-			if (((sse_awk_val_int_t*)left)->val < rr) return -1;
+			if (((ase_awk_val_int_t*)left)->val > rr) return 1;
+			if (((ase_awk_val_int_t*)left)->val < rr) return -1;
 			return 0;
 		}
 	}
 
-	str = sse_awk_valtostr (run, left, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
-	if (str == SSE_NULL)
+	str = ase_awk_valtostr (run, left, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &len);
+	if (str == ASE_NULL)
 	{
-		run->errnum = SSE_AWK_ENOMEM;
+		run->errnum = ASE_AWK_ENOMEM;
 		return CMP_ERROR;
 	}
 
 	if (run->global.ignorecase)
 	{
-		n = sse_awk_strxncasecmp (
+		n = ase_awk_strxncasecmp (
 			run->awk, str, len,
-			((sse_awk_val_str_t*)right)->buf, 
-			((sse_awk_val_str_t*)right)->len);
+			((ase_awk_val_str_t*)right)->buf, 
+			((ase_awk_val_str_t*)right)->len);
 	}
 	else
 	{
-		n = sse_awk_strxncmp (
+		n = ase_awk_strxncmp (
 			str, len,
-			((sse_awk_val_str_t*)right)->buf, 
-			((sse_awk_val_str_t*)right)->len);
+			((ase_awk_val_str_t*)right)->buf, 
+			((ase_awk_val_str_t*)right)->len);
 	}
 
-	SSE_AWK_FREE (run->awk, str);
+	ASE_AWK_FREE (run->awk, str);
 	return n;
 }
 
 static int __cmp_real_nil (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
-	if (((sse_awk_val_real_t*)left)->val > 0) return 1;
-	if (((sse_awk_val_real_t*)left)->val < 0) return -1;
+	if (((ase_awk_val_real_t*)left)->val > 0) return 1;
+	if (((ase_awk_val_real_t*)left)->val < 0) return -1;
 	return 0;
 }
 
 static int __cmp_real_int (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
-	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;
+	if (((ase_awk_val_real_t*)left)->val > 
+	    ((ase_awk_val_int_t*)right)->val) return 1;
+	if (((ase_awk_val_real_t*)left)->val < 
+	    ((ase_awk_val_int_t*)right)->val) return -1;
 	return 0;
 }
 
 static int __cmp_real_real (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
-	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;
+	if (((ase_awk_val_real_t*)left)->val > 
+	    ((ase_awk_val_real_t*)right)->val) return 1;
+	if (((ase_awk_val_real_t*)left)->val < 
+	    ((ase_awk_val_real_t*)right)->val) return -1;
 	return 0;
 }
 
 static int __cmp_real_str (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
-	sse_char_t* str;
-	sse_size_t len;
-	sse_real_t rr;
+	ase_char_t* str;
+	ase_size_t len;
+	ase_real_t rr;
 	int n;
 
-	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)
+	rr = ase_awk_strxtoreal (run->awk,
+		((ase_awk_val_str_t*)right)->buf,
+		((ase_awk_val_str_t*)right)->len, 
+		(const ase_char_t**)&str);
+	if (str == ((ase_awk_val_str_t*)right)->buf + 
+		   ((ase_awk_val_str_t*)right)->len)
 	{
-		if (((sse_awk_val_real_t*)left)->val > rr) return 1;
-		if (((sse_awk_val_real_t*)left)->val < rr) return -1;
+		if (((ase_awk_val_real_t*)left)->val > rr) return 1;
+		if (((ase_awk_val_real_t*)left)->val < rr) return -1;
 		return 0;
 	}
 
-	str = sse_awk_valtostr (run, left, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
-	if (str == SSE_NULL)
+	str = ase_awk_valtostr (run, left, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &len);
+	if (str == ASE_NULL)
 	{
-		run->errnum = SSE_AWK_ENOMEM;
+		run->errnum = ASE_AWK_ENOMEM;
 		return CMP_ERROR;
 	}
 
 	if (run->global.ignorecase)
 	{
-		n = sse_awk_strxncasecmp (
+		n = ase_awk_strxncasecmp (
 			run->awk, str, len,
-			((sse_awk_val_str_t*)right)->buf, 
-			((sse_awk_val_str_t*)right)->len);
+			((ase_awk_val_str_t*)right)->buf, 
+			((ase_awk_val_str_t*)right)->len);
 	}
 	else
 	{
-		n = sse_awk_strxncmp (
+		n = ase_awk_strxncmp (
 			str, len,
-			((sse_awk_val_str_t*)right)->buf, 
-			((sse_awk_val_str_t*)right)->len);
+			((ase_awk_val_str_t*)right)->buf, 
+			((ase_awk_val_str_t*)right)->len);
 	}
 
-	SSE_AWK_FREE (run->awk, str);
+	ASE_AWK_FREE (run->awk, str);
 	return n;
 }
 
 static int __cmp_str_nil (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
-	return (((sse_awk_val_str_t*)left)->len == 0)? 0: 1;
+	return (((ase_awk_val_str_t*)left)->len == 0)? 0: 1;
 }
 
 static int __cmp_str_int (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
 	return -__cmp_int_str (run, right, left);
 }
 
 static int __cmp_str_real (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
 	return -__cmp_real_str (run, right, left);
 }
 
 static int __cmp_str_str (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
 	int n;
-	sse_awk_val_str_t* ls, * rs;
+	ase_awk_val_str_t* ls, * rs;
 
-	ls = (sse_awk_val_str_t*)left;
-	rs = (sse_awk_val_str_t*)right;
+	ls = (ase_awk_val_str_t*)left;
+	rs = (ase_awk_val_str_t*)right;
 
 	if (run->global.ignorecase)
 	{
-		n = sse_awk_strxncasecmp (run->awk, 
+		n = ase_awk_strxncasecmp (run->awk, 
 			ls->buf, ls->len, rs->buf, rs->len);
 	}
 	else
 	{
-		n = sse_awk_strxncmp (
+		n = ase_awk_strxncmp (
 			ls->buf, ls->len, rs->buf, rs->len);
 	}
 
@@ -3233,147 +3233,147 @@ static int __cmp_str_str (
 }
 
 static int __cmp_val (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
-	typedef int (*cmp_val_t) (sse_awk_run_t*, sse_awk_val_t*, sse_awk_val_t*);
+	typedef int (*cmp_val_t) (ase_awk_run_t*, ase_awk_val_t*, ase_awk_val_t*);
 
 	static cmp_val_t func[] =
 	{
 		/* this table must be synchronized with 
-		 * the SSE_AWK_VAL_XXX values in val.h */
+		 * the ASE_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 == SSE_AWK_VAL_MAP || right->type == SSE_AWK_VAL_MAP)
+	if (left->type == ASE_AWK_VAL_MAP || right->type == ASE_AWK_VAL_MAP)
 	{
 		/* a map can't be compared againt other values */
-		run->errnum = SSE_AWK_EOPERAND;
+		run->errnum = ASE_AWK_EOPERAND;
 		return CMP_ERROR; 
 	}
 
-	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);
+	ase_awk_assert (run->awk, 
+		left->type >= ASE_AWK_VAL_NIL &&
+		left->type <= ASE_AWK_VAL_STR);
+	ase_awk_assert (run->awk, 
+		right->type >= ASE_AWK_VAL_NIL &&
+		right->type <= ASE_AWK_VAL_STR);
 
 	return func[left->type*4+right->type] (run, left, 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 ase_awk_val_t* __eval_binop_eq (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
 	int n = __cmp_val (run, left, right);
-	if (n == CMP_ERROR) return SSE_NULL;
-	return (n == 0)? sse_awk_val_one: sse_awk_val_zero;
+	if (n == CMP_ERROR) return ASE_NULL;
+	return (n == 0)? ase_awk_val_one: ase_awk_val_zero;
 }
 
-static sse_awk_val_t* __eval_binop_ne (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+static ase_awk_val_t* __eval_binop_ne (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
 	int n = __cmp_val (run, left, right);
-	if (n == CMP_ERROR) return SSE_NULL;
-	return (n != 0)? sse_awk_val_one: sse_awk_val_zero;
+	if (n == CMP_ERROR) return ASE_NULL;
+	return (n != 0)? ase_awk_val_one: ase_awk_val_zero;
 }
 
-static sse_awk_val_t* __eval_binop_gt (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+static ase_awk_val_t* __eval_binop_gt (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
 	int n = __cmp_val (run, left, right);
-	if (n == CMP_ERROR) return SSE_NULL;
-	return (n > 0)? sse_awk_val_one: sse_awk_val_zero;
+	if (n == CMP_ERROR) return ASE_NULL;
+	return (n > 0)? ase_awk_val_one: ase_awk_val_zero;
 }
 
-static sse_awk_val_t* __eval_binop_ge (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+static ase_awk_val_t* __eval_binop_ge (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
 	int n = __cmp_val (run, left, right);
-	if (n == CMP_ERROR) return SSE_NULL;
-	return (n >= 0)? sse_awk_val_one: sse_awk_val_zero;
+	if (n == CMP_ERROR) return ASE_NULL;
+	return (n >= 0)? ase_awk_val_one: ase_awk_val_zero;
 }
 
-static sse_awk_val_t* __eval_binop_lt (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+static ase_awk_val_t* __eval_binop_lt (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
 	int n = __cmp_val (run, left, right);
-	if (n == CMP_ERROR) return SSE_NULL;
-	return (n < 0)? sse_awk_val_one: sse_awk_val_zero;
+	if (n == CMP_ERROR) return ASE_NULL;
+	return (n < 0)? ase_awk_val_one: ase_awk_val_zero;
 }
 
-static sse_awk_val_t* __eval_binop_le (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+static ase_awk_val_t* __eval_binop_le (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
 	int n = __cmp_val (run, left, right);
-	if (n == CMP_ERROR) return SSE_NULL;
-	return (n <= 0)? sse_awk_val_one: sse_awk_val_zero;
+	if (n == CMP_ERROR) return ASE_NULL;
+	return (n <= 0)? ase_awk_val_one: ase_awk_val_zero;
 }
 
-static sse_awk_val_t* __eval_binop_lshift (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+static ase_awk_val_t* __eval_binop_lshift (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
 	int n1, n2, n3;
-	sse_long_t l1, l2;
-	sse_real_t r1, r2;
-	sse_awk_val_t* res;
+	ase_long_t l1, l2;
+	ase_real_t r1, r2;
+	ase_awk_val_t* res;
 
-	n1 = sse_awk_valtonum (run, left, &l1, &r1);
-	n2 = sse_awk_valtonum (run, right, &l2, &r2);
+	n1 = ase_awk_valtonum (run, left, &l1, &r1);
+	n2 = ase_awk_valtonum (run, right, &l2, &r2);
 
-	if (n1 == -1 || n2 == -1) PANIC (run, SSE_AWK_EOPERAND); 
+	if (n1 == -1 || n2 == -1) PANIC (run, ASE_AWK_EOPERAND); 
 
 	n3 = n1 + (n2 << 1);
 	if (n3 == 0)
 	{
-		if  (l2 == 0) PANIC (run, SSE_AWK_EDIVBYZERO);
-		res = sse_awk_makeintval (run, (sse_long_t)l1 << (sse_long_t)l2);
+		if  (l2 == 0) PANIC (run, ASE_AWK_EDIVBYZERO);
+		res = ase_awk_makeintval (run, (ase_long_t)l1 << (ase_long_t)l2);
 	}
-	else PANIC (run, SSE_AWK_EOPERAND);
+	else PANIC (run, ASE_AWK_EOPERAND);
 
-	if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
+	if (res == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 	return res;
 }
 
-static sse_awk_val_t* __eval_binop_rshift (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+static ase_awk_val_t* __eval_binop_rshift (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
 	int n1, n2, n3;
-	sse_long_t l1, l2;
-	sse_real_t r1, r2;
-	sse_awk_val_t* res;
+	ase_long_t l1, l2;
+	ase_real_t r1, r2;
+	ase_awk_val_t* res;
 
-	n1 = sse_awk_valtonum (run, left, &l1, &r1);
-	n2 = sse_awk_valtonum (run, right, &l2, &r2);
+	n1 = ase_awk_valtonum (run, left, &l1, &r1);
+	n2 = ase_awk_valtonum (run, right, &l2, &r2);
 
-	if (n1 == -1 || n2 == -1) PANIC (run, SSE_AWK_EOPERAND); 
+	if (n1 == -1 || n2 == -1) PANIC (run, ASE_AWK_EOPERAND); 
 
 	n3 = n1 + (n2 << 1);
 	if (n3 == 0)
 	{
-		if  (l2 == 0) PANIC (run, SSE_AWK_EDIVBYZERO);
-		res = sse_awk_makeintval (run, (sse_long_t)l1 >> (sse_long_t)l2);
+		if  (l2 == 0) PANIC (run, ASE_AWK_EDIVBYZERO);
+		res = ase_awk_makeintval (run, (ase_long_t)l1 >> (ase_long_t)l2);
 	}
-	else PANIC (run, SSE_AWK_EOPERAND);
+	else PANIC (run, ASE_AWK_EOPERAND);
 
-	if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
+	if (res == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 	return res;
 }
 
-static sse_awk_val_t* __eval_binop_plus (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+static ase_awk_val_t* __eval_binop_plus (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
 	int n1, n2, n3;
-	sse_long_t l1, l2;
-	sse_real_t r1, r2;
-	sse_awk_val_t* res;
+	ase_long_t l1, l2;
+	ase_real_t r1, r2;
+	ase_awk_val_t* res;
 
-	n1 = sse_awk_valtonum (run, left, &l1, &r1);
-	n2 = sse_awk_valtonum (run, right, &l2, &r2);
+	n1 = ase_awk_valtonum (run, left, &l1, &r1);
+	n2 = ase_awk_valtonum (run, right, &l2, &r2);
 
-	if (n1 == -1 || n2 == -1) PANIC (run, SSE_AWK_EOPERAND); 
+	if (n1 == -1 || n2 == -1) PANIC (run, ASE_AWK_EOPERAND); 
 	/*
 	n1  n2    n3
 	0   0   = 0
@@ -3382,889 +3382,889 @@ static sse_awk_val_t* __eval_binop_plus (
 	1   1   = 3
 	*/
 	n3 = n1 + (n2 << 1);
-	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);
+	ase_awk_assert (run->awk, n3 >= 0 && n3 <= 3);
+	res = (n3 == 0)? ase_awk_makeintval(run,(ase_long_t)l1+(ase_long_t)l2):
+	      (n3 == 1)? ase_awk_makerealval(run,(ase_real_t)r1+(ase_real_t)l2):
+	      (n3 == 2)? ase_awk_makerealval(run,(ase_real_t)l1+(ase_real_t)r2):
+	                 ase_awk_makerealval(run,(ase_real_t)r1+(ase_real_t)r2);
 
-	if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
+	if (res == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 	return res;
 }
 
-static sse_awk_val_t* __eval_binop_minus (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+static ase_awk_val_t* __eval_binop_minus (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
 	int n1, n2, n3;
-	sse_long_t l1, l2;
-	sse_real_t r1, r2;
-	sse_awk_val_t* res;
+	ase_long_t l1, l2;
+	ase_real_t r1, r2;
+	ase_awk_val_t* res;
 
-	n1 = sse_awk_valtonum (run, left, &l1, &r1);
-	n2 = sse_awk_valtonum (run, right, &l2, &r2);
+	n1 = ase_awk_valtonum (run, left, &l1, &r1);
+	n2 = ase_awk_valtonum (run, right, &l2, &r2);
 
-	if (n1 == -1 || n2 == -1) PANIC (run, SSE_AWK_EOPERAND);
+	if (n1 == -1 || n2 == -1) PANIC (run, ASE_AWK_EOPERAND);
 
 	n3 = n1 + (n2 << 1);
-	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);
+	ase_awk_assert (run->awk, n3 >= 0 && n3 <= 3);
+	res = (n3 == 0)? ase_awk_makeintval(run,(ase_long_t)l1-(ase_long_t)l2):
+	      (n3 == 1)? ase_awk_makerealval(run,(ase_real_t)r1-(ase_real_t)l2):
+	      (n3 == 2)? ase_awk_makerealval(run,(ase_real_t)l1-(ase_real_t)r2):
+	                 ase_awk_makerealval(run,(ase_real_t)r1-(ase_real_t)r2);
 
-	if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
+	if (res == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 	return res;
 }
 
-static sse_awk_val_t* __eval_binop_mul (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+static ase_awk_val_t* __eval_binop_mul (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
 	int n1, n2, n3;
-	sse_long_t l1, l2;
-	sse_real_t r1, r2;
-	sse_awk_val_t* res;
+	ase_long_t l1, l2;
+	ase_real_t r1, r2;
+	ase_awk_val_t* res;
 
-	n1 = sse_awk_valtonum (run, left, &l1, &r1);
-	n2 = sse_awk_valtonum (run, right, &l2, &r2);
+	n1 = ase_awk_valtonum (run, left, &l1, &r1);
+	n2 = ase_awk_valtonum (run, right, &l2, &r2);
 
-	if (n1 == -1 || n2 == -1) PANIC (run, SSE_AWK_EOPERAND);
+	if (n1 == -1 || n2 == -1) PANIC (run, ASE_AWK_EOPERAND);
 
 	n3 = n1 + (n2 << 1);
-	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);
+	ase_awk_assert (run->awk, n3 >= 0 && n3 <= 3);
+	res = (n3 == 0)? ase_awk_makeintval(run,(ase_long_t)l1*(ase_long_t)l2):
+	      (n3 == 1)? ase_awk_makerealval(run,(ase_real_t)r1*(ase_real_t)l2):
+	      (n3 == 2)? ase_awk_makerealval(run,(ase_real_t)l1*(ase_real_t)r2):
+	                 ase_awk_makerealval(run,(ase_real_t)r1*(ase_real_t)r2);
 
-	if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
+	if (res == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 	return res;
 }
 
-static sse_awk_val_t* __eval_binop_div (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+static ase_awk_val_t* __eval_binop_div (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
 	int n1, n2, n3;
-	sse_long_t l1, l2;
-	sse_real_t r1, r2;
-	sse_awk_val_t* res;
+	ase_long_t l1, l2;
+	ase_real_t r1, r2;
+	ase_awk_val_t* res;
 
-	n1 = sse_awk_valtonum (run, left, &l1, &r1);
-	n2 = sse_awk_valtonum (run, right, &l2, &r2);
+	n1 = ase_awk_valtonum (run, left, &l1, &r1);
+	n2 = ase_awk_valtonum (run, right, &l2, &r2);
 
-	if (n1 == -1 || n2 == -1) PANIC (run, SSE_AWK_EOPERAND);
+	if (n1 == -1 || n2 == -1) PANIC (run, ASE_AWK_EOPERAND);
 
 	n3 = n1 + (n2 << 1);
 	if (n3 == 0)
 	{
-		if  (l2 == 0) PANIC (run, SSE_AWK_EDIVBYZERO);
-		res = sse_awk_makeintval (run, (sse_long_t)l1 / (sse_long_t)l2);
+		if  (l2 == 0) PANIC (run, ASE_AWK_EDIVBYZERO);
+		res = ase_awk_makeintval (run, (ase_long_t)l1 / (ase_long_t)l2);
 	}
 	else if (n3 == 1)
 	{
-		res = sse_awk_makerealval (run, (sse_real_t)r1 / (sse_real_t)l2);
+		res = ase_awk_makerealval (run, (ase_real_t)r1 / (ase_real_t)l2);
 	}
 	else if (n3 == 2)
 	{
-		res = sse_awk_makerealval (run, (sse_real_t)l1 / (sse_real_t)r2);
+		res = ase_awk_makerealval (run, (ase_real_t)l1 / (ase_real_t)r2);
 	}
 	else
 	{
-		sse_awk_assert (run->awk, n3 == 3);
-		res = sse_awk_makerealval (run, (sse_real_t)r1 / (sse_real_t)r2);
+		ase_awk_assert (run->awk, n3 == 3);
+		res = ase_awk_makerealval (run, (ase_real_t)r1 / (ase_real_t)r2);
 	}
 
-	if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
+	if (res == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 	return res;
 }
 
-static sse_awk_val_t* __eval_binop_mod (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+static ase_awk_val_t* __eval_binop_mod (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
 	int n1, n2, n3;
-	sse_long_t l1, l2;
-	sse_real_t r1, r2;
-	sse_awk_val_t* res;
+	ase_long_t l1, l2;
+	ase_real_t r1, r2;
+	ase_awk_val_t* res;
 
-	n1 = sse_awk_valtonum (run, left, &l1, &r1);
-	n2 = sse_awk_valtonum (run, right, &l2, &r2);
+	n1 = ase_awk_valtonum (run, left, &l1, &r1);
+	n2 = ase_awk_valtonum (run, right, &l2, &r2);
 
-	if (n1 == -1 || n2 == -1) PANIC (run, SSE_AWK_EOPERAND);
+	if (n1 == -1 || n2 == -1) PANIC (run, ASE_AWK_EOPERAND);
 
 	n3 = n1 + (n2 << 1);
 	if (n3 == 0)
 	{
-		if  (l2 == 0) PANIC (run, SSE_AWK_EDIVBYZERO);
-		res = sse_awk_makeintval (run, (sse_long_t)l1 % (sse_long_t)l2);
+		if  (l2 == 0) PANIC (run, ASE_AWK_EDIVBYZERO);
+		res = ase_awk_makeintval (run, (ase_long_t)l1 % (ase_long_t)l2);
 	}
-	else PANIC (run, SSE_AWK_EOPERAND);
+	else PANIC (run, ASE_AWK_EOPERAND);
 
-	if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
+	if (res == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 	return res;
 }
 
-static sse_awk_val_t* __eval_binop_exp (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+static ase_awk_val_t* __eval_binop_exp (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
 	int n1, n2, n3;
-	sse_long_t l1, l2;
-	sse_real_t r1, r2;
-	sse_awk_val_t* res;
+	ase_long_t l1, l2;
+	ase_real_t r1, r2;
+	ase_awk_val_t* res;
 
-	n1 = sse_awk_valtonum (run, left, &l1, &r1);
-	n2 = sse_awk_valtonum (run, right, &l2, &r2);
+	n1 = ase_awk_valtonum (run, left, &l1, &r1);
+	n2 = ase_awk_valtonum (run, right, &l2, &r2);
 
-	if (n1 == -1 || n2 == -1) PANIC (run, SSE_AWK_EOPERAND);
+	if (n1 == -1 || n2 == -1) PANIC (run, ASE_AWK_EOPERAND);
 
 	n3 = n1 + (n2 << 1);
 	if (n3 == 0)
 	{
-		sse_long_t v = 1;
+		ase_long_t v = 1;
 		while (l2-- > 0) v *= l1;
-		res = sse_awk_makeintval (run, v);
+		res = ase_awk_makeintval (run, v);
 	}
 	else if (n3 == 1)
 	{
-		/*res = sse_awk_makerealval (
-			run, pow((sse_real_t)r1,(sse_real_t)l2));*/
-		sse_real_t v = 1.0;
+		/*res = ase_awk_makerealval (
+			run, pow((ase_real_t)r1,(ase_real_t)l2));*/
+		ase_real_t v = 1.0;
 		while (l2-- > 0) v *= r1;
-		res = sse_awk_makerealval (run, v);
+		res = ase_awk_makerealval (run, v);
 	}
 	else if (n3 == 2)
 	{
-		res = sse_awk_makerealval (
-			run, pow((sse_real_t)l1,(sse_real_t)r2));
+		res = ase_awk_makerealval (
+			run, pow((ase_real_t)l1,(ase_real_t)r2));
 	}
 	else
 	{
-		sse_awk_assert (run->awk, n3 == 3);
-		res = sse_awk_makerealval (
-			run, pow((sse_real_t)r1,(sse_real_t)r2));
+		ase_awk_assert (run->awk, n3 == 3);
+		res = ase_awk_makerealval (
+			run, pow((ase_real_t)r1,(ase_real_t)r2));
 	}
 
-	if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
+	if (res == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 	return res;
 }
 
-static sse_awk_val_t* __eval_binop_concat (
-	sse_awk_run_t* run, sse_awk_val_t* left, sse_awk_val_t* right)
+static ase_awk_val_t* __eval_binop_concat (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right)
 {
-	sse_char_t* strl, * strr;
-	sse_size_t strl_len, strr_len;
-	sse_awk_val_t* res;
+	ase_char_t* strl, * strr;
+	ase_size_t strl_len, strr_len;
+	ase_awk_val_t* res;
 
-	strl = sse_awk_valtostr (
-		run, left, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &strl_len);
-	if (strl == SSE_NULL) return SSE_NULL;
+	strl = ase_awk_valtostr (
+		run, left, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &strl_len);
+	if (strl == ASE_NULL) return ASE_NULL;
 
-	strr = sse_awk_valtostr (
-		run, right, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &strr_len);
-	if (strr == SSE_NULL) 
+	strr = ase_awk_valtostr (
+		run, right, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &strr_len);
+	if (strr == ASE_NULL) 
 	{
-		SSE_AWK_FREE (run->awk, strl);
-		return SSE_NULL;
+		ASE_AWK_FREE (run->awk, strl);
+		return ASE_NULL;
 	}
 
-	res = sse_awk_makestrval2 (run, strl, strl_len, strr, strr_len);
-	if (res == SSE_NULL)
+	res = ase_awk_makestrval2 (run, strl, strl_len, strr, strr_len);
+	if (res == ASE_NULL)
 	{
-		SSE_AWK_FREE (run->awk, strl);
-		SSE_AWK_FREE (run->awk, strr);
-		PANIC (run, SSE_AWK_ENOMEM);
+		ASE_AWK_FREE (run->awk, strl);
+		ASE_AWK_FREE (run->awk, strr);
+		PANIC (run, ASE_AWK_ENOMEM);
 	}
 
-	SSE_AWK_FREE (run->awk, strl);
-	SSE_AWK_FREE (run->awk, strr);
+	ASE_AWK_FREE (run->awk, strl);
+	ASE_AWK_FREE (run->awk, strr);
 
 	return res;
 }
 
-static sse_awk_val_t* __eval_binop_ma (
-	sse_awk_run_t* run, sse_awk_nde_t* left, sse_awk_nde_t* right)
+static ase_awk_val_t* __eval_binop_ma (
+	ase_awk_run_t* run, ase_awk_nde_t* left, ase_awk_nde_t* right)
 {
-	sse_awk_val_t* lv, * rv, * res;
+	ase_awk_val_t* lv, * rv, * res;
 
-	sse_awk_assert (run->awk, left->next == SSE_NULL);
-	sse_awk_assert (run->awk, right->next == SSE_NULL);
+	ase_awk_assert (run->awk, left->next == ASE_NULL);
+	ase_awk_assert (run->awk, right->next == ASE_NULL);
 
 	lv = __eval_expression (run, left);
-	if (lv == SSE_NULL) 
+	if (lv == ASE_NULL) 
 	{
-		return SSE_NULL;
+		return ASE_NULL;
 	}
 
-	sse_awk_refupval (lv);
+	ase_awk_refupval (lv);
 
 	rv = __eval_expression0 (run, right);
-	if (rv == SSE_NULL)
+	if (rv == ASE_NULL)
 	{
-		sse_awk_refdownval (run, lv);
-		return SSE_NULL;
+		ase_awk_refdownval (run, lv);
+		return ASE_NULL;
 	}
 
-	sse_awk_refupval (rv);
+	ase_awk_refupval (rv);
 
 	res = __eval_binop_match0 (run, lv, rv, 1);
 
-	sse_awk_refdownval (run, lv);
-	sse_awk_refdownval (run, rv);
+	ase_awk_refdownval (run, lv);
+	ase_awk_refdownval (run, rv);
 
 	return res;
 }
 
-static sse_awk_val_t* __eval_binop_nm (
-	sse_awk_run_t* run, sse_awk_nde_t* left, sse_awk_nde_t* right)
+static ase_awk_val_t* __eval_binop_nm (
+	ase_awk_run_t* run, ase_awk_nde_t* left, ase_awk_nde_t* right)
 {
-	sse_awk_val_t* lv, * rv, * res;
+	ase_awk_val_t* lv, * rv, * res;
 
-	sse_awk_assert (run->awk, left->next == SSE_NULL);
-	sse_awk_assert (run->awk, right->next == SSE_NULL);
+	ase_awk_assert (run->awk, left->next == ASE_NULL);
+	ase_awk_assert (run->awk, right->next == ASE_NULL);
 
 	lv = __eval_expression (run, left);
-	if (lv == SSE_NULL) return SSE_NULL;
+	if (lv == ASE_NULL) return ASE_NULL;
 
-	sse_awk_refupval (lv);
+	ase_awk_refupval (lv);
 
 	rv = __eval_expression0 (run, right);
-	if (rv == SSE_NULL)
+	if (rv == ASE_NULL)
 	{
-		sse_awk_refdownval (run, lv);
-		return SSE_NULL;
+		ase_awk_refdownval (run, lv);
+		return ASE_NULL;
 	}
 
-	sse_awk_refupval (rv);
+	ase_awk_refupval (rv);
 
 	res = __eval_binop_match0 (run, lv, rv, 0);
 
-	sse_awk_refdownval (run, lv);
-	sse_awk_refdownval (run, rv);
+	ase_awk_refdownval (run, lv);
+	ase_awk_refdownval (run, rv);
 
 	return res;
 }
 
-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 ase_awk_val_t* __eval_binop_match0 (
+	ase_awk_run_t* run, ase_awk_val_t* left, ase_awk_val_t* right, int ret)
 {
-	sse_awk_val_t* res;
+	ase_awk_val_t* res;
 	int n, errnum;
-	sse_char_t* str;
-	sse_size_t len;
+	ase_char_t* str;
+	ase_size_t len;
 	void* rex_code;
 
-	if (right->type == SSE_AWK_VAL_REX)
+	if (right->type == ASE_AWK_VAL_REX)
 	{
-		rex_code = ((sse_awk_val_rex_t*)right)->code;
+		rex_code = ((ase_awk_val_rex_t*)right)->code;
 	}
-	else if (right->type == SSE_AWK_VAL_STR)
+	else if (right->type == ASE_AWK_VAL_STR)
 	{
-		rex_code = sse_awk_buildrex ( 
+		rex_code = ase_awk_buildrex ( 
 			run->awk,
-			((sse_awk_val_str_t*)right)->buf,
-			((sse_awk_val_str_t*)right)->len, &errnum);
-		if (rex_code == SSE_NULL)
+			((ase_awk_val_str_t*)right)->buf,
+			((ase_awk_val_str_t*)right)->len, &errnum);
+		if (rex_code == ASE_NULL)
 			PANIC (run, errnum);
 	}
 	else
 	{
-		str = sse_awk_valtostr (
-			run, right, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
-		if (str == SSE_NULL) return SSE_NULL;
+		str = ase_awk_valtostr (
+			run, right, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &len);
+		if (str == ASE_NULL) return ASE_NULL;
 
-		rex_code = sse_awk_buildrex (run->awk, str, len, &errnum);
-		if (rex_code == SSE_NULL)
+		rex_code = ase_awk_buildrex (run->awk, str, len, &errnum);
+		if (rex_code == ASE_NULL)
 		{
-			SSE_AWK_FREE (run->awk, str);
+			ASE_AWK_FREE (run->awk, str);
 			PANIC (run, errnum);
 		}
 
-		SSE_AWK_FREE (run->awk, str);
+		ASE_AWK_FREE (run->awk, str);
 	}
 
-	if (left->type == SSE_AWK_VAL_STR)
+	if (left->type == ASE_AWK_VAL_STR)
 	{
-		n = sse_awk_matchrex (
+		n = ase_awk_matchrex (
 			run->awk, rex_code,
-			((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);
+			((run->global.ignorecase)? ASE_AWK_REX_IGNORECASE: 0),
+			((ase_awk_val_str_t*)left)->buf,
+			((ase_awk_val_str_t*)left)->len,
+			ASE_NULL, ASE_NULL, &errnum);
 		if (n == -1) 
 		{
-			if (right->type != SSE_AWK_VAL_REX) 
-				SSE_AWK_FREE (run->awk, rex_code);
+			if (right->type != ASE_AWK_VAL_REX) 
+				ASE_AWK_FREE (run->awk, rex_code);
 			PANIC (run, errnum);
 		}
 
-		res = sse_awk_makeintval (run, (n == ret));
-		if (res == SSE_NULL) 
+		res = ase_awk_makeintval (run, (n == ret));
+		if (res == ASE_NULL) 
 		{
-			if (right->type != SSE_AWK_VAL_REX) 
-				SSE_AWK_FREE (run->awk, rex_code);
-			PANIC (run, SSE_AWK_ENOMEM);
+			if (right->type != ASE_AWK_VAL_REX) 
+				ASE_AWK_FREE (run->awk, rex_code);
+			PANIC (run, ASE_AWK_ENOMEM);
 		}
 	}
 	else
 	{
-		str = sse_awk_valtostr (
-			run, left, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
-		if (str == SSE_NULL) 
+		str = ase_awk_valtostr (
+			run, left, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &len);
+		if (str == ASE_NULL) 
 		{
-			if (right->type != SSE_AWK_VAL_REX) 
-				SSE_AWK_FREE (run->awk, rex_code);
-			return SSE_NULL;
+			if (right->type != ASE_AWK_VAL_REX) 
+				ASE_AWK_FREE (run->awk, rex_code);
+			return ASE_NULL;
 		}
 
-		n = sse_awk_matchrex (
+		n = ase_awk_matchrex (
 			run->awk, rex_code, 
-			((run->global.ignorecase)? SSE_AWK_REX_IGNORECASE: 0),
-			str, len, SSE_NULL, SSE_NULL, &errnum);
+			((run->global.ignorecase)? ASE_AWK_REX_IGNORECASE: 0),
+			str, len, ASE_NULL, ASE_NULL, &errnum);
 		if (n == -1) 
 		{
-			SSE_AWK_FREE (run->awk, str);
-			if (right->type != SSE_AWK_VAL_REX) 
-				SSE_AWK_FREE (run->awk, rex_code);
+			ASE_AWK_FREE (run->awk, str);
+			if (right->type != ASE_AWK_VAL_REX) 
+				ASE_AWK_FREE (run->awk, rex_code);
 			PANIC (run, errnum);
 		}
 
-		res = sse_awk_makeintval (run, (n == ret));
-		if (res == SSE_NULL) 
+		res = ase_awk_makeintval (run, (n == ret));
+		if (res == ASE_NULL) 
 		{
-			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);
+			ASE_AWK_FREE (run->awk, str);
+			if (right->type != ASE_AWK_VAL_REX) 
+				ASE_AWK_FREE (run->awk, rex_code);
+			PANIC (run, ASE_AWK_ENOMEM);
 		}
 
-		SSE_AWK_FREE (run->awk, str);
+		ASE_AWK_FREE (run->awk, str);
 	}
 
-	if (right->type != SSE_AWK_VAL_REX) SSE_AWK_FREE (run->awk, rex_code);
+	if (right->type != ASE_AWK_VAL_REX) ASE_AWK_FREE (run->awk, rex_code);
 	return res;
 }
 
-static sse_awk_val_t* __eval_unary (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_unary (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	sse_awk_val_t* left, * res = SSE_NULL;
-	sse_awk_nde_exp_t* exp = (sse_awk_nde_exp_t*)nde;
+	ase_awk_val_t* left, * res = ASE_NULL;
+	ase_awk_nde_exp_t* exp = (ase_awk_nde_exp_t*)nde;
 
-	sse_awk_assert (run->awk, exp->type == SSE_AWK_NDE_EXP_UNR);
-	sse_awk_assert (run->awk, exp->left != SSE_NULL && exp->right == SSE_NULL);
+	ase_awk_assert (run->awk, exp->type == ASE_AWK_NDE_EXP_UNR);
+	ase_awk_assert (run->awk, exp->left != ASE_NULL && exp->right == ASE_NULL);
 
-	sse_awk_assert (run->awk, exp->left->next == SSE_NULL);
+	ase_awk_assert (run->awk, exp->left->next == ASE_NULL);
 	left = __eval_expression (run, exp->left);
-	if (left == SSE_NULL) return SSE_NULL;
+	if (left == ASE_NULL) return ASE_NULL;
 
-	sse_awk_refupval (left);
+	ase_awk_refupval (left);
 
-	if (exp->opcode == SSE_AWK_UNROP_PLUS) 
+	if (exp->opcode == ASE_AWK_UNROP_PLUS) 
 	{
-		if (left->type == SSE_AWK_VAL_INT)
+		if (left->type == ASE_AWK_VAL_INT)
 		{
-			sse_long_t r = ((sse_awk_val_int_t*)left)->val;
-			res = sse_awk_makeintval (run, r);
+			ase_long_t r = ((ase_awk_val_int_t*)left)->val;
+			res = ase_awk_makeintval (run, r);
 		}
-		else if (left->type == SSE_AWK_VAL_REAL)
+		else if (left->type == ASE_AWK_VAL_REAL)
 		{
-			sse_real_t r = ((sse_awk_val_real_t*)left)->val;
-			res = sse_awk_makerealval (run, r);
+			ase_real_t r = ((ase_awk_val_real_t*)left)->val;
+			res = ase_awk_makerealval (run, r);
 		}
 		else
 		{
-			sse_awk_refdownval (run, left);
-			PANIC (run, SSE_AWK_EOPERAND);
+			ase_awk_refdownval (run, left);
+			PANIC (run, ASE_AWK_EOPERAND);
 		}
 	}
-	else if (exp->opcode == SSE_AWK_UNROP_MINUS)
+	else if (exp->opcode == ASE_AWK_UNROP_MINUS)
 	{
-		if (left->type == SSE_AWK_VAL_INT)
+		if (left->type == ASE_AWK_VAL_INT)
 		{
-			sse_long_t r = ((sse_awk_val_int_t*)left)->val;
-			res = sse_awk_makeintval (run, -r);
+			ase_long_t r = ((ase_awk_val_int_t*)left)->val;
+			res = ase_awk_makeintval (run, -r);
 		}
-		else if (left->type == SSE_AWK_VAL_REAL)
+		else if (left->type == ASE_AWK_VAL_REAL)
 		{
-			sse_real_t r = ((sse_awk_val_real_t*)left)->val;
-			res = sse_awk_makerealval (run, -r);
+			ase_real_t r = ((ase_awk_val_real_t*)left)->val;
+			res = ase_awk_makerealval (run, -r);
 		}
 		else
 		{
-			sse_awk_refdownval (run, left);
-			PANIC (run, SSE_AWK_EOPERAND);
+			ase_awk_refdownval (run, left);
+			PANIC (run, ASE_AWK_EOPERAND);
 		}
 	}
-	else if (exp->opcode == SSE_AWK_UNROP_NOT)
+	else if (exp->opcode == ASE_AWK_UNROP_NOT)
 	{
-		if (left->type == SSE_AWK_VAL_INT)
+		if (left->type == ASE_AWK_VAL_INT)
 		{
-			sse_long_t r = ((sse_awk_val_int_t*)left)->val;
-			res = sse_awk_makeintval (run, !r);
+			ase_long_t r = ((ase_awk_val_int_t*)left)->val;
+			res = ase_awk_makeintval (run, !r);
 		}
-		else if (left->type == SSE_AWK_VAL_REAL)
+		else if (left->type == ASE_AWK_VAL_REAL)
 		{
-			sse_real_t r = ((sse_awk_val_real_t*)left)->val;
-			res = sse_awk_makerealval (run, !r);
+			ase_real_t r = ((ase_awk_val_real_t*)left)->val;
+			res = ase_awk_makerealval (run, !r);
 		}
 		else
 		{
-			sse_awk_refdownval (run, left);
-			PANIC (run, SSE_AWK_EOPERAND);
+			ase_awk_refdownval (run, left);
+			PANIC (run, ASE_AWK_EOPERAND);
 		}
 	}
-	else if (exp->opcode == SSE_AWK_UNROP_BNOT)
+	else if (exp->opcode == ASE_AWK_UNROP_BNOT)
 	{
-		if (left->type == SSE_AWK_VAL_INT)
+		if (left->type == ASE_AWK_VAL_INT)
 		{
-			sse_long_t r = ((sse_awk_val_int_t*)left)->val;
-			res = sse_awk_makeintval (run, ~r);
+			ase_long_t r = ((ase_awk_val_int_t*)left)->val;
+			res = ase_awk_makeintval (run, ~r);
 		}
 		else
 		{
-			sse_awk_refdownval (run, left);
-			PANIC (run, SSE_AWK_EOPERAND);
+			ase_awk_refdownval (run, left);
+			PANIC (run, ASE_AWK_EOPERAND);
 		}
 	}
 
-	if (res == SSE_NULL)
+	if (res == ASE_NULL)
 	{
-		sse_awk_refdownval (run, left);
-		PANIC (run, SSE_AWK_ENOMEM);
+		ase_awk_refdownval (run, left);
+		PANIC (run, ASE_AWK_ENOMEM);
 	}
 
-	sse_awk_refdownval (run, left);
+	ase_awk_refdownval (run, left);
 	return res;
 }
 
-static sse_awk_val_t* __eval_incpre (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_incpre (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	sse_awk_val_t* left, * res;
-	sse_awk_nde_exp_t* exp = (sse_awk_nde_exp_t*)nde;
+	ase_awk_val_t* left, * res;
+	ase_awk_nde_exp_t* exp = (ase_awk_nde_exp_t*)nde;
 
-	sse_awk_assert (run->awk, exp->type == SSE_AWK_NDE_EXP_INCPRE);
-	sse_awk_assert (run->awk, exp->left != SSE_NULL && exp->right == SSE_NULL);
+	ase_awk_assert (run->awk, exp->type == ASE_AWK_NDE_EXP_INCPRE);
+	ase_awk_assert (run->awk, exp->left != ASE_NULL && exp->right == ASE_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 < SSE_AWK_NDE_NAMED ||
-	    exp->left->type > SSE_AWK_NDE_ARGIDX)
+	if (exp->left->type < ASE_AWK_NDE_NAMED ||
+	    exp->left->type > ASE_AWK_NDE_ARGIDX)
 	{
-		PANIC (run, SSE_AWK_EOPERAND);
+		PANIC (run, ASE_AWK_EOPERAND);
 	}
 
-	sse_awk_assert (run->awk, exp->left->next == SSE_NULL);
+	ase_awk_assert (run->awk, exp->left->next == ASE_NULL);
 	left = __eval_expression (run, exp->left);
-	if (left == SSE_NULL) return SSE_NULL;
+	if (left == ASE_NULL) return ASE_NULL;
 
-	sse_awk_refupval (left);
+	ase_awk_refupval (left);
 
-	if (exp->opcode == SSE_AWK_INCOP_PLUS) 
+	if (exp->opcode == ASE_AWK_INCOP_PLUS) 
 	{
-		if (left->type == SSE_AWK_VAL_INT)
+		if (left->type == ASE_AWK_VAL_INT)
 		{
-			sse_long_t r = ((sse_awk_val_int_t*)left)->val;
-			res = sse_awk_makeintval (run, r + 1);
-			if (res == SSE_NULL) 
+			ase_long_t r = ((ase_awk_val_int_t*)left)->val;
+			res = ase_awk_makeintval (run, r + 1);
+			if (res == ASE_NULL) 
 			{
-				sse_awk_refdownval (run, left);
-				PANIC (run, SSE_AWK_ENOMEM);
+				ase_awk_refdownval (run, left);
+				PANIC (run, ASE_AWK_ENOMEM);
 			}
 		}
-		else if (left->type == SSE_AWK_VAL_REAL)
+		else if (left->type == ASE_AWK_VAL_REAL)
 		{
-			sse_real_t r = ((sse_awk_val_real_t*)left)->val;
-			res = sse_awk_makerealval (run, r + 1.0);
-			if (res == SSE_NULL) 
+			ase_real_t r = ((ase_awk_val_real_t*)left)->val;
+			res = ase_awk_makerealval (run, r + 1.0);
+			if (res == ASE_NULL) 
 			{
-				sse_awk_refdownval (run, left);
-				PANIC (run, SSE_AWK_ENOMEM);
+				ase_awk_refdownval (run, left);
+				PANIC (run, ASE_AWK_ENOMEM);
 			}
 		}
 		else
 		{
-			sse_long_t v1;
-			sse_real_t v2;
+			ase_long_t v1;
+			ase_real_t v2;
 			int n;
 
-			n = sse_awk_valtonum (run, left, &v1, &v2);
+			n = ase_awk_valtonum (run, left, &v1, &v2);
 			if (n == -1)
 			{
-				sse_awk_refdownval (run, left);
-				PANIC (run, SSE_AWK_EOPERAND);
+				ase_awk_refdownval (run, left);
+				PANIC (run, ASE_AWK_EOPERAND);
 			}
 
 			if (n == 0) 
 			{
-				res = sse_awk_makeintval (run, v1 + 1);
+				res = ase_awk_makeintval (run, v1 + 1);
 			}
 			else /* if (n == 1) */
 			{
-				sse_awk_assert (run->awk, n == 1);
-				res = sse_awk_makerealval (run, v2 + 1.0);
+				ase_awk_assert (run->awk, n == 1);
+				res = ase_awk_makerealval (run, v2 + 1.0);
 			}
 
-			if (res == SSE_NULL) 
+			if (res == ASE_NULL) 
 			{
-				sse_awk_refdownval (run, left);
-				PANIC (run, SSE_AWK_ENOMEM);
+				ase_awk_refdownval (run, left);
+				PANIC (run, ASE_AWK_ENOMEM);
 			}
 		}
 	}
-	else if (exp->opcode == SSE_AWK_INCOP_MINUS)
+	else if (exp->opcode == ASE_AWK_INCOP_MINUS)
 	{
-		if (left->type == SSE_AWK_VAL_INT)
+		if (left->type == ASE_AWK_VAL_INT)
 		{
-			sse_long_t r = ((sse_awk_val_int_t*)left)->val;
-			res = sse_awk_makeintval (run, r - 1);
-			if (res == SSE_NULL) 
+			ase_long_t r = ((ase_awk_val_int_t*)left)->val;
+			res = ase_awk_makeintval (run, r - 1);
+			if (res == ASE_NULL) 
 			{
-				sse_awk_refdownval (run, left);
-				PANIC (run, SSE_AWK_ENOMEM);
+				ase_awk_refdownval (run, left);
+				PANIC (run, ASE_AWK_ENOMEM);
 			}
 		}
-		else if (left->type == SSE_AWK_VAL_REAL)
+		else if (left->type == ASE_AWK_VAL_REAL)
 		{
-			sse_real_t r = ((sse_awk_val_real_t*)left)->val;
-			res = sse_awk_makerealval (run, r - 1.0);
-			if (res == SSE_NULL) 
+			ase_real_t r = ((ase_awk_val_real_t*)left)->val;
+			res = ase_awk_makerealval (run, r - 1.0);
+			if (res == ASE_NULL) 
 			{
-				sse_awk_refdownval (run, left);
-				PANIC (run, SSE_AWK_ENOMEM);
+				ase_awk_refdownval (run, left);
+				PANIC (run, ASE_AWK_ENOMEM);
 			}
 		}
 		else
 		{
-			sse_long_t v1;
-			sse_real_t v2;
+			ase_long_t v1;
+			ase_real_t v2;
 			int n;
 
-			n = sse_awk_valtonum (run, left, &v1, &v2);
+			n = ase_awk_valtonum (run, left, &v1, &v2);
 			if (n == -1)
 			{
-				sse_awk_refdownval (run, left);
-				PANIC (run, SSE_AWK_EOPERAND);
+				ase_awk_refdownval (run, left);
+				PANIC (run, ASE_AWK_EOPERAND);
 			}
 
 			if (n == 0) 
 			{
-				res = sse_awk_makeintval (run, v1 - 1);
+				res = ase_awk_makeintval (run, v1 - 1);
 			}
 			else /* if (n == 1) */
 			{
-				sse_awk_assert (run->awk, n == 1);
-				res = sse_awk_makerealval (run, v2 - 1.0);
+				ase_awk_assert (run->awk, n == 1);
+				res = ase_awk_makerealval (run, v2 - 1.0);
 			}
 
-			if (res == SSE_NULL) 
+			if (res == ASE_NULL) 
 			{
-				sse_awk_refdownval (run, left);
-				PANIC (run, SSE_AWK_ENOMEM);
+				ase_awk_refdownval (run, left);
+				PANIC (run, ASE_AWK_ENOMEM);
 			}
 		}
 	}
 	else
 	{
-		sse_awk_assert (run->awk, !"should never happen - invalid opcode");
-		sse_awk_refdownval (run, left);
-		PANIC (run, SSE_AWK_EINTERNAL);
+		ase_awk_assert (run->awk, !"should never happen - invalid opcode");
+		ase_awk_refdownval (run, left);
+		PANIC (run, ASE_AWK_EINTERNAL);
 	}
 
-	if (__do_assignment (run, exp->left, res) == SSE_NULL)
+	if (__do_assignment (run, exp->left, res) == ASE_NULL)
 	{
-		sse_awk_refdownval (run, left);
-		return SSE_NULL;
+		ase_awk_refdownval (run, left);
+		return ASE_NULL;
 	}
 
-	sse_awk_refdownval (run, left);
+	ase_awk_refdownval (run, left);
 	return res;
 }
 
-static sse_awk_val_t* __eval_incpst (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_incpst (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	sse_awk_val_t* left, * res, * res2;
-	sse_awk_nde_exp_t* exp = (sse_awk_nde_exp_t*)nde;
+	ase_awk_val_t* left, * res, * res2;
+	ase_awk_nde_exp_t* exp = (ase_awk_nde_exp_t*)nde;
 
-	sse_awk_assert (run->awk, exp->type == SSE_AWK_NDE_EXP_INCPST);
-	sse_awk_assert (run->awk, exp->left != SSE_NULL && exp->right == SSE_NULL);
+	ase_awk_assert (run->awk, exp->type == ASE_AWK_NDE_EXP_INCPST);
+	ase_awk_assert (run->awk, exp->left != ASE_NULL && exp->right == ASE_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 < SSE_AWK_NDE_NAMED ||
-	    exp->left->type > SSE_AWK_NDE_ARGIDX)
+	if (exp->left->type < ASE_AWK_NDE_NAMED ||
+	    exp->left->type > ASE_AWK_NDE_ARGIDX)
 	{
-		PANIC (run, SSE_AWK_EOPERAND);
+		PANIC (run, ASE_AWK_EOPERAND);
 	}
 
-	sse_awk_assert (run->awk, exp->left->next == SSE_NULL);
+	ase_awk_assert (run->awk, exp->left->next == ASE_NULL);
 	left = __eval_expression (run, exp->left);
-	if (left == SSE_NULL) return SSE_NULL;
+	if (left == ASE_NULL) return ASE_NULL;
 
-	sse_awk_refupval (left);
+	ase_awk_refupval (left);
 
-	if (exp->opcode == SSE_AWK_INCOP_PLUS) 
+	if (exp->opcode == ASE_AWK_INCOP_PLUS) 
 	{
-		if (left->type == SSE_AWK_VAL_INT)
+		if (left->type == ASE_AWK_VAL_INT)
 		{
-			sse_long_t r = ((sse_awk_val_int_t*)left)->val;
-			res = sse_awk_makeintval (run, r);
-			if (res == SSE_NULL) 
+			ase_long_t r = ((ase_awk_val_int_t*)left)->val;
+			res = ase_awk_makeintval (run, r);
+			if (res == ASE_NULL) 
 			{
-				sse_awk_refdownval (run, left);
-				PANIC (run, SSE_AWK_ENOMEM);
+				ase_awk_refdownval (run, left);
+				PANIC (run, ASE_AWK_ENOMEM);
 			}
 
-			res2 = sse_awk_makeintval (run, r + 1);
-			if (res2 == SSE_NULL)
+			res2 = ase_awk_makeintval (run, r + 1);
+			if (res2 == ASE_NULL)
 			{
-				sse_awk_refdownval (run, left);
-				sse_awk_freeval (run, res, sse_true);
-				PANIC (run, SSE_AWK_ENOMEM);
+				ase_awk_refdownval (run, left);
+				ase_awk_freeval (run, res, ase_true);
+				PANIC (run, ASE_AWK_ENOMEM);
 			}
 		}
-		else if (left->type == SSE_AWK_VAL_REAL)
+		else if (left->type == ASE_AWK_VAL_REAL)
 		{
-			sse_real_t r = ((sse_awk_val_real_t*)left)->val;
-			res = sse_awk_makerealval (run, r);
-			if (res == SSE_NULL) 
+			ase_real_t r = ((ase_awk_val_real_t*)left)->val;
+			res = ase_awk_makerealval (run, r);
+			if (res == ASE_NULL) 
 			{
-				sse_awk_refdownval (run, left);
-				PANIC (run, SSE_AWK_ENOMEM);
+				ase_awk_refdownval (run, left);
+				PANIC (run, ASE_AWK_ENOMEM);
 			}
 
-			res2 = sse_awk_makerealval (run, r + 1.0);
-			if (res2 == SSE_NULL)
+			res2 = ase_awk_makerealval (run, r + 1.0);
+			if (res2 == ASE_NULL)
 			{
-				sse_awk_refdownval (run, left);
-				sse_awk_freeval (run, res, sse_true);
-				PANIC (run, SSE_AWK_ENOMEM);
+				ase_awk_refdownval (run, left);
+				ase_awk_freeval (run, res, ase_true);
+				PANIC (run, ASE_AWK_ENOMEM);
 			}
 		}
 		else
 		{
-			sse_long_t v1;
-			sse_real_t v2;
+			ase_long_t v1;
+			ase_real_t v2;
 			int n;
 
-			n = sse_awk_valtonum (run, left, &v1, &v2);
+			n = ase_awk_valtonum (run, left, &v1, &v2);
 			if (n == -1)
 			{
-				sse_awk_refdownval (run, left);
-				PANIC (run, SSE_AWK_EOPERAND);
+				ase_awk_refdownval (run, left);
+				PANIC (run, ASE_AWK_EOPERAND);
 			}
 
 			if (n == 0) 
 			{
-				res = sse_awk_makeintval (run, v1);
-				if (res == SSE_NULL)
+				res = ase_awk_makeintval (run, v1);
+				if (res == ASE_NULL)
 				{
-					sse_awk_refdownval (run, left);
-					PANIC (run, SSE_AWK_ENOMEM);
+					ase_awk_refdownval (run, left);
+					PANIC (run, ASE_AWK_ENOMEM);
 				}
 
-				res2 = sse_awk_makeintval (run, v1 + 1);
-				if (res2 == SSE_NULL)
+				res2 = ase_awk_makeintval (run, v1 + 1);
+				if (res2 == ASE_NULL)
 				{
-					sse_awk_refdownval (run, left);
-					sse_awk_freeval (run, res, sse_true);
-					PANIC (run, SSE_AWK_ENOMEM);
+					ase_awk_refdownval (run, left);
+					ase_awk_freeval (run, res, ase_true);
+					PANIC (run, ASE_AWK_ENOMEM);
 				}
 			}
 			else /* if (n == 1) */
 			{
-				sse_awk_assert (run->awk, n == 1);
-				res = sse_awk_makerealval (run, v2);
-				if (res == SSE_NULL)
+				ase_awk_assert (run->awk, n == 1);
+				res = ase_awk_makerealval (run, v2);
+				if (res == ASE_NULL)
 				{
-					sse_awk_refdownval (run, left);
-					PANIC (run, SSE_AWK_ENOMEM);
+					ase_awk_refdownval (run, left);
+					PANIC (run, ASE_AWK_ENOMEM);
 				}
 
-				res2 = sse_awk_makerealval (run, v2 + 1.0);
-				if (res2 == SSE_NULL)
+				res2 = ase_awk_makerealval (run, v2 + 1.0);
+				if (res2 == ASE_NULL)
 				{
-					sse_awk_refdownval (run, left);
-					sse_awk_freeval (run, res, sse_true);
-					PANIC (run, SSE_AWK_ENOMEM);
+					ase_awk_refdownval (run, left);
+					ase_awk_freeval (run, res, ase_true);
+					PANIC (run, ASE_AWK_ENOMEM);
 				}
 			}
 		}
 	}
-	else if (exp->opcode == SSE_AWK_INCOP_MINUS)
+	else if (exp->opcode == ASE_AWK_INCOP_MINUS)
 	{
-		if (left->type == SSE_AWK_VAL_INT)
+		if (left->type == ASE_AWK_VAL_INT)
 		{
-			sse_long_t r = ((sse_awk_val_int_t*)left)->val;
-			res = sse_awk_makeintval (run, r);
-			if (res == SSE_NULL) 
+			ase_long_t r = ((ase_awk_val_int_t*)left)->val;
+			res = ase_awk_makeintval (run, r);
+			if (res == ASE_NULL) 
 			{
-				sse_awk_refdownval (run, left);
-				PANIC (run, SSE_AWK_ENOMEM);
+				ase_awk_refdownval (run, left);
+				PANIC (run, ASE_AWK_ENOMEM);
 			}
 
-			res2 = sse_awk_makeintval (run, r - 1);
-			if (res2 == SSE_NULL)
+			res2 = ase_awk_makeintval (run, r - 1);
+			if (res2 == ASE_NULL)
 			{
-				sse_awk_refdownval (run, left);
-				sse_awk_freeval (run, res, sse_true);
-				PANIC (run, SSE_AWK_ENOMEM);
+				ase_awk_refdownval (run, left);
+				ase_awk_freeval (run, res, ase_true);
+				PANIC (run, ASE_AWK_ENOMEM);
 			}
 		}
-		else if (left->type == SSE_AWK_VAL_REAL)
+		else if (left->type == ASE_AWK_VAL_REAL)
 		{
-			sse_real_t r = ((sse_awk_val_real_t*)left)->val;
-			res = sse_awk_makerealval (run, r);
-			if (res == SSE_NULL) 
+			ase_real_t r = ((ase_awk_val_real_t*)left)->val;
+			res = ase_awk_makerealval (run, r);
+			if (res == ASE_NULL) 
 			{
-				sse_awk_refdownval (run, left);
-				PANIC (run, SSE_AWK_ENOMEM);
+				ase_awk_refdownval (run, left);
+				PANIC (run, ASE_AWK_ENOMEM);
 			}
 
-			res2 = sse_awk_makerealval (run, r - 1.0);
-			if (res2 == SSE_NULL)
+			res2 = ase_awk_makerealval (run, r - 1.0);
+			if (res2 == ASE_NULL)
 			{
-				sse_awk_refdownval (run, left);
-				sse_awk_freeval (run, res, sse_true);
-				PANIC (run, SSE_AWK_ENOMEM);
+				ase_awk_refdownval (run, left);
+				ase_awk_freeval (run, res, ase_true);
+				PANIC (run, ASE_AWK_ENOMEM);
 			}
 		}
 		else
 		{
-			sse_long_t v1;
-			sse_real_t v2;
+			ase_long_t v1;
+			ase_real_t v2;
 			int n;
 
-			n = sse_awk_valtonum (run, left, &v1, &v2);
+			n = ase_awk_valtonum (run, left, &v1, &v2);
 			if (n == -1)
 			{
-				sse_awk_refdownval (run, left);
-				PANIC (run, SSE_AWK_EOPERAND);
+				ase_awk_refdownval (run, left);
+				PANIC (run, ASE_AWK_EOPERAND);
 			}
 
 			if (n == 0) 
 			{
-				res = sse_awk_makeintval (run, v1);
-				if (res == SSE_NULL)
+				res = ase_awk_makeintval (run, v1);
+				if (res == ASE_NULL)
 				{
-					sse_awk_refdownval (run, left);
-					PANIC (run, SSE_AWK_ENOMEM);
+					ase_awk_refdownval (run, left);
+					PANIC (run, ASE_AWK_ENOMEM);
 				}
 
-				res2 = sse_awk_makeintval (run, v1 - 1);
-				if (res2 == SSE_NULL)
+				res2 = ase_awk_makeintval (run, v1 - 1);
+				if (res2 == ASE_NULL)
 				{
-					sse_awk_refdownval (run, left);
-					sse_awk_freeval (run, res, sse_true);
-					PANIC (run, SSE_AWK_ENOMEM);
+					ase_awk_refdownval (run, left);
+					ase_awk_freeval (run, res, ase_true);
+					PANIC (run, ASE_AWK_ENOMEM);
 				}
 			}
 			else /* if (n == 1) */
 			{
-				sse_awk_assert (run->awk, n == 1);
-				res = sse_awk_makerealval (run, v2);
-				if (res == SSE_NULL)
+				ase_awk_assert (run->awk, n == 1);
+				res = ase_awk_makerealval (run, v2);
+				if (res == ASE_NULL)
 				{
-					sse_awk_refdownval (run, left);
-					PANIC (run, SSE_AWK_ENOMEM);
+					ase_awk_refdownval (run, left);
+					PANIC (run, ASE_AWK_ENOMEM);
 				}
 
-				res2 = sse_awk_makerealval (run, v2 - 1.0);
-				if (res2 == SSE_NULL)
+				res2 = ase_awk_makerealval (run, v2 - 1.0);
+				if (res2 == ASE_NULL)
 				{
-					sse_awk_refdownval (run, left);
-					sse_awk_freeval (run, res, sse_true);
-					PANIC (run, SSE_AWK_ENOMEM);
+					ase_awk_refdownval (run, left);
+					ase_awk_freeval (run, res, ase_true);
+					PANIC (run, ASE_AWK_ENOMEM);
 				}
 			}
 		}
 	}
 	else
 	{
-		sse_awk_assert (run->awk, !"should never happen - invalid opcode");
-		sse_awk_refdownval (run, left);
-		PANIC (run, SSE_AWK_EINTERNAL);
+		ase_awk_assert (run->awk, !"should never happen - invalid opcode");
+		ase_awk_refdownval (run, left);
+		PANIC (run, ASE_AWK_EINTERNAL);
 	}
 
-	if (__do_assignment (run, exp->left, res2) == SSE_NULL)
+	if (__do_assignment (run, exp->left, res2) == ASE_NULL)
 	{
-		sse_awk_refdownval (run, left);
-		return SSE_NULL;
+		ase_awk_refdownval (run, left);
+		return ASE_NULL;
 	}
 
-	sse_awk_refdownval (run, left);
+	ase_awk_refdownval (run, left);
 	return res;
 }
 
-static sse_awk_val_t* __eval_cnd (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_cnd (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	sse_awk_val_t* tv, * v;
-	sse_awk_nde_cnd_t* cnd = (sse_awk_nde_cnd_t*)nde;
+	ase_awk_val_t* tv, * v;
+	ase_awk_nde_cnd_t* cnd = (ase_awk_nde_cnd_t*)nde;
 
-	sse_awk_assert (run->awk, cnd->test->next == SSE_NULL);
+	ase_awk_assert (run->awk, cnd->test->next == ASE_NULL);
 	tv = __eval_expression (run, cnd->test);
-	if (tv == SSE_NULL) return SSE_NULL;
+	if (tv == ASE_NULL) return ASE_NULL;
 
-	sse_awk_refupval (tv);
+	ase_awk_refupval (tv);
 
-	sse_awk_assert (run->awk, cnd->left->next == SSE_NULL &&
-	           cnd->right->next == SSE_NULL);
-	v = (sse_awk_valtobool (run, tv))?
+	ase_awk_assert (run->awk, cnd->left->next == ASE_NULL &&
+	           cnd->right->next == ASE_NULL);
+	v = (ase_awk_valtobool (run, tv))?
 		__eval_expression (run, cnd->left):
 		__eval_expression (run, cnd->right);
 
-	sse_awk_refdownval (run, tv);
+	ase_awk_refdownval (run, tv);
 	return v;
 }
 
-static sse_awk_val_t* __eval_bfn (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_bfn (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	sse_awk_nde_call_t* call = (sse_awk_nde_call_t*)nde;
+	ase_awk_nde_call_t* call = (ase_awk_nde_call_t*)nde;
 
 	/* built-in function */
 	if (call->nargs < call->what.bfn.min_args)
 	{
-		PANIC (run, SSE_AWK_ETOOFEWARGS);
+		PANIC (run, ASE_AWK_ETOOFEWARGS);
 	}
 
 	if (call->nargs > call->what.bfn.max_args)
 	{
-		PANIC (run, SSE_AWK_ETOOMANYARGS);
+		PANIC (run, ASE_AWK_ETOOMANYARGS);
 	}
 
-	return __eval_call (run, nde, call->what.bfn.arg_spec, SSE_NULL);
+	return __eval_call (run, nde, call->what.bfn.arg_spec, ASE_NULL);
 }
 
-static sse_awk_val_t* __eval_afn (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_afn (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	sse_awk_nde_call_t* call = (sse_awk_nde_call_t*)nde;
-	sse_awk_afn_t* afn;
-	sse_awk_pair_t* pair;
+	ase_awk_nde_call_t* call = (ase_awk_nde_call_t*)nde;
+	ase_awk_afn_t* afn;
+	ase_awk_pair_t* pair;
 
-	pair = sse_awk_map_get (&run->awk->tree.afns, 
+	pair = ase_awk_map_get (&run->awk->tree.afns, 
 		call->what.afn.name, call->what.afn.name_len);
-	if (pair == SSE_NULL) PANIC (run, SSE_AWK_ENOSUCHFUNC);
+	if (pair == ASE_NULL) PANIC (run, ASE_AWK_ENOSUCHFUNC);
 
-	afn = (sse_awk_afn_t*)pair->val;
-	sse_awk_assert (run->awk, afn != SSE_NULL);
+	afn = (ase_awk_afn_t*)pair->val;
+	ase_awk_assert (run->awk, afn != ASE_NULL);
 
 	if (call->nargs > afn->nargs)
 	{
 		/* TODO: is this correct? what if i want to allow arbitarary numbers of arguments? */
-		PANIC (run, SSE_AWK_ETOOMANYARGS);
+		PANIC (run, ASE_AWK_ETOOMANYARGS);
 	}
 
-	return __eval_call (run, nde, SSE_NULL, afn);
+	return __eval_call (run, nde, ASE_NULL, afn);
 }
 
 
 /* run->stack_base has not been set for this  
  * stack frame. so STACK_ARG cannot be used */ 
-/*sse_awk_refdownval (run, STACK_ARG(run,nargs));*/ 
+/*ase_awk_refdownval (run, STACK_ARG(run,nargs));*/ 
 #define UNWIND_RUN_STACK(run,nargs) \
 	do { \
 		while ((nargs) > 0) \
 		{ \
 			--(nargs); \
-			sse_awk_refdownval ((run), \
+			ase_awk_refdownval ((run), \
 				(run)->stack[(run)->stack_top-1]); \
 			__raw_pop (run); \
 		} \
@@ -4273,15 +4273,15 @@ static sse_awk_val_t* __eval_afn (sse_awk_run_t* run, sse_awk_nde_t* nde)
 		__raw_pop (run); \
 	} while (0)
 
-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 ase_awk_val_t* __eval_call (
+	ase_awk_run_t* run, ase_awk_nde_t* nde, 
+	const ase_char_t* bfn_arg_spec, ase_awk_afn_t* afn)
 {
-	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;
+	ase_awk_nde_call_t* call = (ase_awk_nde_call_t*)nde;
+	ase_size_t saved_stack_top;
+	ase_size_t nargs, i;
+	ase_awk_nde_t* p;
+	ase_awk_val_t* v;
 	int n;
 
 	/* 
@@ -4324,66 +4324,66 @@ static sse_awk_val_t* __eval_call (
 	 * ---------------------
 	 */
 
-	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));
+	ase_awk_assert (run->awk, ase_sizeof(void*) >= ase_sizeof(run->stack_top));
+	ase_awk_assert (run->awk, ase_sizeof(void*) >= ase_sizeof(run->stack_base));
 
 	saved_stack_top = run->stack_top;
 
-/*xp_printf (SSE_T("setting up function stack frame stack_top = %ld stack_base = %ld\n"), run->stack_top, run->stack_base); */
+/*xp_printf (ASE_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, SSE_AWK_ENOMEM);
+		PANIC (run, ASE_AWK_ENOMEM);
 	}
 
 	if (__raw_push(run,(void*)saved_stack_top) == -1) 
 	{
 		__raw_pop (run);
-		PANIC (run, SSE_AWK_ENOMEM);
+		PANIC (run, ASE_AWK_ENOMEM);
 	}
 
 	/* secure space for a return value. */
-	if (__raw_push(run,sse_awk_val_nil) == -1)
+	if (__raw_push(run,ase_awk_val_nil) == -1)
 	{
 		__raw_pop (run);
 		__raw_pop (run);
-		PANIC (run, SSE_AWK_ENOMEM);
+		PANIC (run, ASE_AWK_ENOMEM);
 	}
 
 	/* secure space for nargs */
-	if (__raw_push(run,sse_awk_val_nil) == -1)
+	if (__raw_push(run,ase_awk_val_nil) == -1)
 	{
 		__raw_pop (run);
 		__raw_pop (run);
 		__raw_pop (run);
-		PANIC (run, SSE_AWK_ENOMEM);
+		PANIC (run, ASE_AWK_ENOMEM);
 	}
 
 	nargs = 0;
 	p = call->args;
-	while (p != SSE_NULL)
+	while (p != ASE_NULL)
 	{
-		sse_awk_assert (run->awk, bfn_arg_spec == SSE_NULL ||
-		           (bfn_arg_spec != SSE_NULL && 
-		            sse_awk_strlen(bfn_arg_spec) > nargs));
+		ase_awk_assert (run->awk, bfn_arg_spec == ASE_NULL ||
+		           (bfn_arg_spec != ASE_NULL && 
+		            ase_awk_strlen(bfn_arg_spec) > nargs));
 
-		if (bfn_arg_spec != SSE_NULL && 
-		    bfn_arg_spec[nargs] == SSE_T('r'))
+		if (bfn_arg_spec != ASE_NULL && 
+		    bfn_arg_spec[nargs] == ASE_T('r'))
 		{
-			sse_awk_val_t** ref;
+			ase_awk_val_t** ref;
 			      
 			if (__get_reference (run, p, &ref) == -1)
 			{
 				UNWIND_RUN_STACK (run, nargs);
-				return SSE_NULL;
+				return ASE_NULL;
 			}
 
-			/* 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);
+			/* p->type-ASE_AWK_NDE_NAMED assumes that the
+			 * derived value matches ASE_AWK_VAL_REF_XXX */
+			v = ase_awk_makerefval (
+				run, p->type-ASE_AWK_NDE_NAMED, ref);
 		}
-		else if (bfn_arg_spec != SSE_NULL && 
-		         bfn_arg_spec[nargs] == SSE_T('x'))
+		else if (bfn_arg_spec != ASE_NULL && 
+		         bfn_arg_spec[nargs] == ASE_T('x'))
 		{
 			/* a regular expression is passed to 
 			 * the function as it is */
@@ -4393,44 +4393,44 @@ static sse_awk_val_t* __eval_call (
 		{
 			v = __eval_expression (run, p);
 		}
-		if (v == SSE_NULL)
+		if (v == ASE_NULL)
 		{
 			UNWIND_RUN_STACK (run, nargs);
-			return SSE_NULL;
+			return ASE_NULL;
 		}
 
 #if 0
-		if (bfn_arg_spec != SSE_NULL && 
-		    bfn_arg_spec[nargs] == SSE_T('r'))
+		if (bfn_arg_spec != ASE_NULL && 
+		    bfn_arg_spec[nargs] == ASE_T('r'))
 		{
-			sse_awk_val_t** ref;
-			sse_awk_val_t* tmp;
+			ase_awk_val_t** ref;
+			ase_awk_val_t* tmp;
 			      
 			ref = __get_reference (run, p);
-			if (ref == SSE_NULL)
+			if (ref == ASE_NULL)
 			{
-				sse_awk_refupval (v);
-				sse_awk_refdownval (run, v);
+				ase_awk_refupval (v);
+				ase_awk_refdownval (run, v);
 
 				UNWIND_RUN_STACK (run, nargs);
-				return SSE_NULL;
+				return ASE_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)
+			/* p->type-ASE_AWK_NDE_NAMED assumes that the
+			 * derived value matches ASE_AWK_VAL_REF_XXX */
+			tmp = ase_awk_makerefval (
+				run, p->type-ASE_AWK_NDE_NAMED, ref);
+			if (tmp == ASE_NULL)
 			{
-				sse_awk_refupval (v);
-				sse_awk_refdownval (run, v);
+				ase_awk_refupval (v);
+				ase_awk_refdownval (run, v);
 
 				UNWIND_RUN_STACK (run, nargs);
-				PANIC (run, SSE_AWK_ENOMEM);
+				PANIC (run, ASE_AWK_ENOMEM);
 			}
 
-			sse_awk_refupval (v);
-			sse_awk_refdownval (run, v);
+			ase_awk_refupval (v);
+			ase_awk_refdownval (run, v);
 
 			v = tmp;
 		}
@@ -4443,31 +4443,31 @@ static sse_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 */
-			sse_awk_refupval (v);
-			sse_awk_refdownval (run, v);
+			ase_awk_refupval (v);
+			ase_awk_refdownval (run, v);
 
 			UNWIND_RUN_STACK (run, nargs);
-			PANIC (run, SSE_AWK_ENOMEM);
+			PANIC (run, ASE_AWK_ENOMEM);
 		}
 
-		sse_awk_refupval (v);
+		ase_awk_refupval (v);
 		nargs++;
 		p = p->next;
 	}
 
-	sse_awk_assert (run->awk, nargs == call->nargs);
+	ase_awk_assert (run->awk, nargs == call->nargs);
 
-	if (afn != SSE_NULL)
+	if (afn != ASE_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,sse_awk_val_nil) == -1)
+			if (__raw_push(run,ase_awk_val_nil) == -1)
 			{
 				UNWIND_RUN_STACK (run, nargs);
-				PANIC (run, SSE_AWK_ENOMEM);
+				PANIC (run, ASE_AWK_ENOMEM);
 			}
 
 			nargs++;
@@ -4477,36 +4477,36 @@ static sse_awk_val_t* __eval_call (
 	run->stack_base = saved_stack_top;
 	STACK_NARGS(run) = (void*)nargs;
 	
-/*xp_printf (SSE_T("running function body\n")); */
+/*xp_printf (ASE_T("running function body\n")); */
 
-	if (afn != SSE_NULL)
+	if (afn != ASE_NULL)
 	{
 		/* normal awk function */
-		sse_awk_assert (run->awk, afn->body->type == SSE_AWK_NDE_BLK);
-		n = __run_block(run,(sse_awk_nde_blk_t*)afn->body);
+		ase_awk_assert (run->awk, afn->body->type == ASE_AWK_NDE_BLK);
+		n = __run_block(run,(ase_awk_nde_blk_t*)afn->body);
 	}
 	else
 	{
 		n = 0;
 
 		/* built-in function */
-		sse_awk_assert (run->awk, call->nargs >= call->what.bfn.min_args &&
+		ase_awk_assert (run->awk, call->nargs >= call->what.bfn.min_args &&
 		           call->nargs <= call->what.bfn.max_args);
 
-		if (call->what.bfn.handler != SSE_NULL)
+		if (call->what.bfn.handler != ASE_NULL)
 			n = call->what.bfn.handler (run);
 	}
 
-/*xp_printf (SSE_T("block run complete\n")); */
+/*xp_printf (ASE_T("block run complete\n")); */
 
 	/* refdown args in the run.stack */
-	nargs = (sse_size_t)STACK_NARGS(run);
-/*xp_printf (SSE_T("block run complete nargs = %d\n"), (int)nargs); */
+	nargs = (ase_size_t)STACK_NARGS(run);
+/*xp_printf (ASE_T("block run complete nargs = %d\n"), (int)nargs); */
 	for (i = 0; i < nargs; i++)
 	{
-		sse_awk_refdownval (run, STACK_ARG(run,i));
+		ase_awk_refdownval (run, STACK_ARG(run,i));
 	}
-/*xp_printf (SSE_T("got return value\n")); */
+/*xp_printf (ASE_T("got return value\n")); */
 
 	/* this trick has been mentioned in __run_return.
 	 * adjust the reference count of the return value.
@@ -4514,512 +4514,512 @@ static sse_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);
-	sse_awk_refdownval_nofree (run, v);
+	ase_awk_refdownval_nofree (run, v);
 
-	run->stack_top =  (sse_size_t)run->stack[run->stack_base+1];
-	run->stack_base = (sse_size_t)run->stack[run->stack_base+0];
+	run->stack_top =  (ase_size_t)run->stack[run->stack_base+1];
+	run->stack_base = (ase_size_t)run->stack[run->stack_base+0];
 
 	if (run->exit_level == EXIT_FUNCTION) run->exit_level = EXIT_NONE;
 
-/*xp_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;
+/*xp_printf (ASE_T("returning from function stack_top=%ld, stack_base=%ld\n"), run->stack_top, run->stack_base); */
+	return (n == -1)? ASE_NULL: v;
 }
 
 static int __get_reference (
-	sse_awk_run_t* run, sse_awk_nde_t* nde, sse_awk_val_t*** ref)
+	ase_awk_run_t* run, ase_awk_nde_t* nde, ase_awk_val_t*** ref)
 {
-	sse_awk_nde_var_t* tgt = (sse_awk_nde_var_t*)nde;
-	sse_awk_val_t** tmp;
+	ase_awk_nde_var_t* tgt = (ase_awk_nde_var_t*)nde;
+	ase_awk_val_t** tmp;
 
 	/* refer to __eval_indexed for application of a similar concept */
 
-	if (nde->type == SSE_AWK_NDE_NAMED)
+	if (nde->type == ASE_AWK_NDE_NAMED)
 	{
-		sse_awk_pair_t* pair;
+		ase_awk_pair_t* pair;
 
-		pair = sse_awk_map_get (
+		pair = ase_awk_map_get (
 			&run->named, tgt->id.name, tgt->id.name_len);
-		if (pair == SSE_NULL)
+		if (pair == ASE_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 = sse_awk_map_put (
+			pair = ase_awk_map_put (
 				&run->named, tgt->id.name,
-				tgt->id.name_len, sse_awk_val_nil);
-			if (pair == SSE_NULL) PANIC_I (run, SSE_AWK_ENOMEM);
+				tgt->id.name_len, ase_awk_val_nil);
+			if (pair == ASE_NULL) PANIC_I (run, ASE_AWK_ENOMEM);
 		}
 
-		*ref = (sse_awk_val_t**)&pair->val;
+		*ref = (ase_awk_val_t**)&pair->val;
 		return 0;
 	}
 
-	if (nde->type == SSE_AWK_NDE_GLOBAL)
+	if (nde->type == ASE_AWK_NDE_GLOBAL)
 	{
-		*ref = (sse_awk_val_t**)&STACK_GLOBAL(run,tgt->id.idxa);
+		*ref = (ase_awk_val_t**)&STACK_GLOBAL(run,tgt->id.idxa);
 		return 0;
 	}
 
-	if (nde->type == SSE_AWK_NDE_LOCAL)
+	if (nde->type == ASE_AWK_NDE_LOCAL)
 	{
-		*ref = (sse_awk_val_t**)&STACK_LOCAL(run,tgt->id.idxa);
+		*ref = (ase_awk_val_t**)&STACK_LOCAL(run,tgt->id.idxa);
 		return 0;
 	}
 
-	if (nde->type == SSE_AWK_NDE_ARG)
+	if (nde->type == ASE_AWK_NDE_ARG)
 	{
-		*ref = (sse_awk_val_t**)&STACK_ARG(run,tgt->id.idxa);
+		*ref = (ase_awk_val_t**)&STACK_ARG(run,tgt->id.idxa);
 		return 0;
 	}
 
-	if (nde->type == SSE_AWK_NDE_NAMEDIDX)
+	if (nde->type == ASE_AWK_NDE_NAMEDIDX)
 	{
-		sse_awk_pair_t* pair;
+		ase_awk_pair_t* pair;
 
-		pair = sse_awk_map_get (
+		pair = ase_awk_map_get (
 			&run->named, tgt->id.name, tgt->id.name_len);
-		if (pair == SSE_NULL)
+		if (pair == ASE_NULL)
 		{
-			pair = sse_awk_map_put (
+			pair = ase_awk_map_put (
 				&run->named, tgt->id.name,
-				tgt->id.name_len, sse_awk_val_nil);
-			if (pair == SSE_NULL) PANIC_I (run, SSE_AWK_ENOMEM);
+				tgt->id.name_len, ase_awk_val_nil);
+			if (pair == ASE_NULL) PANIC_I (run, ASE_AWK_ENOMEM);
 		}
 
 		tmp = __get_reference_indexed (
-			run, tgt, (sse_awk_val_t**)&pair->val);
-		if (tmp == SSE_NULL) return -1;
+			run, tgt, (ase_awk_val_t**)&pair->val);
+		if (tmp == ASE_NULL) return -1;
 		*ref = tmp;
 	}
 
-	if (nde->type == SSE_AWK_NDE_GLOBALIDX)
+	if (nde->type == ASE_AWK_NDE_GLOBALIDX)
 	{
 		tmp = __get_reference_indexed (run, tgt, 
-			(sse_awk_val_t**)&STACK_GLOBAL(run,tgt->id.idxa));
-		if (tmp == SSE_NULL) return -1;
+			(ase_awk_val_t**)&STACK_GLOBAL(run,tgt->id.idxa));
+		if (tmp == ASE_NULL) return -1;
 		*ref = tmp;
 	}
 
-	if (nde->type == SSE_AWK_NDE_LOCALIDX)
+	if (nde->type == ASE_AWK_NDE_LOCALIDX)
 	{
 		tmp = __get_reference_indexed (run, tgt, 
-			(sse_awk_val_t**)&STACK_LOCAL(run,tgt->id.idxa));
-		if (tmp == SSE_NULL) return -1;
+			(ase_awk_val_t**)&STACK_LOCAL(run,tgt->id.idxa));
+		if (tmp == ASE_NULL) return -1;
 		*ref = tmp;
 	}
 
-	if (nde->type == SSE_AWK_NDE_ARGIDX)
+	if (nde->type == ASE_AWK_NDE_ARGIDX)
 	{
 		tmp = __get_reference_indexed (run, tgt, 
-			(sse_awk_val_t**)&STACK_ARG(run,tgt->id.idxa));
-		if (tmp == SSE_NULL) return -1;
+			(ase_awk_val_t**)&STACK_ARG(run,tgt->id.idxa));
+		if (tmp == ASE_NULL) return -1;
 		*ref = tmp;
 	}
 
-	if (nde->type == SSE_AWK_NDE_POS)
+	if (nde->type == ASE_AWK_NDE_POS)
 	{
 		int n;
-		sse_long_t lv;
-		sse_real_t rv;
-		sse_awk_val_t* v;
+		ase_long_t lv;
+		ase_real_t rv;
+		ase_awk_val_t* v;
 
 		/* the position number is returned for the positional 
 		 * variable unlike other reference types. */
-		v = __eval_expression (run, ((sse_awk_nde_pos_t*)nde)->val);
-		if (v == SSE_NULL) return -1;
+		v = __eval_expression (run, ((ase_awk_nde_pos_t*)nde)->val);
+		if (v == ASE_NULL) return -1;
 
-		sse_awk_refupval (v);
-		n = sse_awk_valtonum (run, v, &lv, &rv);
-		sse_awk_refdownval (run, v);
+		ase_awk_refupval (v);
+		n = ase_awk_valtonum (run, v, &lv, &rv);
+		ase_awk_refdownval (run, v);
 
-		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);
+		if (n == -1) PANIC_I (run, ASE_AWK_EPOSIDX);
+		if (n == 1) lv = (ase_long_t)rv;
+		if (!IS_VALID_POSIDX(lv)) PANIC_I (run, ASE_AWK_EPOSIDX);
 
-		*ref = (sse_awk_val_t**)((sse_size_t)lv);
+		*ref = (ase_awk_val_t**)((ase_size_t)lv);
 		return 0;
 	}
 
-	PANIC_I (run, SSE_AWK_ENOTREFERENCEABLE);
+	PANIC_I (run, ASE_AWK_ENOTREFERENCEABLE);
 }
 
-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 ase_awk_val_t** __get_reference_indexed (
+	ase_awk_run_t* run, ase_awk_nde_var_t* nde, ase_awk_val_t** val)
 {
-	sse_awk_pair_t* pair;
-	sse_char_t* str;
-	sse_size_t len;
+	ase_awk_pair_t* pair;
+	ase_char_t* str;
+	ase_size_t len;
 
-	sse_awk_assert (run->awk, val != SSE_NULL);
+	ase_awk_assert (run->awk, val != ASE_NULL);
 
-	if ((*val)->type == SSE_AWK_VAL_NIL)
+	if ((*val)->type == ASE_AWK_VAL_NIL)
 	{
-		sse_awk_val_t* tmp;
+		ase_awk_val_t* tmp;
 
-		tmp = sse_awk_makemapval (run);
-		if (tmp == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
+		tmp = ase_awk_makemapval (run);
+		if (tmp == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 
-		sse_awk_refdownval (run, *val);
+		ase_awk_refdownval (run, *val);
 		*val = tmp;
-		sse_awk_refupval ((sse_awk_val_t*)*val);
+		ase_awk_refupval ((ase_awk_val_t*)*val);
 	}
-	else if ((*val)->type != SSE_AWK_VAL_MAP) 
+	else if ((*val)->type != ASE_AWK_VAL_MAP) 
 	{
-		PANIC (run, SSE_AWK_ENOTINDEXABLE);
+		PANIC (run, ASE_AWK_ENOTINDEXABLE);
 	}
 
-	sse_awk_assert (run->awk, nde->idx != SSE_NULL);
+	ase_awk_assert (run->awk, nde->idx != ASE_NULL);
 
 	str = __idxnde_to_str (run, nde->idx, &len);
-	if (str == SSE_NULL) return SSE_NULL;
+	if (str == ASE_NULL) return ASE_NULL;
 
-	pair = sse_awk_map_get ((*(sse_awk_val_map_t**)val)->map, str, len);
-	if (pair == SSE_NULL)
+	pair = ase_awk_map_get ((*(ase_awk_val_map_t**)val)->map, str, len);
+	if (pair == ASE_NULL)
 	{
-		pair = sse_awk_map_put (
-			(*(sse_awk_val_map_t**)val)->map, 
-			str, len, sse_awk_val_nil);
-		if (pair == SSE_NULL)
+		pair = ase_awk_map_put (
+			(*(ase_awk_val_map_t**)val)->map, 
+			str, len, ase_awk_val_nil);
+		if (pair == ASE_NULL)
 		{
-			SSE_AWK_FREE (run->awk, str);
-			PANIC (run, SSE_AWK_ENOMEM);
+			ASE_AWK_FREE (run->awk, str);
+			PANIC (run, ASE_AWK_ENOMEM);
 		}
 
-		sse_awk_refupval (pair->val);
+		ase_awk_refupval (pair->val);
 	}
 
-	SSE_AWK_FREE (run->awk, str);
-	return (sse_awk_val_t**)&pair->val;
+	ASE_AWK_FREE (run->awk, str);
+	return (ase_awk_val_t**)&pair->val;
 }
 
-static sse_awk_val_t* __eval_int (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_int (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	sse_awk_val_t* val;
+	ase_awk_val_t* val;
 
-	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; 
+	val = ase_awk_makeintval (run, ((ase_awk_nde_int_t*)nde)->val);
+	if (val == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
+	((ase_awk_val_int_t*)val)->nde = (ase_awk_nde_int_t*)nde; 
 
 	return val;
 }
 
-static sse_awk_val_t* __eval_real (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_real (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	sse_awk_val_t* val;
+	ase_awk_val_t* val;
 
-	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;
+	val = ase_awk_makerealval (run, ((ase_awk_nde_real_t*)nde)->val);
+	if (val == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
+	((ase_awk_val_real_t*)val)->nde = (ase_awk_nde_real_t*)nde;
 
 	return val;
 }
 
-static sse_awk_val_t* __eval_str (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_str (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	sse_awk_val_t* val;
+	ase_awk_val_t* val;
 
-	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);
+	val = ase_awk_makestrval (run,
+		((ase_awk_nde_str_t*)nde)->buf,
+		((ase_awk_nde_str_t*)nde)->len);
+	if (val == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 
 	return val;
 }
 
-static sse_awk_val_t* __eval_rex (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_rex (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	sse_awk_val_t* val;
+	ase_awk_val_t* val;
 
-	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);
+	val = ase_awk_makerexval (run,
+		((ase_awk_nde_rex_t*)nde)->buf,
+		((ase_awk_nde_rex_t*)nde)->len,
+		((ase_awk_nde_rex_t*)nde)->code);
+	if (val == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 
 	return val;
 }
 
-static sse_awk_val_t* __eval_named (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_named (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	sse_awk_pair_t* pair;
+	ase_awk_pair_t* pair;
 		       
-	pair = sse_awk_map_get (&run->named, 
-		((sse_awk_nde_var_t*)nde)->id.name, 
-		((sse_awk_nde_var_t*)nde)->id.name_len);
+	pair = ase_awk_map_get (&run->named, 
+		((ase_awk_nde_var_t*)nde)->id.name, 
+		((ase_awk_nde_var_t*)nde)->id.name_len);
 
-	return (pair == SSE_NULL)? sse_awk_val_nil: pair->val;
+	return (pair == ASE_NULL)? ase_awk_val_nil: pair->val;
 }
 
-static sse_awk_val_t* __eval_global (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_global (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	return STACK_GLOBAL(run,((sse_awk_nde_var_t*)nde)->id.idxa);
+	return STACK_GLOBAL(run,((ase_awk_nde_var_t*)nde)->id.idxa);
 }
 
-static sse_awk_val_t* __eval_local (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_local (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	return STACK_LOCAL(run,((sse_awk_nde_var_t*)nde)->id.idxa);
+	return STACK_LOCAL(run,((ase_awk_nde_var_t*)nde)->id.idxa);
 }
 
-static sse_awk_val_t* __eval_arg (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_arg (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	return STACK_ARG(run,((sse_awk_nde_var_t*)nde)->id.idxa);
+	return STACK_ARG(run,((ase_awk_nde_var_t*)nde)->id.idxa);
 }
 
-static sse_awk_val_t* __eval_indexed (
-	sse_awk_run_t* run, sse_awk_nde_var_t* nde, sse_awk_val_t** val)
+static ase_awk_val_t* __eval_indexed (
+	ase_awk_run_t* run, ase_awk_nde_var_t* nde, ase_awk_val_t** val)
 {
-	sse_awk_pair_t* pair;
-	sse_char_t* str;
-	sse_size_t len;
+	ase_awk_pair_t* pair;
+	ase_char_t* str;
+	ase_size_t len;
 
-	sse_awk_assert (run->awk, val != SSE_NULL);
+	ase_awk_assert (run->awk, val != ASE_NULL);
 
-	if ((*val)->type == SSE_AWK_VAL_NIL)
+	if ((*val)->type == ASE_AWK_VAL_NIL)
 	{
-		sse_awk_val_t* tmp;
+		ase_awk_val_t* tmp;
 
-		tmp = sse_awk_makemapval (run);
-		if (tmp == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
+		tmp = ase_awk_makemapval (run);
+		if (tmp == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 
-		sse_awk_refdownval (run, *val);
+		ase_awk_refdownval (run, *val);
 		*val = tmp;
-		sse_awk_refupval ((sse_awk_val_t*)*val);
+		ase_awk_refupval ((ase_awk_val_t*)*val);
 	}
-	else if ((*val)->type != SSE_AWK_VAL_MAP) 
+	else if ((*val)->type != ASE_AWK_VAL_MAP) 
 	{
-	        PANIC (run, SSE_AWK_ENOTINDEXABLE);
+	        PANIC (run, ASE_AWK_ENOTINDEXABLE);
 	}
 
-	sse_awk_assert (run->awk, nde->idx != SSE_NULL);
+	ase_awk_assert (run->awk, nde->idx != ASE_NULL);
 
 	str = __idxnde_to_str (run, nde->idx, &len);
-	if (str == SSE_NULL) return SSE_NULL;
+	if (str == ASE_NULL) return ASE_NULL;
 
-	pair = sse_awk_map_get ((*(sse_awk_val_map_t**)val)->map, str, len);
-	SSE_AWK_FREE (run->awk, str);
+	pair = ase_awk_map_get ((*(ase_awk_val_map_t**)val)->map, str, len);
+	ASE_AWK_FREE (run->awk, str);
 
-	return (pair == SSE_NULL)? sse_awk_val_nil: (sse_awk_val_t*)pair->val;
+	return (pair == ASE_NULL)? ase_awk_val_nil: (ase_awk_val_t*)pair->val;
 }
 
-static sse_awk_val_t* __eval_namedidx (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_namedidx (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	sse_awk_nde_var_t* tgt = (sse_awk_nde_var_t*)nde;
-	sse_awk_pair_t* pair;
+	ase_awk_nde_var_t* tgt = (ase_awk_nde_var_t*)nde;
+	ase_awk_pair_t* pair;
 
-	pair = sse_awk_map_get (&run->named, tgt->id.name, tgt->id.name_len);
-	if (pair == SSE_NULL)
+	pair = ase_awk_map_get (&run->named, tgt->id.name, tgt->id.name_len);
+	if (pair == ASE_NULL)
 	{
-		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);
+		pair = ase_awk_map_put (&run->named, 
+			tgt->id.name, tgt->id.name_len, ase_awk_val_nil);
+		if (pair == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 
-		sse_awk_refupval (pair->val); 
+		ase_awk_refupval (pair->val); 
 	}
 
-	return __eval_indexed (run, tgt, (sse_awk_val_t**)&pair->val);
+	return __eval_indexed (run, tgt, (ase_awk_val_t**)&pair->val);
 }
 
-static sse_awk_val_t* __eval_globalidx (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_globalidx (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	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));
+	return __eval_indexed (run, (ase_awk_nde_var_t*)nde, 
+		(ase_awk_val_t**)&STACK_GLOBAL(run,((ase_awk_nde_var_t*)nde)->id.idxa));
 }
 
-static sse_awk_val_t* __eval_localidx (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_localidx (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	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));
+	return __eval_indexed (run, (ase_awk_nde_var_t*)nde, 
+		(ase_awk_val_t**)&STACK_LOCAL(run,((ase_awk_nde_var_t*)nde)->id.idxa));
 }
 
-static sse_awk_val_t* __eval_argidx (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_argidx (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	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));
+	return __eval_indexed (run, (ase_awk_nde_var_t*)nde,
+		(ase_awk_val_t**)&STACK_ARG(run,((ase_awk_nde_var_t*)nde)->id.idxa));
 }
 
-static sse_awk_val_t* __eval_pos (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_pos (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	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;
+	ase_awk_nde_pos_t* pos = (ase_awk_nde_pos_t*)nde;
+	ase_awk_val_t* v;
+	ase_long_t lv;
+	ase_real_t rv;
 	int n;
 
 	v = __eval_expression (run, pos->val);
-	if (v == SSE_NULL) return SSE_NULL;
+	if (v == ASE_NULL) return ASE_NULL;
 
-	sse_awk_refupval (v);
-	n = sse_awk_valtonum (run, v, &lv, &rv);
-	sse_awk_refdownval (run, v);
+	ase_awk_refupval (v);
+	n = ase_awk_valtonum (run, v, &lv, &rv);
+	ase_awk_refdownval (run, v);
 
-	if (n == -1) PANIC (run, SSE_AWK_EPOSIDX);
-	if (n == 1) lv = (sse_long_t)rv;
+	if (n == -1) PANIC (run, ASE_AWK_EPOSIDX);
+	if (n == 1) lv = (ase_long_t)rv;
 
-	if (lv < 0) PANIC (run, SSE_AWK_EPOSIDX);
+	if (lv < 0) PANIC (run, ASE_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 = sse_awk_val_zls; /*sse_awk_val_nil;*/
+	else v = ase_awk_val_zls; /*ase_awk_val_nil;*/
 
 	return v;
 }
 
-static sse_awk_val_t* __eval_getline (sse_awk_run_t* run, sse_awk_nde_t* nde)
+static ase_awk_val_t* __eval_getline (ase_awk_run_t* run, ase_awk_nde_t* nde)
 {
-	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;
+	ase_awk_nde_getline_t* p;
+	ase_awk_val_t* v, * res;
+	ase_char_t* in = ASE_NULL;
+	const ase_char_t* dst;
+	ase_awk_str_t buf;
 	int n;
 
-	p = (sse_awk_nde_getline_t*)nde;
+	p = (ase_awk_nde_getline_t*)nde;
 
-	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));
+	ase_awk_assert (run->awk, (p->in_type == ASE_AWK_IN_PIPE && p->in != ASE_NULL) ||
+	           (p->in_type == ASE_AWK_IN_COPROC && p->in != ASE_NULL) ||
+		   (p->in_type == ASE_AWK_IN_FILE && p->in != ASE_NULL) ||
+	           (p->in_type == ASE_AWK_IN_CONSOLE && p->in == ASE_NULL));
 
-	if (p->in != SSE_NULL)
+	if (p->in != ASE_NULL)
 	{
-		sse_size_t len;
+		ase_size_t len;
 
 		v = __eval_expression (run, p->in);
-		if (v == SSE_NULL) return SSE_NULL;
+		if (v == ASE_NULL) return ASE_NULL;
 
-		/* TODO: distinction between v->type == SSE_AWK_VAL_STR 
-		 *       and v->type != SSE_AWK_VAL_STR
+		/* TODO: distinction between v->type == ASE_AWK_VAL_STR 
+		 *       and v->type != ASE_AWK_VAL_STR
 		 *       if you use the buffer the v directly when
-		 *       v->type == SSE_AWK_VAL_STR, sse_awk_refdownval(v)
+		 *       v->type == ASE_AWK_VAL_STR, ase_awk_refdownval(v)
 		 *       should not be called immediately below */
-		sse_awk_refupval (v);
-		in = sse_awk_valtostr (
-			run, v, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &len);
-		if (in == SSE_NULL) 
+		ase_awk_refupval (v);
+		in = ase_awk_valtostr (
+			run, v, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &len);
+		if (in == ASE_NULL) 
 		{
-			sse_awk_refdownval (run, v);
-			return SSE_NULL;
+			ase_awk_refdownval (run, v);
+			return ASE_NULL;
 		}
-		sse_awk_refdownval (run, v);
+		ase_awk_refdownval (run, v);
 
 		if (len <= 0) 
 		{
 			/* the input source name is empty.
 			 * make getline return -1 */
-			SSE_AWK_FREE (run->awk, in);
+			ASE_AWK_FREE (run->awk, in);
 			n = -1;
 			goto skip_read;
 		}
 
 		while (len > 0)
 		{
-			if (in[--len] == SSE_T('\0'))
+			if (in[--len] == ASE_T('\0'))
 			{
 				/* the input source name contains a null 
 				 * character. make getline return -1 */
 				/* TODO: set ERRNO */
-				SSE_AWK_FREE (run->awk, in);
+				ASE_AWK_FREE (run->awk, in);
 				n = -1;
 				goto skip_read;
 			}
 		}
 	}
 
-	dst = (in == SSE_NULL)? SSE_T(""): in;
+	dst = (in == ASE_NULL)? ASE_T(""): in;
 
 	/* TODO: optimize the line buffer management */
-	if (sse_awk_str_open (&buf, DEF_BUF_CAPA, run->awk) == SSE_NULL)
+	if (ase_awk_str_open (&buf, DEF_BUF_CAPA, run->awk) == ASE_NULL)
 	{
-		if (in != SSE_NULL) SSE_AWK_FREE (run->awk, in);
-		PANIC (run, SSE_AWK_ENOMEM);
+		if (in != ASE_NULL) ASE_AWK_FREE (run->awk, in);
+		PANIC (run, ASE_AWK_ENOMEM);
 	}
 
-	n = sse_awk_readextio (run, p->in_type, dst, &buf);
-	if (in != SSE_NULL) SSE_AWK_FREE (run->awk, in);
+	n = ase_awk_readextio (run, p->in_type, dst, &buf);
+	if (in != ASE_NULL) ASE_AWK_FREE (run->awk, in);
 
 	if (n < 0) 
 	{
-		if (run->errnum != SSE_AWK_EIOHANDLER)
+		if (run->errnum != ASE_AWK_EIOHANDLER)
 		{
-			sse_awk_str_close (&buf);
-			return SSE_NULL;
+			ase_awk_str_close (&buf);
+			return ASE_NULL;
 		}
 
-		/* if run->errnum == SSE_AWK_EIOHANDLER, 
+		/* if run->errnum == ASE_AWK_EIOHANDLER, 
 		 * make getline return -1 */
 		n = -1;
 	}
 
 	if (n > 0)
 	{
-		if (p->var == SSE_NULL)
+		if (p->var == ASE_NULL)
 		{
 			/* set $0 with the input value */
-			if (sse_awk_setrec (run, 0,
-				SSE_AWK_STR_BUF(&buf),
-				SSE_AWK_STR_LEN(&buf)) == -1)
+			if (ase_awk_setrec (run, 0,
+				ASE_AWK_STR_BUF(&buf),
+				ASE_AWK_STR_LEN(&buf)) == -1)
 			{
-				sse_awk_str_close (&buf);
-				return SSE_NULL;
+				ase_awk_str_close (&buf);
+				return ASE_NULL;
 			}
 
-			sse_awk_str_close (&buf);
+			ase_awk_str_close (&buf);
 		}
 		else
 		{
-			sse_awk_val_t* v;
+			ase_awk_val_t* v;
 
-			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);
+			v = ase_awk_makestrval (
+				run, ASE_AWK_STR_BUF(&buf), ASE_AWK_STR_LEN(&buf));
+			ase_awk_str_close (&buf);
+			if (v == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 
-			sse_awk_refupval (v);
-			if (__do_assignment(run, p->var, v) == SSE_NULL)
+			ase_awk_refupval (v);
+			if (__do_assignment(run, p->var, v) == ASE_NULL)
 			{
-				sse_awk_refdownval (run, v);
-				return SSE_NULL;
+				ase_awk_refdownval (run, v);
+				return ASE_NULL;
 			}
-			sse_awk_refdownval (run, v);
+			ase_awk_refdownval (run, v);
 		}
 	}
 	else
 	{
-		sse_awk_str_close (&buf);
+		ase_awk_str_close (&buf);
 	}
 	
 skip_read:
-	res = sse_awk_makeintval (run, n);
-	if (res == SSE_NULL) PANIC (run, SSE_AWK_ENOMEM);
+	res = ase_awk_makeintval (run, n);
+	if (res == ASE_NULL) PANIC (run, ASE_AWK_ENOMEM);
 
 	return res;
 }
 
-static int __raw_push (sse_awk_run_t* run, void* val)
+static int __raw_push (ase_awk_run_t* run, void* val)
 {
 	if (run->stack_top >= run->stack_limit)
 	{
 		void** tmp;
-		sse_size_t n;
+		ase_size_t n;
 	       
 		n = run->stack_limit + STACK_INCREMENT;
 
-		if (run->awk->syscas.realloc != SSE_NULL)
+		if (run->awk->syscas.realloc != ASE_NULL)
 		{
-			tmp = (void**) SSE_AWK_REALLOC (
-				run->awk, run->stack, n * sse_sizeof(void*)); 
-			if (tmp == SSE_NULL) return -1;
+			tmp = (void**) ASE_AWK_REALLOC (
+				run->awk, run->stack, n * ase_sizeof(void*)); 
+			if (tmp == ASE_NULL) return -1;
 		}
 		else
 		{
-			tmp = (void**) SSE_AWK_MALLOC (
-				run->awk, n * sse_sizeof(void*));
-			if (tmp == SSE_NULL) return -1;
-			if (run->stack != SSE_NULL)
+			tmp = (void**) ASE_AWK_MALLOC (
+				run->awk, n * ase_sizeof(void*));
+			if (tmp == ASE_NULL) return -1;
+			if (run->stack != ASE_NULL)
 			{
-				SSE_AWK_MEMCPY (run->awk, tmp, run->stack, 
-					run->stack_limit * sse_sizeof(void*)); 
-				SSE_AWK_FREE (run->awk, run->stack);
+				ASE_AWK_MEMCPY (run->awk, tmp, run->stack, 
+					run->stack_limit * ase_sizeof(void*)); 
+				ASE_AWK_FREE (run->awk, run->stack);
 			}
 		}
 		run->stack = tmp;
@@ -5030,7 +5030,7 @@ static int __raw_push (sse_awk_run_t* run, void* val)
 	return 0;
 }
 
-static void __raw_pop_times (sse_awk_run_t* run, sse_size_t times)
+static void __raw_pop_times (ase_awk_run_t* run, ase_size_t times)
 {
 	while (times > 0)
 	{
@@ -5039,206 +5039,206 @@ static void __raw_pop_times (sse_awk_run_t* run, sse_size_t times)
 	}
 }
 
-static int __read_record (sse_awk_run_t* run)
+static int __read_record (ase_awk_run_t* run)
 {
-	sse_ssize_t n;
+	ase_ssize_t n;
 
-	if (sse_awk_clrrec (run, sse_false) == -1) return -1;
+	if (ase_awk_clrrec (run, ase_false) == -1) return -1;
 
-	n = sse_awk_readextio (
-		run, SSE_AWK_IN_CONSOLE, SSE_T(""), &run->inrec.line);
+	n = ase_awk_readextio (
+		run, ASE_AWK_IN_CONSOLE, ASE_T(""), &run->inrec.line);
 	if (n < 0) 
 	{
 		int errnum = run->errnum;
-		sse_awk_clrrec (run, sse_false);
+		ase_awk_clrrec (run, ase_false);
 		run->errnum = 
-			(errnum == SSE_AWK_EIOHANDLER)? 
-			SSE_AWK_ECONINDATA: errnum;
+			(errnum == ASE_AWK_EIOHANDLER)? 
+			ASE_AWK_ECONINDATA: errnum;
 		return -1;
 	}
 /*
-xp_printf (SSE_T("len = %d str=[%s]\n"), 
-		(int)SSE_AWK_STR_LEN(&run->inrec.line),
-		SSE_AWK_STR_BUF(&run->inrec.line));
+xp_printf (ASE_T("len = %d str=[%s]\n"), 
+		(int)ASE_AWK_STR_LEN(&run->inrec.line),
+		ASE_AWK_STR_BUF(&run->inrec.line));
 */
 	if (n == 0) 
 	{
-		sse_awk_assert (run->awk, SSE_AWK_STR_LEN(&run->inrec.line) == 0);
+		ase_awk_assert (run->awk, ASE_AWK_STR_LEN(&run->inrec.line) == 0);
 		return 0;
 	}
 
-	if (sse_awk_setrec (run, 0, 
-		SSE_AWK_STR_BUF(&run->inrec.line), 
-		SSE_AWK_STR_LEN(&run->inrec.line)) == -1) return -1;
+	if (ase_awk_setrec (run, 0, 
+		ASE_AWK_STR_BUF(&run->inrec.line), 
+		ASE_AWK_STR_LEN(&run->inrec.line)) == -1) return -1;
 
 	return 1;
 }
 
-static int __shorten_record (sse_awk_run_t* run, sse_size_t nflds)
+static int __shorten_record (ase_awk_run_t* run, ase_size_t nflds)
 {
-	sse_awk_val_t* v;
-	sse_char_t* ofs_free = SSE_NULL, * ofs;
-	sse_size_t ofs_len, i;
-	sse_awk_str_t tmp;
+	ase_awk_val_t* v;
+	ase_char_t* ofs_free = ASE_NULL, * ofs;
+	ase_size_t ofs_len, i;
+	ase_awk_str_t tmp;
 
-	sse_awk_assert (run->awk, nflds <= run->inrec.nflds);
+	ase_awk_assert (run->awk, nflds <= run->inrec.nflds);
 
 	if (nflds > 1)
 	{
-		v = STACK_GLOBAL(run, SSE_AWK_GLOBAL_OFS);
-		sse_awk_refupval (v);
+		v = STACK_GLOBAL(run, ASE_AWK_GLOBAL_OFS);
+		ase_awk_refupval (v);
 
-		if (v->type == SSE_AWK_VAL_NIL)
+		if (v->type == ASE_AWK_VAL_NIL)
 		{
 			/* OFS not set */
-			ofs = SSE_T(" ");
+			ofs = ASE_T(" ");
 			ofs_len = 1;
 		}
-		else if (v->type == SSE_AWK_VAL_STR)
+		else if (v->type == ASE_AWK_VAL_STR)
 		{
-			ofs = ((sse_awk_val_str_t*)v)->buf;
-			ofs_len = ((sse_awk_val_str_t*)v)->len;
+			ofs = ((ase_awk_val_str_t*)v)->buf;
+			ofs_len = ((ase_awk_val_str_t*)v)->len;
 		}
 		else
 		{
-			ofs = sse_awk_valtostr (
-				run, v, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, &ofs_len);
-			if (ofs == SSE_NULL) return -1;
+			ofs = ase_awk_valtostr (
+				run, v, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, &ofs_len);
+			if (ofs == ASE_NULL) return -1;
 
 			ofs_free = ofs;
 		}
 	}
 
-	if (sse_awk_str_open (&tmp, 
-		SSE_AWK_STR_LEN(&run->inrec.line), run->awk) == SSE_NULL)
+	if (ase_awk_str_open (&tmp, 
+		ASE_AWK_STR_LEN(&run->inrec.line), run->awk) == ASE_NULL)
 	{
-		run->errnum = SSE_AWK_ENOMEM;
+		run->errnum = ASE_AWK_ENOMEM;
 		return -1;
 	}
 
 	for (i = 0; i < nflds; i++)
 	{
-		if (i > 0 && sse_awk_str_ncat (&tmp, ofs, ofs_len) == (sse_size_t)-1)
+		if (i > 0 && ase_awk_str_ncat (&tmp, ofs, ofs_len) == (ase_size_t)-1)
 		{
-			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;
+			if (ofs_free != ASE_NULL) 
+				ASE_AWK_FREE (run->awk, ofs_free);
+			if (nflds > 1) ase_awk_refdownval (run, v);
+			run->errnum = ASE_AWK_ENOMEM;
 			return -1;
 		}
 
-		if (sse_awk_str_ncat (&tmp, 
+		if (ase_awk_str_ncat (&tmp, 
 			run->inrec.flds[i].ptr, 
-			run->inrec.flds[i].len) == (sse_size_t)-1)
+			run->inrec.flds[i].len) == (ase_size_t)-1)
 		{
-			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;
+			if (ofs_free != ASE_NULL) 
+				ASE_AWK_FREE (run->awk, ofs_free);
+			if (nflds > 1) ase_awk_refdownval (run, v);
+			run->errnum = ASE_AWK_ENOMEM;
 			return -1;
 		}
 	}
 
-	if (ofs_free != SSE_NULL) SSE_AWK_FREE (run->awk, ofs_free);
-	if (nflds > 1) sse_awk_refdownval (run, v);
+	if (ofs_free != ASE_NULL) ASE_AWK_FREE (run->awk, ofs_free);
+	if (nflds > 1) ase_awk_refdownval (run, v);
 
-	v = (sse_awk_val_t*) sse_awk_makestrval (
-		run, SSE_AWK_STR_BUF(&tmp), SSE_AWK_STR_LEN(&tmp));
-	if (v == SSE_NULL)
+	v = (ase_awk_val_t*) ase_awk_makestrval (
+		run, ASE_AWK_STR_BUF(&tmp), ASE_AWK_STR_LEN(&tmp));
+	if (v == ASE_NULL)
 	{
-		run->errnum = SSE_AWK_ENOMEM;
+		run->errnum = ASE_AWK_ENOMEM;
 		return -1;
 	}
 
-	sse_awk_refdownval (run, run->inrec.d0);
+	ase_awk_refdownval (run, run->inrec.d0);
 	run->inrec.d0 = v;
-	sse_awk_refupval (run->inrec.d0);
+	ase_awk_refupval (run->inrec.d0);
 
-	sse_awk_str_swap (&tmp, &run->inrec.line);
-	sse_awk_str_close (&tmp);
+	ase_awk_str_swap (&tmp, &run->inrec.line);
+	ase_awk_str_close (&tmp);
 
 	for (i = nflds; i < run->inrec.nflds; i++)
 	{
-		sse_awk_refdownval (run, run->inrec.flds[i].val);
+		ase_awk_refdownval (run, run->inrec.flds[i].val);
 	}
 
 	run->inrec.nflds = nflds;
 	return 0;
 }
 
-static sse_char_t* __idxnde_to_str (
-	sse_awk_run_t* run, sse_awk_nde_t* nde, sse_size_t* len)
+static ase_char_t* __idxnde_to_str (
+	ase_awk_run_t* run, ase_awk_nde_t* nde, ase_size_t* len)
 {
-	sse_char_t* str;
-	sse_awk_val_t* idx;
+	ase_char_t* str;
+	ase_awk_val_t* idx;
 
-	sse_awk_assert (run->awk, nde != SSE_NULL);
+	ase_awk_assert (run->awk, nde != ASE_NULL);
 
-	if (nde->next == SSE_NULL)
+	if (nde->next == ASE_NULL)
 	{
 		/* single node index */
 		idx = __eval_expression (run, nde);
-		if (idx == SSE_NULL) return SSE_NULL;
+		if (idx == ASE_NULL) return ASE_NULL;
 
-		sse_awk_refupval (idx);
+		ase_awk_refupval (idx);
 
-		str = sse_awk_valtostr (
-			run, idx, SSE_AWK_VALTOSTR_CLEAR, SSE_NULL, len);
-		if (str == SSE_NULL) 
+		str = ase_awk_valtostr (
+			run, idx, ASE_AWK_VALTOSTR_CLEAR, ASE_NULL, len);
+		if (str == ASE_NULL) 
 		{
-			sse_awk_refdownval (run, idx);
-			return SSE_NULL;
+			ase_awk_refdownval (run, idx);
+			return ASE_NULL;
 		}
 
-		sse_awk_refdownval (run, idx);
+		ase_awk_refdownval (run, idx);
 	}
 	else
 	{
 		/* multidimensional index */
-		sse_awk_str_t idxstr;
+		ase_awk_str_t idxstr;
 
-		if (sse_awk_str_open (
-			&idxstr, DEF_BUF_CAPA, run->awk) == SSE_NULL) 
+		if (ase_awk_str_open (
+			&idxstr, DEF_BUF_CAPA, run->awk) == ASE_NULL) 
 		{
-			PANIC (run, SSE_AWK_ENOMEM);
+			PANIC (run, ASE_AWK_ENOMEM);
 		}
 
-		while (nde != SSE_NULL)
+		while (nde != ASE_NULL)
 		{
 			idx = __eval_expression (run, nde);
-			if (idx == SSE_NULL) 
+			if (idx == ASE_NULL) 
 			{
-				sse_awk_str_close (&idxstr);
-				return SSE_NULL;
+				ase_awk_str_close (&idxstr);
+				return ASE_NULL;
 			}
 
-			sse_awk_refupval (idx);
+			ase_awk_refupval (idx);
 
-			if (SSE_AWK_STR_LEN(&idxstr) > 0 &&
-			    sse_awk_str_ncat (&idxstr, 
+			if (ASE_AWK_STR_LEN(&idxstr) > 0 &&
+			    ase_awk_str_ncat (&idxstr, 
 			    	run->global.subsep.ptr, 
-			    	run->global.subsep.len) == (sse_size_t)-1)
+			    	run->global.subsep.len) == (ase_size_t)-1)
 			{
-				sse_awk_refdownval (run, idx);
-				sse_awk_str_close (&idxstr);
-				PANIC (run, SSE_AWK_ENOMEM);
+				ase_awk_refdownval (run, idx);
+				ase_awk_str_close (&idxstr);
+				PANIC (run, ASE_AWK_ENOMEM);
 			}
 
-			if (sse_awk_valtostr (
-				run, idx, 0, &idxstr, SSE_NULL) == SSE_NULL)
+			if (ase_awk_valtostr (
+				run, idx, 0, &idxstr, ASE_NULL) == ASE_NULL)
 			{
-				sse_awk_refdownval (run, idx);
-				sse_awk_str_close (&idxstr);
-				return SSE_NULL;
+				ase_awk_refdownval (run, idx);
+				ase_awk_str_close (&idxstr);
+				return ASE_NULL;
 			}
 
-			sse_awk_refdownval (run, idx);
+			ase_awk_refdownval (run, idx);
 			nde = nde->next;
 		}
 
-		str = SSE_AWK_STR_BUF(&idxstr);
-		*len = SSE_AWK_STR_LEN(&idxstr);
-		sse_awk_str_forfeit (&idxstr);
+		str = ASE_AWK_STR_BUF(&idxstr);
+		*len = ASE_AWK_STR_LEN(&idxstr);
+		ase_awk_str_forfeit (&idxstr);
 	}
 
 	return str;
diff --git a/ase/awk/run.h b/ase/awk/run.h
index c1c877da..45d88daa 100644
--- a/ase/awk/run.h
+++ b/ase/awk/run.h
@@ -1,103 +1,103 @@
 /*
- * $Id: run.h,v 1.20 2006-10-22 12:39:30 bacon Exp $
+ * $Id: run.h,v 1.21 2006-10-24 04:10:12 bacon Exp $
  */
 
-#ifndef _SSE_AWK_RUN_H_
-#define _SSE_AWK_RUN_H_
+#ifndef _ASE_AWK_RUN_H_
+#define _ASE_AWK_RUN_H_
 
-#ifndef _SSE_AWK_AWK_H_
-#error Never include this file directly. Include <sse/awk/awk.h> instead
+#ifndef _ASE_AWK_AWK_H_
+#error Never include this file directly. Include <ase/awk/awk.h> instead
 #endif
 
 enum
 {
 	/* if you change this, you have to change __assop_str in tree.c */
-	SSE_AWK_ASSOP_NONE,
-	SSE_AWK_ASSOP_PLUS,
-	SSE_AWK_ASSOP_MINUS,
-	SSE_AWK_ASSOP_MUL,
-	SSE_AWK_ASSOP_DIV,
-	SSE_AWK_ASSOP_MOD,
-	SSE_AWK_ASSOP_EXP
+	ASE_AWK_ASSOP_NONE,
+	ASE_AWK_ASSOP_PLUS,
+	ASE_AWK_ASSOP_MINUS,
+	ASE_AWK_ASSOP_MUL,
+	ASE_AWK_ASSOP_DIV,
+	ASE_AWK_ASSOP_MOD,
+	ASE_AWK_ASSOP_EXP
 };
 
 enum 
 {
 	/* if you change this, you have to change 
 	 * __binop_str in tree.c and __binop_func in run.c accordingly. */ 
-	SSE_AWK_BINOP_LOR,
-	SSE_AWK_BINOP_LAND,
-	SSE_AWK_BINOP_IN,
+	ASE_AWK_BINOP_LOR,
+	ASE_AWK_BINOP_LAND,
+	ASE_AWK_BINOP_IN,
 
-	SSE_AWK_BINOP_BOR,
-	SSE_AWK_BINOP_BXOR,
-	SSE_AWK_BINOP_BAND,
+	ASE_AWK_BINOP_BOR,
+	ASE_AWK_BINOP_BXOR,
+	ASE_AWK_BINOP_BAND,
 
-	SSE_AWK_BINOP_EQ,
-	SSE_AWK_BINOP_NE,
-	SSE_AWK_BINOP_GT,
-	SSE_AWK_BINOP_GE,
-	SSE_AWK_BINOP_LT,
-	SSE_AWK_BINOP_LE,
+	ASE_AWK_BINOP_EQ,
+	ASE_AWK_BINOP_NE,
+	ASE_AWK_BINOP_GT,
+	ASE_AWK_BINOP_GE,
+	ASE_AWK_BINOP_LT,
+	ASE_AWK_BINOP_LE,
 
-	SSE_AWK_BINOP_LSHIFT,
-	SSE_AWK_BINOP_RSHIFT,
+	ASE_AWK_BINOP_LSHIFT,
+	ASE_AWK_BINOP_RSHIFT,
 
-	SSE_AWK_BINOP_PLUS,
-	SSE_AWK_BINOP_MINUS,
-	SSE_AWK_BINOP_MUL,
-	SSE_AWK_BINOP_DIV,
-	SSE_AWK_BINOP_MOD,
-	SSE_AWK_BINOP_EXP,
+	ASE_AWK_BINOP_PLUS,
+	ASE_AWK_BINOP_MINUS,
+	ASE_AWK_BINOP_MUL,
+	ASE_AWK_BINOP_DIV,
+	ASE_AWK_BINOP_MOD,
+	ASE_AWK_BINOP_EXP,
 
-	SSE_AWK_BINOP_CONCAT,
-	SSE_AWK_BINOP_MA,
-	SSE_AWK_BINOP_NM
+	ASE_AWK_BINOP_CONCAT,
+	ASE_AWK_BINOP_MA,
+	ASE_AWK_BINOP_NM
 };
 
 enum
 {
 	/* if you change this, you have to change 
 	 * __unrop_str in tree.c accordingly. */ 
-	SSE_AWK_UNROP_PLUS,
-	SSE_AWK_UNROP_MINUS,
-	SSE_AWK_UNROP_NOT,
-	SSE_AWK_UNROP_BNOT
+	ASE_AWK_UNROP_PLUS,
+	ASE_AWK_UNROP_MINUS,
+	ASE_AWK_UNROP_NOT,
+	ASE_AWK_UNROP_BNOT
 };
 
 enum
 {
 	/* if you change this, you have to change 
 	 * __incop_str in tree.c accordingly. */ 
-	SSE_AWK_INCOP_PLUS,
-	SSE_AWK_INCOP_MINUS
+	ASE_AWK_INCOP_PLUS,
+	ASE_AWK_INCOP_MINUS
 };
 
 enum
 {
 	/* this table should match __bvtab in parse.c.
-	 * in addition, sse_awk_setglobal also counts 
+	 * in addition, ase_awk_setglobal also counts 
 	 * on the order of these values */
 
-	SSE_AWK_GLOBAL_ARGC,
-	SSE_AWK_GLOBAL_ARGV,
-	SSE_AWK_GLOBAL_CONVFMT,
-	SSE_AWK_GLOBAL_ENVIRON,
-	SSE_AWK_GLOBAL_ERRNO,
-	SSE_AWK_GLOBAL_FILENAME,
-	SSE_AWK_GLOBAL_FNR,
-	SSE_AWK_GLOBAL_FS,
-	SSE_AWK_GLOBAL_IGNORECASE,
-	SSE_AWK_GLOBAL_NF,
-	SSE_AWK_GLOBAL_NR,
-	SSE_AWK_GLOBAL_OFMT,
-	SSE_AWK_GLOBAL_OFS,
-	SSE_AWK_GLOBAL_ORS,
-	SSE_AWK_GLOBAL_RS,
-	SSE_AWK_GLOBAL_RT,
-	SSE_AWK_GLOBAL_RSTART,
-	SSE_AWK_GLOBAL_RLENGTH,
-	SSE_AWK_GLOBAL_SUBSEP
+	ASE_AWK_GLOBAL_ARGC,
+	ASE_AWK_GLOBAL_ARGV,
+	ASE_AWK_GLOBAL_CONVFMT,
+	ASE_AWK_GLOBAL_ENVIRON,
+	ASE_AWK_GLOBAL_ERRNO,
+	ASE_AWK_GLOBAL_FILENAME,
+	ASE_AWK_GLOBAL_FNR,
+	ASE_AWK_GLOBAL_FS,
+	ASE_AWK_GLOBAL_IGNORECASE,
+	ASE_AWK_GLOBAL_NF,
+	ASE_AWK_GLOBAL_NR,
+	ASE_AWK_GLOBAL_OFMT,
+	ASE_AWK_GLOBAL_OFS,
+	ASE_AWK_GLOBAL_ORS,
+	ASE_AWK_GLOBAL_RS,
+	ASE_AWK_GLOBAL_RT,
+	ASE_AWK_GLOBAL_RSTART,
+	ASE_AWK_GLOBAL_RLENGTH,
+	ASE_AWK_GLOBAL_SUBSEP
 };
 
 #endif
diff --git a/ase/awk/str.c b/ase/awk/str.c
index fe2b6961..65a3624a 100644
--- a/ase/awk/str.c
+++ b/ase/awk/str.c
@@ -1,51 +1,51 @@
 /*
- * $Id: str.c,v 1.10 2006-10-22 12:52:50 bacon Exp $
+ * $Id: str.c,v 1.11 2006-10-24 04:10:12 bacon Exp $
  */
 
-#include <sse/awk/awk_i.h>
+#include <ase/awk/awk_i.h>
 
-sse_awk_str_t* sse_awk_str_open (
-	sse_awk_str_t* str, sse_size_t capa, sse_awk_t* awk)
+ase_awk_str_t* ase_awk_str_open (
+	ase_awk_str_t* str, ase_size_t capa, ase_awk_t* awk)
 {
-	if (str == SSE_NULL) 
+	if (str == ASE_NULL) 
 	{
-		str = (sse_awk_str_t*) 
-			SSE_AWK_MALLOC (awk, sizeof(sse_awk_str_t));
-		if (str == SSE_NULL) return SSE_NULL;
-		str->__dynamic = sse_true;
+		str = (ase_awk_str_t*) 
+			ASE_AWK_MALLOC (awk, sizeof(ase_awk_str_t));
+		if (str == ASE_NULL) return ASE_NULL;
+		str->__dynamic = ase_true;
 	}
-	else str->__dynamic = sse_false;
+	else str->__dynamic = ase_false;
 
 	str->awk = awk;
-	str->buf = (sse_char_t*) SSE_AWK_MALLOC (
-		awk, sse_sizeof(sse_char_t) * (capa + 1));
-	if (str->buf == SSE_NULL) 
+	str->buf = (ase_char_t*) ASE_AWK_MALLOC (
+		awk, ase_sizeof(ase_char_t) * (capa + 1));
+	if (str->buf == ASE_NULL) 
 	{
-		if (str->__dynamic) SSE_AWK_FREE (awk, str);
-		return SSE_NULL;
+		if (str->__dynamic) ASE_AWK_FREE (awk, str);
+		return ASE_NULL;
 	}
 
 	str->size = 0;
 	str->capa  = capa;
-	str->buf[0] = SSE_T('\0');
+	str->buf[0] = ASE_T('\0');
 
 	return str;
 }
 
-void sse_awk_str_close (sse_awk_str_t* str)
+void ase_awk_str_close (ase_awk_str_t* str)
 {
-	SSE_AWK_FREE (str->awk, str->buf);
-	if (str->__dynamic) SSE_AWK_FREE (str->awk, str);
+	ASE_AWK_FREE (str->awk, str->buf);
+	if (str->__dynamic) ASE_AWK_FREE (str->awk, str);
 }
 
-void sse_awk_str_forfeit (sse_awk_str_t* str)
+void ase_awk_str_forfeit (ase_awk_str_t* str)
 {
-	if (str->__dynamic) SSE_AWK_FREE (str->awk, str);
+	if (str->__dynamic) ASE_AWK_FREE (str->awk, str);
 }
 
-void sse_awk_str_swap (sse_awk_str_t* str, sse_awk_str_t* str1)
+void ase_awk_str_swap (ase_awk_str_t* str, ase_awk_str_t* str1)
 {
-	sse_awk_str_t tmp;
+	ase_awk_str_t tmp;
 
 	tmp.buf = str->buf;
 	tmp.size = str->size;
@@ -63,69 +63,69 @@ void sse_awk_str_swap (sse_awk_str_t* str, sse_awk_str_t* str1)
 	str1->awk = tmp.awk;
 }
 
-sse_size_t sse_awk_str_cpy (sse_awk_str_t* str, const sse_char_t* s)
+ase_size_t ase_awk_str_cpy (ase_awk_str_t* str, const ase_char_t* s)
 {
 	/* TODO: improve it */
-	return sse_awk_str_ncpy (str, s, sse_awk_strlen(s));
+	return ase_awk_str_ncpy (str, s, ase_awk_strlen(s));
 }
 
-sse_size_t sse_awk_str_ncpy (
-	sse_awk_str_t* str, const sse_char_t* s, sse_size_t len)
+ase_size_t ase_awk_str_ncpy (
+	ase_awk_str_t* str, const ase_char_t* s, ase_size_t len)
 {
-	sse_char_t* buf;
+	ase_char_t* buf;
 
 	if (len > str->capa) 
 	{
-		buf = (sse_char_t*) SSE_AWK_MALLOC (
-			str->awk, sse_sizeof(sse_char_t) * (len + 1));
-		if (buf == SSE_NULL) return (sse_size_t)-1;
+		buf = (ase_char_t*) ASE_AWK_MALLOC (
+			str->awk, ase_sizeof(ase_char_t) * (len + 1));
+		if (buf == ASE_NULL) return (ase_size_t)-1;
 
-		SSE_AWK_FREE (str->awk, str->buf);
+		ASE_AWK_FREE (str->awk, str->buf);
 		str->capa = len;
 		str->buf = buf;
 	}
 
-	str->size = sse_awk_strncpy (str->buf, s, len);
-	str->buf[str->size] = SSE_T('\0');
+	str->size = ase_awk_strncpy (str->buf, s, len);
+	str->buf[str->size] = ASE_T('\0');
 	return str->size;
 }
 
-sse_size_t sse_awk_str_cat (sse_awk_str_t* str, const sse_char_t* s)
+ase_size_t ase_awk_str_cat (ase_awk_str_t* str, const ase_char_t* s)
 {
 	/* TODO: improve it */
-	return sse_awk_str_ncat (str, s, sse_awk_strlen(s));
+	return ase_awk_str_ncat (str, s, ase_awk_strlen(s));
 }
 
-sse_size_t sse_awk_str_ncat (
-	sse_awk_str_t* str, const sse_char_t* s, sse_size_t len)
+ase_size_t ase_awk_str_ncat (
+	ase_awk_str_t* str, const ase_char_t* s, ase_size_t len)
 {
 	if (len > str->capa - str->size) 
 	{
-		sse_char_t* tmp;
-		sse_size_t capa;
+		ase_char_t* tmp;
+		ase_size_t capa;
 
 		capa = str->size + len;
 
 		/* double the capa if necessary for concatenation */
 		if (capa < str->capa * 2) capa = str->capa * 2;
 
-		if (str->awk->syscas.realloc != SSE_NULL)
+		if (str->awk->syscas.realloc != ASE_NULL)
 		{
-			tmp = (sse_char_t*) SSE_AWK_REALLOC (
+			tmp = (ase_char_t*) ASE_AWK_REALLOC (
 				str->awk, str->buf, 
-				sse_sizeof(sse_char_t) * (capa + 1));
-			if (tmp == SSE_NULL) return (sse_size_t)-1;
+				ase_sizeof(ase_char_t) * (capa + 1));
+			if (tmp == ASE_NULL) return (ase_size_t)-1;
 		}
 		else
 		{
-			tmp = (sse_char_t*) SSE_AWK_MALLOC (
-				str->awk, sse_sizeof(sse_char_t) * (capa + 1));
-			if (tmp == SSE_NULL) return (sse_size_t)-1;
-			if (str->buf != SSE_NULL)
+			tmp = (ase_char_t*) ASE_AWK_MALLOC (
+				str->awk, ase_sizeof(ase_char_t) * (capa + 1));
+			if (tmp == ASE_NULL) return (ase_size_t)-1;
+			if (str->buf != ASE_NULL)
 			{
-				SSE_AWK_MEMCPY (str->awk, tmp, str->buf, 
-					sse_sizeof(sse_char_t) * (str->capa + 1));
-				SSE_AWK_FREE (str->awk, str->buf);
+				ASE_AWK_MEMCPY (str->awk, tmp, str->buf, 
+					ase_sizeof(ase_char_t) * (str->capa + 1));
+				ASE_AWK_FREE (str->awk, str->buf);
 			}
 		}
 
@@ -133,23 +133,23 @@ sse_size_t sse_awk_str_ncat (
 		str->buf = tmp;
 	}
 
-	str->size += sse_awk_strncpy (&str->buf[str->size], s, len);
-	str->buf[str->size] = SSE_T('\0');
+	str->size += ase_awk_strncpy (&str->buf[str->size], s, len);
+	str->buf[str->size] = ASE_T('\0');
 	return str->size;
 }
 
-sse_size_t sse_awk_str_ccat (sse_awk_str_t* str, sse_char_t c)
+ase_size_t ase_awk_str_ccat (ase_awk_str_t* str, ase_char_t c)
 {
-	return sse_awk_str_ncat (str, &c, 1);
+	return ase_awk_str_ncat (str, &c, 1);
 }
 
-sse_size_t sse_awk_str_nccat (sse_awk_str_t* str, sse_char_t c, sse_size_t len)
+ase_size_t ase_awk_str_nccat (ase_awk_str_t* str, ase_char_t c, ase_size_t len)
 {
 	while (len > 0)
 	{
-		if (sse_awk_str_ncat (str, &c, 1) == (sse_size_t)-1) 
+		if (ase_awk_str_ncat (str, &c, 1) == (ase_size_t)-1) 
 		{
-			return (sse_size_t)-1;
+			return (ase_size_t)-1;
 		}
 
 		len--;
@@ -157,9 +157,9 @@ sse_size_t sse_awk_str_nccat (sse_awk_str_t* str, sse_char_t c, sse_size_t len)
 	return str->size;
 }
 
-void sse_awk_str_clear (sse_awk_str_t* str)
+void ase_awk_str_clear (ase_awk_str_t* str)
 {
 	str->size = 0;
-	str->buf[0] = SSE_T('\0');
+	str->buf[0] = ASE_T('\0');
 }
 
diff --git a/ase/awk/str.h b/ase/awk/str.h
index 7091ff43..6023b8a9 100644
--- a/ase/awk/str.h
+++ b/ase/awk/str.h
@@ -1,58 +1,58 @@
 /*
- * $Id: str.h,v 1.3 2006-10-22 11:34:53 bacon Exp $
+ * $Id: str.h,v 1.4 2006-10-24 04:10:12 bacon Exp $
  */
 
-#ifndef _SSE_AWK_STR_H_
-#define _SSE_AWK_STR_H_
+#ifndef _ASE_AWK_STR_H_
+#define _ASE_AWK_STR_H_
 
-#ifndef _SSE_AWK_AWK_H_
-#error Never include this file directly. Include <sse/awk/awk.h> instead
+#ifndef _ASE_AWK_AWK_H_
+#error Never include this file directly. Include <ase/awk/awk.h> instead
 #endif
 
-#define SSE_AWK_STR_LEN(x)  ((x)->size)
-#define SSE_AWK_STR_SIZE(x) ((x)->size + 1)
-#define SSE_AWK_STR_CAPA(x) ((x)->capa)
-#define SSE_AWK_STR_BUF(x)  ((x)->buf)
-#define SSE_AWK_STR_CHAR(x,idx) ((x)->buf[idx])
+#define ASE_AWK_STR_LEN(x)  ((x)->size)
+#define ASE_AWK_STR_SIZE(x) ((x)->size + 1)
+#define ASE_AWK_STR_CAPA(x) ((x)->capa)
+#define ASE_AWK_STR_BUF(x)  ((x)->buf)
+#define ASE_AWK_STR_CHAR(x,idx) ((x)->buf[idx])
 
-typedef struct sse_awk_str_t sse_awk_str_t;
+typedef struct ase_awk_str_t ase_awk_str_t;
 
-struct sse_awk_str_t
+struct ase_awk_str_t
 {
-	sse_char_t* buf;
-	sse_size_t size;
-	sse_size_t capa;
-	sse_awk_t* awk;
-	sse_bool_t __dynamic;
+	ase_char_t* buf;
+	ase_size_t size;
+	ase_size_t capa;
+	ase_awk_t* awk;
+	ase_bool_t __dynamic;
 };
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-sse_awk_str_t* sse_awk_str_open (
-	sse_awk_str_t* str, sse_size_t capa, sse_awk_t* awk);
+ase_awk_str_t* ase_awk_str_open (
+	ase_awk_str_t* str, ase_size_t capa, ase_awk_t* awk);
 
-void sse_awk_str_close (sse_awk_str_t* str);
+void ase_awk_str_close (ase_awk_str_t* str);
 
-void sse_awk_str_forfeit (sse_awk_str_t* str);
-void sse_awk_str_swap (sse_awk_str_t* str, sse_awk_str_t* str2);
+void ase_awk_str_forfeit (ase_awk_str_t* str);
+void ase_awk_str_swap (ase_awk_str_t* str, ase_awk_str_t* str2);
 
-sse_size_t sse_awk_str_cpy (sse_awk_str_t* str, const sse_char_t* s);
+ase_size_t ase_awk_str_cpy (ase_awk_str_t* str, const ase_char_t* s);
 
-sse_size_t sse_awk_str_ncpy (
-	sse_awk_str_t* str, const sse_char_t* s, sse_size_t len);
+ase_size_t ase_awk_str_ncpy (
+	ase_awk_str_t* str, const ase_char_t* s, ase_size_t len);
 
-sse_size_t sse_awk_str_cat (sse_awk_str_t* str, const sse_char_t* s);
+ase_size_t ase_awk_str_cat (ase_awk_str_t* str, const ase_char_t* s);
 
-sse_size_t sse_awk_str_ncat (
-	sse_awk_str_t* str, const sse_char_t* s, sse_size_t len);
+ase_size_t ase_awk_str_ncat (
+	ase_awk_str_t* str, const ase_char_t* s, ase_size_t len);
 
-sse_size_t sse_awk_str_ccat (sse_awk_str_t* str, sse_char_t c);
+ase_size_t ase_awk_str_ccat (ase_awk_str_t* str, ase_char_t c);
 
-sse_size_t sse_awk_str_nccat (sse_awk_str_t* str, sse_char_t c, sse_size_t len);
+ase_size_t ase_awk_str_nccat (ase_awk_str_t* str, ase_char_t c, ase_size_t len);
 
-void sse_awk_str_clear (sse_awk_str_t* str);
+void ase_awk_str_clear (ase_awk_str_t* str);
 
 #ifdef __cplusplus
 }
diff --git a/ase/awk/tab.c b/ase/awk/tab.c
index f6958452..c9415c36 100644
--- a/ase/awk/tab.c
+++ b/ase/awk/tab.c
@@ -1,89 +1,89 @@
 /*
- * $Id: tab.c,v 1.22 2006-10-22 11:34:53 bacon Exp $
+ * $Id: tab.c,v 1.23 2006-10-24 04:10:12 bacon Exp $
  */
 
-#include <sse/awk/awk_i.h>
+#include <ase/awk/awk_i.h>
 
-sse_awk_tab_t* sse_awk_tab_open (sse_awk_tab_t* tab, sse_awk_t* awk)
+ase_awk_tab_t* ase_awk_tab_open (ase_awk_tab_t* tab, ase_awk_t* awk)
 {
-	if (tab == SSE_NULL) 
+	if (tab == ASE_NULL) 
 	{
-		tab = (sse_awk_tab_t*) SSE_AWK_MALLOC (
-			awk, sse_sizeof(sse_awk_tab_t));
-		if (tab == SSE_NULL) return SSE_NULL;
-		tab->__dynamic = sse_true;
+		tab = (ase_awk_tab_t*) ASE_AWK_MALLOC (
+			awk, ase_sizeof(ase_awk_tab_t));
+		if (tab == ASE_NULL) return ASE_NULL;
+		tab->__dynamic = ase_true;
 	}
-	else tab->__dynamic = sse_false;
+	else tab->__dynamic = ase_false;
 
 	tab->awk = awk;
-	tab->buf = SSE_NULL;
+	tab->buf = ASE_NULL;
 	tab->size = 0;
 	tab->capa = 0;
 
 	return tab;
 }
 
-void sse_awk_tab_close (sse_awk_tab_t* tab)
+void ase_awk_tab_close (ase_awk_tab_t* tab)
 {
-	sse_awk_tab_clear (tab);
-	if (tab->buf != SSE_NULL) 
+	ase_awk_tab_clear (tab);
+	if (tab->buf != ASE_NULL) 
 	{
-		SSE_AWK_FREE (tab->awk, tab->buf);
-		tab->buf = SSE_NULL;
+		ASE_AWK_FREE (tab->awk, tab->buf);
+		tab->buf = ASE_NULL;
 		tab->capa = 0;
 	}
 
-	if (tab->__dynamic) SSE_AWK_FREE (tab->awk, tab);
+	if (tab->__dynamic) ASE_AWK_FREE (tab->awk, tab);
 }
 
-sse_size_t sse_awk_tab_getsize (sse_awk_tab_t* tab)
+ase_size_t ase_awk_tab_getsize (ase_awk_tab_t* tab)
 {
 	return tab->size;
 }
 
-sse_size_t sse_awk_tab_getcapa (sse_awk_tab_t* tab)
+ase_size_t ase_awk_tab_getcapa (ase_awk_tab_t* tab)
 {
 	return tab->capa;
 }
 
-sse_awk_tab_t* sse_awk_tab_setcapa (sse_awk_tab_t* tab, sse_size_t capa)
+ase_awk_tab_t* ase_awk_tab_setcapa (ase_awk_tab_t* tab, ase_size_t capa)
 {
 	void* tmp;
 
 	if (tab->size > capa) 
 	{
-		sse_awk_tab_remove (tab, capa, tab->size - capa);
-		sse_awk_assert (tab->awk, tab->size <= capa);
+		ase_awk_tab_remove (tab, capa, tab->size - capa);
+		ase_awk_assert (tab->awk, tab->size <= capa);
 	}
 
 	if (capa > 0) 
 	{
-		if (tab->awk->syscas.realloc != SSE_NULL)
+		if (tab->awk->syscas.realloc != ASE_NULL)
 		{
-			tmp = SSE_AWK_REALLOC (tab->awk, 
-				tab->buf, sse_sizeof(*tab->buf) * capa);
-			if (tmp == SSE_NULL) return SSE_NULL;
+			tmp = ASE_AWK_REALLOC (tab->awk, 
+				tab->buf, ase_sizeof(*tab->buf) * capa);
+			if (tmp == ASE_NULL) return ASE_NULL;
 		}
 		else
 		{
-			tmp = SSE_AWK_MALLOC (
-				tab->awk, sse_sizeof(*tab->buf) * capa);
-			if (tmp == SSE_NULL) return SSE_NULL;
-			if (tab->buf != SSE_NULL) 
+			tmp = ASE_AWK_MALLOC (
+				tab->awk, ase_sizeof(*tab->buf) * capa);
+			if (tmp == ASE_NULL) return ASE_NULL;
+			if (tab->buf != ASE_NULL) 
 			{
-				sse_size_t x;
+				ase_size_t x;
 				x = (capa > tab->capa)? tab->capa: capa;
-				SSE_AWK_MEMCPY (
+				ASE_AWK_MEMCPY (
 					tab->awk, tmp, tab->buf, 
-					sse_sizeof(*tab->buf) * x);
-				SSE_AWK_FREE (tab->awk, tab->buf);
+					ase_sizeof(*tab->buf) * x);
+				ASE_AWK_FREE (tab->awk, tab->buf);
 			}
 		}
 	}
 	else 
 	{
-		if (tab->buf != SSE_NULL) SSE_AWK_FREE (tab->awk, tab->buf);
-		tmp = SSE_NULL;
+		if (tab->buf != ASE_NULL) ASE_AWK_FREE (tab->awk, tab->buf);
+		tmp = ASE_NULL;
 	}
 
 	tab->buf = tmp;
@@ -92,14 +92,14 @@ sse_awk_tab_t* sse_awk_tab_setcapa (sse_awk_tab_t* tab, sse_size_t capa)
 	return tab;
 }
 
-void sse_awk_tab_clear (sse_awk_tab_t* tab)
+void ase_awk_tab_clear (ase_awk_tab_t* tab)
 {
-	sse_size_t i;
+	ase_size_t i;
 
 	for (i = 0; i < tab->size; i++) 
 	{
-		SSE_AWK_FREE (tab->awk, tab->buf[i].name);
-		tab->buf[i].name = SSE_NULL;
+		ASE_AWK_FREE (tab->awk, tab->buf[i].name);
+		tab->buf[i].name = ASE_NULL;
 		tab->buf[i].name_len = 0;
 	}
 
@@ -107,19 +107,19 @@ void sse_awk_tab_clear (sse_awk_tab_t* tab)
 }
 
 
-sse_size_t sse_awk_tab_insert (
-	sse_awk_tab_t* tab, sse_size_t index, 
-	const sse_char_t* str, sse_size_t len)
+ase_size_t ase_awk_tab_insert (
+	ase_awk_tab_t* tab, ase_size_t index, 
+	const ase_char_t* str, ase_size_t len)
 {
-	sse_size_t i;
-	sse_char_t* str_dup;
+	ase_size_t i;
+	ase_char_t* str_dup;
 
-	str_dup = sse_awk_strxdup (tab->awk, str, len);
-	if (str_dup == SSE_NULL) return (sse_size_t)-1;
+	str_dup = ase_awk_strxdup (tab->awk, str, len);
+	if (str_dup == ASE_NULL) return (ase_size_t)-1;
 
 	if (index >= tab->capa) 
 	{
-		sse_size_t capa;
+		ase_size_t capa;
 
 		if (tab->capa <= 0) capa = (index + 1);
 		else 
@@ -127,10 +127,10 @@ sse_size_t sse_awk_tab_insert (
 			do { capa = tab->capa * 2; } while (index >= capa);
 		}
 
-		if (sse_awk_tab_setcapa(tab,capa) == SSE_NULL) 
+		if (ase_awk_tab_setcapa(tab,capa) == ASE_NULL) 
 		{
-			SSE_AWK_FREE (tab->awk, str_dup);
-			return (sse_size_t)-1;
+			ASE_AWK_FREE (tab->awk, str_dup);
+			return (ase_size_t)-1;
 		}
 	}
 
@@ -144,10 +144,10 @@ sse_size_t sse_awk_tab_insert (
 	return index;
 }
 
-sse_size_t sse_awk_tab_remove (
-	sse_awk_tab_t* tab, sse_size_t index, sse_size_t count)
+ase_size_t ase_awk_tab_remove (
+	ase_awk_tab_t* tab, ase_size_t index, ase_size_t count)
 {
-	sse_size_t i, j, k;
+	ase_size_t i, j, k;
 
 	if (index >= tab->size) return 0;
 	if (count > tab->size - index) count = tab->size - index;
@@ -158,11 +158,11 @@ sse_size_t sse_awk_tab_remove (
 
 	while (i < k) 
 	{
-		SSE_AWK_FREE (tab->awk, tab->buf[i].name);	
+		ASE_AWK_FREE (tab->awk, tab->buf[i].name);	
 
 		if (j >= tab->size) 
 		{
-			tab->buf[i].name = SSE_NULL;
+			tab->buf[i].name = ASE_NULL;
 			tab->buf[i].name_len = 0; 
 			i++;
 		}
@@ -178,60 +178,60 @@ sse_size_t sse_awk_tab_remove (
 	return count;
 }
 
-sse_size_t sse_awk_tab_add (
-	sse_awk_tab_t* tab, const sse_char_t* str, sse_size_t len)
+ase_size_t ase_awk_tab_add (
+	ase_awk_tab_t* tab, const ase_char_t* str, ase_size_t len)
 {
-	return sse_awk_tab_insert (tab, tab->size, str, len);
+	return ase_awk_tab_insert (tab, tab->size, str, len);
 }
 
-sse_size_t sse_awk_tab_find (
-	sse_awk_tab_t* tab, sse_size_t index, 
-	const sse_char_t* str, sse_size_t len)
+ase_size_t ase_awk_tab_find (
+	ase_awk_tab_t* tab, ase_size_t index, 
+	const ase_char_t* str, ase_size_t len)
 {
-	sse_size_t i;
+	ase_size_t i;
 
 	for (i = index; i < tab->size; i++) 
 	{
-		if (sse_awk_strxncmp (
+		if (ase_awk_strxncmp (
 			tab->buf[i].name, tab->buf[i].name_len, 
 			str, len) == 0) return i;
 	}
 
-	return (sse_size_t)-1;
+	return (ase_size_t)-1;
 }
 
-sse_size_t sse_awk_tab_rfind (
-	sse_awk_tab_t* tab, sse_size_t index, 
-	const sse_char_t* str, sse_size_t len)
+ase_size_t ase_awk_tab_rfind (
+	ase_awk_tab_t* tab, ase_size_t index, 
+	const ase_char_t* str, ase_size_t len)
 {
-	sse_size_t i;
+	ase_size_t i;
 
-	if (index >= tab->size) return (sse_size_t)-1;
+	if (index >= tab->size) return (ase_size_t)-1;
 
 	for (i = index + 1; i-- > 0; ) 
 	{
-		if (sse_awk_strxncmp (
+		if (ase_awk_strxncmp (
 			tab->buf[i].name, tab->buf[i].name_len, 
 			str, len) == 0) return i;
 	}
 
-	return (sse_size_t)-1;
+	return (ase_size_t)-1;
 }
 
-sse_size_t sse_awk_tab_rrfind (
-	sse_awk_tab_t* tab, sse_size_t index,
-	const sse_char_t* str, sse_size_t len)
+ase_size_t ase_awk_tab_rrfind (
+	ase_awk_tab_t* tab, ase_size_t index,
+	const ase_char_t* str, ase_size_t len)
 {
-	sse_size_t i;
+	ase_size_t i;
 
-	if (index >= tab->size) return (sse_size_t)-1;
+	if (index >= tab->size) return (ase_size_t)-1;
 
 	for (i = tab->size - index; i-- > 0; ) 
 	{
-		if (sse_awk_strxncmp (
+		if (ase_awk_strxncmp (
 			tab->buf[i].name, tab->buf[i].name_len, 
 			str, len) == 0) return i;
 	}
 
-	return (sse_size_t)-1;
+	return (ase_size_t)-1;
 }
diff --git a/ase/awk/tab.h b/ase/awk/tab.h
index 0e4dab01..d74c2718 100644
--- a/ase/awk/tab.h
+++ b/ase/awk/tab.h
@@ -1,64 +1,64 @@
 /*
- * $Id: tab.h,v 1.13 2006-10-22 11:34:53 bacon Exp $
+ * $Id: tab.h,v 1.14 2006-10-24 04:10:12 bacon Exp $
  */
 
-#ifndef _SSE_AWK_TAB_H_
-#define _SSE_AWK_TAB_H_
+#ifndef _ASE_AWK_TAB_H_
+#define _ASE_AWK_TAB_H_
 
-#ifndef _SSE_AWK_AWK_H_
-#error Never include this file directly. Include <sse/awk/awk.h> instead
+#ifndef _ASE_AWK_AWK_H_
+#error Never include this file directly. Include <ase/awk/awk.h> instead
 #endif
 
 /* TODO: you have to turn this into a hash table.
 	 as of now, this is an arrayed table. */
 
-typedef struct sse_awk_tab_t sse_awk_tab_t;
+typedef struct ase_awk_tab_t ase_awk_tab_t;
 
-struct sse_awk_tab_t
+struct ase_awk_tab_t
 {
 	struct
 	{
-		sse_char_t* name;
-		sse_size_t name_len;
+		ase_char_t* name;
+		ase_size_t name_len;
 	}* buf;
-	sse_size_t size;
-	sse_size_t capa;
-	sse_awk_t* awk;
-	sse_bool_t __dynamic;	
+	ase_size_t size;
+	ase_size_t capa;
+	ase_awk_t* awk;
+	ase_bool_t __dynamic;	
 };
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-sse_awk_tab_t* sse_awk_tab_open (sse_awk_tab_t* tab, sse_awk_t* awk);
-void sse_awk_tab_close (sse_awk_tab_t* tab);
+ase_awk_tab_t* ase_awk_tab_open (ase_awk_tab_t* tab, ase_awk_t* awk);
+void ase_awk_tab_close (ase_awk_tab_t* tab);
 
-sse_size_t sse_awk_tab_getsize (sse_awk_tab_t* tab);
-sse_size_t sse_awk_tab_getcapa (sse_awk_tab_t* tab);
-sse_awk_tab_t* sse_awk_tab_setcapa (sse_awk_tab_t* tab, sse_size_t capa);
+ase_size_t ase_awk_tab_getsize (ase_awk_tab_t* tab);
+ase_size_t ase_awk_tab_getcapa (ase_awk_tab_t* tab);
+ase_awk_tab_t* ase_awk_tab_setcapa (ase_awk_tab_t* tab, ase_size_t capa);
 
-void sse_awk_tab_clear (sse_awk_tab_t* tab);
+void ase_awk_tab_clear (ase_awk_tab_t* tab);
 
-sse_size_t sse_awk_tab_insert (
-	sse_awk_tab_t* tab, sse_size_t index, 
-	const sse_char_t* str, sse_size_t len);
+ase_size_t ase_awk_tab_insert (
+	ase_awk_tab_t* tab, ase_size_t index, 
+	const ase_char_t* str, ase_size_t len);
 
-sse_size_t sse_awk_tab_remove (
-	sse_awk_tab_t* tab, sse_size_t index, sse_size_t count);
+ase_size_t ase_awk_tab_remove (
+	ase_awk_tab_t* tab, ase_size_t index, ase_size_t count);
 
-sse_size_t sse_awk_tab_add (
-	sse_awk_tab_t* tab, const sse_char_t* str, sse_size_t len);
+ase_size_t ase_awk_tab_add (
+	ase_awk_tab_t* tab, const ase_char_t* str, ase_size_t len);
 
-sse_size_t sse_awk_tab_find (
-	sse_awk_tab_t* tab, sse_size_t index,
-	const sse_char_t* str, sse_size_t len);
-sse_size_t sse_awk_tab_rfind (
-	sse_awk_tab_t* tab, sse_size_t index,
-	const sse_char_t* str, sse_size_t len);
-sse_size_t sse_awk_tab_rrfind (
-	sse_awk_tab_t* tab, sse_size_t index,
-	const sse_char_t* str, sse_size_t len);
+ase_size_t ase_awk_tab_find (
+	ase_awk_tab_t* tab, ase_size_t index,
+	const ase_char_t* str, ase_size_t len);
+ase_size_t ase_awk_tab_rfind (
+	ase_awk_tab_t* tab, ase_size_t index,
+	const ase_char_t* str, ase_size_t len);
+ase_size_t ase_awk_tab_rrfind (
+	ase_awk_tab_t* tab, ase_size_t index,
+	const ase_char_t* str, ase_size_t len);
 
 #ifdef __cplusplus
 }
diff --git a/ase/awk/tree.c b/ase/awk/tree.c
index 80aef6d3..e9b491db 100644
--- a/ase/awk/tree.c
+++ b/ase/awk/tree.c
@@ -1,90 +1,90 @@
 /*
- * $Id: tree.c,v 1.82 2006-10-22 12:39:30 bacon Exp $
+ * $Id: tree.c,v 1.83 2006-10-24 04:10:12 bacon Exp $
  */
 
-#include <sse/awk/awk_i.h>
+#include <ase/awk/awk_i.h>
 
-static const sse_char_t* __assop_str[] =
+static const ase_char_t* __assop_str[] =
 {
-	SSE_T("="),
-	SSE_T("+="),
-	SSE_T("-="),
-	SSE_T("*="),
-	SSE_T("/="),
-	SSE_T("%="),
-	SSE_T("**=")
+	ASE_T("="),
+	ASE_T("+="),
+	ASE_T("-="),
+	ASE_T("*="),
+	ASE_T("/="),
+	ASE_T("%="),
+	ASE_T("**=")
 };
 
-static const sse_char_t* __binop_str[] =
+static const ase_char_t* __binop_str[] =
 {
-	SSE_T("||"),
-	SSE_T("&&"),
-	SSE_T("in"),
+	ASE_T("||"),
+	ASE_T("&&"),
+	ASE_T("in"),
 
-	SSE_T("|"),
-	SSE_T("^"),
-	SSE_T("&"),
+	ASE_T("|"),
+	ASE_T("^"),
+	ASE_T("&"),
 
-	SSE_T("=="),
-	SSE_T("!="),
-	SSE_T(">"),
-	SSE_T(">="),
-	SSE_T("<"),
-	SSE_T("<="),
+	ASE_T("=="),
+	ASE_T("!="),
+	ASE_T(">"),
+	ASE_T(">="),
+	ASE_T("<"),
+	ASE_T("<="),
 
-	SSE_T("<<"),
-	SSE_T(">>"),
+	ASE_T("<<"),
+	ASE_T(">>"),
 
-	SSE_T("+"),
-	SSE_T("-"),
-	SSE_T("*"),
-	SSE_T("/"),
-	SSE_T("%"),
-	SSE_T("**"),
+	ASE_T("+"),
+	ASE_T("-"),
+	ASE_T("*"),
+	ASE_T("/"),
+	ASE_T("%"),
+	ASE_T("**"),
 
-	SSE_T(" "),
-	SSE_T("~"),
-	SSE_T("!~")
+	ASE_T(" "),
+	ASE_T("~"),
+	ASE_T("!~")
 };
 
-static const sse_char_t* __unrop_str[] =
+static const ase_char_t* __unrop_str[] =
 {
-	SSE_T("+"),
-	SSE_T("-"),
-	SSE_T("!"),
-	SSE_T("~")
+	ASE_T("+"),
+	ASE_T("-"),
+	ASE_T("!"),
+	ASE_T("~")
 };
 
-static const sse_char_t* __incop_str[] =
+static const ase_char_t* __incop_str[] =
 {
-	SSE_T("++"),
-	SSE_T("--"),
-	SSE_T("++"),
-	SSE_T("--")
+	ASE_T("++"),
+	ASE_T("--"),
+	ASE_T("++"),
+	ASE_T("--")
 };
 
-static const sse_char_t* __getline_inop_str[] =
+static const ase_char_t* __getline_inop_str[] =
 {
-	SSE_T("|"),
-	SSE_T("|&"),
-	SSE_T("<"),
-	SSE_T("")
+	ASE_T("|"),
+	ASE_T("|&"),
+	ASE_T("<"),
+	ASE_T("")
 };
 
-static const sse_char_t* __print_outop_str[] =
+static const ase_char_t* __print_outop_str[] =
 {
-	SSE_T("|"),
-	SSE_T("|&"),
-	SSE_T(">"),
-	SSE_T(">>"),
-	SSE_T("")
+	ASE_T("|"),
+	ASE_T("|&"),
+	ASE_T(">"),
+	ASE_T(">>"),
+	ASE_T("")
 };
 
 #define PUT_SRCSTR(awk,str) \
-	do { if (sse_awk_putsrcstr (awk, str) == -1) return -1; } while (0)
+	do { if (ase_awk_putsrcstr (awk, str) == -1) return -1; } while (0)
 
 #define PUT_SRCSTRX(awk,str,len) \
-	do { if (sse_awk_putsrcstrx (awk, str, len) == -1) return -1; } while (0)
+	do { if (ase_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)
@@ -98,163 +98,163 @@ static const sse_char_t* __print_outop_str[] =
 #define PRINT_STATEMENTS(awk,nde,depth) \
 	do { if (__print_statements(awk,nde,depth) == -1) return -1; } while (0)
 
-static int __print_tabs (sse_awk_t* awk, int depth);
-static int __print_expression (sse_awk_t* awk, sse_awk_nde_t* nde);
-static int __print_expression_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 (ase_awk_t* awk, int depth);
+static int __print_expression (ase_awk_t* awk, ase_awk_nde_t* nde);
+static int __print_expression_list (ase_awk_t* awk, ase_awk_nde_t* tree);
+static int __print_statements (ase_awk_t* awk, ase_awk_nde_t* tree, int depth);
 
-static int __print_tabs (sse_awk_t* awk, int depth)
+static int __print_tabs (ase_awk_t* awk, int depth)
 {
 	while (depth > 0) 
 	{
-		PUT_SRCSTR (awk, SSE_T("\t"));
+		PUT_SRCSTR (awk, ASE_T("\t"));
 		depth--;
 	}
 
 	return 0;
 }
 
-static int __print_expression (sse_awk_t* awk, sse_awk_nde_t* nde)
+static int __print_expression (ase_awk_t* awk, ase_awk_nde_t* nde)
 {
 	switch (nde->type) 
 	{
-		case SSE_AWK_NDE_GRP:
+		case ASE_AWK_NDE_GRP:
 		{	
-			sse_awk_nde_t* p = ((sse_awk_nde_grp_t*)nde)->body;
+			ase_awk_nde_t* p = ((ase_awk_nde_grp_t*)nde)->body;
 
-			PUT_SRCSTR (awk, SSE_T("("));
-			while (p != SSE_NULL) 
+			PUT_SRCSTR (awk, ASE_T("("));
+			while (p != ASE_NULL) 
 			{
 				PRINT_EXPRESSION (awk, p);
-				if (p->next != SSE_NULL) 
-					PUT_SRCSTR (awk, SSE_T(","));
+				if (p->next != ASE_NULL) 
+					PUT_SRCSTR (awk, ASE_T(","));
 				p = p->next;
 			}
-			PUT_SRCSTR (awk, SSE_T(")"));
+			PUT_SRCSTR (awk, ASE_T(")"));
 			break;
 		}
 
-		case SSE_AWK_NDE_ASS:
+		case ASE_AWK_NDE_ASS:
 		{
-			sse_awk_nde_ass_t* px = (sse_awk_nde_ass_t*)nde;
+			ase_awk_nde_ass_t* px = (ase_awk_nde_ass_t*)nde;
 
 			PRINT_EXPRESSION (awk, px->left);
-			PUT_SRCSTR (awk, SSE_T(" "));
+			PUT_SRCSTR (awk, ASE_T(" "));
 			PUT_SRCSTR (awk, __assop_str[px->opcode]);
-			PUT_SRCSTR (awk, SSE_T(" "));
+			PUT_SRCSTR (awk, ASE_T(" "));
 			PRINT_EXPRESSION (awk, px->right);
 
-			sse_awk_assert (awk, px->right->next == SSE_NULL);
+			ase_awk_assert (awk, px->right->next == ASE_NULL);
 			break;
 		}
 
-		case SSE_AWK_NDE_EXP_BIN:
+		case ASE_AWK_NDE_EXP_BIN:
 		{
-			sse_awk_nde_exp_t* px = (sse_awk_nde_exp_t*)nde;
+			ase_awk_nde_exp_t* px = (ase_awk_nde_exp_t*)nde;
 
-			PUT_SRCSTR (awk, SSE_T("("));
+			PUT_SRCSTR (awk, ASE_T("("));
 			PRINT_EXPRESSION (awk, px->left);
-			sse_awk_assert (awk, px->left->next == SSE_NULL);
+			ase_awk_assert (awk, px->left->next == ASE_NULL);
 
-			PUT_SRCSTR (awk, SSE_T(" "));
+			PUT_SRCSTR (awk, ASE_T(" "));
 			PUT_SRCSTR (awk, __binop_str[px->opcode]);
-			PUT_SRCSTR (awk, SSE_T(" "));
+			PUT_SRCSTR (awk, ASE_T(" "));
 
-			if (px->right->type == SSE_AWK_NDE_ASS) 
-				PUT_SRCSTR (awk, SSE_T("("));
+			if (px->right->type == ASE_AWK_NDE_ASS) 
+				PUT_SRCSTR (awk, ASE_T("("));
 			PRINT_EXPRESSION (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(")"));
+			if (px->right->type == ASE_AWK_NDE_ASS) 
+				PUT_SRCSTR (awk, ASE_T(")"));
+			ase_awk_assert (awk, px->right->next == ASE_NULL); 
+			PUT_SRCSTR (awk, ASE_T(")"));
 			break;
 		}
 
-		case SSE_AWK_NDE_EXP_UNR:
+		case ASE_AWK_NDE_EXP_UNR:
 		{
-			sse_awk_nde_exp_t* px = (sse_awk_nde_exp_t*)nde;
-			sse_awk_assert (awk, px->right == SSE_NULL);
+			ase_awk_nde_exp_t* px = (ase_awk_nde_exp_t*)nde;
+			ase_awk_assert (awk, px->right == ASE_NULL);
 
 			PUT_SRCSTR (awk, __unrop_str[px->opcode]);
-			PUT_SRCSTR (awk, SSE_T("("));
+			PUT_SRCSTR (awk, ASE_T("("));
 			PRINT_EXPRESSION (awk, px->left);
-			PUT_SRCSTR (awk, SSE_T(")"));
+			PUT_SRCSTR (awk, ASE_T(")"));
 			break;
 		}
 
-		case SSE_AWK_NDE_EXP_INCPRE:
+		case ASE_AWK_NDE_EXP_INCPRE:
 		{
-			sse_awk_nde_exp_t* px = (sse_awk_nde_exp_t*)nde;
-			sse_awk_assert (awk, px->right == SSE_NULL);
+			ase_awk_nde_exp_t* px = (ase_awk_nde_exp_t*)nde;
+			ase_awk_assert (awk, px->right == ASE_NULL);
 
 			PUT_SRCSTR (awk, __incop_str[px->opcode]);
-			PUT_SRCSTR (awk, SSE_T("("));
+			PUT_SRCSTR (awk, ASE_T("("));
 			PRINT_EXPRESSION (awk, px->left);
-			PUT_SRCSTR (awk, SSE_T(")"));
+			PUT_SRCSTR (awk, ASE_T(")"));
 			break;
 		}
 
-		case SSE_AWK_NDE_EXP_INCPST:
+		case ASE_AWK_NDE_EXP_INCPST:
 		{
-			sse_awk_nde_exp_t* px = (sse_awk_nde_exp_t*)nde;
-			sse_awk_assert (awk, px->right == SSE_NULL);
+			ase_awk_nde_exp_t* px = (ase_awk_nde_exp_t*)nde;
+			ase_awk_assert (awk, px->right == ASE_NULL);
 
-			PUT_SRCSTR (awk, SSE_T("("));
+			PUT_SRCSTR (awk, ASE_T("("));
 			PRINT_EXPRESSION (awk, px->left);
-			PUT_SRCSTR (awk, SSE_T(")"));
+			PUT_SRCSTR (awk, ASE_T(")"));
 			PUT_SRCSTR (awk, __incop_str[px->opcode]);
 			break;
 		}
 
-		case SSE_AWK_NDE_CND:
+		case ASE_AWK_NDE_CND:
 		{
-			sse_awk_nde_cnd_t* px = (sse_awk_nde_cnd_t*)nde;
+			ase_awk_nde_cnd_t* px = (ase_awk_nde_cnd_t*)nde;
 
-			PUT_SRCSTR (awk, SSE_T("("));
+			PUT_SRCSTR (awk, ASE_T("("));
 			PRINT_EXPRESSION (awk, px->test);
-			PUT_SRCSTR (awk, SSE_T(")?"));
+			PUT_SRCSTR (awk, ASE_T(")?"));
 
 			PRINT_EXPRESSION (awk, px->left);
-			PUT_SRCSTR (awk, SSE_T(":"));
+			PUT_SRCSTR (awk, ASE_T(":"));
 			PRINT_EXPRESSION (awk, px->right);
 			break;
 		}
 
-		case SSE_AWK_NDE_INT:
+		case ASE_AWK_NDE_INT:
 		{
-			if (((sse_awk_nde_int_t*)nde)->str == SSE_NULL)
+			if (((ase_awk_nde_int_t*)nde)->str == ASE_NULL)
 			{
-				sse_char_t tmp[sse_sizeof(sse_long_t)*8+2]; 
-				sse_size_t n;
+				ase_char_t tmp[ase_sizeof(ase_long_t)*8+2]; 
+				ase_size_t n;
 
-				n = sse_awk_longtostr (
-					((sse_awk_nde_int_t*)nde)->val,
-					10, SSE_NULL, tmp, sse_countof(tmp));
+				n = ase_awk_longtostr (
+					((ase_awk_nde_int_t*)nde)->val,
+					10, ASE_NULL, tmp, ase_countof(tmp));
 
 				PUT_SRCSTRX (awk, tmp, n);
 			}
 			else
 			{
 				PUT_SRCSTRX (awk,
-					((sse_awk_nde_int_t*)nde)->str,
-					((sse_awk_nde_int_t*)nde)->len);
+					((ase_awk_nde_int_t*)nde)->str,
+					((ase_awk_nde_int_t*)nde)->len);
 			}
 			break;
 		}
 
-		case SSE_AWK_NDE_REAL:
+		case ASE_AWK_NDE_REAL:
 		{
-			if (((sse_awk_nde_real_t*)nde)->str == SSE_NULL)
+			if (((ase_awk_nde_real_t*)nde)->str == ASE_NULL)
 			{
-				sse_char_t tmp[128];
-			#if (SSE_SIZEOF_LONG_DOUBLE != 0)
+				ase_char_t tmp[128];
+			#if (ASE_SIZEOF_LONG_DOUBLE != 0)
 				awk->syscas.sprintf (
-					tmp, sse_countof(tmp), SSE_T("%Lf"), 
-					(long double)((sse_awk_nde_real_t*)nde)->val);
-			#elif (SSE_SIZEOF_DOUBLE != 0)
+					tmp, ase_countof(tmp), ASE_T("%Lf"), 
+					(long double)((ase_awk_nde_real_t*)nde)->val);
+			#elif (ASE_SIZEOF_DOUBLE != 0)
 				awk->syscas.sprintf (
-					tmp, sse_countof(tmp), SSE_T("%f"), 
-					(double)((sse_awk_nde_real_t*)nde)->val);
+					tmp, ase_countof(tmp), ASE_T("%f"), 
+					(double)((ase_awk_nde_real_t*)nde)->val);
 			#else
 				#error unsupported floating-point data type
 			#endif
@@ -263,244 +263,244 @@ static int __print_expression (sse_awk_t* awk, sse_awk_nde_t* nde)
 			else
 			{
 				PUT_SRCSTRX (awk,
-					((sse_awk_nde_real_t*)nde)->str,
-					((sse_awk_nde_real_t*)nde)->len);
+					((ase_awk_nde_real_t*)nde)->str,
+					((ase_awk_nde_real_t*)nde)->len);
 			}
 			break;
 		}
 
-		case SSE_AWK_NDE_STR:
+		case ASE_AWK_NDE_STR:
 		{
 			/* TODO: ESCAPING */
-			PUT_SRCSTR (awk, SSE_T("\""));
+			PUT_SRCSTR (awk, ASE_T("\""));
 			PUT_SRCSTRX (awk,
-				((sse_awk_nde_str_t*)nde)->buf, 
-				((sse_awk_nde_str_t*)nde)->len);
-			PUT_SRCSTR (awk, SSE_T("\""));
+				((ase_awk_nde_str_t*)nde)->buf, 
+				((ase_awk_nde_str_t*)nde)->len);
+			PUT_SRCSTR (awk, ASE_T("\""));
 			break;
 		}
 
-		case SSE_AWK_NDE_REX:
+		case ASE_AWK_NDE_REX:
 		{
 			/* TODO: buf, len */
-			PUT_SRCSTR (awk, SSE_T("/"));
+			PUT_SRCSTR (awk, ASE_T("/"));
 			PUT_SRCSTRX (awk,
-				((sse_awk_nde_rex_t*)nde)->buf, 
-				((sse_awk_nde_rex_t*)nde)->len);
-			PUT_SRCSTR (awk, SSE_T("/"));
+				((ase_awk_nde_rex_t*)nde)->buf, 
+				((ase_awk_nde_rex_t*)nde)->len);
+			PUT_SRCSTR (awk, ASE_T("/"));
 			break;
 		}
 
-		case SSE_AWK_NDE_ARG:
+		case ASE_AWK_NDE_ARG:
 		{
-			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);
+			ase_char_t tmp[ase_sizeof(ase_long_t)*8+2]; 
+			ase_size_t n;
+			ase_awk_nde_var_t* px = (ase_awk_nde_var_t*)nde;
+			ase_awk_assert (awk, px->id.idxa != (ase_size_t)-1);
 
-			n = sse_awk_longtostr (
-				px->id.idxa, 10, SSE_NULL, tmp, sse_countof(tmp));
+			n = ase_awk_longtostr (
+				px->id.idxa, 10, ASE_NULL, tmp, ase_countof(tmp));
 
-			PUT_SRCSTR (awk, SSE_T("__param"));
+			PUT_SRCSTR (awk, ASE_T("__param"));
 			PUT_SRCSTRX (awk, tmp, n);
 
-			sse_awk_assert (awk, px->idx == SSE_NULL);
+			ase_awk_assert (awk, px->idx == ASE_NULL);
 			break;
 		}
 
-		case SSE_AWK_NDE_ARGIDX:
+		case ASE_AWK_NDE_ARGIDX:
 		{
-			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);
+			ase_char_t tmp[ase_sizeof(ase_long_t)*8+2]; 
+			ase_size_t n;
+			ase_awk_nde_var_t* px = (ase_awk_nde_var_t*)nde;
+			ase_awk_assert (awk, px->id.idxa != (ase_size_t)-1);
+			ase_awk_assert (awk, px->idx != ASE_NULL);
 
-			PUT_SRCSTR (awk, SSE_T("__param"));
-			n = sse_awk_longtostr (
-				px->id.idxa, 10, SSE_NULL, tmp, sse_countof(tmp));
+			PUT_SRCSTR (awk, ASE_T("__param"));
+			n = ase_awk_longtostr (
+				px->id.idxa, 10, ASE_NULL, tmp, ase_countof(tmp));
 			PUT_SRCSTRX (awk, tmp, n);
-			PUT_SRCSTR (awk, SSE_T("["));
+			PUT_SRCSTR (awk, ASE_T("["));
 			PRINT_EXPRESSION_LIST (awk, px->idx);
-			PUT_SRCSTR (awk, SSE_T("]"));
+			PUT_SRCSTR (awk, ASE_T("]"));
 			break;
 		}
 
-		case SSE_AWK_NDE_NAMED:
+		case ASE_AWK_NDE_NAMED:
 		{
-			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);
+			ase_awk_nde_var_t* px = (ase_awk_nde_var_t*)nde;
+			ase_awk_assert (awk, px->id.idxa == (ase_size_t)-1);
+			ase_awk_assert (awk, px->idx == ASE_NULL);
 
 			PUT_SRCSTRX (awk, px->id.name, px->id.name_len);
 			break;
 		}
 
-		case SSE_AWK_NDE_NAMEDIDX:
+		case ASE_AWK_NDE_NAMEDIDX:
 		{
-			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);
+			ase_awk_nde_var_t* px = (ase_awk_nde_var_t*)nde;
+			ase_awk_assert (awk, px->id.idxa == (ase_size_t)-1);
+			ase_awk_assert (awk, px->idx != ASE_NULL);
 
 			PUT_SRCSTRX (awk, px->id.name, px->id.name_len);
-			PUT_SRCSTR (awk, SSE_T("["));
+			PUT_SRCSTR (awk, ASE_T("["));
 			PRINT_EXPRESSION_LIST (awk, px->idx);
-			PUT_SRCSTR (awk, SSE_T("]"));
+			PUT_SRCSTR (awk, ASE_T("]"));
 			break;
 		}
 
-		case SSE_AWK_NDE_GLOBAL:
+		case ASE_AWK_NDE_GLOBAL:
 		{
-			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;
+			ase_char_t tmp[ase_sizeof(ase_long_t)*8+2]; 
+			ase_size_t n;
+			ase_awk_nde_var_t* px = (ase_awk_nde_var_t*)nde;
 
-			if (px->id.idxa != (sse_size_t)-1) 
+			if (px->id.idxa != (ase_size_t)-1) 
 			{
-				PUT_SRCSTR (awk, SSE_T("__global"));
-				n = sse_awk_longtostr (
+				PUT_SRCSTR (awk, ASE_T("__global"));
+				n = ase_awk_longtostr (
 					px->id.idxa, 10, 
-					SSE_NULL, tmp, sse_countof(tmp));
+					ASE_NULL, tmp, ase_countof(tmp));
 				PUT_SRCSTRX (awk, tmp, n);
 			}
 			else 
 			{
 				PUT_SRCSTRX (awk, px->id.name, px->id.name_len);
 			}
-			sse_awk_assert (awk, px->idx == SSE_NULL);
+			ase_awk_assert (awk, px->idx == ASE_NULL);
 			break;
 		}
 
-		case SSE_AWK_NDE_GLOBALIDX:
+		case ASE_AWK_NDE_GLOBALIDX:
 		{
-			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;
+			ase_char_t tmp[ase_sizeof(ase_long_t)*8+2]; 
+			ase_size_t n;
+			ase_awk_nde_var_t* px = (ase_awk_nde_var_t*)nde;
 
-			if (px->id.idxa != (sse_size_t)-1) 
+			if (px->id.idxa != (ase_size_t)-1) 
 			{
-				PUT_SRCSTR (awk, SSE_T("__global"));
-				n = sse_awk_longtostr (
+				PUT_SRCSTR (awk, ASE_T("__global"));
+				n = ase_awk_longtostr (
 					px->id.idxa, 10, 
-					SSE_NULL, tmp, sse_countof(tmp));
+					ASE_NULL, tmp, ase_countof(tmp));
 				PUT_SRCSTRX (awk, tmp, n);
-				PUT_SRCSTR (awk, SSE_T("["));
+				PUT_SRCSTR (awk, ASE_T("["));
 			}
 			else 
 			{
 				PUT_SRCSTRX (awk, px->id.name, px->id.name_len);
-				PUT_SRCSTR (awk, SSE_T("["));
+				PUT_SRCSTR (awk, ASE_T("["));
 			}
-			sse_awk_assert (awk, px->idx != SSE_NULL);
+			ase_awk_assert (awk, px->idx != ASE_NULL);
 			PRINT_EXPRESSION_LIST (awk, px->idx);
-			PUT_SRCSTR (awk, SSE_T("]"));
+			PUT_SRCSTR (awk, ASE_T("]"));
 			break;
 		}
 
-		case SSE_AWK_NDE_LOCAL:
+		case ASE_AWK_NDE_LOCAL:
 		{
-			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;
+			ase_char_t tmp[ase_sizeof(ase_long_t)*8+2]; 
+			ase_size_t n;
+			ase_awk_nde_var_t* px = (ase_awk_nde_var_t*)nde;
 
-			if (px->id.idxa != (sse_size_t)-1) 
+			if (px->id.idxa != (ase_size_t)-1) 
 			{
-				PUT_SRCSTR (awk, SSE_T("__local"));
-				n = sse_awk_longtostr (
+				PUT_SRCSTR (awk, ASE_T("__local"));
+				n = ase_awk_longtostr (
 					px->id.idxa, 10, 
-					SSE_NULL, tmp, sse_countof(tmp));
+					ASE_NULL, tmp, ase_countof(tmp));
 				PUT_SRCSTRX (awk, tmp, n);
 			}
 			else 
 			{
 				PUT_SRCSTRX (awk, px->id.name, px->id.name_len);
 			}
-			sse_awk_assert (awk, px->idx == SSE_NULL);
+			ase_awk_assert (awk, px->idx == ASE_NULL);
 			break;
 		}
 
-		case SSE_AWK_NDE_LOCALIDX:
+		case ASE_AWK_NDE_LOCALIDX:
 		{
-			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;
+			ase_char_t tmp[ase_sizeof(ase_long_t)*8+2]; 
+			ase_size_t n;
+			ase_awk_nde_var_t* px = (ase_awk_nde_var_t*)nde;
 
-			if (px->id.idxa != (sse_size_t)-1) 
+			if (px->id.idxa != (ase_size_t)-1) 
 			{
-				PUT_SRCSTR (awk, SSE_T("__local"));
-				n = sse_awk_longtostr (
+				PUT_SRCSTR (awk, ASE_T("__local"));
+				n = ase_awk_longtostr (
 					px->id.idxa, 10, 
-					SSE_NULL, tmp, sse_countof(tmp));
+					ASE_NULL, tmp, ase_countof(tmp));
 				PUT_SRCSTRX (awk, tmp, n);
-				PUT_SRCSTR (awk, SSE_T("["));
+				PUT_SRCSTR (awk, ASE_T("["));
 			}
 			else 
 			{
 				PUT_SRCSTRX (awk, px->id.name, px->id.name_len);
-				PUT_SRCSTR (awk, SSE_T("["));
+				PUT_SRCSTR (awk, ASE_T("["));
 			}
-			sse_awk_assert (awk, px->idx != SSE_NULL);
+			ase_awk_assert (awk, px->idx != ASE_NULL);
 			PRINT_EXPRESSION_LIST (awk, px->idx);
-			PUT_SRCSTR (awk, SSE_T("]"));
+			PUT_SRCSTR (awk, ASE_T("]"));
 			break;
 		}
 
-		case SSE_AWK_NDE_POS:
+		case ASE_AWK_NDE_POS:
 		{
-			PUT_SRCSTR (awk, SSE_T("$"));
-			PRINT_EXPRESSION (awk, ((sse_awk_nde_pos_t*)nde)->val);
+			PUT_SRCSTR (awk, ASE_T("$"));
+			PRINT_EXPRESSION (awk, ((ase_awk_nde_pos_t*)nde)->val);
 			break;
 		}
 
-		case SSE_AWK_NDE_BFN:
+		case ASE_AWK_NDE_BFN:
 		{
-			sse_awk_nde_call_t* px = (sse_awk_nde_call_t*)nde;
+			ase_awk_nde_call_t* px = (ase_awk_nde_call_t*)nde;
 			PUT_SRCSTRX (awk, 
 				px->what.bfn.name, px->what.bfn.name_len);
-			PUT_SRCSTR (awk, SSE_T(" ("));
+			PUT_SRCSTR (awk, ASE_T(" ("));
 			PRINT_EXPRESSION_LIST (awk, px->args);
-			PUT_SRCSTR (awk, SSE_T(")"));
+			PUT_SRCSTR (awk, ASE_T(")"));
 			break;
 		}
 
-		case SSE_AWK_NDE_AFN:
+		case ASE_AWK_NDE_AFN:
 		{
 			/* TODO: use px->what.afn.name_len */
-			sse_awk_nde_call_t* px = (sse_awk_nde_call_t*)nde;
+			ase_awk_nde_call_t* px = (ase_awk_nde_call_t*)nde;
 			PUT_SRCSTRX (awk, 
 				px->what.afn.name, px->what.afn.name_len);
-			PUT_SRCSTR (awk, SSE_T(" ("));
+			PUT_SRCSTR (awk, ASE_T(" ("));
 			PRINT_EXPRESSION_LIST (awk, px->args);
-			PUT_SRCSTR (awk, SSE_T(")"));
+			PUT_SRCSTR (awk, ASE_T(")"));
 			break;
 		}
 
-		case SSE_AWK_NDE_GETLINE:
+		case ASE_AWK_NDE_GETLINE:
 		{
-			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))
+			ase_awk_nde_getline_t* px = (ase_awk_nde_getline_t*)nde;
+			if (px->in != ASE_NULL &&
+			    (px->in_type == ASE_AWK_IN_PIPE ||
+			     px->in_type == ASE_AWK_IN_COPROC))
 			{
 				PRINT_EXPRESSION (awk, px->in);
-				PUT_SRCSTR (awk, SSE_T(" "));
+				PUT_SRCSTR (awk, ASE_T(" "));
 				PUT_SRCSTR (awk, __getline_inop_str[px->in_type]);
-				PUT_SRCSTR (awk, SSE_T(" "));
+				PUT_SRCSTR (awk, ASE_T(" "));
 			}
 
-			PUT_SRCSTR (awk, SSE_T("getline"));
-			if (px->var != SSE_NULL)
+			PUT_SRCSTR (awk, ASE_T("getline"));
+			if (px->var != ASE_NULL)
 			{
-				PUT_SRCSTR (awk, SSE_T(" "));
+				PUT_SRCSTR (awk, ASE_T(" "));
 				PRINT_EXPRESSION (awk, px->var);
 			}
 
-			if (px->in != SSE_NULL &&
-			    px->in_type == SSE_AWK_IN_FILE)
+			if (px->in != ASE_NULL &&
+			    px->in_type == ASE_AWK_IN_FILE)
 			{
-				PUT_SRCSTR (awk, SSE_T(" "));
+				PUT_SRCSTR (awk, ASE_T(" "));
 				PUT_SRCSTR (awk, __getline_inop_str[px->in_type]);
-				PUT_SRCSTR (awk, SSE_T(" "));
+				PUT_SRCSTR (awk, ASE_T(" "));
 				PRINT_EXPRESSION (awk, px->in);
 			}	  
 			break;
@@ -515,93 +515,93 @@ static int __print_expression (sse_awk_t* awk, sse_awk_nde_t* nde)
 	return 0;
 }
 
-static int __print_expression_list (sse_awk_t* awk, sse_awk_nde_t* tree)
+static int __print_expression_list (ase_awk_t* awk, ase_awk_nde_t* tree)
 {
-	sse_awk_nde_t* p = tree;
+	ase_awk_nde_t* p = tree;
 
-	while (p != SSE_NULL) 
+	while (p != ASE_NULL) 
 	{
 		PRINT_EXPRESSION (awk, p);
 		p = p->next;
-		if (p != SSE_NULL) PUT_SRCSTR (awk, SSE_T(","));
+		if (p != ASE_NULL) PUT_SRCSTR (awk, ASE_T(","));
 	}
 
 	return 0;
 }
 
-static int __print_statements (sse_awk_t* awk, sse_awk_nde_t* tree, int depth)
+static int __print_statements (ase_awk_t* awk, ase_awk_nde_t* tree, int depth)
 {
-	sse_awk_nde_t* p = tree;
-	sse_size_t i;
+	ase_awk_nde_t* p = tree;
+	ase_size_t i;
 
-	while (p != SSE_NULL) 
+	while (p != ASE_NULL) 
 	{
 
 		switch (p->type) 
 		{
-			case SSE_AWK_NDE_NULL:
+			case ASE_AWK_NDE_NULL:
 			{
 				PRINT_TABS (awk, depth);
-				PUT_SRCSTR (awk, SSE_T(";\n"));
+				PUT_SRCSTR (awk, ASE_T(";\n"));
 				break;
 			}
 
-			case SSE_AWK_NDE_BLK:
+			case ASE_AWK_NDE_BLK:
 			{
-				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;
+				ase_char_t tmp[ase_sizeof(ase_long_t)*8+2];
+				ase_size_t n;
+				ase_awk_nde_blk_t* px = (ase_awk_nde_blk_t*)p;
 
 				PRINT_TABS (awk, depth);
-				PUT_SRCSTR (awk, SSE_T("{\n"));
+				PUT_SRCSTR (awk, ASE_T("{\n"));
 
 				if (px->nlocals > 0) 
 				{
 					PRINT_TABS (awk, depth + 1);
-					PUT_SRCSTR (awk, SSE_T("local "));
+					PUT_SRCSTR (awk, ASE_T("local "));
 
 					for (i = 0; i < px->nlocals - 1; i++) 
 					{
-						PUT_SRCSTR (awk, SSE_T("__local"));
-						n = sse_awk_longtostr (
-							i, 10, SSE_NULL, tmp, sse_countof(tmp));
+						PUT_SRCSTR (awk, ASE_T("__local"));
+						n = ase_awk_longtostr (
+							i, 10, ASE_NULL, tmp, ase_countof(tmp));
 						PUT_SRCSTRX (awk, tmp, n);
-						PUT_SRCSTR (awk, SSE_T(", "));
+						PUT_SRCSTR (awk, ASE_T(", "));
 					}
 
-					PUT_SRCSTR (awk, SSE_T("__local"));
-					n = sse_awk_longtostr (
-						i, 10, SSE_NULL, tmp, sse_countof(tmp));
+					PUT_SRCSTR (awk, ASE_T("__local"));
+					n = ase_awk_longtostr (
+						i, 10, ASE_NULL, tmp, ase_countof(tmp));
 					PUT_SRCSTRX (awk, tmp, n);
-					PUT_SRCSTR (awk, SSE_T(";\n"));
+					PUT_SRCSTR (awk, ASE_T(";\n"));
 				}
 
 				PRINT_STATEMENTS (awk, px->body, depth + 1);	
 				PRINT_TABS (awk, depth);
-				PUT_SRCSTR (awk, SSE_T("}\n"));
+				PUT_SRCSTR (awk, ASE_T("}\n"));
 				break;
 			}
 
-			case SSE_AWK_NDE_IF: 
+			case ASE_AWK_NDE_IF: 
 			{
-				sse_awk_nde_if_t* px = (sse_awk_nde_if_t*)p;
+				ase_awk_nde_if_t* px = (ase_awk_nde_if_t*)p;
 
 				PRINT_TABS (awk, depth);
-				PUT_SRCSTR (awk, SSE_T("if ("));	
+				PUT_SRCSTR (awk, ASE_T("if ("));	
 				PRINT_EXPRESSION (awk, px->test);
-				PUT_SRCSTR (awk, SSE_T(")\n"));
+				PUT_SRCSTR (awk, ASE_T(")\n"));
 
-				sse_awk_assert (awk, px->then_part != SSE_NULL);
-				if (px->then_part->type == SSE_AWK_NDE_BLK)
+				ase_awk_assert (awk, px->then_part != ASE_NULL);
+				if (px->then_part->type == ASE_AWK_NDE_BLK)
 					PRINT_STATEMENTS (awk, px->then_part, depth);
 				else
 					PRINT_STATEMENTS (awk, px->then_part, depth + 1);
 
-				if (px->else_part != SSE_NULL) 
+				if (px->else_part != ASE_NULL) 
 				{
 					PRINT_TABS (awk, depth);
-					PUT_SRCSTR (awk, SSE_T("else\n"));	
-					if (px->else_part->type == SSE_AWK_NDE_BLK)
+					PUT_SRCSTR (awk, ASE_T("else\n"));	
+					if (px->else_part->type == ASE_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 (sse_awk_t* awk, sse_awk_nde_t* tree, int depth)
 				break;
 			}
 
-			case SSE_AWK_NDE_WHILE: 
+			case ASE_AWK_NDE_WHILE: 
 			{
-				sse_awk_nde_while_t* px = (sse_awk_nde_while_t*)p;
+				ase_awk_nde_while_t* px = (ase_awk_nde_while_t*)p;
 
 				PRINT_TABS (awk, depth);
-				PUT_SRCSTR (awk, SSE_T("while ("));	
+				PUT_SRCSTR (awk, ASE_T("while ("));	
 				PRINT_EXPRESSION (awk, px->test);
-				PUT_SRCSTR (awk, SSE_T(")\n"));
-				if (px->body->type == SSE_AWK_NDE_BLK) 
+				PUT_SRCSTR (awk, ASE_T(")\n"));
+				if (px->body->type == ASE_AWK_NDE_BLK) 
 				{
 					PRINT_STATEMENTS (awk, px->body, depth);
 				}
@@ -628,13 +628,13 @@ static int __print_statements (sse_awk_t* awk, sse_awk_nde_t* tree, int depth)
 				break;
 			}
 
-			case SSE_AWK_NDE_DOWHILE: 
+			case ASE_AWK_NDE_DOWHILE: 
 			{
-				sse_awk_nde_while_t* px = (sse_awk_nde_while_t*)p;
+				ase_awk_nde_while_t* px = (ase_awk_nde_while_t*)p;
 
 				PRINT_TABS (awk, depth);
-				PUT_SRCSTR (awk, SSE_T("do\n"));	
-				if (px->body->type == SSE_AWK_NDE_BLK) 
+				PUT_SRCSTR (awk, ASE_T("do\n"));	
+				if (px->body->type == ASE_AWK_NDE_BLK) 
 				{
 					PRINT_STATEMENTS (awk, px->body, depth);
 				}
@@ -644,35 +644,35 @@ static int __print_statements (sse_awk_t* awk, sse_awk_nde_t* tree, int depth)
 				}
 
 				PRINT_TABS (awk, depth);
-				PUT_SRCSTR (awk, SSE_T("while ("));	
+				PUT_SRCSTR (awk, ASE_T("while ("));	
 				PRINT_EXPRESSION (awk, px->test);
-				PUT_SRCSTR (awk, SSE_T(");\n"));	
+				PUT_SRCSTR (awk, ASE_T(");\n"));	
 				break;
 			}
 
-			case SSE_AWK_NDE_FOR:
+			case ASE_AWK_NDE_FOR:
 			{
-				sse_awk_nde_for_t* px = (sse_awk_nde_for_t*)p;
+				ase_awk_nde_for_t* px = (ase_awk_nde_for_t*)p;
 
 				PRINT_TABS (awk, depth);
-				PUT_SRCSTR (awk, SSE_T("for ("));
-				if (px->init != SSE_NULL) 
+				PUT_SRCSTR (awk, ASE_T("for ("));
+				if (px->init != ASE_NULL) 
 				{
 					PRINT_EXPRESSION (awk, px->init);
 				}
-				PUT_SRCSTR (awk, SSE_T("; "));
-				if (px->test != SSE_NULL) 
+				PUT_SRCSTR (awk, ASE_T("; "));
+				if (px->test != ASE_NULL) 
 				{
 					PRINT_EXPRESSION (awk, px->test);
 				}
-				PUT_SRCSTR (awk, SSE_T("; "));
-				if (px->incr != SSE_NULL) 
+				PUT_SRCSTR (awk, ASE_T("; "));
+				if (px->incr != ASE_NULL) 
 				{
 					PRINT_EXPRESSION (awk, px->incr);
 				}
-				PUT_SRCSTR (awk, SSE_T(")\n"));
+				PUT_SRCSTR (awk, ASE_T(")\n"));
 
-				if (px->body->type == SSE_AWK_NDE_BLK) 
+				if (px->body->type == ASE_AWK_NDE_BLK) 
 				{
 					PRINT_STATEMENTS (awk, px->body, depth);
 				}
@@ -683,15 +683,15 @@ static int __print_statements (sse_awk_t* awk, sse_awk_nde_t* tree, int depth)
 				break;
 			}
 
-			case SSE_AWK_NDE_FOREACH:
+			case ASE_AWK_NDE_FOREACH:
 			{
-				sse_awk_nde_foreach_t* px = (sse_awk_nde_foreach_t*)p;
+				ase_awk_nde_foreach_t* px = (ase_awk_nde_foreach_t*)p;
 
 				PRINT_TABS (awk, depth);
-				PUT_SRCSTR (awk, SSE_T("for "));
+				PUT_SRCSTR (awk, ASE_T("for "));
 				PRINT_EXPRESSION (awk, px->test);
-				PUT_SRCSTR (awk, SSE_T("\n"));
-				if (px->body->type == SSE_AWK_NDE_BLK) 
+				PUT_SRCSTR (awk, ASE_T("\n"));
+				if (px->body->type == ASE_AWK_NDE_BLK) 
 				{
 					PRINT_STATEMENTS (awk, px->body, depth);
 				}
@@ -702,102 +702,102 @@ static int __print_statements (sse_awk_t* awk, sse_awk_nde_t* tree, int depth)
 				break;
 			}
 
-			case SSE_AWK_NDE_BREAK:
+			case ASE_AWK_NDE_BREAK:
 			{
 				PRINT_TABS (awk, depth);
-				PUT_SRCSTR (awk, SSE_T("break;\n"));
+				PUT_SRCSTR (awk, ASE_T("break;\n"));
 				break;
 			}
 
-			case SSE_AWK_NDE_CONTINUE:
+			case ASE_AWK_NDE_CONTINUE:
 			{
 				PRINT_TABS (awk, depth);
-				PUT_SRCSTR (awk, SSE_T("continue;\n"));
+				PUT_SRCSTR (awk, ASE_T("continue;\n"));
 				break;
 			}
 
-			case SSE_AWK_NDE_RETURN:
+			case ASE_AWK_NDE_RETURN:
 			{
 				PRINT_TABS (awk, depth);
-				if (((sse_awk_nde_return_t*)p)->val == SSE_NULL) 
+				if (((ase_awk_nde_return_t*)p)->val == ASE_NULL) 
 				{
-					PUT_SRCSTR (awk, SSE_T("return;\n"));
+					PUT_SRCSTR (awk, ASE_T("return;\n"));
 				}
 				else 
 				{
-					PUT_SRCSTR (awk, SSE_T("return "));
-					sse_awk_assert (awk, ((sse_awk_nde_return_t*)p)->val->next == SSE_NULL);
+					PUT_SRCSTR (awk, ASE_T("return "));
+					ase_awk_assert (awk, ((ase_awk_nde_return_t*)p)->val->next == ASE_NULL);
 
-					PRINT_EXPRESSION (awk, ((sse_awk_nde_return_t*)p)->val);
-					PUT_SRCSTR (awk, SSE_T(";\n"));
+					PRINT_EXPRESSION (awk, ((ase_awk_nde_return_t*)p)->val);
+					PUT_SRCSTR (awk, ASE_T(";\n"));
 				}
 				break;
 			}
 
-			case SSE_AWK_NDE_EXIT:
+			case ASE_AWK_NDE_EXIT:
 			{
-				sse_awk_nde_exit_t* px = (sse_awk_nde_exit_t*)p;
+				ase_awk_nde_exit_t* px = (ase_awk_nde_exit_t*)p;
 				PRINT_TABS (awk, depth);
 
-				if (px->val == SSE_NULL) 
+				if (px->val == ASE_NULL) 
 				{
-					PUT_SRCSTR (awk, SSE_T("exit;\n"));
+					PUT_SRCSTR (awk, ASE_T("exit;\n"));
 				}
 				else 
 				{
-					PUT_SRCSTR (awk, SSE_T("exit "));
-					sse_awk_assert (awk, px->val->next == SSE_NULL);
+					PUT_SRCSTR (awk, ASE_T("exit "));
+					ase_awk_assert (awk, px->val->next == ASE_NULL);
 					PRINT_EXPRESSION (awk, px->val);
-					PUT_SRCSTR (awk, SSE_T(";\n"));
+					PUT_SRCSTR (awk, ASE_T(";\n"));
 				}
 				break;
 			}
 
-			case SSE_AWK_NDE_NEXT:
+			case ASE_AWK_NDE_NEXT:
 			{
 				PRINT_TABS (awk, depth);
-				PUT_SRCSTR (awk, SSE_T("next;\n"));
+				PUT_SRCSTR (awk, ASE_T("next;\n"));
 				break;
 			}
 
-			case SSE_AWK_NDE_NEXTFILE:
+			case ASE_AWK_NDE_NEXTFILE:
 			{
 				PRINT_TABS (awk, depth);
-				PUT_SRCSTR (awk, SSE_T("nextfile;\n"));
+				PUT_SRCSTR (awk, ASE_T("nextfile;\n"));
 				break;
 			}
 
-			case SSE_AWK_NDE_DELETE:
+			case ASE_AWK_NDE_DELETE:
 			{
 				PRINT_TABS (awk, depth);
-				PUT_SRCSTR (awk, SSE_T("delete "));
+				PUT_SRCSTR (awk, ASE_T("delete "));
 		/* TODO: can't use __print_expression??? */
-				sse_awk_prnpt (awk, ((sse_awk_nde_delete_t*)p)->var);
+				ase_awk_prnpt (awk, ((ase_awk_nde_delete_t*)p)->var);
 				break;
 			}
 
-			case SSE_AWK_NDE_PRINT:
+			case ASE_AWK_NDE_PRINT:
 			{
-				sse_awk_nde_print_t* px = (sse_awk_nde_print_t*)p;
+				ase_awk_nde_print_t* px = (ase_awk_nde_print_t*)p;
 
 				PRINT_TABS (awk, depth);
 
-				PUT_SRCSTR (awk, SSE_T("print"));
-				if (px->args != SSE_NULL)
+				PUT_SRCSTR (awk, ASE_T("print"));
+				if (px->args != ASE_NULL)
 				{
-					PUT_SRCSTR (awk, SSE_T(" "));
+					PUT_SRCSTR (awk, ASE_T(" "));
 					PRINT_EXPRESSION_LIST (awk, px->args);
 				}
 
-				if (px->out != SSE_NULL)
+				if (px->out != ASE_NULL)
 				{
-					PUT_SRCSTR (awk, SSE_T(" "));
+					PUT_SRCSTR (awk, ASE_T(" "));
 					PUT_SRCSTR (awk, __print_outop_str[px->out_type]);
-					PUT_SRCSTR (awk, SSE_T(" "));
+					PUT_SRCSTR (awk, ASE_T(" "));
 					PRINT_EXPRESSION (awk, px->out);
 				}
 
-				PUT_SRCSTR (awk, SSE_T(";\n"));
+				PUT_SRCSTR (awk, ASE_T(";\n"));
 				break;
 			}
 
@@ -805,7 +805,7 @@ static int __print_statements (sse_awk_t* awk, sse_awk_nde_t* tree, int depth)
 			{
 				PRINT_TABS (awk, depth);
 				PRINT_EXPRESSION (awk, p);
-				PUT_SRCSTR (awk, SSE_T(";\n"));
+				PUT_SRCSTR (awk, ASE_T(";\n"));
 			}
 		}
 
@@ -815,297 +815,297 @@ static int __print_statements (sse_awk_t* awk, sse_awk_nde_t* tree, int depth)
 	return 0;
 }
 
-int sse_awk_prnpt (sse_awk_t* awk, sse_awk_nde_t* tree)
+int ase_awk_prnpt (ase_awk_t* awk, ase_awk_nde_t* tree)
 {
 	return __print_statements (awk, tree, 0);
 }
 
-int sse_awk_prnptnpt (sse_awk_t* awk, sse_awk_nde_t* tree)
+int ase_awk_prnptnpt (ase_awk_t* awk, ase_awk_nde_t* tree)
 {
-	sse_awk_nde_t* nde = tree;
+	ase_awk_nde_t* nde = tree;
 
-	while (nde != SSE_NULL)
+	while (nde != ASE_NULL)
 	{
 		if (__print_expression (awk, nde) == -1) return -1;
-		if (nde->next == SSE_NULL) break;
+		if (nde->next == ASE_NULL) break;
 
-		PUT_SRCSTR (awk, SSE_T(","));
+		PUT_SRCSTR (awk, ASE_T(","));
 		nde = nde->next;
 	}
 
 	return 0;
 }
 
-void sse_awk_clrpt (sse_awk_t* awk, sse_awk_nde_t* tree)
+void ase_awk_clrpt (ase_awk_t* awk, ase_awk_nde_t* tree)
 {
-	sse_awk_nde_t* p = tree;
-	sse_awk_nde_t* next;
+	ase_awk_nde_t* p = tree;
+	ase_awk_nde_t* next;
 
-	while (p != SSE_NULL) 
+	while (p != ASE_NULL) 
 	{
 		next = p->next;
 
 		switch (p->type) 
 		{
-			case SSE_AWK_NDE_NULL:
+			case ASE_AWK_NDE_NULL:
 			{
-				SSE_AWK_FREE (awk, p);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_BLK:
+			case ASE_AWK_NDE_BLK:
 			{
-				sse_awk_clrpt (awk, ((sse_awk_nde_blk_t*)p)->body);
-				SSE_AWK_FREE (awk, p);
+				ase_awk_clrpt (awk, ((ase_awk_nde_blk_t*)p)->body);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_IF:
+			case ASE_AWK_NDE_IF:
 			{
-				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);
+				ase_awk_nde_if_t* px = (ase_awk_nde_if_t*)p;
+				ase_awk_clrpt (awk, px->test);
+				ase_awk_clrpt (awk, px->then_part);
 
-				if (px->else_part != SSE_NULL)
-					sse_awk_clrpt (awk, px->else_part);
-				SSE_AWK_FREE (awk, p);
+				if (px->else_part != ASE_NULL)
+					ase_awk_clrpt (awk, px->else_part);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_WHILE:
-			case SSE_AWK_NDE_DOWHILE:
+			case ASE_AWK_NDE_WHILE:
+			case ASE_AWK_NDE_DOWHILE:
 			{
-				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);
+				ase_awk_clrpt (awk, ((ase_awk_nde_while_t*)p)->test);
+				ase_awk_clrpt (awk, ((ase_awk_nde_while_t*)p)->body);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_FOR:
+			case ASE_AWK_NDE_FOR:
 			{
-				sse_awk_nde_for_t* px = (sse_awk_nde_for_t*)p;
+				ase_awk_nde_for_t* px = (ase_awk_nde_for_t*)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);
+				if (px->init != ASE_NULL)
+					ase_awk_clrpt (awk, px->init);
+				if (px->test != ASE_NULL)
+					ase_awk_clrpt (awk, px->test);
+				if (px->incr != ASE_NULL)
+					ase_awk_clrpt (awk, px->incr);
+				ase_awk_clrpt (awk, px->body);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_FOREACH:
+			case ASE_AWK_NDE_FOREACH:
 			{
-				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);
+				ase_awk_clrpt (awk, ((ase_awk_nde_foreach_t*)p)->test);
+				ase_awk_clrpt (awk, ((ase_awk_nde_foreach_t*)p)->body);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_BREAK:
+			case ASE_AWK_NDE_BREAK:
 			{
-				SSE_AWK_FREE (awk, p);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_CONTINUE:
+			case ASE_AWK_NDE_CONTINUE:
 			{
-				SSE_AWK_FREE (awk, p);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_RETURN:
+			case ASE_AWK_NDE_RETURN:
 			{
-				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);
+				ase_awk_nde_return_t* px =
+					(ase_awk_nde_return_t*)p;
+				if (px->val != ASE_NULL) 
+					ase_awk_clrpt (awk, px->val);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_EXIT:
+			case ASE_AWK_NDE_EXIT:
 			{
-				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);
+				if (((ase_awk_nde_exit_t*)p)->val != ASE_NULL) 
+					ase_awk_clrpt (awk, ((ase_awk_nde_exit_t*)p)->val);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_NEXT:
-			case SSE_AWK_NDE_NEXTFILE:
+			case ASE_AWK_NDE_NEXT:
+			case ASE_AWK_NDE_NEXTFILE:
 			{
-				SSE_AWK_FREE (awk, p);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_DELETE:
+			case ASE_AWK_NDE_DELETE:
 			{
-				sse_awk_clrpt (awk, ((sse_awk_nde_delete_t*)p)->var);
-				SSE_AWK_FREE (awk, p);
+				ase_awk_clrpt (awk, ((ase_awk_nde_delete_t*)p)->var);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_PRINT:
+			case ASE_AWK_NDE_PRINT:
 			{
-				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);
+				ase_awk_nde_print_t* px = 
+					(ase_awk_nde_print_t*)p;
+				if (px->args != ASE_NULL) 
+					ase_awk_clrpt (awk, px->args);
+				if (px->out != ASE_NULL) 
+					ase_awk_clrpt (awk, px->out);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_GRP:
+			case ASE_AWK_NDE_GRP:
 			{
-				sse_awk_clrpt (awk, ((sse_awk_nde_grp_t*)p)->body);
-				SSE_AWK_FREE (awk, p);
+				ase_awk_clrpt (awk, ((ase_awk_nde_grp_t*)p)->body);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_ASS:
+			case ASE_AWK_NDE_ASS:
 			{
-				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);
+				ase_awk_clrpt (awk, ((ase_awk_nde_ass_t*)p)->left);
+				ase_awk_clrpt (awk, ((ase_awk_nde_ass_t*)p)->right);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_EXP_BIN:
+			case ASE_AWK_NDE_EXP_BIN:
 			{
-				sse_awk_nde_exp_t* px = (sse_awk_nde_exp_t*)p;
-				sse_awk_assert (awk, px->left->next == SSE_NULL);
-				sse_awk_assert (awk, px->right->next == SSE_NULL);
+				ase_awk_nde_exp_t* px = (ase_awk_nde_exp_t*)p;
+				ase_awk_assert (awk, px->left->next == ASE_NULL);
+				ase_awk_assert (awk, px->right->next == ASE_NULL);
 
-				sse_awk_clrpt (awk, px->left);
-				sse_awk_clrpt (awk, px->right);
-				SSE_AWK_FREE (awk, p);
+				ase_awk_clrpt (awk, px->left);
+				ase_awk_clrpt (awk, px->right);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_EXP_UNR:
-			case SSE_AWK_NDE_EXP_INCPRE:
-			case SSE_AWK_NDE_EXP_INCPST:
+			case ASE_AWK_NDE_EXP_UNR:
+			case ASE_AWK_NDE_EXP_INCPRE:
+			case ASE_AWK_NDE_EXP_INCPST:
 			{
-				sse_awk_nde_exp_t* px = (sse_awk_nde_exp_t*)p;
-				sse_awk_assert (awk, px->right == SSE_NULL);
-				sse_awk_clrpt (awk, px->left);
-				SSE_AWK_FREE (awk, p);
+				ase_awk_nde_exp_t* px = (ase_awk_nde_exp_t*)p;
+				ase_awk_assert (awk, px->right == ASE_NULL);
+				ase_awk_clrpt (awk, px->left);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_CND:
+			case ASE_AWK_NDE_CND:
 			{
-				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);
+				ase_awk_clrpt (awk, ((ase_awk_nde_cnd_t*)p)->test);
+				ase_awk_clrpt (awk, ((ase_awk_nde_cnd_t*)p)->left);
+				ase_awk_clrpt (awk, ((ase_awk_nde_cnd_t*)p)->right);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_INT:
+			case ASE_AWK_NDE_INT:
 			{
-				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);
+				if (((ase_awk_nde_int_t*)p)->str != ASE_NULL)
+					ASE_AWK_FREE (awk, ((ase_awk_nde_int_t*)p)->str);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_REAL:
+			case ASE_AWK_NDE_REAL:
 			{
-				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);
+				if (((ase_awk_nde_real_t*)p)->str != ASE_NULL)
+					ASE_AWK_FREE (awk, ((ase_awk_nde_real_t*)p)->str);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_STR:
+			case ASE_AWK_NDE_STR:
 			{
-				SSE_AWK_FREE (awk, ((sse_awk_nde_str_t*)p)->buf);
-				SSE_AWK_FREE (awk, p);
+				ASE_AWK_FREE (awk, ((ase_awk_nde_str_t*)p)->buf);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_REX:
+			case ASE_AWK_NDE_REX:
 			{
-				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);
+				ASE_AWK_FREE (awk, ((ase_awk_nde_rex_t*)p)->buf);
+				ASE_AWK_FREE (awk, ((ase_awk_nde_rex_t*)p)->code);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_NAMED:
-			case SSE_AWK_NDE_GLOBAL:
-			case SSE_AWK_NDE_LOCAL:
-			case SSE_AWK_NDE_ARG:
+			case ASE_AWK_NDE_NAMED:
+			case ASE_AWK_NDE_GLOBAL:
+			case ASE_AWK_NDE_LOCAL:
+			case ASE_AWK_NDE_ARG:
 			{
-				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);
+				ase_awk_nde_var_t* px = (ase_awk_nde_var_t*)p;
+				ase_awk_assert (awk, px->idx == ASE_NULL);
+				if (px->id.name != ASE_NULL)
+					ASE_AWK_FREE (awk, px->id.name);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_NAMEDIDX:
-			case SSE_AWK_NDE_GLOBALIDX:
-			case SSE_AWK_NDE_LOCALIDX:
-			case SSE_AWK_NDE_ARGIDX:
+			case ASE_AWK_NDE_NAMEDIDX:
+			case ASE_AWK_NDE_GLOBALIDX:
+			case ASE_AWK_NDE_LOCALIDX:
+			case ASE_AWK_NDE_ARGIDX:
 			{
-				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);
+				ase_awk_nde_var_t* px = (ase_awk_nde_var_t*)p;
+				ase_awk_assert (awk, px->idx != ASE_NULL);
+				ase_awk_clrpt (awk, px->idx);
+				if (px->id.name != ASE_NULL)
+					ASE_AWK_FREE (awk, px->id.name);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_POS:
+			case ASE_AWK_NDE_POS:
 			{
-				sse_awk_clrpt (awk, ((sse_awk_nde_pos_t*)p)->val);
-				SSE_AWK_FREE (awk, p);
+				ase_awk_clrpt (awk, ((ase_awk_nde_pos_t*)p)->val);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_BFN:
+			case ASE_AWK_NDE_BFN:
 			{
-				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);
+				ase_awk_nde_call_t* px = (ase_awk_nde_call_t*)p;
+				/* ASE_AWK_FREE (awk, px->what.bfn); */
+				ase_awk_clrpt (awk, px->args);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_AFN:
+			case ASE_AWK_NDE_AFN:
 			{
-				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);
+				ase_awk_nde_call_t* px = (ase_awk_nde_call_t*)p;
+				ASE_AWK_FREE (awk, px->what.afn.name);
+				ase_awk_clrpt (awk, px->args);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
-			case SSE_AWK_NDE_GETLINE:
+			case ASE_AWK_NDE_GETLINE:
 			{
-				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);
+				ase_awk_nde_getline_t* px = 
+					(ase_awk_nde_getline_t*)p;
+				if (px->var != ASE_NULL) 
+					ase_awk_clrpt (awk, px->var);
+				if (px->in != ASE_NULL) 
+					ase_awk_clrpt (awk, px->in);
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 
 			default:
 			{
-				sse_awk_assert (awk, !"should never happen - invalid node type");
-				SSE_AWK_FREE (awk, p);
+				ase_awk_assert (awk, !"should never happen - invalid node type");
+				ASE_AWK_FREE (awk, p);
 				break;
 			}
 		}
diff --git a/ase/awk/tree.h b/ase/awk/tree.h
index a8b1855f..5ec6b7db 100644
--- a/ase/awk/tree.h
+++ b/ase/awk/tree.h
@@ -1,67 +1,67 @@
 /*
- * $Id: tree.h,v 1.76 2006-10-22 12:39:30 bacon Exp $
+ * $Id: tree.h,v 1.77 2006-10-24 04:10:12 bacon Exp $
  */
 
-#ifndef _SSE_AWK_TREE_H_
-#define _SSE_AWK_TREE_H_
+#ifndef _ASE_AWK_TREE_H_
+#define _ASE_AWK_TREE_H_
 
-#ifndef _SSE_AWK_AWK_H_
-#error Never include this file directly. Include <sse/awk/awk.h> instead
+#ifndef _ASE_AWK_AWK_H_
+#error Never include this file directly. Include <ase/awk/awk.h> instead
 #endif
 
 enum
 {
-	SSE_AWK_NDE_NULL,
+	ASE_AWK_NDE_NULL,
 
 	/* statement */
-	SSE_AWK_NDE_BLK,
-	SSE_AWK_NDE_IF,
-	SSE_AWK_NDE_WHILE,
-	SSE_AWK_NDE_DOWHILE,
-	SSE_AWK_NDE_FOR,
-	SSE_AWK_NDE_FOREACH,
-	SSE_AWK_NDE_BREAK,
-	SSE_AWK_NDE_CONTINUE,
-	SSE_AWK_NDE_RETURN,
-	SSE_AWK_NDE_EXIT,
-	SSE_AWK_NDE_NEXT,
-	SSE_AWK_NDE_NEXTFILE,
-	SSE_AWK_NDE_DELETE,
-	SSE_AWK_NDE_PRINT,
+	ASE_AWK_NDE_BLK,
+	ASE_AWK_NDE_IF,
+	ASE_AWK_NDE_WHILE,
+	ASE_AWK_NDE_DOWHILE,
+	ASE_AWK_NDE_FOR,
+	ASE_AWK_NDE_FOREACH,
+	ASE_AWK_NDE_BREAK,
+	ASE_AWK_NDE_CONTINUE,
+	ASE_AWK_NDE_RETURN,
+	ASE_AWK_NDE_EXIT,
+	ASE_AWK_NDE_NEXT,
+	ASE_AWK_NDE_NEXTFILE,
+	ASE_AWK_NDE_DELETE,
+	ASE_AWK_NDE_PRINT,
 
 	/* expression */
 	/* if you change the following values including their order,
 	 * you should change __eval_func of __eval_expression 
 	 * in run.c accordingly */
-	SSE_AWK_NDE_GRP, 
-	SSE_AWK_NDE_ASS,
-	SSE_AWK_NDE_EXP_BIN,
-	SSE_AWK_NDE_EXP_UNR,
-	SSE_AWK_NDE_EXP_INCPRE,
-	SSE_AWK_NDE_EXP_INCPST,
-	SSE_AWK_NDE_CND,
-	SSE_AWK_NDE_BFN,
-	SSE_AWK_NDE_AFN,
-	SSE_AWK_NDE_INT,
-	SSE_AWK_NDE_REAL,
-	SSE_AWK_NDE_STR,
-	SSE_AWK_NDE_REX,
+	ASE_AWK_NDE_GRP, 
+	ASE_AWK_NDE_ASS,
+	ASE_AWK_NDE_EXP_BIN,
+	ASE_AWK_NDE_EXP_UNR,
+	ASE_AWK_NDE_EXP_INCPRE,
+	ASE_AWK_NDE_EXP_INCPST,
+	ASE_AWK_NDE_CND,
+	ASE_AWK_NDE_BFN,
+	ASE_AWK_NDE_AFN,
+	ASE_AWK_NDE_INT,
+	ASE_AWK_NDE_REAL,
+	ASE_AWK_NDE_STR,
+	ASE_AWK_NDE_REX,
 
 	/* keep this order for the following items otherwise, you may have 
 	 * to change __eval_incpre and __eval_incpst in run.c as well as
-	 * SSE_AWK_VAL_REF_XXX in val.h */
-	SSE_AWK_NDE_NAMED,
-	SSE_AWK_NDE_GLOBAL,
-	SSE_AWK_NDE_LOCAL,
-	SSE_AWK_NDE_ARG,
-	SSE_AWK_NDE_NAMEDIDX,
-	SSE_AWK_NDE_GLOBALIDX,
-	SSE_AWK_NDE_LOCALIDX,
-	SSE_AWK_NDE_ARGIDX,
-	SSE_AWK_NDE_POS,
+	 * ASE_AWK_VAL_REF_XXX in val.h */
+	ASE_AWK_NDE_NAMED,
+	ASE_AWK_NDE_GLOBAL,
+	ASE_AWK_NDE_LOCAL,
+	ASE_AWK_NDE_ARG,
+	ASE_AWK_NDE_NAMEDIDX,
+	ASE_AWK_NDE_GLOBALIDX,
+	ASE_AWK_NDE_LOCALIDX,
+	ASE_AWK_NDE_ARGIDX,
+	ASE_AWK_NDE_POS,
 	/* ---------------------------------- */
 
-	SSE_AWK_NDE_GETLINE,
+	ASE_AWK_NDE_GETLINE,
 };
 
 enum
@@ -69,10 +69,10 @@ enum
 	/* the order of these values match 
 	 * __in_type_map and __in_opt_map in extio.c */
 
-	SSE_AWK_IN_PIPE,
-	SSE_AWK_IN_COPROC,
-	SSE_AWK_IN_FILE,
-	SSE_AWK_IN_CONSOLE
+	ASE_AWK_IN_PIPE,
+	ASE_AWK_IN_COPROC,
+	ASE_AWK_IN_FILE,
+	ASE_AWK_IN_CONSOLE
 };
 
 enum
@@ -80,298 +80,298 @@ enum
 	/* the order of these values match 
 	 * __out_type_map and __out_opt_map in extio.c */
 
-	SSE_AWK_OUT_PIPE,
-	SSE_AWK_OUT_COPROC,
-	SSE_AWK_OUT_FILE,
-	SSE_AWK_OUT_FILE_APPEND,
-	SSE_AWK_OUT_CONSOLE
+	ASE_AWK_OUT_PIPE,
+	ASE_AWK_OUT_COPROC,
+	ASE_AWK_OUT_FILE,
+	ASE_AWK_OUT_FILE_APPEND,
+	ASE_AWK_OUT_CONSOLE
 };
 
 /* afn (awk function defined with the keyword function) */
-typedef struct sse_awk_afn_t sse_awk_afn_t;
+typedef struct ase_awk_afn_t ase_awk_afn_t;
 
-typedef struct sse_awk_nde_t sse_awk_nde_t;
+typedef struct ase_awk_nde_t ase_awk_nde_t;
 
-typedef struct sse_awk_nde_blk_t       sse_awk_nde_blk_t;
-typedef struct sse_awk_nde_grp_t       sse_awk_nde_grp_t;
-typedef struct sse_awk_nde_ass_t       sse_awk_nde_ass_t;
-typedef struct sse_awk_nde_exp_t       sse_awk_nde_exp_t;
-typedef struct sse_awk_nde_cnd_t       sse_awk_nde_cnd_t;
-typedef struct sse_awk_nde_pos_t       sse_awk_nde_pos_t;
-typedef struct sse_awk_nde_int_t       sse_awk_nde_int_t;
-typedef struct sse_awk_nde_real_t      sse_awk_nde_real_t;
-typedef struct sse_awk_nde_str_t       sse_awk_nde_str_t;
-typedef struct sse_awk_nde_rex_t       sse_awk_nde_rex_t;
-typedef struct sse_awk_nde_var_t       sse_awk_nde_var_t;
-typedef struct sse_awk_nde_call_t      sse_awk_nde_call_t;
-typedef struct sse_awk_nde_getline_t   sse_awk_nde_getline_t;
+typedef struct ase_awk_nde_blk_t       ase_awk_nde_blk_t;
+typedef struct ase_awk_nde_grp_t       ase_awk_nde_grp_t;
+typedef struct ase_awk_nde_ass_t       ase_awk_nde_ass_t;
+typedef struct ase_awk_nde_exp_t       ase_awk_nde_exp_t;
+typedef struct ase_awk_nde_cnd_t       ase_awk_nde_cnd_t;
+typedef struct ase_awk_nde_pos_t       ase_awk_nde_pos_t;
+typedef struct ase_awk_nde_int_t       ase_awk_nde_int_t;
+typedef struct ase_awk_nde_real_t      ase_awk_nde_real_t;
+typedef struct ase_awk_nde_str_t       ase_awk_nde_str_t;
+typedef struct ase_awk_nde_rex_t       ase_awk_nde_rex_t;
+typedef struct ase_awk_nde_var_t       ase_awk_nde_var_t;
+typedef struct ase_awk_nde_call_t      ase_awk_nde_call_t;
+typedef struct ase_awk_nde_getline_t   ase_awk_nde_getline_t;
 
-typedef struct sse_awk_nde_if_t        sse_awk_nde_if_t;
-typedef struct sse_awk_nde_while_t     sse_awk_nde_while_t;
-typedef struct sse_awk_nde_for_t       sse_awk_nde_for_t;
-typedef struct sse_awk_nde_foreach_t   sse_awk_nde_foreach_t;
-typedef struct sse_awk_nde_break_t     sse_awk_nde_break_t;
-typedef struct sse_awk_nde_continue_t  sse_awk_nde_continue_t;
-typedef struct sse_awk_nde_return_t    sse_awk_nde_return_t;
-typedef struct sse_awk_nde_exit_t      sse_awk_nde_exit_t;
-typedef struct sse_awk_nde_next_t      sse_awk_nde_next_t;
-typedef struct sse_awk_nde_nextfile_t  sse_awk_nde_nextfile_t;
-typedef struct sse_awk_nde_delete_t    sse_awk_nde_delete_t;
-typedef struct sse_awk_nde_print_t     sse_awk_nde_print_t;
+typedef struct ase_awk_nde_if_t        ase_awk_nde_if_t;
+typedef struct ase_awk_nde_while_t     ase_awk_nde_while_t;
+typedef struct ase_awk_nde_for_t       ase_awk_nde_for_t;
+typedef struct ase_awk_nde_foreach_t   ase_awk_nde_foreach_t;
+typedef struct ase_awk_nde_break_t     ase_awk_nde_break_t;
+typedef struct ase_awk_nde_continue_t  ase_awk_nde_continue_t;
+typedef struct ase_awk_nde_return_t    ase_awk_nde_return_t;
+typedef struct ase_awk_nde_exit_t      ase_awk_nde_exit_t;
+typedef struct ase_awk_nde_next_t      ase_awk_nde_next_t;
+typedef struct ase_awk_nde_nextfile_t  ase_awk_nde_nextfile_t;
+typedef struct ase_awk_nde_delete_t    ase_awk_nde_delete_t;
+typedef struct ase_awk_nde_print_t     ase_awk_nde_print_t;
 
-struct sse_awk_afn_t
+struct ase_awk_afn_t
 {
-	sse_char_t* name;
-	sse_size_t name_len;
-	sse_size_t nargs;
-	sse_awk_nde_t* body;
+	ase_char_t* name;
+	ase_size_t name_len;
+	ase_size_t nargs;
+	ase_awk_nde_t* body;
 };
 
-#define SSE_AWK_NDE_HDR \
+#define ASE_AWK_NDE_HDR \
 	int type; \
-	sse_awk_nde_t* next
+	ase_awk_nde_t* next
 
-struct sse_awk_nde_t
+struct ase_awk_nde_t
 {
-	SSE_AWK_NDE_HDR;
+	ASE_AWK_NDE_HDR;
 };
 
-/* SSE_AWK_NDE_BLK - block statement including top-level blocks */
-struct sse_awk_nde_blk_t
+/* ASE_AWK_NDE_BLK - block statement including top-level blocks */
+struct ase_awk_nde_blk_t
 {
-	SSE_AWK_NDE_HDR;
-	sse_size_t nlocals;
-	sse_awk_nde_t* body;
+	ASE_AWK_NDE_HDR;
+	ase_size_t nlocals;
+	ase_awk_nde_t* body;
 };
 
-/* SSE_AWK_NDE_GRP - expression group */
-struct sse_awk_nde_grp_t
+/* ASE_AWK_NDE_GRP - expression group */
+struct ase_awk_nde_grp_t
 {
-	SSE_AWK_NDE_HDR;
-	sse_awk_nde_t* body;
+	ASE_AWK_NDE_HDR;
+	ase_awk_nde_t* body;
 };
 
-/* SSE_AWK_NDE_ASS - assignment */
-struct sse_awk_nde_ass_t
+/* ASE_AWK_NDE_ASS - assignment */
+struct ase_awk_nde_ass_t
 {
-	SSE_AWK_NDE_HDR;
+	ASE_AWK_NDE_HDR;
 	int opcode;
-	sse_awk_nde_t* left;
-	sse_awk_nde_t* right;
+	ase_awk_nde_t* left;
+	ase_awk_nde_t* right;
 };
 
-/* SSE_AWK_NDE_EXP_BIN, SSE_AWK_NDE_EXP_UNR, 
- * SSE_AWK_NDE_EXP_INCPRE, SSE_AW_NDE_EXP_INCPST */
-struct sse_awk_nde_exp_t
+/* ASE_AWK_NDE_EXP_BIN, ASE_AWK_NDE_EXP_UNR, 
+ * ASE_AWK_NDE_EXP_INCPRE, ASE_AW_NDE_EXP_INCPST */
+struct ase_awk_nde_exp_t
 {
-	SSE_AWK_NDE_HDR;
+	ASE_AWK_NDE_HDR;
 	int opcode;
-	sse_awk_nde_t* left;
-	sse_awk_nde_t* right; /* SSE_NULL for UNR, INCPRE, INCPST */
+	ase_awk_nde_t* left;
+	ase_awk_nde_t* right; /* ASE_NULL for UNR, INCPRE, INCPST */
 };
 
-/* SSE_AWK_NDE_CND */
-struct sse_awk_nde_cnd_t
+/* ASE_AWK_NDE_CND */
+struct ase_awk_nde_cnd_t
 {
-	SSE_AWK_NDE_HDR;
-	sse_awk_nde_t* test;
-	sse_awk_nde_t* left;
-	sse_awk_nde_t* right;
+	ASE_AWK_NDE_HDR;
+	ase_awk_nde_t* test;
+	ase_awk_nde_t* left;
+	ase_awk_nde_t* right;
 };
 
-/* SSE_AWK_NDE_POS - positional - $1, $2, $x, etc */
-struct sse_awk_nde_pos_t  
+/* ASE_AWK_NDE_POS - positional - $1, $2, $x, etc */
+struct ase_awk_nde_pos_t  
 {
-	SSE_AWK_NDE_HDR;
-	sse_awk_nde_t* val;	
+	ASE_AWK_NDE_HDR;
+	ase_awk_nde_t* val;	
 };
 
-/* SSE_AWK_NDE_INT */
-struct sse_awk_nde_int_t
+/* ASE_AWK_NDE_INT */
+struct ase_awk_nde_int_t
 {
-	SSE_AWK_NDE_HDR;
-	sse_long_t val;
-	sse_char_t* str; 
-	sse_size_t  len;
+	ASE_AWK_NDE_HDR;
+	ase_long_t val;
+	ase_char_t* str; 
+	ase_size_t  len;
 };
 
-/* SSE_AWK_NDE_REAL */
-struct sse_awk_nde_real_t
+/* ASE_AWK_NDE_REAL */
+struct ase_awk_nde_real_t
 {
-	SSE_AWK_NDE_HDR;
-	sse_real_t val;
-	sse_char_t* str;
-	sse_size_t  len;
+	ASE_AWK_NDE_HDR;
+	ase_real_t val;
+	ase_char_t* str;
+	ase_size_t  len;
 };
 
-/* SSE_AWK_NDE_STR */
-struct sse_awk_nde_str_t
+/* ASE_AWK_NDE_STR */
+struct ase_awk_nde_str_t
 {
-	SSE_AWK_NDE_HDR;
-	sse_char_t* buf;
-	sse_size_t  len;
+	ASE_AWK_NDE_HDR;
+	ase_char_t* buf;
+	ase_size_t  len;
 };
 
-/* SSE_AWK_NDE_REX */
-struct sse_awk_nde_rex_t
+/* ASE_AWK_NDE_REX */
+struct ase_awk_nde_rex_t
 {
-	SSE_AWK_NDE_HDR;
-	sse_char_t* buf;
-	sse_size_t  len;
+	ASE_AWK_NDE_HDR;
+	ase_char_t* buf;
+	ase_size_t  len;
 	void*      code;
 };
 
-/* SSE_AWK_NDE_NAMED, SSE_AWK_NDE_GLOBAL, 
- * SSE_AWK_NDE_LOCAL, SSE_AWK_NDE_ARG 
- * SSE_AWK_NDE_NAMEDIDX, SSE_AWK_NDE_GLOBALIDX, 
- * SSE_AWK_NDE_LOCALIDX, SSE_AWK_NDE_ARGIDX */
-struct sse_awk_nde_var_t
+/* ASE_AWK_NDE_NAMED, ASE_AWK_NDE_GLOBAL, 
+ * ASE_AWK_NDE_LOCAL, ASE_AWK_NDE_ARG 
+ * ASE_AWK_NDE_NAMEDIDX, ASE_AWK_NDE_GLOBALIDX, 
+ * ASE_AWK_NDE_LOCALIDX, ASE_AWK_NDE_ARGIDX */
+struct ase_awk_nde_var_t
 {
-	SSE_AWK_NDE_HDR;
+	ASE_AWK_NDE_HDR;
 	struct 
 	{
-		sse_char_t* name;
-		sse_size_t  name_len;
-		sse_size_t  idxa;
+		ase_char_t* name;
+		ase_size_t  name_len;
+		ase_size_t  idxa;
 	} id;
-	sse_awk_nde_t* idx; /* SSE_NULL for non-XXXXIDX */
+	ase_awk_nde_t* idx; /* ASE_NULL for non-XXXXIDX */
 };
 
-/* SSE_AWK_NDE_BFN, SSE_AWK_NDE_AFN */
-struct sse_awk_nde_call_t
+/* ASE_AWK_NDE_BFN, ASE_AWK_NDE_AFN */
+struct ase_awk_nde_call_t
 {
-	SSE_AWK_NDE_HDR;
+	ASE_AWK_NDE_HDR;
 	union
 	{
 		struct
 		{
-			sse_char_t* name;
-			sse_size_t name_len;
+			ase_char_t* name;
+			ase_size_t name_len;
 		} afn;
 
 		/* minimum information of a built-in function 
 		 * needed during run-time. */
 		struct
 		{
-			const sse_char_t* name;
-			sse_size_t name_len;
-			sse_size_t min_args;
-			sse_size_t max_args;
-			const sse_char_t* arg_spec;
-			int (*handler) (sse_awk_run_t* awk);
+			const ase_char_t* name;
+			ase_size_t name_len;
+			ase_size_t min_args;
+			ase_size_t max_args;
+			const ase_char_t* arg_spec;
+			int (*handler) (ase_awk_run_t* awk);
 		} bfn;
-		/* sse_awk_bfn_t* bfn; */
+		/* ase_awk_bfn_t* bfn; */
 	} what;
-	sse_awk_nde_t* args;
-	sse_size_t nargs;
+	ase_awk_nde_t* args;
+	ase_size_t nargs;
 };
 
-/* SSE_AWK_NDE_GETLINE */
-struct sse_awk_nde_getline_t
+/* ASE_AWK_NDE_GETLINE */
+struct ase_awk_nde_getline_t
 {
-	SSE_AWK_NDE_HDR;
-	sse_awk_nde_t* var;
-	int in_type; /* SSE_AWK_GETLINE_XXX */
-	sse_awk_nde_t* in;
+	ASE_AWK_NDE_HDR;
+	ase_awk_nde_t* var;
+	int in_type; /* ASE_AWK_GETLINE_XXX */
+	ase_awk_nde_t* in;
 };
 
-/* SSE_AWK_NDE_IF */
-struct sse_awk_nde_if_t
+/* ASE_AWK_NDE_IF */
+struct ase_awk_nde_if_t
 {
-	SSE_AWK_NDE_HDR;
-	sse_awk_nde_t* test;
-	sse_awk_nde_t* then_part;
-	sse_awk_nde_t* else_part; /* optional */
+	ASE_AWK_NDE_HDR;
+	ase_awk_nde_t* test;
+	ase_awk_nde_t* then_part;
+	ase_awk_nde_t* else_part; /* optional */
 };
 
-/* SSE_AWK_NDE_WHILE, SSE_AWK_NDE_DOWHILE */
-struct sse_awk_nde_while_t
+/* ASE_AWK_NDE_WHILE, ASE_AWK_NDE_DOWHILE */
+struct ase_awk_nde_while_t
 {
-	SSE_AWK_NDE_HDR; 
-	sse_awk_nde_t* test;
-	sse_awk_nde_t* body;
+	ASE_AWK_NDE_HDR; 
+	ase_awk_nde_t* test;
+	ase_awk_nde_t* body;
 };
 
-/* SSE_AWK_NDE_FOR */
-struct sse_awk_nde_for_t
+/* ASE_AWK_NDE_FOR */
+struct ase_awk_nde_for_t
 {
-	SSE_AWK_NDE_HDR;
-	sse_awk_nde_t* init; /* optional */
-	sse_awk_nde_t* test; /* optional */
-	sse_awk_nde_t* incr; /* optional */
-	sse_awk_nde_t* body;
+	ASE_AWK_NDE_HDR;
+	ase_awk_nde_t* init; /* optional */
+	ase_awk_nde_t* test; /* optional */
+	ase_awk_nde_t* incr; /* optional */
+	ase_awk_nde_t* body;
 };
 
-/* SSE_AWK_NDE_FOREACH */
-struct sse_awk_nde_foreach_t
+/* ASE_AWK_NDE_FOREACH */
+struct ase_awk_nde_foreach_t
 {
-	SSE_AWK_NDE_HDR;
-	sse_awk_nde_t* test;
-	sse_awk_nde_t* body;
+	ASE_AWK_NDE_HDR;
+	ase_awk_nde_t* test;
+	ase_awk_nde_t* body;
 };
 
-/* SSE_AWK_NDE_BREAK */
-struct sse_awk_nde_break_t
+/* ASE_AWK_NDE_BREAK */
+struct ase_awk_nde_break_t
 {
-	SSE_AWK_NDE_HDR;
+	ASE_AWK_NDE_HDR;
 };
 
-/* SSE_AWK_NDE_CONTINUE */
-struct sse_awk_nde_continue_t
+/* ASE_AWK_NDE_CONTINUE */
+struct ase_awk_nde_continue_t
 {
-	SSE_AWK_NDE_HDR;
+	ASE_AWK_NDE_HDR;
 };
 
-/* SSE_AWK_NDE_RETURN */
-struct sse_awk_nde_return_t
+/* ASE_AWK_NDE_RETURN */
+struct ase_awk_nde_return_t
 {
-	SSE_AWK_NDE_HDR;
-	sse_awk_nde_t* val; /* optional (no return code if SSE_NULL) */	
+	ASE_AWK_NDE_HDR;
+	ase_awk_nde_t* val; /* optional (no return code if ASE_NULL) */	
 };
 
-/* SSE_AWK_NDE_EXIT */
-struct sse_awk_nde_exit_t
+/* ASE_AWK_NDE_EXIT */
+struct ase_awk_nde_exit_t
 {
-	SSE_AWK_NDE_HDR;
-	sse_awk_nde_t* val; /* optional (no exit code if SSE_NULL) */
+	ASE_AWK_NDE_HDR;
+	ase_awk_nde_t* val; /* optional (no exit code if ASE_NULL) */
 };
 
-/* SSE_AWK_NDE_NEXT */
-struct sse_awk_nde_next_t
+/* ASE_AWK_NDE_NEXT */
+struct ase_awk_nde_next_t
 {
-	SSE_AWK_NDE_HDR;
+	ASE_AWK_NDE_HDR;
 };
 
-/* SSE_AWK_NDE_NEXTFILE */
-struct sse_awk_nde_nextfile_t
+/* ASE_AWK_NDE_NEXTFILE */
+struct ase_awk_nde_nextfile_t
 {
-	SSE_AWK_NDE_HDR;
+	ASE_AWK_NDE_HDR;
 };
 
-/* SSE_AWK_NDE_DELETE */
-struct sse_awk_nde_delete_t
+/* ASE_AWK_NDE_DELETE */
+struct ase_awk_nde_delete_t
 {
-	SSE_AWK_NDE_HDR;
-	sse_awk_nde_t* var;
+	ASE_AWK_NDE_HDR;
+	ase_awk_nde_t* var;
 };
 
-/* SSE_AWK_NDE_PRINT */
-struct sse_awk_nde_print_t
+/* ASE_AWK_NDE_PRINT */
+struct ase_awk_nde_print_t
 {
-	SSE_AWK_NDE_HDR;
-	sse_awk_nde_t* args;
-	int out_type; /* SSE_AWK_OUT_XXX */
-	sse_awk_nde_t* out;
+	ASE_AWK_NDE_HDR;
+	ase_awk_nde_t* args;
+	int out_type; /* ASE_AWK_OUT_XXX */
+	ase_awk_nde_t* out;
 };
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-int sse_awk_prnpt (sse_awk_t* awk, sse_awk_nde_t* tree);
-int sse_awk_prnptnpt (sse_awk_t* awk, sse_awk_nde_t* tree);
+int ase_awk_prnpt (ase_awk_t* awk, ase_awk_nde_t* tree);
+int ase_awk_prnptnpt (ase_awk_t* awk, ase_awk_nde_t* tree);
 
-void sse_awk_clrpt (sse_awk_t* awk, sse_awk_nde_t* tree);
+void ase_awk_clrpt (ase_awk_t* awk, ase_awk_nde_t* tree);
 
 #ifdef __cplusplus
 }
diff --git a/ase/awk/val.c b/ase/awk/val.c
index e6c6abd7..038e7cf2 100644
--- a/ase/awk/val.c
+++ b/ase/awk/val.c
@@ -1,51 +1,51 @@
 /*
- * $Id: val.c,v 1.75 2006-10-22 12:39:30 bacon Exp $
+ * $Id: val.c,v 1.76 2006-10-24 04:10:12 bacon Exp $
  */
 
-#include <sse/awk/awk_i.h>
+#include <ase/awk/awk_i.h>
 
-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 ase_char_t* __str_to_str (
+	ase_awk_run_t* run, const ase_char_t* str, ase_size_t str_len,
+	int opt, ase_awk_str_t* buf, ase_size_t* len);
+static ase_char_t* __val_int_to_str (
+	ase_awk_run_t* run, ase_awk_val_int_t* v,
+	int opt, ase_awk_str_t* buf, ase_size_t* len);
+static ase_char_t* __val_real_to_str (
+	ase_awk_run_t* run, ase_awk_val_real_t* v,
+	int opt, ase_awk_str_t* buf, ase_size_t* len);
 
-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 ase_awk_val_nil_t __awk_nil = { ASE_AWK_VAL_NIL, 0 };
+ase_awk_val_t* ase_awk_val_nil = (ase_awk_val_t*)&__awk_nil;
 
-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 ase_awk_val_str_t __awk_zls = { ASE_AWK_VAL_STR, 0, ASE_T(""), 0 };
+ase_awk_val_t* ase_awk_val_zls = (ase_awk_val_t*)&__awk_zls; 
 
-static sse_awk_val_int_t __awk_int[] =
+static ase_awk_val_int_t __awk_int[] =
 {
-	{ 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 },
+	{ ASE_AWK_VAL_INT, 0, -1 },
+	{ ASE_AWK_VAL_INT, 0,  0 },
+	{ ASE_AWK_VAL_INT, 0,  1 },
+	{ ASE_AWK_VAL_INT, 0,  2 },
+	{ ASE_AWK_VAL_INT, 0,  3 },
+	{ ASE_AWK_VAL_INT, 0,  4 },
+	{ ASE_AWK_VAL_INT, 0,  5 },
+	{ ASE_AWK_VAL_INT, 0,  6 },
+	{ ASE_AWK_VAL_INT, 0,  7 },
+	{ ASE_AWK_VAL_INT, 0,  8 },
+	{ ASE_AWK_VAL_INT, 0,  9 },
 };
 
-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];
+ase_awk_val_t* ase_awk_val_zero = (ase_awk_val_t*)&__awk_int[1];
+ase_awk_val_t* ase_awk_val_one = (ase_awk_val_t*)&__awk_int[2];
 
-sse_awk_val_t* sse_awk_makeintval (sse_awk_run_t* run, sse_long_t v)
+ase_awk_val_t* ase_awk_makeintval (ase_awk_run_t* run, ase_long_t v)
 {
-	sse_awk_val_int_t* val;
+	ase_awk_val_int_t* val;
 
 	if (v >= __awk_int[0].val && 
-	    v <= __awk_int[sse_countof(__awk_int)-1].val)
+	    v <= __awk_int[ase_countof(__awk_int)-1].val)
 	{
-		return (sse_awk_val_t*)&__awk_int[v-__awk_int[0].val];
+		return (ase_awk_val_t*)&__awk_int[v-__awk_int[0].val];
 	}
 
 	if (run->icache_count > 0)
@@ -54,23 +54,23 @@ sse_awk_val_t* sse_awk_makeintval (sse_awk_run_t* run, sse_long_t v)
 	}
 	else
 	{
-		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 = (ase_awk_val_int_t*) ASE_AWK_MALLOC (
+			run->awk, ase_sizeof(ase_awk_val_int_t));
+		if (val == ASE_NULL) return ASE_NULL;
 	}
 
-	val->type = SSE_AWK_VAL_INT;
+	val->type = ASE_AWK_VAL_INT;
 	val->ref = 0;
 	val->val = v;
-	val->nde = SSE_NULL;
+	val->nde = ASE_NULL;
 
-/*xp_printf (SSE_T("makeintval => %p\n"), val);*/
-	return (sse_awk_val_t*)val;
+/*xp_printf (ASE_T("makeintval => %p\n"), val);*/
+	return (ase_awk_val_t*)val;
 }
 
-sse_awk_val_t* sse_awk_makerealval (sse_awk_run_t* run, sse_real_t v)
+ase_awk_val_t* ase_awk_makerealval (ase_awk_run_t* run, ase_real_t v)
 {
-	sse_awk_val_real_t* val;
+	ase_awk_val_real_t* val;
 
 	if (run->rcache_count > 0)
 	{
@@ -78,138 +78,138 @@ sse_awk_val_t* sse_awk_makerealval (sse_awk_run_t* run, sse_real_t v)
 	}
 	else
 	{
-		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 = (ase_awk_val_real_t*) ASE_AWK_MALLOC (
+			run->awk, ase_sizeof(ase_awk_val_real_t));
+		if (val == ASE_NULL) return ASE_NULL;
 	}
 
-	val->type = SSE_AWK_VAL_REAL;
+	val->type = ASE_AWK_VAL_REAL;
 	val->ref = 0;
 	val->val = v;
-	val->nde = SSE_NULL;
+	val->nde = ASE_NULL;
 
-/*xp_printf (SSE_T("makerealval => %p\n"), val);*/
-	return (sse_awk_val_t*)val;
+/*xp_printf (ASE_T("makerealval => %p\n"), val);*/
+	return (ase_awk_val_t*)val;
 }
 
-sse_awk_val_t* sse_awk_makestrval0 (sse_awk_run_t* run, const sse_char_t* str)
+ase_awk_val_t* ase_awk_makestrval0 (ase_awk_run_t* run, const ase_char_t* str)
 {
-	return sse_awk_makestrval (run, str, sse_awk_strlen(str));
+	return ase_awk_makestrval (run, str, ase_awk_strlen(str));
 }
 
-sse_awk_val_t* sse_awk_makestrval (
-	sse_awk_run_t* run, const sse_char_t* str, sse_size_t len)
+ase_awk_val_t* ase_awk_makestrval (
+	ase_awk_run_t* run, const ase_char_t* str, ase_size_t len)
 {
-	sse_awk_val_str_t* val;
+	ase_awk_val_str_t* val;
 
-	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 = (ase_awk_val_str_t*) ASE_AWK_MALLOC (
+		run->awk, ase_sizeof(ase_awk_val_str_t));
+	if (val == ASE_NULL) return ASE_NULL;
 
-	val->type = SSE_AWK_VAL_STR;
+	val->type = ASE_AWK_VAL_STR;
 	val->ref = 0;
 	val->len = len;
-	val->buf = sse_awk_strxdup (run->awk, str, len);
-	if (val->buf == SSE_NULL) 
+	val->buf = ase_awk_strxdup (run->awk, str, len);
+	if (val->buf == ASE_NULL) 
 	{
-		SSE_AWK_FREE (run->awk, val);
-		return SSE_NULL;
+		ASE_AWK_FREE (run->awk, val);
+		return ASE_NULL;
 	}
 
-/*xp_printf (SSE_T("makestrval => %p\n"), val);*/
-	return (sse_awk_val_t*)val;
+/*xp_printf (ASE_T("makestrval => %p\n"), val);*/
+	return (ase_awk_val_t*)val;
 }
 
-sse_awk_val_t* sse_awk_makestrval2 (
-	sse_awk_run_t* run,
-	const sse_char_t* str1, sse_size_t len1, 
-	const sse_char_t* str2, sse_size_t len2)
+ase_awk_val_t* ase_awk_makestrval2 (
+	ase_awk_run_t* run,
+	const ase_char_t* str1, ase_size_t len1, 
+	const ase_char_t* str2, ase_size_t len2)
 {
-	sse_awk_val_str_t* val;
+	ase_awk_val_str_t* val;
 
-	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 = (ase_awk_val_str_t*) ASE_AWK_MALLOC (
+		run->awk, ase_sizeof(ase_awk_val_str_t));
+	if (val == ASE_NULL) return ASE_NULL;
 
-	val->type = SSE_AWK_VAL_STR;
+	val->type = ASE_AWK_VAL_STR;
 	val->ref = 0;
 	val->len = len1 + len2;
-	val->buf = sse_awk_strxdup2 (run->awk, str1, len1, str2, len2);
-	if (val->buf == SSE_NULL) 
+	val->buf = ase_awk_strxdup2 (run->awk, str1, len1, str2, len2);
+	if (val->buf == ASE_NULL) 
 	{
-		SSE_AWK_FREE (run->awk, val);
-		return SSE_NULL;
+		ASE_AWK_FREE (run->awk, val);
+		return ASE_NULL;
 	}
 
-/*xp_printf (SSE_T("makestrval2 => %p\n"), val);*/
-	return (sse_awk_val_t*)val;
+/*xp_printf (ASE_T("makestrval2 => %p\n"), val);*/
+	return (ase_awk_val_t*)val;
 }
 
-sse_awk_val_t* sse_awk_makerexval (
-	sse_awk_run_t* run, const sse_char_t* buf, sse_size_t len, void* code)
+ase_awk_val_t* ase_awk_makerexval (
+	ase_awk_run_t* run, const ase_char_t* buf, ase_size_t len, void* code)
 {
-	sse_awk_val_rex_t* val;
+	ase_awk_val_rex_t* val;
 
-	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 = (ase_awk_val_rex_t*) ASE_AWK_MALLOC (
+		run->awk, ase_sizeof(ase_awk_val_rex_t));
+	if (val == ASE_NULL) return ASE_NULL;
 
-	val->type = SSE_AWK_VAL_REX;
+	val->type = ASE_AWK_VAL_REX;
 	val->ref = 0;
 	val->len = len;
-	val->buf = sse_awk_strxdup (run->awk, buf, len);
-	if (val->buf == SSE_NULL) 
+	val->buf = ase_awk_strxdup (run->awk, buf, len);
+	if (val->buf == ASE_NULL) 
 	{
-		SSE_AWK_FREE (run->awk, val);
-		return SSE_NULL;
+		ASE_AWK_FREE (run->awk, val);
+		return ASE_NULL;
 	}
 
-	val->code = SSE_AWK_MALLOC (run->awk, SSE_AWK_REX_LEN(code));
-	if (val->code == SSE_NULL)
+	val->code = ASE_AWK_MALLOC (run->awk, ASE_AWK_REX_LEN(code));
+	if (val->code == ASE_NULL)
 	{
-		SSE_AWK_FREE (run->awk, val->buf);
-		SSE_AWK_FREE (run->awk, val);
-		return SSE_NULL;
+		ASE_AWK_FREE (run->awk, val->buf);
+		ASE_AWK_FREE (run->awk, val);
+		return ASE_NULL;
 	}
 
-	SSE_AWK_MEMCPY (run->awk, val->code, code, SSE_AWK_REX_LEN(code));
-	return (sse_awk_val_t*)val;
+	ASE_AWK_MEMCPY (run->awk, val->code, code, ASE_AWK_REX_LEN(code));
+	return (ase_awk_val_t*)val;
 }
 
 static void __free_map_val (void* run, void* v)
 {
 /*
-xp_printf (SSE_T("refdown in map free..."));
-sse_awk_printval (v);
-xp_printf (SSE_T("\n"));
+xp_printf (ASE_T("refdown in map free..."));
+ase_awk_printval (v);
+xp_printf (ASE_T("\n"));
 */
-	sse_awk_refdownval (run, v);
+	ase_awk_refdownval (run, v);
 }
 
-sse_awk_val_t* sse_awk_makemapval (sse_awk_run_t* run)
+ase_awk_val_t* ase_awk_makemapval (ase_awk_run_t* run)
 {
-	sse_awk_val_map_t* val;
+	ase_awk_val_map_t* val;
 
-	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 = (ase_awk_val_map_t*) ASE_AWK_MALLOC (
+		run->awk, ase_sizeof(ase_awk_val_map_t));
+	if (val == ASE_NULL) return ASE_NULL;
 
-	val->type = SSE_AWK_VAL_MAP;
+	val->type = ASE_AWK_VAL_MAP;
 	val->ref = 0;
-	val->map = sse_awk_map_open (
-		SSE_NULL, run, 256, __free_map_val, run->awk);
-	if (val->map == SSE_NULL)
+	val->map = ase_awk_map_open (
+		ASE_NULL, run, 256, __free_map_val, run->awk);
+	if (val->map == ASE_NULL)
 	{
-		SSE_AWK_FREE (run->awk, val);
-		return SSE_NULL;
+		ASE_AWK_FREE (run->awk, val);
+		return ASE_NULL;
 	}
 
-	return (sse_awk_val_t*)val;
+	return (ase_awk_val_t*)val;
 }
 
-sse_awk_val_t* sse_awk_makerefval (sse_awk_run_t* run, int id, sse_awk_val_t** adr)
+ase_awk_val_t* ase_awk_makerefval (ase_awk_run_t* run, int id, ase_awk_val_t** adr)
 {
-	sse_awk_val_ref_t* val;
+	ase_awk_val_ref_t* val;
 
 	if (run->fcache_count > 0)
 	{
@@ -217,176 +217,176 @@ sse_awk_val_t* sse_awk_makerefval (sse_awk_run_t* run, int id, sse_awk_val_t** a
 	}
 	else
 	{
-		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 = (ase_awk_val_ref_t*) ASE_AWK_MALLOC (
+			run->awk, ase_sizeof(ase_awk_val_ref_t));
+		if (val == ASE_NULL) return ASE_NULL;
 	}
 
-	val->type = SSE_AWK_VAL_REF;
+	val->type = ASE_AWK_VAL_REF;
 	val->ref = 0;
 	val->id = id;
 	val->adr = adr;
 
-	return (sse_awk_val_t*)val;
+	return (ase_awk_val_t*)val;
 }
 
-sse_bool_t sse_awk_isbuiltinval (sse_awk_val_t* val)
+ase_bool_t ase_awk_isbuiltinval (ase_awk_val_t* val)
 {
-	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]);
+	return val == ASE_NULL || 
+	       val == ase_awk_val_nil || val == ase_awk_val_zls || 
+	       val == ase_awk_val_zero || val == ase_awk_val_one || 
+	       (val >= (ase_awk_val_t*)&__awk_int[0] &&
+	        val <= (ase_awk_val_t*)&__awk_int[ase_countof(__awk_int)-1]);
 }
 
-void sse_awk_freeval (sse_awk_run_t* run, sse_awk_val_t* val, sse_bool_t cache)
+void ase_awk_freeval (ase_awk_run_t* run, ase_awk_val_t* val, ase_bool_t cache)
 {
-	if (sse_awk_isbuiltinval(val)) return;
+	if (ase_awk_isbuiltinval(val)) return;
 
-/*xp_printf (SSE_T("freeing [cache=%d] ... "), cache);
-sse_awk_printval (val);
-xp_printf (SSE_T("\n"));*/
-	if (val->type == SSE_AWK_VAL_NIL)
+/*xp_printf (ASE_T("freeing [cache=%d] ... "), cache);
+ase_awk_printval (val);
+xp_printf (ASE_T("\n"));*/
+	if (val->type == ASE_AWK_VAL_NIL)
 	{
-		SSE_AWK_FREE (run->awk, val);
+		ASE_AWK_FREE (run->awk, val);
 	}
-	else if (val->type == SSE_AWK_VAL_INT)
+	else if (val->type == ASE_AWK_VAL_INT)
 	{
-		if (cache == sse_true &&
-		    run->icache_count < sse_countof(run->icache))
+		if (cache == ase_true &&
+		    run->icache_count < ase_countof(run->icache))
 		{
 			run->icache[run->icache_count++] = 
-				(sse_awk_val_int_t*)val;	
+				(ase_awk_val_int_t*)val;	
 		}
-		else SSE_AWK_FREE (run->awk, val);
+		else ASE_AWK_FREE (run->awk, val);
 	}
-	else if (val->type == SSE_AWK_VAL_REAL)
+	else if (val->type == ASE_AWK_VAL_REAL)
 	{
-		if (cache == sse_true &&
-		    run->rcache_count < sse_countof(run->rcache))
+		if (cache == ase_true &&
+		    run->rcache_count < ase_countof(run->rcache))
 		{
 			run->rcache[run->rcache_count++] = 
-				(sse_awk_val_real_t*)val;	
+				(ase_awk_val_real_t*)val;	
 		}
-		else SSE_AWK_FREE (run->awk, val);
+		else ASE_AWK_FREE (run->awk, val);
 	}
-	else if (val->type == SSE_AWK_VAL_STR)
+	else if (val->type == ASE_AWK_VAL_STR)
 	{
-		SSE_AWK_FREE (run->awk, ((sse_awk_val_str_t*)val)->buf);
-		SSE_AWK_FREE (run->awk, val);
+		ASE_AWK_FREE (run->awk, ((ase_awk_val_str_t*)val)->buf);
+		ASE_AWK_FREE (run->awk, val);
 	}
-	else if (val->type == SSE_AWK_VAL_REX)
+	else if (val->type == ASE_AWK_VAL_REX)
 	{
-		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);
+		ASE_AWK_FREE (run->awk, ((ase_awk_val_rex_t*)val)->buf);
+		ase_awk_freerex (run->awk, ((ase_awk_val_rex_t*)val)->code);
+		ASE_AWK_FREE (run->awk, val);
 	}
-	else if (val->type == SSE_AWK_VAL_MAP)
+	else if (val->type == ASE_AWK_VAL_MAP)
 	{
-		sse_awk_map_close (((sse_awk_val_map_t*)val)->map);
-		SSE_AWK_FREE (run->awk, val);
+		ase_awk_map_close (((ase_awk_val_map_t*)val)->map);
+		ASE_AWK_FREE (run->awk, val);
 	}
-	else if (val->type == SSE_AWK_VAL_REF)
+	else if (val->type == ASE_AWK_VAL_REF)
 	{
-		if (cache == sse_true &&
-		    run->fcache_count < sse_countof(run->fcache))
+		if (cache == ase_true &&
+		    run->fcache_count < ase_countof(run->fcache))
 		{
 			run->fcache[run->fcache_count++] = 
-				(sse_awk_val_ref_t*)val;	
+				(ase_awk_val_ref_t*)val;	
 		}
-		else SSE_AWK_FREE (run->awk, val);
+		else ASE_AWK_FREE (run->awk, val);
 	}
 	else
 	{
-		sse_awk_assert (run->awk, 
+		ase_awk_assert (run->awk, 
 			!"should never happen - invalid value type");
 	}
 }
 
-void sse_awk_refupval (sse_awk_val_t* val)
+void ase_awk_refupval (ase_awk_val_t* val)
 {
-	if (sse_awk_isbuiltinval(val)) return;
+	if (ase_awk_isbuiltinval(val)) return;
 /*
-xp_printf (SSE_T("ref up "));
-sse_awk_printval (val);
-xp_printf (SSE_T("\n"));
+xp_printf (ASE_T("ref up "));
+ase_awk_printval (val);
+xp_printf (ASE_T("\n"));
 */
 	val->ref++;
 }
 
-void sse_awk_refdownval (sse_awk_run_t* run, sse_awk_val_t* val)
+void ase_awk_refdownval (ase_awk_run_t* run, ase_awk_val_t* val)
 {
-	if (sse_awk_isbuiltinval(val)) return;
+	if (ase_awk_isbuiltinval(val)) return;
 
 /*
-xp_printf (SSE_T("%p, %p, %p\n"), sse_awk_val_nil, &__awk_nil, val);
-xp_printf (SSE_T("ref down [count=>%d]\n"), (int)val->ref);
-sse_awk_printval (val);
-xp_printf (SSE_T("\n"));
+xp_printf (ASE_T("%p, %p, %p\n"), ase_awk_val_nil, &__awk_nil, val);
+xp_printf (ASE_T("ref down [count=>%d]\n"), (int)val->ref);
+ase_awk_printval (val);
+xp_printf (ASE_T("\n"));
 */
 
-	sse_awk_assert (run->awk, val->ref > 0);
+	ase_awk_assert (run->awk, val->ref > 0);
 	val->ref--;
 	if (val->ref <= 0) 
 	{
 /*
-xp_printf (SSE_T("**FREEING ["));
-sse_awk_printval (val);
-xp_printf (SSE_T("]\n"));
+xp_printf (ASE_T("**FREEING ["));
+ase_awk_printval (val);
+xp_printf (ASE_T("]\n"));
 */
-		sse_awk_freeval(run, val, sse_true);
+		ase_awk_freeval(run, val, ase_true);
 	}
 }
 
-void sse_awk_refdownval_nofree (sse_awk_run_t* run, sse_awk_val_t* val)
+void ase_awk_refdownval_nofree (ase_awk_run_t* run, ase_awk_val_t* val)
 {
-	if (sse_awk_isbuiltinval(val)) return;
+	if (ase_awk_isbuiltinval(val)) return;
 
-	sse_awk_assert (run->awk, val->ref > 0);
+	ase_awk_assert (run->awk, val->ref > 0);
 	val->ref--;
 }
 
-sse_bool_t sse_awk_valtobool (sse_awk_run_t* run, sse_awk_val_t* val)
+ase_bool_t ase_awk_valtobool (ase_awk_run_t* run, ase_awk_val_t* val)
 {
-	if (val == SSE_NULL) return sse_false;
+	if (val == ASE_NULL) return ase_false;
 
 	switch (val->type)
 	{
-	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? */
+	case ASE_AWK_VAL_NIL:
+		return ase_false;
+	case ASE_AWK_VAL_INT:
+		return ((ase_awk_val_int_t*)val)->val != 0;
+	case ASE_AWK_VAL_REAL:
+		return ((ase_awk_val_real_t*)val)->val != 0.0;
+	case ASE_AWK_VAL_STR:
+		return ((ase_awk_val_str_t*)val)->len > 0;
+	case ASE_AWK_VAL_REX: /* TODO: is this correct? */
+		return ((ase_awk_val_rex_t*)val)->len > 0;
+	case ASE_AWK_VAL_MAP:
+		return ase_false; /* TODO: is this correct? */
+	case ASE_AWK_VAL_REF:
+		return ase_false; /* TODO: is this correct? */
 	}
 
-	sse_awk_assert (run->awk, !"should never happen - invalid value type");
-	return sse_false;
+	ase_awk_assert (run->awk, !"should never happen - invalid value type");
+	return ase_false;
 }
 
-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)
+ase_char_t* ase_awk_valtostr (
+	ase_awk_run_t* run, ase_awk_val_t* v,
+	int opt, ase_awk_str_t* buf, ase_size_t* len)
 {
-	if (v->type == SSE_AWK_VAL_NIL)
+	if (v->type == ASE_AWK_VAL_NIL)
 	{
-		return __str_to_str (run, SSE_T(""), 0, opt, buf, len);
+		return __str_to_str (run, ASE_T(""), 0, opt, buf, len);
 	}
 
-	if (v->type == SSE_AWK_VAL_INT)
+	if (v->type == ASE_AWK_VAL_INT)
 	{
-		sse_awk_val_int_t* vi = (sse_awk_val_int_t*)v;
+		ase_awk_val_int_t* vi = (ase_awk_val_int_t*)v;
 
 		/*
-		if (vi->nde != SSE_NULL && vi->nde->str != SSE_NULL)
+		if (vi->nde != ASE_NULL && vi->nde->str != ASE_NULL)
 		{
 			return __str_to_str (
 				run, vi->nde->str, vi->nde->len, 
@@ -399,12 +399,12 @@ sse_char_t* sse_awk_valtostr (
 		/*}*/
 	}
 
-	if (v->type == SSE_AWK_VAL_REAL)
+	if (v->type == ASE_AWK_VAL_REAL)
 	{
-		sse_awk_val_real_t* vr = (sse_awk_val_real_t*)v;
+		ase_awk_val_real_t* vr = (ase_awk_val_real_t*)v;
 
 		/*
-		if (vr->nde != SSE_NULL && vr->nde->str != SSE_NULL)
+		if (vr->nde != ASE_NULL && vr->nde->str != ASE_NULL)
 		{
 			return __str_to_str (
 				run, vr->nde->str, vr->nde->len, 
@@ -416,9 +416,9 @@ sse_char_t* sse_awk_valtostr (
 		/*}*/
 	}
 
-	if (v->type == SSE_AWK_VAL_STR) 
+	if (v->type == ASE_AWK_VAL_STR) 
 	{
-		sse_awk_val_str_t* vs = (sse_awk_val_str_t*)v;
+		ase_awk_val_str_t* vs = (ase_awk_val_str_t*)v;
 
 		return __str_to_str (
 			run, vs->buf, vs->len, opt, buf, len);
@@ -426,83 +426,83 @@ sse_char_t* sse_awk_valtostr (
 
 /* TODO: process more value types */
 
-xp_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;
+xp_printf (ASE_T("*** ERROR: WRONG VALUE TYPE [%d] in ase_awk_valtostr v=> %p***\n"), v->type, v);
+	run->errnum = ASE_AWK_EVALTYPE;
+	return ASE_NULL;
 }
 
-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 ase_char_t* __str_to_str (
+	ase_awk_run_t* run, const ase_char_t* str, ase_size_t str_len,
+	int opt, ase_awk_str_t* buf, ase_size_t* len)
 {
-	if (buf == SSE_NULL)
+	if (buf == ASE_NULL)
 	{
-		sse_char_t* tmp;
-		tmp = sse_awk_strxdup (run->awk, str, str_len);
-		if (tmp == SSE_NULL) 
+		ase_char_t* tmp;
+		tmp = ase_awk_strxdup (run->awk, str, str_len);
+		if (tmp == ASE_NULL) 
 		{
-			run->errnum = SSE_AWK_ENOMEM;
-			return SSE_NULL;
+			run->errnum = ASE_AWK_ENOMEM;
+			return ASE_NULL;
 		}
 
-		if (len != SSE_NULL) *len = str_len;
+		if (len != ASE_NULL) *len = str_len;
 		return tmp;
 	}
 	else
 	{
-		sse_size_t n;
+		ase_size_t n;
 
-		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)
+		if (opt & ASE_AWK_VALTOSTR_CLEAR) ase_awk_str_clear (buf);
+		n = ase_awk_str_ncat (buf, str, str_len);
+		if (n == (ase_size_t)-1)
 		{
-			run->errnum = SSE_AWK_ENOMEM;
-			return SSE_NULL;
+			run->errnum = ASE_AWK_ENOMEM;
+			return ASE_NULL;
 		}
 
-		if (len != SSE_NULL) *len = SSE_AWK_STR_LEN(buf);
-		return SSE_AWK_STR_BUF(buf);
+		if (len != ASE_NULL) *len = ASE_AWK_STR_LEN(buf);
+		return ASE_AWK_STR_BUF(buf);
 	}
 }
 
-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 ase_char_t* __val_int_to_str (
+	ase_awk_run_t* run, ase_awk_val_int_t* v,
+	int opt, ase_awk_str_t* buf, ase_size_t* len)
 {
-	sse_char_t* tmp;
-	sse_long_t t;
-	sse_size_t l = 0;
+	ase_char_t* tmp;
+	ase_long_t t;
+	ase_size_t l = 0;
 
 	t = v->val; 
 	if (t == 0)
 	{
 		/* handle zero */
-		if (buf == SSE_NULL)
+		if (buf == ASE_NULL)
 		{
-			tmp = SSE_AWK_MALLOC (
-				run->awk, 2 * sse_sizeof(sse_char_t));
-			if (tmp == SSE_NULL)
+			tmp = ASE_AWK_MALLOC (
+				run->awk, 2 * ase_sizeof(ase_char_t));
+			if (tmp == ASE_NULL)
 			{
-				run->errnum = SSE_AWK_ENOMEM;
-				return SSE_NULL;
+				run->errnum = ASE_AWK_ENOMEM;
+				return ASE_NULL;
 			}
 
-			tmp[0] = SSE_T('0');
-			tmp[1] = SSE_T('\0');
-			if (len != SSE_NULL) *len = 1;
+			tmp[0] = ASE_T('0');
+			tmp[1] = ASE_T('\0');
+			if (len != ASE_NULL) *len = 1;
 			return tmp;
 		}
 		else
 		{
-			if (opt & SSE_AWK_VALTOSTR_CLEAR) sse_awk_str_clear (buf);
-			if (sse_awk_str_cat (buf, SSE_T("0")) == (sse_size_t)-1)
+			if (opt & ASE_AWK_VALTOSTR_CLEAR) ase_awk_str_clear (buf);
+			if (ase_awk_str_cat (buf, ASE_T("0")) == (ase_size_t)-1)
 			{
-				run->errnum = SSE_AWK_ENOMEM;
-				return SSE_NULL;
+				run->errnum = ASE_AWK_ENOMEM;
+				return ASE_NULL;
 			}
 
-			if (len != SSE_NULL) *len = SSE_AWK_STR_LEN(buf);
-			return SSE_AWK_STR_BUF(buf);
+			if (len != ASE_NULL) *len = ASE_AWK_STR_LEN(buf);
+			return ASE_AWK_STR_BUF(buf);
 		}
 	}
 
@@ -510,32 +510,32 @@ static sse_char_t* __val_int_to_str (
 	if (t < 0) { t = -t; l++; }
 	while (t > 0) { l++; t /= 10; }
 
-	if (buf == SSE_NULL)
+	if (buf == ASE_NULL)
 	{
-		tmp = SSE_AWK_MALLOC (
-			run->awk, (l + 1) * sse_sizeof(sse_char_t));
-		if (tmp == SSE_NULL)
+		tmp = ASE_AWK_MALLOC (
+			run->awk, (l + 1) * ase_sizeof(ase_char_t));
+		if (tmp == ASE_NULL)
 		{
-			run->errnum = SSE_AWK_ENOMEM;
-			return SSE_NULL;
+			run->errnum = ASE_AWK_ENOMEM;
+			return ASE_NULL;
 		}
 
-		tmp[l] = SSE_T('\0');
-		if (len != SSE_NULL) *len = l;
+		tmp[l] = ASE_T('\0');
+		if (len != ASE_NULL) *len = l;
 	}
 	else
 	{
 		/* clear the buffer */
-		if (opt & SSE_AWK_VALTOSTR_CLEAR) sse_awk_str_clear (buf);
+		if (opt & ASE_AWK_VALTOSTR_CLEAR) ase_awk_str_clear (buf);
 
-		tmp = SSE_AWK_STR_BUF(buf) + SSE_AWK_STR_LEN(buf);
+		tmp = ASE_AWK_STR_BUF(buf) + ASE_AWK_STR_LEN(buf);
 
 		/* extend the buffer */
-		if (sse_awk_str_nccat (
-			buf, SSE_T(' '), l) == (sse_size_t)-1)
+		if (ase_awk_str_nccat (
+			buf, ASE_T(' '), l) == (ase_size_t)-1)
 		{
-			run->errnum = SSE_AWK_ENOMEM;
-			return SSE_NULL;
+			run->errnum = ASE_AWK_ENOMEM;
+			return ASE_NULL;
 		}
 	}
 
@@ -544,98 +544,98 @@ static sse_char_t* __val_int_to_str (
 
 	while (t > 0) 
 	{
-		tmp[--l] = (sse_char_t)(t % 10) + SSE_T('0');
+		tmp[--l] = (ase_char_t)(t % 10) + ASE_T('0');
 		t /= 10;
 	}
 
-	if (v->val < 0) tmp[--l] = SSE_T('-');
+	if (v->val < 0) tmp[--l] = ASE_T('-');
 
-	if (buf != SSE_NULL) 
+	if (buf != ASE_NULL) 
 	{
-		tmp = SSE_AWK_STR_BUF(buf);
-		if (len != SSE_NULL) *len = SSE_AWK_STR_LEN(buf);
+		tmp = ASE_AWK_STR_BUF(buf);
+		if (len != ASE_NULL) *len = ASE_AWK_STR_LEN(buf);
 	}
 
 	return tmp;
 }
 
-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 ase_char_t* __val_real_to_str (
+	ase_awk_run_t* run, ase_awk_val_real_t* v,
+	int opt, ase_awk_str_t* buf, ase_size_t* len)
 {
 /* TODO: change the code */
-	sse_char_t tbuf[256], * tmp;
+	ase_char_t tbuf[256], * tmp;
 
-	tmp = (opt & SSE_AWK_VALTOSTR_PRINT)? 
+	tmp = (opt & ASE_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, sse_countof(tbuf), tmp, (double)v->val); 
-	if (buf == SSE_NULL) 
+	run->awk->syscas.sprintf (tbuf, ase_countof(tbuf), tmp, (double)v->val); 
+	if (buf == ASE_NULL) 
 	{
-		tmp = sse_awk_strdup (run->awk, tbuf);
-		if (tmp == SSE_NULL) 
+		tmp = ase_awk_strdup (run->awk, tbuf);
+		if (tmp == ASE_NULL) 
 		{
-			run->errnum = SSE_AWK_ENOMEM;
-			return SSE_NULL;
+			run->errnum = ASE_AWK_ENOMEM;
+			return ASE_NULL;
 		}
 
-		if (len != SSE_NULL) *len = sse_awk_strlen(tmp);
+		if (len != ASE_NULL) *len = ase_awk_strlen(tmp);
 	}
 	else
 	{
-		if (opt & SSE_AWK_VALTOSTR_CLEAR) sse_awk_str_clear (buf);
+		if (opt & ASE_AWK_VALTOSTR_CLEAR) ase_awk_str_clear (buf);
 
-		if (sse_awk_str_cat (buf, tbuf) == (sse_size_t)-1)
+		if (ase_awk_str_cat (buf, tbuf) == (ase_size_t)-1)
 		{
-			run->errnum = SSE_AWK_ENOMEM;
-			return SSE_NULL;
+			run->errnum = ASE_AWK_ENOMEM;
+			return ASE_NULL;
 		}
 
-		tmp = SSE_AWK_STR_BUF(buf);
-		if (len != SSE_NULL) *len = SSE_AWK_STR_LEN(buf);
+		tmp = ASE_AWK_STR_BUF(buf);
+		if (len != ASE_NULL) *len = ASE_AWK_STR_LEN(buf);
 	}
 
 	return tmp;
 }
 
-int sse_awk_valtonum (
-	sse_awk_run_t* run, sse_awk_val_t* v, sse_long_t* l, sse_real_t* r)
+int ase_awk_valtonum (
+	ase_awk_run_t* run, ase_awk_val_t* v, ase_long_t* l, ase_real_t* r)
 {
-	if (v->type == SSE_AWK_VAL_NIL) 
+	if (v->type == ASE_AWK_VAL_NIL) 
 	{
 		*l = 0;
 		return 0;
 	}
 
-	if (v->type == SSE_AWK_VAL_INT)
+	if (v->type == ASE_AWK_VAL_INT)
 	{
-		*l = ((sse_awk_val_int_t*)v)->val;
+		*l = ((ase_awk_val_int_t*)v)->val;
 		return 0; /* long */
 	}
 
-	if (v->type == SSE_AWK_VAL_REAL)
+	if (v->type == ASE_AWK_VAL_REAL)
 	{
-		*r = ((sse_awk_val_real_t*)v)->val;
+		*r = ((ase_awk_val_real_t*)v)->val;
 		return 1; /* real */
 	}
 
-	if (v->type == SSE_AWK_VAL_STR)
+	if (v->type == ASE_AWK_VAL_STR)
 	{
-		const sse_char_t* endptr;
+		const ase_char_t* endptr;
 
-		*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'))
+		*l = ase_awk_strxtolong (run->awk, 
+			((ase_awk_val_str_t*)v)->buf, 
+			((ase_awk_val_str_t*)v)->len, 0, &endptr);
+		if (*endptr == ASE_T('.') ||
+		    *endptr == ASE_T('E') ||
+		    *endptr == ASE_T('e'))
 		{
-			*r = sse_awk_strxtoreal (run->awk, 
-				((sse_awk_val_str_t*)v)->buf,
-				((sse_awk_val_str_t*)v)->len, SSE_NULL);
+			*r = ase_awk_strxtoreal (run->awk, 
+				((ase_awk_val_str_t*)v)->buf,
+				((ase_awk_val_str_t*)v)->len, ASE_NULL);
 /* TODO: need to check if it is a valid number using endptr for strxtoreal? */
 			return 1; /* real */
 		}
@@ -643,70 +643,70 @@ int sse_awk_valtonum (
 		return 0; /* long */
 	}
 
-xp_printf (SSE_T("*** ERROR: WRONG VALUE TYPE [%d] in sse_awk_valtonum v=> %p***\n"), v->type, v);
-	run->errnum = SSE_AWK_EVALTYPE;
+xp_printf (ASE_T("*** ERROR: WRONG VALUE TYPE [%d] in ase_awk_valtonum v=> %p***\n"), v->type, v);
+	run->errnum = ASE_AWK_EVALTYPE;
 	return -1; /* error */
 }
 
-static int __print_pair (sse_awk_pair_t* pair, void* arg)
+static int __print_pair (ase_awk_pair_t* pair, void* arg)
 {
-	xp_printf (SSE_T(" %s=>"), pair->key);	
-	sse_awk_printval (pair->val);
-	xp_printf (SSE_T(" "));
+	xp_printf (ASE_T(" %s=>"), pair->key);	
+	ase_awk_printval (pair->val);
+	xp_printf (ASE_T(" "));
 	return 0;
 }
 
-void sse_awk_printval (sse_awk_val_t* val)
+void ase_awk_printval (ase_awk_val_t* val)
 {
 /* TODO: better value printing...................... */
 	switch (val->type)
 	{
-	case SSE_AWK_VAL_NIL:
-		xp_printf (SSE_T("nil"));
+	case ASE_AWK_VAL_NIL:
+		xp_printf (ASE_T("nil"));
 	       	break;
 
-	case SSE_AWK_VAL_INT:
+	case ASE_AWK_VAL_INT:
 #if defined(__LCC__)
-		xp_printf (SSE_T("%lld"), 
-			(long long)((sse_awk_val_int_t*)val)->val);
+		xp_printf (ASE_T("%lld"), 
+			(long long)((ase_awk_val_int_t*)val)->val);
 #elif defined(__BORLANDC__) || defined(_MSC_VER)
-		xp_printf (SSE_T("%I64d"), 
-			(__int64)((sse_awk_nde_int_t*)val)->val);
+		xp_printf (ASE_T("%I64d"), 
+			(__int64)((ase_awk_nde_int_t*)val)->val);
 #elif defined(vax) || defined(__vax) || defined(_SCO_DS)
-		xp_printf (SSE_T("%ld"), 
-			(long)((sse_awk_val_int_t*)val)->val);
+		xp_printf (ASE_T("%ld"), 
+			(long)((ase_awk_val_int_t*)val)->val);
 #else
-		xp_printf (SSE_T("%lld"), 
-			(long long)((sse_awk_val_int_t*)val)->val);
+		xp_printf (ASE_T("%lld"), 
+			(long long)((ase_awk_val_int_t*)val)->val);
 #endif
 		break;
 
-	case SSE_AWK_VAL_REAL:
-		xp_printf (SSE_T("%Lf"), 
-			(long double)((sse_awk_val_real_t*)val)->val);
+	case ASE_AWK_VAL_REAL:
+		xp_printf (ASE_T("%Lf"), 
+			(long double)((ase_awk_val_real_t*)val)->val);
 		break;
 
-	case SSE_AWK_VAL_STR:
-		xp_printf (SSE_T("%s"), ((sse_awk_val_str_t*)val)->buf);
+	case ASE_AWK_VAL_STR:
+		xp_printf (ASE_T("%s"), ((ase_awk_val_str_t*)val)->buf);
 		break;
 
-	case SSE_AWK_VAL_REX:
-		xp_printf (SSE_T("REX[%s]"), ((sse_awk_val_rex_t*)val)->buf);
+	case ASE_AWK_VAL_REX:
+		xp_printf (ASE_T("REX[%s]"), ((ase_awk_val_rex_t*)val)->buf);
 		break;
 
-	case SSE_AWK_VAL_MAP:
-		xp_printf (SSE_T("MAP["));
-		sse_awk_map_walk (((sse_awk_val_map_t*)val)->map, __print_pair, SSE_NULL);
-		xp_printf (SSE_T("]"));
+	case ASE_AWK_VAL_MAP:
+		xp_printf (ASE_T("MAP["));
+		ase_awk_map_walk (((ase_awk_val_map_t*)val)->map, __print_pair, ASE_NULL);
+		xp_printf (ASE_T("]"));
 		break;
 	
-	case SSE_AWK_VAL_REF:
-		xp_printf (SSE_T("REF[id=%d,val="), ((sse_awk_val_ref_t*)val)->id);
-		sse_awk_printval (*((sse_awk_val_ref_t*)val)->adr);
-		xp_printf (SSE_T("]"));
+	case ASE_AWK_VAL_REF:
+		xp_printf (ASE_T("REF[id=%d,val="), ((ase_awk_val_ref_t*)val)->id);
+		ase_awk_printval (*((ase_awk_val_ref_t*)val)->adr);
+		xp_printf (ASE_T("]"));
 		break;
 
 	default:
-		xp_printf (SSE_T("**** INTERNAL ERROR - INVALID VALUE TYPE ****\n"));
+		xp_printf (ASE_T("**** INTERNAL ERROR - INVALID VALUE TYPE ****\n"));
 	}
 }
diff --git a/ase/awk/val.h b/ase/awk/val.h
index 8c7cef62..028f8690 100644
--- a/ase/awk/val.h
+++ b/ase/awk/val.h
@@ -1,180 +1,180 @@
 /*
- * $Id: val.h,v 1.47 2006-10-22 11:34:53 bacon Exp $
+ * $Id: val.h,v 1.48 2006-10-24 04:10:12 bacon Exp $
  */
 
-#ifndef _SSE_AWK_VAL_H_
-#define _SSE_AWK_VAL_H_
+#ifndef _ASE_AWK_VAL_H_
+#define _ASE_AWK_VAL_H_
 
-#ifndef _SSE_AWK_AWK_H_
-#error Never include this file directly. Include <sse/awk/awk.h> instead
+#ifndef _ASE_AWK_AWK_H_
+#error Never include this file directly. Include <ase/awk/awk.h> instead
 #endif
 
 enum
 {
-	/* the values between SSE_AWK_VAL_NIL and SSE_AWK_VAL_STR inclusive
+	/* the values between ASE_AWK_VAL_NIL and ASE_AWK_VAL_STR inclusive
 	 * must be synchronized with an internal table of the __cmp_val 
 	 * function in run.c */
-	SSE_AWK_VAL_NIL  = 0,
-	SSE_AWK_VAL_INT  = 1,
-	SSE_AWK_VAL_REAL = 2,
-	SSE_AWK_VAL_STR  = 3,
+	ASE_AWK_VAL_NIL  = 0,
+	ASE_AWK_VAL_INT  = 1,
+	ASE_AWK_VAL_REAL = 2,
+	ASE_AWK_VAL_STR  = 3,
 
-	SSE_AWK_VAL_REX  = 4,
-	SSE_AWK_VAL_MAP  = 5,
-	SSE_AWK_VAL_REF  = 6
+	ASE_AWK_VAL_REX  = 4,
+	ASE_AWK_VAL_MAP  = 5,
+	ASE_AWK_VAL_REF  = 6
 };
 
 enum
 {
 	/* keep these items in the same order as corresponding items
 	 * in tree.h */
-	SSE_AWK_VAL_REF_NAMED,
-	SSE_AWK_VAL_REF_GLOBAL,
-	SSE_AWK_VAL_REF_LOCAL,
-	SSE_AWK_VAL_REF_ARG,
-	SSE_AWK_VAL_REF_NAMEDIDX,
-	SSE_AWK_VAL_REF_GLOBALIDX,
-	SSE_AWK_VAL_REF_LOCALIDX,
-	SSE_AWK_VAL_REF_ARGIDX,
-	SSE_AWK_VAL_REF_POS
+	ASE_AWK_VAL_REF_NAMED,
+	ASE_AWK_VAL_REF_GLOBAL,
+	ASE_AWK_VAL_REF_LOCAL,
+	ASE_AWK_VAL_REF_ARG,
+	ASE_AWK_VAL_REF_NAMEDIDX,
+	ASE_AWK_VAL_REF_GLOBALIDX,
+	ASE_AWK_VAL_REF_LOCALIDX,
+	ASE_AWK_VAL_REF_ARGIDX,
+	ASE_AWK_VAL_REF_POS
 };
 
 enum
 {
-	SSE_AWK_VALTOSTR_CLEAR = (1 << 0),
-	SSE_AWK_VALTOSTR_PRINT = (1 << 1)
+	ASE_AWK_VALTOSTR_CLEAR = (1 << 0),
+	ASE_AWK_VALTOSTR_PRINT = (1 << 1)
 };
 
-typedef struct sse_awk_val_nil_t  sse_awk_val_nil_t;
-typedef struct sse_awk_val_int_t  sse_awk_val_int_t;
-typedef struct sse_awk_val_real_t sse_awk_val_real_t;
-typedef struct sse_awk_val_str_t  sse_awk_val_str_t;
-typedef struct sse_awk_val_rex_t  sse_awk_val_rex_t;
-typedef struct sse_awk_val_map_t  sse_awk_val_map_t;
-typedef struct sse_awk_val_ref_t  sse_awk_val_ref_t;
+typedef struct ase_awk_val_nil_t  ase_awk_val_nil_t;
+typedef struct ase_awk_val_int_t  ase_awk_val_int_t;
+typedef struct ase_awk_val_real_t ase_awk_val_real_t;
+typedef struct ase_awk_val_str_t  ase_awk_val_str_t;
+typedef struct ase_awk_val_rex_t  ase_awk_val_rex_t;
+typedef struct ase_awk_val_map_t  ase_awk_val_map_t;
+typedef struct ase_awk_val_ref_t  ase_awk_val_ref_t;
 
-#if SSE_SIZEOF_INT == 2
-#define SSE_AWK_VAL_HDR \
+#if ASE_SIZEOF_INT == 2
+#define ASE_AWK_VAL_HDR \
 	unsigned int type: 3; \
 	unsigned int ref: 13
 #else
-#define SSE_AWK_VAL_HDR \
+#define ASE_AWK_VAL_HDR \
 	unsigned int type: 3; \
 	unsigned int ref: 29
 #endif
 
-struct sse_awk_val_t
+struct ase_awk_val_t
 {
-	SSE_AWK_VAL_HDR;	
+	ASE_AWK_VAL_HDR;	
 };
 
-/* SSE_AWK_VAL_NIL */
-struct sse_awk_val_nil_t
+/* ASE_AWK_VAL_NIL */
+struct ase_awk_val_nil_t
 {
-	SSE_AWK_VAL_HDR;
+	ASE_AWK_VAL_HDR;
 };
 
-/* SSE_AWK_VAL_INT */
-struct sse_awk_val_int_t
+/* ASE_AWK_VAL_INT */
+struct ase_awk_val_int_t
 {
-	SSE_AWK_VAL_HDR;
-	sse_long_t val;
-	sse_awk_nde_int_t* nde;
+	ASE_AWK_VAL_HDR;
+	ase_long_t val;
+	ase_awk_nde_int_t* nde;
 };
 
-/* SSE_AWK_VAL_REAL */
-struct sse_awk_val_real_t
+/* ASE_AWK_VAL_REAL */
+struct ase_awk_val_real_t
 {
-	SSE_AWK_VAL_HDR;
-	sse_real_t val;
-	sse_awk_nde_real_t* nde;
+	ASE_AWK_VAL_HDR;
+	ase_real_t val;
+	ase_awk_nde_real_t* nde;
 };
 
-/* SSE_AWK_VAL_STR */
-struct sse_awk_val_str_t
+/* ASE_AWK_VAL_STR */
+struct ase_awk_val_str_t
 {
-	SSE_AWK_VAL_HDR;
-	sse_char_t* buf;
-	sse_size_t  len;
+	ASE_AWK_VAL_HDR;
+	ase_char_t* buf;
+	ase_size_t  len;
 };
 
-/* SSE_AWK_VAL_REX */
-struct sse_awk_val_rex_t
+/* ASE_AWK_VAL_REX */
+struct ase_awk_val_rex_t
 {
-	SSE_AWK_VAL_HDR;
-	sse_char_t* buf;
-	sse_size_t  len;
+	ASE_AWK_VAL_HDR;
+	ase_char_t* buf;
+	ase_size_t  len;
 	void*      code;
 };
 
-/* SSE_AWK_VAL_MAP */
-struct sse_awk_val_map_t
+/* ASE_AWK_VAL_MAP */
+struct ase_awk_val_map_t
 {
-	SSE_AWK_VAL_HDR;
+	ASE_AWK_VAL_HDR;
 
 	/* TODO: make val_map to array if the indices used are all 
 	 *       integers switch to map dynamically once the 
 	 *       non-integral index is seen.
 	 */
-	sse_awk_map_t* map; 
+	ase_awk_map_t* map; 
 };
 
-/* SSE_AWK_VAL_REF */
-struct sse_awk_val_ref_t
+/* ASE_AWK_VAL_REF */
+struct ase_awk_val_ref_t
 {
-	SSE_AWK_VAL_HDR;
+	ASE_AWK_VAL_HDR;
 
 	int id;
-	/* if id is SSE_AWK_VAL_REF_POS, adr holds an index of the 
+	/* if id is ASE_AWK_VAL_REF_POS, adr holds an index of the 
 	 * positionalvariable. Otherwise, adr points to the value 
 	 * directly. */
-	sse_awk_val_t** adr;
+	ase_awk_val_t** adr;
 };
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-extern sse_awk_val_t* sse_awk_val_nil;
-extern sse_awk_val_t* sse_awk_val_zls;
-extern sse_awk_val_t* sse_awk_val_zero;
-extern sse_awk_val_t* sse_awk_val_one;
+extern ase_awk_val_t* ase_awk_val_nil;
+extern ase_awk_val_t* ase_awk_val_zls;
+extern ase_awk_val_t* ase_awk_val_zero;
+extern ase_awk_val_t* ase_awk_val_one;
 
-sse_awk_val_t* sse_awk_makeintval (sse_awk_run_t* run, sse_long_t v);
-sse_awk_val_t* sse_awk_makerealval (sse_awk_run_t* run, sse_real_t v);
+ase_awk_val_t* ase_awk_makeintval (ase_awk_run_t* run, ase_long_t v);
+ase_awk_val_t* ase_awk_makerealval (ase_awk_run_t* run, ase_real_t v);
 
-sse_awk_val_t* sse_awk_makestrval0 (sse_awk_run_t* run, const sse_char_t* str);
-sse_awk_val_t* sse_awk_makestrval (
-	sse_awk_run_t* run, const sse_char_t* str, sse_size_t len);
-sse_awk_val_t* sse_awk_makestrval2 (
-	sse_awk_run_t* run,
-	const sse_char_t* str1, sse_size_t len1, 
-	const sse_char_t* str2, sse_size_t len2);
+ase_awk_val_t* ase_awk_makestrval0 (ase_awk_run_t* run, const ase_char_t* str);
+ase_awk_val_t* ase_awk_makestrval (
+	ase_awk_run_t* run, const ase_char_t* str, ase_size_t len);
+ase_awk_val_t* ase_awk_makestrval2 (
+	ase_awk_run_t* run,
+	const ase_char_t* str1, ase_size_t len1, 
+	const ase_char_t* str2, ase_size_t len2);
 
-sse_awk_val_t* sse_awk_makerexval (
-	sse_awk_run_t* run, const sse_char_t* buf, sse_size_t len, void* code);
-sse_awk_val_t* sse_awk_makemapval (sse_awk_run_t* run);
-sse_awk_val_t* sse_awk_makerefval (
-	sse_awk_run_t* run, int id, sse_awk_val_t** adr);
+ase_awk_val_t* ase_awk_makerexval (
+	ase_awk_run_t* run, const ase_char_t* buf, ase_size_t len, void* code);
+ase_awk_val_t* ase_awk_makemapval (ase_awk_run_t* run);
+ase_awk_val_t* ase_awk_makerefval (
+	ase_awk_run_t* run, int id, ase_awk_val_t** adr);
 
-sse_bool_t sse_awk_isbuiltinval (sse_awk_val_t* val);
+ase_bool_t ase_awk_isbuiltinval (ase_awk_val_t* val);
 
-void sse_awk_freeval (sse_awk_run_t* run, sse_awk_val_t* val, sse_bool_t cache);
-void sse_awk_refupval (sse_awk_val_t* val);
-void sse_awk_refdownval (sse_awk_run_t* run, sse_awk_val_t* val);
-void sse_awk_refdownval_nofree (sse_awk_run_t* run, sse_awk_val_t* val);
+void ase_awk_freeval (ase_awk_run_t* run, ase_awk_val_t* val, ase_bool_t cache);
+void ase_awk_refupval (ase_awk_val_t* val);
+void ase_awk_refdownval (ase_awk_run_t* run, ase_awk_val_t* val);
+void ase_awk_refdownval_nofree (ase_awk_run_t* run, ase_awk_val_t* val);
 
-sse_bool_t sse_awk_valtobool (
-	sse_awk_run_t* run, sse_awk_val_t* val);
+ase_bool_t ase_awk_valtobool (
+	ase_awk_run_t* run, ase_awk_val_t* val);
 
-sse_char_t* sse_awk_valtostr (
-	sse_awk_run_t* run, sse_awk_val_t* val, 
-	int opt, sse_awk_str_t* buf, sse_size_t* len);
+ase_char_t* ase_awk_valtostr (
+	ase_awk_run_t* run, ase_awk_val_t* val, 
+	int opt, ase_awk_str_t* buf, ase_size_t* len);
 
-int sse_awk_valtonum (
-	sse_awk_run_t* run, sse_awk_val_t* v, sse_long_t* l, sse_real_t* r);
+int ase_awk_valtonum (
+	ase_awk_run_t* run, ase_awk_val_t* v, ase_long_t* l, ase_real_t* r);
 
-void sse_awk_printval (sse_awk_val_t* val);
+void ase_awk_printval (ase_awk_val_t* val);
 
 #ifdef __cplusplus
 }