These is the beginning of a try to connect the pd to octave. Especially when using the iemmatrix features in pd, this feature becomes sensible. On the whole it shall enable the user to use the command line parser of octave.svn2git-root

The take-over strategy is bad at this starting point. No threading, no practical data transmission.
Perhaps the common work on it can help. (Franz)

svn path=/trunk/externals/iem/pdoctave/; revision=4611

1 files changed, 249 insertions, 0 deletions

diff --git a/pdoctave_dataframe.c b/pdoctave_dataframe.c
new file mode 100644
index 0000000..7193c62
--- /dev/null
+++ b/pdoctave_dataframe.c
@@ -0,0 +1,249 @@
+#include "pdoctave_dataframe.h"
+
+SharedDataFrame *newSharedDataFrame () 
+{
+   int id;
+   SharedDataFrame *sdf;
+
+   id = shmget (IPC_PRIVATE, sizeof(SharedDataFrame),
+	    SHM_R | SHM_W);
+
+   if (id == -1) return 0;
+
+   sdf = shmat (id, 0, 0);
+
+   if (sdf == (SharedDataFrame *) -1) {
+      shmctl (id, IPC_RMID, 0);
+      return 0;
+   }
+
+   sdf->frame_attached = 1;
+   sdf->data_attached = 0;
+   sdf->data_frame_id = id;
+   sdf->data_vec_id = -1;
+   sdf->block_for_write = 0;
+   sdf->block_for_read = 0;
+
+   return sdf;
+}
+
+
+SharedDataFrame *getSharedDataFrame (int id)
+{
+   SharedDataFrame *sdf;
+   
+   sdf = shmat (id, 0, 0);
+   
+   if (sdf == (SharedDataFrame *) -1)
+      return 0;
+   
+   sdf->frame_attached++;
+   
+   return sdf;
+}
+
+
+
+
+void freeSharedDataFrame (SharedDataFrame **sdf)
+{
+   SharedDataFrame *sdfp = *sdf;
+   if (sdfp) {
+      if (sdfp->frame_attached > 0)
+   	 sdfp->frame_attached--;
+      shmdt(sdfp);
+      *sdf = 0;
+   }
+}
+
+
+void removeSharedDataFrame (SharedDataFrame **sdf)
+{
+   int id;
+   SharedDataFrame *sdfp = *sdf;
+   if (sdfp) {
+      id = sdfp->data_frame_id;
+      if (sdfp->frame_attached > 0)
+	 shmdt (sdfp);
+      if (id != -1)
+	 shmctl(id, IPC_RMID, 0);
+      *sdf = 0;
+   }
+}
+      
+
+int getSharedDataFrameId (SharedDataFrame *sdf) 
+{
+   if (sdf)
+      return sdf->data_frame_id;
+   else
+      return -1;
+}
+
+
+
+DatTyp getSharedDataType (SharedDataFrame *sdf)
+{
+   if (sdf)
+      return sdf->data_typ;
+   else 
+      return UNKNOWN;
+}
+
+
+int getSharedDataVecLength (SharedDataFrame *sdf)
+{
+   if (sdf)
+      return sdf->data_vec_len;
+   else 
+      return 0;
+}
+
+
+void *newSharedData (SharedDataFrame *sdf, int n, int size_bytes, DatTyp dtyp)
+{
+   void *data;
+   int id;
+   
+   if (sdf) {
+
+      id = sdf->data_vec_id;
+      if (id == -1) 
+	 id = shmget(IPC_PRIVATE, n*size_bytes, SHM_R | SHM_W);
+
+      if (id == -1) return 0;
+
+      data = shmat(id,0,0);
+
+      if (data == (void *) -1) {
+	 shmctl (id, IPC_RMID, 0);
+	 return 0;
+      }
+      
+      sdf->data_attached = 1;
+      sdf->data_size_bytes = size_bytes;
+      sdf->data_vec_len = n;
+      sdf->data_vec_id = id;
+      sdf->data_typ = dtyp;
+
+      return data;
+   }
+   else return 0;
+}
+
+
+void *getSharedData (SharedDataFrame *sdf)
+{
+   void *data;
+   
+   if ((sdf)&&(sdf->data_vec_id != -1)) {
+      
+      data = shmat(sdf->data_vec_id,0,0);
+
+      if (data == (void *) -1) {
+	 return 0;
+      }
+
+      sdf->data_attached++;
+
+      return data;
+   }
+   else 
+      return 0;
+}
+
+
+void freeSharedData (SharedDataFrame *sdf, void **data)
+{
+   void *datap = *data;
+   if (datap) {
+      shmdt(datap);
+      *data = 0;
+      if ((sdf)&&(sdf->data_attached > 0))
+	 sdf->data_attached--;
+   }
+}
+
+
+void removeSharedData (SharedDataFrame *sdf, void **data)
+{
+   int id;
+   void *datap = *data;
+   if (datap) {
+      shmdt (datap);
+      *data = 0;
+      if (sdf) {
+	 if (sdf->data_attached > 0)
+	    sdf->data_attached--;
+	 if (sdf->data_vec_id != -1) {
+	    shmctl (sdf->data_vec_id, IPC_RMID, 0);
+	    sdf->data_vec_id = -1;
+	 }
+      }
+   }
+}
+
+void unBlockForReading (SharedDataFrame *sdf)
+{
+   if (sdf)
+      sdf->block_for_read = 0;
+}
+void unBlockForWriting (SharedDataFrame *sdf) 
+{
+   if (sdf)
+      sdf->block_for_write = 0;
+}
+void blockForReading (SharedDataFrame *sdf)
+{
+   if (sdf)
+      sdf->block_for_read = 1;
+}
+void blockForWriting (SharedDataFrame *sdf)
+{
+   if (sdf)
+      sdf->block_for_write = 1;
+}
+void sleepUntilReadUnBlocked (SharedDataFrame *sdf, int usleep_time)
+{
+   int timer = 0;
+   if (sdf) {
+      while ((sdf->block_for_read!=0)&&(timer < MAX_SLEEP_TIME)) {
+	 timer += usleep_time;
+	 usleep (usleep_time);
+      }
+   }
+}
+void sleepUntilReadBlocked (SharedDataFrame *sdf, int usleep_time)
+{
+   int timer = 0;
+   if (sdf) {
+      while ((sdf->block_for_read==0)&&(timer < MAX_SLEEP_TIME)) {
+	 timer +=usleep_time;
+	 usleep (usleep_time);
+      }
+	 
+   }
+}
+void sleepUntilWriteUnBlocked (SharedDataFrame *sdf, int usleep_time)
+{
+   int timer = 0;
+   if (sdf) {
+      while ((sdf->block_for_write!=0)&&(timer < MAX_SLEEP_TIME)) {
+	 timer +=usleep_time;
+	 usleep (usleep_time);
+      }
+	 
+   }
+}
+void sleepUntilWriteBlocked (SharedDataFrame *sdf, int usleep_time)
+{
+   int timer = 0;
+   if (sdf) {
+      while ((sdf->block_for_write==0)&&(timer < MAX_SLEEP_TIME)) {
+	 timer +=usleep_time;
+	 usleep (usleep_time);
+      }
+	 
+   }
+}
+