SHARE
TWEET

Untitled

a guest May 19th, 2019 63 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System;
  2. using System.Collections.Generic;
  3. using ELProg.CodeDSL.Boundary.Language;
  4. using ELProg.CodeDSL.Tokenizer.Tokens;
  5. using Attribute = ELProg.CodeDSL.Boundary.Language.Attribute;
  6.  
  7. namespace ELProg.CodeDSL.Boundary
  8. {
  9.     public class BoundaryParser
  10.     {
  11.         public static Global ParseSimple(string expression)
  12.         {
  13.             return new BoundaryParser().Parse(expression);
  14.         }
  15.  
  16.         private Global _global;
  17.         private Class _currentClass;
  18.         private Method _currentMethod;
  19.         public Global Parse(string expression)
  20.         {
  21.             if (string.IsNullOrEmpty(expression))
  22.             {
  23.                 return null;
  24.             }
  25.  
  26.             var tokenizer = new Tokenizer.Tokenizer<TokenType>(Language.Language.TokenDefinitions);
  27.             var tokens = tokenizer.Tokenize(expression);
  28.  
  29.             var stack = new DslStack<DslToken<TokenType>>(tokens);
  30.  
  31.             _global = new Global();
  32.  
  33.             DslToken<TokenType> currentToken = null;
  34.  
  35.             while ((currentToken = stack.PopNext()) != null)
  36.             {
  37.                 if (currentToken.TokenType == TokenType.Class)
  38.                 {
  39.                     _currentClass = new Class { Name = currentToken.Values[2] };
  40.                     if (currentToken.Values.Count > 3)
  41.                     {
  42.                         _currentClass.Generic = currentToken.Values[3];
  43.                     }
  44.                     ParseClass(stack);
  45.                     _global.Classes.Add(_currentClass);
  46.                 }
  47.                 else if (currentToken.TokenType == TokenType.Global)
  48.                 {
  49.                     ParseBlock(stack, _global);
  50.                     _global.GlobalParsed = true;
  51.                 }
  52.                 else
  53.                 {
  54.                     throw new Exception("Expected token class got " + currentToken.Values[1] + " at " + currentToken.Positions[1]);
  55.                 }
  56.             }
  57.  
  58.             return _global;
  59.         }
  60.  
  61.         private void ParseClass(DslStack<DslToken<TokenType>> stack)
  62.         {
  63.             var next = stack.PopNext();
  64.             if (next.TokenType != TokenType.OpenCurlyBrace)
  65.             {
  66.                 throw new Exception("Expected token { got " + next.Values[0] + " at " + next.Positions[0]);
  67.             }
  68.  
  69.             var closed = false;
  70.             while (!closed)
  71.             {
  72.                 next = stack.PopNext();
  73.                 if (next.TokenType == TokenType.Attribute)
  74.                 {
  75.                     if (next.Values[2].StartsWith("-"))
  76.                     {
  77.                         _currentClass.Attributes.Add(new Attribute("", next.Values[2]));
  78.                     }
  79.                     else
  80.                     {
  81.                         var attr = new Attribute(next.Values[3], next.Values[2]);
  82.                         if (!String.IsNullOrEmpty(next.Values[1]))
  83.                         {
  84.                             attr.Modifier = next.Values[1];
  85.                         }
  86.                        
  87.                         _currentClass.Attributes.Add(attr);
  88.                     }
  89.  
  90.                 }
  91.                 else if (next.TokenType == TokenType.Comma)
  92.                 {
  93.                     //next
  94.                 }
  95.                 else if (next.TokenType == TokenType.Library)
  96.                 {
  97.                     _currentClass.Libraries.Add(new Library(!next.Values[0].StartsWith("-")));
  98.                 }
  99.                 else if (next.TokenType == TokenType.Math)
  100.                 {
  101.                     _currentClass.Maths.Add(new Language.Math(!next.Values[0].StartsWith("-")));
  102.                 }
  103.                 else if (next.TokenType == TokenType.Method)
  104.                 {
  105.                     _currentMethod = new Method(next.Values[3], next.Values[2]);
  106.                     _currentMethod.Modifier = next.Values[1];
  107.                     ParseMethod(stack);
  108.                     _currentClass.Methods.Add(_currentMethod);
  109.                 }
  110.                 else if (next.TokenType == TokenType.Call)
  111.                 {
  112.                     _currentClass.Calls.Add(new Call(next.Values[1]));
  113.                 }
  114.                 else if (next.TokenType == TokenType.Loop)
  115.                 {
  116.                     var tmpLoop = new Loop { Type = next.Values[0] };
  117.                     _currentClass.Loops.Add(tmpLoop);
  118.                 }
  119.                 else if (next.TokenType == TokenType.Flow)
  120.                 {
  121.                     var tmpFlow = new Flow();
  122.                     tmpFlow.Type = next.Values[0];
  123.                     _currentClass.Flows.Add(tmpFlow);
  124.                 }
  125.                 else if (next.TokenType == TokenType.CloseCurlyBrace)
  126.                 {
  127.                     closed = true;
  128.                 }
  129.                 else
  130.                 {
  131.                     throw new Exception("Invalid token " + next.Values[0] + " at " + next.Positions[0]);
  132.                 }
  133.             }
  134.         }
  135.  
  136.         private void ParseMethod(DslStack<DslToken<TokenType>> stack)
  137.         {
  138.             var next = stack.PopNext();
  139.             if (next.TokenType != TokenType.OpenBrace)
  140.             {
  141.                 throw new Exception("Expected token ( got " + next.Values[0] + " at " + next.Positions[0]);
  142.             }
  143.  
  144.             var closed = false;
  145.             while (!closed)
  146.             {
  147.                 next = stack.PopNext();
  148.                 if (next.TokenType == TokenType.Attribute)
  149.                 {
  150.                     _currentMethod.Parameters.Add(new Attribute(next.Values[3], next.Values[2]));
  151.                 }
  152.                 else if (next.TokenType == TokenType.Comma)
  153.                 {
  154.                     //next
  155.                 }
  156.                 else if (next.TokenType == TokenType.CloseBrace)
  157.                 {
  158.                     closed = true;
  159.                 }
  160.                 else
  161.                 {
  162.                     throw new Exception("Invalid token " + next.Values[0] + " at " + next.Positions[0]);
  163.                 }
  164.             }
  165.  
  166.             if (stack.LookUpNext().TokenType == TokenType.OpenCurlyBrace)
  167.             {
  168.                 ParseBlock(stack, _currentMethod);
  169.             }
  170.         }
  171.  
  172.         private void ParseBlock(DslStack<DslToken<TokenType>> stack, Block innerBlock)
  173.         {
  174.             var next = stack.PopNext();
  175.             if (next.TokenType != TokenType.OpenCurlyBrace)
  176.             {
  177.                 throw new Exception("Expected token { got " + next.Values[0] + " at " + next.Positions[0]);
  178.             }
  179.  
  180.             var closed = false;
  181.             while (!closed)
  182.             {
  183.                 next = stack.PopNext();
  184.                 if (next.TokenType == TokenType.Attribute)
  185.                 {
  186.                     if (next.Values[2].StartsWith("-"))
  187.                     {
  188.                         innerBlock.Attributes.Add(new Attribute("", next.Values[2]));
  189.                     }
  190.                     else
  191.                     {
  192.                         innerBlock.Attributes.Add(new Attribute(next.Values[3], next.Values[2]));
  193.                     }
  194.                 }
  195.                 else if (next.TokenType == TokenType.Comma)
  196.                 {
  197.                     //next
  198.                 }
  199.                 else if (next.TokenType == TokenType.Loop)
  200.                 {
  201.                     var tmpLoop = new Loop { Type = next.Values[0] };
  202.                     if (stack.LookUpNext().TokenType == TokenType.OpenCurlyBrace)
  203.                     {
  204.                         ParseBlock(stack, tmpLoop);
  205.                     }
  206.                     innerBlock.Loops.Add(tmpLoop);
  207.                 }
  208.                 else if (next.TokenType == TokenType.Flow)
  209.                 {
  210.                     var tmpFlow = new Flow();
  211.                     tmpFlow.Type = next.Values[0];
  212.                     if (stack.LookUpNext().TokenType == TokenType.OpenCurlyBrace)
  213.                     {
  214.                         ParseBlock(stack, tmpFlow);
  215.                     }
  216.                     innerBlock.Flows.Add(tmpFlow);
  217.                 }
  218.                 else if (next.TokenType == TokenType.Library)
  219.                 {
  220.                     innerBlock.Libraries.Add(new Library(!next.Values[0].StartsWith("-")));
  221.                 }
  222.                 else if (next.TokenType == TokenType.Math)
  223.                 {
  224.                     innerBlock.Maths.Add(new Language.Math(!next.Values[0].StartsWith("-")));
  225.                 }
  226.                 else if (next.TokenType == TokenType.Call)
  227.                 {
  228.                     innerBlock.Calls.Add(new Call(next.Values[1]));
  229.                 }
  230.                 else if (next.TokenType == TokenType.CloseCurlyBrace)
  231.                 {
  232.                     closed = true;
  233.                 }
  234.                 else
  235.                 {
  236.                     throw new Exception("Invalid token " + next.Values[0] + " at " + next.Positions[0]);
  237.                 }
  238.             }
  239.         }
  240.     }
  241. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top