home *** CD-ROM | disk | FTP | other *** search
/ Shareware 1 2 the Maxx / sw_1.zip / sw_1 / OS2 / BEAV132X.ZIP / DEF.H < prev    next >
C/C++ Source or Header  |  1992-01-06  |  22KB  |  534 lines
  1. /*
  2.  *     Common header file.
  3.  *
  4.  * This file is the general header file for all parts
  5.  * of the display editor. It contains all of the
  6.  * general definitions and macros. It also contains some
  7.  * conditional compilation flags. All of the per-system and
  8.  * per-terminal definitions are in special header files.
  9.  * The most common reason to edit this file would be to zap
  10.  * the definition of CVMVAS or BACKUP.
  11.  */
  12. #define LINT_ARGS   1           /* enable lint type checking */
  13. #include        "stdio.h"
  14.  
  15. #ifndef NOPROTO
  16. #ifdef UNIX
  17. #include        "sys/types.h"
  18. #endif /* UNIX */
  19. #include        "prototyp.h"
  20. #endif  /* NOPROTO */
  21.  
  22. #define BACKUP  1           /* Make backup file.            */
  23. #define RUNCHK  1           /* Do additional checking at run time */
  24.  
  25. #ifndef    uchar
  26. #define uchar   unsigned    char
  27. #endif
  28.  
  29. #ifndef    uint
  30. #define uint    unsigned    int
  31. #endif
  32.  
  33. #ifndef    ushort
  34. #define ushort  unsigned    short
  35. #endif
  36.  
  37. #ifndef    ulong
  38. #define ulong   unsigned    long
  39. #endif
  40.  
  41. /* these defines are reserved for handling data values from the buffer */
  42. #define     D8  uchar       /* this had better be a 8 bit quantity */
  43. #define     D16 ushort      /* this had better be a 16 bit quantity */
  44. #define     D32 ulong       /* this had better be a 32 bit quantity */
  45.  
  46. /* this define is reserved for the address of a location in the buffer */
  47. #define     A32 ulong        /* this is a 32 bit address into the buffer */
  48.  
  49. #define     bool char       /* used for boolean values      */
  50. #define     bits char       /* used for boolean bit flags   */
  51.  
  52. /* this define is reserved for the byte location in a LINE structure */
  53. #define     LPOS uint       /* this is a 32 bit address into the buffer */
  54.  
  55. /*
  56.  *      MS-DOS system header file.
  57.  */
  58. #if    MSDOS
  59. #define LARGE   1           /* Large model.         */
  60. #endif
  61. #define PCC 1               /* "[]" won't work.     */
  62. #define GOOD    0           /* Indicate hunkydoryhood   */
  63.  
  64. /*
  65.  * Macros used by the buffer name making code.
  66.  * Start at the end of the file name, scan to the left
  67.  * until BDC1 (or BDC2, if defined) is reached. The buffer
  68.  * name starts just to the right of that location, and
  69.  * stops at end of string (or at the next BDC3 character,
  70.  * if defined). BDC2 and BDC3 are mainly for VMS.
  71.  */
  72. #define BDC1    ':'         /* Buffer names.        */
  73. #define BDC2    '/'         /* Buffer names. jam    */
  74.  
  75. #ifdef UNIX
  76. #define PATHCHR ':'
  77. #define    SEPCHAR '/'
  78. #else
  79. #define PATHCHR ';'
  80. #define    SEPCHAR 0x5c    /* this is a \ char */
  81. #endif
  82.  
  83. /*
  84.  *      Digital ANSI terminal header file
  85.  */
  86. #ifdef MSDOS
  87. #define    ANSI    1            /* send ANSI escape codes */
  88. #endif
  89.  
  90. #define NMAXROW 128         /* Rows.for boot    */
  91. #define NMAXCOL 132
  92. #ifdef UNIX
  93. #define NROW    100
  94. #define NCOL    80          /* Columns.         */
  95. #else
  96. #define NROW    25          /* Rows.for boot    */
  97. #define NCOL    80          /* Columns.         */
  98. #endif
  99.  
  100. #define CUSTOMIZE                       /* compile switch for extended key
  101. binding in extend.c           */
  102. #define COSMETIC                        /* cosmetic screen stuff on
  103. insert off screen             */
  104. #ifdef MSDOS
  105. #define WANG_CHARACTER_SCREEN 0xf0000000L
  106. #endif
  107. /*
  108.  * Table sizes, etc.
  109.  */
  110. #define NSHASH  31          /* Symbol table hash size.      */
  111. #define NFILEN  256         /* Length, file name.           */
  112. #define NBUFN   13          /* Length, buffer name.     */
  113. #define NFILE   12          /* Length, file name.  */ /* krw */
  114. #define NKBDM   256         /* Length, keyboard macro.      */
  115. #define NMSG    512         /* Length, message buffer.      */
  116. #define NPAT    80          /* Length, pattern.             */
  117. #define HUGE    1000        /* A rather large number.       */
  118. #define NSRCH   128         /* Undoable search commands.    */
  119. #define NXNAME  64          /* Length, extended command.    */
  120. #define MAXPOS  0x7FFFFFFF  /* Maximum positive long value  */
  121.  
  122. /*
  123.  * This is the initial allocation for user data storage.
  124.  * It has should be in the range of 1 to less than half the size
  125.  * of an int.   The define LPOS is used to index into an array of this size.
  126.  * This is main tunable parameter for the speed of beav.
  127.  * If it is too large inserts and deletes will be slow but
  128.  * file loads will be fast and memory will be efficiently used.
  129.  * If it is too small the reverse will be true.
  130.  * This seems like a good number, but I have not tested it for performance.
  131.  */
  132. #define NLINE   0x1000      /* Length, line.      pvr  */
  133.  
  134. /*
  135.  * When memory must be reallocated this is added to the allocation
  136.  * request to allow for a little slop on areas that are being worked on.
  137.  * This should reduce the number of allocations done.
  138.  */
  139. #define NBLOCK  0x1000      /* Line block extra size        */
  140.  
  141. /*
  142.  * This is the number of bytes that are allocated for the kill buffer
  143.  * when data cannot be moved by changing the pointers.
  144.  */
  145. #define KBLOCK  0x1000      /* Kill buffer block size.  */
  146.  
  147. /*
  148.  * Universal.
  149.  */
  150. #define FALSE   0                       /* False, no, bad, etc.         */
  151. #define TRUE    1                       /* True, yes, good, etc.        */
  152. #define ABORT   2                       /* Death, ^G, abort, etc.       */
  153.  
  154. /*
  155.  * These flag bits keep track of
  156.  * some aspects of the last command.
  157.  * The CFKILL flag controls the clearing versus appending
  158.  * of data in the kill buffer.
  159.  */
  160. #define CFKILL  0x0002                  /* Last command was a kill      */
  161.  
  162. /*
  163.  * File I/O.
  164.  */
  165. #define FIOSUC  0                       /* Success.                     */
  166. #define FIOFNF  1                       /* File not found.              */
  167. #define FIOEOF  2                       /* End of file.                 */
  168. #define FIOERR  3                       /* Error.                       */
  169.  
  170. /*
  171.  * Directory I/O.
  172.  */
  173. #define DIOSUC  0                       /* Success.                     */
  174. #define DIOEOF  1                       /* End of file.                 */
  175. #define DIOERR  2                       /* Error.                       */
  176.  
  177. /*
  178.  * Display colors.
  179.  */
  180. #define CNONE   0                       /* Unknown color.               */
  181. #define CTEXT   1                       /* Text color.                  */
  182. #define CMODE   2                       /* Mode line color.             */
  183.  
  184. /*
  185.  * Flags for "eread".
  186.  */
  187. #define EFNEW   0x0001                  /* New prompt.                  */
  188. #define EFAUTO  0x0002                  /* Autocompletion enabled.      */
  189. #define EFCR    0x0004                  /* Echo CR at end; last read.   */
  190.  
  191. /*
  192.  * Keys are represented inside using an 11 bit
  193.  * keyboard code. The transformation between the keys on
  194.  * the keyboard and 11 bit code is done by terminal specific
  195.  * code in the "kbd.c" file. The actual character is stored
  196.  * in 8 bits (DEC multinationals work); there is also a control
  197.  * flag KCTRL, a meta flag KMETA, and a control-X flag KCTLX.
  198.  * ASCII control characters are always represented using the
  199.  * KCTRL form. Although the C0 control set is free, it is
  200.  * reserved for C0 controls because it makes the communication
  201.  * between "getkey" and "getkbd" easier. The funny keys get
  202.  * mapped into the C1 control area.
  203.  */
  204. #define NKEYS   4096                    /* 12 bit code.                 */
  205.  
  206. #define METACH  0x1B                    /* M- prefix,   Control-[, ESC  */
  207. #define CTMECH  0x1C                    /* C-M- prefix, Control-\       */
  208. #define EXITCH  0x1D                    /* Exit level,  Control-]       */
  209. #define CTRLCH  0x1E                    /* C- prefix,   Control-^       */
  210. #define HELPCH  0x1F                    /* Help key,    Control-_       */
  211. #define CTL_G   0x07                    /* Abort command key            */
  212.  
  213. #define KCHAR   0x00FF                  /* The basic character code.    */
  214. #define KCTRL   0x0100                  /* Control flag.                */
  215. #define KMETA   0x0200                  /* Meta flag.                   */
  216. #define KCTLX   0x0400                  /* Control-X flag.              */
  217.  
  218. #define KFIRST  0x0080                  /* First special.       fitz    */
  219. #define KLAST   0x00F3                  /* Last special.                */
  220.  
  221. #define KRANDOM 0x0080                  /* A "no key" code.             */
  222.  
  223. /*
  224. *    This causes the key sequence ESC [ <key> to be delevered as
  225. *    KCTRL | KMETA | KCTLX | <key>.   This allows VT100 function keys
  226. *    to be bound.
  227. */
  228. #define    VT100KEY
  229.  
  230. /*
  231.  *    These define the column used in the help (wallchart) function
  232.  */
  233. #define    HFUNCCOL    3
  234. #define    HKEY        32
  235. #define    HKEYCODE    50
  236. #define    HENDCOL     55
  237.  
  238. /*
  239.  * These flags, and the macros below them,
  240.  * make up a do-it-yourself set of "ctype" macros that
  241.  * understand the DEC multinational set, and let me ask
  242.  * a slightly different set of questions.
  243.  */
  244. #define _W      0x01                    /* Word.                        */
  245. #define _U      0x02                    /* Upper case letter.           */
  246. #define _L      0x04                    /* Lower case letter.           */
  247. #define _C      0x08                    /* Control.                     */
  248.  
  249. #define ISCTRL(c)       ((cinfo[(c)]&_C)!=0)
  250. #define ISUPPER(c)      ((cinfo[(c)]&_U)!=0)
  251. #define ISLOWER(c)      ((cinfo[(c)]&_L)!=0)
  252. #define TOUPPER(c)      ((c)-0x20)
  253. #define TOLOWER(c)      ((c)+0x20)
  254.  
  255. #define BUF_SIZE(wp)    (wp -> w_bufp -> b_linep -> l_bp -> l_file_offset + \
  256.                         wp -> w_bufp -> b_linep -> l_bp -> l_used)
  257. #define BUF_START(wp)   (wp -> w_bufp -> b_linep -> l_fp -> l_file_offset)
  258. #define DOT_POS(wp)     (wp -> w_dotp -> l_file_offset + wp -> w_doto)
  259. #define MARK_POS(wp)    (wp -> w_markp -> l_file_offset + wp -> w_marko)
  260. #define DOT_CHAR(wp)    (wp -> w_dotp -> l_text[wp -> w_doto])
  261. #define WIND_POS(wp)    (wp -> w_linep -> l_file_offset + wp -> w_loff)
  262. #define R_TYPE(wp)      (wp -> w_fmt_ptr -> r_type)
  263. #define R_SIZE(wp)      (wp -> w_fmt_ptr -> r_size)
  264. #define R_UNITS(wp)     (wp -> w_fmt_ptr -> r_units)
  265. #define R_BYTES(wp)     (wp -> w_fmt_ptr -> r_bytes)
  266. #define R_ALIGN(wp)     (wp -> w_fmt_ptr -> r_align)
  267. #define R_B_PER_U(wp)   (wp -> w_fmt_ptr -> r_b_per_u)
  268. #define R_CHR_PER_U(wp) (wp -> w_fmt_ptr -> r_chr_per_u)
  269. #define R_FLAGS(wp)     (wp -> w_fmt_ptr -> r_flags)
  270. #define R_UNIT_FMT(wp)  (wp -> w_fmt_ptr -> r_unit_fmt)
  271. #define R_POS_FMT(wp)   (wp -> w_fmt_ptr -> r_pos_fmt)
  272. #define R_BYTE_FMT(wp)   (wp -> w_fmt_ptr -> r_byte_fmt)
  273. #define R_POSITIONS(wp) (wp -> w_fmt_ptr -> r_positions)
  274.  
  275. /*
  276.  * The symbol table links editing functions
  277.  * to names. Entries in the key map point at the symbol
  278.  * table entry. A reference count is kept, but it is
  279.  * probably next to useless right now. The old type code,
  280.  * which was not being used and probably not right
  281.  * anyway, is all gone.
  282.  */
  283. typedef struct  SYMBOL {
  284.     struct  SYMBOL *s_symp;         /* Hash chain.                  */
  285.     short   s_nkey;                 /* Count of keys bound here.    */
  286.     char    *s_name;                /* Name.            */
  287.     bool    (*s_funcp)();           /* Function.                    */
  288.     bits    s_modify;               /* modify bit */
  289. }       SYMBOL;
  290.  
  291. /*
  292. *   These are the legal values for 's_modify' and 'k_modify'
  293. */
  294. #define SMOD    0x01            /* command modifies the buffer  */
  295. #define SSIZE   0x02            /* command changes buffer size  */
  296. #define SSRCH   0x04            /* command valid in search  */
  297. #define SRPLC   0x08            /* command valid in replace */
  298. #define SBOUND  0x10            /* key was bound bu user or rc file */
  299.  
  300. /*
  301.  * There is a window structure allocated for
  302.  * every active display window. The windows are kept in a
  303.  * big list, in top to bottom screen order, with the listhead at
  304.  * "wheadp". Each window contains its own values of dot and mark.
  305.  * The flag field contains some bits that are set by commands
  306.  * to guide redisplay; although this is a bit of a compromise in
  307.  * terms of decoupling, the full blown redisplay is just too
  308.  * expensive to run for every input character.
  309.  */
  310. typedef struct  WINDOW {
  311.     struct  WINDOW *w_wndp;         /* Next window                  */
  312.     struct  BUFFER *w_bufp;         /* Buffer displayed in window   */
  313.     struct  LINE *w_linep;          /* Top line in the window       */
  314.     LPOS    w_loff;                 /* Offset into line for start pvr  */
  315.     A32     w_wind_temp;            /* temp storage for window file pos */
  316.     struct  LINE *w_dotp;           /* Line containing "."          */
  317.     LPOS    w_doto;                 /* Offset into line for "." */
  318.     A32     w_dot_temp;             /* temp storage for dot file pos */
  319.     struct  LINE *w_markp;          /* Line containing "mark"       */
  320.     LPOS    w_marko;                /* Byte offset for "mark"       */
  321.     A32     w_mark_temp;            /* temp storage for mark file pos */
  322.     char    w_unit_offset;          /* Byte offset for "." into unit pvr */
  323.     char    w_toprow;               /* Origin 0 top row of window   */
  324.     char    w_ntrows;               /* # of rows of text in window  */
  325.     bits    w_flag;                 /* Flags.                       */
  326.     char    w_disp_shift;           /* Display byte shift; 0-3  pvr */
  327.     bool    w_intel_mode;           /* Display byte swaped.     pvr */
  328.     struct  ROW_FMT *w_fmt_ptr;     /* Pointer to display format pvr */
  329. }       WINDOW;
  330.  
  331. /*
  332.  * Window flags are set by command processors to
  333.  * tell the display system what has happened to the buffer
  334.  * mapped by the window. Setting "WFHARD" is always a safe thing
  335.  * to do, but it may do more work than is necessary. Always try
  336.  * to set the simplest action that achieves the required update.
  337.  * Because commands set bits in the "w_flag", update will see
  338.  * all change flags, and do the most general one.
  339.  */
  340. #define WFFORCE 0x01                    /* Force reframe.               */
  341. #define WFMOVE  0x02                    /* Movement from line to line.  */
  342. #define WFEDIT  0x04                    /* Editing within a line.       */
  343. #define WFHARD  0x08                    /* Better to a full display.    */
  344. #define WFMODE  0x10                    /* Update mode line.        */
  345. /*
  346. *   This structure contains how a row is constructed.   pvr
  347. */
  348.  
  349. typedef struct  ROW_FMT {
  350.     uchar   r_type;     /* format type nibbles          */
  351.     uchar   r_size;     /* format size: must be 0,1,3,7,15, etc */
  352.     uchar   r_units;    /* number of units per window row: must be 1,2,4,8,16*/
  353.     uchar   r_bytes;    /* number of bytes per window row: must be 1,2,4,8,16*/
  354.     uchar   r_align;    /* number of bytes per align row: must be 1,2,4,8,16*/
  355.     uchar   r_b_per_u;  /* number of bytes per unit: must be 1,2,4,8,16 */
  356.     uchar   r_chr_per_u; /* displayed chars per unit     */
  357.     bits    r_flags;    /* flags controlling format     */
  358.     char    *r_unit_fmt; /* print format for unit */
  359.     char    *r_pos_fmt; /* print format for buffer position, always a long */
  360.     char    *r_byte_fmt; /* print format for bytes */
  361.     uchar   *r_positions; /* list of unit positions   */
  362.     struct ROW_FMT *r_srch_fmt; /* pointer to search display format */
  363. } ROW_FMT;
  364.  
  365. /* legal values for 'r_size'  (values significant; used as bit mask) pvr */
  366.  
  367. #define BYTES   0x00        /* Display as byte; 8 bits  */
  368. #define WORDS   0x01        /* Display as word;    16 bits  */
  369. #define DWORDS  0x03        /* Display as doubles; 32 bits  */
  370.  
  371. /* legal values for 'r_type'   pvr */
  372. #define ASCII   0x10        /* Display as ascii     */
  373. #define OCTAL   0x20        /* Display as octal values  */
  374. #define DECIMAL 0x30        /* Display as decimal values    */
  375. #define HEX     0x40        /* Display as hex values    */
  376. #define BINARY  0x50        /* Display as binary values */
  377. #define EBCDIC  0x60        /* Display as ebcdic        */
  378. #define TEXT    0x70        /* Display as normal text   */
  379.  
  380. /*
  381.  * Text is kept in buffers. A buffer header, described
  382.  * below, exists for every buffer in the system. The buffers are
  383.  * kept in a big list, so that commands that search for a buffer by
  384.  * name can find the buffer header. There is a safe store for the
  385.  * dot and mark in the header, but this is only valid if the buffer
  386.  * is not being displayed (that is, if "b_nwnd" is 0). The text for
  387.  * the buffer is kept in a circularly linked list of lines, with
  388.  * a pointer to the header line in "b_linep".
  389.  */
  390. typedef struct  BUFFER {
  391.     bits    b_type;         /* Type of buffer       */
  392.     struct  BUFFER *b_bufp; /* Link to next BUFFER          */
  393.     struct  LINE *b_dotp;   /* Link to "." LINE structure   */
  394.     LPOS    b_doto;         /* Offset of "." in above LINE  */
  395.     char    b_unit_offset;  /* Offset into unit for "." pvr */
  396.     struct  LINE *b_markp;  /* The same as the above two,   */
  397.     LPOS    b_marko;        /* but for the "mark"       */
  398.     struct  LINE *b_linep;  /* Link to the header LINE      */
  399.     char    b_nwnd;         /* Count of windows on buffer   */
  400.     bits    b_flag;         /* Flags            */
  401.     A32     b_begin_addr;   /* File address of begining of buffer */
  402.     A32     b_end_addr;     /* File address of end of buffer */
  403.     A32     b_file_size;    /* Size of file */
  404.     char    b_fname[NFILEN]; /* File name                    */
  405.     char    b_bname[NBUFN];  /* Buffer name                  */
  406. }   BUFFER;
  407.  
  408. /* Values for 'buf_type' */
  409. #define BTFILE   0x00            /* Buffer contains a file   */
  410. #define BTDISK   0x01            /* Buffer points to a disk  */
  411. #define BTMEMORY 0x02            /* Buffer points to memory  */
  412. #define BTSAVE   0x03            /* This is the save buffer */
  413. #define BTLIST   0x04            /* This is the buffer list */
  414. #define BTHELP   0x05            /* This is the help buffer */
  415.  
  416. /* Values for 'b_flag' */
  417.  
  418. #define BFCHG   0x01            /* Changed.         */
  419. #define BFBAK   0x02            /* Need to make a backup.       */
  420. #define BFBAD   0x04            /* may be trashed alloc error?  */
  421. #define BFINMEM 0x08            /* File is entirely in memory */
  422. #define BFVIEW  0x10            /* read only (jam)               */
  423. #define BFLINK  0x20            /* Linked mode    pvr        */
  424. #define BFSLOCK 0x40            /* Lock buffer size   pvr    */
  425. /*
  426.  * This structure holds the starting position
  427.  * (as a line/offset pair) and the number of characters in a
  428.  * region of a buffer. This makes passing the specification
  429.  * of a region around a little bit easier.
  430.  * There have been some complaints that the short in this
  431.  * structure is wrong; that a long would be more appropriate.
  432.  * I'll await more comments from the folks with the little
  433.  * machines; I have a VAX, and everything fits.
  434.  */
  435. typedef struct  reg {
  436.     struct  LINE *r_linep;          /* Origin LINE address.         */
  437.     LPOS    r_offset;               /* Origin LINE offset.          */
  438.     A32     r_size;                 /* Length in characters.        */
  439. }       REGION;
  440.  
  441. /*
  442.  * All text is kept in circularly linked
  443.  * lists of "LINE" structures. These begin at the
  444.  * header line (which is the blank line beyond the
  445.  * end of the buffer). This line is pointed to by
  446.  * the "BUFFER". Each line contains a the number of
  447.  * bytes in the line (the "used" size), the size
  448.  * of the text array, and the text. The end of line
  449.  * is not stored as a byte; it's implied. Future
  450.  * additions will include update hints, and a
  451.  * list of marks into the line.
  452.  */
  453. typedef struct  LINE {
  454.     struct  LINE *l_fp;       /* Link to the next line        */
  455.     struct  LINE *l_bp;       /* Link to the previous line    */
  456.     A32     l_file_offset;        /* Offset from begining of file pvr */
  457.     LPOS    l_size;           /* Allocated size           */
  458.     LPOS    l_used;           /* Used size            */
  459. #if     PCC
  460.     D8      l_text[1];        /* A bunch of characters.       */
  461. #else
  462.     D8      l_text[];         /* A bunch of characters.       */
  463. #endif
  464. }      LINE;
  465.  
  466. /*
  467.  * The rationale behind these macros is that you
  468.  * could (with some editing, like changing the type of a line
  469.  * link from a "LINE *" to a "REFLINE", and fixing the commands
  470.  * like file reading that break the rules) change the actual
  471.  * storage representation of lines to use something fancy on
  472.  * machines with small address spaces.
  473.  */
  474. #define lforw(lp)       ((lp)->l_fp)
  475. #define lback(lp)       ((lp)->l_bp)
  476. #define lgetc(lp, n)    ((lp)->l_text[(n)]&0xFF)
  477. #define lputc(lp, n, c) ((lp)->l_text[(n)]=(c))
  478. #define llength(lp)     ((lp)->l_used)
  479.  
  480. /*
  481.  * Externals.
  482.  */
  483. extern  int     thisflag;
  484. extern  int     lastflag;
  485. extern  int     curgoal;
  486. extern  int     epresf;
  487. extern  int     sgarbf;
  488. extern  WINDOW  *curwp;
  489. extern  BUFFER  *curbp;
  490. extern  WINDOW  *wheadp;
  491. extern  BUFFER  *bheadp;
  492. extern  BUFFER  *blistp;
  493. extern  short   kbdm[];
  494. extern  short   *kbdmip;
  495. extern  short   *kbdmop;
  496. extern  SYMBOL  *symbol[];
  497. extern  SYMBOL  *binding[];
  498. extern  BUFFER  *bfind();
  499. extern  BUFFER  *bcreate();
  500. extern  WINDOW  *wpopup();
  501. extern  LINE    *lalloc();
  502. extern  int     nrow;
  503. extern  int     ncol;
  504. extern  char    version[];
  505. extern  int     ttrow;
  506. extern  int     ttcol;
  507. extern  int     tceeol;
  508. extern  int     tcinsl;
  509. extern  int     tcdell;
  510. extern  char    cinfo[];
  511. extern  SYMBOL  *symlookup();
  512. extern  int     nmsg;
  513. extern  int     curmsgf;
  514. extern  int     newmsgf;
  515. extern  char    msg[];
  516.  
  517. /* jam
  518.  */
  519. extern  char    *okmsg;
  520. extern  int     insert_mode;
  521. extern  int     extend_buf;
  522. extern  int     flush_num;
  523. extern  int     auto_update;
  524. extern  int     flush_count;
  525. extern  int     rowb;
  526. extern  char    file_off_bad;
  527.  
  528. /*
  529.  * Standard I/O.
  530.  */
  531. extern  char    *malloc();
  532. extern  char    *strcpy();
  533. extern  char    *strcat();
  534.