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

Recovered from cvs revision 2007-05-20 16:06:00

Browse Source
This commit is contained in:
hyung-hwan 2007-05-21 01:22:00 +00:00
parent c29572a781
commit f429b0faea
10 changed files with 483 additions and 161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

253
ase/awk/Awk.cpp
View File

@ -1,5 +1,5 @@
/* /*
* $Id: Awk.cpp,v 1.31 2007/05/17 15:02:54 bacon Exp $ * $Id: Awk.cpp,v 1.35 2007/05/19 16:45:27 bacon Exp $
*/ */
#include <ase/awk/Awk.hpp> #include <ase/awk/Awk.hpp>
@ -56,16 +56,6 @@ namespace ASE
extio->handle = handle; extio->handle = handle;
} }
Awk::run_t* Awk::Extio::getRun () const
{
return extio->run;
}
Awk::awk_t* Awk::Extio::getAwk () const
{
return ase_awk_getrunawk(extio->run);
}
////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////
// Awk::Pipe // Awk::Pipe
////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////
@ -281,18 +271,6 @@ namespace ASE
} }
} }
Awk::run_t* Awk::Argument::getRun () const
{
ASE_ASSERT (this->run != ASE_NULL);
return this->run;
}
Awk::awk_t* Awk::Argument::getAwk () const
{
ASE_ASSERT (this->run != ASE_NULL);
return ase_awk_getrunawk (this->run);
}
////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////
// Awk::Return // Awk::Return
////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////
@ -327,16 +305,6 @@ namespace ASE
return ASE_NULL; return ASE_NULL;
} }
Awk::run_t* Awk::Return::getRun () const
{
return this->run;
}
Awk::awk_t* Awk::Return::getAwk () const
{
return ase_awk_getrunawk (this->run);
}
int Awk::Return::set (long_t v) int Awk::Return::set (long_t v)
{ {
clear (); clear ();
@ -391,45 +359,107 @@ namespace ASE
// Awk::Run // Awk::Run
////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////
Awk::Run::Run (run_t* run): run (run) Awk::Run::Run (Awk* awk):
awk (awk), run (ASE_NULL), callbackFailed (false)
{ {
} }
int Awk::Run::stop ()
{
ASE_ASSERT (this->run != ASE_NULL);
return ase_awk_stop (this->run);
}
Awk::ErrorCode Awk::Run::getErrorCode () const
{
ASE_ASSERT (this->run != ASE_NULL);
return (ErrorCode)ase_awk_getrunerrnum (this->run);
}
Awk::size_t Awk::Run::getErrorLine () const
{
ASE_ASSERT (this->run != ASE_NULL);
return ase_awk_getrunerrlin (this->run);
}
const Awk::char_t* Awk::Run::getErrorMessage () const
{
ASE_ASSERT (this->run != ASE_NULL);
return ase_awk_getrunerrmsg (this->run);
}
////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////
// Awk // Awk
////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////
Awk::Awk (): awk (ASE_NULL), functionMap (ASE_NULL), Awk::Awk (): awk (ASE_NULL), functionMap (ASE_NULL),
sourceIn (Source::READ), sourceOut (Source::WRITE), sourceIn (Source::READ), sourceOut (Source::WRITE),
errnum (E_NOERR), errlin (0) errnum (E_NOERR), errlin (0), runCallback (false)
{ {
this->errmsg[0] = ASE_T('\0');
} }
Awk::~Awk () Awk::~Awk ()
{ {
} }
Awk::ErrorCode Awk::getErrorCode () Awk::ErrorCode Awk::getErrorCode () const
{ {
return this->errnum; return this->errnum;
} }
Awk::size_t Awk::getErrorLine () Awk::size_t Awk::getErrorLine () const
{ {
return this->errlin; return this->errlin;
} }
void Awk::setError (ErrorCode code, size_t line) const Awk::char_t* Awk::getErrorMessage () const
{
return this->errmsg;
}
void Awk::setError (
ErrorCode code, size_t line, const char_t* arg, size_t len)
{
if (awk != ASE_NULL)
{
ase_cstr_t x = { arg, len };
ase_awk_seterror (awk, code, line, &x, 1);
retrieveError ();
}
else
{ {
this->errnum = code; this->errnum = code;
this->errlin = line; this->errlin = line;
const char_t* es = ase_awk_geterrstr (ASE_NULL, code);
ase_strxcpy (this->errmsg, ASE_COUNTOF(this->errmsg), es);
}
} }
void Awk::clearError () void Awk::clearError ()
{ {
this->errnum = E_NOERR; this->errnum = E_NOERR;
this->errlin = 0; this->errlin = 0;
this->errmsg[0] = ASE_T('\0');
}
void Awk::retrieveError ()
{
if (this->awk == ASE_NULL)
{
clearError ();
}
else
{
int num;
const char_t* msg;
ase_awk_geterror (this->awk, &num, &this->errlin, &msg);
this->errnum = (ErrorCode)num;
ase_strxcpy (this->errmsg, ASE_COUNTOF(this->errmsg), msg);
}
} }
int Awk::open () int Awk::open ()
@ -481,6 +511,22 @@ namespace ASE
return -1; return -1;
} }
int opt =
OPT_IMPLICIT |
OPT_EXPLICIT |
OPT_UNIQUEFN |
OPT_IDIV |
OPT_SHADING |
OPT_SHIFT |
OPT_EXTIO |
OPT_BLOCKLESS |
OPT_STRBASEONE |
OPT_STRIPSPACES |
OPT_NEXTOFILE |
OPT_ARGSTOMAIN;
ase_awk_setoption (awk, opt);
runCallback = false;
return 0; return 0;
} }
@ -499,6 +545,19 @@ namespace ASE
} }
clearError (); clearError ();
runCallback = false;
}
void Awk::setOption (int opt)
{
ASE_ASSERT (awk != ASE_NULL);
ase_awk_setoption (awk, opt);
}
int Awk::getOption () const
{
ASE_ASSERT (awk != ASE_NULL);
return ase_awk_getoption (awk);
} }
int Awk::parse () int Awk::parse ()
@ -511,7 +570,9 @@ namespace ASE
srcios.out = sourceWriter; srcios.out = sourceWriter;
srcios.custom_data = this; srcios.custom_data = this;
return ase_awk_parse (awk, &srcios); int n = ase_awk_parse (awk, &srcios);
if (n == -1) retrieveError ();
return n;
} }
int Awk::run (const char_t* main, const char_t** args, size_t nargs) int Awk::run (const char_t* main, const char_t** args, size_t nargs)
@ -522,6 +583,7 @@ namespace ASE
ase_awk_runios_t runios; ase_awk_runios_t runios;
ase_awk_runcbs_t runcbs; ase_awk_runcbs_t runcbs;
ase_awk_runarg_t* runarg = ASE_NULL; ase_awk_runarg_t* runarg = ASE_NULL;
Run emptyRun (this);
runios.pipe = pipeHandler; runios.pipe = pipeHandler;
runios.coproc = ASE_NULL; runios.coproc = ASE_NULL;
@ -529,11 +591,14 @@ namespace ASE
runios.console = consoleHandler; runios.console = consoleHandler;
runios.custom_data = this; runios.custom_data = this;
if (runCallback)
{
runcbs.on_start = onRunStart; runcbs.on_start = onRunStart;
runcbs.on_end = onRunEnd; runcbs.on_end = onRunEnd;
runcbs.on_return = ASE_NULL; runcbs.on_return = onRunReturn;
runcbs.on_statement = ASE_NULL; runcbs.on_statement = onRunStatement;
runcbs.custom_data = this; runcbs.custom_data = &emptyRun;
}
if (nargs > 0) if (nargs > 0)
{ {
@ -542,7 +607,7 @@ namespace ASE
if (runarg == ASE_NULL) if (runarg == ASE_NULL)
{ {
// TODO: SET ERROR INFO setError (E_NOMEM);
return -1; return -1;
} }
@ -560,7 +625,7 @@ namespace ASE
} }
} }
// TODO: SET ERROR INFO setError (E_NOMEM);
return -1; return -1;
} }
} }
@ -570,7 +635,10 @@ namespace ASE
} }
int n = ase_awk_run ( int n = ase_awk_run (
awk, main, &runios, &runcbs, runarg, this); awk, main, &runios,
(runCallback? &runcbs: ASE_NULL),
runarg, this);
if (n == -1) retrieveError ();
if (runarg != ASE_NULL) if (runarg != ASE_NULL)
{ {
@ -593,11 +661,7 @@ namespace ASE
awk = ase_awk_getrunawk (run); awk = ase_awk_getrunawk (run);
pair = ase_awk_map_get (functionMap, name, len); pair = ase_awk_map_get (functionMap, name, len);
if (pair == ASE_NULL) if (pair == ASE_NULL) return -1;
{
// TODO: SET ERROR INFO
return -1;
}
FunctionHandler handler; FunctionHandler handler;
handler = *(FunctionHandler*)ASE_AWK_PAIR_VAL(pair); handler = *(FunctionHandler*)ASE_AWK_PAIR_VAL(pair);
@ -607,11 +671,7 @@ namespace ASE
//Argument* args = ASE_NULL; //Argument* args = ASE_NULL;
//try { args = new Argument [nargs]; } catch (...) {} //try { args = new Argument [nargs]; } catch (...) {}
Argument* args = new(awk) Argument[nargs]; Argument* args = new(awk) Argument[nargs];
if (args == ASE_NULL) if (args == ASE_NULL) return -1;
{
// TODO: SET ERROR INFO
return -1;
}
for (i = 0; i < nargs; i++) for (i = 0; i < nargs; i++)
{ {
@ -619,29 +679,19 @@ namespace ASE
if (args[i].init (run, v) == -1) if (args[i].init (run, v) == -1)
{ {
delete[] args; delete[] args;
// TODO: SET ERROR INFO
return -1; return -1;
} }
} }
Return ret (run); Return ret (run);
int n = (this->*handler) (&ret, args, nargs); int n = (this->*handler) (&ret, args, nargs);
delete[] args; delete[] args;
if (n <= -1) if (n <= -1) return -1;
{
// TODO: SET ERROR INFO
return -1;
}
val_t* r = ret.toVal (); val_t* r = ret.toVal ();
if (r == ASE_NULL) if (r == ASE_NULL) return -1;
{
// TODO: SET ERROR INFO
return -1;
}
ase_awk_setretval (run, r); ase_awk_setretval (run, r);
return 0; return 0;
@ -657,7 +707,7 @@ namespace ASE
ase_awk_malloc (awk, ASE_SIZEOF(handler)); ase_awk_malloc (awk, ASE_SIZEOF(handler));
if (tmp == ASE_NULL) if (tmp == ASE_NULL)
{ {
// TODO: SET ERROR INFO -> ENOMEM setError (E_NOMEM);
return -1; return -1;
} }
@ -672,15 +722,17 @@ namespace ASE
if (p == ASE_NULL) if (p == ASE_NULL)
{ {
ase_awk_free (awk, tmp); ase_awk_free (awk, tmp);
retrieveError ();
return -1; return -1;
} }
pair_t* pair = ase_awk_map_put (functionMap, name, nameLen, tmp); pair_t* pair = ase_awk_map_put (functionMap, name, nameLen, tmp);
if (pair == ASE_NULL) if (pair == ASE_NULL)
{ {
// TODO: SET ERROR INFO
ase_awk_delbfn (awk, name, nameLen); ase_awk_delbfn (awk, name, nameLen);
ase_awk_free (awk, tmp); ase_awk_free (awk, tmp);
setError (E_NOMEM);
return -1; return -1;
} }
@ -695,15 +747,34 @@ namespace ASE
int n = ase_awk_delbfn (awk, name, nameLen); int n = ase_awk_delbfn (awk, name, nameLen);
if (n == 0) ase_awk_map_remove (functionMap, name, nameLen); if (n == 0) ase_awk_map_remove (functionMap, name, nameLen);
else retrieveError ();
return n; return n;
} }
void Awk::enableRunCallback ()
{
runCallback = true;
}
void Awk::disableRunCallback ()
{
runCallback = false;
}
void Awk::onRunStart (const Run& run) void Awk::onRunStart (const Run& run)
{ {
} }
void Awk::onRunEnd (const Run& run, int errnum) void Awk::onRunEnd (const Run& run)
{
}
void Awk::onRunReturn (const Run& run, const Argument& ret)
{
}
void Awk::onRunStatement (const Run& run, size_t line)
{ {
} }
@ -853,14 +924,48 @@ namespace ASE
void Awk::onRunStart (run_t* run, void* custom) void Awk::onRunStart (run_t* run, void* custom)
{ {
Awk* awk = (Awk*)custom; Run* r = (Run*)custom;
awk->onRunStart (Run(run)); r->run = run;
r->callbackFailed = false;
r->awk->onRunStart (*r);
} }
void Awk::onRunEnd (run_t* run, int errnum, void* custom) void Awk::onRunEnd (run_t* run, int errnum, void* custom)
{ {
Awk* awk = (Awk*)custom; Run* r = (Run*)custom;
awk->onRunEnd (Run(run), errnum);
if (errnum == E_NOERR && r->callbackFailed)
{
ase_awk_setrunerror (
r->run, ASE_AWK_ENOMEM, 0, ASE_NULL, 0);
}
r->awk->onRunEnd (*r);
}
void Awk::onRunReturn (run_t* run, val_t* ret, void* custom)
{
Run* r = (Run*)custom;
if (r->callbackFailed) return;
Argument x;
if (x.init (run, ret) == -1)
{
r->callbackFailed = true;
}
else
{
r->awk->onRunReturn (*r, x);
}
}
void Awk::onRunStatement (run_t* run, size_t line, void* custom)
{
Run* r = (Run*)custom;
if (r->callbackFailed) return;
r->awk->onRunStatement (*r, line);
} }
void* Awk::allocMem (void* custom, size_t n) void* Awk::allocMem (void* custom, size_t n)

