in modules/asc/src/java/macromedia/abc/ConstantPool.java [776:1023]
private final void decodeOnDemand(final int poolIndex, final int kind, final int j, final int j2)
{
ConstantPool pool = pools[poolIndex];
ByteArrayPool baPool = null;
BytecodeBuffer poolIn = null;
int[] positions = null;
int length = 0, endPos = 0;
if (kind == cp_int)
{
positions = pool.intpositions;
length = positions.length;
endPos = pool.intEnd;
baPool = intP;
poolIn = pool.in;
}
else if (kind == cp_uint)
{
positions = pool.uintpositions;
length = positions.length;
endPos = pool.uintEnd;
baPool = uintP;
poolIn = pool.in;
}
else if (kind == cp_double)
{
positions = pool.doublepositions;
length = positions.length;
endPos = pool.doubleEnd;
baPool = doubleP;
poolIn = pool.in;
}
else if (kind == cp_decimal)
{
assert(hasDecimal);
positions = pool.decimalpositions;
length = positions.length;
endPos = pool.decimalEnd;
baPool = decimalP;
poolIn = pool.in;
}
else if (kind == cp_string)
{
positions = pool.strpositions;
length = positions.length;
endPos = pool.strEnd;
baPool = stringP;
poolIn = pool.in;
}
else if (kind == cp_ns)
{
positions = pool.nspositions;
length = positions.length;
endPos = pool.nsEnd;
baPool = nsP;
poolIn = pool.in;
}
else if (kind == cp_nsset)
{
positions = pool.nsspositions;
length = positions.length;
endPos = pool.nssEnd;
baPool = nssP;
poolIn = pool.in;
}
else if (kind == cp_mn)
{
positions = pool.mnpositions;
length = positions.length;
endPos = pool.mnEnd;
baPool = mnP;
poolIn = pool.in;
}
int start = positions[j];
int end = (j != length - 1) ? positions[j + 1] : endPos;
if (kind == cp_ns)
{
int pos = positions[j];
int originalPos = poolIn.pos();
poolIn.seek(pos);
start = in_ns.size();
int nsKind = poolIn.readU8();
in_ns.writeU8(nsKind);
switch (nsKind)
{
case CONSTANT_PrivateNamespace:
if( this.disableDebuggingInfo )
{
in_ns.writeU32(0); // name not important for private namespace
break;
}
// else fall through and treat like a normal namespace
case CONSTANT_Namespace:
case CONSTANT_PackageNamespace:
case CONSTANT_PackageInternalNs:
case CONSTANT_ProtectedNamespace:
case CONSTANT_ExplicitNamespace:
case CONSTANT_StaticProtectedNs:
int index = poolIn.readU32();
int newIndex = getIndex(poolIndex, cp_string, index);
in_ns.writeU32(newIndex);
break;
default:
assert false; // can't possibly happen...
}
poolIn.seek(originalPos);
end = in_ns.size();
poolIn = in_ns;
}
else if (kind == cp_nsset)
{
int pos = positions[j];
int originalPos = poolIn.pos();
poolIn.seek(pos);
start = in_nsset.size();
/*
nss.clear();
int count = (int) poolIn.readU32();
for (int k = 0; k < count; k++)
{
nss.add((int) poolIn.readU32());
}
count = nss.size();
in5.writeU32(count);
for (Iterator<Integer> k = nss.iterator(); k.hasNext();)
{
int index = k.next();
int newIndex = getIndex(poolIndex, 4, index);
in_nsset.writeU32(newIndex);
}
*/
int count = poolIn.readU32();
in_nsset.writeU32(count);
for (int k = 0; k < count; k++)
{
int index = poolIn.readU32();
int newIndex = getIndex(poolIndex, cp_ns, index);
in_nsset.writeU32(newIndex);
}
poolIn.seek(originalPos);
end = in_nsset.size();
poolIn = in_nsset;
}
else if (kind == cp_mn)
{
int pos = positions[j];
int originalPos = poolIn.pos();
poolIn.seek(pos);
start = in_mn.size();
int constKind = poolIn.readU8();
if( !(constKind==CONSTANT_TypeName))
in_mn.writeU8(constKind);
switch (constKind)
{
case CONSTANT_Qname:
case CONSTANT_QnameA:
{
int namespaceIndex = poolIn.readU32();
int newNamespaceIndex = getIndex(poolIndex, cp_ns, namespaceIndex);
in_mn.writeU32(newNamespaceIndex);
int nameIndex = poolIn.readU32();
int newNameIndex = getIndex(poolIndex, cp_string, nameIndex);
in_mn.writeU32(newNameIndex);
break;
}
case CONSTANT_Multiname:
case CONSTANT_MultinameA:
{
int nameIndex = poolIn.readU32();
int newNameIndex = getIndex(poolIndex, cp_string, nameIndex);
in_mn.writeU32(newNameIndex);
int namespace_set = poolIn.readU32();
int newNamespace_set = getIndex(poolIndex, cp_nsset, namespace_set);
in_mn.writeU32(newNamespace_set);
break;
}
case CONSTANT_RTQname:
case CONSTANT_RTQnameA:
{
int index = poolIn.readU32();
int newIndex = getIndex(poolIndex, cp_string, index);
in_mn.writeU32(newIndex);
break;
}
case CONSTANT_RTQnameL:
case CONSTANT_RTQnameLA:
break;
case CONSTANT_MultinameL:
case CONSTANT_MultinameLA:
{
int namespace_set = poolIn.readU32();
int newNamespace_set = getIndex(poolIndex, cp_nsset, namespace_set);
in_mn.writeU32(newNamespace_set);
break;
}
case CONSTANT_TypeName:
{
int nameIndex = poolIn.readU32();
int newNameIndex = getIndex(poolIndex, cp_mn, nameIndex);
int count = poolIn.readU32();
IntList newParams = new IntList();
for( int i = 0; i<count;++i) {
newParams.add(getIndex(poolIndex, cp_mn, poolIn.readU32()));
}
start = in_mn.size();
in_mn.writeU8(constKind);
in_mn.writeU32(newNameIndex);
in_mn.writeU32(count);
for( int i =0; i < count; ++i ) {
in_mn.writeU32(newParams.at(i));
}
break;
}
default:
assert false; // can't possibly happen...
}
poolIn.seek(originalPos);
end = in_mn.size();
poolIn = in_mn;
}
int newIndex = baPool.contains(poolIn, start, end);
if (newIndex == -1)
{
newIndex = baPool.store(poolIn, start, end);
}
else
{
duplicate++;
duplicateBytes += (end - start);
}
total++;
totalBytes += (end - start);
if (j != 0)
{
map[j2] = newIndex;
}
}