自学教程：C++ strclose函数代码示例

void nemo_main(void) /* this replaces main(argc,argv)        <--- required */{    stream instr, outstr;    string times = getparam("times");    real   tsnap;    Body  *btab = NULL, *bp;    int    i, nbody, bits;    bool   first = TRUE;    instr = stropen(getparam("in"), "r");    outstr = stropen(getparam("out"), "w");    for (;;) {    /* infinite loop, broken only when ran out of snapshots */    	get_history(instr);                    /* read history */        if (!get_tag_ok(instr, SnapShotTag)) break; /* check if done */        get_snap(instr, &btab, &nbody, &tsnap, &bits);  /* get next */                /* Operate on the snapshot here : */        for (bp=btab, i=0; i<nbody; bp++, i++) {            /* all the work goes here */        }        if (first) {            put_history(outstr);            first = FALSE;        }        put_snap(outstr, &btab, &nbody, &tsnap, &bits);     /* output */    }    strclose(instr);    if (first) {    	warning("No snapshots processed");  	strdelete(outstr,TRUE);    } else        strclose(outstr);}

void nemo_main (){    setparams();			/* set par's in globals */    instr = stropen (infile, "r");    read_image (instr,&iptr);				/* set some global paramters */    nx = Nx(iptr);	    ny = Ny(iptr);    nz = Nz(iptr);    xmin = Xmin(iptr);    ymin = Ymin(iptr);    zmin = Zmin(iptr);    dx = Dx(iptr);    dy = Dy(iptr);    dz = Dz(iptr);    if(hasvalue("gauss"))        make_gauss_beam(getparam("dir"));    outstr = stropen (outfile,"w");    if (hasvalue("wiener"))      wiener();    else      smooth_it();    write_image (outstr,iptr);    strclose(instr);    strclose(outstr);}

void stopoutput(){    if (outstr != NULL)        strclose(outstr);    if (quadstr != NULL)        strclose(quadstr);}

nemo_main(){    real frame[N][N];    image f1;    imageptr fp1, fp2;	/* or image *fp1 */    stream instr,outstr;    if (strcmp(getparam("mode"),"w")==0) {		/* write test */	printf ("WRITING test (mode=w) foo.dat/n");	outstr = stropen ("foo.dat","w");	f1.frame = &frame[0][0];  /* compiler complained when = frame used ???? */				  /* would be same as fp2->frame = ... */	fp1 = &f1;		  /* to initialize structures, we need pointer to them */	ini_matrix (&fp1,N,N);    /* ini_matrix MUST have pointer to pointer to image */		fp2 = NULL;		  /* This is to check dynamic allocation of whole thing */	ini_matrix (&fp2,N,N);	write_image (outstr,fp2);	write_image (outstr,&f1);		/* or fp1 */	strclose(outstr);	exit(0);    } else {	printf ("READING test (mode<>w) foo.dat/n");	fp2=NULL;					/* read test */	instr = stropen ("foo.dat","r");	while (read_image(instr,&fp2)) {            printf ("Read image/n");            printf ("with MapValue(5,5)=%f/n",MapValue(fp2,5,5));	}	strclose(instr);    }}

nemo_main(){  stream instr, outstr;  int    i, n, nfile, blocking[2];  string outfile, hdselect, *insert, *fix, *deletes, *keep, *print;  char   basename[128];  struct fits_header fh;  bool   split, sel_head, sel_data;    instr = stropen(getparam("in"),"r");    /* open input */  outfile = getparam("out");            outstr = stropen(outfile,"w");	/* open file now */  for (i=1;;i++) {			             /* loop over all HDU's */    fts_zero(&fh);			             /* reset header */    n = fts_rhead(&fh,instr);	              /* read header */    if (n<0)				              /* if no data (EOF) .. */      break;			              /* ... quit */    fts_chead816(&fh,outstr);                         /* copy header */    fts_cdata816(&fh,instr,outstr);         /* copy data, with trailing bits */                                               /* this also modifies fh->bitpix */  }  strclose(outstr);  strclose(instr);                    /* close files */}

