public override ExecuteResult Execute(Space space) {
if (_variableExpresison.GetExpressionType() != ExpressionType.Variable) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.ExpressionDouble, "The expression isn't a type of variable!");
return ExecuteResult.Failed;
}
if (!IsSuccess(_variableExpresison.Execute(space))) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.ExpressionDouble, "The expression execute failed!");
return ExecuteResult.Failed;
}
var variable = (_variableExpresison as SentenceExpressionVariable).variable;
var value = _variableExpresison.value;
if (!ValueTool.IsNumber(value)) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.ExpressionDouble, "The value of variable isn't a type of 'number'!");
return ExecuteResult.Failed;
}
var ret = _calculate.Calculate(value, new ValueNumber(1));
if (!ret) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.ExpressionDouble, "The calculate is failed!");
return ExecuteResult.Failed;
}
if (!variable.SetValue(ret)) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.ExpressionDouble, "The variable set value failed!");
return ExecuteResult.Failed;
}
SetValue(_bLast ? value : ret);
return ExecuteResult.Successed;
}
public Variable Execute(Space space) {
if (!Sentence.IsSuccess(_header.Execute(space))) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.VariableInsideAnalysis, "The header expression execute failed!");
return null;
}
var headerValue = _header.value;
if (!ValueTool.IsObject(headerValue)) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.VariableInsideAnalysis, "The header expression isn't a object!");
return null;
}
var tempValue = headerValue;
Variable retVariable = null;
foreach (var expression in _insides) {
if (!ValueTool.IsObject(tempValue)) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.VariableInsideAnalysis, "The expression isn't a object!");
return null;
}
var objSpace = (tempValue as ValueObject).space;
if (expression.GetExpressionType() != ExpressionType.Variable) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.VariableInsideAnalysis, "The inside expression can't return a variable!");
return null;
}
if (!Sentence.IsSuccess(expression.Execute(objSpace))) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.VariableInsideAnalysis, "The inside expression execute failed!");
return null;
}
retVariable = (expression as SentenceExpressionVariable).variable;
tempValue = expression.value;
}
return retVariable;
}
public override ExecuteResult Execute(Space space) {
if (!Sentence.IsSuccess(_header.Execute(space))) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.Inside, "The header expression execute failed!");
return ExecuteResult.Failed;
}
var headerValue = _header.value;
if (!ValueTool.IsObject(headerValue)) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.Inside, "The header expression isn't a object!");
return ExecuteResult.Failed;
}
var tempValue = headerValue;
foreach (var expression in _insides) {
if (!ValueTool.IsObject(tempValue)) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.Inside, "The expression isn't a object!");
return ExecuteResult.Failed;
}
var objSpace = (tempValue as ValueObject).space;
if (!Sentence.IsSuccess(expression.Execute(objSpace))) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.Inside, "The inside expression execute failed!");
return ExecuteResult.Failed;
}
tempValue = expression.value;
}
SetValue(tempValue);
return ExecuteResult.Successed;
}
public override ExecuteResult Execute(Space space) {
var tempSpace = new Space(SpaceType.Loop, space);
while (true) {
tempSpace.Clear();
var ret = _sentence.Execute(tempSpace);
if (!IsSuccess(ret)) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.DoWhile, "The sentence execute failed!");
return ExecuteResult.Failed;
}
if (ret == ExecuteResult.Break) {
break;
}
if (ret == ExecuteResult.Return) {
SetReturnValue((_sentence as SentenceReturn).returnValue);
tempSpace.Clear();
return ExecuteResult.Return;
}
if (!IsSuccess(_expression.Execute(space))) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.DoWhile, "The condition expression execute failed!");
return ExecuteResult.Failed;
}
if (!ValueTool.ToLogic(_expression.value)) {
break;
}
}
tempSpace.Clear();
return ExecuteResult.Successed;
}
public override ExecuteResult Execute(Space space) {
if (!IsSuccess(_expression.Execute(space))) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.Condition, "The condition expression execute failed!");
return ExecuteResult.Failed;
}
bool bTrue = ValueTool.ToLogic(_expression.value);
var tempSentence = bTrue ? _sentenceTrue : _sentenceFalse;
if (tempSentence) {
var tempSpace = new Space(SpaceType.Condition, space);
var executeRet = tempSentence.Execute(tempSpace);
if (!IsSuccess(executeRet)) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.Condition, bTrue ? "The 'true' code sentence execute failed!" : "The 'false' code sentence execute failed!");
return ExecuteResult.Failed;
}
if (executeRet == ExecuteResult.Return) {
SetReturnValue((tempSentence as SentenceReturn).returnValue);
return ExecuteResult.Return;
}
if (executeRet == ExecuteResult.Continue) {
return ExecuteResult.Continue;
}
if (executeRet == ExecuteResult.Break) {
return ExecuteResult.Break;
}
tempSpace.Clear();
}
return ExecuteResult.Successed;
}
public override ExecuteResult Execute(Space space) {
if (!IsSuccess(_expression.Execute(space))) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.Echo, "The parameter expression execute failed!");
return ExecuteResult.Failed;
}
var value = _expression.value;
System0.Echo(ValueTool.ToString(value));
return ExecuteResult.Successed;
}
public override ExecuteResult Execute(Space space) {
if (!IsSuccess(_expression.Execute(space))) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.ExpressionNot, "The [not-expression] execute failed!");
return ExecuteResult.Failed;
}
var ret = ValueTool.ToLogic(_expression.value);
SetValue(new ValueBool(!ret));
return ExecuteResult.Successed;
}
public override ExecuteResult Execute(Space space) {
var tempSpace = new Space(SpaceType.Loop, space);
if (_sentence0) {
if (!IsSuccess(_sentence0.Execute(tempSpace))) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.For, "The 'sentence0' of 'for' execute failed!");
return ExecuteResult.Failed;
}
}
var contentSpace = new Space(SpaceType.Loop, tempSpace);
while (true) {
if (_expression0) {
if (!IsSuccess(_expression0.Execute(tempSpace))) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.For, "The condition0-expression of 'for' execute failed!");
return ExecuteResult.Failed;
}
if (!ValueTool.ToLogic(_expression0.value)) {
break;
}
}
if (_content) {
contentSpace.Clear();
var ret = _content.Execute(contentSpace);
if (!IsSuccess(ret)) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.For, "The sentence of 'for' execute failed!");
return ExecuteResult.Failed;
}
if (ret == ExecuteResult.Break) {
break;
}
if (ret == ExecuteResult.Return) {
SetReturnValue((_content as SentenceReturn).returnValue);
tempSpace.Clear();
return ExecuteResult.Return;
}
}
if (_expression1) {
if (!IsSuccess(_expression1.Execute(tempSpace))) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.For, "The condition1-expression of 'for' execute failed!");
return ExecuteResult.Failed;
}
}
}
tempSpace.Clear();
return ExecuteResult.Successed;
}
public override ExecuteResult Execute(Space space) {
if (!IsSuccess(_expression.Execute(space))) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.Foreach, "The expression execute failed!");
return ExecuteResult.Failed;
}
if (!ValueTool.IsArray(_expression.value)) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.Foreach, "The expression isn't a array!");
return ExecuteResult.Failed;
}
var arr = (_expression.value as ValueArray).value;
if (arr.Count == 0) {
return ExecuteResult.Successed;
}
var tempSpace = new Space(SpaceType.Loop, space);
var itemVariable = new Variable(_name, VariableAttribute.None);
if (!tempSpace.AddVariable(itemVariable)) {
ErrorLogger.LogRuntimeError(_name);
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.Foreach, "The variable \"" + _name + "\" execute failed!");
return ExecuteResult.Failed;
}
var contentSpace = new Space(SpaceType.Loop, tempSpace);
foreach (var item in arr) {
itemVariable.SetValue(item.value);
contentSpace.Clear();
var ret = _sentence.Execute(contentSpace);
if (!IsSuccess(ret)) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.Foreach, "The sentence execute failed!");
return ExecuteResult.Failed;
}
if (ret == ExecuteResult.Break) {
break;
}
if (ret == ExecuteResult.Return) {
SetReturnValue((_sentence as SentenceReturn).returnValue);
tempSpace.Clear();
return ExecuteResult.Return;
}
}
tempSpace.Clear();
return ExecuteResult.Successed;
}
public Variable Execute(Space space) {
if (!Sentence.IsSuccess(_valueExpression.Execute(space))) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.VariableArrayItemAnalysis, "The expression execute failed!");
return null;
}
var retValue = _valueExpression.value;
Variable retVariable = null;
var expressionVecSize = _indexExpressionVec.Count;
for (var i = 0; i < expressionVecSize; ++i) {
if (!ValueTool.IsArray(retValue)) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.VariableArrayItemAnalysis, "The result of expression isn't a array!");
return null;
}
var arr = (retValue as ValueArray).value;
var expression = _indexExpressionVec[i];
if (!Sentence.IsSuccess(expression.Execute(space))) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.VariableArrayItemAnalysis, "The expression execute failed!");
return null;
}
var indexValue = expression.value;
if (!ValueTool.IsInteger(indexValue)) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.VariableArrayItemAnalysis, "The index isn't a integer value!");
return null;
}
var index = (int) ((indexValue as ValueNumber).value);
if (index >= arr.Count) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.VariableArrayItemAnalysis, "The index out of range!");
return null;
}
retVariable = arr[index];
if (!retVariable) {
ErrorLogger.LogRuntimeError(ErrorRuntimeCode.VariableArrayItemAnalysis, "The array value is invalid!");
return null;
}
retValue = retVariable.value;
}
return retVariable;
}
private BuiltInFunction()
{
Action <string, int, Func <List <Value>, Space, Value> > _Emplace = (string name, int paramSize, Func <List <Value>, Space, Value> func) => {
var value = new ValueFunction(paramSize, func);
var variable = new Variable(name, VariableAttribute.Const, value);
variables.Add(name, variable);
};
// print
_Emplace.Invoke("print", 1, (List <Value> args, Space s) => {
string ret = "";
foreach (var arg in args)
{
ret += ValueTool.ToString(arg);
}
System0.Echo(ret);
return(ValueNull.DEFAULT_VALUE);
});
// type
_Emplace("type", 1, (List <Value> args, Space s) => {
if (args.Count == 0)
{
return(null);
}
return(new ValueString(ValueTool.ToTypeString(args[0])));
});
// is_null
_Emplace("is_null", 1, (List <Value> args, Space s) => {
if (args.Count == 0)
{
return(null);
}
bool ret = true;
foreach (var arg in args)
{
ret &= ValueTool.IsNull(arg);
}
return(new ValueBool(ret));
});
// is_number
_Emplace("is_number", 1, (List <Value> args, Space s) => {
if (args.Count == 0)
{
return(null);
}
bool ret = true;
foreach (var arg in args)
{
ret &= ValueTool.IsNumber(arg);
}
return(new ValueBool(ret));
});
// is_bool
_Emplace("is_bool", 1, (List <Value> args, Space s) => {
if (args.Count == 0)
{
return(null);
}
bool ret = true;
foreach (var arg in args)
{
ret &= ValueTool.IsBool(arg);
}
return(new ValueBool(ret));
});
// is_string
_Emplace("is_string", 1, (List <Value> args, Space s) => {
if (args.Count == 0)
{
return(null);
}
bool ret = true;
foreach (var arg in args)
{
ret &= ValueTool.IsString(arg);
}
return(new ValueBool(ret));
});
// is_array
_Emplace("is_array", 1, (List <Value> args, Space s) => {
if (args.Count == 0)
{
return(null);
}
bool ret = true;
foreach (var arg in args)
{
ret &= ValueTool.IsArray(arg);
}
return(new ValueBool(ret));
});
// is_function
_Emplace("is_function", 1, (List <Value> args, Space s) => {
if (args.Count == 0)
{
return(null);
}
bool ret = true;
foreach (var arg in args)
{
ret &= ValueTool.IsFunction(arg);
}
return(new ValueBool(ret));
});
// is_object
_Emplace("is_object", 1, (List <Value> args, Space s) => {
if (args.Count == 0)
{
return(null);
}
bool ret = true;
foreach (var arg in args)
{
ret &= ValueTool.IsObject(arg);
}
return(new ValueBool(ret));
});
// len
_Emplace("len", 1, (List <Value> args, Space s) => {
if (args.Count == 0)
{
return(null);
}
var value = args[0];
if (ValueTool.IsArray(value))
{
return(new ValueNumber((double)(value as ValueArray).value.Count));
}
else if (ValueTool.IsString(value))
{
return(new ValueNumber((double)(value as ValueString).value.Length));
}
return(ValueNull.DEFAULT_VALUE);
});
// to_string
_Emplace("to_string", 1, (List <Value> args, Space s) => {
if (args.Count == 0)
{
return(null);
}
var value = args[0];
return(new ValueString(ValueTool.ToString(value)));
});
// to_number
_Emplace("to_number", 1, (List <Value> args, Space s) => {
if (args.Count == 0)
{
return(null);
}
var value = args[0];
if (!ValueTool.IsString(value))
{
return(null);
}
double ret = 0;
if (!double.TryParse((value as ValueString).value, out ret))
{
ret = 0;
}
return(new ValueNumber(ret));
});
}
private static Sentence _ParseEnumDefine(string src, int size, int pos, out int nextPos) {
nextPos = pos;
if (!Grammar.MatchEnum(src, size, pos, out pos)) {
return null;
}
if (!Jump(src, size, pos, out pos)) {
return null;
}
string name;
if (!Grammar.MatchName(src, size, pos, out pos, out name)) {
return null;
}
Jump(src, size, pos, out pos);
if (!Grammar.MatchObjectBegin(src, size, pos, out pos)) {
return null;
}
var checkNameSet = new HashSet<string>();
var checkValueSet = new HashSet<double>();
var valueList = new LinkedList<KeyValuePair<string, ValueNumber>>();
double indexValue = 0;
while (true) {
if (pos >= size) {
return null;
}
Jump(src, size, pos, out pos);
if (Grammar.MatchObjectEnd(src, size, pos, out pos)) {
break;
}
string valueName = "";
if (!Grammar.MatchName(src, size, pos, out pos, out valueName)) {
return null;
}
Jump(src, size, pos, out pos);
if (Grammar.MatchAssign(src, size, pos, out pos)) {
Jump(src, size, pos, out pos);
if (!Grammar.MatchNumber(src, size, pos, out pos, out indexValue)) {
return null;
}
Jump(src, size, pos, out pos);
}
var valueNumber = new ValueNumber(indexValue);
if (!ValueTool.IsInteger(valueNumber)) {
return null;
}
if (checkNameSet.Contains(valueName)) {
return null;
}
if (checkValueSet.Contains(indexValue)) {
return null;
}
checkNameSet.Add(valueName);
checkValueSet.Add(indexValue);
valueList.AddLast(new KeyValuePair<string, ValueNumber>(valueName, valueNumber));
Jump(src, size, pos, out pos);
if (!Grammar.MatchSplitSymbol(src, size, pos, out pos)) {
if (Grammar.MatchObjectEnd(src, size, pos, out pos)) {
break;
}
return null;
}
indexValue += 1;
}
nextPos = pos;
return new SentenceEnumDefine(name, valueList);
}
