![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to parse-colors.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / readline|
Return to parse-colors.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / readline |
1.1 misho 1: /* `dir', `vdir' and `ls' directory listing programs for GNU.
2:
3: Modified by Chet Ramey for Readline.
4:
5: Copyright (C) 1985, 1988, 1990-1991, 1995-2010, 2012 Free Software Foundation,
6: Inc.
7:
8: This program is free software: you can redistribute it and/or modify
9: it under the terms of the GNU General Public License as published by
10: the Free Software Foundation, either version 3 of the License, or
11: (at your option) any later version.
12:
13: This program is distributed in the hope that it will be useful,
14: but WITHOUT ANY WARRANTY; without even the implied warranty of
15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16: GNU General Public License for more details.
17:
18: You should have received a copy of the GNU General Public License
19: along with this program. If not, see <http://www.gnu.org/licenses/>. */
20:
21: /* Written by Richard Stallman and David MacKenzie. */
22:
23: /* Color support by Peter Anvin <Peter.Anvin@linux.org> and Dennis
24: Flaherty <dennisf@denix.elk.miles.com> based on original patches by
25: Greg Lee <lee@uhunix.uhcc.hawaii.edu>. */
26:
27: #define READLINE_LIBRARY
28:
29: #if defined (HAVE_CONFIG_H)
30: # include <config.h>
31: #endif
32:
33: #include <stdio.h>
34:
35: // strdup() / strcpy()
36: #if defined (HAVE_STRING_H)
37: # include <string.h>
38: #else /* !HAVE_STRING_H */
39: # include <strings.h>
40: #endif /* !HAVE_STRING_H */
41:
42: // abort()
43: #if defined (HAVE_STDLIB_H)
44: # include <stdlib.h>
45: #else
46: # include "ansi_stdlib.h"
47: #endif /* HAVE_STDLIB_H */
48:
49: #include "rldefs.h" // STREQ, savestring
50: #include "readline.h"
51: #include "rlprivate.h"
52: #include "rlshell.h"
53: #include "xmalloc.h"
54:
55: #include "colors.h"
56: #include "parse-colors.h"
57:
58: #if defined (COLOR_SUPPORT)
59:
60: static bool get_funky_string (char **dest, const char **src, bool equals_end, size_t *output_count);
61:
62: struct bin_str _rl_color_indicator[] =
63: {
64: { LEN_STR_PAIR ("\033[") }, // lc: Left of color sequence
65: { LEN_STR_PAIR ("m") }, // rc: Right of color sequence
66: { 0, NULL }, // ec: End color (replaces lc+no+rc)
67: { LEN_STR_PAIR ("0") }, // rs: Reset to ordinary colors
68: { 0, NULL }, // no: Normal
69: { 0, NULL }, // fi: File: default
70: { LEN_STR_PAIR ("01;34") }, // di: Directory: bright blue
71: { LEN_STR_PAIR ("01;36") }, // ln: Symlink: bright cyan
72: { LEN_STR_PAIR ("33") }, // pi: Pipe: yellow/brown
73: { LEN_STR_PAIR ("01;35") }, // so: Socket: bright magenta
74: { LEN_STR_PAIR ("01;33") }, // bd: Block device: bright yellow
75: { LEN_STR_PAIR ("01;33") }, // cd: Char device: bright yellow
76: { 0, NULL }, // mi: Missing file: undefined
77: { 0, NULL }, // or: Orphaned symlink: undefined
78: { LEN_STR_PAIR ("01;32") }, // ex: Executable: bright green
79: { LEN_STR_PAIR ("01;35") }, // do: Door: bright magenta
80: { LEN_STR_PAIR ("37;41") }, // su: setuid: white on red
81: { LEN_STR_PAIR ("30;43") }, // sg: setgid: black on yellow
82: { LEN_STR_PAIR ("37;44") }, // st: sticky: black on blue
83: { LEN_STR_PAIR ("34;42") }, // ow: other-writable: blue on green
84: { LEN_STR_PAIR ("30;42") }, // tw: ow w/ sticky: black on green
85: { LEN_STR_PAIR ("30;41") }, // ca: black on red
86: { 0, NULL }, // mh: disabled by default
87: { LEN_STR_PAIR ("\033[K") }, // cl: clear to end of line
88: };
89:
90: /* Parse a string as part of the LS_COLORS variable; this may involve
91: decoding all kinds of escape characters. If equals_end is set an
92: unescaped equal sign ends the string, otherwise only a : or \0
93: does. Set *OUTPUT_COUNT to the number of bytes output. Return
94: true if successful.
95:
96: The resulting string is *not* null-terminated, but may contain
97: embedded nulls.
98:
99: Note that both dest and src are char **; on return they point to
100: the first free byte after the array and the character that ended
101: the input string, respectively. */
102:
103: static bool
104: get_funky_string (char **dest, const char **src, bool equals_end, size_t *output_count) {
105: char num; /* For numerical codes */
106: size_t count; /* Something to count with */
107: enum {
108: ST_GND, ST_BACKSLASH, ST_OCTAL, ST_HEX, ST_CARET, ST_END, ST_ERROR
109: } state;
110: const char *p;
111: char *q;
112:
113: p = *src; /* We don't want to double-indirect */
114: q = *dest; /* the whole darn time. */
115:
116: count = 0; /* No characters counted in yet. */
117: num = 0;
118:
119: state = ST_GND; /* Start in ground state. */
120: while (state < ST_END)
121: {
122: switch (state)
123: {
124: case ST_GND: /* Ground state (no escapes) */
125: switch (*p)
126: {
127: case ':':
128: case '\0':
129: state = ST_END; /* End of string */
130: break;
131: case '\\':
132: state = ST_BACKSLASH; /* Backslash scape sequence */
133: ++p;
134: break;
135: case '^':
136: state = ST_CARET; /* Caret escape */
137: ++p;
138: break;
139: case '=':
140: if (equals_end)
141: {
142: state = ST_END; /* End */
143: break;
144: }
145: /* else fall through */
146: default:
147: *(q++) = *(p++);
148: ++count;
149: break;
150: }
151: break;
152:
153: case ST_BACKSLASH: /* Backslash escaped character */
154: switch (*p)
155: {
156: case '0':
157: case '1':
158: case '2':
159: case '3':
160: case '4':
161: case '5':
162: case '6':
163: case '7':
164: state = ST_OCTAL; /* Octal sequence */
165: num = *p - '0';
166: break;
167: case 'x':
168: case 'X':
169: state = ST_HEX; /* Hex sequence */
170: num = 0;
171: break;
172: case 'a': /* Bell */
173: num = '\a';
174: break;
175: case 'b': /* Backspace */
176: num = '\b';
177: break;
178: case 'e': /* Escape */
179: num = 27;
180: break;
181: case 'f': /* Form feed */
182: num = '\f';
183: break;
184: case 'n': /* Newline */
185: num = '\n';
186: break;
187: case 'r': /* Carriage return */
188: num = '\r';
189: break;
190: case 't': /* Tab */
191: num = '\t';
192: break;
193: case 'v': /* Vtab */
194: num = '\v';
195: break;
196: case '?': /* Delete */
197: num = 127;
198: break;
199: case '_': /* Space */
200: num = ' ';
201: break;
202: case '\0': /* End of string */
203: state = ST_ERROR; /* Error! */
204: break;
205: default: /* Escaped character like \ ^ : = */
206: num = *p;
207: break;
208: }
209: if (state == ST_BACKSLASH)
210: {
211: *(q++) = num;
212: ++count;
213: state = ST_GND;
214: }
215: ++p;
216: break;
217:
218: case ST_OCTAL: /* Octal sequence */
219: if (*p < '0' || *p > '7')
220: {
221: *(q++) = num;
222: ++count;
223: state = ST_GND;
224: }
225: else
226: num = (num << 3) + (*(p++) - '0');
227: break;
228:
229: case ST_HEX: /* Hex sequence */
230: switch (*p)
231: {
232: case '0':
233: case '1':
234: case '2':
235: case '3':
236: case '4':
237: case '5':
238: case '6':
239: case '7':
240: case '8':
241: case '9':
242: num = (num << 4) + (*(p++) - '0');
243: break;
244: case 'a':
245: case 'b':
246: case 'c':
247: case 'd':
248: case 'e':
249: case 'f':
250: num = (num << 4) + (*(p++) - 'a') + 10;
251: break;
252: case 'A':
253: case 'B':
254: case 'C':
255: case 'D':
256: case 'E':
257: case 'F':
258: num = (num << 4) + (*(p++) - 'A') + 10;
259: break;
260: default:
261: *(q++) = num;
262: ++count;
263: state = ST_GND;
264: break;
265: }
266: break;
267:
268: case ST_CARET: /* Caret escape */
269: state = ST_GND; /* Should be the next state... */
270: if (*p >= '@' && *p <= '~')
271: {
272: *(q++) = *(p++) & 037;
273: ++count;
274: }
275: else if (*p == '?')
276: {
277: *(q++) = 127;
278: ++count;
279: }
280: else
281: state = ST_ERROR;
282: break;
283:
284: default:
285: /* should we ? */
286: /* abort (); no, we should not */
287: state = ST_ERROR;
288: break;
289: }
290: }
291:
292: *dest = q;
293: *src = p;
294: *output_count = count;
295:
296: return state != ST_ERROR;
297: }
298: #endif /* COLOR_SUPPORT */
299:
300: void _rl_parse_colors()
301: {
302: #if defined (COLOR_SUPPORT)
303: const char *p; /* Pointer to character being parsed */
304: char *buf; /* color_buf buffer pointer */
305: int state; /* State of parser */
306: int ind_no; /* Indicator number */
307: char label[3]; /* Indicator label */
308: COLOR_EXT_TYPE *ext; /* Extension we are working on */
309:
310: p = sh_get_env_value ("LS_COLORS");
311: if (p == 0 || *p == '\0')
312: {
313: _rl_color_ext_list = NULL;
314: return;
315: }
316:
317: ext = NULL;
318: strcpy (label, "??");
319:
320: /* This is an overly conservative estimate, but any possible
321: LS_COLORS string will *not* generate a color_buf longer than
322: itself, so it is a safe way of allocating a buffer in
323: advance. */
324: buf = color_buf = savestring (p);
325:
326: state = 1;
327: while (state > 0)
328: {
329: switch (state)
330: {
331: case 1: /* First label character */
332: switch (*p)
333: {
334: case ':':
335: ++p;
336: break;
337:
338: case '*':
339: /* Allocate new extension block and add to head of
340: linked list (this way a later definition will
341: override an earlier one, which can be useful for
342: having terminal-specific defs override global). */
343:
344: ext = (COLOR_EXT_TYPE *)xmalloc (sizeof *ext);
345: ext->next = _rl_color_ext_list;
346: _rl_color_ext_list = ext;
347:
348: ++p;
349: ext->ext.string = buf;
350:
351: state = (get_funky_string (&buf, &p, true, &ext->ext.len)
352: ? 4 : -1);
353: break;
354:
355: case '\0':
356: state = 0; /* Done! */
357: break;
358:
359: default: /* Assume it is file type label */
360: label[0] = *(p++);
361: state = 2;
362: break;
363: }
364: break;
365:
366: case 2: /* Second label character */
367: if (*p)
368: {
369: label[1] = *(p++);
370: state = 3;
371: }
372: else
373: state = -1; /* Error */
374: break;
375:
376: case 3: /* Equal sign after indicator label */
377: state = -1; /* Assume failure... */
378: if (*(p++) == '=')/* It *should* be... */
379: {
380: for (ind_no = 0; indicator_name[ind_no] != NULL; ++ind_no)
381: {
382: if (STREQ (label, indicator_name[ind_no]))
383: {
384: _rl_color_indicator[ind_no].string = buf;
385: state = (get_funky_string (&buf, &p, false,
386: &_rl_color_indicator[ind_no].len)
387: ? 1 : -1);
388: break;
389: }
390: }
391: if (state == -1)
392: {
393: _rl_errmsg ("LS_COLORS: unrecognized prefix: %s", label);
394: /* recover from an unrecognized prefix */
395: while (p && *p && *p != ':')
396: p++;
397: if (p && *p == ':')
398: state = 1;
399: else if (p && *p == 0)
400: state = 0;
401: }
402: }
403: break;
404:
405: case 4: /* Equal sign after *.ext */
406: if (*(p++) == '=')
407: {
408: ext->seq.string = buf;
409: state = (get_funky_string (&buf, &p, false, &ext->seq.len)
410: ? 1 : -1);
411: }
412: else
413: state = -1;
414: /* XXX - recover here as with an unrecognized prefix? */
415: if (state == -1 && ext->ext.string)
416: _rl_errmsg ("LS_COLORS: syntax error: %s", ext->ext.string);
417: break;
418: }
419: }
420:
421: if (state < 0)
422: {
423: COLOR_EXT_TYPE *e;
424: COLOR_EXT_TYPE *e2;
425:
426: _rl_errmsg ("unparsable value for LS_COLORS environment variable");
427: free (color_buf);
428: for (e = _rl_color_ext_list; e != NULL; /* empty */)
429: {
430: e2 = e;
431: e = e->next;
432: free (e2);
433: }
434: _rl_color_ext_list = NULL;
435: _rl_colored_stats = 0; /* can't have colored stats without colors */
436: }
437: #else /* !COLOR_SUPPORT */
438: ;
439: #endif /* !COLOR_SUPPORT */
440: }