|
public UnreadToken ( |
||
| token | ||
| Résultat | void | |
public bool Parse(idScriptParser parser)
{
// first token should be function call
// then a potentially variable set of parms
// ended with a ;
idToken token;
GuiCommand cmd = new GuiCommand();
if((token = parser.ReadToken()) == null)
{
parser.Error("Unexpected end of file");
return false;
}
_handler = null;
string tokenLower = token.ToString().ToLower();
foreach(GuiCommand tmp in CommandList)
{
if(tmp.Name.ToLower() == tokenLower)
{
_handler = tmp.Handler;
cmd = tmp;
break;
}
}
if(_handler == null)
{
parser.Error("Unknown script call {0}", token.ToString());
}
// now read parms til ;
// all parms are read as idWinStr's but will be fixed up later
// to be proper types
while(true)
{
if((token = parser.ReadToken()) == null)
{
parser.Error("Unexpected end of file");
return false;
}
tokenLower = token.ToString().ToLower();
if(tokenLower == ";")
{
break;
}
else if(tokenLower == "}")
{
parser.UnreadToken(token);
break;
}
idWinString str = new idWinString(string.Empty);
str.Set(token.ToString());
_parameters.Add(new idWinGuiScript(true, str));
}
//
// verify min/max params
if((_handler != null) && ((_parameters.Count < cmd.MinParameterCount) || (_parameters.Count > cmd.MaxParameterCount)))
{
parser.Error("incorrect number of parameters for script {0}", cmd.Name);
}
//
return true;
}
/// <summary>
///
/// </summary>
/// <param name="parser"></param>
/// <param name="var"></param>
/// <param name="component"></param>
/// <returns>Returns a register index.</returns>
private int ParseTerm(idScriptParser parser, idWindowVariable var, int component)
{
int a, b;
object tmp;
idToken token = parser.ReadToken();
string tokenValue = token.ToString().ToLower();
if(tokenValue == "(")
{
a = ParseExpression(parser);
parser.ExpectTokenString(")");
return a;
}
else if(tokenValue == "time")
{
return (int) WindowExpressionRegister.Time;
}
// parse negative numbers
else if(tokenValue == "-")
{
token = parser.ReadToken();
if((token.Type == TokenType.Number) || (token.ToString() == "."))
{
return ExpressionConstant(-token.ToFloat());
}
parser.Warning("Bad negative number '{0}'", token.ToString());
return 0;
}
if((token.Type == TokenType.Number) || (token.ToString() == ".") || (token.ToString() == "-"))
{
return ExpressionConstant(token.ToFloat());
}
// see if it is a table name
idDeclTable table = idE.DeclManager.FindType<idDeclTable>(DeclType.Table, token.ToString(), false);
if(table != null)
{
a = table.Index;
// parse a table expression
parser.ExpectTokenString("[");
b = ParseExpression(parser);
parser.ExpectTokenString("]");
return EmitOperation(a, b, WindowExpressionOperationType.Table);
}
if(var == null)
{
var = GetVariableByName(token.ToString(), true);
}
if(var != null)
{
var.Init(tokenValue, this);
tmp = var;
b = component;
if(var is idWinVector4)
{
if((token = parser.ReadToken()) != null)
{
if(token.ToString() == "[")
{
b = ParseExpression(parser);
parser.ExpectTokenString("]");
}
else
{
parser.UnreadToken(token);
}
}
return EmitOperation(tmp, b, WindowExpressionOperationType.Var);
}
else if(var is idWinFloat)
{
return EmitOperation(tmp, b, WindowExpressionOperationType.VarF);
}
else if(var is idWinInteger)
{
return EmitOperation(tmp, b, WindowExpressionOperationType.VarI);
}
else if(var is idWinBool)
{
return EmitOperation(tmp, b, WindowExpressionOperationType.VarB);
}
else if(var is idWinString)
{
return EmitOperation(tmp, b, WindowExpressionOperationType.VarS);
}
else
{
parser.Warning("Variable expression not vec4, float or int '{0}'", token.ToString());
}
return 0;
}
else
{
// ugly but used for post parsing to fixup named vars
EmitOperation(token.ToString(), -2, WindowExpressionOperationType.Var);
}
return 0;
}
private int ParseExpressionPriority(idScriptParser parser, int priority, idWindowVariable var = null, int component = 0)
{
if(priority == 0)
{
return ParseTerm(parser, var, component);
}
idToken token;
string tokenValue;
int a = ParseExpressionPriority(parser, priority - 1, var, component);
if((token = parser.ReadToken()) == null)
{
// we won't get EOF in a real file, but we can when parsing from generated strings
return a;
}
tokenValue = token.ToString();
if(priority == 1)
{
if(tokenValue == "*")
{
return ParseEmitOperation(parser, a, WindowExpressionOperationType.Multiply, priority);
}
else if(tokenValue == "/")
{
return ParseEmitOperation(parser, a, WindowExpressionOperationType.Divide, priority);
}
else if(tokenValue == "%")
{
return ParseEmitOperation(parser, a, WindowExpressionOperationType.Modulo, priority);
}
}
else if(priority == 2)
{
if(tokenValue == "+")
{
return ParseEmitOperation(parser, a, WindowExpressionOperationType.Add, priority);
}
else if(tokenValue == "-")
{
return ParseEmitOperation(parser, a, WindowExpressionOperationType.Subtract, priority);
}
}
else if(priority == 3)
{
if(tokenValue == ">")
{
return ParseEmitOperation(parser, a, WindowExpressionOperationType.GreaterThan, priority);
}
else if(tokenValue == ">=")
{
return ParseEmitOperation(parser, a, WindowExpressionOperationType.GreaterThanOrEqual, priority);
}
else if(tokenValue == "<")
{
return ParseEmitOperation(parser, a, WindowExpressionOperationType.LessThan, priority);
}
else if(tokenValue == "<=")
{
return ParseEmitOperation(parser, a, WindowExpressionOperationType.LessThanOrEqual, priority);
}
else if(tokenValue == "==")
{
return ParseEmitOperation(parser, a, WindowExpressionOperationType.Equal, priority);
}
else if(tokenValue == "!=")
{
return ParseEmitOperation(parser, a, WindowExpressionOperationType.NotEqual, priority);
}
}
else if(priority == 4)
{
if(tokenValue == "&&")
{
return ParseEmitOperation(parser, a, WindowExpressionOperationType.And, priority);
}
else if(tokenValue == "||")
{
return ParseEmitOperation(parser, a, WindowExpressionOperationType.Or, priority);
}
else if(tokenValue == "?")
{
WindowExpressionOperation op;
int o = ParseEmitOperation(parser, a, WindowExpressionOperationType.Conditional, priority, out op);
if((token = parser.ReadToken()) == null)
{
return o;
}
else if(token.ToString() == ":")
{
a = ParseExpressionPriority(parser, priority - 1, var);
op.D = a;
}
return priority;
}
}
// assume that anything else terminates the expression
// not too robust error checking...
parser.UnreadToken(token);
return a;
}
private bool ParseScript(idScriptParser parser, idGuiScriptList list, bool elseBlock = false)
{
bool ifElseBlock = false;
idToken token;
// scripts start with { ( unless parm is true ) and have ; separated command lists.. commands are command,
// arg.. basically we want everything between the { } as it will be interpreted at
// run time
if(elseBlock == true)
{
token = parser.ReadToken();
if(token.ToString().ToLower() == "if")
{
ifElseBlock = true;
}
parser.UnreadToken(token);
if((ifElseBlock == false) && (parser.ExpectTokenString("{") == false))
{
return false;
}
}
else if(parser.ExpectTokenString("{") == false)
{
return false;
}
int nest = 0;
string tokenLower;
while(true)
{
if((token = parser.ReadToken()) == null)
{
parser.Error("Unexpected end of file");
return false;
}
tokenLower = token.ToString().ToLower();
if(tokenLower == "{")
{
nest++;
}
else if(tokenLower == "}")
{
if(nest-- <= 0)
{
return true;
}
}
idGuiScript script = new idGuiScript();
if(tokenLower == "if")
{
script.ConditionRegister = ParseExpression(parser);
ParseScript(parser, script.IfList);
if((token = parser.ReadToken()) != null)
{
if(token.ToString() == "else")
{
// pass true to indicate we are parsing an else condition
ParseScript(parser, script.ElseList, true);
}
else
{
parser.UnreadToken(token);
}
}
list.Append(script);
// if we are parsing an else if then return out so
// the initial "if" parser can handle the rest of the tokens
if(ifElseBlock == true)
{
return true;
}
continue;
}
else
{
parser.UnreadToken(token);
}
// empty { } is not allowed
if(token.ToString() == "{")
{
parser.Error("Unexpected {");
return false;
}
script.Parse(parser);
list.Append(script);
}
}
public bool Parse(idScriptParser parser, bool rebuild)
{
if(this.Disposed == true)
{
throw new ObjectDisposedException(this.GetType().Name);
}
if(rebuild == true)
{
CleanUp();
}
_timeLineEvents.Clear();
_namedEvents.Clear();
_transitions.Clear();
idToken token2;
idToken token = parser.ExpectTokenType(TokenType.Name, 0);
DrawWindow drawWindow;
SetInitialState(token.ToString());
parser.ExpectTokenString("{");
token = parser.ExpectAnyToken();
bool ret = true;
while(token.ToString() != "}")
{
string tokenLower = token.ToString().ToLower();
// track what was parsed so we can maintain it for the guieditor
parser.SetMarker();
if((tokenLower == "windowdef") || (tokenLower == "animationdef"))
{
if(tokenLower == "animationdef")
{
_visible.Set(false);
_rect.Set(new idRectangle(0, 0, 0, 0));
}
token = parser.ExpectTokenType(TokenType.Name, 0);
token2 = token;
parser.UnreadToken(token);
drawWindow = FindChildByName(token2.ToString());
if((drawWindow != null) && (drawWindow.Window != null))
{
SaveExpressionParseState();
drawWindow.Window.Parse(parser, rebuild);
RestoreExpressionParseState();
}
else
{
idWindow window = new idWindow(_gui, _context);
SaveExpressionParseState();
window.Parse(parser, rebuild);
RestoreExpressionParseState();
window.Parent = this;
drawWindow = new DrawWindow();
if(window.IsSimple == true)
{
drawWindow.Simple = new idSimpleWindow(window);
_drawWindows.Add(drawWindow);
}
else
{
AddChild(window);
SetFocus(window, false);
drawWindow.Window = window;
_drawWindows.Add(drawWindow);
}
}
}
else if(tokenLower == "editdef")
{
SaveExpressionParseState();
idEditWindow window = new idEditWindow(_context, _gui);
window.Parse(parser, rebuild);
RestoreExpressionParseState();
AddChild(window);
window.Parent = this;
drawWindow = new DrawWindow();
drawWindow.Simple = null;
drawWindow.Window = window;
_drawWindows.Add(drawWindow);
}
else if(tokenLower == "choicedef")
{
SaveExpressionParseState();
idChoiceWindow window = new idChoiceWindow(_context, _gui);
window.Parse(parser, rebuild);
RestoreExpressionParseState();
AddChild(window);
window.Parent = this;
drawWindow = new DrawWindow();
drawWindow.Simple = null;
drawWindow.Window = window;
_drawWindows.Add(drawWindow);
}
else if(tokenLower == "sliderdef")
{
SaveExpressionParseState();
idSliderWindow window = new idSliderWindow(_context, _gui);
window.Parse(parser, rebuild);
RestoreExpressionParseState();
AddChild(window);
window.Parent = this;
drawWindow = new DrawWindow();
drawWindow.Simple = null;
drawWindow.Window = window;
_drawWindows.Add(drawWindow);
}
else if(tokenLower == "markerdef")
{
idConsole.Warning("TODO: markerDef");
/*idMarkerWindow *win = new idMarkerWindow(dc, gui);
SaveExpressionParseState();
win->Parse(src, rebuild);
RestoreExpressionParseState();
AddChild(win);
win->SetParent(this);
dwt.simp = NULL;
dwt.win = win;
drawWindows.Append(dwt);*/
}
else if(tokenLower == "binddef")
{
SaveExpressionParseState();
idBindWindow window = new idBindWindow(_context, _gui);
window.Parse(parser, rebuild);
RestoreExpressionParseState();
AddChild(window);
window.Parent = this;
drawWindow = new DrawWindow();
drawWindow.Simple = null;
drawWindow.Window = window;
_drawWindows.Add(drawWindow);
}
else if(tokenLower == "listdef")
{
SaveExpressionParseState();
idListWindow window = new idListWindow(_context, _gui);
window.Parse(parser, rebuild);
RestoreExpressionParseState();
AddChild(window);
window.Parent = this;
drawWindow = new DrawWindow();
drawWindow.Simple = null;
drawWindow.Window = window;
_drawWindows.Add(drawWindow);
}
else if(tokenLower == "fielddef")
{
idConsole.Warning("TODO: fieldDef");
/*idFieldWindow *win = new idFieldWindow(dc, gui);
SaveExpressionParseState();
win->Parse(src, rebuild);
RestoreExpressionParseState();
AddChild(win);
win->SetParent(this);
dwt.simp = NULL;
dwt.win = win;
drawWindows.Append(dwt);*/
}
else if(tokenLower == "renderdef")
{
SaveExpressionParseState();
idRenderWindow window = new idRenderWindow(_context, _gui);
window.Parse(parser, rebuild);
RestoreExpressionParseState();
AddChild(window);
window.Parent = this;
drawWindow = new DrawWindow();
drawWindow.Simple = null;
drawWindow.Window = window;
_drawWindows.Add(drawWindow);
}
else if(tokenLower == "gamessddef")
{
idConsole.Warning("TODO: gameSSDDef");
/*idGameSSDWindow *win = new idGameSSDWindow(dc, gui);
SaveExpressionParseState();
win->Parse(src, rebuild);
RestoreExpressionParseState();
AddChild(win);
win->SetParent(this);
dwt.simp = NULL;
dwt.win = win;
drawWindows.Append(dwt);*/
}
else if(tokenLower == "gamebearshootdef")
{
idConsole.Warning("TODO: gameBearShootDef");
/*idGameBearShootWindow *win = new idGameBearShootWindow(dc, gui);
SaveExpressionParseState();
win->Parse(src, rebuild);
RestoreExpressionParseState();
AddChild(win);
win->SetParent(this);
dwt.simp = NULL;
dwt.win = win;
drawWindows.Append(dwt);*/
}
else if(tokenLower == "gamebustoutdef")
{
idConsole.Warning("TODO: gameBustOutDef");
/*idGameBustOutWindow *win = new idGameBustOutWindow(dc, gui);
SaveExpressionParseState();
win->Parse(src, rebuild);
RestoreExpressionParseState();
AddChild(win);
win->SetParent(this);
dwt.simp = NULL;
dwt.win = win;
drawWindows.Append(dwt);*/
}
//
// added new onEvent
else if(tokenLower == "onnamedevent")
{
// read the event name
if((token = parser.ReadToken()) == null)
{
parser.Error("Expected event name");
return false;
}
idNamedEvent ev = new idNamedEvent(token.ToString());
parser.SetMarker();
if(ParseScript(parser, ev.Event) == false)
{
ret = false;
break;
}
_namedEvents.Add(ev);
}
else if(tokenLower == "ontime")
{
idTimeLineEvent ev = new idTimeLineEvent();
if((token = parser.ReadToken()) == null)
{
parser.Error("Unexpected end of file");
return false;
}
int tmp;
int.TryParse(token.ToString(), out tmp);
ev.Time = tmp;
// reset the mark since we dont want it to include the time
parser.SetMarker();
if(ParseScript(parser, ev.Event) == false)
{
ret = false;
break;
}
// this is a timeline event
ev.Pending = true;
_timeLineEvents.Add(ev);
}
else if(tokenLower == "definefloat")
{
token = parser.ReadToken();
tokenLower = token.ToString().ToLower();
idWinFloat var = new idWinFloat(tokenLower);
_definedVariables.Add(var);
// add the float to the editors wrapper dict
// Set the marker after the float name
parser.SetMarker();
// Read in the float
_regList.AddRegister(tokenLower, RegisterType.Float, parser, this, var);
}
else if(tokenLower == "definevec4")
{
token = parser.ReadToken();
tokenLower = token.ToString().ToLower();
idWinVector4 var = new idWinVector4(tokenLower);
// set the marker so we can determine what was parsed
// set the marker after the vec4 name
parser.SetMarker();
// FIXME: how about we add the var to the desktop instead of this window so it won't get deleted
// when this window is destoyed which even happens during parsing with simple windows ?
//definedVars.Append(var);
_gui.Desktop._definedVariables.Add(var);
_gui.Desktop._regList.AddRegister(tokenLower, RegisterType.Vector4, parser, _gui.Desktop, var);
}
else if(tokenLower == "float")
{
token = parser.ReadToken();
tokenLower = token.ToString();
idWinFloat var = new idWinFloat(tokenLower);
_definedVariables.Add(var);
// add the float to the editors wrapper dict
// set the marker to after the float name
parser.SetMarker();
// Parse the float
_regList.AddRegister(tokenLower, RegisterType.Float, parser, this, var);
}
else if(ParseScriptEntry(token, parser) == true)
{
}
else if(ParseInternalVariable(token.ToString(), parser) == true)
{
}
else
{
ParseRegisterEntry(token.ToString(), parser);
}
if((token = parser.ReadToken()) == null)
{
parser.Error("Unexpected end of file");
ret = false;
break;
}
}
if(ret == true)
{
EvaluateRegisters(-1, true);
}
SetupFromState();
PostParse();
return ret;
}
