muParser API -  1.35
muParserDef.h
Go to the documentation of this file.
1 /*
2 
3  _____ __ _____________ _______ ______ ___________
4  / \| | \____ \__ \\_ __ \/ ___// __ \_ __ \
5  | Y Y \ | / |_> > __ \| | \/\___ \\ ___/| | \/
6  |__|_| /____/| __(____ /__| /____ >\___ >__|
7  \/ |__| \/ \/ \/
8  Copyright (C) 2004 - 2020 Ingo Berg
9 
10  Redistribution and use in source and binary forms, with or without modification, are permitted
11  provided that the following conditions are met:
12 
13  * Redistributions of source code must retain the above copyright notice, this list of
14  conditions and the following disclaimer.
15  * Redistributions in binary form must reproduce the above copyright notice, this list of
16  conditions and the following disclaimer in the documentation and/or other materials provided
17  with the distribution.
18 
19  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
20  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
21  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
22  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25  IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
26  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28 
29 #ifndef MUP_DEF_H
30 #define MUP_DEF_H
31 
32 #include <iostream>
33 #include <string>
34 #include <sstream>
35 #include <map>
36 
37 #include "muParserFixes.h"
38 
39 /** \file
40  \brief This file contains standard definitions used by the parser.
41 */
42 
43 /** \brief Define the base datatype for values.
44 
45  This datatype must be a built in value type. You can not use custom classes.
46  It should be working with all types except "int"!
47 */
48 #define MUP_BASETYPE double
49 
50 /** \brief Activate this option in order to compile with OpenMP support.
51 
52  OpenMP is used only in the bulk mode it may increase the performance a bit.
53 
54  !!! DO NOT ACTIVATE THIS MACRO HERE IF YOU USE CMAKE FOR BUILDING !!!
55 
56  use the cmake option instead!
57 */
58 //#define MUP_USE_OPENMP
59 
60 #if defined(_UNICODE)
61  /** \brief Definition of the basic parser string type. */
62  #define MUP_STRING_TYPE std::wstring
63 
64  #if !defined(_T)
65  #define _T(x) L##x
66  #endif // not defined _T
67 #else
68  #ifndef _T
69  #define _T(x) x
70  #endif
71 
72  /** \brief Definition of the basic parser string type. */
73  #define MUP_STRING_TYPE std::string
74 #endif
75 
76 /** \brief An assertion that does not kill the program. */
77 #define MUP_ASSERT(COND) \
78  if (!(COND)) \
79  { \
80  stringstream_type ss; \
81  ss << _T("Assertion \"") _T(#COND) _T("\" failed: ") \
82  << __FILE__ << _T(" line ") \
83  << __LINE__ << _T("."); \
84  throw ParserError( ecINTERNAL_ERROR, -1, ss.str()); \
85  }
86 
87 #if defined(_MSC_VER)
88  #pragma warning(push)
89  #pragma warning(disable : 26812)
90 #endif
91 
92 
93 namespace mu
94 {
95 #if defined(_UNICODE)
96 
97  /** \brief Encapsulate wcout. */
98  inline std::wostream& console()
99  {
100  return std::wcout;
101  }
102 
103  /** \brief Encapsulate cin. */
104  inline std::wistream& console_in()
105  {
106  return std::wcin;
107  }
108 
109 #else
110 
111  /** \brief Encapsulate cout.
112 
113  Used for supporting UNICODE more easily.
114  */
115  inline std::ostream& console()
116  {
117  return std::cout;
118  }
119 
120  /** \brief Encapsulate cin.
121 
122  Used for supporting UNICODE more easily.
123  */
124  inline std::istream& console_in()
125  {
126  return std::cin;
127  }
128 
129 #endif
130 
131  /** \brief Bytecode values.
132 
133  \attention The order of the operator entries must match the order in ParserBase::c_DefaultOprt!
134  */
135  enum ECmdCode
136  {
137  // The following are codes for built in binary operators
138  // apart from built in operators the user has the opportunity to
139  // add user defined operators.
140  cmLE = 0, ///< Operator item: less or equal
141  cmGE = 1, ///< Operator item: greater or equal
142  cmNEQ = 2, ///< Operator item: not equal
143  cmEQ = 3, ///< Operator item: equals
144  cmLT = 4, ///< Operator item: less than
145  cmGT = 5, ///< Operator item: greater than
146  cmADD = 6, ///< Operator item: add
147  cmSUB = 7, ///< Operator item: subtract
148  cmMUL = 8, ///< Operator item: multiply
149  cmDIV = 9, ///< Operator item: division
150  cmPOW = 10, ///< Operator item: y to the power of ...
151  cmLAND = 11,
152  cmLOR = 12,
153  cmASSIGN = 13, ///< Operator item: Assignment operator
154  cmBO = 14, ///< Operator item: opening bracket
155  cmBC = 15, ///< Operator item: closing bracket
156  cmIF = 16, ///< For use in the ternary if-then-else operator
157  cmELSE = 17, ///< For use in the ternary if-then-else operator
158  cmENDIF = 18, ///< For use in the ternary if-then-else operator
159  cmARG_SEP = 19, ///< function argument separator
160  cmVAR = 20, ///< variable item
161  cmVAL = 21, ///< value item
162 
163  // For optimization purposes
164  cmVARPOW2 = 22,
165  cmVARPOW3 = 23,
166  cmVARPOW4 = 24,
167  cmVARMUL = 25,
168 
169  // operators and functions
170  cmFUNC = 26, ///< Code for a generic function item
171  cmFUNC_STR, ///< Code for a function with a string parameter
172  cmFUNC_BULK, ///< Special callbacks for Bulk mode with an additional parameter for the bulk index
173  cmSTRING, ///< Code for a string token
174  cmOPRT_BIN, ///< user defined binary operator
175  cmOPRT_POSTFIX, ///< code for postfix operators
176  cmOPRT_INFIX, ///< code for infix operators
177  cmEND, ///< end of formula
178  cmUNKNOWN ///< uninitialized item
179  };
180 
181  /** \brief Types internally used by the parser.
182  */
184  {
185  tpSTR = 0, ///< String type (Function arguments and constants only, no string variables)
186  tpDBL = 1, ///< Floating point variables
187  tpVOID = 2 ///< Undefined type.
188  };
189 
190 
191  enum EParserVersionInfo
192  {
193  pviBRIEF,
194  pviFULL
195  };
196 
197 
198  /** \brief Parser operator precedence values. */
200  {
201  oaLEFT = 0,
202  oaRIGHT = 1,
203  oaNONE = 2
204  };
205 
206 
207  /** \brief Parser operator precedence values. */
209  {
210  // binary operators
211  prLOR = 1,
212  prLAND = 2,
213  prLOGIC = 3, ///< logic operators
214  prCMP = 4, ///< comparsion operators
215  prADD_SUB = 5, ///< addition
216  prMUL_DIV = 6, ///< multiplication/division
217  prPOW = 7, ///< power operator priority (highest)
218 
219  // infix operators
220  prINFIX = 6, ///< Signs have a higher priority than ADD_SUB, but lower than power operator
221  prPOSTFIX = 6 ///< Postfix operator priority (currently unused)
222  };
223 
224 
225  /** \brief Error codes. */
227  {
228  // Formula syntax errors
229  ecUNEXPECTED_OPERATOR = 0, ///< Unexpected binary operator found
230  ecUNASSIGNABLE_TOKEN = 1, ///< Token can't be identified.
231  ecUNEXPECTED_EOF = 2, ///< Unexpected end of formula. (Example: "2+sin(")
232  ecUNEXPECTED_ARG_SEP = 3, ///< An unexpected comma has been found. (Example: "1,23")
233  ecUNEXPECTED_ARG = 4, ///< An unexpected argument has been found
234  ecUNEXPECTED_VAL = 5, ///< An unexpected value token has been found
235  ecUNEXPECTED_VAR = 6, ///< An unexpected variable token has been found
236  ecUNEXPECTED_PARENS = 7, ///< Unexpected Parenthesis, opening or closing
237  ecUNEXPECTED_STR = 8, ///< A string has been found at an inapropriate position
238  ecSTRING_EXPECTED = 9, ///< A string function has been called with a different type of argument
239  ecVAL_EXPECTED = 10, ///< A numerical function has been called with a non value type of argument
240  ecMISSING_PARENS = 11, ///< Missing parens. (Example: "3*sin(3")
241  ecUNEXPECTED_FUN = 12, ///< Unexpected function found. (Example: "sin(8)cos(9)")
242  ecUNTERMINATED_STRING = 13, ///< unterminated string constant. (Example: "3*valueof("hello)")
243  ecTOO_MANY_PARAMS = 14, ///< Too many function parameters
244  ecTOO_FEW_PARAMS = 15, ///< Too few function parameters. (Example: "ite(1<2,2)")
245  ecOPRT_TYPE_CONFLICT = 16, ///< binary operators may only be applied to value items of the same type
246  ecSTR_RESULT = 17, ///< result is a string
247 
248  // Invalid Parser input Parameters
249  ecINVALID_NAME = 18, ///< Invalid function, variable or constant name.
250  ecINVALID_BINOP_IDENT = 19, ///< Invalid binary operator identifier
251  ecINVALID_INFIX_IDENT = 20, ///< Invalid function, variable or constant name.
252  ecINVALID_POSTFIX_IDENT = 21, ///< Invalid function, variable or constant name.
253 
254  ecBUILTIN_OVERLOAD = 22, ///< Trying to overload builtin operator
255  ecINVALID_FUN_PTR = 23, ///< Invalid callback function pointer
256  ecINVALID_VAR_PTR = 24, ///< Invalid variable pointer
257  ecEMPTY_EXPRESSION = 25, ///< The Expression is empty
258  ecNAME_CONFLICT = 26, ///< Name conflict
259  ecOPT_PRI = 27, ///< Invalid operator priority
260  //
261  ecDOMAIN_ERROR = 28, ///< catch division by zero, sqrt(-1), log(0) (currently unused)
262  ecDIV_BY_ZERO = 29, ///< Division by zero (currently unused)
263  ecGENERIC = 30, ///< Generic error
264  ecLOCALE = 31, ///< Conflict with current locale
265 
266  ecUNEXPECTED_CONDITIONAL = 32,
267  ecMISSING_ELSE_CLAUSE = 33,
268  ecMISPLACED_COLON = 34,
269 
270  ecUNREASONABLE_NUMBER_OF_COMPUTATIONS = 35,
271 
272  ecIDENTIFIER_TOO_LONG = 36, ///< Thrown when an identifier with more then 255 characters is used.
273 
274  ecEXPRESSION_TOO_LONG = 37, ///< Throw an exception if the expression has more than 10000 characters. (an arbitrary limit)
275 
276  ecINVALID_CHARACTERS_FOUND = 38,///< The expression or identifier contains invalid non printable characters
277 
278  // internal errors
279  ecINTERNAL_ERROR = 39, ///< Internal error of any kind.
280 
281  // The last two are special entries
282  ecCOUNT, ///< This is no error code, It just stores just the total number of error codes
283  ecUNDEFINED = -1 ///< Undefined message, placeholder to detect unassigned error messages
284  };
285 
286  //------------------------------------------------------------------------------
287  // Basic Types
288  //------------------------------------------------------------------------------
289 
290  /** \brief The numeric datatype used by the parser.
291 
292  Normally this is a floating point type either single or double precision.
293  */
295 
296  /** \brief The stringtype used by the parser.
297 
298  Depends on whether UNICODE is used or not.
299  */
301 
302  /** \brief The character type used by the parser.
303 
304  Depends on whether UNICODE is used or not.
305  */
307 
308  /** \brief Typedef for easily using stringstream that respect the parser stringtype. */
309  typedef std::basic_stringstream<char_type, std::char_traits<char_type>, std::allocator<char_type> > stringstream_type;
310 
311  // Data container types
312 
313  /** \brief Type used for storing variables. */
314  typedef std::map<string_type, value_type*> varmap_type;
315 
316  /** \brief Type used for storing constants. */
317  typedef std::map<string_type, value_type> valmap_type;
318 
319  /** \brief Type for assigning a string name to an index in the internal string table. */
320  typedef std::map<string_type, std::size_t> strmap_type;
321 
322  // Parser callbacks
323 
324  /** \brief Callback type used for functions without arguments. */
326 
327  /** \brief Callback type used for functions without arguments. */
328  typedef value_type(*fun_type0)();
329 
330  /** \brief Callback type used for functions with a single arguments. */
332 
333  /** \brief Callback type used for functions with two arguments. */
335 
336  /** \brief Callback type used for functions with three arguments. */
338 
339  /** \brief Callback type used for functions with four arguments. */
341 
342  /** \brief Callback type used for functions with five arguments. */
344 
345  /** \brief Callback type used for functions with six arguments. */
347 
348  /** \brief Callback type used for functions with seven arguments. */
350 
351  /** \brief Callback type used for functions with eight arguments. */
353 
354  /** \brief Callback type used for functions with nine arguments. */
356 
357  /** \brief Callback type used for functions with ten arguments. */
359 
360  /** \brief Callback type used for functions without arguments. */
361  typedef value_type(*bulkfun_type0)(int, int);
362 
363  /** \brief Callback type used for functions with a single arguments. */
364  typedef value_type(*bulkfun_type1)(int, int, value_type);
365 
366  /** \brief Callback type used for functions with two arguments. */
368 
369  /** \brief Callback type used for functions with three arguments. */
371 
372  /** \brief Callback type used for functions with four arguments. */
374 
375  /** \brief Callback type used for functions with five arguments. */
377 
378  /** \brief Callback type used for functions with six arguments. */
380 
381  /** \brief Callback type used for functions with seven arguments. */
383 
384  /** \brief Callback type used for functions with eight arguments. */
386 
387  /** \brief Callback type used for functions with nine arguments. */
389 
390  /** \brief Callback type used for functions with ten arguments. */
392 
393  /** \brief Callback type used for functions with a variable argument list. */
394  typedef value_type(*multfun_type)(const value_type*, int);
395 
396  /** \brief Callback type used for functions taking a string as an argument. */
397  typedef value_type(*strfun_type1)(const char_type*);
398 
399  /** \brief Callback type used for functions taking a string and a value as arguments. */
400  typedef value_type(*strfun_type2)(const char_type*, value_type);
401 
402  /** \brief Callback type used for functions taking a string and two values as arguments. */
403  typedef value_type(*strfun_type3)(const char_type*, value_type, value_type);
404 
405  /** \brief Callback type used for functions taking a string and a value as arguments. */
406  typedef value_type(*strfun_type4)(const char_type*, value_type, value_type, value_type);
407 
408  /** \brief Callback type used for functions taking a string and two values as arguments. */
410 
411  /** \brief Callback used for functions that identify values in a string. */
412  typedef int (*identfun_type)(const char_type* sExpr, int* nPos, value_type* fVal);
413 
414  /** \brief Callback used for variable creation factory functions. */
415  typedef value_type* (*facfun_type)(const char_type*, void*);
416 
417  static const int MaxLenExpression = 5000;
418  static const int MaxLenIdentifier = 100;
419  static const string_type ParserVersion = string_type(_T("2.3.2"));
420  static const string_type ParserVersionDate = string_type(_T("20200617"));
421 } // end of namespace
422 
423 #if defined(_MSC_VER)
424  #pragma warning(pop)
425 #endif
426 
427 #endif
428 
Operator item: closing bracket.
Definition: muParserDef.h:155
code for infix operators
Definition: muParserDef.h:176
value_type(* strfun_type1)(const char_type *)
Callback type used for functions taking a string as an argument.
Definition: muParserDef.h:397
multiplication/division
Definition: muParserDef.h:216
user defined binary operator
Definition: muParserDef.h:174
#define _T(x)
Activate this option in order to compile with OpenMP support.
Definition: muParserDef.h:69
value_type(* bulkfun_type1)(int, int, value_type)
Callback type used for functions with a single arguments.
Definition: muParserDef.h:364
binary operators may only be applied to value items of the same type
Definition: muParserDef.h:245
An unexpected comma has been found. (Example: "1,23")
Definition: muParserDef.h:232
std::ostream & console()
Encapsulate cout.
Definition: muParserDef.h:115
Token can't be identified.
Definition: muParserDef.h:230
result is a string
Definition: muParserDef.h:246
An unexpected argument has been found.
Definition: muParserDef.h:233
Division by zero (currently unused)
Definition: muParserDef.h:262
Throw an exception if the expression has more than 10000 characters. (an arbitrary limit) ...
Definition: muParserDef.h:274
#define MUP_STRING_TYPE
Definition of the basic parser string type.
Definition: muParserDef.h:73
Postfix operator priority (currently unused)
Definition: muParserDef.h:221
std::map< string_type, std::size_t > strmap_type
Type for assigning a string name to an index in the internal string table.
Definition: muParserDef.h:320
Name conflict.
Definition: muParserDef.h:258
std::map< string_type, value_type * > varmap_type
Type used for storing variables.
Definition: muParserDef.h:314
function argument separator
Definition: muParserDef.h:159
Operator item: y to the power of ...
Definition: muParserDef.h:150
Internal error of any kind.
Definition: muParserDef.h:279
code for postfix operators
Definition: muParserDef.h:175
unterminated string constant. (Example: "3*valueof("hello)")
Definition: muParserDef.h:242
Trying to overload builtin operator.
Definition: muParserDef.h:254
This file contains compatibility fixes for some platforms.
value_type(* bulkfun_type8)(int, int, value_type, value_type, value_type, value_type, value_type, value_type, value_type, value_type)
Callback type used for functions with eight arguments.
Definition: muParserDef.h:385
Undefined message, placeholder to detect unassigned error messages.
Definition: muParserDef.h:283
Operator item: not equal.
Definition: muParserDef.h:142
For use in the ternary if-then-else operator.
Definition: muParserDef.h:156
value_type(* fun_type5)(value_type, value_type, value_type, value_type, value_type)
Callback type used for functions with five arguments.
Definition: muParserDef.h:343
value_type(* bulkfun_type2)(int, int, value_type, value_type)
Callback type used for functions with two arguments.
Definition: muParserDef.h:367
value_type(* fun_type1)(value_type)
Callback type used for functions with a single arguments.
Definition: muParserDef.h:331
#define MUP_BASETYPE
Define the base datatype for values.
Definition: muParserDef.h:48
value_type(* strfun_type4)(const char_type *, value_type, value_type, value_type)
Callback type used for functions taking a string and a value as arguments.
Definition: muParserDef.h:406
Unexpected function found. (Example: "sin(8)cos(9)")
Definition: muParserDef.h:241
value_type(* bulkfun_type9)(int, int, value_type, value_type, value_type, value_type, value_type, value_type, value_type, value_type, value_type)
Callback type used for functions with nine arguments.
Definition: muParserDef.h:388
end of formula
Definition: muParserDef.h:177
power operator priority (highest)
Definition: muParserDef.h:217
std::basic_stringstream< char_type, std::char_traits< char_type >, std::allocator< char_type > > stringstream_type
Typedef for easily using stringstream that respect the parser stringtype.
Definition: muParserDef.h:309
This is no error code, It just stores just the total number of error codes.
Definition: muParserDef.h:282
value_type(* strfun_type3)(const char_type *, value_type, value_type)
Callback type used for functions taking a string and two values as arguments.
Definition: muParserDef.h:403
value_type(* multfun_type)(const value_type *, int)
Callback type used for functions with a variable argument list.
Definition: muParserDef.h:394
Code for a generic function item.
Definition: muParserDef.h:170
EOprtAssociativity
Parser operator precedence values.
Definition: muParserDef.h:199
value_type(* fun_type8)(value_type, value_type, value_type, value_type, value_type, value_type, value_type, value_type)
Callback type used for functions with eight arguments.
Definition: muParserDef.h:352
value_type(* bulkfun_type5)(int, int, value_type, value_type, value_type, value_type, value_type)
Callback type used for functions with five arguments.
Definition: muParserDef.h:376
value_type(* bulkfun_type6)(int, int, value_type, value_type, value_type, value_type, value_type, value_type)
Callback type used for functions with six arguments.
Definition: muParserDef.h:379
An unexpected value token has been found.
Definition: muParserDef.h:234
value_type(* strfun_type5)(const char_type *, value_type, value_type, value_type, value_type)
Callback type used for functions taking a string and two values as arguments.
Definition: muParserDef.h:409
Conflict with current locale.
Definition: muParserDef.h:264
comparsion operators
Definition: muParserDef.h:214
std::map< string_type, value_type > valmap_type
Type used for storing constants.
Definition: muParserDef.h:317
For use in the ternary if-then-else operator.
Definition: muParserDef.h:157
catch division by zero, sqrt(-1), log(0) (currently unused)
Definition: muParserDef.h:261
An unexpected variable token has been found.
Definition: muParserDef.h:235
value_type(* fun_type10)(value_type, value_type, value_type, value_type, value_type, value_type, value_type, value_type, value_type, value_type)
Callback type used for functions with ten arguments.
Definition: muParserDef.h:358
value_type(* fun_type9)(value_type, value_type, value_type, value_type, value_type, value_type, value_type, value_type, value_type)
Callback type used for functions with nine arguments.
Definition: muParserDef.h:355
ETypeCode
Types internally used by the parser.
Definition: muParserDef.h:183
Invalid variable pointer.
Definition: muParserDef.h:256
Invalid function, variable or constant name.
Definition: muParserDef.h:249
Operator item: subtract.
Definition: muParserDef.h:147
value_type(* fun_type2)(value_type, value_type)
Callback type used for functions with two arguments.
Definition: muParserDef.h:334
addition
Definition: muParserDef.h:215
For use in the ternary if-then-else operator.
Definition: muParserDef.h:158
ECmdCode
Bytecode values.
Definition: muParserDef.h:135
logic operators
Definition: muParserDef.h:213
Operator item: multiply.
Definition: muParserDef.h:148
MUP_BASETYPE value_type
The numeric datatype used by the parser.
Definition: muParserDef.h:294
String type (Function arguments and constants only, no string variables)
Definition: muParserDef.h:185
Operator item: division.
Definition: muParserDef.h:149
The Expression is empty.
Definition: muParserDef.h:257
value_type(* strfun_type2)(const char_type *, value_type)
Callback type used for functions taking a string and a value as arguments.
Definition: muParserDef.h:400
Too many function parameters.
Definition: muParserDef.h:243
Operator item: add.
Definition: muParserDef.h:146
A numerical function has been called with a non value type of argument.
Definition: muParserDef.h:239
Namespace for mathematical applications.
Definition: muParser.cpp:46
Unexpected end of formula. (Example: "2+sin(")
Definition: muParserDef.h:231
Operator item: less than.
Definition: muParserDef.h:144
int(* identfun_type)(const char_type *sExpr, int *nPos, value_type *fVal)
Callback used for functions that identify values in a string.
Definition: muParserDef.h:412
Too few function parameters. (Example: "ite(1<2,2)")
Definition: muParserDef.h:244
A string function has been called with a different type of argument.
Definition: muParserDef.h:238
value item
Definition: muParserDef.h:161
value_type(* fun_type3)(value_type, value_type, value_type)
Callback type used for functions with three arguments.
Definition: muParserDef.h:337
value_type(* fun_type0)()
Callback type used for functions without arguments.
Definition: muParserDef.h:328
Operator item: greater than.
Definition: muParserDef.h:145
value_type(* generic_fun_type)()
Callback type used for functions without arguments.
Definition: muParserDef.h:325
Undefined type.
Definition: muParserDef.h:187
Special callbacks for Bulk mode with an additional parameter for the bulk index.
Definition: muParserDef.h:172
string_type::value_type char_type
The character type used by the parser.
Definition: muParserDef.h:306
Code for a function with a string parameter.
Definition: muParserDef.h:171
Thrown when an identifier with more then 255 characters is used.
Definition: muParserDef.h:272
value_type(* bulkfun_type7)(int, int, value_type, value_type, value_type, value_type, value_type, value_type, value_type)
Callback type used for functions with seven arguments.
Definition: muParserDef.h:382
EOprtPrecedence
Parser operator precedence values.
Definition: muParserDef.h:208
Operator item: equals.
Definition: muParserDef.h:143
uninitialized item
Definition: muParserDef.h:178
Operator item: Assignment operator.
Definition: muParserDef.h:153
value_type(* fun_type4)(value_type, value_type, value_type, value_type)
Callback type used for functions with four arguments.
Definition: muParserDef.h:340
Unexpected binary operator found.
Definition: muParserDef.h:229
MUP_STRING_TYPE string_type
The stringtype used by the parser.
Definition: muParserDef.h:300
Invalid operator priority.
Definition: muParserDef.h:259
value_type(* fun_type7)(value_type, value_type, value_type, value_type, value_type, value_type, value_type)
Callback type used for functions with seven arguments.
Definition: muParserDef.h:349
Code for a string token.
Definition: muParserDef.h:173
Operator item: less or equal.
Definition: muParserDef.h:140
value_type(* bulkfun_type4)(int, int, value_type, value_type, value_type, value_type)
Callback type used for functions with four arguments.
Definition: muParserDef.h:373
variable item
Definition: muParserDef.h:160
Unexpected Parenthesis, opening or closing.
Definition: muParserDef.h:236
Invalid function, variable or constant name.
Definition: muParserDef.h:252
Operator item: greater or equal.
Definition: muParserDef.h:141
Invalid callback function pointer.
Definition: muParserDef.h:255
The expression or identifier contains invalid non printable characters.
Definition: muParserDef.h:276
std::istream & console_in()
Encapsulate cin.
Definition: muParserDef.h:124
value_type(* bulkfun_type0)(int, int)
Callback type used for functions without arguments.
Definition: muParserDef.h:361
Floating point variables.
Definition: muParserDef.h:186
value_type(* bulkfun_type3)(int, int, value_type, value_type, value_type)
Callback type used for functions with three arguments.
Definition: muParserDef.h:370
EErrorCodes
Error codes.
Definition: muParserDef.h:226
Generic error.
Definition: muParserDef.h:263
Missing parens. (Example: "3*sin(3")
Definition: muParserDef.h:240
A string has been found at an inapropriate position.
Definition: muParserDef.h:237
Signs have a higher priority than ADD_SUB, but lower than power operator.
Definition: muParserDef.h:220
value_type(* fun_type6)(value_type, value_type, value_type, value_type, value_type, value_type)
Callback type used for functions with six arguments.
Definition: muParserDef.h:346
Invalid function, variable or constant name.
Definition: muParserDef.h:251
Operator item: opening bracket.
Definition: muParserDef.h:154
Invalid binary operator identifier.
Definition: muParserDef.h:250
value_type(* bulkfun_type10)(int, int, value_type, value_type, value_type, value_type, value_type, value_type, value_type, value_type, value_type, value_type)
Callback type used for functions with ten arguments.
Definition: muParserDef.h:391