[Back to TEXTFILE SWAG index] [Back to Main SWAG index] [Original]

    {
    | From: Scott Stone <pslvax!ucsd!u.cc.utah.edu!ss8913>
    |
    | This may sound like a simplistic request, but I need code to do the
    following:

     not really trivial, although its not hard
    |
    | Take a standard 80-column textfile and reformat it (w/ correct
    | wordwrapping) to be a new text file with lines of specified length (ie,
    | 40, 50, 60, etc).  Can anyone tell me how to do this (w/o truncating
    | lines, and w/o splitting words)?

     anyway, the following program may fill your needs as is
     its for dos, of course, ..
     (just change the constant max_wid to 40, 50, 60 etc), or,
     at least, it will give you a head start on writing a program
     for yourself.
    }

    {*************************************************************************
    Program reformat
    by Sadunathan Nadesan
    6/9/89

    Formats a file into paragraphs suitable for sending via MCI

    Usage: (on MS Dos)   % reformat < filename > outfilename

    *************************************************************************}

    program reformat(input,output);

    const
            max_wid =      80; {all output lines are less than this}
          {change this for different sized lines}
    type
     i_line  = string;  {input line buffer type}
     o_line  = string;  {input line buffer type}
     ref = ^node;
     node = record
        word : string;
        next : ref;
       end;
    var
     root : ref;  {beginning of sized line}
     tail : ref;  {pointer to last record in list}
     line : i_line; {input buffer}
    {------------------------------------------------------------------------}

    function end_of_paragraph (buffer : i_line): boolean;
    {detect the end of a paragraph}
    begin
    if (length(buffer) > 0) then
         end_of_paragraph := FALSE
    else
         end_of_paragraph := TRUE;
    end;

    {------------------------------------------------------------------------}
    procedure store_words ( buffer : i_line );
    { **********************************************************
      create a single linked list of all the words in a paragraph)
      this is called anew for every line of the paragraph, but
      uses a global linked list that it keeps working with.

      input paramters are buffer = the input line
      uses global variables root and tail
      ********************************************************** }
    var
     insize          : integer; {size of input line}
     b_counter : integer; {position marker in input buffer}
     p  : ref;  {word record}
    begin
    insize    := length(buffer);
    b_counter := 1;
    if not (end_of_paragraph(buffer)) then  {if not an empty line}
         repeat    {for each word in the input line}
       begin
       new (p);   {make a bucket for the word}
       with p^ do
            begin
            next := nil;
            word := '';
            repeat
          begin
          if (buffer[b_counter] <> ' ') then
        word := concat(word, buffer[b_counter]);
          b_counter := b_counter + 1;
          end;
            until ((buffer[b_counter] = ' ') or (b_counter > insize));
            end;
       if (root = nil) then    {this is the first word in the par.}
            begin
            root := p;
            tail := p;
            end
       else   {attach this word to the list of words}
            begin
            tail^.next := p;
            tail := p;
            end;
       end; {repeat 1}
         until (b_counter > insize);
    end; {store_words}

    {------------------------------------------------------------------------}
    procedure format_output( p : ref );
    { **********************************************************
      dump a single linked list of all the words in a paragraph
      out into lines of <= max_wid characters

      input paramters is p = root, the starting record of the linked word list
      uses global variable line

      ********************************************************** }
    var
     pretty   : o_line; {output buffer}
     one_more  : boolean;
    begin
    one_more := false;
    pretty := '';
    while (p^.next <> nil) do
         begin
         if (length(p^.word) + length(pretty) + 1 < max_wid)  then
            begin
            pretty := concat (pretty, p^.word);
            pretty := concat (pretty, ' ');
            p := p^.next;
            end
         else
       begin
       writeln(pretty);
       pretty := '';
       end;

         if (p^.next = nil) then   {for the last word!}
       if (length(p^.word) + length(pretty) + 1 < max_wid)  then
            pretty := concat (pretty, p^.word)
         else
       one_more := true;
         end;

    if (length(pretty) > 0) then  {get the last line}
         writeln(pretty);
    if (one_more) then
         writeln(p^.word);
    end;
    {------------------------------------------------------------------------}

    begin
    root := nil;
    repeat
         repeat
       begin
       readln(input, line);
       store_words ( line);
       end;
         until (end_of_paragraph(line));

         if (root <> nil) then
       begin
       format_output(root);
       writeln;
       root := nil;
       end;

    until (eof(input));
    end.

[Back to TEXTFILE SWAG index] [Back to Main SWAG index] [Original]