/* Copyright 1996 Acorn Computers Ltd
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/*
 * Title: txtmisc.c
 * Purpose: Search text for string.
 * Author: AFP
 * Status: system-independent
 * Requires:
 *   h.txt
 * History:
 *   16 Jul 87 -- started
 *   18 Dec 87: AFP: converted into C.
 *   02 Mar 88: WRS: improved use of trace.
 *   17 Mar 88: IGJ: txtmisc_formattxt added
 *    1 Jun 90: NDR: txtmisc wordwrap routines moved here from c.txtedit
 *    8 May 91: ECN: #ifndefed out unused ROM functions
 *   11 Jun 91: IDJ: expand tabs and CR<>LF now set modified flag
 */

#define BOOL int
#define TRUE 1
#define FALSE 0

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <limits.h>
#include "werr.h"
#include "txt.h"
#include "flex.h"
#include "txtscrap.h"
#include "EditIntern/txtmisc.h"
#include "EditIntern/txtundo.h"
#include "trace.h"
#include "msgs.h"
#include "VerIntern/messages.h"

#define EDIT2 1
/* 05-Jan-89: wordwrap facilities. */

int txtmisc_alphach(char c)

/* We try to cover the letters with accents on them too. Is this right?
Not sure. */

{

return(((c >= 'a') && (c <= 'z')) ||
       ((c >= 'A') && (c <= 'Z')) ||
       ((c >= '0') && (c <= '9')) ||
       (c >= 128+64));

}

txt_index txtmisc_bow(txt t, txt_index i)

{

#if FALSE
while (i > 0 && txtmisc_alphach(txt_charat(t, i - 1)))
     --i;
while (i > 0 && !txtmisc_alphach(txt_charat(t, i - 1)))
     --i;
#else
if (i > 0 && txt_charat(t, i - 1) == '\n')
     --i;
while (i > 0 && txtmisc_alphach(txt_charat(t, i - 1)) && txt_charat(t, i - 1) != '\n')
     --i;
while (i > 0 && !txtmisc_alphach(txt_charat(t, i - 1)) && txt_charat(t, i - 1) != '\n')
     --i;
#endif

return(i);

}




txt_index txtmisc_eow(txt t, txt_index i)

{

txt_index lim;

lim = txt_size(t);
#if FALSE
while (i < lim && txtmisc_alphach(txt_charat(t, i)))
     ++i;
while (i < lim && !txtmisc_alphach(txt_charat(t, i)))
     ++i;
#else
if (i < lim && txt_charat(t, i) == '\n')
     ++i;
while (i < lim && txtmisc_alphach(txt_charat(t, i)) && txt_charat(t, i) != '\n')
     ++i;
while (i < lim && !txtmisc_alphach(txt_charat(t, i)) && txt_charat(t, i) != '\n')
     ++i;
#endif
return(i);

}



/* beginning of line */
txt_index txtmisc_bol(txt t, txt_index i)

{

while (i > 0 && (txt_charat(t, i - 1) != '\n'))
     --i;
return(i);

}



/* end of line */
txt_index txtmisc_eol(txt t, txt_index i)

{

txt_index lim;

lim = txt_size(t);

while (i < lim && (txt_charat(t, i) != '\n'))
     ++i;
return(i);

}


#ifndef UROM
int txtmisc_bof(txt t)
{

return(txt_dot(t) == 0);

}
#endif


int txtmisc_eof(txt t)
{
return(txt_dot(t) == txt_size(t));
}



unsigned txtmisc_currentlinenumber(txt t)

{

txt_index at;
unsigned size;
char *a;
int n,j,line;

size = txt_dot(t);
at = 0;
line = 1;

while (at != size)

     {
     txt_arrayseg(t, at, &a, &n);
     n = (n < size) ? n : size;
     for (j = 0; j < n; j++)
        if (a[j] == '\n')
          ++line;
     at += n;
     }
return(line);

}




void txtmisc_gotoline(txt t, unsigned l)

