C# JsAstNode.Accept方法代码示例

 public static void Apply(JsAstNode node)
 {
     if (node != null)
     {
         node.Accept(s_instance);
     }
 }

        public static bool Apply(TextWriter writer, JsAstNode node)
        {
            if (node != null)
            {
                var visitor = new JsonOutputVisitor(writer);
                node.Accept(visitor);
                return visitor.IsValid;
            }

            return false;
        }

        public bool Match(JsAstNode 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 void Apply(JsAstNode node, JsActivationObject scope, JsSettings 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 JsResolutionVisitor(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);
            }
        }

 public static bool NeedsParens(JsAstNode expression, bool outerHasNoArguments)
 {
     var visitor = new JsNewParensVisitor(outerHasNoArguments);
     expression.Accept(visitor);
     return visitor.m_needsParens;
 }

        public static void Apply(TextWriter writer, JsAstNode node, JsSettings settings)
        {
            if (node != null)
            {
                var outputVisitor = new JsOutputVisitor(writer, settings);
                node.Accept(outputVisitor);

                // if there is a symbol map that we are tracking, tell it that we have ended an output run
                // and pass it offsets to the last line and column positions.
                settings.IfNotNull(s => s.SymbolsMap.IfNotNull(m => m.EndOutputRun(outputVisitor.m_lineCount, outputVisitor.m_lineLength)));
            }
        }

        private void AcceptNodeWithParens(JsAstNode node, bool needsParens)
        {
            // if we need parentheses, add the opening
            if (needsParens)
            {
                OutputPossibleLineBreak('(');

                // because we output an open paren, reset the start flag
                m_startOfStatement = false;

                // and because we are outputting a paren, we are no longer in a no-in scenario
                m_noIn = false;
            }

            // now output the node
            node.Accept(this);

            // if we need parentheses, add the closing and restore whatever noin state we had
            if (needsParens)
            {
                Output(')');
            }

            // make SURE the start flag is reset
            m_startOfStatement = false;
        }

 public static void Apply(JsAstNode node, JsParser parser)
 {
     var visitor = new JsFinalPassVisitor(parser);
     node.Accept(visitor);
 }