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;
            }
Пример #2
0
        ZScriptToken TryReadSprite(ZScriptParser parser, Stream stream, ZScriptTokenizer tokenizer)
        {
            // this is a hack to read #### and ----.
            // also [\]
            string specialinvalid = "-#";
            string outs           = "";
            long   cpos           = stream.Position;

            for (int i = 0; ; i++)
            {
                cpos = stream.Position;
                ZScriptToken token = tokenizer.ReadToken(true);

                if ((token == null) ||
                    (token.Type != ZScriptTokenType.Invalid) ||
                    (token.Value == ";") ||
                    ((outs.Length > 0 && token.Value[0] != outs[0]) && specialinvalid.Contains(token.Value[0])))
                {
                    if (outs.Length == 0 && (token.Type == ZScriptTokenType.String || token.Type == ZScriptTokenType.Name))
                    {
                        return(token);
                    }

                    stream.Position = cpos;
                    break;
                }

                outs += token.Value[0];
            }

            if (outs.Length > 0)
            {
                ZScriptToken tok = new ZScriptToken();
                tok.Type  = ZScriptTokenType.String;
                tok.Value = outs;
                return(tok);
            }

            stream.Position = cpos;
            return(null);
        }
        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();
        }
    }
Пример #4
0
        internal ZScriptStateStructure(ActorStructure actor, ZDTextParser zdparser)
        {
            ZScriptParser    parser    = (ZScriptParser)zdparser;
            Stream           stream    = parser.DataStream;
            ZScriptTokenizer tokenizer = new ZScriptTokenizer(parser.DataReader);

            parser.tokenizer = tokenizer;

            // todo: parse stuff
            //
            string[] control_keywords = new string[] { "goto", "loop", "wait", "fail", "stop" };

            while (true)
            {
                // expect identifier or string.
                // if it's an identifier, it can be goto/loop/wait/fail/stop.
                // if it's a string, it's always a sprite name.
                tokenizer.SkipWhitespace();
                long         cpos  = stream.Position;
                ZScriptToken token = tokenizer.ExpectToken(ZScriptTokenType.Identifier, ZScriptTokenType.String, ZScriptTokenType.CloseCurly);
                if (token == null || !token.IsValid)
                {
                    ZScriptToken _token = TryReadSprite(parser, stream, tokenizer);
                    if (_token == null)
                    {
                        parser.ReportError("Expected identifier or string, got " + ((Object)token ?? "<null>").ToString());
                        return;
                    }

                    token = _token;
                }

                if (token.Type == ZScriptTokenType.CloseCurly)
                {
                    stream.Position--;
                    break; // done
                }
                else if (token.Type == ZScriptTokenType.Identifier)
                {
                    string s_keyword = token.Value.ToLowerInvariant();
                    if (control_keywords.Contains(s_keyword))
                    {
                        if (s_keyword == "goto") // just use decorate goto here. should work. but check for semicolon!
                        {
                            gotostate        = new ZScriptStateGoto(actor, parser);
                            parser.tokenizer = tokenizer;
                        }

                        //parser.LogWarning(string.Format("keyword {0}", s_keyword));

                        tokenizer.SkipWhitespace();
                        token = tokenizer.ExpectToken(ZScriptTokenType.Semicolon);
                        if (token == null || !token.IsValid)
                        {
                            parser.ReportError("Expected ;, got " + ((Object)token ?? "<null>").ToString());
                            return;
                        }

                        continue;
                    }
                }

                // make sure it's not a label of the next state. if it is, break out.
                long         cpos2     = stream.Position; // local rewind point
                ZScriptToken token2    = tokenizer.ExpectToken(ZScriptTokenType.Colon, ZScriptTokenType.Dot);
                bool         nextstate = (token2 != null && token2.IsValid);
                stream.Position = cpos2; // rewind to before state label read
                if (nextstate)
                {
                    stream.Position = cpos;
                    break;
                }

                // it's a frame definition. read it.
                string spritename = token.Value.ToLowerInvariant();
                if (spritename.Length != 4)
                {
                    parser.ReportError("Sprite name should be exactly 4 characters long (got " + spritename + ")");
                    return;
                }

                tokenizer.SkipWhitespace();

                token = TryReadSprite(parser, stream, tokenizer);
                if (token == null)
                {
                    parser.ReportError("Expected sprite frame(s)");
                    return;
                }

                string spriteframes = token.Value;

                //parser.LogWarning(string.Format("sprite {0} {1}", spritename, spriteframes));

                // duration
                int duration;
                tokenizer.SkipWhitespace();
                // this can be a function call, or a constant.
                token = tokenizer.ExpectToken(ZScriptTokenType.Identifier);
                if (token != null && token.IsValid)
                {
                    duration = -1;
                    tokenizer.SkipWhitespace();
                    token = tokenizer.ExpectToken(ZScriptTokenType.OpenParen);
                    if (token != null && token.IsValid)
                    {
                        List <ZScriptToken> tokens = parser.ParseExpression(true);
                        tokenizer.SkipWhitespace();
                        token = tokenizer.ExpectToken(ZScriptTokenType.CloseParen);
                        if (token == null || !token.IsValid)
                        {
                            parser.ReportError("Expected ), got " + ((Object)token ?? "<null>").ToString());
                            return;
                        }
                    }
                }
                else
                {
                    if (!parser.ParseInteger(out duration))
                    {
                        return;
                    }
                }

                // now, it can also contain BRIGHT, LIGHT(), OFFSET()
                string[]         allspecials = new string[] { "bright", "light", "offset", "fast", "slow", "nodelay", "canraise" };
                HashSet <string> specials    = new HashSet <string>();
                // maybe something else. I don't know.
                FrameInfo info = new FrameInfo();

                // Make the sprite name
                string realspritename = (spritename + spriteframes[0]).ToUpperInvariant();

                // Ignore some odd ZDoom things
                if (/*!realspritename.StartsWith("TNT1") && */ !realspritename.StartsWith("----") && !realspritename.Contains("#")) // [ZZ] some actors have only TNT1 state and receive a random image because of this
                {
                    info.Sprite   = realspritename;                                                                                 //mxd
                    info.Duration = duration;
                    sprites.Add(info);
                }

                while (true)
                {
                    tokenizer.SkipWhitespace();
                    cpos2 = stream.Position;
                    token = tokenizer.ExpectToken(ZScriptTokenType.Identifier, ZScriptTokenType.Semicolon, ZScriptTokenType.OpenCurly);
                    if (token == null || !token.IsValid)
                    {
                        parser.ReportError("Expected identifier, ;, or {, got " + ((Object)token ?? "<null>").ToString());
                        return;
                    }

                    // if it's opencurly, it means that everything else is an anonymous block.
                    // skip/parse that.
                    // if it's semicolon, it means end of the frame.
                    // if it's BRIGHT, LIGHT() or OFFSET(), it should be processed.
                    // if it's something else (but identifier), then it's an action function call, process it.
                    if (token.Type == ZScriptTokenType.OpenCurly)
                    {
                        stream.Position--;
                        if (!parser.SkipBlock())
                        {
                            return;
                        }
                        break; // this block is done
                    }
                    else if (token.Type == ZScriptTokenType.Semicolon)
                    {
                        break; // done
                    }
                    else // identifier
                    {
                        string special = token.Value.ToLowerInvariant();
                        if (allspecials.Contains(special))
                        {
                            if (specials.Contains(special))
                            {
                                parser.ReportError("'" + special + "' cannot be used twice");
                                return;
                            }

                            specials.Add(special);

                            if (special == "bright")
                            {
                                info.Bright = true;
                            }
                            else if (special == "light" || special == "offset")
                            {
                                tokenizer.SkipWhitespace();
                                token = tokenizer.ExpectToken(ZScriptTokenType.OpenParen);
                                if (token == null || !token.IsValid)
                                {
                                    parser.ReportError("Expected (, got " + ((Object)token ?? "<null>").ToString());
                                    return;
                                }

                                List <ZScriptToken> tokens = parser.ParseExpression(true);
                                tokenizer.SkipWhitespace();
                                token = tokenizer.ExpectToken(ZScriptTokenType.CloseParen);
                                if (token == null || !token.IsValid)
                                {
                                    parser.ReportError("Expected ), got " + ((Object)token ?? "<null>").ToString());
                                    return;
                                }

                                // parse the light expression.
                                if (special == "light")
                                {
                                    if (tokens.Count != 1 || (tokens[0].Type != ZScriptTokenType.String && tokens[0].Type != ZScriptTokenType.Identifier))
                                    {
                                        parser.ReportError("Light() special takes one string argument");
                                        return;
                                    }

                                    info.LightName = tokens[0].Value;
                                }
                            }
                        }
                        else
                        {
                            //
                            stream.Position = cpos2;
                            string actionfunction = parser.ParseDottedIdentifier();
                            //parser.LogWarning("actionfunction = " + actionfunction);
                            if (actionfunction == null)
                            {
                                return;
                            }
                            //
                            tokenizer.SkipWhitespace();
                            token = tokenizer.ExpectToken(ZScriptTokenType.OpenParen);
                            if (token != null && token.IsValid)
                            {
                                List <ZScriptToken> tokens = parser.ParseExpression(true);
                                tokenizer.SkipWhitespace();
                                token = tokenizer.ExpectToken(ZScriptTokenType.CloseParen);
                                if (token == null || !token.IsValid)
                                {
                                    parser.ReportError("Expected ), got " + ((Object)token ?? "<null>").ToString());
                                    return;
                                }

                                // possibly do something with the arguments? not now though.
                            }

                            // expect semicolon and break.
                            tokenizer.SkipWhitespace();
                            token = tokenizer.ExpectToken(ZScriptTokenType.Semicolon);
                            if (token == null || !token.IsValid)
                            {
                                parser.ReportError("Expected ;, got " + ((Object)token ?? "<null>").ToString());
                                return;
                            }

                            break;
                        } // if not special
                    }     // if identifier
                }         // frame parsing loop (inner)
            }             // state parsing loop (outer)

            TrimLeft();
        }