205
ase/awk/Awk.hpp
View File

@ -1,5 +1,5 @@
/* /*
* $Id: Awk.hpp,v 1.29 2007/05/17 15:02:54 bacon Exp $ * $Id: Awk.hpp,v 1.33 2007/05/19 16:45:27 bacon Exp $
*/ */
#ifndef _ASE_AWK_AWK_HPP_ #ifndef _ASE_AWK_AWK_HPP_
@ -60,9 +60,6 @@ namespace ASE
const void* getHandle () const; const void* getHandle () const;
void setHandle (void* handle); void setHandle (void* handle);
run_t* getRun () const;
awk_t* getAwk () const;
protected: protected:
extio_t* extio; extio_t* extio;
}; };
@ -159,9 +156,6 @@ namespace ASE
real_t toReal () const; real_t toReal () const;
const char_t* toStr (size_t* len) const; const char_t* toStr (size_t* len) const;
run_t* getRun () const;
awk_t* getAwk () const;
protected: protected:
run_t* run; run_t* run;
val_t* val; val_t* val;
@ -187,9 +181,6 @@ namespace ASE
val_t* toVal () const; val_t* toVal () const;
public: public:
run_t* getRun () const;
awk_t* getAwk () const;
int set (long_t v); int set (long_t v);
int set (real_t v); int set (real_t v);
int set (char_t* ptr, size_t len); int set (char_t* ptr, size_t len);
@ -212,36 +203,199 @@ namespace ASE
} v; } v;
}; };
// generated by generrcode.awk
enum ErrorCode
{
E_NOERR = ASE_AWK_ENOERR,
E_INVAL = ASE_AWK_EINVAL,
E_NOMEM = ASE_AWK_ENOMEM,
E_NOSUP = ASE_AWK_ENOSUP,
E_NOPER = ASE_AWK_ENOPER,
E_NODEV = ASE_AWK_ENODEV,
E_NOSPC = ASE_AWK_ENOSPC,
E_MFILE = ASE_AWK_EMFILE,
E_MLINK = ASE_AWK_EMLINK,
E_AGAIN = ASE_AWK_EAGAIN,
E_NOENT = ASE_AWK_ENOENT,
E_EXIST = ASE_AWK_EEXIST,
E_FTBIG = ASE_AWK_EFTBIG,
E_TBUSY = ASE_AWK_ETBUSY,
E_ISDIR = ASE_AWK_EISDIR,
E_IOERR = ASE_AWK_EIOERR,
E_OPEN = ASE_AWK_EOPEN,
E_READ = ASE_AWK_EREAD,
E_WRITE = ASE_AWK_EWRITE,
E_CLOSE = ASE_AWK_ECLOSE,
E_INTERN = ASE_AWK_EINTERN,
E_RUNTIME = ASE_AWK_ERUNTIME,
E_BLKNST = ASE_AWK_EBLKNST,
E_EXPRNST = ASE_AWK_EEXPRNST,
E_SINOP = ASE_AWK_ESINOP,
E_SINCL = ASE_AWK_ESINCL,
E_SINRD = ASE_AWK_ESINRD,
E_SOUTOP = ASE_AWK_ESOUTOP,
E_SOUTCL = ASE_AWK_ESOUTCL,
E_SOUTWR = ASE_AWK_ESOUTWR,
E_LXCHR = ASE_AWK_ELXCHR,
E_LXUNG = ASE_AWK_ELXUNG,
E_ENDSRC = ASE_AWK_EENDSRC,
E_ENDCMT = ASE_AWK_EENDCMT,
E_ENDSTR = ASE_AWK_EENDSTR,
E_ENDREX = ASE_AWK_EENDREX,
E_LBRACE = ASE_AWK_ELBRACE,
E_LPAREN = ASE_AWK_ELPAREN,
E_RPAREN = ASE_AWK_ERPAREN,
E_RBRACK = ASE_AWK_ERBRACK,
E_COMMA = ASE_AWK_ECOMMA,
E_SCOLON = ASE_AWK_ESCOLON,
E_COLON = ASE_AWK_ECOLON,
E_STMEND = ASE_AWK_ESTMEND,
E_IN = ASE_AWK_EIN,
E_NOTVAR = ASE_AWK_ENOTVAR,
E_EXPRES = ASE_AWK_EEXPRES,
E_WHILE = ASE_AWK_EWHILE,
E_ASSIGN = ASE_AWK_EASSIGN,
E_IDENT = ASE_AWK_EIDENT,
E_FNNAME = ASE_AWK_EFNNAME,
E_BLKBEG = ASE_AWK_EBLKBEG,
E_BLKEND = ASE_AWK_EBLKEND,
E_DUPBEG = ASE_AWK_EDUPBEG,
E_DUPEND = ASE_AWK_EDUPEND,
E_BFNRED = ASE_AWK_EBFNRED,
E_AFNRED = ASE_AWK_EAFNRED,
E_GBLRED = ASE_AWK_EGBLRED,
E_PARRED = ASE_AWK_EPARRED,
E_DUPPAR = ASE_AWK_EDUPPAR,
E_DUPGBL = ASE_AWK_EDUPGBL,
E_DUPLCL = ASE_AWK_EDUPLCL,
E_BADPAR = ASE_AWK_EBADPAR,
E_BADVAR = ASE_AWK_EBADVAR,
E_UNDEF = ASE_AWK_EUNDEF,
E_LVALUE = ASE_AWK_ELVALUE,
E_GBLTM = ASE_AWK_EGBLTM,
E_LCLTM = ASE_AWK_ELCLTM,
E_PARTM = ASE_AWK_EPARTM,
E_DELETE = ASE_AWK_EDELETE,
E_BREAK = ASE_AWK_EBREAK,
E_CONTINUE = ASE_AWK_ECONTINUE,
E_NEXTBEG = ASE_AWK_ENEXTBEG,
E_NEXTEND = ASE_AWK_ENEXTEND,
E_NEXTFBEG = ASE_AWK_ENEXTFBEG,
E_NEXTFEND = ASE_AWK_ENEXTFEND,
E_PRINTFARG = ASE_AWK_EPRINTFARG,
E_PREPST = ASE_AWK_EPREPST,
E_GLNCPS = ASE_AWK_EGLNCPS,
E_DIVBY0 = ASE_AWK_EDIVBY0,
E_OPERAND = ASE_AWK_EOPERAND,
E_POSIDX = ASE_AWK_EPOSIDX,
E_ARGTF = ASE_AWK_EARGTF,
E_ARGTM = ASE_AWK_EARGTM,
E_FNNONE = ASE_AWK_EFNNONE,
E_NOTIDX = ASE_AWK_ENOTIDX,
E_NOTDEL = ASE_AWK_ENOTDEL,
E_NOTMAP = ASE_AWK_ENOTMAP,
E_NOTMAPIN = ASE_AWK_ENOTMAPIN,
E_NOTMAPNILIN = ASE_AWK_ENOTMAPNILIN,
E_NOTREF = ASE_AWK_ENOTREF,
E_NOTASS = ASE_AWK_ENOTASS,
E_IDXVALASSMAP = ASE_AWK_EIDXVALASSMAP,
E_POSVALASSMAP = ASE_AWK_EPOSVALASSMAP,
E_MAPTOSCALAR = ASE_AWK_EMAPTOSCALAR,
E_SCALARTOMAP = ASE_AWK_ESCALARTOMAP,
E_MAPNOTALLOWED = ASE_AWK_EMAPNOTALLOWED,
E_VALTYPE = ASE_AWK_EVALTYPE,
E_RDELETE = ASE_AWK_ERDELETE,
E_RNEXTBEG = ASE_AWK_ERNEXTBEG,
E_RNEXTEND = ASE_AWK_ERNEXTEND,
E_RNEXTFBEG = ASE_AWK_ERNEXTFBEG,
E_RNEXTFEND = ASE_AWK_ERNEXTFEND,
E_BFNUSER = ASE_AWK_EBFNUSER,
E_BFNIMPL = ASE_AWK_EBFNIMPL,
E_IOUSER = ASE_AWK_EIOUSER,
E_IONONE = ASE_AWK_EIONONE,
E_IOIMPL = ASE_AWK_EIOIMPL,
E_IONMEM = ASE_AWK_EIONMEM,
E_IONMNL = ASE_AWK_EIONMNL,
E_FMTARG = ASE_AWK_EFMTARG,
E_FMTCNV = ASE_AWK_EFMTCNV,
E_CONVFMTCHR = ASE_AWK_ECONVFMTCHR,
E_OFMTCHR = ASE_AWK_EOFMTCHR,
E_REXRECUR = ASE_AWK_EREXRECUR,
E_REXRPAREN = ASE_AWK_EREXRPAREN,
E_REXRBRACKET = ASE_AWK_EREXRBRACKET,
E_REXRBRACE = ASE_AWK_EREXRBRACE,
E_REXUNBALPAR = ASE_AWK_EREXUNBALPAR,
E_REXCOLON = ASE_AWK_EREXCOLON,
E_REXCRANGE = ASE_AWK_EREXCRANGE,
E_REXCCLASS = ASE_AWK_EREXCCLASS,
E_REXBRANGE = ASE_AWK_EREXBRANGE,
E_REXEND = ASE_AWK_EREXEND,
E_REXGARBAGE = ASE_AWK_EREXGARBAGE
};
// end of enum ErrorCode
// generated by genoptcode.awk
enum Option
{
OPT_IMPLICIT = ASE_AWK_IMPLICIT,
OPT_EXPLICIT = ASE_AWK_EXPLICIT,
OPT_UNIQUEFN = ASE_AWK_UNIQUEFN,
OPT_SHADING = ASE_AWK_SHADING,
OPT_SHIFT = ASE_AWK_SHIFT,
OPT_IDIV = ASE_AWK_IDIV,
OPT_STRCONCAT = ASE_AWK_STRCONCAT,
OPT_EXTIO = ASE_AWK_EXTIO,
OPT_COPROC = ASE_AWK_COPROC,
OPT_BLOCKLESS = ASE_AWK_BLOCKLESS,
OPT_STRBASEONE = ASE_AWK_STRBASEONE,
OPT_STRIPSPACES = ASE_AWK_STRIPSPACES,
OPT_NEXTOFILE = ASE_AWK_NEXTOFILE,
OPT_CRLF = ASE_AWK_CRLF,
OPT_ARGSTOMAIN = ASE_AWK_ARGSTOMAIN
};
// end of enum Option
class Run class Run
{ {
protected: protected:
friend class Awk; friend class Awk;
Run (run_t* run);
Run (Awk* awk);
public:
int stop ();
ErrorCode getErrorCode () const;
size_t getErrorLine () const;
const char_t* getErrorMessage () const;
protected: protected:
Awk* awk;
run_t* run; run_t* run;
bool callbackFailed;
}; };
enum ErrorCode
{
E_NOERR = ASE_AWK_ENOERR,
E_NOMEM = ASE_AWK_ENOMEM
};
Awk (); Awk ();
virtual ~Awk (); virtual ~Awk ();
ErrorCode getErrorCode (); ErrorCode getErrorCode () const;
size_t getErrorLine (); size_t getErrorLine () const ;
const char_t* getErrorMessage () const;
protected: protected:
void setError (ErrorCode code, size_t line = 0); void setError (ErrorCode code, size_t line = 0,
const char_t* arg = ASE_NULL, size_t len = 0);
void clearError (); void clearError ();
void retrieveError ();
public: public:
virtual int open (); virtual int open ();
virtual void close (); virtual void close ();
virtual void setOption (int opt);
virtual int getOption () const;
virtual int parse (); virtual int parse ();
virtual int run (const char_t* main = ASE_NULL, virtual int run (const char_t* main = ASE_NULL,
const char_t** args = ASE_NULL, size_t nargs = 0); const char_t** args = ASE_NULL, size_t nargs = 0);
@ -254,8 +408,10 @@ namespace ASE
FunctionHandler handler); FunctionHandler handler);
virtual int deleteFunction (const char_t* main); virtual int deleteFunction (const char_t* main);
protected: virtual void enableRunCallback ();
virtual void disableRunCallback ();
protected:
virtual int dispatchFunction ( virtual int dispatchFunction (
run_t* run, const char_t* name, size_t len); run_t* run, const char_t* name, size_t len);
@ -289,7 +445,9 @@ namespace ASE
// run-time callbacks // run-time callbacks
virtual void onRunStart (const Run& run); virtual void onRunStart (const Run& run);
virtual void onRunEnd (const Run& run, int errnum); virtual void onRunEnd (const Run& run);
virtual void onRunReturn (const Run& run, const Argument& ret);
virtual void onRunStatement (const Run& run, size_t line);
// primitive handlers // primitive handlers
virtual void* allocMem (size_t n) = 0; virtual void* allocMem (size_t n) = 0;
@ -334,6 +492,8 @@ namespace ASE
static void onRunStart (run_t* run, void* custom); static void onRunStart (run_t* run, void* custom);
static void onRunEnd (run_t* run, int errnum, void* custom); static void onRunEnd (run_t* run, int errnum, void* custom);
static void onRunReturn (run_t* run, val_t* ret, void* custom);
static void onRunStatement (run_t* run, size_t line, void* custom);
static void* allocMem (void* custom, size_t n); static void* allocMem (void* custom, size_t n);
static void* reallocMem (void* custom, void* ptr, size_t n); static void* reallocMem (void* custom, void* ptr, size_t n);
@ -367,6 +527,9 @@ namespace ASE
ErrorCode errnum; ErrorCode errnum;
size_t errlin; size_t errlin;
char_t errmsg[256];
bool runCallback;
private: private:
Awk (const Awk&); Awk (const Awk&);