{

txt_index at;
unsigned size;
char *a;
int n,j=0;

if (l == 1) /* move to top of file */
  txt_setdot(t, 0);

if (l > 1)

  {

  size = txt_size(t);
  at = 0;
  while (at != size && l != 1)
       {
       txt_arrayseg(t, at, &a, &n);
       for (j = 0; (j < n && l != 1); j++)
           if (a[j] == '\n')
            --l;
       if (l != 1)
         {
         at += n;
         j = 0;
         }
       }

  txt_setdot(t, at+j);

  }
}


static int txtmisc_blackch(char c)

{
return(c != ' ' && c != '\n' && c != 0);
}

void txtmisc_tab(txt t)

/* This implementation is somewhat of a cheat, in that I move up
to the line above, hit cursor right a few times, and go back down
again. Various things can go wrong, e.g. with wrapped lines. In tests,
doing a tab with the line above wrapped is particularly noticable. */

{

txt_index to, dot;
int       topline;
BOOL      endoflineabove = FALSE;


txt_setcharoptions(t, txt_CARET, 0);

dot = txt_dot(t);

txt_movevertical(t, -1, NULL); /* move to line above */

topline = (dot == txt_dot(t)) ? 0 : 1;

dot = txt_dot(t);

to = dot;

while (txtmisc_blackch(txt_charat(t, to)))
     ++to;

if (txt_charat(t, to) == '\n') endoflineabove = TRUE;

while (txt_charat(t, to) == ' ')
     ++to;

txt_setdot(t, to);

if (topline)
  txt_movevertical(t, 1, NULL); /* and move back to line below again */

if (endoflineabove) txt_setdot(t, txtmisc_bol(t, txt_dot(t)));

txt_setcharoptions(t, txt_CARET, txt_CARET);

}

void txtmisc_tabcol(txt t) {
/* If the dot is at a newline then the whole thing is different: tabbing
affects the horizontal tab offset, rather than moving you in the file. There
is a problem in that you can't tell about the existing horizontal tab at the
txt interface: BUT YOU CAN, by inserting a space and seeing how many spaces
appear! Then undo this, and presto. */

  txt_index i = txt_dot(t);
  BOOL atnewline = txt_charatdot(t) == '\n' || txt_dot(t) == txt_size(t);
  int currentoffset = 0;

  if (atnewline) {
    txt_charoption opts = txt_charoptions(t);
    if ((txt_CARET & opts) != 0) txt_setcharoptions(t, txt_CARET, 0);
    txtundo_separate_major_edits(t);
    txt_insertchar(t, ' ');
    /* Turning off display loses your horizontal offset, so it must be done
    after the insertchar. */
    currentoffset = txt_dot(t) - i;
    while (txtundo_undo(t) == txtundo_MINOR); /* undo the insert. */
    txtundo_commit(t); /* totally forget the insertion and its reversal */
    if ((txt_CARET & opts) != 0) txt_setcharoptions(t, txt_CARET, txt_CARET);
  };

  while (i > 0 && txt_charat(t, i-1) != '\n') i--; /* i now start of line */
  i = txt_dot(t) - i; /* i now length of line */
  if (atnewline) i += currentoffset; /* i now current col position. */
  while (i >= 8) i -= 8; /* i now fraction of tab col that we stick out over */
  i = 8 - i; /* i now no of spaces to insert; */

  if (atnewline) {
    txt_movehorizontal(t, currentoffset + i);
  } else {
    txt_replacechars(t, 0, "        ", i);
    txt_movedot(t, i);
  };

}

void txtmisc_expandtabs(txt t)

{

char c, *spaces = "        ";
txt_index at, size, dot;
unsigned col, nspaces;
#if FALSE
int updated;
#endif

at = col = 0;
size = txt_size(t);
#if FALSE
updated = ((txt_UPDATED & txt_charoptions(t)) != 0);
#endif
dot = txt_dot(t);
 txt_setcharoptions(t, txt_DISPLAY, 0);
while (at != size)
      {
      if ((c = txt_charat(t, at)) == '\n')
         {
         ++at;
         col = 0;
         }
      else if (c == 9)
         {
         txt_setdot(t, at);
         nspaces = 8 - col % 8;
         txt_replacechars(t, 1, spaces, nspaces);
         size += (nspaces - 1);
         if (at < dot)
            dot += (nspaces - 1);
         }
      else
         {
         ++at;
         ++col;
         }
      }
txt_setdot(t, dot);

#if FALSE
if (!updated)
  /* if it wasn't updated before, set this as still the case. */
  txt_setcharoptions(t, txt_UPDATED, NULL);
#endif

txt_setcharoptions(t, txt_DISPLAY, txt_DISPLAY);
}



