lib/librte_cmdline/cmdline_rdline.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation.
   3  * Copyright (c) 2009, Olivier MATZ <zer0@droids-corp.org>
   4  * All rights reserved.
   5  */
   6
   7 #include <stdlib.h>
   8 #include <stdio.h>
   9 #include <stdint.h>
  10 #include <string.h>
  11 #include <stdarg.h>
  12 #include <errno.h>
  13 #include <ctype.h>
  14
  15 #include "cmdline_cirbuf.h"
  16 #include "cmdline_rdline.h"
  17
  18 static void rdline_puts(struct rdline *rdl, const char *buf);
  19 static void rdline_miniprintf(struct rdline *rdl,
  20                               const char *buf, unsigned int val);
  21
  22 static void rdline_remove_old_history_item(struct rdline *rdl);
  23 static void rdline_remove_first_history_item(struct rdline *rdl);
  24 static unsigned int rdline_get_history_size(struct rdline *rdl);
  25
  26
  27 /* isblank() needs _XOPEN_SOURCE >= 600 || _ISOC99_SOURCE, so use our
  28  * own. */
  29 static int
  30 isblank2(char c)
  31 {
  32         if (c == ' ' ||
  33             c == '\t' )
  34                 return 1;
  35         return 0;
  36 }
  37
  38 int
  39 rdline_init(struct rdline *rdl,
  40                  rdline_write_char_t *write_char,
  41                  rdline_validate_t *validate,
  42                  rdline_complete_t *complete)
  43 {
  44         if (!rdl || !write_char || !validate || !complete)
  45                 return -EINVAL;
  46         memset(rdl, 0, sizeof(*rdl));
  47         rdl->validate = validate;
  48         rdl->complete = complete;
  49         rdl->write_char = write_char;
  50         rdl->status = RDLINE_INIT;
  51         return cirbuf_init(&rdl->history, rdl->history_buf, 0, RDLINE_HISTORY_BUF_SIZE);
  52 }
  53
  54 void
  55 rdline_newline(struct rdline *rdl, const char *prompt)
  56 {
  57         unsigned int i;
  58
  59         if (!rdl || !prompt)
  60                 return;
  61
  62         vt100_init(&rdl->vt100);
  63         cirbuf_init(&rdl->left, rdl->left_buf, 0, RDLINE_BUF_SIZE);
  64         cirbuf_init(&rdl->right, rdl->right_buf, 0, RDLINE_BUF_SIZE);
  65
  66         rdl->prompt_size = strnlen(prompt, RDLINE_PROMPT_SIZE-1);
  67         if (prompt != rdl->prompt)
  68                 memcpy(rdl->prompt, prompt, rdl->prompt_size);
  69         rdl->prompt[RDLINE_PROMPT_SIZE-1] = '\0';
  70
  71         for (i=0 ; i<rdl->prompt_size ; i++)
  72                 rdl->write_char(rdl, rdl->prompt[i]);
  73         rdl->status = RDLINE_RUNNING;
  74
  75         rdl->history_cur_line = -1;
  76 }
  77
  78 void
  79 rdline_stop(struct rdline *rdl)
  80 {
  81         if (!rdl)
  82                 return;
  83         rdl->status = RDLINE_INIT;
  84 }
  85
  86 void
  87 rdline_quit(struct rdline *rdl)
  88 {
  89         if (!rdl)
  90                 return;
  91         rdl->status = RDLINE_EXITED;
  92 }
  93
  94 void
  95 rdline_restart(struct rdline *rdl)
  96 {
  97         if (!rdl)
  98                 return;
  99         rdl->status = RDLINE_RUNNING;
 100 }
 101
 102 void
 103 rdline_reset(struct rdline *rdl)
 104 {
 105         if (!rdl)
 106                 return;
 107         vt100_init(&rdl->vt100);
 108         cirbuf_init(&rdl->left, rdl->left_buf, 0, RDLINE_BUF_SIZE);
 109         cirbuf_init(&rdl->right, rdl->right_buf, 0, RDLINE_BUF_SIZE);
 110
 111         rdl->status = RDLINE_RUNNING;
 112
 113         rdl->history_cur_line = -1;
 114 }
 115
 116 const char *
 117 rdline_get_buffer(struct rdline *rdl)
 118 {
 119         if (!rdl)
 120                 return NULL;
 121         unsigned int len_l, len_r;
 122         cirbuf_align_left(&rdl->left);
 123         cirbuf_align_left(&rdl->right);
 124
 125         len_l = CIRBUF_GET_LEN(&rdl->left);
 126         len_r = CIRBUF_GET_LEN(&rdl->right);
 127         memcpy(rdl->left_buf+len_l, rdl->right_buf, len_r);
 128
 129         rdl->left_buf[len_l + len_r] = '\n';
 130         rdl->left_buf[len_l + len_r + 1] = '\0';
 131         return rdl->left_buf;
 132 }
 133
 134 static void
 135 display_right_buffer(struct rdline *rdl, int force)
 136 {
 137         unsigned int i;
 138         char tmp;
 139
 140         if (!force && CIRBUF_IS_EMPTY(&rdl->right))
 141                 return;
 142
 143         rdline_puts(rdl, vt100_clear_right);
 144         CIRBUF_FOREACH(&rdl->right, i, tmp) {
 145                 rdl->write_char(rdl, tmp);
 146         }
 147         if (!CIRBUF_IS_EMPTY(&rdl->right))
 148                 rdline_miniprintf(rdl, vt100_multi_left,
 149                                   CIRBUF_GET_LEN(&rdl->right));
 150 }
 151
 152 void
 153 rdline_redisplay(struct rdline *rdl)
 154 {
 155         unsigned int i;
 156         char tmp;
 157
 158         if (!rdl)
 159                 return;
 160
 161         rdline_puts(rdl, vt100_home);
 162         for (i=0 ; i<rdl->prompt_size ; i++)
 163                 rdl->write_char(rdl, rdl->prompt[i]);
 164         CIRBUF_FOREACH(&rdl->left, i, tmp) {
 165                 rdl->write_char(rdl, tmp);
 166         }
 167         display_right_buffer(rdl, 1);
 168 }
 169
 170 int
 171 rdline_char_in(struct rdline *rdl, char c)
 172 {
 173         unsigned int i;
 174         int cmd;
 175         char tmp;
 176         char *buf;
 177
 178         if (!rdl)
 179                 return -EINVAL;
 180
 181         if (rdl->status == RDLINE_EXITED)
 182                 return RDLINE_RES_EXITED;
 183         if (rdl->status != RDLINE_RUNNING)
 184                 return RDLINE_RES_NOT_RUNNING;
 185
 186         cmd = vt100_parser(&rdl->vt100, c);
 187         if (cmd == -2)
 188                 return RDLINE_RES_SUCCESS;
 189
 190         if (cmd >= 0) {
 191                 switch (cmd) {
 192                 /* move caret 1 char to the left */
 193                 case CMDLINE_KEY_CTRL_B:
 194                 case CMDLINE_KEY_LEFT_ARR:
 195                         if (CIRBUF_IS_EMPTY(&rdl->left))
 196                                 break;
 197                         tmp = cirbuf_get_tail(&rdl->left);
 198                         cirbuf_del_tail(&rdl->left);
 199                         cirbuf_add_head(&rdl->right, tmp);
 200                         rdline_puts(rdl, vt100_left_arr);
 201                         break;
 202
 203                 /* move caret 1 char to the right */
 204                 case CMDLINE_KEY_CTRL_F:
 205                 case CMDLINE_KEY_RIGHT_ARR:
 206                         if (CIRBUF_IS_EMPTY(&rdl->right))
 207                                 break;
 208                         tmp = cirbuf_get_head(&rdl->right);
 209                         cirbuf_del_head(&rdl->right);
 210                         cirbuf_add_tail(&rdl->left, tmp);
 211                         rdline_puts(rdl, vt100_right_arr);
 212                         break;
 213
 214                 /* move caret 1 word to the left */
 215                 /* keyboard equivalent: Alt+B */
 216                 case CMDLINE_KEY_WLEFT:
 217                         while (! CIRBUF_IS_EMPTY(&rdl->left) &&
 218                                (tmp = cirbuf_get_tail(&rdl->left)) &&
 219                                isblank2(tmp)) {
 220                                 rdline_puts(rdl, vt100_left_arr);
 221                                 cirbuf_del_tail(&rdl->left);
 222                                 cirbuf_add_head(&rdl->right, tmp);
 223                         }
 224                         while (! CIRBUF_IS_EMPTY(&rdl->left) &&
 225                                (tmp = cirbuf_get_tail(&rdl->left)) &&
 226                                !isblank2(tmp)) {
 227                                 rdline_puts(rdl, vt100_left_arr);
 228                                 cirbuf_del_tail(&rdl->left);
 229                                 cirbuf_add_head(&rdl->right, tmp);
 230                         }
 231                         break;
 232
 233                 /* move caret 1 word to the right */
 234                 /* keyboard equivalent: Alt+F */
 235                 case CMDLINE_KEY_WRIGHT:
 236                         while (! CIRBUF_IS_EMPTY(&rdl->right) &&
 237                                (tmp = cirbuf_get_head(&rdl->right)) &&
 238                                isblank2(tmp)) {
 239                                 rdline_puts(rdl, vt100_right_arr);
 240                                 cirbuf_del_head(&rdl->right);
 241                                 cirbuf_add_tail(&rdl->left, tmp);
 242                         }
 243                         while (! CIRBUF_IS_EMPTY(&rdl->right) &&
 244                                (tmp = cirbuf_get_head(&rdl->right)) &&
 245                                !isblank2(tmp)) {
 246                                 rdline_puts(rdl, vt100_right_arr);
 247                                 cirbuf_del_head(&rdl->right);
 248                                 cirbuf_add_tail(&rdl->left, tmp);
 249                         }
 250                         break;
 251
 252                 /* move caret to the left */
 253                 case CMDLINE_KEY_CTRL_A:
 254                         if (CIRBUF_IS_EMPTY(&rdl->left))
 255                                 break;
 256                         rdline_miniprintf(rdl, vt100_multi_left,
 257                                                 CIRBUF_GET_LEN(&rdl->left));
 258                         while (! CIRBUF_IS_EMPTY(&rdl->left)) {
 259                                 tmp = cirbuf_get_tail(&rdl->left);
 260                                 cirbuf_del_tail(&rdl->left);
 261                                 cirbuf_add_head(&rdl->right, tmp);
 262                         }
 263                         break;
 264
 265                 /* move caret to the right */
 266                 case CMDLINE_KEY_CTRL_E:
 267                         if (CIRBUF_IS_EMPTY(&rdl->right))
 268                                 break;
 269                         rdline_miniprintf(rdl, vt100_multi_right,
 270                                                 CIRBUF_GET_LEN(&rdl->right));
 271                         while (! CIRBUF_IS_EMPTY(&rdl->right)) {
 272                                 tmp = cirbuf_get_head(&rdl->right);
 273                                 cirbuf_del_head(&rdl->right);
 274                                 cirbuf_add_tail(&rdl->left, tmp);
 275                         }
 276                         break;
 277
 278                 /* delete 1 char from the left */
 279                 case CMDLINE_KEY_BKSPACE:
 280                 case CMDLINE_KEY_BKSPACE2:
 281                         if(!cirbuf_del_tail_safe(&rdl->left)) {
 282                                 rdline_puts(rdl, vt100_bs);
 283                                 display_right_buffer(rdl, 1);
 284                         }
 285                         break;
 286
 287                 /* delete 1 char from the right */
 288                 case CMDLINE_KEY_SUPPR:
 289                 case CMDLINE_KEY_CTRL_D:
 290                         if (cmd == CMDLINE_KEY_CTRL_D &&
 291                             CIRBUF_IS_EMPTY(&rdl->left) &&
 292                             CIRBUF_IS_EMPTY(&rdl->right)) {
 293                                 return RDLINE_RES_EOF;
 294                         }
 295                         if (!cirbuf_del_head_safe(&rdl->right)) {
 296                                 display_right_buffer(rdl, 1);
 297                         }
 298                         break;
 299
 300                 /* delete 1 word from the left */
 301                 case CMDLINE_KEY_META_BKSPACE:
 302                 case CMDLINE_KEY_CTRL_W:
 303                         while (! CIRBUF_IS_EMPTY(&rdl->left) && isblank2(cirbuf_get_tail(&rdl->left))) {
 304                                 rdline_puts(rdl, vt100_bs);
 305                                 cirbuf_del_tail(&rdl->left);
 306                         }
 307                         while (! CIRBUF_IS_EMPTY(&rdl->left) && !isblank2(cirbuf_get_tail(&rdl->left))) {
 308                                 rdline_puts(rdl, vt100_bs);
 309                                 cirbuf_del_tail(&rdl->left);
 310                         }
 311                         display_right_buffer(rdl, 1);
 312                         break;
 313
 314                 /* delete 1 word from the right */
 315                 case CMDLINE_KEY_META_D:
 316                         while (! CIRBUF_IS_EMPTY(&rdl->right) && isblank2(cirbuf_get_head(&rdl->right)))
 317                                 cirbuf_del_head(&rdl->right);
 318                         while (! CIRBUF_IS_EMPTY(&rdl->right) && !isblank2(cirbuf_get_head(&rdl->right)))
 319                                 cirbuf_del_head(&rdl->right);
 320                         display_right_buffer(rdl, 1);
 321                         break;
 322
 323                 /* set kill buffer to contents on the right side of caret */
 324                 case CMDLINE_KEY_CTRL_K:
 325                         cirbuf_get_buf_head(&rdl->right, rdl->kill_buf, RDLINE_BUF_SIZE);
 326                         rdl->kill_size = CIRBUF_GET_LEN(&rdl->right);
 327                         cirbuf_del_buf_head(&rdl->right, rdl->kill_size);
 328                         rdline_puts(rdl, vt100_clear_right);
 329                         break;
 330
 331                 /* paste contents of kill buffer to the left side of caret */
 332                 case CMDLINE_KEY_CTRL_Y:
 333                         i=0;
 334                         while(CIRBUF_GET_LEN(&rdl->right) + CIRBUF_GET_LEN(&rdl->left) <
 335                               RDLINE_BUF_SIZE &&
 336                               i < rdl->kill_size) {
 337                                 cirbuf_add_tail(&rdl->left, rdl->kill_buf[i]);
 338                                 rdl->write_char(rdl, rdl->kill_buf[i]);
 339                                 i++;
 340                         }
 341                         display_right_buffer(rdl, 0);
 342                         break;
 343
 344                 /* clear and newline */
 345                 case CMDLINE_KEY_CTRL_C:
 346                         rdline_puts(rdl, "\r\n");
 347                         rdline_newline(rdl, rdl->prompt);
 348                         break;
 349
 350                 /* redisplay (helps when prompt is lost in other output) */
 351                 case CMDLINE_KEY_CTRL_L:
 352                         rdline_redisplay(rdl);
 353                         break;
 354
 355                 /* autocomplete */
 356                 case CMDLINE_KEY_TAB:
 357                 case CMDLINE_KEY_HELP:
 358                         cirbuf_align_left(&rdl->left);
 359                         rdl->left_buf[CIRBUF_GET_LEN(&rdl->left)] = '\0';
 360                         if (rdl->complete) {
 361                                 char tmp_buf[BUFSIZ];
 362                                 int complete_state;
 363                                 int ret;
 364                                 unsigned int tmp_size;
 365
 366                                 if (cmd == CMDLINE_KEY_TAB)
 367                                         complete_state = 0;
 368                                 else
 369                                         complete_state = -1;
 370
 371                                 /* see in parse.h for help on complete() */
 372                                 ret = rdl->complete(rdl, rdl->left_buf,
 373                                                     tmp_buf, sizeof(tmp_buf),
 374                                                     &complete_state);
 375                                 /* no completion or error */
 376                                 if (ret <= 0) {
 377                                         return RDLINE_RES_COMPLETE;
 378                                 }
 379
 380                                 tmp_size = strnlen(tmp_buf, sizeof(tmp_buf));
 381                                 /* add chars */
 382                                 if (ret == RDLINE_RES_COMPLETE) {
 383                                         i=0;
 384                                         while(CIRBUF_GET_LEN(&rdl->right) + CIRBUF_GET_LEN(&rdl->left) <
 385                                               RDLINE_BUF_SIZE &&
 386                                               i < tmp_size) {
 387                                                 cirbuf_add_tail(&rdl->left, tmp_buf[i]);
 388                                                 rdl->write_char(rdl, tmp_buf[i]);
 389                                                 i++;
 390                                         }
 391                                         display_right_buffer(rdl, 1);
 392                                         return RDLINE_RES_COMPLETE; /* ?? */
 393                                 }
 394
 395                                 /* choice */
 396                                 rdline_puts(rdl, "\r\n");
 397                                 while (ret) {
 398                                         rdl->write_char(rdl, ' ');
 399                                         for (i=0 ; tmp_buf[i] ; i++)
 400                                                 rdl->write_char(rdl, tmp_buf[i]);
 401                                         rdline_puts(rdl, "\r\n");
 402                                         ret = rdl->complete(rdl, rdl->left_buf,
 403                                                             tmp_buf, sizeof(tmp_buf),
 404                                                             &complete_state);
 405                                 }
 406
 407                                 rdline_redisplay(rdl);
 408                         }
 409                         return RDLINE_RES_COMPLETE;
 410
 411                 /* complete buffer */
 412                 case CMDLINE_KEY_RETURN:
 413                 case CMDLINE_KEY_RETURN2:
 414                         rdline_get_buffer(rdl);
 415                         rdl->status = RDLINE_INIT;
 416                         rdline_puts(rdl, "\r\n");
 417                         if (rdl->history_cur_line != -1)
 418                                 rdline_remove_first_history_item(rdl);
 419
 420                         if (rdl->validate)
 421                                 rdl->validate(rdl, rdl->left_buf, CIRBUF_GET_LEN(&rdl->left)+2);
 422                         /* user may have stopped rdline */
 423                         if (rdl->status == RDLINE_EXITED)
 424                                 return RDLINE_RES_EXITED;
 425                         return RDLINE_RES_VALIDATED;
 426
 427                 /* previous element in history */
 428                 case CMDLINE_KEY_UP_ARR:
 429                 case CMDLINE_KEY_CTRL_P:
 430                         if (rdl->history_cur_line == 0) {
 431                                 rdline_remove_first_history_item(rdl);
 432                         }
 433                         if (rdl->history_cur_line <= 0) {
 434                                 rdline_add_history(rdl, rdline_get_buffer(rdl));
 435                                 rdl->history_cur_line = 0;
 436                         }
 437
 438                         buf = rdline_get_history_item(rdl, rdl->history_cur_line + 1);
 439                         if (!buf)
 440                                 break;
 441
 442                         rdl->history_cur_line ++;
 443                         vt100_init(&rdl->vt100);
 444                         cirbuf_init(&rdl->left, rdl->left_buf, 0, RDLINE_BUF_SIZE);
 445                         cirbuf_init(&rdl->right, rdl->right_buf, 0, RDLINE_BUF_SIZE);
 446                         cirbuf_add_buf_tail(&rdl->left, buf, strnlen(buf, RDLINE_BUF_SIZE));
 447                         rdline_redisplay(rdl);
 448                         break;
 449
 450                 /* next element in history */
 451                 case CMDLINE_KEY_DOWN_ARR:
 452                 case CMDLINE_KEY_CTRL_N:
 453                         if (rdl->history_cur_line - 1 < 0)
 454                                 break;
 455
 456                         rdl->history_cur_line --;
 457                         buf = rdline_get_history_item(rdl, rdl->history_cur_line);
 458                         if (!buf)
 459                                 break;
 460                         vt100_init(&rdl->vt100);
 461                         cirbuf_init(&rdl->left, rdl->left_buf, 0, RDLINE_BUF_SIZE);
 462                         cirbuf_init(&rdl->right, rdl->right_buf, 0, RDLINE_BUF_SIZE);
 463                         cirbuf_add_buf_tail(&rdl->left, buf, strnlen(buf, RDLINE_BUF_SIZE));
 464                         rdline_redisplay(rdl);
 465
 466                         break;
 467
 468
 469                 default:
 470                         break;
 471                 }
 472
 473                 return RDLINE_RES_SUCCESS;
 474         }
 475
 476         if (!isprint((int)c))
 477                 return RDLINE_RES_SUCCESS;
 478
 479         /* standard chars */
 480         if (CIRBUF_GET_LEN(&rdl->left) + CIRBUF_GET_LEN(&rdl->right) >= RDLINE_BUF_SIZE)
 481                 return RDLINE_RES_SUCCESS;
 482
 483         if (cirbuf_add_tail_safe(&rdl->left, c))
 484                 return RDLINE_RES_SUCCESS;
 485
 486         rdl->write_char(rdl, c);
 487         display_right_buffer(rdl, 0);
 488
 489         return RDLINE_RES_SUCCESS;
 490 }
 491
 492
 493 /* HISTORY */
 494
 495 static void
 496 rdline_remove_old_history_item(struct rdline * rdl)
 497 {
 498         char tmp;
 499
 500         while (! CIRBUF_IS_EMPTY(&rdl->history) ) {
 501                 tmp = cirbuf_get_head(&rdl->history);
 502                 cirbuf_del_head(&rdl->history);
 503                 if (!tmp)
 504                         break;
 505         }
 506 }
 507
 508 static void
 509 rdline_remove_first_history_item(struct rdline * rdl)
 510 {
 511         char tmp;
 512
 513         if ( CIRBUF_IS_EMPTY(&rdl->history) ) {
 514                 return;
 515         }
 516         else {
 517                 cirbuf_del_tail(&rdl->history);
 518         }
 519
 520         while (! CIRBUF_IS_EMPTY(&rdl->history) ) {
 521                 tmp = cirbuf_get_tail(&rdl->history);
 522                 if (!tmp)
 523                         break;
 524                 cirbuf_del_tail(&rdl->history);
 525         }
 526 }
 527
 528 static unsigned int
 529 rdline_get_history_size(struct rdline * rdl)
 530 {
 531         unsigned int i, tmp, ret=0;
 532
 533         CIRBUF_FOREACH(&rdl->history, i, tmp) {
 534                 if (tmp == 0)
 535                         ret ++;
 536         }
 537
 538         return ret;
 539 }
 540
 541 char *
 542 rdline_get_history_item(struct rdline * rdl, unsigned int idx)
 543 {
 544         unsigned int len, i, tmp;
 545
 546         if (!rdl)
 547                 return NULL;
 548
 549         len = rdline_get_history_size(rdl);
 550         if ( idx >= len ) {
 551                 return NULL;
 552         }
 553
 554         cirbuf_align_left(&rdl->history);
 555
 556         CIRBUF_FOREACH(&rdl->history, i, tmp) {
 557                 if ( idx == len - 1) {
 558                         return rdl->history_buf + i;
 559                 }
 560                 if (tmp == 0)
 561                         len --;
 562         }
 563
 564         return NULL;
 565 }
 566
 567 int
 568 rdline_add_history(struct rdline * rdl, const char * buf)
 569 {
 570         unsigned int len, i;
 571
 572         if (!rdl || !buf)
 573                 return -EINVAL;
 574
 575         len = strnlen(buf, RDLINE_BUF_SIZE);
 576         for (i=0; i<len ; i++) {
 577                 if (buf[i] == '\n') {
 578                         len = i;
 579                         break;
 580                 }
 581         }
 582
 583         if ( len >= RDLINE_HISTORY_BUF_SIZE )
 584                 return -1;
 585
 586         while ( len >= CIRBUF_GET_FREELEN(&rdl->history) ) {
 587                 rdline_remove_old_history_item(rdl);
 588         }
 589
 590         cirbuf_add_buf_tail(&rdl->history, buf, len);
 591         cirbuf_add_tail(&rdl->history, 0);
 592
 593         return 0;
 594 }
 595
 596 void
 597 rdline_clear_history(struct rdline * rdl)
 598 {
 599         if (!rdl)
 600                 return;
 601         cirbuf_init(&rdl->history, rdl->history_buf, 0, RDLINE_HISTORY_BUF_SIZE);
 602 }
 603
 604
 605 /* STATIC USEFUL FUNCS */
 606
 607 static void
 608 rdline_puts(struct rdline * rdl, const char * buf)
 609 {
 610         char c;
 611         while ( (c = *(buf++)) != '\0' ) {
 612                 rdl->write_char(rdl, c);
 613         }
 614 }
 615
 616 /* a very very basic printf with one arg and one format 'u' */
 617 static void
 618 rdline_miniprintf(struct rdline *rdl, const char * buf, unsigned int val)
 619 {
 620         char c, started=0, div=100;
 621
 622         while ( (c=*(buf++)) ) {
 623                 if (c != '%') {
 624                         rdl->write_char(rdl, c);
 625                         continue;
 626                 }
 627                 c = *(buf++);
 628                 if (c != 'u') {
 629                         rdl->write_char(rdl, '%');
 630                         rdl->write_char(rdl, c);
 631                         continue;
 632                 }
 633                 /* val is never more than 255 */
 634                 while (div) {
 635                         c = (char)(val / div);
 636                         if (c || started) {
 637                                 rdl->write_char(rdl, (char)(c+'0'));
 638                                 started = 1;
 639                         }
 640                         val %= div;
 641                         div /= 10;
 642                 }
 643         }
 644 }