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;
}
