2007-05-02 01:07:00 +00:00
|
|
|
/*
|
2009-07-15 02:06:14 +00:00
|
|
|
* $Id: Awk.cpp 232 2009-07-14 08:06:14Z hyunghwan.chung $
|
2007-09-25 20:25:00 +00:00
|
|
|
*
|
2009-02-04 08:39:21 +00:00
|
|
|
Copyright 2006-2009 Chung, Hyung-Hwan.
|
2008-12-30 04:49:25 +00:00
|
|
|
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
you may not use this file except in compliance with the License.
|
|
|
|
You may obtain a copy of the License at
|
|
|
|
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
See the License for the specific language governing permissions and
|
|
|
|
limitations under the License.
|
2007-05-02 01:07:00 +00:00
|
|
|
*/
|
|
|
|
|
2008-12-21 21:35:07 +00:00
|
|
|
#include <qse/awk/Awk.hpp>
|
|
|
|
#include <qse/cmn/str.h>
|
2008-08-19 05:21:48 +00:00
|
|
|
#include "../cmn/mem.h"
|
2009-02-17 02:11:31 +00:00
|
|
|
#include "awk.h"
|
2007-05-02 01:07:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
/////////////////////////////////
|
2008-12-30 04:49:25 +00:00
|
|
|
QSE_BEGIN_NAMESPACE(QSE)
|
2007-09-11 22:42:00 +00:00
|
|
|
/////////////////////////////////
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
// Awk::Source
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
|
2009-02-15 08:38:00 +00:00
|
|
|
struct xtn_t
|
|
|
|
{
|
|
|
|
Awk* awk;
|
|
|
|
};
|
|
|
|
|
2009-02-16 08:31:34 +00:00
|
|
|
struct rxtn_t
|
|
|
|
{
|
|
|
|
Awk::Run* run;
|
|
|
|
};
|
|
|
|
|
2009-07-14 04:03:53 +00:00
|
|
|
Awk::NoSource Awk::Source::NONE;
|
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
//////////////////////////////////////////////////////////////////
|
2009-02-16 08:31:34 +00:00
|
|
|
// Awk::RIO
|
2007-09-11 22:42:00 +00:00
|
|
|
//////////////////////////////////////////////////////////////////
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2009-07-07 06:37:25 +00:00
|
|
|
Awk::RIOBase::RIOBase (Run* run, rio_arg_t* riod): run (run), riod (riod)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
|
|
|
}
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2009-06-26 01:39:27 +00:00
|
|
|
const Awk::char_t* Awk::RIOBase::getName () const
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2009-02-16 08:31:34 +00:00
|
|
|
return this->riod->name;
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2009-06-26 01:39:27 +00:00
|
|
|
const void* Awk::RIOBase::getHandle () const
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2009-02-16 08:31:34 +00:00
|
|
|
return this->riod->handle;
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2009-06-26 01:39:27 +00:00
|
|
|
void Awk::RIOBase::setHandle (void* handle)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2009-02-16 08:31:34 +00:00
|
|
|
this->riod->handle = handle;
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2009-06-26 01:39:27 +00:00
|
|
|
Awk::RIOBase::operator Awk* () const
|
2009-01-17 08:57:27 +00:00
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
return this->run->awk;
|
2009-01-17 08:57:27 +00:00
|
|
|
}
|
|
|
|
|
2009-06-26 01:39:27 +00:00
|
|
|
Awk::RIOBase::operator Awk::awk_t* () const
|
2009-01-17 08:57:27 +00:00
|
|
|
{
|
2009-07-08 07:05:10 +00:00
|
|
|
QSE_ASSERT (qse_awk_rtx_getawk(this->run->rtx) == this->run->awk->awk);
|
|
|
|
return this->run->awk->awk;
|
2009-01-17 08:57:27 +00:00
|
|
|
}
|
|
|
|
|
2009-06-26 01:39:27 +00:00
|
|
|
Awk::RIOBase::operator Awk::rio_arg_t* () const
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2009-02-16 08:31:34 +00:00
|
|
|
return this->riod;
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-15 01:21:00 +00:00
|
|
|
|
2009-07-08 07:05:10 +00:00
|
|
|
Awk::RIOBase::operator Awk::Run* () const
|
|
|
|
{
|
|
|
|
return this->run;
|
|
|
|
}
|
|
|
|
|
2009-06-26 01:39:27 +00:00
|
|
|
Awk::RIOBase::operator Awk::rtx_t* () const
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
return this->run->rtx;
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-09-07 23:14:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
// Awk::Pipe
|
|
|
|
//////////////////////////////////////////////////////////////////
|
2007-09-07 23:14:00 +00:00
|
|
|
|
2009-07-07 06:37:25 +00:00
|
|
|
Awk::Pipe::Pipe (Run* run, rio_arg_t* riod): RIOBase (run, riod)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
|
|
|
}
|
2007-05-16 01:03:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
Awk::Pipe::Mode Awk::Pipe::getMode () const
|
|
|
|
{
|
2009-02-16 08:31:34 +00:00
|
|
|
return (Mode)riod->mode;
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
// Awk::File
|
|
|
|
//////////////////////////////////////////////////////////////////
|
2007-05-16 01:03:00 +00:00
|
|
|
|
2009-07-07 06:37:25 +00:00
|
|
|
Awk::File::File (Run* run, rio_arg_t* riod): RIOBase (run, riod)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
|
|
|
}
|
2007-05-16 01:03:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
Awk::File::Mode Awk::File::getMode () const
|
|
|
|
{
|
2009-02-16 08:31:34 +00:00
|
|
|
return (Mode)riod->mode;
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-16 01:03:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
// Awk::Console
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
|
2009-07-07 06:37:25 +00:00
|
|
|
Awk::Console::Console (Run* run, rio_arg_t* riod):
|
|
|
|
RIOBase (run, riod), filename (QSE_NULL)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
|
|
|
}
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
Awk::Console::~Console ()
|
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
if (filename != QSE_NULL)
|
2007-05-15 01:21:00 +00:00
|
|
|
{
|
2009-01-18 00:44:31 +00:00
|
|
|
qse_awk_free ((awk_t*)this, filename);
|
2007-05-15 01:21:00 +00:00
|
|
|
}
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-15 01:21:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
int Awk::Console::setFileName (const char_t* name)
|
|
|
|
{
|
2009-07-08 07:05:10 +00:00
|
|
|
if (this->getMode() == READ)
|
2007-05-15 01:21:00 +00:00
|
|
|
{
|
2009-01-31 22:03:05 +00:00
|
|
|
return qse_awk_rtx_setfilename (
|
2009-07-07 06:37:25 +00:00
|
|
|
this->run->rtx, name, qse_strlen(name));
|
2007-05-15 01:21:00 +00:00
|
|
|
}
|
2007-09-11 22:42:00 +00:00
|
|
|
else
|
2007-05-06 19:44:00 +00:00
|
|
|
{
|
2009-01-31 22:03:05 +00:00
|
|
|
return qse_awk_rtx_setofilename (
|
2009-07-07 06:37:25 +00:00
|
|
|
this->run->rtx, name, qse_strlen(name));
|
2007-05-06 19:44:00 +00:00
|
|
|
}
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
|
|
|
|
2007-10-30 00:20:00 +00:00
|
|
|
int Awk::Console::setFNR (long_t fnr)
|
|
|
|
{
|
2009-07-11 08:05:51 +00:00
|
|
|
val_t* tmp;
|
2007-10-30 00:20:00 +00:00
|
|
|
int n;
|
|
|
|
|
2009-07-07 06:37:25 +00:00
|
|
|
tmp = qse_awk_rtx_makeintval (this->run->rtx, fnr);
|
2008-12-21 21:35:07 +00:00
|
|
|
if (tmp == QSE_NULL) return -1;
|
2007-10-30 00:20:00 +00:00
|
|
|
|
2009-07-07 06:37:25 +00:00
|
|
|
qse_awk_rtx_refupval (this->run->rtx, tmp);
|
|
|
|
n = qse_awk_rtx_setgbl (this->run->rtx, QSE_AWK_GBL_FNR, tmp);
|
|
|
|
qse_awk_rtx_refdownval (this->run->rtx, tmp);
|
2007-10-30 00:20:00 +00:00
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
Awk::Console::Mode Awk::Console::getMode () const
|
|
|
|
{
|
2009-02-16 08:31:34 +00:00
|
|
|
return (Mode)riod->mode;
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
|
|
|
|
2009-07-11 08:05:51 +00:00
|
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
// Awk::Value
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
const Awk::char_t* Awk::Value::EMPTY_STRING = QSE_T("");
|
2009-07-14 02:51:23 +00:00
|
|
|
Awk::Value::IndexIterator Awk::Value::IndexIterator::END;
|
|
|
|
|
|
|
|
Awk::Value::IntIndex::IntIndex (long_t x)
|
|
|
|
{
|
|
|
|
ptr = buf;
|
|
|
|
len = 0;
|
|
|
|
|
|
|
|
#define NTOC(n) ((n) + QSE_T('0'))
|
|
|
|
|
|
|
|
int base = 10;
|
|
|
|
long_t last = x % base;
|
|
|
|
long_t y = 0;
|
|
|
|
int dig = 0;
|
|
|
|
|
|
|
|
if (x < 0) buf[len++] = QSE_T('-');
|
|
|
|
|
|
|
|
x = x / base;
|
|
|
|
if (x < 0) x = -x;
|
|
|
|
|
|
|
|
while (x > 0)
|
|
|
|
{
|
|
|
|
y = y * base + (x % base);
|
|
|
|
x = x / base;
|
|
|
|
dig++;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (y > 0)
|
|
|
|
{
|
|
|
|
buf[len++] = NTOC (y % base);
|
|
|
|
y = y / base;
|
|
|
|
dig--;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (dig > 0)
|
|
|
|
{
|
|
|
|
dig--;
|
|
|
|
buf[len++] = QSE_T('0');
|
|
|
|
}
|
|
|
|
if (last < 0) last = -last;
|
|
|
|
buf[len++] = NTOC(last);
|
|
|
|
|
|
|
|
buf[len] = QSE_T('\0');
|
|
|
|
|
|
|
|
#undef NTOC
|
|
|
|
}
|
2009-07-13 07:06:01 +00:00
|
|
|
|
|
|
|
void* Awk::Value::operator new (size_t n, Run* run) throw ()
|
|
|
|
{
|
|
|
|
void* ptr = qse_awk_rtx_alloc (run->rtx, QSE_SIZEOF(run) + n);
|
|
|
|
if (ptr == QSE_NULL) return QSE_NULL;
|
|
|
|
|
|
|
|
*(Run**)ptr = run;
|
|
|
|
return (char*)ptr+QSE_SIZEOF(run);
|
|
|
|
}
|
|
|
|
|
|
|
|
void* Awk::Value::operator new[] (size_t n, Run* run) throw ()
|
|
|
|
{
|
|
|
|
void* ptr = qse_awk_rtx_alloc (run->rtx, QSE_SIZEOF(run) + n);
|
|
|
|
if (ptr == QSE_NULL) return QSE_NULL;
|
|
|
|
|
|
|
|
*(Run**)ptr = run;
|
|
|
|
return (char*)ptr+QSE_SIZEOF(run);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if !defined(__BORLANDC__)
|
|
|
|
void Awk::Value::operator delete (void* ptr, Run* run) throw ()
|
|
|
|
{
|
|
|
|
qse_awk_rtx_free (run->rtx, (char*)ptr-QSE_SIZEOF(run));
|
|
|
|
}
|
|
|
|
|
|
|
|
void Awk::Value::operator delete[] (void* ptr, Run* run) throw ()
|
|
|
|
{
|
|
|
|
qse_awk_rtx_free (run->rtx, (char*)ptr-QSE_SIZEOF(run));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
void Awk::Value::operator delete (void* ptr) throw ()
|
|
|
|
{
|
|
|
|
void* p = (char*)ptr-QSE_SIZEOF(Run*);
|
|
|
|
qse_awk_rtx_free ((*(Run**)p)->rtx, p);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Awk::Value::operator delete[] (void* ptr) throw ()
|
|
|
|
{
|
|
|
|
void* p = (char*)ptr-QSE_SIZEOF(Run*);
|
|
|
|
qse_awk_rtx_free ((*(Run**)p)->rtx, p);
|
|
|
|
}
|
|
|
|
|
|
|
|
Awk::Value::Value (): run (QSE_NULL), val (qse_awk_val_nil)
|
|
|
|
{
|
|
|
|
cached.str.ptr = QSE_NULL;
|
|
|
|
cached.str.len = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
Awk::Value::Value (Run& run): run (&run), val (qse_awk_val_nil)
|
|
|
|
{
|
|
|
|
cached.str.ptr = QSE_NULL;
|
|
|
|
cached.str.len = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
Awk::Value::Value (Run* run): run (run), val (qse_awk_val_nil)
|
|
|
|
{
|
|
|
|
cached.str.ptr = QSE_NULL;
|
|
|
|
cached.str.len = 0;
|
|
|
|
}
|
|
|
|
|
2009-07-11 08:05:51 +00:00
|
|
|
Awk::Value::Value (const Value& v): run (v.run), val (v.val)
|
|
|
|
{
|
|
|
|
if (run != QSE_NULL)
|
|
|
|
qse_awk_rtx_refupval (run->rtx, val);
|
2009-07-13 07:06:01 +00:00
|
|
|
|
|
|
|
cached.str.ptr = QSE_NULL;
|
|
|
|
cached.str.len = 0;
|
2009-07-11 08:05:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Awk::Value::~Value ()
|
|
|
|
{
|
|
|
|
if (run != QSE_NULL)
|
2009-07-13 07:06:01 +00:00
|
|
|
{
|
2009-07-11 08:05:51 +00:00
|
|
|
qse_awk_rtx_refdownval (run->rtx, val);
|
2009-07-13 07:06:01 +00:00
|
|
|
if (cached.str.ptr != QSE_NULL)
|
|
|
|
qse_awk_rtx_free (run->rtx, cached.str.ptr);
|
|
|
|
}
|
2009-07-11 08:05:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Awk::Value& Awk::Value::operator= (const Value& v)
|
|
|
|
{
|
2009-07-13 07:06:01 +00:00
|
|
|
if (this == &v) return *this;
|
|
|
|
|
2009-07-11 08:05:51 +00:00
|
|
|
if (run != QSE_NULL)
|
2009-07-13 07:06:01 +00:00
|
|
|
{
|
2009-07-11 08:05:51 +00:00
|
|
|
qse_awk_rtx_refdownval (run->rtx, val);
|
2009-07-13 07:06:01 +00:00
|
|
|
if (cached.str.ptr != QSE_NULL)
|
|
|
|
{
|
|
|
|
qse_awk_rtx_free (run->rtx, cached.str.ptr);
|
|
|
|
cached.str.ptr = QSE_NULL;
|
|
|
|
cached.str.len = 0;
|
|
|
|
}
|
|
|
|
}
|
2009-07-11 08:05:51 +00:00
|
|
|
|
|
|
|
run = v.run;
|
|
|
|
val = v.val;
|
|
|
|
|
|
|
|
if (run != QSE_NULL)
|
|
|
|
qse_awk_rtx_refupval (run->rtx, val);
|
|
|
|
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Awk::Value::clear ()
|
|
|
|
{
|
|
|
|
if (run != QSE_NULL)
|
|
|
|
{
|
|
|
|
qse_awk_rtx_refdownval (run->rtx, val);
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
if (cached.str.ptr != QSE_NULL)
|
|
|
|
{
|
|
|
|
qse_awk_rtx_free (run->rtx, cached.str.ptr);
|
|
|
|
cached.str.ptr = QSE_NULL;
|
|
|
|
cached.str.len = 0;
|
|
|
|
}
|
|
|
|
|
2009-07-11 08:05:51 +00:00
|
|
|
run = QSE_NULL;
|
|
|
|
val = qse_awk_val_nil;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-11 21:01:36 +00:00
|
|
|
Awk::Value::operator Awk::long_t () const
|
|
|
|
{
|
|
|
|
long_t v;
|
2009-07-13 07:06:01 +00:00
|
|
|
if (getInt (&v) <= -1) v = 0;
|
2009-07-11 21:01:36 +00:00
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
Awk::Value::operator Awk::real_t () const
|
|
|
|
{
|
|
|
|
real_t v;
|
2009-07-13 07:06:01 +00:00
|
|
|
if (getReal (&v) <= -1) v = 0.0;
|
2009-07-11 21:01:36 +00:00
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
Awk::Value::operator const Awk::char_t* () const
|
|
|
|
{
|
|
|
|
const char_t* ptr;
|
|
|
|
size_t len;
|
2009-07-13 07:06:01 +00:00
|
|
|
if (getStr (&ptr, &len) <= -1) ptr = QSE_T("");
|
2009-07-11 21:01:36 +00:00
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
int Awk::Value::getInt (long_t* v) const
|
2009-07-11 21:01:36 +00:00
|
|
|
{
|
|
|
|
long_t lv = 0;
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
QSE_ASSERT (val != QSE_NULL);
|
|
|
|
|
|
|
|
if (run != QSE_NULL &&
|
|
|
|
val->type != QSE_AWK_VAL_NIL &&
|
|
|
|
val->type != QSE_AWK_VAL_MAP)
|
2009-07-11 21:01:36 +00:00
|
|
|
{
|
|
|
|
real_t rv;
|
|
|
|
int n = qse_awk_rtx_valtonum (run->rtx, val, &lv, &rv);
|
2009-07-14 02:51:23 +00:00
|
|
|
if (n <= -1)
|
|
|
|
{
|
|
|
|
run->awk->retrieveError (run->rtx);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-07-11 21:01:36 +00:00
|
|
|
if (n >= 1) lv = rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
*v = lv;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
int Awk::Value::getReal (real_t* v) const
|
2009-07-11 21:01:36 +00:00
|
|
|
{
|
|
|
|
real_t rv = 0;
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
QSE_ASSERT (val != QSE_NULL);
|
|
|
|
|
|
|
|
if (run != QSE_NULL &&
|
|
|
|
val->type != QSE_AWK_VAL_NIL &&
|
|
|
|
val->type != QSE_AWK_VAL_MAP)
|
2009-07-11 21:01:36 +00:00
|
|
|
{
|
|
|
|
long_t lv;
|
|
|
|
int n = qse_awk_rtx_valtonum (run->rtx, val, &lv, &rv);
|
2009-07-14 02:51:23 +00:00
|
|
|
if (n <= -1)
|
|
|
|
{
|
|
|
|
run->awk->retrieveError (run->rtx);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-07-11 21:01:36 +00:00
|
|
|
if (n == 0) rv = lv;
|
|
|
|
}
|
|
|
|
|
|
|
|
*v = rv;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
int Awk::Value::getStr (const char_t** str, size_t* len) const
|
2009-07-11 21:01:36 +00:00
|
|
|
{
|
2009-07-13 07:06:01 +00:00
|
|
|
const char_t* p = EMPTY_STRING;
|
|
|
|
size_t l = 0;
|
2009-07-11 21:01:36 +00:00
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
QSE_ASSERT (val != QSE_NULL);
|
2009-07-11 21:01:36 +00:00
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
if (run != QSE_NULL &&
|
|
|
|
val->type != QSE_AWK_VAL_NIL &&
|
|
|
|
val->type != QSE_AWK_VAL_MAP)
|
2009-07-11 21:01:36 +00:00
|
|
|
{
|
2009-07-13 07:06:01 +00:00
|
|
|
if (val->type == QSE_AWK_VAL_STR)
|
|
|
|
{
|
|
|
|
p = ((qse_awk_val_str_t*)val)->ptr;
|
|
|
|
l = ((qse_awk_val_str_t*)val)->len;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (cached.str.ptr == QSE_NULL)
|
|
|
|
{
|
|
|
|
qse_awk_rtx_valtostr_out_t out;
|
|
|
|
out.type = QSE_AWK_RTX_VALTOSTR_CPLDUP;
|
|
|
|
if (qse_awk_rtx_valtostr (
|
|
|
|
run->rtx, val, &out) == QSE_NULL)
|
|
|
|
{
|
2009-07-14 02:51:23 +00:00
|
|
|
run->awk->retrieveError (run->rtx);
|
2009-07-13 07:06:01 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
p = out.u.cpldup.ptr;
|
|
|
|
l = out.u.cpldup.len;
|
|
|
|
|
|
|
|
cached.str.ptr = out.u.cpldup.ptr;
|
|
|
|
cached.str.len = out.u.cpldup.len;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
p = cached.str.ptr;
|
|
|
|
l = cached.str.len;
|
|
|
|
}
|
|
|
|
}
|
2009-07-11 21:01:36 +00:00
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
*str = p;
|
|
|
|
*len = l;
|
|
|
|
|
2009-07-11 21:01:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
int Awk::Value::setVal (val_t* v)
|
2009-07-11 08:05:51 +00:00
|
|
|
{
|
|
|
|
if (run == QSE_NULL) return -1;
|
2009-07-13 07:06:01 +00:00
|
|
|
return setVal (run, v);
|
2009-07-11 08:05:51 +00:00
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
int Awk::Value::setVal (Run* r, val_t* v)
|
2009-07-11 08:05:51 +00:00
|
|
|
{
|
|
|
|
if (run != QSE_NULL)
|
2009-07-13 07:06:01 +00:00
|
|
|
{
|
2009-07-11 08:05:51 +00:00
|
|
|
qse_awk_rtx_refdownval (run->rtx, val);
|
2009-07-13 07:06:01 +00:00
|
|
|
if (cached.str.ptr != QSE_NULL)
|
|
|
|
{
|
|
|
|
qse_awk_rtx_free (run->rtx, cached.str.ptr);
|
|
|
|
cached.str.ptr = QSE_NULL;
|
|
|
|
cached.str.len = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
QSE_ASSERT (cached.str.ptr == QSE_NULL);
|
2009-07-11 08:05:51 +00:00
|
|
|
qse_awk_rtx_refupval (r->rtx, v);
|
|
|
|
|
|
|
|
run = r;
|
|
|
|
val = v;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
int Awk::Value::setInt (long_t v)
|
2009-07-11 08:05:51 +00:00
|
|
|
{
|
|
|
|
if (run == QSE_NULL) return -1;
|
2009-07-13 07:06:01 +00:00
|
|
|
return setInt (run, v);
|
2009-07-11 08:05:51 +00:00
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
int Awk::Value::setInt (Run* r, long_t v)
|
2009-07-11 08:05:51 +00:00
|
|
|
{
|
|
|
|
val_t* tmp;
|
|
|
|
tmp = qse_awk_rtx_makeintval (r->rtx, v);
|
2009-07-14 02:51:23 +00:00
|
|
|
if (tmp == QSE_NULL)
|
|
|
|
{
|
|
|
|
r->awk->retrieveError (r->rtx);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-07-11 08:05:51 +00:00
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
int n = setVal (r, tmp);
|
2009-07-11 08:05:51 +00:00
|
|
|
QSE_ASSERT (n == 0);
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
int Awk::Value::setReal (real_t v)
|
2009-07-11 08:05:51 +00:00
|
|
|
{
|
|
|
|
if (run == QSE_NULL) return -1;
|
2009-07-13 07:06:01 +00:00
|
|
|
return setReal (run, v);
|
2009-07-11 08:05:51 +00:00
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
int Awk::Value::setReal (Run* r, real_t v)
|
2009-07-11 08:05:51 +00:00
|
|
|
{
|
|
|
|
val_t* tmp;
|
|
|
|
tmp = qse_awk_rtx_makerealval (r->rtx, v);
|
2009-07-14 02:51:23 +00:00
|
|
|
if (tmp == QSE_NULL)
|
|
|
|
{
|
|
|
|
r->awk->retrieveError (r->rtx);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-07-11 08:05:51 +00:00
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
int n = setVal (r, tmp);
|
2009-07-11 08:05:51 +00:00
|
|
|
QSE_ASSERT (n == 0);
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
int Awk::Value::setStr (const char_t* str, size_t len)
|
2009-07-11 08:05:51 +00:00
|
|
|
{
|
|
|
|
if (run == QSE_NULL) return -1;
|
2009-07-13 07:06:01 +00:00
|
|
|
return setStr (run, str, len);
|
2009-07-11 08:05:51 +00:00
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
int Awk::Value::setStr (Run* r, const char_t* str, size_t len)
|
2009-07-11 08:05:51 +00:00
|
|
|
{
|
|
|
|
val_t* tmp;
|
|
|
|
tmp = qse_awk_rtx_makestrval (r->rtx, str, len);
|
2009-07-14 02:51:23 +00:00
|
|
|
if (tmp == QSE_NULL)
|
|
|
|
{
|
|
|
|
r->awk->retrieveError (r->rtx);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-07-11 08:05:51 +00:00
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
int n = setVal (r, tmp);
|
2009-07-11 21:01:36 +00:00
|
|
|
QSE_ASSERT (n == 0);
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
int Awk::Value::setStr (const char_t* str)
|
2009-07-11 21:01:36 +00:00
|
|
|
{
|
|
|
|
if (run == QSE_NULL) return -1;
|
2009-07-13 07:06:01 +00:00
|
|
|
return setStr (run, str);
|
2009-07-11 21:01:36 +00:00
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
int Awk::Value::setStr (Run* r, const char_t* str)
|
2009-07-11 21:01:36 +00:00
|
|
|
{
|
|
|
|
val_t* tmp;
|
|
|
|
tmp = qse_awk_rtx_makestrval0 (r->rtx, str);
|
2009-07-14 02:51:23 +00:00
|
|
|
if (tmp == QSE_NULL)
|
|
|
|
{
|
|
|
|
r->awk->retrieveError (r->rtx);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-07-11 21:01:36 +00:00
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
int n = setVal (r, tmp);
|
2009-07-11 08:05:51 +00:00
|
|
|
QSE_ASSERT (n == 0);
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2009-07-14 02:51:23 +00:00
|
|
|
int Awk::Value::setIndexedVal (const Index& idx, val_t* v)
|
2009-07-11 08:05:51 +00:00
|
|
|
{
|
|
|
|
if (run == QSE_NULL) return -1;
|
2009-07-14 02:51:23 +00:00
|
|
|
return setIndexedVal (run, idx, v);
|
2009-07-11 08:05:51 +00:00
|
|
|
}
|
|
|
|
|
2009-07-14 02:51:23 +00:00
|
|
|
int Awk::Value::setIndexedVal (Run* r, const Index& idx, val_t* v)
|
2009-07-11 08:05:51 +00:00
|
|
|
{
|
2009-07-14 02:51:23 +00:00
|
|
|
QSE_ASSERT (r != QSE_NULL);
|
|
|
|
|
2009-07-11 08:05:51 +00:00
|
|
|
if (val->type != QSE_AWK_VAL_MAP)
|
|
|
|
{
|
|
|
|
/* the previous value is not a map.
|
|
|
|
* a new map value needs to be created first */
|
2009-07-14 02:51:23 +00:00
|
|
|
val_t* map = qse_awk_rtx_makemapval (r->rtx);
|
|
|
|
if (map == QSE_NULL)
|
|
|
|
{
|
|
|
|
r->awk->retrieveError (r->rtx);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-07-11 08:05:51 +00:00
|
|
|
|
|
|
|
qse_awk_rtx_refupval (r->rtx, map);
|
|
|
|
qse_awk_rtx_refupval (r->rtx, v);
|
|
|
|
|
|
|
|
/* update the map with a given value */
|
|
|
|
pair_t* pair = qse_map_upsert (
|
|
|
|
((qse_awk_val_map_t*)map)->map,
|
2009-07-14 02:51:23 +00:00
|
|
|
(char_t*)idx.ptr, idx.len, v, 0);
|
2009-07-11 08:05:51 +00:00
|
|
|
if (pair == QSE_NULL)
|
|
|
|
{
|
|
|
|
qse_awk_rtx_refdownval (r->rtx, v);
|
|
|
|
qse_awk_rtx_refdownval (r->rtx, map);
|
2009-07-14 02:51:23 +00:00
|
|
|
r->setError (ERR_NOMEM, 0, QSE_NULL, 0);
|
|
|
|
r->awk->retrieveError (r->rtx);
|
2009-07-11 08:05:51 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (run != QSE_NULL)
|
|
|
|
qse_awk_rtx_refdownval (run->rtx, val);
|
|
|
|
|
|
|
|
run = r;
|
|
|
|
val = map;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
QSE_ASSERT (run != QSE_NULL);
|
|
|
|
|
|
|
|
// if the previous value is a map, things are a bit simpler
|
|
|
|
// however it needs to check if the runtime context matches
|
|
|
|
// with the previous one.
|
|
|
|
if (run != r)
|
|
|
|
{
|
|
|
|
// it can't span across multiple runtime contexts
|
|
|
|
run->setError (ERR_INVAL);
|
2009-07-14 02:51:23 +00:00
|
|
|
run->awk->retrieveError (run->rtx);
|
2009-07-11 08:05:51 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
qse_awk_rtx_refupval (r->rtx, v);
|
|
|
|
|
|
|
|
pair_t* pair = qse_map_upsert (
|
|
|
|
((qse_awk_val_map_t*)val)->map,
|
2009-07-14 02:51:23 +00:00
|
|
|
(char_t*)idx.ptr, idx.len, v, 0);
|
2009-07-11 08:05:51 +00:00
|
|
|
if (pair == QSE_NULL)
|
|
|
|
{
|
|
|
|
qse_awk_rtx_refdownval (r->rtx, v);
|
|
|
|
run->setError (ERR_NOMEM);
|
2009-07-14 02:51:23 +00:00
|
|
|
run->awk->retrieveError (run->rtx);
|
2009-07-11 08:05:51 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-14 02:51:23 +00:00
|
|
|
int Awk::Value::setIndexedInt (const Index& idx, long_t v)
|
2009-07-11 08:05:51 +00:00
|
|
|
{
|
|
|
|
if (run == QSE_NULL) return -1;
|
2009-07-14 02:51:23 +00:00
|
|
|
return setIndexedInt (run, idx, v);
|
2009-07-11 08:05:51 +00:00
|
|
|
}
|
|
|
|
|
2009-07-14 02:51:23 +00:00
|
|
|
int Awk::Value::setIndexedInt (Run* r, const Index& idx, long_t v)
|
2009-07-11 08:05:51 +00:00
|
|
|
{
|
|
|
|
val_t* tmp;
|
|
|
|
tmp = qse_awk_rtx_makeintval (r->rtx, v);
|
2009-07-14 02:51:23 +00:00
|
|
|
if (tmp == QSE_NULL)
|
|
|
|
{
|
|
|
|
r->awk->retrieveError (r->rtx);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-07-11 08:05:51 +00:00
|
|
|
|
|
|
|
qse_awk_rtx_refupval (r->rtx, tmp);
|
2009-07-14 02:51:23 +00:00
|
|
|
int n = setIndexedVal (r, idx, tmp);
|
2009-07-11 08:05:51 +00:00
|
|
|
qse_awk_rtx_refdownval (r->rtx, tmp);
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2009-07-14 02:51:23 +00:00
|
|
|
int Awk::Value::setIndexedReal (const Index& idx, real_t v)
|
2009-07-11 08:05:51 +00:00
|
|
|
{
|
|
|
|
if (run == QSE_NULL) return -1;
|
2009-07-14 02:51:23 +00:00
|
|
|
return setIndexedReal (run, idx, v);
|
2009-07-11 08:05:51 +00:00
|
|
|
}
|
|
|
|
|
2009-07-14 02:51:23 +00:00
|
|
|
int Awk::Value::setIndexedReal (Run* r, const Index& idx, real_t v)
|
2009-07-11 08:05:51 +00:00
|
|
|
{
|
|
|
|
val_t* tmp;
|
|
|
|
tmp = qse_awk_rtx_makerealval (r->rtx, v);
|
2009-07-14 02:51:23 +00:00
|
|
|
if (tmp == QSE_NULL)
|
|
|
|
{
|
|
|
|
r->awk->retrieveError (r->rtx);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-07-11 08:05:51 +00:00
|
|
|
|
|
|
|
qse_awk_rtx_refupval (r->rtx, tmp);
|
2009-07-14 02:51:23 +00:00
|
|
|
int n = setIndexedVal (r, idx, tmp);
|
2009-07-11 08:05:51 +00:00
|
|
|
qse_awk_rtx_refdownval (r->rtx, tmp);
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2009-07-14 02:51:23 +00:00
|
|
|
int Awk::Value::setIndexedStr (const Index& idx, const char_t* str, size_t len)
|
2009-07-11 08:05:51 +00:00
|
|
|
{
|
|
|
|
if (run == QSE_NULL) return -1;
|
2009-07-14 02:51:23 +00:00
|
|
|
return setIndexedStr (run, idx, str, len);
|
2009-07-11 08:05:51 +00:00
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
int Awk::Value::setIndexedStr (
|
2009-07-14 02:51:23 +00:00
|
|
|
Run* r, const Index& idx, const char_t* str, size_t len)
|
2009-07-11 08:05:51 +00:00
|
|
|
{
|
|
|
|
val_t* tmp;
|
|
|
|
tmp = qse_awk_rtx_makestrval (r->rtx, str, len);
|
2009-07-14 02:51:23 +00:00
|
|
|
if (tmp == QSE_NULL)
|
|
|
|
{
|
|
|
|
r->awk->retrieveError (r->rtx);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-07-11 08:05:51 +00:00
|
|
|
|
|
|
|
qse_awk_rtx_refupval (r->rtx, tmp);
|
2009-07-14 02:51:23 +00:00
|
|
|
int n = setIndexedVal (r, idx, tmp);
|
2009-07-13 07:06:01 +00:00
|
|
|
qse_awk_rtx_refdownval (r->rtx, tmp);
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2009-07-14 02:51:23 +00:00
|
|
|
int Awk::Value::setIndexedStr (const Index& idx, const char_t* str)
|
2009-07-13 07:06:01 +00:00
|
|
|
{
|
|
|
|
if (run == QSE_NULL) return -1;
|
2009-07-14 02:51:23 +00:00
|
|
|
return setIndexedStr (run, idx, str);
|
2009-07-13 07:06:01 +00:00
|
|
|
}
|
|
|
|
|
2009-07-14 02:51:23 +00:00
|
|
|
int Awk::Value::setIndexedStr (Run* r, const Index& idx, const char_t* str)
|
2009-07-13 07:06:01 +00:00
|
|
|
{
|
|
|
|
val_t* tmp;
|
|
|
|
tmp = qse_awk_rtx_makestrval0 (r->rtx, str);
|
2009-07-14 02:51:23 +00:00
|
|
|
if (tmp == QSE_NULL)
|
|
|
|
{
|
|
|
|
r->awk->retrieveError (r->rtx);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-07-13 07:06:01 +00:00
|
|
|
|
|
|
|
qse_awk_rtx_refupval (r->rtx, tmp);
|
2009-07-14 02:51:23 +00:00
|
|
|
int n = setIndexedVal (r, idx, tmp);
|
2009-07-11 08:05:51 +00:00
|
|
|
qse_awk_rtx_refdownval (r->rtx, tmp);
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
|
2009-07-11 08:05:51 +00:00
|
|
|
bool Awk::Value::isIndexed () const
|
|
|
|
{
|
|
|
|
QSE_ASSERT (val != QSE_NULL);
|
|
|
|
return val->type == QSE_AWK_VAL_MAP;
|
|
|
|
}
|
|
|
|
|
2009-07-14 02:51:23 +00:00
|
|
|
int Awk::Value::getIndexed (const Index& idx, Value* v) const
|
2009-07-11 08:05:51 +00:00
|
|
|
{
|
|
|
|
QSE_ASSERT (val != QSE_NULL);
|
|
|
|
|
|
|
|
// not a map. v is just nil. not an error
|
|
|
|
if (val->type != QSE_AWK_VAL_MAP)
|
|
|
|
{
|
2009-07-14 02:51:23 +00:00
|
|
|
v->clear ();
|
2009-07-11 08:05:51 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// get the value from the map.
|
|
|
|
qse_awk_val_map_t* m = (qse_awk_val_map_t*)val;
|
2009-07-14 02:51:23 +00:00
|
|
|
pair_t* pair = qse_map_search (m->map, idx.ptr, idx.len);
|
2009-07-11 08:05:51 +00:00
|
|
|
|
|
|
|
// the key is not found. it is not an error. v is just nil
|
|
|
|
if (pair == QSE_NULL)
|
|
|
|
{
|
2009-07-14 02:51:23 +00:00
|
|
|
v->clear ();
|
2009-07-11 08:05:51 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// if v.set fails, it should return an error
|
2009-07-14 02:51:23 +00:00
|
|
|
return v->setVal (run, (val_t*)QSE_MAP_VPTR(pair));
|
|
|
|
}
|
|
|
|
|
|
|
|
Awk::Value::IndexIterator Awk::Value::getFirstIndex (Index* idx) const
|
|
|
|
{
|
|
|
|
QSE_ASSERT (val != QSE_NULL);
|
|
|
|
|
|
|
|
if (val->type != QSE_AWK_VAL_MAP) return IndexIterator::END;
|
|
|
|
|
|
|
|
size_t buckno;
|
|
|
|
qse_awk_val_map_t* m = (qse_awk_val_map_t*)val;
|
|
|
|
pair_t* pair = qse_map_getfirstpair (m->map, &buckno);
|
|
|
|
if (pair == QSE_NULL) return IndexIterator::END; // no more key
|
|
|
|
|
|
|
|
idx->ptr = (const char_t*)QSE_MAP_KPTR(pair);
|
|
|
|
idx->len = QSE_MAP_KLEN(pair);
|
|
|
|
|
|
|
|
return IndexIterator (pair, buckno);
|
|
|
|
}
|
|
|
|
|
|
|
|
Awk::Value::IndexIterator Awk::Value::getNextIndex (
|
|
|
|
Index* idx, const IndexIterator& iter) const
|
|
|
|
{
|
|
|
|
QSE_ASSERT (val != QSE_NULL);
|
|
|
|
|
|
|
|
if (val->type != QSE_AWK_VAL_MAP) return IndexIterator::END;
|
|
|
|
|
|
|
|
qse_awk_val_map_t* m = (qse_awk_val_map_t*)val;
|
|
|
|
|
|
|
|
pair_t* pair = (pair_t*)iter.pair;
|
|
|
|
size_t buckno = iter.buckno;
|
|
|
|
|
|
|
|
pair = qse_map_getnextpair (m->map, pair, &buckno);
|
|
|
|
if (pair == QSE_NULL) return IndexIterator::END;
|
|
|
|
|
|
|
|
idx->ptr = (const char_t*)QSE_MAP_KPTR(pair);
|
|
|
|
idx->len = QSE_MAP_KLEN(pair);
|
|
|
|
|
|
|
|
return IndexIterator (pair, buckno);
|
2007-10-04 23:26:00 +00:00
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
#if 0
|
2007-10-02 00:22:00 +00:00
|
|
|
int Awk::Argument::getFirstIndex (Awk::Argument& val) const
|
|
|
|
{
|
|
|
|
val.clear ();
|
|
|
|
|
2008-12-21 21:35:07 +00:00
|
|
|
if (this->val == QSE_NULL) return -1;
|
2009-07-02 07:14:39 +00:00
|
|
|
if (this->val->type != QSE_AWK_VAL_MAP) return -1;
|
2007-10-02 00:22:00 +00:00
|
|
|
|
2008-12-21 21:35:07 +00:00
|
|
|
qse_size_t buckno;
|
|
|
|
qse_awk_val_map_t* m = (qse_awk_val_map_t*)this->val;
|
|
|
|
pair_t* pair = qse_map_getfirstpair (m->map, &buckno);
|
|
|
|
if (pair == QSE_NULL) return 0; // no more key
|
2007-10-02 00:22:00 +00:00
|
|
|
|
2008-09-28 03:51:23 +00:00
|
|
|
if (val.init (
|
2008-12-21 21:35:07 +00:00
|
|
|
(qse_char_t*)QSE_MAP_KPTR(pair),
|
|
|
|
QSE_MAP_KLEN(pair)) == -1) return -1;
|
2007-10-02 00:22:00 +00:00
|
|
|
|
|
|
|
// reuse the string field as an interator.
|
|
|
|
this->str.ptr = (char_t*)pair;
|
|
|
|
this->str.len = buckno;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Awk::Argument::getNextIndex (Awk::Argument& val) const
|
|
|
|
{
|
|
|
|
val.clear ();
|
|
|
|
|
2008-12-21 21:35:07 +00:00
|
|
|
if (this->val == QSE_NULL) return -1;
|
2009-07-02 07:14:39 +00:00
|
|
|
if (this->val->type != QSE_AWK_VAL_MAP) return -1;
|
2007-10-02 00:22:00 +00:00
|
|
|
|
2008-12-21 21:35:07 +00:00
|
|
|
qse_awk_val_map_t* m = (qse_awk_val_map_t*)this->val;
|
2007-10-02 00:22:00 +00:00
|
|
|
|
2008-02-13 01:39:56 +00:00
|
|
|
pair_t* pair = (pair_t*)this->str.ptr;
|
2008-12-21 21:35:07 +00:00
|
|
|
qse_size_t buckno = this->str.len;
|
2007-10-02 00:22:00 +00:00
|
|
|
|
2008-12-21 21:35:07 +00:00
|
|
|
pair = qse_map_getnextpair (m->map, pair, &buckno);
|
|
|
|
if (pair == QSE_NULL) return 0;
|
2007-10-02 00:22:00 +00:00
|
|
|
|
2008-09-28 03:51:23 +00:00
|
|
|
if (val.init (
|
2008-12-21 21:35:07 +00:00
|
|
|
(qse_char_t*)QSE_MAP_KPTR(pair),
|
|
|
|
QSE_MAP_KLEN(pair)) == -1) return -1;
|
2007-10-02 00:22:00 +00:00
|
|
|
|
|
|
|
// reuse the string field as an interator.
|
|
|
|
this->str.ptr = (char_t*)pair;
|
|
|
|
this->str.len = buckno;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
#endif
|
2007-05-11 10:07:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
// Awk::Run
|
|
|
|
//////////////////////////////////////////////////////////////////
|
2007-05-11 10:07:00 +00:00
|
|
|
|
2009-07-07 06:37:25 +00:00
|
|
|
Awk::Run::Run (Awk* awk): awk (awk), rtx (QSE_NULL)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
|
|
|
}
|
2007-05-12 19:14:00 +00:00
|
|
|
|
2009-07-09 07:01:45 +00:00
|
|
|
Awk::Run::Run (Awk* awk, rtx_t* rtx): awk (awk), rtx (rtx)
|
2007-09-25 00:12:00 +00:00
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
QSE_ASSERT (this->rtx != QSE_NULL);
|
2007-09-25 00:12:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Awk::Run::~Run ()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2007-10-10 16:03:00 +00:00
|
|
|
Awk::Run::operator Awk* () const
|
|
|
|
{
|
|
|
|
return this->awk;
|
|
|
|
}
|
|
|
|
|
2009-02-16 08:31:34 +00:00
|
|
|
Awk::Run::operator Awk::rtx_t* () const
|
2007-10-10 16:03:00 +00:00
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
return this->rtx;
|
2007-10-10 16:03:00 +00:00
|
|
|
}
|
|
|
|
|
2007-10-12 00:13:00 +00:00
|
|
|
void Awk::Run::stop () const
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
QSE_ASSERT (this->rtx != QSE_NULL);
|
|
|
|
qse_awk_rtx_stop (this->rtx);
|
2007-10-12 00:13:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool Awk::Run::isStop () const
|
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
QSE_ASSERT (this->rtx != QSE_NULL);
|
|
|
|
return qse_awk_rtx_shouldstop (this->rtx)? true: false;
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-11 10:07:00 +00:00
|
|
|
|
2009-06-02 07:33:01 +00:00
|
|
|
Awk::ErrorNumber Awk::Run::getErrorNumber () const
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
QSE_ASSERT (this->rtx != QSE_NULL);
|
|
|
|
return (ErrorNumber)qse_awk_rtx_geterrnum (this->rtx);
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-16 01:03:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
Awk::size_t Awk::Run::getErrorLine () const
|
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
QSE_ASSERT (this->rtx != QSE_NULL);
|
|
|
|
return qse_awk_rtx_geterrlin (this->rtx);
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-21 01:22:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
const Awk::char_t* Awk::Run::getErrorMessage () const
|
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
QSE_ASSERT (this->rtx != QSE_NULL);
|
|
|
|
return qse_awk_rtx_geterrmsg (this->rtx);
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
|
|
|
|
2009-06-02 07:33:01 +00:00
|
|
|
void Awk::Run::setError (ErrorNumber code)
|
2007-10-10 22:33:00 +00:00
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
QSE_ASSERT (this->rtx != QSE_NULL);
|
|
|
|
qse_awk_rtx_seterror (this->rtx, (errnum_t)code, 0, QSE_NULL);
|
2007-10-10 22:33:00 +00:00
|
|
|
}
|
|
|
|
|
2009-06-02 07:33:01 +00:00
|
|
|
void Awk::Run::setError (ErrorNumber code, size_t line)
|
2007-10-10 22:33:00 +00:00
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
QSE_ASSERT (this->rtx != QSE_NULL);
|
|
|
|
qse_awk_rtx_seterror (this->rtx, (errnum_t)code, line, QSE_NULL);
|
2007-10-10 22:33:00 +00:00
|
|
|
}
|
|
|
|
|
2009-06-02 07:33:01 +00:00
|
|
|
void Awk::Run::setError (ErrorNumber code, size_t line, const char_t* arg)
|
2007-10-10 22:33:00 +00:00
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
QSE_ASSERT (this->rtx != QSE_NULL);
|
2008-12-21 21:35:07 +00:00
|
|
|
qse_cstr_t x = { arg, qse_strlen(arg) };
|
2009-07-07 06:37:25 +00:00
|
|
|
qse_awk_rtx_seterror (this->rtx, (errnum_t)code, line, &x);
|
2007-10-10 22:33:00 +00:00
|
|
|
}
|
|
|
|
|
2007-10-02 00:22:00 +00:00
|
|
|
void Awk::Run::setError (
|
2009-06-02 07:33:01 +00:00
|
|
|
ErrorNumber code, size_t line, const char_t* arg, size_t len)
|
2007-10-02 00:22:00 +00:00
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
QSE_ASSERT (this->rtx != QSE_NULL);
|
2008-12-21 21:35:07 +00:00
|
|
|
qse_cstr_t x = { arg, len };
|
2009-07-07 06:37:25 +00:00
|
|
|
qse_awk_rtx_seterror (this->rtx, (errnum_t)code, line, &x);
|
2007-10-02 00:22:00 +00:00
|
|
|
}
|
|
|
|
|
2007-10-10 22:33:00 +00:00
|
|
|
void Awk::Run::setErrorWithMessage (
|
2009-06-02 07:33:01 +00:00
|
|
|
ErrorNumber code, size_t line, const char_t* msg)
|
2007-10-02 00:22:00 +00:00
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
QSE_ASSERT (this->rtx != QSE_NULL);
|
2009-06-15 02:40:52 +00:00
|
|
|
|
|
|
|
qse_awk_errinf_t errinf;
|
|
|
|
|
|
|
|
errinf.num = (errnum_t)code;
|
|
|
|
errinf.lin = line;
|
|
|
|
qse_strxcpy (errinf.msg, QSE_COUNTOF(errinf.msg), msg);
|
|
|
|
|
2009-07-07 06:37:25 +00:00
|
|
|
qse_awk_rtx_seterrinf (this->rtx, &errinf);
|
2007-10-02 00:22:00 +00:00
|
|
|
}
|
|
|
|
|
2007-09-25 00:12:00 +00:00
|
|
|
int Awk::Run::setGlobal (int id, long_t v)
|
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
QSE_ASSERT (this->rtx != QSE_NULL);
|
2007-09-25 00:12:00 +00:00
|
|
|
|
2009-07-11 08:05:51 +00:00
|
|
|
val_t* tmp = qse_awk_rtx_makeintval (this->rtx, v);
|
2008-12-21 21:35:07 +00:00
|
|
|
if (tmp == QSE_NULL) return -1;
|
2007-09-25 00:12:00 +00:00
|
|
|
|
2009-07-07 06:37:25 +00:00
|
|
|
qse_awk_rtx_refupval (this->rtx, tmp);
|
|
|
|
int n = qse_awk_rtx_setgbl (this->rtx, id, tmp);
|
|
|
|
qse_awk_rtx_refdownval (this->rtx, tmp);
|
2007-09-25 00:12:00 +00:00
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Awk::Run::setGlobal (int id, real_t v)
|
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
QSE_ASSERT (this->rtx != QSE_NULL);
|
2007-09-25 00:12:00 +00:00
|
|
|
|
2009-07-11 08:05:51 +00:00
|
|
|
val_t* tmp = qse_awk_rtx_makerealval (this->rtx, v);
|
2008-12-21 21:35:07 +00:00
|
|
|
if (tmp == QSE_NULL) return -1;
|
2007-09-25 00:12:00 +00:00
|
|
|
|
2009-07-07 06:37:25 +00:00
|
|
|
qse_awk_rtx_refupval (this->rtx, tmp);
|
|
|
|
int n = qse_awk_rtx_setgbl (this->rtx, id, tmp);
|
|
|
|
qse_awk_rtx_refdownval (this->rtx, tmp);
|
2007-09-25 00:12:00 +00:00
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Awk::Run::setGlobal (int id, const char_t* ptr, size_t len)
|
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
QSE_ASSERT (this->rtx != QSE_NULL);
|
2007-09-25 00:12:00 +00:00
|
|
|
|
2009-07-11 08:05:51 +00:00
|
|
|
val_t* tmp = qse_awk_rtx_makestrval (this->rtx, ptr, len);
|
2008-12-21 21:35:07 +00:00
|
|
|
if (tmp == QSE_NULL) return -1;
|
2007-09-25 00:12:00 +00:00
|
|
|
|
2009-07-07 06:37:25 +00:00
|
|
|
qse_awk_rtx_refupval (this->rtx, tmp);
|
|
|
|
int n = qse_awk_rtx_setgbl (this->rtx, id, tmp);
|
|
|
|
qse_awk_rtx_refdownval (this->rtx, tmp);
|
2007-09-25 00:12:00 +00:00
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
int Awk::Run::setGlobal (int id, const Value& gbl)
|
2007-10-08 18:50:00 +00:00
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
QSE_ASSERT (this->rtx != QSE_NULL);
|
2009-07-13 07:06:01 +00:00
|
|
|
return qse_awk_rtx_setgbl (this->rtx, id, (val_t*)gbl);
|
2007-10-08 18:50:00 +00:00
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
int Awk::Run::getGlobal (int id, Value& g) const
|
2007-09-25 00:12:00 +00:00
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
QSE_ASSERT (this->rtx != QSE_NULL);
|
2009-07-13 07:06:01 +00:00
|
|
|
return g.setVal ((Run*)this, qse_awk_rtx_getgbl (this->rtx, id));
|
2007-10-08 18:50:00 +00:00
|
|
|
}
|
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
// Awk
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
|
2009-05-21 04:44:47 +00:00
|
|
|
Awk::Awk () throw (): awk (QSE_NULL), functionMap (QSE_NULL),
|
2009-07-10 06:46:14 +00:00
|
|
|
sourceIn (this, Source::READ), sourceOut (this, Source::WRITE),
|
2009-07-09 07:01:45 +00:00
|
|
|
errnum (ERR_NOERR), errlin (0), runCallback (false),
|
|
|
|
runctx (this)
|
2007-09-11 22:42:00 +00:00
|
|
|
|
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
this->errmsg[0] = QSE_T('\0');
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-21 01:22:00 +00:00
|
|
|
|
2007-10-10 16:03:00 +00:00
|
|
|
Awk::operator Awk::awk_t* () const
|
|
|
|
{
|
|
|
|
return this->awk;
|
|
|
|
}
|
|
|
|
|
2009-06-02 07:33:01 +00:00
|
|
|
Awk::ErrorNumber Awk::getErrorNumber () const
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
|
|
|
return this->errnum;
|
|
|
|
}
|
|
|
|
|
|
|
|
Awk::size_t Awk::getErrorLine () const
|
|
|
|
{
|
|
|
|
return this->errlin;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Awk::char_t* Awk::getErrorMessage () const
|
|
|
|
{
|
|
|
|
return this->errmsg;
|
|
|
|
}
|
|
|
|
|
2009-06-02 07:33:01 +00:00
|
|
|
void Awk::setError (ErrorNumber code)
|
2007-10-10 22:33:00 +00:00
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
setError (code, 0, QSE_NULL, 0);
|
2007-10-10 22:33:00 +00:00
|
|
|
}
|
|
|
|
|
2009-06-02 07:33:01 +00:00
|
|
|
void Awk::setError (ErrorNumber code, size_t line)
|
2007-10-10 22:33:00 +00:00
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
setError (code, line, QSE_NULL, 0);
|
2007-10-10 22:33:00 +00:00
|
|
|
}
|
|
|
|
|
2009-06-02 07:33:01 +00:00
|
|
|
void Awk::setError (ErrorNumber code, size_t line, const char_t* arg)
|
2007-10-10 22:33:00 +00:00
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
setError (code, line, arg, qse_strlen(arg));
|
2007-10-10 22:33:00 +00:00
|
|
|
}
|
|
|
|
|
2009-06-02 07:33:01 +00:00
|
|
|
void Awk::setError (ErrorNumber code, size_t line, const char_t* arg, size_t len)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
if (awk != QSE_NULL)
|
2007-05-21 01:22:00 +00:00
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
qse_cstr_t x = { arg, len };
|
2009-06-02 03:34:34 +00:00
|
|
|
qse_awk_seterror (awk, (errnum_t)code, line, &x);
|
2007-09-11 22:42:00 +00:00
|
|
|
retrieveError ();
|
2007-05-21 01:22:00 +00:00
|
|
|
}
|
2007-09-11 22:42:00 +00:00
|
|
|
else
|
2007-05-21 01:22:00 +00:00
|
|
|
{
|
2007-09-11 22:42:00 +00:00
|
|
|
this->errnum = code;
|
|
|
|
this->errlin = line;
|
2009-06-02 03:34:34 +00:00
|
|
|
qse_strxcpy (this->errmsg, QSE_COUNTOF(this->errmsg),
|
|
|
|
QSE_T("not ready to set an error message"));
|
2007-05-16 01:03:00 +00:00
|
|
|
}
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-16 01:03:00 +00:00
|
|
|
|
2009-06-02 07:33:01 +00:00
|
|
|
void Awk::setErrorWithMessage (ErrorNumber code, size_t line, const char_t* msg)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
if (awk != QSE_NULL)
|
2007-05-02 01:07:00 +00:00
|
|
|
{
|
2009-06-15 02:40:52 +00:00
|
|
|
qse_awk_errinf_t errinf;
|
|
|
|
|
|
|
|
errinf.num = (errnum_t)code;
|
|
|
|
errinf.lin = line;
|
|
|
|
qse_strxcpy (errinf.msg, QSE_COUNTOF(errinf.msg), msg);
|
|
|
|
|
|
|
|
qse_awk_seterrinf (awk, &errinf);
|
2007-09-11 22:42:00 +00:00
|
|
|
retrieveError ();
|
2007-05-02 01:07:00 +00:00
|
|
|
}
|
2007-09-11 22:42:00 +00:00
|
|
|
else
|
2007-05-02 01:07:00 +00:00
|
|
|
{
|
2007-09-11 22:42:00 +00:00
|
|
|
this->errnum = code;
|
|
|
|
this->errlin = line;
|
2008-12-21 21:35:07 +00:00
|
|
|
qse_strxcpy (this->errmsg, QSE_COUNTOF(this->errmsg), msg);
|
2007-05-02 01:07:00 +00:00
|
|
|
}
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Awk::clearError ()
|
|
|
|
{
|
|
|
|
this->errnum = ERR_NOERR;
|
|
|
|
this->errlin = 0;
|
2008-12-21 21:35:07 +00:00
|
|
|
this->errmsg[0] = QSE_T('\0');
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-02 01:07:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
void Awk::retrieveError ()
|
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
if (this->awk == QSE_NULL)
|
2007-05-19 01:30:00 +00:00
|
|
|
{
|
2007-09-11 22:42:00 +00:00
|
|
|
clearError ();
|
2007-05-19 01:30:00 +00:00
|
|
|
}
|
2007-09-11 22:42:00 +00:00
|
|
|
else
|
2007-05-19 01:30:00 +00:00
|
|
|
{
|
2009-06-02 03:34:34 +00:00
|
|
|
errnum_t num;
|
2007-09-11 22:42:00 +00:00
|
|
|
const char_t* msg;
|
|
|
|
|
2008-12-21 21:35:07 +00:00
|
|
|
qse_awk_geterror (this->awk, &num, &this->errlin, &msg);
|
2009-06-02 07:33:01 +00:00
|
|
|
this->errnum = (ErrorNumber)num;
|
2008-12-21 21:35:07 +00:00
|
|
|
qse_strxcpy (this->errmsg, QSE_COUNTOF(this->errmsg), msg);
|
2007-05-19 01:30:00 +00:00
|
|
|
}
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-19 01:30:00 +00:00
|
|
|
|
2009-02-15 08:38:00 +00:00
|
|
|
void Awk::retrieveError (rtx_t* rtx)
|
|
|
|
{
|
2009-06-02 03:34:34 +00:00
|
|
|
errnum_t num;
|
2009-02-15 08:38:00 +00:00
|
|
|
const char_t* msg;
|
|
|
|
|
|
|
|
qse_awk_rtx_geterror (rtx, &num, &this->errlin, &msg);
|
2009-06-02 07:33:01 +00:00
|
|
|
this->errnum = (ErrorNumber)num;
|
2009-02-15 08:38:00 +00:00
|
|
|
qse_strxcpy (this->errmsg, QSE_COUNTOF(this->errmsg), msg);
|
|
|
|
}
|
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
int Awk::open ()
|
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
QSE_ASSERT (awk == QSE_NULL && functionMap == QSE_NULL);
|
2007-09-11 22:42:00 +00:00
|
|
|
|
2009-02-17 02:11:31 +00:00
|
|
|
qse_awk_prm_t prm;
|
|
|
|
prm.pow = pow;
|
|
|
|
prm.sprintf = sprintf;
|
|
|
|
|
2009-05-21 04:44:47 +00:00
|
|
|
awk = qse_awk_open (this, QSE_SIZEOF(xtn_t), &prm);
|
2008-12-21 21:35:07 +00:00
|
|
|
if (awk == QSE_NULL)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
|
|
|
setError (ERR_NOMEM);
|
|
|
|
return -1;
|
2007-05-21 01:22:00 +00:00
|
|
|
}
|
|
|
|
|
2009-02-15 08:38:00 +00:00
|
|
|
// associate this Awk object with the underlying awk object
|
2009-02-17 02:11:31 +00:00
|
|
|
xtn_t* xtn = (xtn_t*) QSE_XTN (awk);
|
2009-02-15 08:38:00 +00:00
|
|
|
xtn->awk = this;
|
|
|
|
|
2009-06-02 03:34:34 +00:00
|
|
|
dflerrstr = qse_awk_geterrstr (awk);
|
|
|
|
qse_awk_seterrstr (awk, xerrstr);
|
|
|
|
|
2008-12-21 21:35:07 +00:00
|
|
|
//functionMap = qse_map_open (
|
|
|
|
// this, 512, 70, freeFunctionMapValue, QSE_NULL,
|
|
|
|
// qse_awk_getmmgr(awk));
|
|
|
|
functionMap = qse_map_open (
|
|
|
|
qse_awk_getmmgr(awk), QSE_SIZEOF(this), 512, 70);
|
|
|
|
if (functionMap == QSE_NULL)
|
2007-05-19 01:30:00 +00:00
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
qse_awk_close (awk);
|
|
|
|
awk = QSE_NULL;
|
2007-05-21 01:22:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
setError (ERR_NOMEM);
|
|
|
|
return -1;
|
2007-05-19 01:30:00 +00:00
|
|
|
}
|
|
|
|
|
2009-02-17 02:11:31 +00:00
|
|
|
*(Awk**)QSE_XTN(functionMap) = this;
|
2008-12-21 21:35:07 +00:00
|
|
|
qse_map_setcopier (functionMap, QSE_MAP_KEY, QSE_MAP_COPIER_INLINE);
|
|
|
|
qse_map_setfreeer (functionMap, QSE_MAP_VAL, freeFunctionMapValue);
|
|
|
|
qse_map_setscale (functionMap, QSE_MAP_KEY, QSE_SIZEOF(qse_char_t));
|
2008-09-28 03:51:23 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
runCallback = false;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Awk::close ()
|
|
|
|
{
|
2009-07-09 07:01:45 +00:00
|
|
|
fini_runctx ();
|
2009-07-02 07:14:39 +00:00
|
|
|
clearArguments ();
|
|
|
|
|
2008-12-21 21:35:07 +00:00
|
|
|
if (functionMap != QSE_NULL)
|
2007-08-26 23:33:00 +00:00
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
qse_map_close (functionMap);
|
|
|
|
functionMap = QSE_NULL;
|
2007-08-26 23:33:00 +00:00
|
|
|
}
|
|
|
|
|
2008-12-21 21:35:07 +00:00
|
|
|
if (awk != QSE_NULL)
|
2007-05-19 01:30:00 +00:00
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
qse_awk_close (awk);
|
|
|
|
awk = QSE_NULL;
|
2007-05-21 01:22:00 +00:00
|
|
|
}
|
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
clearError ();
|
|
|
|
runCallback = false;
|
|
|
|
}
|
2007-05-19 01:30:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
void Awk::setOption (int opt)
|
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
QSE_ASSERT (awk != QSE_NULL);
|
|
|
|
qse_awk_setoption (awk, opt);
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-19 01:30:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
int Awk::getOption () const
|
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
QSE_ASSERT (awk != QSE_NULL);
|
|
|
|
return qse_awk_getoption (awk);
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-19 01:30:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
void Awk::setMaxDepth (int ids, size_t depth)
|
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
QSE_ASSERT (awk != QSE_NULL);
|
|
|
|
qse_awk_setmaxdepth (awk, ids, depth);
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-19 01:30:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
Awk::size_t Awk::getMaxDepth (int id) const
|
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
QSE_ASSERT (awk != QSE_NULL);
|
|
|
|
return qse_awk_getmaxdepth (awk, id);
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-19 01:30:00 +00:00
|
|
|
|
2009-06-02 07:33:01 +00:00
|
|
|
const Awk::char_t* Awk::getErrorString (ErrorNumber num) const
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2009-06-02 03:34:34 +00:00
|
|
|
QSE_ASSERT (dflerrstr != QSE_NULL);
|
|
|
|
return dflerrstr (awk, (errnum_t)num);
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-19 01:30:00 +00:00
|
|
|
|
2009-06-02 03:34:34 +00:00
|
|
|
const Awk::char_t* Awk::xerrstr (awk_t* a, errnum_t num) throw ()
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2009-06-02 03:34:34 +00:00
|
|
|
Awk* awk = *(Awk**)QSE_XTN(a);
|
|
|
|
try
|
|
|
|
{
|
2009-06-02 07:33:01 +00:00
|
|
|
return awk->getErrorString ((ErrorNumber)num);
|
2009-06-02 03:34:34 +00:00
|
|
|
}
|
|
|
|
catch (...)
|
|
|
|
{
|
|
|
|
return awk->dflerrstr (a, num);
|
|
|
|
}
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-19 01:30:00 +00:00
|
|
|
|
2007-11-09 00:08:00 +00:00
|
|
|
int Awk::getWord (
|
2008-12-21 21:35:07 +00:00
|
|
|
const char_t* ow, qse_size_t owl,
|
|
|
|
const char_t** nw, qse_size_t* nwl)
|
2007-11-09 00:08:00 +00:00
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
QSE_ASSERT (awk != QSE_NULL);
|
|
|
|
return qse_awk_getword (awk, ow, owl, nw, nwl);
|
2007-11-09 00:08:00 +00:00
|
|
|
}
|
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
int Awk::setWord (const char_t* ow, const char_t* nw)
|
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
return setWord (ow, qse_strlen(ow), nw, qse_strlen(nw));
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-21 01:22:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
int Awk::setWord (
|
2008-12-21 21:35:07 +00:00
|
|
|
const char_t* ow, qse_size_t owl,
|
|
|
|
const char_t* nw, qse_size_t nwl)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
QSE_ASSERT (awk != QSE_NULL);
|
|
|
|
return qse_awk_setword (awk, ow, owl, nw, nwl);
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-21 01:22:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
int Awk::unsetWord (const char_t* ow)
|
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
return unsetWord (ow, qse_strlen(ow));
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-19 01:30:00 +00:00
|
|
|
|
2008-12-21 21:35:07 +00:00
|
|
|
int Awk::unsetWord (const char_t* ow, qse_size_t owl)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
QSE_ASSERT (awk != QSE_NULL);
|
|
|
|
return qse_awk_setword (awk, ow, owl, QSE_NULL, 0);
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-24 15:56:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
int Awk::unsetAllWords ()
|
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
QSE_ASSERT (awk != QSE_NULL);
|
|
|
|
return qse_awk_setword (awk, QSE_NULL, 0, QSE_NULL, 0);
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-24 15:56:00 +00:00
|
|
|
|
2009-07-14 04:03:53 +00:00
|
|
|
Awk::Run* Awk::parse (Source& in, Source& out)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
QSE_ASSERT (awk != QSE_NULL);
|
2007-08-26 23:33:00 +00:00
|
|
|
|
2009-07-14 04:03:53 +00:00
|
|
|
if (&in == &Source::NONE)
|
|
|
|
{
|
|
|
|
setError (ERR_INVAL);
|
|
|
|
return QSE_NULL;
|
|
|
|
}
|
|
|
|
|
2009-07-09 07:01:45 +00:00
|
|
|
fini_runctx ();
|
2007-06-24 20:14:00 +00:00
|
|
|
|
2009-07-14 04:03:53 +00:00
|
|
|
sourceReader = ∈
|
|
|
|
sourceWriter = (&out == &Source::NONE)? QSE_NULL: &out;
|
2009-07-10 06:46:14 +00:00
|
|
|
|
2009-07-09 07:01:45 +00:00
|
|
|
qse_awk_sio_t sio;
|
2009-07-10 06:46:14 +00:00
|
|
|
sio.in = readSource;
|
|
|
|
sio.out = (sourceWriter == QSE_NULL)? QSE_NULL: writeSource;
|
2007-06-19 23:59:00 +00:00
|
|
|
|
2009-02-12 04:46:24 +00:00
|
|
|
int n = qse_awk_parse (awk, &sio);
|
2009-07-09 07:01:45 +00:00
|
|
|
if (n <= -1)
|
|
|
|
{
|
|
|
|
retrieveError ();
|
|
|
|
return QSE_NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (init_runctx () <= -1) return QSE_NULL;
|
|
|
|
return &runctx;
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-06-19 23:59:00 +00:00
|
|
|
|
2009-07-09 07:01:45 +00:00
|
|
|
int Awk::init_runctx ()
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2009-07-09 07:01:45 +00:00
|
|
|
if (runctx.rtx != QSE_NULL) return 0;
|
2007-06-29 20:40:00 +00:00
|
|
|
|
2009-02-12 04:46:24 +00:00
|
|
|
qse_awk_rio_t rio;
|
|
|
|
qse_awk_rcb_t rcb;
|
2007-10-08 00:27:00 +00:00
|
|
|
|
2009-02-12 04:46:24 +00:00
|
|
|
rio.pipe = pipeHandler;
|
|
|
|
rio.file = fileHandler;
|
|
|
|
rio.console = consoleHandler;
|
2007-06-29 20:40:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
if (runCallback)
|
2007-05-02 01:07:00 +00:00
|
|
|
{
|
2009-02-13 08:23:35 +00:00
|
|
|
QSE_MEMSET (&rcb, 0, QSE_SIZEOF(rcb));
|
2009-07-02 07:14:39 +00:00
|
|
|
rcb.on_loop_enter = onLoopEnter;
|
|
|
|
rcb.on_loop_exit = onLoopExit;
|
|
|
|
rcb.on_statement = onStatement;
|
|
|
|
rcb.udd = &runctx;
|
2007-05-02 01:07:00 +00:00
|
|
|
}
|
2009-07-09 07:01:45 +00:00
|
|
|
|
2009-02-15 08:38:00 +00:00
|
|
|
rtx_t* rtx = qse_awk_rtx_open (
|
2009-07-02 07:14:39 +00:00
|
|
|
awk, QSE_SIZEOF(rxtn_t), &rio, (qse_cstr_t*)runarg.ptr);
|
2009-02-13 04:55:25 +00:00
|
|
|
if (rtx == QSE_NULL)
|
|
|
|
{
|
|
|
|
retrieveError();
|
2009-07-09 07:01:45 +00:00
|
|
|
return -1;
|
2009-02-13 04:55:25 +00:00
|
|
|
}
|
2009-02-16 08:31:34 +00:00
|
|
|
|
2009-07-09 07:01:45 +00:00
|
|
|
runctx.rtx = rtx;
|
|
|
|
|
|
|
|
rxtn_t* rxtn = (rxtn_t*) QSE_XTN (rtx);
|
|
|
|
rxtn->run = &runctx;
|
2009-02-13 04:55:25 +00:00
|
|
|
|
2009-07-09 07:01:45 +00:00
|
|
|
if (runCallback) qse_awk_rtx_setrcb (rtx, &rcb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Awk::fini_runctx ()
|
|
|
|
{
|
|
|
|
if (runctx.rtx != QSE_NULL)
|
|
|
|
{
|
|
|
|
qse_awk_rtx_close (runctx.rtx);
|
|
|
|
runctx.rtx = QSE_NULL;
|
2009-02-13 04:55:25 +00:00
|
|
|
}
|
2009-07-09 07:01:45 +00:00
|
|
|
}
|
2009-02-13 04:55:25 +00:00
|
|
|
|
2009-07-09 07:01:45 +00:00
|
|
|
int Awk::loop ()
|
|
|
|
{
|
|
|
|
QSE_ASSERT (awk != QSE_NULL);
|
|
|
|
QSE_ASSERT (runctx.rtx != QSE_NULL);
|
|
|
|
|
|
|
|
int n = qse_awk_rtx_loop (runctx.rtx);
|
|
|
|
if (n <= -1) retrieveError (runctx.rtx);
|
2007-09-11 22:42:00 +00:00
|
|
|
return n;
|
|
|
|
}
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
int Awk::call (const char_t* name, Value* ret, const Value* args, size_t nargs)
|
2009-07-09 07:01:45 +00:00
|
|
|
{
|
|
|
|
QSE_ASSERT (awk != QSE_NULL);
|
|
|
|
QSE_ASSERT (runctx.rtx != QSE_NULL);
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
val_t* buf[16];
|
2009-07-09 07:01:45 +00:00
|
|
|
val_t** ptr = QSE_NULL;
|
|
|
|
|
|
|
|
if (args != QSE_NULL)
|
|
|
|
{
|
2009-07-13 07:06:01 +00:00
|
|
|
if (nargs <= QSE_COUNTOF(buf)) ptr = buf;
|
|
|
|
else
|
2009-07-09 07:01:45 +00:00
|
|
|
{
|
2009-07-13 07:06:01 +00:00
|
|
|
ptr = (val_t**) qse_awk_alloc (
|
|
|
|
awk, QSE_SIZEOF(val_t*) * nargs);
|
|
|
|
if (ptr == QSE_NULL)
|
|
|
|
{
|
|
|
|
runctx.setError (ERR_NOMEM);
|
2009-07-14 02:51:23 +00:00
|
|
|
retrieveError (runctx.rtx);
|
2009-07-13 07:06:01 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2009-07-09 07:01:45 +00:00
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
for (size_t i = 0; i < nargs; i++) ptr[i] = (val_t*)args[i];
|
2009-07-09 07:01:45 +00:00
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
val_t* rv = qse_awk_rtx_call (runctx.rtx, name, ptr, nargs);
|
2009-07-09 07:01:45 +00:00
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
if (ptr != QSE_NULL && ptr != buf) qse_awk_free (awk, ptr);
|
2009-07-09 07:01:45 +00:00
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
if (rv == QSE_NULL)
|
2009-07-09 07:01:45 +00:00
|
|
|
{
|
|
|
|
retrieveError (runctx.rtx);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
ret->setVal (&runctx, rv);
|
|
|
|
|
|
|
|
qse_awk_rtx_refdownval (runctx.rtx, rv);
|
2009-07-09 07:01:45 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-10-12 00:13:00 +00:00
|
|
|
void Awk::stop ()
|
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
QSE_ASSERT (awk != QSE_NULL);
|
2009-02-02 04:12:49 +00:00
|
|
|
qse_awk_stopall (awk);
|
2007-10-12 00:13:00 +00:00
|
|
|
}
|
|
|
|
|
2007-10-08 00:27:00 +00:00
|
|
|
int Awk::dispatchFunction (Run* run, const char_t* name, size_t len)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
|
|
|
pair_t* pair;
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2008-12-21 21:35:07 +00:00
|
|
|
pair = qse_map_search (functionMap, name, len);
|
|
|
|
if (pair == QSE_NULL)
|
2007-09-25 00:12:00 +00:00
|
|
|
{
|
2009-07-02 07:14:39 +00:00
|
|
|
run->setError (ERR_FUNNF, 0, name, len);
|
2007-09-25 00:12:00 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2007-05-09 00:09:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
FunctionHandler handler;
|
2008-12-21 21:35:07 +00:00
|
|
|
handler = *(FunctionHandler*)QSE_MAP_VPTR(pair);
|
2007-05-09 00:09:00 +00:00
|
|
|
|
2009-07-07 06:37:25 +00:00
|
|
|
size_t i, nargs = qse_awk_rtx_getnargs(run->rtx);
|
2007-09-11 22:42:00 +00:00
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
Value buf[16];
|
|
|
|
Value* args;
|
|
|
|
if (nargs <= QSE_COUNTOF(buf)) args = buf;
|
|
|
|
else
|
2007-09-25 00:12:00 +00:00
|
|
|
{
|
2009-07-13 07:06:01 +00:00
|
|
|
args = new(run) Value[nargs];
|
|
|
|
if (args == QSE_NULL)
|
|
|
|
{
|
|
|
|
run->setError (ERR_NOMEM, 0, QSE_NULL, 0);
|
|
|
|
return -1;
|
|
|
|
}
|
2007-09-25 00:12:00 +00:00
|
|
|
}
|
2007-09-11 22:42:00 +00:00
|
|
|
|
|
|
|
for (i = 0; i < nargs; i++)
|
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
val_t* v = qse_awk_rtx_getarg (run->rtx, i);
|
2009-07-13 07:06:01 +00:00
|
|
|
if (args[i].setVal (run, v) == -1)
|
2007-05-09 00:09:00 +00:00
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
run->setError (ERR_NOMEM, 0, QSE_NULL, 0);
|
2009-07-13 07:06:01 +00:00
|
|
|
if (args != buf) delete[] args;
|
2007-09-11 22:42:00 +00:00
|
|
|
return -1;
|
2007-05-09 00:09:00 +00:00
|
|
|
}
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
Value ret (run);
|
2007-09-25 00:12:00 +00:00
|
|
|
|
2007-10-08 00:27:00 +00:00
|
|
|
int n = (this->*handler) (*run, ret, args, nargs, name, len);
|
2007-09-11 22:42:00 +00:00
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
if (args != buf) delete[] args;
|
2007-05-09 00:09:00 +00:00
|
|
|
|
2007-09-25 00:12:00 +00:00
|
|
|
if (n <= -1)
|
|
|
|
{
|
|
|
|
/* this is really the handler error. the underlying engine
|
|
|
|
* will take care of the error code. */
|
|
|
|
return -1;
|
|
|
|
}
|
2007-05-09 00:09:00 +00:00
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
qse_awk_rtx_setretval (run->rtx, ret.toVal());
|
2007-09-11 22:42:00 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-08 07:05:10 +00:00
|
|
|
int Awk::xstrs_t::add (awk_t* awk, const char_t* arg, size_t len)
|
2009-07-02 07:14:39 +00:00
|
|
|
{
|
2009-07-08 07:05:10 +00:00
|
|
|
if (this->len >= this->capa)
|
2009-07-02 07:14:39 +00:00
|
|
|
{
|
|
|
|
qse_xstr_t* ptr;
|
2009-07-08 07:05:10 +00:00
|
|
|
size_t capa = this->capa;
|
2009-07-02 07:14:39 +00:00
|
|
|
|
|
|
|
capa += 64;
|
|
|
|
ptr = (qse_xstr_t*) qse_awk_realloc (
|
2009-07-08 07:05:10 +00:00
|
|
|
awk, this->ptr, QSE_SIZEOF(qse_xstr_t)*(capa+1));
|
|
|
|
if (ptr == QSE_NULL) return -1;
|
2009-07-02 07:14:39 +00:00
|
|
|
|
2009-07-08 07:05:10 +00:00
|
|
|
this->ptr = ptr;
|
|
|
|
this->capa = capa;
|
2009-07-02 07:14:39 +00:00
|
|
|
}
|
|
|
|
|
2009-07-08 07:05:10 +00:00
|
|
|
this->ptr[this->len].len = len;
|
|
|
|
this->ptr[this->len].ptr = qse_awk_strxdup (awk, arg, len);
|
|
|
|
if (this->ptr[this->len].ptr == QSE_NULL) return -1;
|
2009-07-02 07:14:39 +00:00
|
|
|
|
2009-07-08 07:05:10 +00:00
|
|
|
this->len++;
|
|
|
|
this->ptr[this->len].len = 0;
|
|
|
|
this->ptr[this->len].ptr = QSE_NULL;
|
2009-07-02 07:14:39 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-08 07:05:10 +00:00
|
|
|
void Awk::xstrs_t::clear (awk_t* awk)
|
|
|
|
{
|
|
|
|
if (this->ptr != QSE_NULL)
|
|
|
|
{
|
2009-07-09 07:01:45 +00:00
|
|
|
while (this->len > 0)
|
|
|
|
qse_awk_free (awk, this->ptr[--this->len].ptr);
|
|
|
|
|
2009-07-08 07:05:10 +00:00
|
|
|
qse_awk_free (awk, this->ptr);
|
|
|
|
this->ptr = QSE_NULL;
|
|
|
|
this->capa = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int Awk::addArgument (const char_t* arg, size_t len)
|
|
|
|
{
|
|
|
|
QSE_ASSERT (awk != QSE_NULL);
|
|
|
|
int n = runarg.add (awk, arg, len);
|
|
|
|
if (n <= -1) setError (ERR_NOMEM);
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2009-07-02 07:14:39 +00:00
|
|
|
int Awk::addArgument (const char_t* arg)
|
|
|
|
{
|
|
|
|
return addArgument (arg, qse_strlen(arg));
|
|
|
|
}
|
|
|
|
|
|
|
|
void Awk::clearArguments ()
|
|
|
|
{
|
2009-07-08 07:05:10 +00:00
|
|
|
runarg.clear (awk);
|
2009-07-02 07:14:39 +00:00
|
|
|
}
|
|
|
|
|
2007-09-25 00:12:00 +00:00
|
|
|
int Awk::addGlobal (const char_t* name)
|
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
QSE_ASSERT (awk != QSE_NULL);
|
2007-09-25 00:12:00 +00:00
|
|
|
|
2009-02-02 08:28:04 +00:00
|
|
|
int n = qse_awk_addgbl (awk, name, qse_strlen(name));
|
2009-07-15 02:06:14 +00:00
|
|
|
if (n <= -1) retrieveError ();
|
2007-09-25 00:12:00 +00:00
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Awk::deleteGlobal (const char_t* name)
|
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
QSE_ASSERT (awk != QSE_NULL);
|
2009-02-02 08:28:04 +00:00
|
|
|
int n = qse_awk_delgbl (awk, name, qse_strlen(name));
|
2009-07-15 02:06:14 +00:00
|
|
|
if (n <= -1) retrieveError ();
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Awk::setGlobal (int id, const Value& v)
|
|
|
|
{
|
|
|
|
QSE_ASSERT (awk != QSE_NULL);
|
|
|
|
QSE_ASSERT (runctx.rtx != QSE_NULL);
|
|
|
|
|
|
|
|
if (v.run != &runctx)
|
|
|
|
{
|
|
|
|
setError (ERR_INVAL);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int n = runctx.setGlobal (id, v);
|
|
|
|
if (n <= -1) retrieveError ();
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Awk::getGlobal (int id, Value& v)
|
|
|
|
{
|
|
|
|
QSE_ASSERT (awk != QSE_NULL);
|
|
|
|
QSE_ASSERT (runctx.rtx != QSE_NULL);
|
|
|
|
|
|
|
|
int n = runctx.getGlobal (id, v);
|
|
|
|
if (n <= -1) retrieveError ();
|
2007-09-25 00:12:00 +00:00
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
int Awk::addFunction (
|
|
|
|
const char_t* name, size_t minArgs, size_t maxArgs,
|
|
|
|
FunctionHandler handler)
|
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
QSE_ASSERT (awk != QSE_NULL);
|
2007-05-09 00:09:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
FunctionHandler* tmp = (FunctionHandler*)
|
2008-12-21 21:35:07 +00:00
|
|
|
qse_awk_alloc (awk, QSE_SIZEOF(handler));
|
|
|
|
if (tmp == QSE_NULL)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
|
|
|
setError (ERR_NOMEM);
|
|
|
|
return -1;
|
2007-05-06 19:44:00 +00:00
|
|
|
}
|
|
|
|
|
2008-12-21 21:35:07 +00:00
|
|
|
//QSE_MEMCPY (tmp, &handler, QSE_SIZEOF(handler));
|
2007-09-11 22:42:00 +00:00
|
|
|
*tmp = handler;
|
|
|
|
|
2008-12-21 21:35:07 +00:00
|
|
|
size_t nameLen = qse_strlen(name);
|
2007-09-11 22:42:00 +00:00
|
|
|
|
2009-02-01 03:59:46 +00:00
|
|
|
void* p = qse_awk_addfnc (awk, name, nameLen,
|
2008-12-21 21:35:07 +00:00
|
|
|
0, minArgs, maxArgs, QSE_NULL,
|
2007-09-11 22:42:00 +00:00
|
|
|
functionHandler);
|
2008-12-21 21:35:07 +00:00
|
|
|
if (p == QSE_NULL)
|
2007-05-06 19:44:00 +00:00
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
qse_awk_free (awk, tmp);
|
2007-09-11 22:42:00 +00:00
|
|
|
retrieveError ();
|
|
|
|
return -1;
|
|
|
|
}
|
2007-05-07 01:05:00 +00:00
|
|
|
|
2008-12-21 21:35:07 +00:00
|
|
|
pair_t* pair = qse_map_upsert (
|
2008-09-28 03:51:23 +00:00
|
|
|
functionMap, (char_t*)name, nameLen, tmp, 0);
|
2008-12-21 21:35:07 +00:00
|
|
|
if (pair == QSE_NULL)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2009-02-01 03:59:46 +00:00
|
|
|
qse_awk_delfnc (awk, name, nameLen);
|
2008-12-21 21:35:07 +00:00
|
|
|
qse_awk_free (awk, tmp);
|
2007-05-07 01:05:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
setError (ERR_NOMEM);
|
|
|
|
return -1;
|
|
|
|
}
|
2007-05-07 01:05:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2007-05-07 01:05:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
int Awk::deleteFunction (const char_t* name)
|
|
|
|
{
|
2008-12-21 21:35:07 +00:00
|
|
|
QSE_ASSERT (awk != QSE_NULL);
|
2007-05-21 01:22:00 +00:00
|
|
|
|
2008-12-21 21:35:07 +00:00
|
|
|
size_t nameLen = qse_strlen(name);
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2009-02-01 03:59:46 +00:00
|
|
|
int n = qse_awk_delfnc (awk, name, nameLen);
|
2008-12-21 21:35:07 +00:00
|
|
|
if (n == 0) qse_map_delete (functionMap, name, nameLen);
|
2007-09-11 22:42:00 +00:00
|
|
|
else retrieveError ();
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
return n;
|
|
|
|
}
|
2007-05-07 01:05:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
void Awk::enableRunCallback ()
|
|
|
|
{
|
|
|
|
runCallback = true;
|
|
|
|
}
|
2007-05-07 01:05:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
void Awk::disableRunCallback ()
|
|
|
|
{
|
|
|
|
runCallback = false;
|
|
|
|
}
|
2007-05-07 01:05:00 +00:00
|
|
|
|
2009-07-02 07:14:39 +00:00
|
|
|
bool Awk::onLoopEnter (Run& run)
|
2009-01-23 04:40:57 +00:00
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
void Awk::onLoopExit (Run& run, const Value& ret)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
|
|
|
}
|
2007-05-21 01:22:00 +00:00
|
|
|
|
2009-07-02 07:14:39 +00:00
|
|
|
void Awk::onStatement (Run& run, size_t line)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
|
|
|
}
|
2007-05-16 01:03:00 +00:00
|
|
|
|
2009-07-10 06:46:14 +00:00
|
|
|
Awk::ssize_t Awk::readSource (
|
2009-02-17 02:11:31 +00:00
|
|
|
awk_t* awk, qse_awk_sio_cmd_t cmd, char_t* data, size_t count)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2009-02-17 02:11:31 +00:00
|
|
|
xtn_t* xtn = (xtn_t*) QSE_XTN (awk);
|
2007-05-21 01:22:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
switch (cmd)
|
2007-05-21 01:22:00 +00:00
|
|
|
{
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_SIO_OPEN:
|
2009-07-10 06:46:14 +00:00
|
|
|
return xtn->awk->sourceReader->open (xtn->awk->sourceIn);
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_SIO_CLOSE:
|
2009-07-10 06:46:14 +00:00
|
|
|
return xtn->awk->sourceReader->close (xtn->awk->sourceIn);
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_SIO_READ:
|
2009-07-10 06:46:14 +00:00
|
|
|
return xtn->awk->sourceReader->read (xtn->awk->sourceIn, data, count);
|
|
|
|
default:
|
2009-02-17 02:11:31 +00:00
|
|
|
return -1;
|
2007-05-21 01:22:00 +00:00
|
|
|
}
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-16 01:03:00 +00:00
|
|
|
|
2009-07-10 06:46:14 +00:00
|
|
|
Awk::ssize_t Awk::writeSource (
|
2009-02-17 02:11:31 +00:00
|
|
|
awk_t* awk, qse_awk_sio_cmd_t cmd, char_t* data, size_t count)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2009-02-17 02:11:31 +00:00
|
|
|
xtn_t* xtn = (xtn_t*) QSE_XTN (awk);
|
2007-05-04 20:30:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
switch (cmd)
|
2007-05-04 00:14:00 +00:00
|
|
|
{
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_SIO_OPEN:
|
2009-07-10 06:46:14 +00:00
|
|
|
return xtn->awk->sourceWriter->open (xtn->awk->sourceOut);
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_SIO_CLOSE:
|
2009-07-10 06:46:14 +00:00
|
|
|
return xtn->awk->sourceWriter->close (xtn->awk->sourceOut);
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_SIO_WRITE:
|
2009-07-10 06:46:14 +00:00
|
|
|
return xtn->awk->sourceWriter->write (xtn->awk->sourceOut, data, count);
|
|
|
|
default:
|
2009-02-17 02:11:31 +00:00
|
|
|
return -1;
|
2007-05-06 19:44:00 +00:00
|
|
|
}
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
Awk::ssize_t Awk::pipeHandler (
|
2009-06-17 00:05:40 +00:00
|
|
|
rtx_t* rtx, rio_cmd_t cmd, rio_arg_t* riod,
|
2009-02-17 02:11:31 +00:00
|
|
|
char_t* data, size_t count)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2009-02-17 02:11:31 +00:00
|
|
|
rxtn_t* rxtn = (rxtn_t*) QSE_XTN (rtx);
|
2009-02-16 08:31:34 +00:00
|
|
|
Awk* awk = rxtn->run->awk;
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2009-02-16 08:31:34 +00:00
|
|
|
QSE_ASSERT ((riod->type & 0xFF) == QSE_AWK_RIO_PIPE);
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2009-07-07 06:37:25 +00:00
|
|
|
Pipe pipe (rxtn->run, riod);
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
switch (cmd)
|
|
|
|
{
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_RIO_OPEN:
|
2007-09-11 22:42:00 +00:00
|
|
|
return awk->openPipe (pipe);
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_RIO_CLOSE:
|
2007-09-11 22:42:00 +00:00
|
|
|
return awk->closePipe (pipe);
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_RIO_READ:
|
2007-09-11 22:42:00 +00:00
|
|
|
return awk->readPipe (pipe, data, count);
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_RIO_WRITE:
|
2007-09-11 22:42:00 +00:00
|
|
|
return awk->writePipe (pipe, data, count);
|
2007-05-16 01:03:00 +00:00
|
|
|
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_RIO_FLUSH:
|
2007-09-11 22:42:00 +00:00
|
|
|
return awk->flushPipe (pipe);
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_RIO_NEXT:
|
2007-09-11 22:42:00 +00:00
|
|
|
return -1;
|
2007-05-06 19:44:00 +00:00
|
|
|
}
|
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
Awk::ssize_t Awk::fileHandler (
|
2009-06-17 00:05:40 +00:00
|
|
|
rtx_t* rtx, rio_cmd_t cmd, rio_arg_t* riod,
|
2009-02-17 02:11:31 +00:00
|
|
|
char_t* data, size_t count)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2009-02-17 02:11:31 +00:00
|
|
|
rxtn_t* rxtn = (rxtn_t*) QSE_XTN (rtx);
|
2009-02-16 08:31:34 +00:00
|
|
|
Awk* awk = rxtn->run->awk;
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2009-02-16 08:31:34 +00:00
|
|
|
QSE_ASSERT ((riod->type & 0xFF) == QSE_AWK_RIO_FILE);
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2009-07-07 06:37:25 +00:00
|
|
|
File file (rxtn->run, riod);
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
switch (cmd)
|
|
|
|
{
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_RIO_OPEN:
|
2007-09-11 22:42:00 +00:00
|
|
|
return awk->openFile (file);
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_RIO_CLOSE:
|
2007-09-11 22:42:00 +00:00
|
|
|
return awk->closeFile (file);
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_RIO_READ:
|
2007-09-11 22:42:00 +00:00
|
|
|
return awk->readFile (file, data, count);
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_RIO_WRITE:
|
2007-09-11 22:42:00 +00:00
|
|
|
return awk->writeFile (file, data, count);
|
2007-05-16 01:03:00 +00:00
|
|
|
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_RIO_FLUSH:
|
2007-09-11 22:42:00 +00:00
|
|
|
return awk->flushFile (file);
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_RIO_NEXT:
|
2007-09-11 22:42:00 +00:00
|
|
|
return -1;
|
2007-05-06 19:44:00 +00:00
|
|
|
}
|
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
Awk::ssize_t Awk::consoleHandler (
|
2009-06-17 00:05:40 +00:00
|
|
|
rtx_t* rtx, rio_cmd_t cmd, rio_arg_t* riod,
|
2009-02-17 02:11:31 +00:00
|
|
|
char_t* data, size_t count)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2009-02-17 02:11:31 +00:00
|
|
|
rxtn_t* rxtn = (rxtn_t*) QSE_XTN (rtx);
|
2009-02-16 08:31:34 +00:00
|
|
|
Awk* awk = rxtn->run->awk;
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2009-02-16 08:31:34 +00:00
|
|
|
QSE_ASSERT ((riod->type & 0xFF) == QSE_AWK_RIO_CONSOLE);
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2009-07-07 06:37:25 +00:00
|
|
|
Console console (rxtn->run, riod);
|
2007-05-06 19:44:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
switch (cmd)
|
2007-05-07 01:05:00 +00:00
|
|
|
{
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_RIO_OPEN:
|
2007-09-11 22:42:00 +00:00
|
|
|
return awk->openConsole (console);
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_RIO_CLOSE:
|
2007-09-11 22:42:00 +00:00
|
|
|
return awk->closeConsole (console);
|
2007-05-07 01:05:00 +00:00
|
|
|
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_RIO_READ:
|
2007-09-11 22:42:00 +00:00
|
|
|
return awk->readConsole (console, data, count);
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_RIO_WRITE:
|
2007-09-11 22:42:00 +00:00
|
|
|
return awk->writeConsole (console, data, count);
|
2007-05-21 01:22:00 +00:00
|
|
|
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_RIO_FLUSH:
|
2007-09-11 22:42:00 +00:00
|
|
|
return awk->flushConsole (console);
|
2009-02-17 02:11:31 +00:00
|
|
|
case QSE_AWK_RIO_NEXT:
|
2007-09-11 22:42:00 +00:00
|
|
|
return awk->nextConsole (console);
|
2007-05-16 01:03:00 +00:00
|
|
|
}
|
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2007-05-21 01:22:00 +00:00
|
|
|
|
2009-02-16 08:31:34 +00:00
|
|
|
int Awk::functionHandler (rtx_t* rtx, const char_t* name, size_t len)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2009-02-17 02:11:31 +00:00
|
|
|
rxtn_t* rxtn = (rxtn_t*) QSE_XTN (rtx);
|
2009-02-16 08:31:34 +00:00
|
|
|
return rxtn->run->awk->dispatchFunction (rxtn->run, name, len);
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-21 01:22:00 +00:00
|
|
|
|
2008-09-28 03:51:23 +00:00
|
|
|
void Awk::freeFunctionMapValue (map_t* map, void* dptr, size_t dlen)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2009-02-17 02:11:31 +00:00
|
|
|
Awk* awk = *(Awk**) QSE_XTN (map);
|
2008-12-21 21:35:07 +00:00
|
|
|
qse_awk_free (awk->awk, dptr);
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-21 01:22:00 +00:00
|
|
|
|
2009-07-07 06:37:25 +00:00
|
|
|
int Awk::onLoopEnter (rtx_t* rtx, void* data)
|
2009-01-23 04:40:57 +00:00
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
Run* run = (Run*)data;
|
|
|
|
return run->awk->onLoopEnter(*run)? 0: -1;
|
2009-01-23 04:40:57 +00:00
|
|
|
}
|
|
|
|
|
2009-07-07 06:37:25 +00:00
|
|
|
void Awk::onLoopExit (rtx_t* rtx, val_t* ret, void* data)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
Run* run = (Run*)data;
|
2007-05-04 20:30:00 +00:00
|
|
|
|
2009-07-13 07:06:01 +00:00
|
|
|
Value x;
|
|
|
|
if (x.setVal (run, ret) == -1)
|
2009-07-07 06:37:25 +00:00
|
|
|
qse_awk_rtx_seterrnum (run->rtx, (errnum_t)ERR_NOMEM);
|
|
|
|
else run->awk->onLoopExit (*run, x);
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-04 20:30:00 +00:00
|
|
|
|
2009-07-07 06:37:25 +00:00
|
|
|
void Awk::onStatement (rtx_t* rtx, size_t line, void* data)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2009-07-07 06:37:25 +00:00
|
|
|
Run* run = (Run*)data;
|
|
|
|
run->awk->onStatement (*run, line);
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
2007-05-04 20:30:00 +00:00
|
|
|
|
2009-02-15 08:38:00 +00:00
|
|
|
Awk::real_t Awk::pow (awk_t* awk, real_t x, real_t y)
|
2007-09-11 22:42:00 +00:00
|
|
|
{
|
2009-02-17 02:11:31 +00:00
|
|
|
xtn_t* xtn = (xtn_t*) QSE_XTN (awk);
|
2009-02-15 08:38:00 +00:00
|
|
|
return xtn->awk->pow (x, y);
|
2007-09-11 22:42:00 +00:00
|
|
|
}
|
|
|
|
|
2009-02-15 08:38:00 +00:00
|
|
|
int Awk::sprintf (awk_t* awk, char_t* buf, size_t size,
|
2007-09-11 22:42:00 +00:00
|
|
|
const char_t* fmt, ...)
|
|
|
|
{
|
2009-02-17 02:11:31 +00:00
|
|
|
xtn_t* xtn = (xtn_t*) QSE_XTN (awk);
|
2009-02-15 08:38:00 +00:00
|
|
|
|
2007-09-11 22:42:00 +00:00
|
|
|
va_list ap;
|
|
|
|
va_start (ap, fmt);
|
2009-02-15 08:38:00 +00:00
|
|
|
int n = xtn->awk->vsprintf (buf, size, fmt, ap);
|
2007-09-11 22:42:00 +00:00
|
|
|
va_end (ap);
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////
|
2008-12-30 04:49:25 +00:00
|
|
|
QSE_END_NAMESPACE(QSE)
|
2007-09-11 22:42:00 +00:00
|
|
|
/////////////////////////////////
|
|
|
|
|