internal ZScriptClassStructure(ZScriptParser parser, string classname, string replacesname, string parentname, DecorateCategoryInfo region) { Parser = parser; Stream = parser.datastream; Position = parser.datastream.Position; DataReader = parser.datareader; SourceName = parser.sourcename; DataLocation = parser.datalocation; TextResourcePath = parser.textresourcepath; ClassName = classname; ReplacementName = replacesname; ParentName = parentname; Actor = null; Region = region; }
internal ZScriptActorStructure(ZDTextParser zdparser, DecorateCategoryInfo catinfo, string _classname, string _replacesname, string _parentname) { this.catinfo = catinfo; //mxd parser = (ZScriptParser)zdparser; stream = parser.DataStream; tokenizer = new ZScriptTokenizer(parser.DataReader); parser.tokenizer = tokenizer; classname = _classname; replaceclass = _replacesname; //baseclass = parser.GetArchivedActorByName(_parentname); // this is not guaranteed to work here mixins = new List <string>(); ZScriptToken cls_open = tokenizer.ExpectToken(ZScriptTokenType.OpenCurly); if (cls_open == null || !cls_open.IsValid) { parser.ReportError("Expected {, got " + ((Object)cls_open ?? "<null>").ToString()); return; } // this dict holds temporary user settings per field (function, etc) Dictionary <string, List <string> > var_props = new Dictionary <string, List <string> >(); // in the class definition, we can have the following: // - Defaults block // - States block // - method signature: [native] [action] <type [, type [...]]> <name> (<arguments>); // - method: <method signature (except native)> <block> // - field declaration: [native] <type> <name>; // - enum definition: enum <name> <block>; // we are skipping everything, except Defaults and States. while (true) { var_props.Clear(); while (true) { ZScriptToken tt = tokenizer.ExpectToken(ZScriptTokenType.Whitespace, ZScriptTokenType.BlockComment, ZScriptTokenType.LineComment, ZScriptTokenType.Newline); if (tt == null || !tt.IsValid) { break; } if (tt.Type == ZScriptTokenType.LineComment) { ParseGZDBComment(var_props, tt.Value); } } //tokenizer.SkipWhitespace(); long ocpos = stream.Position; ZScriptToken token = tokenizer.ExpectToken(ZScriptTokenType.Identifier, ZScriptTokenType.CloseCurly); if (token == null || !token.IsValid) { parser.ReportError("Expected identifier, got " + ((Object)cls_open ?? "<null>").ToString()); return; } if (token.Type == ZScriptTokenType.CloseCurly) // end of class { break; } string b_lower = token.Value.ToLowerInvariant(); switch (b_lower) { case "default": if (!ParseDefaultBlock()) { return; } continue; case "states": if (!ParseStatesBlock()) { return; } continue; case "enum": if (!parser.ParseEnum()) { return; } continue; case "const": if (!parser.ParseConst()) { return; } continue; // apparently we can have a struct inside a class, but not another class. case "struct": if (!parser.ParseClassOrStruct(true, false, false, null)) { return; } continue; // new properties syntax case "property": if (!ParseProperty()) { return; } continue; // new flags syntax case "flagdef": if (!ParseFlagdef()) { return; } continue; // mixins case "mixin": if (!ParseMixin()) { return; } continue; default: stream.Position = ocpos; break; } // try to read in a variable/method. bool bmethod = false; string[] availablemodifiers = new string[] { "static", "native", "action", "readonly", "protected", "private", "virtual", "override", "meta", "transient", "deprecated", "final", "play", "ui", "clearscope", "virtualscope", "version", "const" }; string[] versionedmodifiers = new string[] { "version", "deprecated" }; string[] methodmodifiers = new string[] { "action", "virtual", "override", "final" }; HashSet <string> modifiers = new HashSet <string>(); List <string> types = new List <string>(); List <List <int> > typearraylens = new List <List <int> >(); List <string> names = new List <string>(); List <List <int> > arraylens = new List <List <int> >(); List <ZScriptToken> args = null; // this is for the future //List<ZScriptToken> body = null; while (true) { tokenizer.SkipWhitespace(); long cpos = stream.Position; token = tokenizer.ExpectToken(ZScriptTokenType.Identifier); if (token == null || !token.IsValid) { parser.ReportError("Expected modifier or name, got " + ((Object)cls_open ?? "<null>").ToString()); return; } b_lower = token.Value.ToLowerInvariant(); if (availablemodifiers.Contains(b_lower)) { if (modifiers.Contains(b_lower)) { parser.ReportError("Field/method modifier '" + b_lower + "' was specified twice"); return; } if (methodmodifiers.Contains(b_lower)) { bmethod = true; } if (versionedmodifiers.Contains(b_lower)) { string version = ParseVersion(b_lower == "version"); // deprecated doesn't require version string for historical reasons. (compatibility with old gzdoom.pk3) if (version == null && b_lower == "version") { return; } } modifiers.Add(b_lower); } else { stream.Position = cpos; break; } } // read in the type name(s) // type name can be: // - identifier // - identifier<identifier> while (true) { tokenizer.SkipWhitespace(); string typename = ParseTypeName(); if (typename == null) { return; } types.Add(typename.ToLowerInvariant()); typearraylens.Add(null); long cpos = stream.Position; tokenizer.SkipWhitespace(); token = tokenizer.ExpectToken(ZScriptTokenType.Comma, ZScriptTokenType.Identifier, ZScriptTokenType.OpenSquare); if (token != null && !token.IsValid) { parser.ReportError("Expected comma, identifier or array dimensions, got " + ((Object)token ?? "<null>").ToString()); return; } if (token == null || token.Type != ZScriptTokenType.Comma) { stream.Position = cpos; if (token.Type == ZScriptTokenType.OpenSquare) { List <int> typelens = ParseArrayDimensions(); if (typelens == null) // error { return; } typearraylens[typearraylens.Count - 1] = typelens; } break; } } while (true) { string name = null; List <int> lens = null; // read in the method/field name tokenizer.SkipWhitespace(); token = tokenizer.ExpectToken(ZScriptTokenType.Identifier); if (token == null || !token.IsValid) { parser.ReportError("Expected field/method name, got " + ((Object)token ?? "<null>").ToString()); return; } name = token.Value.ToLowerInvariant(); // check the token. if it's a (, then it's a method. if it's a ;, then it's a field, if it's a [ it's an array field. // if it's a field and bmethod=true, report error. tokenizer.SkipWhitespace(); long cpos = stream.Position; token = tokenizer.ExpectToken(ZScriptTokenType.Comma, ZScriptTokenType.OpenParen, ZScriptTokenType.OpenSquare, ZScriptTokenType.Semicolon); if (token == null || !token.IsValid) { parser.ReportError("Expected comma, ;, [, or argument list, got " + ((Object)token ?? "<null>").ToString()); return; } if (token.Type == ZScriptTokenType.OpenParen) { // if we have multiple names if (names.Count > 0) { parser.ReportError("Cannot have multiple names in a method"); return; } bmethod = true; // now, I could parse this properly, but it won't be used anyway, so I'll do it as a fake expression. args = parser.ParseExpression(true); token = tokenizer.ExpectToken(ZScriptTokenType.CloseParen); if (token == null || !token.IsValid) { parser.ReportError("Expected ), got " + ((Object)token ?? "<null>").ToString()); return; } // also get the body block, if any. tokenizer.SkipWhitespace(); cpos = stream.Position; token = tokenizer.ExpectToken(ZScriptTokenType.Semicolon, ZScriptTokenType.OpenCurly, ZScriptTokenType.Identifier); if (token == null || !token.IsValid) { parser.ReportError("Expected 'const', ; or {, got " + ((Object)token ?? "<null>").ToString()); return; } // if (token.Type == ZScriptTokenType.Identifier) { if (token.Value.ToLowerInvariant() != "const") { parser.ReportError("Expected 'const', got " + ((Object)token ?? "<null>").ToString()); return; } tokenizer.SkipWhitespace(); cpos = stream.Position; token = tokenizer.ExpectToken(ZScriptTokenType.Semicolon, ZScriptTokenType.OpenCurly); if (token == null || !token.IsValid) { parser.ReportError("Expected ; or {, got " + ((Object)token ?? "<null>").ToString()); return; } } if (token.Type == ZScriptTokenType.OpenCurly) { stream.Position = cpos; parser.SkipBlock(); //body = parser.ParseBlock(false); } break; // end method parsing } else { if (bmethod) { parser.ReportError("Cannot have virtual, override or action fields"); return; } // array if (token.Type == ZScriptTokenType.OpenSquare) { stream.Position = cpos; lens = ParseArrayDimensions(); if (lens == null) // error { return; } tokenizer.SkipWhitespace(); ZScriptTokenType[] expectTokens; if (modifiers.Contains("static")) { expectTokens = new ZScriptTokenType[] { ZScriptTokenType.Semicolon, ZScriptTokenType.Comma, ZScriptTokenType.OpAssign } } ; else { expectTokens = new ZScriptTokenType[] { ZScriptTokenType.Semicolon, ZScriptTokenType.Comma } }; token = tokenizer.ExpectToken(expectTokens); if (token == null || !token.IsValid) { parser.ReportError("Expected ;, =, or comma, got " + ((Object)token ?? "<null>").ToString()); return; } // "static int A[] = {1, 2, 3};" if (token.Type == ZScriptTokenType.OpAssign) { // read in array data tokenizer.SkipWhitespace(); parser.SkipBlock(false); tokenizer.SkipWhitespace(); token = tokenizer.ExpectToken(ZScriptTokenType.Semicolon, ZScriptTokenType.Comma); if (token == null || !token.IsValid) { parser.ReportError("Expected ; or comma, got " + ((Object)token ?? "<null>").ToString()); return; } } } } names.Add(name); arraylens.Add(lens); if (token.Type != ZScriptTokenType.Comma) // next name { break; } } // validate modifiers here. // protected and private cannot be combined. if (bmethod) { if (modifiers.Contains("protected") && modifiers.Contains("private")) { parser.ReportError("Cannot have protected and private on the same method"); return; } // virtual and override cannot be combined. int cvirtual = modifiers.Contains("virtual") ? 1 : 0; cvirtual += modifiers.Contains("override") ? 1 : 0; cvirtual += modifiers.Contains("final") ? 1 : 0; if (cvirtual > 1) { parser.ReportError("Cannot have virtual, override and final on the same method"); return; } // meta (what the f**k is that?) probably cant be on a method if (modifiers.Contains("meta")) { parser.ReportError("Cannot have meta on a method"); return; } } // finished method or field parsing. /*for (int i = 0; i < names.Count; i++) * { * string name = names[i]; * int arraylen = arraylens[i]; * * string _args = ""; * if (args != null) _args = " (" + ZScriptTokenizer.TokensToString(args) + ")"; * else if (arraylen != -1) _args = " [" + arraylen.ToString() + "]"; * parser.LogWarning(string.Format("{0} {1} {2}{3}", string.Join(" ", modifiers.ToArray()), string.Join(", ", types.ToArray()), name, _args)); * }*/ // update 08.02.17: add user variables from ZScript actors. if (args == null && types.Count == 1) // it's a field { // we support: // - float // - int // - double // - bool string type = types[0]; UniversalType utype; object udefault = null; switch (type) { case "int": case "int8": case "int16": case "uint": case "uint8": case "uint16": utype = UniversalType.Integer; break; case "float": case "double": utype = UniversalType.Float; break; case "bool": utype = UniversalType.Boolean; break; case "string": utype = UniversalType.String; break; // todo test if class names and colors will work default: continue; // go read next field } UniversalType utype_reinterpret = utype; if (var_props.ContainsKey("$userreinterpret")) { string sp = var_props["$userreinterpret"][0].Trim().ToLowerInvariant(); switch (sp) { case "color": if (utype != UniversalType.Integer) { parser.LogWarning("Cannot use $UserReinterpret Color with non-integers"); break; } utype_reinterpret = UniversalType.Color; break; } } if (var_props.ContainsKey("$userdefaultvalue")) { string sp = var_props["$userdefaultvalue"][0]; switch (utype) { case UniversalType.String: if (sp[0] == '"' && sp[sp.Length - 1] == '"') { sp = sp.Substring(1, sp.Length - 2); } udefault = sp; break; case UniversalType.Float: double d; if (!double.TryParse(sp, out d)) { parser.LogWarning("Incorrect float default from string \"" + sp + "\""); break; } udefault = d; break; case UniversalType.Integer: int i; if (!int.TryParse(sp, out i)) { if (utype_reinterpret == UniversalType.Color) { sp = sp.ToLowerInvariant(); Rendering.PixelColor pc; if (!ZDTextParser.GetColorFromString(sp, out pc)) { parser.LogWarning("Incorrect color default from string \"" + sp + "\""); break; } udefault = pc.ToInt() & 0xFFFFFF; break; } } udefault = i; break; case UniversalType.Boolean: sp = sp.ToLowerInvariant(); if (sp == "true") { udefault = true; } else if (sp == "false") { udefault = false; } else { parser.LogWarning("Incorrect boolean default from string \"" + sp + "\""); } break; } } for (int i = 0; i < names.Count; i++) { string name = names[i]; if (arraylens[i] != null || typearraylens[0] != null) { continue; // we don't process arrays } if (!name.StartsWith("user_")) { continue; // we don't process non-user_ fields (because ZScript won't pick them up anyway) } // parent class is not guaranteed to be loaded already, so handle collisions later uservars.Add(name, utype_reinterpret); if (udefault != null) { uservar_defaults.Add(name, udefault); } } } } // parsing done, process thing arguments ParseCustomArguments(); } }
} //mxd #endregion #region ================== Constructor / Disposer // Constructor internal ActorStructure(DecorateParser parser, DecorateCategoryInfo catinfo) { // Initialize this.catinfo = catinfo; //mxd flags = new Dictionary <string, bool>(StringComparer.OrdinalIgnoreCase); props = new Dictionary <string, List <string> >(StringComparer.OrdinalIgnoreCase); states = new Dictionary <string, StateStructure>(StringComparer.OrdinalIgnoreCase); uservars = new Dictionary <string, UniversalType>(StringComparer.OrdinalIgnoreCase); //mxd bool done = false; //mxd // Always define a game property, but default to 0 values props["game"] = new List <string>(); inheritclass = "actor"; replaceclass = null; baseclass = null; skipsuper = false; // First next token is the class name parser.SkipWhitespace(true); classname = parser.StripTokenQuotes(parser.ReadToken(ACTOR_CLASS_SPECIAL_TOKENS)); if (string.IsNullOrEmpty(classname)) { parser.ReportError("Expected actor class name"); return; } //mxd. Fail on duplicates if (parser.ActorsByClass.ContainsKey(classname.ToLowerInvariant())) { parser.ReportError("Actor \"" + classname + "\" is double-defined"); return; } // Parse tokens before entering the actor scope while (parser.SkipWhitespace(true)) { string token = parser.ReadToken(); if (!string.IsNullOrEmpty(token)) { token = token.ToLowerInvariant(); switch (token) { case ":": // The next token must be the class to inherit from parser.SkipWhitespace(true); inheritclass = parser.StripTokenQuotes(parser.ReadToken()); if (string.IsNullOrEmpty(inheritclass)) { parser.ReportError("Expected class name to inherit from"); return; } // Find the actor to inherit from baseclass = parser.GetArchivedActorByName(inheritclass); break; case "replaces": // The next token must be the class to replace parser.SkipWhitespace(true); replaceclass = parser.StripTokenQuotes(parser.ReadToken()); if (string.IsNullOrEmpty(replaceclass)) { parser.ReportError("Expected class name to replace"); return; } break; case "native": // Igore this token break; case "{": // Actor scope begins here, // break out of this parse loop done = true; break; case "-": // This could be a negative doomednum (but our parser sees the - as separate token) // So read whatever is after this token and ignore it (negative doomednum indicates no doomednum) parser.ReadToken(); break; default: //mxd. Property begins with $? Then the whole line is a single value if (token.StartsWith("$")) { // This is for editor-only properties such as $sprite and $category props[token] = new List <string> { (parser.SkipWhitespace(false) ? parser.ReadLine() : "") }; continue; } if (!int.TryParse(token, NumberStyles.Integer, CultureInfo.InvariantCulture, out doomednum)) // Check if numeric { // Not numeric! parser.ReportError("Expected editor number or start of actor scope while parsing \"" + classname + "\""); return; } //mxd. Range check if ((doomednum < General.Map.FormatInterface.MinThingType) || (doomednum > General.Map.FormatInterface.MaxThingType)) { // Out of bounds! parser.ReportError("Actor \"" + classname + "\" has invalid editor number. Editor number must be between " + General.Map.FormatInterface.MinThingType + " and " + General.Map.FormatInterface.MaxThingType); return; } break; } if (done) { break; //mxd } } else { parser.ReportError("Unexpected end of structure"); return; } } // Now parse the contents of actor structure string previoustoken = ""; done = false; //mxd while (parser.SkipWhitespace(true)) { string token = parser.ReadToken(); token = token.ToLowerInvariant(); switch (token) { case "+": case "-": // Next token is a flag (option) to set or remove bool flagvalue = (token == "+"); parser.SkipWhitespace(true); string flagname = parser.ReadToken(); if (!string.IsNullOrEmpty(flagname)) { // Add the flag with its value flagname = flagname.ToLowerInvariant(); flags[flagname] = flagvalue; } else { parser.ReportError("Expected flag name"); return; } break; case "action": case "native": // We don't need this, ignore up to the first next ; while (parser.SkipWhitespace(true)) { string t = parser.ReadToken(); if (string.IsNullOrEmpty(t) || t == ";") { break; } } break; case "skip_super": skipsuper = true; break; case "states": // Now parse actor states until we reach the end of the states structure while (parser.SkipWhitespace(true)) { string statetoken = parser.ReadToken(); if (!string.IsNullOrEmpty(statetoken)) { // Start of scope? if (statetoken == "{") { // This is fine } // End of scope? else if (statetoken == "}") { // Done with the states, // break out of this parse loop break; } // State label? else if (statetoken == ":") { if (!string.IsNullOrEmpty(previoustoken)) { // Parse actor state StateStructure st = new StateStructure(this, parser); if (parser.HasError) { return; } states[previoustoken.ToLowerInvariant()] = st; } else { parser.ReportError("Expected actor state name"); return; } } else { // Keep token previoustoken = statetoken; } } else { parser.ReportError("Unexpected end of structure"); return; } } break; case "var": //mxd // Type parser.SkipWhitespace(true); string typestr = parser.ReadToken().ToUpperInvariant(); UniversalType type = UniversalType.EnumOption; // There is no Unknown type, so let's use something impossiburu... switch (typestr) { case "INT": type = UniversalType.Integer; break; case "FLOAT": type = UniversalType.Float; break; default: parser.LogWarning("Unknown user variable type"); break; } // Name parser.SkipWhitespace(true); string name = parser.ReadToken(); if (string.IsNullOrEmpty(name)) { parser.ReportError("Expected User Variable name"); return; } if (!name.StartsWith("user_", StringComparison.OrdinalIgnoreCase)) { parser.ReportError("User Variable name must start with \"user_\" prefix"); return; } if (uservars.ContainsKey(name)) { parser.ReportError("User Variable \"" + name + "\" is double defined"); return; } if (!skipsuper && baseclass != null && baseclass.uservars.ContainsKey(name)) { parser.ReportError("User variable \"" + name + "\" is already defined in one of the parent classes"); return; } // Rest parser.SkipWhitespace(true); string next = parser.ReadToken(); if (next == "[") // that's User Array. Let's skip it... { int arrlen = -1; if (!parser.ReadSignedInt(ref arrlen)) { parser.ReportError("Expected User Array length"); return; } if (arrlen < 1) { parser.ReportError("User Array length must be a positive value"); return; } if (!parser.NextTokenIs("]") || !parser.NextTokenIs(";")) { return; } } else if (next != ";") { parser.ReportError("Expected \";\", but got \"" + next + "\""); return; } else { // Add to collection uservars.Add(name, type); } break; case "}": //mxd. Get user vars from the BaseClass, if we have one if (!skipsuper && baseclass != null && baseclass.uservars.Count > 0) { foreach (var group in baseclass.uservars) { uservars.Add(group.Key, group.Value); } } // Actor scope ends here, break out of this parse loop done = true; break; // Monster property? case "monster": // This sets certain flags we are interested in flags["shootable"] = true; flags["countkill"] = true; flags["solid"] = true; flags["canpushwalls"] = true; flags["canusewalls"] = true; flags["activatemcross"] = true; flags["canpass"] = true; flags["ismonster"] = true; break; // Projectile property? case "projectile": // This sets certain flags we are interested in flags["noblockmap"] = true; flags["nogravity"] = true; flags["dropoff"] = true; flags["missile"] = true; flags["activateimpact"] = true; flags["activatepcross"] = true; flags["noteleport"] = true; break; // Clearflags property? case "clearflags": // Clear all flags flags.Clear(); break; // Game property? case "game": // Include all tokens on the same line List <string> games = new List <string>(); while (parser.SkipWhitespace(false)) { string v = parser.ReadToken(); if (string.IsNullOrEmpty(v)) { parser.ReportError("Expected \"Game\" property value"); return; } if (v == "\n") { break; } if (v == "}") { return; //mxd } if (v != ",") { games.Add(v.ToLowerInvariant()); } } props[token] = games; break; // Property default: // Property begins with $? Then the whole line is a single value if (token.StartsWith("$")) { // This is for editor-only properties such as $sprite and $category props[token] = new List <string> { (parser.SkipWhitespace(false) ? parser.ReadLine() : "") }; } else { // Next tokens up until the next newline are values List <string> values = new List <string>(); while (parser.SkipWhitespace(false)) { string v = parser.ReadToken(); if (string.IsNullOrEmpty(v)) { parser.ReportError("Unexpected end of structure"); return; } if (v == "\n") { break; } if (v == "}") { return; //mxd } if (v != ",") { values.Add(v); } } //mxd. Translate scale to xscale and yscale if (token == "scale") { props["xscale"] = values; props["yscale"] = values; } else { props[token] = values; } } break; } if (done) { break; //mxd } // Keep token previoustoken = token; } //mxd. Check if baseclass is valid if (inheritclass.ToLowerInvariant() != "actor" && doomednum > -1 && baseclass == null) { //check if this class inherits from a class defined in game configuration Dictionary <int, ThingTypeInfo> things = General.Map.Config.GetThingTypes(); string inheritclasscheck = inheritclass.ToLowerInvariant(); foreach (KeyValuePair <int, ThingTypeInfo> ti in things) { if (!string.IsNullOrEmpty(ti.Value.ClassName) && ti.Value.ClassName.ToLowerInvariant() == inheritclasscheck) { //states if (states.Count == 0 && !string.IsNullOrEmpty(ti.Value.Sprite)) { states.Add("spawn", new StateStructure(ti.Value.Sprite.Substring(0, 5))); } //flags if (ti.Value.Hangs && !flags.ContainsKey("spawnceiling")) { flags["spawnceiling"] = true; } if (ti.Value.Blocking > 0 && !flags.ContainsKey("solid")) { flags["solid"] = true; } //properties if (!props.ContainsKey("height")) { props["height"] = new List <string> { ti.Value.Height.ToString() } } ; if (!props.ContainsKey("radius")) { props["radius"] = new List <string> { ti.Value.Radius.ToString() } } ; return; } } parser.LogWarning("Unable to find \"" + inheritclass + "\" class to inherit from, while parsing \"" + classname + ":" + doomednum + "\""); } }
// This parses the given decorate stream // Returns false on errors public override bool Parse(TextResourceData data, bool clearerrors) { //mxd. Already parsed? if (!base.AddTextResource(data)) { if (clearerrors) { ClearError(); } return(true); } // Cannot process? if (!base.Parse(data, clearerrors)) { return(false); } // [ZZ] For whatever reason, the parser is closely tied to the tokenizer, and to the general scripting lumps framework (see scripttype). // For this reason I have to still inherit the old tokenizer while only using the new one. //ReportError("found zscript? :)"); prevstreamposition = -1; tokenizer = new ZScriptTokenizer(datareader); // region-as-category, ZScript ver List <DecorateCategoryInfo> regions = new List <DecorateCategoryInfo>(); while (true) { ZScriptToken token = tokenizer.ExpectToken(ZScriptTokenType.Identifier, // const, enum, class, etc ZScriptTokenType.Whitespace, ZScriptTokenType.Newline, ZScriptTokenType.BlockComment, ZScriptTokenType.LineComment, ZScriptTokenType.Preprocessor); if (token == null) // EOF reached, whatever. { break; } if (!token.IsValid) { ReportError("Expected preprocessor statement, const, enum or class declaraction, got " + token); return(false); } // toplevel tokens allowed are only Preprocessor and Identifier. switch (token.Type) { case ZScriptTokenType.Whitespace: case ZScriptTokenType.Newline: case ZScriptTokenType.BlockComment: break; case ZScriptTokenType.LineComment: { string cmtval = token.Value.TrimStart(); if (cmtval.Length <= 0 || cmtval[0] != '$') { break; } // check for $GZDB_SKIP if (cmtval.Trim().ToLowerInvariant() == "$gzdb_skip") { return(true); } // if we are in a region, read property using function from ZScriptActorStructure if (regions.Count > 0) { ZScriptActorStructure.ParseGZDBComment(regions.Last().Properties, cmtval); } } break; case ZScriptTokenType.Preprocessor: { tokenizer.SkipWhitespace(); ZScriptToken directive = tokenizer.ExpectToken(ZScriptTokenType.Identifier); if (directive == null || !directive.IsValid) { ReportError("Expected preprocessor directive, got " + ((Object)directive ?? "<null>").ToString()); return(false); } string d_value = directive.Value.ToLowerInvariant(); if (d_value == "include") { tokenizer.SkipWhitespace(); ZScriptToken include_name = tokenizer.ExpectToken(ZScriptTokenType.Identifier, ZScriptTokenType.String, ZScriptTokenType.Name); if (include_name == null || !include_name.IsValid) { ReportError("Cannot include: expected a string value, got " + ((Object)include_name ?? "<null>").ToString()); return(false); } if (!ParseInclude(include_name.Value)) { return(false); } } else if (d_value == "region") { // just read everything until newline. string region_name = ""; while (true) { token = tokenizer.ReadToken(); if (token == null || token.Type == ZScriptTokenType.Newline) { break; } region_name += token.Value; } DecorateCategoryInfo region = new DecorateCategoryInfo(); string[] cattitle = region_name.Split(DataManager.CATEGORY_SPLITTER, StringSplitOptions.RemoveEmptyEntries); if (regions.Count > 0) { region.Category.AddRange(regions.Last().Category); region.Properties = new Dictionary <string, List <string> >(regions.Last().Properties, StringComparer.OrdinalIgnoreCase); } region.Category.AddRange(cattitle); regions.Add(region); } else if (d_value == "endregion") { // read everything until newline too? // - only if it causes problems if (regions.Count > 0) { regions.RemoveAt(regions.Count - 1); // remove last region from the list } else { LogWarning("Superfluous #endregion found without corresponding #region"); } } else { ReportError("Unknown preprocessor directive: " + directive.Value); return(false); } break; } case ZScriptTokenType.Identifier: { // identifier can be one of: class, enum, const, struct // the only type that we really care about is class, as it's the one that has all actors. switch (token.Value.ToLowerInvariant()) { case "extend": tokenizer.SkipWhitespace(); token = tokenizer.ExpectToken(ZScriptTokenType.Identifier); if (token == null || !token.IsValid || ((token.Value.ToLowerInvariant() != "class") && (token.Value.ToLowerInvariant() != "struct"))) { ReportError("Expected class or struct, got " + ((Object)token ?? "<null>").ToString()); return(false); } if (!ParseClassOrStruct((token.Value.ToLowerInvariant() == "struct"), true, (regions.Count > 0 ? regions.Last() : null))) { return(false); } break; case "class": // todo parse class if (!ParseClassOrStruct(false, false, (regions.Count > 0 ? regions.Last() : null))) { return(false); } break; case "struct": // todo parse struct if (!ParseClassOrStruct(true, false, null)) { return(false); } break; case "const": if (!ParseConst()) { return(false); } break; case "enum": if (!ParseEnum()) { return(false); } break; case "version": // expect a string. do nothing about it. tokenizer.SkipWhitespace(); token = tokenizer.ExpectToken(ZScriptTokenType.String); if (token == null || !token.IsValid) { ReportError("Expected version string, got " + ((Object)token ?? "<null>").ToString()); return(false); } break; default: ReportError("Expected preprocessor statement, const, enum or class declaraction, got " + token); return(false); } break; } } } return(true); }
internal bool ParseClassOrStruct(bool isstruct, bool extend, DecorateCategoryInfo region) { // 'class' keyword is already parsed tokenizer.SkipWhitespace(); ZScriptToken tok_classname = tokenizer.ExpectToken(ZScriptTokenType.Identifier); if (tok_classname == null || !tok_classname.IsValid) { ReportError("Expected class name, got " + ((Object)tok_classname ?? "<null>").ToString()); return(false); } // name [replaces name] [: name] [native] ZScriptToken tok_replacename = null; ZScriptToken tok_parentname = null; ZScriptToken tok_native = null; ZScriptToken tok_scope = null; ZScriptToken tok_version = null; string[] class_scope_modifiers = new string[] { "clearscope", "ui", "play" }; while (true) { tokenizer.SkipWhitespace(); ZScriptToken token = tokenizer.ReadToken(); if (token == null) { ReportError("Expected a token"); return(false); } if (token.Type == ZScriptTokenType.Identifier) { if (token.Value.ToLowerInvariant() == "replaces") { if (tok_native != null) { ReportError("Cannot have replacement after native"); return(false); } if (tok_replacename != null) { ReportError("Cannot have two replacements per class"); return(false); } tokenizer.SkipWhitespace(); tok_replacename = tokenizer.ExpectToken(ZScriptTokenType.Identifier); if (tok_replacename == null || !tok_replacename.IsValid) { ReportError("Expected replacement class name, got " + ((Object)tok_replacename ?? "<null>").ToString()); return(false); } } else if (token.Value.ToLowerInvariant() == "native") { if (tok_native != null) { ReportError("Cannot have two native keywords"); return(false); } tok_native = token; } else if (Array.IndexOf(class_scope_modifiers, token.Value.ToLowerInvariant()) >= 0) { if (tok_scope != null) { ReportError("Cannot have two scope qualifiers"); return(false); } tok_scope = token; } else if (token.Value.ToLowerInvariant() == "version") { if (tok_version != null) { ReportError("Cannot have two versions"); return(false); } // read in the version. tokenizer.SkipWhitespace(); token = tokenizer.ExpectToken(ZScriptTokenType.OpenParen); if (token == null || !token.IsValid) { ReportError("Expected (, got " + ((Object)token ?? "<null>").ToString()); return(false); } tokenizer.SkipWhitespace(); token = tokenizer.ExpectToken(ZScriptTokenType.String); if (token == null || !token.IsValid) { ReportError("Expected version, got " + ((Object)token ?? "<null>").ToString()); return(false); } tok_version = token; tokenizer.SkipWhitespace(); token = tokenizer.ExpectToken(ZScriptTokenType.CloseParen); if (token == null || !token.IsValid) { ReportError("Expected ), got " + ((Object)token ?? "<null>").ToString()); return(false); } } else { ReportError("Unexpected token " + ((Object)token ?? "<null>").ToString()); } } else if (token.Type == ZScriptTokenType.Colon) { if (tok_parentname != null) { ReportError("Cannot have two parent classes"); return(false); } if (tok_replacename != null || tok_native != null) { ReportError("Cannot have parent class after replacement class or native keyword"); return(false); } tokenizer.SkipWhitespace(); tok_parentname = tokenizer.ExpectToken(ZScriptTokenType.Identifier); if (tok_parentname == null || !tok_parentname.IsValid) { ReportError("Expected replacement class name, got " + ((Object)tok_parentname ?? "<null>").ToString()); return(false); } } else if (token.Type == ZScriptTokenType.OpenCurly) { datastream.Position--; break; } } // do nothing else atm, except remember the position to put it into the class parsing code tokenizer.SkipWhitespace(); long cpos = datastream.Position; //List<ZScriptToken> classblocktokens = ParseBlock(false); //if (classblocktokens == null) return false; if (!SkipBlock()) { return(false); } string log_inherits = ((tok_parentname != null) ? "inherits " + tok_parentname.Value : ""); if (tok_replacename != null) { log_inherits += ((log_inherits.Length > 0) ? ", " : "") + "replaces " + tok_replacename.Value; } if (extend) { log_inherits += ((log_inherits.Length > 0) ? ", " : "") + "extends"; } if (log_inherits.Length > 0) { log_inherits = " (" + log_inherits + ")"; } // now if we are a class, and we inherit actor, parse this entry as an actor. don't process extensions. if (!isstruct && !extend) { ZScriptClassStructure cls = new ZScriptClassStructure(this, tok_classname.Value, (tok_replacename != null) ? tok_replacename.Value : null, (tok_parentname != null) ? tok_parentname.Value : null, region); cls.Position = cpos; string clskey = cls.ClassName.ToLowerInvariant(); if (allclasses.ContainsKey(clskey)) { ReportError("Class " + cls.ClassName + " is double-defined"); return(false); } allclasses.Add(cls.ClassName.ToLowerInvariant(), cls); allclasseslist.Add(cls); } //LogWarning(string.Format("Parsed {0} {1}{2}", (isstruct ? "struct" : "class"), tok_classname.Value, log_inherits)); return(true); }
// This parses the given decorate stream // Returns false on errors public override bool Parse(TextResourceData data, bool clearerrors) { //mxd. Already parsed? if (!base.AddTextResource(data)) { if (clearerrors) { ClearError(); } return(true); } // Cannot process? if (!base.Parse(data, clearerrors)) { return(false); } //mxd. Region-as-category stuff... List <DecorateCategoryInfo> regions = new List <DecorateCategoryInfo>(); //mxd // Keep local data Stream localstream = datastream; string localsourcename = sourcename; BinaryReader localreader = datareader; DataLocation locallocation = datalocation; //mxd string localtextresourcepath = textresourcepath; //mxd // Continue until at the end of the stream while (SkipWhitespace(true)) { // Read a token string objdeclaration = ReadToken(); if (!string.IsNullOrEmpty(objdeclaration)) { objdeclaration = objdeclaration.ToLowerInvariant(); if (objdeclaration == "$gzdb_skip") { break; } switch (objdeclaration) { case "actor": { // Read actor structure ActorStructure actor = new ActorStructure(this, (regions.Count > 0 ? regions[regions.Count - 1] : null)); if (this.HasError) { return(false); } // Add the actor archivedactors[actor.ClassName.ToLowerInvariant()] = actor; if (actor.CheckActorSupported()) { actors[actor.ClassName.ToLowerInvariant()] = actor; } // Replace an actor? if (actor.ReplacesClass != null) { if (GetArchivedActorByName(actor.ReplacesClass) != null) { archivedactors[actor.ReplacesClass.ToLowerInvariant()] = actor; } else { LogWarning("Unable to find \"" + actor.ReplacesClass + "\" class to replace, while parsing \"" + actor.ClassName + "\""); } if (actor.CheckActorSupported() && GetActorByName(actor.ReplacesClass) != null) { actors[actor.ReplacesClass.ToLowerInvariant()] = actor; } } //mxd. Add to current text resource if (!textresources[textresourcepath].Entries.Contains(actor.ClassName)) { textresources[textresourcepath].Entries.Add(actor.ClassName); } } break; case "#include": { //INFO: ZDoom DECORATE include paths can't be relative ("../actor.txt") //or absolute ("d:/project/actor.txt") //or have backward slashes ("info\actor.txt") //include paths are relative to the first parsed entry, not the current one //also include paths may or may not be quoted SkipWhitespace(true); string filename = StripQuotes(ReadToken(false)); //mxd. Don't skip newline //mxd. Sanity checks if (string.IsNullOrEmpty(filename)) { ReportError("Expected file name to include"); return(false); } //mxd. Check invalid path chars if (!CheckInvalidPathChars(filename)) { return(false); } //mxd. Absolute paths are not supported... if (Path.IsPathRooted(filename)) { ReportError("Absolute include paths are not supported by ZDoom"); return(false); } //mxd. Relative paths are not supported if (filename.StartsWith(RELATIVE_PATH_MARKER) || filename.StartsWith(CURRENT_FOLDER_PATH_MARKER) || filename.StartsWith(ALT_RELATIVE_PATH_MARKER) || filename.StartsWith(ALT_CURRENT_FOLDER_PATH_MARKER)) { ReportError("Relative include paths are not supported by ZDoom"); return(false); } //mxd. Backward slashes are not supported if (filename.Contains(Path.DirectorySeparatorChar.ToString(CultureInfo.InvariantCulture))) { ReportError("Only forward slashes are supported by ZDoom"); return(false); } //mxd. Already parsed? if (parsedlumps.Contains(filename)) { ReportError("Already parsed \"" + filename + "\". Check your include directives"); return(false); } //mxd. Add to collection parsedlumps.Add(filename); // Callback to parse this file now if (OnInclude != null) { OnInclude(this, filename); } //mxd. Bail out on error if (this.HasError) { return(false); } // Set our buffers back to continue parsing datastream = localstream; datareader = localreader; sourcename = localsourcename; datalocation = locallocation; //mxd textresourcepath = localtextresourcepath; //mxd } break; case "damagetype": //mxd // Get DamageType name SkipWhitespace(true); string damagetype = StripQuotes(ReadToken(false)); if (string.IsNullOrEmpty(damagetype)) { ReportError("Expected DamageType name"); return(false); } // Next should be "{" SkipWhitespace(true); if (!NextTokenIs("{")) { return(false); } // Skip the structure while (SkipWhitespace(true)) { string t = ReadToken(); if (string.IsNullOrEmpty(t) || t == "}") { break; } } // Add to collection if (!damagetypes.Contains(damagetype)) { damagetypes.Add(damagetype); } break; case "enum": case "native": case "const": while (SkipWhitespace(true)) { string t = ReadToken(); if (string.IsNullOrEmpty(t) || t == ";") { break; } } break; //mxd. Region-as-category handling case "#region": SkipWhitespace(false); string cattitle = ReadLine(); if (!string.IsNullOrEmpty(cattitle)) { // Make new category info string[] parts = cattitle.Split(DataManager.CATEGORY_SPLITTER, StringSplitOptions.RemoveEmptyEntries); DecorateCategoryInfo info = new DecorateCategoryInfo(); if (regions.Count > 0) { // Preserve nesting info.Category.AddRange(regions[regions.Count - 1].Category); info.Properties = new Dictionary <string, List <string> >(regions[regions.Count - 1].Properties); } info.Category.AddRange(parts); // Add to collection regions.Add(info); } break; //mxd. Region-as-category handling case "#endregion": if (regions.Count > 0) { regions.RemoveAt(regions.Count - 1); } else { LogWarning("Unexpected #endregion token"); } break; default: { //mxd. In some special cases (like the whole actor commented using "//") our special comments will be detected here... if (objdeclaration.StartsWith("$")) { if (regions.Count > 0) { // Store region property regions[regions.Count - 1].Properties[objdeclaration] = new List <string> { (SkipWhitespace(false) ? ReadLine() : "") }; } else { // Skip the whole line, then carry on ReadLine(); } break; } // Unknown structure! // Best we can do now is just find the first { and then // follow the scopes until the matching } is found string token2; do { if (!SkipWhitespace(true)) { break; } token2 = ReadToken(); if (string.IsNullOrEmpty(token2)) { break; } }while(token2 != "{"); int scopelevel = 1; do { if (!SkipWhitespace(true)) { break; } token2 = ReadToken(); if (string.IsNullOrEmpty(token2)) { break; } if (token2 == "{") { scopelevel++; } if (token2 == "}") { scopelevel--; } }while(scopelevel > 0); } break; } } } // Return true when no errors occurred return(ErrorDescription == null); }