static inline list forward1(list t, int n) { static bucket b[CHARS]; /* buckets */ group g, g2; /* groups */ int pos = 0; /* pos in string */ if (n<2) return t; initmem(groupmem, sizeof(struct grouprec), n/15); initmem(bucketmem, sizeof(struct bucketrec), n/5); /* We use a dummy group g as the header of the group data structure. It does not contain any elements, but only a pointer to the first unfinished group. */ g = (group) allocmem(groupmem, sizeof(struct grouprec)); g2 = (group) allocmem(groupmem, sizeof(struct grouprec)); g->next = g->nextunf = g2; g2->head = t; g2->next = g2->nextunf = NULL; g2->finis = FALSE; intobuckets(g, b, pos); while (g->nextunf) { pos++; intogroups(b, pos); intobuckets(g, b, pos); } t = collect(g); freemem(bucketmem); freemem(groupmem); return t; }
int rom_load() { FILE *f; byte c, header[16384]; if (strcmp(romfile, "-")) f = fopen(romfile, "rb"); else f = stdin; if (!f) die("cannot open rom file: %s\n", romfile); memset(header, 0xff, 16384); fread(header, 16384, 1, f); strncpy(rom.name, header+0x0134, 16); if (rom.name[14] & 0x80) rom.name[14] = 0; if (rom.name[15] & 0x80) rom.name[15] = 0; rom.name[16] = 0; c = header[0x0147]; mbc.type = mbc_table[c]; mbc.batt = (batt_table[c] && !nobatt) || forcebatt; rtc.batt = rtc_table[c]; mbc.romsize = romsize_table[header[0x0148]]; mbc.ramsize = ramsize_table[header[0x0149]]; if (!mbc.romsize) die("unknown ROM size %02X\n", header[0x0148]); if (!mbc.ramsize) die("unknown SRAM size %02X\n", header[0x0149]); rom.bank = malloc(16384 * mbc.romsize); memset(rom.bank, 0xff, 16384 * mbc.romsize); memcpy(rom.bank, header, 16384); fread(rom.bank+1, 16384, mbc.romsize-1, f); ram.sbank = malloc(8192 * mbc.ramsize); if (!ram.loaded) /* just in case... */ initmem(ram.sbank, 8192 * mbc.ramsize); initmem(ram.ibank, 4096 * 8); /* initmem(ram.hi, 256); */ mbc.rombank = 1; mbc.rambank = 0; c = header[0x0143]; hw.cgb = ((c == 0x80) || (c == 0xc0)) && !forcedmg; if (strcmp(romfile, "-")) fclose(f); return 0; }
int rom_load() { FILE *f; byte c, *data, *header; int len = 0, rlen; if (strcmp(romfile, "-")) f = fopen(romfile, "rb"); else f = stdin; if (!f) die("cannot open rom file: %s\n", romfile); data = loadfile(f, &len); header = data = decompress(data, &len); memcpy(rom.name, header+0x0134, 16); if (rom.name[14] & 0x80) rom.name[14] = 0; if (rom.name[15] & 0x80) rom.name[15] = 0; rom.name[16] = 0; c = header[0x0147]; mbc.type = mbc_table[c]; mbc.batt = (batt_table[c] && !nobatt) || forcebatt; rtc.batt = rtc_table[c]; mbc.romsize = romsize_table[header[0x0148]]; mbc.ramsize = ramsize_table[header[0x0149]]; if (!mbc.romsize) die("unknown ROM size %02X\n", header[0x0148]); if (!mbc.ramsize) die("unknown SRAM size %02X\n", header[0x0149]); rlen = 16384 * mbc.romsize; rom.bank = realloc(data, rlen); if (rlen > len) memset(rom.bank[0]+len, 0xff, rlen - len); ram.sbank = malloc(8192 * mbc.ramsize); initmem(ram.sbank, 8192 * mbc.ramsize); initmem(ram.ibank, 4096 * 8); mbc.rombank = 1; mbc.rambank = 0; c = header[0x0143]; hw.cgb = ((c == 0x80) || (c == 0xc0)) && !forcedmg; hw.gba = (hw.cgb && gbamode); if (strcmp(romfile, "-")) fclose(f); return 0; }
int rom_load(const char *romfile) { byte c, *data, *header; int len = 0, rlen; header = data = loadfile(romfile, &len); if (data == NULL) return 0; memcpy(rom.name, header+0x0134, 16); if (rom.name[14] & 0x80) rom.name[14] = 0; if (rom.name[15] & 0x80) rom.name[15] = 0; rom.name[16] = 0; c = header[0x0147]; mbc.type = mbc_table[c]; mbc.batt = (batt_table[c] && !nobatt) || forcebatt; rtc.batt = rtc_table[c]; mbc.romsize = romsize_table[header[0x0148]]; mbc.ramsize = ramsize_table[header[0x0149]]; if (!mbc.romsize) { die("unknown ROM size %02X\n", header[0x0148]); free(data); return 0; } if (!mbc.ramsize) { die("unknown SRAM size %02X\n", header[0x0149]); free(data); return 0; } rlen = 16384 * mbc.romsize; rom.bank = (void *)data; ram.sbank = malloc(8192 * mbc.ramsize); initmem(ram.sbank, 8192 * mbc.ramsize); initmem(ram.ibank, 4096 * 8); mbc.rombank = 1; mbc.rambank = 0; c = header[0x0143]; hw.cgb = ((c == 0x80) || (c == 0xc0)) && !forcedmg; hw.gba = (hw.cgb && gbamode); return 1; }
/* Use this function to see what happens when your malloc and free * implementations are called. Run "mem -try <args>" to call this function. * We have given you a simple example to start. */ void try_mymem(int argc, char **argv) { strategies strat; void *a, *b, *c, *d, *e; if(argc > 1) strat = strategyFromString(argv[1]); else strat = First; /* A simple example. Each algorithm should produce a different layout. */ initmem(strat,500); a = mymalloc(100); b = mymalloc(100); c = mymalloc(100); myfree(b); d = mymalloc(50); myfree(a); e = mymalloc(25); print_memory(); print_memory_status(); }
static inline list MSD(list a, int n) { list res = NULL; stack *s; if (n < 2) return a; initmem(stackmem, sizeof(struct stackrec), n/50); push(a, NULL, n, 0); while (!stackempty()) { s = pop(); if (!s->size) { /* finished */ s->tail->next = res; res = s->head; continue; } if (s->size <= BYTE_BREAK) onebyte(s->head, s->pos); else twobytes(s->head, s->pos); } freemem(stackmem); return res; }
bfl_t sys$bfl_new(vms$pointer size) { bfl_t bfl; vms$pointer array_size; vms$pointer i; array_size = (size / BITS_PER_BFL_WORD) + 1; // Allocate enough space for the header and the bit array needed if ((bfl = (bfl_t) sys$alloc(sizeof(struct bfl) + (array_size) * sizeof(bfl_word))) == NULL) { return(NULL); } bfl->curpos = 0; bfl->len = array_size; // Set all as allocated sys$initmem((vms$pointer) bfl->bitarray, array_size * sizeof(bfl_word)); // Now free the ones we have // FIXME: This is a terribly ineffecient way to do this for(i = 0; i < size; i++) { sys$bfl_free(bfl, i); } return(bfl); }
int rom_load() { FILE *f=NULL; byte c, *header; int len = 0, rlen; f = fopen(romfile, "rb"); if (!f) die("cannot open rom file: %s\n", romfile); rom.bank = header = loadfile(f, &len); fclose(f); memcpy(rom.name, header+0x0134, 16); if (rom.name[14] & 0x80) rom.name[14] = 0; if (rom.name[15] & 0x80) rom.name[15] = 0; rom.name[16] = 0; c = header[0x0147]; mbc.type = mbc_table[c]; mbc.batt = (batt_table[c] && !nobatt) || forcebatt; rtc.batt = rtc_table[c]; mbc.romsize = romsize_table[header[0x0148]]; mbc.ramsize = ramsize_table[header[0x0149]]; if (!mbc.romsize) die("unknown ROM size %02X\n", header[0x0148]); if (!mbc.ramsize) die("unknown SRAM size %02X\n", header[0x0149]); ram.sbank = malloc(8192 * mbc.ramsize); ram.ibank = malloc(4096 * 8); initmem(ram.sbank, 8192 * mbc.ramsize); initmem(ram.ibank, 4096 * 8); mbc.rombank = 1; mbc.rambank = 0; c = header[0x0143]; hw.cgb = ((c == 0x80) || (c == 0xc0)) && !forcedmg; hw.gba = (hw.cgb && gbamode); return 0; }
sys$new_quota(void) { struct quota *q; if ((q = (struct quota *) sys$alloc(sizeof(struct quota))) == NULL) { return(NULL); } sys$initmem((vms$pointer) q, sizeof(struct quota)); return(q); }
/* basic sequential allocation of single byte blocks */ int test_alloc_1(int argc, char **argv) { strategies strategy; int lbound = 1; int ubound = 4; if (strategyFromString(*(argv+1))>0) lbound=ubound=strategyFromString(*(argv+1)); for (strategy = lbound; strategy <= ubound; strategy++) { int correct_holes = 0; int correct_alloc = 100; int correct_largest_free = 0; int i; void* lastPointer = NULL; initmem(strategy,100); for (i = 0; i < 100; i++) { void* pointer = mymalloc(1); if ( i > 0 && pointer != (lastPointer+1) ) { printf("Allocation with %s was not sequential at %i; expected %p, actual %p\n", strategy_name(strategy), i,lastPointer+1,pointer); return 1; } lastPointer = pointer; } if (mem_holes() != correct_holes) { printf("Holes not counted as %d with %s\n", correct_holes, strategy_name(strategy)); return 1; } if (mem_allocated() != correct_alloc) { printf("Allocated memory not reported as %d with %s\n", correct_alloc, strategy_name(strategy)); return 1; } if (mem_largest_free() != correct_largest_free) { printf("Largest memory block free not reported as %d with %s\n", correct_largest_free, strategy_name(strategy)); return 1; } } return 0; }
void init() { cl_uint n; cl_platform_id *ids,id=NULL; int i,status; char s[MAXCHAR]; /* choose AMD platform if possible, otherwise just pick one */ if(CL_SUCCESS!=clGetPlatformIDs(0,NULL,&n)) error("error getting platforms 1"); if(NULL==(ids=malloc(sizeof(cl_platform_id)*n))) error("out of memory"); if(CL_SUCCESS!=clGetPlatformIDs(n,ids,NULL)) error("error getting platforms 2"); for(i=0;i<n;i++) { if(CL_SUCCESS!=clGetPlatformInfo(ids[i],CL_PLATFORM_VENDOR,MAXCHAR,s,NULL)) error("error getting platform 3"); if(!strcmp(s,"Advanced Micro Devices, Inc.")) { id=ids[i]; break; } } if(i==n) id=ids[0]; free(ids); /* get context stuff */ cl_context_properties cps[3]={CL_CONTEXT_PLATFORM,(cl_context_properties)id,0}; context=clCreateContextFromType(cps,CL_DEVICE_TYPE_CPU,NULL,NULL,&status); if(CL_SUCCESS!=status) error("couldn't create context"); if(CL_SUCCESS!=clGetContextInfo(context,CL_CONTEXT_DEVICES,0,NULL,(size_t *)&n)) error("error getting context info 1"); if(!n) error("no devices!"); if(NULL==(devices=malloc(n))) error("out of memory"); if(CL_SUCCESS!=clGetContextInfo(context,CL_CONTEXT_DEVICES,n,devices,NULL)) error("error getting context info 2"); /* create opencl command queue */ cmdq=clCreateCommandQueue(context,devices[0],0,&status); if(CL_SUCCESS!=status) error("error creating command queue"); /* create memory buffers */ initmem(); /* copy contents of in to inbuffer */ inbuffer=clCreateBuffer(context,CL_MEM_READ_WRITE|CL_MEM_USE_HOST_PTR, MAXP,in,&status); if(CL_SUCCESS!=status) { printf("max alloc %d\n",(int)CL_DEVICE_MAX_MEM_ALLOC_SIZE); printf("status %d\n",status); error("error creating input buffer"); } loadkernel("sieve.cl"); }
void newmem(long newval) { unsigned long maxptrs0=maxptrs; void** ptr0=ptr; boolean* marked0=marked; /* handles for old values */ /* <lie-py> */ unsigned int* pyobj0=pyobj; /* </lie-py> */ if ((maxptrs=newval)<=GCCRIT) { maxptrs=maxptrs0; error("You can't lower maxobjects from %ld to %ld.\n" ,(long)maxptrs,(long)newval); } initmem(); { long k; for (k=0; k<maxptrs0; k++) if (ptr0[k]!=NULL) /* copy all non-null pointers */ { long h; { long i; h=hash(ptr0[k]); for (i=0; i<maxptrs; i++) /* find an empty slot; try |maxptrs| times */ if (ptr[h]==NULL) break; /* found */ else if (++h>=maxptrs) h=0; /* try next slot, wrapping around */ if (i==maxptrs) { free(ptr); ptr=ptr0; free(marked); marked=marked0; maxptrs=maxptrs0; /* reset to old values */ error("You currently cannot decrease 'maxobjects' below %ld.\n" ,chunks); } } ptr[h]=ptr0[k]; /* copy pointer to empty slot */ marked[h]=false; /* make new pointer unmarked */ /* <lie-py> */ if (pyobj0[k]) { pyobj[h]=pyobj0[k]; } /* </lie-py> */ } } if (!redirected_input) Printf("New object table of size %ld.\n",(long)maxptrs); free(ptr0); free(marked0); /* release the old tables */ /* <lie-py> */ free(pyobj0); /* </lie-py> */ }
static void rmfram(void) { Type *t; Frame *f; uchar *nsp; t = (Type*)R.s; if(t == H) error(exModule); nsp = R.SP + t->size; if(nsp >= R.TS) { R.s = t; extend(); T(d) = R.s; return; } f = (Frame*)R.SP; R.SP = nsp; f->t = t; f->mr = nil; initmem(t, f); T(d) = f; }
/* performs a randomized test: totalSize == the total size of the memory pool, as passed to initmem2 totalSize must be less than 10,000 * minBlockSize fillRatio == when the allocated memory is >= fillRatio * totalSize, a block is freed; otherwise, a new block is allocated. If a block cannot be allocated, this is tallied and a random block is freed immediately thereafter in the next iteration minBlockSize, maxBlockSize == size for allocated blocks is picked uniformly at random between these two numbers, inclusive */ void do_randomized_test(int strategyToUse, int totalSize, float fillRatio, int minBlockSize, int maxBlockSize, int iterations) { void * pointers[10000]; int storedPointers = 0; int strategy; int lbound = 1; int ubound = 4; int smallBlockSize = maxBlockSize/10; if (strategyToUse>0) lbound=ubound=strategyToUse; FILE *log; log = fopen("tests.log","a"); if(log == NULL) { perror("Can't append to log file.\n"); return; } fprintf(log,"Running randomized tests: pool size == %d, fill ratio == %f, block size is from %d to %d, %d iterations\n",totalSize,fillRatio,minBlockSize,maxBlockSize,iterations); fclose(log); for (strategy = lbound; strategy <= ubound; strategy++) { double sum_largest_free = 0; double sum_hole_size = 0; double sum_allocated = 0; int failed_allocations = 0; double sum_small = 0; struct timespec execstart, execend; int force_free = 0; int i; storedPointers = 0; initmem(strategy,totalSize); #ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time clock_serv_t cclock; mach_timespec_t mts; host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock); clock_get_time(cclock, &mts); mach_port_deallocate(mach_task_self(), cclock); execstart.tv_sec = mts.tv_sec; execstart.tv_nsec = mts.tv_nsec; #else clock_gettime(CLOCK_REALTIME, &execstart); #endif for (i = 0; i < iterations; i++) { if ( (i % 10000)==0 ) srand ( time(NULL) ); if (!force_free && (mem_free() > (totalSize * (1-fillRatio)))) { int newBlockSize = (rand()%(maxBlockSize-minBlockSize+1))+minBlockSize; /* allocate */ void * pointer = mymalloc(newBlockSize); if (pointer != NULL) pointers[storedPointers++] = pointer; else { failed_allocations++; force_free = 1; } } else { int chosen; void * pointer; /* free */ force_free = 0; if (storedPointers == 0) continue; chosen = rand() % storedPointers; pointer = pointers[chosen]; pointers[chosen] = pointers[storedPointers-1]; storedPointers--; myfree(pointer); } sum_largest_free += mem_largest_free(); sum_hole_size += (mem_free() / mem_holes()); sum_allocated += mem_allocated(); sum_small += mem_small_free(smallBlockSize); } #ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time //clock_serv_t cclock; //mach_timespec_t mts; host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock); clock_get_time(cclock, &mts); mach_port_deallocate(mach_task_self(), cclock); execend.tv_sec = mts.tv_sec; execend.tv_nsec = mts.tv_nsec; #else clock_gettime(CLOCK_REALTIME, &execend); #endif log = fopen("tests.log","a"); if(log == NULL) { perror("Can't append to log file.\n"); return; } fprintf(log,"\t=== %s ===\n",strategy_name(strategy)); fprintf(log,"\tTest took %.2fms.\n", (execend.tv_sec - execstart.tv_sec) * 1000 + (execend.tv_nsec - execstart.tv_nsec) / 1000000.0); fprintf(log,"\tAverage hole size: %f\n",sum_hole_size/iterations); fprintf(log,"\tAverage largest free block: %f\n",sum_largest_free/iterations); fprintf(log,"\tAverage allocated bytes: %f\n",sum_allocated/iterations); fprintf(log,"\tAverage number of small blocks: %f\n",sum_small/iterations); fprintf(log,"\tFailed allocations: %d\n",failed_allocations); fclose(log); } }
/* basic sequential allocation followed by 50 frees */ int test_alloc_3(int argc, char **argv) { strategies strategy; int lbound = 1; int ubound = 4; if (strategyFromString(*(argv+1))>0) lbound=ubound=strategyFromString(*(argv+1)); for (strategy = lbound; strategy <= ubound; strategy++) { int correct_holes = 50; int correct_alloc = 50; int correct_largest_free = 1; int i; void* lastPointer = NULL; initmem(strategy,100); for (i = 0; i < 100; i++) { void* pointer = mymalloc(1); if ( i > 0 && pointer != (lastPointer+1) ) { printf("Allocation with %s was not sequential at %i; expected %p, actual %p\n", strategy_name(strategy), i,lastPointer+1,pointer); return 1; } lastPointer = pointer; } for (i = 1; i < 100; i+= 2) { myfree(mem_pool() + i); } if (mem_holes() != correct_holes) { printf("Holes not counted as %d with %s\n", correct_holes, strategy_name(strategy)); return 1; } if (mem_allocated() != correct_alloc) { printf("Memory not reported as %d with %s\n", correct_alloc, strategy_name(strategy)); return 1; } if (mem_largest_free() != correct_largest_free) { printf("Largest memory block free not reported as %d with %s\n", correct_largest_free, strategy_name(strategy)); return 1; } for(i=0;i<100;i++) { if(mem_is_alloc(mem_pool()+i) == i%2) { printf("Byte %d in memory claims to ",i); if(i%2) printf("not "); printf("be allocated. It should "); if(!i%2) printf("not "); printf("be allocated.\n"); return 1; } } } return 0; }
int rom_load() { int f; byte c, *data, *header; int len = 0, rlen; f = open(romfile, O_RDONLY); if (f<0) { // debug("Retry!"); // f = open(romfile, O_RDONLY); // if (f<0) DIE("cannot open rom file: %s\n", romfile); DIE("cannot open rom file: %s\n", romfile); } else printf("File opened!\n"); data = loadfile(f, &len); printf("Data loaded!\n"); header = data = decompress(data, &len); printf("Data decompressed!\n"); memcpy(rom.name, header+0x0134, 16); if (rom.name[14] & 0x80) rom.name[14] = 0; if (rom.name[15] & 0x80) rom.name[15] = 0; rom.name[16] = 0; c = header[0x0147]; mbc.type = mbc_table[c]; mbc.batt = (batt_table[c] && !nobatt) || forcebatt; rtc.batt = rtc_table[c]; mbc.romsize = romsize_table[header[0x0148]]; mbc.ramsize = ramsize_table[header[0x0149]]; if (!mbc.romsize) DIE("unknown ROM size %02X\n", header[0x0148]); if (!mbc.ramsize) DIE("unknown SRAM size %02X\n", header[0x0149]); rlen = 16384 * mbc.romsize; rom.bank = realloc(data, rlen); if (rlen > len) memset(rom.bank[0]+len, 0xff, rlen - len); ram.sbank = malloc(8192 * mbc.ramsize); initmem(ram.sbank, 8192 * mbc.ramsize); initmem(ram.ibank, 4096 * 8); mbc.rombank = 1; mbc.rambank = 0; c = header[0x0143]; hw.cgb = ((c == 0x80) || (c == 0xc0)) && !forcedmg; hw.gba = (hw.cgb && gbamode); if (strcmp(romfile, "-")) close(f); printf("Rom_load ok!\n"); return 0; }
/* alloc, alloc, free, alloc */ int test_alloc_2(int argc, char **argv) { strategies strategy; int lbound = 1; int ubound = 4; if (strategyFromString(*(argv+1))>0) lbound=ubound=strategyFromString(*(argv+1)); for (strategy = lbound; strategy <= ubound; strategy++) { int correct_holes; int correct_alloc; int correct_largest_free; int correct_small; void* first; void* second; void* third; int correctThird; initmem(strategy,100); first = mymalloc(10); second = mymalloc(1); myfree(first); third = mymalloc(1); if (second != (first+10)) { printf("Second allocation failed; allocated at incorrect offset with strategy %s", strategy_name(strategy)); return 1; } correct_alloc = 2; correct_small = (strategy == First || strategy == Best); switch (strategy) { case Best: correctThird = (third == first); correct_holes = 2; correct_largest_free = 89; break; case Worst: correctThird = (third == second+1); correct_holes = 2; correct_largest_free = 88; break; case First: correctThird = (third == first); correct_holes = 2; correct_largest_free = 89; break; case Next: correctThird = (third == second+1); correct_holes = 2; correct_largest_free = 88; break; case NotSet: break; } if (!correctThird) { printf("Third allocation failed; allocated at incorrect offset with %s", strategy_name(strategy)); return 1; } if (mem_holes() != correct_holes) { printf("Holes counted as %d, should be %d with %s\n", mem_holes(), correct_holes, strategy_name(strategy)); return 1; } if (mem_small_free(9) != correct_small) { printf("Small holes counted as %d, should be %d with %s\n", mem_small_free(9), correct_small, strategy_name(strategy)); return 1; } if (mem_allocated() != correct_alloc) { printf("Memory reported as %d, should be %d with %s\n", mem_allocated(0), correct_alloc, strategy_name(strategy)); return 1; } if (mem_largest_free() != correct_largest_free) { printf("Largest memory block free reported as %d, should be %d with %s\n", mem_largest_free(), correct_largest_free, strategy_name(strategy)); return 1; } } return 0; }
int main() { SDL_Event ev; SDL_MouseButtonEvent *mbev; SDL_MouseMotionEvent *mmev; SDL_Surface *op_surf, *ind_surf, *extra_surf; SDL_Rect op_panel = { 0, 274, 1280, 210 }; SDL_Rect ind_panel = { 0, 64, 1280, 210 }; SDL_Rect extra_panel = { 0, 0, 1280, 210 }; int i; Light *l; Switch *sw; // void testinst(Apr*); // testinst(&apr); if(SDL_Init(SDL_INIT_VIDEO) < 0){ error: fprintf(stderr, "error: %s\n", SDL_GetError()); return 1; } screen = SDL_SetVideoMode(1280, 484, 32, SDL_DOUBLEBUF); if(screen == NULL) goto error; if((IMG_Init(IMG_INIT_PNG) & IMG_INIT_PNG) != IMG_INIT_PNG){ fprintf(stderr, "error: init SDL_Image: %s\n", IMG_GetError()); return 1; } op_surf = IMG_Load("op_panel.png"); if(op_surf == NULL){ fprintf(stderr, "Couldn't load op_panel.png\n"); return 1; } ind_surf = IMG_Load("ind_panel.png"); if(ind_surf == NULL){ fprintf(stderr, "Couldn't load ind_panel.png\n"); return 1; } extra_surf = IMG_Load("extra_panel.png"); if(extra_surf == NULL){ fprintf(stderr, "Couldn't load extra_panel.png\n"); return 1; } keysurf[0] = IMG_Load("key_n.png"); if(keysurf[0] == NULL){ fprintf(stderr, "Couldn't load key_n.png\n"); return 1; } keysurf[1] = IMG_Load("key_d.png"); if(keysurf[1] == NULL){ fprintf(stderr, "Couldn't load key_d.png\n"); return 1; } keysurf[2] = IMG_Load("key_u.png"); if(keysurf[2] == NULL){ fprintf(stderr, "Couldn't load key_u.png\n"); return 1; } lampsurf[0] = IMG_Load("lamp_off.png"); if(lampsurf[0] == NULL){ fprintf(stderr, "Couldn't load lamp_off.png\n"); return 1; } lampsurf[1] = IMG_Load("lamp_on.png"); if(lampsurf[1] == NULL){ fprintf(stderr, "Couldn't load lamp_on.png\n"); return 1; } switchsurf[0] = IMG_Load("switch_d.png"); if(switchsurf[0] == NULL){ fprintf(stderr, "Couldn't load switch_d.png\n"); return 1; } switchsurf[1] = IMG_Load("switch_u.png"); if(switchsurf[1] == NULL){ fprintf(stderr, "Couldn't load switch_u.png\n"); return 1; } l = op_lights; ir_lght = l; l += 18; mi_lght = l; l += 36; pc_lght = l; l += 18; ma_lght = l; l += 18; pih_lght = l; l += 7; pir_lght = l; l += 7; pio_lght = l; l += 7; rest_lght = l; sw = switches; data_sw = sw; sw += 36; ma_sw = sw; sw += 18; rest_sw = sw; sw += 4; rim_maint_sw = sw; l = ind_lights; mb_lght = l; l += 36; ar_lght = l; l += 36; mq_lght = l; l += 36; fe_lght = l; l += 9; sc_lght = l; l += 9; ff_lght = l; l = extra_lights; membus_lght = l; l += 36; pr_lght = l; l += 8; rlr_lght = l; l += 8; rla_lght = l; for(i = 0; i < nelem(keys); i++){ keys[i].r.x += op_panel.x; keys[i].r.y += op_panel.y; } for(i = 0; i < nelem(op_lights); i++){ op_lights[i].r.x += op_panel.x; op_lights[i].r.y += op_panel.y; } for(i = 0; i < nelem(ind_lights); i++){ ind_lights[i].r.x += ind_panel.x; ind_lights[i].r.y += ind_panel.y; } for(i = 0; i < nelem(extra_lights); i++){ extra_lights[i].r.x += extra_panel.x; extra_lights[i].r.y += extra_panel.y; } for(i = 0; i < nelem(switches)-1; i++){ switches[i].r.x += op_panel.x; switches[i].r.y += op_panel.y; } rim_maint_sw->r.x += extra_panel.x; rim_maint_sw->r.y += extra_panel.y; initmem(); inittty(); memset(&apr, 0xff, sizeof apr); apr.extpulse = 0; /* int frm = 0; time_t tm, tm2; tm = time(nil);*/ for(;;){ /* frm++; tm2 = time(nil); if((tm2 - tm) > 5){ print("fps: %f\n", (float)frm/(tm2-tm)); tm = tm2; frm = 0; } */ // usleep(1000); while(SDL_PollEvent(&ev)) switch(ev.type){ case SDL_MOUSEMOTION: mmev = (SDL_MouseMotionEvent*)&ev; mouse(0, mmev->state, mmev->x, mmev->y); break; case SDL_MOUSEBUTTONDOWN: case SDL_MOUSEBUTTONUP: mbev = (SDL_MouseButtonEvent*)&ev; mouse(mbev->button, mbev->state, mbev->x, mbev->y); break; case SDL_QUIT: dumpmem(); SDL_Quit(); return 0; case SDL_USEREVENT: print("user\n"); break; } setlights(apr.ir, ir_lght, 18); setlights(apr.mi, mi_lght, 36); setlights(apr.pc, pc_lght, 18); setlights(apr.ma, ma_lght, 18); setlights(apr.pih, pih_lght, 7); setlights(apr.pio, pio_lght, 7); setlights(apr.pir, pir_lght, 7); rest_lght[4].state = apr.run; rest_lght[5].state = apr.mc_stop; rest_lght[6].state = apr.pi_active; rest_lght[0].state = apr.sw_addr_stop = rest_sw[0].state; rest_lght[1].state = apr.sw_repeat = rest_sw[1].state; rest_lght[2].state = apr.sw_mem_disable = rest_sw[2].state; rest_lght[3].state = apr.sw_power = rest_sw[3].state; apr.sw_rim_maint = rim_maint_sw->state; apr.data = getswitches(data_sw, 36); apr.mas = getswitches(ma_sw, 18); apr.key_start = keys[0].state == 1; apr.key_readin = keys[0].state == 2; apr.key_inst_cont = keys[1].state == 1; apr.key_mem_cont = keys[1].state == 2; apr.key_inst_stop = keys[2].state == 1; apr.key_mem_stop = keys[2].state == 2; apr.key_io_reset = keys[3].state == 1; apr.key_exec = keys[3].state == 2; apr.key_dep = keys[4].state == 1; apr.key_dep_nxt = keys[4].state == 2; apr.key_ex = keys[5].state == 1; apr.key_ex_nxt = keys[5].state == 2; apr.key_rd_off = keys[6].state == 1; apr.key_rd_on = keys[6].state == 2; apr.key_pt_rd = keys[7].state == 1; apr.key_pt_wr = keys[7].state == 2; setlights(apr.mb, mb_lght, 36); setlights(apr.ar, ar_lght, 36); setlights(apr.mq, mq_lght, 36); setlights(apr.fe, fe_lght, 9); setlights(apr.sc, sc_lght, 9); ff_lght[0].state = apr.key_ex_st; ff_lght[1].state = apr.key_ex_sync; ff_lght[2].state = apr.key_dep_st; ff_lght[3].state = apr.key_dep_sync; ff_lght[4].state = apr.key_rd_wr; ff_lght[5].state = apr.mc_rd; ff_lght[6].state = apr.mc_wr; ff_lght[7].state = apr.mc_rq; ff_lght[8].state = apr.if1a; ff_lght[9].state = apr.af0; ff_lght[10].state = apr.af3; ff_lght[11].state = apr.af3a; ff_lght[12].state = apr.et4_ar_pse; ff_lght[13].state = apr.f1a; ff_lght[14].state = apr.f4a; ff_lght[15].state = apr.f6a; ff_lght[16].state = apr.sf3; ff_lght[17].state = apr.sf5a; ff_lght[18].state = apr.sf7; ff_lght[19].state = apr.ar_com_cont; ff_lght[20].state = apr.blt_f0a; ff_lght[21].state = apr.blt_f3a; ff_lght[22].state = apr.blt_f5a; ff_lght[23].state = apr.iot_f0a; ff_lght[24].state = apr.fpf1; ff_lght[25].state = apr.fpf2; ff_lght[26].state = apr.faf1; ff_lght[27].state = apr.faf2; ff_lght[28].state = apr.faf3; ff_lght[29].state = apr.faf4; ff_lght[30].state = apr.fmf1; ff_lght[31].state = apr.fmf2; ff_lght[32].state = apr.fdf1; ff_lght[33].state = apr.fdf2; ff_lght[34].state = apr.ir & H6 && apr.mq & F1 && !apr.nrf3; ff_lght[35].state = apr.nrf1; ff_lght[36].state = apr.nrf2; ff_lght[37].state = apr.nrf3; ff_lght[38].state = apr.fsf1; ff_lght[39].state = apr.chf7; ff_lght[40].state = apr.dsf1; ff_lght[41].state = apr.dsf2; ff_lght[42].state = apr.dsf3; ff_lght[43].state = apr.dsf4; ff_lght[44].state = apr.dsf5; ff_lght[45].state = apr.dsf6; ff_lght[46].state = apr.dsf7; ff_lght[47].state = apr.dsf8; ff_lght[48].state = apr.dsf9; ff_lght[49].state = apr.msf1; ff_lght[50].state = apr.mpf1; ff_lght[51].state = apr.mpf2; ff_lght[52].state = apr.mc_split_cyc_sync; ff_lght[53].state = apr.mc_stop_sync; ff_lght[54].state = apr.shf1; ff_lght[55].state = apr.sc == 0777; ff_lght[56].state = apr.chf1; ff_lght[57].state = apr.chf2; ff_lght[58].state = apr.chf3; ff_lght[59].state = apr.chf4; ff_lght[60].state = apr.chf5; ff_lght[61].state = apr.chf6; ff_lght[62].state = apr.lcf1; ff_lght[63].state = apr.dcf1; ff_lght[64].state = apr.pi_ov; ff_lght[65].state = apr.pi_cyc; ff_lght[66].state = !!apr.pi_req; ff_lght[67].state = apr.iot_go; ff_lght[68].state = apr.a_long; ff_lght[69].state = apr.ma == apr.mas; ff_lght[70].state = apr.uuo_f1; ff_lght[71].state = apr.cpa_pdl_ov; ff_lght[72].state = !apr.ex_user; ff_lght[73].state = apr.cpa_illeg_op; ff_lght[74].state = apr.ex_ill_op; ff_lght[75].state = apr.ex_uuo_sync; ff_lght[76].state = apr.ex_pi_sync; ff_lght[77].state = apr.mq36; ff_lght[78].state = apr.key_rim_sbr; ff_lght[79].state = apr.ar_cry0_xor_cry1; ff_lght[80].state = apr.ar_cry0; ff_lght[81].state = apr.ar_cry1; ff_lght[82].state = apr.ar_ov_flag; ff_lght[83].state = apr.ar_cry0_flag; ff_lght[84].state = apr.ar_cry1_flag; ff_lght[85].state = apr.ar_pc_chg_flag; ff_lght[86].state = apr.cpa_non_exist_mem; ff_lght[87].state = apr.cpa_clock_enable; ff_lght[88].state = apr.cpa_clock_flag; ff_lght[89].state = apr.cpa_pc_chg_enable; ff_lght[90].state = apr.cpa_arov_enable; ff_lght[91].state = !!(apr.cpa_pia&4); ff_lght[92].state = !!(apr.cpa_pia&2); ff_lght[93].state = !!(apr.cpa_pia&1); setlights(membus0, membus_lght, 36); setlights(apr.pr, pr_lght, 8); setlights(apr.rlr, rlr_lght, 8); setlights(apr.rla, rla_lght, 8); SDL_BlitSurface(op_surf, NULL, screen, &op_panel); SDL_BlitSurface(ind_surf, NULL, screen, &ind_panel); SDL_BlitSurface(extra_surf, NULL, screen, &extra_panel); for(i = 0; i < nelem(keys); i++) SDL_BlitSurface(keys[i].surfs[keys[i].state], NULL, screen, &keys[i].r); for(i = 0; i < nelem(op_lights); i++) SDL_BlitSurface(op_lights[i].surfs[op_lights[i].state && apr.sw_power], NULL, screen, &op_lights[i].r); for(i = 0; i < nelem(ind_lights); i++) SDL_BlitSurface(ind_lights[i].surfs[ind_lights[i].state && apr.sw_power], NULL, screen, &ind_lights[i].r); for(i = 0; i < nelem(extra_lights); i++) SDL_BlitSurface(extra_lights[i].surfs[extra_lights[i].state && apr.sw_power], NULL, screen, &extra_lights[i].r); for(i = 0; i < nelem(switches); i++) SDL_BlitSurface(switches[i].surfs[switches[i].state], NULL, screen, &switches[i].r); SDL_Flip(screen); } }
int main(int argn, char **argv) { int sound = 1; int jump = 0; if (argn >= 2) { switch (argv[1][0]) { case 'n' : sound = 0; break; case '1' : jump = 1; break; case '2' : jump = 2; break; case '3' : jump = 3; break; case '4' : jump = 4; break; } } memset(vesa,0,modes*sizeof(tvesa)); //vesa[3].flags = 1; //erz-effekt kann 8 bit readconfig(); if ((dflags & dfNosound)) sound = 0; initvesa(vesa,modes); tarjstream s("fulcrum.dat"); // tstream s; if ( SDL_Init (SDL_INIT_VIDEO) != 0 ) exit("Error: Couldn't initialize SDL"); atexit(SDL_Quit); i8_init(); if (sound) initxm(); int memsize = vesa[1].xres*vesa[1].yres*28 + 16000000; if (sound == 0) memsize -= 1000000; initmem(memsize); if (jump == 1) goto main; if (jump == 2) goto pic; if (jump == 3) goto extro; if (jump == 4) goto erz; //intro part setmode(0); initcredits(s,vesa[0]); initmese(s,vesa[0],1 ,0 ,0 ,0); //camera,tracks,ambient,debug); if (sound) loadxm(s,"fx.rxm",0); startmese(0/*frame*/); if (keypressed()) { if (sound) rxmstop(xmStop); goto weg; } if (sound) rxmstop(xmFade); //goto weg; //if (keypressed()) getch(); emptymem(); main: //main part setmode(1); initmoove(s,vesa[1]); if (sound) loadxm(s,"looping.rxm",0); startmoove(); if (keypressed()) { if (sound) rxmstop(xmStop); goto weg; } if (sound) rxmstop(xmStop); emptymem(); pic: //adler pic setmode(2); ShowPic(s, vesa[2]); if (delay(8000)) goto weg; emptymem(); extro: //extro setmode(0); // initcredits(s,vesa[0]); initmese(s,vesa[0],0 ,1 ,1 ,0); //camera,tracks,ambient,debug); if (sound) loadxm(s,"fx.rxm",0x20); startmese(/*60000*/0/*frame*/); if (keypressed()) { if (sound) rxmstop(xmStop); goto weg; } if (sound) rxmstop(xmFade); emptymem(); erz: //erzeffekt setmode(3); initerz(s,vesa[3]); if (sound) loadxm(s,"bunga.rxm",0); starterz(); if (keypressed()) { if (sound) rxmstop(xmStop); goto weg; } if (sound) rxmstop(xmFade); weg: if (sound) donexm(); i8_done(); textmode(); //checkit(); return 0; };
int main (int argc, char **argv) { LISP expr, val; char *progname, *prog = 0; progname = *argv++; for (--argc; argc>0 && **argv=='-'; --argc, ++argv) { char *p; for (p=1+*argv; *p; ++p) switch (*p) { case 'h': fprintf (stderr, "Usage: %s [-h] [-v] [-t] [-m#] prog [arg...]\n", progname); return (0); case 't': ++trace; break; case 'v': ++verbose; break; case 'm': if (! *++p) { if (argc <= 1) break; p = *++argv; --argc; } memsz = atoi (p); p += strlen (p) - 1; break; } } if (argc > 0) { prog = *argv++; --argc; } if (memsz < 1000) memsz = (sizeof (unsigned) < 4 ? 64000 : 256000) / sizeof (cell); if (verbose) { fprintf (stderr, "Micro Scheme Interpreter, Release 1.0\n"); fprintf (stderr, "Memory size = %d bytes\n", memsz * sizeof (cell)); } mem = (cell *) malloc (sizeof (cell) * memsz); gclabel = malloc (memsz); if (!mem || !gclabel) { fprintf (stderr, "Out of memory\n"); return (-1); } if (prog && freopen (prog, "r", stdin) != stdin) { fprintf (stderr, "Cannot open %s\n", prog); return (-1); } initmem (); T = alloc (TBOOL); /* логическая истина #t */ ZERO = number (0); /* целый ноль */ ENV = cons (cons (symbol ("version"), number (10)), NIL); initcontext (stdfunc); for (;;) { gc (); if (isatty (0)) printf ("> "); expr = getexpr (); if (feof (stdin)) break; val = eval (expr, 0); if (verbose) { putexpr (expr, stdout); printf (" --> "); putexpr (val, stdout); putchar ('\n'); } } return (0); }
int main(int argc, char *argv[]) { int c; char *ptr; ERR_ZERO(&msgset); while ((c = getopt(argc, argv, "abcdeghmprstuvwyzFX:")) != -1) { switch (c) { case 'a': aflag++; break; case 'b': bflag = 1; break; case 'c': cflag = 1; break; case 'd': dflag = 1; break; case 'e': eflag = 1; break; case 'F': Fflag = 1; break; case 'g': gflag = 1; break; case 'h': hflag = 1; break; case 'p': pflag = 1; break; case 'r': rflag = 1; break; case 's': sflag = 1; break; case 't': tflag = 1; break; case 'u': uflag = 0; break; case 'w': wflag = 1; break; case 'v': vflag = 0; break; case 'y': yflag = 1; break; case 'z': zflag = 0; break; case 'm': msglist(); return(0); case 'X': for (ptr = strtok(optarg, ","); ptr; ptr = strtok(NULL, ",")) { char *eptr; long msg = strtol(ptr, &eptr, 0); if ((msg == LONG_MIN || msg == LONG_MAX) && errno == ERANGE) err(1, "invalid error message id '%s'", ptr); if (*eptr || ptr == eptr || msg < 0 || msg >= ERR_SETSIZE) errx(1, "invalid error message id '%s'", ptr); ERR_SET(msg, &msgset); } break; case '?': default: usage(); break; } } argc -= optind; argv += optind; if (argc != 2) usage(); /* open the input file */ if ((yyin = fopen(argv[0], "r")) == NULL) err(1, "cannot open '%s'", argv[0]); /* initialize output */ outopen(argv[1]); if (yflag) yydebug = 1; initmem(); initdecl(); initscan(); initmtab(); yyparse(); /* Following warnings cannot be suppressed by LINTED */ nowarn = 0; chkglsyms(); outclose(); return (nerr != 0); }
int main(int argc, char *argv[]) { int c, i; size_t len; char *lname; libs = xcalloc(1, sizeof (char *)); opterr = 0; while ((c = getopt(argc, argv, "hpstxuC:HFl:")) != -1) { switch (c) { case 's': sflag = 1; break; case 't': tflag = 1; break; case 'u': uflag = 0; break; case 'x': xflag = 1; break; case 'p': pflag = 1; break; case 'C': len = strlen(optarg); lname = xmalloc(len + 10); (void)sprintf(lname, "llib-l%s.ln", optarg); libname = lname; Cflag = 1; uflag = 0; break; case 'H': Hflag = 1; break; case 'h': hflag++; break; case 'F': Fflag = 1; break; case 'l': for (i = 0; libs[i] != NULL; i++) continue; libs = xrealloc(libs, (i + 2) * sizeof (char *)); libs[i] = xstrdup(optarg); libs[i + 1] = NULL; break; case '?': usage(); } } argc -= optind; argv += optind; if (argc == 0) usage(); initmem(); /* initialize hash table */ inithash(); inittyp(); for (i = 0; i < argc; i++) readfile(argv[i]); /* write the lint library */ if (Cflag) { forall(mkstatic); outlib(libname); } /* read additional libraries */ for (i = 0; libs[i] != NULL; i++) readfile(libs[i]); forall(mkstatic); mainused(); /* perform all tests */ forall(chkname); exit(0); /* NOTREACHED */ }