static JSBool
Print(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
nsJSSh* shell;
if (!GetJSShGlobal(cx, obj, &shell)) return JS_FALSE;
JSAutoRequest ar(cx);
PRUint32 bytesWritten;
#ifdef DEBUG
// nsCOMPtr<nsIThread> thread;
// nsIThread::GetCurrent(getter_AddRefs(thread));
// printf("printing on thread %p, shell %p, output %p, cx=%p, obj=%p\n", thread.get(), shell, shell->mOutput, cx, obj);
#endif
for (unsigned int i=0; i<argc; ++i) {
JSString *str = JS_ValueToString(cx, argv[i]);
if (!str) return JS_FALSE;
if (shell->mOutput) {
if (shell->mEmitHeader) {
char buf[80];
sprintf(buf, "[%d]", JS_GetStringLength(str));
shell->mOutput->Write(buf, strlen(buf), &bytesWritten);
}
shell->mOutput->Write(JS_GetStringBytes(str), JS_GetStringLength(str), &bytesWritten);
}
else
printf("%s", JS_GetStringBytes(str)); // use cout if no output stream given.
#ifdef DEBUG
// printf("%s", JS_GetStringBytes(str));
#endif
}
return JS_TRUE;
}
/* PRBool newResolve (in nsIXPConnectWrappedNative wrapper, in JSContextPtr cx, in JSObjectPtr obj, in JSVal id, in PRUint32 flags, out JSObjectPtr objp); */
NS_IMETHODIMP
calDateTime::NewResolve(nsIXPConnectWrappedNative *wrapper, JSContext * cx,
JSObject * obj, jsval id, PRUint32 flags,
JSObject * *objp, PRBool *_retval)
{
NS_ENSURE_ARG_POINTER(objp);
NS_ENSURE_ARG_POINTER(_retval);
if (JSVAL_IS_STRING(id)) {
JSString *str = JSVAL_TO_STRING(id);
nsDependentString const name(
reinterpret_cast<PRUnichar const*>(JS_GetStringChars(str)),
JS_GetStringLength(str));
if (name.EqualsLiteral("jsDate")) {
*_retval = JS_DefineUCProperty(cx, obj, JS_GetStringChars(str),
JS_GetStringLength(str),
JSVAL_VOID,
nsnull, nsnull, 0);
*objp = obj;
return *_retval ? NS_OK : NS_ERROR_FAILURE;
}
}
*_retval = PR_TRUE;
return NS_OK;
}
/**
* Convert a JavaScript Object to a map
*
* @param cx the JavaScript context
* @param t the JavaScript Object to convert
* @return a new map containing the JavaScript Object
*/
map* mapFromJSObject(JSContext *cx,jsval t){
map *res=NULL;
JSIdArray *idp=JS_Enumerate(cx,JSVAL_TO_OBJECT(t));
#ifdef JS_DEBUG
fprintf(stderr,"Properties %p\n",(void*)t);
#endif
if(idp!=NULL) {
int index;
jsdouble argNum;
#ifdef JS_DEBUG
fprintf(stderr,"Properties length : %d \n",idp->length);
#endif
for (index=0,argNum=idp->length;index<argNum;index++) {
jsval id = idp->vector[index];
jsval vp;
JS_IdToValue(cx,id,&vp);
char *tmp, *tmp1;
JSString *jsmsg,*jsmsg1;
size_t len,len1;
jsmsg = JS_ValueToString(cx,vp);
len = JS_GetStringLength(jsmsg);
jsval nvp;
tmp=JS_EncodeString(cx,jsmsg);
JS_GetProperty(cx, JSVAL_TO_OBJECT(t), tmp, &nvp);
jsmsg1 = JS_ValueToString(cx,nvp);
len1 = JS_GetStringLength(jsmsg1);
tmp1=JS_EncodeString(cx,jsmsg1);
#ifdef JS_DEBUG
fprintf(stderr,"Enumerate id : %d [ %s => %s ]\n",index,tmp,tmp1);
#endif
if(strcasecmp(tmp,"child")!=0){
if(res!=NULL){
#ifdef JS_DEBUG
fprintf(stderr,"%s - %s\n",tmp,tmp1);
#endif
addToMap(res,tmp,tmp1);
}
else{
res=createMap(tmp,tmp1);
res->next=NULL;
}
}
free(tmp);
free(tmp1);
#ifdef JS_DEBUG
dumpMap(res);
#endif
}
JS_DestroyIdArray(cx,idp);
}
#ifdef JS_DEBUG
dumpMap(res);
#endif
return res;
}
int
to_erl_object(emonk_buf_t* buf, JSContext* cx, JSObject* obj)
{
JSObject* iter;
JSString* key;
jsid idp;
jsval val;
jschar* keyname;
size_t keylen;
int count = 0;
int lengthpos;
REQUEST(7);
BUFPTR[0] = SMALL_TUPLE;
BUFPTR[1] = (char) 1;
BUFPTR[2] = LIST;
// Remember the byte offset where length goes so we can write it
// after enumerating the properties.
lengthpos = buf->used + 3;
buf->used += 7;
iter = JS_NewPropertyIterator(cx, obj);
if(iter == NULL) return ERROR;
while(JS_NextProperty(cx, iter, &idp))
{
// Done iterating, write length and bail.
if(idp == JSVAL_VOID)
{
count = htonl(count);
memcpy(buf->buf+lengthpos, &count, 4);
REQUEST(1);
BUFPTR[0] = NIL;
buf->used += 1;
return OK;
}
REQUEST(2);
BUFPTR[0] = SMALL_TUPLE;
BUFPTR[1] = 2;
buf->used += 2;
if(!JS_IdToValue(cx, idp, &val)) return ERROR;
if(!to_erl_string(buf, cx, val)) return ERROR;
key = JS_ValueToString(cx, val);
keyname = JS_GetStringChars(key);
keylen = JS_GetStringLength(key);
if(!JS_GetUCProperty(cx, obj, keyname, keylen, &val)) return ERROR;
if(!to_erl_intern(buf, cx, val)) return ERROR;
count += 1;
}
return ERROR;
}
Btoa(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
JSString *str;
if (!argc)
return JS_TRUE;
str = JS_ValueToString(cx, argv[0]);
if (!str)
return JS_FALSE;
char *bin_data = JS_GetStringBytes(str);
size_t bin_dataLength = JS_GetStringLength(str);
char *base64 = PL_Base64Encode(bin_data, bin_dataLength, nsnull);
if (!base64)
return JS_FALSE;
PRUint32 base64Length = ((bin_dataLength + 2) / 3) * 4;
str = JS_NewStringCopyN(cx, base64, base64Length);
PR_Free(base64);
if (!str)
return JS_FALSE;
*rval = STRING_TO_JSVAL(str);
return JS_TRUE;
}
Atob(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
JSString *str;
if (!argc)
return JS_TRUE;
str = JS_ValueToString(cx, argv[0]);
if (!str)
return JS_FALSE;
size_t base64StrLength = JS_GetStringLength(str);
char *base64Str = JS_GetStringBytes(str);
PRUint32 bin_dataLength = (PRUint32)base64StrLength;
if (base64Str[base64StrLength - 1] == '=') {
if (base64Str[base64StrLength - 2] == '=')
bin_dataLength -= 2;
else
--bin_dataLength;
}
bin_dataLength = (PRUint32)((PRUint64)bin_dataLength * 3) / 4;
char *bin_data = PL_Base64Decode(base64Str, base64StrLength, nsnull);
if (!bin_data)
return JS_FALSE;
str = JS_NewStringCopyN(cx, bin_data, bin_dataLength);
PR_Free(bin_data);
if (!str)
return JS_FALSE;
*rval = STRING_TO_JSVAL(str);
return JS_TRUE;
}
JSBool wimg_image_info_setter(JSContext * cx, JSObject * obj, jsval idval, jsval * vp)
{
JS_BeginRequest(cx);
HANDLE hImage = JS_GetPrivate(cx, obj);
JSString * newInfo = JS_ValueToString(cx, *vp);
*vp = STRING_TO_JSVAL(newInfo);
DWORD length = JS_GetStringLength(newInfo);
LPWSTR chars = (LPWSTR)JS_GetStringChars(newInfo);
if(*chars != 0xfeff)
{
length++;
LPWSTR back = chars;
chars = (LPWSTR)JS_malloc(cx, sizeof(WCHAR) * (length + 1));
memset(chars, 0, sizeof(WCHAR) * (length + 1));
*chars = 0xfeff;
wcscat(chars, back);
newInfo = JS_NewUCString(cx, (jschar*)chars, sizeof(WCHAR) * length);
*vp = STRING_TO_JSVAL(newInfo);
}
DWORD errorCode = 0;
if(!WIMSetImageInformation(hImage, (LPVOID)chars, length * sizeof(WCHAR)))
errorCode = GetLastError();
JS_EndRequest(cx);
return JS_TRUE;
}
JSBool wimg_image_info_getter(JSContext * cx, JSObject * obj, jsval idval, jsval * vp)
{
JS_BeginRequest(cx);
HANDLE hImage = JS_GetPrivate(cx, obj);
LPVOID rawImageInfo;
DWORD rawImageInfoSize;
if(!WIMGetImageInformation(hImage, &rawImageInfo, &rawImageInfoSize))
*vp = JSVAL_NULL;
JSString * xmlStr = JS_NewUCStringCopyN(cx, (jschar*)rawImageInfo, rawImageInfoSize / sizeof(WCHAR));
if(xmlStr == NULL)
{
JS_ReportError(cx, "Error creating xml string from raw image information");
JS_EndRequest(cx);
return JS_FALSE;
}
jsval xmlStrVal = STRING_TO_JSVAL(xmlStr);
*vp = xmlStrVal;
LocalFree(rawImageInfo);
WIMSetImageInformation(hImage, JS_GetStringChars(xmlStr), JS_GetStringLength(xmlStr) * sizeof(jschar));
JS_EndRequest(cx);
return JS_TRUE;
}
xpc_qsACString::xpc_qsACString(JSContext *cx, jsval *pval)
{
// From the T_CSTRING case in XPCConvert::JSData2Native.
jsval v;
JSString *s;
v = *pval;
if(JSVAL_IS_STRING(v))
{
s = JSVAL_TO_STRING(v);
}
else
{
if(JSVAL_IS_NULL(v) || JSVAL_IS_VOID(v))
{
(new(mBuf) implementation_type())->SetIsVoid(PR_TRUE);
mValid = JS_TRUE;
return;
}
s = JS_ValueToString(cx, v);
if(!s)
{
mValid = JS_FALSE;
return;
}
*pval = STRING_TO_JSVAL(s); // Root the new string.
}
const char *bytes = JS_GetStringBytes(s);
size_t len = JS_GetStringLength(s);
new(mBuf) implementation_type(bytes, len);
mValid = JS_TRUE;
}
static JSBool
jsWrite( JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval )
{
*rval = JSVAL_FALSE ;
jsUsblpPoll_t *dev = (jsUsblpPoll_t *)JS_GetInstancePrivate( cx, obj, &jsUsblpClass_, NULL );
if( dev )
{
unsigned totalLength = 0 ;
for( uintN arg = 0 ; arg < argc ; arg++ )
{
JSString *str = JS_ValueToString(cx, argv[arg]);
if( str ) {
unsigned const segLength = JS_GetStringLength( str );
char const *outData = JS_GetStringBytes( str );
int numWritten = dev->write( outData, segLength );
if( 0 < numWritten ) {
totalLength += numWritten ;
}
else if( 0 > numWritten ) {
JS_ReportError( cx, "usblp: short write %d of %u\n", numWritten, segLength );
}
}
else
JS_ReportError( cx, "usblp.write() - error converting to string\n" );
}
*rval = INT_TO_JSVAL(totalLength);
}
else
JS_ReportError( cx, "Invalid usblp object\n" );
return JS_TRUE ;
}
SV *
PJS_JSString2SV(
pTHX_
JSString *jstr
) {
SV *ret;
#if PJS_UTF8_NATIVE
char *str = JS_GetStringBytes(jstr);
ret = newSVpv(str, 0);
SvUTF8_on(ret);
#else
dSP;
jschar *chars = JS_GetStringChars(jstr);
SV *esv = newSVpv((char *)chars, JS_GetStringLength(jstr) * sizeof(jschar));
ENTER; SAVETMPS;
PUSHMARK(SP);
XPUSHs(sv_2mortal(newSVpv(PJS_STR_ENCODING, 0)));
XPUSHs(sv_2mortal(esv));
PUTBACK;
call_pv("Encode::decode", G_SCALAR);
SPAGAIN;
ret = newSVsv(POPs);
PUTBACK;
FREETMPS; LEAVE;
// sv_utf8_downgrade(ret, 1); Its safe, but pays the cost?
#endif
return ret;
}
nsresult
nsDOMWorkerTimeout::ExpressionCallback::Run(nsDOMWorkerTimeout* aTimeout,
JSContext* aCx)
{
JSObject* global = JS_GetGlobalObject(aCx);
NS_ENSURE_TRUE(global, NS_ERROR_FAILURE);
JSPrincipals* principal = nsDOMWorkerSecurityManager::WorkerPrincipal();
NS_ENSURE_TRUE(principal, NS_ERROR_FAILURE);
JSString* expression = JS_ValueToString(aCx, mExpression);
NS_ENSURE_TRUE(expression, NS_ERROR_FAILURE);
jschar* string = JS_GetStringChars(expression);
NS_ENSURE_TRUE(string, NS_ERROR_FAILURE);
size_t stringLength = JS_GetStringLength(expression);
jsval rval;
PRBool success = JS_EvaluateUCScriptForPrincipals(aCx, global, principal,
string, stringLength,
mFileName.get(),
mLineNumber, &rval);
if (!success) {
return NS_ERROR_FAILURE;
}
return NS_OK;
}
static JSBool
jsSend( JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval )
{
*rval = JSVAL_FALSE ;
jsPort_t *params = (jsPort_t *)JS_GetInstancePrivate( cx, obj, &jsSerialPortClass_, NULL );
if( params )
{
if( 1 == argc )
{
JSString *jsMsg = JSVAL_TO_STRING( argv[0] );
char * p = JS_GetStringBytes( jsMsg );
int len = JS_GetStringLength( jsMsg );
int numWritten;
if (params->outputDelay()==0)
numWritten = write( params->getFd(), p, len );
else {
numWritten=0;
while (len) {
usleep(params->outputDelay() );
numWritten += write( params->getFd(), p, 1 );
p++;
len--;
}
}
*rval = INT_TO_JSVAL( numWritten );
}
else
JS_ReportError( cx, "Usage: sendToScanner( \'string\' );" );
}
return JS_TRUE ;
}
static JSBool
js_json_parse(JSContext *cx, JSObject* pThis, uintN argc, jsval *vp, jsval* rval)
{
JSString *s = NULL;
jsval *argv = vp;
// Must throw an Error if there isn't a first arg
if (!JS_ConvertArguments(cx, argc, argv, "S", &s))
return JS_FALSE;
JSBool ok = JS_TRUE;
JSONParser *jp = js_BeginJSONParse(cx, rval);
if (!jp)
ok = JS_FALSE;
if (ok) {
ok = js_ConsumeJSONText(cx, jp, JS_GetStringChars(s), JS_GetStringLength(s));
ok &= js_FinishJSONParse(cx, jp);
}
if (!ok)
JS_ReportError(cx, "Error parsing JSON.");
return ok;
}
/* PRBool getProperty (in nsIXPConnectWrappedNative wrapper, in JSContextPtr cx, in JSObjectPtr obj, in JSVal id, in JSValPtr vp); */
NS_IMETHODIMP
calDateTime::GetProperty(nsIXPConnectWrappedNative *wrapper, JSContext * cx,
JSObject * obj_, jsval id, jsval * vp, PRBool *_retval)
{
NS_ENSURE_ARG_POINTER(vp);
NS_ENSURE_ARG_POINTER(_retval);
if (JSVAL_IS_STRING(id)) {
nsDependentString const jsid(
reinterpret_cast<PRUnichar const*>(
JS_GetStringChars(JSVAL_TO_STRING(id))),
JS_GetStringLength(JSVAL_TO_STRING(id)));
if (jsid.EqualsLiteral("jsDate")) {
PRTime tmp, thousand;
jsdouble msec;
LL_I2L(thousand, 1000);
LL_DIV(tmp, mNativeTime, thousand);
LL_L2D(msec, tmp);
JSObject *obj;
PRBool b;
if (NS_SUCCEEDED(mTimezone->GetIsFloating(&b)) && b)
obj = js_NewDateObject(cx, mYear, mMonth, mDay, mHour, mMinute, mSecond);
else
obj = js_NewDateObjectMsec(cx, msec);
*vp = OBJECT_TO_JSVAL(obj);
*_retval = PR_TRUE;
return NS_SUCCESS_I_DID_SOMETHING;
}
}
*_retval = PR_TRUE;
return NS_OK;
}
PyObject*
Context_execute(Context* self, PyObject* args, PyObject* kwargs)
{
PyObject* obj = NULL;
PyObject* ret = NULL;
JSContext* cx = NULL;
JSObject* root = NULL;
JSString* script = NULL;
jschar* schars = NULL;
JSBool started_counter = JS_FALSE;
size_t slen;
jsval rval;
JS_BeginRequest(self->cx);
if(!PyArg_ParseTuple(args, "O", &obj)) goto error;
script = py2js_string_obj(self, obj);
if(script == NULL) goto error;
schars = JS_GetStringChars(script);
slen = JS_GetStringLength(script);
cx = self->cx;
root = self->root;
// Mark us for time consumption
if(self->start_time == 0)
{
started_counter = JS_TRUE;
self->start_time = time(NULL);
}
if(!JS_EvaluateUCScript(cx, root, schars, slen, "<JavaScript>", 1, &rval))
{
if(!PyErr_Occurred())
{
PyErr_SetString(PyExc_RuntimeError, "Failed to execute script.");
}
goto error;
}
if(PyErr_Occurred()) goto error;
ret = js2py(self, rval);
JS_EndRequest(self->cx);
JS_MaybeGC(self->cx);
goto success;
error:
JS_EndRequest(self->cx);
success:
if(started_counter)
{
self->start_time = 0;
}
return ret;
}
char*
enc_string(JSContext* cx, jsval arg, size_t* buflen)
{
JSString* str = NULL;
jschar* src = NULL;
char* bytes = NULL;
size_t srclen = 0;
size_t byteslen = 0;
str = JS_ValueToString(cx, arg);
if(!str) goto error;
src = JS_GetStringChars(str);
srclen = JS_GetStringLength(str);
if(!enc_charbuf(src, srclen, NULL, &byteslen)) goto error;
bytes = JS_malloc(cx, (byteslen) + 1);
bytes[byteslen] = 0;
if(!enc_charbuf(src, srclen, bytes, &byteslen)) goto error;
if(buflen) *buflen = byteslen;
goto success;
error:
if(bytes != NULL) JS_free(cx, bytes);
bytes = NULL;
success:
return bytes;
}
/**
* Convert a JavaScript value to a char*
*
* @param context the JavaScript context
* @param arg the JavaScript value
* @return a new char*
* @warning be sure to free the resources returned by this function
*/
char* JSValToChar(JSContext* context, jsval* arg) {
char *c;
char *tmp;
JSString *jsmsg;
size_t len;
int i;
if(!JSVAL_IS_STRING(*arg)) {
return NULL;
}
jsmsg = JS_ValueToString(context,*arg);
len = JS_GetStringLength(jsmsg);
tmp = JS_EncodeString(context,jsmsg);
c = (char*)malloc((len+1)*sizeof(char));
c[len] = '\0';
#ifdef ULINET_DEBUG
fprintf(stderr,"%d \n",len);
#endif
for(i = 0;i < len;i++) {
c[i] = tmp[i];
c[i+1] = 0;
}
#ifdef ULINET_DEBUG
fprintf(stderr,"%s \n",c);
#endif
return c;
}
VALUE convert_js_string_to_ruby(JohnsonRuntime* runtime, JSString* str)
{
JSContext * context = johnson_get_current_context(runtime);
PREPARE_RUBY_JROOTS(context, 1);
JROOT(str);
char* bytes = JS_GetStringBytes(str);
JCHECK(bytes);
JRETURN_RUBY(rb_str_new(bytes, (signed long)JS_GetStringLength(str)));
}
/* Execute a string in its own context (away from Synchronet objects) */
static JSBool
js_eval(JSContext *parent_cx, JSObject *parent_obj, uintN argc, jsval *argv, jsval *rval)
{
char* buf;
size_t buflen;
JSString* str;
JSScript* script;
JSContext* cx;
JSObject* obj;
JSErrorReporter reporter;
#ifndef EVAL_BRANCH_CALLBACK
JSBranchCallback callback;
#endif
if(argc<1)
return(JS_TRUE);
if((str=JS_ValueToString(parent_cx, argv[0]))==NULL)
return(JS_FALSE);
if((buf=JS_GetStringBytes(str))==NULL)
return(JS_FALSE);
buflen=JS_GetStringLength(str);
if((cx=JS_NewContext(JS_GetRuntime(parent_cx),JAVASCRIPT_CONTEXT_STACK))==NULL)
return(JS_FALSE);
/* Use the error reporter from the parent context */
reporter=JS_SetErrorReporter(parent_cx,NULL);
JS_SetErrorReporter(parent_cx,reporter);
JS_SetErrorReporter(cx,reporter);
#ifdef EVAL_BRANCH_CALLBACK
JS_SetContextPrivate(cx, JS_GetPrivate(parent_cx, parent_obj));
JS_SetBranchCallback(cx, js_BranchCallback);
#else /* Use the branch callback from the parent context */
JS_SetContextPrivate(cx, JS_GetContextPrivate(parent_cx));
callback=JS_SetBranchCallback(parent_cx,NULL);
JS_SetBranchCallback(parent_cx, callback);
JS_SetBranchCallback(cx, callback);
#endif
if((obj=JS_NewObject(cx, NULL, NULL, NULL))==NULL
|| !JS_InitStandardClasses(cx,obj)) {
JS_DestroyContext(cx);
return(JS_FALSE);
}
if((script=JS_CompileScript(cx, obj, buf, buflen, NULL, 0))!=NULL) {
JS_ExecuteScript(cx, obj, script, rval);
JS_DestroyScript(cx, script);
}
JS_DestroyContext(cx);
return(JS_TRUE);
}
//
// constructor for the scanner object
//
static JSBool jsSerialPort( JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval )
{
JSString *sDevice = JSVAL_TO_STRING( argv[0] );
if( ( 0 != (cx->fp->flags & JSFRAME_CONSTRUCTING) )
&&
( 1 <= argc )
&&
( 0 != ( sDevice = JSVAL_TO_STRING( argv[0] ) ) ) )
{
JSObject *portObj = JS_NewObject( cx, &jsSerialPortClass_, spProto, obj );
if( portObj )
{
*rval = OBJECT_TO_JSVAL(portObj); // root
JS_SetPrivate( cx, portObj, 0 );
JS_DefineProperty( cx, portObj, "deviceName", argv[0], 0, 0, JSPROP_READONLY|JSPROP_ENUMERATE );
char terminator = '\0' ;
unsigned inputTimeout = 0 ;
if( 2 <= argc )
{
JSString *sTerminator = JSVAL_TO_STRING( argv[1] );
if( sTerminator && ( 1 == JS_GetStringLength( sTerminator ) ) )
{
JS_DefineProperty( cx, portObj, "terminator", argv[1], 0, 0, JSPROP_READONLY|JSPROP_ENUMERATE );
terminator = *JS_GetStringBytes( sTerminator );
}
else
JS_ReportError( cx, "serialPort terminator must be single-character string" );
if( 3 <= argc )
{
if( JSVAL_IS_INT( argv[2] ) )
{
inputTimeout = (unsigned)JSVAL_TO_INT( argv[2] );
}
else
JS_ReportError( cx, "input timeout must be an integer" );
} // input timeout property
} // have terminator property
(void )new jsPort_t( pollHandlers_, JS_GetStringBytes( sDevice ),
9600, 8, 'N', 0, terminator, inputTimeout, *rval, portObj );
}
else
{
JS_ReportError( cx, "allocating serialPort\n" );
*rval = JSVAL_FALSE ;
}
}
else
JS_ReportError( cx, "Usage : myVar = new serialPort( '/dev/ttyS2', '\r' );" );
return JS_TRUE;
}
std::string
gjs_debug_string(JSString *str)
{
if (!JS_StringIsFlat(str)) {
std::ostringstream out("<non-flat string of length ");
out << JS_GetStringLength(str) << '>';
return out.str();
}
return gjs_debug_flat_string(JS_ASSERT_STRING_IS_FLAT(str));
}
struct Hjava_lang_String *netscape_jsdebug_DebugController_executeScriptInStackFrame0(struct Hnetscape_jsdebug_DebugController *self,struct Hnetscape_jsdebug_JSStackFrameInfo *frame,struct Hjava_lang_String *src,struct Hjava_lang_String *filename,long lineno)
{
struct Hnetscape_jsdebug_JSThreadState* threadStateOb;
JSDThreadState* jsdthreadstate;
JSDStackFrameInfo* jsdframe;
char* filenameC;
char* srcC;
JSString* jsstr;
jsval rval;
JSBool success;
int srclen;
threadStateOb = (struct Hnetscape_jsdebug_JSThreadState*)unhand(frame)->threadState;
jsdthreadstate = (JSDThreadState*) unhand(threadStateOb)->nativeThreadState;
jsdframe = (JSDStackFrameInfo*) unhand(frame)->_nativePtr;
if( ! context || ! controller || ! jsdframe )
return NULL;
filenameC = allocCString(filename);
if( ! filenameC )
return NULL;
srcC = allocCString(src);
if( ! srcC )
{
free(filenameC);
return NULL;
}
srclen = strlen(srcC);
success = JSD_EvaluateScriptInStackFrame(context, jsdthreadstate, jsdframe,
srcC, srclen,
filenameC, lineno, &rval);
/* XXX crashing on Windows under Symantec (though I can't see why!)*/
free(filenameC);
free(srcC);
if( ! success )
return NULL;
if( JSVAL_IS_NULL(rval) || JSVAL_IS_VOID(rval) )
return NULL;
jsstr = JSD_ValToStringInStackFrame(context,jsdthreadstate,jsdframe,rval);
if( ! jsstr )
return NULL;
/* XXXbe should use JS_GetStringChars and preserve Unicode. */
return makeJavaString((char*)JS_GetStringBytes(jsstr), JS_GetStringLength(jsstr));
}
void set(JSString* str, JSContext* cx) {
this->cx = cx;
string = str;
// Not suppored in SpiderMonkey v19
//buffer = JS_EncodeString(cx, string);
const jschar *chars = JS_GetStringCharsZ(cx, string);
size_t l = JS_GetStringLength(string);
char* pUTF8Str = cc_utf16_to_utf8((const unsigned short*)chars, l, NULL, NULL);
buffer = pUTF8Str;
}
jstring
jsj_ConvertJSStringToJavaString(JSContext *cx, JNIEnv *jEnv, JSString *js_str)
{
jstring result;
result = (*jEnv)->NewString(jEnv, JS_GetStringChars(js_str),
JS_GetStringLength(js_str));
if (!result) {
jsj_UnexpectedJavaError(cx, jEnv, "Couldn't construct instance "
"of java.lang.String");
}
return result;
}
JSBool JsHttpServerResponse::binaryWrite(JSContext *cx,JSObject *obj,uintN argc,jsval *argv,jsval *rval)
{
if ( !JSVAL_IS_STRING(argv[0]) ) {
return Engine::throwUsageError(cx,argv);
}
JSString *data = JSVAL_TO_STRING(argv[0]);
ContextPrivate *cxPrivate = (ContextPrivate*)JS_GetContextPrivate(cx);
cxPrivate->getHttpResponse().write(JS_GetStringBytes(data),JS_GetStringLength(data));
return JS_TRUE;
}
JSBool
xmljs_parse(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
XMLCallback *cb;
XML_Parser xml;
JSString *str;
JSBool ok;
cb = (XMLCallback *)JS_GetPrivate(cx, obj);
if (!cb) {
JS_ReportError(cx, "XMLParser object has no parser!");
return JS_FALSE;
}
if (cb->preParse &&
!cb->preParse(cx, obj, argc, argv, rval))
return JS_FALSE;
if (argc < 1) {
*rval = JSVAL_TRUE;
return JS_TRUE;
}
xml = XML_ParserCreate(NULL);
if (!xml)
return JS_FALSE; /* XXX report error */
/* after this point, have to leave via out: */
XML_SetElementHandler(xml, cb->start, cb->end);
XML_SetCharacterDataHandler(xml, cb->cdata);
XML_SetProcessingInstructionHandler(xml, cb->processing);
XML_SetUserData(xml, (void *)cb);
cb->xml = xml;
str = JS_ValueToString(cx, argv[0]);
if (!XML_Parse(xml, JS_GetStringBytes(str), JS_GetStringLength(str), 1)) {
str = JS_NewStringCopyZ(cx, XML_ErrorString(XML_GetErrorCode(xml)));
if (!str) {
ok = JS_FALSE;
goto out;
}
if (!JS_DefineProperty(cx, obj, "error", STRING_TO_JSVAL(str),
NULL, NULL, JSPROP_ENUMERATE)) {
ok = JS_FALSE;
goto out;
}
*rval = JSVAL_FALSE;
} else {
*rval = JSVAL_TRUE;
}
out:
XML_ParserFree(xml);
cb->xml = NULL;
return ok;
}
static JSBool
evalcx(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
JSString *str;
JSObject *sandbox;
JSContext *subcx;
const jschar *src;
size_t srclen;
JSBool ret = JS_FALSE;
char *name = NULL;
sandbox = NULL;
if(!JS_ConvertArguments(cx, argc, argv, "S / o", &str, &sandbox)) {
return JS_FALSE;
}
subcx = JS_NewContext(JS_GetRuntime(cx), 8L * 1024L);
if(!subcx) {
JS_ReportOutOfMemory(cx);
return JS_FALSE;
}
SETUP_REQUEST(subcx);
src = JS_GetStringChars(str);
srclen = JS_GetStringLength(str);
if(!sandbox) {
sandbox = JS_NewObject(subcx, NULL, NULL, NULL);
if(!sandbox || !JS_InitStandardClasses(subcx, sandbox)) {
goto done;
}
}
if(argc > 2) {
name = enc_string(cx, argv[2], NULL);
}
if(srclen == 0) {
*rval = OBJECT_TO_JSVAL(sandbox);
} else {
JS_EvaluateUCScript(subcx, sandbox, src, srclen, name, 1, rval);
}
ret = JS_TRUE;
done:
if(name) JS_free(cx, name);
FINISH_REQUEST(subcx);
JS_DestroyContext(subcx);
return ret;
}
template<> bool ScriptInterface::FromJSVal<std::string>(JSContext* cx, jsval v, std::string& out)
{
WARN_IF_NOT(JSVAL_IS_STRING(v) || JSVAL_IS_NUMBER(v), v); // allow implicit number conversions
JSString* ret = JS_ValueToString(cx, v);
if (!ret)
FAIL("Argument must be convertible to a string");
char* ch = JS_EncodeString(cx, ret); // chops off high byte of each jschar
if (!ch)
FAIL("JS_EncodeString failed"); // out of memory
out = std::string(ch, ch + JS_GetStringLength(ret));
JS_free(cx, ch);
return true;
}
template<> bool ScriptInterface::FromJSVal<std::string>(JSContext* cx, JS::HandleValue v, std::string& out)
{
JSAutoRequest rq(cx);
WARN_IF_NOT(v.isString() || v.isNumber(), v); // allow implicit number conversions
JS::RootedString str(cx, JS::ToString(cx, v));
if (!str)
FAIL("Argument must be convertible to a string");
char* ch = JS_EncodeString(cx, str); // chops off high byte of each char16_t
if (!ch)
FAIL("JS_EncodeString failed"); // out of memory
out.assign(ch, ch + JS_GetStringLength(str));
JS_free(cx, ch);
return true;
}