46
ase/awk/StdAwk.cpp
View File

@ -1,5 +1,5 @@
/* /*
* $Id: StdAwk.cpp,v 1.15 2007/05/18 15:36:02 bacon Exp $ * $Id: StdAwk.cpp,v 1.17 2007/05/19 16:45:27 bacon Exp $
*/ */
#include <ase/awk/StdAwk.hpp> #include <ase/awk/StdAwk.hpp>
@ -37,22 +37,6 @@ namespace ASE
int n = Awk::open (); int n = Awk::open ();
if (n == -1) return n; if (n == -1) return n;
int opt =
ASE_AWK_IMPLICIT |
ASE_AWK_EXPLICIT |
ASE_AWK_UNIQUEFN |
ASE_AWK_IDIV |
ASE_AWK_SHADING |
ASE_AWK_SHIFT |
ASE_AWK_EXTIO |
ASE_AWK_BLOCKLESS |
ASE_AWK_STRBASEONE |
ASE_AWK_STRIPSPACES |
ASE_AWK_NEXTOFILE |
ASE_AWK_ARGSTOMAIN;
ase_awk_setoption (awk, opt);
ADD_FUNC (ASE_T("sin"), 1, 1, &StdAwk::sin); ADD_FUNC (ASE_T("sin"), 1, 1, &StdAwk::sin);
ADD_FUNC (ASE_T("cos"), 1, 1, &StdAwk::cos); ADD_FUNC (ASE_T("cos"), 1, 1, &StdAwk::cos);
ADD_FUNC (ASE_T("tan"), 1, 1, &StdAwk::tan); ADD_FUNC (ASE_T("tan"), 1, 1, &StdAwk::tan);
@ -236,7 +220,7 @@ namespace ASE
FILE* fp = (FILE*)io.getHandle(); FILE* fp = (FILE*)io.getHandle();
ssize_t n = 0; ssize_t n = 0;
while (n < len) while (n < (ssize_t)len)
{ {
ase_cint_t c = ase_fgetc (fp); ase_cint_t c = ase_fgetc (fp);
if (c == ASE_CHAR_EOF) break; if (c == ASE_CHAR_EOF) break;
@ -246,18 +230,8 @@ namespace ASE
} }
return n; return n;
/*
if (ase_fgets (buf, len, fp) == ASE_NULL)
{
if (ferror(fp)) return -1;
return 0;
} }
return ase_strlen(buf);
*/
}
StdAwk::ssize_t StdAwk::writePipe (Pipe& io, char_t* buf, size_t len) StdAwk::ssize_t StdAwk::writePipe (Pipe& io, char_t* buf, size_t len)
{ {
FILE* fp = (FILE*)io.getHandle(); FILE* fp = (FILE*)io.getHandle();
@ -298,7 +272,7 @@ namespace ASE
int n = ase_fprintf (fp, ASE_T("%.*s"), left, buf); int n = ase_fprintf (fp, ASE_T("%.*s"), left, buf);
#endif #endif
if (n < 0 || n > left) return -1; if (n < 0 || n > (ssize_t)left) return -1;
left -= n; buf += n; left -= n; buf += n;
} }
} }
@ -347,7 +321,7 @@ namespace ASE
FILE* fp = (FILE*)io.getHandle(); FILE* fp = (FILE*)io.getHandle();
ssize_t n = 0; ssize_t n = 0;
while (n < len) while (n < (ssize_t)len)
{ {
ase_cint_t c = ase_fgetc (fp); ase_cint_t c = ase_fgetc (fp);
if (c == ASE_CHAR_EOF) break; if (c == ASE_CHAR_EOF) break;
@ -357,16 +331,6 @@ namespace ASE
} }
return n; return n;
/*
if (ase_fgets (buf, len, fp) == ASE_NULL)
{
if (ferror(fp)) return -1;
return 0;
}
return ase_strlen(buf);
*/
} }
StdAwk::ssize_t StdAwk::writeFile (File& io, char_t* buf, size_t len) StdAwk::ssize_t StdAwk::writeFile (File& io, char_t* buf, size_t len)
@ -384,7 +348,7 @@ namespace ASE
else else
{ {
int n = ase_fprintf (fp, ASE_T("%.*s"), left, buf); int n = ase_fprintf (fp, ASE_T("%.*s"), left, buf);
if (n < 0 || n > left) return -1; if (n < 0 || n > (ssize_t)left) return -1;
left -= n; buf += n; left -= n; buf += n;
} }
} }

