OTB  6.7.0
Orfeo Toolbox
otbParserXPlugins.h
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2005-2019 Centre National d'Etudes Spatiales (CNES)
3  *
4  * This file is part of Orfeo Toolbox
5  *
6  * https://www.orfeo-toolbox.org/
7  *
8  * Licensed under the Apache License, Version 2.0 (the "License");
9  * you may not use this file except in compliance with the License.
10  * You may obtain a copy of the License at
11  *
12  * http://www.apache.org/licenses/LICENSE-2.0
13  *
14  * Unless required by applicable law or agreed to in writing, software
15  * distributed under the License is distributed on an "AS IS" BASIS,
16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17  * See the License for the specific language governing permissions and
18  * limitations under the License.
19  */
20 
21 #ifndef otbParserXPlugins_h
22 #define otbParserXPlugins_h
23 
24 #include "itkMacro.h"
25 #include "otbMath.h"
26 
27 #if defined(__GNUC__) || defined(__clang__)
28 #pragma GCC diagnostic push
29 #pragma GCC diagnostic ignored "-Winconsistent-missing-override"
30 #include "mpParser.h"
31 #pragma GCC diagnostic pop
32 #else
33 #include "mpParser.h"
34 #endif
35 #include <vector>
36 
37 namespace otb
38 {
39 
40 
41 class bands : public mup::ICallback
42  {
43 public:
44  bands():ICallback(mup::cmFUNC, "bands", 2)
45  {}
46 
47  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) override;
48 
49  const mup::char_type* GetDesc() const override
50  {
51  return "bands - A bands selector";
52  }
53 
54  mup::IToken* Clone() const override
55  {
56  return new bands(*this);
57  }
58  };
59 
60 
61 class dotpr : public mup::ICallback
62  {
63 public:
64  dotpr():ICallback(mup::cmFUNC, "dotpr", -1)
65  {}
66 
67  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) override;
68 
69  const mup::char_type* GetDesc() const override
70  {
71  return "dotpr(m1,m2) - A vector/matrix dot product";
72  }
73 
74  mup::IToken* Clone() const override
75  {
76  return new dotpr(*this);
77  }
78  };
79 
80 class ElementWiseDivision : public mup::IOprtBin
81  {
82  public:
83  ElementWiseDivision():IOprtBin(_T("div"), (int)(mup::prMUL_DIV), mup::oaLEFT)
84  {}
85 
86  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override;
87 
88  const mup::char_type* GetDesc() const override
89  {
90  return _T("x div y - Element-wise division (vectors / matrices)");
91  }
92 
93  mup::IToken* Clone() const override
94  {
95  return new ElementWiseDivision(*this);
96  }
97  };
98 
99 
100 class DivisionByScalar : public mup::IOprtBin
101  {
102  public:
103  DivisionByScalar():IOprtBin(_T("dv"), (int)(mup::prMUL_DIV), mup::oaLEFT)
104  {}
105 
106  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override;
107 
108  const mup::char_type* GetDesc() const override
109  {
110  return _T("x dv y - division of vectors / matrices by a scalar");
111  }
112 
113  mup::IToken* Clone() const override
114  {
115  return new DivisionByScalar(*this);
116  }
117  };
118 
119 
120 class ElementWiseMultiplication : public mup::IOprtBin
121  {
122  public:
123  ElementWiseMultiplication():IOprtBin(_T("mult"), (int)(mup::prMUL_DIV), mup::oaLEFT)
124  {}
125 
126  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override;
127 
128  const mup::char_type* GetDesc() const override
129  {
130  return _T("x mult y - Element wise multiplication (vectors / matrices)");
131  }
132 
133  mup::IToken* Clone() const override
134  {
135  return new ElementWiseMultiplication(*this);
136  }
137  };
138 
139 
140 class MultiplicationByScalar : public mup::IOprtBin
141  {
142  public:
143  MultiplicationByScalar():IOprtBin(_T("mlt"), (int)(mup::prMUL_DIV), mup::oaLEFT)
144  {}
145 
146  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override;
147 
148  const mup::char_type* GetDesc() const override
149  {
150  return _T("x mlt y - multiplication of vectors / matrices by a scalar");
151  }
152 
153  mup::IToken* Clone() const override
154  {
155  return new MultiplicationByScalar(*this);
156  }
157  };
158 
159 
160 class ElementWisePower : public mup::IOprtBin
161  {
162 public:
163  ElementWisePower():IOprtBin(_T("pow"), (int) mup::prPOW, mup::oaRIGHT)
164  {}
165 
166  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) override;
167 
168  const mup::char_type* GetDesc() const override
169  {
170  return _T("pow - Power for noncomplex vectors & matrices");
171  }
172 
173  mup::IToken* Clone() const override
174  {
175  return new ElementWisePower(*this);
176  }
177  };
178 
179 
180 class PowerByScalar : public mup::IOprtBin
181  {
182  public:
183  PowerByScalar():IOprtBin(_T("pw"), (int)(mup::prMUL_DIV), mup::oaLEFT)
184  {}
185 
186  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override;
187 
188  const mup::char_type* GetDesc() const override
189  {
190  return _T("x pw y - power of vectors / matrices by a scalar");
191  }
192 
193  mup::IToken* Clone() const override
194  {
195  return new PowerByScalar(*this);
196  }
197  };
198 
199 
200 class ndvi : public mup::ICallback
201  {
202 public:
203  ndvi():ICallback(mup::cmFUNC, "ndvi", 2)
204  {}
205 
206  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) override;
207 
208  const mup::char_type* GetDesc() const override
209  {
210  return "NDVI - Normalized Difference Vegetation Index";
211  }
212 
213  mup::IToken* Clone() const override
214  {
215  return new ndvi(*this);
216  }
217  };
218 
219 
220 class cat : public mup::ICallback
221  {
222 public:
223  cat():ICallback(mup::cmFUNC, "cat", -1)
224  {}
225 
226  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) override;
227 
228  const mup::char_type* GetDesc() const override
229  {
230  return "cat(m1,m2) - Values concatenation";
231  }
232 
233  mup::IToken* Clone() const override
234  {
235  return new cat(*this);
236  }
237  };
238 
239 
240 class mean : public mup::ICallback
241  {
242 public:
243  mean():ICallback(mup::cmFUNC, "mean", -1)
244  {}
245 
246  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) override;
247 
248  const mup::char_type* GetDesc() const override
249  {
250  return "mean(m1,m2,..) - mean of each neighborhood";
251  }
252 
253  mup::IToken* Clone() const override
254  {
255  return new mean(*this);
256  }
257  };
258 
259 
260 class var : public mup::ICallback
261  {
262 public:
263  var():ICallback(mup::cmFUNC, "var", -1)
264  {}
265 
266  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) override;
267 
268  const mup::char_type* GetDesc() const override
269  {
270  return "var(m1,m2,..) - variance of each neighborhood";
271  }
272 
273  mup::IToken* Clone() const override
274  {
275  return new var(*this);
276  }
277  };
278 
279 
280 class corr : public mup::ICallback
281  {
282 public:
283  corr():ICallback(mup::cmFUNC, "corr", 2)
284  {}
285 
286  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) override;
287 
288  const mup::char_type* GetDesc() const override
289  {
290  return "corr(m1,m2) - variance of two variables m1 and m2";
291  }
292 
293  mup::IToken* Clone() const override
294  {
295  return new corr(*this);
296  }
297  };
298 
299 
300 class median : public mup::ICallback
301  {
302 public:
303  median():ICallback(mup::cmFUNC, "median", -1)
304  {}
305 
306  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) override;
307 
308  const mup::char_type* GetDesc() const override
309  {
310  return "median(m1,m2,..) - median value of each neighborhood";
311  }
312 
313  mup::IToken* Clone() const override
314  {
315  return new median(*this);
316  }
317  };
318 
319 
320 class maj : public mup::ICallback
321  {
322 public:
323  maj():ICallback(mup::cmFUNC, "maj", -1)
324  {}
325 
326  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) override;
327 
328  const mup::char_type* GetDesc() const override
329  {
330  return "maj(m1,m2,..) - majority value of each neighborhood";
331  }
332 
333  mup::IToken* Clone() const override
334  {
335  return new maj(*this);
336  }
337  };
338 
339 //--------------------------------------------------------------------------------------------------------//
340 class vnorm : public mup::ICallback
341  {
342 public:
343  vnorm():ICallback(mup::cmFUNC, "vnorm", 1)
344  {}
345 
346  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) override;
347 
348  const mup::char_type* GetDesc() const override
349  {
350  return "vnorm(v1) - Norm for a vector : sqrt(sum of squared elements); works also with matrices";
351  }
352 
353  mup::IToken* Clone() const override
354  {
355  return new vnorm(*this);
356  }
357  };
358 
359 class vmin : public mup::ICallback
360  {
361 public:
362  vmin():ICallback(mup::cmFUNC, "vmin", 1)
363  {}
364 
365  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) override;
366 
367  const mup::char_type* GetDesc() const override
368  {
369  return "vmin(m1) - overall minimum";
370  }
371 
372  mup::IToken* Clone() const override
373  {
374  return new vmin(*this);
375  }
376  };
377 
378 
379 class vmax : public mup::ICallback
380  {
381 public:
382  vmax():ICallback(mup::cmFUNC, "vmax", 1)
383  {}
384 
385  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) override;
386 
387  const mup::char_type* GetDesc() const override
388  {
389  return "vmax(m1) - overall maximun";
390  }
391 
392  mup::IToken* Clone() const override
393  {
394  return new vmax(*this);
395  }
396  };
397 
398 
399 class vect2scal : public mup::ICallback
400  {
401 public:
402  vect2scal():ICallback(mup::cmFUNC, "vect2scal", 1)
403  {}
404 
405  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) override;
406 
407  const mup::char_type* GetDesc() const override
408  {
409  return "vect2scal - Convert one dimensional vector to scalar";
410  }
411 
412  mup::IToken* Clone() const override
413  {
414  return new vect2scal(*this);
415  }
416  };
417 
418 
419 
420 class vcos : public mup::ICallback
421  {
422 public:
423  vcos():ICallback(mup::cmFUNC, "vcos", 1)
424  {}
425 
426  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) override;
427 
428  const mup::char_type* GetDesc() const override
429  {
430  return "vcos - Cosinus for noncomplex vectors & matrices";
431  }
432 
433  mup::IToken* Clone() const override
434  {
435  return new vcos(*this);
436  }
437  };
438 
439 
440 class vacos : public mup::ICallback
441  {
442 public:
443  vacos():ICallback(mup::cmFUNC, "vacos", 1)
444  {}
445 
446  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) override;
447 
448  const mup::char_type* GetDesc() const override
449  {
450  return "vacos - Arccosinus for noncomplex vectors & matrices";
451  }
452 
453  mup::IToken* Clone() const override
454  {
455  return new vacos(*this);
456  }
457  };
458 
459 class vsin : public mup::ICallback
460  {
461 public:
462  vsin():ICallback(mup::cmFUNC, "vsin", 1)
463  {}
464 
465  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) override;
466 
467  const mup::char_type* GetDesc() const override
468  {
469  return "vsin - Sinus for noncomplex vectors & matrices";
470  }
471 
472  mup::IToken* Clone() const override
473  {
474  return new vsin(*this);
475  }
476  };
477 
478 class vasin : public mup::ICallback
479  {
480 public:
481  vasin():ICallback(mup::cmFUNC, "vasin", 1)
482  {}
483 
484  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) override;
485 
486  const mup::char_type* GetDesc() const override
487  {
488  return "vasin - Arcsinus for noncomplex vectors & matrices";
489  }
490 
491  mup::IToken* Clone() const override
492  {
493  return new vasin(*this);
494  }
495  };
496 
497 
498 class vtan : public mup::ICallback
499  {
500 public:
501  vtan():ICallback(mup::cmFUNC, "vtan", 1)
502  {}
503 
504  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) override;
505 
506  const mup::char_type* GetDesc() const override
507  {
508  return "vtan - Tangent for noncomplex vectors & matrices";
509  }
510 
511  mup::IToken* Clone() const override
512  {
513  return new vtan(*this);
514  }
515  };
516 
517 
518 class vatan : public mup::ICallback
519  {
520 public:
521  vatan():ICallback(mup::cmFUNC, "vatan", 1)
522  {}
523 
524  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) override;
525 
526  const mup::char_type* GetDesc() const override
527  {
528  return "vatan - Arctangent for noncomplex vectors & matrices";
529  }
530 
531  mup::IToken* Clone() const override
532  {
533  return new vatan(*this);
534  }
535  };
536 
537 
538 class vtanh : public mup::ICallback
539  {
540 public:
541  vtanh():ICallback(mup::cmFUNC, "vtanh", 1)
542  {}
543 
544  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) override;
545 
546  const mup::char_type* GetDesc() const override
547  {
548  return "vtanh - Hyperbolic tangent for noncomplex vectors & matrices";
549  }
550 
551  mup::IToken* Clone() const override
552  {
553  return new vtanh(*this);
554  }
555  };
556 
557 
558 class vsinh : public mup::ICallback
559  {
560 public:
561  vsinh():ICallback(mup::cmFUNC, "vsinh", 1)
562  {}
563 
564  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) override;
565 
566  const mup::char_type* GetDesc() const override
567  {
568  return "vsinh - Hyperbolic sinus for noncomplex vectors & matrices";
569  }
570 
571  mup::IToken* Clone() const override
572  {
573  return new vsinh(*this);
574  }
575  };
576 
577 
578 class vcosh : public mup::ICallback
579  {
580 public:
581  vcosh():ICallback(mup::cmFUNC, "vcosh", 1)
582  {}
583 
584  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) override;
585 
586  const mup::char_type* GetDesc() const override
587  {
588  return "vcosh - Hyperbolic cosinus for noncomplex vectors & matrices";
589  }
590 
591  mup::IToken* Clone() const override
592  {
593  return new vcosh(*this);
594  }
595  };
596 
597 
598 class vlog : public mup::ICallback
599  {
600 public:
601  vlog():ICallback(mup::cmFUNC, "vlog", 1)
602  {}
603 
604  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) override;
605 
606  const mup::char_type* GetDesc() const override
607  {
608  return "vlog - Log for noncomplex vectors & matrices";
609  }
610 
611  mup::IToken* Clone() const override
612  {
613  return new vlog(*this);
614  }
615  };
616 
617 
618 class vlog10 : public mup::ICallback
619  {
620 public:
621  vlog10():ICallback(mup::cmFUNC, "vlog10", 1)
622  {}
623 
624  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) override;
625 
626  const mup::char_type* GetDesc() const override
627  {
628  return "vlog10 - Log10 for noncomplex vectors & matrices";
629  }
630 
631  mup::IToken* Clone() const override
632  {
633  return new vlog10(*this);
634  }
635  };
636 
637 
638 class vabs : public mup::ICallback
639  {
640 public:
641  vabs():ICallback(mup::cmFUNC, "vabs", 1)
642  {}
643 
644  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) override;
645 
646  const mup::char_type* GetDesc() const override
647  {
648  return "vabs - Absolute value for noncomplex vectors & matrices";
649  }
650 
651  mup::IToken* Clone() const override
652  {
653  return new vabs(*this);
654  }
655  };
656 
657 
658 class vexp : public mup::ICallback
659  {
660 public:
661  vexp():ICallback(mup::cmFUNC, "vexp", 1)
662  {}
663 
664  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) override;
665 
666  const mup::char_type* GetDesc() const override
667  {
668  return "vexp - Exponential for noncomplex vectors & matrices";
669  }
670 
671  mup::IToken* Clone() const override
672  {
673  return new vexp(*this);
674  }
675  };
676 
677 
678 class vsqrt : public mup::ICallback
679  {
680 public:
681  vsqrt():ICallback(mup::cmFUNC, "vsqrt", 1)
682  {}
683 
684  void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int itkNotUsed(a_iArgc)) override;
685 
686  const mup::char_type* GetDesc() const override
687  {
688  return "vsqrt - Sqrt for noncomplex vectors & matrices";
689  }
690 
691  mup::IToken* Clone() const override
692  {
693  return new vsqrt(*this);
694  }
695  };
696 
697 
698 }//end namespace otb
699 
700 #endif
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
const mup::char_type * GetDesc() const override
const mup::char_type * GetDesc() const override
const mup::char_type * GetDesc() const override
mup::IToken * Clone() const override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) override
mup::IToken * Clone() const override
mup::IToken * Clone() const override
const mup::char_type * GetDesc() const override
mup::IToken * Clone() const override
mup::IToken * Clone() const override
mup::IToken * Clone() const override
const mup::char_type * GetDesc() const override
mup::IToken * Clone() const override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
mup::IToken * Clone() const override
mup::IToken * Clone() const override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
mup::IToken * Clone() const override
const mup::char_type * GetDesc() const override
mup::IToken * Clone() const override
const mup::char_type * GetDesc() const override
mup::IToken * Clone() const override
mup::IToken * Clone() const override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
mup::IToken * Clone() const override
mup::IToken * Clone() const override
mup::IToken * Clone() const override
const mup::char_type * GetDesc() const override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) override
const mup::char_type * GetDesc() const override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
const mup::char_type * GetDesc() const override
mup::IToken * Clone() const override
const mup::char_type * GetDesc() const override
const mup::char_type * GetDesc() const override
const mup::char_type * GetDesc() const override
const mup::char_type * GetDesc() const override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
const mup::char_type * GetDesc() const override
mup::IToken * Clone() const override
const mup::char_type * GetDesc() const override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
mup::IToken * Clone() const override
mup::IToken * Clone() const override
const mup::char_type * GetDesc() const override
mup::IToken * Clone() const override
const mup::char_type * GetDesc() const override
mup::IToken * Clone() const override
mup::IToken * Clone() const override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) override
mup::IToken * Clone() const override
const mup::char_type * GetDesc() const override
mup::IToken * Clone() const override
const mup::char_type * GetDesc() const override
const mup::char_type * GetDesc() const override
const mup::char_type * GetDesc() const override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
mup::IToken * Clone() const override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
const mup::char_type * GetDesc() const override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
mup::IToken * Clone() const override
mup::IToken * Clone() const override
mup::IToken * Clone() const override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
const mup::char_type * GetDesc() const override
mup::IToken * Clone() const override
const mup::char_type * GetDesc() const override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
const mup::char_type * GetDesc() const override
mup::IToken * Clone() const override
const mup::char_type * GetDesc() const override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
const mup::char_type * GetDesc() const override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) override
mup::IToken * Clone() const override
mup::IToken * Clone() const override
const mup::char_type * GetDesc() const override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int a_iArgc) override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
void Eval(mup::ptr_val_type &ret, const mup::ptr_val_type *a_pArg, int) override
const mup::char_type * GetDesc() const override
const mup::char_type * GetDesc() const override
const mup::char_type * GetDesc() const override
const mup::char_type * GetDesc() const override