muParser API -  1.35
muParserDLL.cpp
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 #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 defined(_MSC_VER)
47  #pragma warning(push)
48  #pragma warning(disable : 26812)
49 #endif
50 
51 #define MU_TRY \
52  try \
53  {
54 
55 #define MU_CATCH \
56  } \
57  catch (muError_t &e) \
58  { \
59  ParserTag *pTag = static_cast<ParserTag*>(a_hParser); \
60  pTag->exc = e; \
61  pTag->bError = true; \
62  if (pTag->errHandler) \
63  (pTag->errHandler)(a_hParser); \
64  } \
65  catch (...) \
66  { \
67  ParserTag *pTag = static_cast<ParserTag*>(a_hParser); \
68  pTag->exc = muError_t(mu::ecINTERNAL_ERROR); \
69  pTag->bError = true; \
70  if (pTag->errHandler) \
71  (pTag->errHandler)(a_hParser); \
72  }
73 
74 /** \file
75  \brief This file contains the implementation of the DLL interface of muparser.
76 */
77 
78 typedef mu::ParserBase::exception_type muError_t;
79 typedef mu::ParserBase muParser_t;
80 int g_nBulkSize;
81 
82 
83 class ParserTag
84 {
85 public:
86  ParserTag(int nType)
87  : pParser((nType == muBASETYPE_FLOAT)
88  ? (mu::ParserBase*)new mu::Parser()
89  : (nType == muBASETYPE_INT) ? (mu::ParserBase*)new mu::ParserInt() : nullptr)
90  , exc()
91  , errHandler(nullptr)
92  , bError(false)
93  , m_nParserType(nType)
94  {}
95 
96  ~ParserTag()
97  {
98  delete pParser;
99  }
100 
101  mu::ParserBase* pParser;
103  muErrorHandler_t errHandler;
104  bool bError;
105 
106 private:
107  ParserTag(const ParserTag& ref);
108  ParserTag& operator=(const ParserTag& ref);
109 
110  int m_nParserType;
111 };
112 
113 static muChar_t s_tmpOutBuf[2048];
114 
115 //---------------------------------------------------------------------------
116 //
117 //
118 // unexported functions
119 //
120 //
121 //---------------------------------------------------------------------------
122 
123 
124 inline muParser_t* AsParser(muParserHandle_t a_hParser)
125 {
126  return static_cast<ParserTag*>(a_hParser)->pParser;
127 }
128 
129 
130 inline ParserTag* AsParserTag(muParserHandle_t a_hParser)
131 {
132  return static_cast<ParserTag*>(a_hParser);
133 }
134 
135 
136 #if defined(_WIN32)
137 
138 BOOL APIENTRY DllMain(HANDLE /*hModule*/, DWORD ul_reason_for_call, LPVOID /*lpReserved*/)
139 {
140  switch (ul_reason_for_call)
141  {
142  case DLL_PROCESS_ATTACH:
143  break;
144 
145  case DLL_THREAD_ATTACH:
146  case DLL_THREAD_DETACH:
147  case DLL_PROCESS_DETACH:
148  break;
149  }
150 
151  return TRUE;
152 }
153 
154 #endif
155 
156 //---------------------------------------------------------------------------
157 //
158 //
159 // exported functions
160 //
161 //
162 //---------------------------------------------------------------------------
163 
164 API_EXPORT(void) mupSetVarFactory(muParserHandle_t a_hParser, muFacFun_t a_pFactory, void* pUserData)
165 {
166  MU_TRY
167  muParser_t* p(AsParser(a_hParser));
168  p->SetVarFactory(a_pFactory, pUserData);
169  MU_CATCH
170 }
171 
172 
173 /** \brief Create a new Parser instance and return its handle. */
174 API_EXPORT(muParserHandle_t) mupCreate(int nBaseType)
175 {
176  switch (nBaseType)
177  {
178  case muBASETYPE_FLOAT: return (void*)(new ParserTag(muBASETYPE_FLOAT));
179  case muBASETYPE_INT: return (void*)(new ParserTag(muBASETYPE_INT));
180  default: return nullptr;
181  }
182 }
183 
184 
185 /** \brief Release the parser instance related with a parser handle. */
186 API_EXPORT(void) mupRelease(muParserHandle_t a_hParser)
187 {
188  MU_TRY
189  ParserTag* p = static_cast<ParserTag*>(a_hParser);
190  delete p;
191  MU_CATCH
192 }
193 
194 
195 API_EXPORT(const muChar_t*) mupGetVersion(muParserHandle_t a_hParser)
196 {
197  MU_TRY
198  muParser_t* const p(AsParser(a_hParser));
199 
200 #ifndef _UNICODE
201  sprintf(s_tmpOutBuf, "%s", p->GetVersion().c_str());
202 #else
203  wsprintf(s_tmpOutBuf, _T("%s"), p->GetVersion().c_str());
204 #endif
205 
206  return s_tmpOutBuf;
207  MU_CATCH
208  return _T("");
209 }
210 
211 
212 /** \brief Evaluate the expression. */
213 API_EXPORT(muFloat_t) mupEval(muParserHandle_t a_hParser)
214 {
215  MU_TRY
216  muParser_t* const p(AsParser(a_hParser));
217  return p->Eval();
218  MU_CATCH
219  return 0;
220 }
221 
222 
223 API_EXPORT(muFloat_t*) mupEvalMulti(muParserHandle_t a_hParser, int* nNum)
224 {
225  MU_TRY
226  if (nNum == nullptr)
227  throw std::runtime_error("Argument is null!");
228 
229  muParser_t* const p(AsParser(a_hParser));
230  return p->Eval(*nNum);
231  MU_CATCH
232  return 0;
233 }
234 
235 
236 API_EXPORT(void) mupEvalBulk(muParserHandle_t a_hParser, muFloat_t* a_res, int nSize)
237 {
238  MU_TRY
239  muParser_t* p(AsParser(a_hParser));
240  p->Eval(a_res, nSize);
241  MU_CATCH
242 }
243 
244 
245 API_EXPORT(void) mupSetExpr(muParserHandle_t a_hParser, const muChar_t* a_szExpr)
246 {
247  MU_TRY
248  muParser_t* const p(AsParser(a_hParser));
249  p->SetExpr(a_szExpr);
250  MU_CATCH
251 }
252 
253 
254 API_EXPORT(void) mupRemoveVar(muParserHandle_t a_hParser, const muChar_t* a_szName)
255 {
256  MU_TRY
257  muParser_t* const p(AsParser(a_hParser));
258  p->RemoveVar(a_szName);
259  MU_CATCH
260 }
261 
262 
263 /** \brief Release all parser variables.
264  \param a_hParser Handle to the parser instance.
265 */
266 API_EXPORT(void) mupClearVar(muParserHandle_t a_hParser)
267 {
268  MU_TRY
269  muParser_t* const p(AsParser(a_hParser));
270  p->ClearVar();
271  MU_CATCH
272 }
273 
274 
275 /** \brief Release all parser variables.
276  \param a_hParser Handle to the parser instance.
277 */
278 API_EXPORT(void) mupClearConst(muParserHandle_t a_hParser)
279 {
280  MU_TRY
281  muParser_t* const p(AsParser(a_hParser));
282  p->ClearConst();
283  MU_CATCH
284 }
285 
286 
287 /** \brief Clear all user defined operators.
288  \param a_hParser Handle to the parser instance.
289 */
290 API_EXPORT(void) mupClearOprt(muParserHandle_t a_hParser)
291 {
292  MU_TRY
293  muParser_t* const p(AsParser(a_hParser));
294  p->ClearOprt();
295  MU_CATCH
296 }
297 
298 
299 API_EXPORT(void) mupClearFun(muParserHandle_t a_hParser)
300 {
301  MU_TRY
302  muParser_t* const p(AsParser(a_hParser));
303  p->ClearFun();
304  MU_CATCH
305 }
306 
307 
308 API_EXPORT(void) mupDefineFun0(muParserHandle_t a_hParser,
309  const muChar_t* a_szName,
310  muFun0_t a_pFun,
311  muBool_t a_bAllowOpt)
312 {
313  MU_TRY
314  muParser_t* const p(AsParser(a_hParser));
315  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
316  MU_CATCH
317 }
318 
319 
320 API_EXPORT(void) mupDefineFun1(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun1_t a_pFun, muBool_t a_bAllowOpt)
321 {
322  MU_TRY
323  muParser_t* const p(AsParser(a_hParser));
324  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
325  MU_CATCH
326 }
327 
328 
329 API_EXPORT(void) mupDefineFun2(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun2_t a_pFun, muBool_t a_bAllowOpt)
330 {
331  MU_TRY
332  muParser_t* const p(AsParser(a_hParser));
333  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
334  MU_CATCH
335 }
336 
337 
338 API_EXPORT(void) mupDefineFun3(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun3_t a_pFun, muBool_t a_bAllowOpt)
339 {
340  MU_TRY
341  muParser_t* const p(AsParser(a_hParser));
342  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
343  MU_CATCH
344 }
345 
346 
347 API_EXPORT(void) mupDefineFun4(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun4_t a_pFun, muBool_t a_bAllowOpt)
348 {
349  MU_TRY
350  muParser_t* const p(AsParser(a_hParser));
351  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
352  MU_CATCH
353 }
354 
355 
356 API_EXPORT(void) mupDefineFun5(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun5_t a_pFun, muBool_t a_bAllowOpt)
357 {
358  MU_TRY
359  muParser_t* const p(AsParser(a_hParser));
360  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
361  MU_CATCH
362 }
363 
364 
365 API_EXPORT(void) mupDefineFun6(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun6_t a_pFun, muBool_t a_bAllowOpt)
366 {
367  MU_TRY
368  muParser_t* const p(AsParser(a_hParser));
369  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
370  MU_CATCH
371 }
372 
373 
374 API_EXPORT(void) mupDefineFun7(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun7_t a_pFun, muBool_t a_bAllowOpt)
375 {
376  MU_TRY
377  muParser_t* const p(AsParser(a_hParser));
378  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
379  MU_CATCH
380 }
381 
382 
383 API_EXPORT(void) mupDefineFun8(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun8_t a_pFun, muBool_t a_bAllowOpt)
384 {
385  MU_TRY
386  muParser_t* const p(AsParser(a_hParser));
387  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
388  MU_CATCH
389 }
390 
391 
392 API_EXPORT(void) mupDefineFun9(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun9_t a_pFun, muBool_t a_bAllowOpt)
393 {
394  MU_TRY
395  muParser_t* const p(AsParser(a_hParser));
396  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
397  MU_CATCH
398 }
399 
400 
401 API_EXPORT(void) mupDefineFun10(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun10_t a_pFun, muBool_t a_bAllowOpt)
402 {
403  MU_TRY
404  muParser_t* const p(AsParser(a_hParser));
405  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
406  MU_CATCH
407 }
408 
409 
410 API_EXPORT(void) mupDefineBulkFun0(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun0_t a_pFun)
411 {
412  MU_TRY
413  muParser_t* const p(AsParser(a_hParser));
414  p->DefineFun(a_szName, a_pFun, false);
415  MU_CATCH
416 }
417 
418 
419 API_EXPORT(void) mupDefineBulkFun1(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun1_t a_pFun)
420 {
421  MU_TRY
422  muParser_t* const p(AsParser(a_hParser));
423  p->DefineFun(a_szName, a_pFun, false);
424  MU_CATCH
425 }
426 
427 
428 API_EXPORT(void) mupDefineBulkFun2(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun2_t a_pFun)
429 {
430  MU_TRY
431  muParser_t* const p(AsParser(a_hParser));
432  p->DefineFun(a_szName, a_pFun, false);
433  MU_CATCH
434 }
435 
436 
437 API_EXPORT(void) mupDefineBulkFun3(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun3_t a_pFun)
438 {
439  MU_TRY
440  muParser_t* const p(AsParser(a_hParser));
441  p->DefineFun(a_szName, a_pFun, false);
442  MU_CATCH
443 }
444 
445 
446 API_EXPORT(void) mupDefineBulkFun4(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun4_t a_pFun)
447 {
448  MU_TRY
449  muParser_t* const p(AsParser(a_hParser));
450  p->DefineFun(a_szName, a_pFun, false);
451  MU_CATCH
452 }
453 
454 
455 API_EXPORT(void) mupDefineBulkFun5(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun5_t a_pFun)
456 {
457  MU_TRY
458  muParser_t* const p(AsParser(a_hParser));
459  p->DefineFun(a_szName, a_pFun, false);
460  MU_CATCH
461 }
462 
463 
464 API_EXPORT(void) mupDefineBulkFun6(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun6_t a_pFun)
465 {
466  MU_TRY
467  muParser_t* const p(AsParser(a_hParser));
468  p->DefineFun(a_szName, a_pFun, false);
469  MU_CATCH
470 }
471 
472 
473 API_EXPORT(void) mupDefineBulkFun7(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun7_t a_pFun)
474 {
475  MU_TRY
476  muParser_t* const p(AsParser(a_hParser));
477  p->DefineFun(a_szName, a_pFun, false);
478  MU_CATCH
479 }
480 
481 
482 API_EXPORT(void) mupDefineBulkFun8(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun8_t a_pFun)
483 {
484  MU_TRY
485  muParser_t* const p(AsParser(a_hParser));
486  p->DefineFun(a_szName, a_pFun, false);
487  MU_CATCH
488 }
489 
490 
491 API_EXPORT(void) mupDefineBulkFun9(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun9_t a_pFun)
492 {
493  MU_TRY
494  muParser_t* const p(AsParser(a_hParser));
495  p->DefineFun(a_szName, a_pFun, false);
496  MU_CATCH
497 }
498 
499 
500 API_EXPORT(void) mupDefineBulkFun10(muParserHandle_t a_hParser, const muChar_t* a_szName, muBulkFun10_t a_pFun)
501 {
502  MU_TRY
503  muParser_t* const p(AsParser(a_hParser));
504  p->DefineFun(a_szName, a_pFun, false);
505  MU_CATCH
506 }
507 
508 
509 API_EXPORT(void) mupDefineStrFun1(muParserHandle_t a_hParser, const muChar_t* a_szName, muStrFun1_t a_pFun)
510 {
511  MU_TRY
512  muParser_t* const p(AsParser(a_hParser));
513  p->DefineFun(a_szName, a_pFun, false);
514  MU_CATCH
515 }
516 
517 
518 API_EXPORT(void) mupDefineStrFun2(muParserHandle_t a_hParser, const muChar_t* a_szName, muStrFun2_t a_pFun)
519 {
520  MU_TRY
521  muParser_t* const p(AsParser(a_hParser));
522  p->DefineFun(a_szName, a_pFun, false);
523  MU_CATCH
524 }
525 
526 
527 API_EXPORT(void) mupDefineStrFun3(muParserHandle_t a_hParser, const muChar_t* a_szName, muStrFun3_t a_pFun)
528 {
529  MU_TRY
530  muParser_t* const p(AsParser(a_hParser));
531  p->DefineFun(a_szName, a_pFun, false);
532  MU_CATCH
533 }
534 
535 
536 API_EXPORT(void) mupDefineMultFun(muParserHandle_t a_hParser, const muChar_t* a_szName, muMultFun_t a_pFun, muBool_t a_bAllowOpt)
537 {
538  MU_TRY
539  muParser_t* const p(AsParser(a_hParser));
540  p->DefineFun(a_szName, a_pFun, a_bAllowOpt != 0);
541  MU_CATCH
542 }
543 
544 
545 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)
546 {
547  MU_TRY
548  muParser_t* const p(AsParser(a_hParser));
549  p->DefineOprt(a_szName, a_pFun, a_nPrec, (mu::EOprtAssociativity)a_nOprtAsct, a_bAllowOpt != 0);
550  MU_CATCH
551 }
552 
553 
554 API_EXPORT(void) mupDefineVar(muParserHandle_t a_hParser, const muChar_t* a_szName, muFloat_t* a_pVar)
555 {
556  MU_TRY
557  muParser_t* const p(AsParser(a_hParser));
558  p->DefineVar(a_szName, a_pVar);
559  MU_CATCH
560 }
561 
562 
563 API_EXPORT(void) mupDefineBulkVar(muParserHandle_t a_hParser, const muChar_t* a_szName, muFloat_t* a_pVar)
564 {
565  MU_TRY
566  muParser_t* const p(AsParser(a_hParser));
567  p->DefineVar(a_szName, a_pVar);
568  MU_CATCH
569 }
570 
571 
572 API_EXPORT(void) mupDefineConst(muParserHandle_t a_hParser, const muChar_t* a_szName, muFloat_t a_fVal)
573 {
574  MU_TRY
575  muParser_t* const p(AsParser(a_hParser));
576  p->DefineConst(a_szName, a_fVal);
577  MU_CATCH
578 }
579 
580 
581 API_EXPORT(void) mupDefineStrConst(muParserHandle_t a_hParser, const muChar_t* a_szName, const muChar_t* a_szVal)
582 {
583  MU_TRY
584  muParser_t* const p(AsParser(a_hParser));
585  p->DefineStrConst(a_szName, a_szVal);
586  MU_CATCH
587 }
588 
589 
590 API_EXPORT(const muChar_t*) mupGetExpr(muParserHandle_t a_hParser)
591 {
592  MU_TRY
593  muParser_t* const p(AsParser(a_hParser));
594 
595  // C# explodes when pMsg is returned directly. For some reason it can't access
596  // the memory where the message lies directly.
597 #ifndef _UNICODE
598  sprintf(s_tmpOutBuf, "%s", p->GetExpr().c_str());
599 #else
600  wsprintf(s_tmpOutBuf, _T("%s"), p->GetExpr().c_str());
601 #endif
602 
603  return s_tmpOutBuf;
604  MU_CATCH
605 
606  return _T("");
607 }
608 
609 
610 API_EXPORT(void) mupDefinePostfixOprt(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun1_t a_pOprt, muBool_t a_bAllowOpt)
611 {
612  MU_TRY
613  muParser_t* const p(AsParser(a_hParser));
614  p->DefinePostfixOprt(a_szName, a_pOprt, a_bAllowOpt != 0);
615  MU_CATCH
616 }
617 
618 
619 API_EXPORT(void) mupDefineInfixOprt(muParserHandle_t a_hParser, const muChar_t* a_szName, muFun1_t a_pOprt, muBool_t a_bAllowOpt)
620 {
621  MU_TRY
622  muParser_t* const p(AsParser(a_hParser));
623  p->DefineInfixOprt(a_szName, a_pOprt, a_bAllowOpt != 0);
624  MU_CATCH
625 }
626 
627 // Define character sets for identifiers
628 API_EXPORT(void) mupDefineNameChars(muParserHandle_t a_hParser, const muChar_t* a_szCharset)
629 {
630  muParser_t* const p(AsParser(a_hParser));
631  p->DefineNameChars(a_szCharset);
632 }
633 
634 
635 API_EXPORT(void) mupDefineOprtChars(muParserHandle_t a_hParser, const muChar_t* a_szCharset)
636 {
637  muParser_t* const p(AsParser(a_hParser));
638  p->DefineOprtChars(a_szCharset);
639 }
640 
641 
642 API_EXPORT(void) mupDefineInfixOprtChars(muParserHandle_t a_hParser, const muChar_t* a_szCharset)
643 {
644  muParser_t* const p(AsParser(a_hParser));
645  p->DefineInfixOprtChars(a_szCharset);
646 }
647 
648 
649 /** \brief Get the number of variables defined in the parser.
650  \param a_hParser [in] Must be a valid parser handle.
651  \return The number of used variables.
652  \sa mupGetExprVar
653 */
654 API_EXPORT(int) mupGetVarNum(muParserHandle_t a_hParser)
655 {
656  MU_TRY
657  muParser_t* const p(AsParser(a_hParser));
658  const mu::varmap_type VarMap = p->GetVar();
659  return (int)VarMap.size();
660  MU_CATCH
661 
662  return 0; // never reached
663 }
664 
665 
666 /** \brief Return a variable that is used in an expression.
667  \param a_hParser [in] A valid parser handle.
668  \param a_iVar [in] The index of the variable to return.
669  \param a_szName [out] Pointer to the variable name.
670  \param a_pVar [out] Pointer to the variable.
671  \throw nothrow
672 
673  Prior to calling this function call mupGetExprVarNum in order to get the
674  number of variables in the expression. If the parameter a_iVar is greater
675  than the number of variables both a_szName and a_pVar will be set to zero.
676  As a side effect this function will trigger an internal calculation of the
677  expression undefined variables will be set to zero during this calculation.
678  During the calculation user defined callback functions present in the expression
679  will be called, this is unavoidable.
680 */
681 API_EXPORT(void) mupGetVar(muParserHandle_t a_hParser, unsigned a_iVar, const muChar_t** a_szName, muFloat_t** a_pVar)
682 {
683  // A static buffer is needed for the name since i can't return the
684  // pointer from the map.
685  static muChar_t szName[1024];
686 
687  MU_TRY
688  muParser_t* const p(AsParser(a_hParser));
689  const mu::varmap_type VarMap = p->GetVar();
690 
691  if (a_iVar >= VarMap.size())
692  {
693  *a_szName = 0;
694  *a_pVar = 0;
695  return;
696  }
697  mu::varmap_type::const_iterator item;
698 
699  item = VarMap.begin();
700  for (unsigned i = 0; i < a_iVar; ++i)
701  ++item;
702 
703 #ifndef _UNICODE
704  strncpy(szName, item->first.c_str(), sizeof(szName));
705 #else
706  wcsncpy(szName, item->first.c_str(), sizeof(szName));
707 #endif
708 
709  szName[sizeof(szName) - 1] = 0;
710 
711  *a_szName = &szName[0];
712  *a_pVar = item->second;
713  return;
714  MU_CATCH
715 
716  * a_szName = 0;
717  *a_pVar = 0;
718 }
719 
720 
721 /** \brief Get the number of variables used in the expression currently set in the parser.
722  \param a_hParser [in] Must be a valid parser handle.
723  \return The number of used variables.
724  \sa mupGetExprVar
725  */
726 API_EXPORT(int) mupGetExprVarNum(muParserHandle_t a_hParser)
727 {
728  MU_TRY
729  muParser_t* const p(AsParser(a_hParser));
730  const mu::varmap_type VarMap = p->GetUsedVar();
731  return (int)VarMap.size();
732  MU_CATCH
733 
734  return 0; // never reached
735 }
736 
737 
738 /** \brief Return a variable that is used in an expression.
739 
740  Prior to calling this function call mupGetExprVarNum in order to get the
741  number of variables in the expression. If the parameter a_iVar is greater
742  than the number of variables both a_szName and a_pVar will be set to zero.
743  As a side effect this function will trigger an internal calculation of the
744  expression undefined variables will be set to zero during this calculation.
745  During the calculation user defined callback functions present in the expression
746  will be called, this is unavoidable.
747 
748  \param a_hParser [in] A valid parser handle.
749  \param a_iVar [in] The index of the variable to return.
750  \param a_szName [out] Pointer to the variable name.
751  \param a_pVar [out] Pointer to the variable.
752  \throw nothrow
753 */
754 API_EXPORT(void) mupGetExprVar(muParserHandle_t a_hParser, unsigned a_iVar, const muChar_t** a_szName, muFloat_t** a_pVar)
755 {
756  // A static buffer is needed for the name since i can't return the
757  // pointer from the map.
758  static muChar_t szName[1024];
759 
760  MU_TRY
761  muParser_t* const p(AsParser(a_hParser));
762  const mu::varmap_type VarMap = p->GetUsedVar();
763 
764  if (a_iVar >= VarMap.size())
765  {
766  *a_szName = 0;
767  *a_pVar = 0;
768  return;
769  }
770  mu::varmap_type::const_iterator item;
771 
772  item = VarMap.begin();
773  for (unsigned i = 0; i < a_iVar; ++i)
774  ++item;
775 
776 #ifndef _UNICODE
777  strncpy(szName, item->first.c_str(), sizeof(szName));
778 #else
779  wcsncpy(szName, item->first.c_str(), sizeof(szName));
780 #endif
781 
782  szName[sizeof(szName) - 1] = 0;
783 
784  *a_szName = &szName[0];
785  *a_pVar = item->second;
786  return;
787  MU_CATCH
788 
789  * a_szName = 0;
790  *a_pVar = 0;
791 }
792 
793 
794 /** \brief Return the number of constants defined in a parser. */
795 API_EXPORT(int) mupGetConstNum(muParserHandle_t a_hParser)
796 {
797  MU_TRY
798  muParser_t* const p(AsParser(a_hParser));
799  const mu::valmap_type ValMap = p->GetConst();
800  return (int)ValMap.size();
801  MU_CATCH
802 
803  return 0; // never reached
804 }
805 
806 
807 API_EXPORT(void) mupSetArgSep(muParserHandle_t a_hParser, const muChar_t cArgSep)
808 {
809  MU_TRY
810  muParser_t* const p(AsParser(a_hParser));
811  p->SetArgSep(cArgSep);
812  MU_CATCH
813 }
814 
815 
816 API_EXPORT(void) mupResetLocale(muParserHandle_t a_hParser)
817 {
818  MU_TRY
819  muParser_t* const p(AsParser(a_hParser));
820  p->ResetLocale();
821  MU_CATCH
822 }
823 
824 
825 API_EXPORT(void) mupSetDecSep(muParserHandle_t a_hParser, const muChar_t cDecSep)
826 {
827  MU_TRY
828  muParser_t* const p(AsParser(a_hParser));
829  p->SetDecSep(cDecSep);
830  MU_CATCH
831 }
832 
833 
834 API_EXPORT(void) mupSetThousandsSep(muParserHandle_t a_hParser, const muChar_t cThousandsSep)
835 {
836  MU_TRY
837  muParser_t* const p(AsParser(a_hParser));
838  p->SetThousandsSep(cThousandsSep);
839  MU_CATCH
840 }
841 
842 //---------------------------------------------------------------------------
843 /** \brief Retrieve name and value of a single parser constant.
844  \param a_hParser [in] a valid parser handle
845  \param a_iVar [in] Index of the constant to query
846  \param a_pszName [out] pointer to a null terminated string with the constant name
847  \param [out] The constant value
848  */
849 API_EXPORT(void) mupGetConst(muParserHandle_t a_hParser, unsigned a_iVar, const muChar_t** a_pszName, muFloat_t* a_fVal)
850 {
851  // A static buffer is needed for the name since i can't return the
852  // pointer from the map.
853  static muChar_t szName[1024];
854 
855  MU_TRY
856  muParser_t* const p(AsParser(a_hParser));
857  const mu::valmap_type ValMap = p->GetConst();
858 
859  if (a_iVar >= ValMap.size())
860  {
861  *a_pszName = 0;
862  *a_fVal = 0;
863  return;
864  }
865 
866  mu::valmap_type::const_iterator item;
867  item = ValMap.begin();
868  for (unsigned i = 0; i < a_iVar; ++i)
869  ++item;
870 
871 #ifndef _UNICODE
872  strncpy(szName, item->first.c_str(), sizeof(szName));
873 #else
874  wcsncpy(szName, item->first.c_str(), sizeof(szName));
875 #endif
876 
877  szName[sizeof(szName) - 1] = 0;
878 
879  *a_pszName = &szName[0];
880  *a_fVal = item->second;
881  return;
882 
883  MU_CATCH
884 
885  * a_pszName = 0;
886  *a_fVal = 0;
887 }
888 
889 
890 /** \brief Add a custom value recognition function. */
891 API_EXPORT(void) mupAddValIdent(muParserHandle_t a_hParser, muIdentFun_t a_pFun)
892 {
893  MU_TRY
894  muParser_t* p(AsParser(a_hParser));
895  p->AddValIdent(a_pFun);
896  MU_CATCH
897 }
898 
899 
900 /** \brief Query if an error occurred.
901 
902  After querying the internal error bit will be reset. So a consecutive call
903  will return false.
904 */
905 API_EXPORT(muBool_t) mupError(muParserHandle_t a_hParser)
906 {
907  bool bError(AsParserTag(a_hParser)->bError);
908  AsParserTag(a_hParser)->bError = false;
909  return bError;
910 }
911 
912 
913 /** \brief Reset the internal error flag. */
914 API_EXPORT(void) mupErrorReset(muParserHandle_t a_hParser)
915 {
916  AsParserTag(a_hParser)->bError = false;
917 }
918 
919 
920 API_EXPORT(void) mupSetErrorHandler(muParserHandle_t a_hParser, muErrorHandler_t a_pHandler)
921 {
922  AsParserTag(a_hParser)->errHandler = a_pHandler;
923 }
924 
925 
926 /** \brief Return the message associated with the last error. */
927 API_EXPORT(const muChar_t*) mupGetErrorMsg(muParserHandle_t a_hParser)
928 {
929  ParserTag* const p(AsParserTag(a_hParser));
930  const muChar_t* pMsg = p->exc.GetMsg().c_str();
931 
932  // C# explodes when pMsg is returned directly. For some reason it can't access
933  // the memory where the message lies directly.
934 #ifndef _UNICODE
935  sprintf(s_tmpOutBuf, "%s", pMsg);
936 #else
937  wsprintf(s_tmpOutBuf, _T("%s"), pMsg);
938 #endif
939 
940  return s_tmpOutBuf;
941 }
942 
943 
944 /** \brief Return the message associated with the last error. */
945 API_EXPORT(const muChar_t*) mupGetErrorToken(muParserHandle_t a_hParser)
946 {
947  ParserTag* const p(AsParserTag(a_hParser));
948  const muChar_t* pToken = p->exc.GetToken().c_str();
949 
950  // C# explodes when pMsg is returned directly. For some reason it can't access
951  // the memory where the message lies directly.
952 #ifndef _UNICODE
953  sprintf(s_tmpOutBuf, "%s", pToken);
954 #else
955  wsprintf(s_tmpOutBuf, _T("%s"), pToken);
956 #endif
957 
958  return s_tmpOutBuf;
959 }
960 
961 
962 /** \brief Return the code associated with the last error.
963 */
964 API_EXPORT(int) mupGetErrorCode(muParserHandle_t a_hParser)
965 {
966  return AsParserTag(a_hParser)->exc.GetCode();
967 }
968 
969 
970 /** \brief Return the position associated with the last error. */
971 API_EXPORT(int) mupGetErrorPos(muParserHandle_t a_hParser)
972 {
973  return (int)AsParserTag(a_hParser)->exc.GetPos();
974 }
975 
976 
977 API_EXPORT(muFloat_t*) mupCreateVar()
978 {
979  return new muFloat_t(0);
980 }
981 
982 
983 API_EXPORT(void) mupReleaseVar(muFloat_t* ptr)
984 {
985  delete ptr;
986 }
987 
988 #if defined(_MSC_VER)
989  #pragma warning(pop)
990 #endif
991 
992 #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:314
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:317
Error class of the parser.
Definition: muParserError.h:68
Namespace for mathematical applications.
Definition: muParser.cpp:46
This file contains the DLL interface of muparser.
Mathematical expressions parser (base parser engine).
Definition: muParserBase.h:63
This file defines the error class used by the parser.