modules/pack200/src/main/java/org/apache/harmony/pack200/PackingOptions.java - harmony-classlib - Git at Google

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You under the Apache License, Version 2.0
  *  (the "License"); you may not use this file except in compliance with
  *  the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
 package org.apache.harmony.pack200;

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

 import org.objectweb.asm.Attribute;

 /**
  * Utility class to manage the various options available for pack200
  */
 public class PackingOptions {

     public static final String STRIP = "strip";
     public static final String ERROR = "error";
     public static final String PASS = "pass";
     public static final String KEEP = "keep";

     // All options are initially set to their defaults
     private boolean repack = false;
     private boolean gzip = true;
     private boolean stripDebug = false;
     private boolean keepFileOrder = true;
     private long segmentLimit = 1000000L;
     private int effort = 5;
     private String deflateHint = KEEP;
     private String modificationTime = KEEP;
     private List passFiles;
     private String unknownAttributeAction = PASS;
     private Map classAttributeActions;
     private Map fieldAttributeActions;
     private Map methodAttributeActions;
     private Map codeAttributeActions;
     private boolean verbose = false;
     private boolean quiet = true;
     private String logFile;

     private Attribute[] unknownAttributeTypes;

     public boolean isRepack() {
         return repack;
     }

     public void setRepack(boolean repack) {
         this.repack = repack;
     }

     public boolean isGzip() {
         return gzip;
     }

     public void setGzip(boolean gzip) {
         this.gzip = gzip;
     }

     public boolean isStripDebug() {
         return stripDebug;
     }

     /**
      * Set strip debug attributes. If true, all debug attributes (i.e.
      * LineNumberTable, SourceFile, LocalVariableTable and
      * LocalVariableTypeTable attributes) are stripped when reading the input
      * class files and not included in the output archive.
      *
      * @param stripDebug
      */
     public void setStripDebug(boolean stripDebug) {
         this.stripDebug = stripDebug;
     }

     public boolean isKeepFileOrder() {
         return keepFileOrder;
     }

     public void setKeepFileOrder(boolean keepFileOrder) {
         this.keepFileOrder = keepFileOrder;
     }

     public long getSegmentLimit() {
         return segmentLimit;
     }

     /**
      * Set the segment limit (equivalent to -S command line option)
      * @param segmentLimit - the limit in bytes
      */
     public void setSegmentLimit(long segmentLimit) {
         this.segmentLimit = segmentLimit;
     }

     public int getEffort() {
         return effort;
     }

     /**
      * Set the compression effort level (0-9, equivalent to -E command line option)
      * @param effort
      */
     public void setEffort(int effort) {
         this.effort = effort;
     }

     public String getDeflateHint() {
         return deflateHint;
     }

     public boolean isKeepDeflateHint() {
         return KEEP.equals(deflateHint);
     }

     public void setDeflateHint(String deflateHint) {
         this.deflateHint = deflateHint;
     }

     public String getModificationTime() {
         return modificationTime;
     }

     public void setModificationTime(String modificationTime) {
         if (!KEEP.equals(modificationTime)
                 && !"latest".equals(modificationTime)) {
             throw new IllegalArgumentException(
                     "Bad argument: -m "
                             + modificationTime
                             + " ? transmit modtimes should be either latest or keep (default)");
         }
         this.modificationTime = modificationTime;
     }

     public boolean isPassFile(String passFileName) {
         if (passFiles != null) {
             for (Iterator iterator = passFiles.iterator(); iterator.hasNext();) {
                 String pass = (String) iterator.next();
                 if (passFileName.equals(pass)) {
                     return true;
                 } else if (!pass.endsWith(".class")) { // a whole directory is
                     // passed
                     if (!pass.endsWith("/")) {
                         // Make sure we don't get any false positives (e.g.
                         // exclude "org/apache/harmony/pack" should not match
                         // files under "org/apache/harmony/pack200/")
                         pass = pass + "/";
                     }
                     return passFileName.startsWith(pass);
                 }
             }
         }
         return false;
     }

     /**
      * Tell the compressor to pass the file with the given name, or if the name
      * is a directory name all files under that directory will be passed.
      *
      * @param passFileName
      *            the file name
      */
     public void addPassFile(String passFileName) {
         if(passFiles == null) {
             passFiles = new ArrayList();
         }
         String fileSeparator = System.getProperty("file.separator");
         if(fileSeparator.equals("\\")) {
             // Need to escape backslashes for replaceAll(), which uses regex
             fileSeparator += "\\";
         }
         passFileName = passFileName.replaceAll(fileSeparator, "/");
         passFiles.add(passFileName);
     }

     public void removePassFile(String passFileName) {
         passFiles.remove(passFileName);
     }

     public String getUnknownAttributeAction() {
         return unknownAttributeAction;
     }

     /**
      * Tell the compressor what to do if an unknown attribute is encountered
      * @param unknownAttributeAction - the action to perform
      */
     public void setUnknownAttributeAction(String unknownAttributeAction) {
         this.unknownAttributeAction = unknownAttributeAction;
         if (!PASS.equals(unknownAttributeAction)
                 && !ERROR.equals(unknownAttributeAction)
                 && !STRIP.equals(unknownAttributeAction)) {
             throw new RuntimeException("Incorrect option for -U, "
                     + unknownAttributeAction);
         }
     }

     public Map getClassAttributeActions() {
         return classAttributeActions;
     }

     public void addClassAttributeAction(String attributeName, String action) {
         if(classAttributeActions == null) {
             classAttributeActions = new HashMap();
         }
         classAttributeActions.put(attributeName, action);
     }

     public Map getFieldAttributeActions() {
         return fieldAttributeActions;
     }

     public void addFieldAttributeAction(String attributeName, String action) {
         if(fieldAttributeActions == null) {
             fieldAttributeActions = new HashMap();
         }
         fieldAttributeActions.put(attributeName, action);
     }

     public Map getMethodAttributeActions() {
         return methodAttributeActions;
     }

     public void addMethodAttributeAction(String attributeName, String action) {
         if(methodAttributeActions == null) {
             methodAttributeActions = new HashMap();
         }
         methodAttributeActions.put(attributeName, action);
     }

     public Map getCodeAttributeActions() {
         return codeAttributeActions;
     }

     public void addCodeAttributeAction(String attributeName, String action) {
         if(codeAttributeActions == null) {
             codeAttributeActions = new HashMap();
         }
         codeAttributeActions.put(attributeName, action);
     }

     public boolean isVerbose() {
         return verbose;
     }

     public void setVerbose(boolean verbose) {
         this.verbose = verbose;
     }

     public boolean isQuiet() {
         return quiet;
     }

     public void setQuiet(boolean quiet) {
         this.quiet = quiet;
     }

     public String getLogFile() {
         return logFile;
     }

     public void setLogFile(String logFile) {
         this.logFile = logFile;
     }

     private void addOrUpdateAttributeActions(List prototypes, Map attributeActions,
             int tag) {
         if (attributeActions != null) {
             if (attributeActions.size() > 0) {
                 String name, action;
                 boolean prototypeExists;
                 NewAttribute newAttribute;
                 for (Iterator iteratorI = attributeActions.keySet().iterator(); iteratorI
                         .hasNext();) {
                     name = (String) iteratorI.next();
                     action = (String) attributeActions.get(name);
                     if (!ERROR.equals(action) && !STRIP.equals(action)
                             && !PASS.equals(action)) {
                         prototypeExists = false;
                         for (Iterator iteratorJ = prototypes.iterator(); iteratorJ
                                 .hasNext();) {
                             newAttribute = (NewAttribute) iteratorJ.next();
                             if (newAttribute.type.equals(name)) {
                                 // if the attribute exists, update its context
                                 newAttribute.addContext(tag);
                                 prototypeExists = true;
                                 break;
                             }
                             // if no attribute is found, add a new attribute
                             if (!prototypeExists) {
                                 newAttribute = new NewAttribute(name, action,
                                         tag);
                                 prototypes.add(newAttribute);
                             }
                         }
                     }
                 }
             }
         }
     }

     public Attribute[] getUnknownAttributePrototypes() {
         if (unknownAttributeTypes == null) {
             List prototypes = new ArrayList();
             addOrUpdateAttributeActions(prototypes, classAttributeActions,
                     AttributeDefinitionBands.CONTEXT_CLASS);

             addOrUpdateAttributeActions(prototypes, methodAttributeActions,
                     AttributeDefinitionBands.CONTEXT_METHOD);

             addOrUpdateAttributeActions(prototypes, fieldAttributeActions,
                     AttributeDefinitionBands.CONTEXT_FIELD);

             addOrUpdateAttributeActions(prototypes, codeAttributeActions,
                     AttributeDefinitionBands.CONTEXT_CODE);

             unknownAttributeTypes = (Attribute[]) prototypes
                     .toArray(new Attribute[0]);
         }
         return unknownAttributeTypes;
     }

     public String getUnknownClassAttributeAction(String type) {
         String action = (String) classAttributeActions.get(type);
         if(action == null) {
             action = unknownAttributeAction;
         }
         return action;
     }

     public String getUnknownMethodAttributeAction(String type) {
         String action = (String) methodAttributeActions.get(type);
         if(action == null) {
             action = unknownAttributeAction;
         }
         return action;
     }

     public String getUnknownFieldAttributeAction(String type) {
         String action = (String) fieldAttributeActions.get(type);
         if(action == null) {
             action = unknownAttributeAction;
         }
         return action;
     }

     public String getUnknownCodeAttributeAction(String type) {
         String action = (String) codeAttributeActions.get(type);
         if(action == null) {
             action = unknownAttributeAction;
         }
         return action;
     }

 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package org.apache.harmony.pack200;

	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;

	import org.objectweb.asm.Attribute;

	/**
	* Utility class to manage the various options available for pack200
	*/
	public class PackingOptions {

	public static final String STRIP = "strip";
	public static final String ERROR = "error";
	public static final String PASS = "pass";
	public static final String KEEP = "keep";

	// All options are initially set to their defaults
	private boolean repack = false;
	private boolean gzip = true;
	private boolean stripDebug = false;
	private boolean keepFileOrder = true;
	private long segmentLimit = 1000000L;
	private int effort = 5;
	private String deflateHint = KEEP;
	private String modificationTime = KEEP;
	private List passFiles;
	private String unknownAttributeAction = PASS;
	private Map classAttributeActions;
	private Map fieldAttributeActions;
	private Map methodAttributeActions;
	private Map codeAttributeActions;
	private boolean verbose = false;
	private boolean quiet = true;
	private String logFile;

	private Attribute[] unknownAttributeTypes;

	public boolean isRepack() {
	return repack;
	}

	public void setRepack(boolean repack) {
	this.repack = repack;
	}

	public boolean isGzip() {
	return gzip;
	}

	public void setGzip(boolean gzip) {
	this.gzip = gzip;
	}

	public boolean isStripDebug() {
	return stripDebug;
	}

	/**
	* Set strip debug attributes. If true, all debug attributes (i.e.
	* LineNumberTable, SourceFile, LocalVariableTable and
	* LocalVariableTypeTable attributes) are stripped when reading the input
	* class files and not included in the output archive.
	*
	* @param stripDebug
	*/
	public void setStripDebug(boolean stripDebug) {
	this.stripDebug = stripDebug;
	}

	public boolean isKeepFileOrder() {
	return keepFileOrder;
	}

	public void setKeepFileOrder(boolean keepFileOrder) {
	this.keepFileOrder = keepFileOrder;
	}

	public long getSegmentLimit() {
	return segmentLimit;
	}

	/**
	* Set the segment limit (equivalent to -S command line option)
	* @param segmentLimit - the limit in bytes
	*/
	public void setSegmentLimit(long segmentLimit) {
	this.segmentLimit = segmentLimit;
	}

	public int getEffort() {
	return effort;
	}

	/**
	* Set the compression effort level (0-9, equivalent to -E command line option)
	* @param effort
	*/
	public void setEffort(int effort) {
	this.effort = effort;
	}

	public String getDeflateHint() {
	return deflateHint;
	}

	public boolean isKeepDeflateHint() {
	return KEEP.equals(deflateHint);
	}

	public void setDeflateHint(String deflateHint) {
	this.deflateHint = deflateHint;
	}

	public String getModificationTime() {
	return modificationTime;
	}

	public void setModificationTime(String modificationTime) {
	if (!KEEP.equals(modificationTime)
	&& !"latest".equals(modificationTime)) {
	throw new IllegalArgumentException(
	"Bad argument: -m "
	+ modificationTime
	+ " ? transmit modtimes should be either latest or keep (default)");
	}
	this.modificationTime = modificationTime;
	}

	public boolean isPassFile(String passFileName) {
	if (passFiles != null) {
	for (Iterator iterator = passFiles.iterator(); iterator.hasNext();) {
	String pass = (String) iterator.next();
	if (passFileName.equals(pass)) {
	return true;
	} else if (!pass.endsWith(".class")) { // a whole directory is
	// passed
	if (!pass.endsWith("/")) {
	// Make sure we don't get any false positives (e.g.
	// exclude "org/apache/harmony/pack" should not match
	// files under "org/apache/harmony/pack200/")
	pass = pass + "/";
	}
	return passFileName.startsWith(pass);
	}
	}
	}
	return false;
	}

	/**
	* Tell the compressor to pass the file with the given name, or if the name
	* is a directory name all files under that directory will be passed.
	*
	* @param passFileName
	* the file name
	*/
	public void addPassFile(String passFileName) {
	if(passFiles == null) {
	passFiles = new ArrayList();
	}
	String fileSeparator = System.getProperty("file.separator");
	if(fileSeparator.equals("\\")) {
	// Need to escape backslashes for replaceAll(), which uses regex
	fileSeparator += "\\";
	}
	passFileName = passFileName.replaceAll(fileSeparator, "/");
	passFiles.add(passFileName);
	}

	public void removePassFile(String passFileName) {
	passFiles.remove(passFileName);
	}

	public String getUnknownAttributeAction() {
	return unknownAttributeAction;
	}

	/**
	* Tell the compressor what to do if an unknown attribute is encountered
	* @param unknownAttributeAction - the action to perform
	*/
	public void setUnknownAttributeAction(String unknownAttributeAction) {
	this.unknownAttributeAction = unknownAttributeAction;
	if (!PASS.equals(unknownAttributeAction)
	&& !ERROR.equals(unknownAttributeAction)
	&& !STRIP.equals(unknownAttributeAction)) {
	throw new RuntimeException("Incorrect option for -U, "
	+ unknownAttributeAction);
	}
	}

	public Map getClassAttributeActions() {
	return classAttributeActions;
	}

	public void addClassAttributeAction(String attributeName, String action) {
	if(classAttributeActions == null) {
	classAttributeActions = new HashMap();
	}
	classAttributeActions.put(attributeName, action);
	}

	public Map getFieldAttributeActions() {
	return fieldAttributeActions;
	}

	public void addFieldAttributeAction(String attributeName, String action) {
	if(fieldAttributeActions == null) {
	fieldAttributeActions = new HashMap();
	}
	fieldAttributeActions.put(attributeName, action);
	}

	public Map getMethodAttributeActions() {
	return methodAttributeActions;
	}

	public void addMethodAttributeAction(String attributeName, String action) {
	if(methodAttributeActions == null) {
	methodAttributeActions = new HashMap();
	}
	methodAttributeActions.put(attributeName, action);
	}

	public Map getCodeAttributeActions() {
	return codeAttributeActions;
	}

	public void addCodeAttributeAction(String attributeName, String action) {
	if(codeAttributeActions == null) {
	codeAttributeActions = new HashMap();
	}
	codeAttributeActions.put(attributeName, action);
	}

	public boolean isVerbose() {
	return verbose;
	}

	public void setVerbose(boolean verbose) {
	this.verbose = verbose;
	}

	public boolean isQuiet() {
	return quiet;
	}

	public void setQuiet(boolean quiet) {
	this.quiet = quiet;
	}

	public String getLogFile() {
	return logFile;
	}

	public void setLogFile(String logFile) {
	this.logFile = logFile;
	}

	private void addOrUpdateAttributeActions(List prototypes, Map attributeActions,
	int tag) {
	if (attributeActions != null) {
	if (attributeActions.size() > 0) {
	String name, action;
	boolean prototypeExists;
	NewAttribute newAttribute;
	for (Iterator iteratorI = attributeActions.keySet().iterator(); iteratorI
	.hasNext();) {
	name = (String) iteratorI.next();
	action = (String) attributeActions.get(name);
	if (!ERROR.equals(action) && !STRIP.equals(action)
	&& !PASS.equals(action)) {
	prototypeExists = false;
	for (Iterator iteratorJ = prototypes.iterator(); iteratorJ
	.hasNext();) {
	newAttribute = (NewAttribute) iteratorJ.next();
	if (newAttribute.type.equals(name)) {
	// if the attribute exists, update its context
	newAttribute.addContext(tag);
	prototypeExists = true;
	break;
	}
	// if no attribute is found, add a new attribute
	if (!prototypeExists) {
	newAttribute = new NewAttribute(name, action,
	tag);
	prototypes.add(newAttribute);
	}
	}
	}
	}
	}
	}
	}

	public Attribute[] getUnknownAttributePrototypes() {
	if (unknownAttributeTypes == null) {
	List prototypes = new ArrayList();
	addOrUpdateAttributeActions(prototypes, classAttributeActions,
	AttributeDefinitionBands.CONTEXT_CLASS);

	addOrUpdateAttributeActions(prototypes, methodAttributeActions,
	AttributeDefinitionBands.CONTEXT_METHOD);

	addOrUpdateAttributeActions(prototypes, fieldAttributeActions,
	AttributeDefinitionBands.CONTEXT_FIELD);

	addOrUpdateAttributeActions(prototypes, codeAttributeActions,
	AttributeDefinitionBands.CONTEXT_CODE);

	unknownAttributeTypes = (Attribute[]) prototypes
	.toArray(new Attribute[0]);
	}
	return unknownAttributeTypes;
	}

	public String getUnknownClassAttributeAction(String type) {
	String action = (String) classAttributeActions.get(type);
	if(action == null) {
	action = unknownAttributeAction;
	}
	return action;
	}

	public String getUnknownMethodAttributeAction(String type) {
	String action = (String) methodAttributeActions.get(type);
	if(action == null) {
	action = unknownAttributeAction;
	}
	return action;
	}

	public String getUnknownFieldAttributeAction(String type) {
	String action = (String) fieldAttributeActions.get(type);
	if(action == null) {
	action = unknownAttributeAction;
	}
	return action;
	}

	public String getUnknownCodeAttributeAction(String type) {
	String action = (String) codeAttributeActions.get(type);
	if(action == null) {
	action = unknownAttributeAction;
	}
	return action;
	}

	}