CuFile *pp_create_file(const char *controlpath){

  CuFile *file;
  PPfile *ppfile;
  
  /* get file structure */
  file = CuCreateFile(CuPP);
  if (file == (CuFile*)0) goto err1;

  /* allocate internal structure - hang it off cu_file structure */
  ppfile=pp_malloc(sizeof(PPfile), NULL);
  if (ppfile==NULL) goto err2;
  
  file->internp = ppfile;
  ppfile->fh = NULL;
  strncpy(file->controlpath, controlpath, CU_MAX_PATH);
  ppfile->landmask = NULL;
  ppfile->store_raw_headers = 0;
  ppfile->basetime = 0;

  /* initialise heap list */
  ppfile->heaplist = pp_list_new(NULL);
  if (ppfile->heaplist == NULL) goto err3;

  return file;

 err3:
  pp_free(ppfile,NULL);
 err2:
  CuDeleteFile(file->id);
 err1:
  pp_error("pp_create_file");
  return NULL;
}
Example #2
0
int to_TimeInternal(TimeInternal *internal, Timestamp *external)
{
	/* Program will not run after 2038... */
	if (external->secondsField.lsb < INT_MAX) {
		internal->seconds = external->secondsField.lsb;
		internal->nanoseconds = external->nanosecondsField;
		return 0;
	} else {
		pp_error("to_TimeInternal: "
		    "seconds field is higher than signed integer (32bits)\n");
		return -1;
	}
}
Example #3
0
int pp_check_sizes()
{
  if (sizeof(Freal4) != 4 ||
      sizeof(Freal8) != 8 ||
      sizeof(Fint4) != 4 ||
      sizeof(Fint8) != 8 ||
      sizeof(Fint) != sizeof (Freal) ||
      cutypelen(inttype) != sizeof(Fint) ||
      cutypelen(realtype) != sizeof(Freal)) {

    pp_error("pp_check_sizes");
    return -1;
  }

  return 0;
}
Example #4
0
int from_TimeInternal(TimeInternal *internal, Timestamp *external)
{
	/*
	 * fromInternalTime is only used to convert time given by the system
	 * to a timestamp As a consequence, no negative value can normally
	 * be found in (internal)
	 *
	 * Note that offsets are also represented with TimeInternal structure,
	 * and can be negative, but offset are never convert into Timestamp
	 * so there is no problem here.
	 */

	if ((internal->seconds & ~INT_MAX) ||
	    (internal->nanoseconds & ~INT_MAX)) {
		pp_error("Negative value cannot be converted into "
			  "timestamp\n");
		return -1;
	} else {
		external->secondsField.lsb = internal->seconds;
		external->nanosecondsField = internal->nanoseconds;
		external->secondsField.msb = 0;
	}
	return 0;
}
Example #5
0
void cField_to_TimeInternal(TimeInternal *internal, Integer64 cField)
{
	uint64_t i64;

	i64 = cField.lsb;
	i64 |= ((int64_t)cField.msb) << 32;

	if ((int32_t)cField.msb < 0)
		pp_error("BUG: %s doesn't support negatives\n", __func__);

	/*
	 * the correctionField is nanoseconds scaled by 16 bits.
	 * It is updated by transparent clocks and may be used to count
	 * for asymmetry. Since we support no better than nanosecond with
	 * the standard protocol and WR (which is better than nanosecond)
	 * doesn't use this field, just approximate to nanoseconds.
	 * and the WR extension uses its own methods for asymmetry,
	 */
	i64 += 0x8000;
	i64 >>= 16;
	/* Use __div64_32 from library, to avoid libgcc on small targets */
	internal->nanoseconds = __div64_32(&i64, PP_NSEC_PER_SEC);
	internal->seconds = i64;
}