The mdsupport.h & mdsupport.c

Collaboration diagram for The mdsupport.h & mdsupport.c:

Modules
	Midas dump error code
	Midas dump support Define
	Midas dump support Macros

Classes
struct	MY

Macros
#define	TRACE
#define	EXPRT

Functions
INT	md_dev_os_read (INT handle, INT type, void *prec, DWORD nbytes, DWORD *nread)
INT	md_dev_os_write (INT handle, INT type, void *prec, DWORD nbytes, DWORD *written)
void	md_bank_event_display (const void *pevent, INT data_fmt, INT dsp_fmt, INT dsp_mode, const char *bn)
void	md_raw_event_display (const void *pevent, INT data_fmt, INT dsp_fmt)
void	md_raw_bank_display (void *pbank, INT data_fmt, INT dsp_fmt)
INT	midas_event_get (void **pevent, DWORD *size)
INT	midas_physrec_get (void *prec, DWORD *readn)
INT	midas_event_skip (INT evtn)
void	midas_bank_display (BANK *pbk, INT dsp_fmt)
template<typename T >
void	midas_bank_display32 (T *pbk, INT dsp_fmt)
INT	md_file_ropen (char *infile, INT data_fmt, INT openzip, INT max_event_size)
INT	md_file_rclose (INT data_fmt)
INT	md_file_wopen (INT type, INT data_fmt, char *filename, INT *hDev)
INT	md_file_wclose (INT handle, INT type, INT data_fmt, char *destination)
INT	md_physrec_get (INT data_fmt, void **precord, DWORD *readn)
INT	md_log_write (INT handle, INT data_fmt, INT type, void *prec, DWORD nbytes)
INT	md_all_info_display (INT what)
INT	md_event_swap (INT data_fmt, void *pevent)
void	md_event_display (const void *pevent, INT data_fmt, INT dsp_mode, INT dsp_fmt, const char *bn)
void	md_bank_display (void *pmbh, void *pbk, INT data_fmt, INT dsp_mode, INT dsp_fmt)

Variables
struct stat *	filestat
char *	ptopmrd
gzFile	filegz
MY	my

Detailed Description

dox

Macro Definition Documentation

EXPRT

#define EXPRT

dox

Definition at line 49 of file mdsupport.h.

TRACE

#define TRACE

dox

Definition at line 32 of file mdsupport.cxx.

Function Documentation

md_all_info_display()

INT EXPRT md_all_info_display

(

INT

what

)

Definition at line 669 of file mdsupport.cxx.

{
   if (my.fmt == FORMAT_MIDAS) {
      DWORD mbn, run, ser;
      WORD id, msk;
      mbn = my.evtn;
      run = my.runn;
      id = my.pmh->event_id;
      msk = my.pmh->trigger_mask;
      ser = my.pmh->serial_number;
      switch (what) {
         case D_RECORD:
         case D_HEADER:
            printf(">>> No physical record structure for Midas format <<<\n");
            return MD_DONE;
            break;
         case D_EVTLEN:
            printf("Evt#%d- ", my.evtn);
            printf("%irun 0x%4.4uxid 0x%4.4uxmsk %5dmevt#", run, id, msk, mbn);
            printf("%5del/x%x %5dserial\n", my.evtlen, my.evtlen, ser);
            break;
      }
   }  else {
      assert(!"unsupported data format, sorry!");
   }
 
   return MD_SUCCESS;
}

Here is the call graph for this function:

md_bank_display()

void EXPRT md_bank_display	(	void *	pmbh,
		void *	pbk,
		INT	fmt,
		INT	dsp_mode,
		INT	dsp_fmt
	)

dox

Definition at line 906 of file mdsupport.cxx.

