home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3580 < prev    next >
Text File  |  1991-07-02  |  20KB  |  608 lines

  1. Newsgroups: alt.sources
  2. From: goer@ellis.uchicago.edu (Richard L. Goerwitz)
  3. Subject: kjv browser, part 4 of 11
  4. Message-ID: <1991Jul3.065038.28067@midway.uchicago.edu>
  5. Date: Wed, 3 Jul 1991 06:50:38 GMT
  6.  
  7. ---- Cut Here and feed the following to sh ----
  8. #!/bin/sh
  9. # this is bibleref.04 (part 4 of a multipart archive)
  10. # do not concatenate these parts, unpack them in order with /bin/sh
  11. # file binsrch.icn continued
  12. #
  13. if test ! -r _shar_seq_.tmp; then
  14.     echo 'Please unpack part 1 first!'
  15.     exit 1
  16. fi
  17. (read Scheck
  18.  if test "$Scheck" != 4; then
  19.     echo Please unpack part "$Scheck" next!
  20.     exit 1
  21.  else
  22.     exit 0
  23.  fi
  24. ) < _shar_seq_.tmp || exit 1
  25. if test ! -f _shar_wnt_.tmp; then
  26.     echo 'x - still skipping binsrch.icn'
  27. else
  28. echo 'x - continuing file binsrch.icn'
  29. sed 's/^X//' << 'SHAR_EOF' >> 'binsrch.icn' &&
  30. X#
  31. X#  This file contains a single procedure, binary_index_search(str,
  32. X#  filename), which goes through a file called filename looking for a
  33. X#  line beginning with str.  Note well that binary_index_search()
  34. X#  assumes lines in filename will contain more than str.  Str must
  35. X#  occupy the first part of the line, separated from the remainder by
  36. X#  a tab.
  37. X#
  38. X############################################################################
  39. X#
  40. X#  Links: none
  41. X#
  42. X#  See also: retrieve.icn, makeind.icn
  43. X#
  44. X############################################################################
  45. X
  46. X
  47. Xprocedure binary_index_search(entry, index_filename)
  48. X
  49. X    local in_index, bottom, top, loc, incr, firstpart, offset
  50. X
  51. X    in_index := open(index_filename) |
  52. X    abort("binary_index_search","can't open "||index_filename,18)
  53. X
  54. X    bottom := 1
  55. X    seek(in_index, 0)
  56. X    top := where(in_index)
  57. X
  58. X    # If bottom gets bigger than top, there's no such entry.
  59. X    until bottom > top do {
  60. X
  61. X    loc := (top+bottom) / 2
  62. X    seek(in_index, loc)
  63. X
  64. X    # Move past next newline.  If at bottom, break.
  65. X    incr := 1
  66. X    until reads(in_index) == "\n" do
  67. X        incr +:= 1
  68. X    if loc+incr = bottom then {
  69. X        top := loc-1
  70. X        next
  71. X    }
  72. X
  73. X    # Check to see if the current line starts with entry (arg 1).
  74. X    read(in_index) ? {
  75. X
  76. X        # .IND file line format is entry\tbitmap-file-offset
  77. X        if entry == (firstpart := tab(find("\t"))) then {
  78. X        # return offset
  79. X        return (move(1), tab(0))
  80. X        }
  81. X        # Ah, this is what all binary searches do.
  82. X        else {
  83. X        if entry << firstpart
  84. X        then top := loc-1
  85. X        else bottom := loc + incr + *&subject
  86. X        }
  87. X    }
  88. X    }
  89. X
  90. Xend
  91. SHAR_EOF
  92. echo 'File binsrch.icn is complete' &&
  93. true || echo 'restore of binsrch.icn failed'
  94. rm -f _shar_wnt_.tmp
  95. fi
  96. # ============= bmp2text.icn ==============
  97. if test -f 'bmp2text.icn' -a X"$1" != X"-c"; then
  98.     echo 'x - skipping bmp2text.icn (File already exists)'
  99.     rm -f _shar_wnt_.tmp
  100. else
  101. > _shar_wnt_.tmp
  102. echo 'x - extracting bmp2text.icn (Text)'
  103. sed 's/^X//' << 'SHAR_EOF' > 'bmp2text.icn' &&
  104. X############################################################################
  105. X#
  106. X#    Name:     bmp2text.icn
  107. X#
  108. X#    Title:     convert a bitmap to a text-chunk
  109. X#
  110. X#    Author:     Richard L. Goerwitz
  111. X#
  112. X#    Version: 1.12
  113. X#
  114. X############################################################################
  115. X#
  116. X#  This file contains bitmap_2_text(bitmap, filename).  Recall that
  117. X#  bitmaps are just a series of fixed-length bitfields used to mark
  118. X#  divisions within a text.  The procedure retrieve() finds words in
  119. X#  an index file, and returns a list of these bitmaps, which point to
  120. X#  divisions within the original text file - divisions within which a
  121. X#  given indexed word found by retrieve() occurs.  The procedure
  122. X#  bitmap_2_filename() simply takes a given bitmap and finds the text
  123. X#  with which it is associated in the full text file.
  124. X#
  125. X#  Note that bitmap_2_text() does not seek directly to the correct
  126. X#  location within "filename" (arg 2).  It first breaks down the
  127. X#  bitmap into a less precise form, looks up the location of that
  128. X#  form, seeks up to its location, and then bumbles along until it
  129. X#  reaches the chunk of text corresponding to the full "bitmap" (arg
  130. X#  1).  The reason bitmap_2_text() does this is that makeind (the
  131. X#  indexing routine which creates data files for retrieve() and
  132. X#  bitmap_2_text()) does not store the offset within filename for
  133. X#  every bitmap.  It just saves the locations of major blocks.  This
  134. X#  is basically just a space-saving device.  It would eat up too much
  135. X#  memory (both disk and core) to keep a list of every offset for
  136. X#  every chunk of text marked out by a bitmap in filename.
  137. X#
  138. X#  Note also that, although retrieve() returns a list of bitmaps, bit-
  139. X#  map_2_text(bitmap, filename) expects a single bitmap as its first
  140. X#  argument.  It is better that text be retrieved as needed, one chunk
  141. X#  at a time, and not stuffed en masse into core memory as soon as it
  142. X#  is retrieve()'d.
  143. X#
  144. X############################################################################
  145. X#
  146. X#  Links: ./indexutl.icn, ./initfile.icn
  147. X#
  148. X#  See also: retrieve.icn, makeind.icn
  149. X#
  150. X############################################################################
  151. X
  152. X# Declared in indexutl.icn.
  153. X# record is(FS, s_len, len, no, is_case_sensitive)
  154. X# global IS
  155. X
  156. X# Declared in initfile.icn.
  157. X# global filestats
  158. X# record Fs(ind_filename, bmp_filename, lim_filename, IS, ofs_table)
  159. X
  160. Xprocedure bitmap_2_text(bitmap, filename)
  161. X
  162. X    local intext, cut_down_bitmap, upto_field, offset, line, value,
  163. X    base_value_mask, base_value, location
  164. X    static t
  165. X    # global filestats, IS
  166. X    initial t := table()
  167. X
  168. X    # Check for sloppy programming.
  169. X    /filename & abort("bitmap_2_text","you called me without a filename",29)
  170. X
  171. X    # If necessary, initialize stats for the current file.
  172. X    #
  173. X    if /filestats | /filestats[filename]
  174. X    then initfile(filename)           # see initfile.icn
  175. X    # Reset IS to current file.
  176. X    IS := filestats[filename].IS
  177. X
  178. X    # open full text file for reading
  179. X    intext := open(filename) |
  180. X    abort("bitmap_2_text", "can't open "||filename, 26)
  181. X
  182. X    # Determine offset to seek to by using the bitmap->offset table
  183. X    # for the current file (arg 2).  The name of the bitmap_offset
  184. X    # table is stored in filestats[filename].ofs_table.
  185. X    #
  186. X    upto_field := 1 < (filestats[filename].IS.no * 2) / 3 | 1
  187. X    cut_down_bitmap := ishift(bitmap, -(IS.no - upto_field) * IS.len)
  188. X    offset := \filestats[filename].ofs_table[cut_down_bitmap] | fail
  189. X
  190. X    # Seek to offset, and begin looking for the string equiv. of
  191. X    # bitmap (arg 1).
  192. X    #
  193. X    seek(intext, offset) |
  194. X    abort("bitmap_2_text","can't seek to offset "||offset, 27)
  195. X
  196. X    #
  197. X    # This works a lot like the routine in gettext.icn (another related
  198. X    # retrieval package).  Note that bitmaps in "filename" (arg 2) are on
  199. X    # their own lines, preceded by a double colon.
  200. X    #
  201. X    # First figure out how to tell if we've gone too far.  Basically,
  202. X    # mask out the lower bits, and record the value of the upper bits.
  203. X    # Some fooling around is necessary because bitmaps may use large
  204. X    # ints, making it impossible to use icom() in a naive manner.
  205. X    # If the upper bits of the bitmaps being read change, then we've
  206. X    # gone too far.
  207. X    #
  208. X    base_value_mask := icom(2^((IS.no - upto_field) * IS.len)- 1)
  209. X    base_value := iand(bitmap, base_value_mask)
  210. X
  211. X    while line := read(intext) do {
  212. X    line ? {
  213. X        if ="::" then {
  214. X        location := digits_2_bitmap(tab(0)) # in indexutl.icn
  215. X        if bitmap = location
  216. X        then {
  217. X        # Collect all text upto the next colon+colon-initial
  218. X        # line (::) or EOF.
  219. X            value := ""
  220. X            while line := read(intext) do {
  221. X            match("::",line) & break
  222. X            value ||:= line || "\n"
  223. X            }
  224. X            # Note that a key with an empty value returns an
  225. X            # empty string.
  226. X            close(intext)
  227. X            return trim(value, '\n')
  228. X        }
  229. X        else {
  230. X            if base_value ~= iand(location, base_value_mask)
  231. X            then fail
  232. X        }
  233. X        }
  234. X    }
  235. X    }
  236. X
  237. X    # we should have returned by now
  238. X    close(intext)
  239. X    fail
  240. X
  241. Xend
  242. X
  243. SHAR_EOF
  244. true || echo 'restore of bmp2text.icn failed'
  245. rm -f _shar_wnt_.tmp
  246. fi
  247. # ============= initfile.icn ==============
  248. if test -f 'initfile.icn' -a X"$1" != X"-c"; then
  249.     echo 'x - skipping initfile.icn (File already exists)'
  250.     rm -f _shar_wnt_.tmp
  251. else
  252. > _shar_wnt_.tmp
  253. echo 'x - extracting initfile.icn (Text)'
  254. sed 's/^X//' << 'SHAR_EOF' > 'initfile.icn' &&
  255. X############################################################################
  256. X#
  257. X#    Name:     initfile.icn
  258. X#
  259. X#    Title:     initialize entry for file in filestats table
  260. X#
  261. X#    Author:     Richard L. Goerwitz
  262. X#
  263. X#    Version: 1.9
  264. X#
  265. X############################################################################
  266. X#
  267. X#  This file contains initfile(filename), which creates a set of stats
  268. X#  for the indexed database contained in filename.  Uses several global
  269. X#  structures, primarily for speed.  Beware.
  270. X#
  271. X############################################################################
  272. X#
  273. X#  See also: retrieve.icn, bmp2text.icn, retrops.icn
  274. X#
  275. X############################################################################
  276. X
  277. X# Used to store stats for each filename.
  278. Xrecord Fs(ind_filename, bmp_filename, lim_filename, IS, ofs_table)
  279. X
  280. X# IS is declared in indexutl.icn.
  281. X# global IS
  282. X
  283. Xglobal filestats
  284. X
  285. Xprocedure initfile(filename)
  286. X
  287. X    # Messy procedure which creates and stores the names of several
  288. X    # files that will be repeatedly used with "filename."  Reads in
  289. X    # the stats for filename from that file's .IS file.  Also reads in
  290. X    # the bitmap->offset (.OFS file) table, and puts it into
  291. X    # filestats[filename].ofs_table for later (re-)use.
  292. X
  293. X    local IS_filename, in_IS, upto_field, stored_bitmap_length,
  294. X    ofs_filename, intext, cut_down_bitmap, block_size, offset
  295. X    # global filestats
  296. X    initial {
  297. X    filestats := table()
  298. X    # OS-specific parameters are initialized here.
  299. X    initialize_os_params()    # in indexutl.icn
  300. X    }
  301. X
  302. X    # Check for sloppy programming.  Did we do this one already??
  303. X    if not (/filestats[filename] := Fs(,,,,table())) then fail
  304. X
  305. X    filestats[filename].ind_filename :=
  306. X    dir_name(filename)||create_fname(filename, "IND")
  307. X    filestats[filename].bmp_filename :=
  308. X    dir_name(filename)||create_fname(filename, "BMP")
  309. X    filestats[filename].lim_filename :=
  310. X    dir_name(filename)||create_fname(filename, "LIM")
  311. X
  312. X    # Decode stored IS record for filename.
  313. X    IS_filename := dir_name(filename)||create_fname(filename, "IS")
  314. X    in_IS := open(IS_filename) | abort("bitmap_2_text",
  315. X    "Can't open "||IS_filename||".  Did you forget to index?", 24)
  316. X    filestats[filename].IS := decode(!in_IS)
  317. X    close(in_IS)
  318. X    
  319. X    # Having decoded IS, we can now determine the length of the cut-
  320. X    # down bitmaps stored in the .OFS file for filename.
  321. X    upto_field := 1 < (filestats[filename].IS.no * 2) / 3 | 1
  322. X    stored_bitmap_length :=
  323. X    ((filestats[filename].IS.len * upto_field) <= seq(0,8))
  324. X
  325. X    # open .OFS file
  326. X    ofs_filename := dir_name(filename)||create_fname(filename, "OFS")
  327. X    intext := open(ofs_filename) |
  328. X    abort("bitmap_2_text", "can't open "||ofs_filename, 23)
  329. X    
  330. X    # read in blocks from .OFS file, breaking them into their
  331. X    # constituent parts
  332. X    while block_size := read_int(intext, 8) * 8 do {
  333. X    cut_down_bitmap := read_int(intext, stored_bitmap_length)
  334. X    offset := read_int(intext, block_size - stored_bitmap_length)
  335. X    insert(filestats[filename].ofs_table, cut_down_bitmap, offset)
  336. X    }
  337. X
  338. X    close(intext)
  339. X    # For lack of a better thing to return, return the size of
  340. X    # the internal bitmap->offset table for filename.
  341. X    return *filestats[filename].ofs_table
  342. X
  343. Xend
  344. SHAR_EOF
  345. true || echo 'restore of initfile.icn failed'
  346. rm -f _shar_wnt_.tmp
  347. fi
  348. # ============= retrieve.icn ==============
  349. if test -f 'retrieve.icn' -a X"$1" != X"-c"; then
  350.     echo 'x - skipping retrieve.icn (File already exists)'
  351.     rm -f _shar_wnt_.tmp
  352. else
  353. > _shar_wnt_.tmp
  354. echo 'x - extracting retrieve.icn (Text)'
  355. sed 's/^X//' << 'SHAR_EOF' > 'retrieve.icn' &&
  356. X############################################################################
  357. X#
  358. X#    Name:     retrieve.icn
  359. X#
  360. X#    Title:     retrieve locations of words in database file
  361. X#
  362. X#    Author:     Richard L. Goerwitz
  363. X#
  364. X#    Version: 1.13
  365. X#
  366. X############################################################################
  367. X#
  368. X#  Retrieve(pattern, filename) retrieves all locations containing
  369. X#  words matching pattern (arg1) in filename (arg2), placing them in a
  370. X#  list.  "Locations" are integer-coded pointers to places in filename
  371. X#  where corresponding text is located.  To actually retrieve that
  372. X#  block of text, you must call bitmap_2_text(location, filename).
  373. X#  Retrieve() only gathers up a list of locations in filename
  374. X#  containing words which match pattern.
  375. X#
  376. X#  The reason retrieve() doesn't do the logical thing - namely, to
  377. X#  "retrieve" text itself - is that doing so might use a *lot* of
  378. X#  memory.  It is far more economical to retrieve text only when a
  379. X#  given chunk is requested via bitmap_2_text().
  380. X#
  381. X#  The format for filename must conform to a simple, but strict, set
  382. X#  of guidelines.  Basically, it must interleave a series of keys
  383. X#  (so-called "bitmaps") with actual text:
  384. X#
  385. X#  ::001:001:001
  386. X#  This is text.
  387. X#  ::001:001:002
  388. X#  This is more text.
  389. X#
  390. X#  The lines beginning with :: (a double colon) are the keys.  These
  391. X#  translate into an integer dividable internally into (in this case)
  392. X#  three bit-fields of length 10 (enough to handle 999:999:999), which
  393. X#  serve as a location markers for the text that goes with them.  See
  394. X#  makeind.icn for a precise instructions on how to construct and index
  395. X#  files.
  396. X#
  397. X#  Note:  Patterns must match words in their entirety.  For instance,
  398. X#  retrieve("dog",filename) would only retrieve exact matches for the
  399. X#  word "dog" in filename.  To catch, say, "doggie" as well, it would
  400. X#  be necessary to call retrieve with a regular expression that
  401. X#  matched both dog and doggie (e.g. retrieve("dog.*",filename)).
  402. X#
  403. X############################################################################
  404. X#
  405. X#  Links: codeobj.icn, ./indexutl.icn, ./binsrch.icn, ./initfile.icn
  406. X#         ./findre.icn
  407. X#
  408. X#  See also: makeind.icn, bmp2text.icn
  409. X#
  410. X############################################################################
  411. X
  412. Xlink codeobj
  413. X
  414. X# The following globals contain stats for current file (here, arg2).
  415. X# global filestats    # declared in initfile.icn
  416. X# global IS           # declared in indexutl.icn
  417. X
  418. Xprocedure retrieve(pattern, filename, inverse)
  419. X
  420. X    local bitmap_list, bmp_file, in_egrep, intext, cmd, offset, line
  421. X    static is_UNIX, egrep_filename
  422. X    initial {
  423. X    if is_UNIX := find("UNIX",&features) then
  424. X        # If egrep is available, use it.  It's fast.
  425. X        egrep_filename := "egrep"
  426. X        # egrep_filename := "/usr/local/bin/gnuegrep"
  427. X    }
  428. X
  429. X    # Check for sloppy programming.
  430. X    /filename & abort("retrieve","you called me without a filename",22)
  431. X
  432. X    # Initialize important variables.
  433. X    #
  434. X    if /filestats | /filestats[filename]
  435. X    then initfile(filename)           # see initfile.icn
  436. X    bitmap_list := list()          # list will contain locations of hits
  437. X    IS := filestats[filename].IS      # re-initialize IS for current file
  438. X    if /IS.is_case_sensitive then
  439. X    pattern := map(pattern)
  440. X
  441. X    # Open bitmap file.
  442. X    #
  443. X    bmp_file := open(filestats[filename].bmp_filename) |
  444. X    abort("retrieve","can't open "||filestats[filename].bmp_filename, 29)
  445. X
  446. X    # Search index.
  447. X    #
  448. X    if are_metas(pattern) then {
  449. X    # NB: are_metas() can be found in indexutl.icn
  450. X
  451. X    # If there are metacharacters in pattern, do a regexp pattern match.
  452. X    # The .IND file goes:  line ::= key \t other-stuff.
  453. X    pattern := "^(" || pattern || ")\t"
  454. X
  455. X    # If UNIX, then use egrep to search index.
  456. X    #
  457. X    if \is_UNIX then {
  458. X
  459. X        # Set up command line to be passed to /bin/sh.  If
  460. X        # inverse is nonnull, invert the sense of the search
  461. X        # (i.e. egrep -v).
  462. X        if \inverse then {
  463. X        cmd := egrep_filename || "-v '" || pattern ||
  464. X            "' " || filestats[filename].ind_filename
  465. X        } else {
  466. X        cmd := egrep_filename || " '" || pattern ||
  467. X            "' " || filestats[filename].ind_filename
  468. X        }
  469. X        # open pipe
  470. X        in_egrep := open(cmd, "rp") |
  471. X        abort("retrieve","can't open pipe from\n\t"||cmd, 20)
  472. X        # grep .IND index file
  473. X        every line := !in_egrep do {
  474. X        line ? (tab(find("\t")+1), offset := integer(tab(0)))
  475. X        bitmap_list |||:= retrieve_bitmaps(offset, bmp_file)
  476. X        }
  477. X        every close(bmp_file | in_egrep)
  478. X
  479. X    # ...otherwise (i.e. if not UNIX) use findre() instead of egrep
  480. X    #
  481. X    } else {
  482. X
  483. X        # Probably MS-DOS or something else.  SLOW, SLOW!
  484. X        intext := open(filestats[filename].ind_filename) |
  485. X        abort("retrieve","can't open index file", 21)
  486. X        # grep .IND file
  487. X        if \inverse then {
  488. X        # if inverse is nonnull, invert the sense of the search
  489. X        every line := !intext do {
  490. X            line ? {
  491. X            if not findre(pattern) & tab(find("\t")+1) then {
  492. X                bitmap_list |||:=
  493. X                retrieve_bitmaps(integer(tab(0)), bmp_file)
  494. X            }
  495. X            }
  496. X        }
  497. X        } else {
  498. X        # inverse is null; don't invert the sense of the search
  499. X        every line := !intext do {
  500. X            line ? {
  501. X            if findre(pattern) & tab(find("\t")+1) then {
  502. X                bitmap_list |||:=
  503. X                retrieve_bitmaps(integer(tab(0)), bmp_file)
  504. X            }
  505. X            }
  506. X        }
  507. X        }
  508. X        every close(bmp_file | intext)
  509. X
  510. X    }
  511. X
  512. X    # If *not* are_metas(pattern), then do a binary search of index.
  513. X    # No need to worry about is_UNIX, egrep, findre(), etc.
  514. X    #
  515. X    } else {
  516. X
  517. X    # If inverse is nonnull, invert the sense of the search
  518. X        # (binary_index_search() may be found in binsrch.icn).
  519. X    if \inverse then {
  520. X        if not (offset :=
  521. X        binary_index_search(pattern, filestats[filename].ind_filename))
  522. X        then bitmap_list |||:= retrieve_bitmaps(offset, bmp_file)
  523. X    } else {
  524. X        if offset :=
  525. X        binary_index_search(pattern, filestats[filename].ind_filename)
  526. X        then bitmap_list |||:= retrieve_bitmaps(offset, bmp_file)
  527. X    }
  528. X    close(bmp_file)
  529. X    }
  530. X
  531. X    # We're done.  See if there were any hits.
  532. X    #
  533. X    if *bitmap_list > 0
  534. X    then return bitmap_list
  535. X    else fail
  536. X
  537. Xend
  538. X
  539. X
  540. X
  541. Xprocedure retrieve_bitmaps(offset, f)
  542. X
  543. X    local bitmap_list, bitmap_length, i
  544. X    # global IS      # contains stats for current file
  545. X    
  546. X    seek(f, offset)
  547. X    bitmap_list := list()
  548. X    bitmap_length := ((IS.len * IS.no) <= seq(0,8))
  549. X
  550. X    every i := 1 to read_int(f, 16) do
  551. X    put(bitmap_list, read_int(f, bitmap_length))
  552. X
  553. X    return bitmap_list
  554. X
  555. Xend
  556. SHAR_EOF
  557. true || echo 'restore of retrieve.icn failed'
  558. rm -f _shar_wnt_.tmp
  559. fi
  560. # ============= indexutl.icn ==============
  561. if test -f 'indexutl.icn' -a X"$1" != X"-c"; then
  562.     echo 'x - skipping indexutl.icn (File already exists)'
  563.     rm -f _shar_wnt_.tmp
  564. else
  565. > _shar_wnt_.tmp
  566. echo 'x - extracting indexutl.icn (Text)'
  567. sed 's/^X//' << 'SHAR_EOF' > 'indexutl.icn' &&
  568. X############################################################################
  569. X#
  570. X#    Name:     indexutl.icn
  571. X#
  572. X#    Title:     indexing utilities
  573. X#
  574. X#    Author:     Richard L. Goerwitz
  575. X#
  576. X#    Version: 1.19
  577. X#
  578. X############################################################################
  579. X#
  580. X#  This file contains base_name(), dir_name(), get_index_fname(),
  581. X#  stripchars(), abort(), and gettokens().
  582. X#
  583. X#  base_name(s), dir_name(s)    - like the Unix system commands
  584. X#  create_fname(fname,ext)    - get a new filename based on fname + ext
  585. X#  stripchars(s,c)        - strip chars c from string s
  586. X#  abort(proc,msg,ecode)    - abort procedure proc with exit code ecode
  587. X#  write_int(f, int, size)    - breaks int into 8-bit chunks & writes to f
  588. X#  read_int(f, int, size)    - like write_int, only constructs int from f
  589. X#  are_metas(pattern)        - succeeds if pattern has egrep-style metas
  590. X#  digits_2_bitmap(s)        - converts string 01:13:94 to an int-bitmap
  591. X#
  592. X############################################################################
  593. X#
  594. X#  Links: ./findre.icn, radcon.icn, bincvt.icn
  595. X#
  596. X#  See also: retrieve.icn, retrops.icn, bmp2text.icn, makeind.icn
  597. SHAR_EOF
  598. true || echo 'restore of indexutl.icn failed'
  599. fi
  600. echo 'End of  part 4'
  601. echo 'File indexutl.icn is continued in part 5'
  602. echo 5 > _shar_seq_.tmp
  603. exit 0
  604. -- 
  605.  
  606.    -Richard L. Goerwitz              goer%sophist@uchicago.bitnet
  607.    goer@sophist.uchicago.edu         rutgers!oddjob!gide!sophist!goer
  608.