public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var stringOp = operandStack.PopString();
var stringVal = stringOp.Value;
var seekOp = operandStack.PopString();
var seekVal = seekOp.Value;
var index = stringVal.IndexOf(seekVal);
if (index >= 0)
{
var post = stringVal.Substring(index + seekVal.Length);
var postOp = new StringOperand(post);
operandStack.Push(postOp);
operandStack.Push(seekOp);
var pre = stringVal.Substring(0, index);
var preOp = new StringOperand(pre);
operandStack.Push(preOp);
var boolOp = new BooleanOperand(true);
operandStack.Push(boolOp);
}
else
{
operandStack.Push(stringOp);
var boolOp = new BooleanOperand(false);
operandStack.Push(boolOp);
}
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var strOp = operandStack.PopString();
var fileOp = operandStack.PopFile();
var length = strOp.Value.Length;
var sb = new StringBuilder();
bool atEnd = false;
while (length > 0 && !atEnd)
{
var ch = fileOp.Reader.Read();
if (ch != Chars.EOF)
{
sb.Append(ch);
length--;
}
else
{
atEnd = true;
}
}
var substrOp = new StringOperand(sb.ToString());
operandStack.Push(substrOp);
operandStack.Push(new BooleanOperand(!atEnd));
}
/// <summary>
/// Convert the given encoded string to a byte array
/// <summary>
private static byte[] GetBytes(StringOperand stringOp)
{
byte[] bytes;
switch (stringOp.Type)
{
case StringType.Hex:
{
bytes = new byte[stringOp.Length];
for (int i = 0; i < stringOp.Length; i++)
{
bytes[i] = (byte)stringOp.Value[i];
}
break;
}
case StringType.AsciiBase85:
{
bytes = Ascii85Decoder.Decode(stringOp.Value);
break;
}
default:
{
throw new Exception("Encoded Number String expected");
}
}
return(bytes);
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var stringVal = operandStack.PopStringValue();
byte[] bytes = System.Text.Encoding.ASCII.GetBytes(stringVal);
var memoryStream = new MemoryStream(bytes);
var scriptReader = new StreamReader(memoryStream);
var fileReader = new EpsStreamReader(scriptReader);
var parser = new Parser(fileReader);
var operand = parser.GetNextOperand();
if (operand != null)
{
var post = scriptReader.ReadToEnd();
var postOp = new StringOperand(post);
operandStack.Push(postOp);
operandStack.Push(operand);
var boolOp = new BooleanOperand(true);
operandStack.Push(boolOp);
}
else
{
var boolOp = new BooleanOperand(false);
operandStack.Push(boolOp);
}
scriptReader.Dispose();
memoryStream.Dispose();
}
/// <summary>
/// Construct a substring
/// </summary>
public StringOperand(StringOperand originalOperand, int startIndex, int length) : this()
{
isOriginalValue = false;
stringProxy = originalOperand.stringProxy;
this.startIndex = originalOperand.startIndex + startIndex;
Length = length;
}
/// <summary>
/// Converts an encoded number string to a list of double values
/// </summary>
/// <param name="stringOperand"></param>
/// <returns></returns>
public static List <double> Decode(StringOperand stringOperand)
{
byte[] bytes = null;
switch (stringOperand.Type)
{
case StringType.Standard:
{
throw new Exception("Encoded Number String expected");
}
case StringType.Hex:
{
bytes = new byte[stringOperand.Length];
for (int i = 0; i < stringOperand.Length; i++)
{
bytes[i] = (byte)stringOperand.Value[i];
}
}
break;
case StringType.AsciiBase85:
{
bytes = Ascii85Decoder.Decode(stringOperand.Value);
break;
}
}
return(DecodeWorker(bytes));
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var stringOp = operandStack.PopString();
var stringVal = stringOp.Value;
var seekOp = operandStack.PopString();
var seekVal = seekOp.Value;
if (stringVal.StartsWith(seekVal))
{
var post = stringVal.Substring(seekVal.Length);
var postOp = new StringOperand(post);
operandStack.Push(postOp);
operandStack.Push(seekOp);
var boolOp = new BooleanOperand(true);
operandStack.Push(boolOp);
}
else
{
operandStack.Push(stringOp);
var boolOp = new BooleanOperand(false);
operandStack.Push(boolOp);
}
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var count = operandStack.PopIntegerValue();
var index = operandStack.PopIntegerValue();
var operand = operandStack.Pop();
switch (operand)
{
case ArrayOperand arrayOperand:
{
var subArray = new ArrayOperand();
for (int i = index; i < index + count; i++)
{
subArray.Values.Add(arrayOperand.Values[i]);
}
operandStack.Push(subArray);
break;
}
case StringOperand stringOperand:
{
var str = new StringOperand(stringOperand, index, count);
operandStack.Push(str);
break;
}
}
}
/// <summary>
/// CopyTo
/// </summary>
public void CopyTo(StringOperand copy)
{
copy.Type = Type;
copy.isOriginalValue = isOriginalValue;
copy.stringProxy = stringProxy;
copy.startIndex = startIndex;
copy.Length = Length;
}
/// <summary>
/// Create a copy
/// </summary>
protected override Operand CreateCopy()
{
var copy = new StringOperand();
CopyTo(copy);
return(copy);
}
public override void Execute(EpsInterpreter interpreter)
{
var dollarErrordict = interpreter.DollarErrordict;
var newError = (BooleanOperand)dollarErrordict.TryFind("newerror");
newError.Value = false;
var error = new StringOperand("error");
interpreter.OperandStack.Push(error);
}
public SetString(string variableName, string npcName, StringOperand operand, Conversation conversation)
{
this.variableName = variableName;
if (npcName != null){
GameObject npc = CharacterManager.GetCharacter(npcName);
variableSet = ((CharacterState)npc.GetComponent(typeof(CharacterState))).GetVariableSet();
} else {
variableSet = conversation.GetVariableSet();
}
this.operand = operand;
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var strOp = operandStack.PopString();
var fileOp = operandStack.PopFile();
var line = fileOp.Reader.ReadLine();
var substrOp = new StringOperand(line);
operandStack.Push(substrOp);
operandStack.Push(new BooleanOperand(!string.IsNullOrEmpty(line)));
}
public bool CompareStrings(string val1, string val2, StringOperand operand, string delimiter = " ")
{
switch (operand)
{
case StringOperand.Equals:
if (string.Equals(val1, val2,
StringComparison.OrdinalIgnoreCase))
{
return(true);
}
break;
case StringOperand.Contains:
if (val1.ToLower().Contains(val2.ToLower()))
{
return(true);
}
break;
case StringOperand.StartsWith:
if (val1.ToLower().StartsWith(val2.ToLower()))
{
return(true);
}
break;
case StringOperand.EndsWith:
if (val1.ToLower().EndsWith(val2.ToLower()))
{
return(true);
}
break;
case StringOperand.OccursIn:
if (val2.Split(delimiter[0])
.Any(str => string.Equals(str, val1,
StringComparison.OrdinalIgnoreCase)))
{
return(true);
}
break;
default:
throw new ArgumentOutOfRangeException(nameof(operand), operand, null);
}
return(false);
}
public static IOperand CreateDynamic(object value)
{
if (value == null)
{
return(new NullValueOperand());
}
Type t = value.GetType();
IOperand op;
if (ReferenceEquals(t, typeof(double)))
{
op = new DoubleOperand((double)value);
}
else if (ReferenceEquals(t, typeof(string)))
{
op = new StringOperand((string)value);
}
else if (ReferenceEquals(t, typeof(bool)))
{
op = new BooleanOperand((bool)value);
}
else if (ReferenceEquals(t, typeof(int)))
{
op = new IntegerOperand((int)value);
}
else if ((value) is IReference)
{
op = (IOperand)value;
}
else if (ReferenceEquals(t, typeof(ErrorValueWrapper)))
{
op = new ErrorValueOperand((ErrorValueWrapper)value);
}
else if (ReferenceEquals(t, typeof(DateTime)))
{
op = new DateTimeOperand((DateTime)value);
}
else
{
throw new ArgumentException(String.Format("The type {0} is not supported as an operand", t.Name));
}
return(op);
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var count = operandStack.PopIntegerValue();
StringBuilder str = new StringBuilder(count);
for (int i = 0; i < count; i++)
{
str.Append('.');
}
var strOp = new StringOperand {
Value = str.ToString()
};
operandStack.Push(strOp);
}
/// <summary>
/// string content functions
/// </summary>
/// <example>
/// "abcdefg".StartsWith("abc") ?
/// </example>
public StringExpression(
string stringProperty,
StringOperand operand,
string value,
Conditional conditional)
: base(stringProperty, value, operand, conditional)
{
this._binaryExpression = new CodeBinaryOperatorExpression
{
Left =
new CodeMethodInvokeExpression(
CodeTypeReferenceExpression, "StringFunction",
new CodeExpression[]
{
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(),
stringProperty),
new CodePrimitiveExpression(value),
new CodePrimitiveExpression(operand),
}),
Operator = CodeBinaryOperatorType.ValueEquality,
Right = CodePrimitiveExpressionTrue
};
}
private static Instruction Parse(MethodInfo methodInfo)
{
Instruction head = null;
Instruction tail = null;
var data = methodInfo.GetMethodBody().GetILAsByteArray();
var offset = 0u;
while (offset < data.Length)
{
IOperand operand = null;
short opcodeValue = data[offset++];
if (opcodeValue == 0xFE)
{
opcodeValue |= (short)data[offset++];
}
OpCode opcode = _opcodes[opcodeValue];
switch (opcode.OperandType)
{
case OperandType.InlineBrTarget:
{
var branchTarget = Read <uint>(data, ref offset) + offset;
operand = new BranchTargetOperand(branchTarget);
break;
}
case OperandType.InlineField:
{
var metadataToken = Read <int>(data, ref offset);
try {
var fieldInfo = methodInfo.Module.ResolveField(metadataToken);
operand = new FieldOperand(fieldInfo);
} catch (Exception) {
operand = new FieldOperand(null);
}
break;
}
case OperandType.InlineI:
operand = new ImmediateOperand <uint>(opcode.OperandType, Read <uint>(data, ref offset));
break;
case OperandType.InlineI8:
operand = new ImmediateOperand <ulong>(opcode.OperandType, Read <ulong>(data, ref offset));
break;
case OperandType.InlineMethod:
{
var metadataToken = Read <int>(data, ref offset);
try {
var inlineMethodInfo = methodInfo.Module.ResolveMethod(metadataToken);
operand = new MethodOperand(inlineMethodInfo);
} catch (Exception) {
operand = new MethodOperand(null);
}
break;
}
case OperandType.InlineNone:
break;
case OperandType.InlineR:
operand = new ImmediateOperand <double>(opcode.OperandType, Read <double>(data, ref offset));
break;
case OperandType.InlineSig:
{
var metadataToken = Read <int>(data, ref offset);
try {
var blobData = methodInfo.Module.ResolveSignature(metadataToken);
operand = new DataBlobOperand(blobData);
} catch (Exception) {
operand = new DataBlobOperand(null);
}
break;
}
case OperandType.InlineString:
{
var metadataToken = Read <int>(data, ref offset);
try {
var stringInfo = methodInfo.Module.ResolveString(metadataToken);
operand = new StringOperand(stringInfo);
} catch (Exception) {
operand = new StringOperand(null);
}
break;
}
case OperandType.InlineSwitch:
{
var count = Read <uint>(data, ref offset);
var tableOffset = offset;
var switchTargets = new uint[count];
for (var i = 0; i < count; ++i)
{
switchTargets[i] = Read <uint>(data, ref offset) + tableOffset * count * 4;
}
throw new NotImplementedException();
}
case OperandType.InlineTok:
{
var metadataToken = Read <int>(data, ref offset);
try {
var tokenRef = methodInfo.Module.ResolveType(metadataToken);
operand = new TypeOperand(opcode.OperandType, tokenRef);
} catch (Exception) {
operand = new TypeOperand(opcode.OperandType, null);
}
break;
}
case OperandType.InlineType:
{
var metadataToken = Read <int>(data, ref offset);
try {
var tokenRef = methodInfo.Module.ResolveType(metadataToken, methodInfo.DeclaringType.GetGenericArguments(), methodInfo.GetGenericArguments());
operand = new TypeOperand(opcode.OperandType, tokenRef);
} catch (Exception) {
operand = new TypeOperand(opcode.OperandType, null);
}
break;
}
case OperandType.InlineVar:
{
var variableOrdinal = Read <ushort>(data, ref offset);
operand = new VariableOperand(methodInfo.GetMethodBody().LocalVariables[variableOrdinal]);
break;
}
}
var instruction = new Instruction(opcode, operand);
if (head == null)
{
head = tail = instruction;
}
else
{
tail = tail.Next = instruction;
}
}
// Fix branch instruction targets
tail = head;
while (tail != null)
{
if (tail.Operand is BranchTargetOperand branchTargetOperand)
{
var next = tail.Next;
while (next != null && next.Offset != branchTargetOperand.BranchTarget)
{
next = next.Next;
}
branchTargetOperand.Target = next ?? throw new InvalidProgramException("Unable to resolve branch target");
}
tail = tail.Next;
}
return(head);
}
public override void Execute(EpsInterpreter interpreter)
{
var prod = new StringOperand("Shape Converter");
interpreter.OperandStack.Push(prod);
}
public StringEquals(StringOperand operand0, StringOperand operand1)
: base(operand0, operand1)
{
}
public StringNotEqualTo(StringOperand operand0, StringOperand operand1)
: base(operand0, operand1)
{
}
/// <summary>
/// Gets the next operand
/// </summary>
public Operand GetNextOperand()
{
var symbol = lexer.ScanNextToken(reader);
switch (symbol)
{
case LexerToken.Eof:
{
return(null);
}
case LexerToken.DscComment:
{
// We handle each comment that starts at the beginning of a
// line as a dsc comment. That enables us to handle some
// special Illustrator comments.
DscCommentOperand dscOp = new DscCommentOperand();
dscOp.LineNumber = reader.LineNumber;
dscOp.Name = lexer.StringToken;
if (!reader.IsAtEndOfLine)
{
// The number and types and syntax of the parameters depend
// on the dsc comment and vary pretty much. That's why we
// cannot scan and parse the parameters here. Just pass the
// pure rest of the line to the dsc comment, it needs to do
// the rest :-(
var restOfLine = reader.ReadLine();
dscOp.Parameters = restOfLine.Trim();
}
return(dscOp);
}
case LexerToken.Integer:
{
IntegerOperand n = new IntegerOperand();
n.LineNumber = reader.LineNumber;
n.Value = lexer.IntegerToken;
return(n);
}
case LexerToken.Real:
{
RealOperand r = new RealOperand();
r.LineNumber = reader.LineNumber;
r.Value = lexer.RealToken;
return(r);
}
case LexerToken.String:
{
var s = new StringOperand();
s.LineNumber = reader.LineNumber;
s.Value = lexer.StringToken;
s.Type = StringType.Standard;
return(s);
}
case LexerToken.HexString:
{
var s = new StringOperand();
s.LineNumber = reader.LineNumber;
s.Value = lexer.StringToken;
s.Type = StringType.Hex;
return(s);
}
case LexerToken.AsciiBase85String:
{
var s = new StringOperand();
s.LineNumber = reader.LineNumber;
s.Value = lexer.StringToken;
s.Type = StringType.AsciiBase85;
return(s);
}
case LexerToken.Name:
{
NameOperand name = new NameOperand();
name.LineNumber = reader.LineNumber;
name.Value = lexer.StringToken;
return(name);
}
case LexerToken.Operator:
{
var op = new OperatorOperand();
op.LineNumber = reader.LineNumber;
op.Name = lexer.StringToken;
return(op);
}
case LexerToken.ImmediateOperator:
{
var op = new ImmediateOperand();
op.LineNumber = reader.LineNumber;
op.Name = lexer.StringToken;
return(op);
}
case LexerToken.BeginDictionary:
{
var op = new MarkOperand();
op.LineNumber = reader.LineNumber;
return(op);
}
case LexerToken.EndDictionary:
{
var op = new EndDictionaryOperand();
op.LineNumber = reader.LineNumber;
return(op);
}
case LexerToken.BeginArray:
{
var op = new MarkOperand();
op.LineNumber = reader.LineNumber;
return(op);
}
case LexerToken.EndArray:
{
var op = new EndArrayOperand();
op.LineNumber = reader.LineNumber;
return(op);
}
case LexerToken.BeginProcedure:
{
var op = new BeginProcedureOperand();
op.LineNumber = reader.LineNumber;
return(op);
}
case LexerToken.EndProcedure:
{
var op = new EndProcedureOperand();
op.LineNumber = reader.LineNumber;
return(op);
}
default:
throw new Exception("unhandled token");
}
}
/// <summary>
/// Decodes relative samples given in a string operand
/// </summary>
/// <param name="stringOperand"></param>
/// <returns>list of doubles in range 0..1</returns>
public static List <double> Decode(StringOperand stringOperand, int bitsPerSample)
{
var bytes = GetBytes(stringOperand);
return(ConvertToSamples(bytes, bitsPerSample));
}
public override void Execute(EpsInterpreter interpreter)
{
var str = new StringOperand("1.0");
interpreter.OperandStack.Push(str);
}
/// <summary>
/// instance string methods could bomb due to null, so we just wrap these
/// </summary>
/// <remarks>unfortunately this must remain public for the codedom dispatch</remarks>
public static bool StringFunction(string a, string b, StringOperand operand)
{
// a is null ?
if (operand == StringOperand.Equals && a == null && b == null) return true;
if (null == a) return false;
if (operand == StringOperand.Equals)
return a == b;
if (operand == StringOperand.DoesNotEqual)
return a != b;
if (null == b) return false;
if (operand == StringOperand.StartsWith)
return a.StartsWith(b);
if (operand == StringOperand.DoesNotStartWith)
return !a.StartsWith(b);
if (operand == StringOperand.Contains)
return a.Contains(b);
if (operand == StringOperand.DoesNotContain)
return !a.Contains(b);
if (operand == StringOperand.EndsWith)
return a.EndsWith(b);
if (operand == StringOperand.DoesNotEndWith)
return !a.EndsWith(b);
throw new ArgumentException("operand " + operand + " not mapped");
}
public BringPCDrinkConsequenceNode(GameObject actor, StringOperand stringOperand)
: base(actor, true)
{
this.stringOperand = stringOperand;
}
