[BUGFIX] Fix crash in parser.

[ginac.git] / ginac / parser / parser.cpp

diff --git a/ginac/parser/parser.cpp b/ginac/parser/parser.cpp
index acf5f3d00260a9ee58ef62a6f5c6badc440fa27a..a7288c32a6b3e614c6b06adc910a5fff2fcb9e99 100644 (file)
--- a/ginac/parser/parser.cpp
+++ b/ginac/parser/parser.cpp
@@ -3,7 +3,7 @@
  *  Implementation of GiNaC's parser. */
 
 /*
- *  GiNaC Copyright (C) 1999-2009 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2024 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
@@ -21,46 +21,31 @@
  */
 
 #include "parser.h"
+#include "lst.h"
 #include "lexer.h"
 #include "debug.h"
 #include "mul.h"
 #include "constant.h"
 #include "function.h"
+#include "operators.h"
 
+#include <cstdint> // for uintptr_t
 #include <sstream>
 #include <stdexcept>
 
 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)
+ex reader_func::operator()(const exvector& args) const
 {
-       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
+       switch (type) {
+       case FUNCTION_PTR:
+               return func(args);
+       case GINAC_FUNCTION:
                return function(serial, args);
+       default:
+               abort();
+       }
 }
-// </KLUDGE>
-
 
 /// identifier_expr:  identifier |  identifier '(' expression* ')'
 ex parser::parse_identifier_expr()
@@ -90,16 +75,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({name, args.size()});
        if (reader == funcs.end()) {
                Parse_error_("no function \"" << name << "\" with " <<
                             args.size() << " arguments");
        }
        // 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;
+       return reader->second(args);
 }
 
 /// paren_expr:  '(' expression ')'
@@ -114,26 +97,32 @@ ex parser::parse_paren_expr()
        return e;
 }
 
-extern numeric* _num_1_p;
-extern ex _ex0;
-
-/// unary_expr: [+-] expression
-ex parser::parse_unary_expr()
+/// lst_expr:  '{' expression { ',' expression } '}'
+ex parser::parse_lst_expr()
 {
-       // Unlike most other parse_* method this one does NOT consume
-       // current token so parse_binop_rhs() knows what kind of operator
-       // is being parsed.
-       
-       // There are different kinds of expressions which need to be handled:
-       // -a+b 
-       // -(a) 
-       // +a
-       // +(a)
-       // Delegete 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);
-       return e;
+       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;
 }
 
 /// primary: identifier_expr | number_expr | paren_expr | unary_expr 
@@ -146,7 +135,10 @@ ex parser::parse_primary()
                         return parse_number_expr();
                case '(': 
                         return parse_paren_expr();
+               case '{': 
+                        return parse_lst_expr();
                case '-':
+                        return -parse_unary_expr();
                case '+':
                         return parse_unary_expr();
                case lexer::token_type::literal:
@@ -194,7 +186,7 @@ ex parser::operator()(std::istream& 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
+       // 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)