//------------------------------------------------------------
// 下層に伝達できるなら伝達する。
public void TransferIfPossible(SemanticAnalyzeComponent aComp)
{
// 可能ならEvaluateInfoを伝達
if (mIsReceived || //自分で確保した
mTransferredEI.IsReusableSR // 再利用していいレジスタなので伝達してよい
)
{
aComp.TransferredEvaluateInfoSet(mNodeEI);
}
}
//------------------------------------------------------------
// 意味解析。
public void SemanticAnalyze(SemanticAnalyzeComponent aComp)
{
// 戻り値用の評価情報を取得
EvaluateInfo returnEI = aComp.ReturnEvaluateInfoGet();
if (returnEI == null)
{// 戻り値がないとき
// 式がないことをチェック
if (mExpression != null)
{// エラー
aComp.ThrowErrorException(SymbolTree.ErrorKind.SEMICOLON_EXPECTED, mExpression.GetToken());
}
// Return実行
execReturn(aComp);
}
else
{
// 式があることをチェック
if (mExpression == null)
{// エラー
aComp.ThrowErrorException(SymbolTree.ErrorKind.EXPRESSION_EXPECTED, mKeyToken);
}
// 評価ノードを作成
var exprNode = mExpression.CreateEvaluateNode();
// 評価準備
exprNode.SendEvent(aComp, EvaluateNodeEventKind.Analyze);
// 評価情報を伝達
aComp.TransferredEvaluateInfoSet(returnEI);
// 評価実行
exprNode.SendEvent(aComp, EvaluateNodeEventKind.Evaluate);
// 伝達リセット
aComp.TransferredEvaluateInfoReset();
// 型確認
Assert.Check(exprNode.GetEvaluateInfo().Kind == EvaluateInfo.InfoKind.Value);
EvaluateInfo exprEI = exprNode.GetEvaluateInfo();
TypeInfo exprTypeInfo = exprEI.TypeInfo;
if (exprTypeInfo.Symbol.GetKind() != TypeInfo.TypeSymbol.Kind.BuiltIn ||
(exprTypeInfo.Symbol.GetBuiltInType() != BuiltInType.SInt32 && exprTypeInfo.Symbol.GetBuiltInType() != BuiltInType.Bool)
)
{// todo: 今はboolとintしかサポートしない
aComp.ThrowErrorException(SymbolTree.ErrorKind.NOT_SUPPORTED_TYPENAME, exprTypeInfo.Symbol.GetToken());
}
// 型が同じか確認
if (returnEI.TypeInfo.Symbol.GetBuiltInType() != exprTypeInfo.Symbol.GetBuiltInType())
{// 違う型
// エラーメッセージ
throw new SymbolTree.ErrorException(new SymbolTree.ErrorInfo(
SymbolTree.ErrorKind.CANT_IMPLICIT_CAST_TYPEA_TO_TYPEB
, aComp.TypeSymbolNode.ModuleContext()
, mKeyToken
, exprTypeInfo
, returnEI.TypeInfo
));
}
// レジスタが異なればロード命令を追加する
if (!returnEI.SR.IsSame(exprEI.SR))
{
aComp.BCFunction.AddOPCode_SReg1_SReg2(
BCOpCode.OpType.LDSRSR
, returnEI.SR
, exprEI.SR
);
}
// 親の評価終了
exprNode.SendEvent(aComp, EvaluateNodeEventKind.Release);
// return実行
execReturn(aComp);
}
}
//------------------------------------------------------------
// 評価実行。
void eventEvaluate(SemanticAnalyzeComponent aComp)
{
// レジスタ確保
mEvaluateInfo.SR = aComp.SRReserve();
// 初期化式があるか否かの分岐
if (mExpr == null)
{// 初期化子がないので既定値で初期化する
// todo: 組み込み型以外の対応
if (mEvaluateInfo.TypeInfo.Symbol.GetKind() != TypeInfo.TypeSymbol.Kind.BuiltIn)
{//
aComp.ThrowErrorException(SymbolTree.ErrorKind.NOT_SUPPORTED_TYPENAME, mEvaluateInfo.TypeInfo.Symbol.GetToken());
}
// 組み込み型ならゼロ初期化
aComp.BCFunction.AddOPCode_SReg(
BCOpCode.OpType.LDSRZR
, mEvaluateInfo.SR
);
}
else
{// 初期化式の結果でロード命令を挟む
// 評価情報を伝達
aComp.TransferredEvaluateInfoSet(mEvaluateInfo);
// 評価
mExprNode.SendEvent(aComp, EvaluateNodeEventKind.Evaluate);
// 伝達リセット
aComp.TransferredEvaluateInfoReset();
// todo:
// 暗黙の変換の対応
// 型確認
Assert.Check(mExprNode.GetEvaluateInfo().Kind == EvaluateInfo.InfoKind.Value);
EvaluateInfo exprEI = mExprNode.GetEvaluateInfo();
TypeInfo exprTypeInfo = exprEI.TypeInfo;
if (exprTypeInfo.Symbol.GetKind() != TypeInfo.TypeSymbol.Kind.BuiltIn ||
(exprTypeInfo.Symbol.GetBuiltInType() != BuiltInType.SInt32 && exprTypeInfo.Symbol.GetBuiltInType() != BuiltInType.Bool)
)
{// todo: 今はboolとintしかサポートしない
aComp.ThrowErrorException(SymbolTree.ErrorKind.NOT_SUPPORTED_TYPENAME, exprTypeInfo.Symbol.GetToken());
}
// 型が同じか確認
if (mEvaluateInfo.TypeInfo.Symbol.GetBuiltInType() != exprTypeInfo.Symbol.GetBuiltInType())
{// 違う型
// エラーメッセージ
throw new SymbolTree.ErrorException(new SymbolTree.ErrorInfo(
SymbolTree.ErrorKind.CANT_IMPLICIT_CAST_TYPEA_TO_TYPEB
, aComp.TypeSymbolNode.ModuleContext()
, mSymbol.GetIdentifier().Token
, exprTypeInfo
, mEvaluateInfo.TypeInfo
));
}
// レジスタが異なればロード命令を追加する
if (!mEvaluateInfo.SR.IsSame(exprEI.SR))
{
aComp.BCFunction.AddOPCode_SReg1_SReg2(
BCOpCode.OpType.LDSRSR
, mEvaluateInfo.SR
, exprEI.SR
);
}
// 親の評価が終わったことを告げる
mExprNode.SendEvent(aComp, EvaluateNodeEventKind.Release);
}
}
//------------------------------------------------------------
// 評価実行。
void eventEvaluate(SemanticAnalyzeComponent aComp)
{
// todo:
// 暗黙の変換の対応
// 今はint,boolしか対応しない
if (mLeftNode.GetEvaluateInfo().Kind != EvaluateInfo.InfoKind.Value ||
mRightNode.GetEvaluateInfo().Kind != EvaluateInfo.InfoKind.Value ||
(mLeftNode.GetEvaluateInfo().TypeInfo.Symbol.GetBuiltInType() != mRightNode.GetEvaluateInfo().TypeInfo.Symbol.GetBuiltInType()) ||
(mLeftNode.GetEvaluateInfo().TypeInfo.Symbol.GetBuiltInType() != BuiltInType.SInt32 && mLeftNode.GetEvaluateInfo().TypeInfo.Symbol.GetBuiltInType() != BuiltInType.Bool) ||
(mRightNode.GetEvaluateInfo().TypeInfo.Symbol.GetBuiltInType() != BuiltInType.SInt32 && mRightNode.GetEvaluateInfo().TypeInfo.Symbol.GetBuiltInType() != BuiltInType.Bool)
)
{
aComp.ThrowErrorException(SymbolTree.ErrorKind.NOT_SUPPORTED_EXPRESSION, mExpr.mOpToken);
}
// 左を評価
mLeftNode.SendEvent(aComp, EvaluateNodeEventKind.Evaluate);
// 伝達リセット
aComp.TransferredEvaluateInfoReset();
// 左のEvaluateInfoを伝達設定
if (mExpr.mOpKind == OpKind.Assign)
{// Assignのときだけ
// 再利用禁止設定
var ei = mLeftNode.GetEvaluateInfo();
ei.DisableReuseSR();
// 伝達
aComp.TransferredEvaluateInfoSet(ei);
}
// 右を評価
mRightNode.SendEvent(aComp, EvaluateNodeEventKind.Evaluate);
// 伝達リセット
aComp.TransferredEvaluateInfoReset();
// Assignならここで終了
if (mExpr.mOpKind == OpKind.Assign)
{
if (!mLeftNode.GetEvaluateInfo().SR.IsSame(mRightNode.GetEvaluateInfo().SR))
{// レジスタが異なればロード命令を追加する
aComp.BCFunction.AddOPCode_SReg1_SReg2(
BCOpCode.OpType.LDSRSR
, mLeftNode.GetEvaluateInfo().SR
, mRightNode.GetEvaluateInfo().SR
);
}
return;
}
// boolなら演算ができないのでエラー扱い
if (mLeftNode.GetEvaluateInfo().TypeInfo.Symbol.GetBuiltInType() == BuiltInType.Bool)
{
throw new SymbolTree.ErrorException(new SymbolTree.ErrorInfo(
SymbolTree.ErrorKind.CANT_IMPLICIT_CAST_TYPEA_TO_TYPEB
, aComp.TypeSymbolNode.ModuleContext()
, mExpr.mOpToken
, mLeftNode.GetEvaluateInfo().TypeInfo
, new TypeInfo(new TypeInfo.TypeSymbol(null, BuiltInType.SInt32), new TypeInfo.TypeAttribute(true, false))
));
}
// 演算子に対応する命令を選択
BCOpCode.OpType opType = BCOpCode.OpType.NOP;
switch (mExpr.mOpKind)
{
case OpKind.AddAssign: opType = BCOpCode.OpType.ADDI32; break;
case OpKind.SubAssign: opType = BCOpCode.OpType.SUBI32; break;
case OpKind.MulAssign: opType = BCOpCode.OpType.MULS32; break;
case OpKind.DivAssign: opType = BCOpCode.OpType.DIVS32; break;
case OpKind.ModAssign: opType = BCOpCode.OpType.MODS32; break;
case OpKind.AndAssign: opType = BCOpCode.OpType.ANDI32; break;
case OpKind.OrAssign: opType = BCOpCode.OpType.ORI32; break;
case OpKind.XorAssign: opType = BCOpCode.OpType.XORI32; break;
case OpKind.LShiftAssign: opType = BCOpCode.OpType.SLLI32; break;
case OpKind.RShiftAssign: opType = BCOpCode.OpType.SLRI32; break;
default:
Assert.NotReachHere();
break;
}
// 命令追加
aComp.BCFunction.AddOPCode_SReg1_SReg2_SReg3(
opType
, mLeftNode.GetEvaluateInfo().SR
, mLeftNode.GetEvaluateInfo().SR
, mRightNode.GetEvaluateInfo().SR
);
}