home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / OL.LZH / PROCS.LZH / REWRAP.ICN < prev    next >
Text File  |  1991-07-13  |  4KB  |  147 lines
  1. ############################################################################
  2. #
  3. #    Name:     rewrap.icn
  4. #
  5. #    Title:     advanced line rewrap utility
  6. #
  7. #    Author:     Richard L. Goerwitz
  8. #
  9. #    Date:     June 3, 1991
  10. #
  11. #    Version: 1.3
  12. #
  13. ############################################################################
  14. #
  15. #  The procedure rewrap(s,i), included in this file, reformats text
  16. #  fed to it into strings < i in length.  Rewrap utilizes a static
  17. #  buffer, so it can be called repeatedly with different s arguments,
  18. #  and still produce homogenous output.  This buffer is flushed by
  19. #  calling rewrap with a null first argument.  The default for
  20. #  argument 2 (i) is 70.
  21. #
  22. #  Here's a simple example of how rewrap could be used.  The following
  23. #  program reads the standard input, producing fully rewrapped output.
  24. #
  25. #  procedure main()
  26. #      every write(rewrap(!&input))
  27. #      write(rewrap())
  28. #  end
  29. #
  30. #  Naturally, in practice you would want to do things like check for in-
  31. #  dentation or blank lines in order to wrap only on a paragraph-by para-
  32. #  graph basis, as in
  33. #
  34. #  procedure main()
  35. #      while line := read(&input) do {
  36. #          if line == "" then {
  37. #              "" ~== write(rewrap())
  38. #              write(line)
  39. #          } else {
  40. #              if match("\t", line) then {
  41. #                  write(rewrap())
  42. #                  write(rewrap(line))
  43. #              } else {
  44. #                  write(rewrap(line))
  45. #              }
  46. #          }
  47. #      }
  48. #  end
  49. #
  50. #  Fill-prefixes can be implemented simply by prepending them to the
  51. #  output of rewrap:
  52. #
  53. #      i := 70; fill_prefix := " > "
  54. #      while line := read(input_file) do {
  55. #          line ?:= (f_bit := tab(many('> ')) | "", tab(0))
  56. #          write(fill_prefix || f_bit || rewrap(line, i - *fill_prefix))
  57. #          etc.
  58. #
  59. #  Obviously, these examples are fairly simplistic.  Putting them to
  60. #  actual use would certainly require a few environment-specific
  61. #  modifications and/or extensions.  Still, I hope they offer some
  62. #  indication of the kinds of applications rewrap might be used in.
  63. # 
  64. #  Note:  If you want leading and trailing tabs removed, map them to
  65. #  spaces first.  Rewrap only fools with spaces, leaving tabs intact.
  66. #  This can be changed easily enough, by running its input through the
  67. #  Icon detab() function.
  68. #
  69. ############################################################################
  70. #
  71. #  See also:  wrap.icn
  72. #
  73. ############################################################################
  74.  
  75.  
  76. procedure rewrap(s,i)
  77.  
  78.     local extra_bit, line
  79.     static old_line
  80.     initial old_line := ""
  81.  
  82.     # Default column to wrap on is 70.
  83.     /i := 70
  84.     # Flush buffer on null first argument.
  85.     if /s then {
  86.     extra_bit := old_line
  87.     old_line := ""
  88.     return "" ~== extra_bit
  89.     }
  90.  
  91.     # Prepend to s anything that is in the buffer (leftovers from the last s).
  92.     s ?:= { tab(many(' ')); old_line || trim(tab(0)) }
  93.  
  94.     # If the line isn't long enough, just add everything to old_line.
  95.     if *s < i then old_line := s || " " & fail
  96.  
  97.     s ? {
  98.  
  99.     # While it is possible to find places to break s, do so.
  100.     while any(' -',line := EndToFront(i),-1) do {
  101.         # Clean up and suspend the last piece of s tabbed over.
  102.         line ?:= (tab(many(' ')), trim(tab(0)))
  103.             if *&subject - &pos + *line > i
  104.         then suspend line
  105.         else {
  106.         old_line := ""
  107.         return line || tab(0)
  108.         }
  109.     }
  110.  
  111.     # Keep the extra section of s in a buffer.
  112.     old_line := tab(0)
  113.  
  114.     # If the reason the remaining section of s was unrewrapable was
  115.     # that it was too long, and couldn't be broken up, then just return
  116.     # the thing as-is.
  117.     if *old_line > i then {
  118.         old_line ? {
  119.         if extra_bit := tab(upto(' -')+1) || (tab(many(' ')) | "")
  120.         then old_line := tab(0)
  121.         else extra_bit := old_line & old_line := ""
  122.         return trim(extra_bit)
  123.         }
  124.     }
  125.     # Otherwise, clean up the buffer for prepending to the next s.
  126.     else {
  127.         # If old_line is blank, then don't mess with it.  Otherwise,
  128.         # add whatever is needed in order to link it with the next s.
  129.         if old_line ~== "" then {
  130.         # If old_line ends in a dash, then there's no need to add a
  131.         # space to it.
  132.         if old_line[-1] ~== "-"
  133.         then old_line ||:= " "
  134.         }
  135.     }
  136.     }
  137.     
  138. end
  139.  
  140.  
  141.  
  142. procedure EndToFront(i)
  143.     # Goes with rewrap(s,i)
  144.     *&subject+1 - &pos >= i | fail
  145.     suspend &subject[.&pos:&pos <- &pos+i to &pos by -1]
  146. end
  147.