muParser API -  1.35
muParserDLL.cpp
1 /*
2 
3  _____ __ _____________ _______ ______ ___________
4  / \| | \____ \__ \\_ __ \/ ___// __ \_ __ \
5  | Y Y \ | / |_> > __ \| | \/\___ \\ ___/| | \/
6  |__|_| /____/| __(____ /__| /____ >\___ >__|
7  \/ |__| \/ \/ \/
8  Copyright (C) 2004 - 2022 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 #if defined(MUPARSER_DLL)
30 
31 #if defined(_WIN32)
32  #define WIN32_LEAN_AND_MEAN
33  #define _CRT_SECURE_NO_WARNINGS
34  #define _CRT_SECURE_NO_DEPRECATE
35 
36  #include <windows.h>
37 #endif
38 
39 #include <cassert>
40 
41 #include "muParserDLL.h"
42 #include "muParser.h"
43 #include "muParserInt.h"
44 #include "muParserError.h"
45 
46 #if _UNICODE
47  #include <wchar.h>
48 #endif
49 
50 #if defined(_MSC_VER)
51  #pragma warning(push)
52  #pragma warning(disable : 26812)
53 #endif
54 
55 #define MU_TRY \
56  try \
57  {
58 
59 #define MU_CATCH \
60  } \
61  catch (muError_t &e) \
62  { \
63  ParserTag *pTag = static_cast<ParserTag*>(a_hParser); \
64  pTag->exc = e; \
65  pTag->bError = true; \
66  if (pTag->errHandler) \
67  (pTag->errHandler)(a_hParser); \
68  } \
69  catch (...) \
70  { \
71  ParserTag *pTag = static_cast<ParserTag*>(a_hParser); \
72  pTag->exc = muError_t(mu::ecINTERNAL_ERROR); \
73  pTag->bError = true; \
74  if (pTag->errHandler) \
75  (pTag->errHandler)(a_hParser); \
76  }
77 
78 /** \file
79  \brief This file contains the implementation of the DLL interface of muparser.
80 */
81 
82 typedef mu::ParserBase::exception_type muError_t;
83 typedef mu::ParserBase muParser_t;
84 int g_nBulkSize;
85 
86 
87 class ParserTag
88 {
89 public:
90  ParserTag(int nType)
91  : pParser((nType == muBASETYPE_FLOAT)
92  ? (mu::ParserBase*)new mu::Parser()
93  : (nType == muBASETYPE_INT) ? (mu::ParserBase*)new mu::ParserInt() : nullptr)
94  , exc()
95  , errHandler(nullptr)
96  , bError(false)
97  , m_nParserType(nType)
98  {}
99 
100  ~ParserTag()
101  {
102  delete pParser;
103  }
104 
105  mu::ParserBase* pParser;
107  muErrorHandler_t errHandler;
108  bool bError;
109 
110 private:
111  ParserTag(const ParserTag& ref);
112  ParserTag& operator=(const ParserTag& ref);
113 
114  int m_nParserType;
115 };
116 
117 static muChar_t s_tmpOutBuf[2048];
118 
119 template <typename T>
120 constexpr std::size_t count_of(const T& array)
121 {
122  return (sizeof(array) / sizeof(array[0]));
123 }
124 
125 //---------------------------------------------------------------------------
126 //
127 //
128 // unexported functions
129 //
130 //
131 //---------------------------------------------------------------------------
132 
133 
134 inline muParser_t* AsParser(muParserHandle_t a_hParser)
135 {
136  return static_cast<ParserTag*>(a_hParser)->pParser;
137 }
138 
139 
140 inline ParserTag* AsParserTag(muParserHandle_t a_hParser)
141 {
142  return static_cast<ParserTag*>(a_hParser);
143 }
144 
145 
146 #if defined(_WIN32)
147 
148 BOOL APIENTRY DllMain(HANDLE /*hModule*/, DWORD ul_reason_for_call, LPVOID /*lpReserved*/)
149 {
150  switch (ul_reason_for_call)
151  {
152  case DLL_PROCESS_ATTACH:
153  break;
154 
155  case DLL_THREAD_ATTACH:
156  case DLL_THREAD_DETACH:
157  case DLL_PROCESS_DETACH:
158  break;
159  }
160 
161  return TRUE;
162 }
163 
164 #endif
165 
166 //---------------------------------------------------------------------------
167 //
168 //
169 // exported functions
170 //
171 //
172 //---------------------------------------------------------------------------
173 
174 API_EXPORT(void) mupSetVarFactory(muParserHandle_t a_hParser, muFacFun_t a_pFactory, void* pUserData)
175 {
176  MU_TRY
177  muParser_t* p(AsParser(a_hParser));
178  p->SetVarFactory(a_pFactory, pUserData);
179  MU_CATCH
180 }
181 
182 
183 /** \brief Create a new Parser instance and return its handle. */
184 API_EXPORT(muParserHandle_t) mupCreate(int nBaseType)
185 {
186  switch (nBaseType)
187  {
188  case muBASETYPE_FLOAT: return (void*)(new ParserTag(muBASETYPE_FLOAT));
189  case muBASETYPE_INT: return (void*)(new ParserTag(muBASETYPE_INT));
190  default: return nullptr;
191  }
192 }
193 
194 
195 /** \brief Release the parser instance related with a parser handle. */
196 API_EXPORT(void) mupRelease(muParserHandle_t a_hParser)
197 {
198  MU_TRY
199  ParserTag* p = static_cast<ParserTag*>(a_hParser);
200  delete p;
201  MU_CATCH
202 }
203 
204 
205 API_EXPORT(const muChar_t*) mupGetVersion(muParserHandle_t a_hParser)
206 {
207  MU_TRY
208  muParser_t* const p(AsParser(a_hParser));
209 
210 #ifndef _UNICODE
211  snprintf(s_tmpOutBuf, count_of(s_tmpOutBuf), "%s", p->GetVersion().c_str());
212 #else
213  swprintf(s_tmpOutBuf, count_of(s_tmpOutBuf), _T("%s"), p->GetVersion().c_str());
214 #endif
215 
216  return s_tmpOutBuf;
217  MU_CATCH
218  return _T("");
219 }
220 
221 
222 /** \brief Evaluate the expression. */
223 API_EXPORT(muFloat_t) mupEval(muParserHandle_t a_hParser)
224 {
225  MU_TRY
226  muParser_t* const p(AsParser(a_hParser));
227  return p->Eval();
228  MU_CATCH
229  return 0;
230 }
231 
232 
233 API_EXPORT(muFloat_t*) mupEvalMulti(muParserHandle_t a_hParser, int* nNum)
234 {
235  MU_TRY
236  if (nNum == nullptr)
237  throw std::runtime_error("Argument is null!");
238 
239  muParser_t* const p(AsParser(a_hParser));
240  return p->Eval(*nNum);
241  MU_CATCH
242  return 0;
243 }
244 
245 
246 API_EXPORT(void) mupEvalBulk(muParserHandle_t a_hParser, muFloat_t* a_res, int nSize)
247 {
248  MU_TRY
249  muParser_t* p(AsParser(a_hParser));
250  p->Eval(a_res, nSize);
251  MU_CATCH
252 }
253 
254 
255 API_EXPORT(void) mupSetExpr(muParserHandle_t a_hParser, const muChar_t* a_szExpr)
256 {
257  MU_TRY
258  muParser_t* const p(AsParser(a_hParser));
259  p->SetExpr(a_szExpr);
260  MU_CATCH
261 }
262 
263 
264 API_EXPORT(void) mupRemoveVar(muParserHandle_t a_hParser, const muChar_t* a_szName)
265 {
266  MU_TRY
267  muParser_t* const p(AsParser(a_hParser));
268  p->RemoveVar(a_szName);
269  MU_CATCH
270 }
271 
272 
273 /** \brief Release all parser variables.
274  \param a_hParser Handle to the parser instance.
275 */
276 API_EXPORT(void) mupClearVar(muParserHandle_t a_hParser)
277 {
278  MU_TRY
279  muParser_t* const p(AsParser(a_hParser));
280  p->ClearVar();
281  MU_CATCH
282 }
283 
284 
285 /** \brief Release all parser variables.
286  \param a_hParser Handle to the parser instance.
287 */
288 API_EXPORT(void) mupClearConst(muParserHandle_t a_hParser)
289 {
290  MU_TRY
291  muParser_t* const p(AsParser(a_hParser));
292  p->ClearConst();
293  MU_CATCH
294 }
295 
296 
297 /** \brief Clear all user defined operators.
298  \param a_hParser Handle to the parser instance.
299 */
300 API_EXPORT(void) mupClearOprt(muParserHandle_t a_hParser)
301 {
302  MU_TRY
303  muParser_t* const p(AsParser(a_hParser));
304  p->ClearOprt();
305  MU_CATCH
306 }
307 
308 
309 API_EXPORT(void) mupClearFun(muParserHandle_t a_hParser)
310 {
311  MU_TRY
312  muParser_t* const p(AsParser(a_hParser));
313  p->ClearFun();
314  MU_CATCH
315 }
316 
317 
318 API_EXPORT(void) mupDefineFun0(muParserHandle_t a_hParser,
319  const muChar_t* a_szName,
320  muFun0_t a_pFun,
321  muBool_t a_bAllowOpt)
322 {
323  MU_TRY
324  muParser_t* const p(AsParser(a_hParser));
325  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
326  MU_CATCH
327 }
328 
329 
330 API_EXPORT(void) mupDefineFun1(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun1_t a_pFun, muBool_t a_bAllowOpt)
331 {
332  MU_TRY
333  muParser_t* const p(AsParser(a_hParser));
334  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
335  MU_CATCH
336 }
337 
338 
339 API_EXPORT(void) mupDefineFun2(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun2_t a_pFun, muBool_t a_bAllowOpt)
340 {
341  MU_TRY
342  muParser_t* const p(AsParser(a_hParser));
343  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
344  MU_CATCH
345 }
346 
347 
348 API_EXPORT(void) mupDefineFun3(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun3_t a_pFun, muBool_t a_bAllowOpt)
349 {
350  MU_TRY
351  muParser_t* const p(AsParser(a_hParser));
352  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
353  MU_CATCH
354 }
355 
356 
357 API_EXPORT(void) mupDefineFun4(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun4_t a_pFun, muBool_t a_bAllowOpt)
358 {
359  MU_TRY
360  muParser_t* const p(AsParser(a_hParser));
361  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
362  MU_CATCH
363 }
364 
365 
366 API_EXPORT(void) mupDefineFun5(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun5_t a_pFun, muBool_t a_bAllowOpt)
367 {
368  MU_TRY
369  muParser_t* const p(AsParser(a_hParser));
370  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
371  MU_CATCH
372 }
373 
374 
375 API_EXPORT(void) mupDefineFun6(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun6_t a_pFun, muBool_t a_bAllowOpt)
376 {
377  MU_TRY
378  muParser_t* const p(AsParser(a_hParser));
379  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
380  MU_CATCH
381 }
382 
383 
384 API_EXPORT(void) mupDefineFun7(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun7_t a_pFun, muBool_t a_bAllowOpt)
385 {
386  MU_TRY
387  muParser_t* const p(AsParser(a_hParser));
388  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
389  MU_CATCH
390 }
391 
392 
393 API_EXPORT(void) mupDefineFun8(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun8_t a_pFun, muBool_t a_bAllowOpt)
394 {
395  MU_TRY
396  muParser_t* const p(AsParser(a_hParser));
397  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
398  MU_CATCH
399 }
400 
401 
402 API_EXPORT(void) mupDefineFun9(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun9_t a_pFun, muBool_t a_bAllowOpt)
403 {
404  MU_TRY
405  muParser_t* const p(AsParser(a_hParser));
406  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
407  MU_CATCH
408 }
409 
410 
411 API_EXPORT(void) mupDefineFun10(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun10_t a_pFun, muBool_t a_bAllowOpt)
412 {
413  MU_TRY
414  muParser_t* const p(AsParser(a_hParser));
415  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
416  MU_CATCH
417 }
418 
419 
420 API_EXPORT(void) mupDefineFunUserData0(muParserHandle_t a_hParser, const muChar_t* a_szName, muFunUserData0_t a_pFun, void* a_pUserData, muBool_t a_bAllowOpt)
421 {
422  MU_TRY
423  muParser_t* const p(AsParser(a_hParser));
424  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, a_bAllowOpt != 0);
425  MU_CATCH
426 }
427 
428 
429 API_EXPORT(void) mupDefineFunUserData1(muParserHandle_t a_hParser, const muChar_t* a_szName, muFunUserData1_t a_pFun, void* a_pUserData, muBool_t a_bAllowOpt)
430 {
431  MU_TRY
432  muParser_t* const p(AsParser(a_hParser));
433  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, a_bAllowOpt != 0);
434  MU_CATCH
435 }
436 
437 
438 API_EXPORT(void) mupDefineFunUserData2(muParserHandle_t a_hParser, const muChar_t* a_szName, muFunUserData2_t a_pFun, void* a_pUserData, muBool_t a_bAllowOpt)
439 {
440  MU_TRY
441  muParser_t* const p(AsParser(a_hParser));
442  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, a_bAllowOpt != 0);
443  MU_CATCH
444 }
445 
446 
447 API_EXPORT(void) mupDefineFunUserData3(muParserHandle_t a_hParser, const muChar_t* a_szName, muFunUserData3_t a_pFun, void* a_pUserData, muBool_t a_bAllowOpt)
448 {
449  MU_TRY
450  muParser_t* const p(AsParser(a_hParser));
451  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, a_bAllowOpt != 0);
452  MU_CATCH
453 }
454 
455 
456 API_EXPORT(void) mupDefineFunUserData4(muParserHandle_t a_hParser, const muChar_t* a_szName, muFunUserData4_t a_pFun, void* a_pUserData, muBool_t a_bAllowOpt)
457 {
458  MU_TRY
459  muParser_t* const p(AsParser(a_hParser));
460  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, a_bAllowOpt != 0);
461  MU_CATCH
462 }
463 
464 
465 API_EXPORT(void) mupDefineFunUserData5(muParserHandle_t a_hParser, const muChar_t* a_szName, muFunUserData5_t a_pFun, void* a_pUserData, muBool_t a_bAllowOpt)
466 {
467  MU_TRY
468  muParser_t* const p(AsParser(a_hParser));
469  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, a_bAllowOpt != 0);
470  MU_CATCH
471 }
472 
473 
474 API_EXPORT(void) mupDefineFunUserData6(muParserHandle_t a_hParser, const muChar_t* a_szName, muFunUserData6_t a_pFun, void* a_pUserData, muBool_t a_bAllowOpt)
475 {
476  MU_TRY
477  muParser_t* const p(AsParser(a_hParser));
478  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, a_bAllowOpt != 0);
479  MU_CATCH
480 }
481 
482 
483 API_EXPORT(void) mupDefineFunUserData7(muParserHandle_t a_hParser, const muChar_t* a_szName, muFunUserData7_t a_pFun, void* a_pUserData, muBool_t a_bAllowOpt)
484 {
485  MU_TRY
486  muParser_t* const p(AsParser(a_hParser));
487  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, a_bAllowOpt != 0);
488  MU_CATCH
489 }
490 
491 
492 API_EXPORT(void) mupDefineFunUserData8(muParserHandle_t a_hParser, const muChar_t* a_szName, muFunUserData8_t a_pFun, void* a_pUserData, muBool_t a_bAllowOpt)
493 {
494  MU_TRY
495  muParser_t* const p(AsParser(a_hParser));
496  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, a_bAllowOpt != 0);
497  MU_CATCH
498 }
499 
500 
501 API_EXPORT(void) mupDefineFunUserData9(muParserHandle_t a_hParser, const muChar_t* a_szName, muFunUserData9_t a_pFun, void* a_pUserData, muBool_t a_bAllowOpt)
502 {
503  MU_TRY
504  muParser_t* const p(AsParser(a_hParser));
505  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, a_bAllowOpt != 0);
506  MU_CATCH
507 }
508 
509 
510 API_EXPORT(void) mupDefineFunUserData10(muParserHandle_t a_hParser, const muChar_t* a_szName, muFunUserData10_t a_pFun, void* a_pUserData, muBool_t a_bAllowOpt)
511 {
512  MU_TRY
513  muParser_t* const p(AsParser(a_hParser));
514  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, a_bAllowOpt != 0);
515  MU_CATCH
516 }
517 
518 
519 API_EXPORT(void) mupDefineBulkFun0(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun0_t a_pFun)
520 {
521  MU_TRY
522  muParser_t* const p(AsParser(a_hParser));
523  p->DefineFun(a_szName, a_pFun, false);
524  MU_CATCH
525 }
526 
527 
528 API_EXPORT(void) mupDefineBulkFun1(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun1_t a_pFun)
529 {
530  MU_TRY
531  muParser_t* const p(AsParser(a_hParser));
532  p->DefineFun(a_szName, a_pFun, false);
533  MU_CATCH
534 }
535 
536 
537 API_EXPORT(void) mupDefineBulkFun2(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun2_t a_pFun)
538 {
539  MU_TRY
540  muParser_t* const p(AsParser(a_hParser));
541  p->DefineFun(a_szName, a_pFun, false);
542  MU_CATCH
543 }
544 
545 
546 API_EXPORT(void) mupDefineBulkFun3(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun3_t a_pFun)
547 {
548  MU_TRY
549  muParser_t* const p(AsParser(a_hParser));
550  p->DefineFun(a_szName, a_pFun, false);
551  MU_CATCH
552 }
553 
554 
555 API_EXPORT(void) mupDefineBulkFun4(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun4_t a_pFun)
556 {
557  MU_TRY
558  muParser_t* const p(AsParser(a_hParser));
559  p->DefineFun(a_szName, a_pFun, false);
560  MU_CATCH
561 }
562 
563 
564 API_EXPORT(void) mupDefineBulkFun5(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun5_t a_pFun)
565 {
566  MU_TRY
567  muParser_t* const p(AsParser(a_hParser));
568  p->DefineFun(a_szName, a_pFun, false);
569  MU_CATCH
570 }
571 
572 
573 API_EXPORT(void) mupDefineBulkFun6(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun6_t a_pFun)
574 {
575  MU_TRY
576  muParser_t* const p(AsParser(a_hParser));
577  p->DefineFun(a_szName, a_pFun, false);
578  MU_CATCH
579 }
580 
581 
582 API_EXPORT(void) mupDefineBulkFun7(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun7_t a_pFun)
583 {
584  MU_TRY
585  muParser_t* const p(AsParser(a_hParser));
586  p->DefineFun(a_szName, a_pFun, false);
587  MU_CATCH
588 }
589 
590 
591 API_EXPORT(void) mupDefineBulkFun8(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun8_t a_pFun)
592 {
593  MU_TRY
594  muParser_t* const p(AsParser(a_hParser));
595  p->DefineFun(a_szName, a_pFun, false);
596  MU_CATCH
597 }
598 
599 
600 API_EXPORT(void) mupDefineBulkFun9(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun9_t a_pFun)
601 {
602  MU_TRY
603  muParser_t* const p(AsParser(a_hParser));
604  p->DefineFun(a_szName, a_pFun, false);
605  MU_CATCH
606 }
607 
608 
609 API_EXPORT(void) mupDefineBulkFun10(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun10_t a_pFun)
610 {
611  MU_TRY
612  muParser_t* const p(AsParser(a_hParser));
613  p->DefineFun(a_szName, a_pFun, false);
614  MU_CATCH
615 }
616 
617 
618 API_EXPORT(void) mupDefineBulkFunUserData0(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFunUserData0_t a_pFun, void* a_pUserData)
619 {
620  MU_TRY
621  muParser_t* const p(AsParser(a_hParser));
622  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, false);
623  MU_CATCH
624 }
625 
626 
627 API_EXPORT(void) mupDefineBulkFunUserData1(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFunUserData1_t a_pFun, void* a_pUserData)
628 {
629  MU_TRY
630  muParser_t* const p(AsParser(a_hParser));
631  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, false);
632  MU_CATCH
633 }
634 
635 
636 API_EXPORT(void) mupDefineBulkFunUserData2(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFunUserData2_t a_pFun, void* a_pUserData)
637 {
638  MU_TRY
639  muParser_t* const p(AsParser(a_hParser));
640  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, false);
641  MU_CATCH
642 }
643 
644 
645 API_EXPORT(void) mupDefineBulkFunUserData3(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFunUserData3_t a_pFun, void* a_pUserData)
646 {
647  MU_TRY
648  muParser_t* const p(AsParser(a_hParser));
649  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, false);
650  MU_CATCH
651 }
652 
653 
654 API_EXPORT(void) mupDefineBulkFunUserData4(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFunUserData4_t a_pFun, void* a_pUserData)
655 {
656  MU_TRY
657  muParser_t* const p(AsParser(a_hParser));
658  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, false);
659  MU_CATCH
660 }
661 
662 
663 API_EXPORT(void) mupDefineBulkFunUserData5(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFunUserData5_t a_pFun, void* a_pUserData)
664 {
665  MU_TRY
666  muParser_t* const p(AsParser(a_hParser));
667  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, false);
668  MU_CATCH
669 }
670 
671 
672 API_EXPORT(void) mupDefineBulkFunUserData6(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFunUserData6_t a_pFun, void* a_pUserData)
673 {
674  MU_TRY
675  muParser_t* const p(AsParser(a_hParser));
676  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, false);
677  MU_CATCH
678 }
679 
680 
681 API_EXPORT(void) mupDefineBulkFunUserData7(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFunUserData7_t a_pFun, void* a_pUserData)
682 {
683  MU_TRY
684  muParser_t* const p(AsParser(a_hParser));
685  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, false);
686  MU_CATCH
687 }
688 
689 
690 API_EXPORT(void) mupDefineBulkFunUserData8(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFunUserData8_t a_pFun, void* a_pUserData)
691 {
692  MU_TRY
693  muParser_t* const p(AsParser(a_hParser));
694  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, false);
695  MU_CATCH
696 }
697 
698 
699 API_EXPORT(void) mupDefineBulkFunUserData9(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFunUserData9_t a_pFun, void* a_pUserData)
700 {
701  MU_TRY
702  muParser_t* const p(AsParser(a_hParser));
703  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, false);
704  MU_CATCH
705 }
706 
707 
708 API_EXPORT(void) mupDefineBulkFunUserData10(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFunUserData10_t a_pFun, void* a_pUserData)
709 {
710  MU_TRY
711  muParser_t* const p(AsParser(a_hParser));
712  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, false);
713  MU_CATCH
714 }
715 
716 
717 API_EXPORT(void) mupDefineStrFun1(muParserHandle_t a_hParser, const muChar_t* a_szName, muStrFun1_t a_pFun)
718 {
719  MU_TRY
720  muParser_t* const p(AsParser(a_hParser));
721  p->DefineFun(a_szName, a_pFun, false);
722  MU_CATCH
723 }
724 
725 
726 API_EXPORT(void) mupDefineStrFun2(muParserHandle_t a_hParser, const muChar_t* a_szName, muStrFun2_t a_pFun)
727 {
728  MU_TRY
729  muParser_t* const p(AsParser(a_hParser));
730  p->DefineFun(a_szName, a_pFun, false);
731  MU_CATCH
732 }
733 
734 
735 API_EXPORT(void) mupDefineStrFun3(muParserHandle_t a_hParser, const muChar_t* a_szName, muStrFun3_t a_pFun)
736 {
737  MU_TRY
738  muParser_t* const p(AsParser(a_hParser));
739  p->DefineFun(a_szName, a_pFun, false);
740  MU_CATCH
741 }
742 
743 
744 API_EXPORT(void) mupDefineStrFun4(muParserHandle_t a_hParser, const muChar_t* a_szName, muStrFun4_t a_pFun)
745 {
746  MU_TRY
747  muParser_t* const p(AsParser(a_hParser));
748  p->DefineFun(a_szName, a_pFun, false);
749  MU_CATCH
750 }
751 
752 
753 API_EXPORT(void) mupDefineStrFun5(muParserHandle_t a_hParser, const muChar_t* a_szName, muStrFun5_t a_pFun)
754 {
755  MU_TRY
756  muParser_t* const p(AsParser(a_hParser));
757  p->DefineFun(a_szName, a_pFun, false);
758  MU_CATCH
759 }
760 
761 
762 API_EXPORT(void) mupDefineStrFunUserData1(muParserHandle_t a_hParser, const muChar_t* a_szName, muStrFunUserData1_t a_pFun, void* a_pUserData)
763 {
764  MU_TRY
765  muParser_t* const p(AsParser(a_hParser));
766  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, false);
767  MU_CATCH
768 }
769 
770 
771 API_EXPORT(void) mupDefineStrFunUserData2(muParserHandle_t a_hParser, const muChar_t* a_szName, muStrFunUserData2_t a_pFun, void* a_pUserData)
772 {
773  MU_TRY
774  muParser_t* const p(AsParser(a_hParser));
775  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, false);
776  MU_CATCH
777 }
778 
779 
780 API_EXPORT(void) mupDefineStrFunUserData3(muParserHandle_t a_hParser, const muChar_t* a_szName, muStrFunUserData3_t a_pFun, void* a_pUserData)
781 {
782  MU_TRY
783  muParser_t* const p(AsParser(a_hParser));
784  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, false);
785  MU_CATCH
786 }
787 
788 
789 API_EXPORT(void) mupDefineStrFunUserData4(muParserHandle_t a_hParser, const muChar_t* a_szName, muStrFunUserData4_t a_pFun, void* a_pUserData)
790 {
791  MU_TRY
792  muParser_t* const p(AsParser(a_hParser));
793  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, false);
794  MU_CATCH
795 }
796 
797 
798 API_EXPORT(void) mupDefineStrFunUserData5(muParserHandle_t a_hParser, const muChar_t* a_szName, muStrFunUserData5_t a_pFun, void* a_pUserData)
799 {
800  MU_TRY
801  muParser_t* const p(AsParser(a_hParser));
802  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, false);
803  MU_CATCH
804 }
805 
806 
807 API_EXPORT(void) mupDefineMultFun(muParserHandle_t a_hParser, const muChar_t* a_szName, muMultFun_t a_pFun, muBool_t a_bAllowOpt)
808 {
809  MU_TRY
810  muParser_t* const p(AsParser(a_hParser));
811  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
812  MU_CATCH
813 }
814 
815 
816 API_EXPORT(void) mupDefineMultFunUserData(muParserHandle_t a_hParser, const muChar_t* a_szName, muMultFunUserData_t a_pFun, void* a_pUserData, muBool_t a_bAllowOpt)
817 {
818  MU_TRY
819  muParser_t* const p(AsParser(a_hParser));
820  p->DefineFunUserData(a_szName, a_pFun, a_pUserData, a_bAllowOpt != 0);
821  MU_CATCH
822 }
823 
824 
825 API_EXPORT(void) mupDefineOprt(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun2_t a_pFun, muInt_t a_nPrec, muInt_t a_nOprtAsct, muBool_t a_bAllowOpt)
826 {
827  MU_TRY
828  muParser_t* const p(AsParser(a_hParser));
829  p->DefineOprt(a_szName, a_pFun, a_nPrec, (mu::EOprtAssociativity)a_nOprtAsct, a_bAllowOpt != 0);
830  MU_CATCH
831 }
832 
833 
834 API_EXPORT(void) mupDefineVar(muParserHandle_t a_hParser, const muChar_t* a_szName, muFloat_t* a_pVar)
835 {
836  MU_TRY
837  muParser_t* const p(AsParser(a_hParser));
838  p->DefineVar(a_szName, a_pVar);
839  MU_CATCH
840 }
841 
842 
843 API_EXPORT(void) mupDefineBulkVar(muParserHandle_t a_hParser, const muChar_t* a_szName, muFloat_t* a_pVar)
844 {
845  MU_TRY
846  muParser_t* const p(AsParser(a_hParser));
847  p->DefineVar(a_szName, a_pVar);
848  MU_CATCH
849 }
850 
851 
852 API_EXPORT(void) mupDefineConst(muParserHandle_t a_hParser, const muChar_t* a_szName, muFloat_t a_fVal)
853 {
854  MU_TRY
855  muParser_t* const p(AsParser(a_hParser));
856  p->DefineConst(a_szName, a_fVal);
857  MU_CATCH
858 }
859 
860 
861 API_EXPORT(void) mupDefineStrConst(muParserHandle_t a_hParser, const muChar_t* a_szName, const muChar_t* a_szVal)
862 {
863  MU_TRY
864  muParser_t* const p(AsParser(a_hParser));
865  p->DefineStrConst(a_szName, a_szVal);
866  MU_CATCH
867 }
868 
869 
870 API_EXPORT(const muChar_t*) mupGetExpr(muParserHandle_t a_hParser)
871 {
872  MU_TRY
873  muParser_t* const p(AsParser(a_hParser));
874 
875  // C# explodes when pMsg is returned directly. For some reason it can't access
876  // the memory where the message lies directly.
877 #ifndef _UNICODE
878  snprintf(s_tmpOutBuf, count_of(s_tmpOutBuf), "%s", p->GetExpr().c_str());
879 #else
880  swprintf(s_tmpOutBuf, count_of(s_tmpOutBuf), _T("%s"), p->GetExpr().c_str());
881 #endif
882 
883  return s_tmpOutBuf;
884  MU_CATCH
885 
886  return _T("");
887 }
888 
889 
890 API_EXPORT(void) mupDefinePostfixOprt(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun1_t a_pOprt, muBool_t a_bAllowOpt)
891 {
892  MU_TRY
893  muParser_t* const p(AsParser(a_hParser));
894  p->DefinePostfixOprt(a_szName, a_pOprt, a_bAllowOpt != 0);
895  MU_CATCH
896 }
897 
898 // Signature changed to fix #125 (https://github.com/beltoforion/muparser/issues/125)
899 API_EXPORT(void) mupDefineInfixOprt(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun1_t a_pOprt, int a_iPrec, muBool_t a_bAllowOpt)
900 {
901  MU_TRY
902  muParser_t* const p(AsParser(a_hParser));
903  p->DefineInfixOprt(a_szName, a_pOprt, a_iPrec, a_bAllowOpt != 0);
904  MU_CATCH
905 }
906 
907 // Define character sets for identifiers
908 API_EXPORT(void) mupDefineNameChars(muParserHandle_t a_hParser, const muChar_t* a_szCharset)
909 {
910  muParser_t* const p(AsParser(a_hParser));
911  p->DefineNameChars(a_szCharset);
912 }
913 
914 
915 API_EXPORT(void) mupDefineOprtChars(muParserHandle_t a_hParser, const muChar_t* a_szCharset)
916 {
917  muParser_t* const p(AsParser(a_hParser));
918  p->DefineOprtChars(a_szCharset);
919 }
920 
921 
922 API_EXPORT(void) mupDefineInfixOprtChars(muParserHandle_t a_hParser, const muChar_t* a_szCharset)
923 {
924  muParser_t* const p(AsParser(a_hParser));
925  p->DefineInfixOprtChars(a_szCharset);
926 }
927 
928 
929 /** \brief Get the number of variables defined in the parser.
930  \param a_hParser [in] Must be a valid parser handle.
931  \return The number of used variables.
932  \sa mupGetExprVar
933 */
934 API_EXPORT(int) mupGetVarNum(muParserHandle_t a_hParser)
935 {
936  MU_TRY
937  muParser_t* const p(AsParser(a_hParser));
938  const mu::varmap_type VarMap = p->GetVar();
939  return (int)VarMap.size();
940  MU_CATCH
941 
942  return 0; // never reached
943 }
944 
945 
946 /** \brief Return a variable that is used in an expression.
947  \param a_hParser [in] A valid parser handle.
948  \param a_iVar [in] The index of the variable to return.
949  \param a_szName [out] Pointer to the variable name.
950  \param a_pVar [out] Pointer to the variable.
951  \throw nothrow
952 
953  Prior to calling this function call mupGetExprVarNum in order to get the
954  number of variables in the expression. If the parameter a_iVar is greater
955  than the number of variables both a_szName and a_pVar will be set to zero.
956  As a side effect this function will trigger an internal calculation of the
957  expression undefined variables will be set to zero during this calculation.
958  During the calculation user defined callback functions present in the expression
959  will be called, this is unavoidable.
960 */
961 API_EXPORT(void) mupGetVar(muParserHandle_t a_hParser, unsigned a_iVar, const muChar_t** a_szName, muFloat_t** a_pVar)
962 {
963  // A static buffer is needed for the name since i can't return the
964  // pointer from the map.
965  static muChar_t szName[1024];
966 
967  MU_TRY
968  muParser_t* const p(AsParser(a_hParser));
969  const mu::varmap_type VarMap = p->GetVar();
970 
971  if (a_iVar >= VarMap.size())
972  {
973  *a_szName = 0;
974  *a_pVar = 0;
975  return;
976  }
977  mu::varmap_type::const_iterator item;
978 
979  item = VarMap.begin();
980  for (unsigned i = 0; i < a_iVar; ++i)
981  ++item;
982 
983 #ifndef _UNICODE
984  strncpy(szName, item->first.c_str(), count_of(szName));
985 #else
986  wcsncpy(szName, item->first.c_str(), count_of(szName));
987 #endif
988 
989  szName[count_of(szName) - 1] = 0;
990 
991  *a_szName = &szName[0];
992  *a_pVar = item->second;
993  return;
994  MU_CATCH
995 
996  * a_szName = 0;
997  *a_pVar = 0;
998 }
999 
1000 
1001 /** \brief Get the number of variables used in the expression currently set in the parser.
1002  \param a_hParser [in] Must be a valid parser handle.
1003  \return The number of used variables.
1004  \sa mupGetExprVar
1005  */
1006 API_EXPORT(int) mupGetExprVarNum(muParserHandle_t a_hParser)
1007 {
1008  MU_TRY
1009  muParser_t* const p(AsParser(a_hParser));
1010  const mu::varmap_type VarMap = p->GetUsedVar();
1011  return (int)VarMap.size();
1012  MU_CATCH
1013 
1014  return 0; // never reached
1015 }
1016 
1017 
1018 /** \brief Return a variable that is used in an expression.
1019 
1020  Prior to calling this function call mupGetExprVarNum in order to get the
1021  number of variables in the expression. If the parameter a_iVar is greater
1022  than the number of variables both a_szName and a_pVar will be set to zero.
1023  As a side effect this function will trigger an internal calculation of the
1024  expression undefined variables will be set to zero during this calculation.
1025  During the calculation user defined callback functions present in the expression
1026  will be called, this is unavoidable.
1027 
1028  \param a_hParser [in] A valid parser handle.
1029  \param a_iVar [in] The index of the variable to return.
1030  \param a_szName [out] Pointer to the variable name.
1031  \param a_pVar [out] Pointer to the variable.
1032  \throw nothrow
1033 */
1034 API_EXPORT(void) mupGetExprVar(muParserHandle_t a_hParser, unsigned a_iVar, const muChar_t** a_szName, muFloat_t** a_pVar)
1035 {
1036  // A static buffer is needed for the name since i can't return the
1037  // pointer from the map.
1038  static muChar_t szName[1024];
1039 
1040  MU_TRY
1041  muParser_t* const p(AsParser(a_hParser));
1042  const mu::varmap_type VarMap = p->GetUsedVar();
1043 
1044  if (a_iVar >= VarMap.size())
1045  {
1046  *a_szName = 0;
1047  *a_pVar = 0;
1048  return;
1049  }
1050  mu::varmap_type::const_iterator item;
1051 
1052  item = VarMap.begin();
1053  for (unsigned i = 0; i < a_iVar; ++i)
1054  ++item;
1055 
1056 #ifndef _UNICODE
1057  strncpy(szName, item->first.c_str(), count_of(szName));
1058 #else
1059  wcsncpy(szName, item->first.c_str(), count_of(szName));
1060 #endif
1061 
1062  szName[count_of(szName) - 1] = 0;
1063 
1064  *a_szName = &szName[0];
1065  *a_pVar = item->second;
1066  return;
1067  MU_CATCH
1068 
1069  * a_szName = 0;
1070  *a_pVar = 0;
1071 }
1072 
1073 
1074 /** \brief Return the number of constants defined in a parser. */
1075 API_EXPORT(int) mupGetConstNum(muParserHandle_t a_hParser)
1076 {
1077  MU_TRY
1078  muParser_t* const p(AsParser(a_hParser));
1079  const mu::valmap_type ValMap = p->GetConst();
1080  return (int)ValMap.size();
1081  MU_CATCH
1082 
1083  return 0; // never reached
1084 }
1085 
1086 
1087 API_EXPORT(void) mupSetArgSep(muParserHandle_t a_hParser, const muChar_t cArgSep)
1088 {
1089  MU_TRY
1090  muParser_t* const p(AsParser(a_hParser));
1091  p->SetArgSep(cArgSep);
1092  MU_CATCH
1093 }
1094 
1095 
1096 API_EXPORT(void) mupResetLocale(muParserHandle_t a_hParser)
1097 {
1098  MU_TRY
1099  muParser_t* const p(AsParser(a_hParser));
1100  p->ResetLocale();
1101  MU_CATCH
1102 }
1103 
1104 
1105 API_EXPORT(void) mupSetDecSep(muParserHandle_t a_hParser, const muChar_t cDecSep)
1106 {
1107  MU_TRY
1108  muParser_t* const p(AsParser(a_hParser));
1109  p->SetDecSep(cDecSep);
1110  MU_CATCH
1111 }
1112 
1113 
1114 API_EXPORT(void) mupSetThousandsSep(muParserHandle_t a_hParser, const muChar_t cThousandsSep)
1115 {
1116  MU_TRY
1117  muParser_t* const p(AsParser(a_hParser));
1118  p->SetThousandsSep(cThousandsSep);
1119  MU_CATCH
1120 }
1121 
1122 //---------------------------------------------------------------------------
1123 /** \brief Retrieve name and value of a single parser constant.
1124  \param a_hParser [in] a valid parser handle
1125  \param a_iVar [in] Index of the constant to query
1126  \param a_pszName [out] pointer to a null terminated string with the constant name
1127  \param [out] The constant value
1128  */
1129 API_EXPORT(void) mupGetConst(muParserHandle_t a_hParser, unsigned a_iVar, const muChar_t** a_pszName, muFloat_t* a_fVal)
1130 {
1131  // A static buffer is needed for the name since i can't return the
1132  // pointer from the map.
1133  static muChar_t szName[1024];
1134 
1135  MU_TRY
1136  muParser_t* const p(AsParser(a_hParser));
1137  const mu::valmap_type ValMap = p->GetConst();
1138 
1139  if (a_iVar >= ValMap.size())
1140  {
1141  *a_pszName = 0;
1142  *a_fVal = 0;
1143  return;
1144  }
1145 
1146  mu::valmap_type::const_iterator item;
1147  item = ValMap.begin();
1148  for (unsigned i = 0; i < a_iVar; ++i)
1149  ++item;
1150 
1151 #ifndef _UNICODE
1152  strncpy(szName, item->first.c_str(), count_of(szName));
1153 #else
1154  wcsncpy(szName, item->first.c_str(), count_of(szName));
1155 #endif
1156 
1157  szName[count_of(szName) - 1] = 0;
1158 
1159  *a_pszName = &szName[0];
1160  *a_fVal = item->second;
1161  return;
1162 
1163  MU_CATCH
1164 
1165  * a_pszName = 0;
1166  *a_fVal = 0;
1167 }
1168 
1169 
1170 /** \brief Add a custom value recognition function. */
1171 API_EXPORT(void) mupAddValIdent(muParserHandle_t a_hParser, muIdentFun_t a_pFun)
1172 {
1173  MU_TRY
1174  muParser_t* p(AsParser(a_hParser));
1175  p->AddValIdent(a_pFun);
1176  MU_CATCH
1177 }
1178 
1179 
1180 /** \brief Query if an error occurred.
1181 
1182  After querying the internal error bit will be reset. So a consecutive call
1183  will return false.
1184 */
1185 API_EXPORT(muBool_t) mupError(muParserHandle_t a_hParser)
1186 {
1187  bool bError(AsParserTag(a_hParser)->bError);
1188  AsParserTag(a_hParser)->bError = false;
1189  return bError;
1190 }
1191 
1192 
1193 /** \brief Reset the internal error flag. */
1194 API_EXPORT(void) mupErrorReset(muParserHandle_t a_hParser)
1195 {
1196  AsParserTag(a_hParser)->bError = false;
1197 }
1198 
1199 
1200 API_EXPORT(void) mupSetErrorHandler(muParserHandle_t a_hParser, muErrorHandler_t a_pHandler)
1201 {
1202  AsParserTag(a_hParser)->errHandler = a_pHandler;
1203 }
1204 
1205 
1206 /** \brief Return the message associated with the last error. */
1207 API_EXPORT(const muChar_t*) mupGetErrorMsg(muParserHandle_t a_hParser)
1208 {
1209  ParserTag* const p(AsParserTag(a_hParser));
1210  const muChar_t* pMsg = p->exc.GetMsg().c_str();
1211 
1212  // C# explodes when pMsg is returned directly. For some reason it can't access
1213  // the memory where the message lies directly.
1214 #ifndef _UNICODE
1215  snprintf(s_tmpOutBuf, count_of(s_tmpOutBuf), "%s", pMsg);
1216 #else
1217  swprintf(s_tmpOutBuf, count_of(s_tmpOutBuf), _T("%s"), pMsg);
1218 #endif
1219 
1220  return s_tmpOutBuf;
1221 }
1222 
1223 
1224 /** \brief Return the message associated with the last error. */
1225 API_EXPORT(const muChar_t*) mupGetErrorToken(muParserHandle_t a_hParser)
1226 {
1227  ParserTag* const p(AsParserTag(a_hParser));
1228  const muChar_t* pToken = p->exc.GetToken().c_str();
1229 
1230  // C# explodes when pMsg is returned directly. For some reason it can't access
1231  // the memory where the message lies directly.
1232 #ifndef _UNICODE
1233  snprintf(s_tmpOutBuf, count_of(s_tmpOutBuf), "%s", pToken);
1234 #else
1235  swprintf(s_tmpOutBuf, count_of(s_tmpOutBuf), _T("%s"), pToken);
1236 #endif
1237 
1238  return s_tmpOutBuf;
1239 }
1240 
1241 
1242 /** \brief Return the code associated with the last error.
1243 */
1244 API_EXPORT(int) mupGetErrorCode(muParserHandle_t a_hParser)
1245 {
1246  return AsParserTag(a_hParser)->exc.GetCode();
1247 }
1248 
1249 
1250 /** \brief Return the position associated with the last error. */
1251 API_EXPORT(int) mupGetErrorPos(muParserHandle_t a_hParser)
1252 {
1253  return (int)AsParserTag(a_hParser)->exc.GetPos();
1254 }
1255 
1256 
1257 API_EXPORT(muFloat_t*) mupCreateVar()
1258 {
1259  return new muFloat_t(0);
1260 }
1261 
1262 
1263 API_EXPORT(void) mupReleaseVar(muFloat_t* ptr)
1264 {
1265  delete ptr;
1266 }
1267 
1268 #if defined(_MSC_VER)
1269  #pragma warning(pop)
1270 #endif
1271 
1272 #endif // MUPARSER_DLL
#define _T(x)
Activate this option in order to compile with OpenMP support.
Definition: muParserDef.h:69
std::map< string_type, value_type * > varmap_type
Type used for storing variables.
Definition: muParserDef.h:316
Definition of a parser using integer value.
Definition of the standard floating point parser.
EOprtAssociativity
Parser operator precedence values.
Definition: muParserDef.h:199
std::map< string_type, value_type > valmap_type
Type used for storing constants.
Definition: muParserDef.h:319
Error class of the parser.
Definition: muParserError.h:74
Namespace for mathematical applications.
Definition: muParser.cpp:48
This file contains the DLL interface of muparser.
Mathematical expressions parser (base parser engine).
Definition: muParserBase.h:68
This file defines the error class used by the parser.