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

Recovered from cvs revision 2007-09-08 13:08:00

Browse Source
This commit is contained in:
hyung-hwan 2007-09-11 22:42:00 +00:00
parent f212242f01
commit dc2af2c9ad
5 changed files with 2269 additions and 2245 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

698
ase/awk/Awk.cpp
View File

File diff suppressed because it is too large Load Diff

32
ase/awk/Awk.hpp
View File

@ -1,5 +1,5 @@
/* /*
* $Id: Awk.hpp,v 1.52 2007/09/06 14:38:56 bacon Exp $ * $Id: Awk.hpp,v 1.53 2007/09/07 05:40:16 bacon Exp $
*/ */
#ifndef _ASE_AWK_AWK_HPP_ #ifndef _ASE_AWK_AWK_HPP_
@ -9,14 +9,16 @@
#include <ase/awk/map.h> #include <ase/awk/map.h>
#include <stdarg.h> #include <stdarg.h>
namespace ASE /////////////////////////////////
{ ASE_BEGIN_NAMESPACE(ASE)
/** /////////////////////////////////
/**
* Provides the awk interpreter engine * Provides the awk interpreter engine
*/ */
class Awk class Awk
{ {
public: public:
/** /**
* boolean data type * boolean data type
*/ */
@ -472,7 +474,7 @@ namespace ASE
size_t getErrorLine () const ; size_t getErrorLine () const ;
const char_t* getErrorMessage () 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); const char_t* arg = ASE_NULL, size_t len = 0);
void setError (ErrorCode code, size_t line, const char_t* msg); void setError (ErrorCode code, size_t line, const char_t* msg);
@ -480,7 +482,7 @@ namespace ASE
void clearError (); void clearError ();
void retrieveError (); void retrieveError ();
public: public:
virtual int open (); virtual int open ();
virtual void close (); virtual void close ();
@ -553,7 +555,7 @@ namespace ASE
*/ */
virtual void disableRunCallback (); virtual void disableRunCallback ();
protected: 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);
@ -687,7 +689,7 @@ namespace ASE
const char_t* fmt, ...); const char_t* fmt, ...);
static void dprintf (void* custom, const char_t* fmt, ...); static void dprintf (void* custom, const char_t* fmt, ...);
protected: protected:
awk_t* awk; awk_t* awk;
map_t* functionMap; map_t* functionMap;
@ -700,11 +702,13 @@ namespace ASE
bool runCallback; bool runCallback;
private: private:
Awk (const Awk&); Awk (const Awk&);
Awk& operator= (const Awk&); Awk& operator= (const Awk&);
}; };
} /////////////////////////////////
ASE_END_NAMESPACE(ASE)
/////////////////////////////////
#endif #endif

417
ase/awk/StdAwk.cpp
View File

