public static ExprDeclaredNodeImpl GetExistsDeclaredExpr( IContainer container, String name, IList <ExprNode> parameters, ICollection <ExpressionDeclItem> expressionDeclarations, ExprDeclaredService exprDeclaredService, ContextDescriptor contextDescriptor) { // Find among local expressions if (expressionDeclarations.IsNotEmpty()) { foreach (ExpressionDeclItem declNode in expressionDeclarations) { if (declNode.Name.Equals(name)) { return(new ExprDeclaredNodeImpl( container, declNode, parameters, contextDescriptor)); } } } // find among global expressions ExpressionDeclItem found = exprDeclaredService.GetExpression(name); if (found != null) { return(new ExprDeclaredNodeImpl( container, found, parameters, contextDescriptor)); } return(null); }
public ExprDeclaredNodeImpl( ExpressionDeclItem prototype, IList<ExprNode> chainParameters, ContextCompileTimeDescriptor contextDescriptor, ExprNode expressionBodyCopy) { PrototypeWVisibility = prototype; ChainParameters = chainParameters; ExpressionBodyCopy = expressionBodyCopy; // replace context-properties where they are currently identifiers if (contextDescriptor == null) { return; } var visitorWParent = new ExprNodeIdentVisitorWParent(); expressionBodyCopy.Accept(visitorWParent); foreach (var pair in visitorWParent.IdentNodes) { var streamOrProp = pair.Second.StreamOrPropertyName; if (streamOrProp != null && contextDescriptor.ContextPropertyRegistry.IsContextPropertyPrefix(streamOrProp)) { var context = new ExprContextPropertyNodeImpl(pair.Second.UnresolvedPropertyName); if (pair.First == null) { ExpressionBodyCopy = context; } else { ExprNodeUtilityModify.ReplaceChildNode(pair.First, pair.Second, context); } } } }
public ExpressionDeclItem Resolve(string name) { // try self-originated protected types first ExpressionDeclItem localExpr = _locals.Expressions.Get(name); if (localExpr != null) { return localExpr; } try { var expression = _path.GetAnyModuleExpectSingle(name, _moduleUses); if (expression != null) { if (!_isFireAndForget && !NameAccessModifierExtensions.Visible( expression.First.Visibility, expression.First.ModuleName, _moduleName)) { return null; } _moduleDependencies.AddPathExpression(name, expression.Second); return expression.First; } } catch (PathException e) { throw CompileTimeResolverUtil.MakePathAmbiguous(PathRegistryObjectType.EXPRDECL, name, e); } return null; }
public void AddExpressionDeclarations(ExpressionDeclItem item) { if (expressionDeclarations == null) { expressionDeclarations = new Dictionary<string, ExpressionDeclItem>(); } expressionDeclarations.Put(item.Name, item); }
public void RegisterExprDeclared( string expressionName, ExpressionDeclItem meta) { if (expressions.ContainsKey(expressionName)) { throw new IllegalStateException("Expression name already found '" + expressionName + "'"); } expressions.Put(expressionName, meta); }
public void NewExprDeclared(ExpressionDeclItem detail) { if (!detail.Visibility.IsModuleProvidedAccessModifier()) { throw new IllegalStateException("Invalid visibility for contexts"); } var name = detail.Name; var existing = Expressions.Get(name); if (existing != null) { throw new IllegalStateException("Duplicate declared expression encountered for name '" + name + "'"); } Expressions.Put(name, detail); }
protected ExprDeclaredEvalBase(ExprEvaluator innerEvaluator, ExpressionDeclItem prototype, bool isCache) { _innerEvaluator = innerEvaluator; _prototype = prototype; if (innerEvaluator is ExprEvaluatorEnumeration) { _innerEvaluatorLambda = (ExprEvaluatorEnumeration)innerEvaluator; } else { _innerEvaluatorLambda = null; } _isCache = isCache; }
public ExprDeclaredForgeConstant( ExprDeclaredNodeImpl parent, Type returnType, ExpressionDeclItem prototype, object value, bool audit, string statementName) { this.parent = parent; EvaluationType = returnType; this.prototype = prototype; this.value = value; this.audit = audit; this.statementName = statementName; }
public String AddExpressionOrScript(CreateExpressionDesc expressionDesc) { using (_iLock.Acquire()) { if (expressionDesc.Expression != null) { ExpressionDeclItem expression = expressionDesc.Expression; String name = expression.Name; if (_globalExpressions.ContainsKey(name)) { throw new ExprValidationException("Expression '" + name + "' has already been declared"); } _globalExpressions.Put(name, expression); return(name); } else { ExpressionScriptProvided newScript = expressionDesc.Script; String name = newScript.Name; List <ExpressionScriptProvided> scripts = _globalScripts.Get(name); if (scripts != null) { foreach (ExpressionScriptProvided script in scripts) { if (script.ParameterNames.Count == newScript.ParameterNames.Count) { throw new ExprValidationException( "Script '" + name + "' that takes the same number of parameters has already been declared"); } } } else { scripts = new List <ExpressionScriptProvided>(2); _globalScripts.Put(name, scripts); } scripts.Add(newScript); return(name); } } }
public ExprDeclaredNodeImpl( IContainer container, ExpressionDeclItem prototype, IList <ExprNode> chainParameters, ContextDescriptor contextDescriptor) { _prototype = prototype; _chainParameters = chainParameters; // copy expression - we do it at this time and not later try { _expressionBodyCopy = (ExprNode)SerializableObjectCopier.Copy(container, prototype.Inner); } catch (Exception e) { throw new Exception("Internal error providing expression tree: " + e.Message, e); } // replace context-properties where they are currently identifiers if (contextDescriptor == null) { return; } var visitorWParent = new ExprNodeIdentVisitorWParent(); _expressionBodyCopy.Accept(visitorWParent); foreach (var pair in visitorWParent.IdentNodes) { var streamOrProp = pair.Second.StreamOrPropertyName; if (streamOrProp != null && contextDescriptor.ContextPropertyRegistry.IsContextPropertyPrefix(streamOrProp)) { var context = new ExprContextPropertyNode(pair.Second.UnresolvedPropertyName); if (pair.First == null) { _expressionBodyCopy = context; } else { ExprNodeUtility.ReplaceChildNode(pair.First, pair.Second, context); } } } }
public static CodegenExpressionInstanceField MakeRuntimeCacheKeyField( CodegenExpression instance, ExpressionDeclItem expression, CodegenClassScope classScope, Type generator) { if (expression.Visibility == NameAccessModifier.TRANSIENT) { // for private expression that cache key is simply an Object shared by the name of the // expression (fields are per-statement already so its safe) return classScope.NamespaceScope.AddOrGetInstanceFieldSharable( instance, new ExprDeclaredCacheKeyLocalCodegenField(expression.Name)); } // global expressions need a cache key that derives from the deployment id of the expression and the expression name CodegenMethod keyInit = classScope.NamespaceScope.InitMethod .MakeChild(typeof(ExprDeclaredCacheKeyGlobal), generator, classScope) .AddParam( typeof(EPStatementInitServices), EPStatementInitServicesConstants.REF.Ref); keyInit.Block.DeclareVar<string>( "deploymentId", StaticMethod( typeof(ExpressionDeployTimeResolver), "ResolveDeploymentId", Constant(expression.Name), Constant(expression.Visibility), Constant(expression.ModuleName), EPStatementInitServicesConstants.REF)) .MethodReturn( NewInstance<ExprDeclaredCacheKeyGlobal>( Ref("deploymentId"), Constant(expression.Name))); return classScope.NamespaceScope.AddInstanceFieldUnshared( instance, true, typeof(ExprDeclaredCacheKeyGlobal), LocalMethod(keyInit, EPStatementInitServicesConstants.REF)); }
public ExprDeclaredEvalRewrite(ExprEvaluator innerEvaluator, ExpressionDeclItem prototype, bool isCache, int[] streamAssignments) : base(innerEvaluator, prototype, isCache) { _streamAssignments = streamAssignments; }
public ExprDeclaredEvalConstant(Type returnType, ExpressionDeclItem prototype, Object value) { _returnType = returnType; _prototype = prototype; _value = value; }
public void QExprDeclared(ExpressionDeclItem parent) { }
public void RegisterExprDeclared( string expressionName, ExpressionDeclItem meta) { moduleExpressions.Put(expressionName, meta); }
public ExprDeclaredEvalNoRewrite(ExprEvaluator innerEvaluator, ExpressionDeclItem prototype, bool isCache) : base(innerEvaluator, prototype, isCache) { }
public static Pair <ExpressionDeclItem, ExpressionScriptProvided> WalkExpressionDecl( EsperEPL2GrammarParser.ExpressionDeclContext ctx, IList <String> scriptBodies, IDictionary <ITree, ExprNode> astExprNodeMap, CommonTokenStream tokenStream) { var name = ctx.name.Text; if (ctx.alias != null) { if (ctx.alias.Text.ToLower().Trim() != "alias") { throw ASTWalkException.From("For expression alias '" + name + "' expecting 'alias' keyword but received '" + ctx.alias.Text + "'"); } if (ctx.columnList() != null) { throw ASTWalkException.From("For expression alias '" + name + "' expecting no parameters but received '" + tokenStream.GetText(ctx.columnList()) + "'"); } if (ctx.expressionDef() != null && ctx.expressionDef().expressionLambdaDecl() != null) { throw ASTWalkException.From("For expression alias '" + name + "' expecting an expression without parameters but received '" + tokenStream.GetText(ctx.expressionDef().expressionLambdaDecl()) + "'"); } if (ctx.expressionDef().stringconstant() != null) { throw ASTWalkException.From("For expression alias '" + name + "' expecting an expression but received a script"); } var exprNode = ASTExprHelper.ExprCollectSubNodes(ctx, 0, astExprNodeMap)[0]; var alias = ctx.name.Text; var decl = new ExpressionDeclItem(alias, Collections.GetEmptyList <String>(), exprNode, true); return(new Pair <ExpressionDeclItem, ExpressionScriptProvided>(decl, null)); } if (ctx.expressionDef().stringconstant() != null) { var expressionText = scriptBodies[0]; scriptBodies.RemoveAt(0); var parameters = ASTUtil.GetIdentList(ctx.columnList()); var optionalReturnType = ctx.classIdentifier() == null ? null : ASTUtil.UnescapeClassIdent(ctx.classIdentifier()); var optionalReturnTypeArray = ctx.array != null; var optionalDialect = ctx.expressionDialect() == null ? null : ctx.expressionDialect().d.Text; var script = new ExpressionScriptProvided( name, expressionText, parameters, optionalReturnType, optionalReturnTypeArray, optionalDialect); return(new Pair <ExpressionDeclItem, ExpressionScriptProvided>(null, script)); } var ctxexpr = ctx.expressionDef(); var inner = ASTExprHelper.ExprCollectSubNodes(ctxexpr.expression(), 0, astExprNodeMap)[0]; var parametersNames = Collections.GetEmptyList <string>(); var lambdactx = ctxexpr.expressionLambdaDecl(); if (ctxexpr.expressionLambdaDecl() != null) { parametersNames = ASTLibFunctionHelper.GetLambdaGoesParams(lambdactx); } var expr = new ExpressionDeclItem(name, parametersNames, inner, false); return(new Pair <ExpressionDeclItem, ExpressionScriptProvided>(expr, null)); }
public static MyPair WalkExpressionDecl( EsperEPL2GrammarParser.ExpressionDeclContext ctx, IList<string> scriptBodies, IDictionary<ITree, ExprNode> astExprNodeMap, CommonTokenStream tokenStream) { var name = ctx.name.Text; if (ctx.alias != null) { if (!ctx.alias.Text.ToLowerInvariant().Trim().Equals("alias")) { throw ASTWalkException.From( "For expression alias '" + name + "' expecting 'alias' keyword but received '" + ctx.alias.Text + "'"); } if (ctx.columnList() != null) { throw ASTWalkException.From( "For expression alias '" + name + "' expecting no parameters but received '" + tokenStream.GetText(ctx.columnList()) + "'"); } if (ctx.expressionDef() != null && ctx.expressionDef().expressionLambdaDecl() != null) { throw ASTWalkException.From( "For expression alias '" + name + "' expecting an expression without parameters but received '" + tokenStream.GetText(ctx.expressionDef().expressionLambdaDecl()) + "'"); } if (ctx.expressionDef().stringconstant() != null) { throw ASTWalkException.From("For expression alias '" + name + "' expecting an expression but received a script"); } var node = ASTExprHelper.ExprCollectSubNodes(ctx, 0, astExprNodeMap)[0]; var alias = ctx.name.Text; var expressionUnmap = StatementSpecMapper.Unmap(node); var decl = new ExpressionDeclItem(alias, new string[0], true); decl.OptionalSoda = expressionUnmap; return new MyPair(decl, null); } if (ctx.expressionDef().stringconstant() != null) { var expressionText = scriptBodies.DeleteAt(0); var parameters = ASTUtil.GetIdentList(ctx.columnList()); var optionalReturnType = ctx.classIdentifier() == null ? null : ASTUtil.UnescapeClassIdent(ctx.classIdentifier()); var optionalReturnTypeArray = ctx.array != null; var optionalDialect = ctx.expressionDialect() == null ? null : ctx.expressionDialect().d.Text; var optionalEventTypeName = ASTTypeExpressionAnnoHelper.ExpectMayTypeAnno(ctx.typeExpressionAnnotation(), tokenStream); var script = new ExpressionScriptProvided( name, expressionText, parameters.ToArray(), optionalReturnType, optionalReturnTypeArray, optionalEventTypeName, optionalDialect); return new MyPair(null, script); } var ctxexpr = ctx.expressionDef(); var inner = ASTExprHelper.ExprCollectSubNodes(ctxexpr.expression(), 0, astExprNodeMap)[0]; IList<string> parametersNames = new EmptyList<string>(); var lambdactx = ctxexpr.expressionLambdaDecl(); if (ctxexpr.expressionLambdaDecl() != null) { parametersNames = ASTLambdaHelper.GetLambdaGoesParams(lambdactx); } var expression = StatementSpecMapper.Unmap(inner); var expr = new ExpressionDeclItem(name, parametersNames.ToArray(), false); expr.OptionalSoda = expression; return new MyPair(expr, null); }