private void CompileNeg(ILExpression e, ExpectType expect) { CompileExpression(e.Arguments[0], ExpectType.Primitive); InterType opType = resolver.Resolve(e.InferredType, thisMethod.FullGenericArguments); JavaPrimitiveType jp = JavaHelpers.InterTypeToJavaPrimitive(opType); OpCodes opcode = OpCodes.ineg; switch (jp) { case JavaPrimitiveType.Long: opcode = OpCodes.lneg; break; case JavaPrimitiveType.Float: opcode = OpCodes.fneg; break; case JavaPrimitiveType.Double: opcode = OpCodes.dneg; break; case JavaPrimitiveType.Ref: throw new Exception(); //TODO: normal error } codeGenerator.Add(opcode, null, e); TranslateType(opType, expect, e); }
public static JsonCommand ClearExpectBuffer(int timeout, ExpectType expect_type = ExpectType.P2P) { var jc = new JsonCommand(CommandType.ClearExpectBuffer, "", timeout); jc.ExpectType = expect_type; return(jc); }
private void CompileBlock(ILBlock block, ExpectType expect) { foreach (ILNode node in block.Body) { CompileNode(node, expect); } }
public static JsonCommand ResetExpectSession(int timeout, ExpectType expect_type = ExpectType.P2P) { var jc = new JsonCommand(CommandType.ResetExpectSession, "", timeout); jc.ExpectType = expect_type; return(jc); }
private void CompileConvR8(ILExpression e, ExpectType expect) { InterType gettedType = resolver.Resolve(e.Arguments[0].InferredType, thisMethod.FullGenericArguments); JavaPrimitiveType gettedJava = JavaHelpers.InterTypeToJavaPrimitive(gettedType); CompileExpression(e.Arguments[0], ExpectType.Any); switch (gettedJava) { case JavaPrimitiveType.Bool: case JavaPrimitiveType.Byte: case JavaPrimitiveType.Short: case JavaPrimitiveType.Char: case JavaPrimitiveType.Int: codeGenerator.Add(Java.OpCodes.i2d, e); break; case JavaPrimitiveType.Long: codeGenerator.Add(Java.OpCodes.l2d, e); break; case JavaPrimitiveType.Float: codeGenerator.Add(Java.OpCodes.f2d, e); break; case JavaPrimitiveType.Double: break; default: Messages.Message(MessageCode.CantConvertType, gettedType.Fullname, "double"); return; } TranslateType(InterType.PrimitiveTypes[(int)PrimitiveType.Double], expect, e); }
private void CompileBreak(ILExpression e, ExpectType expect) { if (Program.CompileBreak) { codeGenerator.Add(Java.OpCodes.breakpoint, null, e); } }
private void CompileLocalloc(ILExpression e, ExpectType expect) { Messages.Message(MessageCode.UnsafeInstruction, e.Code.ToString()); CompileExpression(e.Arguments[0], ExpectType.Primitive); codeGenerator.AddNewArray(JavaArrayType.Byte, e); }
private void CompileLdobj(ILExpression e, ExpectType expect) { InterType operand = resolver.Resolve((TypeReference)e.Operand, thisMethod.FullGenericArguments); if ((operand.IsPrimitive) && (e.Arguments[0].Code == ILCode.Ldloc) && (((ILVariable)e.Arguments[0].Operand).Name == "this")) { //Special treatment. Value for primitive types codeGenerator .Add(Java.OpCodes.aload_0, null, e) .Add(Java.OpCodes.getfield, new Java.Constants.FieldRef( namesController.TypeNameToJava(operand.CILBoxType), "value", namesController.GetFieldDescriptor(operand)), e); } else if (operand.IsValueType) { CompileExpression(e.Arguments[0], ExpectType.ByRef); MethodRef getCopyRef = new MethodRef(namesController.TypeNameToJava(operand), ClassNames.ValueTypeGetCopy, "()" + namesController.GetFieldDescriptor(operand)); codeGenerator.Add(Java.OpCodes.invokevirtual, getCopyRef, e); } else { // From ECMA-335, III.4.29 // If typeTok is not a generic parameter and either a reference type or a built-in value // class, then the ldind instruction provides a shorthand for the ldobj instruction. CompileLdind(e, expect); } }
private void CompileLogicAnd(ILExpression e, ExpectType expect) { string labelsSufix = rnd.Next().ToString(); string falseLabel = "false" + labelsSufix; string exitLabel = "exit" + labelsSufix; Java.OpCodes branch = Java.OpCodes.ifeq; CompileExpression(e.Arguments[0], ExpectType.Primitive); TranslateToBool(e.Arguments[0].InferredType, ref branch, e); codeGenerator.Add(branch, falseLabel, e); CompileExpression(e.Arguments[1], ExpectType.Primitive); TranslateToBool(e.Arguments[1].InferredType, ref branch, e); branch = Java.OpCodes.ifeq; codeGenerator .Add(branch, falseLabel, e) .Add(Java.OpCodes.iconst_1, null, e) .Add(Java.OpCodes._goto, exitLabel, e) .Label(falseLabel) .Add(Java.OpCodes.iconst_0, null, e) .Label(exitLabel); }
private void CompileLdcDecimal(ILExpression e, ExpectType expect) { decimal operand = (decimal)e.Operand; int[] bits = decimal.GetBits(operand); codeGenerator .Add(OpCodes._new, new Java.Constants.Class(namesController.TypeNameToJava(ClassNames.SystemDecimal.ClassNames)), e) .Add(OpCodes.dup, null, e) .Add(OpCodes.iconst_4, null, e) .AddNewArray(JavaArrayType.Int, e) .Add(OpCodes.dup, null, e) .Add(OpCodes.iconst_0, null, e) .AddIntConst(bits[0], e) .Add(OpCodes.iastore, null, e) .Add(OpCodes.dup, null, e) .Add(OpCodes.iconst_1, null, e) .AddIntConst(bits[1], e) .Add(OpCodes.iastore, null, e) .Add(OpCodes.dup, null, e) .Add(OpCodes.iconst_2, null, e) .AddIntConst(bits[2], e) .Add(OpCodes.iastore, null, e) .Add(OpCodes.dup, null, e) .Add(OpCodes.iconst_3, null, e) .AddIntConst(bits[3], e) .Add(OpCodes.iastore, null, e) .Add(OpCodes.invokespecial, ClassNames.SystemDecimal.FromBitsCtorRef, e); }
private void CompileLdcR4(ILExpression e, ExpectType expect) { float operand = (float)e.Operand; if (operand == 0.0f) { codeGenerator.AddInstruction(new JavaInstruction(Java.OpCodes.fconst_0, null, e)); } else if (operand == 1.0f) { codeGenerator.AddInstruction(new JavaInstruction(Java.OpCodes.fconst_1, null, e)); } else if (operand == 2.0f) { codeGenerator.AddInstruction(new JavaInstruction(Java.OpCodes.fconst_2, null, e)); } else { //TODO: From Java Virtual Machine Specification: //The ldc instruction can only be used to push a value of type float taken from the float value set (§2.3.2) //because a constant of type float in the constant pool (§4.4.4) must be taken from the float value set. //What this means, and check this (may be NaN and Inf?) codeGenerator.AddInstruction(new JavaInstruction(Java.OpCodes.ldc, new Java.Constants.Float(operand), e)); } TranslateType(InterType.PrimitiveTypes[(int)PrimitiveType.Single], expect, e); }
private void CompileLogicNot(ILExpression e, ExpectType expect) { CompileExpression(e.Arguments[0], ExpectType.Primitive); // push exp // ifeq zero // iconst_0 // goto exit //zero: // iconst_1 //exit string labelSufixes = rnd.Next().ToString(); string zeroLabel = "zero" + labelSufixes; string exitLabel = "exit" + labelSufixes; Java.OpCodes branch = Java.OpCodes.ifeq; TranslateToBool(e.Arguments[0].InferredType, ref branch, e); codeGenerator .Add(branch, zeroLabel, e) .Add(Java.OpCodes.iconst_0, null, e) .Add(Java.OpCodes._goto, exitLabel, e) .Label(zeroLabel) .Add(Java.OpCodes.iconst_1) .Label(exitLabel); }
private void CompileStfld(ILExpression e, ExpectType expectType) { InterField operand = resolver.Resolve((FieldReference)e.Operand, thisMethod.FullGenericArguments); bool needDup = ((e.ExpectedType != null) && (expectType != ExpectType.None)); bool boxed = operand.IsStatic && operand.IsThreadLocal; int argIndex = 0; if (e.Code == ILCode.Stfld) CompileExpression(e.Arguments[argIndex++], ExpectType.Reference); CompileExpression(e.Arguments[argIndex++], boxed ? ExpectType.Boxed : GetExpectType(operand)); if (needDup) { JavaPrimitiveType jp = JavaHelpers.InterTypeToJavaPrimitive(operand.FieldType); if (e.Code == ILCode.Stfld) { if (jp.IsDoubleSlot()) codeGenerator.Add(Java.OpCodes.dup2_x1, null, e); else codeGenerator.Add(Java.OpCodes.dup_x1, null, e); } else { if (jp.IsDoubleSlot()) codeGenerator.Add(Java.OpCodes.dup2, null, e); else codeGenerator.Add(Java.OpCodes.dup, null, e); } } CompileFieldStore(operand, e); }
private void CompileStobj(ILExpression e, ExpectType expect) { InterType operand = resolver.Resolve((TypeReference)e.Operand, thisMethod.FullGenericArguments); if (operand.IsValueType) { // stobj(destPtr, src) compiling to // src.CopyTo(destPtr) CompileExpression(e.Arguments[1], ExpectType.Any); CompileExpression(e.Arguments[0], ExpectType.ByRef); MethodRef copyToRef = new MethodRef(namesController.TypeNameToJava(operand), ClassNames.ValueTypeCopyTo, "(" + namesController.GetFieldDescriptor(operand) + ")V"); bool needDup = ((e.ExpectedType != null) && (expect != ExpectType.None)); if (needDup) { codeGenerator.Add(Java.OpCodes.dup_x1, null, e); } codeGenerator.Add(Java.OpCodes.invokevirtual, copyToRef, e); } else { // From ECMA-335, III.4.29 // The stobj instruction copies the value src to the address dest. If typeTok is not // a generic parameter and either a reference type or a built-in value class, then // the stind instruction provides a shorthand for the stobj instruction. CompileStind(e, expect); } }
private void CompileIsinst(ILExpression e, ExpectType expect) { InterType operand = resolver.Resolve((TypeReference)e.Operand, thisMethod.FullGenericArguments); CompileExpression(e.Arguments[0], ExpectType.Reference); // dup // instanceof operand // ifne :end // pop // aconst_null //:end // checkcast operand string endLabel = rnd.Next().ToString() + "end"; Java.Constants.Class operandRef = new Java.Constants.Class(namesController.TypeNameToJava(GetBoxType(operand))); codeGenerator .Add(Java.OpCodes.dup, null, e) .Add(Java.OpCodes.instanceof, operandRef, e) .Add(Java.OpCodes.ifne, endLabel, e) .Add(Java.OpCodes.pop, null, e) .Add(Java.OpCodes.aconst_null, null, e) .Label(endLabel) .Add(Java.OpCodes.checkcast, operandRef, e); }
private void CompileLdstr(ILExpression e, ExpectType expect) { string operand = (string)e.Operand; codeGenerator.AddInstruction(new JavaInstruction(Java.OpCodes.ldc, new Java.Constants.String(operand), e)); TranslateType(resolver.Resolve(e.ExpectedType, thisMethod.FullGenericArguments), expect, e); }
private void CompileCastclass(ILExpression e, ExpectType expect) { InterType operand = resolver.Resolve((TypeReference)e.Operand, thisMethod.FullGenericArguments); CompileExpression(e.Arguments[0], expect); codeGenerator.Add(Java.OpCodes.checkcast, new Java.Constants.Class(namesController.TypeNameToJava(operand)), e); }
private void CompileLdcI8(ILExpression e, ExpectType expect) { long operand = (long)e.Operand; codeGenerator.AddLongConst(operand, e); TranslateType(InterType.PrimitiveTypes[(int)PrimitiveType.Int32], expect, e); }
private void CompileArglist(ILExpression e, ExpectType expect) { codeGenerator .Add(OpCodes._new, new Java.Constants.Class(namesController.TypeNameToJava(ClassNames.SystemRuntimeArgumentHandle.ClassName)), e) .Add(OpCodes.dup, null, e) .AddLoad(JavaPrimitiveType.Ref, var2Index.Where(K => K.Key.Name == ClassNames.VarArgParamName).FirstOrDefault().Value, e) .Add(OpCodes.invokespecial, ClassNames.SystemRuntimeArgumentHandle.CtorMethodRef); }
private void CompileValueOf(ILExpression e, ExpectType expect) { InterType returnType = resolver.Resolve(e.InferredType, thisMethod.FullGenericArguments); InterType nullableType = resolver.Resolve(e.Arguments[0].InferredType, thisMethod.FullGenericArguments); CompileExpression(e.Arguments[0], ExpectType.ByRef); codeGenerator.Add(OpCodes.invokevirtual, new MethodRef(namesController.TypeNameToJava(nullableType), ClassNames.SystemNullable_1.GetValueOrDefaultMethodName, "()" + namesController.GetFieldDescriptor(returnType))); }
private void CompileAddressOf(ILExpression e, ExpectType expectType) { e = e.Arguments[0]; if (e.Operand is TypeReference) { //ValueType CompileExpression(e, expectType); return; } else if (!(e.Operand is MethodReference)) { CompileExpression(e, ExpectType.Boxed); return; } InterMethod method = resolver.Resolve((MethodReference)e.Operand, thisMethod.FullGenericArguments); InterType operand = method.DeclaringType; if (!operand.IsArray) { //Getter if (method.ReturnParameter.Type.IsPrimitive) { CompileExpression(e, ExpectType.Boxed); } else { CompileExpression(e, GetExpectType(method.ReturnParameter)); } return; } JavaArrayType arrType = JavaHelpers.InterTypeToJavaArrayType(operand); string arrayByRefName = byRefController.GetArrayByRefTypeName(operand); Java.Constants.Class arrayByRefNameClass = new Java.Constants.Class(namesController.TypeNameToJava(arrayByRefName)); Java.Constants.MethodRef arrayByRefInitMethodRef = byRefController.GetArrayByRefCtorMethodRef(operand); codeGenerator .Add(OpCodes._new, arrayByRefNameClass, e) .Add(OpCodes.dup, null, e); CompileExpression(e.Arguments[0], ExpectType.Reference); //array CompileExpression(e.Arguments[1], ExpectType.Primitive); //first index for (int i = 0; i < operand.ArrayRank - 1; i++) { codeGenerator.Add(Java.OpCodes.aaload, null, e); CompileExpression(e.Arguments[i + 2], ExpectType.Primitive); } codeGenerator.Add(OpCodes.invokespecial, arrayByRefInitMethodRef, e); }
private void CompileLdloca(ILExpression e, ExpectType expectType) { ILVariable operand = (ILVariable)e.Operand; int varIndex = GetVarIndex(operand); InterType operandType = resolver.Resolve(operand.Type, thisMethod.FullGenericArguments); if (operandType.IsValueType) { codeGenerator.AddLoad(JavaPrimitiveType.Ref, varIndex); return; } if ((operandType.IsPrimitive) && (expectType == ExpectType.Reference)) { codeGenerator.AddLoad(JavaHelpers.InterTypeToJavaPrimitive(operandType), varIndex, e); TranslateType(operandType, ExpectType.Boxed, e); return; } string localByRefName = byRefController.GetLocalByRefTypeName(operandType); Java.Constants.Class localByRefNameClass = new Java.Constants.Class(namesController.TypeNameToJava(localByRefName)); Java.Constants.MethodRef localByRefInitMethodRef = byRefController.GetLocalByRefCtorMethodRef(operandType); Java.Constants.MethodRef getValueMethodRef = byRefController.GetByRefGetValueMethodRef(JavaHelpers.InterTypeToJavaPrimitive(operandType)); int localRefTempVar = GetNextFreeVar(JavaPrimitiveType.Ref); codeGenerator .Add(OpCodes._new, localByRefNameClass, e) .Add(OpCodes.dup, null, e) .AddLocalVarInstruction(LocalVarInstruction.Load, JavaHelpers.InterTypeToJavaPrimitive(operandType), varIndex, e) .Add(OpCodes.invokespecial, localByRefInitMethodRef, e) .Add(OpCodes.dup, null, e) .AddLocalVarInstruction(LocalVarInstruction.Store, JavaPrimitiveType.Ref, localRefTempVar, e); RegisterLocalByRef(() => { codeGenerator .AddLocalVarInstruction(LocalVarInstruction.Load, JavaPrimitiveType.Ref, localRefTempVar, e) .Add(OpCodes.invokevirtual, getValueMethodRef, e); if ((!operandType.IsPrimitive) && (!operandType.IsEnum)) { codeGenerator.Add(OpCodes.checkcast, new Java.Constants.Class(namesController.TypeNameToJava(operandType)), e); } codeGenerator.AddLocalVarInstruction(LocalVarInstruction.Store, JavaHelpers.InterTypeToJavaPrimitive(operandType), varIndex, e); FreeVar(localRefTempVar, JavaPrimitiveType.Ref); }); //TODO: TranslateType if neeeded }
private void CompilePostIncrement(ILExpression e, ExpectType expect) { int incVal = (int)e.Operand; e = e.Arguments[0]; //TODO: PostIncrement for long and other types if (e.Code == ILCode.Ldloca) { int varIndex = GetVarIndex((ILVariable)e.Operand); codeGenerator .AddLoad(JavaPrimitiveType.Int, varIndex, e) .Add(OpCodes.dup, null, e) .AddIntConst(incVal, e) .Add(OpCodes.iadd, null, e) .AddStore(JavaPrimitiveType.Int, varIndex, e); } else if (e.Code == ILCode.Ldsflda) { InterField operand = resolver.Resolve((FieldReference)e.Operand, thisMethod.FullGenericArguments); CompileFieldLoad(operand, e); codeGenerator .Add(OpCodes.dup, null, e) .AddIntConst(incVal, e) .Add(OpCodes.iadd, null, e); CompileFieldStore(operand, e); } else if (e.Code == ILCode.Ldflda) { InterField operand = resolver.Resolve((FieldReference)e.Operand, thisMethod.FullGenericArguments); int tmpVar = GetNextFreeVar(JavaPrimitiveType.Int); CompileExpression(e.Arguments[0], ExpectType.Reference); //this codeGenerator.Add(OpCodes.dup, null, e); CompileFieldLoad(operand, e); codeGenerator .Add(OpCodes.dup, null, e) .AddStore(JavaPrimitiveType.Int, tmpVar, e) .AddIntConst(incVal, e) .Add(OpCodes.iadd, null, e); CompileFieldStore(operand, e); codeGenerator .AddLoad(JavaPrimitiveType.Int, tmpVar, e); FreeVar(tmpVar, JavaPrimitiveType.Int); } else { throw new Exception(); //TODO: another supported postincrements. } // See ICSharpCode.Decompiler\ILAst\PeepholeTransform.cs:IntroducePostIncrement }
private void CompileConvTo8(ILExpression e, ExpectType expect) { InterType gettedType = resolver.Resolve(e.Arguments[0].InferredType, thisMethod.FullGenericArguments); JavaPrimitiveType gettedJava = JavaHelpers.InterTypeToJavaPrimitive(gettedType); CompileExpression(e.Arguments[0], ExpectType.Any); bool isToUnsigned = e.Code.IsConvToUnsigned(); bool isFromUnsigned = e.Code.IsConvFromUnsigned(); bool isOvf = e.Code.IsOvf(); if (isOvf) { long mask = unchecked ((long)0xffffffffffffffffL); double minValue = (double)long.MinValue; double maxValue = (double)long.MaxValue; if (isToUnsigned) { minValue = (double)ulong.MinValue; maxValue = (double)ulong.MaxValue; } if ((isToUnsigned && !isFromUnsigned) || (!isToUnsigned && isFromUnsigned)) { mask = 0x7fffffffffffffffL; } CompileCheckOvf(e, gettedJava, mask, minValue, maxValue); } switch (gettedJava) { case JavaPrimitiveType.Bool: case JavaPrimitiveType.Byte: case JavaPrimitiveType.Char: case JavaPrimitiveType.Short: case JavaPrimitiveType.Int: codeGenerator.Add(OpCodes.i2l, null, e); break; case JavaPrimitiveType.Long: break; case JavaPrimitiveType.Float: codeGenerator.Add(OpCodes.f2l, null, e); break; case JavaPrimitiveType.Double: codeGenerator.Add(OpCodes.d2l, null, e); break; default: throw new Exception(); //TODO: Normal error } TranslateType(InterType.PrimitiveTypes[(int)(isToUnsigned ? PrimitiveType.UInt64 : PrimitiveType.Int64)], expect, e); }
private void CompileInitblk(ILExpression e, ExpectType expect) { Messages.Message(MessageCode.UnsafeInstruction, e.Code.ToString()); CompileExpression(e.Arguments[0], ExpectType.Reference); CompileExpression(e.Arguments[1], ExpectType.Primitive); CompileExpression(e.Arguments[2], ExpectType.Primitive); codeGenerator.Add(OpCodes.invokestatic, ClassNames.CIL2JavaVESInstructions.InitblkRef, e); }
private void CompileStelem(ILExpression e, ExpectType expect) { TypeReference typeRef = e.Operand as TypeReference ?? e.InferredType; InterType operand = null; if (typeRef != null) { operand = resolver.Resolve(typeRef, thisMethod.FullGenericArguments); } else { switch (e.Code) { case ILCode.Stelem_I: operand = InterType.PrimitiveTypes[(int)(Program.AsX64 ? PrimitiveType.Int64 : PrimitiveType.Int32)]; break; case ILCode.Stelem_I1: operand = InterType.PrimitiveTypes[(int)PrimitiveType.SByte]; break; case ILCode.Stelem_I2: operand = InterType.PrimitiveTypes[(int)PrimitiveType.Int16]; break; case ILCode.Stelem_I4: operand = InterType.PrimitiveTypes[(int)PrimitiveType.Int32]; break; case ILCode.Stelem_I8: operand = InterType.PrimitiveTypes[(int)PrimitiveType.Int64]; break; case ILCode.Stelem_R4: operand = InterType.PrimitiveTypes[(int)PrimitiveType.Single]; break; case ILCode.Stelem_R8: operand = InterType.PrimitiveTypes[(int)PrimitiveType.Double]; break; } } JavaPrimitiveType valueJPType = operand != null?JavaHelpers.InterTypeToJavaPrimitive(operand) : JavaPrimitiveType.Ref; JavaArrayType arrType = JavaHelpers.JavaPrimitiveToArrayType(valueJPType); ExpectType valueExpectType = operand != null?GetExpectType(operand) : ExpectType.Reference; bool needDup = ((e.ExpectedType != null) && (expect != ExpectType.None)); CompileExpression(e.Arguments[0], ExpectType.Reference); //array CompileExpression(e.Arguments[1], ExpectType.Primitive); //index CompileExpression(e.Arguments[2], valueExpectType); //value if (needDup) { if (valueJPType.IsDoubleSlot()) { codeGenerator.Add(Java.OpCodes.dup2_x2, null, e); } else { codeGenerator.Add(Java.OpCodes.dup_x2, null, e); } } codeGenerator.AddArrayStore(arrType, e); }
private void CompileInitializedObject(ILExpression e, ExpectType expect) { if (initializedObjectsVarIndexes.Count == 0) { Messages.Message(MessageCode.NoInitializedObject); } else { codeGenerator.AddLoad(JavaPrimitiveType.Ref, initializedObjectsVarIndexes.Peek(), e); } }
private void CompileConvToNative(ILExpression e, ExpectType expect) { if (Program.AsX64) { CompileConvTo8(e, expect); } else { CompileConvTo4(e, expect); } }
private void CompileTernaryOp(ILExpression e, ExpectType expect) { ILCondition conditionNode = new ILCondition(); conditionNode.Condition = e.Arguments[0]; conditionNode.TrueBlock = new ILBlock(e.Arguments[1]); conditionNode.FalseBlock = new ILBlock(e.Arguments[2]); CompileCondition(conditionNode, expect); TranslateType(resolver.Resolve(e.InferredType, thisMethod.FullGenericArguments), expect, e); }
private void CompileLoopContinue(ILExpression e, ExpectType expect) { if (loopContinueLabel.Count == 0) { Messages.Message(MessageCode.LoopOpcodeFoundedOutsideLoop, e.Code.ToString()); } else { codeGenerator.Add(OpCodes._goto, loopContinueLabel.Peek(), e); } }
private ExpectValueHandler(Browser browser, ExpectType expectType) { _browser = browser; _expectType = expectType; }
/// <summary> /// Prevents a default instance of the <see cref="Text"/> class from being created. /// </summary> /// <param name="provider">The provider.</param> /// <param name="manager">The manager.</param> /// <param name="expectType">Type of the expect.</param> private Text(AutomationProvider provider, CommandManager manager, ExpectType expectType) : base(provider, manager) { _expectType = expectType; }