If heirloom shell is in /usr/lib/heirloom/5bin/sh, use it to run tests.
[mmh] / docs / historical / mh-6.8.5 / miscellany / less-177 / charset.c
1 /*
2  * Functions to define the character set
3  * and do things specific to the character set.
4  */
5
6 #include "less.h"
7
8 /*
9  * Predefined character sets,
10  * selected by the LESSCHARSET environment variable.
11  */
12 struct charset {
13         char *name;
14         char *desc;
15 } charsets[] = {
16         { "ascii",      "8bcccbcc18b95.b"       },
17         { "latin1",     "8bcccbcc18b95.33b."    },
18         { NULL }
19 };
20
21 #define IS_BINARY_CHAR  01
22 #define IS_CONTROL_CHAR 02
23
24 static char chardef[256];
25 static char *binfmt = "\\%o";
26 public int binattr = BLINK;
27
28 extern char *getenv();
29
30 /*
31  * Define a charset, given a description string.
32  * The string consists of 256 letters,
33  * one for each character in the charset.
34  * If the string is shorter than 256 letters, missing letters
35  * are taken to be identical to the last one.
36  * A decimal number followed by a letter is taken to be a 
37  * repetition of the letter.
38  *
39  * Each letter is one of:
40  *      . normal character
41  *      b binary character
42  *      c control character
43  */
44         static void
45 ichardef(s)
46         char *s;
47 {
48         register char *cp;
49         register int n;
50         register char v;
51
52         n = 0;
53         cp = chardef;
54         while (*s != '\0')
55         {
56                 switch (*s++)
57                 {
58                 case '.':
59                         v = 0;
60                         break;
61                 case 'c':
62                         v = IS_CONTROL_CHAR;
63                         break;
64                 case 'b':
65                         v = IS_BINARY_CHAR|IS_CONTROL_CHAR;
66                         break;
67
68                 case '0': case '1': case '2': case '3': case '4':
69                 case '5': case '6': case '7': case '8': case '9':
70                         n = (10 * n) + (s[-1] - '0');
71                         continue;
72
73                 default:
74                         error("invalid chardef", NULL_PARG);
75                         quit(1);
76                         /*NOTREACHED*/
77                 }
78
79                 do
80                 {
81                         if (cp >= chardef + sizeof(chardef))
82                         {
83                                 error("chardef longer than 256", NULL_PARG);
84                                 quit(1);
85                                 /*NOTREACHED*/
86                         }
87                         *cp++ = v;
88                 } while (--n > 0);
89                 n = 0;
90         }
91
92         while (cp < chardef + sizeof(chardef))
93                 *cp++ = v;
94 }
95
96 /*
97  * Define a charset, given a charset name.
98  * The valid charset names are listed in the "charsets" array.
99  */
100         static int
101 icharset(name)
102         register char *name;
103 {
104         register struct charset *p;
105
106         if (name == NULL || *name == '\0')
107                 return (0);
108
109         for (p = charsets;  p->name != NULL;  p++)
110         {
111                 if (strcmp(name, p->name) == 0)
112                 {
113                         ichardef(p->desc);
114                         return (1);
115                 }
116         }
117
118         error("invalid charset name", NULL_PARG);
119         quit(1);
120         /*NOTREACHED*/
121 }
122
123 /*
124  * Initialize charset data structures.
125  */
126         public void
127 init_charset()
128 {
129         register char *s;
130
131         /*
132          * Try environment variable LESSCHARSET.
133          * If LESSCHARSET is not set, try LESSCHARDEF.
134          * If LESSCHARDEF is not set, default to "ascii" charset.
135          */
136         s = getenv("LESSCHARSET");
137         if (icharset(s))
138                 return;
139
140         s = getenv("LESSCHARDEF");
141         if (s != NULL && *s != '\0')
142         {
143                 ichardef(s);
144                 return;
145         }
146
147         (void) icharset("ascii");
148
149         s = getenv("LESSBINFMT");
150         if (s != NULL && *s != '\0')
151         {
152                 if (*s == '*')
153                 {
154                         switch (s[1])
155                         {
156                         case 'd':  binattr = BOLD;      break;
157                         case 'k':  binattr = BLINK;     break;
158                         case 'u':  binattr = UNDERLINE; break;
159                         default:   binattr = NORMAL;    break;
160                         }
161                         s += 2;
162                 }
163                 if (*s != '\0')
164                         binfmt = s;
165         }
166 }
167
168 /*
169  * Is a given character a "binary" character?
170  */
171         public int
172 binary_char(c)
173         int c;
174 {
175         return (chardef[c] & IS_BINARY_CHAR);
176 }
177
178 /*
179  * Is a given character a "control" character?
180  */
181         public int
182 control_char(c)
183         int c;
184 {
185         return (chardef[c] & IS_CONTROL_CHAR);
186 }
187
188 /*
189  * Return the printable form of a character.
190  * For example, in the "ascii" charset '\3' is printed as "^C".
191  */
192         public char *
193 prchar(c)
194         int c;
195 {
196         static char buf[8];
197
198         if (!control_char(c))
199                 sprintf(buf, "%c", c);
200         else if (!control_char(c ^ 0100))
201                 sprintf(buf, "^%c", c ^ 0100);
202         else
203                 sprintf(buf, binfmt, c);
204         return (buf);
205 }