@ -1,5 +1,5 @@
/* /*
* $Id: StdAwk.cpp,v 1.25 2007/09/06 09:23:34 bacon Exp $ * $Id: StdAwk.cpp,v 1.26 2007/09/07 05:40:16 bacon Exp $
*/ */
#include <ase/awk/StdAwk.hpp> #include <ase/awk/StdAwk.hpp>
@ -12,21 +12,23 @@
#include <time.h> #include <time.h>
#ifdef _WIN32 #ifdef _WIN32
#include <tchar.h> #include <tchar.h>
#else #else
#include <wchar.h> #include <wchar.h>
#endif #endif
namespace ASE /////////////////////////////////
{ ASE_BEGIN_NAMESPACE(ASE)
/////////////////////////////////
StdAwk::StdAwk ()
{ StdAwk::StdAwk ()
{
seed = (unsigned int)::time(NULL); seed = (unsigned int)::time(NULL);
::srand (seed); ::srand (seed);
} }
#define ADD_FUNC(name,min,max,impl) \ #define ADD_FUNC(name,min,max,impl) \
do { \ do { \
if (addFunction (name, min, max, \ if (addFunction (name, min, max, \
(FunctionHandler)impl) == -1) \ (FunctionHandler)impl) == -1) \
@ -36,8 +38,8 @@ namespace ASE
} \ } \
} while (0) } while (0)
int StdAwk::open () int StdAwk::open ()
{ {
int n = Awk::open (); int n = Awk::open ();
if (n == -1) return n; if (n == -1) return n;
@ -58,76 +60,76 @@ namespace ASE
ADD_FUNC (ASE_T("system"), 1, 1, &StdAwk::system); ADD_FUNC (ASE_T("system"), 1, 1, &StdAwk::system);
return 0; return 0;
} }
int StdAwk::sin (Return* ret, const Argument* args, size_t nargs, int StdAwk::sin (Return* ret, const Argument* args, size_t nargs,
const char_t* name, size_t len) const char_t* name, size_t len)
{ {
return ret->set ((real_t)::sin(args[0].toReal())); return ret->set ((real_t)::sin(args[0].toReal()));
} }
int StdAwk::cos (Return* ret, const Argument* args, size_t nargs, int StdAwk::cos (Return* ret, const Argument* args, size_t nargs,
const char_t* name, size_t len) const char_t* name, size_t len)
{ {
return ret->set ((real_t)::cos(args[0].toReal())); return ret->set ((real_t)::cos(args[0].toReal()));
} }
int StdAwk::tan (Return* ret, const Argument* args, size_t nargs, int StdAwk::tan (Return* ret, const Argument* args, size_t nargs,
const char_t* name, size_t len) const char_t* name, size_t len)
{ {
return ret->set ((real_t)::tan(args[0].toReal())); return ret->set ((real_t)::tan(args[0].toReal()));
} }
int StdAwk::atan (Return* ret, const Argument* args, size_t nargs, int StdAwk::atan (Return* ret, const Argument* args, size_t nargs,
const char_t* name, size_t len) const char_t* name, size_t len)
{ {
return ret->set ((real_t)::atan(args[0].toReal())); return ret->set ((real_t)::atan(args[0].toReal()));
} }
int StdAwk::atan2 (Return* ret, const Argument* args, size_t nargs, int StdAwk::atan2 (Return* ret, const Argument* args, size_t nargs,
const char_t* name, size_t len) const char_t* name, size_t len)
{ {
return ret->set ((real_t)::atan2(args[0].toReal(), args[1].toReal())); return ret->set ((real_t)::atan2(args[0].toReal(), args[1].toReal()));
} }
int StdAwk::log (Return* ret, const Argument* args, size_t nargs, int StdAwk::log (Return* ret, const Argument* args, size_t nargs,
const char_t* name, size_t len) const char_t* name, size_t len)
{ {
return ret->set ((real_t)::log(args[0].toReal())); return ret->set ((real_t)::log(args[0].toReal()));
} }
int StdAwk::exp (Return* ret, const Argument* args, size_t nargs, int StdAwk::exp (Return* ret, const Argument* args, size_t nargs,
const char_t* name, size_t len) const char_t* name, size_t len)
{ {
return ret->set ((real_t)::exp(args[0].toReal())); return ret->set ((real_t)::exp(args[0].toReal()));
} }
int StdAwk::sqrt (Return* ret, const Argument* args, size_t nargs, int StdAwk::sqrt (Return* ret, const Argument* args, size_t nargs,
const char_t* name, size_t len) const char_t* name, size_t len)
{ {
return ret->set ((real_t)::sqrt(args[0].toReal())); return ret->set ((real_t)::sqrt(args[0].toReal()));
} }
int StdAwk::fnint (Return* ret, const Argument* args, size_t nargs, int StdAwk::fnint (Return* ret, const Argument* args, size_t nargs,
const char_t* name, size_t len) const char_t* name, size_t len)
{ {
return ret->set (args[0].toInt()); return ret->set (args[0].toInt());
} }
int StdAwk::rand (Return* ret, const Argument* args, size_t nargs, int StdAwk::rand (Return* ret, const Argument* args, size_t nargs,
const char_t* name, size_t len) const char_t* name, size_t len)
{ {
return ret->set ((long_t)::rand()); return ret->set ((long_t)::rand());
} }
int StdAwk::srand (Return* ret, const Argument* args, size_t nargs, int StdAwk::srand (Return* ret, const Argument* args, size_t nargs,
const char_t* name, size_t len) const char_t* name, size_t len)
{ {
unsigned int prevSeed = seed; unsigned int prevSeed = seed;
seed = (unsigned int)args[0].toInt(); seed = (unsigned int)args[0].toInt();
::srand (seed); ::srand (seed);
return ret->set ((long_t)prevSeed); return ret->set ((long_t)prevSeed);
} }
#if defined(_WIN32) && defined(_MSC_VER) && (_MSC_VER>=1400) #if defined(_WIN32) && defined(_MSC_VER) && (_MSC_VER>=1400)
#define time_t __time64_t #define time_t __time64_t
@ -136,15 +138,15 @@ namespace ASE
#define gmtime _gmtime64 #define gmtime _gmtime64
#endif #endif
int StdAwk::systime (Return* ret, const Argument* args, size_t nargs, int StdAwk::systime (Return* ret, const Argument* args, size_t nargs,
const char_t* name, size_t len) const char_t* name, size_t len)
{ {
return ret->set ((long_t)::time(NULL)); return ret->set ((long_t)::time(NULL));
} }
int StdAwk::strftime (Return* ret, const Argument* args, size_t nargs, int StdAwk::strftime (Return* ret, const Argument* args, size_t nargs,
const char_t* name, size_t len) const char_t* name, size_t len)
{ {
const char_t* fmt; const char_t* fmt;
size_t fln; size_t fln;
@ -153,25 +155,25 @@ namespace ASE
char_t buf[128]; char_t buf[128];
struct tm* tm; struct tm* tm;
#ifdef _WIN32 #ifdef _WIN32
tm = ::localtime (&t); tm = ::localtime (&t);
#else #else
struct tm tmb; struct tm tmb;
tm = ::localtime_r (&t, &tmb); tm = ::localtime_r (&t, &tmb);
#endif #endif
#ifdef ASE_CHAR_IS_MCHAR #ifdef ASE_CHAR_IS_MCHAR
size_t l = ::strftime (buf, ASE_COUNTOF(buf), fmt, tm); size_t l = ::strftime (buf, ASE_COUNTOF(buf), fmt, tm);
#else #else
size_t l = ::wcsftime (buf, ASE_COUNTOF(buf), fmt, tm); size_t l = ::wcsftime (buf, ASE_COUNTOF(buf), fmt, tm);
#endif #endif
return ret->set (buf, l); return ret->set (buf, l);
} }
int StdAwk::strfgmtime (Return* ret, const Argument* args, size_t nargs, int StdAwk::strfgmtime (Return* ret, const Argument* args, size_t nargs,
const char_t* name, size_t len) const char_t* name, size_t len)
{ {
const char_t* fmt; const char_t* fmt;
size_t fln; size_t fln;
@ -180,33 +182,33 @@ namespace ASE
char_t buf[128]; char_t buf[128];
struct tm* tm; struct tm* tm;
#ifdef _WIN32 #ifdef _WIN32
tm = ::gmtime (&t); tm = ::gmtime (&t);
#else #else
struct tm tmb; struct tm tmb;
tm = ::gmtime_r (&t, &tmb); tm = ::gmtime_r (&t, &tmb);
#endif #endif
#ifdef ASE_CHAR_IS_MCHAR #ifdef ASE_CHAR_IS_MCHAR
size_t l = ::strftime (buf, ASE_COUNTOF(buf), fmt, tm); size_t l = ::strftime (buf, ASE_COUNTOF(buf), fmt, tm);
#else #else
size_t l = ::wcsftime (buf, ASE_COUNTOF(buf), fmt, tm); size_t l = ::wcsftime (buf, ASE_COUNTOF(buf), fmt, tm);
#endif #endif
return ret->set (buf, l); return ret->set (buf, l);
} }
int StdAwk::system (Return* ret, const Argument* args, size_t nargs, int StdAwk::system (Return* ret, const Argument* args, size_t nargs,
const char_t* name, size_t len) const char_t* name, size_t len)
{ {
size_t l; size_t l;
const char_t* ptr = args[0].toStr(&l); const char_t* ptr = args[0].toStr(&l);
#ifdef _WIN32 #ifdef _WIN32
return ret->set ((long_t)::_tsystem(ptr)); return ret->set ((long_t)::_tsystem(ptr));
#elif defined(ASE_CHAR_IS_MCHAR) #elif defined(ASE_CHAR_IS_MCHAR)
return ret->set ((long_t)::system(ptr)); return ret->set ((long_t)::system(ptr));
#else #else
char* mbs = (char*)ase_awk_malloc (awk, l*5+1); char* mbs = (char*)ase_awk_malloc (awk, l*5+1);
if (mbs == ASE_NULL) return -1; if (mbs == ASE_NULL) return -1;
@ -217,11 +219,11 @@ namespace ASE
ase_awk_free (awk, mbs); ase_awk_free (awk, mbs);
return n; return n;
#endif #endif
} }
int StdAwk::openPipe (Pipe& io) int StdAwk::openPipe (Pipe& io)
{ {
Awk::Pipe::Mode mode = io.getMode(); Awk::Pipe::Mode mode = io.getMode();
FILE* fp = NULL; FILE* fp = NULL;
@ -239,16 +241,16 @@ namespace ASE
io.setHandle (fp); io.setHandle (fp);
return 1; return 1;
} }
int StdAwk::closePipe (Pipe& io) int StdAwk::closePipe (Pipe& io)
{ {
fclose ((FILE*)io.getHandle()); fclose ((FILE*)io.getHandle());
return 0; return 0;
} }
StdAwk::ssize_t StdAwk::readPipe (Pipe& io, char_t* buf, size_t len) StdAwk::ssize_t StdAwk::readPipe (Pipe& io, char_t* buf, size_t len)
{ {
FILE* fp = (FILE*)io.getHandle(); FILE* fp = (FILE*)io.getHandle();
ssize_t n = 0; ssize_t n = 0;
@ -262,10 +264,10 @@ namespace ASE
} }
return n; return n;
} }
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();
size_t left = len; size_t left = len;
@ -310,16 +312,16 @@ namespace ASE
} }
return len; return len;
} }
int StdAwk::flushPipe (Pipe& io) int StdAwk::flushPipe (Pipe& io)
{ {
return ::fflush ((FILE*)io.getHandle()); return ::fflush ((FILE*)io.getHandle());
} }
// file io handlers // file io handlers
int StdAwk::openFile (File& io) int StdAwk::openFile (File& io)
{ {
Awk::File::Mode mode = io.getMode(); Awk::File::Mode mode = io.getMode();
FILE* fp = NULL; FILE* fp = NULL;
@ -340,16 +342,16 @@ namespace ASE
io.setHandle (fp); io.setHandle (fp);
return 1; return 1;
} }
int StdAwk::closeFile (File& io) int StdAwk::closeFile (File& io)
{ {
fclose ((FILE*)io.getHandle()); fclose ((FILE*)io.getHandle());
return 0; return 0;
} }
StdAwk::ssize_t StdAwk::readFile (File& io, char_t* buf, size_t len) StdAwk::ssize_t StdAwk::readFile (File& io, char_t* buf, size_t len)
{ {
FILE* fp = (FILE*)io.getHandle(); FILE* fp = (FILE*)io.getHandle();
ssize_t n = 0; ssize_t n = 0;
@ -363,10 +365,10 @@ namespace ASE
} }
return n; return n;
} }
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)
{ {
FILE* fp = (FILE*)io.getHandle(); FILE* fp = (FILE*)io.getHandle();
size_t left = len; size_t left = len;
@ -386,110 +388,113 @@ namespace ASE
} }
return len; return len;
}
int StdAwk::flushFile (File& io)
{
return ::fflush ((FILE*)io.getHandle());
}
// memory allocation primitives
void* StdAwk::allocMem (size_t n)
{
return ::malloc (n);
}
void* StdAwk::reallocMem (void* ptr, size_t n)
{
return ::realloc (ptr, n);
}
void StdAwk::freeMem (void* ptr)
{
::free (ptr);
}
// character class primitives
StdAwk::bool_t StdAwk::isUpper (cint_t c)
{
return ase_isupper (c);
}
StdAwk::bool_t StdAwk::isLower (cint_t c)
{
return ase_islower (c);
}
StdAwk::bool_t StdAwk::isAlpha (cint_t c)
{
return ase_isalpha (c);
}
StdAwk::bool_t StdAwk::isDigit (cint_t c)
{
return ase_isdigit (c);
}
StdAwk::bool_t StdAwk::isXdigit (cint_t c)
{
return ase_isxdigit (c);
}
StdAwk::bool_t StdAwk::isAlnum (cint_t c)
{
return ase_isalnum (c);
}
StdAwk::bool_t StdAwk::isSpace (cint_t c)
{
return ase_isspace (c);
}
StdAwk::bool_t StdAwk::isPrint (cint_t c)
{
return ase_isprint (c);
}
StdAwk::bool_t StdAwk::isGraph (cint_t c)
{
return ase_isgraph (c);
}
StdAwk::bool_t StdAwk::isCntrl (cint_t c)
{
return ase_iscntrl (c);
}
StdAwk::bool_t StdAwk::isPunct (cint_t c)
{
return ase_ispunct (c);
}
StdAwk::cint_t StdAwk::toUpper (cint_t c)
{
return ase_toupper (c);
}
StdAwk::cint_t StdAwk::toLower (cint_t c)
{
return ase_tolower (c);
}
// miscellaneous primitive
StdAwk::real_t StdAwk::pow (real_t x, real_t y)
{
return ::pow (x, y);
}
int StdAwk::vsprintf (
char_t* buf, size_t size, const char_t* fmt, va_list arg)
{
return ase_vsprintf (buf, size, fmt, arg);
}
void StdAwk::vdprintf (const char_t* fmt, va_list arg)
{
ase_vfprintf (stderr, fmt, arg);
}
} }
int StdAwk::flushFile (File& io)
{
return ::fflush ((FILE*)io.getHandle());
}
// memory allocation primitives
void* StdAwk::allocMem (size_t n)
{
return ::malloc (n);
}
void* StdAwk::reallocMem (void* ptr, size_t n)
{
return ::realloc (ptr, n);
}
void StdAwk::freeMem (void* ptr)
{
::free (ptr);
}
// character class primitives
StdAwk::bool_t StdAwk::isUpper (cint_t c)
{
return ase_isupper (c);
}
StdAwk::bool_t StdAwk::isLower (cint_t c)
{
return ase_islower (c);
}
StdAwk::bool_t StdAwk::isAlpha (cint_t c)
{
return ase_isalpha (c);
}
StdAwk::bool_t StdAwk::isDigit (cint_t c)
{
return ase_isdigit (c);
}
StdAwk::bool_t StdAwk::isXdigit (cint_t c)
{
return ase_isxdigit (c);
}
StdAwk::bool_t StdAwk::isAlnum (cint_t c)
{
return ase_isalnum (c);
}
StdAwk::bool_t StdAwk::isSpace (cint_t c)
{
return ase_isspace (c);
}
StdAwk::bool_t StdAwk::isPrint (cint_t c)
{
return ase_isprint (c);
}
StdAwk::bool_t StdAwk::isGraph (cint_t c)
{
return ase_isgraph (c);
}
StdAwk::bool_t StdAwk::isCntrl (cint_t c)
{
return ase_iscntrl (c);
}
StdAwk::bool_t StdAwk::isPunct (cint_t c)
{
return ase_ispunct (c);
}
StdAwk::cint_t StdAwk::toUpper (cint_t c)
{
return ase_toupper (c);
}
StdAwk::cint_t StdAwk::toLower (cint_t c)
{
return ase_tolower (c);
}
// miscellaneous primitive
StdAwk::real_t StdAwk::pow (real_t x, real_t y)
{
return ::pow (x, y);
}
int StdAwk::vsprintf (
char_t* buf, size_t size, const char_t* fmt, va_list arg)
{
return ase_vsprintf (buf, size, fmt, arg);
}
void StdAwk::vdprintf (const char_t* fmt, va_list arg)
{
ase_vfprintf (stderr, fmt, arg);
}
/////////////////////////////////
ASE_END_NAMESPACE(ASE)
/////////////////////////////////

