root/src/tparam.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. tparam
  2. tgoto
  3. tparam1
  4. main

     1 /* Merge parameters into a termcap entry string.
     2    Copyright (C) 1985, 1987, 1993, 1995, 2000-2008, 2013-2023 Free
     3    Software Foundation, Inc.
     4 
     5 This program is free software; you can redistribute it and/or modify
     6 it under the terms of the GNU General Public License as published by
     7 the Free Software Foundation; either version 2, or (at your option)
     8 any later version.
     9 
    10 This program is distributed in the hope that it will be useful,
    11 but WITHOUT ANY WARRANTY; without even the implied warranty of
    12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    13 GNU General Public License for more details.
    14 
    15 You should have received a copy of the GNU General Public License
    16 along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
    17 
    18 /* Emacs config.h may rename various library functions such as malloc.  */
    19 #include <config.h>
    20 
    21 #include "lisp.h"               /* for xmalloc */
    22 #include "tparam.h"
    23 
    24 /* Assuming STRING is the value of a termcap string entry
    25    containing `%' constructs to expand parameters,
    26    merge in parameter values and store result in block OUTSTRING points to.
    27    LEN is the length of OUTSTRING.  If more space is needed,
    28    a block is allocated with `malloc'.
    29 
    30    The value returned is the address of the resulting string.
    31    This may be OUTSTRING or may be the address of a block got with `malloc'.
    32    In the latter case, the caller must free the block.
    33 
    34    The fourth and following args to tparam serve as the parameter values.  */
    35 
    36 static char *tparam1 (char const *string, char *outstring, int len,
    37                       char *up, char *left, int *argp);
    38 
    39 char *
    40 tparam (const char *string, char *outstring, int len,
    41         int arg0, int arg1, int arg2, int arg3)
    42 {
    43   int arg[4];
    44 
    45   arg[0] = arg0;
    46   arg[1] = arg1;
    47   arg[2] = arg2;
    48   arg[3] = arg3;
    49   return tparam1 (string, outstring, len, NULL, NULL, arg);
    50 }
    51 
    52 char *BC;
    53 char *UP;
    54 
    55 static char tgoto_buf[50];
    56 
    57 char *
    58 tgoto (const char *cm, int hpos, int vpos)
    59 {
    60   int args[2];
    61   if (!cm)
    62     return NULL;
    63   args[0] = vpos;
    64   args[1] = hpos;
    65   return tparam1 (cm, tgoto_buf, 50, UP, BC, args);
    66 }
    67 
    68 static char *
    69 tparam1 (const char *string, char *outstring, int len,
    70          char *up, char *left, register int *argp)
    71 {
    72   register int c;
    73   register const char *p = string;
    74   register char *op = outstring;
    75   char *outend;
    76   char *new = 0;
    77   ptrdiff_t outlen = 0;
    78 
    79   register int tem;
    80   int *old_argp = argp;                 /* can move */
    81   int *fixed_argp = argp;               /* never moves */
    82   bool explicit_param_p = false;        /* set by %p */
    83   ptrdiff_t doleft = 0;
    84   ptrdiff_t doup = 0;
    85   ptrdiff_t append_len = 0;
    86 
    87   outend = outstring + len;
    88 
    89   while (true)
    90     {
    91       /* If the buffer might be too short, make it bigger.  */
    92       while (outend - op - append_len <= 5)
    93         {
    94           ptrdiff_t offset = op - outstring;
    95 
    96           if (outlen == 0)
    97             {
    98               outlen = len + 40;
    99               new = xmalloc (outlen);
   100               memcpy (new, outstring, offset);
   101             }
   102           else
   103             {
   104               new = xpalloc (outstring, &outlen, 1, -1, 1);
   105             }
   106 
   107           op = new + offset;
   108           outend = new + outlen;
   109           outstring = new;
   110         }
   111       c = *p++;
   112       if (!c)
   113         break;
   114       if (c == '%')
   115         {
   116           c = *p++;
   117           if (explicit_param_p)
   118             explicit_param_p = false;
   119           else
   120             tem = *argp;
   121           switch (c)
   122             {
   123             case 'd':           /* %d means output in decimal.  */
   124               if (tem < 10)
   125                 goto onedigit;
   126               if (tem < 100)
   127                 goto twodigit;
   128               FALLTHROUGH;
   129             case '3':           /* %3 means output in decimal, 3 digits.  */
   130               if (tem > 999)
   131                 {
   132                   *op++ = tem / 1000 + '0';
   133                   tem %= 1000;
   134                 }
   135               *op++ = tem / 100 + '0';
   136               FALLTHROUGH;
   137             case '2':           /* %2 means output in decimal, 2 digits.  */
   138             twodigit:
   139               tem %= 100;
   140               *op++ = tem / 10 + '0';
   141             onedigit:
   142               *op++ = tem % 10 + '0';
   143               argp++;
   144               break;
   145 
   146             case 'p':           /* %pN means use param N for next subst.  */
   147               tem = fixed_argp[(*p++) - '1'];
   148               explicit_param_p = true;
   149               break;
   150 
   151             case 'C':
   152               /* For c-100: print quotient of value by 96, if nonzero,
   153                  then do like %+.  */
   154               if (tem >= 96)
   155                 {
   156                   *op++ = tem / 96;
   157                   tem %= 96;
   158                 }
   159               FALLTHROUGH;
   160             case '+':           /* %+x means add character code of char x.  */
   161               tem += *p++;
   162               FALLTHROUGH;
   163             case '.':           /* %. means output as character.  */
   164               if (left)
   165                 {
   166                   /* If want to forbid output of 0 and \n and \t,
   167                      and this is one of them, increment it.  */
   168                   while (tem == 0 || tem == '\n' || tem == '\t')
   169                     {
   170                       ptrdiff_t append_len_incr;
   171                       tem++;
   172                       if (argp == old_argp)
   173                         doup++, append_len_incr = strlen (up);
   174                       else
   175                         doleft++, append_len_incr = strlen (left);
   176                       if (ckd_add (&append_len, append_len, append_len_incr))
   177                         memory_full (SIZE_MAX);
   178                     }
   179                 }
   180               *op++ = tem ? tem : 0200;
   181               FALLTHROUGH;
   182             case 'f':           /* %f means discard next arg.  */
   183               argp++;
   184               break;
   185 
   186             case 'b':           /* %b means back up one arg (and re-use it).  */
   187               argp--;
   188               break;
   189 
   190             case 'r':           /* %r means interchange following two args.  */
   191               argp[0] = argp[1];
   192               argp[1] = tem;
   193               old_argp++;
   194               break;
   195 
   196             case '>':           /* %>xy means if arg is > char code of x, */
   197               if (argp[0] > *p++) /* then add char code of y to the arg, */
   198                 argp[0] += *p;  /* and in any case don't output.  */
   199               p++;              /* Leave the arg to be output later.  */
   200               break;
   201 
   202             case 'a':           /* %a means arithmetic.  */
   203               /* Next character says what operation.
   204                  Add or subtract either a constant or some other arg.  */
   205               /* First following character is + to add or - to subtract
   206                  or = to assign.  */
   207               /* Next following char is 'p' and an arg spec
   208                  (0100 plus position of that arg relative to this one)
   209                  or 'c' and a constant stored in a character.  */
   210               tem = p[2] & 0177;
   211               if (p[1] == 'p')
   212                 tem = argp[tem - 0100];
   213               if (p[0] == '-')
   214                 argp[0] -= tem;
   215               else if (p[0] == '+')
   216                 argp[0] += tem;
   217               else if (p[0] == '*')
   218                 argp[0] *= tem;
   219               else if (p[0] == '/')
   220                 argp[0] /= tem;
   221               else
   222                 argp[0] = tem;
   223 
   224               p += 3;
   225               break;
   226 
   227             case 'i':           /* %i means add one to arg, */
   228               argp[0] ++;       /* and leave it to be output later.  */
   229               argp[1] ++;       /* Increment the following arg, too!  */
   230               break;
   231 
   232             case '%':           /* %% means output %; no arg.  */
   233               goto ordinary;
   234 
   235             case 'n':           /* %n means xor each of next two args with 140.  */
   236               argp[0] ^= 0140;
   237               argp[1] ^= 0140;
   238               break;
   239 
   240             case 'm':           /* %m means xor each of next two args with 177.  */
   241               argp[0] ^= 0177;
   242               argp[1] ^= 0177;
   243               break;
   244 
   245             case 'B':           /* %B means express arg as BCD char code.  */
   246               argp[0] += 6 * (tem / 10);
   247               break;
   248 
   249             case 'D':           /* %D means weird Delta Data transformation.  */
   250               argp[0] -= 2 * (tem % 16);
   251               break;
   252 
   253             default:
   254               emacs_abort ();
   255             }
   256         }
   257       else
   258         /* Ordinary character in the argument string.  */
   259       ordinary:
   260         *op++ = c;
   261     }
   262   *op = 0;
   263   while (doup-- > 0)
   264     op = stpcpy (op, up);
   265   while (doleft-- > 0)
   266     op = stpcpy (op, left);
   267   return outstring;
   268 }
   269 
   270 #ifdef DEBUG
   271 
   272 int
   273 main (int argc, char **argv)
   274 {
   275   char buf[50];
   276   int args[3];
   277   args[0] = atoi (argv[2]);
   278   args[1] = atoi (argv[3]);
   279   args[2] = atoi (argv[4]);
   280   tparam1 (argv[1], buf, 50, "LEFT", "UP", args);
   281   printf ("%s\n", buf);
   282   return 0;
   283 }
   284 
   285 #endif /* DEBUG */

/* [<][>][^][v][top][bottom][index][help] */