8
ase/awk/awk.h
View File

@ -1,5 +1,5 @@
/* /*
* $Id: awk.h,v 1.4 2007/05/09 16:07:44 bacon Exp $ * $Id: awk.h,v 1.5 2007/05/19 12:13:41 bacon Exp $
* *
* {License} * {License}
*/ */
@ -117,7 +117,7 @@ struct ase_awk_runarg_t
}; };
/* io function commands */ /* io function commands */
enum enum ase_awk_iocmd_t
{ {
ASE_AWK_IO_OPEN = 0, ASE_AWK_IO_OPEN = 0,
ASE_AWK_IO_CLOSE = 1, ASE_AWK_IO_CLOSE = 1,
@ -128,7 +128,7 @@ enum
}; };
/* various options */ /* various options */
enum enum ase_awk_option_t
{ {
/* allow undeclared variables and implicit concatenation */ /* allow undeclared variables and implicit concatenation */
ASE_AWK_IMPLICIT = (1 << 0), ASE_AWK_IMPLICIT = (1 << 0),
@ -194,7 +194,7 @@ enum
}; };
/* error code */ /* error code */
enum enum ase_awk_errnum_t
{ {
ASE_AWK_ENOERR, /* no error */ ASE_AWK_ENOERR, /* no error */

8
ase/awk/awk.txt
View File

@ -32,12 +32,12 @@ Actions
Variables Variables
global variables (enabled when awk->opt & XP_AWK_OPT_VARDCL) global variables (enabled when awk->opt & ASE_AWK_OPT_VARDCL)
global x; global x;
global x, y; global x, y;
local variables (enabled when awk->opt & XP_AWK_OPT_VARDCL) local variables (enabled when awk->opt & ASE_AWK_OPT_VARDCL)
local x; local x;
local x, y; local x, y;
@ -47,12 +47,12 @@ function arguments (enabled always)
function funca (x, y) function funca (x, y)
local variables in function declaration (enabled when awk->opt & XP_AWK_OPT_FUNCLOCAL) local variables in function declaration (enabled when awk->opt & ASE_AWK_OPT_FUNCLOCAL)
function funca (x, y, v1, v2) function funca (x, y, v1, v2)
variables without any declarations (enabled when awk->opt & XP_AWK_OPT_NAMEDVAR) variables without any declarations (enabled when awk->opt & ASE_AWK_OPT_NAMEDVAR)
x = 10; // x is put into the global hash table. x = 10; // x is put into the global hash table.

3
ase/awk/err.c
View File

@ -1,5 +1,5 @@
/* /*
* $Id: err.c,v 1.3 2007/04/30 05:47:33 bacon Exp $ * $Id: err.c,v 1.4 2007/05/19 12:13:41 bacon Exp $
* *
* {License} * {License}
*/ */
@ -175,7 +175,6 @@ int ase_awk_seterrstr (ase_awk_t* awk, int num, const ase_char_t* str)
if (awk->errstr[num] != ASE_NULL) if (awk->errstr[num] != ASE_NULL)
ASE_AWK_FREE (awk, awk->errstr[num]); ASE_AWK_FREE (awk, awk->errstr[num]);
else awk->errstr[num] = dup; else awk->errstr[num] = dup;
return 0; return 0;
} }

