src/edln.c

   1 /*
   2  * ion/edln.c
   3  *
   4  * Copyright (c) Tuomo Valkonen 1999-2001.
   5  * See the included file LICENSE for details.
   6  */
   7
   8 #include <string.h>
   9 #include <ctype.h>
  10 #include <string.h>
  11 #include "common.h"
  12
  13 #include "selection.h"
  14 #include "edln.h"
  15 #include "wedln.h"
  16 #include "complete.h"
  17
  18 #define EDLN_ALLOCUNIT 16
  19 #define EDLN_HISTORY_SIZE 256
  20
  21
  22 #define UPDATE(X) edln->ui_update(edln->uiptr, X, FALSE)
  23 #define UPDATE_MOVED(X) edln->ui_update(edln->uiptr, X, TRUE)
  24
  25
  26 /*{{{ Alloc */
  27
  28
  29 static bool edln_pspc(Edln *edln, int n)
  30 {
  31         char *np;
  32         int pa;
  33
  34         if(edln->palloced<edln->psize+1+n){
  35                 pa=edln->palloced+n;
  36                 pa|=(EDLN_ALLOCUNIT-1);
  37                 np=ALLOC_N(char, pa);
  38
  39                 if(np==NULL){
  40                         warn_err();
  41                         return FALSE;
  42                 }
  43
  44                 memmove(np, edln->p, edln->point*sizeof(char));
  45                 memmove(np+edln->point+n, edln->p+edln->point,
  46                                 (edln->psize-edln->point+1)*sizeof(char));
  47                 free(edln->p);
  48                 edln->p=np;
  49                 edln->palloced=pa;
  50         }else{
  51                 memmove(edln->p+edln->point+n, edln->p+edln->point,
  52                                 (edln->psize-edln->point+1)*sizeof(char));
  53         }
  54
  55         edln->psize+=n;
  56         edln->modified=1;
  57         return TRUE;
  58 }
  59
  60
  61 static bool edln_rspc(Edln *edln, int n)
  62 {
  63         char *np;
  64         int pa;
  65
  66         if(n+edln->point>=edln->psize)
  67                 n=edln->psize-edln->point;
  68
  69         if(n==0)
  70                 return TRUE;
  71
  72         if((edln->psize+1-n)<(edln->palloced&~(EDLN_ALLOCUNIT-1))){
  73                 pa=edln->palloced&~(EDLN_ALLOCUNIT-1);
  74                 np=ALLOC_N(char, pa);
  75
  76                 if(np==NULL){
  77                         warn_err();
  78                         goto norm;
  79                 }
  80
  81                 memmove(np, edln->p, edln->point*sizeof(char));
  82                 memmove(np+edln->point, edln->p+edln->point+n,
  83                                 (edln->psize-edln->point+1-n)*sizeof(char));
  84                 free(edln->p);
  85                 edln->p=np;
  86                 edln->palloced=pa;
  87         }else{
  88         norm:
  89                 memmove(edln->p+edln->point, edln->p+edln->point+n,
  90                                 (edln->psize-edln->point+1-n)*sizeof(char));
  91         }
  92         edln->psize-=n;
  93
  94         edln->modified=1;
  95         return TRUE;
  96 }
  97
  98
  99 static void edln_clearstr(Edln *edln)
 100 {
 101         if(edln->p!=NULL)
 102                 free(edln->p);
 103         edln->palloced=0;
 104         edln->psize=0;
 105 }
 106
 107
 108 static bool edln_initstr(Edln *edln, const char *p)
 109 {
 110         int l=strlen(p), al;
 111
 112         al=(l+1)|(EDLN_ALLOCUNIT-1);
 113
 114         edln->p=ALLOC_N(char, al);
 115
 116         if(edln->p==NULL){
 117                 warn_err();
 118                 return FALSE;
 119         }
 120
 121         edln->palloced=al;
 122         edln->psize=l;
 123         strcpy(edln->p, p);
 124
 125         return TRUE;
 126 }
 127
 128
 129 static bool edln_setstr(Edln *edln, const char *p)
 130 {
 131         edln_clearstr(edln);
 132         return edln_initstr(edln, p);
 133 }
 134
 135
 136 /*}}}*/
 137
 138
 139 /*{{{ Insert */
 140
 141
 142 bool edln_insch(Edln *edln, char ch)
 143 {
 144         if(edln_pspc(edln, 1)){
 145                 edln->p[edln->point]=ch;
 146                 edln->point++;
 147                 UPDATE_MOVED(edln->point-1);
 148                 return TRUE;
 149         }
 150         return FALSE;
 151 }
 152
 153
 154 bool edln_ovrch(Edln *edln, char ch)
 155 {
 156         edln_delete(edln);
 157         return edln_insch(edln, ch);
 158 }
 159
 160
 161 bool edln_insstr(Edln *edln, const char *str)
 162 {
 163         int l;
 164
 165         if(str==NULL)
 166                 return FALSE;
 167
 168         l=strlen(str);
 169
 170         return edln_insstr_n(edln, str, l);
 171 }
 172
 173
 174 bool edln_insstr_n(Edln *edln, const char *str, int l)
 175 {
 176         if(!edln_pspc(edln, l))
 177                 return FALSE;
 178
 179         memmove(&(edln->p[edln->point]), str, l);
 180         edln->point+=l;
 181         UPDATE_MOVED(edln->point-l);
 182
 183         return TRUE;
 184 }
 185
 186
 187 /*}}}*/
 188
 189
 190 /*{{{ Movement */
 191
 192
 193 void edln_back(Edln *edln)
 194 {
 195         if(edln->point>0){
 196                 edln->point--;
 197                 UPDATE_MOVED(edln->point);
 198         }
 199 }
 200
 201
 202 void edln_forward(Edln *edln)
 203 {
 204         if(edln->point<edln->psize){
 205                 edln->point++;
 206                 UPDATE_MOVED(edln->point-1);
 207         }
 208 }
 209
 210
 211 void edln_bol(Edln *edln)
 212 {
 213         if(edln->point!=0){
 214                 edln->point=0;
 215                 UPDATE_MOVED(0);
 216         }
 217 }
 218
 219
 220 void edln_eol(Edln *edln)
 221 {
 222         int o=edln->point;
 223
 224         if(edln->point!=edln->psize){
 225                 edln->point=edln->psize;
 226                 UPDATE_MOVED(o);
 227         }
 228 }
 229
 230
 231 void edln_bskip_word(Edln *edln)
 232 {
 233         int p=edln->point-1;
 234
 235         while(p>0){
 236                 if(isalnum(edln->p[p]))
 237                         goto fnd;
 238                 p--;
 239         }
 240         return;
 241
 242 fnd:
 243         while(p>0){
 244                 if(!isalnum(edln->p[p])){
 245                         p++;
 246                         break;
 247                 }
 248                 p--;
 249         }
 250         edln->point=p;
 251         UPDATE_MOVED(edln->point);
 252 }
 253
 254
 255 void edln_skip_word(Edln *edln)
 256 {
 257         int p=edln->point;
 258         int o=p;
 259
 260         while(p<edln->psize){
 261                 if(!isalnum(edln->p[p]))
 262                         goto fnd;
 263                 p++;
 264         }
 265         return;
 266
 267 fnd:
 268         while(p<edln->psize){
 269                 if(isalnum(edln->p[p]))
 270                         break;
 271                 p++;
 272         }
 273         edln->point=p;
 274         UPDATE_MOVED(o);
 275 }
 276
 277
 278 void edln_set_point(Edln *edln, int point)
 279 {
 280         int o=edln->point;
 281
 282         if(point<0)
 283                 point=0;
 284         else if(point>edln->psize)
 285                 point=edln->psize;
 286
 287         edln->point=point;
 288
 289         if(o<point)
 290                 UPDATE_MOVED(o);
 291         else
 292                 UPDATE_MOVED(point);
 293 }
 294
 295
 296 /*}}}*/
 297
 298
 299 /*{{{ Delete */
 300
 301
 302 void edln_delete(Edln *edln)
 303 {
 304         edln_rspc(edln, 1);
 305         UPDATE(edln->point);
 306 }
 307
 308
 309 void edln_backspace(Edln *edln)
 310 {
 311         if(edln->point!=0){
 312                 edln_back(edln);
 313                 edln_delete(edln);
 314                 UPDATE_MOVED(edln->point);
 315         }
 316 }
 317
 318 void edln_kill_to_eol(Edln *edln)
 319 {
 320         edln_rspc(edln, edln->psize-edln->point);
 321         UPDATE(edln->point);
 322 }
 323
 324
 325 void edln_kill_to_bol(Edln *edln)
 326 {
 327         int p=edln->point;
 328
 329         edln_bol(edln);
 330         edln_rspc(edln, p);
 331         edln->point=0;
 332         UPDATE_MOVED(0);
 333 }
 334
 335
 336 void edln_kill_line(Edln *edln)
 337 {
 338         edln_bol(edln);
 339         edln_kill_to_eol(edln);
 340         UPDATE_MOVED(0);
 341 }
 342
 343
 344 void edln_kill_word(Edln *edln)
 345 {
 346         int p=edln->point;
 347         int o=p;
 348
 349         if(!isalnum(edln->p[p])){
 350                 while(p<edln->psize){
 351                         p++;
 352                         if(isalnum(edln->p[p]))
 353                                 break;
 354                 }
 355         }else{
 356                 while(p<edln->psize){
 357                         p++;
 358                         if(!isalnum(edln->p[p]))
 359                                 break;
 360                 }
 361         }
 362         edln_rspc(edln, p-edln->point);
 363         UPDATE(o);
 364 }
 365
 366
 367 void edln_bkill_word(Edln *edln)
 368 {
 369         int p=edln->point, p2;
 370
 371         if(p==0)
 372                 return;
 373
 374         p--;
 375         if(!isalnum(edln->p[p])){
 376                 while(p>0){
 377                         p--;
 378                         if(isalnum(edln->p[p])){
 379                                 p++;
 380                                 break;
 381                         }
 382                 }
 383         }else{
 384                 while(p>0){
 385                         p--;
 386                         if(!isalnum(edln->p[p])){
 387                                 p++;
 388                                 break;
 389                         }
 390                 }
 391         }
 392
 393         p2=edln->point;
 394         edln->point=p;
 395         edln_rspc(edln, p2-p);
 396         UPDATE_MOVED(edln->point);
 397 }
 398
 399
 400 /*}}}*/
 401
 402
 403 /*{{{ Selection */
 404
 405
 406 void edln_set_mark(Edln *edln)
 407 {
 408         edln->mark=edln->point;
 409 }
 410
 411
 412 void edln_clear_mark(Edln *edln)
 413 {
 414         int m=edln->mark;
 415         edln->mark=-1;
 416
 417         if(m<edln->point)
 418                 UPDATE(m);
 419         else
 420                 UPDATE(edln->point);
 421 }
 422
 423
 424 static void edln_do_copy(Edln *edln, bool del)
 425 {
 426         int beg, end;
 427
 428         if(edln->mark<0 || edln->point==edln->mark)
 429                 return;
 430
 431         if(edln->point<edln->mark){
 432                 beg=edln->point;
 433                 end=edln->mark;
 434         }else{
 435                 beg=edln->mark;
 436                 end=edln->point;
 437         }
 438
 439         set_selection(edln->p+beg, end-beg);
 440
 441         if(del){
 442                 edln->point=beg;
 443                 edln_rspc(edln, end-beg);
 444         }
 445         edln->mark=-1;
 446
 447         UPDATE(beg);
 448 }
 449
 450
 451 void edln_cut(Edln *edln)
 452 {
 453         edln_do_copy(edln, TRUE);
 454 }
 455
 456
 457 void edln_copy(Edln *edln)
 458 {
 459         edln_do_copy(edln, FALSE);
 460 }
 461
 462
 463 /*}}}*/
 464
 465
 466 /*{{{ History */
 467
 468
 469 static int hist_head=EDLN_HISTORY_SIZE;
 470 static int hist_count=0;
 471 static char *hist[EDLN_HISTORY_SIZE];
 472
 473
 474 void edlnhist_push(const char *str)
 475 {
 476         char *strc=scopy(str);
 477
 478         if(strc==NULL){
 479                 warn_err();
 480                 return;
 481         }
 482
 483         hist_head--;
 484         if(hist_head<0)
 485                 hist_head=EDLN_HISTORY_SIZE-1;
 486
 487         if(hist_count==EDLN_HISTORY_SIZE)
 488                 free(hist[hist_head]);
 489         else
 490                 hist_count++;
 491
 492         hist[hist_head]=strc;
 493 }
 494
 495
 496 void edlnhist_clear()
 497 {
 498         while(hist_count!=0){
 499                 free(hist[hist_head]);
 500                 hist_count--;
 501                 if(++hist_head==EDLN_HISTORY_SIZE)
 502                         hist_head=0;
 503         }
 504         hist_head=EDLN_HISTORY_SIZE;
 505 }
 506
 507
 508 static void edln_do_set_hist(Edln *edln, int e)
 509 {
 510         edln->histent=e;
 511         edln_setstr(edln, hist[e]);
 512         edln->point=edln->psize;
 513         edln->mark=-1;
 514         edln->modified=FALSE;
 515         UPDATE_MOVED(0);
 516 }
 517
 518
 519 void edln_history_prev(Edln *edln)
 520 {
 521         int e;
 522
 523         if(edln->histent==-1){
 524                 if(hist_count==0)
 525                         return;
 526                 edln->tmp_p=edln->p;
 527                 edln->p=NULL;
 528                 e=hist_head;
 529         }else{
 530                 e=edln->histent;
 531                 if(e==(hist_head+hist_count-1)%EDLN_HISTORY_SIZE)
 532                         return;
 533                 e=(e+1)%EDLN_HISTORY_SIZE;
 534         }
 535
 536         edln_do_set_hist(edln, e);
 537 }
 538
 539
 540 void edln_history_next(Edln *edln)
 541 {
 542         int e=edln->histent;
 543
 544         if(edln->histent==-1)
 545                 return;
 546
 547         if(edln->histent==hist_head){
 548                 edln->histent=-1;
 549                 if(edln->p!=NULL)
 550                         free(edln->p);
 551                 edln->p=edln->tmp_p;
 552                 edln->tmp_p=NULL;
 553                 edln->point=strlen(edln->p);
 554                 edln->mark=-1;
 555                 edln->modified=TRUE;
 556                 UPDATE_MOVED(0);
 557                 return;
 558         }
 559
 560 /*      e=edln->histent-1;*/
 561
 562         edln_do_set_hist(edln, (e+EDLN_HISTORY_SIZE-1)%EDLN_HISTORY_SIZE);
 563 }
 564
 565
 566 /*}}}*/
 567
 568
 569 /*{{{ Init/deinit */
 570
 571
 572 bool edln_init(Edln *edln, const char *p)
 573 {
 574         if(p==NULL)
 575                 p="";
 576
 577         if(!edln_initstr(edln, p))
 578                 return FALSE;
 579
 580         edln->point=edln->psize;
 581         edln->mark=-1;
 582         edln->histent=-1;
 583         edln->modified=FALSE;
 584         edln->completion_handler=NULL;
 585         edln->tmp_p=NULL;
 586
 587         return TRUE;
 588 }
 589
 590
 591 void edln_deinit(Edln *edln)
 592 {
 593         if(edln->p!=NULL){
 594                 free(edln->p);
 595                 edln->p=NULL;
 596         }
 597         if(edln->tmp_p!=NULL){
 598                 free(edln->tmp_p);
 599                 edln->tmp_p=NULL;
 600         }
 601 }
 602
 603
 604 char* edln_finish(Edln *edln)
 605 {
 606         char *p=edln->p;
 607
 608         /*if(edln->modified)*/
 609                 edlnhist_push(p);
 610
 611         edln->p=NULL;
 612         edln->psize=edln->palloced=0;
 613
 614         stripws(p);
 615         return p;
 616 }
 617
 618 /*}}}*/
 619