public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var operand2 = operandStack.Pop();
var operand1 = operandStack.Pop();
var integer1 = operand1 as IntegerOperand;
var integer2 = operand2 as IntegerOperand;
if (integer1 != null && integer2 != null)
{
var res = new IntegerOperand();
res.Value = integer1.Value * integer2.Value;
operandStack.Push(res);
}
else
{
var double1 = OperandHelper.GetRealValue(operand1);
var double2 = OperandHelper.GetRealValue(operand2);
var res = new RealOperand();
res.Value = double1 * double2;
operandStack.Push(res);
}
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var operand1 = operandStack.Pop();
var operand2 = operandStack.Pop();
switch (operand1)
{
case BooleanOperand boolOperand1:
{
var boolOperand2 = (BooleanOperand)operand2;
var boolean = new BooleanOperand(boolOperand1.Value || boolOperand2.Value);
operandStack.Push(boolean);
break;
}
case IntegerOperand intOperand1:
{
var intOperand2 = (IntegerOperand)operand2;
var boolean = new IntegerOperand(intOperand1.Value | intOperand2.Value);
operandStack.Push(boolean);
break;
}
default:
throw new Exception("illegal operator");
}
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var operand = operandStack.Pop();
int ret;
switch (operand)
{
case StringOperand stringOperand:
{
ret = int.Parse(stringOperand.Value, CultureInfo.InvariantCulture);
break;
}
case IntegerOperand intOperand:
{
ret = intOperand.Value;
break;
}
case RealOperand realOperand:
{
ret = (int)Math.Round(realOperand.Value);
break;
}
default:
throw new Exception("illegal operator");
}
var real = new IntegerOperand(ret);
operandStack.Push(real);
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var count = new IntegerOperand {
Value = operandStack.Count
};
operandStack.Push(count);
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var dict = (DictionaryOperand)operandStack.Pop();
// there is no limit in the size of the dictionary
// return any number bigger than the current size
var counter = dict.Dictionary.Count * 2;
var count = new IntegerOperand(counter);
operandStack.Push(count);
}
public override void Execute(EpsInterpreter interpreter)
{
var dict = new EpsDictionary();
var name = new NameOperand {
Value = "MaxPatternCache"
};
var someValue = new IntegerOperand {
Value = 42
};
dict.Add(name, someValue);
interpreter.OperandStack.Push(new DictionaryOperand(dict));
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var operand2 = operandStack.Pop();
var operand1 = operandStack.Pop();
var integer1 = (IntegerOperand)operand1;
var integer2 = (IntegerOperand)operand2;
var res = new IntegerOperand();
res.Value = integer1.Value % integer2.Value;
operandStack.Push(res);
}
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 operand = operandStack.Pop();
if (operand is IntegerOperand integer)
{
var res = new IntegerOperand();
res.Value = -integer.Value;
operandStack.Push(res);
}
else
{
var real = (RealOperand)operand;
var res = new RealOperand();
res.Value = -real.Value;
operandStack.Push(res);
}
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var shiftVal = operandStack.PopIntegerValue();
var intVal = operandStack.PopIntegerValue();
var res = new IntegerOperand();
if (shiftVal >= 0)
{
res.Value = intVal << shiftVal;
}
else
{
res.Value = intVal >> shiftVal;
}
operandStack.Push(res);
}
public override void Execute(EpsInterpreter interpreter)
{
int counter = 0;
var operandStack = interpreter.OperandStack;
for (int i = operandStack.Count - 1; i >= 0; i--)
{
var mark = operandStack[i];
if (mark is MarkOperand)
{
var count = new IntegerOperand(counter);
operandStack.Push(count);
return;
}
counter++;
}
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var operand = operandStack.Pop();
int count = 0;
switch (operand)
{
case DictionaryOperand dictionaryOperand:
{
count = dictionaryOperand.Dictionary.Count;
break;
}
case ArrayOperand arrayOperand:
{
count = arrayOperand.Values.Count;
break;
}
case NameOperand nameOperand:
{
count = nameOperand.Value.Length;
break;
}
case StringOperand stringOperand:
{
count = stringOperand.Length;
break;
}
}
var countOp = new IntegerOperand(count);
operandStack.Push(countOp);
}
/// <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");
}
}
