miriad 4.1.0.0

data/ext/miriad.i

@@ -0,0 +1,464 @@
+/* $Id: miriad.i 899 2008-04-17 21:51:06Z davidm $ */
+
+/* MIRIAD Swig wrapper */
+
+%module(docstring="Scripting interface to MIRIAD I/O routines") miriad
+%feature("autodoc","");
+%include "exception.i"
+
+// This specifies the name for mirlib error messages.
+%init %{
+  buglabel_c("mirlib");
+%}
+
+%{
+#include "miriad.h"
+#define MAX_STRLEN (255)
+
+typedef struct {
+  int fd;
+} uvio;
+%}
+
+// Language specific includes
+//TODO %include miriad_tcl.i
+//TODO %include miriad_java.i
+//TODO %include miriad_python.i
+%include miriad_ruby.i   // Typemaps
+
+typedef struct {} uvio;
+
+%extend uvio {
+
+    // uvio.c
+
+    //void uvopen_c   (int *tno, Const char *name, Const char *status);
+    // status is either "old" (to read), "new" (to create), or "append" (to
+    // append)
+    uvio(char * name, char * status) {
+      char * his_status = "append";
+      uvio * self;
+      if(name == NULL) {
+        SWIG_exception(SWIG_NullReferenceError,"invalid name");
+      }
+      if(status == NULL) {
+        SWIG_exception(SWIG_NullReferenceError,"invalid status");
+      }
+      switch(status[0]) {
+        case 'o':
+        case 'r': status = "old";
+                  his_status = "read";
+                  break;
+        case 'n':
+        case 'w': status = "new";
+                  break;
+        case 'a': status = "append";
+                  break;
+        default: SWIG_exception(SWIG_ValueError,"invalid status");
+                  break;
+      }
+      self = malloc(sizeof(uvio));
+      uvopen_c(&(self->fd), name, status);
+      // TODO Error check
+      hisopen_c(self->fd,his_status);
+      uvset_c(self->fd, "preamble", "uvw/time/baseline", 0, 0.0, 0.0, 0.0);
+      uvset_c(self->fd, "coord", "nanosec", 0, 0.0, 0.0, 0.0);
+      if(status[0] == 'o') {
+        // To read initial values of uv vars
+        uvnext_c(self->fd);
+        uvrewind_c(self->fd);
+      }
+      return self;
+    }
+
+    ~uvio() {
+      if(self->fd != -1) {
+        hisclose_c(self->fd);
+        uvflush_c(self->fd);
+        uvclose_c(self->fd);
+        self->fd = -1;
+      }
+      free(self);
+    }
+
+    //void uvclose_c  (int tno);
+    void close() {
+      hisclose_c(self->fd);
+      uvflush_c(self->fd);
+      uvclose_c(self->fd);
+      self->fd = -1;
+    }
+
+    //void uvflush_c  (int tno);
+    void flush() {
+      uvflush_c(self->fd);
+    }
+
+    //void uvnext_c   (int tno);
+    void uvnext() {
+      uvnext_c(self->fd);
+    }
+
+    //void uvrewind_c (int tno);
+    void rewind() {
+      uvrewind_c(self->fd);
+    }
+
+    //void uvprobvr_c (int tno, Const char *var, char *type, int *length, int *updated);
+    void probvr(char *var, char *type, int *length, int *updated) {
+      uvprobvr_c(self->fd, var, type, length, updated);
+    }
+
+    //void uvputvr_c  (int tno, int type, Const char *var, Const char *data, int n);
+    // NB: Swapped order of var and type parameters!
+    //     (For simpler SWIG typemaps.)
+    void putvr(char *var, char *data, int n, int type = -1) {
+      uvputvr_c(self->fd, type, var, data, n);
+    }
+
+    //void uvscan_c   (int tno, Const char *var);
+    void scan(char *var) {
+      uvscan_c(self->fd, var);
+    }
+
+    //void uvwrite_c  (int tno, Const double *preamble, Const float *data, Const int *flags, int n);
+    void write(double *preamble, float *data, int *flags, int n) {
+      uvwrite_c(self->fd, preamble, data, flags, n);
+    }
+
+    //void uvwwrite_c (int tno, Const float *data, Const int *flags, int n);
+    void wwrite(float *data, int *flags, int n) {
+      uvwwrite_c(self->fd, data, flags, n);
+    }
+
+    //void uvset_c(int tno, Const char *object, Const char *type, int n, double p1,double p2,double p3);
+    void set(char *object, char *type, int n = 0,
+        double p1 = 0.0, double p2 = 0.0, double p3 = 0.0) {
+      uvset_c(self->fd, object, type, n, p1, p2, p3);
+    }
+
+    //void uvread_c   (int tno, double *preamble, float *data, int *flags, int n, int *nread);
+    // Named uvread to allow for a higher level read method
+    void uvread(double *preamble, float *data, int *flags, int n, int *nread) {
+      uvread_c(self->fd, preamble, data, flags, n, nread);
+    }
+
+    //void uvwread_c  (int tno, float *data, int *flags, int n, int *nread);
+    void uvwread(float *data, int *flags, int n, int *nread) {
+      uvwread_c(self->fd, data, flags, n, nread);
+    }
+
+#if 0
+    void putvra(char * name, char * value) {
+      uvputvra_c(self->fd,name,value);
+    }
+
+    void putvrj(char * name, short * value, int n) {
+      uvputvrj_c(self->fd,name,value,n);
+    }
+
+    void putvri(char * name, int * value, int n) {
+      uvputvri_c(self->fd,name,value,n);
+    }
+
+    void putvrr(char * name, float * value, int n) {
+      uvputvrr_c(self->fd,name,value,n);
+    }
+
+    void putvrd(char * name, double * value, int n) {
+      uvputvrd_c(self->fd,name,value,n);
+    }
+
+    void putvrc(char * name,value,n) {
+      uvputvrc_c(self->fd,name,value,n);
+    }
+#endif // 0
+
+#if 0
+    // This is redundant; use more general getvr
+    char * getvra(char * name) {
+      char *value = NULL;
+      char type = 'c';
+      int n = 0;
+      int updated = 0;
+      uvprobvr_c(self->fd,name,&type,&n,&updated);
+      if(n > 0) {
+        if(type != 'c') {
+          rb_raise(rb_eArgError,
+              "variable %s is not an ASCII string, it is type '%c'",
+              name, type);
+        }
+        value = malloc(sizeof(char)*n);
+        uvgetvr_c(self->fd,H_BYTE,name,value,n);
+      }
+      return value;
+    }
+#endif
+
+#if 0
+    // TODO TODO TODO
+    void getvrj(char * name,value,n) {
+      uvgetvr_c(tno,H_INT2,name,(char *)(value),n)
+    }
+#endif
+    void getvr(char * name, void ** value, int * n, char *type) {
+      int updated = 0;
+      *n = 0;
+      *type = ' ';
+      uvprobvr_c(self->fd,name,type,n,&updated);
+      if(*n > 0) {
+        switch(*type) {
+          case 'a': *value = malloc(sizeof(char)*((*n)+1));
+                    uvgetvr_c(self->fd,H_BYTE,name,(char *)(*value),((*n)+1));
+                    break;
+          case 'i': *value = malloc(sizeof(int)*(*n));
+                    uvgetvr_c(self->fd,H_INT,name,(char *)(*value),*n);
+                    break;
+          case 'r': *value = malloc(sizeof(float)*(*n));
+                    uvgetvr_c(self->fd,H_REAL,name,(char *)(*value),*n);
+                    break;
+          case 'd': *value = malloc(sizeof(double)*(*n));
+                    uvgetvr_c(self->fd,H_DBLE,name,(char *)(*value),*n);
+                    break;
+          case ' ': // Variable not present
+          case 'j': // Unsuported
+                    // Return NULL, but don't raise exception
+                    break;
+          default: // TODO Raise exception
+                    break;
+        }
+      }
+    }
+#if 0
+    void getvrr(char * name,value,n) {
+      uvgetvr_c(tno,H_REAL,name,(char *)(value),n)
+    }
+    void getvrd(char * name,value,n) {
+      uvgetvr_c(tno,H_DBLE,name,(char *)(value),n)
+    }
+    void getvrc(char * name,value,n) {
+      uvgetvr_c(tno,H_CMPLX,name,(char *)(value),n)
+    }
+
+    // TODO Typemaps!!!
+    void rdvra(char * name, char * data, char * def, int n) {
+      uvrdvr_c(self->fd,H_BYTE,name,data,def,n);
+      if(n > 0) {
+        data[n-1] = '\0';
+      }
+      return data;
+    }
+
+    int rdvri(char * name, int def) {
+      int data = 0;
+      uvrdvr_c(self->fd,H_INT,name,(char *)(&data),(char *)(&def),1);
+      return data;
+    }
+
+    float rdvrf(char * name, float def) {
+      float data = 0.0;
+      uvrdvr_c(self->fd,H_REAL,name,(char *)(&data),(char *)(&def),1);
+      return data;
+    }
+
+    double rdvrd(char * name, double def) {
+      double * data = 0.0;
+      uvrdvr_c(self->fd,H_DBLE,name,(char *)(&data),(char *)(&def),1);
+      return data;
+    }
+
+    void rdvrc(char * name, float * cdata, float * cdef) {
+      uvrdvr_c(self->fd,H_CMPLX,name,(char *)(cdata),(char *)(cdef),1);
+    }
+
+//TODO void uvcopyvr_c (int tin, int tout);
+#endif // 0
+
+    // int  uvupdate_c (int tno);
+    int updated() {
+      return uvupdate_c(self->fd);
+    }
+
+#if 0
+//TODO void uvvarini_c (int tno, int *vhan);
+//TODO void uvvarset_c (int vhan, Const char *var);
+//TODO void uvvarcpy_c (int vhan, int tout);
+//TODO int  uvvarupd_c (int vhan);
+#endif // 0
+
+    // void uvtrack_c  (int tno, Const char *name, Const char *switches);
+    void track(char *name, char *switches) {
+      uvtrack_c(self->fd, name, switches);
+    }
+
+    // void uvsela_c   (int tno, Const char *object, Const char *string, int datasel);
+    void sela(char *object, int datasel, char *string) {
+      uvsela_c(self->fd, object, string, datasel);
+    }
+
+    // void uvselect_c (int tno, Const char *object, double p1, double p2, int datasel);
+    void select(char *object, int datasel, double p1=0.0, double p2=0.0) {
+      uvselect_c(self->fd, object, p1, p2, datasel);
+    }
+
+    // TODO Needs static nread (maintained by uvread)
+#if 0
+    // void uvinfo_c   (int tno, Const char *object, double *data);
+    void info(char *object, double *data) {
+      uvinfo_c(self->fd, object, data);
+    }
+#endif
+
+    // void uvflgwr_c  (int tno, Const int *flags);
+    void flagwr(int *flags) {
+      uvflgwr_c(self->fd, flags);
+    }
+
+    // void uvwflgwr_c (int tno, Const int *flags);
+    void wflagwr(int *flags) {
+      uvwflgwr_c(self->fd, flags);
+    }
+
+/* hio.c */
+
+#if 0
+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);
+#endif
+
+  //void haccess_c(int tno, int *ihandle, Const char *keyword, Const char *status, int *iostat);
+  int haccess(char *keyword, char *status) {
+    int ihandle;
+    int iostat;
+
+    if(keyword == NULL) {
+      SWIG_exception(SWIG_NullReferenceError,"invalid item name");
+    }
+    if(status == NULL) {
+      SWIG_exception(SWIG_NullReferenceError,"invalid status");
+    }
+    switch(status[0]) {
+      case 'r': status = "read";
+                break;
+      case 'w': status = "write";
+                break;
+      case 'a': status = "append";
+                break;
+      case 's': status = "scratch";
+                break;
+      default: SWIG_exception(SWIG_ValueError,"invalid status");
+                break;
+    }
+
+    haccess_c(self->fd,&ihandle,keyword,status,&iostat);
+
+    if(iostat != 0) {
+      SWIG_exception(SWIG_IOError, "error opening item");
+    }
+    return ihandle;
+  }
+
+#if 0
+void hmode_c(int tno, char *mode);
+int  hexists_c(int tno, Const char *keyword);
+#endif
+
+  //void hdaccess_c(int ihandle, int *iostat);
+  void hdaccess(int ihandle) {
+    int iostat;
+    hdaccess_c(ihandle,&iostat);
+    if(iostat != 0 && iostat != -1) {
+      SWIG_exception(SWIG_IOError, "error closing item");
+    }
+  }
+
+#if 0
+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);
+#endif
+
+  //void hreada_c(int ihandle, char *line, size_t length, int *iostat);
+  void hreadln(int ihandle, char *linein, size_t length, int *iostat) {
+    if(linein == NULL) {
+      SWIG_exception(
+          SWIG_NullReferenceError, "no buffer to receive line from item");
+    }
+    if(length < 1) {
+      SWIG_exception(
+          SWIG_ValueError, "invalid buffer length to receive line from item");
+    }
+
+    hreada_c(ihandle, linein, length, iostat);
+    linein[length-1] = '\0';
+
+    if(*iostat != 0 && *iostat != -1) {
+      SWIG_exception(SWIG_IOError, "error reading item");
+    }
+  }
+
+  //void hwritea_c(int ihandle, Const char *line, size_t length, int *iostat);
+  void hwriteln(int ihandle, char *lineout, size_t length) {
+    int iostat;
+    if(lineout == NULL) {
+      SWIG_exception(
+          SWIG_NullReferenceError, "no line to write to item");
+    }
+    if(length < 1) {
+      SWIG_exception(
+          SWIG_ValueError, "invalid line length to write to item");
+    }
+
+    hwritea_c(ihandle, lineout, length, &iostat);
+
+    if(iostat != 0 && iostat != -1) {
+      SWIG_exception(SWIG_IOError, "error writing item");
+    }
+  }
+
+/* headio.c */
+
+#if 0 // TODO TODO TODO
+void hisopen_c  (int tno, Const char *status);
+#endif // 0
+
+    //void hiswrite_c (int tno, Const char *text);
+    void hiswrite(char *text) {
+      hiswrite_c(self->fd, text);
+    }
+
+#if 0 // TODO TODO TODO
+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);
+#endif // 0
+
+    //void wrhda_c (int tno, Const char *keyword, Const char *value);
+    void wrhda(char *keyword, char *value) {
+      wrhda_c (self->fd, keyword, value);
+    }
+
+#if 0 // TODO TODO TODO
+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);
+#endif // 0
+
+};
+
+/* vim: set expandtab ts=2 sw=2 smarttab syntax=c cindent fo+=tcroq : */