void txtmisc_indentregion(txt t, txt_index from, txt_index to, int by,
                          char *with)

{
unsigned cby, del, del1;
int big;
txt_marker savedot;

if (from != 0)
   {
   from = txtmisc_eol(t, txtmisc_bol(t, from - 1)); /* now on a NewLineCh. */
   ++from; /* now at the start of a line */
   }
to = (to < txt_size(t)) ? to : txt_size(t);
if (by == 0)
   return;

if (by > 0)
   {
   cby = (by < strlen(with)) ? by : strlen(with);
   del = 0;
   }
else
   {
   cby = 0;
   del = -1 * by;
   }
big = to > from + 1000;
if (big)
   txt_setcharoptions(t, txt_DISPLAY, 0);
txt_newmarker(t, &savedot);
while (from < to)
      {
      txt_setdot(t, from);
      if (txt_charatdot(t) != '\n')
         /* don't do anything to blank lines */
         {
         int linelen = txtmisc_eol(t, from) - from;
         del1 = (del < linelen) ? del : linelen; /* 22-Nov-88 WRS: bug fix. */
         txt_replacechars(t, del1, with, cby);
         to += cby;
         to -= del1;
         }
      if (cby > 0 && txt_selectstart(t) > txt_dot(t))
         /* only for first line: we fail to select inserted chars */
         txtscrap_setselect(t, txt_selectstart(t) - cby, txt_selectend(t));
      from = txtmisc_eol(t, from) + 1;
      /* the EOL is done twice because the Replace affects its value. */
      }
txt_movedottomarker(t, &savedot);
txt_disposemarker(t, &savedot);
if (big)
   txt_setcharoptions(t, txt_DISPLAY, txt_DISPLAY);
}


void txtmisc_exchangecrlf(txt t)

{

txt_index at;
unsigned size, j;
int n;
char *a, c;
BOOL updated = FALSE;

txt_setcharoptions(t, txt_DISPLAY, 0);
size = txt_size(t);
at = 0;
while (at != size)
      {
      txt_arrayseg(t, at, &a, &n);
      for (j = 0; j < n; j++)
          {
            if ((c = a[j]) == '\n')
            {
               updated = TRUE;
               a[j] = '\r';
            }
            if (c == '\r')
            {
               updated = TRUE;
               a[j] = '\n';
            }
          }
      at += n;
      }
txt_setcharoptions(t, txt_DISPLAY, txt_DISPLAY);
if (updated) txt_setcharoptions(t, txt_UPDATED, txt_UPDATED);
txtundo_prevent_undo(t);
}


#if EDIT2
#else

static BOOL txtmisc_iswhitespace(char c)

{
  return((c == '\n') || (c == ' '));
}


BOOL txtmisc_isparaend(txt t, txt_index at)

{
  if (at == txt_size(t)) return TRUE;
  if (txt_charat(t, at) == '\n') {
    if (at == txt_size(t) -1) return TRUE;
    {
      char nextch = txt_charat(t, at+1);
      return txtmisc_iswhitespace(nextch) || nextch == '.';
    };
  };
  return FALSE;
}


void txtmisc_formattext(txt t, int width)

/* format text a la Twin - if a line is longer than 80 characters split it
at word boundries by newlines, removing spaces, to give several lines of
80 or less cols */

