00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
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
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
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
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
00103
00104
00105
00106
00107
00108
00109 VPUBLIC void viostp(void)
00110 {
00111 Vio_stop();
00112 }
00113
00114
00115
00116
00117
00118
00119
00120
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
00165
00166
00167
00168
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
00188
00189
00190
00191
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
00208 VJMPERR1( 0 <= Vio_accept(sock,0) );
00209 } else if ( sock->rwkey == VIO_W ) {
00210
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
00235
00236
00237
00238
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
00261
00262
00263
00264
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
00287
00288
00289
00290
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
00313
00314
00315
00316
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
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
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
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
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
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