qse/ase/lib/awk/err.c
2008-06-27 04:46:39 +00:00

492 lines
13 KiB
C

/*
* $Id: err.c 229 2008-06-26 10:46:39Z baconevi $
*
* {License}
*/
#include "awk_i.h"
#include <stdarg.h>
static const ase_char_t* __geterrstr (int errnum)
{
static const ase_char_t* errstr[] =
{
ASE_T("no error"),
ASE_T("custom error"),
ASE_T("invalid parameter or data"),
ASE_T("out of memory"),
ASE_T("not supported"),
ASE_T("operation not allowed"),
ASE_T("no such device"),
ASE_T("no space left on device"),
ASE_T("too many open files"),
ASE_T("too many links"),
ASE_T("resource temporarily unavailable"),
ASE_T("'%.*s' not existing"),
ASE_T("'%.*s' already exists"),
ASE_T("file or data too big"),
ASE_T("system too busy"),
ASE_T("is a directory"),
ASE_T("i/o error"),
ASE_T("cannot open '%.*s'"),
ASE_T("cannot read '%.*s'"),
ASE_T("cannot write '%.*s'"),
ASE_T("cannot close '%.*s'"),
ASE_T("internal error that should never have happened"),
ASE_T("general run-time error"),
ASE_T("block nested too deeply"),
ASE_T("expressio nested too deeply"),
ASE_T("cannot open source input"),
ASE_T("cannot close source input"),
ASE_T("cannot read source input"),
ASE_T("cannot open source output"),
ASE_T("cannot close source output"),
ASE_T("cannot write source output"),
ASE_T("invalid character '%.*s'"),
ASE_T("invalid digit '%.*s'"),
ASE_T("cannot unget character"),
ASE_T("unexpected end of source"),
ASE_T("a comment not closed properly"),
ASE_T("a string not closed with a quote"),
ASE_T("unexpected end of a regular expression"),
ASE_T("a left brace expected in place of '%.*s'"),
ASE_T("a left parenthesis expected in place of '%.*s'"),
ASE_T("a right parenthesis expected in place of '%.*s'"),
ASE_T("a right bracket expected in place of '%.*s'"),
ASE_T("a comma expected in place of '%.*s'"),
ASE_T("a semicolon expected in place of '%.*s'"),
ASE_T("a colon expected in place of '%.*s'"),
ASE_T("statement not ending with a semicolon"),
ASE_T("'in' expected in place of '%.*s'"),
ASE_T("right-hand side of the 'in' operator not a variable"),
ASE_T("invalid expression"),
ASE_T("keyword 'function' expected in place of '%.*s'"),
ASE_T("keyword 'while' expected in place of '%.*s'"),
ASE_T("invalid assignment statement"),
ASE_T("an identifier expected in place of '%.*s'"),
ASE_T("'%.*s' not a valid function name"),
ASE_T("BEGIN not followed by a left bracket on the same line"),
ASE_T("END not followed by a left bracket on the same line"),
ASE_T("duplicate BEGIN"),
ASE_T("duplicate END"),
ASE_T("intrinsic function '%.*s' redefined"),
ASE_T("function '%.*s' redefined"),
ASE_T("global variable '%.*s' redefined"),
ASE_T("parameter '%.*s' redefined"),
ASE_T("variable '%.*s' redefined"),
ASE_T("duplicate parameter name '%.*s'"),
ASE_T("duplicate global variable '%.*s'"),
ASE_T("duplicate local variable '%.*s'"),
ASE_T("'%.*s' not a valid parameter name"),
ASE_T("'%.*s' not a valid variable name"),
ASE_T("undefined identifier '%.*s'"),
ASE_T("l-value required"),
ASE_T("too many global variables"),
ASE_T("too many local variables"),
ASE_T("too many parameters"),
ASE_T("delete statement not followed by a normal variable"),
ASE_T("reset statement not followed by a normal variable"),
ASE_T("break statement outside a loop"),
ASE_T("continue statement outside a loop"),
ASE_T("next statement illegal in the BEGIN block"),
ASE_T("next statement illegal in the END block"),
ASE_T("nextfile statement illegal in the BEGIN block"),
ASE_T("nextfile statement illegal in the END block"),
ASE_T("printf not followed by any arguments"),
ASE_T("both prefix and postfix increment/decrement operator present"),
ASE_T("coprocess not supported by getline"),
ASE_T("divide by zero"),
ASE_T("invalid operand"),
ASE_T("wrong position index"),
ASE_T("too few arguments"),
ASE_T("too many arguments"),
ASE_T("function '%.*s' not found"),
ASE_T("variable not indexable"),
ASE_T("variable '%.*s' not deletable"),
ASE_T("value not a map"),
ASE_T("right-hand side of the 'in' operator not a map"),
ASE_T("right-hand side of the 'in' operator not a map nor nil"),
ASE_T("value not referenceable"),
ASE_T("value not assignable"),
ASE_T("an indexed value cannot be assigned a map"),
ASE_T("a positional value cannot be assigned a map"),
ASE_T("map '%.*s' not assignable with a scalar"),
ASE_T("cannot change a scalar value to a map"),
ASE_T("a map is not allowed"),
ASE_T("invalid value type"),
ASE_T("delete statement called with a wrong target"),
ASE_T("reset statement called with a wrong target"),
ASE_T("next statement called from the BEGIN block"),
ASE_T("next statement called from the END block"),
ASE_T("nextfile statement called from the BEGIN block"),
ASE_T("nextfile statement called from the END block"),
ASE_T("wrong implementation of intrinsic function handler"),
ASE_T("intrinsic function handler returned an error"),
ASE_T("wrong implementation of user-defined io handler"),
ASE_T("no such io name found"),
ASE_T("i/o handler returned an error"),
ASE_T("i/o name empty"),
ASE_T("i/o name containing a null character"),
ASE_T("not sufficient arguments to formatting sequence"),
ASE_T("recursion detected in format conversion"),
ASE_T("invalid character in CONVFMT"),
ASE_T("invalid character in OFMT"),
ASE_T("recursion too deep in the regular expression"),
ASE_T("a right parenthesis expected in the regular expression"),
ASE_T("a right bracket expected in the regular expression"),
ASE_T("a right brace expected in the regular expression"),
ASE_T("unbalanced parenthesis in the regular expression"),
ASE_T("a colon 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 < ASE_COUNTOF(errstr))
{
return errstr[errnum];
}
return ASE_T("unknown error");
}
const ase_char_t* ase_awk_geterrstr (ase_awk_t* awk, int num)
{
if (awk != ASE_NULL &&
awk->errstr[num] != ASE_NULL) return awk->errstr[num];
return __geterrstr (num);
}
int ase_awk_seterrstr (ase_awk_t* awk, int num, const ase_char_t* str)
{
ase_char_t* dup;
if (str == ASE_NULL) dup = ASE_NULL;
else
{
dup = ase_strdup (str, &awk->prmfns.mmgr);
if (dup == ASE_NULL) return -1;
}
if (awk->errstr[num] != ASE_NULL)
ASE_AWK_FREE (awk, awk->errstr[num]);
else awk->errstr[num] = dup;
return 0;
}
int ase_awk_geterrnum (ase_awk_t* awk)
{
return awk->errnum;
}
ase_size_t ase_awk_geterrlin (ase_awk_t* awk)
{
return awk->errlin;
}
const ase_char_t* ase_awk_geterrmsg (ase_awk_t* awk)
{
if (awk->errmsg[0] == ASE_T('\0'))
return ase_awk_geterrstr (awk, awk->errnum);
return awk->errmsg;
}
void ase_awk_geterror (
ase_awk_t* awk, int* errnum,
ase_size_t* errlin, const ase_char_t** errmsg)
{
if (errnum != ASE_NULL) *errnum = awk->errnum;
if (errlin != ASE_NULL) *errlin = awk->errlin;
if (errmsg != ASE_NULL)
{
if (awk->errmsg[0] == ASE_T('\0'))
*errmsg = ase_awk_geterrstr (awk, awk->errnum);
else
*errmsg = awk->errmsg;
}
}
void ase_awk_seterrnum (ase_awk_t* awk, int errnum)
{
awk->errnum = errnum;
awk->errlin = 0;
awk->errmsg[0] = ASE_T('\0');
}
void ase_awk_seterrmsg (ase_awk_t* awk,
int errnum, ase_size_t errlin, const ase_char_t* errmsg)
{
awk->errnum = errnum;
awk->errlin = errlin;
ase_strxcpy (awk->errmsg, ASE_COUNTOF(awk->errmsg), errmsg);
}
void ase_awk_seterror (
ase_awk_t* awk, int errnum, ase_size_t errlin,
const ase_cstr_t* errarg, ase_size_t argcnt)
{
const ase_char_t* errfmt;
ase_size_t fmtlen;
ASE_ASSERT (argcnt <= 5);
awk->errnum = errnum;
awk->errlin = errlin;
errfmt = ase_awk_geterrstr (awk, errnum);
fmtlen = ase_strlen(errfmt);
switch (argcnt)
{
case 0:
awk->prmfns.misc.sprintf (
awk->prmfns.misc.custom_data,
awk->errmsg,
ASE_COUNTOF(awk->errmsg),
errfmt);
return;
case 1:
{
ase_char_t tmp[ASE_COUNTOF(awk->errmsg)];
ase_size_t len, tl;
if (fmtlen < ASE_COUNTOF(awk->errmsg) &&
errarg[0].len + fmtlen >= ASE_COUNTOF(awk->errmsg))
{
len = ASE_COUNTOF(awk->errmsg) - fmtlen - 3 - 1;
tl = ase_strxncpy (tmp, ASE_COUNTOF(tmp), errarg[0].ptr, len);
tmp[tl] = ASE_T('.');
tmp[tl+1] = ASE_T('.');
tmp[tl+2] = ASE_T('.');
len += 3;
}
else
{
len = errarg[0].len;
ase_strxncpy (tmp, ASE_COUNTOF(tmp), errarg[0].ptr, len);
}
awk->prmfns.misc.sprintf (
awk->prmfns.misc.custom_data,
awk->errmsg,
ASE_COUNTOF(awk->errmsg),
errfmt, (int)len, tmp);
return;
}
case 2:
awk->prmfns.misc.sprintf (
awk->prmfns.misc.custom_data,
awk->errmsg,
ASE_COUNTOF(awk->errmsg),
errfmt,
(int)errarg[0].len, errarg[0].ptr,
(int)errarg[1].len, errarg[1].ptr);
return;
case 3:
awk->prmfns.misc.sprintf (
awk->prmfns.misc.custom_data,
awk->errmsg,
ASE_COUNTOF(awk->errmsg),
errfmt,
(int)errarg[0].len, errarg[0].ptr,
(int)errarg[1].len, errarg[1].ptr,
(int)errarg[2].len, errarg[2].ptr);
return;
case 4:
awk->prmfns.misc.sprintf (
awk->prmfns.misc.custom_data,
awk->errmsg,
ASE_COUNTOF(awk->errmsg),
errfmt,
(int)errarg[0].len, errarg[0].ptr,
(int)errarg[1].len, errarg[1].ptr,
(int)errarg[2].len, errarg[2].ptr,
(int)errarg[3].len, errarg[3].ptr);
return;
case 5:
awk->prmfns.misc.sprintf (
awk->prmfns.misc.custom_data,
awk->errmsg,
ASE_COUNTOF(awk->errmsg),
errfmt,
(int)errarg[0].len, errarg[0].ptr,
(int)errarg[1].len, errarg[1].ptr,
(int)errarg[2].len, errarg[2].ptr,
(int)errarg[3].len, errarg[3].ptr,
(int)errarg[4].len, errarg[4].ptr);
return;
}
}
int ase_awk_getrunerrnum (ase_awk_run_t* run)
{
return run->errnum;
}
ase_size_t ase_awk_getrunerrlin (ase_awk_run_t* run)
{
return run->errlin;
}
const ase_char_t* ase_awk_getrunerrmsg (ase_awk_run_t* run)
{
if (run->errmsg[0] == ASE_T('\0'))
return ase_awk_geterrstr (run->awk, run->errnum);
return run->errmsg;
}
void ase_awk_setrunerrnum (ase_awk_run_t* run, int errnum)
{
run->errnum = errnum;
run->errlin = 0;
run->errmsg[0] = ASE_T('\0');
}
void ase_awk_setrunerrmsg (ase_awk_run_t* run,
int errnum, ase_size_t errlin, const ase_char_t* errmsg)
{
run->errnum = errnum;
run->errlin = errlin;
ase_strxcpy (run->errmsg, ASE_COUNTOF(run->errmsg), errmsg);
}
void ase_awk_getrunerror (
ase_awk_run_t* run, int* errnum,
ase_size_t* errlin, const ase_char_t** errmsg)
{
if (errnum != ASE_NULL) *errnum = run->errnum;
if (errlin != ASE_NULL) *errlin = run->errlin;
if (errmsg != ASE_NULL)
{
if (run->errmsg[0] == ASE_T('\0'))
*errmsg = ase_awk_geterrstr (run->awk, run->errnum);
else
*errmsg = run->errmsg;
}
}
void ase_awk_setrunerror (
ase_awk_run_t* run, int errnum, ase_size_t errlin,
const ase_cstr_t* errarg, ase_size_t argcnt)
{
const ase_char_t* errfmt;
ase_size_t fmtlen;
ASE_ASSERT (argcnt <= 5);
run->errnum = errnum;
run->errlin = errlin;
errfmt = ase_awk_geterrstr (run->awk, errnum);
fmtlen = ase_strlen (errfmt);
switch (argcnt)
{
case 0:
/* TODO: convert % to %% if the original % is not
* the first % of the %% sequence */
run->awk->prmfns.misc.sprintf (
run->awk->prmfns.misc.custom_data,
run->errmsg,
ASE_COUNTOF(run->errmsg),
errfmt);
return;
case 1:
{
/* TODO: what if the argument contains a null character?
* handle the case more gracefully than now... */
ase_char_t tmp[ASE_COUNTOF(run->errmsg)];
ase_size_t len, tl;
if (fmtlen < ASE_COUNTOF(run->errmsg) &&
errarg[0].len + fmtlen >= ASE_COUNTOF(run->errmsg))
{
len = ASE_COUNTOF(run->errmsg) - fmtlen - 3 - 1;
tl = ase_strxncpy (tmp, ASE_COUNTOF(tmp), errarg[0].ptr, len);
tmp[tl] = ASE_T('.');
tmp[tl+1] = ASE_T('.');
tmp[tl+2] = ASE_T('.');
len += 3;
}
else
{
len = errarg[0].len;
ase_strxncpy (tmp, ASE_COUNTOF(tmp), errarg[0].ptr, len);
}
run->awk->prmfns.misc.sprintf (
run->awk->prmfns.misc.custom_data,
run->errmsg,
ASE_COUNTOF(run->errmsg),
errfmt, len, tmp);
return;
}
case 2:
run->awk->prmfns.misc.sprintf (
run->awk->prmfns.misc.custom_data,
run->errmsg,
ASE_COUNTOF(run->errmsg),
errfmt,
errarg[0].len, errarg[0].ptr,
errarg[1].len, errarg[1].ptr);
return;
case 3:
run->awk->prmfns.misc.sprintf (
run->awk->prmfns.misc.custom_data,
run->errmsg,
ASE_COUNTOF(run->errmsg),
errfmt,
errarg[0].len, errarg[0].ptr,
errarg[1].len, errarg[1].ptr,
errarg[2].len, errarg[2].ptr);
return;
case 4:
run->awk->prmfns.misc.sprintf (
run->awk->prmfns.misc.custom_data,
run->errmsg,
ASE_COUNTOF(run->errmsg),
errfmt,
errarg[0].len, errarg[0].ptr,
errarg[1].len, errarg[1].ptr,
errarg[2].len, errarg[2].ptr,
errarg[3].len, errarg[3].ptr);
return;
case 5:
run->awk->prmfns.misc.sprintf (
run->awk->prmfns.misc.custom_data,
run->errmsg,
ASE_COUNTOF(run->errmsg),
errfmt,
errarg[0].len, errarg[0].ptr,
errarg[1].len, errarg[1].ptr,
errarg[2].len, errarg[2].ptr,
errarg[3].len, errarg[3].ptr,
errarg[4].len, errarg[4].ptr);
return;
}
}