CodeCompletion/CodeFormatter.cs - master - n-dimens/pascalabcnet

CodeCompletion/CodeFormatter.cs
3 535 строк133 KB
Mikhalkovich Stanislav
Исправление автоформатирования []
04 янв 2025, 22:54
04 янв 2025, 22:540848a1b
// Copyright (c) Ivan Bondarev, Stanislav Mikhalkovich (for details please see \doc\copyright.txt)
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
/*
 * algoritm formatirovanija sledujushij:
 * po sintaksicheskomu derevu stroitsja generiruetsja tekst programmy
 * vse chto nahoditsja mezhdu uzlami sintaksicheskogo dereva takzhe uchityvaetsja
 * s pomoshuj razlichnyh flagov proizvoditsja sootvetstvujushee formatirovanie
 * naprimer. posle procedury stavitsja pustaja stroka
 * dalee pod kommentariem budet ponimatsja obobshennyj kommentarii, kotorye vkluchajut v sebja
 * takzhe znaki operacii, drugie simvoly, kotorye ne okajamlajut tekuchij token
 * zdes ochen vazhny source konteksty
*/
using System;
using System.Collections.Generic;
using System.Text;
using System.Globalization;
using PascalABCCompiler.SyntaxTree;
using System.IO;

namespace CodeFormatters
{
    class FormatterOptions
    {
        public int SpaceBetweenArguments = 1;
        public int AlwaysNewLineForBeginEndBlock = 1;
        public int SpaceBetweenIdentifiers = 1;
        public int AggressiveMode = 0;
    }

    public class CodeFormatter : PascalABCCompiler.SyntaxTree.AbstractVisitor/*, PascalABCCompiler.Parsers.ICodeFormatter*/
    {
        private StringBuilder sb = new StringBuilder();
        private int tab = 2;//tabulacija
        private int off = 0;//tekushij otstup
        private Stack<int> region_offsets = new Stack<int>();
        private bool in_procedure = false;//flag, v procedure li my
        private bool attr_on_new_line = true;
        private bool in_class = false;
        private bool has_implementation = false;
        private bool init_part = false;
        private NumberFormatInfo nfi;
        private Dictionary<string, string> keywords = new Dictionary<string, string>();
        private int[] line_lens;//massiv dlin strok, ispolzuetsja dlja podscheta pozicii v tekste (Position v sintaksicheskom dereve nepravilnye ;) )
        private string Text;//tekst programmy
        private syntax_tree_node prev_sn = null;//predydushij obrabotannyj uzel dereva
        private int cur_src_off = 0;
        private bool add_space_before = false;//flag, stavit li probel pered kommentariem (esli nuzhno)
        private bool is_lambda_parameters = false;
        private bool add_space_after = false;//stavit li probel posle kommentarija (esli nuzhno)
        //private bool add_tab_after = false;
        private bool add_newline_before = false;//dobavlat novuju stroku pered kommentariem (esli nuzhno)
        private bool add_newline_after = false;//dobavit novuju stroku posle kommentarija (esli nuzhno)
        private bool insert_newline_after_prev = false;//stavit pustuju stroku posle konstrukcii
        private bool insert_newline_after_prev_semicolon = false;//vstavit pustuju stroku dlja sluchaja, kogda ot predydushej konstrukcii
                                                                 //ostalsja razdiletel, kotoryj ne vhodit v etu konstrukciju. primer blok var a: integer; type t = integer; pered type nado stavit pustuju stroku, no pri etom ne zabyt
                                                                 //dobavit tochku s zapjatoj
        private bool read_from_beg_pos = false;
        private bool dec_offset_before_comment = false;
        private bool add_new_line_else_specific = false;
        private int keyword_offset = 0;
        private int caret_line = 0;
        private int caret_col = 0;
        private int caret_pos = 0;
        private int output_caret_line = 0;
        private int output_caret_col = 0;
        private bool caret_syn_node_found = false;
        private Dictionary<string, string> nodes_with_beg_pos = new Dictionary<string, string>();
        private bool use_strong_formatting = false;
        private bool skip_spaces_before = false;
        private bool skip_spaces_after = false;
        private bool force_tab = false;
        private int addit_pos_for_multiline = 0;
        private Stack<syntax_tree_node> multi_line_nodes = new Stack<syntax_tree_node>();
        private FormatterOptions options;
        

        public CodeFormatter(int tab)
        {
            nfi = new NumberFormatInfo();
            nfi.NumberGroupSeparator = ".";
            this.tab = tab;
            nodes_with_beg_pos.Add("for_node","for_node");
            nodes_with_beg_pos.Add("function_header", "function_header");

            ReadOptions();
        }

        private void ReadOptions()
        {
            options = new FormatterOptions();
            try
            {
                string PABCWorkIniFile = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.FullyQualifiedName) + @"\pabcworknet.ini";
                //System.Windows.Forms.MessageBox.Show(PABCWorkIniFile);
                string FormatterOptionsFile = "FormatterOptions.ini";
                if (File.Exists(PABCWorkIniFile))
                {
                    string PABCWorkDir = File.ReadAllText(PABCWorkIniFile);
                    if (File.Exists(Path.Combine(PABCWorkDir, "FormatterOptions.ini")))
                        FormatterOptionsFile = Path.Combine(PABCWorkDir, "FormatterOptions.ini");
                }
                string[] lines = File.ReadAllLines(FormatterOptionsFile);
                for (int i = 0; i < lines.Length; i++)
                {
                    int pos = lines[i].IndexOf(';');
                    if (pos != -1)
                        lines[i] = lines[i].Substring(0, pos);
                }
                Type t = options.GetType();
                for (int i = 0; i < lines.Length; i++)
                {
                    string key = lines[i].Substring(0, lines[i].IndexOf('='));
                    string val = lines[i].Substring(lines[i].IndexOf('=') + 1);
                    t.GetField(key).SetValue(options, Convert.ToInt32(val));
                }
            }
            catch
            {
            }
        }

        public string FormatTree(string Text, compilation_unit cu, int cursor_line, int cursor_col)
        {
            PascalABCCompiler.Parsers.CommentBinder binder = new PascalABCCompiler.Parsers.CommentBinder();
            //comments = binder.Bind(cu, Text);
            this.Text = Text;
            string[] lines = Text.Split('\n');
            line_lens = new int[lines.Length];
            for (int i = 0; i < lines.Length; i++)
            {
                if (i > 0)
                    line_lens[i] = lines[i].Length + line_lens[i - 1] + 1;
                else
                    line_lens[i] = lines[i].Length + 1;
            }
            caret_line = cursor_line;
            caret_col = cursor_col;
            caret_pos = GetPosition(cursor_line, cursor_col);
            visit_node(cu);
            return sb.ToString();
        }

        public int Line
        {
            get
            {
                return output_caret_line;
            }
        }

        public int Column
        {
            get
            {
                return output_caret_col;
            }
        }

        private int GetPosition(int line, int col)
        {
            if (line >= 2)
                return line_lens[line - 2] + col - 1;
            return col - 1;
        }

        private void SetKeywordOffset(string s)
        {
            keyword_offset = s.Length;
            add_space_before = true;
        }

        private void multiline_stack_push(syntax_tree_node sn)
        {
            if (!in_one_row(sn))
                multi_line_nodes.Push(sn);
        }

        private void multiline_stack_pop(syntax_tree_node sn)
        {
            if (!in_one_row(sn) && multi_line_nodes.Count > 0)
                multi_line_nodes.Pop();
        }

        private bool in_one_row(syntax_tree_node sn)
        {
            if (options.AlwaysNewLineForBeginEndBlock == 0)
                return true;
            if (sn.source_context == null)
                return true;
            return sn.source_context.begin_position.line_num == sn.source_context.end_position.line_num;
        }

        private bool in_same_row(syntax_tree_node sn, syntax_tree_node sn2)
        {
            if (sn.source_context == null || sn2.source_context == null)
                return false;
            return sn.source_context.end_position.line_num == sn2.source_context.begin_position.line_num;
        }

        private int distance(syntax_tree_node sn1, syntax_tree_node sn2)
        {
            return GetPosition(sn2.source_context.begin_position.line_num, sn2.source_context.begin_position.column_num)-GetPosition(sn1.source_context.end_position.line_num, sn1.source_context.end_position.column_num)-1;
        }

        private bool is_forward(procedure_header ph)
        {
            if (ph.proc_attributes == null)
                return false;
            foreach (procedure_attribute pa in ph.proc_attributes.proc_attributes)
                if (pa.attribute_type == proc_attribute.attr_forward)
                    return true;
            return false;
        }

        private void WriteAmpersandIfNeed(ident id)
        {
            if (id.source_context != null)
            {
                int pos = GetPosition(id.source_context.begin_position.line_num, id.source_context.begin_position.column_num);
                if (Text[pos] == '&')
                    sb.Append("&");
            }
        }

        private void WriteNodeAndReplaceOverSpaces(syntax_tree_node sn)
        {
            if (sn.source_context != null)
            {
                int start_pos = GetPosition(sn.source_context.begin_position.line_num, sn.source_context.begin_position.column_num);
                int end_pos = GetPosition(sn.source_context.end_position.line_num, sn.source_context.end_position.column_num);
                string s = Text.Substring(start_pos, end_pos - start_pos + 1);
                string[] arr = s.Split(' ');
                for (int i = 0; i < arr.Length; i++)
                {
                    if (arr[i] != "")
                    {
                        sb.Append(arr[i]);
                        if (i < arr.Length - 1)
                            sb.Append(" ");
                    }
                }
                    
            }
        }

        private string RemoveOverSpaces(string s)
        {
            if (s.IndexOf("//") != -1 || s.IndexOf("{") != -1)
                return s;
            StringBuilder sb = new StringBuilder();
            string[] arr = s.Split(' ');
            for (int i = 0; i < arr.Length; i++)
            {
                if (arr[i] != "")
                {
                    sb.Append(arr[i]);
                    if (i < arr.Length - 1)
                        sb.Append(" ");
                }
            }
            return sb.ToString();
        }

        private void WriteNode(syntax_tree_node sn, bool remove_spaces = false)
        {
            if (sn.source_context != null)
            {
                int start_pos = GetPosition(sn.source_context.begin_position.line_num, sn.source_context.begin_position.column_num);
                int end_pos = GetPosition(sn.source_context.end_position.line_num, sn.source_context.end_position.column_num);
                string node_text = Text.Substring(start_pos, Math.Max(end_pos - start_pos + 1, 0));
                if (remove_spaces && !node_text.Contains("{"))
                    node_text = node_text.Replace(" ", "");
                sb.Append(node_text);
            }
        }

        private void WriteNodeWithIndent(syntax_tree_node sn)
        {
            int start_pos = GetPosition(sn.source_context.begin_position.line_num, sn.source_context.begin_position.column_num);
            int end_pos = GetPosition(sn.source_context.end_position.line_num, sn.source_context.end_position.column_num);
            string node_text = prepare_comment(RemoveOverSpaces(Text.Substring(start_pos, end_pos - start_pos + 1)), false);
            sb.Append(node_text);
        }

        private void WriteNode(syntax_tree_node sn, int offset)
        {
            int start_pos = GetPosition(sn.source_context.begin_position.line_num, sn.source_context.begin_position.column_num) + offset;
            int end_pos = GetPosition(sn.source_context.end_position.line_num, sn.source_context.end_position.column_num);
            bool tmp_add_space_after = add_space_after;
            add_space_after = false;
            WriteCommentWithIndent(Text.Substring(start_pos, end_pos - start_pos + 1), true);
            add_space_after = tmp_add_space_after;
            //sb.Append(new string(' ', off) + Text.Substring(start_pos, end_pos - start_pos + 1));
        }

        private string prepare_comment(string s, bool off_first_line=true)
        {
            s = s.TrimStart(' ', '\n', '\t', '\r');
            if (s.Contains("\n"))
            {
                string[] rows = s.Split('\n');
                for (int i = 0; i < rows.Length; i++)
                {
                    if (i != 0 || off_first_line)
                        rows[i] = new string(' ', off) + rows[i].TrimStart(' ', '\t');
                }
                return string.Join("\n", rows);
            }
            return s;
        }

        private string GetPossibleComment(syntax_tree_node sn, int off, syntax_tree_node next_sn)
        {
            int pos = GetPosition(sn.source_context.end_position.line_num, sn.source_context.end_position.column_num) + off;
            int next_pos = GetPosition(next_sn.source_context.begin_position.line_num, next_sn.source_context.begin_position.column_num);
            string comm = Text.Substring(pos, next_pos - pos + 1);
            return comm;
        }

        private bool has_comment(string s)
        {
            return s.Contains("{") || s.Contains("(*") || s.Contains("//");
        }

        private int GetSpacesBefore(string s)
        {
            int i = 0;
            while (i < s.Length && s[i] == ' ')
                i++;
            return i;
        }

