This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-compress.git
The following commit(s) were added to refs/heads/master by this push:
new fc821091 Camel case local names
fc821091 is described below
commit fc82109124a22a95793c10b8acaa2eaf4cb96cb5
Author: Gary Gregory <[email protected]>
AuthorDate: Mon Jan 16 08:05:00 2023 -0500
Camel case local names
---
.../commons/compress/archivers/cpio/CpioUtil.java | 16 ++---
.../harmony/unpack200/MetadataBandGroup.java | 6 +-
.../harmony/unpack200/NewAttributeBands.java | 32 +++++-----
.../compress/harmony/unpack200/Segment.java | 30 +++++-----
.../bytecode/AnnotationDefaultAttribute.java | 16 ++---
.../unpack200/bytecode/AnnotationsAttribute.java | 64 ++++++++++----------
.../bytecode/EnclosingMethodAttribute.java | 18 +++---
.../unpack200/bytecode/ExceptionTableEntry.java | 4 +-
.../unpack200/bytecode/InnerClassesAttribute.java | 54 ++++++++---------
.../bytecode/LineNumberTableAttribute.java | 31 +++++-----
.../bytecode/LocalVariableTableAttribute.java | 68 +++++++++++-----------
.../bytecode/LocalVariableTypeTableAttribute.java | 68 +++++++++++-----------
...timeVisibleorInvisibleAnnotationsAttribute.java | 12 ++--
...leorInvisibleParameterAnnotationsAttribute.java | 36 ++++++------
.../unpack200/bytecode/SignatureAttribute.java | 6 +-
.../unpack200/bytecode/forms/LookupSwitchForm.java | 30 +++++-----
.../unpack200/bytecode/forms/TableSwitchForm.java | 26 ++++-----
17 files changed, 259 insertions(+), 258 deletions(-)
diff --git
a/src/main/java/org/apache/commons/compress/archivers/cpio/CpioUtil.java
b/src/main/java/org/apache/commons/compress/archivers/cpio/CpioUtil.java
index 2468fc84..1eb7bf63 100644
--- a/src/main/java/org/apache/commons/compress/archivers/cpio/CpioUtil.java
+++ b/src/main/java/org/apache/commons/compress/archivers/cpio/CpioUtil.java
@@ -45,21 +45,21 @@ class CpioUtil {
long ret;
int pos = 0;
- final byte[] tmp_number = Arrays.copyOf(number, number.length);
+ final byte[] tmpNumber = Arrays.copyOf(number, number.length);
if (!swapHalfWord) {
byte tmp = 0;
- for (pos = 0; pos < tmp_number.length; pos++) {
- tmp = tmp_number[pos];
- tmp_number[pos++] = tmp_number[pos];
- tmp_number[pos] = tmp;
+ for (pos = 0; pos < tmpNumber.length; pos++) {
+ tmp = tmpNumber[pos];
+ tmpNumber[pos++] = tmpNumber[pos];
+ tmpNumber[pos] = tmp;
}
}
- ret = tmp_number[0] & 0xFF;
- for (pos = 1; pos < tmp_number.length; pos++) {
+ ret = tmpNumber[0] & 0xFF;
+ for (pos = 1; pos < tmpNumber.length; pos++) {
ret <<= 8;
- ret |= tmp_number[pos] & 0xFF;
+ ret |= tmpNumber[pos] & 0xFF;
}
return ret;
}
diff --git
a/src/main/java/org/apache/commons/compress/harmony/unpack200/MetadataBandGroup.java
b/src/main/java/org/apache/commons/compress/harmony/unpack200/MetadataBandGroup.java
index a77efd92..407a9ff5 100644
---
a/src/main/java/org/apache/commons/compress/harmony/unpack200/MetadataBandGroup.java
+++
b/src/main/java/org/apache/commons/compress/harmony/unpack200/MetadataBandGroup.java
@@ -219,16 +219,16 @@ public class MetadataBandGroup {
}
private Attribute getParameterAttribute(final int numParameters, final
Iterator<CPUTF8> namesIterator) {
- final ParameterAnnotation[] parameter_annotations = new
ParameterAnnotation[numParameters];
+ final ParameterAnnotation[] parameterAnnotations = new
ParameterAnnotation[numParameters];
for (int i = 0; i < numParameters; i++) {
final int numAnnotations = anno_N[anno_N_Index++];
final int[] pairCounts = pair_N[pair_N_Index++];
final Annotation[] annotations = new Annotation[numAnnotations];
Arrays.setAll(annotations, j -> getAnnotation(type_RS[anno_N_Index
- 1][j], pairCounts[j], namesIterator));
- parameter_annotations[i] = new ParameterAnnotation(annotations);
+ parameterAnnotations[i] = new ParameterAnnotation(annotations);
}
return new
RuntimeVisibleorInvisibleParameterAnnotationsAttribute(type.equals("RVPA") ?
rvpaUTF8 : ripaUTF8,
- parameter_annotations);
+ parameterAnnotations);
}
}
\ No newline at end of file
diff --git
a/src/main/java/org/apache/commons/compress/harmony/unpack200/NewAttributeBands.java
b/src/main/java/org/apache/commons/compress/harmony/unpack200/NewAttributeBands.java
index 45dfb602..d913a21b 100644
---
a/src/main/java/org/apache/commons/compress/harmony/unpack200/NewAttributeBands.java
+++
b/src/main/java/org/apache/commons/compress/harmony/unpack200/NewAttributeBands.java
@@ -220,16 +220,16 @@ public class NewAttributeBands extends BandSet {
// Don't add V's - they shouldn't be written out to the class
// file
} else if (tag.startsWith("PO")) {
- final char uint_type = tag.substring(2).toCharArray()[0];
- final int length = getLength(uint_type);
+ final char uintType = tag.substring(2).toCharArray()[0];
+ final int length = getLength(uintType);
attribute.addBCOffset(length, value);
} else if (tag.startsWith("P")) {
- final char uint_type = tag.substring(1).toCharArray()[0];
- final int length = getLength(uint_type);
+ final char uintType = tag.substring(1).toCharArray()[0];
+ final int length = getLength(uintType);
attribute.addBCIndex(length, value);
} else if (tag.startsWith("OS")) {
- final char uint_type = tag.substring(2).toCharArray()[0];
- final int length = getLength(uint_type);
+ final char uintType = tag.substring(2).toCharArray()[0];
+ final int length = getLength(uintType);
switch (length) {
case 1:
value = (byte) value;
@@ -245,8 +245,8 @@ public class NewAttributeBands extends BandSet {
}
attribute.addBCLength(length, value);
} else if (tag.startsWith("O")) {
- final char uint_type = tag.substring(1).toCharArray()[0];
- final int length = getLength(uint_type);
+ final char uintType = tag.substring(1).toCharArray()[0];
+ final int length = getLength(uintType);
attribute.addBCLength(length, value);
}
}
@@ -268,9 +268,9 @@ public class NewAttributeBands extends BandSet {
private abstract static class LayoutElement implements
AttributeLayoutElement {
- protected int getLength(final char uint_type) {
+ protected int getLength(final char uintType) {
int length = 0;
- switch (uint_type) {
+ switch (uintType) {
case 'B':
length = 1;
break;
@@ -775,16 +775,16 @@ public class NewAttributeBands extends BandSet {
// Replication
case 'N':
- final char uint_type = (char) stream.read();
+ final char uintType = (char) stream.read();
stream.read(); // '['
final String str = readUpToMatchingBracket(stream);
- return new Replication("" + uint_type, str);
+ return new Replication("" + uintType, str);
// Union
case 'T':
- String int_type = "" + (char) stream.read();
- if (int_type.equals("S")) {
- int_type += (char) stream.read();
+ String intType = "" + (char) stream.read();
+ if (intType.equals("S")) {
+ intType += (char) stream.read();
}
final List<UnionCase> unionCases = new ArrayList<>();
UnionCase c;
@@ -801,7 +801,7 @@ public class NewAttributeBands extends BandSet {
stream.reset();
body = readBody(getStreamUpToMatchingBracket(stream));
}
- return new Union(int_type, unionCases, body);
+ return new Union(intType, unionCases, body);
// Call
case '(':
diff --git
a/src/main/java/org/apache/commons/compress/harmony/unpack200/Segment.java
b/src/main/java/org/apache/commons/compress/harmony/unpack200/Segment.java
index 3f29fc04..44ecb04d 100644
--- a/src/main/java/org/apache/commons/compress/harmony/unpack200/Segment.java
+++ b/src/main/java/org/apache/commons/compress/harmony/unpack200/Segment.java
@@ -221,11 +221,11 @@ public class Segment {
// add inner class attribute (if required)
boolean addInnerClassesAttr = false;
- final IcTuple[] ic_local = getClassBands().getIcLocal()[classNum];
- final boolean ic_local_sent = ic_local != null;
+ final IcTuple[] icLocal = getClassBands().getIcLocal()[classNum];
+ final boolean icLocalSent = icLocal != null;
final InnerClassesAttribute innerClassesAttribute = new
InnerClassesAttribute("InnerClasses");
- final IcTuple[] ic_relevant =
getIcBands().getRelevantIcTuples(fullName, cp);
- final List<IcTuple> ic_stored = computeIcStored(ic_local, ic_relevant);
+ final IcTuple[] icRelevant =
getIcBands().getRelevantIcTuples(fullName, cp);
+ final List<IcTuple> ic_stored = computeIcStored(icLocal, icRelevant);
for (final IcTuple icStored : ic_stored) {
final int innerClassIndex = icStored.thisClassIndex();
final int outerClassIndex = icStored.outerClassIndex();
@@ -256,13 +256,13 @@ public class Segment {
}
// If ic_local is sent and it's empty, don't add
// the inner classes attribute.
- if (ic_local_sent && (ic_local.length == 0)) {
+ if (icLocalSent && (icLocal.length == 0)) {
addInnerClassesAttr = false;
}
// If ic_local is not sent and ic_relevant is empty,
// don't add the inner class attribute.
- if (!ic_local_sent && (ic_relevant.length == 0)) {
+ if (!icLocalSent && (icRelevant.length == 0)) {
addInnerClassesAttr = false;
}
@@ -296,22 +296,22 @@ public class Segment {
/**
* Given an ic_local and an ic_relevant, use them to calculate what should
be added as ic_stored.
*
- * @param ic_local IcTuple[] array of local transmitted tuples
- * @param ic_relevant IcTuple[] array of relevant tuples
+ * @param icLocal IcTuple[] array of local transmitted tuples
+ * @param icRelevant IcTuple[] array of relevant tuples
* @return List of tuples to be stored. If ic_local is null or empty, the
values returned may not be correct. The
* caller will have to determine if this is the case.
*/
- private List<IcTuple> computeIcStored(final IcTuple[] ic_local, final
IcTuple[] ic_relevant) {
- final List<IcTuple> result = new ArrayList<>(ic_relevant.length);
- final List<IcTuple> duplicates = new ArrayList<>(ic_relevant.length);
- final Set<IcTuple> isInResult = new HashSet<>(ic_relevant.length);
+ private List<IcTuple> computeIcStored(final IcTuple[] icLocal, final
IcTuple[] icRelevant) {
+ final List<IcTuple> result = new ArrayList<>(icRelevant.length);
+ final List<IcTuple> duplicates = new ArrayList<>(icRelevant.length);
+ final Set<IcTuple> isInResult = new HashSet<>(icRelevant.length);
// need to compute:
// result = ic_local XOR ic_relevant
// add ic_local
- if (ic_local != null) {
- for (final IcTuple element : ic_local) {
+ if (icLocal != null) {
+ for (final IcTuple element : icLocal) {
if (isInResult.add(element)) {
result.add(element);
}
@@ -319,7 +319,7 @@ public class Segment {
}
// add ic_relevant
- for (final IcTuple element : ic_relevant) {
+ for (final IcTuple element : icRelevant) {
if (isInResult.add(element)) {
result.add(element);
} else {
diff --git
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/AnnotationDefaultAttribute.java
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/AnnotationDefaultAttribute.java
index b22b7ee8..a755d817 100644
---
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/AnnotationDefaultAttribute.java
+++
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/AnnotationDefaultAttribute.java
@@ -32,11 +32,11 @@ public class AnnotationDefaultAttribute extends
AnnotationsAttribute {
attributeName = cpUTF8Value;
}
- private final ElementValue element_value;
+ private final ElementValue elementValue;
- public AnnotationDefaultAttribute(final ElementValue element_value) {
+ public AnnotationDefaultAttribute(final ElementValue elementValue) {
super(attributeName);
- this.element_value = element_value;
+ this.elementValue = elementValue;
}
@Override
@@ -46,14 +46,14 @@ public class AnnotationDefaultAttribute extends
AnnotationsAttribute {
@Override
protected int getLength() {
- return element_value.getLength();
+ return elementValue.getLength();
}
@Override
protected ClassFileEntry[] getNestedClassFileEntries() {
final List<Object> nested = new ArrayList<>();
nested.add(attributeName);
- nested.addAll(element_value.getClassFileEntries());
+ nested.addAll(elementValue.getClassFileEntries());
final ClassFileEntry[] nestedEntries = new
ClassFileEntry[nested.size()];
for (int i = 0; i < nestedEntries.length; i++) {
nestedEntries[i] = (ClassFileEntry) nested.get(i);
@@ -64,17 +64,17 @@ public class AnnotationDefaultAttribute extends
AnnotationsAttribute {
@Override
protected void resolve(final ClassConstantPool pool) {
super.resolve(pool);
- element_value.resolve(pool);
+ elementValue.resolve(pool);
}
@Override
public String toString() {
- return "AnnotationDefault: " + element_value;
+ return "AnnotationDefault: " + elementValue;
}
@Override
protected void writeBody(final DataOutputStream dos) throws IOException {
- element_value.writeBody(dos);
+ elementValue.writeBody(dos);
}
}
diff --git
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/AnnotationsAttribute.java
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/AnnotationsAttribute.java
index 5e55e7ef..32f047f8 100644
---
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/AnnotationsAttribute.java
+++
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/AnnotationsAttribute.java
@@ -31,28 +31,28 @@ public abstract class AnnotationsAttribute extends
Attribute {
*/
public static class Annotation {
- private final int num_pairs;
- private final CPUTF8[] element_names;
- private final ElementValue[] element_values;
+ private final int numPairs;
+ private final CPUTF8[] elementNames;
+ private final ElementValue[] elementValues;
private final CPUTF8 type;
// Resolved values
- private int type_index;
- private int[] name_indexes;
+ private int typeIndex;
+ private int[] nameIndexes;
- public Annotation(final int num_pairs, final CPUTF8 type, final
CPUTF8[] element_names,
- final ElementValue[] element_values) {
- this.num_pairs = num_pairs;
+ public Annotation(final int numPairs, final CPUTF8 type, final
CPUTF8[] elementNames,
+ final ElementValue[] elementValues) {
+ this.numPairs = numPairs;
this.type = type;
- this.element_names = element_names;
- this.element_values = element_values;
+ this.elementNames = elementNames;
+ this.elementValues = elementValues;
}
public List<Object> getClassFileEntries() {
final List<Object> entries = new ArrayList<>();
- for (int i = 0; i < element_names.length; i++) {
- entries.add(element_names[i]);
- entries.addAll(element_values[i].getClassFileEntries());
+ for (int i = 0; i < elementNames.length; i++) {
+ entries.add(elementNames[i]);
+ entries.addAll(elementValues[i].getClassFileEntries());
}
entries.add(type);
return entries;
@@ -60,30 +60,30 @@ public abstract class AnnotationsAttribute extends
Attribute {
public int getLength() {
int length = 4;
- for (int i = 0; i < num_pairs; i++) {
+ for (int i = 0; i < numPairs; i++) {
length += 2;
- length += element_values[i].getLength();
+ length += elementValues[i].getLength();
}
return length;
}
public void resolve(final ClassConstantPool pool) {
type.resolve(pool);
- type_index = pool.indexOf(type);
- name_indexes = new int[num_pairs];
- for (int i = 0; i < element_names.length; i++) {
- element_names[i].resolve(pool);
- name_indexes[i] = pool.indexOf(element_names[i]);
- element_values[i].resolve(pool);
+ typeIndex = pool.indexOf(type);
+ nameIndexes = new int[numPairs];
+ for (int i = 0; i < elementNames.length; i++) {
+ elementNames[i].resolve(pool);
+ nameIndexes[i] = pool.indexOf(elementNames[i]);
+ elementValues[i].resolve(pool);
}
}
public void writeBody(final DataOutputStream dos) throws IOException {
- dos.writeShort(type_index);
- dos.writeShort(num_pairs);
- for (int i = 0; i < num_pairs; i++) {
- dos.writeShort(name_indexes[i]);
- element_values[i].writeBody(dos);
+ dos.writeShort(typeIndex);
+ dos.writeShort(numPairs);
+ for (int i = 0; i < numPairs; i++) {
+ dos.writeShort(nameIndexes[i]);
+ elementValues[i].writeBody(dos);
}
}
}
@@ -94,7 +94,7 @@ public abstract class AnnotationsAttribute extends Attribute {
private final int tag;
// resolved value index if it's a constant
- private int constant_value_index = -1;
+ private int constantValueIndex = -1;
public ElementValue(final int tag, final Object value) {
this.tag = tag;
@@ -152,13 +152,13 @@ public abstract class AnnotationsAttribute extends
Attribute {
public void resolve(final ClassConstantPool pool) {
if (value instanceof CPConstant) {
((CPConstant) value).resolve(pool);
- constant_value_index = pool.indexOf((CPConstant) value);
+ constantValueIndex = pool.indexOf((CPConstant) value);
} else if (value instanceof CPClass) {
((CPClass) value).resolve(pool);
- constant_value_index = pool.indexOf((CPClass) value);
+ constantValueIndex = pool.indexOf((CPClass) value);
} else if (value instanceof CPUTF8) {
((CPUTF8) value).resolve(pool);
- constant_value_index = pool.indexOf((CPUTF8) value);
+ constantValueIndex = pool.indexOf((CPUTF8) value);
} else if (value instanceof CPNameAndType) {
((CPNameAndType) value).resolve(pool);
} else if (value instanceof Annotation) {
@@ -173,8 +173,8 @@ public abstract class AnnotationsAttribute extends
Attribute {
public void writeBody(final DataOutputStream dos) throws IOException {
dos.writeByte(tag);
- if (constant_value_index != -1) {
- dos.writeShort(constant_value_index);
+ if (constantValueIndex != -1) {
+ dos.writeShort(constantValueIndex);
} else if (value instanceof CPNameAndType) {
((CPNameAndType) value).writeBody(dos);
} else if (value instanceof Annotation) {
diff --git
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/EnclosingMethodAttribute.java
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/EnclosingMethodAttribute.java
index 21a2fea7..29cd2108 100644
---
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/EnclosingMethodAttribute.java
+++
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/EnclosingMethodAttribute.java
@@ -28,8 +28,8 @@ public class EnclosingMethodAttribute extends Attribute {
public static void setAttributeName(final CPUTF8 cpUTF8Value) {
attributeName = cpUTF8Value;
}
- private int class_index;
- private int method_index;
+ private int classIndex;
+ private int methodIndex;
private final CPClass cpClass;
private final CPNameAndType method;
@@ -53,21 +53,21 @@ public class EnclosingMethodAttribute extends Attribute {
@Override
protected ClassFileEntry[] getNestedClassFileEntries() {
if (method != null) {
- return new ClassFileEntry[] {attributeName, cpClass, method};
+ return new ClassFileEntry[] { attributeName, cpClass, method };
}
- return new ClassFileEntry[] {attributeName, cpClass};
+ return new ClassFileEntry[] { attributeName, cpClass };
}
@Override
protected void resolve(final ClassConstantPool pool) {
super.resolve(pool);
cpClass.resolve(pool);
- class_index = pool.indexOf(cpClass);
+ classIndex = pool.indexOf(cpClass);
if (method != null) {
method.resolve(pool);
- method_index = pool.indexOf(method);
+ methodIndex = pool.indexOf(method);
} else {
- method_index = 0;
+ methodIndex = 0;
}
}
@@ -88,8 +88,8 @@ public class EnclosingMethodAttribute extends Attribute {
*/
@Override
protected void writeBody(final DataOutputStream dos) throws IOException {
- dos.writeShort(class_index);
- dos.writeShort(method_index);
+ dos.writeShort(classIndex);
+ dos.writeShort(methodIndex);
}
}
diff --git
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/ExceptionTableEntry.java
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/ExceptionTableEntry.java
index e9d446f3..c51b54aa 100644
---
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/ExceptionTableEntry.java
+++
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/ExceptionTableEntry.java
@@ -37,8 +37,8 @@ public class ExceptionTableEntry {
/**
* Create a new ExceptionTableEntry. Exception tables are of two kinds:
either a normal one (with a Throwable as the
- * catch_type) or a finally clause (which has no catch_type). In the class
file, the finally clause is represented
- * as catch_type == 0.
+ * catchType) or a finally clause (which has no catchType). In the class
file, the finally clause is represented
+ * as catchType == 0.
*
* To create a finally clause with this method, pass in null for the
catchType.
*
diff --git
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/InnerClassesAttribute.java
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/InnerClassesAttribute.java
index 8a6aaa6d..80ce2caf 100644
---
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/InnerClassesAttribute.java
+++
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/InnerClassesAttribute.java
@@ -28,21 +28,21 @@ public class InnerClassesAttribute extends Attribute {
private static class InnerClassesEntry {
- CPClass inner_class_info;
- CPClass outer_class_info;
- CPUTF8 inner_class_name;
+ CPClass innerClassInfo;
+ CPClass outerClassInfo;
+ CPUTF8 innerClassName;
- int inner_class_info_index = -1;
- int outer_class_info_index = -1;
- int inner_name_index = -1;
- int inner_class_access_flags = -1;
+ int innerClassInfoIndex = -1;
+ int outerClassInfoIndex = -1;
+ int innerNameIndex = -1;
+ int innerClassAccessFlags = -1;
public InnerClassesEntry(final CPClass innerClass, final CPClass
outerClass, final CPUTF8 innerName,
final int flags) {
- this.inner_class_info = innerClass;
- this.outer_class_info = outerClass;
- this.inner_class_name = innerName;
- this.inner_class_access_flags = flags;
+ this.innerClassInfo = innerClass;
+ this.outerClassInfo = outerClass;
+ this.innerClassName = innerName;
+ this.innerClassAccessFlags = flags;
}
/**
@@ -51,33 +51,33 @@ public class InnerClassesAttribute extends Attribute {
* @param pool ClassConstantPool which holds the CPClass and CPUTF8
objects.
*/
public void resolve(final ClassConstantPool pool) {
- if (inner_class_info != null) {
- inner_class_info.resolve(pool);
- inner_class_info_index = pool.indexOf(inner_class_info);
+ if (innerClassInfo != null) {
+ innerClassInfo.resolve(pool);
+ innerClassInfoIndex = pool.indexOf(innerClassInfo);
} else {
- inner_class_info_index = 0;
+ innerClassInfoIndex = 0;
}
- if (inner_class_name != null) {
- inner_class_name.resolve(pool);
- inner_name_index = pool.indexOf(inner_class_name);
+ if (innerClassName != null) {
+ innerClassName.resolve(pool);
+ innerNameIndex = pool.indexOf(innerClassName);
} else {
- inner_name_index = 0;
+ innerNameIndex = 0;
}
- if (outer_class_info != null) {
- outer_class_info.resolve(pool);
- outer_class_info_index = pool.indexOf(outer_class_info);
+ if (outerClassInfo != null) {
+ outerClassInfo.resolve(pool);
+ outerClassInfoIndex = pool.indexOf(outerClassInfo);
} else {
- outer_class_info_index = 0;
+ outerClassInfoIndex = 0;
}
}
public void write(final DataOutputStream dos) throws IOException {
- dos.writeShort(inner_class_info_index);
- dos.writeShort(outer_class_info_index);
- dos.writeShort(inner_name_index);
- dos.writeShort(inner_class_access_flags);
+ dos.writeShort(innerClassInfoIndex);
+ dos.writeShort(outerClassInfoIndex);
+ dos.writeShort(innerNameIndex);
+ dos.writeShort(innerClassAccessFlags);
}
}
diff --git
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/LineNumberTableAttribute.java
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/LineNumberTableAttribute.java
index 2cee319d..06dc1596 100644
---
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/LineNumberTableAttribute.java
+++
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/LineNumberTableAttribute.java
@@ -25,20 +25,21 @@ import java.io.IOException;
public class LineNumberTableAttribute extends BCIRenumberedAttribute {
private static CPUTF8 attributeName;
+
public static void setAttributeName(final CPUTF8 cpUTF8Value) {
attributeName = cpUTF8Value;
}
- private final int line_number_table_length;
- private final int[] start_pcs;
- private final int[] line_numbers;
+ private final int lineNumberTableLength;
+ private final int[] startPcs;
+ private final int[] lineNumbers;
- public LineNumberTableAttribute(final int line_number_table_length, final
int[] start_pcs,
- final int[] line_numbers) {
+ public LineNumberTableAttribute(final int lineNumberTableLength, final
int[] startPcs,
+ final int[] lineNumbers) {
super(attributeName);
- this.line_number_table_length = line_number_table_length;
- this.start_pcs = start_pcs;
- this.line_numbers = line_numbers;
+ this.lineNumberTableLength = lineNumberTableLength;
+ this.startPcs = startPcs;
+ this.lineNumbers = lineNumbers;
}
@Override
@@ -48,7 +49,7 @@ public class LineNumberTableAttribute extends
BCIRenumberedAttribute {
@Override
protected int getLength() {
- return 2 + (4 * line_number_table_length);
+ return 2 + (4 * lineNumberTableLength);
}
/*
@@ -63,7 +64,7 @@ public class LineNumberTableAttribute extends
BCIRenumberedAttribute {
@Override
protected int[] getStartPCs() {
- return start_pcs;
+ return startPcs;
}
/*
@@ -85,15 +86,15 @@ public class LineNumberTableAttribute extends
BCIRenumberedAttribute {
*/
@Override
public String toString() {
- return "LineNumberTable: " + line_number_table_length + " lines";
+ return "LineNumberTable: " + lineNumberTableLength + " lines";
}
@Override
protected void writeBody(final DataOutputStream dos) throws IOException {
- dos.writeShort(line_number_table_length);
- for (int i = 0; i < line_number_table_length; i++) {
- dos.writeShort(start_pcs[i]);
- dos.writeShort(line_numbers[i]);
+ dos.writeShort(lineNumberTableLength);
+ for (int i = 0; i < lineNumberTableLength; i++) {
+ dos.writeShort(startPcs[i]);
+ dos.writeShort(lineNumbers[i]);
}
}
}
diff --git
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/LocalVariableTableAttribute.java
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/LocalVariableTableAttribute.java
index 42651082..0d2cc3e7 100644
---
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/LocalVariableTableAttribute.java
+++
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/LocalVariableTableAttribute.java
@@ -33,22 +33,22 @@ public class LocalVariableTableAttribute extends
BCIRenumberedAttribute {
public static void setAttributeName(final CPUTF8 cpUTF8Value) {
attributeName = cpUTF8Value;
}
- private final int local_variable_table_length;
- private final int[] start_pcs;
+ private final int localVariableTableLength;
+ private final int[] startPcs;
private final int[] lengths;
- private int[] name_indexes;
- private int[] descriptor_indexes;
+ private int[] nameIndexes;
+ private int[] descriptorIndexes;
private final int[] indexes;
private final CPUTF8[] names;
private final CPUTF8[] descriptors;
private int codeLength;
- public LocalVariableTableAttribute(final int local_variable_table_length,
final int[] start_pcs,
+ public LocalVariableTableAttribute(final int localVariableTableLength,
final int[] startPcs,
final int[] lengths, final CPUTF8[] names, final CPUTF8[] descriptors,
final int[] indexes) {
super(attributeName);
- this.local_variable_table_length = local_variable_table_length;
- this.start_pcs = start_pcs;
+ this.localVariableTableLength = localVariableTableLength;
+ this.startPcs = startPcs;
this.lengths = lengths;
this.names = names;
this.descriptors = descriptors;
@@ -57,14 +57,14 @@ public class LocalVariableTableAttribute extends
BCIRenumberedAttribute {
@Override
protected int getLength() {
- return 2 + (10 * local_variable_table_length);
+ return 2 + (10 * localVariableTableLength);
}
@Override
protected ClassFileEntry[] getNestedClassFileEntries() {
final List<CPUTF8> nestedEntries = new ArrayList<>();
nestedEntries.add(getAttributeName());
- for (int i = 0; i < local_variable_table_length; i++) {
+ for (int i = 0; i < localVariableTableLength; i++) {
nestedEntries.add(names[i]);
nestedEntries.add(descriptors[i]);
}
@@ -73,7 +73,7 @@ public class LocalVariableTableAttribute extends
BCIRenumberedAttribute {
@Override
protected int[] getStartPCs() {
- return start_pcs;
+ return startPcs;
}
/*
@@ -83,33 +83,33 @@ public class LocalVariableTableAttribute extends
BCIRenumberedAttribute {
*/
@Override
public void renumber(final List<Integer> byteCodeOffsets) throws
Pack200Exception {
- // Remember the unrenumbered start_pcs, since that's used later
+ // Remember the unrenumbered startPcs, since that's used later
// to calculate end position.
- final int[] unrenumbered_start_pcs = Arrays.copyOf(start_pcs,
start_pcs.length);
+ final int[] unrenumberedStartPcs = Arrays.copyOf(startPcs,
startPcs.length);
- // Next renumber start_pcs in place
+ // Next renumber startPcs in place
super.renumber(byteCodeOffsets);
// lengths are BRANCH5 encoded, not BCI-encoded.
// In other words:
- // start_pc is BCI5 start_pc
- // end_pc is byteCodeOffset[(index of start_pc in byteCodeOffset) +
+ // startPc is BCI5 startPc
+ // endPc is byteCodeOffset[(index of startPc in byteCodeOffset) +
// (encoded length)]
- // real length = end_pc - start_pc
- // special case if end_pc is beyond end of bytecode array
+ // real length = endPc - startPc
+ // special case if endPc is beyond end of bytecode array
final int maxSize = codeLength;
// Iterate through the lengths and update each in turn.
// This is done in place in the lengths array.
for (int index = 0; index < lengths.length; index++) {
- final int start_pc = start_pcs[index];
+ final int startPc = startPcs[index];
int revisedLength = -1;
final int encodedLength = lengths[index];
- // First get the index of the start_pc in the byteCodeOffsets
- final int indexOfStartPC = unrenumbered_start_pcs[index];
- // Given the index of the start_pc, we can now add
+ // First get the index of the startPc in the byteCodeOffsets
+ final int indexOfStartPC = unrenumberedStartPcs[index];
+ // Given the index of the startPc, we can now add
// the encodedLength to it to get the stop index.
final int stopIndex = indexOfStartPC + encodedLength;
if (stopIndex < 0) {
@@ -120,11 +120,11 @@ public class LocalVariableTableAttribute extends
BCIRenumberedAttribute {
// end of the byte code offsets. Need to determine which this is.
if (stopIndex == byteCodeOffsets.size()) {
// Pointing to one past the end of the byte code array
- revisedLength = maxSize - start_pc;
+ revisedLength = maxSize - startPc;
} else {
// We're indexed into the byte code array
final int stopValue =
byteCodeOffsets.get(stopIndex).intValue();
- revisedLength = stopValue - start_pc;
+ revisedLength = stopValue - startPc;
}
lengths[index] = revisedLength;
}
@@ -133,13 +133,13 @@ public class LocalVariableTableAttribute extends
BCIRenumberedAttribute {
@Override
protected void resolve(final ClassConstantPool pool) {
super.resolve(pool);
- name_indexes = new int[local_variable_table_length];
- descriptor_indexes = new int[local_variable_table_length];
- for (int i = 0; i < local_variable_table_length; i++) {
+ nameIndexes = new int[localVariableTableLength];
+ descriptorIndexes = new int[localVariableTableLength];
+ for (int i = 0; i < localVariableTableLength; i++) {
names[i].resolve(pool);
descriptors[i].resolve(pool);
- name_indexes[i] = pool.indexOf(names[i]);
- descriptor_indexes[i] = pool.indexOf(descriptors[i]);
+ nameIndexes[i] = pool.indexOf(names[i]);
+ descriptorIndexes[i] = pool.indexOf(descriptors[i]);
}
}
@@ -149,17 +149,17 @@ public class LocalVariableTableAttribute extends
BCIRenumberedAttribute {
@Override
public String toString() {
- return "LocalVariableTable: " + +local_variable_table_length + "
variables";
+ return "LocalVariableTable: " + +localVariableTableLength + "
variables";
}
@Override
protected void writeBody(final DataOutputStream dos) throws IOException {
- dos.writeShort(local_variable_table_length);
- for (int i = 0; i < local_variable_table_length; i++) {
- dos.writeShort(start_pcs[i]);
+ dos.writeShort(localVariableTableLength);
+ for (int i = 0; i < localVariableTableLength; i++) {
+ dos.writeShort(startPcs[i]);
dos.writeShort(lengths[i]);
- dos.writeShort(name_indexes[i]);
- dos.writeShort(descriptor_indexes[i]);
+ dos.writeShort(nameIndexes[i]);
+ dos.writeShort(descriptorIndexes[i]);
dos.writeShort(indexes[i]);
}
}
diff --git
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/LocalVariableTypeTableAttribute.java
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/LocalVariableTypeTableAttribute.java
index 81da4920..3811d45d 100644
---
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/LocalVariableTypeTableAttribute.java
+++
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/LocalVariableTypeTableAttribute.java
@@ -33,22 +33,22 @@ public class LocalVariableTypeTableAttribute extends
BCIRenumberedAttribute {
public static void setAttributeName(final CPUTF8 cpUTF8Value) {
attributeName = cpUTF8Value;
}
- private final int local_variable_type_table_length;
- private final int[] start_pcs;
+ private final int localVariableTypeTableLength;
+ private final int[] startPcs;
private final int[] lengths;
- private int[] name_indexes;
- private int[] signature_indexes;
+ private int[] nameIndexes;
+ private int[] signatureIndexes;
private final int[] indexes;
private final CPUTF8[] names;
private final CPUTF8[] signatures;
private int codeLength;
- public LocalVariableTypeTableAttribute(final int
local_variable_type_table_length, final int[] start_pcs,
+ public LocalVariableTypeTableAttribute(final int
localVariableTypeTableLength, final int[] startPcs,
final int[] lengths, final CPUTF8[] names, final CPUTF8[] signatures,
final int[] indexes) {
super(attributeName);
- this.local_variable_type_table_length =
local_variable_type_table_length;
- this.start_pcs = start_pcs;
+ this.localVariableTypeTableLength = localVariableTypeTableLength;
+ this.startPcs = startPcs;
this.lengths = lengths;
this.names = names;
this.signatures = signatures;
@@ -57,14 +57,14 @@ public class LocalVariableTypeTableAttribute extends
BCIRenumberedAttribute {
@Override
protected int getLength() {
- return 2 + (10 * local_variable_type_table_length);
+ return 2 + (10 * localVariableTypeTableLength);
}
@Override
protected ClassFileEntry[] getNestedClassFileEntries() {
final List<CPUTF8> nestedEntries = new ArrayList<>();
nestedEntries.add(getAttributeName());
- for (int i = 0; i < local_variable_type_table_length; i++) {
+ for (int i = 0; i < localVariableTypeTableLength; i++) {
nestedEntries.add(names[i]);
nestedEntries.add(signatures[i]);
}
@@ -73,7 +73,7 @@ public class LocalVariableTypeTableAttribute extends
BCIRenumberedAttribute {
@Override
protected int[] getStartPCs() {
- return start_pcs;
+ return startPcs;
}
/*
@@ -83,33 +83,33 @@ public class LocalVariableTypeTableAttribute extends
BCIRenumberedAttribute {
*/
@Override
public void renumber(final List<Integer> byteCodeOffsets) throws
Pack200Exception {
- // Remember the unrenumbered start_pcs, since that's used later
+ // Remember the unrenumbered startPcs, since that's used later
// to calculate end position.
- final int[] unrenumbered_start_pcs = Arrays.copyOf(start_pcs,
start_pcs.length);
+ final int[] unrenumberedStartPcs = Arrays.copyOf(startPcs,
startPcs.length);
- // Next renumber start_pcs in place
+ // Next renumber startPcs in place
super.renumber(byteCodeOffsets);
// lengths are BRANCH5 encoded, not BCI-encoded.
// In other words:
- // start_pc is BCI5 start_pc
- // end_pc is byteCodeOffset[(index of start_pc in byteCodeOffset) +
+ // startPc is BCI5 startPc
+ // endPc is byteCodeOffset[(index of startPc in byteCodeOffset) +
// (encoded length)]
- // real length = end_pc - start_pc
- // special case if end_pc is beyond end of bytecode array
+ // real length = endPc - startPc
+ // special case if endPc is beyond end of bytecode array
final int maxSize = codeLength;
// Iterate through the lengths and update each in turn.
// This is done in place in the lengths array.
for (int index = 0; index < lengths.length; index++) {
- final int start_pc = start_pcs[index];
+ final int startPc = startPcs[index];
int revisedLength = -1;
final int encodedLength = lengths[index];
- // First get the index of the start_pc in the byteCodeOffsets
- final int indexOfStartPC = unrenumbered_start_pcs[index];
- // Given the index of the start_pc, we can now add
+ // First get the index of the startPc in the byteCodeOffsets
+ final int indexOfStartPC = unrenumberedStartPcs[index];
+ // Given the index of the startPc, we can now add
// the encodedLength to it to get the stop index.
final int stopIndex = indexOfStartPC + encodedLength;
if (stopIndex < 0) {
@@ -120,11 +120,11 @@ public class LocalVariableTypeTableAttribute extends
BCIRenumberedAttribute {
// end of the byte code offsets. Need to determine which this is.
if (stopIndex == byteCodeOffsets.size()) {
// Pointing to one past the end of the byte code array
- revisedLength = maxSize - start_pc;
+ revisedLength = maxSize - startPc;
} else {
// We're indexed into the byte code array
final int stopValue =
byteCodeOffsets.get(stopIndex).intValue();
- revisedLength = stopValue - start_pc;
+ revisedLength = stopValue - startPc;
}
lengths[index] = revisedLength;
}
@@ -133,13 +133,13 @@ public class LocalVariableTypeTableAttribute extends
BCIRenumberedAttribute {
@Override
protected void resolve(final ClassConstantPool pool) {
super.resolve(pool);
- name_indexes = new int[local_variable_type_table_length];
- signature_indexes = new int[local_variable_type_table_length];
- for (int i = 0; i < local_variable_type_table_length; i++) {
+ nameIndexes = new int[localVariableTypeTableLength];
+ signatureIndexes = new int[localVariableTypeTableLength];
+ for (int i = 0; i < localVariableTypeTableLength; i++) {
names[i].resolve(pool);
signatures[i].resolve(pool);
- name_indexes[i] = pool.indexOf(names[i]);
- signature_indexes[i] = pool.indexOf(signatures[i]);
+ nameIndexes[i] = pool.indexOf(names[i]);
+ signatureIndexes[i] = pool.indexOf(signatures[i]);
}
}
@@ -149,17 +149,17 @@ public class LocalVariableTypeTableAttribute extends
BCIRenumberedAttribute {
@Override
public String toString() {
- return "LocalVariableTypeTable: " + +local_variable_type_table_length
+ " varaibles";
+ return "LocalVariableTypeTable: " + +localVariableTypeTableLength + "
varaibles";
}
@Override
protected void writeBody(final DataOutputStream dos) throws IOException {
- dos.writeShort(local_variable_type_table_length);
- for (int i = 0; i < local_variable_type_table_length; i++) {
- dos.writeShort(start_pcs[i]);
+ dos.writeShort(localVariableTypeTableLength);
+ for (int i = 0; i < localVariableTypeTableLength; i++) {
+ dos.writeShort(startPcs[i]);
dos.writeShort(lengths[i]);
- dos.writeShort(name_indexes[i]);
- dos.writeShort(signature_indexes[i]);
+ dos.writeShort(nameIndexes[i]);
+ dos.writeShort(signatureIndexes[i]);
dos.writeShort(indexes[i]);
}
}
diff --git
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/RuntimeVisibleorInvisibleAnnotationsAttribute.java
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/RuntimeVisibleorInvisibleAnnotationsAttribute.java
index e59f466c..c31ade96 100644
---
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/RuntimeVisibleorInvisibleAnnotationsAttribute.java
+++
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/RuntimeVisibleorInvisibleAnnotationsAttribute.java
@@ -27,19 +27,19 @@ import java.util.List;
*/
public class RuntimeVisibleorInvisibleAnnotationsAttribute extends
AnnotationsAttribute {
- private final int num_annotations;
+ private final int numAnnotations;
private final Annotation[] annotations;
public RuntimeVisibleorInvisibleAnnotationsAttribute(final CPUTF8 name,
final Annotation[] annotations) {
super(name);
- this.num_annotations = annotations.length;
+ this.numAnnotations = annotations.length;
this.annotations = annotations;
}
@Override
protected int getLength() {
int length = 2;
- for (int i = 0; i < num_annotations; i++) {
+ for (int i = 0; i < numAnnotations; i++) {
length += annotations[i].getLength();
}
return length;
@@ -65,14 +65,14 @@ public class RuntimeVisibleorInvisibleAnnotationsAttribute
extends AnnotationsAt
@Override
public String toString() {
- return attributeName.underlyingString() + ": " + num_annotations + "
annotations";
+ return attributeName.underlyingString() + ": " + numAnnotations + "
annotations";
}
@Override
protected void writeBody(final DataOutputStream dos) throws IOException {
final int size = dos.size();
- dos.writeShort(num_annotations);
- for (int i = 0; i < num_annotations; i++) {
+ dos.writeShort(numAnnotations);
+ for (int i = 0; i < numAnnotations; i++) {
annotations[i].writeBody(dos);
}
if (dos.size() - size != getLength()) {
diff --git
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/RuntimeVisibleorInvisibleParameterAnnotationsAttribute.java
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/RuntimeVisibleorInvisibleParameterAnnotationsAttribute.java
index af21ea15..8b6ccf95 100644
---
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/RuntimeVisibleorInvisibleParameterAnnotationsAttribute.java
+++
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/RuntimeVisibleorInvisibleParameterAnnotationsAttribute.java
@@ -33,10 +33,10 @@ public class
RuntimeVisibleorInvisibleParameterAnnotationsAttribute extends Anno
public static class ParameterAnnotation {
private final Annotation[] annotations;
- private final int num_annotations;
+ private final int numAnnotations;
public ParameterAnnotation(final Annotation[] annotations) {
- this.num_annotations = annotations.length;
+ this.numAnnotations = annotations.length;
this.annotations = annotations;
}
@@ -63,29 +63,29 @@ public class
RuntimeVisibleorInvisibleParameterAnnotationsAttribute extends Anno
}
public void writeBody(final DataOutputStream dos) throws IOException {
- dos.writeShort(num_annotations);
+ dos.writeShort(numAnnotations);
for (final Annotation annotation : annotations) {
annotation.writeBody(dos);
}
}
}
- private final int num_parameters;
+ private final int numParameters;
- private final ParameterAnnotation[] parameter_annotations;
+ private final ParameterAnnotation[] parameterAnnotations;
public RuntimeVisibleorInvisibleParameterAnnotationsAttribute(final CPUTF8
name,
- final ParameterAnnotation[] parameter_annotations) {
+ final ParameterAnnotation[] parameterAnnotations) {
super(name);
- this.num_parameters = parameter_annotations.length;
- this.parameter_annotations = parameter_annotations;
+ this.numParameters = parameterAnnotations.length;
+ this.parameterAnnotations = parameterAnnotations;
}
@Override
protected int getLength() {
int length = 1;
- for (int i = 0; i < num_parameters; i++) {
- length += parameter_annotations[i].getLength();
+ for (int i = 0; i < numParameters; i++) {
+ length += parameterAnnotations[i].getLength();
}
return length;
}
@@ -94,8 +94,8 @@ public class
RuntimeVisibleorInvisibleParameterAnnotationsAttribute extends Anno
protected ClassFileEntry[] getNestedClassFileEntries() {
final List<Object> nested = new ArrayList<>();
nested.add(attributeName);
- for (final ParameterAnnotation parameter_annotation :
parameter_annotations) {
- nested.addAll(parameter_annotation.getClassFileEntries());
+ for (final ParameterAnnotation parameterAnnotation :
parameterAnnotations) {
+ nested.addAll(parameterAnnotation.getClassFileEntries());
}
return nested.toArray(ClassFileEntry.NONE);
}
@@ -103,21 +103,21 @@ public class
RuntimeVisibleorInvisibleParameterAnnotationsAttribute extends Anno
@Override
protected void resolve(final ClassConstantPool pool) {
super.resolve(pool);
- for (final ParameterAnnotation parameter_annotation :
parameter_annotations) {
- parameter_annotation.resolve(pool);
+ for (final ParameterAnnotation parameterAnnotation :
parameterAnnotations) {
+ parameterAnnotation.resolve(pool);
}
}
@Override
public String toString() {
- return attributeName.underlyingString() + ": " + num_parameters + "
parameter annotations";
+ return attributeName.underlyingString() + ": " + numParameters + "
parameter annotations";
}
@Override
protected void writeBody(final DataOutputStream dos) throws IOException {
- dos.writeByte(num_parameters);
- for (int i = 0; i < num_parameters; i++) {
- parameter_annotations[i].writeBody(dos);
+ dos.writeByte(numParameters);
+ for (int i = 0; i < numParameters; i++) {
+ parameterAnnotations[i].writeBody(dos);
}
}
diff --git
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/SignatureAttribute.java
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/SignatureAttribute.java
index ad97c04a..c41769d6 100644
---
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/SignatureAttribute.java
+++
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/SignatureAttribute.java
@@ -29,7 +29,7 @@ public class SignatureAttribute extends Attribute {
attributeName = cpUTF8Value;
}
- private int signature_index;
+ private int signatureIndex;
private final CPUTF8 signature;
@@ -57,7 +57,7 @@ public class SignatureAttribute extends Attribute {
protected void resolve(final ClassConstantPool pool) {
super.resolve(pool);
signature.resolve(pool);
- signature_index = pool.indexOf(signature);
+ signatureIndex = pool.indexOf(signature);
}
/*
@@ -78,7 +78,7 @@ public class SignatureAttribute extends Attribute {
*/
@Override
protected void writeBody(final DataOutputStream dos) throws IOException {
- dos.writeShort(signature_index);
+ dos.writeShort(signatureIndex);
}
}
diff --git
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/forms/LookupSwitchForm.java
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/forms/LookupSwitchForm.java
index 8d531fcf..9d85e4dd 100644
---
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/forms/LookupSwitchForm.java
+++
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/forms/LookupSwitchForm.java
@@ -38,16 +38,16 @@ public class LookupSwitchForm extends SwitchForm {
@Override
public void setByteCodeOperands(final ByteCode byteCode, final
OperandManager operandManager,
final int codeLength) {
- final int case_count = operandManager.nextCaseCount();
- final int default_pc = operandManager.nextLabel();
- final int[] case_values = new int[case_count];
- Arrays.setAll(case_values, i -> operandManager.nextCaseValues());
- final int[] case_pcs = new int[case_count];
- Arrays.setAll(case_pcs, i -> operandManager.nextLabel());
+ final int caseCount = operandManager.nextCaseCount();
+ final int defaultPc = operandManager.nextLabel();
+ final int[] caseValues = new int[caseCount];
+ Arrays.setAll(caseValues, i -> operandManager.nextCaseValues());
+ final int[] casePcs = new int[caseCount];
+ Arrays.setAll(casePcs, i -> operandManager.nextLabel());
- final int[] labelsArray = new int[case_count + 1];
- labelsArray[0] = default_pc;
- System.arraycopy(case_pcs, 0, labelsArray, 1, case_count + 1 - 1);
+ final int[] labelsArray = new int[caseCount + 1];
+ labelsArray[0] = defaultPc;
+ System.arraycopy(casePcs, 0, labelsArray, 1, caseCount + 1 - 1);
byteCode.setByteCodeTargets(labelsArray);
// All this gets dumped into the rewrite bytes of the
@@ -65,7 +65,7 @@ public class LookupSwitchForm extends SwitchForm {
final int padLength = 3 - (codeLength % 4);
final int rewriteSize = 1 + padLength + 4 // defaultbytes
+ 4 // npairs
- + (4 * case_values.length) + (4 * case_pcs.length);
+ + (4 * caseValues.length) + (4 * casePcs.length);
final int[] newRewrite = new int[rewriteSize];
int rewriteIndex = 0;
@@ -88,15 +88,15 @@ public class LookupSwitchForm extends SwitchForm {
// npairs
final int npairsIndex = rewriteIndex;
- setRewrite4Bytes(case_values.length, npairsIndex, newRewrite);
+ setRewrite4Bytes(caseValues.length, npairsIndex, newRewrite);
rewriteIndex += 4;
// match-offset pairs
- // The case_values aren't overwritten, but the
- // case_pcs will get overwritten by fixUpByteCodeTargets
- for (final int case_value : case_values) {
+ // The caseValues aren't overwritten, but the
+ // casePcs will get overwritten by fixUpByteCodeTargets
+ for (final int caseValue : caseValues) {
// match
- setRewrite4Bytes(case_value, rewriteIndex, newRewrite);
+ setRewrite4Bytes(caseValue, rewriteIndex, newRewrite);
rewriteIndex += 4;
// offset
newRewrite[rewriteIndex++] = -1;
diff --git
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/forms/TableSwitchForm.java
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/forms/TableSwitchForm.java
index 1c77c7cb..138ded32 100644
---
a/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/forms/TableSwitchForm.java
+++
b/src/main/java/org/apache/commons/compress/harmony/unpack200/bytecode/forms/TableSwitchForm.java
@@ -38,21 +38,21 @@ public class TableSwitchForm extends SwitchForm {
@Override
public void setByteCodeOperands(final ByteCode byteCode, final
OperandManager operandManager,
final int codeLength) {
- final int case_count = operandManager.nextCaseCount();
- final int default_pc = operandManager.nextLabel();
- int case_value = -1;
- case_value = operandManager.nextCaseValues();
+ final int caseCount = operandManager.nextCaseCount();
+ final int defaultPc = operandManager.nextLabel();
+ int caseValue = -1;
+ caseValue = operandManager.nextCaseValues();
- final int[] case_pcs = new int[case_count];
- Arrays.setAll(case_pcs, i -> operandManager.nextLabel());
+ final int[] casePcs = new int[caseCount];
+ Arrays.setAll(casePcs, i -> operandManager.nextLabel());
- final int[] labelsArray = new int[case_count + 1];
- labelsArray[0] = default_pc;
- System.arraycopy(case_pcs, 0, labelsArray, 1, case_count + 1 - 1);
+ final int[] labelsArray = new int[caseCount + 1];
+ labelsArray[0] = defaultPc;
+ System.arraycopy(casePcs, 0, labelsArray, 1, caseCount + 1 - 1);
byteCode.setByteCodeTargets(labelsArray);
- final int lowValue = case_value;
- final int highValue = lowValue + case_count - 1;
+ final int lowValue = caseValue;
+ final int highValue = lowValue + caseCount - 1;
// All this gets dumped into the rewrite bytes of the
// poor bytecode.
@@ -69,7 +69,7 @@ public class TableSwitchForm extends SwitchForm {
final int rewriteSize = 1 + padLength + 4 // defaultbytes
+ 4 // lowbyte
+ 4 // highbyte
- + (4 * case_pcs.length);
+ + (4 * casePcs.length);
final int[] newRewrite = new int[rewriteSize];
int rewriteIndex = 0;
@@ -102,7 +102,7 @@ public class TableSwitchForm extends SwitchForm {
// jump offsets
// The case_pcs will get overwritten by fixUpByteCodeTargets
- for (int index = 0; index < case_count; index++) {
+ for (int index = 0; index < caseCount; index++) {
// offset
newRewrite[rewriteIndex++] = -1;
newRewrite[rewriteIndex++] = -1;
