int main(int argc, char **argv) { int i, got; int maxrow=1024; Ev ev, ebuf=NULL; Fun fun, ofun; /* open file for reading */ if( !(fun=FunOpen(argv[1], "r", NULL)) ){ fprintf(stderr, "ERROR: can't open input funtools file: %s\n", argv[1]); return 1; } if( !(ofun=FunOpen(argv[2], "w", fun)) ){ fprintf(stderr, "ERROR: can't open output funtools file: %s\n", argv[2]); return 1; } /* select columns to read (and data types to convert to) */ got = FunColumnSelect(fun, sizeof(EvRec), "merge=update", "pi", "J", "rw", FUN_OFFSET(Ev, pi), NULL); /* read and process events */ while(ebuf=(void *)FunTableRowGet(fun, NULL, maxrow, NULL, &got) ){ for(i=0; i<got; i++){ ev = (Ev)ebuf+i; ev->pi = ev->pi + 1; } if( FunTableRowPut(ofun, ebuf, got, 0, NULL) != got ){ fprintf(stderr, "ERROR: writing to funtools file: %s\n", argv[2]); return 1; } if( ebuf) free(ebuf); } /* close files */ FunClose(ofun); FunClose(fun); }
int main(int argc, char *argv[]) { #ifndef GEN_HASKELL printf("/* This file is created automatically. Do not edit by hand.*/\n\n"); printf("#define STD_HDR_SIZE %" FMT_SizeT "\n", (size_t)sizeofW(StgHeader) - sizeofW(StgProfHeader)); /* grrr.. PROFILING is on so we need to subtract sizeofW(StgProfHeader) */ printf("#define PROF_HDR_SIZE %" FMT_SizeT "\n", (size_t)sizeofW(StgProfHeader)); printf("#define BLOCK_SIZE %u\n", BLOCK_SIZE); printf("#define MBLOCK_SIZE %u\n", MBLOCK_SIZE); printf("#define BLOCKS_PER_MBLOCK %" FMT_SizeT "\n", (lnat)BLOCKS_PER_MBLOCK); // could be derived, but better to save doing the calculation twice printf("\n\n"); #endif field_offset(StgRegTable, rR1); field_offset(StgRegTable, rR2); field_offset(StgRegTable, rR3); field_offset(StgRegTable, rR4); field_offset(StgRegTable, rR5); field_offset(StgRegTable, rR6); field_offset(StgRegTable, rR7); field_offset(StgRegTable, rR8); field_offset(StgRegTable, rR9); field_offset(StgRegTable, rR10); field_offset(StgRegTable, rF1); field_offset(StgRegTable, rF2); field_offset(StgRegTable, rF3); field_offset(StgRegTable, rF4); field_offset(StgRegTable, rD1); field_offset(StgRegTable, rD2); field_offset(StgRegTable, rL1); field_offset(StgRegTable, rSp); field_offset(StgRegTable, rSpLim); field_offset(StgRegTable, rHp); field_offset(StgRegTable, rHpLim); field_offset(StgRegTable, rCCCS); field_offset(StgRegTable, rCurrentTSO); field_offset(StgRegTable, rCurrentNursery); field_offset(StgRegTable, rHpAlloc); struct_field(StgRegTable, rRet); struct_field(StgRegTable, rNursery); def_offset("stgEagerBlackholeInfo", FUN_OFFSET(stgEagerBlackholeInfo)); def_offset("stgGCEnter1", FUN_OFFSET(stgGCEnter1)); def_offset("stgGCFun", FUN_OFFSET(stgGCFun)); field_offset(Capability, r); field_offset(Capability, lock); struct_field(Capability, no); struct_field(Capability, mut_lists); struct_field(Capability, context_switch); struct_field(Capability, interrupt); struct_field(Capability, sparks); struct_field(bdescr, start); struct_field(bdescr, free); struct_field(bdescr, blocks); struct_field(bdescr, gen_no); struct_field(bdescr, link); struct_size(generation); struct_field(generation, n_new_large_words); struct_size(CostCentreStack); struct_field(CostCentreStack, ccsID); struct_field(CostCentreStack, mem_alloc); struct_field(CostCentreStack, scc_count); struct_field(CostCentreStack, prevStack); struct_field(CostCentre, ccID); struct_field(CostCentre, link); struct_field(StgHeader, info); struct_field_("StgHeader_ccs", StgHeader, prof.ccs); struct_field_("StgHeader_ldvw", StgHeader, prof.hp.ldvw); struct_size(StgSMPThunkHeader); closure_payload(StgClosure,payload); struct_field(StgEntCounter, allocs); struct_field(StgEntCounter, registeredp); struct_field(StgEntCounter, link); struct_field(StgEntCounter, entry_count); closure_size(StgUpdateFrame); closure_size(StgCatchFrame); closure_size(StgStopFrame); closure_size(StgMutArrPtrs); closure_field(StgMutArrPtrs, ptrs); closure_field(StgMutArrPtrs, size); closure_size(StgArrWords); closure_field(StgArrWords, bytes); closure_payload(StgArrWords, payload); closure_field(StgTSO, _link); closure_field(StgTSO, global_link); closure_field(StgTSO, what_next); closure_field(StgTSO, why_blocked); closure_field(StgTSO, block_info); closure_field(StgTSO, blocked_exceptions); closure_field(StgTSO, id); closure_field(StgTSO, cap); closure_field(StgTSO, saved_errno); closure_field(StgTSO, trec); closure_field(StgTSO, flags); closure_field(StgTSO, dirty); closure_field(StgTSO, bq); closure_field_("StgTSO_cccs", StgTSO, prof.cccs); closure_field(StgTSO, stackobj); closure_field(StgStack, sp); closure_field_offset(StgStack, stack); closure_field(StgStack, stack_size); closure_field(StgStack, dirty); struct_size(StgTSOProfInfo); opt_struct_size(StgTSOProfInfo,PROFILING); closure_field(StgUpdateFrame, updatee); closure_field(StgCatchFrame, handler); closure_field(StgCatchFrame, exceptions_blocked); closure_size(StgPAP); closure_field(StgPAP, n_args); closure_field_gcptr(StgPAP, fun); closure_field(StgPAP, arity); closure_payload(StgPAP, payload); thunk_size(StgAP); closure_field(StgAP, n_args); closure_field_gcptr(StgAP, fun); closure_payload(StgAP, payload); thunk_size(StgAP_STACK); closure_field(StgAP_STACK, size); closure_field_gcptr(StgAP_STACK, fun); closure_payload(StgAP_STACK, payload); thunk_size(StgSelector); closure_field_gcptr(StgInd, indirectee); closure_size(StgMutVar); closure_field(StgMutVar, var); closure_size(StgAtomicallyFrame); closure_field(StgAtomicallyFrame, code); closure_field(StgAtomicallyFrame, next_invariant_to_check); closure_field(StgAtomicallyFrame, result); closure_field(StgInvariantCheckQueue, invariant); closure_field(StgInvariantCheckQueue, my_execution); closure_field(StgInvariantCheckQueue, next_queue_entry); closure_field(StgAtomicInvariant, code); closure_field(StgTRecHeader, enclosing_trec); closure_size(StgCatchSTMFrame); closure_field(StgCatchSTMFrame, handler); closure_field(StgCatchSTMFrame, code); closure_size(StgCatchRetryFrame); closure_field(StgCatchRetryFrame, running_alt_code); closure_field(StgCatchRetryFrame, first_code); closure_field(StgCatchRetryFrame, alt_code); closure_field(StgTVarWatchQueue, closure); closure_field(StgTVarWatchQueue, next_queue_entry); closure_field(StgTVarWatchQueue, prev_queue_entry); closure_field(StgTVar, current_value); closure_size(StgWeak); closure_field(StgWeak,link); closure_field(StgWeak,key); closure_field(StgWeak,value); closure_field(StgWeak,finalizer); closure_field(StgWeak,cfinalizer); closure_size(StgDeadWeak); closure_field(StgDeadWeak,link); closure_size(StgMVar); closure_field(StgMVar,head); closure_field(StgMVar,tail); closure_field(StgMVar,value); closure_size(StgMVarTSOQueue); closure_field(StgMVarTSOQueue, link); closure_field(StgMVarTSOQueue, tso); closure_size(StgBCO); closure_field(StgBCO, instrs); closure_field(StgBCO, literals); closure_field(StgBCO, ptrs); closure_field(StgBCO, arity); closure_field(StgBCO, size); closure_payload(StgBCO, bitmap); closure_size(StgStableName); closure_field(StgStableName,sn); closure_size(StgBlockingQueue); closure_field(StgBlockingQueue, bh); closure_field(StgBlockingQueue, owner); closure_field(StgBlockingQueue, queue); closure_field(StgBlockingQueue, link); closure_size(MessageBlackHole); closure_field(MessageBlackHole, link); closure_field(MessageBlackHole, tso); closure_field(MessageBlackHole, bh); struct_field_("RtsFlags_ProfFlags_showCCSOnException", RTS_FLAGS, ProfFlags.showCCSOnException); struct_field_("RtsFlags_DebugFlags_apply", RTS_FLAGS, DebugFlags.apply); struct_field_("RtsFlags_DebugFlags_sanity", RTS_FLAGS, DebugFlags.sanity); struct_field_("RtsFlags_DebugFlags_weak", RTS_FLAGS, DebugFlags.weak); struct_field_("RtsFlags_GcFlags_initialStkSize", RTS_FLAGS, GcFlags.initialStkSize); struct_field_("RtsFlags_MiscFlags_tickInterval", RTS_FLAGS, MiscFlags.tickInterval); struct_size(StgFunInfoExtraFwd); struct_field(StgFunInfoExtraFwd, slow_apply); struct_field(StgFunInfoExtraFwd, fun_type); struct_field(StgFunInfoExtraFwd, arity); struct_field_("StgFunInfoExtraFwd_bitmap", StgFunInfoExtraFwd, b.bitmap); struct_size(StgFunInfoExtraRev); struct_field(StgFunInfoExtraRev, slow_apply_offset); struct_field(StgFunInfoExtraRev, fun_type); struct_field(StgFunInfoExtraRev, arity); struct_field_("StgFunInfoExtraRev_bitmap", StgFunInfoExtraRev, b.bitmap); struct_field(StgLargeBitmap, size); field_offset(StgLargeBitmap, bitmap); struct_size(snEntry); struct_field(snEntry,sn_obj); struct_field(snEntry,addr); #ifdef mingw32_HOST_OS struct_size(StgAsyncIOResult); struct_field(StgAsyncIOResult, reqID); struct_field(StgAsyncIOResult, len); struct_field(StgAsyncIOResult, errCode); #endif return 0; }
int main (int argc, char **argv) { int i, got; int maxrow=MAXROW; double x=0.5; char *tmode; char *s; Fun fun, fun2; Ev ebuf, ev; /* exit on gio errors */ setgerror(2); /* make sure we have minimal arguments */ if( argc < 3 ) gerror(stderr, "usage: %s iname oname [columns]\n", argv[0]); /* get maxrow,if user-specified */ if( (s=(char *)getenv("FUN_MAXROW")) != NULL ) maxrow = atoi(s); /* open input file */ if( !(fun = FunOpen(argv[1], "rc", NULL)) ) gerror(stderr, "could not FunOpen input file: %s\n", argv[1]); /* open the output FITS image, inheriting params from input */ if( !(fun2 = FunOpen(argv[2], "w", fun)) ) gerror(stderr, "could not FunOpen output file: %s\n", argv[2]); /* if we have "time2", read it, else create it */ if( FunColumnLookup(fun, "tinc", 0, NULL, NULL, NULL, NULL, NULL, NULL) ) tmode = "rw"; else tmode = "w"; FunColumnSelect(fun, sizeof(EvRec), "merge=replace", "time", "D", "r", FUN_OFFSET(Ev, time), "ntime", "D", "rw", FUN_OFFSET(Ev, ntime), "tinc", "D", tmode, FUN_OFFSET(Ev, tinc), NULL); /* activate specified columns -- these will be written to the output file */ if( argc >= 4 ) FunColumnActivate(fun, argv[3], NULL); /* get rows -- let routine allocate the row array */ while( (ebuf = (Ev)FunTableRowGet(fun, NULL, maxrow, NULL, &got)) ){ /* process all rows */ for(i=0; i<got; i++){ /* point to the i'th row */ ev = ebuf+i; ev->tinc += (i*sqrt(cos(x)*cos(x) + sin(x)*sin(x))); ev->ntime = ev->time + ev->tinc; /* write out row with the new columns */ FunTableRowPut(fun2, (char *)ev, 1, i, NULL); } /* free row data */ if( ebuf ) free(ebuf); } /* clean up -- close output before input to perform flush automatically */ FunClose(fun2); FunClose(fun); return(0); }
int main(int argc, char **argv) { int i; int got; int npha; char tbuf[SZ_LINE]; Ev ebuf, ev, nev; Fun fun, fun2; /* make sure we have minimal arguments */ if( argc < 3 ){ fprintf(stderr, "usage: %s iname oname [columns]\n", argv[0]); exit(1); } /* exit on gio errors */ setgerror(2); /* open input FITS file for reading, and allowing copy of other extensions */ if( !(fun = FunOpen(argv[1], "rc", NULL)) ) gerror(stderr, "could not FunOpen input file: %s\n", argv[1]); /* look for the size of the phas vector */ if( !FunColumnLookup(fun, "phas", 0, NULL, NULL, NULL, NULL, &npha, NULL) ) gerror(stderr, "can't find phas column\n"); /* open the output FITS image, inheriting params from input */ if( !(fun2 = FunOpen(argv[2], "w", fun)) ) gerror(stderr, "could not FunOpen output file: %s\n", argv[2]); /* allocate a new row buffer, now that we know the size of phas */ nev = (Ev)calloc(1, sizeof(EvRec)); nev->phas = (int *)calloc(npha, sizeof(int)); /* create format statement for the pha vector, @ means its a pointer */ sprintf(tbuf, "@%dJ", npha); /* specify input columns we want brought into user space */ FunColumnSelect(fun, sizeof(EvRec), "merge=replace", "$x", "D", "rw", FUN_OFFSET(Ev, x), "$y", "D", "rw", FUN_OFFSET(Ev, y), "phas", tbuf, "rw", FUN_OFFSET(Ev, phas), NULL); /* set columns to be written to the output file */ if( argc >= 4 ) FunColumnActivate(fun, argv[3], NULL); /* loop through rows and replicate */ while( (ebuf=(Ev)FunTableRowGet(fun, NULL, MAXROW, NULL, &got)) ){ for(i=0; i<got; i++){ /* get pointer to the user info containing x,y, phas */ ev = ebuf+i; /* generate a new rows (with new x, y, phas values) */ Reverse(ev->x, ev->y, ev->phas, &(nev->x), &(nev->y), nev->phas, npha); /* write this new row -- with the replacements from user space */ FunTableRowPut(fun2, nev, 1, i, NULL); } if( ebuf ) free(ebuf); } /* free the new row */ if( nev ){ if( nev->phas ) free(nev->phas); free(nev); } /* close output before input so that funtools will copy the rest of the input extensions to the output (if such copy is requred) */ FunClose(fun2); FunClose(fun); return(0); }