        private void WriteCommentWithIndent(string comm, bool before)
        {
            string[] lines = null;
            if (insert_newline_after_prev && !insert_newline_after_prev_semicolon && before)
            {
                if (comm.IndexOf("\n") != -1 && comm.IndexOf("\r") == -1)
                    lines = comm.Split(new string[] { "\n" }, StringSplitOptions.None);
                else
                    lines = comm.Split(new string[] { "\r\n" }, StringSplitOptions.None);
                if (lines.Length == 2)
                    comm = comm + "\r\n";
                else if (lines.Length < 2)
                    comm = comm + "\r\n" + "\r\n";
                insert_newline_after_prev = false;
            }
            if (add_newline_before)
            {
                if (comm.IndexOf("\r\n") == -1 && comm.IndexOf("\n") == -1)
                    comm = comm + "\r\n";
                //if (!comm.Trim(' ','\t').StartsWith("\r\n"))
                //    comm = "\r\n" + comm;
                add_newline_before = false;
            }
            else if (add_newline_after)
            {
                if (!comm.Trim(' ', '\t').EndsWith("\r\n") && !comm.Trim(' ', '\t').EndsWith("\n"))
                    comm = comm.TrimEnd()+"\r\n";
                add_newline_after = false;
            }
            if (comm.IndexOf("\n") != -1 && comm.IndexOf("\r") == -1)
                lines = comm.Split(new string[] { "\n" }, StringSplitOptions.None);
            else
                lines = comm.Split(new string[] { "\r\n" }, StringSplitOptions.None);
            if (lines.Length > 1)
            {
                int min_off = 0;
                for (int i = 1; i < lines.Length; i++)
                {
                    if (!add_new_line_else_specific && !(dec_offset_before_comment && i < lines.Length - 1))
                        if (multi_line_nodes.Count == 0 && lines[i].Trim() != "")
                        {
                            int ind = 0;
                            string tmp = lines[i];
                            while (ind < tmp.Length && (tmp[ind] == ' ' || tmp[ind] == '\t'))
                            {
                                ind++;
                            }
                            if (ind < off)
                            {
                                min_off = Math.Max(off - ind, min_off);
                            }
                        }
                }
                for (int i = 1; i < lines.Length; i++)
                {
                    if (add_new_line_else_specific)
                    {
                        if (i < lines.Length - 1 || lines[i].TrimStart(' ', '\t') != "")
                            lines[i] = new string(' ', off - tab) + lines[i].TrimStart(' ', '\t');
                        else
                            lines[i] = new string(' ', off) + lines[i].TrimStart(' ', '\t');
                    }
                    else if (dec_offset_before_comment && i < lines.Length - 1)
                        lines[i] = new string(' ', off + tab) + lines[i].TrimStart(' ', '\t');
                    else
                    {
                        if (multi_line_nodes.Count > 0)
                        {
                            if (multi_line_nodes.Count == 1)
                            {
                                if (!(multi_line_nodes.Peek() is function_lambda_definition) && !(multi_line_nodes.Peek() is simple_property))
                                    lines[i] = new string(' ', addit_pos_for_multiline) + lines[i];
                                else
                                    lines[i] = new string(' ', off) + lines[i].Trim();
                            }
                                
                            else
                            {
                                if (!(multi_line_nodes.Peek() is function_lambda_definition) && !(multi_line_nodes.Peek() is simple_property))
                                {
                                    if (off > lines[i].Length)
                                        lines[i] = new string(' ', addit_pos_for_multiline + off) + lines[i];
                                    else
                                        lines[i] = new string(' ', addit_pos_for_multiline) + lines[i];
                                }
                                else
                                {
                                    
                                    lines[i] = new string(' ', off) + lines[i].Trim();
                                    if (lines[i].EndsWith(" else"))
                                        lines[i] += " ";
                                }
                                    
                            }
                                
                        }
                        else
                        {
                            int ind = 0;
                            string tmp = lines[i];
                            while (ind < tmp.Length && (tmp[ind] == ' ' || tmp[ind] == '\t'))
                            {
                                ind++;
                            }
                            if (ind < off)
                            {
                                addit_pos_for_multiline = off - ind;
                            }
                            else
                                addit_pos_for_multiline = 0;
                            string ln = lines[i].TrimStart(' ', '\t');
                            if (ln.StartsWith("{$region"))
                            {
                                region_offsets.Push(off);
                                lines[i] = new string(' ', off) + ln;
                            }
                            else if (ln.StartsWith("{$endregion"))
                            {
                                int region_off = off;
                                if (region_offsets.Count != 0)
                                    region_off = region_offsets.Pop();
                                lines[i] = new string(' ', region_off) + ln;
                            }
                            else if (i < lines.Length - 1)
                            {
                                if (lines[i].Trim() != "")
                                    lines[i] = new string(' ', min_off) + lines[i];
                                else
                                    lines[i] = new string(' ', off);
                            }
                            else
                            {
                                string str = lines[i].TrimStart(' ', '\t');
                                /*if (str.StartsWith("//") || str.StartsWith("{"))
                                    lines[i] = new string(' ', off) + lines[i];
                                else*/
                                    lines[i] = new string(' ', off) + str;
                            }
                                
                        }
                    }
                }
            }
            if (lines.Length <= 2 && insert_newline_after_prev_semicolon && before)
            {
                if (lines.Length == 1)
                {
                    lines = new string[3] { lines[0], new string(' ', off), new string(' ', off) };
                }
                else
                {
                    lines = new string[3] { lines[0], new string(' ', off), lines[1] };
                }
            }
            string s = string.Join("\r\n", lines);
            if (add_space_before)
            {
                if (s.Length > 0 && !char.IsWhiteSpace(s[0]) && s[0] != '{' && !s.StartsWith("//") && !s.StartsWith("(*") && s[0] != ';' && !char.IsWhiteSpace(s[0]) && (sb.Length == 0 || !char.IsWhiteSpace(sb[sb.Length-1])))
                    sb.Append(' ');
            }
            else if (s.IndexOf("//") == -1)
                s = s.TrimStart(' ', '\t');
            sb.Append(s);
            if (add_space_after)
            {
                if (s.Length > 0)
                {
                    if (!char.IsWhiteSpace(s[s.Length - 1]) && s[s.Length - 1] != '}' && !s.EndsWith("//") && !s.EndsWith("*)"))
                        sb.Append(' ');
                }
                else
                    sb.Append(' ');
            }
            else
                s = s.TrimEnd(' ', '\t');
            add_space_after = false;
            add_space_before = false;
            add_newline_after = false;
            dec_offset_before_comment = false;
            add_new_line_else_specific = false;
            if (before)
            {
                insert_newline_after_prev = false;
                insert_newline_after_prev_semicolon = false;
            }
        }

        private void WritePossibleCommentBefore(syntax_tree_node sn)
        {
            int pos = GetPosition(sn.source_context.begin_position.line_num, sn.source_context.begin_position.column_num);
            int prev_pos = 0;
            if (prev_sn != null)
                if (read_from_beg_pos || sn is procedure_definition && prev_sn is program_module)
                {
                    prev_pos = GetPosition(prev_sn.source_context.begin_position.line_num, prev_sn.source_context.begin_position.column_num) + keyword_offset;
                }
                else
                    prev_pos = GetPosition(prev_sn.source_context.end_position.line_num, prev_sn.source_context.end_position.column_num) + 1;
            if (prev_pos < pos)
            {
                string comm = Text.Substring(prev_pos, pos - prev_pos);
                if (options.AggressiveMode == 1)
                {
                    string trimed_comm = comm.Trim();
                    if (comm.EndsWith(" ") && comm.IndexOf("\n") == -1)
                    {
                        comm = comm.TrimEnd(' ');
                        if (comm.Length == 0 || char.IsLetterOrDigit(comm[comm.Length - 1]) || add_space_before)
                            comm += " ";
                    }
                    if (comm.StartsWith(" ") && comm.IndexOf("\n") == -1)
                    {
                        comm = comm.TrimStart(' ');
                        if (comm.Length == 0 || char.IsLetterOrDigit(comm[0]) || add_space_after)
                            comm = " " + comm;
                    }
                    if (comm.StartsWith(" "))
                    {
                        
                        if (trimed_comm == "then" || trimed_comm == "do" || trimed_comm == "of")
                        {
                            comm = comm.TrimStart(' ');
                            if (comm.Length == 0 || char.IsLetterOrDigit(comm[0]) || add_space_after)
                                comm = " " + comm;
                        }
                    }
                    if (comm.EndsWith(" "))
                    {
                        string trimed_end = comm.TrimEnd(' ');
                        if (trimed_end.EndsWith("class") || trimed_end.EndsWith("static") || trimed_end.EndsWith("else"))
                            comm = comm.TrimEnd(' ')+" ";
                    }
                    if (comm.Replace(" ","") == "():")//special case: functions with no parameters
                    {
                        comm = "():";
                    }
                    if (comm.EndsWith("->"))
                    {
                        if (comm.StartsWith("()"))
                            comm = RemoveOverSpaces(comm);
                        else if (comm.StartsWith("procedure") || comm.StartsWith("function"))
                        {
                            comm = RemoveOverSpaces(comm);
                            comm = comm.Replace("( )", "()");
                        }
                        if (comm == "()->")
                            comm = "() ->";
                        comm += " ";
                    }
                    else if (comm.EndsWith("procedure->("))
                    {
                        comm = comm.Replace("procedure->(", "procedure -> (");
                    }
                    else if (comm.EndsWith("procedure->"))
                    {
                        comm = comm.Replace("procedure->", "procedure -> ");
                    }
                    else if (comm.StartsWith(":") && comm.EndsWith(":") && comm.Replace(" ", "") == "::")
                        comm = "::";
                    else if (comm.StartsWith("[") && comm.EndsWith(":"))
                        comm = comm.Replace(" ", "");
                    else if (comm.StartsWith("( ") && comm.TrimEnd().EndsWith("var"))
                        comm = comm.Replace(" ", "") + " ";
                    else if (trimed_comm.StartsWith(", ") && comm.TrimEnd().EndsWith("var"))
                        comm = RemoveOverSpaces(comm);
                    else if (trimed_comm.StartsWith(",var"))
                        comm = ", var" + trimed_comm.Replace(",var", "");
                    else if (comm.StartsWith("array") || comm.StartsWith("set") || comm.StartsWith("sequence"))
                        comm = RemoveOverSpaces(comm);
                    else if ((comm.StartsWith("class") || comm.StartsWith("interface")) && comm.EndsWith("("))
                        comm = comm.Replace(" ", "");
                    else if ((comm.StartsWith("auto") || comm.StartsWith("sealed") || comm.StartsWith("abstract")) && comm.EndsWith("("))
                        comm = RemoveOverSpaces(comm);
                    else if (comm.TrimEnd(' ').EndsWith("property"))
                        comm = RemoveOverSpaces(comm);
                    else if (comm.StartsWith("var") && comm.EndsWith("("))
                        comm = RemoveOverSpaces(comm);
                    else if (trimed_comm.StartsWith("[") && trimed_comm.EndsWith("]"))
                        comm = RemoveOverSpaces(comm).Replace("[ ", "[").Replace(" ]", "]");
                    else if ((comm.StartsWith("auto") || comm.StartsWith("sealed") || comm.StartsWith("abstract") || comm.StartsWith("static")) && (trimed_comm.EndsWith("class") || trimed_comm.EndsWith("record")))
                        comm = RemoveOverSpaces(comm);
                    else if (trimed_comm.StartsWith("]") && trimed_comm.EndsWith(":"))
                        comm = comm.Replace(" ", "");
                    
                }
                WriteCommentWithIndent(comm, true);
                read_from_beg_pos = false;
                keyword_offset = 0;
            }
            else if (prev_pos == pos)
            {
                keyword_offset = 0;
                read_from_beg_pos = false;
                if (insert_newline_after_prev)
                {
                    sb.AppendLine();
                    sb.AppendLine();
                    insert_newline_after_prev = false;
                }
                if (force_tab && sb[sb.Length - 1] == '\n')
                    sb.Append(new string(' ', off));
                force_tab = false;
            }
            skip_spaces_after = false;
            skip_spaces_before = false;
            add_space_after = false;
            add_space_before = false;
        }

        private void WritePossibleCommentAfter(syntax_tree_node sn)
        {
            int prev_pos = GetPosition(prev_sn.source_context.end_position.line_num, prev_sn.source_context.end_position.column_num) + 1;
            int pos = GetPosition(sn.source_context.end_position.line_num, sn.source_context.end_position.column_num) + 1;
            if (prev_pos < pos && cur_src_off < pos)
            {
                string comm = Text.Substring(prev_pos, pos - prev_pos);
                string trimedstr = comm.TrimStart();
                if (sn is loop_stmt || sn is case_node || sn is if_node || sn is while_node || sn is foreach_stmt || sn is for_node || sn is lock_stmt)
                {

                    if (trimedstr == "do" || trimedstr == "of" || trimedstr == "then")
                        comm = comm.TrimStart();
                    else if (trimedstr.StartsWith("of") && !char.IsLetterOrDigit(trimedstr[2]))
                        comm = comm.TrimStart();
                }
                else if (trimedstr.StartsWith(")") || trimedstr.StartsWith(";") || trimedstr.StartsWith("]") || trimedstr.StartsWith(">") || trimedstr.StartsWith(":"))
                    comm = trimedstr;
                if (trimedstr.Length >= 2 && trimedstr[0] == '(' && trimedstr[trimedstr.Length - 1] == ')' && trimedstr.Replace("(", "").Replace(")", "").Trim() == "")
                    comm = "()";
                else if (trimedstr.Length >= 2 && trimedstr[0] == '(' && trimedstr[trimedstr.Length - 1] == ';')
                    comm = trimedstr.Replace(" ", "");
                else if (trimedstr.StartsWith("[") || trimedstr.EndsWith("]"))
                    comm = trimedstr.Replace(" ", "");
                if (trimedstr.StartsWith(";  "))
                {
                    comm = "; " + trimedstr.Substring(1).TrimStart(' ', '\t');
                }
                else if (trimedstr == "." || trimedstr == "^")
                    comm = trimedstr;
                else if (trimedstr.StartsWith(",") && trimedstr.EndsWith(">"))
                    comm = ",>";
                //else if (sn is uses_closure || sn is formal_parameters || sn is type_declaration)
                //    comm = comm.TrimStart();
                if (sn is program_module || sn is unit_module)
                {
                    comm = Text.Substring(prev_pos);
                    trimedstr = comm.TrimStart();
                    if (trimedstr.StartsWith("."))
                        comm = trimedstr;
                }
                else if (sn is simple_property)
                {
                    comm = RemoveOverSpaces(comm).Replace(" ;", ";");
                }
                if (comm.StartsWith(" "))
                    add_space_before = true;
                if (comm != "()")
                    WriteCommentWithIndent(comm, false);
                else
                    sb.Append("()");
                cur_src_off = pos;
            }
            else if (sn is program_module && (sn as program_module).program_block.program_code.right_logical_bracket.source_context == null)
            {
                string comm = Text.Substring(prev_pos).Trim();
                sb.Append(comm);
            }
        }

