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()); }