int main(int argc, string argv[]){    stream istr;    gsprof *tgsp, *mgsp;    real beta_a, *sig2, rrange[2], lgrs, r;    int np, i;    initparam(argv, defv);    istr = stropen(getparam("gsp"), "r");    get_history(istr);    tgsp = get_gsprof(istr);    strclose(istr);    if (! strnull(getparam("grav"))) {        istr = stropen(getparam("grav"), "r");        get_history(istr);        mgsp = get_gsprof(istr);        strclose(istr);    } else        mgsp = tgsp;    beta_a = getdparam("beta_a");    sig2 = calc_sig2_gsp(tgsp, mgsp, beta_a);    np = getiparam("npoint");    setrange(rrange, getparam("rrange"));    lgrs = rlog2(rrange[1] / rrange[0]) / (np - 1);    printf("%12s  %12s/n", "radius", "sig_r^2");    for (i = 0; i < np; i++) {        r = rrange[0] * rpow(2.0, lgrs * i);        printf("%12.5f  %12.7f/n",               r, sig2_gsp(tgsp, mgsp, beta_a, sig2, r));    }    return (0);}

void readgsp(void){    stream istr;    istr = stropen(getparam("gsp"), "r");    get_history(istr);    gsp = ggsp = get_gsprof(istr);    strclose(istr);    if (! strnull(getparam("grav"))) {        istr = stropen(getparam("grav"), "r");        get_history(istr);        ggsp = get_gsprof(istr);        strclose(istr);    }}

nemo_main(){  int n = 0;  setparams();                    /* set globals */  instr = stropen (infile, "r");  plinit ("***", 0.0, 20.0, 0.0, 20.0);       /* init yapp */  while (read_image(instr,&iptr)) {   /* loop while more images found */    dprintf(1,"Time= %g MinMax= %g %g/n",Time(iptr),MapMin(iptr),MapMax(iptr));    nx=Nx(iptr);			    ny=Ny(iptr);    nz=Nz(iptr);    if (nz > 1) error("Cannot handle 3D images [%d,%d,%d]",nx,ny,nz);    xmin=Xmin(iptr);    ymin=Ymin(iptr);    dx=Dx(iptr);    dy=Dy(iptr);    xsize = nx * dx;    ysize = ny * dy;    if (n>0) {      sleep(1);      plframe();    }    plot_map();                                 /* plot the map */    n++;  }  plstop();                                   /* end of yapp */  strclose(instr);}

int main(int argc, string argv[]){  stream istr, ostr;  string times, *vecs, *produce, iotags[MaxBodyFields];  bool expand;  snapshot snap = { NULL, 0, 0.0 };  initparam(argv, defv);  istr = stropen(getparam("in"), "r");  get_history(istr);  ostr = stropen(getparam("out"), "w");  put_history(ostr);  times = getparam("times");  vecs = burststring(getparam("vectors"), ", ");  expand = streq(getparam("produce"), "*");  if (! expand) {    produce = burststring(getparam("produce"), ", ");    layout_body(produce, Precision, NDIM);  }  while (get_snapshot_timed(istr, snap, iotags, expand, times)) {    eprintf("[%s: rotating time %f]/n", getprog(), snap.time);    snaprotate(&snap, iotags, vecs, getparam("order"), getbparam("invert"),	       getdparam("thetax"), getdparam("thetay"), getdparam("thetaz"));    put_snapshot(ostr, snap, iotags);    skip_history(istr);  }  strclose(ostr);  return (0);}

nemo_main (){    setparams();    outstr = stropen(getparam("out"),"w");    cube_create(outstr);    strclose(outstr);}