{

txt_index at, wasat, sol, eol;

if (txt_charatdot(t) == '\n') {  /* >>>> 15-Nov-88 */
  txt_movedot(t, 1);
  return;
};

txt_setcharoptions(t, txt_DISPLAY, NULL);

at = txt_dot(t);
wasat = at;

while (!txtmisc_isparaend(t, at))
{
  if (txt_charat(t, at) == '\n')
  {
    txt_setdot(t, at);
    txt_replacechars(t, 1, " ", 1);
  }
  at++;
}

sol = txtmisc_bol(t, wasat);
eol = txtmisc_eol(t, wasat);

while (sol + width <= eol)  /* have we more than 76 chars on line ? */
{
  at = sol + width;
  while (at > sol && !txtmisc_iswhitespace(txt_charat(t, at)))
     --at;
  while (at > sol && txtmisc_iswhitespace(txt_charat(t, at - 1)))
     --at;
  if (at == sol) {
    /* A word longer than the width. Advance past this word. */
    while (at < txt_size(t) && ! txtmisc_iswhitespace(txt_charat(t, at)))
      ++at;
  };

#if TRUE
  if (at >= eol) break; /* 29-Nov-88: para with last line just right width, went wrong. */
#endif

  txt_setdot(t, at);          /* set the insertion point */
  txt_insertchar(t, '\n');    /* insert the new line */
  txt_movedot(t, 1);          /* advance past the NL */
  eol++;                      /* the eol is one further on */

  while (txtmisc_iswhitespace(txt_charatdot(t)))
  {
    txt_delete(t, 1);
    eol--;
  }
  sol = txt_dot(t);;
}

txt_setdot(t, wasat);                            /* set to where we started */
txt_setcharoptions(t, txt_DISPLAY, txt_DISPLAY); /* redisplay text */
txt_setdot(t, eol);                              /* set to end of line */
txt_movedot(t, 1);                               /* advance to next line */
}
#endif

/* -------- Selection utilities. -------- */


txt_index txtmisc_furthestaway(txt t, txt_index from, txt_index a1,
                               txt_index a2)

{
t=t;
if (from <= (a1 + a2) / 2)
   return((a1 > a2) ? a1 : a2);
else
   return((a1 < a2) ? a1 : a2);
}


void txtmisc_select3(txt t, txt_index a1, txt_index a2, txt_index a3)

{

txt_index a4;

txtscrap_setselect(t, (a1 < (a4 = (a2 < a3) ? a2 : a3)) ? a1 : a4,
                   (a1 > (a4 = (a2 > a3) ? a2 : a3)) ? a1 : a4);
}


#if FALSE
void txtmisc_selectpointandword(txt t, txt_index point, txt_index word)

{

txt_index begin, end;

begin = txtmisc_bow(t, word);
if (begin != 0) begin = txtmisc_eow(t, begin); /* fix for start of file. */
end = txtmisc_eow(t, begin);
txtmisc_select3(t, point, begin, end);

}
#else
/* New, smarter version 07-Nov-89 */

static BOOL txtmisc__linenonalpha(txt t, txt_index i) {
  char c = txt_charat(t, i);
  if (i > txt_size(t)) return FALSE;
  if (i < 0) return FALSE;
  if (txtmisc_alphach(c)) return FALSE;
  if (c == '\n') return FALSE;
  return TRUE;
}

void txtmisc_selectpointandword(txt t, txt_index point, txt_index word)

{

txt_index begin = word;
txt_index end = begin;
txt_index size = txt_size(t);

if (txtmisc_alphach(txt_charat(t, begin - 1))
    ||
    txtmisc_alphach(txt_charat(t, end)))
{
  /* We are pointed at a word. */
  while (begin > 0 && txtmisc_alphach(txt_charat(t, begin - 1))) begin--;
  while (txtmisc_alphach(txt_charat(t, end))) end++;
  if (txt_charat(t, end) == '\n' || end == size) {
    /* There is no whitespace after this word - gobble up whitespace before it. */
    while (txtmisc__linenonalpha(t, begin - 1)) begin--;
  } else {
    /* There is whitespace after this word - gobble it up (default case) */
    while (txtmisc__linenonalpha(t, end)) end++;
  };
} else {
  /* We are pointed at whitespace. */
  while (txtmisc__linenonalpha(t, begin - 1)) begin--;
  while (txtmisc__linenonalpha(t, end)) end++;
  if (begin == 0 || txt_charat(t, begin - 1) == '\n') {
    /* We are at the left end of a line - gobble up the word on the right */
    while (txtmisc_alphach(txt_charat(t, end))) end++;
  } else {
    /* Gobble up the word on the left (default case). */
    while (begin > 0 && txtmisc_alphach(txt_charat(t, begin - 1))) begin--;
  };
};

txtmisc_select3(t, point, begin, end);

}
#endif


void txtmisc_selectpointandline(txt t, txt_index point, txt_index line)

