callable_postmini_cbind.c

this file is contain important facts aboute different programming langueges.

/*
      Copyright (c) 1999,2000, Compaq Computer Corporation

      See the file "license.terms" for information on usage and redistribution
      of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 */
/*
 *
 *   C interface to callable Postmini
 *
 */

#if !(defined(vms) || defined(__vms))
/* Most Unix FORTRAN's append an underscore to external names */
#define pmplxy pmplxy_
#define pmplot pmplot_
#define pmcomp pmcomp_
#define pmclxy pmclxy_
#define pmadxy pmadxy_
#define pmlab  pmlab_
#define pmdef  pmdef_
#define pmtitl pmtitl_
#define pmcltl pmcltl_
#define pmcllb pmcllb_
#define pmclos pmclos_
#define pmcont pmcont_
#endif

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#if defined(vms) || defined(__vms)
#include <descrip.h>
/* VMS FORTRAN RTL barks if you pass it a character string that is 256
   characters long... */
#define PM_MAXPATHLEN (FILENAME_MAX - 1)
#else
#define PM_MAXPATHLEN FILENAME_MAX
#endif

#include "callable_postmini_cbind.h"

extern void pmplxy(), pmplot(), pmclxy(), pmadxy(), pmlab(),
            pmdef(), pmtitl(), pmcltl(), pmcllb(), pmclos();

static char   *buffer = NULL;
static char   pmfile_buffer[PM_MAXPATHLEN];

#define MAX(a,b)  (a)>(b) ? (a) : (b)
#define MIN(a,b)  (a)<(b) ? (a) : (b)

char *PmPlotXY(float *float_data, int  *int_data,
               int   *log_data,   char *char_data[],
               int nfloat, int nint, int nlog, int nchar,
               char *title, char *hcfile, int ilu, int linter, char *pmfile)
{

   int ilen, istr, i;

#if defined(vms) || defined(__vms)
   struct dsc$descriptor hcfile_dsc, pmfile_dsc, title_dsc;
   struct dsc$descriptor_a array_dsc;
#else
   int ilen1, ilen2, ilen3;
#endif

   /* Copy string data (if any) to fixed length, blank filled, strings
      for FORTRAN */
   /* As a firewall against nchar>0, but empty input strings,
      set minimum length to 1 */
   ilen = 1;
   for(i=0; i<nchar; i++) {
      ilen=MAX(ilen,strlen(char_data[i]));
   }

   if( nchar > 0 ) {
      if( (buffer = malloc(ilen*nchar)) == NULL ) {
         perror("PmaddXY");
         return;
      }
      /* Set temporary buffer to all blanks, then store string information */
      memset(buffer,' ',ilen*nchar);
      for(i=0; i<nchar; i++) {
         istr=strlen(char_data[i]);
         memcpy(&buffer[i*ilen],char_data[i],MIN(ilen,istr));
      }
   }

#if defined(vms) || defined(__vms)
   PmInitStringArrayDescriptor(&array_dsc);
   PmSetStringArrayDescriptor(&array_dsc,buffer,nchar,ilen);
   PmInitStringDescriptor(&title_dsc);
   PmSetStringDescriptorConst(&title_dsc,title);
   PmInitStringDescriptor(&hcfile_dsc);
   PmSetStringDescriptorConst(&hcfile_dsc,hcfile);
   PmInitStringDescriptor(&pmfile_dsc);
   PmSetStringDescriptorVar(&pmfile_dsc,pmfile_buffer,pmfile,PM_MAXPATHLEN);
   pmplxy(float_data, int_data, log_data, &array_dsc,
          &nfloat, &nint, &nlog, &nchar,
          &title_dsc, &hcfile_dsc, &ilu, &linter, &pmfile_dsc);
#else
   ilen1 = ilen;
   ilen2 = strlen(title);
   ilen3 = strlen(hcfile);
   memset(pmfile_buffer,' ',PM_MAXPATHLEN);
   memcpy(pmfile_buffer,pmfile,MIN(strlen(pmfile),PM_MAXPATHLEN));
   pmplxy(float_data, int_data, log_data, buffer,
          &nfloat, &nint, &nlog, &nchar,
           title, hcfile, &ilu, &linter, pmfile_buffer,
           ilen1, ilen2, ilen3, PM_MAXPATHLEN);
#endif

   /* Null terminate string, remember, array is zero based */
   for(i=PM_MAXPATHLEN-2; i>0; i-- ) {
      if( pmfile_buffer[i] != ' ' ) {
         pmfile_buffer[i+1] = '\0';
         break;
      }
   }
   return(pmfile_buffer);
}