int restorestate(string file){    stream str;    string program, version;    str = stropen(file, "r");			/* open state input file    */    program = get_string(str, "program");    version = get_string(str, "version");    if (! streq(version, getparam("VERSION")))	printf("warning: state file may be outdated/n/n");    headline = get_string(str, "headline");	/* read control parameters  */    get_data(str, "freq", RealType, &freq, 0);    get_data(str, "mode", IntType, &mode, 0);    get_data(str, "eps1", RealType, &eps1, 0);    get_data(str, "eps2", RealType, &eps2, 0);    options = get_string(str, "options");    get_data(str, "tstop", RealType, &tstop, 0);    get_data(str, "minor_freqout", RealType, &minor_freqout, 0);    get_data(str, "freqout", RealType, &freqout, 0);    get_data(str, "tnow", RealType, &tnow, 0);	/* read system state        */    get_data(str, "minor_tout", RealType, &minor_tout, 0);    get_data(str, "tout", RealType, &tout, 0);    get_data(str, "nbody", IntType, &nbody, 0);    bodytab = (Body *) allocate(nbody * sizeof(body));    get_data(str, "bodytab", AnyType, bodytab, nbody, sizeof(body), 0);    get_data(str, "qfld", AnyType, &qfld, sizeof(qfld), 0);    strclose(str);}

nemo_main(){    setparams();    read_data();    if (scanopt(method,"line")) {        do_line();    } else if (scanopt(method,"ellipse")) {        do_ellipse();    } else if (scanopt(method,"imageshift")) {        do_imageshift();    } else if (scanopt(method,"plane")) {    	do_plane();    } else if (scanopt(method,"gauss1d")) {    	do_gauss1d();    } else if (scanopt(method,"gauss2d")) {    	do_gauss2d();    } else if (scanopt(method,"poly")) {    	do_poly();    } else if (scanopt(method,"area")) {        do_area();    } else if (scanopt(method,"peak")) {    	do_peak();    } else if (scanopt(method,"zero")) {    	do_zero();    } else if (scanopt(method,"fourier")) {    	do_fourier();    } else        error("fit=%s invalid; try [line,ellipse,imageshift,plane,gauss1d,gauss2d,poly,area,peak,zero,fourier]",	      getparam("fit"));    if (outstr) strclose(outstr);}