        private void IncOffset()
        {
            off += tab;
        }

        private void IncOffset(int tab)
        {
            off += tab;
        }

        private void DecOffset()
        {
            off -= tab;
            if (off < 0)
                off = 0;
        }

        private void DecOffset(int tab)
        {
            off -= tab;
            if (off < 0)
                off = 0;
        }

        private bool NewLineNeeded(statement_list sl)
        {
            return true;
        }

        private string GetUnaryOperator(Operators op)
        {
            switch (op)
            {
                case Operators.Plus: return "+";
                case Operators.Minus: return "-";
                case Operators.LogicalNOT: return "not ";
            }
            throw new NotSupportedException();
        }

        private string GetOperator(Operators op)
        {
            switch (op)
            {
                case Operators.Plus: return " + ";
                case Operators.Minus: return " - ";
                case Operators.Multiplication: return " * ";
                case Operators.Division: return " / ";
                case Operators.IntegerDivision: return " div ";
                case Operators.In: return " in ";
                case Operators.Equal: return " = ";
                case Operators.NotEqual: return " <> ";
                case Operators.ModulusRemainder: return " mod ";
                case Operators.Less: return " < ";
                case Operators.LessEqual: return " <= ";
                case Operators.Greater: return " > ";
                case Operators.GreaterEqual: return " >= ";
                case Operators.Is: return " is ";
                case Operators.As: return " as ";
                case Operators.LogicalAND: return " and ";
                case Operators.LogicalOR: return " or ";
                case Operators.BitwiseAND: return " and ";
                case Operators.BitwiseOR: return " or ";
                case Operators.BitwiseXOR: return " xor ";
                case Operators.BitwiseLeftShift: return " shl ";
                case Operators.BitwiseRightShift: return " shr ";
                case Operators.AssignmentAddition: return " += ";
                case Operators.AssignmentMultiplication: return " *= ";
                case Operators.AssignmentSubtraction: return " -= ";
                case Operators.AssignmentDivision: return " /= ";
            }
            throw new NotSupportedException();
        }

        private string GetParamKind(parametr_kind kind)
        {
            switch (kind)
            {
                case parametr_kind.const_parametr: return "const";
                case parametr_kind.out_parametr: return "out";
                case parametr_kind.params_parametr: return "params";
                case parametr_kind.var_parametr: return "var";
            }
            return "";
        }

        private string GetAccessModifier(access_modifer acc_mod)
        {
            switch (acc_mod)
            {
                case access_modifer.internal_modifer: return "internal";
                case access_modifer.private_modifer: return "private";
                case access_modifer.protected_modifer: return "protected";
                case access_modifer.public_modifer: return "public";
                case access_modifer.published_modifer: return "published";
                
            }
            return "";
        }

        private bool has_attributes(procedure_attributes_list attrs)
        {
            if (attrs.proc_attributes.Count == 0)
                return false;
            else if (attrs.proc_attributes.Count == 1)
            {
                if (attrs.proc_attributes[0].source_context == null)
                    return false;
                else
                    return true;
            }
            else
                return true;

        }

        private string GetClassKeyword(class_keyword key)
        {
            switch (key)
            {
                case class_keyword.Class: return "class";
                case class_keyword.Interface: return "interface";
                case class_keyword.Record: return "record";
                case class_keyword.TemplateClass: return "template class";
                case class_keyword.TemplateInterface: return "template interface";
                case class_keyword.TemplateRecord: return "template record";           
            }
            throw new NotSupportedException();
        }

        private string prepare_ident(string ident)
        {
            return ident;
        }

        private bool has_members(class_body_list body)
        {
            return body.class_def_blocks.Count != 0;
        }

        private void visit_node(syntax_tree_node sn)
        {
            if (sn != null && !(sn is empty_statement))
            {
                if (!caret_syn_node_found && sn.source_context != null && GetPosition(sn.source_context.begin_position.line_num, sn.source_context.begin_position.column_num) >= caret_pos)
                {
                    caret_syn_node_found = true;
                    if (GetPosition(sn.source_context.begin_position.line_num, sn.source_context.begin_position.column_num) == caret_pos)
                    {
                        output_caret_line = sn.source_context.begin_position.line_num;
                        output_caret_col = sn.source_context.begin_position.column_num;
                    }
                    else
                    if (prev_sn != null && prev_sn.source_context != null)
                    {
                        output_caret_line = prev_sn.source_context.begin_position.line_num;
                        output_caret_col = prev_sn.source_context.begin_position.column_num;
                    }
                    else if (sn.source_context != null)
                    {
                        output_caret_line = sn.source_context.begin_position.line_num;
                        output_caret_col = sn.source_context.begin_position.column_num;
                    }
                }
                if (!(sn is block) && !(sn is declarations) && !(sn is class_body_list && has_members(sn as class_body_list)) && 
                    !(sn is class_members) && !(sn is procedure_attributes_list) && !(sn is property_accessors) &&
                    !(sn is exception_block) && !(sn is exception_handler_list))
                {
                    if (sn.source_context != null)
                        WritePossibleCommentBefore(sn);
                    if (sn.source_context != null)
                        prev_sn = sn;
                    if (sn is variable_definitions || sn is array_type || sn is sequence_type || sn is set_type_definition
                        || sn is repeat_node || sn is if_node || sn is while_node || sn is for_node
                        || sn is foreach_stmt || sn is var_statement || sn is try_stmt || sn is goto_statement
                        || sn is with_statement || sn is case_node || sn is function_header || sn is procedure_header
                        || sn is constructor || sn is destructor || sn is type_declarations || sn is consts_definitions_list
                        || sn is label_definitions || sn is class_definition || sn is uses_list || sn is uses_closure || sn is unit_name || sn is program_name ||
                        sn is new_expr || sn is raise_stmt || sn is interface_node || sn is implementation_node
                        || sn is lock_stmt || sn is loop_stmt || sn is simple_property || sn is read_accessor_name || sn is write_accessor_name
                        || sn is formal_parameters || sn is bracket_expr || sn is record_const || sn is array_const || sn is enum_type_definition || sn is exception_handler
                        || sn is try_handler_finally || sn is try_handler_except || sn is external_directive || sn is where_definition
                        || sn is var_tuple_def_statement
                        || sn is match_with
                        || (sn is simple_const_definition && in_class && !in_procedure) || (sn is typed_const_definition && in_class && !in_procedure)
                        )
                        read_from_beg_pos = true;
                }
                sn.visit(this);
                if (!(sn is block) && !(sn is declarations) && !(sn is class_body_list) && !(sn is class_members))
                {
                    if (sn.source_context != null)
                        WritePossibleCommentAfter(sn);
                    if (sn.source_context != null /*&& !(sn is exception_handler)*/)
                        prev_sn = sn;
                    
                }
            }
        }

        public override void DefaultVisit(syntax_tree_node sn)
        {
            throw new NotImplementedException();
        }

        #region IVisitor Member

        public override void visit(syntax_tree_node n)
        { }

        public override void visit(no_type_foreach _no_type_foreach)
        { }

        public override void visit(statement_list _statement_list)
        {
            bool tmp_init_part = false;
            if (_statement_list.left_logical_bracket != null)
            {
                /*if (options.AggressiveMode == 1)
                {
                    add_newline_before = true;
                }*/
                visit_node(_statement_list.left_logical_bracket);
                //add_space_before = true;
            }
            
            if (!in_one_row(_statement_list) && _statement_list.left_logical_bracket != null && _statement_list.subnodes.Count > 0 
                && _statement_list.subnodes[0].source_context != null
                && _statement_list.left_logical_bracket.source_context != null
                && _statement_list.left_logical_bracket.source_context.end_position.line_num == _statement_list.subnodes[0].source_context.begin_position.line_num 
                && !_statement_list.left_logical_bracket.text.StartsWith("##"))
                add_newline_after = true;
            else
                add_space_after = true;
            bool tmp_add_newline_after = add_newline_after;
            if (init_part)
            {
                init_part = false;
                tmp_init_part = true;
            }
            foreach (statement stmt in _statement_list.subnodes)
            {
                /*if (options.AggressiveMode == 1 && !(stmt is empty_statement))
                {
                    add_newline_before = true;
                }*/
                   
                if (stmt is assign)
                {
                    assign ass_stmt = stmt as assign;
                    if (ass_stmt.to is ident && (ass_stmt.to as ident).source_context == null)
                    {
                        visit_node(ass_stmt.from);
                        continue;
                    }
                }
                if (!(stmt is empty_statement))
                    add_space_after = true;
                visit_node(stmt);
                
            }
            if (_statement_list.subnodes.Count == 2 && _statement_list.subnodes[0] is statement_list)
                add_newline_after = tmp_add_newline_after;
            DecOffset();
            if (!tmp_init_part)
                if (_statement_list.right_logical_bracket != null)
                    if (!(_statement_list.left_logical_bracket != null && _statement_list.left_logical_bracket is token_info
                        && (_statement_list.left_logical_bracket as token_info).text.ToLower() == "finalization"))
                    {
                        dec_offset_before_comment = true;
                        add_space_after = true;
                        //if (options.AggressiveMode == 1)
                        //    add_newline_before = true;
                        visit_node(_statement_list.right_logical_bracket);
                    }
        }

        public override void visit(assign _assign)
        {
            multiline_stack_push(_assign);
            visit_node(_assign.to);
            //sb.Append(" := ");
            add_space_before = true;
            add_space_after = true;
            visit_node(_assign.from);
            multiline_stack_pop(_assign);
        }

        public override void visit(bin_expr _bin_expr)
        {
            multiline_stack_push(_bin_expr);
            visit_node(_bin_expr.left);
            add_space_before = true;
            add_space_after = true;
            visit_node(_bin_expr.right);
            multiline_stack_pop(_bin_expr);
        }

        public override void visit(un_expr _un_expr)
        {
            sb.Append(GetUnaryOperator(_un_expr.operation_type));
            visit_node(_un_expr.subnode);
        }

        public override void visit(bool_const _bool_const)
        {
            WriteNode(_bool_const);
        }

        public override void visit(int32_const _int32_const)
        {
            WriteNode(_int32_const);
        }

        public override void visit(double_const _double_const)
        {
            WriteNode(_double_const);
        }

        public override void visit(ident _ident)
        {
            WriteAmpersandIfNeed(_ident);
            sb.Append(prepare_ident(_ident.name));
        }

        public override void visit(named_type_reference _named_type_reference)
        {
            for (int i = 0; i < _named_type_reference.names.Count; i++)
            {
                visit_node(_named_type_reference.names[i]);
            }
        }

        public override void visit(variable_definitions _variable_definitions)
        {
            bool is_event = false;
            for (int i = 0; i < _variable_definitions.var_definitions.Count; i++)
            {
                if (_variable_definitions.var_definitions[i].is_event)
                    is_event = true;
            }
            if (is_event)
                sb.Append("event");
            else
                sb.Append("var");
            IncOffset();
            for (int i = 0; i < _variable_definitions.var_definitions.Count; i++)
            {
                if (i == 0)
                {
                    add_newline_before = true;
                    if (is_event)
                        keyword_offset = "event".Length;
                    else
                        keyword_offset = "var".Length;
                }
                if (options.AggressiveMode == 1)
                    add_newline_before = true;
                var_def_statement vds = _variable_definitions.var_definitions[i];
                //next_sn = (i < _variable_definitions.var_definitions.Count - 1) ? _variable_definitions.var_definitions[i + 1] : null;
                visit_node(vds);
            }
            DecOffset();
            if (!in_procedure)
                insert_newline_after_prev_semicolon = true;
        }

        public override void visit(ident_list _ident_list)
        {
            for (int i = 0; i < _ident_list.idents.Count; i++)
            {
                if (i > 0 && options.SpaceBetweenIdentifiers == 1)
                    add_space_after = true;
                visit_node(_ident_list.idents[i]);
            }
        }

        public override void visit(var_def_statement _var_def_statement)
        {
            /*if (_var_def_statement.attributes != null)
            {
                visit_node(_var_def_statement.attributes);
            }*/
            if (_var_def_statement.is_event || _var_def_statement.var_attr == definition_attribute.Static)
                read_from_beg_pos = true;
            visit_node(_var_def_statement.vars);
            if (_var_def_statement.vars_type != null)
            {
                //sb.Append(": ");
                add_space_after = true;
                visit_node(_var_def_statement.vars_type);
            }
            if (_var_def_statement.inital_value != null)
            {
                //sb.Append(" := ");
                add_space_after = true;
                add_space_before = true;
                visit_node(_var_def_statement.inital_value);
            }
        }

        public override void visit(declaration _declaration)
        {
            throw new NotImplementedException();
        }

