source: trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.NRefactory/5.5.0/NRefactory.CSharp-5.5.0/IndentEngine/CSharpIndentEngine.cs @ 12252

//
// CSharpIndentEngine.cs
//
// Author:
//       Matej Miklečić <matej.miklecic@gmail.com>
//
// Copyright (c) 2013 Matej Miklečić (matej.miklecic@gmail.com)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
using ICSharpCode.NRefactory.Editor;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ICSharpCode.NRefactory.CSharp
{
  /// <summary>
  ///     Indentation engine based on a state machine.
  ///     Supports only pushing new chars to the end.
  /// </summary>
  /// <remarks>
  ///     Represents the context for transitions between <see cref="IndentState"/>.
  ///     Delegates the responsibility for pushing a new char to the current 
  ///     state and changes between states depending on the pushed chars.
  /// </remarks>
  public class CSharpIndentEngine : IStateMachineIndentEngine
  {
    #region Properties

    /// <summary>
    ///     Formatting options.
    /// </summary>
    internal readonly CSharpFormattingOptions formattingOptions;

    /// <summary>
    ///     Text editor options.
    /// </summary>
    internal readonly TextEditorOptions textEditorOptions;

    /// <summary>
    ///     A readonly reference to the document that's parsed
    ///     by the engine.
    /// </summary>
    internal readonly IDocument document;

    /// <summary>
    ///     Represents the new line character.
    /// </summary>
    internal readonly char newLineChar;

    /// <summary>
    ///     The current indentation state.
    /// </summary>
    internal IndentState currentState;

    /// <summary>
    ///     Stores conditional symbols of #define directives.
    /// </summary>
    internal HashSet<string> conditionalSymbols;

    /// <summary>
    ///     Stores custom conditional symbols.
    /// </summary>
    internal HashSet<string> customConditionalSymbols;

    /// <summary>
    ///     Stores the results of evaluations of the preprocessor if/elif directives 
    ///     in the current block (between #if and #endif).
    /// </summary>
    internal CloneableStack<bool> ifDirectiveEvalResults = new CloneableStack<bool> ();

    /// <summary>
    ///     Stores the indentation levels of the if directives in the current block.
    /// </summary>
    internal CloneableStack<Indent> ifDirectiveIndents = new CloneableStack<Indent>();

    /// <summary>
    ///     Stores the last sequence of characters that can form a
    ///     valid keyword or variable name.
    /// </summary>
    internal StringBuilder wordToken;

    /// <summary>
    ///     Stores the previous sequence of chars that formed a
    ///     valid keyword or variable name.
    /// </summary>
    internal string previousKeyword;

    #endregion

    #region IDocumentIndentEngine

    /// <inheritdoc />
    public IDocument Document
    {
      get { return document; }
    }

    /// <inheritdoc />
    public string ThisLineIndent
    {
      get
      {
        // OPTION: IndentBlankLines
        // remove the indentation of this line if isLineStart is true
//        if (!textEditorOptions.IndentBlankLines && isLineStart)
//        {
//          return string.Empty;
//        }

        return currentState.ThisLineIndent.IndentString;
      }
    }

    /// <inheritdoc />
    public string NextLineIndent
    {
      get
      {
        return currentState.NextLineIndent.IndentString;
      }
    }

    /// <inheritdoc />
    public string CurrentIndent
    {
      get
      {
        return currentIndent.ToString();
      }
    }

    /// <inheritdoc />
    /// <remarks>
    ///     This is set depending on the current <see cref="Location"/> and
    ///     can change its value until the <see cref="newLineChar"/> char is
    ///     pushed. If this is true, that doesn't necessarily mean that the
    ///     current line has an incorrect indent (this can be determined
    ///     only at the end of the current line).
    /// </remarks>
    public bool NeedsReindent
    {
      get
      {
        // return true if it's the first column of the line and it has an indent
        if (Location.Column == 1)
        {
          return ThisLineIndent.Length > 0;
        }

        // ignore incorrect indentations when there's only ws on this line
        if (isLineStart)
        {
          return false;
        }

        return ThisLineIndent != CurrentIndent.ToString();
      }
    }

    /// <inheritdoc />
    public int Offset
    {
      get
      {
        return offset;
      }
    }

    /// <inheritdoc />
    public TextLocation Location
    {
      get
      {
        return new TextLocation(line, column);
      }
    }

    /// <inheritdoc />
    public bool EnableCustomIndentLevels
    {
      get;
      set;
    }

    #endregion

    #region Fields

    /// <summary>
    ///    Represents the number of pushed chars.
    /// </summary>
    internal int offset = 0;

    /// <summary>
    ///    The current line number.
    /// </summary>
    internal int line = 1;

    /// <summary>
    ///    The current column number.
    /// </summary>
    /// <remarks>
    ///    One char can take up multiple columns (e.g. \t).
    /// </remarks>
    internal int column = 1;

    /// <summary>
    ///    True if <see cref="char.IsWhiteSpace(char)"/> is true for all
    ///    chars at the current line.
    /// </summary>
    internal bool isLineStart = true;

    /// <summary>
    ///    True if <see cref="isLineStart"/> was true before the current
    ///    <see cref="wordToken"/>.
    /// </summary>
    internal bool isLineStartBeforeWordToken = true;

    /// <summary>
    ///    Current char that's being pushed.
    /// </summary>
    internal char currentChar = '\0';

    /// <summary>
    ///    Last non-whitespace char that has been pushed.
    /// </summary>
    internal char previousChar = '\0';

    /// <summary>
    ///    Previous new line char
    /// </summary>
    internal char previousNewline = '\0';

    /// <summary>
    ///    Current indent level on this line.
    /// </summary>
    internal StringBuilder currentIndent = new StringBuilder();

    /// <summary>
    ///     True if this line began in <see cref="VerbatimStringState"/>.
    /// </summary>
    internal bool lineBeganInsideVerbatimString = false;

    /// <summary>
    ///     True if this line began in <see cref="MultiLineCommentState"/>.
    /// </summary>
    internal bool lineBeganInsideMultiLineComment = false;

    #endregion

    #region Constructors

    /// <summary>
    ///     Creates a new CSharpIndentEngine instance.
    /// </summary>
    /// <param name="document">
    ///     An instance of <see cref="IDocument"/> which is being parsed.
    /// </param>
    /// <param name="formattingOptions">
    ///     C# formatting options.
    /// </param>
    /// <param name="textEditorOptions">
    ///    Text editor options for indentation.
    /// </param>
    public CSharpIndentEngine(IDocument document, TextEditorOptions textEditorOptions, CSharpFormattingOptions formattingOptions)
    {
      this.formattingOptions = formattingOptions;
      this.textEditorOptions = textEditorOptions;
      this.document = document;

      this.currentState = new GlobalBodyState(this);

      this.conditionalSymbols = new HashSet<string>();
      this.customConditionalSymbols = new HashSet<string>();
      this.wordToken = new StringBuilder();
      this.previousKeyword = string.Empty;
      this.newLineChar = textEditorOptions.EolMarker[0];
    }

    /// <summary>
    ///     Creates a new CSharpIndentEngine instance from the given prototype.
    /// </summary>
    /// <param name="prototype">
    ///     An CSharpIndentEngine instance.
    /// </param>
    public CSharpIndentEngine(CSharpIndentEngine prototype)
    {
      this.formattingOptions = prototype.formattingOptions;
      this.textEditorOptions = prototype.textEditorOptions;
      this.document = prototype.document;

      this.newLineChar = prototype.newLineChar;
      this.currentState = prototype.currentState.Clone(this);
      this.conditionalSymbols = new HashSet<string>(prototype.conditionalSymbols);
      this.customConditionalSymbols = new HashSet<string>(prototype.customConditionalSymbols);

      this.wordToken = new StringBuilder(prototype.wordToken.ToString());
      this.previousKeyword = string.Copy(prototype.previousKeyword);

      this.offset = prototype.offset;
      this.line = prototype.line;
      this.column = prototype.column;
      this.isLineStart = prototype.isLineStart;
      this.isLineStartBeforeWordToken = prototype.isLineStartBeforeWordToken;
      this.currentChar = prototype.currentChar;
      this.previousChar = prototype.previousChar;
      this.previousNewline = prototype.previousNewline;
      this.currentIndent = new StringBuilder(prototype.CurrentIndent.ToString());
      this.lineBeganInsideMultiLineComment = prototype.lineBeganInsideMultiLineComment;
      this.lineBeganInsideVerbatimString = prototype.lineBeganInsideVerbatimString;
      this.ifDirectiveEvalResults = prototype.ifDirectiveEvalResults.Clone();
      this.ifDirectiveIndents = prototype.ifDirectiveIndents.Clone();

      this.EnableCustomIndentLevels = prototype.EnableCustomIndentLevels;
    }

    #endregion

    #region IClonable

    object ICloneable.Clone()
    {
      return Clone();
    }

    /// <inheritdoc />
    IDocumentIndentEngine IDocumentIndentEngine.Clone()
    {
      return Clone();
    }

    public IStateMachineIndentEngine Clone()
    {
      return new CSharpIndentEngine(this);
    }

    #endregion

    #region Methods

    /// <inheritdoc />
    public void Push(char ch)
    {
      // append this char to the wordbuf if it can form a valid keyword, otherwise check
      // if the last sequence of chars form a valid keyword and reset the wordbuf.
      if ((wordToken.Length == 0 ? char.IsLetter(ch) : char.IsLetterOrDigit(ch)) || ch == '_')
      {
        wordToken.Append(ch);
      }
      else if (wordToken.Length > 0)
      {
        currentState.CheckKeyword(wordToken.ToString());
        previousKeyword = wordToken.ToString();
        wordToken.Length = 0;
        isLineStartBeforeWordToken = false;
      }

      var isNewLine = NewLine.IsNewLine(ch);
      if (!isNewLine) {
        currentState.Push(currentChar = ch);
        offset++;
        previousNewline = '\0';
        // ignore whitespace and newline chars
        var isWhitespace = currentChar == ' ' || currentChar == '\t';
        if (!isWhitespace)
        {
          previousChar = currentChar;
          isLineStart = false;
        }

        if (isLineStart)
        {
          currentIndent.Append(ch);
        }

        if (ch == '\t')
        {
          var nextTabStop = (column - 1 + textEditorOptions.IndentSize) / textEditorOptions.IndentSize;
          column = 1 + nextTabStop * textEditorOptions.IndentSize;
        }
        else
        {
          column++;
        }
      } else {
        if (ch == NewLine.LF && previousNewline == NewLine.CR) {
          offset++;
          return;
        }
        currentState.Push(currentChar = newLineChar);
        offset++;

        previousNewline = ch;
        // there can be more than one chars that determine the EOL,
        // the engine uses only one of them defined with newLineChar
        if (currentChar != newLineChar)
        {
          return;
        }
        currentIndent.Length = 0;
        isLineStart = true;
        isLineStartBeforeWordToken = true;
        column = 1;
        line++;

        lineBeganInsideMultiLineComment = IsInsideMultiLineComment;
        lineBeganInsideVerbatimString = IsInsideVerbatimString;
      }
    }

    /// <inheritdoc />
    public void Reset()
    {
      currentState = new GlobalBodyState(this);
      conditionalSymbols.Clear();
      ifDirectiveEvalResults.Clear();
      ifDirectiveIndents.Clear();

      offset = 0;
      line = 1;
      column = 1;
      isLineStart = true;
      currentChar = '\0';
      previousChar = '\0';
      currentIndent.Length = 0;
      lineBeganInsideMultiLineComment = false;
      lineBeganInsideVerbatimString = false;
    }

    /// <inheritdoc />
    public void Update(int offset)
    {
      if (Offset > offset)
      {
        Reset();
      }

      while (Offset < offset)
      {
        Push(Document.GetCharAt(Offset));
      }
    }

    /// <summary>
    /// Defines the conditional symbol.
    /// </summary>
    /// <param name="defineSymbol">The symbol to define.</param>
    public void DefineSymbol(string defineSymbol)
    {
      if (!customConditionalSymbols.Contains(defineSymbol))
        customConditionalSymbols.Add(defineSymbol);
    }

    /// <summary>
    /// Removes the symbol.
    /// </summary>
    /// <param name="undefineSymbol">The symbol to undefine.</param>
    public void RemoveSymbol(string undefineSymbol)
    {
      if (customConditionalSymbols.Contains(undefineSymbol))
        customConditionalSymbols.Remove(undefineSymbol);
    }
    #endregion

    #region IStateMachineIndentEngine

    public bool IsInsidePreprocessorDirective
    {
      get { return currentState is PreProcessorState; }
    }

    public bool IsInsidePreprocessorComment
    {
      get { return currentState is PreProcessorCommentState; }
    }

    public bool IsInsideStringLiteral
    {
      get { return currentState is StringLiteralState; }
    }

    public bool IsInsideVerbatimString
    {
      get { return currentState is VerbatimStringState; }
    }

    public bool IsInsideCharacter
    {
      get { return currentState is CharacterState; }
    }

    public bool IsInsideString
    {
      get { return IsInsideStringLiteral || IsInsideVerbatimString || IsInsideCharacter; }
    }

    public bool IsInsideLineComment
    {
      get { return currentState is LineCommentState; }
    }

    public bool IsInsideMultiLineComment
    {
      get { return currentState is MultiLineCommentState; }
    }

    public bool IsInsideDocLineComment
    {
      get { return currentState is DocCommentState; }
    }

    public bool IsInsideComment
    {
      get { return IsInsideLineComment || IsInsideMultiLineComment || IsInsideDocLineComment; }
    }

    public bool IsInsideOrdinaryComment
    {
      get { return IsInsideLineComment || IsInsideMultiLineComment; }
    }

    public bool IsInsideOrdinaryCommentOrString
    {
      get { return IsInsideOrdinaryComment || IsInsideString; }
    }

    public bool LineBeganInsideVerbatimString
    {
      get { return lineBeganInsideVerbatimString; }
    }

    public bool LineBeganInsideMultiLineComment
    {
      get { return lineBeganInsideMultiLineComment; }
    }

    #endregion
  }
}