* This file must be processed with yacc/bison. */
/*
- * GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany
+ * GiNaC Copyright (C) 1999-2002 Johannes Gutenberg University Mainz, Germany
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
typedef multimap<string, string> help_tab;
static help_tab help;
+static void insert_fcn_help(const char *name, const char *str);
static void print_help(const string &topic);
static void print_help_topics(void);
%}
| T_SYMBOL '(' exprseq ')' {
fcn_tab::const_iterator i = find_function($1, $3.nops());
if (i->second.is_ginac) {
- $$ = ((fcnp2)(i->second.p))(static_cast<const exprseq &>(*($3.bp)), i->second.serial);
+ $$ = ((fcnp2)(i->second.p))(ex_to<exprseq>($3), i->second.serial);
} else {
- $$ = (i->second.p)(static_cast<const exprseq &>(*($3.bp)));
+ $$ = (i->second.p)(ex_to<exprseq>($3));
}
}
| T_DIGITS '=' T_NUMBER {$$ = $3; Digits = ex_to<numeric>($3).to_int();}
- | T_SYMBOL '=' exp {$$ = $3; const_cast<symbol *>(&ex_to<symbol>($1))->assign($3);}
+ | T_SYMBOL '=' exp {$$ = $3; const_cast<symbol&>(ex_to<symbol>($1)).assign($3);}
| exp T_EQUAL exp {$$ = $1 == $3;}
| exp T_NOTEQ exp {$$ = $1 != $3;}
| exp '<' exp {$$ = $1 < $3;}
;
exprseq : exp {$$ = exprseq($1);}
- | exprseq ',' exp {exprseq es(static_cast<exprseq &>(*($1.bp))); $$ = es.append($3);}
+ | exprseq ',' exp {exprseq es(ex_to<exprseq>($1)); $$ = es.append($3);}
;
list_or_empty: /* empty */ {$$ = *new lst;}
;
list : exp {$$ = lst($1);}
- | list ',' exp {lst l(static_cast<lst &>(*($1.bp))); $$ = l.append($3);}
+ | list ',' exp {lst l(ex_to<lst>($1)); $$ = l.append($3);}
;
matrix : '[' row ']' {$$ = lst($2);}
- | matrix ',' '[' row ']' {lst l(static_cast<lst &>(*($1.bp))); $$ = l.append($4);}
+ | matrix ',' '[' row ']' {lst l(ex_to<lst>($1)); $$ = l.append($4);}
;
row : exp {$$ = lst($1);}
- | row ',' exp {lst l(static_cast<lst &>(*($1.bp))); $$ = l.append($3);}
+ | row ',' exp {lst l(ex_to<lst>($1)); $$ = l.append($3);}
;
return e[0].evalf(ex_to<numeric>(e[1]).to_int());
}
+static ex f_find(const exprseq &e)
+{
+ lst found;
+ e[0].find(e[1], found);
+ return found;
+}
+
static ex f_inverse(const exprseq &e)
{
CHECK_ARG(0, matrix, inverse);
return (bool)ex_to<relational>(e[0]) ? ex(1) : ex(0);
}
+class apply_map_function : public map_function {
+ ex apply;
+public:
+ apply_map_function(const ex & a) : apply(a) {}
+ virtual ~apply_map_function() {}
+ ex operator()(const ex & e) { return apply.subs(wild() == e, true); }
+};
+
+static ex f_map(const exprseq &e)
+{
+ apply_map_function fcn(e[1]);
+ return e[0].map(fcn);
+}
+
static ex f_match(const exprseq &e)
{
lst repl_lst;
static ex f_unassign(const exprseq &e)
{
CHECK_ARG(0, symbol, unassign);
- (const_cast<symbol *>(&ex_to<symbol>(e[0])))->unassign();
+ const_cast<symbol&>(ex_to<symbol>(e[0])).unassign();
return e[0];
}
throw(std::logic_error("dummy function called (shouldn't happen)"));
}
-// Table for initializing the "fcns" map
+// Tables for initializing the "fcns" map and the function help topics
struct fcn_init {
const char *name;
const fcn_desc desc;
{"evalf", fcn_desc(f_evalf2, 2)},
{"evalm", fcn_desc(f_evalm, 1)},
{"expand", fcn_desc(f_expand, 1)},
+ {"find", fcn_desc(f_find, 2)},
{"gcd", fcn_desc(f_gcd, 2)},
{"has", fcn_desc(f_has, 2)},
{"inverse", fcn_desc(f_inverse, 1)},
{"lcoeff", fcn_desc(f_lcoeff, 2)},
{"ldegree", fcn_desc(f_ldegree, 2)},
{"lsolve", fcn_desc(f_lsolve, 2)},
+ {"map", fcn_desc(f_map, 2)},
{"match", fcn_desc(f_match, 2)},
{"nops", fcn_desc(f_nops, 1)},
{"normal", fcn_desc(f_normal1, 1)},
{NULL, fcn_desc(f_dummy, 0)} // End marker
};
+struct fcn_help_init {
+ const char *name;
+ const char *help;
+};
+
+static const fcn_help_init builtin_help[] = {
+ {"acos", "inverse cosine function"},
+ {"acosh", "inverse hyperbolic cosine function"},
+ {"asin", "inverse sine function"},
+ {"asinh", "inverse hyperbolic sine function"},
+ {"atan", "inverse tangent function"},
+ {"atan2", "inverse tangent function with two arguments"},
+ {"atanh", "inverse hyperbolic tangent function"},
+ {"beta", "Beta function"},
+ {"binomial", "binomial function"},
+ {"cos", "cosine function"},
+ {"cosh", "hyperbolic cosine function"},
+ {"exp", "exponential function"},
+ {"factorial", "factorial function"},
+ {"lgamma", "natural logarithm of Gamma function"},
+ {"tgamma", "Gamma function"},
+ {"log", "natural logarithm"},
+ {"psi", "psi function\npsi(x) is the digamma function, psi(n,x) the nth polygamma function"},
+ {"sin", "sine function"},
+ {"sinh", "hyperbolic sine function"},
+ {"tan", "tangent function"},
+ {"tanh", "hyperbolic tangent function"},
+ {"zeta", "zeta function\nzeta(x) is Riemann's zeta function, zeta(n,x) its nth derivative"},
+ {"Li2", "dilogarithm"},
+ {"Li3", "trilogarithm"},
+ {"Order", "order term function (for truncated power series)"},
+ {"Derivative", "inert differential operator"},
+ {NULL, NULL} // End marker
+};
+
+#include "ginsh_extensions.h"
+
/*
* Add functions to ginsh
unsigned serial = 0;
while (i != end) {
fcns.insert(make_pair(i->get_name(), fcn_desc(f_ginac_function, i->get_nparams(), serial)));
- i++;
+ ++i;
serial++;
}
}
}
}
+// Help strings for functions from fcn_help_init array
+static void insert_help(const fcn_help_init *p)
+{
+ while (p->name) {
+ insert_fcn_help(p->name, p->help);
+ p++;
+ }
+}
+
/*
* Print help to cout
* Function name completion functions for readline
*/
-static char *fcn_generator(char *text, int state)
+static char *fcn_generator(const char *text, int state)
{
static int len; // Length of word to complete
static fcn_tab::const_iterator index; // Iterator to function being currently considered
// Return the next function which partially matches
while (index != fcns.end()) {
const char *fcn_name = index->first.c_str();
- index++;
+ ++index;
if (strncmp(fcn_name, text, len) == 0)
return strdup(fcn_name);
}
return NULL;
}
-static char **fcn_completion(char *text, int start, int end)
+static char **fcn_completion(const char *text, int start, int end)
{
if (rl_line_buffer[0] == '!') {
// For shell commands, revert back to filename completion
rl_basic_word_break_characters = orig_basic_word_break_characters;
rl_completer_word_break_characters = rl_basic_word_break_characters;
#if (GINAC_RL_VERSION_MAJOR < 4) || (GINAC_RL_VERSION_MAJOR == 4 && GINAC_RL_VERSION_MINOR < 2)
- return completion_matches(text, (CPFunction *)filename_completion_function);
+ return completion_matches(const_cast<char *>(text), (CPFunction *)filename_completion_function);
#else
- return rl_completion_matches(text, (CPFunction *)rl_filename_completion_function);
+ return rl_completion_matches(text, rl_filename_completion_function);
#endif
} else {
// Otherwise, complete function names
rl_basic_word_break_characters = " \t\n\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~";
rl_completer_word_break_characters = rl_basic_word_break_characters;
#if (GINAC_RL_VERSION_MAJOR < 4) || (GINAC_RL_VERSION_MAJOR == 4 && GINAC_RL_VERSION_MINOR < 2)
- return completion_matches(text, (CPFunction *)fcn_generator);
+ return completion_matches(const_cast<char *>(text), (CPFunction *)fcn_generator);
#else
- return rl_completion_matches(text, (CPFunction *)fcn_generator);
+ return rl_completion_matches(text, fcn_generator);
#endif
}
}
void greeting(void)
{
cout << "ginsh - GiNaC Interactive Shell (" << PACKAGE << " V" << VERSION << ")" << endl;
- cout << " __, _______ Copyright (C) 1999-2001 Johannes Gutenberg University Mainz,\n"
+ cout << " __, _______ Copyright (C) 1999-2002 Johannes Gutenberg University Mainz,\n"
<< " (__) * | Germany. This is free software with ABSOLUTELY NO WARRANTY.\n"
<< " ._) i N a C | You are welcome to redistribute it under certain conditions.\n"
<< "<-------------' For details type `warranty;'.\n" << endl;
// Init function table
insert_fcns(builtin_fcns);
+ insert_fcns(extended_fcns);
ginsh_get_ginac_functions();
// Init help for operators (automatically generated from man page)
insert_help("operators", "Operators in falling order of precedence:");
-#include "ginsh_op_help.c"
+#include "ginsh_op_help.h"
// Init help for built-in functions (automatically generated from man page)
-#include "ginsh_fcn_help.c"
+#include "ginsh_fcn_help.h"
// Help for GiNaC functions is added manually
- insert_fcn_help("acos", "inverse cosine function");
- insert_fcn_help("acosh", "inverse hyperbolic cosine function");
- insert_fcn_help("asin", "inverse sine function");
- insert_fcn_help("asinh", "inverse hyperbolic sine function");
- insert_fcn_help("atan", "inverse tangent function");
- insert_fcn_help("atan2", "inverse tangent function with two arguments");
- insert_fcn_help("atanh", "inverse hyperbolic tangent function");
- insert_fcn_help("beta", "Beta function");
- insert_fcn_help("binomial", "binomial function");
- insert_fcn_help("cos", "cosine function");
- insert_fcn_help("cosh", "hyperbolic cosine function");
- insert_fcn_help("exp", "exponential function");
- insert_fcn_help("factorial", "factorial function");
- insert_fcn_help("lgamma", "natural logarithm of Gamma function");
- insert_fcn_help("tgamma", "Gamma function");
- insert_fcn_help("log", "natural logarithm");
- insert_fcn_help("psi", "psi function\npsi(x) is the digamma function, psi(n,x) the nth polygamma function");
- insert_fcn_help("sin", "sine function");
- insert_fcn_help("sinh", "hyperbolic sine function");
- insert_fcn_help("tan", "tangent function");
- insert_fcn_help("tanh", "hyperbolic tangent function");
- insert_fcn_help("zeta", "zeta function\nzeta(x) is Riemann's zeta function, zeta(n,x) its nth derivative");
- insert_fcn_help("Li2", "dilogarithm");
- insert_fcn_help("Li3", "trilogarithm");
- insert_fcn_help("Order", "order term function (for truncated power series)");
+ insert_help(builtin_help);
+ insert_help(extended_help);
// Init readline completer
rl_readline_name = argv[0];
+#if (GINAC_RL_VERSION_MAJOR < 4) || (GINAC_RL_VERSION_MAJOR == 4 && GINAC_RL_VERSION_MINOR < 2)
rl_attempted_completion_function = (CPPFunction *)fcn_completion;
+#else
+ rl_attempted_completion_function = fcn_completion;
+#endif
orig_completion_append_character = rl_completion_append_character;
orig_basic_word_break_characters = rl_basic_word_break_characters;