home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / enterprs / c128 / util / 128c.arc / FIND.C < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-04  |  7.4 KB  |  396 lines
  1. #INCLUDE <STDIO.H>
  2.  
  3. #DEFINE  ═┴╪╠╔╬┼  256
  4. #DEFINE  ═┴╪╨┴╘   256
  5. #DEFINE  ┼╥╥       -3
  6. #DEFINE  ┘┼╙        1
  7. #DEFINE  ╬╧         0
  8. #DEFINE  ├╠╧╙╒╥┼  '*'
  9. #DEFINE  ├╠╧╙╔┌┼    4
  10. #DEFINE  ├╧╒╬╘      1
  11. #DEFINE  ╙╘┴╥╘      3
  12. #DEFINE  ╨╥┼╓├╠     2
  13. #DEFINE  ╧╦         1
  14.  
  15. #DEFINE  ┼╧╙     '\0'
  16. #DEFINE  ├╚╥      'A'
  17. #DEFINE  ┬╧╠      '%'
  18. #DEFINE  ┼╧╠      '$'
  19. #DEFINE  ┴╬┘      '?'
  20. #DEFINE  ├├╠      '['
  21. #DEFINE  ╬├├╠     'N'
  22. #DEFINE  ├├╠┼╬─   ']'
  23. #DEFINE  ╬╧╘      '!'
  24. #DEFINE  ┼╙├┴╨┼   '@'
  25. #DEFINE  ─┴╙╚     '-'
  26.  
  27. CHAR LINE[═┴╪╠╔╬┼];
  28. CHAR *IRET, *JRET;
  29.  
  30.  
  31. MAIN (ARGC, ARGV)
  32. UNSIGNED ARGC;
  33. CHAR **ARGV;
  34. █
  35.    STATIC CHAR PAT[═┴╪╨┴╘];
  36.    CHAR *S;
  37.    ╞╔╠┼ FIN;
  38.    INT EXCEPT, NUMBER, PRNAME;
  39.  
  40.    EXCEPT = ╬╧;
  41.    NUMBER = ╬╧;
  42.    PRNAME = ╬╧;
  43.    WHILE (--ARGC && **++ARGV == '-')
  44.       FOR (S = *ARGV + 1; *S; S++)
  45.          SWITCH (*S) █
  46.             CASE 'X':
  47.                  EXCEPT = ┘┼╙;
  48.                  BREAK;
  49.             CASE 'N':
  50.                  NUMBER = ┘┼╙;
  51.                  BREAK;
  52.             CASE 'F':
  53.                  PRNAME = ┘┼╙;
  54.                  BREAK;
  55.             DEFAULT:
  56.                  PRINTF ("FIND: ILLEGAL OPTION %C\N", *S);
  57.                  BREAK;
  58.          ▌
  59.  
  60.    IF (ARGC == 0)
  61.       ERROR ("USAGE: FIND [-X] [-N] [-F] PATTERN");
  62.  
  63.    IF (GETPAT (*ARGV, PAT) == ┼╥╥)
  64.       ERROR ("ILLEGAL PATTERN");
  65.  
  66.    IF (ARGC == 1)
  67.       FIND (STDIN, PAT, EXCEPT, NUMBER, PRNAME, "STDIN");
  68.    ELSE
  69.       WHILE (--ARGC) █
  70.          IF ((FIN = FOPEN (*++ARGV, "R")) == ╬╒╠╠ ▀▀ FERROR()) █
  71.             PRINTF ("CAN'T OPEN %S\N", *ARGV);
  72.             EXIT();
  73.          ▌
  74.          FIND (FIN, PAT, EXCEPT, NUMBER, PRNAME, *ARGV);
  75.          FCLOSE (FIN);
  76.       ▌
  77. ▌
  78.  
  79. FIND (FIN, PAT, EXCEPT, NUMBER, PRNAME, NAME)
  80. ╞╔╠┼ FIN;
  81. CHAR *PAT, *NAME;
  82. █
  83.    INT LINENO = 0;
  84.  
  85.    WHILE (FGETS(LINE, ═┴╪╠╔╬┼, FIN) != ╬╒╠╠) █
  86.       LINENO++;
  87.       IF (MATCH(LINE, PAT) != EXCEPT) █
  88.          IF (PRNAME)
  89.             PRINTF ("%S: ", NAME);
  90.          IF (NUMBER)
  91.             PRINTF ("%D: ", LINENO);
  92.          FPUTS (LINE, STDOUT);
  93.          ▌
  94.       ▌
  95. ▌
  96.  
  97. ERROR(S)
  98. CHAR *S;
  99. █
  100.    PUTS(S);
  101.    EXIT();
  102. ▌
  103.  
  104. MATCH (LIN, PAT)
  105. CHAR *LIN, *PAT;
  106. █
  107.    FOR (; *LIN; LIN++)
  108.       IF (AMATCH (LIN, PAT))
  109.          RETURN (┘┼╙);
  110.    RETURN (╬╧);
  111. ▌
  112.  
  113. AMATCH (LIN, PAT)
  114. CHAR *LIN, *PAT;
  115. █
  116.    CHAR *I, *J, *OFFSET, *STACK;
  117.  
  118.    STACK = PAT - 1;
  119.    OFFSET = LIN;
  120.    FOR (J=PAT; *J; J += PATSIZ(J))
  121.       IF (*J == ├╠╧╙╒╥┼) █
  122.          STACK = J;
  123.          J += ├╠╧╙╔┌┼;
  124.          FOR (I=OFFSET; *I; I=IRET)
  125.             IF (OMATCH (I, J) == ╬╧)
  126.                BREAK;
  127.          *(STACK + ├╧╒╬╘) = I - OFFSET;
  128.          *(STACK + ╙╘┴╥╘) = OFFSET - LIN;
  129.          OFFSET = I;
  130.          ▌
  131.       ELSE IF (OMATCH (OFFSET, J) == ╬╧) █
  132.          FOR (; STACK >= PAT; STACK = PAT + *(STACK+╨╥┼╓├╠) - 1)
  133.             IF (*(STACK + ├╧╒╬╘) > 0)
  134.                BREAK;
  135.          IF (STACK < PAT)
  136.             RETURN (0);
  137.          (*(STACK + ├╧╒╬╘))--;
  138.          J = STACK + ├╠╧╙╔┌┼;
  139.          OFFSET = LIN + *(STACK+╙╘┴╥╘) + *(STACK+├╧╒╬╘);
  140.          ▌
  141.       ELSE
  142.          OFFSET = IRET;
  143.    RETURN (OFFSET - LIN + 1);
  144. ▌
  145.  
  146. PATSIZ(N)
  147. CHAR *N;
  148. █
  149.    SWITCH (*N) █
  150.       CASE ├╚╥:
  151.          RETURN 2;
  152.       CASE ┬╧╠:
  153.       CASE ┼╧╠:
  154.       CASE ┴╬┘:
  155.          RETURN 1;
  156.       CASE ├├╠:
  157.       CASE ╬├├╠:
  158.          RETURN *(N+1) + 2;
  159.       CASE ├╠╧╙╒╥┼:
  160.          RETURN ├╠╧╙╔┌┼;
  161.       DEFAULT:
  162.          ERROR ("IN PATSIZ: CAN'T HAPPEN");
  163.    ▌
  164. ▌
  165.  
  166. OMATCH (I, J)
  167. CHAR *I, *J;
  168. █
  169.    INT BUMP;
  170.  
  171.    IRET = I;
  172.    IF (*I == '\0')
  173.       RETURN ╬╧;
  174.    BUMP = -1;
  175.    SWITCH (*J) █
  176.       CASE ├╚╥:
  177.          IF (*I == *(J+1))
  178.             BUMP = 1;
  179.          BREAK;
  180.       CASE ┬╧╠:
  181.          IF (I == LINE)
  182.             BUMP = 0;
  183.          BREAK;
  184.       CASE ┴╬┘:
  185.          IF (*I != '\N')
  186.             BUMP = 1;
  187.          BREAK;
  188.       CASE ┼╧╠:
  189.          IF (*I == '\N')
  190.             BUMP = 0;
  191.          BREAK;
  192.       CASE ├├╠:
  193.          IF (LOCATE(*I, J+1))
  194.             BUMP = 1;
  195.          BREAK;
  196.       CASE ╬├├╠:
  197.          IF (*I != '\N' && LOCATE(*I,J+1) == ╬╧)
  198.             BUMP = 1;
  199.          BREAK;
  200.       DEFAULT:
  201.          ERROR ("IN OMATCH: CAN'T HAPPEN");
  202.    ▌
  203.    IF (BUMP >= 0) █
  204.       IRET = I + BUMP;
  205.       RETURN ┘┼╙;
  206.    ▌
  207.    RETURN ╬╧;
  208. ▌
  209.  
  210. LOCATE (C, OFFSET)
  211. CHAR *OFFSET;
  212. █
  213.    CHAR *I;
  214.  
  215.    FOR (I=OFFSET+*OFFSET; I>OFFSET; I--)
  216.       IF (*I == C)
  217.          RETURN ┘┼╙;
  218.    RETURN ╬╧;
  219. ▌
  220.  
  221. GETPAT (ARG, PAT)
  222. CHAR *ARG, *PAT;
  223. █
  224.    RETURN (MAKPAT(ARG, ┼╧╙, PAT));
  225. ▌
  226.  
  227. MAKPAT (FROM, DELIM, PAT)
  228. CHAR *FROM, *PAT;
  229. █
  230.    CHAR *I, *J, *LASTJ, *LJ, *ADDSET();
  231.    INT LASTCL;
  232.  
  233.    J = PAT;
  234.    LASTJ = PAT;
  235.    LASTCL = 0;
  236.    FOR (I=FROM; *I; I++) █
  237.       LJ = J;
  238.       IF (*I == ┴╬┘)
  239.          J = ADDSET (┴╬┘, J);
  240.       ELSE IF (*I == ┬╧╠ && I == FROM)
  241.          J = ADDSET (┬╧╠, J);
  242.       ELSE IF (*I == ┼╧╠ && *(I+1)==DELIM)
  243.          J = ADDSET (┼╧╠, J);
  244.       ELSE IF (*I == ├├╠) █
  245.          INT TMP;
  246.          TMP = GETCCL (I, J);
  247.          I = IRET;
  248.          J = JRET;
  249.          IF (TMP == ┼╥╥)
  250.             BREAK;
  251.          ▌
  252.       ELSE IF (*I == ├╠╧╙╒╥┼ && I > FROM) █
  253.          LJ = LASTJ;
  254.          IF (*LJ == ┬╧╠ ▀▀ *LJ == ┼╧╠ ▀▀ *LJ == ├╠╧╙╒╥┼)
  255.             BREAK;
  256.          LASTCL = STCLOS (PAT, J, LASTJ, LASTCL);
  257.          J = JRET;
  258.          LASTJ = IRET;
  259.          ▌
  260.       ELSE █
  261.          J = ADDSET (├╚╥, J);
  262.          J = ADDSET (ESC(I), J);
  263.          I = IRET;
  264.          ▌
  265.       LASTJ = LJ;
  266.       ▌
  267.    IF (*I != DELIM)
  268.       RETURN ┼╥╥;
  269.    ADDSET (┼╧╙, J);
  270.    RETURN ╧╦;
  271. ▌
  272.  
  273. GETCCL (I, J)
  274. CHAR *I, *J;
  275. █
  276.    CHAR *ADDSET(), *FILSET();
  277.    CHAR *JSTART;
  278.  
  279.    IF (*++I == ╬╧╘) █
  280.       J = ADDSET (╬├├╠, J);
  281.       I++;
  282.       ▌
  283.    ELSE
  284.       J = ADDSET (├├╠, J);
  285.    JSTART = J;
  286.    J = ADDSET (0, J);
  287.    J = FILSET (├├╠┼╬─, I, J);
  288.    I = IRET;
  289.    *JSTART = J - JSTART - 1;
  290.    JRET = J;
  291.    IF (*I == ├├╠┼╬─)
  292.       RETURN ╧╦;
  293.    RETURN ┼╥╥;
  294. ▌
  295.  
  296. STCLOS (PAT, J, LASTJ, LASTCL)
  297. CHAR *PAT, *J, *LASTJ;
  298. █
  299.    CHAR *JP, *ADDSET();
  300.  
  301.    FOR (JP=J-1; JP >= LASTJ; JP--)
  302.       ADDSET (*JP, JP+├╠╧╙╔┌┼);
  303.    J += ├╠╧╙╔┌┼;
  304.    JP = LASTJ;
  305.    LASTJ = ADDSET (├╠╧╙╒╥┼, LASTJ);
  306.    LASTJ = ADDSET (0, LASTJ);
  307.    LASTJ = ADDSET (LASTCL, LASTJ);
  308.    LASTJ = ADDSET (0, LASTJ);
  309.    JRET = J;
  310.    IRET = LASTJ;
  311.    RETURN (JP - PAT + 1);
  312. ▌
  313.  
  314. CHAR *FILSET (DELIM, I, J)
  315. CHAR *I, *J;
  316. █
  317.    STATIC CHAR DIGITS[] = "0123456789";
  318.    STATIC CHAR LOWALF[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  319.    STATIC CHAR UPALF[]  = "┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌";
  320.    CHAR *ADDSET();
  321.    UNSIGNED INDEX();
  322.  
  323.    FOR (; *I != DELIM && *I != ┼╧╙; I++)
  324.       IF (*I == ┼╙├┴╨┼) █
  325.          J = ADDSET (ESC(I), J);
  326.          I = IRET;
  327.          ▌
  328.       ELSE IF (*I != ─┴╙╚)
  329.          J = ADDSET (*I, J);
  330.       ELSE IF (INDEX (DIGITS, *(J-1)) > 0) █
  331.          DODASH (DIGITS, I, J);
  332.          I = IRET;
  333.          J = JRET;
  334.          ▌
  335.       ELSE IF (INDEX (LOWALF, *(J-1)) > 0) █
  336.          DODASH (LOWALF, I, J);
  337.          I = IRET;
  338.          J = JRET;
  339.          ▌
  340.       ELSE IF (INDEX (UPALF, *(J-1)) > 0) █
  341.          DODASH (UPALF, I, J);
  342.          I = IRET;
  343.          J = JRET;
  344.          ▌
  345.       ELSE
  346.          J = ADDSET (─┴╙╚, J);
  347.       IRET = I;
  348.       RETURN J;
  349. ▌
  350.  
  351. ESC(I)
  352. CHAR *I;
  353. █
  354.    IRET = I;
  355.    IF (*I != ┼╙├┴╨┼)
  356.       RETURN *I;
  357.    IF (*(I+1) == ┼╧╙)
  358.       RETURN ┼╙├┴╨┼;
  359.    IRET = ++I;
  360.    IF (*I == 'N')
  361.       RETURN '\N';
  362.    RETURN *I;
  363. ▌
  364.  
  365. DODASH (VALID, I, J)
  366. CHAR *VALID, *I, *J;
  367. █
  368.    UNSIGNED K, LIMIT, INDEX();
  369.  
  370.    I++;
  371.    J--;
  372.    LIMIT = INDEX (VALID, ESC(I));
  373.    FOR (K = INDEX(VALID, *J); K <= LIMIT; K++)
  374.       J = ADDSET (VALID[K-1], J);
  375.    JRET = J;
  376. ▌
  377.  
  378. CHAR *ADDSET (C, J)
  379. CHAR *J;
  380. █
  381.    *J++ = C;
  382.    RETURN J;
  383. ▌
  384.  
  385. UNSIGNED INDEX (STR, C)
  386. CHAR *STR;
  387. █
  388.    CHAR *I;
  389.  
  390.    FOR (I = STR; *I; I++)
  391.       IF (*I == C)
  392.          RETURN (I - STR + 1);
  393.    RETURN 0;
  394. ▌
  395.  
  396.