25
ase/awk/StdAwk.hpp
View File

@ -1,5 +1,5 @@
/* /*
* $Id: StdAwk.hpp,v 1.13 2007/08/26 14:33:38 bacon Exp $ * $Id: StdAwk.hpp,v 1.14 2007/09/07 05:40:16 bacon Exp $
*/ */
#ifndef _ASE_AWK_STDAWK_HPP_ #ifndef _ASE_AWK_STDAWK_HPP_
@ -7,16 +7,17 @@
#include <ase/awk/Awk.hpp> #include <ase/awk/Awk.hpp>
namespace ASE /////////////////////////////////
{ ASE_BEGIN_NAMESPACE(ASE)
class StdAwk: public Awk /////////////////////////////////
{
public:
StdAwk ();
class StdAwk: public Awk
{
public:
StdAwk ();
int open (); int open ();
protected: protected:
// builtin functions // builtin functions
int sin (Return* ret, const Argument* args, size_t nargs, int sin (Return* ret, const Argument* args, size_t nargs,
@ -88,11 +89,13 @@ namespace ASE
const char_t* fmt, va_list arg); const char_t* fmt, va_list arg);
void vdprintf (const char_t* fmt, va_list arg); void vdprintf (const char_t* fmt, va_list arg);
protected: protected:
unsigned int seed; unsigned int seed;
}; };
} /////////////////////////////////
ASE_END_NAMESPACE(ASE)
/////////////////////////////////
#endif #endif

10
ase/cmn/macros.h
View File

@ -1,5 +1,5 @@
/* /*
* $Id: macros.h,v 1.5 2007/05/06 10:08:36 bacon Exp $ * $Id: macros.h,v 1.6 2007/09/07 05:40:16 bacon Exp $
* *
* {License} * {License}
*/ */
@ -150,4 +150,12 @@
#define ASE_TOUPPER(ccls,c) (ccls)->to_upper((ccls)->custom_data,c) #define ASE_TOUPPER(ccls,c) (ccls)->to_upper((ccls)->custom_data,c)
#define ASE_TOLOWER(ccls,c) (ccls)->to_lower((ccls)->custom_data,c) #define ASE_TOLOWER(ccls,c) (ccls)->to_lower((ccls)->custom_data,c)
#ifdef __cplusplus
#define ASE_BEGIN_NAMESPACE(x) namespace x {
#define ASE_END_NAMESPACE(x) }
#define ASE_BEGIN_NAMESPACE2(x,y) namespace x { namespace y {
#define ASE_END_NAMESPACE2(y,x) }}
#endif
#endif #endif