        public override void visit(declarations _declarations)
        {
            foreach (declaration decl in _declarations.defs)
            {
                if ((decl is procedure_definition || decl is short_func_definition) && in_procedure)
                {
                    //insert_newline_after_prev_semicolon = true;
                    IncOffset();
                }
                visit_node(decl);
                if ((decl is procedure_definition || decl is short_func_definition) && in_procedure)
                    DecOffset();
            }
        }

        public override void visit(program_name _program_name)
        {
            //sb.Append("program ");
            sb.Append("program");
            SetKeywordOffset("program");
            visit_node(_program_name.prog_name);
            insert_newline_after_prev_semicolon = true;
            //sb.AppendLine(";");
        }

        public override void visit(string_const _string_const)
        {
            int pos = GetPosition(_string_const.source_context.begin_position.line_num, _string_const.source_context.begin_position.column_num);
            if (Text[pos] == '$')
                sb.Append('$');
            if (_string_const.IsMultiline)
            {
                //sb.Append("'''");
                sb.Append(_string_const.Value);
                //sb.Append("'''");
            }
            else
            {
                sb.Append("'");
                sb.Append(_string_const.Value.Replace("'", "''"));
                sb.Append("'");
            }
        }

        public override void visit(expression_list _expression_list)
        {
            for (int i = 0; i < _expression_list.expressions.Count; i++)
            {
                if (i > 0 && options.SpaceBetweenArguments == 1)
                    add_space_after = true;
                visit_node(_expression_list.expressions[i]);
            }
        }

        public override void visit(dereference _dereference)
        {
            throw new NotImplementedException();
        }

        public override void visit(roof_dereference _roof_dereference)
        {
            visit_node(_roof_dereference.dereferencing_value);
            //sb.Append('^');
        }

        public override void visit(indexer _indexer)
        {
            visit_node(_indexer.dereferencing_value);
            //sb.Append("[");
            visit_node(_indexer.indexes);
            //sb.Append("]");
        }

        public override void visit(for_node _for_node)
        {
            //WritePossibleMultilineComment();
            sb.Append("for");
            SetKeywordOffset("for");
            visit_node(_for_node.loop_variable);
            if (_for_node.type_name != null)
            {
                add_space_after = true;
                visit_node(_for_node.type_name);
            }
            add_space_after = true;
            add_space_before = true;
            visit_node(_for_node.initial_value);
            add_space_before = true;
            add_space_after = true;
            visit_node(_for_node.finish_value);
            add_space_before = true;
            //WriteKeyword(" do ");
            bool need_off = !(_for_node.statements is statement_list);
            if (!in_one_row(_for_node.statements))
                add_newline_after = true;
            if (need_off)
            IncOffset();
            visit_node(_for_node.statements);
            if (need_off)
            DecOffset();
        }

        public override void visit(repeat_node _repeat_node)
        {
            WriteKeyword("repeat");
            SetKeywordOffset("repeat");
            IncOffset();
            //add_newline_after = true;
            visit_node(_repeat_node.statements);
            sb.Append("until");
            //sb.Append(" ");
            add_space_before = true;
            multiline_stack_push(_repeat_node.expr);
            visit_node(_repeat_node.expr);
            multiline_stack_pop(_repeat_node.expr);
        }

        public override void visit(while_node _while_node)
        {
            sb.Append("while");
            SetKeywordOffset("while");
            multiline_stack_push(_while_node.expr);
            visit_node(_while_node.expr);
            multiline_stack_pop(_while_node.expr);
            if (!in_one_row(_while_node.statements))
                add_newline_after = true;
            add_space_before = true;
            //WriteKeyword(" do");
            bool need_off = !(_while_node.statements is statement_list);
            if (need_off)
                IncOffset();
            visit_node(_while_node.statements);
            if (need_off)
                DecOffset();
        }

        private void WriteKeyword(string s)
        {
            sb.Append(s);
        }

        public override void visit(if_node _if_node)
        {
            sb.Append("if"); //sb.Append(" ");
            SetKeywordOffset("if");
            visit_node(_if_node.condition);
            if (!in_one_row(_if_node.condition))
                add_newline_after = true;
            add_space_before = true;
            //WriteKeyword(" then");
            bool need_off = true;
            if (_if_node.then_body is statement_list)
                need_off = false;
            if (need_off)
                IncOffset();
            visit_node(_if_node.then_body);
            if (need_off)
                DecOffset();
            if (_if_node.else_body != null)
            {
                //WriteKeyword("else");
                need_off = true;
                add_space_before = true;
                if (_if_node.else_body is statement_list)
                    need_off = false;
                else if (!(_if_node.else_body is if_node) && !(_if_node.else_body is empty_statement))
                    add_new_line_else_specific = true;
                else
                    need_off = false;
                if (need_off)
                    IncOffset();
                visit_node(_if_node.else_body);
                if (need_off)
                    DecOffset();
            }
        }

        public override void visit(ref_type _ref_type)
        {
            sb.Append("^");
            visit_node(_ref_type.pointed_to);
        }

        public override void visit(diapason _diapason)
        {
            visit_node(_diapason.left);
            visit_node(_diapason.right);
        }

        private bool is_multi_dyn_arr(indexers_types _indexers_types)
        {
            for (int i = 0; i < _indexers_types.indexers.Count; i++)
            {
                if (_indexers_types.indexers[i] != null)
                    return false;
            }
            return true;
        }

        public override void visit(indexers_types _indexers_types)
        {
            if (is_multi_dyn_arr(_indexers_types))
            {
                WriteNode(_indexers_types);
            }
            else
            {
                //sb.Append("[");
                for (int i = 0; i < _indexers_types.indexers.Count; i++)
                {
                    if (i > 0)
                        add_space_after = true;
                    if (_indexers_types.indexers[i] != null)
                        visit_node(_indexers_types.indexers[i]);
                }
            }
        }

        public override void visit(array_type _array_type)
        {
            if (_array_type.indexers != null)
            {
                skip_spaces_after = true;
                visit_node(_array_type.indexers);
                add_space_after = false;
                add_space_before = false;
            }
            visit_node(_array_type.elements_type);
        }

        public override void visit(label_definitions _label_definitions)
        {
            sb.Append("label");
            SetKeywordOffset("label");
            visit_node(_label_definitions.labels);
        }

        public override void visit(procedure_attribute _procedure_attribute)
        {
            if (_procedure_attribute.source_context != null)
                switch (_procedure_attribute.attribute_type)
                {
                    case proc_attribute.attr_abstract: sb.Append("abstract"); return;
                    case proc_attribute.attr_forward: sb.Append("forward"); return;
                    case proc_attribute.attr_overload: sb.Append("overload"); return;
                    case proc_attribute.attr_override: sb.Append("override"); return;
                    case proc_attribute.attr_reintroduce: sb.Append("reintroduce"); return;
                    case proc_attribute.attr_virtual: sb.Append("virtual"); return;
                    case proc_attribute.attr_static: sb.Append("static"); return;
                    case proc_attribute.attr_extension: sb.Append("extensionmethod"); return;
                }
            return;
        }

        public override void visit(typed_parameters _typed_parametres)
        {
            /*if (_typed_parametres.attributes != null)
            {
                attr_on_new_line = false;
                visit_node(_typed_parametres.attributes);
                attr_on_new_line = true;
            }*/
            if (_typed_parametres.param_kind != parametr_kind.none)
            {
                string s = GetParamKind(_typed_parametres.param_kind);
                sb.Append(s);
                SetKeywordOffset(s);
                read_from_beg_pos = true;
            }
            //sb.Append(GetParamKind(_typed_parametres.param_kind));
            visit_node(_typed_parametres.idents);
            add_space_after = true;
            //sb.Append(": ");
            if (!(_typed_parametres.vars_type is lambda_inferred_type))
                visit_node(_typed_parametres.vars_type);
            if (_typed_parametres.inital_value != null)
            {
                //sb.Append(" := ");
                add_space_before = true;
                add_space_after = true;
                visit_node(_typed_parametres.inital_value);
            }
        }

        public override void visit(formal_parameters _formal_parametres)
        {
            if (!is_lambda_parameters)
            {
                sb.Append("(");
                keyword_offset = 1;
            }
            else
                is_lambda_parameters = true;
            for (int i = 0; i < _formal_parametres.params_list.Count; i++)
            {
                if (i > 0)
                    add_space_after = true;
                if (_formal_parametres.params_list[i].attributes != null)
                {
                    add_space_after = true;
                }
                    
                visit_node(_formal_parametres.params_list[i]);
            }
        }

        public override void visit(procedure_attributes_list _procedure_attributes_list)
        {
            for (int i=0; i<_procedure_attributes_list.proc_attributes.Count; i++)
            {
                if (_procedure_attributes_list.proc_attributes[i].source_context == null)
                    continue;
                add_space_after = true;
                visit_node(_procedure_attributes_list.proc_attributes[i]);
            }
        }

        public override void visit(procedure_header _procedure_header)
        {
            multiline_stack_push(_procedure_header);
            sb.Append("procedure");
            SetKeywordOffset("procedure");
            if (_procedure_header.name != null)
                visit_node(_procedure_header.name);
            else
                add_space_before = false;
            if (_procedure_header.template_args != null && !(_procedure_header.name.meth_name is operator_name_ident))
            {
                sb.Append("<");
                visit_node(_procedure_header.template_args);
                //sb.Append(">");
            }
            if (_procedure_header.parameters != null)
            {
                visit_node(_procedure_header.parameters);
            }
            
            if (_procedure_header.proc_attributes != null && has_attributes(_procedure_header.proc_attributes))
            {
                if (is_forward(_procedure_header))
                    _procedure_header.source_context = new SourceContext(_procedure_header.source_context.begin_position.line_num, _procedure_header.source_context.begin_position.column_num, _procedure_header.proc_attributes.source_context.end_position.line_num, _procedure_header.proc_attributes.source_context.end_position.column_num);
                visit_node(_procedure_header.proc_attributes);
            }
            if (_procedure_header.where_defs != null)
                visit_node(_procedure_header.where_defs);
            keyword_offset = 0;
            read_from_beg_pos = false;
            multiline_stack_pop(_procedure_header);
            //add_newline_before = true;
        }

        public override void visit(function_header _function_header)
        {
            //if (_function_header.attributes != null)
            //    visit_node(_function_header.attributes);
            multiline_stack_push(_function_header);

            sb.Append("function");
            SetKeywordOffset("function");
            if (_function_header.name != null)
                visit_node(_function_header.name);
            else
                add_space_before = false;
            if (_function_header.template_args != null && !(_function_header.name.meth_name is operator_name_ident))
            {
                sb.Append("<");
                visit_node(_function_header.template_args);
            }
            if (_function_header.parameters != null)
            {
                visit_node(_function_header.parameters);
            }
            //sb.Append(": ");
            add_space_after = true;
            visit_node(_function_header.return_type);
            
            if (_function_header.proc_attributes != null && has_attributes(_function_header.proc_attributes))
            {
                if (is_forward(_function_header))
                    _function_header.source_context = new SourceContext(_function_header.source_context.begin_position.line_num, _function_header.source_context.begin_position.column_num, _function_header.proc_attributes.source_context.end_position.line_num, _function_header.proc_attributes.source_context.end_position.column_num);
                visit_node(_function_header.proc_attributes);
            }
            if (_function_header.where_defs != null)
            {
                visit_node(_function_header.where_defs);
            }
            keyword_offset = 0;
            read_from_beg_pos = false;
            multiline_stack_pop(_function_header);
            //add_newline_before = true;
        }

        public override void visit(procedure_definition _procedure_definition)
        {
            if (_procedure_definition.proc_body is external_directive)
                multiline_stack_push(_procedure_definition);
            visit_node(_procedure_definition.proc_header);
            bool tmp_in_proc = in_procedure;
            in_procedure = true;
            if (_procedure_definition.proc_body is external_directive)
                add_space_after = true;
            if (/*options.AggressiveMode == 1 && _procedure_definition.proc_body != null ||*/ (!in_one_row(_procedure_definition) && in_same_row(_procedure_definition.proc_header, _procedure_definition.proc_body)))
            { 
                if (distance(_procedure_definition.proc_header, _procedure_definition.proc_body) > 0)
                    add_newline_after = true;
                else
                    sb.AppendLine();
            }
            if (_procedure_definition.proc_body is block && (_procedure_definition.proc_body as block).program_code.left_logical_bracket == null)
            {
                add_space_before = true;
                add_space_after = true;
            }
            visit_node(_procedure_definition.proc_body);
            in_procedure = tmp_in_proc;
            //if (in_procedure)
            //    DecOffset();
            if (_procedure_definition.proc_body is external_directive || is_forward(_procedure_definition.proc_header))
                insert_newline_after_prev_semicolon = true;
            else
                insert_newline_after_prev_semicolon = true;
            if (_procedure_definition.proc_body is external_directive)
                multiline_stack_pop(_procedure_definition);
        }

        public override void visit(type_declaration _type_declaration)
        {
            visit_node(_type_declaration.type_name);
            //sb.Append(" = ");
            add_space_after = true;
            add_space_before = true;
            visit_node(_type_declaration.type_def);
        }

        public override void visit(type_declarations _type_declarations)
        {
            sb.Append("type");
            IncOffset();
            for (int i = 0; i < _type_declarations.types_decl.Count; i++)
            {
                if (i == 0)
                {
                    add_newline_before = true;
                    keyword_offset = "type".Length;
                }
                type_declaration td = _type_declarations.types_decl[i];
                //next_sn = (i < _variable_definitions.var_definitions.Count - 1) ? _variable_definitions.var_definitions[i + 1] : null;
                visit_node(td);
            }
            DecOffset();
            if (!in_procedure)
                insert_newline_after_prev_semicolon = true;
        }

