home *** CD-ROM | disk | FTP | other *** search
/ Shareware Overload / ShartewareOverload.cdr / progm / cpgms.zip / 123DUMP.C next >
C/C++ Source or Header  |  1985-11-17  |  9KB  |  422 lines
  1.  
  2. #include "stdio.h"
  3.  
  4.  
  5.  
  6. char    *documentation[] = {
  7. "123dump prints a set of files with headings.",
  8. "   123dump [flags] file_list [>file]",
  9. "",
  10. "Flags are single characters preceeded by '-':",
  11. "   -m      Display macro definitions",
  12. "   -h      Print headings switch.  Normally, on.",
  13. "   -v      Verbose. Show file stats on stderr.",
  14. "   -lnnn   Line length (nnn).",
  15. "   -pnnn   Page length (nnn).",
  16. "   -tnnn   Tab stop every nnn columns.",
  17. "The file_list is a list of files (wildcards are acceptable).",
  18. "",
  19. "Output is to stdout.  To print add >PRN: to your command.",
  20. 0 };
  21.  
  22.  
  23. #define DeSmet 1
  24. #define MSDOS 1
  25. #define LMAX  256
  26.  
  27. #ifndef stdin
  28. #define stdin STDIN
  29. #define stdout STDOUT
  30. #define stderr STDERR
  31. #endif
  32.  
  33.  
  34. int    mflag;
  35. int    nflag;
  36. int    hflag;
  37. int    vflag;
  38. int    nfile;
  39.  
  40. int    pflag = 56;
  41. int    tflag = 4;
  42. int    lflag = 80;
  43.  
  44. char sbuf[LMAX];
  45.  
  46. struct rnamtb {
  47.     char rname[16];
  48.     int rrow;
  49.     int rcol;};
  50.  
  51. struct rnamtb rtbl[30];
  52.  
  53. int rmax;
  54. int rndx;
  55.  
  56. int    debug    =    0;       /* Set for debug code      */
  57.  
  58. char    *pp;
  59.  
  60. /*    char *colnam[] = {"A","B","C","D","E","F","G","H","I","J","K",
  61.         "L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z",
  62.         "AA","AB","AC","AD","AE","AF","AG","AH","AI","AJ","AK","AL",
  63.         "AM","AN","AO","AP","AQ","AR","AS","AT","AU","AV","AW","AX",
  64.         "AY","AZ",
  65.         "BA","BB","BC","BD","BE","BF","BG","BH","BI","BJ","BK","BL",
  66.         "BM","BN","BO","BP","BQ","BR","BS","BT","BU","BV","BW","BX",
  67.         "BY","BZ",
  68.         "CA","CB","CC","CD","CE","CF","CG","CH","CI","CJ","CK","CL",
  69.         "CM","CN","CO","CP","CQ","CR","CS","CT","CU","CV","CW","CX",
  70.         "CY","CZ",
  71.         "DA","DB","DC","DD","DE","DF","DG","DH","DI","DJ","DK","DL",
  72.         "DM","DN","DO","DP","DQ","DR","DS","DT","DU","DV","DW","DX",
  73.         "DY","DZ",
  74.         "EA","EB","EC","ED","EE","EF","EG","EH","EI","EJ","EK","EL",
  75.         "EM","EN","EO","EP","EQ","ER","ES","ET","EU","EV","EW","EX",
  76.         "EY","EZ",
  77.         "FA","FB","FC","FD","FE","FF","FG","FH","FI","FJ","FK","FL",
  78.         "FM","FN","FO","FP","FQ","FR","FS","FT","FU","FV","FW","FX",
  79.         "FY","FZ",
  80.         "GA","GB","GC","GD","GE","GF","GG","GH","GI","GJ","GK","GL",
  81.         "GM","GN","GO","GP","GQ","GR","GS","GT","GU","GV","GW","GX",
  82.         "GY","GZ",
  83.         "HA","HB","HC","HD","HE","HF","HG","HH","HI","HJ","HK","HL",
  84.         "HM","HN","HO","HP","HQ","HR","HS","HT","HU","HV","HW","HX",
  85.         "HY","HZ",
  86.         "IA","IB","IC","ID","IE","IF","IG","IH","II","IJ","IK","IL",
  87.         "IM","IN","IO","IP","IQ","IR","IS","IT","IU","IV","IW","IX",
  88.         "IY","IZ"};   */
  89.  
  90. /*******************************************************/
  91.  
  92. main(argc, argv)
  93. char *argv[];
  94. {
  95.    register char   *p;
  96.    register int    c, i;
  97.    char  *fexpnd();
  98.  
  99.    FILE        *f;
  100.  
  101.    if (argc <= 1)
  102.       usage("No arguments");
  103.    if (argc == 2 && argv[1][0] == '?' && argv[1][1] == 0) {
  104.       help(documentation);
  105.       return;
  106.       }
  107.    nfile = argc-1;
  108.    for (i=1; i < argc; ++i) {
  109.       p = argv[i];
  110.       if (*p == '-') {
  111.      ++p;
  112.      while (c = *p++) {
  113.         switch(tolower(c)) {
  114.  
  115.         case '?':
  116.            help(documentation);
  117.            break;
  118.  
  119.         case 'M':
  120.         case 'm':
  121.            ++mflag;
  122.            break;
  123.  
  124.         case 'D':
  125.         case 'd':
  126.            ++debug;
  127.            break;
  128.  
  129.         case 'N':
  130.         case 'n':
  131.            ++nflag;
  132.            break;
  133.  
  134.         case 'H':
  135.         case 'h':
  136.            ++hflag;
  137.            break;
  138.  
  139.         case 'V':
  140.         case 'v':
  141.            ++vflag;
  142.            break;
  143.  
  144.         case 'L':
  145.         case 'l':
  146.            lflag=atoi(p);
  147.            if (lflag > 132 | lflag < 9)
  148.               error("Line size must be 9 - 132\n","");
  149.            while (*p != '\0')        /* skip value */
  150.                    p++;
  151.            break;
  152.  
  153.         case 'P':
  154.         case 'p':
  155.            pflag=atoi(p)-4;      /* -4 to allow for heading */
  156.            if (pflag < 1)
  157.               error("Page size must be > 4","");
  158.            while (*p != '\0')        /* skip value */
  159.                    p++;
  160.            break;
  161.  
  162.         case 'T':
  163.         case 't':
  164.            tflag=atoi(p);
  165.            while (*p != '\0')        /* skip value */
  166.                    p++;
  167.            break;
  168.  
  169.         default:
  170.            usage("Unknown flag");
  171.         }
  172.      }
  173.      argv[i] = 0;
  174.      --nfile;
  175.       }
  176.    }
  177.    if (nfile == 0)
  178.       dmp123(stdin, 0);
  179.    else {
  180.       for (i=1; i < argc; ++i) {
  181. #if MSDOS 
  182.      if (argv[i])
  183.      while (p = fexpnd(argv[i])) {
  184. #else
  185.      if (p = argv[i]) {
  186. #endif
  187.         if ((f=fopen(p, "r")) == NULL)
  188.            cant(p);
  189.         else {
  190.            dmp123(f, p);
  191.            fclose(f);
  192.         }
  193.      }
  194.       }
  195.    }
  196. }
  197.  
  198. /*******************************************************/
  199.  
  200. usage(s)
  201. char    *s;
  202. {
  203.    fprintf(stderr, "?123DUMP-E-%s\n", s);
  204.    fprintf(stderr,
  205.       "Usage: 123dump [-whnv] [-lnnn] [-pnnn] [-tnnn] [file ...].  \n");
  206.    fprintf(stderr,
  207.       " 123dump ? for help\n");
  208.    exit(1);
  209. }
  210.  
  211.  
  212.     int lno;
  213.     int pageno;
  214.  
  215.  
  216. /*******************************************************/
  217.  
  218. dmp123(fp, fn)
  219. FILE       *fp;       /* File to process        */
  220. char       *fn;       /* File name (for -f option)  */
  221. /*
  222.  * Dump information from and about a Lotus 123 worksheet 
  223.  */
  224. {
  225.     int ndx, itype, ilen;
  226.  
  227.     pageno = 0;
  228.  
  229.     lno = pflag + 1;
  230.  
  231.     rmax = -1;        /* reset macro table */
  232.      
  233.     while ((itype = getint(fp)) != 0x01) {
  234.         ilen = getint(fp);        /* record length */
  235.  
  236.         switch(itype) {
  237.  
  238.         case 0x00:                /* header */
  239.            skipby(fp,ilen);
  240.            break;
  241.  
  242.         case 0x06:                /* range record */
  243.            skipby(fp,ilen);
  244.            break;
  245.  
  246.         case 0x0b:                /* range name record */
  247.                if (ilen != 0x18) {        /* range name is 24 bytes */
  248.                 skipby(fp,ilen);
  249.                 break;
  250.             }
  251.             proc0b(fp,fn,ilen);
  252.             break;
  253.  
  254.         case 0x0d:                /* integer cell */
  255.            skipby(fp,ilen);
  256.            break;
  257.  
  258.         case 0x0e:                /* double precision cell */
  259.            skipby(fp,ilen);
  260.            break;
  261.  
  262.         case 0x0f:                /* character string cell */
  263.             proc0f(fp,fn,ilen);
  264.             break;
  265.  
  266.         case 0x10:                /* formula cell */
  267.            skipby(fp,ilen);
  268.            break;
  269.  
  270.         default:
  271.            skipby(fp,ilen);
  272.         }
  273.  
  274.    }
  275.  
  276.  /*  search for unmatched macro definitions  */
  277.     for (rndx = 0;rndx <= rmax; rndx++) 
  278.         if (' ' != rtbl[rndx].rname[1]) { 
  279.             sprintf(sbuf,"\n %-20s %d/%d\t  string not in worksheet",
  280.                 rtbl[rndx].rname,rtbl[rndx].rcol,rtbl[rndx].rrow);
  281.             prt123(fn);
  282.         }
  283.     if (vflag) 
  284.       fprintf(stderr,"Worksheet %s has been processed\n", fn);
  285.  
  286. }
  287.  
  288.  
  289.  
  290.  
  291.  
  292.  
  293. /*******************************************************/
  294.  
  295. skipby(fp,len)
  296. FILE       *fp;       /* File to process        */
  297. int    len;
  298. /*
  299.  * Read and discard <len> bytes from file <fp>.
  300.  */
  301. {
  302.     char c;
  303.     
  304.     while (len--)
  305.         c = fgetc(fp);   
  306.  
  307. }
  308.  
  309.  
  310.  
  311.  
  312.  
  313. /*******************************************************/
  314.  
  315. proc0b(fp,fn,ilen)
  316. FILE       *fp;       /* File to process        */
  317. char *fn;
  318. int    ilen;
  319. /*
  320.  * Process type 0x0b records (range name recs).
  321.  */
  322. {
  323.     int ndx, icolb, icole, irowb, irowe;
  324.     char mname[17];
  325.  
  326.     ndx = 0;
  327.     while (mname[ndx++] = fgetc(fp)) ;
  328.     if (ndx < 16)
  329.         skipby(fp,16 - ndx);
  330.     icolb = getint(fp)+1;
  331.     irowb = getint(fp)+1;
  332.     icole = getint(fp)+1;
  333.     irowe = getint(fp)+1;
  334. /*    printf("\n %-20s %s%d .. %s%d        ",mname,colnam[icolb],irowb,colnam[icole],irowe); */
  335.     if (mflag && (mname[0] == '\\')) {
  336.         rmax++;
  337.         strcpy(rtbl[rmax].rname,mname);    /* name */
  338.         rtbl[rmax].rrow = irowb;        /* row[rmax] */
  339.         rtbl[rmax].rcol = icolb;        /* column */
  340.     }
  341.     if (!mflag) {
  342.         sprintf(sbuf,"\n %-20s %d/%d .. %d/%d",mname,icolb,irowb,icole,irowe);
  343.         prt123(fn);
  344.     }
  345. }
  346.  
  347.  
  348.  
  349.  
  350. /*******************************************************/
  351.  
  352. proc0f(fp,fn,ilen)
  353. FILE       *fp;       /* File to process        */
  354. char *fn;
  355. int    ilen;
  356. /*
  357.  * Process type 0x0f records (range name recs).
  358.  */
  359. {
  360.     int ndx, icolb, irowb;
  361.     char stbuf[LMAX];
  362.  
  363.     skipby(fp,1);    /* skip format byte */
  364.     icolb = getint(fp) + 1;    /* starting column */
  365.     irowb = getint(fp) + 1;    /* starting row    */
  366.     for (ndx = 0; (stbuf[ndx++] = fgetc(fp)) && (ndx < LMAX) ;) 
  367.         ;    /* copy string to save area  */
  368.  /*  search for macro definition for this string  */
  369.     for (rndx = 0;rndx <= rmax; rndx++) 
  370.         if ((icolb == rtbl[rndx].rcol) &&
  371.             (irowb == rtbl[rndx].rrow)) {
  372.             sprintf(sbuf,"\n %-20s %d/%d       ",rtbl[rndx].rname,
  373.                 icolb,irowb);
  374.             strncat(sbuf,stbuf,LMAX);
  375.             prt123(fn);
  376.             rtbl[rndx].rname[1] = ' ';   /* mark macro printed */
  377.         }
  378. }
  379.  
  380.  
  381.  
  382.  
  383. /*******************************************************/
  384.  
  385. prt123(fn)
  386. char *fn;
  387. /*
  388.  * Print information from and about a Lotus 123 worksheet 
  389.  */
  390. {
  391.     char date[9], time[9], lbuf[LMAX];
  392.     int llen, rlen;
  393.    
  394.     dates(date);                /* get date and time from operating system */
  395.     times(time);
  396.  
  397.     if (!hflag && lno > pflag) { 
  398.         printf("\f \n %-44s %s %s    Page %d\n\n",fn,date,time,++pageno);
  399.         lno = 0;
  400.     }
  401.     llen = lflag;
  402.         
  403.     rlen = strlen(sbuf);
  404.  
  405.     for (;rlen > 0;rlen-=llen) {
  406.         ++lno;
  407.         strncpy(lbuf,sbuf,llen);  /* limit output line length */
  408.         if (lbuf[llen-1] != '\0') {
  409.             lbuf[llen] = '\n';          /* in case len(lbuf) > llen */
  410.             lbuf[llen+1] = '\0';
  411.         }
  412.     
  413.         printf("%s", lbuf);
  414.  
  415.         if (rlen > llen) {
  416.             strncpy(sbuf,sbuf+llen,llen);    /* discard part printed */
  417.             printf("        ");
  418.             llen = lflag - 8;
  419.         }
  420.     }
  421. }
  422.