granicus.if.org Git - apache/blob - modules/filters/sed1.c

   1 /*
   2  * Copyright (c) 2005, 2008 Sun Microsystems, Inc. All Rights Reserved.
   3  * Use is subject to license terms.
   4  *
   5  *      Copyright (c) 1984 AT&T
   6  *        All Rights Reserved
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *  http://www.apache.org/licenses/LICENSE-2.0.
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  16  * or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21 #include "apr.h"
  22 #include "apr_lib.h"
  23 #include "libsed.h"
  24 #include "sed.h"
  25 #include "apr_strings.h"
  26 #include "regexp.h"
  27
  28 char    *trans[040]  = {
  29     "\\01",
  30     "\\02",
  31     "\\03",
  32     "\\04",
  33     "\\05",
  34     "\\06",
  35     "\\07",
  36     "\\10",
  37     "\\11",
  38     "\n",
  39     "\\13",
  40     "\\14",
  41     "\\15",
  42     "\\16",
  43     "\\17",
  44     "\\20",
  45     "\\21",
  46     "\\22",
  47     "\\23",
  48     "\\24",
  49     "\\25",
  50     "\\26",
  51     "\\27",
  52     "\\30",
  53     "\\31",
  54     "\\32",
  55     "\\33",
  56     "\\34",
  57     "\\35",
  58     "\\36",
  59     "\\37"
  60 };
  61 char rub[] = {"\\177"};
  62
  63 extern int sed_step(char *p1, char *p2, int circf, step_vars_storage *vars);
  64 static int substitute(sed_eval_t *eval, sed_reptr_t *ipc,
  65                       step_vars_storage *step_vars);
  66 static apr_status_t execute(sed_eval_t *eval);
  67 static int match(sed_eval_t *eval, char *expbuf, int gf,
  68                  step_vars_storage *step_vars);
  69 static apr_status_t dosub(sed_eval_t *eval, char *rhsbuf, int n,
  70                           step_vars_storage *step_vars);
  71 static char *place(sed_eval_t *eval, char *asp, char *al1, char *al2);
  72 static apr_status_t command(sed_eval_t *eval, sed_reptr_t *ipc,
  73                             step_vars_storage *step_vars);
  74 static apr_status_t wline(sed_eval_t *eval, char *buf, int sz);
  75 static apr_status_t arout(sed_eval_t *eval);
  76
  77 static void eval_errf(sed_eval_t *eval, const char *fmt, ...)
  78 {
  79     if (eval->errfn && eval->pool) {
  80         va_list args;
  81         const char* error;
  82         va_start(args, fmt);
  83         error = apr_pvsprintf(eval->pool, fmt, args);
  84         eval->errfn(eval->data, error);
  85         va_end(args);
  86     }
  87 }
  88
  89 #define INIT_BUF_SIZE 1024
  90
  91 /*
  92  * grow_buffer
  93  */
  94 static void grow_buffer(apr_pool_t *pool, char **buffer,
  95                         char **spend, unsigned int *cursize,
  96                         unsigned int newsize)
  97 {
  98     char* newbuffer = NULL;
  99     int spendsize = 0;
 100     if (*cursize >= newsize)
 101         return;
 102     /* Avoid number of times realloc is called. It could cause huge memory
 103      * requirement if line size is huge e.g 2 MB */
 104     if (newsize < *cursize * 2) {
 105         newsize = *cursize * 2;
 106     }
 107
 108     /* Align it to 4 KB boundary */
 109     newsize = (newsize  + ((1 << 12) - 1)) & ~((1 << 12) -1);
 110     newbuffer = apr_pcalloc(pool, newsize);
 111     if (*spend && *buffer && (*cursize > 0)) {
 112         spendsize = *spend - *buffer;
 113     }
 114     if ((*cursize > 0) && *buffer) {
 115         memcpy(newbuffer, *buffer, *cursize);
 116     }
 117     *buffer = newbuffer;
 118     *cursize = newsize;
 119     if (spend != buffer) {
 120         *spend = *buffer + spendsize;
 121     }
 122 }
 123
 124 /*
 125  * grow_line_buffer
 126  */
 127 static void grow_line_buffer(sed_eval_t *eval, int newsize)
 128 {
 129     grow_buffer(eval->pool, &eval->linebuf, &eval->lspend,
 130                 &eval->lsize, newsize);
 131 }
 132
 133 /*
 134  * grow_hold_buffer
 135  */
 136 static void grow_hold_buffer(sed_eval_t *eval, int newsize)
 137 {
 138     grow_buffer(eval->pool, &eval->holdbuf, &eval->hspend,
 139                 &eval->hsize, newsize);
 140 }
 141
 142 /*
 143  * grow_gen_buffer
 144  */
 145 static void grow_gen_buffer(sed_eval_t *eval, int newsize,
 146                             char **gspend)
 147 {
 148     if (gspend == NULL) {
 149         gspend = &eval->genbuf;
 150     }
 151     grow_buffer(eval->pool, &eval->genbuf, gspend,
 152                 &eval->gsize, newsize);
 153     eval->lcomend = &eval->genbuf[71];
 154 }
 155
 156 /*
 157  * appendmem_to_linebuf
 158  */
 159 static void appendmem_to_linebuf(sed_eval_t *eval, const char* sz, int len)
 160 {
 161     unsigned int reqsize = (eval->lspend - eval->linebuf) + len;
 162     if (eval->lsize < reqsize) {
 163         grow_line_buffer(eval, reqsize);
 164     }
 165     memcpy(eval->lspend, sz, len);
 166     eval->lspend += len;
 167 }
 168
 169 /*
 170  * append_to_linebuf
 171  */
 172 static void append_to_linebuf(sed_eval_t *eval, const char* sz)
 173 {
 174     int len = strlen(sz);
 175     /* Copy string including null character */
 176     appendmem_to_linebuf(eval, sz, len + 1);
 177     --eval->lspend; /* lspend will now point to NULL character */
 178 }
 179
 180 /*
 181  * copy_to_linebuf
 182  */
 183 static void copy_to_linebuf(sed_eval_t *eval, const char* sz)
 184 {
 185     eval->lspend = eval->linebuf;
 186     append_to_linebuf(eval, sz);
 187 }
 188
 189 /*
 190  * append_to_holdbuf
 191  */
 192 static void append_to_holdbuf(sed_eval_t *eval, const char* sz)
 193 {
 194     int len = strlen(sz);
 195     unsigned int reqsize = (eval->hspend - eval->holdbuf) + len + 1;
 196     if (eval->hsize <= reqsize) {
 197         grow_hold_buffer(eval, reqsize);
 198     }
 199     strcpy(eval->hspend, sz);
 200     /* hspend will now point to NULL character */
 201     eval->hspend += len;
 202 }
 203
 204 /*
 205  * copy_to_holdbuf
 206  */
 207 static void copy_to_holdbuf(sed_eval_t *eval, const char* sz)
 208 {
 209     eval->hspend = eval->holdbuf;
 210     append_to_holdbuf(eval, sz);
 211 }
 212
 213 /*
 214  * append_to_genbuf
 215  */
 216 static void append_to_genbuf(sed_eval_t *eval, const char* sz, char **gspend)
 217 {
 218     int len = strlen(sz);
 219     unsigned int reqsize = (*gspend - eval->genbuf) + len + 1;
 220     if (eval->gsize < reqsize) {
 221         grow_gen_buffer(eval, reqsize, gspend);
 222     }
 223     strcpy(*gspend, sz);
 224     /* *gspend will now point to NULL character */
 225     *gspend += len;
 226 }
 227
 228 /*
 229  * copy_to_genbuf
 230  */
 231 static void copy_to_genbuf(sed_eval_t *eval, const char* sz)
 232 {
 233     int len = strlen(sz);
 234     unsigned int reqsize = len + 1;
 235     if (eval->gsize < reqsize) {
 236         grow_gen_buffer(eval, reqsize, NULL);
 237     }
 238 }
 239
 240 /*
 241  * sed_init_eval
 242  */
 243 apr_status_t sed_init_eval(sed_eval_t *eval, sed_commands_t *commands, sed_err_fn_t *errfn, void *data, sed_write_fn_t *writefn, apr_pool_t* p)
 244 {
 245     memset(eval, 0, sizeof(*eval));
 246     eval->pool = p;
 247     eval->writefn = writefn;
 248     return sed_reset_eval(eval, commands, errfn, data);
 249 }
 250
 251 /*
 252  * sed_reset_eval
 253  */
 254 apr_status_t sed_reset_eval(sed_eval_t *eval, sed_commands_t *commands, sed_err_fn_t *errfn, void *data)
 255 {
 256     int i;
 257
 258     eval->errfn = errfn;
 259     eval->data = data;
 260
 261     eval->commands = commands;
 262
 263     eval->lnum = 0;
 264     eval->fout = NULL;
 265
 266     if (eval->linebuf == NULL) {
 267         eval->lsize = INIT_BUF_SIZE;
 268         eval->linebuf = apr_pcalloc(eval->pool, eval->lsize);
 269     }
 270     if (eval->holdbuf == NULL) {
 271         eval->hsize = INIT_BUF_SIZE;
 272         eval->holdbuf = apr_pcalloc(eval->pool, eval->hsize);
 273     }
 274     if (eval->genbuf == NULL) {
 275         eval->gsize = INIT_BUF_SIZE;
 276         eval->genbuf = apr_pcalloc(eval->pool, eval->gsize);
 277     }
 278     eval->lspend = eval->linebuf;
 279     eval->hspend = eval->holdbuf;
 280     eval->lcomend = &eval->genbuf[71];
 281
 282     for (i = 0; i < sizeof(eval->abuf) / sizeof(eval->abuf[0]); i++)
 283         eval->abuf[i] = NULL;
 284     eval->aptr = eval->abuf;
 285     eval->pending = NULL;
 286     eval->inar = apr_pcalloc(eval->pool, commands->nrep * sizeof(unsigned char));
 287     eval->nrep = commands->nrep;
 288
 289     eval->dolflag = 0;
 290     eval->sflag = 0;
 291     eval->jflag = 0;
 292     eval->delflag = 0;
 293     eval->lreadyflag = 0;
 294     eval->quitflag = 0;
 295     eval->finalflag = 1; /* assume we're evaluating only one file/stream */
 296     eval->numpass = 0;
 297     eval->nullmatch = 0;
 298     eval->col = 0;
 299
 300     for (i = 0; i < commands->nfiles; i++) {
 301         const char* filename = commands->fname[i];
 302         if (apr_file_open(&eval->fcode[i], filename,
 303                           APR_WRITE | APR_CREATE, APR_OS_DEFAULT,
 304                           eval->pool) != APR_SUCCESS) {
 305             eval_errf(eval, SEDERR_COMES, filename);
 306             return APR_EGENERAL;
 307         }
 308     }
 309
 310     return APR_SUCCESS;
 311 }
 312
 313 /*
 314  * sed_destroy_eval
 315  */
 316 void sed_destroy_eval(sed_eval_t *eval)
 317 {
 318     int i;
 319     /* eval->linebuf, eval->holdbuf, eval->genbuf and eval->inar are allocated
 320      * on pool. It will be freed when pool will be freed */
 321     for (i = 0; i < eval->commands->nfiles; i++) {
 322         if (eval->fcode[i] != NULL) {
 323             apr_file_close(eval->fcode[i]);
 324             eval->fcode[i] = NULL;
 325         }
 326     }
 327 }
 328
 329 /*
 330  * sed_eval_file
 331  */
 332 apr_status_t sed_eval_file(sed_eval_t *eval, apr_file_t *fin, void *fout)
 333 {
 334     for (;;) {
 335         char buf[1024];
 336         apr_size_t read_bytes = 0;
 337
 338         read_bytes = sizeof(buf);
 339         if (apr_file_read(fin, buf, &read_bytes) != APR_SUCCESS)
 340             break;
 341
 342         if (sed_eval_buffer(eval, buf, read_bytes, fout) != APR_SUCCESS)
 343             return APR_EGENERAL;
 344
 345         if (eval->quitflag)
 346             return APR_SUCCESS;
 347     }
 348
 349     return sed_finalize_eval(eval, fout);
 350 }
 351
 352 /*
 353  * sed_eval_buffer
 354  */
 355 apr_status_t sed_eval_buffer(sed_eval_t *eval, const char *buf, int bufsz, void *fout)
 356 {
 357     apr_status_t rv;
 358
 359     if (eval->quitflag)
 360         return APR_SUCCESS;
 361
 362     if (!sed_canbe_finalized(eval->commands)) {
 363         /* Commands were not finalized properly. */
 364         const char* error = sed_get_finalize_error(eval->commands, eval->pool);
 365         if (error) {
 366             eval_errf(eval, error);
 367             return APR_EGENERAL;
 368         }
 369     }
 370
 371     eval->fout = fout;
 372
 373     /* Process leftovers */
 374     if (bufsz && eval->lreadyflag) {
 375         eval->lreadyflag = 0;
 376         eval->lspend--;
 377         *eval->lspend = '\0';
 378         rv = execute(eval);
 379         if (rv != APR_SUCCESS)
 380             return rv;
 381     }
 382
 383     while (bufsz) {
 384         char *n;
 385         int llen;
 386
 387         n = memchr(buf, '\n', bufsz);
 388         if (n == NULL)
 389             break;
 390
 391         llen = n - buf;
 392         if (llen == bufsz - 1) {
 393             /* This might be the last line; delay its processing */
 394             eval->lreadyflag = 1;
 395             break;
 396         }
 397
 398         appendmem_to_linebuf(eval, buf, llen + 1);
 399         --eval->lspend;
 400         /* replace new line character with NULL */
 401         *eval->lspend = '\0';
 402         buf += (llen + 1);
 403         bufsz -= (llen + 1);
 404         rv = execute(eval);
 405         if (rv != APR_SUCCESS)
 406             return rv;
 407         if (eval->quitflag)
 408             break;
 409     }
 410
 411     /* Save the leftovers for later */
 412     if (bufsz) {
 413         appendmem_to_linebuf(eval, buf, bufsz);
 414     }
 415
 416     return APR_SUCCESS;
 417 }
 418
 419 /*
 420  * sed_finalize_eval
 421  */
 422 apr_status_t sed_finalize_eval(sed_eval_t *eval, void *fout)
 423 {
 424     if (eval->quitflag)
 425         return APR_SUCCESS;
 426
 427     if (eval->finalflag)
 428         eval->dolflag = 1;
 429
 430     eval->fout = fout;
 431
 432     /* Process leftovers */
 433     if (eval->lspend > eval->linebuf) {
 434         apr_status_t rv;
 435
 436         if (eval->lreadyflag) {
 437             eval->lreadyflag = 0;
 438             eval->lspend--;
 439         } else {
 440             /* Code can probably reach here when last character in output
 441              * buffer is not a newline.
 442              */
 443             /* Assure space for NULL */
 444             append_to_linebuf(eval, "");
 445         }
 446
 447         *eval->lspend = '\0';
 448         rv = execute(eval);
 449         if (rv != APR_SUCCESS)
 450             return rv;
 451     }
 452
 453     eval->quitflag = 1;
 454
 455     return APR_SUCCESS;
 456 }
 457
 458 /*
 459  * execute
 460  */
 461 static apr_status_t execute(sed_eval_t *eval)
 462 {
 463     sed_reptr_t *ipc = eval->commands->ptrspace;
 464     step_vars_storage step_vars;
 465     apr_status_t rv = APR_SUCCESS;
 466
 467     eval->lnum++;
 468
 469     eval->sflag = 0;
 470
 471     if (eval->pending) {
 472         ipc = eval->pending;
 473         eval->pending = NULL;
 474     }
 475
 476     memset(&step_vars, 0, sizeof(step_vars));
 477
 478     while (ipc->command) {
 479         char *p1;
 480         char *p2;
 481         int c;
 482
 483         p1 = ipc->ad1;
 484         p2 = ipc->ad2;
 485
 486         if (p1) {
 487
 488             if (eval->inar[ipc->nrep]) {
 489                 if (*p2 == CEND) {
 490                     p1 = 0;
 491                 } else if (*p2 == CLNUM) {
 492                     c = (unsigned char)p2[1];
 493                     if (eval->lnum > eval->commands->tlno[c]) {
 494                         eval->inar[ipc->nrep] = 0;
 495                         if (ipc->negfl)
 496                             goto yes;
 497                         ipc = ipc->next;
 498                         continue;
 499                     }
 500                     if (eval->lnum == eval->commands->tlno[c]) {
 501                         eval->inar[ipc->nrep] = 0;
 502                     }
 503                 } else if (match(eval, p2, 0, &step_vars)) {
 504                     eval->inar[ipc->nrep] = 0;
 505                 }
 506             } else if (*p1 == CEND) {
 507                 if (!eval->dolflag) {
 508                     if (ipc->negfl)
 509                         goto yes;
 510                     ipc = ipc->next;
 511                     continue;
 512                 }
 513             } else if (*p1 == CLNUM) {
 514                 c = (unsigned char)p1[1];
 515                 if (eval->lnum != eval->commands->tlno[c]) {
 516                     if (ipc->negfl)
 517                         goto yes;
 518                     ipc = ipc->next;
 519                     continue;
 520                 }
 521                 if (p2)
 522                     eval->inar[ipc->nrep] = 1;
 523             } else if (match(eval, p1, 0, &step_vars)) {
 524                 if (p2)
 525                     eval->inar[ipc->nrep] = 1;
 526             } else {
 527                 if (ipc->negfl)
 528                     goto yes;
 529                 ipc = ipc->next;
 530                 continue;
 531             }
 532         }
 533
 534         if (ipc->negfl) {
 535             ipc = ipc->next;
 536             continue;
 537         }
 538
 539 yes:
 540         rv = command(eval, ipc, &step_vars);
 541         if (rv != APR_SUCCESS)
 542             return rv;
 543
 544         if (eval->quitflag)
 545             return APR_SUCCESS;
 546
 547         if (eval->pending)
 548             return APR_SUCCESS;
 549
 550         if (eval->delflag)
 551             break;
 552
 553         if (eval->jflag) {
 554             eval->jflag = 0;
 555             if ((ipc = ipc->lb1) == 0) {
 556                 ipc = eval->commands->ptrspace;
 557                 break;
 558             }
 559         } else
 560             ipc = ipc->next;
 561     }
 562
 563     if (!eval->commands->nflag && !eval->delflag) {
 564         rv = wline(eval, eval->linebuf, eval->lspend - eval->linebuf);
 565         if (rv != APR_SUCCESS)
 566             return rv;
 567     }
 568
 569     if (eval->aptr > eval->abuf)
 570         rv = arout(eval);
 571
 572     eval->delflag = 0;
 573
 574     eval->lspend = eval->linebuf;
 575
 576     return rv;
 577 }
 578
 579 /*
 580  * match
 581  */
 582 static int match(sed_eval_t *eval, char *expbuf, int gf,
 583                  step_vars_storage *step_vars)
 584 {
 585     char   *p1;
 586     int circf;
 587
 588     if(gf) {
 589         if(*expbuf)    return(0);
 590         step_vars->locs = p1 = step_vars->loc2;
 591     } else {
 592         p1 = eval->linebuf;
 593         step_vars->locs = 0;
 594     }
 595
 596     circf = *expbuf++;
 597     return(sed_step(p1, expbuf, circf, step_vars));
 598 }
 599
 600 /*
 601  * substitute
 602  */
 603 static int substitute(sed_eval_t *eval, sed_reptr_t *ipc,
 604                       step_vars_storage *step_vars)
 605 {
 606     if(match(eval, ipc->re1, 0, step_vars) == 0)    return(0);
 607
 608     eval->numpass = 0;
 609     eval->sflag = 0;        /* Flags if any substitution was made */
 610     if (dosub(eval, ipc->rhs, ipc->gfl, step_vars) != APR_SUCCESS)
 611         return -1;
 612
 613     if(ipc->gfl) {
 614         while(*step_vars->loc2) {
 615             if(match(eval, ipc->re1, 1, step_vars) == 0) break;
 616             if (dosub(eval, ipc->rhs, ipc->gfl, step_vars) != APR_SUCCESS)
 617                 return -1;
 618         }
 619     }
 620     return(eval->sflag);
 621 }
 622
 623 /*
 624  * dosub
 625  */
 626 static apr_status_t dosub(sed_eval_t *eval, char *rhsbuf, int n,
 627                           step_vars_storage *step_vars)
 628 {
 629     char *lp, *sp, *rp;
 630     int c;
 631     apr_status_t rv = APR_SUCCESS;
 632
 633     if(n > 0 && n < 999) {
 634         eval->numpass++;
 635         if(n != eval->numpass) return APR_SUCCESS;
 636     }
 637     eval->sflag = 1;
 638     lp = eval->linebuf;
 639     sp = eval->genbuf;
 640     rp = rhsbuf;
 641     sp = place(eval, sp, lp, step_vars->loc1);
 642     while ((c = *rp++) != 0) {
 643         if (c == '&') {
 644             sp = place(eval, sp, step_vars->loc1, step_vars->loc2);
 645             if (sp == NULL)
 646                 return APR_EGENERAL;
 647         }
 648         else if (c == '\\') {
 649             c = *rp++;
 650             if (c >= '1' && c < NBRA+'1') {
 651                 sp = place(eval, sp, step_vars->braslist[c-'1'],
 652                            step_vars->braelist[c-'1']);
 653                 if (sp == NULL)
 654                     return APR_EGENERAL;
 655             }
 656             else
 657                 *sp++ = c;
 658           } else
 659             *sp++ = c;
 660         if (sp >= eval->genbuf + eval->gsize) {
 661             /* expand genbuf and set the sp appropriately */
 662             grow_gen_buffer(eval, eval->gsize + 1024, &sp);
 663         }
 664     }
 665     lp = step_vars->loc2;
 666     step_vars->loc2 = sp - eval->genbuf + eval->linebuf;
 667     append_to_genbuf(eval, lp, &sp);
 668     copy_to_linebuf(eval, eval->genbuf);
 669     return rv;
 670 }
 671
 672 /*
 673  * place
 674  */
 675 static char *place(sed_eval_t *eval, char *asp, char *al1, char *al2)
 676 {
 677     char *sp = asp;
 678     int n = al2 - al1;
 679     unsigned int reqsize = (sp - eval->genbuf) + n + 1;
 680
 681     if (eval->gsize < reqsize) {
 682         grow_gen_buffer(eval, reqsize, &sp);
 683     }
 684     memcpy(sp, al1, n);
 685     return sp + n;
 686 }
 687
 688 /*
 689  * command
 690  */
 691 static apr_status_t command(sed_eval_t *eval, sed_reptr_t *ipc,
 692                             step_vars_storage *step_vars)
 693 {
 694     int    i;
 695     char   *p1, *p2, *p3;
 696     int length;
 697     char sz[32]; /* 32 bytes enough to store 64 bit integer in decimal */
 698     apr_status_t rv = APR_SUCCESS;
 699
 700
 701     switch(ipc->command) {
 702
 703         case ACOM:
 704             if(eval->aptr >= &eval->abuf[SED_ABUFSIZE]) {
 705                 eval_errf(eval, SEDERR_TMAMES, eval->lnum);
 706             } else {
 707                 *eval->aptr++ = ipc;
 708                 *eval->aptr = NULL;
 709             }
 710             break;
 711
 712         case CCOM:
 713             eval->delflag = 1;
 714             if(!eval->inar[ipc->nrep] || eval->dolflag) {
 715                 for (p1 = ipc->re1; *p1; p1++)
 716                     ;
 717                 rv = wline(eval, ipc->re1, p1 - ipc->re1);
 718             }
 719             break;
 720         case DCOM:
 721             eval->delflag++;
 722             break;
 723         case CDCOM:
 724             p1 = eval->linebuf;
 725
 726             while(*p1 != '\n') {
 727                 if(*p1++ == 0) {
 728                     eval->delflag++;
 729                     return APR_SUCCESS;
 730                 }
 731             }
 732
 733             p1++;
 734             copy_to_linebuf(eval, p1);
 735             eval->jflag++;
 736             break;
 737
 738         case EQCOM:
 739             length = apr_snprintf(sz, sizeof(sz), "%d", (int) eval->lnum);
 740             rv = wline(eval, sz, length);
 741             break;
 742
 743         case GCOM:
 744             copy_to_linebuf(eval, eval->holdbuf);
 745             break;
 746
 747         case CGCOM:
 748             append_to_linebuf(eval, "\n");
 749             append_to_linebuf(eval, eval->holdbuf);
 750             break;
 751
 752         case HCOM:
 753             copy_to_holdbuf(eval, eval->linebuf);
 754             break;
 755
 756         case CHCOM:
 757             append_to_holdbuf(eval, "\n");
 758             append_to_holdbuf(eval, eval->linebuf);
 759             break;
 760
 761         case ICOM:
 762             for (p1 = ipc->re1; *p1; p1++);
 763             rv = wline(eval, ipc->re1, p1 - ipc->re1);
 764             break;
 765
 766         case BCOM:
 767             eval->jflag = 1;
 768             break;
 769
 770
 771         case LCOM:
 772             p1 = eval->linebuf;
 773             p2 = eval->genbuf;
 774             eval->genbuf[72] = 0;
 775             while(*p1)
 776                 if((unsigned char)*p1 >= 040) {
 777                     if(*p1 == 0177) {
 778                         p3 = rub;
 779                         while ((*p2++ = *p3++) != 0)
 780                             if(p2 >= eval->lcomend) {
 781                                 *p2 = '\\';
 782                                 rv = wline(eval, eval->genbuf,
 783                                            strlen(eval->genbuf));
 784                                 if (rv != APR_SUCCESS)
 785                                     return rv;
 786                                 p2 = eval->genbuf;
 787                             }
 788                         p2--;
 789                         p1++;
 790                         continue;
 791                     }
 792                     if(!isprint(*p1 & 0377)) {
 793                         *p2++ = '\\';
 794                         if(p2 >= eval->lcomend) {
 795                             *p2 = '\\';
 796                             rv = wline(eval, eval->genbuf,
 797                                        strlen(eval->genbuf));
 798                             if (rv != APR_SUCCESS)
 799                                 return rv;
 800                             p2 = eval->genbuf;
 801                         }
 802                         *p2++ = (*p1 >> 6) + '0';
 803                         if(p2 >= eval->lcomend) {
 804                             *p2 = '\\';
 805                             rv = wline(eval, eval->genbuf,
 806                                        strlen(eval->genbuf));
 807                             if (rv != APR_SUCCESS)
 808                                 return rv;
 809                             p2 = eval->genbuf;
 810                         }
 811                         *p2++ = ((*p1 >> 3) & 07) + '0';
 812                         if(p2 >= eval->lcomend) {
 813                             *p2 = '\\';
 814                             rv = wline(eval, eval->genbuf,
 815                                        strlen(eval->genbuf));
 816                             if (rv != APR_SUCCESS)
 817                                 return rv;
 818                             p2 = eval->genbuf;
 819                         }
 820                         *p2++ = (*p1++ & 07) + '0';
 821                         if(p2 >= eval->lcomend) {
 822                             *p2 = '\\';
 823                             rv = wline(eval, eval->genbuf,
 824                                        strlen(eval->genbuf));
 825                             if (rv != APR_SUCCESS)
 826                                 return rv;
 827                             p2 = eval->genbuf;
 828                         }
 829                     } else {
 830                         *p2++ = *p1++;
 831                         if(p2 >= eval->lcomend) {
 832                             *p2 = '\\';
 833                             rv = wline(eval, eval->genbuf,
 834                                        strlen(eval->genbuf));
 835                             if (rv != APR_SUCCESS)
 836                                 return rv;
 837                             p2 = eval->genbuf;
 838                         }
 839                     }
 840                 } else {
 841                     p3 = trans[(unsigned char)*p1-1];
 842                     while ((*p2++ = *p3++) != 0)
 843                         if(p2 >= eval->lcomend) {
 844                             *p2 = '\\';
 845                             rv = wline(eval, eval->genbuf,
 846                                        strlen(eval->genbuf));
 847                             if (rv != APR_SUCCESS)
 848                                 return rv;
 849                             p2 = eval->genbuf;
 850                         }
 851                     p2--;
 852                     p1++;
 853                 }
 854             *p2 = 0;
 855             rv = wline(eval, eval->genbuf, strlen(eval->genbuf));
 856             break;
 857
 858         case NCOM:
 859             if(!eval->commands->nflag) {
 860                 rv = wline(eval, eval->linebuf, eval->lspend - eval->linebuf);
 861                 if (rv != APR_SUCCESS)
 862                     return rv;
 863             }
 864
 865             if(eval->aptr > eval->abuf) {
 866                 rv = arout(eval);
 867                 if (rv != APR_SUCCESS)
 868                     return rv;
 869             }
 870             eval->lspend = eval->linebuf;
 871             eval->pending = ipc->next;
 872
 873             break;
 874         case CNCOM:
 875             if(eval->aptr > eval->abuf) {
 876                 rv = arout(eval);
 877                 if (rv != APR_SUCCESS)
 878                     return rv;
 879             }
 880             append_to_linebuf(eval, "\n");
 881             eval->pending = ipc->next;
 882             break;
 883
 884         case PCOM:
 885             rv = wline(eval, eval->linebuf, eval->lspend - eval->linebuf);
 886             break;
 887         case CPCOM:
 888             for (p1 = eval->linebuf; *p1 != '\n' && *p1 != '\0'; p1++);
 889             rv = wline(eval, eval->linebuf, p1 - eval->linebuf);
 890             break;
 891
 892         case QCOM:
 893             if (!eval->commands->nflag) {
 894                 rv = wline(eval, eval->linebuf, eval->lspend - eval->linebuf);
 895                 if (rv != APR_SUCCESS)
 896                     break;
 897             }
 898
 899             if(eval->aptr > eval->abuf) {
 900                 rv = arout(eval);
 901                 if (rv != APR_SUCCESS)
 902                     return rv;
 903             }
 904
 905             eval->quitflag = 1;
 906             break;
 907         case RCOM:
 908             if(eval->aptr >= &eval->abuf[SED_ABUFSIZE]) {
 909                 eval_errf(eval, SEDERR_TMRMES, eval->lnum);
 910             } else {
 911                 *eval->aptr++ = ipc;
 912                 *eval->aptr = NULL;
 913             }
 914             break;
 915
 916         case SCOM:
 917             i = substitute(eval, ipc, step_vars);
 918             if (i == -1) {
 919                 return APR_EGENERAL;
 920             }
 921             if(ipc->pfl && eval->commands->nflag && i) {
 922                 if(ipc->pfl == 1) {
 923                     rv = wline(eval, eval->linebuf, eval->lspend -
 924                                eval->linebuf);
 925                     if (rv != APR_SUCCESS)
 926                         return rv;
 927                 } else {
 928                     for (p1 = eval->linebuf; *p1 != '\n' && *p1 != '\0'; p1++);
 929                     rv = wline(eval, eval->linebuf, p1 - eval->linebuf);
 930                     if (rv != APR_SUCCESS)
 931                         return rv;
 932                 }
 933             }
 934             if (i && (ipc->findex >= 0) && eval->fcode[ipc->findex])
 935                 apr_file_printf(eval->fcode[ipc->findex], "%s\n",
 936                                 eval->linebuf);
 937             break;
 938
 939         case TCOM:
 940             if(eval->sflag == 0)  break;
 941             eval->sflag = 0;
 942             eval->jflag = 1;
 943             break;
 944
 945         case WCOM:
 946             if (ipc->findex >= 0)
 947                 apr_file_printf(eval->fcode[ipc->findex], "%s\n",
 948                                 eval->linebuf);
 949             break;
 950         case XCOM:
 951             copy_to_genbuf(eval, eval->linebuf);
 952             copy_to_linebuf(eval, eval->holdbuf);
 953             copy_to_holdbuf(eval, eval->genbuf);
 954             break;
 955
 956         case YCOM:
 957             p1 = eval->linebuf;
 958             p2 = ipc->re1;
 959             while((*p1 = p2[(unsigned char)*p1]) != 0)    p1++;
 960             break;
 961     }
 962     return rv;
 963 }
 964
 965 /*
 966  * arout
 967  */
 968 static apr_status_t arout(sed_eval_t *eval)
 969 {
 970     apr_status_t rv = APR_SUCCESS;
 971     eval->aptr = eval->abuf - 1;
 972     while (*++eval->aptr) {
 973         if ((*eval->aptr)->command == ACOM) {
 974             char *p1;
 975
 976             for (p1 = (*eval->aptr)->re1; *p1; p1++);
 977             rv = wline(eval, (*eval->aptr)->re1, p1 - (*eval->aptr)->re1);
 978             if (rv != APR_SUCCESS)
 979                 return rv;
 980         } else {
 981             apr_file_t *fi = NULL;
 982             char buf[512];
 983             apr_size_t n = sizeof(buf);
 984
 985             if (apr_file_open(&fi, (*eval->aptr)->re1, APR_READ, 0, eval->pool)
 986                               != APR_SUCCESS)
 987                 continue;
 988             while ((apr_file_read(fi, buf, &n)) == APR_SUCCESS) {
 989                 if (n == 0)
 990                     break;
 991                 rv = eval->writefn(eval->fout, buf, n);
 992                 if (rv != APR_SUCCESS) {
 993                     apr_file_close(fi);
 994                     return rv;
 995                 }
 996                 n = sizeof(buf);
 997             }
 998             apr_file_close(fi);
 999         }
1000     }
1001     eval->aptr = eval->abuf;
1002     *eval->aptr = NULL;
1003     return rv;
1004 }
1005
1006 /*
1007  * wline
1008  */
1009 static apr_status_t wline(sed_eval_t *eval, char *buf, int sz)
1010 {
1011     apr_status_t rv = APR_SUCCESS;
1012     rv = eval->writefn(eval->fout, buf, sz);
1013     if (rv != APR_SUCCESS)
1014         return rv;
1015     rv = eval->writefn(eval->fout, "\n", 1);
1016     return rv;
1017 }
1018