        public override void visit(simple_const_definition _simple_const_definition)
        {
            if (in_class && !in_procedure)
            {
                sb.Append("const");
                SetKeywordOffset("const");
                add_space_before = true;
            }
            visit_node(_simple_const_definition.const_name);
            //sb.Append(" = ");
            add_space_before = true;
            add_space_after = true;
            visit_node(_simple_const_definition.const_value);
            //sb.AppendLine(";");
        }

        public override void visit(typed_const_definition _typed_const_definition)
        {
            if (in_class && !in_procedure)
            {
                sb.Append("const");
                SetKeywordOffset("const");
                add_space_before = true;
            }
            visit_node(_typed_const_definition.const_name);
            //sb.Append(" : ");
            add_space_after = true;
            visit_node(_typed_const_definition.const_type);
            //sb.Append(" = ");
            add_space_before = true;
            add_space_after = true;
            visit_node(_typed_const_definition.const_value);
            //sb.AppendLine(";");
        }

        public override void visit(consts_definitions_list _consts_definitions_list)
        {
            sb.Append("const");
            IncOffset();
            for (int i = 0; i < _consts_definitions_list.const_defs.Count; i++)
            {
                if (i == 0)
                {
                    add_newline_before = true;
                    keyword_offset = "const".Length;
                }
                if (options.AggressiveMode == 1)
                    add_newline_before = true;
                const_definition cnst = _consts_definitions_list.const_defs[i];
                //next_sn = (i < _variable_definitions.var_definitions.Count - 1) ? _variable_definitions.var_definitions[i + 1] : null;
                visit_node(cnst);
            }
            DecOffset();
            if (!in_procedure)
                insert_newline_after_prev_semicolon = true;
        }

        public override void visit(unit_name _unit_name)
        {
            if (_unit_name.HeaderKeyword == UnitHeaderKeyword.Unit)
            {
                sb.Append("unit");
                SetKeywordOffset("unit");
            }
            else if (_unit_name.HeaderKeyword == UnitHeaderKeyword.Library)
            {
                sb.Append("library");
                SetKeywordOffset("library");
            }
            else if (_unit_name.HeaderKeyword == UnitHeaderKeyword.Namespace)
            {
                sb.Append("namespace");
                SetKeywordOffset("namespace");
            }
            visit_node(_unit_name.idunit_name);
            //sb.AppendLine(";");
        }

        public override void visit(unit_or_namespace _unit_or_namespace)
        {
            for (int i = 0; i < _unit_or_namespace.name.idents.Count; i++)
            {
                visit_node(_unit_or_namespace.name.idents[i]);
            }
        }

        public override void visit(uses_unit_in _uses_unit_in)
        {
            for (int i = 0; i < _uses_unit_in.name.idents.Count; i++)
            {
                visit_node(_uses_unit_in.name.idents[i]);
            }
            add_space_before = true;
            visit_node(_uses_unit_in.in_file);
        }

        public override void visit(uses_list _uses_list)
        {
            //sb.Append("uses");
            IncOffset(tab);
            //if (!in_one_row(_uses_list))
                force_tab = true;
            for (int i = 0; i < _uses_list.units.Count; i++)
            {
                if (i > 0)
                    add_space_after = true;
                if (_uses_list.units[i].source_context != null)
                    visit_node(_uses_list.units[i]);
            }
            insert_newline_after_prev = true;
            DecOffset(tab);
        }

        public override void visit(unit_module _unit_module)
        {
            has_implementation = _unit_module.implementation_part != null;
            if (_unit_module.attributes != null)
                visit_node(_unit_module.attributes);
            visit_node(_unit_module.unit_name);
            insert_newline_after_prev = true;
            if (_unit_module.interface_part != null)
                visit_node(_unit_module.interface_part);
            if (_unit_module.implementation_part != null)
                visit_node(_unit_module.implementation_part);
            init_part = true;
            if (_unit_module.initialization_part != null)
            {
                if (_unit_module.initialization_part.source_context != null)
                _unit_module.initialization_part.source_context = new SourceContext(_unit_module.initialization_part.left_logical_bracket.source_context.begin_position.line_num,
                    _unit_module.initialization_part.left_logical_bracket.source_context.begin_position.column_num,_unit_module.initialization_part.source_context.end_position.line_num,
                    _unit_module.initialization_part.source_context.end_position.column_num);
                visit_node(_unit_module.initialization_part);
            }
            init_part = true;
            if (_unit_module.finalization_part != null)
            {
                if (_unit_module.finalization_part.source_context != null)
                _unit_module.finalization_part.source_context = new SourceContext(_unit_module.finalization_part.left_logical_bracket.source_context.begin_position.line_num,
                   _unit_module.finalization_part.left_logical_bracket.source_context.begin_position.column_num, _unit_module.finalization_part.source_context.end_position.line_num,
                   _unit_module.finalization_part.source_context.end_position.column_num);
                visit_node(_unit_module.finalization_part);
            }
            //sb.Append(".");
        }

        public override void visit(program_module _program_module)
        {
            // Хак
            var s = sb.ToString();
            if (s.Equals("###") || s.Equals("##"))
                sb.Append(" ");

            if (_program_module.program_name != null)
                visit_node(_program_module.program_name);
            if (_program_module.used_units != null && _program_module.used_units.source_context != null)
            {
                /*if (_program_module.program_block != null && _program_module.program_block.program_code.left_logical_bracket.text.StartsWith("##"))
                    ;
                else*/ visit_node(_program_module.used_units);
            }
            if (_program_module.program_block != null)
                visit_node(_program_module.program_block); 
            //sb.Append(".");
        }

        public override void visit(hex_constant _hex_constant)
        {
            sb.Append("$");
            sb.Append(_hex_constant.val.ToString());
        }

        public override void visit(get_address _get_address)
        {
            sb.Append("@");
            visit_node(_get_address.address_of);
        }

        public override void visit(case_variant _case_variant)
        {
            List<case_variant> variants = (_case_variant.Parent as case_variants).variants;
            visit_node(_case_variant.conditions);
            //sb.Append(": ");
            
            if (!(_case_variant.exec_if_true is empty_statement && variants.IndexOf(_case_variant) == variants.Count - 1))
                add_space_after = true;
            
            bool one_row = in_one_row(_case_variant.exec_if_true);
            if (!one_row)
            {
                add_newline_after = true;
                IncOffset();
            }
            visit_node(_case_variant.exec_if_true);
            if (!one_row)
            {
                DecOffset();
            }
            
            //sb.AppendLine(";");
        }

        public override void visit(case_node _case_node)
        {
            sb.Append("case");
            SetKeywordOffset("case");
            visit_node(_case_node.param);
            //sb.AppendLine(" of");
            add_space_before = true;
            IncOffset();
            if (_case_node.conditions != null)
                visit_node(_case_node.conditions);
            
            DecOffset();
            if (_case_node.else_statement != null)
            {
                //IncOffset();
                add_new_line_else_specific = true;
                IncOffset();
                //if (!(_case_node.else_statement is statement_list sl && sl.list.Count == 1 && sl.list[0] is empty_statement))
                statement_list stmt_list = _case_node.else_statement as statement_list;
                
                visit_node(_case_node.else_statement);
                if (stmt_list != null && stmt_list.subnodes.Count > 0 && contains_only_empty_statements(stmt_list.subnodes))
                {
                    WriteNode(stmt_list);
                    add_space_after = false;
                }
                //DecOffset();
            }
        }

        public override void visit(method_name _method_name)
        {
            if (_method_name.ln != null)
            {
                foreach (ident id in _method_name.ln)
                    visit_node(id);
            }
            else
            {
                if (_method_name.class_name != null)
                    visit_node(_method_name.class_name);
                if (_method_name.explicit_interface_name != null)
                    visit_node(_method_name.explicit_interface_name);
                if (_method_name.meth_name != null)
                    visit_node(_method_name.meth_name);
            }
        }

        public override void visit(dot_node _dot_node)
        {
            visit_node(_dot_node.left);
            visit_node(_dot_node.right);
        }

        public override void visit(empty_statement _empty_statement)
        {
            //sb.Append("");
        }

        public override void visit(goto_statement _goto_statement)
        {
            sb.Append("goto");
            SetKeywordOffset("goto");
            visit_node(_goto_statement.label);
        }

        public override void visit(labeled_statement _labeled_statement)
        {
            visit_node(_labeled_statement.label_name);
            add_space_after = true;
            visit_node(_labeled_statement.to_statement);
        }

        public override void visit(with_statement _with_statement)
        {
            sb.Append("with");
            SetKeywordOffset("with");
            multiline_stack_push(_with_statement.do_with);
            visit_node(_with_statement.do_with);
            multiline_stack_pop(_with_statement.do_with);
            //sb.Append(" do");
            add_space_before = true;
            bool need_off = !(_with_statement.what_do is statement_list);
            if (need_off)
                IncOffset();
            if (!in_one_row(_with_statement.what_do))
                add_newline_after = true;
            visit_node(_with_statement.what_do);
            if (need_off)
                DecOffset();
        }

        public override void visit(method_call _method_call)
        {
            multiline_stack_push(_method_call);
            visit_node(_method_call.dereferencing_value);
            
            if (_method_call.parameters != null)
            {
                //sb.Append("(");
                visit_node(_method_call.parameters);
                //sb.Append(")");
            }
            multiline_stack_pop(_method_call);
        }

        public override void visit(pascal_set_constant _pascal_set_constant)
        {
            if (_pascal_set_constant.values != null)
            {
                sb.Append("[");
                visit_node(_pascal_set_constant.values);
            }
            else
                WriteNode(_pascal_set_constant, true);
            //sb.Append("]");
        }

        public override void visit(array_const _array_const)
        {
            if (_array_const.elements != null)
            {
                multiline_stack_push(_array_const);
                sb.Append("(");
                keyword_offset = 1;

                visit_node(_array_const.elements);
                multiline_stack_pop(_array_const);
            }
            else
            {
                WriteNode(_array_const);
                read_from_beg_pos = false;
            }
        }

        public override void visit(write_accessor_name _write_accessor_name)
        {
            sb.Append("write");
            SetKeywordOffset("write");
            if (_write_accessor_name.statment_for_formatting != null)
            {
                if (_write_accessor_name.statment_for_formatting is statement_list)
                    IncOffset();
                visit_node(_write_accessor_name.statment_for_formatting);
                if (_write_accessor_name.statment_for_formatting is statement_list)
                    DecOffset();
            }
                
            else if (_write_accessor_name.accessor_name != null)
                visit_node(_write_accessor_name.accessor_name);
            else
                read_from_beg_pos = false;
        }

        public override void visit(read_accessor_name _read_accessor_name)
        {
            sb.Append("read");
            SetKeywordOffset("read");
            if (_read_accessor_name.expression_for_formatting != null)
                visit_node(_read_accessor_name.expression_for_formatting);
            else if (_read_accessor_name.accessor_name != null)
                visit_node(_read_accessor_name.accessor_name);
            else
                read_from_beg_pos = false;
        }

        public override void visit(property_accessors _property_accessors)
        {
            //MikhailoMMX - теперь исходный порядок Accessor'ов учитывается
            syntax_tree_node FirstAccessor = _property_accessors.read_accessor;
            syntax_tree_node SecondAccessor = _property_accessors.write_accessor;
            if (FirstAccessor != null && SecondAccessor != null)
                if ((FirstAccessor.source_context.begin_position.line_num>SecondAccessor.source_context.begin_position.line_num)
                    || ((FirstAccessor.source_context.begin_position.line_num == SecondAccessor.source_context.begin_position.line_num)
                        && (FirstAccessor.source_context.begin_position.column_num > SecondAccessor.source_context.begin_position.column_num)))
                {
                    syntax_tree_node t = FirstAccessor;
                    FirstAccessor = SecondAccessor;
                    SecondAccessor = t;
                }
            //\MikhailoMMX
            if (FirstAccessor != null)
            {
                visit_node(FirstAccessor);
            }
            if (SecondAccessor != null)
            {
                add_space_after = true;
                visit_node(SecondAccessor);
            }
        }

        public override void visit(simple_property _simple_property)
        {
            multiline_stack_push(_simple_property);
            
            var property_keyword = "property";
            if (_simple_property.attr != definition_attribute.Static && !_simple_property.is_auto)
            {
                sb.Append(property_keyword);
                SetKeywordOffset(property_keyword);
            }

            visit_node(_simple_property.property_name);
            if (_simple_property.parameter_list != null)
            {
                visit_node(_simple_property.parameter_list);
            }
            add_space_after = true;
            visit_node(_simple_property.property_type);
            add_space_after = true;
            if (_simple_property.accessors != null)
                visit_node(_simple_property.accessors);
            if (_simple_property.initial_value != null)
            {
                add_space_before = true;
                visit_node(_simple_property.initial_value);
            }
            if (_simple_property.array_default != null)
                visit_node(_simple_property.array_default);
            add_space_before = false;
            add_space_after = false;
            multiline_stack_pop(_simple_property);
        }

        public override void visit(class_members _class_members)
        {
            if (_class_members.access_mod != null && _class_members.access_mod.source_context != null)
            {
                bool already_off = true;
                declaration first_decl = null;
                if (_class_members.members.Count > 0)
                    first_decl = _class_members.members[0];
                if (first_decl is short_func_definition)
                    first_decl = (first_decl as short_func_definition).procdef;
                if (first_decl != null && first_decl.source_context != null && _class_members.access_mod.source_context.end_position.line_num == first_decl.source_context.begin_position.line_num)
                    IncOffset();
                else
                    already_off = false;
                visit_node(_class_members.access_mod);
                if (first_decl != null && !(_class_members.members[0] is short_func_definition) && 
                    _class_members.access_mod.source_context.end_position.line_num == _class_members.source_context.begin_position.line_num)
                    sb.Append(" ");
                if (!already_off)
                    IncOffset();
            }
            else
                IncOffset();
            foreach (declaration decl in _class_members.members)
            {
                visit_node(decl);
            }
            DecOffset();
        }

