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;
}
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);
}
//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));
}
