//type VarPrimitive(identity expression) { VarPrimitive(identity expression) }
void VarCreate(YSParseNode VarCreateNode)
{
Current = VarCreateNode;
List <int> Dimensions;
IdentityType _DataType;
DataType(VarCreateNode.Children [0], out _DataType, out Dimensions);
if (Dimensions != null)
{
YSToken NameToken = VarCreateNode.Children [1].Token;
if (VarCreateNode.Children [2].Type == NType.ExpressionList)
{
IdentityType ResolvedType = IdentityType.Unknown;
List <int> ReversedDimensions = new List <int> ();
IDPacket exp_list = ExpressionList(VarCreateNode.Children [2], ref ReversedDimensions, ref ResolvedType);
IDPacket put = IDPacket.CreateIDPacket(STATE, NameToken.Content, IdentityType.Structure);
put.ArrayType = ResolvedType;
ReversedDimensions.Reverse();
ArrayFrame AF = new ArrayFrame(put.ArrayType, ReversedDimensions.ToArray());
STATE.PutGeneric(put, AF);
GenericFrame CastedGeneric;
ArrayFrame AF_Casted;
STATE.TryGetGeneric(put, out CastedGeneric);
AF_Casted = (ArrayFrame)CastedGeneric;
STATE.COPY(put, exp_list);
Debug("T");
}
else if (VarCreateNode.Children [2].Type == NType.ArrayInit)
{
//TODO array initializer
}
else
{
Error("Arrays must be initialized with an expression list or array initializer");
}
}
else
{
for (int i = 1; i < VarCreateNode.Children.Count; i++)
{
VarPrimitive(VarCreateNode.Children [i], _DataType);
}
}
Debug("Exit VarCreate");
}
//type VarPrimitive(identity expression) { VarPrimitive(identity expression) }
void VarCreate(YSParseNode VarCreateNode)
{
Current = VarCreateNode;
List<int> Dimensions;
IdentityType _DataType;
DataType (VarCreateNode.Children [0], out _DataType, out Dimensions);
if (Dimensions != null) {
YSToken NameToken = VarCreateNode.Children [1].Token;
if (VarCreateNode.Children [2].Type == NType.ExpressionList) {
IdentityType ResolvedType = IdentityType.Unknown;
List<int> ReversedDimensions = new List<int> ();
IDPacket exp_list = ExpressionList (VarCreateNode.Children [2], ref ReversedDimensions, ref ResolvedType);
IDPacket put = IDPacket.CreateIDPacket (STATE, NameToken.Content, IdentityType.Structure);
put.ArrayType = ResolvedType;
ReversedDimensions.Reverse ();
ArrayFrame AF = new ArrayFrame (put.ArrayType, ReversedDimensions.ToArray());
STATE.PutGeneric (put, AF);
GenericFrame CastedGeneric;
ArrayFrame AF_Casted;
STATE.TryGetGeneric (put, out CastedGeneric);
AF_Casted = (ArrayFrame)CastedGeneric;
STATE.COPY (put, exp_list);
Debug ("T");
} else if(VarCreateNode.Children [2].Type == NType.ArrayInit) {
//TODO array initializer
} else {
Error("Arrays must be initialized with an expression list or array initializer");
}
} else {
for (int i = 1; i < VarCreateNode.Children.Count; i++) {
VarPrimitive (VarCreateNode.Children [i], _DataType);
}
}
Debug ("Exit VarCreate");
}
IDPacket ExpressionList(YSParseNode ExpressionListNode, ref List<int> DimensionsReversed, ref IdentityType ResolvedType)
{
DIMCNT = 0;
Debug ("Expression List Resolving");
//STATE.PutStructure (ARRAY, ArrayFrame);
if (ExpressionListNode.Children.Count < 1) {
Debug ("Expression List had no children");
return null;
}
IDPacket ARRAY = IDPacket.CreateSystemPacket ("EXPL_TEMP", IdentityType.Structure);
ScopeFrame ArrayScope = new ScopeFrame (new StructureFrame(), ARRAY.Name, ScopeFrame.FrameTypes.None);
STATE.PushScope (ArrayScope);
//List<IDPacket> RESULT = new List<IDPacket> ();
//Look at the first node, all other nodes must conform to this node's type
int NC = 0;
YSParseNode FirstNode = ExpressionListNode.Children [NC++];
//IdentityType ListType;
int ListDimensions = 0;
if (FirstNode.Type == NType.ExpressionList) {
ListDimensions++;
IDPacket IEXPL = ExpressionList (FirstNode, ref DimensionsReversed, ref ResolvedType);
DimensionsReversed.AddRange (new List<int>(DimensionsReversed));
//RESULT.Add (IEXPL);
IDPacket FIRST = IDPacket.CreateIDPacket (STATE, "0", IdentityType.Structure);
STATE.COPY (FIRST, IEXPL);
} else {
IDPacket EXP = Expression (FirstNode);
ResolvedType = EXP.Type;
if (!STATE.IsPrimitive (ResolvedType))
Error ("Expression Lists can only contain identities that resolve to Primitive Types");
//RESULT.Add (EXP);
IDPacket FIRST = IDPacket.CreateIDPacket (STATE, "0", EXP.Type);
STATE.COPY (FIRST, EXP);
}
int ELEMENT_COUNT = 1;
while (NC < ExpressionListNode.Children.Count) {
YSParseNode Node = ExpressionListNode.Children [NC++];
if (Node.Type != FirstNode.Type)
Error (String.Format("All children in an expression list must have the same dimensions " +
"Expecting {0} got {1}",
FirstNode.Type, Node.Type));
if (FirstNode.Type == NType.ExpressionList) {
IdentityType NodeType = IdentityType.Unknown;
int NodeDimensions = 0;
IDPacket NEXPL = ExpressionList (Node, ref DimensionsReversed, ref NodeType);
if (NodeDimensions != ListDimensions) {
Error (String.Format ("All children of an expression list must have matching dimensions. " +
"Expected dimensions:{0} Found:{1}",
ListDimensions, NodeDimensions));
}
if (NodeType != ResolvedType) {
Error (String.Format ("All children of an expression list must have matching types. " +
"Expected type:{0} Found:{1}",
ResolvedType, NodeType));
}
//RESULT.Add (NEXPL);
IDPacket NODE = IDPacket.CreateIDPacket (STATE, "" + ELEMENT_COUNT++, IdentityType.Structure);
STATE.COPY (NODE, NEXPL);
} else {
IDPacket NEXP = Expression (Node);
if (NEXP.Type != ResolvedType) {
Error (String.Format ("All children of an expression list must have matching types. " +
"Expected type:{0} Found:{1}",
ResolvedType, NEXP.Type));
}
//RESULT.Add (NEXP);
IDPacket NODE = IDPacket.CreateIDPacket (STATE, "" + ELEMENT_COUNT++, NEXP.Type);
STATE.COPY (NODE, NEXP);
}
}
DIMCNT = ELEMENT_COUNT;
DimensionsReversed.Add (DIMCNT);
ArrayScope = STATE.PopScopeNoSave ();
ArrayFrame ArrayFrame = new ArrayFrame (new IdentityType[] { ResolvedType });
ArrayFrame.Merge ((GenericFrame)ArrayScope);
ArrayFrame.ResolvedType = ResolvedType;
DimensionsReversed.Reverse ();
ArrayFrame.Dimensions = DimensionsReversed.ToArray();
ARRAY.ArrayType = ResolvedType;
STATE.PutGeneric (ARRAY, ArrayFrame);
//ResolvedType = RESOLVED_TYPE;
return ARRAY;
}
IDPacket ExpressionList(YSParseNode ExpressionListNode, ref List <int> DimensionsReversed, ref IdentityType ResolvedType)
{
DIMCNT = 0;
Debug("Expression List Resolving");
//STATE.PutStructure (ARRAY, ArrayFrame);
if (ExpressionListNode.Children.Count < 1)
{
Debug("Expression List had no children");
return(null);
}
IDPacket ARRAY = IDPacket.CreateSystemPacket("EXPL_TEMP", IdentityType.Structure);
ScopeFrame ArrayScope = new ScopeFrame(new StructureFrame(), ARRAY.Name, ScopeFrame.FrameTypes.None);
STATE.PushScope(ArrayScope);
//List<IDPacket> RESULT = new List<IDPacket> ();
//Look at the first node, all other nodes must conform to this node's type
int NC = 0;
YSParseNode FirstNode = ExpressionListNode.Children [NC++];
//IdentityType ListType;
int ListDimensions = 0;
if (FirstNode.Type == NType.ExpressionList)
{
ListDimensions++;
IDPacket IEXPL = ExpressionList(FirstNode, ref DimensionsReversed, ref ResolvedType);
DimensionsReversed.AddRange(new List <int>(DimensionsReversed));
//RESULT.Add (IEXPL);
IDPacket FIRST = IDPacket.CreateIDPacket(STATE, "0", IdentityType.Structure);
STATE.COPY(FIRST, IEXPL);
}
else
{
IDPacket EXP = Expression(FirstNode);
ResolvedType = EXP.Type;
if (!STATE.IsPrimitive(ResolvedType))
{
Error("Expression Lists can only contain identities that resolve to Primitive Types");
}
//RESULT.Add (EXP);
IDPacket FIRST = IDPacket.CreateIDPacket(STATE, "0", EXP.Type);
STATE.COPY(FIRST, EXP);
}
int ELEMENT_COUNT = 1;
while (NC < ExpressionListNode.Children.Count)
{
YSParseNode Node = ExpressionListNode.Children [NC++];
if (Node.Type != FirstNode.Type)
{
Error(String.Format("All children in an expression list must have the same dimensions " +
"Expecting {0} got {1}",
FirstNode.Type, Node.Type));
}
if (FirstNode.Type == NType.ExpressionList)
{
IdentityType NodeType = IdentityType.Unknown;
int NodeDimensions = 0;
IDPacket NEXPL = ExpressionList(Node, ref DimensionsReversed, ref NodeType);
if (NodeDimensions != ListDimensions)
{
Error(String.Format("All children of an expression list must have matching dimensions. " +
"Expected dimensions:{0} Found:{1}",
ListDimensions, NodeDimensions));
}
if (NodeType != ResolvedType)
{
Error(String.Format("All children of an expression list must have matching types. " +
"Expected type:{0} Found:{1}",
ResolvedType, NodeType));
}
//RESULT.Add (NEXPL);
IDPacket NODE = IDPacket.CreateIDPacket(STATE, "" + ELEMENT_COUNT++, IdentityType.Structure);
STATE.COPY(NODE, NEXPL);
}
else
{
IDPacket NEXP = Expression(Node);
if (NEXP.Type != ResolvedType)
{
Error(String.Format("All children of an expression list must have matching types. " +
"Expected type:{0} Found:{1}",
ResolvedType, NEXP.Type));
}
//RESULT.Add (NEXP);
IDPacket NODE = IDPacket.CreateIDPacket(STATE, "" + ELEMENT_COUNT++, NEXP.Type);
STATE.COPY(NODE, NEXP);
}
}
DIMCNT = ELEMENT_COUNT;
DimensionsReversed.Add(DIMCNT);
ArrayScope = STATE.PopScopeNoSave();
ArrayFrame ArrayFrame = new ArrayFrame(new IdentityType[] { ResolvedType });
ArrayFrame.Merge((GenericFrame)ArrayScope);
ArrayFrame.ResolvedType = ResolvedType;
DimensionsReversed.Reverse();
ArrayFrame.Dimensions = DimensionsReversed.ToArray();
ARRAY.ArrayType = ResolvedType;
STATE.PutGeneric(ARRAY, ArrayFrame);
//ResolvedType = RESOLVED_TYPE;
return(ARRAY);
}
