home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 12 / MA_Cover_12.iso / internet / gethelp / source / get_title.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-06-06  |  6.2 KB  |  302 lines
  1. #include <stdio.h>
  2. #include <ctype.h>
  3. #include <string.h>
  4.  
  5. #include <exec/memory.h>
  6. #include <exec/types.h>
  7.  
  8. #define MAXLEN 256
  9. #define MEMTYPE MEMF_PUBLIC | MEMF_CLEAR
  10.  
  11. static char strbuf[MAXLEN];         /* string buffer */
  12. extern int debug;                   /* debug flag */
  13.  
  14. /*
  15.  * int *findstring(lineptr, nlines, findstr, flag_whole, flag_case)
  16.  *
  17.  * return TRUE if findstr found in array of lines linptr
  18.  * flag_whole: look for whole word
  19.  * flag_case:  look for matching case
  20.  *
  21. */
  22. int findstring(lineptr, nlines, findstr, flag_whole, flag_case)
  23.  
  24. char *lineptr[];
  25. int nlines;
  26. char *findstr;
  27. int flag_whole;
  28. int flag_case;
  29. {
  30.     extern int strindex(), isword();
  31.  
  32.     int flag_found = 0, pos = 0;
  33.  
  34.     while (--nlines >= 0) {
  35.  
  36.         if ((pos = strindex(*lineptr, findstr, flag_case)) > -1) {
  37.             if (debug) printf ("Found it at pos=%d!\n",pos);
  38.             flag_found = 1;
  39.             if (flag_whole)
  40.                 if (!(isword(*lineptr, findstr, pos))) flag_found = 0;
  41.         }
  42.  
  43.         *lineptr++;
  44.     }
  45.  
  46.     return(flag_found);
  47. }
  48.  
  49. int findtitle(filename, lineptr, nlines, fp)
  50.  
  51. char *filename,
  52.      *lineptr[];
  53. int nlines;
  54. FILE *fp;
  55.  
  56. {
  57.     extern int strindex(), strcmptext();
  58.     extern char *midstr(), *solidstr();
  59.     extern void add_url();
  60.  
  61.     int pos = 0, startpos = 0, flag_found = 0;
  62.     char titlestr[MAXLEN];
  63.  
  64.     while ((--nlines > 0) && (*lineptr)) {
  65.  
  66.         if (debug) printf("found flag = %d\n",flag_found);
  67.  
  68.         /* check for <TITLE> tag */
  69.         if ((pos = strindex(*lineptr, "<TITLE>", 0)) > -1) {
  70.             if (debug) printf("Got <TITLE>!\n");
  71.             flag_found = 1;
  72.             startpos = pos + 7;
  73.  
  74.             /* anything else on this line? */
  75.             if (startpos != strlen(*lineptr)) {
  76.  
  77.                  /* yes there is, get it */
  78.                  if (debug) printf("remainder was %s\n",midstr(*lineptr, startpos, strlen(*lineptr)));
  79.  
  80.                  /* check for </TITLE> tag */
  81.                  if ((pos = strindex(*lineptr, "</TITLE>", 0)) > -1) {
  82.  
  83.                      nlines = 0;
  84.                  } else pos = strlen(*lineptr);
  85.  
  86.                  if (debug) printf("reading title..%s\n",midstr(*lineptr,startpos,pos));
  87.  
  88.                  strcpy(titlestr,(char *)midstr(*lineptr,startpos,pos));
  89.  
  90.             } /* else nothing */
  91.  
  92.         }
  93.  
  94.         /* proceed through subsequent line(s) */
  95.         *lineptr++;
  96.         startpos = 0;
  97.  
  98.         if (flag_found && nlines) {
  99.  
  100.             /* check for </TITLE> tag */
  101.             if ((pos = strindex(*lineptr, "</TITLE>", 0)) > -1) {
  102.                 nlines=0;
  103.                 startpos = pos + 8;
  104.  
  105.                 /* anthing preceeding the tag */
  106.                 if (strcmptext("</TITLE>",*lineptr))
  107.                     strcpy(titlestr,(char *)midstr(*lineptr,startpos,pos));
  108.                 else nlines = 0;
  109.  
  110.             } else strcpy(titlestr,*lineptr);
  111.  
  112.         }
  113.     }
  114.  
  115.     if (flag_found) {
  116.         if (debug) printf("Title is '%s'\n",(char *)solidstr(titlestr));
  117.  
  118.         /* add title to report file */
  119.         add_url(fp, filename, solidstr(titlestr));
  120.     }
  121.  
  122.     return(flag_found);
  123. }
  124.  
  125. /*
  126.  * int strcmptext(s,t)
  127.  *
  128.  * return <0 if s<t, 0 if s==t, >0 if s>t
  129.  * ignoring whitespace in t
  130.  *
  131. */
  132.  
  133. int strcmptext(s, t)
  134.  
  135. char *s, *t;
  136.  
  137. {
  138.     int i = 0, j = 0;
  139.  
  140.     while(s[i] != '\0')
  141.        if (!(s[i] == t[j])) {
  142.            if ((t[j] == ' ')||(t[j] == '\t')) j++; else return(s[i]-t[j]);
  143.        } else {
  144.            i++; j++;
  145.        }
  146.     return(0);
  147. }
  148.  
  149. /*
  150.  * char *midstr(s,startpos,endpos)
  151.  *
  152.  * return a substring of s from position startpos to endpos
  153.  * use a string buffer to avoid hacking up arguments!
  154.  *
  155. */
  156. char *midstr(s, startp, endp)
  157.  
  158. char *s;
  159. int startp, endp;
  160.  
  161. {
  162.     extern char strbuf[MAXLEN];
  163.     int i=0, pos=0;
  164.  
  165.     pos = startp;
  166.  
  167.     while ((strbuf[i++] = s[pos++]) != '\0' && pos<endp);
  168.  
  169.     strbuf[i] = '\0';
  170.  
  171.     return(strbuf);
  172.  
  173. }
  174.  
  175. /*
  176.  * char *solidstr(s)
  177.  *
  178.  * return a substring of s without leading or trailing whitespace
  179.  * use a string buffer to avoid hacking up arguements!
  180.  *
  181. */
  182. char *solidstr(s)
  183.  
  184. char *s;
  185. {
  186.     extern char strbuf[MAXLEN];
  187.     int i=0, j=0;
  188.  
  189.     /* skip leading whitespace */
  190.     while (isspace(s[j])) j++;
  191.  
  192.     /* copy remainder of string */
  193.     while ((strbuf[i] = s[j++]) != '\0') i++;
  194.  
  195.     /* backtrack to confirm end of string */
  196.     while (isspace(strbuf[i])) strbuf[i--] = '\0';
  197.  
  198.     return(strbuf);
  199. }
  200.  
  201. /*
  202.  * int strindex(s, t, flag)
  203.  *
  204.  * return position of string s in t or -1 if not found
  205.  * if flag is TRUE match case
  206.  *
  207. */
  208. int strindex(s, t, flag)
  209.  
  210. char *s, *t;
  211. int flag;
  212. {
  213.     int i, j, k;
  214.  
  215.     for (i = 0; s[i] != '\0'; i++) {
  216.         if (flag)
  217.             for (j=i, k=0; t[k]!='\0' && s[j]==t[k]; j++, k++);
  218.         else
  219.             for (j=i, k=0; t[k]!='\0' && tolower(s[j])==tolower(t[k]); j++, k++);
  220.         if (t[k] == '\0') return(i);
  221.     }
  222.     return(-1);
  223. }
  224.  
  225. /*
  226.  * int isword(s,t)
  227.  *
  228.  * returns TRUE if string t was a complete word in s at position pos
  229. */
  230. int isword(s, t, pos)
  231.  
  232. char *s, *t;
  233. int pos;
  234. {
  235.     if (pos > 0)
  236.         if (isalnum(s[pos-1])) return(0);
  237.  
  238.     if (isalnum(s[pos + strlen(t)])) return(0);
  239.  
  240.     return(1);
  241. }
  242.  
  243. /*
  244.  * int readlines(lineptr, maxlines, fp)
  245.  *
  246.  * read file fp with maximum lines maxlines into array lineptr
  247.  * return number of lines
  248. */
  249. int readlines(lineptr, maxlines, fp)
  250.  
  251. char *lineptr[];
  252. int maxlines;
  253. FILE *fp;
  254.  
  255. {
  256.     extern struct Remember *RememberLinesPtr;  /* Lines memory area */
  257.     int len,                    /* length of current line */
  258.         nlines;                 /* number of lines found */
  259.     char line[MAXLEN];          /* storage for each line */
  260.  
  261.     UBYTE *AllocRemember();
  262.  
  263.     nlines=0;       /* reset lines counter */
  264.  
  265.     while((fgets(line,MAXLEN,fp)) != NULL)
  266.  
  267.         if (nlines >= maxlines)
  268.             return(-1);
  269.         else {
  270.  
  271.             len = strlen(line);
  272.  
  273.             if (lineptr[nlines] = AllocRemember(&RememberLinesPtr, (ULONG)len, MEMTYPE)) {
  274.  
  275.                 line[len-1] = '\0';
  276.                 strcpy(lineptr[nlines++],line);
  277.  
  278.             } else {
  279.  
  280.                 printf("Out of Memory in readlines!\n");
  281.                 return(-1);
  282.             }
  283.         }
  284.  
  285.     return(nlines);
  286. }
  287. /*
  288.  * void writelines(lineptr, nlines)
  289.  *
  290.  * print nlines lines of array lineptr
  291. */
  292. void writelines(lineptr, nlines)
  293.  
  294. char *lineptr[];
  295. int nlines;
  296. {
  297.     while (--nlines >= 0)
  298.         printf("%s\n", *lineptr++);
  299. }
  300.  
  301.  
  302.