#include "stdio.h"

#include "stdio.h"
#include "ed.h"
/* ovudfb31.c: (read "up down forward back" for "udfb")
** overlay 31 source code.
** this large overlay is a portmanteau of frequently-used
** commands. One can hardly justify having some of them in
** overlays UNLESS the overlay in question is one which is
** likely to be in memory at all times -- so, this overlay
** includes gobs of the most useful commands.
*/

extern int wstyle; /* Which kind of Word operations? */
extern int currow; /* set by update() */
extern int tabsize; /* if tabs are expanded to spaces. */
extern char *kbufp; /* Kill buffer data */
extern int kused; /* # of bytes used in KB */
extern int ksize; /* # of bytes allocated in KB */

#define TABCASE 40 /* case TABCASE and above are special. */
/* cases < TABCASE are numbered so that we can handle a negative
** parameter with "casenumber ^= 1"
*/

ovmain( x )
#define cmdflag (*(int *)0x102)
#define cmdparm (*(int *)0x104)
{
register LINE * mylp;
register WINDOW * mywp;

#define temp_int (*(int *)0xc0)
#define mydoto (*(int *)0xc2)
#define xbufchar (*(int *)0xc4)
#define limitp (*(LINE **)0xc6)
#define localx (*(int *)0xc8)
#define xinsct (*(int *)0xca)
#define mylen (*(int *)0xcc)
#define Wdoto (*(int *)0xce)
/* the above #defines are temporary variables, in effect:
** the compiler generates much smaller code for specific addresses
** than it does for stack variables.
*/

xinsct = 1;
mywp = curwp;
mylp = mywp->w_dotp;
limitp = curbp->b_linep;
temp_int = mydoto = 0;
mylen = llength( mylp );
Wdoto = mywp->w_doto;

if ( ( localx = x ) < TABCASE )
{ /* most commands here have negative-parameter counterparts. */

if ( cmdparm < 0 )
{ localx ^= 1;
cmdparm = -cmdparm;
}
}

switch ( localx )
{
case 13: /* goto end of line. */
mydoto = mylen;
goto dotpset;
case 12: /* goto start of line. */
if ( cmdflag && ( mydoto = cmdparm -1 ) > mylen )
mydoto = mylen;
goto dotpset;
case 10: /* page forwards */
case 11: /* page back. */
cmdparm *= ( mywp->w_ntrows - 1 );
goto linemotion;
case 1: /* up arrow. */
++cmdparm;
goto linemo2; /* backward goes n+1 lines! */
case 9: /* gotoeob */
if ( cmdparm ) --cmdparm;
case 8: /* gotobob */
mylp = curbp->b_linep;
linemotion:
/* if ( localx & 1 ) */
/* { mylp = lforw( mylp ); */
/* } */
curgoal = curcol = 0;
/* mywp->w_flag |= WFHARD; */
linemo2: /* fall through. */
case 0: /* down arrow */
{ /* up or down */
if ( ! ( lastflag & CFCPCN ))
{ /* Reset goal if last not up/down */
curgoal = curcol;
}
thisflag |= CFCPCN;

if ( localx & 1 ) /* backward */
{ while ( decparm()
&& ( mylp = lback( mylp )) != limitp
);
}
else
{ while ( decparm()
&& ( mylp = lforw( mylp )) != limitp
);
} /* "--n >= 0" for n+1 lines. */

while ( mydoto != llength( mylp ))/* NOT mylen! */
{ if ( ( xbufchar = lgetc( mylp, mydoto ))
== '\t' )
temp_int |= 0x07;
else if ( ! isinsert( xbufchar ))
plustemp();
if ( ++temp_int > curgoal ) break;
++mydoto;
}
dotpmove: wfmove();
dotpset: mywp->w_dotp = mylp;
mywp->w_doto = mydoto;
goto rettrue; /* return ( 1 ); */
} /* end case 0 or 1 */
case 2: /* word forward */
case 4: /* del word forward */
{ /* mylp = curwp->w_dotp; at top (mylp) */
mydoto = Wdoto;
while ( decparm())
{ if ( ! ( wstyle & 2 ) && ! fwx())
{ goto retfalse;
}
while ( inword( ))
{ fc1();
/* assert the above cannot fail. */
plustemp();
}
if ( wstyle & 2 && ! fwx())
{ goto retfalse;
}
}
if ( localx == 2 ) goto rettrue;
mywp->w_dotp = mylp;
mywp->w_doto = mydoto;
goto retldel; /* return ( ldelete( temp_int, 1 )); */
} /* end case 2 or 4 */
case 3: /* word backward */
case 5: /* del word backward */
{
if ( ! bc1( )) goto retfalse; /* TOF */
/* temp_int++; */
while ( decparm())
{
while ( ! inword( ))
{ if ( ! bc1()) goto retfalse;
plustemp();
}
while ( inword( ))
{ if ( ! bc1())
{ /* top of file. */
retfalse: return ( 0 );
}
plustemp();
}
}
/* temp_int--; */
fc1(); /* can't fail. */
if ( localx == 5 )
{ /* delword. */
retldel: cmdflag = 1;
ret2ldel: return ( ldelete( temp_int, cmdflag ));
}
rettrue: return ( 1 );
} /* end case 3 or 5. */
case 6: /* forwdel() */
case 7: /* backdel() */
{
if ( cmdflag )
{ /* Really a kill. */
kdcheck();
}
if ( ( localx & 1 ) && ! backchar( cmdflag, cmdparm ))
goto retfalse;
temp_int = cmdparm;
goto ret2ldel; /*return(ldelete(cmdparm,cmdflag));*/
} /* end cases 6 and 7 */
case TABCASE:
{ /* with no parameter, perform tab function;
** with one, set tabsize.
*/
if ( cmdparm < 0 ) return ( 0 );
if ( cmdparm != 1 )
{ tabsize = cmdparm;
return( 1 );
}
xbufchar = '\t';
if ( tabsize )
{ xinsct = tabsize -
( ( curcol + 1 ) % tabsize );
xbufchar = ' ';
}
return( xlinsc( ));
} /* end case TABCASE */
case TABCASE+1: /* openline() */
case TABCASE+2: /* indent() */
{ /* openline() keeps cursor in same place,
** inserts arg newlines.
** indent() moves forward with its newlines,
** adds whitespace to match the current line.
*/
mylp = lback( mylp );
mydoto = Wdoto;
while ( decparm()) if ( ! lnewline()) goto retfalse;
mylp = lforw( mylp );
/* lnewline() may delete the original
** target of mylp.
*/
if ( localx == ( TABCASE + 1 ))
{ /* openline(), done. */
goto dotpset;
}
while ( ( xbufchar = lgetc( mylp, ++cmdparm )) == ' '
|| xbufchar == '\t' )
{ xlinsc( );
}
if ( xbufchar == '{' )
{ /* C indent */
xbufchar = '\t';
xlinsc();
}
goto rettrue;
} /* end case indent() and openline() */
case TABCASE+7: /* vi-style kill. */
cmdflag = 1;
mywp->w_doto = Wdoto = 0; /* fall through. */
case TABCASE+3: /* kill() */
{ kdcheck();
mydoto = Wdoto;
if ( ! cmdflag )
{ temp_int = mylen - mydoto;
if ( temp_int == 0 ) temp_int = 1;
} else if ( ! cmdparm )
{ temp_int = mydoto;
mywp->w_doto = 0;
} else if ( decparm()) /* "if n > 0" */
{ temp_int = mylen - mydoto + 1;
mylp = lforw( mylp );
while (decparm()) /* while --n */
{ if ( mylp == limitp )
goto retfalse;
temp_int += llength( mylp ) + 1;
mylp = lforw( mylp );
}
} else
{ /* mlwrite("neg kill"); */
ctrlg();
goto retfalse;
}
goto retldel; /*return(ldelete(temp_int,TRUE));*/
} /* end case "kill()" */
case TABCASE+4: /* yank() */
{ if ( ! decparm()) goto retfalse;
do /* make cmdparm copies. */
{ temp_int = 0;
while ( temp_int < kused )
{ if ( ( xbufchar = kbufp[ temp_int ])
== '\n' )
{ lnewline( );
} else
{ if ( ! xlinsc())
goto retfalse;
}
plustemp();
}
} while ( decparm( ));
goto rettrue;
} /* end case yank() */
case TABCASE+5: /* set mark */
{ mlwrite("[Mark]");
markset: mywp->w_markp = mylp;
mywp->w_marko = Wdoto;
goto rettrue;
} /* end case set mark */
case TABCASE+6: /* exchange mark and cursor. */
{ if ( mywp->w_markp == NULL )
{ mlwrite("No mark");
return ( 0 );
}
mywp->w_dotp = mywp->w_markp;
mywp->w_doto = mywp->w_marko;
wfmove();
goto markset;
} /* end case ^X^X */
}
}

fc1() /* saves 10 bytes per call to it. */
{ return( forwchar( 0, 1 ));
}
bc1() /* saves 10 bytes per call to it. */
{ return( backchar( 0, 1 ));
}
fwx() /* loop used twice in forwword. */
{ while ( ! inword( ))
{ if ( ! fc1( )) return ( 0 );
plustemp();
}
return ( 1 );
}
plustemp() /* temp_int++ : saves 2 bytes per call. */
{ ++temp_int;
}
decparm() /* --cmdparm >= 0 */
{ return ( --cmdparm >= 0 );
}
xlinsc()
{ return( linsert( xinsct, xbufchar ));
}
kdcheck()
{ if ( ! ( lastflag & CFKILL )) kdelete();
thisflag |= CFKILL;
}
wfmove()
{ curwp->w_flag |= WFMOVE;
}