int CreateFunctionInstance(TypeBase args, FunctionSyntax syntax, CompoundView compoundView)
{
var index = _list.Count;
var f = new FunctionType(index, syntax, compoundView, args);
_list.Add(f);
return index;
}
internal Value(Func<Category, Result> function, TypeBase source)
: base(_nextObjectId++)
{
Function = function;
Source = source;
Tracer.Assert(Source != null);
}
internal static WebFile FromDbValue(WebFile file, string content, TypeBase type)
{
/*if (url == null) return null;
var u = url.AsUri();
var file =
type == TypeBase.WebImage ? WebImage.FromUrl(u) :
type == TypeBase.WebAudio ? WebAudio.FromUrl(u) :
type == TypeBase.WebVideo ? WebVideo.FromUrl(u) :
WebFile.FromUrl(u);
*/
if (content != null)
{
var serializer = new JsonSerializer();
serializer.AddAwdeeConverters();
using (var sr = new StringReader(content))
using (var jr = Utils.CreateJsonReader(sr))
{
serializer.Deserialize(jr, type.NativeType);
}
}
return file;
}
internal SymmetricClosureService(TypeBase source)
{
Source = source;
AllFeatures = source
.SymmetricFeatureClosure()
.ToArray();
}
public override bool IsAssignableTo(TypeBase other, int depth = 0, bool checkConst = true)
{
if (!base.IsAssignableTo(other, depth, checkConst))
return false;
return other is BoolType;
}
public override bool Equals(TypeBase other)
{
if (!base.Equals(other))
return false;
return other is BoolType;
}
public override bool Equals(TypeBase other)
{
if (!base.Equals(other))
return false;
return IsConstant == other.IsConstant && other is PointerType;
}
public RegisterFrameResource(Frame frame, TypeBase type, Register register)
: base(frame, type)
{
Register = register;
if (type is PointerType)
{
_type = OperandValueType.Dword;
}
else
{
var typePrim = type as PrimitiveType;
if (typePrim == null)
throw new ArgumentException("Type must be a primitive.", nameof(type));
switch (typePrim.Type)
{
case Primitive.Int:
_type = OperandValueType.Dword;
break;
case Primitive.Short:
_type = OperandValueType.Word;
break;
case Primitive.Char:
_type = OperandValueType.Byte;
break;
default:
throw new NotSupportedException();
}
}
}
public ArrayType(TypeBase innerType, int count, bool constant = false)
: base(innerType, constant)
{
if (count <= 0)
throw new ArgumentOutOfRangeException(nameof(count));
Count = count;
}
internal Function(ContextBase parent, TypeBase argsType, TypeBase valueType = null)
: base(parent)
{
_order = CodeArgs.NextOrder++;
ArgsType = argsType;
ValueType = valueType;
StopByObjectIds();
}
protected TypeModifier(TypeBase innerType, bool constant = false)
: base(constant)
{
if (innerType == null)
throw new ArgumentNullException(nameof(innerType));
InnerType = innerType;
}
internal Conversion(Func<Category, Result> function, TypeBase source)
: base(_nextObjectId++)
{
Function = function;
Source = source;
Tracer.Assert(Source != null);
StopByObjectIds();
}
internal Result Result(Category category, Result leftResult, TypeBase right)
{
var rightResult = right
.Conversion(category.Typed, IndexType)
.AutomaticDereferencedAlignedResult();
return Result(category, leftResult + rightResult);
}
public static SearchResult Create(IImplementation feature, TypeBase definingItem)
{
var searchResult = feature as SearchResult;
if(searchResult == null)
return new SearchResult(feature, definingItem);
var source = searchResult.Source;
Tracer.Assert(source == definingItem);
return searchResult;
}
public override bool IsAssignableTo(TypeBase other, int depth = 0, bool checkConst = true)
{
if (!base.IsAssignableTo(other, depth, checkConst))
return false;
if (depth > 0 && other is AnyType)
return true;
return Equals(other);
}
private Type GetClrType(TypeBase t)
{
var clrType = m_typeTable.Get(t);
if (clrType != null)
{
return clrType;
}
CodeClassType ccType = t as CodeClassType;
if (ccType != null)
{
Type baseClass = typeof(Object);
if (ccType.BaseType != null)
{
baseClass = GetClrType(ccType.BaseType);
}
clrType = m_module.DefineType(t.Name, TypeAttributes.Class | TypeAttributes.BeforeFieldInit, baseClass);
m_typeTable.Set(t, clrType);
return clrType;
}
ArrayType aType = t as ArrayType;
if (aType != null)
{
var elementType = GetClrType(aType.ElementType);
clrType = elementType.MakeArrayType();
m_typeTable.Set(t, clrType);
return clrType;
}
PrimaryType pType = t as PrimaryType;
switch (pType.Name)
{
case "int":
clrType = typeof(int);
break;
case "bool":
clrType = typeof(bool);
break;
default:
Debug.Assert(false, "unknown primary type");
break;
}
m_typeTable.Set(t, clrType);
return clrType;
}
public override bool Equals(TypeBase other)
{
if (!base.Equals(other))
return false;
var otherMod = other as TypeModifier;
if (otherMod == null)
return false;
return InnerType.Equals(otherMod.InnerType);
}
public override bool IsAssignableTo(TypeBase other, int depth = 0, bool checkConst = true)
{
if (!base.IsAssignableTo(other, depth, checkConst))
return false;
var otherMod = other as TypeModifier;
if (otherMod == null)
return false;
return InnerType.IsAssignableTo(otherMod.InnerType, depth + 1);
}
public override bool Equals(TypeBase other)
{
if (!base.Equals(other))
return false;
var otherArray = other as ArrayType;
if (otherArray == null)
return false;
return IsConstant == other.IsConstant && Count == otherArray.Count;
}
public override bool Equals(TypeBase other)
{
if (!base.Equals(other))
return false;
var otherPrim = other as PrimitiveType;
if (otherPrim == null)
return false;
return IsConstant == other.IsConstant && Type == otherPrim.Type;
}
public override bool IsAssignableTo(TypeBase other, int depth = 0, bool checkConst = true)
{
if (!base.IsAssignableTo(other, depth, checkConst))
return false;
if (other is PointerType)
return true;
var otherArray = other as ArrayType;
return Count >= otherArray?.Count;
}
public override bool Equals(TypeBase other)
{
if (!base.Equals(other))
return false;
var otherNamed = other as NamedType;
if (otherNamed == null)
return false;
return IsConstant == other.IsConstant && Name == otherNamed.Name;
}
internal FunctionType
(int index, FunctionSyntax body, CompoundView compoundView, TypeBase argsType)
{
Getter = new GetterFunction(this, index, body.Getter);
Setter = body.Setter == null ? null : new SetterFunction(this, index, body.Setter);
Index = index;
Body = body;
_compoundView = compoundView;
ArgsType = argsType;
StopByObjectIds();
}
public override bool IsAssignableFrom(TypeBase type)
{
if (this == type)
{
return true;
}
else
{
return false;
}
}
public FuncType(IList<TypeBase> parameterTypes, TypeBase returnType, bool constant = false)
: base(constant)
{
if (parameterTypes == null)
throw new ArgumentNullException(nameof(parameterTypes));
if (parameterTypes.Any(p => p == null))
throw new ArgumentNullException(nameof(parameterTypes), "contains null entry");
ParameterTypes = new ReadOnlyCollection<TypeBase>(parameterTypes);
ReturnType = returnType;
}
public FrameResource Allocate(TypeBase type, bool canUseRegister = true)
{
if (canUseRegister)
{
var register = TryAllocateRegister();
if (register.HasValue)
return new RegisterFrameResource(this, type, register.Value);
}
var offset = AllocateStack(type.Size);
return new StackFrameResource(this, type, offset, type.Size);
}
public bool TryDefine(string name, TypeBase type, out FrameResource resource)
{
resource = null;
if (IsDefined(name))
return false;
resource = Frame.Allocate(type, false);
_identifiers.Add(name, resource);
return true;
}
public override bool IsAssignableFrom(TypeBase type)
{
CodeClassType elementClassType = ElementType as CodeClassType;
ArrayType arrayType = type as ArrayType;
if (elementClassType != null && arrayType != null)
{
return elementClassType.IsAssignableFrom(arrayType.ElementType);
}
return false;
}
public override bool Equals(TypeBase other)
{
if (!base.Equals(other))
return false;
var otherFunc = other as FuncType;
if (otherFunc == null)
return false;
return IsConstant == other.IsConstant &&
ParameterTypes.SequenceEqual(otherFunc.ParameterTypes) &&
ReturnType == otherFunc.ReturnType;
}
public override bool IsAssignableTo(TypeBase other, int depth = 0, bool checkConst = true)
{
if (!base.IsAssignableTo(other, depth, checkConst))
return false;
if (depth > 0 && other is AnyType)
return true;
var otherPrim = other as PrimitiveType;
if (otherPrim == null)
return false;
return Type == otherPrim.Type || (depth == 0 && otherPrim.Type >= Type);
}
protected override SourceFileGenerator CreateSourceFileGenerator(TypeBase type, bool sort_using, bool generate_document_comment, string compagny_name, string copyright_header, string author)
{
return(new JavaSourceFileGenerator(type, RootNamespace, sort_using, generate_document_comment, compagny_name, copyright_header, author));
}
private static EffectTypeDescription CreateTypeInfo(TypeBase variableType, List <AttributeBase> attributes, out EffectTypeDescription elementType)
{
elementType = default;
var parameterTypeInfo = new EffectTypeDescription();
if (variableType.TypeInference.TargetType != null)
{
variableType = variableType.TypeInference.TargetType;
}
if (variableType is ArrayType)
{
var arrayType = (ArrayType)variableType;
variableType = arrayType.Type;
parameterTypeInfo.Elements = (int)((LiteralExpression)arrayType.Dimensions[0]).Literal.Value;
if (variableType.TypeInference.TargetType != null)
{
variableType = variableType.TypeInference.TargetType;
}
}
if (variableType is ScalarType)
{
if (variableType == ScalarType.Int)
{
parameterTypeInfo.Class = EffectParameterClass.Scalar;
parameterTypeInfo.Type = EffectParameterType.Int;
}
else if (variableType == ScalarType.UInt)
{
parameterTypeInfo.Class = EffectParameterClass.Scalar;
parameterTypeInfo.Type = EffectParameterType.UInt;
}
else if (variableType == ScalarType.Float)
{
parameterTypeInfo.Class = EffectParameterClass.Scalar;
parameterTypeInfo.Type = EffectParameterType.Float;
}
else if (variableType == ScalarType.Double)
{
parameterTypeInfo.Class = EffectParameterClass.Scalar;
parameterTypeInfo.Type = EffectParameterType.Double;
}
else if (variableType == ScalarType.Bool)
{
parameterTypeInfo.Class = EffectParameterClass.Scalar;
parameterTypeInfo.Type = EffectParameterType.Bool;
}
parameterTypeInfo.RowCount = 1;
parameterTypeInfo.ColumnCount = 1;
}
else if (variableType is VectorType vectorType)
{
if (vectorType.Type == ScalarType.Float)
{
bool isColor = attributes.OfType <AttributeDeclaration>().Any(x => x.Name == "Color");
parameterTypeInfo.Class = isColor ? EffectParameterClass.Color : EffectParameterClass.Vector;
parameterTypeInfo.Type = EffectParameterType.Float;
}
else if (vectorType.Type == ScalarType.Double)
{
parameterTypeInfo.Class = EffectParameterClass.Vector;
parameterTypeInfo.Type = EffectParameterType.Double;
}
else if (vectorType.Type == ScalarType.Int)
{
parameterTypeInfo.Class = EffectParameterClass.Vector;
parameterTypeInfo.Type = EffectParameterType.Int;
}
else if (vectorType.Type == ScalarType.UInt)
{
parameterTypeInfo.Class = EffectParameterClass.Vector;
parameterTypeInfo.Type = EffectParameterType.UInt;
}
parameterTypeInfo.RowCount = 1;
parameterTypeInfo.ColumnCount = ((VectorType)variableType).Dimension;
}
else if (variableType is MatrixType)
{
parameterTypeInfo.Class = EffectParameterClass.MatrixColumns;
parameterTypeInfo.Type = EffectParameterType.Float;
parameterTypeInfo.RowCount = ((MatrixType)variableType).RowCount;
parameterTypeInfo.ColumnCount = ((MatrixType)variableType).ColumnCount;
}
else if (variableType is StructType)
{
var structType = (StructType)variableType;
parameterTypeInfo.Class = EffectParameterClass.Struct;
parameterTypeInfo.RowCount = 1;
parameterTypeInfo.ColumnCount = 1;
parameterTypeInfo.Name = structType.Name.Text;
var members = new List <EffectTypeMemberDescription>();
foreach (var field in structType.Fields)
{
var memberInfo = new EffectTypeMemberDescription
{
Name = field.Name.Text,
Type = CreateTypeInfo(field.Type, field.Attributes, out var _),
};
members.Add(memberInfo);
}
parameterTypeInfo.Members = members.ToArray();
}
else
{
var variableTypeName = variableType.Name.Text.ToLowerInvariant();
if (variableType is ClassType classType && classType.GenericArguments.Count == 1)
{
elementType = CreateTypeInfo(classType.GenericArguments[0], new List <AttributeBase>(), out var _);
}
switch (variableTypeName)
{
case "cbuffer":
parameterTypeInfo.Class = EffectParameterClass.ConstantBuffer;
parameterTypeInfo.Type = EffectParameterType.ConstantBuffer;
break;
case "tbuffer":
parameterTypeInfo.Class = EffectParameterClass.TextureBuffer;
parameterTypeInfo.Type = EffectParameterType.TextureBuffer;
break;
case "structuredbuffer":
parameterTypeInfo.Class = EffectParameterClass.ShaderResourceView;
parameterTypeInfo.Type = EffectParameterType.StructuredBuffer;
break;
case "rwstructuredbuffer":
parameterTypeInfo.Class = EffectParameterClass.UnorderedAccessView;
parameterTypeInfo.Type = EffectParameterType.RWStructuredBuffer;
break;
case "consumestructuredbuffer":
parameterTypeInfo.Class = EffectParameterClass.UnorderedAccessView;
parameterTypeInfo.Type = EffectParameterType.ConsumeStructuredBuffer;
break;
case "appendstructuredbuffer":
parameterTypeInfo.Class = EffectParameterClass.UnorderedAccessView;
parameterTypeInfo.Type = EffectParameterType.AppendStructuredBuffer;
break;
case "buffer":
parameterTypeInfo.Class = EffectParameterClass.ShaderResourceView;
parameterTypeInfo.Type = EffectParameterType.Buffer;
break;
case "rwbuffer":
parameterTypeInfo.Class = EffectParameterClass.UnorderedAccessView;
parameterTypeInfo.Type = EffectParameterType.RWBuffer;
break;
case "byteaddressbuffer":
parameterTypeInfo.Class = EffectParameterClass.ShaderResourceView;
parameterTypeInfo.Type = EffectParameterType.ByteAddressBuffer;
break;
case "rwbyteaddressbuffer":
parameterTypeInfo.Class = EffectParameterClass.UnorderedAccessView;
parameterTypeInfo.Type = EffectParameterType.RWByteAddressBuffer;
break;
case "texture1d":
parameterTypeInfo.Class = EffectParameterClass.ShaderResourceView;
parameterTypeInfo.Type = EffectParameterType.Texture1D;
break;
case "texturecube":
parameterTypeInfo.Class = EffectParameterClass.ShaderResourceView;
parameterTypeInfo.Type = EffectParameterType.TextureCube;
break;
case "texture2d":
parameterTypeInfo.Class = EffectParameterClass.ShaderResourceView;
parameterTypeInfo.Type = EffectParameterType.Texture2D;
break;
case "texture2dms":
parameterTypeInfo.Class = EffectParameterClass.ShaderResourceView;
parameterTypeInfo.Type = EffectParameterType.Texture2DMultisampled;
break;
case "texture3d":
parameterTypeInfo.Class = EffectParameterClass.ShaderResourceView;
parameterTypeInfo.Type = EffectParameterType.Texture3D;
break;
case "texture1darray":
parameterTypeInfo.Class = EffectParameterClass.ShaderResourceView;
parameterTypeInfo.Type = EffectParameterType.Texture1DArray;
break;
case "texturecubearray":
parameterTypeInfo.Class = EffectParameterClass.ShaderResourceView;
parameterTypeInfo.Type = EffectParameterType.TextureCubeArray;
break;
case "texture2darray":
parameterTypeInfo.Class = EffectParameterClass.ShaderResourceView;
parameterTypeInfo.Type = EffectParameterType.Texture2DArray;
break;
case "texture2dmsarray":
parameterTypeInfo.Class = EffectParameterClass.ShaderResourceView;
parameterTypeInfo.Type = EffectParameterType.Texture2DMultisampledArray;
break;
case "rwtexture1d":
parameterTypeInfo.Class = EffectParameterClass.UnorderedAccessView;
parameterTypeInfo.Type = EffectParameterType.RWTexture1D;
break;
case "rwtexture2d":
parameterTypeInfo.Class = EffectParameterClass.UnorderedAccessView;
parameterTypeInfo.Type = EffectParameterType.RWTexture2D;
break;
case "rwtexture3d":
parameterTypeInfo.Class = EffectParameterClass.UnorderedAccessView;
parameterTypeInfo.Type = EffectParameterType.RWTexture3D;
break;
case "rwtexture1darray":
parameterTypeInfo.Class = EffectParameterClass.UnorderedAccessView;
parameterTypeInfo.Type = EffectParameterType.RWTexture1DArray;
break;
case "rwtexture2darray":
parameterTypeInfo.Class = EffectParameterClass.UnorderedAccessView;
parameterTypeInfo.Type = EffectParameterType.RWTexture2DArray;
break;
case "samplerstate":
case "samplercomparisonstate":
parameterTypeInfo.Class = EffectParameterClass.Sampler;
parameterTypeInfo.Type = EffectParameterType.Sampler;
break;
}
}
return(parameterTypeInfo);
}
private int ComputeSize(TypeBase type)
{
if (type.TypeInference.TargetType != null)
{
type = type.TypeInference.TargetType;
}
var structType = type as StructType;
if (structType != null)
{
var structSize = 0;
foreach (var field in structType.Fields)
{
var memberSize = ComputeSize(field.Type);
// Seems like this element needs to be split accross multiple lines,
if ((structSize + memberSize - 1) / 16 != structSize / 16)
{
structSize = (structSize + 16 - 1) / 16 * 16;
}
structSize += memberSize;
}
return(structSize);
}
if (type is ScalarType)
{
// Uint and int are collapsed to int
if (type == ScalarType.Int || type == ScalarType.UInt ||
type == ScalarType.Float || type == ScalarType.Bool)
{
return(4);
}
else if (type == ScalarType.Double)
{
return(8);
}
else
{
throw new NotImplementedException();
}
}
var vectorType = type as VectorType;
if (vectorType != null)
{
return(ComputeSize(vectorType.Type) * vectorType.Dimension);
}
var matrixType = type as MatrixType;
if (matrixType is MatrixType)
{
return(4 * (matrixType.ColumnCount - 1) + matrixType.RowCount);
}
throw new NotImplementedException();
}
protected static bool IsTextureType(TypeBase type)
{
// TODO we should improve AST type system
return(type is TextureType || (type is GenericBaseType && type.Name.Text.Contains("Texture")));
}
public int GetIndex(TypeBase type) => typeLookup[type];
/// <summary>
/// Gets the type of the binary implicit conversion.
/// </summary>
/// <param name="span">The span.</param>
/// <param name="left">The left.</param>
/// <param name="right">The right.</param>
/// <param name="isBinaryOperator">if set to <c>true</c> [is binary operator].</param>
/// <returns>
/// The implicit conversion between between to two types
/// </returns>
protected virtual TypeBase GetBinaryImplicitConversionType(SourceSpan span, TypeBase left, TypeBase right, bool isBinaryOperator)
{
var result = CastHelper.GetBinaryImplicitConversionType(left, right, isBinaryOperator);
if (result == null)
{
Error(MessageCode.ErrorBinaryTypeDeduction, span, left, right);
}
return(result);
}
protected abstract SourceFileGenerator CreateSourceFileGenerator(TypeBase type);
private static ForeignKeyAttribute GetForeignKeyAttribute(TypeBase entityType, string propertyName)
=> entityType.GetRuntimeProperties()?.Values
.FirstOrDefault(
p => string.Equals(p.Name, propertyName, StringComparison.OrdinalIgnoreCase) &&
Attribute.IsDefined(p, typeof(ForeignKeyAttribute), inherit: true))
?.GetCustomAttribute <ForeignKeyAttribute>(inherit: true);
/// <exception cref="NullReferenceException">
/// <paramref name="type"/> is null.
/// </exception>
public CSharpSourceFileGenerator(TypeBase type, string rootNamespace)
: base(type, rootNamespace)
{
}
public CSharpTemplateSourceFileGenerator
(TypeBase type, string rootNamespace, Model model)
: base(type, rootNamespace, model)
{}
public static bool IsSamplerType(this TypeBase type)
{
return(Parse(type.Name) != null);
}
public MapType(TypeBase keyType, TypeBase valueType, bool isOptional, IDictionary <string, object> parameters)
: base(isOptional, parameters)
{
this.KeyType = keyType ?? throw new ArgumentNullException(nameof(keyType));
this.ValueType = valueType ?? throw new ArgumentNullException(nameof(valueType));
}
public VectorType(TypeBase elementType, bool isOptional, IDictionary <string, object> parameters)
: base(isOptional, parameters)
{
this.ElementType = elementType ?? throw new ArgumentNullException(nameof(elementType));
}
public ObjectElement(IEnumerable <string> attributes, string name, TypeBase type)
{
this.Attributes = attributes?.ToList() ?? throw new ArgumentNullException(nameof(attributes));
this.Name = name ?? throw new ArgumentNullException(nameof(name));
this.Type = type ?? throw new ArgumentNullException(nameof(type));
}
protected override SourceFileGenerator CreateSourceFileGenerator(TypeBase type)
{
return(new CSharpSourceFileGenerator(type, RootNamespace));
}
private static TemplateData CreateTemplateData <T>(int id, TypeBase typeBase)
{
return(CreateTemplateData <T>(id, typeBase.GetKeyValuePairList()));
}
/// <summary>
/// Gets the type of the binary implicit conversion.
/// </summary>
/// <param name="span">The span.</param>
/// <param name="left">The left.</param>
/// <param name="right">The right.</param>
/// <returns>The implicit conversion between between to two types</returns>
protected virtual TypeBase GetDivideImplicitConversionType(SourceSpan span, TypeBase left, TypeBase right)
{
var result = CastHelper.GetDivideImplicitConversionType(left.ResolveType(), right.ResolveType());
if (result == null)
{
Error(MessageCode.ErrorBinaryTypeDeduction, span, left, right);
}
return(result);
}
private IList <Method> GetMethods(Type type, TypeBase parent)
{
var list = new List <Method>();
// Used for ID generation
var methodNames = new List <string>();
// Get only methods for this object, none of the inherited methods.
foreach (var info in type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance))
{
try
{
if (!info.IsSpecialName)
{
var method = new Method
{
Parent = parent,
ParentClass = parent.Id,
Name = info.Name,
};
// Contains overloads - ID is the hashcode
if (methodNames.Contains(info.Name))
{
method.UseHashCodeForId = true;
}
methodNames.Add(info.Name);
if (info.IsGenericMethod)
{
var arguments = info.GetGenericArguments().Select(genericType => genericType.Name).ToList();
method.Name = info.Name + "<" + string.Join(",", arguments) + ">";
method.UseHashCodeForId = true;
}
try
{
method.Fullname = info.ToString();
method.ReturnType = GetTypeName(info.ReturnType);
method.ReturnTypeFullName = GetFullTypeName(info.ReturnType);
// Get common tags
var element =
_reader.GetComments(info.IsGenericMethod ? info.GetGenericMethodDefinition() : info);
var comments = GetCommonTags(element);
method.Example = comments.Example;
method.Remarks = comments.Remarks;
method.Returns = comments.Returns;
method.Summary = comments.Summary;
method.Parameters = GetMethodParameters(info.GetParameters(), element); // Parameters
}
catch (Exception ex)
{
method.LoadError = true;
method.Fullname = ex.Message;
}
list.Add(method);
}
}
catch (Exception ex)
{
Trace.TraceError("Type {0} : Parse methods Problem. {1} => {2}", type, ex.Message, ex.Source);
}
}
list = list.OrderBy(m => m.Name).ToList();
return(list);
}
protected static bool IsBufferType(TypeBase type)
{
// TODO we should improve AST type system
return((type is GenericBaseType && type.Name.Text.Contains("Buffer")) || type.IsByteAddressBufferType());
}
/// <exception cref="NullReferenceException">
/// <paramref name="type" /> is null.
/// </exception>
public JavaSourceFileGenerator(TypeBase type, string rootNamespace, bool sort_using, bool generate_document_comment, string compagny_name, string copyright_header, string author) : base(type, rootNamespace, sort_using, generate_document_comment, compagny_name, copyright_header, author)
{
}
private static void MapComplexProperties(XElement complexMappingParentElement, MappingBase complexMappingOwner, TypeBase type, ICSharpCode.Data.EDMDesigner.Core.EDMObjects.SSDL.EntityType.EntityType table)
{
foreach (var complexPropertyElement in complexMappingParentElement.Elements(XName.Get("ComplexProperty", mslNamespace.NamespaceName)))
{
var complexProperty = type.AllComplexProperties.GetByName(complexPropertyElement.Attribute("Name").Value);
var complexPropertyMapping = complexMappingOwner[complexProperty];
foreach (var scalarPropertyElement in complexPropertyElement.Elements(XName.Get("ScalarProperty", mslNamespace.NamespaceName)))
{
var scalarProperty = complexProperty.ComplexType.AllScalarProperties.GetByName(scalarPropertyElement.Attribute("Name").Value);
var column = table.Properties.First(c => c.Name == scalarPropertyElement.Attribute("ColumnName").Value);
complexPropertyMapping[scalarProperty, table] = column;
}
MapComplexProperties(complexPropertyElement, complexPropertyMapping, complexProperty.ComplexType, table);
}
}
public override Node Visit(BinaryExpression expression)
{
// First, dispatch to resolve type of node at deeper level
base.Visit(expression);
var leftType = expression.Left.TypeInference.TargetType;
var rightType = expression.Right.TypeInference.TargetType;
var returnType = expression.TypeInference.ExpectedType ?? expression.TypeInference.TargetType;
bool isNumericOperator = true;
switch (expression.Operator)
{
case BinaryOperator.LogicalAnd:
case BinaryOperator.LogicalOr:
isNumericOperator = false;
returnType = GetBinaryImplicitConversionType(expression.Span, leftType, rightType, true);
expression.TypeInference.TargetType = returnType;
break;
case BinaryOperator.Less:
case BinaryOperator.LessEqual:
case BinaryOperator.Greater:
case BinaryOperator.GreaterEqual:
case BinaryOperator.Equality:
case BinaryOperator.Inequality:
isNumericOperator = false;
returnType = GetBinaryImplicitConversionType(expression.Span, leftType, rightType, false);
TypeBase resultType = ScalarType.Bool;
if (returnType is VectorType)
{
resultType = new VectorType(ScalarType.Bool, ((VectorType)returnType).Dimension);
}
else if (returnType is MatrixType)
{
var matrixType = (MatrixType)returnType;
resultType = new MatrixType(ScalarType.Bool, matrixType.RowCount, matrixType.ColumnCount);
}
expression.TypeInference.TargetType = resultType;
break;
}
if (returnType != null)
{
if (returnType == ScalarType.Bool && isNumericOperator)
{
var typeToCheck = leftType ?? rightType;
if (typeToCheck != null)
{
return(ConvertExpressionToBool(expression, typeToCheck));
}
}
}
if (!isNumericOperator || CastHelper.NeedConvertForBinary(leftType, returnType))
{
expression.Left = Cast(leftType, returnType, expression.Left);
}
if (!isNumericOperator || CastHelper.NeedConvertForBinary(rightType, returnType))
{
expression.Right = Cast(rightType, returnType, expression.Right);
}
return(expression);
}
protected TypeShape(TypeBase typeBase) : base(typeBase)
{
MinimumSize = new Size(DefaultWidth, MinimumSize.Height);
typeBase.Modified += delegate { UpdateMinSize(); };
}
public SignalDataSingle()
{
m_type = TypeSingle.Instance;
}
private void FindTypes(Assembly assembly, List <Namespace> namespaces)
{
var typesInAsm = assembly.GetLoadableTypes().Where(p => p.IsPublic || p.IsNestedPublic || p.IsVisible).ToArray();
foreach (var type in typesInAsm)
{
try
{
// The namespace is everything before this type name, e.g. [Docy.Core].XYZ
string typeNamespace = type.Namespace;
var nameSpace = namespaces.FirstOrDefault(n => n.Name == typeNamespace);
if (nameSpace == null)
{
nameSpace = new Namespace {
Name = typeNamespace
};
namespaces.Add(nameSpace);
}
// Comments
var element = _reader.GetComments(type);
var comments = GetCommonTags(element);
var typeBase = new TypeBase
{
Namespace = nameSpace,
IsAbstract = type.IsAbstract,
IsPrimitive = type.IsPrimitive,
IsPublic = type.IsPublic,
IsSealed = type.IsSealed,
IsNested = type.IsNested,
ParentClass = type.BaseType != null ? type.BaseType.FullName : "",
Parents = GetParents(type),
Name = GetTypeName(type),
Fullname = GetFullTypeName(type),
Example = comments.Example,
Remarks = comments.Remarks,
Returns = comments.Returns,
Summary = comments.Summary
};
typeBase.Constructors = GetConstructors(type, typeBase);
typeBase.Methods = GetMethods(type, typeBase);
typeBase.Properties = GetProperties(type, typeBase);
if (type.IsClass)
{
if (type.BaseType != null && type.BaseType == typeof(Delegate) || type.BaseType == typeof(MulticastDelegate))
{
typeBase.ObjectType = "Delegate";
nameSpace.Delegates.Add(typeBase);
}
else
{
typeBase.ObjectType = "Class";
nameSpace.Classes.Add(typeBase);
}
}
else if (type.IsEnum)
{
typeBase.ObjectType = "Enumeration";
typeBase.Members = GetMembers(type);
nameSpace.Enumerations.Add(typeBase);
}
else if (type.IsValueType)
{
typeBase.ObjectType = "Structure";
nameSpace.Structures.Add(typeBase);
}
else if (type.IsInterface)
{
typeBase.ObjectType = "Interface";
nameSpace.Interfaces.Add(typeBase);
}
else
{
typeBase.ObjectType = "Delegate";
// TODO: Find out how to get delegate types
nameSpace.Delegates.Add(typeBase);
}
}
catch (Exception ex)
{
Trace.TraceError("Type {0} : Parse Problem. {1} => {2}", type, ex.Message, ex.Source);
}
}
}
public override string ToString()
{
return(TypeBase.ToString());
}
protected virtual void Visit(TypeBase type)
{
Write(type.Name);
ProcessInitialValueStatus = true;
}
/// <summary>
/// Gets the type of the binary implicit scalar conversion.
/// </summary>
/// <param name="span">The span.</param>
/// <param name="left">The left.</param>
/// <param name="right">The right.</param>
/// <returns>
/// The implicit conversion between the two scalar types
/// </returns>
protected ScalarType GetBinaryImplicitScalarConversionType(SourceSpan span, TypeBase left, TypeBase right)
{
var result = CastHelper.GetBinaryImplicitScalarConversionType(left, right);
if (result == null)
{
Error(MessageCode.ErrorScalarTypeConversion, span, left, right);
}
return(result);
}
public ITypeReference GetReference(TypeBase type) => new TypeReference(this, typeLookup[type]);
public TypeConvert(Expression source, TypeBase targetType)
{
Source = source;
ExpressionType = targetType;
}
