hyung-hwan/hawk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

implemented switch ... case .. default ..

Browse Source
This commit is contained in:
hyung-hwan 2025-06-18 23:45:34 +09:00
parent 846cbcf951
commit fac4aa7af5
24 changed files with 1909 additions and 1306 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
README.md
View File

@ -476,7 +476,9 @@ The following words are reserved and cannot be used as a variable name, a parame
- BEGIN
- END
- break
- case
- continue
- default
- delete
- do
- else
@ -494,6 +496,7 @@ The following words are reserved and cannot be used as a variable name, a parame
- printf
- return
- while
- switch
However, some of these words not beginning with `@` can be used as normal names in the context of a module call. For example, `mymod::break`. In practice, the predefined names used for built-in commands, functions, and variables are treated as if they are reserved since you can't create another definition with the same name.
@ -633,7 +636,7 @@ BEGIN {
Hawk supports various control structures for flow control and iteration, similar to those found in awk.
The `if` statement in Hawk follows the same syntax as in awk and other programming languages. It allows you to execute a block of code conditionally based on a specified condition.
The `if` statement follows the same syntax as in awk and other programming languages. It allows you to execute a block of code conditionally based on a specified condition.
```awk
if (condition) {
@ -645,7 +648,18 @@ if (condition) {
}
```
The `while` loop in Hawk is used to repeatedly execute a block of code as long as a specific condition is true.
The `switch` statement allows the result of an expression to be tested against a list of values.
```awk
switch (expression) {
case value:
## statements
...
default:
## statements
}
```
The `while` loop is used to repeatedly execute a block of code as long as a specific condition is true.
```awk
while (condition) {
# statements
@ -659,13 +673,13 @@ do {
} while (condition)
```
The `for` loop in Hawk follows the same syntax as in awk and allows you to iterate over a range of values or an array.
The `for` loop follows the same syntax as in awk and allows you to iterate over a range of values or an array.
```awk
for (initialization; condition; increment/decrement) {
## statements
}
```
You can also use the for loop to iterate over the elements of an array:
You can also use the `fo`r loop to iterate over the elements of an array:
```awk
for (index in array) {
## statements using array[index]

9
bin/hawk.c
View File

@ -539,6 +539,15 @@ static void print_usage (FILE* out, const hawk_bch_t* argv0, const hawk_bch_t* r
{
fprintf (out, " --%-18s on/off %s\n", opttab[j].name, opttab[j].desc);
}
if (!real_argv0)
{
fprintf (out, "\n");
fprintf (out, "Special mode switching options(must be specified first to take effect):\n");
fprintf (out, " --hawk/--awk run in the hawk mode\n");
fprintf (out, " --cut run in the cut mode\n");
fprintf (out, " --sed run in the sed mode\n");
}
}
/* ---------------------------------------------------------------------- */

12
lib/Hawk.cpp
View File

@ -1914,7 +1914,7 @@ int Hawk::setIncludeDirs (const hawk_uch_t* dirs)
if (HAWK_UNLIKELY(!tmp)) return -1;
int n = hawk_setopt(hawk, HAWK_OPT_INCLUDEDIRS, tmp);
hawk_freemem (hawk, tmp);
hawk_freemem(hawk, tmp);
return n;
#endif
}
@ -1927,7 +1927,7 @@ int Hawk::setIncludeDirs (const hawk_bch_t* dirs)
if (HAWK_UNLIKELY(!tmp)) return -1;
int n = hawk_setopt(hawk, HAWK_OPT_INCLUDEDIRS, tmp);
hawk_freemem (hawk, tmp);
hawk_freemem(hawk, tmp);
return n;
#else
return hawk_setopt(this->hawk, HAWK_OPT_INCLUDEDIRS, dirs);
@ -2175,9 +2175,9 @@ void Hawk::xstrs_t::clear (hawk_t* hawk)
if (this->ptr != HAWK_NULL)
{
while (this->len > 0)
hawk_freemem (hawk, this->ptr[--this->len].ptr);
hawk_freemem(hawk, this->ptr[--this->len].ptr);
hawk_freemem (hawk, this->ptr);
hawk_freemem(hawk, this->ptr);
this->ptr = HAWK_NULL;
this->capa = 0;
}
@ -2423,7 +2423,7 @@ hawk_ooi_t Hawk::readSource (hawk_t* hawk, hawk_sio_cmd_t cmd, hawk_sio_arg_t* a
case HAWK_SIO_CMD_READ:
return xtn->hawk->source_reader->read(sdat, data, count);
default:
hawk_seterrnum (hawk, HAWK_NULL, HAWK_EINTERN);
hawk_seterrnum(hawk, HAWK_NULL, HAWK_EINTERN);
return -1;
}
}
@ -2442,7 +2442,7 @@ hawk_ooi_t Hawk::writeSource (hawk_t* hawk, hawk_sio_cmd_t cmd, hawk_sio_arg_t*
case HAWK_SIO_CMD_WRITE:
return xtn->hawk->source_writer->write (sdat, data, count);
default:
hawk_seterrnum (hawk, HAWK_NULL, HAWK_EINTERN);
hawk_seterrnum(hawk, HAWK_NULL, HAWK_EINTERN);
return -1;
}
}

3
lib/err.c
View File

@ -76,6 +76,7 @@ const hawk_ooch_t* hawk_dfl_errstr (hawk_errnum_t errnum)
HAWK_T("left brace expected"),
HAWK_T("left parenthesis expected"),
HAWK_T("right parenthesis expected"),
HAWK_T("right brace expected"),
HAWK_T("right bracket expected"),
HAWK_T("comma expected"),
HAWK_T("semicolon expected"),
@ -88,6 +89,8 @@ const hawk_ooch_t* hawk_dfl_errstr (hawk_errnum_t errnum)
HAWK_T("keyword 'function' expected"),
HAWK_T("keyword 'while' expected"),
HAWK_T("keyword 'case' expected"),
HAWK_T("multiple 'default' labels"),
HAWK_T("invalid assignment statement"),
HAWK_T("identifier expected"),
HAWK_T("not a valid function name"),

6
lib/fio.c
View File

@ -284,7 +284,7 @@ int hawk_fio_init (hawk_fio_t* fio, hawk_gem_t* gem, const hawk_ooch_t* path, in
{
handle = *(hawk_fio_hnd_t*)path;
/* do not specify an invalid handle value */
/*HAWK_ASSERT (hawk, handle != INVALID_HANDLE_VALUE);*/
/*HAWK_ASSERT(hawk, handle != INVALID_HANDLE_VALUE);*/
if (handle == GetStdHandle (STD_INPUT_HANDLE))
fio->status |= STATUS_WIN32_STDIN;
@ -573,7 +573,7 @@ int hawk_fio_init (hawk_fio_t* fio, hawk_gem_t* gem, const hawk_ooch_t* path, in
{
handle = *(hawk_fio_hnd_t*)path;
/* do not specify an invalid handle value */
/*HAWK_ASSERT (hawk, handle >= 0);*/
/*HAWK_ASSERT(hawk, handle >= 0);*/
}
else
{
@ -784,7 +784,7 @@ int hawk_fio_init (hawk_fio_t* fio, hawk_gem_t* gem, const hawk_ooch_t* path, in
{
handle = *(hawk_fio_hnd_t*)path;
/* do not specify an invalid handle value */
/*HAWK_ASSERT (hawk, handle >= 0);*/
/*HAWK_ASSERT(hawk, handle >= 0);*/
}
else
{

12
lib/fmt.c
View File

@ -1218,7 +1218,7 @@ static int fmt_outv (hawk_fmtout_t* fmtout, va_list ap)
newcapa = precision + width + 32;
if (fltout->capa < newcapa)
{
HAWK_ASSERT (hawk, fltout->ptr == fltout->buf);
HAWK_ASSERT(hawk, fltout->ptr == fltout->buf);
fltout->ptr = HAWK_MMGR_ALLOC(fmtout->mmgr, HAWK_SIZEOF(char_t) * (newcapa + 1));
if (!fltout->ptr) goto oops;
@ -1583,7 +1583,7 @@ int hawk_ufmt_out (hawk_fmtout_t* fmtout, const hawk_uch_t* fmt, ...)
#define log_write(hawk,mask,ptr,len) do { \
int shuterr = (hawk)->shuterr; \
(hawk)->shuterr = 1; \
(hawk)->prm.logwrite (hawk, mask, ptr, len); \
(hawk)->prm.logwrite(hawk, mask, ptr, len); \
(hawk)->shuterr = shuterr; \
} while(0)
@ -1604,7 +1604,7 @@ static int log_oocs (hawk_fmtout_t* fmtout, const hawk_ooch_t* ptr, hawk_oow_t l
hawk->log.ptr[hawk->log.len++] = '\n';
}
log_write (hawk, hawk->log.last_mask, hawk->log.ptr, hawk->log.len);
log_write(hawk, hawk->log.last_mask, hawk->log.ptr, hawk->log.len);
hawk->log.len = 0;
}
@ -1648,7 +1648,7 @@ redo:
/* no line ending - append a line terminator */
hawk->log.ptr[hawk->log.len++] = '\n';
}
log_write (hawk, hawk->log.last_mask, hawk->log.ptr, hawk->log.len);
log_write(hawk, hawk->log.last_mask, hawk->log.ptr, hawk->log.len);
hawk->log.len = 0;
}
@ -1761,7 +1761,7 @@ hawk_ooi_t hawk_logbfmtv (hawk_t* hawk, hawk_bitmask_t mask, const hawk_bch_t* f
if (hawk->log.len > 0 && hawk->log.ptr[hawk->log.len - 1] == '\n')
{
log_write (hawk, hawk->log.last_mask, hawk->log.ptr, hawk->log.len);
log_write(hawk, hawk->log.last_mask, hawk->log.ptr, hawk->log.len);
hawk->log.len = 0;
}
@ -1814,7 +1814,7 @@ hawk_ooi_t hawk_logufmtv (hawk_t* hawk, hawk_bitmask_t mask, const hawk_uch_t* f
if (hawk->log.len > 0 && hawk->log.ptr[hawk->log.len - 1] == '\n')
{
log_write (hawk, hawk->log.last_mask, hawk->log.ptr, hawk->log.len);
log_write(hawk, hawk->log.last_mask, hawk->log.ptr, hawk->log.len);
hawk->log.len = 0;
}
return (x <= -1)? -1: fo.count;

42
lib/fnc.c
View File

@ -98,7 +98,7 @@ static hawk_fnc_t* add_fnc (hawk_t* hawk, const hawk_ooch_t* name, const hawk_fn
ncs.len = hawk_count_oocstr(name);
if (ncs.len <= 0)
{
hawk_seterrnum (hawk, HAWK_NULL, HAWK_EINVAL);
hawk_seterrnum(hawk, HAWK_NULL, HAWK_EINVAL);
return HAWK_NULL;
}
@ -108,7 +108,7 @@ static hawk_fnc_t* add_fnc (hawk_t* hawk, const hawk_ooch_t* name, const hawk_fn
if (hawk_findfncwithoocs(hawk, &ncs) != HAWK_NULL)
{
hawk_seterrfmt (hawk, HAWK_NULL, HAWK_EEXIST, HAWK_T("unable to add existing function - %js"), name);
hawk_seterrfmt(hawk, HAWK_NULL, HAWK_EEXIST, HAWK_T("unable to add existing function - %js"), name);
return HAWK_NULL;
}
@ -135,8 +135,8 @@ static hawk_fnc_t* add_fnc (hawk_t* hawk, const hawk_ooch_t* name, const hawk_fn
if (!hawk_htb_insert(hawk->fnc.user, (hawk_ooch_t*)ncs.ptr, ncs.len, fnc, 0))
{
const hawk_ooch_t* bem = hawk_backuperrmsg(hawk);
hawk_seterrfmt (hawk, HAWK_NULL, hawk_geterrnum(hawk), HAWK_T("unable to add function - %js - %js"), name, bem);
hawk_freemem (hawk, fnc);
hawk_seterrfmt(hawk, HAWK_NULL, hawk_geterrnum(hawk), HAWK_T("unable to add function - %js - %js"), name, bem);
hawk_freemem(hawk, fnc);
fnc = HAWK_NULL;
}
}
@ -166,13 +166,13 @@ hawk_fnc_t* hawk_addfncwithbcstr (hawk_t* hawk, const hawk_bch_t* name, const ha
wcs.ptr = hawk_dupbtoucstr(hawk, name, &wcs.len, 0);
if (HAWK_UNLIKELY(!wcs.ptr))
{
if (wspec.arg.spec) hawk_freemem (hawk, (hawk_uch_t*)wspec.arg.spec);
if (wspec.arg.spec) hawk_freemem(hawk, (hawk_uch_t*)wspec.arg.spec);
return HAWK_NULL;
}
fnc = add_fnc(hawk, wcs.ptr, &wspec);
hawk_freemem (hawk, wcs.ptr);
if (wspec.arg.spec) hawk_freemem (hawk, (hawk_uch_t*)wspec.arg.spec);
hawk_freemem(hawk, wcs.ptr);
if (wspec.arg.spec) hawk_freemem(hawk, (hawk_uch_t*)wspec.arg.spec);
return fnc;
#endif
}
@ -197,13 +197,13 @@ hawk_fnc_t* hawk_addfncwithucstr (hawk_t* hawk, const hawk_uch_t* name, const ha
mbs.ptr = hawk_duputobcstr(hawk, name, &mbs.len);
if (HAWK_UNLIKELY(!mbs.ptr))
{
if (mspec.arg.spec) hawk_freemem (hawk, (hawk_bch_t*)mspec.arg.spec);
if (mspec.arg.spec) hawk_freemem(hawk, (hawk_bch_t*)mspec.arg.spec);
return HAWK_NULL;
}
fnc = add_fnc(hawk, mbs.ptr, &mspec);
hawk_freemem (hawk, mbs.ptr);
if (mspec.arg.spec) hawk_freemem (hawk, (hawk_bch_t*)mspec.arg.spec);
hawk_freemem(hawk, mbs.ptr);
if (mspec.arg.spec) hawk_freemem(hawk, (hawk_bch_t*)mspec.arg.spec);
return fnc;
#else
return add_fnc(hawk, name, spec);
@ -221,7 +221,7 @@ int hawk_delfncwithbcstr (hawk_t* hawk, const hawk_bch_t* name)
#if defined(HAWK_OOCH_IS_BCH)
if (hawk_htb_delete(hawk->fnc.user, ncs.ptr, ncs.len) <= -1)
{
hawk_seterrfmt (hawk, HAWK_NULL, HAWK_ENOENT, HAWK_T("no such function - %hs"), name);
hawk_seterrfmt(hawk, HAWK_NULL, HAWK_ENOENT, HAWK_T("no such function - %hs"), name);
return -1;
}
#else
@ -229,11 +229,11 @@ int hawk_delfncwithbcstr (hawk_t* hawk, const hawk_bch_t* name)
if (!wcs.ptr) return -1;
if (hawk_htb_delete(hawk->fnc.user, wcs.ptr, wcs.len) <= -1)
{
hawk_seterrfmt (hawk, HAWK_NULL, HAWK_ENOENT, HAWK_T("no such function - %hs"), name);
hawk_freemem (hawk, wcs.ptr);
hawk_seterrfmt(hawk, HAWK_NULL, HAWK_ENOENT, HAWK_T("no such function - %hs"), name);
hawk_freemem(hawk, wcs.ptr);
return -1;
}
hawk_freemem (hawk, wcs.ptr);
hawk_freemem(hawk, wcs.ptr);
#endif
return 0;
@ -252,15 +252,15 @@ int hawk_delfncwithucstr (hawk_t* hawk, const hawk_uch_t* name)
if (!mbs.ptr) return -1;
if (hawk_htb_delete(hawk->fnc.user, mbs.ptr, mbs.len) <= -1)
{
hawk_seterrfmt (hawk, HAWK_NULL, HAWK_ENOENT, HAWK_T("no such function - %ls"), name);
hawk_freemem (hawk, mbs.ptr);
hawk_seterrfmt(hawk, HAWK_NULL, HAWK_ENOENT, HAWK_T("no such function - %ls"), name);
hawk_freemem(hawk, mbs.ptr);
return -1;
}
hawk_freemem (hawk, mbs.ptr);
hawk_freemem(hawk, mbs.ptr);
#else
if (hawk_htb_delete(hawk->fnc.user, ncs.ptr, ncs.len) <= -1)
{
hawk_seterrfmt (hawk, HAWK_NULL, HAWK_ENOENT, HAWK_T("no such function - %ls"), name);
hawk_seterrfmt(hawk, HAWK_NULL, HAWK_ENOENT, HAWK_T("no such function - %ls"), name);
return -1;
}
#endif
@ -297,7 +297,7 @@ static hawk_fnc_t* find_fnc (hawk_t* hawk, const hawk_oocs_t* name)
if ((hawk->opt.trait & fnc->spec.trait) == fnc->spec.trait) return fnc;
}
hawk_seterrfmt (hawk, HAWK_NULL, HAWK_ENOENT, HAWK_T("no such function - %js"), name);
hawk_seterrfmt(hawk, HAWK_NULL, HAWK_ENOENT, HAWK_T("no such function - %js"), name);
return HAWK_NULL;
}
@ -312,7 +312,7 @@ hawk_fnc_t* hawk_findfncwithbcs (hawk_t* hawk, const hawk_bcs_t* name)
wcs.ptr = hawk_dupbtouchars(hawk, name->ptr, name->len, &wcs.len, 0);
if (HAWK_UNLIKELY(!wcs.ptr)) return HAWK_NULL;
fnc = find_fnc(hawk, &wcs);
hawk_freemem (hawk, wcs.ptr);
hawk_freemem(hawk, wcs.ptr);
return fnc;
#endif
}
@ -326,7 +326,7 @@ hawk_fnc_t* hawk_findfncwithucs (hawk_t* hawk, const hawk_ucs_t* name)
mbs.ptr = hawk_duputobchars(hawk, name->ptr, name->len, &mbs.len);
if (HAWK_UNLIKELY(!mbs.ptr)) return HAWK_NULL;
fnc = find_fnc(hawk, &mbs);
hawk_freemem (hawk, mbs.ptr);
hawk_freemem(hawk, mbs.ptr);
return fnc;
#else
return find_fnc(hawk, name);

3
lib/hawk-cmn.h
View File

@ -940,6 +940,7 @@ enum hawk_errnum_t
HAWK_ELBRACE, /**< left brace expected */
HAWK_ELPAREN, /**< left parenthesis expected */
HAWK_ERPAREN, /**< right parenthesis expected */
HAWK_ERBRACE, /**< right brace expected */
HAWK_ERBRACK, /**< right bracket expected */
HAWK_ECOMMA, /**< comma expected */
HAWK_ESCOLON, /**< semicolon expected */
@ -952,6 +953,8 @@ enum hawk_errnum_t
HAWK_EKWFNC, /**< keyword 'function' expected */
HAWK_EKWWHL, /**< keyword 'while' expected */
HAWK_EKWCASE, /**< keyword 'case' expected */
HAWK_EMULDFL, /**< multiple 'default' labels */
HAWK_EASSIGN, /**< assignment statement expected */
HAWK_EIDENT, /**< identifier expected */
HAWK_EFUNNAM, /**< not a valid function name */

1
lib/hawk-prv.h
View File

@ -278,6 +278,7 @@ struct hawk_t
hawk_oow_t loop;
hawk_oow_t expr; /* expression */
hawk_oow_t incl;
hawk_oow_t swtch; /* switch */
} depth;
/* current pragma values */

62
lib/hawk.c
View File

@ -30,18 +30,18 @@ static void free_fun (hawk_htb_t* map, void* vptr, hawk_oow_t vlen)
hawk_fun_t* f = (hawk_fun_t*)vptr;
/* f->name doesn't have to be freed */
/*hawk_freemem (hawk, f->name);*/
/*hawk_freemem(hawk, f->name);*/
if (f->argspec) hawk_freemem (hawk, f->argspec);
hawk_clrpt (hawk, f->body);
hawk_freemem (hawk, f);
if (f->argspec) hawk_freemem(hawk, f->argspec);
hawk_clrpt(hawk, f->body);
hawk_freemem(hawk, f);
}
static void free_fnc (hawk_htb_t* map, void* vptr, hawk_oow_t vlen)
{
hawk_t* hawk = *(hawk_t**)(map + 1);
hawk_fnc_t* f = (hawk_fnc_t*)vptr;
hawk_freemem (hawk, f);
hawk_freemem(hawk, f);
}
static int init_token (hawk_t* hawk, hawk_tok_t* tok)
@ -139,7 +139,7 @@ int hawk_init (hawk_t* hawk, hawk_mmgr_t* mmgr, hawk_cmgr_t* cmgr, const hawk_pr
};
/* zero out the object */
HAWK_MEMSET (hawk, 0, HAWK_SIZEOF(*hawk));
HAWK_MEMSET(hawk, 0, HAWK_SIZEOF(*hawk));
/* remember the memory manager */
hawk->_instsize = HAWK_SIZEOF(*hawk);
@ -164,7 +164,7 @@ int hawk_init (hawk_t* hawk, hawk_mmgr_t* mmgr, hawk_cmgr_t* cmgr, const hawk_pr
prm->math.pow == HAWK_NULL ||
prm->math.mod == HAWK_NULL)
{
hawk_seterrnum (hawk, HAWK_NULL, HAWK_EINVAL);
hawk_seterrnum(hawk, HAWK_NULL, HAWK_EINVAL);
goto oops;
}
hawk->prm = *prm;
@ -217,7 +217,7 @@ int hawk_init (hawk_t* hawk, hawk_mmgr_t* mmgr, hawk_cmgr_t* cmgr, const hawk_pr
hawk->fnc.user == HAWK_NULL ||
hawk->modtab == HAWK_NULL)
{
hawk_seterrnum (hawk, HAWK_NULL, HAWK_ENOMEM);
hawk_seterrnum(hawk, HAWK_NULL, HAWK_ENOMEM);
goto oops;
}
@ -262,7 +262,7 @@ oops:
fini_token (&hawk->ntok);
fini_token (&hawk->tok);
fini_token (&hawk->ptok);
if (hawk->log.ptr) hawk_freemem (hawk, hawk->log.ptr);
if (hawk->log.ptr) hawk_freemem(hawk, hawk->log.ptr);
hawk->log.capa = 0;
return -1;
@ -280,14 +280,14 @@ void hawk_fini (hawk_t* hawk)
{
int shuterr = hawk->shuterr;
hawk->shuterr = 1;
hawk->prm.logwrite (hawk, hawk->log.last_mask, hawk->log.ptr, hawk->log.len);
hawk->prm.logwrite(hawk, hawk->log.last_mask, hawk->log.ptr, hawk->log.len);
hawk->shuterr = shuterr;
}
for (ecb = hawk->ecb; ecb != (hawk_ecb_t*)hawk; ecb = ecb_next)
{
ecb_next = ecb->next;
if (ecb->close) ecb->close (hawk, ecb->ctx);
if (ecb->close) ecb->close(hawk, ecb->ctx);
}
do { ecb = hawk_popecb(hawk); } while (ecb);
@ -309,23 +309,23 @@ void hawk_fini (hawk_t* hawk)
fini_token (&hawk->tok);
fini_token (&hawk->ptok);
if (hawk->parse.incl_hist.ptr) hawk_freemem (hawk, hawk->parse.incl_hist.ptr);
if (hawk->parse.incl_hist.ptr) hawk_freemem(hawk, hawk->parse.incl_hist.ptr);
hawk_clearsionames (hawk);
/* destroy dynamically allocated options */
for (i = 0; i < HAWK_COUNTOF(hawk->opt.mod); i++)
{
if (hawk->opt.mod[i].ptr) hawk_freemem (hawk, hawk->opt.mod[i].ptr);
if (hawk->opt.mod[i].ptr) hawk_freemem(hawk, hawk->opt.mod[i].ptr);
}
if (hawk->opt.includedirs.ptr) hawk_freemem (hawk, hawk->opt.includedirs.ptr);
if (hawk->opt.includedirs.ptr) hawk_freemem(hawk, hawk->opt.includedirs.ptr);
for (i = 0; i < HAWK_COUNTOF(hawk->sbuf); i++)
{
if (hawk->sbuf[i].ptr)
{
hawk_freemem (hawk, hawk->sbuf[i].ptr);
hawk_freemem(hawk, hawk->sbuf[i].ptr);
hawk->sbuf[i].ptr = HAWK_NULL;
hawk->sbuf[i].len = 0;
hawk->sbuf[i].capa = 0;
@ -340,13 +340,13 @@ void hawk_fini (hawk_t* hawk)
* logging */
int shuterr = hawk->shuterr;
hawk->shuterr = 1;
hawk->prm.logwrite (hawk, hawk->log.last_mask, hawk->log.ptr, hawk->log.len);
hawk->prm.logwrite(hawk, hawk->log.last_mask, hawk->log.ptr, hawk->log.len);
hawk->shuterr = shuterr;
}
if (hawk->log.ptr)
{
hawk_freemem (hawk, hawk->log.ptr);
hawk_freemem(hawk, hawk->log.ptr);
hawk->log.capa = 0;
hawk->log.len = 0;
}
@ -359,7 +359,7 @@ static hawk_rbt_walk_t unload_module (hawk_rbt_t* rbt, hawk_rbt_pair_t* pair, vo
md = HAWK_RBT_VPTR(pair);
if (md->mod.unload) md->mod.unload (&md->mod, hawk);
if (md->handle) hawk->prm.modclose (hawk, md->handle);
if (md->handle) hawk->prm.modclose(hawk, md->handle);
return HAWK_RBT_WALK_FORWARD;
}
@ -371,7 +371,7 @@ void hawk_clear (hawk_t* hawk)
for (ecb = hawk->ecb; ecb != (hawk_ecb_t*)hawk; ecb = ecb_next)
{
ecb_next = ecb->next;
if (ecb->clear) ecb->clear (hawk, ecb->ctx);
if (ecb->clear) ecb->clear(hawk, ecb->ctx);
}
/* hawk_clear() this doesn't pop event callbacks */
@ -418,14 +418,14 @@ void hawk_clear (hawk_t* hawk)
if (hawk->tree.begin)
{
hawk_clrpt (hawk, hawk->tree.begin);
hawk_clrpt(hawk, hawk->tree.begin);
hawk->tree.begin = HAWK_NULL;
hawk->tree.begin_tail = HAWK_NULL;
}
if (hawk->tree.end)
{
hawk_clrpt (hawk, hawk->tree.end);
hawk_clrpt(hawk, hawk->tree.end);
hawk->tree.end = HAWK_NULL;
hawk->tree.end_tail = HAWK_NULL;
}
@ -433,9 +433,9 @@ void hawk_clear (hawk_t* hawk)
while (hawk->tree.chain)
{
hawk_chain_t* next = hawk->tree.chain->next;
if (hawk->tree.chain->pattern) hawk_clrpt (hawk, hawk->tree.chain->pattern);
if (hawk->tree.chain->action) hawk_clrpt (hawk, hawk->tree.chain->action);
hawk_freemem (hawk, hawk->tree.chain);
if (hawk->tree.chain->pattern) hawk_clrpt(hawk, hawk->tree.chain->pattern);
if (hawk->tree.chain->action) hawk_clrpt(hawk, hawk->tree.chain->action);
hawk_freemem(hawk, hawk->tree.chain);
hawk->tree.chain = next;
}
@ -493,7 +493,7 @@ int hawk_setopt (hawk_t* hawk, hawk_opt_t id, const void* value)
if (dup_str_opt(hawk, value, &tmp) <= -1) return -1;
idx = id - HAWK_OPT_MODLIBDIRS;
if (hawk->opt.mod[idx].ptr) hawk_freemem (hawk, hawk->opt.mod[idx].ptr);
if (hawk->opt.mod[idx].ptr) hawk_freemem(hawk, hawk->opt.mod[idx].ptr);
hawk->opt.mod[idx] = tmp;
return 0;
@ -503,7 +503,7 @@ int hawk_setopt (hawk_t* hawk, hawk_opt_t id, const void* value)
{
hawk_oocs_t tmp;
if (dup_str_opt(hawk, value, &tmp) <= -1) return -1;
if (hawk->opt.includedirs.ptr) hawk_freemem (hawk, hawk->opt.includedirs.ptr);
if (hawk->opt.includedirs.ptr) hawk_freemem(hawk, hawk->opt.includedirs.ptr);
hawk->opt.includedirs = tmp;
return 0;
}
@ -535,7 +535,7 @@ int hawk_setopt (hawk_t* hawk, hawk_opt_t id, const void* value)
}
hawk_seterrnum (hawk, HAWK_NULL, HAWK_EINVAL);
hawk_seterrnum(hawk, HAWK_NULL, HAWK_EINVAL);
return -1;
}
@ -581,7 +581,7 @@ int hawk_getopt (hawk_t* hawk, hawk_opt_t id, void* value)
};
hawk_seterrnum (hawk, HAWK_NULL, HAWK_EINVAL);
hawk_seterrnum(hawk, HAWK_NULL, HAWK_EINVAL);
return -1;
}
@ -728,21 +728,21 @@ int hawk_findmodsymflt_noseterr (hawk_t* hawk, hawk_mod_flt_tab_t* flttab, hawk_
int hawk_findmodsymfnc (hawk_t* hawk, hawk_mod_fnc_tab_t* fnctab, hawk_oow_t count, const hawk_ooch_t* name, hawk_mod_sym_t* sym)
{
int n = hawk_findmodsymfnc_noseterr(hawk, fnctab, count, name, sym);
if (n <= -1) hawk_seterrfmt (hawk, HAWK_NULL, HAWK_ENOENT, HAWK_T("'%js' not found"), name);
if (n <= -1) hawk_seterrfmt(hawk, HAWK_NULL, HAWK_ENOENT, HAWK_T("'%js' not found"), name);
return n;
}
int hawk_findmodsymint (hawk_t* hawk, hawk_mod_int_tab_t* inttab, hawk_oow_t count, const hawk_ooch_t* name, hawk_mod_sym_t* sym)
{
int n = hawk_findmodsymint_noseterr(hawk, inttab, count, name, sym);
if (n <= -1) hawk_seterrfmt (hawk, HAWK_NULL, HAWK_ENOENT, HAWK_T("'%js' not found"), name);
if (n <= -1) hawk_seterrfmt(hawk, HAWK_NULL, HAWK_ENOENT, HAWK_T("'%js' not found"), name);
return n;
}
int hawk_findmodsymflt (hawk_t* hawk, hawk_mod_flt_tab_t* flttab, hawk_oow_t count, const hawk_ooch_t* name, hawk_mod_sym_t* sym)
{
int n = hawk_findmodsymflt_noseterr(hawk, flttab, count, name, sym);
if (n <= -1) hawk_seterrfmt (hawk, HAWK_NULL, HAWK_ENOENT, HAWK_T("'%js' not found"), name);
if (n <= -1) hawk_seterrfmt(hawk, HAWK_NULL, HAWK_ENOENT, HAWK_T("'%js' not found"), name);
return n;
}

14
lib/hawk.h
View File

@ -60,7 +60,7 @@
* hawk_rio_cbs_t rio; // need to initialize it with callback functions
*
* hawk = hawk_open(mmgr, 0, prm); // create an interpreter
* hawk_parse (hawk, &sio); // parse a script
* hawk_parse(hawk, &sio); // parse a script
* rtx = hawk_rtx_open(hawk, 0, &rio); // create a runtime context
* retv = hawk_rtx_loop(rtx); // run a standard AWK loop
* if (retv) hawk_rtx_refdownval (rtx, retv); // free return value
@ -398,6 +398,8 @@ enum hawk_nde_type_t
/* statement */
HAWK_NDE_BLK,
HAWK_NDE_IF,
HAWK_NDE_SWITCH,
HAWK_NDE_CASE,
HAWK_NDE_WHILE,
HAWK_NDE_DOWHILE,
HAWK_NDE_FOR,
@ -1903,8 +1905,8 @@ HAWK_EXPORT void hawk_clrfnc (
* if (n >= 0)
* {
* while (n > 0)
* n = sio->in (hawk, HAWK_SIO_CMD_READ, buf, buf_size);
* sio->in (hawk, HAWK_SIO_CMD_CLOSE);
* n = sio->in(hawk, HAWK_SIO_CMD_READ, buf, buf_size);
* sio->in(hawk, HAWK_SIO_CMD_CLOSE);
* }
* \endcode
*
@ -1917,12 +1919,12 @@ HAWK_EXPORT void hawk_clrfnc (
* calling \a sio->out as shown below:
*
* \code
* n = sio->out (hawk, HAWK_SIO_CMD_OPEN);
* n = sio->out(hawk, HAWK_SIO_CMD_OPEN);
* if (n >= 0)
* {
* while (n > 0)
* n = sio->out (hawk, HAWK_SIO_CMD_WRITE, text, text_size);
* sio->out (hawk, HAWK_SIO_CMD_CLOSE);
* n = sio->out(hawk, HAWK_SIO_CMD_WRITE, text, text_size);
* sio->out(hawk, HAWK_SIO_CMD_CLOSE);
* }
* \endcode
*

4
lib/mod-math.c
View File

@ -182,7 +182,7 @@ static hawk_flt_t math_round (hawk_t* hawk, hawk_flt_t x)
hawk_flt_t f, d;
f = math_floor (hawk, x);
f = math_floor(hawk, x);
d = x - f; /* get fraction */
if (d > (hawk_flt_t)0.5)
@ -670,7 +670,7 @@ static void unload (hawk_mod_t* mod, hawk_t* hawk)
modctx_t* modctx;
modctx = (modctx_t*)mod->ctx;
hawk_freemem (hawk, modctx);
hawk_freemem(hawk, modctx);
}
int hawk_mod_math (hawk_mod_t* mod, hawk_t* hawk)

4
lib/mod-sys.c
View File

@ -6394,7 +6394,7 @@ static void unload (hawk_mod_t* mod, hawk_t* hawk)
HAWK_ASSERT (HAWK_RBT_SIZE(mctx->rtxtab) == 0);
hawk_rbt_close (mctx->rtxtab);
hawk_freemem (hawk, mctx);
hawk_freemem(hawk, mctx);
}
int hawk_mod_sys (hawk_mod_t* mod, hawk_t* hawk)
@ -6413,7 +6413,7 @@ int hawk_mod_sys (hawk_mod_t* mod, hawk_t* hawk)
rbt = hawk_rbt_open(hawk_getgem(hawk), 0, 1, 1);
if (HAWK_UNLIKELY(!rbt))
{
hawk_freemem (hawk, mod->ctx);
hawk_freemem(hawk, mod->ctx);
return -1;
}
hawk_rbt_setstyle (rbt, hawk_get_rbt_style(HAWK_RBT_STYLE_INLINE_COPIERS));

3
lib/parse-prv.h
View File

@ -41,7 +41,9 @@ enum hawk_kwid_t
HAWK_KWID_BEGIN,
HAWK_KWID_END,
HAWK_KWID_BREAK,
HAWK_KWID_CASE,
HAWK_KWID_CONTINUE,
HAWK_KWID_DEFAULT,
HAWK_KWID_DELETE,
HAWK_KWID_DO,
HAWK_KWID_ELSE,
@ -58,6 +60,7 @@ enum hawk_kwid_t
HAWK_KWID_PRINT,
HAWK_KWID_PRINTF,
HAWK_KWID_RETURN,
HAWK_KWID_SWITCH,
HAWK_KWID_WHILE
};

1328
lib/parse.c
View File

File diff suppressed because it is too large Load Diff

525
lib/run.c
View File

File diff suppressed because it is too large Load Diff

2
lib/sio.c
View File

@ -156,7 +156,7 @@ int hawk_sio_init (hawk_sio_t* sio, hawk_gem_t* gem, const hawk_ooch_t* path, in
if (hawk_tio_init(&sio->tio.io, gem, topt) <= -1) goto oops03;
/* store the back-reference to sio in the extension area.*/
/*HAWK_ASSERT (hawk, (&sio->tio.io + 1) == &sio->tio.xtn);*/
/*HAWK_ASSERT(hawk, (&sio->tio.io + 1) == &sio->tio.xtn);*/
*(hawk_sio_t**)(&sio->tio.io + 1) = sio;
if (hawk_tio_attachin(&sio->tio.io, file_input, sio->inbuf, HAWK_COUNTOF(sio->inbuf)) <= -1 ||

134
lib/std.c
View File

@ -346,7 +346,7 @@ static void* std_mod_open_checked (hawk_t* hawk, const hawk_mod_spec_t* spec)
{
/* hawk_stdmodstartup() must have failed upon start-up.
* return failure immediately */
hawk_seterrnum (hawk, HAWK_NULL, HAWK_ENOIMPL);
hawk_seterrnum(hawk, HAWK_NULL, HAWK_ENOIMPL);
return HAWK_NULL;
}
@ -388,7 +388,7 @@ void* hawk_stdmodopen (hawk_t* hawk, const hawk_mod_spec_t* spec)
if (lt_dladvise_init(&adv) != 0)
{
hawk_seterrfmt (hawk, HAWK_NULL, HAWK_ESYSERR, HAWK_T("%hs"), lt_dlerror());
hawk_seterrfmt(hawk, HAWK_NULL, HAWK_ESYSERR, HAWK_T("%hs"), lt_dlerror());
return HAWK_NULL;
}
@ -396,7 +396,7 @@ void* hawk_stdmodopen (hawk_t* hawk, const hawk_mod_spec_t* spec)
/*lt_dladvise_resident (&adv); useful for debugging with valgrind */
h = lt_dlopenadvise(modpath, adv);
if (!h) hawk_seterrfmt (hawk, HAWK_NULL, HAWK_ESYSERR, HAWK_T("%hs"), lt_dlerror());
if (!h) hawk_seterrfmt(hawk, HAWK_NULL, HAWK_ESYSERR, HAWK_T("%hs"), lt_dlerror());
lt_dladvise_destroy (&adv);
@ -407,7 +407,7 @@ void* hawk_stdmodopen (hawk_t* hawk, const hawk_mod_spec_t* spec)
{
void* h;
h = lt_dlopen(HAWK_NULL);
if (HAWK_UNLIKELY(!h)) hawk_seterrfmt (hawk, HAWK_NULL, HAWK_ESYSERR, HAWK_T("%hs"), lt_dlerror());
if (HAWK_UNLIKELY(!h)) hawk_seterrfmt(hawk, HAWK_NULL, HAWK_ESYSERR, HAWK_T("%hs"), lt_dlerror());
return h;
}
@ -442,9 +442,9 @@ void* hawk_stdmodopen (hawk_t* hawk, const hawk_mod_spec_t* spec)
if (!modpath) return HAWK_NULL;
h = LoadLibrary(modpath);
if (!h) hawk_seterrnum (hawk, HAWK_NULL, hawk_syserr_to_errnum(GetLastError());
if (!h) hawk_seterrnum(hawk, HAWK_NULL, hawk_syserr_to_errnum(GetLastError());
hawk_freemem (hawk, modpath);
hawk_freemem(hawk, modpath);
HAWK_ASSERT (HAWK_SIZEOF(h) <= HAWK_SIZEOF(void*));
return h;
@ -453,7 +453,7 @@ void* hawk_stdmodopen (hawk_t* hawk, const hawk_mod_spec_t* spec)
{
HMODULE h;
h = GetModuleHandle(HAWK_NULL);
if (!h) hawk_seterrnum (hawk, HAWK_NULL, hawk_syserr_to_errnum(GetLastError());
if (!h) hawk_seterrnum(hawk, HAWK_NULL, hawk_syserr_to_errnum(GetLastError());
return h;
}
@ -496,17 +496,17 @@ void* hawk_stdmodopen (hawk_t* hawk, const hawk_mod_spec_t* spec)
if (rc != NO_ERROR)
{
h = HAWK_NULL;
hawk_seterrnum (hawk, HAWK_NULL, hawk_syserr_to_errnum(rc));
hawk_seterrnum(hawk, HAWK_NULL, hawk_syserr_to_errnum(rc));
}
hawk_freemem (hawk, modpath);
hawk_freemem(hawk, modpath);
HAWK_ASSERT (HAWK_SIZEOF(h) <= HAWK_SIZEOF(void*));
return h;
}
else
{
hawk_seterrnum (hawk, HAWK_NULL, HAWK_ENOIMPL);
hawk_seterrnum(hawk, HAWK_NULL, HAWK_ENOIMPL);
return HAWK_NULL;
}
@ -545,9 +545,9 @@ void* hawk_stdmodopen (hawk_t* hawk, const hawk_mod_spec_t* spec)
if (!modpath) return HAWK_NULL;
h = LoadModule(modpath);
if (!h) hawk_seterrnum (hawk, HAWK_NULL, HAWK_ESYSERR);
if (!h) hawk_seterrnum(hawk, HAWK_NULL, HAWK_ESYSERR);
hawk_freemem (hawk, modpath);
hawk_freemem(hawk, modpath);
HAWK_ASSERT (HAWK_SIZEOF(h) <= HAWK_SIZEOF(void*));
return h;
@ -556,7 +556,7 @@ void* hawk_stdmodopen (hawk_t* hawk, const hawk_mod_spec_t* spec)
{
void* h;
h = GetModuleHandle(HAWK_NULL);
if (!h) hawk_seterrnum (hawk, HAWK_NULL, HAWK_ESYSERR);
if (!h) hawk_seterrnum(hawk, HAWK_NULL, HAWK_ESYSERR);
return h;
}
@ -591,9 +591,9 @@ void* hawk_stdmodopen (hawk_t* hawk, const hawk_mod_spec_t* spec)
if (!modpath) return HAWK_NULL;
h = dlopen(modpath, RTLD_NOW | RTLD_LOCAL);
if (!h) hawk_seterrfmt (hawk, HAWK_NULL, HAWK_ESYSERR, HAWK_T("%hs"), dlerror());
if (!h) hawk_seterrfmt(hawk, HAWK_NULL, HAWK_ESYSERR, HAWK_T("%hs"), dlerror());
hawk_freemem (hawk, modpath);
hawk_freemem(hawk, modpath);
return h;
}
@ -601,11 +601,11 @@ void* hawk_stdmodopen (hawk_t* hawk, const hawk_mod_spec_t* spec)
{
void* h;
h = dlopen(NULL, RTLD_NOW | RTLD_LOCAL);
if (!h) hawk_seterrfmt (hawk, HAWK_NULL, HAWK_ESYSERR, HAWK_T("%hs"), dlerror());
if (!h) hawk_seterrfmt(hawk, HAWK_NULL, HAWK_ESYSERR, HAWK_T("%hs"), dlerror());
return h;
}
#else
hawk_seterrnum (hawk, HAWK_NULL, HAWK_ENOIMPL);
hawk_seterrnum(hawk, HAWK_NULL, HAWK_ENOIMPL);
return HAWK_NULL;
#endif
}
@ -641,11 +641,11 @@ void* hawk_stdmodgetsym (hawk_t* hawk, void* handle, const hawk_ooch_t* name)
#if defined(USE_LTDL)
s = lt_dlsym(handle, mname);
if (!s) hawk_seterrfmt (hawk, HAWK_NULL, HAWK_ESYSERR, HAWK_T("%hs"), lt_dlerror());
if (!s) hawk_seterrfmt(hawk, HAWK_NULL, HAWK_ESYSERR, HAWK_T("%hs"), lt_dlerror());
#elif defined(_WIN32)
s = GetProcAddress((HMODULE)handle, mname);
if (!s) hawk_seterrnum (hawk, HAWK_NULL, hawk_syserr_to_errnum(GetLastError());
if (!s) hawk_seterrnum(hawk, HAWK_NULL, hawk_syserr_to_errnum(GetLastError());
#elif defined(__OS2__)
{
@ -654,17 +654,17 @@ void* hawk_stdmodgetsym (hawk_t* hawk, void* handle, const hawk_ooch_t* name)
if (rc != NO_ERROR)
{
s = HAWK_NULL;
hawk_seterrnum (hawk, HAWK_NULL, hawk_syserr_to_errnum(rc));
hawk_seterrnum(hawk, HAWK_NULL, hawk_syserr_to_errnum(rc));
}
}
#elif defined(__DOS__) && defined(HAWK_ENABLE_DOS_DYNAMIC_MODULE)
s = GetProcAddress(handle, mname);
if (!s) hawk_seterrnum (hawk, HAWK_NULL, HAWK_ESYSERR);
if (!s) hawk_seterrnum(hawk, HAWK_NULL, HAWK_ESYSERR);
#elif defined(USE_DLFCN)
s = dlsym(handle, mname);
if (!s) hawk_seterrfmt (hawk, HAWK_NULL, HAWK_ESYSERR, HAWK_T("%hs"), dlerror());
if (!s) hawk_seterrfmt(hawk, HAWK_NULL, HAWK_ESYSERR, HAWK_T("%hs"), dlerror());
#else
s = HAWK_NULL;
@ -673,7 +673,7 @@ void* hawk_stdmodgetsym (hawk_t* hawk, void* handle, const hawk_ooch_t* name)
#if defined(HAWK_OOCH_IS_BCH)
/* nothing to do */
#else
hawk_freemem (hawk, mname);
hawk_freemem(hawk, mname);
#endif
return s;
@ -910,14 +910,14 @@ static void log_write (hawk_t* hawk, hawk_bitmask_t mask, const hawk_ooch_t* msg
}
#endif
write_log (hawk, logfd, ts, tslen);
write_log(hawk, logfd, ts, tslen);
}
if (logfd == xtn->log.fd && (xtn->log.fd_flag & LOGFD_TTY))
{
if (mask & HAWK_LOG_FATAL) write_log (hawk, logfd, "\x1B[1;31m", 7);
else if (mask & HAWK_LOG_ERROR) write_log (hawk, logfd, "\x1B[1;32m", 7);
else if (mask & HAWK_LOG_WARN) write_log (hawk, logfd, "\x1B[1;33m", 7);
if (mask & HAWK_LOG_FATAL) write_log(hawk, logfd, "\x1B[1;31m", 7);
else if (mask & HAWK_LOG_ERROR) write_log(hawk, logfd, "\x1B[1;32m", 7);
else if (mask & HAWK_LOG_WARN) write_log(hawk, logfd, "\x1B[1;33m", 7);
}
#if defined(HAWK_OOCH_IS_UCH)
@ -956,15 +956,15 @@ static void log_write (hawk_t* hawk, hawk_bitmask_t mask, const hawk_ooch_t* msg
}
}
#else
write_log (hawk, logfd, msg, len);
write_log(hawk, logfd, msg, len);
#endif
if (logfd == xtn->log.fd && (xtn->log.fd_flag & LOGFD_TTY))
{
if (mask & (HAWK_LOG_FATAL | HAWK_LOG_ERROR | HAWK_LOG_WARN)) write_log (hawk, logfd, "\x1B[0m", 4);
if (mask & (HAWK_LOG_FATAL | HAWK_LOG_ERROR | HAWK_LOG_WARN)) write_log(hawk, logfd, "\x1B[0m", 4);
}
flush_log (hawk, logfd);
flush_log(hawk, logfd);
}
/* ----------------------------------------------------------------------- */
@ -1054,7 +1054,7 @@ hawk_t* hawk_openstdwithmmgr (hawk_mmgr_t* mmgr, hawk_oow_t xtnsize, hawk_cmgr_t
xtn->ecb.close = fini_xtn;
xtn->ecb.clear = clear_xtn;
xtn->ecb.ctx = HAWK_NULL;
hawk_pushecb (hawk, &xtn->ecb);
hawk_pushecb(hawk, &xtn->ecb);
return hawk;
@ -1070,7 +1070,7 @@ static hawk_sio_t* open_sio (hawk_t* hawk, const hawk_ooch_t* file, int flags)
if (sio == HAWK_NULL)
{
const hawk_ooch_t* bem = hawk_backuperrmsg(hawk);
hawk_seterrfmt (hawk, HAWK_NULL, HAWK_EOPEN, HAWK_T("unable to open %js - %js"), file, bem);
hawk_seterrfmt(hawk, HAWK_NULL, HAWK_EOPEN, HAWK_T("unable to open %js - %js"), file, bem);
}
return sio;
}
@ -1101,7 +1101,7 @@ static hawk_sio_t* open_sio_std (hawk_t* hawk, hawk_sio_std_t std, int flags)
if (sio == HAWK_NULL)
{
const hawk_ooch_t* bem = hawk_backuperrmsg(hawk);
hawk_seterrfmt (hawk, HAWK_NULL, HAWK_EOPEN, HAWK_T("unable to open %js - %js"), &sio_std_names[std], bem);
hawk_seterrfmt(hawk, HAWK_NULL, HAWK_EOPEN, HAWK_T("unable to open %js - %js"), &sio_std_names[std], bem);
}
return sio;
}
@ -1218,7 +1218,7 @@ static int open_parsestd (hawk_t* hawk, hawk_sio_arg_t* arg, xtn_t* xtn, hawk_oo
return 0;
default:
hawk_seterrnum (hawk, HAWK_NULL, HAWK_EINTERN);
hawk_seterrnum(hawk, HAWK_NULL, HAWK_EINTERN);
return -1;
}
}
@ -1253,7 +1253,7 @@ static int fill_sio_arg_unique_id (hawk_t* hawk, hawk_sio_arg_t* arg, const hawk
if (!bpath) return -1;
x = HAWK_STAT(bpath, &st);
hawk_freemem (hawk, bpath);
hawk_freemem(hawk, bpath);
if (x <= -1) return -1;
#endif
@ -1283,7 +1283,7 @@ int hawk_stdplainfileexists (hawk_t* hawk, const hawk_ooch_t* file)
tmp = hawk_duputobcstr(hawk, file, HAWK_NULL);
if (!tmp) return 0;
n = stat(tmp, &st);
hawk_freemem (hawk, tmp);
hawk_freemem(hawk, tmp);
if (n == -1) return 0;
#else
if (stat(file, &st) == -1) return 0;
@ -1384,7 +1384,7 @@ static hawk_ooi_t sf_in_open (hawk_t* hawk, hawk_sio_arg_t* arg, xtn_t* xtn)
}
xpath = hawk_addsionamewithoochars(hawk, path, hawk_count_oocstr(path));
if (dbuf) hawk_freemem (hawk, dbuf);
if (dbuf) hawk_freemem(hawk, dbuf);
}
else
{
@ -1408,14 +1408,14 @@ static hawk_ooi_t sf_in_open (hawk_t* hawk, hawk_sio_arg_t* arg, xtn_t* xtn)
const hawk_ooch_t* bem;
fail:
bem = hawk_backuperrmsg(hawk);
hawk_seterrfmt (hawk, HAWK_NULL, HAWK_EOPEN, HAWK_T("unable to open %js - %js"), arg->name, bem);
hawk_seterrfmt(hawk, HAWK_NULL, HAWK_EOPEN, HAWK_T("unable to open %js - %js"), arg->name, bem);
return -1;
}
arg->path = xpath;
/* TODO: use the system handle(file descriptor) instead of the path? */
/*syshnd = hawk_sio_gethnd(arg->handle);*/
fill_sio_arg_unique_id (hawk, arg, xpath); /* ignore failure */
fill_sio_arg_unique_id(hawk, arg, xpath); /* ignore failure */
return 0;
}
@ -1478,9 +1478,9 @@ static hawk_ooi_t sf_in_read (hawk_t* hawk, hawk_sio_arg_t* arg, hawk_ooch_t* da
const hawk_uch_t* path;
path = xtn->s.in.x[xtn->s.in.xindex].u.fileu.path;
if (path)
hawk_seterrfmt (hawk, HAWK_NULL, HAWK_EREAD, HAWK_T("unable to read %ls - %js"), path, bem);
hawk_seterrfmt(hawk, HAWK_NULL, HAWK_EREAD, HAWK_T("unable to read %ls - %js"), path, bem);
else
hawk_seterrfmt (hawk, HAWK_NULL, HAWK_EREAD, HAWK_T("unable to read %js - %js"), sio_std_names[HAWK_SIO_STDIN].ptr, bem);
hawk_seterrfmt(hawk, HAWK_NULL, HAWK_EREAD, HAWK_T("unable to read %js - %js"), sio_std_names[HAWK_SIO_STDIN].ptr, bem);
}
break;
@ -1496,9 +1496,9 @@ static hawk_ooi_t sf_in_read (hawk_t* hawk, hawk_sio_arg_t* arg, hawk_ooch_t* da
const hawk_bch_t* path;
path = xtn->s.in.x[xtn->s.in.xindex].u.fileb.path;
if (path)
hawk_seterrfmt (hawk, HAWK_NULL, HAWK_EREAD, HAWK_T("unable to read %hs - %js"), path, bem);
hawk_seterrfmt(hawk, HAWK_NULL, HAWK_EREAD, HAWK_T("unable to read %hs - %js"), path, bem);
else
hawk_seterrfmt (hawk, HAWK_NULL, HAWK_EREAD, HAWK_T("unable to read %js - %js"), sio_std_names[HAWK_SIO_STDIN].ptr, bem);
hawk_seterrfmt(hawk, HAWK_NULL, HAWK_EREAD, HAWK_T("unable to read %js - %js"), sio_std_names[HAWK_SIO_STDIN].ptr, bem);
}
break;
@ -1523,7 +1523,7 @@ static hawk_ooi_t sf_in_read (hawk_t* hawk, hawk_sio_arg_t* arg, hawk_ooch_t* da
wcslen = size;
if ((m = hawk_conv_bchars_to_uchars_with_cmgr(xtn->s.in.u.bcs.ptr, &mbslen, data, &wcslen, hawk_getcmgr(hawk), 0)) <= -1 && m != -2)
{
hawk_seterrnum (hawk, HAWK_NULL, HAWK_EINVAL);
hawk_seterrnum(hawk, HAWK_NULL, HAWK_EINVAL);
n = -1;
}
else
@ -1545,7 +1545,7 @@ static hawk_ooi_t sf_in_read (hawk_t* hawk, hawk_sio_arg_t* arg, hawk_ooch_t* da
mbslen = size;
if ((m = hawk_conv_uchars_to_bchars_with_cmgr(xtn->s.in.u.ucs.ptr, &wcslen, data, &mbslen, hawk_getcmgr(hawk))) <= -1 && m != -2)
{
hawk_seterrnum (hawk, HAWK_NULL, HAWK_EINVAL);
hawk_seterrnum(hawk, HAWK_NULL, HAWK_EINVAL);
n = -1;
}
else
@ -1561,7 +1561,7 @@ static hawk_ooi_t sf_in_read (hawk_t* hawk, hawk_sio_arg_t* arg, hawk_ooch_t* da
default:
/* this should never happen */
hawk_seterrnum (hawk, HAWK_NULL, HAWK_EINTERN);
hawk_seterrnum(hawk, HAWK_NULL, HAWK_EINTERN);
n = -1;
break;
}
@ -1599,7 +1599,7 @@ static hawk_ooi_t sf_in_read (hawk_t* hawk, hawk_sio_arg_t* arg, hawk_ooch_t* da
if (n <= -1)
{
const hawk_ooch_t* bem = hawk_backuperrmsg(hawk);
hawk_seterrfmt (hawk, HAWK_NULL, HAWK_EREAD, HAWK_T("unable to read %js - %js"), arg->name, bem);
hawk_seterrfmt(hawk, HAWK_NULL, HAWK_EREAD, HAWK_T("unable to read %js - %js"), arg->name, bem);
}
return n;
}
@ -1621,7 +1621,7 @@ static hawk_ooi_t sf_in (hawk_t* hawk, hawk_sio_cmd_t cmd, hawk_sio_arg_t* arg,
return sf_in_read(hawk, arg, data, size, xtn);
default:
hawk_seterrnum (hawk, HAWK_NULL, HAWK_EINTERN);
hawk_seterrnum(hawk, HAWK_NULL, HAWK_EINTERN);
return -1;
}
}
@ -1655,7 +1655,7 @@ static hawk_ooi_t sf_out (hawk_t* hawk, hawk_sio_cmd_t cmd, hawk_sio_arg_t* arg,
upath = hawk_dupbtoucstr(hawk, xtn->s.out.x->u.fileb.path, HAWK_NULL, 1);
if (!upath) return -1;
xtn->s.out.u.file.sio = open_sio(hawk, upath, HAWK_SIO_WRITE | HAWK_SIO_CREATE | HAWK_SIO_TRUNCATE | HAWK_SIO_IGNOREECERR);
hawk_freemem (hawk, upath);
hawk_freemem(hawk, upath);
#else
xtn->s.out.u.file.sio = open_sio(hawk, xtn->s.out.x->u.fileb.path, HAWK_SIO_WRITE | HAWK_SIO_CREATE | HAWK_SIO_TRUNCATE | HAWK_SIO_IGNOREECERR);
#endif
@ -1686,7 +1686,7 @@ static hawk_ooi_t sf_out (hawk_t* hawk, hawk_sio_cmd_t cmd, hawk_sio_arg_t* arg,
bpath = hawk_duputobcstr(hawk, xtn->s.out.x->u.fileu.path, HAWK_NULL);
if (!bpath) return -1;
xtn->s.out.u.file.sio = open_sio(hawk, bpath, HAWK_SIO_WRITE | HAWK_SIO_CREATE | HAWK_SIO_TRUNCATE | HAWK_SIO_IGNOREECERR);
hawk_freemem (hawk, bpath);
hawk_freemem(hawk, bpath);
#endif
if (xtn->s.out.u.file.sio == HAWK_NULL) return -1;
}
@ -1757,7 +1757,7 @@ static hawk_ooi_t sf_out (hawk_t* hawk, hawk_sio_cmd_t cmd, hawk_sio_arg_t* arg,
const hawk_ooch_t* bem = hawk_backuperrmsg(hawk);
ioname = xtn->s.out.x->u.file.path;
if (!ioname) ioname = sio_std_names[HAWK_SIO_STDOUT].ptr;
hawk_seterrfmt (hawk, HAWK_NULL, HAWK_EWRITE, HAWK_T("unable to write to %js - %js"), ioname, bem);
hawk_seterrfmt(hawk, HAWK_NULL, HAWK_EWRITE, HAWK_T("unable to write to %js - %js"), ioname, bem);
}
return n;
}
@ -1784,7 +1784,7 @@ static hawk_ooi_t sf_out (hawk_t* hawk, hawk_sio_cmd_t cmd, hawk_sio_arg_t* arg,
if (hawk_becs_setlen(xtn->s.out.u.bcs.buf, orglen + mbslen) == (hawk_oow_t)-1) return -1;
wcslen = size;
hawk_convutobchars (hawk, data, &wcslen, HAWK_BECS_CPTR(xtn->s.out.u.bcs.buf, orglen), &mbslen);
hawk_convutobchars(hawk, data, &wcslen, HAWK_BECS_CPTR(xtn->s.out.u.bcs.buf, orglen), &mbslen);
size = wcslen;
return size;
@ -1805,7 +1805,7 @@ static hawk_ooi_t sf_out (hawk_t* hawk, hawk_sio_cmd_t cmd, hawk_sio_arg_t* arg,
if (hawk_uecs_setlen(xtn->s.out.u.ucs.buf, orglen + wcslen) == (hawk_oow_t)-1) return -1;
mbslen = size;
hawk_convbtouchars (hawk, data, &mbslen, HAWK_UECS_CPTR(xtn->s.out.u.ucs.buf, orglen), &wcslen, 0);
hawk_convbtouchars(hawk, data, &mbslen, HAWK_UECS_CPTR(xtn->s.out.u.ucs.buf, orglen), &wcslen, 0);
size = mbslen;
return size;
@ -1827,7 +1827,7 @@ static hawk_ooi_t sf_out (hawk_t* hawk, hawk_sio_cmd_t cmd, hawk_sio_arg_t* arg,
}
internal_error:
hawk_seterrnum (hawk, HAWK_NULL, HAWK_EINTERN);
hawk_seterrnum(hawk, HAWK_NULL, HAWK_EINTERN);
return -1;
}
@ -1846,7 +1846,7 @@ int hawk_parsestd (hawk_t* hawk, hawk_parsestd_t in[], hawk_parsestd_t* out)
{
/* the input is a must. at least 1 file or 1 string
* must be specified */
hawk_seterrnum (hawk, HAWK_NULL, HAWK_EINVAL);
hawk_seterrnum(hawk, HAWK_NULL, HAWK_EINVAL);
return -1;
}
@ -1863,7 +1863,7 @@ int hawk_parsestd (hawk_t* hawk, hawk_parsestd_t in[], hawk_parsestd_t* out)
out->type != HAWK_PARSESTD_BCS &&
out->type != HAWK_PARSESTD_UCS)
{
hawk_seterrnum (hawk, HAWK_NULL, HAWK_EINVAL);
hawk_seterrnum(hawk, HAWK_NULL, HAWK_EINVAL);
return -1;
}
sio.out = sf_out;
@ -3125,18 +3125,18 @@ done:
{
if (xocf)
{
for (i = 0; xocf[i]; i++) hawk_freemem (hawk, xocf[i]);
hawk_freemem (hawk, xocf);
for (i = 0; xocf[i]; i++) hawk_freemem(hawk, xocf[i]);
hawk_freemem(hawk, xocf);
}
if (xicf)
{
for (i = 0; xicf[i]; i++) hawk_freemem (hawk, xicf[i]);
hawk_freemem (hawk, xicf);
for (i = 0; xicf[i]; i++) hawk_freemem(hawk, xicf[i]);
hawk_freemem(hawk, xicf);
}
}
#if defined(HAWK_OOCH_IS_UCH)
hawk_freemem (hawk, xid);
hawk_freemem(hawk, xid);
#endif
return rtx;
@ -3206,18 +3206,18 @@ done:
{
if (xocf)
{
for (i = 0; xocf[i]; i++) hawk_freemem (hawk, xocf[i]);
hawk_freemem (hawk, xocf);
for (i = 0; xocf[i]; i++) hawk_freemem(hawk, xocf[i]);
hawk_freemem(hawk, xocf);
}
if (xicf)
{
for (i = 0; xicf[i]; i++) hawk_freemem (hawk, xicf[i]);
hawk_freemem (hawk, xicf);
for (i = 0; xicf[i]; i++) hawk_freemem(hawk, xicf[i]);
hawk_freemem(hawk, xicf);
}
}
#if defined(HAWK_OOCH_IS_BCH)
hawk_freemem (hawk, xid);
hawk_freemem(hawk, xid);
#endif
return rtx;
@ -3532,7 +3532,7 @@ static int add_functions (hawk_t* hawk)
for (i = 0; i < HAWK_COUNTOF(fnctab); i++)
{
if (hawk_addfnc (hawk, fnctab[i].name, &fnctab[i].spec) == HAWK_NULL) return -1;
if (hawk_addfnc(hawk, fnctab[i].name, &fnctab[i].spec) == HAWK_NULL) return -1;
}
return 0;

19
lib/tree-prv.h
View File

@ -75,6 +75,8 @@ typedef struct hawk_nde_fncall_t hawk_nde_fncall_t;
typedef struct hawk_nde_getline_t hawk_nde_getline_t;
typedef struct hawk_nde_if_t hawk_nde_if_t;
typedef struct hawk_nde_switch_t hawk_nde_switch_t;
typedef struct hawk_nde_case_t hawk_nde_case_t;
typedef struct hawk_nde_while_t hawk_nde_while_t;
typedef struct hawk_nde_for_t hawk_nde_for_t;
typedef struct hawk_nde_forin_t hawk_nde_forin_t;
@ -280,6 +282,23 @@ struct hawk_nde_if_t
hawk_nde_t* else_part; /* optional */
};
/* HAWK_NDE_SWITCH */
struct hawk_nde_switch_t
{
HAWK_NDE_HDR;
hawk_nde_t* test;
hawk_nde_t* case_part; /* optional */
hawk_nde_t* default_part; /* optional */
};
/* HAWK_NDE_CASE */
struct hawk_nde_case_t
{
HAWK_NDE_HDR;
hawk_nde_t* val;
hawk_nde_t* action;
};
/* HAWK_NDE_WHILE, HAWK_NDE_DOWHILE */
struct hawk_nde_while_t
{

884
lib/tree.c
View File

File diff suppressed because it is too large Load Diff

12
lib/utf8.c
View File

@ -74,8 +74,8 @@ static HAWK_INLINE __utf8_t* get_utf8_slot (hawk_uch_t uc)
{
__utf8_t* cur, * end;
/*HAWK_ASSERT (hawk, HAWK_SIZEOF(hawk_bch_t) == 1);
HAWK_ASSERT (hawk, HAWK_SIZEOF(hawk_uch_t) >= 2);*/
/*HAWK_ASSERT(hawk, HAWK_SIZEOF(hawk_bch_t) == 1);
HAWK_ASSERT(hawk, HAWK_SIZEOF(hawk_uch_t) >= 2);*/
end = utf8_table + HAWK_COUNTOF(utf8_table);
cur = utf8_table;
@ -120,10 +120,10 @@ hawk_oow_t hawk_utf8_to_uc (const hawk_bch_t* utf8, hawk_oow_t size, hawk_uch_t*
{
__utf8_t* cur, * end;
/*HAWK_ASSERT (hawk, utf8 != HAWK_NULL);
HAWK_ASSERT (hawk, size > 0);
HAWK_ASSERT (hawk, HAWK_SIZEOF(hawk_bch_t) == 1);
HAWK_ASSERT (hawk, HAWK_SIZEOF(hawk_uch_t) >= 2);*/
/*HAWK_ASSERT(hawk, utf8 != HAWK_NULL);
HAWK_ASSERT(hawk, size > 0);
HAWK_ASSERT(hawk, HAWK_SIZEOF(hawk_bch_t) == 1);
HAWK_ASSERT(hawk, HAWK_SIZEOF(hawk_uch_t) >= 2);*/
end = utf8_table + HAWK_COUNTOF(utf8_table);
cur = utf8_table;

4
lib/utl.c
View File

@ -354,7 +354,7 @@ int hawk_conv_uchars_to_bchars_with_cmgr (const hawk_uch_t* ucs, hawk_oow_t* ucs
}
/* it assumes that bcsbuf is large enough to hold a character */
/*HAWK_ASSERT (hawk, n <= HAWK_COUNTOF(bcsbuf));*/
/*HAWK_ASSERT(hawk, n <= HAWK_COUNTOF(bcsbuf));*/
p++; mlen += n;
}
@ -435,7 +435,7 @@ int hawk_conv_ucstr_to_bcstr_with_cmgr (
}
/* it assumes that bcs is large enough to hold a character */
/*HAWK_ASSERT (hawk, n <= HAWK_COUNTOF(bcs));*/
/*HAWK_ASSERT(hawk, n <= HAWK_COUNTOF(bcs));*/
p++; mlen += n;
}

2
lib/val.c
View File

@ -2778,7 +2778,7 @@ int hawk_rtx_valtonum (hawk_rtx_t* rtx, const hawk_val_t* v, hawk_int_t* l, hawk
default:
invalid:
#if defined(DEBUG_VAL)
hawk_logfmt (hawk, HAWK_T(">>WRONG VALUE TYPE [%d] in hawk_rtx_valtonum()\n"), v->type);
hawk_logfmt(hawk, HAWK_T(">>WRONG VALUE TYPE [%d] in hawk_rtx_valtonum()\n"), v->type);
#endif
hawk_rtx_seterrnum (rtx, HAWK_NULL, HAWK_EVALTONUM);
return -1; /* error */

108
t/h-002.hawk
View File

@ -665,6 +665,29 @@ function main()
f = test10
tap_ensure (f(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), 55, @SCRIPTNAME, @SCRIPTLINE);
}
{
tap_ensure(test12(2,5), -3, @SCRIPTNAME, @SCRIPTLINE);
tap_ensure(test12(3,5), 8, @SCRIPTNAME, @SCRIPTLINE);
tap_ensure(test13(1), 1, @SCRIPTNAME, @SCRIPTLINE);
tap_ensure(test13(2), 2, @SCRIPTNAME, @SCRIPTLINE);
tap_ensure(test13(3), 3, @SCRIPTNAME, @SCRIPTLINE);
tap_ensure(test13(4), 4, @SCRIPTNAME, @SCRIPTLINE);
tap_ensure(test13(5), 5, @SCRIPTNAME, @SCRIPTLINE);
tap_ensure(test13(6), 1005, @SCRIPTNAME, @SCRIPTLINE);
tap_ensure(test14("hello"), "world", @SCRIPTNAME, @SCRIPTLINE);
tap_ensure(test14("donkey"), "rankey", @SCRIPTNAME, @SCRIPTLINE);
tap_ensure(test14("speed"), "unknown", @SCRIPTNAME, @SCRIPTLINE);
tap_ensure(test15("hello"), "world", @SCRIPTNAME, @SCRIPTLINE);
tap_ensure(test15("donkey"), "[rankey012]", @SCRIPTNAME, @SCRIPTLINE);
tap_ensure(test15("skunk"), "stinks", @SCRIPTNAME, @SCRIPTLINE);
tap_ensure(test15("speed"), "unknown", @SCRIPTNAME, @SCRIPTLINE);
}
tap_end ();
}
@ -709,3 +732,88 @@ function test10(...) {
function test11(...) {
return (3 in @argv);
}
function test12(...) {
switch(@argv[0] * @argv[1]) {
case 10:
return @argv[0] - @argv[1];
default:
return @argv[0] + @argv[1];
}
}
function test13(x) {
@local a;
a = 0;
switch(x) {
default:
a = 1000;
case 5:
a++;
case 4:
a++;
case 3:
a++;
case 2:
a++;
case 1:
a++;
break;
}
return a;
}
function test14(x) {
switch(x) {
case "hello":
return "world";
case "donkey":
return "rankey";
default:
return "unknown";
}
}
function test15(x) {
@local a, i;
switch(x) {
case "hello":
a = "world";
break;
case "donkey":
{
@local l;
a = "rankey";
l = length(a);
for (i = 0; i < l; i++) {
if (i == 3) break;
a = sprintf("%s%d", a, i);
}
a = sprintf("[%s]", a);
break;
}
default:
if (x == "skunk") a = "stinks";
else a = "unknown";
break;
}
return a;
}