C# (CSharp) CILEmitterの例

コード例 #1

ファイル: Procedure.cs プロジェクト: tmakij/MiniPascal

        public void EmitIR(CILEmitter Emitter)
        {
            CILEmitter proc = Emitter.StartProcedure(identifier, Parameters, ReturnType);

            block.EmitIR(proc);
            proc.Return();
        }

コード例 #2

ファイル: AssigmentStatement.cs プロジェクト: tmakij/MiniPascal

 public void EmitIR(CILEmitter Emitter)
 {
     if (variable.IsReference)
     {
         if (reference.ArrayIndex == null)
         {
             Emitter.LoadVariable(reference.Name);
             assigment.EmitIR(Emitter, false);
             Emitter.SaveReferenceVariable(variable);
         }
         else
         {
             Emitter.LoadReferenceVariable(variable);
             reference.ArrayIndex.EmitIR(Emitter, false);
             assigment.EmitIR(Emitter, false);
             Emitter.SaveArray(variable);
         }
     }
     else
     {
         if (reference.ArrayIndex == null)
         {
             assigment.EmitIR(Emitter, false);
             Emitter.SaveVariable(reference.Name);
         }
         else
         {
             Emitter.LoadVariable(variable.Identifier);
             reference.ArrayIndex.EmitIR(Emitter, false);
             assigment.EmitIR(Emitter, false);
             Emitter.SaveArray(variable);
         }
     }
 }

コード例 #3

ファイル: VariableOperand.cs プロジェクト: tmakij/MiniPascal

 public void EmitIR(CILEmitter Emitter, bool Reference)
 {
     if (Reference)
     {
         if (Type.IsArray && reference.ArrayIndex != null)
         {
             Emitter.LoadVariable(reference.Name);
             reference.ArrayIndex.EmitIR(Emitter, false);
             Emitter.LoadArrayIndexAddress(Type);
         }
         else
         {
             Emitter.LoadVariableAddress(reference.Name);
         }
     }
     else if (variable.IsReference)
     {
         Emitter.LoadReferenceVariable(variable);
     }
     else
     {
         Emitter.LoadVariable(reference.Name);
         if (reference.ArrayIndex != null)
         {
             reference.ArrayIndex.EmitIR(Emitter, false);
             Emitter.LoadArrayVariable(variable);
         }
     }
 }

コード例 #4

ファイル: Call.cs プロジェクト: tmakij/MiniPascal

 public void EmitIR(CILEmitter Emitter, bool Reference)
 {
     if (Reference)
     {
         throw new InvalidByReferenceException();
     }
     for (int i = 0; i < arguments.Count; i++)
     {
         IExpression expr          = arguments.Expression(i);
         bool        loadReference = ToCall.Parameters.At(i).IsReference;
         expr.EmitIR(Emitter, loadReference);
     }
     foreach (Variable prevVar in ToCall.Parameters.PreviousVariables)
     {
         if (current.Variable(prevVar.Identifier).IsReference)
         {
             Emitter.LoadVariable(prevVar.Identifier);
         }
         else
         {
             Emitter.LoadVariableAddress(prevVar.Identifier);
         }
     }
     Emitter.Call(toBeCalled);
 }

コード例 #5

ファイル: NoReturnCall.cs プロジェクト: tmakij/MiniPascal

 public void EmitIR(CILEmitter Emitter)
 {
     call.EmitIR(Emitter, false);
     if (call.ToCall.ReturnType != null)
     {
         Emitter.Pop();
     }
 }

コード例 #6

 public void EmitIR(CILEmitter Emitter, bool Reference)
 {
     if (Reference)
     {
         throw new InvalidByReferenceException();
     }
     Emitter.CallRead(Type);
 }

コード例 #7

 public void EmitIR(CILEmitter Emitter, bool Reference)
 {
     if (Reference)
     {
         throw new InvalidByReferenceException();
     }
     Emitter.PushInt32(literal);
 }

コード例 #8

 public void EmitIR(CILEmitter Emitter, bool Reference)
 {
     if (Reference)
     {
         throw new InvalidByReferenceException();
     }
     expression.EmitIR(Emitter, Reference);
 }

コード例 #9

 public void EmitIR(CILEmitter Emitter, bool Reference)
 {
     if (Reference)
     {
         throw new InvalidByReferenceException();
     }
     factor.EmitIR(Emitter, false);
     Type.UnaryOperation(oper).EmitIR(Emitter);
 }

コード例 #10

        public void EmitIR(CILEmitter Emitter, bool Reference)
        {
            if (Reference)
            {
                throw new InvalidByReferenceException();
            }
            int booleanValue = literal ? 1 : 0;

            Emitter.PushInt32(booleanValue);
        }

