Subversion Repositories pentevo

Rev

Blame | Last modification | View Log | Download | RSS feed | ?url?

  1. /* function.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* internal holder for int/float/string                                      */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12. #include "bpemu.h"
  13. #include <string.h>
  14. #include <ctype.h>
  15. #include "nonzstring.h"
  16. #include "strutil.h"
  17. #include "asmdef.h"
  18. #include "errmsg.h"
  19. #include "asmerr.h"
  20. #include "chartrans.h"
  21. #include "asmpars.h"
  22. #include "cpu2phys.h"
  23. #include "function.h"
  24.  
  25. static Boolean FuncSUBSTR(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  26. {
  27.   int cnt = pArgs[0].Contents.str.len - pArgs[1].Contents.Int;
  28.  
  29.   UNUSED(ArgCnt);
  30.   if ((pArgs[2].Contents.Int != 0) && (pArgs[2].Contents.Int < cnt))
  31.     cnt = pArgs[2].Contents.Int;
  32.   if (cnt < 0)
  33.     cnt = 0;
  34.   as_tempres_set_c_str(pResult, "");
  35.   as_nonz_dynstr_append_raw(&pResult->Contents.str, pArgs[0].Contents.str.p_str + pArgs[1].Contents.Int, cnt);
  36.  
  37.   return True;
  38. }
  39.  
  40. static Boolean FuncSTRSTR(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  41. {
  42.   UNUSED(ArgCnt);
  43.  
  44.   as_tempres_set_int(pResult, as_nonz_dynstr_find(&pArgs[0].Contents.str, &pArgs[1].Contents.str));
  45.  
  46.   return True;
  47. }
  48.  
  49. static Boolean FuncCHARFROMSTR(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  50. {
  51.   UNUSED(ArgCnt);
  52.  
  53.   as_tempres_set_int(pResult, ((pArgs[1].Contents.Int >= 0) && ((unsigned)pArgs[1].Contents.Int < pArgs[0].Contents.str.len)) ? pArgs[0].Contents.str.p_str[pArgs[1].Contents.Int] : -1);
  54.  
  55.   return True;
  56. }
  57.  
  58. static Boolean FuncCODEPAGE_VAL(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  59. {
  60.   PTransTable p_table;
  61.  
  62.   UNUSED(ArgCnt);
  63.  
  64.   if (ArgCnt >= 2)
  65.   {
  66.     String name;
  67.  
  68.     as_nonz_dynstr_to_c_str(name, &pArgs[1].Contents.str, sizeof(name));
  69.     p_table = FindCodepage(name, NULL);
  70.     if (!p_table)
  71.     {
  72.       WrXError(ErrNum_UnknownCodepage, name);
  73.       as_tempres_set_int(pResult, 0);
  74.       return True;
  75.     }
  76.   }
  77.   else
  78.     p_table = CurrTransTable;
  79.  
  80.   if (ChkRange(pArgs[0].Contents.Int, 0, 255))
  81.     as_tempres_set_int(pResult, as_chartrans_xlate(p_table->p_table, pArgs[0].Contents.Int));
  82.   else
  83.     as_tempres_set_int(pResult, 0);
  84.   return True;
  85. }
  86.  
  87. static Boolean FuncEXPRTYPE(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  88. {
  89.   UNUSED(ArgCnt);
  90.  
  91.   switch (pArgs[0].Typ)
  92.   {
  93.     case TempInt:
  94.       as_tempres_set_int(pResult, 0);
  95.       break;
  96.     case TempFloat:
  97.       as_tempres_set_int(pResult, 1);
  98.       break;
  99.     case TempString:
  100.       as_tempres_set_int(pResult, 2);
  101.       break;
  102.     default:
  103.       as_tempres_set_int(pResult, -1);
  104.   }
  105.  
  106.   return True;
  107. }
  108.  
  109. /* in Grossbuchstaben wandeln */
  110.  
  111. static Boolean FuncUPSTRING(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  112. {
  113.   char *pRun;
  114.  
  115.   UNUSED(ArgCnt);
  116.  
  117.   as_tempres_set_str(pResult, &pArgs[0].Contents.str);
  118.   for (pRun = pResult->Contents.str.p_str;
  119.        pRun < pResult->Contents.str.p_str + pResult->Contents.str.len;
  120.        pRun++)
  121.     *pRun = as_toupper(*pRun);
  122.  
  123.   return True;
  124. }
  125.  
  126. /* in Kleinbuchstaben wandeln */
  127.  
  128. static Boolean FuncLOWSTRING(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  129. {
  130.   char *pRun;
  131.  
  132.   UNUSED(ArgCnt);
  133.  
  134.   as_tempres_set_str(pResult, &pArgs[0].Contents.str);
  135.   for (pRun = pResult->Contents.str.p_str;
  136.        pRun < pResult->Contents.str.p_str + pResult->Contents.str.len;
  137.        pRun++)
  138.     *pRun = as_tolower(*pRun);
  139.  
  140.   return True;
  141. }
  142.  
  143. /* Laenge ermitteln */
  144.  
  145. static Boolean FuncSTRLEN(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  146. {
  147.   UNUSED(ArgCnt);
  148.  
  149.   as_tempres_set_int(pResult, pArgs[0].Contents.str.len);
  150.  
  151.   return True;
  152. }
  153.  
  154. /* Parser aufrufen */
  155.  
  156. static Boolean FuncVAL(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  157. {
  158.   String Tmp;
  159.  
  160.   UNUSED(ArgCnt);
  161.  
  162.   as_nonz_dynstr_to_c_str(Tmp, &pArgs[0].Contents.str, sizeof(Tmp));
  163.   EvalExpression(Tmp, pResult);
  164.  
  165.   return True;
  166. }
  167.  
  168. static Boolean FuncTOUPPER(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  169. {
  170.   UNUSED(ArgCnt);
  171.  
  172.   if ((pArgs[0].Contents.Int < 0) || (pArgs[0].Contents.Int > 255)) WrError(ErrNum_OverRange);
  173.   else
  174.     as_tempres_set_int(pResult, as_toupper(pArgs[0].Contents.Int));
  175.  
  176.   return True;
  177. }
  178.  
  179. static Boolean FuncTOLOWER(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  180. {
  181.   UNUSED(ArgCnt);
  182.  
  183.   if ((pArgs[0].Contents.Int < 0) || (pArgs[0].Contents.Int > 255)) WrError(ErrNum_OverRange);
  184.   else
  185.     as_tempres_set_int(pResult, as_tolower(pArgs[0].Contents.Int));
  186.  
  187.   return True;
  188. }
  189.  
  190. static Boolean FuncBITCNT(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  191. {
  192.   int z;
  193.   LargeInt in = pArgs[0].Contents.Int, out = 0;
  194.  
  195.   UNUSED(ArgCnt);
  196.  
  197.   out = 0;
  198.   for (z = 0; z < LARGEBITS; z++)
  199.   {
  200.     out += (in & 1);
  201.     in >>= 1;
  202.   }
  203.   as_tempres_set_int(pResult, out);
  204.  
  205.   return True;
  206. }
  207.  
  208. static Boolean FuncFIRSTBIT(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  209. {
  210.   LargeInt in = pArgs[0].Contents.Int;
  211.   int out;
  212.  
  213.   UNUSED(ArgCnt);
  214.  
  215.   out = 0;
  216.   do
  217.   {
  218.     if (!Odd(in))
  219.       out++;
  220.     in >>= 1;
  221.   }
  222.   while ((out < LARGEBITS) && !Odd(in));
  223.   as_tempres_set_int(pResult, (out >= LARGEBITS) ? -1 : out);
  224.  
  225.   return True;
  226. }
  227.  
  228. static Boolean FuncLASTBIT(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  229. {
  230.   int z, out;
  231.   LargeInt in = pArgs[0].Contents.Int;
  232.  
  233.   UNUSED(ArgCnt);
  234.  
  235.   out = -1;
  236.   for (z = 0; z < LARGEBITS; z++)
  237.   {
  238.     if (Odd(in))
  239.       out = z;
  240.     in >>= 1;
  241.   }
  242.   as_tempres_set_int(pResult, out);
  243.  
  244.   return True;
  245. }
  246.  
  247. static Boolean FuncBITPOS(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  248. {
  249.   LargeInt out;
  250.  
  251.   UNUSED(ArgCnt);
  252.  
  253.   pResult->Typ = TempInt;
  254.   if (!SingleBit(pArgs[0].Contents.Int, &out))
  255.   {
  256.     out = -1;
  257.     WrError(ErrNum_NotOneBit);
  258.   }
  259.   as_tempres_set_int(pResult, out);
  260.  
  261.   return True;
  262. }
  263.  
  264. static Boolean FuncABS(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  265. {
  266.   UNUSED(ArgCnt);
  267.  
  268.   switch (pArgs[0].Typ)
  269.   {
  270.     case TempInt:
  271.       as_tempres_set_int(pResult, (pArgs[0].Contents.Int  < 0) ? -pArgs[0].Contents.Int : pArgs[0].Contents.Int);
  272.       break;
  273.     case TempFloat:
  274.       as_tempres_set_float(pResult, fabs(pArgs[0].Contents.Float));
  275.       break;
  276.     default:
  277.       pResult->Typ = TempNone;
  278.   }
  279.  
  280.   return True;
  281. }
  282.  
  283. static Boolean FuncSGN(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  284. {
  285.   UNUSED(ArgCnt);
  286.  
  287.   switch (pArgs[0].Typ)
  288.   {
  289.     case TempInt:
  290.       as_tempres_set_int(pResult, (pArgs[0].Contents.Int < 0) ? -1 : ((pArgs[0].Contents.Int > 0) ? 1 : 0));
  291.       break;
  292.     case TempFloat:
  293.       as_tempres_set_int(pResult, (pArgs[0].Contents.Float < 0) ? -1 : ((pArgs[0].Contents.Float > 0) ? 1 : 0));
  294.       break;
  295.     default:
  296.       as_tempres_set_none(pResult);
  297.   }
  298.  
  299.   return True;
  300. }
  301.  
  302. static Boolean FuncINT(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  303. {
  304.   UNUSED(ArgCnt);
  305.  
  306.   if (fabs(pArgs[0].Contents.Float) > IntTypeDefs[LargeSIntType].Max)
  307.   {
  308.     as_tempres_set_none(pResult);
  309.     WrError(ErrNum_OverRange);
  310.   }
  311.   else
  312.     as_tempres_set_int(pResult, (LargeInt) floor(pArgs[0].Contents.Float));
  313.  
  314.   return True;
  315. }
  316.  
  317. static Boolean FuncSQRT(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  318. {
  319.   UNUSED(ArgCnt);
  320.  
  321.   if (pArgs[0].Contents.Float < 0)
  322.   {
  323.     as_tempres_set_none(pResult);
  324.     WrError(ErrNum_InvFuncArg);
  325.   }
  326.   else
  327.     as_tempres_set_float(pResult, sqrt(pArgs[0].Contents.Float));
  328.  
  329.   return True;
  330. }
  331.  
  332. /* trigonometrische Funktionen */
  333.  
  334. static Boolean FuncSIN(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  335. {
  336.   UNUSED(ArgCnt);
  337.  
  338.   as_tempres_set_float(pResult, sin(pArgs[0].Contents.Float));
  339.  
  340.   return True;
  341. }
  342.  
  343. static Boolean FuncCOS(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  344. {
  345.   UNUSED(ArgCnt);
  346.  
  347.   as_tempres_set_float(pResult, cos(pArgs[0].Contents.Float));
  348.  
  349.   return True;
  350. }
  351.  
  352. static Boolean FuncTAN(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  353. {
  354.   UNUSED(ArgCnt);
  355.  
  356.   if (cos(pArgs[0].Contents.Float) == 0.0)
  357.   {
  358.     as_tempres_set_none(pResult);
  359.     WrError(ErrNum_InvFuncArg);
  360.   }
  361.   else
  362.     as_tempres_set_float(pResult, tan(pArgs[0].Contents.Float));
  363.  
  364.   return True;
  365. }
  366.  
  367. static Boolean FuncCOT(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  368. {
  369.   Double FVal = sin(pArgs[0].Contents.Float);
  370.   UNUSED(ArgCnt);
  371.  
  372.   if (FVal == 0.0)
  373.   {
  374.     as_tempres_set_none(pResult);
  375.     WrError(ErrNum_InvFuncArg);
  376.   }
  377.   else
  378.     as_tempres_set_float(pResult, cos(pArgs[0].Contents.Float) / FVal);
  379.  
  380.   return True;
  381. }
  382.  
  383. /* inverse trigonometrische Funktionen */
  384.  
  385. static Boolean FuncASIN(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  386. {
  387.   UNUSED(ArgCnt);
  388.  
  389.   if (fabs(pArgs[0].Contents.Float) > 1)
  390.   {
  391.     as_tempres_set_none(pResult);
  392.     WrError(ErrNum_InvFuncArg);
  393.   }
  394.   else
  395.     as_tempres_set_float(pResult, asin(pArgs[0].Contents.Float));
  396.  
  397.   return True;
  398. }
  399.  
  400. static Boolean FuncACOS(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  401. {
  402.   UNUSED(ArgCnt);
  403.  
  404.   if (fabs(pArgs[0].Contents.Float) > 1)
  405.   {
  406.     as_tempres_set_none(pResult);
  407.     WrError(ErrNum_InvFuncArg);
  408.   }
  409.   else
  410.     as_tempres_set_float(pResult, acos(pArgs[0].Contents.Float));
  411.  
  412.   return True;
  413. }
  414.  
  415. static Boolean FuncATAN(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  416. {
  417.   UNUSED(ArgCnt);
  418.  
  419.   as_tempres_set_float(pResult, atan(pArgs[0].Contents.Float));
  420.  
  421.   return True;
  422. }
  423.  
  424. static Boolean FuncACOT(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  425. {
  426.   UNUSED(ArgCnt);
  427.  
  428.   as_tempres_set_float(pResult, M_PI / 2 - atan(pArgs[0].Contents.Float));
  429.  
  430.   return True;
  431. }
  432.  
  433. static Boolean FuncEXP(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  434. {
  435.   UNUSED(ArgCnt);
  436.  
  437.   if (pArgs[0].Contents.Float > 709)
  438.   {
  439.     as_tempres_set_none(pResult);
  440.     WrError(ErrNum_FloatOverflow);
  441.   }
  442.   else
  443.     as_tempres_set_float(pResult, exp(pArgs[0].Contents.Float));
  444.  
  445.   return True;
  446. }
  447.  
  448. static Boolean FuncALOG(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  449. {
  450.   UNUSED(ArgCnt);
  451.  
  452.   if (pArgs[0].Contents.Float > 308)
  453.   {
  454.     as_tempres_set_none(pResult);
  455.     WrError(ErrNum_FloatOverflow);
  456.   }
  457.   else
  458.     as_tempres_set_float(pResult, exp(pArgs[0].Contents.Float * log(10.0)));
  459.  
  460.   return True;
  461. }
  462.  
  463. static Boolean FuncALD(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  464. {
  465.   UNUSED(ArgCnt);
  466.  
  467.   if (pArgs[0].Contents.Float > 1022)
  468.   {
  469.     as_tempres_set_none(pResult);
  470.     WrError(ErrNum_FloatOverflow);
  471.   }
  472.   else
  473.     as_tempres_set_float(pResult, exp(pArgs[0].Contents.Float * log(2.0)));
  474.  
  475.   return True;
  476. }
  477.  
  478. static Boolean FuncSINH(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  479. {
  480.   UNUSED(ArgCnt);
  481.  
  482.   if (pArgs[0].Contents.Float > 709)
  483.   {
  484.     as_tempres_set_none(pResult);
  485.     WrError(ErrNum_FloatOverflow);
  486.   }
  487.   else
  488.     as_tempres_set_float(pResult, sinh(pArgs[0].Contents.Float));
  489.  
  490.   return True;
  491. }
  492.  
  493. static Boolean FuncCOSH(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  494. {
  495.   UNUSED(ArgCnt);
  496.  
  497.   if (pArgs[0].Contents.Float > 709)
  498.   {
  499.     as_tempres_set_none(pResult);
  500.     WrError(ErrNum_FloatOverflow);
  501.   }
  502.   else
  503.     as_tempres_set_float(pResult, cosh(pArgs[0].Contents.Float));
  504.  
  505.   return True;
  506. }
  507.  
  508. static Boolean FuncTANH(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  509. {
  510.   UNUSED(ArgCnt);
  511.  
  512.   if (pArgs[0].Contents.Float > 709)
  513.   {
  514.     as_tempres_set_none(pResult);
  515.     WrError(ErrNum_FloatOverflow);
  516.   }
  517.   else
  518.     as_tempres_set_float(pResult, tanh(pArgs[0].Contents.Float));
  519.  
  520.   return True;
  521. }
  522.  
  523. static Boolean FuncCOTH(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  524. {
  525.   Double FVal;
  526.  
  527.   UNUSED(ArgCnt);
  528.  
  529.   if (pArgs[0].Contents.Float > 709)
  530.   {
  531.     as_tempres_set_none(pResult);
  532.     WrError(ErrNum_FloatOverflow);
  533.   }
  534.   else if ((FVal = tanh(pArgs[0].Contents.Float)) == 0.0)
  535.   {
  536.     as_tempres_set_none(pResult);
  537.     WrError(ErrNum_InvFuncArg);
  538.   }
  539.   else
  540.     as_tempres_set_float(pResult, pResult->Contents.Float = 1.0 / FVal);
  541.  
  542.   return True;
  543. }
  544.  
  545. /* logarithmische & inverse hyperbolische Funktionen */
  546.  
  547. static Boolean FuncLN(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  548. {
  549.   UNUSED(ArgCnt);
  550.  
  551.   if (pArgs[0].Contents.Float <= 0)
  552.   {
  553.     as_tempres_set_none(pResult);
  554.     WrError(ErrNum_InvFuncArg);
  555.   }
  556.   else
  557.     as_tempres_set_float(pResult, log(pArgs[0].Contents.Float));
  558.  
  559.   return True;
  560. }
  561.  
  562. static Boolean FuncLOG(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  563. {
  564.   UNUSED(ArgCnt);
  565.  
  566.   if (pArgs[0].Contents.Float <= 0)
  567.   {
  568.     as_tempres_set_none(pResult);
  569.     WrError(ErrNum_InvFuncArg);
  570.   }
  571.   else
  572.     as_tempres_set_float(pResult, log10(pArgs[0].Contents.Float));
  573.  
  574.   return True;
  575. }
  576.  
  577. static Boolean FuncLD(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  578. {
  579.   UNUSED(ArgCnt);
  580.  
  581.   if (pArgs[0].Contents.Float <= 0)
  582.   {
  583.     as_tempres_set_none(pResult);
  584.     WrError(ErrNum_InvFuncArg);
  585.   }
  586.   else
  587.     as_tempres_set_float(pResult, log(pArgs[0].Contents.Float) / log(2.0));
  588.  
  589.   return True;
  590. }
  591.  
  592. static Boolean FuncASINH(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  593. {
  594.   UNUSED(ArgCnt);
  595.  
  596.   as_tempres_set_float(pResult, log(pArgs[0].Contents.Float+sqrt(pArgs[0].Contents.Float * pArgs[0].Contents.Float + 1)));
  597.  
  598.   return True;
  599. }
  600.  
  601. static Boolean FuncACOSH(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  602. {
  603.   UNUSED(ArgCnt);
  604.  
  605.   if (pArgs[0].Contents.Float < 1)
  606.   {
  607.     as_tempres_set_none(pResult);
  608.     WrError(ErrNum_FloatOverflow);
  609.   }
  610.   else
  611.     as_tempres_set_float(pResult, log(pArgs[0].Contents.Float+sqrt(pArgs[0].Contents.Float * pArgs[0].Contents.Float - 1)));
  612.  
  613.   return True;
  614. }
  615.  
  616. static Boolean FuncATANH(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  617. {
  618.   UNUSED(ArgCnt);
  619.  
  620.   if (fabs(pArgs[0].Contents.Float) >= 1)
  621.   {
  622.     as_tempres_set_none(pResult);
  623.     WrError(ErrNum_FloatOverflow);
  624.   }
  625.   else
  626.     as_tempres_set_float(pResult, 0.5 * log((1 + pArgs[0].Contents.Float) / (1 - pArgs[0].Contents.Float)));
  627.  
  628.   return True;
  629. }
  630.  
  631. static Boolean FuncACOTH(TempResult *pResult, const TempResult *pArgs, unsigned ArgCnt)
  632. {
  633.   UNUSED(ArgCnt);
  634.  
  635.   if (fabs(pArgs[0].Contents.Float) <= 1)
  636.   {
  637.     as_tempres_set_none(pResult);
  638.     WrError(ErrNum_FloatOverflow);
  639.   }
  640.   else
  641.     as_tempres_set_float(pResult, 0.5 * log((pArgs[0].Contents.Float + 1) / (pArgs[0].Contents.Float - 1)));
  642.  
  643.   return True;
  644. }
  645.  
  646. #define TempAll (TempInt | TempFloat | TempString)
  647.  
  648. static const tFunction Functions[] =
  649. {
  650.   { "SUBSTR"     , 3, 3, { TempString              , TempInt        , TempInt        }, FuncSUBSTR      },
  651.   { "STRSTR"     , 2, 2, { TempString              , TempString     , 0              }, FuncSTRSTR      },
  652.   { "CHARFROMSTR", 2, 2, { TempString              , TempInt        , 0              }, FuncCHARFROMSTR },
  653.   { "CODEPAGE_VAL",1, 2, { TempInt                 , TempString     , 0              }, FuncCODEPAGE_VAL},
  654.   { "EXPRTYPE"   , 1, 1, { TempAll                 , 0              , 0              }, FuncEXPRTYPE    },
  655.   { "UPSTRING"   , 1, 1, { TempString              , 0              , 0              }, FuncUPSTRING    },
  656.   { "LOWSTRING"  , 1, 1, { TempString              , 0              , 0              }, FuncLOWSTRING   },
  657.   { "STRLEN"     , 1, 1, { TempString              , 0              , 0              }, FuncSTRLEN      },
  658.   { "VAL"        , 1, 1, { TempString              , 0              , 0              }, FuncVAL         },
  659.   { "TOUPPER"    , 1, 1, { TempInt                 , 0              , 0              }, FuncTOUPPER     },
  660.   { "TOLOWER"    , 1, 1, { TempInt                 , 0              , 0              }, FuncTOLOWER     },
  661.   { "BITCNT"     , 1, 1, { TempInt                 , 0              , 0              }, FuncBITCNT      },
  662.   { "FIRSTBIT"   , 1, 1, { TempInt                 , 0              , 0              }, FuncFIRSTBIT    },
  663.   { "LASTBIT"    , 1, 1, { TempInt                 , 0              , 0              }, FuncLASTBIT     },
  664.   { "BITPOS"     , 1, 1, { TempInt                 , 0              , 0              }, FuncBITPOS      },
  665.   { "ABS"        , 1, 1, { TempInt | TempFloat     , 0              , 0              }, FuncABS         },
  666.   { "SGN"        , 1, 1, { TempInt | TempFloat     , 0              , 0              }, FuncSGN         },
  667.   { "INT"        , 1, 1, { TempFloat               , 0              , 0              }, FuncINT         },
  668.   { "SQRT"       , 1, 1, { TempFloat               , 0              , 0              }, FuncSQRT        },
  669.   { "SIN"        , 1, 1, { TempFloat               , 0              , 0              }, FuncSIN         },
  670.   { "COS"        , 1, 1, { TempFloat               , 0              , 0              }, FuncCOS         },
  671.   { "TAN"        , 1, 1, { TempFloat               , 0              , 0              }, FuncTAN         },
  672.   { "COT"        , 1, 1, { TempFloat               , 0              , 0              }, FuncCOT         },
  673.   { "ASIN"       , 1, 1, { TempFloat               , 0              , 0              }, FuncASIN        },
  674.   { "ACOS"       , 1, 1, { TempFloat               , 0              , 0              }, FuncACOS        },
  675.   { "ATAN"       , 1, 1, { TempFloat               , 0              , 0              }, FuncATAN        },
  676.   { "ACOT"       , 1, 1, { TempFloat               , 0              , 0              }, FuncACOT        },
  677.   { "EXP"        , 1, 1, { TempFloat               , 0              , 0              }, FuncEXP         },
  678.   { "ALOG"       , 1, 1, { TempFloat               , 0              , 0              }, FuncALOG        },
  679.   { "ALD"        , 1, 1, { TempFloat               , 0              , 0              }, FuncALD         },
  680.   { "SINH"       , 1, 1, { TempFloat               , 0              , 0              }, FuncSINH        },
  681.   { "COSH"       , 1, 1, { TempFloat               , 0              , 0              }, FuncCOSH        },
  682.   { "TANH"       , 1, 1, { TempFloat               , 0              , 0              }, FuncTANH        },
  683.   { "COTH"       , 1, 1, { TempFloat               , 0              , 0              }, FuncCOTH        },
  684.   { "LN"         , 1, 1, { TempFloat               , 0              , 0              }, FuncLN          },
  685.   { "LOG"        , 1, 1, { TempFloat               , 0              , 0              }, FuncLOG         },
  686.   { "LD"         , 1, 1, { TempFloat               , 0              , 0              }, FuncLD          },
  687.   { "ASINH"      , 1, 1, { TempFloat               , 0              , 0              }, FuncASINH       },
  688.   { "ACOSH"      , 1, 1, { TempFloat               , 0              , 0              }, FuncACOSH       },
  689.   { "ATANH"      , 1, 1, { TempFloat               , 0              , 0              }, FuncATANH       },
  690.   { "ACOTH"      , 1, 1, { TempFloat               , 0              , 0              }, FuncACOTH       },
  691.   { "PHYS2CPU"   , 1, 1, { TempInt                 , 0              , 0              }, fnc_phys_2_cpu  },
  692.   { "CPU2PHYS"   , 1, 1, { TempInt                 , 0              , 0              }, fnc_cpu_2_phys  },
  693.   { NULL         , 0, 0, { 0                            , 0              , 0              }, NULL            }
  694. };
  695.  
  696. /*!------------------------------------------------------------------------
  697.  * \fn     tFunction *function_find(const char *p_name)
  698.  * \brief  look up built-in function
  699.  * \param  p_name function name
  700.  * \return retrieved function or NULL if not found
  701.  * ------------------------------------------------------------------------ */
  702.  
  703. const tFunction *function_find(const char *p_name)
  704. {
  705.   const tFunction *p_run;
  706.  
  707.   for (p_run = Functions; p_run->pName; p_run++)
  708.     if (!strcmp(p_name, p_run->pName))
  709.       return p_run;
  710.   return NULL;
  711. }
  712.