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

int prot_x (int connfd){	XDR xdrs_r, xdrs_w;	//char buf[MAXBUFL];	//int nread;	int op1 = 0;	int op2 = 0;	int res;	//xdrmem_create(xdrs, buf, MAXBUFL, XDR_DECODE);	FILE *stream_socket_r = fdopen(connfd, "r");	if (stream_socket_r == NULL)		err_sys ("(%s) error - fdopen() failed", prog_name);	xdrstdio_create(&xdrs_r, stream_socket_r, XDR_DECODE);	FILE *stream_socket_w = fdopen(connfd, "w");	if (stream_socket_w == NULL)		err_sys ("(%s) error - fdopen() failed", prog_name);	xdrstdio_create(&xdrs_w, stream_socket_w, XDR_ENCODE);	trace( err_msg("(%s) - waiting for operands ...", prog_name) );	/* get the operands */	if ( ! xdr_int(&xdrs_r, &op1) ) {		trace( err_msg("(%s) - cannot read op1 with XDR", prog_name) );	} else {		trace( err_msg("(%s) - read op1 = %d", prog_name, op1) );	}	if ( ! xdr_int(&xdrs_r, &op2) ) {		trace( err_msg("(%s) - cannot read op2 with XDR", prog_name) );	} else {		trace( err_msg("(%s) - read op2 = %d", prog_name, op2) );	}	/* do the operation */	res = op1 + op2;	xdr_destroy(&xdrs_r);	trace( err_msg("(%s) --- result of the sum: %d", prog_name, res) );	/* send the result */	xdr_int(&xdrs_w, &res);	fflush(stream_socket_w);	xdr_destroy(&xdrs_w);	fclose(stream_socket_w);	/* NB: Close read streams only after writing operations have also been done */	fclose(stream_socket_r);	trace( err_msg("(%s) --- result just sent back", prog_name) );	return 0;}

intmbbs_rdversion(FILE *fp, int *version){	XDR xdrs;	if (sizeof(int) < 4)		return BS_BADARCH;	bs_iobytecnt= 0;	xdrstdio_create(&xdrs, fp, XDR_DECODE);	if (!xdr_int(&xdrs, version))		return BS_FAILURE;	bs_iobytecnt+= 4;	switch (*version) {	case MR1_VERSION_1_0:	case MR1_VERSION_2_0:	case BS_VERSION_1_0:	case BS_VERSION_1_1:	case BS_VERSION_1_2:	case BS_VERSION_1_3:	case BS_VERSION_1_4:		break;	default:		return BS_BADDATA;	}	xdr_destroy(&xdrs);	return BS_SUCCESS;}

main (){        FILE *fp;                  /*указатель файла */        XDR xdrs;                  /*дескpиптоp XDR */        long val1=10;              /*целое */        float val2=4.456789;       /*с плавающей точкой */        char val3s[] = "qwerty123456uvwxyz"; /* 18+1 bytes null terminated string */        char *val3;        int r;        val3 = malloc(20);        strcpy(val3,val3s);/*откpытие файла на запись */        fp = fopen(FIC, "w");/*      создание потока XDR для кодиpования */        xdrstdio_create(&xdrs, fp, XDR_ENCODE);/*запись целого */        xdr_long(&xdrs, &val1);/*запись числа с плавающей точкой */        xdr_float(&xdrs, &val2);/* write string */        r = xdr_string(&xdrs, &val3, strlen(val3));        printf("r=%d/n",r);        free(val3);        fclose(fp);        exit(0);}

static void *read_nis_obj (const char *name, iofct_t readfct, freefct_t freefct,	      size_t objsize){  FILE *in = fopen (name, "rce");  if (in == NULL)    return NULL;  void *obj = calloc (1, objsize);  if (obj != NULL)    {      XDR xdrs;      xdrstdio_create (&xdrs, in, XDR_DECODE);      bool_t status = readfct (&xdrs, obj);      xdr_destroy (&xdrs);      if (!status)	{	  freefct (obj);	  obj = NULL;	}    }  fclose (in);  return obj;}

static bool_twrite_struct(char *filename, xdrproc_t structproc, void *list){	FILE *fp;	XDR xdrs;	mode_t omask;	omask = umask(077);	fp = fopen(filename, "w");	if (fp == NULL) {		int i;		for (i = 0; i < 10; i++)			close(i);		fp = fopen(filename, "w");		if (fp == NULL) {			syslog(LOG_ERR,				"cannot open file = %s for writing", filename);			syslog(LOG_ERR, "cannot save any registration");			return (FALSE);		}	}	(void) umask(omask);	xdrstdio_create(&xdrs, fp, XDR_ENCODE);	if (structproc(&xdrs, list) == FALSE) {		syslog(LOG_ERR, "rpcbind: xdr_%s: failed", filename);		fclose(fp);		return (FALSE);	}	XDR_DESTROY(&xdrs);	fclose(fp);	return (TRUE);}

/* opens test file for read or write */bool_txdrstdio_create_cb (XDR *xdrs, enum xdr_op op, void * data){  bool_t rVal = TRUE;  xdrstdio_creation_data* xdrstdio_data = (xdrstdio_creation_data*)data;  switch (op)    {      case XDR_DECODE:      case XDR_FREE:        xdrstdio_data->f = fopen (xdrstdio_data->fullname, FOPEN_RB);        break;      case XDR_ENCODE:        xdrstdio_data->f = fopen (xdrstdio_data->fullname, FOPEN_WB);        break;    }  if (!xdrstdio_data->f)    {      log_msg (xdrstdio_data->o->log, XDR_LOG_NORMAL,               "could not open data file: %s/n", xdrstdio_data->fullname);      rVal = FALSE;    }  else    {      xdrstdio_create (xdrs, xdrstdio_data->f, op);      xdrstdio_data->finish_guard = 1;    }  return rVal;}

nis_object *nis_read_obj (const char *name){  XDR xdrs;  FILE *in;  bool_t status;  nis_object *obj;  in = fopen (name, "rb");  if (in == NULL)    return NULL;  obj = calloc (1, sizeof (nis_object));  if (obj == NULL)    {      fclose (in);      return NULL;    }  xdrstdio_create (&xdrs, in, XDR_DECODE);  status =_xdr_nis_object (&xdrs, obj);  xdr_destroy (&xdrs);  fclose (in);  if (status)    return obj;  else    {      nis_free_object (obj);      return NULL;    }}

void *restore_data(void *data){//Deserialization  /*This way I can actually recover the data in the same process*/  container *old_data;  old_data=(container *) malloc(sizeof(container));  FILE *fp;  XDR xdrs;  fp=fopen(ser_process_var,"r");  xdrstdio_create(&xdrs,fp, XDR_DECODE);   if(!xdr_container(&xdrs,old_data)) printf("Deserialization error/n"); //Do sth!!!   //else printf("Data restored/n");   xdr_destroy (&xdrs);  fclose (fp);//  printf("From old version:/nage %f    name %s   address %s   option %d/n",old_data->age,old_data->name, old_data->address, old_data->option);    container_2 *new_data;  new_data=(container_2 *) malloc(sizeof(container_2));    new_data->name=old_data->name;  new_data->num_executions=(int)old_data->num_executions;//  printf("Restored :/nage %d    name %s   address %s   option %d/n",new_data->age,new_data->name, new_data->address, new_data->option);    free(old_data);  return (void *)new_data;}

directory_obj *readColdStartFile (void){  XDR xdrs;  FILE *in;  bool_t status = TRUE;  directory_obj *obj;  in = fopen (cold_start_file, "rb");  if (in == NULL)    return NULL;  obj = calloc (1, sizeof (directory_obj));  if (obj != NULL)    {      xdrstdio_create (&xdrs, in, XDR_DECODE);      status = _xdr_directory_obj (&xdrs, obj);      xdr_destroy (&xdrs);      if (!status)	{	  nis_free_directory (obj);	  obj = NULL;	}    }  fclose (in);  return obj;}

int mda_dump( char *file){  XDR xdrstream;  FILE *input;  int extraflag;  if( (input = fopen( file, "rb")) == NULL)    {      fprintf(stderr, "Can't open file!/n");      return 1;    }  xdrstdio_create(&xdrstream, input, XDR_DECODE);    extraflag = mda_dump_header( &xdrstream);  mda_dump_scan( &xdrstream);  if( extraflag)    mda_dump_extra( &xdrstream);  xdr_destroy( &xdrstream);  fclose(input);  return 0;}

long *kdReadLongArray(char *filename, int bAscii, char *arrayName)// Reads a tipsy array file{  XDR xdrs;  FILE *fp;  long np;  long *arr, temp;  int i;  char arrFile[256];  strcpy(arrFile, filename);  strcat(arrFile, ".");  strcat(arrFile, arrayName);  fprintf(stderr, "array = %s/n", arrFile);  if (!bAscii) {    assert(sizeof(Real)==sizeof(float)); /* Otherwise, this XDR stuff					    ain't gonna work */        fp = fopen(arrFile, "r");    xdrstdio_create(&xdrs, fp, XDR_DECODE);    xdr_long(&xdrs, &np);    arr = malloc(sizeof(float)*np);    for(i=0;i<np;i++) xdr_long(&xdrs,&temp);  }  fclose(fp);    return arr; }

main(){  xdrstdio_create(&xdrs, stdin, XDR_DECODE);  forever {	if(xdr_header() != 1)	  break;	if(gas_particles != NULL) free(gas_particles);	if(header.nsph != 0) {	    gas_particles = (struct gas_particle *)				malloc(header.nsph*sizeof(*gas_particles));	    if(gas_particles == NULL) {		printf("<sorry, no memory for gas particles, master>/n") ;		return ;	    }	}	else	  gas_particles = NULL;	if(dark_particles != NULL) free(dark_particles);	if(header.ndark != 0) {	    dark_particles = (struct dark_particle *)				malloc(header.ndark*sizeof(*dark_particles));	    if(dark_particles == NULL) {		printf("<sorry, no memory for dark particles, master>/n") ;		return ;	    }	}	else	  dark_particles = NULL;	if(star_particles != NULL) free(star_particles);	if(header.nstar != 0) {	    star_particles = (struct star_particle *)				malloc(header.nstar*sizeof(*star_particles));	    if(star_particles == NULL) {		printf("<sorry, no memory for star particles, master>/n") ;		return ;	    }	}	else	  star_particles = NULL;	xdr_gas();	xdr_dark();	xdr_star();		fwrite((char *)&header,sizeof(header),1,stdout) ;	fwrite((char *)gas_particles,sizeof(struct gas_particle),	      header.nsph, stdout) ;	fwrite((char *)dark_particles,sizeof(struct dark_particle),	       header.ndark,stdout) ;	fwrite((char *)star_particles,sizeof(struct star_particle),	      header.nstar, stdout) ;  	fprintf(stderr, "read time %lf/n",header.time) ;      }  xdr_destroy(&xdrs);}

intmain (){  XDR xdr;  stringlist strings;  stringentry *entry;  FILE *fp;  fp = fopen ("test1.out", "w");  xdrstdio_create (&xdr, fp, XDR_ENCODE);  strings = malloc (sizeof (struct stringentry));  strings->item = strdup ("hello");  strings->next = malloc (sizeof (struct stringentry));  strings->next->item = strdup ("goodbye");  strings->next->next = NULL;  if (!xdr_stringlist (&xdr, &strings)) {    fprintf (stderr, "test1: could not encode/n");    exit (1);  }  xdr_free ((xdrproc_t) xdr_stringlist, (char *) &strings);  xdr_destroy (&xdr);  fclose (fp);  fp = fopen ("test1.out", "r");  xdrstdio_create (&xdr, fp, XDR_DECODE);  strings = NULL;  if (!xdr_stringlist (&xdr, &strings)) {    fprintf (stderr, "test1: could not decode/n");    exit (1);  }  fclose (fp);  for (entry = strings; entry; entry = entry->next)    printf ("entry->item = %s/n", entry->item);  xdr_free ((xdrproc_t) xdr_stringlist, (char *) &strings);  xdr_destroy (&xdr);  exit (0);}

/**  * Write a SAC data file from memory to disk is XDR (portable) format *  * @param idfl  *    Data file list index number * @param kname  *    Name of file to write * @param kname_s  *    Length of /p kname * @param ldta  *    - TRUE to write the data and header *    - FALSE to write only the header, not data * @param nerr  *    Error Return Flag *    - 0 on Success *    - ERROR_WRITING_XDR_FILE *    - ERROR_ENCODING_XDR_FILE * * @date   010496:  Original version. * */void wrxdr(int   idfl,       char *kname,       int   kname_s,       int   ldta,       int  *nerr) {	int jcomp, ncerr, nlcmem, nptwr;         FILE *nun;        XDR xdrs;	*nerr = 0;        if( !ldta ){          *nerr = ERROR_WRITING_XDR_FILE;          return;	}	/* create a file */	znfiles(&nun, kname, kname_s, "TEXT", 5, nerr);	if( *nerr != 0 )	    return;	/* create a stream for the XDR conversions */	xdrstdio_create(&xdrs, nun, XDR_ENCODE);	/* - Write the header to disk. */	nlcmem = Ndxhdr[idfl];	xdrhdr(xdrs, cmmem.sacmem[nlcmem],nerr);	if( *nerr != 0 )	    goto L_8888;	/* - Write each data component, if requested. */	if( ldta ){	    for( jcomp = 0; jcomp < Ncomp[idfl]; jcomp++ ){		nlcmem = cmdfm.ndxdta[idfl - 1][jcomp];		nptwr = Nlndta[idfl];		if( !xdr_array(&xdrs, (caddr_t *)&cmmem.sacmem[nlcmem],		    (u_int *)&nptwr, (u_int)nptwr, sizeof(float), xdr_float)){		    *nerr = ERROR_ENCODING_XDR_FILE;		    goto L_8888;		}	    }	}/* - Close disk file. */L_8888:        xdr_destroy(&xdrs);	zcloses( &nun, &ncerr );	return;} 

void mint_1_readfh(mint_1 *dest, FILE *fh){	XDR xdrs;	xdrstdio_create(&xdrs, fh, XDR_DECODE);	if (!xdr_mint_1(&xdrs, dest))		panic("error decoding MINT input file");	xdr_destroy(&xdrs);	mint_1_check(dest);}

/* aoi_readfh() uses rpcgen-created routes to read in AOI.*/void aoi_readfh(aoi *dest, FILE *fh){    XDR xdrs;    xdrstdio_create(&xdrs, fh, XDR_DECODE);    if (!xdr_aoi(&xdrs, dest))        panic("error decoding AOI input file");    xdr_destroy(&xdrs);    aoi_check(dest);}

intssioOpen(const char *filename,SSIO *ssio,const u_int mode) {    const char type[][3] = {"r","w","r+"};    const enum xdr_op op[] = {XDR_DECODE,XDR_ENCODE,XDR_ENCODE};    assert(filename != NULL && ssio != NULL);    assert(mode == SSIO_READ || mode == SSIO_WRITE || mode == SSIO_UPDATE);    if (!(ssio->fp = fopen(filename,type[mode])))	return 1;    xdrstdio_create(&ssio->xdrs,ssio->fp,op[mode]);    return 0;    }

void writeInput(void){  const char routineName[] = "writeInput";  bool_t  result=TRUE, PRD_angle_dep, XRD, big_endian;  FILE   *fp_out;  XDR     xdrs;  if (!strcmp(INPUT_DOT_OUT, "none")) return;  if ((fp_out = fopen(INPUT_DOT_OUT, "w")) == NULL) {    sprintf(messageStr, "Unable to open output file %s",	    INPUT_DOT_OUT);    Error(ERROR_LEVEL_1, routineName, messageStr);    return;  }  xdrstdio_create(&xdrs, fp_out, XDR_ENCODE);  PRD_angle_dep = (input.PRD_angle_dep != PRD_ANGLE_INDEP  &&  atmos.NPRDactive > 0);  XRD           = (input.XRD  &&  atmos.NPRDactive > 0);  /* --- Write various input parameters to file --     -------------- */        result &= xdr_bool(&xdrs, &input.magneto_optical);  result &= xdr_bool(&xdrs, &PRD_angle_dep);  result &= xdr_bool(&xdrs, &XRD);  result &= xdr_enum(&xdrs, (enum_t *) &input.startJ);  result &= xdr_enum(&xdrs, (enum_t *) &input.StokesMode);  result &= xdr_double(&xdrs, &input.metallicity);  result &= xdr_bool(&xdrs, &input.backgr_pol);  /* --- Write Endianness of compute architecture so that J can be         read properly in the analysis --              -------------- */  big_endian = is_big_endian();  result &= xdr_bool(&xdrs, &big_endian);  if (!result) {    sprintf(messageStr, "Unable to write proper amount to output file %s",	    INPUT_DOT_OUT);    Error(ERROR_LEVEL_1, routineName, messageStr);  }  xdr_destroy(&xdrs);  fclose(fp_out);}

static bool_twrite_nis_obj (const char *name, const void *obj, iofct_t writefct){  FILE *out = fopen (name, "wce");  if (out == NULL)    return FALSE;  XDR xdrs;  xdrstdio_create (&xdrs, out, XDR_ENCODE);  bool_t status = writefct (&xdrs, (void *) obj);  xdr_destroy (&xdrs);  fclose (out);  return status;}

void gmx_fio_rewind(t_fileio* fio){    gmx_fio_lock(fio);    if (fio->xdr)    {        xdr_destroy(fio->xdr);        frewind(fio->fp);        xdrstdio_create(fio->xdr, fio->fp, fio->xdrmode);    }    else    {        frewind(fio->fp);    }    gmx_fio_unlock(fio);}

int save_data(void *data){    container_2 *old_data;  old_data=(container_2 *)data;  //printf("Before serialization: %s/n",old_data->name);  XDR xdrs;  //Serialization  FILE *fp;  fp=fopen(ser_process_var,"w");  xdrstdio_create(&xdrs,fp, XDR_ENCODE);  if(!xdr_container(&xdrs,old_data)) {printf("Serialization error/n"); return 1;}  //else printf("Data saved/n");   xdr_destroy (&xdrs);  fclose (fp);  return 0;}

//read decode from ./w and encodeintmain(int argc, char *argv[]){    XDR xdr;    long j;    xdrstdio_create(&xdr, stdin, XDR_DECODE);    for (int i =0; i < 8; ++i)    {        if ( !xdr_long(&xdr, &j) ) {            fprintf(stderr, "failed");            exit(1);        }        printf("%ld/n", j);    }    printf("/n");    return 0;}

bool_twriteColdStartFile (const directory_obj *obj){  XDR xdrs;  FILE *out;  bool_t status;  out = fopen (cold_start_file, "wb");  if (out == NULL)    return FALSE;  xdrstdio_create (&xdrs, out, XDR_ENCODE);  status = _xdr_directory_obj (&xdrs, (directory_obj *) obj);  xdr_destroy (&xdrs);  fclose (out);  return status;}

bool_tnis_write_obj (const char *name, const nis_object *obj){  XDR xdrs;  FILE *out;  bool_t status;  out = fopen (name, "wb");  if (out == NULL)    return FALSE;  xdrstdio_create (&xdrs, out, XDR_ENCODE);  status = _xdr_nis_object (&xdrs, (nis_object *) obj);  xdr_destroy (&xdrs);  fclose (out);  return status;}

static bool_tread_struct(char *filename, xdrproc_t structproc, void *list){	FILE *fp;	XDR xdrs;	struct stat sbuf;	if (stat(filename, &sbuf) != 0) {		fprintf(stderr,		"rpcbind: cannot stat file = %s for reading/n", filename);		goto error;	}	if ((sbuf.st_uid != 0) || (sbuf.st_mode & S_IRWXG) ||	    (sbuf.st_mode & S_IRWXO)) {		fprintf(stderr,		"rpcbind: invalid permissions on file = %s for reading/n",			filename);		goto error;	}	fp = fopen(filename, "r");	if (fp == NULL) {		fprintf(stderr,		"rpcbind: cannot open file = %s for reading/n", filename);		goto error;	}	xdrstdio_create(&xdrs, fp, XDR_DECODE);	if (structproc(&xdrs, list) == FALSE) {		fprintf(stderr, "rpcbind: xdr_%s: failed/n", filename);		fclose(fp);		goto error;	}	XDR_DESTROY(&xdrs);	fclose(fp);	return (TRUE);error:	fprintf(stderr, "rpcbind: will start from scratch/n");	return (FALSE);}

intmain(){    struct gas_particle gas;    struct dark_particle dark;    struct star_particle star;    struct dump header;    int i;    XDR xdrs;  setvbuf(stdin, NULL, _IOFBF, 32*4096);  setvbuf(stdout, NULL, _IOFBF, 32*4096);  xdrstdio_create(&xdrs, stdout, XDR_ENCODE);  forever {	if(fread((char *)&header,sizeof(header),1,stdin) != 1)	  break;	fprintf(stderr, "reading time %f/n",header.time) ;	xdr_header(&xdrs, &header);	for(i = 0; i < header.nsph; i++) {	    fread((char *)&gas,sizeof(struct gas_particle), 1, stdin) ;	    xdr_gas(&xdrs, &gas);	}	for(i = 0; i < header.ndark; i++) {	    fread((char *)&dark,sizeof(struct dark_particle), 1, stdin) ;	    xdr_dark(&xdrs, &dark);	}	for(i = 0; i < header.nstar; i++) {	    fread((char *)&star,sizeof(struct star_particle), 1, stdin) ;	    xdr_star(&xdrs, &star);	}		fprintf(stderr, "read time %f/n",header.time) ;      }  xdr_destroy(&xdrs);  return 0;}

main(){ XDR xdr; FILE* fp = fopen("test", "r+"); if(fp) {   xdrstdio_create(&xdr, fp, XDR_DECODE);    RWXDRistream rw_xdr(&xdr);   int data;   for(int i=0; i<10; ++i)     {       rw_xdr >> data;      // decode integer data       if(data == i)         cout << data << endl;       else         cout << "Bad input value" << endl;     }    fclose(fp);  }  else

void XdrMGF::init (XdrMGF::XdrIO_TYPE t, const char* fn, const char*, int){  m_type=t;  // Close old file if necessary  if (mp_fp) this->fini();  // Open file  switch (m_type)    {#ifdef LIBMESH_HAVE_XDR    case (XdrMGF::ENCODE):    case (XdrMGF::DECODE):      {        mp_fp = fopen (fn, (m_type == ENCODE) ? "w" : "r");        // Make sure the file is ready for use        if (!mp_fp)          libmesh_error_msg("XDR Error: Accessing file: " << fn << " failed.");        // Create the XDR handle        mp_xdr_handle = new XDR;        xdrstdio_create(mp_xdr_handle,                        mp_fp,                        ((m_type == ENCODE) ? XDR_ENCODE : XDR_DECODE));        break;      }#endif    case (XdrMGF::R_ASCII):      {        mp_in.open(fn, std::ios::in);        // Make sure it opened correctly        if (!mp_in.good())          libmesh_file_error(fn);        break;      }    case (XdrMGF::W_ASCII):      {        mp_out.open(fn, std::ios::out);        // Make sure it opened correctly        if (!mp_out.good())          libmesh_file_error(fn);        break;      }    default:      libmesh_error_msg("Unrecognized file access type!");    }  // Read/Write the file signature  const int  bufLen = 12;  char       buf[bufLen+1];  switch (m_type)    {#ifdef LIBMESH_HAVE_XDR    case (XdrMGF::ENCODE):      {        char* p = &buf[0];        const LegacyXdrIO::FileFormat orig = this->get_orig_flag();        std::ostringstream name;        if (orig == LegacyXdrIO::DEAL)          name << "DEAL 003:003";        else if (orig == LegacyXdrIO::MGF)          name << "MGF  002:000";        else if (orig == LegacyXdrIO::LIBM)          name << "LIBM " << this->get_num_levels();        else          libmesh_error_msg("Unknown orig " << orig);        // Fill the buffer        std::sprintf(&buf[0], "%s", name.str().c_str());        xdr_string(mp_xdr_handle, &p, bufLen);  // Writes binary signature        break;      }    case (XdrMGF::DECODE)://.........这里部分代码省略.........

int main(int argc, char *argv[]){  register int k, l, n, la;  int     Nspace, result, NmaxIter, Ngdelay, Ngorder, Ngperiod, btype[3],          inputs[N_INPUTS], nwrite, Nx, Nz;  double  iterLimit, *lambda, Adamp;  stats.printCPU = TRUE;  commandline.quiet = FALSE;  commandline.logfile = stderr;  input.Eddington = FALSE;  getCPU(0, TIME_START, NULL);  SetFPEtraps();  fpin  = fopen("2dinput.dat", "r");  xdrstdio_create(&xdrs, fpin, XDR_DECODE);  result = xdr_vector(&xdrs, (char *) inputs, N_INPUTS,		      sizeof(int), (xdrproc_t) xdr_int);  atmos.angleSet.set = (enum angleset) inputs[0];  if (atmos.angleSet.set == SET_GL) {     result = xdr_int(&xdrs, &atmos.angleSet.Ninclination);     result = xdr_int(&xdrs, &atmos.angleSet.Nazimuth);  }  result = xdr_double(&xdrs, &iterLimit);  result = xdr_double(&xdrs, &Adamp);  Nx = geometry.Nx = inputs[1];  Nz = geometry.Nz = inputs[2];  NmaxIter = inputs[3];  Ngdelay  = inputs[4];  Ngorder = inputs[5];  Ngperiod = inputs[6];  Nlambda  = inputs[7];  Nspace   = atmos.Nspace = geometry.Nx * geometry.Nz;  result = xdr_vector(&xdrs, (char *) btype, 3,		      sizeof(int), (xdrproc_t) xdr_int);  geometry.hboundary = (enum boundary) btype[0];  for (n = 0;  n < 2;  n++)    geometry.bvalue[n] = (enum boundval) btype[1+n];  /* --- Check the validity of boundary conditions and values -- ---- */   switch (geometry.hboundary) {  case FIXED:     break;  case PERIODIC:  break;  default:    sprintf(messageStr, "Invalid horizontal boundary condition: %d",	    geometry.hboundary);    Error(ERROR_LEVEL_2, argv[0], messageStr);    break;  }  switch (geometry.bvalue[TOP]) {  case IRRADIATED:   break;  case ZERO:         break;  case THERMALIZED:  break;  default:    sprintf(messageStr, "Invalid boundary value at TOP: %d/n",	    geometry.bvalue[TOP]);    Error(ERROR_LEVEL_2, argv[0], messageStr);    break;  }  switch (geometry.bvalue[BOTTOM]) {  case IRRADIATED:   break;  case ZERO:         break;  case THERMALIZED:  break;  default:    sprintf(messageStr, "Invalid boundary value at BOTTOM: %d",	    geometry.bvalue[BOTTOM]);    Error(ERROR_LEVEL_2, argv[0], messageStr);    break;  }  /* --- Get increments in x, store and check for monotonicity -- --- */  geometry.dx = (double *) malloc(Nx * sizeof(double));  result = xdr_vector(&xdrs, (char *) geometry.dx, Nx,		       sizeof(double), (xdrproc_t) xdr_double);  for (l = 0;  l < ((geometry.hboundary == PERIODIC) ? Nx : Nx-1);  l++) {    geometry.dx[l] *= KM_TO_M;    if (geometry.dx[l] <= 0.0) {      sprintf(messageStr, "At l = %d:/n x does not increase strictly "              "monotonically towards the right", l);      Error(ERROR_LEVEL_2, argv[0], messageStr);    }   }  geometry.x = (double *) malloc(Nx * sizeof(double));  geometry.x[0] = 0.0;  for (l = 0;  l < Nx-1;  l++)    geometry.x[l+1] = geometry.x[l] + geometry.dx[l];  /* --- Get vertical grid --                          -------------- */  geometry.z = (double *) malloc(Nz * sizeof(double));  result = xdr_vector(&xdrs, (char *) geometry.z, Nz,		      sizeof(double), (xdrproc_t) xdr_double);  for (k = 0;  k < Nz;  k++) geometry.z[k] *= KM_TO_M;//.........这里部分代码省略.........

intmbbs_splitfile(char *dirnm, char *bsfnm0, char *bsfnm1, int pngid, char *logprefix){	int chngdir, origdirfd, err;	char tmpfilenm[80], prefix[80], newlogtail[120];	char *lp, *tailstr;	FILE *ifp, *ofp;	XDR xdri, xdro;	BSFile bsfi, bsfo;	if (sizeof(int) < 4)		return BS_BADARCH;	if ((bsfnm0 == (char *) 0) ||	    ((int) strlen(bsfnm0) == 0) ||	    (bsfnm1 == (char *) 0) ||	    ((int) strlen(bsfnm1) == 0) ||	    (pngid < 0))		return BS_BADARG;	if ((dirnm == (char *) 0) ||	    ((int) strlen(dirnm) == 0))		chngdir= 0;	else		chngdir= 1;	if (chngdir) {		if ((origdirfd= open(".", O_RDONLY)) < 0)			return BS_OPEN;		if (chdir(dirnm) < 0) {			(void) close(origdirfd);			return BS_CHDIR;		}	}	/* rename original file to temporary name */	(void) strcpy(tmpfilenm, "BSLIBsplittmp");	if (access(tmpfilenm, F_OK) == 0) {		if (chngdir) {			(void) fchdir(origdirfd);			(void) close(origdirfd);		}		return BS_ACCESS;	}	if (rename(bsfnm0, tmpfilenm) < 0) {		if (chngdir) {			(void) fchdir(origdirfd);			(void) close(origdirfd);		}		return BS_RENAME;	}	if ((ifp= fopen(tmpfilenm, "r")) == (FILE *) 0) {		(void) rename(tmpfilenm, bsfnm0);		if (chngdir) {			(void) fchdir(origdirfd);			(void) close(origdirfd);		}		return BS_OPEN;	}	xdrstdio_create(&xdri, ifp, XDR_DECODE);	if ((err= mbbs_rdbsfhdr(&bsfi, &xdri)) != BS_SUCCESS) {		(void) fclose(ifp);		(void) rename(tmpfilenm, bsfnm0);		if (chngdir) {			(void) fchdir(origdirfd);			(void) close(origdirfd);		}		return err;	}	if (pngid >= bsfi.bsf_count) {		(void) mbbs_freebsfmem(&bsfi);		(void) fclose(ifp);		(void) rename(tmpfilenm, bsfnm0);		if (chngdir) {			(void) fchdir(origdirfd);			(void) close(origdirfd);		}		return BS_BADARG;	}	MemCopy(&bsfi, &bsfo, sizeof(BSFile));	/* these strings now belong to the output header! */	bsfi.bsf_srcfilenm= (char *) 0;	bsfi.bsf_log= (char *) 0;	if ((logprefix == (char *) 0) ||	    ((int) strlen(logprefix) == 0)) {		(void) sprintf(prefix, "BSLIB::bs_split()");		lp= prefix;	}	else if ((int) strlen(logprefix) > 50) {		(void) strncpy(prefix, logprefix, 47);		prefix[47]= '/0';		(void) strcat(prefix, "...");		lp= prefix;	}	else		lp= logprefix;	if ((int) strlen(bsfo.bsf_log) > 0)//.........这里部分代码省略.........