{

txt_index begin, end;

begin = txtmisc_bol(t, line);
end = 1 + txtmisc_eol(t, begin);
txtmisc_select3(t, point, begin, end);

}



void txtmisc_clearselection(void)

/* Clear any selection. */

{
txtscrap_setselect(NULL, 0, 0);
}

#if EDIT2
/* -------- Wordwrap -------- */

/* This incorrectly resides in txtedit at the moment. */
void txtmisc_normalisepara(
  txt t,
  int parawidth
);
#endif

/* -------- Operations on Selections -------- */

void txtmisc_deleteselection(int parawidth)

{

txt_marker m;
txt owner;

owner = txtscrap_selectowner();
if (owner != NULL && txt_selectset(owner))
   {
   txt_newmarker(owner, &m);
   txt_setdot(owner, txt_selectstart(owner));
   txt_delete(owner, txt_selectend(owner) - txt_selectstart(owner));
   txtmisc_normalisepara(owner, parawidth);
   txt_movedottomarker(owner, &m);
   txt_disposemarker(owner, &m);
   txtscrap_setselect(owner, 0, 0);
   }
}

#define BIG 256

static void movecopyselection(txt t, int deletesource, int parawidthsrc, int parawidthdst)

/* Two different techniques are used for small and for big operations. Small
ones are quicker to repaint. Bigger ones use FlexiStore as the transitory
space, this is tricky because inserting from FlexiStore might cause the
source to move under your feet if the object expands. */

{

unsigned size;
int n, stored, segsize;
txt owner;
char *a;
void *scrap;

owner = txtscrap_selectowner();
if (owner != NULL)
   {
   /* determine size */
   size = txt_selectend(owner) - txt_selectstart(owner);
   if (t == owner && deletesource &&
       txt_dot(t) >= txt_selectstart(t) && txt_dot(t) < txt_selectend(t))

     /* move with caret in the middle of select, do nothing */
     txt_setdot(t, txt_selectend(t));

   else

     {

     /* get temporary space */
     stored = TRUE;
     if (size <= BIG) {
        scrap = malloc(BIG);
        if (scrap == 0) {
          werr(FALSE, msgs_lookup(MSGS_txt48));
          return;
        };
     } else
        if (!flex_alloc(&scrap, size))
          {
          werr(NULL, msgs_lookup(MSGS_txt48));
          stored = FALSE;
          };
     tracef2("\nRequired size is %d, stored = %d.\n", size, stored);
     if (stored)
        {

        /* Copy the selection into the temporary store */
        n = 0;
        while (n != size)
              {
              txt_arrayseg(owner, txt_selectstart(owner) + n, &a, &segsize);
              segsize = (segsize < size - n) ? segsize : size - n;
              memcpy((char *)scrap + n, a, segsize);
              n += segsize;
              }

        /* Delete the source. */
        if (deletesource)
           txtmisc_deleteselection(parawidthsrc);
        /* >>>> dangerous? If t=owner, definitely a good move. */

        {
          int prevsize = txt_size(t);
          /* Insert the selection into the target */
          if (size <= BIG)
             {
             txt_replacechars(t, 0, scrap, size);
             tracef0("small MoveCopy.\n");
             }
          else
             {
             tracef0("large MoveCopy.\n");
             txtmisc_textinsertfromflexistore(t, &scrap, size);
             }
          if (txt_size(t) == prevsize + size) {
            /* managed to insert: not out of space. */

            /* The result becomes the selection */
            if (deletesource)
               txtscrap_setselect(t, txt_dot(t), txt_dot(t) + size);

            txtmisc_normalisepara(t, parawidthdst);
            /* NB we're relying on this not changing the size of what we've
            inserted: otherwise, moving past the insertion needs a marker. */

            /* Move past the result. */
            txt_movedot(t, size);

          };
        };

        /* deallocate temporary space */
        if (size <= BIG)
           free(scrap);
        else
           flex_free(&scrap);
        }
     }
   }
}


void txtmisc_moveselection(txt t, int parawidthsrc, int parawidthdst)

/* The selection is copied to the caret, then deleted at the source.
The new version is now the selection. */

{
movecopyselection(t, 1, parawidthsrc, parawidthdst);
}