void savestate(string pattern){    char namebuf[256];    stream str;    sprintf(namebuf, pattern, nstep & 1);		// construct alternate name    str = stropen(namebuf, "w!");			// open state output file    put_string(str, "program", getprog());    put_string(str, "version", getversion());    put_string(str, "headline", headline);	// save control parameters    put_data(str, "dtime", RealType, &dtime, 0);    put_data(str, "nstatic", IntType, &nstatic, 0);#if !defined(QUICKSCAN)    put_data(str, "theta", RealType, &theta, 0);#endif    put_data(str, "usequad", BoolType, &usequad, 0);    put_data(str, "eps", RealType, &eps, 0);    put_string(str, "options", options);    put_string(str, "outputs", outputs);    put_data(str, "tstop", RealType, &tstop, 0);    put_data(str, "dtout", RealType, &dtout, 0);    put_data(str, "tnow", RealType, &tnow, 0);	// save state variables    put_data(str, "tout", RealType, &tout, 0);    put_data(str, "nstep", IntType, &nstep, 0);    put_data(str, "rsize", RealType, &rsize, 0);    put_data(str, "nbody", IntType, &nbody, 0);    put_data(str, "timesteps", IntType, &nbody, 0);    put_data(str, "bodytab", AnyType, bodytab, nbody, sizeof(body), 0);    strclose(str);}

setcolors(){    stream cstr;    int ncolors;    real red[MAXCOL], green[MAXCOL], blue[MAXCOL];    char line[256];    if (hasvalue("color_table")) {	cstr = stropen(getparam("color_table"), "r");        if(qsf(cstr)) {	    get_data(cstr, "ncolors", IntType, &ncolors, 0);	    get_data(cstr, "red", RealType, red, ncolors, 0);	    get_data(cstr, "green", RealType, green, ncolors, 0);	    get_data(cstr, "blue", RealType, blue, ncolors, 0);	    plpalette(red, green, blue, ncolors);        } else {            rewind(cstr);            ncolors = 0;            while (fgets(line,256,cstr)) {                sscanf(line,"%g %g %g",&red[ncolors], &green[ncolors], &blue[ncolors]);                ncolors++;            }	    plpalette(red, green, blue, ncolors);        }	strclose(cstr);        dprintf(0,"New colortable with %d entries/n",ncolors);    }}

// disconnect from external sources -----------------------------------------void __fastcall TPlot::Disconnect(void){    AnsiString s;    char *cmd;    int i;        trace(3,"Disconnect/n");        if (!ConnectState) return;        ConnectState=0;        for (i=0;i<2;i++) {        if (StrCmdEna[i][1]) {            cmd=StrCmds[i][1].c_str();            strwrite(Stream+i,(unsigned char *)cmd,strlen(cmd));        }        strclose(Stream+i);    }    if (strstr(Caption.c_str(),"CONNECT")) {        Caption=s.sprintf("DISCONNECT%s",Caption.c_str()+7);    }    UpdateTime();    UpdatePlot();}

restorestate(string file){    stream str;    string program, version;    str = stropen(file, "r");			/* open state input file    */    program = get_string(str, "program");    version = get_string(str, "version");    if (! streq(program, getargv0()) ||		/* check program, version   */	  ! streq(version, getparam("VERSION")))	printf("warning: state file may be outdated/n/n");    headline = get_string(str, "headline");	/* read control parameters  */    get_data(str, "freq", RealType, &freq, 0);    get_data(str, "tol", RealType, &tol, 0);    get_data(str, "eps", RealType, &eps, 0);    get_data(str, "fcells", RealType, &fcells, 0);    options = get_string(str, "options");    get_data(str, "tstop", RealType, &tstop, 0);    get_data(str, "freqout", RealType, &freqout, 0);    get_data(str, "minor_freqout", RealType, &minor_freqout, 0);    get_data(str, "tnow", RealType, &tnow, 0);	/* read state variables     */    get_data(str, "tout", RealType, &tout, 0);    get_data(str, "minor_tout", RealType, &minor_tout, 0);    get_data(str, "nstep", IntType, &nstep, 0);    get_data(str, "rmin", RealType, rmin, NDIM, 0);    get_data(str, "rsize", RealType, &rsize, 0);    get_data(str, "nbody", IntType, &nbody, 0);    bodytab = (bodyptr) allocate(nbody * sizeof(body));    if (bodytab == NULL)	error("restorestate: not enuf memory/n");    get_data(str, "bodytab", AnyType, bodytab, nbody, sizeof(body), 0);    strclose(str);}

void nemo_main (){  setparams();	/* get cmdline stuff and compute x,y,u,v,etot,lz */  optr = NULL;				/* make an orbit */  allocate_orbit (&optr, 3, 1);  Masso(optr)  = 1.0;                     /* and set Mass */  Key(optr) = 0;  Torb(optr,0) = tnow;  Xorb(optr,0) = x;			/* .. positions */  Yorb(optr,0) = y;  Zorb(optr,0) = z;  Uorb(optr,0) = u;			/* .. velocities */  Vorb(optr,0) = v;  Worb(optr,0) = w;  I1(optr) = etot;			/*  energy (zero if not used) */  I2(optr) = lz;                          /* angular momentum */    dprintf(0,"pos: %f %f %f  /nvel: %f %f %f  /netot: %f/nlz=%f/n",	  x,y,z,u,v,w,etot,lz);  outstr = stropen (outfile,"w");		/* write to file */  put_history(outstr);  PotName(optr) = p.name;  PotPars(optr) = p.pars;  PotFile(optr) = p.file;  write_orbit(outstr,optr);  strclose(outstr);}

int main(int argc, string argv[]){  string prog, itags[MaxBodyFields], otags[MaxBodyFields];  stream xstr, ostr;  bodyptr btab = NULL;  int nbody;  real tnow;  initparam(argv, defv);  exprs[0] = getparam("weight");  prog = mktemp((string) copxstr("/tmp/sm_XXXXXX", sizeof(char)));  buildmap(prog, names, exprs, types, NULL, Precision, NDIM, TRUE);  xstr = execmap(prog);  if (get_tag_ok(xstr, "History"))    skip_item(xstr);  get_history(xstr);  ostr = stropen(getparam("out"), "w");  put_history(ostr);  new_field(&WeightField, RealType, "Weight");  new_field(&WeightField + 1, NULL, NULL);  while (get_snap(xstr, &btab, &nbody, &tnow, itags, TRUE)) {    snaprect(btab, nbody);    del_tag(otags, itags, "Weight");    put_snap(ostr, &btab, &nbody, &tnow, otags);  }  strclose(ostr);  if (unlink(prog) != 0)    error("%s: can't unlink %s/n", getargv0(), prog);  return (0);}

int main(int argc, string argv[]){  stream istr, ostr;  bodyptr btab = NULL;  int nbody;  real tnow;  string intags[MaxBodyFields];  gsprof *gsp;  initparam(argv, defv);  layout_body(bodyfields, Precision, NDIM);  istr = stropen(getparam("in"), "r");  get_history(istr);  if (! get_snap(istr, &btab, &nbody, &tnow, intags, FALSE))    error("%s: snapshot input failed/n", getargv0());  if (! set_member(intags, PosTag))    error("%s: position data missing/n", getargv0());  if (! set_member(intags, MassTag))    error("%s: mass data missing/n", getargv0());  gsp = snapgsp(btab, nbody, getiparam("npoint"),		getdparam("alpha"), getdparam("beta"));  if (! strnull(getparam("out"))) {    ostr = stropen(getparam("out"), "w");    put_history(ostr);    put_gsprof(ostr, gsp);    strclose(ostr);  }  return (0);}

int main(int argc, string argv[]){    stream istr, ostr;    string itags[MaxBodyFields];    initparam(argv, defv);    new_field(&LinkField, IntType, LinkTag);	/* use int's worth of space */    new_field(&LinkField + 1, NULL, NULL);    layout_body(bodytags, Precision, NDIM);    istr = stropen(getparam("in"), "r");    get_history(istr);    if (! get_snap(istr, &btab, &nbody, &tnow, itags, TRUE))        error("%s: snapshot input failed/n", getargv0());    if (! set_member(itags, PosTag))        error("%s: %s data missing/n", getargv0(), PosTag);    if (getbparam("subkey") && ! set_member(itags, KeyTag))        error("%s: %s data missing/n", getargv0(), KeyTag);    findobj(getdparam("bcrit"),	getiparam("nmin"), getbparam("subkey"));    ostr = stropen(getparam("out"), "w");    put_history(ostr);    put_snap(ostr, &btab, &nbody, &tnow,             set_union(itags, set_cons(KeyTag, NULL)));    strclose(ostr);    return (0);}

void restorestate(string file){    stream str;    string program, version;    str = stropen(file, "r");			// open state input file    program = get_string(str, "program");    version = get_string(str, "version");    if (! streq(program, getprog()) ||		// check program, version            ! streq(version, getversion()))        eprintf("[%s: warning: state file may be outdated]/n", getprog());    headline = get_string(str, "headline");	// read control parameters    get_data(str, "dtime", RealType, &dtime, 0);    get_data(str, "nstatic", IntType, &nstatic, 0);#if !defined(QUICKSCAN)    get_data(str, "theta", RealType, &theta, 0);#endif    get_data(str, "usequad", BoolType, &usequad, 0);    get_data(str, "eps", RealType, &eps, 0);    options = get_string(str, "options");    outputs = get_string(str, "outputs");    get_data(str, "tstop", RealType, &tstop, 0);    get_data(str, "dtout", RealType, &dtout, 0);    get_data(str, "tnow", RealType, &tnow, 0);	// read state variables    get_data(str, "tout", RealType, &tout, 0);    get_data(str, "nstep", IntType, &nstep, 0);    get_data(str, "rsize", RealType, &rsize, 0);    get_data(str, "nbody", IntType, &nbody, 0);    get_data(str, "timesteps", IntType, &nbody, 0);    bodytab = (bodyptr) allocate(nbody * sizeof(body));    get_data(str, "bodytab", AnyType, bodytab, nbody, sizeof(body), 0);    strclose(str);}

void nemo_main(){    int i, nrad, n;    int mode = getiparam("mode");    if (mode==1) {      dubinski();      return;    }    sign_L = getdparam("sign");    nrad = nemoinpi(getparam("nbody"),nbody,MAXRAD);    n = nemoinpd(getparam("radius"),radius,MAXRAD);    if (n!=nrad) error("radius=");    n = nemoinpd(getparam("mass"),mass,MAXRAD);    if (n!=nrad) error("mass=");    n = nemoinpd(getparam("phi"),phi,MAXRAD);    if (n!=nrad) error("phi=");    nobj_max = nbody[0];    for (i=1; i<nrad; i++)      if (nbody[i] > nobj_max) nobj_max = nbody[i];    pmass = (real *) allocate(sizeof(real)*nobj_max);    pphase = allocate_mdarray3(nobj_max,2,NDIM);    headline = getparam("headline");    for (i=0; i<nrad; i++) {      makering(nbody[i],mass[i],radius[i],phi[i]);      writesnap(nbody[i]);    }    strclose(outstr);    nemo_dprintf(1,"Total number of particles written: %d/n",ntot);}

int savestate(string file){    stream str;    str = stropen(file, "a");			/* open state output file   */    fseek(str, 0L, 0);				/* rewind stream to origin  */    put_string(str, "program", getargv0());    put_string(str, "version", getparam("VERSION"));    put_string(str, "headline", headline);	/* save control parameters  */    put_data(str, "freq", RealType, &freq, 0);    put_data(str, "mode", IntType, &mode, 0);    put_data(str, "eps1", RealType, &eps1, 0);    put_data(str, "eps2", RealType, &eps2, 0);    put_string(str, "options", options);    put_data(str, "tstop", RealType, &tstop, 0);    put_data(str, "minor_freqout", RealType, &minor_freqout, 0);    put_data(str, "freqout", RealType, &freqout, 0);    put_data(str, "tnow", RealType, &tnow, 0);	/* save state variables     */    put_data(str, "minor_tout", RealType, &minor_tout, 0);    put_data(str, "tout", RealType, &tout, 0);    put_data(str, "nbody", IntType, &nbody, 0);    put_data(str, "bodytab", AnyType, bodytab, nbody, sizeof(body), 0);    put_data(str, "qfld", AnyType, &qfld, sizeof(qfld), 0);    strclose(str);}

void testing(string name, string mode, string text, bool del){    char buf[128];    stream str;    str = stropen(name, mode);    dprintf(0,"%s has strname -> %s/n", name, strname(str));    dprintf(0,"%s has strseek -> %d/n", name, strseek(str)?1:0);    if (streq(mode, "a") || streq(mode, "r")) {        printf("READING/n");	while (fgets(buf, 127, str) != NULL)	    printf("%s", buf);    }    if (streq(mode,"w") || streq(mode,"w!") ||	streq(mode,"s") || streq(mode,"a")) {        printf("WRITING/n");        sprintf(buf, "%s/n", text);	fputs(buf, str);    }    if (streq(mode, "s")) {      printf("REWIND AND READING/n");        rewind(str);	while (fgets(buf, 127, str) != NULL)	    printf("%s", buf);    }    if (del)        strdelete(str,TRUE);    else        strclose(str);}

int main(int argc, string argv[]){    stream istr, ostr;    gsprof *gsp;    int np, i;    real r0, lgrs, r;    initparam(argv, defv);    istr = stropen(getparam("in"), "r");    get_history(istr);    gsp = get_gsprof(istr);    if (! strnull(getparam("out"))) {	ostr = stropen(getparam("out"), "w");	put_history(ostr);	put_gsprof(ostr, gsp);	strclose(ostr);    }    np = getiparam("npoint");    r0 = 1.0 / getdparam("r0inv");    lgrs = getdparam("lgrstep");    printf("%12s%12s%12s%12s%12s%12s/n",	   "radius", "log rho", "drho/dr", "mass", "mtot-mass", "radius(m)");    for (i = 0; i < np; i++) {	r = r0 * rpow(2.0, lgrs * i);	printf("%12.5f%12.7f%12.3e%12.8f%12.8f%12.5f/n", r,	       rlog10(rho_gsp(gsp, r)), drho_gsp(gsp, r),	       mass_gsp(gsp, r), gsp->mtot - mass_gsp(gsp, r),	       r_mass_gsp(gsp, mass_gsp(gsp, r)));    }    free_gsprof(gsp);    return (0);}

int main(int argc, string argv[]){  string prog, itags[MaxBodyFields];  stream xstr, ostr;  int nold = -1;  initparam(argv, defv);  exprs[0] = getparam("group");  prog = mktemp((string) copxstr("/tmp/sm_XXXXXX", sizeof(char)));  buildmap(prog, names, exprs, types, NULL, Precision, NDIM, TRUE);  xstr = execmap(prog);  if (get_tag_ok(xstr, "History"))    skip_item(xstr);  get_history(xstr);  ostr = stropen(getparam("out"), "w");  put_history(ostr);  new_field(&GroupField, IntType, "Group");  new_field(&GroupField + 1, NULL, NULL);  layout_body(btags, Precision, NDIM);  while (get_snap(xstr, &bodytab, &nbody, &tbody, itags, FALSE)) {    snaptrak();    put_snap(ostr, &traktab, &ntrak, &tbody, otags);    if (ntrak != nold)      eprintf("[%s: wrote %d groups at t = %f]/n",	      getprog(), ntrak, tbody);    nold = ntrak;  }  strclose(ostr);  if (unlink(prog) != 0)    error("%s: can't unlink %s/n", getprog(), prog);  return (0);}

nemo_main(){    imageptr iptr=NULL, optr=NULL;    string *filename;    stream instr, outstr;    int i, j, i0, j0, nfiles;    int nx, ny, nx1, ny1, ix, iy, n;    nx = hasvalue("nx") ? getiparam("nx") : 0;    ny = hasvalue("ny") ? getiparam("ny") : 0;        filename = burststring(getparam("in")," ,/n");    nfiles = xstrlen(filename,sizeof(string))-1;    if (nx==0 && ny==0)      error("Need at least one of nx= or ny=");    else if (nx==0) {      nx = nfiles/ny;      dprintf(0,"nx=%d ny=%d nfiles=%d/n",nx,ny,nfiles);      if (nfiles % ny) error("nfiles=%d/ny=%d does not divide evenly",nfiles,ny);    } else if (ny==0) {      ny = nfiles/nx;      dprintf(0,"nx=%d ny=%d nfiles=%d/n",nx,ny,nfiles);      if (nfiles % nx) error("nfiles=%d/nx=%d does not divide evenly",nfiles,nx);    }    for (iy=0, n=0; iy<ny; iy++) {      for (ix=0; ix<nx; ix++, n++) {	instr = stropen (filename[n],"r");	read_image (instr,&iptr);               /* read image */	strclose(instr);                        /* close image file */	if (n==0) {	  nx1 = Nx(iptr);	  ny1 = Ny(iptr);	  create_image(&optr,nx*nx1,ny*ny1);	}	i0 = ix*nx1;	j0 = iy*ny1;	for (j=0; j<ny1; j++)	  for (i=0; i<nx1; i++)	    MapValue(optr,i+i0,j+j0) = MapValue(iptr,i,j);	i++;      }    }    outstr = stropen(getparam("out"),"w");    write_image(outstr,optr);    strclose(outstr);}

local void read_data(){  int   i, k, ndata, n;  real *data;  stream instr;  imageptr iptr=NULL;	  instr = stropen (input, "r");  read_image (instr,&iptr);  strclose(instr);  ndata = Nx(iptr) * Ny(iptr) * Nz(iptr);  data = Frame(iptr);  x = (real *) allocate(ndata*sizeof(real));  if (scale != 1.0) {    for (i=0; i<ndata; i++)      data[i] *= scale;  }  if (Qdual) {    /* pass over the data, finding the mean */    dual_mean = 0.0;    n = 0;    for (i=0; i<ndata; i++) {      if (Qblank && data[i]==blankval) continue;      dual_mean += data[i];      n++;    }    dual_mean /= n;    dprintf(0,"Dual pass mean       : %g/n",dual_mean);  } else    dual_mean = 0.0;  Nunder = Nover = Nblank = 0;  for (i=0, k=0; i<ndata; i++) {    if (Qblank && data[i]==blankval) { Nblank++; continue;}    data[i] -= dual_mean;    if (Qmin && data[i] < xrange[0]) { Nunder++; continue;}    if (Qmax && data[i] > xrange[1]) { Nover++;  continue;}    /* should now copy data into new array for later work */    x[k++] = data[i];  }  npt = k;  dprintf(0,"Under/Over flow: %d %d/n",Nunder,Nover);  dprintf(0,"Blanked:         %d/n",Nblank);  minmax(npt, x, &xmin, &xmax);  if (!Qmin) xrange[0] = xmin;  if (!Qmax) xrange[1] = xmax;  /*  allocate index arrray , and compute sorted index for median */  if (Qmedian)     (mysort)(x,npt,sizeof(real),compar_real);  free_image(iptr);}

void nemo_main(void){    stream instr, outstr;    real   tsnap;    string times;    Body *btab = NULL, *bp;    float mass, pos[NDIM], vel[NDIM], t;    int j, nbody, bits;                instr = stropen(getparam("in"), "r");	/* open input file */    outstr = stropen(getparam("out"), "w");	/* open output file */    times = getparam("times");    get_history(instr);                 /* read history */    for(;;) {                /* repeating until first or all times are read */	get_history(instr);        if (!get_tag_ok(instr, SnapShotTag))            break;                                  /* done with work */        get_snap(instr, &btab, &nbody, &tsnap, &bits);        if (!streq(times,"all") && !within(tsnap,times,0.0001))            continue;                   /* skip work on this snapshot */        if ( (bits & PhaseSpaceBit) == 0)            continue;                   /* skip work, only diagnostics here */        dprintf(0,"Converting time=%f to RV format",tsnap);        	fwrite(&nbody,sizeof(int),1,outstr);        for (bp = btab; bp < btab+nbody; bp++) {	    mass = Mass(bp);            fwrite(&mass,sizeof(float),1,outstr);        }        t = tsnap;        fwrite(&t,sizeof(float),1,outstr);        for (bp = btab; bp < btab+nbody; bp++) {	    for(j = 0; j < NDIM; j++) {		pos[j] = Pos(bp)[j];		vel[j] = Vel(bp)[j];	    }	    fwrite(pos,sizeof(float),NDIM,outstr);	    fwrite(vel,sizeof(float),NDIM,outstr);        }    }    strclose(instr);    strclose(outstr);}

void nemo_main(){  int n;  stream parstr, outstr;  string molfile = getparam("mol");  string outfile = getparam("out");  string outdir  = getparam("outdir");  string exefile = "radex";  string datfile = "mol.dat";  string parfile = "input.txt";  string logfile = "radex.txt";  char dname[256], cmd[256];  real  fmin = getdparam("fmin");  real  fmax = getdparam("fmax");  real  tkin = getdparam("tkin");  int   npartner;  string *partner;  real  density[MAXPARTNER];  real  tbg = getdparam("tbg");  real  cdmol = getdparam("cdmol");  real  deltav = getdparam("deltav");  partner = burststring(getparam("partner"),",");  npartner = xstrlen(partner,sizeof(string))-1;  if (npartner < 1 || npartner>MAXPARTNER) error("too few/many partners");  n = nemoinpr(getparam("density"),density,MAXPARTNER);  if (n != npartner) error("need matching numbers for partner= and density=");  run_mkdir(outdir);  sprintf(dname,"%s/%s",outdir,parfile);  parstr = stropen(dname,"w");  fprintf(parstr,"%s/n",molfile);  fprintf(parstr,"%s/n",outfile);  fprintf(parstr,"%g %g/n",fmin,fmax);  fprintf(parstr,"%g/n",tkin);  fprintf(parstr,"%d/n",npartner);  for (n=0; n<npartner; n++) {    fprintf(parstr,"%s/n",partner[n]);    fprintf(parstr,"%g/n",density[n]);  }   fprintf(parstr,"%g/n",tbg);  fprintf(parstr,"%g/n",cdmol);  fprintf(parstr,"%g/n",deltav);  fprintf(parstr,"0/n");  strclose(parstr);  run_cd(outdir);  sprintf(cmd,"%s < %s > %s ", exefile, parfile, logfile);  run_sh(cmd);}