Пример #1
0
        private static void EmitMessage(IEmitter emitter, FileContainer.Message msg)
        {
            emitter.Emit(new MappingStart());
            emitter.Emit(new Scalar(msg.MsgName));

            emitter.Emit(new SequenceStart(null, null, true, SequenceStyle.Block));
            foreach (FileContainer.Message.Page page in msg)
            {
                EmitPage(emitter, page);
                emitter.Emit(new Comment(string.Empty, false));
            }

            emitter.Emit(new SequenceEnd());
            emitter.Emit(new MappingEnd());
        }
Пример #2
0
        private static void ReadMessage(IParser parser, FileContainer cont)
        {
            var msg = new FileContainer.Message();

            //Name
            parser.Expect <MappingStart>();
            var msgName = parser.Expect <Scalar>();

            if (msgName.Value != string.Empty)
            {
                msg.MsgName = msgName.Value;
            }

            //Pages
            parser.Expect <SequenceStart>();
            while (parser.Allow <SequenceEnd>() == null)
            {
                ReadPage(parser, msg);
            }

            parser.Expect <MappingEnd>();
            cont.Messages.Add(msg);
        }
Пример #3
0
        private static void ReadPage(IParser parser, FileContainer.Message msg)
        {
            var page = new FileContainer.Message.Page();

            //Commands
            parser.Expect <MappingStart>();
            var cmdsName = parser.Expect <Scalar>();

            if (cmdsName.Value != nameof(page.Commands))
            {
                throw new YamlException($"\"{nameof(page.Commands)}\" scalar expected.");
            }

            parser.Expect <SequenceStart>();
            while (parser.Allow <SequenceEnd>() == null)
            {
                ReadCommand(parser, page);
            }
            parser.Expect <MappingEnd>();

            //Comments
            parser.Expect <MappingStart>();
            var commentsName = parser.Expect <Scalar>();

            if (commentsName.Value != nameof(page.Comments))
            {
                throw new YamlException($"\"{nameof(page.Comments)}\" scalar expected.");
            }

            parser.Expect <MappingStart>();
            while (parser.Allow <MappingEnd>() == null)
            {
                var commentIndex   = parser.Expect <Scalar>();
                var commentContent = parser.Expect <Scalar>();

                page.Comments.Add(Convert.ToInt32(commentIndex.Value), commentContent.Value);
            }
            parser.Expect <MappingEnd>();

            //Dialogue
            parser.Expect <MappingStart>();
            var dialogeName = parser.Expect <Scalar>();

            if (dialogeName.Value != nameof(page.SpokenLine))
            {
                throw new YamlException($"\"{nameof(page.SpokenLine)}\" scalar expected.");
            }

            string[] dialogue = parser.Expect <Scalar>().Value.Split(new[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);
            foreach (string str in dialogue)
            {
                page.SpokenLine.Add(str.Trim());
            }

            parser.Expect <MappingEnd>();

            //Page end
            parser.Expect <MappingStart>();
            var pageEnd = parser.Expect <Scalar>();

            if (pageEnd.Value != CommandType.PageEnd.ToString())
            {
                throw new YamlException($"\"{CommandType.PageEnd}\" scalar expected.");
            }

            var symbol = parser.Expect <Scalar>();

            if (symbol.Value != string.Empty)
            {
                var pgEndCmd = new Command(symbol.Value, new string[0], CommandType.PageEnd);
                page.Commands.Add(pgEndCmd);
            }

            parser.Expect <MappingEnd>();
            msg.Pages.Add(page);
        }