JSString* __Window_readLine (JSContext* cx, WINDOW* win, JSBool moveFirst, jsval x, jsval y) { char* string = (char*) JS_malloc(cx, 16*sizeof(char)); size_t length = 0; JS_BeginRequest(cx); JS_EnterLocalRootScope(cx); string[0] = (moveFirst ? mvwgetch(win, JSVAL_TO_INT(y), JSVAL_TO_INT(x)) : wgetch(win)); while (string[(++length)-1] != '\n') { if ((length+1) % 16) { string = (char*) JS_realloc(cx, string, (length+16+1)*sizeof(char)); } string[length] = (char) wgetch(win); } string[length-1] = '\0'; string = (char*) JS_realloc(cx, string, length*sizeof(char)); JSString* jsString = JS_NewString(cx, string, strlen(string)); JS_LeaveLocalRootScope(cx); JS_EndRequest(cx); return jsString; }
JSString* couch_readline(JSContext* cx, FILE* fp) { JSString* str; char* bytes = NULL; char* tmp = NULL; size_t used = 0; size_t byteslen = 256; size_t readlen = 0; bytes = JS_malloc(cx, byteslen); if(bytes == NULL) return NULL; while((readlen = couch_fgets(bytes+used, byteslen-used, fp)) > 0) { used += readlen; if(bytes[used-1] == '\n') { bytes[used-1] = '\0'; break; } // Double our buffer and read more. byteslen *= 2; tmp = JS_realloc(cx, bytes, byteslen); if(!tmp) { JS_free(cx, bytes); return NULL; } bytes = tmp; } // Treat empty strings specially if(used == 0) { JS_free(cx, bytes); return JSVAL_TO_STRING(JS_GetEmptyStringValue(cx)); } // Shring the buffer to the actual data size tmp = JS_realloc(cx, bytes, used); if(!tmp) { JS_free(cx, bytes); return NULL; } bytes = tmp; byteslen = used; str = dec_string(cx, bytes, byteslen); JS_free(cx, bytes); return str; }
JS_XDRRegisterClass(JSXDRState *xdr, JSClass *clasp, uint32 *idp) { uintN numclasses, maxclasses; JSClass **registry; numclasses = xdr->numclasses; maxclasses = xdr->maxclasses; if (numclasses == maxclasses) { maxclasses = (maxclasses == 0) ? CLASS_REGISTRY_MIN : maxclasses << 1; registry = (JSClass **) JS_realloc(xdr->cx, xdr->registry, maxclasses * sizeof(JSClass *)); if (!registry) return JS_FALSE; xdr->registry = registry; xdr->maxclasses = maxclasses; } else { JS_ASSERT(numclasses && numclasses < maxclasses); registry = xdr->registry; } registry[numclasses] = clasp; if (xdr->reghash) { JSRegHashEntry *entry = (JSRegHashEntry *) JS_DHashTableOperate(xdr->reghash, clasp->name, JS_DHASH_ADD); if (!entry) { JS_ReportOutOfMemory(xdr->cx); return JS_FALSE; } entry->name = clasp->name; entry->index = numclasses; } *idp = CLASS_INDEX_TO_ID(numclasses); xdr->numclasses = ++numclasses; return JS_TRUE; }
static JSBool ejszlib_compress (JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) { EJS_CHECK_NUM_ARGS(cx,obj,1,argc); char* ctype; size_t len; STRING_TO_CHARVEC(argv[0],ctype,len); // todo: perhaps simply return an empty string if (!len) EJS_THROW_ERROR(cx,obj,"nothing to compress"); uLong destLen=compressBound(len); Byte* dest=(Byte *)JS_malloc(cx, destLen); if (!dest) return JS_FALSE; if (compress(dest, &destLen, (Byte*)ctype, len)!=Z_OK) { JS_free(cx,dest); EJS_THROW_ERROR(cx,obj,"compression failed"); } assert(destLen>0); dest=(Byte *)JS_realloc(cx,dest,destLen); RETSTR(dest,destLen,rval); }
static size_t recv_body(void *ptr, size_t size, size_t nmem, void *data) { CurlState* state = (CurlState*) data; size_t length = size * nmem; char* tmp = NULL; if(!state->recvbuf) { state->recvlen = 4096; state->read = 0; state->recvbuf = JS_malloc(state->cx, state->recvlen); } if(!state->recvbuf) { return CURLE_WRITE_ERROR; } // +1 so we can add '\0' back up in the go function. while(length+1 > state->recvlen - state->read) state->recvlen *= 2; tmp = JS_realloc(state->cx, state->recvbuf, state->recvlen); if(!tmp) return CURLE_WRITE_ERROR; state->recvbuf = tmp; memcpy(state->recvbuf + state->read, ptr, length); state->read += length; return length; }
void js_FreeSlot(JSContext *cx, JSObject *obj, uint32 slot) { JSObjectMap *map; uint32 nslots; size_t nbytes; jsval *newslots; PR_ASSERT(JS_IS_LOCKED(cx)); map = obj->map; PR_ASSERT(((JSScope *)map)->object == obj); if (map->freeslot == slot + 1) map->freeslot = slot; nslots = map->nslots; if (nslots > JS_INITIAL_NSLOTS && map->freeslot < nslots / 2) { nslots = map->freeslot; nslots += nslots / 2; nbytes = (size_t)nslots * sizeof(jsval); newslots = JS_realloc(cx, obj->slots, nbytes); if (!newslots) return; obj->slots = newslots; map->nslots = nslots; } }
JSBool Core_exec (JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) { FILE* pipe; char* output = NULL; size_t length = 0; size_t read = 0; const char* command; JS_BeginRequest(cx); JS_EnterLocalRootScope(cx); if (argc != 1 || !JS_ConvertArguments(cx, argc, argv, "s", &command)) { JS_ReportError(cx, "Not enough parameters."); return JS_FALSE; } jsrefcount req = JS_SuspendRequest(cx); if ((pipe = popen(command, "r")) == NULL) { JS_ReportError(cx, "Command not found"); return JS_FALSE; } // Read untill the pipe is empty. while (1) { output = (char*) JS_realloc(cx, output, length+=512); read = fread(output+(length-512), sizeof(char), 512, pipe); if (read < 512) { output = (char*) JS_realloc(cx, output, length-=(512-read)); break; } } output[length-1] = '\0'; pclose(pipe); JS_ResumeRequest(cx, req); *rval = STRING_TO_JSVAL(JS_NewString(cx, output, length)); JS_LeaveLocalRootScope(cx); JS_EndRequest(cx); return JS_TRUE; }
static JSBool ejszlib_uncompress (JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) { EJS_CHECK_NUM_ARGS(cx,obj,2,argc); char* ctype; size_t len; STRING_TO_CHARVEC(argv[0],ctype,len); // todo: perhaps simply return an empty string if (!len) EJS_THROW_ERROR(cx,obj,"nothing to uncompress"); int32 d; if (!JS_ValueToInt32(cx,argv[1],&d)) return JS_FALSE; if (d<0) EJS_THROW_ERROR(cx,obj,"Argument 1 must be a postive number"); uLong destLen=d; Byte* dest=(Byte *)JS_malloc(cx, destLen); if (!dest) return JS_FALSE; int r; if ((r=uncompress(dest, &destLen, (Byte*)ctype, len))!=Z_OK) { JS_free(cx,dest); std::string error="uncompression failed: "; switch(r) { case Z_DATA_ERROR: error+="DATA_ERROR"; break; case Z_BUF_ERROR: error+="wrong size"; break; case Z_MEM_ERROR: error+="out of memory"; break; default: error+="unknown error"; }; EJS_THROW_ERROR(cx,obj,error.c_str()); } assert(destLen>0); dest=(Byte *)JS_realloc(cx,dest,destLen); RETSTR(dest,destLen,rval); }
JSBool js_AllocSlot(JSContext *cx, JSObject *obj, uint32 *slotp) { JSObjectMap *map; uint32 nslots; size_t nbytes; jsval *newslots; PR_ASSERT(JS_IS_LOCKED(cx)); map = obj->map; PR_ASSERT(((JSScope *)map)->object == obj); nslots = map->nslots; if (map->freeslot >= nslots) { nslots = PR_MAX(map->freeslot, nslots); if (nslots < JS_INITIAL_NSLOTS) nslots = JS_INITIAL_NSLOTS; else nslots += (nslots + 1) / 2; nbytes = (size_t)nslots * sizeof(jsval); #if defined(XP_PC) && defined _MSC_VER && _MSC_VER <= 800 if (nbytes > 60000U) { JS_ReportOutOfMemory(cx); return JS_FALSE; } #endif if (obj->slots) newslots = JS_realloc(cx, obj->slots, nbytes); else newslots = JS_malloc(cx, nbytes); if (!newslots) return JS_FALSE; obj->slots = newslots; map->nslots = nslots; } #ifdef TOO_MUCH_GC obj->slots[map->freeslot] = JSVAL_VOID; #endif *slotp = map->freeslot++; return JS_TRUE; }
JSBool ToUnicode(JSContext* cx, const char* src, jsval* rval) { nsresult rv; if (!mDecoder) { // use app default locale nsCOMPtr<nsILocaleService> localeService = do_GetService(NS_LOCALESERVICE_CONTRACTID, &rv); if (NS_SUCCEEDED(rv)) { nsCOMPtr<nsILocale> appLocale; rv = localeService->GetApplicationLocale(getter_AddRefs(appLocale)); if (NS_SUCCEEDED(rv)) { nsAutoString localeStr; rv = appLocale-> GetCategory(NS_LITERAL_STRING(NSILOCALE_TIME), localeStr); NS_ASSERTION(NS_SUCCEEDED(rv), "failed to get app locale info"); nsCOMPtr<nsIPlatformCharset> platformCharset = do_GetService(NS_PLATFORMCHARSET_CONTRACTID, &rv); if (NS_SUCCEEDED(rv)) { nsCAutoString charset; rv = platformCharset->GetDefaultCharsetForLocale(localeStr, charset); if (NS_SUCCEEDED(rv)) { // get/create unicode decoder for charset nsCOMPtr<nsICharsetConverterManager> ccm = do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv); if (NS_SUCCEEDED(rv)) ccm->GetUnicodeDecoder(charset.get(), getter_AddRefs(mDecoder)); } } } } } JSString *str = nsnull; PRInt32 srcLength = PL_strlen(src); if (mDecoder) { PRInt32 unicharLength = srcLength; PRUnichar *unichars = (PRUnichar *)JS_malloc(cx, (srcLength + 1) * sizeof(PRUnichar)); if (unichars) { rv = mDecoder->Convert(src, &srcLength, unichars, &unicharLength); if (NS_SUCCEEDED(rv)) { // terminate the returned string unichars[unicharLength] = 0; // nsIUnicodeDecoder::Convert may use fewer than srcLength PRUnichars if (unicharLength + 1 < srcLength + 1) { PRUnichar *shrunkUnichars = (PRUnichar *)JS_realloc(cx, unichars, (unicharLength + 1) * sizeof(PRUnichar)); if (shrunkUnichars) unichars = shrunkUnichars; } str = JS_NewUCString(cx, reinterpret_cast<jschar*>(unichars), unicharLength); } if (!str) JS_free(cx, unichars); } } if (!str) { nsDOMClassInfo::ThrowJSException(cx, NS_ERROR_OUT_OF_MEMORY); return JS_FALSE; } *rval = STRING_TO_JSVAL(str); return JS_TRUE; }
static JSString * StackTraceToString(JSContext *cx, JSExnPrivate *priv) { jschar *stackbuf; size_t stacklen, stackmax; JSStackTraceElem *elem, *endElem; jsval *values; size_t i; JSString *str; const char *cp; char ulnbuf[11]; /* After this point, failing control flow must goto bad. */ stackbuf = NULL; stacklen = stackmax = 0; /* Limit the stackbuf length to a reasonable value to avoid overflow checks. */ #define STACK_LENGTH_LIMIT JS_BIT(20) #define APPEND_CHAR_TO_STACK(c) \ JS_BEGIN_MACRO \ if (stacklen == stackmax) { \ void *ptr_; \ if (stackmax >= STACK_LENGTH_LIMIT) \ goto done; \ stackmax = stackmax ? 2 * stackmax : 64; \ ptr_ = JS_realloc(cx, stackbuf, (stackmax+1) * sizeof(jschar)); \ if (!ptr_) \ goto bad; \ stackbuf = (jschar *) ptr_; \ } \ stackbuf[stacklen++] = (c); \ JS_END_MACRO #define APPEND_STRING_TO_STACK(str) \ JS_BEGIN_MACRO \ JSString *str_ = str; \ jschar *chars_; \ size_t length_; \ \ JSSTRING_CHARS_AND_LENGTH(str_, chars_, length_); \ if (length_ > stackmax - stacklen) { \ void *ptr_; \ if (stackmax >= STACK_LENGTH_LIMIT || \ length_ >= STACK_LENGTH_LIMIT - stacklen) { \ goto done; \ } \ stackmax = JS_BIT(JS_CeilingLog2(stacklen + length_)); \ ptr_ = JS_realloc(cx, stackbuf, (stackmax+1) * sizeof(jschar)); \ if (!ptr_) \ goto bad; \ stackbuf = (jschar *) ptr_; \ } \ js_strncpy(stackbuf + stacklen, chars_, length_); \ stacklen += length_; \ JS_END_MACRO values = GetStackTraceValueBuffer(priv); elem = priv->stackElems; for (endElem = elem + priv->stackDepth; elem != endElem; elem++) { if (elem->funName) { APPEND_STRING_TO_STACK(elem->funName); APPEND_CHAR_TO_STACK('('); for (i = 0; i != elem->argc; i++, values++) { if (i > 0) APPEND_CHAR_TO_STACK(','); str = ValueToShortSource(cx, *values); if (!str) goto bad; APPEND_STRING_TO_STACK(str); } APPEND_CHAR_TO_STACK(')'); } APPEND_CHAR_TO_STACK('@'); if (elem->filename) { for (cp = elem->filename; *cp; cp++) APPEND_CHAR_TO_STACK(*cp); } APPEND_CHAR_TO_STACK(':'); JS_snprintf(ulnbuf, sizeof ulnbuf, "%u", elem->ulineno); for (cp = ulnbuf; *cp; cp++) APPEND_CHAR_TO_STACK(*cp); APPEND_CHAR_TO_STACK('\n'); } #undef APPEND_CHAR_TO_STACK #undef APPEND_STRING_TO_STACK #undef STACK_LENGTH_LIMIT done: if (stacklen == 0) { JS_ASSERT(!stackbuf); return cx->runtime->emptyString; } 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 = JS_realloc(cx, stackbuf, (stacklen+1) * sizeof(jschar)); if (shrunk) stackbuf = (jschar *) shrunk; } stackbuf[stacklen] = 0; str = js_NewString(cx, stackbuf, stacklen); if (str) return str; bad: if (stackbuf) JS_free(cx, stackbuf); return NULL; }
/* * function readline() * Provides a hook for scripts to read a line from stdin. */ static JSBool ReadLine(JSContext *cx, uintN argc, jsval *vp) { #define BUFSIZE 256 FILE *from; char *buf, *tmp; size_t bufsize, buflength, gotlength; JSBool sawNewline; JSString *str; SG_UNUSED(argc); from = stdin; buflength = 0; bufsize = BUFSIZE; buf = (char *) JS_malloc(cx, bufsize); if (!buf) return JS_FALSE; sawNewline = JS_FALSE; while ((gotlength = js_fgets(buf + buflength, (int)(bufsize - buflength), from)) > 0) { buflength += gotlength; /* Are we done? */ if (buf[buflength - 1] == '\n') { buf[buflength - 1] = '\0'; sawNewline = JS_TRUE; break; } else if (buflength < bufsize - 1) { break; } /* Else, grow our buffer for another pass. */ bufsize *= 2; if (bufsize > buflength) { tmp = (char *) JS_realloc(cx, buf, bufsize); } else { JS_ReportOutOfMemory(cx); tmp = NULL; } if (!tmp) { JS_free(cx, buf); return JS_FALSE; } buf = tmp; } /* Treat the empty string specially. */ if (buflength == 0) { *vp = feof(from) ? JSVAL_NULL : JS_GetEmptyStringValue(cx); JS_free(cx, buf); return JS_TRUE; } /* Shrink the buffer to the real size. */ tmp = (char *) JS_realloc(cx, buf, buflength); if (!tmp) { JS_free(cx, buf); return JS_FALSE; } buf = tmp; /* * Turn buf into a JSString. Note that buflength includes the trailing null * character. */ str = JS_NewStringCopyN(cx, buf, sawNewline ? buflength - 1 : buflength); JS_free(cx, buf); if (!str) return JS_FALSE; *vp = STRING_TO_JSVAL(str); return JS_TRUE; }