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