home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c410 / 1.ddi / LEX / LEXSRT.C < prev    next >
Encoding:
C/C++ Source or Header  |  1980-01-01  |  4.1 KB  |  162 lines
  1. /*
  2.   HEADER:              CUG  nnn.nn;
  3.   TITLE:               LEX - A Lexical Analyser Generator
  4.   VERSION:             1.1 for IBM-PC
  5.   DATE:                Jan 30, 1985
  6.   DESCRIPTION:         A Lexical Analyser Generator. From UNIX
  7.   KEYWORDS:            Lexical Analyser Generator YACC C PREP
  8.   SYSTEM:              IBM-PC and Compatiables
  9.   FILENAME:            LEXSRT.C
  10.   WARNINGS:            This program is not for the casual user. It will
  11.                        be useful primarily to expert developers.
  12.   CRC:                 N/A
  13.   SEE-ALSO:            YACC and PREP
  14.   AUTHORS:             Charles H. Forsyth
  15.                        Scott Guthery 11100 leafwood lane Austin, TX 78750
  16.                        Andrew M. Ward, Jr.  Houston, Texas (Modifications)
  17.   COMPILERS:           LATTICE C
  18.   REFERENCES:          UNIX Systems Manuals -- Lex Manual on distribution disks
  19. */
  20. /*
  21.  * Modified 22-Jun-86 Andrew Ward -- Modified code to compile under Lattice C
  22.  *                                 version 3.0h. Modified code to use LATTICE
  23.  *                    sort functions and argument type checking.
  24.  */
  25. /*
  26.  * Quick Sort: Used when builtin function not available
  27.  */
  28. #define LATTICE
  29.  
  30. #ifdef LATTICE
  31. extern  void q_exc( char *, char * );
  32. extern  void q_tex( char *, char *, char * );
  33. #else
  34. extern  void q_exc();
  35. extern  void q_tex();
  36. #endif
  37. extern  void q_sort();
  38. static  int     size;
  39. int     (*qs__cmp)();
  40.  
  41. #ifndef LATTICE
  42.  
  43. void qsort(a, n, es, fc) /* Lattice qsort function used when available */
  44. char *a;
  45. int n, es;
  46. int (*fc)();
  47. {
  48.         qs__cmp = fc;
  49.         size = es;
  50.         q_sort(a, a+n*es);
  51. }
  52.  
  53. #endif
  54.  
  55. void q_sort(a, l)
  56. char *a, *l;
  57. {
  58.        char *i, *j;
  59.        int es;
  60.        char *lp, *hp;
  61.        int n, c;
  62.  
  63.        es = size;
  64.  
  65. start:
  66.        if((n=l-a) <= es)
  67.                return;
  68.        n = es * ( n/(2*es));
  69.        hp = lp = a+n;
  70.        i = a;
  71.        j = l-es;
  72.        for(;;) {
  73.                if(i < lp) {
  74.                        if((c = (*qs__cmp)(i, lp)) == 0) {
  75.                                q_exc(i, lp -= es);
  76.                                continue;
  77.                        }
  78.                        if(c < 0) {
  79.                                i += es;
  80.                                continue;
  81.                        }
  82.                }
  83.  
  84. loop:
  85.                if(j > hp) {
  86.                        if((c = (*qs__cmp)(hp, j)) == 0) {
  87.                                q_exc(hp += es, j);
  88.                                goto loop;
  89.                        }
  90.                        if(c > 0) {
  91.                                if(i == lp) {
  92.                                        q_tex(i, hp += es, j);
  93.                                        i = lp += es;
  94.                                        goto loop;
  95.                                }
  96.                                q_exc(i, j);
  97.                                j -= es;
  98.                                i += es;
  99.  
  100.                                continue;
  101.                        }
  102.                        j -= es;
  103.                        goto loop;
  104.                }
  105.  
  106.  
  107.                if(i == lp) {
  108.                        if(lp-a >= l-hp) {
  109.                                q_sort(hp+es, l);
  110.                                l = lp;
  111.                        } else {
  112.                                q_sort(a, lp);
  113.                                a = hp+es;
  114.                        }
  115.                        goto start;
  116.                }
  117.                q_tex(j, lp -= es, i);
  118.                j = hp -= es;
  119.        }
  120. }
  121.  
  122. void q_exc(i, j)
  123. char *i, *j;
  124. {
  125.        char *ri, *rj, c;
  126.        int n;
  127.  
  128.        n = size;
  129.        ri = i;
  130.        rj = j;
  131.        do {
  132.                c = *ri;
  133.                *ri++ = *rj;
  134.                *rj++ = c;
  135.        } while(--n);
  136. }
  137.  
  138. void q_tex(i, j, k)
  139. char *i, *j, *k;
  140. {
  141.        char *ri, *rj, *rk;
  142.        int c;
  143.        int n;
  144.  
  145.        n = size;
  146.        ri = i;
  147.        rj = j;
  148.        rk = k;
  149.        do {
  150.                c = *ri;
  151.                *ri++ = *rk;
  152.                *rk++ = *rj;
  153.                *rj++ = c;
  154.        } while(--n);
  155. }
  156.  
  157.  
  158.  
  159.  
  160.  
  161.  
  162.