internal static CompilationError CtorCallBindError(Expr expr, Symbol symbol, ArgList args, OverloadResult ovRes)
{
if (ovRes?.Valid != true)
{
if (symbol is SymbolList)
{
return(expr.Error(ErrorCode.NoSuitableCtor));
}
else if (symbol is ConstructorSymbol)
{
return(expr.Error(ErrorCode.ArgumentsNotMatchCtor));
}
else
{
return(expr.Error(ErrorCode.CtorNotFound));
}
}
if (ovRes.Unique == false)
{
return(expr.Error(ErrorCode.AmbiguousCall));
}
return(expr.Error(ErrorCode.CtorNotFound));
}
public override CompiledCommand GetCompiledCommand(ArgList args)
{
var cc = new CompiledCommandFilled();
cc.OnInvoke += script => { Execute(null, null); };
return(cc);
}
void OnMessage(Message msg)
{
MessageChat msgChat = JsonReader.Deserialize <MessageChat>(msg.rawString);
string strName = string.Format("<color=#ff00ffff>{0}: </color>", msgChat.nickName);
//if (Game.Instance.player.UID != msgChat.uid)
{
bool bShow = Game.Instance.level.bForbidChat;
if (Game.Instance.level.uIDHookMap.ContainsKey(msgChat.uid) && !bShow)
{
BaseHook bh = Game.Instance.level.uIDHookMap[msgChat.uid];
if (bh != null)
{
if (bh.hookPos == HookPos.right)
{
UIManager.Instance.ShowWindow <ChatPaopao>("ChatPaopao", ArgList.Create(msgChat.message, new Vector3(200f, 300f, 0f), 180f), false);
}
else
{
UIManager.Instance.ShowWindow <ChatPaopao>("ChatPaopao", ArgList.Create(msgChat.message, new Vector3(-200f, 300f, 0f), 0f), false);
}
}
}
}
if (Game.Instance.player.UID == msgChat.uid)
{
string strMessage = "<color=#00ff00ff>ÎÒ: </color>" + msgChat.message;
AddMessage(strMessage);
}
else
{
AddMessage(strName + msgChat.message);
}
}
// This method actually returns a Dictionary<string, eeObject>, but uses eeObject as a vehicle as to conform to the visitor's uniform return type
public override eeObject VisitFn_args([NotNull] EelooParser.Fn_argsContext ctx)
{
// add this to scope
Interpreter.currentScope.scopeCtx = ctx;
// key is argument name, value is the default value if one is provided
ArgList arguments
= new ArgList();
var args = ctx.fn_arg();
if (args != null)
{
foreach (var arg in args)
{
if (arg.exp() == null)
{
arguments.Add(arg.IDENTIFIER().GetText(), null);
}
else
{
arguments.Add(arg.IDENTIFIER().GetText(), Visit(arg.exp()));
}
}
}
return(new eeObject(arguments)
{
type = eeObjectType.internal_FN_ARG_LIST
});
}
private static Tuple <List <string>, List <string> > ExtractUsedInterfaceIdsFromArgMap(ArgMap data, string visaTypeFilter)
{
List <string> visas = new List <string>();
List <string> sicls = new List <string>();
var parsed = new Tuple <List <string>, List <string> >(visas, sicls);
if (data == null)
{
return(parsed);
}
ArgList v = data.GetArgList(Ace2ApiConstants.VisaInterfaceIdAssignments_Parameter);
ArgList s = data.GetArgList(Ace2ApiConstants.SiclInterfaceIdAssignments_Parameter);
if (v == null || s == null)
{
return(parsed);
}
for (int i = 0; i < v.Count; i++)
{
if (v[i].ToString().StartsWith(visaTypeFilter, StringComparison.InvariantCultureIgnoreCase))
{
visas.Add(v[i].ToString());
sicls.Add(s[i].ToString()); // The SICL interface list MUST be 1-for-1 to the VISA interfaces
}
}
return(parsed);
}
internal static MemberSymbol TryBindArrayAccess(Expr self, Symbol symbol, ArgList args, ref OverloadResult ovRes, BindOptions options)
{
bool isStatic = self == null;
if ((symbol as PropertySymbol)?.IsStatic == isStatic)
{
CheckArguments(symbol as PropertySymbol, (symbol as PropertySymbol).Parameters, args, ref ovRes, options);
}
else if ((symbol as SymbolList)?.HasProperty == true)
{
var properties = symbol as SymbolList;
for (int i = 0; i < properties.Symbols.Count; i++)
{
var p = properties.Symbols[i];
if ((p as PropertySymbol)?.IsStatic == isStatic)
{
CheckArguments(p as PropertySymbol, (p as PropertySymbol).Parameters, args, ref ovRes, options);
if (ovRes?.Exact == true)
{
break;
}
}
}
}
if (ovRes?.Unique == true)
{
ApplyConversions(args, ovRes);
return(ovRes.Symbol);
}
return(null);
}
public override void OnEnter(ArgList args)
{
base.OnEnter(args);
this.Fsm.Owner.LevelStart(args);
_wnd = UIManager.Instance.ShowWindow <PlayWindow>("PlayWindow", args, false);
Owner.bgPlayer.PlayLevelBG();
}
internal static CompilationError CtorCallBindError(Expr expr, Symbol symbol, ArgList args, OverloadResult ovRes)
{
if (ovRes?.Valid != true)
{
if (symbol is SymbolList)
{
return(expr.Error(ErrorCode.NoSuitableCtor));
}
else if (symbol is ConstructorSymbol)
{
return(expr.Error(ErrorCode.ArgumentsNotMatchCtor));
}
else
{
return(expr.Error(ErrorCode.CtorNotFound));
}
}
if (ovRes.Unique == false)
{
string sMessage1 = "";
string sMessage2 = "";
if (ovRes?.Symbol is ConstructorSymbol msym)
{
sMessage1 = msym.Signature;
}
if (ovRes?.Equivalent?.Symbol is ConstructorSymbol msym2)
{
sMessage2 = msym2.Signature;
}
return(expr.Error(ErrorCode.AmbiguousCall, sMessage1, sMessage2));
}
return(expr.Error(ErrorCode.CtorNotFound));
}
public override bool SameClause(Part term, IDictionary <string, string> varlist)
{
var term2 = term as Term;
if (term2 == null)
{
return(false);
}
if (headIsVar)
{
if (!term2.headIsVar)
{
return(false);
}
if (!SameVar(term2.fname, this.fname, varlist))
{
return(false);
}
}
else
{
if (term2.headIsVar)
{
return(false);
}
if (term2.fname != this.fname)
{
return(false);
}
}
return(ArgList.SameClause(term2.ArgList, varlist));
}
public void Execute(string argString)
{
ArgList args = new ArgList();
args.Parse(argString);
Execute(args);
}
internal MemberSymbol TryBindArrayAccess(Expr self, Symbol symbol, ArgList args, ref OverloadResult ovRes, BindOptions options)
{
bool isStatic = self == null;
var matching = new List <OverloadResult>();
if ((symbol as PropertySymbol)?.IsStatic == isStatic)
{
CheckArguments(symbol as PropertySymbol, (symbol as PropertySymbol).Parameters, args, ref ovRes, options);
}
else if ((symbol as SymbolList)?.HasProperty == true)
{
var properties = symbol as SymbolList;
for (int i = 0; i < properties.Symbols.Count; i++)
{
var p = properties.Symbols[i];
if ((p as PropertySymbol)?.IsStatic == isStatic)
{
CheckArguments(p as PropertySymbol, (p as PropertySymbol).Parameters, args, ref ovRes, options);
if (ovRes?.Exact == true)
{
break;
}
if (ovRes != null)
{
if (!matching.Contains(ovRes))
{
matching.Add(ovRes);
}
if (ovRes.Equivalent != null && !matching.Contains(ovRes.Equivalent))
{
matching.Add(ovRes.Equivalent);
}
}
}
}
}
Expr writeBack;
if (ovRes?.Unique == true)
{
ApplyConversions(args, ovRes, out writeBack);
return(ovRes.Symbol);
}
if (matching.Count > 1 && ovRes.Valid && Options.Resolver != null)
{
var res = AskUserForCorrectOverload(matching, args);
if (res != null)
{
ovRes = res;
ApplyConversions(args, ovRes, out writeBack);
return(ovRes.Symbol);
}
}
return(null);
}
public override void Set(OptionInfo info, string arg)
{
var argIndex = ArgList.IndexOf(arg);
var argValue = ArgList[argIndex + 1];
var value = TranslateActivator.Activate(info.TranslatorType, info.TargetType, argValue);
var property = typeof(TOptions).GetProperty(info.Name);
property?.SetValue(Options, value);
}
internal void ConvertArrayBase(ArgList args)
{
if (!Options.ArrayZero)
{
for (int i = 0; i < args.Args.Count; i++)
{
args.Args[i].Expr = BinaryExpr.Bound(args.Args[i].Expr, args.Args[i].Expr.Token, LiteralExpr.Bound(Constant.Create(1)), BinaryOperatorKind.Subtraction, false, Options.Binding);
}
}
}
public T ChangeState <T>(ArgList args, bool force)
where T : State <O>, new()
{
if (!force && CurrentState is T)
{
return(CurrentState as T);
}
PopState();
return(PushState <T>(args));
}
public override void Show(ArgList args)
{
base.Show(args);
this._txtMessage = transform.FindChild("message").GetComponent <Text>();
string strMessage = args.GetAt <string>(0);
this._txtMessage.text = strMessage;
Vector3 pos = args.GetAt <Vector3>(1);
float angel = args.GetAt <float>(2);
Init(pos, angel);
}
public T PushState <T>(ArgList args)
where T : State <O>, new()
{
var t = new T()
{
Owner = Owner, Fsm = this
};
mStates.Push(t);
t.OnEnter(args);
return(t);
}
public override void OnEnter(ArgList args)
{
_wnd = UIManager.Instance.ShowWindow <LoadingWindow>("LoadingWindow", null, false);
_wnd.CCB = OnCompelete;
LoadConfig();
this.Fsm.Owner.StartCoroutine(LoadScene(args.GetAt <string>(0)));
this._tableId = args.GetAt <int>(1);
this._tableName = args.GetAt <string>(2);
this._tableRate = args.GetAt <int>(3);
this._sceneId = args.GetAt <int>(4);
//this._strPos = args.GetAt<string>(2);
}
private static void FillResourceList(List <Resource> resourceList, ArgList rawList)
{
foreach (var raw in rawList)
{
var deviceRaw = raw as ArgMap;
if (deviceRaw != null)
{
var resource = new Resource(deviceRaw);
resourceList.Add(resource);
}
}
}
public override ProgNodeValue Evaluate(ProgNodeContext context, ArgList arguments)
{
int maxValue = arguments.GetInteger(context, 0);
for (int i = 1; i < arguments.Size(); i++)
{
int value = arguments.GetInteger(context, i);
maxValue = Math.Max(maxValue, value);
}
return(new ProgNodeValue(maxValue));
}
protected override bool TryParse(ArgList args, out string result)
{
result = null;
if (args.Count == 0)
{
return(false);
}
result = args.Next;
return(true);
}
internal void ConvertArrayBase(ArgList args)
{
if (!Options.ArrayZero)
{
for (int i = 0; i < args.Args.Count; i++)
{
args.Args[i].Expr = BinaryExpr.Bound(args.Args[i].Expr, args.Args[i].Expr.Token, LiteralExpr.Bound(Constant.Create(1)), BinaryOperatorKind.Subtraction, Options.Binding);
var expr = args.Args[i].Expr;
Binder.Convert(ref expr, Compilation.Get(NativeType.Int32), BindOptions.Default);
args.Args[i].Expr = expr;
}
}
}
internal MemberSymbol BindArrayAccess(Expr self, Symbol symbol, ArgList args)
{
OverloadResult ovRes = null;
var res = TryBindArrayAccess(self, symbol, args, ref ovRes, Options.Binding);
if (res != null)
{
return(res);
}
throw ArrayAccessBindError(self, symbol, args, ovRes);
}
internal MemberSymbol BindMethodCall(Expr expr, Symbol symbol, ArgList args, out Expr self)
{
OverloadResult ovRes = null;
var res = TryBindCall(expr, symbol, args, out self, ref ovRes, Options.Binding);
if (res != null)
{
return(res);
}
throw MethodCallBindError(expr, symbol, args, ovRes);
}
public void Insert(Command command, ArgList args)
{
if (first == null)
{
CommandBufferEntry entry = new CommandBufferEntry(command, args);
first = entry;
last = entry;
}
else
{
CommandBufferEntry entry = new CommandBufferEntry(command, args, first);
first = entry;
}
}
void LoginResult(Constants result, PlayerData playerData)
{
if (result == Constants.SUCCESS)
{
Game.Instance.player = new Player(playerData);
Game.Instance.GameFsm.ChangeState <Hall>(ArgList.Create(0), false);
//Trigger the event.
_raiseLoginResultEvent(true);
}
else
{
//DebugLogger.LogError("login failed!!!!!!");
//Trigger the event.
_raiseLoginResultEvent(false);
}
}
protected override bool TryParse(ArgList args, out bool result)
{
result = false;
if (args.Count == 0)
{
return(false);
}
if (args.Peek.Type != ArgType.Numeric)
{
return(false);
}
result = args.Peek.IntValue == 1;
return(true);
}
protected override bool TryParse(ArgList args, out float result)
{
result = 0f;
if (args.Count == 0)
{
return(false);
}
if (args.Peek.Type != ArgType.Numeric)
{
return(false);
}
result = args.Next.FloatValue;
return(true);
}
public void Append(Command command, ArgList args)
{
if (first == null)
{
CommandBufferEntry entry = new CommandBufferEntry(command, args);
first = entry;
last = entry;
}
else
{
CommandBufferEntry entry = new CommandBufferEntry(command, args);
last.Next = entry;
last = entry;
}
}
Arg ApplyUsualConversions(ArgList args, out Expr writeBack)
{
writeBack = null;
bool hasRefArgs = false;
for (int i = 0; i < args.Args.Count; i++)
{
var e = args.Args[i].Expr;
Convert(ref e, Compilation.Get(NativeType.Usual));
if (args.Args[i].RefKind != RefKind.None)
{
hasRefArgs = true;
}
}
var arguments = new Arg(LiteralArray.Bound(args.Args));
if (hasRefArgs)
{
var conv = ConversionSymbol.Create(ConversionSymbol.Create(ConversionKind.Identity), new ConversionToTemp(arguments.Expr.Datatype));
Convert(ref arguments.Expr, arguments.Expr.Datatype, conv);
for (int i = 0; i < args.Args.Count; i++)
{
if (args.Args[i].RefKind != RefKind.None)
{
HandleVarArgWriteBack(conv, args.Args[i].Expr, i, ref writeBack);
}
}
}
return(arguments);
void HandleVarArgWriteBack(ConversionSymbol conv, Expr e, int i, ref Expr wb)
{
if (e.Symbol?.HasSetAccess == true || e is AutoVarExpr || e is AliasExpr)
{
// Handle writeBack
Expr t = IdExpr.Bound(conv.IndirectRefConversionTempLocal());
t = ArrayAccessExpr.Bound(t, ArgList.Bound(LiteralExpr.Bound(Constant.Create(i + 1))), this);
var wc = Conversion(t, e.Datatype, BindOptions.Default);
if (wc.Exists)
{
Convert(ref t, e.Datatype, wc);
SymbolExtensions.AddExpr(ref wb, AssignExpr.Bound(e, t, BindOptions.Default));
}
}
}
}
private string createArgumentString(ArgList arguments)
{
StringBuilder sb = new StringBuilder();
foreach (var arg in arguments.Args)
{
if (arg.Value == "")
{
sb.Append(string.Format("--{0} ", arg.Key));
}
else
{
sb.Append(string.Format("--{0}=\"{1}\" ", arg.Key, arg.Value));
}
}
return(sb.ToString());
}