コード例 #11

 public void EmitIR(CILEmitter Emitter, bool Reference)
 {
     if (Reference)
     {
         throw new InvalidByReferenceException();
     }
     factor.EmitIR(Emitter, false);
     Emitter.ArraySize();
     Emitter.ToInt32();
 }

コード例 #12

ファイル: PrintStatement.cs プロジェクト: tmakij/MiniPascal

 public void EmitIR(CILEmitter Emitter)
 {
     for (int i = 0; i < toPrint.Count; i++)
     {
         IExpression    expr     = toPrint.Expression(i);
         MiniPascalType exprType = toPrint.Type(i);
         expr.EmitIR(Emitter, false);
         Emitter.CallPrint(exprType);
     }
 }

コード例 #13

ファイル: If.cs プロジェクト: tmakij/MiniPascal

 public void EmitIR(CILEmitter Emitter)
 {
     condition.EmitIR(Emitter, false);
     if (elseStatement == null)
     {
         Emitter.If(() => thenStatement.EmitIR(Emitter));
     }
     else
     {
         Emitter.IfElse(() => thenStatement.EmitIR(Emitter), () => elseStatement.EmitIR(Emitter));
     }
 }

コード例 #14

ファイル: SignedExpression.cs プロジェクト: tmakij/MiniPascal

 protected override void LoadFirst(CILEmitter Emitter, bool Reference)
 {
     base.LoadFirst(Emitter, Reference);
     if (sign == OperatorType.Substraction)
     {
         if (Type.Equals(MiniPascalType.Integer))
         {
             Emitter.PushInt32(-1);
         }
         else if (Type.Equals(MiniPascalType.Real))
         {
             Emitter.PushSingle(-1f);
         }
         Emitter.Multiply();
         return;
     }
 }

コード例 #15

 public void EmitIR(CILEmitter Emitter)
 {
     Emitter.CallStringLessThan();
 }

コード例 #16

 public void EmitIR(CILEmitter Emitter)
 {
     Emitter.LessThan();
 }

コード例 #17

ファイル: StringNotEquals.cs プロジェクト: tmakij/MiniPascal

 public void EmitIR(CILEmitter Emitter)
 {
     Emitter.CallStringEquals();
     Emitter.PushInt32(0);
     Emitter.Equals();
 }

コード例 #18

 public void EmitIR(CILEmitter Emitter)
 {
     Emitter.Divide();
 }

コード例 #19

ファイル: NumericalEquals.cs プロジェクト: tmakij/MiniPascal

 public void EmitIR(CILEmitter Emitter)
 {
     Emitter.Equals();
 }

コード例 #20

 public void EmitIR(CILEmitter Emitter)
 {
     Emitter.GreaterThan();
     Emitter.PushInt32(0);
     Emitter.Equals();
 }

コード例 #21

 public void EmitIR(CILEmitter Emitter)
 {
     Emitter.CallStringEquals();
 }

コード例 #22

ファイル: Assert.cs プロジェクト: tmakij/MiniPascal

 public void EmitIR(CILEmitter Emitter)
 {
     toAssert.EmitIR(Emitter, false);
     Emitter.Assert();
 }

コード例 #23

 public void EmitIR(CILEmitter Emitter)
 {
     Emitter.Modulo();
 }

コード例 #24

 public void EmitIR(CILEmitter Emitter)
 {
     Emitter.While(() => condition.EmitIR(Emitter, false), () => doStatement.EmitIR(Emitter));
 }

コード例 #25

 public void EmitIR(CILEmitter Emitter)
 {
     Emitter.GreaterThan();
 }

コード例 #26

 public void EmitIR(CILEmitter Emitter)
 {
     Emitter.Multiply();
 }

コード例 #27

ファイル: IntegerSubstraction.cs プロジェクト: tmakij/MiniPascal

 public void EmitIR(CILEmitter Emitter)
 {
     Emitter.Substract();
 }

コード例 #28

ファイル: IntegerAddition.cs プロジェクト: tmakij/MiniPascal

 public void EmitIR(CILEmitter Emitter)
 {
     Emitter.Add();
 }

コード例 #29

ファイル: StringConcatenation.cs プロジェクト: tmakij/MiniPascal

 public void EmitIR(CILEmitter Emitter)
 {
     Emitter.CallStringConcat();
 }

コード例 #30

ファイル: BooleanOr.cs プロジェクト: tmakij/MiniPascal

 public void EmitIR(CILEmitter Emitter)
 {
     Emitter.Or();
 }