char  *PmMainMenu(float *float_data, int  *int_data,
                 int   *log_data,   char *char_data[],
                 int nfloat, int nint, int nlog, int nchar,
                 char *title, char *hcfile, int ilu, int linter, char *pmfile)
{
   printf("This jacket routine is not implemented yet!\n");
   return NULL;
}

void PmClearXY(void)
{
   pmclxy();
}
 
int  PmAddXY(float *x, float *y, int nd,
               float *float_data, int *int_data,
               int   *log_data,   char *char_data[],
               int   nfloat, int nint, int nlog, int nchar,
               int *icode1, int *icode2)
{

   int ilen, istr, i, ierr;
#if defined(vms) || defined(__vms)
   struct dsc$descriptor_a array_dsc;
#endif

   /* Copy string data (if any) to fixed length, blank filled, strings
      for FORTRAN */
   /* As a firewall against nchar>0, but empty input strings,
      set minimum length to 1 */
   ilen = 1;
   for(i=0; i<nchar; i++) {
      ilen=MAX(ilen,strlen(char_data[i]));
   }

   if( nchar > 0 ) {
      if( (buffer = malloc(ilen*nchar)) == NULL ) {
         perror("PmAddXY");
         return(PM_FAILURE);
      }
      /* Set temporary buffer to all blanks, then store string information */
      memset(buffer,' ',ilen*nchar);
      for(i=0; i<nchar; i++) {
         istr=strlen(char_data[i]);
         memcpy(&buffer[i*ilen],char_data[i],MIN(ilen,istr));
      }
   }

#if defined(vms) || defined(__vms)
   PmInitStringArrayDescriptor(&array_dsc);
   PmSetStringArrayDescriptor(&array_dsc,buffer,nchar,ilen);
   pmadxy(x, y, &nd, float_data, int_data, log_data, &array_dsc,
                     &nfloat,    &nint,    &nlog,    &nchar,
                     &ierr,      icode1,  icode2);
#else

   pmadxy(x, y, &nd, float_data, int_data, log_data,  buffer,
                     &nfloat,    &nint,    &nlog,    &nchar,
                     &ierr,       icode1,   icode2,   ilen);
#endif

   if( buffer != NULL ) {
      free(buffer);
      buffer = NULL;
   }
   return(ierr);
}

int PmSetDefault(int    icode,
                 float *float_data,
                 int   *int_data,
                 int   *logical_data,
                 char  *string)
{

   int rc,ilen;

#if defined(vms) || defined(__vms)
   struct dsc$descriptor dsc;
   PmInitStringDescriptor(&dsc);
   PmSetStringDescriptorConst(&dsc, string);
   pmdef(&icode,float_data,int_data,logical_data,&dsc,&rc);
#else
   ilen = strlen(string);
   pmdef(&icode,float_data,int_data,logical_data,string,&rc,ilen);
#endif

   return(rc);
}

int PmSetTitle(char *title)
{

   int rc, ilen;

#if defined(vms) || defined(__vms)
   struct dsc$descriptor dsc;

   PmInitStringDescriptor(&dsc);
   PmSetStringDescriptorConst(&dsc, title);
   pmtitl(&dsc, &rc);
#else
   ilen = strlen(title);
   pmtitl(title, &rc, ilen);
#endif

   return rc;

}

void PmClearTitle()
{
   pmcltl();
}

int PmSetLabel(char *label)
{
   int rc;
   int ilen;

#if defined(vms) || defined(__vms)
   struct dsc$descriptor dsc;

   PmInitStringDescriptor(&dsc);
   PmSetStringDescriptorConst(&dsc, label);
   pmlab(&dsc, &rc);
#else
   ilen = strlen(label);
   pmlab(label, &rc, ilen);
#endif

   return(rc);
}

void PmClearLabel(void)
{
   pmcllb();
}

void PmClose(void)
{
   pmclos();
}

