• Main Page
  • Related Pages
  • Modules
  • Namespaces
  • Data Structures
  • Files
  • File List
  • Globals

contrib/maloc/src/vsys/viofb.c

00001 /*
00002  * ***************************************************************************
00003  * MALOC = < Minimal Abstraction Layer for Object-oriented C >
00004  * Copyright (C) 1994--2008 Michael Holst
00005  *
00006  * This library is free software; you can redistribute it and/or
00007  * modify it under the terms of the GNU Lesser General Public
00008  * License as published by the Free Software Foundation; either
00009  * version 2.1 of the License, or (at your option) any later version.
00010  *
00011  * This library is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00014  * Lesser General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU Lesser General Public
00017  * License along with this library; if not, write to the Free Software
00018  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
00019  *
00020  * rcsid="$Id: viofb.c,v 1.18 2008/03/12 05:13:59 fetk Exp $"
00021  * ***************************************************************************
00022  */
00023 
00024 /*
00025  * ***************************************************************************
00026  * File:     viofb.c
00027  *
00028  * Purpose:  FORTRAN bindings for the Vio class methods.
00029  *
00030  * Notes:    We provide FORTRAN stubs for the following manglings:
00031  *
00032  *               vrnd   --> no underscore,     lowercase (default)
00033  *               VRND   --> no underscore,     uppercase
00034  *               vrnd_  --> single underscore, lowercase
00035  *               VRND_  --> single underscore, uppercase
00036  *               vrnd__ --> double underscore, lowercase
00037  *               VRND__ --> double underscore, uppercase
00038  *
00039  * Author:   Michael Holst
00040  * ***************************************************************************
00041  */
00042 
00043 #include "vio_p.h"
00044 
00045 VEMBED(rcsid="$Id: viofb.c,v 1.18 2008/03/12 05:13:59 fetk Exp $")
00046 
00047 #define MAXVIO 10
00048 VPRIVATE Vio theVio[MAXVIO];
00049 VPRIVATE int stack[MAXVIO];
00050 VPRIVATE int stackPtr = 0;
00051 
00052 /*
00053  * ***************************************************************************
00054  * Class Vio FORTRAN binding prototypes (default: no underscore, lowercase)
00055  * ***************************************************************************
00056  */
00057 
00058 VEXTERNC void viosta(void);
00059 VEXTERNC void viostp(void);
00060 
00061 VEXTERNC int vioctr(char type[4], char frmt[3], 
00062     char *host, int *lenh, char *file, int *lenf,
00063     char mode[1]);
00064 VEXTERNC int viodtr(int *socknum);
00065 VEXTERNC int vioutl(int *socknum, char mode[1]);
00066 
00067 VEXTERNC void vioint(int *socknum, int *ival, int *len);
00068 VEXTERNC void vioflt(int *socknum, float *fval, int *len);
00069 VEXTERNC void viodbl(int *socknum, double *dval, int *len);
00070 VEXTERNC void viostr(int *socknum, char *sval, int *len);
00071 
00072 /*
00073  * ***************************************************************************
00074  * Class Vio FORTRAN bindings
00075  * ***************************************************************************
00076  */
00077 
00078 /*
00079  * ***************************************************************************
00080  * Routine:  viosta
00081  *
00082  * Purpose:  Start the Vio communication layer.
00083  *
00084  * Author:   Michael Holst
00085  * ***************************************************************************
00086  */
00087 VPUBLIC void viosta(void)
00088 {
00089     int i;
00090 
00091     for (i=0; i<MAXVIO; i++) {
00092         stack[i] = i+1;
00093     }
00094     stack[MAXVIO-1] = -1;
00095     stackPtr = 0;
00096 
00097     Vio_start();
00098 }
00099 
00100 /*
00101  * ***************************************************************************
00102  * Routine:  viostp
00103  *
00104  * Purpose:  Stop the Vio communication layer.
00105  *
00106  * Author:   Michael Holst
00107  * ***************************************************************************
00108  */
00109 VPUBLIC void viostp(void)
00110 {
00111     Vio_stop();
00112 }
00113 
00114 /*
00115  * ***************************************************************************
00116  * Routine:  vioctr
00117  *
00118  * Purpose:  Construct the Vio object.
00119  *
00120  * Author:   Michael Holst
00121  * ***************************************************************************
00122  */
00123 VPUBLIC int vioctr(char type[4], char frmt[3],
00124     char *host, int *lenh, char *file, int *lenf,
00125     char mode[1])
00126 {
00127     int i, socknum;
00128     char phost[VMAX_ARGLEN], pfile[VMAX_ARGLEN], ptype[VMAX_ARGLEN];
00129     char pfrmt[VMAX_ARGLEN], pmode[VMAX_ARGLEN];
00130     Vio *sock;
00131 
00132 #if 0
00133     Vio sockSize;
00134     fprintf(stderr,"vioctr: Vio structure size is exactly <%d> bytes.\n",
00135         sizeof(sockSize) );
00136 #endif
00137 
00138     for (i=0; i<4; i++) ptype[i] = type[i];
00139     ptype[4] = '\0';
00140     for (i=0; i<3; i++) pfrmt[i] = frmt[i];
00141     pfrmt[3] = '\0';
00142     for (i=0; i<*lenh; i++) phost[i] = host[i];
00143     phost[*lenh] = '\0';
00144     for (i=0; i<*lenf; i++) pfile[i] = file[i];
00145     pfile[*lenf] = '\0';
00146     pmode[0] = mode[0];
00147     pmode[1] = '\0';
00148 
00149     VASSERT( (0 <= stackPtr) && (stackPtr < MAXVIO) );
00150 
00151     socknum = stackPtr;
00152     stackPtr = stack[socknum];
00153     sock = &theVio[socknum];
00154     VJMPERR1(0 != Vio_ctor2(sock, ptype, pfrmt, phost, pfile, pmode));
00155 
00156     return socknum;
00157 
00158   VERROR1:
00159     return -1;
00160 }
00161 
00162 /*
00163  * ***************************************************************************
00164  * Routine:  viodtr
00165  *
00166  * Purpose:  Destruct the Vio object.
00167  *
00168  * Author:   Michael Holst
00169  * ***************************************************************************
00170  */
00171 VPUBLIC int viodtr(int *socknum)
00172 {
00173     Vio *sock = &theVio[*socknum];
00174 
00175     VASSERT( (0 <= *socknum) && (*socknum < MAXVIO) );
00176 
00177     Vio_dtor2(sock);
00178 
00179     stack[*socknum] = stackPtr;
00180     stackPtr = *socknum;
00181 
00182     return 0;
00183 }
00184 
00185 /*
00186  * ***************************************************************************
00187  * Routine:  vioutl
00188  *
00189  * Purpose:  Vio state utility.
00190  *
00191  * Author:   Michael Holst
00192  * ***************************************************************************
00193  */
00194 VPUBLIC int vioutl(int *socknum, char mode[1])
00195 {
00196     Vio *sock = &theVio[*socknum];
00197     char pmode[VMAX_ARGLEN];
00198 
00199     VASSERT( (0 <= *socknum) && (*socknum < MAXVIO) );
00200 
00201     pmode[0] = mode[0];
00202     pmode[1] = '\0';
00203 
00204     if ( !strcmp(pmode,"o") ) {
00205 
00206         if ( sock->rwkey == VIO_R ) {
00207             /* BLOCKING READ (blocking accept) */
00208             VJMPERR1( 0 <= Vio_accept(sock,0) );
00209         } else if ( sock->rwkey == VIO_W ) {
00210             /* BLOCKING WRITE (blocking connect) */
00211             VJMPERR1( 0 <= Vio_connect(sock,0) );
00212         } else { VJMPERR1(0); }
00213 
00214         return 0;
00215 
00216     } else if (!strcmp(pmode,"c")) {
00217 
00218         if ( sock->rwkey == VIO_R ) {
00219             Vio_acceptFree(sock);
00220         } else if ( sock->rwkey == VIO_W ) {
00221             Vio_connectFree(sock);
00222         } else { VJMPERR1(0); }
00223 
00224         return 0;
00225 
00226     } else { VJMPERR1(0); }
00227 
00228   VERROR1:
00229     return 1;
00230 }
00231 
00232 /*
00233  * ***************************************************************************
00234  * Routine:  vioint
00235  *
00236  * Purpose:  Integer READ/WRITE.
00237  *
00238  * Author:   Michael Holst
00239  * ***************************************************************************
00240  */
00241 VPUBLIC void vioint(int *socknum, int *ival, int *len)
00242 {
00243     Vio *sock = &theVio[*socknum];
00244     int i;
00245 
00246     VASSERT( (0 <= *socknum) && (*socknum < MAXVIO) );
00247 
00248     if ( sock->rwkey == VIO_R ) {
00249         for (i=0; i<*len; i++)
00250             Vio_scanf(sock,"%d",&(ival[i]));
00251     } else if ( sock->rwkey == VIO_W ) {
00252         for (i=0; i<*len; i++)
00253             Vio_printf(sock,"%d ",ival[i]);
00254         Vio_printf(sock,"\n");
00255     }
00256 }
00257 
00258 /*
00259  * ***************************************************************************
00260  * Routine:  vioflt
00261  *
00262  * Purpose:  Float READ/WRITE.
00263  *
00264  * Author:   Michael Holst
00265  * ***************************************************************************
00266  */
00267 VPUBLIC void vioflt(int *socknum, float *fval, int *len)
00268 {
00269     Vio *sock = &theVio[*socknum];
00270     int i;
00271 
00272     VASSERT( (0 <= *socknum) && (*socknum < MAXVIO) );
00273 
00274     if ( sock->rwkey == VIO_R ) {
00275         for (i=0; i<*len; i++)
00276             Vio_scanf(sock,"%e",&(fval[i]));
00277     } else if ( sock->rwkey == VIO_W ) {
00278         for (i=0; i<*len; i++)
00279             Vio_printf(sock,"%e ",fval[i]);
00280         Vio_printf(sock,"\n");
00281     }
00282 }
00283 
00284 /*
00285  * ***************************************************************************
00286  * Routine:  viodbl
00287  *
00288  * Purpose:  Double READ/WRITE.
00289  *
00290  * Author:   Michael Holst
00291  * ***************************************************************************
00292  */
00293 VPUBLIC void viodbl(int *socknum, double *dval, int *len)
00294 {
00295     Vio *sock = &theVio[*socknum];
00296     int i;
00297 
00298     VASSERT( (0 <= *socknum) && (*socknum < MAXVIO) );
00299 
00300     if ( sock->rwkey == VIO_R ) {
00301         for (i=0; i<*len; i++)
00302             Vio_scanf(sock,"%le",&(dval[i]));
00303     } else if ( sock->rwkey == VIO_W ) {
00304         for (i=0; i<*len; i++)
00305             Vio_printf(sock,"%le ",dval[i]);
00306         Vio_printf(sock,"\n");
00307     }
00308 }
00309 
00310 /*
00311  * ***************************************************************************
00312  * Routine:  viostr
00313  *
00314  * Purpose:  String READ/WRITE.
00315  *
00316  * Author:   Michael Holst
00317  * ***************************************************************************
00318  */
00319 VPUBLIC void viostr(int *socknum, char *sval, int *len)
00320 {
00321     Vio *sock = &theVio[*socknum];
00322     int i;
00323     char buf[VMAX_BUFSIZE];
00324 
00325     VASSERT( (0 <= *socknum) && (*socknum < MAXVIO) );
00326 
00327     if ( sock->rwkey == VIO_R ) {
00328         Vio_scanf(sock,"%s",buf);
00329         VASSERT( (int)strlen(buf) == *len );
00330         for (i=0; i<*len; i++) sval[i] = buf[i];
00331     } else if ( sock->rwkey == VIO_W ) {
00332         for (i=0; i<*len; i++) buf[i] = sval[i];
00333         buf[*len] = '\0';
00334         Vio_printf(sock,"%s\n",buf);
00335     }
00336 }
00337 
00338 /*
00339  * ***************************************************************************
00340  * Class Vio FORTRAN binding STUBS (no underscore, uppercase)
00341  * ***************************************************************************
00342  */
00343 
00344 VPUBLIC void VIOSTA(void)
00345 {
00346     viosta();
00347 }
00348 
00349 VPUBLIC void VIOSTP(void)
00350 {
00351     viostp();
00352 }
00353 
00354 VPUBLIC int VIOCTR(char type[4], char frmt[3], 
00355     char *host, int *lenh, char *file, int *lenf,
00356     char mode[1])
00357 {
00358     return vioctr(type, frmt, host, lenh, file, lenf, mode);
00359 }
00360 
00361 VPUBLIC int VIODTR(int *socknum)
00362 {
00363     return viodtr(socknum);
00364 }
00365 
00366 VPUBLIC int VIOUTL(int *socknum, char mode[1])
00367 {
00368     return vioutl(socknum, mode);
00369 }
00370 
00371 VPUBLIC void VIOINT(int *socknum, int *ival, int *len)
00372 {
00373     vioint(socknum, ival, len);
00374 }
00375 
00376 VPUBLIC void VIOFLT(int *socknum, float *fval, int *len)
00377 {
00378     vioflt(socknum, fval, len);
00379 }
00380 
00381 VPUBLIC void VIODBL(int *socknum, double *dval, int *len)
00382 {
00383     viodbl(socknum, dval, len);
00384 }
00385 
00386 VPUBLIC void VIOSTR(int *socknum, char *sval, int *len)
00387 {
00388     viostr(socknum, sval, len);
00389 }
00390 
00391 /*
00392  * ***************************************************************************
00393  * Class Vio FORTRAN binding STUBS (single underscore, lowercase)
00394  * ***************************************************************************
00395  */
00396 
00397 VPUBLIC void viosta_(void)
00398 {
00399     viosta();
00400 }
00401 
00402 VPUBLIC void viostp_(void)
00403 {
00404     viostp();
00405 }
00406 
00407 VPUBLIC int vioctr_(char type[4], char frmt[3], 
00408     char *host, int *lenh, char *file, int *lenf,
00409     char mode[1])
00410 {
00411     return vioctr(type, frmt, host, lenh, file, lenf, mode);
00412 }
00413 
00414 VPUBLIC int viodtr_(int *socknum)
00415 {
00416     return viodtr(socknum);
00417 }
00418 
00419 VPUBLIC int vioutl_(int *socknum, char mode[1])
00420 {
00421     return vioutl(socknum, mode);
00422 }
00423 
00424 VPUBLIC void vioint_(int *socknum, int *ival, int *len)
00425 {
00426     vioint(socknum, ival, len);
00427 }
00428 
00429 VPUBLIC void vioflt_(int *socknum, float *fval, int *len)
00430 {
00431     vioflt(socknum, fval, len);
00432 }
00433 
00434 VPUBLIC void viodbl_(int *socknum, double *dval, int *len)
00435 {
00436     viodbl(socknum, dval, len);
00437 }
00438 
00439 VPUBLIC void viostr_(int *socknum, char *sval, int *len)
00440 {
00441     viostr(socknum, sval, len);
00442 }
00443 
00444 /*
00445  * ***************************************************************************
00446  * Class Vio FORTRAN binding STUBS (double underscore, lowercase)
00447  * ***************************************************************************
00448  */
00449 
00450 VPUBLIC void viosta__(void)
00451 {
00452     viosta();
00453 }
00454 
00455 VPUBLIC void viostp__(void)
00456 {
00457     viostp();
00458 }
00459 
00460 VPUBLIC int vioctr__(char type[4], char frmt[3], 
00461     char *host, int *lenh, char *file, int *lenf,
00462     char mode[1])
00463 {
00464     return vioctr(type, frmt, host, lenh, file, lenf, mode);
00465 }
00466 
00467 VPUBLIC int viodtr__(int *socknum)
00468 {
00469     return viodtr(socknum);
00470 }
00471 
00472 VPUBLIC int vioutl__(int *socknum, char mode[1])
00473 {
00474     return vioutl(socknum, mode);
00475 }
00476 
00477 VPUBLIC void vioint__(int *socknum, int *ival, int *len)
00478 {
00479     vioint(socknum, ival, len);
00480 }
00481 
00482 VPUBLIC void vioflt__(int *socknum, float *fval, int *len)
00483 {
00484     vioflt(socknum, fval, len);
00485 }
00486 
00487 VPUBLIC void viodbl__(int *socknum, double *dval, int *len)
00488 {
00489     viodbl(socknum, dval, len);
00490 }
00491 
00492 VPUBLIC void viostr__(int *socknum, char *sval, int *len)
00493 {
00494     viostr(socknum, sval, len);
00495 }
00496 
00497 /*
00498  * ***************************************************************************
00499  * Class Vio FORTRAN binding STUBS (single underscore, uppercase)
00500  * ***************************************************************************
00501  */
00502 
00503 VPUBLIC void VIOSTA_(void)
00504 {
00505     viosta();
00506 }
00507 
00508 VPUBLIC void VIOSTP_(void)
00509 {
00510     viostp();
00511 }
00512 
00513 VPUBLIC int VIOCTR_(char type[4], char frmt[3], 
00514     char *host, int *lenh, char *file, int *lenf,
00515     char mode[1])
00516 {
00517     return vioctr(type, frmt, host, lenh, file, lenf, mode);
00518 }
00519 
00520 VPUBLIC int VIODTR_(int *socknum)
00521 {
00522     return viodtr(socknum);
00523 }
00524 
00525 VPUBLIC int VIOUTL_(int *socknum, char mode[1])
00526 {
00527     return vioutl(socknum, mode);
00528 }
00529 
00530 VPUBLIC void VIOINT_(int *socknum, int *ival, int *len)
00531 {
00532     vioint(socknum, ival, len);
00533 }
00534 
00535 VPUBLIC void VIOFLT_(int *socknum, float *fval, int *len)
00536 {
00537     vioflt(socknum, fval, len);
00538 }
00539 
00540 VPUBLIC void VIODBL_(int *socknum, double *dval, int *len)
00541 {
00542     viodbl(socknum, dval, len);
00543 }
00544 
00545 VPUBLIC void VIOSTR_(int *socknum, char *sval, int *len)
00546 {
00547     viostr(socknum, sval, len);
00548 }
00549 
00550 /*
00551  * ***************************************************************************
00552  * Class Vio FORTRAN binding STUBS (double underscore, uppercase)
00553  * ***************************************************************************
00554  */
00555 
00556 VPUBLIC void VIOSTA__(void)
00557 {
00558     viosta();
00559 }
00560 
00561 VPUBLIC void VIOSTP__(void)
00562 {
00563     viostp();
00564 }
00565 
00566 VPUBLIC int VIOCTR__(char type[4], char frmt[3], 
00567     char *host, int *lenh, char *file, int *lenf,
00568     char mode[1])
00569 {
00570     return vioctr(type, frmt, host, lenh, file, lenf, mode);
00571 }
00572 
00573 VPUBLIC int VIODTR__(int *socknum)
00574 {
00575     return viodtr(socknum);
00576 }
00577 
00578 VPUBLIC int VIOUTL__(int *socknum, char mode[1])
00579 {
00580     return vioutl(socknum, mode);
00581 }
00582 
00583 VPUBLIC void VIOINT__(int *socknum, int *ival, int *len)
00584 {
00585     vioint(socknum, ival, len);
00586 }
00587 
00588 VPUBLIC void VIOFLT__(int *socknum, float *fval, int *len)
00589 {
00590     vioflt(socknum, fval, len);
00591 }
00592 
00593 VPUBLIC void VIODBL__(int *socknum, double *dval, int *len)
00594 {
00595     viodbl(socknum, dval, len);
00596 }
00597 
00598 VPUBLIC void VIOSTR__(int *socknum, char *sval, int *len)
00599 {
00600     viostr(socknum, sval, len);
00601 }
00602 

Generated on Wed Oct 20 2010 11:12:15 for APBS by  doxygen 1.7.2