home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / edit / microspe / quick.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-06-26  |  6.6 KB  |  317 lines
  1. /*    QUICK:    Quicksort module for MicroSPELL 2.0
  2.         Spell Checker and Corrector
  3.  
  4.         (C)opyright May 1987,1992 by Daniel Lawrence
  5.         All Rights Reserved
  6. */
  7.  
  8. #include    <stdio.h>
  9. #include    "dopt.h"
  10. #include    "dstruct.h"
  11. #include    "ddef.h"
  12.  
  13. possort()    /* sort the current wordlist on position order */
  14.  
  15. {
  16.     int cmppos();
  17.     static WORD lastpos =        /* infinite key */
  18.         {32767, 32767, 32767, 0xFF};
  19.  
  20.     /* set comparison routines to check positions */
  21.     comp = &cmppos;
  22.  
  23.     /* make sure there is a "infinite" key at the end */
  24.     sword[numwords] = &lastpos;
  25.  
  26.     /* and sort them */
  27.     quick(0, numwords - 1);
  28. }
  29.  
  30. wordsort()    /* sort the current wordlist on word order */
  31.  
  32. {
  33.     int cmpnam();
  34.  
  35.     static WORD lastalpha =        /* infinite key */
  36.         {0, 0, 0, 0xFF};
  37.     /* this is the rest of the lastalpha key....make sure it is
  38.        right after last alpha */
  39.  
  40.     /* set comparison routines to check names */
  41.     comp = &cmpnam;
  42.  
  43.     /* make sure there is a "infinite" key at the end */
  44.     sword[numwords] = &lastalpha;
  45.  
  46.     /* and sort them */
  47.     quick(0, numwords - 1);
  48. }
  49.  
  50. comsort()    /* sort the common word list alphabetically */
  51.  
  52. {
  53.     /* make sure there is a "infinite" key at the end */
  54.     cword[numfiltr] = hivalue;
  55.  
  56.     /* and sort them */
  57.     uquick(0, numfiltr - 1);
  58. }
  59.  
  60. quick(lower, upper)    /* quicksort part of the word list */
  61.  
  62. int lower;    /* lowermost element to sort */
  63. int upper;    /* uppermost element to sort */
  64.  
  65. {
  66.     int testkey;    /* key used to compare items */
  67.     int i, j;    /* quicksort partitioning pointers */
  68.     WORD *t;    /* temp pointer into word list */
  69.  
  70.     /* if we have less than 9 items...bubble sort them */
  71.     if ((upper - lower) < 9) {
  72.         slow(lower, upper);
  73.         return;
  74.     }
  75.  
  76.     /* swap the middle item for the first...*/
  77.     testkey = (upper - lower) / 2 + lower;
  78.     t = sword[testkey];
  79.     sword[testkey] = sword[lower];
  80.     sword[lower] = t;    
  81.  
  82.     /* set up the pointers and prepare to partition */
  83.     testkey = lower;
  84.     i = lower;
  85.     j = upper + 1;
  86.  
  87.     /* and partition the subfile */
  88.     while (i < j) {
  89.  
  90.         /* scan to the right */
  91.         i++;
  92.         while ((*comp)(i, testkey) < 0)
  93.             i++;
  94.  
  95.         /* scan to the left */
  96.         j--;
  97.         while ((*comp)(j, testkey) > 0)
  98.             j--;
  99.  
  100.         /* switch em if appropriate */
  101.         if (i < j) {
  102.             t = sword[i];
  103.             sword[i] = sword[j];
  104.             sword[j] = t;
  105.         }
  106.     }
  107.     /* and now swap the testkey between the two partitions */
  108.     t = sword[j];
  109.     sword[j] = sword[testkey];
  110.     sword[testkey] = t;
  111.  
  112.     /* and sort the resulting partitions */
  113.     quick(lower, j - 1);
  114.     quick(j + 1, upper);
  115. }
  116.  
  117. slow(lower, upper)    /* do a straight bubble sort on a small subfile */
  118.  
  119. int lower;    /* lower limit */
  120. int upper;    /* upper limit */
  121.  
  122. {
  123.     int i, j;    /* ptrs in sort */
  124.     WORD *t;    /* temp value for an exchange */
  125.     int swapflag;    /* was there a swap? */
  126.  
  127.     /* make sure this is needed */
  128.     if (upper <= lower)
  129.         return;
  130.  
  131.     /* sort the suckers */
  132.     for (i = upper; i > lower; i--) {
  133.         swapflag = FALSE;
  134.         for (j = lower; j < i; j++)
  135.             if ((*comp)(j, j+1) > 0) {
  136.                 swapflag = TRUE;
  137.                 t = sword[j+1];
  138.                 sword[j+1] = sword[j];
  139.                 sword[j] = t;
  140.             }
  141.         if (swapflag == FALSE)
  142.             return;
  143.     }
  144. }
  145.  
  146. int cmpnam(n1, n2)    /* compare the text of two source words */
  147.  
  148. int n1, n2;        /* pointer to words to compare */
  149.  
  150. {
  151.     return(lowcmp(sword[n1]->w_text, sword[n2]->w_text));
  152. }
  153.  
  154. int cmppos(n1, n2)    /* compare the position of two source words */
  155.  
  156. int n1, n2;        /* pointer to words to compare */
  157.  
  158. {
  159.     WORD *p1, *p2;    /* ptr to the two words in question */
  160.  
  161.     /* grab the two word pointers */
  162.     p1 = sword[n1];
  163.     p2 = sword[n2];
  164.  
  165.     if (p1->w_file > p2->w_file)
  166.         return(1);
  167.  
  168.     if (p1->w_file < p2->w_file)
  169.         return(-1);
  170.  
  171.     if (p1->w_line > p2->w_line)
  172.         return(1);
  173.  
  174.     if (p1->w_line < p2->w_line)
  175.         return(-1);
  176.  
  177.     if (p1->w_col > p2->w_col)
  178.         return(1);
  179.  
  180.     if (p1->w_col < p2->w_col)
  181.         return(-1);
  182.  
  183.     return(0);
  184. }
  185.  
  186. uquick(lower, upper)    /* quicksort part of the common word list */
  187.  
  188. int lower;    /* lowermost element to sort */
  189. int upper;    /* uppermost element to sort */
  190.  
  191. {
  192.     int testkey;    /* key used to compare items */
  193.     int i, j;    /* quicksort partitioning pointers */
  194.     char *t;    /* temp pointer into common word list */
  195.  
  196.     /* if we have less than 9 items...bubble sort them */
  197.     if ((upper - lower) < 9) {
  198.         uslow(lower, upper);
  199.         return;
  200.     }
  201.  
  202.     /* swap the middle item for the first...*/
  203.     testkey = (upper - lower) / 2 + lower;
  204.     t = cword[testkey];
  205.     cword[testkey] = cword[lower];
  206.     cword[lower] = t;    
  207.  
  208.     /* set up the pointers and prepare to partition */
  209.     testkey = lower;
  210.     i = lower;
  211.     j = upper + 1;
  212.  
  213.     /* and partition the subfile */
  214.     while (i < j) {
  215.  
  216.         /* scan to the right */
  217.         i++;
  218.         while (lowcmp(cword[i], cword[testkey]) < 0)
  219.             i++;
  220.  
  221.         /* scan to the left */
  222.         j--;
  223.         while (lowcmp(cword[j], cword[testkey]) > 0)
  224.             j--;
  225.  
  226.         /* switch em if appropriate */
  227.         if (i < j) {
  228.             t = cword[i];
  229.             cword[i] = cword[j];
  230.             cword[j] = t;
  231.         }
  232.     }
  233.     /* and now swap the testkey between the two partitions */
  234.     t = cword[j];
  235.     cword[j] = cword[testkey];
  236.     cword[testkey] = t;
  237.  
  238.     /* and sort the resulting partitions */
  239.     uquick(lower, j - 1);
  240.     uquick(j + 1, upper);
  241. }
  242.  
  243. uslow(lower, upper)    /* do a straight bubble sort on a small subfile */
  244.  
  245. int lower;    /* lower limit */
  246. int upper;    /* upper limit */
  247.  
  248. {
  249.     int i, j;    /* ptrs in sort */
  250.     char *t;    /* temp value for an exchange */
  251.     int swapflag;    /* did a swap occur? */
  252.  
  253.     /* make sure this is needed */
  254.     if (upper <= lower)
  255.         return;
  256.  
  257.     /* sort the suckers */
  258.     for (i = upper; i > lower; i--) {
  259.         swapflag = FALSE;
  260.         for (j = lower; j < i; j++)
  261.             if (lowcmp(cword[j], cword[j+1]) > 0) {
  262.                 swapflag = TRUE;
  263.                 t = cword[j+1];
  264.                 cword[j+1] = cword[j];
  265.                 cword[j] = t;
  266.             }
  267.         if (swapflag == FALSE)
  268.             return;
  269.     }
  270. }
  271.  
  272. #if    EBCDIC
  273. /*    if we are using the EBCDIC character set, spell, to operate
  274.     properly in regards to uppercase words in the merge() phase
  275.     MUST have uppercase sort higher then lower. To effect this,
  276.     we slip in the replacement to the library strcmp() function.
  277. */
  278.  
  279. strcmp(s, t)
  280.  
  281. char *s, *t;    /* two strings to compare with reversed case */
  282.  
  283. {
  284.     register char s1, t1;    /* current chars in s and t */
  285.     register int cresult;    /* result of current copmparison */
  286.  
  287.     /* scan through the strings */
  288.     while (*s) {
  289.         /* record the current characters */
  290.         s1 = *s;
  291.         t1 = *t;
  292.  
  293.         /* swap the case on them */
  294.         if (isletter(s1))
  295.             s1 ^= 0x40;
  296.         if (isletter(t1))
  297.             t1 ^= 0x40;
  298.  
  299.         /* compare them and return value if unequal */
  300.         cresult = s1 - t1;
  301.         if (cresult != 0)
  302.             return(cresult);
  303.  
  304.         /* advance to the next charector */
  305.         ++s;
  306.         ++t;
  307.     }
  308.  
  309.     /* if there is anything left of t it is greater */
  310.     if (*t)
  311.         return(-1);
  312.  
  313.     /* they are the same! */
  314.     return(0);
  315. }
  316. #endif
  317.