static void init(Handle<Object> target) { target->Set(String::NewSymbol("popen"), FunctionTemplate::New(NodePopen)->GetFunction()); target->Set(String::NewSymbol("popen2"), FunctionTemplate::New(NodePopen2)->GetFunction()); }
static Handle<Value> NodePopen2(const Arguments& args) { HandleScope scope; // Expect a callback function for stdout Handle<String> Command = Handle<String >::Cast(args[0]); Handle<Array> ArgArray = Handle<Array >::Cast(args[1]); // Create Pipes for STDIN, STDOUT, and STDERR // int PIPE_READ = 0; int PIPE_WRITE = 1; int pipe_stdin [2]; // [read,write] int pipe_stdout[2]; int pipe_stderr[2]; pipe (pipe_stdin); pipe (pipe_stdout); pipe (pipe_stderr); pid_t pid; pid = fork(); Handle<Object> ob = Object::New(); if(pid == (pid_t) 0) { // Child // char* command = getAscii(Command); int arrayLen = ArgArray->Length(); char* pargs[arrayLen + 2]; // Create Argument Array from JavaScript Array pargs[0] = command; for(int i=0; i < arrayLen; i++) { pargs[i+1] = getAscii(Handle<String>::Cast( ArgArray->Get(i) )); } pargs[arrayLen+1] = '\0'; // Close Unused Pipe Ends for Child close( pipe_stdin [PIPE_WRITE] ); close( pipe_stdout[PIPE_READ] ); close( pipe_stderr[PIPE_READ] ); // Switch Standard File Descriptors to IPC Pipes dup2( pipe_stdin [PIPE_READ ], STDIN_FILENO ); dup2( pipe_stdout[PIPE_WRITE], STDOUT_FILENO ); dup2( pipe_stderr[PIPE_WRITE], STDERR_FILENO ); int code = execvp(command, pargs); _exit(code); } else { // Parent // Close Unused Ends for Parent close( pipe_stdin [PIPE_READ] ); close( pipe_stdout[PIPE_WRITE] ); close( pipe_stderr[PIPE_WRITE] ); std::string stdout; std::string stderr; char buffer; while( read(pipe_stdout[PIPE_READ], &buffer, 1 ) > 0 ) { stdout.append( 1, buffer ); } while( read(pipe_stderr[PIPE_READ], &buffer, 1 ) > 0 ) { stderr.append( 1, buffer ); } int status; waitpid(pid, &status, 0); ob->Set( String::NewSymbol("code"), Integer::New(status) ); ob->Set( String::NewSymbol("stdout"), String::New(stdout.c_str()) ); ob->Set( String::NewSymbol("stderr"), String::New(stderr.c_str()) ); } return scope.Close(ob); }
V8FunctionData(V8Context* context_, Handle<Object> object_, SV* sv_) : V8ObjectData(context_, object_, sv_) , returns_list(object_->Has(String::New("__perlReturnsList"))) { }
void ConstantPoolCacheEntry::set_method_handle_common(const constantPoolHandle& cpool, Bytecodes::Code invoke_code, const CallInfo &call_info) { // NOTE: This CPCE can be the subject of data races. // There are three words to update: flags, refs[f2], f1 (in that order). // Writers must store all other values before f1. // Readers must test f1 first for non-null before reading other fields. // Competing writers must acquire exclusive access via a lock. // A losing writer waits on the lock until the winner writes f1 and leaves // the lock, so that when the losing writer returns, he can use the linked // cache entry. objArrayHandle resolved_references = cpool->resolved_references(); // Use the resolved_references() lock for this cpCache entry. // resolved_references are created for all classes with Invokedynamic, MethodHandle // or MethodType constant pool cache entries. assert(resolved_references() != NULL, "a resolved_references array should have been created for this class"); ObjectLocker ol(resolved_references, Thread::current()); if (!is_f1_null()) { return; } const methodHandle adapter = call_info.resolved_method(); const Handle appendix = call_info.resolved_appendix(); const Handle method_type = call_info.resolved_method_type(); const bool has_appendix = appendix.not_null(); const bool has_method_type = method_type.not_null(); // Write the flags. set_method_flags(as_TosState(adapter->result_type()), ((has_appendix ? 1 : 0) << has_appendix_shift ) | ((has_method_type ? 1 : 0) << has_method_type_shift) | ( 1 << is_final_shift ), adapter->size_of_parameters()); if (TraceInvokeDynamic) { ttyLocker ttyl; tty->print_cr("set_method_handle bc=%d appendix=" PTR_FORMAT "%s method_type=" PTR_FORMAT "%s method=" PTR_FORMAT " ", invoke_code, p2i(appendix()), (has_appendix ? "" : " (unused)"), p2i(method_type()), (has_method_type ? "" : " (unused)"), p2i(adapter())); adapter->print(); if (has_appendix) appendix()->print(); } // Method handle invokes and invokedynamic sites use both cp cache words. // refs[f2], if not null, contains a value passed as a trailing argument to the adapter. // In the general case, this could be the call site's MethodType, // for use with java.lang.Invokers.checkExactType, or else a CallSite object. // f1 contains the adapter method which manages the actual call. // In the general case, this is a compiled LambdaForm. // (The Java code is free to optimize these calls by binding other // sorts of methods and appendices to call sites.) // JVM-level linking is via f1, as if for invokespecial, and signatures are erased. // The appendix argument (if any) is added to the signature, and is counted in the parameter_size bits. // Even with the appendix, the method will never take more than 255 parameter slots. // // This means that given a call site like (List)mh.invoke("foo"), // the f1 method has signature '(Ljl/Object;Ljl/invoke/MethodType;)Ljl/Object;', // not '(Ljava/lang/String;)Ljava/util/List;'. // The fact that String and List are involved is encoded in the MethodType in refs[f2]. // This allows us to create fewer Methods, while keeping type safety. // // Store appendix, if any. if (has_appendix) { const int appendix_index = f2_as_index() + _indy_resolved_references_appendix_offset; assert(appendix_index >= 0 && appendix_index < resolved_references->length(), "oob"); assert(resolved_references->obj_at(appendix_index) == NULL, "init just once"); resolved_references->obj_at_put(appendix_index, appendix()); } // Store MethodType, if any. if (has_method_type) { const int method_type_index = f2_as_index() + _indy_resolved_references_method_type_offset; assert(method_type_index >= 0 && method_type_index < resolved_references->length(), "oob"); assert(resolved_references->obj_at(method_type_index) == NULL, "init just once"); resolved_references->obj_at_put(method_type_index, method_type()); } release_set_f1(adapter()); // This must be the last one to set (see NOTE above)! // The interpreter assembly code does not check byte_2, // but it is used by is_resolved, method_if_resolved, etc. set_bytecode_1(invoke_code); NOT_PRODUCT(verify(tty)); if (TraceInvokeDynamic) { ttyLocker ttyl; this->print(tty, 0); } }
int main(void) { Object* ns = 0; esInit(&ns); FatFileSystem::initializeConstructor(); Handle<es::Context> nameSpace(ns); #ifdef __es__ Handle<es::Stream> disk = nameSpace->lookup("device/floppy"); #else Handle<es::Stream> disk = new VDisk(static_cast<char*>("2hd.img")); #endif long long diskSize; diskSize = disk->getSize(); esReport("diskSize: %lld\n", diskSize); Handle<es::FileSystem> fatFileSystem; long long freeSpace; long long totalSpace; fatFileSystem = es::FatFileSystem::createInstance(); fatFileSystem->mount(disk); fatFileSystem->format(); freeSpace = fatFileSystem->getFreeSpace(); totalSpace = fatFileSystem->getTotalSpace(); esReport("Free space %lld, Total space %lld\n", freeSpace, totalSpace); { Handle<es::Context> root; root = fatFileSystem->getRoot(); long ret = TestFileSystem(root); TEST (ret == 0); freeSpace = fatFileSystem->getFreeSpace(); totalSpace = fatFileSystem->getTotalSpace(); esReport("Free space %lld, Total space %lld\n", freeSpace, totalSpace); esReport("\nChecking the file system...\n"); TEST(fatFileSystem->checkDisk(false)); } fatFileSystem->dismount(); fatFileSystem = 0; fatFileSystem = es::FatFileSystem::createInstance(); fatFileSystem->mount(disk); freeSpace = fatFileSystem->getFreeSpace(); totalSpace = fatFileSystem->getTotalSpace(); esReport("Free space %lld, Total space %lld\n", freeSpace, totalSpace); esReport("\nChecking the file system...\n"); TEST(fatFileSystem->checkDisk(false)); fatFileSystem->dismount(); fatFileSystem = 0; esReport("done.\n\n"); }
static long TestFileSystem(Handle<es::Context> root) { const char* dirList[] = { "ディレクトリ", "ディレクトリ", "a1", "a2", "a3", "a4", "a5", "a6", "a7", "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15", "a16", "@abc", "@", "_abc", "_", "`abc", "`", "~abc", "~", "+abc", "+", "=abc", "=", "-abc", "-", "1", "1a", "a", "abc_defgh", "abc-defgh", "bcd", "a.b.c", "a b c", "a b c", "^", "^", "!", "!abc", "#", "#abc", "$", "$abc", "%", "%abc", "&", "&abc", "{}", "{abc}", ";abc", ";", ";;;", ";;;abc", "[]", "[abc]", ",", "aaaaaaaaaabbbbbbbbbbccccccccccddddddddddeeeeeeeeee" "ffffffffffgggggggggghhhhhhhhhhiiiiiiiiiijjjjjjjjjj" "kkkkkkkkkkllllllllllmmmmmmmmmmnnnnnnnnnnoooooooooo" "ppppppppppqqqqqqqqqqrrrrrrrrrrsssssssssstttttttttt" "uuuuuuuuuuvvvvvvvvvvwwwwwwwwwwxxxxxxxxxxyyyyyyyyyy" "zzzzz", // 255 "...a", "..opq", ".bcd", // ".e.f.g.", ".e.f.g", // "hij.", // "k.l.m.", "k.l.m", // "rst..", // "u..v..w..", "u..v..w", // "xyz..." }; esReport("Create Directories\n"); int i; for (i = 0; i < sizeof(dirList)/sizeof(dirList[0]); ++i) { int len = strlen(dirList[i]); esReport("create \"%s\" (len %d)\n", dirList[i], len); Handle<es::File> file = root->lookup(dirList[i]); if (!file) { file = root->createSubcontext(dirList[i]); TEST(file->isDirectory()); TEST(file->canRead()); TEST(file->canWrite()); TEST(!file->isHidden()); TEST(!file->isFile()); } TEST(file); char created[512]; file->getName(created, sizeof(created)); TEST(strcmp(created, dirList[i]) == 0); } Handle<es::File> dir = root->createSubcontext("abc"); TEST(dir); dir = 0; dir = root->createSubcontext("abc/def"); TEST(dir); dir = 0; dir = root->createSubcontext("abc\\ghi"); TEST(dir); dir = 0; Handle<es::Context> abc = root->lookup("abc"); TEST(abc); Handle<es::Iterator> iter; iter = abc->list(""); long n = 0; while (iter->hasNext()) { char name[1024]; Handle<es::Binding> binding(iter->next()); binding->getName(name, sizeof name); TEST(strcmp(name, "def") == 0 || strcmp(name, "ghi") == 0); ++n; } TEST(n == 2); // create the directory that already exists. dir = root->createSubcontext("abc"); TEST(!dir); // check wrong name. const char* wrongDirList[] = { "*", "<", ">", "\"", "|", ":", "?", "aaaaaaaaaabbbbbbbbbbccccccccccddddddddddeeeeeeeeee" "ffffffffffgggggggggghhhhhhhhhhiiiiiiiiiijjjjjjjjjj" "kkkkkkkkkkllllllllllmmmmmmmmmmnnnnnnnnnnoooooooooo" "ppppppppppqqqqqqqqqqrrrrrrrrrrsssssssssstttttttttt" "uuuuuuuuuuvvvvvvvvvvwwwwwwwwwwxxxxxxxxxxyyyyyyyyyy" "zzzzzz", // 256, "nonexistent/dir", "nonexistent\\dir" }; for (i = 0; i < sizeof(wrongDirList)/sizeof(wrongDirList[0]); ++i) { int len = strlen(wrongDirList[i]); esReport("create \"%s\" (len %d)\n", wrongDirList[i], len); try { Handle<es::File> file = root->createSubcontext(wrongDirList[i]); TEST(!file); } catch (SystemException<EACCES>& e) { TEST(strcmp(wrongDirList[i], "*") == 0 || strcmp(wrongDirList[i], "<") == 0 || strcmp(wrongDirList[i], ">") == 0 || strcmp(wrongDirList[i], "\"") == 0 || strcmp(wrongDirList[i], "|") == 0 || strcmp(wrongDirList[i], ":") == 0 || strcmp(wrongDirList[i], "?") == 0); } catch (SystemException<ENAMETOOLONG>& e) { TEST(strcmp(wrongDirList[i], "aaaaaaaaaabbbbbbbbbbccccccccccddddddddddeeeeeeeeee" "ffffffffffgggggggggghhhhhhhhhhiiiiiiiiiijjjjjjjjjj" "kkkkkkkkkkllllllllllmmmmmmmmmmnnnnnnnnnnoooooooooo" "ppppppppppqqqqqqqqqqrrrrrrrrrrsssssssssstttttttttt" "uuuuuuuuuuvvvvvvvvvvwwwwwwwwwwxxxxxxxxxxyyyyyyyyyy" "zzzzzz") == 0); } } return 0; }
bool PDFDictionaryDriver::HasInstance(Handle<Value> inObject) { CREATE_ISOLATE_CONTEXT; return inObject->IsObject() && HAS_INSTANCE(constructor_template, inObject); }
Handle<ObjectTemplate> AlutFactory::createAlut(int* pargc, char** argv) { HandleScope handle_scope; Handle<ObjectTemplate> Alut = ObjectTemplate::New(); Alut->SetInternalFieldCount(1); Alut->SetAccessor(String::NewSymbol("API"), GetALUT_API); Alut->SetAccessor(String::NewSymbol("APIENTRY"), GetALUT_APIENTRY); Alut->SetAccessor(String::NewSymbol("ATTRIBUTE_DEPRECATED"), GetALUT_ATTRIBUTE_DEPRECATED); Alut->SetAccessor(String::NewSymbol("API_MAJOR_VERSION"), GetALUT_API_MAJOR_VERSION); Alut->SetAccessor(String::NewSymbol("API_MINOR_VERSION"), GetALUT_API_MINOR_VERSION); Alut->SetAccessor(String::NewSymbol("ERROR_NO_ERROR"), GetALUT_ERROR_NO_ERROR); Alut->SetAccessor(String::NewSymbol("ERROR_OUT_OF_MEMORY"), GetALUT_ERROR_OUT_OF_MEMORY); Alut->SetAccessor(String::NewSymbol("ERROR_INVALID_ENUM"), GetALUT_ERROR_INVALID_ENUM); Alut->SetAccessor(String::NewSymbol("ERROR_INVALID_VALUE"), GetALUT_ERROR_INVALID_VALUE); Alut->SetAccessor(String::NewSymbol("ERROR_INVALID_OPERATION"), GetALUT_ERROR_INVALID_OPERATION); Alut->SetAccessor(String::NewSymbol("ERROR_NO_CURRENT_CONTEXT"), GetALUT_ERROR_NO_CURRENT_CONTEXT); Alut->SetAccessor(String::NewSymbol("ERROR_AL_ERROR_ON_ENTRY"), GetALUT_ERROR_AL_ERROR_ON_ENTRY); Alut->SetAccessor(String::NewSymbol("ERROR_ALC_ERROR_ON_ENTRY"), GetALUT_ERROR_ALC_ERROR_ON_ENTRY); Alut->SetAccessor(String::NewSymbol("ERROR_OPEN_DEVICE"), GetALUT_ERROR_OPEN_DEVICE); Alut->SetAccessor(String::NewSymbol("ERROR_CLOSE_DEVICE"), GetALUT_ERROR_CLOSE_DEVICE); Alut->SetAccessor(String::NewSymbol("ERROR_CREATE_CONTEXT"), GetALUT_ERROR_CREATE_CONTEXT); Alut->SetAccessor(String::NewSymbol("ERROR_MAKE_CONTEXT_CURRENT"), GetALUT_ERROR_MAKE_CONTEXT_CURRENT); Alut->SetAccessor(String::NewSymbol("ERROR_DESTROY_CONTEXT"), GetALUT_ERROR_DESTROY_CONTEXT); Alut->SetAccessor(String::NewSymbol("ERROR_GEN_BUFFERS"), GetALUT_ERROR_GEN_BUFFERS); Alut->SetAccessor(String::NewSymbol("ERROR_BUFFER_DATA"), GetALUT_ERROR_BUFFER_DATA); Alut->SetAccessor(String::NewSymbol("ERROR_IO_ERROR"), GetALUT_ERROR_IO_ERROR); Alut->SetAccessor(String::NewSymbol("ERROR_UNSUPPORTED_FILE_TYPE"), GetALUT_ERROR_UNSUPPORTED_FILE_TYPE); Alut->SetAccessor(String::NewSymbol("ERROR_UNSUPPORTED_FILE_SUBTYPE"), GetALUT_ERROR_UNSUPPORTED_FILE_SUBTYPE); Alut->SetAccessor(String::NewSymbol("ERROR_CORRUPT_OR_TRUNCATED_DATA"), GetALUT_ERROR_CORRUPT_OR_TRUNCATED_DATA); Alut->SetAccessor(String::NewSymbol("WAVEFORM_SINE"), GetALUT_WAVEFORM_SINE); Alut->SetAccessor(String::NewSymbol("WAVEFORM_SQUARE"), GetALUT_WAVEFORM_SQUARE); Alut->SetAccessor(String::NewSymbol("WAVEFORM_SAWTOOTH"), GetALUT_WAVEFORM_SAWTOOTH); Alut->SetAccessor(String::NewSymbol("WAVEFORM_WHITENOISE"), GetALUT_WAVEFORM_WHITENOISE); Alut->SetAccessor(String::NewSymbol("WAVEFORM_IMPULSE"), GetALUT_WAVEFORM_IMPULSE); Alut->SetAccessor(String::NewSymbol("LOADER_BUFFER"), GetALUT_LOADER_BUFFER); Alut->SetAccessor(String::NewSymbol("LOADER_MEMORY"), GetALUT_LOADER_MEMORY); Alut->Set(String::NewSymbol("init"), FunctionTemplate::New(ALUTInitCallback)); Alut->Set(String::NewSymbol("initWithoutContext"), FunctionTemplate::New(ALUTInitWithoutContextCallback)); Alut->Set(String::NewSymbol("exit"), FunctionTemplate::New(ALUTExitCallback)); Alut->Set(String::NewSymbol("getError"), FunctionTemplate::New(ALUTGetErrorCallback)); Alut->Set(String::NewSymbol("getErrorString"), FunctionTemplate::New(ALUTGetErrorStringCallback)); Alut->Set(String::NewSymbol("createBufferFromFile"), FunctionTemplate::New(ALUTCreateBufferFromFileCallback)); Alut->Set(String::NewSymbol("createBufferFromFileImage"), FunctionTemplate::New(ALUTCreateBufferFromFileImageCallback)); Alut->Set(String::NewSymbol("createBufferHelloWorld"), FunctionTemplate::New(ALUTCreateBufferHelloWorldCallback)); Alut->Set(String::NewSymbol("createBufferWaveform"), FunctionTemplate::New(ALUTCreateBufferWaveformCallback)); Alut->Set(String::NewSymbol("loadMemoryFromFile"), FunctionTemplate::New(ALUTLoadMemoryFromFileCallback)); Alut->Set(String::NewSymbol("loadMemoryFromFileImage"), FunctionTemplate::New(ALUTLoadMemoryFromFileImageCallback)); Alut->Set(String::NewSymbol("loadMemoryHelloWorld"), FunctionTemplate::New(ALUTLoadMemoryHelloWorldCallback)); Alut->Set(String::NewSymbol("loadMemoryWaveform"), FunctionTemplate::New(ALUTLoadMemoryWaveformCallback)); Alut->Set(String::NewSymbol("getMIMETypes"), FunctionTemplate::New(ALUTGetMIMETypesCallback)); Alut->Set(String::NewSymbol("getMajorVersion"), FunctionTemplate::New(ALUTGetMajorVersionCallback)); Alut->Set(String::NewSymbol("getMinorVersion"), FunctionTemplate::New(ALUTGetMinorVersionCallback)); Alut->Set(String::NewSymbol("sleep"), FunctionTemplate::New(ALUTSleepCallback)); Alut->Set(String::NewSymbol("loadWAVFile"), FunctionTemplate::New(ALUTLoadWAVFileCallback)); Alut->Set(String::NewSymbol("loadWAVMemory"), FunctionTemplate::New(ALUTLoadWAVMemoryCallback)); Alut->Set(String::NewSymbol("loadWAVFile"), FunctionTemplate::New(ALUTLoadWAVFileCallback)); Alut->Set(String::NewSymbol("loadWAVMemory"), FunctionTemplate::New(ALUTLoadWAVMemoryCallback)); Alut->Set(String::NewSymbol("unloadWAV"), FunctionTemplate::New(ALUTUnloadWAVCallback)); // Again, return the result through the current handle scope. return handle_scope.Close(Alut); }
bool JavaScriptShared::fromDescriptor(JSContext* cx, Handle<PropertyDescriptor> desc, PPropertyDescriptor* out) { out->attrs() = desc.attributes(); if (!toVariant(cx, desc.value(), &out->value())) return false; if (!toObjectOrNullVariant(cx, desc.object(), &out->obj())) return false; if (!desc.getter()) { out->getter() = 0; } else if (desc.hasGetterObject()) { JSObject* getter = desc.getterObject(); ObjectVariant objVar; if (!toObjectVariant(cx, getter, &objVar)) return false; out->getter() = objVar; } else { MOZ_ASSERT(desc.getter() != JS_PropertyStub); out->getter() = UnknownPropertyOp; } if (!desc.setter()) { out->setter() = 0; } else if (desc.hasSetterObject()) { JSObject* setter = desc.setterObject(); ObjectVariant objVar; if (!toObjectVariant(cx, setter, &objVar)) return false; out->setter() = objVar; } else { MOZ_ASSERT(desc.setter() != JS_StrictPropertyStub); out->setter() = UnknownPropertyOp; } return true; }
void V8Script::run(ShapeManager2d& pb) { isolate->Enter(); // Create a stack-allocated handle scope. HandleScope handle_scope(Isolate::GetCurrent()); Handle<ObjectTemplate> global = ObjectTemplate::New(); /* global->Set(String::NewFromUtf8(Isolate::GetCurrent(), "__buffer__"), External::New(&pb)); auto color = [](const v8::FunctionCallbackInfo<v8::Value>& args) -> Handle<Value> { unsigned int x = args[0]->Uint32Value(); unsigned int y = args[1]->Uint32Value(); Local<Value> funcObj = args.Callee()->Get(String::NewFromUtf8(Isolate::GetCurrent(), "__buffer")); Local<External> wrap = Local<External>::Cast(funcObj); void* ptr = wrap->Value(); Local<Object> obj = color_templ->NewInstance(); obj->SetInternalField(0, External::New(&(*static_cast<PixelBuffer*>(ptr))(x, y))); args.GetReturnValue().Set(obj); }; Local<FunctionTemplate> colorFuncTemplate = FunctionTemplate::New(Isolate::GetCurrent(), color); colorFuncTemplate->Set(String::NewFromUtf8(Isolate::GetCurrent(), "__buffer"), External::New(&pb));*/ Local<External> shapeManagerWrap = External::New(Isolate::GetCurrent(), static_cast<void*>(&pb)); Local<FunctionTemplate> makeTriangleTemplate = FunctionTemplate::New(Isolate::GetCurrent(), makeTriangle); makeTriangleTemplate->Set(Isolate::GetCurrent(), shapeManagerStr.c_str(), shapeManagerWrap); Local<FunctionTemplate> makeLineTemplate = FunctionTemplate::New(Isolate::GetCurrent(), makeLine); makeLineTemplate->Set(Isolate::GetCurrent(), shapeManagerStr.c_str(), shapeManagerWrap); Local<FunctionTemplate> makeQuadTemplate = FunctionTemplate::New(Isolate::GetCurrent(), makeQuad); makeQuadTemplate->Set(Isolate::GetCurrent(), shapeManagerStr.c_str(), shapeManagerWrap); Local<FunctionTemplate> frameWaitTemplate = FunctionTemplate::New(Isolate::GetCurrent(), frameWait); frameWaitTemplate->Set(Isolate::GetCurrent(), shapeManagerStr.c_str(), shapeManagerWrap); //Local<FunctionTemplate> getShapeTemplate = FunctionTemplate::New(Isolate::GetCurrent(), getShape); //getShapeTemplate->Set(shapeManagerStr.c_str(), External::New(&pb)); // Return an empty result if there was an error creating the array. /* if (array.IsEmpty()) { return Handle<Array>(); }*/ // Fill out the values global->Set(String::NewFromUtf8(Isolate::GetCurrent(), "makeTriangle"), makeTriangleTemplate); global->Set(String::NewFromUtf8(Isolate::GetCurrent(), "makeLine"), makeLineTemplate); global->Set(String::NewFromUtf8(Isolate::GetCurrent(), "makeQuad"), makeQuadTemplate); global->Set(String::NewFromUtf8(Isolate::GetCurrent(), "frameWait"), frameWaitTemplate); global->Set(String::NewFromUtf8(Isolate::GetCurrent(), "getMouseX"), FunctionTemplate::New(Isolate::GetCurrent(), getMouseX)); global->Set(String::NewFromUtf8(Isolate::GetCurrent(), "getMouseY"), FunctionTemplate::New(Isolate::GetCurrent(), getMouseY)); //global->Set(String::NewFromUtf8(Isolate::GetCurrent(), "shape"), getShapeTemplate); // Create a new context. Handle<Context> context = Context::New(Isolate::GetCurrent(), NULL, global); // Enter the created context for compiling and // running the hello world script. Context::Scope context_scope(context); /* // Create a new empty array. Handle<Array> array = Array::New(pb.maxX()); for(unsigned int x = 0; x < pb.maxX(); x++) { Handle<Array> line = Array::New(pb.maxY()); if(!line.IsEmpty()) { for(unsigned int y = 0; y < pb.maxY(); y++) { Local<Object> obj = color_templ->NewInstance(); obj->SetInternalField(0, External::New(&pb(x, y))); line->Set(y, obj); } } array->Set(x, line); } context->Global()->Set(String::NewFromUtf8(Isolate::GetCurrent(), "color"), array);*/ // Create a string containing the JavaScript source code. Handle<String> source = String::NewFromUtf8(Isolate::GetCurrent(), program.c_str()); // Compile the source code. Handle<Script> script = Script::Compile(source); // Run the script to get the result. //while(true) { //Handle<Value> result = script->Run(); script->Run(); //SDL_Delay(1); //pb.clear(); //} isolate->Exit(); }
int V8Scope::type( const char *field ){ V8_SIMPLE_HEADER Handle<Value> v = get( field ); if ( v->IsNull() ) return jstNULL; if ( v->IsUndefined() ) return Undefined; if ( v->IsString() ) return String; if ( v->IsFunction() ) return Code; if ( v->IsArray() ) return Array; if ( v->IsBoolean() ) return Bool; if ( v->IsInt32() ) return NumberInt; if ( v->IsNumber() ) return NumberDouble; if ( v->IsExternal() ){ uassert( 10230 , "can't handle external yet" , 0 ); return -1; } if ( v->IsDate() ) return Date; if ( v->IsObject() ) return Object; throw UserException( 12509, (string)"don't know what this is: " + field ); }
BiasedLocking::Condition BiasedLocking::revoke_and_rebias(Handle obj, bool attempt_rebias, TRAPS) { assert(!SafepointSynchronize::is_at_safepoint(), "must not be called while at safepoint"); // We can revoke the biases of anonymously-biased objects // efficiently enough that we should not cause these revocations to // update the heuristics because doing so may cause unwanted bulk // revocations (which are expensive) to occur. markOop mark = obj->mark(); if (mark->is_biased_anonymously() && !attempt_rebias) { // We are probably trying to revoke the bias of this object due to // an identity hash code computation. Try to revoke the bias // without a safepoint. This is possible if we can successfully // compare-and-exchange an unbiased header into the mark word of // the object, meaning that no other thread has raced to acquire // the bias of the object. markOop biased_value = mark; markOop unbiased_prototype = markOopDesc::prototype()->set_age(mark->age()); markOop res_mark = (markOop) Atomic::cmpxchg_ptr(unbiased_prototype, obj->mark_addr(), mark); if (res_mark == biased_value) { return BIAS_REVOKED; } } else if (mark->has_bias_pattern()) { Klass* k = obj->klass(); markOop prototype_header = k->prototype_header(); if (!prototype_header->has_bias_pattern()) { // This object has a stale bias from before the bulk revocation // for this data type occurred. It's pointless to update the // heuristics at this point so simply update the header with a // CAS. If we fail this race, the object's bias has been revoked // by another thread so we simply return and let the caller deal // with it. markOop biased_value = mark; markOop res_mark = (markOop) Atomic::cmpxchg_ptr(prototype_header, obj->mark_addr(), mark); assert(!(*(obj->mark_addr()))->has_bias_pattern(), "even if we raced, should still be revoked"); return BIAS_REVOKED; } else if (prototype_header->bias_epoch() != mark->bias_epoch()) { // The epoch of this biasing has expired indicating that the // object is effectively unbiased. Depending on whether we need // to rebias or revoke the bias of this object we can do it // efficiently enough with a CAS that we shouldn't update the // heuristics. This is normally done in the assembly code but we // can reach this point due to various points in the runtime // needing to revoke biases. if (attempt_rebias) { assert(THREAD->is_Java_thread(), ""); markOop biased_value = mark; markOop rebiased_prototype = markOopDesc::encode((JavaThread*) THREAD, mark->age(), prototype_header->bias_epoch()); markOop res_mark = (markOop) Atomic::cmpxchg_ptr(rebiased_prototype, obj->mark_addr(), mark); if (res_mark == biased_value) { return BIAS_REVOKED_AND_REBIASED; } } else { markOop biased_value = mark; markOop unbiased_prototype = markOopDesc::prototype()->set_age(mark->age()); markOop res_mark = (markOop) Atomic::cmpxchg_ptr(unbiased_prototype, obj->mark_addr(), mark); if (res_mark == biased_value) { return BIAS_REVOKED; } } } } HeuristicsResult heuristics = update_heuristics(obj(), attempt_rebias); if (heuristics == HR_NOT_BIASED) { return NOT_BIASED; } else if (heuristics == HR_SINGLE_REVOKE) { Klass *k = obj->klass(); markOop prototype_header = k->prototype_header(); if (mark->biased_locker() == THREAD && prototype_header->bias_epoch() == mark->bias_epoch()) { // A thread is trying to revoke the bias of an object biased // toward it, again likely due to an identity hash code // computation. We can again avoid a safepoint in this case // since we are only going to walk our own stack. There are no // races with revocations occurring in other threads because we // reach no safepoints in the revocation path. // Also check the epoch because even if threads match, another thread // can come in with a CAS to steal the bias of an object that has a // stale epoch. ResourceMark rm; if (TraceBiasedLocking) { tty->print_cr("Revoking bias by walking my own stack:"); } BiasedLocking::Condition cond = revoke_bias(obj(), false, false, (JavaThread*) THREAD); ((JavaThread*) THREAD)->set_cached_monitor_info(NULL); assert(cond == BIAS_REVOKED, "why not?"); return cond; } else { VM_RevokeBias revoke(&obj, (JavaThread*) THREAD); VMThread::execute(&revoke); return revoke.status_code(); } } assert((heuristics == HR_BULK_REVOKE) || (heuristics == HR_BULK_REBIAS), "?"); VM_BulkRevokeBias bulk_revoke(&obj, (JavaThread*) THREAD, (heuristics == HR_BULK_REBIAS), attempt_rebias); VMThread::execute(&bulk_revoke); return bulk_revoke.status_code(); }
bool PDFBooleanDriver::HasInstance(Handle<Value> inObject) { return inObject->IsObject() && constructor_template->HasInstance(inObject->ToObject()); }