cptc_geomsh_utils.c

算断裂的

#include <stdio.h>
#include <time.h>
#include <string.h>
#include <types.h>
#include <xdr.h>
#include "GeoFmt.h"
#include "MshFmt2.h"
#ifndef _WIN32
#include <unistd.h>
#endif

#define cptc_malloc malloc

/* define memory allocation symbols */

#define CPTC_HEADER_SIZE (256)

/* --------------------------------------------------------------------
** xdr_int_vector: encode/decode a vector of ints of specified length
**
** Arguments:
**    xdrs   - XDR stream handle
**    ap     - pointer to vector of ints (int **)
**    num_elements - number of elements in vector
**
** --------------------------------------------------------------------
*/

bool_t xdr_int_vector(XDR* xdrs, int** ap, int num_elements)
{
  int i, *a;

  if (num_elements <= 0) {
    if (xdrs -> x_op == XDR_DECODE)
    *ap = 0;
    return (TRUE);
  }
  if (xdrs->x_op == XDR_DECODE) {
    a = (int *)cptc_malloc(num_elements*sizeof(int));
  }
  else {
    a = *ap;
  }

  for (i = 0; i < num_elements; i++) {
    if (!xdr_int(xdrs, &a[i])) {
      return (FALSE);
    }
  }
  
  if (xdrs->x_op == XDR_DECODE) {
    *ap = a; 
  }

  return (TRUE);
}


/* -------------------------------------------------------------
** generate_Cptc_header: generate the standard file header and 
**    store in a 256-byte character array (no null termination)
**
** Arguments:
**    header - (char *) to hold header information
**    type   - 4 byte file type code
**    prefix - file name prefix (problem name)
**
** Header format:
**       bytes     value
**      0 -   3  Bit pattern to check byte ordering "abcd"
**      4 -   7  4 character file type code
**      8 -  71  file name prefix (up to 64 characters, space padded)
**     72 -  91  creation date and time, mmm dd hh:mm:ss yyyy
**     91 - 254  currently unused
**    255 - 255  '\n'
*/

/* -------------------------------------------------------------------- */

int generate_Cptc_header(char *header, char *type, char *prefix)
{
  int     i, len ;
  time_t  time_s ;
  char    *time_string ;
  char    buff[CPTC_HEADER_SIZE];

  /* check bit pattern */
  buff[0] = 'a' ;
  buff[1] = 'b' ;
  buff[2] = 'c' ;
  buff[3] = 'd' ;

  /* type code */

  len = strlen(type) ;
  if (len > 4 ) len = 4 ;
  for (i=0 ; i<len ; i++) buff[i+4] = type[i] ;
  for (i=len ; i<4 ; i++) buff[i+4] = ' ' ;

  /* file name prefix */

  len = strlen(prefix) ;
  if (len > 64 ) len = 64 ;
  for (i=0 ; i<len ; i++) buff[i+8] = prefix[i] ;
  for (i=len ; i<64 ; i++) buff[i+8] = ' ' ;

  /* the creation data */

  time(&time_s) ;
  time_string = ctime(&time_s) ;
  for (i=4 ; i<24 ; i++) buff[i+68] = time_string[i] ;
    
  /* fill */
    
  for (i=92 ; i<252 ; i++) buff[i] = '-' ;
  buff[252] = '\0' ;
    
  strcpy(header, buff);
  return 0;
}

/* --------------------------------------------------------------------
** xdr_Cptc_header - encode/decode a standard header buffer to 
**    an XDR formatted file
**
** Arguments:
**    xdrs - XDR stream handle
**    header_p - pointer to character array
**
** --------------------------------------------------------------------
*/

bool_t xdr_Cptc_header(XDR *xdrs, char **header_p)
{
  char *header;

  if (xdrs->x_op == XDR_DECODE) {
    header = (char *) cptc_malloc ((CPTC_HEADER_SIZE+1) * sizeof(char));
  }
  else {
    header = *header_p;
  }

  if (!xdr_string(xdrs, &header, CPTC_HEADER_SIZE)) return (FALSE);

  if (xdrs->x_op == XDR_DECODE) {
    *header_p = header;
  }

  return (TRUE);
}

/* --------------------------------------------------------------------
** cptc_xdr_write_header - generate the standard file header, and write
**    the contents to an XDR formatted file
**
** Arguments:
**    xdrs - XDR stream handle
**    type   - 4 byte file type code
**    prefix - file name prefix (problem name)
**
** --------------------------------------------------------------------
*/

bool_t cptc_xdr_write_header(XDR *xdrs, char *type, char *prefix)
{
  char *header = (char *) cptc_malloc (256 * sizeof(char));
  generate_Cptc_header(header, type, prefix);

  if (xdrs->x_op != XDR_ENCODE) {
    fprintf(stderr, 
    "Error: cptc_write_xdr_header only valid for XDR_ENCODE streams.\n");
    exit(-1);
  }

  if (!xdr_Cptc_header(xdrs, &header)) return (FALSE);
  free(header);

  return (TRUE);
}


/* --------------------------------------------------------------------
** cptc_xdr_read_and_ignore_header - read the standard file header to an
**    XDR formatted file, and ignore the contents.
**
** Arguments:
**    xdrs - XDR stream handle
**
** --------------------------------------------------------------------
*/

bool_t cptc_xdr_read_and_ignore_header(XDR *xdrs)
{
  char *header;

  if (xdrs->x_op == XDR_DECODE) {
    header = (char *) cptc_malloc (CPTC_HEADER_SIZE * sizeof(char));
  }
  else {
    fprintf(stderr, 
    "Error: cptc_xdr_read_and_ignore_header only valid for XDR_DECODE streams.\n");
    exit(-1);
  }

  if (!xdr_Cptc_header(xdrs, &header)) return (FALSE);
  free(header);

  return (TRUE);
}

#ifndef _WIN32
char *cptc_geo_id(Cptc_GeomDesc* geom)
{
  unsigned long hostid;   
  unsigned long pid;
  time_t current_time;
  unsigned long memaddr;
  char *buf;

  hostid = gethostid();
  pid = getpid();
  current_time = time(0);
  memaddr = (unsigned long) geom;

  buf = (char *) malloc(255 * sizeof(char));
  sprintf(buf, "%u%u%u%u\0", hostid, pid, current_time, memaddr);
  return (buf);
}
#endif

void free_prop_or_val(int count, char **array) 
{
  int i;
  if (array == 0) return;
  for (i = 0; i < count; ++i)
    free(array[i]);
  free(array);
}