static JSBool jwindow_dialog(JSContext *cx, JSObject *obj,uintN argc, jsval *argv, jsval *rval, int which_dialogue) { WebcJSDocumentContext *jsmgr = (WebcJSDocumentContext *) jhutil_GetPrivate(cx, obj); HTMLDocument *pDoc = (jsmgr)? jsmgr->GetDocument() : 0; if (argc < 1) return(JS_FALSE); char *prompt_str = JS_GetStringBytes(JS_ValueToString(cx, argv[0])); // << EDIT 20080120 - Needs work // Clone the graphics abstraction layer function pointers so we know who to call HTMLBrowserConfig config, docConfig; rtp_memset(&config, 0, sizeof(config)); rtp_memset(&docConfig, 0, sizeof(docConfig)); pDoc->GetBrowser()->GetConfig(&docConfig); config.graphics = docConfig.graphics; switch (which_dialogue) { case WHICH_DIALOGUE_ALERT: config.WindowConfig.left = WEBC_SKIN_ALERT_LEFT; config.WindowConfig.top = WEBC_SKIN_ALERT_TOP; config.WindowConfig.width = WEBC_SKIN_ALERT_WIDTH; config.WindowConfig.height = WEBC_SKIN_ALERT_HEIGHT; break; case WHICH_DIALOGUE_PROMPT: config.WindowConfig.left = WEBC_SKIN_PROMPT_LEFT; config.WindowConfig.top = WEBC_SKIN_PROMPT_TOP; config.WindowConfig.width = WEBC_SKIN_PROMPT_WIDTH; config.WindowConfig.height = WEBC_SKIN_PROMPT_HEIGHT; break; case WHICH_DIALOGUE_CONFIRM: default: config.WindowConfig.left = WEBC_SKIN_CONFIRM_LEFT; config.WindowConfig.top = WEBC_SKIN_CONFIRM_TOP; config.WindowConfig.width = WEBC_SKIN_CONFIRM_WIDTH; config.WindowConfig.height = WEBC_SKIN_CONFIRM_HEIGHT; break; } config.WindowConfig.WindowFlags |= WF_MODAL; HBROWSER_HANDLE Browser = webc_CreateBrowser(&config, WEBC_TRUE,"dialog", ""); if (Browser) { HDOC_HANDLE hDoc = webc_BrowserGetDocument(Browser); wcCtx Ctx; char buff[128]; wcCtxtInit(&Ctx, (wcBROW) Browser, (wcDOC) hDoc); /* Experimental */ wcDocClear(&Ctx, wcFALSE); wcDocOpen(&Ctx); // Create a link between 'C' and Javascript the Native 'C' function PromptDismiss will // be called with the value of the input field. webc_JScriptDefineFunction(hDoc, "PromptDismiss", (JSNative) PromptDismiss, 0); if (which_dialogue == WHICH_DIALOGUE_ALERT) { WriteDlgLine(&Ctx, WEBC_SKIN_ALERT_SOURCE_1); WriteDlgLine(&Ctx, prompt_str); WriteDlgLine(&Ctx, WEBC_SKIN_ALERT_SOURCE_2); WriteDlgLine(&Ctx, WEBC_SKIN_ALERT_SOURCE_3); } else if (which_dialogue == WHICH_DIALOGUE_CONFIRM) { WriteDlgLine(&Ctx, WEBC_SKIN_CONFIRM_SOURCE_1); WriteDlgLine(&Ctx, prompt_str); WriteDlgLine(&Ctx, WEBC_SKIN_CONFIRM_SOURCE_2); WriteDlgLine(&Ctx, WEBC_SKIN_CONFIRM_SOURCE_3); } else if (which_dialogue == WHICH_DIALOGUE_PROMPT) { char *default_str = ""; if (argc > 1) default_str = JS_GetStringBytes(JS_ValueToString(cx, argv[1])); WriteDlgLine(&Ctx, prompt_str); rtp_sprintf(&buff[0],WEBC_SKIN_PROMPT_SOURCE_1,default_str); WriteDlgLine(&Ctx, &buff[0]); WriteDlgLine(&Ctx, WEBC_SKIN_PROMPT_SOURCE_2); WriteDlgLine(&Ctx, WEBC_SKIN_PROMPT_SOURCE_3); } wcDocClose(&Ctx); wcDocRefresh(&Ctx); /* Go modal here */ // HBROWSER_HANDLE Browser = webc_CreateBrowser(&config, WEBC_TRUE, ""); HTMLBrowser *pBrowser = (HTMLBrowser *) Browser; while (pBrowser->ProcessInputQueue(WEBC_TRUE) >= 0) { WebString *user_WebString; void* privateData = webc_BrowserGetPrivateData(Browser); if (privateData) { user_WebString = (WebString *) privateData; if (which_dialogue == WHICH_DIALOGUE_PROMPT) { if (user_WebString && user_WebString->getLength()) *rval = STRING_TO_JSVAL(WEBC_JS_NEW_STRING_COPY_Z(cx, user_WebString->getChars())); else *rval = JSVAL_VOID; } else if (which_dialogue == WHICH_DIALOGUE_ALERT) *rval = JSVAL_VOID; else if (which_dialogue == WHICH_DIALOGUE_CONFIRM) { if (user_WebString && webc_c_strcmp(user_WebString->getChars(), "OK")==0) *rval = BOOLEAN_TO_JSVAL(JS_TRUE); else *rval = BOOLEAN_TO_JSVAL(JS_FALSE); } WEBC_DELETE(user_WebString); webc_JScriptExecuteSource(hDoc, "window.close();"); break; } } } return jutils_CheckContextState(cx); }
JSAtom * js_AtomizeString(JSContext *cx, JSString *str, uintN flags) { jsval v; JSAtomState *state; JSDHashTable *table; JSAtomHashEntry *entry; JSString *key; uint32 gen; JS_ASSERT(!(flags & ~(ATOM_PINNED|ATOM_INTERNED|ATOM_TMPSTR|ATOM_NOCOPY))); JS_ASSERT_IF(flags & ATOM_NOCOPY, flags & ATOM_TMPSTR); if (str->isAtomized()) return (JSAtom *) STRING_TO_JSVAL(str); size_t length = str->length(); if (length == 1) { jschar c = str->chars()[0]; if (c < UNIT_STRING_LIMIT) return (JSAtom *) STRING_TO_JSVAL(JSString::unitString(c)); } /* * Here we know that JSString::intStringTable covers only 256 (or at least * not 1000 or more) chars. We rely on order here to resolve the unit vs. * int string atom identity issue by giving priority to unit strings for * '0' through '9' (see JSString::intString in jsstrinlines.h). */ JS_STATIC_ASSERT(INT_STRING_LIMIT <= 999); if (2 <= length && length <= 3) { const jschar *chars = str->chars(); if ('1' <= chars[0] && chars[0] <= '9' && '0' <= chars[1] && chars[1] <= '9' && (length == 2 || ('0' <= chars[2] && chars[2] <= '9'))) { jsint i = (chars[0] - '0') * 10 + chars[1] - '0'; if (length == 3) i = i * 10 + chars[2] - '0'; if (jsuint(i) < INT_STRING_LIMIT) return (JSAtom *) STRING_TO_JSVAL(JSString::intString(i)); } } state = &cx->runtime->atomState; table = &state->stringAtoms; JS_LOCK(cx, &state->lock); entry = TO_ATOM_ENTRY(JS_DHashTableOperate(table, str, JS_DHASH_ADD)); if (!entry) goto failed_hash_add; if (entry->keyAndFlags != 0) { key = (JSString *)ATOM_ENTRY_KEY(entry); } else { /* * We created a new hashtable entry. Unless str is already allocated * from the GC heap and flat, we have to release state->lock as * string construction is a complex operation. For example, it can * trigger GC which may rehash the table and make the entry invalid. */ ++table->generation; if (!(flags & ATOM_TMPSTR) && str->isFlat()) { str->flatClearMutable(); key = str; } else { gen = table->generation; JS_UNLOCK(cx, &state->lock); if (flags & ATOM_TMPSTR) { if (flags & ATOM_NOCOPY) { key = js_NewString(cx, str->flatChars(), str->flatLength()); if (!key) return NULL; /* Finish handing off chars to the GC'ed key string. */ str->mChars = NULL; } else { key = js_NewStringCopyN(cx, str->flatChars(), str->flatLength()); if (!key) return NULL; } } else { JS_ASSERT(str->isDependent()); if (!js_UndependString(cx, str)) return NULL; key = str; } JS_LOCK(cx, &state->lock); if (table->generation == gen) { JS_ASSERT(entry->keyAndFlags == 0); } else { entry = TO_ATOM_ENTRY(JS_DHashTableOperate(table, key, JS_DHASH_ADD)); if (!entry) goto failed_hash_add; if (entry->keyAndFlags != 0) { key = (JSString *)ATOM_ENTRY_KEY(entry); goto finish; } ++table->generation; } } INIT_ATOM_ENTRY(entry, key); key->flatSetAtomized(); } finish: ADD_ATOM_ENTRY_FLAGS(entry, flags & (ATOM_PINNED | ATOM_INTERNED)); JS_ASSERT(key->isAtomized()); v = STRING_TO_JSVAL(key); cx->weakRoots.lastAtom = v; JS_UNLOCK(cx, &state->lock); return (JSAtom *)v; failed_hash_add: JS_UNLOCK(cx, &state->lock); JS_ReportOutOfMemory(cx); return NULL; }
JSDProperty* jsd_GetValueProperty(JSDContext* jsdc, JSDValue* jsdval, JSString* name) { JSContext* cx = jsdc->dumbContext; JSDProperty* jsdprop; JSDProperty* iter = NULL; JSObject* obj; uintN attrs = 0; JSBool found; JSPropertyDesc pd; const jschar * nameChars; size_t nameLen; jsval val, nameval; jsid nameid; JSCrossCompartmentCall *call = NULL; if(!jsd_IsValueObject(jsdc, jsdval)) return NULL; /* If we already have the prop, then return it */ while(NULL != (jsdprop = jsd_IterateProperties(jsdc, jsdval, &iter))) { JSString* propName = jsd_GetValueString(jsdc, jsdprop->name); if(propName) { intN result; if (JS_CompareStrings(cx, propName, name, &result) && !result) return jsdprop; } JSD_DropProperty(jsdc, jsdprop); } /* Not found in property list, look it up explicitly */ if(!(obj = JSVAL_TO_OBJECT(jsdval->val))) return NULL; if (!(nameChars = JS_GetStringCharsZAndLength(cx, name, &nameLen))) return NULL; JS_BeginRequest(cx); call = JS_EnterCrossCompartmentCall(cx, obj); if(!call) { JS_EndRequest(cx); return NULL; } JS_GetUCPropertyAttributes(cx, obj, nameChars, nameLen, &attrs, &found); if (!found) { JS_LeaveCrossCompartmentCall(call); JS_EndRequest(cx); return NULL; } JS_ClearPendingException(cx); if(!JS_GetUCProperty(cx, obj, nameChars, nameLen, &val)) { if (JS_IsExceptionPending(cx)) { if (!JS_GetPendingException(cx, &pd.value)) { JS_LeaveCrossCompartmentCall(call); JS_EndRequest(cx); return NULL; } pd.flags = JSPD_EXCEPTION; } else { pd.flags = JSPD_ERROR; pd.value = JSVAL_VOID; } } else { pd.value = val; } JS_LeaveCrossCompartmentCall(call); JS_EndRequest(cx); nameval = STRING_TO_JSVAL(name); if (!JS_ValueToId(cx, nameval, &nameid) || !JS_IdToValue(cx, nameid, &pd.id)) { return NULL; } pd.slot = pd.spare = 0; pd.alias = JSVAL_NULL; pd.flags |= (attrs & JSPROP_ENUMERATE) ? JSPD_ENUMERATE : 0 | (attrs & JSPROP_READONLY) ? JSPD_READONLY : 0 | (attrs & JSPROP_PERMANENT) ? JSPD_PERMANENT : 0; return _newProperty(jsdc, &pd, JSDPD_HINTED); }
JS_BINDED_PROP_GET_IMPL(FakeAudio, src) { JSString* str = JS_NewStringCopyZ(cx, src.c_str()); vp.set(STRING_TO_JSVAL(str)); return JS_TRUE; }
// Clone a new value (and root it and add it to the mapping) jsval Clone(jsval val) { if (JSVAL_IS_DOUBLE(val)) { jsval rval; CLONE_REQUIRE(JS_NewNumberValue(cxTo, JSVAL_TO_DOUBLE(val), &rval), L"JS_NewNumberValue"); m_RooterTo.Push(rval); return rval; } if (JSVAL_IS_STRING(val)) { size_t len; const jschar* chars = JS_GetStringCharsAndLength(cxFrom, JSVAL_TO_STRING(val), &len); CLONE_REQUIRE(chars, L"JS_GetStringCharsAndLength"); JSString* str = JS_NewUCStringCopyN(cxTo, chars, len); CLONE_REQUIRE(str, L"JS_NewUCStringCopyN"); jsval rval = STRING_TO_JSVAL(str); m_Mapping[JSVAL_TO_GCTHING(val)] = rval; m_RooterTo.Push(rval); return rval; } ENSURE(JSVAL_IS_OBJECT(val)); JSObject* newObj; if (JS_IsArrayObject(cxFrom, JSVAL_TO_OBJECT(val))) { jsuint length; CLONE_REQUIRE(JS_GetArrayLength(cxFrom, JSVAL_TO_OBJECT(val), &length), L"JS_GetArrayLength"); newObj = JS_NewArrayObject(cxTo, length, NULL); CLONE_REQUIRE(newObj, L"JS_NewArrayObject"); } else { newObj = JS_NewObject(cxTo, NULL, NULL, NULL); CLONE_REQUIRE(newObj, L"JS_NewObject"); } m_Mapping[JSVAL_TO_GCTHING(val)] = OBJECT_TO_JSVAL(newObj); m_RooterTo.Push(newObj); AutoJSIdArray ida (cxFrom, JS_Enumerate(cxFrom, JSVAL_TO_OBJECT(val))); CLONE_REQUIRE(ida.get(), L"JS_Enumerate"); AutoGCRooter idaRooter(scriptInterfaceFrom); idaRooter.Push(ida.get()); for (size_t i = 0; i < ida.length(); ++i) { jsid id = ida[i]; jsval idval, propval; CLONE_REQUIRE(JS_IdToValue(cxFrom, id, &idval), L"JS_IdToValue"); CLONE_REQUIRE(JS_GetPropertyById(cxFrom, JSVAL_TO_OBJECT(val), id, &propval), L"JS_GetPropertyById"); jsval newPropval = GetOrClone(propval); if (JSVAL_IS_INT(idval)) { // int jsids are portable across runtimes CLONE_REQUIRE(JS_SetPropertyById(cxTo, newObj, id, &newPropval), L"JS_SetPropertyById"); } else if (JSVAL_IS_STRING(idval)) { // string jsids are runtime-specific, so we need to copy the string content JSString* idstr = JS_ValueToString(cxFrom, idval); CLONE_REQUIRE(idstr, L"JS_ValueToString (id)"); size_t len; const jschar* chars = JS_GetStringCharsAndLength(cxFrom, idstr, &len); CLONE_REQUIRE(idstr, L"JS_GetStringCharsAndLength (id)"); CLONE_REQUIRE(JS_SetUCProperty(cxTo, newObj, chars, len, &newPropval), L"JS_SetUCProperty"); } else { // this apparently could be an XML object; ignore it } } return OBJECT_TO_JSVAL(newObj); }
static JSBool log_and_maybe_keep_exception(JSContext *context, char **message_p, gboolean keep) { jsval exc = JSVAL_VOID; JSString *s; char *message; JSBool retval = JS_FALSE; JS_BeginRequest(context); if (message_p) *message_p = NULL; JS_AddRoot(context, &exc); if (!JS_GetPendingException(context, &exc)) goto out; JS_ClearPendingException(context); s = JS_ValueToString(context, exc); if (s == NULL) { gjs_debug(GJS_DEBUG_ERROR, "Failed to convert exception to string"); goto out; /* Exception should be thrown already */ } if (!gjs_string_to_utf8(context, STRING_TO_JSVAL(s), &message)) { gjs_debug(GJS_DEBUG_ERROR, "Failed to convert exception string to UTF-8"); goto out; /* Error already set */ } gjs_debug(GJS_DEBUG_ERROR, "Exception was: %s", message); if (message_p) { *message_p = message; } else { g_free(message); } gjs_log_exception_props(context, exc); /* We clear above and then set it back so any exceptions * from the logging process don't overwrite the original */ if (keep) JS_SetPendingException(context, exc); retval = JS_TRUE; out: JS_RemoveRoot(context, &exc); JS_EndRequest(context); return retval; }
/* * Return a string that may eval to something similar to the original object. */ static JSBool exn_toSource(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) { jsval v; JSString *name, *message, *filename, *lineno_as_str, *result; int32 lineno; size_t lineno_length, name_length, message_length, filename_length, length; jschar *chars, *cp; if (!OBJ_GET_PROPERTY(cx, obj, (jsid)cx->runtime->atomState.nameAtom, &v)) return JS_FALSE; name = js_ValueToString(cx, v); if (!name) return JS_FALSE; if (!JS_GetProperty(cx, obj, js_message_str, &v) || !(message = js_ValueToSource(cx, v))) { return JS_FALSE; } if (!JS_GetProperty(cx, obj, js_filename_str, &v) || !(filename = js_ValueToSource(cx, v))) { return JS_FALSE; } if (!JS_GetProperty(cx, obj, js_lineno_str, &v) || !js_ValueToInt32 (cx, v, &lineno)) { return JS_FALSE; } if (lineno != 0) { if (!(lineno_as_str = js_ValueToString(cx, v))) { return JS_FALSE; } lineno_length = JSSTRING_LENGTH(lineno_as_str); } else { lineno_as_str = NULL; lineno_length = 0; } /* Magic 8, for the characters in ``(new ())''. */ name_length = JSSTRING_LENGTH(name); message_length = JSSTRING_LENGTH(message); length = 8 + name_length + message_length; filename_length = JSSTRING_LENGTH(filename); if (filename_length != 0) { /* append filename as ``, {filename}'' */ length += 2 + filename_length; if (lineno_as_str) { /* append lineno as ``, {lineno_as_str}'' */ length += 2 + lineno_length; } } else { if (lineno_as_str) { /* * no filename, but have line number, * need to append ``, "", {lineno_as_str}'' */ length += 6 + lineno_length; } } cp = chars = (jschar*) JS_malloc(cx, (length + 1) * sizeof(jschar)); if (!chars) return JS_FALSE; *cp++ = '('; *cp++ = 'n'; *cp++ = 'e'; *cp++ = 'w'; *cp++ = ' '; js_strncpy(cp, JSSTRING_CHARS(name), name_length); cp += name_length; *cp++ = '('; if (message_length != 0) { js_strncpy(cp, JSSTRING_CHARS(message), message_length); cp += message_length; } if (filename_length != 0) { /* append filename as ``, {filename}'' */ *cp++ = ','; *cp++ = ' '; js_strncpy(cp, JSSTRING_CHARS(filename), filename_length); cp += filename_length; } else { if (lineno_as_str) { /* * no filename, but have line number, * need to append ``, "", {lineno_as_str}'' */ *cp++ = ','; *cp++ = ' '; *cp++ = '"'; *cp++ = '"'; } } if (lineno_as_str) { /* append lineno as ``, {lineno_as_str}'' */ *cp++ = ','; *cp++ = ' '; js_strncpy(cp, JSSTRING_CHARS(lineno_as_str), lineno_length); cp += lineno_length; } *cp++ = ')'; *cp++ = ')'; *cp = 0; result = js_NewString(cx, chars, length, 0); if (!result) { JS_free(cx, chars); return JS_FALSE; } *rval = STRING_TO_JSVAL(result); return JS_TRUE; }
jsval charptr_to_jsval( JSContext *cx, const char *str) { JSString *ret_obj = JS_NewStringCopyZ(cx, str); return STRING_TO_JSVAL(ret_obj); }
NS_IMETHODIMP TelemetryImpl::GetChromeHangs(JSContext *cx, jsval *ret) { MutexAutoLock hangReportMutex(mHangReportsMutex); JSObject *reportArray = JS_NewArrayObject(cx, 0, nullptr); if (!reportArray) { return NS_ERROR_FAILURE; } *ret = OBJECT_TO_JSVAL(reportArray); // Each hang report is an object in the 'chromeHangs' array for (size_t i = 0; i < mHangReports.Length(); ++i) { JSObject *reportObj = JS_NewObject(cx, NULL, NULL, NULL); if (!reportObj) { return NS_ERROR_FAILURE; } jsval reportObjVal = OBJECT_TO_JSVAL(reportObj); if (!JS_SetElement(cx, reportArray, i, &reportObjVal)) { return NS_ERROR_FAILURE; } // Record the hang duration (expressed in seconds) JSBool ok = JS_DefineProperty(cx, reportObj, "duration", INT_TO_JSVAL(mHangReports[i].duration), NULL, NULL, JSPROP_ENUMERATE); if (!ok) { return NS_ERROR_FAILURE; } // Represent call stack PCs as strings // (JS can't represent all 64-bit integer values) JSObject *pcArray = JS_NewArrayObject(cx, 0, nullptr); if (!pcArray) { return NS_ERROR_FAILURE; } ok = JS_DefineProperty(cx, reportObj, "stack", OBJECT_TO_JSVAL(pcArray), NULL, NULL, JSPROP_ENUMERATE); if (!ok) { return NS_ERROR_FAILURE; } const uint32_t pcCount = mHangReports[i].callStack.Length(); for (size_t pcIndex = 0; pcIndex < pcCount; ++pcIndex) { nsCAutoString pcString; pcString.AppendPrintf("0x%p", mHangReports[i].callStack[pcIndex]); JSString *str = JS_NewStringCopyZ(cx, pcString.get()); if (!str) { return NS_ERROR_FAILURE; } jsval v = STRING_TO_JSVAL(str); if (!JS_SetElement(cx, pcArray, pcIndex, &v)) { return NS_ERROR_FAILURE; } } // Record memory map info JSObject *moduleArray = JS_NewArrayObject(cx, 0, nullptr); if (!moduleArray) { return NS_ERROR_FAILURE; } ok = JS_DefineProperty(cx, reportObj, "memoryMap", OBJECT_TO_JSVAL(moduleArray), NULL, NULL, JSPROP_ENUMERATE); if (!ok) { return NS_ERROR_FAILURE; } #if defined(MOZ_ENABLE_PROFILER_SPS) const uint32_t moduleCount = mHangReports[i].moduleMap.GetSize(); for (size_t moduleIndex = 0; moduleIndex < moduleCount; ++moduleIndex) { // Current module const SharedLibrary &module = mHangReports[i].moduleMap.GetEntry(moduleIndex); JSObject *moduleInfoArray = JS_NewArrayObject(cx, 0, nullptr); if (!moduleInfoArray) { return NS_ERROR_FAILURE; } jsval val = OBJECT_TO_JSVAL(moduleInfoArray); if (!JS_SetElement(cx, moduleArray, moduleIndex, &val)) { return NS_ERROR_FAILURE; } // Start address nsCAutoString addressString; addressString.AppendPrintf("0x%p", module.GetStart()); JSString *str = JS_NewStringCopyZ(cx, addressString.get()); if (!str) { return NS_ERROR_FAILURE; } val = STRING_TO_JSVAL(str); if (!JS_SetElement(cx, moduleInfoArray, 0, &val)) { return NS_ERROR_FAILURE; } // Module name str = JS_NewStringCopyZ(cx, module.GetName()); if (!str) { return NS_ERROR_FAILURE; } val = STRING_TO_JSVAL(str); if (!JS_SetElement(cx, moduleInfoArray, 1, &val)) { return NS_ERROR_FAILURE; } // Module size in memory val = INT_TO_JSVAL(int32_t(module.GetEnd() - module.GetStart())); if (!JS_SetElement(cx, moduleInfoArray, 2, &val)) { return NS_ERROR_FAILURE; } // "PDB Age" identifier val = INT_TO_JSVAL(0); #if defined(MOZ_PROFILING) && defined(XP_WIN) val = INT_TO_JSVAL(module.GetPdbAge()); #endif if (!JS_SetElement(cx, moduleInfoArray, 3, &val)) { return NS_ERROR_FAILURE; } // "PDB Signature" GUID char guidString[NSID_LENGTH] = { 0 }; #if defined(MOZ_PROFILING) && defined(XP_WIN) module.GetPdbSignature().ToProvidedString(guidString); #endif str = JS_NewStringCopyZ(cx, guidString); if (!str) { return NS_ERROR_FAILURE; } val = STRING_TO_JSVAL(str); if (!JS_SetElement(cx, moduleInfoArray, 4, &val)) { return NS_ERROR_FAILURE; } // Name of associated PDB file const char *pdbName = ""; #if defined(MOZ_PROFILING) && defined(XP_WIN) pdbName = module.GetPdbName(); #endif str = JS_NewStringCopyZ(cx, pdbName); if (!str) { return NS_ERROR_FAILURE; } val = STRING_TO_JSVAL(str); if (!JS_SetElement(cx, moduleInfoArray, 5, &val)) { return NS_ERROR_FAILURE; } } #endif } return NS_OK; }
void CThreadDebugger::SaveCallstack() { ENSURE(GetIsInBreak()); CScopeLock lock(m->m_Mutex); JSStackFrame *fp; JSStackFrame *iter = 0; std::string functionName; jsint counter = 0; JSObject* jsArray; jsArray = JS_NewArrayObject(m->m_pScriptInterface->GetContext(), 0, 0); JSString* functionID; fp = JS_FrameIterator(m->m_pScriptInterface->GetContext(), &iter); while (fp) { JSFunction* fun = 0; fun = JS_GetFrameFunction(m->m_pScriptInterface->GetContext(), fp); if (NULL == fun) functionID = JS_NewStringCopyZ(m->m_pScriptInterface->GetContext(), "null"); else { functionID = JS_GetFunctionId(fun); if (NULL == functionID) functionID = JS_NewStringCopyZ(m->m_pScriptInterface->GetContext(), "anonymous"); } JSBool ret = JS_DefineElement(m->m_pScriptInterface->GetContext(), jsArray, counter, STRING_TO_JSVAL(functionID), NULL, NULL, 0); ENSURE(ret); fp = JS_FrameIterator(m->m_pScriptInterface->GetContext(), &iter); counter++; } m->m_Callstack = ""; m->m_Callstack = m->m_pScriptInterface->StringifyJSON(OBJECT_TO_JSVAL(jsArray), false).c_str(); }
// static XPCNativeInterface* XPCNativeInterface::NewInstance(XPCCallContext& ccx, nsIInterfaceInfo* aInfo) { static const PRUint16 MAX_LOCAL_MEMBER_COUNT = 16; XPCNativeMember local_members[MAX_LOCAL_MEMBER_COUNT]; XPCNativeInterface* obj = nsnull; XPCNativeMember* members = nsnull; int i; JSBool failed = JS_FALSE; PRUint16 constCount; PRUint16 methodCount; PRUint16 totalCount; PRUint16 realTotalCount = 0; XPCNativeMember* cur; JSString* str; jsval name; jsval interfaceName; // XXX Investigate lazy init? This is a problem given the // 'placement new' scheme - we need to at least know how big to make // the object. We might do a scan of methods to determine needed size, // then make our object, but avoid init'ing *any* members until asked? // Find out how often we create these objects w/o really looking at // (or using) the members. PRBool canScript; if(NS_FAILED(aInfo->IsScriptable(&canScript)) || !canScript) return nsnull; if(NS_FAILED(aInfo->GetMethodCount(&methodCount)) || NS_FAILED(aInfo->GetConstantCount(&constCount))) return nsnull; // If the interface does not have nsISupports in its inheritance chain // then we know we can't reflect its methods. However, some interfaces that // are used just to reflect constants are declared this way. We need to // go ahead and build the thing. But, we'll ignore whatever methods it may // have. if(!nsXPConnect::IsISupportsDescendant(aInfo)) methodCount = 0; totalCount = methodCount + constCount; if(totalCount > MAX_LOCAL_MEMBER_COUNT) { members = new XPCNativeMember[totalCount]; if(!members) return nsnull; } else { members = local_members; } // NOTE: since getters and setters share a member, we might not use all // of the member objects. for(i = 0; i < methodCount; i++) { const nsXPTMethodInfo* info; if(NS_FAILED(aInfo->GetMethodInfo(i, &info))) { failed = JS_TRUE; break; } // don't reflect Addref or Release if(i == 1 || i == 2) continue; if(!XPCConvert::IsMethodReflectable(*info)) continue; str = JS_InternString(ccx, info->GetName()); if(!str) { NS_ASSERTION(0,"bad method name"); failed = JS_TRUE; break; } name = STRING_TO_JSVAL(str); if(info->IsSetter()) { NS_ASSERTION(realTotalCount,"bad setter"); // Note: ASSUMES Getter/Setter pairs are next to each other // This is a rule of the typelib spec. cur = &members[realTotalCount-1]; NS_ASSERTION(cur->GetName() == name,"bad setter"); NS_ASSERTION(cur->IsReadOnlyAttribute(),"bad setter"); NS_ASSERTION(cur->GetIndex() == i-1,"bad setter"); cur->SetWritableAttribute(); } else { // XXX need better way to find dups // NS_ASSERTION(!LookupMemberByID(name),"duplicate method name"); cur = &members[realTotalCount++]; cur->SetName(name); if(info->IsGetter()) cur->SetReadOnlyAttribute(i); else cur->SetMethod(i); } } if(!failed) { for(i = 0; i < constCount; i++) { const nsXPTConstant* constant; if(NS_FAILED(aInfo->GetConstant(i, &constant))) { failed = JS_TRUE; break; } str = JS_InternString(ccx, constant->GetName()); if(!str) { NS_ASSERTION(0,"bad constant name"); failed = JS_TRUE; break; } name = STRING_TO_JSVAL(str); // XXX need better way to find dups //NS_ASSERTION(!LookupMemberByID(name),"duplicate method/constant name"); cur = &members[realTotalCount++]; cur->SetName(name); cur->SetConstant(i); } } if(!failed) { const char* bytes; if(NS_FAILED(aInfo->GetNameShared(&bytes)) || !bytes || nsnull == (str = JS_InternString(ccx, bytes))) { failed = JS_TRUE; } interfaceName = STRING_TO_JSVAL(str); } if(!failed) { // Use placement new to create an object with the right amount of space // to hold the members array int size = sizeof(XPCNativeInterface); if(realTotalCount > 1) size += (realTotalCount - 1) * sizeof(XPCNativeMember); void* place = new char[size]; if(place) obj = new(place) XPCNativeInterface(aInfo, interfaceName); if(obj) { obj->mMemberCount = realTotalCount; // copy valid members if(realTotalCount) memcpy(obj->mMembers, members, realTotalCount * sizeof(XPCNativeMember)); } } if(members && members != local_members) delete [] members; return obj; }
/** * Define OS-specific constants. * * This function creates or uses JS object |OS.Constants| to store * all its constants. */ bool DefineOSFileConstants(JSContext *cx, JS::Handle<JSObject*> global) { MOZ_ASSERT(gInitialized); if (gPaths == nullptr) { // If an initialization error was ignored, we may end up with // |gInitialized == true| but |gPaths == nullptr|. We cannot // |MOZ_ASSERT| this, as this would kill precompile_cache.js, // so we simply return an error. JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_CANT_OPEN, "OSFileConstants", "initialization has failed"); return false; } JS::Rooted<JSObject*> objOS(cx); if (!(objOS = GetOrCreateObjectProperty(cx, global, "OS"))) { return false; } JS::Rooted<JSObject*> objConstants(cx); if (!(objConstants = GetOrCreateObjectProperty(cx, objOS, "Constants"))) { return false; } // Build OS.Constants.libc JS::Rooted<JSObject*> objLibc(cx); if (!(objLibc = GetOrCreateObjectProperty(cx, objConstants, "libc"))) { return false; } if (!dom::DefineConstants(cx, objLibc, gLibcProperties)) { return false; } #if defined(XP_WIN) // Build OS.Constants.Win JS::Rooted<JSObject*> objWin(cx); if (!(objWin = GetOrCreateObjectProperty(cx, objConstants, "Win"))) { return false; } if (!dom::DefineConstants(cx, objWin, gWinProperties)) { return false; } #endif // defined(XP_WIN) // Build OS.Constants.Sys JS::Rooted<JSObject*> objSys(cx); if (!(objSys = GetOrCreateObjectProperty(cx, objConstants, "Sys"))) { return false; } nsCOMPtr<nsIXULRuntime> runtime = do_GetService(XULRUNTIME_SERVICE_CONTRACTID); if (runtime) { nsAutoCString os; DebugOnly<nsresult> rv = runtime->GetOS(os); MOZ_ASSERT(NS_SUCCEEDED(rv)); JSString* strVersion = JS_NewStringCopyZ(cx, os.get()); if (!strVersion) { return false; } JS::Rooted<JS::Value> valVersion(cx, STRING_TO_JSVAL(strVersion)); if (!JS_SetProperty(cx, objSys, "Name", valVersion)) { return false; } } #if defined(DEBUG) JS::Rooted<JS::Value> valDebug(cx, JSVAL_TRUE); if (!JS_SetProperty(cx, objSys, "DEBUG", valDebug)) { return false; } #endif dom::ConstantSpec umask_cs[] = { { "umask", UINT_TO_JSVAL(gUserUmask) }, PROP_END }; if (!dom::DefineConstants(cx, objSys, umask_cs)) { return false; } // Build OS.Constants.Path JS::Rooted<JSObject*> objPath(cx); if (!(objPath = GetOrCreateObjectProperty(cx, objConstants, "Path"))) { return false; } // Locate libxul // Note that we don't actually provide the full path, only the name of the // library, which is sufficient to link to the library using js-ctypes. #if defined(XP_MACOSX) // Under MacOS X, for some reason, libxul is called simply "XUL", // and we need to provide the full path. nsAutoString libxul; libxul.Append(gPaths->libDir); libxul.Append(NS_LITERAL_STRING("/XUL")); #else // On other platforms, libxul is a library "xul" with regular // library prefix/suffix. nsAutoString libxul; libxul.Append(NS_LITERAL_STRING(DLL_PREFIX)); libxul.Append(NS_LITERAL_STRING("xul")); libxul.Append(NS_LITERAL_STRING(DLL_SUFFIX)); #endif // defined(XP_MACOSX) if (!SetStringProperty(cx, objPath, "libxul", libxul)) { return false; } if (!SetStringProperty(cx, objPath, "libDir", gPaths->libDir)) { return false; } if (!SetStringProperty(cx, objPath, "tmpDir", gPaths->tmpDir)) { return false; } // Configure profileDir only if it is available at this stage if (!gPaths->profileDir.IsVoid() && !SetStringProperty(cx, objPath, "profileDir", gPaths->profileDir)) { return false; } // Configure localProfileDir only if it is available at this stage if (!gPaths->localProfileDir.IsVoid() && !SetStringProperty(cx, objPath, "localProfileDir", gPaths->localProfileDir)) { return false; } if (!SetStringProperty(cx, objPath, "homeDir", gPaths->homeDir)) { return false; } if (!SetStringProperty(cx, objPath, "desktopDir", gPaths->desktopDir)) { return false; } if (!SetStringProperty(cx, objPath, "userApplicationDataDir", gPaths->userApplicationDataDir)) { return false; } #if defined(XP_WIN) if (!SetStringProperty(cx, objPath, "winAppDataDir", gPaths->winAppDataDir)) { return false; } if (!SetStringProperty(cx, objPath, "winStartMenuProgsDir", gPaths->winStartMenuProgsDir)) { return false; } #endif // defined(XP_WIN) #if defined(XP_MACOSX) if (!SetStringProperty(cx, objPath, "macUserLibDir", gPaths->macUserLibDir)) { return false; } if (!SetStringProperty(cx, objPath, "macLocalApplicationsDir", gPaths->macLocalApplicationsDir)) { return false; } #endif // defined(XP_MACOSX) // sqlite3 is linked from different places depending on the platform nsAutoString libsqlite3; #if defined(ANDROID) // On Android, we use the system's libsqlite3 libsqlite3.Append(NS_LITERAL_STRING(DLL_PREFIX)); libsqlite3.Append(NS_LITERAL_STRING("sqlite3")); libsqlite3.Append(NS_LITERAL_STRING(DLL_SUFFIX)); #elif defined(XP_WIN) // On Windows, for some reason, this is part of nss3.dll libsqlite3.Append(NS_LITERAL_STRING(DLL_PREFIX)); libsqlite3.Append(NS_LITERAL_STRING("nss3")); libsqlite3.Append(NS_LITERAL_STRING(DLL_SUFFIX)); #else // On other platforms, we link sqlite3 into libxul libsqlite3 = libxul; #endif // defined(ANDROID) || defined(XP_WIN) if (!SetStringProperty(cx, objPath, "libsqlite3", libsqlite3)) { return false; } return true; }
/* * This is a wrapper around JS_ReportError(), useful when an error condition * is the result of a JVM failure or exception condition. It appends the * message associated with the pending Java exception to the passed in * printf-style format string and arguments. */ static void vreport_java_error(JSContext *cx, JNIEnv *jEnv, const char *format, va_list ap) { jobject java_obj; jclass java_class; JavaClassDescriptor *class_descriptor; jthrowable java_exception; JSType wrapped_exception_type; jsval js_exception; java_obj = NULL; class_descriptor = NULL; /* Get the exception out of the java environment. */ java_exception = (*jEnv)->ExceptionOccurred(jEnv); if (!java_exception) { JSString *err_jsstr; char *err = JS_vsmprintf(format, ap); if (!err) return; err_jsstr = JS_NewString(cx, err, strlen(err)); if (!err_jsstr) return; JS_SetPendingException(cx, STRING_TO_JSVAL(err_jsstr)); return; } (*jEnv)->ExceptionClear(jEnv); /* Check for JSException */ if (njJSException && (*jEnv)->IsInstanceOf(jEnv, java_exception, njJSException)) { wrapped_exception_type = (*jEnv)->GetIntField(jEnv, java_exception, njJSException_wrappedExceptionType); /* (int) to suppress warning */ if ((int)wrapped_exception_type != JSTYPE_EMPTY) { java_obj = (*jEnv)->GetObjectField(jEnv, java_exception, njJSException_wrappedException); if ((java_obj == NULL) && (wrapped_exception_type == JSTYPE_OBJECT)) { js_exception = JSVAL_NULL; } else { java_class = (*jEnv)->GetObjectClass(jEnv, java_obj); class_descriptor = jsj_GetJavaClassDescriptor(cx, jEnv, java_class); /* OK to delete ref, since above call adds global ref */ (*jEnv)->DeleteLocalRef(jEnv, java_class); /* Convert native JS values back to native types. */ switch(wrapped_exception_type) { case JSTYPE_NUMBER: if (!jsj_ConvertJavaObjectToJSNumber(cx, jEnv, class_descriptor, java_obj, &js_exception)) goto error; break; case JSTYPE_BOOLEAN: if (!jsj_ConvertJavaObjectToJSBoolean(cx, jEnv, class_descriptor, java_obj, &js_exception)) goto error; break; case JSTYPE_STRING: if (!jsj_ConvertJavaObjectToJSString(cx, jEnv, class_descriptor, java_obj, &js_exception)) goto error; break; case JSTYPE_VOID: js_exception = JSVAL_VOID; break; case JSTYPE_OBJECT: case JSTYPE_FUNCTION: default: if ((*jEnv)->IsInstanceOf(jEnv, java_obj, njJSObject)) { js_exception = OBJECT_TO_JSVAL(jsj_UnwrapJSObjectWrapper(jEnv, java_obj)); if (!js_exception) goto error; } else { if (!jsj_ConvertJavaObjectToJSValue(cx, jEnv, java_obj, &js_exception)) goto error; } } } } /* Check for internal exception */ } else { if (!JSJ_ConvertJavaObjectToJSValue(cx, java_exception, &js_exception)) { goto error; } } /* Set pending JS exception and clear the java exception. */ JS_SetPendingException(cx, js_exception); goto done; error: JS_ASSERT(0); jsj_LogError("Out of memory while attempting to throw JSException\n"); done: if (class_descriptor) jsj_ReleaseJavaClassDescriptor(cx, jEnv, class_descriptor); if (java_obj) (*jEnv)->DeleteLocalRef(jEnv, java_obj); if (java_exception) (*jEnv)->DeleteLocalRef(jEnv, java_exception); }
JSBool js_destroy(JSContext *context) { JS_SetPendingException(context, STRING_TO_JSVAL(JS_NewStringCopyZ(context, "timeout"))); return JS_FALSE; }
static JSBool js_console_get(JSContext *cx, JSObject *obj, jsval id, jsval *vp) { ulong val; jsint tiny; JSString* js_str; sbbs_t* sbbs; if((sbbs=(sbbs_t*)JS_GetContextPrivate(cx))==NULL) return(JS_FALSE); tiny = JSVAL_TO_INT(id); switch(tiny) { case CON_PROP_STATUS: val=sbbs->console; break; case CON_PROP_LNCNTR: val=sbbs->lncntr; break; case CON_PROP_ATTR: val=sbbs->curatr; break; case CON_PROP_TOS: val=sbbs->tos; break; case CON_PROP_ROWS: val=sbbs->rows; break; case CON_PROP_COLUMNS: val=sbbs->cols; break; case CON_PROP_AUTOTERM: val=sbbs->autoterm; break; case CON_PROP_TERMINAL: if((js_str=JS_NewStringCopyZ(cx, sbbs->terminal))==NULL) return(JS_FALSE); *vp = STRING_TO_JSVAL(js_str); return(JS_TRUE); case CON_PROP_TIMEOUT: val=sbbs->timeout; break; case CON_PROP_TIMELEFT_WARN: val=sbbs->timeleft_warn; break; case CON_PROP_ABORTED: *vp=BOOLEAN_TO_JSVAL(INT_TO_BOOL(sbbs->sys_status&SS_ABORT)); return(JS_TRUE); case CON_PROP_ABORTABLE: *vp=BOOLEAN_TO_JSVAL(INT_TO_BOOL(sbbs->rio_abortable)); return(JS_TRUE); case CON_PROP_TELNET_MODE: val=sbbs->telnet_mode; break; case CON_PROP_GETSTR_OFFSET: val=sbbs->getstr_offset; break; case CON_PROP_WORDWRAP: if((js_str=JS_NewStringCopyZ(cx, sbbs->wordwrap))==NULL) return(JS_FALSE); *vp = STRING_TO_JSVAL(js_str); return(JS_TRUE); case CON_PROP_QUESTION: if((js_str=JS_NewStringCopyZ(cx, sbbs->question))==NULL) return(JS_FALSE); *vp = STRING_TO_JSVAL(js_str); return(JS_TRUE); case CON_PROP_CTRLKEY_PASSTHRU: val=sbbs->cfg.ctrlkey_passthru; break; case CON_PROP_INBUF_LEVEL: val=RingBufFull(&sbbs->inbuf); break; case CON_PROP_INBUF_SPACE: val=RingBufFree(&sbbs->inbuf); break; case CON_PROP_OUTBUF_LEVEL: val=RingBufFull(&sbbs->outbuf); break; case CON_PROP_OUTBUF_SPACE: val=RingBufFree(&sbbs->outbuf); break; default: return(JS_TRUE); } *vp = INT_TO_JSVAL(val); return(JS_TRUE); }
JSAtom * js_AtomizeString(JSContext *cx, JSString *str, uintN flags) { JSHashNumber keyHash; jsval key; JSAtomState *state; JSHashTable *table; JSHashEntry *he, **hep; JSAtom *atom; keyHash = js_HashString(str); key = STRING_TO_JSVAL(str); state = &cx->runtime->atomState; JS_LOCK(&state->lock, cx); table = state->table; hep = JS_HashTableRawLookup(table, keyHash, (void *)key); if ((he = *hep) == NULL) { #ifdef JS_THREADSAFE uint32 gen = state->tablegen; JS_UNLOCK(&state->lock, cx); #endif if (flags & ATOM_TMPSTR) { str = (flags & ATOM_NOCOPY) ? js_NewString(cx, str->chars, str->length, 0) : js_NewStringCopyN(cx, str->chars, str->length, 0); if (!str) return NULL; key = STRING_TO_JSVAL(str); } else { if (!JS_MakeStringImmutable(cx, str)) return NULL; } #ifdef JS_THREADSAFE JS_LOCK(&state->lock, cx); if (state->tablegen != gen) { hep = JS_HashTableRawLookup(table, keyHash, (void *)key); if ((he = *hep) != NULL) { atom = (JSAtom *)he; if (flags & ATOM_NOCOPY) str->chars = NULL; goto out; } } #endif he = JS_HashTableRawAdd(table, hep, keyHash, (void *)key, NULL); if (!he) { JS_ReportOutOfMemory(cx); atom = NULL; goto out; } } atom = (JSAtom *)he; atom->flags |= flags & (ATOM_PINNED | ATOM_INTERNED); out: JS_UNLOCK(&state->lock,cx); return atom; }
JSBool Window_getString (JSContext* cx, JSObject* object, uintN argc, jsval* argv, jsval* rval) { JSObject* options; WINDOW* win = (WINDOW*) JS_GetPrivate(cx, object); JS_BeginRequest(cx); JS_EnterLocalRootScope(cx); jsval parent; JS_GetProperty(cx, JS_GetGlobalObject(cx), "ncurses", &parent); JS_GetProperty(cx, JSVAL_TO_OBJECT(parent), "Screen", &parent); JSObject* Screen = JSVAL_TO_OBJECT(parent); jsval property; JS_GetProperty(cx, Screen, "echo", &property); JSBool windowEchoing = JSVAL_TO_BOOLEAN(property); JS_GetProperty(cx, Screen, "cursor", &property); jsint windowCursor = JSVAL_TO_INT(property); if (argc == 0) { echo(); curs_set(1); *rval = STRING_TO_JSVAL(__Window_readLine(cx, win, JS_FALSE, 0, 0)); if (!windowEchoing) { noecho(); } curs_set(windowCursor); } else { JS_ValueToObject(cx, argv[0], &options); if (!options) { JS_ReportError(cx, "Options isn't a valid object."); JS_LeaveLocalRootScope(cx); JS_EndRequest(cx); return JS_FALSE; } jsval x, y, jsEcho; JS_GetProperty(cx, options, "x", &x); JS_GetProperty(cx, options, "y", &y); JS_GetProperty(cx, options, "echo", &jsEcho); if (!JSVAL_IS_INT(x) || !JSVAL_IS_INT(y)) { __Window_echofy(jsEcho, windowEchoing, windowCursor, JS_TRUE); *rval = STRING_TO_JSVAL(__Window_readLine(cx, win, JS_FALSE, 0, 0)); __Window_echofy(jsEcho, windowEchoing, windowCursor, JS_FALSE); } else { __Window_echofy(jsEcho, windowEchoing, windowCursor, JS_TRUE); *rval = STRING_TO_JSVAL(__Window_readLine(cx, win, JS_TRUE, x, y)); __Window_echofy(jsEcho, windowEchoing, windowCursor, JS_FALSE); } } JS_LeaveLocalRootScope(cx); JS_EndRequest(cx); return JS_TRUE; }
static bool JS_SET_STDSTRING_RVAL(JSContext* cx, jsval* vp, const char* result) { JSString* jsResult = JS_NewStringCopyZ(cx, result); JS_SET_RVAL(cx, vp, STRING_TO_JSVAL(jsResult)); return true; }
static JSBool InitExceptionObject(JSContext *cx, JSObject *obj, JSString *message, JSString *filename, uintN lineno) { JSCheckAccessOp checkAccess; JSErrorReporter older; JSExceptionState *state; jschar *stackbuf; size_t stacklen, stackmax; JSStackFrame *fp; jsval callerid, v; JSBool ok; JSString *argsrc, *stack; uintN i, ulineno; const char *cp; char ulnbuf[11]; if (!JS_DefineProperty(cx, obj, js_message_str, STRING_TO_JSVAL(message), NULL, NULL, JSPROP_ENUMERATE)) { return JS_FALSE; } if (!JS_DefineProperty(cx, obj, js_filename_str, STRING_TO_JSVAL(filename), NULL, NULL, JSPROP_ENUMERATE)) { return JS_FALSE; } if (!JS_DefineProperty(cx, obj, js_lineno_str, INT_TO_JSVAL(lineno), NULL, NULL, JSPROP_ENUMERATE)) { return JS_FALSE; } /* * Set the 'stack' property. * * First, set aside any error reporter for cx and save its exception state * so we can suppress any checkAccess failures. Such failures should stop * the backtrace procedure, not result in a failure of this constructor. */ checkAccess = cx->runtime->checkObjectAccess; if (checkAccess) { older = JS_SetErrorReporter(cx, NULL); state = JS_SaveExceptionState(cx); } #ifdef __GNUC__ /* suppress bogus gcc warnings */ else { older = NULL; state = NULL; } #endif callerid = ATOM_KEY(cx->runtime->atomState.callerAtom); /* * Prepare to allocate a jschar buffer at stackbuf, where stacklen indexes * the next free jschar slot, and with room for at most stackmax non-null * jschars. If stackbuf is non-null, it always contains an extra slot for * the null terminator we'll store at the end, as a backstop. * * All early returns must goto done after this point, till the after-loop * cleanup code has run! */ stackbuf = NULL; stacklen = stackmax = 0; ok = JS_TRUE; #define APPEND_CHAR_TO_STACK(c) \ JS_BEGIN_MACRO \ if (stacklen == stackmax) { \ void *ptr_; \ stackmax = stackmax ? 2 * stackmax : 64; \ ptr_ = JS_realloc(cx, stackbuf, (stackmax+1) * sizeof(jschar)); \ if (!ptr_) { \ ok = JS_FALSE; \ goto done; \ } \ stackbuf = ptr_; \ } \ stackbuf[stacklen++] = (c); \ JS_END_MACRO #define APPEND_STRING_TO_STACK(str) \ JS_BEGIN_MACRO \ JSString *str_ = str; \ size_t length_ = JSSTRING_LENGTH(str_); \ if (stacklen + length_ > stackmax) { \ void *ptr_; \ stackmax = JS_BIT(JS_CeilingLog2(stacklen + length_)); \ ptr_ = JS_realloc(cx, stackbuf, (stackmax+1) * sizeof(jschar)); \ if (!ptr_) { \ ok = JS_FALSE; \ goto done; \ } \ stackbuf = ptr_; \ } \ js_strncpy(stackbuf + stacklen, JSSTRING_CHARS(str_), length_); \ stacklen += length_; \ JS_END_MACRO for (fp = cx->fp; fp; fp = fp->down) { if (checkAccess) { v = (fp->fun && fp->argv) ? fp->argv[-2] : JSVAL_NULL; if (!JSVAL_IS_PRIMITIVE(v)) { ok = checkAccess(cx, fp->fun->object, callerid, JSACC_READ, &v); if (!ok) { ok = JS_TRUE; break; } } } if (fp->fun) { if (fp->fun->atom) APPEND_STRING_TO_STACK(ATOM_TO_STRING(fp->fun->atom)); APPEND_CHAR_TO_STACK('('); for (i = 0; i < fp->argc; i++) { argsrc = js_ValueToSource(cx, fp->argv[i]); if (!argsrc) { ok = JS_FALSE; goto done; } if (i > 0) APPEND_CHAR_TO_STACK(','); APPEND_STRING_TO_STACK(argsrc); } APPEND_CHAR_TO_STACK(')'); } APPEND_CHAR_TO_STACK('@'); if (fp->script && fp->script->filename) { for (cp = fp->script->filename; *cp; cp++) APPEND_CHAR_TO_STACK(*cp); } APPEND_CHAR_TO_STACK(':'); if (fp->script && fp->pc) { ulineno = js_PCToLineNumber(fp->script, fp->pc); JS_snprintf(ulnbuf, sizeof ulnbuf, "%u", ulineno); for (cp = ulnbuf; *cp; cp++) APPEND_CHAR_TO_STACK(*cp); } else { APPEND_CHAR_TO_STACK('0'); } APPEND_CHAR_TO_STACK('\n'); } #undef APPEND_CHAR_TO_STACK #undef APPEND_STRING_TO_STACK done: if (checkAccess) { if (ok) JS_RestoreExceptionState(cx, state); else JS_DropExceptionState(cx, state); JS_SetErrorReporter(cx, older); } if (!ok) { JS_free(cx, stackbuf); return JS_FALSE; } if (!stackbuf) { stack = cx->runtime->emptyString; } else { /* NB: if stackbuf was allocated, it has room for the terminator. */ JS_ASSERT(stacklen <= stackmax); if (stacklen < stackmax) { /* * Realloc can fail when shrinking on some FreeBSD versions, so * don't use JS_realloc here; simply let the oversized allocation * be owned by the string in that rare case. */ void *shrunk = realloc(stackbuf, (stacklen+1) * sizeof(jschar)); if (shrunk) stackbuf = shrunk; } stackbuf[stacklen] = 0; stack = js_NewString(cx, stackbuf, stacklen, 0); if (!stack) { JS_free(cx, stackbuf); return JS_FALSE; } } return JS_DefineProperty(cx, obj, js_stack_str, STRING_TO_JSVAL(stack), NULL, NULL, JSPROP_ENUMERATE); }
int js_plugin_load(const char *id, const char *url, char *errbuf, size_t errlen) { char *sbuf; struct fa_stat fs; JSContext *cx; js_plugin_t *jsp; JSObject *pobj, *gobj, *confobj; JSScript *s; char path[PATH_MAX]; jsval val; if((sbuf = fa_quickload(url, &fs, NULL, errbuf, errlen)) == NULL) return -1; cx = js_newctx(); JS_BeginRequest(cx); /* Remove any plugin with same URL */ LIST_FOREACH(jsp, &js_plugins, jsp_link) if(!strcmp(jsp->jsp_id, id)) break; if(jsp != NULL) js_plugin_unload(cx, jsp); jsp = calloc(1, sizeof(js_plugin_t)); jsp->jsp_url = strdup(url); jsp->jsp_id = strdup(id); LIST_INSERT_HEAD(&js_plugins, jsp, jsp_link); gobj = JS_NewObject(cx, &global_class, NULL, NULL); JS_InitStandardClasses(cx, gobj); JS_DefineProperty(cx, gobj, "showtime", OBJECT_TO_JSVAL(showtimeobj), NULL, NULL, JSPROP_READONLY | JSPROP_PERMANENT); /* Plugin object */ pobj = JS_NewObject(cx, &plugin_class, NULL, gobj); JS_AddNamedRoot(cx, &pobj, "plugin"); JS_SetPrivate(cx, pobj, jsp); JS_DefineFunctions(cx, pobj, plugin_functions); /* Plugin config object */ confobj = JS_DefineObject(cx, pobj, "config", &plugin_conf_class, NULL, 0); JS_SetPrivate(cx, confobj, jsp); val = STRING_TO_JSVAL(JS_NewStringCopyZ(cx, url)); JS_SetProperty(cx, confobj, "url", &val); if(!fa_parent(path, sizeof(path), url)) { val = STRING_TO_JSVAL(JS_NewStringCopyZ(cx, path)); JS_SetProperty(cx, confobj, "path", &val); } JS_DefineProperty(cx, confobj, "URIRouting", BOOLEAN_TO_JSVAL(1), NULL, jsp_setEnableURIRoute, JSPROP_PERMANENT); JS_DefineProperty(cx, confobj, "search", BOOLEAN_TO_JSVAL(1), NULL, jsp_setEnableSearch, JSPROP_PERMANENT); s = JS_CompileScript(cx, pobj, sbuf, fs.fs_size, url, 1); free(sbuf); if(s != NULL) { JSObject *sobj = JS_NewScriptObject(cx, s); jsval result; JS_AddNamedRoot(cx, &sobj, "script"); JS_ExecuteScript(cx, pobj, s, &result); JS_RemoveRoot(cx, &sobj); } JS_RemoveRoot(cx, &pobj); JS_EndRequest(cx); JS_GC(cx); JS_DestroyContext(cx); return 0; }
JSObject * js_InitExceptionClasses(JSContext *cx, JSObject *obj) { int i; JSObject *protos[JSEXN_LIMIT]; /* Initialize the prototypes first. */ for (i = 0; exceptions[i].name != 0; i++) { JSAtom *atom; JSFunction *fun; JSString *nameString; int protoIndex = exceptions[i].protoIndex; /* Make the prototype for the current constructor name. */ protos[i] = js_NewObject(cx, &ExceptionClass, (protoIndex != JSEXN_NONE) ? protos[protoIndex] : NULL, obj); if (!protos[i]) return NULL; /* So exn_finalize knows whether to destroy private data. */ OBJ_SET_SLOT(cx, protos[i], JSSLOT_PRIVATE, JSVAL_VOID); atom = js_Atomize(cx, exceptions[i].name, strlen(exceptions[i].name), 0); if (!atom) return NULL; /* Make a constructor function for the current name. */ fun = js_DefineFunction(cx, obj, atom, exceptions[i].native, 3, 0); if (!fun) return NULL; /* Make this constructor make objects of class Exception. */ fun->clasp = &ExceptionClass; /* Make the prototype and constructor links. */ if (!js_SetClassPrototype(cx, fun->object, protos[i], JSPROP_READONLY | JSPROP_PERMANENT)) { return NULL; } /* proto bootstrap bit from JS_InitClass omitted. */ nameString = JS_NewStringCopyZ(cx, exceptions[i].name); if (!nameString) return NULL; /* Add the name property to the prototype. */ if (!JS_DefineProperty(cx, protos[i], js_name_str, STRING_TO_JSVAL(nameString), NULL, NULL, JSPROP_ENUMERATE)) { return NULL; } } /* * Add an empty message property. (To Exception.prototype only, * because this property will be the same for all the exception * protos.) */ if (!JS_DefineProperty(cx, protos[0], js_message_str, STRING_TO_JSVAL(cx->runtime->emptyString), NULL, NULL, JSPROP_ENUMERATE)) { return NULL; } if (!JS_DefineProperty(cx, protos[0], js_filename_str, STRING_TO_JSVAL(cx->runtime->emptyString), NULL, NULL, JSPROP_ENUMERATE)) { return NULL; } if (!JS_DefineProperty(cx, protos[0], js_lineno_str, INT_TO_JSVAL(0), NULL, NULL, JSPROP_ENUMERATE)) { return NULL; } /* * Add methods only to Exception.prototype, because ostensibly all * exception types delegate to that. */ if (!JS_DefineFunctions(cx, protos[0], exception_methods)) return NULL; return protos[0]; }
static JSBool DumpHeap(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) { char *fileName = NULL; void* startThing = NULL; uint32 startTraceKind = 0; void *thingToFind = NULL; size_t maxDepth = (size_t)-1; void *thingToIgnore = NULL; jsval *vp; FILE *dumpFile; JSBool ok; vp = &argv[0]; if (*vp != JSVAL_NULL && *vp != JSVAL_VOID) { JSString *str; str = JS_ValueToString(cx, *vp); if (!str) return JS_FALSE; *vp = STRING_TO_JSVAL(str); fileName = JS_GetStringBytes(str); } vp = &argv[1]; if (*vp != JSVAL_NULL && *vp != JSVAL_VOID) { if (!JSVAL_IS_TRACEABLE(*vp)) goto not_traceable_arg; startThing = JSVAL_TO_TRACEABLE(*vp); startTraceKind = JSVAL_TRACE_KIND(*vp); } vp = &argv[2]; if (*vp != JSVAL_NULL && *vp != JSVAL_VOID) { if (!JSVAL_IS_TRACEABLE(*vp)) goto not_traceable_arg; thingToFind = JSVAL_TO_TRACEABLE(*vp); } vp = &argv[3]; if (*vp != JSVAL_NULL && *vp != JSVAL_VOID) { uint32 depth; if (!JS_ValueToECMAUint32(cx, *vp, &depth)) return JS_FALSE; maxDepth = depth; } vp = &argv[4]; if (*vp != JSVAL_NULL && *vp != JSVAL_VOID) { if (!JSVAL_IS_TRACEABLE(*vp)) goto not_traceable_arg; thingToIgnore = JSVAL_TO_TRACEABLE(*vp); } if (!fileName) { dumpFile = gOutFile; } else { dumpFile = fopen(fileName, "w"); if (!dumpFile) { fprintf(gErrFile, "dumpHeap: can't open %s: %s\n", fileName, strerror(errno)); return JS_FALSE; } } ok = JS_DumpHeap(cx, dumpFile, startThing, startTraceKind, thingToFind, maxDepth, thingToIgnore); if (dumpFile != gOutFile) fclose(dumpFile); return ok; not_traceable_arg: fprintf(gErrFile, "dumpHeap: argument %u is not null or a heap-allocated thing\n", (unsigned)(vp - argv)); return JS_FALSE; }
long sbbs_t::js_execfile(const char *cmd, const char* startup_dir, JSObject* scope) { char* p; char* args=NULL; char* fname; int argc=0; char cmdline[MAX_PATH+1]; char path[MAX_PATH+1]; JSObject* js_scope=scope; JSObject* js_script=NULL; jsval rval; int32 result=0; if(js_cx==NULL) { errormsg(WHERE,ERR_CHK,"JavaScript support",0); errormsg(WHERE,ERR_EXEC,cmd,0); return -1; } SAFECOPY(cmdline,cmd); p=strchr(cmdline,' '); if(p!=NULL) { *p=0; args=p+1; } fname=cmdline; path[0]=0; if(strcspn(fname,"/\\")==strlen(fname)) { if(startup_dir!=NULL && *startup_dir) SAFEPRINTF3(path,"%s%s%s",startup_dir,fname,js_ext(fname)); if(path[0]==0 || !fexistcase(path)) { SAFEPRINTF3(path,"%s%s%s",cfg.mods_dir,fname,js_ext(fname)); if(cfg.mods_dir[0]==0 || !fexistcase(path)) SAFEPRINTF3(path,"%s%s%s",cfg.exec_dir,fname,js_ext(fname)); } } else SAFECOPY(path,fname); if(!fexistcase(path)) { errormsg(WHERE,ERR_OPEN,path,O_RDONLY); return -1; } JS_BEGINREQUEST(js_cx); if(js_scope==NULL) js_scope=JS_NewObject(js_cx, NULL, NULL, js_glob); if(js_scope!=NULL) { JSObject* argv=JS_NewArrayObject(js_cx, 0, NULL); JS_DefineProperty(js_cx, js_scope, "argv", OBJECT_TO_JSVAL(argv) ,NULL,NULL,JSPROP_READONLY|JSPROP_ENUMERATE); /* TODO: Handle quoted "one arg" syntax here? */ if(args!=NULL && argv!=NULL) { while(*args) { p=strchr(args,' '); if(p!=NULL) *p=0; while(*args && *args==' ') args++; /* Skip spaces */ JSString* arg = JS_NewStringCopyZ(js_cx, args); if(arg==NULL) break; jsval val=STRING_TO_JSVAL(arg); if(!JS_SetElement(js_cx, argv, argc, &val)) break; argc++; if(p==NULL) /* last arg */ break; args+=(strlen(args)+1); } } JS_DefineProperty(js_cx, js_scope, "argc", INT_TO_JSVAL(argc) ,NULL,NULL,JSPROP_READONLY|JSPROP_ENUMERATE); JS_ClearPendingException(js_cx); js_script=JS_CompileFile(js_cx, js_scope, path); } if(js_scope==NULL || js_script==NULL) { JS_ReportPendingException(js_cx); /* Added Feb-2-2006, rswindell */ JS_ENDREQUEST(js_cx); errormsg(WHERE,"compiling",path,0); return -1; } if(scope==NULL) { js_callback.counter=0; // Reset loop counter #if JS_VERSION>180 JS_SetOperationCallback(js_cx, js_OperationCallback); #else JS_SetBranchCallback(js_cx, js_BranchCallback); #endif js_PrepareToExecute(js_cx, js_glob, path, startup_dir); } JS_ExecuteScript(js_cx, js_scope, js_script, &rval); if(scope==NULL) { JS_GetProperty(js_cx, js_scope, "exit_code", &rval); if(rval!=JSVAL_VOID) JS_ValueToInt32(js_cx,rval,&result); js_EvalOnExit(js_cx, js_scope, &js_callback); } JS_ReportPendingException(js_cx); /* Added Dec-4-2005, rswindell */ JS_DestroyScript(js_cx, js_script); if(scope==NULL) JS_ClearScope(js_cx, js_scope); JS_GC(js_cx); JS_ENDREQUEST(js_cx); return(result); }
static int ProcessArgs(JSContext *cx, JSObject *obj, char **argv, int argc) { const char rcfilename[] = "xpcshell.js"; FILE *rcfile; int i, j, length; JSObject *argsObj; char *filename = NULL; JSBool isInteractive = JS_TRUE; JSBool forceTTY = JS_FALSE; rcfile = fopen(rcfilename, "r"); if (rcfile) { printf("[loading '%s'...]\n", rcfilename); ProcessFile(cx, obj, rcfilename, rcfile, JS_FALSE); } /* * Scan past all optional arguments so we can create the arguments object * before processing any -f options, which must interleave properly with * -v and -w options. This requires two passes, and without getopt, we'll * have to keep the option logic here and in the second for loop in sync. */ for (i = 0; i < argc; i++) { if (argv[i][0] != '-' || argv[i][1] == '\0') { ++i; break; } switch (argv[i][1]) { case 'v': case 'f': case 'e': ++i; break; default:; } } /* * Create arguments early and define it to root it, so it's safe from any * GC calls nested below, and so it is available to -f <file> arguments. */ argsObj = JS_NewArrayObject(cx, 0, NULL); if (!argsObj) return 1; if (!JS_DefineProperty(cx, obj, "arguments", OBJECT_TO_JSVAL(argsObj), NULL, NULL, 0)) { return 1; } length = argc - i; for (j = 0; j < length; j++) { JSString *str = JS_NewStringCopyZ(cx, argv[i++]); if (!str) return 1; if (!JS_DefineElement(cx, argsObj, j, STRING_TO_JSVAL(str), NULL, NULL, JSPROP_ENUMERATE)) { return 1; } } for (i = 0; i < argc; i++) { if (argv[i][0] != '-' || argv[i][1] == '\0') { filename = argv[i++]; isInteractive = JS_FALSE; break; } switch (argv[i][1]) { case 'v': if (++i == argc) { return usage(); } JS_SetVersion(cx, JSVersion(atoi(argv[i]))); break; case 'W': reportWarnings = JS_FALSE; break; case 'w': reportWarnings = JS_TRUE; break; case 's': JS_ToggleOptions(cx, JSOPTION_STRICT); break; case 'x': JS_ToggleOptions(cx, JSOPTION_XML); break; case 'P': if (JS_GET_CLASS(cx, JS_GetPrototype(cx, obj)) != &global_class) { JSObject *gobj; if (!JS_SealObject(cx, obj, JS_TRUE)) return JS_FALSE; gobj = JS_NewObject(cx, &global_class, NULL, NULL); if (!gobj) return JS_FALSE; if (!JS_SetPrototype(cx, gobj, obj)) return JS_FALSE; JS_SetParent(cx, gobj, NULL); JS_SetGlobalObject(cx, gobj); obj = gobj; } break; case 'f': if (++i == argc) { return usage(); } Process(cx, obj, argv[i], JS_FALSE); /* * XXX: js -f foo.js should interpret foo.js and then * drop into interactive mode, but that breaks test * harness. Just execute foo.js for now. */ isInteractive = JS_FALSE; break; case 'i': isInteractive = forceTTY = JS_TRUE; break; case 'e': { jsval rval; if (++i == argc) { return usage(); } JS_EvaluateScript(cx, obj, argv[i], strlen(argv[i]), "-e", 1, &rval); isInteractive = JS_FALSE; break; } case 'C': compileOnly = JS_TRUE; isInteractive = JS_FALSE; break; #ifdef MOZ_SHARK case 'k': JS_ConnectShark(); break; #endif default: return usage(); } } if (filename || isInteractive) Process(cx, obj, filename, forceTTY); return gExitCode; }
/* [implicit_jscontext] jsval getListOfCameras (); */ NS_IMETHODIMP nsDOMCameraManager::GetListOfCameras(JSContext* cx, JS::Value* _retval) { JSObject* a = JS_NewArrayObject(cx, 0, nullptr); camera_module_t* module; uint32_t index = 0; uint32_t count; if (!a) { DOM_CAMERA_LOGE("getListOfCameras : Could not create array object"); return NS_ERROR_OUT_OF_MEMORY; } if (hw_get_module(CAMERA_HARDWARE_MODULE_ID, (const hw_module_t**)&module) < 0) { DOM_CAMERA_LOGE("getListOfCameras : Could not load camera HAL module"); return NS_ERROR_NOT_AVAILABLE; } count = module->get_number_of_cameras(); DOM_CAMERA_LOGI("getListOfCameras : get_number_of_cameras() returned %d\n", count); while (count--) { struct camera_info info; int rv = module->get_camera_info(count, &info); if (rv != 0) { DOM_CAMERA_LOGE("getListOfCameras : get_camera_info(%d) failed: %d\n", count, rv); continue; } JSString* v; jsval jv; switch (info.facing) { case CAMERA_FACING_BACK: v = JS_NewStringCopyZ(cx, "back"); index = 0; break; case CAMERA_FACING_FRONT: v = JS_NewStringCopyZ(cx, "front"); index = 1; break; default: // TODO: see bug 779143. { static uint32_t extraIndex = 2; nsCString s; s.AppendPrintf("extra-camera-%d", count); v = JS_NewStringCopyZ(cx, s.get()); index = extraIndex++; } break; } if (!v) { DOM_CAMERA_LOGE("getListOfCameras : out of memory populating camera list"); return NS_ERROR_NOT_AVAILABLE; } jv = STRING_TO_JSVAL(v); if (!JS_SetElement(cx, a, index, &jv)) { DOM_CAMERA_LOGE("getListOfCameras : failed building list of cameras"); return NS_ERROR_NOT_AVAILABLE; } } *_retval = OBJECT_TO_JSVAL(a); return NS_OK; }
JSBool openfiledlg(JSContext * cx, JSObject * obj, uintN argc, jsval * argv, jsval * rval) { JSObject * filterArray = NULL; LPWSTR initialDirectory = NULL; LPWSTR dlgTitle = NULL; LPWSTR defaultExtension = NULL; JSBool save = JS_FALSE; JS_BeginRequest(cx); if(!JS_ConvertArguments(cx, argc, argv, "W W W o/ b", &initialDirectory, &defaultExtension, &dlgTitle, &filterArray, &save)) { JS_ReportError(cx, "Error parsing arguments in OpenFileDialog"); JS_EndRequest(cx); return JS_FALSE; } jsuint nFilters; JS_GetArrayLength(cx, filterArray, &nFilters); LPWSTR filterBuffer = (LPWSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (50 * nFilters) * sizeof(WCHAR)); long filterBufferUsed = 0, filterBufferSize = (50 * nFilters); for(jsuint i = 0; i < nFilters; i++) { jsval curFilter; JS_GetElement(cx, filterArray, i, &curFilter); JSString * curFilterString = JS_ValueToString(cx, curFilter); LPWSTR curFilterRaw = (LPWSTR)JS_GetStringChars(curFilterString); int delta = wcslen(curFilterRaw); if(filterBufferSize - ( 2 + JS_GetStringLength(curFilterString) + filterBufferUsed) <= 0) { filterBufferSize += 50; HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, filterBuffer, filterBufferSize * sizeof(WCHAR)); } wcscpy_s(filterBuffer + filterBufferUsed, filterBufferSize - filterBufferUsed, (LPWSTR)JS_GetStringChars(curFilterString)); filterBufferUsed += JS_GetStringLength(curFilterString) + 1; } filterBuffer[filterBufferUsed] = TEXT('\0'); OPENFILENAME ofn; memset(&ofn, 0, sizeof(OPENFILENAME)); ofn.lStructSize = sizeof(OPENFILENAME); ofn.lpstrFilter = filterBuffer; ofn.nFilterIndex = 0; ofn.lpstrFile = (LPWSTR)JS_malloc(cx, 260 * sizeof(WCHAR)); memset(ofn.lpstrFile, 0, sizeof(WCHAR) * 260); ofn.nMaxFile = 260; ofn.lpstrFileTitle = (LPWSTR)JS_malloc(cx, 260 * sizeof(WCHAR)); memset(ofn.lpstrFileTitle, 0, sizeof(WCHAR) * 260); ofn.nMaxFileTitle = 260; ofn.lpstrInitialDir = initialDirectory; ofn.lpstrTitle = dlgTitle; ofn.lpstrDefExt = defaultExtension; ofn.lpfnHook = OFN_Hook; ofn.Flags = OFN_ENABLEHOOK | OFN_EXPLORER; jsrefcount rCount = JS_SuspendRequest(cx); BOOL ok; if(save) ok = GetSaveFileName(&ofn); else ok = GetOpenFileName(&ofn); DWORD errorCode = CommDlgExtendedError(); HeapFree(GetProcessHeap(), 0, filterBuffer); JS_ResumeRequest(cx, rCount); if(!ok) { JS_free(cx, ofn.lpstrFile); JS_free(cx, ofn.lpstrFileTitle); *rval = JSVAL_FALSE; return JS_TRUE; } JSObject * retObj = JS_NewObject(cx, NULL, NULL, obj); *rval = OBJECT_TO_JSVAL(retObj); jsval filePathVal = STRING_TO_JSVAL(JS_NewUCString(cx, (jschar*)ofn.lpstrFile, wcslen(ofn.lpstrFile))); JS_DefineProperty(cx, retObj, "filePath", filePathVal, NULL, NULL, JSPROP_PERMANENT | JSPROP_ENUMERATE); jsval fileTitleVal = STRING_TO_JSVAL(JS_NewUCString(cx, (jschar*)ofn.lpstrFileTitle, wcslen(ofn.lpstrFileTitle))); JS_DefineProperty(cx, retObj, "fileTitle", fileTitleVal, NULL, NULL, JSPROP_PERMANENT | JSPROP_ENUMERATE); JS_EndRequest(cx); return JS_TRUE; }
static JSBool js_get(JSContext *cx, JSObject *obj, jsid id, jsval *vp) { jsval idval; jsint tiny; jsrefcount rc; JS_IdToValue(cx, id, &idval); tiny = JSVAL_TO_INT(idval); rc=JS_SUSPENDREQUEST(cx); switch(tiny) { case PROP_WSCROLL: *vp=BOOLEAN_TO_JSVAL(_wscroll); break; case PROP_DIRECTVIDEO: *vp=BOOLEAN_TO_JSVAL(directvideo); break; case PROP_HOLD_UPDATE: *vp=BOOLEAN_TO_JSVAL(hold_update); break; case PROP_PUTTEXT_CAN_MOVE: *vp=BOOLEAN_TO_JSVAL(puttext_can_move); break; case PROP_MODE: *vp=INT_TO_JSVAL(cio_api.mode); break; case PROP_MOUSE: *vp=BOOLEAN_TO_JSVAL(cio_api.mouse); break; case PROP_ESCDELAY: *vp=INT_TO_JSVAL(cio_api.ESCDELAY?*cio_api.ESCDELAY:0); break; case PROP_TEXTATTR: *vp=INT_TO_JSVAL(cio_textinfo.attribute); break; case PROP_KBHIT: *vp=BOOLEAN_TO_JSVAL(kbhit()); break; case PROP_WHEREX: *vp=INT_TO_JSVAL(cio_textinfo.curx); break; case PROP_WHEREY: *vp=INT_TO_JSVAL(cio_textinfo.cury); break; case PROP_TEXTMODE: *vp=INT_TO_JSVAL(cio_textinfo.currmode); break; case PROP_WINLEFT: *vp=INT_TO_JSVAL(cio_textinfo.winleft); break; case PROP_WINTOP: *vp=INT_TO_JSVAL(cio_textinfo.wintop); break; case PROP_WINRIGHT: *vp=INT_TO_JSVAL(cio_textinfo.winright); break; case PROP_WINBOTTOM: *vp=INT_TO_JSVAL(cio_textinfo.winbottom); break; case PROP_SCREENWIDTH: *vp=INT_TO_JSVAL(cio_textinfo.screenwidth); break; case PROP_SCREENHEIGHT: *vp=INT_TO_JSVAL(cio_textinfo.screenheight); break; case PROP_NORMATTR: *vp=INT_TO_JSVAL(cio_textinfo.normattr); break; case PROP_TEXTBACKGROUND: *vp=INT_TO_JSVAL((cio_textinfo.attribute & 0x70)>>4); break; case PROP_TEXTCOLOR: *vp=INT_TO_JSVAL(cio_textinfo.attribute & 0xf); break; case PROP_CLIPBOARD: *vp=STRING_TO_JSVAL(JS_NewStringCopyZ(cx,getcliptext())); break; case PROP_HIGHVIDEO: *vp=BOOLEAN_TO_JSVAL(cio_textinfo.attribute & 0x8); break; case PROP_LOWVIDEO: *vp=BOOLEAN_TO_JSVAL(!(cio_textinfo.attribute & 0x8)); break; } JS_RESUMEREQUEST(cx, rc); return(JS_TRUE); }
// convert a readable to a JSString, copying string data // static jsval XPCStringConvert::ReadableToJSVal(JSContext *cx, const nsAString &readable, nsStringBuffer** sharedBuffer) { JSString *str; *sharedBuffer = nsnull; PRUint32 length = readable.Length(); JSAtom *atom; if (length == 0 && (atom = cx->runtime->atomState.emptyAtom)) { return ATOM_TO_JSVAL(atom); } nsStringBuffer *buf = nsStringBuffer::FromString(readable); if (buf) { // yay, we can share the string's buffer! if (sDOMStringFinalizerIndex == -1) { sDOMStringFinalizerIndex = JS_AddExternalStringFinalizer(DOMStringFinalizer); if (sDOMStringFinalizerIndex == -1) return JSVAL_NULL; } str = JS_NewExternalString(cx, reinterpret_cast<jschar *>(buf->Data()), length, sDOMStringFinalizerIndex); if (str) { *sharedBuffer = buf; } } else { // blech, have to copy. jschar *chars = reinterpret_cast<jschar *> (JS_malloc(cx, (length + 1) * sizeof(jschar))); if (!chars) return JSVAL_NULL; if (length && !CopyUnicodeTo(readable, 0, reinterpret_cast<PRUnichar *>(chars), length)) { JS_free(cx, chars); return JSVAL_NULL; } chars[length] = 0; str = JS_NewUCString(cx, chars, length); if (!str) JS_free(cx, chars); } return STRING_TO_JSVAL(str); }
JSBool S_SimpleNativeClass::jsPropertyGet(JSContext *cx, JSObject *obj, jsid _id, jsval *val) { int32_t propId = JSID_TO_INT(_id); S_SimpleNativeClass *cobj; JSGET_PTRSHELL(S_SimpleNativeClass, cobj, obj); if (!cobj) return JS_FALSE; switch(propId) { case kSomeField: do { jsval tmp; JS_NewNumberValue(cx, cobj->getSomeField(), &tmp); JS_SET_RVAL(cx, val, tmp); } while (0); break; case kSomeOtherField: do { jsval tmp; JS_NewNumberValue(cx, cobj->getSomeOtherField(), &tmp); JS_SET_RVAL(cx, val, tmp); } while (0); break; case kAnotherMoreComplexField: do { JSString *tmp = JS_NewStringCopyZ(cx, cobj->getAnotherMoreComplexField()); JS_SET_RVAL(cx, val, STRING_TO_JSVAL(tmp)); } while (0); break; default: break; } return JS_TRUE; }
int main(int argc, const char* argv[]) { JSRuntime* rt = NULL; JSContext* cx = NULL; JSObject* global = NULL; JSObject* klass = NULL; JSScript* script; JSString* scriptsrc; jschar* schars; size_t slen; jsval sroot; jsval result; int i; couch_args* args = couch_parse_args(argc, argv); rt = JS_NewRuntime(args->stack_size); if(rt == NULL) return 1; cx = JS_NewContext(rt, 8L * 1024L); if(cx == NULL) return 1; JS_SetErrorReporter(cx, couch_error); JS_ToggleOptions(cx, JSOPTION_XML); JS_SetContextPrivate(cx, args); SETUP_REQUEST(cx); global = JS_NewObject(cx, &global_class, NULL, NULL); if(global == NULL) return 1; JS_SetGlobalObject(cx, global); if(!JS_InitStandardClasses(cx, global)) return 1; if(couch_load_funcs(cx, global, global_functions) != JS_TRUE) return 1; if(args->use_http) { http_check_enabled(); klass = JS_InitClass( cx, global, NULL, &CouchHTTPClass, req_ctor, 0, CouchHTTPProperties, CouchHTTPFunctions, NULL, NULL ); if(!klass) { fprintf(stderr, "Failed to initialize CouchHTTP class.\n"); exit(2); } } for (i = 0 ; args->scripts[i] ; i++) { // Convert script source to jschars. scriptsrc = couch_readfile(cx, args->scripts[i]); if(!scriptsrc) return 1; schars = JS_GetStringChars(scriptsrc); slen = JS_GetStringLength(scriptsrc); // Root it so GC doesn't collect it. sroot = STRING_TO_JSVAL(scriptsrc); if(JS_AddRoot(cx, &sroot) != JS_TRUE) { fprintf(stderr, "Internal root error.\n"); return 1; } // Compile and run script = JS_CompileUCScript(cx, global, schars, slen, args->scripts[i], 1); if(!script) { fprintf(stderr, "Failed to compile script.\n"); return 1; } JS_ExecuteScript(cx, global, script, &result); // Warning message if we don't remove it. JS_RemoveRoot(cx, &sroot); } FINISH_REQUEST(cx); JS_DestroyContext(cx); JS_DestroyRuntime(rt); JS_ShutDown(); return 0; }