public ParameterDoc(string name, string typeName, ParameterFlags paramFlags) {
ContractUtils.RequiresNotNull(name, "name");
_name = name;
_flags = paramFlags;
_typeName = typeName;
}
public Parameter(ParameterFlags prefix, string name, AstType type, Expression value)
{
this.Prefix = prefix;
this.Name = name.NotNull();
this.Type = type;
this.Value = value;
}
public ParameterInfo(ParameterInfo o)
{
_flags = o._flags;
Name = o.Name;
Format = o.Format;
Type = o.Type;
Description = o.Description;
}
/// <summary>
/// Initializes a new instance of the <see cref="QueryParameter"/> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="value">The value.</param>
public QueryParameter(string name, object value)
{
if (name == null)
throw new ArgumentNullException("name");
flags = ParameterFlags.Named;
this.name = name;
this.value = value;
}
public ParameterDoc(string name, string typeName, string documentation, ParameterFlags paramFlags)
{
ContractUtils.RequiresNotNull(name, "name");
_name = name;
_flags = paramFlags;
_typeName = typeName;
_doc = documentation;
}
public ParameterDoc(string name, string typeName, string documentation, ParameterFlags paramFlags)
{
ContractUtils.RequiresNotNull(name, nameof(name));
Name = name;
Flags = paramFlags;
TypeName = typeName;
Documentation = documentation;
}
/// <summary>
/// Initializes a new instance of the <see cref="QueryParameter"/> class.
/// </summary>
/// <param name="position">The position.</param>
/// <param name="value">The value.</param>
public QueryParameter(int position, object value)
{
if (position < 0)
throw new ArgumentException("Position must be equal or greater than 0", "position");
flags = ParameterFlags.Positional;
this.position = position;
this.value = value;
}
/// <summary>
/// Initializes a new instance of the <see cref="QueryParameter"/> class.
/// </summary>
/// <param name="position">The position.</param>
/// <param name="value">The value.</param>
public QueryParameter(int position, object value)
{
if (position < 0)
{
throw new ArgumentException("Position must be equal or greater than 0", "position");
}
flags = ParameterFlags.Positional;
this.position = position;
this.value = value;
}
/// <summary>
/// Initializes a new instance of the <see cref="QueryParameter"/> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="value">The value.</param>
public QueryParameter(string name, object value)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
flags = ParameterFlags.Named;
this.name = name;
this.value = value;
}
public ParameterNode(Token token,
ParseNodeList attributes,
ParameterFlags flags,
ParseNode type,
AtomicNameNode name)
: base(ParseNodeType.FormalParameter, token) {
_attributes = GetParentedNodeList(AttributeNode.GetAttributeList(attributes));
_flags = flags;
_type = GetParentedNode(type);
_name = (AtomicNameNode)GetParentedNode(name);
}
public ParameterNode(Token token,
ParseNodeList attributes,
ParameterFlags flags,
ParseNode type,
AtomicNameNode name)
: base(ParseNodeType.FormalParameter, token)
{
_attributes = GetParentedNodeList(AttributeNode.GetAttributeList(attributes));
_flags = flags;
_type = GetParentedNode(type);
_name = (AtomicNameNode)GetParentedNode(name);
}
public Parameter(string name, Type type, ParameterFlags flags)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
this.Name = name;
this.Type = type;
this.Flags = flags;
}
public static FunctionType CreateBinaryOperator(Type returnType, Type leftType, Type rightType, ParameterFlags lhsFlags = ParameterFlags.In, ParameterFlags rhsFlags = ParameterFlags.In)
{
var fun = new FunctionType
{
ReturnType = returnType ?? throw new ArgumentNullException(nameof(ReturnType))
};
fun.Parameters = new Parameter[]
{
new Parameter(fun, "lhs", 0)
{
Flags = lhsFlags,
Type = leftType ?? throw new ArgumentNullException(nameof(leftType)),
Initializer = null,
},
public ParameterNode(
Token token,
ParseNodeList attributes,
ParameterFlags flags,
ParseNode type,
AtomicNameNode name,
bool isExtensionMethodTarget = false)
: base(ParseNodeType.FormalParameter, token)
{
Attributes = GetParentedNodeList(AttributeNode.GetAttributeList(attributes));
Flags = flags;
IsExtensionMethodTarget = isExtensionMethodTarget;
Type = GetParentedNode(type);
this.name = (AtomicNameNode)GetParentedNode(name);
}
public static FunctionType CreateUnaryOperator(Type returnType, Type paramType, ParameterFlags paramFlags = ParameterFlags.In)
{
var fun = new FunctionType
{
ReturnType = returnType ?? throw new ArgumentNullException(nameof(ReturnType))
};
fun.Parameters = new Parameter[]
{
new Parameter(fun, "operand", 0)
{
Flags = paramFlags,
Type = paramType ?? throw new ArgumentNullException(nameof(paramType)),
Initializer = null,
},
};
return(fun);
}
internal override void Deserialize(IDefinitionReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
var type = reader.ReadReference <NativeDefinition>();
var flags = (ParameterFlags)reader.ReadValueU8();
var unknownFlags = flags & ~KnownFlags;
if (unknownFlags != ParameterFlags.None)
{
throw new FormatException();
}
this.Type = type;
this.Flags = flags;
}
static ParameterDescription ParamDesc(string name, string semanticName, ShaderVariableType type, ShaderVariableClass @class,
int rows, int columns, SharpDX.Direct3D.InterpolationMode interpolationMode,
ParameterFlags flags, int firstInRegister, int firstInComponent,
int firstOutRegister, int firstOutComponent)
{
return(new ParameterDescription()
{
Name = name,
SemanticName = semanticName,
Type = type,
Class = @class,
Rows = rows,
Columns = columns,
InterpolationMode = interpolationMode,
Flags = flags,
FirstInRegister = firstInRegister,
FirstInComponent = firstInComponent,
FirstOutRegister = firstOutRegister,
FirstOutComponent = firstOutComponent
});
}
private static ICollection <ParameterDoc> GetParameterDocs(PythonFunction pf)
{
ParameterDoc[] res = new ParameterDoc[pf.ArgNames.Length];
for (int i = 0; i < res.Length; i++)
{
ParameterFlags flags = ParameterFlags.None;
if (i == pf.ExpandDictPosition)
{
flags |= ParameterFlags.ParamsDict;
}
else if (i == pf.ExpandListPosition)
{
flags |= ParameterFlags.ParamsArray;
}
res[i] = new ParameterDoc(
pf.ArgNames[i],
flags
);
}
return(res);
}
public static ParameterFlags GetParameterFlags(this ParameterSyntax parameter)
{
ParameterFlags result = 0;
foreach (var modifier in parameter.Modifiers)
{
switch (modifier.Kind())
{
case SyntaxKind.RefKeyword:
result |= ParameterFlags.Ref;
break;
case SyntaxKind.OutKeyword:
result |= ParameterFlags.Out;
break;
case SyntaxKind.ParamsKeyword:
result |= ParameterFlags.Params;
break;
}
}
return(result);
}
public static D3DX_PARAMETER ToD3DX_PARAMETER(this ParameterFlags src)
{
return((D3DX_PARAMETER)src);
}
public ParameterAttribute(string name, string format, bool inverse, ParameterType type, ParameterFlags flags, string description = "")
{
Registration = new ParameterInfo();
Registration.Name = name;
Registration.Format = format;
Registration.Inverse = inverse;
Registration.Type = type;
Registration.Flags = flags;
Registration.Description = description;
}
private ParameterDescription CreateParam(string name, string semanticName, int columns, InterpolationMode interpolationMode, ParameterFlags parameterFlags)
{
return new ParameterDescription
{
Name = name,
SemanticName = semanticName,
Type = ShaderVariableType.Float,
Class = ShaderVariableClass.Vector,
Rows = 1,
Columns = columns,
InterpolationMode = interpolationMode,
Flags = parameterFlags,
FirstInRegister = 0,
FirstInComponent = 0,
FirstOutRegister = 0,
FirstOutComponent = 0
};
}
public ParameterAttribute(string name, string format, ParameterType type, ParameterFlags flags, string description = "")
: this(name, format, false, type, flags, description)
{
}
public ParameterAttribute(string name, string format, bool inverse, ParameterFlags flags, string description = "")
: this(name, format, inverse, ParameterType.String, flags, description)
{
}
private static string GetParameterDirection(ParameterFlags flags)
{
switch (flags)
{
case ParameterFlags.None: return string.Empty;
case ParameterFlags.In: return string.Empty;
case ParameterFlags.Out: return "out ";
case ParameterFlags.In | ParameterFlags.Out: return "ref ";
default:
throw new ArgumentException("Unexpected ParameterFlags value");
}
}
public ParameterAttribute(string helpText, ParameterFlags flags = ParameterFlags.None, Type converter = null)
{
HelpText = helpText;
Flags = flags;
Converter = converter;
}
/// <summary>
/// Constructor used by rehydration
/// </summary>
internal ParameterSetMetadata(
int position,
ParameterFlags flags,
string helpMessage)
{
this.Position = position;
this.Flags = flags;
this.HelpMessage = helpMessage;
}
public ParameterDoc(string name, ParameterFlags paramFlags)
: this(name, null, null, paramFlags)
{
}
private bool IsFlagged(ParameterFlags flag)
{
return ((flags & flag) == flag);
}
public Parameter(AttributeList attributes, ParameterFlags flags, Identifier name, TypeNode type,
Literal defaultValue, MarshallingInformation marshallingInformation)
: base(NodeType.Parameter)
{
this.attributes = attributes;
this.defaultValue = defaultValue;
this.flags = flags;
this.marshallingInformation = marshallingInformation;
this.Name = name;
this.Type = type;
}
public ParamFlagModifier(CodeString Code, ParameterFlags Flags)
: base(Code)
{
this.Flags = Flags;
}
internal ParameterSetMetadata(int position, ParameterFlags flags, string helpMessage)
{
this.Position = position;
this.Flags = flags;
this.HelpMessage = helpMessage;
}
public ParameterExpression AddInternalVariable(Type type, string name = null, ParameterFlags flags = 0)
{
if (string.IsNullOrEmpty(name) || string.IsNullOrWhiteSpace(name))
{
name = "_var$";
}
variables = variables ?? new StructList <Parameter>();
ParameterExpression retn = Expression.Parameter(type, compiler.GetUniqueVariableName(name));
variables.Add(new Parameter()
{
name = retn.Name,
type = retn.Type,
expression = retn,
flags = flags
});
return(retn);
}
private bool IsFlagged(ParameterFlags flag)
{
return((flags & flag) == flag);
}
public ParameterDoc(string name, ParameterFlags paramFlags)
: this(name, null, null, paramFlags) {
}
/// <summary>
/// Initializes a new instance of the <see cref="QueryParameter"/> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="value">The value.</param>
public QueryParameter(String name, ICollection value)
: this(name, (object)value)
{
flags |= ParameterFlags.List;
}
public ParameterAttribute(string name, ParameterType type, ParameterFlags flags, string description = "")
: this(name, null, type, flags, description)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="QueryParameter"/> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="value">The value.</param>
/// <param name="type">The type.</param>
public QueryParameter(String name, ICollection value, IType type)
: this(name, (object) value, type)
{
flags |= ParameterFlags.List;
}
private static ParameterFlags Filter(ParameterFlags flags)
{
return(flags & ~ParameterFlags.This);
}
/// <summary>
/// Creates a DLR OverloadDoc object which describes information about this overload.
/// </summary>
/// <param name="info">The method to document</param>
/// <param name="name">The name of the method if it should override the name in the MethodBase</param>
/// <param name="endParamSkip">Parameters to skip at the end - used for removing the value on a setter method</param>
/// <param name="includeSelf">true to include self on instance methods</param>
public static OverloadDoc GetOverloadDoc(MethodBase info, string name, int endParamSkip, bool includeSelf)
{
string summary = null, returns = null;
List <KeyValuePair <string, string> > parameters = null;
#if FEATURE_XMLDOC
GetXmlDoc(info, out summary, out returns, out parameters);
#endif
StringBuilder retType = new StringBuilder();
int returnCount = 0;
MethodInfo mi = info as MethodInfo;
if (mi != null)
{
if (mi.ReturnType != typeof(void))
{
retType.Append(GetPythonTypeName(mi.ReturnType));
returnCount++;
try {
var typeAttrs = mi.ReturnParameter.GetCustomAttributes(typeof(SequenceTypeInfoAttribute), true);
if (typeAttrs.Any())
{
retType.Append(" (of ");
SequenceTypeInfoAttribute typeAttr = (SequenceTypeInfoAttribute)typeAttrs.First();
for (int curTypeAttr = 0; curTypeAttr < typeAttr.Types.Count; curTypeAttr++)
{
if (curTypeAttr != 0)
{
retType.Append(", ");
}
retType.Append(GetPythonTypeName(typeAttr.Types[curTypeAttr]));
}
retType.Append(")");
}
}
catch (IndexOutOfRangeException) { } // swallow bug in .NET Core
try {
var dictTypeAttrs = mi.ReturnParameter.GetCustomAttributes(typeof(DictionaryTypeInfoAttribute), true);
if (dictTypeAttrs.Any())
{
var dictTypeAttr = (DictionaryTypeInfoAttribute)dictTypeAttrs.First();
retType.Append(String.Format(" (of {0} to {1})", GetPythonTypeName(dictTypeAttr.KeyType), GetPythonTypeName(dictTypeAttr.ValueType)));
}
}
catch (IndexOutOfRangeException) { } // swallow bug in .NET Core
}
if (name == null)
{
var hashIndex = mi.Name.IndexOf('#');
if (hashIndex == -1)
{
name = mi.Name;
}
else
{
name = mi.Name.Substring(0, hashIndex);
}
}
}
else if (name == null)
{
name = "__new__";
}
// For generic methods display either type parameters (for unbound methods) or
// type arguments (for bound ones).
if (mi != null && mi.IsGenericMethod)
{
Type[] typePars = mi.GetGenericArguments();
bool unbound = mi.ContainsGenericParameters;
StringBuilder tmp = new StringBuilder();
tmp.Append(name);
tmp.Append("[");
if (typePars.Length > 1)
{
tmp.Append("(");
}
bool insertComma = false;
foreach (Type t in typePars)
{
if (insertComma)
{
tmp.Append(", ");
}
if (unbound)
{
tmp.Append(t.Name);
}
else
{
tmp.Append(GetPythonTypeName(t));
}
insertComma = true;
}
if (typePars.Length > 1)
{
tmp.Append(")");
}
tmp.Append("]");
name = tmp.ToString();
}
List <ParameterDoc> paramDoc = new List <ParameterDoc>();
if (mi == null)
{
if (name == "__new__")
{
// constructor, auto-insert cls
paramDoc.Add(new ParameterDoc("cls", "type"));
}
}
else if (!mi.IsStatic && includeSelf)
{
paramDoc.Add(new ParameterDoc("self", GetPythonTypeName(mi.DeclaringType)));
}
ParameterInfo[] pis = info.GetParameters();
for (int i = 0; i < pis.Length - endParamSkip; i++)
{
ParameterInfo pi = pis[i];
if (i == 0 && pi.ParameterType == typeof(CodeContext))
{
// hide CodeContext parameters
continue;
}
if ((pi.Attributes & ParameterAttributes.Out) == ParameterAttributes.Out || pi.ParameterType.IsByRef)
{
if (returnCount == 1)
{
retType.Insert(0, "(");
}
if (returnCount != 0)
{
retType.Append(", ");
}
returnCount++;
retType.Append(GetPythonTypeName(pi.ParameterType));
if ((pi.Attributes & ParameterAttributes.Out) == ParameterAttributes.Out)
{
continue;
}
}
ParameterFlags flags = ParameterFlags.None;
if (pi.IsDefined(typeof(ParamArrayAttribute), false))
{
flags |= ParameterFlags.ParamsArray;
}
else if (pi.IsDefined(typeof(ParamDictionaryAttribute), false))
{
flags |= ParameterFlags.ParamsDict;
}
string paramDocString = null;
if (parameters != null)
{
foreach (var paramXmlDoc in parameters)
{
if (paramXmlDoc.Key == pi.Name)
{
paramDocString = paramXmlDoc.Value;
break;
}
}
}
paramDoc.Add(
new ParameterDoc(
pi.Name ?? "", // manufactured methods, such as string[].ctor(int) can have no parameter names.
pi.ParameterType.IsGenericParameter ? pi.ParameterType.Name : GetPythonTypeName(pi.ParameterType),
paramDocString,
flags
)
);
}
if (returnCount > 1)
{
retType.Append(')');
}
ParameterDoc retDoc = new ParameterDoc(String.Empty, retType.ToString(), returns);
return(new OverloadDoc(
name,
summary,
paramDoc,
retDoc
));
}
private ParameterDescription CreateParam(string name, string semanticName, int columns, InterpolationMode interpolationMode, ParameterFlags parameterFlags)
{
return(new ParameterDescription
{
Name = name,
SemanticName = semanticName,
Type = ShaderVariableType.Float,
Class = ShaderVariableClass.Vector,
Rows = 1,
Columns = columns,
InterpolationMode = interpolationMode,
Flags = parameterFlags,
FirstInRegister = 0,
FirstInComponent = 0,
FirstOutRegister = 0,
FirstOutComponent = 0
});
}