/*
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package flash.swf;
import flash.swf.actions.Branch;
import flash.swf.actions.ConstantPool;
import flash.swf.actions.DefineFunction;
import flash.swf.actions.GetURL;
import flash.swf.actions.GetURL2;
import flash.swf.actions.GotoFrame;
import flash.swf.actions.GotoFrame2;
import flash.swf.actions.GotoLabel;
import flash.swf.actions.Label;
import flash.swf.actions.Push;
import flash.swf.actions.SetTarget;
import flash.swf.actions.StoreRegister;
import flash.swf.actions.StrictMode;
import flash.swf.actions.Try;
import flash.swf.actions.Unknown;
import flash.swf.actions.WaitForFrame;
import flash.swf.actions.With;
import flash.swf.debug.LineRecord;
import flash.swf.debug.RegisterRecord;
import flash.swf.types.ActionList;
import flash.swf.types.ClipActionRecord;
import flash.swf.types.ClipActions;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
/**
* AS2 encoder.
*/
public class ActionEncoder extends ActionHandler
{
private SwfEncoder writer;
private DebugEncoder debug;
// map label -> position
private HashMap<Label, LabelEntry> labels;
private ArrayList<UpdateEntry> updates;
private int actionCount;
public ActionEncoder(SwfEncoder writer, DebugEncoder debug)
{
this.writer = writer;
this.debug = debug;
labels = new HashMap<Label, LabelEntry>();
updates = new ArrayList<UpdateEntry>();
}
private static class UpdateEntry
{
int anchor; // location to subtract to compute delta
int updatePos; // byte offset to update with delta value
Action source;
public UpdateEntry(int anchor, int updatePos, Action source)
{
this.anchor = anchor;
this.updatePos = updatePos;
this.source = source;
}
}
private static class LabelEntry
{
int offset; // byte offset in swf file
int count; // action ordinal number (Nth action in current block)
public LabelEntry(int offset, int count)
{
this.count = count;
this.offset = offset;
}
}
private int getLabelOffset(Label label)
{
assert (labels.containsKey(label)) : ("missing label");
return labels.get(label).offset;
}
private int getLabelCount(Label label)
{
assert (labels.containsKey(label)) : ("missing label");
return labels.get(label).count;
}
public void encode(ActionList actionList)
{
// write the actions
for (int i=0; i < actionList.size(); i++)
{
Action a = actionList.getAction(i);
switch (a.code)
{
// don't update actionCount for synthetic opcodes
case ActionList.sactionLabel:
a.visit(this);
break;
case ActionList.sactionLineRecord:
if (debug != null)
debug.offset(writer.getPos(), (LineRecord)a);
break;
case ActionList.sactionRegisterRecord:
if (debug != null)
debug.registers(writer.getPos(), (RegisterRecord)a);
break;
// the remaining types need counting
case ActionConstants.sactionPush:
i = encodePush((Push)a, i, actionList);
actionCount++;
break;
default:
if (a.code < 0x80)
writer.writeUI8(a.code);
else
a.visit(this);
actionCount++;
break;
}
}
patchForwardBranches();
}
private void patchForwardBranches()
{
// now patch forward branches
for (Iterator<UpdateEntry> i = updates.iterator(); i.hasNext();)
{
UpdateEntry entry = i.next();
switch (entry.source.code)
{
case ActionConstants.sactionIf:
case ActionConstants.sactionJump:
int target = getLabelOffset(((Branch)entry.source).target);
writer.writeSI16at(entry.updatePos, target - entry.anchor);
break;
case ActionConstants.sactionWith:
int endWith = getLabelOffset(((With)entry.source).endWith);
writer.writeUI16at(entry.updatePos, endWith - entry.anchor);
break;
case ActionConstants.sactionWaitForFrame:
case ActionConstants.sactionWaitForFrame2:
int skipTarget = getLabelCount(((WaitForFrame)entry.source).skipTarget);
writer.writeUI8at(entry.updatePos, skipTarget - entry.anchor);
break;
case ActionConstants.sactionTry:
Try t = (Try) entry.source;
int endTry = getLabelOffset(t.endTry);
writer.writeUI16at(entry.updatePos, endTry - entry.anchor);
entry.anchor = endTry;
if (t.hasCatch())
{
int endCatch = getLabelOffset(t.endCatch);
writer.writeUI16at(entry.updatePos+2, endCatch - entry.anchor);
entry.anchor = endCatch;
}
if (t.hasFinally())
{
int endFinally = getLabelOffset(t.endFinally);
writer.writeUI16at(entry.updatePos+4, endFinally - entry.anchor);
}
break;
default:
assert false : ("invalid action in UpdateEntry");
}
}
}
// public void inlineBinaryOp(InlineBinaryOp op)
// {
// writer.writeU8(op.code);
// writer.writeU8(op.dst);
// encodeOperand(op.lhs, op.rhs);
// }
// private void encodeOperand(Object lhs, Object rhs)
// {
// int lhsType = operandType(lhs);
// int rhsType = operandType(rhs);
// writer.writeU8(lhsType >> 4 | rhsType);
// encodeOperand(lhsType, lhs);
// encodeOperand(rhsType, rhs);
// }
//
// private void encodeOperand(Object operand)
// {
// int type = operandType(operand);
// writer.writeU8(type);
// encodeOperand(type, operand);
// }
//
// public void inlineBranchWhenFalse(InlineBranchWhenFalse op)
// {
// writer.writeU8(op.code);
// int pos = writer.getPos();
// writer.writeU8(op.cond);
// encodeOperand(op.lhs, op.rhs);
// Integer offset = (Integer) labels.get(op.target);
// if (offset != null)
// {
// // label came earlier
// writer.writeU16(offset.intValue() - pos - 2);
// }
// else
// {
// // label comes later. don't know the offset yet.
// updates.add(new UpdateEntry(pos+2, pos, op));
// writer.writeU16(0);
// }
// }
// public void inlineGetMember(InlineGetMember op)
// {
// writer.writeU8(op.code);
// writer.writeU8(op.dst);
// writer.writeU8(op.src);
// encodeOperand(op.member);
// }
//
// public void inlineSetMember(InlineSetMember op)
// {
// writer.writeU8(op.code);
// writer.writeU8(op.dst);
// encodeOperand(op.member, op.src);
// }
// public void inlineSetRegister(InlineSetRegister op)
// {
// writer.writeU8(op.code);
// writer.writeU8(op.dst);
// encodeOperand(op.value);
// }
//
// public void inlineUnaryRegOp(InlineUnaryRegOp op)
// {
// writer.writeU8(op.code);
// writer.writeU8(op.register);
// }
// private void encodeOperand(int opType, Object operand)
// {
// switch (opType)
// {
// case ActionConstants.kInlineTrue:
// case ActionConstants.kInlineFalse:
// case ActionConstants.kInlineNull:
// case ActionConstants.kInlineUndefined:
// // do nothing, type implies value
// break;
// case ActionConstants.kInlineConstantByte:
// case ActionConstants.kInlineChar:
// case ActionConstants.kInlineRegister:
// int i = ((Number)operand).intValue();
// writer.writeU8(i);
// break;
// case ActionConstants.kInlineConstantWord:
// case ActionConstants.kInlineShort:
// i = ((Number)operand).intValue();
// writer.writeU16(i);
// break;
// case ActionConstants.kInlineLong:
// i = ((Number)operand).intValue();
// writer.write32(i);
// break;
// case ActionConstants.kInlineDouble:
// long num = Double.doubleToLongBits(((Number)operand).doubleValue());
// writer.write32((int)(num>>32));
// writer.write32((int)num);
// break;
// }
// }
// private int operandType(Object operand)
// {
// if (operand == Boolean.TRUE)
// return ActionConstants.kInlineTrue;
// else if (operand == Boolean.FALSE)
// return ActionConstants.kInlineFalse;
// else if (operand == ActionFactory.UNDEFINED)
// return ActionConstants.kInlineUndefined;
// else if (operand == ActionFactory.STACKTOP)
// return ActionConstants.kInlineStack;
// else if (operand == null)
// return ActionConstants.kInlineNull;
// else if (operand instanceof Short)
// return ((Short)operand).intValue() < 256 ? ActionConstants.kInlineConstantByte : ActionConstants.kInlineConstantWord;
// else if (operand instanceof Double)
// return ActionConstants.kInlineDouble;
// else if (operand instanceof Integer)
// return (((Integer)operand).intValue() & ~0xFF) == 0 ? ActionConstants.kInlineChar :
// (((Integer)operand).intValue() & ~0xFFFF) == 0 ? ActionConstants.kInlineShort :
// ActionConstants.kInlineLong;
// else if (operand instanceof Byte)
// return ActionConstants.kInlineRegister;
// else
// throw new IllegalArgumentException("unknown operand type " + operand.getClass().getName());
// }
public void call(Action action)
{
writer.writeUI8(action.code);
// this action's opcode 0x9E has hi bit set, but it never has data. considered a permanent minor bug.
writer.writeUI16(0);
}
public void constantPool(ConstantPool action)
{
int updatePos = encodeActionHeader(action);
writer.writeUI16(action.pool.length);
for (int i = 0; i < action.pool.length; i++)
{
writer.writeString(action.pool[i]);
}
updateActionHeader(updatePos);
}
private void updateActionHeader(int updatePos)
{
int length = (writer.getPos()-updatePos)-2;
if (length >= 0x10000)
{
assert false : ("action length ("+length+") exceeds 64K");
}
writer.writeUI16at(updatePos, length);
}
private int encodeActionHeader(Action action)
{
writer.writeUI8(action.code);
int updatePos = writer.getPos();
writer.writeUI16(0);
return updatePos;
}
public void defineFunction(DefineFunction action)
{
int updatePos = encodeActionHeader(action);
writer.writeString(action.name);
writer.writeUI16(action.params.length);
for (int i = 0; i < action.params.length; i++)
{
writer.writeString(action.params[i]);
}
int pos = writer.getPos();
writer.writeUI16(0); // codesize placeholder
updateActionHeader(updatePos);
new ActionEncoder(writer, debug).encode(action.actionList);
writer.writeUI16at(pos, (writer.getPos()-pos)-2);
}
public void defineFunction2(DefineFunction action)
{
int updatePos = encodeActionHeader(action);
writer.writeString(action.name);
writer.writeUI16(action.params.length);
writer.writeUI8(action.regCount);
writer.writeUI16(action.flags);
for (int i = 0; i < action.params.length; i++)
{
writer.writeUI8(action.paramReg[i]);
writer.writeString(action.params[i]);
}
int pos = writer.getPos();
writer.writeUI16(0); // placeholder
updateActionHeader(updatePos);
new ActionEncoder(writer, debug).encode(action.actionList);
writer.writeUI16at(pos, (writer.getPos()-pos)-2);
}
public void getURL(GetURL action)
{
int updatePos = encodeActionHeader(action);
writer.writeString(action.url);
writer.writeString(action.target);
updateActionHeader(updatePos);
}
public void getURL2(GetURL2 action)
{
int updatePos = encodeActionHeader(action);
writer.writeUI8(action.method);
updateActionHeader(updatePos);
}
public void gotoFrame(GotoFrame action)
{
int updatePos = encodeActionHeader(action);
writer.writeUI16(action.frame);
updateActionHeader(updatePos);
}
public void gotoFrame2(GotoFrame2 action)
{
int updatePos = encodeActionHeader(action);
writer.writeUI8(action.playFlag);
updateActionHeader(updatePos);
}
public void gotoLabel(GotoLabel action)
{
int updatePos = encodeActionHeader(action);
writer.writeString(action.label);
updateActionHeader(updatePos);
}
public void ifAction(Branch action)
{
encodeBranch(action);
}
public void jump(Branch action)
{
encodeBranch(action);
}
private void encodeBranch(Branch branch)
{
writer.writeUI8(branch.code);
writer.writeUI16(2);
int pos = writer.getPos();
if (labels.containsKey(branch.target))
{
// label came earlier
writer.writeSI16(getLabelOffset(branch.target) - pos - 2);
}
else
{
// label comes later. don't know the offset yet.
updates.add(new UpdateEntry(pos+2, pos, branch));
writer.writeSI16(0);
}
}
public void with(With action)
{
writer.writeUI8(action.code);
writer.writeUI16(2);
// label comes later, don't know offset yet
int pos = writer.getPos();
updates.add(new UpdateEntry(pos+2, pos, action));
writer.writeUI16(0);
}
public void waitForFrame(WaitForFrame action)
{
writer.writeUI8(action.code);
writer.writeUI16(3);
writer.writeUI16(action.frame);
int pos = writer.getPos();
updates.add(new UpdateEntry(actionCount+1, pos, action));
writer.writeUI8(0);
}
public void waitForFrame2(WaitForFrame action)
{
writer.writeUI8(action.code);
writer.writeUI16(1);
int pos = writer.getPos();
updates.add(new UpdateEntry(actionCount+1, pos, action));
writer.writeUI8(0);
}
public void label(Label label)
{
assert (!labels.containsKey(label)) : ("found duplicate label");
int labelPos = writer.getPos();
labels.put(label, new LabelEntry(labelPos, actionCount));
}
/**
* encode a run of push actions into one action record. The player
* supports this compact encoding since push is such a common
* opcode. the format is:
*
* sactionPush type1 value1 type2 value2 ...
*
* @param push
* @param j the index of the starting push action
* @param actions
* @return the index of the last push action encoded. the next action will
* not be a push action.
*/
public int encodePush(Push push, int j, ActionList actions)
{
int updatePos = encodeActionHeader(push);
do
{
Object value = push.value;
int type = Push.getTypeCode(value);
writer.writeUI8(type);
switch (type)
{
case 0: // string
writer.writeString(value.toString());
break;
case 1: // float
int bits = Float.floatToIntBits(((Float) value).floatValue());
writer.write32(bits);
break;
case 2: // null
break;
case 3: // undefined
break;
case 4: // register
writer.writeUI8(((Byte) value).intValue() & 0xFF);
break;
case 5: // boolean
writer.writeUI8(((Boolean) value).booleanValue() ? 1 : 0);
break;
case 6: // double
double d = ((Double) value).doubleValue();
long num = Double.doubleToLongBits(d);
writer.write32((int)(num>>32));
writer.write32((int)num);
break;
case 7: // integer
writer.write32(((Integer) value).intValue());
break;
case 8: // const8
writer.writeUI8(((Short) value).intValue());
break;
case 9: // const16
writer.writeUI16(((Short) value).intValue() & 0xFFFF);
break;
}
if (debug == null)
{
// ignore line records if we aren't debugging
while (j+1 < actions.size() && actions.getAction(j+1).code == ActionList.sactionLineRecord)
j++;
}
Action a;
if (++j < actions.size()
&& (a=actions.getAction(j)).code == ActionConstants.sactionPush)
{
push = (Push) a;
}
else
{
push = null;
}
}
while (push != null);
updateActionHeader(updatePos);
return j-1;
}
public void setTarget(SetTarget action)
{
int updatePos = encodeActionHeader(action);
writer.writeString(action.targetName);
updateActionHeader(updatePos);
}
public void storeRegister(StoreRegister action)
{
int updatePos = encodeActionHeader(action);
writer.writeUI8(action.register);
updateActionHeader(updatePos);
}
public void strictMode(StrictMode action)
{
int updatePos = encodeActionHeader(action);
writer.writeUI8(action.mode ? 1 : 0);
updateActionHeader(updatePos);
}
public void tryAction(Try a)
{
int updatePos = encodeActionHeader(a);
writer.writeUI8(a.flags);
int trySizePos = writer.getPos();
writer.writeUI16(0); // try size
writer.writeUI16(0); // catch size
writer.writeUI16(0); // finally size
if (a.hasRegister())
writer.writeUI8(a.catchReg);
else
writer.writeString(a.catchName);
// we have emitted the try action, what follows is label mgmt
updateActionHeader(updatePos);
int tryStart = writer.getPos();
updates.add(new UpdateEntry(tryStart, trySizePos, a));
}
public void unknown(Unknown action)
{
int updatePos = encodeActionHeader(action);
writer.write(action.data);
updateActionHeader(updatePos);
}
public void encodeClipActions(ClipActions clipActions)
{
writer.writeUI16(0);
encodeClipEventFlags(clipActions.allEventFlags, writer);
Iterator it = clipActions.clipActionRecords.iterator();
while (it.hasNext())
{
ClipActionRecord r = (ClipActionRecord) it.next();
encodeClipActionRecord(r);
}
if (writer.swfVersion >= 6)
writer.write32(0);
else
writer.writeUI16(0);
}
private void encodeClipActionRecord(ClipActionRecord r)
{
encodeClipEventFlags(r.eventFlags, writer);
int pos = writer.getPos();
writer.write32(0); // offset placeholder
if ((r.eventFlags & ClipActionRecord.keyPress) != 0)
{
writer.writeUI8(r.keyCode);
}
encode(r.actionList);
writer.write32at(pos, (writer.getPos()-pos)-4);
}
private void encodeClipEventFlags(int flags, SwfEncoder w)
{
if (w.swfVersion >= 6)
w.write32(flags);
else
w.writeUI16(flags);
}
}