int main(void) {
bst b = bst_new();
printf("inserting d,b,f,a,c,e,g\n");
b = bst_insert(b, "d");
b = bst_insert(b, "b");
b = bst_insert(b, "f");
b = bst_insert(b, "a");
b = bst_insert(b, "c");
b = bst_insert(b, "e");
b = bst_insert(b, "g");
printf("inorder traversal\n");
bst_inorder(b, print_key);
printf("preorder traversal\n");
bst_preorder(b, print_key);
printf("searching\n");
dosearch(b, "f");
dosearch(b, "o");
dosearch(b, "x");
dosearch(b, "e");
dosearch(b, "d");
bst_free(b);
return EXIT_SUCCESS;
}
void search(int a[ ])
{
int b;
cout<<"Enter Number to Search for: ";
cin>>b;
dosearch(a,b);
cout<<"The number was found in line number "<<dosearch(a,b)<<endl;
}
int main (int argc, char *argv[]) {
int i;
struct QueryDataForamt QueryData;
//send out an HTTP header:
printf("Content-type: text/xml\n\n");
//hvis vi har argumeneter er det første et query
if (getenv("QUERY_STRING") == NULL) {
if (argc < 2 ) {
printf("Error ingen query spesifisert.\n\nEksempel på bruk for å søke på boitho:\n\tsearchkernel boitho\n");
}
else {
QueryData.query[0] = '\0';
for(i=1;i<argc ;i++) {
sprintf(QueryData.query,"%s %s",QueryData.query,argv[i]);
}
//strcpy(QueryData.query,argv[1]);
//printf("argc :%i %s %s\n",argc,argv[1],argv[2]);
printf("query %s\n",QueryData.query);
}
}
else {
parseTheEnv(&QueryData);
}
if (strlen(QueryData.query) > MaxQueryLen -1) {
printf("query to long\n");
exit(1);
}
//gjør om til liten case
for(i=0;i<strlen(QueryData.query);i++) {
QueryData.query[i] = tolower(QueryData.query[i]);
}
dosearch(QueryData.query, strlen(QueryData.query));
}
void
main(int argc, char **argv)
{
fmtinstall('H', httpfmt);
fmtinstall('U', hurlfmt);
fmtinstall('M', dirmodefmt);
aio = Bopen("/sys/lib/webls.allowed", OREAD);
dio = Bopen("/sys/lib/webls.denied", OREAD);
if(argc == 2){
hinit(&houtb, 1, Hwrite);
hout = &houtb;
dols(argv[1]);
exits(nil);
}
close(2);
connect = init(argc, argv);
hout = &connect->hout;
vermaj = connect->req.vermaj;
if(hparseheaders(connect, HSTIMEOUT) < 0)
exits("failed");
if(strcmp(connect->req.meth, "GET") != 0 && strcmp(connect->req.meth, "HEAD") != 0){
hunallowed(connect, "GET, HEAD");
exits("not allowed");
}
if(connect->head.expectother || connect->head.expectcont){
hfail(connect, HExpectFail, nil);
exits("failed");
}
bind("/usr/web", "/", MREPL);
if(connect->req.search != nil)
dosearch(connect->req.search);
else
error("Bad argument", "<p>Need a search argument</p>");
hflush(hout);
writelog(connect, "200 webls %ld %ld\n", hout->seek, hout->seek);
exits(nil);
}
boolean wpverbfind (hdlexternalvariable hvariable, boolean *flzoom) {
#pragma unused(flzoom)
register hdlwpvariable hv = (hdlwpvariable) hvariable;
register hdlwprecord hwp;
register boolean fl;
boolean fltempload;
boolean flwindowopen;
hdlwindowinfo hinfo;
fltempload = !(**hv).flinmemory;
if (!wpverbinmemory ((hdlexternalvariable) hv))
return (false);
hwp = (hdlwprecord) (**hv).variabledata;
flwindowopen = wpwindowopen ((hdlexternalvariable) hv, &hinfo);
if (flwindowopen)
shellpushglobals ((**hinfo).macwindow);
else {
shellpushglobals (nil);
wppushdata (hwp);
}
fl = dosearch (true, false, &fltempload);
if (fltempload && !fl && !(**hwp).fldirty)
wpverbunload (hv);
if (!flwindowopen)
wppopdata ();
shellpopglobals ();
return (fl);
} /*wpverbfind*/
void
main(int argc, char **argv)
{
fmtinstall('H', httpfmt);
fmtinstall('U', hurlfmt);
if(argc == 2){
hinit(&houtb, 1, Hwrite);
hout = &houtb;
doconvert(argv[1], 0);
exits(nil);
}
close(2);
connect = init(argc, argv);
hout = &connect->hout;
if(hparseheaders(connect, HSTIMEOUT) < 0)
exits("failed");
if(strcmp(connect->req.meth, "GET") != 0 && strcmp(connect->req.meth, "HEAD") != 0){
hunallowed(connect, "GET, HEAD");
exits("not allowed");
}
if(connect->head.expectother || connect->head.expectcont){
hfail(connect, HExpectFail, nil);
exits("failed");
}
bind("/usr/web/sys/man", "/sys/man", MREPL);
if(connect->req.search != nil)
dosearch(connect->req.vermaj, connect->req.search);
else
doconvert(connect->req.uri, connect->req.vermaj);
hflush(hout);
writelog(connect, "200 man2html %ld %ld\n", hout->seek, hout->seek);
exits(nil);
}
static boolean wpverbsearch (void) {
/*
2/13/92 dmb: use new dosearch to handle replace all
*/
long wprefcon = (**wpdata).wprefcon;
boolean fltempload = false;
startingtosearch (wprefcon);
/*
if (wpsearch (searchparams.bsfind, false, !searchparams.flunicase, searchparams.flwholewords, searchshouldwrap (wprefcon)))
return (true);
*/
if (dosearch (false, searchshouldwrap (wprefcon), &fltempload))
return (true);
if (!searchshouldcontinue (wprefcon))
return (false);
return (langexternalcontinuesearch ((hdlexternalvariable) wprefcon));
} /*wpverbsearch*/
int
main( int argc, char **argv )
{
char *filtpattern, **attrs;
int rc, optind, i, first, free_filtpattern;
LDAP *ld;
#ifdef SOLARIS_LDAP_CMD
char *locale = setlocale(LC_ALL, "");
textdomain(TEXT_DOMAIN);
ldaptool_require_binddn = 0;
#endif /* SOLARIS_LDAP_CMD */
free_filtpattern = 0;
deref = LDAP_DEREF_NEVER;
allow_binary = vals2tmp = attrsonly = 0;
minimize_base64 = produce_file_urls = 0;
ldif = 1;
fold = 1;
sizelimit = timelimit = 0;
scope = LDAP_SCOPE_SUBTREE;
server_sort = 0;
#ifdef notdef
#ifdef HPUX11
#ifndef __LP64__
_main( argc, argv);
#endif /* __LP64_ */
#endif /* HPUX11 */
#endif
ldaptool_reset_control_array( ldaptool_request_ctrls );
#ifdef HAVE_SASL_OPTIONS
#ifdef SOLARIS_LDAP_CMD
optind = ldaptool_process_args( argc, argv, "ABLTU1etuxra:b:F:G:l:S:s:z:C:",
0, options_callback );
#else
optind = ldaptool_process_args( argc, argv, "ABLTU1etuxa:b:F:G:l:S:s:z:C:c:",
0, options_callback );
#endif /* SOLARIS_LDAP_CMD */
#else
optind = ldaptool_process_args( argc, argv, "ABLTU1eotuxa:b:F:G:l:S:s:z:C:c:",
0, options_callback );
#endif /* HAVE_SASL_OPTIONS */
if ( optind == -1 ) {
usage();
}
if ( base == NULL ) {
if (( base = getenv( "LDAP_BASEDN" )) == NULL ) {
usage();
}
}
if ( sortattr ) {
for ( sortsize = 0; sortattr[sortsize] != NULL; sortsize++ ) {
; /* NULL */
}
sortsize++; /* add in the final NULL field */
skipsortattr = (int *) malloc( sortsize * sizeof(int *) );
if ( skipsortattr == NULL ) {
fprintf( stderr, gettext("Out of memory\n") );
exit( LDAP_NO_MEMORY );
}
memset( (char *) skipsortattr, 0, sortsize * sizeof(int *) );
} else if ( server_sort ) {
server_sort = 0; /* ignore this option if no sortattrs were given */
}
if ( argc - optind < 1 ) {
if ( ldaptool_fp == NULL ) {
usage();
}
attrs = NULL;
filtpattern = "%s";
} else { /* there are additional args (filter + attrs) */
if ( ldaptool_fp == NULL || strstr( argv[ optind ], "%s" ) != NULL ) {
filtpattern = ldaptool_local2UTF8( argv[ optind ] );
/* since local2UTF8 always allocates something, we should free it */
free_filtpattern = 1;
++optind;
} else {
filtpattern = "%s";
}
if ( argv[ optind ] == NULL ) {
attrs = NULL;
} else if ( sortattr == NULL || *sortattr == '\0' || server_sort) {
attrs = &argv[ optind ];
} else {
attrs = ldap_charray_dup( &argv[ optind ] );
if ( attrs == NULL ) {
fprintf( stderr, gettext("Out of memory\n") );
exit( LDAP_NO_MEMORY );
}
for ( i = 0; i < (sortsize - 1); i++ ) {
if ( !ldap_charray_inlist( attrs, sortattr[i] ) ) {
if ( ldap_charray_add( &attrs, sortattr[i] ) != 0 ) {
fprintf( stderr, gettext("Out of memory\n") );
exit( LDAP_NO_MEMORY );
}
/*
* attribute in the search list only for the purpose of
* sorting
*/
skipsortattr[i] = 1;
}
}
}
}
ld = ldaptool_ldap_init( 0 );
if ( !ldaptool_not ) {
ldap_set_option( ld, LDAP_OPT_DEREF, &deref );
ldap_set_option( ld, LDAP_OPT_TIMELIMIT, &timelimit );
ldap_set_option( ld, LDAP_OPT_SIZELIMIT, &sizelimit );
}
ldaptool_bind( ld );
if ( ldaptool_verbose ) {
printf( gettext("filter pattern: %s\nreturning: "), filtpattern );
if ( attrs == NULL ) {
printf( gettext("ALL") );
} else {
for ( i = 0; attrs[ i ] != NULL; ++i ) {
printf( "%s ", attrs[ i ] );
}
}
putchar( '\n' );
}
if ( ldaptool_fp == NULL ) {
char *conv;
conv = ldaptool_local2UTF8( base );
rc = dosearch( ld, conv, scope, attrs, attrsonly, filtpattern, "" );
if( conv != NULL )
free( conv );
} else {
int done = 0;
rc = LDAP_SUCCESS;
first = 1;
while ( rc == LDAP_SUCCESS && !done ) {
char *linep = NULL;
int increment = 0;
int c, index;
/* allocate initial block of memory */
if ((linep = (char *)malloc(BUFSIZ)) == NULL) {
fprintf( stderr, gettext("Out of memory\n") );
exit( LDAP_NO_MEMORY );
}
increment++;
index = 0;
while ((c = fgetc( ldaptool_fp )) != '\n' && c != EOF) {
/* check if we will overflow the buffer */
if ((c != EOF) && (index == ((increment * BUFSIZ) -1))) {
/* if we did, add another BUFSIZ worth of bytes */
if ((linep = (char *)
realloc(linep, (increment + 1) * BUFSIZ)) == NULL) {
fprintf( stderr, gettext("Out of memory\n") );
exit( LDAP_NO_MEMORY );
}
increment++;
}
linep[index++] = c;
}
if (c == EOF) {
done = 1;
break;
}
linep[index] = '\0';
if ( !first ) {
putchar( '\n' );
} else {
first = 0;
}
rc = dosearch( ld, base, scope, attrs, attrsonly, filtpattern,
linep );
free (linep);
}
}
ldaptool_cleanup( ld );
if (free_filtpattern != 0 && filtpattern != NULL) {
free (filtpattern);
}
/* check for and report output error */
fflush( stdout );
rc = ldaptool_check_ferror( stdout, rc,
gettext("output error (output might be incomplete)") );
return( rc );
}
int
main(int argc, char *argv[])
{
int fd;
#ifdef CHDIR
char *dir;
#endif
hname = argv[0];
hackpid = getpid();
#ifdef CHDIR /* otherwise no chdir() */
/*
* See if we must change directory to the playground.
* (Perhaps hack runs suid and playground is inaccessible
* for the player.)
* The environment variable HACKDIR is overridden by a
* -d command line option (must be the first option given)
*/
dir = getenv("HACKDIR");
if (argc > 1 && !strncmp(argv[1], "-d", 2)) {
argc--;
argv++;
dir = argv[0] + 2;
if (*dir == '=' || *dir == ':')
dir++;
if (!*dir && argc > 1) {
argc--;
argv++;
dir = argv[0];
}
if (!*dir)
error("Flag -d must be followed by a directory name.");
}
#endif
/*
* Who am i? Algorithm: 1. Use name as specified in HACKOPTIONS
* 2. Use $USER or $LOGNAME (if 1. fails)
* 3. Use getlogin() (if 2. fails)
* The resulting name is overridden by command line options.
* If everything fails, or if the resulting name is some generic
* account like "games", "play", "player", "hack" then eventually
* we'll ask him.
* Note that we trust him here; it is possible to play under
* somebody else's name.
*/
{
char *s;
initoptions();
if (!*plname && (s = getenv("USER")))
strncpy(plname, s, sizeof(plname) - 1);
if (!*plname && (s = getenv("LOGNAME")))
strncpy(plname, s, sizeof(plname) - 1);
if (!*plname && (s = getlogin()))
strncpy(plname, s, sizeof(plname) - 1);
}
/*
* Now we know the directory containing 'record' and
* may do a prscore().
*/
if (argc > 1 && !strncmp(argv[1], "-s", 2)) {
#ifdef CHDIR
chdirx(dir, 0);
#endif
prscore(argc, argv);
exit(0);
}
/*
* It seems he really wants to play.
* Remember tty modes, to be restored on exit.
*/
gettty();
setbuf(stdout, obuf);
umask(007);
setrandom();
startup();
cls();
u.uhp = 1; /* prevent RIP on early quits */
u.ux = FAR; /* prevent nscr() */
signal(SIGHUP, hangup);
/*
* Find the creation date of this game,
* so as to avoid restoring outdated savefiles.
*/
gethdate(hname);
/*
* We cannot do chdir earlier, otherwise gethdate will fail.
*/
#ifdef CHDIR
chdirx(dir, 1);
#endif
/*
* Process options.
*/
while (argc > 1 && argv[1][0] == '-') {
argv++;
argc--;
switch (argv[0][1]) {
#ifdef WIZARD
case 'D':
wizard = TRUE;
break;
#endif
#ifdef NEWS
case 'n':
flags.nonews = TRUE;
break;
#endif
case 'u':
if (argv[0][2])
strncpy(plname, argv[0] + 2, sizeof(plname) - 1);
else if (argc > 1) {
argc--;
argv++;
strncpy(plname, argv[0], sizeof(plname) - 1);
} else
printf("Player name expected after -u\n");
break;
default:
/* allow -T for Tourist, etc. */
strncpy(pl_character, argv[0] + 1,
sizeof(pl_character) - 1);
}
}
if (argc > 1)
locknum = atoi(argv[1]);
#ifdef MAX_NR_OF_PLAYERS
if (!locknum || locknum > MAX_NR_OF_PLAYERS)
locknum = MAX_NR_OF_PLAYERS;
#endif
#ifdef DEF_PAGER
if (!(catmore = getenv("HACKPAGER")) && !(catmore = getenv("PAGER")))
catmore = DEF_PAGER;
#endif
#ifdef MAIL
getmailstatus();
#endif
#ifdef WIZARD
if (wizard)
strcpy(plname, "wizard");
else
#endif
if (!*plname || !strncmp(plname, "player", 4)
|| !strncmp(plname, "games", 4))
askname();
plnamesuffix(); /* strip suffix from name; calls askname() */
/* again if suffix was whole name */
/* accepts any suffix */
#ifdef WIZARD
if (!wizard) {
#endif
/*
* check for multiple games under the same name
* (if !locknum) or check max nr of players (otherwise)
*/
signal(SIGQUIT, SIG_IGN);
signal(SIGINT, SIG_IGN);
if (!locknum)
strcpy(lock, plname);
getlock(); /* sets lock if locknum != 0 */
#ifdef WIZARD
} else {
char *sfoo;
strcpy(lock, plname);
if ((sfoo = getenv("MAGIC")))
while (*sfoo) {
switch (*sfoo++) {
case 'n':
srandom(*sfoo++);
break;
}
}
if ((sfoo = getenv("GENOCIDED")) != NULL) {
if (*sfoo == '!') {
struct permonst *pm = mons;
char *gp = genocided;
while (pm < mons + CMNUM + 2) {
if (!strchr(sfoo, pm->mlet))
*gp++ = pm->mlet;
pm++;
}
*gp = 0;
} else
strncpy(genocided, sfoo, sizeof(genocided) - 1);
strcpy(fut_geno, genocided);
}
}
#endif
setftty();
sprintf(SAVEF, "save/%d%s", getuid(), plname);
regularize(SAVEF + 5); /* avoid . or / in name */
if ((fd = open(SAVEF, O_RDONLY)) >= 0 &&
(uptodate(fd) || unlink(SAVEF) == 666)) {
signal(SIGINT, done1);
pline("Restoring old save file...");
fflush(stdout);
if (!dorecover(fd))
goto not_recovered;
pline("Hello %s, welcome to %s!", plname, gamename);
flags.move = 0;
} else {
not_recovered:
fobj = fcobj = invent = 0;
fmon = fallen_down = 0;
ftrap = 0;
fgold = 0;
flags.ident = 1;
init_objects();
u_init();
signal(SIGINT, done1);
mklev();
u.ux = xupstair;
u.uy = yupstair;
inshop();
setsee();
flags.botlx = 1;
makedog();
{
struct monst *mtmp;
if ((mtmp = m_at(u.ux, u.uy)) != NULL)
mnexto(mtmp); /* riv05!a3 */
}
seemons();
#ifdef NEWS
if (flags.nonews || !readnews())
/* after reading news we did docrt() already */
#endif
docrt();
/* give welcome message before pickup messages */
pline("Hello %s, welcome to %s!", plname, gamename);
pickup(1);
read_engr_at(u.ux, u.uy);
flags.move = 1;
}
flags.moonphase = phase_of_the_moon();
if (flags.moonphase == FULL_MOON) {
pline("You are lucky! Full moon tonight.");
u.uluck++;
} else if (flags.moonphase == NEW_MOON)
pline("Be careful! New moon tonight.");
initrack();
for (;;) {
if (flags.move) { /* actual time passed */
settrack();
if (moves % 2 == 0 ||
(!(Fast & ~INTRINSIC) && (!Fast || rn2(3)))) {
movemon();
if (!rn2(70))
makemon(NULL, 0, 0);
}
if (Glib)
glibr();
p_timeout();
++moves;
if (flags.time)
flags.botl = 1;
if (u.uhp < 1) {
pline("You die...");
done("died");
}
if (u.uhp * 10 < u.uhpmax && moves - wailmsg > 50) {
wailmsg = moves;
if (u.uhp == 1)
pline("You hear the wailing of the Banshee...");
else
pline("You hear the howling of the CwnAnnwn...");
}
if (u.uhp < u.uhpmax) {
if (u.ulevel > 9) {
if (Regeneration || !(moves % 3)) {
flags.botl = 1;
u.uhp += rnd((int)u.ulevel - 9);
if (u.uhp > u.uhpmax)
u.uhp = u.uhpmax;
}
} else if (Regeneration ||
(!(moves % (22 - u.ulevel * 2)))) {
flags.botl = 1;
u.uhp++;
}
}
if (Teleportation && !rn2(85))
tele();
if (Searching && multi >= 0)
dosearch();
gethungry();
invault();
amulet();
}
if (multi < 0) {
if (!++multi) {
pline("%s", nomovemsg ? nomovemsg :
"You can move again.");
nomovemsg = 0;
if (afternmv)
(*afternmv)();
afternmv = NULL;
}
}
find_ac();
#ifndef QUEST
if (!flags.mv || Blind)
#endif
{
seeobjs();
seemons();
nscr();
}
if (flags.botl || flags.botlx)
bot();
flags.move = 1;
if (multi >= 0 && occupation) {
if (monster_nearby())
stop_occupation();
else if ((*occupation)() == 0)
occupation = NULL;
continue;
}
if (multi > 0) {
#ifdef QUEST
if (flags.run >= 4)
finddir();
#endif
lookaround();
if (!multi) { /* lookaround may clear multi */
flags.move = 0;
continue;
}
if (flags.mv) {
if (multi < COLNO && !--multi)
flags.mv = flags.run = 0;
domove();
} else {
--multi;
rhack(save_cm);
}
} else if (multi == 0) {
#ifdef MAIL
ckmailstatus();
#endif
rhack(NULL);
}
if (multi && multi % 7 == 0)
fflush(stdout);
}
}
/*
This is the routine that is executed from a new thread
*/
void *do_chld(void *arg)
{
// starter loging
bblog(DEBUGINFO, "searchd_child: Starting new thread.");
bblog(DEBUGINFO, "searchd: do_chld()");
// deklarerer variabler
struct searchd_configFORMAT *searchd_config = arg;
int mysocfd = (*searchd_config).newsockfd;
struct timeval globalstart_time, globalend_time;
FILE *LOGFILE;
int i,n;
struct queryNodeHederFormat queryNodeHeder;
struct SiderFormat *Sider;
int net_status;
int ranking;
struct hashtable *crc32hashmap;
int nrOfSubnames;
config_setting_t *cfgstring;
config_setting_t *cfgcollection;
config_setting_t *cfgcollections;
struct subnamesConfigFormat subnamesDefaultsConfig;
char **Data;
int Count;
char groupOrQuery[1024];
groupOrQuery[0] = '\0';
struct SiderHederFormat *SiderHeder;
// Setter signalhånterer for allarm. Hvis allarm skjer i straten av programet, er noe seriøst galt. For eks er vi tom for minne.
//Da fungerer det dårlig å logge, syslog kan kalle malloc og slikt. Vil resette den til en versjon som logger før vi kjører søk.
signal (SIGALRM, catch_alarm_nolog);
/* Set an alarm to go off in a little while. This so we don't run forever if we get en ever loop */
alarm (searchd_config->optAlarm);
dp_priority_locl_start();
// første malloc. Har vi forlite minne vil vi henge her.
if ((SiderHeder = malloc(sizeof(struct SiderHederFormat))) == NULL) {
bblog(ERROR, "malloc()");
bblog(CLEAN, "~do_chld()");
return 0;
}
gettimeofday(&globalstart_time, NULL);
#ifdef WITH_THREAD
bblog(DEBUGINFO, "Child thread [%d]: Socket number = %d", pthread_self(), mysocfd);
#else
bblog(DEBUGINFO, "Socket number = %d",mysocfd);
#endif
#ifdef DEBUG
struct timeval start_time, end_time;
#endif
// Setter signalhånterer for allarm. Hvis allarm skjer i straten av programet, er noe seriøst galt. For eks er vi tom for minne.
//Da fungerer det dårlig å logge, syslog kan kalle malloc og slikt. Nå resetter vi den den til en versjon som logger søk.
signal (SIGALRM, catch_alarm);
/* Disable tcp delay */
int nodelayflag = 1;
setsockopt(mysocfd, IPPROTO_TCP, TCP_NODELAY, &nodelayflag, sizeof(int));
/* read from the given socket */
if ((i=recv(mysocfd, &queryNodeHeder, sizeof(queryNodeHeder),MSG_WAITALL)) == -1) {
bblog_errno(ERROR, "recv()");
}
// Read collections /w cfg.
if ((recv(mysocfd, &nrOfSubnames, sizeof nrOfSubnames, MSG_WAITALL)) == -1)
bblog_errno(ERROR, "recv nrOfSubnames");
bblog(DEBUGINFO, "nrOfSubnames: %d",nrOfSubnames);
struct subnamesFormat subnames[nrOfSubnames];
if (nrOfSubnames > 0) {
if ((recv(mysocfd, &subnames, sizeof subnames, MSG_WAITALL)) == -1)
bblog_errno(ERROR, "recv subnames");
}
//sender svar med en gang at vi kan gjøre dette
net_status = net_CanDo;
//if ((n=sendall(mysocfd,&net_status, sizeof(net_status))) != sizeof(net_status)) {
if ((n=send(mysocfd,&net_status, sizeof(net_status),MSG_NOSIGNAL)) != sizeof(net_status)) {
bblog_errno(ERROR, "searchd_child: Warning! Sent only %i of %i bytes at %s:%d",n,sizeof(net_status),__FILE__,__LINE__);
}
bblog(DEBUGINFO, "MaxsHits %i",queryNodeHeder.MaxsHits);
//Sider = (struct SiderFormat *)malloc(sizeof(struct SiderFormat) * (queryNodeHeder.MaxsHits));
bblog(DEBUGINFO, "Ranking search?");
#ifndef BLACK_BOKS
//ToDo: må ha låsing her
if ((LOGFILE = bfopen("config/query.log","a")) == NULL) {
bblog_errno(ERROR, "logfile");
}
else {
fprintf(LOGFILE,"%s\n",queryNodeHeder.query);
fclose(LOGFILE);
}
#endif
bblog(DEBUGINFO, "searchd_child: Incoming query: %s",queryNodeHeder.query);
strcpy(SiderHeder->servername,servername);
#ifndef WITHOUT_THESAURUS
// TODO: Denne må skalere til flere språk:
char *lang = NULL;
switch (queryNodeHeder.lang)
{
case LANG_NBO: lang = "nbo"; break;
case LANG_ENG: lang = "eng"; break;
}
bblog(INFO, "[searchd] lang_id = %i", queryNodeHeder.lang);
bblog(INFO, "[searchd] lang = %s", lang);
searchd_config->thesaurusp = NULL;
if (lang != NULL && searchd_config->thesaurus_all != NULL)
{
iterator it = map_find(searchd_config->thesaurus_all, lang);
if (it.valid)
{
bblog(INFO, "[searchd] Loading %s thesaurus", lang);
searchd_config->thesaurusp = map_val(it).ptr;
}
else
{
bblog(INFO, "[searchd] No thesaurus for %s", lang);
}
}
#endif
/***************************************/
/****************/
//dekoder subname
bblog(DEBUGINFO, "nrOfSubnames %i",nrOfSubnames);
/*
nrOfSubnames = 1;
subnames = malloc(sizeof(struct subnamesFormat) * nrOfSubnames);
strscpy(subnames[0].subname,"www",sizeof(subnames[0].subname));
*/
#ifdef DEBUG
bblog(DEBUGINFO, "searchd_child: ");
bblog(DEBUGINFO, "##########################################################");
bblog(DEBUGINFO, "searchd_child: subnames:");
bblog(DEBUGINFO, "Total of %i", nrOfSubnames);
for (i=0;i<nrOfSubnames;i++) {
bblog(DEBUGINFO, "searchd_child: subname nr %i: \"%s\"",i,subnames[i].subname);
}
bblog(DEBUGINFO, "searchd_child: ##########################################################");
#endif
SiderHeder->filtypesnrof = MAXFILTYPES;
SiderHeder->errorstrlen=sizeof(SiderHeder->errorstr);
int parsing_failed;
attr_conf *navmenu_cfg = parse_navmenu_cfg(queryNodeHeder.navmenucfg, &parsing_failed, globalOptVerbose);
if (parsing_failed) {
SiderHeder->responstype = searchd_responstype_error;
snprintf(SiderHeder->errorstr, sizeof SiderHeder->errorstr,
"An error occurred while parsing configuration for navigation menu.");
SiderHeder->errorstrlen = strlen(SiderHeder->errorstr); // TODO: is errorstrlen even used?
}
if (!dosearch(queryNodeHeder.query, strlen(queryNodeHeder.query),&Sider,SiderHeder,SiderHeder->hiliteQuery,
servername,subnames,nrOfSubnames,queryNodeHeder.MaxsHits,
queryNodeHeder.start, queryNodeHeder.filterOn,
"",queryNodeHeder.orderby,SiderHeder->dates,queryNodeHeder.search_user,
&SiderHeder->filters,
searchd_config,
SiderHeder->errorstr, &SiderHeder->errorstrlen,
&global_DomainIDs, queryNodeHeder.HTTP_USER_AGENT,
groupOrQuery, queryNodeHeder.anonymous, navmenu_cfg,
spelling
))
{
bblog(WARN, "searchd_child: dosearch did not return success");
SiderHeder->responstype = searchd_responstype_error;
//setter at vi ikke hadde noen svar
SiderHeder->TotaltTreff = 0;
SiderHeder->showabal = 0;
bblog(ERROR, "searchd_child: can't do dosearch: \"%s\"", SiderHeder->errorstr);
}
show_attributes_destroy(navmenu_cfg);
dp_priority_locl_end();
//kopierer inn subnames. Kan bare sende over MAX_COLLECTIONS, men søker i alle
for (i=0;((i<MAX_COLLECTIONS) && (i<nrOfSubnames));i++) {
SiderHeder->subnames[i] = subnames[i];
}
SiderHeder->nrOfSubnames = i--;
if (globalOptVerbose) {
bblog(INFO, "searchd_child: subnames:");
for (i=0;i<SiderHeder->nrOfSubnames;i++) {
bblog(INFO, "searchd_child: \t%s: %i",SiderHeder->subnames[i].subname,SiderHeder->subnames[i].hits);
}
bblog(INFO, "searchd_child:");
}
//finer først tiden vi brukte
gettimeofday(&globalend_time, NULL);
SiderHeder->total_usecs = getTimeDifference(&globalstart_time,&globalend_time);
//printf("query \"%s\", TotaltTreff %i,showabal %i,filtered %i,total_usecs %f\n",queryNodeHeder.query,SiderHeder->TotaltTreff,SiderHeder->showabal,SiderHeder->filtered,SiderHeder->total_usecs);
bblog(CLEAN, "|%-40s | %-11i | %-11i | %-11i | %-11f|",
queryNodeHeder.query,
SiderHeder->TotaltTreff,
SiderHeder->showabal,
SiderHeder->filtered,
SiderHeder->total_usecs);
#ifdef DEBUG
gettimeofday(&start_time, NULL);
#endif
#if 1
#ifdef DEBUG
gettimeofday(&end_time, NULL);
bblog(DEBUGINFO, "searchd_child: Time debug: sending SiderHeder %f",getTimeDifference(&start_time,&end_time));
#endif
#ifdef DEBUG
gettimeofday(&start_time, NULL);
#endif
struct sendarrayFormat{
int size;
void *p;
int copy;
};
void send_to_array (struct sendarrayFormat *sendarray, int *sendarraylength, void *p, int size, int copy) {
#ifdef DEBUG
printf("send_to_array(sendarraylength=%i,size=%i)\n",*sendarraylength,size);
#endif
if (size == 0) {
return;
}
sendarray[*sendarraylength].copy = copy;
if (copy) {
sendarray[*sendarraylength].p = malloc(size);
memcpy(sendarray[*sendarraylength].p,p,size);
sendarray[*sendarraylength].size = size;
}
else {
sendarray[*sendarraylength].p = p;
sendarray[*sendarraylength].size = size;
}
*sendarraylength += 1;
}
void
normal()
{
register u_char c;
long n;
int flag = FALSE;
int type = 0; /* used in some operations to modify type */
int dir = FORWARD; /* search direction */
u_char nchar = NUL;
int finish_op;
linenr_t Prenum1;
char searchbuff[CMDBUFFSIZE]; /* buffer for search string */
FPOS *pos;
register char *ptr;
int command_busy = FALSE;
static linenr_t redo_Quote_nlines;
static int redo_Quote_type;
static long redo_Quote_col;
Prenum = 0;
/*
* If there is an operator pending, then the command we take this time
* will terminate it. Finish_op tells us to finish the operation before
* returning this time (unless the operation was cancelled).
*/
finish_op = (operator != NOP);
if (!finish_op && !yankbuffer)
opnum = 0;
if (vpeekc() == NUL || KeyTyped == TRUE)
premsg(NUL, NUL);
State = NORMAL_BUSY;
c = vgetc();
/* Pick up any leading digits and compute 'Prenum' */
while ((c >= '1' && c <= '9') || (Prenum > 0 && (c == DEL || c == '0')))
{
if (c == DEL)
Prenum /= 10;
else
Prenum = Prenum * 10 + (c - '0');
premsg(' ', NUL);
c = vgetc();
}
/*
* If we're in the middle of an operator (including after entering a yank
* buffer with ") AND we had a count before the
* operator, then that count overrides the current value of Prenum. What
* this means effectively, is that commands like "3dw" get turned into
* "d3w" which makes things fall into place pretty neatly.
* If you give a count before AND after the operator, they are multiplied.
*/
if (opnum != 0)
{
if (Prenum)
Prenum *= opnum;
else
Prenum = opnum;
opnum = 0;
}
Prenum1 = (Prenum == 0 ? 1 : Prenum); /* Prenum often defaults to 1 */
premsg(c, NUL);
/*
* get an additional character if we need one
*/
if (strchr("@zZtTfF[]rm'`\"", c) || (c == 'v' && Recording == FALSE))
{
State = NOMAPPING;
nchar = vgetc(); /* no macro mapping for this char */
premsg(c, nchar);
}
flushbuf(); /* flush the premsg() characters onto the screen so we can
see them while the command is being executed */
if (c != 'z') /* the 'z' command gets another character */
{
State = NORMAL;
script_winsize_pp();
}
if (nchar == ESC)
{
CLEAROP;
goto normal_end;
}
switch (c)
{
/*
* 0: Macros
*/
case 'v': /* (stop) recording into a named buffer */
CHECKCLEAROP;
if (!dorecord(nchar))
CLEAROPBEEP;
break;
case '@': /* execute a named buffer */
CHECKCLEAROP;
while (Prenum1--)
if (!doexecbuf(nchar))
{
CLEAROPBEEP;
break;
}
break;
/*
* 1: Screen positioning commands
*/
case CTRL('D'):
flag = TRUE;
case CTRL('U'):
CHECKCLEAROP;
if (Prenum)
p_scroll = (Prenum > Rows - 1) ? Rows - 1 : Prenum;
n = (p_scroll < Rows) ? p_scroll : Rows - 1;
if (flag)
{
scrollup(n);
onedown(n);
}
else
{
scrolldown(n);
oneup(n);
}
updateScreen(VALID);
break;
case CTRL('B'):
case K_SUARROW:
dir = BACKWARD;
case CTRL('F'):
case K_SDARROW:
CHECKCLEAROP;
onepage(dir, Prenum1);
break;
case CTRL('E'):
CHECKCLEAROP;
scrollup(Prenum1);
updateScreen(VALID);
break;
case CTRL('Y'):
CHECKCLEAROP;
scrolldown(Prenum1);
updateScreen(VALID);
break;
case 'z':
CHECKCLEAROP;
if (isdigit(nchar))
{
/*
* we misuse some variables to be able to call premsg()
*/
operator = c;
opnum = Prenum;
Prenum = nchar - '0';
for (;;)
{
premsg(' ', NUL);
nchar = vgetc();
State = NORMAL;
script_winsize_pp();
if (nchar == DEL)
Prenum /= 10;
else if (isdigit(nchar))
Prenum = Prenum * 10 + (nchar - '0');
else if (nchar == CR)
{
set_winsize((int)Columns, (int)Prenum, TRUE);
break;
}
else
{
CLEAROPBEEP;
break;
}
}
operator = NOP;
break;
}
if (Prenum) /* line number given */
{
if (Prenum > line_count)
Curpos.lnum = line_count;
else
Curpos.lnum = Prenum;
}
State = NORMAL;
script_winsize_pp();
switch (nchar)
{
case NL: /* put Curpos at top of screen */
case CR:
Topline = Prenum;
updateScreen(VALID);
break;
case '.': /* put Curspos in middle of screen */
n = Rows / 2;
goto dozcmd;
case '-': /* put Curpos at bottom of screen */
n = Rows - 1;
/* FALLTHROUGH */
dozcmd:
{
register linenr_t lp = Prenum;
register long l = 0;
while ((l < n) && (lp != 0))
{
l += plines(lp);
Topline = lp;
--lp;
}
}
updateScreen(VALID);
break;
default:
CLEAROPBEEP;
}
break;
/*
* 2: Control commands
*/
case ':':
if (Quote.lnum)
goto dooperator;
CHECKCLEAROP;
docmdline(NULL);
break;
case K_HELP:
CHECKCLEAROP;
help();
break;
case CTRL('L'):
CHECKCLEAROP;
updateScreen(CLEAR);
break;
case CTRL('G'):
CHECKCLEAROP;
fileinfo();
break;
case K_CCIRCM: /* shorthand command */
CHECKCLEAROPQ;
if (getaltfile((int)Prenum, (linenr_t)0, TRUE))
emsg(e_noalt);
break;
case 'Z': /* write, if changed, and exit */
CHECKCLEAROPQ;
if (nchar != 'Z')
{
CLEAROPBEEP;
break;
}
stuffReadbuff(":x\n");
break;
case CTRL(']'): /* :ta to current identifier */
CHECKCLEAROPQ;
case '*': /* / to current identifier */
case '#': /* ? to current identifier */
case 'K': /* run program for current identifier */
{
register int col;
ptr = nr2ptr(Curpos.lnum);
col = Curpos.col;
/*
* skip to start of identifier.
*/
while (ptr[col] != NUL && !isidchar(ptr[col]))
++col;
/*
* Back up to start of identifier. This doesn't match the
* real vi but I like it a little better and it shouldn't bother
* anyone.
*/
while (col > 0 && isidchar(ptr[col - 1]))
--col;
if (!isidchar(ptr[col]))
{
CLEAROPBEEP;
break;
}
if (Prenum)
stuffnumReadbuff(Prenum);
switch (c)
{
case '*':
stuffReadbuff("/");
break;
case '#':
stuffReadbuff("?");
break;
case 'K':
stuffReadbuff(":! ");
stuffReadbuff(p_kp);
stuffReadbuff(" ");
break;
default:
stuffReadbuff(":ta ");
}
/*
* Now grab the chars in the identifier
*/
while (isidchar(ptr[col]))
{
stuffReadbuff(mkstr(ptr[col]));
++col;
}
stuffReadbuff("\n");
}
break;
case CTRL('T'): /* backwards in tag stack */
CHECKCLEAROPQ;
dotag("", 2, (int)Prenum1);
break;
/*
* Cursor motions
*/
case 'G':
mtype = MLINE;
setpcmark();
if (Prenum == 0 || Prenum > line_count)
Curpos.lnum = line_count;
else
Curpos.lnum = Prenum;
beginline(TRUE);
break;
case 'H':
case 'M':
if (c == 'M')
n = Rows / 2;
else
n = Prenum;
mtype = MLINE;
Curpos.lnum = Topline;
while (n && onedown((long)1))
--n;
beginline(TRUE);
break;
case 'L':
mtype = MLINE;
Curpos.lnum = Botline - 1;
for (n = Prenum; n && oneup((long)1); n--)
;
beginline(TRUE);
break;
case 'l':
case K_RARROW:
case ' ':
mtype = MCHAR;
mincl = FALSE;
n = Prenum1;
while (n--)
{
if (!oneright())
{
if (operator == NOP)
beep();
else
{
if (lineempty(Curpos.lnum))
CLEAROPBEEP;
else
{
mincl = TRUE;
if (n)
beep();
}
}
break;
}
}
set_want_col = TRUE;
break;
case 'h':
case K_LARROW:
case CTRL('H'):
case DEL:
mtype = MCHAR;
mincl = FALSE;
n = Prenum1;
while (n--)
{
if (!oneleft())
{
if (operator != DELETE && operator != CHANGE)
beep();
else if (Prenum1 == 1)
CLEAROPBEEP;
break;
}
}
set_want_col = TRUE;
break;
case '-':
flag = TRUE;
/* FALLTHROUGH */
case 'k':
case K_UARROW:
case CTRL('P'):
mtype = MLINE;
if (!oneup(Prenum1))
CLEAROPBEEP;
else if (flag)
beginline(TRUE);
break;
case '+':
case CR:
flag = TRUE;
/* FALLTHROUGH */
case 'j':
case K_DARROW:
case CTRL('N'):
case NL:
mtype = MLINE;
if (!onedown(Prenum1))
CLEAROPBEEP;
else if (flag)
beginline(TRUE);
break;
/*
* This is a strange motion command that helps make operators more
* logical. It is actually implemented, but not documented in the
* real 'vi'. This motion command actually refers to "the current
* line". Commands like "dd" and "yy" are really an alternate form of
* "d_" and "y_". It does accept a count, so "d3_" works to delete 3
* lines.
*/
case '_':
lineop:
mtype = MLINE;
if (!onedown((long)(Prenum1 - 1)))
CLEAROPBEEP;
else if (operator != YANK) /* 'Y' does not move cursor */
beginline(TRUE);
break;
case '|':
mtype = MCHAR;
mincl = TRUE;
beginline(FALSE);
if (Prenum > 0)
coladvance((colnr_t)(Prenum - 1));
Curswant = Prenum - 1;
break;
/*
* Word Motions
*/
case 'B':
type = 1;
/* FALLTHROUGH */
case 'b':
case K_SLARROW:
mtype = MCHAR;
mincl = FALSE;
set_want_col = TRUE;
if (bck_word(Prenum1, type))
CLEAROPBEEP;
break;
case 'E':
type = 1;
/* FALLTHROUGH */
case 'e':
mincl = TRUE;
goto dowrdcmd;
case 'W':
type = 1;
/* FALLTHROUGH */
case 'w':
case K_SRARROW:
mincl = FALSE;
flag = TRUE;
/*
* This is a little strange. To match what the real vi does, we
* effectively map 'cw' to 'ce', and 'cW' to 'cE', provided that we are
* not on a space or a TAB. This seems
* impolite at first, but it's really more what we mean when we say
* 'cw'.
*/
if (operator == CHANGE && (n = gcharCurpos()) != ' ' && n != TAB &&
n != NUL)
{
mincl = TRUE;
flag = FALSE;
}
dowrdcmd:
mtype = MCHAR;
set_want_col = TRUE;
if (flag)
n = fwd_word(Prenum1, type);
else
n = end_word(Prenum1, type, operator == CHANGE);
if (n)
{
CLEAROPBEEP;
break;
}
/*
* if we do a 'dw' for the last word in a line, we only delete the rest
* of the line, not joining the two lines.
*/
if (operator == DELETE && Prenum1 == 1 && startop.lnum != Curpos.lnum)
{
Curpos = startop;
while (oneright())
;
mincl = TRUE;
}
break;
case '$':
mtype = MCHAR;
mincl = TRUE;
Curswant = 29999; /* so we stay at the end */
if (!onedown((long)(Prenum1 - 1)))
{
CLEAROPBEEP;
break;
}
if (Quote_block)
updateScreen(NOT_VALID);
break;
case '^':
flag = TRUE;
/* FALLTHROUGH */
case '0':
mtype = MCHAR;
mincl = TRUE;
beginline(flag);
break;
/*
* 4: Searches
*/
case '?':
case '/':
if (!getcmdline(c, (u_char *)searchbuff))
{
CLEAROP;
break;
}
mtype = MCHAR;
mincl = FALSE;
set_want_col = TRUE;
n = dosearch(c == '/' ? FORWARD : BACKWARD, searchbuff, FALSE, Prenum1);
if (n == 0)
CLEAROPBEEP;
else if (n == 2)
mtype = MLINE;
break;
case 'N':
flag = 1;
case 'n':
mtype = MCHAR;
mincl = FALSE;
set_want_col = TRUE;
if (!dosearch(0, NULL, flag, Prenum1))
CLEAROPBEEP;
break;
/*
* Character searches
*/
case 'T':
dir = BACKWARD;
/* FALLTHROUGH */
case 't':
type = 1;
goto docsearch;
case 'F':
dir = BACKWARD;
/* FALLTHROUGH */
case 'f':
docsearch:
mtype = MCHAR;
mincl = TRUE;
set_want_col = TRUE;
if (!searchc(nchar, dir, type, Prenum1))
{
CLEAROPBEEP;
}
break;
case ',':
flag = 1;
/* FALLTHROUGH */
case ';':
dir = flag;
goto docsearch; /* nchar == NUL, thus repeat previous search */
/*
* section or C function searches
*/
case '[':
dir = BACKWARD;
/* FALLTHROUGH */
case ']':
mtype = MLINE;
set_want_col = TRUE;
flag = '{';
if (nchar != c)
{
if (nchar == '[' || nchar == ']')
flag = '}';
else
{
CLEAROPBEEP;
break;
}
}
if (dir == FORWARD && operator != NOP) /* e.g. y]] searches for '}' */
flag = '}';
if (!findpar(dir, Prenum1, flag))
{
CLEAROPBEEP;
}
break;
case '%':
mincl = TRUE;
if (Prenum) /* {cnt}% : goto {cnt} percentage in file */
{
if (Prenum > 100)
CLEAROPBEEP;
else
{
mtype = MLINE;
setpcmark();
Curpos.lnum = line_count * Prenum / 100;
Curpos.col = 0;
}
}
else /* % : go to matching paren */
{
mtype = MCHAR;
if ((pos = showmatch()) == NULL)
CLEAROPBEEP;
else
{
setpcmark();
Curpos = *pos;
set_want_col = TRUE;
}
}
break;
case '(':
dir = BACKWARD;
/* FALLTHROUGH */
case ')':
mtype = MCHAR;
if (c == ')')
mincl = FALSE;
else
mincl = TRUE;
set_want_col = TRUE;
if (!findsent(dir, Prenum1))
CLEAROPBEEP;
break;
case '{':
dir = BACKWARD;
/* FALLTHROUGH */
case '}':
mtype = MCHAR;
mincl = FALSE;
set_want_col = TRUE;
if (!findpar(dir, Prenum1, NUL))
CLEAROPBEEP;
break;
/*
* 5: Edits
*/
case '.':
CHECKCLEAROPQ;
if (!start_redo(Prenum))
CLEAROPBEEP;
break;
case 'u':
if (Quote.lnum)
goto dooperator;
case K_UNDO:
CHECKCLEAROPQ;
u_undo((int)Prenum1);
set_want_col = TRUE;
break;
case CTRL('R'):
CHECKCLEAROPQ;
u_redo((int)Prenum1);
set_want_col = TRUE;
break;
case 'U':
if (Quote.lnum)
goto dooperator;
CHECKCLEAROPQ;
u_undoline();
set_want_col = TRUE;
break;
case 'r':
if (Quote.lnum)
{
c = 'c';
goto dooperator;
}
CHECKCLEAROPQ;
n = strlen(nr2ptr(Curpos.lnum)) - Curpos.col;
if (n < Prenum1) /* not enough characters to replace */
{
CLEAROPBEEP;
break;
}
prep_redo(Prenum1, 'r', NUL, nchar);
stuffnumReadbuff(Prenum1);
stuffReadbuff("R");
stuffReadbuff(mkstr(nchar));
stuffReadbuff("\033");
break;
case 'J':
if (Quote.lnum) /* join the quoted lines */
{
if (Curpos.lnum > Quote.lnum)
{
Prenum = Curpos.lnum - Quote.lnum + 1;
Curpos.lnum = Quote.lnum;
}
else
Prenum = Quote.lnum - Curpos.lnum + 1;
Quote.lnum = 0;
}
CHECKCLEAROP;
if (Prenum <= 1)
Prenum = 2; /* default for join is two lines! */
if (Curpos.lnum + Prenum - 1 > line_count) /* beyond last line */
{
CLEAROPBEEP;
break;
}
prep_redo(Prenum, 'J', NUL, NUL);
dodojoin(Prenum, TRUE, TRUE);
break;
case 'P':
dir = BACKWARD;
/* FALLTHROUGH */
case 'p':
CHECKCLEAROPQ;
prep_redo(Prenum, c, NUL, NUL);
doput(dir, Prenum1);
break;
case CTRL('A'): /* add to number */
case CTRL('S'): /* subtract from number */
CHECKCLEAROPQ;
{
register int col;
char buf[30];
int hex; /* 'x' or 'X': hexadecimal; '0': octal */
static int hexupper = FALSE; /* 0xABC */
ptr = nr2ptr(Curpos.lnum);
col = Curpos.col;
/* first check if we are on a hexadecimal number */
while (col > 0 && isxdigit(ptr[col]))
--col;
if (col > 0 && toupper(ptr[col]) == 'X' && ptr[col - 1] == '0' && isxdigit(ptr[col + 1]))
--col; /* found hexadecimal number */
else
{
/* first search forward and then backward for start of number */
col = Curpos.col;
while (ptr[col] != NUL && !isdigit(ptr[col]))
++col;
while (col > 0 && isdigit(ptr[col - 1]))
--col;
}
if (isdigit(ptr[col]) && u_saveCurpos())
{
set_want_col = TRUE;
prep_redo(Prenum1, c, NUL, NUL);
if (ptr[col] != '0')
hex = 0; /* decimal */
else
{
hex = toupper(ptr[col + 1]); /* assume hexadecimal */
if (hex != 'X' || !isxdigit(ptr[col + 2]))
{
if (isdigit(hex))
hex = '0'; /* octal */
else
hex = 0; /* 0 by itself is decimal */
}
}
if (!hex && col > 0 && ptr[col - 1] == '-')
--col;
ptr += col;
if (hex == '0')
sscanf(ptr, "%lo", &n);
else if (hex)
sscanf(ptr, "%lx", &n); /* "%X" doesn't work! */
else
n = atol(ptr);
if (c == CTRL('A'))
n += Prenum1;
else
n -= Prenum1;
if (hex == 'X') /* skip the '0x' */
col += 2;
Curpos.col = col;
do /* delete the old number */
{
if (isalpha(c))
{
if (isupper(c))
hexupper = TRUE;
else
hexupper = FALSE;
}
delchar(FALSE);
c = gcharCurpos();
}
while (hex ? (hex == '0' ? c >= '0' && c <= '7' : isxdigit(c)) : isdigit(c));
if (hex == '0')
sprintf(buf, "0%lo", n);
else if (hexupper)
sprintf(buf, "%lX", n);
else if (hex)
sprintf(buf, "%lx", n);
else
sprintf(buf, "%ld", n);
insstr(buf); /* insert the new number */
--Curpos.col;
updateline();
}
else
beep();
}
break;
/*
* 6: Inserts
*/
case 'A':
set_want_col = TRUE;
while (oneright())
;
/* FALLTHROUGH */
case 'a':
CHECKCLEAROPQ;
/* Works just like an 'i'nsert on the next character. */
if (u_saveCurpos())
{
if (!lineempty(Curpos.lnum))
incCurpos();
startinsert(c, FALSE, Prenum1);
command_busy = TRUE;
}
break;
case 'I':
beginline(TRUE);
/* FALLTHROUGH */
case 'i':
CHECKCLEAROPQ;
if (u_saveCurpos())
{
startinsert(c, FALSE, Prenum1);
command_busy = TRUE;
}
break;
case 'o':
if (Quote.lnum) /* switch start and end of quote */
{
Prenum = Quote.lnum;
Quote.lnum = Curpos.lnum;
Curpos.lnum = Prenum;
n = Quote.col;
Quote.col = Curpos.col;
Curpos.col = n;
break;
}
CHECKCLEAROP;
if (u_save(Curpos.lnum, (linenr_t)(Curpos.lnum + 1)) && Opencmd(FORWARD, TRUE))
{
startinsert('o', TRUE, Prenum1);
command_busy = TRUE;
}
break;
case 'O':
CHECKCLEAROPQ;
if (u_save((linenr_t)(Curpos.lnum - 1), Curpos.lnum) && Opencmd(BACKWARD, TRUE))
{
startinsert('O', TRUE, Prenum1);
command_busy = TRUE;
}
break;
case 'R':
if (Quote.lnum)
{
c = 'c';
Quote.col = QUOTELINE;
goto dooperator;
}
CHECKCLEAROPQ;
if (u_saveCurpos())
{
startinsert('R', FALSE, Prenum1);
command_busy = TRUE;
}
break;
/*
* 7: Operators
*/
case '~': /* swap case */
/*
* if tilde is not an operator and Quoting is off: swap case
* of a single character
*/
if (!p_to && !Quote.lnum)
{
CHECKCLEAROPQ;
if (lineempty(Curpos.lnum))
{
CLEAROPBEEP;
break;
}
prep_redo(Prenum, '~', NUL, NUL);
if (!u_saveCurpos())
break;
for (; Prenum1 > 0; --Prenum1)
{
if (gcharCurpos() == NUL)
break;
swapchar(&Curpos);
incCurpos();
}
set_want_col = TRUE;
CHANGED;
updateline();
break;
}
/*FALLTHROUGH*/
case 'd':
case 'c':
case 'y':
case '>':
case '<':
case '!':
case '=':
case 'V':
dooperator:
n = strchr(opchars, c) - opchars + 1;
if (n == operator) /* double operator works on lines */
goto lineop;
CHECKCLEAROP;
if (Prenum != 0)
opnum = Prenum;
startop = Curpos;
operator = n;
break;
/*
* 8: Abbreviations
*/
/* when quoting the next commands are operators */
case 'S':
case 'Y':
case 'D':
case 'C':
case 'x':
case 'X':
case 's':
if (Quote.lnum)
{
static char trans[] = "ScYyDdCcxdXdsc";
if (isupper(c)) /* uppercase means linewise */
Quote.col = QUOTELINE;
c = *(strchr(trans, c) + 1);
goto dooperator;
}
case '&':
CHECKCLEAROPQ;
if (Prenum)
stuffnumReadbuff(Prenum);
if (c == 'S')
{
beginline((int)p_ai);
substituting = TRUE;
}
else if (c == 'Y' && p_ye)
c = 'Z';
{
static char *(ar[9]) = {"dl", "dh", "d$", "c$", "cl", "c$", "yy", "y$", ":s\r"};
static char *str = "xXDCsSYZ&";
stuffReadbuff(ar[strchr(str, c) - str]);
}
break;
/*
* 9: Marks
*/
case 'm':
CHECKCLEAROP;
if (!setmark(nchar))
CLEAROPBEEP;
break;
case '\'':
flag = TRUE;
/* FALLTHROUGH */
case '`':
pos = getmark(nchar, (operator == NOP));
if (pos == (FPOS *)-1) /* jumped to other file */
{
if (flag)
beginline(TRUE);
break;
}
if (pos != NULL)
setpcmark();
cursormark:
if (pos == NULL)
CLEAROPBEEP;
else
{
Curpos = *pos;
if (flag)
beginline(TRUE);
}
mtype = flag ? MLINE : MCHAR;
mincl = FALSE; /* ignored if not MCHAR */
set_want_col = TRUE;
break;
case CTRL('O'): /* goto older pcmark */
Prenum1 = -Prenum1;
/* FALLTHROUGH */
case CTRL('I'): /* goto newer pcmark */
CHECKCLEAROPQ;
pos = movemark((int)Prenum1);
if (pos == (FPOS *)-1) /* jump to other file */
{
set_want_col = TRUE;
break;
}
goto cursormark;
/*
* 10. Buffer setting
*/
case '"':
CHECKCLEAROP;
if (isalnum(nchar) || nchar == '.')
{
yankbuffer = nchar;
opnum = Prenum; /* remember count before '"' */
}
else
CLEAROPBEEP;
break;
/*
* 11. Quoting
*/
case 'q':
case 'Q':
case CTRL('Q'):
CHECKCLEAROP;
Quote_block = FALSE;
if (Quote.lnum) /* stop quoting */
{
Quote.lnum = 0;
updateScreen(NOT_VALID); /* delete the inversion */
}
else /* start quoting */
{
Quote = Curpos;
if (c == 'Q') /* linewise */
Quote.col = QUOTELINE;
else if (c == CTRL('Q')) /* blockwise */
Quote_block = TRUE;
updateline(); /* start the inversion */
}
break;
/*
* 12. Suspend
*/
case CTRL('Z'):
CLEAROP;
Quote.lnum = 0; /* stop quoting */
stuffReadbuff(":st!\r"); /* no autowrite */
break;
/*
* The end
*/
case ESC:
if (Quote.lnum)
{
Quote.lnum = 0; /* stop quoting */
updateScreen(NOT_VALID);
}
default: /* not a known command */
CLEAROPBEEP;
break;
} /* end of switch on command character */
/*
* if we didn't start or finish an operator, reset yankbuffer, unless we
* need it later.
*/
if (!finish_op && !operator && strchr("\"DCYSsXx", c) == NULL)
yankbuffer = 0;
/*
* If an operation is pending, handle it...
*/
if ((Quote.lnum || finish_op) && operator != NOP)
{
if (operator != YANK && !Quote.lnum) /* can't redo yank */
{
prep_redo(Prenum, opchars[operator - 1], c, nchar);
if (c == '/' || c == '?') /* was a search */
{
AppendToRedobuff(searchbuff);
AppendToRedobuff(NL_STR);
}
}
if (redo_Quote_busy)
{
startop = Curpos;
Curpos.lnum += redo_Quote_nlines - 1;
switch (redo_Quote_type)
{
case 'Q': Quote.col = QUOTELINE;
break;
case CTRL('Q'):
Quote_block = TRUE;
break;
case 'q':
if (redo_Quote_nlines <= 1)
Curpos.col += redo_Quote_col;
else
Curpos.col = redo_Quote_col;
break;
}
if (redo_Quote_col == 29999)
{
Curswant = 29999;
coladvance(29999);
}
}
else if (Quote.lnum)
startop = Quote;
if (lt(startop, Curpos))
{
endop = Curpos;
Curpos = startop;
}
else
{
endop = startop;
startop = Curpos;
}
nlines = endop.lnum - startop.lnum + 1;
if (Quote.lnum || redo_Quote_busy)
{
if (Quote_block) /* block mode */
{
startvcol = getvcol(&startop, 2);
n = getvcol(&endop, 2);
if (n < startvcol)
startvcol = n;
/* if '$' was used, get endvcol from longest line */
if (Curswant == 29999)
{
Curpos.col = 29999;
endvcol = 0;
for (Curpos.lnum = startop.lnum; Curpos.lnum <= endop.lnum; ++Curpos.lnum)
if ((n = getvcol(&Curpos, 3)) > endvcol)
endvcol = n;
Curpos = startop;
}
else if (redo_Quote_busy)
endvcol = startvcol + redo_Quote_col;
else
{
endvcol = getvcol(&startop, 3);
n = getvcol(&endop, 3);
if (n > endvcol)
endvcol = n;
}
coladvance(startvcol);
}
/*
* prepare to redo quoting: this is based on the size
* of the quoted text
*/
if (operator != YANK) /* can't redo yank */
{
prep_redo(0L, 'q', opchars[operator - 1], NUL);
if (Quote_block)
redo_Quote_type = CTRL('Q');
else if (Quote.col == QUOTELINE)
redo_Quote_type = 'Q';
else
redo_Quote_type = 'q';
if (Curswant == 29999)
redo_Quote_col = 29999;
else if (Quote_block)
redo_Quote_col = endvcol - startvcol;
else if (nlines > 1)
redo_Quote_col = endop.col;
else
redo_Quote_col = endop.col - startop.col;
redo_Quote_nlines = nlines;
}
mincl = TRUE;
if (Quote.col == QUOTELINE)
mtype = MLINE;
else
mtype = MCHAR;
redo_Quote_busy = FALSE;
/*
* Switch quoting off now, so screen updating does
* not show inverted text when the screen is redrawn.
* With YANK and sometimes with COLON there is no screen redraw, so
* it is done here to remove the inverted part.
*/
Quote.lnum = 0;
if (operator == YANK || operator == COLON)
updateScreen(NOT_VALID);
}
set_want_col = 1;
if (!mincl && !equal(startop, endop))
oneless = 1;
else
oneless = 0;
switch (operator)
{
case LSHIFT:
case RSHIFT:
adjust_lnum();
doshift(operator);
break;
case DELETE:
dodelete();
break;
case YANK:
doyank(FALSE);
break;
case CHANGE:
dochange();
break;
case FILTER:
AppendToRedobuff("!\n"); /* strange but necessary */
case INDENT:
case COLON:
adjust_lnum();
sprintf(IObuff, ":%ld,%ld", (long)startop.lnum, (long)endop.lnum);
stuffReadbuff(IObuff);
if (operator != COLON)
stuffReadbuff("!");
if (operator == INDENT)
{
stuffReadbuff(p_ep);
stuffReadbuff("\n");
}
/* docmdline() does the rest */
break;
case TILDE:
case UPPER:
case LOWER:
dotilde();
break;
case FORMAT:
adjust_lnum();
doformat();
break;
default:
CLEAROPBEEP;
}
operator = NOP;
Quote_block = FALSE;
yankbuffer = 0;
}
normal_end:
premsg(-1, NUL);
if (restart_edit && operator == NOP && Quote.lnum == 0 && !command_busy && stuff_empty() && yankbuffer == 0)
startinsert(NUL, FALSE, 1L);
}
int
main(int argc, char **argv)
{
FILE *fp;
FILE *in;
if(argc == 2){
fp = fopen(argv[1], "r");
in = stdin;
} else {
fp = stdin;
in = fopen("/dev/tty", "r");
}
if(!fp || !in)
err(1, "Cannot open files");
signal(SIGINT, finish);
(void) initscr();
(void) keypad(stdscr, TRUE);
(void) nonl();
(void) cbreak();
(void) noecho();
(void) read_file(fp);
v_end = LINES;
(void) repaint();
lastreg = malloc(80 * sizeof(char*));
if(!lastreg)
err(1, "can't lastreg");
for(;;){
int c = getch();
switch(c){
case 'j':
godown();
break;
case 'k':
goup();
break;
case '<':
gostart();
break;
case '>':
goend();
break;
case 'q':
finish(0);
break;
case KEY_NPAGE:
case ' ':
downpage();
break;
case KEY_PPAGE:
case KEY_BACKSPACE:
uppage();
break;
case '/':
dosearch();
break;
case '?':
dobacksearch();
break;
case 12: /* ^L */
repaint();
break;
}
}
}
void
normal()
{
register int c;
long n;
int flag = FALSE;
int flag2 = FALSE;
int type = 0; /* type of operation */
int dir = FORWARD; /* search direction */
int nchar = NUL;
int finish_op;
linenr_t Prenum1;
char_u searchbuff[CMDBUFFSIZE];/* buffer for search string */
FPOS *pos = NULL; /* init for gcc */
register char_u *ptr;
int command_busy = FALSE;
static int didwarn = FALSE; /* warned for broken inversion */
int modified = FALSE; /* changed current buffer */
int ctrl_w = FALSE; /* got CTRL-W command */
/* the visual area is remembered for reselection */
static linenr_t resel_Visual_nlines; /* number of lines */
static int resel_Visual_type = 0; /* type 'v', 'V' or CTRL-V */
static colnr_t resel_Visual_col; /* number of columns or end column */
/* the visual area is remembered for redo */
static linenr_t redo_Visual_nlines; /* number of lines */
static int redo_Visual_type = 0; /* type 'v', 'V' or CTRL-V */
static colnr_t redo_Visual_col; /* number of columns or end column */
static long redo_Visual_Prenum; /* Prenum for operator */
Prenum = 0;
/*
* If there is an operator pending, then the command we take this time
* will terminate it. Finish_op tells us to finish the operation before
* returning this time (unless the operation was cancelled).
*/
finish_op = (operator != NOP);
if (!finish_op && !yankbuffer)
opnum = 0;
if (p_sc && (vpeekc() == NUL || KeyTyped == TRUE))
premsg(NUL, NUL);
State = NORMAL_BUSY;
c = vgetc();
getcount:
/* Pick up any leading digits and compute 'Prenum' */
while ((c >= '1' && c <= '9') || (Prenum != 0 && (c == DEL || c == '0')))
{
if (c == DEL)
Prenum /= 10;
else
Prenum = Prenum * 10 + (c - '0');
if (Prenum < 0) /* got too large! */
Prenum = 999999999;
premsg(ctrl_w ? Ctrl('W') : ' ', NUL);
c = vgetc();
}
/*
* If we got CTRL-W there may be a/another count
*/
if (c == Ctrl('W') && !ctrl_w)
{
ctrl_w = TRUE;
opnum = Prenum; /* remember first count */
Prenum = 0;
State = ONLYKEY; /* no mapping for nchar, but keys */
premsg(c, NUL);
c = vgetc(); /* get next character */
goto getcount; /* jump back */
}
/*
* If we're in the middle of an operator (including after entering a yank
* buffer with ") AND we had a count before the
* operator, then that count overrides the current value of Prenum. What
* this means effectively, is that commands like "3dw" get turned into
* "d3w" which makes things fall into place pretty neatly.
* If you give a count before AND after the operator, they are multiplied.
*/
if (opnum != 0)
{
if (Prenum)
Prenum *= opnum;
else
Prenum = opnum;
opnum = 0;
}
Prenum1 = (Prenum == 0 ? 1 : Prenum); /* Prenum often defaults to 1 */
premsg(c, NUL);
/*
* get an additional character if we need one
* for CTRL-W we already got it when looking for a count
*/
if (ctrl_w)
{
nchar = c;
c = Ctrl('W');
premsg(c, nchar);
}
else if (strchr("@zZtTfF[]mg'`\"", c) || (c == 'q' && !Recording && !Exec_reg) ||
(c == 'r' && !VIsual.lnum))
{
State = NOMAPPING;
nchar = vgetc(); /* no macro mapping for this char */
premsg(c, nchar);
}
if (p_sc)
flushbuf(); /* flush the premsg() characters onto the screen so we can
see them while the command is being executed */
/*
* For commands that don't get another character we can put the State back to
* NORMAL and check for a window size change.
*/
if (STRCHR("z:/?", c) == NULL)
State = NORMAL;
if (nchar == ESC)
{
CLEAROP;
goto normal_end;
}
switch (c)
{
/*
* 0: Macros
*/
case 'q': /* (stop) recording into a named register */
CHECKCLEAROP;
/* command is ignored while executing a register */
if (!Exec_reg && dorecord(nchar) == FAIL)
CLEAROPBEEP;
break;
case '@': /* execute a named buffer */
CHECKCLEAROP;
while (Prenum1--)
{
if (doexecbuf(nchar) == FAIL)
{
CLEAROPBEEP;
break;
}
}
break;
/*
* 1: Screen positioning commands
*/
case Ctrl('D'):
flag = TRUE;
case Ctrl('U'):
CHECKCLEAROP;
if (Prenum)
curwin->w_p_scroll = (Prenum > curwin->w_height) ? curwin->w_height : Prenum;
n = (curwin->w_p_scroll <= curwin->w_height) ? curwin->w_p_scroll : curwin->w_height;
if (flag)
{
curwin->w_topline += n;
if (curwin->w_topline > curbuf->b_ml.ml_line_count)
curwin->w_topline = curbuf->b_ml.ml_line_count;
comp_Botline(curwin); /* compute curwin->w_botline */
(void)onedown(n);
}
else
{
if (n >= curwin->w_cursor.lnum)
n = curwin->w_cursor.lnum - 1;
Prenum1 = curwin->w_cursor.lnum - n;
scrolldown(n);
if (Prenum1 < curwin->w_cursor.lnum)
curwin->w_cursor.lnum = Prenum1;
}
beginline(TRUE);
updateScreen(VALID);
break;
case Ctrl('B'):
case K_SUARROW:
dir = BACKWARD;
case Ctrl('F'):
case K_SDARROW:
CHECKCLEAROP;
(void)onepage(dir, Prenum1);
break;
case Ctrl('E'):
CHECKCLEAROP;
scrollup(Prenum1);
/* We may have moved to another line -- webb */
coladvance(curwin->w_curswant);
updateScreen(VALID);
break;
case Ctrl('Y'):
CHECKCLEAROP;
scrolldown(Prenum1);
/* We may have moved to another line -- webb */
coladvance(curwin->w_curswant);
updateScreen(VALID);
break;
case 'z':
CHECKCLEAROP;
if (isdigit(nchar))
{
/*
* we misuse some variables to be able to call premsg()
*/
operator = c;
opnum = Prenum;
Prenum = nchar - '0';
for (;;)
{
premsg(' ', NUL);
nchar = vgetc();
State = NORMAL;
if (nchar == DEL)
Prenum /= 10;
else if (isdigit(nchar))
Prenum = Prenum * 10 + (nchar - '0');
else if (nchar == CR)
{
win_setheight((int)Prenum);
break;
}
else
{
CLEAROPBEEP;
break;
}
}
operator = NOP;
break;
}
if (Prenum && Prenum != curwin->w_cursor.lnum) /* line number given */
{
setpcmark();
if (Prenum > curbuf->b_ml.ml_line_count)
curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
else
curwin->w_cursor.lnum = Prenum;
}
State = NORMAL; /* for updateScreen() */
switch (nchar)
{
case NL: /* put curwin->w_cursor at top of screen */
case CR:
beginline(TRUE);
case 't':
curwin->w_topline = curwin->w_cursor.lnum;
break;
case '.': /* put curwin->w_cursor in middle of screen */
case 'z':
n = (curwin->w_height + plines(curwin->w_cursor.lnum)) / 2;
goto dozcmd;
case '-': /* put curwin->w_cursor at bottom of screen */
case 'b':
n = curwin->w_height;
/* FALLTHROUGH */
dozcmd:
{
register linenr_t lp = curwin->w_cursor.lnum;
register long l = plines(lp);
do
{
curwin->w_topline = lp;
if (--lp == 0)
break;
l += plines(lp);
} while (l <= n);
}
if (nchar != 'z' && nchar != 'b')
beginline(TRUE);
break;
case Ctrl('S'): /* ignore CTRL-S and CTRL-Q to avoid problems */
case Ctrl('Q'): /* with terminals that use xon/xoff */
break;
default:
CLEAROPBEEP;
}
updateScreen(VALID);
break;
/*
* 2: Control commands
*/
case ':':
if (VIsual.lnum)
goto dooperator;
CHECKCLEAROP;
/*
* translate "count:" into ":.,.+(count - 1)"
*/
if (Prenum)
{
stuffReadbuff((char_u *)".");
if (Prenum > 1)
{
stuffReadbuff((char_u *)",.+");
stuffnumReadbuff((long)Prenum - 1L);
}
}
docmdline(NULL);
modified = TRUE;
break;
case K_HELP:
CHECKCLEAROP;
help();
break;
case Ctrl('L'):
CHECKCLEAROP;
updateScreen(CLEAR);
break;
case Ctrl('G'):
CHECKCLEAROP;
fileinfo(did_cd || Prenum); /* print full name if count given or :cd used */
break;
case K_CCIRCM: /* CTRL-^, short for ":e #" */
CHECKCLEAROPQ;
(void)buflist_getfile((int)Prenum, (linenr_t)0, TRUE);
break;
case 'Z': /* write, if changed, and exit */
CHECKCLEAROPQ;
if (nchar != 'Z')
{
CLEAROPBEEP;
break;
}
stuffReadbuff((char_u *)":x\n");
break;
case Ctrl(']'): /* :ta to current identifier */
CHECKCLEAROPQ;
case '*': /* / to current identifier or string */
case '#': /* ? to current identifier or string */
case 'K': /* run program for current identifier */
{
register int col;
register int i;
/*
* if i == 0: try to find an identifier
* if i == 1: try to find any string
*/
ptr = ml_get(curwin->w_cursor.lnum);
for (i = 0; i < 2; ++i)
{
/*
* skip to start of identifier/string
*/
col = curwin->w_cursor.col;
while (ptr[col] != NUL &&
(i == 0 ? !isidchar(ptr[col]) : iswhite(ptr[col])))
++col;
/*
* Back up to start of identifier/string. This doesn't match the
* real vi but I like it a little better and it shouldn't bother
* anyone.
*/
while (col > 0 && (i == 0 ? isidchar(ptr[col - 1]) :
(!iswhite(ptr[col - 1]) && !isidchar(ptr[col - 1]))))
--col;
/*
* if identifier found or not '*' or '#' command, stop searching
*/
if (isidchar(ptr[col]) || (c != '*' && c != '#'))
break;
}
/*
* did't find an identifier of string
*/
if (ptr[col] == NUL || (!isidchar(ptr[col]) && i == 0))
{
CLEAROPBEEP;
break;
}
if (Prenum)
stuffnumReadbuff(Prenum);
switch (c)
{
case '*':
stuffReadbuff((char_u *)"/");
goto sow;
case '#':
stuffReadbuff((char_u *)"?");
sow: if (i == 0)
stuffReadbuff((char_u *)"\\<");
break;
case 'K':
stuffReadbuff((char_u *)":! ");
stuffReadbuff(p_kp);
stuffReadbuff((char_u *)" ");
break;
default:
stuffReadbuff((char_u *)":ta ");
}
/*
* Now grab the chars in the identifier
*/
while (i == 0 ? isidchar(ptr[col]) :
(ptr[col] != NUL && !iswhite(ptr[col])))
{
stuffcharReadbuff(ptr[col]);
++col;
}
if ((c == '*' || c == '#') && i == 0)
stuffReadbuff((char_u *)"\\>");
stuffReadbuff((char_u *)"\n");
}
break;
case Ctrl('T'): /* backwards in tag stack */
CHECKCLEAROPQ;
dotag((char_u *)"", 2, (int)Prenum1);
break;
/*
* Cursor motions
*/
case 'G':
mtype = MLINE;
setpcmark();
if (Prenum == 0 || Prenum > curbuf->b_ml.ml_line_count)
curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
else
curwin->w_cursor.lnum = Prenum;
beginline(TRUE);
break;
case 'H':
case 'M':
if (c == 'M')
n = (curwin->w_height - curwin->w_empty_rows) / 2;
else
n = Prenum;
mtype = MLINE;
setpcmark();
curwin->w_cursor.lnum = curwin->w_topline;
while (n && onedown((long)1) == OK)
--n;
beginline(TRUE);
break;
case 'L':
mtype = MLINE;
setpcmark();
curwin->w_cursor.lnum = curwin->w_botline - 1;
for (n = Prenum; n && oneup((long)1) == OK; n--)
;
beginline(TRUE);
break;
case 'l':
case K_RARROW:
case ' ':
mtype = MCHAR;
mincl = FALSE;
n = Prenum1;
while (n--)
{
if (oneright() == FAIL)
{
/* space wraps to next line if 'whichwrap' bit 1 set */
/* 'l' wraps to next line if 'whichwrap' bit 2 set */
/* CURS_RIGHT wraps to next line if 'whichwrap' bit 3 set */
if (((c == ' ' && (p_ww & 2)) ||
(c == 'l' && (p_ww & 4)) ||
(c == K_RARROW && (p_ww & 8))) &&
curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count)
{
++curwin->w_cursor.lnum;
curwin->w_cursor.col = 0;
curwin->w_set_curswant = TRUE;
continue;
}
if (operator == NOP)
beep();
else
{
if (lineempty(curwin->w_cursor.lnum))
CLEAROPBEEP;
else
{
mincl = TRUE;
if (n)
beep();
}
}
break;
}
}
break;
case Ctrl('H'):
case 'h':
case K_LARROW:
case DEL:
mtype = MCHAR;
mincl = FALSE;
n = Prenum1;
while (n--)
{
if (oneleft() == FAIL)
{
/* backspace and del wrap to previous line if 'whichwrap'
* bit 0 set */
/* 'h' wraps to previous line if 'whichwrap' bit 2 set */
/* CURS_LEFT wraps to previous line if 'whichwrap' bit 3 set */
if ((((c == Ctrl('H') || c == DEL) && (p_ww & 1)) ||
(c == 'h' && (p_ww & 4)) ||
(c == K_LARROW && (p_ww & 8))) &&
curwin->w_cursor.lnum > 1)
{
--(curwin->w_cursor.lnum);
coladvance(MAXCOL);
curwin->w_set_curswant = TRUE;
continue;
}
else if (operator != DELETE && operator != CHANGE)
beep();
else if (Prenum1 == 1)
CLEAROPBEEP;
break;
}
}
break;
case '-':
flag = TRUE;
/* FALLTHROUGH */
case 'k':
case K_UARROW:
case Ctrl('P'):
mtype = MLINE;
if (oneup(Prenum1) == FAIL)
CLEAROPBEEP;
else if (flag)
beginline(TRUE);
break;
case '+':
case CR:
flag = TRUE;
/* FALLTHROUGH */
case 'j':
case K_DARROW:
case Ctrl('N'):
case NL:
mtype = MLINE;
if (onedown(Prenum1) == FAIL)
CLEAROPBEEP;
else if (flag)
beginline(TRUE);
break;
/*
* This is a strange motion command that helps make operators more
* logical. It is actually implemented, but not documented in the
* real 'vi'. This motion command actually refers to "the current
* line". Commands like "dd" and "yy" are really an alternate form of
* "d_" and "y_". It does accept a count, so "d3_" works to delete 3
* lines.
*/
case '_':
lineop:
mtype = MLINE;
if (onedown((long)(Prenum1 - 1)) == FAIL)
CLEAROPBEEP;
if (operator != YANK) /* 'Y' does not move cursor */
beginline(TRUE);
break;
case '|':
mtype = MCHAR;
mincl = TRUE;
beginline(FALSE);
if (Prenum > 0)
coladvance((colnr_t)(Prenum - 1));
curwin->w_curswant = (colnr_t)(Prenum - 1);
/* keep curswant at the column where we wanted to go, not where
we ended; differs is line is too short */
curwin->w_set_curswant = FALSE;
break;
/*
* Word Motions
*/
case 'B':
type = 1;
/* FALLTHROUGH */
case 'b':
case K_SLARROW:
mtype = MCHAR;
mincl = FALSE;
curwin->w_set_curswant = TRUE;
if (bck_word(Prenum1, type))
CLEAROPBEEP;
break;
case 'E':
type = 1;
/* FALLTHROUGH */
case 'e':
mincl = TRUE;
goto dowrdcmd;
case 'W':
type = 1;
/* FALLTHROUGH */
case 'w':
case K_SRARROW:
mincl = FALSE;
flag = TRUE;
/*
* This is a little strange. To match what the real vi does, we
* effectively map 'cw' to 'ce', and 'cW' to 'cE', provided that we are
* not on a space or a TAB. This seems
* impolite at first, but it's really more what we mean when we say
* 'cw'.
* Another strangeness: When standing on the end of a word "ce" will
* change until the end of the next wordt, but "cw" will change only
* one character! This is done by setting type to 2.
*/
if (operator == CHANGE && (n = gchar_cursor()) != ' ' && n != TAB &&
n != NUL)
{
mincl = TRUE;
flag = FALSE;
flag2 = TRUE;
}
dowrdcmd:
mtype = MCHAR;
curwin->w_set_curswant = TRUE;
if (flag)
n = fwd_word(Prenum1, type, operator != NOP);
else
n = end_word(Prenum1, type, flag2);
if (n)
{
CLEAROPBEEP;
break;
}
#if 0
/*
* If we do a 'dw' for the last word in a line, we only delete the rest
* of the line, not joining the two lines, unless the current line is empty.
*/
if (operator == DELETE && Prenum1 == 1 &&
curbuf->b_startop.lnum != curwin->w_cursor.lnum && !lineempty(startop.lnum))
{
curwin->w_cursor = curbuf->b_startop;
while (oneright() == OK)
;
mincl = TRUE;
}
#endif
break;
case '$':
mtype = MCHAR;
mincl = TRUE;
curwin->w_curswant = MAXCOL; /* so we stay at the end */
if (onedown((long)(Prenum1 - 1)) == FAIL)
{
CLEAROPBEEP;
break;
}
break;
case '^':
flag = TRUE;
/* FALLTHROUGH */
case '0':
mtype = MCHAR;
mincl = FALSE;
beginline(flag);
break;
/*
* 4: Searches
*/
case '?':
case '/':
if (!getcmdline(c, searchbuff))
{
CLEAROP;
break;
}
mtype = MCHAR;
mincl = FALSE;
curwin->w_set_curswant = TRUE;
n = dosearch(c, searchbuff, FALSE, Prenum1, TRUE, TRUE);
if (n == 0)
CLEAROP;
else if (n == 2)
mtype = MLINE;
break;
case 'N':
flag = 1;
case 'n':
mtype = MCHAR;
mincl = FALSE;
curwin->w_set_curswant = TRUE;
if (!dosearch(0, NULL, flag, Prenum1, TRUE, TRUE))
CLEAROP;
break;
/*
* Character searches
*/
case 'T':
dir = BACKWARD;
/* FALLTHROUGH */
case 't':
type = 1;
goto docsearch;
case 'F':
dir = BACKWARD;
/* FALLTHROUGH */
case 'f':
docsearch:
mtype = MCHAR;
if (dir == BACKWARD)
mincl = FALSE;
else
mincl = TRUE;
curwin->w_set_curswant = TRUE;
if (!searchc(nchar, dir, type, Prenum1))
CLEAROPBEEP;
break;
case ',':
flag = 1;
/* FALLTHROUGH */
case ';':
dir = flag;
goto docsearch; /* nchar == NUL, thus repeat previous search */
/*
* section or C function searches
*/
case '[':
dir = BACKWARD;
/* FALLTHROUGH */
case ']':
mtype = MCHAR;
mincl = FALSE;
/*
* "[f" or "]f" : Edit file under the cursor (same as "gf")
*/
if ((c == ']' || c == '[') && nchar == 'f')
goto gotofile;
/*
* "[{", "[(", "]}" or "])": go to Nth unclosed '{', '(', '}' or ')'
*/
if ((c == '[' && (nchar == '{' || nchar == '(')) ||
((c == ']' && (nchar == '}' || nchar == ')'))))
{
FPOS old_pos;
old_pos = curwin->w_cursor;
while (Prenum1--)
{
if ((pos = showmatch(nchar)) == NULL)
{
CLEAROPBEEP;
break;
}
curwin->w_cursor = *pos;
}
curwin->w_cursor = old_pos;
if (pos != NULL)
{
setpcmark();
curwin->w_cursor = *pos;
curwin->w_set_curswant = TRUE;
}
break;
}
/*
* "[[", "[]", "]]" and "][": move to start or end of function
*/
if (nchar == '[' || nchar == ']')
{
if (nchar == c) /* "]]" or "[[" */
flag = '{';
else
flag = '}'; /* "][" or "[]" */
curwin->w_set_curswant = TRUE;
/*
* Imitate strange vi behaviour: When using "]]" with an operator we
* also stop at '}'.
*/
if (!findpar(dir, Prenum1, flag,
(operator != NOP && dir == FORWARD && flag == '{')))
CLEAROPBEEP;
break;
}
/*
* "[p" and "]p": put with indent adjustment
*/
if (nchar == 'p')
{
doput((c == ']') ? FORWARD : BACKWARD, Prenum1, TRUE);
modified = TRUE;
break;
}
/*
* end of '[' and ']': not a valid nchar
*/
CLEAROPBEEP;
break;
case '%':
mincl = TRUE;
if (Prenum) /* {cnt}% : goto {cnt} percentage in file */
{
if (Prenum > 100)
CLEAROPBEEP;
else
{
mtype = MLINE;
setpcmark();
/* round up, so CTRL-G will give same value */
curwin->w_cursor.lnum = (curbuf->b_ml.ml_line_count * Prenum + 99) / 100;
beginline(TRUE);
}
}
else /* % : go to matching paren */
{
mtype = MCHAR;
if ((pos = showmatch(NUL)) == NULL)
CLEAROPBEEP;
else
{
setpcmark();
curwin->w_cursor = *pos;
curwin->w_set_curswant = TRUE;
}
}
break;
case '(':
dir = BACKWARD;
/* FALLTHROUGH */
case ')':
mtype = MCHAR;
if (c == ')')
mincl = FALSE;
else
mincl = TRUE;
curwin->w_set_curswant = TRUE;
if (!findsent(dir, Prenum1))
CLEAROPBEEP;
break;
case '{':
dir = BACKWARD;
/* FALLTHROUGH */
case '}':
mtype = MCHAR;
mincl = FALSE;
curwin->w_set_curswant = TRUE;
if (!findpar(dir, Prenum1, NUL, FALSE))
CLEAROPBEEP;
break;
/*
* 5: Edits
*/
case '.':
CHECKCLEAROPQ;
if (start_redo(Prenum) == FAIL)
CLEAROPBEEP;
modified = TRUE;
break;
case 'u':
if (VIsual.lnum)
goto dooperator;
case K_UNDO:
CHECKCLEAROPQ;
u_undo((int)Prenum1);
curwin->w_set_curswant = TRUE;
modified = TRUE;
break;
case Ctrl('R'):
CHECKCLEAROPQ;
u_redo((int)Prenum1);
curwin->w_set_curswant = TRUE;
modified = TRUE;
break;
case 'U':
if (VIsual.lnum)
goto dooperator;
CHECKCLEAROPQ;
u_undoline();
curwin->w_set_curswant = TRUE;
modified = TRUE;
break;
case 'r':
if (VIsual.lnum)
{
c = 'c';
goto dooperator;
}
CHECKCLEAROPQ;
ptr = ml_get_cursor();
if (STRLEN(ptr) < (unsigned)Prenum1) /* not enough characters to replace */
{
CLEAROPBEEP;
break;
}
/*
* Replacing with a line break or tab is done by edit(), because it
* is complicated.
* Other characters are done below to avoid problems with things like
* CTRL-V 048 (for edit() this would be R CTRL-V 0 ESC).
*/
if (nchar == '\r' || nchar == '\n' || nchar == '\t')
{
prep_redo(Prenum1, 'r', nchar, NUL);
stuffnumReadbuff(Prenum1);
stuffcharReadbuff('R');
stuffcharReadbuff(nchar);
stuffcharReadbuff(ESC);
break;
}
if (nchar == Ctrl('V')) /* get another character */
{
c = Ctrl('V');
nchar = get_literal(&type);
if (type) /* typeahead */
stuffcharReadbuff(type);
}
else
c = NUL;
prep_redo(Prenum1, 'r', c, nchar);
if (!u_save_cursor()) /* save line for undo */
break;
/*
* Get ptr again, because u_save will have released the line.
* At the same time we let know that the line will be changed.
*/
ptr = ml_get_buf(curbuf, curwin->w_cursor.lnum, TRUE) + curwin->w_cursor.col;
curwin->w_cursor.col += Prenum1 - 1;
while (Prenum1--) /* replace the characters */
*ptr++ = nchar;
curwin->w_set_curswant = TRUE;
CHANGED;
updateline();
modified = TRUE;
break;
case 'J':
if (VIsual.lnum) /* join the visual lines */
{
if (curwin->w_cursor.lnum > VIsual.lnum)
{
Prenum = curwin->w_cursor.lnum - VIsual.lnum + 1;
curwin->w_cursor.lnum = VIsual.lnum;
}
else
Prenum = VIsual.lnum - curwin->w_cursor.lnum + 1;
VIsual.lnum = 0;
}
CHECKCLEAROP;
if (Prenum <= 1)
Prenum = 2; /* default for join is two lines! */
if (curwin->w_cursor.lnum + Prenum - 1 > curbuf->b_ml.ml_line_count) /* beyond last line */
{
CLEAROPBEEP;
break;
}
prep_redo(Prenum, 'J', NUL, NUL);
dodojoin(Prenum, TRUE, TRUE);
modified = TRUE;
break;
case 'P':
dir = BACKWARD;
/* FALLTHROUGH */
case 'p':
CHECKCLEAROPQ;
prep_redo(Prenum, c, NUL, NUL);
doput(dir, Prenum1, FALSE);
modified = TRUE;
break;
case Ctrl('A'): /* add to number */
case Ctrl('X'): /* subtract from number */
CHECKCLEAROPQ;
if (doaddsub((int)c, Prenum1) == OK)
prep_redo(Prenum1, c, NUL, NUL);
modified = TRUE;
break;
/*
* 6: Inserts
*/
case 'A':
curwin->w_set_curswant = TRUE;
while (oneright() == OK)
;
/* FALLTHROUGH */
case 'a':
CHECKCLEAROPQ;
/* Works just like an 'i'nsert on the next character. */
if (u_save_cursor())
{
if (!lineempty(curwin->w_cursor.lnum))
inc_cursor();
startinsert(c, FALSE, Prenum1);
modified = TRUE;
command_busy = TRUE;
}
break;
case 'I':
beginline(TRUE);
/* FALLTHROUGH */
case 'i':
CHECKCLEAROPQ;
if (u_save_cursor())
{
startinsert(c, FALSE, Prenum1);
modified = TRUE;
command_busy = TRUE;
}
break;
case 'o':
if (VIsual.lnum) /* switch start and end of visual */
{
Prenum = VIsual.lnum;
VIsual.lnum = curwin->w_cursor.lnum;
curwin->w_cursor.lnum = Prenum;
if (VIsual.col != VISUALLINE)
{
n = VIsual.col;
VIsual.col = curwin->w_cursor.col;
curwin->w_cursor.col = (int)n;
curwin->w_set_curswant = TRUE;
}
break;
}
CHECKCLEAROP;
if (u_save(curwin->w_cursor.lnum, (linenr_t)(curwin->w_cursor.lnum + 1)) &&
Opencmd(FORWARD, TRUE, TRUE))
{
startinsert('o', TRUE, Prenum1);
modified = TRUE;
command_busy = TRUE;
}
break;
case 'O':
CHECKCLEAROPQ;
if (u_save((linenr_t)(curwin->w_cursor.lnum - 1), curwin->w_cursor.lnum) && Opencmd(BACKWARD, TRUE, TRUE))
{
startinsert('O', TRUE, Prenum1);
modified = TRUE;
command_busy = TRUE;
}
break;
case 'R':
if (VIsual.lnum)
{
c = 'c';
VIsual.col = VISUALLINE;
goto dooperator;
}
CHECKCLEAROPQ;
if (u_save_cursor())
{
startinsert('R', FALSE, Prenum1);
modified = TRUE;
command_busy = TRUE;
}
break;
/*
* 7: Operators
*/
case '~': /* swap case */
/*
* if tilde is not an operator and Visual is off: swap case
* of a single character
*/
if (!p_to && !VIsual.lnum)
{
CHECKCLEAROPQ;
if (lineempty(curwin->w_cursor.lnum))
{
CLEAROPBEEP;
break;
}
prep_redo(Prenum, '~', NUL, NUL);
if (!u_save_cursor())
break;
for (; Prenum1 > 0; --Prenum1)
{
if (gchar_cursor() == NUL)
break;
swapchar(&curwin->w_cursor);
inc_cursor();
}
curwin->w_set_curswant = TRUE;
CHANGED;
updateline();
modified = TRUE;
break;
}
/*FALLTHROUGH*/
case 'd':
case 'c':
case 'y':
case '>':
case '<':
case '!':
case '=':
case 'Q':
dooperator:
n = STRCHR(opchars, c) - opchars + 1;
if (n == operator) /* double operator works on lines */
goto lineop;
CHECKCLEAROP;
if (Prenum != 0)
opnum = Prenum;
curbuf->b_startop = curwin->w_cursor;
operator = (int)n;
break;
/*
* 8: Abbreviations
*/
/* when Visual the next commands are operators */
case 'S':
case 'Y':
case 'D':
case 'C':
case 'x':
case 'X':
case 's':
if (VIsual.lnum)
{
static char_u trans[] = "ScYyDdCcxdXdsc";
if (isupper(c) && !Visual_block) /* uppercase means linewise */
VIsual.col = VISUALLINE;
c = *(STRCHR(trans, c) + 1);
goto dooperator;
}
case '&':
CHECKCLEAROPQ;
if (Prenum)
stuffnumReadbuff(Prenum);
if (c == 'Y' && p_ye)
c = 'Z';
{
static char_u *(ar[9]) = {(char_u *)"dl", (char_u *)"dh", (char_u *)"d$", (char_u *)"c$", (char_u *)"cl", (char_u *)"cc", (char_u *)"yy", (char_u *)"y$", (char_u *)":s\r"};
static char_u *str = (char_u *)"xXDCsSYZ&";
stuffReadbuff(ar[(int)(STRCHR(str, c) - str)]);
}
break;
/*
* 9: Marks
*/
case 'm':
CHECKCLEAROP;
if (setmark(nchar) == FAIL)
CLEAROPBEEP;
break;
case '\'':
flag = TRUE;
/* FALLTHROUGH */
case '`':
pos = getmark(nchar, (operator == NOP));
if (pos == (FPOS *)-1) /* jumped to other file */
{
if (flag)
beginline(TRUE);
break;
}
if (pos != NULL)
setpcmark();
cursormark:
if (pos == NULL || pos->lnum == 0)
CLEAROPBEEP;
else
{
curwin->w_cursor = *pos;
if (flag)
beginline(TRUE);
}
mtype = flag ? MLINE : MCHAR;
mincl = FALSE; /* ignored if not MCHAR */
curwin->w_set_curswant = TRUE;
break;
case Ctrl('O'): /* goto older pcmark */
Prenum1 = -Prenum1;
/* FALLTHROUGH */
case Ctrl('I'): /* goto newer pcmark */
CHECKCLEAROPQ;
pos = movemark((int)Prenum1);
if (pos == (FPOS *)-1) /* jump to other file */
{
curwin->w_set_curswant = TRUE;
break;
}
goto cursormark;
/*
* 10. Buffer setting
*/
case '"':
CHECKCLEAROP;
if (nchar != NUL && is_yank_buffer(nchar, FALSE))
{
yankbuffer = nchar;
opnum = Prenum; /* remember count before '"' */
}
else
CLEAROPBEEP;
break;
/*
* 11. Visual
*/
case 'v':
case 'V':
case Ctrl('V'):
CHECKCLEAROP;
Visual_block = FALSE;
/* stop Visual */
if (VIsual.lnum)
{
VIsual.lnum = 0;
updateScreen(NOT_VALID); /* delete the inversion */
}
/* start Visual */
else
{
if (!didwarn && set_highlight('v') == FAIL)/* cannot highlight */
{
EMSG("Warning: terminal cannot highlight");
didwarn = TRUE;
}
if (Prenum) /* use previously selected part */
{
if (!resel_Visual_type) /* there is none */
{
beep();
break;
}
VIsual = curwin->w_cursor;
if (resel_Visual_nlines > 1)
curwin->w_cursor.lnum += resel_Visual_nlines * Prenum - 1;
switch (resel_Visual_type)
{
case 'V': VIsual.col = VISUALLINE;
break;
case Ctrl('V'):
Visual_block = TRUE;
break;
case 'v':
if (resel_Visual_nlines <= 1)
curwin->w_cursor.col += resel_Visual_col * Prenum - 1;
else
curwin->w_cursor.col = resel_Visual_col;
break;
}
if (resel_Visual_col == MAXCOL)
{
curwin->w_curswant = MAXCOL;
coladvance(MAXCOL);
}
else if (Visual_block)
coladvance((colnr_t)(curwin->w_virtcol + resel_Visual_col * Prenum - 1));
curs_columns(TRUE); /* recompute w_virtcol */
updateScreen(NOT_VALID); /* show the inversion */
}
else
{
VIsual = curwin->w_cursor;
if (c == 'V') /* linewise */
VIsual.col = VISUALLINE;
else if (c == Ctrl('V')) /* blockwise */
Visual_block = TRUE;
updateline(); /* start the inversion */
}
}
break;
/*
* 12. Suspend
*/
case Ctrl('Z'):
CLEAROP;
VIsual.lnum = 0; /* stop Visual */
stuffReadbuff((char_u *)":st\r"); /* with autowrite */
break;
/*
* 13. Window commands
*/
case Ctrl('W'):
CHECKCLEAROP;
do_window(nchar, Prenum); /* everything is in window.c */
break;
/*
* 14. extended commands (starting with 'g')
*/
case 'g':
switch (nchar)
{
/*
* "gf": goto file, edit file under cursor
* "]f" and "[f": can also be used.
*/
case 'f':
gotofile:
ptr = file_name_at_cursor();
/* do autowrite if necessary */
if (curbuf->b_changed && curbuf->b_nwindows <= 1 && !p_hid)
autowrite(curbuf);
if (ptr != NULL)
{
setpcmark();
stuffReadbuff((char_u *) ":e ");
stuffReadbuff(ptr);
stuffReadbuff((char_u *) "\n");
free(ptr);
}
else
CLEAROPBEEP;
break;
/*
* "gs": goto sleep
*/
case 's': while (Prenum1-- && !got_int)
{
sleep(1);
breakcheck();
}
break;
default: CLEAROPBEEP;
break;
}
break;
/*
* The end
*/
case ESC:
if (VIsual.lnum)
{
VIsual.lnum = 0; /* stop Visual */
updateScreen(NOT_VALID);
CLEAROP; /* don't beep */
break;
}
/* Don't drop through and beep if we are canceling a command: */
else if (operator != NOP || opnum || Prenum || yankbuffer)
{
CLEAROP; /* don't beep */
break;
}
/* FALLTHROUGH */
default: /* not a known command */
CLEAROPBEEP;
break;
} /* end of switch on command character */
/*
* if we didn't start or finish an operator, reset yankbuffer, unless we
* need it later.
*/
if (!finish_op && !operator && strchr("\"DCYSsXx.", c) == NULL)
yankbuffer = 0;
/*
* If an operation is pending, handle it...
*/
if ((VIsual.lnum || finish_op) && operator != NOP)
{
if (operator != YANK && !VIsual.lnum) /* can't redo yank */
{
prep_redo(Prenum, opchars[operator - 1], c, nchar);
if (c == '/' || c == '?') /* was a search */
{
AppendToRedobuff(searchbuff);
AppendToRedobuff(NL_STR);
}
}
if (redo_Visual_busy)
{
curbuf->b_startop = curwin->w_cursor;
curwin->w_cursor.lnum += redo_Visual_nlines - 1;
switch (redo_Visual_type)
{
case 'V': VIsual.col = VISUALLINE;
break;
case Ctrl('V'):
Visual_block = TRUE;
break;
case 'v':
if (redo_Visual_nlines <= 1)
curwin->w_cursor.col += redo_Visual_col - 1;
else
curwin->w_cursor.col = redo_Visual_col;
break;
}
if (redo_Visual_col == MAXCOL)
{
curwin->w_curswant = MAXCOL;
coladvance(MAXCOL);
}
Prenum = redo_Visual_Prenum;
if (Prenum == 0)
Prenum1 = 1L;
else
Prenum1 = Prenum;
}
else if (VIsual.lnum)
curbuf->b_startop = VIsual;
if (lt(curbuf->b_startop, curwin->w_cursor))
{
curbuf->b_endop = curwin->w_cursor;
curwin->w_cursor = curbuf->b_startop;
}
else
{
curbuf->b_endop = curbuf->b_startop;
curbuf->b_startop = curwin->w_cursor;
}
nlines = curbuf->b_endop.lnum - curbuf->b_startop.lnum + 1;
if (VIsual.lnum || redo_Visual_busy)
{
if (Visual_block) /* block mode */
{
startvcol = getvcol(curwin, &(curbuf->b_startop), 2);
n = getvcol(curwin, &(curbuf->b_endop), 2);
if (n < startvcol)
startvcol = (colnr_t)n;
/* if '$' was used, get endvcol from longest line */
if (curwin->w_curswant == MAXCOL)
{
curwin->w_cursor.col = MAXCOL;
endvcol = 0;
for (curwin->w_cursor.lnum = curbuf->b_startop.lnum; curwin->w_cursor.lnum <= curbuf->b_endop.lnum; ++curwin->w_cursor.lnum)
if ((n = getvcol(curwin, &curwin->w_cursor, 3)) > endvcol)
endvcol = (colnr_t)n;
curwin->w_cursor = curbuf->b_startop;
}
else if (redo_Visual_busy)
endvcol = startvcol + redo_Visual_col - 1;
else
{
endvcol = getvcol(curwin, &(curbuf->b_startop), 3);
n = getvcol(curwin, &(curbuf->b_endop), 3);
if (n > endvcol)
endvcol = (colnr_t)n;
}
coladvance(startvcol);
}
/*
* prepare to reselect and redo Visual: this is based on the size
* of the Visual text
*/
if (Visual_block)
resel_Visual_type = Ctrl('V');
else if (VIsual.col == VISUALLINE)
resel_Visual_type = 'V';
else
resel_Visual_type = 'v';
if (curwin->w_curswant == MAXCOL)
resel_Visual_col = MAXCOL;
else if (Visual_block)
resel_Visual_col = endvcol - startvcol + 1;
else if (nlines > 1)
resel_Visual_col = curbuf->b_endop.col;
else
resel_Visual_col = curbuf->b_endop.col - curbuf->b_startop.col + 1;
resel_Visual_nlines = nlines;
if (operator != YANK && operator != COLON) /* can't redo yank and : */
{
prep_redo(0L, 'v', opchars[operator - 1], NUL);
redo_Visual_type = resel_Visual_type;
redo_Visual_col = resel_Visual_col;
redo_Visual_nlines = resel_Visual_nlines;
redo_Visual_Prenum = Prenum;
}
/*
* Mincl defaults to TRUE.
* If endop is on a NUL (empty line) mincl becomes FALSE
* This makes "d}P" and "v}dP" work the same.
*/
mincl = TRUE;
if (VIsual.col == VISUALLINE)
mtype = MLINE;
else
{
mtype = MCHAR;
if (*ml_get_pos(&(curbuf->b_endop)) == NUL)
mincl = FALSE;
}
redo_Visual_busy = FALSE;
/*
* Switch Visual off now, so screen updating does
* not show inverted text when the screen is redrawn.
* With YANK and sometimes with COLON and FILTER there is no screen
* redraw, so it is done here to remove the inverted part.
*/
VIsual.lnum = 0;
if (operator == YANK || operator == COLON || operator == FILTER)
updateScreen(NOT_VALID);
}
else if (operator == LSHIFT || operator == RSHIFT)
Prenum1 = 1L; /* if not visual mode: shift one indent */
curwin->w_set_curswant = 1;
/* no_op is set when start and end are the same */
no_op = (mtype == MCHAR && !mincl && equal(curbuf->b_startop, curbuf->b_endop));
/*
* If the end of an operator is in column one while mtype is MCHAR and mincl
* is FALSE, we put endop after the last character in the previous line.
* If startop is on or before the first non-blank in the line, the operator
* becomes linewise (strange, but that's the way vi does it).
*/
if (mtype == MCHAR && mincl == FALSE && curbuf->b_endop.col == 0 && nlines > 1)
{
--nlines;
--curbuf->b_endop.lnum;
if (inindent())
mtype = MLINE;
else
{
curbuf->b_endop.col = STRLEN(ml_get(curbuf->b_endop.lnum));
if (curbuf->b_endop.col)
{
--curbuf->b_endop.col;
mincl = TRUE;
}
}
}
switch (operator)
{
case LSHIFT:
case RSHIFT:
doshift(operator, TRUE, (int)Prenum1);
modified = TRUE;
break;
case DELETE:
if (!no_op)
{
dodelete();
modified = TRUE;
}
break;
case YANK:
if (!no_op)
(void)doyank(FALSE);
break;
case CHANGE:
dochange();
modified = TRUE;
command_busy = TRUE;
break;
case FILTER:
bangredo = TRUE; /* dobang() will put cmd in redo buffer */
case INDENT:
case COLON:
dofilter:
sprintf((char *)IObuff, ":%ld,%ld", (long)curbuf->b_startop.lnum, (long)curbuf->b_endop.lnum);
stuffReadbuff(IObuff);
if (operator != COLON)
stuffReadbuff((char_u *)"!");
if (operator == INDENT)
{
stuffReadbuff(p_ep);
stuffReadbuff((char_u *)"\n");
}
else if (operator == FORMAT)
{
stuffReadbuff(p_fp);
stuffReadbuff((char_u *)"\n");
}
/* docmdline() does the rest */
break;
case TILDE:
case UPPER:
case LOWER:
if (!no_op)
{
dotilde();
modified = TRUE;
}
break;
case FORMAT:
if (*p_fp != NUL)
goto dofilter; /* use external command */
doformat(); /* use internal function */
modified = TRUE;
break;
default:
CLEAROPBEEP;
}
operator = NOP;
Visual_block = FALSE;
yankbuffer = 0;
}
normal_end:
premsg(-1, NUL);
if (restart_edit && operator == NOP && VIsual.lnum == 0 && !command_busy && stuff_empty() && yankbuffer == 0)
{
startinsert(restart_edit, FALSE, 1L);
modified = TRUE;
}
checkpcmark(); /* check if we moved since setting pcmark */
/*
* TEMPORARY: update the other windows for the current buffer if modified
*/
if (modified)
{
WIN *wp;
for (wp = firstwin; wp; wp = wp->w_next)
if (wp != curwin && wp->w_buffer == curbuf)
{
cursor_off();
wp->w_redr_type = NOT_VALID;
win_update(wp);
}
}
}