Example #1
0
        // returning an empty string means we could not parse it
        //
        // note: for now, I ignore double %%
        //
        // log4net is case sensitive
        public static string parse(string syntax)
        {
            syntax_to_lw_syntax to_lw = new syntax_to_lw_syntax(syntax, "log4net");

            try {
                var stripped = strip_details(syntax);
                var patterns = stripped.Split(new [] { "%" }, StringSplitOptions.RemoveEmptyEntries);
                foreach (string pattern_and_suffix in patterns)
                {
                    var pattern = new string( pattern_and_suffix.TakeWhile(x => Char.IsLetterOrDigit(x) || x == '-' || x == '.').ToArray());
                    var suffix  = pattern_and_suffix.Substring(pattern.Length);

                    // https://logging.apache.org/log4net/log4net-1.2.13/release/sdk/log4net.Layout.PatternLayout.html
                    // '-' or '.' -> they are padding
                    var pad = new string( pattern.TakeWhile(x => Char.IsDigit(x) || x == '-' || x == '.').ToArray());
                    pattern = pattern.Substring(pad.Length);

                    if (pad.StartsWith("-"))
                    {
                        pad = pad.Substring(1);
                    }
                    // it can contain padding - but only "." specifies exact number of characters
                    bool fixed_now = pad.Contains(".");
                    if (fixed_now)
                    {
                        pad = pad.Substring(pad.IndexOf(".") + 1);
                    }

                    int min_len   = pad != "" ? int.Parse(pad) : -1;
                    var lw_column = column_to_lw_column(pattern);
                    if (lw_column == "newline")
                    {
                        continue;
                    }
                    to_lw.add_column(min_len, fixed_now, pattern, suffix, lw_column);
                }
            } catch (Exception e) {
                to_lw.on_error(e.Message);
            }
            return(to_lw.lw_syntax);
        }
Example #2
0
        // returning an empty string means we could not parse it
        //
        // nlog syntax is case-insensitive
        public static string parse(string syntax) {
            // https://github.com/NLog/NLog/wiki/Pad-Layout-Renderer
            // https://github.com/NLog/NLog/wiki/Layout-renderers
            syntax_to_lw_syntax to_lw = new syntax_to_lw_syntax(syntax, "nlog");
            syntax = syntax.ToLower();
            try {
                var renderers = split_into_renderers(syntax);
                foreach (var renderer_and_suffix in renderers) {
                    int end_idx = renderer_and_suffix.LastIndexOf("}");
                    if (end_idx < 0) {
                        to_lw.on_error("pattern not ending in }");
                        break;
                    }
                    var renderer = renderer_and_suffix.Substring(0, end_idx).Trim();
                    if (renderer.StartsWith("${"))
                        renderer = renderer.Substring(2);
                    var suffix = renderer_and_suffix.Substring(end_idx + 1);
                    var renderer_and_props = parse_renderer(renderer);

                    if (need_to_get_inner_renderer(renderer_and_props.Item1))
                        renderer_and_props = get_inner_renderer(renderer_and_props.Item2);
                    if (ignore_renderer(renderer_and_props.Item1))
                        continue;
                    var inner = renderer_and_props.Item2.FirstOrDefault(x => x.Item1 == "inner");
                    if (inner != null && inner.Item2 == "layout")
                        // applies to full layout, we don't care
                        continue;
                    string renderer_name = renderer_and_props.Item1;
                    if (renderer_name == "newline")
                        continue;
                    // here - we have the renderer and its properties
                    int min_len = -1;
                    bool fixed_now = false;
                    if (renderer_name == "pad") {
                        // care about padding
                        inner = renderer_and_props.Item2.FirstOrDefault(x => x.Item1 == "inner");
                        if (inner == null) {
                            inner = renderer_and_props.Item2.FirstOrDefault(x => x.Item2.StartsWith("${"));
                            if (inner == null) {
                                to_lw.on_error("Invalid padding");
                                break;
                            }
                        }
                        if (inner.Item1 == "layout")
                            // applies to all line - we don't care
                            continue;
                        renderer_name = parse_renderer(inner.Item2).Item1;
                        var padding = renderer_and_props.Item2.FirstOrDefault(x => x.Item1 == "padding");
                        if (padding != null)
                            min_len = Math.Abs(int.Parse(padding.Item2));
                        var fixed_len = renderer_and_props.Item2.FirstOrDefault(x => x.Item1 == "fixedlength");
                        fixed_now = fixed_len != null && fixed_len.Item2 == "true" && min_len > 0;
                    }
                    var lw_column = column_to_lw_column(renderer_name);
                    to_lw.add_column(min_len, fixed_now, renderer_name, suffix, lw_column);
                }
            } catch (Exception e) {
                to_lw.on_error(e.Message);
            }
            return to_lw.lw_syntax;
        }
