private void AddDependencyFromType(Item forItem, Core.Type type, bool onlyHeader) { var typeStruct = type as Core.TypeStruct; if (typeStruct != null) { itemGraph.AddEdge( forItem, (onlyHeader ? itemStructHeaders[typeStruct.structIndex] : itemStructs[typeStruct.structIndex])); return; } var typePtr = type as Core.TypePointer; if (typePtr != null) { AddDependencyFromType(forItem, typePtr.pointedToType, true); return; } var typeTuple = type as Core.TypeTuple; if (typeTuple != null) { foreach (var elem in typeTuple.elementTypes) { AddDependencyFromType(forItem, elem, onlyHeader); } return; } }
private void ApplyRuleForMoveTupleLiteral(ref bool appliedRule, Core.InstructionMoveLiteralTuple inst) { var destType = TypeResolver.GetDataAccessType(session, funct, inst.destination); var tupleElements = new Core.Type[inst.sourceElements.Length]; for (var i = 0; i < inst.sourceElements.Length; i++) { tupleElements[i] = TypeResolver.GetDataAccessType(session, funct, inst.sourceElements[i]); } var srcTuple = Core.TypeTuple.Of(tupleElements); var srcType = (Core.Type)srcTuple; var inferredDest = TypeInferencer.Try(session, srcType, ref destType); var inferredSrc = TypeInferencer.Try(session, destType, ref srcType); if (inferredDest) { appliedRule = ApplyToDataAccess(inst.destination, destType); } if (inferredSrc) { for (var i = 0; i < inst.sourceElements.Length; i++) { appliedRule = ApplyToDataAccess(inst.sourceElements[i], srcTuple.elementTypes[i]); } } }
public Core.TypeFunct MakeFunctType() { var parameterTypes = new Core.Type[this.parameterNum]; for (var i = 0; i < this.parameterNum; i++) parameterTypes[i] = this.registerTypes[i + 1]; return Core.TypeFunct.Of(this.registerTypes[0], parameterTypes); }
public ActionResult Edit([Bind(Include = "ID,Description,Status")] Core.Type type) { if (ModelState.IsValid) { typeService.Edit(type); return(RedirectToAction("Index")); } return(View(type)); }
public Core.TypeFunct MakeFunctType() { var parameterTypes = new Core.Type[this.parameterNum]; for (var i = 0; i < this.parameterNum; i++) { parameterTypes[i] = this.registerTypes[i + 1]; } return(Core.TypeFunct.Of(this.registerTypes[0], parameterTypes)); }
private bool ApplyToDataAccess(Core.DataAccess access, Core.Type type) { var regAccess = access as Core.DataAccessRegister; if (regAccess != null) { this.funct.registerTypes[regAccess.registerIndex] = type; return(true); } return(false); }
// type data - creating types public static List <Core.Type> InitDataTypes() { var type1 = new Core.Type() { ID = id++, TypeType = "Dog" }; types.Add(type1); var type2 = new Core.Type() { ID = id++, TypeType = "Cat" }; types.Add(type2); var type3 = new Core.Type() { ID = id++, TypeType = "Dog" }; types.Add(type3); var type4 = new Core.Type() { ID = id++, TypeType = "Bird" }; types.Add(type4); var type5 = new Core.Type() { ID = id++, TypeType = "Dog" }; types.Add(type5); var type6 = new Core.Type() { ID = id++, TypeType = "Cat" }; types.Add(type6); return(types); }
// GET: Types/Edit/5 public ActionResult Edit(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } Core.Type type = typeService.Get(id); if (type == null) { return(HttpNotFound()); } return(View(type)); }
private string ConvertFieldDecl(Core.Type type, string name) { var typeStruct = type as Core.TypeStruct; if (typeStruct != null) { var st = session.GetStruct(typeStruct.structIndex); var structName = MangleName(session.GetStructName(typeStruct.structIndex)); return((st.primitive ? "" : "struct ") + structName + (name == null ? "" : " " + name)); } var typePointer = type as Core.TypePointer; if (typePointer != null) { return(ConvertFieldDecl(typePointer.pointedToType, "*" + name)); } var typeTuple = type as Core.TypeTuple; if (typeTuple != null) { if (typeTuple.IsEmptyTuple()) { return("void" + (name == null ? "" : " " + name)); } } var typeFunct = type as Core.TypeFunct; if (typeFunct != null) { var res = ConvertFieldDecl(typeFunct.returnType, null) + "(*" + (name == null ? "" : name) + ")" + "("; for (var i = 0; i < typeFunct.parameterTypes.Length; i++) { res += ConvertFieldDecl(typeFunct.parameterTypes[i], null); if (i < typeFunct.parameterTypes.Length - 1) { res += ", "; } } return(res + ")"); } return("??? " + name); }
private void CheckMove(Core.DataAccess destination, Core.Type srcType, Diagnostics.Span srcSpan) { if (!TypeResolver.ValidateDataAccess(this.session, this.funct, destination)) { this.foundErrors = true; return; } var destType = TypeResolver.GetDataAccessType(this.session, this.funct, destination); if (destType == null) { return; } if (!srcType.IsConvertibleTo(destType) && ShouldDiagnose(srcType) && ShouldDiagnose(destType)) { this.foundErrors = true; var destReg = destination as Core.DataAccessRegister; if (destReg != null && destReg.registerIndex == 0) { this.session.AddMessage( Diagnostics.MessageKind.Error, Diagnostics.MessageCode.IncompatibleTypes, "returning '" + srcType.GetString(this.session) + "' " + "but expecting '" + destType.GetString(this.session) + "'", srcSpan, destination.span); } else { this.session.AddMessage( Diagnostics.MessageKind.Error, Diagnostics.MessageCode.IncompatibleTypes, "moving '" + srcType.GetString(this.session) + "' " + "into '" + destType.GetString(this.session) + "'", srcSpan, destination.span); } } }
public void Notify(Core.Type type, Priority priority, string message) { string heading; switch (type) { case Core.Type.Error: heading = "Error"; break; case Core.Type.Notification: heading = "Notification"; break; case Core.Type.Warning: heading = "Warning"; break; default: heading = string.Empty; break; } var ttm = new ToolTipModel(heading, message, this); _toolTipHandler.Draw(ttm); }
// GET: Types/Delete/5 public ActionResult Delete(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } Core.Type type = typeService.Get(id); if (type == null) { return(HttpNotFound()); } TypeViewModel model = new TypeViewModel { Type = type, Questions = questionService.GetAll().Where(x => x.TypeID == id) }; return(View(model)); }
private static bool CheckField( Core.Session session, int structIndex, int fieldIndex, Core.Type innerType, Stack <int> seenStructs) { var fieldStruct = innerType as Core.TypeStruct; if (fieldStruct == null) { return(false); } var st = session.GetStruct(structIndex); Core.Name fieldName; st.fieldNames.FindByValue(fieldIndex, out fieldName); session.PushContext( "in struct '" + session.GetStructName(structIndex).GetString() + "', " + "field '" + fieldName.GetString() + "'", st.GetFieldNameSpan(fieldIndex)); var err = false; if (seenStructs.Contains(fieldStruct.structIndex)) { err = true; session.AddMessage( Diagnostics.MessageKind.Error, Diagnostics.MessageCode.StructRecursion, "struct recursion", session.GetStruct(fieldStruct.structIndex).GetNameSpan(), st.GetFieldNameSpan(fieldIndex)); } if (!err) { CheckStruct(session, fieldStruct.structIndex, seenStructs); } session.PopContext(); return(err); }
public static int GetFieldNum( Core.Session session, Core.Type baseType) { var baseStruct = baseType as Core.TypeStruct; if (baseStruct != null) { return(session.GetStruct(baseStruct.structIndex).fieldTypes.Count); } var baseTuple = baseType as Core.TypeTuple; if (baseTuple != null) { return(baseTuple.elementTypes.Length); } return(0); }
private void CheckMoveTupleLiteral(Core.InstructionMoveLiteralTuple inst) { var destType = TypeResolver.GetDataAccessType(this.session, this.funct, inst.destination); var tupleElements = new Core.Type[inst.sourceElements.Length]; for (var i = 0; i < inst.sourceElements.Length; i++) { if (!TypeResolver.ValidateDataAccess(this.session, this.funct, inst.sourceElements[i])) { this.foundErrors = true; return; } tupleElements[i] = TypeResolver.GetDataAccessType(this.session, this.funct, inst.sourceElements[i]); } var srcTuple = Core.TypeTuple.Of(tupleElements); CheckMove(inst.destination, srcTuple, inst.span); }
public static Core.Type GetFieldType( Core.Session session, Core.Type baseType, int fieldIndex) { var baseStruct = baseType as Core.TypeStruct; if (baseStruct != null) { return(session.GetStruct(baseStruct.structIndex).fieldTypes[fieldIndex]); } var baseTuple = baseType as Core.TypeTuple; if (baseTuple != null) { return(baseTuple.elementTypes[fieldIndex]); } return(new Core.TypeError()); }
public override bool IsConvertibleTo(Core.Type other) { var otherPointer = other as Core.TypePointer; if (otherPointer == null) { return(false); } if (!this.pointedToType.IsSame(otherPointer.pointedToType)) { return(false); } if (!this.mutable && otherPointer.mutable) { return(false); } return(true); }
public static Core.Name GetFieldName( Core.Session session, Core.Type baseType, int fieldIndex) { var baseStruct = baseType as Core.TypeStruct; if (baseStruct != null) { Core.Name name; session.GetStruct(baseStruct.structIndex).fieldNames.FindByValue(fieldIndex, out name); return(name); } var baseTuple = baseType as Core.TypeTuple; if (baseTuple != null) { return(Core.Name.FromPath(fieldIndex.ToString())); } return(null); }
public static Core.Type Resolve( Core.Session session, Grammar.ASTNodeType typeNode, IList<Core.UseDirective> useDirectives, bool mustBeResolved) { var typePlaceholderNode = typeNode as Grammar.ASTNodeTypePlaceholder; if (typePlaceholderNode != null) { if (mustBeResolved) { session.AddMessage( Diagnostics.MessageKind.Error, Diagnostics.MessageCode.Expected, "type must be known", typeNode.GetSpan()); return new Core.TypeError(); } return new Core.TypePlaceholder(); } var typeStructNode = typeNode as Grammar.ASTNodeTypeStruct; if (typeStructNode != null) { return ResolveStruct(session, typeStructNode.name, useDirectives, mustBeResolved); } var typeTupleNode = typeNode as Grammar.ASTNodeTypeTuple; if (typeTupleNode != null) { var elementTypes = new Core.Type[typeTupleNode.elements.Count]; for (var i = 0; i < typeTupleNode.elements.Count; i++) elementTypes[i] = Resolve(session, typeTupleNode.elements[i], useDirectives, mustBeResolved); return Core.TypeTuple.Of(elementTypes); } var typeFunctNode = typeNode as Grammar.ASTNodeTypeFunct; if (typeFunctNode != null) { var returnType = Resolve(session, typeFunctNode.returnType, useDirectives, mustBeResolved); var parameterTypes = new Core.Type[typeFunctNode.parameters.Count]; for (var i = 0; i < typeFunctNode.parameters.Count; i++) parameterTypes[i] = Resolve(session, typeFunctNode.parameters[i], useDirectives, mustBeResolved); return Core.TypeFunct.Of(returnType, parameterTypes); } var typeRefNode = typeNode as Grammar.ASTNodeTypePointer; if (typeRefNode != null) { return Core.TypePointer.Of( typeRefNode.mutable, Resolve(session, typeRefNode.referenced, useDirectives, mustBeResolved)); } throw new System.NotImplementedException(); }
private bool ShouldDiagnose(Core.Type type) { return(type.IsResolved() && !type.IsError()); }
public void Notify(Core.Type type, Priority priority, string message) { // TODO: Add functionality for dislpaying messages on AddTransactionWindow }
public static InstructionMoveLiteralInt Of(Diagnostics.Span span, DataAccess destination, Core.Type type, long value) { return(new InstructionMoveLiteralInt { span = span, destination = destination, type = type, value = value }); }
public virtual bool IsConvertibleTo(Core.Type other) { return(IsSame(other)); }
public Variable(Core.Type type, string name) { this.type = type; //this.type_match = type_match; this.name = name; }
//creates a type in the database and returns it public Core.Type Create(Core.Type ty) { ty.ID = id++; _types.Add(ty); return(ty); }
public virtual bool IsSame(Core.Type other) { return(false); }
public int CreateRegister(Core.Type type, bool mutable) { this.registerTypes.Add(type); this.registerMutabilities.Add(mutable); return(this.registerTypes.Count - 1); }
public static bool Try(Core.Session session, Core.Type typeFrom, ref Core.Type typeTo) { if (typeTo is Core.TypePlaceholder && !(typeFrom is Core.TypePlaceholder)) { typeTo = typeFrom; return(true); } else if (typeTo is Core.TypePointer && typeFrom is Core.TypePointer) { var refTo = (Core.TypePointer)typeTo; var refFrom = (Core.TypePointer)typeFrom; return(Try(session, refFrom.pointedToType, ref refTo.pointedToType)); } /*else if (typeTo is TypeStruct && typeFrom is TypeStruct) * { * var structTo = (TypeStruct)typeTo; * var structFrom = (TypeStruct)typeFrom; * * if (structTo.potentialStructs.Count > 1 && structFrom.potentialStructs.Count == 1) * { * TryInference(session, structFrom.nameInference.template, ref structTo.nameInference.template); * typeTo = typeFrom; * } * * return false; * }*/ else if (typeTo is Core.TypeFunct && typeFrom is Core.TypeFunct) { var functTo = (Core.TypeFunct)typeTo; var functFrom = (Core.TypeFunct)typeFrom; var result = Try(session, functFrom.returnType, ref functTo.returnType); if (functTo.parameterTypes == null && functFrom.parameterTypes != null) { functTo.parameterTypes = new Core.Type[functFrom.parameterTypes.Length]; System.Array.Copy(functFrom.parameterTypes, functTo.parameterTypes, functFrom.parameterTypes.Length); result = true; } /*if (functTo.argumentTypes != null && * functFrom.argumentTypes != null && * functTo.argumentTypes.Count == functFrom.argumentTypes.Count) * { * for (var i = 0; i < functTo.argumentTypes.Count; i++) * { * var argTo = functTo.argumentTypes[i]; * result |= Try(session, functFrom.argumentTypes[i], ref argTo); * functTo.argumentTypes[i] = argTo; * } * }*/ typeTo = functTo; return(result); } else if (typeTo is Core.TypeTuple && typeFrom is Core.TypeTuple) { var tupleTo = (Core.TypeTuple)typeTo; var tupleFrom = (Core.TypeTuple)typeFrom; var result = false; if (tupleTo.elementTypes.Length == tupleFrom.elementTypes.Length) { for (var i = 0; i < tupleTo.elementTypes.Length; i++) { var elemTo = tupleTo.elementTypes[i]; result |= Try(session, tupleFrom.elementTypes[i], ref elemTo); tupleTo.elementTypes[i] = elemTo; } } typeTo = tupleTo; return(result); } return(false); }
public static Core.Type Resolve( Core.Session session, Grammar.ASTNodeType typeNode, IList <Core.UseDirective> useDirectives, bool mustBeResolved) { var typePlaceholderNode = typeNode as Grammar.ASTNodeTypePlaceholder; if (typePlaceholderNode != null) { if (mustBeResolved) { session.AddMessage( Diagnostics.MessageKind.Error, Diagnostics.MessageCode.Expected, "type must be known", typeNode.GetSpan()); return(new Core.TypeError()); } return(new Core.TypePlaceholder()); } var typeStructNode = typeNode as Grammar.ASTNodeTypeStruct; if (typeStructNode != null) { return(ResolveStruct(session, typeStructNode.name, useDirectives, mustBeResolved)); } var typeTupleNode = typeNode as Grammar.ASTNodeTypeTuple; if (typeTupleNode != null) { var elementTypes = new Core.Type[typeTupleNode.elements.Count]; for (var i = 0; i < typeTupleNode.elements.Count; i++) { elementTypes[i] = Resolve(session, typeTupleNode.elements[i], useDirectives, mustBeResolved); } return(Core.TypeTuple.Of(elementTypes)); } var typeFunctNode = typeNode as Grammar.ASTNodeTypeFunct; if (typeFunctNode != null) { var returnType = Resolve(session, typeFunctNode.returnType, useDirectives, mustBeResolved); var parameterTypes = new Core.Type[typeFunctNode.parameters.Count]; for (var i = 0; i < typeFunctNode.parameters.Count; i++) { parameterTypes[i] = Resolve(session, typeFunctNode.parameters[i], useDirectives, mustBeResolved); } return(Core.TypeFunct.Of(returnType, parameterTypes)); } var typeRefNode = typeNode as Grammar.ASTNodeTypePointer; if (typeRefNode != null) { return(Core.TypePointer.Of( typeRefNode.mutable, Resolve(session, typeRefNode.referenced, useDirectives, mustBeResolved))); } throw new System.NotImplementedException(); }
public ActionResult DeleteConfirmed(int id) { Core.Type type = typeService.Get(id); typeService.Delete(type); return(RedirectToAction("Index")); }
public void Notify(Core.Type type, Priority priority, string message) { throw new NotImplementedException(); }
public ActionResult Add(AddCTCViewModel ctc) { int id; if (!IsEnglish(ctc.Name)) { ModelState.AddModelError("Name", "请输入英文代称"); return(View(ctc)); } try { _vir.FindVirID(ctc.Name); ModelState.AddModelError("Name", "已存在该货币,且只可存在一种结算货币"); } catch { } if (ModelState.IsValid) { Response _response = null; //添加的是结算货币 还需添加至货币体系 if (ctc.ID == 5) { Core.Type type = new Core.Type(); type.TypeName = ctc.Name; _response = _type.Add(type); VirtualCurrency vir = new VirtualCurrency(); vir.Name = ctc.Name; vir.TypeID = ctc.ID; vir.Description = ctc.Name + "/" + ctc.Name; _response = _vir.Add(vir); id = vir.VirCurID; } //添加的是交易对 直接添加至货币体系 else { VirtualCurrency vir = new VirtualCurrency(); vir.Name = ctc.Name; vir.TypeID = ctc.ID; vir.Description = ctc.Name + "/" + _type.Find(ctc.ID).TypeName; _response = _vir.Add(vir); id = vir.VirCurID; } //都需要为每一个用户添加新的钱包 List <int> users = _user.FindList().Select(u => u.UserID).ToList(); Wallet wallet = new Wallet(); foreach (var item in users) { wallet.Amount = 0; wallet.UserID = item; wallet.VirCurID = id; _wallet.Add(wallet); } //为新加的货币添加每日情况表 PriceInDay pr = new PriceInDay { CoinToCoin = ctc.Name + "/" + _type.Find(ctc.ID).TypeName, AmountInDay = 0, Price = 0, VolumeInDay = 0, MaxInDay = 0, MinInDay = 0, Up = 0 }; _pr.Add(pr); if (_response.Code == 1) { return(View("Prompt", new Prompt() { Title = "添加货币成功", Message = "您已成功添加了货币【" + _response.Data.Name + "】", Buttons = new List <string> { "<a href=\"" + Url.Action("Index", "Coin") + "\" class=\"btn btn-default\">交易对管理</a>", "<a href=\"" + Url.Action("Add", "Coin") + "\" class=\"btn btn-default\">继续添加</a>" } })); } else { ModelState.AddModelError("", _response.Message); } } //这里还需初始化一次 如果不跳转页面 var _types = new TypeManager().FindList(); List <SelectListItem> _listItems = new List <SelectListItem>(_types.Count()); foreach (var _type in _types) { _listItems.Add(new SelectListItem() { Text = _type.TypeName, Value = _type.ID.ToString() }); //这里的属性名要与view中的model属性一致 } ViewBag.Types = _listItems; return(View(ctc)); }