void txtmisc_copyselection(txt t, int parawidth)

/* The selection is copied to the caret. The new version is now the
selection. */

{
movecopyselection(t, NULL, parawidth, parawidth);
}




int txtmisc_textinsertfromflexistore(txt t, flex_ptr anchor, unsigned n)

/* If we just did an insert and this caused an expand and we got moved, the
text would be taken from the wrong place. So, we must turn off display for
this one.

Return FALSE, with situation unchanged, if out of store. */

{
void *prevad;
int prevsize;

prevad = *anchor;
prevsize = txt_size(t);
txt_setcharoptions(t, txt_DISPLAY, 0);
txt_replacechars(t, 0, *anchor, n);
if (txt_size(t) != n + prevsize) {
  tracef0("not enough space.\n");
  txt_delete(t, txt_size(t) - prevsize);
  txt_setcharoptions(t, txt_DISPLAY, txt_DISPLAY);
  /* werr(FALSE, "Not enough space."); */
  /* 21-Nov-88 WRS: Failure will already have produced an error message. */
  return FALSE;
};
if (*anchor != prevad)
   {
   tracef0("Replace caused movement.\n");
   txt_replacechars(t, n, *anchor, n);
   }
txt_setcharoptions(t, txt_DISPLAY, txt_DISPLAY);
return(1);
}
/* >>>> do out of store stuff. */


/* -------- Wordwrap. -------- */

#if WORDWRAP

BOOL txtmisc_paraend(txt t, txt_index i) {
  if (txt_size(t) <= i) return TRUE;
  if (txt_charat(t, i) != '\n') return FALSE;
  if (i == 0) return TRUE;
  if (txt_charat(t, i-1) == '\n') return TRUE;
  if (txt_size(t) == i+1) return TRUE;
/*  return strchr("\n .", txt_charat(t, i+1)) != 0; */
  {
    char ch = txt_charat(t, i+1);
    if (ch == '\n') return TRUE;
    if (ch == ' ') return TRUE;
    if (ch == '.') return TRUE;
    return FALSE;
  };
}

#ifndef UROM
BOOL txtmisc_parastart(txt t, txt_index i) {
  if (i == 0) return TRUE;
  if (txtmisc_paraend(t, i-1)) return TRUE;
  if (i == 1) return FALSE;
  return (txtmisc_paraend(t, i-2));
}
#endif

#ifndef UROM
txt_index txtmisc_bop(txt t, txt_index i) {
  while (!txtmisc_parastart(t, i)) {
    i = txtmisc_bol(t, i-1);
  };
  return i;
}
#endif

txt_index txtmisc_eop(txt t, txt_index i) {
  while (!txtmisc_paraend(t, i)) {
    i = txtmisc_eol(t, i+1);
  };
  return i;
}

void txtmisc_normalisepara(
  txt t,
  int parawidth
)
/* Usually called during typin (flag-controlled), after the insertion but before
the advancement of the caret. Normalise the characters from the caret to the
next end-of-paragraph, converting between spaces and newlines in order to
improve layout. Do this all in a separate memory block and then do a single
txt_replacechars in order to manufacture the resulting effect.

Bugs: limited buffer size
*/

#define PSIZ 512

/* It's reasonable to have a maximum on the amount that you're prepared to look
ahead. If the result ripples ahead more than this, tough luck. */
/* If parawidth is more than this it won't work very well. */