33
ase/awk/generrcode.awk Normal file
View File

@ -0,0 +1,33 @@
#
# generrcode.awk
#
# aseawk -f generror.awk awk.h
#
BEGIN {
collect=0;
tab3="\t\t";
tab4="\t\t\t";
}
/^[[:space:]]*enum[[:space:]]+ase_awk_errnum_t[[:space:]]*$/ {
collect=1;
print tab3 "// generated by generrcode.awk";
print tab3 "enum ErrorCode";
print tab3 "{";
}
collect && /^[[:space:]]*};[[:space:]]*$/ {
print tab3 "};";
print tab3 "// end of enum ErrorCode";
print "";
collect=0;
}
collect && /^[[:space:]]*ASE_AWK_E[[:alnum:]]+/ {
split ($1, flds, ",");
name=flds[1];
print tab4 "E_" substr (name,10,length(name)-9) " = " name ",";
}

33
ase/awk/genoptcode.awk Normal file
View File

@ -0,0 +1,33 @@
#
# genoptcode.awk
#
# aseawk -f generror.awk awk.h
#
BEGIN {
collect=0;
tab3="\t\t";
tab4="\t\t\t";
}
/^[[:space:]]*enum[[:space:]]+ase_awk_option_t[[:space:]]*$/ {
collect=1;
print tab3 "// generated by genoptcode.awk";
print tab3 "enum Option";
print tab3 "{";
}
collect && /^[[:space:]]*};[[:space:]]*$/ {
print tab3 "};";
print tab3 "// end of enum Option";
print "";
collect=0;
}
collect && /^[[:space:]]*ASE_AWK_[[:alnum:]]+/ {
split ($1, flds, ",");
name=flds[1];
print tab4 "OPT_" substr (name,9,length(name)-8) " = " name ",";
}

