From a206062acc874453087d1c98147cdd5ecd63abcf Mon Sep 17 00:00:00 2001 From: hyung-hwan Date: Thu, 22 Mar 2007 10:31:24 +0000 Subject: [PATCH] *** empty log message *** --- ase/awk/awk.c | 8 +-- ase/awk/err.c | 8 +-- ase/awk/extio.c | 132 ++++++++++++++++++++++++------------------------ ase/awk/map.c | 14 ++--- ase/awk/val.c | 94 +++++++++++++++++----------------- 5 files changed, 128 insertions(+), 128 deletions(-) diff --git a/ase/awk/awk.c b/ase/awk/awk.c index 7d6d93cf..a8b27c22 100644 --- a/ase/awk/awk.c +++ b/ase/awk/awk.c @@ -1,5 +1,5 @@ /* - * $Id: awk.c,v 1.118 2007-03-12 12:55:57 bacon Exp $ + * $Id: awk.c,v 1.119 2007-03-22 10:31:23 bacon Exp $ * * {License} */ @@ -11,7 +11,7 @@ #include -static void __free_afn (void* awk, void* afn); +static void free_afn (void* awk, void* afn); ase_awk_t* ase_awk_open (const ase_awk_prmfns_t* prmfns, void* custom_data) { @@ -62,7 +62,7 @@ ase_awk_t* ase_awk_open (const ase_awk_prmfns_t* prmfns, void* custom_data) /* TODO: initial map size?? */ if (ase_awk_map_open ( - &awk->tree.afns, awk, 256, __free_afn, awk) == ASE_NULL) + &awk->tree.afns, awk, 256, free_afn, awk) == ASE_NULL) { ase_str_close (&awk->token.name); ASE_AWK_FREE (awk, awk); @@ -142,7 +142,7 @@ ase_awk_t* ase_awk_open (const ase_awk_prmfns_t* prmfns, void* custom_data) return awk; } -static void __free_afn (void* owner, void* afn) +static void free_afn (void* owner, void* afn) { ase_awk_afn_t* f = (ase_awk_afn_t*)afn; diff --git a/ase/awk/err.c b/ase/awk/err.c index 3168c005..b7724f80 100644 --- a/ase/awk/err.c +++ b/ase/awk/err.c @@ -1,5 +1,5 @@ /* - * $Id: err.c,v 1.96 2007-03-20 10:44:44 bacon Exp $ + * $Id: err.c,v 1.97 2007-03-22 10:31:24 bacon Exp $ * * {License} */ @@ -8,7 +8,7 @@ static const ase_char_t* __geterrstr (int errnum) { - static const ase_char_t* __errstr[] = + static const ase_char_t* errstr[] = { ASE_T("no error"), @@ -147,9 +147,9 @@ static const ase_char_t* __geterrstr (int errnum) ASE_T("garbage after the regular expression") }; - if (errnum >= 0 && errnum < ASE_COUNTOF(__errstr)) + if (errnum >= 0 && errnum < ASE_COUNTOF(errstr)) { - return __errstr[errnum]; + return errstr[errnum]; } return ASE_T("unknown error"); diff --git a/ase/awk/extio.c b/ase/awk/extio.c index 3c33d0d5..1120b56c 100644 --- a/ase/awk/extio.c +++ b/ase/awk/extio.c @@ -1,5 +1,5 @@ /* - * $Id: extio.c,v 1.78 2007-03-20 10:44:44 bacon Exp $ + * $Id: extio.c,v 1.79 2007-03-22 10:31:24 bacon Exp $ * * {License} */ @@ -8,14 +8,14 @@ enum { - __MASK_READ = 0x0100, - __MASK_WRITE = 0x0200, - __MASK_RDWR = 0x0400, + MASK_READ = 0x0100, + MASK_WRITE = 0x0200, + MASK_RDWR = 0x0400, - __MASK_CLEAR = 0x00FF + MASK_CLEAR = 0x00FF }; -static int __in_type_map[] = +static int in_type_map[] = { /* the order should match the order of the * ASE_AWK_IN_XXX values in tree.h */ @@ -25,7 +25,7 @@ static int __in_type_map[] = ASE_AWK_EXTIO_CONSOLE }; -static int __in_mode_map[] = +static int in_mode_map[] = { /* the order should match the order of the * ASE_AWK_IN_XXX values in tree.h */ @@ -35,15 +35,15 @@ static int __in_mode_map[] = ASE_AWK_EXTIO_CONSOLE_READ }; -static int __in_mask_map[] = +static int in_mask_map[] = { - __MASK_READ, - __MASK_RDWR, - __MASK_READ, - __MASK_READ + MASK_READ, + MASK_RDWR, + MASK_READ, + MASK_READ }; -static int __out_type_map[] = +static int out_type_map[] = { /* the order should match the order of the * ASE_AWK_OUT_XXX values in tree.h */ @@ -54,7 +54,7 @@ static int __out_type_map[] = ASE_AWK_EXTIO_CONSOLE }; -static int __out_mode_map[] = +static int out_mode_map[] = { /* the order should match the order of the * ASE_AWK_OUT_XXX values in tree.h */ @@ -65,13 +65,13 @@ static int __out_mode_map[] = ASE_AWK_EXTIO_CONSOLE_WRITE }; -static int __out_mask_map[] = +static int out_mask_map[] = { - __MASK_WRITE, - __MASK_RDWR, - __MASK_WRITE, - __MASK_WRITE, - __MASK_WRITE + MASK_WRITE, + MASK_RDWR, + MASK_WRITE, + MASK_WRITE, + MASK_WRITE }; int ase_awk_readextio ( @@ -87,14 +87,14 @@ int ase_awk_readextio ( ase_size_t line_len = 0; ase_char_t c = ASE_T('\0'), pc; - ASE_ASSERT (in_type >= 0 && in_type <= ASE_COUNTOF(__in_type_map)); - ASE_ASSERT (in_type >= 0 && in_type <= ASE_COUNTOF(__in_mode_map)); - ASE_ASSERT (in_type >= 0 && in_type <= ASE_COUNTOF(__in_mask_map)); + ASE_ASSERT (in_type >= 0 && in_type <= ASE_COUNTOF(in_type_map)); + ASE_ASSERT (in_type >= 0 && in_type <= ASE_COUNTOF(in_mode_map)); + ASE_ASSERT (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]; - extio_mode = __in_mode_map[in_type]; - extio_mask = __in_mask_map[in_type]; + extio_type = in_type_map[in_type]; + extio_mode = in_mode_map[in_type]; + extio_mask = in_mask_map[in_type]; handler = run->extio.handler[extio_type]; if (handler == ASE_NULL) @@ -424,14 +424,14 @@ int ase_awk_writeextio_str ( ase_awk_io_t handler; int extio_type, extio_mode, extio_mask, n; - ASE_ASSERT (out_type >= 0 && out_type <= ASE_COUNTOF(__out_type_map)); - ASE_ASSERT (out_type >= 0 && out_type <= ASE_COUNTOF(__out_mode_map)); - ASE_ASSERT (out_type >= 0 && out_type <= ASE_COUNTOF(__out_mask_map)); + ASE_ASSERT (out_type >= 0 && out_type <= ASE_COUNTOF(out_type_map)); + ASE_ASSERT (out_type >= 0 && out_type <= ASE_COUNTOF(out_mode_map)); + ASE_ASSERT (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]; - extio_mode = __out_mode_map[out_type]; - extio_mask = __out_mask_map[out_type]; + extio_type = out_type_map[out_type]; + extio_mode = out_mode_map[out_type]; + extio_mask = out_mask_map[out_type]; handler = run->extio.handler[extio_type]; if (handler == ASE_NULL) @@ -565,14 +565,14 @@ int ase_awk_flushextio ( int extio_type, /*extio_mode,*/ extio_mask, n; ase_bool_t ok = ase_false; - ASE_ASSERT (out_type >= 0 && out_type <= ASE_COUNTOF(__out_type_map)); - ASE_ASSERT (out_type >= 0 && out_type <= ASE_COUNTOF(__out_mode_map)); - ASE_ASSERT (out_type >= 0 && out_type <= ASE_COUNTOF(__out_mask_map)); + ASE_ASSERT (out_type >= 0 && out_type <= ASE_COUNTOF(out_type_map)); + ASE_ASSERT (out_type >= 0 && out_type <= ASE_COUNTOF(out_mode_map)); + ASE_ASSERT (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]; - /*extio_mode = __out_mode_map[out_type];*/ - extio_mask = __out_mask_map[out_type]; + extio_type = out_type_map[out_type]; + /*extio_mode = out_mode_map[out_type];*/ + extio_mask = out_mask_map[out_type]; handler = run->extio.handler[extio_type]; if (handler == ASE_NULL) @@ -618,14 +618,14 @@ int ase_awk_nextextio_read ( ase_awk_io_t handler; int extio_type, /*extio_mode,*/ extio_mask, n; - ASE_ASSERT (in_type >= 0 && in_type <= ASE_COUNTOF(__in_type_map)); - ASE_ASSERT (in_type >= 0 && in_type <= ASE_COUNTOF(__in_mode_map)); - ASE_ASSERT (in_type >= 0 && in_type <= ASE_COUNTOF(__in_mask_map)); + ASE_ASSERT (in_type >= 0 && in_type <= ASE_COUNTOF(in_type_map)); + ASE_ASSERT (in_type >= 0 && in_type <= ASE_COUNTOF(in_mode_map)); + ASE_ASSERT (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]; - /*extio_mode = __in_mode_map[in_type];*/ - extio_mask = __in_mask_map[in_type]; + extio_type = in_type_map[in_type]; + /*extio_mode = in_mode_map[in_type];*/ + extio_mask = in_mask_map[in_type]; handler = run->extio.handler[extio_type]; if (handler == ASE_NULL) @@ -694,14 +694,14 @@ int ase_awk_nextextio_write ( ase_awk_io_t handler; int extio_type, /*extio_mode,*/ extio_mask, n; - ASE_ASSERT (out_type >= 0 && out_type <= ASE_COUNTOF(__out_type_map)); - ASE_ASSERT (out_type >= 0 && out_type <= ASE_COUNTOF(__out_mode_map)); - ASE_ASSERT (out_type >= 0 && out_type <= ASE_COUNTOF(__out_mask_map)); + ASE_ASSERT (out_type >= 0 && out_type <= ASE_COUNTOF(out_type_map)); + ASE_ASSERT (out_type >= 0 && out_type <= ASE_COUNTOF(out_mode_map)); + ASE_ASSERT (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]; - /*extio_mode = __out_mode_map[out_type];*/ - extio_mask = __out_mask_map[out_type]; + extio_type = out_type_map[out_type]; + /*extio_mode = out_mode_map[out_type];*/ + extio_mask = out_mask_map[out_type]; handler = run->extio.handler[extio_type]; if (handler == ASE_NULL) @@ -766,14 +766,14 @@ int ase_awk_closeextio_read ( ase_awk_io_t handler; int extio_type, /*extio_mode,*/ extio_mask; - ASE_ASSERT (in_type >= 0 && in_type <= ASE_COUNTOF(__in_type_map)); - ASE_ASSERT (in_type >= 0 && in_type <= ASE_COUNTOF(__in_mode_map)); - ASE_ASSERT (in_type >= 0 && in_type <= ASE_COUNTOF(__in_mask_map)); + ASE_ASSERT (in_type >= 0 && in_type <= ASE_COUNTOF(in_type_map)); + ASE_ASSERT (in_type >= 0 && in_type <= ASE_COUNTOF(in_mode_map)); + ASE_ASSERT (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]; - /*extio_mode = __in_mode_map[in_type];*/ - extio_mask = __in_mask_map[in_type]; + extio_type = in_type_map[in_type]; + /*extio_mode = in_mode_map[in_type];*/ + extio_mask = in_mask_map[in_type]; handler = run->extio.handler[extio_type]; if (handler == ASE_NULL) @@ -790,7 +790,7 @@ int ase_awk_closeextio_read ( { ase_awk_io_t handler; - handler = run->extio.handler[p->type & __MASK_CLEAR]; + handler = run->extio.handler[p->type & MASK_CLEAR]; if (handler != ASE_NULL) { if (handler (ASE_AWK_IO_CLOSE, p, ASE_NULL, 0) <= -1) @@ -825,14 +825,14 @@ int ase_awk_closeextio_write ( ase_awk_io_t handler; int extio_type, /*extio_mode,*/ extio_mask; - ASE_ASSERT (out_type >= 0 && out_type <= ASE_COUNTOF(__out_type_map)); - ASE_ASSERT (out_type >= 0 && out_type <= ASE_COUNTOF(__out_mode_map)); - ASE_ASSERT (out_type >= 0 && out_type <= ASE_COUNTOF(__out_mask_map)); + ASE_ASSERT (out_type >= 0 && out_type <= ASE_COUNTOF(out_type_map)); + ASE_ASSERT (out_type >= 0 && out_type <= ASE_COUNTOF(out_mode_map)); + ASE_ASSERT (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]; - /*extio_mode = __out_mode_map[out_type];*/ - extio_mask = __out_mask_map[out_type]; + extio_type = out_type_map[out_type]; + /*extio_mode = out_mode_map[out_type];*/ + extio_mask = out_mask_map[out_type]; handler = run->extio.handler[extio_type]; if (handler == ASE_NULL) @@ -849,7 +849,7 @@ int ase_awk_closeextio_write ( { ase_awk_io_t handler; - handler = run->extio.handler[p->type & __MASK_CLEAR]; + handler = run->extio.handler[p->type & MASK_CLEAR]; if (handler != ASE_NULL) { ase_awk_setrunerrnum (run, ASE_AWK_ENOERR); @@ -889,7 +889,7 @@ int ase_awk_closeextio (ase_awk_run_t* run, const ase_char_t* name) { ase_awk_io_t handler; - handler = run->extio.handler[p->type & __MASK_CLEAR]; + handler = run->extio.handler[p->type & MASK_CLEAR]; if (handler != ASE_NULL) { ase_awk_setrunerrnum (run, ASE_AWK_ENOERR); @@ -928,7 +928,7 @@ void ase_awk_clearextio (ase_awk_run_t* run) while (run->extio.chain != ASE_NULL) { handler = run->extio.handler[ - run->extio.chain->type & __MASK_CLEAR]; + run->extio.chain->type & MASK_CLEAR]; next = run->extio.chain->next; if (handler != ASE_NULL) diff --git a/ase/awk/map.c b/ase/awk/map.c index 2e212d30..8e07704b 100644 --- a/ase/awk/map.c +++ b/ase/awk/map.c @@ -1,5 +1,5 @@ /* - * $Id: map.c,v 1.37 2007-03-06 14:51:52 bacon Exp $ + * $Id: map.c,v 1.38 2007-03-22 10:31:24 bacon Exp $ * * {License} */ @@ -9,7 +9,7 @@ /* TODO: improve the entire map routines. support automatic bucket resizing and remaping, etc. */ -static ase_size_t __hash (const ase_char_t* key, ase_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 { \ @@ -91,7 +91,7 @@ ase_awk_pair_t* ase_awk_map_get ( ase_awk_pair_t* pair; ase_size_t hc; - hc = __hash(key,key_len) % map->capa; + hc = hash(key,key_len) % map->capa; pair = map->buck[hc]; while (pair != ASE_NULL) @@ -125,7 +125,7 @@ int ase_awk_map_putx ( ase_awk_pair_t* pair; ase_size_t hc; - hc = __hash(key,key_len) % map->capa; + hc = hash(key,key_len) % map->capa; pair = map->buck[hc]; while (pair != ASE_NULL) @@ -173,7 +173,7 @@ ase_awk_pair_t* ase_awk_map_set ( ase_awk_pair_t* pair; ase_size_t hc; - hc = __hash(key,key_len) % map->capa; + hc = hash(key,key_len) % map->capa; pair = map->buck[hc]; while (pair != ASE_NULL) @@ -222,7 +222,7 @@ int ase_awk_map_remove (ase_awk_map_t* map, ase_char_t* key, ase_size_t key_len) ase_awk_pair_t* pair, * prev; ase_size_t hc; - hc = __hash(key,key_len) % map->capa; + hc = hash(key,key_len) % map->capa; pair = map->buck[hc]; prev = ASE_NULL; @@ -269,7 +269,7 @@ int ase_awk_map_walk (ase_awk_map_t* map, return 0; } -static ase_size_t __hash (const ase_char_t* key, ase_size_t key_len) +static ase_size_t hash (const ase_char_t* key, ase_size_t key_len) { ase_size_t n = 0, i; const ase_char_t* end = key + key_len; diff --git a/ase/awk/val.c b/ase/awk/val.c index 4c443501..00aaae24 100644 --- a/ase/awk/val.c +++ b/ase/awk/val.c @@ -1,5 +1,5 @@ /* - * $Id: val.c,v 1.115 2007-03-10 11:58:35 bacon Exp $ + * $Id: val.c,v 1.116 2007-03-22 10:31:24 bacon Exp $ * * {License} */ @@ -11,23 +11,23 @@ #endif -static ase_char_t* __str_to_str ( +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_str_t* buf, ase_size_t* len); -static ase_char_t* __val_int_to_str ( +static ase_char_t* val_int_to_str ( ase_awk_run_t* run, ase_awk_val_int_t* v, int opt, ase_str_t* buf, ase_size_t* len); -static ase_char_t* __val_real_to_str ( +static ase_char_t* val_real_to_str ( ase_awk_run_t* run, ase_awk_val_real_t* v, int opt, ase_str_t* buf, ase_size_t* len); -static ase_awk_val_nil_t __awk_nil = { ASE_AWK_VAL_NIL, 0 }; -static ase_awk_val_str_t __awk_zls = { ASE_AWK_VAL_STR, 0, ASE_T(""), 0 }; +static ase_awk_val_nil_t awk_nil = { ASE_AWK_VAL_NIL, 0 }; +static ase_awk_val_str_t awk_zls = { ASE_AWK_VAL_STR, 0, ASE_T(""), 0 }; -ase_awk_val_t* ase_awk_val_nil = (ase_awk_val_t*)&__awk_nil; -ase_awk_val_t* ase_awk_val_zls = (ase_awk_val_t*)&__awk_zls; +ase_awk_val_t* ase_awk_val_nil = (ase_awk_val_t*)&awk_nil; +ase_awk_val_t* ase_awk_val_zls = (ase_awk_val_t*)&awk_zls; -static ase_awk_val_int_t __awk_int[] = +static ase_awk_val_int_t awk_int[] = { { ASE_AWK_VAL_INT, 0, -1, ASE_NULL }, { ASE_AWK_VAL_INT, 0, 0, ASE_NULL }, @@ -53,18 +53,18 @@ static ase_awk_val_int_t __awk_int[] = { ASE_AWK_VAL_INT, 0, 20, ASE_NULL } }; -ase_awk_val_t* ase_awk_val_negone = (ase_awk_val_t*)&__awk_int[0]; -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]; +ase_awk_val_t* ase_awk_val_negone = (ase_awk_val_t*)&awk_int[0]; +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]; ase_awk_val_t* ase_awk_makeintval (ase_awk_run_t* run, ase_long_t v) { ase_awk_val_int_t* val; - if (v >= __awk_int[0].val && - v <= __awk_int[ASE_COUNTOF(__awk_int)-1].val) + if (v >= awk_int[0].val && + v <= awk_int[ASE_COUNTOF(awk_int)-1].val) { - return (ase_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) @@ -219,7 +219,7 @@ ase_awk_val_t* ase_awk_makerexval ( return (ase_awk_val_t*)val; } -static void __free_map_val (void* run, void* v) +static void free_map_val (void* run, void* v) { #ifdef DEBUG_VAL ase_dprintf (ASE_T("refdown in map free...")); @@ -241,7 +241,7 @@ ase_awk_val_t* ase_awk_makemapval (ase_awk_run_t* run) val->type = ASE_AWK_VAL_MAP; val->ref = 0; val->map = ase_awk_map_open ( - ASE_NULL, run, 256, __free_map_val, run->awk); + ASE_NULL, run, 256, free_map_val, run->awk); if (val->map == ASE_NULL) { ASE_AWK_FREE (run->awk, val); @@ -281,8 +281,8 @@ ase_bool_t ase_awk_isbuiltinval (ase_awk_val_t* val) 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]); + (val >= (ase_awk_val_t*)&awk_int[0] && + val <= (ase_awk_val_t*)&awk_int[ASE_COUNTOF(awk_int)-1]); } void ase_awk_freeval (ase_awk_run_t* run, ase_awk_val_t* val, ase_bool_t cache) @@ -429,7 +429,7 @@ ase_char_t* ase_awk_valtostr ( { if (v->type == ASE_AWK_VAL_NIL) { - return __str_to_str (run, ASE_T(""), 0, opt, buf, len); + return str_to_str (run, ASE_T(""), 0, opt, buf, len); } if (v->type == ASE_AWK_VAL_INT) @@ -439,14 +439,14 @@ ase_char_t* ase_awk_valtostr ( /* if (vi->nde != ASE_NULL && vi->nde->str != ASE_NULL) { - return __str_to_str ( + return str_to_str ( run, vi->nde->str, vi->nde->len, opt, buf, len); } else { */ - return __val_int_to_str (run, vi, opt, buf, len); + return val_int_to_str (run, vi, opt, buf, len); /*}*/ } @@ -457,13 +457,13 @@ ase_char_t* ase_awk_valtostr ( /* if (vr->nde != ASE_NULL && vr->nde->str != ASE_NULL) { - return __str_to_str ( + return str_to_str ( run, vr->nde->str, vr->nde->len, opt, buf, len); } else {*/ - return __val_real_to_str (run, vr, opt, buf, len); + return val_real_to_str (run, vr, opt, buf, len); /*}*/ } @@ -471,7 +471,7 @@ ase_char_t* ase_awk_valtostr ( { ase_awk_val_str_t* vs = (ase_awk_val_str_t*)v; - return __str_to_str ( + return str_to_str ( run, vs->buf, vs->len, opt, buf, len); } @@ -485,7 +485,7 @@ ase_char_t* ase_awk_valtostr ( return ASE_NULL; } -static ase_char_t* __str_to_str ( +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_str_t* buf, ase_size_t* len) { @@ -521,7 +521,7 @@ static ase_char_t* __str_to_str ( } } -static ase_char_t* __val_int_to_str ( +static ase_char_t* val_int_to_str ( ase_awk_run_t* run, ase_awk_val_int_t* v, int opt, ase_str_t* buf, ase_size_t* len) { @@ -619,7 +619,7 @@ static ase_char_t* __val_int_to_str ( return tmp; } -static ase_char_t* __val_real_to_str ( +static ase_char_t* val_real_to_str ( ase_awk_run_t* run, ase_awk_val_real_t* v, int opt, ase_str_t* buf, ase_size_t* len) { @@ -767,16 +767,16 @@ int ase_awk_strtonum ( } -#define __DPRINTF run->awk->prmfns.misc.dprintf -#define __DCUSTOM run->awk->prmfns.misc.custom_data +#define DPRINTF run->awk->prmfns.misc.dprintf +#define DCUSTOM run->awk->prmfns.misc.custom_data -static int __print_pair (ase_awk_pair_t* pair, void* arg) +static int print_pair (ase_awk_pair_t* pair, void* arg) { ase_awk_run_t* run = (ase_awk_run_t*)arg; - __DPRINTF (__DCUSTOM, ASE_T(" %s=>"), pair->key); + DPRINTF (DCUSTOM, ASE_T(" %s=>"), pair->key); ase_awk_dprintval ((ase_awk_run_t*)arg, pair->val); - __DPRINTF (__DCUSTOM, ASE_T(" ")); + DPRINTF (DCUSTOM, ASE_T(" ")); return 0; } @@ -787,21 +787,21 @@ void ase_awk_dprintval (ase_awk_run_t* run, ase_awk_val_t* val) switch (val->type) { case ASE_AWK_VAL_NIL: - __DPRINTF (__DCUSTOM, ASE_T("nil")); + DPRINTF (DCUSTOM, ASE_T("nil")); break; case ASE_AWK_VAL_INT: #if ASE_SIZEOF_LONG_LONG > 0 - __DPRINTF (__DCUSTOM, ASE_T("%lld"), + DPRINTF (DCUSTOM, ASE_T("%lld"), (long long)((ase_awk_val_int_t*)val)->val); #elif ASE_SIZEOF___INT64 > 0 - __DPRINTF (__DCUSTOM, ASE_T("%I64d"), + DPRINTF (DCUSTOM, ASE_T("%I64d"), (__int64)((ase_awk_val_int_t*)val)->val); #elif ASE_SIZEOF_LONG > 0 - __DPRINTF (__DCUSTOM, ASE_T("%ld"), + DPRINTF (DCUSTOM, ASE_T("%ld"), (long)((ase_awk_val_int_t*)val)->val); #elif ASE_SIZEOF_INT > 0 - __DPRINTF (__DCUSTOM, ASE_T("%d"), + DPRINTF (DCUSTOM, ASE_T("%d"), (int)((ase_awk_val_int_t*)val)->val); #else #error unsupported size @@ -809,31 +809,31 @@ void ase_awk_dprintval (ase_awk_run_t* run, ase_awk_val_t* val) break; case ASE_AWK_VAL_REAL: - __DPRINTF (__DCUSTOM, ASE_T("%Lf"), + DPRINTF (DCUSTOM, ASE_T("%Lf"), (long double)((ase_awk_val_real_t*)val)->val); break; case ASE_AWK_VAL_STR: - __DPRINTF (__DCUSTOM, ASE_T("%s"), ((ase_awk_val_str_t*)val)->buf); + DPRINTF (DCUSTOM, ASE_T("%s"), ((ase_awk_val_str_t*)val)->buf); break; case ASE_AWK_VAL_REX: - __DPRINTF (__DCUSTOM, ASE_T("REX[%s]"), ((ase_awk_val_rex_t*)val)->buf); + DPRINTF (DCUSTOM, ASE_T("REX[%s]"), ((ase_awk_val_rex_t*)val)->buf); break; case ASE_AWK_VAL_MAP: - __DPRINTF (__DCUSTOM, ASE_T("MAP[")); - ase_awk_map_walk (((ase_awk_val_map_t*)val)->map, __print_pair, run); - __DPRINTF (__DCUSTOM, ASE_T("]")); + DPRINTF (DCUSTOM, ASE_T("MAP[")); + ase_awk_map_walk (((ase_awk_val_map_t*)val)->map, print_pair, run); + DPRINTF (DCUSTOM, ASE_T("]")); break; case ASE_AWK_VAL_REF: - __DPRINTF (__DCUSTOM, ASE_T("REF[id=%d,val="), ((ase_awk_val_ref_t*)val)->id); + DPRINTF (DCUSTOM, ASE_T("REF[id=%d,val="), ((ase_awk_val_ref_t*)val)->id); ase_awk_dprintval (run, *((ase_awk_val_ref_t*)val)->adr); - __DPRINTF (__DCUSTOM, ASE_T("]")); + DPRINTF (DCUSTOM, ASE_T("]")); break; default: - __DPRINTF (__DCUSTOM, ASE_T("**** INTERNAL ERROR - INVALID VALUE TYPE ****\n")); + DPRINTF (DCUSTOM, ASE_T("**** INTERNAL ERROR - INVALID VALUE TYPE ****\n")); } }