Return to calcread.c CVS log

Up to [local] / OpenXM_contrib / gmp / demos / calc

Annotation of OpenXM_contrib/gmp/demos/calc/calcread.c, Revision 1.1.1.1

1.1       ohara       1: /* Readline support for calc program.
                      2:
                      3: Copyright 2000, 2001 Free Software Foundation, Inc.
                      4:
                      5: This file is part of the GNU MP Library.
                      6:
                      7: This program is free software; you can redistribute it and/or modify it under
                      8: the terms of the GNU General Public License as published by the Free Software
                      9: Foundation; either version 2 of the License, or (at your option) any later
                     10: version.
                     11:
                     12: This program is distributed in the hope that it will be useful, but WITHOUT ANY
                     13: WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
                     14: PARTICULAR PURPOSE.  See the GNU General Public License for more details.
                     15:
                     16: You should have received a copy of the GNU General Public License along with
                     17: this program; if not, write to the Free Software Foundation, Inc., 59 Temple
                     18: Place - Suite 330, Boston, MA 02111-1307, USA. */
                     19:
                     20: #include "calc-common.h"
                     21:
                     22: #if WITH_READLINE
                     23: #include <stdio.h>   /* for FILE for old versions of readline/readline.h */
                     24: #include <stdlib.h>  /* for free */
                     25: #include <string.h>  /* for strdup */
                     26: #include <unistd.h>  /* for isatty */
                     27: #include <readline/readline.h>
                     28: #include <readline/history.h>
                     29:
                     30: #include "gmp.h"
                     31:
                     32:
                     33: /* change this to "#define TRACE(x) x" for a few diagnostics */
                     34: #define TRACE(x)
                     35:
                     36:
                     37: #define MIN(x,y) ((x) < (y) ? (x) : (y))
                     38:
                     39: char *
                     40: calc_completion_entry (const char *text, int state)
                     41: {
                     42:   static int  index, len;
                     43:   char  *name;
                     44:
                     45:   if (!state)
                     46:     {
                     47:       index = 0;
                     48:       len = strlen (text);
                     49:     }
                     50:   TRACE (printf ("calc_completion_entry %s %d, index=%d len=%d\n",
                     51:                  text, state, index, len));
                     52:   while ((name = calc_keywords[index].name) != NULL)
                     53:     {
                     54:       index++;
                     55:       if (memcmp (name, text, len) == 0)
                     56:         return (strdup (name));
                     57:     }
                     58:   return NULL;
                     59: }
                     60:
                     61: void
                     62: calc_init_readline (void)
                     63: {
                     64:   /* By default use readline when the input is a tty.  It's a bit contrary
                     65:      to the GNU interface conventions to make the behaviour depend on where
                     66:      the input is coming from, but this is pretty convenient.  */
                     67:   if (calc_option_readline == -1)
                     68:     {
                     69:       calc_option_readline = isatty (fileno (stdin));
                     70:       TRACE (printf ("calc_option_readline %d\n", calc_option_readline));
                     71:     }
                     72:
                     73:   if (calc_option_readline)
                     74:     {
                     75:       printf ("GNU MP demo calculator program, gmp version %s\n", gmp_version);
                     76:       printf ("Type \"help\" for help.\n");
                     77:       rl_readline_name = "gmp-calc";
                     78:       rl_completion_entry_function = calc_completion_entry;
                     79:     }
                     80: }
                     81:
                     82:
                     83: /* This function is supposed to return YY_NULL to indicate EOF, but that
                     84:    constant is only in calclex.c and we don't want to clutter calclex.l with
                     85:    this readline stuff, so instead just hard code 0 for YY_NULL.  That's
                     86:    it's defined value on unix anyway.  */
                     87:
                     88: int
                     89: calc_input (char *buf, size_t max_size)
                     90: {
                     91:   if (calc_option_readline)
                     92:     {
                     93:       static char    *line = NULL;
                     94:       static size_t  line_size = 0;
                     95:       static size_t  upto = 0;
                     96:       size_t         copy_size;
                     97:
                     98:       if (upto >= line_size)
                     99:         {
                    100:           if (line != NULL)
                    101:             free (line);
                    102:
                    103:           line = readline (calc_more_input ? "more> " : "> ");
                    104:           calc_more_input = 1;
                    105:           if (line == NULL)
                    106:             return 0;
                    107:           TRACE (printf ("readline: %s\n", line));
                    108:
                    109:           if (line[0] != '\0')
                    110:             add_history (line);
                    111:
                    112:           line_size = strlen (line);
                    113:           line[line_size] = '\n';
                    114:           line_size++;
                    115:           upto = 0;
                    116:         }
                    117:
                    118:       copy_size = MIN (line_size-upto, max_size);
                    119:       memcpy (buf, line+upto, copy_size);
                    120:       upto += copy_size;
                    121:       return copy_size;
                    122:     }
                    123:   else
                    124:     {
                    125:       /* not readline */
                    126:       return fread (buf, 1, max_size, stdin);
                    127:     }
                    128: }
                    129:
                    130:
                    131: /* This redefined input() might let a traditional lex use the readline
                    132:    support here.  Apparently POSIX doesn't specify whether an override like
                    133:    this will work, so maybe it'll work or maybe it won't.  This function is
                    134:    also not particularly efficient, but don't worry about that, since flex
                    135:    is the preferred parser.  */
                    136:
                    137: int
                    138: input (void)
                    139: {
                    140:   char  c;
                    141:   if (calc_input (&c, 1) != 1)
                    142:     return EOF;
                    143:   else
                    144:     return (int) c;
                    145: }
                    146:
                    147: #endif /* WITH_READLINE */