Ejemplo n.º 1
0
        //-----------------------------------------------------------------------------
        // Constructors
        //-----------------------------------------------------------------------------
        public CommandParam(string str)
        {
            stringValue = str;
            parent = null;
            type = CommandParamType.String;
            count = 0;
            // TODO: parse int/float.

            float.TryParse(str, out floatValue);
            int.TryParse(str, out intValue);
            bool.TryParse(str, out boolValue);
        }
Ejemplo n.º 2
0
        // Parse and interpret the given text stream as a script, line by line.
        public override void ReadScript(StreamReader reader, string path)
        {
            this.fileName = path;
            this.streamReader = reader;

            BeginReading();

            parameterParent	= new CommandParam("");
            parameterParent.Type = CommandParamType.Array;
            parameterRoot	= parameterParent;
            parameter		= null;

            // Read all lines.
            lineIndex = -1;
            while (!reader.EndOfStream) {
                NextLine();
                ReadLine(line);
            }

            EndReading();
        }
Ejemplo n.º 3
0
        protected void CompleteStatement()
        {
            if (parameterRoot.Children != null) {
                string commandName = parameterRoot.Children.Str;
                parameterRoot.Children = parameterRoot.Children.NextParam;
                parameterRoot.Count--;

                if (!ReadCommand(commandName, parameterRoot)) {
                    ThrowParseError(commandName + " is not a valid command", false);
                }
            }

            parameterParent	= new CommandParam("");
            parameterParent.Type = CommandParamType.Array;
            parameterRoot	= parameterParent;
            parameter		= null;
        }
Ejemplo n.º 4
0
 //-----------------------------------------------------------------------------
 // Constructor
 //-----------------------------------------------------------------------------
 public NewScriptReader()
 {
     parameter		= null;
     parameterRoot	= null;
     commands		= new List<ScriptCommand>();
 }
Ejemplo n.º 5
0
 private CommandParam AddParam()
 {
     CommandParam newParam = new CommandParam(word);
     if (parameter == null)
         parameterParent.Children = newParam;
     else
         parameter.NextParam = newParam;
     parameterParent.Count++;
     newParam.Parent = parameterParent;
     parameter = newParam;
     return newParam;
 }
Ejemplo n.º 6
0
        // Read a single line of the script.
        protected override void ReadLine(string line)
        {
            word = "";
            bool quotes = false;
            charIndex = 0;

            // Parse line character by character.
            for (int i = 0; i < line.Length; i++) {
                char c = line[i];
                charIndex = i;

                // Parse quotes.
                if (quotes) {
                    // Closing quotes.
                    if (c == '\"') {
                        quotes = false;
                        CompleteWord(true);
                    }
                    else
                        word += c;
                }

                // Whitespace.
                else if (c == ' ' || c == '\t')
                    CompleteWord();

                // Commas.
                else if (c == ',')
                    CompleteWord();

                // Semicolons.
                else if (c == ';') {
                    CompleteWord();
                    int prevLineIndex = lineIndex;
                    CompleteStatement();
                    if (lineIndex > prevLineIndex)
                        return;
                }

                // Single-line comment.
                else if (c == '#') {
                    break; // Ignore the rest of the line.
                }

                // Opening quotes.
                else if (word.Length == 0 && c == '\"')
                    quotes = true;

                // Opening parenthesis.
                else if (word.Length == 0 && c == '(') {
                    parameterParent = AddParam();
                    parameterParent.Type = CommandParamType.Array;
                    parameter = null;
                }

                // Closing parenthesis.
                else if (c == ')') {
                    CompleteWord();
                    if (parameterParent == parameterRoot) {
                        ThrowParseError("Unexpected symbol ')'");
                    }
                    else {
                        parameter = parameterParent;
                        parameterParent = parameterParent.Parent;
                    }
                }

                // Valid keyword character.
                else if (IsValidKeywordCharacter(c))
                    word += c;

                // Error: Unexpected character.
                else
                    ThrowParseError("Unexpected symbol '" + c + "'");
            }

            charIndex++;

            // Make sure quotes are closed and statements are ended.
            if (quotes)
                ThrowParseError("Expected \"");

            CompleteWord();
        }
Ejemplo n.º 7
0
        //-----------------------------------------------------------------------------
        // Virtual methods
        //-----------------------------------------------------------------------------
        // Begins reading the script.
        //protected virtual void BeginReading() {}
        // Ends reading the script.
        //protected virtual void EndReading() {}
        // Reads a line in the script as a command.
        protected virtual bool ReadCommand(string commandName, CommandParam parameters)
        {
            for (int i = 0; i < commands.Count; i++) {
                if (String.Compare(commands[i].Name, commandName,
                    StringComparison.CurrentCultureIgnoreCase) == 0)
                {
                    commands[i].Action(parameters);
                    return true;
                }
            }

            return false;
        }
Ejemplo n.º 8
0
        protected void PrintParementers(CommandParam param)
        {
            CommandParam p = param.Children;
            while (p != null) {
                if (p.Type == CommandParamType.Array) {
                    Console.Write("(");
                    PrintParementers(p);
                    Console.Write(")");
                }
                else
                    Console.Write(p.Str);

                p = p.NextParam;
                if (p != null)
                    Console.Write(", ");
            }
        }
Ejemplo n.º 9
0
 private void ReadSpecialCommand(string commandName, CommandParam parameters)
 {
     bool exists = false;
     switch (loadingMode) {
     case LoadingModes.Tilesets:
         for (int i = 0; i < tilesetCommands.Count; i++) {
             if (String.Compare(tilesetCommands[i].Name, commandName,
                 StringComparison.CurrentCultureIgnoreCase) == 0) {
                     tilesetCommands[i].Action(parameters);
                 exists = true;
                 break;
             }
         }
         if (!exists)
             ThrowParseError(commandName + " is not a valid command while loading tilesets", false);
         break;
     case LoadingModes.Animations:
         for (int i = 0; i < animationCommands.Count; i++) {
             if (String.Compare(animationCommands[i].Name, commandName,
                 StringComparison.CurrentCultureIgnoreCase) == 0) {
                     animationCommands[i].Action(parameters);
                 exists = true;
                 break;
             }
         }
         if (!exists)
             ThrowParseError(commandName + " is not a valid command while loading animations", false);
         break;
     case LoadingModes.Sprites:
         for (int i = 0; i < spriteCommands.Count; i++) {
             if (String.Compare(spriteCommands[i].Name, commandName,
                 StringComparison.CurrentCultureIgnoreCase) == 0) {
                     spriteCommands[i].Action(parameters);
                 exists = true;
                 break;
             }
         }
         if (!exists)
             ThrowParseError(commandName + " is not a valid command while loading sprites", false);
         break;
     }
 }