private static FunctionMetadataRegistry GetInstance()
{
if (_instance == null)
{
_instance = FunctionMetadataReader.CreateRegistry();
}
return(_instance);
}
public FuncPtg(int functionIndex)
{
field_2_fnc_index = (short)functionIndex;
FunctionMetadata fm = FunctionMetadataRegistry.GetFunctionByIndex(functionIndex);
numParams = fm.MinParams; // same as max since these are not var-arg funcs
returnClass = fm.ReturnClassCode;
paramClass = fm.ParameterClassCodes;
}
public static FuncPtg Create(int functionIndex)
{
FunctionMetadata fm = FunctionMetadataRegistry.GetFunctionByIndex(functionIndex);
if (fm == null)
{
throw new Exception("Invalid built-in function index (" + functionIndex + ")");
}
return(new FuncPtg(functionIndex, fm));
}
/**
* Resolves internal function names into function indexes.
*
* The name matching is case insensitive.
* @return the standard worksheet function index if found, otherwise <c>FUNCTION_INDEX_EXTERNAL</c>
*/
protected static short LookupIndex(String name)
{
short ix = FunctionMetadataRegistry.LookupIndexByName(name.ToUpper());
if (ix < 0)
{
return(FUNCTION_INDEX_EXTERNAL);
}
return(ix);
}
private static FuncVarPtg Create(int numArgs, int functionIndex)
{
FunctionMetadata fm = FunctionMetadataRegistry.GetFunctionByIndex(functionIndex);
if (fm == null)
{
// Happens only as a result of a call to FormulaParser.parse(), with a non-built-in function name
return(new FuncVarPtg(functionIndex, Ptg.CLASS_VALUE, new byte[] { Ptg.CLASS_VALUE }, numArgs));
}
return(new FuncVarPtg(functionIndex, fm.ReturnClassCode, fm.ParameterClassCodes, numArgs));
}
public static void ReplaceFunction(string name, Function function)
{
var func = FunctionMetadataRegistry.GetFunctionByName(name.ToUpper());
if (func == null)
{
throw new InvalidOperationException($"Functin {name} not found in NPoi.");
}
functions[func.Index] = function;
}
private static void ConfirmFunction(int index, String funcName)
{
FunctionMetadata fm;
fm = FunctionMetadataRegistry.GetFunctionByIndex(index);
Assert.IsNotNull(fm);
Assert.AreEqual(funcName, fm.Name);
fm = FunctionMetadataRegistry.GetFunctionByName(funcName);
Assert.IsNotNull(fm);
Assert.AreEqual(index, fm.Index);
}
protected String LookupName(short index)
{
if (index == FunctionMetadataRegistry.FUNCTION_INDEX_EXTERNAL)
{
return("#external#");
}
FunctionMetadata fm = FunctionMetadataRegistry.GetFunctionByIndex(index);
if (fm == null)
{
throw new Exception("bad function index (" + index + ")");
}
return(fm.Name);
}
/**Creates new function pointer from a byte array
* usually called while Reading an excel file.
*/
public FuncPtg(LittleEndianInput in1)
{
//field_1_num_args = data[ offset + 0 ];
field_2_fnc_index = in1.ReadShort();
FunctionMetadata fm = FunctionMetadataRegistry.GetFunctionByIndex(field_2_fnc_index);
if (fm == null)
{
throw new Exception("Invalid built-in function index (" + field_2_fnc_index + ")");
}
numParams = fm.MinParams;
returnClass = fm.ReturnClassCode;
paramClass = fm.ParameterClassCodes;
}
/**
* Returns an array of function names NOT implemented by POI.
*
* @return an array of not supported functions
* @since 3.8 beta6
*/
public static ReadOnlyCollection <String> GetNotSupportedFunctionNames()
{
List <String> lst = new List <String>();
for (int i = 0; i < functions.Length; i++)
{
Function func = functions[i];
if (func != null && (func is NotImplementedFunction))
{
FunctionMetadata metaData = FunctionMetadataRegistry.GetFunctionByIndex(i);
lst.Add(metaData.Name);
}
}
lst.Remove("INDIRECT"); // INDIRECT is a special case
return(lst.AsReadOnly()); // Collections.unmodifiableCollection(lst);
}
/**
* Create a function ptg from a string tokenised by the Parser
*/
public FuncVarPtg(String pName, byte pNumOperands)
{
field_1_num_args = pNumOperands;
field_2_fnc_index = LookupIndex(pName);
FunctionMetadata fm = FunctionMetadataRegistry.GetFunctionByIndex(field_2_fnc_index);
if (fm == null)
{
// Happens only as a result of a call to FormulaParser.Parse(), with a non-built-in function name
returnClass = Ptg.CLASS_VALUE;
paramClass = new byte[] { Ptg.CLASS_VALUE };
}
else
{
returnClass = fm.ReturnClassCode;
paramClass = fm.ParameterClassCodes;
}
}
/**Creates new function pointer from a byte array
* usually called while Reading an excel file.
*/
public FuncVarPtg(LittleEndianInput in1)
{
field_1_num_args = (byte)in1.ReadByte();
field_2_fnc_index = in1.ReadShort();
FunctionMetadata fm = FunctionMetadataRegistry.GetFunctionByIndex(field_2_fnc_index);
if (fm == null)
{
// Happens only as a result of a call to FormulaParser.Parse(), with a non-built-in function name
returnClass = Ptg.CLASS_VALUE;
paramClass = new byte[] { Ptg.CLASS_VALUE };
}
else
{
returnClass = fm.ReturnClassCode;
paramClass = fm.ParameterClassCodes;
}
}
/**
* Generates the variable function ptg for the formula.
* <p>
* For IF Formulas, Additional PTGs are Added To the Tokens
* @param name
* @param numArgs
* @return Ptg a null Is returned if we're in an IF formula, it needs extreme manipulation and Is handled in this function
*/
private ParseNode GetFunction(String name, NamePtg namePtg, ParseNode[] args)
{
FunctionMetadata fm = FunctionMetadataRegistry.GetFunctionByName(name.ToUpper());
int numArgs = args.Length;
if (fm == null)
{
if (namePtg == null)
{
throw new InvalidOperationException("NamePtg must be supplied for external functions");
}
// must be external function
ParseNode[] allArgs = new ParseNode[numArgs + 1];
allArgs[0] = new ParseNode(namePtg);
Array.Copy(args, 0, allArgs, 1, numArgs);
return(new ParseNode(new FuncVarPtg(name, (byte)(numArgs + 1)), allArgs));
}
if (namePtg != null)
{
throw new InvalidOperationException("NamePtg no applicable To internal functions");
}
bool IsVarArgs = !fm.HasFixedArgsLength;
int funcIx = fm.Index;
ValidateNumArgs(args.Length, fm);
AbstractFunctionPtg retval;
if (IsVarArgs)
{
retval = new FuncVarPtg(name, (byte)numArgs);
}
else
{
retval = new FuncPtg(funcIx);
}
return(new ParseNode(retval, args));
}
/**
* Used to detect whether a function name found in a formula is one of the standard excel functions
*
* The name matching is case insensitive.
* @return <c>true</c> if the name specifies a standard worksheet function,
* <c>false</c> if the name should be assumed to be an external function.
*/
public static bool IsBuiltInFunctionName(String name)
{
short ix = FunctionMetadataRegistry.LookupIndexByName(name.ToUpper());
return(ix >= 0);
}