Пример #5
0
        internal ZScriptStateGoto(ActorStructure actor, ZDTextParser zdparser)
        {
            // goto syntax that is accepted by GZDB is [classname::]statename[+offset]

            ZScriptParser    parser    = (ZScriptParser)zdparser;
            Stream           stream    = parser.DataStream;
            ZScriptTokenizer tokenizer = new ZScriptTokenizer(parser.DataReader);

            parser.tokenizer = tokenizer;

            tokenizer.SkipWhitespace();
            string firsttarget = parser.ParseDottedIdentifier();

            if (firsttarget == null)
            {
                return;
            }

            ZScriptToken token;

            string secondtarget = null;
            int    offset       = 0;

            tokenizer.SkipWhitespace();
            token = tokenizer.ExpectToken(ZScriptTokenType.DoubleColon);
            if (token != null && token.IsValid)
            {
                secondtarget = parser.ParseDottedIdentifier();
                if (secondtarget == null)
                {
                    return;
                }
            }

            tokenizer.SkipWhitespace();
            token = tokenizer.ExpectToken(ZScriptTokenType.OpAdd);
            if (token != null && token.IsValid)
            {
                tokenizer.SkipWhitespace();
                token = tokenizer.ExpectToken(ZScriptTokenType.Integer);
                if (token == null || !token.IsValid)
                {
                    parser.ReportError("Expected state offset, got " + ((Object)token ?? "<null>").ToString());
                    return;
                }

                offset = token.ValueInt;
            }

            // Check if we don't have the class specified
            if (string.IsNullOrEmpty(secondtarget))
            {
                // First target is the state to go to
                classname = actor.ClassName;
                statename = firsttarget.ToLowerInvariant().Trim();
            }
            else
            {
                // First target is the base class to use
                // Second target is the state to go to
                classname = firsttarget.ToLowerInvariant().Trim();
                statename = secondtarget.ToLowerInvariant().Trim();
            }

            spriteoffset = offset;

            if ((classname == "super") && (actor.BaseClass != null))
            {
                classname = actor.BaseClass.ClassName;
            }
        }