1: #include <sys/types.h>
   2: #include <sys/time.h>
   3: #include <sys/mtio.h>
   4: #include <sys/ioctl.h>
   5: #include <sys/file.h>
   6: #include <sys/stat.h>
   7: #include <a.out.h>
   8: #include <stdio.h>
   9: #include <ctype.h>
  10: 
  11: char *malloc();
  12: int wflag;
  13: int xflag;
  14: int tflag;
  15: int cflag;
  16: int vflag;
  17: int dflag;
  18: int totalreadfiles = 0 ;
  19: int totalreadblocks = 0 ;
  20: int totalreadlines = 0 ;
  21: int totalreadchars = 0 ;
  22: int totalwritefiles = 0 ;
  23: int totalwriteblocks = 0 ;
  24: int totalwritelines = 0 ;
  25: int totalwritechars = 0 ;
  26: 
  27: main(argc,argv)
  28:     int argc;
  29:     char *argv[];
  30: {
  31:     struct tm *tm;
  32:     long timetemp;
  33:     int year;
  34:     int day;
  35:     char *tapename;
  36:     char *filename;
  37:     char *namelist=NULL;
  38:     char *device = "/dev/rmt12";
  39:     int tape;
  40:     int file;
  41:     int filenum;
  42:     int argnum;
  43:     char line[1001];
  44:     char vmsname[1000];
  45:     char unixname[1000];
  46:     FILE *names;
  47:     int count;
  48:     int tmp;
  49:     char blockchar;
  50:     int blocksize=2048;
  51: 
  52:     char *key;
  53: 
  54:     timetemp = time(0);
  55:     tm = localtime(&timetemp);
  56:     year = tm->tm_year;
  57:     day = tm->tm_yday;
  58:     tapename = malloc(10);
  59:     gethostname(tapename,6);
  60:     tapename[7]='\0';
  61: 
  62:     /* parse command line */
  63:     if (argc < 2)
  64:         usage();
  65: 
  66:     argv++;
  67:     argc--;
  68:     /* loop through first argument (key) */
  69:     argc--;
  70:     for (key = *argv++; *key; key++)
  71:         switch(*key) {
  72: 
  73:         case 'f':
  74:             if (*argv == NULL || argc <1) {
  75:                 fprintf(stderr,
  76:             "ansitape: 'f' option requires tape name \n");
  77:                 usage();
  78:             }
  79:             device = *argv++;
  80:             argc--;
  81:             break;
  82: 
  83:         case 'n':
  84:             if (*argv == NULL || argc <1) {
  85:                 fprintf(stderr,
  86:             "ansitape: 'n' option requires file name\n");
  87:                 usage();
  88:             }
  89:             namelist = *argv++;
  90:             argc--;
  91:             break;
  92: 
  93:         case 'l':
  94:             if (*argv == NULL || argc<1) {
  95:                 fprintf(stderr,
  96:             "ansitape: 'l' option requires label\n");
  97:                 usage();
  98:             }
  99:             tapename = *argv++;
 100:             argc--;
 101:             break;
 102: 
 103:         case 'b':
 104:             if (*argv == NULL) {
 105:                 fprintf(stderr,
 106:             "ansitape: 'b' option requires blocksize specifier \n");
 107:                 usage();
 108:             }
 109:             tmp = sscanf(*argv++," %d%c ",&blocksize,&blockchar);
 110:             argc--;
 111:             if(tmp<1) {
 112:                 fprintf(stderr,"illegal blocksize: blocksize set to 2048\n");
 113:                 blocksize=2048;
 114:             } else if(tmp>1) {
 115:                 if(blockchar == 'b') blocksize *= 512;
 116:                 if(blockchar == 'k') blocksize *= 1024;
 117:             }
 118:             if(blocksize <18) blocksize=18;
 119:             if(blocksize >62*1024) blocksize=62*1024;
 120:             break;
 121: 
 122:         case 'c':
 123:             cflag++;
 124:             wflag++;
 125:             break;
 126: 
 127:         case 'r':
 128:             /*I know, this should be rflag, but I just don't like r for write*/
 129:             wflag++;
 130:             break;
 131: 
 132:         case 'v':
 133:             vflag++;
 134:             break;
 135: 
 136:         case 'x':
 137:             xflag++;
 138:             break;
 139: 
 140:         case 't':
 141:             tflag++;
 142:             break;
 143: 
 144:         case '-':
 145:             break;
 146: 
 147:         default:
 148:             fprintf(stderr, "ansitape: %c: unknown option\n", *key);
 149:             usage();
 150:         }
 151: 
 152:     if (!wflag && !xflag && !tflag)
 153:         usage();
 154: 
 155:     tape = open(device,wflag?O_RDWR:O_RDONLY,NULL);
 156:     if(tape<0) {
 157:         perror(device);
 158:         printf(stderr,"tape not accessable - check if drive online and write ring present\n");
 159:         exit(1);
 160:     }
 161:     rewind(tape);
 162:     filenum=1;
 163:     casefix(tapename);
 164: 
 165:     if(cflag) {
 166:         writevol(tapename,tape);
 167:     } else {
 168:         getvol(tapename,tape);
 169:         while(1) {
 170:             /* read files */
 171:             if( readfile(tape,argc,argv) ) break;
 172:             filenum++;
 173:         }
 174:         backspace(tape);
 175:     }
 176: 
 177:     if(wflag) {
 178:         if(namelist) {
 179:             if(*namelist == '-') {
 180:                 names = stdin;
 181:             } else {
 182:                 names=fopen(namelist,"r");
 183:                 if(names == NULL) {
 184:                     fprintf(stderr,"unable to open namelist file - no files added to tape\n");
 185:                 }
 186:             }
 187:             while(1) {
 188:                 fgets(line,1000,names);
 189:                 if(feof(names)) break;
 190:                 count = sscanf(line,"%s %s",unixname,vmsname);
 191:                 if(count<1) continue; /* blank line */
 192:                 if(count==1) strcpy(vmsname,unixname);
 193:                 casefix(vmsname);
 194:                 if(filecheck(&file,unixname)) continue;
 195:                 writefile(tape,file,vmsname,tapename,filenum,year,day,blocksize);
 196:                 filenum++;
 197:                 close(file);
 198:             }
 199:         } else {
 200:             for(argnum=0;argnum<argc;argnum++) {
 201:                 filename = argv[argnum];
 202:                 if(filecheck(&file,filename)) continue;
 203:                 casefix(filename);
 204:                 writefile(tape,file,filename,tapename,filenum,year,day,blocksize);
 205:                 filenum++;
 206:                 close(file);
 207:             }
 208:         }
 209:         writetm(tape);
 210:         writetm(tape);
 211:         writetm(tape);
 212:         writetm(tape);
 213:     }
 214:     rewind(tape);
 215:     close(tape);
 216:     if(vflag && (tflag || xflag)) {
 217:         fprintf(stdout," read  %d files in %d blocks (%d lines, %d chars)\n",
 218:             totalreadfiles,totalreadblocks,totalreadlines,totalreadchars);
 219:     }
 220:     if(vflag && wflag) {
 221:         fprintf(stdout," wrote  %d files in %d blocks (%d lines, %d chars)\n",
 222:             totalwritefiles,totalwriteblocks,totalwritelines,totalwritechars);
 223:     }
 224: }
 225: usage() {
 226:     fprintf(stderr,
 227:             "ansitape: usage: ansitape -{rxtc}[flnvb] [filename] [label] [filename] [blocksize] [files]\n");
 228:     exit();
 229: }
 230: 
 231: writefile(tape,file,filename,tapename,filenum,year,day,blocksize)
 232:     int tape;
 233:     int file;
 234:     char *filename;
 235:     char *tapename;
 236:     int filenum;
 237:     int year;
 238:     int day;
 239:     int blocksize;
 240: 
 241: {
 242:     int blocks;
 243:     writehdr1(tape,filename,tapename,filenum,year,day);
 244:     writehdr2(tape,blocksize);
 245:     writehdr3(tape);
 246:     writetm(tape);
 247:     writedata(tape,file,filename,&blocks,blocksize);
 248:     writetm(tape);
 249:     writeeof1(tape,filename,tapename,filenum,year,day,blocks);
 250:     writeeof2(tape);
 251:     writeeof3(tape);
 252:     writetm(tape);
 253:     totalwritefiles++;
 254: }
 255: 
 256: writedata(tape,file,filename,blocks,blocksize)
 257:     int tape;
 258:     int file;
 259:     char *filename;
 260:     int *blocks;
 261:     int blocksize;
 262: {
 263: char *ibuf;
 264: char *ibufstart;
 265: char *obuf;
 266: char *obufstart;
 267: char sizebuf[5];
 268: char *endibuf;
 269: char *endobuf;
 270: int got;
 271: int i;
 272: char *j;
 273: int numchar = 0 ;
 274: int numline = 0 ;
 275: int numblock = 0;
 276: int success;
 277: 
 278:     ibufstart = ibuf = malloc(blocksize<4096?8200:(2*blocksize+10));
 279:     obufstart = obuf = malloc(blocksize+10);
 280:     endobuf = obuf + blocksize;
 281:     endibuf = ibuf;
 282: 
 283: 
 284:     i=0;
 285:     while(1) {
 286:         if(ibuf+i>=endibuf) {   /* end of input buffer */
 287:             strncpy(ibufstart,ibuf,endibuf-ibuf); /* copy leftover to start */
 288:             ibuf = ibufstart+(endibuf-ibuf);    /* point to end of valid data */
 289:             got = read(file,ibuf,blocksize<4096?4096:2*blocksize);  /* read in a chunk */
 290:             endibuf = ibuf + got;
 291:             ibuf = ibufstart;   /* point to beginning of data */
 292:             if(got == 0) { /* end of input */
 293:                 if(ibuf==ibufstart){ /* no leftovers */
 294:                     break; /* done */
 295:                 } else {
 296:                     ibuf[i]='\n'; /* fake extra newline */
 297:                 }
 298:             }
 299:         }
 300: 
 301:         if(obuf+i+4 > endobuf) {  /* end of output buffer */
 302:             if(i>blocksize-4) {
 303:                 printf("record exceeds blocksize - file truncated\n");
 304:                 break;
 305:             }
 306:             /* filled up output record - have to fill,output,restart*/
 307:             for(j=obuf;j<endobuf;j++) {
 308:                 *j = '^';
 309:             }
 310:             success = write(tape,obufstart,blocksize);
 311:             if(success != blocksize) {
 312:                 perror("tape");
 313:                 fprintf(stderr," hard write error:  write aborted\n");
 314:                 rewind(tape);
 315:                 exit(1);
 316:             }
 317:             obuf=obufstart;
 318:             numchar -= i;
 319:             i=0;
 320:             numblock++;
 321:             continue;
 322:         }
 323: 
 324:         if(ibuf[i] == '\n') { /* end of line */
 325:             /*sprintf(sizebuf,"%4.4d",i+4); /* make length string */
 326:             /*strncpy(obuf,sizebuf,4); /* put in length field */
 327:             obuf[0] = ((i+4)/1000) + '0';
 328:             obuf[1] = (((i+4)/100)%10) + '0';
 329:             obuf[2] = (((i+4)/10)%10) + '0';
 330:             obuf[3] = (((i+4)/1)%10) + '0';
 331:             obuf += (4+i); /* size + strlen */
 332:             ibuf += (1+i); /* newline + strlen */
 333:             i=0;
 334:             numline++;
 335:             continue; /* back to the top */
 336:         }
 337: 
 338:         obuf[i+4]=ibuf[i];
 339:         numchar++;
 340:         i++;
 341: 
 342:     }
 343:     /* exited - write last record and go for lunch */
 344:     if(obuf != obufstart) {
 345:         for(j=obuf;j<endobuf;j++) {
 346:             *j = '^';
 347:         }
 348:         success = write(tape,obufstart,blocksize);
 349:         if(success != blocksize) {
 350:             perror("tape");
 351:             fprintf(stderr," hard write error:  write aborted\n");
 352:             rewind(tape);
 353:             exit(1);
 354:         }
 355:         numblock++;
 356:     }
 357:     free(ibufstart);
 358:     free(obufstart);
 359:     if(vflag) {
 360:         fprintf(stdout,"r - %s:  %d lines (%d chars) in %d tape blocks\n",
 361:                 filename,numline,numchar,numblock);
 362:     }
 363:     totalwritechars += numchar;
 364:     totalwritelines += numline;
 365:     totalwriteblocks += numblock;
 366:     *blocks = numblock;
 367: }
 368: 
 369: writetm(tape)
 370:     int tape;
 371: {
 372:     struct mtop mtop;
 373:     mtop.mt_op = MTWEOF;
 374:     mtop.mt_count = 1;
 375:     ioctl(tape,MTIOCTOP,&mtop);
 376: }
 377: 
 378: rewind(tape)
 379:     int tape;
 380: {
 381:     struct mtop mtop;
 382:     mtop.mt_op = MTREW;
 383:     mtop.mt_count = 1;
 384:     ioctl(tape,MTIOCTOP,&mtop);
 385: }
 386: 
 387: skipfile(tape)
 388:     int tape;
 389: {
 390:     struct mtop mtop;
 391:     mtop.mt_op = MTFSF;
 392:     mtop.mt_count = 1;
 393:     ioctl(tape,MTIOCTOP,&mtop);
 394: }
 395: 
 396: backspace(tape)
 397:     int tape;
 398: {
 399:     struct mtop mtop;
 400:     mtop.mt_op = MTBSF;
 401:     mtop.mt_count = 1;
 402:     ioctl(tape,MTIOCTOP,&mtop);
 403: }
 404: 
 405: writehdr1(tape,filename,tapename,filenum,year,day)
 406:     int tape;
 407:     char *filename;
 408:     char *tapename;
 409:     int filenum;
 410:     int year;
 411:     int day;
 412: {
 413:     char buf[81];
 414:     sprintf(buf,
 415: "HDR1%-17.17s%-6.6s0001%4.4d000101 %2.2d%3.3d %2.2d%3.3d 000000DECFILE11A          "
 416:         ,filename,tapename,filenum,year,day,year,day);
 417:     write(tape,buf,80);
 418: }
 419: 
 420: writeeof1(tape,filename,tapename,filenum,year,day,blocks)
 421:     int tape;
 422:     char *filename;
 423:     char *tapename;
 424:     int filenum;
 425:     int year;
 426:     int day;
 427:     int blocks;
 428: {
 429:     char buf[81];
 430:     sprintf(buf,
 431: "EOF1%-17.17s%-6.6s0001%4.4d000101 %2.2d%3.3d %2.2d%3.3d %6.6dDECFILE11A          "
 432:         ,filename,tapename,filenum,year,day,year,day,blocks);
 433:     write(tape,buf,80);
 434: }
 435: 
 436: writehdr2(tape,blocksize)
 437:     int tape;
 438:     int blocksize;
 439: {
 440:     char buf[81];
 441:     sprintf(buf, "HDR2D%5.5d%5.5d%35.35s00%28.28s",blocksize,blocksize," "," ");
 442:     write(tape,buf,80);
 443: }
 444: 
 445: writeeof2(tape,blocksize)
 446:     int tape;
 447:     int blocksize;
 448: {
 449:     char buf[81];
 450:     sprintf(buf, "EOF2D%5.5d%5.5d%35.35s00%28.28s",blocksize,blocksize," "," ");
 451:     write(tape,buf,80);
 452: }
 453: 
 454: writehdr3(tape)
 455:     int tape;
 456: {
 457:     char buf[81];
 458:     sprintf(buf, "HDR3%76.76s"," ");
 459:     write(tape,buf,80);
 460: }
 461: 
 462: writeeof3(tape)
 463:     int tape;
 464: {
 465:     char buf[81];
 466:     sprintf(buf, "EOF3%76.76s"," ");
 467:     write(tape,buf,80);
 468: }
 469: 
 470: writevol(tapename,tape)
 471:     int tape;
 472:     char *tapename;
 473: {
 474:     char buf[81];
 475:     sprintf(buf,"VOL1%-6.6s %26.26sD%%C%10.10s1%28.28s3",tapename," "," "," ");
 476:     write(tape,buf,80);
 477:     if(vflag) {
 478:         fprintf(stdout," tape labeled %-6.6s\n",tapename);
 479:     }
 480: }
 481: 
 482: getvol(tapename,tape)
 483:     int tape;
 484:     char *tapename;
 485: {
 486:     char buf[81];
 487:     read(tape,buf,80);
 488:     sscanf(buf,"VOL1%6s",tapename);
 489:     if(vflag) {
 490:         fprintf(stdout," tape was labeled %-6.6s\n",tapename);
 491:     }
 492: }
 493: 
 494: casefix(string)
 495:     register char *string;
 496: {
 497:     while(*string) {
 498:         if(islower(*string)) {
 499:             *string = toupper(*string);
 500:         }
 501:         string++;
 502:     }
 503: }
 504: 
 505: #define getsize(a) ((a[0]-'0')*1000)+((a[1]-'0')*100)+((a[2]-'0')*10)+(a[3]-'0')
 506: int
 507: readfile(tape,argc,argv)
 508:     int tape;
 509:     int argc;
 510:     char *argv[];
 511: {
 512: char buf[80];
 513: char mode;
 514: char filename[18];
 515: FILE *file;
 516: int extract;
 517: char *ibuf;
 518: char *ibufstart;
 519: char *endibuf;
 520: int i;
 521: int size;
 522: int numblock = 0 ;
 523: int numchar = 0 ;
 524: int numline = 0 ;
 525: int argnum;
 526: int ok;
 527: int blocksize;
 528: int recordsize;
 529: int writeblock;
 530: 
 531:     if(!(read(tape,buf,80))) return(1); /* no hdr record, so second eof */
 532:     sscanf(buf,"HDR1%17s",filename);
 533:     read(tape,buf,80);
 534:     sscanf(buf,"HDR2%c%5d%5d",&mode,&blocksize,&recordsize);
 535:     blocksize = blocksize>recordsize?blocksize:recordsize;
 536:     skipfile(tape); /* throw away rest of header(s) - not interesting */
 537:     ibufstart=ibuf=malloc(blocksize+10);
 538:     endibuf=ibufstart+blocksize;
 539:     extract=0;
 540:     if(tflag || xflag) {
 541:         ok=0;
 542:         if(!argc) {
 543:             ok=1;
 544:         } else for(argnum=0;argnum<argc;argnum++) {
 545:             casefix(argv[argnum]);
 546:             if(!strcmp(filename,argv[argnum])) {
 547:                 ok=1;
 548:                 break;
 549:             }
 550:         }
 551:         if(mode == 'D') {
 552:             if(xflag && ok) {
 553:                 file = fopen(filename,"w");
 554:                 if(file == NULL) {
 555:                     perror(filename);
 556:                 } else {
 557:                     extract = 1;
 558:                 }
 559:             }
 560:             while(read(tape,ibufstart,blocksize)) {
 561:                 numblock++;
 562:                 ibuf = ibufstart;
 563:                 while(strncmp("^^^^",ibuf,4)) {
 564:                     size = getsize(ibuf);
 565:                     if(extract) {
 566:                         fwrite(ibuf+4,sizeof(char),size-4,file);
 567:                         fwrite("\n",1,1,file);
 568:                     }
 569:                     ibuf += (size);
 570:                     numline++;
 571:                     numchar += (size-4);
 572:                     if(ibuf > endibuf+1) {
 573:                         fprintf(stderr,"error:  bad tape records(s) - file may be corrupted\n");
 574:                         break;
 575:                     }
 576:                     if(ibuf>endibuf-4) break;
 577:                 }
 578:             }
 579:             if(extract) {
 580:                 fclose(file);
 581:             }
 582:         } else if (mode == 'F') {
 583:             if(xflag && ok) {
 584:                 file = fopen(filename,"w");
 585:                 if(file == NULL) {
 586:                     perror(filename);
 587:                 } else {
 588:                     extract = 1;
 589:                 }
 590:             }
 591:             while(read(tape,ibufstart,blocksize)) {
 592:                 numblock++;
 593:                 ibuf = ibufstart;
 594:                 while(ibuf+recordsize <= endibuf) {
 595:                     if(extract) {
 596:                         fwrite(ibuf,sizeof(char),recordsize,file);
 597:                         fwrite("\n",1,1,file);
 598:                     }
 599:                     ibuf += recordsize;
 600:                     numline++;
 601:                     numchar += recordsize;
 602:                 }
 603:             }
 604:             if(extract) {
 605:                 fclose(file);
 606:             }
 607:         } else {
 608:             fprintf(stderr,"unknown record mode (%c) - file %s skipped\n",
 609:                     mode,filename);
 610:             skipfile(tape); /* throw away actual file */
 611:         }
 612:     } else {
 613:         /* not interested in contents of file, so move fast */
 614:         skipfile(tape);
 615:     }
 616:     skipfile(tape); /* throw away eof stuff - not interesting */
 617:     totalreadchars += numchar;
 618:     totalreadlines += numline;
 619:     totalreadblocks += numblock;
 620:     totalreadfiles ++;
 621:     if(xflag && vflag && ok) {
 622:         fprintf(stdout,"x - %s:  %d lines (%d chars) in %d tape blocks\n",
 623:                 filename,numline,numchar,numblock);
 624:     } else if(tflag && ok) {
 625:         fprintf(stdout,"t - %s:  %d lines (%d chars) in %d tape blocks\n",
 626:                 filename,numline,numchar,numblock);
 627:     }
 628:     free(ibufstart);
 629:     return(0);
 630: }
 631: 
 632: filecheck(file,name)
 633:     int *file;
 634:     char *name;
 635: 
 636: {
 637: 
 638:     struct stat buf;
 639:     struct exec sample;
 640: 
 641:     stat(name,&buf);
 642:     if ((buf.st_mode & S_IFDIR)==S_IFDIR) {
 643:         fprintf(stderr,"%s: directory - skipped\n",name);
 644:         return(1);
 645:     }
 646:     if ((buf.st_mode & S_IFCHR)==S_IFCHR) {
 647:         fprintf(stderr,"%s: character device - skipped\n",name);
 648:         return(1);
 649:     }
 650:     if ((buf.st_mode & S_IFBLK)==S_IFBLK) {
 651:         fprintf(stderr,"%s: block device - skipped\n",name);
 652:         return(1);
 653:     }
 654:     if ((buf.st_mode & S_IFLNK)==S_IFLNK) {
 655:         fprintf(stderr,"%s: symbolic link - skipped\n",name);
 656:         return(1);
 657:     }
 658:     if ((buf.st_mode & S_IFSOCK)==S_IFSOCK) {
 659:         fprintf(stderr,"%s: socket - skipped\n",name);
 660:         return(1);
 661:     }
 662:     *file = open(name,O_RDONLY,NULL);
 663:     if(*file <0) {
 664:         perror(name);
 665:         return(1);
 666:     }
 667:     if(read(*file,&sample,sizeof(struct exec))>= sizeof(struct exec)) {
 668:         if(!(N_BADMAG(sample))) {
 669:             /* executable */
 670:             /* the format requires either fixed blocked records,
 671: 			 * or variable format records with each record remaining
 672: 			 * entirely within a tape block - this limits the
 673: 			 * distance between \n's to 2044 bytes, something
 674: 			 * which is VERY rarely true of executables, so
 675: 			 * we don't even try with them....
 676: 			 */
 677:             close(*file);
 678:             fprintf(stderr,"%s: executable - skipped\n",name);
 679:             return(1);
 680:         }
 681:     }
 682:     /* either couldn't read sizeof(struct exec) or wasn't executable */
 683:     /* so we assume it is a reasonable file until proven otherwise */
 684:     lseek(*file,0l,0);
 685:     return(0);
 686: }

