home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / Samples / CSAPE32.ARJ / SOURCE / CSSRC / TEDIT.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-12-15  |  14.3 KB  |  639 lines
  1. /*
  2.     tedit.c  
  3.  
  4.     % commmon routines used in text editting
  5.  
  6.     C-scape 3.2
  7.     Copyright (c) 1988 by Oakland Group, Inc.
  8.     ALL RIGHTS RESERVED.
  9.  
  10.     Revision History:
  11.     -----------------
  12.      6/17/88 jdc    created
  13.      9/22/88 jmd    Fixed ted_reset... now calls sed_Update
  14.     12/18/88 jdc    added check before BDM_SCROLL in ted_DeleteString
  15.  
  16.      2/08/89 jmd    added args
  17.      3/24/89 jmd    added sed_ macros
  18.      4/06/89 jmd    made this match teddecl (int to boolean)
  19.      5/19/89 jdc    removed cursor from ted_DeleteString
  20.      5/23/89 jdc    made tb_setcursor menu_setcursor
  21.      5/24/89 jdc    added clipping to sed_Paint, now takes menu coords
  22.      5/25/89 jdc    removed sed_Paint, now uses sd_paintbox
  23.      5/28/89 jdc    fixed ted_PageDown for LNF
  24.      6/26/89 jmd    removed unused yoffset from ted_PageDown
  25.      7/03/89 jdc    fixed ted_reset
  26.      7/21/89 jdc    fixed ted_reset again, off_text case
  27.      7/22/89 jdc    moved ted_SetMoveMethod to tedsetmv.c
  28.      8/14/89 jmd    Added call to disp_evcheck() macro
  29.      9/08/89 jmd    Added LNF stuff
  30.  
  31.     11/04/89 jdc    added paint optimization
  32.     12/04/89 jmd    added cursor color
  33.     12/20/89 jdc    preened
  34.      1/29/90 jdc    removed lnf_GotoField() from ted_SetCursor()
  35.      2/22/90 jdc    created ted_MoveChar removed LeftChar & RightChar
  36.      3/04/90 jdc    fixed MoveChar
  37.      3/15/90 jmd    added Cache/Flush to ted_AddString and ted_MoveChar
  38.      3/28/90 jmd    ansi-fied
  39.      5/02/90 jdc    added return values to PageUp, PageDown and GoBottom
  40.      5/03/90 jmd    added ifdef for Zortech
  41.      6/14/90 jdc    preened, tweeked VWidth stuff in ted_reset
  42.      6/15/90 jdc    fixed a preening
  43.      8/06/90 jdc    fixed GoBottom on last row bug
  44.     10/13/90 jdc    renamed global lnf_type to lnfglobal
  45.     10/15/90 jdc    removed LNF stuff
  46.     10/28/90 jdc    fixed boolean/int ret conflict
  47.     11/01/90 jmd    added fix for delete in middle of tab
  48.     12/15/90 jdc    preened color operation
  49. */
  50.  
  51. #ifdef LNF
  52. #    include "lnf.h"
  53. #    include "teddecl.h"
  54. #    include "tbpriv.h"
  55. #else
  56. #    include "ted.h"
  57. #endif
  58.  
  59. OSTATIC boolean  mark_GetUpdate(int arow, int acol, int lrow, int lcol, int row, int col, ocbox *Abox, ocbox *Bbox);
  60.  
  61. void ted_StartWorking(sed_type sed)
  62. {
  63.  
  64. #ifdef Z2
  65.     /* compensate for Zortech 2.0 Compiler */
  66.     if (sed_GetMoveMethod(sed) == (VOID *) default_move) {
  67.         sed_SetMove(sed, ted_Follow);
  68.     }
  69. #else
  70.     if (sed_GetMoveMethod(sed) == default_move) {
  71.         sed_SetMove(sed, ted_Follow);
  72.     }
  73. #endif
  74.  
  75.     if (ted_GetWrapWidth(sed) < 32000) {
  76.         sed_SetMenuVWidth(sed, ted_GetWrapWidth(sed));
  77.     }
  78.  
  79.     /* adjust cursor color */
  80.     win_SetCursorColor(sed, win_GetFgColor(sed));
  81.  
  82.     ted_GotoPosition(sed, sed_GetCRow(sed), sed_GetCCol(sed));
  83.     ted_SetCursor(sed, sed_GetCRow(sed), sed_GetCCol(sed));
  84.     win_ShowCursor(sed);
  85. }
  86.  
  87. void ted_GetPosition(sed_type sed, int *row, int *col)
  88. {
  89.     *row = sed_GetCRow(sed);
  90.     *col = sed_GetCCol(sed);
  91. }
  92.  
  93. boolean ted_MoveChar(sed_type sed, int r, int c, int tab_mode)
  94. /*
  95.     r and c are offsets and should only be 1 or -1's
  96.     if tab_mode == TED_TABJUMP then move by whole tabs,
  97.     else internal to tab.
  98. */
  99. {
  100.     int row, col;
  101.     boolean ret;
  102.     tb_type tb;
  103.         
  104.     ted_GetPosition(sed, &row, &col);
  105.     row += r;
  106.     col += c;
  107.  
  108.     if (win_IsEmployed(sed)) {
  109.         disp_Cache();
  110.     }
  111.  
  112.     if ((ret = ted_GotoPosition(sed, row, col)) == TRUE
  113.         && tab_mode == TED_TABJUMP) {
  114.  
  115.         tb = sed_GetTextbuf(sed);
  116.         while (row == tb_GetRow(tb) && col < tb->exp_len 
  117.             && col != tb_GetCol(tb)) {
  118.  
  119.             col += c;
  120.             ted_GotoPosition(sed, row, col);
  121.         }
  122.     }
  123.  
  124.     if (win_IsEmployed(sed)) {
  125.         disp_Flush();
  126.     }
  127.  
  128.     return(ret);
  129. }    
  130.  
  131. boolean ted_GoEnd(sed_type sed)
  132. {
  133.     tb_type tb;
  134.     int row, col;
  135.  
  136.     ted_GetPosition(sed, &row, &col);
  137.     tb = sed_GetTextbuf(sed);
  138.  
  139.     if (row > tb_GetRow(tb)) {
  140.         col = 0;
  141.     }
  142.     else {
  143.         col = tb->exp_len - 1;
  144.     }
  145.     return(ted_GotoPosition(sed, row, col));
  146. }
  147.  
  148. boolean ted_PageUp(sed_type sed)
  149. {
  150.     int row, col, yoffset;
  151.  
  152.     ted_GetPosition(sed, &row, &col);
  153.  
  154.     if (row == 0) {
  155.         return(FALSE);
  156.     }
  157.     else if (sed_GetYoffset(sed) == 0) {
  158.         row = 0;
  159.     }
  160.     else {
  161.         yoffset = (sed_GetYoffset(sed) > sed_GetHeight(sed)) ?
  162.             sed_GetHeight(sed) : sed_GetYoffset(sed);
  163.  
  164.         row -= yoffset;
  165.         if (ted_GetMark(sed) != TED_NOMARK) {
  166.  
  167.             /* cheat to prevent marking flash */
  168.             if (!((sed_GetTextbuf(sed))->m_stop)) {
  169.                 (sed_GetTextbuf(sed))->markbox.cleat_row -= yoffset;
  170.             }
  171.         }
  172.         sd_scroll(sed, -yoffset, 0, FALSE);
  173.     }
  174.     ted_GotoPosition(sed, row, col);
  175.  
  176.     return(TRUE);
  177. }
  178.  
  179. boolean ted_PageDown(sed_type sed)
  180. {
  181.     int refresh;
  182.     int row, col, yoffset;
  183.  
  184.     ted_GetPosition(sed, &row, &col);
  185.  
  186.     row += sed_GetHeight(sed);
  187.     refresh = ted_GetRefresh(sed);
  188.     ted_SetRefresh(sed, TED_NOREFRESH);
  189.     yoffset = sed_GetYoffset(sed);
  190.  
  191.     if (!ted_GotoPosition(sed, row, col)) {
  192.  
  193.          ted_SetRefresh(sed, refresh);
  194.         return(ted_GoBottom(sed));
  195.     }
  196.     else {
  197.         yoffset = sed_GetHeight(sed) - (sed_GetYoffset(sed) - yoffset);
  198.         sd_scroll(sed, yoffset, 0, FALSE);
  199.  
  200.         if (ted_SetRefresh(sed, refresh) == TED_REFRESH) {
  201.             win_Paint(sed);
  202.         }
  203.         ted_SetCursor(sed, row, col);
  204.     }
  205.     return(TRUE);
  206. }
  207.  
  208. boolean ted_GoBottom(sed_type sed)
  209. /*
  210.     moves the cursor to the last row 
  211. */
  212. {
  213.     int row, startrow, startcol;
  214.     tb_type tb;
  215.  
  216.     tb = sed_GetTextbuf(sed);    
  217.     startrow = row = sed_GetCRow(sed);
  218.     startcol = sed_GetCCol(sed);
  219.  
  220.     if (!tb_FindPosition(tb, row, 0)) {
  221.         /* find last row backwards */
  222.         while (!tb_FindPosition(tb, row, 0)) {
  223.             row--;
  224.         }
  225.     }
  226.     else {
  227.         /* find last row forwards */
  228.         while (tb_FindPosition(tb, row, 0)) {
  229.             row++;
  230.         }
  231.         row--;
  232.     }
  233.     if (row == startrow && startcol == tb->exp_len - 1) {    
  234.         return(FALSE);
  235.     }
  236.  
  237.     return(ted_GotoPosition(sed, row, tb->exp_len - 1));
  238. }
  239.  
  240. void ted_reset(sed_type sed, int i, int mode)
  241. /* 
  242.     resets wrap width (mode == 0) or tab size (mode == 1), and hints
  243. */
  244. {
  245.     tb_type tb;
  246.     int row, col, off_text = FALSE;
  247.     long cursor;
  248.  
  249.     tb = sed_GetTextbuf(sed);    
  250.     ted_GetPosition(sed, &row, &col);
  251.     cursor = tb->cursor;
  252.     
  253.     if (!tb_FindPosition(tb, row, col)) {
  254.         off_text = TRUE;
  255.     }
  256.     if (mode == 0) {
  257.         tb_SetWrapWidth(tb, i);
  258.  
  259.         if (i < 32000) {
  260.  
  261.             /* teds' width are their wrap width */
  262.  
  263.             sed_SetMenuVWidth(sed, i);
  264.         }
  265.         else {
  266.             sed_SetMenuVWidth(sed, -1);
  267.         }
  268.  
  269.          /* Send Scroll message to the border */
  270.         sed_SendBorderMsg(sed, BDM_SCROLL, NULL, NULL);
  271.     }
  272.     else {
  273.         tb_SetTabSize(tb, i);
  274.     }
  275.     tb_Rewind(tb);
  276.     if (off_text) {
  277.         tb_FindPosition(tb, row, col);
  278.     }
  279.     else {
  280.         tb->cursor = cursor;
  281.         menu_setcursor(sed_GetMenu(sed));
  282.         if (ted_GetRefresh(sed)) {
  283.             ted_GotoPosition(sed, tb_GetRow(tb), tb_GetCol(tb));
  284.         }
  285.     }
  286. }
  287.  
  288. void ted_SetCursor(sed_type sed, int row, int col)
  289. /* 
  290.     sets the window cursor from the sed's (menu!) cursor position 
  291. */
  292. {
  293.     tb_type tb;
  294.     int lrow, lcol, len;
  295.     ocbox Abox, Bbox;
  296.     
  297.     lrow = sed_GetCRow(sed);    
  298.     lcol = sed_GetCCol(sed);    
  299.  
  300.     sed_SetTrow(sed, row);
  301.     sed_SetTcol(sed, col);
  302.  
  303.     tb = sed_GetTextbuf(sed);    
  304.     box_sort(&Abox, &(tb->markbox), BOXSORT_ROW);
  305.  
  306.     if (ted_GetMark(sed) != TED_NOMARK) {
  307.         if (!(tb->m_stop)) {
  308.             tb->markbox.cleat_row = row;
  309.             tb->markbox.cleat_col = col;
  310.             tb->cleat = tb->cursor;
  311.         }
  312.     }
  313.  
  314.     if (ted_GetRefresh(sed)) {
  315.  
  316.         ted_Scroll(sed);
  317.         win_SetCursorPos(sed, row - sed_GetYoffset(sed), col - sed_GetXoffset(sed));
  318.  
  319.         if (tb->m_stop || tb->mark == TED_NOMARK) {
  320.             ;
  321.         }
  322.         else if (tb->mark == TED_MARK) {
  323.             if (row == lrow) {
  324.                 if ((len = col - lcol) < 0) {
  325.                     len = -len;
  326.                     lcol = col;
  327.                 }
  328.                 sed_RepaintRow(sed, row, lcol, len + 1);
  329.             }
  330.             else if (row <= Abox.toprow) {
  331.                 if (lrow <= tb->markbox.anchor_row) {
  332.                     sed_RepaintRows(sed, row, Abox.toprow);
  333.                 }
  334.                 else {
  335.                     sed_RepaintRows(sed, row, Abox.botrow);
  336.                 }
  337.             }
  338.             else if (row <= Abox.botrow) {
  339.                 if (lrow <= tb->markbox.anchor_row) {
  340.                     sed_RepaintRows(sed, Abox.toprow, row);
  341.                 }
  342.                 else {
  343.                     sed_RepaintRows(sed, row, Abox.botrow);
  344.                 }
  345.             }
  346.             else {
  347.                 if (lrow < tb->markbox.anchor_row) {
  348.                     sed_RepaintRows(sed, Abox.toprow, Abox.botrow);
  349.                 }
  350.                 else {
  351.                     sed_RepaintRows(sed, Abox.botrow, row);
  352.                 }
  353.             }
  354.         }
  355.         else if (mark_GetUpdate(tb->markbox.anchor_row, 
  356.             tb->markbox.anchor_col, lrow, lcol, row, col, &Abox, &Bbox)) {
  357.  
  358.             win_Paint(sed);
  359.         }
  360.         else {
  361.             if ((Abox.toprow <= Abox.botrow) && (Abox.leftcol <= Abox.rightcol)) {
  362.                 Abox.toprow -= sed_GetYoffset(sed);
  363.                 Abox.botrow -= sed_GetYoffset(sed);
  364.                 Abox.leftcol -= sed_GetXoffset(sed);
  365.                 Abox.rightcol -= sed_GetXoffset(sed);
  366.  
  367. #ifdef LNF        /* funny field marking */
  368.  
  369.                 Abox.leftcol = 0;
  370.                 Abox.rightcol = win_GetWidth(sed);
  371. #endif
  372.                 win_PaintBox(sed, &Abox);
  373.             }
  374.             if ((Bbox.toprow <= Bbox.botrow) && (Bbox.leftcol <= Bbox.rightcol)) {
  375.                 Bbox.toprow -= sed_GetYoffset(sed);
  376.                 Bbox.botrow -= sed_GetYoffset(sed);
  377.                 Bbox.leftcol -= sed_GetXoffset(sed);
  378.                 Bbox.rightcol -= sed_GetXoffset(sed);
  379.  
  380. #ifdef LNF
  381.                 Bbox.leftcol = 0;
  382.                 Bbox.rightcol = win_GetWidth(sed);
  383. #endif
  384.                 win_PaintBox(sed, &Bbox);
  385.             }
  386.         }
  387.     }
  388. }
  389.  
  390. static boolean mark_GetUpdate(int arow, int acol, int lrow, int lcol, int row, int col, ocbox *Abox, ocbox *Bbox)
  391. /*
  392.     finds the two minimum box paint
  393.     passes back minimum paint boxes Abox & Bbox
  394.     return value:     TRUE  == just paint the whole window
  395.                     FALSE == paint the boxes
  396. */
  397. {
  398.     int     y, z;
  399.  
  400.     boolean paint = TRUE;                    /* paint flag */
  401.  
  402.     /* compute repaint regions by quadrant */
  403.     if (row <= arow && lrow <= arow) {
  404.         /* 1 */
  405.         paint = FALSE;
  406.         y = (row > lrow) ? row : lrow;
  407.         z = (row < lrow) ? row : lrow;
  408.  
  409.         Abox->toprow = z;
  410.         Abox->botrow = arow;
  411.  
  412.         Bbox->toprow = Abox->toprow;
  413.         Bbox->botrow = y - 1;
  414.     }
  415.     else if (row >= arow && lrow >= arow) {
  416.         /* 2 */
  417.         paint = FALSE;
  418.         y = (row < lrow) ? row : lrow;
  419.         z = (row > lrow) ? row : lrow;
  420.  
  421.         Abox->toprow = arow;
  422.         Abox->botrow = z;
  423.  
  424.         Bbox->toprow = y + 1;
  425.         Bbox->botrow = Abox->botrow;
  426.     }
  427.  
  428.     if (!paint) {
  429.         if (col <= acol && lcol <= acol) {
  430.             /* 3 */
  431.             paint = FALSE;
  432.             y = (col > lcol) ? col : lcol;
  433.             z = (col < lcol) ? col : lcol;
  434.  
  435.             Abox->leftcol  = z;
  436.             Abox->rightcol = y - 1;
  437.  
  438.             Bbox->leftcol  = y;
  439.             Bbox->rightcol = acol;
  440.         }
  441.         else if (col >= acol && lcol >= acol) {
  442.             /* 4 */
  443.             paint = FALSE;
  444.             y = (col < lcol) ? col : lcol;
  445.             z = (col > lcol) ? col : lcol;
  446.  
  447.             Abox->leftcol  = y + 1;
  448.             Abox->rightcol = z;
  449.  
  450.             Bbox->leftcol  = acol;
  451.             Bbox->rightcol = y;
  452.         }
  453.         else {
  454.             paint = TRUE;
  455.         }
  456.     }
  457.     return(paint);
  458. }
  459.  
  460. #define HORZ_JUMP 5
  461.  
  462. boolean ted_Scroll(sed_type sed)
  463. /* 
  464.     checks whether the cursor is outside the window and scrolls appropriately 
  465. */
  466. {
  467.      int offset, row, col;
  468.     int deltaY = 0, deltaX = 0;
  469.     boolean ret = FALSE;
  470.  
  471.     row = sed_GetCRow(sed) - sed_GetYoffset(sed);
  472.     col = sed_GetCCol(sed) - sed_GetXoffset(sed);
  473.  
  474.     if ((offset = row) < 0) {
  475.         deltaY = offset;
  476.         ret = TRUE;
  477.     }        
  478.     else if ((offset = row - (sed_GetHeight(sed) - 1)) > 0){
  479.         deltaY = offset;
  480.         ret = TRUE;
  481.     }
  482.  
  483.     if ((offset = col) < 0) {
  484.         deltaX = (offset/HORZ_JUMP - 1) * HORZ_JUMP;
  485.         deltaX = (deltaX + sed_GetXoffset(sed) < 0) ? (-sed_GetXoffset(sed)) : deltaX;
  486.         ret = TRUE;
  487.     }
  488.     else if ((offset = col - (sed_GetWidth(sed) - 1)) > 0){
  489.         deltaX = (offset/HORZ_JUMP + 1) * HORZ_JUMP;
  490.         ret = TRUE;
  491.     }
  492.     if (ret && ted_GetRefresh(sed)) {
  493.         sd_scroll(sed, deltaY, deltaX, FALSE);
  494.     }                                                
  495.     return(ret);
  496. }
  497.  
  498. boolean ted_AddChar(sed_type sed, char c)
  499. {
  500.     return(ted_AddString(sed, &c, 1));
  501. }
  502.  
  503. boolean ted_AddString(sed_type sed, char *s, unsigned int len)
  504. /* 
  505.     places s at the cursor, resets hints, and refreshes display 
  506. */
  507. {
  508.     tb_type tb;
  509.     int        row, col, refresh_row, refresh_col, x, mode = TB_SAMECOLOR;
  510.     boolean ret;
  511.     boolean wrap;
  512.     byte    attr;
  513.     bblock_type b;
  514.  
  515.     ted_GetPosition(sed, &row, &col);
  516.  
  517.     /* check for color change */
  518.     tb = sed_GetTextbuf(sed);    
  519.     b = tb->bbc->b;
  520.     x = b->off + (int)(tb->cursor - tb->offset);
  521.     while (x > 0 && b->next != NULL) {
  522.         x -= b->len;
  523.         b = b->next;
  524.     }
  525.     if (x == 0) {
  526.         mode = TB_COLORNNL;
  527.         attr = b->attr;
  528.     }
  529.  
  530.     if ((refresh_row = tb_GetRow(tb)) > row - 1 && 
  531.         ((*s == ' ' || *s == '\t') && tb->width < 32000)) {
  532.  
  533.         refresh_row = (row > 0) ? row - 1 : 0;
  534.     }
  535.     refresh_col = (col >= tb->exp_len) ? tb->exp_len - 1 : col;
  536.  
  537.     if (row == tb_GetRow(tb) && col != tb->col && col < tb->exp_len) {
  538.         /* in middle of tab */
  539.         if (!menu_putTB(sed_GetMenu(sed), row, tb->col, NULL, ' ', 
  540.         col - tb->col, attr, attr, mode)) {
  541.             ret = FALSE;
  542.         }
  543.     }        
  544.     if (tb_FindLine(sed_GetTextbuf(sed), row) <= 0) {
  545.         wrap = FALSE;
  546.     }
  547.     else if (ted_GetInsert(sed)) {
  548.         wrap = (tb->width >= 32000 || tb->exp_len + len < tb->width)
  549.             ? FALSE : TRUE;
  550.     }
  551.     else {
  552.         wrap = TRUE;
  553.     }
  554.     ret = menu_putTB(sed_GetMenu(sed), row, col, s, 0x00, len, 
  555.         attr, attr, mode);
  556.  
  557.     if (win_IsEmployed(sed)) {
  558.         disp_Cache();
  559.     }
  560.  
  561.     ted_GotoPosition(sed, tb_GetRow(tb), tb_GetCol(tb));
  562.     if (ted_GetRefresh(sed)) {
  563.  
  564.         if (wrap || *s == '\n') {
  565.             sed_RepaintBelow(sed, refresh_row);
  566.         }
  567.         else if (refresh_row < row) {
  568.             sed_RepaintRows(sed, refresh_row, tb_GetRow(tb));
  569.         }
  570.         else {
  571.             sed_RepaintRow(sed, row, refresh_col, tb->exp_len - refresh_col);
  572.         }
  573.  
  574.         if (tb_GetRow(tb) > row) {
  575.             sed_SendBorderMsg(sed, BDM_SCROLL, NULL, NULL);
  576.         }
  577.     }
  578.  
  579.     if (win_IsEmployed(sed)) {
  580.         disp_Flush();
  581.     }
  582.  
  583.     tb->xcol = sed_GetCCol(sed);
  584.     return(ret);
  585. }
  586.  
  587. char ted_DeleteString(sed_type sed, int row, int col, unsigned int len)
  588. /* 
  589.     deletes the string at the row, col.
  590.     resets hints, and refreshes display 
  591. */
  592. {
  593.     tb_type tb;
  594.     int spaces, rowcount, before_len, xlen;
  595.     char oldchr[2];
  596.  
  597.     tb = sed_GetTextbuf(sed);    
  598.  
  599.     if (!tb_FindPosition(tb, row, col)) {
  600.         return('\0');
  601.     }
  602.     before_len = tb->len;
  603.     xlen = tb->exp_len;
  604.  
  605.     ted_GetString(sed, oldchr, 1);    /* remember the first deleted char */
  606.  
  607.     if ((spaces = col - (tb->exp_len - 1)) > 0) {
  608.         menu_Addc(sed_GetMenu(sed), row, tb->len, ' ', spaces);
  609.         tb_SetLineLen(tb);
  610.     }                
  611.  
  612.     rowcount = (sed_GetMenu(sed))->rowcount;
  613.     if (menu_strdel(sed_GetMenu(sed), row, col, (long)len) == 0L) {
  614.         *oldchr = '\0';
  615.     }
  616.  
  617.     ted_GotoPosition(sed, tb_GetRow(tb), tb_GetCol(tb));
  618.     if (row == tb_GetRow(tb) && col != tb->col && col < tb->exp_len) {
  619.         col = tb->col;
  620.     }
  621.  
  622.     if (ted_GetRefresh(sed)) {
  623.  
  624.         if (row != tb_GetRow(tb) || before_len - len != tb->len) {
  625.             sed_RepaintBelow(sed, (row <= 1) ? 0 : row - 1);
  626.         }
  627.         else {
  628.             sed_RepaintRow(sed, row, col, xlen - col);
  629.         }
  630.  
  631.         /* size change */
  632.         if (rowcount != (sed_GetMenu(sed))->rowcount) {
  633.             sed_SendBorderMsg(sed, BDM_SCROLL, NULL, NULL);
  634.         }
  635.     }
  636.     return(*oldchr);
  637. }
  638.  
  639.