Annotation of OpenXM_contrib/pari/src/gp/gp_rl.c, Revision 1.1.1.1
1.1 maekawa 1: /*******************************************************************/
2: /* */
3: /* INTERFACE TO READLINE COMPLETION */
4: /* */
5: /*******************************************************************/
6: /* $Id: gp_rl.c,v 1.2 1999/09/20 16:39:33 karim Exp $ */
7: #include "pari.h"
8: #include "../language/anal.h"
9: #include "gp.h"
10:
11: #ifdef READLINE
12: typedef char** (*CF)(char*, char* (*)()); /* completion function */
13: typedef char* (*GF)(char*, int); /* generator function */
14: typedef int (*RLCI)(int, int); /* rl_complete and rl_insert functions */
15:
16: BEGINEXTERN
17: #ifdef HAS_RL_MESSAGE
18: # define USE_VARARGS
19: # define PREFER_STDARG
20: #endif
21: #ifdef READLINE_LIBRARY
22: # include <readline.h>
23: #else
24: # include <readline/readline.h>
25: #endif
26: #ifndef HAS_RL_MESSAGE
27: extern int rl_message (const char *, ...);
28: extern int rl_clear_message();
29: extern int rl_begin_undo_group(), rl_end_undo_group();
30: extern int rl_read_key();
31: extern int rl_stuff_char();
32: extern char *filename_completion_function(char *text,int state);
33: extern char *username_completion_function(char *text,int state);
34: #endif
35: char **pari_completion(char *text, int start, int end);
36: extern int rl_completion_query_items;
37: extern int rl_bind_key_in_map();
38: ENDEXTERN
39:
40: void print_fun_list(char **matches, int nbli);
41: void aide(char *s, int flag);
42:
43: extern default_type gp_default_list[];
44: extern char *keyword_list[];
45: static int add_help_keywords;
46: static entree *current_ep = NULL;
47:
48: static int pari_rl_back;
49: extern RLCI rl_last_func;
50: static int do_args_complete = 1;
51: static int do_matched_insert = 0;
52: static int did_init_matched = 0;
53:
54: #ifdef HAS_RL_SAVE_PROMPT
55: # define SAVE_PROMPT() rl_save_prompt()
56: # define RESTORE_PROMPT() rl_restore_prompt()
57: #else
58: # ifdef HAS_UNDERSCORE_RL_SAVE_PROMPT
59: # define SAVE_PROMPT() _rl_save_prompt()
60: # define RESTORE_PROMPT() _rl_restore_prompt()
61: # else
62: # define SAVE_PROMPT()
63: # define RESTORE_PROMPT()
64: # endif
65: #endif
66:
67: #define ELECTRIC_PAREN 1
68: #define ARGS_COMPLETE 2
69: static int
70: change_state(char *msg, int *opt, int count)
71: {
72: int c;
73:
74: switch(count)
75: {
76: case 0: c = 0; break; /* off */
77: case -1: c = 1; break; /* on */
78: case -2: c = 1 - *opt; /* toggle */
79: }
80: *opt = c;
81: SAVE_PROMPT();
82: rl_message("%s: %s.", (long)msg, (long)(c? "on": "off"));
83: c = rl_read_key();
84: RESTORE_PROMPT();
85: rl_clear_message();
86: rl_stuff_char(c); return 1;
87: }
88:
89: /* Wrapper around rl_complete to allow insertion of () with a point in
90: between. */
91: static int
92: pari_rl_complete(int count, int key)
93: {
94: int ret;
95:
96: pari_rl_back = 0;
97: if (count <= 0)
98: return change_state("complete args", &do_args_complete, count);
99:
100: rl_begin_undo_group();
101: if (rl_last_func == pari_rl_complete)
102: rl_last_func = (RLCI) rl_complete; /* Make repeated TABs different */
103: ret = ((RLCI)rl_complete)(count,key);
104: if (pari_rl_back && (pari_rl_back <= rl_point))
105: rl_point -= pari_rl_back;
106: rl_end_undo_group(); return ret;
107: }
108:
109: static const char paropen[] = "([{";
110: static const char parclose[] = ")]}";
111:
112: /* To allow insertion of () with a point in between. */
113: static int
114: pari_rl_matched_insert(int count, int key)
115: {
116: int i = 0, ret;
117:
118: if (count <= 0)
119: return change_state("electric parens", &do_matched_insert, count);
120: while (paropen[i] && paropen[i] != key) i++;
121: if (!paropen[i] || !do_matched_insert || under_emacs)
122: return ((RLCI)rl_insert)(count,key);
123: rl_begin_undo_group();
124: ((RLCI)rl_insert)(count,key);
125: ret = ((RLCI)rl_insert)(count,parclose[i]);
126: rl_point -= count;
127: rl_end_undo_group(); return ret;
128: }
129:
130: static int
131: pari_rl_default_matched_insert(int count, int key)
132: {
133: if (!did_init_matched) {
134: did_init_matched = 1;
135: do_matched_insert = 1;
136: }
137: return pari_rl_matched_insert(count, key);
138: }
139:
140: static int
141: pari_rl_forward_sexp(int count, int key)
142: {
143: int deep = 0, dir = 1, move_point, lfail;
144:
145: if (count < 0)
146: {
147: count = -count; dir = -1;
148: if (!rl_point) goto fail;
149: rl_point--;
150: }
151: while (count || deep)
152: {
153: move_point = 1; /* Need to move point if moving left. */
154: lfail = 0; /* Do not need to fail left movement yet. */
155: while ( !is_keyword_char(rl_line_buffer[rl_point])
156: && !strchr("\"([{}])",rl_line_buffer[rl_point])
157: && !( (dir == 1)
158: ? (rl_point >= rl_end)
159: : (rl_point <= 0 && (lfail = 1))))
160: rl_point += dir;
161: if (lfail || !rl_line_buffer[rl_point]) goto fail;
162:
163: if (is_keyword_char(rl_line_buffer[rl_point]))
164: {
165: while ( is_keyword_char(rl_line_buffer[rl_point])
166: && (!((dir == 1) ? (rl_point >= rl_end) : (rl_point <= 0))
167: || (move_point = 0)))
168: rl_point += dir;
169: if (!deep) count--;
170: }
171: else if (strchr(paropen,rl_line_buffer[rl_point]))
172: {
173: if (deep == 0 && dir == -1) goto fail; /* We are already out of pars. */
174: rl_point += dir;
175: deep++; if (!deep) count--;
176: }
177: else if (strchr(parclose,rl_line_buffer[rl_point]))
178: {
179: if (deep == 0 && dir == 1)
180: {
181: rl_point++; goto fail; /* Get out of pars. */
182: }
183: rl_point += dir;
184: deep--; if (!deep) count--;
185: }
186: else if (rl_line_buffer[rl_point] == '\"')
187: {
188: int bad = 1;
189:
190: rl_point += dir;
191: while ( ((rl_line_buffer[rl_point] != '\"') || (bad = 0))
192: && (!((dir == 1) ? (rl_point >= rl_end) : (rl_point <= 0))
193: || (move_point = 0)) )
194: rl_point += dir;
195: if (bad) goto fail;
196: rl_point += dir; /* Skip the other delimiter */
197: if (!deep) count--;
198: }
199: else
200: {
201: fail: ding(); return 1;
202: }
203: }
204: if (dir != 1 && move_point) rl_point++;
205: return 1;
206: }
207:
208: static int
209: pari_rl_backward_sexp(int count, int key)
210: {
211: return pari_rl_forward_sexp(-count, key);
212: }
213:
214: /* do we add () at the end of completed word? (is it a function?) */
215: static int
216: add_paren(int end)
217: {
218: entree *ep;
219: char *s;
220:
221: if (end < 0 || rl_line_buffer[end] == '(')
222: return 0; /* not from command_generator or already there */
223: ep = do_alias(current_ep); /* current_ep set in command_generator */
224: if (EpVALENCE(ep) < EpUSER)
225: { /* is it a constant masked as a function (e.g Pi)? */
226: s = ep->help; if (!s) return 1;
227: while (is_keyword_char(*s)) s++;
228: return (*s != '=');
229: }
230: switch(EpVALENCE(ep))
231: {
232: case EpUSER:
233: case EpINSTALL: return 1;
234: }
235: return 0;
236: }
237:
238: static void
239: match_concat(char **matches, char *s)
240: {
241: int i = strlen(matches[0]) + 1;
242: matches[0] = (char*) gprealloc(matches[0], i+strlen(s), i);
243: strcat(matches[0],s);
244: }
245:
246: static char **
247: matches_for_emacs(char *text, char **matches)
248: {
249: if (!matches) printf("@");
250: else
251: {
252: int i;
253: printf("%s@", matches[0] + strlen(text));
254: if (matches[1]) print_fun_list(matches+1,0);
255:
256: /* we don't want readline to do anything, but insert some junk
257: * which will be erased by emacs.
258: */
259: for (i=0; matches[i]; i++) free(matches[i]);
260: free(matches);
261: }
262: matches = (char **) gpmalloc(2*sizeof(char *));
263: matches[0] = gpmalloc(2); sprintf(matches[0],"_");
264: matches[1] = NULL; printf("@E_N_D"); pariflush();
265: return matches;
266: }
267:
268: #define add_comma(x) (x==-2) /* from default_generator */
269:
270: /* Attempt to complete on the contents of TEXT. END points to the end of the
271: * word to complete. Return the array of matches, or NULL if there aren't any.
272: */
273: static char **
274: get_matches(int end, char *text, char* f(char*,int))
275: {
276: char **matches;
277:
278: #ifdef HAS_COMPLETION_APPEND_CHAR
279: rl_completion_append_character = ' ';
280: #endif
281: current_ep = NULL;
282: matches = ((CF) completion_matches)(text, (char *(*)())f);
283: if (matches && !matches[1]) /* a single match */
284: {
285: if (add_paren(end))
286: {
287: match_concat(matches,"()");
288: pari_rl_back = 1;
289: if (rl_point == rl_end)
290: #ifdef HAS_COMPLETION_APPEND_CHAR
291: rl_completion_append_character = '\0'; /* Do not append space. */
292: #else
293: pari_rl_back = 2;
294: #endif
295: }
296: else if (add_comma(end))
297: match_concat(matches,",");
298: }
299: if (under_emacs) matches = matches_for_emacs(text,matches);
300: return matches;
301: }
302: #undef add_comma
303:
304: static char *
305: add_junk(char *name, char *text, long junk)
306: {
307: char *s = strncpy((char*) gpmalloc(strlen(name)+1+junk),text,junk);
308: strcpy(s+junk,name); return s;
309: }
310:
311: /* Generator function for command completion. STATE lets us know whether
312: * to start from scratch; without any state (i.e. STATE == 0), then we
313: * start at the top of the list.
314: */
315: static char *
316: hashtable_generator (char *text, int state, entree **hash)
317: {
318: static int hashpos, len, junk, n;
319: static entree* ep;
320: static char *TEXT;
321:
322: /* If this is a new word to complete, initialize now:
323: * + indexes hashpos (GP hash list) and n (keywords specific to long help).
324: * + file completion and keyword completion use different word boundaries,
325: * have TEXT point to the keyword start.
326: * + save the length of TEXT for efficiency.
327: */
328: if (!state)
329: {
330: n = hashpos = 0; ep=hash[hashpos];
331: len=strlen(text); junk=len-1;
332: while (junk >= 0 && is_keyword_char(text[junk])) junk--;
333: junk++; len -= junk; TEXT = text + junk;
334: }
335:
336: /* First check the keywords list */
337: if (add_help_keywords)
338: {
339: for ( ; keyword_list[n]; n++)
340: if (!strncmp(keyword_list[n],TEXT,len))
341: {
342: text = add_junk(keyword_list[n],text,junk);
343: n++; return text;
344: }
345: }
346:
347: /* Return the next name which partially matches from the command list. */
348: for(;;)
349: if (!ep)
350: {
351: if (++hashpos >= functions_tblsz) return NULL; /* no names matched */
352: ep = hash[hashpos];
353: }
354: else if (strncmp(ep->name,TEXT,len))
355: ep = ep->next;
356: else
357: break;
358: current_ep = ep;
359: text = add_junk(ep->name,text,junk);
360: ep=ep->next; return text;
361: }
362:
363: static char *
364: command_generator (char *text, int state)
365: {
366: return hashtable_generator(text,state, functions_hash);
367: }
368: static char *
369: member_generator (char *text, int state)
370: {
371: return hashtable_generator(text,state, members_hash);
372: }
373:
374: #define DFLT 0
375: #define ENTREE 1
376:
377: static char *
378: generator(void *list, char *text, int *nn, int len, int typ)
379: {
380: char *def = NULL, *name;
381: int n = *nn;
382:
383: /* Return the next name which partially matches from list.*/
384: switch(typ)
385: {
386: case DFLT :
387: do
388: def = (((default_type *) list)[n++]).name;
389: while (def && strncmp(def,text,len));
390: break;
391:
392: case ENTREE :
393: do
394: def = (((entree *) list)[n++]).name;
395: while (def && strncmp(def,text,len));
396: }
397:
398: *nn = n;
399: if (def)
400: {
401: name = strcpy((char*) gpmalloc(strlen(def)+1), def);
402: return name;
403: }
404: return NULL; /* no names matched */
405: }
406:
407: static char *
408: old_generator(char *text,int state)
409: {
410: static int n,len;
411: static char *res;
412:
413: if (!state) { res = "a"; n=0; len=strlen(text); }
414: if (res)
415: {
416: res = generator((void *)oldfonctions,text,&n,len,ENTREE);
417: if (res) return res;
418: n=0;
419: }
420: return generator((void *)functions_oldgp,text,&n,len,ENTREE);
421: }
422:
423: static char *
424: default_generator(char *text,int state)
425: {
426: static int n,len;
427:
428: if (!state) { n=0; len=strlen(text); }
429: return generator(gp_default_list,text,&n,len,DFLT);
430: }
431:
432: char **
433: pari_completion(char *text, int start, int end)
434: {
435: int i, first=0;
436:
437: /* If the line does not begin by a backslash, then it is:
438: * . an old command ( if preceded by "whatnow(" ).
439: * . a default ( if preceded by "default(" ).
440: * . a member function ( if preceded by "." within 4 letters )
441: * . a file name (in current directory) ( if preceded by "read(" )
442: * . a command
443: */
444: if (start >=1 && rl_line_buffer[start] != '~') start--;
445: while (start && is_keyword_char(rl_line_buffer[start])) start--;
446: if (rl_line_buffer[start] == '~')
447: {
448: for(i=start+1;i<=end;i++)
449: if (rl_line_buffer[i] == '/')
450: return get_matches(-1,text,(GF)filename_completion_function);
451: return get_matches(-1,text,(GF)username_completion_function);
452: }
453:
454: while (rl_line_buffer[first] && isspace((int)rl_line_buffer[first])) first++;
455: switch (rl_line_buffer[first])
456: {
457: case '\\':
458: if (first == start) text = rl_line_buffer+start+1;
459: return get_matches(-1,text,(GF)filename_completion_function);
460: case '?':
461: if (rl_line_buffer[first+1] == '?') add_help_keywords = 1;
462: return get_matches(-1,text,command_generator);
463: }
464:
465: while (start && rl_line_buffer[start] != '('
466: && rl_line_buffer[start] != ',') start--;
467: if (rl_line_buffer[start] == '(' && start)
468: {
469: #define MAX_KEYWORD 200
470: int iend, j;
471: entree *ep;
472: char buf[MAX_KEYWORD];
473:
474: i = start;
475:
476: while (i && isspace((int)rl_line_buffer[i-1])) i--;
477: iend = i;
478: while (i && is_keyword_char(rl_line_buffer[i-1])) i--;
479:
480: if (iend - i == 7)
481: {
482: if (strncmp(rl_line_buffer + i,"default",7) == 0)
483: return get_matches(-2,text,default_generator);
484: if (strncmp(rl_line_buffer + i,"whatnow",7) == 0)
485: return get_matches(-1,text,old_generator);
486: }
487: if (iend - i >= 4)
488: {
489: if (strncmp(rl_line_buffer + i,"read",4) == 0)
490: return get_matches(-1,text,(GF)filename_completion_function);
491: }
492:
493: j = start + 1;
494: while (j && isspace((int)rl_line_buffer[j])) j++;
495: /* If we are in empty parens, insert arguments for the function: */
496: if ( (rl_line_buffer[j] == ')' || !rl_line_buffer[j] )
497: && do_args_complete
498: && (iend - i < MAX_KEYWORD)
499: && ( strncpy(buf, rl_line_buffer + i, iend - i),
500: buf[iend - i] = 0, 1)
501: && (ep = is_entry(buf)) && ep->help)
502: {
503: char *s = ep->help;
504:
505: while (is_keyword_char(*s)) s++;
506: if (*s++ == '(')
507: { /* Function, print arguments! */
508: char *endh = s;
509: while (*endh && *endh != ')' && *endh != '(') endh++;
510: if (*endh == ')')
511: { /* Well-formed help. */
512: char *str = strncpy((char*) gpmalloc(endh-s + 1), s, endh-s);
513: char **ret = (char**)gpmalloc(sizeof(char*)*2);
514: str[endh-s] = 0;
515: ret[0] = str; ret[1] = NULL;
516: if (under_emacs) ret = matches_for_emacs("",ret);
517: return ret;
518: }
519: }
520: }
521: }
522: for(i=end-1;i>=start;i--)
523: if (!is_keyword_char(rl_line_buffer[i]))
524: {
525: if (rl_line_buffer[i] == '.')
526: return get_matches(-1,text,member_generator);
527: break;
528: }
529: add_help_keywords = 0;
530: return get_matches(end,text,command_generator);
531: }
532:
533: static int
534: rl_short_help(int count, int key)
535: {
536: int p=rl_point, off=p, e = rl_end;
537: FILE *save = pari_outfile;
538: long flag = h_RL;
539:
540: while (off && is_keyword_char(rl_line_buffer[off-1])) off--;
541: rl_point = 0; rl_end = 0; pari_outfile = rl_outstream;
542: if (count < 0) flag |= h_LONG; /* long help */
543: SAVE_PROMPT();
544: rl_message("",0,0);
545: aide(rl_line_buffer + off, flag);
546: RESTORE_PROMPT();
547: rl_point = p; rl_end = e; pari_outfile = save;
548: rl_clear_message();
549: #ifdef RL_REFRESH_LINE_OLDPROTO
550: rl_refresh_line();
551: #else
552: rl_refresh_line(count,key);
553: #endif
554: return 0;
555: }
556:
557: static int
558: rl_long_help(int count, int key)
559: {
560: return rl_short_help(-1,key);
561: }
562:
563: void
564: init_readline()
565: {
566: /* Allow conditional parsing of the ~/.inputrc file. */
567: rl_readline_name = "Pari-GP";
568:
569: /* added ~, ? and , */
570: rl_basic_word_break_characters = " \t\n\"\\'`@$><=;|&{(?,~";
571: rl_special_prefixes = "~";
572:
573: /* custom completer */
574: #ifndef CPPFunction_defined
575: # define CPPFunction Function
576: #endif
577: rl_attempted_completion_function = (CPPFunction *) pari_completion;
578:
579: /* we always want the whole list of completions under emacs */
580: if (under_emacs) rl_completion_query_items = 0x8fff;
581:
582: #define Bind ((void(*)(int,Function*,Keymap)) rl_bind_key_in_map)
583: #define Defun ((void(*)(const char*,Function*,int)) rl_add_defun)
584:
585: Defun("short-help", (Function*) rl_short_help, -1);
586: Defun("long-help", (Function*) rl_long_help, -1);
587: Defun("pari-complete", (Function*) pari_rl_complete, '\t');
588: Defun("pari-matched-insert", (Function*) pari_rl_default_matched_insert, -1);
589: Defun("pari-forward-sexp", (Function*) pari_rl_forward_sexp, -1);
590: Defun("pari-backward-sexp", (Function*) pari_rl_backward_sexp, -1);
591:
592: Bind('h', (Function*) rl_short_help, emacs_meta_keymap);
593: Bind('H', (Function*) rl_long_help, emacs_meta_keymap);
594: Bind('h', (Function*) rl_short_help, vi_movement_keymap);
595: Bind('H', (Function*) rl_long_help, vi_movement_keymap);
596: Bind('(', (Function*) pari_rl_matched_insert, emacs_standard_keymap);
597: Bind('[', (Function*) pari_rl_matched_insert, emacs_standard_keymap);
598: Bind(6, (Function*) pari_rl_forward_sexp, emacs_meta_keymap); /* M-C-f */
599: Bind(2, (Function*) pari_rl_backward_sexp, emacs_meta_keymap); /* M-C-b */
600:
601: #ifdef EMACS_DOS_KEYMAP
602: Bind(';', (Function*) rl_short_help, emacs_dos_keymap); /* F1 */
603: Bind('T', (Function*) rl_long_help, emacs_dos_keymap); /* Shift-F1 */
604: Bind(155, (Function*) pari_rl_backward_sexp, emacs_dos_keymap); /* Alt-Left */
605: Bind(157, (Function*) pari_rl_forward_sexp, emacs_dos_keymap); /* Alt-Right*/
606: #endif
607: }
608: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to gp_rl.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / pari / src / gp