8
ase/awk/run.c
View File

@ -1,5 +1,5 @@
/* /*
* $Id: run.c,v 1.5 2007/05/13 14:43:58 bacon Exp $ * $Id: run.c,v 1.7 2007/05/19 16:45:27 bacon Exp $
* *
* {License} * {License}
*/ */
@ -662,6 +662,12 @@ int ase_awk_run (ase_awk_t* awk,
/* the run loop ended. execute the end callback if it exists */ /* the run loop ended. execute the end callback if it exists */
if (runcbs != ASE_NULL && runcbs->on_end != ASE_NULL) if (runcbs != ASE_NULL && runcbs->on_end != ASE_NULL)
{ {
if (n == 0)
{
/* clear error if run is successful just in case */
ase_awk_setrunerror (run, ASE_AWK_ENOERR, 0, ASE_NULL, 0);
}
runcbs->on_end (run, runcbs->on_end (run,
((n == -1)? run->errnum: ASE_AWK_ENOERR), ((n == -1)? run->errnum: ASE_AWK_ENOERR),
runcbs->custom_data); runcbs->custom_data);

35
ase/test/awk/Awk.cpp
View File

@ -1,5 +1,5 @@
/* /*
* $Id: Awk.cpp,v 1.15 2007/05/16 14:44:13 bacon Exp $ * $Id: Awk.cpp,v 1.17 2007/05/19 16:45:27 bacon Exp $
*/ */
#include <ase/awk/StdAwk.hpp> #include <ase/awk/StdAwk.hpp>
@ -87,12 +87,27 @@ protected:
void onRunStart (const Run& run) void onRunStart (const Run& run)
{ {
wprintf (L"*** awk run started ***\n"); ase_printf (ASE_T("*** awk run started ***\n"));
} }
void onRunEnd (const Run& run, int errnum) void onRunEnd (const Run& run)
{ {
wprintf (L"*** awk run ended ***\n"); ErrorCode err = run.getErrorCode();
if (err != E_NOERR)
{
ase_fprintf (stderr, ASE_T("cannot run: LINE[%d] %s\n"),
run.getErrorLine(), run.getErrorMessage());
}
ase_printf (ASE_T("*** awk run ended ***\n"));
}
void onRunReturn (const Run& run, const Argument& ret)
{
size_t len;
const char_t* ptr = ret.toStr (&len);
ase_printf (ASE_T("*** return [%.*s] ***\n"), len, ptr);
} }
int openSource (Source& io) int openSource (Source& io)
@ -142,7 +157,7 @@ protected:
FILE* fp = (FILE*)io.getHandle(); FILE* fp = (FILE*)io.getHandle();
ssize_t n = 0; ssize_t n = 0;
while (n < len) while (n < (ssize_t)len)
{ {
ase_cint_t c = ase_fgetc (fp); ase_cint_t c = ase_fgetc (fp);
if (c == ASE_CHAR_EOF) break; if (c == ASE_CHAR_EOF) break;
@ -248,7 +263,7 @@ protected:
FILE* fp = t->handle; FILE* fp = t->handle;
ssize_t n = 0; ssize_t n = 0;
while (n < len) while (n < (ssize_t)len)
{ {
ase_cint_t c = ase_fgetc (fp); ase_cint_t c = ase_fgetc (fp);
if (c == ASE_CHAR_EOF) break; if (c == ASE_CHAR_EOF) break;
@ -546,13 +561,17 @@ int awk_main (int argc, ase_char_t* argv[])
if (awk.parse (srcin, srcout) == -1) if (awk.parse (srcin, srcout) == -1)
{ {
ase_fprintf (stderr, ASE_T("cannot parse\n")); ase_fprintf (stderr, ASE_T("cannot parse: LINE[%d] %s\n"),
awk.getErrorLine(), awk.getErrorMessage());
return -1; return -1;
} }
awk.enableRunCallback ();
if (awk.run (mainfn, args, nargs) == -1) if (awk.run (mainfn, args, nargs) == -1)
{ {
ase_fprintf (stderr, ASE_T("cannot run\n")); ase_fprintf (stderr, ASE_T("cannot run: LINE[%d] %s\n"),
awk.getErrorLine(), awk.getErrorMessage());
return -1; return -1;
} }