java-decompiler: post-import cleanup (formatting and copyright)

12 files changed, 858 insertions, 827 deletions

diff --git a/src/org/jetbrains/java/decompiler/struct/attr/StructAnnDefaultAttribute.java b/src/org/jetbrains/java/decompiler/struct/attr/StructAnnDefaultAttribute.java
index d171349..f36df6d 100644
--- a/src/org/jetbrains/java/decompiler/struct/attr/StructAnnDefaultAttribute.java
+++ b/src/org/jetbrains/java/decompiler/struct/attr/StructAnnDefaultAttribute.java
@@ -1,40 +1,40 @@
 /*
- *    Fernflower - The Analytical Java Decompiler
- *    http://www.reversed-java.com
+ * Copyright 2000-2014 JetBrains s.r.o.
  *
- *    (C) 2008 - 2010, Stiver
+ * Licensed 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
  *
- *    This software is NEITHER public domain NOR free software 
- *    as per GNU License. See license.txt for more details.
+ * http://www.apache.org/licenses/LICENSE-2.0
  *
- *    This software is distributed WITHOUT ANY WARRANTY; without 
- *    even the implied warranty of MERCHANTABILITY or FITNESS FOR 
- *    A PARTICULAR PURPOSE. 
+ * 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 org.jetbrains.java.decompiler.struct.attr;
 
-import java.io.ByteArrayInputStream;
-import java.io.DataInputStream;
-
 import org.jetbrains.java.decompiler.modules.decompiler.exps.Exprent;
 import org.jetbrains.java.decompiler.struct.consts.ConstantPool;
 
+import java.io.ByteArrayInputStream;
+import java.io.DataInputStream;
+
 
 public class StructAnnDefaultAttribute extends StructGeneralAttribute {
 
-	private Exprent defaultValue;
-	
-	public void initContent(ConstantPool pool) {
-
-		name = ATTRIBUTE_ANNOTATION_DEFAULT;
-	
-		DataInputStream data = new DataInputStream(new ByteArrayInputStream(info));
-		defaultValue = StructAnnotationAttribute.parseAnnotationElement(data, pool); 
-	}
-	
-	public Exprent getDefaultValue() {
-		return defaultValue;
-	}
-	
+  private Exprent defaultValue;
+
+  public void initContent(ConstantPool pool) {
+
+    name = ATTRIBUTE_ANNOTATION_DEFAULT;
+
+    DataInputStream data = new DataInputStream(new ByteArrayInputStream(info));
+    defaultValue = StructAnnotationAttribute.parseAnnotationElement(data, pool);
+  }
+
+  public Exprent getDefaultValue() {
+    return defaultValue;
+  }
 }
diff --git a/src/org/jetbrains/java/decompiler/struct/attr/StructAnnotationAttribute.java b/src/org/jetbrains/java/decompiler/struct/attr/StructAnnotationAttribute.java
index 8958299..2a2c74c 100644
--- a/src/org/jetbrains/java/decompiler/struct/attr/StructAnnotationAttribute.java
+++ b/src/org/jetbrains/java/decompiler/struct/attr/StructAnnotationAttribute.java
@@ -1,187 +1,182 @@
 /*
- *    Fernflower - The Analytical Java Decompiler
- *    http://www.reversed-java.com
+ * Copyright 2000-2014 JetBrains s.r.o.
  *
- *    (C) 2008 - 2010, Stiver
+ * Licensed 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
  *
- *    This software is NEITHER public domain NOR free software 
- *    as per GNU License. See license.txt for more details.
+ * http://www.apache.org/licenses/LICENSE-2.0
  *
- *    This software is distributed WITHOUT ANY WARRANTY; without 
- *    even the implied warranty of MERCHANTABILITY or FITNESS FOR 
- *    A PARTICULAR PURPOSE. 
+ * 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 org.jetbrains.java.decompiler.struct.attr;
 
-import java.io.ByteArrayInputStream;
-import java.io.DataInputStream;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-
 import org.jetbrains.java.decompiler.code.CodeConstants;
-import org.jetbrains.java.decompiler.modules.decompiler.exps.AnnotationExprent;
-import org.jetbrains.java.decompiler.modules.decompiler.exps.ConstExprent;
-import org.jetbrains.java.decompiler.modules.decompiler.exps.Exprent;
-import org.jetbrains.java.decompiler.modules.decompiler.exps.FieldExprent;
-import org.jetbrains.java.decompiler.modules.decompiler.exps.NewExprent;
+import org.jetbrains.java.decompiler.modules.decompiler.exps.*;
 import org.jetbrains.java.decompiler.struct.consts.ConstantPool;
 import org.jetbrains.java.decompiler.struct.consts.PrimitiveConstant;
 import org.jetbrains.java.decompiler.struct.gen.FieldDescriptor;
 import org.jetbrains.java.decompiler.struct.gen.VarType;
 
+import java.io.ByteArrayInputStream;
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
 public class StructAnnotationAttribute extends StructGeneralAttribute {
 
-	private List<AnnotationExprent> annotations;
-	
-	public void initContent(ConstantPool pool) {
-
-		super.initContent(pool);
-		
-		annotations = new ArrayList<AnnotationExprent>();
-		DataInputStream data = new DataInputStream(new ByteArrayInputStream(info, 2, info.length));
-		
-		int len = (((info[0] & 0xFF)<<8) | (info[1] & 0xFF));
-		for(int i=0;i<len;i++) {
-			annotations.add(parseAnnotation(data, pool));
-		}
-		
-	}
-	
-	public static AnnotationExprent parseAnnotation(DataInputStream data, ConstantPool pool) {
-
-		try {
-		
-			String classname = pool.getPrimitiveConstant(data.readUnsignedShort()).getString();
-			VarType cltype = new VarType(classname);
-			
-			int len = data.readUnsignedShort();
-			
-			List<String> parnames = new ArrayList<String>();
-			List<Exprent> parvalues = new ArrayList<Exprent>();
-			
-			for(int i=0;i<len;i++) {
-				parnames.add(pool.getPrimitiveConstant(data.readUnsignedShort()).getString());
-				parvalues.add(parseAnnotationElement(data, pool));
-			}
-			
-			return new AnnotationExprent(cltype.value, parnames, parvalues);
-			
-		} catch(IOException ex) {
-			throw new RuntimeException(ex);
-		}
-	
-	}
-	
-	public static Exprent parseAnnotationElement(DataInputStream data, ConstantPool pool) {
-
-		try {
-			int tag = data.readUnsignedByte();
-			
-			switch(tag) {
-			case 'e': // enum constant
-				String classname = pool.getPrimitiveConstant(data.readUnsignedShort()).getString();
-				String constname = pool.getPrimitiveConstant(data.readUnsignedShort()).getString();
-				
-				FieldDescriptor descr = FieldDescriptor.parseDescriptor(classname);
-				return new FieldExprent(constname, descr.type.value, true, null, descr);
-			case 'c': // class
-				String descriptor = pool.getPrimitiveConstant(data.readUnsignedShort()).getString();
-				VarType type = FieldDescriptor.parseDescriptor(descriptor).type;
-				
-				String value;
-				switch(type.type) {  
-				case CodeConstants.TYPE_OBJECT:
-					value = type.value;
-					break;
-				case CodeConstants.TYPE_BYTE:
-          value = byte.class.getName();
-          break;
-				case CodeConstants.TYPE_CHAR:
-          value = char.class.getName();
-          break;
-				case CodeConstants.TYPE_DOUBLE:
-          value = double.class.getName();
-          break;
-				case CodeConstants.TYPE_FLOAT:
-          value = float.class.getName();
-          break;
-				case CodeConstants.TYPE_INT:
-          value = int.class.getName();
-          break;
-				case CodeConstants.TYPE_LONG:
-          value = long.class.getName();
-          break;
-				case CodeConstants.TYPE_SHORT:
-          value = short.class.getName();
-          break;
-				case CodeConstants.TYPE_BOOLEAN:
-          value = boolean.class.getName();
-          break;
-				case CodeConstants.TYPE_VOID:
-          value = void.class.getName();
-          break;
-				default:
-					throw new RuntimeException("invalid class type: " + type.type);
-				}
-				return new ConstExprent(VarType.VARTYPE_CLASS, value);
-			case '[': // array
-				int len = data.readUnsignedShort();
-				List<Exprent> lst = new ArrayList<Exprent>();
-				
-				for(int i=0;i<len;i++) {
-					lst.add(parseAnnotationElement(data, pool));
-				}
-				
-				VarType newtype;
-				if(lst.isEmpty()) {
-					newtype = new VarType(CodeConstants.TYPE_OBJECT, 1, "java/lang/Object");
-				} else {
-					VarType eltype = lst.get(0).getExprType();
-					newtype = new VarType(eltype.type, 1, eltype.value);
-				}
-				
-				NewExprent newexpr = new NewExprent(newtype, new ArrayList<Exprent>());
-				newexpr.setDirectArrayInit(true);
-				newexpr.setLstArrayElements(lst);
-				return newexpr;
-			case '@': // annotation
-				return parseAnnotation(data, pool);
-			default:
-				PrimitiveConstant cn = pool.getPrimitiveConstant(data.readUnsignedShort());
-				switch(tag) {
-				case 'B':
-					return new ConstExprent(VarType.VARTYPE_BYTE, cn.value);
-				case 'C': 
-					return new ConstExprent(VarType.VARTYPE_CHAR, cn.value);
-				case 'D': 
-					return new ConstExprent(VarType.VARTYPE_DOUBLE, cn.value);
-				case 'F':
-					return new ConstExprent(VarType.VARTYPE_FLOAT, cn.value);
-				case 'I':
-					return new ConstExprent(VarType.VARTYPE_INT, cn.value);
-				case 'J':
-					return new ConstExprent(VarType.VARTYPE_LONG, cn.value);
-				case 'S':
-					return new ConstExprent(VarType.VARTYPE_SHORT, cn.value);
-				case 'Z':
-					return new ConstExprent(VarType.VARTYPE_BOOLEAN, cn.value);
-				case 's':
-					return new ConstExprent(VarType.VARTYPE_STRING, cn.value);
-				default:
-					throw new RuntimeException("invalid element type!");
-				}
-			}
-		} catch(IOException ex) {
-			throw new RuntimeException(ex);
-		}
-		
-	}
-	
-
-	public List<AnnotationExprent> getAnnotations() {
-		return annotations;
-	}
-	
+  private List<AnnotationExprent> annotations;
+
+  public void initContent(ConstantPool pool) {
+
+    super.initContent(pool);
+
+    annotations = new ArrayList<AnnotationExprent>();
+    DataInputStream data = new DataInputStream(new ByteArrayInputStream(info, 2, info.length));
+
+    int len = (((info[0] & 0xFF) << 8) | (info[1] & 0xFF));
+    for (int i = 0; i < len; i++) {
+      annotations.add(parseAnnotation(data, pool));
+    }
+  }
+
+  public static AnnotationExprent parseAnnotation(DataInputStream data, ConstantPool pool) {
+
+    try {
+
+      String classname = pool.getPrimitiveConstant(data.readUnsignedShort()).getString();
+      VarType cltype = new VarType(classname);
+
+      int len = data.readUnsignedShort();
+
+      List<String> parnames = new ArrayList<String>();
+      List<Exprent> parvalues = new ArrayList<Exprent>();
+
+      for (int i = 0; i < len; i++) {
+        parnames.add(pool.getPrimitiveConstant(data.readUnsignedShort()).getString());
+        parvalues.add(parseAnnotationElement(data, pool));
+      }
+
+      return new AnnotationExprent(cltype.value, parnames, parvalues);
+    }
+    catch (IOException ex) {
+      throw new RuntimeException(ex);
+    }
+  }
+
+  public static Exprent parseAnnotationElement(DataInputStream data, ConstantPool pool) {
+
+    try {
+      int tag = data.readUnsignedByte();
+
+      switch (tag) {
+        case 'e': // enum constant
+          String classname = pool.getPrimitiveConstant(data.readUnsignedShort()).getString();
+          String constname = pool.getPrimitiveConstant(data.readUnsignedShort()).getString();
+
+          FieldDescriptor descr = FieldDescriptor.parseDescriptor(classname);
+          return new FieldExprent(constname, descr.type.value, true, null, descr);
+        case 'c': // class
+          String descriptor = pool.getPrimitiveConstant(data.readUnsignedShort()).getString();
+          VarType type = FieldDescriptor.parseDescriptor(descriptor).type;
+
+          String value;
+          switch (type.type) {
+            case CodeConstants.TYPE_OBJECT:
+              value = type.value;
+              break;
+            case CodeConstants.TYPE_BYTE:
+              value = byte.class.getName();
+              break;
+            case CodeConstants.TYPE_CHAR:
+              value = char.class.getName();
+              break;
+            case CodeConstants.TYPE_DOUBLE:
+              value = double.class.getName();
+              break;
+            case CodeConstants.TYPE_FLOAT:
+              value = float.class.getName();
+              break;
+            case CodeConstants.TYPE_INT:
+              value = int.class.getName();
+              break;
+            case CodeConstants.TYPE_LONG:
+              value = long.class.getName();
+              break;
+            case CodeConstants.TYPE_SHORT:
+              value = short.class.getName();
+              break;
+            case CodeConstants.TYPE_BOOLEAN:
+              value = boolean.class.getName();
+              break;
+            case CodeConstants.TYPE_VOID:
+              value = void.class.getName();
+              break;
+            default:
+              throw new RuntimeException("invalid class type: " + type.type);
+          }
+          return new ConstExprent(VarType.VARTYPE_CLASS, value);
+        case '[': // array
+          int len = data.readUnsignedShort();
+          List<Exprent> lst = new ArrayList<Exprent>();
+
+          for (int i = 0; i < len; i++) {
+            lst.add(parseAnnotationElement(data, pool));
+          }
+
+          VarType newtype;
+          if (lst.isEmpty()) {
+            newtype = new VarType(CodeConstants.TYPE_OBJECT, 1, "java/lang/Object");
+          }
+          else {
+            VarType eltype = lst.get(0).getExprType();
+            newtype = new VarType(eltype.type, 1, eltype.value);
+          }
+
+          NewExprent newexpr = new NewExprent(newtype, new ArrayList<Exprent>());
+          newexpr.setDirectArrayInit(true);
+          newexpr.setLstArrayElements(lst);
+          return newexpr;
+        case '@': // annotation
+          return parseAnnotation(data, pool);
+        default:
+          PrimitiveConstant cn = pool.getPrimitiveConstant(data.readUnsignedShort());
+          switch (tag) {
+            case 'B':
+              return new ConstExprent(VarType.VARTYPE_BYTE, cn.value);
+            case 'C':
+              return new ConstExprent(VarType.VARTYPE_CHAR, cn.value);
+            case 'D':
+              return new ConstExprent(VarType.VARTYPE_DOUBLE, cn.value);
+            case 'F':
+              return new ConstExprent(VarType.VARTYPE_FLOAT, cn.value);
+            case 'I':
+              return new ConstExprent(VarType.VARTYPE_INT, cn.value);
+            case 'J':
+              return new ConstExprent(VarType.VARTYPE_LONG, cn.value);
+            case 'S':
+              return new ConstExprent(VarType.VARTYPE_SHORT, cn.value);
+            case 'Z':
+              return new ConstExprent(VarType.VARTYPE_BOOLEAN, cn.value);
+            case 's':
+              return new ConstExprent(VarType.VARTYPE_STRING, cn.value);
+            default:
+              throw new RuntimeException("invalid element type!");
+          }
+      }
+    }
+    catch (IOException ex) {
+      throw new RuntimeException(ex);
+    }
+  }
+
+
+  public List<AnnotationExprent> getAnnotations() {
+    return annotations;
+  }
 }
diff --git a/src/org/jetbrains/java/decompiler/struct/attr/StructAnnotationParameterAttribute.java b/src/org/jetbrains/java/decompiler/struct/attr/StructAnnotationParameterAttribute.java
index dd28aa7..432d3b6 100644
--- a/src/org/jetbrains/java/decompiler/struct/attr/StructAnnotationParameterAttribute.java
+++ b/src/org/jetbrains/java/decompiler/struct/attr/StructAnnotationParameterAttribute.java
@@ -1,57 +1,58 @@
 /*
- *    Fernflower - The Analytical Java Decompiler
- *    http://www.reversed-java.com
+ * Copyright 2000-2014 JetBrains s.r.o.
  *
- *    (C) 2008 - 2010, Stiver
+ * Licensed 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
  *
- *    This software is NEITHER public domain NOR free software 
- *    as per GNU License. See license.txt for more details.
+ * http://www.apache.org/licenses/LICENSE-2.0
  *
- *    This software is distributed WITHOUT ANY WARRANTY; without 
- *    even the implied warranty of MERCHANTABILITY or FITNESS FOR 
- *    A PARTICULAR PURPOSE. 
+ * 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 org.jetbrains.java.decompiler.struct.attr;
 
+import org.jetbrains.java.decompiler.modules.decompiler.exps.AnnotationExprent;
+import org.jetbrains.java.decompiler.struct.consts.ConstantPool;
+
 import java.io.ByteArrayInputStream;
 import java.io.DataInputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.jetbrains.java.decompiler.modules.decompiler.exps.AnnotationExprent;
-import org.jetbrains.java.decompiler.struct.consts.ConstantPool;
-
 public class StructAnnotationParameterAttribute extends StructGeneralAttribute {
 
-	private List<List<AnnotationExprent>> paramAnnotations;
-	
-	public void initContent(ConstantPool pool) {
-
-		super.initContent(pool);
-		
-		paramAnnotations = new ArrayList<List<AnnotationExprent>>();
-		DataInputStream data = new DataInputStream(new ByteArrayInputStream(info));
-		
-		try {
-			int len = data.readUnsignedByte();
-			for(int i=0;i<len;i++) {
-				List<AnnotationExprent> lst = new ArrayList<AnnotationExprent>(); 
-				int annsize = data.readUnsignedShort();
-
-				for(int j=0;j<annsize;j++) {
-					lst.add(StructAnnotationAttribute.parseAnnotation(data, pool));
-				}
-				paramAnnotations.add(lst);
-			}
-		} catch(IOException ex) {
-			throw new RuntimeException(ex);
-		}
-
-	}
-
-	public List<List<AnnotationExprent>> getParamAnnotations() {
-		return paramAnnotations;
-	}
+  private List<List<AnnotationExprent>> paramAnnotations;
+
+  public void initContent(ConstantPool pool) {
+
+    super.initContent(pool);
+
+    paramAnnotations = new ArrayList<List<AnnotationExprent>>();
+    DataInputStream data = new DataInputStream(new ByteArrayInputStream(info));
+
+    try {
+      int len = data.readUnsignedByte();
+      for (int i = 0; i < len; i++) {
+        List<AnnotationExprent> lst = new ArrayList<AnnotationExprent>();
+        int annsize = data.readUnsignedShort();
+
+        for (int j = 0; j < annsize; j++) {
+          lst.add(StructAnnotationAttribute.parseAnnotation(data, pool));
+        }
+        paramAnnotations.add(lst);
+      }
+    }
+    catch (IOException ex) {
+      throw new RuntimeException(ex);
+    }
+  }
+
+  public List<List<AnnotationExprent>> getParamAnnotations() {
+    return paramAnnotations;
+  }
 }
diff --git a/src/org/jetbrains/java/decompiler/struct/attr/StructAnnotationTypeAttribute.java b/src/org/jetbrains/java/decompiler/struct/attr/StructAnnotationTypeAttribute.java
index 9677ddd..f228ed5 100644
--- a/src/org/jetbrains/java/decompiler/struct/attr/StructAnnotationTypeAttribute.java
+++ b/src/org/jetbrains/java/decompiler/struct/attr/StructAnnotationTypeAttribute.java
@@ -1,188 +1,203 @@
+/*
+ * Copyright 2000-2014 JetBrains s.r.o.
+ *
+ * Licensed 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 org.jetbrains.java.decompiler.struct.attr;
 
+import org.jetbrains.java.decompiler.modules.decompiler.exps.AnnotationExprent;
+import org.jetbrains.java.decompiler.struct.consts.ConstantPool;
+
 import java.io.ByteArrayInputStream;
 import java.io.DataInputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.jetbrains.java.decompiler.modules.decompiler.exps.AnnotationExprent;
-import org.jetbrains.java.decompiler.struct.consts.ConstantPool;
-
 public class StructAnnotationTypeAttribute extends StructGeneralAttribute {
-	
-	public static final int ANNOTATION_TARGET_TYPE_GENERIC_CLASS = 0x00;
-	public static final int ANNOTATION_TARGET_TYPE_GENERIC_METHOD = 0x01;
-	public static final int ANNOTATION_TARGET_TYPE_EXTENDS_IMPLEMENTS = 0x10;
-	public static final int ANNOTATION_TARGET_TYPE_GENERIC_CLASS_BOUND = 0x11;
-	public static final int ANNOTATION_TARGET_TYPE_GENERIC_METHOD_BOUND = 0x12;
-	public static final int ANNOTATION_TARGET_TYPE_FIELD = 0x13;
-	public static final int ANNOTATION_TARGET_TYPE_RETURN = 0x14;
-	public static final int ANNOTATION_TARGET_TYPE_RECEIVER = 0x15;
-	public static final int ANNOTATION_TARGET_TYPE_FORMAL = 0x16;
-	public static final int ANNOTATION_TARGET_TYPE_THROWS = 0x17;
-	public static final int ANNOTATION_TARGET_TYPE_LOCAL_VARIABLE = 0x40;
-	public static final int ANNOTATION_TARGET_TYPE_RESOURCE_VARIABLE = 0x41;
-	public static final int ANNOTATION_TARGET_TYPE_EXCEPTION = 0x42;
-	public static final int ANNOTATION_TARGET_TYPE_INSTANCEOF = 0x43;
-	public static final int ANNOTATION_TARGET_TYPE_NEW = 0x44;
-	public static final int ANNOTATION_TARGET_TYPE_DOUBLECOLON_NEW = 0x45;
-	public static final int ANNOTATION_TARGET_TYPE_DOUBLECOLON_ID = 0x46;
-	public static final int ANNOTATION_TARGET_TYPE_CAST = 0x47;
-	public static final int ANNOTATION_TARGET_TYPE_INVOKATION_CONSTRUCTOR = 0x48;
-	public static final int ANNOTATION_TARGET_TYPE_INVOKATION_METHOD = 0x49;
-	public static final int ANNOTATION_TARGET_TYPE_GENERIC_DOUBLECOLON_NEW = 0x4A;
-	public static final int ANNOTATION_TARGET_TYPE_GENERIC_DOUBLECOLON_ID = 0x4B;
-	
-	public static final int ANNOTATION_TARGET_UNION_TYPE_PARAMETER = 1;
-	public static final int ANNOTATION_TARGET_UNION_SUPERTYPE = 2;
-	public static final int ANNOTATION_TARGET_UNION_TYPE_PARAMETER_BOUND = 3;
-	public static final int ANNOTATION_TARGET_UNION_EMPTY = 4;
-	public static final int ANNOTATION_TARGET_UNION_FORMAL_PARAMETER = 5;
-	public static final int ANNOTATION_TARGET_UNION_THROWS = 6;
-	public static final int ANNOTATION_TARGET_UNION_LOCALVAR = 7;
-	public static final int ANNOTATION_TARGET_UNION_CATCH = 8;
-	public static final int ANNOTATION_TARGET_UNION_OFFSET = 9;
-	public static final int ANNOTATION_TARGET_UNION_TYPE_ARGUMENT = 10;
-	
-
-	List<AnnotationLocation> locations = new ArrayList<AnnotationLocation>();
-	List<AnnotationExprent> annotations = new ArrayList<AnnotationExprent>();
-	
-	public void initContent(ConstantPool pool) {
-
-		super.initContent(pool);
-		
-		DataInputStream data = new DataInputStream(new ByteArrayInputStream(info));
-		
-		try {
-			
-			int ann_number = data.readUnsignedByte();
-			for(int i = 0; i < ann_number; i++) {
-				locations.add(parseAnnotationLocation(data));
-				annotations.add(StructAnnotationAttribute.parseAnnotation(data, pool));
-			}
-			
-		} catch(IOException ex) {
-			throw new RuntimeException(ex);
-		}
-	}
-
-	public AnnotationLocation parseAnnotationLocation(DataInputStream data) throws IOException {
-
-		AnnotationLocation ann_location = new AnnotationLocation();
-		
-		// target type 
-		
-		ann_location.target_type = data.readUnsignedByte();
-		
-		// target union 
-		
-		switch(ann_location.target_type) {
-			case ANNOTATION_TARGET_TYPE_GENERIC_CLASS:
-			case ANNOTATION_TARGET_TYPE_GENERIC_METHOD:
-				ann_location.target_union = ANNOTATION_TARGET_UNION_TYPE_PARAMETER;
-				break;
-			case ANNOTATION_TARGET_TYPE_EXTENDS_IMPLEMENTS:
-				ann_location.target_union = ANNOTATION_TARGET_UNION_SUPERTYPE;
-				break;
-			case ANNOTATION_TARGET_TYPE_GENERIC_CLASS_BOUND:
-			case ANNOTATION_TARGET_TYPE_GENERIC_METHOD_BOUND:
-				ann_location.target_union = ANNOTATION_TARGET_UNION_TYPE_PARAMETER_BOUND;
-				break;
-			case ANNOTATION_TARGET_TYPE_FIELD:
-			case ANNOTATION_TARGET_TYPE_RETURN:
-			case ANNOTATION_TARGET_TYPE_RECEIVER:
-				ann_location.target_union = ANNOTATION_TARGET_UNION_EMPTY;
-				break;
-			case ANNOTATION_TARGET_TYPE_FORMAL:
-				ann_location.target_union = ANNOTATION_TARGET_UNION_FORMAL_PARAMETER;
-				break;
-			case ANNOTATION_TARGET_TYPE_THROWS:
-				ann_location.target_union = ANNOTATION_TARGET_UNION_THROWS;
-				break;
-			case ANNOTATION_TARGET_TYPE_LOCAL_VARIABLE:
-			case ANNOTATION_TARGET_TYPE_RESOURCE_VARIABLE:
-				ann_location.target_union = ANNOTATION_TARGET_UNION_LOCALVAR;
-				break;
-			case ANNOTATION_TARGET_TYPE_EXCEPTION:
-				ann_location.target_union = ANNOTATION_TARGET_UNION_CATCH;
-				break;
-			case ANNOTATION_TARGET_TYPE_INSTANCEOF:
-			case ANNOTATION_TARGET_TYPE_NEW:
-			case ANNOTATION_TARGET_TYPE_DOUBLECOLON_NEW:
-			case ANNOTATION_TARGET_TYPE_DOUBLECOLON_ID:
-				ann_location.target_union = ANNOTATION_TARGET_UNION_OFFSET;
-				break;
-			case ANNOTATION_TARGET_TYPE_CAST:
-			case ANNOTATION_TARGET_TYPE_INVOKATION_CONSTRUCTOR:
-			case ANNOTATION_TARGET_TYPE_INVOKATION_METHOD:
-			case ANNOTATION_TARGET_TYPE_GENERIC_DOUBLECOLON_NEW:
-			case ANNOTATION_TARGET_TYPE_GENERIC_DOUBLECOLON_ID:
-				ann_location.target_union = ANNOTATION_TARGET_UNION_TYPE_ARGUMENT;
-				break;
-			default:
-				throw new RuntimeException("Unknown target type in a type annotation!");
-		}
-		
-		// target union data
-		
-		switch(ann_location.target_union) {
-			case ANNOTATION_TARGET_UNION_TYPE_PARAMETER:
-			case ANNOTATION_TARGET_UNION_FORMAL_PARAMETER:
-				ann_location.data = new int[] {data.readUnsignedByte()};
-				break;
-			case ANNOTATION_TARGET_UNION_SUPERTYPE:
-			case ANNOTATION_TARGET_UNION_THROWS:
-			case ANNOTATION_TARGET_UNION_CATCH:
-			case ANNOTATION_TARGET_UNION_OFFSET:
-				ann_location.data = new int[] {data.readUnsignedShort()};
-				break;
-			case ANNOTATION_TARGET_UNION_TYPE_PARAMETER_BOUND:
-				ann_location.data = new int[] {data.readUnsignedByte(), data.readUnsignedByte()};
-				break;
-			case ANNOTATION_TARGET_UNION_EMPTY:
-				break;
-			case ANNOTATION_TARGET_UNION_LOCALVAR:
-				int table_length = data.readUnsignedShort();
-				
-				ann_location.data = new int[table_length * 3 + 1];
-				ann_location.data[0] = table_length; 
-				
-				for(int i = 0; i < table_length; ++i) {
-					ann_location.data[3 * i + 1] = data.readUnsignedShort();	
-					ann_location.data[3 * i + 2] = data.readUnsignedShort();	
-					ann_location.data[3 * i + 3] = data.readUnsignedShort();	
-				}
-				break;
-			case ANNOTATION_TARGET_UNION_TYPE_ARGUMENT:
-				ann_location.data = new int[] {data.readUnsignedShort(), data.readUnsignedByte()};
-		}
-
-		// target path
-		
-		int path_length = data.readUnsignedByte();
-		
-		ann_location.target_path_kind = new int[path_length];
-		ann_location.target_argument_index = new int[path_length];
-		
-		for(int i = 0; i < path_length; ++i) {
-			ann_location.target_path_kind[i] = data.readUnsignedByte(); 	
-			ann_location.target_argument_index[i] = data.readUnsignedByte(); 	
-		}
-		
-		return ann_location;
-	}
-	
-	private static class AnnotationLocation {
-		
-		public int target_type;
-		public int target_union;
-		
-		public int[] data;
-		
-		public int[] target_path_kind;
-		public int[] target_argument_index;
-	}
+
+  public static final int ANNOTATION_TARGET_TYPE_GENERIC_CLASS = 0x00;
+  public static final int ANNOTATION_TARGET_TYPE_GENERIC_METHOD = 0x01;
+  public static final int ANNOTATION_TARGET_TYPE_EXTENDS_IMPLEMENTS = 0x10;
+  public static final int ANNOTATION_TARGET_TYPE_GENERIC_CLASS_BOUND = 0x11;
+  public static final int ANNOTATION_TARGET_TYPE_GENERIC_METHOD_BOUND = 0x12;
+  public static final int ANNOTATION_TARGET_TYPE_FIELD = 0x13;
+  public static final int ANNOTATION_TARGET_TYPE_RETURN = 0x14;
+  public static final int ANNOTATION_TARGET_TYPE_RECEIVER = 0x15;
+  public static final int ANNOTATION_TARGET_TYPE_FORMAL = 0x16;
+  public static final int ANNOTATION_TARGET_TYPE_THROWS = 0x17;
+  public static final int ANNOTATION_TARGET_TYPE_LOCAL_VARIABLE = 0x40;
+  public static final int ANNOTATION_TARGET_TYPE_RESOURCE_VARIABLE = 0x41;
+  public static final int ANNOTATION_TARGET_TYPE_EXCEPTION = 0x42;
+  public static final int ANNOTATION_TARGET_TYPE_INSTANCEOF = 0x43;
+  public static final int ANNOTATION_TARGET_TYPE_NEW = 0x44;
+  public static final int ANNOTATION_TARGET_TYPE_DOUBLECOLON_NEW = 0x45;
+  public static final int ANNOTATION_TARGET_TYPE_DOUBLECOLON_ID = 0x46;
+  public static final int ANNOTATION_TARGET_TYPE_CAST = 0x47;
+  public static final int ANNOTATION_TARGET_TYPE_INVOKATION_CONSTRUCTOR = 0x48;
+  public static final int ANNOTATION_TARGET_TYPE_INVOKATION_METHOD = 0x49;
+  public static final int ANNOTATION_TARGET_TYPE_GENERIC_DOUBLECOLON_NEW = 0x4A;
+  public static final int ANNOTATION_TARGET_TYPE_GENERIC_DOUBLECOLON_ID = 0x4B;
+
+  public static final int ANNOTATION_TARGET_UNION_TYPE_PARAMETER = 1;
+  public static final int ANNOTATION_TARGET_UNION_SUPERTYPE = 2;
+  public static final int ANNOTATION_TARGET_UNION_TYPE_PARAMETER_BOUND = 3;
+  public static final int ANNOTATION_TARGET_UNION_EMPTY = 4;
+  public static final int ANNOTATION_TARGET_UNION_FORMAL_PARAMETER = 5;
+  public static final int ANNOTATION_TARGET_UNION_THROWS = 6;
+  public static final int ANNOTATION_TARGET_UNION_LOCALVAR = 7;
+  public static final int ANNOTATION_TARGET_UNION_CATCH = 8;
+  public static final int ANNOTATION_TARGET_UNION_OFFSET = 9;
+  public static final int ANNOTATION_TARGET_UNION_TYPE_ARGUMENT = 10;
+
+
+  List<AnnotationLocation> locations = new ArrayList<AnnotationLocation>();
+  List<AnnotationExprent> annotations = new ArrayList<AnnotationExprent>();
+
+  public void initContent(ConstantPool pool) {
+
+    super.initContent(pool);
+
+    DataInputStream data = new DataInputStream(new ByteArrayInputStream(info));
+
+    try {
+
+      int ann_number = data.readUnsignedByte();
+      for (int i = 0; i < ann_number; i++) {
+        locations.add(parseAnnotationLocation(data));
+        annotations.add(StructAnnotationAttribute.parseAnnotation(data, pool));
+      }
+    }
+    catch (IOException ex) {
+      throw new RuntimeException(ex);
+    }
+  }
+
+  public AnnotationLocation parseAnnotationLocation(DataInputStream data) throws IOException {
+
+    AnnotationLocation ann_location = new AnnotationLocation();
+
+    // target type
+
+    ann_location.target_type = data.readUnsignedByte();
+
+    // target union
+
+    switch (ann_location.target_type) {
+      case ANNOTATION_TARGET_TYPE_GENERIC_CLASS:
+      case ANNOTATION_TARGET_TYPE_GENERIC_METHOD:
+        ann_location.target_union = ANNOTATION_TARGET_UNION_TYPE_PARAMETER;
+        break;
+      case ANNOTATION_TARGET_TYPE_EXTENDS_IMPLEMENTS:
+        ann_location.target_union = ANNOTATION_TARGET_UNION_SUPERTYPE;
+        break;
+      case ANNOTATION_TARGET_TYPE_GENERIC_CLASS_BOUND:
+      case ANNOTATION_TARGET_TYPE_GENERIC_METHOD_BOUND:
+        ann_location.target_union = ANNOTATION_TARGET_UNION_TYPE_PARAMETER_BOUND;
+        break;
+      case ANNOTATION_TARGET_TYPE_FIELD:
+      case ANNOTATION_TARGET_TYPE_RETURN:
+      case ANNOTATION_TARGET_TYPE_RECEIVER:
+        ann_location.target_union = ANNOTATION_TARGET_UNION_EMPTY;
+        break;
+      case ANNOTATION_TARGET_TYPE_FORMAL:
+        ann_location.target_union = ANNOTATION_TARGET_UNION_FORMAL_PARAMETER;
+        break;
+      case ANNOTATION_TARGET_TYPE_THROWS:
+        ann_location.target_union = ANNOTATION_TARGET_UNION_THROWS;
+        break;
+      case ANNOTATION_TARGET_TYPE_LOCAL_VARIABLE:
+      case ANNOTATION_TARGET_TYPE_RESOURCE_VARIABLE:
+        ann_location.target_union = ANNOTATION_TARGET_UNION_LOCALVAR;
+        break;
+      case ANNOTATION_TARGET_TYPE_EXCEPTION:
+        ann_location.target_union = ANNOTATION_TARGET_UNION_CATCH;
+        break;
+      case ANNOTATION_TARGET_TYPE_INSTANCEOF:
+      case ANNOTATION_TARGET_TYPE_NEW:
+      case ANNOTATION_TARGET_TYPE_DOUBLECOLON_NEW:
+      case ANNOTATION_TARGET_TYPE_DOUBLECOLON_ID:
+        ann_location.target_union = ANNOTATION_TARGET_UNION_OFFSET;
+        break;
+      case ANNOTATION_TARGET_TYPE_CAST:
+      case ANNOTATION_TARGET_TYPE_INVOKATION_CONSTRUCTOR:
+      case ANNOTATION_TARGET_TYPE_INVOKATION_METHOD:
+      case ANNOTATION_TARGET_TYPE_GENERIC_DOUBLECOLON_NEW:
+      case ANNOTATION_TARGET_TYPE_GENERIC_DOUBLECOLON_ID:
+        ann_location.target_union = ANNOTATION_TARGET_UNION_TYPE_ARGUMENT;
+        break;
+      default:
+        throw new RuntimeException("Unknown target type in a type annotation!");
+    }
+
+    // target union data
+
+    switch (ann_location.target_union) {
+      case ANNOTATION_TARGET_UNION_TYPE_PARAMETER:
+      case ANNOTATION_TARGET_UNION_FORMAL_PARAMETER:
+        ann_location.data = new int[]{data.readUnsignedByte()};
+        break;
+      case ANNOTATION_TARGET_UNION_SUPERTYPE:
+      case ANNOTATION_TARGET_UNION_THROWS:
+      case ANNOTATION_TARGET_UNION_CATCH:
+      case ANNOTATION_TARGET_UNION_OFFSET:
+        ann_location.data = new int[]{data.readUnsignedShort()};
+        break;
+      case ANNOTATION_TARGET_UNION_TYPE_PARAMETER_BOUND:
+        ann_location.data = new int[]{data.readUnsignedByte(), data.readUnsignedByte()};
+        break;
+      case ANNOTATION_TARGET_UNION_EMPTY:
+        break;
+      case ANNOTATION_TARGET_UNION_LOCALVAR:
+        int table_length = data.readUnsignedShort();
+
+        ann_location.data = new int[table_length * 3 + 1];
+        ann_location.data[0] = table_length;
+
+        for (int i = 0; i < table_length; ++i) {
+          ann_location.data[3 * i + 1] = data.readUnsignedShort();
+          ann_location.data[3 * i + 2] = data.readUnsignedShort();
+          ann_location.data[3 * i + 3] = data.readUnsignedShort();
+        }
+        break;
+      case ANNOTATION_TARGET_UNION_TYPE_ARGUMENT:
+        ann_location.data = new int[]{data.readUnsignedShort(), data.readUnsignedByte()};
+    }
+
+    // target path
+
+    int path_length = data.readUnsignedByte();
+
+    ann_location.target_path_kind = new int[path_length];
+    ann_location.target_argument_index = new int[path_length];
+
+    for (int i = 0; i < path_length; ++i) {
+      ann_location.target_path_kind[i] = data.readUnsignedByte();
+      ann_location.target_argument_index[i] = data.readUnsignedByte();
+    }
+
+    return ann_location;
+  }
+
+  private static class AnnotationLocation {
+
+    public int target_type;
+    public int target_union;
+
+    public int[] data;
+
+    public int[] target_path_kind;
+    public int[] target_argument_index;
+  }
 }
 
diff --git a/src/org/jetbrains/java/decompiler/struct/attr/StructBootstrapMethodsAttribute.java b/src/org/jetbrains/java/decompiler/struct/attr/StructBootstrapMethodsAttribute.java
index ac51027..717bad9 100644
--- a/src/org/jetbrains/java/decompiler/struct/attr/StructBootstrapMethodsAttribute.java
+++ b/src/org/jetbrains/java/decompiler/struct/attr/StructBootstrapMethodsAttribute.java
@@ -1,62 +1,75 @@
+/*
+ * Copyright 2000-2014 JetBrains s.r.o.
+ *
+ * Licensed 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 org.jetbrains.java.decompiler.struct.attr;
 
+import org.jetbrains.java.decompiler.struct.consts.ConstantPool;
+import org.jetbrains.java.decompiler.struct.consts.LinkConstant;
+import org.jetbrains.java.decompiler.struct.consts.PooledConstant;
+
 import java.io.ByteArrayInputStream;
 import java.io.DataInputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.jetbrains.java.decompiler.struct.consts.ConstantPool;
-import org.jetbrains.java.decompiler.struct.consts.LinkConstant;
-import org.jetbrains.java.decompiler.struct.consts.PooledConstant;
-
 public class StructBootstrapMethodsAttribute extends StructGeneralAttribute {
-	
-	private List<LinkConstant> method_refs = new ArrayList<LinkConstant>();   
-	private List<List<PooledConstant>> method_arguments = new ArrayList<List<PooledConstant>>();   
-	
-	public void initContent(ConstantPool pool) {
-
-		name = ATTRIBUTE_BOOTSTRAP_METHODS;
-
-		try {
-			
-			DataInputStream data = new DataInputStream(new ByteArrayInputStream(info, 0, info.length));
-	
-			int method_number = data.readUnsignedShort();
-			
-			for(int i = 0; i < method_number; ++i) {
-				int bootstrap_method_ref = data.readUnsignedShort();
-				int num_bootstrap_arguments = data.readUnsignedShort();
-				
-				List<PooledConstant> list_arguments = new ArrayList<PooledConstant>(); 
-				
-				for(int j = 0; j < num_bootstrap_arguments; ++j) {
-					int bootstrap_argument_ref = data.readUnsignedShort();
-					
-					list_arguments.add(pool.getConstant(bootstrap_argument_ref));
-				}
-				
-				method_refs.add(pool.getLinkConstant(bootstrap_method_ref));
-				method_arguments.add(list_arguments);
-			}
-		
-		} catch(IOException ex) {
-			throw new RuntimeException(ex);
-		}
-		
-	}
-
-	public int getMethodsNumber() {
-		return method_refs.size();
-	}
-	
-	public LinkConstant getMethodReference(int index) {
-		return method_refs.get(index);
-	}
-
-	public List<PooledConstant> getMethodArguments(int index) {
-		return method_arguments.get(index);
-	}
-	
+
+  private List<LinkConstant> method_refs = new ArrayList<LinkConstant>();
+  private List<List<PooledConstant>> method_arguments = new ArrayList<List<PooledConstant>>();
+
+  public void initContent(ConstantPool pool) {
+
+    name = ATTRIBUTE_BOOTSTRAP_METHODS;
+
+    try {
+
+      DataInputStream data = new DataInputStream(new ByteArrayInputStream(info, 0, info.length));
+
+      int method_number = data.readUnsignedShort();
+
+      for (int i = 0; i < method_number; ++i) {
+        int bootstrap_method_ref = data.readUnsignedShort();
+        int num_bootstrap_arguments = data.readUnsignedShort();
+
+        List<PooledConstant> list_arguments = new ArrayList<PooledConstant>();
+
+        for (int j = 0; j < num_bootstrap_arguments; ++j) {
+          int bootstrap_argument_ref = data.readUnsignedShort();
+
+          list_arguments.add(pool.getConstant(bootstrap_argument_ref));
+        }
+
+        method_refs.add(pool.getLinkConstant(bootstrap_method_ref));
+        method_arguments.add(list_arguments);
+      }
+    }
+    catch (IOException ex) {
+      throw new RuntimeException(ex);
+    }
+  }
+
+  public int getMethodsNumber() {
+    return method_refs.size();
+  }
+
+  public LinkConstant getMethodReference(int index) {
+    return method_refs.get(index);
+  }
+
+  public List<PooledConstant> getMethodArguments(int index) {
+    return method_arguments.get(index);
+  }
 }
diff --git a/src/org/jetbrains/java/decompiler/struct/attr/StructConstantValueAttribute.java b/src/org/jetbrains/java/decompiler/struct/attr/StructConstantValueAttribute.java
index f186767..ae3bd1d 100644
--- a/src/org/jetbrains/java/decompiler/struct/attr/StructConstantValueAttribute.java
+++ b/src/org/jetbrains/java/decompiler/struct/attr/StructConstantValueAttribute.java
@@ -1,34 +1,33 @@
 /*
- *    Fernflower - The Analytical Java Decompiler
- *    http://www.reversed-java.com
+ * Copyright 2000-2014 JetBrains s.r.o.
  *
- *    (C) 2008 - 2010, Stiver
+ * Licensed 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
  *
- *    This software is NEITHER public domain NOR free software 
- *    as per GNU License. See license.txt for more details.
+ * http://www.apache.org/licenses/LICENSE-2.0
  *
- *    This software is distributed WITHOUT ANY WARRANTY; without 
- *    even the implied warranty of MERCHANTABILITY or FITNESS FOR 
- *    A PARTICULAR PURPOSE. 
+ * 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 org.jetbrains.java.decompiler.struct.attr;
 
 import org.jetbrains.java.decompiler.struct.consts.ConstantPool;
 
 public class StructConstantValueAttribute extends StructGeneralAttribute {
 
-	private int index;
+  private int index;
+
+  public void initContent(ConstantPool pool) {
 
-	public void initContent(ConstantPool pool) {
+    name = ATTRIBUTE_CONSTANT_VALUE;
+    index = ((info[0] & 0xFF) << 8) | (info[1] & 0xFF);
+  }
 
-		name = ATTRIBUTE_CONSTANT_VALUE;
-		index = ((info[0] & 0xFF)<<8) | (info[1] & 0xFF);
-	}
-	
-	public int getIndex() {
-		return index;
-	}
-	
-	
+  public int getIndex() {
+    return index;
+  }
 }
diff --git a/src/org/jetbrains/java/decompiler/struct/attr/StructEnclosingMethodAttribute.java b/src/org/jetbrains/java/decompiler/struct/attr/StructEnclosingMethodAttribute.java
index 61bb886..ebf9407 100644
--- a/src/org/jetbrains/java/decompiler/struct/attr/StructEnclosingMethodAttribute.java
+++ b/src/org/jetbrains/java/decompiler/struct/attr/StructEnclosingMethodAttribute.java
@@ -1,17 +1,18 @@
 /*
- *    Fernflower - The Analytical Java Decompiler
- *    http://www.reversed-java.com
+ * Copyright 2000-2014 JetBrains s.r.o.
  *
- *    (C) 2008 - 2010, Stiver
+ * Licensed 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
  *
- *    This software is NEITHER public domain NOR free software 
- *    as per GNU License. See license.txt for more details.
+ * http://www.apache.org/licenses/LICENSE-2.0
  *
- *    This software is distributed WITHOUT ANY WARRANTY; without 
- *    even the implied warranty of MERCHANTABILITY or FITNESS FOR 
- *    A PARTICULAR PURPOSE. 
+ * 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 org.jetbrains.java.decompiler.struct.attr;
 
 import org.jetbrains.java.decompiler.struct.consts.ConstantPool;
@@ -19,39 +20,37 @@ import org.jetbrains.java.decompiler.struct.consts.LinkConstant;
 
 public class StructEnclosingMethodAttribute extends StructGeneralAttribute {
 
-	private String classname;
-	
-	private String mtname;
-	
-	private String methodDescriptor;
-	
-	public void initContent(ConstantPool pool) {
-
-		name = ATTRIBUTE_ENCLOSING_METHOD;
-
-		int clindex = (((info[0] & 0xFF)<<8) | (info[1] & 0xFF));
-		int mtindex = (((info[2] & 0xFF)<<8) | (info[3] & 0xFF));
-		
-		classname = pool.getPrimitiveConstant(clindex).getString();
-		if(mtindex != 0) {
-			LinkConstant lk = pool.getLinkConstant(mtindex);
-			
-			mtname = lk.elementname;
-			methodDescriptor = lk.descriptor;
-		}
-	}
-
-	public String getClassname() {
-		return classname;
-	}
-
-	public String getMethodDescriptor() {
-		return methodDescriptor;
-	}
-
-	public String getMethodName() {
-		return mtname;
-	}
-	
-	
+  private String classname;
+
+  private String mtname;
+
+  private String methodDescriptor;
+
+  public void initContent(ConstantPool pool) {
+
+    name = ATTRIBUTE_ENCLOSING_METHOD;
+
+    int clindex = (((info[0] & 0xFF) << 8) | (info[1] & 0xFF));
+    int mtindex = (((info[2] & 0xFF) << 8) | (info[3] & 0xFF));
+
+    classname = pool.getPrimitiveConstant(clindex).getString();
+    if (mtindex != 0) {
+      LinkConstant lk = pool.getLinkConstant(mtindex);
+
+      mtname = lk.elementname;
+      methodDescriptor = lk.descriptor;
+    }
+  }
+
+  public String getClassname() {
+    return classname;
+  }
+
+  public String getMethodDescriptor() {
+    return methodDescriptor;
+  }
+
+  public String getMethodName() {
+    return mtname;
+  }
 }
diff --git a/src/org/jetbrains/java/decompiler/struct/attr/StructExceptionsAttribute.java b/src/org/jetbrains/java/decompiler/struct/attr/StructExceptionsAttribute.java
index 4d6bd4c..930db78 100644
--- a/src/org/jetbrains/java/decompiler/struct/attr/StructExceptionsAttribute.java
+++ b/src/org/jetbrains/java/decompiler/struct/attr/StructExceptionsAttribute.java
@@ -1,78 +1,76 @@
 /*
- *    Fernflower - The Analytical Java Decompiler
- *    http://www.reversed-java.com
+ * Copyright 2000-2014 JetBrains s.r.o.
  *
- *    (C) 2008 - 2010, Stiver
+ * Licensed 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
  *
- *    This software is NEITHER public domain NOR free software 
- *    as per GNU License. See license.txt for more details.
+ * http://www.apache.org/licenses/LICENSE-2.0
  *
- *    This software is distributed WITHOUT ANY WARRANTY; without 
- *    even the implied warranty of MERCHANTABILITY or FITNESS FOR 
- *    A PARTICULAR PURPOSE. 
+ * 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 org.jetbrains.java.decompiler.struct.attr;
 
+import org.jetbrains.java.decompiler.struct.consts.ConstantPool;
+
 import java.io.ByteArrayOutputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.jetbrains.java.decompiler.struct.consts.ConstantPool;
-
 public class StructExceptionsAttribute extends StructGeneralAttribute {
 
-	private List<Integer> throwsExceptions = new ArrayList<Integer>(); 
-	
-	public void initContent(ConstantPool pool) {
-		
-		name = ATTRIBUTE_EXCEPTIONS;
-
-		int length = 2+(((info[0] & 0xFF)<<8) | (info[1] & 0xFF))*2;
-		for(int i=2;i<length;i+=2) {
-			int index = ((info[i] & 0xFF)<<8) | (info[i+1] & 0xFF);
-			throwsExceptions.add(index);
-		}
-		
-	}
-
-	public void writeToStream(DataOutputStream out) throws IOException {
-		
-		out.writeShort(attribute_name_index);
-		
-		ByteArrayOutputStream codeout = new ByteArrayOutputStream();
-		DataOutputStream dataout = new DataOutputStream(codeout);
-		
-		int len = throwsExceptions.size();
-		dataout.writeShort(len);
-
-		if(len>0) {
-			info = new byte[len*2];
-			for(int i=0,j=0;i<len;i++,j+=2) {
-				int index = ((Integer)throwsExceptions.get(i)).intValue(); 
-				info[j] = (byte)(index >> 8);
-				info[j+1] = (byte)(index & 0xFF);
-			}
-			dataout.write(info);
-		}
-		
-		out.writeInt(codeout.size());
-		out.write(codeout.toByteArray());
-	}
-	
-	public String getExcClassname(int index, ConstantPool pool) {
-		return pool.getPrimitiveConstant(((Integer)throwsExceptions.get(index)).intValue()).getString(); 
-	}
-
-	public List<Integer> getThrowsExceptions() {
-		return throwsExceptions;
-	}
-
-	public void setThrowsExceptions(List<Integer> throwsExceptions) {
-		this.throwsExceptions = throwsExceptions;
-	}
-	
-	
+  private List<Integer> throwsExceptions = new ArrayList<Integer>();
+
+  public void initContent(ConstantPool pool) {
+
+    name = ATTRIBUTE_EXCEPTIONS;
+
+    int length = 2 + (((info[0] & 0xFF) << 8) | (info[1] & 0xFF)) * 2;
+    for (int i = 2; i < length; i += 2) {
+      int index = ((info[i] & 0xFF) << 8) | (info[i + 1] & 0xFF);
+      throwsExceptions.add(index);
+    }
+  }
+
+  public void writeToStream(DataOutputStream out) throws IOException {
+
+    out.writeShort(attribute_name_index);
+
+    ByteArrayOutputStream codeout = new ByteArrayOutputStream();
+    DataOutputStream dataout = new DataOutputStream(codeout);
+
+    int len = throwsExceptions.size();
+    dataout.writeShort(len);
+
+    if (len > 0) {
+      info = new byte[len * 2];
+      for (int i = 0, j = 0; i < len; i++, j += 2) {
+        int index = ((Integer)throwsExceptions.get(i)).intValue();
+        info[j] = (byte)(index >> 8);
+        info[j + 1] = (byte)(index & 0xFF);
+      }
+      dataout.write(info);
+    }
+
+    out.writeInt(codeout.size());
+    out.write(codeout.toByteArray());
+  }
+
+  public String getExcClassname(int index, ConstantPool pool) {
+    return pool.getPrimitiveConstant(((Integer)throwsExceptions.get(index)).intValue()).getString();
+  }
+
+  public List<Integer> getThrowsExceptions() {
+    return throwsExceptions;
+  }
+
+  public void setThrowsExceptions(List<Integer> throwsExceptions) {
+    this.throwsExceptions = throwsExceptions;
+  }
 }
diff --git a/src/org/jetbrains/java/decompiler/struct/attr/StructGeneralAttribute.java b/src/org/jetbrains/java/decompiler/struct/attr/StructGeneralAttribute.java
index 2648b3c..bd0596a 100644
--- a/src/org/jetbrains/java/decompiler/struct/attr/StructGeneralAttribute.java
+++ b/src/org/jetbrains/java/decompiler/struct/attr/StructGeneralAttribute.java
@@ -1,24 +1,25 @@
 /*
- *    Fernflower - The Analytical Java Decompiler
- *    http://www.reversed-java.com
+ * Copyright 2000-2014 JetBrains s.r.o.
  *
- *    (C) 2008 - 2010, Stiver
+ * Licensed 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
  *
- *    This software is NEITHER public domain NOR free software 
- *    as per GNU License. See license.txt for more details.
+ * http://www.apache.org/licenses/LICENSE-2.0
  *
- *    This software is distributed WITHOUT ANY WARRANTY; without 
- *    even the implied warranty of MERCHANTABILITY or FITNESS FOR 
- *    A PARTICULAR PURPOSE. 
+ * 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 org.jetbrains.java.decompiler.struct.attr;
 
+import org.jetbrains.java.decompiler.struct.consts.ConstantPool;
+
 import java.io.DataOutputStream;
 import java.io.IOException;
 
-import org.jetbrains.java.decompiler.struct.consts.ConstantPool;
-
 /*
     attribute_info {
     	u2 attribute_name_index;
@@ -29,117 +30,128 @@ import org.jetbrains.java.decompiler.struct.consts.ConstantPool;
 
 public class StructGeneralAttribute {
 
-	public static final String ATTRIBUTE_CODE = "Code";
-	public static final String ATTRIBUTE_INNER_CLASSES = "InnerClasses";
-	public static final String ATTRIBUTE_SIGNATURE = "Signature";
-	public static final String ATTRIBUTE_ANNOTATION_DEFAULT = "AnnotationDefault";
-	public static final String ATTRIBUTE_EXCEPTIONS = "Exceptions";
-	public static final String ATTRIBUTE_ENCLOSING_METHOD = "EnclosingMethod";
-	public static final String ATTRIBUTE_RUNTIME_VISIBLE_ANNOTATIONS = "RuntimeVisibleAnnotations";
-	public static final String ATTRIBUTE_RUNTIME_INVISIBLE_ANNOTATIONS = "RuntimeInvisibleAnnotations";
-	public static final String ATTRIBUTE_RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS = "RuntimeVisibleParameterAnnotations";
-	public static final String ATTRIBUTE_RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS = "RuntimeInvisibleParameterAnnotations";
-	public static final String ATTRIBUTE_RUNTIME_VISIBLE_TYPE_ANNOTATIONS = "RuntimeVisibleTypeAnnotations";
-	public static final String ATTRIBUTE_RUNTIME_INVISIBLE_TYPE_ANNOTATIONS = "RuntimeInvisibleTypeAnnotations";
-	public static final String ATTRIBUTE_LOCAL_VARIABLE_TABLE = "LocalVariableTable";
-	public static final String ATTRIBUTE_CONSTANT_VALUE = "ConstantValue";
-	public static final String ATTRIBUTE_BOOTSTRAP_METHODS = "BootstrapMethods";
+  public static final String ATTRIBUTE_CODE = "Code";
+  public static final String ATTRIBUTE_INNER_CLASSES = "InnerClasses";
+  public static final String ATTRIBUTE_SIGNATURE = "Signature";
+  public static final String ATTRIBUTE_ANNOTATION_DEFAULT = "AnnotationDefault";
+  public static final String ATTRIBUTE_EXCEPTIONS = "Exceptions";
+  public static final String ATTRIBUTE_ENCLOSING_METHOD = "EnclosingMethod";
+  public static final String ATTRIBUTE_RUNTIME_VISIBLE_ANNOTATIONS = "RuntimeVisibleAnnotations";
+  public static final String ATTRIBUTE_RUNTIME_INVISIBLE_ANNOTATIONS = "RuntimeInvisibleAnnotations";
+  public static final String ATTRIBUTE_RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS = "RuntimeVisibleParameterAnnotations";
+  public static final String ATTRIBUTE_RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS = "RuntimeInvisibleParameterAnnotations";
+  public static final String ATTRIBUTE_RUNTIME_VISIBLE_TYPE_ANNOTATIONS = "RuntimeVisibleTypeAnnotations";
+  public static final String ATTRIBUTE_RUNTIME_INVISIBLE_TYPE_ANNOTATIONS = "RuntimeInvisibleTypeAnnotations";
+  public static final String ATTRIBUTE_LOCAL_VARIABLE_TABLE = "LocalVariableTable";
+  public static final String ATTRIBUTE_CONSTANT_VALUE = "ConstantValue";
+  public static final String ATTRIBUTE_BOOTSTRAP_METHODS = "BootstrapMethods";
   public static final String ATTRIBUTE_SYNTHETIC = "Synthetic";
   public static final String ATTRIBUTE_DEPRECATED = "Deprecated";
 
 
-	// *****************************************************************************
-	// private fields
-	// *****************************************************************************
-
-	protected int attribute_name_index;
-	
-	protected byte[] info;
-	
-	protected String name;
-
-	// *****************************************************************************
-	// public methods
-	// *****************************************************************************
-	
-	public void writeToStream(DataOutputStream out) throws IOException {
-		out.writeShort(attribute_name_index);
-		out.writeInt(info.length);
-		if(info.length>0) {
-			out.write(info);
-		}
-	}
-	
-	public void initContent(ConstantPool pool) {
-		name = pool.getPrimitiveConstant(attribute_name_index).getString();
-	}
-	
-	public static StructGeneralAttribute getMatchingAttributeInstance(int nameindex, String attrname) {
-		
-		StructGeneralAttribute attr; 
-		
-		if(ATTRIBUTE_INNER_CLASSES.equals(attrname)) {
-			attr = new StructInnerClassesAttribute();
-		} else if(ATTRIBUTE_CONSTANT_VALUE.equals(attrname)) {
-			attr = new StructConstantValueAttribute();
-		} else if(ATTRIBUTE_SIGNATURE.equals(attrname)) {
-			attr = new StructGenericSignatureAttribute();
-		} else if(ATTRIBUTE_ANNOTATION_DEFAULT.equals(attrname)) {
-			attr = new StructAnnDefaultAttribute();
-		} else if(ATTRIBUTE_EXCEPTIONS.equals(attrname)) {
-			attr = new StructExceptionsAttribute();
-		} else if(ATTRIBUTE_ENCLOSING_METHOD.equals(attrname)) {
-			attr = new StructEnclosingMethodAttribute();
-		} else if(ATTRIBUTE_RUNTIME_VISIBLE_ANNOTATIONS.equals(attrname) ||
-				ATTRIBUTE_RUNTIME_INVISIBLE_ANNOTATIONS.equals(attrname)) {
-			attr = new StructAnnotationAttribute();
-		} else if(ATTRIBUTE_RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS.equals(attrname) ||
-				ATTRIBUTE_RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS.equals(attrname)) {
-			attr = new StructAnnotationParameterAttribute();
-		} else if(ATTRIBUTE_RUNTIME_VISIBLE_TYPE_ANNOTATIONS.equals(attrname) ||
-				ATTRIBUTE_RUNTIME_INVISIBLE_TYPE_ANNOTATIONS.equals(attrname)) {
-			attr = new StructAnnotationTypeAttribute();
-		} else if(ATTRIBUTE_LOCAL_VARIABLE_TABLE.equals(attrname)) {
-			attr = new StructLocalVariableTableAttribute();
-		} else if(ATTRIBUTE_BOOTSTRAP_METHODS.equals(attrname)) {
-			attr = new StructBootstrapMethodsAttribute();
-		} else if(ATTRIBUTE_SYNTHETIC.equals(attrname) || ATTRIBUTE_DEPRECATED.equals(attrname)) {
-			attr = new StructGeneralAttribute();
-		} else {
-			// unsupported attribute
-			return null;
-		}
-		
-		attr.setAttribute_name_index(nameindex);
-		return attr;
-	}
-	
-	// *****************************************************************************
-	// getter and setter methods
-	// *****************************************************************************
-	
-	public byte[] getInfo() {
-		return info;
-	}
-
-	public void setInfo(byte[] info) {
-		this.info = info;
-	} 
-	
-	public String getName() {
-		return name;
-	}
-
-	public void setName(String name) {
-		this.name = name;
-	}
-
-	public int getAttribute_name_index() {
-		return attribute_name_index;
-	}
-
-	public void setAttribute_name_index(int attribute_name_index) {
-		this.attribute_name_index = attribute_name_index;
-	}
-	
+  // *****************************************************************************
+  // private fields
+  // *****************************************************************************
+
+  protected int attribute_name_index;
+
+  protected byte[] info;
+
+  protected String name;
+
+  // *****************************************************************************
+  // public methods
+  // *****************************************************************************
+
+  public void writeToStream(DataOutputStream out) throws IOException {
+    out.writeShort(attribute_name_index);
+    out.writeInt(info.length);
+    if (info.length > 0) {
+      out.write(info);
+    }
+  }
+
+  public void initContent(ConstantPool pool) {
+    name = pool.getPrimitiveConstant(attribute_name_index).getString();
+  }
+
+  public static StructGeneralAttribute getMatchingAttributeInstance(int nameindex, String attrname) {
+
+    StructGeneralAttribute attr;
+
+    if (ATTRIBUTE_INNER_CLASSES.equals(attrname)) {
+      attr = new StructInnerClassesAttribute();
+    }
+    else if (ATTRIBUTE_CONSTANT_VALUE.equals(attrname)) {
+      attr = new StructConstantValueAttribute();
+    }
+    else if (ATTRIBUTE_SIGNATURE.equals(attrname)) {
+      attr = new StructGenericSignatureAttribute();
+    }
+    else if (ATTRIBUTE_ANNOTATION_DEFAULT.equals(attrname)) {
+      attr = new StructAnnDefaultAttribute();
+    }
+    else if (ATTRIBUTE_EXCEPTIONS.equals(attrname)) {
+      attr = new StructExceptionsAttribute();
+    }
+    else if (ATTRIBUTE_ENCLOSING_METHOD.equals(attrname)) {
+      attr = new StructEnclosingMethodAttribute();
+    }
+    else if (ATTRIBUTE_RUNTIME_VISIBLE_ANNOTATIONS.equals(attrname) ||
+             ATTRIBUTE_RUNTIME_INVISIBLE_ANNOTATIONS.equals(attrname)) {
+      attr = new StructAnnotationAttribute();
+    }
+    else if (ATTRIBUTE_RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS.equals(attrname) ||
+             ATTRIBUTE_RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS.equals(attrname)) {
+      attr = new StructAnnotationParameterAttribute();
+    }
+    else if (ATTRIBUTE_RUNTIME_VISIBLE_TYPE_ANNOTATIONS.equals(attrname) ||
+             ATTRIBUTE_RUNTIME_INVISIBLE_TYPE_ANNOTATIONS.equals(attrname)) {
+      attr = new StructAnnotationTypeAttribute();
+    }
+    else if (ATTRIBUTE_LOCAL_VARIABLE_TABLE.equals(attrname)) {
+      attr = new StructLocalVariableTableAttribute();
+    }
+    else if (ATTRIBUTE_BOOTSTRAP_METHODS.equals(attrname)) {
+      attr = new StructBootstrapMethodsAttribute();
+    }
+    else if (ATTRIBUTE_SYNTHETIC.equals(attrname) || ATTRIBUTE_DEPRECATED.equals(attrname)) {
+      attr = new StructGeneralAttribute();
+    }
+    else {
+      // unsupported attribute
+      return null;
+    }
+
+    attr.setAttribute_name_index(nameindex);
+    return attr;
+  }
+
+  // *****************************************************************************
+  // getter and setter methods
+  // *****************************************************************************
+
+  public byte[] getInfo() {
+    return info;
+  }
+
+  public void setInfo(byte[] info) {
+    this.info = info;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public int getAttribute_name_index() {
+    return attribute_name_index;
+  }
+
+  public void setAttribute_name_index(int attribute_name_index) {
+    this.attribute_name_index = attribute_name_index;
+  }
 }
diff --git a/src/org/jetbrains/java/decompiler/struct/attr/StructGenericSignatureAttribute.java b/src/org/jetbrains/java/decompiler/struct/attr/StructGenericSignatureAttribute.java
index 11206e0..6f2224c 100644
--- a/src/org/jetbrains/java/decompiler/struct/attr/StructGenericSignatureAttribute.java
+++ b/src/org/jetbrains/java/decompiler/struct/attr/StructGenericSignatureAttribute.java
@@ -1,34 +1,33 @@
 /*
- *    Fernflower - The Analytical Java Decompiler
- *    http://www.reversed-java.com
+ * Copyright 2000-2014 JetBrains s.r.o.
  *
- *    (C) 2008 - 2010, Stiver
+ * Licensed 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
  *
- *    This software is NEITHER public domain NOR free software 
- *    as per GNU License. See license.txt for more details.
+ * http://www.apache.org/licenses/LICENSE-2.0
  *
- *    This software is distributed WITHOUT ANY WARRANTY; without 
- *    even the implied warranty of MERCHANTABILITY or FITNESS FOR 
- *    A PARTICULAR PURPOSE. 
+ * 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 org.jetbrains.java.decompiler.struct.attr;
 
 import org.jetbrains.java.decompiler.struct.consts.ConstantPool;
 
 public class StructGenericSignatureAttribute extends StructGeneralAttribute {
 
-	private String signature;
+  private String signature;
+
+  public void initContent(ConstantPool pool) {
 
-	public void initContent(ConstantPool pool) {
+    name = ATTRIBUTE_SIGNATURE;
+    signature = pool.getPrimitiveConstant(((info[0] & 0xFF) << 8) | (info[1] & 0xFF)).getString();
+  }
 
-		name = ATTRIBUTE_SIGNATURE;
-		signature = pool.getPrimitiveConstant(((info[0] & 0xFF)<<8) | (info[1] & 0xFF)).getString();
-	}
-	
-	public String getSignature() {
-		return signature;
-	}
-	
-	
+  public String getSignature() {
+    return signature;
+  }
 }
diff --git a/src/org/jetbrains/java/decompiler/struct/attr/StructInnerClassesAttribute.java b/src/org/jetbrains/java/decompiler/struct/attr/StructInnerClassesAttribute.java
index 794da15..14ecd36 100644
--- a/src/org/jetbrains/java/decompiler/struct/attr/StructInnerClassesAttribute.java
+++ b/src/org/jetbrains/java/decompiler/struct/attr/StructInnerClassesAttribute.java
@@ -1,73 +1,72 @@
 /*
- *    Fernflower - The Analytical Java Decompiler
- *    http://www.reversed-java.com
+ * Copyright 2000-2014 JetBrains s.r.o.
  *
- *    (C) 2008 - 2010, Stiver
+ * Licensed 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
  *
- *    This software is NEITHER public domain NOR free software 
- *    as per GNU License. See license.txt for more details.
+ * http://www.apache.org/licenses/LICENSE-2.0
  *
- *    This software is distributed WITHOUT ANY WARRANTY; without 
- *    even the implied warranty of MERCHANTABILITY or FITNESS FOR 
- *    A PARTICULAR PURPOSE. 
+ * 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 org.jetbrains.java.decompiler.struct.attr;
 
+import org.jetbrains.java.decompiler.struct.consts.ConstantPool;
+
 import java.util.ArrayList;
 import java.util.List;
 
-import org.jetbrains.java.decompiler.struct.consts.ConstantPool;
-
 public class StructInnerClassesAttribute extends StructGeneralAttribute {
 
-	private List<int[]> classentries = new ArrayList<int[]>(); 
-
-	private List<String[]> stringentries = new ArrayList<String[]>(); 
-	
-	public void initContent(ConstantPool pool) {
-		
-		name = ATTRIBUTE_INNER_CLASSES;
-
-		int length = 2+(((info[0] & 0xFF)<<8) | (info[1] & 0xFF))*8;
-		int i=2;
-		
-		while(i<length) {
-			
-			int[] arr = new int[4];
-			for(int j=0;j<4;j++) {
-				arr[j] = ((info[i] & 0xFF)<<8) | (info[i+1] & 0xFF);
-				i+=2;
-			}
-
-			classentries.add(arr);
-		}
-		
-		for(int[] entry: classentries) {
-			
-			String[] arr = new String[3];
-			// inner name
-			arr[0] = pool.getPrimitiveConstant(entry[0]).getString();
-			//enclosing class
-			if(entry[1] != 0) {
-				arr[1] = pool.getPrimitiveConstant(entry[1]).getString();
-			} 
-			// original simple name
-			if(entry[2]!=0) {
-				arr[2] = pool.getPrimitiveConstant(entry[2]).getString();
-			}
-			
-			stringentries.add(arr);
-		}
-		
-	}
-
-	public List<int[]> getClassentries() {
-		return classentries;
-	}
-
-	public List<String[]> getStringentries() {
-		return stringentries;
-	}
+  private List<int[]> classentries = new ArrayList<int[]>();
+
+  private List<String[]> stringentries = new ArrayList<String[]>();
+
+  public void initContent(ConstantPool pool) {
+
+    name = ATTRIBUTE_INNER_CLASSES;
+
+    int length = 2 + (((info[0] & 0xFF) << 8) | (info[1] & 0xFF)) * 8;
+    int i = 2;
+
+    while (i < length) {
+
+      int[] arr = new int[4];
+      for (int j = 0; j < 4; j++) {
+        arr[j] = ((info[i] & 0xFF) << 8) | (info[i + 1] & 0xFF);
+        i += 2;
+      }
+
+      classentries.add(arr);
+    }
+
+    for (int[] entry : classentries) {
+
+      String[] arr = new String[3];
+      // inner name
+      arr[0] = pool.getPrimitiveConstant(entry[0]).getString();
+      //enclosing class
+      if (entry[1] != 0) {
+        arr[1] = pool.getPrimitiveConstant(entry[1]).getString();
+      }
+      // original simple name
+      if (entry[2] != 0) {
+        arr[2] = pool.getPrimitiveConstant(entry[2]).getString();
+      }
+
+      stringentries.add(arr);
+    }
+  }
+
+  public List<int[]> getClassentries() {
+    return classentries;
+  }
 
+  public List<String[]> getStringentries() {
+    return stringentries;
+  }
 }
diff --git a/src/org/jetbrains/java/decompiler/struct/attr/StructLocalVariableTableAttribute.java b/src/org/jetbrains/java/decompiler/struct/attr/StructLocalVariableTableAttribute.java
index 119d1ff..0cf2a89 100644
--- a/src/org/jetbrains/java/decompiler/struct/attr/StructLocalVariableTableAttribute.java
+++ b/src/org/jetbrains/java/decompiler/struct/attr/StructLocalVariableTableAttribute.java
@@ -1,47 +1,48 @@
 /*
- *    Fernflower - The Analytical Java Decompiler
- *    http://www.reversed-java.com
+ * Copyright 2000-2014 JetBrains s.r.o.
  *
- *    (C) 2008 - 2010, Stiver
+ * Licensed 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
  *
- *    This software is NEITHER public domain NOR free software 
- *    as per GNU License. See license.txt for more details.
+ * http://www.apache.org/licenses/LICENSE-2.0
  *
- *    This software is distributed WITHOUT ANY WARRANTY; without 
- *    even the implied warranty of MERCHANTABILITY or FITNESS FOR 
- *    A PARTICULAR PURPOSE. 
+ * 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 org.jetbrains.java.decompiler.struct.attr;
 
-import java.util.HashMap;
-
 import org.jetbrains.java.decompiler.struct.consts.ConstantPool;
 
+import java.util.HashMap;
+
 public class StructLocalVariableTableAttribute extends StructGeneralAttribute {
 
-	private HashMap<Integer, String> mapVarNames = new HashMap<Integer, String>();
-	
-	public void initContent(ConstantPool pool) {
-
-		name = ATTRIBUTE_LOCAL_VARIABLE_TABLE;
-
-		int len = ((info[0] & 0xFF)<<8) | (info[1] & 0xFF);
-		
-		int ind = 6; 
-		for(int i=0;i<len;i++, ind+=10) {
-			int nindex = ((info[ind] & 0xFF)<<8) | (info[ind+1] & 0xFF);
-			int vindex = ((info[ind+4] & 0xFF)<<8) | (info[ind+5] & 0xFF);
-			
-			mapVarNames.put(vindex, pool.getPrimitiveConstant(nindex).getString());
-		}
-	}
-
-	public void addLocalVariableTable(StructLocalVariableTableAttribute attr) {
-		mapVarNames.putAll(attr.getMapVarNames());
-	}
-	
-	public HashMap<Integer, String> getMapVarNames() {
-		return mapVarNames;
-	}
+  private HashMap<Integer, String> mapVarNames = new HashMap<Integer, String>();
+
+  public void initContent(ConstantPool pool) {
+
+    name = ATTRIBUTE_LOCAL_VARIABLE_TABLE;
+
+    int len = ((info[0] & 0xFF) << 8) | (info[1] & 0xFF);
+
+    int ind = 6;
+    for (int i = 0; i < len; i++, ind += 10) {
+      int nindex = ((info[ind] & 0xFF) << 8) | (info[ind + 1] & 0xFF);
+      int vindex = ((info[ind + 4] & 0xFF) << 8) | (info[ind + 5] & 0xFF);
+
+      mapVarNames.put(vindex, pool.getPrimitiveConstant(nindex).getString());
+    }
+  }
+
+  public void addLocalVariableTable(StructLocalVariableTableAttribute attr) {
+    mapVarNames.putAll(attr.getMapVarNames());
+  }
+
+  public HashMap<Integer, String> getMapVarNames() {
+    return mapVarNames;
+  }
 }