        public override void visit(access_modifer_node _access_modifer_node)
        {
            sb.Append(GetAccessModifier(_access_modifer_node.access_level));
        }

        public override void visit(class_body_list _class_body)
        {
            in_class = true;
            if (_class_body.class_def_blocks.Count == 0)
                sb.Append("end");
            else
                foreach (class_members cmem in _class_body.class_def_blocks)
                    visit_node(cmem);
            in_class = false;
        }

        public override void visit(class_definition _class_definition)
        {
            bool class_pred = true;
            if (_class_definition.class_parents != null)
            {
                class_pred = false;
                visit_node(_class_definition.class_parents);
            }

            if (_class_definition.where_section != null)
            {
                class_pred = false;
                add_space_after = true;
                visit_node(_class_definition.where_section);
            }
            if (_class_definition.body != null)
            {
                if (!((_class_definition.body.class_def_blocks.Count == 0 || _class_definition.body.class_def_blocks[0].members != null && _class_definition.body.class_def_blocks[0].members.Count == 0) && _class_definition.class_parents == null && _class_definition.where_section == null))
                {
                    class_pred = false;
                    visit_node(_class_definition.body);
                }
                else
                {
                    read_from_beg_pos = false;
                    class_pred = false;
                    WriteNodeWithIndent(_class_definition);
                }
            }
            if (class_pred)
            {
                read_from_beg_pos = false;
                WriteNode(_class_definition);
            }
            insert_newline_after_prev = false;
            insert_newline_after_prev_semicolon = false;
        }

        public override void visit(set_type_definition _set_type_definition)
        {
            visit_node(_set_type_definition.of_type);
        }

        public override void visit(record_const_definition _record_const_definition)
        {
            visit_node(_record_const_definition.name);
            //sb.Append(": ");
            add_space_before = false;
            add_space_after = true;
            visit_node(_record_const_definition.val);
        }

        public override void visit(record_const _record_const)
        {
            multiline_stack_push(_record_const);
            sb.Append("(");
            keyword_offset = 1;
            for (int i = 0; i < _record_const.rec_consts.Count; i++)
            {
                if (i > 0)
                    add_space_after = true;
                visit_node(_record_const.rec_consts[i]);
            }
            multiline_stack_pop(_record_const);
        }

        public override void visit(record_type _record_type)
        {
            throw new NotImplementedException();
        }

        public override void visit(enum_type_definition _enum_type_definition)
        {
            sb.Append("(");
            keyword_offset = 1;
            multiline_stack_push(_enum_type_definition);
            visit_node(_enum_type_definition.enumerators);
            multiline_stack_pop(_enum_type_definition);
            //sb.Append(")");
        }

        public override void visit(char_const _char_const)
        {
            sb.Append("'");
            sb.Append(_char_const.cconst.ToString());
            sb.Append("'");
        }

        public override void visit(raise_statement _raise_statement)
        {
            sb.Append("raise");
            sb.Append(" ");
            visit_node(_raise_statement.excep);
        }

        public override void visit(sharp_char_const _sharp_char_const)
        {
            sb.Append("#");
            sb.Append(_sharp_char_const.char_num.ToString());
        }

        public override void visit(literal_const_line _literal_const_line)
        {
            foreach (literal l in _literal_const_line.literals)
                visit_node(l);
        }

        public override void visit(string_num_definition _string_num_definition)
        {
            visit_node(_string_num_definition.name);
            visit_node(_string_num_definition.num_of_symbols);
        }

        public override void visit(variant _variant)
        {
            throw new NotImplementedException();
        }

        public override void visit(variant_list _variant_list)
        {
            throw new NotImplementedException();
        }

        public override void visit(variant_type _variant_type)
        {
            throw new NotImplementedException();
        }

        public override void visit(variant_types _variant_types)
        {
            throw new NotImplementedException();
        }

        public override void visit(variant_record_type _variant_record_type)
        {
            throw new NotImplementedException();
        }

        public override void visit(procedure_call _procedure_call)
        {
            visit_node(_procedure_call.func_name);
        }

        public override void visit(class_predefinition _class_predefinition)
        {
            throw new NotImplementedException();
        }

        public override void visit(nil_const _nil_const)
        {
            sb.Append("nil");
        }

        public override void visit(file_type_definition _file_type_definition)
        {
            if (_file_type_definition.elem_type != null)
            {
                //sb.Append("file of ");
                visit_node(_file_type_definition.elem_type);
            }
            else
            {
                sb.Append("file");
            }
        }

        public override void visit(constructor _constructor)
        {
            if (_constructor.name == null && _constructor.template_args == null && _constructor.parameters == null && _constructor.where_defs == null && (_constructor.proc_attributes == null || !has_attributes(_constructor.proc_attributes)))
            {
                WriteNode(_constructor);
                read_from_beg_pos = false;
                keyword_offset = 0;
                return;
            }
            multiline_stack_push(_constructor);
            if (!_constructor.class_keyword)
            {
                sb.Append("constructor");
                SetKeywordOffset("constructor");
            }
            if (_constructor.name != null)
            {
                //add_space_before = true;
                visit_node(_constructor.name);
            }
            else
                add_space_before = false;
            if (_constructor.template_args != null)
            {
                sb.Append("<");
                visit_node(_constructor.template_args);
            }
            if (_constructor.parameters != null)
            {
                visit_node(_constructor.parameters);
            }
            if (_constructor.where_defs != null)
                visit_node(_constructor.where_defs);
            if (_constructor.proc_attributes != null && has_attributes(_constructor.proc_attributes))
                visit_node(_constructor.proc_attributes);
            read_from_beg_pos = false;
            keyword_offset = 0;
            multiline_stack_pop(_constructor);
        }

        public override void visit(destructor _destructor)
        {
            multiline_stack_push(_destructor);
            sb.Append("destructor");
            SetKeywordOffset("destructor");
            if (_destructor.name != null)
            {
                add_space_before = true;
                visit_node(_destructor.name);
            }
            if (_destructor.template_args != null)
            {
                sb.Append("<");
                visit_node(_destructor.template_args);
            }
            if (_destructor.parameters != null)
            {
                visit_node(_destructor.parameters);
            }
            if (_destructor.where_defs != null)
                visit_node(_destructor.where_defs);
            if (_destructor.proc_attributes != null && has_attributes(_destructor.proc_attributes))
                visit_node(_destructor.proc_attributes);
            read_from_beg_pos = false;
            keyword_offset = 0;
            multiline_stack_pop(_destructor);
        }

        public override void visit(inherited_method_call _inherited_method_call)
        {
            visit_node(_inherited_method_call.method_name);
            if (_inherited_method_call.exprs != null)
            {
                sb.Append("(");
                visit_node(_inherited_method_call.exprs);
                sb.Append(")");
            }
        }

        public override void visit(typecast_node _typecast_node)
        {
            visit_node(_typecast_node.expr);
            if (_typecast_node.cast_op == op_typecast.is_op || _typecast_node.cast_op == op_typecast.as_op)
            {
                add_space_before = true;
                add_space_after = true;
            }

            visit_node(_typecast_node.type_def);
        }

        public override void visit(interface_node _interface_node)
        {
            if (_interface_node.source_context != null && has_implementation)
            {
                sb.Append("interface");
                SetKeywordOffset("interface");
                insert_newline_after_prev_semicolon = true;
            }
            else if (_interface_node.source_context == null)
            {
                read_from_beg_pos = false;
                //return;
            }
            visit_node(_interface_node.uses_modules);
            if (_interface_node.interface_definitions != null)
                visit_node(_interface_node.interface_definitions);
        }

        public override void visit(implementation_node _implementation_node)
        {
            if (_implementation_node.source_context != null)
            {
                sb.Append("implementation");
                SetKeywordOffset("implementation");
                insert_newline_after_prev_semicolon = true;
            }
            visit_node(_implementation_node.uses_modules);
            if (_implementation_node.implementation_definitions != null)
                visit_node(_implementation_node.implementation_definitions);
        }

        public override void visit(diap_expr _diap_expr)
        {
            throw new NotImplementedException();
        }

        public override void visit(block _block)
        {
            if (_block.defs != null)
                visit_node(_block.defs);
            visit_node(_block.program_code);
        }

        public override void visit(proc_block _proc_block)
        {
            throw new NotImplementedException();
        }

        public override void visit(array_of_named_type_definition _array_of_named_type_definition)
        {
            throw new NotImplementedException();
        }

        public override void visit(array_of_const_type_definition _array_of_const_type_definition)
        {
            throw new NotImplementedException();
        }

        public override void visit(literal _literal)
        {
            throw new NotImplementedException();
        }

        public override void visit(case_variants _case_variants)
        {
            foreach (case_variant cv in _case_variants.variants)
                visit_node(cv);
        }

        public override void visit(diapason_expr _diapason_expr)
        {
            visit_node(_diapason_expr.left);
            visit_node(_diapason_expr.right);
        }

        public override void visit(var_def_list_for_record _var_def_list)
        {
            throw new NotImplementedException();
        }

        public override void visit(record_type_parts _record_type_parts)
        {
            throw new NotImplementedException();
        }

        public override void visit(property_array_default _property_array_default)
        {
            WriteNode(_property_array_default);
        }

        public override void visit(property_interface _property_interface)
        {
            throw new NotImplementedException();
        }

        public override void visit(property_parameter _property_parameter)
        {
            visit_node(_property_parameter.names);
            add_space_after = true;
            visit_node(_property_parameter.type);
        }

        public override void visit(property_parameter_list _property_parameter_list)
        {
            for (int i=0; i<_property_parameter_list.parameters.Count; i++)
            {
                if (i > 0)
                    add_space_after = true;
                visit_node(_property_parameter_list.parameters[i]);
            }
        }

        public override void visit(inherited_ident _inherited_ident)
        {
            sb.Append("inherited ");
            sb.Append(_inherited_ident.name);
        }

        public override void visit(format_expr _format_expr)
        {
            visit_node(_format_expr.expr);
            visit_node(_format_expr.format1);
            if (_format_expr.format2 != null)
            {
                visit_node(_format_expr.format2);
            }
        }

        public override void visit(initfinal_part _initfinal_part)
        {
            throw new NotImplementedException();
        }

        public override void visit(token_info _token_info)
        {
            if (string.Compare(_token_info.text, "begin", true) == 0)
            {
                WriteKeyword("begin");
                IncOffset();
            }
            else if (string.Compare(_token_info.text, "##", true) == 0)
            {
                WriteKeyword("##\n");
            }
            else if (string.Compare(_token_info.text, "###", true) == 0)
            {
                WriteKeyword("###\n");
            }
            else if (string.Compare(_token_info.text, "initialization", true) == 0)
            {
                WriteKeyword("initialization");
                IncOffset();
            }
            else if (string.Compare(_token_info.text, "finalization", true) == 0)
            {
                WriteKeyword("finalization");
                IncOffset();
            }
            else if (string.Compare(_token_info.text, "finally", true) == 0)
            {
                WriteKeyword("finally");
                IncOffset();
            }
            else if (string.Compare(_token_info.text, "end", true) == 0)
            {
                sb.Append("end");
            } 
        }

        public override void visit(raise_stmt _raise_stmt)
        {
            sb.Append("raise");
            SetKeywordOffset("raise");
            if (_raise_stmt.expr != null)
                visit_node(_raise_stmt.expr);
            else
                add_space_before = false;
        }

        public override void visit(op_type_node _op_type_node)
        {
            throw new NotImplementedException();
        }

        public override void visit(file_type _file_type)
        {
            sb.Append("file");
            if (_file_type.file_of_type != null)
            {
                sb.Append(" of ");
                visit_node(_file_type.file_of_type);
            }
            else
            {
            }
        }

        public override void visit(known_type_ident _known_type_ident)
        {
            throw new NotImplementedException();
        }

        public override void visit(exception_handler ex)
        {
            sb.Append("on");
            SetKeywordOffset("on");
            if (ex.variable != null)
            {
                visit_node(ex.variable);
                add_space_after = true;
            }
            visit_node(ex.type_name);
            add_space_before = true;
            if (!(ex.statements is statement_list))
                IncOffset();
            visit_node(ex.statements);
            if (!(ex.statements is statement_list))
                DecOffset();
        }

        public override void visit(exception_ident _exception_ident)
        {
            throw new NotImplementedException();
        }

        public override void visit(exception_handler_list _exception_handler_list)
        {
            foreach (exception_handler ex in _exception_handler_list.handlers)
            {
                visit_node(ex);
            }
        }

        public override void visit(exception_block _exception_block)
        {
            if (_exception_block.handlers != null)
            {
                IncOffset();
                visit_node(_exception_block.handlers);
                DecOffset();
            }
            if (_exception_block.stmt_list != null)
            {
                IncOffset();
                visit_node(_exception_block.stmt_list);
            }
            if (_exception_block.else_stmt_list != null)
            {
                add_space_before = true;
                if (!(_exception_block.else_stmt_list.Count == 1 && _exception_block.else_stmt_list.list[0] is empty_statement))
                {
                    add_new_line_else_specific = true;
                    IncOffset();
                    visit_node(_exception_block.else_stmt_list);
                }
                else
                {
                    add_newline_after = false;
                }
                    
                //DecOffset();
            }
        }

