public bool Match(TokenNodeType token1, TokenNodeType token2)
{
if (token1 == NTriplesTokenType.L_BRACE)
{
return (token2 == NTriplesTokenType.R_BRACE);
}
if (token1 == NTriplesTokenType.L_PARENTHESES)
{
return (token2 == NTriplesTokenType.R_PARENTHESES);
}
if (token1 == NTriplesTokenType.L_BRACKET)
{
return (token2 == NTriplesTokenType.R_BRACKET);
}
if (token1 == NTriplesTokenType.R_BRACE)
{
return (token2 == NTriplesTokenType.L_BRACE);
}
if (token1 == NTriplesTokenType.R_PARENTHESES)
{
return (token2 == NTriplesTokenType.L_PARENTHESES);
}
if (token1 == NTriplesTokenType.R_BRACKET)
{
return (token2 == NTriplesTokenType.L_BRACKET);
}
return false;
}
private static bool IsSupportedTokenType(TokenNodeType tokenType) {
return tokenType == T4TokenNodeTypes.Name
|| tokenType == T4TokenNodeTypes.Space
|| tokenType == T4TokenNodeTypes.DirectiveStart
|| tokenType == T4TokenNodeTypes.Quote
|| tokenType == T4TokenNodeTypes.Value;
}
public void Start(int startOffset, int endOffset, uint state)
{
yy_buffer_index = startOffset;
yy_buffer_start = startOffset;
yy_buffer_end = startOffset;
yy_eof_pos = endOffset;
yy_lexical_state = (int)state;
currTokenType = null;
}
public bool IsRightBracket(TokenNodeType tokenType)
{
if (((tokenType != NTriplesTokenType.R_BRACE) && (tokenType != NTriplesTokenType.R_PARENTHESES)) &&
(tokenType != NTriplesTokenType.R_BRACKET))
{
return false;
}
return true;
}
public int Compare(TokenNodeType x, TokenNodeType y)
{
if ((this.IsLeftBracket(x) && this.IsLeftBracket(y)) || (this.IsRightBracket(x) && this.IsRightBracket(y)))
{
if (x == NTriplesTokenType.L_BRACE)
{
return 1;
}
if (y == NTriplesTokenType.L_BRACE)
{
return -1;
}
if (x == NTriplesTokenType.R_BRACE)
{
return 1;
}
if (y == NTriplesTokenType.R_BRACE)
{
return -1;
}
}
return 0;
}
protected override bool Match(TokenNodeType token1, TokenNodeType token2)
{
if (token1 == NTriplesTokenType.L_BRACE)
{
return token2 == NTriplesTokenType.R_BRACE;
}
if (token1 == NTriplesTokenType.L_PARENTHESES)
{
return token2 == NTriplesTokenType.R_PARENTHESES;
}
if (token1 == NTriplesTokenType.L_BRACKET)
{
return token2 == NTriplesTokenType.R_BRACKET;
}
if (token1 == NTriplesTokenType.URI_BEGIN)
{
return token2 == NTriplesTokenType.URI_END;
}
if (token1 == NTriplesTokenType.R_BRACE)
{
return token2 == NTriplesTokenType.L_BRACE;
}
if (token1 == NTriplesTokenType.R_PARENTHESES)
{
return token2 == NTriplesTokenType.L_PARENTHESES;
}
if (token1 == NTriplesTokenType.R_BRACKET)
{
return token2 == NTriplesTokenType.L_BRACKET;
}
if (token1 == NTriplesTokenType.URI_END)
{
return token2 == NTriplesTokenType.URI_BEGIN;
}
return false;
}
private void LocateToken()
{
if (currTokenType == null)
currTokenType = _locateToken();
}
//Method doesn't call now
protected override bool Match(TokenNodeType token1, TokenNodeType token2)
{
return false;
}
public static string GetTokenText(TokenNodeType token)
{
if (OurTokenTextMap.ContainsKey(token))
{
return OurTokenTextMap.GetValue(token);
}
if (OurKeywordTextMap.ContainsKey(token))
{
return OurKeywordTextMap.GetValue(token);
}
return token.ToString();
}
/// <summary>
/// Negative and positive signs must be spaced correctly.
/// </summary>
/// <param name="node">
/// The node to use.
/// </param>
/// <param name="tokenToCheck">
/// The token to check.
/// </param>
public void NegativeAndPositiveSignsMustBeSpacedCorrectly(ITreeNode node, TokenNodeType tokenToCheck)
{
for (ITreeNode currentNode = node; currentNode != null; currentNode = currentNode.NextSibling)
{
if (currentNode is ITokenNode)
{
ITokenNode tokenNode = currentNode as ITokenNode;
if (tokenNode.GetTokenType() == tokenToCheck)
{
if (tokenNode.Parent is IOperatorExpression && !(tokenNode.Parent is IAdditiveExpression))
{
ITokenNode nextToken = tokenNode.GetNextToken();
if (nextToken.IsWhitespace())
{
using (WriteLockCookie.Create(true))
{
// remove the whitespace or new line
LowLevelModificationUtil.DeleteChild(nextToken);
}
}
}
}
}
if (currentNode.FirstChild != null)
{
this.NegativeAndPositiveSignsMustBeSpacedCorrectly(currentNode.FirstChild, tokenToCheck);
}
}
}
public void Advance()
{
bool findHeader = false;
if (myCurOffset > EndOffset)
{
myTokenNodeType = null;
return;
}
var isInteresting = false;
myTokenStartOffset = myCurOffset;
while (true)
{
if (myCurOffset > EndOffset)
{
EatUntilDocumentEnd();
return;
}
switch (myBuffer[myCurOffset])
{
case '%':
findHeader = true;
while (true)
{
if (myCurOffset > EndOffset)
{
myTokenNodeType = UnityYamlTokenType.DOCUMENT;
return;
}
if (myBuffer[myCurOffset] == '\r')
{
myCurOffset++;
myCurrentLineOffset = 0;
if (myCurOffset <= EndOffset && myBuffer[myCurOffset] == '\n')
{
myCurOffset++;
}
break;
}
if (myBuffer[myCurOffset] == '\n')
{
myCurOffset++;
myCurrentLineOffset = 0;
break;
}
myCurOffset++;
}
break;
case '-':
if (findHeader)
{
myTokenNodeType = UnityYamlTokenType.USELESS_DOCUMENT;
return;
}
myCurOffset++;
if (myCurOffset + 1 <= EndOffset && myBuffer[myCurOffset] == '-' &&
myBuffer[myCurOffset + 1] == '-')
{
myCurOffset++;
myCurOffset++;
if (myCurOffset <= EndOffset && myBuffer[myCurOffset] == ' ')
{
myCurOffset++;
var sb = new StringBuilder();
while (myCurOffset <= EndOffset && myBuffer[myCurOffset] != ' ' &&
myBuffer[myCurOffset] != '\r' &&
myBuffer[myCurOffset] != '\n')
{
sb.Append(Buffer[myCurOffset]);
myCurOffset++;
}
var tag = sb.ToString();
if (tag.Equals("!u!1") ||
tag.Equals("!u!4") ||
tag.Equals("!u!1001") ||
tag.Equals("!u!114") ||
tag.Equals("!u!224") ||
tag.Equals("!u!1102") ||
tag.Equals("!u!1107") ||
tag.Equals("!u!74"))
{
isInteresting = true;
}
}
}
myCurrentLineOffset = 1; // just mark that it is not line start
EatUntilDocumentEnd();
return;
default:
EatUntilDocumentEnd();
return;
}
}
void EatUntilDocumentEnd()
{
while (true)
{
if (myCurOffset > EndOffset)
{
myTokenNodeType = UnityYamlTokenType.DOCUMENT;
break;
}
var curChar = myBuffer[myCurOffset];
if (curChar == '\r')
{
myCurrentLineOffset = 0;
myCurOffset++;
continue;
}
if (curChar == '\n')
{
myCurrentLineOffset = 0;
myCurOffset++;
continue;
}
if (myCurrentLineOffset == 0 && myCurOffset + 2 <= EndOffset && (
(curChar == '-' && myBuffer[myCurOffset + 1] == '-' &&
myBuffer[myCurOffset + 2] == '-')))
{
myTokenNodeType = isInteresting ? UnityYamlTokenType.DOCUMENT : UnityYamlTokenType.USELESS_DOCUMENT;
// debug highlightings...
// myTokenNodeType = isInteresting ? UnityYamlTokenType.DOCUMENT : YamlTokenType.COMMENT;
break;
}
myCurrentLineOffset++;
myCurOffset++;
}
}
}
public PsiGenericToken(TokenNodeType nodeType, string text)
{
myNodeType = nodeType;
myText = text;
}
protected override bool IsNumber(TokenNodeType tokenType)
{
return(tokenType == CgTokenNodeTypes.NUMERIC_LITERAL);
}
protected override bool IsBlockComment(TokenNodeType tokenType)
{
return(tokenType == CgTokenNodeTypes.DELIMITED_COMMENT || tokenType == CgTokenNodeTypes.UNFINISHED_DELIMITED_COMMENT);
}
public CgGenericTokenNode(TokenNodeType tokenNodeType, string text)
{
myTokenNodeType = tokenNodeType;
myText = text;
}
protected override bool IsEndOfLineComment(TokenNodeType tokenType, string tokenText)
{
return(tokenType.IsComment && tokenText.StartsWith("//"));
}
public virtual void Advance()
{
LocateToken();
currTokenType = null;
}
protected override bool IsLineComment(TokenNodeType tokenType)
{
return(tokenType == CgTokenNodeTypes.SINGLE_LINE_COMMENT);
}
protected override bool IsLeftBracket(TokenNodeType tokenType)
{
return tokenType == NTriplesTokenType.L_BRACE || tokenType == NTriplesTokenType.L_PARENTHESES ||
tokenType == NTriplesTokenType.L_BRACKET || tokenType == NTriplesTokenType.URI_BEGIN;
}
protected override bool IsBlockComment(TokenNodeType tokenType)
{
return(tokenType == ShaderLabTokenType.MULTI_LINE_COMMENT);
}
protected override bool Skip(TokenNodeType tokenType)
{
return ((tokenType == PsiTokenType.NEW_LINE) || (tokenType == PsiTokenType.WHITE_SPACE) || (tokenType == PsiTokenType.END_OF_LINE_COMMENT) || (tokenType == PsiTokenType.C_STYLE_COMMENT));
}
protected override bool IsNumber(TokenNodeType tokenType)
{
return(tokenType == ShaderLabTokenType.NUMERIC_LITERAL || tokenType == ShaderLabTokenType.PP_DIGITS);
}
private void locateToken()
{
if (currTokenType == null)
{
currTokenType = _locateToken();
}
if (currTokenType != null && !currTokenType.IsWhitespace)
{
myMakeDivide = MAKE_DIVIDE[currTokenType];
}
}
private TokenNodeType makeToken(TokenNodeType type)
{
//yy_lexical_state = state;
return(currTokenType = type);
}
public TokenTypePair(TokenNodeType type1, TokenNodeType type2)
{
myType1 = type1;
myType2 = type2;
}
public virtual void Advance()
{
LocateToken();
currTokenType = null;
}
protected override bool IsNewLine(TokenNodeType tokenType)
{
return(tokenType == ShaderLabTokenType.END_OF_LINE_COMMENT);
}
/// <summary>
/// Negative and positive signs must be spaced correctly.
/// </summary>
/// <param name="node">
/// The node to use.
/// </param>
/// <param name="tokenToCheck">
/// The token to check.
/// </param>
public static void NegativeAndPositiveSignsMustBeSpacedCorrectly(ITreeNode node, TokenNodeType tokenToCheck)
{
for (ITreeNode currentNode = node; currentNode != null; currentNode = currentNode.NextSibling)
{
if (currentNode is ITokenNode)
{
ITokenNode tokenNode = currentNode as ITokenNode;
if (tokenNode.GetTokenType() == tokenToCheck)
{
if (tokenNode.Parent is IOperatorExpression && !(tokenNode.Parent is IAdditiveExpression))
{
ITokenNode nextToken = tokenNode.GetNextToken();
if (nextToken.IsWhitespace())
{
using (WriteLockCookie.Create(true))
{
// remove the whitespace or new line
LowLevelModificationUtil.DeleteChild(nextToken);
}
}
}
}
}
if (currentNode.FirstChild != null)
{
NegativeAndPositiveSignsMustBeSpacedCorrectly(currentNode.FirstChild, tokenToCheck);
}
}
}
//Method doesn't call now
protected override bool IsRightBracket(TokenNodeType tokenType)
{
return false;
}
public GenericTokenElement(TokenNodeType tokenNodeType, string text)
{
myTokenNodeType = tokenNodeType;
myText = text;
}
/// <summary>
/// Returns whether to skips a specified token type.
/// </summary>
/// <param name="tokenType">Type of the token.</param>
/// <returns><c>true</c> if the token must be skipped, <c>false</c> otherwise.</returns>
protected override bool Skip(TokenNodeType tokenType) {
return tokenType.IsWhitespace;
}
protected override bool IsLineComment(TokenNodeType tokenType)
{
return(base.IsLineComment(tokenType));
}
private TokenNodeType makeToken(TokenNodeType type)
{
//yy_lexical_state = state;
return currTokenType = type;
}
protected override bool IsString(TokenNodeType tokenType)
{
return(base.IsString(tokenType));
}
public static string GetTokenText(TokenNodeType token)
{
return GetKeywordTextByTokenType(token);
}
protected override bool IsNumber(TokenNodeType tokenType)
{
return(base.IsNumber(tokenType));
}
protected override bool IsRightBracket(TokenNodeType tokenType)
{
return tokenType == NTriplesTokenType.R_BRACE || tokenType == NTriplesTokenType.R_PARENTHESES ||
tokenType == NTriplesTokenType.R_BRACKET || tokenType == NTriplesTokenType.URI_END;
}
protected override bool IsKeyword(TokenNodeType tokenType)
{
return(base.IsKeyword(tokenType) || tokenType.IsConstantLiteral);
}
public override string GetTokenReprByTokenType(TokenNodeType token)
{
return base.GetTokenReprByTokenType(token);
}
public DocComment([NotNull] TokenNodeType nodeType, [NotNull] string text) : base(nodeType, text)
{
}
public NTriplesGenericToken(TokenNodeType nodeType, string text)
{
this.myNodeType = nodeType;
this.myText = text;
}
public void Advance()
{
locateToken();
currTokenType = null;
}
private TokenNodeType makeToken(TokenNodeType type)
{
return currTokenType = type;
}
public override string GetTokenContentsText(string tokenText, TokenNodeType tokenType)
{
return null;
}
protected override bool Skip(TokenNodeType tokenType)
{
return(NTriplesLanguageService.WHITESPACE_OR_COMMENT[tokenType]);
}
protected override bool IsWhitespace(TokenNodeType tokenType)
{
return(tokenType.IsWhitespace);
}
private bool IsIdentifier(TokenNodeType tokenType)
{
return tokenType == CSharpTokenType.IDENTIFIER || CSharpTokenType.KEYWORDS.Exists(type => type == tokenType);
}
/// <summary>
/// Determines whether a given node is filtered.
/// </summary>
/// <param name="node">The node to check.</param>
/// <returns><c>true</c> if <paramref name="node"/> is a whitespace; otherwise, <c>false</c>.</returns>
public override bool IsFilteredNode(ITreeNode node)
{
TokenNodeType nodeType = node.GetTokenType();
return(nodeType != null && nodeType.IsWhitespace);
}
public override string GetTokenReprByTokenType(TokenNodeType token)
{
return null;
}
public void Advance()
{
LocateToken();
currentTokenType = null;
}
protected virtual bool IsBlockComment(TokenNodeType tokenType)
{
return(false);
}
protected virtual bool IsNumber(TokenNodeType tokenType)
{
return(false);
}
public Comment(TokenNodeType nodeType, string text)
: base(nodeType, text)
{
}
private static bool IsSupportedTokenType(TokenNodeType tokenType) => tokenType == T4TokenNodeTypes.Name || tokenType == T4TokenNodeTypes.Space || tokenType == T4TokenNodeTypes.DirectiveStart || tokenType == T4TokenNodeTypes.Quote || tokenType == T4TokenNodeTypes.Value;