{
    char c[PSIZ];
    int paramax;
    int at = 0; /* index of current point into c. */
    int col = 0; /* column of current point. */
    txt_index dot;
    txt_index parastart;
    int minchange;
    int maxchange;
    int hascaret = txt_charoptions(t) & txt_CARET;
    BOOL modified = FALSE;
    BOOL bufoverflow = TRUE;

    tracef1("normalisepara width=%i.\n", parawidth);
    if (parawidth == 0) return; /* do no formatting. */

    dot = txt_dot(t);
#if FALSE
    parastart = txtmisc_bop(t, dot);
#else
    parastart = txtmisc_bol(t, dot);
#endif

    while (bufoverflow) {
      /* We only loop here if the paragraph is larger than PSIZ, e.g. our work
      buffer is not big enough. */
      int prevat = at;
      int prevcol = col;
      int prevprevat;
      int prevprevcol;

      /* col == dot's current column position. */
      tracef2("dot=%i, dot para start=%i.\n", dot, parastart);

      /* Fill the buffer from parastart to the next end of paragraph. */
      paramax = 0;
      while (paramax < PSIZ && !txtmisc_paraend(t, parastart + paramax)) {
        c[paramax] = txt_charat(t, parastart + paramax);
        paramax++;
      };
      /* c[paramax] is the final NewLineCh, or is beyond the end of file. */
      tracef1("paramax = %i.\n", paramax);

      minchange = paramax;
      maxchange = 0;
      /* c[minchange]..c[maxchange] must be updated in the text buffer. */

      while (1) {
        int nextwhite;
        int nextwhitecol;

        prevprevat = prevat;
        prevprevcol = prevcol;
        prevat = at;
        prevcol = col;

        while (c[at] != '\n' && c[at] != ' ' && at < paramax) { /* hop over word */
          at++;
          col++;
        };
        while ((c[at] == '\n' || c[at] == ' ') && at < paramax) { /* hop over gap */
          at++;
          col++;
        };
        if (at == paramax) {
          if (paramax != PSIZ) {
            bufoverflow = FALSE; /* "usual" exit route from the loop */
          };
          break;
        };
        /* We are now at the start of a word, at>0, or at==paramax cos the buffer's not big enough. */
        tracef2("word start: at=%i col=%i.\n", at, col);

        nextwhite = at;
        while (c[nextwhite] != '\n' && c[nextwhite] != ' ' && nextwhite < paramax) { /* find end of word */
          nextwhite++;
        };
        if (nextwhite == PSIZ) {
          /* the buffer's not big enough. */
          break;
        };
        nextwhitecol = col + nextwhite - at;

        at--; /* point at the whitespace before */
        if (nextwhitecol > parawidth) { /* or >= perhaps? */
          if (c[at] == ' ') { /* this should be a newline */
            c[at] = '\n';
            if (minchange > at) minchange = at;
            if (maxchange <= at) maxchange = at+1;
          };
        } else {
          if (c[at] == '\n') { /* this should be a space */
            c[at] = ' ';
            if (minchange > at) minchange = at;
            if (maxchange <= at) maxchange = at+1;
          };
        };
        if (c[at] == '\n') col = 0;
        at++; /* point at the word start */
      }; /* end while */

      if (minchange < maxchange) {
        /* there is some changing to do. */
        tracef2("update %i..%i.\n", minchange, maxchange);
        if ((! modified) && (hascaret != 0)) txt_setcharoptions(t, txt_CARET, 0);
        txt_setdot(t, parastart + minchange);

        /* At this point we'd like to just do the replace, but we also want to preserve
        the positioning of the selection start and end, if they are affected. */
        /* Arguably this should be a flag to replacechars - e.g. do not affect the position of
        markers within the replaced area? */
        {
          txt_index selstart = txt_selectstart(t);
          txt_index selend = txt_selectend(t);
          txt_index here = txt_dot(t);
          txt_replacechars(t, maxchange - minchange, &c[minchange], maxchange - minchange);
          if ((selstart >= here && selstart <= here + maxchange - minchange)
          || (selend >= here && selend <= here + maxchange - minchange)) {
            txt_setselect(t, selstart, selend);
          };
        };
        modified = TRUE;
      } else {
        tracef0("Not updating.\n");
      }; /* if */

      if (bufoverflow) { /* we're going to be looping. */
        if (prevat == 0) {
          /* a word longer than the buffer - don't really care as long as we advance */
          parastart += at;
          /* col stays as it is. */
        } else if (prevprevat == 0) {
          /* words so long that two words spans the buffer */
          parastart += prevat;
          col = prevcol;
        } else {
          /* normal case - go back two words, to ensure that we get all possible
          line breaks correct. */
          parastart += prevprevat;
          col = prevprevcol;
        };
        at = 0;
      };

    }; /* while */

    if (modified) {
      txt_setdot(t, dot);
      if (hascaret != 0) txt_setcharoptions(t, txt_CARET, txt_CARET);
    };
}
/* Should be able to go round again if the paragraph is bigger than the buffer. */

#endif