public IEnumerator CoroutineCompute(CQ_Content content, ICoroutine coroutine)
{
#if CQUARK_DEBUG
content.InStack(this);
#endif
content.DepthAdd();
CQ_Value value = null;
foreach (ICQ_Expression i in _expressions)
{
ICQ_Expression e = i as ICQ_Expression;
if (e != null)
{
if (e.hasCoroutine)
{
yield return(coroutine.StartNewCoroutine(e.CoroutineCompute(content, coroutine)));
}
else
{
value = e.ComputeValue(content);
if (value != null && value.breakBlock != 0)
{
break;
}
}
}
}
content.DepthRemove();
#if CQUARK_DEBUG
content.OutStack(this);
#endif
yield break;
}
public CQ_Value ComputeValue(CQ_Content content)
{
#if CQUARK_DEBUG
content.InStack(this);
#endif
content.DepthAdd();
CQ_Value value = null;
foreach (ICQ_Expression i in _expressions)
{
ICQ_Expression e = i as ICQ_Expression;
if (e != null)
{
value = e.ComputeValue(content);
}
if (value != null && value.breakBlock != 0)
{
break;
}
}
content.DepthRemove();
#if CQUARK_DEBUG
content.OutStack(this);
#endif
return(value);
}
public void InStack(ICQ_Expression expr)
{
// if (stackExpr.Count > 0 && stackExpr.Peek() == expr)
// {
// throw new Exception("InStack error");
// }
// stackExpr.Push(expr);
}
public CQ_Content.Value Expr_Execute(ICQ_Expression expr, CQ_Content content)
{
if (content == null)
{
content = CreateContent();
}
return(expr.ComputeValue(content));
}
public IEnumerator Expr_Coroutine(ICQ_Expression expr, CQ_Content content, ICoroutine coroutine)
{
if (content == null)
{
content = CreateContent();
}
yield return(coroutine.StartNewCoroutine(expr.CoroutineCompute(content, coroutine)));
}
public void OutStack(ICQ_Expression expr)
{
if (stackExpr.Peek() != expr)
{
throw new Exception("OutStack error:" + expr.ToString() + " err:" + stackExpr.Peek().ToString());
}
stackExpr.Pop();
}
public IEnumerator CoroutineCompute(CQ_Content content, ICoroutine coroutine)
{
content.InStack(this);
content.DepthAdd();
ICQ_Expression expr_switch = listParam[0] as ICQ_Expression;
CQ_Content.Value switchVal = null;
// CQ_Content.Value vrt = null;
if (expr_switch != null)
{
switchVal = expr_switch.ComputeValue(content); //switch//
}
for (int i = 1; i < listParam.Count - 1; i += 2)
{
if (listParam[i] != null)
{
//case xxx://
if (switchVal.value.Equals(listParam[i].ComputeValue(content).value))
{
while (listParam[i + 1] == null)
{
i += 2;
}
content.DepthAdd();
if (listParam[i + 1].hasCoroutine)
{
yield return(coroutine.StartNewCoroutine(listParam[i + 1].CoroutineCompute(content, coroutine)));
}
else
{
listParam[i + 1].ComputeValue(content);
}
break;
}
else
{
continue;
}
}
else
{
//default:
content.DepthAdd();
if (listParam[i + 1].hasCoroutine)
{
yield return(coroutine.StartNewCoroutine(listParam[i + 1].CoroutineCompute(content, coroutine)));
}
else
{
listParam[i + 1].ComputeValue(content);
}
break;
}
}
content.DepthRemove();
content.OutStack(this);
}
public CQ_Content.Value ComputeValue(CQ_Content content)
{
content.InStack(this);
List <string> depth__;
content.Record(out depth__);
try
{
ICQ_Expression expr = listParam[0];
if (expr is CQ_Expression_Block)
{
expr.ComputeValue(content);
}
else
{
content.DepthAdd();
expr.ComputeValue(content);
content.DepthRemove();
}
}
catch (Exception err)
{
bool bParse = false;
int i = 1;
while (i < listParam.Count)
{
CQ_Expression_Define def = listParam[i] as CQ_Expression_Define;
if (err.GetType() == (Type)def.value_type || err.GetType().IsSubclassOf((Type)def.value_type))
{
content.DepthAdd();
content.DefineAndSet(def.value_name, def.value_type, err);
listParam[i + 1].ComputeValue(content);
content.DepthRemove();
bParse = true;
break;
}
i += 2;
}
if (!bParse)
{
throw err;
}
}
content.Restore(depth__, this);
//while((bool)expr_continue.value);
//for 逻辑
//做数学计算
//从上下文取值
//_value = null;
content.OutStack(this);
return(null);
}
public void Restore(List <string> depth, ICQ_Expression expr)
{
while (tvalues.Peek() != depth)
{
tvalues.Pop();
}
while (stackExpr.Peek() != expr)
{
stackExpr.Pop();
}
}
public void InStack(ICQ_Expression expr)
{
if (!useDebug)
{
return;
}
if (stackExpr.Count > 0 && stackExpr.Peek() == expr)
{
throw new Exception("InStack error");
}
stackExpr.Push(expr);
}
public CQ_Value ComputeValue(CQ_Content content)
{
#if CQUARK_DEBUG
content.InStack(this);
#endif
int oldDepthCount = content.Record();
try {
ICQ_Expression expr = _expressions[0];
if (expr is CQ_Expression_Block)
{
expr.ComputeValue(content);
}
else
{
content.DepthAdd();
expr.ComputeValue(content);
content.DepthRemove();
}
}
catch (Exception err) {
bool bParse = false;
int i = 1;
while (i < _expressions.Count)
{
CQ_Expression_Define def = _expressions[i] as CQ_Expression_Define;
if (err.GetType() == (Type)def.value_type || err.GetType().IsSubclassOf((Type)def.value_type))
{
content.DepthAdd();
CQ_Value errVal = new CQ_Value();
errVal.SetObject(def.value_type, err);
content.DefineAndSet(def.value_name, def.value_type, errVal);
_expressions[i + 1].ComputeValue(content);
content.DepthRemove();
bParse = true;
break;
}
i += 2;
}
if (!bParse)
{
throw err;
}
}
content.Restore(oldDepthCount, this);
//while((bool)expr_continue.value);
#if CQUARK_DEBUG
content.OutStack(this);
#endif
return(CQ_Value.Null);
}
public ICQ_Expression Optimize(ICQ_Expression value, ICQ_Environment env)
{
ICQ_Expression expr = value as ICQ_Expression;
if (expr == null)
{
return(value);
}
else
{
return(OptimizeDepth(expr, new CQ_Content(env)));
}
}
public CQ_Content.Value ComputeValue(CQ_Content content)
{
content.InStack(this);
ICQ_Expression expr_if = listParam[0];
bool bif = (bool)expr_if.ComputeValue(content).value;
//if (expr_init != null) expr_init.ComputeValue(content);
ICQ_Expression expr_go1 = listParam[1];
ICQ_Expression expr_go2 = null;
if (listParam.Count > 2)
{
expr_go2 = listParam[2];
}
CQ_Content.Value value = null;
if (bif && expr_go1 != null)
{
if (expr_go1 is CQ_Expression_Block)
{
value = expr_go1.ComputeValue(content);
}
else
{
content.DepthAdd();
value = expr_go1.ComputeValue(content);
content.DepthRemove();
}
}
else if (!bif && expr_go2 != null)
{
if (expr_go2 is CQ_Expression_Block)
{
value = expr_go2.ComputeValue(content);
}
else
{
content.DepthAdd();
value = expr_go2.ComputeValue(content);
content.DepthRemove();
}
}
//while((bool)expr_continue.value);
//for 逻辑
//做数学计算
//从上下文取值
//_value = null;
content.OutStack(this);
return(value);
}
public CQ_Value ComputeValue(CQ_Content content)
{
#if CQUARK_DEBUG
content.InStack(this);
#endif
content.DepthAdd();
ICQ_Expression expr_switch = _expressions[0] as ICQ_Expression;
CQ_Value switchVal = CQ_Value.Null;
// CQ_Content.Value vrt = null;
if (expr_switch != null)
{
switchVal = expr_switch.ComputeValue(content);//switch//
}
for (int i = 1; i < _expressions.Count - 1; i += 2)
{
if (_expressions[i] != null)
{
//case xxx://
if (switchVal == _expressions[i].ComputeValue(content))
{
while (_expressions[i + 1] == null)
{
i += 2;
}
// content.InStack(_expressions[i+1]);
content.DepthAdd();
_expressions[i + 1].ComputeValue(content);
break;
}
else
{
continue;
}
}
else
{
//default:
// content.InStack(_expressions[i+1]);
content.DepthAdd();
_expressions[i + 1].ComputeValue(content);
break;
}
}
content.DepthRemove();
#if CQUARK_DEBUG
content.OutStack(this);
#endif
return(CQ_Value.Null);
}
public CQ_Value ComputeValue(CQ_Content content)
{
#if CQUARK_DEBUG
content.InStack(this);
#endif
ICQ_Expression expr_if = _expressions[0];
CQ_Value v = expr_if.ComputeValue(content);
bool bif = v.GetBool();
//if (expr_init != null) expr_init.ComputeValue(content);
ICQ_Expression expr_go1 = _expressions[1];
ICQ_Expression expr_go2 = null;
if (_expressions.Count > 2)
{
expr_go2 = _expressions[2]; //else
}
CQ_Value value = CQ_Value.Null;
if (bif && expr_go1 != null)
{
if (expr_go1 is CQ_Expression_Block)
{
value = expr_go1.ComputeValue(content);
}
else
{
content.DepthAdd();
value = expr_go1.ComputeValue(content);
content.DepthRemove();
}
}
else if (!bif && expr_go2 != null)
{
if (expr_go2 is CQ_Expression_Block)
{
value = expr_go2.ComputeValue(content);
}
else
{
content.DepthAdd();
value = expr_go2.ComputeValue(content);
content.DepthRemove();
}
}
#if CQUARK_DEBUG
content.OutStack(this);
#endif
return(value);
}
ICQ_Expression OptimizeSingle(ICQ_Expression expr, CQ_Content content)
{
if (expr is CQ_Expression_Math2Value || expr is CQ_Expression_Math2ValueAndOr || expr is CQ_Expression_Math2ValueLogic)
{
if (expr.listParam[0] is ICQ_Value &&
expr.listParam[1] is ICQ_Value)
{
CQ_Content.Value result = expr.ComputeValue(content);
if ((Type)result.type == typeof(bool))
{
CQ_Value_Value <bool> value = new CQ_Value_Value <bool>();
value.value_value = (bool)result.value;
value.tokenBegin = expr.listParam[0].tokenBegin;
value.tokenEnd = expr.listParam[1].tokenEnd;
value.lineBegin = expr.listParam[0].lineBegin;
value.lineEnd = expr.listParam[1].lineEnd;
return(value);
}
else
{
ICQ_Type v = content.environment.GetType(result.type);
ICQ_Value value = v.MakeValue(result.value);
value.tokenBegin = expr.listParam[0].tokenBegin;
value.tokenEnd = expr.listParam[1].tokenEnd;
value.lineBegin = expr.listParam[0].lineBegin;
value.lineEnd = expr.listParam[1].lineEnd;
return(value);
}
}
}
if (expr is CQ_Expression_Math3Value)
{
CQ_Content.Value result = expr.listParam[0].ComputeValue(content);
if ((Type)result.type == typeof(bool))
{
bool bv = (bool)result.value;
if (bv)
{
return(expr.listParam[1]);
}
else
{
return(expr.listParam[2]);
}
}
}
return(expr);
}
public void Restore(List <string> depth, ICQ_Expression expr)
{
if (tvalues != null)
{
while (tvalues.Peek() != depth)
{
tvalues.Pop();
}
}
#if CQUARK_DEBUG
while (stackExpr.Peek() != expr)
{
stackExpr.Pop();
}
#endif
}
ICQ_Expression OptimizeDepth(ICQ_Expression expr, CQ_Content content)
{
//先进行深入优化
if (expr.listParam != null)
{
for (int i = 0; i < expr.listParam.Count; i++)
{
ICQ_Expression subexpr = expr.listParam[i] as ICQ_Expression;
if (subexpr != null)
{
expr.listParam[i] = OptimizeDepth(subexpr, content);
}
}
}
return(OptimizeSingle(expr, content));
}
protected override void Initialize()
{
switch (m_codeType)
{
case ECodeType.FileName:
break;
case ECodeType.TextAsset:
AppDomain.BuildFile(m_className, m_ta.text);
break;
case ECodeType.Text:
AppDomain.BuildFile(m_className, m_codeText);
break;
}
type = CQuark.AppDomain.GetTypeByKeywordQuiet(m_className);
if (type == null)
{
Debug.LogError("Type:" + m_className + "不存在与脚本项目中");
return;
}
cclass = type._class as Class_CQuark;
content = new CQ_Content();
//TODO 最好在编译的时候就做，不要在实例化的时候做
RegisterMember("gameObject", typeof(GameObject));
RegisterMember("transform", typeof(Transform));
inst = type._class.New(content, null).value as CQuark.CQClassInstance;
SetMember("gameObject", typeof(GameObject), this.gameObject);
SetMember("transform", typeof(Transform), this.transform);
if (cclass.functions.ContainsKey("Update"))
{
m_update = cclass.functions["Update"].expr_runtime;
}
if (cclass.functions.ContainsKey("FixedUpdate"))
{
m_fixedpdate = cclass.functions["FixedUpdate"].expr_runtime;
}
_updateContent = new CQ_Content();
_updateContent.CallType = cclass;
_updateContent.CallThis = inst;
}
public CQ_Content.Value ComputeValue(CQ_Content content)
{
content.InStack(this);
content.DepthAdd();
ICQ_Expression expr_switch = listParam[0] as ICQ_Expression;
CQ_Content.Value switchVal = null;
// CQ_Content.Value vrt = null;
if (expr_switch != null)
{
switchVal = expr_switch.ComputeValue(content); //switch//
}
for (int i = 1; i < listParam.Count - 1; i += 2)
{
if (listParam[i] != null)
{
//case xxx://
if (switchVal.value.Equals(listParam[i].ComputeValue(content).value))
{
while (listParam[i + 1] == null)
{
i += 2;
}
// content.InStack(listParam[i+1]);
content.DepthAdd();
listParam[i + 1].ComputeValue(content);
break;
}
else
{
continue;
}
}
else
{
//default:
// content.InStack(listParam[i+1]);
content.DepthAdd();
listParam[i + 1].ComputeValue(content);
break;
}
}
content.DepthRemove();
content.OutStack(this);
return(null);
}
public void Restore(int depthCount, ICQ_Expression expr)
{
int newCount = tvalueDepth.Pop();
tvalueDepth.Push(depthCount);
int needRemove = newCount - depthCount;
for (; needRemove > 0; needRemove--)
{
string name = tvalues.Pop();
values.Remove(name);
}
#if CQUARK_DEBUG
while (stackExpr.Peek() != expr)
{
stackExpr.Pop();
}
#endif
}
public void OutStack(ICQ_Expression expr)
{
if (!useDebug)
{
return;
}
if (stackExpr.Peek() != expr)
{
if (expr.hasCoroutine)
{
DepthRemove();
}
else
{
throw new Exception("OutStack error:" + expr.ToString() + " err:" + stackExpr.Peek().ToString());
}
}
stackExpr.Pop();
}
public CQ_Content.Value ComputeValue(CQ_Content content)
{
content.InStack(this);
content.DepthAdd();
CQ_Content.Value value = null;
foreach (ICQ_Expression i in listParam)
{
ICQ_Expression e = i as ICQ_Expression;
if (e != null)
{
value = e.ComputeValue(content);
}
if (value != null && value.breakBlock != 0)
{
break;
}
}
content.DepthRemove();
content.OutStack(this);
return(value);
}
public DeleLambda(CQ_Content content, IList <ICQ_Expression> param, ICQ_Expression func)
{
this.content = content.Clone();
this.expr_func = func;
foreach (var p in param)
{
CQ_Expression_GetValue v1 = p as CQ_Expression_GetValue;
CQ_Expression_Define v2 = p as CQ_Expression_Define;
if (v1 != null)
{
paramTypes.Add(null);
paramNames.Add(v1.value_name);
}
else if (v2 != null)
{
paramTypes.Add(v2.value_type);
paramNames.Add(v2.value_name);
}
else
{
throw new Exception("DeleLambda 参数不正确");
}
}
}
public CQ_Value ComputeValue(CQ_Content content)
{
#if CQUARK_DEBUG
content.InStack(this);
#endif
content.DepthAdd();
CQ_Expression_Define define = _expressions[0] as CQ_Expression_Define;
define.ComputeValue(content);
System.Collections.IEnumerable emu = _expressions[1].ComputeValue(content).GetObject() as System.Collections.IEnumerable;
ICQ_Expression expr_block = _expressions[2] as ICQ_Expression;
var it = emu.GetEnumerator();
CQ_Value vrt = CQ_Value.Null;
while (it.MoveNext())
{
//content.Set(define.value_name, it.Current);
CQ_Value val = new CQ_Value();
val.SetObject(define.value_type, it.Current);
content.Set(define.value_name, val);
if (expr_block != null)
{
if (expr_block is CQ_Expression_Block)
{
CQ_Value v = expr_block.ComputeValue(content);
if (v.m_breakBlock == BreakType.Return)
{
vrt = v;
}
if (v.m_breakBlock == BreakType.Return || v.m_breakBlock == BreakType.Break)
{
break;
}
}
else
{
content.DepthAdd();
bool bbreak = false;
CQ_Value v = expr_block.ComputeValue(content);
if (v.m_breakBlock == BreakType.Return)
{
vrt = v;
}
if (v.m_breakBlock == BreakType.Break || v.m_breakBlock == BreakType.Return)
{
bbreak = true;
}
content.DepthRemove();
if (bbreak)
{
break;
}
}
}
}
content.DepthRemove();
#if CQUARK_DEBUG
content.OutStack(this);
#endif
return(vrt);
}
public CQ_Content.Value ComputeValue(CQ_Content content)
{
content.InStack(this);
content.DepthAdd();
ICQ_Expression expr_init = listParam[0] as ICQ_Expression;
if (expr_init != null)
{
expr_init.ComputeValue(content); //expr1
}
ICQ_Expression expr_continue = listParam[1] as ICQ_Expression;
ICQ_Expression expr_step = listParam[2] as ICQ_Expression;
ICQ_Expression expr_block = listParam[3] as ICQ_Expression;
CQ_Content.Value vrt = null;
for (; ;)
{
if (expr_continue != null && !(bool)expr_continue.ComputeValue(content).value)
{
break; //expr2
}
if (expr_block != null)
{
if (expr_block is CQ_Expression_Block)
{
var v = expr_block.ComputeValue(content);
if (v != null)
{
if (v.breakBlock > 2)
{
vrt = v;
}
if (v.breakBlock > 1)
{
break;
}
}
}
else
{
content.DepthAdd();
bool bbreak = false;
var v = expr_block.ComputeValue(content);
if (v != null)
{
if (v.breakBlock > 2)
{
vrt = v;
}
if (v.breakBlock > 1)
{
bbreak = true;
}
}
content.DepthRemove();
if (bbreak)
{
break;
}
}
//if (v.breakBlock == 1) continue;
//if (v.breakBlock == 2) break;
//if (v.breakBlock == 10) return v;
}
if (expr_step != null)
{
expr_step.ComputeValue(content);//expr3
}
}
content.DepthRemove();
content.OutStack(this);
return(vrt);
//for 逻辑
//做数学计算
//从上下文取值
//_value = null;
}
public CQ_Content.Value Expr_Execute(ICQ_Expression expr)
{
CQ_Content content = CreateContent();
return(expr.ComputeValue(content));
}
//CQ_Content contentGloabl = null;
public ICQ_Expression Expr_Optimize(ICQ_Expression old)
{
return(compiler.Optimize(old, this));
}
public IEnumerator CoroutineCompute(CQ_Content content, UnityEngine.MonoBehaviour coroutine)
{
#if CQUARK_DEBUG
content.InStack(this);
#endif
ICQ_Expression expr_if = _expressions[0];
bool bif = expr_if.ComputeValue(content).GetBool();
//if (expr_init != null) expr_init.ComputeValue(content);
ICQ_Expression expr_go1 = _expressions[1];
ICQ_Expression expr_go2 = null;
if (_expressions.Count > 2)
{
expr_go2 = _expressions[2];
}
// CQ_Content.Value value = null;
if (bif && expr_go1 != null)
{
if (expr_go1 is CQ_Expression_Block)
{
if (expr_go1.hasCoroutine)
{
yield return(coroutine.StartCoroutine(expr_go1.CoroutineCompute(content, coroutine)));
}
else
{
expr_go1.ComputeValue(content);
}
}
else
{
content.DepthAdd();
if (expr_go1.hasCoroutine)
{
yield return(coroutine.StartCoroutine(expr_go1.CoroutineCompute(content, coroutine)));
}
else
{
expr_go1.ComputeValue(content);
}
content.DepthRemove();
}
}
else if (!bif && expr_go2 != null)
{
if (expr_go2 is CQ_Expression_Block)
{
if (expr_go2.hasCoroutine)
{
yield return(coroutine.StartCoroutine(expr_go2.CoroutineCompute(content, coroutine)));
}
else
{
expr_go2.ComputeValue(content);
}
}
else
{
content.DepthAdd();
if (expr_go2.hasCoroutine)
{
yield return(coroutine.StartCoroutine(expr_go2.CoroutineCompute(content, coroutine)));
}
else
{
expr_go2.ComputeValue(content);
}
content.DepthRemove();
}
}
#if CQUARK_DEBUG
content.OutStack(this);
#endif
}
public IEnumerator CoroutineCompute(CQ_Content content, ICoroutine coroutine)
{
content.InStack(this);
ICQ_Expression expr_if = listParam[0];
bool bif = (bool)expr_if.ComputeValue(content).value;
//if (expr_init != null) expr_init.ComputeValue(content);
ICQ_Expression expr_go1 = listParam[1];
ICQ_Expression expr_go2 = null;
if (listParam.Count > 2)
{
expr_go2 = listParam[2];
}
// CQ_Content.Value value = null;
if (bif && expr_go1 != null)
{
if (expr_go1 is CQ_Expression_Block)
{
if (expr_go1.hasCoroutine)
{
yield return(coroutine.StartNewCoroutine(expr_go1.CoroutineCompute(content, coroutine)));
}
else
{
expr_go1.ComputeValue(content);
}
}
else
{
content.DepthAdd();
if (expr_go1.hasCoroutine)
{
yield return(coroutine.StartNewCoroutine(expr_go1.CoroutineCompute(content, coroutine)));
}
else
{
expr_go1.ComputeValue(content);
}
content.DepthRemove();
}
}
else if (!bif && expr_go2 != null)
{
if (expr_go2 is CQ_Expression_Block)
{
if (expr_go2.hasCoroutine)
{
yield return(coroutine.StartNewCoroutine(expr_go2.CoroutineCompute(content, coroutine)));
}
else
{
expr_go2.ComputeValue(content);
}
}
else
{
content.DepthAdd();
if (expr_go2.hasCoroutine)
{
yield return(coroutine.StartNewCoroutine(expr_go2.CoroutineCompute(content, coroutine)));
}
else
{
expr_go2.ComputeValue(content);
}
content.DepthRemove();
}
}
//while((bool)expr_continue.value);
//for 逻辑
//做数学计算
//从上下文取值
//_value = null;
content.OutStack(this);
}
