1 /*
2 * ***************************************************************************
3 * MALOC = < Minimal Abstraction Layer for Object-oriented C >
4 * Copyright (C) 1994-- Michael Holst
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 * rcsid="$Id: viofb.c,v 1.19 2010/08/12 05:40:31 fetk Exp $"
21 * ***************************************************************************
22 */
23
24 /*
25 * ***************************************************************************
26 * File: viofb.c
27 *
28 * Purpose: FORTRAN bindings for the Vio class methods.
29 *
30 * Notes: We provide FORTRAN stubs for the following manglings:
31 *
32 * vrnd --> no underscore, lowercase (default)
33 * VRND --> no underscore, uppercase
34 * vrnd_ --> single underscore, lowercase
35 * VRND_ --> single underscore, uppercase
36 * vrnd__ --> double underscore, lowercase
37 * VRND__ --> double underscore, uppercase
38 *
39 * Author: Michael Holst
40 * ***************************************************************************
41 */
42
43 #include "vio_p.h"
44
45 VEMBED(rcsid="$Id: viofb.c,v 1.19 2010/08/12 05:40:31 fetk Exp $")
46
47 #define MAXVIO 10
48 VPRIVATE Vio theVio[MAXVIO];
49 VPRIVATE int stack[MAXVIO];
50 VPRIVATE int stackPtr = 0;
51
52 /*
53 * ***************************************************************************
54 * Class Vio FORTRAN binding prototypes (default: no underscore, lowercase)
55 * ***************************************************************************
56 */
57
58 VEXTERNC void viosta(void);
59 VEXTERNC void viostp(void);
60
61 VEXTERNC int vioctr(char type[4], char frmt[3],
62 char *host, int *lenh, char *file, int *lenf,
63 char mode[1]);
64 VEXTERNC int viodtr(int *socknum);
65 VEXTERNC int vioutl(int *socknum, char mode[1]);
66
67 VEXTERNC void vioint(int *socknum, int *ival, int *len);
68 VEXTERNC void vioflt(int *socknum, float *fval, int *len);
69 VEXTERNC void viodbl(int *socknum, double *dval, int *len);
70 VEXTERNC void viostr(int *socknum, char *sval, int *len);
71
72 /*
73 * ***************************************************************************
74 * Class Vio FORTRAN bindings
75 * ***************************************************************************
76 */
77
78 /*
79 * ***************************************************************************
80 * Routine: viosta
81 *
82 * Purpose: Start the Vio communication layer.
83 *
84 * Author: Michael Holst
85 * ***************************************************************************
86 */
viosta(void)87 VPUBLIC void viosta(void)
88 {
89 int i;
90
91 for (i=0; i<MAXVIO; i++) {
92 stack[i] = i+1;
93 }
94 stack[MAXVIO-1] = -1;
95 stackPtr = 0;
96
97 Vio_start();
98 }
99
100 /*
101 * ***************************************************************************
102 * Routine: viostp
103 *
104 * Purpose: Stop the Vio communication layer.
105 *
106 * Author: Michael Holst
107 * ***************************************************************************
108 */
viostp(void)109 VPUBLIC void viostp(void)
110 {
111 Vio_stop();
112 }
113
114 /*
115 * ***************************************************************************
116 * Routine: vioctr
117 *
118 * Purpose: Construct the Vio object.
119 *
120 * Author: Michael Holst
121 * ***************************************************************************
122 */
vioctr(char type[4],char frmt[3],char * host,int * lenh,char * file,int * lenf,char mode[1])123 VPUBLIC int vioctr(char type[4], char frmt[3],
124 char *host, int *lenh, char *file, int *lenf,
125 char mode[1])
126 {
127 int i, socknum;
128 char phost[VMAX_ARGLEN], pfile[VMAX_ARGLEN], ptype[VMAX_ARGLEN];
129 char pfrmt[VMAX_ARGLEN], pmode[VMAX_ARGLEN];
130 Vio *sock;
131
132 #if 0
133 Vio sockSize;
134 fprintf(stderr,"vioctr: Vio structure size is exactly <%d> bytes.\n",
135 sizeof(sockSize) );
136 #endif
137
138 for (i=0; i<4; i++) ptype[i] = type[i];
139 ptype[4] = '\0';
140 for (i=0; i<3; i++) pfrmt[i] = frmt[i];
141 pfrmt[3] = '\0';
142 for (i=0; i<*lenh; i++) phost[i] = host[i];
143 phost[*lenh] = '\0';
144 for (i=0; i<*lenf; i++) pfile[i] = file[i];
145 pfile[*lenf] = '\0';
146 pmode[0] = mode[0];
147 pmode[1] = '\0';
148
149 VASSERT( (0 <= stackPtr) && (stackPtr < MAXVIO) );
150
151 socknum = stackPtr;
152 stackPtr = stack[socknum];
153 sock = &theVio[socknum];
154 VJMPERR1(0 != Vio_ctor2(sock, ptype, pfrmt, phost, pfile, pmode));
155
156 return socknum;
157
158 VERROR1:
159 return -1;
160 }
161
162 /*
163 * ***************************************************************************
164 * Routine: viodtr
165 *
166 * Purpose: Destruct the Vio object.
167 *
168 * Author: Michael Holst
169 * ***************************************************************************
170 */
viodtr(int * socknum)171 VPUBLIC int viodtr(int *socknum)
172 {
173 Vio *sock = &theVio[*socknum];
174
175 VASSERT( (0 <= *socknum) && (*socknum < MAXVIO) );
176
177 Vio_dtor2(sock);
178
179 stack[*socknum] = stackPtr;
180 stackPtr = *socknum;
181
182 return 0;
183 }
184
185 /*
186 * ***************************************************************************
187 * Routine: vioutl
188 *
189 * Purpose: Vio state utility.
190 *
191 * Author: Michael Holst
192 * ***************************************************************************
193 */
vioutl(int * socknum,char mode[1])194 VPUBLIC int vioutl(int *socknum, char mode[1])
195 {
196 Vio *sock = &theVio[*socknum];
197 char pmode[VMAX_ARGLEN];
198
199 VASSERT( (0 <= *socknum) && (*socknum < MAXVIO) );
200
201 pmode[0] = mode[0];
202 pmode[1] = '\0';
203
204 if ( !strcmp(pmode,"o") ) {
205
206 if ( sock->rwkey == VIO_R ) {
207 /* BLOCKING READ (blocking accept) */
208 VJMPERR1( 0 <= Vio_accept(sock,0) );
209 } else if ( sock->rwkey == VIO_W ) {
210 /* BLOCKING WRITE (blocking connect) */
211 VJMPERR1( 0 <= Vio_connect(sock,0) );
212 } else { VJMPERR1(0); }
213
214 return 0;
215
216 } else if (!strcmp(pmode,"c")) {
217
218 if ( sock->rwkey == VIO_R ) {
219 Vio_acceptFree(sock);
220 } else if ( sock->rwkey == VIO_W ) {
221 Vio_connectFree(sock);
222 } else { VJMPERR1(0); }
223
224 return 0;
225
226 } else { VJMPERR1(0); }
227
228 VERROR1:
229 return 1;
230 }
231
232 /*
233 * ***************************************************************************
234 * Routine: vioint
235 *
236 * Purpose: Integer READ/WRITE.
237 *
238 * Author: Michael Holst
239 * ***************************************************************************
240 */
vioint(int * socknum,int * ival,int * len)241 VPUBLIC void vioint(int *socknum, int *ival, int *len)
242 {
243 Vio *sock = &theVio[*socknum];
244 int i;
245
246 VASSERT( (0 <= *socknum) && (*socknum < MAXVIO) );
247
248 if ( sock->rwkey == VIO_R ) {
249 for (i=0; i<*len; i++)
250 Vio_scanf(sock,"%d",&(ival[i]));
251 } else if ( sock->rwkey == VIO_W ) {
252 for (i=0; i<*len; i++)
253 Vio_printf(sock,"%d ",ival[i]);
254 Vio_printf(sock,"\n");
255 }
256 }
257
258 /*
259 * ***************************************************************************
260 * Routine: vioflt
261 *
262 * Purpose: Float READ/WRITE.
263 *
264 * Author: Michael Holst
265 * ***************************************************************************
266 */
vioflt(int * socknum,float * fval,int * len)267 VPUBLIC void vioflt(int *socknum, float *fval, int *len)
268 {
269 Vio *sock = &theVio[*socknum];
270 int i;
271
272 VASSERT( (0 <= *socknum) && (*socknum < MAXVIO) );
273
274 if ( sock->rwkey == VIO_R ) {
275 for (i=0; i<*len; i++)
276 Vio_scanf(sock,"%e",&(fval[i]));
277 } else if ( sock->rwkey == VIO_W ) {
278 for (i=0; i<*len; i++)
279 Vio_printf(sock,"%e ",fval[i]);
280 Vio_printf(sock,"\n");
281 }
282 }
283
284 /*
285 * ***************************************************************************
286 * Routine: viodbl
287 *
288 * Purpose: Double READ/WRITE.
289 *
290 * Author: Michael Holst
291 * ***************************************************************************
292 */
viodbl(int * socknum,double * dval,int * len)293 VPUBLIC void viodbl(int *socknum, double *dval, int *len)
294 {
295 Vio *sock = &theVio[*socknum];
296 int i;
297
298 VASSERT( (0 <= *socknum) && (*socknum < MAXVIO) );
299
300 if ( sock->rwkey == VIO_R ) {
301 for (i=0; i<*len; i++)
302 Vio_scanf(sock,"%le",&(dval[i]));
303 } else if ( sock->rwkey == VIO_W ) {
304 for (i=0; i<*len; i++)
305 Vio_printf(sock,"%le ",dval[i]);
306 Vio_printf(sock,"\n");
307 }
308 }
309
310 /*
311 * ***************************************************************************
312 * Routine: viostr
313 *
314 * Purpose: String READ/WRITE.
315 *
316 * Author: Michael Holst
317 * ***************************************************************************
318 */
viostr(int * socknum,char * sval,int * len)319 VPUBLIC void viostr(int *socknum, char *sval, int *len)
320 {
321 Vio *sock = &theVio[*socknum];
322 int i;
323 char buf[VMAX_BUFSIZE];
324
325 VASSERT( (0 <= *socknum) && (*socknum < MAXVIO) );
326
327 if ( sock->rwkey == VIO_R ) {
328 Vio_scanf(sock,"%s",buf);
329 VASSERT( (int)strlen(buf) == *len );
330 for (i=0; i<*len; i++) sval[i] = buf[i];
331 } else if ( sock->rwkey == VIO_W ) {
332 for (i=0; i<*len; i++) buf[i] = sval[i];
333 buf[*len] = '\0';
334 Vio_printf(sock,"%s\n",buf);
335 }
336 }
337
338 /*
339 * ***************************************************************************
340 * Class Vio FORTRAN binding STUBS (no underscore, uppercase)
341 * ***************************************************************************
342 */
343
VIOSTA(void)344 VPUBLIC void VIOSTA(void)
345 {
346 viosta();
347 }
348
VIOSTP(void)349 VPUBLIC void VIOSTP(void)
350 {
351 viostp();
352 }
353
VIOCTR(char type[4],char frmt[3],char * host,int * lenh,char * file,int * lenf,char mode[1])354 VPUBLIC int VIOCTR(char type[4], char frmt[3],
355 char *host, int *lenh, char *file, int *lenf,
356 char mode[1])
357 {
358 return vioctr(type, frmt, host, lenh, file, lenf, mode);
359 }
360
VIODTR(int * socknum)361 VPUBLIC int VIODTR(int *socknum)
362 {
363 return viodtr(socknum);
364 }
365
VIOUTL(int * socknum,char mode[1])366 VPUBLIC int VIOUTL(int *socknum, char mode[1])
367 {
368 return vioutl(socknum, mode);
369 }
370
VIOINT(int * socknum,int * ival,int * len)371 VPUBLIC void VIOINT(int *socknum, int *ival, int *len)
372 {
373 vioint(socknum, ival, len);
374 }
375
VIOFLT(int * socknum,float * fval,int * len)376 VPUBLIC void VIOFLT(int *socknum, float *fval, int *len)
377 {
378 vioflt(socknum, fval, len);
379 }
380
VIODBL(int * socknum,double * dval,int * len)381 VPUBLIC void VIODBL(int *socknum, double *dval, int *len)
382 {
383 viodbl(socknum, dval, len);
384 }
385
VIOSTR(int * socknum,char * sval,int * len)386 VPUBLIC void VIOSTR(int *socknum, char *sval, int *len)
387 {
388 viostr(socknum, sval, len);
389 }
390
391 /*
392 * ***************************************************************************
393 * Class Vio FORTRAN binding STUBS (single underscore, lowercase)
394 * ***************************************************************************
395 */
396
viosta_(void)397 VPUBLIC void viosta_(void)
398 {
399 viosta();
400 }
401
viostp_(void)402 VPUBLIC void viostp_(void)
403 {
404 viostp();
405 }
406
vioctr_(char type[4],char frmt[3],char * host,int * lenh,char * file,int * lenf,char mode[1])407 VPUBLIC int vioctr_(char type[4], char frmt[3],
408 char *host, int *lenh, char *file, int *lenf,
409 char mode[1])
410 {
411 return vioctr(type, frmt, host, lenh, file, lenf, mode);
412 }
413
viodtr_(int * socknum)414 VPUBLIC int viodtr_(int *socknum)
415 {
416 return viodtr(socknum);
417 }
418
vioutl_(int * socknum,char mode[1])419 VPUBLIC int vioutl_(int *socknum, char mode[1])
420 {
421 return vioutl(socknum, mode);
422 }
423
vioint_(int * socknum,int * ival,int * len)424 VPUBLIC void vioint_(int *socknum, int *ival, int *len)
425 {
426 vioint(socknum, ival, len);
427 }
428
vioflt_(int * socknum,float * fval,int * len)429 VPUBLIC void vioflt_(int *socknum, float *fval, int *len)
430 {
431 vioflt(socknum, fval, len);
432 }
433
viodbl_(int * socknum,double * dval,int * len)434 VPUBLIC void viodbl_(int *socknum, double *dval, int *len)
435 {
436 viodbl(socknum, dval, len);
437 }
438
viostr_(int * socknum,char * sval,int * len)439 VPUBLIC void viostr_(int *socknum, char *sval, int *len)
440 {
441 viostr(socknum, sval, len);
442 }
443
444 /*
445 * ***************************************************************************
446 * Class Vio FORTRAN binding STUBS (double underscore, lowercase)
447 * ***************************************************************************
448 */
449
viosta__(void)450 VPUBLIC void viosta__(void)
451 {
452 viosta();
453 }
454
viostp__(void)455 VPUBLIC void viostp__(void)
456 {
457 viostp();
458 }
459
vioctr__(char type[4],char frmt[3],char * host,int * lenh,char * file,int * lenf,char mode[1])460 VPUBLIC int vioctr__(char type[4], char frmt[3],
461 char *host, int *lenh, char *file, int *lenf,
462 char mode[1])
463 {
464 return vioctr(type, frmt, host, lenh, file, lenf, mode);
465 }
466
viodtr__(int * socknum)467 VPUBLIC int viodtr__(int *socknum)
468 {
469 return viodtr(socknum);
470 }
471
vioutl__(int * socknum,char mode[1])472 VPUBLIC int vioutl__(int *socknum, char mode[1])
473 {
474 return vioutl(socknum, mode);
475 }
476
vioint__(int * socknum,int * ival,int * len)477 VPUBLIC void vioint__(int *socknum, int *ival, int *len)
478 {
479 vioint(socknum, ival, len);
480 }
481
vioflt__(int * socknum,float * fval,int * len)482 VPUBLIC void vioflt__(int *socknum, float *fval, int *len)
483 {
484 vioflt(socknum, fval, len);
485 }
486
viodbl__(int * socknum,double * dval,int * len)487 VPUBLIC void viodbl__(int *socknum, double *dval, int *len)
488 {
489 viodbl(socknum, dval, len);
490 }
491
viostr__(int * socknum,char * sval,int * len)492 VPUBLIC void viostr__(int *socknum, char *sval, int *len)
493 {
494 viostr(socknum, sval, len);
495 }
496
497 /*
498 * ***************************************************************************
499 * Class Vio FORTRAN binding STUBS (single underscore, uppercase)
500 * ***************************************************************************
501 */
502
VIOSTA_(void)503 VPUBLIC void VIOSTA_(void)
504 {
505 viosta();
506 }
507
VIOSTP_(void)508 VPUBLIC void VIOSTP_(void)
509 {
510 viostp();
511 }
512
VIOCTR_(char type[4],char frmt[3],char * host,int * lenh,char * file,int * lenf,char mode[1])513 VPUBLIC int VIOCTR_(char type[4], char frmt[3],
514 char *host, int *lenh, char *file, int *lenf,
515 char mode[1])
516 {
517 return vioctr(type, frmt, host, lenh, file, lenf, mode);
518 }
519
VIODTR_(int * socknum)520 VPUBLIC int VIODTR_(int *socknum)
521 {
522 return viodtr(socknum);
523 }
524
VIOUTL_(int * socknum,char mode[1])525 VPUBLIC int VIOUTL_(int *socknum, char mode[1])
526 {
527 return vioutl(socknum, mode);
528 }
529
VIOINT_(int * socknum,int * ival,int * len)530 VPUBLIC void VIOINT_(int *socknum, int *ival, int *len)
531 {
532 vioint(socknum, ival, len);
533 }
534
VIOFLT_(int * socknum,float * fval,int * len)535 VPUBLIC void VIOFLT_(int *socknum, float *fval, int *len)
536 {
537 vioflt(socknum, fval, len);
538 }
539
VIODBL_(int * socknum,double * dval,int * len)540 VPUBLIC void VIODBL_(int *socknum, double *dval, int *len)
541 {
542 viodbl(socknum, dval, len);
543 }
544
VIOSTR_(int * socknum,char * sval,int * len)545 VPUBLIC void VIOSTR_(int *socknum, char *sval, int *len)
546 {
547 viostr(socknum, sval, len);
548 }
549
550 /*
551 * ***************************************************************************
552 * Class Vio FORTRAN binding STUBS (double underscore, uppercase)
553 * ***************************************************************************
554 */
555
VIOSTA__(void)556 VPUBLIC void VIOSTA__(void)
557 {
558 viosta();
559 }
560
VIOSTP__(void)561 VPUBLIC void VIOSTP__(void)
562 {
563 viostp();
564 }
565
VIOCTR__(char type[4],char frmt[3],char * host,int * lenh,char * file,int * lenf,char mode[1])566 VPUBLIC int VIOCTR__(char type[4], char frmt[3],
567 char *host, int *lenh, char *file, int *lenf,
568 char mode[1])
569 {
570 return vioctr(type, frmt, host, lenh, file, lenf, mode);
571 }
572
VIODTR__(int * socknum)573 VPUBLIC int VIODTR__(int *socknum)
574 {
575 return viodtr(socknum);
576 }
577
VIOUTL__(int * socknum,char mode[1])578 VPUBLIC int VIOUTL__(int *socknum, char mode[1])
579 {
580 return vioutl(socknum, mode);
581 }
582
VIOINT__(int * socknum,int * ival,int * len)583 VPUBLIC void VIOINT__(int *socknum, int *ival, int *len)
584 {
585 vioint(socknum, ival, len);
586 }
587
VIOFLT__(int * socknum,float * fval,int * len)588 VPUBLIC void VIOFLT__(int *socknum, float *fval, int *len)
589 {
590 vioflt(socknum, fval, len);
591 }
592
VIODBL__(int * socknum,double * dval,int * len)593 VPUBLIC void VIODBL__(int *socknum, double *dval, int *len)
594 {
595 viodbl(socknum, dval, len);
596 }
597
VIOSTR__(int * socknum,char * sval,int * len)598 VPUBLIC void VIOSTR__(int *socknum, char *sval, int *len)
599 {
600 viostr(socknum, sval, len);
601 }
602
603