char *PmContour(float *data2d, float *posx, float *posy,
                int iposx, int iposy,
                char *title, char *quantity, char *units,
                int llinear, int ilu, int linter, char *pmfile)
{

   int ilen, istr, i;
   void pmcont();

#if defined(vms) || defined(__vms)
   struct dsc$descriptor title_dsc, quantity_dsc, units_dsc,
                         pmfile_dsc;
#else
   int ilen1, ilen2, ilen3;
#endif

#if defined(vms) || defined(__vms)
   PmInitStringDescriptor(&title_dsc);
   PmSetStringDescriptorConst(&title_dsc,title);
   PmInitStringDescriptor(&quantity_dsc);
   PmSetStringDescriptorConst(&quantity_dsc,quantity);
   PmInitStringDescriptor(&units_dsc);
   PmSetStringDescriptorConst(&units_dsc,units);
   PmInitStringDescriptor(&pmfile_dsc);
   PmSetStringDescriptorVar(&pmfile_dsc,pmfile_buffer,pmfile,PM_MAXPATHLEN);
   pmcont(data2d, posx, posy, &iposy, &iposx, &iposy, &iposx,
          &title_dsc, &quantity_dsc, &units_dsc,
          &llinear, &ilu, &linter, &pmfile_dsc);
#else
   ilen1 = strlen(title);
   ilen2 = strlen(quantity);
   ilen3 = strlen(units);
   memset(pmfile_buffer,' ',PM_MAXPATHLEN);
   memcpy(pmfile_buffer,pmfile,MIN(strlen(pmfile),PM_MAXPATHLEN));
   pmcont(data2d, posx, posy, &iposy, &iposx, &iposy, &iposx,
          title, quantity, units,
          &llinear, &ilu, &linter, pmfile_buffer,
          ilen1, ilen2, ilen3, PM_MAXPATHLEN);
#endif

   /* Null terminate string, remember, array is zero based */
   for(i=PM_MAXPATHLEN-2; i>0; i-- ) {
      if( pmfile_buffer[i] != ' ' ) {
         pmfile_buffer[i+1] = '\0';
         break;
      }
   }
   return(pmfile_buffer);

}


#if defined(vms) || defined(__vms)
void PmInitStringDescriptor(struct dsc$descriptor *string)
{
   string->dsc$w_length = 0;
   string->dsc$a_pointer = NULL;
   string->dsc$b_dtype = DSC$K_DTYPE_T;
   string->dsc$b_class = DSC$K_CLASS_S;
}

void PmSetStringDescriptorConst(struct dsc$descriptor *desc,
                                char                  *string)
{
      desc->dsc$a_pointer = string;
      desc->dsc$w_length  = strlen(string);
}

void PmSetStringDescriptorVar(struct dsc$descriptor *desc,
                              char                  *string,
                              char                  *init,
                              int                   len)
{
      int ilen;

      desc->dsc$a_pointer = string;
      desc->dsc$w_length  = len;

      memset(string,' ',len);
      ilen = strlen(init);
      memcpy(string,init,MIN(ilen,len));
}

void PmInitStringArrayDescriptor(struct dsc$descriptor_a *cchar)
{
      /* Initialize string array descriptor */
      cchar->dsc$w_length = 0;
      cchar->dsc$b_dtype  = DSC$K_DTYPE_T;
      cchar->dsc$b_class  = DSC$K_CLASS_A;
      cchar->dsc$a_pointer = NULL;
      cchar->dsc$b_scale   = 0;
      cchar->dsc$b_digits  = 0;
      cchar->dsc$b_aflags.dsc$v_fl_binscale  = 0;
      cchar->dsc$b_aflags.dsc$v_fl_redim   = 0;
      cchar->dsc$b_aflags.dsc$v_fl_column  = 0;
      cchar->dsc$b_aflags.dsc$v_fl_coeff   = 0;
      cchar->dsc$b_aflags.dsc$v_fl_bounds  = 0;
      cchar->dsc$b_dimct = 1;
      cchar->dsc$l_arsize = 0;
}

void PmSetStringArrayDescriptor(struct dsc$descriptor_a *cchar,
                                char                    *data,
                                int                      num,
                                int                      size)
{
      /* Define array of character strings, num entries of length size */
      cchar->dsc$w_length = size;
      cchar->dsc$a_pointer = data;
      cchar->dsc$l_arsize = num*size;
}
#endif