lib/libterminfo/tparm.c

   1 /* $NetBSD: tparm.c,v 1.8 2012/06/02 19:10:33 roy Exp $ */
   2
   3 /*
   4  * Copyright (c) 2009, 2011 The NetBSD Foundation, Inc.
   5  *
   6  * This code is derived from software contributed to The NetBSD Foundation
   7  * by Roy Marples.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __RCSID("$NetBSD: tparm.c,v 1.8 2012/06/02 19:10:33 roy Exp $");
  32 #include <sys/param.h>
  33
  34 #include <assert.h>
  35 #include <ctype.h>
  36 #include <errno.h>
  37 #include <stdarg.h>
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include <term_private.h>
  42 #include <term.h>
  43
  44 static TERMINAL *dumbterm; /* For non thread safe functions */
  45
  46 typedef struct {
  47         int nums[20];
  48         char *strings[20];
  49         size_t offset;
  50 } TPSTACK;
  51
  52 typedef struct {
  53         int num;
  54         char *string;
  55 } TPVAR;
  56
  57 static int
  58 push(int num, char *string, TPSTACK *stack)
  59 {
  60         if (stack->offset > sizeof(stack->nums)) {
  61                 errno = E2BIG;
  62                 return -1;
  63         }
  64         stack->nums[stack->offset] = num;
  65         stack->strings[stack->offset] = string;
  66         stack->offset++;
  67         return 0;
  68 }
  69
  70 static int
  71 pop(int *num, char **string, TPSTACK *stack)
  72 {
  73         if (stack->offset == 0) {
  74                 if (num)
  75                         *num = 0;
  76                 if (string)
  77                         *string = NULL;
  78                 errno = E2BIG;
  79                 return -1;
  80         }
  81         stack->offset--;
  82         if (num)
  83                 *num = stack->nums[stack->offset];
  84         if (string)
  85                 *string = stack->strings[stack->offset];
  86         return 0;
  87 }
  88
  89 static char *
  90 checkbuf(TERMINAL *term, size_t len)
  91 {
  92         char *buf;
  93
  94         if (term->_bufpos + len >= term->_buflen) {
  95                 len = term->_buflen + MAX(len, BUFSIZ);
  96                 buf = realloc(term->_buf, len);
  97                 if (buf == NULL)
  98                         return NULL;
  99                 term->_buf = buf;
 100                 term->_buflen = len;
 101         }
 102         return term->_buf;
 103 }
 104
 105 static size_t
 106 ochar(TERMINAL *term, int c)
 107 {
 108         if (c == 0)
 109                 c = 0200;
 110         /* Check we have space and a terminator */
 111         if (checkbuf(term, 2) == NULL)
 112                 return 0;
 113         term->_buf[term->_bufpos++] = (char)c;
 114         return 1;
 115 }
 116
 117 static size_t
 118 onum(TERMINAL *term, const char *fmt, int num, int len)
 119 {
 120         size_t l;
 121
 122         /* Assume we never have natural number longer than 64 chars */
 123         if (len < 64)
 124                 len = 64;
 125         if (checkbuf(term, (size_t)len + 1) == NULL)
 126                 return 0;
 127         l = sprintf(term->_buf + term->_bufpos, fmt, num);
 128         term->_bufpos += l;
 129         return l;
 130 }
 131
 132 static char *
 133 _ti_tiparm(TERMINAL *term, const char *str, va_list parms)
 134 {
 135         const char *sp;
 136         char c, fmt[64], *fp, *ostr;
 137         int val, val2;
 138         int dnums[26]; /* dynamic variables a-z, not preserved */
 139         size_t l, max;
 140         TPSTACK stack;
 141         TPVAR params[9];
 142         int done, dot, minus, width, precision, olen;
 143         int piss[9]; /* Parameter IS String - piss ;) */
 144
 145         if (str == NULL)
 146                 return NULL;
 147
 148         /*
 149           If not passed a terminal, malloc a dummy one.
 150           This means we can preserve buffers and variables per terminal and
 151           still work with non thread safe functions (which sadly are still the
 152           norm and standard).
 153         */
 154
 155         if (term == NULL) {
 156                 if (dumbterm == NULL) {
 157                         dumbterm = malloc(sizeof(*dumbterm));
 158                         if (dumbterm == NULL)
 159                                 return NULL;
 160                         dumbterm->_buflen = 0;
 161                 }
 162                 term = dumbterm;
 163         }
 164
 165         term->_bufpos = 0;
 166         /* Ensure we have an initial buffer */
 167         if (term->_buflen == 0) {
 168                 term->_buf = malloc(BUFSIZ);
 169                 if (term->_buf == NULL)
 170                         return NULL;
 171                 term->_buflen = BUFSIZ;
 172         }
 173
 174         /*
 175           Make a first pass through the string so we can work out
 176           which parameters are ints and which are char *.
 177           Basically we only use char * if %p[1-9] is followed by %l or %s.
 178         */
 179         memset(&piss, 0, sizeof(piss));
 180         max = 0;
 181         sp = str;
 182         while ((c = *sp++) != '\0') {
 183                 if (c != '%')
 184                         continue;
 185                 c = *sp++;
 186                 if (c == '\0')
 187                         break;
 188                 if (c != 'p')
 189                         continue;
 190                 c = *sp++;
 191                 if (c < '1' || c > '9') {
 192                         errno = EINVAL;
 193                         continue;
 194                 }
 195                 l = c - '0';
 196                 if (l > max)
 197                         max = l;
 198                 if (*sp != '%')
 199                         continue;
 200                 /* Skip formatting */
 201                 sp++;
 202                 while (*sp == '.' || *sp == '#' || *sp == ' ' || *sp == ':' ||
 203                     *sp == '-' || isdigit((unsigned char)*sp))
 204                         sp++;
 205                 if (*sp == 'l' || *sp == 's')
 206                         piss[l - 1] = 1;
 207         }
 208
 209         /* Put our parameters into variables */
 210         memset(&params, 0, sizeof(params));
 211         for (l = 0; l < max; l++) {
 212                 if (piss[l] == 0)
 213                         params[l].num = va_arg(parms, int);
 214                 else
 215                         params[l].string = va_arg(parms, char *);
 216         }
 217
 218         term->_bufpos = 0;
 219         memset(&stack, 0, sizeof(stack));
 220         while ((c = *str++) != '\0') {
 221                 if (c != '%' || (c = *str++) == '%') {
 222                         if (c == '\0')
 223                                 break;
 224                         if (ochar(term, c) == 0)
 225                                 return NULL;
 226                         continue;
 227                 }
 228
 229                 /* Handle formatting. */
 230                 fp = fmt;
 231                 *fp++ = '%';
 232                 done = dot = minus = width = precision = 0;
 233                 val = 0;
 234                 while (done == 0 && (size_t)(fp - fmt) < sizeof(fmt)) {
 235                         switch (c) {
 236                         case 'c': /* FALLTHROUGH */
 237                         case 'd': /* FALLTHROUGH */
 238                         case 'o': /* FALLTHROUGH */
 239                         case 'x': /* FALLTHROUGH */
 240                         case 'X': /* FALLTHROUGH */
 241                         case 's':
 242                                 *fp++ = c;
 243                                 done = 1;
 244                                 break;
 245                         case '#': /* FALLTHROUGH */
 246                         case ' ':
 247                                 *fp++ = c;
 248                                 break;
 249                         case '.':
 250                                 *fp++ = c;
 251                                 if (dot == 0) {
 252                                         dot = 1;
 253                                         width = val;
 254                                 } else
 255                                         done = 2;
 256                                 val = 0;
 257                                 break;
 258                         case ':':
 259                                 minus = 1;
 260                                 break;
 261                         case '-':
 262                                 if (minus)
 263                                         *fp++ = c;
 264                                 else
 265                                         done = 1;
 266                                 break;
 267                         default:
 268                                 if (isdigit((unsigned char)c)) {
 269                                         val = (val * 10) + (c - '0');
 270                                         if (val > 10000)
 271                                                 done = 2;
 272                                         else
 273                                                 *fp++ = c;
 274                                 } else
 275                                         done = 1;
 276                         }
 277                         if (done == 0)
 278                                 c = *str++;
 279                 }
 280                 if (done == 2) {
 281                         /* Found an error in the format */
 282                         fp = fmt + 1;
 283                         *fp = *str;
 284                         olen = 0;
 285                 } else {
 286                         if (dot == 0)
 287                                 width = val;
 288                         else
 289                                 precision = val;
 290                         olen = (width > precision) ? width : precision;
 291                 }
 292                 *fp++ = '\0';
 293
 294                 /* Handle commands */
 295                 switch (c) {
 296                 case 'c':
 297                         pop(&val, NULL, &stack);
 298                         if (ochar(term, (unsigned char)val) == 0)
 299                                 return NULL;
 300                         break;
 301                 case 's':
 302                         pop(NULL, &ostr, &stack);
 303                         if (ostr != NULL) {
 304                                 l = strlen(ostr);
 305                                 if (l < (size_t)olen)
 306                                         l = olen;
 307                                 if (checkbuf(term, (size_t)(l + 1)) == NULL)
 308                                         return NULL;
 309                                 l = sprintf(term->_buf + term->_bufpos,
 310                                     fmt, ostr);
 311                                 term->_bufpos += l;
 312                         }
 313                         break;
 314                 case 'l':
 315                         pop(NULL, &ostr, &stack);
 316                         if (ostr == NULL)
 317                                 l = 0;
 318                         else
 319                                 l = strlen(ostr);
 320                         if (onum(term, "%d", (int)l, 0) == 0)
 321                                 return NULL;
 322                         break;
 323                 case 'd': /* FALLTHROUGH */
 324                 case 'o': /* FALLTHROUGH */
 325                 case 'x': /* FALLTHROUGH */
 326                 case 'X':
 327                         pop(&val, NULL, &stack);
 328                         if (onum(term, fmt, val, olen) == 0)
 329                                 return NULL;
 330                         break;
 331                 case 'p':
 332                         if (*str < '1' || *str > '9')
 333                                 break;
 334                         l = *str++ - '1';
 335                         if (push(params[l].num, params[l].string, &stack))
 336                                 return NULL;
 337                         break;
 338                 case 'P':
 339                         pop(&val, NULL, &stack);
 340                         if (*str >= 'a' && *str <= 'z')
 341                                 dnums[*str - 'a'] = val;
 342                         else if (*str >= 'A' && *str <= 'Z')
 343                                 term->_snums[*str - 'A'] = val;
 344                         break;
 345                 case 'g':
 346                         if (*str >= 'a' && *str <= 'z') {
 347                                 if (push(dnums[*str - 'a'], NULL, &stack))
 348                                         return NULL;
 349                         } else if (*str >= 'A' && *str <= 'Z') {
 350                                 if (push(term->_snums[*str - 'A'],
 351                                         NULL, &stack))
 352                                         return NULL;
 353                         }
 354                         break;
 355                 case 'i':
 356                         if (piss[0] == 0)
 357                                 params[0].num++;
 358                         if (piss[1] == 0)
 359                                 params[1].num++;
 360                         break;
 361                 case '\'':
 362                         if (push((int)(unsigned char)*str++, NULL, &stack))
 363                                 return NULL;
 364                         while (*str != '\0' && *str != '\'')
 365                                 str++;
 366                         if (*str == '\'')
 367                                 str++;
 368                         break;
 369                 case '{':
 370                         val = 0;
 371                         for (; isdigit((unsigned char)*str);  str++)
 372                                 val = (val * 10) + (*str - '0');
 373                         if (push(val, NULL, &stack))
 374                                 return NULL;
 375                         while (*str != '\0' && *str != '}')
 376                                 str++;
 377                         if (*str == '}')
 378                                 str++;
 379                         break;
 380                 case '+': /* FALLTHROUGH */
 381                 case '-': /* FALLTHROUGH */
 382                 case '*': /* FALLTHROUGH */
 383                 case '/': /* FALLTHROUGH */
 384                 case 'm': /* FALLTHROUGH */
 385                 case 'A': /* FALLTHROUGH */
 386                 case 'O': /* FALLTHROUGH */
 387                 case '&': /* FALLTHROUGH */
 388                 case '|': /* FALLTHROUGH */
 389                 case '^': /* FALLTHROUGH */
 390                 case '=': /* FALLTHROUGH */
 391                 case '<': /* FALLTHROUGH */
 392                 case '>':
 393                         pop(&val, NULL, &stack);
 394                         pop(&val2, NULL, &stack);
 395                         switch (c) {
 396                         case '+':
 397                                 val = val + val2;
 398                                 break;
 399                         case '-':
 400                                 val = val2 - val;
 401                                 break;
 402                         case '*':
 403                                 val = val * val2;
 404                                 break;
 405                         case '/':
 406                                 val = val ? val2 / val : 0;
 407                                 break;
 408                         case 'm':
 409                                 val = val ? val2 % val : 0;
 410                                 break;
 411                         case 'A':
 412                                 val = val && val2;
 413                                 break;
 414                         case 'O':
 415                                 val = val || val2;
 416                                 break;
 417                         case '&':
 418                                 val = val & val2;
 419                                 break;
 420                         case '|':
 421                                 val = val | val2;
 422                                 break;
 423                         case '^':
 424                                 val = val ^ val2;
 425                                 break;
 426                         case '=':
 427                                 val = val == val2;
 428                                 break;
 429                         case '<':
 430                                 val = val2 < val;
 431                                 break;
 432                         case '>':
 433                                 val = val2 > val;
 434                                 break;
 435                         }
 436                         if (push(val, NULL, &stack))
 437                                 return NULL;
 438                         break;
 439                 case '!':
 440                 case '~':
 441                         pop(&val, NULL, &stack);
 442                         switch (*str) {
 443                         case '!':
 444                                 val = !val;
 445                                 break;
 446                         case '~':
 447                                 val = ~val;
 448                                 break;
 449                         }
 450                         if (push(val, NULL, &stack))
 451                                 return NULL;
 452                         break;
 453                 case '?': /* if */
 454                         break;
 455                 case 't': /* then */
 456                         pop(&val, NULL, &stack);
 457                         if (val != 0) {
 458                                 l = 0;
 459                                 for (; *str != '\0'; str++) {
 460                                         if (*str != '%')
 461                                                 continue;
 462                                         str++;
 463                                         if (*str == '?')
 464                                                 l++;
 465                                         else if (*str == ';') {
 466                                                 if (l > 0)
 467                                                         l--;
 468                                                 else
 469                                                         break;
 470                                         } else if (*str == 'e' && l == 0)
 471                                                 break;
 472                                 }
 473                         }
 474                         break;
 475                 case 'e': /* else */
 476                         l = 0;
 477                         for (; *str != '\0'; str++) {
 478                                 if (*str != '%')
 479                                         continue;
 480                                 str++;
 481                                 if (*str == '?')
 482                                         l++;
 483                                 else if (*str == ';') {
 484                                         if (l > 0)
 485                                                 l--;
 486                                         else
 487                                                 break;
 488                                 }
 489                         }
 490                         break;
 491                 case ';': /* fi */
 492                         break;
 493                 }
 494         }
 495         term->_buf[term->_bufpos] = '\0';
 496         return term->_buf;
 497 }
 498
 499 char *
 500 ti_tiparm(TERMINAL *term, const char *str, ...)
 501 {
 502         va_list va;
 503         char *ret;
 504
 505         _DIAGASSERT(term != NULL);
 506         _DIAGASSERT(str != NULL);
 507
 508         va_start(va, str);
 509         ret = _ti_tiparm(term, str, va);
 510         va_end(va);
 511         return ret;
 512 }
 513
 514 char *
 515 tiparm(const char *str, ...)
 516 {
 517         va_list va;
 518         char *ret;
 519
 520         _DIAGASSERT(str != NULL);
 521
 522         va_start(va, str);
 523         ret = _ti_tiparm(NULL, str, va);
 524         va_end(va);
 525         return ret;
 526 }
 527
 528 char *
 529 tparm(const char *str,
 530     long lp1, long lp2, long lp3, long lp4, long lp5,
 531     long lp6, long lp7, long lp8, long lp9)
 532 {
 533         int p1 = lp1, p2 = lp2, p3 = lp3, p4 = lp4, p5 = lp5;
 534         int p6 = lp6, p7 = lp7, p8 = lp8, p9 = lp9;
 535
 536         return tiparm(str, p1, p2, p3, p4, p5, p6, p7, p8, p9);
 537 }