{
   if (dsp_mode == DSP_RAW)
      md_raw_bank_display(pbk, data_fmt, dsp_fmt);
   else {
      if (data_fmt == FORMAT_MIDAS) {
         if (bk_is32a(pmbh)) {
            midas_bank_display32<BANK32A>((BANK32A *) pbk, dsp_fmt);
         } else if (bk_is32(pmbh)) {
            midas_bank_display32<BANK32>((BANK32 *) pbk, dsp_fmt);
         } else {
            midas_bank_display((BANK *) pbk, dsp_fmt);
         }
      } else {
         assert(!"unsupported data_fmt, sorry!");
      }
   }
   return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

md_bank_event_display()

void md_bank_event_display	(	const void *	pevent,
		INT	data_fmt,
		INT	dsp_fmt,
		INT	dsp_mode,
		const char *	bn
	)

Definition at line 806 of file mdsupport.cxx.

{
   char banklist[MD_STRING_BANKLIST_MAX + STRING_BANKLIST_MAX];
   DWORD *pdata, *pdata1;
   BANK_HEADER *pbh = NULL;
   BANK *pmbk;
   BANK32 *pmbk32;
   BANK32A *pmbk32a;
   EVENT_HEADER *pheader;
   INT status, single = 0;
 
   if (data_fmt == FORMAT_MIDAS) {
      /* skip these special events (NO bank structure) */
      pheader = (EVENT_HEADER *) pevent;
      if (pheader->event_id == EVENTID_BOR ||
          pheader->event_id == EVENTID_EOR || pheader->event_id == EVENTID_MESSAGE)
         return;
 
      /* check if format is MIDAS or FIXED */
      pbh = (BANK_HEADER *) (pheader + 1);
 
      /* Check for single bank display request */
      if (dsp_mode == DSP_BANK_SINGLE) {
         bk_locate(pbh, bn, &pdata1);
         single = 1;
      }
      /* event header (skip it if in single bank display) */
      if (!single)
         printf("Evid:%4.4x- Mask:%4.4x- Serial:%i- Time:0x%x- Dsize:%i/0x%x",
                (WORD) pheader->event_id, (WORD) pheader->trigger_mask,
                pheader->serial_number, pheader->time_stamp, pheader->data_size, pheader->data_size);
 
      if ((pbh->data_size + 8) == pheader->data_size) {
         /* bank list */
         if (!single) {
            /* Skip list if in single bank display */
            status = bk_list((BANK_HEADER *) (pheader + 1), banklist);
            printf("\n#banks:%i - Bank list:-%s-\n", status, banklist);
         }
 
         /* display bank content */
         if (bk_is32a(pbh)) {
            pmbk32a = NULL;
            do {
               bk_iterate32a(pbh, &pmbk32a, &pdata);
               if (pmbk32a != NULL)
                  if (single && (pdata == pdata1))
                     midas_bank_display32<BANK32A>(pmbk32a, dsp_fmt);
               if (!single)
                  if (pmbk32a != NULL)
                     midas_bank_display32<BANK32A>(pmbk32a, dsp_fmt);
            } while (pmbk32a != NULL);
         } else if (bk_is32(pbh)) {
            pmbk32 = NULL;
            do {
               bk_iterate32(pbh, &pmbk32, &pdata);
               if (pmbk32 != NULL)
                  if (single && (pdata == pdata1))
                     midas_bank_display32<BANK32>(pmbk32, dsp_fmt);
               if (!single)
                  if (pmbk32 != NULL)
                     midas_bank_display32<BANK32>(pmbk32, dsp_fmt);
            } while (pmbk32 != NULL);
         } else {
            pmbk = NULL;
            do {
               bk_iterate(pbh, &pmbk, &pdata);
               if (pmbk != NULL)
                  if (single && (pdata == pdata1))
                     midas_bank_display(pmbk, dsp_fmt);
               if (!single)
                  if (pmbk != NULL)
                     midas_bank_display(pmbk, dsp_fmt);
            } while (pmbk != NULL);
         }
      } else {
         printf("\nFIXED event with Midas Header\n");
         md_raw_event_display(pevent, data_fmt, dsp_fmt);
      }
   } else {
      assert(!"unsupported data_fmt, sorry!");
   }
 
   return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

md_dev_os_read()

INT md_dev_os_read	(	INT	handle,
		INT	type,
		void *	prec,
		DWORD	nbytes,
		DWORD *	nread
	)

Definition at line 428 of file mdsupport.cxx.

{
   INT status;
   if (type == LOG_TYPE_DISK)
      /* --------- DISK ---------- */
   {
      *readn = read(handle, prec, nbytes);
      if (*readn <= 0)
         status = SS_FILE_ERROR;
      else
         status = SS_SUCCESS;
      return status;
   }
      /* --------- TAPE ---------- */
#ifdef OS_UNIX
   else if (type == LOG_TYPE_TAPE) {
      *readn = read(handle, prec, nbytes);
      if (*readn <= 0)
         status = SS_FILE_ERROR;
      else
         status = SS_SUCCESS;
      return status;
   }
#endif
 
#ifdef OS_WINNT
      else if (type == LOG_TYPE_TAPE) {
         if (!ReadFile((HANDLE) handle, prec, nbytes, readn, NULL))
            status = GetLastError();
         else
            status = SS_SUCCESS;
         if (status == ERROR_NO_DATA_DETECTED)
            status = SS_END_OF_TAPE;
 
         return status;
      }
#endif                          /* OS_WINNT */
   else
      return SS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

md_dev_os_write()

INT md_dev_os_write	(	INT	handle,
		INT	type,
		void *	prec,
		DWORD	nbytes,
		DWORD *	written
	)

Definition at line 484 of file mdsupport.cxx.

{
   INT status;
   if (type == LOG_TYPE_DISK)
#ifdef OS_WINNT
      {                            /* --------- DISK ---------- */
         WriteFile((HANDLE) handle, (char *) prec, nbytes, written, NULL);
         status = *written == nbytes ? SS_SUCCESS : SS_FILE_ERROR;
         return status;            /* return for DISK */
      }
#else
   {                            /* --------- DISK ---------- */
      status = *written = write(handle, (char *) prec, nbytes) == (INT) nbytes ? SS_SUCCESS : SS_FILE_ERROR;
      return status;            /* return for DISK */
   }
#endif
   else if (type == LOG_TYPE_TAPE) {    /* --------- TAPE ---------- */
#ifdef OS_UNIX
      do {
         status = write(handle, (char *) prec, nbytes);
      } while (status == -1 && errno == EINTR);
      *written = status;
      if (*written != nbytes) {
         cm_msg(MERROR, "any_dev_os_write", "write() status %d, errno %d (%s)", status, errno, strerror(errno));
         if (errno == EIO)
            return SS_IO_ERROR;
         if (errno == ENOSPC)
            return SS_NO_SPACE;
         else
            return SS_TAPE_ERROR;
      }
#endif                          /* OS_UNIX */
 
#ifdef OS_WINNT
      WriteFile((HANDLE) handle, (char *) prec, nbytes, written, NULL);
      if (*written != nbytes) {
         status = GetLastError();
         cm_msg(MERROR, "any_dev_os_write", "error %d", status);
         return SS_IO_ERROR;
      }
      return SS_SUCCESS;        /* return for TAPE */
#endif                          /* OS_WINNT */
   } else if (type == LOG_TYPE_FTP)
#ifdef HAVE_FTPLIB
   {
      *written = status = ftp_send(ftp_con->data, (char *) prec,
                                   (int) nbytes) == (int) nbytes ? SS_SUCCESS : SS_FILE_ERROR;
      return status;
   }
#else
   {
      cm_msg(MERROR, "mdsupport", "FTP support not included");
      return SS_IO_ERROR;
   }
#endif
   return SS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

md_event_display()

void EXPRT md_event_display	(	const void *	pevent,
		INT	data_fmt,
		INT	dsp_mode,
		INT	dsp_fmt,
		const char *	bn
	)

Definition at line 740 of file mdsupport.cxx.

{
   if (dsp_mode == DSP_RAW)
      md_raw_event_display(pevent, data_fmt, dsp_fmt);
   else if ((dsp_mode == DSP_BANK) || (dsp_mode == DSP_BANK_SINGLE))
      md_bank_event_display(pevent, data_fmt, dsp_fmt, dsp_mode, bn);
   else
      printf("mdsupport- Unknown format:%i\n", dsp_fmt);
   return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

md_event_swap()

INT EXPRT md_event_swap	(	INT	data_fmt,
		void *	pevent
	)

Definition at line 710 of file mdsupport.cxx.

{
   INT status;
   BANK_HEADER *pbh;
 
   if (data_fmt == FORMAT_MIDAS) {
      if ((((EVENT_HEADER *) pevent)->event_id == EVENTID_BOR) ||
          (((EVENT_HEADER *) pevent)->event_id == EVENTID_EOR) ||
          (((EVENT_HEADER *) pevent)->event_id == EVENTID_MESSAGE))
         return SS_SUCCESS;
      pbh = (BANK_HEADER *) (((EVENT_HEADER *) pevent) + 1);
      status = bk_swap(pbh, FALSE);
      return status == CM_SUCCESS ? MD_EVENT_NOT_SWAPPED : MD_SUCCESS;
   } else {
      return MD_UNKNOWN_FORMAT;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

md_file_rclose()

INT EXPRT md_file_rclose

(

INT

data_fmt

)

Definition at line 266 of file mdsupport.cxx.

{
   switch (my.type) {
      case LOG_TYPE_TAPE:
      case LOG_TYPE_DISK:
         /* close file */
         if (my.zipfile) {
            gzclose(filegz);
         } else {
            if (my.handle != 0)
               close(my.handle);
         }
         break;
   }
   if (ptopmrd != NULL)
      free(ptopmrd);
   if (my.pmp != NULL)
      free(my.pmp);
   my.pmp = NULL;
   my.pmh = NULL;
   ptopmrd = NULL;
   my.pmrd = NULL;              /* ptopmrd and my.pmrd point to the same place. K.O. 25-FEB-2005 */
   return (MD_SUCCESS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

md_file_ropen()

INT EXPRT md_file_ropen	(	char *	infile,
		INT	data_fmt,
		INT	openzip,
		INT	max_event_size
	)

dox

Definition at line 184 of file mdsupport.cxx.

{
   /* fill up record with file name */
   strcpy(my.name, infile);
 
   /* find out what dev it is ? : check on /dev */
   my.zipfile = FALSE;
   if ((strncmp(my.name, "/dev", 4) == 0) || (strncmp(my.name, "\\\\.\\", 4) == 0)) {
      /* tape device */
      my.type = LOG_TYPE_TAPE;
   } else {
      /* disk device */
      my.type = LOG_TYPE_DISK;
      if (strncmp(infile + strlen(infile) - 3, ".gz", 3) == 0) {
         // FALSE will for now prevent the mdump to see inside the .gz
         // But lazylogger will NOT unzip during copy!
         if (openzip == 0) my.zipfile = FALSE; // ignore zip, copy blindly blocks
         else my.zipfile = TRUE; // Open Zip file
      }
   }
 
   /* open file */
   if (!my.zipfile) {
      if (my.type == LOG_TYPE_TAPE) {
         ss_tape_open(my.name, O_RDONLY | O_BINARY, &my.handle);
      } else if ((my.handle = open(my.name, O_RDONLY | O_BINARY | O_LARGEFILE, 0644)) == -1) {
         printf("dev name :%s Handle:%d \n", my.name, my.handle);
         return (SS_FILE_ERROR);
      }
   } else {
      if (my.type == LOG_TYPE_TAPE) {
         printf(" Zip on tape not yet supported \n");
         return (SS_FILE_ERROR);
      }
      filegz = gzopen(my.name, "rb");
      my.handle = 0;
      if (filegz == NULL) {
         printf("dev name :%s gzopen error:%d \n", my.name, my.handle);
         return (SS_FILE_ERROR);
      }
   }
 
   if (data_fmt == FORMAT_MIDAS) {
      my.fmt = FORMAT_MIDAS;
      my.size = TAPE_BUFFER_SIZE;
      my.pmp = (char *) malloc(my.size);
      if (my.pmp == NULL)
         return SS_NO_MEMORY;
      my.pme = (EVENT_HEADER *) my.pmp;
 
      /* allocate memory for one full event */
      if (my.pmrd != NULL)
         free(my.pmrd);
      my.pmrd = (char *) malloc(5 * max_event_size);    /* in bytes */
      ptopmrd = my.pmrd;
      if (my.pmrd == NULL)
         return SS_NO_MEMORY;
      memset((char *) my.pmrd, -1, 5 * max_event_size);
      my.pmh = (EVENT_HEADER *) my.pmrd;
   } else {
      assert(!"unsupported data_fmt, sorry!");
   }
 
   /* initialize pertinent variables */
   my.recn = -1;
   my.evtn = 0;
   return (MD_SUCCESS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

md_file_wclose()

INT EXPRT md_file_wclose	(	INT	handle,
		INT	type,
		INT	data_fmt,
		char *	destination
	)

Definition at line 358 of file mdsupport.cxx.

{
   INT status;
 
   status = SS_SUCCESS;
   switch (type) {
      case LOG_TYPE_TAPE:
         /* writing EOF mark on tape Fonly */
         status = ss_tape_write_eof(handle);
         ss_tape_close(handle);
         break;
      case LOG_TYPE_DISK:
         /* close file */
         if (handle != 0)
#ifdef OS_WINNT
            CloseHandle((HANDLE) handle);
#else
            close(handle);
#endif
         break;
      case LOG_TYPE_FTP:
#ifdef HAVE_FTPLIB
      {
         char *p, filename[256];
         int i;
 
         ftp_close(ftp_con);
 
         /*
            destination should have the form:
            host, port, user, password, directory, run%05d.mid, file_mode, command, ...
         */
         p = destination;
         for (i = 0; i < 5 && p != NULL; i++) {
            p = strchr(p, ',');
            if (*p == ',')
               p++;
         }
         if (p != NULL) {
            mstrlcpy(filename, p, sizeof(filename));
            if (strchr(filename, ','))
               *strchr(filename, ',') = 0;
         } else
            mstrlcpy(filename, destination, sizeof(filename));
 
         /* if filename starts with a '.' rename it */
         if (filename[0] == '.')
            ftp_move(ftp_con, filename, filename + 1);
 
         ftp_bye(ftp_con);
      }
#endif
         break;
   }
   if (status != SS_SUCCESS)
      return status;
   return (MD_SUCCESS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

md_file_wopen()

INT EXPRT md_file_wopen	(	INT	type,
		INT	data_fmt,
		char *	filename,
		INT *	hDev
	)

Definition at line 302 of file mdsupport.cxx.

{
   INT status = 0;
 
   if (type == LOG_TYPE_DISK)
      /* takes care of TapeLX/NT under ss_tape_open , DiskLX/NT here */
   {
      if (data_fmt == FORMAT_MIDAS) {
#ifdef OS_WINNT
         *hDev =
      (int) CreateFile(filename, GENERIC_WRITE, FILE_SHARE_READ,
             NULL, CREATE_ALWAYS,
             FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH | FILE_FLAG_SEQUENTIAL_SCAN, 0);
#else
         *hDev = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE, 0644);
#endif
         status = *hDev < 0 ? SS_FILE_ERROR : SS_SUCCESS;
      } else {
         assert(!"unsupported data_fmt, sorry!");
      }
   } else if (type == LOG_TYPE_TAPE) {
      if (data_fmt == FORMAT_MIDAS) {
         status = ss_tape_open(filename, O_WRONLY | O_CREAT | O_TRUNC, hDev);
      } else {
         assert(!"unsupported data_fmt, sorry!");
      }
   } else if (type == LOG_TYPE_FTP) {
#ifdef HAVE_FTPLIB
      status = mftp_open(filename, (FTP_CON **) &ftp_con);
      if (status != SS_SUCCESS) {
         *hDev = 0;
         return status;
      } else
         *hDev = 1;
#else
      cm_msg(MERROR, "mdsupport", "FTP support not included");
      return SS_FILE_ERROR;
#endif
   }
 
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

md_log_write()

INT EXPRT md_log_write	(	INT	handle,
		INT	data_fmt,
		INT	type,
		void *	prec,
		DWORD	nbytes
	)

Definition at line 579 of file mdsupport.cxx.

{
   INT status;
   DWORD written;
 
   status = data_fmt;           /* avoid compiler warning */
   /* write record */
   status = md_dev_os_write(handle, type, prec, nbytes, &written);
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

md_physrec_get()

INT EXPRT md_physrec_get	(	INT	data_fmt,
		void **	precord,
		DWORD *	readn
	)

Definition at line 558 of file mdsupport.cxx.

{
   *precord = my.pmp;
   if (data_fmt == FORMAT_MIDAS) {
      return midas_physrec_get(*precord, readn);
   } else
      return MD_UNKNOWN_FORMAT;
}

Here is the call graph for this function:

Here is the caller graph for this function:

md_raw_bank_display()

void md_raw_bank_display	(	void *	pbank,
		INT	data_fmt,
		INT	dsp_fmt
	)

Definition at line 940 of file mdsupport.cxx.

{
   DWORD *pdata = NULL, lrl = 0, j, i;
 
   if (data_fmt == FORMAT_MIDAS) {
      lrl = ((BANK *) pbank)->data_size >> 2;   /* in DWORD */
      pdata = (DWORD *) ((BANK *) (pbank) + 1);
   } else {
      assert(!"unsupported data_fmt, sorry!");
   }
 
   for (i = 0; i < lrl; i += NLINE) {
      j = 0;
      printf("\n%4i-> ", i + j + 1);
      for (j = 0; j < NLINE; j++) {
         if ((i + j) < lrl) {
            if (dsp_fmt == DSP_DEC)
               printf("%8.i ", *((DWORD *) pdata));
            if (dsp_fmt == DSP_ASC)
               printf("%8.8x ", *((DWORD *) pdata));
            if (dsp_fmt == DSP_HEX)
               printf("%8.8x ", *((DWORD *) pdata));
            pdata++;
         }
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

md_raw_event_display()

void md_raw_event_display	(	const void *	pevent,
		INT	data_fmt,
		INT	dsp_fmt
	)

Definition at line 765 of file mdsupport.cxx.

{
   DWORD lrl = 0, *pevt = NULL, j, i, total = 0;
 
   if (data_fmt == FORMAT_MIDAS) {
      lrl = ((((EVENT_HEADER *) pevent)->data_size) + sizeof(EVENT_HEADER)) /
            sizeof(DWORD);    /* in I*4 for raw including the header */
      pevt = (DWORD *) pevent;  /* local copy starting from the pheader */
   } else {
      assert(!"unsupported data_fmt, sorry!");
   }
 
   for (i = 0; i < lrl; i += NLINE) {
      printf("%6.0d->: ", total);
      for (j = 0; j < NLINE; j++) {
         if ((i + j) < lrl) {
            if (dsp_fmt == DSP_DEC)
               printf("%8.i ", *pevt);
            else
               printf("%8.8x ", *pevt);
            pevt++;
         }
      }
      total += NLINE;
      printf("\n");
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

midas_bank_display()

void midas_bank_display	(	BANK *	pbk,
		INT	dsp_fmt
	)

Definition at line 1117 of file mdsupport.cxx.

{
   char bank_name[5], strbktype[32];
   char *pdata, *pendbk;
   DWORD length_type = 0, lrl;
   INT type, i, j;
 
   lrl = pbk->data_size;        /* in bytes */
   type = pbk->type & 0xff;
   bank_name[4] = 0;
   memcpy(bank_name, (char *) (pbk->name), 4);
   pdata = (char *) (pbk + 1);
 
   j = 64;                      /* elements within line */
   i = 1;                       /* data counter */
   strcpy(strbktype, "Unknown format");
   if (type == TID_DOUBLE) {
      length_type = sizeof(double);
      strcpy(strbktype, "double*8");
   }
   if (type == TID_FLOAT) {
      length_type = sizeof(float);
      strcpy(strbktype, "Real*4 (FMT machine dependent)");
   }
   if (type == TID_UINT64) {
      length_type = sizeof(uint64_t);
      strcpy(strbktype, "Unsigned Integer*8");
   }
   if (type == TID_INT64) {
      length_type = sizeof(int64_t);
      strcpy(strbktype, "Signed Integer*8");
   }
   if (type == TID_DWORD) {
      length_type = sizeof(DWORD);
      strcpy(strbktype, "Unsigned Integer*4");
   }
   if (type == TID_INT) {
      length_type = sizeof(INT);
      strcpy(strbktype, "Signed Integer*4");
   }
   if (type == TID_WORD) {
      length_type = sizeof(WORD);
      strcpy(strbktype, "Unsigned Integer*2");
   }
   if (type == TID_SHORT) {
      length_type = sizeof(short);
      strcpy(strbktype, "Signed Integer*2");
   }
   if (type == TID_BYTE) {
      length_type = sizeof(BYTE);
      strcpy(strbktype, "Unsigned Bytes");
   }
   if (type == TID_SBYTE) {
      length_type = sizeof(BYTE);
      strcpy(strbktype, "Signed Bytes");
   }
   if (type == TID_BOOL) {
      length_type = sizeof(DWORD);
      strcpy(strbktype, "Boolean");
   }
   if (type == TID_CHAR) {
      length_type = sizeof(char);
      strcpy(strbktype, "8 bit ASCII");
   }
   if (type == TID_STRUCT) {
      length_type = sizeof(char);
      strcpy(strbktype, "STRUCT (not supported->8 bits)");
   }
   if (type == TID_STRING) {
      length_type = sizeof(char);
      strcpy(strbktype, "String 8bit ASCII");
   }
 
   printf("\nBank:%s Length: %i(I*1)/%i(I*4)/%i(Type) Type:%s",
          bank_name, lrl, lrl >> 2, lrl / (length_type == 0 ? 1 : length_type), strbktype);
 
   pendbk = pdata + lrl;
   while (pdata < pendbk) {
      switch (type) {
         case TID_DOUBLE:
            if (j > 3) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 4;
            }
            printf("%15.5le    ", *((double *) pdata));
            pdata = (char *) (((double *) pdata) + 1);
            j++;
            break;
         case TID_FLOAT:
            if (j > 7) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 8;
            }
            if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
               printf("%8.3e ", *((float *) pdata));
            if (dsp_fmt == DSP_HEX)
               printf("0x%8.8x ", *((DWORD *) pdata));
            pdata = (char *) (((DWORD *) pdata) + 1);
            j++;
            break;
         case TID_UINT64:
            if (j > 7) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 8;
            }
            if (dsp_fmt == DSP_DEC)
               printf("%16.1llu ", (long long unsigned) *((uint64_t *) pdata));
            if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
               printf("0x%16.16llx ", (long long unsigned) *((uint64_t *) pdata));
            pdata = (char *) (((uint64_t *) pdata) + 1);
            j++;
            break;
         case TID_INT64:
            if (j > 7) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 8;
            }
            if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
               printf("%16.1lli ", (long long int) *((int64_t *) pdata));
            if (dsp_fmt == DSP_HEX)
               printf("0x%16.16llx ", (long long unsigned int) *((int64_t *) pdata));
            pdata = (char *) (((int64_t *) pdata) + 1);
            j++;
            break;
         case TID_DWORD:
            if (j > 7) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 8;
            }
            if (dsp_fmt == DSP_DEC)
               printf("%8.1i ", *((DWORD *) pdata));
            if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
               printf("0x%8.8x ", *((DWORD *) pdata));
            pdata = (char *) (((DWORD *) pdata) + 1);
            j++;
            break;
         case TID_INT:
            if (j > 7) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 8;
            }
            if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
               printf("%8.1i ", *((DWORD *) pdata));
            if (dsp_fmt == DSP_HEX)
               printf("0x%8.8x ", *((DWORD *) pdata));
            pdata = (char *) (((DWORD *) pdata) + 1);
            j++;
            break;
         case TID_WORD:
            if (j > 7) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 8;
            }
            if (dsp_fmt == DSP_DEC)
               printf("%5.1i ", *((WORD *) pdata));
            if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
               printf("0x%4.4x ", *((WORD *) pdata));
            pdata = (char *) (((WORD *) pdata) + 1);
            j++;
            break;
         case TID_SHORT:
            if (j > 7) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 8;
            }
            if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
               printf("%5.1i ", *((short *) pdata));
            if (dsp_fmt == DSP_HEX)
               printf("0x%4.4x ", *((short *) pdata));
            pdata = (char *) (((short *) pdata) + 1);
            j++;
            break;
         case TID_BYTE:
         case TID_STRUCT:
            if (j > 15) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 16;
            }
            if (dsp_fmt == DSP_DEC)
               printf("%4.i ", *((BYTE *) pdata));
            if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
               printf("0x%2.2x ", *((BYTE *) pdata));
            pdata++;
            j++;
            break;
         case TID_SBYTE:
            if (j > 15) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 16;
            }
            if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
               printf("%4.i ", *((BYTE *) pdata));
            if (dsp_fmt == DSP_HEX)
               printf("0x%2.2x ", *((BYTE *) pdata));
            pdata++;
            j++;
            break;
         case TID_BOOL:
            if (j > 15) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 16;
            }
            (*((BOOL *) pdata) != 0) ? printf("Y ") : printf("N ");
            pdata = (char *) (((DWORD *) pdata) + 1);
            j++;
            break;
         case TID_CHAR:
         case TID_STRING:
            if (j > 15) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 16;
            }
            if (dsp_fmt == DSP_DEC)
               printf("%3.i ", *((BYTE *) pdata));
            if ((dsp_fmt == DSP_ASC) || (dsp_fmt == DSP_UNK))
               printf("%1.1s ", (char *) pdata);
            if (dsp_fmt == DSP_HEX)
               printf("0x%2.2x ", *((BYTE *) pdata));
            pdata++;
            j++;
            break;
         default:
            printf("bank type not supported (%d)\n", type);
            return;
            break;
      }
   }                            /* end of bank */
   printf("\n");
   return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

midas_bank_display32()

template<typename T >

void midas_bank_display32	(	T *	pbk,
		INT	dsp_fmt
	)

Definition at line 1373 of file mdsupport.cxx.

{
   char bank_name[5], strbktype[32];
   char *pdata, *pendbk;
   DWORD length_type = 0, lrl;
   INT type, i, j;
 
   lrl = pbk->data_size;        /* in bytes */
   type = pbk->type & 0xff;
   bank_name[4] = 0;
   memcpy(bank_name, (char *) (pbk->name), 4);
   pdata = (char *) (pbk + 1);
 
   j = 64;                      /* elements within line */
   i = 1;                       /* data counter */
   strcpy(strbktype, "Unknown format");
   if (type == TID_DOUBLE) {
      length_type = sizeof(double);
      strcpy(strbktype, "double*8");
   }
   if (type == TID_FLOAT) {
      length_type = sizeof(float);
      strcpy(strbktype, "Real*4 (FMT machine dependent)");
   }
   if (type == TID_UINT64) {
      length_type = sizeof(uint64_t);
      strcpy(strbktype, "Unsigned Integer*8");
   }
   if (type == TID_INT64) {
      length_type = sizeof(int64_t);
      strcpy(strbktype, "Signed Integer*8");
   }
   if (type == TID_DWORD) {
      length_type = sizeof(DWORD);
      strcpy(strbktype, "Unsigned Integer*4");
   }
   if (type == TID_INT) {
      length_type = sizeof(INT);
      strcpy(strbktype, "Signed Integer*4");
   }
   if (type == TID_WORD) {
      length_type = sizeof(WORD);
      strcpy(strbktype, "Unsigned Integer*2");
   }
   if (type == TID_SHORT) {
      length_type = sizeof(short);
      strcpy(strbktype, "Signed Integer*2");
   }
   if (type == TID_BYTE) {
      length_type = sizeof(BYTE);
      strcpy(strbktype, "Unsigned Bytes");
   }
   if (type == TID_SBYTE) {
      length_type = sizeof(BYTE);
      strcpy(strbktype, "Signed Bytes");
   }
   if (type == TID_BOOL) {
      length_type = sizeof(DWORD);
      strcpy(strbktype, "Boolean");
   }
   if (type == TID_CHAR) {
      length_type = sizeof(char);
      strcpy(strbktype, "8 bit ASCII");
   }
   if (type == TID_STRUCT) {
      length_type = sizeof(char);
      strcpy(strbktype, "STRUCT (not supported->8 bits)");
   }
   if (type == TID_STRING) {
      length_type = sizeof(char);
      strcpy(strbktype, "String 8bit ASCI");
   }
 
   printf("\nBank:%s Length: %i(I*1)/%i(I*4)/%i(Type) Type:%s",
          bank_name, lrl, lrl >> 2, lrl / (length_type == 0 ? 1 : length_type), strbktype);
 
   pendbk = pdata + lrl;
   while (pdata < pendbk) {
      switch (type) {
         case TID_DOUBLE:
            if (j > 3) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 4;
            }
            printf("%15.5e    ", *((double *) pdata));
            pdata = (char *) (((double *) pdata) + 1);
            j++;
            break;
         case TID_FLOAT:
            if (j > 7) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 8;
            }
            if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
               printf("%8.3e ", *((float *) pdata));
            if (dsp_fmt == DSP_HEX)
               printf("0x%8.8x ", *((DWORD *) pdata));
            pdata = (char *) (((DWORD *) pdata) + 1);
            j++;
            break;
         case TID_UINT64:
            if (j > 7) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 8;
            }
            if (dsp_fmt == DSP_DEC)
               printf("%16.1llu ", (long long unsigned int) *((uint64_t *) pdata));
            if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
               printf("0x%16.16llx ", (long long unsigned int) *((uint64_t *) pdata));
            pdata = (char *) (((uint64_t *) pdata) + 1);
            j++;
            break;
         case TID_INT64:
            if (j > 7) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 8;
            }
            if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
               printf("%16.1lli ", (long long int) *((int64_t *) pdata));
            if (dsp_fmt == DSP_HEX)
               printf("0x%16.16llx ", (long long unsigned int) *((int64_t *) pdata));
            pdata = (char *) (((int64_t *) pdata) + 1);
            j++;
            break;
         case TID_DWORD:
            if (j > 7) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 8;
            }
            if (dsp_fmt == DSP_DEC)
               printf("%8.1i ", *((DWORD *) pdata));
            if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
               printf("0x%8.8x ", *((DWORD *) pdata));
            pdata = (char *) (((DWORD *) pdata) + 1);
            j++;
            break;
         case TID_INT:
            if (j > 7) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 8;
            }
            if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
               printf("%8.1i ", *((DWORD *) pdata));
            if (dsp_fmt == DSP_HEX)
               printf("0x%8.8x ", *((DWORD *) pdata));
            pdata = (char *) (((DWORD *) pdata) + 1);
            j++;
            break;
         case TID_WORD:
            if (j > 7) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 8;
            }
            if (dsp_fmt == DSP_DEC)
               printf("%5.1i ", *((WORD *) pdata));
            if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
               printf("0x%4.4x ", *((WORD *) pdata));
            pdata = (char *) (((WORD *) pdata) + 1);
            j++;
            break;
         case TID_SHORT:
            if (j > 7) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 8;
            }
            if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
               printf("%5.1i ", *((short *) pdata));
            if (dsp_fmt == DSP_HEX)
               printf("0x%4.4x ", *((short *) pdata));
            pdata = (char *) (((short *) pdata) + 1);
            j++;
            break;
         case TID_BYTE:
         case TID_STRUCT:
            if (j > 15) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 16;
            }
            if (dsp_fmt == DSP_DEC)
               printf("%4.i ", *((BYTE *) pdata));
            if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
               printf("0x%2.2x ", *((BYTE *) pdata));
            pdata++;
            j++;
            break;
         case TID_SBYTE:
            if (j > 15) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 16;
            }
            if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
               printf("%4.i ", *((BYTE *) pdata));
            if (dsp_fmt == DSP_HEX)
               printf("0x%2.2x ", *((BYTE *) pdata));
            pdata++;
            j++;
            break;
         case TID_BOOL:
            if (j > 15) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 16;
            }
            (*((BOOL *) pdata) != 0) ? printf("Y ") : printf("N ");
            pdata = (char *) (((DWORD *) pdata) + 1);
            j++;
            break;
         case TID_CHAR:
         case TID_STRING:
            if (j > 15) {
               printf("\n%4i-> ", i);
               j = 0;
               i += 16;
            }
            if (dsp_fmt == DSP_DEC)
               printf("%3.i ", *((BYTE *) pdata));
            if (dsp_fmt == DSP_ASC || (dsp_fmt == DSP_UNK))
               printf("%1.1s ", (char *) pdata);
            if (dsp_fmt == DSP_HEX)
               printf("0x%2.2x ", *((BYTE *) pdata));
            pdata++;
            j++;
            break;
         default:
            printf("bank type not supported (%d)\n", type);
            return;
            break;
      }
   }                            /* end of bank */
   printf("\n");
   return;
}

Here is the call graph for this function:

midas_event_get()

INT midas_event_get	(	void **	pevent,
		DWORD *	size
	)

midas_event_skip()

INT midas_event_skip

(

INT

evtn

)

midas_physrec_get()

INT midas_physrec_get	(	void *	prec,
		DWORD *	readn
	)

Definition at line 1075 of file mdsupport.cxx.

{
   INT status = 0;
 
   /* read one block of data */
   if (!my.zipfile) {
      status = md_dev_os_read(my.handle, my.type, prec, my.size, readn);
   } else {
      *readn = gzread(filegz, (char *) prec, my.size);
      if (*readn <= 0)
         status = SS_FILE_ERROR;
      else
         status = SS_SUCCESS;
   }
 
   if (status != SS_SUCCESS) {
      return (MD_DONE);
   } else {
      /* count blocks */
      my.recn++;
      return (MD_SUCCESS);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

filegz

gzFile filegz

Definition at line 73 of file mdsupport.cxx.

filestat

struct stat* filestat

Definition at line 70 of file mdsupport.cxx.

my

MY my

Definition at line 96 of file mdsupport.cxx.

ptopmrd

char* ptopmrd

Definition at line 71 of file mdsupport.cxx.