public IEnumerable <LSLLibraryFunctionSignature> LSLFunctions()
{
var sigs = new HashSet <LSLLibraryFunctionSignature>();
foreach (var f in _scriptLibrary.Functions)
{
var matches = _functionSig.Regex.Matches(f.Desc);
if (matches.Count == 0)
{
Log.WriteLineWithHeader("[FirestormLibraryData]: ", "script_library name={0}: function {1} has no signature in doc string",
_scriptLibrary.Name, f.Name);
yield break;
}
foreach (Match match in matches)
{
if (match.Success)
{
var sig = LSLLibraryFunctionSignature.Parse(match.ToString());
sig.DocumentationString = _functionSig.Regex.Replace(f.Desc, "");
if (!sigs.Contains(sig))
{
sigs.Add(sig);
yield return(sig);
}
}
}
}
}
public IReadOnlyGenericArray <LSLLibraryFunctionSignature> LSLFunctionOverloads(string name)
{
var sigs = new HashSet <LSLLibraryFunctionSignature>();
foreach (var overload in _scriptLibrary.Functions.Get(name))
{
var matches = _functionSig.Regex.Matches(overload.Desc);
foreach (Match match in matches)
{
if (match.Success)
{
var sig = LSLLibraryFunctionSignature.Parse(match.ToString());
sig.DocumentationString = _functionSig.Regex.Replace(overload.Desc, "");
if (!sigs.Contains(sig))
{
Log.WriteLineWithHeader("[FirestormLibraryData]: ", "script_library name={0}: function {1} signature {2} found in doc string",
_scriptLibrary.Name, overload.Name, sig.SignatureString);
sigs.Add(sig);
}
else if (matches.Count == 1)
{
Log.WriteLineWithHeader("[FirestormLibraryData]: ", "function {1} has a duplicate overload caused by multiple xml node definitions",
_scriptLibrary.Name, sig.Name);
}
else
{
Log.WriteLineWithHeader("[FirestormLibraryData]: ", "script_library name={0}: function {1} has a duplicate overload caused by the documentation signature",
_scriptLibrary.Name, overload.Name);
}
}
else
{
Log.WriteLineWithHeader("[FirestormLibraryData]: ", "script_library name={0}: function {1} has no signature in doc string",
_scriptLibrary.Name, overload.Name);
}
}
}
return(sigs.ToGenericArray());
}
public IEnumerable <IReadOnlyGenericArray <LSLLibraryFunctionSignature> > LSLFunctionOverloadGroups()
{
foreach (var fs in _scriptLibrary.Functions.OverloadGroups)
{
var sigs = new HashSet <LSLLibraryFunctionSignature>();
foreach (var f in fs)
{
var matches = _functionSig.Regex.Matches(f.Desc);
if (matches.Count == 0)
{
Log.WriteLineWithHeader("[FirestormLibraryData]: ", "script_library name={0}: function {1} has no signature in doc string",
_scriptLibrary.Name, f.Name);
continue;
}
foreach (Match match in matches)
{
if (match.Success)
{
var sig = LSLLibraryFunctionSignature.Parse(match.ToString());
sig.DocumentationString = _functionSig.Regex.Replace(f.Desc, "");
if (!sigs.Contains(sig))
{
sigs.Add(sig);
}
else if (matches.Count == 1)
{
Log.WriteLineWithHeader("[FirestormLibraryData]: ", "script_library name={0}: function {1} has a duplicate overload caused by multiple xml node definitions",
_scriptLibrary.Name, sig.Name);
}
else
{
Log.WriteLineWithHeader("[FirestormLibraryData]: ", "script_library name={0}: function {1} has a duplicate overload caused by the documentation signature",
_scriptLibrary.Name, sig.Name);
}
}
}
}
yield return(sigs.ToGenericArray());
}
}
private IEnumerable <LSLLibraryFunctionSignature> GetLSLFunctionsFromKeywordsAll()
{
var data = _client.DownloadString(SecondlifeWikiBaseUrl + "Category:LSL_Keywords/All");
var group = _functionsGroupInKeywordsAll.Match(data);
if (group.Success)
{
foreach (Match functionMatch in _functionInKeywordsAll.Matches(group.ToString()))
{
var sig = functionMatch.Groups[1] + " " + functionMatch.Groups[2] + functionMatch.Groups[3];
var result = LSLLibraryFunctionSignature.Parse(sig);
result.Subsets.SetSubsets(_subsets);
yield return(result);
}
}
}
private LSLLibraryFunctionSignature GetSigFromFunctionPage(string url)
{
var page = _client.DownloadString(url);
var matches = _functionSignature.Regex.Matches(page);
if (matches.Count == 0)
{
return(null);
}
foreach (Match match in matches)
{
var functionSignature = LSLLibraryFunctionSignature.Parse(match.Groups[1].ToString());
functionSignature.Deprecated = _deprecatedMarker.IsMatch(page);
functionSignature.Subsets.SetSubsets(_subsets);
if (url.ToLower() != SecondlifeWikiBaseUrl + functionSignature.Name.ToLower())
{
continue;
}
Log.WriteLineWithHeader(
"[SecondlifeWikiLibraryData]: ", "Retrieved" + (functionSignature.Deprecated ? " (DEPRECATED) " : " ") +
"function {0}; from {1}",
functionSignature.SignatureString,
url);
return(functionSignature);
}
return(null);
}
public string DocumentFunction(LSLLibraryFunctionSignature function)
{
return("");
}
public IReadOnlyGenericArray <LSLLibraryFunctionSignature> LSLFunctionOverloads(string name)
{
var map = GetFunctionOSDMap(_data, name);
if (map == null)
{
return(new GenericArray <LSLLibraryFunctionSignature> ());
}
LSLType returnType = LSLType.Void;
if (map.ContainsKey("return"))
{
var value = map["return"].AsString();
if (value != "void")
{
returnType = LSLTypeTools.FromLSLTypeName(value);
}
}
LSLLibraryFunctionSignature func = new LSLLibraryFunctionSignature(returnType, name)
{
DocumentationString = DocumentFunction(_data, name)
};
func.Subsets.SetSubsets(_subsets);
func.Deprecated = map.ContainsKey("deprecated");
if (!map.ContainsKey("arguments"))
{
return new GenericArray <LSLLibraryFunctionSignature> {
func
}
}
;
var args = map["arguments"] as OSDArray;
if (args == null)
{
return new GenericArray <LSLLibraryFunctionSignature> {
func
}
}
;
var paramNameDuplicates = new HashMap <string, int>();
foreach (var arg in args.Cast <OSDMap>())
{
var argName = arg.Keys.First();
var paramDetails = (OSDMap)arg[argName];
if (paramNameDuplicates.ContainsKey(argName))
{
//rename duplicates with a trailing number
int curValue = paramNameDuplicates[argName];
int newValue = curValue + 1;
paramNameDuplicates[argName] = newValue;
argName = argName + "_" + newValue;
}
else
{
paramNameDuplicates.Add(argName, 0);
}
func.AddParameter(new LSLParameterSignature(
LSLTypeTools.FromLSLTypeName(paramDetails["type"].AsString()), argName, false));
}
return(new GenericArray <LSLLibraryFunctionSignature> {
func
});
}
/// <summary>
/// Allows modification a function signature after its basic information has been serialized, before its returned.
/// </summary>
/// <param name="serializer">The <see cref="LSLLibraryDataReflectionSerializer" /> this add-on belongs to.</param>
/// <param name="info">The <see cref="MethodInfo" /> object the library function signature was serialized from.</param>
/// <param name="signature">The signature.</param>
/// <returns><c>true</c> if the method needs to be filtered from the results.</returns>
public bool MutateSignature(LSLLibraryDataReflectionSerializer serializer, MethodInfo info,
LSLLibraryFunctionSignature signature)
{
return(MutateSignatureFunction != null && MutateSignatureFunction(serializer, info, signature));
}
public string DocumentFunction(LSLLibraryFunctionSignature function)
{
var scriptLibraryHasFunction = _scriptLibrary.Functions.Contains(function.Name);
if (scriptLibraryHasFunction)
{
var doc = "";
var hasDocSig = false;
var hasMatchingDocSig = false;
foreach (var f in _scriptLibrary.Functions.Get(function.Name))
{
var matches = _functionSig.Regex.Matches(f.Desc);
foreach (Match match in matches)
{
if (match.Success)
{
hasDocSig = true;
var sig = LSLLibraryFunctionSignature.Parse(match.ToString());
doc = _functionSig.Regex.Replace(f.Desc, "");
if (!sig.SignatureEquivalent(function))
{
continue;
}
hasMatchingDocSig = true;
break;
}
doc = f.Desc;
hasDocSig = false;
}
}
/*
* if (function.Name == "lsSetWindlightScene")
* {
* Console.WriteLine("test");
* }*/
if (hasDocSig)
{
if (hasMatchingDocSig)
{
Log.WriteLineWithHeader("[FirestormDocumentationScraper]: ", "script_library name={0}: Matching docstring signature found for function {1}",
_scriptLibrary.Name, function.Name);
return(doc);
}
Log.WriteLineWithHeader("[FirestormDocumentationScraper]: ", "script_library name={0}: Docstring signature found for function {1} mismatches passed function signature",
_scriptLibrary.Name, function.Name);
return(doc);
}
if (string.IsNullOrWhiteSpace(doc))
{
Log.WriteLineWithHeader("[FirestormDocumentationScraper]: ", "script_library name={0}: Docstring for function {1} is empty",
_scriptLibrary.Name, function.Name);
return(null);
}
Log.WriteLineWithHeader("[FirestormDocumentationScraper]: ", "script_library name={0}: Docstring found for function {1} did not contain a signature",
_scriptLibrary.Name, function.Name);
return(doc);
}
Log.WriteLineWithHeader("[FirestormDocumentationScraper]: ", "script_library name={0}: Function {1} not defined in firestorm data",
_scriptLibrary.Name, function.Name);
return(null);
}
private IEnumerable <LSLLibraryFunctionSignature> ModuleMethods(Type containerType)
{
const BindingFlags bindingFlags = BindingFlags.Default | BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic;
if (ScriptModuleConstantAttribute == null)
{
yield break;
}
var methods = containerType.GetMethods(bindingFlags)
.Where(x =>
x.GetCustomAttributes(ScriptModuleFunctionAttribute, true).Any());
var subsets = _subsetsMap[containerType];
foreach (var v in methods)
{
var returnType = LslTypeFromCsharpType(v.ReturnType);
var pTypes = new GenericArray <LSLParameterSignature>();
foreach (var p in v.GetParameters().Skip(2))
{
var isVariadic = IsParams(p);
if (p.ParameterType == (typeof(object[])) && isVariadic)
{
pTypes.Add(new LSLParameterSignature(LSLType.Void, p.Name, true));
goto omitRestOfParameters;
}
if (isVariadic)
{
Log.WriteLineWithHeader("[OpenSimLibraryDataReflector]: ",
"Optional script module function {0} of type {1}, variadic parameter {2} is an un-recognized data type ({3}), function omitted",
v.Name, containerType.Name, p.Name, p.ParameterType.Name);
goto omitFunction;
}
var type = LslTypeFromCsharpParameterType(p.ParameterType);
if (type != null)
{
pTypes.Add(new LSLParameterSignature(type.Value, p.Name, false));
}
else
{
Log.WriteLineWithHeader("[OpenSimLibraryDataReflector]: ",
"Optional script module function {0} of type {1}, parameter {2} is an un-recognized data type ({3}), function omitted",
v.Name, containerType.Name, p.Name, p.ParameterType.Name);
goto omitFunction;
}
}
omitRestOfParameters:
if (returnType != null)
{
var f = new LSLLibraryFunctionSignature(returnType.Value, v.Name, pTypes);
f.DocumentationString = _documentationProvider.DocumentFunction(f);
f.Subsets.SetSubsets(subsets);
f.ModInvoke = true;
yield return(f);
}
else
{
Log.WriteLineWithHeader("[OpenSimLibraryDataReflector]: ",
"Optional script module {0} of type {1} return type is an un-recognized data type ({2})",
v.Name, containerType.Name, v.ReturnType.Name);
}
omitFunction:
;
}
}
private IEnumerable <LSLLibraryFunctionSignature> InterfaceMethods(Type containerType)
{
foreach (var v in containerType.GetMethods())
{
var subsets = _subsetsMap[containerType];
var returnType = LslTypeFromCsharpType(v.ReturnType);
var pTypes = new GenericArray <LSLParameterSignature>();
foreach (var p in v.GetParameters())
{
var isVariadic = IsParams(p);
if (p.ParameterType == (typeof(object[])) && isVariadic)
{
pTypes.Add(new LSLParameterSignature(LSLType.Void, p.Name, true));
goto omitRestOfParameters;
}
if (isVariadic)
{
Log.WriteLineWithHeader("[OpenSimLibraryDataReflector]: ",
"Interface function {0} of type {1}, variadic parameter {2} is an un-recognized data type ({3}), function omitted",
v.Name, containerType.Name, p.Name, p.ParameterType.Name);
goto omitFunction;
}
var type = LslTypeFromCsharpParameterType(p.ParameterType);
if (type != null)
{
pTypes.Add(new LSLParameterSignature(type.Value, p.Name, false));
}
else
{
Log.WriteLineWithHeader("[OpenSimLibraryDataReflector]: ",
"Interface function {0} of type {1}, parameter {2} is an un-recognized data type ({3}), function omitted",
v.Name, containerType.Name, p.Name, p.ParameterType.Name);
goto omitFunction;
}
}
omitRestOfParameters:
if (returnType != null)
{
var f = new LSLLibraryFunctionSignature(returnType.Value, v.Name, pTypes);
f.DocumentationString = _documentationProvider.DocumentFunction(f);
f.Subsets.SetSubsets(subsets);
yield return(f);
}
else
{
Log.WriteLineWithHeader("[OpenSimLibraryDataReflector]: ",
"function {0} of type {1} return type is an un-recognized data type ({2})",
v.Name, containerType.Name, v.ReturnType.Name);
}
omitFunction:
;
}
}
public string DocumentFunction(LSLLibraryFunctionSignature function)
{
return
_providers.Select(documentationProvider => documentationProvider.DocumentFunction(function))
.FirstOrDefault(d => !string.IsNullOrWhiteSpace(d));
}
/// <summary>
/// Allows modification a function signature after its basic information has been serialized, before its returned.
/// </summary>
/// <param name="serializer">The <see cref="LSLLibraryDataReflectionSerializer" /> this add-on belongs to.</param>
/// <param name="info">The <see cref="MethodInfo" /> object the library function signature was serialized from.</param>
/// <param name="signature">The signature.</param>
/// <returns><c>true</c> if the method needs to be filtered from the results.</returns>
public bool MutateSignature(LSLLibraryDataReflectionSerializer serializer, MethodInfo info,
LSLLibraryFunctionSignature signature)
{
return(Filters.Any(filter => filter.MutateSignature(serializer, info, signature)));
}
public string DocumentFunction(LSLLibraryFunctionSignature function)
{
var v = LLSDLibraryData.DocumentFunction(_data, function.Name);
return(v);
}
