miriad 4.1.0.0

data/ext/maskio.c

@@ -0,0 +1,398 @@
+/************************************************************************/
+/*									*/
+/*	A package of routines to read and write masks (bitmaps)		*/
+/*	These are used by MIRIAD for data flagging and blanking.	*/
+/*									*/
+/*	Masks are implemented as integer data items. The 32nd		*/
+/*	bit in the integer is not used, as this could cause		*/
+/*	portability problems. As it is, this software assumes that	*/
+/*	the host integer is at least 32 bits long.			*/
+/*									*/
+/*  History:								*/
+/*    rjs  Dark-ages Original version.					*/
+/*    rjs   6nov89   Does not abort if the mask file is missing.	*/
+/*    rjs   3mar93   Make mkflush a user-callable routine.		*/
+/*    rjs  23dec93   Do not open in read/write mode unless necessary.	*/
+/*    rjs   6nov94   Change item handle to an integer.			*/
+/*    rjs  19apr97   Handle FORTRAN LOGICALs better. Some tidying.      */
+/************************************************************************/
+
+#define BUG(sev,a)   bug_c(sev,a)
+#define ERROR(sev,a) bug_c(sev,((void)sprintf a,message))
+#define CHECK(x) if(x) bugno_c('f',x)
+#define private static
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "miriad.h"
+
+
+static char message[128];
+
+#define BITS_PER_INT 31
+
+static int bits[BITS_PER_INT] = {
+		0x00000001,0x00000002,0x00000004,0x00000008,
+		0x00000010,0x00000020,0x00000040,0x00000080,
+		0x00000100,0x00000200,0x00000400,0x00000800,
+		0x00001000,0x00002000,0x00004000,0x00008000,
+		0x00010000,0x00020000,0x00040000,0x00080000,
+		0x00100000,0x00200000,0x00400000,0x00800000,
+		0x01000000,0x02000000,0x04000000,0x08000000,
+		0x10000000,0x20000000,0x40000000};
+
+static int masks[BITS_PER_INT+1]={
+		0x00000000,0x00000001,0x00000003,0x00000007,0x0000000F,
+			   0x0000001F,0x0000003F,0x0000007F,0x000000FF,
+			   0x000001FF,0x000003FF,0x000007FF,0x00000FFF,
+			   0x00001FFF,0x00003FFF,0x00007FFF,0x0000FFFF,
+			   0x0001FFFF,0x0003FFFF,0x0007FFFF,0x000FFFFF,
+			   0x001FFFFF,0x003FFFFF,0x007FFFFF,0x00FFFFFF,
+			   0x01FFFFFF,0x03FFFFFF,0x07FFFFFF,0x0FFFFFFF,
+			   0x1FFFFFFF,0x3FFFFFFF,0x7FFFFFFF};
+
+#include "io.h"
+
+#define MK_FLAGS 1
+#define MK_RUNS 2
+#define BUFFERSIZE 128
+#define OFFSET (((ITEM_HDR_SIZE-1)/H_INT_SIZE + 1)*BITS_PER_INT)
+typedef struct {
+  int item;
+  int buf[BUFFERSIZE],offset,length,size,modified,rdonly,tno;
+  char name[32];
+} MASK_INFO;
+
+
+private void mkfill(MASK_INFO *mask,int offset);
+
+/************************************************************************/
+char *mkopen_c(int tno,char *name,char *status)
+/*
+  This opens a mask item, and readies it for access.
+
+  Inputs:
+    tno		The handle of the data set containing the item.
+    name	Name of the item (something like "mask" or "flags").
+    status	"old" or "new".
+
+  Output:
+    mkopen_c	This is a handle used in subsequent calls to the maskio
+		routines. A NULL indicates that an error was encountered.
+
+------------------------------------------------------------------------*/
+{
+  MASK_INFO *mask;
+  int iostat;
+  char s[ITEM_HDR_SIZE];
+
+  mask = (MASK_INFO *)malloc((unsigned int)sizeof(MASK_INFO));
+
+/* The case of an old mask file. Perform a number of checks to make sure
+   the file looks OK. */
+
+  if(!strcmp("old",status)) {
+    haccess_c(tno,&(mask->item),name,"read",&iostat);
+    if(iostat) { free((char *)mask); return(NULL); }
+    mask->size = hsize_c(mask->item);
+    if(mask->size <= H_INT_SIZE * (OFFSET/BITS_PER_INT))
+      ERROR('f',(message,"Mask file %s appears bad",name));
+    hreadb_c(mask->item,s,0,ITEM_HDR_SIZE,&iostat);		CHECK(iostat);
+    if(memcmp(s,int_item,ITEM_HDR_SIZE)) 
+      ERROR('f',(message,"Mask file %s is not integer valued",name));
+    mask->rdonly   = TRUE;
+
+/* The case of a new masl file. Create it and make it look nice. */
+
+  } else if(!strcmp("new",status)) {
+    haccess_c(tno,&(mask->item),name,"write",&iostat);		CHECK(iostat);
+    hwriteb_c(mask->item,int_item,0,ITEM_HDR_SIZE,&iostat);	CHECK(iostat);
+    mask->size = OFFSET/BITS_PER_INT * H_INT_SIZE;
+    mask->rdonly   = FALSE;
+  } else ERROR('f',(message,"Unrecognised status %s in MKOPEN",status));
+
+/* Common to both old and new mask files. Initialise the structure
+   describing the file. */
+
+  mask->size = (mask->size/H_INT_SIZE) * BITS_PER_INT;
+  mask->offset = -BUFFERSIZE*BITS_PER_INT;
+  mask->length = 0;
+  mask->modified = FALSE;
+  mask->tno = tno;
+  strcpy(mask->name,name);
+
+  return((char *)mask);
+}
+/************************************************************************/
+void mkclose_c(char *handle)
+/*
+  This writes out any stuff that we have buffered up, and then closes
+  the mask file.
+
+  Inputs:
+    handle	Pointer to the structure describing the massk file.
+------------------------------------------------------------------------*/
+{
+  MASK_INFO *mask;
+  int iostat;
+
+  mask = (MASK_INFO *)handle;
+  if(mask->modified) mkflush_c(handle);
+  hdaccess_c(mask->item,&iostat);				CHECK(iostat);
+  free((char *)mask);
+}
+/************************************************************************/
+int mkread_c(char *handle,int mode,int *flags,int offset,int n,int nsize)
+/*
+------------------------------------------------------------------------*/
+{
+#define SWITCH_STATE *flags++ = runs + (state ? 0 : 1 ); \
+		     t = state; state = otherstate; otherstate = t
+
+  MASK_INFO *mask;
+  int i,len,boff,blen,bitmask,*buf,iostat,t,state,otherstate,runs;
+  int *flags0;
+
+  flags0 = flags;
+  mask = (MASK_INFO *)handle;
+  offset += OFFSET;
+  state = 0;
+  otherstate = 0x7FFFFFFF;
+  runs = 0;
+
+
+/* Get a buffer full of information if we need it. */
+
+  while(n > 0){
+    if(offset < mask->offset || offset >= mask->offset + mask->length) {
+      if(mask->modified)mkflush_c(handle);
+      mask->offset = (offset/BITS_PER_INT)*BITS_PER_INT;
+      mask->length = min(mask->size - mask->offset,BUFFERSIZE*BITS_PER_INT);
+      mask->modified = FALSE;
+      if(mask->length == 0) BUG('f',"Read past end of mask file");
+      hreadi_c(mask->item,mask->buf,
+		(mask->offset/BITS_PER_INT)*H_INT_SIZE,
+		(mask->length/BITS_PER_INT)*H_INT_SIZE,
+					&iostat);	CHECK(iostat);
+    }
+
+/* Copy the flags to the output buffer. Use special sections of code
+   to deal with all bits being set of clear. */
+
+    boff = offset - mask->offset;
+    t = boff/BITS_PER_INT;
+    buf = mask->buf + t;
+    len = min(mask->length - boff,n);
+    boff -= t*BITS_PER_INT;
+
+    n -= len;
+    offset += len;
+
+/* Copy to the output, in "flags" format. */
+
+    if(mode == MK_FLAGS){
+      while( len > 0){
+	blen = min( BITS_PER_INT - boff,len);
+	bitmask = *buf++;
+	if(bitmask == 0x7FFFFFFF) for(i=0; i<blen; i++) *flags++ = FORT_TRUE;
+	else if(bitmask == 0)     for(i=0; i<blen; i++) *flags++ = FORT_FALSE;
+	else{
+	  for(i=boff; i<boff+blen; i++)
+	    *flags++ = ( bits[i] & bitmask ? FORT_TRUE : FORT_FALSE );
+	}
+	len -= blen;
+	boff = 0;
+      }
+
+/* Copy to the output, in "runs" format. */
+
+    } else {
+      while( len > 0){
+	blen = min( BITS_PER_INT - boff,len);
+	bitmask = *buf++;
+	if(bitmask == state ) runs += blen;
+        else if(bitmask == otherstate ) { SWITCH_STATE; runs += blen; }
+	else {
+	  for(i=boff; i<boff+blen; i++){
+	    if((bits[i] & bitmask) != (bits[i] & state)) { SWITCH_STATE; }
+	    runs++;
+	  }
+	}
+	len -= blen;
+	boff = 0;
+      }
+    }
+  }
+  if(state) *flags++ = runs;
+  nsize -= (flags - flags0);
+  if(nsize < 0) bug_c('f',"Buffer overflow in MKREAD");
+  return(flags - flags0);
+}
+/************************************************************************/
+void mkwrite_c(char *handle,int mode,int *flags,int offset,int n,int nsize)
+/*
+------------------------------------------------------------------------*/
+{
+  MASK_INFO *mask;
+  int i,len,boff,blen,bitmask,*buf,t;
+  int run,curr,state,iostat;
+
+  curr = 0;
+  state = 1;
+  run = 0;
+
+  mask = (MASK_INFO *)handle;
+  offset += OFFSET;
+
+/* If the mask is currently read-only, close it and reopen it as read/write. */
+
+  if(mask->rdonly){
+    hdaccess_c(mask->item,&iostat);
+    haccess_c(mask->tno,&(mask->item),mask->name,"append",&iostat);
+    if(iostat){
+      bug_c('w',"Error opening mask/flagging file in read/write mode\n");
+      bugno_c('f',iostat);
+    }
+    mask->rdonly = FALSE;
+  }
+
+/* Check if we have the right buffer. Flush if not. */
+
+  while(n > 0){
+    if(offset < mask->offset || offset >= mask->offset + BUFFERSIZE*BITS_PER_INT) {
+      if(mask->modified)mkflush_c(handle);
+      mask->offset = (offset/BITS_PER_INT)*BITS_PER_INT;
+      mask->length = 0;
+      mask->modified = FALSE;
+    }
+
+/* See if we have to read in any stuff to fill in between the last write
+   and the current write. */
+
+  if(offset > mask->offset + mask->length)mkfill(mask,offset);
+
+/* Copy the flags to the output buffer. */
+
+    boff = offset - mask->offset;
+    t = boff/BITS_PER_INT;
+    buf = mask->buf + t;
+    len = min(BITS_PER_INT*BUFFERSIZE - boff,n);
+    boff -= t*BITS_PER_INT;
+
+    mask->length = max(mask->length,offset - mask->offset + len);
+    mask->modified = TRUE;
+
+    n -= len;
+    offset += len;
+
+/* Write to the file, assuming the input is in FLAGS format. */
+
+    if(mode == MK_FLAGS){
+      while( len > 0){
+        blen = min( BITS_PER_INT - boff,len);
+        bitmask = *buf;
+        for(i=boff; i<boff+blen; i++){
+	  if(FORT_LOGICAL(*flags)) bitmask |=  bits[i];
+	  else			       bitmask &= ~bits[i];
+	  flags++;
+        }
+        *buf++ = bitmask;
+        len -= blen;
+        boff = 0;
+      }
+
+/* Write to the file, assuming the input is in RUNS format. */
+
+    } else {
+      while( len > 0 ){
+	while(run == 0){
+	  if(nsize == 0) run = n + len;
+	  else{
+	    t = *flags++ - (state ? 1 : 0);
+	    run = t - curr;
+	    curr = t;
+	    nsize --;
+	  }
+	  state ^= 1;
+	}
+	blen = min(run, min( BITS_PER_INT - boff, len));
+	bitmask = masks[boff+blen] ^ masks[boff];
+	if(state) *buf |=  bitmask;	/* Set the bits. */
+	else	  *buf &= ~bitmask;	/* Clear the bits. */
+	run -= blen;
+	len -= blen;
+	boff = (boff + blen) % BITS_PER_INT;
+	if(!boff) buf++;
+      }
+    }
+  }
+}
+/************************************************************************/
+void mkflush_c(char *handle)
+/*
+  Flush out the data in the buffer. A complication is that the last
+  integer in the buffer may not be completely filled. In this case we
+  have to read in the value of this integer, and copy the old bits to
+  the output.
+
+  Input:
+    mask	Pointer to the mask structure.
+------------------------------------------------------------------------*/
+{
+  MASK_INFO *mask;
+  int i,t,*buf,offset,iostat;
+
+  mask = (MASK_INFO *)handle;
+
+/* If we are writing at the end of the file, make sure the number we
+   write is a multiple of BITS_PER_INT. Also update the size of the
+   file. */
+
+  if( mask->offset + mask->length >= mask->size) {
+    mask->length = ((mask->length-1)/BITS_PER_INT + 1)*BITS_PER_INT;
+    mask->size = mask->offset + mask->length;
+
+/* If the last word is only partially filled, read in the rest of the
+   word and transfer the bits. */
+
+  } else if((mask->length % BITS_PER_INT) != 0) {
+    offset = (mask->offset + mask->length) / BITS_PER_INT * H_INT_SIZE;
+    hreadi_c(mask->item,&t,offset,H_INT_SIZE,&iostat);		CHECK(iostat);
+    buf = mask->buf + mask->length/BITS_PER_INT;
+    i = mask->length % BITS_PER_INT;
+    *buf = ( t & ~masks[i] ) | (*buf & masks[i]);
+    mask->length = ((mask->length-1)/BITS_PER_INT + 1)*BITS_PER_INT;
+  }
+
+/* Write out the stuff at last. */
+
+  hwritei_c(mask->item,mask->buf,
+		mask->offset/BITS_PER_INT*H_INT_SIZE,
+		mask->length/BITS_PER_INT*H_INT_SIZE,&iostat);	CHECK(iostat);
+  mask->modified = FALSE;
+}
+/************************************************************************/
+private void mkfill(MASK_INFO *mask,int offset)
+/*
+  We have to fill in some bits in the current buffer.
+
+  Inputs:
+    mask	Pointer to the mask structure.
+    offset	The first location that we want to write at.
+------------------------------------------------------------------------*/
+{
+  int off,len,t,*buf,iostat,i;
+
+  if(mask->offset+mask->length < mask->size) {
+    buf = mask->buf + mask->length/BITS_PER_INT;
+    t = *buf;
+    off = (mask->offset + mask->length)/BITS_PER_INT;
+    len = min(offset/BITS_PER_INT + 1,mask->size/BITS_PER_INT) - off;
+    hreadi_c(mask->item,buf,
+		off*H_INT_SIZE,len*H_INT_SIZE,&iostat);		CHECK(iostat);
+    i = mask->length % BITS_PER_INT;
+    *buf = ( t & masks[i] ) | (*buf & ~masks[i]);
+    mask->length = (off + len)*BITS_PER_INT - mask->offset;
+  }
+}

