public override void DefaultIn(Node node) { if (isFirst) { isFirst = false; } else { int index = 0; CloneMethod.GetChildTypeIndex getChildTypeIndex = new CloneMethod.GetChildTypeIndex() { Parent = node.Parent(), Child = node }; node.Parent().Apply(getChildTypeIndex); index = getChildTypeIndex.Index; CloneMethod.GetChildTypeByIndex getChildTypeByIndex = new CloneMethod.GetChildTypeByIndex() { Child = node, Index = index, Parent = currentClone }; currentClone.Apply(getChildTypeByIndex); currentClone = getChildTypeByIndex.Child; } if (node is ANamedType && data.GenericLinks.ContainsKey((ANamedType)node)) { TIdentifier name = data.GenericLinks[(ANamedType)node]; AStructDecl str = (AStructDecl)name.Parent(); PType type = types[str.GetGenericVars().IndexOf(name)]; replacer = Util.MakeClone(type, data); } }
public override void InAStructDecl(AStructDecl node) { decls.Add(node); /*node.GetName().Text = nextName; * NextName();*/ }
/*public override void InAMethodDecl(AMethodDecl node) * { * AABlock block = (AABlock) node.GetBlock(); * if (block != null) * { * if (!data.Locals.ContainsKey(block)) * data.Locals.Add(block, new List<AALocalDecl>()); * foreach (AALocalDecl formal in node.GetFormals()) * { * data.Locals[block].Add(formal); * } * } * } * * public override void InAConstructorDecl(AConstructorDecl node) * { * AABlock block = (AABlock)node.GetBlock(); * if (block != null) * { * if (!data.Locals.ContainsKey(block)) * data.Locals.Add(block, new List<AALocalDecl>()); * foreach (AALocalDecl formal in node.GetFormals()) * { * data.Locals[block].Add(formal); * } * } * }*/ public override void OutAMethodDecl(AMethodDecl node) { AStructDecl parentStruct = Util.GetAncestor <AStructDecl>(node); AEnrichmentDecl parentEnrichment = Util.GetAncestor <AEnrichmentDecl>(node); if (parentStruct != null) { //Struct method data.StructMethods[parentStruct].Add(node); } else if (parentEnrichment == null) {//Global method //Dont care about abstract methods - will add them later if (node.GetBlock() != null || node.GetNative() != null) { data.Methods.Add(new SharedData.DeclItem <AMethodDecl>(currentSourceFile, node)); data.UserMethods.Add(node); } else if (node.GetDelegate() != null) { data.Delegates.Add(new SharedData.DeclItem <AMethodDecl>(currentSourceFile, node)); } else { node.Parent().RemoveChild(node); return; } } base.OutAMethodDecl(node); }
public override void OutADeconstructorDecl(ADeconstructorDecl node) { AStructDecl parentStruct = Util.GetAncestor <AStructDecl>(node); if (parentStruct != null) { if (data.StructDeconstructor.ContainsKey(parentStruct) && data.StructDeconstructor[parentStruct] != node) { errors.Add(new ErrorCollection.Error(node.GetName(), "You can only define one deconstructor in a " + Util.GetTypeName(parentStruct) + ".", false, new[] { new ErrorCollection.Error( data.StructDeconstructor[parentStruct].GetName(), "Other deconstructor") })); } data.StructDeconstructor[parentStruct] = node; if (parentStruct.GetName().Text != node.GetName().Text) { errors.Add(new ErrorCollection.Error(node.GetName(), currentSourceFile, "Deconstructors must have same name as the enclosing struct.")); } } base.OutADeconstructorDecl(node); }
public override void OutAStructDecl(AStructDecl node) { //Insert init in each constructor AThisLvalue thisLvalue = new AThisLvalue(new TThis("this")); ALvalueExp thisExp = new ALvalueExp(thisLvalue); APointerLvalue pointerLvalue = new APointerLvalue(new TStar("*"), thisExp); ANamedType namedType = new ANamedType(new TIdentifier(node.GetName().Text), null); data.StructTypeLinks[namedType] = node; data.LvalueTypes[thisLvalue] = data.ExpTypes[thisExp] = new APointerType(new TStar("*"), namedType); data.LvalueTypes[pointerLvalue] = namedType; foreach (AConstructorDecl constructor in node.GetLocals().OfType <ADeclLocalDecl>().Select(decl => decl.GetDecl()).OfType <AConstructorDecl>()) { AABlock block = new AABlock(new ArrayList(), new TRBrace("}")); MakeAssignments(block, namedType, pointerLvalue, false); ((AABlock)constructor.GetBlock()).GetStatements().Insert(0, new ABlockStm(new TLBrace("{"), block)); } base.OutAStructDecl(node); }
public override void CaseAStructFieldLvalue(AStructFieldLvalue node) { //replace strField1 //with <structFormal>.strField1 AStructDecl str = finalTrans.data.StructTypeLinks[(ANamedType)structFormal.GetType()]; ALocalLvalue parameterRefference = new ALocalLvalue(new TIdentifier("tempName")); finalTrans.data.LocalLinks[parameterRefference] = structFormal; finalTrans.data.LvalueTypes[parameterRefference] = structFormal.GetType(); ALvalueExp exp = new ALvalueExp(parameterRefference); finalTrans.data.ExpTypes[exp] = structFormal.GetType(); AStructLvalue replacer = new AStructLvalue(exp, new ADotDotType(new TDot(".")), node.GetName()); foreach (AALocalDecl structField in finalTrans.data.StructFields[str]) { if (structField.GetName().Text == replacer.GetName().Text) { finalTrans.data.StructFieldLinks[replacer] = structField; finalTrans.data.LvalueTypes[replacer] = structField.GetType(); break; } } foreach (APropertyDecl property in finalTrans.data.StructProperties[str]) { if (property.GetName().Text == replacer.GetName().Text) { finalTrans.data.StructPropertyLinks[replacer] = property; finalTrans.data.LvalueTypes[replacer] = property.GetType(); break; } } node.ReplaceBy(replacer); }
public void Join(LibraryData other) { int count = Methods.Count; foreach (AMethodDecl method in other.Methods) { bool add = true; for (int i = 0; i < count; i++) { if (Util.GetMethodSignature(Methods[i]) != Util.GetMethodSignature(method)) { add = false; break; } } if (add) { Methods.Add(method); } } count = Fields.Count; foreach (AFieldDecl field in other.Fields) { bool add = true; for (int i = 0; i < count; i++) { if (Fields[i].GetName().Text != field.GetName().Text) { add = false; break; } } if (add) { Fields.Add(field); } } count = Structs.Count; for (int j = 0; j < other.Structs.Count; j++) { bool add = true; AStructDecl str = other.Structs[j]; for (int i = 0; i < count; i++) { if (Structs[i].GetName().Text != str.GetName().Text) { add = false; break; } } if (add) { Structs.Add(str); StructMethods.Add(str, other.StructMethods[str]); StructFields.Add(str, other.StructFields[str]); } } }
public override void OutADeconstructorDecl(ADeconstructorDecl node) { AStructDecl parentStruct = Util.GetAncestor <AStructDecl>(node); if (parentStruct != null) { if (data.StructDeconstructor.ContainsKey(parentStruct) && data.StructDeconstructor[parentStruct] != node) { errors.Add(new ErrorCollection.Error(node.GetName(), LocRM.GetString("ErrorText13") + Util.GetTypeName(parentStruct) + ".", false, new[] { new ErrorCollection.Error( data.StructDeconstructor[parentStruct].GetName(), LocRM.GetString("ErrorText15")) })); } data.StructDeconstructor[parentStruct] = node; if (parentStruct.GetName().Text != node.GetName().Text) { errors.Add(new ErrorCollection.Error(node.GetName(), currentSourceFile, LocRM.GetString("ErrorText16"))); } } base.OutADeconstructorDecl(node); }
public override void OutAStructDecl(AStructDecl node) { if (node.GetClassToken() != null && node.GetIntDim() == null) { node.Parent().RemoveChild(node); } base.OutAStructDecl(node); }
public override void InANamedType(ANamedType node) { if (!node.IsPrimitive())// !GalaxyKeywords.Primitives.words.Any(word => word == node.GetName().Text)) { AStructDecl decl = finalTrans.data.StructTypeLinks[node]; AddDepency(Util.GetAncestor <AASourceFile>(node), Util.GetAncestor <AASourceFile>(decl)); } }
public StructDecl(AStructDecl decl) { Decl = decl; if (Name.StartsWith("_")) { Name = "u" + Name; } }
public override void CaseAALocalDecl(AALocalDecl node) { //It wont enter methods //Repeated fields in structs are syntax errors AStructDecl str = Util.GetAncestor <AStructDecl>(node); StructFields[str].Add(node); node.Parent().RemoveChild(node); }
public static void Parse(AStructDecl str, AStructDecl clone, List <PType> types, SharedData data) { FixGenericLinks fixer = new FixGenericLinks(clone, types, data) { original = str, clone = clone }; str.Apply(fixer); }
public override void OutAStructDecl(AStructDecl node) { if (node.GetGenericVars().Count > 0 && !Refferences.ContainsKey(node)) { Refferences[node] = new List <AGenericType>(); } base.OutAStructDecl(node); }
public override void CaseAStructDecl(AStructDecl node) { Write("struct " + node.GetName().Text + "\n{\n"); foreach (AALocalDecl local in node.GetLocals().OfType <AALocalDecl>()) { local.Apply(this); Write(";\n"); } Write("};\n"); }
public override void InAStructDecl(AStructDecl node) { data.Structs.Add(new SharedData.DeclItem <AStructDecl>(currentSourceFile, node)); data.StructMethods.Add(node, new List <AMethodDecl>()); data.StructFields.Add(node, new List <AALocalDecl>()); data.StructConstructors.Add(node, new List <AConstructorDecl>()); data.StructProperties.Add(node, new List <APropertyDecl>()); base.InAStructDecl(node); }
public override void CaseAStructDecl(AStructDecl node) { if (node.GetLocals().Count == 0) { node.Parent().RemoveChild(node); } else { base.CaseAStructDecl(node); } }
public override void CaseAStructDecl(AStructDecl node) { if (Structs.Any(structDecl => structDecl.GetName().Text == node.GetName().Text)) { return; } Structs.Add(node); StructMethods.Add(node, new List <AMethodDecl>()); StructFields.Add(node, new List <AALocalDecl>()); base.CaseAStructDecl(node); node.Parent().RemoveChild(node); }
public override void CaseANamedType(ANamedType node) { if (processStructs) { AStructDecl structDecl = finalTrans.data.StructTypeLinks.ContainsKey(node) ? finalTrans.data.StructTypeLinks[node] : null; if (structDecl != null && !usedStructs.Contains(structDecl)) { usedStructs.Add(structDecl); } } base.CaseANamedType(node); }
public override void CaseAMethodDecl(AMethodDecl node) { if (node.GetNative() == null && node.GetBlock() == null) { return; } if (node.GetStatic() != null) { return; } string inputStr = "native " + TypeToString(node.GetReturnType()) + " " + node.GetName().Text + "("; bool first = true; foreach (AALocalDecl formal in node.GetFormals()) { if (!first) { inputStr += ", "; } inputStr += TypeToString(formal.GetType()) + " " + formal.GetName().Text; first = false; } inputStr += ");"; writer.WriteLine(inputStr); AStructDecl str = Util.GetAncestor <AStructDecl>(node); List <AMethodDecl> methodList; if (str != null) { methodList = StructMethods[str]; } else { methodList = Methods; } string sig = Util.GetMethodSignature(node); if (methodList.Any(otherMethod => Util.GetMethodSignature(otherMethod) == sig)) { return; } methodList.Add(node); node.SetBlock(null); node.Parent().RemoveChild(node); }
//Convert struct variables to a collection of local variables public override void CaseAALocalDecl(AALocalDecl node) { if (node.GetType() is ANamedType && data.StructTypeLinks.ContainsKey((ANamedType)node.GetType()) && Util.HasAncestor <PStm>(node)) { //Can not have init - it would be bulk copy AStructDecl str = data.StructTypeLinks[(ANamedType)node.GetType()]; Dictionary <AALocalDecl, AALocalDecl> variableMap = new Dictionary <AALocalDecl, AALocalDecl>(); PStm pStm = (PStm)node.Parent(); AABlock pBlock = (AABlock)pStm.Parent(); foreach (AALocalDecl structLocal in str.GetLocals()) { AALocalDecl replacementLocal = new AALocalDecl(new APublicVisibilityModifier(), null, null, null, null, Util.MakeClone(structLocal.GetType(), data), new TIdentifier(node.GetName().Text + "_" + structLocal.GetName().Text), null); pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(pStm), new ALocalDeclStm(new TSemicolon(";"), replacementLocal)); AALocalDecl baseLocal = structLocal; if (data.EnheritanceLocalMap.ContainsKey(baseLocal)) { baseLocal = data.EnheritanceLocalMap[baseLocal]; } List <AALocalDecl> localsToAdd = new List <AALocalDecl>(); localsToAdd.AddRange(data.EnheritanceLocalMap.Where(pair => pair.Value == baseLocal).Select(pair => pair.Key)); localsToAdd.Add(baseLocal); foreach (AALocalDecl localDecl in localsToAdd) { variableMap[localDecl] = replacementLocal; } } List <ALocalLvalue> uses = new List <ALocalLvalue>(); uses.AddRange(data.LocalLinks.Where(k => k.Value == node && Util.GetAncestor <AAProgram>(k.Key) != null).Select(k => k.Key)); foreach (ALocalLvalue lvalue in uses) { AStructLvalue structLocalRef = (AStructLvalue)lvalue.Parent().Parent(); AALocalDecl replacementLocal = variableMap[data.StructFieldLinks[structLocalRef]]; ALocalLvalue replacementLvalue = new ALocalLvalue(new TIdentifier(replacementLocal.GetName().Text)); data.LocalLinks[replacementLvalue] = replacementLocal; data.LvalueTypes[replacementLvalue] = replacementLocal.GetType(); structLocalRef.ReplaceBy(replacementLvalue); } foreach (AALocalDecl replacementLocal in variableMap.Select(k => k.Value)) { replacementLocal.Apply(this); } } base.CaseAALocalDecl(node); }
public override void OutAStructDecl(AStructDecl node) { //Insert parameterless constructor if ( !node.GetLocals().OfType <ADeclLocalDecl>().Select(localDecl => localDecl.GetDecl()).OfType <AConstructorDecl>().Any(constructor => constructor.GetFormals().Count == 0)) { node.GetLocals().Add( new ADeclLocalDecl(new AConstructorDecl(new APublicVisibilityModifier(), new TIdentifier(node.GetName().Text), new ArrayList(), new ArrayList(), new AABlock(new ArrayList(), new TRBrace("}"))))); } }
private void MakeAssignments(AABlock block, PType type, PLvalue leftSide, bool onEnhritedFields) { if (type is ANamedType && data.StructTypeLinks.ContainsKey((ANamedType)type)) { AStructDecl str = data.StructTypeLinks[(ANamedType)type]; foreach (AALocalDecl field in str.GetLocals().OfType <AALocalDecl>()) { if (!onEnhritedFields && data.EnheritanceLocalMap.ContainsKey(field)) { continue; } ALvalueExp lvalueExp = new ALvalueExp(Util.MakeClone(leftSide, data)); data.ExpTypes[lvalueExp] = data.LvalueTypes[leftSide]; AStructLvalue newLeftSide = new AStructLvalue(lvalueExp, new ADotDotType(new TDot(".")), new TIdentifier(field.GetName().Text)); data.StructFieldLinks[newLeftSide] = field; data.LvalueTypes[newLeftSide] = field.GetType(); if (field.GetInit() != null) { AAssignmentExp assignment = new AAssignmentExp(new TAssign("="), newLeftSide, Util.MakeClone(field.GetInit(), data)); data.ExpTypes[assignment] = data.LvalueTypes[newLeftSide]; block.GetStatements().Add(new AExpStm(new TSemicolon(";"), assignment)); } else { MakeAssignments(block, field.GetType(), newLeftSide, onEnhritedFields); } } } else if (type is AArrayTempType) { AArrayTempType aType = (AArrayTempType)type; for (int i = 0; i < int.Parse(aType.GetIntDim().Text); i++) { AIntConstExp index = new AIntConstExp(new TIntegerLiteral(i.ToString())); data.ExpTypes[index] = new ANamedType(new TIdentifier("int"), null); ALvalueExp lvalueExp = new ALvalueExp(Util.MakeClone(leftSide, data)); data.ExpTypes[lvalueExp] = data.LvalueTypes[leftSide]; AArrayLvalue newLeftSide = new AArrayLvalue(new TLBracket("["), lvalueExp, index); data.LvalueTypes[newLeftSide] = aType.GetType(); MakeAssignments(block, aType.GetType(), newLeftSide, onEnhritedFields); } } }
public override void OutAConstructorDecl(AConstructorDecl node) { AStructDecl parentStruct = Util.GetAncestor <AStructDecl>(node); if (parentStruct != null) { data.StructConstructors[parentStruct].Add(node); if (parentStruct.GetName().Text != node.GetName().Text) { errors.Add(new ErrorCollection.Error(node.GetName(), currentSourceFile, "Constructors must have same name as the enclosing struct.")); } } base.OutAConstructorDecl(node); }
public override void OutAConstructorDecl(AConstructorDecl node) { AStructDecl parentStruct = Util.GetAncestor <AStructDecl>(node); if (parentStruct != null) { data.StructConstructors[parentStruct].Add(node); if (parentStruct.GetName().Text != node.GetName().Text) { errors.Add(new ErrorCollection.Error(node.GetName(), currentSourceFile, LocRM.GetString("ErrorText12"))); } } base.OutAConstructorDecl(node); }
public override void OutAGenericType(AGenericType node) { if (!(node.GetBase() is ANamedType)) { errors.Add(new ErrorCollection.Error(node.GetToken(), LocRM.GetString("ErrorText44"))); return; } ANamedType Base = (ANamedType)node.GetBase(); if (!data.StructTypeLinks.ContainsKey(Base)) { errors.Add(new ErrorCollection.Error(node.GetToken(), LocRM.GetString("ErrorText44"))); return; } AStructDecl str = data.StructTypeLinks[Base]; if (str.GetGenericVars().Count != node.GetGenericTypes().Count) { errors.Add(new ErrorCollection.Error(node.GetToken(), LocRM.GetString("ErrorText45"), false, new ErrorCollection.Error(str.GetName(), LocRM.GetString("ErrorText46") + Util.GetTypeName(str)))); return; } LookForGenericVar finder = new LookForGenericVar(); foreach (PType genericType in node.GetGenericTypes()) { genericType.Apply(finder); if (finder.ContainsGenericVar || finder.ContainsNestedGenerics) { //if (finder.ContainsGenericVar) structsWithGenerics.Add(Util.GetAncestor <AStructDecl>(node)); if (finder.ContainsNestedGenerics) { if (!Util.HasAncestor <AStructDecl>(node) || Util.GetAncestor <AStructDecl>(node).GetGenericVars().Count == 0) { needAnotherPass = true; } } return; } } if (!Refferences.ContainsKey(str)) { Refferences[str] = new List <AGenericType>(); } Refferences[str].Add(node); base.OutAGenericType(node); }
public static bool Extends(AStructDecl baseType, AStructDecl cType, SharedData data) { if (cType == null) { return(false); } if (baseType == cType) { return(true); } if (cType.GetBase() == null) { return(false); } return(Extends(baseType, data.StructTypeLinks[(ANamedType)cType.GetBase()], data)); }
public override void OutAPropertyDecl(APropertyDecl node) { AStructDecl pStruct = Util.GetAncestor <AStructDecl>(node); AEnrichmentDecl pEnrichment = Util.GetAncestor <AEnrichmentDecl>(node); if (pStruct != null) { data.StructProperties[pStruct].Add(node); } else if (pEnrichment == null) { data.Properties.Add(new SharedData.DeclItem <APropertyDecl>(currentSourceFile, node)); } base.OutAPropertyDecl(node); }
public override void OutAEnumDecl(AEnumDecl node) { AStructDecl replacer = new AStructDecl(node.GetVisibilityModifier(), null, null, null, node.GetEndToken(), node.GetName(), new ArrayList(), null, new ArrayList()); int intVal = 0; //int min = int.MaxValue; //int max = int.MinValue; //List<TIdentifier> types = new List<TIdentifier>(); foreach (AAEnumLocal value in node.GetValues()) { AIntConstExp intConst; if (value.GetValue() != null) { intConst = (AIntConstExp)value.GetValue(); intVal = int.Parse(intConst.GetIntegerLiteral().Text) + 1; } else { intConst = new AIntConstExp(new TIntegerLiteral(intVal.ToString(), value.GetName().Line, value.GetName().Pos)); intVal++; } // min = Math.Min(intVal - 1, min); // max = Math.Max(intVal - 1, max); TIdentifier typeIdentifier = new TIdentifier(replacer.GetName().Text, value.GetName().Line, value.GetName().Pos); // types.Add(typeIdentifier); AALocalDecl localDecl = new AALocalDecl(new APublicVisibilityModifier(), new TStatic("static", value.GetName().Line, value.GetName().Pos), null, null, new TConst("const", value.GetName().Line, value.GetName().Pos), new ANamedType(typeIdentifier, null), value.GetName(), intConst); replacer.GetLocals().Add(localDecl); } /* if (min < 0 || max > 255) * foreach (TIdentifier identifier in types) * { * identifier.Text = "int"; * }*/ node.ReplaceBy(replacer); replacer.Apply(this); replacer.GetName().Text = "enum " + replacer.GetName().Text; }
public override void CaseAStructDecl(AStructDecl node) { if (node.GetDimention() != null) { bool prevFolding = folding; int prevValue = value; bool wasANewExp = isANewExp; folding = true; value = 0; node.GetDimention().Apply(this); node.SetIntDim(new TIntegerLiteral(value.ToString())); folding = prevFolding; value = prevValue; isANewExp = wasANewExp; } base.CaseAStructDecl(node); }