public static UserDefinedFunctionNode GetUserDefinedFunctionString(string input, RootNode root)
{
string potentialMatch = input.ToLower().Trim();
foreach (UserDefinedFunctionNode node in root.UserDefinedFunctionNodes)
{
if (node.ScriptString == potentialMatch)
{
return node;
}
}
return null;
}
public static UserDefinedFunctionNode GetUserDefinedFunctionString(string input, RootNode root)
{
for (int i = 0; i < input.Length; i++)
{
if (input[i] == '(')
{
string potentialMatch = input.Substring(0, i).Trim().ToLower();
foreach (UserDefinedFunctionNode node in root.UserDefinedFunctionNodes)
{
if (node.ScriptString == potentialMatch)
{
return node;
}
}
}
}
return null;
}
public void AddRootNodeIndeces(RootNode inputNode, List<int> inputList) // gives the trail of ChildRoots indeces to follow to reach the input root node
{
// e.g.
// <-- default root node (doesn't involve any spawn, always exists in all parsed scripts)
// orc <-- if this root node is input, then you would return a list with [0]
// {
// onDeath
// {
// troll <-- if this root node is input, then you would return a list with [0,0]
// {
// onDeath
// {
// MSG(TRIGMOB(),haha)
// }
// }
// orc <-- if this root node is input, then you would return a list with [0,1]
// {
// onDeath
// {
// MSG(TRIGMOB(),haha)
// }
// }
// }
// onHit
// {
// ettin <-- if this root node is input, then you would return a list with [0,2]
// {
// onDeath
// {
// MSG(TRIGMOB(),haha)
// }
// }
// }
// }
// titan <-- if this root node is input, then you would return a list with [1]
// {
// }
List<int> output = new List<int>();
// first find the root node just up one from this one
RootNode parentRoot = this.GetRootNode;
if (parentRoot == null)
return;
int index = 0;
foreach (RootNode child in parentRoot.ChildRoots)
{
if (child == inputNode)
{
// we have to "go backwards" up the tree, so add indeces related to the parent root first
AddRootNodeIndeces(parentRoot, inputList);
// now add the index for this, the closer ancestor
inputList.Add(index);
return;
}
index++;
}
// then traverse the rootnode tree, add indeces as you go, until the
}
public static RootNode ParseFileContents(string[] lines, string fileName)
{
CurrentFileBeingParsed = fileName;
// ERROR HANDLING OUTSIDE OF THIS FUNCTION
var balanceStack = new Stack<UberNode>();
RootNode root = new RootNode(null, null);
RootNode currentRoot = root; // spawn nodes are root nodes
UberNode current = root;
UberNode prev = null;
int currentLineNumber = 0;
int openCurlyBraces = 0;
var cleanedStrings = new List<CleanLine>();
foreach (string line in lines)
{
//Console.WriteLine(line);
currentLineNumber++;
StringBuilder sb = new StringBuilder();
string cleanedLine = line.Trim();
if (cleanedLine.StartsWith("//"))
{
continue;
}
bool insideQuotation = false;
bool justEscapedBackslash = false;
bool possibleComment = false;
int forLoopRemainingSemiColons = 0;
for (int i = 0; i < cleanedLine.Length; i++)
{
if (cleanedLine[i] == '\t')
{
continue; // always remove tabs... not allowed even in strings..
}
if (cleanedLine[i] == '\\')
{
if (!insideQuotation)
{
throw new UberScriptException(
String.Format(
"Parse: unexpected escape token '\\' in '{0}' at line {1}:\n{2}", fileName, currentLineNumber, cleanedLine));
}
if (!justEscapedBackslash)
{
if (i > 0 && cleanedLine[i - 1] == '\\')
{
justEscapedBackslash = true;
}
}
else
{
justEscapedBackslash = false;
}
sb.Append('\\'); // keep the double backslash in there regardless (it is handled in MathTree.ParseOperand)
continue;
}
if (cleanedLine[i] == '"')
{
if (!(i > 0 && cleanedLine[i - 1] == '\\' && !justEscapedBackslash))
{
insideQuotation = !insideQuotation;
}
sb.Append("\""); // add \" to the string
continue;
}
justEscapedBackslash = false; // make sure to reset this if you have gotten to this point
if (insideQuotation)
{
sb.Append(cleanedLine[i]);
continue;
}
if (cleanedLine[i] == '/')
{
if (possibleComment)
{
sb.Remove(sb.Length - 1, 1); // remove the previously added / character
break;
}
possibleComment = true;
sb.Append('/');
continue;
}
possibleComment = false;
if (cleanedLine[i] == ' ' || cleanedLine[i] == '\t')
{
continue;
}
// handle lines with multiple delimiters (e.g. orc { name = "Bob"; } )
if (cleanedLine[i] == '{' || cleanedLine[i] == '}')
{
// check if unbalanced
if (cleanedLine[i] == '{')
{
openCurlyBraces++;
}
else
{
openCurlyBraces--;
}
if (openCurlyBraces < 0)
{
throw new UberScriptException(
String.Format(
"Parse: brace mismatch detected in '{0}' at line {1}:\n{2}", fileName, currentLineNumber, cleanedLine));
}
// add everything before the { or } (if there is anything)
if (i > 0)
{
cleanedStrings.Add(new CleanLine(currentLineNumber, sb.ToString()));
}
cleanedStrings.Add(new CleanLine(currentLineNumber, cleanedLine[i].ToString(CultureInfo.InvariantCulture)));
// add { or } on separate "line" (it's processed as a line)
cleanedLine = cleanedLine.Substring(i + 1);
i = -1;
sb.Clear();
continue;
}
if (cleanedLine[i] == ';')
{
if (cleanedLine.Length == i + 1)
{
break;
} // we are at the end of the loop, ignore lines ending in semicolon
string stringPreviousToSemiColon = sb.ToString();
if (stringPreviousToSemiColon.Contains("for"))
{
if (stringPreviousToSemiColon.Contains("foreach("))
{
forLoopRemainingSemiColons += 1;
}
else if (stringPreviousToSemiColon.Contains("for(")) // for loop has 2 semicolons
{
forLoopRemainingSemiColons += 2;
}
}
if (forLoopRemainingSemiColons == 0)
{
// we have encountered a statement-separating semi-colon!
// add everything before the { or } (if there is anything)
if (i > 0)
{
cleanedStrings.Add(new CleanLine(currentLineNumber, sb.ToString()));
}
cleanedLine = cleanedLine.Substring(i + 1);
i = -1;
sb.Clear();
continue;
}
forLoopRemainingSemiColons--;
}
sb.Append(cleanedLine[i]);
}
cleanedLine = sb.ToString();
if (!String.IsNullOrWhiteSpace(cleanedLine) && !cleanedLine.StartsWith("//"))
{
cleanedStrings.Add(new CleanLine(currentLineNumber, sb.ToString()));
}
}
foreach (CleanLine cleanedString in cleanedStrings)
{
// i have to use this CleanLine object to keep track of line numbers
// in spite of {, }, and ; characters splitting the lines up!
currentLineNumber = cleanedString.LineNumber;
string cleanedLine = cleanedString.Value;
if (cleanedLine == "" || cleanedLine.StartsWith("//"))
{
continue;
}
if (cleanedLine == "{")
{
balanceStack.Push(current);
if (prev != null)
{
current = prev;
}
continue;
}
if (cleanedLine == "}")
{
if (balanceStack.Count > 0)
{
current = balanceStack.Pop();
if (current is RootNode)
{
// likely we have finished procesinto a spawn nodes (ChildRoots)
// and therefore need to go back to the spawn node's root
// so triggers are correctly assigned to it
currentRoot = current.GetRootNode;
}
continue;
}
throw new UberScriptException(
String.Format(
"Parse: brace mismatch detected in '{0}' at line {1}:\n{2}", fileName, currentLineNumber, cleanedLine));
}
// remove ending ";" characters (doesn't matter if you end with ; or not)
// CANNOT do more than one statement on a line, though.
// determine which type of node it is
string lowerCase = cleanedLine.ToLower();
if (UberScriptTriggers.HasTrigger(lowerCase))
{
prev = new TriggerNode(current, lowerCase);
//Console.WriteLine(current + "->" + prev);
currentRoot.TriggerNodes.Add(prev as TriggerNode);
}
else if (char.IsDigit(cleanedLine[0])) // must be a sequence node
{
int stage;
if (!Int32.TryParse(cleanedLine, out stage))
{
throw new UberScriptException(
String.Format(
"Parse: incorrect sequence format, integer expected at line {0}:\n{1}", currentLineNumber, cleanedLine));
}
prev = new SequenceNode(current, cleanedLine, stage);
}
else if (cleanedLine.StartsWith("foreach"))
{
/*
objs.moblist = GETNEARBYMOBS(TRIGMOB(),5)
foreach(objs.mob ; objs.moblist)
{
}
*/
prev = new ForEachNode(current, cleanedLine, currentLineNumber);
}
else if (cleanedLine.StartsWith("for"))
{
/*
for(ints.i = 0; ints.i < TRIGMOB().hits; ints.i = ints.i + 1)
{
}
*/
prev = new ForLoopNode(current, cleanedLine, currentLineNumber);
}
else if (cleanedLine.StartsWith("if") || cleanedLine.StartsWith("elif") || cleanedLine.StartsWith("else") ||
cleanedLine.StartsWith("elseif"))
{
prev = new ConditionalNode(current, cleanedLine, currentLineNumber);
//Console.WriteLine(current + "->" + prev);
}
else if (cleanedLine.StartsWith("return"))
{
prev = new ReturnNode(current, cleanedLine);
if (cleanedLine == "returnoverride")
{
((ReturnNode)prev).Override = true;
}
}
else switch (cleanedLine)
{
case "break":
{
// check whether it has a foreach / for ancestor
UberNode testParent = current;
bool foundForNodeAncestor = false;
while (testParent != null)
{
if (testParent is ForEachNode || testParent is ForLoopNode)
{
foundForNodeAncestor = true;
break;
}
testParent = testParent.Parent;
}
if (!foundForNodeAncestor)
{
throw new UberScriptException(
String.Format("Parse: unexpected 'break' statement at line {0}:\n{1}", currentLineNumber, cleanedLine));
}
prev = new BreakNode(current, cleanedLine);
}
break;
case "continue":
{
// check whether it has a foreach / for ancestor
UberNode testParent = current;
bool foundForNodeAncestor = false;
while (testParent != null)
{
if (testParent is ForEachNode || testParent is ForLoopNode)
{
foundForNodeAncestor = true;
break;
}
testParent = testParent.Parent;
}
if (!foundForNodeAncestor)
{
throw new UberScriptException(
String.Format("Parse: unexpected 'continue' statement at line {0}:\n{1}", currentLineNumber, cleanedLine));
}
prev = new ContinueNode(current, cleanedLine);
}
break;
default:
{
if (cleanedLine.StartsWith("pause"))
{
double pauseDuration;
if (!Double.TryParse(cleanedLine.Substring(5), out pauseDuration))
{
pauseDuration = 0;
}
prev = new PauseNode(current, cleanedLine, pauseDuration);
}
else if (cleanedLine.StartsWith("function"))
{
prev = new UserDefinedFunctionNode(current, lowerCase);
//Console.WriteLine(current + "->" + prev);
root.UserDefinedFunctionNodes.Add(prev as UserDefinedFunctionNode);
}
/*
else if (cleanedLine.StartsWith("spawngroup"))
{
prev = new SpawnGroupNode
}
else if (cleanedLine.StartsWith("spawnregion"))
{
}
else if (cleanedLine.StartsWith("spawnentry"))
{
}
*/
else
{
int equalCount = 0;
//char beforeChar = '\0';
int numOpenParentheses = 0;
bool inQuotes = false;
for (int i = 0; i < cleanedLine.Length; i++)
{
if (!inQuotes)
{
if (cleanedLine[i] == '=' && numOpenParentheses == 0)
{
equalCount++;
}
else
switch (cleanedLine[i])
{
case '(':
numOpenParentheses++;
break;
case ')':
{
numOpenParentheses--;
if (numOpenParentheses < 0)
{
throw new UberScriptException(
String.Format(
"Parse: parentheses mismatch detected in '{0}' at line {1}:\n{2}",
fileName,
currentLineNumber,
cleanedLine));
}
}
break;
}
}
if (cleanedLine[i] != '"')
{
continue;
}
inQuotes = !inQuotes; // assume that it's not an escaped quotation
// determine if it is an escaped quotation (and that there aren't escaped backslashes preceding it)
for (int ix = i - 1; ix >= 0 && cleanedLine[ix] == '\\'; ix--)
{
inQuotes = !inQuotes; // for each backslash behind, unescape or escape accordingly
}
}
if (equalCount == 1) // it's a statement node
{
prev = new StatementNode(current, cleanedLine, currentLineNumber);
//Console.WriteLine(current + "->" + prev);
if (((StatementNode)prev).ContainsSpawnNode)
{
// global_objs.test = orc
// {
// name = goober
// }
prev.LineNumber = currentLineNumber; // we "continue" here so we set this later
current.Children.Add(prev); // we "continue" here so we don't add it later
//Console.WriteLine(current + "->" + prev + "... adding spawn node to statement node!");
prev = prev.Children[1]; // should contain a spawn node
currentRoot.ChildRoots.Add(prev as RootNode);
currentRoot = prev as RootNode; // spawn node become the new root node
continue;
}
}
else if (UberScriptFunctions.IsFunctionString(cleanedLine))
{
prev = new FunctionNode(current, cleanedLine, currentLineNumber);
//Console.WriteLine(current + "->" + prev);
}
else if (UserDefinedFunctionNode.GetUserDefinedFunctionString(cleanedLine, root) != null)
{
prev = new UserDefinedFunctionExectueNode(current, cleanedLine, currentLineNumber);
((UserDefinedFunctionExectueNode)prev).UserDefinedFunction =
UserDefinedFunctionNode.GetUserDefinedFunctionString(cleanedLine, root);
}
else
{
// the string might have commas (indicating a spawn type with a constructor accepting arguments
// such as "static,100"
int commaIndex = cleanedLine.IndexOf(',');
Type spawnType =
ScriptCompiler.FindTypeByName(commaIndex > 0 ? cleanedLine.Substring(0, commaIndex) : cleanedLine);
if (spawnType != null && typeof(Mobile).IsAssignableFrom(spawnType) || typeof(Item).IsAssignableFrom(spawnType))
{
prev = new RootNode(current, cleanedLine);
// keep a list of child root nodes so that spawned creatures that have triggers
// specific to them can correctly point to the right place in the script e.g.
// troll
// {
// onDeath
// {
// orc
// {
// onDeath
// {
// ...
// }
// }
// }
// }
// --> trigger nodes are only added to their closest root node
currentRoot.ChildRoots.Add(prev as RootNode);
//Console.WriteLine(current + "->" + prev);
currentRoot = prev as RootNode; // spawn node become the new root node
}
else
{
throw new UberScriptException(
String.Format("Parse: could not parse node at line {0}:\n{1}", currentLineNumber, cleanedLine));
}
}
}
}
break;
}
current.Children.Add(prev);
prev.LineNumber = currentLineNumber; // used for debugging purposes
}
if (balanceStack.Count > 0)
{
throw new UberScriptException(
String.Format("Parse: brace mismatch detected in '{0}' at line {1}", fileName, currentLineNumber));
}
return root;
}
public static UserDefinedFunctionNode GetUserDefinedFunctionString(string input, RootNode root)
{
string potentialMatch = input.ToLower().Trim();
foreach (UserDefinedFunctionNode node in root.UserDefinedFunctionNodes)
{
if (node.ScriptString == potentialMatch)
{
return(node);
}
}
return(null);
}