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);
}
