public static ReturnStatementExpression Produce(IEnumerable <Symbol> symbols) { List <Symbol> result = new List <Symbol>(); // Get return syntax string returnName = ParserExtensions.ExtractText(ref symbols); if (!string.IsNullOrEmpty(returnName)) { // Add return syntax result.Add(new TextPart(returnName)); ParserExtensions.RemoveBlankSpace(ref symbols); } // Parsing return value like right side StatementExpression.ParsingRightSide(ref symbols, result); // Remove semicolon from symbols // Add sememicolon to members int semicolonBefore = symbols.TakeWhile(s => !(s is Semicolon)).Count(); symbols = symbols.Skip(semicolonBefore + 1); result.Add(new Semicolon()); return(result == null ? null : new ReturnStatementExpression(result)); }
static void RecursiveProduceArgument(ref IEnumerable <Symbol> symbols, List <Symbol> arguments) { ParserExtensions.RemoveBlankSpace(ref symbols); if (symbols.Count() <= 0) { return; } string keyword = ParserExtensions.ExtractText(ref symbols); ParserExtensions.RemoveBlankSpace(ref symbols); string name = ParserExtensions.ExtractText(ref symbols); if (!string.IsNullOrEmpty(keyword) && !string.IsNullOrEmpty(name)) { arguments.Add(new TextPart(keyword)); arguments.Add(new TextPart(name)); } ParserExtensions.RemoveBlankSpace(ref symbols); if (symbols.FirstOrDefault() is Comma) { symbols = symbols.Skip(1); arguments.Add(new Comma()); RecursiveProduceArgument(ref symbols, arguments); } }
static void RecursiveProduce(IEnumerable <Symbol> symbols, List <Symbol> compiles) { // Empty blank space before keyword ParserExtensions.RemoveBlankSpace(ref symbols); // Return if symbols <= 0 if (symbols.Count() <= 0) { return; } // Get compile shader List <Symbol> compileSymbols = symbols.TakeWhile(s => !(s is Semicolon)).ToList(); symbols = symbols.Skip(compileSymbols.Count() + 1); // Return if symbols <= 0 if (symbols.Count() <= 0) { return; } compileSymbols.Add(new Semicolon()); // Add to compiles compiles.Add(CompileExpression.Produce(compileSymbols)); RecursiveProduce(symbols, compiles); }
public static IfHeaderExpression Produce(IEnumerable <Symbol> symbols) { List <Symbol> result = new List <Symbol>(); ParserExtensions.RemoveBlankSpace(ref symbols); bool searching = symbols.Count() > 0; while (searching) { string text = ParserExtensions.ExtractText(ref symbols); if (!string.IsNullOrEmpty(text)) { ParserExtensions.RemoveBlankSpace(ref symbols); } Symbol nextSymbol = null; try { nextSymbol = symbols.First(); if (nextSymbol is DecimalDigit || nextSymbol is Character || nextSymbol is FullStop) { nextSymbol = null; } } catch { searching = false; } bool isProcedure = false; if (!string.IsNullOrEmpty(text) && nextSymbol is OpenRoundBracket) { isProcedure = true; result.Add(ProcedureExpression.Produce(text, ParserExtensions.TakeSymbolInRoundBrackets(ref symbols))); } else { if (!string.IsNullOrEmpty(text)) { result.Add(new TextPart(text)); } } if (!isProcedure && nextSymbol != null) { result.Add(nextSymbol); symbols = symbols.Skip(1); } ParserExtensions.RemoveBlankSpace(ref symbols); searching = symbols.Count() > 0; } return(result == null ? null : new IfHeaderExpression(result)); }
static void RecursiveProduce(IEnumerable <Symbol> symbols, List <Symbol> passes) { ParserExtensions.RemoveBlankSpace(ref symbols); if (symbols.Count() <= 0) { return; } // Get keyword string keyword = ParserExtensions.ExtractText(ref symbols); // Empty blank space after keyword ParserExtensions.RemoveBlankSpace(ref symbols); // Get name string name = ParserExtensions.ExtractText(ref symbols); // Empty blank space after name ParserExtensions.RemoveBlankSpace(ref symbols); if (!string.IsNullOrEmpty(keyword) && !string.IsNullOrEmpty(name)) { if (keyword == "pass") { int openBracketIndex = 0; int closeBracketIndex = 0; if (symbols.RollUpCurlyBrackets(out openBracketIndex, out closeBracketIndex)) { // Get body List <Symbol> bodySymbols = symbols.Take(closeBracketIndex + 1).ToList(); // Remove body symbols = symbols.Skip(closeBracketIndex + 1).ToList(); // Create pass symbols List <Symbol> passSymbols = new List <Symbol>(); passSymbols.Add(new TextPart(keyword)); passSymbols.Add(new TextPart(name)); passSymbols.AddRange(bodySymbols); // Parse technique passes.Add(PassExpression.Produce(passSymbols)); } else { throw new InvalidOperationException("Roll Up Bracket"); } } } RecursiveProduce(symbols, passes); }
static IEnumerable <Symbol> Extract(IEnumerable <Symbol> symbols) { // Empty blank space before keyword ParserExtensions.RemoveBlankSpace(ref symbols); List <Symbol> parts = new List <Symbol>(); if (symbols.Count() <= 0) { return(parts); } // Get keyword string keyword = ParserExtensions.ExtractText(ref symbols); if (!string.IsNullOrEmpty(keyword) && (keyword == "SetVertexShader" || keyword == "SetPixelShader")) { // Add Set{N}Shader parts.Add(new TextPart(keyword)); // Empty blank space before keyword ParserExtensions.RemoveBlankSpace(ref symbols); int openParenthesisIndex = 0; int closeParenthesisIndex = 0; if (symbols.RollUpRoundBrackets(out openParenthesisIndex, out closeParenthesisIndex)) { // Get body IEnumerable <Symbol> bodySymbols = symbols.Take(closeParenthesisIndex + 1).ToList(); bodySymbols = bodySymbols.Skip(1).SkipLast(1); // Remove body symbols = symbols.Skip(closeParenthesisIndex + 1).ToList(); parts.Add(new OpenRoundBracket()); ExtractSetShader(bodySymbols, parts); parts.Add(new CloseRoundBracket()); } parts.AddRange(symbols); } else { throw new ParserException("SetVertexShader or SetPixelShader is not found"); } return(parts); }
public static StructStatementExpression Produce(IEnumerable <Symbol> symbols) { List <Symbol> members = new List <Symbol>(); string keyword = ParserExtensions.ExtractText(ref symbols); if (!string.IsNullOrEmpty(keyword)) { members.Add(new TextPart(keyword)); ParserExtensions.RemoveBlankSpace(ref symbols); string name = ParserExtensions.ExtractText(ref symbols); members.Add(new TextPart(name)); if (string.IsNullOrEmpty(name)) { throw new ParserException("Error struct parsed"); } int doubleDotBefore = symbols.TakeWhile(s => !(s is Colon)).Count(); symbols = symbols.Skip(doubleDotBefore + 1); members.Add(new Colon()); ParserExtensions.RemoveBlankSpace(ref symbols); string inputType = ParserExtensions.ExtractText(ref symbols); members.Add(new TextPart(inputType)); if (string.IsNullOrEmpty(inputType)) { throw new ParserException("Error struct parsed"); } int semicolonBefore = symbols.TakeWhile(s => !(s is Semicolon)).Count(); symbols = symbols.Skip(semicolonBefore + 1); members.Add(new Semicolon()); } return(new StructStatementExpression(members)); }
static void ExtractSetShader(IEnumerable <Symbol> symbols, List <Symbol> parts) { // Empty blank space before keyword ParserExtensions.RemoveBlankSpace(ref symbols); if (symbols.Count() <= 0) { return; } // Get keyword string keyword = ParserExtensions.ExtractText(ref symbols); if (!string.IsNullOrEmpty(keyword)) { // Add Vertex or Pixel / Fragment function name parts.Add(new TextPart(keyword)); // Empty blank space after keyword ParserExtensions.RemoveBlankSpace(ref symbols); } }
static void RecursiveProduce(IEnumerable <Symbol> symbols, List <Symbol> members) { ParserExtensions.RemoveBlankSpace(ref symbols); if (symbols.Count() <= 0) { return; } int semicolonBefore = symbols.TakeWhile(s => !(s is Semicolon)).Count(); // Get IEnumerable <Symbol> memberPartSymbols = symbols.Take(semicolonBefore + 1); // Empty symbols = symbols.Skip(semicolonBefore + 1); // Add to members members.Add(StructStatementExpression.Produce(memberPartSymbols)); // Recursive produce RecursiveProduce(symbols, members); }
static void RecursiveProduce(IEnumerable <Symbol> symbols, List <Symbol> members) { ParserExtensions.RemoveBlankSpace(ref symbols); if (symbols.Count() <= 0) { return; } string keyword = ParserExtensions.ExtractText(ref symbols); if (!string.IsNullOrEmpty(keyword)) { members.Add(new TextPart(keyword)); ParserExtensions.RemoveBlankSpace(ref symbols); int assignBefore = symbols.TakeWhile(s => !(s is Equals)).Count(); symbols = symbols.Skip(assignBefore + 1); members.Add(new Equals()); ParserExtensions.RemoveBlankSpace(ref symbols); string inputType = ParserExtensions.ExtractText(ref symbols); members.Add(new TextPart(inputType)); if (string.IsNullOrEmpty(inputType)) { throw new ParserException("Error sampler parsed"); } int semicolonBefore = symbols.TakeWhile(s => !(s is Semicolon)).Count(); symbols = symbols.Skip(semicolonBefore + 1); members.Add(new Semicolon()); } RecursiveProduce(symbols, members); }
static void RecursiveProduce(IEnumerable <Symbol> symbols, List <Symbol> scriptExpressions) { // Empty blank space before keyword ParserExtensions.RemoveBlankSpace(ref symbols); if (symbols.Count() <= 0) { return; } // Get keyword string keyword = ParserExtensions.ExtractText(ref symbols); // Empty blank space after keyword ParserExtensions.RemoveBlankSpace(ref symbols); // Get name string name = ParserExtensions.ExtractText(ref symbols); // Empty blank space after name ParserExtensions.RemoveBlankSpace(ref symbols); #region Parsing sub expression if (!string.IsNullOrEmpty(keyword) && !string.IsNullOrEmpty(name)) { // Create text symbol for identifier TextPart keywordTextPart = new TextPart(keyword); // Create text symbol for name TextPart nameTextPart = new TextPart(name); if (keyword.StartsWith("sampler") || keyword == "struct") { int openBracketIndex = 0; int closeBracketIndex = 0; if (symbols.RollUpCurlyBrackets(out openBracketIndex, out closeBracketIndex)) { // Get body List <Symbol> bodySymbols = symbols.Take(closeBracketIndex + 1).ToList(); // Remove body symbols = symbols.Skip(closeBracketIndex + 1).ToList(); // Count until next semicolon int beforeSemicolon = symbols.TakeWhile(s => !(s is Semicolon)).Count(); // Normalize symbols = symbols.Skip(beforeSemicolon + 1); // Combined final symbols List <Symbol> samplerOrStructSymbols = new List <Symbol>(); samplerOrStructSymbols.Add(keywordTextPart); samplerOrStructSymbols.Add(nameTextPart); samplerOrStructSymbols.AddRange(bodySymbols); samplerOrStructSymbols.Add(new Semicolon()); // Add sampler expression if (keyword.StartsWith("sampler")) { string keywordType = keyword.Replace("sampler", ""); //if (keywordType != "2D" || keywordType != "Cube") //new ParserException("Unsupported " + keyword + " syntax"); scriptExpressions.Add(SamplerExpression.Produce(samplerOrStructSymbols)); } else { // Add struct expression scriptExpressions.Add(StructExpression.Produce(samplerOrStructSymbols)); } } else { throw new ParserException("Error roll up bracket"); } } else if (keyword == "technique") { int openBracketIndex = 0; int closeBracketIndex = 0; if (symbols.RollUpCurlyBrackets(out openBracketIndex, out closeBracketIndex)) { // Get body List <Symbol> bodySymbols = symbols.Take(closeBracketIndex + 1).ToList(); // Remove body symbols = symbols.Skip(closeBracketIndex + 1).ToList(); // Combined final symbols List <Symbol> techniqueSymbols = new List <Symbol>(); techniqueSymbols.Add(keywordTextPart); techniqueSymbols.Add(nameTextPart); techniqueSymbols.AddRange(bodySymbols); // Add technique expression scriptExpressions.Add(TechniqueExpression.Produce(techniqueSymbols)); } else { throw new ParserException("Error roll up bracket"); } } else { bool isFunction = symbols.FirstOrDefault() is OpenRoundBracket; if (isFunction) { List <Symbol> functionExpression = new List <Symbol>(); // Add header functionExpression.Add(keywordTextPart); functionExpression.Add(nameTextPart); // Begin parse arguments IEnumerable <Symbol> argumentSymbols = ParserExtensions.TakeSymbolInRoundBrackets(ref symbols); // Add arguments functionExpression.Add(new OpenRoundBracket()); functionExpression.Add(ArgumentExpression.Produce(argumentSymbols)); functionExpression.Add(new CloseRoundBracket()); // End parse arguments // Remove blank spaces ParserExtensions.RemoveBlankSpace(ref symbols); // Begin parse return IEnumerable <Symbol> returnSymbol = symbols.TakeWhile(s => !(s is OpenCurlyBracket)); int removeReturnsCount = returnSymbol.Count(); if (returnSymbol.FirstOrDefault() is Colon) { // Remove return symbols = symbols.Skip(removeReturnsCount); // Remove double dot returnSymbol = returnSymbol.Skip(1); // Remove blank spaces ParserExtensions.RemoveBlankSpace(ref returnSymbol); // Get return type string returnType = ParserExtensions.ExtractText(ref returnSymbol); // Add returns functionExpression.Add(new Colon()); functionExpression.Add(new TextPart(returnType)); ParserExtensions.RemoveBlankSpace(ref returnSymbol); } // End parse return // Remove blank spaces ParserExtensions.RemoveBlankSpace(ref symbols); // Begin parse body IEnumerable <Symbol> memberSymbols = ParserExtensions.TakeSymbolInCurlyBrackets(ref symbols); // Add function body functionExpression.Add(new OpenCurlyBracket()); functionExpression.Add(StatementBlockExpression.Produce(memberSymbols)); functionExpression.Add(new CloseCurlyBracket()); // End parse body // Produce function expression scriptExpressions.Add(FunctionExpression.Produce(functionExpression)); } else { // Parse fields // Get symbols before semicolon List <Symbol> bodySymbols = symbols.TakeWhile(s => !(s is Semicolon)).ToList(); // Normalize original symbols symbols = symbols.Skip(bodySymbols.Count + 1); // Create newSymbols List <Symbol> newSymbols = new List <Symbol>(); // Add symbols newSymbols.Add(keywordTextPart); newSymbols.Add(nameTextPart); // Add body symbols newSymbols.AddRange(bodySymbols); // Add semi colon to new Symbols newSymbols.Add(new Semicolon()); // Parse resource if (keyword.StartsWith("texture")) { string keywordType = keyword.Replace("texture", ""); //if (keywordType != "2D" || keywordType != "Cube") //throw new ParserException("Unsupported " + keyword + " syntax"); scriptExpressions.Add(ResourceExpression.Produce(newSymbols)); } // Parse constant else { scriptExpressions.Add(ConstantExpression.Produce(newSymbols)); } } } } #endregion RecursiveProduce(symbols, scriptExpressions); }
static void RecursiveProduce(IEnumerable <Symbol> symbols, List <Symbol> members) { ParserExtensions.RemoveBlankSpace(ref symbols); if (symbols.Count() <= 0) { return; } string identify = ParserExtensions.GetFirstText(ref symbols); if (!string.IsNullOrEmpty(identify)) { // Checking .. // 1. If statement if (identify == "if") { List <Symbol> ifExpression = new List <Symbol>(); IfStatementProduce(ref symbols, ifExpression, identify); // Produce if expression members.Add(IfStatementExpression.Produce(ifExpression)); } // 2. For statement else if (identify == "for") { List <Symbol> forExpression = new List <Symbol>(); // Normalize symbols = symbols.Skip(identify.Length); // Remove blank spaces ParserExtensions.RemoveBlankSpace(ref symbols); // Add syntax forExpression.Add(new TextPart(identify)); // Begin parse arguments IEnumerable <Symbol> argumentSymbols = ParserExtensions.TakeSymbolInRoundBrackets(ref symbols); // Add arguments forExpression.Add(new OpenRoundBracket()); forExpression.Add(ForHeaderExpression.Produce(argumentSymbols)); forExpression.Add(new CloseRoundBracket()); // End parse arguments // Remove blank spaces ParserExtensions.RemoveBlankSpace(ref symbols); // Begin parse body IEnumerable <Symbol> bodySymbols = ParserExtensions.TakeSymbolInCurlyBrackets(ref symbols); // Add function body forExpression.Add(new OpenCurlyBracket()); forExpression.Add(StatementBlockExpression.Produce(bodySymbols)); forExpression.Add(new CloseCurlyBracket()); // End parse body // Produce if expression members.Add(ForStatementExpression.Produce(forExpression)); } // 3. Other else { int semicolonBefore = symbols.TakeWhile(s => !(s is Semicolon)).Count(); // Get IEnumerable <Symbol> memberPartSymbols = symbols.Take(semicolonBefore + 1); // Empty symbols = symbols.Skip(semicolonBefore + 1); switch (identify) { case "clip": members.Add(ClipStatementExpression.Produce(memberPartSymbols)); break; case "break": members.Add(BreakStatementExpression.Produce(memberPartSymbols)); break; case "continue": members.Add(ContinueStatementExpression.Produce(memberPartSymbols)); break; case "discard": members.Add(DiscardStatementExpression.Produce(memberPartSymbols)); break; case "return": members.Add(ReturnStatementExpression.Produce(memberPartSymbols)); break; default: members.Add(StatementExpression.Produce(memberPartSymbols)); break; } } } RecursiveProduce(symbols, members); }
static void IfStatementProduce(ref IEnumerable <Symbol> symbols, List <Symbol> ifExpression, string identify) { // Normalize symbols = symbols.Skip(identify.Length); // Remove blank spaces ParserExtensions.RemoveBlankSpace(ref symbols); // Add syntax ifExpression.Add(new TextPart(identify)); bool skipHeaderParsed = false; if (identify == "else") { string identify2 = ParserExtensions.GetFirstText(ref symbols); if (!string.IsNullOrEmpty(identify2)) { if (identify2 != "if") { throw new ParserException("Error parsed if statement"); } // Normalize symbols = symbols.Skip(identify2.Length); // Remove blank spaces ParserExtensions.RemoveBlankSpace(ref symbols); // Add syntax ifExpression.Add(new TextPart(identify2)); } else { skipHeaderParsed = true; } } if (!skipHeaderParsed) { // Begin parse header IEnumerable <Symbol> argumentSymbols = ParserExtensions.TakeSymbolInRoundBrackets(ref symbols); // Add arguments ifExpression.Add(new OpenRoundBracket()); ifExpression.Add(IfHeaderExpression.Produce(argumentSymbols)); ifExpression.Add(new CloseRoundBracket()); // End parse header } // Remove blank spaces ParserExtensions.RemoveBlankSpace(ref symbols); // Begin parse body IEnumerable <Symbol> bodySymbols = ParserExtensions.TakeSymbolInCurlyBrackets(ref symbols); // Add function body ifExpression.Add(new OpenCurlyBracket()); ifExpression.Add(StatementBlockExpression.Produce(bodySymbols)); ifExpression.Add(new CloseCurlyBracket()); // End parse body // Remove blank spaces ParserExtensions.RemoveBlankSpace(ref symbols); // Find again if (!skipHeaderParsed) { if (identify == "if" || identify == "else") { string nextIdentify = ParserExtensions.GetFirstText(ref symbols); if (nextIdentify == "else") { IfStatementProduce(ref symbols, ifExpression, nextIdentify); } } } }
public static StatementExpression Produce(IEnumerable <Symbol> symbols) { List <Symbol> result = new List <Symbol>(); // Get variable type string left1 = ParserExtensions.ExtractText(ref symbols); if (!string.IsNullOrEmpty(left1)) { // Add variable type result.Add(new TextPart(left1)); ParserExtensions.RemoveBlankSpace(ref symbols); } // Get variable name string left2 = ParserExtensions.ExtractText(ref symbols); if (!string.IsNullOrEmpty(left2)) { // Add variable name result.Add(new TextPart(left2)); ParserExtensions.RemoveBlankSpace(ref symbols); } // Chack it has modified assign Symbol checking = symbols.First(); if (checking is Plus || checking is Minus || checking is Asterisk || checking is ForwardSlash) { symbols = symbols.Skip(1); result.Add(checking); ParserExtensions.RemoveBlankSpace(ref symbols); checking = symbols.First(); if (!(checking is Equals)) { string variableTypeName = left1; if (!string.IsNullOrEmpty(left2)) { variableTypeName += " " + left2; } throw new ParserException("Error parsed statement for " + variableTypeName + ". Missing assign"); } } // Chack it has assign or not if (checking is Equals) { // If has // Remove assign from symbols // Add assign to members int assignBefore = symbols.TakeWhile(s => !(s is Equals)).Count(); symbols = symbols.Skip(assignBefore + 1); result.Add(new Equals()); // Parsing right side ParsingRightSide(ref symbols, result); // Remove semicolon from symbols // Add sememicolon to members int semicolonBefore = symbols.TakeWhile(s => !(s is Semicolon)).Count(); symbols = symbols.Skip(semicolonBefore + 1); result.Add(new Semicolon()); } // Chack it has semicolon or not else if (checking is Semicolon) { // If not // Remove semicolon from symbols // Add sememicolon to members int semicolonBefore = symbols.TakeWhile(s => !(s is Semicolon)).Count(); symbols = symbols.Skip(semicolonBefore + 1); result.Add(new Semicolon()); } else { string variableTypeName = left1; if (!string.IsNullOrEmpty(left2)) { variableTypeName += " " + left2; } throw new ParserException("Error parsed statement for " + variableTypeName); } return(result == null ? null : new StatementExpression(result)); }
static void RecursiveProduce(string name, ref IEnumerable <Symbol> symbols, List <Symbol> result) { ParserExtensions.RemoveBlankSpace(ref symbols); if (string.IsNullOrEmpty(name)) { return; } // Write procedure name result.Add(new TextPart(name)); // Begin procedure result.Add(new OpenRoundBracket()); bool searching = true; while (searching) { string text = ParserExtensions.ExtractText(ref symbols); if (!string.IsNullOrEmpty(text)) { ParserExtensions.RemoveBlankSpace(ref symbols); } Symbol nextSymbol = null; try { nextSymbol = symbols.First(s => !(s is DecimalDigit || s is Character || s is FullStop)); } catch { searching = false; } bool isProcedure = false; if (!string.IsNullOrEmpty(text) && nextSymbol is OpenRoundBracket) { isProcedure = true; result.Add(ProcedureExpression.Produce(text, ParserExtensions.TakeSymbolInRoundBrackets(ref symbols))); } else { if (!string.IsNullOrEmpty(text)) { result.Add(new TextPart(text)); } } if (!isProcedure && nextSymbol != null) { result.Add(nextSymbol); symbols = symbols.Skip(1); } ParserExtensions.RemoveBlankSpace(ref symbols); searching = symbols.Count() > 0; } // End procedure result.Add(new CloseRoundBracket()); }