Common Intermediate Language и системное программирование в Microsoft.Net. Макаров А.В - 159 стр.

UptoLike

ВУЗ: 

МГТУ им. Баумана | Москва

Составители: 

Рубрика: 

{
public VariableExpression() { }
public override string GenerateCS()
{
return “x”;
}
public override void GenerateCIL(ILGenerator il)
{
il.Emit(OpCodes.Ldarg_1);
}
public override double Evaluate(double x)
{
return x;
}
}
public class Parser
{
private const string REGEXP_NUMBER = “[0-9]+(.[0-9])?”;
private Match token;
public Parser(string expr)
{
token = Regex.Match(expr,
“x|” + // identifier x
REGEXP_NUMBER+”|”+ // floating-point numbers
“\\+|\\-|\\*|/|”+ // arithmetic operators
“\\(|\\)” // parens
);
}
public Expression Parse()
{
checkToken();
Expression result = null;
OpCode op = OpCodes.Add;
if (isAddOp())
Исходный код программы Integral
305
{
a.GenerateCIL(il);
b.GenerateCIL(il);
il.Emit(op);
}
public override double Evaluate(double x)
{
if (op.Equals(OpCodes.Add))
return a.Evaluate(x) + b.Evaluate(x);
else if (op.Equals(OpCodes.Sub))
return a.Evaluate(x) – b.Evaluate(x);
else if (op.Equals(OpCodes.Mul))
return a.Evaluate(x) * b.Evaluate(x);
else
return a.Evaluate(x) / b.Evaluate(x);
}
}
class ConstExpression: Expression
{
private double value;
public ConstExpression(double value) { this.value = value; }
public override string GenerateCS()
{
return value.ToString(new CultureInfo(“”));
}
public override void GenerateCIL(ILGenerator il)
{
il.Emit(OpCodes.Ldc_R8,value);
}
public override double Evaluate(double x)
{
return value;
}
}
class VariableExpression: Expression
304
CIL и системное программирование в Microsoft .NET
304                                CIL и системное программирование в Microsoft .NET   Исходный код программы Integral                                  305


          {                                                                                 {
              a.GenerateCIL(il);                                                                public VariableExpression() { }
              b.GenerateCIL(il);
              il.Emit(op);                                                                      public override string GenerateCS()
          }                                                                                     {
                                                                                                   return “x”;
          public override double Evaluate(double x)                                             }
          {
             if (op.Equals(OpCodes.Add))                                                        public override void GenerateCIL(ILGenerator il)
               return a.Evaluate(x) + b.Evaluate(x);                                            {
             else if (op.Equals(OpCodes.Sub))                                                      il.Emit(OpCodes.Ldarg_1);
                return a.Evaluate(x) – b.Evaluate(x);                                           }
             else if (op.Equals(OpCodes.Mul))
                return a.Evaluate(x) * b.Evaluate(x);                                           public override double Evaluate(double x)
             else                                                                               {
                return a.Evaluate(x) / b.Evaluate(x);                                              return x;
          }                                                                                     }
      }                                                                                     }

      class ConstExpression: Expression                                                     public class Parser
      {                                                                                     {
        private double value;                                                                 private const string REGEXP_NUMBER = “[0-9]+(.[0-9])?”;
                                                                                              private Match token;
          public ConstExpression(double value) { this.value = value; }
                                                                                                public Parser(string expr)
          public override string GenerateCS()                                                   {
          {
             return value.ToString(new CultureInfo(“”));                                            token = Regex.Match(expr,
          }                                                                                            “x|” +             // identifier x
                                                                                                       REGEXP_NUMBER+”|”+ // floating-point numbers
          public override void GenerateCIL(ILGenerator il)                                             “\\+|\\-|\\*|/|”+ // arithmetic operators
          {                                                                                            “\\(|\\)”          // parens
             il.Emit(OpCodes.Ldc_R8,value);                                                            );
          }                                                                                     }

          public override double Evaluate(double x)                                             public Expression Parse()
          {                                                                                     {
             return value;                                                                         checkToken();
          }                                                                                        Expression result = null;
      }                                                                                            OpCode op = OpCodes.Add;

      class VariableExpression: Expression                                                          if (isAddOp())

Страницы