home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: Product / Product.zip / ISPSRC.ZIP / subset.X < prev    next >
Encoding:
Text File  |  1992-08-14  |  5.4 KB  |  194 lines
  1. : Use /bin/sh
  2. #
  3. # $Id: subset.X,v 1.9 1992/01/09 09:29:53 geoff Exp $
  4. #
  5. # Copyright 1987, 1988, 1989, by Geoff Kuenning, Manhattan Beach, CA
  6. # Permission for non-profit use is hereby granted.
  7. # All other rights reserved.
  8. # See "version.h" for a more complete copyright notice.
  9. #
  10. # $Log: subset.X,v $
  11. # Revision 1.9  1992/01/09  09:29:53  geoff
  12. # Fix a typo and a tiny documentation error.
  13. #
  14. # Revision 1.8  91/07/27  20:48:35  geoff
  15. # Improve the commentary and the usage message.  Just for neatness,
  16. # generate dict.0 first rather than last.  Remove intermediate
  17. # dictionaries from the temp directory as they are used up.
  18. # 
  19. # Revision 1.7  91/06/12  19:15:20  geoff
  20. # Remember to exit after issuing a usage message.  Add some warnings about
  21. # anomalous behaviors of the script under semi-error conditions.
  22. # 
  23. # Revision 1.6  89/04/28  01:17:08  geoff
  24. # Change Header to Id;  nobody cares about my pathnames.
  25. # 
  26. # Revision 1.5  89/04/27  23:34:16  geoff
  27. # Add (untested) support for a selectable flag marker.
  28. # 
  29. # Revision 1.4  88/12/26  02:32:22  geoff
  30. # Update the copyright notice.
  31. # 
  32. # Revision 1.3  88/03/30  00:15:01  geoff
  33. # Replace the -d switch with the -l switch.
  34. # 
  35. # Revision 1.2  88/02/20  23:14:34  geoff
  36. # Get rid of icombine.  Fix some typos.  Use a better temp file name.
  37. # Run munchlist on the output dictionaries.
  38. # 
  39. # Revision 1.1  87/09/25  00:28:20  geoff
  40. # Initial revision
  41. # 
  42. #
  43. #    Combine and resolve various dictionaries so they are proper
  44. #    subsets of one another, and so that maximal use is made of
  45. #    flags in the smaller ones.
  46. #
  47. #    Usage:
  48. #
  49. #    subset [-b base] [-l langfile] small-dict bigger-dict ... biggest-dict
  50. #
  51. #    The output is a an equal number of successively-larger
  52. #    dictionaries.  The smallest is written to "dict.0".  Successive
  53. #    files are named "dict.1", "dict.2", and so forth, and each contains
  54. #    a list of words which should be added to the previous files to
  55. #    generate a dictionary.  Words which are in smaller dictionaries are
  56. #    effectively propagated to the larger ones, so that the smaller ones
  57. #    are proper subsets of their siblings.  If dictionaries are
  58. #    completely disjoint, this may result in an empty output dictionary.
  59. #    Affix flags are propagated to the smallest dictionary containing
  60. #    the root word;  this expands the effectiveness of small dictionaries
  61. #    at no cost in hash table space.
  62. #
  63. #    The -b switch is used to specify a different base name for the
  64. #    output files than "dict".  (In other words, "-b english" would
  65. #    produce output in english.0, english.1, etc.).
  66. #
  67. #    If the -l switch is specified, the language tables are gotten
  68. #    from the specified file;  otherwise they come from $LIBDIR/!!DEFLANG!!.
  69. #
  70. #    Input dictionaries should be "clean";  if non-word characters
  71. #    appear in the dictionaries, the script may produce incorrect output.
  72. #
  73. LIBDIR=!!LIBDIR!!
  74. TDIR=${TMPDIR-/usr/tmp}
  75. TMP=${TDIR}/sset$$.
  76. SORTTMP="-T ${TDIR}"            # !!SORTTMP!!
  77. USAGE="Usage:  subset [-b base] [-l langfile] dict-0 dict-1 ..."
  78.  
  79. langtabs=${LIBDIR}/!!DEFLANG!!
  80. outbase=dict
  81. while :
  82. do
  83.     case "$1" in
  84.     -b)
  85.         outbase="$2"
  86.         shift; shift
  87.         ;;
  88.     -l)
  89.         langtabs="$2"
  90.         shift; shift
  91.         ;;
  92.     -*)
  93.         echo "$USAGE" 1>&2
  94.         exit 1
  95.         ;;
  96.     *)
  97.         break
  98.         ;;
  99.     esac
  100. done
  101.  
  102. if [ $# -lt 2 ]
  103. then
  104.     echo "$USAGE" 1>&2
  105.     exit 1
  106. fi
  107.  
  108. # Temp files
  109. MUNCHOUTPUT=${TMP}a
  110. MISSINGWORDS=${TMP}b
  111. TEMPDICT=${TMP}c
  112. FAKEDICT=${TMP}d
  113. FAKEHASH=${TMP}e.hash
  114.  
  115. trap "/bin/rm -f ${TMP}*; exit 1" 1 2 15
  116. trap "/bin/rm -f ${TMP}*; exit 0" 13
  117.  
  118. #
  119. # Create a dummy dictionary to hold a compiled copy of the language
  120. # tables.
  121. #
  122. echo 'QQQQQQQQ' > $FAKEDICT
  123. buildhash -s $FAKEDICT $langtabs $FAKEHASH \
  124.   ||  (echo "Couldn't create fake hash file" 1>&2; /bin/rm -f ${TMP}*; exit 1) \
  125.   ||  exit 1
  126. /bin/rm -f ${FAKEDICT}*
  127. #
  128. # Figure out what the flag-marking character is.
  129. #
  130. flagmarker=`ispell -D -d $FAKEHASH \
  131.   | sed -n '/^flagmarker/s/flagmarker //p'`
  132. case "$flagmarker" in
  133.     \\*)
  134.     flagmarker=`expr "$flagmarker" : '.\(.\)'`
  135.     ;;
  136. esac    
  137. #
  138. #    (1) Use munchlist to create a list of roots and maximal suffixes.
  139. #
  140. munchlist -l $langtabs "$@" | sort $SORTTMP > $MUNCHOUTPUT
  141. #
  142. #    (2) Use join to add the maximal suffixes to each dictionary's roots.
  143. #        Re-expand this, combine with the original, and save for later.
  144. #
  145. newline='
  146. '
  147. dictno=0
  148. for dictfile
  149. do
  150.     ispell -e -d $FAKEHASH < $dictfile | tr ' ' "$newline" \
  151.       | sort -u $SORTTMP | join "-t$flagmarker" -a1 - $MUNCHOUTPUT \
  152.       | ispell -e -d $FAKEHASH | tr ' ' "$newline" \
  153.       | sort -u $SORTTMP > ${TEMPDICT}.$dictno
  154.     dictno=`expr $dictno + 1`
  155. done
  156. /bin/rm -f $MUNCHOUTPUT
  157. #
  158. #    (3) For each adjacent pair of dictionaries, use comm to find words
  159. #        in the smaller that are missing from the larger, and add them
  160. #        to the larger.
  161. #
  162. firstdict="$1"
  163. shift
  164. lastdict="${TEMPDICT}.0"
  165. dictno=1
  166. for dictfile
  167. do
  168.     comm -23 $lastdict ${TEMPDICT}.$dictno > $MISSINGWORDS.$dictno
  169.     if [ -s $MISSINGWORDS.$dictno ]
  170.     then
  171.     sort $SORTTMP -o ${TEMPDICT}.$dictno \
  172.       ${TEMPDICT}.$dictno $MISSINGWORDS.$dictno
  173.     fi
  174.     lastdict="${TEMPDICT}.$dictno"
  175.     dictno=`expr $dictno + 1`
  176. done
  177. /bin/rm -f $MISSINGWORDS.*
  178. #
  179. #    (4) For each pair of dictionaries, use comm to eliminate words in
  180. #        the smaller from the larger, and shrink the result with munchlist.
  181. #
  182. munchlist ${TEMPDICT}.0 > $outbase.0
  183. lastdict="${TEMPDICT}.0"
  184. dictno=1
  185. for dictfile
  186. do
  187.     comm -13 $lastdict ${TEMPDICT}.$dictno \
  188.       | munchlist -l $langtabs > $outbase.$dictno
  189.     /bin/rm -f $lastdict
  190.     lastdict="${TEMPDICT}.$dictno"
  191.     dictno=`expr $dictno + 1`
  192. done
  193. /bin/rm -f ${TMP}*
  194.