dexlib2/src/main/java/org/jf/dexlib2/util/AnnotatedBytes.java - platform/external/google-smali - Git at Google

 /*
  * Copyright 2013, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
  * copyright notice, this list of conditions and the following disclaimer
  * in the documentation and/or other materials provided with the
  * distribution.
  *     * Neither the name of Google Inc. nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 package org.jf.dexlib2.util;

 import com.google.common.base.Strings;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;

 import org.jf.util.ExceptionWithContext;
 import org.jf.util.Hex;
 import org.jf.util.TwoColumnOutput;

 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import java.io.IOException;
 import java.io.Writer;
 import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;

 /**
  * Collects/presents a set of textual annotations, each associated with a range of bytes or a specific point
  * between bytes.
  *
  * Point annotations cannot occur within the middle of a range annotation, only at the endpoints, or some other area
  * with no range annotation.
  *
  * Multiple point annotations can be defined for a given point. They will be printed in insertion order.
  *
  * Only a single range annotation may exist for any given range of bytes. Range annotations may not overlap.
  */
 public class AnnotatedBytes {
     /**
      * This defines the bytes ranges and their associated range and point annotations.
      *
      * A range is defined by 2 consecutive keys in the map. The first key is the inclusive start point, the second key
      * is the exclusive end point. The range annotation for a range is associated with the first key for that range.
      * The point annotations for a point are associated with the key at that point.
      */
     @Nonnull private TreeMap<Integer, AnnotationEndpoint> annotatations = Maps.newTreeMap();

     private int cursor;
     private int indentLevel;

     /** &gt;= 40 (if used); the desired maximum output width */
     private int outputWidth;

     /**
      * &gt;= 8 (if used); the number of bytes of hex output to use
      * in annotations
      */
     private int hexCols = 8;

     private int startLimit = -1;
     private int endLimit = -1;

     public AnnotatedBytes(int width) {
         this.outputWidth = width;
     }

     /**
      * Moves the cursor to a new location
      *
      * @param offset The offset to move to
      */
     public void moveTo(int offset) {
         cursor = offset;
     }

     /**
      * Moves the cursor forward or backward by some amount
      *
      * @param offset The amount to move the cursor
      */
     public void moveBy(int offset) {
         cursor += offset;
     }

     public void annotateTo(int offset, @Nonnull String msg, Object... formatArgs) {
         annotate(offset - cursor, msg, formatArgs);
     }

     /**
      * Add an annotation of the given length at the current location.
      *
      * The location
      *
      *
      * @param length the length of data being annotated
      * @param msg the annotation message
      * @param formatArgs format arguments to pass to String.format
      */
     public void annotate(int length, @Nonnull String msg, Object... formatArgs) {
         if (startLimit != -1 && endLimit != -1 && (cursor < startLimit || cursor >= endLimit)) {
             throw new ExceptionWithContext("Annotating outside the parent bounds");
         }

         String formattedMsg;
         if (formatArgs != null && formatArgs.length > 0) {
             formattedMsg = String.format(msg, formatArgs);
         } else {
             formattedMsg = msg;
         }
         int exclusiveEndOffset = cursor + length;

         AnnotationEndpoint endPoint = null;

         // Do we have an endpoint at the beginning of this annotation already?
         AnnotationEndpoint startPoint = annotatations.get(cursor);
         if (startPoint == null) {
             // Nope. We need to check that we're not in the middle of an existing range annotation.
             Map.Entry<Integer, AnnotationEndpoint> previousEntry = annotatations.lowerEntry(cursor);
             if (previousEntry != null) {
                 AnnotationEndpoint previousAnnotations = previousEntry.getValue();
                 AnnotationItem previousRangeAnnotation = previousAnnotations.rangeAnnotation;
                 if (previousRangeAnnotation != null) {
                     throw new ExceptionWithContext(
                             "Cannot add annotation %s, due to existing annotation %s",
                             formatAnnotation(cursor, cursor + length, formattedMsg),
                             formatAnnotation(previousEntry.getKey(),
                                 previousRangeAnnotation.annotation));
                 }
             }
         } else if (length > 0) {
             AnnotationItem existingRangeAnnotation = startPoint.rangeAnnotation;
             if (existingRangeAnnotation != null) {
                 throw new ExceptionWithContext(
                         "Cannot add annotation %s, due to existing annotation %s",
                                 formatAnnotation(cursor, cursor + length, formattedMsg),
                                 formatAnnotation(cursor, existingRangeAnnotation.annotation));
             }
         }

         if (length > 0) {
             // Ensure that there is no later annotation that would intersect with this one
             Map.Entry<Integer, AnnotationEndpoint> nextEntry = annotatations.higherEntry(cursor);
             if (nextEntry != null) {
                 int nextKey = nextEntry.getKey();
                 if (nextKey < exclusiveEndOffset) {
                     // there is an endpoint that would intersect with this annotation. Find one of the annotations
                     // associated with the endpoint, to print in the error message
                     AnnotationEndpoint nextEndpoint = nextEntry.getValue();
                     AnnotationItem nextRangeAnnotation = nextEndpoint.rangeAnnotation;
                     if (nextRangeAnnotation != null) {
                         throw new ExceptionWithContext(
                                 "Cannot add annotation %s, due to existing annotation %s",
                                         formatAnnotation(cursor, cursor + length, formattedMsg),
                                         formatAnnotation(nextKey, nextRangeAnnotation.annotation));
                     }
                     if (nextEndpoint.pointAnnotations.size() > 0) {
                         throw new ExceptionWithContext(
                                 "Cannot add annotation %s, due to existing annotation %s",
                                         formatAnnotation(cursor, cursor + length, formattedMsg),
                                         formatAnnotation(nextKey, nextKey,
                                             nextEndpoint.pointAnnotations.get(0).annotation));
                     }
                     // There are no annotations on this endpoint. This "shouldn't" happen. We can still throw an exception.
                     throw new ExceptionWithContext(
                             "Cannot add annotation %s, due to existing annotation endpoint at %d",
                                     formatAnnotation(cursor, cursor + length, formattedMsg),
                                     nextKey);
                 }

                 if (nextKey == exclusiveEndOffset) {
                     // the next endpoint matches the end of the annotation we are adding
                     endPoint = nextEntry.getValue();
                 }
             }
         }

         // Now, actually add the annotation
         // If startPoint is null, we need to create a new one and add it to annotations. Otherwise, we just need to add
         // the annotation to the existing AnnotationEndpoint
         // the range annotation
         if (startPoint == null) {
             startPoint = new AnnotationEndpoint();
             annotatations.put(cursor, startPoint);
         }
         if (length == 0) {
             startPoint.pointAnnotations.add(new AnnotationItem(indentLevel, formattedMsg));
         } else {
             startPoint.rangeAnnotation = new AnnotationItem(indentLevel, formattedMsg);

             // If endPoint is null, we need to create a new, empty one and add it to annotations
             if (endPoint == null) {
                 endPoint = new AnnotationEndpoint();
                 annotatations.put(exclusiveEndOffset, endPoint);
             }
         }

         cursor += length;
     }

     private String formatAnnotation(int offset, String annotationMsg) {
         Integer endOffset = annotatations.higherKey(offset);
         return formatAnnotation(offset, endOffset, annotationMsg);
     }

     private String formatAnnotation(int offset, Integer endOffset, String annotationMsg) {
         if (endOffset != null) {
             return String.format("[0x%x, 0x%x) \"%s\"", offset, endOffset, annotationMsg);
         } else {
             return String.format("[0x%x, ) \"%s\"", offset, annotationMsg);
         }
     }

     public void indent() {
         indentLevel++;
     }

     public void deindent() {
         indentLevel--;
         if (indentLevel < 0) {
             indentLevel = 0;
         }
     }

     public int getCursor() {
         return cursor;
     }

     private static class AnnotationEndpoint {
         /** Annotations that are associated with a specific point between bytes */
         @Nonnull
         public final List<AnnotationItem> pointAnnotations = Lists.newArrayList();
         /** Annotations that are associated with a range of bytes */
         @Nullable
         public AnnotationItem rangeAnnotation = null;
     }

     private static class AnnotationItem {
         public final int indentLevel;
         public final String annotation;

         public AnnotationItem(int  indentLevel, String annotation) {
             this.indentLevel = indentLevel;
             this.annotation = annotation;
         }
     }

     /**
      * Gets the width of the right side containing the annotations
      * @return
      */
     public int getAnnotationWidth() {
         int leftWidth = 8 + (hexCols * 2) + (hexCols / 2);

         return outputWidth - leftWidth;
     }

     /**
      * Writes the annotated content of this instance to the given writer.
      *
      * @param out non-null; where to write to
      */
     public void writeAnnotations(Writer out, byte[] data) throws IOException {
         int rightWidth = getAnnotationWidth();
         int leftWidth = outputWidth - rightWidth - 1;

         String padding = Strings.repeat(" ", 1000);

         TwoColumnOutput twoc = new TwoColumnOutput(out, leftWidth, rightWidth, "|");

         Integer[] keys = new Integer[annotatations.size()];
         keys = annotatations.keySet().toArray(keys);

         AnnotationEndpoint[] values = new AnnotationEndpoint[annotatations.size()];
         values = annotatations.values().toArray(values);

         for (int i=0; i<keys.length-1; i++) {
             int rangeStart = keys[i];
             int rangeEnd = keys[i+1];

             AnnotationEndpoint annotations = values[i];

             for (AnnotationItem pointAnnotation: annotations.pointAnnotations) {
                 String paddingSub = padding.substring(0, pointAnnotation.indentLevel*2);
                 twoc.write("", paddingSub + pointAnnotation.annotation);
             }

             String right;
             AnnotationItem rangeAnnotation = annotations.rangeAnnotation;
             if (rangeAnnotation != null) {
                 right = padding.substring(0, rangeAnnotation.indentLevel*2);
                 right += rangeAnnotation.annotation;
             } else {
                 right = "";
             }

             String left = Hex.dump(data, rangeStart, rangeEnd - rangeStart, rangeStart, hexCols, 6);

             twoc.write(left, right);
         }

         int lastKey = keys[keys.length-1];
         if (lastKey < data.length) {
             String left = Hex.dump(data, lastKey, data.length - lastKey, lastKey, hexCols, 6);
             twoc.write(left, "");
         }
     }

     public void setLimit(int start, int end) {
         this.startLimit = start;
         this.endLimit = end;
     }

     public void clearLimit() {
         this.startLimit = -1;
         this.endLimit = -1;
     }
 }
	/*
	* Copyright 2013, Google Inc.
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are
	* met:
	*
	* * Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* * Redistributions in binary form must reproduce the above
	* copyright notice, this list of conditions and the following disclaimer
	* in the documentation and/or other materials provided with the
	* distribution.
	* * Neither the name of Google Inc. nor the names of its
	* contributors may be used to endorse or promote products derived from
	* this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	package org.jf.dexlib2.util;

	import com.google.common.base.Strings;
	import com.google.common.collect.Lists;
	import com.google.common.collect.Maps;

	import org.jf.util.ExceptionWithContext;
	import org.jf.util.Hex;
	import org.jf.util.TwoColumnOutput;

	import javax.annotation.Nonnull;
	import javax.annotation.Nullable;
	import java.io.IOException;
	import java.io.Writer;
	import java.util.List;
	import java.util.Map;
	import java.util.TreeMap;

	/**
	* Collects/presents a set of textual annotations, each associated with a range of bytes or a specific point
	* between bytes.
	*
	* Point annotations cannot occur within the middle of a range annotation, only at the endpoints, or some other area
	* with no range annotation.
	*
	* Multiple point annotations can be defined for a given point. They will be printed in insertion order.
	*
	* Only a single range annotation may exist for any given range of bytes. Range annotations may not overlap.
	*/
	public class AnnotatedBytes {
	/**
	* This defines the bytes ranges and their associated range and point annotations.
	*
	* A range is defined by 2 consecutive keys in the map. The first key is the inclusive start point, the second key
	* is the exclusive end point. The range annotation for a range is associated with the first key for that range.
	* The point annotations for a point are associated with the key at that point.
	*/
	@Nonnull private TreeMap<Integer, AnnotationEndpoint> annotatations = Maps.newTreeMap();

	private int cursor;
	private int indentLevel;

	/** >= 40 (if used); the desired maximum output width */
	private int outputWidth;

	/**
	* >= 8 (if used); the number of bytes of hex output to use
	* in annotations
	*/
	private int hexCols = 8;

	private int startLimit = -1;
	private int endLimit = -1;

	public AnnotatedBytes(int width) {
	this.outputWidth = width;
	}

	/**
	* Moves the cursor to a new location
	*
	* @param offset The offset to move to
	*/
	public void moveTo(int offset) {
	cursor = offset;
	}

	/**
	* Moves the cursor forward or backward by some amount
	*
	* @param offset The amount to move the cursor
	*/
	public void moveBy(int offset) {
	cursor += offset;
	}

	public void annotateTo(int offset, @Nonnull String msg, Object... formatArgs) {
	annotate(offset - cursor, msg, formatArgs);
	}

	/**
	* Add an annotation of the given length at the current location.
	*
	* The location
	*
	*
	* @param length the length of data being annotated
	* @param msg the annotation message
	* @param formatArgs format arguments to pass to String.format
	*/
	public void annotate(int length, @Nonnull String msg, Object... formatArgs) {
	if (startLimit != -1 && endLimit != -1 && (cursor < startLimit \|\| cursor >= endLimit)) {
	throw new ExceptionWithContext("Annotating outside the parent bounds");
	}

	String formattedMsg;
	if (formatArgs != null && formatArgs.length > 0) {
	formattedMsg = String.format(msg, formatArgs);
	} else {
	formattedMsg = msg;
	}
	int exclusiveEndOffset = cursor + length;

	AnnotationEndpoint endPoint = null;

	// Do we have an endpoint at the beginning of this annotation already?
	AnnotationEndpoint startPoint = annotatations.get(cursor);
	if (startPoint == null) {
	// Nope. We need to check that we're not in the middle of an existing range annotation.
	Map.Entry<Integer, AnnotationEndpoint> previousEntry = annotatations.lowerEntry(cursor);
	if (previousEntry != null) {
	AnnotationEndpoint previousAnnotations = previousEntry.getValue();
	AnnotationItem previousRangeAnnotation = previousAnnotations.rangeAnnotation;
	if (previousRangeAnnotation != null) {
	throw new ExceptionWithContext(
	"Cannot add annotation %s, due to existing annotation %s",
	formatAnnotation(cursor, cursor + length, formattedMsg),
	formatAnnotation(previousEntry.getKey(),
	previousRangeAnnotation.annotation));
	}
	}
	} else if (length > 0) {
	AnnotationItem existingRangeAnnotation = startPoint.rangeAnnotation;
	if (existingRangeAnnotation != null) {
	throw new ExceptionWithContext(
	"Cannot add annotation %s, due to existing annotation %s",
	formatAnnotation(cursor, cursor + length, formattedMsg),
	formatAnnotation(cursor, existingRangeAnnotation.annotation));
	}
	}

	if (length > 0) {
	// Ensure that there is no later annotation that would intersect with this one
	Map.Entry<Integer, AnnotationEndpoint> nextEntry = annotatations.higherEntry(cursor);
	if (nextEntry != null) {
	int nextKey = nextEntry.getKey();
	if (nextKey < exclusiveEndOffset) {
	// there is an endpoint that would intersect with this annotation. Find one of the annotations
	// associated with the endpoint, to print in the error message
	AnnotationEndpoint nextEndpoint = nextEntry.getValue();
	AnnotationItem nextRangeAnnotation = nextEndpoint.rangeAnnotation;
	if (nextRangeAnnotation != null) {
	throw new ExceptionWithContext(
	"Cannot add annotation %s, due to existing annotation %s",
	formatAnnotation(cursor, cursor + length, formattedMsg),
	formatAnnotation(nextKey, nextRangeAnnotation.annotation));
	}
	if (nextEndpoint.pointAnnotations.size() > 0) {
	throw new ExceptionWithContext(
	"Cannot add annotation %s, due to existing annotation %s",
	formatAnnotation(cursor, cursor + length, formattedMsg),
	formatAnnotation(nextKey, nextKey,
	nextEndpoint.pointAnnotations.get(0).annotation));
	}
	// There are no annotations on this endpoint. This "shouldn't" happen. We can still throw an exception.
	throw new ExceptionWithContext(
	"Cannot add annotation %s, due to existing annotation endpoint at %d",
	formatAnnotation(cursor, cursor + length, formattedMsg),
	nextKey);
	}

	if (nextKey == exclusiveEndOffset) {
	// the next endpoint matches the end of the annotation we are adding
	endPoint = nextEntry.getValue();
	}
	}
	}

	// Now, actually add the annotation
	// If startPoint is null, we need to create a new one and add it to annotations. Otherwise, we just need to add
	// the annotation to the existing AnnotationEndpoint
	// the range annotation
	if (startPoint == null) {
	startPoint = new AnnotationEndpoint();
	annotatations.put(cursor, startPoint);
	}
	if (length == 0) {
	startPoint.pointAnnotations.add(new AnnotationItem(indentLevel, formattedMsg));
	} else {
	startPoint.rangeAnnotation = new AnnotationItem(indentLevel, formattedMsg);

	// If endPoint is null, we need to create a new, empty one and add it to annotations
	if (endPoint == null) {
	endPoint = new AnnotationEndpoint();
	annotatations.put(exclusiveEndOffset, endPoint);
	}
	}

	cursor += length;
	}

	private String formatAnnotation(int offset, String annotationMsg) {
	Integer endOffset = annotatations.higherKey(offset);
	return formatAnnotation(offset, endOffset, annotationMsg);
	}

	private String formatAnnotation(int offset, Integer endOffset, String annotationMsg) {
	if (endOffset != null) {
	return String.format("[0x%x, 0x%x) \"%s\"", offset, endOffset, annotationMsg);
	} else {
	return String.format("[0x%x, ) \"%s\"", offset, annotationMsg);
	}
	}

	public void indent() {
	indentLevel++;
	}

	public void deindent() {
	indentLevel--;
	if (indentLevel < 0) {
	indentLevel = 0;
	}
	}

	public int getCursor() {
	return cursor;
	}

	private static class AnnotationEndpoint {
	/** Annotations that are associated with a specific point between bytes */
	@Nonnull
	public final List<AnnotationItem> pointAnnotations = Lists.newArrayList();
	/** Annotations that are associated with a range of bytes */
	@Nullable
	public AnnotationItem rangeAnnotation = null;
	}

	private static class AnnotationItem {
	public final int indentLevel;
	public final String annotation;

	public AnnotationItem(int indentLevel, String annotation) {
	this.indentLevel = indentLevel;
	this.annotation = annotation;
	}
	}

	/**
	* Gets the width of the right side containing the annotations
	* @return
	*/
	public int getAnnotationWidth() {
	int leftWidth = 8 + (hexCols * 2) + (hexCols / 2);

	return outputWidth - leftWidth;
	}

	/**
	* Writes the annotated content of this instance to the given writer.
	*
	* @param out non-null; where to write to
	*/
	public void writeAnnotations(Writer out, byte[] data) throws IOException {
	int rightWidth = getAnnotationWidth();
	int leftWidth = outputWidth - rightWidth - 1;

	String padding = Strings.repeat(" ", 1000);

	TwoColumnOutput twoc = new TwoColumnOutput(out, leftWidth, rightWidth, "\|");

	Integer[] keys = new Integer[annotatations.size()];
	keys = annotatations.keySet().toArray(keys);

	AnnotationEndpoint[] values = new AnnotationEndpoint[annotatations.size()];
	values = annotatations.values().toArray(values);

	for (int i=0; i<keys.length-1; i++) {
	int rangeStart = keys[i];
	int rangeEnd = keys[i+1];

	AnnotationEndpoint annotations = values[i];

	for (AnnotationItem pointAnnotation: annotations.pointAnnotations) {
	String paddingSub = padding.substring(0, pointAnnotation.indentLevel*2);
	twoc.write("", paddingSub + pointAnnotation.annotation);
	}

	String right;
	AnnotationItem rangeAnnotation = annotations.rangeAnnotation;
	if (rangeAnnotation != null) {
	right = padding.substring(0, rangeAnnotation.indentLevel*2);
	right += rangeAnnotation.annotation;
	} else {
	right = "";
	}

	String left = Hex.dump(data, rangeStart, rangeEnd - rangeStart, rangeStart, hexCols, 6);

	twoc.write(left, right);
	}

	int lastKey = keys[keys.length-1];
	if (lastKey < data.length) {
	String left = Hex.dump(data, lastKey, data.length - lastKey, lastKey, hexCols, 6);
	twoc.write(left, "");
	}
	}

	public void setLimit(int start, int end) {
	this.startLimit = start;
	this.endLimit = end;
	}

	public void clearLimit() {
	this.startLimit = -1;
	this.endLimit = -1;
	}
	}