public int callFunc(FuncType funcType, string s)
{
int androidFuncType = (int)funcType;
// TODO
return(ao.Call <int>("callFunc", androidFuncType, s));
}
//public FuncSelector(string name, Action<List<string>> f, params string[] args)
//{
// DisplayName = name;
// FunctionB = f;
// type = FuncType.STRLIST;
// FunctionParams = args;
//}
public FuncSelector(string name, Action <IExperimentFace, List <string> > f, params string[] args)
{
DisplayName = name;
FunctionC = f;
type = FuncType.EXPERIMENTFACE_STRING;
FunctionParams = args;
}
public UMCAttribute(FuncType currentType, Type classtype, string key)
{
//构造函数
this.currentType = currentType;
this.classType = classtype;
this.key = key;
}
public bool isFunctionSupported(FuncType type) //1暂停游戏,2进入用户中心,3进入论坛,4处理应用跳转(旧),5显示浮动工具栏,6隐藏浮动工具栏,7处理应用跳转(新)
{
#if UNITY_IOS && !UNITY_EDITOR
switch (type)
{
case FuncType.QUICK_SDK_FUNC_TYPE_ENTER_BBS:
return(quicksdk_nativeIsFunctionTypeSupported(3));
case FuncType.QUICK_SDK_FUNC_TYPE_ENTER_USER_CENTER:
return(quicksdk_nativeIsFunctionTypeSupported(2));
case FuncType.QUICK_SDK_FUNC_TYPE_SHOW_TOOLBAR:
return(quicksdk_nativeIsFunctionTypeSupported(5));
case FuncType.QUICK_SDK_FUNC_TYPE_HIDE_TOOLBAR:
return(quicksdk_nativeIsFunctionTypeSupported(6));
case FuncType.QUICK_SDK_FUNC_TYPE_PAUSED_GAME:
return(quicksdk_nativeIsFunctionTypeSupported(1));
case FuncType.QUICK_SDK_FUNC_TYPE_ENTER_CUSTOMER_CENTER:
return(quicksdk_nativeIsFunctionTypeSupported(7));
default:
return(false);
}
#elif UNITY_ANDROID && !UNITY_EDITOR
QuickUnitySupportAndroid androidSupport = QuickUnitySupportAndroid.getInstance();
return(androidSupport.isFuncSupport(type));
#else
return(false);
#endif
}
private bool IsPredicate(ITypeSymbol type)
{
if (!ExpressionType.Equals(type.OriginalDefinition, SymbolEqualityComparer.Default) ||
!(type is INamedTypeSymbol namedType))
{
return(false);
}
var actualFuncType = namedType.TypeArguments[0];
if (!FuncType.Equals(actualFuncType.OriginalDefinition, SymbolEqualityComparer.Default) ||
!(actualFuncType is INamedTypeSymbol actualFuncNamedType))
{
return(false);
}
var returnType = actualFuncNamedType.TypeArguments[1];
if (returnType.SpecialType != SpecialType.System_Boolean)
{
return(false);
}
return(true);
}
public DeclareFieldElement(VariableLexeme lexeme, List <TreeElement> body, FuncType type) : base(lexeme.File, lexeme.Position, lexeme.Line,
lexeme.CharIndex)
{
FieldName = lexeme.Value;
Body = body;
Type = type;
}
public Function(MethodInfo mi, object target, FuncType returnType)
{
if (mi == null)
{
throw new ArgumentNullException();
}
if (!mi.IsStatic && target == null)
{
throw new MethodIsNotStaticException();
}
meth = (Func <object[], object>)mi.CreateDelegate(typeof(Func <object[], object>), target);
Name = mi.Name;
ReturnType = returnType;
if (mi.GetCustomAttribute <DescriptionAttribute>() != null)//проверка на наличие атрибута описания
{
Description = mi.GetCustomAttribute <DescriptionAttribute>().Description;
}
if (mi.GetCustomAttribute <FuncGroupAttribute>() != null)//проверка на наличие атрибута группы
{
GroupName = mi.GetCustomAttribute <FuncGroupAttribute>().GroupName;
}
else
{
GroupName = "None";
}
}
public Function(Delegate func, FuncType returnType, string Name = "") : this(func.Method, func.Target, returnType)
{
if (Name.Length > 0)
{
this.Name = Name;
}
}
public void callFunction(FuncType type)//only for android
{
#if UNITY_ANDROID && !UNITY_EDITOR
QuickUnitySupportAndroid androidSupport = QuickUnitySupportAndroid.getInstance();
androidSupport.callFunc(type);
#endif
}
public override LLVMTypeRef visitFuncType(FuncType funcType)
{
LLVMTypeRef retType = funcType.ReturnType.accept(this);
int parameterTypesCount = funcType.ParameterTypes.Count;
Symbol funcOwner = funcType.symbol.owner;
bool isMember = funcOwner.kind == Symbol.Kind.STRUCT;
if (isMember)
{
parameterTypesCount++;
}
LLVMTypeRef[] paramTypes = new LLVMTypeRef[parameterTypesCount];
if (isMember)
{
paramTypes[0] = HEAP_PTR(((Symbol.StructSymbol)funcOwner).llvmTypeRef);
for (int i = 1; i < paramTypes.Length; i++)
{
paramTypes[i] = funcType.ParameterTypes[i - 1].accept(this);
}
}
else
{
for (int i = 0; i < paramTypes.Length; i++)
{
paramTypes[i] = funcType.ParameterTypes[i].accept(this);
}
}
return(LLVM.FunctionType(retType, paramTypes, funcType.isVarArg));
}
public FuncStandard(string path, bool isCoroutine = false, bool autoResetCoroutine = false, bool required = true)
{
Path = path;
Required = required;
//SplitPath = path.Split('.');
//IsCoroutine = isCoroutine;
// AutoResetCoroutine = autoResetCoroutine;
if (isCoroutine)
{
if (autoResetCoroutine)
{
FuncType = FuncType.AutoCoroutine;
}
else
{
FuncType = FuncType.SingleUseCoroutine;
}
}
else
{
FuncType = FuncType.Function;
}
}
//Выбор функции
private void BoxWithFunc_SelectedIndexChanged(object sender, EventArgs e)
{
TValue.Enabled = true;
MinValue.Enabled = true;
MaxValue.Enabled = true;
var selected = BoxWithFunc.SelectedIndex;
switch (selected)
{
case 0:
Type = FuncType.FrequencyResponse; //ачх
break;
case 1:
Type = FuncType.PhaseResponse;//фчх
KValue.Enabled = true;
break;
case 2:
Type = FuncType.BodePlot;//лачх
IValue.Enabled = true;
break;
}
}
public FuncSelector(string name, Action <IExperimentFace, List <string> > f, params RomVersion[] args)
{
DisplayName = name;
FunctionC = f;
type = FuncType.EXPERIMENTFACE_ROMS;
RomParams = args;
}
/// <summary>
/// 点击全部按钮
/// </summary>
/// <param name="isClick"></param>
public void ClickAll()
{
if (ItemMgr.Instance.itemList != null)
{
Ptype = 0;
CollatingType(Ptype);
}
}
/// <summary>
/// �f�V���A���C�Y���ꂽ�I�u�W�F�N�g��擾����
/// </summary>
/// <param name="type">���̎��</param>
/// <param name="bytes">�V���A���C�Y�ς݃f�[�^</param>
/// <param name="offset">�f�[�^�̊J�n�ʒu</param>
/// <param name="nextOffset">���̃f�[�^�̊J�n�ʒu</param>
/// <returns>���s���I�u�W�F�N�g</returns>
public static TimeFuncBase GetDeserialized(FuncType type, byte[] bytes, int offset, out int nextOffset)
{
// �I�u�W�F�N�g�쐬
var func = CreateInstance(type);
// �f�V���A���C�Y
nextOffset = func.Deserialize(bytes, offset);
return func;
}
public void DrawOsc(FuncType funcType = FuncType.Normal, int periods = 1)
{
OSCtype = funcType;
Periods[0] = periods;
PeriodsText.Text = Periods[0].ToString();
signal.SetPeriods(Periods[0]);
OscToChart();
}
public static FuncModel Get(string name, FuncType funcType = FuncType.URLFUNCTION)
{
using (var db = new LiteDatabase(@"LiteDb/Funcs.db"))
{
var col = db.GetCollection <FuncModel>("funcs");
return(col.Find(m => m.Name == name && m.Type == funcType).FirstOrDefault());
}
}
public FunctionBuilder()
{
localVariables = new Dictionary <string, LocalBuilder>();
localFinals = new Dictionary <string, LocalBuilder>();
methodBuilder = null;
constructorBuilder = null;
type = FuncType.DEFAULT;
parameterAttributes = ParameterAttributes.None;
}
public bool isFunctionTypeSupported(FuncType type)//1暂停游戏,2进入用户中心,3进入论坛,4处理应用跳转(旧),5显示浮动工具栏,6隐藏浮动工具栏,7处理应用跳转(新)
{
#if UNITY_ANDROID && !UNITY_EDITOR
QuickUnitySupportAndroid androidSupport = QuickUnitySupportAndroid.getInstance();
return(androidSupport.isFuncSupport(type));
#else
return(false);
#endif
}
private HelpProperty GetFuncTypeHelp(FuncType type)
{
HelpProperty answer = new HelpProperty(_prefix: "{count}");
foreach (IInterpreterFunction f in Interpreter.GetFullLibrary().Where(func => func.ReturnType == type))
{
answer.Add(f.Description);
}
return(answer);
}
//////////////////////////////////////////////////////////////////////////
// Bind
//////////////////////////////////////////////////////////////////////////
public Func bind(List args)
{
if (args.sz() == 0) return this;
if (args.sz() > @params().sz()) throw ArgErr.make("args.size > params.size").val;
Type[] newParams = new Type[@params().sz()-args.sz()];
for (int i=0; i<newParams.Length; ++i)
newParams[i] = ((Param)@params().get(args.sz()+i)).m_type;
FuncType newType = new FuncType(newParams, this.returns());
return new BindFunc(newType, this, args);
}
public void CreateFunc(FuncType type)
{
if (curFuncType != type)
{
if (m_CurFunc != null)
{
m_CurFunc.RemoveFunc();
}
m_CurFunc = funcTypes[type].CreateFunc();
m_CurFuncType = type;
}
}
private static void GetFuncsFromType(Type typeWithMethods, FuncType funcType)
{
foreach (MethodInfo mi in typeWithMethods.GetRuntimeMethods())
{
Function buffer;
try
{
buffer = new Function(mi, null, funcType);
AddToArray(ref library, buffer);
}
catch { };
}
}
public ColumnSpec(string columnName, Func <T, HtmlString> htmlStringValueFunc, int gridWidth,
DhtmlxGridColumnDataType dhtmlxGridColumnDataType, DhtmlxGridColumnFormatType dhtmlxGridColumnFormatType,
DhtmlxGridColumnAlignType dhtmlxGridColumnAlignType, DhtmlxGridColumnSortType dhtmlxGridColumnSortType,
DhtmlxGridColumnFilterType dhtmlxGridColumnFilterType,
DhtmlxGridColumnAggregationType dhtmlxGridColumnAggregationType, Func <T, string> cssClassFunction,
Func <T, string> titleFunction)
: this(
columnName, gridWidth, dhtmlxGridColumnDataType, dhtmlxGridColumnFormatType, dhtmlxGridColumnAlignType,
dhtmlxGridColumnSortType, dhtmlxGridColumnFilterType, dhtmlxGridColumnAggregationType, cssClassFunction,
titleFunction)
{
_htmlStringValueFunc = htmlStringValueFunc;
_funcType = FuncType.HtmlString;
}
public ColumnSpec(string columnName, Func <T, bool?> nullableBoolValueFunc, int gridWidth,
DhtmlxGridColumnDataType dhtmlxGridColumnDataType, DhtmlxGridColumnFormatType dhtmlxGridColumnFormatType,
DhtmlxGridColumnAlignType dhtmlxGridColumnAlignType, DhtmlxGridColumnSortType dhtmlxGridColumnSortType,
DhtmlxGridColumnFilterType dhtmlxGridColumnFilterType,
DhtmlxGridColumnAggregationType dhtmlxGridColumnAggregationType, Func <T, string> cssClassFunction,
Func <T, string> titleFunction)
: this(
columnName, gridWidth, dhtmlxGridColumnDataType, dhtmlxGridColumnFormatType, dhtmlxGridColumnAlignType,
dhtmlxGridColumnSortType, dhtmlxGridColumnFilterType, dhtmlxGridColumnAggregationType, cssClassFunction,
titleFunction)
{
_nullableBoolValueFunc = nullableBoolValueFunc;
_funcType = FuncType.NullableBool;
}
void OnGUI()
{
var enumNames = System.Enum.GetNames(typeof(FuncType));
var newFuncType = (FuncType)GUILayout.SelectionGrid((int)_funcType, enumNames, enumNames.Length);
if (newFuncType != _funcType)
{
_startRequested = true;
_funcType = newFuncType;
}
if (GUILayout.Button("Restart"))
{
_startRequested = true;
}
_showError = GUILayout.Toggle(_showError, "ShowError");
GUILayout.Label("spring stiffness: " + _springStiffness.ToString("N4"));
var log = Mathf.Log10(_springStiffness);
var newLog = GUILayout.HorizontalSlider(log, -3f, 4f);
if (newLog != log)
{
_startRequested = true;
_springStiffness = Mathf.Pow(10f, newLog);
}
GUILayout.Label("spring dumper: " + _springDumper.ToString("N4"));
log = Mathf.Log10(_springDumper);
newLog = GUILayout.HorizontalSlider(log, -2f, 2f);
if (newLog != log)
{
_startRequested = true;
_springDumper = Mathf.Pow(10f, newLog);
}
if (_showError)
{
var exact = _positionFunc(_time).x;
GUILayout.Label("euler error: " + Mathf.Abs(_eulerState.position.x - exact) / 300f);
GUILayout.Label("semi-implicit Euler error: " + Mathf.Abs(_semiImplicitEulerState.position.x - exact) / 300f);
GUILayout.Label("verlet error: " + Mathf.Abs(_verletState.position.x - exact) / 300f);
}
else
{
var eulerEnergy = _energyFunc(_eulerState.position, _eulerState.velocity);
var siEulerEnergy = _energyFunc(_semiImplicitEulerState.position, _semiImplicitEulerState.velocity);
var verletEnergy = _energyFunc(_verletState.position, _verletState.velocity);
GUILayout.Label("euler energy: " + (eulerEnergy / _initialEnergy));
GUILayout.Label("semi-implicit Euler energy: " + (siEulerEnergy / _initialEnergy));
GUILayout.Label("verlet energy: " + (verletEnergy / _initialEnergy));
}
}
static void Main(string[] args)
{
// Difinition of test functions
var funcMap = new FuncType()
{
{ "Linq 100", BindChecking(SortAlgos.BabbleSort, 100) },
{ "Linq 1000", BindChecking(SortAlgos.BabbleSort, 1000) },
{ "Linq 10000", BindChecking(SortAlgos.BabbleSort, 10000) },
{ "Babble 100", BindChecking(SortAlgos.BabbleSort, 100) },
{ "Babble 1000", BindChecking(SortAlgos.BabbleSort, 1000) },
{ "Babble 10000", BindChecking(SortAlgos.BabbleSort, 10000) },
{ "Shaker 100", BindChecking(SortAlgos.ShakerSort, 100) },
{ "Shaker 1000", BindChecking(SortAlgos.ShakerSort, 1000) },
{ "Shaker 10000", BindChecking(SortAlgos.ShakerSort, 10000) },
{ "Comb 100", BindChecking(SortAlgos.CombSort, 100) },
{ "Comb 1000", BindChecking(SortAlgos.CombSort, 1000) },
{ "Comb 10000", BindChecking(SortAlgos.CombSort, 10000) },
{ "Selection 100", BindChecking(SortAlgos.SelectionSort, 100) },
{ "Selection 1000", BindChecking(SortAlgos.SelectionSort, 1000) },
{ "Selection 10000", BindChecking(SortAlgos.SelectionSort, 10000) },
{ "Insertion 100", BindChecking(SortAlgos.InsertionSort, 100) },
{ "Insertion 1000", BindChecking(SortAlgos.InsertionSort, 1000) },
{ "Insertion 10000", BindChecking(SortAlgos.InsertionSort, 10000) },
{ "Gnome 100", BindChecking(SortAlgos.GnomeSort, 100) },
{ "Gnome 1000", BindChecking(SortAlgos.GnomeSort, 1000) },
{ "Gnome 10000", BindChecking(SortAlgos.GnomeSort, 10000) },
{ "Shell 100", BindChecking(SortAlgos.ShellSort, 100) },
{ "Shell 1000", BindChecking(SortAlgos.ShellSort, 1000) },
{ "Shell 10000", BindChecking(SortAlgos.ShellSort, 10000) },
{ "Shell2 100", BindChecking(SortAlgos.ShellSort2, 100) },
{ "Shell2 1000", BindChecking(SortAlgos.ShellSort2, 1000) },
{ "Shell2 10000", BindChecking(SortAlgos.ShellSort2, 10000) },
{ "Merge 100", BindChecking(SortAlgos.MergeSort, 100) },
{ "Merge 1000", BindChecking(SortAlgos.MergeSort, 1000) },
{ "Merge 10000", BindChecking(SortAlgos.MergeSort, 10000) },
{ "Merge2 100", BindChecking(SortAlgos.MergeSort2, 100) },
{ "Merge2 1000", BindChecking(SortAlgos.MergeSort2, 1000) },
{ "Merge2 10000", BindChecking(SortAlgos.MergeSort2, 10000) },
{ "Quick 100", BindChecking(SortAlgos.QuickSort, 100) },
{ "Quick 1000", BindChecking(SortAlgos.QuickSort, 1000) },
{ "Quick 10000", BindChecking(SortAlgos.QuickSort, 10000) },
};
MeasureFuncs(funcMap, out List <Tuple <double, long> > results);
ShowResult(funcMap, results);
// Wait for a user input.
Console.Read();
}
private AbstractFunc GetFunc(FuncType type)
{
AbstractFunc func;
switch (type)
{
case FuncType.FrequencyResponse:
func = new FrequencyResponse(DataInfo);
break;
default:
throw new ArgumentOutOfRangeException(nameof(type));
}
return(func);
}
public static int GetOrder(FuncType func)
{
switch (func)
{
case FuncType.Equals: return(0);
case FuncType.Addition: return(1);
case FuncType.Multiplication: return(3);
case FuncType.Power: return(4);
default: return(int.MaxValue);
}
}
public TypeSection(BinaryReader reader) : base(reader)
{
uint count = LEB128.ReadUInt32(reader);
if (count > int.MaxValue)
{
throw new NotImplementedException($"Count larger than {int.MaxValue} bytes not supported.");
}
entries = new FuncType[count];
for (uint i = 0; i < count; i++)
{
entries[i] = new FuncType(reader);
}
}
/// <summary>
/// Show result with good format
/// </summary>
/// <param name="results">list for showing</param>
private static void ShowResult(FuncType funcMap, List <Tuple <double, long> > results)
{
for (int i = 0; i < results.Count; i++)
{
int maxKeyLen = funcMap.Keys.Max((key) => key.Count());
string result
= ($"{funcMap.Keys.ToArray()[i]}").PadRight(maxKeyLen)
+ " :"
+ ($"{results[i].Item1:F1} [ms]").PadLeft(13);
Console.Write(result + " |");
int ave = Math.Max((int)Math.Log(results[i].Item1, 1.2), 0);
int max = Math.Max((int)Math.Log(results[i].Item2, 1.2), 0);
Console.WriteLine(("").PadRight(ave, '#').PadRight(max) + "|");
}
}
public Function(Position position, string name, FuncType type, IEnumerable<string> paramNames, IUnboundExpr body,
IEnumerable<IBoundDecl> typeArgs, bool hasInferrableTypeArguments)
: base(position, name, typeArgs)
{
if (position == null) throw new ArgumentNullException("position");
if (type == null) throw new ArgumentNullException("type");
if (paramNames != null)
{
ParamNames.AddRange(paramNames);
}
Body = new Expr(body);
Type = type;
HasInferrableTypeArguments = hasInferrableTypeArguments;
}
/**
* return 0 success, -100 false or not support such function
*/
public int callFunc(FuncType funcType)
{
int androidFuncType = 0;
switch (funcType)
{
case FuncType.QUICK_SDK_FUNC_TYPE_UNDEFINED:
// Do nothing
break;
case FuncType.QUICK_SDK_FUNC_TYPE_ENTER_BBS:
androidFuncType = 101;
break;
case FuncType.QUICK_SDK_FUNC_TYPE_ENTER_USER_CENTER:
androidFuncType = 102;
break;
case FuncType.QUICK_SDK_FUNC_TYPE_SHOW_TOOLBAR:
androidFuncType = 103;
break;
case FuncType.QUICK_SDK_FUNC_TYPE_HIDE_TOOLBAR:
androidFuncType = 104;
break;
case FuncType.QUICK_SDK_FUNC_TYPE_SWITCH_ACCOUNT:
androidFuncType = 107;
break;
case FuncType.QUICK_SDK_FUNC_TYPE_REAL_NAME_REGISTER:
androidFuncType = 105;
break;
case FuncType.QUICK_SDK_FUNC_TYPE_ANTI_ADDICTION_QUERY:
androidFuncType = 106;
break;
case FuncType.QUICK_SDK_FUNC_TYPE_SHARE:
androidFuncType = 108;
break;
}
// TODO
return(ao.Call <int>("callFunc", androidFuncType));
}
public UpdateRule(FuncType type, string ruleArgument, bool isInverted)
{
_ruleArgument = ruleArgument;
_isInverted = isInverted;
switch (type) {
case FuncType.StartsWith:
_checkFunction = (s, r) => FixPathSeparators(s).ToLower().StartsWith(FixPathSeparators(r));
break;
case FuncType.EndsWith:
_checkFunction = (s, r) => FixPathSeparators(s).ToLower().EndsWith(FixPathSeparators(r));
break;
case FuncType.Equals:
_checkFunction = (s, r) => FixPathSeparators(s).Equals(FixPathSeparators(r),
StringComparison.InvariantCultureIgnoreCase);
break;
default: throw new ArgumentException("Unlnown argument value is received.", "type");
}
}
internal Wrapper(FuncType t, Func orig)
: base(t)
{
m_orig = orig;
}
private Intrinsic(string name, FuncType type)
{
Name = name;
FuncType = type;
}
public FAtrAttribute(FuncType t)
{
funcType = t;
//this.funcName = name;
}
protected Indirect(FuncType type)
{
this.m_type = type;
}
private Intrinsic(string name, OpCode opCode, FuncType type)
: this(name, type)
{
OpCodes.Add(opCode);
}
protected IndirectX(FuncType type)
: base(type)
{
}
internal BindFunc(FuncType type, Func orig, List bound)
: base(type)
{
this.m_orig = orig;
this.m_bound = bound.ro();
}
public Function(Position position, string name, FuncType type, IEnumerable<string> paramNames, IUnboundExpr body)
: this(position, name, type, paramNames, body, null, false)
{
}
