pico/random.c

   1 #if     !defined(lint) && !defined(DOS)
   2 static char rcsid[] = "$Id: random.c 769 2007-10-24 00:15:40Z hubert@u.washington.edu $";
   3 #endif
   4
   5 /*
   6  * ========================================================================
   7  * Copyright 2006-2007 University of Washington
   8  * Copyright 2013-2017 Eduardo Chappa
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *     http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * ========================================================================
  17  */
  18
  19 /*
  20  * Program:     Random routines
  21  *
  22  * This file contains the command processing functions for a number of random
  23  * commands. There is no functional grouping here, for sure.
  24  */
  25
  26 #include        "headers.h"
  27
  28 #include "osdep/terminal.h"
  29
  30 int     worthit(int *);
  31
  32 int     tabsize;                        /* Tab size (0: use real tabs)  */
  33
  34
  35 /*
  36  * Display the current position of the cursor, in origin 1 X-Y coordinates,
  37  * the character that is under the cursor (in octal), and the fraction of the
  38  * text that is before the cursor. The displayed column is not the current
  39  * column, but the column that would be used on an infinite width display.
  40  * Normally this is bound to "C-X =".
  41  */
  42 int
  43 showcpos(int f, int n)
  44 {
  45     register LINE   *clp;
  46     register long   nch;
  47     register int    cbo;
  48     register long   nbc;
  49     register int    lines;
  50     register int    thisline;
  51     char     buffer[80];
  52
  53     clp = lforw(curbp->b_linep);            /* Grovel the data.     */
  54     cbo = 0;
  55     nch = 0L;
  56     lines = 0;
  57     for (;;) {
  58         if (clp==curwp->w_dotp && cbo==curwp->w_doto) {
  59             thisline = lines;
  60             nbc = nch;
  61         }
  62         if (cbo == llength(clp)) {
  63             if (clp == curbp->b_linep)
  64               break;
  65             clp = lforw(clp);
  66             cbo = 0;
  67             lines++;
  68         } else
  69           ++cbo;
  70         ++nch;
  71     }
  72
  73     snprintf(buffer,sizeof(buffer),"line %d of %d (%d%%%%), character %ld of %ld (%d%%%%)",
  74             thisline+1, lines+1, (int)((100L*(thisline+1))/(lines+1)),
  75             nbc, nch, (nch) ? (int)((100L*nbc)/nch) : 0);
  76
  77     emlwrite(buffer, NULL);
  78     return (TRUE);
  79 }
  80
  81
  82 /*
  83  * Return current column.  Stop at first non-blank given TRUE argument.
  84  */
  85 int
  86 getccol(int bflg)
  87 {
  88     UCS c;
  89     int i, col;
  90
  91     col = 0;
  92     for (i=0; i<curwp->w_doto; ++i) {
  93         c = lgetc(curwp->w_dotp, i).c;
  94         if (c!=' ' && c!='\t' && bflg)
  95           break;
  96
  97         if (c == '\t'){
  98             col |= 0x07;
  99             ++col;
 100         }
 101         else if (ISCONTROL(c)){
 102             col += 2;
 103         }
 104         else{
 105             int ww;
 106
 107             ww = wcellwidth(c);
 108             col += (ww >= 0 ? ww : 1);
 109         }
 110     }
 111
 112     return(col);
 113 }
 114
 115
 116
 117 /*
 118  * Set tab size if given non-default argument (n <> 1).  Otherwise, insert a
 119  * tab into file.  If given argument, n, of zero, change to true tabs.
 120  * If n > 1, simulate tab stop every n-characters using spaces. This has to be
 121  * done in this slightly funny way because the tab (in ASCII) has been turned
 122  * into "C-I" (in 10 bit code) already. Bound to "C-I".
 123  */
 124 int
 125 tab(int f, int n)
 126 {
 127     if (n < 0)
 128       return (FALSE);
 129
 130     if (n == 0 || n > 1) {
 131         tabsize = n;
 132         return(TRUE);
 133     }
 134
 135     if (! tabsize)
 136       return(linsert(1, '\t'));
 137
 138     return(linsert(tabsize - (getccol(FALSE) % tabsize), ' '));
 139 }
 140
 141
 142 /*
 143  * Insert a newline. Bound to "C-M".
 144  */
 145 int
 146 newline(int f, int n)
 147 {
 148     register int    s;
 149
 150     if (curbp->b_mode&MDVIEW)   /* don't allow this command if  */
 151       return(rdonly()); /* we are in read only mode     */
 152
 153     if (n < 0)
 154       return (FALSE);
 155
 156     if(TERM_OPTIMIZE && (curwp->w_dotp != curwp->w_bufp->b_linep)){
 157         int l;
 158
 159         if(worthit(&l)){
 160             if(curwp->w_doto != 0)
 161               l++;
 162             scrolldown(curwp, l, n);
 163         }
 164     }
 165
 166     /* if we are in C mode and this is a default <NL> */
 167     /* pico's never in C mode */
 168
 169     if(Pmaster && Pmaster->allow_flowed_text && curwp->w_doto
 170        && ucs4_isspace(lgetc(curwp->w_dotp, curwp->w_doto - 1).c)
 171        && !(curwp->w_doto == 3
 172             && lgetc(curwp->w_dotp, 0).c == '-'
 173             && lgetc(curwp->w_dotp, 1).c == '-'
 174             && lgetc(curwp->w_dotp, 2).c == ' ')){
 175         /*
 176          * flowed mode, make the newline a hard one by
 177          * stripping trailing space.
 178          */
 179         int i, dellen;
 180         for(i = curwp->w_doto - 1;
 181             i && ucs4_isspace(lgetc(curwp->w_dotp, i - 1).c);
 182             i--);
 183         dellen = curwp->w_doto - i;
 184         curwp->w_doto = i;
 185         ldelete(dellen, NULL);
 186     }
 187     /* insert some lines */
 188     while (n--) {
 189         if ((s=lnewline()) != TRUE)
 190           return (s);
 191     }
 192     return (TRUE);
 193 }
 194
 195
 196
 197 /*
 198  * Delete forward. This is real easy, because the basic delete routine does
 199  * all of the work. Watches for negative arguments, and does the right thing.
 200  * If any argument is present, it kills rather than deletes, to prevent loss
 201  * of text if typed with a big argument. Normally bound to "C-D".
 202  */
 203 int
 204 forwdel(int f, int n)
 205 {
 206     if (curbp->b_mode&MDVIEW)   /* don't allow this command if  */
 207       return(rdonly()); /* we are in read only mode     */
 208
 209     if (n < 0)
 210       return (backdel(f, -n));
 211
 212     if(TERM_OPTIMIZE && (curwp->w_dotp != curwp->w_bufp->b_linep)){
 213         int l;
 214
 215         if(worthit(&l) && curwp->w_doto == llength(curwp->w_dotp))
 216           scrollup(curwp, l+1, 1);
 217     }
 218
 219     if (f != FALSE) {                       /* Really a kill.       */
 220         if ((lastflag&CFKILL) == 0)
 221           kdelete();
 222         thisflag |= CFKILL;
 223     }
 224
 225     return (ldelete((long) n, f ? kinsert : NULL));
 226 }
 227
 228
 229
 230 /*
 231  * Delete backwards. This is quite easy too, because it's all done with other
 232  * functions. Just move the cursor back, and delete forwards. Like delete
 233  * forward, this actually does a kill if presented with an argument. Bound to
 234  * both "RUBOUT" and "C-H".
 235  */
 236 int
 237 backdel(int f, int n)
 238 {
 239     register int    s;
 240
 241     if (curbp->b_mode&MDVIEW)   /* don't allow this command if  */
 242       return(rdonly()); /* we are in read only mode     */
 243
 244     if (n < 0)
 245       return (forwdel(f, -n));
 246
 247     if(TERM_OPTIMIZE && curwp->w_dotp != curwp->w_bufp->b_linep){
 248         int l;
 249
 250         if(worthit(&l) && curwp->w_doto == 0 &&
 251            lback(curwp->w_dotp) != curwp->w_bufp->b_linep){
 252             if(l == curwp->w_toprow)
 253               scrollup(curwp, l+1, 1);
 254             else if(llength(lback(curwp->w_dotp)) == 0)
 255               scrollup(curwp, l-1, 1);
 256             else
 257               scrollup(curwp, l, 1);
 258         }
 259     }
 260
 261     if (f != FALSE) {                       /* Really a kill.       */
 262         if ((lastflag&CFKILL) == 0)
 263           kdelete();
 264
 265         thisflag |= CFKILL;
 266     }
 267
 268     if ((s=backchar(f, n)) == TRUE)
 269       s = ldelete((long) n, f ? kinsert : NULL);
 270
 271     return (s);
 272 }
 273
 274
 275
 276 /*
 277  * killtext - delete the line that the cursor is currently in.
 278  *            a greatly pared down version of its former self.
 279  */
 280 int
 281 killtext(int f, int n)
 282 {
 283     register int chunk;
 284     int          opt_scroll = 0;
 285
 286     if (curbp->b_mode&MDVIEW)           /* don't allow this command if  */
 287       return(rdonly());                 /* we are in read only mode     */
 288
 289     if ((lastflag&CFKILL) == 0)         /* Clear kill buffer if */
 290       kdelete();                        /* last wasn't a kill.  */
 291
 292     if(gmode & MDDTKILL){               /*  */
 293         if((chunk = llength(curwp->w_dotp) - curwp->w_doto) == 0){
 294             chunk = 1;
 295             if(TERM_OPTIMIZE)
 296               opt_scroll = 1;
 297         }
 298     }
 299     else{
 300         gotobol(FALSE, 1);              /* wack from bol past newline */
 301         chunk = llength(curwp->w_dotp) + 1;
 302         if(TERM_OPTIMIZE)
 303           opt_scroll = 1;
 304     }
 305
 306     /* optimize what motion we can */
 307     if(opt_scroll && (curwp->w_dotp != curwp->w_bufp->b_linep)){
 308         int l;
 309
 310         if(worthit(&l))
 311           scrollup(curwp, l, 1);
 312     }
 313
 314     thisflag |= CFKILL;
 315     return(ldelete((long) chunk, kinsert));
 316 }
 317
 318
 319 /*
 320  * Yank text back from the kill buffer. This is really easy. All of the work
 321  * is done by the standard insert routines. All you do is run the loop, and
 322  * check for errors. Bound to "C-Y".
 323  */
 324 int
 325 yank(int f, int n)
 326 {
 327     int    c, i;
 328     REGION region, *added_region;
 329     LINE  *dotp;
 330
 331     if (curbp->b_mode&MDVIEW)   /* don't allow this command if  */
 332       return(rdonly()); /* we are in read only mode     */
 333
 334     if (n < 0)
 335       return (FALSE);
 336
 337     if(TERM_OPTIMIZE && (curwp->w_dotp != curwp->w_bufp->b_linep)){
 338         int l;
 339
 340         if(worthit(&l) && !(lastflag&CFFILL)){
 341             register int  t = 0;
 342             register int  i = 0;
 343             register int  ch;
 344
 345             while((ch=fremove(i++)) >= 0)
 346               if(ch == '\n')
 347                 t++;
 348             if(t+l < curwp->w_toprow+curwp->w_ntrows)
 349               scrolldown(curwp, l, t);
 350         }
 351     }
 352
 353     if(lastflag & CFFILL){              /* if last command was fillpara() */
 354         if(lastflag & CFFLBF){
 355             gotoeob(FALSE, 1);
 356             dotp = curwp->w_dotp;
 357             gotobob(FALSE, 1);
 358             curwp->w_doto = 0;
 359             getregion(&region, dotp, llength(dotp));
 360         }
 361         else{
 362             added_region = get_last_region_added();
 363             if(added_region){
 364                 curwp->w_dotp = added_region->r_linep;
 365                 curwp->w_doto = added_region->r_offset;
 366                 region = (*added_region);
 367             }
 368             else
 369               return(FALSE);
 370         }
 371
 372         if(!ldelete(region.r_size, NULL))
 373           return(FALSE);
 374     }                                   /* then splat out the saved buffer */
 375
 376     while (n--) {
 377         i = 0;
 378         while ((c = ((lastflag&CFFILL)
 379                      ? ((lastflag & CFFLBF) ? kremove(i) : fremove(i))
 380                      : kremove(i))) >= 0) {
 381             if (c == '\n') {
 382                 if (lnewline() == FALSE)
 383                   return (FALSE);
 384             } else {
 385                 if (linsert(1, c) == FALSE)
 386                   return (FALSE);
 387             }
 388
 389             ++i;
 390         }
 391     }
 392
 393     if(lastflag&CFFLPA){            /* if last command was fill paragraph */
 394         curwp->w_dotp = lforw(curwp->w_dotp);
 395         curwp->w_doto = 0;
 396
 397         curwp->w_flag |= WFMODE;
 398
 399         if(!Pmaster){
 400             sgarbk = TRUE;
 401             emlwrite("", NULL);
 402         }
 403     }
 404
 405     return (TRUE);
 406 }
 407
 408
 409
 410 /*
 411  * worthit - generic sort of test to roughly gage usefulness of using
 412  *           optimized scrolling.
 413  *
 414  * note:
 415  *      returns the line on the screen, l, that the dot is currently on
 416  */
 417 int
 418 worthit(int *l)
 419 {
 420     int i;                      /* l is current line */
 421     unsigned below;             /* below is avg # of ch/line under . */
 422
 423     *l = doton(&i, &below);
 424     below = (i > 0) ? below/(unsigned)i : 0;
 425
 426     return(below > 3);
 427 }