public FciFunctionCall(IFX IFXMan) throws UWIException
      {
      FunctionCallManager theFCM;
         if ((theFCM = IFSSingleton.getFunctionCallManager()) == null) 
            throw new UWIException("Needed Function Call Manager");
         IFXMan.registerInterface(this, 
            FunctionCall.FUNCTIONCALL_INTERFACE_NAME,
            FunctionCall.FUNCTIONCALL_CURRENT_VERSION,
            FunctionCall.FUNCTIONCALL_MIN_VERSION_SUPPORTED, 
            0x01000300, 0, null, theFCM.getDefaultListener( ));
      }

      public FciFunctionCall(IFX IFXMan) throws UWIException
      {
      FunctionCallManager theFCM;
         if ((theFCM = IFSSingleton.getFunctionCallManager()) == null) 
            throw new UWIException("Needed Function Call Manager");
         IFXMan.registerInterface(this, 
            FunctionCall.FUNCTIONCALL_INTERFACE_NAME,
            FunctionCall.FUNCTIONCALL_CURRENT_VERSION,
            FunctionCall.FUNCTIONCALL_MIN_VERSION_SUPPORTED, 
            0x01000300, 0, null, theFCM.getDefaultListener( ));
         theFCM.registerFunctionCall(this, "sample_package", 
            "convertDate", FciFunctionCall.CONVERTDATE,
            FunctionCall.FCI_FOLLOWS_STRICT_CALLING_PARAMETERS,
            "S,S", 0x01000300, "Converts a date to a different 
            locale");
      }

   public class FciFunctionCall extends FunctionCallImplBase implements 
      FunctionCall
      {
      /* Additional Code Removed */
         public void evaluate(String thePackageName, 
            String theFunctionName, int theFunctionID, 
            int theFunctionInstance, short theCommand, 
            com.PureEdge.xfdl.FormNodeP theForm, 
            com.PureEdge.xfdl.FormNodeP theComputeNode, 
            com.PureEdge.IFSUserDataHolder theFunctionData, 
            com.PureEdge.IFSUserDataHolder theFunctionInstanceData, 
            com.PureEdge.xfdl.FormNodeP [] theArgList, 
            com.PureEdge.xfdl.FormNodeP theResult) throws UWIException
         {
         String theDateString;
         String theLocaleString;
         String theAnswerString = null;
         Date theDate = null;
         Locale theLocale;
         DateFormat theDateFormat;
            
            if (theCommand == FunctionCall.FCICOMMAND_RUN) 
            {
            
            /* Now we'll switch on the function ID. This makes it easy for a
               single FunctionCall object to support multiple functions. */
            
            if (theFunctionID == FciFunctionCall.CONVERTDATE)
            {
            
            /* First, we'll grab the string values of the two arguments. 
               Since    we indicated that this method has two parameters and
               that it       must have two parameters 
               (FCI_FOLLOWS_STRICT_CALLING_PARAMETERS) when we registered 
               it, we don't have to check to see if we actually received
               both parameters, since this code won't even be called unless
               the caller used the right number of parameters. */
               theDateString = theArgList[0].getLiteralEx(null);
               theLocaleString = theArgList[1].getLiteralEx(null);
            
               /* Now we perform the conversion. */
               if (theLocaleString.length( ) != 5) 
                  theAnswerString = "Locale must be 2 characters, " +
                     "a space and    2 characters";
               else
               {
                  theLocale = new Locale(theLocaleString.substring(0, 2),
                     theLocaleString.substring(3));
                     
                  if ((theDateFormat = DateFormat.getDateInstance(
                     DateFormat.LONG, theLocale)) == null)
                     theAnswerString = "Unrecognized locale";
                  else
                  {
                     try
                     {
                        if ((theDate = new SimpleDateFormat
                           ("yyyyMMdd").parse(theDateString)) == null)
                           theAnswerString = "Unable to parse";
                     }
                     catch (ParseException ex)
                     {
                        theAnswerString = ex.toString( );
                     }
                           
                     if (theAnswerString == null)
                        theAnswerString = theDateFormat.format(theDate);
                  }
               }
            
               /* Lastly, we'll store the result in the result node */
            
               theResult.setLiteralEx(null, theAnswerString);
            }
         }
         /* Additional Code Removed */
      }

      public class FciFunctionCall extends 
      com.PureEdge.xfdl.FunctionCallImplBase implements FunctionCall
      {
         /* Additional Code Removed */
         
         public void help(String thePackageName, 
            String theFunctionName, int theFunctionID, 
            com.PureEdge.IFSUserDataHolder theFunctionData, 
            com.PureEdge.StringHolder theQuickDesc, 
            com.PureEdge.StringHolder theFunctionDesc, 
            com.PureEdge.StringHolder theSampleCode, 
            com.PureEdge.StringListHolder theArgsNameList, 
            com.PureEdge.StringListHolder theArgsDescList, 
            com.PureEdge.ShortListHolder theArgsFlagList, 
            com.PureEdge.StringHolder theRetValDesc, 
            com.PureEdge.ShortHolder theRetValFlag) throws
            UWIException
         {
            switch(theFunctionID)
            {
            case FciFunctionCall.CONVERTDATE:
               theQuickDesc.value = "Converts a date to a different " + 
                  "locale";
               theFunctionDesc.value = "This function takes a date in " +
                  "the first parameter and a locale in the second " +
                  "parameter and returns the date formatted for the " + 
                  "specified locale";
               theSampleCode.value = "\t <LABEL SID = \"LABEL1\"> \n" +
                  "\t\t <VALUE COMPUTE = "sample_package.convert " + 
                  "(\'19980101\', \'french\')"></VALUE> \n" +
                  "\t\t <SIZE CONTENT = \"ARRAY\"> \n" +
                  "\t\t\t <AE>10</AE> \n" +
                  "\t\t\t <AE>1</AE> \n" +
                  "\t\t </SIZE> \n" +
                  "\t </LABEL> \n";
               theArgsNameList.value = new String[2];
               theArgsNameList.value[0] = "theDate";
               theArgsNameList.value[1] = "theLocale";
               theArgsDescList.value = new String[2];
               theArgsDescList.value[0] = "The english date";
               theArgsDescList.value[1] = "The locale";
               theRetValDesc.value = "The formatted date";
               break;
            }
         }
      }

   <Viewer program folder>\Extensions

#ifndef OLD_STYLE_PARAMS
PRE_FUNCTION_DECL r_short POST_FUNCTION_DECL C_ExtensionInit(
      Extension *theExtension, IFX *theIFXManager)
#else
PRE_FUNCTION_DECL r_short POST_FUNCTION_DECL C_ExtensionInit(
      theExtension, theIFXManager)
Extension *theExtension;
IFX *theIFXManager;
#endif
{
      /* Additional code removed */
}

if ((theError = FunctionCall_SetObjectProc(theFunctionCall,
      (voidP)FCISimpleFunctions, FUNCTIONCALLEVALUATE)) != OK)
      return(theError);
if ((theError = FunctionCall_SetObjectProc(theFunctionCall,
      (voidP)FCISimpleHelp, FUNCTIONCALLHELP)) != OK)
      return(theError);

/*    Get the default listener */
if ((returnPtr = FCMGetDefaultListener()) == NULL)
      return(NOTOK);
/*    Register the interface with the Extention Manager.*/
if ((theError = IFXRegisterInterface(theIFXManager,
      (GenericInterface*)theFunctionCall, FUNCTIONCALL_INTERFACE_NAME,
      FUNCTIONCALL_CURRENT_VERSION, FUNCTIONCALL_MIN_VERSION_SUPPORTED,
      0X01000300L, 0, NULL, 0, returnPtr)) != OK)
      return(theError);

if ((theError = FCMRegisterFunctionCall(theFunctionCall, PACKAGE_NAME,
      "multiply", FCI_MULTIPLY_ID, FCI_FOLLOWS_STRICT_CALLING_PARAMETERS,
      "S,S", FCI_MULTIPLY_VERSION, FCI_MULTIPLY_DESCRIPTION)) != OK)
      return(theError);
      /* Finished */
      return(OK);
}

#ifndef OLD_STYLE_PARAMS
PRE_FUNCTION_DECL r_short POST_FUNCTION_DECL FCISimpleFunctions(FunctionCall 
   *theObject, 

r_charP thePackageName, r_charP theFunctionName, r_u_long theFunctionID, 
   r_long theFunctionInstance, 
r_short theCommand, formNodeP theForm, formNodeP theComputeNode, IFSUserData 

**theFunctionDataPtr, IFSUserData **theFunctionInstanceDataPtr, formNodeP 
   *theArgList, r_long 
theArgListSize, formNodeP theResult)
#else
PRE_FUNCTION_DECL r_short POST_FUNCTION_DECL FCISimpleFunctions(theObject, 
thePackageName, theFunctionName,theFunctionID, theFunctionInstance,theCommand, 
   theForm, 
theComputeNode, theArgList, theArgListSize, theResult)
FunctionCallManager *theObject;
r_charP thePackageName;
r_charP theFunctionName;
r_u_long theFunctionID;
r_long theFunctionInstance;
r_short theCommand;
formNodeP theForm;
formNodeP theComputeNode;
IFSUserData **theFunctionDataPtr;
IFSUserData **theFunctionInstanceDataPtr;
formNodeP *theArgList;
r_long *theArgListSize;
formNodeP theResult;
#endif
{
r_charP theFirstParam;
double firstNum;
r_charP theSecondParam;
double secondNum;
r_short theError;
double theMultiplyResult;
char theLiteralBuffer[50]; 
/*    Verify the input parameters */
      if ((thePackageName == NULL) || (theFunctionName == NULL))
      {
         MessageBox(NULL, "Invalid parameters", "Error", MB_OK);
         return(NOTOK);
      }
/*    Make sure that the package is the one we are expecting. */
      if (cp_strcmp(thePackageName, PACKAGE_NAME) != OK)
      {
         MessageBox(NULL, "This function was called with the wrong
            package name", "Error", MB_OK);
         return(NOTOK);
      }
/*    First switch based on the command */
      switch (theCommand)
      {
         case FCICOMMAND_RUN:
/*    Now switch based on the function name */
            switch (theFunctionID)
            {
/*    The "multiply" function. */
               case FCI_MULTIPLY_ID:
            
                  if ((theError = UFLGetLiteralEx(theArgList[0],
                     NULL, &theFirstParam)) != OK)
                  {
                     MessageBox(NULL, "Unable to get the first
                        parameter.", "Error", MB_OK);
                     return(theError);
                  }
                  if ((theError = UFLGetLiteralEx(theArgList[1],
                     NULL, &theSecondParam)) != OK)
                  {
                     MessageBox(NULL, "Unable to get the first
                        parameter.", "Error", MB_OK);
                     return(theError);
                  }
            
/*    Since the literal can be NULL, we make sure that it isn't */
                  if (theFirstParam == NULL)
                     theFirstParam = "";
                  if (theSecondParam == NULL)
                     theSecondParam = "";
      
/*    Convert the literal into a number */
                  firstNum = atof(theFirstParam);
                  secondNum = atof(theSecondParam);
/*    Now multiply the numbers */
                  theMultiplyResult = firstNum * secondNum;
                  sprintf(theLiteralBuffer, "%f", theMultiplyResult);
                  UFLSetLiteralEx(theResult, NULL, theLiteralBuffer);
                  break;
/*    Error if the function is unknown. */
               default:
                  MessageBox(NULL, "The function was called with an
                     unrecognized function", "Error", MB_OK);
               return(NOTOK);
            }
            break;
         case FCICOMMAND_INSTANCEREGISTER:
            break;
         case FCICOMMAND_INSTANCEDEREGISTER:
            break;
         case FCICOMMAND_REGISTER:
            break;
         case FCICOMMAND_DEREGISTER:
            break;
         default:
            break;
      }
/*    Finished */
      return(OK);
}

#ifndef OLD_STYLE_PARAMS
PRE_FUNCTION_DECL r_short POST_FUNCTION_DECL FCISimpleHelp(FunctionCall 
   *theObject, 
r_charP thePackageName, r_charP theFunctionName, r_u_long theFunctionID, 
   IFSUserData 
**theFunctionDataPtr, r_charP *theQuickDescPtr, r_charP *theFunctionDescPtr, 
   r_charP 
*theSampleCodePtr, r_charP **theArgsNameListPtr, r_long *theArgsNameListSizePtr, 
   r_charP 
**theArgsDescListPtr, r_long *theArgsDescListSizePtr, r_short 
   **theArgsFlagListPtr, r_long 
*theArgsFlagListSizePtr, r_charP *theRetValDescPtr, r_short 
   *theRetValFlagPtr)
#else
PRE_FUNCTION_DECL r_short POST_FUNC_DECL FCISimpleHelp(theObject, 
   thePackageName, 
theFunctionName, theFunctionID, theFunctionDataPtr, theQuickDescPtr, 
   theFunctionDescPtr, 
theSampleCodePtr, theArgsNameListPtr, theArgsNameListSizePtr, 
   theArgsDescListPtr, 
theArgsDescListSizePtr, theArgsFlagListPtr, theArgsFlagListSizePtr, 
   theRetValDescPtr, theRetValFlagPtr)
FunctionCall *theObject;
r_charP thePackageName;
r_charP theFunctionName;
r_u_long theFunctionID;
IFSUserData **theFunctionDataPtr;
r_charP *theQuickDescPtr;
r_charP *theFunctionDescPtr;
r_charP *theSampleCodePtr;
r_charP **theArgsNameListPtr;
r_long *theArgsNameListSizePtr;
r_charP **theArgsDescListPtr;
r_long *theArgsDescListSizePtr;
r_short **theArgsFlagListPtr;
r_long *theArgsFlagListSizePtr;
r_charP *theRetValDescPtr;
r_short *theRetValFlagPtr;
#endif
{
      switch(theFunctionID)
      {
         case FCI_MULTIPLY_ID:
            if (((*theQuickDescPtr) = cp_strdup("Multiplies two numbers
               together")) == NULL)
            {
               MessageBox(NULL, "Out of memory", "Error", MB_OK);
               return(NOTOK);
            }
            if (((*theFunctionDescPtr) = cp_strdup(
               "This function multiplies two numbers together."
               "/n It takes the values of two fields"
               "/n and finds their product with a precision"
               "/n of up to seven decimal places.")) == NULL)
            {
               MessageBox(NULL, "Out of memory", "Error", MB_OK);
               return(NOTOK);
            }
            if (((*theSampleCodePtr) = cp_strdup(
               "\t<field sid=\"PRODUCT_FIELD\">\n"
               "\t\t<value compute=\"test_Package.multiply" 
               "(field1.value, field2.value)\"></value>\n"
               "\t\t<size>\n"
               "\t\t\t<ae>10</ae>\n"
               "\t\t\t<ae>1</ae>\n"
               "\t\t</size>\n"
               "\t</field>\n")) == NULL)
            {
               MessageBox(NULL, "Out of memory", "Error", MB_OK);
               return(NOTOK);
            }
            if (((*theRetValDescPtr) = cp_strdup(
               "The product of the two parameters given")) == NULL)
            {
               MessageBox(NULL, "Out of memory", "Error", MB_OK);
               return(NOTOK);
            }
            break;
         default:
            break;
      }
      return(OK);
}