public void Parse(ref string[] program)
{
string ifstring = ParseUtils.GetToken(ref program);
if (!ifstring.Equals("if", StringComparison.Ordinal))
{
throw new ParseException("If Statement should always start with if, found " + ifstring + " instead.");
}
string openbracket = ParseUtils.GetToken(ref program);
if (!openbracket.Equals("(", StringComparison.Ordinal))
{
throw new ParseException("if statement must be followed by a condition in brackets, found " + openbracket + " instead.");
}
_Condition = ConditionBuilder.Parse(ref program);
string closebracket = ParseUtils.GetToken(ref program);
if (!closebracket.Equals(")", StringComparison.Ordinal))
{
throw new ParseException("if statement found a conditional expression without a closing bracket, found " + closebracket + " instead.");
}
_Block = new RuleBlock();
_Block.Parse(ref program);
}
public void Parse(ref string[] program)
{
string repeatstring = ParseUtils.GetToken(ref program);
if (!repeatstring.Equals("repeat", StringComparison.Ordinal))
{
throw new ParseException("repeat Statement should always start with repeat, found " + repeatstring + " instead.");
}
string openbracket = ParseUtils.GetToken(ref program);
if (!openbracket.Equals("(", StringComparison.Ordinal))
{
throw new ParseException("if statement must be followed by a condition in brackets, found " + openbracket + " instead.");
}
_Expression = ExpressionBuilder.Parse(ref program);
if (_Expression.GetExpressionType() != VarType.varFloat)
{
throw new ParseException("repeat statement requires a float parameter");
}
string closebracket = ParseUtils.GetToken(ref program);
if (!closebracket.Equals(")", StringComparison.Ordinal))
{
throw new ParseException("if statement found a conditional expression without a closing bracket, found " + closebracket + " instead.");
}
_RepeatBlock = new RuleBlock();
_RepeatBlock.Parse(ref program);
}
public void Parse(ref string[] program)
{
IfConditionBlock ifConditionBlock = new IfConditionBlock();
ifConditionBlock.Parse(ref program);
_IfBlock.Add(ifConditionBlock);
string token = ParseUtils.PeekToken(program);
while (token.Equals("else", StringComparison.Ordinal))
{
string elsestring = ParseUtils.GetToken(ref program);
if (!elsestring.Equals("else", StringComparison.Ordinal))
{
throw new ParseException("missing else statement, found " + elsestring + " instead.");
}
string iftoken = ParseUtils.PeekToken(program);
if (iftoken.Equals("if", StringComparison.Ordinal))
{
IfConditionBlock ifCondBlock = new IfConditionBlock();
ifCondBlock.Parse(ref program);
_IfBlock.Add(ifCondBlock);
}
else
{
_ElseBlock = new RuleBlock();
_ElseBlock.Parse(ref program);
return; // no more blocks allowed...
}
token = ParseUtils.PeekToken(program);
}
}
public void Parse(ref string[] program)
{
_Target = ParseUtils.PeekToken(program);
bool isFloatVar = ShaderScript.IsFloatVar(_Target);
bool isVectorVar = ShaderScript.IsVectorVar(_Target);
bool isNullFunc = ShaderScript.IsNullFunction(_Target);
if (!isFloatVar && !isVectorVar && !isNullFunc)
{
throw new ParseException("Expected \"" + _Target + "\" to be a float or vector variable or a non-return function");
}
if (isFloatVar || isVectorVar)
{
_Target = ParseUtils.GetToken(ref program);
_IsNull = false;
WooScript._Log.AddMsg("Found target variable \"" + _Target + "\"");
WooScript._Log.Indent();
_AssignOp = ParseUtils.GetToken(ref program);
if (!ShaderScript.IsAssignOp(_AssignOp))
{
throw new ParseException("Expected \"" + _AssignOp + "\" to be an assignment operation");
}
}
_Argument = ShaderScript.ParseExpression(ref program);
}
public void Parse(ref string[] program)
{
string floatFunctionName = ParseUtils.GetToken(ref program);
_Function = WooScript.GetFloatFunction(floatFunctionName);
_Function.Parse(ref program);
}
public static string PeekToken(string[] lines)
{
string[] tempLines = lines.Clone() as string[];
string token = ParseUtils.GetToken(ref tempLines);
return(token);
}
public void ConsumeRule(ref string[] program)
{
string token = ParseUtils.GetToken(ref program);
if (!token.Equals("{", StringComparison.Ordinal))
{
throw new ParseException("rules/shaders not currently supported with arguments, expected {, found " + token + " instead.");
}
int braces = 1;
while (braces > 0)
{
token = ParseUtils.GetToken(ref program);
if (token.Equals("{", StringComparison.Ordinal))
{
braces++;
}
if (token.Equals("}", StringComparison.Ordinal))
{
braces--;
}
if (token.Equals("rule", StringComparison.Ordinal))
{
throw new ParseException("missing }, found " + token + " instead.");
}
if (token.Equals("shader", StringComparison.Ordinal))
{
throw new ParseException("missing }, found " + token + " instead.");
}
}
}
public void Parse(ref string[] program)
{
while (program[0].IndexOf(',') >= 0)
{
string rulename = ParseUtils.GetToken(ref program);
_Rule.Add(rulename);
string comma = ParseUtils.GetToken(ref program);
if (!comma.Equals(",", StringComparison.Ordinal))
{
throw new ParseException("Expected \",\"");
}
WooScript._Log.AddMsg("Rule1 : " + rulename);
Expression expression = ExpressionBuilder.Parse(ref program);
if (expression.GetExpressionType() != VarType.varFloat)
{
throw new ParseException("Failed to convert weighting parameter to repeat method to float");
}
_Weight.Add(expression);
WooScript._Log.AddMsg("Weight : " + expression);
comma = ParseUtils.PeekToken(program);
if (comma.Equals(",", StringComparison.Ordinal))
{
comma = ParseUtils.GetToken(ref program);
}
}
}
public void Parse(ref string[] program)
{
string openbrace = ParseUtils.GetToken(ref program);
string nexttoken = ParseUtils.PeekToken(program);
while (nexttoken != "}")
{
TokenType type = WooScript.GetTokenType(nexttoken);
if (nexttoken.Equals("if", StringComparison.Ordinal))
{
IfStatement ifStatement = new IfStatement();
ifStatement.Parse(ref program);
_Statements.Add(ifStatement);
}
else if (nexttoken.Equals("repeat", StringComparison.Ordinal))
{
RepeatStatement repeatStatement = new RepeatStatement();
repeatStatement.Parse(ref program);
_Statements.Add(repeatStatement);
}
else if (nexttoken.Equals("{", StringComparison.Ordinal))
{
ScopeStatement scopeStatement = new ScopeStatement();
scopeStatement.Parse(ref program);
_Statements.Add(scopeStatement);
}
else if (type == TokenType.rule)
{
CallStatement callStatement = new CallStatement();
callStatement.Parse(ref program);
_Statements.Add(callStatement);
}
else if (type == TokenType.nullFunction)
{
NullStatement nullStatement = new NullStatement();
nullStatement.Parse(ref program);
_Statements.Add(nullStatement);
}
else if ((type == TokenType.vecVar) || (type == TokenType.floatVar))
{
VarStatement varStatement = new VarStatement();
varStatement.Parse(ref program);
_Statements.Add(varStatement);
}
else
{
throw new ParseException("Unexpected token \"" + nexttoken + "\" at start of expression");
}
nexttoken = ParseUtils.PeekToken(program);
}
string closebrace = ParseUtils.GetToken(ref program);
}
public void Parse(ref string[] program)
{
_DistanceFunction = ParseUtils.GetToken(ref program);
if (WooScript.IsShader(_DistanceFunction))
{
_ShaderMode = true;
}
else
{
_ShaderMode = false;
}
}
public void Parse(ref string[] program)
{
string token = ParseUtils.PeekToken(program);
if (token.Equals("(", StringComparison.Ordinal))
{
token = ParseUtils.GetToken(ref program);
do
{
Argument arg = new Argument();
token = ParseUtils.GetToken(ref program);
if (token.Equals("float", StringComparison.Ordinal))
{
arg._Type = VarType.varFloat;
}
else if (token.Equals("vec", StringComparison.Ordinal))
{
arg._Type = VarType.varVector;
}
else
{
throw new ParseException("Expected type of parameter (float OR vec), not" + token);
}
arg._Name = ParseUtils.GetToken(ref program);
WooScript.ValidateName(arg._Name);
_Arguments.Add(arg);
token = ParseUtils.GetToken(ref program);
}while (token.Equals(",", StringComparison.Ordinal));
if (!token.Equals(")", StringComparison.Ordinal))
{
throw new ParseException("Expected \")\" but found \"" + token + "\" instead. :(");
}
}
foreach (Argument a in _Arguments)
{
a.Add();
}
block.Parse(ref program);
foreach (Argument a in _Arguments)
{
a.Remove();
}
}
public void Parse(ref string[] program)
{
string openbrace = ParseUtils.GetToken(ref program);
if (!openbrace.Equals("(", StringComparison.Ordinal))
{
throw new ParseException("Expected \"(\" at start of function parameters");
}
_XExpr = ExpressionBuilder.Parse(ref program);
if (_XExpr.GetExpressionType() != VarType.varFloat)
{
throw new ParseException("parameter one to vec() is not a float");
}
string comma = ParseUtils.GetToken(ref program);
if (!comma.Equals(",", StringComparison.Ordinal))
{
throw new ParseException("Expected \",\"");
}
_YExpr = ExpressionBuilder.Parse(ref program);
if (_YExpr.GetExpressionType() != VarType.varFloat)
{
throw new ParseException("parameter two to vec() is not a float");
}
comma = ParseUtils.GetToken(ref program);
if (!comma.Equals(",", StringComparison.Ordinal))
{
throw new ParseException("Expected \",\"");
}
_ZExpr = ExpressionBuilder.Parse(ref program);
if (_ZExpr.GetExpressionType() != VarType.varFloat)
{
throw new ParseException("parameter three to vec() is not a float");
}
string closebrace = ParseUtils.GetToken(ref program);
if (!closebrace.Equals(")", StringComparison.Ordinal))
{
throw new ParseException("Expected \")\" at end of function parameters");
}
}
public void Parse(ref string[] program)
{
string token = ParseUtils.GetToken(ref program);
if (token.Length > 0)
{
_MaterialFunction = token;
if (!WooScript.IsShader(_MaterialFunction))
{
throw new ParseException("materialfunction call expected a shader, sadly " + _MaterialFunction + " isn't one...");
}
}
else
{
_MaterialFunction = "";
}
}
public void Parse(ref string[] program)
{
_ColourExpr = ExpressionBuilder.Parse(ref program);
if (_ColourExpr.GetExpressionType() != VarType.varVector)
{
throw new ParseException("malformed directional light colour");
}
string comma = ParseUtils.GetToken(ref program);
if (!comma.Equals(",", StringComparison.Ordinal))
{
throw new ParseException("Expected \",\"");
}
_DirectionExpr = ExpressionBuilder.Parse(ref program);
if (_DirectionExpr.GetExpressionType() != VarType.varVector)
{
throw new ParseException("malformed directional light direction");
}
comma = ParseUtils.GetToken(ref program);
if (!comma.Equals(",", StringComparison.Ordinal))
{
throw new ParseException("Expected \",\"");
}
_AreaExpr = ExpressionBuilder.Parse(ref program);
if (_AreaExpr.GetExpressionType() != VarType.varFloat)
{
throw new ParseException("malformed directional light area");
}
comma = ParseUtils.GetToken(ref program);
if (!comma.Equals(",", StringComparison.Ordinal))
{
throw new ParseException("Expected \",\"");
}
_SamplesExpr = ExpressionBuilder.Parse(ref program);
if (_SamplesExpr.GetExpressionType() != VarType.varFloat)
{
throw new ParseException("malformed directional light samples");
}
}
public void Parse(ref string[] program)
{
_Rotate1 = ExpressionBuilder.Parse(ref program);
if (_Rotate1.GetExpressionType() != VarType.varVector)
{
throw new ParseException("_Rotate1 must be of type vector");
}
string comma = ParseUtils.GetToken(ref program);
if (!comma.Equals(",", StringComparison.Ordinal))
{
throw new ParseException("Expected \",\"");
}
_Rotate2 = ExpressionBuilder.Parse(ref program);
if (_Rotate2.GetExpressionType() != VarType.varVector)
{
throw new ParseException("_Rotate2 must be of type vector");
}
comma = ParseUtils.GetToken(ref program);
if (!comma.Equals(",", StringComparison.Ordinal))
{
throw new ParseException("Expected \",\"");
}
_Scale = ExpressionBuilder.Parse(ref program);
if (_Scale.GetExpressionType() != VarType.varFloat)
{
throw new ParseException("_Scale must be of type float");
}
comma = ParseUtils.GetToken(ref program);
if (!comma.Equals(",", StringComparison.Ordinal))
{
throw new ParseException("Expected \",\"");
}
_Offset = ExpressionBuilder.Parse(ref program);
if (_Offset.GetExpressionType() != VarType.varVector)
{
throw new ParseException("_Offset must be of type vector");
}
}
public void Parse(ref string[] program)
{
string token1 = ParseUtils.GetToken(ref program);
if (!token1.Equals("(", StringComparison.Ordinal))
{
throw new ParseException("Expected \"(\" in Brackets");
}
_Expression = ExpressionBuilder.Parse(ref program);
string token2 = ParseUtils.GetToken(ref program);
if (!token2.Equals(")", StringComparison.Ordinal))
{
throw new ParseException("Expected \")\" in Brackets");
}
}
public void Parse(ref string[] program)
{
_Variable = ParseUtils.GetToken(ref program);
TokenType tokenType = WooScript.GetTokenType(_Variable);
if (tokenType == TokenType.floatVar)
{
_Type = VarType.varFloat;
}
else if (tokenType == TokenType.vecVar)
{
_Type = VarType.varVector;
}
else
{
throw new ParseException("Unknown type for variable \"" + _Variable + "\"");
}
}
public void Parse(ref string[] program)
{
_Callee = ParseUtils.GetToken(ref program);
WooScript._Log.AddMsg("Callee : " + _Callee);
string comma = ParseUtils.GetToken(ref program);
if (!comma.Equals(",", StringComparison.Ordinal))
{
throw new ParseException("Expected \",\"");
}
_Expr = ExpressionBuilder.Parse(ref program);
if (_Expr.GetExpressionType() != VarType.varFloat)
{
throw new ParseException("Failed to convert repeat number to float");
}
WooScript._Log.AddMsg("Repeats : " + _Expr.ToString());
}
public void Parse(ref string[] program)
{
string _PatternStr = ParseUtils.GetToken(ref program);
if (_PatternStr.Length != 27)
{
throw new ParseException("argument must have 27 digits mengerpattern(101101...)");
}
for (int i = 0; i < 27; i++)
{
if (_PatternStr[i] == '1')
{
_Pattern[i] = 1;
}
else
{
_Pattern[i] = 0;
}
}
}
public void Parse(ref string[] program)
{
_ColourExpr = ExpressionBuilder.Parse(ref program);
if (_ColourExpr.GetExpressionType() != VarType.varVector)
{
throw new ParseException("malformed point light colour");
}
string comma = ParseUtils.GetToken(ref program);
if (!comma.Equals(",", StringComparison.Ordinal))
{
throw new ParseException("Expected \",\"");
}
_PositionExpr = ExpressionBuilder.Parse(ref program);
if (_PositionExpr.GetExpressionType() != VarType.varVector)
{
throw new ParseException("malformed point light position");
}
}
public void Parse(ref string[] program)
{
string token = ParseUtils.GetToken(ref program);
WooScript._Log.AddMsg("Found \"" + token + "\" function (null return)");
WooScript._Log.Indent();
_NullFunction = WooScript.GetNullFunction(token);
string openCurl = ParseUtils.GetToken(ref program);
if (!openCurl.Equals("(", StringComparison.Ordinal))
{
new ParseException("Expected \"(\" not \"" + openCurl + "\"");
}
_NullFunction.Parse(ref program);
string closeCurl = ParseUtils.GetToken(ref program);
if (!closeCurl.Equals(")", StringComparison.Ordinal))
{
new ParseException("Expected \")\" not \"" + closeCurl + "\"");
}
WooScript._Log.UnIndent();
}
public void Parse(ref string[] program)
{
string token = ParseUtils.GetToken(ref program);
WooScript._Log.AddMsg("Found function, target \"" + token + "\"");
WooScript._Log.Indent();
if (WooScript.IsFloatVariable(token))
{
_ReturnType = VarType.varFloat;
_Var = token;
}
else if (WooScript.IsVecVariable(token))
{
_ReturnType = VarType.varVector;
_Var = token;
}
else
{
throw new ParseException("Expected \"" + token + "\" to be a float or vector variable");
}
string assignOp = ParseUtils.GetToken(ref program);
_AssignOp = WooScript.GetAssignOp(assignOp);
_Expression = ExpressionBuilder.Parse(ref program);
if (_ReturnType == VarType.varVector &&
(_Expression.GetExpressionType() != VarType.varVector))
{
throw new ParseException("Target token is \"" + token + "\" which is a vector, expression isn't...");
}
if (_ReturnType == VarType.varFloat &&
(_Expression.GetExpressionType() != VarType.varFloat))
{
throw new ParseException("Target token is \"" + token + "\" which is a float, expression isn't...");
}
}
public void Parse(ref string[] program)
{
string openbrace = ParseUtils.GetToken(ref program);
if (!openbrace.Equals("(", StringComparison.Ordinal))
{
throw new ParseException("Expected \"(\" at start of function parameters");
}
_Arg = ExpressionBuilder.Parse(ref program);
if (_Arg.GetExpressionType() != VarType.varVector)
{
throw new ParseException("parameter to normalise() is not a vector");
}
string closebrace = ParseUtils.GetToken(ref program);
if (!closebrace.Equals(")", StringComparison.Ordinal))
{
throw new ParseException("Expected \")\" at end of function parameters");
}
}
public void Parse(ref string[] program)
{
string openbrace = ParseUtils.GetToken(ref program);
if (!openbrace.Equals("{"))
{
throw new ParseException("Found \"" + openbrace + "\", but expected \"{\".");
}
string nexttoken = ParseUtils.PeekToken(program);
while (nexttoken != "}")
{
ShaderStatement shaderStatement = new ShaderStatement();
shaderStatement.Parse(ref program);
_Statements.Add(shaderStatement);
nexttoken = ParseUtils.PeekToken(program);
}
string closebrace = ParseUtils.GetToken(ref program);
}
public void Parse(ref string[] program)
{
string data = ParseUtils.GetToken(ref program);
// deal with -ve numbers (bit hacky, but keeps the token parser state free)
if (data.Length == 1 && data[0] == '-')
{
data += ParseUtils.GetToken(ref program);
}
if (data.IndexOf(':') > 0)
{
_RangeType = RangeTypeT.Continuous;
WooScript._Log.AddMsg("Number type : Continuous range");
int opPos = data.IndexOf(':');
val1 = StringToFloat(data.Substring(0, opPos));
val2 = StringToFloat(data.Substring(opPos + 1));
WooScript._Log.AddMsg("Val1 : " + val1.ToString(CultureInfo.InvariantCulture));
WooScript._Log.AddMsg("Val2 : " + val2.ToString(CultureInfo.InvariantCulture));
}
else if (data.IndexOf('|') > 0)
{
_RangeType = RangeTypeT.Binary;
WooScript._Log.AddMsg("Number type : Binary Option");
int opPos = data.IndexOf('|');
val1 = StringToFloat(data.Substring(0, opPos));
val2 = StringToFloat(data.Substring(opPos + 1));
WooScript._Log.AddMsg("Val1 : " + val1.ToString(CultureInfo.InvariantCulture));
WooScript._Log.AddMsg("Val2 : " + val2.ToString(CultureInfo.InvariantCulture));
}
else
{
_RangeType = RangeTypeT.Single;
WooScript._Log.AddMsg("Number type : Single Value");
val1 = StringToFloat(data);
WooScript._Log.AddMsg("Val1 : " + val1.ToString(CultureInfo.InvariantCulture));
}
}
public void Parse(ref string[] program)
{
string ruleName = ParseUtils.GetToken(ref program);
_RulePrototype = WooScript.GetRulePrototype(ruleName);
WooScript._Log.AddMsg("Call Rule : " + ruleName);
string openbracket = ParseUtils.PeekToken(program);
if (openbracket.Equals("(", StringComparison.Ordinal) || _RulePrototype._Args.Count() > 0)
{
openbracket = ParseUtils.GetToken(ref program);
if (!openbracket.Equals("(", StringComparison.Ordinal))
{
throw new ParseException("rule called without required arguments, or syntax error. Found " + openbracket + ", expeceted \"(\" instead.");
}
for (int i = 0; i < _RulePrototype._Args.Count(); i++)
{
_ArgValue.Add(ExpressionBuilder.Parse(ref program));
if (i + 1 < _RulePrototype._Args.Count())
{
string comma = ParseUtils.GetToken(ref program);
if (!comma.Equals(",", StringComparison.Ordinal))
{
throw new ParseException("Found " + comma + " but expected another argument after a \",\"");
}
}
}
string closebracket = ParseUtils.GetToken(ref program);
if (!closebracket.Equals(")", StringComparison.Ordinal))
{
throw new ParseException("rules not currently supported with arguments, missing ), found " + closebracket + " instead.");
}
}
}
public static ScriptElement ParseExpression(ref string[] program)
{
ScriptElement ret = new ScriptElement();
string token = ParseUtils.PeekToken(program);
ret._Reorderable = false;
if (token.Equals("-", StringComparison.Ordinal))
{
token = ParseUtils.GetToken(ref program);
token += ParseUtils.PeekToken(program);
}
if (token.Equals("(", StringComparison.Ordinal))
{
token = ParseUtils.GetToken(ref program);
ret = ParseExpression(ref program);
ret._Reorderable = false;
token = ParseUtils.GetToken(ref program);
if (!token.Equals(")", StringComparison.Ordinal))
{
throw new ParseException("Missing closebracket on bracketed expression, found" + token);
}
}
else if (IsFloatVar(token))
{
token = ParseUtils.GetToken(ref program);
ret._Type = SEType.FloatVar;
ret._String = token;
}
else if (IsVectorVar(token))
{
token = ParseUtils.GetToken(ref program);
ret._Type = SEType.VectorVar;
ret._String = token;
}
else if (IsFloatNum(token))
{
string chuck = ParseUtils.GetToken(ref program);
ret._Type = SEType.FloatVar;
ret._String = token;
}
else if (token.Equals("{"))
{
ret._Type = SEType.CodeBlock;
ret._Codeblock = new CodeBlock();
ret._Codeblock.Parse(ref program);
}
else if (token.IndexOf('.') > -1)
{
token = ParseUtils.GetToken(ref program);
int dotPosition = token.IndexOf('.');
ret._Type = SEType.VectorVar;
ret._String = token.Substring(0, dotPosition);
ScriptElement getter = new ScriptElement();
string index = token.Substring(dotPosition + 1);
if (index.Equals("x", StringComparison.Ordinal))
{
getter._String = "getx";
}
else if (index.Equals("y", StringComparison.Ordinal))
{
getter._String = "gety";
}
else if (index.Equals("z", StringComparison.Ordinal))
{
getter._String = "getz";
}
else
{
throw new ParseException("Invalid subindex " + index);
}
getter._Arguments.Add(ret);
getter._Type = SEType.FloatVar;
ret = getter;
}
else if (token.Equals("repeat", StringComparison.Ordinal))
{
token = ParseUtils.GetToken(ref program);
ret._String = token;
string openBracket = ParseUtils.PeekToken(program);
if (openBracket.Equals("(", StringComparison.Ordinal))
{
openBracket = ParseUtils.GetToken(ref program);
ret._Arguments.Add(ParseExpression(ref program));
string closeBracket = ParseUtils.GetToken(ref program);
if (!closeBracket.Equals(")", StringComparison.Ordinal))
{
throw new ParseException("Expected close bracket, found \"" + token + "\"");
}
}
else
{
throw new ParseException("repeat not followed by number, found \"" + token + "\", usage : repeat(x){}");
}
ret._Arguments.Add(ParseExpression(ref program));
}
else if (IsFunction(token))
{
token = ParseUtils.GetToken(ref program);
ret._String = token;
string openBracket = ParseUtils.PeekToken(program);
if (openBracket.Equals("(", StringComparison.Ordinal))
{
openBracket = ParseUtils.GetToken(ref program);
ret._Arguments.Add(ParseExpression(ref program));
string comma = ParseUtils.PeekToken(program);
while (comma.Equals(",", StringComparison.Ordinal))
{
comma = ParseUtils.GetToken(ref program);
ret._Arguments.Add(ParseExpression(ref program));
comma = ParseUtils.PeekToken(program);
}
string closeBracket = ParseUtils.GetToken(ref program);
if (!closeBracket.Equals(")", StringComparison.Ordinal))
{
throw new ParseException("Expected close bracket, found \"" + token + "\"");
}
}
ValidateFunction(ret);
}
else
{
throw new ParseException("Unrecognised token found \"" + token + "\"");
}
string opCode = ParseUtils.PeekToken(program);
if (IsOperator(opCode))
{
opCode = ParseUtils.GetToken(ref program);
ScriptElement opElement = new ScriptElement();
if (opCode.Equals("+", StringComparison.Ordinal))
{
opElement._String = "add";
}
if (opCode.Equals("-", StringComparison.Ordinal))
{
opElement._String = "sub";
}
if (opCode.Equals("*", StringComparison.Ordinal))
{
opElement._String = "mul";
}
if (opCode.Equals("/", StringComparison.Ordinal))
{
opElement._String = "div";
}
if (opCode.Equals("%", StringComparison.Ordinal))
{
opElement._String = "mod";
}
opElement._Type = ret._Type;
opElement._Arguments.Add(ret);
ScriptElement arg2 = ParseExpression(ref program);
opElement._Arguments.Add(arg2);
if (arg2._Reorderable)
{
if (GetPrecedence(opElement._String) < GetPrecedence(arg2._String))
{
ScriptElement Arg1Arg1 = ret;
ScriptElement Arg2Arg1 = arg2._Arguments.ElementAt(0);
ScriptElement Arg2Arg2 = arg2._Arguments.ElementAt(1);
arg2._Arguments.Clear();
arg2._Arguments.Add(opElement);
arg2._Arguments.Add(Arg2Arg2);
opElement._Arguments.Clear();
opElement._Arguments.Add(Arg1Arg1);
opElement._Arguments.Add(Arg2Arg1);
opElement = arg2;
}
}
ret = opElement;
ret._Reorderable = true;
ValidateFunction(opElement);
}
return(ret);
}
public void Parse(ref string[] program)
{
string op = ParseUtils.GetToken(ref program);
_Op = WooScript.GetOp(op);
}
public void ParseProgram(ref string[] program)
{
string token;
// pre parse
string[] preprogram = program.Clone() as string[];
do
{
token = ParseUtils.GetToken(ref preprogram);
if (string.Compare(token, "rule", true) == 0)
{
string rulename = ParseUtils.GetToken(ref preprogram);
_Log.AddMsg("Preparser found rule " + rulename);
RulePrototype ruleproto = new RulePrototype(rulename);
string itoken = ParseUtils.PeekToken(preprogram);
if (itoken.Equals("(", StringComparison.Ordinal))
{
itoken = ParseUtils.GetToken(ref preprogram);
do
{
itoken = ParseUtils.GetToken(ref preprogram); // type
Argument arg = new Argument();
if (itoken.Equals("float", StringComparison.Ordinal))
{
arg._Type = VarType.varFloat;
}
else if (itoken.Equals("vec", StringComparison.Ordinal))
{
arg._Type = VarType.varVector;
}
else
{
throw new ParseException("Expected type of parameter (float OR vec), not" + itoken);
}
arg._Name = ParseUtils.GetToken(ref preprogram); // name
ruleproto._Args.Add(arg);
itoken = ParseUtils.GetToken(ref preprogram); // , or )
}while (itoken.Equals(",", StringComparison.Ordinal));
}
_RulePrototypes.Add(ruleproto);
ConsumeRule(ref preprogram);
}
else if (string.Compare(token, "shader", true) == 0)
{
string shadername = ParseUtils.GetToken(ref preprogram);
_Log.AddMsg("Preparser found shader " + shadername);
_ShaderNames.Add(shadername);
ConsumeRule(ref preprogram);
}
else
{
if (token.Length > 0)
{
throw new ParseException("Global statements must start with \"rule\".");
}
}
}while (token.Length > 0);
// full parse
do
{
token = ParseUtils.GetToken(ref program);
if (string.Compare(token, "rule", true) == 0)
{
string rulename = ParseUtils.GetToken(ref program);
_Log.AddMsg("Found rule " + rulename);
Rule newRule = new Rule(rulename);
_Log.Indent();
newRule.Parse(ref program);
_Log.UnIndent();
_Rules.Add(newRule);
}
else if (string.Compare(token, "shader", true) == 0)
{
string shadername = ParseUtils.GetToken(ref program);
_Log.AddMsg("Found shader " + shadername);
Shader newShader = new Shader(shadername);
_Log.Indent();
newShader.Parse(ref program);
_Log.UnIndent();
_Shaders.Add(newShader);
}
else
{
if (token.Length > 0)
{
throw new ParseException("Global statements must start with \"rule\".");
}
}
}while (token.Length > 0);
// rule rulename { statement* }
// statement = floatvar aop floatrhs | vecvar aop vecexpr | nfun ( args )
// args = (rulename|floatexpr|vecexpr)*
// floatexpr = ( floatexpr ) | num op floatexpr | ffun(args) op floatexpr | num | ffun(args) | floatvar
// num = 0.x | vec.sel
// vecexpr = Vec(floatexpr, floatexpr, floatexpr) | vec op vecexpr | vfun ( args )
// vec = vec(x,y,z) | vec(x,y,z).rep
}
public static ConditionalExpression Parse(ref string[] program)
{
ConditionalExpression ret = null;
Expression expr = null;
string token1 = ParseUtils.PeekToken(program);
TokenType type1 = WooScript.GetTokenType(token1);
if (token1.Equals("(", StringComparison.Ordinal))
{
ret = new ConditionalBrackets();
(ret as ConditionalBrackets).Parse(ref program);
}
else if (type1 == TokenType.UnaryBooleanOp)
{
ret = WooScript.GetUnaryBooleanOp(token1);
(ret as UnaryBooleanOp).Parse(ref program);
}
else if (type1 == TokenType.floatVar ||
type1 == TokenType.floatNum ||
type1 == TokenType.floatFunction)
{
expr = ExpressionBuilder.Parse(ref program);
}
else
{
throw new ParseException("Unrecognised expression \"" + token1 + "\"");
}
string token2 = ParseUtils.GetToken(ref program);
TokenType type2 = WooScript.GetTokenType(token2);
if (type2 == TokenType.ConditionalOp)
{
if (type1 != TokenType.floatNum && type1 != TokenType.floatVar && type1 != TokenType.floatFunction)
{
throw new ParseException("Conditional operation only takes floating point parameters");
}
ConditionalOp condOp = WooScript.GetConditionalOp(token2);
condOp._Arg1 = expr;
Expression arg2 = ExpressionBuilder.Parse(ref program);
if (arg2.GetExpressionType() != VarType.varFloat)
{
throw new ParseException("Conditional operation only takes floating point parameters");
}
condOp._Arg2 = arg2;
// no need for precedence check on conditional operator
ret = condOp;
string token3 = ParseUtils.PeekToken(program);
TokenType type3 = WooScript.GetTokenType(token3);
if (type3 == TokenType.BooleanOp)
{
BooleanOp boolOp = WooScript.GetBooleanOp(token3);
boolOp._Arg1 = condOp;
ConditionalExpression condArg2 = ConditionBuilder.Parse(ref program);
boolOp._Arg2 = condArg2;
// operator precedence check
if (condArg2 is BooleanOp)
{
if ((condArg2 as BooleanOp).GetPrecedence() < boolOp.GetPrecedence())
{
// shuffle args
boolOp._Arg2 = (condArg2 as BooleanOp)._Arg1;
(condArg2 as BooleanOp)._Arg1 = boolOp;
boolOp = (condArg2 as BooleanOp);
}
}
ret = boolOp;
}
}
if (ret == null)
{
throw new ParseException("Malformed conditional expression, expected conditional operation");
}
return(ret);
}
