X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fparser%2Fparser.cpp;h=b0a743316e22b473dc5c3ce5646ff66a812eb0b1;hp=f48d37fdf5c495916d7d3c0330d92068ecdde868;hb=8cffcdf13d817a47f217f1a1043317d95969e070;hpb=05157f89a3db97fff79e33fd53156b380107011f

diff --git a/ginac/parser/parser.cpp b/ginac/parser/parser.cpp
index f48d37fd..b0a74331 100644
--- a/ginac/parser/parser.cpp
+++ b/ginac/parser/parser.cpp
@@ -1,13 +1,68 @@
-#include <stdexcept>
-#include <sstream>
-#include "parser.hpp"
-#include "lexer.hpp"
-#include "debug.hpp"
+/** @file parser.cpp
+ *
+ *  Implementation of GiNaC's parser. */
+
+/*
+ *  GiNaC Copyright (C) 1999-2019 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
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "parser.h"
+#include "lst.h"
+#include "lexer.h"
+#include "debug.h"
 #include "mul.h"
 #include "constant.h"
+#include "function.h"
+
+#include <cstdint> // for uintptr_t
+#include <sstream>
+#include <stdexcept>
 
-namespace GiNaC 
+namespace GiNaC {
+
+// <KLUDGE>
+// Find out if ptr is a pointer to a function or a specially crafted integer.
+// It's possible to distinguish between these because functions are aligned.
+// Returns true if ptr is a pointer and false otherwise.
+static bool decode_serial(unsigned& serial, const reader_func ptr)
 {
+	uintptr_t u = (uintptr_t)(void *)ptr;
+	if (u & 1) {
+		u >>= 1;
+		serial = (unsigned)u;
+		return false;
+	}
+	return true;
+}
+
+// Figures out if ptr is a pointer to function or a serial of GiNaC function.
+// In the former case calls that function, in the latter case constructs
+// GiNaC function with corresponding serial and arguments.
+static ex dispatch_reader_fcn(const reader_func ptr, const exvector& args)
+{
+	unsigned serial = 0; // dear gcc, could you please shut up?
+	bool is_ptr = decode_serial(serial, ptr);
+	if (is_ptr)
+		return ptr(args);
+	else
+		return function(serial, args);
+}
+// </KLUDGE>
+
 
 /// identifier_expr:  identifier |  identifier '(' expression* ')'
 ex parser::parse_identifier_expr()
@@ -38,12 +93,14 @@ ex parser::parse_identifier_expr()
 	// Eat the ')'.
 	get_next_tok();
 	prototype the_prototype = make_pair(name, args.size());
-	prototype_table::const_iterator reader = funcs.find(the_prototype);
+	auto reader = funcs.find(the_prototype);
 	if (reader == funcs.end()) {
 		Parse_error_("no function \"" << name << "\" with " <<
 			     args.size() << " arguments");
 	}
-	ex ret = reader->second(args);
+	// reader->second might be a pointer to a C++ function or a specially
+	// crafted serial of a GiNaC::function.
+	ex ret = dispatch_reader_fcn(reader->second, args);
 	return ret;
 }
 
@@ -59,8 +116,35 @@ ex parser::parse_paren_expr()
 	return e;
 }
 
-extern numeric* _num_1_p;
-extern ex _ex0;
+/// lst_expr:  '{' expression { ',' expression } '}'
+ex parser::parse_lst_expr()
+{
+	get_next_tok();  // eat {.
+
+	lst list;
+	if (token != '}') {
+		while (true) {
+			ex e = parse_expression(); // expression();
+			list.append(e);
+
+			if (token == '}') {
+				break;
+			}
+
+			if (token != ',') {
+				Parse_error("expected '}'");
+			}
+
+			get_next_tok();  // eat ','.
+		}
+	}
+	// Eat the '}'.
+	get_next_tok();
+
+	return list;
+}
+
+extern const ex _ex0;
 
 /// unary_expr: [+-] expression
 ex parser::parse_unary_expr()
@@ -74,7 +158,7 @@ ex parser::parse_unary_expr()
 	// -(a) 
 	// +a
 	// +(a)
-	// Delegete the work to parse_binop_rhs(), otherwise we end up
+	// Delegate the work to parse_binop_rhs(), otherwise we end up
 	// duplicating it here. 
 	ex lhs = _ex0; // silly trick
 	ex e = parse_binop_rhs(0, lhs);
@@ -91,6 +175,8 @@ ex parser::parse_primary()
 			 return parse_number_expr();
 		case '(': 
 			 return parse_paren_expr();
+		case '{': 
+			 return parse_lst_expr();
 		case '-':
 		case '+':
 			 return parse_unary_expr();
@@ -121,6 +207,7 @@ ex parser::parse_number_expr()
 /// literal_expr: 'I' | 'Pi' | 'Euler' | 'Catalan'
 ex parser::parse_literal_expr()
 {
+	get_next_tok(); // consume the literal
 	if (scanner->str == "I")
 		return I;
 	else if (scanner->str == "Pi")
@@ -137,6 +224,13 @@ ex parser::operator()(std::istream& input)
 	scanner->switch_input(&input);
 	get_next_tok();
 	ex ret = parse_expression();
+	// parse_expression() stops if it encounters an unknown token.
+	// This is not a bug: since the parser is recursive checking
+	// whether the next token is valid is responsibility of the caller.
+	// Hence make sure nothing is left in the stream:
+	if (token != lexer::token_type::eof)
+		Parse_error("expected EOF");
+
 	return ret;
 }