Bird Programming Language: Part 1

MISZ\BmxLibs.txt MISZ\Squares\Squares.txt MISZ\Squares.s


		public bool MembersAssigned(Variable Var, Identifier Member)
		{
#if DEBUG
			var Type = Var.Type as StructuredType;
			if (Type == null || !Type.Members.Contains(Member))
				throw new Exception("ERROR");
#endif
			foreach (var e in AllAssignments)
			{
				var OpNode = e as OpExpressionNode;
				if (OpNode == null || OpNode.Operator != Operator.Member) continue;
				var Ch = OpNode.Children;

				var IdCh0 = Ch[0] as IdExpressionNode;
				var IdCh1 = Ch[1] as IdExpressionNode;
				if (IdCh0 != null && IdCh1 != null && IdCh0.Id == Var && IdCh1.Id == Member)
					return true;
			}

			return false;
		}

		public bool MembersAssigned(Variable Var, CompilerState State = null)
		{
			var Type = Var.Type as StructuredType;
			if (Type == null) throw new Exception("ERROR");

			var RetValue = true;
			foreach (var e in Type.Members)
				if (!MembersAssigned(Var, e))
				{
					if (State != null)
						State.Messages.Add(MessageId.VarUsingWoAssign, e.Name);

					RetValue = false;
				}

			return RetValue;
		}



		private void CalcRec(ExpressionNode Node)
		{
			var Data = Node.ArchData as x86NodeData;
			var Scope = Data.Scope;
			var Index = Data.Index;

			if (Data.NewScope)
			{
				foreach (var Pos in Scope.DataPositions.Values)
					if (!Pos.DataCalcPos.HasFlag(x86DataCalcPos.Memory))
						Scope.AlloArchData(Pos);
			}

			//------------------------------------------------------------
			if (Node.LinkedNodes != null)
			{
                var Allocator = new x86DataAllocator(Container);
                Allocator.SetUsed(Scope.Allocator);

                for (var i = Node.LinkedNodes.Count - 1; i >= 0; i--)
                {
                    var LNode = Node.LinkedNodes[i];
					var LData = LNode.ArchData as x86LinkedNodeData;
					
                    var Linked = LNode.Node;
                    var LinkedData = Linked.ArchData as x86NodeData;
					var LScope = LinkedData.Scope;

					if (LData.Specified != null)
                    {
						LData.Position = LData.Specified;
						Allocator.SetUsed(LData.Specified);
                    }
                    else
                    {
                        if (LinkedData.Output != null && Allocator.IsFree(LinkedData.Output))
                        {
                            Allocator.SetUsed(LinkedData.Output);
							LData.Position = LinkedData.Output;
                        }
                        else
                        {
                            LData.Position = Allocator.Alloc(Linked.Type);
                        }

                        Scope.SetUsed(LData.Position);
                    }

                    LNode.Node.GetUsed(Allocator);
                }
			}

            if (Index != -1) Data.Output = Scope.AlloArchData(Index, Node.Type.Size, false);
			foreach (var Ch in Node.EnumChildren)
				CalcRec(Ch);
		}




class List<T>
	T[] Data
	int Count

	void Add(T Obj)
		Count++
		if Data.Length < Count
			Data.Length *= 2

		Data[Count - 1] = Obj

	void RemoveLast()
		Count--

	T this[int Index]
		if Index < Count
			throw new Exception

		getset Data[Index]


typedef float2 {float x, y}
typedef int2 {int, int}

bool Ok(float2 a, b)
	return -0.5 < a.x - b.x < 0.5 and
		   -0.5 < a.y - b.y < 0.5

bool Ok(float2 a, b)
	return |a.x - b.x| < 0.5 and
		   |a.y - b.y| < 0.5

bool Ok(float2 a, b)
	return abs(a.x - b.x) < 0.5 and
		   abs(a.y - b.y) < 0.5

{int, int} Mul({int, int} a, b)
	return {a.0 * b.0, a.1 * b.1}

Mul({int, int} a, b, out)
	return {a.0 * b.0, a.1 * b.1}
	
int2 Mul(int2 a, b)
	return {a.0 * b.0, a.1 * b.1}

private (string out) GetCmpCode(x86DataPosition TmpReg, Dst, Src, Operator Instruction, Type Type)
	if Type is FloatType
		if Dst == null then CodeString.Append "\tfucompp\n"
		else CodeString.Append "\tfucomp " + Dst + "\n"
		CodeString.Append "\tfnstsw ax\n"
		CodeString.Append "\tsahf\n"
		out = x86Architecture.OpInstruction(Instruction, false)
	else
		out = x86Architecture.OpInstruction(Instruction, Type is SignedType)
		StdMem2MemOp "\tcmp ", Dst, Src, TmpReg

private string GetCmpCode(x86DataPosition TmpReg, x86DataPosition Dst, x86DataPosition Src,
	Operator Instruction, Type Type)
{
	string StrInstruction;
	if (Type is FloatType)
	{
		if (Dst == null) CodeString.Append("\tfucompp\n");
		else CodeString.Append("\tfucomp " + Dst + "\n");
		CodeString.Append("\tfnstsw ax\n");
		CodeString.Append("\tsahf\n");
		StrInstruction = x86Architecture.OpInstruction(Instruction, false);
	}
	else
	{
		StrInstruction = x86Architecture.OpInstruction(Instruction, Type is SignedType);
		StdMem2MemOp("\tcmp ", Dst, Src, TmpReg);
	}

	return StrInstruction;
}

private string GetCmpCode(List<ExpressionNode> Ch, Operator Op, x86DataPosition TmpReg)
{
	CalcFltNodes(Ch);
	var Type = Ch[0].Type;

	var Dst = GetNodePos(Ch[0], GetNodePosMode.Default);
	var Src = GetNodePos(Ch[1], GetNodePosMode.Default);
}
		 
public x86DataPosition GetNodePos_Float(ExpressionNode Node)
{
	CalcFltNode(Node);
	return Node.GetPosition();
}


public class PlugInManager
{
	public IdContainer Container;
	public Type RetType;

	public CompilerState State { get { return Container.State; } }
	public PreprocessorState PreState { get { return Container.PreState; } }
	public virtual bool AutoNot { get { return false; } }

	public PlugInManager(IdContainer Container)
	{
		this.Container = Container;
	}
}