/// <summary>Applies the css validation visitors.</summary> /// <param name="stylesheetNode">The stylesheet node.</param> /// <param name="threadContext">The thread Context.</param> /// <returns>The processed node.</returns> private AstNode ApplyValidation(AstNode stylesheetNode, IWebGreaseContext threadContext) { threadContext.SectionedAction(SectionIdParts.MinifyCssActivity, SectionIdParts.Validate).Execute(() => { // Step # 1 - Remove the Css properties from Ast which need to be excluded (Bridging) if (this.ShouldExcludeProperties) { stylesheetNode = stylesheetNode.Accept(new ExcludePropertyVisitor()); } // Step # 2 - Validate for lower case if (this.ShouldValidateForLowerCase) { stylesheetNode = stylesheetNode.Accept(new ValidateLowercaseVisitor()); } // Step # 3 - Validate for Css hacks which don't work cross browser if (this.HackSelectors != null && this.HackSelectors.Any()) { stylesheetNode = stylesheetNode.Accept(new SelectorValidationOptimizationVisitor(this.HackSelectors, false, true)); } // Step # 4 - Remove any banned selectors which are exposed for page efficiency if (this.BannedSelectors != null && this.BannedSelectors.Any()) { stylesheetNode = stylesheetNode.Accept(new SelectorValidationOptimizationVisitor(this.BannedSelectors, false, false)); } }); return(stylesheetNode); }
private void FillFollowPosClosure(int posOffset, AstNode inner) { var firstPosVisitor = new FirstPosGetter(); foreach (int pos in inner.Accept(lastPosGetter, posOffset)) { positions[pos].FollowPos.AddAll(inner.Accept(firstPosVisitor, posOffset)); } }
public int Measure() { // we just want to measure the potential delta m_measure = true; m_delta = 0; // do it and return the result m_expression.Accept(this); return(m_delta); }
private NFA ConvertRegexAstToNFA(AstNode root) { var visitor = new RegexToNFAVisitor(); root.Accept(visitor); return(visitor.Root); }
public static Process CreateFromAst(AstNode n, string[] namespaces, Type[] types) { var sb = new StringBuilder(); foreach (var ns in namespaces) { sb.AppendLine($"using {ns};"); } sb.AppendLine(@" using System; using System.Linq; namespace ce_toy_fx.dynamic { class DynamicProcess { public static Process GetProcess() { return "); var compiler = new AstCompiler(); n.Accept(compiler); sb.AppendLine(compiler.ToString()); sb.AppendLine(@" .CompileToProcess(""Sample process""); } } } "); return(CreateFromString(sb.ToString(), types)); }
public static void Apply(AstNode node) { if (node != null) { node.Accept(s_instance); } }
public static void Apply(AstNode node) { if (node != null) { node.Accept(s_instance); } }
public static bool NeedsParens(AstNode expression, bool outerHasNoArguments) { var visitor = new NewParensVisitor(outerHasNoArguments); expression.Accept(visitor); return(visitor.m_needsParens); }
public override AstNode Visit(FunctionDefinition node) { // Visit the prototype. AstNode proto = node.GetPrototype(); proto.Accept(this); return(node); }
public RegularTree(AstNode root) { this.EoiCharSetNode = CharSetNode.Create(EoiChar); this.AugmentedRoot = new CatNode(new List<AstNode> { root, EoiCharSetNode }); var positionBuilder = new PositionBuilder(); AugmentedRoot.Accept(positionBuilder, null); Positions = positionBuilder.Positions; EoiPosition = Positions.FindIndex(pos => pos.Characters.Contains(EoiChar)); Debug.Assert(EoiPosition >= 0); var firstPosVisitor = new FirstPosGetter(); this.FirstPos = AugmentedRoot.Accept(firstPosVisitor, 0); var followPosBuilder = new FollowPosBuilder(Positions); AugmentedRoot.Accept(followPosBuilder, 0); }
/// <summary>Applies the css optimization visitors.</summary> /// <param name="stylesheetNode">The stylesheet node.</param> /// <param name="threadContext">The thread Context.</param> /// <returns>The processed node.</returns> private AstNode ApplyOptimization(AstNode stylesheetNode, IWebGreaseContext threadContext) { // Step # 5 - Run the Css optimization visitors if (this.ShouldOptimize) { threadContext.SectionedAction(SectionIdParts.MinifyCssActivity, SectionIdParts.Optimize).Execute( () => { stylesheetNode = stylesheetNode.Accept(new OptimizationVisitor { ShouldMergeMediaQueries = this.ShouldMergeMediaQueries, ShouldPreventOrderBasedConflict = this.ShouldPreventOrderBasedConflict, ShouldMergeBasedOnCommonDeclarations = this.ShouldMergeBasedOnCommonDeclarations, NonMergeRuleSetSelectors = this.NonMergeSelectors }); stylesheetNode = stylesheetNode.Accept(new ColorOptimizationVisitor()); stylesheetNode = stylesheetNode.Accept(new FloatOptimizationVisitor()); }); } return(stylesheetNode); }
private static T MakeFunc <T>(AstNode astFunction) { var generator = new ExpressionGenerator(); var expressionBody = astFunction.Accept(generator); var lambda = Expression.Lambda <T>(expressionBody, generator.GetParameters()); var f = lambda.Compile(DebugInfoGenerator.CreatePdbGenerator()); return(f); }
/// <summary> /// For the given binding node, return a collection of individual INameDeclaration /// nodes that represent the names being declared for this binding element. /// </summary> /// <param name="node">binding node</param> /// <returns>collection of INameDeclaration nodes</returns> public static IList<BindingIdentifier> Bindings(AstNode node) { var visitor = new BindingsVisitor(); if (node != null) { node.Accept(visitor); } return visitor.m_bindings; }
/// <summary> /// For the given binding node, return a collection of individual lookup /// nodes that represent the names being referenced. /// </summary> /// <param name="node">binding node</param> /// <returns>collection of Lookup nodes</returns> public static IList<LookupExpression> References(AstNode node) { var visitor = new BindingsVisitor(); if (node != null) { node.Accept(visitor); } return visitor.m_lookups; }
/// <summary>Applies the css resource visitors.</summary> /// <param name="stylesheetNode">The stylesheet node.</param> /// <param name="resources">The resources.</param> /// <param name="threadContext">The thread Context.</param> /// <returns>The processed node.</returns> private static AstNode ApplyResources(AstNode stylesheetNode, IEnumerable <IDictionary <string, string> > resources, IWebGreaseContext threadContext) { if (resources.Any()) { threadContext.SectionedAction(SectionIdParts.MinifyCssActivity, SectionIdParts.ResourcesResolution) .Execute(() => { stylesheetNode = stylesheetNode.Accept(new ResourceResolutionVisitor(resources)); }); } return(stylesheetNode); }
public static bool Apply(TextWriter writer, AstNode node, CodeSettings settings) { if (node != null) { var visitor = new JsonOutputVisitor(writer, settings); node.Accept(visitor); return(visitor.IsValid); } return(false); }
public static bool Apply(TextWriter writer, AstNode node) { if (node != null) { var visitor = new JSONOutputVisitor(writer); node.Accept(visitor); return visitor.IsValid; } return false; }
public bool IsSafe(AstNode node) { // assume it is unless preven otherwise m_isSafe = true; if (node != null) { node.Accept(this); } return(m_isSafe); }
public static bool References(AstNode node, Lookup lookup) { if (node == null || lookup == null) { return(false); } var visitor = new ReferencesVisitor(lookup); node.Accept(visitor); return(visitor.m_hasReference); }
public bool Query(AstNode node) { // requires by default unless a node explicitly says it doesn't need one DoesRequire = node != null; if (node != null) { node.Accept(this); } return(DoesRequire); }
public static IEnumerable <AstNode> Traverse(AstNode node) { yield return(node); foreach (var child in node.Accept(new AstChildrenVisitor())) { foreach (var childTraverse in Traverse(child)) { yield return(childTraverse); } } }
/// <summary>Print the <see cref="AstNode"/></summary> /// <param name="prettyPrint">The pretty print</param> /// <param name="node">The node to print</param> /// <returns>The string representation of AST node</returns> internal string Print(bool prettyPrint, AstNode node) { _printerFormatter.PrettyPrint = prettyPrint; _printerFormatter.IndentCharacter = IndentCharacter; _printerFormatter.IndentSize = IndentSize; if (node != null) { node.Accept(this); } return(_printerFormatter.ToString()); }
public RegularTree(AstNode root) { this.EoiCharSetNode = CharSetNode.Create(EoiChar); this.AugmentedRoot = new CatNode(new List <AstNode> { root, EoiCharSetNode }); var positionBuilder = new PositionBuilder(); AugmentedRoot.Accept(positionBuilder, null); Positions = positionBuilder.Positions; EoiPosition = Positions.FindIndex(pos => pos.Characters.Contains(EoiChar)); Debug.Assert(EoiPosition >= 0); var firstPosVisitor = new FirstPosGetter(); this.FirstPos = AugmentedRoot.Accept(firstPosVisitor, 0); var followPosBuilder = new FollowPosBuilder(Positions); AugmentedRoot.Accept(followPosBuilder, 0); }
public void LinkProgram() { // Read the result. AstNode content = moduleNode; // Perform semantic analysis passes. AstVisitor[] semanticPasses = new AstVisitor[] { // Declare module types. new ModuleTypeDeclaration(), // Expand using <namespaces>. new PseudoScopeExpansion(), // Expand type defs. new TypedefExpansion(), // Read the object bases. new ModuleReadBases(), // Declare module object(type members) new ModuleObjectDeclarator(), // Explicit interface member binding. new ExplicitInterfaceBinding(), // Build type inheritance tables. new ModuleInheritance(), // Perform function semantic analysis. new FunctionSemantic(), // Expand constants. new ConstantExpansion(), // Generate function byte code. new FunctionGenerator(), }; // Execute passes. for (int i = 0; i < semanticPasses.Length; ++i) { AstVisitor pass = semanticPasses[i]; pass.BeginPass(); Benchmark.Begin(); content.Accept(pass); Benchmark.End(pass.GetType().ToString()); pass.EndPass(); } }
public override AstNode Visit(AstNode node) { if (node == null) { return(null); } AddDiagnostics(node); if (!node.Unused.IsNullOrEmpty()) { foreach (var un in node.Unused) { AddDiagnostics(un); } } return(node.Accept(this)); }
public void RgbCollapse() { const string FileName = @"RgbCollapse.css"; AstNode styleSheetNode = CssParser.Parse(new FileInfo(Path.Combine(ActualDirectory, FileName))); Assert.IsNotNull(styleSheetNode); styleSheetNode = styleSheetNode.Accept(new ColorOptimizationVisitor()); Assert.IsNotNull(styleSheetNode); MinificationVerifier.VerifyMinification(BaseDirectory, FileName, new List <NodeVisitor> { new ColorOptimizationVisitor() }); PrettyPrintVerifier.VerifyPrettyPrint(BaseDirectory, FileName, new List <NodeVisitor> { new ColorOptimizationVisitor() }); }
/// <summary>Executes the image assembly update visitor</summary> /// <param name="stylesheetNode">The stylesheet Ast node</param> /// <param name="imageLogs">The sprite Log Files.</param> /// <param name="dpi">The dpi.</param> /// <returns>The modified AST node if modified otherwise the original node</returns> private AstNode ExecuteImageAssemblyUpdate(AstNode stylesheetNode, IEnumerable <ImageLog> imageLogs, float dpi) { var imageAssemblyUpdateVisitor = new ImageAssemblyUpdateVisitor( this.SourceFile, imageLogs, dpi, this.OutputUnit, this.OutputUnitFactor, this.ImageBasePrefixToRemoveFromOutputPathInLog, this.ImageBasePrefixToAddToOutputPath, this.availableSourceImages, this.MissingImageUrl); stylesheetNode = stylesheetNode.Accept(imageAssemblyUpdateVisitor); // Return the updated Ast return(stylesheetNode); }
bool IsEqualNodes(AstNode first, AstNode second) { if (first == null) { return(second == null); } if (second == null) { return(false); } if (first.GetType() != second.GetType()) { return(false); } _other = second; return(first.Accept(this)); }
private ILCode CreateCode(string moduleName, string typeName, AstNode exp) { if (Path.GetFileName(moduleName) != moduleName) { throw new Exception("can only output into current directory!"); } var name = new AssemblyName(Path.GetFileNameWithoutExtension(moduleName)); AssemblyBuilder asmb = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.Save); ModuleBuilder modb = asmb.DefineDynamicModule(moduleName); TypeBuilder typeBuilder = modb.DefineType(typeName); MethodBuilder methMain = typeBuilder.DefineMethod("Main", MethodAttributes.Static, typeof(void), Type.EmptyTypes); var ilcode = new ILCode { Type = typeBuilder, Method = methMain, Module = modb }; init.CodeInfo = ilcode; init.GeneratePredifinedCode(); TypeBuilder nested = AddFunctionMainToCode(ilcode, methMain); ilcode.Type = nested; ILCodeGenerator codeGenerator = new ILCodeGenerator(ilcode); //generacion de codigos exp.Accept(codeGenerator); ILGenerator il = methMain.GetILGenerator(); il.Emit(OpCodes.Ret); nested.CreateType(); typeBuilder.CreateType(); modb.CreateGlobalFunctions(); asmb.SetEntryPoint(methMain); asmb.Save(moduleName); return(ilcode); }
/// <summary>Scans the css for the image path references</summary> /// <param name="stylesheetNode">The stylesheet node</param> /// <param name="threadContext">The thread Context.</param> /// <returns>The modified AST node if modified otherwise the original node</returns> private ImageAssemblyScanVisitor ExecuteImageAssemblyScan(AstNode stylesheetNode, IWebGreaseContext threadContext) { var imageAssemblyScanVisitor = new ImageAssemblyScanVisitor( this.SourceFile, this.ImageAssembleReferencesToIgnore, this.IgnoreImagesWithNonDefaultBackgroundSize, this.OutputUnit, this.OutputUnitFactor, this.availableSourceImages, this.MissingImageUrl, true) { Context = threadContext }; // Scan log visitor should and does not change the stylesheet, no need to use the result. stylesheetNode.Accept(imageAssemblyScanVisitor); // return the can log results. return(imageAssemblyScanVisitor); }
public bool Match(AstNode node, string identifiers) { // set the match to false m_isMatch = false; // identifiers cannot be null or blank and must match: IDENT(.IDENT)* // since for JS there has to be at least a global object, the dot must be AFTER the first character. if (node != null && !string.IsNullOrEmpty(identifiers)) { // get all the parts var parts = identifiers.Split('.'); // each part must be a valid JavaScript identifier. Assume everything is valid // unless at least one is invalid -- then forget it var isValid = true; foreach (var part in parts) { if (!JSScanner.IsValidIdentifier(part)) { isValid = false; break; } } // must be valid to continue if (isValid) { // save the parts and start the index on the last one, since we'll be walking backwards m_parts = parts; m_index = parts.Length - 1; node.Accept(this); } } return(m_isMatch); }
public bool Match(AstNode node, string identifiers) { // set the match to false m_isMatch = false; // identifiers cannot be null or blank and must match: IDENT(.IDENT)* // since for JS there has to be at least a global object, the dot must be AFTER the first character. if (node != null && !string.IsNullOrEmpty(identifiers)) { // get all the parts var parts = identifiers.Split('.'); // each part must be a valid JavaScript identifier. Assume everything is valid // unless at least one is invalid -- then forget it var isValid = true; foreach (var part in parts) { if (!JSScanner.IsValidIdentifier(part)) { isValid = false; break; } } // must be valid to continue if (isValid) { // save the parts and start the index on the last one, since we'll be walking backwards m_parts = parts; m_index = parts.Length - 1; node.Accept(this); } } return m_isMatch; }
public static bool NeedsParens(AstNode expression, bool outerHasNoArguments) { var visitor = new NewParensVisitor(outerHasNoArguments); expression.Accept(visitor); return visitor.m_needsParens; }
private static bool IsNullable(AstNode root) { bool result = root.Accept(NullableGetter.Instance); return result; }
public static void Apply(AstNode node, ActivationObject scope, CodeSettings settings) { if (node != null && scope != null) { // create the visitor and run it. This will create all the child // scopes and populate all the scopes with the var-decl, lex-decl, // and lookup references within them. var visitor = new ResolutionVisitor(scope, settings); node.Accept(visitor); // now that all the scopes are created and they all know what decls // they contains, create all the fields CreateFields(scope); // now that all the fields have been created in all the scopes, // let's go through and resolve all the references ResolveLookups(scope, settings); // now that everything is declared and resolved as per the language specs, // we need to go back and add ghosted fields for older versions of IE that // incorrectly implement catch-variables and named function expressions. AddGhostedFields(scope); } }
private CodeDomArg VisitChild(AstNode node, CodeDomArg arg) { _codeStack.Push(arg); node.Accept(this); return _codeStack.Pop(); }
public virtual AstNode Visit(AstNode node) { return(node?.Accept(this)); }
private object Evaluate(AstNode expr) { return(expr.Accept(this)); }
public void Visit(AstNode node) { if (node != null) node.Accept(this); }