home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume26 / mytinfo / part02 / gettcap.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-12-26  |  5.1 KB  |  274 lines
  1. /*
  2.  * gettcap.c
  3.  *
  4.  * By Ross Ridge
  5.  * Public Domain
  6.  * 92/02/01 07:30:00
  7.  *
  8.  */
  9.  
  10. #include "defs.h"
  11. #include "term.h"
  12.  
  13. #include <ctype.h>
  14.  
  15. #ifdef USE_SCCS_IDS
  16. static const char SCCSid[] = "@(#) mytinfo gettcap.c 3.2 92/02/01 public domain, By Ross Ridge";
  17. #endif
  18.  
  19. int
  20. _gettcap(sp, cur, path)
  21. register char *sp;
  22. TERMINAL *cur;
  23. struct term_path *path; {
  24.     static char name[MAX_NAME];
  25.     static char entry[MAX_LINE];
  26.     register char *dp;
  27.     register TERMINAL *ct = cur;
  28.     int i, pad, fract, mul, ind;
  29.     char c, flag;
  30.  
  31.     dp = entry;
  32.     while(*sp != ':' && *sp != '\0')
  33.         *dp++ = *sp++;
  34.     if (ct->name_all == NULL) {
  35.         *dp = '\0';
  36.         if ((ct->name_all = _addstr(entry)) == NULL)
  37.             return 1;
  38.         while(dp > entry && *--dp != '|');
  39.         ct->name_long = ct->name_all + (dp - entry) + 1;
  40.     }
  41.  
  42.      while(*sp != '\0') {
  43.         while(*sp == ':')
  44.             sp++;
  45.         while(isspace(*sp))
  46.             sp++;
  47.         if (*sp == ':')
  48.             continue;
  49.         if (*sp == '\0')
  50.             break;
  51.         dp = name;
  52.         while (*sp != ':' && *sp != '#' && *sp != '=' &&
  53.                !isspace(*sp) && *sp != '\0')
  54.             *dp++ = *sp++;
  55.         *dp = '\0';
  56. #ifdef DEBUG
  57.         printf(" %s", name);
  58. #endif
  59.         switch(*sp) {
  60.         case '=':
  61. #ifdef DEBUG
  62.             putchar('$');
  63. #endif
  64.             ind = _findstrcode(name);
  65.             if (ind != -1)
  66.                 flag = _strflags[ind];
  67.             else
  68.                 flag = 'K';
  69.             dp = entry;
  70.             fract = pad = 0;
  71.             sp++;
  72.             if (isdigit(*sp) && flag != 'K') {
  73.                 pad = *sp++ - '0';
  74.                 while(isdigit(*sp))
  75.                     pad = pad * 10 + (*sp++ - '0');
  76.                 if (*sp == '.' && isdigit(sp[1])) {
  77.                     sp++;
  78.                     fract = (*sp++ - '0');
  79.                 }
  80.                 if (*sp == '*') {
  81.                     mul = 1;
  82.                     sp++;
  83.                 } else
  84.                     mul = 0;
  85.     
  86.             }
  87.             while(*sp != '\0' && *sp != ':') {
  88.                 switch(*sp) {
  89.                 case '\\':
  90.                     switch(*++sp) {
  91.                     case 'e':
  92.                     case 'E': *dp++ = '\033'; break;
  93.                     case 'l': *dp++ = '\012'; break;
  94.                     case 'n': *dp++ = '\n'; break;
  95.                     case 'r': *dp++ = '\r'; break;
  96.                     case 't': *dp++ = '\t'; break;
  97.                     case 'b': *dp++ = '\b'; break;
  98.                     case 'f': *dp++ = '\f'; break;
  99.                     case 's': *dp++ = ' '; break;
  100.  
  101.                     case '^': 
  102.                     case '\\':
  103.                     case ',':
  104.                     case ':':
  105.                         *dp++ = *sp;
  106.                         break;
  107.  
  108.                     case '0':
  109.                         if (!isdigit(*(sp + 1))) {
  110.                             *dp++ = '\200';
  111.                             break;
  112.                         }
  113.                         ;/* FALLTHROUGH */
  114.                     case '1':
  115.                     case '2':
  116.                     case '3':
  117.                     case '4':
  118.                     case '5':
  119.                     case '6':
  120.                     case '7':
  121.                         c = *sp - '0';
  122.                         if (sp[1] >= '0'
  123.                             && sp[1] <= '8')
  124.                             c = c * 8
  125.                                 + (*++sp - '0');
  126.                         if (sp[1] >= '0'
  127.                             && sp[1] <= '8')
  128.                             c = c * 8
  129.                                 + (*++sp - '0');
  130.                         switch((char)c) {
  131.                         case 0:
  132.                             if (flag == 'K')
  133.                                 *dp++ = '\200';
  134.                             else {
  135.                                 *dp++ = '\\';
  136.                                 *dp++ = '0';
  137.                                 *dp++ = '0';
  138.                                 *dp++ = '0';
  139.                             }
  140.                             break;
  141.                         case '$':
  142.                         case '\'':
  143.                         case '\\':
  144.                             if (flag != 'K')
  145.                                 *dp++ = '\\';
  146.                             /* FALLTHROUGH */
  147.                         default:
  148.                             if (flag == 'G'
  149.                                 && c == '%')
  150.                                 *dp++ = '\\';
  151.                             *dp++ = c;
  152.                             break;
  153.                         }
  154.                         break;
  155.                     default:
  156.                         *dp++ = '\\';
  157.                         *dp++ = *sp;
  158.                         break;
  159.                     }
  160.                     sp++;
  161.                     break;
  162.                 case '^':
  163.                     if (*++sp >= 'A' && *sp <= '_') {
  164.                         *dp++ = *sp++ - '@';
  165.                     } else if (*sp >= 'a' && *sp <= 'z') {
  166.                         *dp++ = *sp++ - 'a' + 1;
  167.                     } else if (*sp == '@') {
  168.                         if (flag == 'K')
  169.                             *dp++ = '\200';
  170.                         else {
  171.                             *dp++ = '\\';
  172.                             *dp++ = '0';
  173.                             *dp++ = '0';
  174.                             *dp++ = '0';
  175.                         }
  176.                         sp++;
  177.                     } else 
  178.                         *dp++ = '^';
  179.                     break;
  180.                 case '$':
  181.                     if (flag != 'K')
  182.                         *dp++ = '\\';
  183.                     /* FALLTHROUGH */
  184.                 default:
  185.                     *dp++ = *sp++;
  186.                     break;
  187.                 }
  188.             }
  189.             if (pad != 0 || fract != 0) {
  190.                 if (fract == 0)
  191.                     sprintf(dp, "$<%d", pad);
  192.                 else
  193.                     sprintf(dp, "$<%d.%d", pad, fract);
  194.                 dp += strlen(dp);
  195.                 if (mul) 
  196.                     *dp++ = '*';
  197.                 *dp++ = '>';
  198.             }
  199.             *dp++ = '\0';
  200.             if(name[0] == 't' && name[1] == 'c' && name[2] == '\0'){
  201.                 if (_getother(entry, path, ct))
  202.                     return 1;
  203.                 break;
  204.             }
  205.             if (ind == -1)
  206.                 break;
  207.             if (ct->strs[ind] != (char *) -1)
  208.                 break;
  209.             if ((ct->strs[ind] = _addstr(entry)) == NULL)
  210.                 return 1;
  211.             break;    
  212.         case '#':
  213. #ifdef DEBUG
  214.             putchar('#');
  215. #endif
  216.             i = atoi(++sp);
  217.             while(*sp != '\0' && *sp++ != ':');
  218.             ind = _findnumcode(name);
  219.             if (ind == -1)
  220.                 break;
  221.             if (ct->nums[ind] != -2)
  222.                 break;
  223.             ct->nums[ind] = i;
  224.             break;
  225.         default:
  226.             while(*sp != '\0' && *sp++ != ':');
  227.             if (*(dp - 1) == '@') {
  228. #ifdef DEBUG
  229.                 putchar('@');
  230. #endif
  231.                 *(dp - 1) = '\0';
  232.                 ind = _findboolcode(name);
  233.                 if (ind != -1) {
  234. #ifdef DEBUG
  235.                     putchar('!');
  236. #endif
  237.                     if (ct->bools[ind] == -1)
  238.                         ct->bools[ind] = 0;
  239.                     break;
  240.                 }
  241.                 ind = _findnumcode(name);
  242.                 if (ind != -1) {
  243. #ifdef DEBUG
  244.                     putchar('#');
  245. #endif
  246.                     if (ct->nums[ind] == -2)
  247.                         ct->nums[ind] = -1;
  248.                     break;
  249.                 }
  250.                 ind = _findstrcode(name);
  251.                 if (ind != -1) {
  252. #ifdef DEBUG
  253.                     putchar('$');
  254. #endif
  255.                     if (ct->strs[ind] == (char *) -1)
  256.                         ct->strs[ind] = NULL;
  257.                     break;
  258.                 }
  259.                 break;
  260.             }
  261. #ifdef DEBUG
  262.             putchar('!');
  263. #endif
  264.             ind = _findboolcode(name);
  265.             if (ind == -1)
  266.                 break;
  267.             if (ct->bools[ind] != -1)
  268.                 break;
  269.             ct->bools[ind] = 1;
  270.         }
  271.     }
  272.     return 0;
  273. }
  274.