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());
}
