home *** CD-ROM | disk | FTP | other *** search
/ Sams Cobol 24 Hours / Sams_Cobol_24_Hours.iso / Cobol32 / CRW / 32BIT / DISK6 / UFLSAMP2.C_ / UFLSAMP2.C
C/C++ Source or Header  |  1995-08-29  |  35KB  |  1,066 lines
  1. // file UFLSamp2.c
  2. // Rex Benning 92 Dec 28
  3. // This file is a sample of some user defined functions,
  4. // to be used for debugging and as a template for real
  5. // functions.
  6.  
  7. #include <Windows.h>
  8. #include <UFDll.h>
  9. #include "UFMain.h"
  10. #include "UFUser.h"
  11. #include "UFJob.h"
  12.  
  13. #include <StdLib.h>
  14.  
  15. // #define DEBUG_TOPN
  16. // #define DEBUG_INSERT
  17.  
  18. #define MaxN 10
  19.  
  20.  
  21. ExternC UFError FAR _export PASCAL TopNStart (UFParamBlock * ParamBlock);
  22. ExternC UFError FAR _export PASCAL TopNStore (UFParamBlock * ParamBlock);
  23. ExternC UFError FAR _export PASCAL TopNGet (UFParamBlock * ParamBlock);
  24.  
  25. ExternC UFError FAR _export PASCAL TestErrorReturn (UFParamBlock * ParamBlock);
  26. ExternC UFError FAR _export PASCAL TestReplString (UFParamBlock * ParamBlock);
  27. ExternC UFError FAR _export PASCAL TestReplStringRetSize (UFMemCalcBlock * ParamBlock);
  28. ExternC UFError FAR _export PASCAL TestReplChars (UFParamBlock * ParamBlock);
  29. ExternC UFError FAR _export PASCAL TestTwoStrings (UFParamBlock * ParamBlock);
  30. ExternC UFError FAR _export PASCAL TestNumberArray (UFParamBlock * ParamBlock);
  31. ExternC UFError FAR _export PASCAL TestCurrencyArray (UFParamBlock * ParamBlock);
  32. ExternC UFError FAR _export PASCAL TestDateArray (UFParamBlock * ParamBlock);
  33. ExternC UFError FAR _export PASCAL UFMakeNumberRange (UFParamBlock * ParamBlock);
  34. ExternC UFError FAR _export PASCAL UFMakeDateRange (UFParamBlock * ParamBlock);
  35. ExternC UFError FAR _export PASCAL UFSumNumberArray (UFParamBlock * ParamBlock);
  36. ExternC UFError FAR _export PASCAL UFAvgNumberArray (UFParamBlock * ParamBlock);
  37. ExternC UFError FAR _export PASCAL UFStringLength (UFParamBlock * ParamBlock);
  38. ExternC UFError FAR _export PASCAL UFArrayMax (UFParamBlock * ParamBlock);
  39. ExternC UFError FAR _export PASCAL TestStringArray (UFParamBlock * ParamBlock);
  40. ExternC UFError FAR _export PASCAL TestStringArrayLength (UFMemCalcBlock * ParamBlock);
  41. ExternC UFError FAR _export PASCAL UFSumCurrencyArray (UFParamBlock * ParamBlock);
  42. ExternC UFError FAR _export PASCAL UFSum10Numbers (UFParamBlock * ParamBlock);
  43. ExternC UFError FAR _export PASCAL UFConcat10Str (UFParamBlock * ParamBlock);
  44. ExternC UFError FAR _export PASCAL UFConcat10StrLengths (UFMemCalcBlock * ParamBlock);
  45. ExternC UFError FAR _export PASCAL UFTestErrors (UFParamBlock * ParamBlock);
  46. ExternC UFError FAR _export PASCAL UFSumStringLengths (UFParamBlock * ParamBlock);
  47. ExternC UFError FAR _export PASCAL UFArrayElementsInRange (UFParamBlock * ParamBlock);
  48. ExternC UFError FAR _export PASCAL UFStringSubstitutions (UFParamBlock * ParamBlock);
  49. ExternC UFError FAR _export PASCAL UFStringSubMemCalc (UFMemCalcBlock * ParamBlock);
  50. ExternC UFError FAR _export PASCAL UFMakeNumberArray (UFParamBlock * ParamBlock);
  51. ExternC UFError FAR _export PASCAL UFNumberArrayLength (UFMemCalcBlock * ParamBlock);
  52. ExternC UFError FAR _export PASCAL UFMakeStringArray (UFParamBlock * ParamBlock);
  53. ExternC UFError FAR _export PASCAL UFStringArrayLength (UFMemCalcBlock * ParamBlock);
  54. ExternC UFError FAR _export PASCAL UFMakeDateArray (UFParamBlock * ParamBlock);
  55. ExternC UFError FAR _export PASCAL UFDateArrayLength (UFMemCalcBlock * ParamBlock);
  56. ExternC UFError FAR _export PASCAL UFMakeCurrencyArray (UFParamBlock * ParamBlock);
  57. ExternC UFError FAR _export PASCAL UFCurrencyArrayLength (UFMemCalcBlock * ParamBlock);
  58. ExternC UFError FAR _export PASCAL UFMakeStringRange (UFParamBlock * ParamBlock);
  59. ExternC UFError FAR _export PASCAL MakeStringRangeFromArray (UFParamBlock * ParamBlock);
  60.  
  61.  
  62.  
  63.  
  64.  
  65. UFFunctionDefStrings  FunctionDefStrings [] =
  66. {
  67.         {"Number TopNStart (Number)", TopNStart},
  68.         {"Number TopNStore (Number)", TopNStore},
  69.         {"Number TopNGet   (Number)", TopNGet},
  70.  
  71.         {"String TestReplString (String, Number)",TestReplString, TestReplStringRetSize},
  72.         {"String TestReplChars (String, Number)", TestReplChars, TestReplStringRetSize},
  73.         {"Number TestNumberArray (Array(Number), Number)", TestNumberArray, NULL},
  74.         {"Currency TestCurrencyArray ( Array  ( Currency ), Number)", TestCurrencyArray, NULL},
  75.         {"Date TestDateArray(Array(Date),Number)", TestDateArray, NULL},
  76.         {"Range (Number) UFMakeNumberRange(Number, Number)", UFMakeNumberRange, NULL},
  77.         {"Range ( Date ) UFMakeDateRange ( Date , Date)", UFMakeDateRange, NULL},
  78.         {"Number UFSumNumberArray (Array (Number))", UFSumNumberArray, NULL},
  79.         {"Number UFAvgNumberArray (Array (Number))", UFAvgNumberArray, NULL},
  80.         {"Number UFStringLength (String)", UFStringLength, NULL},
  81.         {"Number UFArrayMax (  Array (Number))", UFArrayMax, NULL},
  82.         {"  String TestStringArray(Array(String),Number)", TestStringArray, TestStringArrayLength},
  83.         {"  Currency UFSumCurrencyArray (Array(Currency))", UFSumCurrencyArray, NULL},
  84.         {"Number UFSum10Numbers (number,number,number,number,number,number,number,number,number,number)",
  85.                  UFSum10Numbers, NULL},
  86.         {"String UFConcat10Str(string,string,string,string,string,string,string,string,string,string)",
  87.                  UFConcat10Str, UFConcat10StrLengths},
  88.         {"Number UFTestErrors( Number)", UFTestErrors, NULL},
  89.         {"  Number UFSumStringLengths (Array(String))", UFSumStringLengths, NULL},
  90.         {"Boolean UFArrayElementsInRange (Array (Number=>Currency), Range (Number=>Currency), Number)",
  91.                   UFArrayElementsInRange, NULL},
  92.         {"String UFStringSubstitutions (String, Array(String))", UFStringSubstitutions, UFStringSubMemCalc},
  93.         {"Array (Number) UFMakeNumberArray (Number, Number, Number, Number)", UFMakeNumberArray, UFNumberArrayLength},
  94.         {"Array (String) UFMakeStringArray (String, String, String, String)", UFMakeStringArray, UFStringArrayLength},
  95.         {"Array (Date) UFMakeDateArray (Date, Date)", UFMakeDateArray, UFDateArrayLength},
  96.         {"Array (Currency) UFMakeCurrencyArray (Currency, Currency, Currency, Currency, Currency, Currency)", UFMakeCurrencyArray, UFCurrencyArrayLength},
  97.         {"Range (String) UFMakeStringRange(String, String)", UFMakeStringRange, NULL},
  98.         {"Range (String) MakeStringRangeFromArray (Array (String), Number, Number)", MakeStringRangeFromArray, NULL},
  99.         {NULL, NULL, NULL}
  100. };
  101.  
  102.  
  103.  
  104. UFFunctionTemplates FunctionTemplates [] =
  105. {
  106.        {"TopNStart (!)"},
  107.        {"TopNStore (!)"},
  108.        {"TopNGet (!)"},
  109.  
  110.        {"TestReplString (!, )"},
  111.        {"TestReplChars (!, )"},
  112.        {"TestNumberArray (!, )"},
  113.        {"TestCurrencyArray (!, )"},
  114.        {"TestDateArray (!, )"},
  115.        {"UFMakeNumberRange (!, )"},
  116.        {"UFMakeDateRange (!, )"},
  117.        {"UFSumNumberArray (!)"},
  118.        {"UFAvgNumberArray (!)"},
  119.        {"UFStringLength (!)"},
  120.        {"UFArrayMax (!)"},
  121.        {"TestStringArray (!, )"},
  122.        {"UFSumCurrencyArray (!)"},
  123.        {"UFSum10Numbers (!,,,,,,,,,)"},
  124.        {"UFConcat10Str (!,,,,,,,,,)"},
  125.        {"UFTestErrors (!)"},
  126.        {"UFSumStringLengths (!)"},
  127.        {"UFArrayElementsInRange (!, , )"},
  128.        {"UFStringSubstitutions (!, )"},
  129.        {"UFMakeNumberArray (!,,,)"},
  130.        {"UFMakeStringArray (!,,,)"},
  131.        {"UFMakeDateArray (!,)"},
  132.        {"UFMakeCurrencyArray (!,,,,,)"},
  133.        {"UFMakeStringRange (!,)"},
  134.        {"MakeStringRangeFromArray (!,,)"},
  135.        {NULL}
  136. };
  137.  
  138.  
  139.  
  140. UFFunctionExamples FunctionExamples [] =
  141. {
  142.        {"\tTopNStart (#values)"},
  143.        {"\tTopNStore (number)"},
  144.        {"\tTopNGet (value#)"},
  145.  
  146.        {"\tTestReplString (String, Number)"},
  147.        {"\tTestReplChars (String, Number)"},
  148.        {"\tTestNumberArray (NumberArray, Number)"},
  149.        {"\tTestCurrencyArray (CurrencyArray, Number)"},
  150.        {"\tTestDateArray (DateArray, Number)"},
  151.        {"\tUFMakeNumberRange (StartNumber, EndNumber)"},
  152.        {"\tUFMakeDateRange (StartDate, EndDate)"},
  153.        {"\tUFSumNumberArray (NumberArray)"},
  154.        {"\tUFAvgNumberArray (NumberArray)"},
  155.        {"\tUFStringLength (String)"},
  156.        {"\tUFArrayMax (NumberArray)"},
  157.        {"\tTestStringArray (StringArray, Number)"},
  158.        {"\tUFSumCurrencyArray (CurrencyArray)"},
  159.        {"\tUFSum10Numbers (Number,Number,Number ... )"},
  160.        {"\tUFConcat10Str (String,String,String ... )"},
  161.        {"\tUFTestErrors (ErrorNumber)"},
  162.        {"\tUFSumStringLengths (StringArray)"},
  163.        {"\tUFArrayElementsInRange (CurrencyOrNumber Array, CurrencyOrNumber Range, Count)"},
  164.        {"\tUFStringSubstitutions (String, StringArray)"},
  165.        {"\tUFMakeNumberArray (Number, Number, Number, Number)"},
  166.        {"\tUFMakeStringArray (String, String, String, String)"},
  167.        {"\tUFMakeDateArray (Date, Date)"},
  168.        {"\tUFMakeCurrencyArray (Currency, Currency, Currency, Currency, Currency, Currency)"},
  169.        {"\tUFMakeStringRange (String, String)"},
  170.        {"\tMakeStringRangeFromArray (StringArray, Number, Number)"},
  171.        {NULL}
  172. };
  173.  
  174.  
  175.  
  176. #define ERR_NOUTOFRANGE     7
  177. #define ERR_INDEXOUTOFRANGE 8
  178.  
  179. char *ErrorTable [] =
  180. {
  181.     "Error Message number zero",
  182.     "Null String Found",
  183.     "Parameter seems to have disappeared",
  184.     "Error Message number three",
  185.     "Error Message number four",
  186.     "Last Error Message",
  187.     "Invalid error number",
  188.  
  189.     "N must be between 1 and 10.",
  190.     "The index must be between 1 and the number of values specified"
  191. };
  192.  
  193. void InitJob (struct JobInfo *jobInfo)
  194. {
  195. }
  196.  
  197. void TermJob (struct JobInfo *jobInfo)
  198. {
  199.     if (jobInfo->data != 0)
  200.         free (jobInfo->data);
  201. }
  202.  
  203. /*
  204. ** The TopN* functions
  205. */
  206.  
  207. // the structure we use to store the top N values
  208. struct TopN
  209. {
  210.     UFTInt16u nMax,    // the N
  211.               nUsed;   // the actual number of data stored
  212.  
  213.     UFTNumber values [1];
  214. };
  215.  
  216. ExternC UFError FAR _export PASCAL TopNStart (UFParamBlock * ParamBlock)
  217. {
  218.     // set up to store numbers
  219.     struct JobInfo *jobInfo;
  220.  
  221.     jobInfo = FindJobInfo (ParamBlock->JobId);
  222.  
  223.     if (jobInfo != 0 && jobInfo->data == 0)
  224.     {
  225.         UFParamListElement * ParamPtr;
  226.         UFTInt16s N;
  227.         struct TopN *topN;
  228.  
  229.         ParamPtr = GetParam (ParamBlock, 1);
  230.         if (ParamPtr == NULL)
  231.             return UFNotEnoughParameters;
  232.  
  233.         N = ParamPtr->Parameter.ParamNumber / UFNumberScalingFactor;
  234.  
  235. #if defined (DEBUG_TOPN)
  236.         {
  237.             char buffer [80];
  238.             sprintf (buffer, "parameter 1: %g (%d)",
  239.                              ParamPtr->Parameter.ParamNumber,
  240.                              N);
  241.             MessageBox (0, buffer, "CRSampl1", MB_OK);
  242.         }
  243. #endif
  244.  
  245.         if (N <= 0 || N > MaxN)
  246.         {
  247.             ParamBlock->ReturnValue.UFReturnUserError = ERR_NOUTOFRANGE;
  248.             return UFUserError;
  249.         }
  250.  
  251.         topN = malloc (sizeof (struct TopN) + (N - 1) * sizeof (UFTNumber));
  252.  
  253.         if (topN == 0)
  254.             return UFNoMemory;
  255.  
  256.         topN->nMax = N;
  257.         topN->nUsed = 0;
  258.  
  259.         jobInfo->data = topN;
  260.  
  261.         ParamBlock->ReturnValue.ReturnNumber = N * UFNumberScalingFactor;
  262.     }
  263.     else
  264.         ParamBlock->ReturnValue.ReturnNumber = 0;
  265.  
  266.     return UFNoError;
  267. }
  268.  
  269. static void insertDatum (struct TopN *topN, UFTNumber datum)
  270. {
  271.     UFTInt16u index;
  272.  
  273. #if defined (DEBUG_INSERT)
  274.     char buffer [80];
  275.     sprintf (buffer, "starting insert\n"
  276.                      "nUsed: %d, nMax: %d, datum: %g",
  277.                      topN->nUsed,
  278.                      topN->nMax,
  279.                      datum);
  280.     MessageBox (0, buffer, "CRSampl1", MB_OK);
  281. #endif
  282.  
  283.     for (index = 0; index < topN->nUsed; index++)
  284.     {
  285.         if (topN->values [index] < datum)
  286.             break;
  287.         else if (topN->values [index] == datum)
  288.             // don't store duplicates
  289.             return;
  290.     }
  291.  
  292. #if defined (DEBUG_INSERT)
  293.     sprintf (buffer, "after search\n"
  294.                      "index: %d",
  295.                      index);
  296.     MessageBox (0, buffer, "CRSampl1", MB_OK);
  297. #endif
  298.  
  299.     if (index < topN->nMax)
  300.     {
  301.         UFTInt16s copyIndex;
  302.  
  303.         if (topN->nUsed < topN->nMax)
  304.             ++topN->nUsed;
  305.  
  306.         for (copyIndex = topN->nUsed - 1; copyIndex > index; copyIndex--)
  307.              topN->values [copyIndex] = topN->values [copyIndex - 1];
  308.  
  309.         topN->values [index] = datum;
  310.     }
  311. }
  312.  
  313. ExternC UFError FAR _export PASCAL TopNStore (UFParamBlock * ParamBlock)
  314. {
  315.     // store a number
  316.     struct JobInfo *jobInfo;
  317.  
  318.     jobInfo = FindJobInfo (ParamBlock->JobId);
  319.  
  320.     if (jobInfo != 0 && jobInfo->data != 0)
  321.     {
  322.         struct TopN *topN;
  323.         UFParamListElement * ParamPtr;
  324.         UFTNumber datum;
  325.  
  326.         topN = jobInfo->data;
  327.  
  328.         ParamPtr = GetParam (ParamBlock, 1);
  329.         if (ParamPtr == NULL)
  330.             return UFNotEnoughParameters;
  331.  
  332.         datum = ParamPtr->Parameter.ParamNumber;
  333.  
  334.         insertDatum (topN, datum);
  335.  
  336.         ParamBlock->ReturnValue.ReturnNumber = datum;
  337.     }
  338.     else
  339.         ParamBlock->ReturnValue.ReturnNumber = 0;
  340.  
  341.     return UFNoError;
  342. }
  343.  
  344. ExternC UFError FAR _export PASCAL TopNGet (UFParamBlock * ParamBlock)
  345. {
  346.     // return the nth value
  347.     struct JobInfo *jobInfo;
  348.  
  349.     jobInfo = FindJobInfo (ParamBlock->JobId);
  350.  
  351.     if (jobInfo != 0 && jobInfo->data != 0)
  352.     {
  353.         struct TopN *topN;
  354.         UFParamListElement * ParamPtr;
  355.         UFTInt16s index;
  356.  
  357.         topN = jobInfo->data;
  358.  
  359.         ParamPtr = GetParam (ParamBlock, 1);
  360.         if (ParamPtr == NULL)
  361.             return UFNotEnoughParameters;
  362.  
  363.         index = ParamPtr->Parameter.ParamNumber / UFNumberScalingFactor;
  364.  
  365.         if (index < 1 || index > topN->nMax)
  366.         {
  367.             ParamBlock->ReturnValue.UFReturnUserError = ERR_INDEXOUTOFRANGE;
  368.             return UFUserError;
  369.         }
  370.  
  371. #if defined (DEBUG_INSERT)
  372.         {
  373.             char buffer [80];
  374.             sprintf (buffer, "fetching datum\n"
  375.                              "index: %d, nUsed: %d",
  376.                              index,
  377.                              topN->nUsed);
  378.             MessageBox (0, buffer, "CRSampl1", MB_OK);
  379.         }
  380. #endif
  381.  
  382.         if (index <= topN->nUsed)
  383.             ParamBlock->ReturnValue.ReturnNumber = topN->values [index - 1];
  384.         else
  385.             ParamBlock->ReturnValue.ReturnNumber = 0;
  386.     }
  387.     else
  388.         ParamBlock->ReturnValue.ReturnNumber = 0;
  389.  
  390.     return UFNoError;
  391. }
  392.  
  393.  
  394. /*
  395. ************************************************************
  396. **
  397. ** The following are various test functions.  They don't do anything
  398. ** particularly useful.
  399. */
  400.  
  401.  
  402. ExternC UFError FAR _export PASCAL TestErrorReturn (UFParamBlock *ParamBlock)
  403. {
  404.     ParamBlock->ReturnValue.ReturnDate = 3;
  405.  
  406.     return (UFNoMemory);
  407. }
  408.  
  409. ExternC UFError FAR _export PASCAL TestReplString (UFParamBlock *ParamBlock)
  410. {
  411.     UFTNumber i;
  412.  
  413.     ParamBlock->ReturnValue.ReturnString[0] = '\0';
  414.     for ( i = ParamBlock->UFParamList->NextParam->Parameter.ParamNumber/UFNumberScalingFactor; i > 0; --i)
  415.         lstrcat (ParamBlock->ReturnValue.ReturnString,
  416.                  ParamBlock->UFParamList->Parameter.ParamString);
  417.  
  418.     return (UFNoError);
  419. }
  420.  
  421. ExternC UFError FAR _export PASCAL TestReplStringRetSize (UFMemCalcBlock * ParamBlock)
  422. {
  423.     UFMemCalcParam * ParamPtr;
  424.     UFTInt16s x, y;
  425.  
  426.     if ((ParamPtr =  GetMemCalcParam (ParamBlock, 2)) == NULL)
  427.     {
  428.         ParamBlock->UFMemCalcStringLength = 99;
  429.         return (UFNoError);
  430.     }
  431.  
  432.     if (ParamPtr->MemCalcParamType != UFNumber)
  433.     {
  434.         ParamBlock->UFMemCalcStringLength = 98;
  435.         return (UFNoError);
  436.     }
  437.  
  438.     if (ParamPtr->MemCalcLiteralFlag == UFLiteral)
  439.         x = (ParamPtr->MemCalcParameter.ParamNumber/UFNumberScalingFactor);
  440.     else
  441.     {
  442.         ParamBlock->UFMemCalcStringLength = UFMaxStringLength;
  443.         return (UFNoError);
  444.     }
  445.  
  446.     if ((ParamPtr =  GetMemCalcParam (ParamBlock, 1)) == NULL)
  447.     {
  448.         ParamBlock->UFMemCalcStringLength = 97;
  449.         return (UFNoError);
  450.     }
  451.  
  452.     if (ParamPtr->MemCalcParamType != UFStringArg)
  453.     {
  454.         ParamBlock->UFMemCalcStringLength = 96;
  455.         return (UFNoError);
  456.     }
  457.  
  458.     ParamBlock->UFMemCalcStringLength = (x * (ParamPtr->MemCalcParamLength-1))+1;
  459.  
  460.     return (UFNoError);
  461. }
  462.  
  463. ExternC UFError FAR _export PASCAL TestReplChars (UFParamBlock *ParamBlock)
  464. {
  465.     int i, j, k, l;
  466.  
  467.     ParamBlock->ReturnValue.ReturnString[0] = '\0';
  468.     k = lstrlen(ParamBlock->UFParamList->Parameter.ParamString);
  469.     l = ParamBlock->UFParamList->NextParam->Parameter.ParamNumber/UFNumberScalingFactor;
  470.     for ( j = 0; j < k; ++j)
  471.         for ( i = 0; i <l ; ++i)
  472.             ParamBlock->ReturnValue.ReturnString[(j*l)+i] =
  473.                 ParamBlock->UFParamList->Parameter.ParamString[j];
  474.  
  475.     ParamBlock->ReturnValue.ReturnString[(k*l)] = '\0';
  476.  
  477.     return (UFNoError);
  478. }
  479.  
  480. ExternC UFError FAR _export PASCAL TestTwoStrings (UFParamBlock *ParamBlock)
  481. {
  482.     ParamBlock->ReturnValue.ReturnString[0] = '\0';
  483.  
  484.     lstrcat (ParamBlock->ReturnValue.ReturnString,
  485.              ParamBlock->UFParamList->Parameter.ParamString);
  486.     lstrcat (ParamBlock->ReturnValue.ReturnString,
  487.              ParamBlock->UFParamList->NextParam->Parameter.ParamString);
  488.  
  489.     return (UFNoError);
  490. }
  491.  
  492. ExternC UFError FAR _export PASCAL TestNumberArray (UFParamBlock * ParamBlock)
  493. {
  494.     int index = (int)(ParamBlock->UFParamList->NextParam->Parameter.ParamNumber/UFNumberScalingFactor);
  495.  
  496.     if (index < 1 || index > ParamBlock->UFParamList->ParamLength)
  497.         return UFArrayIndexTooBig;
  498.  
  499.     ParamBlock->ReturnValue.ReturnNumber
  500.         = ParamBlock->UFParamList->Parameter.ParamNumberArray[index - 1];
  501.  
  502.     return UFNoError;
  503. }
  504.  
  505. ExternC UFError FAR _export PASCAL TestCurrencyArray (UFParamBlock * ParamBlock)
  506. {
  507.     int index = (int)(ParamBlock->UFParamList->NextParam->Parameter.ParamNumber/UFNumberScalingFactor);
  508.  
  509.     if (index < 1 || index > ParamBlock->UFParamList->ParamLength)
  510.         return UFArrayIndexTooBig;
  511.  
  512.     ParamBlock->ReturnValue.ReturnCurrency
  513.         = ParamBlock->UFParamList->Parameter.ParamCurrencyArray[index - 1];
  514.  
  515.     return UFNoError;
  516. }
  517.  
  518. ExternC UFError FAR _export PASCAL TestDateArray (UFParamBlock * ParamBlock)
  519. {
  520.     int index = (int)(ParamBlock->UFParamList->NextParam->Parameter.ParamNumber/UFNumberScalingFactor);
  521.  
  522.     if (index < 1 || index > ParamBlock->UFParamList->ParamLength)
  523.         return UFArrayIndexTooBig;
  524.  
  525.     ParamBlock->ReturnValue.ReturnDate
  526.         = ParamBlock->UFParamList->Parameter.ParamDateArray[index - 1];
  527.  
  528.     return UFNoError;
  529. }
  530.  
  531. ExternC UFError FAR _export PASCAL TestStringArray (UFParamBlock * ParamBlock)
  532. {
  533.     int index = (int)(GetParam(ParamBlock,2)->Parameter.ParamNumber/UFNumberScalingFactor);
  534.  
  535.     if (index < 1 || index > ParamBlock->UFParamList->ParamLength)
  536.         return UFArrayIndexTooBig;
  537.  
  538.     lstrcpy (ParamBlock->ReturnValue.ReturnString,
  539.              GetParam(ParamBlock, 1)->Parameter.ParamStringArray[index - 1]);
  540.  
  541.     return UFNoError;
  542. }
  543.  
  544. ExternC UFError FAR _export PASCAL UFMakeNumberRange (UFParamBlock * ParamBlock)
  545. {
  546.     UFParamListElement * ParamPtr;
  547.  
  548.     if ((ParamPtr = GetParam(ParamBlock, 1)) == NULL)
  549.         return UFNotEnoughParameters;
  550.  
  551.     ParamBlock->ReturnValue.ReturnNumberRange.ReturnNumberStart = ParamPtr->Parameter.ParamNumber;
  552.  
  553.     if ((ParamPtr = GetParam(ParamBlock, 2)) == NULL)
  554.         return UFNotEnoughParameters;
  555.  
  556.     ParamBlock->ReturnValue.ReturnNumberRange.ReturnNumberEnd = ParamPtr->Parameter.ParamNumber;
  557.  
  558.     return UFNoError;
  559. }
  560.  
  561. ExternC UFError FAR _export PASCAL UFMakeStringRange (UFParamBlock * ParamBlock)
  562. {
  563.     UFParamListElement * ParamPtr;
  564.  
  565.     if ((ParamPtr = GetParam(ParamBlock, 1)) == NULL)
  566.         return UFNotEnoughParameters;
  567.  
  568.     lstrcpy (ParamBlock->ReturnValue.ReturnStringRange.ReturnStringStart, ParamPtr->Parameter.ParamString);
  569.  
  570.     if ((ParamPtr = GetParam(ParamBlock, 2)) == NULL)
  571.         return UFNotEnoughParameters;
  572.  
  573.     lstrcpy (ParamBlock->ReturnValue.ReturnStringRange.ReturnStringEnd, ParamPtr->Parameter.ParamString);
  574.  
  575.     return UFNoError;
  576. }
  577.  
  578. ExternC UFError FAR _export PASCAL MakeStringRangeFromArray (UFParamBlock * ParamBlock)
  579. {
  580.     UFParamListElement * ParamPtr, * IndexPtr;
  581.     int i,j;
  582.  
  583.     if ((ParamPtr = GetParam(ParamBlock, 1)) == NULL)
  584.         return UFNotEnoughParameters;
  585.  
  586.     if ((IndexPtr = GetParam(ParamBlock, 2)) == NULL)
  587.         return UFNotEnoughParameters;
  588.  
  589.     i = (int) IndexPtr->Parameter.ParamNumber / UFNumberScalingFactor;
  590.     if ((IndexPtr = GetParam(ParamBlock, 3)) == NULL)
  591.         return UFNotEnoughParameters;
  592.  
  593.     j = (int) IndexPtr->Parameter.ParamNumber / UFNumberScalingFactor;
  594.     if ((i > ParamPtr->ParamLength ) || (i < 1) || ( j < 1) ||
  595.         (j > ParamPtr->ParamLength ))
  596.         return UFArrayIndexTooBig;
  597.  
  598.     lstrcpy (ParamBlock->ReturnValue.ReturnStringRange.ReturnStringStart, ParamPtr->Parameter.ParamStringArray[i-1]);
  599.     lstrcpy (ParamBlock->ReturnValue.ReturnStringRange.ReturnStringEnd, ParamPtr->Parameter.ParamStringArray[j-1]);
  600.  
  601.     return UFNoError;
  602. }
  603.  
  604. ExternC UFError FAR _export PASCAL UFMakeDateRange (UFParamBlock * ParamBlock)
  605. {
  606.     UFParamListElement * ParamPtr;
  607.  
  608.     if ((ParamPtr = GetParam(ParamBlock, 1)) == NULL)
  609.         return UFNotEnoughParameters;
  610.  
  611.     ParamBlock->ReturnValue.ReturnDateRange.ReturnDateStart = ParamPtr->Parameter.ParamDate;
  612.  
  613.     if ((ParamPtr = GetParam(ParamBlock, 2)) == NULL)
  614.         return UFNotEnoughParameters;
  615.  
  616.     ParamBlock->ReturnValue.ReturnDateRange.ReturnDateEnd = ParamPtr->Parameter.ParamDate;
  617.  
  618.     return UFNoError;
  619. }
  620.  
  621. ExternC UFError FAR _export PASCAL UFSumNumberArray (UFParamBlock * ParamBlock)
  622. {
  623.     UFTInt16s i;
  624.     UFParamListElement * ParamPtr = GetParam (ParamBlock, 1);
  625.  
  626.     if (ParamPtr == NULL)
  627.         return UFNotEnoughParameters;
  628.  
  629.     ParamBlock->ReturnValue.ReturnNumber = 0;
  630.     for (i = 0; i < ParamPtr->ParamLength; ++i)
  631.         ParamBlock->ReturnValue.ReturnNumber += ParamPtr->Parameter.ParamNumberArray[i];
  632.  
  633.     return UFNoError;
  634. }
  635.  
  636. ExternC UFError FAR _export PASCAL UFSum10Numbers (UFParamBlock * ParamBlock)
  637. {
  638.     UFTInt16s i;
  639.     UFParamListElement * ParamPtr;
  640.  
  641.     ParamBlock->ReturnValue.ReturnNumber = 0;
  642.     for (i = 1; i <= 10; ++i)
  643.     {
  644.         ParamPtr = GetParam (ParamBlock, i);
  645.         if (ParamPtr == NULL)
  646.             return UFNotEnoughParameters;
  647.  
  648.         ParamBlock->ReturnValue.ReturnNumber += ParamPtr->Parameter.ParamNumber;
  649.     }
  650.  
  651.     return UFNoError;
  652. }
  653.  
  654. ExternC UFError FAR _export PASCAL UFConcat10Str (UFParamBlock * ParamBlock)
  655. {
  656.     UFTInt16s i;
  657.     UFParamListElement * ParamPtr;
  658.  
  659.     ParamBlock->ReturnValue.ReturnString[0] = '\0';
  660.     for (i = 1; i <= 10; ++i)
  661.     {
  662.         ParamPtr = GetParam (ParamBlock, i);
  663.  
  664.         if (ParamPtr == NULL)
  665.             return UFNotEnoughParameters;
  666.  
  667.         if (lstrlen (ParamBlock->ReturnValue.ReturnString) + lstrlen (ParamPtr->Parameter.ParamString)
  668.             > UFMaxStringLength)
  669.            return UFStringTooBig;
  670.  
  671.         lstrcat (ParamBlock->ReturnValue.ReturnString, ParamPtr->Parameter.ParamString);
  672.     }
  673.  
  674.     return UFNoError;
  675. }
  676.  
  677. ExternC UFError FAR _export PASCAL UFConcat10StrLengths (UFMemCalcBlock * ParamBlock)
  678. {
  679.     UFTInt16s i, j = 0;
  680.     UFMemCalcParam * ParamPtr;
  681.  
  682.     for (i = 1; i <= 10; ++i)
  683.     {
  684.         ParamPtr = GetMemCalcParam (ParamBlock, i);
  685.  
  686.         if (ParamPtr == NULL)
  687.             return UFNotEnoughParameters;
  688.  
  689.         if (ParamPtr->MemCalcParamType != UFStringArg)
  690.             return UFMemCalcFail;
  691.  
  692.         if ((j += (ParamPtr->MemCalcParamLength-1))
  693.             > UFMaxStringLength)
  694.         {
  695.            j = UFMaxStringLength;
  696.            break;
  697.         }
  698.  
  699.     }
  700.  
  701.     ParamBlock->UFMemCalcStringLength = j+1;;
  702.  
  703.     return UFNoError;
  704. }
  705.  
  706. ExternC UFError FAR _export PASCAL UFSumCurrencyArray (UFParamBlock * ParamBlock)
  707. {
  708.     UFTInt16s i;
  709.     UFParamListElement * ParamPtr = GetParam (ParamBlock, 1);
  710.  
  711.     if (ParamPtr == NULL)
  712.         return UFNotEnoughParameters;
  713.  
  714.     ParamBlock->ReturnValue.ReturnNumber = 0;
  715.     for (i = 0; i < ParamPtr->ParamLength; ++i)
  716.         ParamBlock->ReturnValue.ReturnCurrency += ParamPtr->Parameter.ParamCurrencyArray[i];
  717.  
  718.     return UFNoError;
  719. }
  720.  
  721. ExternC UFError FAR _export PASCAL UFArrayMax (UFParamBlock * ParamBlock)
  722. {
  723.     UFTInt16s i;
  724.     UFParamListElement * ParamPtr = GetParam (ParamBlock, 1);
  725.  
  726.     if (ParamPtr == NULL)
  727.         return UFNotEnoughParameters;
  728.  
  729.     ParamBlock->ReturnValue.ReturnNumber = ParamPtr->Parameter.ParamNumberArray[0];
  730.     for (i = 0; i < ParamPtr->ParamLength; ++i)
  731.         if (ParamBlock->ReturnValue.ReturnNumber < ParamPtr->Parameter.ParamNumberArray[i])
  732.             ParamBlock->ReturnValue.ReturnNumber = ParamPtr->Parameter.ParamNumberArray[i];
  733.  
  734.     return UFNoError;
  735. }
  736.  
  737. ExternC UFError FAR _export PASCAL UFAvgNumberArray (UFParamBlock * ParamBlock)
  738. {
  739.     UFTInt16s i;
  740.     UFParamListElement * ParamPtr = GetParam (ParamBlock, 1);
  741.  
  742.     if (ParamPtr == NULL)
  743.         return UFNotEnoughParameters;
  744.  
  745.     ParamBlock->ReturnValue.ReturnNumber = 0;
  746.     for (i = 0; i < ParamPtr->ParamLength; ++i)
  747.         ParamBlock->ReturnValue.ReturnNumber += ParamPtr->Parameter.ParamNumberArray[i];
  748.  
  749.     ParamBlock->ReturnValue.ReturnNumber /= ParamPtr->ParamLength;
  750.  
  751.     return UFNoError;
  752. }
  753.  
  754. ExternC UFError FAR _export PASCAL UFStringLength (UFParamBlock * ParamBlock)
  755. {
  756.     ParamBlock->ReturnValue.ReturnNumber = (UFTNumber) lstrlen (GetParam(ParamBlock, 1)->Parameter.ParamString) * UFNumberScalingFactor;
  757.  
  758.     return UFNoError;
  759. }
  760.  
  761. ExternC UFError FAR _export PASCAL UFTestErrors (UFParamBlock * ParamBlock)
  762. {
  763.     UFTInt32s ErrorNumber;
  764.  
  765.     if ((ErrorNumber = (UFTInt32s) (GetParam(ParamBlock, 1)->Parameter.ParamNumber)/UFNumberScalingFactor) > 6
  766.         || (ErrorNumber < 0))
  767.         return UFStringIndexTooBig;
  768.  
  769.     ParamBlock->ReturnValue.UFReturnUserError = ErrorNumber;
  770.  
  771.     return UFUserError;
  772. }
  773.  
  774. ExternC UFError FAR _export PASCAL UFSumStringLengths (UFParamBlock * ParamBlock)
  775. {
  776.     UFTInt16s i;
  777.     UFParamListElement * ParamPtr = GetParam(ParamBlock, 1);
  778.  
  779.     if (ParamPtr == NULL)
  780.     {
  781.        ParamBlock->ReturnValue.UFReturnUserError = 2;
  782.        return UFUserError;
  783.     }
  784.  
  785.     for (i = 0; i < ParamPtr->ParamLength; ++i)
  786.     {
  787.         if (lstrlen (ParamPtr->Parameter.ParamStringArray[i]) == 0)
  788.         {
  789.             ParamBlock->ReturnValue.UFReturnUserError = 1;
  790.             return UFUserError;
  791.         }
  792.  
  793.         ParamBlock->ReturnValue.ReturnNumber += lstrlen (ParamPtr->Parameter.ParamStringArray[i]);
  794.     }
  795.  
  796.     ParamBlock->ReturnValue.ReturnNumber *= UFNumberScalingFactor;
  797.  
  798.     return UFNoError;
  799. }
  800.  
  801. ExternC UFError FAR _export PASCAL UFArrayElementsInRange (UFParamBlock * ParamBlock)
  802. {
  803.     UFTInt16s Count, i;
  804.     UFTNumber Max, Min;
  805.     UFTNumber * NumArray;
  806.     UFParamListElement * ParamPtr;
  807.  
  808.     Count = (UFTInt16s) (GetParam(ParamBlock, 3)->Parameter.ParamNumber/UFNumberScalingFactor);
  809.     ParamPtr = GetParam(ParamBlock, 2);
  810.     Min = ParamPtr->Parameter.ParamNumberRange.ParamNumberStart;
  811.     Max = ParamPtr->Parameter.ParamNumberRange.ParamNumberEnd;
  812.     ParamPtr = GetParam(ParamBlock, 1);
  813.     for (i = 0; i < ParamPtr->ParamLength; ++i)
  814.         if ((Min < ParamPtr->Parameter.ParamNumberArray[i]) &&
  815.             (ParamPtr->Parameter.ParamNumberArray[i] < Max))
  816.             --Count;
  817.  
  818.     ParamBlock->ReturnValue.ReturnBoolean = (Count <= 0);
  819.  
  820.     return UFNoError;
  821. }
  822.  
  823. ExternC UFError FAR _export PASCAL UFStringSubstitutions (UFParamBlock * ParamBlock)
  824. {
  825.     UFTInt16s StringArrayLength, StringArrayIndex = 0;
  826.     char * * StringArrayPtr, * ArrayElementPtr;
  827.     char * TargetString = ParamBlock->ReturnValue.ReturnString;
  828.  
  829.     char * TemplateString = GetParam (ParamBlock, 1)->Parameter.ParamString;
  830.     StringArrayPtr = GetParam (ParamBlock, 2)->Parameter.ParamStringArray;
  831.     StringArrayLength = GetParam (ParamBlock, 2)->ParamLength;
  832.     while (*TemplateString)
  833.     {
  834.         if ((*TemplateString == '*') &&(StringArrayIndex < StringArrayLength))
  835.         {
  836.             ArrayElementPtr = StringArrayPtr[StringArrayIndex++];
  837.             while (*ArrayElementPtr)
  838.                 *(TargetString++) = *(ArrayElementPtr++);
  839.             ++TemplateString;
  840.         }
  841.         else
  842.             *(TargetString++) = *(TemplateString++);
  843.     }
  844.  
  845.     *TargetString = '\0';
  846.  
  847.     return UFNoError;
  848. }
  849.  
  850. ExternC UFError FAR _export PASCAL UFStringSubMemCalc (UFMemCalcBlock * ParamBlock)
  851. {
  852.     UFMemCalcParam * ParamPtr, * SubParamPtr;
  853.     UFTInt16s x, y;
  854.  
  855.     if ((ParamPtr =  GetMemCalcParam (ParamBlock, 1)) == NULL)
  856.     {
  857.         ParamBlock->UFMemCalcStringLength = UFMaxStringLength;
  858.         return (UFMemCalcFail);
  859.     }
  860.  
  861.     if (ParamPtr->MemCalcParamType != UFStringArg)
  862.     {
  863.         ParamBlock->UFMemCalcStringLength = UFMaxStringLength;
  864.         return (UFMemCalcFail);
  865.     }
  866.  
  867.     if (ParamPtr->MemCalcLiteralFlag == UFLiteral)
  868.         x = (ParamPtr->MemCalcParamLength);
  869.     else
  870.     {
  871.         ParamBlock->UFMemCalcStringLength = UFMaxStringLength;
  872.         return (UFMemCalcFail);
  873.     }
  874.  
  875.     if ((ParamPtr =  GetMemCalcParam (ParamBlock, 2)) == NULL)
  876.     {
  877.         ParamBlock->UFMemCalcStringLength = UFMaxStringLength;
  878.         return (UFMemCalcFail);
  879.     }
  880.  
  881.     if (ParamPtr->MemCalcParamType != UFStringArray)
  882.     {
  883.         ParamBlock->UFMemCalcStringLength = UFMaxStringLength;
  884.         return (UFMemCalcFail);
  885.     }
  886.  
  887.     for (y=1; y <= ParamPtr->MemCalcParamLength; ++y)
  888.     {
  889.         SubParamPtr = GetMemCalcArrayElement (ParamPtr, y);
  890.         if ((SubParamPtr != NULL) && (SubParamPtr->MemCalcParamType == UFStringArg))
  891.             x += SubParamPtr->MemCalcParamLength - 2; // Minus the "*", and the '\0';
  892.         else
  893.         {
  894.             ParamBlock->UFMemCalcStringLength = UFMaxStringLength;
  895.             return (UFMemCalcFail);
  896.         }
  897.     }
  898.  
  899.     ParamBlock->UFMemCalcStringLength = x + 1; // The last '\0'
  900.  
  901.     return (UFNoError);
  902. }
  903.  
  904. ExternC UFError FAR _export PASCAL TestStringArrayLength (UFMemCalcBlock * ParamBlock)
  905. {
  906.     UFMemCalcParam * ParamPtr, * SubParamPtr;
  907.     UFTInt16s x, y;
  908.  
  909.     if ((ParamPtr =  GetMemCalcParam (ParamBlock, 1)) == NULL)
  910.     {
  911.         ParamBlock->UFMemCalcStringLength = UFMaxStringLength;
  912.         return (UFMemCalcFail);
  913.     }
  914.  
  915.     if (ParamPtr->MemCalcParamType != UFStringArray)
  916.     {
  917.         ParamBlock->UFMemCalcStringLength = UFMaxStringLength;
  918.         return (UFMemCalcFail);
  919.     }
  920.  
  921.     x = 0;
  922.     for (y=1; y <= ParamPtr->MemCalcParamLength; ++y)
  923.     {
  924.         SubParamPtr = GetMemCalcArrayElement (ParamPtr, y);
  925.         if ((SubParamPtr != NULL) && (SubParamPtr->MemCalcParamType == UFStringArg))
  926.         {
  927.             if (x < SubParamPtr->MemCalcParamLength)
  928.                 x = SubParamPtr->MemCalcParamLength;
  929.         }
  930.         else
  931.         {
  932.             ParamBlock->UFMemCalcStringLength = UFMaxStringLength;
  933.             return (UFMemCalcFail);
  934.         }
  935.     }
  936.  
  937.     ParamBlock->UFMemCalcStringLength = x;
  938.  
  939.     return (UFNoError);
  940. }
  941.  
  942. ExternC UFError FAR _export PASCAL UFMakeNumberArray (UFParamBlock * ParamBlock)
  943. {
  944.     UFTInt16s i;
  945.     UFParamListElement * ParamPtr;
  946.  
  947.     for (i=1; i<=4; ++i)
  948.     {
  949.         if ((ParamPtr = GetParam (ParamBlock, i)) == NULL)
  950.             ParamBlock->ReturnValue.ReturnNumberArray[i-1] = 0;
  951.         else
  952.             ParamBlock->ReturnValue.ReturnNumberArray[i-1] =
  953.                 ParamPtr->Parameter.ParamNumber;
  954.     }
  955.  
  956.     return UFNoError;
  957. }
  958.  
  959. ExternC UFError FAR _export PASCAL UFNumberArrayLength (UFMemCalcBlock * ParamBlock)
  960. {
  961.     ParamBlock->UFMemCalcArrayLength = 4;
  962.  
  963.     return UFNoError;
  964. }
  965.  
  966. ExternC UFError FAR _export PASCAL UFMakeStringArray (UFParamBlock * ParamBlock)
  967. {
  968.     UFTInt16s i;
  969.     UFParamListElement * ParamPtr;
  970.  
  971.     for (i=1; i<=4; ++i)
  972.     {
  973.         if ((ParamPtr = GetParam (ParamBlock, i)) == NULL)
  974.             ParamBlock->ReturnValue.ReturnStringArray[i-1][0] = '\0';
  975.         else
  976.             lstrcpy (ParamBlock->ReturnValue.ReturnStringArray[i-1],
  977.                      ParamPtr->Parameter.ParamString);
  978.     }
  979.  
  980.     return UFNoError;
  981. }
  982.  
  983. ExternC UFError FAR _export PASCAL UFStringArrayLength (UFMemCalcBlock * ParamBlock)
  984. {
  985.     UFTInt16s i;
  986.     UFParamListElement * ParamPtr;
  987.     UFMemCalcParam * ParseParamPtr;
  988.  
  989.     ParamBlock->UFMemCalcStringLength = 0;
  990.  
  991.     if (ParamBlock->MemCalcCommand == UFCalcStringLength)
  992.     {   // This is at parse time - have to estimate the max string length
  993.         // from the parse tree values.
  994.         for (i=1; i<=4; ++i)
  995.             if ((ParseParamPtr = GetMemCalcParam (ParamBlock, i)) == NULL)
  996.                 return UFMemCalcFail;
  997.             else // find the longest string, use that length for the array elements sizes.
  998.                 if (ParamBlock->UFMemCalcStringLength <
  999.                     ParseParamPtr->MemCalcParamLength + 1)
  1000.                         ParamBlock->UFMemCalcStringLength =
  1001.                             ParseParamPtr->MemCalcParamLength + 1; // Don't forget the NULL!
  1002.  
  1003.         return UFNoError;
  1004.     }
  1005.  
  1006.     for (i=1; i<=4; ++i)
  1007.     {
  1008.         if ((ParamPtr = GetMemCalcRunParam (ParamBlock, i)) == NULL)
  1009.             return UFMemCalcFail;
  1010.         else // find the longest string, use that length for the array elements sizes.
  1011.             if (ParamBlock->UFMemCalcStringLength <
  1012.                 lstrlen(ParamPtr->Parameter.ParamString) + 1)
  1013.                     ParamBlock->UFMemCalcStringLength =
  1014.                         lstrlen(ParamPtr->Parameter.ParamString) + 1; // Don't forget the NULL!
  1015.     }
  1016.  
  1017.     ParamBlock->UFMemCalcArrayLength = 4;
  1018.  
  1019.     return UFNoError;
  1020. }
  1021.  
  1022. ExternC UFError FAR _export PASCAL UFMakeDateArray (UFParamBlock * ParamBlock)
  1023. {
  1024.     UFTInt16s i;
  1025.     UFParamListElement * ParamPtr;
  1026.  
  1027.     for (i=1; i<=2; ++i)
  1028.         if ((ParamPtr = GetParam (ParamBlock, i)) == NULL)
  1029.             ParamBlock->ReturnValue.ReturnDateArray[i-1] = 0;
  1030.         else
  1031.             ParamBlock->ReturnValue.ReturnDateArray[i-1] =
  1032.                 ParamPtr->Parameter.ParamDate;
  1033.  
  1034.     return UFNoError;
  1035. }
  1036.  
  1037. ExternC UFError FAR _export PASCAL UFDateArrayLength (UFMemCalcBlock * ParamBlock)
  1038. {
  1039.     ParamBlock->UFMemCalcArrayLength = 2;
  1040.     return UFNoError;
  1041. }
  1042.  
  1043. ExternC UFError FAR _export PASCAL UFMakeCurrencyArray (UFParamBlock * ParamBlock)
  1044. {
  1045.     UFTInt16s i;
  1046.     UFParamListElement * ParamPtr;
  1047.  
  1048.     for (i=1; i<=6; ++i)
  1049.     {
  1050.         if ((ParamPtr = GetParam (ParamBlock, i)) == NULL)
  1051.             ParamBlock->ReturnValue.ReturnCurrencyArray[i-1] = 0;
  1052.         else
  1053.             ParamBlock->ReturnValue.ReturnCurrencyArray[i-1] =
  1054.                 ParamPtr->Parameter.ParamCurrency;
  1055.     }
  1056.  
  1057.     return UFNoError;
  1058. }
  1059.  
  1060. ExternC UFError FAR _export PASCAL UFCurrencyArrayLength (UFMemCalcBlock * ParamBlock)
  1061. {
  1062.     ParamBlock->UFMemCalcArrayLength = 6;
  1063.  
  1064.     return UFNoError;
  1065. }
  1066.