/// Implements <Query> ::= SELECT <TypeIdentifier> WHERE <Expression> public Reduction CreateRULE_QUERY_SELECT_WHERE(Reduction reduction) { //selectType can be one of the following depending on the query text: - //1. A plain string that is the name of Type; we can build IsOfTypePredicate from this. //2. AggregateFunctionPredicate that has IsOfTypePredicate set as its ChildPredicate // cant be this, grammer changed //3. IsOfTypePredicate object selectType = ((Reduction)reduction.GetToken(1).Data).Tag; Predicate lhs = null; Predicate rhs = (Predicate)((Reduction)reduction.GetToken(3).Data).Tag; Predicate selectTypePredicate = selectType as Predicate; Predicate result = null; //1. selectType is string if (selectTypePredicate == null) { lhs = new IsOfTypePredicate(selectType.ToString()); result = ExpressionBuilder.CreateLogicalAndPredicate(lhs, rhs); } ////2. selectType is AggregateFunctionPredicate //3. selectType is IsOfTypePredicate else { lhs = selectTypePredicate; result = ExpressionBuilder.CreateLogicalAndPredicate(lhs, rhs); } reduction.Tag = result; if (NCacheLog.IsInfoEnabled) NCacheLog.Info("CreateRULE_QUERY_SELECT_WHERE"); return null; }
public ParseMessage Parse(string query) { NCQLParser parser = new NCQLParser(ResourceName, _ncacheLog); System.IO.TextReader tr = new System.IO.StringReader(query); ParseMessage message = parser.Parse(tr, true); _currentReduction = parser.CurrentReduction; return message; }
/// Pops the specified number of tokens from the stack and adds them /// to the specified <c>Reduction</c>. public void PopTokensInto(Reduction p_reduction, int p_count) { int start = m_items.Count - p_count; int end = m_items.Count; for (int i = start; i < end; i++) p_reduction.AddToken((Token)m_items[i]); m_items.RemoveRange(start, p_count); }
/// Pops the specified number of tokens from the stack and adds them /// to the specified <c>Reduction</c>. public void PopTokensInto(Reduction p_reduction, int p_count) { int start = m_items.Count - p_count; int end = m_items.Count; for (int i = start; i < end; i++) { p_reduction.AddToken((Token)m_items[i]); } m_items.RemoveRange(start, p_count); }
/// Implements <Query> ::= SELECT <TypeIdentifier> public Reduction CreateRULE_QUERY_SELECT(Reduction reduction) { object selectType = ((Reduction)((Token)reduction.GetToken(1)).Data).Tag; Predicate selectTypePredicate = selectType as Predicate; if (selectTypePredicate == null) reduction.Tag = new IsOfTypePredicate(selectType.ToString()); else reduction.Tag = selectTypePredicate; if(NCacheLog.IsInfoEnabled) NCacheLog.Info("CreateRULE_QUERY_SELECT"); return null; }
/// <summary>Produces a reduction.</summary> /// <remarks>Removes as many tokens as members in the rule and pushes a /// non-terminal token.</remarks> private ParseResult Reduce(Rule p_rule) { ParseResult result; Token head; if (m_trimReductions && p_rule.ContainsOneNonTerminal) { // The current rule only consists of a single nonterminal and can be trimmed from the // parse tree. Usually we create a new Reduction, assign it to the Data property // of Head and push it on the stack. However, in this case, the Data property of the // Head will be assigned the Data property of the reduced token (i.e. the only one // on the stack). In this case, to save code, the value popped of the stack is changed // into the head. head = m_tempStack.PopToken(); head.SetParent(p_rule.RuleNonTerminal); result = ParseResult.ReduceEliminated; } else { Reduction reduction = new Reduction(); reduction.ParentRule = p_rule; m_tempStack.PopTokensInto(reduction, p_rule.SymbolCount); head = new Token(); head.Data = reduction; head.SetParent(p_rule.RuleNonTerminal); m_haveReduction = true; result = ParseResult.ReduceNormal; } int index = m_tempStack.PeekToken().State; LRAction action = m_LalrTables[index].GetActionForSymbol(p_rule.RuleNonTerminal.TableIndex); if (action != null) { head.State = m_LalrState = action.Value;; m_tempStack.PushToken(head); } else { throw new ParserException("Action for LALR state is null"); } return(result); }
/// Implements <CompareExpr> ::= <Value> Type Plus Attribute DOT public Reduction CreateRULE_TYPEPLUSATTRIBUTE_DOT(Reduction reduction) { return null; }
/// Implements <CompareExpr> ::= <Value> Property Identifier public Reduction CreateRULE_PROPERTY_IDENTIFIER(Reduction reduction) { return CreateRULE_OBJECTTYPE_IDENTIFIER(reduction); }
/// Implements <CompareExpr> ::= <Value> ObjectType public Reduction CreateRULE_OBJECTTYPE(Reduction reduction) { return null; }
/// Implements <StrLiteralList> ::= <StrLiteral> ',' <StrLiteralList> public Reduction CreateRULE_STRLITERALLIST_COMMA(Reduction reduction) { return CreateInclusionList(reduction); }
/// Implements <Identifier> ::= Identifier public Reduction CreateRULE_IDENTIFIER_IDENTIFIER(Reduction reduction) { reduction.Tag = ((Token)reduction.GetToken(0)).Data.ToString(); if(NCacheLog.IsInfoEnabled) NCacheLog.Info("RULE_IDENTIFIER_IDENTIFIER -> " + reduction.Tag); return null; }
///Implements <ObjectAttribute> ::= Keyword '.' Identifier public Reduction CreateRULE_OBJECTATTRIBUTE_KEYWORD_DOT_IDENTIFIER(Reduction reduction) { return CreateRULE_OBJECTVALUE_KEYWORD_DOT_IDENTIFIER(reduction); }
/// Implements <CompareExpr> ::= <Value> COUNT Function COUNT LParan RParan public Reduction CreateRULE_COUNTFUNCTION_COUNTLPARAN_RPARAN(Reduction reduction) { return CreateRULE_COUNTFUNCTION_COUNTLPARAN_TIMES_RPARAN(reduction); }
public Reduction CreateRULE_DELETEPARAMS_DOLLARTEXTDOLLAR(Reduction reduction) { reduction.Tag = "System.String"; if (NCacheLog.IsInfoEnabled) NCacheLog.Info("CreateRULE_OBJECTTYPE_DOLLARTEXTDOLLAR"); return null; }
public Reduction CreateRULE_OBJECTVALUE_KEYWORD_DOT_IDENTIFIER(Reduction reduction) { if(NCacheLog.IsInfoEnabled) NCacheLog.Info("RULE_OBJECTVALUE_KEYWORD_DOT_IDENTIFIER"); string memName = reduction.GetToken(2).Data.ToString(); reduction.Tag = new MemberFunction(memName); return null; }
public Reduction CreateRULE_DATE_DATETIME_LPARAN_STRINGLITERAL_RPARAN(Reduction reduction) { if(NCacheLog.IsInfoEnabled) NCacheLog.Info("RULE_DATE_DATETIME_LPARAN_STRINGLITERAL_RPARAN"); string dateTime = reduction.GetToken(2).Data.ToString().Trim('\''); reduction.Tag = new DateTimeConstantValue(dateTime); return null; }
//self create //========================= public Reduction CreateRULE_ATRRIB(Reduction reduction) { if(NCacheLog.IsInfoEnabled) NCacheLog.Info("CreateRULE_ATRRIB"); reduction.Tag = ((Reduction)((Token)reduction.GetToken(0)).Data).Tag; return null; }
/// Implements <DateList> ::= <Date> ',' <DateList> public Reduction CreateRULE_DATELIST_COMMA(Reduction reduction) { return CreateInclusionList(reduction); }
///Implements <Query> ::= SELECT <AggregateFunction> public Reduction CreateRULE_QUERY_SELECT2(Reduction reduction) { return CreateRULE_QUERY_SELECT(reduction); }
/// Implements <CompareExpr> ::= <Value> Aggregate Function5 public Reduction CreateRULE_AGGREGATEFUNCTION5(Reduction reduction) { return null; }
/// Implements <InList> ::= '(' <ListType> ')' public Reduction CreateRULE_INLIST_LPARAN_RPARAN(Reduction reduction) { if(NCacheLog.IsInfoEnabled) NCacheLog.Info("CreateRULE_INLIST_LPARAN_RPARAN"); object obj = ((Reduction)((Token)reduction.GetToken(1)).Data).Tag; if (obj is ConstantValue || obj is RuntimeValue) { IsInListPredicate pred = new IsInListPredicate(); pred.Append(obj); reduction.Tag = pred; } else { reduction.Tag = ((Reduction)((Token)reduction.GetToken(1)).Data).Tag; } return null; }
/// Implements <CountFunction> ::= 'COUNT(' <Property> ')' public Reduction CreateRULE_COUNTFUNCTION_COUNTLPARAN_TIMES_RPARAN(Reduction reduction) { string typeName = ((Reduction)reduction.GetToken(1).Data).Tag as string; Predicate childPredicate = new IsOfTypePredicate(typeName); AggregateFunctionPredicate countFunctionPredicate = ExpressionBuilder.CreateCountFunctionPredicate() as AggregateFunctionPredicate; countFunctionPredicate.ChildPredicate = childPredicate; reduction.Tag = countFunctionPredicate; return null; }
//======================== public Reduction CreateInclusionList(Reduction reduction) { object tag = ((Reduction)reduction.GetToken(2).Data).Tag; IsInListPredicate inc = null; if(tag is IsInListPredicate) inc = tag as IsInListPredicate; else { inc = new IsInListPredicate(); inc.Append(tag); } inc.Append(((Reduction)reduction.GetToken(0).Data).Tag); reduction.Tag = inc; return null; }
private Reduction CreateNewObject(Reduction reduction) { Reduction result = null; switch((RuleConstants)Enum.ToObject(typeof(RuleConstants), reduction.ParentRule.TableIndex)) { case RuleConstants.RULE_QUERY_SELECT : ////<Query> ::= SELECT <ObjectType> result = _parserRule.CreateRULE_QUERY_SELECT(reduction); break; case RuleConstants.RULE_QUERY_SELECT_WHERE : ////<Query> ::= SELECT <ObjectType> WHERE <Expression> result = _parserRule.CreateRULE_QUERY_SELECT_WHERE(reduction); break; case RuleConstants.RULE_QUERY_SELECT2 : ////<Query> ::= SELECT <AggregateFunction> result = _parserRule.CreateRULE_QUERY_SELECT2(reduction); break; case RuleConstants.RULE_QUERY_SELECT_WHERE2 : ////<Query> ::= SELECT <AggregateFunction> WHERE <Expression> result = _parserRule.CreateRULE_QUERY_SELECT_WHERE2(reduction); break; case RuleConstants.RULE_EXPRESSION : ////<Expression> ::= <OrExpr> result = _parserRule.CreateRULE_EXPRESSION(reduction); break; case RuleConstants.RULE_OREXPR_OR : ////<OrExpr> ::= <OrExpr> OR <AndExpr> result = _parserRule.CreateRULE_OREXPR_OR(reduction); break; case RuleConstants.RULE_OREXPR : ////<OrExpr> ::= <AndExpr> result = _parserRule.CreateRULE_OREXPR(reduction); break; case RuleConstants.RULE_ANDEXPR_AND : ////<AndExpr> ::= <AndExpr> AND <UnaryExpr> result = _parserRule.CreateRULE_ANDEXPR_AND(reduction); break; case RuleConstants.RULE_ANDEXPR : ////<AndExpr> ::= <UnaryExpr> result = _parserRule.CreateRULE_ANDEXPR(reduction); break; case RuleConstants.RULE_UNARYEXPR_NOT : ////<UnaryExpr> ::= NOT <CompareExpr> result = _parserRule.CreateRULE_UNARYEXPR_NOT(reduction); break; case RuleConstants.RULE_UNARYEXPR : ////<UnaryExpr> ::= <CompareExpr> result = _parserRule.CreateRULE_UNARYEXPR(reduction); break; case RuleConstants.RULE_COMPAREEXPR_EQ : ////<CompareExpr> ::= <Atrrib> '=' <Value> result = _parserRule.CreateRULE_COMPAREEXPR_EQ(reduction); break; case RuleConstants.RULE_COMPAREEXPR_EXCLAMEQ : ////<CompareExpr> ::= <Atrrib> '!=' <Value> result = _parserRule.CreateRULE_COMPAREEXPR_EXCLAMEQ(reduction); break; case RuleConstants.RULE_COMPAREEXPR_EQEQ : ////<CompareExpr> ::= <Atrrib> '==' <Value> result = _parserRule.CreateRULE_COMPAREEXPR_EQEQ(reduction); break; case RuleConstants.RULE_COMPAREEXPR_LTGT : ////<CompareExpr> ::= <Atrrib> '<>' <Value> result = _parserRule.CreateRULE_COMPAREEXPR_LTGT(reduction); break; case RuleConstants.RULE_COMPAREEXPR_LT : ////<CompareExpr> ::= <Atrrib> '<' <Value> result = _parserRule.CreateRULE_COMPAREEXPR_LT(reduction); break; case RuleConstants.RULE_COMPAREEXPR_GT : ////<CompareExpr> ::= <Atrrib> '>' <Value> result = _parserRule.CreateRULE_COMPAREEXPR_GT(reduction); break; case RuleConstants.RULE_COMPAREEXPR_LTEQ : ////<CompareExpr> ::= <Atrrib> '<=' <Value> result = _parserRule.CreateRULE_COMPAREEXPR_LTEQ(reduction); break; case RuleConstants.RULE_COMPAREEXPR_GTEQ : ////<CompareExpr> ::= <Atrrib> '>=' <Value> result = _parserRule.CreateRULE_COMPAREEXPR_GTEQ(reduction); break; case RuleConstants.RULE_COMPAREEXPR_LIKE_STRINGLITERAL : ////<CompareExpr> ::= <Atrrib> LIKE StringLiteral result = _parserRule.CreateRULE_COMPAREEXPR_LIKE_STRINGLITERAL(reduction); break; case RuleConstants.RULE_COMPAREEXPR_LIKE_QUESTION : ////<CompareExpr> ::= <Atrrib> LIKE '?' result = _parserRule.CreateRULE_COMPAREEXPR_LIKE_QUESTION(reduction); break; case RuleConstants.RULE_COMPAREEXPR_NOT_LIKE_STRINGLITERAL : ////<CompareExpr> ::= <Atrrib> NOT LIKE StringLiteral result = _parserRule.CreateRULE_COMPAREEXPR_NOT_LIKE_STRINGLITERAL(reduction); break; case RuleConstants.RULE_COMPAREEXPR_NOT_LIKE_QUESTION : ////<CompareExpr> ::= <Atrrib> NOT LIKE '?' result = _parserRule.CreateRULE_COMPAREEXPR_NOT_LIKE_QUESTION(reduction); break; case RuleConstants.RULE_COMPAREEXPR_IN : ////<CompareExpr> ::= <Atrrib> IN <InList> result = _parserRule.CreateRULE_COMPAREEXPR_IN(reduction); break; case RuleConstants.RULE_COMPAREEXPR_NOT_IN : ////<CompareExpr> ::= <Atrrib> NOT IN <InList> result = _parserRule.CreateRULE_COMPAREEXPR_NOT_IN(reduction); break; case RuleConstants.RULE_COMPAREEXPR_IS_NULL : ////<CompareExpr> ::= <Atrrib> IS NULL result = _parserRule.CreateRULE_COMPAREEXPR_IS_NULL(reduction); break; case RuleConstants.RULE_COMPAREEXPR_IS_NOT_NULL : ////<CompareExpr> ::= <Atrrib> IS NOT NULL result = _parserRule.CreateRULE_COMPAREEXPR_IS_NOT_NULL(reduction); break; case RuleConstants.RULE_COMPAREEXPR_LPARAN_RPARAN : ////<CompareExpr> ::= '(' <Expression> ')' result = _parserRule.CreateRULE_COMPAREEXPR_LPARAN_RPARAN(reduction); break; case RuleConstants.RULE_ATRRIB : ////<Atrrib> ::= <ObjectValue> result = _parserRule.CreateRULE_ATRRIB(reduction); break; case RuleConstants.RULE_VALUE_MINUS : ////<Value> ::= '-' <NumLiteral> result = _parserRule.CreateRULE_VALUE_MINUS(reduction); break; case RuleConstants.RULE_VALUE : ////<Value> ::= <NumLiteral> result = _parserRule.CreateRULE_VALUE(reduction); break; case RuleConstants.RULE_VALUE2 : ////<Value> ::= <StrLiteral> result = _parserRule.CreateRULE_VALUE2(reduction); break; case RuleConstants.RULE_VALUE_TRUE : ////<Value> ::= true result = _parserRule.CreateRULE_VALUE_TRUE(reduction); break; case RuleConstants.RULE_VALUE_FALSE : ////<Value> ::= false result = _parserRule.CreateRULE_VALUE_FALSE(reduction); break; case RuleConstants.RULE_VALUE3 : ////<Value> ::= <Date> result = _parserRule.CreateRULE_VALUE3(reduction); break; case RuleConstants.RULE_DATE_DATETIME_DOT_NOW : ////<Date> ::= DateTime '.' now result = _parserRule.CreateRULE_DATE_DATETIME_DOT_NOW(reduction); break; case RuleConstants.RULE_DATE_DATETIME_LPARAN_STRINGLITERAL_RPARAN : ////<Date> ::= DateTime '(' StringLiteral ')' result = _parserRule.CreateRULE_DATE_DATETIME_LPARAN_STRINGLITERAL_RPARAN(reduction); break; case RuleConstants.RULE_STRLITERAL_STRINGLITERAL : ////<StrLiteral> ::= StringLiteral result = _parserRule.CreateRULE_STRLITERAL_STRINGLITERAL(reduction); break; case RuleConstants.RULE_STRLITERAL_NULL : ////<StrLiteral> ::= NULL result = _parserRule.CreateRULE_STRLITERAL_NULL(reduction); break; case RuleConstants.RULE_STRLITERAL_QUESTION : ////<StrLiteral> ::= '?' result = _parserRule.CreateRULE_STRLITERAL_QUESTION(reduction); break; case RuleConstants.RULE_NUMLITERAL_INTEGERLITERAL : ////<NumLiteral> ::= IntegerLiteral result = _parserRule.CreateRULE_NUMLITERAL_INTEGERLITERAL(reduction); break; case RuleConstants.RULE_NUMLITERAL_REALLITERAL : ////<NumLiteral> ::= RealLiteral result = _parserRule.CreateRULE_NUMLITERAL_REALLITERAL(reduction); break; case RuleConstants.RULE_OBJECTTYPE_TIMES : ////<ObjectType> ::= '*' result = _parserRule.CreateRULE_OBJECTTYPE_TIMES(reduction); break; case RuleConstants.RULE_OBJECTTYPE_DOLLARTEXTDOLLAR : ////<ObjectType> ::= '$Text$' result = _parserRule.CreateRULE_OBJECTTYPE_DOLLARTEXTDOLLAR(reduction); break; case RuleConstants.RULE_OBJECTTYPE : ////<ObjectType> ::= <Property> result = _parserRule.CreateRULE_OBJECTTYPE(reduction); break; case RuleConstants.RULE_OBJECTATTRIBUTE_IDENTIFIER : ////<ObjectAttribute> ::= Identifier result = _parserRule.CreateRULE_OBJECTATTRIBUTE_IDENTIFIER(reduction); break; case RuleConstants.RULE_DELETEPARAMS_DOLLARTEXTDOLLAR : ////<DeleteParams> ::= '$Text$' result = _parserRule.CreateRULE_DELETEPARAMS_DOLLARTEXTDOLLAR(reduction); break; case RuleConstants.RULE_DELETEPARAMS : ////<DeleteParams> ::= <Property> result = _parserRule.CreateRULE_DELETEPARAMS(reduction); break; case RuleConstants.RULE_PROPERTY_DOT_IDENTIFIER : ////<Property> ::= <Property> '.' Identifier result = _parserRule.CreateRULE_PROPERTY_DOT_IDENTIFIER(reduction); break; case RuleConstants.RULE_PROPERTY_IDENTIFIER : ////<Property> ::= Identifier result = _parserRule.CreateRULE_PROPERTY_IDENTIFIER(reduction); break; case RuleConstants.RULE_TYPEPLUSATTRIBUTE_DOT : ////<TypePlusAttribute> ::= <Property> '.' <ObjectAttribute> result = _parserRule.CreateRULE_TYPEPLUSATTRIBUTE_DOT(reduction); break; case RuleConstants.RULE_AGGREGATEFUNCTION : ////<AggregateFunction> ::= <SumFunction> result = _parserRule.CreateRULE_AGGREGATEFUNCTION(reduction); break; case RuleConstants.RULE_AGGREGATEFUNCTION2 : ////<AggregateFunction> ::= <CountFunction> result = _parserRule.CreateRULE_AGGREGATEFUNCTION2(reduction); break; case RuleConstants.RULE_AGGREGATEFUNCTION3 : ////<AggregateFunction> ::= <MinFunction> result = _parserRule.CreateRULE_AGGREGATEFUNCTION3(reduction); break; case RuleConstants.RULE_AGGREGATEFUNCTION4 : ////<AggregateFunction> ::= <MaxFunction> result = _parserRule.CreateRULE_AGGREGATEFUNCTION4(reduction); break; case RuleConstants.RULE_AGGREGATEFUNCTION5 : ////<AggregateFunction> ::= <AverageFunction> result = _parserRule.CreateRULE_AGGREGATEFUNCTION5(reduction); break; case RuleConstants.RULE_SUMFUNCTION_SUMLPARAN_RPARAN : ////<SumFunction> ::= 'SUM(' <TypePlusAttribute> ')' result = _parserRule.CreateRULE_SUMFUNCTION_SUMLPARAN_RPARAN(reduction); break; case RuleConstants.RULE_COUNTFUNCTION_COUNTLPARAN_RPARAN : ////<CountFunction> ::= 'COUNT(' <Property> ')' result = _parserRule.CreateRULE_COUNTFUNCTION_COUNTLPARAN_RPARAN(reduction); break; case RuleConstants.RULE_MINFUNCTION_MINLPARAN_RPARAN : ////<MinFunction> ::= 'MIN(' <TypePlusAttribute> ')' result = _parserRule.CreateRULE_MINFUNCTION_MINLPARAN_RPARAN(reduction); break; case RuleConstants.RULE_MAXFUNCTION_MAXLPARAN_RPARAN : ////<MaxFunction> ::= 'MAX(' <TypePlusAttribute> ')' result = _parserRule.CreateRULE_MAXFUNCTION_MAXLPARAN_RPARAN(reduction); break; case RuleConstants.RULE_AVERAGEFUNCTION_AVGLPARAN_RPARAN : ////<AverageFunction> ::= 'AVG(' <TypePlusAttribute> ')' result = _parserRule.CreateRULE_AVERAGEFUNCTION_AVGLPARAN_RPARAN(reduction); break; case RuleConstants.RULE_OBJECTATTRIBUTE_KEYWORD_DOT_IDENTIFIER : ////<ObjectAttribute> ::= Keyword '.' Identifier result = _parserRule.CreateRULE_OBJECTATTRIBUTE_KEYWORD_DOT_IDENTIFIER(reduction); break; case RuleConstants.RULE_OBJECTVALUE_KEYWORD_DOT_IDENTIFIER : ////<ObjectValue> ::= Keyword '.' Identifier result = _parserRule.CreateRULE_OBJECTVALUE_KEYWORD_DOT_IDENTIFIER(reduction); break; case RuleConstants.RULE_INLIST_LPARAN_RPARAN : ////<InList> ::= '(' <ListType> ')' result = _parserRule.CreateRULE_INLIST_LPARAN_RPARAN(reduction); break; case RuleConstants.RULE_LISTTYPE : ////<ListType> ::= <NumLiteralList> result = _parserRule.CreateRULE_LISTTYPE(reduction); break; case RuleConstants.RULE_LISTTYPE2 : ////<ListType> ::= <StrLiteralList> result = _parserRule.CreateRULE_LISTTYPE2(reduction); break; case RuleConstants.RULE_LISTTYPE3 : ////<ListType> ::= <DateList> result = _parserRule.CreateRULE_LISTTYPE3(reduction); break; case RuleConstants.RULE_NUMLITERALLIST_COMMA : ////<NumLiteralList> ::= <NumLiteral> ',' <NumLiteralList> result = _parserRule.CreateRULE_NUMLITERALLIST_COMMA(reduction); break; case RuleConstants.RULE_NUMLITERALLIST : ////<NumLiteralList> ::= <NumLiteral> result = _parserRule.CreateRULE_NUMLITERALLIST(reduction); break; case RuleConstants.RULE_STRLITERALLIST_COMMA : ////<StrLiteralList> ::= <StrLiteral> ',' <StrLiteralList> result = _parserRule.CreateRULE_STRLITERALLIST_COMMA(reduction); break; case RuleConstants.RULE_STRLITERALLIST : ////<StrLiteralList> ::= <StrLiteral> result = _parserRule.CreateRULE_STRLITERALLIST(reduction); break; case RuleConstants.RULE_DATELIST_COMMA : ////<DateList> ::= <Date> ',' <DateList> result = _parserRule.CreateRULE_DATELIST_COMMA(reduction); break; case RuleConstants.RULE_DATELIST : ////<DateList> ::= <Date> result = _parserRule.CreateRULE_DATELIST(reduction); break; } if (result == null) result = reduction; return result; }
/// Implements <Identifier> ::= Keyword public Reduction CreateRULE_IDENTIFIER_KEYWORD(Reduction reduction) { reduction.Tag = ((Token)reduction.GetToken(0)).Data; if(NCacheLog.IsInfoEnabled) NCacheLog.Info("RULE_IDENTIFIER_KEYWORD -> " + reduction.Tag); return null; }
/// Implements <Property> ::= <Identifier> public Reduction CreateRULE_PROPERTY(Reduction reduction) { if(NCacheLog.IsInfoEnabled) NCacheLog.Info("CreateRULE_PROPERTY"); reduction.Tag = ((Token)reduction.GetToken(0)).Data; return null; }
/// Implements <AverageFunction> ::= 'AVG(' <TypePlusAttribute> ')' public Reduction CreateRULE_AVERAGEFUNCTION_AVGLPARAN_RPARAN(Reduction reduction) { Reduction typePlusAttributeReduction = (Reduction)reduction.GetToken(1).Data; string typeName = ((Reduction)typePlusAttributeReduction.GetToken(0).Data).Tag as string; string memberName = ((Reduction)typePlusAttributeReduction.GetToken(2).Data).Tag as string; Predicate childPredicate = new IsOfTypePredicate(typeName); AggregateFunctionPredicate avgFunctionPredicate = ExpressionBuilder.CreateAverageFunctionPredicate(memberName) as AggregateFunctionPredicate; avgFunctionPredicate.ChildPredicate = childPredicate; reduction.Tag = avgFunctionPredicate; return null; }
/// Implements <NumLiteralList> ::= <NumLiteral> public Reduction CreateRULE_NUMLITERALLIST(Reduction reduction) { if(NCacheLog.IsInfoEnabled) NCacheLog.Info("CreateRULE_NUMLITERALLIST"); IsInListPredicate pred = new IsInListPredicate(); pred.Append(((Reduction)reduction.GetToken(0).Data).Tag); reduction.Tag = pred; return null; }
/// <summary>Produces a reduction.</summary> /// <remarks>Removes as many tokens as members in the rule and pushes a /// non-terminal token.</remarks> private ParseResult Reduce(Rule p_rule) { ParseResult result; Token head; if (m_trimReductions && p_rule.ContainsOneNonTerminal) { // The current rule only consists of a single nonterminal and can be trimmed from the // parse tree. Usually we create a new Reduction, assign it to the Data property // of Head and push it on the stack. However, in this case, the Data property of the // Head will be assigned the Data property of the reduced token (i.e. the only one // on the stack). In this case, to save code, the value popped of the stack is changed // into the head. head = m_tempStack.PopToken(); head.SetParent(p_rule.RuleNonTerminal); result = ParseResult.ReduceEliminated; } else { Reduction reduction = new Reduction(); reduction.ParentRule = p_rule; m_tempStack.PopTokensInto(reduction, p_rule.SymbolCount); head = new Token(); head.Data = reduction; head.SetParent(p_rule.RuleNonTerminal); m_haveReduction = true; result = ParseResult.ReduceNormal; } int index = m_tempStack.PeekToken().State; LRAction action = m_LalrTables[index].GetActionForSymbol(p_rule.RuleNonTerminal.TableIndex); if (action != null) { head.State = m_LalrState = action.Value;; m_tempStack.PushToken(head); } else throw new ParserException("Action for LALR state is null"); return result; }
public Reduction CreateRULE_DELETEPARAMS(Reduction reduction) { return null; }
/// <summary> /// Adds the query to the PreparedQueryTable. This method also does the eviction /// if PreparedQueryTable count is greater than eviction ratio. /// This method is only called from GetPreparedReduction(string). /// </summary> /// <param name="query">The query to add in the table.</param> /// <param name="currentReduction">The successful query result in the form of Reduction.</param> private void AddPreparedReduction(string query, Reduction currentReduction) { _preparedQueryTable.Add(new QueryIdentifier(query), currentReduction); if (_preparedQueryTable.Count > _preparedQueryTableSize) { ArrayList list = new ArrayList(_preparedQueryTable.Keys); list.Sort(); int evictCount = (_preparedQueryTable.Count * _preparedQueryEvictionPercentage) / 100; for (int i = 0; i < evictCount; i++) _preparedQueryTable.Remove(list[i]); } }
/// Implements <CompareExpr> ::= <Value> NOT LIKE Question public Reduction CreateRULE_COMPAREEXPR_NOT_LIKE_QUESTION(Reduction reduction) { return CreateRULE_COMPAREEXPR_NOT_LIKE_STRINGLITERAL(reduction); }