        public override void visit(try_handler _try_handler)
        {
            throw new NotImplementedException();
        }

        public override void visit(try_handler_finally _try_handler_finally)
        {
            _try_handler_finally.stmt_list.source_context = new SourceContext(_try_handler_finally.source_context.LeftSourceContext, _try_handler_finally.source_context.RightSourceContext);
            visit_node(_try_handler_finally.stmt_list);
        }

        public override void visit(try_handler_except _try_handler_except)
        {
            sb.Append("except");
            SetKeywordOffset("except");
            add_newline_after = true;
            visit_node(_try_handler_except.except_block);
            add_newline_after = false;
        }

        public override void visit(try_stmt _try_stmt)
        {
            WriteKeyword("try");
            SetKeywordOffset("try");
            add_newline_after = true;
            
            if (!contains_only_empty_statements(_try_stmt.stmt_list.subnodes))
            {
                IncOffset();
                visit_node(_try_stmt.stmt_list);
            }
                
            if (_try_stmt.handler is try_handler_except)
            {
                try_handler_except hndlr = _try_stmt.handler as try_handler_except;
                visit_node(_try_stmt.handler);
                if (hndlr.except_block.stmt_list != null && hndlr.except_block.stmt_list.subnodes.Count > 0 && contains_only_empty_statements(hndlr.except_block.stmt_list.subnodes))
                {
                    add_space_before = true;
                    WriteNode(_try_stmt.handler, "except".Length);
                    read_from_beg_pos = false;
                    add_space_before = false;
                    add_space_after = false;
                }

            }
            else if (_try_stmt.handler is try_handler_finally)
            {
                try_handler_finally hndlr = _try_stmt.handler as try_handler_finally;
                visit_node(_try_stmt.handler);
            }
            read_from_beg_pos = false;
        }

        private bool contains_only_empty_statements(List<statement> statements)
        {
            foreach (statement stmt in statements)
                if (!(stmt is empty_statement))
                    return false;
            return true;
        }

        public override void visit(inherited_message _inherited_message)
        {
            sb.Append("inherited");
        }

        public override void visit(external_directive _external_directive)
        {
            sb.Append("external");
            SetKeywordOffset("external");
            if (_external_directive.modulename != null)
            {
                visit_node(_external_directive.modulename);
            }
            if (_external_directive.name != null)
            {
                add_space_before = true;
                add_space_after = true;
                visit_node(_external_directive.name);
            }
            add_space_before = false;
            add_space_after = false;
            read_from_beg_pos = false;
        }

        public override void visit(using_list _using_list)
        {
            throw new NotImplementedException();
        }

        public override void visit(jump_stmt _jump_stmt)
        {
            throw new NotImplementedException();
        }

        public override void visit(loop_stmt loop)
        {
            sb.Append("loop");
            SetKeywordOffset("loop");

            multiline_stack_push(loop.count);
            visit_node(loop.count);
            multiline_stack_pop(loop.count);
            if (!in_one_row(loop.stmt))
                add_newline_after = true;
            add_space_before = true;
            //WriteKeyword(" do");
            bool need_off = !(loop.stmt is statement_list);
            if (need_off)
                IncOffset();
            visit_node(loop.stmt);
            if (need_off)
                DecOffset();
        }

        public override void visit(foreach_stmt _foreach_stmt)
        {
            WriteKeyword("foreach");
            SetKeywordOffset("foreach");
            visit_node(_foreach_stmt.identifier);
            if (_foreach_stmt.type_name != null)
            {
                add_space_after = true;
                visit_node(_foreach_stmt.type_name);
            }
            add_space_after = true;
            add_space_before = true;
            visit_node(_foreach_stmt.in_what);
            if (!in_one_row(_foreach_stmt.stmt))
                add_newline_after = true;
            add_space_before = true;
            bool need_off = !(_foreach_stmt.stmt is statement_list);
            if (need_off)
                IncOffset();
            visit_node(_foreach_stmt.stmt);
            if (need_off)
            DecOffset();
        }

        public override void visit(addressed_value_funcname _addressed_value_funcname)
        {
            throw new NotImplementedException();
        }

        public override void visit(named_type_reference_list _named_type_reference_list)
        {
            for (int i = 0; i < _named_type_reference_list.types.Count; i++)
            {
                if (i > 0)
                    add_space_after = true;
                visit_node(_named_type_reference_list.types[i]);
            }
        }

        public override void visit(template_param_list _template_param_list)
        {
            sb.Append("<");
            for (int i = 0; i < _template_param_list.params_list.Count; i++)
            {
                if (i > 0 && !(_template_param_list.params_list[i] is named_type_reference && (_template_param_list.params_list[i] as named_type_reference).names.Count > 0 
                    && (_template_param_list.params_list[i] as named_type_reference).names[0].name == ""))
                    add_space_after = true;
                visit_node(_template_param_list.params_list[i]);
            }
        }

        public override void visit(template_type_reference _template_type_reference)
        {
            visit_node(_template_type_reference.name);
            visit_node(_template_type_reference.params_list);
        }

        public override void visit(int64_const _int64_const)
        {
            WriteNode(_int64_const);
        }

        public override void visit(uint64_const _uint64_const)
        {
            WriteNode(_uint64_const);
        }

        public override void visit(new_expr _new_expr)
        {
            sb.Append("new");
            SetKeywordOffset("new");
            visit_node(_new_expr.type);
            if (_new_expr.params_list != null && _new_expr.params_list.expressions[0].source_context != null)
            {
                skip_spaces_after = true;
                visit_node(_new_expr.params_list);
            }
            if (_new_expr.array_init_expr != null)
                visit_node(_new_expr.array_init_expr);
        }

        public override void visit(where_type_specificator_list _type_definition_list)
        {
            for (int i = 0; i < _type_definition_list.defs.Count; i++)
            {
                if (i > 0)
                    add_space_after = true;
                visit_node(_type_definition_list.defs[i]);
            }
        }

        public override void visit(where_definition _where_definition)
        {
            sb.Append("where");
            SetKeywordOffset("where");
            visit_node(_where_definition.names);
            add_space_after = true;
            visit_node(_where_definition.types);
        }

        public override void visit(where_definition_list _where_definition_list)
        {
            foreach (where_definition wd in _where_definition_list.defs)
            {
                visit_node(wd);
            }
        }

        public override void visit(sizeof_operator _sizeof_operator)
        {
            sb.Append("sizeof");
            SetKeywordOffset("sizeof");
            add_space_before = false;
            read_from_beg_pos = true;
            if (_sizeof_operator.expr != null)
                visit_node(_sizeof_operator.expr);
            else if (_sizeof_operator.type_def != null)
                visit_node(_sizeof_operator.type_def);
        }

        public override void visit(typeof_operator _typeof_operator)
        {
            sb.Append("typeof");
            SetKeywordOffset("typeof");
            add_space_before = false;
            read_from_beg_pos = true;
            visit_node(_typeof_operator.type_name);
        }

        public override void visit(compiler_directive _compiler_directive)
        {
            throw new NotImplementedException();
        }

        public override void visit(operator_name_ident _operator_name_ident)
        {
            WriteNodeAndReplaceOverSpaces(_operator_name_ident);
        }

        public override void visit(var_statement _var_statement)
        {
            sb.Append("var");
            SetKeywordOffset("var");
            visit_node(_var_statement.var_def);
        }

        public override void visit(question_colon_expression _question_colon_expression)
        {
            visit_node(_question_colon_expression.condition);
            add_space_before = true;
            add_space_after = true;
            visit_node(_question_colon_expression.ret_if_true);
            add_space_before = true;
            add_space_after = true;
            visit_node(_question_colon_expression.ret_if_false);
        }

        public override void visit(expression_as_statement _expression_as_statement)
        {
            visit_node(_expression_as_statement.expr);
        }

        public override void visit(c_scalar_type _c_scalar_type)
        {
            throw new NotImplementedException();
        }

        public override void visit(c_module _c_module)
        {
            throw new NotImplementedException();
        }

        public override void visit(declarations_as_statement _declarations_as_statement)
        {
            throw new NotImplementedException();
        }

        public override void visit(array_size _array_size)
        {
            throw new NotImplementedException();
        }

        public override void visit(enumerator _enumerator)
        {
            visit_node(_enumerator.name);
            if (_enumerator.value != null)
            {
                add_space_before = true;
                add_space_after = true;
                visit_node(_enumerator.value);
            }
        }

        public override void visit(enumerator_list _enumerator_list)
        {
            for (int i = 0; i < _enumerator_list.enumerators.Count; i++)
            {
                if (i > 0)
                    add_space_after = true;
                visit_node(_enumerator_list.enumerators[i]);
            }
        }

        public override void visit(c_for_cycle _c_for_cycle)
        {
            throw new NotImplementedException();
        }

        public override void visit(switch_stmt _switch_stmt)
        {
            throw new NotImplementedException();
        }

        public override void visit(type_definition_attr_list _type_definition_attr_list)
        {
            throw new NotImplementedException();
        }

        public override void visit(type_definition_attr _type_definition_attr)
        {
            throw new NotImplementedException();
        }

        public override void visit(lock_stmt _lock_stmt)
        {
            sb.Append("lock");
            SetKeywordOffset("lock");
            multiline_stack_push(_lock_stmt.lock_object);
            visit_node(_lock_stmt.lock_object);
            multiline_stack_pop(_lock_stmt.lock_object);
            add_space_before = true;
            bool need_off = !(_lock_stmt.stmt is statement_list);
            if (!in_one_row(_lock_stmt.stmt))
                add_newline_after = true;
            if (need_off)
                IncOffset();
            visit_node(_lock_stmt.stmt);
            if (need_off)
                DecOffset();
        }

        public override void visit(compiler_directive_list _compiler_directive_list)
        {
            throw new NotImplementedException();
        }

        public override void visit(compiler_directive_if _compiler_directive_if)
        {
            throw new NotImplementedException();
        }

        public override void visit(documentation_comment_list _documentation_comment_list)
        {
            throw new NotImplementedException();
        }

        public override void visit(documentation_comment_tag _documentation_comment_tag)
        {
            throw new NotImplementedException();
        }

        public override void visit(documentation_comment_tag_param _documentation_comment_tag_param)
        {
            throw new NotImplementedException();
        }

        public override void visit(documentation_comment_section _documentation_comment_section)
        {
            throw new NotImplementedException();
        }

        public override void visit(token_taginfo _token_taginfo)
        {
            throw new NotImplementedException();
        }

        public override void visit(declaration_specificator _declaration_specificator)
        {
            sb.Append(_declaration_specificator.name);
        }

        public override void visit(ident_with_templateparams _ident_with_templateparams)
        {
            visit_node(_ident_with_templateparams.name);
            visit_node(_ident_with_templateparams.template_params);
        }

        public override void visit(template_type_name _template_type_name)
        {
            sb.Append(prepare_ident(_template_type_name.name));
            sb.Append("<");
            visit_node(_template_type_name.template_args);
        }

        public override void visit(default_operator _default_operator)
        {
            sb.Append("default");
            SetKeywordOffset("default");
            add_space_before = false;
            read_from_beg_pos = true;
            //sb.Append("(");
            visit_node(_default_operator.type_name);
        }

        public override void visit(bracket_expr _bracket_expr)
        {
            sb.Append("(");
            keyword_offset = 1;
            visit_node(_bracket_expr.expr);
        }

        public override void visit(attribute _attribute)
        {
            if (_attribute.qualifier != null)
                visit_node(_attribute.qualifier);
            visit_node(_attribute.type);
            if (_attribute.arguments != null)
            {
                //sb.Append("(");
                visit_node(_attribute.arguments);
                //sb.Append(")");
            }
        }

        public override void visit(simple_attribute_list _simple_attribute_list)
        {
            sb.Append("[");
            for (int i = 0; i < _simple_attribute_list.attributes.Count; i++)
            {
                visit_node(_simple_attribute_list.attributes[i]);
                if (i < _simple_attribute_list.attributes.Count - 1)
                    sb.Append(",");
            }
        }

        public override void visit(attribute_list _attribute_list)
        {
            foreach (simple_attribute_list sal in _attribute_list.attributes)
                visit_node(sal);
        }

        public override void visit(function_lambda_definition _function_lambda_definition)
        {
            multiline_stack_push(_function_lambda_definition);
            read_from_beg_pos = true;
            if (_function_lambda_definition.formal_parameters != null)
                WritePossibleCommentBefore(_function_lambda_definition.formal_parameters);
            add_space_before = false;
            if (_function_lambda_definition.formal_parameters != null)
            {
                
                is_lambda_parameters = true;
                visit_node(_function_lambda_definition.formal_parameters);
                keyword_offset = 0;
                read_from_beg_pos = false;
            }
            if (_function_lambda_definition.formal_parameters != null && Text[GetPosition(_function_lambda_definition.formal_parameters.source_context.end_position.line_num, _function_lambda_definition.formal_parameters.source_context.end_position.column_num)+1] != ')')
                add_space_before = true;
            
            int tmp_off = off;
            visit_node(_function_lambda_definition.proc_body);
            multiline_stack_pop(_function_lambda_definition);
            off = tmp_off;
        }
        public override void visit(function_lambda_call _function_lambda_call)
        {
            //
        }
        public override void visit(semantic_check _semantic_check)
        {
        }
		
