Open64: osprey/libf/pxf/pxfaintget.c Source File

00001 /*
00002 
00003   Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.
00004 
00005   This program is free software; you can redistribute it and/or modify it
00006   under the terms of version 2.1 of the GNU Lesser General Public License 
00007   as published by the Free Software Foundation.
00008 
00009   This program is distributed in the hope that it would be useful, but
00010   WITHOUT ANY WARRANTY; without even the implied warranty of
00011   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
00012 
00013   Further, this software is distributed without any warranty that it is
00014   free of the rightful claim of any third person regarding infringement 
00015   or the like.  Any license provided herein, whether implied or 
00016   otherwise, applies only to this software file.  Patent licenses, if
00017   any, provided herein do not apply to combinations of this program with 
00018   other software, or any other product whatsoever.  
00019 
00020   You should have received a copy of the GNU Lesser General Public 
00021   License along with this program; if not, write the Free Software 
00022   Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, 
00023   USA.
00024 
00025   Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
00026   Mountain View, CA 94043, or:
00027 
00028   http://www.sgi.com
00029 
00030   For further information regarding this notice, see:
00031 
00032   http://oss.sgi.com/projects/GenInfo/NoticeExplan
00033 
00034 */
00035 
00036 
00037 #pragma ident "@(#) libf/pxf/pxfaintget.c 92.2  06/29/99 11:36:06"
00038 
00039 /*
00040  *  PXFAINTGET -- Access an array of integers in the termios structure
00041  *  PXFAINTSET -- Access an array of integers in the termios structure
00042  *  PXFEINTGET -- Access an integer array element in the termios structure
00043  *  PXFEINTSET -- Access an integer array element in the termios structure
00044  *             (section 7.1.2.1 of Posix 1003.9-1992)
00045  *
00046  *  Synopsis:
00047  *
00048  *     SUBROUTINE PXFAINTGET(jtermios, compnam, iavalue, ialen, ierror)
00049  *     INTEGER jtermios, ialen, iavalue(ialen), ierror
00050  *     CHARACTER*(*) compnam
00051  *
00052  *     SUBROUTINE PXFAINTSET(jtermios, compnam, iavalue, ialen, ierror)
00053  *     INTEGER jtermios, ialen, iavalue(ialen), ierror
00054  *     CHARACTER*(*) compnam
00055  *
00056  *     SUBROUTINE PXFEINTGET(jtermios, compnam, ivalue, index, ierror)
00057  *     INTEGER jtermios, ivalue, index, ierror
00058  *     CHARACTER*(*) compnam
00059  *
00060  *     SUBROUTINE PXFEINTSET(jtermios, compnam, ivalue, index, ierror)
00061  *     INTEGER jtermios, ivalue, index, ierror
00062  *     CHARACTER*(*) compnam
00063  *
00064  *  Description:
00065  *
00066  *  PXFAINTGET accesses an array of integers in a structure.
00067  *  PXFAINTSET accesses an array of integers in a structure.
00068  *  PXFEINTGET accesses an integer array element within an array.
00069  *  PXFEINTSET accesses an integer array element within an array.
00070  *
00071  *  The arguments are:
00072  *
00073  *      jtermios -  default integer input variable containing an
00074  *                  input handle variable created with PXFSTRUCTCREATE.
00075  *      compnam  -  intput character variable or array element
00076  *                  containing the desired structure component name.
00077  *      index    -  default input integer variable specifying the
00078  *                  desired element in the array.
00079  *      ivalue   -  default integer variable containing the value of
00080  *                  the array element.  This is an input argument for
00081  *                  the SET entry points and an output argument for
00082  *                  the GET entry points.
00083  *      iavalue   - default integer array containing the values of
00084  *                  the array elements.  This is an input argument
00085  *                  for the SET entry points and an output argument
00086  *                  for the GET entry points.
00087  *      ialen    -  default input integer variable containing the
00088  *                  number of array elements to access.
00089  *      ierror   -  default integer output variable that contains zero
00090  *                  if the operation was successful or nonzero if the
00091  *                  operation was not successful.
00092  *
00093  *   PXFEINTGET, PXFEINTSET, PXFAINTGET, and PXFAINTSET may return
00094  *   one of the following error values:
00095  *
00096  *   EBADHANDLE If jhandle is invalid.
00097  *
00098  *   EINVAL     If index is out of range.
00099  *
00100  *   ENOMEM     If there is insufficient memory to create data
00101  *              structures needed by the routine.
00102  *
00103  *   ENONAM     If the component name is not defined for this
00104  *              structure.
00105  *
00106  *   EARRAYLEN  If the number of array elements to be returned
00107  *              exceeds ialen for the GET routines and only the
00108  *              first elements of iavalue have been set.  If the
00109  *              number of array elements to be set exceeds ialen for
00110  *              the SET routines and only the first elements of
00111  *              the structure array have been set.
00112  *              
00113  */
00114 
00115 #include <errno.h>
00116 #include <fortran.h>
00117 #include <liberrno.h>
00118 #include <malloc.h>
00119 #include <string.h>
00120 #include <sys/errno.h>
00121 #include <sys/types.h>
00122 #include <sys/termios.h>
00123 #include "pxfstruct.h"
00124 #include "table.h"
00125 
00126 /*
00127  * if index is < zero or > NCCS, (i.e., c_cc[NCCS]), return EINVAL.
00128  */
00129 #define GETIFMATCHE(_A_,_B_,_C_) if (strcmp(_A_,#_C_) == 0) {\
00130   if(cindex >= 0 && cindex < arrlen) {\
00131     *ivalue = ((struct _B_ *)(pxfhand.pxfstructptr))->_C_[cindex];\
00132   } else {\
00133     errsts = EINVAL;\
00134   }\
00135 }
00136 
00137 #define SETIFMATCHE(_A_,_B_,_C_) if (strcmp(_A_,#_C_) == 0) {\
00138   if(cindex >= 0 && cindex < arrlen) {\
00139     ((struct _B_ *)(pxfhand.pxfstructptr))->_C_[cindex] = *ivalue;\
00140   } else {\
00141     errsts = EINVAL;\
00142   }\
00143 }
00144 
00145 /*
00146  * if length in argument ialen does not match NCCS from c_cc[NCCS],
00147  * return error EARRAYLEN and:
00148  * 1. if ialen is less than zero, do not move anything.
00149  * 2. if ialen is greater than NCCS, move only NCCS elements.
00150  * 3. if ialen is less than NCCS, move only ialen elements.
00151  */
00152 #define GETIFMATCHA(_A_,_B_,_C_) if (strcmp(_A_,#_C_) == 0) {\
00153   if(elemnum < 0 ) {\
00154     errsts = EARRAYLEN;\
00155   } else {\
00156     if(elemnum > arrlen) {\
00157       errsts = EARRAYLEN;\
00158       elemnum = NCCS;\
00159     } else {\
00160       if(elemnum < arrlen) {\
00161         errsts = EARRAYLEN;\
00162       }\
00163     }\
00164     for(i=0; i <= elemnum; i++) {\
00165       iavalue[i] = ((struct _B_ *)(pxfhand.pxfstructptr))->_C_[i];\
00166     } \
00167   } \
00168 }
00169 
00170 #define SETIFMATCHA(_A_,_B_,_C_) if (strcmp(_A_,#_C_) == 0) {\
00171   if(elemnum < 0 ) {\
00172     errsts = EARRAYLEN;\
00173   } else {\
00174     if(elemnum > arrlen) {\
00175       errsts = EARRAYLEN;\
00176       elemnum = NCCS;\
00177     } else {\
00178       if(elemnum < arrlen) {\
00179         errsts = EARRAYLEN;\
00180       }\
00181     }\
00182     for(i=0; i <= elemnum; i++) {\
00183       ((struct _B_ *)(pxfhand.pxfstructptr))->_C_[i] = iavalue[i]; \
00184     } \
00185   } \
00186 }
00187 
00188 extern char *_fc_acopy(_fcd f);
00189 
00190 #ifdef _UNICOS
00191 void
00192 PXFEINTGET(
00193 #else /* _UNICOS */
00194 void
00195 _PXFEINTGET(
00196 #endif  /* _UNICOS */
00197   _f_int  *jhandle,
00198   _fcd  compnam,
00199   _f_int  *ivalue,
00200   _f_int  *index,
00201   _f_int  *ierror)
00202 {
00203   char  *component;
00204   _f_int  cindex;
00205   int arrlen;
00206   int errsts;
00207   struct  pxfhandle pxfhand;
00208   cindex  = *index - 1;
00209   component = _fc_acopy(compnam);
00210   errsts  = 0;
00211   *ivalue = 0;
00212 
00213   /* verify component name is present. */
00214   if (component == NULL) {
00215     *ierror = ENOMEM;
00216     return;
00217   }
00218 
00219   pxfhand = _pxfhandle_table_lookup(&_pxfhandle_table, *jhandle);
00220   /* verify jhandle is present. */
00221   if (pxfhand.pxfstructptr == NULL)
00222     errsts  = EBADHANDLE;
00223   else {
00224     switch (pxfhand.pxftype) {
00225       case PXF_TERMIOS:
00226         arrlen  = NCCS;
00227         GETIFMATCHE(component,termios,c_cc)
00228         else {
00229           errsts  = ENONAME;
00230         }
00231         break;
00232       default:
00233         errsts  = ENONAME;
00234         break;
00235     }
00236   }
00237   free(component);
00238   *ierror = errsts;
00239   return;
00240 }
00241 
00242 #ifdef _UNICOS
00243 void
00244 PXFEINTSET(
00245 #else /* _UNICOS */
00246 void
00247 _PXFEINTSET(
00248 #endif  /* _UNICOS */
00249   _f_int  *jhandle,
00250   _fcd  compnam,
00251   _f_int  *ivalue,
00252   _f_int  *index,
00253   _f_int  *ierror)
00254 {
00255   char  *component;
00256   _f_int  cindex;
00257   int arrlen;
00258   int errsts;
00259   struct  pxfhandle pxfhand;
00260   cindex  = *index - 1;
00261   component = _fc_acopy(compnam);
00262   errsts  = 0;
00263 
00264   /* verify component name is present. */
00265   if (component == NULL) {
00266     *ierror = ENOMEM;
00267     return;
00268   }
00269 
00270   pxfhand = _pxfhandle_table_lookup(&_pxfhandle_table, *jhandle);
00271   /* verify jhandle is present. */
00272   if (pxfhand.pxfstructptr == NULL)
00273     errsts  = EBADHANDLE;
00274   else {
00275     switch (pxfhand.pxftype) {
00276       case PXF_TERMIOS:
00277         arrlen  = NCCS;
00278         SETIFMATCHE(component,termios,c_cc)
00279         else {
00280           errsts  = ENONAME;
00281         }
00282         break;
00283       default:
00284         errsts  = ENONAME;
00285         break;
00286     }
00287   }
00288   free(component);
00289   *ierror = errsts;
00290   return;
00291 }
00292 
00293 #ifdef _UNICOS
00294 void
00295 PXFAINTGET(
00296 #else /* _UNICOS */
00297 void
00298 _PXFAINTGET(
00299 #endif  /* _UNICOS */
00300   _f_int  *jhandle,
00301   _fcd  compnam,
00302   _f_int  *iavalue,
00303   _f_int  *ialen,
00304   _f_int  *ierror)
00305 {
00306   char  *component;
00307   _f_int  arrlen;
00308   _f_int  elemnum;
00309   _f_int  errsts;
00310   int i;
00311   struct  pxfhandle pxfhand;
00312   component = _fc_acopy(compnam);
00313   elemnum = *ialen;
00314   errsts  = 0;
00315 
00316   /* verify component name is present. */
00317   if (component == NULL) {
00318     *ierror = ENOMEM;
00319     return;
00320   }
00321 
00322   pxfhand = _pxfhandle_table_lookup(&_pxfhandle_table, *jhandle);
00323   /* verify jhandle is present. */
00324   if (pxfhand.pxfstructptr == NULL)
00325     errsts  = EBADHANDLE;
00326   else {
00327     switch (pxfhand.pxftype) {
00328       case PXF_TERMIOS:
00329         arrlen  = NCCS;
00330         GETIFMATCHA(component,termios,c_cc)
00331         else {
00332           errsts  = ENONAME;
00333         }
00334         break;
00335       default:
00336         errsts  = ENONAME;
00337         break;
00338     }
00339   }
00340   free(component);
00341   *ierror = errsts;
00342   return;
00343 }
00344 
00345 #ifdef _UNICOS
00346 void
00347 PXFAINTSET(
00348 #else /* _UNICOS */
00349 void
00350 _PXFAINTSET(
00351 #endif  /* _UNICOS */
00352   _f_int  *jhandle,
00353   _fcd  compnam,
00354   _f_int  *iavalue,
00355   _f_int  *ialen,
00356   _f_int  *ierror)
00357 {
00358   char  *component;
00359   _f_int  arrlen;
00360   _f_int  elemnum;
00361   _f_int  errsts;
00362   int i;
00363   struct  pxfhandle pxfhand;
00364   component = _fc_acopy(compnam);
00365   elemnum = *ialen;
00366   errsts  = 0;
00367 
00368   /* verify component name is present. */
00369   if (component == NULL) {
00370     *ierror = ENOMEM;
00371     return;
00372   }
00373 
00374   pxfhand = _pxfhandle_table_lookup(&_pxfhandle_table, *jhandle);
00375   /* verify jhandle is present. */
00376   if (pxfhand.pxfstructptr == NULL)
00377     errsts  = EBADHANDLE;
00378   else {
00379     switch (pxfhand.pxftype) {
00380       case PXF_TERMIOS:
00381         arrlen  = NCCS;
00382         SETIFMATCHA(component,termios,c_cc)
00383         else {
00384           errsts  = ENONAME;
00385         }
00386         break;
00387       default:
00388         errsts  = ENONAME;
00389         break;
00390     }
00391   }
00392   free(component);
00393   *ierror = errsts;
00394   return;
00395 }
00396 
00397 #ifndef _UNICOS
00398 void
00399 pxfeintget_(
00400   _f_int  *jhandle,
00401   char  *compnam,
00402   _f_int  *ivalue,
00403   _f_int  *index,
00404   _f_int  *ierror,
00405   int lencompnam)
00406 {
00407   _PXFEINTGET(jhandle, _cptofcd(compnam, lencompnam),
00408     ivalue, index, ierror);
00409 }
00410 
00411 void
00412 pxfeintset_(
00413   _f_int  *jhandle,
00414   char  *compnam,
00415   _f_int  *ivalue,
00416   _f_int  *index,
00417   _f_int  *ierror,
00418   int lencompnam)
00419 {
00420   _PXFEINTGET(jhandle, _cptofcd(compnam, lencompnam),
00421     ivalue, index, ierror);
00422 }
00423 
00424 void
00425 pxfaintget_(
00426   _f_int  *jhandle,
00427   char  *compnam,
00428   _f_int  *iavalue,
00429   _f_int  *ialen,
00430   _f_int  *ierror,
00431   int lencompnam)
00432 {
00433   _PXFAINTGET(jhandle, _cptofcd(compnam, lencompnam),
00434     iavalue, ialen, ierror);
00435 }
00436 
00437 void
00438 pxfaintset_(
00439   _f_int  *jhandle,
00440   char  *compnam,
00441   _f_int  *iavalue,
00442   _f_int  *ialen,
00443   _f_int  *ierror,
00444   int lencompnam)
00445 {
00446   _PXFAINTGET(jhandle, _cptofcd(compnam, lencompnam),
00447     iavalue, ialen, ierror);
00448 }
00449 
00450 #endif  /* end NOT _UNICOS */