std::string traceInfo(int32_t deep)
{
v8::Local<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(
Isolate::now().isolate, deep, v8::StackTrace::kOverview);
int count = stackTrace->GetFrameCount();
int i;
std::string strBuffer;
for (i = 0; i < count; i++)
{
char numStr[32];
v8::Local<v8::StackFrame> f = stackTrace->GetFrame(i);
v8::String::Utf8Value funname(f->GetFunctionName());
v8::String::Utf8Value filename(f->GetScriptName());
strBuffer.append("\n at ");
if (**funname)
{
strBuffer.append(*funname);
strBuffer.append(" (", 2);
}
if (*filename)
{
strBuffer.append(*filename);
strBuffer.append(1, ':');
}
else
strBuffer.append("[eval]:", 7);
sprintf(numStr, "%d", f->GetLineNumber());
strBuffer.append(numStr);
strBuffer.append(1, ':');
sprintf(numStr, "%d", f->GetColumn());
strBuffer.append(numStr);
if (**funname)
strBuffer.append(")", 1);
}
return strBuffer;
}
void _define(const v8::FunctionCallbackInfo<v8::Value> &args)
{
int argc = args.Length();
if (argc == 0)
{
ThrowResult(CALL_E_PARAMNOTOPTIONAL);
return;
}
if (argc > 3)
{
ThrowResult(CALL_E_BADPARAMCOUNT);
return;
}
// v8::LocalScope handle_scope(isolate);
v8::Local<v8::Object> glob = isolate->GetCallingContext()->Global();
// cache string
v8::Local<v8::String> strRequire = v8::String::NewFromUtf8(isolate, "require");
v8::Local<v8::String> strExports = v8::String::NewFromUtf8(isolate, "exports");
v8::Local<v8::String> strModule = v8::String::NewFromUtf8(isolate, "module");
v8::Local<v8::String> strDefs = v8::String::NewFromUtf8(isolate, "defs");
v8::Local<v8::String> strId = v8::String::NewFromUtf8(isolate, "id");
// fetch default module object
v8::Local<v8::Object> mod = glob->Get(strModule)->ToObject();
// fetch module.id
std::string path;
path_base::dirname(*v8::String::Utf8Value(mod->Get(strId)), path);
v8::Local<v8::Array> defs;
{
v8::Local<v8::Value> v;
// fetch hidden value module.defs
v = mod->GetHiddenValue(strDefs);
if (!v.IsEmpty() && v->IsArray())
defs = v8::Local<v8::Array>::Cast(v);
else
{
// create one if not exists.
defs = v8::Array::New(isolate);
mod->SetHiddenValue(strDefs, defs);
}
}
v8::Local<v8::Array> deps;
std::string id;
int n = argc - 1, i;
// check deps array
if ((n > 0) && (args[n - 1]->IsArray()))
{
v8::Local<v8::Array> a = v8::Local<v8::Array>::Cast(args[n - 1]);
int an = a->Length();
deps = v8::Array::New(isolate, an);
// copy deps array to module.deps
for (i = 0; i < an; i++)
{
v8::String::Utf8Value s(a->Get(i));
deps->Set(i, v8::String::NewFromUtf8(isolate, resolvePath(path, *s).c_str()));
}
n--;
}
else
{
deps = v8::Array::New(isolate, 3);
// default deps: ['require', 'exports', 'module']
deps->Set(0, strRequire);
deps->Set(1, strExports);
deps->Set(2, strModule);
}
if (n > 1)
{
ThrowResult(CALL_E_INVALIDARG);
return;
}
else if (n == 1)
{
// we have an id name
v8::String::Utf8Value s(args[0]);
id = *s;
}
v8::Local<v8::Object> modDef;
if (id.empty())
{
// anonymous module attach default module
modDef = mod;
}
else
{
// named module
id = resolvePath(path, id.c_str());
modDef = v8::Object::New(isolate);
v8::Local<v8::Object> exports = v8::Object::New(isolate);
// init module properties
modDef->Set(strExports, exports);
modDef->Set(strRequire, glob->Get(strRequire), v8::ReadOnly);
v8::Local<v8::String> strFname = v8::String::NewFromUtf8(isolate, id.c_str(),
v8::String::kNormalString, (int) id.length());
modDef->Set(strId, strFname, v8::ReadOnly);
// add to modules
InstallModule(id, exports);
}
v8::Local<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(isolate, 1,
v8::StackTrace::kOverview);
std::stringstream strBuffer;
v8::Local<v8::StackFrame> f = stackTrace->GetFrame(0);
v8::String::Utf8Value funname(f->GetFunctionName());
v8::String::Utf8Value filename(f->GetScriptName());
strBuffer << "\n at ";
if (**funname)
strBuffer << *funname << " (";
strBuffer << *filename << ':' << f->GetLineNumber() << ':'
<< f->GetColumn();
if (**funname)
strBuffer << ')';
std::string strStack = strBuffer.str();
// set hidden value module.deps and module.factory
modDef->SetHiddenValue(v8::String::NewFromUtf8(isolate, "deps"), deps);
modDef->SetHiddenValue(v8::String::NewFromUtf8(isolate, "factory"), args[argc - 1]);
modDef->SetHiddenValue(v8::String::NewFromUtf8(isolate, "stack"),
v8::String::NewFromUtf8(isolate, strStack.c_str(),
v8::String::kNormalString, (int) strStack.length()));
// append to define array
defs->Set(defs->Length(), modDef);
args.GetReturnValue().Set(v8::Null(isolate));
}
const char *getsymb (int t, const parser *p)
{
if ((t > F1_MIN && t < F1_MAX) ||
(t > F1_MAX && t < F2_MAX) ||
(t > F2_MAX && t < FN_MAX)) {
return funname(t);
}
if (t == EOT) {
return "";
}
/* yes, well */
if (t == OBS || t == DOBS) {
return "OBS";
} else if (t == MSL) {
return "MSL";
} else if (t == DMSL) {
return "DMSL";
} else if (t == DMSTR) {
return "DMSTR";
} else if (t == MSL2) {
return "MSL2";
} else if (t == MSPEC) {
return "MSPEC";
} else if (t == SUBSL) {
return "SUBSL";
} else if (t == MDEF) {
return "MDEF";
} else if (t == FARGS) {
return "FARGS";
} else if (t == LIST || t == ULIST || t == WLIST) {
return "LIST";
} else if (t == OVAR) {
return "OVAR";
} else if (t == USTR) {
return "USTR";
} else if (t == EMPTY) {
return "EMPTY";
} else if (t == LISTVAR) {
return "LISTVAR";
} else if (t == BOBJ) {
return "BOBJ";
} else if (t == BMEMB) {
return "BMEMB";
} else if (t == LISTELEM) {
return "LISTELEM";
} else if (t == VEC) {
return "VEC";
} else if (t == MAT) {
return "MAT";
} else if (t == EROOT) {
return "EROOT";
} else if (t == UNDEF) {
return "UNDEF";
} else if (t == NUM) {
return "NUM";
}
if (p != NULL) {
if (t == UVEC) {
return p->dset->varname[p->idnum];
} else if (t == UNUM) {
return p->idstr;
} else if (t == BUNDLE) {
return p->idstr;
} else if (t == UMAT || t == UOBJ) {
return p->idstr;
} else if (t == CON) {
return constname(p->idnum);
} else if (t == DUM) {
return dumname(p->idnum);
} else if (t == DVAR) {
return dvarname(p->idnum);
} else if (t == MVAR) {
return mvarname(p->idnum);
} else if (t == UFUN || t == RFUN) {
return p->idstr;
} else if (t == STR) {
return p->idstr;
}
} else {
if (t == UVEC) {
return "UVEC";
} else if (t == UNUM) {
return "UNUM";
} else if (t == BUNDLE) {
return "BUNDLE";
} else if (t == UMAT) {
return "UMAT";
} else if (t == UOBJ) {
return "UOBJ";
} else if (t == CON) {
return "CON";
} else if (t == DUM) {
return "DUM";
} else if (t == DVAR) {
return "DVAR";
} else if (t == MVAR) {
return "MVAR";
} else if (t == UFUN) {
return "UFUN";
} else if (t == RFUN) {
return "RFUN";
} else if (t == STR) {
return "STR";
}
}
switch (t) {
case B_ASN:
return "=";
case B_ADD:
case U_POS:
return "+";
case B_SUB:
case U_NEG:
return "-";
case B_MUL:
return "*";
case B_TRMUL:
return "'";
case B_DIV:
return "/";
case B_LDIV:
return "\\";
case B_MOD:
return "%";
case B_POW:
return "^";
case B_EQ:
return "=";
case B_NEQ:
return "!=";
case B_GT:
return ">";
case B_LT:
return "<";
case B_GTE:
return ">=";
case B_LTE:
return "<=";
case B_AND:
return "&&";
case B_RANGE:
return " to ";
case U_ADDR:
return "&";
case B_OR:
return "||";
case U_NOT:
return "!";
case G_LPR:
return "(";
case G_RPR:
return ")";
case G_LBR:
return "[";
case G_RBR:
return "]";
case G_LCB:
return "{";
case G_RCB:
return "}";
case B_DOTMULT:
return ".*";
case B_DOTDIV:
return "./";
case B_DOTPOW:
return ".^";
case B_DOTADD:
return ".+";
case B_DOTSUB:
return ".-";
case B_DOTEQ:
return ".=";
case B_DOTGT:
return ".>";
case B_DOTLT:
return ".<";
case B_DOTGTE:
return ".>=";
case B_DOTLTE:
return ".<=";
case B_KRON:
return "**";
case B_HCAT:
return "~";
case B_VCAT:
return "|";
case B_LCAT:
return "LCAT";
case P_COM:
return ",";
case P_DOT:
return ".";
case P_SEMI:
return ";";
case P_COL:
return ":";
case QUERY:
return "query";
case LAG:
return "lag";
default:
break;
}
return "unknown";
}
