public IRenderRequest CreateInstancedRequest(IRenderContext renderContext, RasterizerState rasterizerState,
BlendState blendState, DepthStencilState depthStencilState, IEffect effect, IEffectParameterSet effectParameterSet,
VertexBuffer meshVertexBuffer, IndexBuffer meshIndexBuffer, PrimitiveType primitiveType,
Matrix[] instanceWorldTransforms, Action<List<Matrix>, VertexBuffer, IndexBuffer> computeCombinedBuffers)
{
throw new NotImplementedException();
}
public RrdPrimitive(RrdUpdater updater, PrimitiveType type, int count, bool isConstant)
{
backend = updater.getRrdBackend();
byteCount = RRD_PRIM_SIZES[(int)type] * count;
pointer = updater.getRrdAllocator().allocate(byteCount);
cachingAllowed = isConstant || backend.isCachingAllowed();
}
private static void InsertBinaryOperationMethod(Core core, ProtoCore.AST.Node root, Operator op, PrimitiveType r, PrimitiveType op1, PrimitiveType op2, int retRank = 0, int op1rank = 0, int op2rank = 0)
{
ProtoCore.AST.AssociativeAST.FunctionDefinitionNode funcDefNode = new ProtoCore.AST.AssociativeAST.FunctionDefinitionNode();
funcDefNode.access = ProtoCore.DSASM.AccessSpecifier.kPublic;
funcDefNode.IsAssocOperator = true;
funcDefNode.IsBuiltIn = true;
funcDefNode.Name = Op.GetOpFunction(op);
funcDefNode.ReturnType = new ProtoCore.Type() { Name = core.TypeSystem.GetType((int)r), UID = (int)r, rank = retRank};
ProtoCore.AST.AssociativeAST.ArgumentSignatureNode args = new ProtoCore.AST.AssociativeAST.ArgumentSignatureNode();
args.AddArgument(new ProtoCore.AST.AssociativeAST.VarDeclNode()
{
memregion = ProtoCore.DSASM.MemoryRegion.kMemStack,
access = ProtoCore.DSASM.AccessSpecifier.kPublic,
NameNode = BuildAssocIdentifier(core, ProtoCore.DSASM.Constants.kLHS),
ArgumentType = new ProtoCore.Type { Name = core.TypeSystem.GetType((int)op1), UID = (int)op1, rank = op1rank}
});
args.AddArgument(new ProtoCore.AST.AssociativeAST.VarDeclNode()
{
memregion = ProtoCore.DSASM.MemoryRegion.kMemStack,
access = ProtoCore.DSASM.AccessSpecifier.kPublic,
NameNode = BuildAssocIdentifier(core, ProtoCore.DSASM.Constants.kRHS),
ArgumentType = new ProtoCore.Type { Name = core.TypeSystem.GetType((int)op2), UID = (int)op2, rank = op2rank}
});
funcDefNode.Signature = args;
ProtoCore.AST.AssociativeAST.CodeBlockNode body = new ProtoCore.AST.AssociativeAST.CodeBlockNode();
ProtoCore.AST.AssociativeAST.IdentifierNode _return = BuildAssocIdentifier(core, ProtoCore.DSDefinitions.Keyword.Return, ProtoCore.PrimitiveType.kTypeReturn);
ProtoCore.AST.AssociativeAST.IdentifierNode lhs = BuildAssocIdentifier(core, ProtoCore.DSASM.Constants.kLHS);
ProtoCore.AST.AssociativeAST.IdentifierNode rhs = BuildAssocIdentifier(core, ProtoCore.DSASM.Constants.kRHS);
body.Body.Add(new ProtoCore.AST.AssociativeAST.BinaryExpressionNode() { LeftNode = _return, Optr = ProtoCore.DSASM.Operator.assign, RightNode = new ProtoCore.AST.AssociativeAST.BinaryExpressionNode() { LeftNode = lhs, RightNode = rhs, Optr = op } });
funcDefNode.FunctionBody = body;
(root as ProtoCore.AST.AssociativeAST.CodeBlockNode).Body.Add(funcDefNode);
}
private Expression MaybeNarrow(PrimitiveType pt, Expression e)
{
if (e.DataType.Size != pt.Size)
return emitter.Cast(pt, e);
else
return e;
}
public Mesh(int vbo, int ibo, int count, PrimitiveType mode)
{
VboId = vbo;
IboId = ibo;
Count = count;
Mode = mode;
}
protected AddressOperand(Address a, PrimitiveType type)
: base(type)
{
if (a == null)
throw new ArgumentNullException("a");
Address = a;
}
public void AddVertex( Vector2 vertex, Color color, PrimitiveType primitiveType )
{
if ( !_hasBegun )
throw new InvalidOperationException( "Begin must be called before AddVertex can be called." );
if ( primitiveType == PrimitiveType.LineStrip || primitiveType == PrimitiveType.TriangleStrip )
throw new NotSupportedException( "The specified primitiveType is not supported by PrimitiveBatch." );
if ( primitiveType == PrimitiveType.TriangleList ) {
if ( _triangleVertsCount >= _triangleVertices.Length )
FlushTriangles();
_triangleVertices[ _triangleVertsCount ].Position = new Vector3( vertex, -0.1f );
_triangleVertices[ _triangleVertsCount ].Color = color;
_triangleVertsCount++;
}
if ( primitiveType == PrimitiveType.LineList ) {
if ( _lineVertsCount >= _lineVertices.Length )
FlushLines();
_lineVertices[ _lineVertsCount ].Position = new Vector3( vertex, 0f );
_lineVertices[ _lineVertsCount ].Color = color;
_lineVertsCount++;
}
}
public SparcArchitecture(PrimitiveType wordWidth)
{
this.WordWidth = wordWidth;
this.PointerType = PrimitiveType.Create(Domain.Pointer, wordWidth.Size);
this.FramePointerType = PointerType;
this.InstructionBitSize = 32;
}
/// <summary>
/// Initializes a new <see cref="VertexBufferObject"/>
/// </summary>
/// <param name="vertexBufferLength">The lenght of the vertex buffer</param>
/// <param name="elementBufferLength">The lenght of the element buffer</param>
/// <param name="primitiveType">The <see cref="OpenTK.Graphics.OpenGL.PrimitiveType"/> used to render the <see cref="VertexBufferObject"/></param>
public VertexBufferObject(int vertexBufferLength, int elementBufferLength, PrimitiveType primitiveType)
{
this.VertexBufferLength = vertexBufferLength;
this.ElementBufferLength = elementBufferLength;
this.PrimitiveType = primitiveType;
this.Initialize();
}
/// <summary>
/// Converts a javascript primitive type to a .NET type.
/// </summary>
/// <param name="type"> The type to convert. </param>
/// <returns> A .NET type. </returns>
public static Type ToType(PrimitiveType type)
{
switch (type)
{
case PrimitiveType.Any:
return typeof(object);
case PrimitiveType.Undefined:
return typeof(Undefined);
case PrimitiveType.Null:
return typeof(Null);
case PrimitiveType.Bool:
return typeof(bool);
case PrimitiveType.Int32:
return typeof(int);
case PrimitiveType.UInt32:
return typeof(uint);
case PrimitiveType.Number:
return typeof(double);
case PrimitiveType.String:
return typeof(string);
case PrimitiveType.ConcatenatedString:
return typeof(ConcatenatedString);
case PrimitiveType.Object:
return typeof(Library.ObjectInstance);
default:
throw new NotImplementedException(string.Format("Unsupported primitive type: {0}", type));
}
}
public Constant CreateConstant(ImmediateOperand imm, PrimitiveType dataWidth)
{
if (dataWidth.BitSize > imm.Width.BitSize)
return Constant.Create(dataWidth, imm.Value.ToInt64());
else
return Constant.Create(imm.Width, imm.Value.ToUInt32());
}
/// <summary>
/// Creates an instance of PowerPcArchitecture.
/// </summary>
/// <param name="wordWidth">Supplies the word width of the PowerPC architecture.</param>
public PowerPcArchitecture(PrimitiveType wordWidth)
{
this.wordWidth = wordWidth;
this.ptrType = PrimitiveType.Create(Domain.Pointer, wordWidth.Size);
this.lr = new RegisterStorage("lr", 0x68, wordWidth);
this.cr = new RegisterStorage("cr", 0x69, wordWidth);
this.ctr = new RegisterStorage("ctr", 0x6A, wordWidth);
this.xer = new RegisterStorage("xer", 0x6B, wordWidth);
this.fpscr = new RegisterStorage("fpscr", 0x6C, wordWidth);
regs = new ReadOnlyCollection<RegisterStorage>(
Enumerable.Range(0, 0x20)
.Select(n => new RegisterStorage("r" + n, n, wordWidth))
.Concat(Enumerable.Range(0, 0x20)
.Select(n => new RegisterStorage("f" + n, n + 0x20, PrimitiveType.Word64)))
.Concat(Enumerable.Range(0, 0x20)
.Select(n => new RegisterStorage("v" + n, n + 0x40, PrimitiveType.Word128)))
.Concat(Enumerable.Range(0, 8)
.Select(n => new RegisterStorage("cr" + n, n + 0x60, PrimitiveType.Byte)))
.Concat(new[] { lr, cr, ctr, xer })
.ToList());
fpregs = new ReadOnlyCollection<RegisterStorage>(
regs.Skip(0x20).Take(0x20).ToList());
vregs = new ReadOnlyCollection<RegisterStorage>(
regs.Skip(0x40).Take(0x20).ToList());
cregs = new ReadOnlyCollection<RegisterStorage>(
regs.Skip(0x60).Take(0x8).ToList());
}
public void Draw(IndexBuffer ibo, PrimitiveType primitiveType)
{
ibo.Draw();
bool bWireframe = (SceneManager.Current.RenderMode == SceneManager.RenderMeshMode.Wireframe);
GL.BindBuffer(BufferTarget.ArrayBuffer, vbo);
GL.EnableClientState(ArrayCap.VertexArray);
GL.EnableClientState(ArrayCap.NormalArray);
GL.EnableClientState(ArrayCap.TextureCoordArray);
if (!bWireframe) { GL.EnableClientState(ArrayCap.ColorArray); }
GL.VertexPointer(3, VertexPointerType.Float, Vertex.Stride, new IntPtr(0));
GL.NormalPointer(NormalPointerType.Float, Vertex.Stride, new IntPtr(Vector3.SizeInBytes));
GL.TexCoordPointer(2, TexCoordPointerType.Float, Vertex.Stride, new IntPtr(2 * Vector3.SizeInBytes));
if (!bWireframe) { GL.ColorPointer(4, ColorPointerType.Float, Vertex.Stride, new IntPtr((2 * Vector3.SizeInBytes) + Vector4.SizeInBytes)); }
GL.DrawElements(primitiveType, ibo.Length, DrawElementsType.UnsignedInt, IntPtr.Zero);
GL.DisableClientState(ArrayCap.VertexArray);
GL.DisableClientState(ArrayCap.NormalArray);
GL.DisableClientState(ArrayCap.TextureCoordArray);
if (!bWireframe) { GL.DisableClientState(ArrayCap.ColorArray);}
GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
}
/// <summary>
/// Checks whether a vertex count is valid for the specified type of primitives
/// </summary>
/// <param name="verticesOrIndices">Number of vertices or indices</param>
/// <param name="type">Type of primitives the vertices will be processed as</param>
/// <returns>
/// True if the specified number is a valid vertex count for the specified
/// type of primitives
/// </returns>
/// <remarks>
/// A zero check is expected to be done in addition to this method. Negative
/// vertex or index counts will result in undefined behavior.
/// </remarks>
public static bool IsValidVertexCount(int verticesOrIndices, PrimitiveType type) {
switch(type) {
#if !XNA_4
case PrimitiveType.PointList: {
return true;
}
#endif
case PrimitiveType.LineStrip: {
return (verticesOrIndices >= 2);
}
case PrimitiveType.LineList: {
return ((verticesOrIndices % 2) == 0);
}
#if !XNA_4
case PrimitiveType.TriangleFan:
#endif
case PrimitiveType.TriangleStrip: {
return (verticesOrIndices >= 3);
}
case PrimitiveType.TriangleList: {
return (verticesOrIndices % 3) == 0;
}
default: { throw new ArgumentException("Invalid primitive type"); }
}
}
public static PrimitiveTopology ConvertPrimitiveType(PrimitiveType primitiveType)
{
switch (primitiveType)
{
case PrimitiveType.PointList:
return PrimitiveTopology.PointList;
case PrimitiveType.LineList:
return PrimitiveTopology.LineList;
case PrimitiveType.LineStrip:
return PrimitiveTopology.LineStrip;
case PrimitiveType.TriangleList:
return PrimitiveTopology.TriangleList;
case PrimitiveType.TriangleStrip:
return PrimitiveTopology.TriangleStrip;
case PrimitiveType.LineListWithAdjacency:
return PrimitiveTopology.LineListWithAdjacency;
case PrimitiveType.LineStripWithAdjacency:
return PrimitiveTopology.LineStripWithAdjacency;
case PrimitiveType.TriangleListWithAdjacency:
return PrimitiveTopology.TriangleListWithAdjacency;
case PrimitiveType.TriangleStripWithAdjacency:
return PrimitiveTopology.TriangleStripWithAdjacency;
default:
throw new ArgumentOutOfRangeException(nameof(primitiveType));
}
}
public VertexArray(PrimitiveType primitive)
{
this.id = GL.GenVertexArray();
this.primitive = primitive;
this.arrays = new Dictionary<string, GLBuffer>();
this.attributes = new Dictionary<int, VertexAttribute>();
}
private static void InsertBinaryOperationMethod(Core core, CodeBlockNode root, Operator op, PrimitiveType r, PrimitiveType op1, PrimitiveType op2, int retRank = 0, int op1rank = 0, int op2rank = 0)
{
FunctionDefinitionNode funcDefNode = new FunctionDefinitionNode();
funcDefNode.access = CompilerDefinitions.AccessModifier.kPublic;
funcDefNode.IsAssocOperator = true;
funcDefNode.IsBuiltIn = true;
funcDefNode.Name = Op.GetOpFunction(op);
funcDefNode.ReturnType = new Type() { Name = core.TypeSystem.GetType((int)r), UID = (int)r, rank = retRank };
ArgumentSignatureNode args = new ArgumentSignatureNode();
args.AddArgument(new VarDeclNode()
{
Access = CompilerDefinitions.AccessModifier.kPublic,
NameNode = AstFactory.BuildIdentifier(DSASM.Constants.kLHS),
ArgumentType = new Type { Name = core.TypeSystem.GetType((int)op1), UID = (int)op1, rank = op1rank }
});
args.AddArgument(new VarDeclNode()
{
Access = CompilerDefinitions.AccessModifier.kPublic,
NameNode = AstFactory.BuildIdentifier(DSASM.Constants.kRHS),
ArgumentType = new Type { Name = core.TypeSystem.GetType((int)op2), UID = (int)op2, rank = op2rank }
});
funcDefNode.Signature = args;
CodeBlockNode body = new CodeBlockNode();
var lhs = AstFactory.BuildIdentifier(DSASM.Constants.kLHS);
var rhs = AstFactory.BuildIdentifier(DSASM.Constants.kRHS);
var binaryExpr = AstFactory.BuildBinaryExpression(lhs, rhs, op);
body.Body.Add(AstFactory.BuildReturnStatement(binaryExpr));
funcDefNode.FunctionBody = body;
root.Body.Add(funcDefNode);
}
/*
* sets the projectile's meshfilter, collider, and
*/
private void assignShape(PrimitiveType shape)
{
//PrimitiveType shape = PrimitiveType.Cylinder;
GameObject obj = GameObject.CreatePrimitive(shape);
obj.transform.position = new Vector3(0,115,0);
MeshFilter filter = this.gameObject.AddComponent<MeshFilter>();
filter.mesh = obj.GetComponent<MeshFilter>().mesh;
transform.localScale = new Vector3(data.xScale, data.yScale, data.zScale);
switch (shape) {
case PrimitiveType.Sphere:
SphereCollider col1 = this.gameObject.AddComponent<SphereCollider>();
col1 = obj.GetComponent<SphereCollider>();
break;
case PrimitiveType.Capsule:
CapsuleCollider col2 = this.gameObject.AddComponent<CapsuleCollider>();
col2 = obj.GetComponent<CapsuleCollider>();
break;
default:
MeshCollider col3 = this.gameObject.AddComponent<MeshCollider>();
col3.sharedMesh = this.GetComponent<MeshFilter>().mesh;
col3.convex = true;
break;
}
MeshRenderer renderer = this.gameObject.AddComponent<MeshRenderer>();
renderer.material = obj.GetComponent<MeshRenderer>().material;
Destroy(obj);
}
/// <summary>
/// Specify which elements shall be drawn by indexing them, specifying an offset and the number of elements.
/// </summary>
/// <param name="vao">
/// The <see cref="VertexArrayObject"/> to which this element belongs to.
/// </param>
/// <param name="mode">
/// A <see cref="PrimitiveType"/> that indicates how elements are interpreted.
/// </param>
protected Element(VertexArrayObject vao, PrimitiveType mode)
{
if (vao == null)
throw new ArgumentNullException("vao");
_VertexArrayObject = vao;
ElementsMode = mode;
}
public DrawableShape( bool useDisplayList )
{
UseDisplayList = useDisplayList;
PrimitiveMode = PrimitiveType.Triangles;
VertexArray = null;
IndexArray = null;
}
public void DrawVertexBuffer(IVertexBuffer<Vertex> buffer, int start, int length, PrimitiveType type, Sheet sheet)
{
shader.SetTexture("DiffuseTexture", sheet.Texture);
renderer.Device.SetBlendMode(BlendMode.Alpha);
shader.Render(() => renderer.DrawBatch(buffer, start, length, type));
renderer.Device.SetBlendMode(BlendMode.None);
}
/// <summary>
/// Read the message header structure and cache the meta data for finding the key fields for decoding messages.
/// </summary>
/// <param name="headerStructure"> for the meta data describing the message header. </param>
public OtfHeaderDecoder(HeaderStructure headerStructure)
{
_size = headerStructure.Tokens[0].Size;
foreach (Token token in headerStructure.Tokens)
{
switch (token.Name)
{
case HeaderStructure.BlockLength:
_blockLengthOffset = token.Offset;
_blockLengthType = token.Encoding.PrimitiveType;
_blockLengthByteOrder = token.Encoding.ByteOrder;
break;
case HeaderStructure.TemplateId:
_templateIdOffset = token.Offset;
_templateIdType = token.Encoding.PrimitiveType;
_templateIdByteOrder = token.Encoding.ByteOrder;
break;
case HeaderStructure.SchemaId:
_schemaIdOffset = token.Offset;
_schemaIdType = token.Encoding.PrimitiveType;
_schemaIdByteOrder = token.Encoding.ByteOrder;
break;
case HeaderStructure.SchemaVersion:
_schemaVersionOffset = token.Offset;
_schemaVersionType = token.Encoding.PrimitiveType;
_schemaVersionByteOrder = token.Encoding.ByteOrder;
break;
}
}
}
public ArmMemoryOperand(PrimitiveType width, RegisterStorage regBase, MachineOperand offset) : base(width)
{
if (width == null)
throw new ArgumentNullException("width");
Base = regBase;
Offset = offset;
}
public Primitive(PrimitiveType _type)
{
id = Guid.NewGuid().ToString();
type = _type;
edges = new List<Edge>();
nodes = new List<Node>();
}
private void RewriteAcbi(PrimitiveType width)
{
var limit = RewriteSrcOp(0, width);
var add = RewriteSrcOp(1, width);
var index = RewriteDstOp(2, width, e => emitter.IAdd(e, add));
NZV(index);
var cAdd = add as Constant;
if (cAdd == null)
throw new AddressCorrelatedException(
dasm.Current.Address,
"Instruction {0] too complex to rewrite.",
dasm.Current);
if (cAdd.ToInt32() >= 0)
{
emitter.Branch(
emitter.Le(index, limit),
((AddressOperand)dasm.Current.Operands[3]).Address,
RtlClass.ConditionalTransfer);
}
else
{
emitter.Branch(
emitter.Ge(index, limit),
((AddressOperand)dasm.Current.Operands[3]).Address,
RtlClass.ConditionalTransfer);
}
rtlc.Class = RtlClass.ConditionalTransfer;
}
public static void DrawMeshArraysSUN(PrimitiveType mode, Int32 first, Int32 count, Int32 width)
{
Debug.Assert(Delegates.pglDrawMeshArraysSUN != null, "pglDrawMeshArraysSUN not implemented");
Delegates.pglDrawMeshArraysSUN((Int32)mode, first, count, width);
LogFunction("glDrawMeshArraysSUN({0}, {1}, {2}, {3})", mode, first, count, width);
DebugCheckErrors(null);
}
public void Draw(PrimitiveType mode, IElementArray elements)
{
using (elements.Bind())
{
_gl.DrawElements(mode, (int)elements.Elements, (uint)elements.Type, IntPtr.Zero);
}
}
public OperandRewriter(M68kArchitecture arch, RtlEmitter emitter, Frame frame, PrimitiveType dataWidth)
{
this.arch = arch;
this.m = emitter;
this.frame = frame;
this.DataWidth = dataWidth;
}
public Primitive()
{
id = Guid.NewGuid().ToString();
type = PrimitiveType.None;
edges = new List<Edge>();
nodes = new List<Node>();
}
private void RewriteFpu3(PrimitiveType width, Func<Expression, Expression, Expression> fn, Action<Expression> genFlags)
{
var op1 = RewriteSrcOp(0, width);
var op2 = RewriteSrcOp(1, width);
var dst = RewriteDstOp(2, width, e => fn(op2, op1));
genFlags(dst);
}
public bool VisitBinaryExpression(BinaryExpression binExp, TypeVariable tv)
{
var eLeft = binExp.Left;
var eRight = binExp.Right;
if (binExp.Operator == Operator.IAdd)
{
var dt = PushAddendDataType(binExp.TypeVariable.DataType, eRight.TypeVariable.DataType);
if (dt != null)
{
MeetDataType(eLeft, dt);
}
dt = PushAddendDataType(binExp.TypeVariable.DataType, eLeft.TypeVariable.DataType);
if (dt != null)
{
MeetDataType(eRight, dt);
}
}
else if (binExp.Operator == Operator.ISub)
{
var dt = PushMinuendDataType(binExp.TypeVariable.DataType, eRight.TypeVariable.DataType);
MeetDataType(eLeft, dt);
dt = PushSubtrahendDataType(binExp.TypeVariable.DataType, eLeft.TypeVariable.DataType);
MeetDataType(eRight, dt);
}
else if (binExp.Operator == Operator.And || binExp.Operator == Operator.Or)
{
//$REVIEW: need a push-logical-Data type to push [[a & 3]] = char into its left and right halves.
var dt = PrimitiveType.CreateWord(tv.DataType.BitSize).MaskDomain(Domain.Boolean | Domain.Integer | Domain.Character);
MeetDataType(eLeft, dt);
MeetDataType(eRight, dt);
}
else if (
binExp.Operator == Operator.IMul ||
binExp.Operator == Operator.IMod)
{
var dt = PrimitiveType.CreateWord(DataTypeOf(eLeft).BitSize).MaskDomain(Domain.Boolean | Domain.Integer);
MeetDataType(eLeft, dt);
dt = PrimitiveType.CreateWord(DataTypeOf(eRight).BitSize).MaskDomain(Domain.Boolean | Domain.Integer);
MeetDataType(eRight, dt);
}
else if (
binExp.Operator == Operator.SMul ||
binExp.Operator == Operator.SDiv)
{
var dt = PrimitiveType.CreateWord(DataTypeOf(eLeft).BitSize).MaskDomain(Domain.Boolean | Domain.SignedInt);
MeetDataType(eLeft, dt);
dt = PrimitiveType.CreateWord(DataTypeOf(eRight).BitSize).MaskDomain(Domain.Boolean | Domain.SignedInt);
MeetDataType(eRight, dt);
}
else if (
binExp.Operator == Operator.UMul ||
binExp.Operator == Operator.UDiv)
{
var dt = PrimitiveType.CreateWord(DataTypeOf(eLeft).BitSize).MaskDomain(Domain.Boolean | Domain.UnsignedInt);
MeetDataType(eLeft, dt);
dt = PrimitiveType.CreateWord(DataTypeOf(eRight).BitSize).MaskDomain(Domain.Boolean | Domain.UnsignedInt);
MeetDataType(eRight, dt);
}
else if (binExp.Operator == Operator.FAdd ||
binExp.Operator == Operator.FSub ||
binExp.Operator == Operator.FMul ||
binExp.Operator == Operator.FDiv)
{
var dt = PrimitiveType.Create(Domain.Real, eLeft.DataType.BitSize);
MeetDataType(eLeft, dt);
dt = PrimitiveType.Create(Domain.Real, eRight.DataType.BitSize);
MeetDataType(eRight, dt);
}
else if (binExp.Operator is SignedIntOperator)
{
var dt = PrimitiveType.CreateWord(eRight.TypeVariable.DataType.BitSize).MaskDomain(Domain.SignedInt | Domain.Character);
MeetDataType(eLeft, dt);
dt = PrimitiveType.CreateWord(eRight.TypeVariable.DataType.BitSize).MaskDomain(Domain.SignedInt | Domain.Character);
MeetDataType(eRight, dt);
}
else if (binExp.Operator is UnsignedIntOperator)
{
var dt = PrimitiveType.CreateWord(eRight.TypeVariable.DataType.BitSize).MaskDomain(Domain.Pointer | Domain.UnsignedInt | Domain.Character);
MeetDataType(eLeft, dt);
dt = PrimitiveType.CreateWord(eRight.TypeVariable.DataType.BitSize).MaskDomain(Domain.Pointer | Domain.UnsignedInt | Domain.Character);
MeetDataType(eRight, dt);
}
else if (binExp.Operator == Operator.Eq || binExp.Operator == Operator.Ne ||
binExp.Operator == Operator.Xor || binExp.Operator == Operator.Cand ||
binExp.Operator == Operator.Cor)
{
// Not much can be deduced here, except that the operands should have the same size. Earlier passes
// already did that work, so just continue with the operands.
}
else if (binExp.Operator is RealConditionalOperator)
{
// We know leaves must be floats
var dt = PrimitiveType.Create(Domain.Real, eLeft.DataType.BitSize);
MeetDataType(eLeft, dt);
dt = PrimitiveType.Create(Domain.Real, eLeft.DataType.BitSize);
MeetDataType(eRight, dt);
}
else if (binExp.Operator == Operator.Shl)
{
var dt = PrimitiveType.CreateWord(tv.DataType.BitSize).MaskDomain(Domain.Boolean | Domain.Integer | Domain.Character);
MeetDataType(eLeft, dt);
dt = PrimitiveType.Create(Domain.Integer, DataTypeOf(eRight).BitSize);
}
else if (binExp.Operator == Operator.Shr)
{
var dt = PrimitiveType.CreateWord(tv.DataType.BitSize).MaskDomain(Domain.Boolean | Domain.UnsignedInt | Domain.Character);
MeetDataType(eLeft, dt);
dt = PrimitiveType.Create(Domain.Integer, DataTypeOf(eRight).BitSize);
}
else if (binExp.Operator == Operator.Sar)
{
var dt = PrimitiveType.CreateWord(tv.DataType.BitSize).MaskDomain(Domain.Boolean | Domain.SignedInt | Domain.Character);
MeetDataType(eLeft, dt);
dt = PrimitiveType.Create(Domain.Integer, DataTypeOf(eRight).BitSize);
}
else
{
throw new NotImplementedException(string.Format("Unhandled binary operator {0} in expression {1}.", binExp.Operator, binExp));
}
eLeft.Accept(this, eLeft.TypeVariable);
eRight.Accept(this, eRight.TypeVariable);
return(false);
}
public OperandRewriter(M68kArchitecture arch, RtlEmitter emitter, IStorageBinder frame, PrimitiveType dataWidth)
{
this.arch = arch;
this.m = emitter;
this.binder = frame;
this.DataWidth = dataWidth;
}
public virtual bool VisitPrimitiveType(PrimitiveType type, TypeQualifiers quals)
{
return(true);
}
public virtual bool VisitPrimitiveType(PrimitiveType type, TypeQualifiers quals)
{
throw new NotImplementedException();
}
public partial void DrawArraysInstanced([Flow(FlowDirection.In)] PrimitiveType mode, [Flow(FlowDirection.In)] int start, [Flow(FlowDirection.In)] uint count, [Flow(FlowDirection.In)] uint primcount);
/// <summary>
/// Initializes a new instance of the ColumnModel class.
///
/// Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources
/// (such as the end user of an application). If input is accepted from such sources it should be validated
/// before being passed to these APIs to protect against SQL injection attacks etc.
/// </summary>
/// <param name="type"> The data type for this column. </param>
/// <param name="typeUsage"> Additional details about the data type. This includes details such as maximum length, nullability etc. </param>
public ColumnModel(PrimitiveTypeKind type, TypeUsage typeUsage)
: base(type, typeUsage)
{
_clrType = PrimitiveType.GetEdmPrimitiveType(type).ClrEquivalentType;
_clrDefaultValue = CreateDefaultValue();
}
// Use this for initialization
void Start()
{
objectCount = 10; // should read from configuration file later on
Regex reg = new Regex(@"^[0-9]+\.json$");
string[] files = Directory.GetFiles(Application.streamingAssetsPath.ToString(), "*");
for (int i = 0; i < files.Length; i++)
{
files[i] = Path.GetFileName(files[i]);
}
files = files.Where(path => reg.IsMatch(path)).ToArray();
frameCount = files.Length; // same for this one
currentFrameNum = 0;
gameDatas = new GameData[frameCount];
gameObjects = new GameObject[objectCount];
for (int i = 0; i < frameCount; i++)
{
string filePath = Path.Combine(Application.streamingAssetsPath, files[i]);
string dataAsJson = File.ReadAllText(filePath);
gameDatas [i] = JsonUtility.FromJson <GameData> (dataAsJson);
}
foreach (BasicObject obj in gameDatas[currentFrameNum].objects)
{
PrimitiveType type = PrimitiveType.Cube;
switch (obj.type)
{
case 0:
type = PrimitiveType.Cube;
break;
case 1:
type = PrimitiveType.Sphere;
break;
case 2:
type = PrimitiveType.Cylinder;
break;
}
gameObjects[obj.id] = GameObject.CreatePrimitive(type);
gameObjects[obj.id].transform.position = obj.position;
gameObjects[obj.id].transform.eulerAngles = obj.orientation;
}
isPlaying = false;
Progress.maxValue = frameCount - 1;
// objs = loadedData.objects;
// for (int i = 0; i < objs.Length; i++) {
// Debug.Log ("object N.O.: " + i);
// Debug.Log ("id: " + objs [i].id);
// Debug.Log ("type: " + objs [i].type);
// Debug.Log ("position: " + objs [i].position);
// Debug.Log ("orientation: " + objs [i].orientation);
// Debug.Log ("linear_velocity: " + objs [i].linear_velocity);
// Debug.Log ("angular_velocity: " + objs [i].angular_velocity);
// Debug.Log ("linear_acceleration: " + objs [i].linear_acceleration);
// Debug.Log ("angular_acceleration: " + objs [i].angular_acceleration);
//
// PrimitiveType type = PrimitiveType.Cube;
// switch (objs [i].type) {
// case 0:
// type = PrimitiveType.Cube;
// break;
// case 1:
// type = PrimitiveType.Sphere;
// break;
// }
//
// GameObject instance = GameObject.CreatePrimitive (type);
// instance.transform.position = objs [i].position;
// instance.transform.eulerAngles = objs [i].orientation;
//
// }
}
public bool TryRead(PrimitiveType dataType, out Constant value) => TryReadBe(dataType, out value);
public IndexedMemoryOperand(RegisterStorage r1, RegisterStorage r2, PrimitiveType width) : base(width)
{
this.Base = r1;
this.Index = r2;
}
public MemoryOperand(RegisterStorage b, Constant offset, PrimitiveType width) : base(width)
{
this.Base = b;
this.Offset = offset;
}
private void RewriteOne(PrimitiveType dt)
{
m.Assign(RewriteSrc(instr.Operands[0]), Constant.Create(dt, 1));
}
private static Mutator <V850Disassembler> Mep(int bitpos, int length, int mask, int shift, PrimitiveType dt)
{
var ep = Registers.ElementPtr;
var field = new Bitfield(bitpos, length);
return((u, d) =>
{
var offset = (mask & (int)field.Read(u)) << shift;
var mem = new MemoryOperand(dt, ep, offset);
d.ops.Add(mem);
return true;
});
}
private void RewriteClr(PrimitiveType dt)
{
m.Assign(RewriteSrc(instr.Operands[0]), Constant.Zero(dt));
}
/// <summary>
/// Stores the value on the top of the stack in the reference.
/// </summary>
/// <param name="generator"> The generator to output the CIL to. </param>
/// <param name="optimizationInfo"> Information about any optimizations that should be performed. </param>
/// <param name="valueType"> The primitive type of the value that is on the top of the stack. </param>
/// <param name="throwIfUnresolvable"> <c>true</c> to throw a ReferenceError exception if
/// the name is unresolvable; <c>false</c> to create a new property instead. </param>
public void GenerateSet(ILGenerator generator, OptimizationInfo optimizationInfo, PrimitiveType valueType, bool throwIfUnresolvable)
{
string propertyName = null;
bool isArrayIndex = false;
//optimizationInfo = optimizationInfo.RemoveFlags(OptimizationFlags.SuppressReturnValue);
// Right-hand-side can be a property name (a.b)
if (this.OperatorType == OperatorType.MemberAccess)
{
var rhs = this.GetOperand(1) as NameExpression;
if (rhs == null)
{
throw new JavaScriptException(optimizationInfo.Engine, ErrorType.SyntaxError, "Invalid member access", optimizationInfo.SourceSpan.StartLine, optimizationInfo.Source.Path, optimizationInfo.FunctionName);
}
propertyName = rhs.Name;
}
// Or a constant indexer (a['b'])
if (this.OperatorType == OperatorType.Index)
{
var rhs = this.GetOperand(1) as LiteralExpression;
if (rhs != null)
{
propertyName = TypeConverter.ToString(rhs.Value);
// Or a array index (a[0])
if (rhs.ResultType == PrimitiveType.Int32 || (propertyName != null && Library.ArrayInstance.ParseArrayIndex(propertyName) != uint.MaxValue))
{
isArrayIndex = true;
}
}
}
// Convert the value to an object and store it in a temporary variable.
var value = generator.CreateTemporaryVariable(typeof(object));
EmitConversion.ToAny(generator, valueType);
generator.StoreVariable(value);
if (isArrayIndex == true)
{
// Array indexer
// -------------
// xxx = object[index]
// Load the left-hand side and convert to an object instance.
var lhs = this.GetOperand(0);
lhs.GenerateCode(generator, optimizationInfo);
EmitConversion.ToObject(generator, lhs.ResultType, optimizationInfo);
// Load the right-hand side and convert to a uint32.
var rhs = this.GetOperand(1);
rhs.GenerateCode(generator, optimizationInfo);
EmitConversion.ToUInt32(generator, rhs.ResultType);
// Call the indexer.
generator.LoadVariable(value);
generator.LoadBoolean(optimizationInfo.StrictMode);
generator.Call(ReflectionHelpers.ObjectInstance_SetPropertyValue_Int);
}
else if (propertyName != null)
{
//// Load the left-hand side and convert to an object instance.
//var lhs = this.GetOperand(0);
//lhs.GenerateCode(generator, optimizationInfo);
//EmitConversion.ToObject(generator, lhs.ResultType);
//// Call the indexer.
//generator.LoadString(propertyName);
//generator.LoadVariable(value);
//generator.LoadBoolean(optimizationInfo.StrictMode);
//generator.Call(ReflectionHelpers.ObjectInstance_SetPropertyValue_String);
// Named property modification (e.g. x.property = y)
// -------------------------------------------------
// __object_cacheKey = null;
// __object_property_cachedIndex = 0;
// ...
// if (__object_cacheKey != object.InlineCacheKey)
// object.InlineSetPropertyValue("property", value, strictMode, out __object_property_cachedIndex, out __object_cacheKey)
// else
// object.InlinePropertyValues[__object_property_cachedIndex] = value;
// Load the left-hand side and convert to an object instance.
var lhs = this.GetOperand(0);
lhs.GenerateCode(generator, optimizationInfo);
EmitConversion.ToObject(generator, lhs.ResultType, optimizationInfo);
// TODO: share these variables somehow.
var cacheKey = generator.DeclareVariable(typeof(object));
var cachedIndex = generator.DeclareVariable(typeof(int));
// Store the object into a temp variable.
var objectInstance = generator.DeclareVariable(PrimitiveType.Object);
generator.StoreVariable(objectInstance);
// if (__object_cacheKey != object.InlineCacheKey)
generator.LoadVariable(cacheKey);
generator.LoadVariable(objectInstance);
generator.Call(ReflectionHelpers.ObjectInstance_InlineCacheKey);
var elseClause = generator.CreateLabel();
generator.BranchIfEqual(elseClause);
// xxx = object.InlineSetPropertyValue("property", value, strictMode, out __object_property_cachedIndex, out __object_cacheKey)
generator.LoadVariable(objectInstance);
generator.LoadString(propertyName);
generator.LoadVariable(value);
generator.LoadBoolean(optimizationInfo.StrictMode);
generator.LoadAddressOfVariable(cachedIndex);
generator.LoadAddressOfVariable(cacheKey);
generator.Call(ReflectionHelpers.ObjectInstance_InlineSetPropertyValue);
var endOfIf = generator.CreateLabel();
generator.Branch(endOfIf);
// else
generator.DefineLabelPosition(elseClause);
// object.InlinePropertyValues[__object_property_cachedIndex] = value;
generator.LoadVariable(objectInstance);
generator.Call(ReflectionHelpers.ObjectInstance_InlinePropertyValues);
generator.LoadVariable(cachedIndex);
generator.LoadVariable(value);
generator.StoreArrayElement(typeof(object));
// End of the if statement
generator.DefineLabelPosition(endOfIf);
}
else
{
// Dynamic property access
// -----------------------
// xxx = object.Get(x)
// Load the left-hand side and convert to an object instance.
var lhs = this.GetOperand(0);
lhs.GenerateCode(generator, optimizationInfo);
EmitConversion.ToObject(generator, lhs.ResultType, optimizationInfo);
// Load the value and convert it to a property key.
var rhs = this.GetOperand(1);
rhs.GenerateCode(generator, optimizationInfo);
EmitConversion.ToPropertyKey(generator, rhs.ResultType);
// Call the indexer.
generator.LoadVariable(value);
generator.LoadBoolean(optimizationInfo.StrictMode);
generator.Call(ReflectionHelpers.ObjectInstance_SetPropertyValue_Object);
}
// The temporary variable is no longer needed.
generator.ReleaseTemporaryVariable(value);
}
//private static
public static void DrawSphereLegacy(Vector3 center, float radius, float precision, bool useWireframe = false)
{
GL.PushAttrib(AttribMask.AllAttribBits);
GL.UseProgram(0);
PrimitiveType primitiveType = PrimitiveType.TriangleStrip;
if (useWireframe)
{
primitiveType = PrimitiveType.LineStrip;
}
if (radius < 0.0f)
{
radius = -radius;
}
if (radius == 0.0f)
{
return;
}
if (precision == 0)
{
return;
}
float halfPI = (float)(Math.PI * 0.5);
float oneThroughPrecision = 1.0f / precision;
float twoPIThroughPrecision = (float)(Math.PI * 2.0 * oneThroughPrecision);
float theta1, theta2, theta3;
Vector3 norm = new Vector3(), pos = new Vector3();
for (uint j = 0; j < precision / 2; j++)
{
theta1 = (j * twoPIThroughPrecision) - halfPI;
theta2 = ((j + 1) * twoPIThroughPrecision) - halfPI;
GL.Begin(primitiveType);
for (uint i = 0; i <= precision; i++)
{
theta3 = i * twoPIThroughPrecision;
norm.X = (float)(Math.Cos(theta2) * Math.Cos(theta3));
norm.Y = (float)Math.Sin(theta2);
norm.Z = (float)(Math.Cos(theta2) * Math.Sin(theta3));
pos.X = center.X + radius * norm.X;
pos.Y = center.Y + radius * norm.Y;
pos.Z = center.Z + radius * norm.Z;
GL.Normal3(norm.X, norm.Y, norm.Z);
GL.TexCoord2(i * oneThroughPrecision, 2.0f * (j + 1) * oneThroughPrecision);
GL.Vertex3(new Vector3(pos.X, pos.Y, pos.Z));// Vector3.TransformPosition(new Vector3(pos.X, pos.Y, pos.Z), transform));
norm.X = (float)(Math.Cos(theta1) * Math.Cos(theta3));
norm.Y = (float)Math.Sin(theta1);
norm.Z = (float)(Math.Cos(theta1) * Math.Sin(theta3));
pos.X = center.X + radius * norm.X;
pos.Y = center.Y + radius * norm.Y;
pos.Z = center.Z + radius * norm.Z;
GL.Normal3(norm.X, norm.Y, norm.Z);
GL.TexCoord2(i * oneThroughPrecision, 2.0f * j * oneThroughPrecision);
GL.Vertex3(new Vector3(pos.X, pos.Y, pos.Z));
}
GL.End();
}
GL.PopAttrib();
}
public override TypeUsage GetEdmType(TypeUsage storeType)
{
if (storeType == null)
{
throw new ArgumentNullException("storeType");
}
string storeTypeName = storeType.EdmType.Name;
PrimitiveType primitiveType = StoreTypeNameToEdmPrimitiveType[storeTypeName];
// TODO: come up with way to determin if unicode is used
bool isUnicode = true;
Facet facet;
switch (storeTypeName)
{
case "bool":
case "int2":
case "int4":
case "int8":
case "float4":
case "float8":
case "uuid":
return(TypeUsage.CreateDefaultTypeUsage(primitiveType));
case "numeric":
{
byte scale;
byte precision;
if (storeType.Facets.TryGetValue(ScaleFacet, false, out facet) &&
!facet.IsUnbounded && facet.Value != null)
{
scale = (byte)facet.Value;
if (storeType.Facets.TryGetValue(PrecisionFacet, false, out facet) &&
!facet.IsUnbounded && facet.Value != null)
{
precision = (byte)facet.Value;
return(TypeUsage.CreateDecimalTypeUsage(primitiveType, precision, scale));
}
}
return(TypeUsage.CreateDecimalTypeUsage(primitiveType));
}
case "bpchar":
if (storeType.Facets.TryGetValue(MaxLengthFacet, false, out facet) &&
!facet.IsUnbounded && facet.Value != null)
{
return(TypeUsage.CreateStringTypeUsage(primitiveType, isUnicode, true, (int)facet.Value));
}
else
{
return(TypeUsage.CreateStringTypeUsage(primitiveType, isUnicode, true));
}
case "varchar":
if (storeType.Facets.TryGetValue(MaxLengthFacet, false, out facet) &&
!facet.IsUnbounded && facet.Value != null)
{
return(TypeUsage.CreateStringTypeUsage(primitiveType, isUnicode, false, (int)facet.Value));
}
else
{
return(TypeUsage.CreateStringTypeUsage(primitiveType, isUnicode, false));
}
case "text":
case "xml":
return(TypeUsage.CreateStringTypeUsage(primitiveType, isUnicode, false));
case "timestamp":
// TODO: make sure the arguments are correct here
if (storeType.Facets.TryGetValue(PrecisionFacet, false, out facet) &&
!facet.IsUnbounded && facet.Value != null)
{
return(TypeUsage.CreateDateTimeTypeUsage(primitiveType, (byte)facet.Value));
}
else
{
return(TypeUsage.CreateDateTimeTypeUsage(primitiveType, null));
}
case "date":
return(TypeUsage.CreateDateTimeTypeUsage(primitiveType, 0));
case "timestamptz":
if (storeType.Facets.TryGetValue(PrecisionFacet, false, out facet) &&
!facet.IsUnbounded && facet.Value != null)
{
return(TypeUsage.CreateDateTimeOffsetTypeUsage(primitiveType, (byte)facet.Value));
}
else
{
return(TypeUsage.CreateDateTimeOffsetTypeUsage(primitiveType, null));
}
case "time":
case "interval":
if (storeType.Facets.TryGetValue(PrecisionFacet, false, out facet) &&
!facet.IsUnbounded && facet.Value != null)
{
return(TypeUsage.CreateTimeTypeUsage(primitiveType, (byte)facet.Value));
}
else
{
return(TypeUsage.CreateTimeTypeUsage(primitiveType, null));
}
case "bytea":
{
if (storeType.Facets.TryGetValue(MaxLengthFacet, false, out facet) &&
!facet.IsUnbounded && facet.Value != null)
{
return(TypeUsage.CreateBinaryTypeUsage(primitiveType, false, (int)facet.Value));
}
return(TypeUsage.CreateBinaryTypeUsage(primitiveType, false));
}
case "rowversion":
{
return(TypeUsage.CreateBinaryTypeUsage(primitiveType, true, 8));
}
//TypeUsage.CreateBinaryTypeUsage
//TypeUsage.CreateDateTimeTypeUsage
//TypeUsage.CreateDecimalTypeUsage
//TypeUsage.CreateStringTypeUsage
}
throw new NotSupportedException("Not supported store type: " + storeTypeName);
}
public override TypeUsage GetStoreType(TypeUsage edmType)
{
if (edmType == null)
{
throw new ArgumentNullException("edmType");
}
PrimitiveType primitiveType = edmType.EdmType as PrimitiveType;
if (primitiveType == null)
{
throw new ArgumentException("Store does not support specified edm type");
}
// TODO: come up with way to determin if unicode is used
bool isUnicode = true;
Facet facet;
switch (primitiveType.PrimitiveTypeKind)
{
case PrimitiveTypeKind.Boolean:
return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["bool"]));
case PrimitiveTypeKind.Int16:
return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["int2"]));
case PrimitiveTypeKind.Int32:
return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["int4"]));
case PrimitiveTypeKind.Int64:
return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["int8"]));
case PrimitiveTypeKind.Single:
return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["float4"]));
case PrimitiveTypeKind.Double:
return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["float8"]));
case PrimitiveTypeKind.Decimal:
{
byte scale;
byte precision;
if (edmType.Facets.TryGetValue(ScaleFacet, false, out facet) &&
!facet.IsUnbounded && facet.Value != null)
{
scale = (byte)facet.Value;
if (edmType.Facets.TryGetValue(PrecisionFacet, false, out facet) &&
!facet.IsUnbounded && facet.Value != null)
{
precision = (byte)facet.Value;
return(TypeUsage.CreateDecimalTypeUsage(StoreTypeNameToStorePrimitiveType["numeric"], precision, scale));
}
}
return(TypeUsage.CreateDecimalTypeUsage(StoreTypeNameToStorePrimitiveType["numeric"]));
}
case PrimitiveTypeKind.String:
{
// TODO: could get character, character varying, text
if (edmType.Facets.TryGetValue(FixedLengthFacet, false, out facet) &&
!facet.IsUnbounded && facet.Value != null && (bool)facet.Value)
{
PrimitiveType characterPrimitive = StoreTypeNameToStorePrimitiveType["bpchar"];
if (edmType.Facets.TryGetValue(MaxLengthFacet, false, out facet) &&
!facet.IsUnbounded && facet.Value != null)
{
return(TypeUsage.CreateStringTypeUsage(characterPrimitive, isUnicode, true, (int)facet.Value));
}
// this may not work well
return(TypeUsage.CreateStringTypeUsage(characterPrimitive, isUnicode, true));
}
if (edmType.Facets.TryGetValue(MaxLengthFacet, false, out facet) &&
!facet.IsUnbounded && facet.Value != null)
{
return(TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["varchar"], isUnicode, false, (int)facet.Value));
}
// assume text since it is not fixed length and has no max length
return(TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["text"], isUnicode, false));
}
case PrimitiveTypeKind.DateTime:
if (edmType.Facets.TryGetValue(PrecisionFacet, false, out facet) &&
!facet.IsUnbounded && facet.Value != null)
{
return(TypeUsage.CreateDateTimeTypeUsage(StoreTypeNameToStorePrimitiveType["timestamp"], (byte)facet.Value));
}
else
{
return(TypeUsage.CreateDateTimeTypeUsage(StoreTypeNameToStorePrimitiveType["timestamp"], null));
}
case PrimitiveTypeKind.DateTimeOffset:
if (edmType.Facets.TryGetValue(PrecisionFacet, false, out facet) &&
!facet.IsUnbounded && facet.Value != null)
{
return(TypeUsage.CreateDateTimeOffsetTypeUsage(StoreTypeNameToStorePrimitiveType["timestamptz"], (byte)facet.Value));
}
else
{
return(TypeUsage.CreateDateTimeOffsetTypeUsage(StoreTypeNameToStorePrimitiveType["timestamptz"], null));
}
case PrimitiveTypeKind.Time:
if (edmType.Facets.TryGetValue(PrecisionFacet, false, out facet) &&
!facet.IsUnbounded && facet.Value != null)
{
return(TypeUsage.CreateTimeTypeUsage(StoreTypeNameToStorePrimitiveType["interval"], (byte)facet.Value));
}
else
{
return(TypeUsage.CreateTimeTypeUsage(StoreTypeNameToStorePrimitiveType["interval"], null));
}
case PrimitiveTypeKind.Binary:
{
if (edmType.Facets.TryGetValue(MaxLengthFacet, false, out facet) &&
!facet.IsUnbounded && facet.Value != null)
{
return(TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["bytea"], false, (int)facet.Value));
}
return(TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["bytea"], false));
}
case PrimitiveTypeKind.Guid:
return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["uuid"]));
case PrimitiveTypeKind.Byte:
case PrimitiveTypeKind.SByte:
return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["int2"]));
}
throw new NotSupportedException("Not supported edm type: " + edmType);
}
public void DrawPrimitives(PrimitiveType pt, int firstVertex, int numVertices)
{
VerifyThreadAffinity();
OpenGL.glDrawArrays(ModeFromPrimitiveType(pt), firstVertex, numVertices);
OpenGL.CheckGLError();
}
public MemoryOperand(PrimitiveType dataWidth) : base(dataWidth)
{
}
private bool TryDecodeOperand(PrimitiveType width, int maxReg, out MachineOperand op)
{
op = null !;
if (!rdr.TryReadByte(out byte bSpecifier))
{
return(false);
}
var reg = arch.GetRegister(bSpecifier & 0xF) !;
switch (bSpecifier >> 4)
{
case 0: // Literal mode
case 1:
case 2:
case 3:
op = LiteralOperand(width, bSpecifier);
break;
case 4: // Index mode
op = IndexOperand(width, reg) !;
if (op == null)
{
return(false);
}
break;
case 5: // Register mode
if (reg.Number > maxReg)
{
return(false);
}
op = new RegisterOperand(reg);
break;
case 6: // Register deferred
op = new MemoryOperand(width)
{
Base = new RegisterOperand(reg)
};
break;
case 7: // Autodecrement mode
op = new MemoryOperand(width)
{
Base = new RegisterOperand(reg),
AutoDecrement = true,
};
break;
case 8: // Autoincrement mode
if (reg.Number == 0x0F)
{
op = ImmediateOperand(width) !;
return(op != null);
}
else
{
op = new MemoryOperand(width)
{
Base = new RegisterOperand(reg),
AutoIncrement = true,
};
}
break;
case 9: // Deferred Autoincrement mode
op = new MemoryOperand(width)
{
Base = new RegisterOperand(reg),
AutoIncrement = true,
Deferred = true,
};
break;
case 0xA: // Displacement mode
case 0xB:
if (!rdr.TryReadByte(out byte b))
{
return(false);
}
op = DisplacementOperand(width, reg, Constant.SByte((sbyte)b), bSpecifier);
break;
case 0xC:
case 0xD:
if (!rdr.TryReadUInt16(out ushort w))
{
return(false);
}
op = DisplacementOperand(width, reg, Constant.Int16((short)w), bSpecifier);
break;
case 0xE:
case 0xF:
if (!rdr.TryReadUInt32(out uint dw))
{
return(false);
}
op = DisplacementOperand(width, reg, Constant.Word32(dw), bSpecifier);
break;
default:
throw new InvalidCastException("Impossiburu!");
}
return(true);
}
public abstract bool TryRead(MemoryArea mem, Address addr, PrimitiveType dt, out Constant value);
public void Crate_creates_store_function_for_enum_type_function_import()
{
var model = new DbModelBuilder()
.Build(new DbProviderInfo("System.Data.SqlClient", "2012"));
var enumTypeCtor = typeof(EnumType).GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance).Single(c => c.GetParameters().Count() == 5);
var enumType = (EnumType)enumTypeCtor.Invoke(BindingFlags.NonPublic | BindingFlags.Instance, null,
new object[] { "TestEnumType", "Model", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), false, DataSpace.CSpace },
CultureInfo.InvariantCulture);
var functionDescriptor =
new FunctionDescriptor(
"f",
new[] { new ParameterDescriptor("p1", enumType, null, false) },
new EdmType[] { enumType },
"ResultCol",
"dbo",
StoreFunctionKind.TableValuedFunction,
isBuiltIn: null,
isNiladic: null);
var storeFunction = new StoreFunctionBuilder(model, "docs", "ns").Create(functionDescriptor);
Assert.Equal(
BuiltInTypeKind.CollectionType,
storeFunction.ReturnParameter.TypeUsage.EdmType.BuiltInTypeKind);
var collectionItemType =
(RowType)((CollectionType)storeFunction.ReturnParameter.TypeUsage.EdmType).TypeUsage.EdmType;
Assert.Single(collectionItemType.Properties);
Assert.Equal("ResultCol", collectionItemType.Properties[0].Name);
Assert.Equal("int", collectionItemType.Properties[0].TypeUsage.EdmType.Name);
Assert.Single(storeFunction.Parameters);
Assert.Equal("p1", storeFunction.Parameters[0].Name);
Assert.Equal("int", storeFunction.Parameters[0].TypeName);
Assert.Equal(ParameterMode.In, storeFunction.Parameters[0].Mode);
Assert.True(storeFunction.IsComposableAttribute);
}
/// <summary>
/// Returns the list of key properties defined on <paramref name="type"/>; null if <paramref name="type"/> is complex.
/// </summary>
/// <param name="type">Type in question.</param>
/// <param name="hasProperties">true if <paramref name="type"/> has any (declared or inherited) properties; otherwise false.</param>
/// <returns>Returns the list of key properties defined on <paramref name="type"/>; null if <paramref name="type"/> is complex.</returns>
internal static PropertyInfo[] GetKeyPropertiesOnType(Type type, out bool hasProperties)
{
if (CommonUtil.IsUnsupportedType(type))
{
throw new InvalidOperationException(c.Strings.ClientType_UnsupportedType(type));
}
string typeName = type.ToString();
IEnumerable <object> customAttributes = type.GetCustomAttributes(true);
bool isEntity = customAttributes.OfType <EntityTypeAttribute>().Any();
KeyAttribute dataServiceKeyAttribute = customAttributes.OfType <KeyAttribute>().FirstOrDefault();
List <PropertyInfo> keyProperties = new List <PropertyInfo>();
PropertyInfo[] properties = ClientTypeUtil.GetPropertiesOnType(type, false /*declaredOnly*/).ToArray();
hasProperties = properties.Length > 0;
KeyKind currentKeyKind = KeyKind.NotKey;
KeyKind newKeyKind = KeyKind.NotKey;
foreach (PropertyInfo propertyInfo in properties)
{
if ((newKeyKind = ClientTypeUtil.IsKeyProperty(propertyInfo, dataServiceKeyAttribute)) != KeyKind.NotKey)
{
if (newKeyKind > currentKeyKind)
{
keyProperties.Clear();
currentKeyKind = newKeyKind;
keyProperties.Add(propertyInfo);
}
else if (newKeyKind == currentKeyKind)
{
keyProperties.Add(propertyInfo);
}
}
}
Type keyPropertyDeclaringType = null;
foreach (PropertyInfo key in keyProperties)
{
if (null == keyPropertyDeclaringType)
{
keyPropertyDeclaringType = key.DeclaringType;
}
else if (keyPropertyDeclaringType != key.DeclaringType)
{
throw c.Error.InvalidOperation(c.Strings.ClientType_KeysOnDifferentDeclaredType(typeName));
}
if (!PrimitiveType.IsKnownType(key.PropertyType))
{
throw c.Error.InvalidOperation(c.Strings.ClientType_KeysMustBeSimpleTypes(key.Name, typeName, key.PropertyType.FullName));
}
}
if (newKeyKind == KeyKind.AttributedKey && keyProperties.Count != dataServiceKeyAttribute.KeyNames.Count)
{
var m = (from string a in dataServiceKeyAttribute.KeyNames
where null == (from b in properties
where b.Name == a
select b).FirstOrDefault()
select a).First <string>();
throw c.Error.InvalidOperation(c.Strings.ClientType_MissingProperty(typeName, m));
}
return(keyProperties.Count > 0 ? keyProperties.ToArray() : (isEntity ? ClientTypeUtil.EmptyPropertyInfoArray : null));
}
/// <summary>
/// Is the type or element type (in the case of nullableOfT or IEnumOfT) a Entity Type?
/// </summary>
/// <param name="type">Type to examine</param>
/// <returns>bool indicating whether or not entity type</returns>
internal static bool TypeOrElementTypeIsEntity(Type type)
{
type = TypeSystem.GetElementType(type);
type = Nullable.GetUnderlyingType(type) ?? type;
return(!PrimitiveType.IsKnownType(type) && ClientTypeUtil.GetKeyPropertiesOnType(type) != null);
}
/// <summary>Returns the list of properties defined on <paramref name="type"/>.</summary>
/// <param name="type">Type instance in question.</param>
/// <param name="declaredOnly">True to to get the properties declared on <paramref name="type"/>; false to get all properties defined on <paramref name="type"/>.</param>
/// <returns>Returns the list of properties defined on <paramref name="type"/>.</returns>
internal static IEnumerable <PropertyInfo> GetPropertiesOnType(Type type, bool declaredOnly)
{
if (!PrimitiveType.IsKnownType(type))
{
foreach (PropertyInfo propertyInfo in type.GetPublicProperties(true /*instanceOnly*/, declaredOnly))
{
//// examples where class<PropertyType>
//// the normal examples
//// PropertyType Property { get; set }
//// Nullable<PropertyType> Property { get; set; }
//// if 'Property: struct' then we would be unable set the property during construction (and have them stick)
//// but when its a class, we can navigate if non-null and set the nested properties
//// PropertyType Property { get; } where PropertyType: class
//// we do support adding elements to collections
//// ICollection<PropertyType> { get; /*ignored set;*/ }
//// indexed properties are not suported because
//// we don't have anything to use as the index
//// PropertyType Property[object x] { /*ignored get;*/ /*ignored set;*/ }
//// also ignored
//// if PropertyType.IsPointer (like byte*)
//// if PropertyType.IsArray except for byte[] and char[]
//// if PropertyType == IntPtr or UIntPtr
//// Properties overriding abstract or virtual properties on a base type
//// are also ignored (because they are part of the base type declaration
//// and not of the derived type).
Type propertyType = propertyInfo.PropertyType; // class / interface / value
propertyType = Nullable.GetUnderlyingType(propertyType) ?? propertyType;
if (propertyType.IsPointer ||
(propertyType.IsArray && (typeof(byte[]) != propertyType) && typeof(char[]) != propertyType) ||
(typeof(IntPtr) == propertyType) ||
(typeof(UIntPtr) == propertyType))
{
continue;
}
// Ignore properties overriding abstract/virtual properties of a base type
// when only getting the declared properties (otherwise the property will
// only be included once in the property list anyways).
if (declaredOnly && IsOverride(type, propertyInfo))
{
continue;
}
Debug.Assert(!propertyType.ContainsGenericParameters(), "remove when test case is found that encounters this");
if (propertyInfo.CanRead &&
(!propertyType.IsValueType() || propertyInfo.CanWrite) &&
!propertyType.ContainsGenericParameters() &&
(0 == propertyInfo.GetIndexParameters().Length))
{
yield return(propertyInfo);
}
}
}
}
public override TypePrinterResult VisitPrimitiveType(PrimitiveType type,
TypeQualifiers quals)
{
return(VisitPrimitiveType(type));
}
public Expression RewriteUnary(
MachineOperand operand,
Address addrInstr,
PrimitiveType dataWidth,
Func <Expression, Expression> opGen)
{
var reg = operand as RegisterOperand;
if (reg != null)
{
Expression r = binder.EnsureRegister(reg.Register);
if (r.DataType.Size > dataWidth.Size)
{
var tmp = binder.CreateTemporary(dataWidth);
m.Assign(tmp, opGen(m.Cast(dataWidth, r)));
m.Assign(r, m.Dpb(r, tmp, 0));
return(tmp);
}
else
{
m.Assign(r, opGen(r));
return(r);
}
}
var addr = operand as M68kAddressOperand;
if (addr != null)
{
var load = m.Load(dataWidth, addr.Address);
var tmp = binder.CreateTemporary(dataWidth);
m.Assign(tmp, opGen(load));
m.Assign(load, tmp);
return(tmp);
}
var mem = operand as MemoryOperand;
if (mem != null)
{
var load = RewriteMemoryAccess(mem, dataWidth, addrInstr);
var tmp = binder.CreateTemporary(dataWidth);
m.Assign(tmp, opGen(load));
m.Assign(RewriteMemoryAccess(mem, dataWidth, addrInstr), tmp);
return(tmp);
}
var post = operand as PostIncrementMemoryOperand;
if (post != null)
{
var r = binder.EnsureRegister(post.Register);
var tmp = binder.CreateTemporary(dataWidth);
m.Assign(tmp, opGen(m.Load(dataWidth, r)));
m.Assign(m.Load(dataWidth, r), tmp);
m.Assign(r, m.IAdd(r, dataWidth.Size));
return(tmp);
}
var pre = operand as PredecrementMemoryOperand;
if (pre != null)
{
var r = binder.EnsureRegister(pre.Register);
m.Assign(r, m.ISub(r, dataWidth.Size));
var tmp = binder.CreateTemporary(dataWidth);
m.Assign(tmp, opGen(m.Load(dataWidth, r)));
m.Assign(m.Load(dataWidth, r), tmp);
return(tmp);
}
throw new NotImplementedException("Unimplemented RewriteUnary for operand type " + operand.ToString());
}
public Expression RewriteMoveDst(MachineOperand opDst, Address addrInstr, PrimitiveType dataWidth, Expression src)
{
var reg = opDst as RegisterOperand;
if (reg != null)
{
var r = binder.EnsureRegister(reg.Register);
if (r.DataType.Size > dataWidth.Size)
{
var tmp = binder.CreateTemporary(dataWidth);
m.Assign(r, m.Dpb(r, src, 0));
return(tmp);
}
else
{
m.Assign(r, src);
return(r);
}
}
var mem = opDst as MemoryOperand;
if (mem != null)
{
src = Spill(src, binder.EnsureRegister(mem.Base));
var load = RewriteMemoryAccess(mem, dataWidth, addrInstr);
var tmp = binder.CreateTemporary(dataWidth);
m.Assign(load, src);
return(tmp);
}
var post = opDst as PostIncrementMemoryOperand;
if (post != null)
{
var r = binder.EnsureRegister(post.Register);
var rExp = Spill(src, r);
var load = m.Load(dataWidth, r);
m.Assign(load, rExp);
m.Assign(r, m.IAdd(r, dataWidth.Size));
return(src);
}
var pre = opDst as PredecrementMemoryOperand;
if (pre != null)
{
var r = binder.EnsureRegister(pre.Register);
m.Assign(r, m.ISub(r, dataWidth.Size));
var rExp = Spill(src, r);
var load = m.Load(dataWidth, rExp);
m.Assign(load, src);
return(src);
}
var idxop = opDst as IndexedOperand;
if (idxop != null)
{
var b = binder.EnsureRegister(idxop.base_reg);
var i = binder.EnsureRegister(idxop.index_reg);
var s = m.Const(i.DataType, idxop.index_scale);
var load = m.Load(dataWidth, m.IAdd(b, m.IMul(i, s)));
m.Assign(load, src);
return(src);
}
var indidx = opDst as IndirectIndexedOperand;
if (indidx != null)
{
var a = binder.EnsureRegister(indidx.ARegister);
var x = binder.EnsureRegister(indidx.XRegister);
var load = m.Load(dataWidth, m.IAdd(a, x));
m.Assign(load, src);
return(src);
}
var mAddr = opDst as M68kAddressOperand;
if (mAddr != null)
{
m.Assign(
m.Load(
dataWidth,
Constant.Word32(mAddr.Address.ToUInt32())),
src);
return(src);
}
throw new NotImplementedException("Unimplemented RewriteMoveDst for operand type " + opDst.GetType().Name);
}
public Expression RewriteDst(
MachineOperand operand,
Address addrInstr,
PrimitiveType dataWidth,
Expression src,
Func <Expression, Expression, Expression> opGen)
{
var reg = operand as RegisterOperand;
if (reg != null)
{
Expression r = binder.EnsureRegister(reg.Register);
Expression tmp = r;
if (dataWidth != null &&
reg.Width.BitSize > dataWidth.BitSize &&
reg.Width.Domain != Domain.Real)
{
Expression rSub = m.Cast(dataWidth, r);
var srcExp = opGen(src, rSub);
if (srcExp is Identifier || srcExp is Constant || srcExp is DepositBits)
{
tmp = srcExp;
}
else
{
tmp = binder.CreateTemporary(dataWidth);
m.Assign(tmp, srcExp);
}
src = m.Dpb(r, tmp, 0);
}
else
{
src = opGen(src, r);
}
m.Assign(r, src);
return(tmp);
}
var dbl = operand as DoubleRegisterOperand;
if (dbl != null)
{
Identifier h = binder.EnsureRegister(dbl.Register1);
Identifier l = binder.EnsureRegister(dbl.Register2);
var d = binder.EnsureSequence(h.Storage, l.Storage, PrimitiveType.Word64);
var result = opGen(src, l);
m.Assign(d, result);
return(d);
}
var addr = operand as M68kAddressOperand;
if (addr != null)
{
var load = m.Load(dataWidth, addr.Address);
var tmp = binder.CreateTemporary(dataWidth);
m.Assign(tmp, opGen(src, load));
m.Assign(load, tmp);
return(tmp);
}
var mem = operand as MemoryOperand;
if (mem != null)
{
var load = RewriteMemoryAccess(mem, dataWidth, addrInstr);
var tmp = binder.CreateTemporary(dataWidth);
m.Assign(tmp, opGen(src, load));
m.Assign(load, tmp);
return(tmp);
}
var post = operand as PostIncrementMemoryOperand;
if (post != null)
{
var r = binder.EnsureRegister(post.Register);
var tmp = binder.CreateTemporary(dataWidth);
m.Assign(tmp, opGen(src, m.Load(post.Width, r)));
m.Assign(m.Load(dataWidth, r), tmp);
m.Assign(r, m.IAdd(r, dataWidth.Size));
return(tmp);
}
var pre = operand as PredecrementMemoryOperand;
if (pre != null)
{
var r = binder.EnsureRegister(pre.Register);
src = Spill(src, r);
m.Assign(r, m.ISub(r, dataWidth.Size));
var load = m.Load(dataWidth, r);
var tmp = binder.CreateTemporary(dataWidth);
m.Assign(tmp, opGen(src, load));
m.Assign(m.Load(dataWidth, r), tmp);
return(tmp);
}
var indidx = operand as IndirectIndexedOperand;
if (indidx != null)
{
Expression ea = binder.EnsureRegister(indidx.ARegister);
if (indidx.Imm8 != 0)
{
ea = m.IAdd(ea, Constant.Int32(indidx.Imm8));
}
Expression ix = binder.EnsureRegister(indidx.XRegister);
if (indidx.Scale > 1)
{
ix = m.IMul(ix, Constant.Int32(indidx.Scale));
}
var load = m.Load(dataWidth, m.IAdd(ea, ix));
var tmp = binder.CreateTemporary(dataWidth);
m.Assign(tmp, opGen(src, load));
m.Assign(load, tmp);
return(tmp);
}
return(null);
}
public int AddVertex(Vector2 position, Color color, PrimitiveType primitiveType)
{
return(AddVertex(ref position, color, primitiveType));
}