		public override void visit(lambda_inferred_type lit) //lroman//
        {
        }
        public override void visit(same_type_node stn) //SS 22/06/13//
        {
        }
        public override void visit(name_assign_expr _name_assign_expr) // SSM 27.06.13
        {
            multiline_stack_push(_name_assign_expr);
            if (_name_assign_expr.name.source_context.Eq(_name_assign_expr.expr.source_context))
            {
                visit_node(_name_assign_expr.expr);
            }
            else
            {
                visit_node(_name_assign_expr.name);
                //sb.Append(" := ");
                add_space_before = true;
                add_space_after = true;
                visit_node(_name_assign_expr.expr);
            }
            multiline_stack_pop(_name_assign_expr);
        }
        public override void visit(name_assign_expr_list _name_assign_expr_list) // SSM 27.06.13
        {
            if (_name_assign_expr_list.name_expr != null)
            for (int i = 0; i < _name_assign_expr_list.name_expr.Count; i++)
            {
                if (i > 0 && options.SpaceBetweenIdentifiers == 1)
                    add_space_after = true;
                visit_node(_name_assign_expr_list.name_expr[i]);
            }
        }
        public override void visit(unnamed_type_object _unnamed_type_object) // SSM 27.06.13
        {
            //sb.Append("new");
            //SetKeywordOffset("new");
            read_from_beg_pos = true;
            visit_node(_unnamed_type_object.ne_list);
        }
        public override void visit(semantic_type_node stn) // SSM 
        {
        }
        public override void visit(matching_expression _matching_expression)
        {
            visit_node(_matching_expression.left);
            visit_node(_matching_expression.right);
        }
        public override void visit(short_func_definition _short_func_definition)
        {
            multiline_stack_push(_short_func_definition);
            
            add_space_after = true;
            if (_short_func_definition.Parent is class_members && (_short_func_definition.Parent as class_members).access_mod != null && (_short_func_definition.Parent as class_members).access_mod.source_context != null)
                add_space_before = true;
            add_newline_after = false;
            int cur_off = tab;
            visit_node(_short_func_definition.procdef.proc_header);
            bool tmp_in_procedure = in_procedure;
            in_procedure = true;
            //sb.Append(":=");
            add_space_before = true;
            add_space_after = true;
            
            visit_node(_short_func_definition.procdef.proc_body);
            //if (!(_short_func_definition.procdef.proc_header is constructor))
               IncOffset();
            in_procedure = tmp_in_procedure;
            multiline_stack_pop(_short_func_definition);
        }

        public override void visit(sequence_type _sequence_type)
        {
            visit_node(_sequence_type.elements_type);
        }

        public override void visit(modern_proc_type _modern_proc_type)
        {
            if (_modern_proc_type.aloneparam != null)
            {
                visit_node(_modern_proc_type.aloneparam);
                add_space_before = false;
                add_space_after = false;
                visit_node(_modern_proc_type.res);
            }
            else
            {
                if (_modern_proc_type.el == null && _modern_proc_type.res == null)
                {
                    int beg_pos = GetPosition(_modern_proc_type.source_context.begin_position.line_num, _modern_proc_type.source_context.begin_position.column_num);
                    int end_pos = GetPosition(_modern_proc_type.source_context.end_position.line_num, _modern_proc_type.source_context.end_position.column_num);
                    sb.Append(Text.Substring(beg_pos, end_pos - beg_pos + 1));
                }
                else
                {
                    if (_modern_proc_type.el != null && _modern_proc_type.el.enumerators != null)
                    {
                        sb.Append("(");
                        for (int i = 0; i < _modern_proc_type.el.enumerators.Count; i++)
                        {
                            visit_node(_modern_proc_type.el.enumerators[i]);
                        }
                    }
                    else
                        read_from_beg_pos = true;
                    add_space_before = false;
                    add_space_after = false;
                    visit_node(_modern_proc_type.res);
                }
            }
        }

        public override void visit(tuple_node _tuple_node)
        {
            sb.Append("(");
            visit_node(_tuple_node.el);
        }

        public override void visit(uses_closure uc)
        {
            foreach (var ul in uc.listunitsections)
            {
                visit_node(ul);
            }
        }

        public override void visit(assign_tuple at)
        {
            //multiline_stack_push(at);
            visit_node(at.vars);
            add_space_after = true;
            visit_node(at.expr);
            //multiline_stack_pop(at);
        }

        public override void visit(addressed_value_list al)
        {
            sb.Append("(");
            var i = 0;
            foreach (var av in al.variables)
            {
                visit_node(av);
                add_space_after = true;
                i++;
            }
        }

        public override void visit(yield_node yn)
        {
            sb.Append("yield ");
            visit_node(yn.ex);
        }

        public override void visit(yield_sequence_node yn)
        {
            sb.Append("yield sequence ");
            visit_node(yn.ex);
        }

        public override void visit(assign_var_tuple _assign_var_tuple)
        {
            read_from_beg_pos = true;
            for (int i = 0; i < _assign_var_tuple.idents.idents.Count; i++)
            {
                if (options.SpaceBetweenArguments == 1 && i > 0)
                {
                    add_space_after = true;
                }  
                visit_node(_assign_var_tuple.idents.idents[i]);
            }
            sb.Append(")");
            add_space_after = true;
            add_space_before = true;
            prev_sn = _assign_var_tuple.idents;
            visit_node(_assign_var_tuple.expr);
        }

        public override void visit(slice_expr _slice_expr)
        {
            visit_node(_slice_expr.v);
            if (_slice_expr.from != null)
                visit_node(_slice_expr.from);
            if (_slice_expr.to != null)
                visit_node(_slice_expr.to);
            if (_slice_expr.step != null)
                visit_node(_slice_expr.step);          
        }

        public override void visit(slice_expr_question _slice_expr_question)
        {
            visit_node(_slice_expr_question.v);
            if (_slice_expr_question.from != null)
                visit_node(_slice_expr_question.from);
            if (_slice_expr_question.to != null)
                visit_node(_slice_expr_question.to);
            if (_slice_expr_question.step != null)
                visit_node(_slice_expr_question.step);
        }

        public override void visit(index _index)
        {
            if (_index.inverted)
                sb.Append("^");
            visit_node(_index.index_expr);
        }

        public override void visit(is_pattern_expr _is_pattern_expr)
        {
            if (_is_pattern_expr.left != null)
                visit_node(_is_pattern_expr.left);

            if (_is_pattern_expr.right == null || 
                !(_is_pattern_expr.right is collection_pattern) && !(_is_pattern_expr.right is tuple_pattern))
                sb.Append(" is ");
            else
                add_space_before = true;

            if (_is_pattern_expr.right != null)
                visit_node(_is_pattern_expr.right);
        }

        public override void visit(type_pattern _type_pattern)
        {
            if (_type_pattern.type != null)
                visit_node(_type_pattern.type);
        }

        public override void visit(match_with _match_with)
        {
            sb.Append("match");
            SetKeywordOffset("match");
            visit_node(_match_with.expr);
            IncOffset();
            add_space_before = true;
            visit_node(_match_with.case_list);
            DecOffset();
        }

        public override void visit(pattern_cases _pattern_cases)
        {
            foreach (var patternCase in _pattern_cases.elements)
                visit_node(patternCase);
        }

        public override void visit(pattern_case _pattern_case)
        {
            visit_node(_pattern_case.pattern);

            if (_pattern_case.condition != null)
            {
                add_space_before = true;
                visit_node(_pattern_case.condition);
            }

            add_space_after = true;
            IncOffset();
            visit_node(_pattern_case.case_action);
            DecOffset();
        }

        public override void visit(const_pattern _const_pattern)
        {
            visit_node(_const_pattern.pattern_expressions);
            add_space_after = false;
        }

        public override void visit(const_pattern_parameter _const_parameter)
        {
            visit_node(_const_parameter.const_param);
            add_space_after = false;
        }

        public override void visit(wild_card_deconstructor_parameter _wild_card_deconstructor_parameter)
        {
            sb.Append("_");
            add_space_after = true;
        }

        public override void visit(tuple_pattern_var_parameter _tuple_pattern_var_parameter)
        {
            sb.Append("var");
            SetKeywordOffset("var");
            read_from_beg_pos = true;
            visit_node(_tuple_pattern_var_parameter.identifier);
        }

        public override void visit(tuple_pattern_wild_card _tuple_pattern_wild_card)
        {
            sb.Append("_");
            add_space_after = true;
        }

        public override void visit(tuple_pattern _tuple_pattern)
        {
            sb.Append("(");
            foreach (var parameter in _tuple_pattern.parameters)
            {
                visit_node(parameter);
                add_space_after = true;
            }
            add_space_after = false;
        }

        public override void visit(collection_pattern _collection_pattern)
        {
            sb.Append("[");
            foreach (var parameter in _collection_pattern.parameters)
            {
                visit_node(parameter);
                add_space_after = true;
            }
            add_space_after = false;
        }

        public override void visit(collection_pattern_gap_parameter _collection_pattern_gap_parameter)
        {
            sb.Append("..");
            add_space_after = true;
        }

        public override void visit(collection_pattern_var_parameter _collection_pattern_var_parameter)
        {
            sb.Append("var");
            SetKeywordOffset("var");
            read_from_beg_pos = true;
            visit_node(_collection_pattern_var_parameter.identifier);
        }

        public override void visit(collection_pattern_wild_card _collection_pattern_wild_card)
        {
            sb.Append("_");
            add_space_after = true;
        }

        public override void visit(deconstructor_pattern _deconstructor_pattern)
        {
            visit_node(_deconstructor_pattern.type);
            foreach (var parameter in _deconstructor_pattern.parameters)
            {
                visit_node(parameter);
                add_space_after = true;
            }
            add_space_after = false; 
        }

        public override void visit(var_deconstructor_parameter _var_deconstructor_parameter)
        {
            if (_var_deconstructor_parameter.var_keyword_used)
            {
                sb.Append("var");
                SetKeywordOffset("var");
                read_from_beg_pos = true;
            }
            visit_node(_var_deconstructor_parameter.identifier);
            if (_var_deconstructor_parameter.type != null)
                visit_node(_var_deconstructor_parameter.type);
        }

        public override void visit(recursive_pattern_parameter _recursive_pattern_parameter)
        {
            visit_node(_recursive_pattern_parameter.pattern);
        }

        public override void visit(recursive_deconstructor_parameter _recursive_deconstructor_parameter)
        {
            visit_node(_recursive_deconstructor_parameter.pattern);
        }
        public override void visit(recursive_tuple_parameter _recursive_tuple_parameter)
        {
            visit_node(_recursive_tuple_parameter.pattern);
        }
        public override void visit(recursive_collection_parameter _recursive_collection_parameter)
        {
            visit_node(_recursive_collection_parameter.pattern);
        }

        public override void visit(var_tuple_def_statement _var_tuple_def_statement)
        {
            sb.Append("(");
            SetKeywordOffset("(");
            read_from_beg_pos = true;
            visit_node(_var_tuple_def_statement.vars);
            if (_var_tuple_def_statement.vars_type != null)
            {
                add_space_after = true;
                visit_node(_var_tuple_def_statement.vars_type);
            }
            if (_var_tuple_def_statement.inital_value != null)
            {
                add_space_after = true;
                add_space_before = true;
                visit_node(_var_tuple_def_statement.inital_value);
            }
        }

        public override void visit(dot_question_node _dot_question_node)
        {
            visit_node(_dot_question_node.left);
            visit_node(_dot_question_node.right);
        }
        public override void visit(diapason_expr_new diap)
        {
            visit_node(diap.left);
            visit_node(diap.right);
        }

        public override void visit(if_expr_new _if_expr_new)
        {
            sb.Append("if"); //sb.Append(" ");
            SetKeywordOffset("if");
            read_from_beg_pos = true;
            visit_node(_if_expr_new.condition);
            if (!in_one_row(_if_expr_new.condition))
                add_newline_after = true;
            add_space_before = true;
            visit_node(_if_expr_new.if_true);
            if (_if_expr_new.if_false != null)
            {
                add_space_before = true;
                visit_node(_if_expr_new.if_false);
            }
        }

        public override void visit(array_const_new acn)
        {
            sb.Append(acn.braces_type);
            visit_node(acn.elements);
            //sb.Append("|");
        }

        public override void visit(double_question_node dn)
        {
            visit_node(dn.left);
            visit_node(dn.right);
        }
        public override void visit(bigint_const bi)
        {
            visit(new uint64_const(bi.val, bi.source_context));
            //sb.Append("bi");
        }

        public override void visit(property_ident _property_ident)
        {
            if (_property_ident.ln != null)
            {
                foreach (ident id in _property_ident.ln)
                    visit_node(id);
                return;
            }
            WriteAmpersandIfNeed(_property_ident);
            sb.Append(prepare_ident(_property_ident.name));
        }

        public override void visit(foreach_stmt_formatting fe)
        {
            WriteKeyword("foreach");
            SetKeywordOffset("foreach");
            sb.Append(" var (");
            visit_node(fe.il);
            add_space_after = true;
            add_space_before = true;
            visit_node(fe.in_what);
            if (!in_one_row(fe.stmt))
                add_newline_after = true;
            add_space_before = true;
            bool need_off = !(fe.stmt is statement_list);
            if (need_off)
                IncOffset();
            visit_node(fe.stmt);
            if (need_off)
                DecOffset();
        }
        public override void visit(let_var_expr lvex)
        {
            sb.Append("(var ");

            visit_node(lvex.id);
            add_space_after = true;
            add_space_before = true;
            visit_node(lvex.ex);
        }
        public override void visit(to_expr to_ex)
        {
            visit_node(to_ex.key);
            sb.Append(" ");
            visit_node(to_ex.value);
        }
        #endregion
    }


}