mirror of
https://git.do.srb2.org/STJr/UltimateZoneBuilder.git
synced 2024-12-18 08:01:36 +00:00
401 lines
No EOL
12 KiB
C#
401 lines
No EOL
12 KiB
C#
#region ================== Namespaces
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using CodeImp.DoomBuilder.Config;
|
|
using CodeImp.DoomBuilder.Data;
|
|
using CodeImp.DoomBuilder.GZBuilder.Data;
|
|
|
|
#endregion
|
|
|
|
//mxd. ACS parser used to create ScriptItems for use in script editor's navigator
|
|
namespace CodeImp.DoomBuilder.ZDoom.Scripting
|
|
{
|
|
internal sealed class AcsParserSE : ZDTextParser
|
|
{
|
|
#region ================== Event Delegates
|
|
|
|
internal delegate void IncludeDelegate(AcsParserSE parser, string includefile, IncludeType includetype);
|
|
internal IncludeDelegate OnInclude;
|
|
|
|
#endregion
|
|
|
|
#region ================== Variables
|
|
|
|
private readonly Dictionary<string, HashSet<string>> includes; // <either "SCRIPTS" or Source library name, <List of files it #includes>>
|
|
private HashSet<string> includestoskip;
|
|
private string libraryname;
|
|
|
|
private readonly List<ScriptItem> namedscripts;
|
|
private readonly List<ScriptItem> numberedscripts;
|
|
private readonly List<ScriptItem> functions;
|
|
|
|
#endregion
|
|
|
|
#region ================== Properties
|
|
|
|
internal override ScriptType ScriptType { get { return ScriptType.ACS; } }
|
|
|
|
internal List<ScriptItem> NamedScripts { get { return namedscripts; } }
|
|
internal List<ScriptItem> NumberedScripts { get { return numberedscripts; } }
|
|
internal List<ScriptItem> Functions { get { return functions; } }
|
|
internal bool IsLibrary { get { return !string.IsNullOrEmpty(libraryname); } }
|
|
internal string LibraryName { get { return libraryname; } }
|
|
|
|
internal bool AddArgumentsToScriptNames;
|
|
internal bool IsMapScriptsLump;
|
|
internal bool IgnoreErrors;
|
|
|
|
#endregion
|
|
|
|
#region ================== Enums
|
|
|
|
internal enum IncludeType
|
|
{
|
|
NONE,
|
|
INCLUDE,
|
|
LIBRARY
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Constructor
|
|
|
|
internal AcsParserSE()
|
|
{
|
|
namedscripts = new List<ScriptItem>();
|
|
numberedscripts = new List<ScriptItem>();
|
|
functions = new List<ScriptItem>();
|
|
includes = new Dictionary<string, HashSet<string>>(StringComparer.OrdinalIgnoreCase);
|
|
includestoskip = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
specialtokens += "(,)";
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Parsing
|
|
|
|
public override bool Parse(TextResourceData data, bool clearerrors) { return Parse(data, new HashSet<string>(), false, IncludeType.NONE, clearerrors); }
|
|
public bool Parse(TextResourceData data, bool processincludes, IncludeType includetype, bool clearerrors) { return Parse(data, includestoskip, processincludes, includetype, clearerrors); }
|
|
public bool Parse(TextResourceData data, HashSet<string> configincludes, bool processincludes, IncludeType includetype, bool clearerrors)
|
|
{
|
|
string source = data.Filename.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
|
|
|
|
//INFO: files included or imported inside a library are not visible to the code outside it
|
|
//and must be included/imported separately
|
|
|
|
// Includes tracking. "Regular" includes go to "SCRIPTS" group, library includes are tracked per-library
|
|
string includecategory = (processincludes && includetype == IncludeType.LIBRARY ? source : "SCRIPTS");
|
|
if(!includes.ContainsKey(includecategory)) includes.Add(includecategory, new HashSet<string>(StringComparer.OrdinalIgnoreCase));
|
|
|
|
includestoskip = configincludes;
|
|
int bracelevel = 0;
|
|
|
|
// Already parsed?
|
|
if(!base.AddTextResource(data))
|
|
{
|
|
if(clearerrors) ClearError();
|
|
return true;
|
|
}
|
|
|
|
// Cannot process?
|
|
if(!base.Parse(data, clearerrors)) return false;
|
|
|
|
// Keep local data
|
|
Stream localstream = datastream;
|
|
string localsourcename = sourcename;
|
|
int localsourcelumpindex = sourcelumpindex;
|
|
BinaryReader localreader = datareader;
|
|
DataLocation locallocation = datalocation;
|
|
string localincludecategory = includecategory;
|
|
|
|
// Continue until at the end of the stream
|
|
while(SkipWhitespace(true))
|
|
{
|
|
string token = ReadToken().ToLowerInvariant();
|
|
if(string.IsNullOrEmpty(token)) continue;
|
|
|
|
// Ignore inner scope stuff
|
|
if(token == "{") { bracelevel++; continue; }
|
|
if(token == "}") { bracelevel--; continue; }
|
|
if(bracelevel > 0) continue;
|
|
|
|
switch(token)
|
|
{
|
|
case "script":
|
|
{
|
|
SkipWhitespace(true);
|
|
int startpos = (int)datastream.Position;
|
|
token = ReadToken();
|
|
|
|
// Is this a named script?
|
|
if(token.IndexOf('"') != -1)
|
|
{
|
|
startpos += 1;
|
|
string scriptname = StripQuotes(token);
|
|
|
|
// Try to parse argument names
|
|
List<KeyValuePair<string, string>> args = ParseArgs();
|
|
List<string> argnames = new List<string>();
|
|
foreach(KeyValuePair<string, string> group in args) argnames.Add(group.Value);
|
|
|
|
// Make full name
|
|
if(AddArgumentsToScriptNames) scriptname += " " + GetArgumentNames(args);
|
|
|
|
// Add to collection
|
|
namedscripts.Add(new ScriptItem(scriptname, argnames, startpos, includetype != IncludeType.NONE));
|
|
}
|
|
// Should be numbered script
|
|
else
|
|
{
|
|
int n;
|
|
if(int.TryParse(token, NumberStyles.Integer, CultureInfo.InvariantCulture, out n))
|
|
{
|
|
// Try to parse argument names
|
|
List<KeyValuePair<string, string>> args = ParseArgs();
|
|
|
|
// Now find the opening brace
|
|
do
|
|
{
|
|
if(!SkipWhitespace(true)) break;
|
|
token = ReadToken();
|
|
} while(!string.IsNullOrEmpty(token) && token != "{");
|
|
|
|
token = ReadLine();
|
|
string name = "";
|
|
bracelevel = 1;
|
|
|
|
if(!string.IsNullOrEmpty(token))
|
|
{
|
|
int commentstart = token.IndexOf("//", StringComparison.Ordinal);
|
|
if(commentstart != -1) // Found comment
|
|
{
|
|
commentstart += 2;
|
|
name = token.Substring(commentstart, token.Length - commentstart).Trim();
|
|
}
|
|
}
|
|
|
|
bool customname = (name.Length > 0);
|
|
name = (customname ? name + " [Script " + n + "]" : "Script " + n);
|
|
|
|
List<string> argnames = new List<string>();
|
|
foreach(KeyValuePair<string, string> group in args) argnames.Add(group.Value);
|
|
|
|
// Make full name
|
|
if(AddArgumentsToScriptNames) name += " " + GetArgumentNames(args);
|
|
|
|
// Add to collection
|
|
numberedscripts.Add(new ScriptItem(n, name, argnames, startpos, includetype != IncludeType.NONE, customname));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case "function":
|
|
{
|
|
SkipWhitespace(true);
|
|
string funcname = ReadToken(); // Read return type
|
|
SkipWhitespace(true);
|
|
int startpos = (int)datastream.Position;
|
|
funcname += " " + ReadToken(); // Read function name
|
|
|
|
// Try to parse argument names
|
|
List<KeyValuePair<string, string>> args = ParseArgs();
|
|
List<string> argnames = new List<string>();
|
|
foreach(KeyValuePair<string, string> group in args) argnames.Add(group.Value);
|
|
|
|
// Make full name
|
|
if(AddArgumentsToScriptNames) funcname += GetArgumentNames(args);
|
|
|
|
// Add to collection
|
|
functions.Add(new ScriptItem(funcname, argnames, startpos, includetype != IncludeType.NONE));
|
|
}
|
|
break;
|
|
|
|
case "#library":
|
|
if(IsMapScriptsLump)
|
|
{
|
|
ReportError("SCRIPTS lump can not be compiled as a library");
|
|
if(!IgnoreErrors) return false;
|
|
}
|
|
|
|
SkipWhitespace(true);
|
|
string libname = ReadToken(false); // Don't skip newline
|
|
|
|
if(!libname.StartsWith("\"") || !libname.EndsWith("\""))
|
|
{
|
|
ReportError("#library name should be quoted");
|
|
return IgnoreErrors;
|
|
}
|
|
|
|
libname = StripQuotes(libname);
|
|
|
|
if(string.IsNullOrEmpty(libname))
|
|
{
|
|
ReportError("Expected library name");
|
|
return IgnoreErrors;
|
|
}
|
|
|
|
// Store only when the script compiling was executed for is library
|
|
if(includetype == IncludeType.NONE)
|
|
{
|
|
libraryname = libname;
|
|
includetype = IncludeType.LIBRARY;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
if(processincludes && (token == "#include" || token == "#import"))
|
|
{
|
|
//INFO: ZDoom ACC include paths can be absolute ("d:\stuff\coollib.acs"), relative ("../coollib.acs")
|
|
//and can use forward and backward slashes ("acs\map01/script.acs")
|
|
//also include paths must be quoted
|
|
//long filenames are supported
|
|
|
|
SkipWhitespace(true);
|
|
string includelump = ReadToken(false); // Don't skip newline
|
|
|
|
if(!includelump.StartsWith("\"") || !includelump.EndsWith("\""))
|
|
{
|
|
ReportError(token + " filename should be quoted");
|
|
return IgnoreErrors;
|
|
}
|
|
|
|
includelump = StripQuotes(includelump);
|
|
|
|
if(string.IsNullOrEmpty(includelump))
|
|
{
|
|
ReportError("Expected file name to " + token);
|
|
return IgnoreErrors;
|
|
}
|
|
|
|
includelump = includelump.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
|
|
|
|
// Compiler files? Track them, but don't parse them
|
|
if(includestoskip.Contains(includelump))
|
|
{
|
|
// These can also be included several times...
|
|
if(includes[includecategory].Contains(includelump))
|
|
{
|
|
ReportError("Already parsed \"" + includelump + "\". Check your " + token + " directives");
|
|
return IgnoreErrors;
|
|
}
|
|
|
|
// Add to collection
|
|
includes[includecategory].Add(includelump);
|
|
continue;
|
|
}
|
|
|
|
// Convert to a path we can use
|
|
string includelumppath = GetRootedPath(source, includelump);
|
|
|
|
// Rooting succeeded?
|
|
if((HasError && !IgnoreErrors) || string.IsNullOrEmpty(includelumppath))
|
|
return IgnoreErrors;
|
|
|
|
// Already parsed?
|
|
if(includes[includecategory].Contains(includelumppath))
|
|
{
|
|
ReportError("Already parsed \"" + includelump + "\". Check your " + token + " directives");
|
|
return IgnoreErrors;
|
|
}
|
|
|
|
// Add to collection
|
|
includes[includecategory].Add(includelumppath);
|
|
|
|
// Callback to parse this file
|
|
if(OnInclude != null)
|
|
{
|
|
IsMapScriptsLump = false;
|
|
OnInclude(this, includelumppath, (token == "#import" ? IncludeType.LIBRARY : IncludeType.INCLUDE));
|
|
}
|
|
|
|
// Bail out on error
|
|
if(this.HasError && !IgnoreErrors) return false;
|
|
|
|
// Set our buffers back to continue parsing
|
|
datastream = localstream;
|
|
datareader = localreader;
|
|
sourcename = localsourcename;
|
|
sourcelumpindex = localsourcelumpindex;
|
|
datalocation = locallocation;
|
|
includecategory = localincludecategory;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Methods
|
|
|
|
internal HashSet<string> GetIncludes()
|
|
{
|
|
HashSet<string> result = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
foreach(KeyValuePair<string, HashSet<string>> group in includes)
|
|
{
|
|
foreach(string include in group.Value) result.Add(include);
|
|
}
|
|
|
|
result.ExceptWith(includestoskip); // Remove compiler includes
|
|
return result;
|
|
}
|
|
|
|
private List<KeyValuePair<string, string>> ParseArgs() //type, name
|
|
{
|
|
List<KeyValuePair<string, string>> argnames = new List<KeyValuePair<string, string>>();
|
|
SkipWhitespace(true);
|
|
string token = ReadToken();
|
|
|
|
// Should be ENTER/OPEN etc. script type
|
|
if(token != "(")
|
|
{
|
|
argnames.Add(new KeyValuePair<string, string>(token.ToUpperInvariant(), string.Empty));
|
|
return argnames;
|
|
}
|
|
|
|
while(SkipWhitespace(true))
|
|
{
|
|
string argtype = ReadToken(); // should be type
|
|
if(IsSpecialToken(argtype)) break;
|
|
if(argtype.ToUpperInvariant() == "VOID")
|
|
{
|
|
argnames.Add(new KeyValuePair<string, string>("void", string.Empty));
|
|
break;
|
|
}
|
|
|
|
SkipWhitespace(true);
|
|
token = ReadToken(); // should be arg name
|
|
argnames.Add(new KeyValuePair<string, string>(argtype, token));
|
|
|
|
SkipWhitespace(true);
|
|
token = ReadToken(); // should be comma or ")"
|
|
if(token != ",") break;
|
|
}
|
|
|
|
return argnames;
|
|
}
|
|
|
|
private static string GetArgumentNames(List<KeyValuePair<string, string>> args)
|
|
{
|
|
// Make full name
|
|
if(args.Count > 0)
|
|
{
|
|
List<string> argdescs = new List<string>(args.Count);
|
|
foreach(KeyValuePair<string, string> group in args)
|
|
argdescs.Add((group.Key + " " + group.Value).TrimEnd());
|
|
|
|
return "(" + string.Join(", ", argdescs.ToArray()) + ")";
|
|
}
|
|
|
|
return "(void)";
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
} |