private void AddSpansForStringToken(StringExpandableToken stringToken, int spanStart, List<ClassificationInfo> classificationInfo)
{
var startOffset = stringToken.Extent.StartOffset;
foreach (var current in stringToken.NestedTokens)
{
ToClassificationInfo(stringToken, startOffset + spanStart, current.Extent.StartOffset - startOffset, classificationInfo);
AddSpanForToken(current, spanStart, classificationInfo);
startOffset = current.Extent.EndOffset;
}
ToClassificationInfo(stringToken, startOffset + spanStart, stringToken.Extent.EndOffset - startOffset, classificationInfo);
}
private List<ExpressionAst> ParseNestedExpressions(StringExpandableToken expandableStringToken)
{
ExpressionAst expressionAst;
List<Token> tokens;
List<ExpressionAst> expressionAsts = new List<ExpressionAst>();
if (this._savingTokens)
{
tokens = new List<Token>();
}
else
{
tokens = null;
}
List<Token> tokens1 = tokens;
foreach (Token nestedToken in expandableStringToken.NestedTokens)
{
VariableToken variableToken = nestedToken as VariableToken;
if (variableToken == null)
{
TokenizerState tokenizerState = null;
try
{
tokenizerState = this._tokenizer.StartNestedScan((UnscannedSubExprToken)nestedToken);
expressionAst = this.PrimaryExpressionRule(true);
if (this._savingTokens)
{
tokens1.AddRange(this._tokenizer.TokenList);
}
}
finally
{
this._ungotToken = null;
this._tokenizer.FinishNestedScan(tokenizerState);
}
}
else
{
expressionAst = this.CheckUsingVariable(variableToken, false);
if (this._savingTokens)
{
tokens1.Add(variableToken);
}
}
expressionAsts.Add(expressionAst);
}
if (this._savingTokens)
{
expandableStringToken.NestedTokens = new ReadOnlyCollection<Token>(tokens1);
}
return expressionAsts;
}
private ExpressionAst ExpandableStringRule(StringExpandableToken strToken)
{
//G value:
//G literal
ExpressionAst expr;
// We need to scan the nested tokens even if there was some error. This is used by the tab completion: "pshome is $psh<tab>
if (strToken.NestedTokens != null)
{
List<ExpressionAst> nestedExpressions = ParseNestedExpressions(strToken);
expr = new ExpandableStringExpressionAst(strToken, strToken.Value, strToken.FormatString, nestedExpressions);
}
else
{
expr = new StringConstantExpressionAst(strToken);
}
return expr;
}
private ExpressionAst ExpandableStringRule(StringExpandableToken strToken)
{
ExpressionAst stringConstantExpressionAst;
if (strToken.NestedTokens == null)
{
stringConstantExpressionAst = new StringConstantExpressionAst(strToken);
}
else
{
List<ExpressionAst> expressionAsts = this.ParseNestedExpressions(strToken);
stringConstantExpressionAst = new ExpandableStringExpressionAst(strToken, strToken.Value, strToken.FormatString, expressionAsts);
}
return stringConstantExpressionAst;
}
private List<ExpressionAst> ParseNestedExpressions(StringExpandableToken expandableStringToken)
{
List<ExpressionAst> nestedExpressions = new List<ExpressionAst>();
List<Token> newNestedTokens = _savingTokens ? new List<Token>() : null;
foreach (var token in expandableStringToken.NestedTokens)
{
Diagnostics.Assert(!token.HasError || ErrorList.Any(), "No nested tokens should have unreported errors.");
ExpressionAst exprAst;
var varToken = token as VariableToken;
if (varToken != null)
{
exprAst = CheckUsingVariable(varToken, false);
if (_savingTokens) { newNestedTokens.Add(varToken); }
}
// Enable if we decide we still need to support
// "${}" or "$var:"
//else if (token.Kind == TokenKind.Unknown)
//{
// //Diagnostics.Assert(token.Text.Equals("${}", StringComparison.OrdinalIgnoreCase),
// // "The unknown token is only used in an expandable string when it's an empty variable name.");
// // TODO: Need strict-mode check at runtime.
// // TODO: in V2, "${}" expanded to '$', but "$var:" expanded to the empty string
// exprAst = new StringConstantExpressionAst(token.Extent, "$", StringConstantType.BareWord);
// if (_savingTokens) { newNestedTokens.Add(token); }
//}
else
{
TokenizerState ts = null;
try
{
ts = _tokenizer.StartNestedScan((UnscannedSubExprToken)token);
exprAst = PrimaryExpressionRule(withMemberAccess: true);
if (_savingTokens) { newNestedTokens.AddRange(_tokenizer.TokenList); }
}
finally
{
// _ungotToken is probably <EOF>, but if there were errors, it could be something
// else. Either way, we don't want it.
_ungotToken = null;
_tokenizer.FinishNestedScan(ts);
}
}
nestedExpressions.Add(exprAst);
}
if (_savingTokens) { expandableStringToken.NestedTokens = new ReadOnlyCollection<Token>(newNestedTokens); }
return nestedExpressions;
}
