public override FunctionType Deserialize(SerializedSignature ss, Frame frame)
{
if (ss == null)
return null;
this.argDeser = new ArgumentDeserializer(this, Architecture, frame, 0, Architecture.WordWidth.Size);
Identifier ret = null;
int fpuDelta = FpuStackOffset;
FpuStackOffset = 0;
if (ss.ReturnValue != null)
{
ret = argDeser.DeserializeReturnValue(ss.ReturnValue);
fpuDelta += FpuStackOffset;
}
FpuStackOffset = 0;
var args = new List<Identifier>();
if (ss.Arguments != null)
{
for (int iArg = 0; iArg < ss.Arguments.Length; ++iArg)
{
var sArg = ss.Arguments[iArg];
var arg = DeserializeArgument(sArg, iArg, ss.Convention);
args.Add(arg);
}
fpuDelta -= FpuStackOffset;
}
FpuStackOffset = fpuDelta;
var sig = new FunctionType(ret, args.ToArray());
ApplyConvention(ss, sig);
return sig;
}
public Function(string prefix, string name, List<AstNode> argumentList)
{
this.functionType = FunctionType.FuncUserDefined;
this.prefix = prefix;
this.name = name;
this.argumentList = new List<AstNode>(argumentList);
}
/// <summary>
/// Sets whether functions 5 to 8 of the locomotive are momentaty or on/off
/// </summary>
/// <remarks>
/// The type of each function is stored in a database maintained by the command station.
/// </remarks>
/// <param name="address">The address of the locomotive (0 - 9999)</param>
/// <param name="f5">Function 5</param>
/// <param name="f6">Function 6</param>
/// <param name="f7">Function 7</param>
/// <param name="f8">Function 8</param>
public SetFunctionType_Group2Message(int address, FunctionType f5, FunctionType f6, FunctionType f7, FunctionType f8)
: base(PacketHeaderType.LocomotiveFunction)
{
Payload.Add(Convert.ToByte(PacketIdentifier.LocomotiveFunctionRequest.SetFunctionState_Group2));
byte[] data = new byte[3];
if (address >= XpressNetConstants.MIN_LOCO_ADDRESS && address <= XpressNetConstants.MAX_LOCO_ADDRESS)
ValueConverter.LocoAddress(address, out data[0], out data[1]);
else
throw new XpressNetProtocolViolationException("Number out of bounds");
data[2] = 0x00;
//TODO: check if & operator speeds up this function
if (f8 == FunctionType.OnOff)
data[2] += 8;
if (f7 == FunctionType.OnOff)
data[2] += 4;
if (f6 == FunctionType.OnOff)
data[2] += 2;
if (f5 == FunctionType.OnOff)
data[2] += 1;
Payload.AddRange(data);
}
public Token(FunctionType functionType, int operandsCount)
{
this.Type = TokenType.Function;
this.FunctionType = functionType;
this.OperandsCount = operandsCount;
this.Precedence = GetPrecedence();
}
public KernelEntryPoint(Function kernelFunction, FunctionType entryPointType)
: base(kernelFunction.GetModule())
{
SetFunctionType(entryPointType);
this.flags = MemberFlags.Static;
this.kernelFunction = kernelFunction;
}
public Function(string prefix, string name, List<AstNode> argumentList)
{
_functionType = FunctionType.FuncUserDefined;
_prefix = prefix;
_name = name;
_argumentList = new List<AstNode>(argumentList);
}
public static FunctionParameter CreateFunctionParameter(IList<string> list, string reference, string matchCount)
{
FunctionType[] types = new FunctionType[list.Count];
for (int i = 0; i < list.Count; i++) {
string s = list[i];
FunctionType funType;
if (String.Compare(s, "any", true) == 0) {
funType = FunctionType.Any;
} else if (String.Compare(s, "comparable", true) == 0) {
funType = FunctionType.Comparable;
} else if (String.Compare(s, "table", true) == 0) {
funType = FunctionType.Table;
} else {
funType = new FunctionType(SqlType.Parse(s));
}
types[i] = funType;
}
FunctionParameterMatch match;
if (matchCount == "1") {
match = FunctionParameterMatch.Exact;
} else if (matchCount == "+") {
match = FunctionParameterMatch.OneOrMore;
} else if (matchCount == "*") {
match = FunctionParameterMatch.ZeroOrMore;
} else {
match = FunctionParameterMatch.ZeroOrOne;
}
return new FunctionParameter(types, reference, match);
}
public NativeTableItem( UFunction function )
{
if( function.IsOperator() )
{
Type = FunctionType.Operator;
}
else if( function.IsPost() )
{
Type = FunctionType.PostOperator;
}
else if( function.IsPre() )
{
Type = FunctionType.PreOperator;
}
else
{
Type = FunctionType.Function;
}
OperPrecedence = function.OperPrecedence;
ByteToken = function.NativeToken;
Name = Type == FunctionType.Function
? function.Name
: function.FriendlyName;
}
public override FunctionType Deserialize(SerializedSignature ss, Frame frame)
{
if (ss == null)
return new FunctionType();
if (ss == null)
return null;
var argser = new ArgumentDeserializer(this, Architecture, frame, 0, Architecture.WordWidth.Size);
Identifier ret = null;
if (ss.ReturnValue != null)
{
ret = argser.DeserializeReturnValue(ss.ReturnValue);
}
var args = new List<Identifier>();
this.gr = 0;
if (ss.Arguments != null)
{
for (int iArg = 0; iArg < ss.Arguments.Length; ++iArg)
{
var sArg = ss.Arguments[iArg];
Identifier arg = DeserializeArgument(argser, sArg);
args.Add(arg);
}
}
var sig = new FunctionType(ret, args.ToArray());
return sig;
}
public FunctionInfo(ObjectName routineName, RoutineParameter[] parameters, DataType returnType, FunctionType functionType)
: base(routineName, parameters)
{
ReturnType = returnType;
FunctionType = functionType;
AssertUnboundAtEnd();
}
public FunctionInfo(ObjectName routineName, DataType returnType, FunctionType functionType)
: base(routineName)
{
ReturnType = returnType;
FunctionType = functionType;
AssertUnboundAtEnd();
}
/// <summary>
/// Инициализирует экземпляр класса Neuron с нулевыми значениями входных сигналов и случайными начальными весами.
/// </summary>
/// <param name="signalsCount">Число синапсов на входе нейрона.</param>
/// <param name="ft">Тип активационной функции нейрона.</param>
/// <param name="funcParam">Значение параметра активационной функции.</param>
public Neuron(int signalsCount, FunctionType ft, double funcParam)
{
SignalsIn = new double[signalsCount];
Weights = new double[signalsCount];
_param = funcParam;
var r = RandomProvider.GetThreadRandom();
Offset = Convert.ToDouble(r.Next(-100, 100)) / 1000;
for (int i = 0; i < SignalsIn.Length; ++i)
{
Weights[i] = Convert.ToDouble(r.Next(-100, 100)) / 1000; //инициализация весов
SignalsIn[i] = 0;
}
_activationFunc = ft;
switch (ft) //инициализация активационной функции нейрона
{
case FunctionType.Linear:
_afd = LinearFunc; //линейная
break;
case FunctionType.Sigmoid:
_afd = LogSigmoidFunc; //лог-сигмоидальная
break;
case FunctionType.HyperbolicTangent:
_afd = HyperbolicTangentFunc; //гиперболический тангенс
break;
case FunctionType.Threshold:
_afd = ThresholdFunc; //пороговая
break;
default:
throw new Exception("Неизвестный тип активационной функции");
}
}
public Function(string prefix, string name, ArrayList argumentList)
{
this.functionType = FunctionType.FuncUserDefined;
this.prefix = prefix;
this.name = name;
this.argumentList = new ArrayList(argumentList);
}
public FunctionDescriptor(
string assembly, string className, string name, string summary,
IEnumerable<TypedParameter> parameters, string returnType, FunctionType type,
bool isVisibleInLibrary = true, IEnumerable<string> returnKeys = null, bool isVarArg = false)
{
this.summary = summary;
Assembly = assembly;
ClassName = className;
Name = name;
if (parameters == null)
Parameters = new List<TypedParameter>();
else
{
Parameters = parameters.Select(
x =>
{
x.Function = this;
return x;
});
}
ReturnType = returnType == null ? "var[]..[]" : returnType.Split('.').Last();
Type = type;
ReturnKeys = returnKeys ?? new List<string>();
IsVarArg = isVarArg;
IsVisibleInLibrary = isVisibleInLibrary;
}
public Building(int id,int price,string name, FunctionType type)
{
ID = id;
Price = price;
Name = name;
Type = type;
}
public void Setup()
{
this.sc = new ServiceContainer();
this.x86 = new X86ArchitectureFlat32();
this.ppc = new PowerPcArchitecture32();
this.m = new ProcedureBuilder();
this.printfChr = new ProcedureCharacteristics()
{
VarargsParserClass =
"Reko.Libraries.Libc.PrintfFormatParser,Reko.Libraries.Libc"
};
this.x86PrintfSig = new FunctionType(
null,
StackId(null, 4, CStringType()),
StackId("...", 8, new UnknownType()));
this.x86SprintfSig = new FunctionType(
null,
StackId(null, 4, CStringType()),
StackId(null, 8, CStringType()),
StackId("...", 12, new UnknownType()));
this.ppcPrintfSig = new FunctionType(
null,
RegId(null, ppc, "r3", CStringType()),
RegId("...", ppc, "r4", new UnknownType()));
this.addrInstr = Address.Ptr32(0x123400);
}
public override string DetermineCallingConvention(FunctionType signature)
{
if (!signature.HasVoidReturn)
{
var reg = signature.ReturnValue.Storage as RegisterStorage;
if (reg != null)
{
if (reg != Registers.al && reg != Registers.ax)
return null;
}
var seq = signature.ReturnValue.Storage as SequenceStorage;
if (seq != null)
{
if (seq.Head != Registers.dx || seq.Tail != Registers.ax)
return null;
}
}
if (signature.Parameters.Any(p => !(p.Storage is StackArgumentStorage)))
return null;
if (signature.FpuStackDelta != 0 || signature.FpuStackArgumentMax >= 0)
return null;
if (signature.StackDelta == 0)
return "__cdecl";
else
return "__pascal";
}
public MlpNeuron(List<Connection> inputs, List<Connection> outputs,
FunctionType functionType, ITunableParameterService paramService)
{
Inputs = inputs;
Outputs = outputs;
_functionType = functionType;
_sigmoidAlpha = paramService.SigmoidAlpha;
}
internal BuiltinFunction(string/*!*/ name, MethodBase/*!*/[]/*!*/ originalTargets, Type/*!*/ declaringType, FunctionType functionType) {
Assert.NotNull(name);
Assert.NotNull(declaringType);
Assert.NotNullItems(originalTargets);
_data = new BuiltinFunctionData(name, originalTargets, declaringType, functionType);
_instance = _noInstance;
}
public void Setup()
{
this.mr = new MockRepository();
this.arch = new MipsLe32Architecture();
this.typeLoader = mr.Stub<ISerializedTypeVisitor<DataType>>();
this.ssig = null;
this.sig = null;
}
public FunctionDeclarationHeader(SymbolDefinition name, AccessModifier visibility, FunctionType type)
: base(CodeElementType.FunctionDeclarationHeader)
{
this.FunctionName = name;
this.Visibility = visibility;
this.UserDefinedType = type != null ? type : FunctionType.Undefined;
this.Profile = new ParametersProfile();
}
public void ApplyConvention(SerializedSignature ssig, FunctionType sig)
{
string d = ssig.Convention;
if (d == null || d.Length == 0)
d = DefaultConvention;
sig.StackDelta = 0;
sig.FpuStackDelta = FpuStackOffset;
}
/// <summary>
/// Finds a typedef with the same return type and parameter types.
/// </summary>
/// <param name="typedefs">The typedef list to search.</param>
/// <param name="functionType">The function to match.</param>
/// <returns>The matching typedef, or null if not found.</returns>
private static TypedefDecl FindMatchingTypedef(IEnumerable<Typedef> typedefs, FunctionType functionType)
{
return (from typedef in typedefs
let type = (FunctionType)typedef.Declaration.Type.GetPointee()
where type.ReturnType == functionType.ReturnType &&
type.Parameters.SequenceEqual(functionType.Parameters, ParameterTypeComparer.Instance)
select typedef.Declaration).SingleOrDefault();
}
public Hero(int id,string name,FunctionType type,string imgPath, string description)
{
Id = id;
Name = name;
Type = type;
ImgPath = imgPath;
Description = description;
}
/// <summary>
/// Creates a built-in function for a .NET method declared on a type.
/// </summary>
internal static BuiltinFunction MakeMethod(string name, MethodBase[] infos, Type declaringType, FunctionType ft)
{
foreach(MethodBase mi in infos){
if (mi.ContainsGenericParameters)
return new GenericBuiltinFunction(name, infos, declaringType, ft);
}
return new BuiltinFunction(name, infos, declaringType, ft);
}
public Building(int id,int price,string name,FunctionType type,string imgPath, string description)
{
Id = id;
Price = price;
Name = name;
Type = type;
ImgPath = imgPath;
Description = description;
}
public static void Add(List<Building> bl, FunctionType type, string name, int price,string imgPath, string description, ref int Startnum, int num)
{
for (int i = Startnum; i < Startnum + num; i++)
{
Building b = new Building(i, price, name, type,imgPath,description);
bl.Add(b);
}
Startnum += num;
}
public Function Find(FunctionType type, bool isStatic)
{
MakeConcrete();
FunctionGroupName gname = new FunctionGroupName(type, isStatic);
FunctionGroupName oldName = functions.Find(gname);
if(oldName != null)
return oldName.GetFunction();
return null;
}
/// <summary>
/// Инициализирует экземпляр класса Layer с заданным числом нейронов c одним входным сигналом(используется когда связи неизвестны заранее).
/// </summary>
/// <param name="neuronCount">Число нейронов для слоя.</param>
/// <param name="func">Активационная функция по-умолчанию.</param>
public Layer(int neuronCount, FunctionType func)
{
_neurons = new Neuron[neuronCount]; //сами нейроны в конструкторе слоя не создаются, только резервируется место под них
for (int i = 0; i < _neurons.Length; ++i)
_neurons[i] = new Neuron(1, func, 1.0);
LayerFunction = func;
FuncDefaultParam = 1.0;
}
private static Function EmitFunction(Module module, MethodBase method)
{
var methodInfo = method as MethodInfo;
var methodConstructor = method as ConstructorInfo;
var declaringType = method.DeclaringType;
if (methodInfo == null && methodConstructor == null)
throw new CudaSharpException("Unknown MethodBase type " + method.GetType().FullName);
if (declaringType == null)
throw new CudaSharpException("Could not find the declaring type of " + method.Name.StripNameToValidPtx());
var parameters = method.GetParameters().Select(p => p.ParameterType);
if (methodConstructor != null)
parameters = new[] { declaringType.MakeByRefType() }.Concat(parameters);
if (methodInfo != null && methodInfo.IsStatic == false)
{
if (declaringType.IsValueType == false)
throw new CudaSharpException("Cannot compile object instance methods (did you forget to mark the method as static?)");
parameters = new[] { declaringType.MakeByRefType() }.Concat(parameters);
}
var llvmParameters =
parameters.Select(t => ConvertType(module, t)).ToArray();
var funcType = new FunctionType(ConvertType(module, methodInfo == null ? typeof(void) : methodInfo.ReturnType), llvmParameters);
var intrinsic = method.GetCustomAttribute<Gpu.BuiltinAttribute>();
if (intrinsic != null)
{
var name = intrinsic.Intrinsic;
var preExisting = module.GetFunction(name);
if (preExisting != null)
return preExisting;
return module.CreateFunction(name, funcType);
}
var function = module.CreateFunction(methodConstructor == null ? method.Name.StripNameToValidPtx() : declaringType.Name.StripNameToValidPtx() + "_ctor", funcType);
var block = new Block("entry", module.Context, function);
var writer = new InstructionBuilder(module.Context, block);
var opcodes = method.Disassemble().ToList();
FindBranchTargets(opcodes, module.Context, function);
var body = method.GetMethodBody();
var efo = new EmitFuncObj(module, function, body, writer, null, new Stack<Value>(),
body == null ? null : new Value[body.LocalVariables.Count], new Value[llvmParameters.Length]);
PrintHeader(efo);
foreach (var opcode in opcodes)
{
if (EmitFunctions.ContainsKey(opcode.Opcode) == false)
throw new CudaSharpException("Unsupported CIL instruction " + opcode.Opcode);
var func = EmitFunctions[opcode.Opcode];
efo.Argument = opcode.Parameter;
func(efo);
}
return function;
}
private static bool IsMatchingOpType(FunctionType opType, OperatorTypeButton otb)
{
return((otb.MetaOp.Inputs.Count > 0) &&
((otb.MetaOp.Inputs[0].OpPart.Type == opType) ||
(otb.MetaOp.Inputs[0].OpPart.Type == FunctionType.Generic)));
}
public override void VisitCallInstruction(CallInstruction ci)
{
FunctionType sig = GetProcedureSignature(ci.Callee);
if (sig != null && sig.ParametersValid)
{
var procCallee = ((ProcedureConstant)ci.Callee).Procedure;
var ab = new ApplicationBuilder(
Procedure.Architecture,
Procedure.Frame,
ci.CallSite,
new ProcedureConstant(program.Platform.PointerType, procCallee),
sig,
false);
if (!sig.HasVoidReturn)
{
varLive.Def(ab.Bind(sig.ReturnValue));
}
foreach (Identifier arg in sig.Parameters)
{
if (arg.Storage is OutArgumentStorage)
{
varLive.Def(ab.Bind(arg));
}
}
foreach (Identifier arg in sig.Parameters)
{
if (!(arg.Storage is OutArgumentStorage))
{
varLive.Use(ab.Bind(arg));
}
}
}
else
{
var pc = ci.Callee as ProcedureConstant;
if (pc == null)
{
return;
}
var procCallee = pc.Procedure as Procedure;
if (procCallee == null)
{
return;
}
if (state.PropagateThroughExitNodes)
{
PropagateToCalleeExitBlocks(stmCur);
}
// Update trash information.
ProcedureFlow pi = mpprocData[procCallee];
ProcedureFlow item = mpprocData[Procedure];
// The registers that are still live before a call are those
// that were live after the call and were bypassed by the called function
// or used by the called function.
var ids = new HashSet <RegisterStorage>(pi.TrashedRegisters);
ids.ExceptWith(pi.ByPass);
varLive.Identifiers.ExceptWith(ids);
varLive.Identifiers.UnionWith(pi.MayUse);
// varLive.BitSet = pi.MayUse | ((pi.ByPass | ~pi.TrashedRegisters) & varLive.BitSet);
varLive.Grf = pi.grfMayUse | ((pi.grfByPass | ~pi.grfTrashed) & varLive.Grf);
// Any stack parameters are also considered live.
MarkLiveStackParameters(ci);
}
}
public override bool VisitFunctionType(FunctionType function, TypeQualifiers quals)
{
Context.Return.Write(Context.ReturnVarName);
return(true);
}
public override void OnProcedureLeft(FunctionType procedureSignature)
{
throw new System.NotImplementedException();
}
public override bool VisitFunctionType(FunctionType function, TypeQualifiers quals)
{
var returnType = function.ReturnType;
return(returnType.Visit(this));
}
public override void OnProcedureLeft(FunctionType sig)
{
}
private static BuiltinFunction MakeBuiltinFunction(string name, MethodInfo info, MethodBase[] targets, FunctionType functionType)
{
switch (info.GetParameters().Length)
{
case 0: return(new OptimizedFunction0(name, info, targets, functionType));
case 1: return(new OptimizedFunction1(name, info, targets, functionType));
case 2: return(new OptimizedFunction2(name, info, targets, functionType));
case 3: return(new OptimizedFunction3(name, info, targets, functionType));
case 4: return(new OptimizedFunction4(name, info, targets, functionType));
case 5: return(new OptimizedFunction5(name, info, targets, functionType));
}
throw new InvalidOperationException("too many args");
}
public OptimizedFunctionN(string name, MethodInfo info, MethodBase[] targets, FunctionType functionType) : base(name, targets, functionType)
{
target = IronPython.Compiler.CodeGen.CreateDelegate(info, typeof(CallTargetN)) as CallTargetN;
}
/// <summary>
/// Finds a typedef with the same return type and parameter types.
/// </summary>
/// <param name="typedefs">The typedef list to search.</param>
/// <param name="functionType">The function to match.</param>
/// <returns>The matching typedef, or null if not found.</returns>
private static TypedefDecl FindMatchingTypedef(IEnumerable <Typedef> typedefs, FunctionType functionType)
{
return((from typedef in typedefs
let type = (FunctionType)typedef.Declaration.Type.GetPointee()
where type.ReturnType == functionType.ReturnType &&
type.Parameters.SequenceEqual(functionType.Parameters, ParameterTypeComparer.Instance)
select typedef.Declaration).SingleOrDefault());
}
public PseudoProcedure(string name, FunctionType sig) : base(name)
{
this.sig = sig;
}
public CodeFormatter VisitFunctionType(FunctionType ft)
{
throw new NotImplementedException();
}
public virtual TypePrinterResult VisitDelegate(FunctionType function)
{
throw new NotImplementedException();
}
public void Uvr_Signature()
{
var arch = new FakeArchitecture();
var pb = new ProgramBuilder(arch);
var _r1 = arch.GetRegister("r1");
var _r2 = arch.GetRegister("r2");
pb.Add("main", m =>
{
var r1 = m.Frame.EnsureRegister(_r1);
m.Assign(m.Frame.EnsureRegister(m.Architecture.StackRegister), m.Frame.FramePointer);
m.Call("foo", 0);
m.MStore(m.Word32(0x123420), r1);
});
pb.Add("foo", m =>
{
var r1 = m.Frame.EnsureRegister(_r1);
var r2 = m.Frame.EnsureRegister(_r2);
m.Assign(m.Frame.EnsureRegister(m.Architecture.StackRegister), m.Frame.FramePointer);
m.Assign(r1, m.Mem32(m.Word32(0x123400)));
m.MStore(m.Word32(0x123408), r1);
m.Assign(r2, m.Mem32(m.Word32(0x123410)));
m.MStore(m.Word32(0x123418), r2);
m.Return();
m.Procedure.Signature = FunctionType.Func(
new Identifier(null, PrimitiveType.Word32, _r1),
new Identifier("arg1", PrimitiveType.Word32, _r2));
});
pb.BuildProgram();
var sExp =
#region Expected
@"// main
// Return size: 0
define main
main_entry:
def r2
// succ: l1
l1:
r1_4 = foo(r2)
Mem5[0x00123420:word32] = r1_4
main_exit:
===
// foo
// Return size: 0
word32 foo(word32 arg1)
foo_entry:
def fp
def Mem0
// succ: l1
l1:
r63_2 = fp
r1_4 = Mem0[0x00123400:word32]
Mem5[0x00123408:word32] = r1_4
r2_6 = Mem5[0x00123410:word32]
Mem7[0x00123418:word32] = r2_6
return
// succ: foo_exit
foo_exit:
use r1_4
===
";
#endregion
RunTest(sExp, pb.Program);
}
public virtual TypePrinterResult VisitFunctionType(FunctionType function,
TypeQualifiers quals)
{
throw new NotImplementedException();
}
public bool VisitDelegateType(FunctionType function, string type)
{
Context.Return.Write("{0} == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate({0})",
Context.Parameter.Name);
return(true);
}
public string DetermineCallingConvention(FunctionType signature)
{
throw new NotImplementedException();
}
public CSharpTypePrinterResult VisitDelegate(FunctionType function)
{
return(string.Format("delegate {0} {{0}}({1})",
function.ReturnType.Visit(this),
VisitParameters(function.Parameters, hasNames: true)));
}
public FunctionWrapper(FunctionType type = FunctionType.Liner)
{
ChoseFun(type);
}
public IEnumerable <WorkItem> VisitFunctionType(FunctionType ft)
{
throw new NotImplementedException();
}
public FunctionAndOperatorCommandParameter(UserInteractionType functionUserInteractionType, UserInteractionType operatorUserInteractionType, FunctionType functionType, OperatorType operatorType)
{
FunctionUserInteractionType = functionUserInteractionType;
OperatorUserInteractionType = operatorUserInteractionType;
FunctionType = functionType;
OperatorType = operatorType;
FunctionText = Functions.GetFunctionText(functionType);
OperatorText = Operators.GetOperatorText(operatorType);
}
/// <summary>
/// Deserializes the signature <paramref name="ss"/>. Any instantiated
/// registers or stack variables are introduced into the Frame.
/// </summary>
/// <param name="ss"></param>
/// <param name="frame"></param>
/// <returns></returns>
public FunctionType?Deserialize(SerializedSignature?ss, Frame frame)
{
if (ss == null)
{
return(null);
}
// If there is no explict return address size,
// use the architecture's default return address size.
var retAddrSize = ss.ReturnAddressOnStack != 0
? ss.ReturnAddressOnStack
: this.Architecture.ReturnAddressOnStack;
if (!ss.ParametersValid)
{
return(new FunctionType
{
StackDelta = ss.StackDelta,
ReturnAddressOnStack = retAddrSize,
});
}
var parameters = new List <Identifier>();
Identifier?ret = null;
if (UseUserSpecifiedStorages(ss))
{
this.argDeser = new ArgumentDeserializer(
this,
Architecture,
frame,
retAddrSize,
Architecture.WordWidth.Size);
if (ss.Arguments != null)
{
FpuStackGrowing = true;
for (int iArg = 0; iArg < ss.Arguments.Length; ++iArg)
{
var sArg = ss.Arguments[iArg];
var arg = DeserializeArgument(sArg, ss.Convention);
if (arg != null)
{
parameters.Add(arg);
}
}
}
if (ss.ReturnValue != null)
{
FpuStackGrowing = false;
ret = DeserializeArgument(ss.ReturnValue, "");
}
FpuStackOffset = -FpuStackOffset;
var sig = FunctionType.Create(ret, parameters.ToArray());
sig.IsVariadic = this.IsVariadic;
sig.IsInstanceMetod = ss.IsInstanceMethod;
ApplyConvention(ss, sig);
return(sig);
}
else
{
var dtRet = ss.ReturnValue != null && ss.ReturnValue.Type != null
? ss.ReturnValue.Type.Accept(TypeLoader)
: null;
var dtThis = ss.EnclosingType != null
? new Pointer(ss.EnclosingType.Accept(TypeLoader), Architecture.PointerType.BitSize)
: null;
var dtParameters = ss.Arguments != null
? ss.Arguments
.TakeWhile(p => p.Name != "...")
.Select(p => p.Type !.Accept(TypeLoader))
.ToList()
: new List <DataType>();
// A calling convention governs the storage of a the
// parameters
var cc = platform.GetCallingConvention(ss.Convention);
if (cc == null)
{
// It was impossible to determine a calling convention,
// so we don't know how to decode this signature accurately.
return(new FunctionType
{
StackDelta = ss.StackDelta,
ReturnAddressOnStack = retAddrSize,
});
}
var res = new CallingConventionEmitter();
cc.Generate(res, dtRet, dtThis, dtParameters);
if (res.Return != null)
{
ret = new Identifier(
res.Return is RegisterStorage retReg ? retReg.Name : "",
dtRet ?? VoidType.Instance,
res.Return);
}
if (res.ImplicitThis != null)
{
var param = new Identifier("this", dtThis !, res.ImplicitThis);
parameters.Add(param);
}
bool isVariadic = false;
if (ss.Arguments != null)
{
for (int i = 0; i < ss.Arguments.Length; ++i)
{
if (ss.Arguments[i].Name == "...")
{
isVariadic = true;
}
else
{
var name = GenerateParameterName(ss.Arguments[i].Name, dtParameters[i], res.Parameters[i]);
var param = new Identifier(name, dtParameters[i], res.Parameters[i]);
parameters.Add(param);
}
}
}
var ft = FunctionType.Create(ret, parameters.ToArray());
ft.IsInstanceMetod = ss.IsInstanceMethod;
ft.StackDelta = ss.StackDelta != 0
? ss.StackDelta
: res.StackDelta;
ft.FpuStackDelta = res.FpuStackDelta;
ft.ReturnAddressOnStack = retAddrSize;
ft.IsVariadic = isVariadic;
return(ft);
}
}
public FunctionToken(string name, Func <double, double> function, FunctionType functionType)
{
this.function = function;
this.Name = name;
FunctionType = functionType;
}
public override bool VisitFunctionType(FunctionType function, TypeQualifiers quals)
{
Context.Return.Write("{0} == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate({0})",
Context.Parameter.Name);
return(true);
}
public override TType GetFunction <TType, TModel>(Expression <Func <TModel, bool> > expression, Expression <Func <TModel, TType> > selectField, FunctionType functionType, bool compileSp = false)
{
var query = new MongoDBLambdaQuery <TModel>(dbContext);
query.Select(selectField.Body);
query.Where(expression);
var collection = _MongoDB.GetCollection <TModel>(query.QueryTableName);
object result = null;
//https://blog.csdn.net/shiyaru1314/article/details/52370478
//https://www.jb51.net/article/113820.htm
//https://blog.csdn.net/u013476435/article/details/81560089
switch (functionType)
{
case FunctionType.COUNT:
result = collection.Count(query.__MongoDBFilter);
break;
default:
throw new NotSupportedException("MongoDB不支持的函数:" + functionType);
}
return(ObjectConvert.ConvertObject <TType>(result));
}
public void VisitFunctionType(FunctionType ft)
{
throw new NotImplementedException();
}
//public TType Sum<TType, TModel>(Expression<Func<TModel, bool>> expression, string field, bool compileSp = false) where TModel : IModel, new()
//{
// return GetFunction<TType, TModel>(expression, field, FunctionType.SUM, compileSp);
//}
#endregion
internal abstract TType GetFunction <TType, TModel>(Expression <Func <TModel, bool> > expression, Expression <Func <TModel, TType> > selectField, FunctionType functionType, bool compileSp = false) where TModel : IModel, new();
public override void OnProcedureLeft(FunctionType procedureSignature)
{
}
public override void OnAfterCall(FunctionType sigCallee)
{
}
public OptimizedFunctionAny(string name, MethodInfo[] infos, MethodBase[] targets, FunctionType functionType) : base(name, targets, functionType)
{
for (int i = 0; i < infos.Length; i++)
{
Debug.Assert(infos[i].IsStatic);
switch (infos[i].GetParameters().Length)
{
case 0: target0 = IronPython.Compiler.CodeGen.CreateDelegate(infos[i], typeof(CallTarget0)) as CallTarget0; break;
case 1:
if (!infos[i].GetParameters()[0].ParameterType.HasElementType)
{
target1 = IronPython.Compiler.CodeGen.CreateDelegate(infos[i], typeof(CallTarget1)) as CallTarget1;
}
else
{
targetN = IronPython.Compiler.CodeGen.CreateDelegate(infos[i], typeof(CallTargetN)) as CallTargetN;
}
break;
case 2: target2 = IronPython.Compiler.CodeGen.CreateDelegate(infos[i], typeof(CallTarget2)) as CallTarget2; break;
case 3: target3 = IronPython.Compiler.CodeGen.CreateDelegate(infos[i], typeof(CallTarget3)) as CallTarget3; break;
case 4: target4 = IronPython.Compiler.CodeGen.CreateDelegate(infos[i], typeof(CallTarget4)) as CallTarget4; break;
case 5: target5 = IronPython.Compiler.CodeGen.CreateDelegate(infos[i], typeof(CallTarget5)) as CallTarget5; break;
}
}
}
private List <Mapping> GetMappings(InputKey inputKey, IEmulationSlot slot, FunctionType functionType)
{
var filtered = slot.Preset.FilterByKey(inputKey);
var mappings = new List <Mapping>();
switch (functionType)
{
case FunctionType.Button:
{
// Normal buttons
foreach (var presetButton in filtered.Buttons)
{
var button = presetButton.Button;
var keys = slot.Preset.GetKeys(presetButton);
mappings.Add(new Mapping(button, keys));
}
// Custom buttons
foreach (var customFunction in filtered.CustomFunctions)
{
var xboxFunction = (XboxCustomFunction)customFunction.Function;
var funcType = Helpers.CustomFunctionHelper.GetFunctionType(xboxFunction);
if (funcType == functionType)
{
var button = (uint)Helpers.CustomFunctionHelper.GetXboxButton(xboxFunction);
var keys = slot.Preset.GetKeys(customFunction);
mappings.Add(new Mapping(button, keys));
}
}
}
break;
case FunctionType.Axis:
{
// Normal axes
foreach (var presetAxis in filtered.Axes)
{
mappings.Add(new Mapping(presetAxis.Axis, slot.Preset.GetKeys(presetAxis), presetAxis.Value));
}
// Custom axes
foreach (var presetCustom in filtered.CustomFunctions)
{
var xboxCustomFunction = (XboxCustomFunction)presetCustom.Function;
var funcType = Helpers.CustomFunctionHelper.GetFunctionType(xboxCustomFunction);
if (funcType == functionType)
{
XboxAxisPosition pos;
var axis = Helpers.CustomFunctionHelper.GetXboxAxis(xboxCustomFunction, out pos);
mappings.Add(new Mapping((uint)axis, slot.Preset.GetKeys(presetCustom), pos));
}
}
}
break;
case FunctionType.Dpad:
// Normal dpad directions
foreach (var presetDpad in filtered.Dpads)
{
mappings.Add(new Mapping(presetDpad.Direction, slot.Preset.GetKeys(presetDpad)));
}
// Custom dpad directions
foreach (var customDpad in filtered.CustomFunctions)
{
var xboxFunction = (XboxCustomFunction)customDpad.Function;
var funcType = Helpers.CustomFunctionHelper.GetFunctionType(xboxFunction);
if (funcType == functionType)
{
var direction = Helpers.CustomFunctionHelper.GetDpadDirection(xboxFunction);
var keys = slot.Preset.GetKeys(customDpad);
mappings.Add(new Mapping(direction, keys));
}
}
break;
case FunctionType.Trigger:
{
// Normal triggers
foreach (var presetTrigger in filtered.Triggers)
{
var trigger = presetTrigger.Trigger;
var keys = slot.Preset.GetKeys(presetTrigger);
mappings.Add(new Mapping(trigger, keys));
}
// Custom triggers
foreach (var customFunction in filtered.CustomFunctions)
{
var xboxFunction = (XboxCustomFunction)customFunction.Function;
var funcType = Helpers.CustomFunctionHelper.GetFunctionType(xboxFunction);
if (funcType == functionType)
{
var trigger = (uint)Helpers.CustomFunctionHelper.GetXboxTrigger(xboxFunction);
var keys = slot.Preset.GetKeys(customFunction);
mappings.Add(new Mapping(trigger, keys));
}
}
}
break;
default:
break;
}
return(mappings);
}
