home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 534.lha / sman_v1.1 / SMan_src.LZH / src / sman.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-08-09  |  6.3 KB  |  371 lines
  1.  
  2. #include <stdlib.h>
  3. #include <stdio.h>
  4. #include <string.h>
  5. #include <ctype.h>
  6. #include <stdarg.h>
  7. #include <libraries/dos.h>
  8. #include <clib/dos_protos.h>
  9. #include <clib/exec_protos.h>
  10. #include <clib/sregexp_protos.h>
  11. #include <libraries/sregexpbase.h>
  12. #include "sman_defs.h"
  13.  
  14. Prototype long        findman(char *, char *, char *, int);
  15. Prototype long        searchpath(char *, char *, char *, int);
  16. Prototype void        usage(void);
  17. Prototype long        okfile(char *, char *, char);
  18. Prototype void        putline(char *);
  19. Prototype void        leave(char *, int);
  20. Prototype char *    expandpath(char *, char *);
  21. Prototype int        spathbrk(void);
  22.  
  23. const char memory[] = "sman: Unable to allocate memory.\n";
  24.  
  25. int
  26. main(ac,av)
  27. int ac;
  28. char *av[];
  29. {
  30.     char *com,*path = NULL,file[MAXPATH],*viewer = NULL;
  31.     long line;
  32.  
  33.     do {
  34.     if (--ac < 1 || **++av != '-')
  35.         break;
  36.     switch (*(*av+1)) {
  37.         case ('p') :
  38.         case ('P') :
  39.         if (!*(path = *av + 2)) {
  40.             ac--;
  41.             path = *(++av);
  42.         }
  43.         break;
  44.         case ('v') :
  45.         case ('V') :
  46.         if (!*(viewer = *av + 2)) {
  47.             ac--;
  48.             viewer = *(++av);
  49.         }
  50.         break;
  51.         default :
  52.         usage();
  53.     }
  54.     } while (1);
  55.     if (ac < 1)
  56.     usage();
  57.  
  58.     if (!path)
  59.     if (!(path = getenv("SmanPath"))) {
  60.         putline("Environment Variable SmanPath not defined.\n");
  61.         return 1;
  62.     }
  63.     if (!viewer)
  64.     viewer = getenv("SmanViewer");
  65.  
  66.     while (ac >= 1) {
  67.     if ((line = findman(av[0],path,file,MAXPATH)) != NOT_FOUND) {
  68.         if (viewer) {
  69.         if (!(com = malloc(strlen(viewer)+strlen(file)+2))) {
  70.             putline(memory);
  71.             return 5;
  72.         }
  73.         strcpy(com,viewer);
  74.         strcat(com," ");
  75.         strcat(com,file);
  76.         } else {
  77.         char f = FALSE;
  78.         int i,mod;
  79.  
  80.         if (!(com = malloc(strlen(file)+17))) {
  81.             putline(memory);
  82.             return 5;
  83.         }
  84.         strcpy(com,"sless -");
  85.         if (line > 0)
  86.             com[7] = 'l';
  87.         else {
  88.             com[7] = 'c';
  89.             line = -line;
  90.         }
  91.         for (i = 8, mod = 10000000; mod != 0; mod /= 10) {
  92.             com[i] = line / mod + '0';
  93.             if (com[i] != '0' || f || mod == 1) {
  94.             f = TRUE;
  95.             i++;
  96.             }
  97.             line %= mod;
  98.         }
  99.         com[i++] = ' ';
  100.         strcpy(com+i,file);
  101.         }
  102.         system(com);
  103.     }
  104.     ac--;
  105.     av++;
  106.     }
  107.  
  108.     return 0;
  109. }
  110.  
  111. long
  112. findman(tar,p,file,len)
  113. char *tar,*p,*file;
  114. int len;
  115. {
  116.     char *h,q;
  117.     long line;
  118.  
  119.     do {
  120.     h = p;
  121.     while (*p != ';' && *p) p++;
  122.     q = *p;
  123.     *p = 0;
  124.     line = searchpath(h,tar,file,len);
  125.     *p++ = q;
  126.     if (line != NOT_FOUND)
  127.         return line;
  128.     } while (q);
  129.  
  130.     putline("No manual entry found for '");
  131.     putline(tar);
  132.     putline("'.\n");
  133.     return NOT_FOUND;
  134. }
  135.  
  136. /* This has to be global to free it on a break... */
  137. struct SpathInfo *spath = NULL;
  138.  
  139. long
  140. searchpath(p,tar,file,len)
  141. char *p,*tar,*file;
  142. int len;
  143. {
  144.     char *e;
  145.     long line,test;
  146.  
  147.     if (!(e = expandpath(p + (*p == ADOC || *p == DREF ? 1 : 0),tar)))
  148.     return NOT_FOUND;
  149.  
  150.     spath = AnchorPath("",e);
  151.     free(e);
  152.     if (!spath) {
  153.     putline("Illegal Path rule '");
  154.     putline(p);
  155.     putline("'\n");
  156.     return NOT_FOUND;
  157.     }
  158.  
  159.     onbreak(&spathbrk);
  160.  
  161.     line = NOT_FOUND;
  162.     do {
  163.     while ((test = NextFile(spath,file,len,SP_FILES_ONLY)) > 0) {
  164.         line = okfile(file,tar,*p);
  165.         if (line != NOT_FOUND)
  166.         break;
  167.     }
  168.     if (test == SPE_SIGBREAK) {
  169.         chkabort();
  170.         SetSignal(0,SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_D|SIGBREAKF_CTRL_E|SIGBREAKF_CTRL_F);
  171.         test = 0;
  172.     }
  173.     } while (line == NOT_FOUND && test >= 0);
  174.     onbreak(NULL);
  175.     FreeSpathInfo(spath);
  176.     spath = NULL;
  177.     return line;
  178. }
  179.  
  180. int
  181. spathbrk()
  182. {
  183.     if (spath)
  184.     FreeSpathInfo(spath);
  185.     return 1;
  186. }
  187.  
  188. long
  189. okfile(file,tar,ftype)
  190. char *file,*tar,ftype;
  191. {
  192.     FILE *fp;
  193.     char buff[200],*m,*n;
  194.     int line,len;
  195.     struct SregExp *spat;
  196.  
  197.     if (ftype != ADOC && ftype != DREF)
  198.     return 0;
  199.  
  200.     if (!(fp = fopen(file,"r")))
  201.     return NOT_FOUND;
  202.  
  203.     if (ftype == ADOC) {
  204.     line = -1;
  205.     do {
  206.         if (fgets(buff,199,fp) != buff) {
  207.         fclose(fp);
  208.         return NOT_FOUND;
  209.         }
  210.         line++;
  211.     } while (*buff == '\n');
  212.  
  213.     if (strnicmp("TABLE OF CONTENTS",buff,17)) {
  214.         fclose(fp);
  215.         return NOT_FOUND;
  216.     }
  217.  
  218.     strcpy(buff,"#?/(");
  219.     strcat(buff,tar);
  220.     strcat(buff,")\n");
  221.     if (!(spat = ParseSregExp(buff))) {
  222.         fclose(fp);
  223.         return NOT_FOUND;
  224.     }
  225.     while (fgets(buff,199,fp) == buff) {
  226.         line++;
  227.         if (*buff == 12) {
  228.         FreeSregExp(spat);
  229.         fclose(fp);
  230.         return NOT_FOUND;
  231.         }
  232.         if (MatchSregExp(buff,spat,TRUE))
  233.         goto agotit;
  234.     }
  235.     FreeSregExp(spat);
  236.     fclose(fp);
  237.     return NOT_FOUND;
  238.  
  239.     agotit:
  240.     FreeSregExp(spat);
  241.     len = strlen(buff);
  242.     buff[len-1] = 0;
  243.     if (!(m = malloc(len))) {
  244.         fclose(fp);
  245.         leave(memory,5);
  246.     }
  247.     strcpy(m,buff);
  248.     while (fgets(buff,199,fp) == buff) {
  249.         line++;
  250.         if (strncmp(m,buff,len - 1) == 0) {
  251.         free(m);
  252.         fclose(fp);
  253.         return line;
  254.         }
  255.     }
  256.     free(m);
  257.     fclose(fp);
  258.     return NOT_FOUND;
  259.     } else {
  260.     len = strlen(tar);
  261.     while (fgets(buff,199,fp) == buff) {
  262.         if (strncmp(tar,buff,len) == 0 && isspace(buff[len])) {
  263.         fclose(fp);
  264.         goto dgotit;
  265.         }
  266.     }
  267.     fclose(fp);
  268.     return NOT_FOUND;
  269.  
  270.     dgotit:
  271.     m = buff;
  272.     for (len = 0; len < 2; len++) {
  273.         while (!isspace(*m++)) ;
  274.         while (isspace(*m)) m++;
  275.     }
  276.     n = m;
  277.     while (*n != ':' && *n != '/' && !isspace(*n)) n++;
  278.     if (*n == ':')
  279.         n = file;
  280.     else {
  281.         n = file + strlen(file);
  282.         while (*(n-1) != '/' && *(n-1) != ':' && n != file) n--;
  283.     }
  284.     while (!isspace(*m))
  285.         *n++ = *m++;
  286.     *n = 0;
  287.     while (isspace(*m)) m++;
  288.     if (*m++ != '@' || *m++ != '@')
  289.         return 0;
  290.     line = 0;
  291.     while (!isspace(*m))
  292.         line = line*10 - *m++ + '0';
  293.     return line;
  294.     }
  295. }
  296.  
  297. char *
  298. expandpath(p,tar)
  299. char *p,*tar;
  300. {
  301.     int num = 0;
  302.     char *q,*r,*t;
  303.  
  304.     for (q = p; *q; q++) {
  305.     if (*q == '\'' && *(q+1) == '&')
  306.         q++;
  307.     else if (*q == '&')
  308.         num++;
  309.     }
  310.  
  311.     if (!(q = malloc(strlen(p) + num*(strlen(tar)+1) + 1))) {
  312.     putline(memory);
  313.     return NULL;
  314.     }
  315.  
  316.     for (r = q; *p; p++) {
  317.     if (*p == '&') {
  318.         *r++ = '(';
  319.         for (t = tar; *t; t++)
  320.         *r++ = *t;
  321.         *r++ = ')';
  322.     } else {
  323.         if (*p == '\'' && *(p+1) == '&')
  324.         p++;
  325.         *r++ = *p;
  326.     }
  327.     }
  328.     *r = 0;
  329.     return q;
  330. }
  331.  
  332. void
  333. usage()
  334. {
  335.     putline("sman V"\
  336.          VERSION\
  337.          ", "
  338.          __DATE__\
  339.          ", (c)Copyright 1991 by Jon Spencer.\n");
  340.     putline("Usage: Sman [-pSearch pattern] [-vViewer] target [target...]\n");
  341.     exit(2);
  342. }
  343.  
  344. void
  345. putline(p)
  346. char *p;
  347. {
  348.     Write(Output(),p,strlen(p));
  349. }
  350.  
  351. void
  352. leave(p,x)
  353. char *p;
  354. int x;
  355. {
  356.     putline(p);
  357.     exit(x);
  358. }
  359.  
  360. int printf(f, ...)
  361. const char *f;
  362. {
  363.     char buff[100];
  364.     va_list va;
  365.  
  366.     va_start(va,f);
  367.     vsprintf(buff,f,va);
  368.     va_end(va);
  369.     Write(Output(),buff,strlen(buff));
  370. }
  371.