Return to tparam.c CVS log

Up to [Apple XNU] / GNUtools / emacs / src

Annotation of GNUtools/emacs/src/tparam.c, revision 1.1

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.