void heap_release(char *base, char *block) { _kernel_oserror *e; heapcb *cb; int errnum; int change; unsigned int actual_change; cb = getcb(base); if (cb == NULL) return; /* unknown heap */ /* MemCheck_UnRegisterMiscBlock(block); */ /* Release the block */ _swi(OS_Heap, _INR(0,2), 3, base, block); /* Current SWI methods don't let us easily get at the returned R3, so we * use our own assembler veneer */ e = xosheap_resize_r3(base, INT_MIN, &change); /* MemCheck_RegisterMiscBlock(e, sizeof(e->errnum)); */ errnum = e->errnum; /* MemCheck_UnRegisterMiscBlock(e); */ if (errnum != 0x187 /* Can't shrink heap any further */) _swi(OS_GenerateError, _IN(0), e); /* Shrink the dynamic area (note this needs to occur before the shrink of * the heap itself, since we need the actual size change) */ _swi(OS_ChangeDynamicArea, _INR(0,1)|_OUT(1), cb->area, -change, &actual_change); /* Shrink the heap by the actual size change */ _swi(OS_Heap, _INR(0,1)|_IN(3), 5, base, change - actual_change); }
char *heap_claim(char *base, size_t required_size) { _kernel_oserror *e; int largest; unsigned int actual_change; void *block; heapcb *cb; if (required_size == 0) return NULL; cb = getcb(base); if (cb == NULL) return NULL; /* unknown heap */ /* Repeatedly attempt to claim a block of the required size */ while ((e = _swix(OS_Heap, _INR(0,1)|_IN(3)|_OUT(2), 2, base, required_size, &block)) != NULL) { int errnum; /* MemCheck_RegisterMiscBlock(e, sizeof(e->errnum)); */ errnum = e->errnum; /* MemCheck_UnRegisterMiscBlock(e); */ if (errnum != 0x184 /* Heap Full */) { #ifndef NDEBUG EC(e); #endif return NULL; /* unknown error */ } /* Read largest free space */ _swi(OS_Heap, _INR(0,1)|_OUT(2), 1, base, &largest); /* Increase the dynamic area by at least the difference between what we * want and what we have spare */ if (EC(_swix(OS_ChangeDynamicArea, _INR(0,1)|_OUT(1), cb->area, required_size - largest, &actual_change)) != NULL) return NULL; /* (most likely) out of memory */ /* Resize the heap itself */ _swi(OS_Heap, _INR(0,1)|_IN(3), 5, base, actual_change); } /* MemCheck_RegisterMiscBlock(block, required_size); */ return block; }
char *heap_create(const char *description, size_t size_limit) { heapcb *cb; int page_size; /* Get a new heapcb and link it into the start of the chain */ cb = malloc(sizeof(heapcb)); if (cb == NULL) return NULL; /* failed - unable to allocate space for control block */ cb->next = first_cb; first_cb = cb; /* Create a dynamic area at least one page in size and set it up as a heap */ _swi(OS_ReadMemMapInfo, _OUT(0), &page_size); if (EC(_swix(OS_DynamicArea, _INR(0,8)|_OUT(1)|_OUT(3), 0, -1, page_size, -1, 0x80, size_limit, NULL, -1, description, &cb->area, &cb->base))) { free(cb); return NULL; } /* page_size must be enough to hold the default heap structure */ _swi(OS_Heap, _INR(0,1)|_IN(3), 0, cb->base, page_size); return cb->base; }
void ro_gui_options_image_redraw(wimp_draw *redraw) { osbool more; os_error *error; wimp_icon_state icon_state; osspriteop_header *bg = NULL, *fg = NULL; unsigned int bg_tinct = 0, fg_tinct = 0; /* get the icon location */ icon_state.w = redraw->w; icon_state.i = IMAGE_CURRENT_DISPLAY; error = xwimp_get_icon_state(&icon_state); if (error) { LOG("xwimp_get_icon_state: 0x%x: %s", error->errnum, error->errmess); ro_warn_user("MenuError", error->errmess); return; } /* find the sprites */ if (example_images) { ro_gui_options_image_read(redraw->w, &bg_tinct, &fg_tinct); fg_tinct |= 0xeeeeee00; xosspriteop_select_sprite(osspriteop_USER_AREA, example_images, (osspriteop_id)"img_bg", &bg); xosspriteop_select_sprite(osspriteop_USER_AREA, example_images, (osspriteop_id)"img_fg", &fg); } /* perform the redraw */ more = wimp_redraw_window(redraw); while (more) { int origin_x, origin_y; origin_x = redraw->box.x0 - redraw->xscroll + icon_state.icon.extent.x0 + 2; origin_y = redraw->box.y1 - redraw->yscroll + icon_state.icon.extent.y0 + 2; if (bg) _swix(Tinct_Plot, _INR(2,4) | _IN(7), bg, origin_x, origin_y, bg_tinct); if (fg) _swix(Tinct_PlotAlpha, _INR(2,4) | _IN(7), fg, origin_x, origin_y, fg_tinct); more = wimp_get_rectangle(redraw); } }
/* * close_output * * close output file, if it not stdout */ BOOL write_output(HSCPRC * hp) { #define MAX_ERRORLEN 500 STRPTR outfilenm = NULL; BOOL written = FALSE; if (outfilename) outfilenm = estr2str(outfilename); if ((return_code == RC_OK) || (return_code == RC_WARN) || hp->debug) { FILE *outfile = NULL; /* output file */ char buf[MAX_ERRORLEN + 2]; /* buffer for error string */ /* * try to open output file */ if (outfilenm) { errno = 0; outfile = fopen(outfilenm, "w"); if (!outfile) { strncpy(buf, "unable to open `", MAX_ERRORLEN); strncat(buf, estr2str(outfilename), MAX_ERRORLEN - strlen(buf)); strncat(buf, "' for output: ", MAX_ERRORLEN - strlen(buf)); strncat(buf, strerror(errno), MAX_ERRORLEN - strlen(buf)); status_error(buf); } } else { outfile = stdout; outfilenm = STDOUT_NAME; } /* * write output */ if (outfile) { DLNODE *nd = dll_first(outlist); status_msg("writing output..."); errno = 0; /* write whole list of output-strings */ while (nd && !errno) { EXPSTR *outstring = (EXPSTR *) dln_data(nd); nd = dln_next(nd); fwrite(estr2str(outstring), sizeof(char), estrlen(outstring), outfile); } /* handle write-error, display message */ if (errno) { strncpy(buf, "error writing `", MAX_ERRORLEN); strncat(buf, outfilenm, MAX_ERRORLEN - strlen(buf)); strncat(buf, "': ", MAX_ERRORLEN - strlen(buf)); strncat(buf, strerror(errno), MAX_ERRORLEN - strlen(buf)); status_error(buf); } else written = TRUE; status_clear(); /* close output file */ if (outfile != stdout) { fclose(outfile); #ifdef RISCOS { /* set the filetype to HTML (&FAF) */ char *riscos_filename=unixname_to_riscos(outfilenm); _swix(OS_File,_IN(0)|_IN(1)|_IN(2),18,riscos_filename,0xFAF); free(riscos_filename); } #endif } } } else { status_msg("no output written"); status_lf(); } return (written); }
bool artworks_convert(struct content *c) { artworks_content *aw = (artworks_content *) c; union content_msg_data msg_data; const char *source_data; unsigned long source_size; void *init_workspace; void *init_routine; os_error *error; int used = -1; /* slightly better with older OSLib versions */ char *title; /* check whether AWViewer has been seen and we can therefore locate the ArtWorks rendering modules */ xos_read_var_val_size("Alias$LoadArtWorksModules", 0, os_VARTYPE_STRING, &used, NULL, NULL); if (used >= 0) { LOG("Alias$LoadArtWorksModules not defined"); msg_data.error = messages_get("AWNotSeen"); content_broadcast(c, CONTENT_MSG_ERROR, msg_data); return false; } /* load the modules, or do nothing if they're already loaded */ error = xos_cli("LoadArtWorksModules"); if (error) { LOG("xos_cli: 0x%x: %s", error->errnum, error->errmess); msg_data.error = error->errmess; content_broadcast(c, CONTENT_MSG_ERROR, msg_data); return false; } /* lookup the addresses of the init and render routines */ error = (os_error*)_swix(AWRender_FileInitAddress, _OUT(0) | _OUT(1), &init_routine, &init_workspace); if (error) { LOG("AWRender_FileInitAddress: 0x%x: %s", error->errnum, error->errmess); msg_data.error = error->errmess; content_broadcast(c, CONTENT_MSG_ERROR, msg_data); return false; } error = (os_error*)_swix(AWRender_RenderAddress, _OUT(0) | _OUT(1), &aw->render_routine, &aw->render_workspace); if (error) { LOG("AWRender_RenderAddress: 0x%x: %s", error->errnum, error->errmess); msg_data.error = error->errmess; content_broadcast(c, CONTENT_MSG_ERROR, msg_data); return false; } source_data = content__get_source_data(c, &source_size); /* initialise (convert file to new format if required) */ error = awrender_init(&source_data, &source_size, init_routine, init_workspace); if (error) { LOG("awrender_init: 0x%x : %s", error->errnum, error->errmess); msg_data.error = error->errmess; content_broadcast(c, CONTENT_MSG_ERROR, msg_data); return false; } error = (os_error*)_swix(AWRender_DocBounds, _IN(0) | _OUT(2) | _OUT(3) | _OUT(4) | _OUT(5), source_data, &aw->x0, &aw->y0, &aw->x1, &aw->y1); if (error) { LOG("AWRender_DocBounds: 0x%x: %s", error->errnum, error->errmess); msg_data.error = error->errmess; content_broadcast(c, CONTENT_MSG_ERROR, msg_data); return false; } LOG("bounding box: %d,%d,%d,%d", aw->x0, aw->y0, aw->x1, aw->y1); /* create the resizable workspace required by the ArtWorksRenderer rendering routine */ aw->size = INITIAL_BLOCK_SIZE; aw->block = malloc(INITIAL_BLOCK_SIZE); if (!aw->block) { LOG("failed to create block for ArtworksRenderer"); msg_data.error = messages_get("NoMemory"); content_broadcast(c, CONTENT_MSG_ERROR, msg_data); return false; } c->width = (aw->x1 - aw->x0) / 512; c->height = (aw->y1 - aw->y0) / 512; title = messages_get_buff("ArtWorksTitle", nsurl_access_leaf(llcache_handle_get_url(c->llcache)), c->width, c->height); if (title != NULL) { content__set_title(c, title); free(title); } content_set_ready(c); content_set_done(c); /* Done: update status bar */ content_set_status(c, ""); return true; }
_kernel_oserror *SWI_OS_CLI(const char *cmd) { /* execute a command */ return _swix(OS_CLI,_IN(0),cmd); }
_kernel_oserror *SWI_OS_File_1(const char *filename, unsigned int loadaddr, unsigned int execaddr, int attrib) { /* write file attributes */ return _swix(OS_File,_INR(0,3)|_IN(5),1,filename,loadaddr,execaddr,attrib); }
_kernel_oserror *SWI_OS_FSControl_27(const char *filename, int actionmask) { /* wipe */ return _swix(OS_FSControl,_INR(0,1)|_IN(3),27,filename,actionmask); }
_kernel_oserror *SWI_DDEUtils_Prefix(const char *dir) { /* sets the 'prefix' directory */ return _swix(DDEUtils_Prefix,_IN(0),dir); }