//------------------------------------------------------------------------------ int main() { char answer[100]; printf("This program will generate the energy maps. It may take some time...\n"); printf("Do you want to continue (yes/no)? "); if(scanf("%s", answer) != EOF && strcmp(answer, "yes") == 0) { char file[200]; pp_init(); for(int configE = 1; configE <= 9; configE++) for(int configI = 1; configI <= 4; configI++) { pp_clear_maps(); printf("Generating configuration (%d/9,%d/4)...\n", configE, configI); pp_draw_config(configE, configI); pp_compute_distance_transform(); sprintf(file,"config%d.dat",configE*10+configI); pp_save_to_file(file); sprintf(file,"config%d.bmp",configE*10+configI); pp_save_to_bmp(file); } printf("Les fichiers configxx.dat générés dans le répertoire courant doivent être placés dans le répertoire 'data' à la racine du client pc.\n"); } return 0; }
bool pass_parse(sourcefile_t *src) { const lineelement_t *lelem; segment_reset(); allBytesResolved = true; allTermsFinal = true; dumpPass = false; /* Set Pet/Screen Mode to the default */ reset_TextMode(); src_reset(src); if( !pp_init(src) ) { return false; } resetResolveCounter(); while( (lelem=pp_peek())!=NULL && lelem->typ!=LE_EOF ) { if( !pass_eparse() ) { pp_skipGarbage(); } /* Change SegElem if PC was redefined in this line */ segment_processChange(); /* if the number of errors reached the maximum value, stop parsing now */ if( errorcnt>=cfg_maxerrors ) { printf("maximum number of errors reached. aborting!\n"); break; } }; if( errorcnt==0 ) { if( segment_getPhaseIdx()!=0 ) { error(EM_PseudoPCStillOpenAtEnd); return false; } if( getLocalBlock()!=0 ) { error(EM_LocalBlockStillOpenAtEnd); return false; } } return true; }
//---------------------------------------------------------- void init(void) { DDRB = BV(PB0); DDRD = BV(PD1) | BV(PD3) | BV(PD4); uart0_init(); // PC uart1_init(); // internal uart2_init(); // external (via extBus) adc_init(); timer_init(); TB_Callback_setBaud = uart1_set_baud; TB_Init((void*) 0x10); // addr in eeprom with settings pp_init(); sei(); }
/*! * V4L2 interface - open function * * @param inode structure inode * * * @param file structure file * * * @return status 0 success, ENODEV invalid device instance, * ENODEV timeout, ERESTARTSYS interrupted by user */ static int mxc_v4l2out_open(struct inode *inode, struct file *file) { struct video_device *dev = video_devdata(file); vout_data *vout = video_get_drvdata(dev); int err; dq_intr_cnt = 0; if (!vout) { pr_info("Internal error, vout_data not found!\n"); return -ENODEV; } down(&vout->busy_lock); err = -EINTR; if (signal_pending(current)) goto oops; if (vout->open_count++ == 0) { pp_init(vout); init_waitqueue_head(&vout->v4l_bufq); init_timer(&vout->output_timer); vout->output_timer.function = mxc_v4l2out_timer_handler; vout->output_timer.data = (unsigned long)vout; vout->state = STATE_STREAM_OFF; g_irq_cnt = g_buf_output_cnt = g_buf_q_cnt = g_buf_dq_cnt = 0; } #ifdef CONFIG_VIDEO_MXC_OUTPUT_FBSYNC vout->tear_protection = TEARING_PROTECTION_ACTIVE; #else vout->tear_protection = TEARING_PROTECTION_UNSUPPORTED; #endif file->private_data = dev; up(&vout->busy_lock); return 0; oops: up(&vout->busy_lock); return err; }
int run_processes_parallel(int n, get_next_task_fn get_next_task, start_failure_fn start_failure, task_finished_fn task_finished, void *pp_cb) { int i, code; int output_timeout = 100; int spawn_cap = 4; struct parallel_processes pp; pp_init(&pp, n, get_next_task, start_failure, task_finished, pp_cb); while (1) { for (i = 0; i < spawn_cap && !pp.shutdown && pp.nr_processes < pp.max_processes; i++) { code = pp_start_one(&pp); if (!code) continue; if (code < 0) { pp.shutdown = 1; kill_children(&pp, -code); } break; } if (!pp.nr_processes) break; pp_buffer_stderr(&pp, output_timeout); pp_output(&pp); code = pp_collect_finished(&pp); if (code) { pp.shutdown = 1; if (code < 0) kill_children(&pp, -code); } } pp_cleanup(&pp); return 0; }
// Render the given term into the output stream. void print(std::ostream& os, Tree* t) { if (not t) { os << "<null>"; return; } switch (t->kind) { case id_tree: return pp_terminal(os, as<Id_tree>(t)); case lit_tree: return pp_terminal(os, as<Lit_tree>(t)); case var_tree: return pp_var(os, as<Var_tree>(t)); case init_tree: return pp_init(os, as<Init_tree>(t)); case abs_tree: return pp_abs(os, as<Abs_tree>(t)); case fn_tree: return pp_fn(os, as<Fn_tree>(t)); case app_tree: return pp_app(os, as<App_tree>(t)); case if_tree: return pp_if(os, as<If_tree>(t)); case succ_tree: return pp_succ(os, as<Succ_tree>(t)); case pred_tree: return pp_pred(os, as<Pred_tree>(t)); case ls_tree: return pp_ls(os, as<Ls_tree>(t));//Rishi case mkdir_tree: return pp_mkdir(os, as<Mkdir_tree>(t));//Rishi case rmdir_tree: return pp_rmdir(os, as<Rmdir_tree>(t));//Rishi case cd_tree: return pp_cd(os, as<Cd_tree>(t));//Rishi case mv_tree: return pp_mv(os, as<Mv_tree>(t));//Rishi case iszero_tree: return pp_iszero(os, as<Iszero_tree>(t)); case arrow_tree: return pp_arrow(os, as<Arrow_tree>(t)); case def_tree: return pp_def(os, as<Def_tree>(t)); case print_tree: return pp_print(os, as<Print_tree>(t)); case typeof_tree: return pp_typeof(os, as<Typeof_tree>(t)); case tuple_tree: return pp_tuple(os, as<Tuple_tree>(t)); case list_tree: return pp_list(os, as<List_tree>(t)); case variant_tree: return pp_variant(os, as<Variant_tree>(t)); case comma_tree: return pp_comma(os, as<Comma_tree>(t)); case dot_tree: return pp_dot(os, as<Dot_tree>(t)); case prog_tree: return pp_prog(os, as<Prog_tree>(t)); } lang_unreachable(format("print unknown node '{}'", node_name(t))); }
int main(int argc, char *argv[]) { bool chook = false; int client = false; int dinx; int disable; int ferr; int inx; char lname[10]; bool mq = false; int oid; void *res; bool rnd = false; int sleept; int snid; int spid; int status; TAD zargs[] = { { "-chook", TA_Bool, TA_NOMAX, &chook }, { "-client", TA_Bool, TA_NOMAX, &client }, { "-dloop", TA_Int, MAX_OUT, &gdloop }, { "-dsize", TA_Int, TA_NOMAX, &gdsize }, { "-ksleep", TA_Int, TA_NOMAX, &gksleep }, { "-loop", TA_Int, TA_NOMAX, &gloop }, { "-maxc", TA_Int, MAX_THR, &gmaxc }, { "-maxs", TA_Int, MAX_THR, &gmaxs }, { "-mq", TA_Bool, TA_NOMAX, &mq }, { "-nodecycle", TA_Bool, TA_NOMAX, &gnodecycle }, { "-rnd", TA_Bool, TA_NOMAX, &rnd }, { "-server", TA_Ign, TA_NOMAX, NULL }, { "-v", TA_Bool, TA_NOMAX, &gverbose }, { "-vpp", TA_Bool, TA_NOMAX, &gverbosepp }, { "", TA_End, TA_NOMAX, NULL } }; arg_proc_args(zargs, false, argc, argv); if (client && chook) test_debug_hook("c", "c"); msfs_util_init(&argc, &argv, msg_debug_hook); util_test_start(client); if (!client) setup_sig(); ferr = msg_mon_process_startup(true); // system messages TEST_CHK_FEOK(ferr); gargc = argc; // after msg_init - it removes args gargp = argv; sprintf(gprog, "%s/%s", getenv("PWD"), argv[0]); gvirtual = (getenv("SQ_VIRTUAL_NODES") != NULL); ferr = msg_mon_get_my_process_name(gname, sizeof(gname)); assert(ferr == XZFIL_ERR_OK); if (client) { msg_mon_enable_mon_messages(true); // get mon messages ferr = msg_mon_get_process_info(NULL, &gcnid, NULL); assert(ferr == XZFIL_ERR_OK); ferr = XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETSENDLIMIT, (short) (gmaxc * gdloop)); assert(ferr == XZFIL_ERR_OK); srand(1); sleept = 1000; start_server(argc, argv); sleep(1); ferr = msg_mon_open_process((char *) "$srv", // name TPT_REF(gphandle), &oid); TEST_CHK_FEOK(ferr); ferr = XPROCESSHANDLE_DECOMPOSE_(TPT_REF(gphandle), &snid, &spid); TEST_CHK_FEOK(ferr); for (inx = 0; inx < gloop; inx++) { if (mq) printf("client: inx=%d\n", inx); for (dinx = 0; dinx < gmaxc; dinx++) { sprintf(lname, "c%d", dinx); gthrc[dinx] = new MyThread(client_thr, lname, dinx); } disable = msg_test_assert_disable(); for (dinx = 0; dinx < gmaxc; dinx++) gthrc[dinx]->start(); if (rnd) sleept = (int) ((float) gksleep * (rand_r(&gseed) / (RAND_MAX + 1.0))); usleep(sleept); for (dinx = 0; dinx < gmaxc; dinx++) { status = gthrc[dinx]->join(&res); TEST_CHK_STATUSOK(status); if (gverbose) printf("joined with client %d\n", dinx); } for (dinx = 0; dinx < gmaxc; dinx++) delete gthrc[dinx]; msg_test_assert_enable(disable); } } else { msg_mon_enable_mon_messages(true); // get mon messages ferr = XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETRECVLIMIT, XMAX_SETTABLE_RECVLIMIT); assert(ferr == XZFIL_ERR_OK); pp_init(); if (!gshutdown) { for (dinx = 0; dinx < gmaxs; dinx++) { char lname[10]; sprintf(lname, "s%d", dinx); gthrs[dinx] = new SB_Thread::Thread(server_thr, lname); } for (dinx = 0; dinx < gmaxs; dinx++) gthrs[dinx]->start(); for (dinx = 0; dinx < gmaxs; dinx++) { status = gthrs[dinx]->join(&res); TEST_CHK_STATUSOK(status); if (gverbose) printf("joined with server %d\n", dinx); } } if (gverbosepp) pp_printf("exit pid=%d\n", getpid()); } if (client) { sleep(1); ferr = msg_mon_close_process(TPT_REF(gphandle)); TEST_CHK_FEOK(ferr); } ferr = msg_mon_process_shutdown(); TEST_CHK_FEOK(ferr); util_test_finish(client); return 0; }
GLboolean dri_create_context(gl_api api, const struct gl_config * visual, __DRIcontext * cPriv, unsigned major_version, unsigned minor_version, uint32_t flags, unsigned *error, void *sharedContextPrivate) { __DRIscreen *sPriv = cPriv->driScreenPriv; struct dri_screen *screen = dri_screen(sPriv); struct st_api *stapi = screen->st_api; struct dri_context *ctx = NULL; struct st_context_iface *st_share = NULL; struct st_context_attribs attribs; enum st_context_error ctx_err = 0; memset(&attribs, 0, sizeof(attribs)); switch (api) { case API_OPENGLES: attribs.profile = ST_PROFILE_OPENGL_ES1; break; case API_OPENGLES2: attribs.profile = ST_PROFILE_OPENGL_ES2; break; case API_OPENGL: attribs.profile = ST_PROFILE_DEFAULT; attribs.major = major_version; attribs.minor = minor_version; if ((flags & __DRI_CTX_FLAG_DEBUG) != 0) attribs.flags |= ST_CONTEXT_FLAG_DEBUG; if ((flags & __DRI_CTX_FLAG_FORWARD_COMPATIBLE) != 0) attribs.flags |= ST_CONTEXT_FLAG_FORWARD_COMPATIBLE; break; default: *error = __DRI_CTX_ERROR_BAD_API; goto fail; } if (sharedContextPrivate) { st_share = ((struct dri_context *)sharedContextPrivate)->st; } ctx = CALLOC_STRUCT(dri_context); if (ctx == NULL) { *error = __DRI_CTX_ERROR_NO_MEMORY; goto fail; } cPriv->driverPrivate = ctx; ctx->cPriv = cPriv; ctx->sPriv = sPriv; driParseConfigFiles(&ctx->optionCache, &screen->optionCache, sPriv->myNum, driver_descriptor.name); dri_fill_st_options(&attribs.options, &ctx->optionCache); dri_fill_st_visual(&attribs.visual, screen, visual); ctx->st = stapi->create_context(stapi, &screen->base, &attribs, &ctx_err, st_share); if (ctx->st == NULL) { switch (ctx_err) { case ST_CONTEXT_SUCCESS: *error = __DRI_CTX_ERROR_SUCCESS; break; case ST_CONTEXT_ERROR_NO_MEMORY: *error = __DRI_CTX_ERROR_NO_MEMORY; break; case ST_CONTEXT_ERROR_BAD_API: *error = __DRI_CTX_ERROR_BAD_API; break; case ST_CONTEXT_ERROR_BAD_VERSION: *error = __DRI_CTX_ERROR_BAD_VERSION; break; case ST_CONTEXT_ERROR_BAD_FLAG: *error = __DRI_CTX_ERROR_BAD_FLAG; break; case ST_CONTEXT_ERROR_UNKNOWN_ATTRIBUTE: *error = __DRI_CTX_ERROR_UNKNOWN_ATTRIBUTE; break; case ST_CONTEXT_ERROR_UNKNOWN_FLAG: *error = __DRI_CTX_ERROR_UNKNOWN_FLAG; break; } goto fail; } ctx->st->st_manager_private = (void *) ctx; ctx->stapi = stapi; // Context successfully created. See if post-processing is requested. dri_pp_query(ctx); ctx->pp = pp_init(screen->base.screen, ctx->pp_enabled); *error = __DRI_CTX_ERROR_SUCCESS; return GL_TRUE; fail: if (ctx && ctx->st) ctx->st->destroy(ctx->st); FREE(ctx); return GL_FALSE; }
context_id GalliumContext::CreateContext(Bitmap *bitmap) { CALLED(); struct hgl_context* context = CALLOC_STRUCT(hgl_context); if (!context) { ERROR("%s: Couldn't create pipe context!\n", __FUNCTION__); return 0; } // Set up the initial things our context needs context->bitmap = bitmap; context->colorSpace = get_bitmap_color_space(bitmap); context->screen = fScreen; context->draw = NULL; context->read = NULL; context->st = NULL; context->api = st_gl_api_create(); if (!context->api) { ERROR("%s: Couldn't obtain Mesa state tracker API!\n", __func__); return -1; } // Create state_tracker manager context->manager = hgl_create_st_manager(context); // Create state tracker visual context->stVisual = hgl_create_st_visual(fOptions); // Create state tracker framebuffers context->draw = hgl_create_st_framebuffer(context); context->read = hgl_create_st_framebuffer(context); if (!context->draw || !context->read) { ERROR("%s: Problem allocating framebuffer!\n", __func__); FREE(context->stVisual); return -1; } // Build state tracker attributes struct st_context_attribs attribs; memset(&attribs, 0, sizeof(attribs)); attribs.options.force_glsl_extensions_warn = false; attribs.profile = ST_PROFILE_DEFAULT; attribs.visual = *context->stVisual; attribs.major = 1; attribs.minor = 0; //attribs.flags |= ST_CONTEXT_FLAG_DEBUG; struct st_api* api = context->api; // Create context using state tracker api call enum st_context_error result; context->st = api->create_context(api, context->manager, &attribs, &result, context->st); if (!context->st) { ERROR("%s: Couldn't create mesa state tracker context!\n", __func__); switch (result) { case ST_CONTEXT_SUCCESS: ERROR("%s: State tracker error: SUCCESS?\n", __func__); break; case ST_CONTEXT_ERROR_NO_MEMORY: ERROR("%s: State tracker error: NO_MEMORY\n", __func__); break; case ST_CONTEXT_ERROR_BAD_API: ERROR("%s: State tracker error: BAD_API\n", __func__); break; case ST_CONTEXT_ERROR_BAD_VERSION: ERROR("%s: State tracker error: BAD_VERSION\n", __func__); break; case ST_CONTEXT_ERROR_BAD_FLAG: ERROR("%s: State tracker error: BAD_FLAG\n", __func__); break; case ST_CONTEXT_ERROR_UNKNOWN_ATTRIBUTE: ERROR("%s: State tracker error: BAD_ATTRIBUTE\n", __func__); break; case ST_CONTEXT_ERROR_UNKNOWN_FLAG: ERROR("%s: State tracker error: UNKNOWN_FLAG\n", __func__); break; } hgl_destroy_st_visual(context->stVisual); FREE(context); return -1; } assert(!context->st->st_manager_private); context->st->st_manager_private = (void*)context; struct st_context *stContext = (struct st_context*)context->st; // Init Gallium3D Post Processing // TODO: no pp filters are enabled yet through postProcessEnable context->postProcess = pp_init(stContext->pipe, context->postProcessEnable, stContext->cso_context); context_id contextNext = -1; Lock(); for (context_id i = 0; i < CONTEXT_MAX; i++) { if (fContext[i] == NULL) { fContext[i] = context; contextNext = i; break; } } Unlock(); if (contextNext < 0) { ERROR("%s: The next context is invalid... something went wrong!\n", __func__); //st_destroy_context(context->st); FREE(context->stVisual); FREE(context); return -1; } TRACE("%s: context #%" B_PRIu64 " is the next available context\n", __func__, contextNext); return contextNext; }
/** * Bind an OSMesaContext to an image buffer. The image buffer is just a * block of memory which the client provides. Its size must be at least * as large as width*height*pixelSize. Its address should be a multiple * of 4 if using RGBA mode. * * By default, image data is stored in the order of glDrawPixels: row-major * order with the lower-left image pixel stored in the first array position * (ie. bottom-to-top). * * If the context's viewport hasn't been initialized yet, it will now be * initialized to (0,0,width,height). * * Input: osmesa - the rendering context * buffer - the image buffer memory * type - data type for pixel components * GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT * or GL_FLOAT. * width, height - size of image buffer in pixels, at least 1 * Return: GL_TRUE if success, GL_FALSE if error because of invalid osmesa, * invalid type, invalid size, etc. */ GLAPI GLboolean GLAPIENTRY OSMesaMakeCurrent(OSMesaContext osmesa, void *buffer, GLenum type, GLsizei width, GLsizei height) { struct st_api *stapi = get_st_api(); struct osmesa_buffer *osbuffer; enum pipe_format color_format; if (!osmesa || !buffer || width < 1 || height < 1) { return GL_FALSE; } if (osmesa->format == OSMESA_RGB_565 && type != GL_UNSIGNED_SHORT_5_6_5) { return GL_FALSE; } color_format = osmesa_choose_format(osmesa->format, type); if (color_format == PIPE_FORMAT_NONE) { fprintf(stderr, "OSMesaMakeCurrent(unsupported format/type)\n"); return GL_FALSE; } /* See if we already have a buffer that uses these pixel formats */ osbuffer = osmesa_find_buffer(color_format, osmesa->depth_stencil_format, osmesa->accum_format, width, height); if (!osbuffer) { /* Existing buffer found, create new buffer */ osbuffer = osmesa_create_buffer(color_format, osmesa->depth_stencil_format, osmesa->accum_format); } osbuffer->width = width; osbuffer->height = height; osbuffer->map = buffer; /* XXX unused for now */ (void) osmesa_destroy_buffer; osmesa->current_buffer = osbuffer; osmesa->type = type; stapi->make_current(stapi, osmesa->stctx, osbuffer->stfb, osbuffer->stfb); if (!osmesa->ever_used) { /* one-time init, just postprocessing for now */ boolean any_pp_enabled = FALSE; unsigned i; for (i = 0; i < ARRAY_SIZE(osmesa->pp_enabled); i++) { if (osmesa->pp_enabled[i]) { any_pp_enabled = TRUE; break; } } if (any_pp_enabled) { osmesa->pp = pp_init(osmesa->stctx->pipe, osmesa->pp_enabled, osmesa->stctx->cso_context); pp_init_fbos(osmesa->pp, width, height); } osmesa->ever_used = TRUE; } return GL_TRUE; }
context_id GalliumContext::CreateContext(Bitmap *bitmap) { CALLED(); struct hgl_context* context = CALLOC_STRUCT(hgl_context); if (!context) { ERROR("%s: Couldn't create pipe context!\n", __FUNCTION__); return 0; } // Set up the initial things our context needs context->bitmap = bitmap; context->colorSpace = get_bitmap_color_space(bitmap); context->draw = NULL; context->read = NULL; context->st = NULL; context->api = st_gl_api_create(); if (!context->api) { ERROR("%s: Couldn't obtain Mesa state tracker API!\n", __func__); return -1; } context->manager = CALLOC_STRUCT(st_manager); if (!context->manager) { ERROR("%s: Couldn't allocate Mesa state tracker manager!\n", __func__); return -1; } context->manager->get_param = hook_stm_get_param; // Calculate visual configuration const GLboolean rgbFlag = ((fOptions & BGL_INDEX) == 0); const GLboolean alphaFlag = ((fOptions & BGL_ALPHA) == BGL_ALPHA); const GLboolean dblFlag = ((fOptions & BGL_DOUBLE) == BGL_DOUBLE); const GLboolean stereoFlag = false; const GLint depth = (fOptions & BGL_DEPTH) ? 24 : 0; const GLint stencil = (fOptions & BGL_STENCIL) ? 8 : 0; const GLint accum = (fOptions & BGL_ACCUM) ? 16 : 0; const GLint red = rgbFlag ? 8 : 5; const GLint green = rgbFlag ? 8 : 5; const GLint blue = rgbFlag ? 8 : 5; const GLint alpha = alphaFlag ? 8 : 0; TRACE("rgb :\t%d\n", (bool)rgbFlag); TRACE("alpha :\t%d\n", (bool)alphaFlag); TRACE("dbl :\t%d\n", (bool)dblFlag); TRACE("stereo :\t%d\n", (bool)stereoFlag); TRACE("depth :\t%d\n", depth); TRACE("stencil :\t%d\n", stencil); TRACE("accum :\t%d\n", accum); TRACE("red :\t%d\n", red); TRACE("green :\t%d\n", green); TRACE("blue :\t%d\n", blue); TRACE("alpha :\t%d\n", alpha); gl_config* glVisual = _mesa_create_visual(dblFlag, stereoFlag, red, green, blue, alpha, depth, stencil, accum, accum, accum, alpha ? accum : 0, 1); if (!glVisual) { ERROR("%s: Couldn't create Mesa visual!\n", __func__); return -1; } TRACE("depthBits :\t%d\n", glVisual->depthBits); TRACE("stencilBits :\t%d\n", glVisual->stencilBits); // Convert Mesa calculated visual into state tracker visual context->stVisual = hgl_fill_st_visual(glVisual); context->draw = new GalliumFramebuffer(context->stVisual, (void*)this); context->read = new GalliumFramebuffer(context->stVisual, (void*)this); if (!context->draw || !context->read) { ERROR("%s: Problem allocating framebuffer!\n", __func__); _mesa_destroy_visual(glVisual); return -1; } // We need to assign the screen *before* calling st_api create_context context->manager->screen = fScreen; // Build state tracker attributes struct st_context_attribs attribs; memset(&attribs, 0, sizeof(attribs)); attribs.options.force_glsl_extensions_warn = false; attribs.profile = ST_PROFILE_DEFAULT; attribs.visual = *context->stVisual; attribs.major = 1; attribs.minor = 0; //attribs.flags |= ST_CONTEXT_FLAG_DEBUG; struct st_api* api = context->api; // Create context using state tracker api call enum st_context_error result; context->st = api->create_context(api, context->manager, &attribs, &result, context->st); if (!context->st) { ERROR("%s: Couldn't create mesa state tracker context!\n", __func__); switch (result) { case ST_CONTEXT_SUCCESS: ERROR("%s: State tracker error: SUCCESS?\n", __func__); break; case ST_CONTEXT_ERROR_NO_MEMORY: ERROR("%s: State tracker error: NO_MEMORY\n", __func__); break; case ST_CONTEXT_ERROR_BAD_API: ERROR("%s: State tracker error: BAD_API\n", __func__); break; case ST_CONTEXT_ERROR_BAD_VERSION: ERROR("%s: State tracker error: BAD_VERSION\n", __func__); break; case ST_CONTEXT_ERROR_BAD_FLAG: ERROR("%s: State tracker error: BAD_FLAG\n", __func__); break; case ST_CONTEXT_ERROR_UNKNOWN_ATTRIBUTE: ERROR("%s: State tracker error: BAD_ATTRIBUTE\n", __func__); break; case ST_CONTEXT_ERROR_UNKNOWN_FLAG: ERROR("%s: State tracker error: UNKNOWN_FLAG\n", __func__); break; } FREE(context); return -1; } assert(!context->st->st_manager_private); context->st->st_manager_private = (void*)context; struct st_context *stContext = (struct st_context*)context->st; stContext->ctx->Driver.Viewport = hgl_viewport; // Init Gallium3D Post Processing // TODO: no pp filters are enabled yet through postProcessEnable context->postProcess = pp_init(stContext->pipe, context->postProcessEnable, stContext->cso_context); context_id contextNext = -1; Lock(); for (context_id i = 0; i < CONTEXT_MAX; i++) { if (fContext[i] == NULL) { fContext[i] = context; contextNext = i; break; } } Unlock(); if (contextNext < 0) { ERROR("%s: The next context is invalid... something went wrong!\n", __func__); //st_destroy_context(context->st); FREE(context); _mesa_destroy_visual(glVisual); return -1; } TRACE("%s: context #%" B_PRIu64 " is the next available context\n", __func__, contextNext); return contextNext; }
int main(int argc,char *argv[]) { int er=1,i; signed char *s=NULL; char *tmpp; int mifiles = 5; int nifiles = 0; int verbose = 0; int oldfile = 0; int no_link = 0; char **ifiles; char *ofile; char *efile; char *lfile; char *ifile; char old_e[MAXLINE]; char old_l[MAXLINE]; char old_o[MAXLINE]; tim1=time(NULL); ncmos=0; n65816=0; cmosfl=1; w65816=0; /* default: 6502 only */ altppchar = '#' ; /* i.e., NO alternate char */ if((tmpp = strrchr(argv[0],'/'))) { tmpp++; } else { tmpp = argv[0]; } if( (!strcmp(tmpp,"xa65816")) || (!strcmp(tmpp,"XA65816")) || (!strcmp(tmpp,"xa816")) || (!strcmp(tmpp,"XA816")) ) { w65816 = 1; /* allow 65816 per default */ } /* default output charset for strings in quotes */ set_charset("ASCII"); ifiles = malloc(mifiles*sizeof(char*)); afile = alloc_file(); if (argc <= 1) { usage(w65816, stderr); exit(1); } if (strstr(argv[1], "--help")) { usage(w65816, stdout); exit(0); } if (strstr(argv[1], "--version")) { version(programname, progversion, authors, copyright); exit(0); } ofile="a.o65"; efile=NULL; lfile=NULL; if(pp_init()) { logout("fatal: pp: no memory!"); return 1; } if(b_init()) { logout("fatal: b: no memory!"); return 1; } if(l_init()) { logout("fatal: l: no memory!"); return 1; } i=1; while(i<argc) { if(argv[i][0]=='-') { switch(argv[i][1]) { case 'p': /* intentionally not allowing an argument to follow with a space to avoid - being seen as the alternate preprocessor char! */ if (argv[i][2] == '\0') { fprintf(stderr, "-p requires a character argument\n"); exit(1); } if (argv[i][2] == '#') fprintf(stderr, "using -p# is evidence of stupidity\n"); altppchar = argv[i][2]; if (argv[i][3] != '\0') fprintf(stderr, "warning: extra characters to -p ignored\n"); break; case 'M': masm = 1; /* MASM compatibility mode */ break; case 'O': /* output charset */ { char *name = NULL; if (argv[i][2] == 0) { name = argv[++i]; } else { name = argv[i]+2; } if (set_charset(name) < 0) { fprintf(stderr, "Output charset name '%s' unknown - ignoring! (check case?)\n", name); } } break; case 'A': /* make text segment start so that text relocation is not necessary when _file_ starts at adr */ romable = 2; if(argv[i][2]==0) romaddr = atoi(argv[++i]); else romaddr = atoi(argv[i]+2); break; case 'G': noglob = 1; break; case 'L': /* define global label */ if(argv[i][2]) lg_set(argv[i]+2); break; case 'r': crossref = 1; break; case 'R': relmode = 1; break; case 'D': s = (signed char*)strstr(argv[i]+2,"="); if(s) *s = ' '; pp_define(argv[i]+2); break; case 'c': no_link = 1; fmode |= FM_OBJ; break; case 'v': verbose = 1; break; case 'C': cmosfl = 0; break; case 'W': w65816 = 0; break; case 'w': w65816 = 1; break; case 'B': showblk = 1; break; case 'x': /* old filename behaviour */ oldfile = 1; fprintf(stderr, "Warning: -x is now deprecated and may disappear in future versions!\n"); break; case 'I': if(argv[i][2]==0) { reg_include(argv[++i]); } else { reg_include(argv[i]+2); } break; case 'o': if(argv[i][2]==0) { ofile=argv[++i]; } else { ofile=argv[i]+2; } break; case 'l': if(argv[i][2]==0) { lfile=argv[++i]; } else { lfile=argv[i]+2; } break; case 'e': if(argv[i][2]==0) { efile=argv[++i]; } else { efile=argv[i]+2; } break; case 'b': /* set segment base addresses */ switch(argv[i][2]) { case 't': if(argv[i][3]==0) tbase = atoi(argv[++i]); else tbase = atoi(argv[i]+3); break; case 'd': if(argv[i][3]==0) dbase = atoi(argv[++i]); else dbase = atoi(argv[i]+3); break; case 'b': if(argv[i][3]==0) bbase = atoi(argv[++i]); else bbase = atoi(argv[i]+3); break; case 'z': if(argv[i][3]==0) zbase = atoi(argv[++i]); else zbase = atoi(argv[i]+3); break; default: fprintf(stderr,"unknown segment type '%c' - ignoring!\n", argv[i][2]); break; } break; case 0: fprintf(stderr, "Single dash '-' on command line - ignoring!\n"); break; default: fprintf(stderr, "Unknown option '%c' - ignoring!\n",argv[i][1]); break; } } else { /* no option -> filename */ ifiles[nifiles++] = argv[i]; if(nifiles>=mifiles) { mifiles += 5; ifiles=realloc(ifiles, mifiles*sizeof(char*)); if(!ifiles) { fprintf(stderr, "Oops: couldn't alloc enough mem for filelist table..!\n"); exit(1); } } } i++; } if(!nifiles) { fprintf(stderr, "No input files given!\n"); exit(0); } if(oldfile) { strcpy(old_e, ifiles[0]); strcpy(old_o, ifiles[0]); strcpy(old_l, ifiles[0]); if(setfext(old_e,".err")==0) efile = old_e; if(setfext(old_o,".obj")==0) ofile = old_o; if(setfext(old_l,".lab")==0) lfile = old_l; } fplab= lfile ? xfopen(lfile,"w") : NULL; fperr= efile ? xfopen(efile,"w") : NULL; if(!strcmp(ofile,"-")) { ofile=NULL; fpout = stdout; } else { fpout= xfopen(ofile,"wb"); } if(!fpout) { fprintf(stderr, "Couldn't open output file!\n"); exit(1); } if(verbose) fprintf(stderr, "%s\n",copyright); if(1 /*!m_init()*/) { if(1 /*!b_init()*/) { if(1 /*!l_init()*/) { /*if(!pp_init())*/ { if(!x_init()) { if(fperr) fprintf(fperr,"%s\n",copyright); if(verbose) logout(ctime(&tim1)); /* Pass 1 */ pc[SEG_ABS]= 0; /* abs addressing */ seg_start(fmode, tbase, dbase, bbase, zbase, 0, relmode); if(relmode) { r_mode(RMODE_RELOC); segment = SEG_TEXT; } else { r_mode(RMODE_ABS); } nolink = no_link; for (i=0; i<nifiles; i++) { ifile = ifiles[i]; sprintf(out,"xAss65: Pass 1: %s\n",ifile); if(verbose) logout(out); er=pp_open(ifile); puttmp(0); puttmp(T_FILE); puttmp(0); puttmp(0); puttmps((signed char*)&ifile, sizeof(filep->fname)); if(!er) { er=pass1(); pp_close(); } else { sprintf(out, "Couldn't open source file '%s'!\n", ifile); logout(out); } } if((er=b_depth())) { sprintf(out,"Still %d blocks open at end of file!\n",er); logout(out); } if(tbase & (align-1)) { sprintf(out,"Warning: text segment ($%04x) start address doesn't align to %d!\n", tbase, align); logout(out); } if(dbase & (align-1)) { sprintf(out,"Warning: data segment ($%04x) start address doesn't align to %d!\n", dbase, align); logout(out); } if(bbase & (align-1)) { sprintf(out,"Warning: bss segment ($%04x) start address doesn't align to %d!\n", bbase, align); logout(out); } if(zbase & (align-1)) { sprintf(out,"Warning: zero segment ($%04x) start address doesn't align to %d!\n", zbase, align); logout(out); } if (n65816>0) fmode |= 0x8000; switch(align) { case 1: break; case 2: fmode |= 1; break; case 4: fmode |= 2; break; case 256: fmode |=3; break; } if((!er) && relmode) h_write(fpout, fmode, tlen, dlen, blen, zlen, 0); if(!er) { if(verbose) logout("xAss65: Pass 2:\n"); seg_pass2(); if(!relmode) { r_mode(RMODE_ABS); } else { r_mode(RMODE_RELOC); segment = SEG_TEXT; } er=pass2(); } if(fplab) printllist(fplab); tim2=time(NULL); if(verbose) printstat(); if((!er) && relmode) seg_end(fpout); /* write reloc/label info */ if(fperr) fclose(fperr); if(fplab) fclose(fplab); if(fpout) fclose(fpout); } else { logout("fatal: x: no memory!\n"); } pp_end(); /* } else { logout("fatal: pp: no memory!");*/ } } else { logout("fatal: l: no memory!\n"); } } else { logout("fatal: b: no memory!\n"); } /*m_exit();*/ } else { logout("Not enough memory available!\n"); } if(ner || er) { fprintf(stderr, "Break after %d error%c\n",ner,ner?'s':0); /*unlink();*/ if(ofile) { unlink(ofile); } } free(ifiles); return( (er || ner) ? 1 : 0 ); }
GLboolean dri_create_context(gl_api api, const struct gl_config * visual, __DRIcontext * cPriv, unsigned major_version, unsigned minor_version, uint32_t flags, bool notify_reset, unsigned *error, void *sharedContextPrivate) { __DRIscreen *sPriv = cPriv->driScreenPriv; struct dri_screen *screen = dri_screen(sPriv); struct st_api *stapi = screen->st_api; struct dri_context *ctx = NULL; struct st_context_iface *st_share = NULL; struct st_context_attribs attribs; enum st_context_error ctx_err = 0; memset(&attribs, 0, sizeof(attribs)); switch (api) { case API_OPENGLES: attribs.profile = ST_PROFILE_OPENGL_ES1; break; case API_OPENGLES2: attribs.profile = ST_PROFILE_OPENGL_ES2; break; case API_OPENGL_COMPAT: case API_OPENGL_CORE: attribs.profile = api == API_OPENGL_COMPAT ? ST_PROFILE_DEFAULT : ST_PROFILE_OPENGL_CORE; attribs.major = major_version; attribs.minor = minor_version; if ((flags & __DRI_CTX_FLAG_DEBUG) != 0) attribs.flags |= ST_CONTEXT_FLAG_DEBUG; if ((flags & __DRI_CTX_FLAG_FORWARD_COMPATIBLE) != 0) attribs.flags |= ST_CONTEXT_FLAG_FORWARD_COMPATIBLE; break; default: *error = __DRI_CTX_ERROR_BAD_API; goto fail; } if (flags & ~(__DRI_CTX_FLAG_DEBUG | __DRI_CTX_FLAG_FORWARD_COMPATIBLE)) { *error = __DRI_CTX_ERROR_UNKNOWN_FLAG; goto fail; } if (notify_reset) { *error = __DRI_CTX_ERROR_UNKNOWN_ATTRIBUTE; goto fail; } if (sharedContextPrivate) { st_share = ((struct dri_context *)sharedContextPrivate)->st; } ctx = CALLOC_STRUCT(dri_context); if (ctx == NULL) { *error = __DRI_CTX_ERROR_NO_MEMORY; goto fail; } cPriv->driverPrivate = ctx; ctx->cPriv = cPriv; ctx->sPriv = sPriv; dri_fill_st_options(&attribs.options, &screen->optionCache); dri_fill_st_visual(&attribs.visual, screen, visual); ctx->st = stapi->create_context(stapi, &screen->base, &attribs, &ctx_err, st_share); if (ctx->st == NULL) { switch (ctx_err) { case ST_CONTEXT_SUCCESS: *error = __DRI_CTX_ERROR_SUCCESS; break; case ST_CONTEXT_ERROR_NO_MEMORY: *error = __DRI_CTX_ERROR_NO_MEMORY; break; case ST_CONTEXT_ERROR_BAD_API: *error = __DRI_CTX_ERROR_BAD_API; break; case ST_CONTEXT_ERROR_BAD_VERSION: *error = __DRI_CTX_ERROR_BAD_VERSION; break; case ST_CONTEXT_ERROR_BAD_FLAG: *error = __DRI_CTX_ERROR_BAD_FLAG; break; case ST_CONTEXT_ERROR_UNKNOWN_ATTRIBUTE: *error = __DRI_CTX_ERROR_UNKNOWN_ATTRIBUTE; break; case ST_CONTEXT_ERROR_UNKNOWN_FLAG: *error = __DRI_CTX_ERROR_UNKNOWN_FLAG; break; } goto fail; } ctx->st->st_manager_private = (void *) ctx; ctx->stapi = stapi; if (ctx->st->cso_context) { ctx->pp = pp_init(ctx->st->pipe, screen->pp_enabled, ctx->st->cso_context); ctx->hud = hud_create(ctx->st->pipe, ctx->st->cso_context); } *error = __DRI_CTX_ERROR_SUCCESS; return GL_TRUE; fail: if (ctx && ctx->st) ctx->st->destroy(ctx->st); free(ctx); return GL_FALSE; }
EXPORT void FrontInitStandardIO( int argc, char **argv, F_BASIC_DATA *f_basic) { char *in_name = f_basic->in_name; char *out_name = f_basic->out_name; char *restart_name = f_basic->restart_name; int *subdomains = f_basic->subdomains; f_basic->ReadFromInput = NO; f_basic->RestartRun = NO; #if defined(__MPI__) pp_init(&argc,&argv); #endif /* defined(__MPI__) */ argc--; argv++; strcpy(out_name,"intfc"); while (argc >= 1) { if (argv[0][0] != '-') { printf("Usage: example -o output\n"); exit(1); } switch(argv[0][1]) { case 'i': case 'I': f_basic->ReadFromInput = YES; zero_scalar(in_name,200); strcpy(in_name,argv[1]); argc -= 2; argv += 2; break; case 'r': case 'R': f_basic->RestartRun = YES; zero_scalar(restart_name,200); strcpy(restart_name,argv[1]); argc -= 2; argv += 2; break; case 't': case 'T': f_basic->RestartStep = atoi(argv[1]); argc -= 2; argv += 2; break; case 'd': case 'D': f_basic->dim = atoi(argv[1]); argc -= 2; argv += 2; break; case 'o': case 'O': zero_scalar(out_name,200); strcpy(out_name,argv[1]); #if defined(__MPI__) sprintf(out_name,"%s.%d",out_name,pp_mynode()); #endif /* defined(__MPI__) */ freopen(out_name,"w",stdout); zero_scalar(out_name,200); strcpy(out_name,argv[1]); argc -= 2; argv += 2; break; #if defined(__MPI__) case 'p': case 'P': { int i,total_num_proc = 1; for (i = 0; i < MAXD; ++i) { if (argc < 2 || argv[1][0] == '-') break; argc -= 1; argv += 1; subdomains[i] = atoi(argv[0]); total_num_proc *= subdomains[i]; } argc -= 1; argv += 1; if (total_num_proc != pp_numnodes()) { printf("total number of processors for the partition %d " "does not equal to requested np %d\n", total_num_proc,pp_numnodes()); clean_up(ERROR); } } #endif /* defined(__MPI__) */ } } } /* end FrontInitStatndardIO */
int main(int argc, char *argv[]) { // Catch signals signal(SIGINT, uquad_sig_handler); signal(SIGQUIT, uquad_sig_handler); int i, retval; FILE *file; uquad_mat_t *x, *w; uquad_bool_t ctrl_outdated = false; double w_hover; if(argc < 2) { err_log_str("Invalid arguments!",USAGE) quit(); } else { file = fopen(argv[1],"r"); if(file == NULL) { err_log_stderr("Failed to open log!"); quit(); } } x = uquad_mat_alloc(STATE_COUNT,1); w = uquad_mat_alloc(LENGTH_INPUT,1); if(x == NULL || w == NULL) { quit_log_if(ERROR_MALLOC,"Failed to allocate tmp mem!"); } /** * The following should be done by calling mot_update_w_hover(), this * is just a test program. */ retval = uquad_solve_pol2(&w_hover, NULL, F_B1, F_B2, -GRAVITY*MASA_DEFAULT/4.0); quit_log_if(retval, "Failed to get w_hover!"); for(i=0; i<LENGTH_INPUT; ++i) w->m_full[i] = w_hover; retval = uquad_mat_zeros(x); quit_if(retval); ctrl = control_init(); if(ctrl == NULL) { quit_if(ERROR_FAIL); } pp = pp_init(); if(pp == NULL) { quit_if(ERROR_FAIL); } retval = pp_new_setpoint(pp, x, w); quit_if(retval); retval = control_update_K(ctrl, pp, MASA_DEFAULT); quit_log_if(retval, "Failed to update control matrix! Aborting..."); for(;;) { retval = uquad_mat_load(x,file); if(retval != ERROR_OK) { quit_log_if(retval, "End of log?"); } #warning "w_hover should use mot_control.h!!" retval = pp_update_setpoint(pp, x, w_hover, &ctrl_outdated); quit_if(retval); if(ctrl_outdated) { retval = control_update_K(ctrl, pp, MASA_DEFAULT); quit_log_if(retval, "Failed to update control matrix! Aborting..."); retval = control_dump(ctrl, NULL); quit_log_if(retval, "Failed to dump new control matrix! Aborting..."); } retval = control(ctrl, w, x, pp->sp, TS_DEFAULT_US); quit_if(retval); ctrl_outdated = false; } // Never gets here quit(); }