Beispiel #1
0
        static string[] SplitCommand(string cmd)
        {
            var result = new List <string>();
            var tmp    = new StringBuilder();
            var ystr   = new YString();

            for (int i = 0; i < cmd.Length; ++i)
            {
                if (char.IsWhiteSpace(cmd[i]))
                {
                    string s = tmp.ToString();
                    if (!string.IsNullOrWhiteSpace(s))
                    {
                        ystr.SetEscapedText(s.Trim());
                        result.Add(ystr.Text);
                    }
                    tmp.Clear();
                }
                else
                {
                    tmp.Append(cmd[i]);
                }
            }
            {
                string s = tmp.ToString();
                if (!string.IsNullOrWhiteSpace(s))
                {
                    ystr.SetEscapedText(s.Trim());
                    result.Add(ystr.Text);
                }
                tmp.Clear();
            }
            return(result.ToArray());
        }
Beispiel #2
0
        public static Value TrimValue(Value value, int maxStringLength)
        {
            if (value.Type != Execution.Type.String)
            {
                return(value);
            }

            return(new Value(YString.Trim(value.String, maxStringLength)));
        }
Beispiel #3
0
        public static void Set(YSection section, string type, string name, string value)
        {
#if RELEASE
            try {
#endif
            switch (type)
            {
            case "str":
                var str = new YString();
                str.Name = name;
                str.Text = value;
                section.Add(str);
                break;

            case "num":
                var num = new YNumber();
                num.Name = name;
                if (ulong.TryParse(value, out var val1))
                {
                    num.UInt64Value = val1;
                }
                section.Add(num);
                break;

            case "flg":
                var flg = new YBoolean();
                flg.Name = name;
                if (value.TryToBoolean(out var val2))
                {
                    flg.Flag = val2;
                }
                section.Add(flg);
                break;

            default:                             // case "nul"
                var nul = new YNullOrEmpty();
                nul.Name = name;
                section.Add(nul);
                break;
            }
#if RELEASE
        }

        catch (Exception e) {
            Program.ShowError(e);
        }
#endif
        }
Beispiel #4
0
 public override Value Evaluate(MachineState state)
 {
     return(new Value(YString.Trim(Value, state.MaxStringLength)));
 }
Beispiel #5
0
 public ConstantString(YString value)
 {
     Value = value;
 }
Beispiel #6
0
 public ConstantString(string value)
 {
     Value = new YString(value);
 }
Beispiel #7
0
 public static YString BoolAdd(bool a, YString b, int maxStringLength)
 {
     return(YString.Add((Number)a, b, maxStringLength));
 }
Beispiel #8
0
        static DocumentGrammar()
        {
            Boolean.Rule = Choice(
                YamlLexer.True.Constant(YBoolean.True),
                YamlLexer.False.Constant(YBoolean.False));

            Null.Rule   = YamlLexer.Null.Constant(YNull.Null);
            Number.Rule = YamlLexer.Number.BindLexeme(YNumber.FromString);

            QuotedString.Rule = Choice(
                YamlLexer.SingleQuotedString.BindLexeme(YString.FromQuotedString),
                YamlLexer.DoubleQuotedString.BindLexeme(YString.FromQuotedString));

            UnquotedString.Rule = YamlLexer.UnquotedString.BindLexeme(YString.FromString);

            AnyString.Rule = Choice(QuotedString, UnquotedString);

            Alias.Rule = YamlLexer.Alias.BindLexeme(YAlias.FromString);

            BlockScalarText.Rule =
                from header in YamlLexer.BlockScalarHeader.Lexeme()
                from lines in Between(
                    ScopeTokenKind.ScopeBegin.Kind(),
                    OneOrMore(Choice(YamlLexer.BlockScalarLine.Lexeme(), YamlLexer.NewLine.Lexeme())),
                    ScopeTokenKind.ScopeEnd.Kind())
                select YString.FromBlockScalar(header, lines);

            BlockSequence.Rule =
                OneOrMore(YamlLexer.BlockSequenceItemMarker.Kind().Take(Node))
                .Bind(YSequence.FromList);

            FlowSequence.Rule =
                Between(YamlLexer.FlowSequenceBegin.Kind(), ZeroOrMore(FlowNode, YamlLexer.FlowItemSeparator.Kind()), YamlLexer.FlowSequenceEnd.Kind())
                .Bind(YSequence.FromList);

            BlockMapping.Rule =
                OneOrMore(NameValuePair(AnyString, YamlLexer.MappingSeparator.Kind(), Choice(Node, Alias)))
                .Bind(YMapping.FromDictionary);

            FlowMapping.Rule =
                Between(
                    YamlLexer.FlowMappingBegin.Kind(),
                    ZeroOrMore(
                        NameValuePair(
                            AnyString,
                            YamlLexer.MappingSeparator.Kind(),
                            Choice(FlowNode, Alias)),
                        YamlLexer.FlowItemSeparator.Kind()),
                    YamlLexer.FlowMappingEnd.Kind())
                .Bind(YMapping.FromDictionary);

            FlowNode.Rule =
                from anchor in Optional(YamlLexer.Anchor.Lexeme())
                from node in Choice <YNode>(
                    FlowSequence,
                    Attempt(FlowMapping), // enclosed into attempt lest it consumes QuotedString, UnquotedString
                    QuotedString,
                    Number,
                    Boolean,
                    Null,
                    UnquotedString)
                select YNode.AttachAnchor(node, anchor);

            BlockNode.Rule = Between(
                ScopeTokenKind.ScopeBegin.Kind(),
                from anchor in Optional(YamlLexer.Anchor.Lexeme())
                from node in Choice <YNode>(
                    BlockSequence,
                    Attempt(BlockMapping), // enclosed into attempt lest it consumes QuotedString, UnquotedString
                    QuotedString,
                    Number,
                    Boolean,
                    Null,
                    BlockScalarText,
                    UnquotedString)
                select YNode.AttachAnchor(node, anchor),
                ScopeTokenKind.ScopeEnd.Kind());

            Node.Rule = Choice(FlowNode, BlockNode);

            TagDirective.Rule = YamlLexer.TagDirective.BindLexeme(YTagDirective.FromLexeme);

            YamlVersionDirective.Rule = YamlLexer.VersionDirective.BindLexeme(YVersionDirective.FromLexeme);

            Directive.Rule = Choice <YDirective>(TagDirective, YamlVersionDirective);

            BareDocument.Rule = Node.Bind(YDocument.FromBareNode);

            ExplicitDocument.Rule = YamlLexer.DirectivesEndMarker.Kind().Take(Optional(Node)).Bind(YDocument.FromBareNode);

            DirectivesDocument.Rule =
                from directives in OneOrMore(Directive)
                from body in YamlLexer.DirectivesEndMarker.Kind().Take(Node)
                select YDocument.Create(directives, body);

            Document.Rule =
                OccupiesEntireInput(Choice(DirectivesDocument, ExplicitDocument, BareDocument).ThenSkip(Optional(YamlLexer.DocumentEndMarker.Lexeme())));
        }