rfivet/uemacs
1
0
Fork 0
mirror of https://github.com/rfivet/uemacs.git synced 2025-02-20 23:17:13 -05:00
Code Releases Activity

Revise bindable functions usage of struct to named types.

Browse Source
This commit is contained in:
Renaud 2021-08-03 13:37:06 +08:00
parent 7730a4e730
commit d890880a52
16 changed files with 427 additions and 567 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
execute.c
View File

@ -78,7 +78,7 @@ static int insbrace( int n, int c) {
count = 1 ;
do {
if( boundry( curwp->w_dotp, curwp->w_doto, REVERSE)) {
if( boundary( curwp->w_dotp, curwp->w_doto, REVERSE)) {
/* at beginning of buffer, no match to be found */
curwp->w_dotp = oldlp ;
curwp->w_doto = oldoff ;
@ -166,7 +166,7 @@ static void fmatch( int ch) {
do {
/* At beginning of window or buffer, no match to be found */
if( curwp->w_dotp == toplp
|| boundry( curwp->w_dotp, curwp->w_doto, REVERSE))
|| boundary( curwp->w_dotp, curwp->w_doto, REVERSE))
break ;
backchar( FALSE, 1) ;
@ -261,7 +261,7 @@ BINDABLE( getfence) {
/* scan until we find a match, or reach the end of file */
count = 1 ;
do {
if( boundry( curwp->w_dotp, curwp->w_doto, sdir)) {
if( boundary( curwp->w_dotp, curwp->w_doto, sdir)) {
/* at buffer limit, no match to be found */
/* restore the current position */
curwp->w_dotp = oldlp ;

130
file.c
View File

@ -1,5 +1,4 @@
/* file.c -- implements file.h */
#include "file.h"
/* file.c
@ -65,21 +64,17 @@ boolean resterr( void) {
return FALSE ;
}
/*
* Read a file into the current
* buffer. This is really easy; all you do is
* find the name of the file, and call the standard
* "read a file into the current buffer" code.
* Bound to "C-X C-R".
/* Read a file into the current buffer. This is really easy; all you do is
* find the name of the file, and call the standard "read a file into the
* current buffer" code. Bound to C-X C-R read-file.
*/
int fileread( int f, int n) {
int status ;
BINDABLE( fileread) {
char *fname ;
if( restflag) /* don't allow this command if restricted */
return resterr() ;
status = newmlarg( &fname, "Read file: ", sizeof( fname_t)) ;
int status = newmlarg( &fname, "read-file: ", sizeof( fname_t)) ;
if( status == TRUE) {
status = readin( fname, TRUE) ;
free( fname) ;
@ -88,25 +83,19 @@ int fileread( int f, int n) {
return status ;
}
/*
* Insert a file into the current
* buffer. This is really easy; all you do is
* find the name of the file, and call the standard
* "insert a file into the current buffer" code.
* Bound to "C-X C-I".
/* Insert a file into the current buffer. This is really easy; all you do
* is find the name of the file, and call the standard "insert a file into
* the current buffer" code. Bound to C-X C-I insert-file.
*/
int insfile( int f, int n) {
int status ;
BINDABLE( insfile) {
char *fname ;
if( restflag) /* don't allow this command if restricted */
return resterr() ;
// if( curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly() ; /* we are in read only mode */
assert( !(curbp->b_mode & MDVIEW)) ;
status = newmlarg( &fname, "Insert file: ", sizeof( fname_t)) ;
int status = newmlarg( &fname, "insert-file: ", sizeof( fname_t)) ;
if( status == TRUE) {
status = ifile( fname) ;
free( fname) ;
@ -118,23 +107,18 @@ int insfile( int f, int n) {
return reposition( TRUE, -1) ; /* Redraw with dot at bottom of window */
}
/*
* Select a file for editing.
* Look around to see if you can find the
* file in another buffer; if you can find it
* just switch to the buffer. If you cannot find
* the file, create a new buffer, read in the
* text, and switch to the new buffer.
* Bound to C-X C-F.
/* Select a file for editing. Look around to see if you can find the file
* in another buffer; if you can find it just switch to the buffer. If you
* cannot find the file, create a new buffer, read in the text, and switch
* to the new buffer. Bound to C-X C-F find-file.
*/
int filefind( int f, int n) {
BINDABLE( filefind) {
char *fname ; /* file user wishes to find */
int status ; /* status return */
if( restflag) /* don't allow this command if restricted */
return resterr() ;
status = newmlarg( &fname, "find-file: ", sizeof( fname_t)) ;
int status = newmlarg( &fname, "find-file: ", sizeof( fname_t)) ;
if( status == TRUE) {
status = getfile( fname, TRUE) ;
free( fname) ;
@ -152,16 +136,15 @@ static void upd_mode( void) {
wp->w_flag |= WFMODE ;
}
int viewfile( int f, int n) { /* visit a file in VIEW mode */
BINDABLE( viewfile) { /* visit a file in VIEW mode */
char *fname ; /* file user wishes to find */
int status ; /* status return */
if( restflag) /* don't allow this command if restricted */
return resterr() ;
status = newmlarg( &fname, "View file: ", sizeof( fname_t)) ;
int status = newmlarg( &fname, "view-file: ", sizeof( fname_t)) ;
if( status == TRUE) {
status = getfile(fname, FALSE) ;
status = getfile( fname, FALSE) ;
free( fname) ;
if( status == TRUE) { /* if we succeed, put it in view mode */
@ -180,7 +163,7 @@ int viewfile( int f, int n) { /* visit a file in VIEW mode */
* boolean lockfl; check the file for locks?
*/
int getfile( const char *fname, boolean lockfl) {
struct buffer *bp;
buffer_p bp;
int s;
bname_t bname ; /* buffer name to put file */
@ -264,7 +247,7 @@ int getfile( const char *fname, boolean lockfl) {
int readin(const char *fname, boolean lockfl)
{
struct window *wp;
struct buffer *bp;
buffer_p bp;
int status ;
fio_code s ;
@ -437,23 +420,17 @@ void unqname(char *name)
}
}
/*
* Ask for a file name, and write the
* contents of the current buffer to that file.
* Update the remembered file name and clear the
* buffer changed flag. This handling of file names
* is different from the earlier versions, and
* is more compatible with Gosling EMACS than
* with ITS EMACS. Bound to "C-X C-W".
/* Ask for a file name, and write the content of the current buffer to that
* file. Update the remembered file name and clear the buffer changed
* flag. Bound to C-X C-W write-file.
*/
int filewrite( int f, int n) {
int status ;
BINDABLE( filewrite) {
char *fname ;
if( restflag) /* don't allow this command if restricted */
return resterr() ;
status = newmlarg( &fname, "Write file: ", sizeof( fname_t)) ;
int status = newmlarg( &fname, "write-file: ", sizeof( fname_t)) ;
if( status == TRUE) {
if( strlen( fname) > sizeof( fname_t) - 1)
status = FALSE ;
@ -469,32 +446,27 @@ int filewrite( int f, int n) {
return status ;
}
/*
* Save the contents of the current
* buffer in its associated file. Do nothing
* if nothing has changed (this may be a bug, not a
* feature). Error if there is no remembered file
* name for the buffer. Bound to "C-X C-S". May
* get called by "C-Z".
/* Save the content of the current buffer in its associated file. Do
* nothing if nothing has changed (this may be a bug, not a feature).
* Error if there is no remembered file name for the buffer. Bound to "C-X
* C-S save-file". May get called by "M-Z quick-exit".
*/
int filesave( int f, int n) {
// if (curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly(); /* we are in read only mode */
BINDABLE( filesave) {
assert( !(curbp->b_mode & MDVIEW)) ;
if ((curbp->b_flag & BFCHG) == 0) /* Return, no changes. */
return TRUE;
if (curbp->b_fname[0] == 0) { /* Must have a name. */
mloutstr( "No file name") ;
return FALSE;
if( (curbp->b_flag & BFCHG) == 0) /* Return, no changes. */
return TRUE ;
if( curbp->b_fname[0] == 0) { /* Must have a name. */
mloutfmt( "%BNo file name") ;
return FALSE ;
}
/* complain about truncated files */
if ((curbp->b_flag & BFTRUNC) != 0) {
if (mlyesno("Truncated file ... write it out") == FALSE) {
mloutstr( "(Aborted)") ;
return FALSE;
}
if( (curbp->b_flag & BFTRUNC) != 0
&& mlyesno("Truncated file ... write it out") == FALSE) {
mloutfmt( "%B(Aborted)") ;
return FALSE ;
}
return writeout( curbp->b_fname) ;
@ -544,23 +516,19 @@ int writeout( const char *fn) {
return FALSE ;
}
/*
* The command allows the user
* to modify the file name associated with
* the current buffer. It is like the "f" command
* in UNIX "ed". The operation is simple; just zap
* the name in the buffer structure, and mark the windows
* as needing an update. You can type a blank line at the
* prompt if you wish.
/* The command allows the user to modify the file name associated with the
current buffer. It is like the "f" command in UNIX "ed". The operation
is simple; just zap the name in the buffer structure, and mark the
windows as needing an update. You can type a blank line at the prompt
if you wish. Bound to C-X N change-file-name.
*/
int filename( int f, int n) {
int status ;
BINDABLE( filename) {
char *fname ;
if( restflag) /* don't allow this command if restricted */
return resterr() ;
status = newmlarg( &fname, "Name: ", sizeof( fname_t)) ;
int status = newmlarg( &fname, "Name: ", sizeof( fname_t)) ;
if( status == ABORT)
return status ;
else if( status == FALSE)
@ -653,3 +621,5 @@ static int ifile( const char *fname) {
return (s == FIOERR) ? FALSE : TRUE ;
}
/* end of file.c */

22
file.h
View File

@ -1,23 +1,29 @@
/* file.h -- file centric commands */
#ifndef _FILE_H_
#define _FILE_H_
#include "buffer.h"
#include "retcode.h"
#include "names.h"
extern boolean restflag ; /* restricted use? */
boolean resterr( void) ; /* restricted error message */
int fileread( int f, int n) ;
int insfile( int f, int n) ;
int filefind( int f, int n) ;
int viewfile( int f, int n) ;
/* Bindable functions */
BINDABLE( filefind) ;
BINDABLE( fileread) ;
BINDABLE( filename) ;
BINDABLE( filesave) ;
BINDABLE( filewrite) ;
BINDABLE( insfile) ;
BINDABLE( viewfile) ;
int getfile( const char *fname, boolean lockfl) ;
int readin( const char *fname, boolean lockfl) ;
void makename( bname_t bname, const char *fname) ;
void unqname( char *name) ;
int filewrite( int f, int n) ;
int filesave( int f, int n) ;
int writeout( const char *fn) ;
int filename( int f, int n) ;
#endif
/* end of file.h */

169
line.c
View File

@ -1,6 +1,7 @@
/* line.c
*
* The functions in this file are a general set of line management utilities.
/* line.c -- implements line.h */
#include "line.h"
/* The functions in this file are a general set of line management utilities.
* They are the only routines that touch the text. They also touch the buffer
* and window structures, to make sure that the necessary updating gets done.
* There are routines in this file that handle the kill buffer too. It isn't
@ -13,12 +14,9 @@
*
*/
#include "line.h"
#include <assert.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h> /* NULL, offsetof() */
#include <stdlib.h> /* malloc(), free() */
#include <string.h>
#include "buffer.h"
@ -41,13 +39,13 @@ static int ldelnewline( void) ;
#define KBLOCK 250 /* sizeof kill buffer chunks */
struct kill {
typedef struct kill {
struct kill *d_next; /* Link to next chunk, NULL if last. */
char d_chunk[KBLOCK]; /* Deleted text. */
};
} *kill_p ;
static struct kill *kbufp = NULL ; /* current kill buffer chunk pointer */
static struct kill *kbufh = NULL ; /* kill buffer header pointer */
static kill_p kbufp = NULL ; /* current kill buffer chunk pointer */
static kill_p kbufh = NULL ; /* kill buffer header pointer */
static int kused = KBLOCK ; /* # of bytes used in kill buffer */
static int klen ; /* length of kill buffer content */
static char *value = NULL ; /* temp buffer for value */
@ -56,7 +54,7 @@ static char *value = NULL ; /* temp buffer for value */
* return some of the contents of the kill buffer
*/
char *getkill( void) {
struct kill *kp ;
kill_p kp ;
char *cp ;
if (kbufh == NULL)
@ -160,12 +158,14 @@ boolean forwchar( int f, int n) {
*/
line_p lalloc( int used) {
#define BLOCK_SIZE 16 /* Line block chunk size. */
line_p lp ;
int size ;
/* size = used + BLOCK_SIZE - used % BLOCK_SIZE ; */
size = (used + BLOCK_SIZE) & ~(BLOCK_SIZE - 1) ; /* as BLOCK_SIZE is power of 2 */
lp = (line_p) malloc( offsetof( struct line, l_text) + size) ;
/* rounding down use masking instead or modulo when BLOCK_SIZE is power of 2 */
#if (BLOCK_SIZE & -BLOCK_SIZE) == BLOCK_SIZE
int size = (used + BLOCK_SIZE) & ~(BLOCK_SIZE - 1) ;
#else
int size = used + BLOCK_SIZE - used % BLOCK_SIZE ;
#endif
line_p lp = (line_p) malloc( offsetof( struct line, l_text) + size) ;
if( lp == NULL)
mloutstr( "(OUT OF MEMORY)") ;
else {
@ -183,7 +183,7 @@ line_p lalloc( int used) {
* conditions described in the above comments don't hold here.
*/
void lfree( line_p lp) {
struct buffer *bp;
buffer_p bp;
struct window *wp;
wp = wheadp;
@ -295,18 +295,13 @@ int linstr( char *instr) {
boolean linsert_byte( int n, int c) {
char *cp1;
char *cp2;
struct line *lp1;
struct line *lp2;
struct line *lp3;
line_p lp1, lp2, lp3 ;
int doto;
int i;
struct window *wp;
assert( (curbp->b_mode & MDVIEW) == 0) ;
#if 0
if (curbp->b_mode & MDVIEW) /* don't allow this command if */
return rdonly(); /* we are in read only mode */
#endif
lchange(WFEDIT);
lp1 = curwp->w_dotp; /* Current line */
if (lp1 == curbp->b_linep) { /* At the end: special */
@ -314,8 +309,11 @@ boolean linsert_byte( int n, int c) {
mloutstr( "bug: linsert") ;
return FALSE;
}
if ((lp2 = lalloc(n)) == NULL) /* Allocate new line */
return FALSE;
lp2 = lalloc( n) ; /* Allocate new line */
if( lp2 == NULL)
return FALSE ;
lp3 = lp1->l_bp; /* Previous line */
lp3->l_fp = lp2; /* Link in */
lp2->l_fp = lp1;
@ -329,8 +327,10 @@ boolean linsert_byte( int n, int c) {
}
doto = curwp->w_doto; /* Save for later. */
if (lp1->l_used + n > lp1->l_size) { /* Hard: reallocate */
if ((lp2 = lalloc(lp1->l_used + n)) == NULL)
return FALSE;
lp2 = lalloc( lp1->l_used + n) ;
if( lp2 == NULL)
return FALSE ;
cp1 = &lp1->l_text[0];
cp2 = &lp2->l_text[0];
while (cp1 != &lp1->l_text[doto])
@ -374,8 +374,6 @@ boolean linsert_byte( int n, int c) {
int linsert( int n, unicode_t c) {
assert( n >= 0) ;
// if (curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly(); /* we are in read only mode */
assert( !(curbp->b_mode & MDVIEW)) ;
if( n > 0) {
@ -398,16 +396,14 @@ int linsert( int n, unicode_t c) {
return TRUE;
}
/*
* Overwrite a character into the current line at the current position
/* Overwrite a character into the current line at the current position
*
* int c; character to overwrite on current position
* int c ; character to overwrite on current position
*/
static int lowrite( int c) {
if( curwp->w_doto < curwp->w_dotp->l_used
&& (
lgetc(curwp->w_dotp, curwp->w_doto) != '\t' ||
((curwp->w_doto) % tabwidth) == (tabwidth - 1)
&& ( lgetc( curwp->w_dotp, curwp->w_doto) != '\t'
|| (curwp->w_doto % tabwidth) == (tabwidth - 1)
))
ldelchar( 1, FALSE) ;
@ -420,15 +416,12 @@ static int lowrite( int c) {
int lover( char *ostr) {
int status = TRUE ;
if (ostr != NULL) {
if( ostr != NULL) {
char tmpc ;
while( (tmpc = *ostr++)) {
status =
(tmpc == '\n' ? lnewline() : lowrite(tmpc));
/* Insertion error? */
if( status != TRUE) {
status = (tmpc == '\n' ? lnewline() : lowrite( tmpc)) ;
if( status != TRUE) { /* Insertion error? */
mloutstr( "%Out of memory while overwriting") ;
return status ;
}
@ -446,17 +439,13 @@ int lover( char *ostr) {
* update of dot and mark is a bit easier then in the above case, because the
* split forces more updating.
*/
int lnewline(void)
{
int lnewline( void) {
char *cp1;
char *cp2;
struct line *lp1;
struct line *lp2;
line_p lp1, lp2 ;
int doto;
struct window *wp;
// if (curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly(); /* we are in read only mode */
assert( !(curbp->b_mode & MDVIEW)) ;
#if SCROLLCODE
@ -466,8 +455,10 @@ int lnewline(void)
#endif
lp1 = curwp->w_dotp; /* Get the address and */
doto = curwp->w_doto; /* offset of "." */
if ((lp2 = lalloc(doto)) == NULL) /* New first half line */
return FALSE;
lp2 = lalloc( doto) ; /* New first half line */
if( lp2 == NULL)
return FALSE ;
cp1 = &lp1->l_text[0]; /* Shuffle text around */
cp2 = &lp2->l_text[0];
while (cp1 != &lp1->l_text[doto])
@ -519,12 +510,14 @@ int lgetchar( unicode_t *c) {
*/
boolean ldelchar( long n, boolean kflag) {
/* testing for read only mode is done by ldelete() */
while (n-- > 0) {
while( n-- > 0) {
unicode_t c;
if (!ldelete(lgetchar(&c), kflag))
return FALSE;
if( !ldelete( lgetchar( &c), kflag))
return FALSE ;
}
return TRUE;
return TRUE ;
}
/*
@ -539,13 +532,11 @@ boolean ldelchar( long n, boolean kflag) {
boolean ldelete( long n, boolean kflag) {
char *cp1;
char *cp2;
struct line *dotp;
line_p dotp;
int doto;
int chunk;
struct window *wp;
// if (curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly(); /* we are in read only mode */
assert( !(curbp->b_mode & MDVIEW)) ;
while( n > 0) {
@ -641,20 +632,14 @@ char *getctext( void) {
* about in memory. Return FALSE on error and TRUE if all looks ok. Called by
* "ldelete" only.
*/
static int ldelnewline(void)
{
static int ldelnewline( void) {
char *cp1;
char *cp2;
struct line *lp1;
struct line *lp2;
struct line *lp3;
line_p lp1, lp2, lp3 ;
struct window *wp;
assert( (curbp->b_mode & MDVIEW) == 0) ;
#if 0
if (curbp->b_mode & MDVIEW) /* don't allow this command if */
return rdonly(); /* we are in read only mode */
#endif
lp1 = curwp->w_dotp;
lp2 = lp1->l_fp;
if (lp2 == curbp->b_linep) { /* At the buffer end. */
@ -687,8 +672,11 @@ static int ldelnewline(void)
free((char *) lp2);
return TRUE;
}
if ((lp3 = lalloc(lp1->l_used + lp2->l_used)) == NULL)
return FALSE;
lp3 = lalloc( lp1->l_used + lp2->l_used) ;
if( lp3 == NULL)
return FALSE ;
cp1 = &lp1->l_text[0];
cp2 = &lp3->l_text[0];
while (cp1 != &lp1->l_text[lp1->l_used])
@ -730,7 +718,7 @@ static int ldelnewline(void)
*/
void kdelete(void)
{
struct kill *kp; /* ptr to scan kill buffer chunk list */
kill_p kp; /* ptr to scan kill buffer chunk list */
if (kbufh != NULL) {
@ -759,30 +747,30 @@ void kdelete(void)
*
* int c; character to insert in the kill buffer
*/
int kinsert(int c)
{
struct kill *nchunk; /* ptr to newly malloced chunk */
int kinsert( int c) {
/* check to see if we need a new chunk */
if (kused >= KBLOCK) {
if ((nchunk = (struct kill *)malloc(sizeof(struct kill))) == NULL)
return FALSE;
if( kused >= KBLOCK) {
kill_p nchunk = malloc( sizeof *nchunk) ;
if( nchunk == NULL)
return FALSE ;
if( kbufh == NULL) { /* set head ptr if first time */
kbufh = nchunk;
kbufh = nchunk ;
klen = 0 ;
}
if (kbufp != NULL) /* point the current to this new one */
kbufp->d_next = nchunk;
kbufp = nchunk;
kbufp->d_next = NULL;
kused = 0;
if( kbufp != NULL) /* point the current to this new one */
kbufp->d_next = nchunk ;
kbufp = nchunk ;
kbufp->d_next = NULL ;
kused = 0 ;
}
/* and now insert the character */
kbufp->d_chunk[kused++] = c;
kbufp->d_chunk[ kused++] = c ;
klen += 1 ;
return TRUE;
return TRUE ;
}
/*
@ -790,15 +778,12 @@ int kinsert(int c)
* is done by the standard insert routines. All you do is run the loop, and
* check for errors. Bound to "C-Y".
*/
int yank(int f, int n)
{
BINDABLE( yank) {
int c;
int i;
char *sp; /* pointer into string to insert */
struct kill *kp; /* pointer into kill buffer */
kill_p kp; /* pointer into kill buffer */
// if (curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly(); /* we are in read only mode */
assert( !(curbp->b_mode & MDVIEW)) ;
if (n < 0)
@ -839,3 +824,5 @@ boolean rdonly( void) {
mloutfmt( "%B(Key illegal in VIEW mode)") ;
return FALSE ;
}
/* end of line.c */

18
line.h
View File

@ -1,7 +1,9 @@
#ifndef LINE_H_
#define LINE_H_
/* line.h -- line centric interface */
#include "retcode.h"
#ifndef _LINE_H_
#define _LINE_H_
#include "names.h"
#include "utf8.h"
/*
@ -34,8 +36,8 @@ char *getkill( void) ;
/* Bindable functions */
boolean backchar( int f, int n) ;
boolean forwchar( int f, int n) ;
int insspace( int f, int n) ;
int yank( int f, int n) ;
BINDABLE( insspace) ;
BINDABLE( yank) ;
void lfree( line_p lp) ;
void lchange( int flag) ;
@ -46,7 +48,7 @@ int lover( char *ostr) ;
int lnewline( void) ;
boolean ldelete( long n, boolean kflag) ;
boolean ldelchar( long n, boolean kflag) ;
int lgetchar( unicode_t *) ;
int lgetchar( unicode_t *cref) ;
char *getctext( void) ;
void kdelete( void) ;
int kinsert( int c) ;
@ -54,4 +56,6 @@ line_p lalloc( int minsize) ; /* Allocate a line of at least minsize chars. */
boolean rdonly( void) ; /* Read Only error message */
#endif /* LINE_H_ */
#endif /* _LINE_H_ */
/* end of line.h */

16
names.c
View File

@ -54,9 +54,7 @@ const name_bind names[] = {
{" clear-and-redraw", redraw, CTRL | 'L'} ,
{" clear-message-line", clrmes, 0} ,
{" copy-region", copyregion, META | 'W'} ,
#if WORDPRO
{" count-words", wordcount, META | CTRL | 'C'} ,
#endif
{" ctlx-prefix", cex, CTRL | 'X'} ,
{"!delete-blank-lines", deblank, CTLX | CTRL | 'O'} ,
{" delete-buffer", killbuffer, CTLX | 'K'} ,
@ -70,15 +68,11 @@ const name_bind names[] = {
{" delete-window", delwind, CTLX | '0'} ,
{" describe-bindings", desbind, 0} ,
{" describe-key", deskey, CTLX | '?'} ,
#if AEDIT
{"!detab-line", detab, CTLX | CTRL | 'D'} , /* X^A */
#endif
{" end-macro", ctlxrp, CTLX | ')'} ,
{" end-of-file", (fnp_t) gotoeob, META | '>'} ,
{" end-of-line", (fnp_t) gotoeol, CTRL | 'E'} ,
#if AEDIT
{"!entab-line", entab, CTLX | CTRL | 'E'} ,
#endif
{" exchange-point-and-mark", (fnp_t) swapmark, CTLX | CTRL | 'X'} ,
{" execute-buffer", execbuf, 0} ,
{" execute-command-line", execcmd, 0} ,
@ -130,9 +124,7 @@ const name_bind names[] = {
#endif
{" execute-program", execprg, CTLX | '$'} ,
{" exit-emacs", quit, CTLX | CTRL | 'C'} ,
#if WORDPRO
{"!fill-paragraph", fillpara, META | 'Q'} ,
#endif
{"!filter-buffer", filter_buffer, CTLX | '#'} ,
{" find-file", filefind, CTLX | CTRL | 'F'} ,
{" forward-character", (fnp_t) forwchar, CTRL | 'F'} ,
@ -152,12 +144,10 @@ const name_bind names[] = {
{"!insert-file", insfile, CTLX | CTRL | 'I'} ,
{"!insert-space", insspace, CTRL | 'C'} ,
{"!insert-string", istring, 0} ,
#if WORDPRO
#if PKCODE
{"!justify-paragraph", justpara, META | 'J'} ,
#endif
{"!kill-paragraph", killpara, META | CTRL | 'W'} ,
#endif
{"!kill-region", killregion, CTRL | 'W'} ,
{"!kill-to-end-of-line", killtext, CTRL | 'K'} ,
{" list-buffers", listbuffers, CTLX | CTRL | 'B'} ,
@ -170,9 +160,7 @@ const name_bind names[] = {
{" next-buffer", nextbuffer, CTLX | 'X'} ,
{" next-line", (fnp_t) forwline, CTRL | 'N'} ,
{" next-page", (fnp_t) forwpage, CTRL | 'V'} ,
#if WORDPRO
{" next-paragraph", gotoeop, META | 'N'} ,
#endif
{" next-window", nextwind, CTLX | 'O'} ,
{" next-word", forwword, META | 'F'} ,
{" nop", nullproc, SPEC | META | 'C'}, /* hook */
@ -181,9 +169,7 @@ const name_bind names[] = {
{" pipe-command", pipecmd, CTLX | '@'} ,
{" previous-line", (fnp_t) backline, CTRL | 'P'} ,
{" previous-page", (fnp_t) backpage, CTRL | 'Z'} , /* MV */
#if WORDPRO
{" previous-paragraph", gotobop, META | 'P'} ,
#endif
{" previous-window", prevwind, CTLX | 'P'} ,
{" previous-word", backword, META | 'B'} ,
{"!query-replace-string", qreplace, META | CTRL | 'R'} ,
@ -221,9 +207,7 @@ const name_bind names[] = {
{" suspend-emacs", bktoshell, CTLX | 'D'} , /* BSD MS */
#endif
{"!transpose-characters", (fnp_t) twiddle, CTRL | 'T'} ,
#if AEDIT
{"!trim-line", trim, CTLX | CTRL | 'T'} ,
#endif
{" unbind-key", unbindkey, META | CTRL | 'K'} ,
{" universal-argument", unarg, CTRL | 'U'} ,
{" unmark-buffer", unmark, META | '~'} ,

258
random.c
View File

@ -51,26 +51,22 @@ int lastflag ; /* Flags, last command */
static int adjustmode( int kind, int global) ;
static int cinsert( void) ;
/*
* Set fill column to n.
/* Set fill column to n. Bound to C-X F set-fill-column.
*/
int setfillcol(int f, int n)
{
fillcol = n;
mlwrite("(Fill column is %d)", n);
return TRUE;
BINDABLE( setfillcol) {
fillcol = n ;
mlwrite( "(Fill column is %d)", n) ;
return TRUE ;
}
/*
* Display the current position of the cursor, in origin 1 X-Y coordinates,
* the character that is under the cursor (in hex), and the fraction of the
* text that is before the cursor. The displayed column is not the current
* column, but the column that would be used on an infinite width display.
* Normally this is bound to "C-X =".
/* Display the current position of the cursor, in origin 1 X-Y coordinates,
the character that is under the cursor (in hex), and the fraction of the
text that is before the cursor. The displayed column is not the current
column, but the column that would be used on an infinite width display.
Normally this is bound to C-X = buffer-position.
*/
int showcpos(int f, int n)
{
struct line *lp; /* current line */
BINDABLE( showcpos) {
line_p lp ; /* current line */
long numchars; /* # of chars in file */
int numlines; /* # of lines in file */
long predchars; /* # chars preceding point */
@ -128,7 +124,7 @@ int showcpos(int f, int n)
int getcline(void)
{ /* get the current line number */
struct line *lp; /* current line */
line_p lp ; /* current line */
int numlines; /* # of lines before point */
/* starting at the beginning of the buffer */
@ -154,7 +150,7 @@ int getcline(void)
int getccol(int bflg)
{
int i, col;
struct line *dlp = curwp->w_dotp;
line_p dlp = curwp->w_dotp ;
int byte_offset = curwp->w_doto;
int len = llength(dlp);
@ -224,14 +220,11 @@ boolean setccol( int pos) {
*/
boolean twiddle( int f, int n) {
unicode_t c ;
int len ;
boolean eof_f = FALSE ;
// if( curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly() ; /* we are in read only mode */
assert( !(curbp->b_mode & MDVIEW)) ;
len = llength( curwp->w_dotp) ;
int len = llength( curwp->w_dotp) ;
if( len < 2 || curwp->w_doto == 0) /* at least 2 chars & not bol */
return FALSE ;
@ -255,44 +248,36 @@ boolean twiddle( int f, int n) {
return TRUE ;
}
/*
* Quote the next character, and insert it into the buffer. All the characters
* are taken literally, with the exception of the newline, which always has
* its line splitting meaning. The character is always read, even if it is
* inserted 0 times, for regularity. Bound to "C-Q"
/* Quote the next character, and insert it into the buffer. All the
characters are taken literally, with the exception of the newline, which
always has its line splitting meaning. The character is always read,
even if it is inserted 0 times, for regularity. Bound to C-Q
quote-character.
*/
int quote(int f, int n)
{
// int c;
//
// if (curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly(); /* we are in read only mode */
BINDABLE( quote) {
int ret ;
assert( !(curbp->b_mode & MDVIEW)) ;
int c = tgetc();
if (n < 0)
return FALSE;
if (n == 0)
return TRUE;
if (c == '\n') {
int s ;
int c = ectoc( get1key()) ;
if( n < 0)
ret = FALSE ;
else if( n == 0)
ret = TRUE ;
else if( c == '\n')
do
ret = lnewline() ;
while( ret == TRUE && --n) ;
else
ret = linsert( n, c) ;
do {
s = lnewline();
} while (s == TRUE && --n);
return s;
}
return linsert(n, c);
return ret ;
}
/*
* Set tab size if given non-default argument (n <> 1). Otherwise, insert a
* tab into file. If given argument, n, of zero, change to true tabs.
* If n > 1, simulate tab stop every n-characters using spaces. This has to be
* done in this slightly funny way because the tab (in ASCII) has been turned
* into "C-I" (in 10 bit code) already. Bound to "C-I".
/* Insert tab/blank/space up to nth next tabulation according to hard/soft
tab current state and tab width. Bound to C-I handle-tab.
*/
int insert_tab( int f, int n) {
BINDABLE( insert_tab) {
int status ;
if( n < 0)
@ -309,27 +294,20 @@ int insert_tab( int f, int n) {
return status ;
}
#if AEDIT
/*
* change tabs to spaces
*
* int f, n; default flag and numeric repeat count
*/
int detab(int f, int n)
{
int inc; /* increment to next line [sgn(n)] */
// if (curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly(); /* we are in read only mode */
BINDABLE( detab) {
assert( !(curbp->b_mode & MDVIEW)) ;
if (f == FALSE)
n = 1;
if( f == FALSE)
n = 1 ;
/* loop thru detabbing n lines */
inc = ((n > 0) ? 1 : -1);
while (n) {
int inc = (n > 0) ? 1 : -1 ; /* increment to next line [sgn(n)] */
for( ; n ; n -= inc) {
curwp->w_doto = 0; /* start at the beginning */
/* detab the entire current line */
@ -349,9 +327,8 @@ int detab(int f, int n)
/* advance/or back to the next line */
if( forwline( TRUE, inc) == FALSE)
break ;
n -= inc;
}
curwp->w_doto = 0; /* to the begining of the line */
thisflag &= ~CFCPCN; /* flag that this resets the goal column */
lchange(WFEDIT); /* yes, we have made at least an edit */
@ -359,27 +336,21 @@ int detab(int f, int n)
}
/*
* change spaces to tabs where posible
* change spaces to tabs where possible
*
* int f, n; default flag and numeric repeat count
*/
int entab(int f, int n)
{
BINDABLE( entab) {
#define nextab(a) (a + tabwidth - a % tabwidth)
int inc; /* increment to next line [sgn(n)] */
// if (curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly(); /* we are in read only mode */
assert( !(curbp->b_mode & MDVIEW)) ;
if (f == FALSE)
n = 1;
if( f == FALSE)
n = 1 ;
/* loop thru entabbing n lines */
inc = ((n > 0) ? 1 : -1);
while (n) {
int inc = (n > 0) ? 1 : -1 ; /* increment to next line [sgn(n)] */
for( ; n ; n -= inc) {
int fspace ; /* pointer to first space if in a run */
int ccol ; /* current cursor column */
@ -426,9 +397,8 @@ int entab(int f, int n)
/* advance/or back to the next line */
if( forwline( TRUE, inc) == FALSE)
break ;
n -= inc;
}
curwp->w_doto = 0; /* to the begining of the line */
thisflag &= ~CFCPCN; /* flag that this resets the goal column */
lchange(WFEDIT); /* yes, we have made at least an edit */
@ -440,21 +410,15 @@ int entab(int f, int n)
*
* int f, n; default flag and numeric repeat count
*/
int trim(int f, int n)
{
int inc; /* increment to next line [sgn(n)] */
// if (curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly(); /* we are in read only mode */
BINDABLE( trim) {
assert( !(curbp->b_mode & MDVIEW)) ;
if (f == FALSE)
n = 1;
if( f == FALSE)
n = 1 ;
/* loop thru trimming n lines */
inc = ((n > 0) ? 1 : -1);
while (n) {
int inc = (n > 0) ? 1 : -1 ; /* increment to next line [sgn(n)] */
for( ; n ; n -= inc) {
line_p lp ; /* current line pointer */
int offset ; /* original line offset position */
int length ; /* current length */
@ -468,60 +432,46 @@ int trim(int f, int n)
if( c != ' ' && c != '\t')
break ;
}
lp->l_used = length;
/* advance/or back to the next line */
if( forwline( TRUE, inc) == FALSE)
break ;
n -= inc;
}
lchange(WFEDIT);
thisflag &= ~CFCPCN; /* flag that this resets the goal column */
return (n == 0) ? TRUE : FALSE ;
}
#endif
/*
* Open up some blank space. The basic plan is to insert a bunch of newlines,
* and then back up over them. Everything is done by the subcommand
* procerssors. They even handle the looping. Normally this is bound to "C-O".
*/
int openline(int f, int n)
{
int i;
int s;
// if (curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly(); /* we are in read only mode */
BINDABLE( openline) {
assert( !(curbp->b_mode & MDVIEW)) ;
if (n < 0)
return FALSE;
if (n == 0)
return TRUE;
i = n; /* Insert newlines. */
do {
s = lnewline();
} while (s == TRUE && --i);
if (s == TRUE) /* Then back up overtop */
s = backchar(f, n); /* of them all. */
return s;
int ret = (n < 0) ? FALSE : TRUE ;
for( int i = n ; ret == TRUE && i ; i--) /* Insert newlines. */
ret = lnewline() ;
if( ret == TRUE) /* Then back up overtop */
ret = backchar( f, n) ; /* of them all. */
return ret ;
}
/*
* Insert a newline. Bound to "C-M". If we are in CMODE, do automatic
* indentation as specified.
*/
int insert_newline(int f, int n)
{
// if (curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly(); /* we are in read only mode */
BINDABLE( insert_newline) {
assert( !(curbp->b_mode & MDVIEW)) ;
if (n < 0)
return FALSE;
if( n < 0)
return FALSE ;
/* if we are in C mode and this is a default <NL> */
if (n == 1 && (curbp->b_mode & MDCMOD) &&
@ -569,7 +519,7 @@ static int cinsert(void)
nicol = 0 ;
for( i = 0 ; i < tptr ; i += 1) {
int ch ;
ch = cptr[ i] ;
if( ch == ' ')
nicol += 1 ;
@ -610,22 +560,17 @@ static int cinsert(void)
}
/*
* Delete blank lines around dot. What this command does depends if dot is
* sitting on a blank line. If dot is sitting on a blank line, this command
* deletes all the blank lines above and below the current line. If it is
* sitting on a non blank line then it deletes all of the blank lines after
* the line. Normally this command is bound to "C-X C-O". Any argument is
* ignored.
/* Delete blank lines around dot. What this command does depends if dot is
* sitting on a blank line. If dot is sitting on a blank line, this
* command deletes all the blank lines above and below the current line.
* If it is sitting on a non blank line then it deletes all of the blank
* lines after the line. Normally this command is bound to C-X C-O
* delete-blank-lines. Any argument is ignored.
*/
int deblank(int f, int n)
{
struct line *lp1;
struct line *lp2;
long nld;
BINDABLE( deblank) {
line_p lp1, lp2 ;
long nld ;
// if (curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly(); /* we are in read only mode */
assert( !(curbp->b_mode & MDVIEW)) ;
lp1 = curwp->w_dotp;
@ -642,28 +587,24 @@ int deblank(int f, int n)
return ldelete(nld, FALSE);
}
/*
* Insert a newline, then enough tabs and spaces to duplicate the indentation
* of the previous line. Assumes tabs are every tabwidth characters.
* Figure out the indentation of the current line. Insert a newline by calling
* the standard routine. Insert the indentation by inserting the right number
* of tabs and spaces. Return TRUE if all ok. Return FALSE if one of the
* subcomands failed. Normally bound to "C-J".
/* Insert a newline, then enough tabs and spaces to duplicate the
* indentation of the previous line. Assumes tabs are every tabwidth
* characters. Figure out the indentation of the current line. Insert a
* newline by calling the standard routine. Insert the indentation by
* inserting the right number of tabs and spaces. Return TRUE if all ok.
* Return FALSE if one of the subcomands failed. Normally bound to C-J
* newline-and-indent.
*/
int indent( int f, int n) {
int nicol ;
BINDABLE( indent) {
int i ;
// if( curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly() ; /* we are in read only mode */
assert( !(curbp->b_mode & MDVIEW)) ;
if( n < 0)
return FALSE ;
/* number of columns to indent */
nicol = 0 ;
int nicol = 0 ;
for( i = 0 ; i < llength( curwp->w_dotp) ; i += 1) {
int c ;
@ -693,10 +634,7 @@ int indent( int f, int n) {
* If any argument is present, it kills rather than deletes, to prevent loss
* of text if typed with a big argument. Normally bound to "C-D".
*/
int forwdel( int f, int n) {
// if( curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly() ; /* we are in read only mode */
BINDABLE( forwdel) {
assert( !(curbp->b_mode & MDVIEW)) ;
if( n == 0)
@ -719,10 +657,7 @@ int forwdel( int f, int n) {
* forward, this actually does a kill if presented with an argument. Bound to
* both "RUBOUT" and "C-H".
*/
int backdel( int f, int n) {
// if( curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly() ; /* we are in read only mode */
BINDABLE( backdel) {
assert( !(curbp->b_mode & MDVIEW)) ;
if( n == 0)
@ -747,13 +682,10 @@ int backdel( int f, int n) {
* number of newlines. If called with a negative argument it kills backwards
* that number of newlines. Normally bound to "C-K".
*/
int killtext(int f, int n)
{
struct line *nextp;
BINDABLE( killtext) {
line_p nextp ;
long chunk;
// if (curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly(); /* we are in read only mode */
assert( !(curbp->b_mode & MDVIEW)) ;
if ((lastflag & CFKILL) == 0) /* Clear kill buffer if */
@ -953,7 +885,7 @@ static int iovstring( int f, int n, const char *prompt, int (*fun)( char *)) {
*
* int f, n; ignored arguments
*/
int istring( int f, int n) {
BINDABLE( istring) {
return iovstring( f, n, "insert-string<META>: ", linstr) ;
}
@ -963,7 +895,7 @@ int istring( int f, int n) {
*
* int f, n; ignored arguments
*/
int ovstring( int f, int n) {
BINDABLE( ovstring) {
return iovstring( f, n, "overwrite-string<META>: ", lover) ;
}

67
random.h
View File

@ -1,49 +1,48 @@
/* random.h -- various commands */
#ifndef _RANDOM_H_
#define _RANDOM_H_
#include "names.h"
#include "retcode.h"
/* Command flags */
#define CFCPCN 0x0001 /* Flag that last command was C-P, C-N */
#define CFKILL 0x0002 /* Flag that last command was a kill */
extern int thisflag ; /* Flags, this command */
extern int lastflag ; /* Flags, last command */
#define AEDIT 1
extern int fillcol ; /* Fill column */
extern int fillcol ; /* Fill column */
extern boolean hardtab ; /* Use hard tab instead of soft tab */
/* Uninitialized global external declarations. */
#define CFCPCN 0x0001 /* Last command was C-P, C-N */
#define CFKILL 0x0002 /* Last command was a kill */
extern int thisflag ; /* Flags, this command */
extern int lastflag ; /* Flags, last command */
int setfillcol( int f, int n) ;
int showcpos( int f, int n) ;
int getcline( void) ;
int getccol( int bflg) ;
boolean setccol( int pos) ;
/* Bindable functions */
BINDABLE( setfillcol) ;
BINDABLE( showcpos) ;
boolean twiddle( int f, int n) ;
int quote( int f, int n) ;
int insert_tab( int f, int n) ;
#if AEDIT
int detab( int f, int n) ;
int entab( int f, int n) ;
int trim( int f, int n) ;
#endif
int openline( int f, int n) ;
int insert_newline( int f, int n) ;
int deblank( int f, int n) ;
int indent( int f, int n) ;
int forwdel( int f, int n) ;
int backdel( int f, int n) ;
int killtext( int f, int n) ;
int setemode( int f, int n) ;
int delmode( int f, int n) ;
int setgmode( int f, int n) ;
int delgmode( int f, int n) ;
int istring( int f, int n) ;
int ovstring( int f, int n) ;
BINDABLE( quote) ;
BINDABLE( insert_tab) ;
BINDABLE( detab) ;
BINDABLE( entab) ;
BINDABLE( trim) ;
BINDABLE( openline) ;
BINDABLE( insert_newline) ;
BINDABLE( deblank) ;
BINDABLE( indent) ;
BINDABLE( forwdel) ;
BINDABLE( backdel) ;
BINDABLE( killtext) ;
BINDABLE( setemode) ;
BINDABLE( delmode) ;
BINDABLE( setgmode) ;
BINDABLE( delgmode) ;
BINDABLE( istring) ;
BINDABLE( ovstring) ;
#endif
/* end of random.h */

97
region.c
View File

@ -20,19 +20,14 @@
#include "random.h"
#include "window.h"
/*
* Kill the region. Ask "getregion"
* to figure out the bounds of the region.
* Move "." to the start, and kill the characters.
* Bound to "C-W".
/* Kill the region. Ask "getregion" to figure out the bounds of the
* region. Move "." to the start, and kill the characters. Bound to
* "C-W".
*/
int killregion(int f, int n)
{
BINDABLE( killregion) {
int s;
struct region region;
region_t region;
// if (curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly(); /* we are in read only mode */
assert( !(curbp->b_mode & MDVIEW)) ;
if ((s = getregion(&region)) != TRUE)
@ -45,18 +40,15 @@ int killregion(int f, int n)
return ldelete(region.r_size, TRUE);
}
/*
* Copy all of the characters in the
* region to the kill buffer. Don't move dot
* at all. This is a bit like a kill region followed
* by a yank. Bound to "M-W".
/* Copy all of the characters in the region to the kill buffer. Don't move
* dot at all. This is a bit like a kill region followed by a yank. Bound
* to "M-W".
*/
int copyregion(int f, int n)
{
struct line *linep;
BINDABLE( copyregion) {
line_p linep;
int loffs;
int s;
struct region region;
region_t region;
if ((s = getregion(&region)) != TRUE)
return s;
@ -81,24 +73,18 @@ int copyregion(int f, int n)
return TRUE;
}
/*
* Lower case region. Zap all of the upper
* case characters in the region to lower case. Use
* the region code to set the limits. Scan the buffer,
* doing the changes. Call "lchange" to ensure that
* redisplay is done in all buffers. Bound to
* "C-X C-L".
/* Lower case region. Zap all of the upper case characters in the region
* to lower case. Use the region code to set the limits. Scan the buffer,
* doing the changes. Call "lchange" to ensure that redisplay is done in
* all buffers. Bound to "C-X C-L".
*/
int lowerregion(int f, int n)
{
struct line *linep;
BINDABLE( lowerregion) {
line_p linep;
int loffs;
int c;
int s;
struct region region;
region_t region;
// if (curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly(); /* we are in read only mode */
assert( !(curbp->b_mode & MDVIEW)) ;
if ((s = getregion(&region)) != TRUE)
@ -120,24 +106,18 @@ int lowerregion(int f, int n)
return TRUE;
}
/*
* Upper case region. Zap all of the lower
* case characters in the region to upper case. Use
* the region code to set the limits. Scan the buffer,
* doing the changes. Call "lchange" to ensure that
* redisplay is done in all buffers. Bound to
* "C-X C-L".
/* Upper case region. Zap all of the lower case characters in the region
* to upper case. Use the region code to set the limits. Scan the buffer,
* doing the changes. Call "lchange" to ensure that redisplay is done in
* all buffers. Bound to "C-X C-L".
*/
int upperregion(int f, int n)
{
struct line *linep;
BINDABLE( upperregion) {
line_p linep;
int loffs;
int c;
int s;
struct region region;
region_t region;
// if (curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly(); /* we are in read only mode */
assert( !(curbp->b_mode & MDVIEW)) ;
if ((s = getregion(&region)) != TRUE)
@ -159,23 +139,16 @@ int upperregion(int f, int n)
return TRUE;
}
/*
* This routine figures out the
* bounds of the region in the current window, and
* fills in the fields of the "struct region" structure pointed
* to by "rp". Because the dot and mark are usually very
* close together, we scan outward from dot looking for
* mark. This should save time. Return a standard code.
* Callers of this routine should be prepared to get
* an "ABORT" status; we might make this have the
* conform thing later.
/* This routine figures out the bounds of the region in the current window,
* and fills in the fields of the "region_t" structure pointed to by "rp".
* Because the dot and mark are usually very close together, we scan
* outward from dot looking for mark. This should save time. Return a
* standard code. Callers of this routine should be prepared to get an
* "ABORT" status; we might make this have the conform thing later.
*/
int getregion(struct region *rp)
{
struct line *flp;
struct line *blp;
long fsize;
long bsize;
int getregion( region_p rp) {
line_p flp, blp ;
long fsize, bsize ;
if (curwp->w_markp == NULL) {
mloutstr( "No mark set in this window") ;
@ -223,3 +196,5 @@ int getregion(struct region *rp)
mloutstr( "Bug: lost mark") ;
return FALSE;
}
/* end of region.c */

27
region.h
View File

@ -1,3 +1,4 @@
/* region.h -- a region starts at the mark and end at the dot */
#ifndef _REGION_H_
#define _REGION_H_
@ -7,16 +8,22 @@
* The starting position of a region, and the size of the region in
* characters, is kept in a region structure. Used by the region commands.
*/
struct region {
struct line *r_linep; /* Origin struct line address. */
int r_offset; /* Origin struct line offset. */
long r_size; /* Length in characters. */
};
typedef struct {
line_p r_linep ; /* Origin struct line address. */
int r_offset ; /* Origin struct line offset. */
long r_size ; /* Length in characters. */
} region_t ;
int killregion( int f, int n) ;
int copyregion( int f, int n) ;
int lowerregion( int f, int n) ;
int upperregion( int f, int n) ;
int getregion( struct region *rp) ;
typedef region_t *region_p ;
/* Bindable functions */
BINDABLE( killregion) ;
BINDABLE( copyregion) ;
BINDABLE( lowerregion) ;
BINDABLE( upperregion) ;
int getregion( region_p rp) ;
#endif
/* end of region.h */

70
search.c
View File

@ -87,7 +87,7 @@
unsigned int matchlen = 0 ;
static unsigned int mlenold = 0 ;
char *patmatch = NULL ;
static struct line *matchline = NULL;
static line_p matchline = NULL;
static int matchoff = 0;
spat_t pat ; /* Search pattern */
@ -165,10 +165,10 @@ static struct magic_replacement rmcpat[NPAT]; /* The replacement magic array. */
static int mcscanner( struct magic *mcpatrn, int direct, int beg_or_end) ;
#endif
static int amatch(struct magic *mcptr, int direct, struct line **pcwline, int *pcwoff);
static int amatch(struct magic *mcptr, int direct, line_p *pcwline, int *pcwoff);
static int readpattern(char *prompt, char *apat, int srch);
static int replaces(int kind, int f, int n);
static int nextch(struct line **pcurline, int *pcuroff, int dir);
static int nextch( line_p *pcurline, int *pcuroff, int dir);
static int mcstr(void);
static int rmcstr(void);
static int mceq(int bc, struct magic *mt);
@ -390,7 +390,7 @@ int backhunt(int f, int n)
*/
static int mcscanner(struct magic *mcpatrn, int direct, int beg_or_end)
{
struct line *curline; /* current line during scan */
line_p curline; /* current line during scan */
int curoff; /* position within current line */
/* If we are going in reverse, then the 'end' is actually
@ -413,7 +413,7 @@ static int mcscanner(struct magic *mcpatrn, int direct, int beg_or_end)
/* Scan each character until we hit the head link record.
*/
while (!boundry(curline, curoff, direct)) {
while (!boundary(curline, curoff, direct)) {
/* Save the current position in case we need to
* restore it on a match, and initialize matchlen to
* zero in case we are doing a search for replacement.
@ -454,13 +454,13 @@ static int mcscanner(struct magic *mcpatrn, int direct, int beg_or_end)
*
* struct magic *mcptr; string to scan for
* int direct; which way to go.
* struct line **pcwline; current line during scan
* line_p *pcwline; current line during scan
* int *pcwoff; position within current line
*/
static int amatch(struct magic *mcptr, int direct, struct line **pcwline, int *pcwoff)
static int amatch(struct magic *mcptr, int direct, line_p *pcwline, int *pcwoff)
{
int c; /* character at current position */
struct line *curline; /* current line during scan */
line_p curline; /* current line during scan */
int curoff; /* position within current line */
int nchars;
@ -600,9 +600,9 @@ int scanner(const char *patrn, int direct, int beg_or_end)
{
int c; /* character at current position */
const char *patptr; /* pointer into pattern */
struct line *curline; /* current line during scan */
line_p curline; /* current line during scan */
int curoff; /* position within current line */
struct line *scanline; /* current line during scanning */
line_p scanline; /* current line during scanning */
int scanoff; /* position in scanned line */
/* If we are going in reverse, then the 'end' is actually
@ -617,7 +617,7 @@ int scanner(const char *patrn, int direct, int beg_or_end)
/* Scan each character until we hit the head link record.
*/
while (!boundry(curline, curoff, direct)) {
while (!boundary(curline, curoff, direct)) {
/* Save the current position in case we match
* the search string at this point.
*/
@ -749,7 +749,7 @@ static int readpattern(char *prompt, char *apat, int srch)
void savematch(void)
{
char *ptr; /* pointer to last match string */
struct line *curline; /* line of last match */
line_p curline; /* line of last match */
int curoff; /* offset " " */
/* Free any existing match string, then
@ -828,17 +828,15 @@ static int replaces(int kind, int f, int n)
int nlrepl; /* was a replace done on the last line? */
char c; /* input char for query */
spat_t tpat ; /* temporary to hold search pattern */
struct line *origline; /* original "." position */
line_p origline; /* original "." position */
int origoff; /* and offset (for . query option) */
struct line *lastline; /* position of last replace and */
line_p lastline; /* position of last replace and */
int lastoff; /* offset (for 'u' query option) */
///* rfi */
lastline = NULL ;
lastoff = 0 ;
// if (curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly(); /* we are in read only mode */
assert( !(curbp->b_mode & MDVIEW)) ;
/* Check for negative repetitions.
@ -1116,25 +1114,23 @@ int expandp(char *srcstr, char *deststr, int maxlength)
return TRUE;
}
/*
* boundry -- Return information depending on whether we may search no
* further. Beginning of file and end of file are the obvious
* cases, but we may want to add further optional boundry restrictions
* in future, a' la VMS EDT. At the moment, just return TRUE or
* FALSE depending on if a boundry is hit (ouch).
*/
int boundry(struct line *curline, int curoff, int dir)
{
int border;
if (dir == FORWARD) {
border = (curoff == llength(curline)) &&
(lforw(curline) == curbp->b_linep);
} else {
border = (curoff == 0) &&
(lback(curline) == curbp->b_linep);
}
return border;
/* boundary -- Returns information depending on whether we may search no
further. Beginning of file and end of file are the obvious cases, but
we may want to add further optional boundary restrictions in future, a'
la VMS EDT. At the moment, just return TRUE or FALSE depending on if a
boundary is hit (ouch).
*/
int boundary( line_p curline, int curoff, int dir) {
int border ;
if( dir == FORWARD)
border = (curoff == llength( curline)) &&
(lforw( curline) == curbp->b_linep) ;
else
border = (curoff == 0) && (lback( curline) == curbp->b_linep) ;
return border ;
}
/*
@ -1145,9 +1141,9 @@ int boundry(struct line *curline, int curoff, int dir)
* the current character and move, reverse searches move and
* look at the character.
*/
static int nextch(struct line **pcurline, int *pcuroff, int dir)
static int nextch( line_p *pcurline, int *pcuroff, int dir)
{
struct line *curline;
line_p curline;
int curoff;
int c;
@ -1606,3 +1602,5 @@ static void setbit(int bc, char *cclmap)
*(cclmap + (bc >> 3)) |= BIT(bc & 7);
}
#endif
/* end of search.c */

20
search.h
View File

@ -1,3 +1,5 @@
/* search.h -- */
#ifndef _SEARCH_H_
#define _SEARCH_H_
@ -26,18 +28,20 @@ extern spat_t rpat ; /* replacement pattern */
int scanner( const char *patrn, int direct, int beg_or_end) ;
int forwsearch( int f, int n) ;
int forwhunt( int f, int n) ;
int backsearch( int f, int n) ;
int backhunt( int f, int n) ;
/* Bindable functions */
BINDABLE( forwsearch) ;
BINDABLE( forwhunt) ;
BINDABLE( backsearch) ;
BINDABLE( backhunt) ;
BINDABLE( sreplace) ;
BINDABLE( qreplace) ;
int eq( unsigned char bc, unsigned char pc) ;
void savematch( void) ;
void rvstrcpy( char *rvstr, char *str) ;
int sreplace( int f, int n) ;
int qreplace( int f, int n) ;
int delins( int dlength, char *instr, int use_meta) ;
int expandp( char *srcstr, char *deststr, int maxlength) ;
int boundry( struct line *curline, int curoff, int dir) ;
int boundary( line_p curline, int curoff, int dir) ;
void setprompt( char *tpat, unsigned tpat_size, char *prompt, char *apat) ;
@ -47,3 +51,5 @@ void rmcclear( void) ;
#endif
#endif
/* end of search.h */

6
spawn.c
View File

@ -183,7 +183,7 @@ int execprg( int f, int n) {
int pipecmd( int f, int n) {
int s ; /* return status from CLI */
struct window *wp ; /* pointer to new window */
struct buffer *bp ; /* pointer to buffer to zot */
buffer_p bp ; /* pointer to buffer to zot */
char *mlarg ;
char *line ; /* command line send to shell */
static char bname[] = "command" ;
@ -277,7 +277,7 @@ int pipecmd( int f, int n) {
*/
int filter_buffer( int f, int n) {
int s ; /* return status from CLI */
struct buffer *bp ; /* pointer to buffer to zot */
buffer_p bp ; /* pointer to buffer to zot */
char *mlarg ;
char *line ; /* command line send to shell */
fname_t tmpnam ; /* place to store real file name */
@ -290,8 +290,6 @@ int filter_buffer( int f, int n) {
if( restflag)
return resterr() ;
// if( curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly() ; /* we are in read only mode */
assert( !(curbp->b_mode & MDVIEW)) ;
/* get the filter name and its args */

20
spawn.h
View File

@ -1,7 +1,15 @@
int spawncli( int f, int n) ;
int bktoshell( int f, int n) ;
/* spawn.h -- various operating system access commands */
#include "names.h"
/* Bindable functions */
BINDABLE( spawncli) ;
BINDABLE( bktoshell) ;
BINDABLE( spawn) ;
BINDABLE( execprg) ;
BINDABLE( pipecmd) ;
BINDABLE( filter_buffer) ;
void rtfrmshell( void) ;
int spawn( int f, int n) ;
int execprg( int f, int n) ;
int pipecmd( int f, int n) ;
int filter_buffer( int f, int n) ;
/* end of spawn.h */

32
word.c
View File

@ -11,7 +11,6 @@
*/
#include <assert.h>
#include <stdio.h>
#include <stdlib.h> /* malloc, free */
#include <string.h> /* memcpy */
@ -152,9 +151,6 @@ static boolean uniflip( boolean toupper_f) { /* flip unicode case and forward */
}
static boolean capcapword( int n, boolean first_f, boolean rest_f) {
// if( curbp->b_mode & MDVIEW) /* don't allow this command if */
// return rdonly() ; /* we are in read only mode */
assert( !(curbp->b_mode & MDVIEW)) ;
if( n < 0)
@ -210,14 +206,9 @@ int capword( int f, int n) {
*/
int delfword(int f, int n)
{
struct line *dotp; /* original cursor line */
line_p dotp; /* original cursor line */
int doto; /* and row */
int c; /* temp char */
long size; /* # of chars to delete */
// /* don't allow this command if we are in read only mode */
// if (curbp->b_mode & MDVIEW)
// return rdonly();
assert( !(curbp->b_mode & MDVIEW)) ;
@ -235,7 +226,7 @@ int delfword(int f, int n)
doto = curwp->w_doto;
/* figure out how many characters to give the axe */
size = 0;
long size = 0 ;
/* get us into a word.... */
while (inword() == FALSE) {
@ -301,12 +292,6 @@ int delfword(int f, int n)
*/
int delbword(int f, int n)
{
long size;
// /* don't allow this command if we are in read only mode */
// if (curbp->b_mode & MDVIEW)
// return rdonly();
assert( !(curbp->b_mode & MDVIEW)) ;
/* ignore the command if there is a nonpositive argument */
@ -320,7 +305,8 @@ int delbword(int f, int n)
if (backchar(FALSE, 1) == FALSE)
return FALSE;
size = 0;
long size = 0 ;
while (n--) {
while (inword() == FALSE) {
if (backchar(FALSE, 1) == FALSE)
@ -352,7 +338,6 @@ static int inword( void) {
return isletter( c) || ( c >= '0' && c <= '9') ;
}
#if WORDPRO
static int parafillnjustify( int f, int n, int justify_f) {
unicode_t c; /* current char during scan */
unicode_t *wbuf ; /* buffer for current word */
@ -361,7 +346,7 @@ static int parafillnjustify( int f, int n, int justify_f) {
int clength; /* position on line during fill */
int eopflag; /* Are we at the End-Of-Paragraph? */
int firstflag = TRUE ; /* first word? (needs no space) */
struct line *eopline; /* pointer to line just past EOP */
line_p eopline; /* pointer to line just past EOP */
int dotflag = 0 ; /* was the last char a period? */
int leftmarg = 0 ; /* left marginal */
@ -549,7 +534,7 @@ int killpara(int f, int n)
*/
int wordcount(int f, int n)
{
struct line *lp; /* current line to scan */
line_p lp; /* current line to scan */
int offset; /* current char to scan */
long size; /* size of region left to count */
int ch; /* current character to scan */
@ -560,10 +545,10 @@ int wordcount(int f, int n)
int nlines; /* total number of lines in region */
int avgch; /* average number of chars/word */
int status; /* status return code */
struct region region; /* region to look at */
region_t region ; /* region to look at */
/* make sure we have a region to count */
if ((status = getregion(&region)) != TRUE)
if( (status = getregion( &region)) != TRUE)
return status;
lp = region.r_linep;
offset = region.r_offset;
@ -684,6 +669,5 @@ int gotoeop(int f, int n)
curwp->w_flag |= WFMOVE; /* force screen update */
return TRUE;
}
#endif
/* end of word.c */

36
word.h
View File

@ -1,23 +1,25 @@
/* word.h -- word processing functions */
#ifndef _WORD_H_
#define _WORD_H_
#define WORDPRO 1
#include "names.h"
int wrapword( int f, int n) ;
int backword( int f, int n) ;
int forwword( int f, int n) ;
int upperword( int f, int n) ;
int lowerword( int f, int n) ;
int capword( int f, int n) ;
int delfword( int f, int n) ;
int delbword( int f, int n) ;
#if WORDPRO
int gotobop( int f, int n) ;
int gotoeop( int f, int n) ;
int fillpara( int f, int n) ;
int justpara( int f, int n) ;
int killpara( int f, int n) ;
int wordcount( int f, int n) ;
#endif
/* Bindable functions */
BINDABLE( wrapword) ;
BINDABLE( backword) ;
BINDABLE( forwword) ;
BINDABLE( upperword) ;
BINDABLE( lowerword) ;
BINDABLE( capword) ;
BINDABLE( delfword) ;
BINDABLE( delbword) ;
BINDABLE( gotobop) ;
BINDABLE( gotoeop) ;
BINDABLE( fillpara) ;
BINDABLE( justpara) ;
BINDABLE( killpara) ;
BINDABLE( wordcount) ;
#endif
/* end of word.h */