public static object op_dif(Tokenizer tok, Context.Entry e, object scope)
{
object left, right; Type lType, rType;
op_BinaryArgs(tok, e, scope, out left, out right, out lType, out rType);
do
{
if (lType == typeof(string) || rType == typeof(string))
{
break;
}
if (CodeConvert.IsConvertable(lType) && CodeConvert.IsConvertable(rType))
{
CodeConvert.TryConvert(ref left, typeof(double));
CodeConvert.TryConvert(ref right, typeof(double));
return(((double)left) - ((double)right));
}
} while (false);
tok.AddError(e.tokens[1], "unable to subtract " + lType + " and " + rType + " : " + left + " - " + right);
return(e);
}
public static object op_mod(Tokenizer tok, Context.Entry e, object scope)
{
object left, right; Type lType, rType;
op_BinaryArgs(tok, e, scope, out left, out right, out lType, out rType);
do
{
if (lType == typeof(string))
{
string format = left as string;
List <object> args;
if (rType != typeof(List <object>))
{
args = new List <object>();
args.Add(right);
}
else
{
args = right as List <object>;
}
return(Format(format, args, scope, tok, e.tokens[0].index));
}
if (lType == typeof(string) || rType == typeof(string))
{
break;
}
if (CodeConvert.IsConvertable(lType) && CodeConvert.IsConvertable(rType))
{
CodeConvert.TryConvert(ref left, typeof(double));
CodeConvert.TryConvert(ref right, typeof(double));
return(((double)left) % ((double)right));
}
} while (false);
tok.AddError(e.tokens[1], "unable to modulo " + lType + " and " + rType + " : " + left + " % " + right);
return(e);
}
bool AddArg(Argument arg, ref int i, List <Token> tokens, Tokenizer tokenizer, object scriptVariables)
{
if (arg.flag)
{
namedValues[arg.id] = true;
return(true);
}
if (++i >= tokens.Count)
{
return(false);
}
Token tValue = tokens[i];
CodeConvert.TryParse(tokens[i], out object result, scriptVariables, tokenizer);
Type type = arg.valueType;
//Show.Log(resultType + " : " + result.StringifySmall());
bool goodArgument = false;
if (result != null)
{
if (!(goodArgument = result.GetType() == type))
{
goodArgument = CodeConvert.TryConvert(ref result, type);
}
if (goodArgument)
{
namedValues[arg.id] = result;
}
}
if (!goodArgument)
{
tokenizer.AddError(tValue.index, "Could not cast (" + type.Name + ") from (" +
(result?.GetType().ToString() ?? "null") + ")");
}
return(goodArgument);
}
protected bool TryGetValue()
{
memberValue = null;
Token token = Current.Token;
object meta = token.meta;
if (SkipStructuredDelimiters(meta as Delim))
{
return(true);
}
Context.Entry context = meta as Context.Entry;
if (context != null)
{
bool subContextUsingSameList = context.tokens == Current.tokens;
if (context.IsText())
{
memberValue = context.GetText();
}
else
{
int index = Current.tokenIndex;
List <Token> parseNext = subContextUsingSameList
? Current.tokens.GetRange(index, context.tokenCount)
: context.tokens;
if (memberType == typeof(Expression))
{
memberValue = new Expression(new List <Token>()
{
token
});
}
else
{
if (CodeConvert.IsConvertable(memberType))
{
//Show.Log(memberId + " :: " + memberValue);
memberValue = context.Resolve(tok, scope);
}
else
{
//Show.Log(memberId+" : "+memberValue);
if (!CodeConvert.TryParseTokens(memberType, parseNext, ref memberValue, scope, tok))
{
return(false);
}
}
}
}
if (subContextUsingSameList)
{
Current.tokenIndex += context.tokenCount - 1; // -1 because increment happens after this method
}
return(true);
}
string s = meta as string;
if (s != null)
{
memberValue = token.ToString(s);
if (!CodeConvert.TryConvert(ref memberValue, memberType))
{
AddError("unable to convert (" + memberValue + ") to type '" + memberType + "'");
return(false);
}
return(true);
}
TokenSubstitution sub = meta as TokenSubstitution;
if (sub != null)
{
memberValue = sub.value;
if (!memberType.IsAssignableFrom(memberValue.GetType()) && !CodeConvert.TryConvert(ref memberValue, memberType))
{
AddError("unable to convert substitution (" + memberValue + ") to type '" + memberType + "'");
return(false);
}
return(true);
}
AddError("unable to parse token with meta data " + meta);
return(false);
}
private bool TryGetValue_String(Token token)
{
//memberValue = token.ToString(s);
CodeRules.op_ResolveToken(tok, token, scope, out memberValue, out Type _memberType);
if (memberType == null || memberValue == null || (!memberType.IsAssignableFrom(memberValue.GetType()) && !CodeConvert.TryConvert(ref memberValue, memberType)))
{
AddError("unable to convert (" + memberValue + ") to type '" + memberType + "'");
return(false);
}
return(true);
}
