Return to tparam.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / emacs / src

Annotation of 43BSD/contrib/emacs/src/tparam.c, revision 1.1

1.1     ! root        1: /* Merge parameters into a termcap entry string.
        !             2:    Copyright (C) 1985 Richard M. Stallman.
        !             3: 
        !             4: This file is part of GNU Emacs.
        !             5: 
        !             6: GNU Emacs is distributed in the hope that it will be useful,
        !             7: but WITHOUT ANY WARRANTY.  No author or distributor
        !             8: accepts responsibility to anyone for the consequences of using it
        !             9: or for whether it serves any particular purpose or works at all,
        !            10: unless he says so in writing.  Refer to the GNU Emacs General Public
        !            11: License for full details.
        !            12: 
        !            13: Everyone is granted permission to copy, modify and redistribute
        !            14: GNU Emacs, but only under the conditions described in the
        !            15: GNU Emacs General Public License.   A copy of this license is
        !            16: supposed to have been given to you along with GNU Emacs so you
        !            17: can know your rights and responsibilities.  It should be in a
        !            18: file named COPYING.  Among other things, the copyright notice
        !            19: and this notice must be preserved on all copies.  */
        !            20: 
        !            21: 
        !            22: /* Assuming `string' is the value of a termcap string entry
        !            23:    containing `%' constructs to expand parameters,
        !            24:    merge in parameter values and store result in block `outstring' points to.
        !            25:    No check is made for overflowing `outstring';
        !            26:    the caller is wise to allocate space for it based on the size of
        !            27:    `string', knowing that the size can increase by at most a couple
        !            28:    of characters per parameter.
        !            29:    The third and following args to tparam serve as the parameter values.  */
        !            30: 
        !            31: /* VARARGS 2 */
        !            32: tparam (string, outstring, arg)
        !            33:      char *string;
        !            34:      char *outstring;
        !            35:      int arg;
        !            36: {
        !            37:   tparam1 (string, outstring, 0, 0, &arg);
        !            38: }
        !            39: 
        !            40: char *BC;
        !            41: char *UP;
        !            42: 
        !            43: static char tgoto_buf[50];
        !            44: 
        !            45: char *
        !            46: tgoto (cm, hpos, vpos)
        !            47:      char *cm;
        !            48:      int hpos, vpos;
        !            49: {
        !            50:   int args[2];
        !            51:   if (!cm)
        !            52:     return 0;
        !            53:   args[0] = vpos;
        !            54:   args[1] = hpos;
        !            55:   tparam1 (cm, tgoto_buf, BC, UP, args);
        !            56:   return tgoto_buf;
        !            57: }
        !            58: 
        !            59: tparam1 (string, outstring, up, left, argp)
        !            60:      char *string;
        !            61:      register char *outstring;
        !            62:      char *up, *left;
        !            63:      register int *argp;
        !            64: {
        !            65:   register int c;
        !            66:   register char *p = string;
        !            67: 
        !            68:   register int tem;
        !            69:   int *oargp = argp;
        !            70:   char *oleft = left;
        !            71: 
        !            72:   while (c = *p++)
        !            73:     {
        !            74:       if (c == '%')
        !            75:        {
        !            76:          c = *p++;
        !            77:          tem = *argp;
        !            78:          switch (c)
        !            79:            {
        !            80:            case 'd':           /* %d means output in decimal */
        !            81:              if (tem < 10)
        !            82:                goto onedigit;
        !            83:              if (tem < 100)
        !            84:                goto twodigit;
        !            85:            case '3':           /* %3 means output in decimal, 3 digits. */
        !            86:              *outstring++ = tem / 100 + '0';
        !            87:            case '2':           /* %2 means output in decimal, 2 digits. */
        !            88:            twodigit:
        !            89:              tem %= 100;
        !            90:              *outstring++ = tem / 10 + '0';
        !            91:            onedigit:
        !            92:              *outstring++ = tem % 10 + '0';
        !            93:              argp++;
        !            94:              break;
        !            95: 
        !            96:            case 'C':
        !            97:              /* For c-100: print quotient of value by 96, if nonzero,
        !            98:                 then do like %+ */
        !            99:              if (tem >= 96)
        !           100:                {
        !           101:                  *outstring++ = tem / 96;
        !           102:                  tem %= 96;
        !           103:                }
        !           104:            case '+':           /* %+x means add character code of char x */
        !           105:              tem += *p++;
        !           106:            case '.':           /* %. means output as character */
        !           107:              if (oleft)
        !           108:                {
        !           109:                  /* If want to forbid output of 0 and \n,
        !           110:                     and this is one, increment it.  */
        !           111:                  if (tem == 0 || tem == '\n')
        !           112:                    tem++;
        !           113:                  /* If this isn't one, cancel the compensation string
        !           114:                     that would otherwise compensate for
        !           115:                     the incrementation that we are not going to do.  */
        !           116:                  else
        !           117:                    {
        !           118:                      if (argp == oargp)
        !           119:                        left = 0;
        !           120:                      else
        !           121:                        up = 0;
        !           122:                    }
        !           123:                }
        !           124:              *outstring++ = tem | 0200;
        !           125:            case 'f':           /* %f means discard next arg */
        !           126:              argp++;
        !           127:              break;
        !           128: 
        !           129:            case 'b':           /* %b means back up one arg (and re-use it) */
        !           130:              argp--;
        !           131:              break;
        !           132: 
        !           133:            case 'r':           /* %r means interchange following two args */
        !           134:              argp[0] = argp[1];
        !           135:              argp[1] = tem;
        !           136:              oargp++;
        !           137:              break;
        !           138: 
        !           139:            case '>':           /* %>xy means if arg is > char code of x, */
        !           140:              if (argp[0] > *p++) /* then add char code of y to the arg, */
        !           141:                argp[0] += *p;  /* and in any case don't output. */
        !           142:              p++;              /* Leave the arg to be output later. */
        !           143:              break;
        !           144: 
        !           145:            case 'a':           /* %a means arithmetic */
        !           146:              /* Next character says what operation.
        !           147:                 Add or subtract either a constant or some other arg */
        !           148:              /* First following character is + to add or - to subtract
        !           149:                 or = to assign.  */
        !           150:              /* Next following char is 'p' and an arg spec
        !           151:                 (0100 plus position of that arg relative to this one)
        !           152:                 or 'c' and a constant stored in a character */
        !           153:              tem = p[2] & 0177;
        !           154:              if (p[1] == 'p')
        !           155:                tem = argp[tem - 0100];
        !           156:              if (p[0] == '-')
        !           157:                argp[0] -= tem;
        !           158:              else if (p[0] == '+')
        !           159:                argp[0] += tem;
        !           160:              else
        !           161:                argp[0] = tem;
        !           162: 
        !           163:              p += 3;
        !           164:              break;
        !           165: 
        !           166:            case 'i':           /* %i means add one to arg, */
        !           167:              argp[0] ++;       /* and leave it to be output later. */
        !           168:              argp[1] ++;       /* Increment the following arg, too!  */
        !           169:              break;
        !           170: 
        !           171:            case '%':           /* %% means output %; no arg. */
        !           172:              goto ordinary;
        !           173: 
        !           174:            case 'n':           /* %n means xor each of next two args with 140 */
        !           175:              argp[0] ^= 0140;
        !           176:              argp[1] ^= 0140;
        !           177:              break;
        !           178: 
        !           179:            case 'm':           /* %m means xor each of next two args with 177 */
        !           180:              argp[0] ^= 0177;
        !           181:              argp[1] ^= 0177;
        !           182:              break;
        !           183: 
        !           184:            case 'B':           /* %B means express arg as BCD char code. */
        !           185:              argp[0] += 6 * (tem / 10);
        !           186:              break;
        !           187: 
        !           188:            case 'D':           /* %D means weird Delta Data transformation */
        !           189:              argp[0] -= 2 * (tem % 16);
        !           190:              break;
        !           191:            }
        !           192:        }
        !           193:       else
        !           194:        /* Ordinary character in the argument string.  */
        !           195:       ordinary:
        !           196:        *outstring++ = c;
        !           197:     }
        !           198:   *outstring = 0;
        !           199:   if (left)
        !           200:     strcat (outstring, left);
        !           201:   if (up)
        !           202:     strcat (outstring, up);
        !           203: }
        !           204: 
        !           205: #ifdef DEBUG
        !           206: 
        !           207: main (argc, argv)
        !           208:      int argc;
        !           209:      char **argv;
        !           210: {
        !           211:   char buf[50];
        !           212:   int args[3];
        !           213:   args[0] = atoi (argv[2]);
        !           214:   args[1] = atoi (argv[3]);
        !           215:   args[2] = atoi (argv[4]);
        !           216:   tparam1 (argv[1], buf, "LEFT", "UP", args);
        !           217:   printf ("%s\n", buf);
        !           218:   return 0;
        !           219: }
        !           220: 
        !           221: #endif /* DEBUG */

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