JSBool
Library::Name(JSContext* cx, uintN argc, jsval *vp)
{
if (argc != 1) {
JS_ReportError(cx, "libraryName takes one argument");
return JS_FALSE;
}
jsval arg = JS_ARGV(cx, vp)[0];
JSString* str = NULL;
if (JSVAL_IS_STRING(arg)) {
str = JSVAL_TO_STRING(arg);
}
else {
JS_ReportError(cx, "name argument must be a string");
return JS_FALSE;
}
AutoString resultString;
AppendString(resultString, DLL_PREFIX);
AppendString(resultString, str);
AppendString(resultString, DLL_SUFFIX);
JSString *result = JS_NewUCStringCopyN(cx, resultString.begin(),
resultString.length());
if (!result)
return JS_FALSE;
JS_SET_RVAL(cx, vp, STRING_TO_JSVAL(result));
return JS_TRUE;
}
bool
Library::Name(JSContext* cx, unsigned argc, Value* vp)
{
CallArgs args = CallArgsFromVp(argc, vp);
if (args.length() != 1) {
JS_ReportErrorASCII(cx, "libraryName takes one argument");
return false;
}
Value arg = args[0];
JSString* str = nullptr;
if (arg.isString()) {
str = arg.toString();
} else {
JS_ReportErrorASCII(cx, "name argument must be a string");
return false;
}
AutoString resultString;
AppendString(resultString, DLL_PREFIX);
AppendString(resultString, str);
AppendString(resultString, DLL_SUFFIX);
JSString* result = JS_NewUCStringCopyN(cx, resultString.begin(),
resultString.length());
if (!result)
return false;
args.rval().setString(result);
return true;
}
AString
sp::BuildTypeName(Type *aType, Atom *name, TypeDiagFlags flags)
{
if (ArrayType *type = aType->asArray()) {
Vector<ArrayType *> stack;
Type *cursor = type;
Type *innermost = nullptr;
for (;;) {
if (!cursor->isArray()) {
innermost = cursor;
break;
}
stack.append(cursor->toArray());
cursor = cursor->toArray()->contained();
}
AutoString builder;
if (aType->isConst() || !!(flags & TypeDiagFlags::IsConst))
builder = "const ";
builder = builder + BuildTypeName(innermost, nullptr, flags & kDiagFlagsInnerMask);
bool hasFixedLengths = false;
AutoString brackets;
for (size_t i = 0; i < stack.length(); i++) {
if (!stack[i]->hasFixedLength()) {
brackets = brackets + "[]";
continue;
}
hasFixedLengths = true;
brackets = brackets + "[" + AutoString(stack[i]->fixedLength()) + "]";
}
if (name) {
if (hasFixedLengths)
builder = builder + " " + name->chars() + brackets;
else
builder = builder + brackets + " " + name->chars();
} else {
builder = builder + brackets;
}
return AString(builder.ptr());
}
AutoString builder;
if (FunctionType *type = aType->asFunction())
builder = BuildTypeFromSignature(type->signature(), flags & kDiagFlagsInnerMask);
else
builder = GetBaseTypeName(aType);
if (!!(flags & TypeDiagFlags::IsByRef)) {
builder = builder + "&";
}
if (name)
builder = builder + " " + name->chars();
return AString(builder.ptr());
}
Status pluginGet(int argc, char *argv[])
{
if (argc != 4)
return ABC_ERROR(ABC_CC_Error, "usage: ... plugin-get <user> <pass> <plugin> <key>");
AutoString result;
ABC_CHECK_OLD(ABC_PluginDataGet(argv[0], argv[1], argv[2], argv[3], &result.get(), &error));
std::cout << '"' << result.get() << '"' << std::endl;
return Status();
}
Status
otpResetGet(int argc, char *argv[])
{
if (argc != 0)
return ABC_ERROR(ABC_CC_Error, "usage: ... otp-reset-get");
AutoString names;
ABC_CHECK_OLD(ABC_OtpResetGet(&names.get(), &error));
std::cout << names.get() << std::endl;
return Status();
}
Status
otpKeyGet(int argc, char *argv[])
{
if (argc != 1)
return ABC_ERROR(ABC_CC_Error, "usage: ... otp-key-get <user>");
AutoString key;
ABC_CHECK_OLD(ABC_OtpKeyGet(argv[0], &key.get(), &error));
std::cout << "key: " << key.get() << std::endl;
return Status();
}
bool
Preprocessor::enterFile(TokenKind directive,
const SourceLocation &from,
const char *file,
const char *where)
{
if (disable_includes_)
return false;
AutoString path = searchPaths(file, where);
if (!path.length()) {
// Try to append '.inc'.
size_t len = strlen(file);
if (len < 4 || strcmp(&file[len - 4], ".inc") != 0) {
AutoString new_file = AutoString(file) + ".inc";
path = searchPaths(new_file, where);
}
}
if (!path.length()) {
if (directive == TOK_M_TRYINCLUDE)
return true;
cc_.report(from, rmsg::include_not_found)
<< file;
return false;
}
ReportingContext rc(cc_, from);
Ref<SourceFile> new_file = cc_.source().open(rc, path.ptr());
if (!new_file)
return false;
LREntry tl = cc_.source().trackFile(from, new_file);
if (!tl.valid()) {
// Error was already reported.
return false;
}
if (include_depth_ >= kMaxIncludeDepth) {
cc_.report(from, rmsg::include_depth_exceeded);
return false;
}
include_depth_++;
assert(!macro_lexer_ && lexer_);
lexer_stack_.append(SavedLexer(lexer_, nullptr));
lexer_ = new Lexer(cc_, *this, lexer_->options(), new_file, tl);
return true;
}
static AString
BuildTypeFromSignature(const FunctionSignature *sig, TypeDiagFlags flags)
{
AutoString base = "function ";
base = base + BuildTypeFromTypeExpr(sig->returnType(), nullptr, flags & kDiagFlagsInnerMask);
base = base + "(";
for (size_t i = 0; i < sig->parameters()->length(); i++) {
TypeDiagFlags varFlags = flags & kDiagFlagsInnerMask;
Atom *name = !!(flags & TypeDiagFlags::Names)
? sig->parameters()->at(i)->name()
: nullptr;
if (sig->parameters()->at(i)->sym()->isByRef())
varFlags |= TypeDiagFlags::IsByRef;
base = base + BuildTypeFromTypeExpr(sig->parameters()->at(i)->te(), name, varFlags);
if (i != sig->parameters()->length() - 1)
base = base + ", ";
}
base = base + ")";
return AString(base.ptr());
}
JsonList *toJson(const ParameterList *params) {
JsonList *list = new (pool_) JsonList();
for (size_t i = 0; i < params->length(); i++) {
VarDecl *decl = params->at(i);
JsonObject *obj = new (pool_) JsonObject();
obj->add(atom_type_, toJson(decl, false));
if (decl->name()) {
obj->add(atom_name_, toJson(decl->name()));
obj->add(atom_decl_, toJson(decl, true));
} else {
obj->add(atom_name_, toJson("..."));
AutoString builder = BuildTypeName(decl->te(), nullptr, TypeDiagFlags::Names);
builder = builder + " ...";
obj->add(atom_decl_, toJson(builder.ptr()));
}
list->add(obj);
}
return list;
}
HRESULT Helpers::LoadScriptFromFile(LPCSTR filenameToLoad, LPCSTR& contents, UINT* lengthBytesOut /*= nullptr*/, std::string* fullPath /*= nullptr*/, bool shouldMute /*=false */)
{
static char sHostApplicationPathBuffer[MAX_URI_LENGTH];
static uint sHostApplicationPathBufferLength = (uint) -1;
char combinedPathBuffer[MAX_URI_LENGTH];
HRESULT hr = S_OK;
BYTE * pRawBytes = nullptr;
BYTE * pRawBytesFromMap = nullptr;
UINT lengthBytes = 0;
contents = nullptr;
FILE * file = NULL;
size_t bufferLength = 0;
LPCSTR filename = fullPath == nullptr ? filenameToLoad : LPCSTR(fullPath->c_str());
if (sHostApplicationPathBufferLength == (uint)-1)
{
// consider incoming filename as the host app and base its' path for others
sHostApplicationPathBufferLength = GetPathNameLocation(filename);
if (sHostApplicationPathBufferLength == -1)
{
// host app has no path info. (it must be located on current folder!)
sHostApplicationPathBufferLength = 0;
}
else
{
sHostApplicationPathBufferLength += 1;
Assert(sHostApplicationPathBufferLength < MAX_URI_LENGTH);
// save host app's path and fix the path separator for platform
pathcpy(sHostApplicationPathBuffer, filename, sHostApplicationPathBufferLength);
}
sHostApplicationPathBuffer[sHostApplicationPathBufferLength] = char(0);
}
else if (filename[0] != '/' && filename[0] != '\\' && fullPath == nullptr) // make sure it's not a full path
{
// concat host path and filename
uint len = ConcatPath(sHostApplicationPathBuffer, sHostApplicationPathBufferLength,
filename, combinedPathBuffer, MAX_URI_LENGTH);
if (len == (uint)-1)
{
hr = E_FAIL;
goto Error;
}
filename = combinedPathBuffer;
}
// check if have it registered
AutoString *data;
if (SourceMap::Find(filenameToLoad, strlen(filenameToLoad), &data) ||
SourceMap::Find(filename, strlen(filename), &data))
{
pRawBytesFromMap = (BYTE*) data->GetString();
lengthBytes = (UINT) data->GetLength();
}
else
{
// Open the file as a binary file to prevent CRT from handling encoding, line-break conversions,
// etc.
if (fopen_s(&file, filename, "rb") != 0)
{
if (!HostConfigFlags::flags.MuteHostErrorMsgIsEnabled && !shouldMute)
{
#ifdef _WIN32
DWORD lastError = GetLastError();
char16 wszBuff[MAX_URI_LENGTH];
fprintf(stderr, "Error in opening file '%s' ", filename);
wszBuff[0] = 0;
if (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
nullptr,
lastError,
0,
wszBuff,
_countof(wszBuff),
nullptr))
{
fwprintf(stderr, _u(": %s"), wszBuff);
}
fwprintf(stderr, _u("\n"));
#elif defined(_POSIX_VERSION)
fprintf(stderr, "Error in opening file: ");
perror(filename);
#endif
}
IfFailGo(E_FAIL);
}
}
if (file != NULL)
{
// Determine the file length, in bytes.
fseek(file, 0, SEEK_END);
lengthBytes = ftell(file);
fseek(file, 0, SEEK_SET);
}
if (lengthBytes != 0)
{
bufferLength = lengthBytes + sizeof(BYTE);
pRawBytes = (LPBYTE)malloc(bufferLength);
}
else
{
bufferLength = 1;
pRawBytes = (LPBYTE)malloc(bufferLength);
}
if (nullptr == pRawBytes)
{
fwprintf(stderr, _u("out of memory"));
IfFailGo(E_OUTOFMEMORY);
}
if (lengthBytes != 0)
{
if (file != NULL)
{
//
// Read the entire content as a binary block.
//
size_t readBytes = fread(pRawBytes, sizeof(BYTE), lengthBytes, file);
if (readBytes < lengthBytes * sizeof(BYTE))
{
IfFailGo(E_FAIL);
}
}
else // from module source register
{
// Q: module source is on persistent memory. Why do we use the copy instead?
// A: if we use the same memory twice, ch doesn't know that during FinalizeCallback free.
// the copy memory will be freed by the finalizer
Assert(pRawBytesFromMap);
memcpy_s(pRawBytes, bufferLength, pRawBytesFromMap, lengthBytes);
}
}
if (pRawBytes)
{
pRawBytes[lengthBytes] = 0; // Null terminate it. Could be UTF16
}
if (file != NULL)
{
//
// Read encoding to make sure it's supported
//
// Warning: The UNICODE buffer for parsing is supposed to be provided by the host.
// This is not a complete read of the encoding. Some encodings like UTF7, UTF1, EBCDIC, SCSU, BOCU could be
// wrongly classified as ANSI
//
#pragma warning(push)
// suppressing prefast warning that "readable size is bufferLength
// bytes but 2 may be read" as bufferLength is clearly > 2 in the code that follows
#pragma warning(disable:6385)
C_ASSERT(sizeof(WCHAR) == 2);
if (bufferLength > 2)
{
__analysis_assume(bufferLength > 2);
#pragma prefast(push)
#pragma prefast(disable:6385, "PREfast incorrectly reports this as an out-of-bound access.");
if ((pRawBytes[0] == 0xFE && pRawBytes[1] == 0xFF) ||
(pRawBytes[0] == 0xFF && pRawBytes[1] == 0xFE) ||
(bufferLength > 4 && pRawBytes[0] == 0x00 && pRawBytes[1] == 0x00 &&
((pRawBytes[2] == 0xFE && pRawBytes[3] == 0xFF) ||
(pRawBytes[2] == 0xFF && pRawBytes[3] == 0xFE))))
{
// unicode unsupported
fwprintf(stderr, _u("unsupported file encoding. Only ANSI and UTF8 supported"));
IfFailGo(E_UNEXPECTED);
}
#pragma prefast(pop)
}
#pragma warning(pop)
}
contents = reinterpret_cast<LPCSTR>(pRawBytes);
Error:
if (SUCCEEDED(hr))
{
if (lengthBytesOut)
{
*lengthBytesOut = lengthBytes;
}
}
if (file != NULL)
{
fclose(file);
}
if (pRawBytes && reinterpret_cast<LPCSTR>(pRawBytes) != contents)
{
free(pRawBytes);
}
return hr;
}
/** Load the PLY mesh. */
bool PiMeshImportPLY::Import(const char * name) {
// Reset mesh.
mesh->Reset();
// Open file.
PiAutoPtr<PiVirtualFile> vf( PiFileSystem::OpenFile( name ) );
if( vf == NULL ) {
piDebug( "*** Cannot open PLY file: '%s'\n", name );
return false;
}
piDebug("--- Loading PLY file '%s'.\n", name );
PiParser parser;
parser.StartParseBuffer( vf->GetMem(), vf->GetSize() );
if( !parser.GetToken( true ) || strCmp(parser.token, "ply") ) {
piDebug( "*** File '%s' does not appear to be a ply file.\n", name );
return false;
}
PlyHeader head;
PlyElement * current = NULL;
LL_Reset( &head.elems, next, prev );
bool result = false;
while(true) {
if( !parser.GetToken( true ) ) {
piDebug( "*** Unexpected 'end of file' found while reading ply file '%s'.\n", name );
break;
}
if( !strCmp( parser.token, "format" ) ) {
// 'format' <type> <version>
if( !parser.GetToken( false ) ) {
piDebug( "*** Type expected while reading ply file '%s'.\n", name );
break;
}
if( !strCmp( parser.token, "ascii" ) ) head.format = PLY_ASCII;
else if( !strCmp( parser.token, "binary_big_endian" ) ) head.format = PLY_BINARY_BE;
else if( !strCmp( parser.token, "binary_little_endian" ) ) head.format = PLY_BINARY_LE;
if( !parser.GetToken( false ) ) {
piDebug( "*** Version expected while reading ply file '%s'.\n", name );
break;
}
head.version = 0;
}
else if( !strCmp( parser.token, "element" ) ) {
// 'element' <type> <num>
current = new PlyElement;
LL_Reset( current, next, prev );
LL_AddLast( &head.elems, current, next, prev );
LL_Reset( ¤t->props, next, prev );
if( !parser.GetToken( false ) ) {
piDebug( "*** Element type expected while reading ply file '%s'.\n", name );
break;
}
current->name = piStrDup( parser.token );
if( !strCmp( parser.token, "vertex" ) ) current->type = PLET_VERTEX;
else if( !strCmp( parser.token, "face" ) ) current->type = PLET_FACE;
else current->type = PLET_OTHER;
if( !parser.GetToken( false ) ) {
piDebug( "*** Number of elements expected while reading ply file '%s'.\n", name );
break;
}
current->num = atoi( parser.token );
}
else if( !strCmp( parser.token, "property" ) ) {
// 'property' <type> <name>
PlyProperty * prop = new PlyProperty;
LL_Reset( prop, next, prev );
LL_AddLast( ¤t->props, prop, next, prev );
if( !parser.GetToken( false ) ) {
piDebug( "*** Property type expected while reading ply file '%s'.\n", name );
break;
}
if( !strCmp( parser.token, "list" ) ) {
prop->mode = PLPM_LIST;
if( !parser.GetToken( false ) ) {
piDebug( "*** Property type expected while reading ply file '%s'.\n", name );
break;
}
if( !ReadType( parser, (int &)prop->ctype ) ) {
piDebug( "*** Unknown property type while reading ply file '%s'.\n", name );
break;
}
if( !parser.GetToken( false ) ) {
piDebug( "*** Property type expected while reading ply file '%s'.\n", name );
break;
}
}
else {
prop->mode = PLPM_SCALAR;
}
if( !ReadType( parser, (int &)prop->type ) ) {
piDebug( "*** Unknown property type while reading ply file '%s'.\n", name );
break;
}
// read name
if( !parser.GetToken( false ) ) {
piDebug( "*** Property name expected while reading ply file '%s'.\n", name );
break;
}
prop->name = piStrDup( parser.token );
}
else if( !strCmp( parser.token, "comment" ) ) {
AutoString comment;
while( parser.GetToken( false ) ) {
comment.Append(" ");
comment.Append(parser.token);
};
piDebug( "--- Comment:%s\n", comment.GetStr() );
}
else if( !strCmp( parser.token, "end_header" ) ) {
if( parser.NextLine() )
result = true;
break;
}
};
if( result == false ) {
piDebug("*** Load failed.\n");
}
else {
// Analize what we have:
PlyElement * e;
for( e = head.elems.next; e != &head.elems; e = e->next ) {
if( strCmp( e->name, "vertex" ) == 0 ) {
mesh->SetVertexNum( e->num );
//pos_array.Resize( e->num );
//col_array.Resize( e->num );
}
else if( strCmp( e->name, "face" ) == 0 ) {
// Number of faces is not the number of triangles.
//face_array.Resize( e->num );
}
}
PiMesh::Channel * pos_channel = mesh->GetChannel(mesh->CreateChannel("position", VS_POS, VF_FLOAT, 3));
uint pos_num = 0;
Vec2 tmp(0, 0);
// Extract data.
for( e = head.elems.next; e != &head.elems; e = e->next ) {
for( uint i = 0; i < e->num; i++ ) {
PlyProperty * p;
for( p = e->props.next; p != &e->props; p = p->next ) {
if( p->mode == PLPM_SCALAR ) {
float value;
ReadFloatValue( parser, head.format, p->type, value );
if( strCmp( p->name, "x" ) == 0 ) {
tmp.x = value;
}
else if( strCmp( p->name, "y" ) == 0 ) {
tmp.y = value;
}
else if( strCmp( p->name, "z" ) == 0 ) {
pos_channel->data[pos_num++] = Vec4(tmp, value, 1.0f);
}
}
else if( p->mode == PLPM_LIST ) {
uint count;
ReadIntValue( parser, head.format, p->ctype, count );
uint v0, v1, v2;
ReadIntValue( parser, head.format, p->type, v0 );
ReadIntValue( parser, head.format, p->type, v1 );
// conver poly to fan
for( uint f = 0; f < count-2; f++ ) {
ReadIntValue( parser, head.format, p->type, v2 );
mesh->AddFace(v0, v1, v2);
v1 = v2;
}
}
}
}
}
piDebug("--- Load succeed.\n");
piDebug( "--- %d vertices\n", mesh->GetVertexNum() );
piDebug( "--- %d faces\n", mesh->GetFaceNum() );
}
// clean header
PlyElement * e, * enext;
for( e=head.elems.next; e!=&head.elems; e=enext ) {
enext = e->next;
LL_Reset( e, next, prev );
PlyProperty * p, * pnext;
for( p=e->props.next; p!=&e->props; p=pnext ) {
pnext = p->next;
LL_Reset( p, next, prev );
mem::free( p->name );
delete p;
}
mem::free( e->name );
delete e;
}
return result;
}
bool Debugger::CompareOrWriteBaselineFile(LPCSTR fileName)
{
AutoRestoreContext autoRestoreContext(this->m_context);
// Pass in undefined for 'this'
JsValueRef undefinedRef;
IfJsrtErrorFailLogAndRetFalse(ChakraRTInterface::JsGetUndefinedValue(&undefinedRef));
JsValueRef result = JS_INVALID_REFERENCE;
bool testPassed = false;
if (HostConfigFlags::flags.dbgbaselineIsEnabled)
{
this->CallFunction("Verify", &result);
JsValueRef numberVal;
IfJsrtErrorFailLogAndRetFalse(ChakraRTInterface::JsConvertValueToNumber(result, &numberVal));
int val;
IfJsrtErrorFailLogAndRetFalse(ChakraRTInterface::JsNumberToInt(numberVal, &val));
testPassed = (val == 0);
}
if (!testPassed)
{
this->CallFunction("GetOutputJson", &result);
AutoString baselineData;
IfJsrtErrorFailLogAndRetFalse(baselineData.Initialize(result));
char16 baselineFilename[256];
swprintf_s(baselineFilename, HostConfigFlags::flags.dbgbaselineIsEnabled ? _u("%S.dbg.baseline.rebase") : _u("%S.dbg.baseline"), fileName);
FILE *file = nullptr;
if (_wfopen_s(&file, baselineFilename, _u("wt")) != 0)
{
return false;
}
if (file != nullptr)
{
int countWritten = static_cast<int>(fwrite(baselineData.GetString(), sizeof(char), baselineData.GetLength(), file));
Assert(baselineData.GetLength() <= INT_MAX);
if (countWritten != (int)baselineData.GetLength())
{
Assert(false);
return false;
}
fclose(file);
}
if (!HostConfigFlags::flags.dbgbaselineIsEnabled)
{
wprintf(_u("No baseline file specified, baseline created at '%s'\n"), baselineFilename);
}
else
{
Helpers::LogError(_u("Rebase file created at '%s'\n"), baselineFilename);
}
}
return true;
}
static AString
BuildTypeFromSpecifier(const TypeSpecifier *spec, Atom *name, TypeDiagFlags flags)
{
AutoString base;
if (spec->isConst() || !!(flags & TypeDiagFlags::IsConst))
base = "const ";
switch (spec->resolver()) {
case TOK_LABEL:
{
// HACK: we should move these atoms into the context.
const char *chars = spec->proxy()->name()->chars();
if (strcmp(chars, "Float") == 0)
base = base + "float";
else if (strcmp(chars, "String") == 0)
base = base + "char";
else if (strcmp(chars, "_") == 0)
base = base + "int";
else
base = base + chars;
break;
}
case TOK_NAME:
base = base + spec->proxy()->name()->chars();
break;
case TOK_IMPLICIT_INT:
base = base + "int";
break;
case TOK_FUNCTION:
base = base + BuildTypeFromSignature(spec->signature(), flags & kDiagFlagsInnerMask);
break;
case TOK_DEFINED:
base = base + BuildTypeName(spec->getResolvedBase(), nullptr, flags & kDiagFlagsInnerMask);
break;
default:
base = base + TokenNames[spec->resolver()];
break;
}
// We need type analysis to determine the true type, so just make a semi-
// intelligent guess based on whether or not any rank has a sized dimension.
bool postDims = (spec->isNewDecl() && spec->hasPostDims()) ||
(spec->isOldDecl() && spec->dims());
if (name && postDims)
base = base + " " + name->chars();
for (size_t i = 0; i < spec->rank(); i++) {
if (Expression *expr = spec->sizeOfRank(i)) {
if (IntegerLiteral *lit = expr->asIntegerLiteral()) {
char value[24];
SafeSprintf(value, sizeof(value), "%d", (int)lit->value());
base = base + "[" + value + "]";
continue;
}
}
// Hack. We can do better if it becomes necessary, these types are only
// for diagnostics.
base = base + "[]";
}
if (name && !postDims) {
base = base + " ";
if (spec->isByRef())
base = base + "&";
base = base + name->chars();
} else {
if (spec->isByRef())
base = base + "&";
}
if (spec->isVariadic())
base = base + " ...";
return AString(base.ptr());
}
