static int mission_menu_handler(listbox *lb, d_event *event, mission_menu *mm) { const char **list = listbox_get_items(lb); int citem = listbox_get_citem(lb); switch (event->type) { case EVENT_NEWMENU_SELECTED: if (citem >= 0) { // Chose a mission strcpy(GameCfg.LastMission, list[citem]); if (!load_mission(mm->mission_list + citem)) { nm_messagebox( NULL, 1, TXT_OK, TXT_MISSION_ERROR); return 1; // stay in listbox so user can select another one } } return !(*mm->when_selected)(); break; case EVENT_WINDOW_CLOSE: free_mission_list(mm->mission_list); d_free(list); d_free(mm); break; default: break; } return 0; }
void hashtable_free( hashtable *ht ) { if (ht->key != NULL ) d_free( ht->key ); if (ht->value != NULL ) d_free( ht->value ); ht->size = 0; }
int automap_handler(window *wind, d_event *event, automap *am) { switch (event->type) { case EVENT_WINDOW_ACTIVATED: game_flush_inputs(); event_toggle_focus(1); key_toggle_repeat(0); break; case EVENT_WINDOW_DEACTIVATED: event_toggle_focus(0); key_toggle_repeat(1); break; case EVENT_IDLE: case EVENT_JOYSTICK_BUTTON_UP: case EVENT_JOYSTICK_BUTTON_DOWN: case EVENT_JOYSTICK_MOVED: case EVENT_MOUSE_BUTTON_UP: case EVENT_MOUSE_BUTTON_DOWN: case EVENT_MOUSE_MOVED: automap_process_input(wind, event, am); break; case EVENT_KEY_COMMAND: case EVENT_KEY_RELEASE: { int kret = automap_key_command(wind, event, am); if (!kret) automap_process_input(wind, event, am); return kret; } case EVENT_WINDOW_DRAW: draw_automap(am); break; case EVENT_WINDOW_CLOSE: if (!am->pause_game) ConsoleObject->mtype.phys_info.flags |= am->old_wiggle; // Restore wiggle event_toggle_focus(0); key_toggle_repeat(1); #ifdef OGL gr_free_bitmap_data(&am->automap_background); #endif d_free(am->edges); d_free(am->drawingListBright); d_free(am); window_set_visible(Game_wind, 1); Automap_active = 0; return 0; // continue closing break; default: return 0; break; } return 1; }
void gr_close() { ogl_brightness_r = ogl_brightness_g = ogl_brightness_b = 0; if (gl_initialized) { ogl_smash_texture_list_internal(); } if (grd_curscreen) { if (grd_curscreen->sc_canvas.cv_bitmap.bm_data) d_free(grd_curscreen->sc_canvas.cv_bitmap.bm_data); d_free(grd_curscreen); } ogl_close_pixel_buffers(); #ifdef _WIN32 if (ogl_rt_loaded) OpenGL_LoadLibrary(false); #endif #ifdef OGLES ogles_destroy(); #ifdef RPI con_printf(CON_DEBUG, "RPi: cleanuing up\n"); if (dispman_display != DISPMANX_NO_HANDLE) { rpi_destroy_element(); con_printf(CON_DEBUG, "RPi: closing display\n"); vc_dispmanx_display_close(dispman_display); dispman_display = DISPMANX_NO_HANDLE; } #endif #endif }
int CreateSphere (tSphereData *sdP) { int nFaces, i, j; tOOF_vector *buf [2]; if (sdP->nFaceNodes == 3) { nFaces = 8; j = 6; } else { nFaces = 6; j = 4; } for (i = 0; i < sdP->nTessDepth; i++) nFaces *= j; for (i = 0; i < 2; i++) { if (!(buf [i] = (tOOF_vector *) d_malloc (nFaces * (sdP->nFaceNodes + 1) * sizeof (tOOF_vector)))) { if (i) d_free (buf [i - 1]); return -1; } } j = (sdP->nFaceNodes == 3) ? BuildSphereTri ((tOOF_triangle **) buf, &nFaces, sdP->nTessDepth) : BuildSphereQuad ((tOOF_quad **) buf, &nFaces, sdP->nTessDepth); d_free (buf [!j]); sdP->pSphere = buf [j]; return nFaces; }
void free_mission(void) { // May become more complex with the editor if (Current_mission) { if (Current_mission->path && !PLAYING_BUILTIN_MISSION) { char hogpath[PATH_MAX]; sprintf(hogpath, MISSION_DIR "%s.hog", Current_mission->path); PHYSFSX_contfile_close(hogpath); } if (Current_mission->path) d_free(Current_mission->path); if (Level_names) d_free(Level_names); if(Secret_level_names) d_free(Secret_level_names); if(Secret_level_table) d_free(Secret_level_table); d_free(Current_mission); } }
int CreateSphere (tOOF_vector **pSphere) { int nFaces, i, j; tOOF_vector *buf [2]; if (gameData.render.sphere.nFaceNodes == 3) { nFaces = 8; j = 6; } else { nFaces = 6; j = 4; } for (i = 0; i < gameData.render.sphere.nTessDepth; i++) nFaces *= j; for (i = 0; i < 2; i++) { if (!(buf [i] = (tOOF_vector *) d_malloc (nFaces * (gameData.render.sphere.nFaceNodes + 1) * sizeof (tOOF_vector)))) { if (i) d_free (buf [i - 1]); return -1; } } j = (gameData.render.sphere.nFaceNodes == 3) ? BuildSphereTri ((tOOF_triangle **) buf, &nFaces) : BuildSphereQuad ((tOOF_quad **) buf, &nFaces); d_free (buf [!j]); *pSphere = buf [j]; return nFaces; }
void align_polygon_model_data(polymodel *pm) { int i, chunk_len; int total_correction = 0; ubyte *cur_old, *cur_new; chunk cur_ch; chunk ch_list[MAX_CHUNKS]; int no_chunks = 0; int tmp_size = pm->model_data_size + SHIFT_SPACE; ubyte *tmp = d_malloc(tmp_size); // where we build the aligned version of pm->model_data Assert(tmp != NULL); //start with first chunk (is always aligned!) cur_old = pm->model_data; cur_new = tmp; chunk_len = get_chunks(cur_old, cur_new, ch_list, &no_chunks); memcpy(cur_new, cur_old, chunk_len); while (no_chunks > 0) { int first_index = get_first_chunks_index(ch_list, no_chunks); cur_ch = ch_list[first_index]; // remove first chunk from array: no_chunks--; for (i = first_index; i < no_chunks; i++) ch_list[i] = ch_list[i + 1]; // if (new) address unaligned: if ((u_int32_t)new_dest(cur_ch) % 4L != 0) { // calculate how much to move to be aligned short to_shift = 4 - (u_int32_t)new_dest(cur_ch) % 4L; // correct chunks' addresses cur_ch.correction += to_shift; for (i = 0; i < no_chunks; i++) ch_list[i].correction += to_shift; total_correction += to_shift; Assert((u_int32_t)new_dest(cur_ch) % 4L == 0); Assert(total_correction <= SHIFT_SPACE); // if you get this, increase SHIFT_SPACE } //write (corrected) chunk for current chunk: *((short *)(cur_ch.new_base + cur_ch.offset)) = INTEL_SHORT(cur_ch.correction + INTEL_SHORT(*((short *)(cur_ch.old_base + cur_ch.offset)))); //write (correctly aligned) chunk: cur_old = old_dest(cur_ch); cur_new = new_dest(cur_ch); chunk_len = get_chunks(cur_old, cur_new, ch_list, &no_chunks); memcpy(cur_new, cur_old, chunk_len); //correct submodel_ptr's for pm, too for (i = 0; i < MAX_SUBMODELS; i++) if (pm->model_data + pm->submodel_ptrs[i] >= cur_old && pm->model_data + pm->submodel_ptrs[i] < cur_old + chunk_len) pm->submodel_ptrs[i] += (cur_new - tmp) - (cur_old - pm->model_data); } d_free(pm->model_data); pm->model_data_size += total_correction; pm->model_data = d_malloc(pm->model_data_size); Assert(pm->model_data != NULL); memcpy(pm->model_data, tmp, pm->model_data_size); d_free(tmp); }
void hmp_close(hmp_file *hmp) { int i; for (i = 0; i < hmp->num_trks; i++) if (hmp->trks[i].data) d_free(hmp->trks[i].data); d_free(hmp); }
static void mve_audio_callback(void *userdata, unsigned char *stream, int len) { int total=0; int length; if (mve_audio_bufhead == mve_audio_buftail) return /* 0 */; //fprintf(stderr, "+ <%d (%d), %d, %d>\n", mve_audio_bufhead, mve_audio_curbuf_curpos, mve_audio_buftail, len); while (mve_audio_bufhead != mve_audio_buftail /* while we have more buffers */ && len > (mve_audio_buflens[mve_audio_bufhead]-mve_audio_curbuf_curpos)) /* and while we need more data */ { length = mve_audio_buflens[mve_audio_bufhead]-mve_audio_curbuf_curpos; memcpy(stream, /* cur output position */ ((unsigned char *)mve_audio_buffers[mve_audio_bufhead])+mve_audio_curbuf_curpos, /* cur input position */ length); /* cur input length */ total += length; stream += length; /* advance output */ len -= length; /* decrement avail ospace */ d_free(mve_audio_buffers[mve_audio_bufhead]); /* free the buffer */ mve_audio_buffers[mve_audio_bufhead]=NULL; /* free the buffer */ mve_audio_buflens[mve_audio_bufhead]=0; /* free the buffer */ if (++mve_audio_bufhead == TOTAL_AUDIO_BUFFERS) /* next buffer */ mve_audio_bufhead = 0; mve_audio_curbuf_curpos = 0; } //fprintf(stderr, "= <%d (%d), %d, %d>: %d\n", mve_audio_bufhead, mve_audio_curbuf_curpos, mve_audio_buftail, len, total); /* return total; */ if (len != 0 /* ospace remaining */ && mve_audio_bufhead != mve_audio_buftail) /* buffers remaining */ { memcpy(stream, /* dest */ ((unsigned char *)mve_audio_buffers[mve_audio_bufhead]) + mve_audio_curbuf_curpos, /* src */ len); /* length */ mve_audio_curbuf_curpos += len; /* advance input */ stream += len; /* advance output (unnecessary) */ len -= len; /* advance output (unnecessary) */ if (mve_audio_curbuf_curpos >= mve_audio_buflens[mve_audio_bufhead]) /* if this ends the current chunk */ { d_free(mve_audio_buffers[mve_audio_bufhead]); /* free buffer */ mve_audio_buffers[mve_audio_bufhead]=NULL; mve_audio_buflens[mve_audio_bufhead]=0; if (++mve_audio_bufhead == TOTAL_AUDIO_BUFFERS) /* next buffer */ mve_audio_bufhead = 0; mve_audio_curbuf_curpos = 0; } } //fprintf(stderr, "- <%d (%d), %d, %d>\n", mve_audio_bufhead, mve_audio_curbuf_curpos, mve_audio_buftail, len); }
/* * Add archives to the game. * 1) archives from Sharepath/Data to extend/replace builtin game content * 2) archived demos */ void PHYSFSX_addArchiveContent() { char **list = NULL; static const char *const archive_exts[] = { ".zip", ".7z", NULL }; char *file[2]; int i = 0, content_updated = 0; con_printf(CON_DEBUG, "PHYSFS: Adding archives to the game.\n"); // find files in Searchpath ... list = PHYSFSX_findFiles("", archive_exts); // if found, add them... for (i = 0; list[i] != NULL; i++) { MALLOC(file[0], char, PATH_MAX); MALLOC(file[1], char, PATH_MAX); snprintf(file[0], sizeof(char)*PATH_MAX, "%s", list[i]); PHYSFSX_getRealPath(file[0],file[1]); if (PHYSFS_addToSearchPath(file[1], 0)) { con_printf(CON_DEBUG, "PHYSFS: Added %s to Search Path\n",file[1]); content_updated = 1; } d_free(file[0]); d_free(file[1]); } PHYSFS_freeList(list); list = NULL; #if PHYSFS_VER_MAJOR >= 2 // find files in DEMO_DIR ... list = PHYSFSX_findFiles(DEMO_DIR, archive_exts); // if found, add them... for (i = 0; list[i] != NULL; i++) { MALLOC(file[0], char, PATH_MAX); MALLOC(file[1], char, PATH_MAX); snprintf(file[0], sizeof(char)*PATH_MAX, "%s%s", DEMO_DIR, list[i]); PHYSFSX_getRealPath(file[0],file[1]); if (PHYSFS_mount(file[1], DEMO_DIR, 0)) { con_printf(CON_DEBUG, "PHYSFS: Added %s to %s\n",file[1], DEMO_DIR); content_updated = 1; } d_free(file[0]); d_free(file[1]); } PHYSFS_freeList(list); list = NULL; #endif if (content_updated) { con_printf(CON_DEBUG, "Game content updated!\n"); PHYSFSX_listSearchPathContent(); } }
void joy_close() { SDL_JoystickClose(SDL_Joysticks[num_joysticks].handle); while (Joystick.n_axes--) d_free(joyaxis_text[Joystick.n_axes]); while (Joystick.n_buttons--) d_free(joybutton_text[Joystick.n_buttons]); }
static void free_mission_list(mle *mission_list) { int i; for (i = 0; i < num_missions; i++) d_free(mission_list[i].path); d_free(mission_list); num_missions = 0; }
void plyr_read_stats_v(int *k, int *d){ char filename[PATH_MAX]; int k1=-1,k2=0,d1=-1,d2=0; PHYSFS_file *f; *k=0;*d=0;//in case the file doesn't exist. memset(filename, '\0', PATH_MAX); snprintf(filename,PATH_MAX,GameArg.SysUsePlayersDir?"Players/%s.eff":"%s.eff",Players[Player_num].callsign); f = PHYSFSX_openReadBuffered(filename); if(f) { char line[256],*word; if(!PHYSFS_eof(f)) { PHYSFSX_fgets(line,50,f); word=splitword(line,':'); if(!strcmp(word,"kills")) *k=atoi(line); d_free(word); } if(!PHYSFS_eof(f)) { PHYSFSX_fgets(line,50,f); word=splitword(line,':'); if(!strcmp(word,"deaths")) *d=atoi(line); d_free(word); } if(!PHYSFS_eof(f)) { PHYSFSX_fgets(line,50,f); word=splitword(line,':'); if(!strcmp(word,"key") && strlen(line)>10){ unsigned char *p; if (line[0]=='0' && line[1]=='1'){ if ((p=decode_stat((unsigned char*)line+3,&k1,effcode1))&& (p=decode_stat(p+1,&k2,effcode2))&& (p=decode_stat(p+1,&d1,effcode3))){ decode_stat(p+1,&d2,effcode4); } } } d_free(word); } if (k1!=k2 || k1!=*k || d1!=d2 || d1!=*d) { *k=0;*d=0; } } if(f) PHYSFS_close(f); }
//writes out an uncompressed RGB .tga file //if we got really spiffy, we could optionally link in libpng or something, and use that. void write_bmp(char *savename,int w,int h,unsigned char *buf) { PHYSFS_file* TGAFile; TGA_header TGA; GLbyte HeightH,HeightL,WidthH,WidthL; unsigned int pixel; unsigned char *rgbaBuf; buf = (unsigned char*)d_calloc(w*h*4,sizeof(unsigned char)); rgbaBuf = (unsigned char*) d_calloc(w * h * 4, sizeof(unsigned char)); glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, rgbaBuf); for(pixel = 0; pixel < w * h; pixel++) { *(buf + pixel * 3) = *(rgbaBuf + pixel * 4 + 2); *(buf + pixel * 3 + 1) = *(rgbaBuf + pixel * 4 + 1); *(buf + pixel * 3 + 2) = *(rgbaBuf + pixel * 4); } d_free(rgbaBuf); if (!(TGAFile = PHYSFSX_openWriteBuffered(savename))) { con_printf(CON_URGENT,"Could not create TGA file to dump screenshot!"); d_free(buf); return; } HeightH = (GLbyte)(h / 256); HeightL = (GLbyte)(h % 256); WidthH = (GLbyte)(w / 256); WidthL = (GLbyte)(w % 256); // Write TGA Header TGA.TGAheader[0] = 0; TGA.TGAheader[1] = 0; TGA.TGAheader[2] = 2; TGA.TGAheader[3] = 0; TGA.TGAheader[4] = 0; TGA.TGAheader[5] = 0; TGA.TGAheader[6] = 0; TGA.TGAheader[7] = 0; TGA.TGAheader[8] = 0; TGA.TGAheader[9] = 0; TGA.TGAheader[10] = 0; TGA.TGAheader[11] = 0; TGA.header[0] = (GLbyte) WidthL; TGA.header[1] = (GLbyte) WidthH; TGA.header[2] = (GLbyte) HeightL; TGA.header[3] = (GLbyte) HeightH; TGA.header[4] = (GLbyte) 24; TGA.header[5] = 0; PHYSFS_write(TGAFile,&TGA,sizeof(TGA_header),1); PHYSFS_write(TGAFile,buf,w*h*3*sizeof(unsigned char),1); PHYSFS_close(TGAFile); d_free(buf); }
/********************************************************************** * * free_posmem * * Frees memory, that is not needed to create transition table. */ static void free_posmem(void) { REG1 int i; REG2 node_t* tnode = &rbuf.tree[rbuf.root]; d_free(&tnode->lastpos); --tnode; for (i = rbuf.root-1; i-- >= 0; tnode--) { d_free(&tnode->firstpos); d_free(&tnode->lastpos); } }
void LoadTerrain (char *filename) { grs_bitmap bmHeight; int iff_error; int i, j; ubyte h, hMin, hMax; LogErr (" loading terrain height map\n"); iff_error = iff_read_bitmap (filename, &bmHeight, BM_LINEAR); if (iff_error != IFF_NO_ERROR) { #if TRACE con_printf (1, "File %s - IFF error: %s", filename, iff_errormsg (iff_error)); #endif Error ("File %s - IFF error: %s", filename, iff_errormsg (iff_error)); } if (gameData.render.terrain.pHeightMap) d_free (gameData.render.terrain.pHeightMap) else atexit (FreeTerrainHeightMap); //first time gameData.render.terrain.nGridW = bmHeight.bm_props.w; gameData.render.terrain.nGridH = bmHeight.bm_props.h; Assert (gameData.render.terrain.nGridW <= TERRAIN_GRID_MAX_SIZE); Assert (gameData.render.terrain.nGridH <= TERRAIN_GRID_MAX_SIZE); gameData.render.terrain.pHeightMap = bmHeight.bm_texBuf; hMax = 0; hMin = 255; for (i = 0; i < gameData.render.terrain.nGridW; i++) for (j = 0; j < gameData.render.terrain.nGridH; j++) { h = HEIGHT (i, j); if (h > hMax) hMax = h; if (h < hMin) hMin = h; } for (i = 0; i < gameData.render.terrain.nGridW; i++) { for (j = 0; j < gameData.render.terrain.nGridH; j++) { HEIGHT (i, j) -= hMin; } } // d_free (bmHeight.bm_texBuf); gameData.render.terrain.bmP = gameData.endLevel.terrain.bmP; #if 0 //the following code turns the (palettized) terrain texture into a white TGA texture for testing gameData.render.terrain.bmP->bm_props.rowsize *= 4; gameData.render.terrain.bmP->bm_props.flags |= BM_FLAG_TGA; d_free (gameData.render.terrain.bmP->bm_texBuf); gameData.render.terrain.bmP->bm_texBuf = d_malloc (gameData.render.terrain.bmP->bm_props.h * gameData.render.terrain.bmP->bm_props.rowsize); memset (gameData.render.terrain.bmP->bm_texBuf, 0xFF, gameData.render.terrain.bmP->bm_props.h * gameData.render.terrain.bmP->bm_props.rowsize); #endif LogErr (" building terrain light map\n"); BuildTerrainLightMap (); }
void ui_pad_close() { int i, j; for (i=0; i< MAX_NUM_PADS; i++ ) if (KeyPad[i]) { for (j=0; j<17; j++ ) d_free(KeyPad[i]->buttontext[j]); d_free( KeyPad[i] ); KeyPad[i] = NULL; } }
void ui_gadget_delete_all( UI_WINDOW * wnd ) { UI_GADGET * tmp; while( wnd->gadget != NULL ) { tmp = wnd->gadget; if (tmp->next == tmp ) { wnd->gadget = NULL; } else { tmp->next->prev = tmp->prev; tmp->prev->next = tmp->next; wnd->gadget = tmp->next; } if (tmp->canvas) gr_free_sub_canvas( tmp->canvas ); if (tmp->kind == 1 ) // Button { UI_GADGET_BUTTON * but1 = (UI_GADGET_BUTTON *)tmp; if (but1->text) d_free( but1->text ); } if (tmp->kind == 6 ) // Inputbox { UI_GADGET_INPUTBOX * but1 = (UI_GADGET_INPUTBOX *)tmp; d_free( but1->text ); } if (tmp->kind == 5 ) // Checkbox { UI_GADGET_CHECKBOX * but1 = (UI_GADGET_CHECKBOX *)tmp; d_free( but1->text ); } if (tmp->kind == 9 ) // Icon { UI_GADGET_ICON * but1 = (UI_GADGET_ICON *)tmp; d_free( but1->text ); } d_free( tmp ); } }
void seq_close() { SEQ_DUMPBUF(); ioctl(seqfd,SNDCTL_SEQ_SYNC); close(seqfd); d_free(voices); }
int do_game_pause() { char *msg; char total_time[9],level_time[9]; #ifdef NETWORK if (Game_mode & GM_MULTI) { netplayerinfo_on= !netplayerinfo_on; return(KEY_PAUSE); } #endif MALLOC(msg, char, 1024); if (!msg) return 0; songs_pause(); format_time(total_time, f2i(Players[Player_num].time_total) + Players[Player_num].hours_total*3600); format_time(level_time, f2i(Players[Player_num].time_level) + Players[Player_num].hours_level*3600); if (Newdemo_state!=ND_STATE_PLAYBACK) snprintf(msg,1024,"PAUSE\n\nSkill level: %s\nHostages on board: %d\nTime on level: %s\nTotal time in game: %s",MENU_DIFFICULTY_TEXT(Difficulty_level),Players[Player_num].hostages_on_board,level_time,total_time); else snprintf(msg,1024,"PAUSE\n\nSkill level: %s\nHostages on board: %d\n",MENU_DIFFICULTY_TEXT(Difficulty_level),Players[Player_num].hostages_on_board); set_screen_mode(SCREEN_MENU); if (!window_create(&grd_curscreen->sc_canvas, 0, 0, SWIDTH, SHEIGHT, (int (*)(window *, d_event *, void *))pause_handler, msg)) d_free(msg); return 0 /*key*/; // Keycode returning ripped out (kreatordxx) }
void _CDECL_ FreeTerrainLightMap () { if (gameData.render.terrain.pLightMap) { LogErr ("unloading terrain light map\n"); d_free (gameData.render.terrain.pLightMap); } }
void _CDECL_ FreeTerrainHeightMap (void) { if (gameData.render.terrain.pHeightMap) { LogErr ("unloading terrain height map\n"); d_free (gameData.render.terrain.pHeightMap); } }
void medkey_init() { PHYSFS_file * keyfile; char keypress[100]; char line_buffer[200]; int key; int i; //, size; int np; char * LispCommand; MALLOC( LispCommand, char, DIAGNOSTIC_MESSAGE_MAX ); for (i=0; i<2048; i++ ) KeyFunction[i] = NULL; keyfile = PHYSFSX_openReadBuffered( "GLOBAL.KEY" ); if (keyfile) { while (PHYSFSX_fgets(line_buffer, 200, keyfile)) { sscanf(line_buffer, " %s %s ", keypress, LispCommand); //ReadLispMacro( keyfile, LispCommand ); if ( (key=DecodeKeyText( keypress ))!= -1 ) { Assert( key < 2048); KeyFunction[key] = func_get( LispCommand, &np ); } else { Error( "Bad key %s in GLOBAL.KEY!", keypress ); } } PHYSFS_close(keyfile); } d_free( LispCommand ); }
void free_mission(void) { // May become more complex with the editor if (Current_mission) { if (!PLAYING_BUILTIN_MISSION) { char hogpath[PATH_MAX]; sprintf(hogpath, MISSION_DIR "%s.hog", Current_mission->path); PHYSFSX_contfile_close(hogpath); } d_free(Current_mission->path); d_free(Current_mission); } }
void medkey_init() { FILE * keyfile; char keypress[100]; int key; int i; //, size; int np; char * LispCommand; MALLOC( LispCommand, char, DIAGNOSTIC_MESSAGE_MAX ); for (i=0; i<2048; i++ ) KeyFunction[i] = NULL; keyfile = fopen( "GLOBAL.KEY", "rt" ); if (keyfile) { while (fscanf( keyfile, " %s %s ", keypress, LispCommand ) != EOF ) { //ReadLispMacro( keyfile, LispCommand ); if ( (key=DecodeKeyText( keypress ))!= -1 ) { Assert( key < 2048); KeyFunction[key] = func_get( LispCommand, &np ); } else { Error( "Bad key %s in GLOBAL.KEY!", keypress ); } } fclose(keyfile); } d_free( LispCommand ); }
void DestroySphere (tSphereData *sdP) { if (sdP) { d_free (sdP->pSphere); sdP->nFaces = 0; } }
int DigiSpeedupSound (digi_sound *gsp, struct sound_slot *ssp, int speed) { int h, i, j, l; ubyte *pDest, *pSrc; l = FixMulDiv (ssp->bResampled ? ssp->length : gsp->length, speed, F1_0); if (!(pDest = (ubyte *) d_malloc (l))) return -1; pSrc = ssp->bResampled ? ssp->samples : gsp->data; for (h = i = j = 0; i < l; i++) { pDest [j] = pSrc [i]; h += speed; while (h >= F1_0) { j++; h -= F1_0; } } if (ssp->bResampled) { d_free (ssp->samples); } else ssp->bResampled = 1; ssp->samples = pDest; return ssp->length = j; }
int hashtable_init( hashtable *ht, int size ) { int i; ht->size=0; for (i=1; i<13; i++ ) { if ( (1<<i) >= size ) { ht->bitsize = i; ht->size = 1<<i; break; } } size = ht->size; ht->and_mask = ht->size - 1; if (ht->size==0) Error( "Hashtable has size of 0" ); ht->key = d_malloc( size * sizeof(char *) ); if (ht->key==NULL) Error( "Not enough memory to create a hash table of size %d", size ); for (i=0; i<size; i++ ) ht->key[i] = NULL; // Use calloc cause we want zero'd array. ht->value = d_malloc( size*sizeof(int) ); if (ht->value==NULL) { d_free(ht->key); Error( "Not enough memory to create a hash table of size %d\n", size ); } ht->nitems = 0; return 0; }
/* * dput() * * This is complicated by the fact that we do not want to put * dentries that are no longer on any hash chain on the unused * list: we'd much rather just get rid of them immediately. * * However, that implies that we have to traverse the dentry * tree upwards to the parents which might _also_ now be * scheduled for deletion (it may have been only waiting for * its last child to go away). * * This tail recursion is done by hand as we don't want to depend * on the compiler to always get this right (gcc generally doesn't). * Real recursion would eat up our stack space. */ void dput(struct dentry *dentry) { int count; if (!dentry) return; repeat: count = dentry->d_count - 1; if (count != 0) goto out; /* * Note that if d_op->d_delete blocks, * the dentry could go back in use. * Each fs will have to watch for this. */ if (dentry->d_op && dentry->d_op->d_delete) { dentry->d_op->d_delete(dentry); count = dentry->d_count - 1; if (count != 0) goto out; } if (!list_empty(&dentry->d_lru)) { dentry_stat.nr_unused--; list_del(&dentry->d_lru); } if (list_empty(&dentry->d_hash)) { struct dentry * parent; list_del(&dentry->d_child); dentry_iput(dentry); parent = dentry->d_parent; d_free(dentry); if (dentry == parent) return; dentry = parent; goto repeat; } list_add(&dentry->d_lru, &dentry_unused); dentry_stat.nr_unused++; /* * Update the timestamp */ dentry->d_reftime = jiffies; out: if (count >= 0) { dentry->d_count = count; return; } printk(KERN_CRIT "Negative d_count (%d) for %s/%s\n", count, dentry->d_parent->d_name.name, dentry->d_name.name); *(int *)0 = 0; }