![[BACK]](/icons/back.gif){kind=icon}
Return to lesskey.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / less|
Return to lesskey.c CVS log | Up to [local] / src / usr.bin / less |
1.1 etheisen 1: /*
2: * Copyright (c) 1984,1985,1989,1994,1995 Mark Nudelman
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice in the documentation and/or other materials provided with
12: * the distribution.
13: *
14: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY
15: * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE
18: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
19: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
20: * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
21: * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
22: * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
23: * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
24: * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25: */
26:
27:
28: /*
29: * lesskey [-o output] [input]
30: *
31: * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
32: *
33: * Make a .less file.
34: * If no input file is specified, standard input is used.
35: * If no output file is specified, $HOME/.less is used.
36: *
37: * The .less file is used to specify (to "less") user-defined
38: * key bindings. Basically any sequence of 1 to MAX_CMDLEN
39: * keystrokes may be bound to an existing less function.
40: *
41: * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
42: *
43: * The input file is an ascii file consisting of a
44: * sequence of lines of the form:
45: * string <whitespace> action [chars] <newline>
46: *
47: * "string" is a sequence of command characters which form
48: * the new user-defined command. The command
49: * characters may be:
50: * 1. The actual character itself.
51: * 2. A character preceded by ^ to specify a
52: * control character (e.g. ^X means control-X).
53: * 3. A backslash followed by one to three octal digits
54: * to specify a character by its octal value.
55: * 4. A backslash followed by b, e, n, r or t
56: * to specify \b, ESC, \n, \r or \t, respectively.
57: * 5. Any character (other than those mentioned above) preceded
58: * by a \ to specify the character itself (characters which
59: * must be preceded by \ include ^, \, and whitespace.
60: * "action" is the name of a "less" action, from the table below.
61: * "chars" is an optional sequence of characters which is treated
62: * as keyboard input after the command is executed.
63: *
64: * Blank lines and lines which start with # are ignored,
65: * except for the special control lines:
66: * #line-edit Signals the beginning of the line-editing
67: * keys section.
68: * #stop Stops command parsing in less;
69: * causes all default keys to be disabled.
70: *
71: * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
72: *
73: * The output file is a non-ascii file, consisting of a header,
74: * one or more sections, and a trailer.
75: * Each section begins with a section header, a section length word
76: * and the section data. Normally there are three sections:
77: * CMD_SECTION Definition of command keys.
78: * EDIT_SECTION Definition of editing keys.
79: * END_SECTION A special section header, with no
80: * length word or section data.
81: *
82: * Section data consists of zero or more byte sequences of the form:
83: * string <0> <action>
84: * or
85: * string <0> <action|A_EXTRA> chars <0>
86: *
87: * "string" is the command string.
88: * "<0>" is one null byte.
89: * "<action>" is one byte containing the action code (the A_xxx value).
90: * If action is ORed with A_EXTRA, the action byte is followed
91: * by the null-terminated "chars" string.
92: *
93: * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
94: */
95:
96: #include "less.h"
97: #include "lesskey.h"
98: #include "cmd.h"
99:
100: struct cmdname
101: {
102: char *cn_name;
103: int cn_action;
104: };
105:
106: struct cmdname cmdnames[] =
107: {
108: "back-bracket", A_B_BRACKET,
109: "back-line", A_B_LINE,
110: "back-line-force", A_BF_LINE,
111: "back-screen", A_B_SCREEN,
112: "back-scroll", A_B_SCROLL,
113: "back-search", A_B_SEARCH,
114: "back-window", A_B_WINDOW,
115: "debug", A_DEBUG,
116: "display-flag", A_DISP_OPTION,
117: "display-option", A_DISP_OPTION,
118: "end", A_GOEND,
119: "examine", A_EXAMINE,
120: "first-cmd", A_FIRSTCMD,
121: "firstcmd", A_FIRSTCMD,
122: "flush-repaint", A_FREPAINT,
123: "forw-bracket", A_F_BRACKET,
124: "forw-forever", A_F_FOREVER,
125: "forw-line", A_F_LINE,
126: "forw-line-force", A_FF_LINE,
127: "forw-screen", A_F_SCREEN,
128: "forw-scroll", A_F_SCROLL,
129: "forw-search", A_F_SEARCH,
130: "forw-window", A_F_WINDOW,
131: "goto-end", A_GOEND,
132: "goto-line", A_GOLINE,
133: "goto-mark", A_GOMARK,
134: "help", A_HELP,
135: "index-file", A_INDEX_FILE,
136: "invalid", A_UINVALID,
137: "next-file", A_NEXT_FILE,
138: "noaction", A_NOACTION,
139: "percent", A_PERCENT,
140: "pipe", A_PIPE,
141: "prev-file", A_PREV_FILE,
142: "quit", A_QUIT,
143: "repaint", A_REPAINT,
144: "repaint-flush", A_FREPAINT,
145: "repeat-search", A_AGAIN_SEARCH,
146: "repeat-search-all", A_T_AGAIN_SEARCH,
147: "reverse-search", A_REVERSE_SEARCH,
148: "reverse-search-all", A_T_REVERSE_SEARCH,
149: "set-mark", A_SETMARK,
150: "shell", A_SHELL,
151: "status", A_STAT,
152: "toggle-flag", A_OPT_TOGGLE,
153: "toggle-option", A_OPT_TOGGLE,
154: "undo-hilite", A_UNDO_SEARCH,
155: "version", A_VERSION,
156: "visual", A_VISUAL,
157: NULL, 0
158: };
159:
160: struct cmdname editnames[] =
161: {
162: "back-complete", EC_B_COMPLETE,
163: "backspace", EC_BACKSPACE,
164: "delete", EC_DELETE,
165: "down", EC_DOWN,
166: "end", EC_END,
167: "expand", EC_EXPAND,
168: "forw-complete", EC_F_COMPLETE,
169: "home", EC_HOME,
170: "insert", EC_INSERT,
171: "invalid", EC_UINVALID,
172: "kill-line", EC_LINEKILL,
173: "left", EC_LEFT,
174: "literal", EC_LITERAL,
175: "right", EC_RIGHT,
176: "up", EC_UP,
177: "word-backspace", EC_W_BACKSPACE,
178: "word-delete", EC_W_DELETE,
179: "word-left", EC_W_RIGHT,
180: "word-right", EC_W_LEFT,
181: NULL, 0
182: };
183:
184: struct table
185: {
186: struct cmdname *names;
187: char *pbuffer;
188: char buffer[MAX_USERCMD];
189: };
190:
191: struct table cmdtable;
192: struct table edittable;
193: struct table *currtable = &cmdtable;
194:
195: char fileheader[] = {
196: C0_LESSKEY_MAGIC,
197: C1_LESSKEY_MAGIC,
198: C2_LESSKEY_MAGIC,
199: C3_LESSKEY_MAGIC
200: };
201: char filetrailer[] = {
202: C0_END_LESSKEY_MAGIC,
203: C1_END_LESSKEY_MAGIC,
204: C2_END_LESSKEY_MAGIC
205: };
206: char cmdsection[1] = { CMD_SECTION };
207: char editsection[1] = { EDIT_SECTION };
208: char endsection[1] = { END_SECTION };
209:
210: char *infile = NULL;
211: char *outfile = NULL ;
212:
213: int linenum;
214: int errors;
215:
216: extern char version[];
217:
218: char *
219: mkpathname(dirname, filename)
220: char *dirname;
221: char *filename;
222: {
223: char *pathname;
224:
225: pathname = calloc(strlen(dirname) + strlen(filename) + 2, sizeof(char));
226: strcpy(pathname, dirname);
227: #if MSOFTC || OS2
228: strcat(pathname, "\\");
229: #else
230: strcat(pathname, "/");
231: #endif
232: strcat(pathname, filename);
233: return (pathname);
234: }
235:
236: /*
237: * Figure out the name of a default file (in the user's HOME directory).
238: */
239: char *
240: homefile(filename)
241: char *filename;
242: {
243: char *p;
244: char *pathname;
245:
246: if ((p = getenv("HOME")) != NULL && *p != '\0')
247: pathname = mkpathname(p, filename);
248: #if OS2
249: else if ((p = getenv("INIT")) != NULL && *p != '\0')
250: pathname = mkpathname(p, filename);
251: #endif
252: else
253: {
254: fprintf(stderr, "cannot find $HOME - using current directory\n");
255: pathname = mkpathname(".", filename);
256: }
257: return (pathname);
258: }
259:
260: /*
261: * Parse command line arguments.
262: */
263: void
264: parse_args(argc, argv)
265: int argc;
266: char **argv;
267: {
268: outfile = NULL;
269: while (--argc > 0 && **(++argv) == '-' && argv[0][1] != '\0')
270: {
271: switch (argv[0][1])
272: {
273: case 'o':
274: outfile = &argv[0][2];
275: if (*outfile == '\0')
276: {
277: if (--argc <= 0)
278: usage();
279: outfile = *(++argv);
280: }
281: break;
282: case 'V':
283: printf("lesskey version %s\n", version);
284: exit(0);
285: default:
286: usage();
287: }
288: }
289: if (argc > 1)
290: usage();
291: /*
292: * Open the input file, or use DEF_LESSKEYINFILE if none specified.
293: */
294: if (argc > 0)
295: infile = *argv;
296: else
297: infile = homefile(DEF_LESSKEYINFILE);
298: }
299:
300: /*
301: * Initialize data structures.
302: */
303: void
304: init_tables()
305: {
306: cmdtable.names = cmdnames;
307: cmdtable.pbuffer = cmdtable.buffer;
308:
309: edittable.names = editnames;
310: edittable.pbuffer = edittable.buffer;
311: }
312:
313: /*
314: * Parse one character of a string.
315: */
316: int
317: tchar(pp)
318: char **pp;
319: {
320: register char *p;
321: register char ch;
322: register int i;
323:
324: p = *pp;
325: switch (*p)
326: {
327: case '\\':
328: ++p;
329: switch (*p)
330: {
331: case '0': case '1': case '2': case '3':
332: case '4': case '5': case '6': case '7':
333: /*
334: * Parse an octal number.
335: */
336: ch = 0;
337: i = 0;
338: do
339: ch = 8*ch + (*p - '0');
340: while (*++p >= '0' && *p <= '7' && ++i < 3);
341: *pp = p;
342: return (ch);
343: case 'b':
344: *pp = p+1;
345: return ('\r');
346: case 'e':
347: *pp = p+1;
348: return (ESC);
349: case 'n':
350: *pp = p+1;
351: return ('\n');
352: case 'r':
353: *pp = p+1;
354: return ('\r');
355: case 't':
356: *pp = p+1;
357: return ('\t');
358: default:
359: /*
360: * Backslash followed by any other char
361: * just means that char.
362: */
363: *pp = p+1;
364: return (*p);
365: }
366: case '^':
367: /*
368: * Carat means CONTROL.
369: */
370: *pp = p+2;
371: return (CONTROL(p[1]));
372: }
373: *pp = p+1;
374: return (*p);
375: }
376:
377: /*
378: * Skip leading spaces in a string.
379: */
380: public char *
381: skipsp(s)
382: register char *s;
383: {
384: while (*s == ' ' || *s == '\t')
385: s++;
386: return (s);
387: }
388:
389: /*
390: * Skip non-space characters in a string.
391: */
392: public char *
393: skipnsp(s)
394: register char *s;
395: {
396: while (*s != '\0' && *s != ' ' && *s != '\t')
397: s++;
398: return (s);
399: }
400:
401: /*
402: * Clean up an input line:
403: * strip off the trailing newline & any trailing # comment.
404: */
405: char *
406: clean_line(s)
407: char *s;
408: {
409: register int i;
410:
411: s = skipsp(s);
412: for (i = 0; s[i] != '\n' && s[i] != '\0'; i++)
413: if (s[i] == '#' && (i == 0 || s[i-1] != '\\'))
414: break;
415: s[i] = '\0';
416: return (s);
417: }
418:
419: /*
420: * Add a byte to the output command table.
421: */
422: void
423: add_cmd_char(c)
424: int c;
425: {
426: if (currtable->pbuffer >= currtable->buffer + MAX_USERCMD)
427: {
428: error("too many commands");
429: exit(1);
430: }
431: *(currtable->pbuffer)++ = c;
432: }
433:
434: /*
435: * See if we have a special "control" line.
436: */
437: int
438: control_line(s)
439: char *s;
440: {
441: #define PREFIX(str,pat) (strncmp(str,pat,strlen(pat)-1) == 0)
442:
443: if (PREFIX(s, "#line-edit"))
444: {
445: currtable = &edittable;
446: return (1);
447: }
448: if (PREFIX(s, "#command"))
449: {
450: currtable = &cmdtable;
451: return (1);
452: }
453: if (PREFIX(s, "#stop"))
454: {
455: add_cmd_char('\0');
456: add_cmd_char(A_END_LIST);
457: return (1);
458: }
459: return (0);
460: }
461:
462: /*
463: * Output some bytes.
464: */
465: void
466: fputbytes(fd, buf, len)
467: FILE *fd;
468: char *buf;
469: int len;
470: {
471: while (len-- > 0)
472: {
473: fwrite(buf, sizeof(char), 1, fd);
474: buf++;
475: }
476: }
477:
478: /*
479: * Output an integer, in special KRADIX form.
480: */
481: void
482: fputint(fd, val)
483: FILE *fd;
484: unsigned int val;
485: {
486: char c;
487:
488: if (val >= KRADIX*KRADIX)
489: {
490: fprintf(stderr, "error: integer too big (%d > %d)\n",
491: val, KRADIX*KRADIX);
492: exit(1);
493: }
494: c = val % KRADIX;
495: fwrite(&c, sizeof(char), 1, fd);
496: c = val / KRADIX;
497: fwrite(&c, sizeof(char), 1, fd);
498: }
499:
500: /*
501: * Find an action, given the name of the action.
502: */
503: int
504: findaction(actname)
505: char *actname;
506: {
507: int i;
508:
509: for (i = 0; currtable->names[i].cn_name != NULL; i++)
510: if (strcmp(currtable->names[i].cn_name, actname) == 0)
511: return (currtable->names[i].cn_action);
512: error("unknown action");
513: return (A_INVALID);
514: }
515:
516: usage()
517: {
518: fprintf(stderr, "usage: lesskey [-o output] [input]\n");
519: exit(1);
520: }
521:
522: void
523: error(s)
524: char *s;
525: {
526: fprintf(stderr, "line %d: %s\n", linenum, s);
527: errors++;
528: }
529:
530:
531: /*
532: * Parse a line from the lesskey file.
533: */
534: void
535: parse_line(line)
536: char *line;
537: {
538: char *p;
539: int cmdlen;
540: char *actname;
541: int action;
542: int c;
543:
544: /*
545: * See if it is a control line.
546: */
547: if (control_line(line))
548: return;
549: /*
550: * Skip leading white space.
551: * Replace the final newline with a null byte.
552: * Ignore blank lines and comments.
553: */
554: p = clean_line(line);
555: if (*p == '\0')
556: return;
557:
558: /*
559: * Parse the command string and store it in the current table.
560: */
561: cmdlen = 0;
562: do
563: {
564: c = tchar(&p);
565: if (++cmdlen > MAX_CMDLEN)
566: error("command too long");
567: else
568: add_cmd_char(c);
569: } while (*p != ' ' && *p != '\t' && *p != '\0');
570: /*
571: * Terminate the command string with a null byte.
572: */
573: add_cmd_char('\0');
574:
575: /*
576: * Skip white space between the command string
577: * and the action name.
578: * Terminate the action name with a null byte.
579: */
580: p = skipsp(p);
581: if (*p == '\0')
582: {
583: error("missing action");
584: return;
585: }
586: actname = p;
587: p = skipnsp(p);
588: c = *p;
589: *p = '\0';
590:
591: /*
592: * Parse the action name and store it in the current table.
593: */
594: action = findaction(actname);
595:
596: /*
597: * See if an extra string follows the action name.
598: */
599: *p = c;
600: p = skipsp(p);
601: if (*p == '\0')
602: {
603: add_cmd_char(action);
604: } else
605: {
606: /*
607: * OR the special value A_EXTRA into the action byte.
608: * Put the extra string after the action byte.
609: */
610: add_cmd_char(action | A_EXTRA);
611: while (*p != '\0')
612: add_cmd_char(tchar(&p));
613: add_cmd_char('\0');
614: }
615: }
616:
617: main(argc, argv)
618: int argc;
619: char *argv[];
620: {
621: FILE *desc;
622: FILE *out;
623: char line[200];
624:
625: /*
626: * Process command line arguments.
627: */
628: parse_args(argc, argv);
629: init_tables();
630:
631: /*
632: * Open the input file.
633: */
634: if (strcmp(infile, "-") == 0)
635: desc = stdin;
636: else if ((desc = fopen(infile, "r")) == NULL)
637: {
638: perror(infile);
639: exit(1);
640: }
641:
642: /*
643: * Read and parse the input file, one line at a time.
644: */
645: errors = 0;
646: linenum = 0;
647: while (fgets(line, sizeof(line), desc) != NULL)
648: {
649: ++linenum;
650: parse_line(line);
651: }
652:
653: /*
654: * Write the output file.
655: * If no output file was specified, use "$HOME/.less"
656: */
657: if (errors > 0)
658: {
659: fprintf(stderr, "%d errors; no output produced\n", errors);
660: exit(1);
661: }
662:
663: if (outfile == NULL)
664: outfile = homefile(LESSKEYFILE);
665: if ((out = fopen(outfile, "wb")) == NULL)
666: {
667: perror(outfile);
668: exit(1);
669: }
670:
671: /* File header */
672: fputbytes(out, fileheader, sizeof(fileheader));
673:
674: /* Command key section */
675: fputbytes(out, cmdsection, sizeof(cmdsection));
676: fputint(out, cmdtable.pbuffer - cmdtable.buffer);
677: fputbytes(out, (char *)cmdtable.buffer, cmdtable.pbuffer-cmdtable.buffer);
678: /* Edit key section */
679: fputbytes(out, editsection, sizeof(editsection));
680: fputint(out, edittable.pbuffer - edittable.buffer);
681: fputbytes(out, (char *)edittable.buffer, edittable.pbuffer-edittable.buffer);
682:
683: /* File trailer */
684: fputbytes(out, endsection, sizeof(endsection));
685: fputbytes(out, filetrailer, sizeof(filetrailer));
686: exit(0);
687: }