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)
{
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)
{
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)
{
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)
{
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("{"))
{
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 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 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);
}
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 Expression Parse(ref string[] program)
{
Expression ret;
string token1 = ParseUtils.PeekToken(program);
TokenType type1 = WooScript.GetTokenType(token1);
if (token1.Equals("(", StringComparison.Ordinal))
{
ret = new Brackets();
ret.Parse(ref program);
}
else if (type1 == TokenType.floatNum)
{
ret = new FloatNumber();
ret.Parse(ref program);
}
else if (type1 == TokenType.floatVar ||
type1 == TokenType.vecVar)
{
ret = new Variable();
ret.Parse(ref program);
}
else if (type1 == TokenType.vecFunction)
{
ret = new VecFunctionExpr();
ret.Parse(ref program);
}
else if (type1 == TokenType.floatFunction)
{
ret = new FloatFunctionExpr();
ret.Parse(ref program);
}
else if (type1 == TokenType.Op)
{
//deal with -8 type numbers
ret = new FloatNumber();
ret.Parse(ref program);
}
else
{
throw new ParseException("Unrecognised expression \"" + token1 + "\"");
}
/* if (type1 == TokenType.floatFunction)
* {
* ret = new FloatFunction();
* ret.Parse(ref program);
* }
*/
string token2 = ParseUtils.PeekToken(program);
TokenType type2 = WooScript.GetTokenType(token2);
if (type2 == TokenType.Op)
{
FloatOperation flop = new FloatOperation();
flop.Parse(ref program);
flop._Argument1 = ret;
Expression arg2 = ExpressionBuilder.Parse(ref program);
flop._Argument2 = arg2;
// operator precedence check
if (arg2 is FloatOperation)
{
if ((arg2 as FloatOperation).GetPrecedence() < flop.GetPrecedence())
{
// shuffle args
flop._Argument2 = (arg2 as FloatOperation)._Argument1;
(arg2 as FloatOperation)._Argument1 = flop;
flop = (arg2 as FloatOperation);
}
}
if (flop._Argument1.GetExpressionType() != flop._Argument2.GetExpressionType())
{
throw new ParseException("Mismatch argument types on operation");
}
ret = flop;
}
return(ret);
}
