Guest User

Untitled

a guest
Dec 22nd, 2014
271
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. private class ParsedSyntaxTreeNode
  2. {
  3.     public SyntaxTreeNode Node { get; set; }
  4.     public bool Parsed { get; set; }
  5.     public int Index { get; set; }
  6. }
  7.  
  8. private IEnumerable<ParsedSyntaxTreeNode> ParseModuleInstruction(string publicScope, string localScope, IEnumerable<LogicalCodeLine> lines,
  9.     Instruction instruction, int index)
  10. {
  11.     foreach (var syntax in _grammar.Where(s => !s.IsChildNodeSyntax))
  12.     {
  13.         string currentLocalScope = localScope;
  14.         SyntaxTreeNode node;
  15.         if (!syntax.IsMatch(publicScope, currentLocalScope, instruction, out node))
  16.         {
  17.             continue;
  18.         }
  19.  
  20.         if (syntax.Type.HasFlag(SyntaxType.HasChildNodes))
  21.         {
  22.             var codeBlockNode = node as CodeBlockNode;
  23.             if (codeBlockNode != null)
  24.             {
  25.                 if (node is ProcedureNode)
  26.                 {
  27.                     currentLocalScope = localScope + "." + (node as ProcedureNode).Identifier.Name;
  28.                     var parsedProcNode = ParseProcedure(publicScope, currentLocalScope, node as ProcedureNode, lines, ref index);
  29.                     yield return new ParsedSyntaxTreeNode()
  30.                     {
  31.                         Node = parsedProcNode,
  32.                         Parsed = true,
  33.                         Index = index
  34.                     };
  35.                     yield break;
  36.                 }
  37.  
  38.                 var parsedCodeNode = ParseCodeBlock(publicScope, currentLocalScope, codeBlockNode, lines, ref index);
  39.                 yield return new ParsedSyntaxTreeNode()
  40.                 {
  41.                     Node = parsedCodeNode,
  42.                     Parsed = true,
  43.                     Index = index
  44.                 };
  45.                 yield break;
  46.             }
  47.         }
  48.  
  49.         yield return new ParsedSyntaxTreeNode()
  50.         {
  51.             Node = node,
  52.             Parsed = true,
  53.             Index = index
  54.         };
  55.     }
  56.     yield return new ParsedSyntaxTreeNode(){Index = index, Parsed = false};
  57. }
  58.  
  59. private IEnumerable<SyntaxTreeNode> ParseModuleMembers(string publicScope, string localScope, IEnumerable<LogicalCodeLine> logicalCodeLines)
  60. {
  61.     var lines = logicalCodeLines.ToArray();
  62.     for (var index = 0; index < lines.Length; index++)
  63.     {
  64.         var line = lines[index];
  65.         if (string.IsNullOrWhiteSpace(line.Content))
  66.         {
  67.             continue;
  68.         }
  69.  
  70.         var instructions = line.SplitInstructions();
  71.         foreach (var instruction in instructions)
  72.         {
  73.             var parsedInstructions = ParseModuleInstruction(publicScope, localScope, lines, instruction, index);
  74.             foreach (var parsedInstruction in parsedInstructions)
  75.             {
  76.                 if (parsedInstruction.Parsed)
  77.                 {
  78.                     yield return parsedInstruction.Node;
  79.                 }
  80.                 else
  81.                 {
  82.                     yield return new ExpressionNode(instruction, localScope);
  83.                 }
  84.                 index = parsedInstruction.Index;
  85.             }
  86.         }
  87.     }
  88. }
  89.  
  90. private SyntaxTreeNode ParseCodeBlock(string publicScope, string localScope, CodeBlockNode codeBlockNode, IEnumerable<LogicalCodeLine> logicalLines, ref int index)
  91. {
  92.     var ifBlockNode = codeBlockNode as IfBlockNode;
  93.     if (ifBlockNode != null && !string.IsNullOrEmpty(ifBlockNode.Expression.Value))
  94.     {
  95.         return codeBlockNode;
  96.     }
  97.  
  98.     var result = codeBlockNode;
  99.     var grammar = result.ChildSyntaxType == null
  100.         ? _grammar.Where(syntax => !syntax.IsChildNodeSyntax).ToList()
  101.         : _grammar.Where(syntax => syntax.IsChildNodeSyntax && syntax.GetType() == result.ChildSyntaxType).ToList();
  102.  
  103.     var logicalCodeLines = logicalLines as LogicalCodeLine[] ?? logicalLines.ToArray();
  104.     var lines = logicalCodeLines.ToArray();
  105.  
  106.     for (++index; index < lines.Length; ++index)
  107.     {
  108.         int indexCaptured = index;
  109.         if (result.EndOfBlockMarkers.Any(marker => lines[indexCaptured].Content.Trim().StartsWith(marker)))
  110.         {
  111.             break;
  112.         }
  113.         var line = lines[index];
  114.         if (string.IsNullOrWhiteSpace(line.Content))
  115.         {
  116.             continue;
  117.         }
  118.  
  119.         var instructions = line.SplitInstructions();
  120.         foreach (var instruction in instructions)
  121.         {
  122.             bool hadMatch = ParseCodeBlockInstruction(publicScope, localScope, logicalCodeLines, instruction, codeBlockNode, grammar, ref index);
  123.             if (!hadMatch)
  124.             {
  125.                 result.AddNode(new ExpressionNode(instruction, localScope));
  126.             }
  127.         }
  128.  
  129.         if (lines[index + 1].Content.Trim().StartsWith(ReservedKeywords.Else))
  130.         {
  131.             break;
  132.         }
  133.     }
  134.     index = Math.Max(index, lines.Length);
  135.     return result;
  136. }
  137.  
  138. private bool ParseCodeBlockInstruction(string publicScope, string localScope, IEnumerable<LogicalCodeLine> logicalLines,
  139.     Instruction instruction, CodeBlockNode codeBlockNode, IEnumerable<ISyntax> grammar, ref int index)
  140. {
  141.     var result = codeBlockNode;
  142.     foreach (var syntax in grammar)
  143.     {
  144.         SyntaxTreeNode node;
  145.         if (!syntax.IsMatch(publicScope, localScope, instruction, out node))
  146.         {
  147.             continue;
  148.         }
  149.  
  150.         var childNode = node as CodeBlockNode;
  151.         if (childNode != null)
  152.         {
  153.             node = ParseCodeBlock(publicScope, localScope, childNode, logicalLines, ref index);
  154.         }
  155.  
  156.         result.AddNode(node);
  157.         return true;
  158.     }
  159.     return false;
  160. }
  161.  
  162. private SyntaxTreeNode ParseProcedure(string publicScope, string localScope, ProcedureNode procedureNode, IEnumerable<LogicalCodeLine> logicalLines, ref int index)
  163. {
  164.     var result = procedureNode;
  165.     var grammar = VBAGrammar.GetGrammarSyntax()
  166.         .Where(s => !s.IsChildNodeSyntax)
  167.         .ToList();
  168.  
  169.     var logicalCodeLines = logicalLines as LogicalCodeLine[] ?? logicalLines.ToArray();
  170.     var lines = logicalCodeLines.ToArray();
  171.  
  172.     for (int i = ++index; i < lines.Length; ++i)
  173.     {
  174.         if (result.EndOfBlockMarkers.Any(marker => lines[i].Content.Trim().StartsWith(marker)))
  175.         {
  176.             break;
  177.         }
  178.         var line = lines[i];
  179.         if (string.IsNullOrWhiteSpace(line.Content))
  180.         {
  181.             continue;
  182.         }
  183.  
  184.         var instructions = line.SplitInstructions();
  185.         foreach (var instruction in instructions)
  186.         {
  187.             bool hadMatch = ParseCodeBlockInstruction(publicScope, localScope, logicalCodeLines, instruction, procedureNode, grammar, ref index);
  188.             if (!hadMatch)
  189.             {
  190.                 result.AddNode(new ExpressionNode(instruction, localScope));
  191.             }
  192.         }
  193.     }
  194.     return result;
  195. }
RAW Paste Data