Defined functions

backspace defined in line 396; used 1 times
casefix defined in line 494; used 4 times
filecheck defined in line 632; used 2 times
getvol defined in line 482; used 1 times
main defined in line 27; never used
readfile defined in line 506; used 1 times
rewind defined in line 378; used 4 times
skipfile defined in line 387; used 4 times
usage defined in line 225; used 7 times
writedata defined in line 256; used 1 times
writeeof1 defined in line 420; used 1 times
writeeof2 defined in line 445; used 1 times
writeeof3 defined in line 462; used 1 times
writefile defined in line 231; used 2 times
writehdr1 defined in line 405; used 1 times
writehdr2 defined in line 436; used 1 times
writehdr3 defined in line 454; used 1 times
writetm defined in line 369; used 7 times
writevol defined in line 470; used 1 times

Defined variables

cflag defined in line 15; used 2 times
dflag defined in line 17; never used
tflag defined in line 14; used 5 times
totalreadblocks defined in line 19; used 2 times
totalreadchars defined in line 21; used 2 times
totalreadfiles defined in line 18; used 2 times
totalreadlines defined in line 20; used 2 times
totalwriteblocks defined in line 23; used 2 times
totalwritechars defined in line 25; used 2 times
totalwritefiles defined in line 22; used 2 times
totalwritelines defined in line 24; used 2 times
vflag defined in line 16; used 7 times
wflag defined in line 12; used 6 times
xflag defined in line 13; used 7 times

Defined macros

getsize defined in line 505; used 1 times
Last modified: 1985-08-14
Generated: 2016-12-26
Generated by src2html V0.67
page hit count: 1509
Valid CSS Valid XHTML 1.0 Strict