Example #3
0
        // returning an empty string means we could not parse it
        //
        // nlog syntax is case-insensitive
        public static string parse(string syntax)
        {
            // https://github.com/NLog/NLog/wiki/Pad-Layout-Renderer
            // https://github.com/NLog/NLog/wiki/Layout-renderers
            syntax_to_lw_syntax to_lw = new syntax_to_lw_syntax(syntax, "nlog");

            syntax = syntax.ToLower();
            try {
                var renderers = split_into_renderers(syntax);
                foreach (var renderer_and_suffix in renderers)
                {
                    int end_idx = renderer_and_suffix.LastIndexOf("}");
                    if (end_idx < 0)
                    {
                        to_lw.on_error("pattern not ending in }");
                        break;
                    }
                    var renderer = renderer_and_suffix.Substring(0, end_idx).Trim();
                    if (renderer.StartsWith("${"))
                    {
                        renderer = renderer.Substring(2);
                    }
                    var suffix             = renderer_and_suffix.Substring(end_idx + 1);
                    var renderer_and_props = parse_renderer(renderer);

                    if (need_to_get_inner_renderer(renderer_and_props.Item1))
                    {
                        renderer_and_props = get_inner_renderer(renderer_and_props.Item2);
                    }
                    if (ignore_renderer(renderer_and_props.Item1))
                    {
                        continue;
                    }
                    var inner = renderer_and_props.Item2.FirstOrDefault(x => x.Item1 == "inner");
                    if (inner != null && inner.Item2 == "layout")
                    {
                        // applies to full layout, we don't care
                        continue;
                    }
                    string renderer_name = renderer_and_props.Item1;
                    if (renderer_name == "newline")
                    {
                        continue;
                    }
                    // here - we have the renderer and its properties
                    int  min_len   = -1;
                    bool fixed_now = false;
                    if (renderer_name == "pad")
                    {
                        // care about padding
                        inner = renderer_and_props.Item2.FirstOrDefault(x => x.Item1 == "inner");
                        if (inner == null)
                        {
                            inner = renderer_and_props.Item2.FirstOrDefault(x => x.Item2.StartsWith("${"));
                            if (inner == null)
                            {
                                to_lw.on_error("Invalid padding");
                                break;
                            }
                        }
                        if (inner.Item1 == "layout")
                        {
                            // applies to all line - we don't care
                            continue;
                        }
                        renderer_name = parse_renderer(inner.Item2).Item1;
                        var padding = renderer_and_props.Item2.FirstOrDefault(x => x.Item1 == "padding");
                        if (padding != null)
                        {
                            min_len = Math.Abs(int.Parse(padding.Item2));
                        }
                        var fixed_len = renderer_and_props.Item2.FirstOrDefault(x => x.Item1 == "fixedlength");
                        fixed_now = fixed_len != null && fixed_len.Item2 == "true" && min_len > 0;
                    }
                    var lw_column = column_to_lw_column(renderer_name);
                    to_lw.add_column(min_len, fixed_now, renderer_name, suffix, lw_column);
                }
            } catch (Exception e) {
                to_lw.on_error(e.Message);
            }
            return(to_lw.lw_syntax);
        }
        // returning an empty string means we could not parse it
        //
        // note: for now, I ignore double %%
        //
        // log4net is case sensitive
        public static string parse(string syntax) {
            syntax_to_lw_syntax to_lw = new syntax_to_lw_syntax(syntax, "log4net");
            try {
                var stripped = strip_details(syntax);
                var patterns = stripped.Split( new [] {"%"}, StringSplitOptions.RemoveEmptyEntries);
                foreach (string pattern_and_suffix in patterns) {
                    var pattern = new string( pattern_and_suffix.TakeWhile(x => Char.IsLetterOrDigit(x) || x == '-' || x == '.').ToArray());
                    var suffix = pattern_and_suffix.Substring(pattern.Length);

                    // https://logging.apache.org/log4net/log4net-1.2.13/release/sdk/log4net.Layout.PatternLayout.html
                    // '-' or '.' -> they are padding
                    var pad = new string( pattern.TakeWhile(x => Char.IsDigit(x) || x == '-' || x == '.').ToArray() );
                    pattern = pattern.Substring(pad.Length);

                    if (pad.StartsWith("-"))
                        pad = pad.Substring(1);
                    // it can contain padding - but only "." specifies exact number of characters
                    bool fixed_now = pad.Contains(".");
                    if (fixed_now)
                        pad = pad.Substring(pad.IndexOf(".") + 1);

                    int min_len = pad != "" ? int.Parse(pad) : -1;
                    var lw_column = column_to_lw_column(pattern);
                    if (lw_column == "newline")
                        continue;
                    to_lw.add_column(min_len, fixed_now, pattern, suffix, lw_column);
                }
            } catch (Exception e) {
                to_lw.on_error(e.Message);
            }
            return to_lw.lw_syntax;
        }