public override CompileResult Execute(IEnumerable<FunctionArgument> arguments, ParsingContext context) { var functionArguments = arguments as FunctionArgument[] ?? arguments.ToArray(); ValidateArguments(functionArguments, 2); var startDate = System.DateTime.FromOADate(ArgToInt(functionArguments, 0)); var endDate = System.DateTime.FromOADate(ArgToInt(functionArguments, 1)); WorkdayCalculator calculator = new WorkdayCalculator(); var weekdayFactory = new HolidayWeekdaysFactory(); if (functionArguments.Length > 2) { var holidayArg = functionArguments[2].Value; if (Regex.IsMatch(holidayArg.ToString(), "^[01]{7}")) { calculator = new WorkdayCalculator(weekdayFactory.Create(holidayArg.ToString())); } else if (IsNumeric(holidayArg)) { var holidayCode = Convert.ToInt32(holidayArg); calculator = new WorkdayCalculator(weekdayFactory.Create(holidayCode)); } else { return new CompileResult(eErrorType.Value); } } var result = calculator.CalculateNumberOfWorkdays(startDate, endDate); if (functionArguments.Length > 3) { result = calculator.ReduceWorkdaysWithHolidays(result, functionArguments[3]); } return new CompileResult(result.NumberOfWorkdays, DataType.Integer); }
private static object HandleArgumentNotResolved(ParsingContext context, ParameterInfo parameterInfo) { var attribute = parameterInfo.GetCustomAttribute<ArgumentAttribute>(); if(attribute == null) { throw new ArgumentException(string.Format("Could not resolve argument: {0}", parameterInfo.Name)); } var startPosition = context.CurrentPosition; var separatorPosition = attribute.Separator == '\0' ? -1 : context.Packet.Data.DataAsString.IndexOf(attribute.Separator, startPosition); var length = (separatorPosition == -1 ? context.Packet.Data.DataAsString.Length : separatorPosition) - startPosition; var valueToParse = context.Packet.Data.DataAsString.Substring(startPosition, length); context.CurrentPosition += length + 1; switch(attribute.Encoding) { case ArgumentAttribute.ArgumentEncoding.HexNumber: return Parse(parameterInfo.ParameterType, valueToParse, NumberStyles.HexNumber); case ArgumentAttribute.ArgumentEncoding.DecimalNumber: return Parse(parameterInfo.ParameterType, valueToParse); case ArgumentAttribute.ArgumentEncoding.BinaryBytes: return context.Packet.Data.DataAsBinary.Skip(startPosition).ToArray(); case ArgumentAttribute.ArgumentEncoding.HexBytesString: return valueToParse.Split(2).Select(x => byte.Parse(x, NumberStyles.HexNumber)).ToArray(); default: throw new ArgumentException(string.Format("Unsupported argument type: {0}", parameterInfo.ParameterType.Name)); } }
private void Calculate(IEnumerable<FunctionArgument> items, ref double nItems, ParsingContext context, ItemContext itemContext) { foreach (var item in items) { var cs = item.Value as ExcelDataProvider.IRangeInfo; if (cs != null) { foreach (var c in cs) { _CheckForAndHandleExcelError(c, context); if (ShouldIgnore(c, context) == false && ShouldCount(c.Value, ItemContext.InRange)) { nItems++; } } } else { var value = item.Value as IEnumerable<FunctionArgument>; if (value != null) { Calculate(value, ref nItems, context, ItemContext.InArray); } else { _CheckForAndHandleExcelError(item, context); if (ShouldIgnore(item) == false && ShouldCount(item.Value, itemContext)) { nItems++; } } } } }
public override CompileResult Execute(IEnumerable<FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 2); var row = ArgToInt(arguments, 0); var col = ArgToInt(arguments, 1); ThrowExcelErrorValueExceptionIf(() => row < 0 && col < 0, eErrorType.Value); var referenceType = ExcelReferenceType.AbsoluteRowAndColumn; var worksheetSpec = string.Empty; if (arguments.Count() > 2) { var arg3 = ArgToInt(arguments, 2); ThrowExcelErrorValueExceptionIf(() => arg3 < 1 || arg3 > 4, eErrorType.Value); referenceType = (ExcelReferenceType)ArgToInt(arguments, 2); } if (arguments.Count() > 3) { var fourthArg = arguments.ElementAt(3).Value; if(fourthArg.GetType().Equals(typeof(bool)) && !(bool)fourthArg) { throw new InvalidOperationException("Excelformulaparser does not support the R1C1 format!"); } if (fourthArg.GetType().Equals(typeof(string))) { worksheetSpec = fourthArg.ToString() + "!"; } } var translator = new IndexToAddressTranslator(context.ExcelDataProvider, referenceType); return CreateResult(worksheetSpec + translator.ToAddress(col, row), DataType.ExcelAddress); }
public override CompileResult Execute(IEnumerable<FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 2); var n1 = ArgToDecimal(arguments, 0); var n2 = ArgToDecimal(arguments, 1); return new CompileResult(n1 % n2, DataType.Decimal); }
public override CompileResult Execute(IEnumerable<FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 3); var values = GetMatchingValues(arguments, context); if (!values.Any()) return CreateResult(0d, DataType.Integer); return CreateResult(values.Max(), DataType.Integer); }
public override CompileResult Execute(IEnumerable<FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 1); var nItems = 0d; Calculate(arguments, ref nItems, context, ItemContext.SingleArg); return CreateResult(nItems, DataType.Integer); }
public override CompileResult Compile(IEnumerable<Expression> children, ParsingContext context) { var args = new List<FunctionArgument>(); Function.BeforeInvoke(context); var firstChild = true; foreach (var child in children) { if (!firstChild || Function.SkipArgumentEvaluation) { child.ParentIsLookupFunction = Function.IsLookupFuction; } else { firstChild = false; } var arg = child.Compile(); if (arg != null) { BuildFunctionArguments(arg.Result, arg.DataType, args); } else { BuildFunctionArguments(null, DataType.Unknown, args); } } return Function.Execute(args, context); }
public override CompileResult Execute(IEnumerable<FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 1); var val = arguments.ElementAt(0).ValueFirst; if (val is string) return CreateResult(val, DataType.String); return CreateResult(string.Empty, DataType.String); }
public override CompileResult Execute(IEnumerable<FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 1); var arg = ArgToDecimal(arguments, 0); var result = System.Math.Sqrt((double)arg); return CreateResult((double)result, DataType.Decimal); }
public override CompileResult Execute(IEnumerable<FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 2); var firstArg = arguments.ElementAt(0); var args = firstArg.Value as IEnumerable<FunctionArgument>; if (args == null && firstArg.IsExcelRange) { args = new List<FunctionArgument>(){ firstArg }; } var criteria = arguments.ElementAt(1).Value; ThrowExcelErrorValueExceptionIf(() => criteria == null || criteria.ToString().Length > 255, eErrorType.Value); var retVal = 0d; if (arguments.Count() > 2) { var secondArg = arguments.ElementAt(2); var lookupRange = secondArg.Value as IEnumerable<FunctionArgument>; if (lookupRange == null && secondArg.IsExcelRange) { lookupRange = new List<FunctionArgument>() {secondArg}; } retVal = CalculateWithLookupRange(args, criteria.ToString(), lookupRange, context); } else { retVal = CalculateSingleRange(args, criteria.ToString(), context); } return CreateResult(retVal, DataType.Decimal); }
public override CompileResult Execute(IEnumerable<FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 1); var dateInt = ArgToInt(arguments, 0); var date = System.DateTime.FromOADate(dateInt); return CreateResult(WeekNumber(date), DataType.Integer); }
public override CompileResult Execute(IEnumerable<FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 1); var arg = GetFirstValue(arguments); if (arg is bool) { var val = (bool) arg ? 1d : 0d; return CreateResult(val, DataType.Decimal); } else if (IsNumeric(arg)) { var val = ConvertUtil.GetValueDouble(arg); return CreateResult(val, DataType.Decimal); } else if (arg is string) { return CreateResult(0d, DataType.Decimal); } else if (arg is ExcelErrorValue) { return CreateResult(arg, DataType.ExcelError); } throw new ExcelErrorValueException(eErrorType.Value); }
public override CompileResult Execute(IEnumerable<FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 1); var number = ArgToInt(arguments, 0); ThrowExcelErrorValueExceptionIf(() => number < 1 || number > 255, eErrorType.Value); return CreateResult(((char) number).ToString(), DataType.String); }
private double Calculate(FunctionArgument arg, ParsingContext context) { var retVal = 0d; if (ShouldIgnore(arg)) { return retVal; } if (arg.Value is IEnumerable<FunctionArgument>) { foreach (var item in (IEnumerable<FunctionArgument>)arg.Value) { retVal += Calculate(item, context); } } else if (arg.Value is ExcelDataProvider.IRangeInfo) { foreach (var c in (ExcelDataProvider.IRangeInfo)arg.Value) { if (ShouldIgnore(c, context) == false) { CheckForAndHandleExcelError(c); retVal += c.ValueDouble; } } } else { CheckForAndHandleExcelError(arg); retVal += ConvertUtil.GetValueDouble(arg.Value, true); } return retVal; }
public override CompileResult Execute(IEnumerable<FunctionArgument> arguments, ParsingContext context) { var functionArguments = arguments as FunctionArgument[] ?? arguments.ToArray(); ValidateArguments(functionArguments, 3); var sumRange = ArgsToDoubleEnumerable(true, new List<FunctionArgument> {functionArguments[0]}, context).ToList(); var argRanges = new List<ExcelDataProvider.IRangeInfo>(); var criterias = new List<object>(); for (var ix = 1; ix < 31; ix += 2) { if (functionArguments.Length <= ix) break; var rangeInfo = functionArguments[ix].ValueAsRangeInfo; argRanges.Add(rangeInfo); if (ix > 1) { ThrowExcelErrorValueExceptionIf(() => rangeInfo.GetNCells() != argRanges[0].GetNCells(), eErrorType.Value); } criterias.Add(functionArguments[ix + 1].Value); } IEnumerable<int> matchIndexes = GetMatchIndexes(argRanges[0], criterias[0]); var enumerable = matchIndexes as IList<int> ?? matchIndexes.ToList(); for (var ix = 1; ix < argRanges.Count && enumerable.Any(); ix++) { var indexes = GetMatchIndexes(argRanges[ix], criterias[ix]); matchIndexes = enumerable.Intersect(indexes); } var result = matchIndexes.Sum(index => sumRange[index]); return CreateResult(result, DataType.Decimal); }
public override CompileResult Execute(IEnumerable<FunctionArgument> arguments, ParsingContext context) { if (arguments == null || arguments.Count() == 0) { return CreateResult(false, DataType.Boolean); } foreach (var argument in arguments) { if (argument.Value is ExcelDataProvider.IRangeInfo) { var r = (ExcelDataProvider.IRangeInfo)argument.Value; if (ExcelErrorValue.Values.IsErrorValue(r.GetValue(r.Address._fromRow, r.Address._fromCol))) { return CreateResult(true, DataType.Boolean); } } else { if (ExcelErrorValue.Values.IsErrorValue(argument.Value)) { return CreateResult(true, DataType.Boolean); } } } return CreateResult(false, DataType.Boolean); }
public override CompileResult Execute(IEnumerable<FunctionArgument> arguments, ParsingContext context) { var isError = new IsError(); var result = isError.Execute(arguments, context); if ((bool) result.Result) { var arg = GetFirstValue(arguments); if (arg is ExcelDataProvider.IRangeInfo) { var r = (ExcelDataProvider.IRangeInfo)arg; var e=r.GetValue(r.Address._fromRow, r.Address._fromCol) as ExcelErrorValue; if (e !=null && e.Type==eErrorType.NA) { return CreateResult(false, DataType.Boolean); } } else { if (arg is ExcelErrorValue && ((ExcelErrorValue)arg).Type==eErrorType.NA) { return CreateResult(false, DataType.Boolean); } } } return result; }
public override CompileResult Execute(IEnumerable<FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 2); var args = arguments.ElementAt(0).Value as ExcelDataProvider.IRangeInfo; //IEnumerable<FunctionArgument>; var criteria = arguments.ElementAt(1).Value; ThrowExcelErrorValueExceptionIf(() => criteria == null || criteria.ToString().Length > 255, eErrorType.Value); var retVal = 0d; if (arguments.Count() > 2) { var sumRange = arguments.ElementAt(2).Value as ExcelDataProvider.IRangeInfo;//IEnumerable<FunctionArgument>; retVal = CalculateWithSumRange(args, criteria.ToString(), sumRange, context); } else { if (args != null) { retVal = CalculateSingleRange(args, criteria.ToString(), context); } else { retVal = CalculateSingleRange((arguments.ElementAt(0).Value as IEnumerable<FunctionArgument>), criteria.ToString(), context); } } return CreateResult(retVal, DataType.Decimal); }
public override CompileResult Compile(IEnumerable<Expression> children, ParsingContext context) { if (children.Count() != 2) return new CompileResult(eErrorType.Value); var args = new List<FunctionArgument>(); Function.BeforeInvoke(context); var firstChild = children.First(); var lastChild = children.ElementAt(1); try { var result = firstChild.Compile(); if (result.DataType == DataType.ExcelError && (Equals(result.Result, ExcelErrorValue.Create(eErrorType.NA)))) { args.Add(new FunctionArgument(lastChild.Compile().Result)); } else { args.Add(new FunctionArgument(result.Result)); } } catch (ExcelErrorValueException) { args.Add(new FunctionArgument(lastChild.Compile().Result)); } return Function.Execute(args, context); }
public override CompileResult Execute(IEnumerable<FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 2); var str = ArgToString(arguments, 0); var length = ArgToInt(arguments, 1); return CreateResult(str.Substring(0, length), DataType.String); }
private void _CheckForAndHandleExcelError(ExcelDataProvider.ICellInfo cell, ParsingContext context) { if (context.Scopes.Current.IsSubtotal) { CheckForAndHandleExcelError(cell); } }
private void Calculate(IEnumerable<FunctionArgument> items, ParsingContext context, ref double nItems) { foreach (var item in items) { var cs = item.Value as ExcelDataProvider.IRangeInfo; if (cs != null) { foreach (var c in cs) { _CheckForAndHandleExcelError(c, context); if (!ShouldIgnore(c, context) && ShouldCount(c.Value)) { nItems++; } } } else if (item.Value is IEnumerable<FunctionArgument>) { Calculate((IEnumerable<FunctionArgument>)item.Value, context, ref nItems); } else { _CheckForAndHandleExcelError(item, context); if (!ShouldIgnore(item) && ShouldCount(item.Value)) { nItems++; } } } }
public override CompileResult Execute(IEnumerable<FunctionArgument> arguments, ParsingContext context) { if (arguments == null || arguments.Count() == 0) { return CreateResult(true, DataType.Boolean); } var result = true; foreach (var arg in arguments) { if (arg.Value is ExcelDataProvider.IRangeInfo) { var r=(ExcelDataProvider.IRangeInfo)arg.Value; if (r.GetValue(r.Address._fromRow, r.Address._fromCol) != null) { result = false; } } else { if (arg.Value != null && (arg.Value.ToString() != string.Empty)) { result = false; break; } } } return CreateResult(result, DataType.Boolean); }
public override void Execute(ParsingContext context) { var savedParserInput = context.CurrentParserInput; context.CurrentParserInput = GetResultNode(context); CompleteReduce(context); context.CurrentParserInput = savedParserInput; }
public override LinkedList<IWikiElement> Parse(ParsingContext parsingContext, ElementContent containerContent) { var elements = new LinkedList<IWikiElement>(); foreach (Match match in _linkExpression.Matches(containerContent.ToString())) { var elementContent = new ElementContent(containerContent, match); var innerContent = new ElementContent(containerContent, match.Groups["content"]); string originalAddress, normalizedAddress; if (match.Groups["url"].Success) { originalAddress = match.Groups["url"].Value; normalizedAddress = FormatUrl(originalAddress); } else if (match.Groups["email"].Success) { originalAddress = match.Groups["email"].Value; normalizedAddress = FormatEmail(originalAddress); } else continue; string text = match.Groups["text"].Success ? match.Groups["text"].Value : originalAddress; bool noFollow = match.Groups["nofollow"].Success; var element = new LinkElement(parsingContext, elementContent, innerContent, normalizedAddress, text, noFollow); elements.AddLast(element); } return elements; }
public override CompileResult Execute(IEnumerable<FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 1); var firstArg = arguments.ElementAt(0); if (firstArg.Value == null || firstArg.ValueIsExcelError) return CreateResult(false, DataType.Boolean); return CreateResult(!(firstArg.Value is string), DataType.Boolean); }
private void _CheckForAndHandleExcelError(FunctionArgument arg, ParsingContext context) { if (context.Scopes.Current.IsSubtotal) { CheckForAndHandleExcelError(arg); } }
public override CompileResult Execute(IEnumerable<FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 1); var error = arguments.ElementAt(0); var isErrorFunc = context.Configuration.FunctionRepository.GetFunction("iserror"); var isErrorResult = isErrorFunc.Execute(arguments, context); if (!(bool) isErrorResult.Result) { return CreateResult(ExcelErrorValue.Create(eErrorType.NA), DataType.ExcelError); } var errorType = error.ValueAsExcelErrorValue; int retValue; switch (errorType.Type) { case eErrorType.Null: return CreateResult(1, DataType.Integer); case eErrorType.Div0: return CreateResult(2, DataType.Integer); case eErrorType.Value: return CreateResult(3, DataType.Integer); case eErrorType.Ref: return CreateResult(4, DataType.Integer); case eErrorType.Name: return CreateResult(5, DataType.Integer); case eErrorType.Num: return CreateResult(6, DataType.Integer); case eErrorType.NA: return CreateResult(7, DataType.Integer); } return CreateResult(ExcelErrorValue.Create(eErrorType.NA), DataType.ExcelError); }
public override CompileResult Execute(IEnumerable<FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 1); var dateObj = arguments.ElementAt(0).Value; System.DateTime date = ParseDate(arguments, dateObj); return CreateResult(date.Second, DataType.Integer); }
public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { throw new NotImplementedException(); }
public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 1); var firstArg = arguments.First(); return(GetResultByObject(firstArg.Value)); }
public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 1); var arg = ArgToDecimal(arguments, 0); return(CreateResult(MathHelper.HArcsin(arg), DataType.Decimal)); }
public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { if (this.ArgumentsAreValid(arguments, 2, out eErrorType argumentError) == false) { return(new CompileResult(argumentError)); } var items = new List <object>(); for (int x = 0; x < arguments.Count(); x++) { items.Add(arguments.ElementAt(x).ValueFirst); } var chooseIndeces = arguments.ElementAt(0).ValueFirst as IEnumerable <FunctionArgument>; if (chooseIndeces != null && chooseIndeces.Count() > 1) { IntArgumentParser intParser = new IntArgumentParser(); object[] values = chooseIndeces.Select(chosenIndex => items[(int)intParser.Parse(chosenIndex.ValueFirst)]).ToArray(); return(CreateResult(values, DataType.Enumerable)); } else { var index = ArgToInt(arguments, 0); return(CreateResult(items[index].ToString(), DataType.String)); } }
public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 3); var text = ArgToString(arguments, 0); var find = ArgToString(arguments, 1); var replaceWith = ArgToString(arguments, 2); var result = text.Replace(find, replaceWith); return(CreateResult(result, DataType.String)); }
public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 4); var rate = ArgToDecimal(arguments, 0); var per = ArgToInt(arguments, 1); var nPer = ArgToInt(arguments, 2); var presentValue = ArgToDecimal(arguments, 3); var fv = 0d; if (arguments.Count() >= 5) { fv = ArgToDecimal(arguments, 4); } var type = PmtDue.EndOfPeriod; if (arguments.Count() >= 6) { type = (PmtDue)ArgToInt(arguments, 5); } var result = IPmtImpl.Ipmt(rate, per, nPer, presentValue, fv, type); if (result.HasError) { return(CreateResult(result.ExcelErrorType)); } return(CreateResult(result.Result, DataType.Decimal)); }
public override CompileResult Compile(IEnumerable <Expression> children, ParsingContext context) { throw new NotImplementedException(); }
public override ParsingResult?TryParse(ParsingContext parsingContext) => _sequence.TryParse(parsingContext);
public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { if (this.ArgumentsAreValid(arguments, 4, out eErrorType argumentError) == false) { return(new CompileResult(argumentError)); } var oldText = ArgToString(arguments, 0); var startPos = ArgToInt(arguments, 1); var nCharsToReplace = ArgToInt(arguments, 2); var newText = ArgToString(arguments, 3); var firstPart = GetFirstPart(oldText, startPos); var lastPart = GetLastPart(oldText, startPos, nCharsToReplace); var result = string.Concat(firstPart, newText, lastPart); return(CreateResult(result, DataType.String)); }
public ParserTests() { var functionService = new FunctionService(new Random()); _parsingContext = new ParsingContext(new StatService(functionService), functionService); }
public override Token TryMatch(ParsingContext context, ISourceStream source) { try { var text = source.Text; switch (_Kind) { case EDateTimeKind.Date: return(source.CreateToken(this.OutputTerminal, DateTime.Parse(PreivewDate(source)))); case EDateTimeKind.TimeOfDay: return(source.CreateToken(this.OutputTerminal, DateTime.Parse(PreivewTime(source)))); case EDateTimeKind.DateTime: { var date = PreivewDate(source); source.IsChar('T'); var time = PreivewTime(source, source.PreviewPosition); return(source.CreateToken(this.OutputTerminal, DateTime.Parse(date + " " + time))); } case EDateTimeKind.DateTimeOffset: { var date = PreivewDate(source); source.IsChar('T'); var time = PreivewTime(source, source.PreviewPosition); if (source.PreviewChar == '+' || source.PreviewChar == '-') { var zone = PreviewZone(source, source.PreviewPosition); return(source.CreateToken(this.OutputTerminal, DateTime.Parse(date + " " + time + " " + zone))); } else { source.IsChar('Z'); } return(source.CreateToken(this.OutputTerminal, DateTime.Parse(date + " " + time))); } case EDateTimeKind.TimeSpan: { var multi = source.PreviewChar == '-' ? -1 : 1; if (source.PreviewChar == '+') { source.Position++; } source.IsChar('P'); var day = PreviewDigit(source); source.IsChar('D'); var space = TimeSpan.FromDays(Convert.ToDouble(day) * multi); if (source.PreviewChar == 'T') { source.PreviewPosition++; var iscontinue = true; do { var val = PreviewDigit(source); switch (source.PreviewChar) { case 'H': space += TimeSpan.FromHours(Convert.ToDouble(val) * multi); break; case 'M': space += TimeSpan.FromMinutes(Convert.ToDouble(val) * multi); break; case 'S': space += TimeSpan.FromSeconds(Convert.ToDouble(val) * multi); break; default: iscontinue = false; break; } if (iscontinue) { source.PreviewPosition++; } } while (iscontinue && Char.IsDigit(source.PreviewChar)); } return(source.CreateToken(this.OutputTerminal, space)); } default: return(context.CreateErrorToken("not suppored datetimekind.")); } } catch (Exception ex) { return(null); } }
public static LookupNavigator Create(LookupDirection direction, LookupArguments args, ParsingContext parsingContext) { if (args.ArgumentDataType == LookupArguments.LookupArgumentDataType.ExcelRange) { return(new ExcelLookupNavigator(direction, args, parsingContext)); } else if (args.ArgumentDataType == LookupArguments.LookupArgumentDataType.DataArray) { return(new ArrayLookupNavigator(direction, args, parsingContext)); } throw new NotSupportedException("Invalid argument datatype"); }
/// <summary> /// The create type name from token ast. /// </summary> /// <param name="parsingcontext"> /// </param> /// <param name="node"> /// </param> protected static void CreateTypeNameFromTokenAst(ParsingContext parsingcontext, ParseTreeNode node) { CreateTypeFromTokenAst <TypeName>(parsingcontext, node); }
public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { var result = System.Math.Round((double)System.Math.PI, 14); return(CreateResult(result, DataType.Decimal)); }
/// <summary> /// The create rank specifier ast. /// </summary> /// <param name="parsingcontext"> /// </param> /// <param name="node"> /// </param> protected static void CreateRankSpecifierAst(ParsingContext parsingcontext, ParseTreeNode node) { // [0] [1] [2] // "[" + expression + "]"; node.AstNode = node.ChildNodes[1].AstNode; }
/// <summary> /// The create variable group raw ast. /// </summary> /// <param name="parsingContext"> /// </param> /// <param name="node"> /// </param> protected static void CreateVariableGroupRawAst(ParsingContext parsingContext, ParseTreeNode node) { var var = Ast <Variable>(node); //// [0] [1] // declaration_specifiers + variable_declarator_list.Q() + ";"; var declarationSpecifiers = (Tuple <Qualifier, TypeBase>)node.ChildNodes[0].AstNode; var.Qualifiers = declarationSpecifiers.Item1; var.Type = declarationSpecifiers.Item2; var declarators = GetOptional <List <Variable> >(node.ChildNodes[1]); if (declarators != null) { var.SubVariables = declarators; // Update array type for sub variables foreach (var subVariable in declarators) { if (subVariable.Type is ArrayType) { ((ArrayType)subVariable.Type).Type = var.Type; } else { subVariable.Type = var.Type; } } } // If this is a variable group, check if we can transform it to a single variable declaration. if (var.IsGroup) { // If the variable is a single variable declaration, replace the group if (var.SubVariables.Count == 1) { var subVariable = var.SubVariables[0]; subVariable.MergeFrom(var); node.AstNode = subVariable; } } else { // If variable declarators is 0, check if this is a named struct var.Type.Qualifiers = var.Qualifiers; if (var.Type is StructType) { node.AstNode = var.Type; } else if (var.Type is InterfaceType) { node.AstNode = var.Type; } else if (var.Type is ClassType) { node.AstNode = var.Type; } else { parsingContext.AddParserError("Expecting identifier for variable declaration [{0}]", var.Type); } if (var.Type.Name == null) { parsingContext.AddParserError("Cannot declare anonymous type at the top level"); } } }
/// <summary> /// The create method declaration ast. /// </summary> /// <param name="context"> /// </param> /// <param name="node"> /// </param> protected static void CreateMethodDeclarationAst(ParsingContext context, ParseTreeNode node) { //// method_declaration_raw + ";"; node.AstNode = node.ChildNodes[0].AstNode; }
/// <summary> /// The create type name ast. /// </summary> /// <param name="parsingcontext"> /// </param> /// <param name="node"> /// </param> protected static void CreateTypeNameAst(ParsingContext parsingcontext, ParseTreeNode node) { var value = Ast <TypeName>(node); value.Name = (Identifier)node.ChildNodes[0].AstNode; }
/// <summary> /// The create identifier list ast. /// </summary> /// <param name="parsingcontext"> /// </param> /// <param name="node"> /// </param> protected static void CreateIdentifierListAst(ParsingContext parsingcontext, ParseTreeNode node) { var identifiers = Ast <List <Identifier> >(node); FillListFromNodes(node.ChildNodes, identifiers); }
protected static void CreateQualifiersAst(ParsingContext context, ParseTreeNode node) { node.AstNode = CollectQualifiers(node.ChildNodes[0]); }
/// <summary> /// The create declaration statement ast. /// </summary> /// <param name="context"> /// </param> /// <param name="node"> /// </param> protected static void CreateDeclarationStatementAst(ParsingContext context, ParseTreeNode node) { var declarationStatement = Ast <DeclarationStatement>(node); declarationStatement.Content = (Node)node.ChildNodes[0].AstNode; }
/// <summary> /// The create literal expression ast. /// </summary> /// <param name="parsingcontext"> /// </param> /// <param name="node"> /// </param> protected static void CreateLiteralExpressionAst(ParsingContext parsingcontext, ParseTreeNode node) { var value = Ast <LiteralExpression>(node); value.Literal = (Literal)node.ChildNodes[0].AstNode; }
public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 1); var val = ArgToDecimal(arguments, 0); if (val < 0) { val *= -1; } return(CreateResult(val, DataType.Decimal)); }
protected static void CreateEmptyStatementAst(ParsingContext context, ParseTreeNode node) { Ast <EmptyStatement>(node); }
public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 2); var val1 = arguments.ElementAt(0).ValueFirst; var val2 = arguments.ElementAt(1).ValueFirst; if (val1 == null && val2 == null) { return(CreateResult(true, DataType.Boolean)); } else if ((val1 == null && val2 != null) || (val1 != null && val2 == null)) { return(CreateResult(false, DataType.Boolean)); } var result = string.Compare(val1.ToString(), val2.ToString(), StringComparisonEx.InvariantCulture); return(CreateResult(result == 0, DataType.Boolean)); }
/// <summary> /// The create assignment operator. /// </summary> /// <param name="parsingContext"> /// </param> /// <param name="node"> /// </param> protected static void CreateAssignmentOperator(ParsingContext parsingContext, ParseTreeNode node) { node.AstNode = AssignmentOperatorHelper.FromString(node.ChildNodes[0].Token.Text); }
public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 2); var number = ArgToDecimal(arguments, 0); var power = ArgToDecimal(arguments, 1); var result = System.Math.Pow(number, power); return(CreateResult(result, DataType.Decimal)); }
internal override IParsingResult Parse(ParsingContext context) { return(Parsers.MangledName.Parse(context)); }
public virtual IEnumerable <string> GetReferencedAddresses(string cellFormula, ParsingContext context) { var resultCells = new List <string>(); var r = context.Configuration.Lexer.Tokenize(cellFormula, context.Scopes.Current.Address.Worksheet); var toAddresses = r.Where(x => x.TokenTypeIsSet(TokenType.ExcelAddress)); foreach (var toAddress in toAddresses) { var rangeAddress = context.RangeAddressFactory.Create(toAddress.Value); var rangeCells = new List <string>(); if (rangeAddress.FromRow < rangeAddress.ToRow || rangeAddress.FromCol < rangeAddress.ToCol) { for (var col = rangeAddress.FromCol; col <= rangeAddress.ToCol; col++) { for (var row = rangeAddress.FromRow; row <= rangeAddress.ToRow; row++) { resultCells.Add(context.RangeAddressFactory.Create(col, row).Address); } } } else { rangeCells.Add(toAddress.Value); } resultCells.AddRange(rangeCells); } return(resultCells); }
/// <summary> /// Calculate the Arccosine of a given input. /// </summary> /// <param name="arguments">Input to have its Arccosine calculated.</param> /// <param name="context">Unused, this is information about where the function is being executed.</param> /// <returns>Returns the Arccosine of a number.</returns> public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { if (this.ArgumentCountIsValid(arguments, 1) == false) { return(new CompileResult(eErrorType.Value)); } var argument = arguments.First().Value; if (!ConvertUtil.TryParseObjectToDecimal(argument, out double result)) { return(new CompileResult(eErrorType.Value)); } return(this.CreateResult(System.Math.Acos(result), DataType.Decimal)); }