data/ext/maxdimc.h.in

@@ -0,0 +1,9 @@
+/*
+ * Warning: do not edit this file, it has possibly been generated by extconf.rb
+ */
+#define   MAXDIM    @MAXDIM@
+#define   MAXIANT   @MAXIANT@
+#define   MAXANT    @MAXANT@
+#define   MAXNAX    @MAXNAX@
+#define   MAXWIN    @MAXWIN@
+#define   MAXBUF    @MAXBUF@

data/ext/miriad.h

@@ -0,0 +1,371 @@
+/*
+// Header that gives C++ code access to the MIRIAD IO routines
+// Is now also used a global prototype header file for all C routines
+//
+// History:
+//
+// 21-oct-94 pjt Created as follows:
+//               cproto uvio.c hio.c dio.c bug.c pack.c headio.c maskio.c > miriad.h
+//                  and edited to please the C++ compiler and the eye:
+//
+// 22-oct-94 pjt added hio.h definitions - clumsy ....	pjt
+//               (the hio routines are macros we don't want to allow that here)
+//
+//   fall-96 pjt minor tidying up for AIPS++ bimafiller release	- pjt
+// 13-dec-96 rjs Regenerated, using
+//		 cproto -I$MIRINC -p -fARGS hio.c headio.c uvio.c xyio.c xyzio.c bug.c
+// 07-feb-97 rjs Added "Const" to definitions, and eliminate some rubbish, as
+//		 suggested by Scott Gordon.
+// 19-Mar-97 rjs Check for definition of various thingos before doing them.
+// 15-jun-01 pjt Added key.c for BIMA version (ATNF uses keyc.c) as well as
+//               the uvget* uvrd* macros from uvio.c
+// 28-may-02 pjt LFS patches: make it for for > 2GB file using off_t/size_t (prep for MIR4)
+// 17-jun-02 pjt added interface.c routines; now used as global prototype file
+// 23-jun-02 pjt define MIR4 here if you want to enable the LSF and MIR4
+// 30-aug-04 pjt removed deprecated ARGS() macro
+//  1-dec-05 pjt added bugv_c
+// 18-may-06 pjt/df  added mir.c prototypes for mir (the miriad->mir converter)
+*/
+
+#if !defined(MIR_MIRIAD_H)
+#define MIR_MIRIAD_H
+
+
+/*  comment this out if you only handle data < 2GB and need to be compatible with old MIRIAD */
+/*  or simply define MIR3 through compile options                                            */
+#if !defined(MIR3)
+#define MIR4  
+#endif
+
+#include <sys/types.h>     /* provides off_t */
+#include <unistd.h>
+#include <stdarg.h>
+#include "sysdep.h"        /* since it now contains the "pack.c" prototypes */
+
+/* Define const and void if needed. */
+
+#ifndef MIRIAD_TYPES_DEFINED
+
+#define MIRIAD_TYPES_DEFINED 1
+#ifdef __STDC__
+#if (__STDC__ == 1)
+typedef void Void;
+#define Const const
+#else
+typedef char Void;
+#define Const /* NULL */
+#endif /* (__STDC__ == 1) */
+#else
+typedef char Void;
+#define Const /* NULL */
+#endif /* __STDC__ */
+
+/* Define the argument list if needed. */
+
+#if !defined(ARGS)
+#  if defined(__STDC__) || defined(__cplusplus)
+#    define ARGS(s) s
+#  else
+#    define ARGS(s) ()
+#  endif
+#endif
+
+#endif
+
+#if defined(__cplusplus)
+extern  "C" {
+#endif
+
+/* hio.h */
+
+#if !defined(TRUE)
+# define TRUE		1
+#else
+# if TRUE != 1
+#  error "TRUE should be 1"
+# endif
+#endif
+
+#if !defined(FALSE)
+# define FALSE		0
+#else
+# if FALSE != 0
+#  error "FALSE should be 0"
+# endif
+#endif
+
+#define H_BYTE          1
+#define H_INT           2
+#define H_INT2          3
+#define H_REAL          4
+#define H_DBLE          5
+#define H_TXT           6
+#define H_CMPLX         7
+
+/* hio.c */
+
+void hopen_c(int *tno, Const char *name, Const char *status, int *iostat);
+void hflush_c(int tno, int *iostat);
+void habort_c(void);
+void hrm_c(int tno);
+void hclose_c(int tno);
+void hdelete_c(int tno, Const char *keyword, int *iostat);
+void haccess_c(int tno, int *ihandle, Const char *keyword, Const char *status, int *iostat);
+void hmode_c(int tno, char *mode);
+int  hexists_c(int tno, Const char *keyword);
+void hdaccess_c(int ihandle, int *iostat);
+off_t hsize_c(int ihandle);
+void hio_c(int ihandle, int dowrite, int type, char *buf, off_t offset, size_t length, int *iostat);
+void hseek_c(int ihandle, off_t offset);
+off_t htell_c(int ihandle);
+void hreada_c(int ihandle, char *line, size_t length, int *iostat);
+void hwritea_c(int ihandle, Const char *line, size_t length, int *iostat);
+
+/* Macros defined in hio.c */
+
+#define hreadb_c(item,buf,offset,length,iostat) \
+        hio_c(item,FALSE,H_BYTE,buf,offset,length,iostat)
+#define hwriteb_c(item,buf,offset,length,iostat) \
+        hio_c(item,TRUE,H_BYTE,buf,offset,length,iostat)
+#define hreadi_c(item,buf,offset,length,iostat) \
+        hio_c(item,FALSE,H_INT,(char *)(buf),offset,length,iostat)
+#define hwritei_c(item,buf,offset,length,iostat) \
+        hio_c(item,TRUE,H_INT,(char *)(buf),offset,length,iostat)
+#define hreadj_c(item,buf,offset,length,iostat) \
+        hio_c(item,FALSE,H_INT2,(char *)(buf),offset,length,iostat)
+#define hwritej_c(item,buf,offset,length,iostat) \
+        hio_c(item,TRUE,H_INT2,(char *)(buf),offset,length,iostat)
+#define hreadl_c(item,buf,offset,length,iostat) \
+        hio_c(item,FALSE,H_INT8,(char *)(buf),offset,length,iostat)
+#define hwritel_c(item,buf,offset,length,iostat) \
+        hio_c(item,TRUE,H_INT8,(char *)(buf),offset,length,iostat)
+#define hreadr_c(item,buf,offset,length,iostat) \
+        hio_c(item,FALSE,H_REAL,(char *)(buf),offset,length,iostat)
+#define hwriter_c(item,buf,offset,length,iostat) \
+        hio_c(item,TRUE,H_REAL,(char *)(buf),offset,length,iostat)
+#define hreadd_c(item,buf,offset,length,iostat) \
+        hio_c(item,FALSE,H_DBLE,(char *)(buf),offset,length,iostat)
+#define hwrited_c(item,buf,offset,length,iostat) \
+        hio_c(item,TRUE,H_DBLE,(char *)(buf),offset,length,iostat)
+#define hreadc_c(item,buf,offset,length,iostat) \
+        hio_c(item,FALSE,H_CMPLX,(char *)(buf),offset,length,iostat)
+#define hwritec_c(item,buf,offset,length,iostat) \
+        hio_c(item,TRUE,H_CMPLX,(char *)(buf),offset,length,iostat)
+#define hwrite_c(item,type,buf,offset,length,iostat) \
+        hio_c(item,TRUE,type,(char *)(buf),offset,length,iostat)
+#define hread_c(item,type,buf,offset,length,iostat) \
+        hio_c(item,FALSE,type,(char *)(buf),offset,length,iostat)
+ 
+/* headio.c */
+
+void hisopen_c  (int tno, Const char *status);
+void hiswrite_c (int tno, Const char *text);
+void hisread_c  (int tno, char *text, size_t length, int *eof);
+void hisclose_c (int tno);
+void wrhdr_c (int tno, Const char *keyword, double value);
+void wrhdd_c (int tno, Const char *keyword, double value);
+void wrhdi_c (int tno, Const char *keyword, int value);
+void wrhdl_c (int tno, Const char *keyword, int8 value);
+void wrhdc_c (int tno, Const char *keyword, Const float *value);
+void wrhda_c (int tno, Const char *keyword, Const char *value);
+void rdhdr_c (int tno, Const char *keyword, float *value, double defval);
+void rdhdi_c (int tno, Const char *keyword, int *value, int defval);
+void rdhdl_c (int tno, Const char *keyword, int8 *value, int8 defval);
+void rdhdd_c (int tno, Const char *keyword, double *value, double defval);
+void rdhdc_c (int tno, Const char *keyword, float *value, Const float *defval);
+void rdhda_c (int tno, Const char *keyword, char *value, Const char *defval, int len);
+void hdcopy_c (int tin, int tout, Const char *keyword);
+int  hdprsnt_c (int tno, Const char *keyword);
+void hdprobe_c (int tno, Const char *keyword, char *descr, size_t length, char *type, int *n);
+
+/* dio.c */
+
+void ddelete_c   (char *path, int *iostat);
+void dtrans_c    (char *inpath, char *outpath, int *iostat);
+void dmkdir_c    (char *path, int *iostat);
+void drmdir_c    (char *path, int *iostat);
+void dopen_c     (int *fd, char *name, char *status, off_t *size, int *iostat);
+void dclose_c    (int fd, int *iostat);
+void dread_c     (int fd, char *buffer, off_t offset, size_t length, int *iostat);
+void dwrite_c    (int fd, char *buffer, off_t offset, size_t length, int *iostat);
+void dwait_c     (int fd, int *iostat);
+int dexpand_c    (char *tmplte, char *output, int length);
+void dopendir_c  (char **contxt, char *path);
+void dclosedir_c (char *contxt);
+void dreaddir_c  (char *contxt, char *path, int length);
+
+/* uvio.c */
+
+void uvopen_c   (int *tno, Const char *name, Const char *status);
+void uvclose_c  (int tno);
+void uvflush_c  (int tno);
+void uvnext_c   (int tno);
+void uvrewind_c (int tno);
+void uvcopyvr_c (int tin, int tout);
+int  uvupdate_c (int tno);
+void uvvarini_c (int tno, int *vhan);
+void uvvarset_c (int vhan, Const char *var);
+void uvvarcpy_c (int vhan, int tout);
+int  uvvarupd_c (int vhan);
+void uvrdvr_c   (int tno, int type, Const char *var, char *data, char *def, int n);
+void uvgetvr_c  (int tno, int type, Const char *var, char *data, int n);
+void uvprobvr_c (int tno, Const char *var, char *type, int *length, int *updated);
+void uvputvr_c  (int tno, int type, Const char *var, Const char *data, int n);
+void uvtrack_c  (int tno, Const char *name, Const char *switches);
+int  uvscan_c   (int tno, Const char *var);
+void uvwrite_c  (int tno, Const double *preamble, Const float *data, Const int *flags, int n);
+void uvwwrite_c (int tno, Const float *data, Const int *flags, int n);
+void uvsela_c   (int tno, Const char *object, Const char *string, int datasel);
+void uvselect_c (int tno, Const char *object, double p1, double p2, int datasel);
+void uvset_c    (int tno, Const char *object, Const char *type, int n, double p1, double p2, double p3);
+void uvread_c   (int tno, double *preamble, float *data, int *flags, int n, int *nread);
+void uvwread_c  (int tno, float *data, int *flags, int n, int *nread);
+void uvflgwr_c  (int tno, Const int *flags);
+void uvwflgwr_c (int tno, Const int *flags);
+void uvinfo_c   (int tno, Const char *object, double *data);
+
+/* Macros defined in uvio.c */
+
+#define uvputvra_c(tno,name,value)   \
+        uvputvr_c(tno,H_BYTE,name,value,strlen(value))
+#define uvputvrj_c(tno,name,value,n) \
+        uvputvr_c(tno,H_INT2,name,(char *)(value),n)
+#define uvputvri_c(tno,name,value,n) \
+        uvputvr_c(tno,H_INT,name,(char *)(value),n)
+#define uvputvrr_c(tno,name,value,n) \
+        uvputvr_c(tno,H_REAL,name,(char *)(value),n)
+#define uvputvrd_c(tno,name,value,n) \
+        uvputvr_c(tno,H_DBLE,name,(char *)(value),n)
+#define uvputvrc_c(tno,name,value,n) \
+        uvputvr_c(tno,H_CMPLX,name,(char *)(value),n)
+
+#define uvgetvra_c(tno,name,value,n)   \
+        uvgetvr_c(tno,H_BYTE,name,value,n)
+#define uvgetvrj_c(tno,name,value,n) \
+        uvgetvr_c(tno,H_INT2,name,(char *)(value),n)
+#define uvgetvri_c(tno,name,value,n) \
+        uvgetvr_c(tno,H_INT,name,(char *)(value),n)
+#define uvgetvrr_c(tno,name,value,n) \
+        uvgetvr_c(tno,H_REAL,name,(char *)(value),n)
+#define uvgetvrd_c(tno,name,value,n) \
+        uvgetvr_c(tno,H_DBLE,name,(char *)(value),n)
+#define uvgetvrc_c(tno,name,value,n) \
+        uvgetvr_c(tno,H_CMPLX,name,(char *)(value),n)
+
+#define uvrdvra_c(tno,name,data,def,len) \
+	uvrdvr_c(tno,H_BYTE,name,data,def,len)
+#define uvrdvri_c(tno,name,data,def) \
+	uvrdvr_c(tno,H_INT,name,(char *)(data),(char *)(def),1)
+#define uvrdvrr_c(tno,name,data,def) \
+	uvrdvr_c(tno,H_REAL,name,(char *)(data),(char *)(def),1)
+#define uvrdvrd_c(tno,name,data,def) \
+	uvrdvr_c(tno,H_DBLE,name,(char *)(data),(char *)(def),1)
+#define uvrdvrc_c(tno,name,data,def) \
+	uvrdvr_c(tno,H_CMPLX,name,(char *)(data),(char *)(def),1)
+
+/* xyio.c */
+
+void xyopen_c  (int *tno, Const char *name, Const char *status, int naxis, int axes[]);
+void xyflush_c (int tno);
+void xyclose_c (int tno);
+void xyread_c  (int tno, int index, float *array);
+void xywrite_c (int tno, int index, Const float *array);
+void xymkrd_c  (int tno, int index, int *runs, int n, int *nread);
+void xymkwr_c  (int tno, int index, Const int *runs, int n);
+void xyflgwr_c (int tno, int index, Const int *flags);
+void xyflgrd_c (int tno, int index, int *flags);
+void xysetpl_c (int tno, int naxis, Const int *axes);
+
+/* maskio.c */
+char *mkopen_c (int tno, char *name, char *status);
+void mkclose_c (char *handle);
+int  mkread_c  (char *handle, int mode, int *flags, int offset, int n, int nsize);
+void mkwrite_c (char *handle, int mode, int *flags, int offset, int n, int nsize);
+void mkflush_c (char *handle);
+
+
+/* xyzio.c */
+
+void xyzopen_c  (int *tno, Const char *name, Const char *status, int *naxis, int axlen[]);
+void xyzclose_c (int tno);
+void xyzflush_c (int tno);
+void xyzmkbuf_c (void);
+void xyzsetup_c (int tno, Const char *subcube, Const int blc[], Const int trc[], int viraxlen[], int vircubesize[]);
+void xyzs2c_c   (int tno, int subcubenr, int coords[]);
+void xyzc2s_c   (int tno, Const int coords[], int *subcubenr);
+void xyzread_c  (int tno, Const int coords[], float *data, int *mask, int *ndata);
+void xyzpixrd_c (int tno, int pixelnr, float *data, int *mask);
+void xyzprfrd_c (int tno, int profilenr, float *data, int *mask, int *ndata);
+void xyzplnrd_c (int tno, int planenr, float *data, int *mask, int *ndata);
+void xyzwrite_c (int tno, Const int coords[], Const float *data, Const int *mask, Const int *ndata);
+void xyzpixwr_c (int tno, int pixelnr, Const float *data, Const int *mask);
+void xyzprfwr_c (int tno, int profilenr, Const float *data, Const int *mask, Const int *ndata);
+void xyzplnwr_c (int tno, int planenr, Const float *data, Const int *mask, Const int *ndata);
+
+
+/* bug.c */
+
+char bugseverity_c(void);
+char *bugmessage_c(void);
+void bugrecover_c(void (*cl)(void));
+void buglabel_c  (Const char *name);
+void bugno_c     (char s, int n);
+void bug_c       (char s, Const char *m);
+void bugv_c      (char s, Const char *m, ...);
+
+/* scrio.c */
+
+void scropen_c  (int *handle);
+void scrclose_c (int handle);
+void scrread_c  (int handle, float *buffer, int offset, int length);
+void scrwrite_c (int handle, Const float *buffer, int offset, int length);
+
+
+/* tabio.c */
+
+void tabopen_c  (int *tno, Const char *name, Const char *status, int *ncol, int *nrow);
+void tabclose_c (int tno);
+void tabsetr_c  (int tno, int row);
+void tabfmtc_c  (int tno, int col, char *fmt);
+void tabcmt_c   (int tno, char *comment);
+void tabwcr_c   (int tno, int col, float value);
+void tabwcd_c   (int tno, int col, double value);
+void tabwci_c   (int tno, int col, int value);
+void tabwca_c   (int tno, int col, char *value);
+
+
+/* key.c */
+
+void keyinit_c (Const char *task);
+void keyput_c  (Const char *task, char *string);
+void keyini_c  (int argc, char *argv[]);
+void keyfin_c  (void);
+int keyprsnt_c (Const char *keyword);
+void keya_c    (Const char *keyword, char *value, Const char *keydef);
+void keyf_c    (Const char *keyword, char *value, Const char *keydef);
+void keyd_c    (Const char *keyword, double *value, Const double keydef);
+void keyr_c    (Const char *keyword, float *value, Const float keydef);
+void keyi_c    (Const char *keyword, int *value, Const int keydef);
+void keyl_c    (Const char *keyword, int *value, Const int keydef);
+void mkeyd_c   (Const char *keyword, double value[], Const int nmax, int *n);
+void mkeyr_c   (Const char *keyword, float value[], Const int nmax, int *n);
+void mkeyi_c   (Const char *keyword, int value[], Const int nmax, int *n);
+
+/* mir.c */
+void mirInit_c(const char *f_name);
+void mirClose_c(void);
+void inWrite_c(const int conid, const int icocd, const int traid, const int inhid, const int ints, const int itq, const float az, const float el, const float ha, const int iut, const int iref_time, const double dhrs, const float vc, const int ivctype, const double sx, const double sy, const double sz, const float rinteg, const int proid, const int souid, const int isource, const int ipos, const float offx, const float offy, const int iofftype, const int ira, const int idec, const double rar, const double decr, const float epoch, const float sflux, const float size);
+void blWrite_c(const int blhid, const int inhid, const int isb, const int ipol, const float pa, const int iaq, const int ibq, const int icq, const int ioq, const int irec, const int iffc, const float u, const float v, const float w, const float prbl, const float angres, const float vis, const float coh, const float sigcoh, const float csnr, const float vflux, const float cnoise, const double avedhrs, const float ampav, const float phaave, const float tpvar, const int blsid, const int itel1, const int itel2, const int iblcd, const float ble, const float bln, const float blu, const int soid);
+void spWrite_c(const int sphid, const int blhid, const int inhid, const int igq, const int ipq, const int iband, const int ipstate, const float tau0, const double vel, const float vres, const int ivtype, const double fsky, const float fres, const float tssb, const float integ, const float wt, const int itaper, const float snoise, const int nch, const int nrec, const int dataoff, const int linid, const int itrans, const double rfreq, const int pasid, const int gaiidamp, const int gaiidpha, const int flcid, const int atmid);
+void codeWrite_c(const char *v_name, const int icode, const char *code, const int ncode);
+void visWrite_c(const float *re, const float *im, const int numvis, const int startvis, int *nbytes);
+
+/* interface.c */
+void pad(char *string, int length);
+char *zterm(char *string, int length);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif   /*  MIR_MIRIAD_H */