public static string GetText(RdParseContext context)
{
var text = string.Empty;
if (RdParseUtility.GetKeywordArgumentBounds(context.Tokens, out var startTokenIndex, out var endTokenIndex))
{
text = RdText.FromTokens(context, startTokenIndex, endTokenIndex);
context.Tokens.Position = endTokenIndex;
}
text = text.Trim();
var index = text.IndexOf(@"\href", StringComparison.Ordinal);
if (index >= 0)
{
var openCurlyIndex = text.IndexOf('{', index);
var closeCurlyIndex = text.LastIndexOf('}', openCurlyIndex);
openCurlyIndex = text.IndexOf('{', closeCurlyIndex);
closeCurlyIndex = text.LastIndexOf('}', openCurlyIndex);
if (openCurlyIndex >= 0 && closeCurlyIndex >= 0 && openCurlyIndex < closeCurlyIndex)
{
var name = text.Substring(openCurlyIndex + 1, closeCurlyIndex - openCurlyIndex - 1);
text = text.Substring(0, index) + name + text.Substring(closeCurlyIndex + 1);
}
}
return(text);
}
private static ISignatureInfo ParseSignature(string functionName, ParseContext context)
{
var info = new SignatureInfo(functionName);
var signatureArguments = new List <IArgumentInfo>();
// RD data may contain function name(s) without braces
if (context.Tokens.CurrentToken.TokenType == RTokenType.OpenBrace)
{
var functionCall = new FunctionCall();
functionCall.Parse(context, context.AstRoot);
foreach (var arg in functionCall.Arguments)
{
string argName = null;
string argDefaultValue = null;
var isEllipsis = false;
if (arg is ExpressionArgument expArg)
{
argName = context.TextProvider.GetText(expArg.ArgumentValue);
}
else
{
if (arg is NamedArgument nameArg)
{
argName = context.TextProvider.GetText(nameArg.NameRange);
argDefaultValue = nameArg.DefaultValue != null?
RdText.CleanRawRdText(context.TextProvider.GetText(nameArg.DefaultValue)) : string.Empty;
}
else if (arg is MissingArgument)
{
argName = string.Empty;
}
else if (arg is EllipsisArgument)
{
argName = "...";
isEllipsis = true;
}
}
if (!string.IsNullOrEmpty(argName))
{
var argInfo = new ArgumentInfo(argName)
{
DefaultValue = argDefaultValue,
IsEllipsis = isEllipsis,
IsOptional = false
};
// TODO: actually parse
signatureArguments.Add(argInfo);
}
}
}
info.Arguments = signatureArguments;
return(info);
}
public static string GetText(RdParseContext context)
{
string text = string.Empty;
int startTokenIndex, endTokenIndex;
if (RdParseUtility.GetKeywordArgumentBounds(context.Tokens, out startTokenIndex, out endTokenIndex))
{
text = RdText.FromTokens(context, startTokenIndex, endTokenIndex);
context.Tokens.Position = endTokenIndex;
}
return(text.Trim());
}
private static IEnumerable <IArgumentInfo> ParseArgumentItem(RdParseContext context)
{
List <IArgumentInfo> arguments = null;
TokenStream <RdToken> tokens = context.Tokens;
tokens.Advance(1);
// Past '\item'. Inside { } we can find any number of '\dots' which are keywords.
Debug.Assert(tokens.CurrentToken.TokenType == RdTokenType.OpenCurlyBrace);
if (tokens.CurrentToken.TokenType == RdTokenType.OpenCurlyBrace)
{
int startTokenIndex, endTokenIndex;
if (RdParseUtility.GetKeywordArgumentBounds(tokens, out startTokenIndex, out endTokenIndex))
{
TextRange range = TextRange.FromBounds(tokens[startTokenIndex].End, tokens[endTokenIndex].Start);
string argumentsText = context.TextProvider.GetText(range);
string[] argumentNames = argumentsText.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
arguments = new List <IArgumentInfo>();
// Move past \item{}
tokens.Position = endTokenIndex + 1;
Debug.Assert(tokens.CurrentToken.TokenType == RdTokenType.OpenCurlyBrace);
if (tokens.CurrentToken.TokenType == RdTokenType.OpenCurlyBrace)
{
string description = RdText.GetText(context);
foreach (string n in argumentNames)
{
string name = n.Trim();
if (name == @"\dots")
{
name = "...";
}
ArgumentInfo info = new ArgumentInfo(name, description.Trim());
arguments.Add(info);
}
}
}
}
return(arguments);
}
private static IReadOnlyList <IFunctionInfo> ParseFunctions(RdParseContext context)
{
IReadOnlyList <ISignatureInfo> signatureInfos = null;
IReadOnlyDictionary <string, string> argumentDescriptions = null;
var aliases = new List <string>();
string functionDescription = null; // Description is normally one for all similar functions
var isInternal = false;
string returnValue = null;
string primaryName = null;
while (!context.Tokens.IsEndOfStream() &&
(functionDescription == null || argumentDescriptions == null ||
signatureInfos == null || returnValue == null))
{
var token = context.Tokens.CurrentToken;
if (context.IsAtKeywordWithParameters())
{
if (string.IsNullOrEmpty(functionDescription) && context.IsAtKeyword(@"\description"))
{
functionDescription = RdText.GetText(context);
}
else if (context.IsAtKeyword(@"\keyword"))
{
var keyword = RdText.GetText(context);
if (!string.IsNullOrEmpty(keyword) && keyword.Contains("internal"))
{
isInternal = true;
}
}
else if (string.IsNullOrEmpty(returnValue) && context.IsAtKeyword(@"\value"))
{
returnValue = RdText.GetText(context);
}
else if (argumentDescriptions == null && context.IsAtKeyword(@"\arguments"))
{
// Extract arguments and their descriptions
argumentDescriptions = RdArgumentDescription.ExtractArgumentDecriptions(context);
}
else if (signatureInfos == null && context.IsAtKeyword(@"\usage"))
{
// Extract signatures with function names
signatureInfos = RdFunctionSignature.ExtractSignatures(context);
}
else if (context.IsAtKeyword(@"\alias"))
{
var alias = RdText.GetText(context);
if (!string.IsNullOrWhiteSpace(alias))
{
aliases.Add(alias);
}
}
else if (primaryName == null && context.IsAtKeyword(@"\name"))
{
primaryName = RdText.GetText(context);
}
else
{
context.Tokens.Advance(2);
}
}
if (token == context.Tokens.CurrentToken)
{
// If token is not recognized, move on
context.Tokens.MoveToNextToken();
}
}
// Merge descriptions into signatures
if (argumentDescriptions != null && signatureInfos != null)
{
foreach (var sigInfo in signatureInfos)
{
// Add missing arguments from the \arguments{} section
foreach (var arg in sigInfo.Arguments)
{
if (argumentDescriptions.TryGetValue(arg.Name, out var description))
{
((NamedItemInfo)arg).Description = description ?? string.Empty;
}
}
}
}
// Merge signatures into function infos
var functionInfos = new Dictionary <string, FunctionInfo>();
if (signatureInfos != null)
{
var functionSignatures = new Dictionary <string, List <ISignatureInfo> >();
foreach (var sigInfo in signatureInfos)
{
List <ISignatureInfo> sigList;
if (!functionInfos.TryGetValue(sigInfo.FunctionName, out FunctionInfo functionInfo))
{
// Create function info
functionInfo = CreateFunctionInfo(sigInfo.FunctionName, context.PackageName, functionDescription, returnValue, isInternal);
functionInfos[sigInfo.FunctionName] = functionInfo;
// Create list of signatures for this function
sigList = new List <ISignatureInfo>();
functionSignatures[sigInfo.FunctionName] = sigList;
functionInfo.Signatures = sigList;
}
else
{
sigList = functionSignatures[sigInfo.FunctionName];
}
sigList.Add(sigInfo);
}
}
// Propage to aliases
if (!string.IsNullOrWhiteSpace(primaryName))
{
FunctionInfo functionInfo;
if (functionInfos.TryGetValue(primaryName, out functionInfo))
{
foreach (var alias in aliases)
{
if (!functionInfos.ContainsKey(alias))
{
functionInfos[alias] = new FunctionInfo(alias, functionInfo);
}
}
}
}
return(functionInfos.Values.ToList());
}
