static int x_try_array(const char *buf, int buflen, const char *want, int wantlen, int *nwords, char ***words) { const char *cmd, *cp; int cmdlen, n, i, slen; char *name, *s; struct tbl *v, *vp; *nwords = 0; *words = NULL; /* Walk back to find start of command. */ if (want == buf) return 0; for (cmd = want; cmd > buf; cmd--) { if (strchr(";|&()`", cmd[-1]) != NULL) break; } while (cmd < want && isspace((u_char)*cmd)) cmd++; cmdlen = 0; while (cmd + cmdlen < want && !isspace((u_char)cmd[cmdlen])) cmdlen++; for (i = 0; i < cmdlen; i++) { if (!isalnum((u_char)cmd[i]) && cmd[i] != '_') return 0; } /* Take a stab at argument count from here. */ n = 1; for (cp = cmd + cmdlen + 1; cp < want; cp++) { if (!isspace((u_char)cp[-1]) && isspace((u_char)*cp)) n++; } /* Try to find the array. */ if (asprintf(&name, "complete_%.*s_%d", cmdlen, cmd, n) < 0) internal_errorf("unable to allocate memory"); v = global(name); free(name); if (~v->flag & (ISSET|ARRAY)) { if (asprintf(&name, "complete_%.*s", cmdlen, cmd) < 0) internal_errorf("unable to allocate memory"); v = global(name); free(name); if (~v->flag & (ISSET|ARRAY)) return 0; } /* Walk the array and build words list. */ for (vp = v; vp; vp = vp->u.array) { if (~vp->flag & ISSET) continue; s = str_val(vp); slen = strlen(s); if (slen < wantlen) continue; if (slen > wantlen) slen = wantlen; if (slen != 0 && strncmp(s, want, slen) != 0) continue; *words = areallocarray(*words, (*nwords) + 2, sizeof **words, ATEMP); (*words)[(*nwords)++] = str_save(s, ATEMP); } if (*nwords != 0) (*words)[*nwords] = NULL; return *nwords != 0; }
void ConsoleUtils::ReportForServiceWorkerScopeInternal( const nsAString& aScope, const nsAString& aMessage, const nsAString& aFilename, uint32_t aLineNumber, uint32_t aColumnNumber, Level aLevel) { MOZ_ASSERT(NS_IsMainThread()); AutoJSAPI jsapi; jsapi.Init(); JSContext* cx = jsapi.cx(); ConsoleCommon::ClearException ce(cx); JS::Rooted<JSObject*> global(cx, GetOrCreateSandbox(cx)); if (NS_WARN_IF(!global)) { return; } // The GetOrCreateSandbox call returns a proxy to the actual sandbox object. // We don't need a proxy here. global = js::UncheckedUnwrap(global); JSAutoRealm ar(cx, global); RootedDictionary<ConsoleEvent> event(cx); event.mID.Construct(); event.mID.Value().SetAsString() = aScope; event.mInnerID.Construct(); event.mInnerID.Value().SetAsString() = NS_LITERAL_STRING("ServiceWorker"); switch (aLevel) { case eLog: event.mLevel = NS_LITERAL_STRING("log"); break; case eWarning: event.mLevel = NS_LITERAL_STRING("warn"); break; case eError: event.mLevel = NS_LITERAL_STRING("error"); break; } event.mFilename = aFilename; event.mLineNumber = aLineNumber; event.mColumnNumber = aColumnNumber; event.mTimeStamp = JS_Now() / PR_USEC_PER_MSEC; JS::Rooted<JS::Value> messageValue(cx); if (!dom::ToJSValue(cx, aMessage, &messageValue)) { return; } event.mArguments.Construct(); if (!event.mArguments.Value().AppendElement(messageValue, fallible)) { return; } nsCOMPtr<nsIConsoleAPIStorage> storage = do_GetService("@mozilla.org/consoleAPI-storage;1"); if (NS_WARN_IF(!storage)) { return; } JS::Rooted<JS::Value> eventValue(cx); if (!ToJSValue(cx, event, &eventValue)) { return; } // This is a legacy property. JS::Rooted<JSObject*> eventObj(cx, &eventValue.toObject()); if (NS_WARN_IF(!JS_DefineProperty(cx, eventObj, "wrappedJSObject", eventObj, JSPROP_ENUMERATE))) { return; } storage->RecordEvent(NS_LITERAL_STRING("ServiceWorker"), aScope, eventValue); }
static int x_command_glob(int flags, const char *str, int slen, char ***wordsp) { char *toglob; char *pat; char *fpath; int nwords; XPtrV w; struct block *l; if (slen < 0) return 0; toglob = add_glob(str, slen); /* Convert "foo*" (toglob) to a pattern for future use */ pat = evalstr(toglob, DOPAT|DOTILDE); afree(toglob, ATEMP); XPinit(w, 32); glob_table(pat, &w, &keywords); glob_table(pat, &w, &aliases); glob_table(pat, &w, &builtins); for (l = genv->loc; l; l = l->next) glob_table(pat, &w, &l->funs); glob_path(flags, pat, &w, search_path); if ((fpath = str_val(global("FPATH"))) != null) glob_path(flags, pat, &w, fpath); nwords = XPsize(w); if (!nwords) { *wordsp = NULL; XPfree(w); return 0; } /* Sort entries */ if (flags & XCF_FULLPATH) { /* Sort by basename, then path order */ struct path_order_info *info; struct path_order_info *last_info = NULL; char **words = (char **) XPptrv(w); int path_order = 0; int i; info = areallocarray(NULL, nwords, sizeof(struct path_order_info), ATEMP); for (i = 0; i < nwords; i++) { info[i].word = words[i]; info[i].base = x_basename(words[i], NULL); if (!last_info || info[i].base != last_info->base || strncmp(words[i], last_info->word, info[i].base) != 0) { last_info = &info[i]; path_order++; } info[i].path_order = path_order; } qsort(info, nwords, sizeof(struct path_order_info), path_order_cmp); for (i = 0; i < nwords; i++) words[i] = info[i].word; afree(info, ATEMP); } else { /* Sort and remove duplicate entries */ char **words = (char **) XPptrv(w); int i, j; qsortp(XPptrv(w), (size_t) nwords, xstrcmp); for (i = j = 0; i < nwords - 1; i++) { if (strcmp(words[i], words[i + 1])) words[j++] = words[i]; else afree(words[i], ATEMP); } words[j++] = words[i]; nwords = j; w.cur = (void **) &words[j]; } XPput(w, NULL); *wordsp = (char **) XPclose(w); return nwords; }
// SCWSS_Activate XCALL_ (int) SCWSS_Activate( long version, GlobalFunc *global, void *local, void *serverData ) { if ( version != LWMODCOMMAND_VERSION ) return AFUNC_BADVERSION; LWModCommand * command = (LWModCommand *)local; if( command == NULL ) return AFUNC_BADLOCAL; // Setup object_funcs = (LWObjectFuncs *)global( LWOBJECTFUNCS_GLOBAL, GFUSE_TRANSIENT ); vmap_count = object_funcs->numVMaps( LWVMAP_PICK ); // Build a list of selection_set_ids for the selected polygons MeshEditOp *op = (command->editBegin)( 0, 0, OPSEL_DIRECT | OPSEL_MODIFY ); selection_set_ids.Flush(); EDError err = op->pointScan( op->state, SCWSS_PointScan_FindSets, (void *)op, OPLYR_FG ); if( err != EDERR_NONE ) { op->done( op->state, err, 0 ); } else { // If there are multiple selection sets, ask the user which one(s) they want bool do_select = true; if( selection_set_ids.NumElements() > 1 ) { // Get some globals ContextMenuFuncs *context_funcs = (ContextMenuFuncs *)global( LWCONTEXTMENU_GLOBAL, GFUSE_TRANSIENT ); LWPanelFuncs *panel_funcs = (LWPanelFuncs *)global( LWPANELFUNCS_GLOBAL, GFUSE_TRANSIENT ); // Set up te context menu LWPanPopupDesc menu_desc; menu_desc.type = LWT_POPUP; menu_desc.width = 200; menu_desc.countFn = SelSetCount; menu_desc.nameFn = SelSetName; // Set up the panel, open the menu and clean up LWPanelID panel = panel_funcs->create( "Selection Sets", panel_funcs ); LWContextMenuID menu = context_funcs->cmenuCreate( &menu_desc, NULL ); int index = context_funcs->cmenuDeploy( menu, panel, 0 ); context_funcs->cmenuDestroy( menu ); panel_funcs->destroy( panel ); // Limit to a single selection set or abort, if applicable if( index == -1 ) { do_select = false; } else if( index != (int)selection_set_names.NumElements() ) { void *id = selection_set_ids[ index ]; selection_set_ids.Reset(); selection_set_ids.Add( id ); } } if( do_select ) { // Select points belonging to the selected selection sets err = op->pointScan( op->state, SCWSS_PointScan_Select, (void *)op, OPLYR_FG ); op->done( op->state, err, 0 ); } } // Clean up selection_set_ids.Reset(); selection_set_names.Flush(); return CSERR_NONE; }
KPrFactory::KPrFactory( QObject* parent, const char* name ) : KoFactory( parent, name ) { (void)global(); }
int main(int argc, char** argv) { if (argc != 2) { std::cout << "Usage: ./pi_vocl num\n" << "\twhere num = 1, 4 or 8\n"; return EXIT_FAILURE; } int vector_size = atoi(argv[1]); // Define some vector size specific constants unsigned int ITERS, WGS; if (vector_size == 1) { ITERS = 262144; WGS = 8; } else if (vector_size == 4) { ITERS = 262144 / 4; WGS = 32; } else if (vector_size == 8) { ITERS = 262144 / 8; WGS = 64; } else { std::cerr << "Invalid vector size\n"; return EXIT_FAILURE; } // Set some default values: // Default number of steps (updated later to device preferable) unsigned int in_nsteps = INSTEPS; // Default number of iterations unsigned int niters = ITERS; unsigned int work_group_size = WGS; try { // Create context, queue and build program cl::Context context(DEVICE); cl::CommandQueue queue(context); cl::Program program(context, util::loadProgram("../pi_vocl.cl"), true); cl::Kernel kernel; // Now that we know the size of the work_groups, we can set the number of work // groups, the actual number of steps, and the step size unsigned int nwork_groups = in_nsteps/(work_group_size*niters); // Get the max work group size for the kernel pi on our device unsigned int max_size; std::vector<cl::Device> devices = context.getInfo<CL_CONTEXT_DEVICES>(); if (vector_size == 1) { kernel = cl::Kernel(program, "pi"); max_size = kernel.getWorkGroupInfo<CL_KERNEL_WORK_GROUP_SIZE>(devices[0]); } else if (vector_size == 4) { kernel = cl::Kernel(program, "pi_vec4"); max_size = kernel.getWorkGroupInfo<CL_KERNEL_WORK_GROUP_SIZE>(devices[0]); } else if (vector_size == 8) { kernel = cl::Kernel(program, "pi_vec8"); max_size = kernel.getWorkGroupInfo<CL_KERNEL_WORK_GROUP_SIZE>(devices[0]); } if (max_size > work_group_size) { work_group_size = max_size; nwork_groups = in_nsteps/(nwork_groups*niters); } if (nwork_groups < 1) { nwork_groups = devices[0].getInfo<CL_DEVICE_MAX_COMPUTE_UNITS>(); work_group_size = in_nsteps/(nwork_groups*niters); } unsigned int nsteps = work_group_size * niters * nwork_groups; float step_size = 1.0f / (float) nsteps; // Vector to hold partial sum std::vector<float> h_psum(nwork_groups); std::cout << nwork_groups << " work groups of size " << work_group_size << ".\n" << nsteps << " Integration steps\n"; cl::Buffer d_partial_sums(context, CL_MEM_WRITE_ONLY, sizeof(float) * nwork_groups); // Start the timer util::Timer timer; // Execute the kernel over the entire range of our 1d input data et // using the maximum number of work group items for this device cl::NDRange global(nwork_groups * work_group_size); cl::NDRange local(work_group_size); kernel.setArg(0, niters); kernel.setArg(1, step_size); cl::LocalSpaceArg localmem = cl::Local(sizeof(float) * work_group_size); kernel.setArg(2, localmem); kernel.setArg(3, d_partial_sums); queue.enqueueNDRangeKernel(kernel, cl::NullRange, global, local); cl::copy(queue, d_partial_sums, begin(h_psum), end(h_psum)); // Complete the sum and compute the final integral value float pi_res = 0.0; for (float x : h_psum) pi_res += x; pi_res *= step_size; // Stop the timer double rtime = static_cast<double>(timer.getTimeMilliseconds()) / 1000.; std::cout << "The calculation ran in " << rtime << " seconds\n" << " pi = " << pi_res << " for " << nsteps << " steps\n"; return EXIT_SUCCESS; } catch (cl::Error err) { std::cerr << "ERROR: " << err.what() << ":\n"; err_code(err.err()); return EXIT_FAILURE; } }
void SimpleFluid::testVelocityField(){ //Setup a quad to draw too GL::VertexArray vao; vao.elementBuffer(quadElems); GL::VertexBuffer vbo(quad, GL::USAGE::STATIC_DRAW); //Setup program GL::Program prog("../res/shader.v.glsl", "../res/shader.f.glsl"); //Setup the attributes vao.setAttribPointer(vbo, prog.getAttribute("position"), 3, GL_FLOAT, GL_FALSE); vao.setAttribPointer(vbo, prog.getAttribute("texIn"), 3, GL_FLOAT, GL_FALSE, 0, (void*)(sizeof(glm::vec3) * 4)); glm::mat4 view = glm::lookAt<float>(glm::vec3(0, 0, 1), glm::vec3(0, 0, -1), glm::vec3(0, 1, 0)); //I suppose later I should pass in the window w/h for setting this properly glm::mat4 proj = glm::perspective(60.0f, static_cast<float>(window.box().w) / static_cast<float>(window.box().h), 0.1f, 100.0f); glm::mat4 model = glm::scale(0.35f, 0.35f, 1.0f); glm::mat4 mvp = proj * view * model; prog.uniformMat4x4("mvp", mvp); //Make textures to work with GL::Texture fieldA("../res/simplefluid/fluid32.png", true, SOIL_FLAG_INVERT_Y); GL::Texture fieldB("../res/simplefluid/fluid32.png", true, SOIL_FLAG_INVERT_Y); GL::Texture velocity("../res/simplefluid/right_velocity_32.png", true, SOIL_FLAG_INVERT_Y); //Output is the advection output texture, which will flip each run GL::Texture output = fieldB; //Setup our OpenCL data #ifdef CL_VERSION_1_2 cl::ImageGL imgA = tiny.imageFromTexture(CL::MEM::READ_WRITE, fieldA); cl::ImageGL imgB = tiny.imageFromTexture(CL::MEM::READ_WRITE, fieldB); cl::ImageGL imgVel = tiny.imageFromTexture(CL::MEM::READ_ONLY, velocity); #else cl::Image2DGL imgA = tiny.imageFromTexture(CL::MEM::READ_WRITE, fieldA); cl::Image2DGL imgB = tiny.imageFromTexture(CL::MEM::READ_WRITE, fieldB); cl::Image2DGL imgVel = tiny.imageFromTexture(CL::MEM::READ_ONLY, velocity); #endif std::vector<cl::Memory> glObjs; glObjs.push_back(imgA); glObjs.push_back(imgB); glObjs.push_back(imgVel); cl::Program advectProgram = tiny.loadProgram("../res/simplefluid/advectImageField.cl"); cl::Kernel advect = tiny.loadKernel(advectProgram, "advectImageField"); //We'll pick an arbitray time step for now advect.setArg(0, 1.f / 30.f); advect.setArg(1, imgVel); advect.setArg(2, imgA); advect.setArg(3, imgB); int workSize = tiny.preferredWorkSize(advect); cl::NDRange local(workSize, workSize); cl::NDRange global(dim, dim); //We use the run number to decide which field image should be input and which should be output //on even runs A is in, B is out and odd runs we flip int run = 0; Input::Init(); while (!Input::Quit()){ Input::PollEvents(); if (Input::KeyDown(SDL_SCANCODE_ESCAPE)) Input::Quit(true); //Advect the field if (run % 2 == 0 || run == 0){ advect.setArg(2, imgA); advect.setArg(3, imgB); output = fieldB; } else { advect.setArg(2, imgB); advect.setArg(3, imgA); output = fieldA; } glFinish(); tiny.mQueue.enqueueAcquireGLObjects(&glObjs); tiny.runKernel(advect, local, global); tiny.mQueue.enqueueReleaseGLObjects(&glObjs); tiny.mQueue.finish(); ++run; //RENDERING window.clear(); prog.use(); glBindVertexArray(vao); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, output); glDrawElements(GL_TRIANGLES, vao.numElements(), GL_UNSIGNED_SHORT, NULL); window.present(); } }
int main(int argc, char * argv[]) { unsigned int clPlatform = 0; unsigned int clDevice = 0; unsigned int iterations = 0; unsigned int N = 0; unsigned int threadUnit = 0; unsigned int maxThreads = 0; isa::utils::ArgumentList args(argc, argv); try { clPlatform = args.getSwitchArgument< unsigned int >("-opencl_platform"); clDevice = args.getSwitchArgument< unsigned int >("-opencl_device"); iterations = args.getSwitchArgument< unsigned int >("-iterations"); N = args.getSwitchArgument< unsigned int >("-N"); threadUnit = args.getSwitchArgument< unsigned int >("-thread_unit"); maxThreads = args.getSwitchArgument< unsigned int >("-max_threads"); } catch ( isa::utils::EmptyCommandLine & err ) { std::cerr << args.getName() << " -opencl_platform ... -opencl_device ... -iterations ... -N ... -thread_unit ... -max_threads ..." << std::endl; return 1; } catch ( std::exception & err ) { std::cerr << err.what() << std::endl; return 1; } // Initialize OpenCL cl::Context * clContext = new cl::Context(); std::vector< cl::Platform > * clPlatforms = new std::vector< cl::Platform >(); std::vector< cl::Device > * clDevices = new std::vector< cl::Device >(); std::vector< std::vector< cl::CommandQueue > > * clQueues = new std::vector< std::vector < cl::CommandQueue > >(); isa::OpenCL::initializeOpenCL(clPlatform, 1, clPlatforms, clContext, clDevices, clQueues); // Allocate memory std::vector< dataType > A(N); cl::Buffer A_d, B_d, C_d; try { A_d = cl::Buffer(*clContext, CL_MEM_READ_ONLY, A.size() * sizeof(dataType), 0, 0); C_d = cl::Buffer(*clContext, CL_MEM_WRITE_ONLY, A.size() * sizeof(dataType), 0, 0); } catch ( cl::Error & err ) { std::cerr << "OpenCL error allocating memory: " << isa::utils::toString(err.err()) << "." << std::endl; } std::srand(std::time(0)); for ( unsigned int n = 0; n < N; n++ ) { A[n] = static_cast< dataType >(std::rand() % 100); } // Copy data structures to device try { clQueues->at(clDevice)[0].enqueueWriteBuffer(A_d, CL_FALSE, 0, A.size() * sizeof(dataType), reinterpret_cast< void * >(A.data()), 0, 0); } catch ( cl::Error & err ) { std::cerr << "OpenCL error H2D transfer: " << isa::utils::toString(err.err()) << "." << std::endl; return 1; } for ( unsigned int threads = threadUnit; threads <= maxThreads; threads += threadUnit ) { if ( (N % threads) != 0 ) { continue; } for ( unsigned int vector = 1; vector <= 16; vector *= 2 ) { if ( (N % (threads * vector)) != 0 ) { continue; } cl::Kernel * kernel; isa::utils::Timer kernelTimer("Kernel Timer"); isa::utils::Stats< double > kernelStats; std::string * code = isa::Benchmarks::getBandwidthOpenCL(vector, typeName); try { kernel = isa::OpenCL::compile("bandwidth", *code, "-cl-mad-enable -Werror", *clContext, clDevices->at(clDevice)); } catch ( isa::OpenCL::OpenCLError & err ) { std::cerr << err.what() << std::endl; return 1; } try { double gbs = isa::utils::giga(static_cast< long long unsigned int >(N) * 2 * sizeof(dataType)); cl::Event kernelSync; cl::NDRange global(N / vector); cl::NDRange local(threads); kernel->setArg(0, A_d); kernel->setArg(1, C_d); // Warm-up clQueues->at(clDevice)[0].enqueueNDRangeKernel(*kernel, cl::NullRange, global, local, 0, &kernelSync); kernelSync.wait(); for ( unsigned int iteration = 0; iteration < iterations; iteration++ ) { kernelTimer.start(); clQueues->at(clDevice)[0].enqueueNDRangeKernel(*kernel, cl::NullRange, global, local, 0, &kernelSync); kernelSync.wait(); kernelTimer.stop(); kernelStats.addElement(gbs / kernelTimer.getLastRunTime()); } } catch ( cl::Error & err ) { std::cerr << "OpenCL error kernel execution: " << isa::utils::toString(err.err()) << "." << std::endl; } std::cout << std::fixed; std::cout << threads << " " << vector << " "; std::cout << std::setprecision(3); std::cout << kernelStats.getAverage() << " " << kernelStats.getStdDev() << " "; std::cout << std::setprecision(6); std::cout << kernelTimer.getAverageTime() << " " << kernelTimer.getStdDev(); std::cout << std::endl; } } return 0; }
/* * lookup variable (according to (set&LOCAL)), set its attributes * (INTEGER, RDONLY, EXPORT, TRACE, LJUST, RJUST, ZEROFIL, LCASEV, * UCASEV_AL), and optionally set its value if an assignment. */ struct tbl * typeset(const char *var, uint32_t set, uint32_t clr, int field, int base) { struct tbl *vp; struct tbl *vpbase, *t; char *tvar; const char *val; size_t len; bool vappend = false; /* check for valid variable name, search for value */ val = skip_varname(var, false); if (*val == '[') { if (set_refflag != SRF_NOP) errorf("%s: %s", var, "reference variable can't be an array"); len = array_ref_len(val); if (len == 0) return (NULL); /* * IMPORT is only used when the shell starts up and is * setting up its environment. Allow only simple array * references at this time since parameter/command * substitution is performed on the [expression] which * would be a major security hole. */ if (set & IMPORT) { size_t i; for (i = 1; i < len - 1; i++) if (!ksh_isdigit(val[i])) return (NULL); } val += len; } if (val[0] == '=' || (val[0] == '+' && val[1] == '=')) { strndupx(tvar, var, val - var, ATEMP); if (*val++ == '+') { ++val; vappend = true; } } else if ((val[0] != '\0') || (set & IMPORT)) { /* * must have a = when setting a variable by importing * the original environment, otherwise be empty; we * also end up here when a variable name was invalid * or none given */ return (NULL); } else { /* just varname with no value part nor equals sign */ strdupx(tvar, var, ATEMP); val = NULL; /* handle foo[*] => foo (whole array) mapping for R39b */ len = strlen(tvar); if (len > 3 && tvar[len - 3] == '[' && tvar[len - 2] == '*' && tvar[len - 1] == ']') tvar[len - 3] = '\0'; } if (set_refflag == SRF_ENABLE) { const char *qval; /* bail out on 'nameref foo+=bar' */ if (vappend) errorfz(); /* find value if variable already exists */ if ((qval = val) == NULL) { varsearch(e->loc, &vp, tvar, hash(tvar)); if (vp != NULL) qval = str_val(vp); } /* silently ignore 'nameref foo=foo' */ if (qval != NULL && !strcmp(qval, tvar)) { afree(tvar, ATEMP); return (&vtemp); } } /* prevent typeset from creating a local PATH/ENV/SHELL */ if (Flag(FRESTRICTED) && (strcmp(tvar, "PATH") == 0 || strcmp(tvar, "ENV") == 0 || strcmp(tvar, "SHELL") == 0)) errorf("%s: %s", tvar, "restricted"); vp = (set&LOCAL) ? local(tvar, tobool(set & LOCAL_COPY)) : global(tvar); if (set_refflag == SRF_DISABLE && (vp->flag & (ARRAY|ASSOC)) == ASSOC) vp->flag &= ~ASSOC; else if (set_refflag == SRF_ENABLE) { if (vp->flag & ARRAY) { struct tbl *a, *tmp; /* free up entire array */ for (a = vp->u.array; a; ) { tmp = a; a = a->u.array; if (tmp->flag & ALLOC) afree(tmp->val.s, tmp->areap); afree(tmp, tmp->areap); } vp->u.array = NULL; vp->flag &= ~ARRAY; } vp->flag |= ASSOC; } set &= ~(LOCAL|LOCAL_COPY); vpbase = (vp->flag & ARRAY) ? global(arrayname(var)) : vp; /* * only allow export flag to be set; AT&T ksh allows any * attribute to be changed which means it can be truncated or * modified (-L/-R/-Z/-i) */ if ((vpbase->flag&RDONLY) && (val || clr || (set & ~EXPORT))) /* XXX check calls - is error here ok by POSIX? */ errorfx(2, "read-only: %s", tvar); afree(tvar, ATEMP); /* most calls are with set/clr == 0 */ if (set | clr) { bool ok = true; /* * XXX if x[0] isn't set, there will be problems: need * to have one copy of attributes for arrays... */ for (t = vpbase; t; t = t->u.array) { bool fake_assign; char *s = NULL; char *free_me = NULL; fake_assign = (t->flag & ISSET) && (!val || t != vp) && ((set & (UCASEV_AL|LCASEV|LJUST|RJUST|ZEROFIL)) || ((t->flag & INTEGER) && (clr & INTEGER)) || (!(t->flag & INTEGER) && (set & INTEGER))); if (fake_assign) { if (t->flag & INTEGER) { s = str_val(t); free_me = NULL; } else { s = t->val.s + t->type; free_me = (t->flag & ALLOC) ? t->val.s : NULL; } t->flag &= ~ALLOC; } if (!(t->flag & INTEGER) && (set & INTEGER)) { t->type = 0; t->flag &= ~ALLOC; } t->flag = (t->flag | set) & ~clr; /* * Don't change base if assignment is to be * done, in case assignment fails. */ if ((set & INTEGER) && base > 0 && (!val || t != vp)) t->type = base; if (set & (LJUST|RJUST|ZEROFIL)) t->u2.field = field; if (fake_assign) { if (!setstr(t, s, KSH_RETURN_ERROR)) { /* * Somewhat arbitrary action * here: zap contents of * variable, but keep the flag * settings. */ ok = false; if (t->flag & INTEGER) t->flag &= ~ISSET; else { if (t->flag & ALLOC) afree(t->val.s, t->areap); t->flag &= ~(ISSET|ALLOC); t->type = 0; } } if (free_me) afree(free_me, t->areap); } } if (!ok) errorfz(); } if (val != NULL) { char *tval; if (vappend) { tval = shf_smprintf("%s%s", str_val(vp), val); val = tval; } else tval = NULL; if (vp->flag&INTEGER) { /* do not zero base before assignment */ setstr(vp, val, KSH_UNWIND_ERROR | 0x4); /* done after assignment to override default */ if (base > 0) vp->type = base; } else /* setstr can't fail (readonly check already done) */ setstr(vp, val, KSH_RETURN_ERROR | 0x4); if (tval != NULL) afree(tval, ATEMP); } /* only x[0] is ever exported, so use vpbase */ if ((vpbase->flag&EXPORT) && !(vpbase->flag&INTEGER) && vpbase->type == 0) exportprep(vpbase, (vpbase->flag&ISSET) ? vpbase->val.s : null); return (vp); }
void watershed(int width, int height, cl::Buffer& src, cl::Buffer& labeled, ProgramCache& cache, cl::CommandQueue& queue) { #ifdef OPENCL_PROFILE watershed_descent_kernel_time = 0; watershed_increment_kernel_time = 0; watershed_minima_kernel_time = 0; watershed_plateau_kernel_time = 0; watershed_flood_kernel_time = 0; #endif cl::Context context = queue.getInfo<CL_QUEUE_CONTEXT>(); std::stringstream params_stream; params_stream << "-DBLOCK_SIZE="; params_stream << BLOCK_SIZE; std::string program_params = params_stream.str(); cl::Program& program = cache.getProgram("Watershed", program_params); cl::Kernel descent_kernel(program, "descent_kernel"); cl::Kernel increment_kernel(program, "increment_kernel"); cl::Kernel minima_kernel(program, "minima_kernel"); cl::Kernel plateau_kernel(program, "plateau_kernel"); cl::Kernel flood_kernel(program, "flood_kernel"); //setting constant memory with neigbourhood cl::Buffer cl_neighbourhood_x = cl::Buffer(context,CL_MEM_READ_ONLY, sizeof(neighbourhood_x)); cl::Buffer cl_neighbourhood_y = cl::Buffer(context, CL_MEM_READ_ONLY, sizeof(neighbourhood_y)); #ifdef OPENCL_PROFILE cl::Event first_event; queue.enqueueWriteBuffer(cl_neighbourhood_x, CL_TRUE, 0, sizeof(neighbourhood_x), neighbourhood_x, __null, &first_event); #else queue.enqueueWriteBuffer(cl_neighbourhood_x, CL_TRUE, 0, sizeof(neighbourhood_x), neighbourhood_x); #endif queue.enqueueWriteBuffer(cl_neighbourhood_y, CL_TRUE, 0, sizeof(neighbourhood_y), neighbourhood_y); //const size_t block_size = 6; //cl::LocalSpaceArg local_mem = cl::__local(block_size * block_size * sizeof(float)); cl::LocalSpaceArg local_mem = cl::__local(BLOCK_SIZE * BLOCK_SIZE * sizeof(float)); //setting args for descent_kernel descent_kernel.setArg(0, src); descent_kernel.setArg(1, labeled); descent_kernel.setArg(2, cl_neighbourhood_x); descent_kernel.setArg(3, cl_neighbourhood_y); descent_kernel.setArg(4, local_mem); descent_kernel.setArg(5, width); descent_kernel.setArg(6, height); size_t global_width = (width / (BLOCK_SIZE - 2) + 1) * BLOCK_SIZE; size_t global_height = (height / (BLOCK_SIZE - 2) + 1) * BLOCK_SIZE; #ifdef DEBUG_PRINT std::cout << "global width=" << global_width << " global height=" << global_height << std::endl; #endif cl::NDRange global(global_width, global_height); cl::NDRange local(BLOCK_SIZE, BLOCK_SIZE); cl_int status; #ifdef OPENCL_PROFILE { VECTOR_CLASS<cl::Event> events_vector(1); status = queue.enqueueNDRangeKernel(descent_kernel, cl::NullRange, global, local, __null, &events_vector[0]); cl::WaitForEvents(events_vector); cl::Event& event = events_vector[0]; cl_ulong start = event.getProfilingInfo<CL_PROFILING_COMMAND_START>(); cl_ulong end = event.getProfilingInfo<CL_PROFILING_COMMAND_END>(); cl_ulong total_time = end - start; watershed_descent_kernel_time = total_time; } #else status = queue.enqueueNDRangeKernel(descent_kernel, cl::NullRange, global, local); #endif #ifdef DEBUG_PRINT std::cout << "kernel execution " << status << std::endl; #endif // queue.flush(); // queue.enqueueBarrier(); /* PREPARING INCREMENT KERNEL */ increment_kernel.setArg(0, labeled); increment_kernel.setArg(1, width); increment_kernel.setArg(2, height); #ifdef OPENCL_PROFILE { VECTOR_CLASS<cl::Event> events_vector(1); status = queue.enqueueNDRangeKernel(increment_kernel, cl::NullRange, global, local, __null, &events_vector[0]); cl::WaitForEvents(events_vector); cl::Event& event = events_vector[0]; cl_ulong start = event.getProfilingInfo<CL_PROFILING_COMMAND_START>(); cl_ulong end = event.getProfilingInfo<CL_PROFILING_COMMAND_END>(); cl_ulong total_time = end - start; watershed_increment_kernel_time = total_time; } #else status = queue.enqueueNDRangeKernel(increment_kernel, cl::NullRange, global, local); #endif // queue.enqueueBarrier(); /* PREPARING MINIMA KERNEL */ int counter_tmp = 0; cl::Buffer counter(context, CL_MEM_READ_WRITE, sizeof(int)); queue.enqueueWriteBuffer(counter, CL_TRUE, 0, sizeof(int), &counter_tmp); queue.enqueueBarrier(); minima_kernel.setArg(0, counter); minima_kernel.setArg(1, labeled); minima_kernel.setArg(2, cl_neighbourhood_x); minima_kernel.setArg(3, cl_neighbourhood_y); minima_kernel.setArg(4, local_mem); minima_kernel.setArg(5, width); minima_kernel.setArg(6, height); int old_val = -1; int new_val = -2; int c = 0; while(old_val != new_val) { old_val = new_val; #ifdef OPENCL_PROFILE { VECTOR_CLASS<cl::Event> events_vector(1); status = queue.enqueueNDRangeKernel(minima_kernel, cl::NullRange, global, local, __null, &events_vector[0]); cl::WaitForEvents(events_vector); cl::Event& event = events_vector[0]; cl_ulong start = event.getProfilingInfo<CL_PROFILING_COMMAND_START>(); cl_ulong end = event.getProfilingInfo<CL_PROFILING_COMMAND_END>(); cl_ulong total_time = end - start; watershed_minima_kernel_time += total_time; } #else status = queue.enqueueNDRangeKernel(minima_kernel, cl::NullRange, global, local); #endif queue.enqueueReadBuffer(counter, CL_TRUE, 0, sizeof(int), &new_val); c++; } #ifdef DEBUG_PRINT std::cout << "step 2: " << c << " iterations" << std::endl; #endif /* PREPARING PLATEAU KERNEL */ queue.enqueueWriteBuffer(counter, CL_TRUE, 0, sizeof(int), &counter_tmp); queue.enqueueBarrier(); plateau_kernel.setArg(0, counter); plateau_kernel.setArg(1, src); plateau_kernel.setArg(2, labeled); plateau_kernel.setArg(3, cl_neighbourhood_x); plateau_kernel.setArg(4, cl_neighbourhood_y); plateau_kernel.setArg(5, local_mem); plateau_kernel.setArg(6, width); plateau_kernel.setArg(7, height); old_val = -1; new_val = -2; c = 0; #ifdef OPENCL_PROFILE watershed_plateau_kernel_time = 0; #endif while(old_val != new_val) { old_val = new_val; #ifdef OPENCL_PROFILE { VECTOR_CLASS<cl::Event> events_vector(1); status = queue.enqueueNDRangeKernel(plateau_kernel, cl::NullRange, global, local, __null, &events_vector[0]); cl::WaitForEvents(events_vector); cl::Event& event = events_vector[0]; cl_ulong start = event.getProfilingInfo<CL_PROFILING_COMMAND_START>(); cl_ulong end = event.getProfilingInfo<CL_PROFILING_COMMAND_END>(); cl_ulong total_time = end - start; watershed_plateau_kernel_time += total_time; } #else status = queue.enqueueNDRangeKernel(plateau_kernel, cl::NullRange, global, local); #endif queue.enqueueReadBuffer(counter, CL_TRUE, 0, sizeof(int), &new_val); c++; } #ifdef DEBUG_PRINT std::cout << "step 3: " << c << " iterations" << std::endl; #endif //preparing flood kernel queue.enqueueWriteBuffer(counter, CL_TRUE, 0, sizeof(int), &counter_tmp); queue.enqueueBarrier(); flood_kernel.setArg(0, counter); flood_kernel.setArg(1, labeled); flood_kernel.setArg(2, width); flood_kernel.setArg(3, height); old_val = -1; new_val = -2; c = 0; int new_block_size = 16; local = cl::NDRange(new_block_size, new_block_size); int n_width = ((width - 1) / new_block_size + 2) * new_block_size; int n_height = ((height - 1) / new_block_size + 2) * new_block_size; global = cl::NDRange(n_width, n_height); #ifdef DEBUG_PRINT std::cout << "flood kernel invocation params:" << std::endl; std::cout << "local: " << local[0] << ", " << local[1] << std::endl; std::cout << "global: " << global[0] << ", " << global[1] << std::endl; #endif #ifdef OPENCL_PROFILE cl::Event last_event; #endif #ifdef OPENCL_PROFILE watershed_flood_kernel_time = 0; #endif while(old_val != new_val) { old_val = new_val; #ifdef OPENCL_PROFILE { VECTOR_CLASS<cl::Event> events_vector(1); status = queue.enqueueNDRangeKernel(flood_kernel, cl::NullRange, global, local, __null, &events_vector[0]); cl::WaitForEvents(events_vector); cl::Event& event = events_vector[0]; cl_ulong start = event.getProfilingInfo<CL_PROFILING_COMMAND_START>(); cl_ulong end = event.getProfilingInfo<CL_PROFILING_COMMAND_END>(); cl_ulong total_time = end - start; watershed_flood_kernel_time += total_time; } #else status = queue.enqueueNDRangeKernel(flood_kernel, cl::NullRange, global, local); #endif #ifdef OPENCL_PROFILE queue.enqueueReadBuffer(counter, CL_TRUE, 0, sizeof(int), &new_val, __null, &last_event); #else queue.enqueueReadBuffer(counter, CL_TRUE, 0, sizeof(int), &new_val); #endif c++; } #ifdef OPENCL_PROFILE watershed_descent_kernel_time /= TIME_DIVISOR; watershed_increment_kernel_time /= TIME_DIVISOR; watershed_minima_kernel_time /= TIME_DIVISOR; watershed_plateau_kernel_time /= TIME_DIVISOR; watershed_flood_kernel_time /= TIME_DIVISOR; #endif #ifdef DEBUG_PRINT std::cout << "step 4: " << c << " iterations" << std::endl; #endif #ifdef OPENCL_PROFILE last_event.wait(); cl_ulong start = first_event.getProfilingInfo<CL_PROFILING_COMMAND_START>(); cl_ulong end = last_event.getProfilingInfo<CL_PROFILING_COMMAND_END>(); cl_ulong total_time = end - start; setLastExecutionTime(total_time/TIME_DIVISOR); #endif }
bool WindowNamedPropertiesHandler::getOwnPropDescriptor(JSContext* aCx, JS::Handle<JSObject*> aProxy, JS::Handle<jsid> aId, bool /* unused */, JS::MutableHandle<JSPropertyDescriptor> aDesc) const { if (!JSID_IS_STRING(aId)) { // Nothing to do if we're resolving a non-string property. return true; } bool hasOnPrototype; if (!HasPropertyOnPrototype(aCx, aProxy, aId, &hasOnPrototype)) { return false; } if (hasOnPrototype) { return true; } nsAutoJSString str; if (!str.init(aCx, JSID_TO_STRING(aId))) { return false; } // Grab the DOM window. JS::Rooted<JSObject*> global(aCx, JS_GetGlobalForObject(aCx, aProxy)); nsGlobalWindow* win = xpc::WindowOrNull(global); if (win->Length() > 0) { nsCOMPtr<nsIDOMWindow> childWin = win->GetChildWindow(str); if (childWin && ShouldExposeChildWindow(str, childWin)) { // We found a subframe of the right name. Shadowing via |var foo| in // global scope is still allowed, since |var| only looks up |own| // properties. But unqualified shadowing will fail, per-spec. JS::Rooted<JS::Value> v(aCx); if (!WrapObject(aCx, childWin, &v)) { return false; } FillPropertyDescriptor(aDesc, aProxy, 0, v); return true; } } // The rest of this function is for HTML documents only. nsCOMPtr<nsIHTMLDocument> htmlDoc = do_QueryInterface(win->GetExtantDoc()); if (!htmlDoc) { return true; } nsHTMLDocument* document = static_cast<nsHTMLDocument*>(htmlDoc.get()); Element* element = document->GetElementById(str); if (element) { JS::Rooted<JS::Value> v(aCx); if (!WrapObject(aCx, element, &v)) { return false; } FillPropertyDescriptor(aDesc, aProxy, 0, v); return true; } nsWrapperCache* cache; nsISupports* result = document->ResolveName(str, &cache); if (!result) { return true; } JS::Rooted<JS::Value> v(aCx); if (!WrapObject(aCx, result, cache, nullptr, &v)) { return false; } FillPropertyDescriptor(aDesc, aProxy, 0, v); return true; }
KFormulaPartFactory::KFormulaPartFactory( QObject* parent ) : KPluginFactory( *aboutData(), parent ) { // Create our instance, it becomes KGlobal::instance if the main app is KFormula (void)global(); }
int c_read(char **wp) { int c = 0; int expand = 1, history = 0; int expanding; int ecode = 0; char *cp; int fd = 0; struct shf *shf; int optc; const char *emsg; XString cs, xs; struct tbl *vp; char *xp = NULL; while ((optc = ksh_getopt(wp, &builtin_opt, "prsu,")) != -1) switch (optc) { case 'p': if ((fd = coproc_getfd(R_OK, &emsg)) < 0) { bi_errorf("-p: %s", emsg); return 1; } break; case 'r': expand = 0; break; case 's': history = 1; break; case 'u': if (!*(cp = builtin_opt.optarg)) fd = 0; else if ((fd = check_fd(cp, R_OK, &emsg)) < 0) { bi_errorf("-u: %s: %s", cp, emsg); return 1; } break; case '?': return 1; } wp += builtin_opt.optind; if (*wp == NULL) *--wp = "REPLY"; /* Since we can't necessarily seek backwards on non-regular files, * don't buffer them so we can't read too much. */ shf = shf_reopen(fd, SHF_RD | SHF_INTERRUPT | can_seek(fd), shl_spare); if ((cp = strchr(*wp, '?')) != NULL) { *cp = 0; if (isatty(fd)) { /* at&t ksh says it prints prompt on fd if it's open * for writing and is a tty, but it doesn't do it * (it also doesn't check the interactive flag, * as is indicated in the Kornshell book). */ shellf("%s", cp+1); } } /* If we are reading from the co-process for the first time, * make sure the other side of the pipe is closed first. This allows * the detection of eof. * * This is not compatible with at&t ksh... the fd is kept so another * coproc can be started with same output, however, this means eof * can't be detected... This is why it is closed here. * If this call is removed, remove the eof check below, too. * coproc_readw_close(fd); */ if (history) Xinit(xs, xp, 128, ATEMP); expanding = 0; Xinit(cs, cp, 128, ATEMP); for (; *wp != NULL; wp++) { for (cp = Xstring(cs, cp); ; ) { if (c == '\n' || c == EOF) break; while (1) { c = shf_getc(shf); if (c == '\0') continue; if (c == EOF && shf_error(shf) && shf_errno(shf) == EINTR) { /* Was the offending signal one that * would normally kill a process? * If so, pretend the read was killed. */ ecode = fatal_trap_check(); /* non fatal (eg, CHLD), carry on */ if (!ecode) { shf_clearerr(shf); continue; } } break; } if (history) { Xcheck(xs, xp); Xput(xs, xp, c); } Xcheck(cs, cp); if (expanding) { expanding = 0; if (c == '\n') { c = 0; if (Flag(FTALKING_I) && isatty(fd)) { /* set prompt in case this is * called from .profile or $ENV */ set_prompt(PS2, NULL); pprompt(prompt, 0); } } else if (c != EOF) Xput(cs, cp, c); continue; } if (expand && c == '\\') { expanding = 1; continue; } if (c == '\n' || c == EOF) break; if (ctype(c, C_IFS)) { if (Xlength(cs, cp) == 0 && ctype(c, C_IFSWS)) continue; if (wp[1]) break; } Xput(cs, cp, c); } /* strip trailing IFS white space from last variable */ if (!wp[1]) while (Xlength(cs, cp) && ctype(cp[-1], C_IFS) && ctype(cp[-1], C_IFSWS)) cp--; Xput(cs, cp, '\0'); vp = global(*wp); /* Must be done before setting export. */ if (vp->flag & RDONLY) { shf_flush(shf); bi_errorf("%s is read only", *wp); return 1; } if (Flag(FEXPORT)) typeset(*wp, EXPORT, 0, 0, 0); if (!setstr(vp, Xstring(cs, cp), KSH_RETURN_ERROR)) { shf_flush(shf); return 1; } } shf_flush(shf); if (history) { Xput(xs, xp, '\0'); source->line++; histsave(source->line, Xstring(xs, xp), 1); Xfree(xs, xp); } /* if this is the co-process fd, close the file descriptor * (can get eof if and only if all processes are have died, ie, * coproc.njobs is 0 and the pipe is closed). */ if (c == EOF && !ecode) coproc_read_close(fd); return ecode ? ecode : c == EOF; }
void QuickInterpreter::init() { debuggerEngine()->clear(); staticGlobals.clear(); staticGlobals << QString::fromLatin1("NaN") << QString::fromLatin1("undefined") << QString::fromLatin1("Infinity") << QString::fromLatin1("Application"); // add some common objects to the Global object QSObject global( env()->globalObject() ); QSClass *objClass = env()->objectClass(); wrpClass = new QSWrapperClass( objClass ); ptrClass = new QSPointerClass( objClass ); varClass = new QSVariantClass( objClass ); appClass = new QSApplicationClass( objClass ); global.put( QString::fromLatin1("Application"), appClass->createWritable() ); pntClass = new QSPointClass( objClass, this ); registerType( pntClass ); sizClass = new QSSizeClass( objClass, this ); registerType( sizClass ); rctClass = new QSRectClass( objClass, this ); registerType( rctClass ); colClass = new QSColorClass( objClass ); registerType( colClass ); fntClass = new QSFontClass( objClass ); registerType( fntClass ); baClass = new QSByteArrayClass( objClass ); registerType( baClass ); pixClass = new QSPixmapClass( objClass, this ); registerType( pixClass ); palClass = new QSPaletteClass(objClass); registerType(palClass); colGrpClass = new QSColorGroupClass(objClass); registerType(colGrpClass); enableDebug(); // adds "debug" function which uses qDebug() env()->globalClass()->addMember( QString::fromLatin1("connect"), QSMember( qsConnect ) ); env()->globalClass()->addMember( QString::fromLatin1("disconnect"), QSMember( qsDisconnect ) ); env()->globalClass()->addMember( QString::fromLatin1("startTimer"), QSMember( qsStartTimer ) ); env()->globalClass()->addMember( QString::fromLatin1("killTimer"), QSMember( qsKillTimer ) ); env()->globalClass()->addMember( QString::fromLatin1("killTimers"), QSMember( qsKillTimers ) ); QMap<QString,QObject*> statDescr = factory->staticDescriptors(); QMap<QString,QString> instDescr = factory->instanceDescriptors(); QValueList<QString> features = instDescr.keys(); for ( QValueList<QString>::ConstIterator it = features.begin(); it != features.end(); ++it ) { if (env()->globalClass()->definedMembers()->contains(*it)) { qWarning("QSObjectFactory: Trying to register existing class: '%s'", (*it).latin1()); continue; } QSObject staticInst; if( statDescr.contains( *it ) ) { // has static? QObject *sinst = statDescr[ *it ]; Q_ASSERT( sinst ); staticInst = wrap( sinst ); statDescr.remove( *it ); } QSObjectConstructor *constr = new QSObjectConstructor( objClass, *it ); QSFactoryObjectProxy *ptype = new QSFactoryObjectProxy( env()->typeClass(), staticInst, constr ); constr->setFactoryObjectProxy(ptype); QSObject proxy( ptype, env()->typeClass()->createTypeShared(constr) ); env()->globalClass()->addStaticVariableMember( constr->identifier(), proxy, AttributeExecutable ); } for( QMap<QString,QObject*>::ConstIterator sit = statDescr.begin(); sit != statDescr.end(); ++sit ) { if (env()->globalClass()->definedMembers()->contains(sit.key())) { qWarning("QSObjectFactory: Trying to register existing class: '%s'", sit.key().latin1()); continue; } QSObject staticInst; QObject *sinst = statDescr[ sit.key() ]; Q_ASSERT( sinst ); staticInst = wrap( sinst ); env()->globalClass()->addStaticVariableMember( sit.key(), staticInst, AttributeNone ); } }
// fetch references to things defined in boot.j void jl_get_builtin_hooks(void) { jl_nothing = global("nothing"); jl_root_task->tls = jl_nothing; jl_char_type = (jl_bits_type_t*)global("Char"); jl_int8_type = (jl_bits_type_t*)global("Int8"); jl_uint8_type = (jl_bits_type_t*)global("Uint8"); jl_int16_type = (jl_bits_type_t*)global("Int16"); jl_uint16_type = (jl_bits_type_t*)global("Uint16"); jl_uint32_type = (jl_bits_type_t*)global("Uint32"); jl_uint64_type = (jl_bits_type_t*)global("Uint64"); jl_float32_type = (jl_bits_type_t*)global("Float32"); jl_float64_type = (jl_bits_type_t*)global("Float64"); jl_weakref_type = (jl_struct_type_t*)global("WeakRef"); jl_weakref_type->fptr = jl_weakref_ctor; jl_weakref_type->env = NULL; jl_weakref_type->linfo = NULL; jl_string_type = (jl_tag_type_t*)global("String"); jl_ascii_string_type = (jl_struct_type_t*)global("ASCIIString"); jl_utf8_string_type = (jl_struct_type_t*)global("UTF8String"); jl_errorexception_type = (jl_struct_type_t*)global("ErrorException"); jl_typeerror_type = (jl_struct_type_t*)global("TypeError"); jl_loaderror_type = (jl_struct_type_t*)global("LoadError"); jl_uniontoocomplex_type = (jl_struct_type_t*)global("UnionTooComplexError"); jl_backtrace_type = (jl_struct_type_t*)global("BackTrace"); jl_symbolnode_type = (jl_struct_type_t*)global("SymbolNode"); jl_stackovf_exception = jl_apply((jl_function_t*)global("StackOverflowError"), NULL, 0); jl_divbyzero_exception = jl_apply((jl_function_t*)global("DivideByZeroError"), NULL, 0); jl_undefref_exception = jl_apply((jl_function_t*)global("UndefRefError"),NULL,0); jl_interrupt_exception = jl_apply((jl_function_t*)global("InterruptException"),NULL,0); jl_memory_exception = jl_apply((jl_function_t*)global("MemoryError"),NULL,0); jl_append_any_func = (jl_function_t*)global("append_any"); jl_method_missing_func = (jl_function_t*)global("method_missing"); jl_array_uint8_type = (jl_type_t*)jl_apply_type((jl_value_t*)jl_array_type, jl_tuple2(jl_uint8_type, jl_box_long(1))); }
DLLEXPORT void jl_set_memio_func(void) { jl_memio_func = (jl_function_t*)global("memio"); }