private ArrayList<Symbol> getSymbolTable(byte[] encodedFileAsBytes) {
    // Finding the Divider in the file & separate the SymbolTable
    System.out.println("\nFileContent: ");
    System.out.println(Arrays.toString(encodedFileAsBytes));
    int i = getDividerIndexInArray(encodedFileAsBytes);

    // Reading the String of symbol table from the byteArray
    String symbolTableString = "";
    for (int j = 0; j < i; j++) {
      symbolTableString += String.valueOf((char) encodedFileAsBytes[j]);
    }
    // Generating the ArrayList<Symbol>
    String[] splitSymbolsAndCodes = symbolTableString.split(",");
    ArrayList<Symbol> symbols = new ArrayList<Symbol>();
    for (int j = 0; j < splitSymbolsAndCodes.length; j++) {
      String[] symbolCodePair = splitSymbolsAndCodes[j].split(":");
      Symbol symbol = new Symbol(0, symbolCodePair[0]);
      symbol.setCode(symbolCodePair[1]);
      symbols.add(symbol);
    }
    // Logging the Symbol List
    System.out.println("\nSymbol Table Retrived from the File");
    System.out.println(Symbol.symbolListToString(symbols));
    return symbols;
  }
  public static void reconstructHeaders(Iterable<NativeLibrary> libraries, PrintWriter out) {
    List<MemberRef> orphanMembers = new ArrayList<MemberRef>();
    Map<TypeRef, List<MemberRef>> membersByClass = new HashMap<TypeRef, List<MemberRef>>();
    for (NativeLibrary library : libraries) {
      for (Symbol symbol : library.getSymbols()) {
        MemberRef mr = symbol.getParsedRef();
        if (mr == null) continue;

        TypeRef et = mr.getEnclosingType();
        if (et == null) orphanMembers.add(mr);
        else {
          List<MemberRef> mrs = membersByClass.get(et);
          if (mrs == null) membersByClass.put(et, mrs = new ArrayList<MemberRef>());
          mrs.add(mr);
        }
      }
    }
    for (TypeRef tr : membersByClass.keySet()) out.println("class " + tr + ";");

    for (MemberRef mr : orphanMembers) out.println(mr + ";");

    for (Map.Entry<TypeRef, List<MemberRef>> e : membersByClass.entrySet()) {
      TypeRef tr = e.getKey();
      List<MemberRef> mrs = e.getValue();
      out.println("class " + tr + " \n{");
      for (MemberRef mr : mrs) {
        out.println("\t" + mr + ";");
      }
      out.println("}");
    }
  }
 private int skipOptionalSize(Symbol sig, int index) {
   byte c = sig.getByteAt(index);
   while (c >= '0' && c <= '9') {
     ++index;
     c = sig.getByteAt(index);
   }
   return index;
 }
Example #4
0
 boolean computeSubtypeOf(Klass k) {
   // An array is a subtype of Serializable, Clonable, and Object
   Symbol name = k.getName();
   if (name != null
       && (name.equals(javaIoSerializableName())
           || name.equals(javaLangCloneableName())
           || name.equals(javaLangObjectName()))) {
     return true;
   } else {
     return false;
   }
 }
 /** Only valid for T_ARRAY; throws unspecified exception otherwise */
 public ArrayInfo getArrayInfo() {
   int index = 1;
   int dim = 1;
   index = skipOptionalSize(signature, index);
   while (signature.getByteAt(index) == '[') {
     index++;
     dim++;
     skipOptionalSize(signature, index);
   }
   int elementType = BasicType.charToType((char) signature.getByteAt(index));
   return new ArrayInfo(dim, elementType);
 }
  /** Field access by name. */
  public Field findLocalField(Symbol name, Symbol sig) {
    TypeArray fields = getFields();
    int n = (int) fields.getLength();
    ConstantPool cp = getConstants();
    for (int i = 0; i < n; i += NEXT_OFFSET) {
      int nameIndex = fields.getShortAt(i + NAME_INDEX_OFFSET);
      int sigIndex = fields.getShortAt(i + SIGNATURE_INDEX_OFFSET);
      Symbol f_name = cp.getSymbolAt(nameIndex);
      Symbol f_sig = cp.getSymbolAt(sigIndex);
      if (name.equals(f_name) && sig.equals(f_sig)) {
        return newField(i);
      }
    }

    return null;
  }
  // refer to compute_modifier_flags in VM code.
  public long computeModifierFlags() {
    long access = getAccessFlags();
    // But check if it happens to be member class.
    TypeArray innerClassList = getInnerClasses();
    int length = (innerClassList == null) ? 0 : (int) innerClassList.getLength();
    if (length > 0) {
      if (Assert.ASSERTS_ENABLED) {
        Assert.that(length % InnerClassAttributeOffset.innerClassNextOffset == 0, "just checking");
      }
      for (int i = 0; i < length; i += InnerClassAttributeOffset.innerClassNextOffset) {
        int ioff =
            innerClassList.getShortAt(i + InnerClassAttributeOffset.innerClassInnerClassInfoOffset);
        // 'ioff' can be zero.
        // refer to JVM spec. section 4.7.5.
        if (ioff != 0) {
          // only look at classes that are already loaded
          // since we are looking for the flags for our self.
          Oop classInfo = getConstants().getObjAt(ioff);
          Symbol name = null;
          if (classInfo instanceof Klass) {
            name = ((Klass) classInfo).getName();
          } else if (classInfo instanceof Symbol) {
            name = (Symbol) classInfo;
          } else {
            throw new RuntimeException("should not reach here");
          }

          if (name.equals(getName())) {
            // This is really a member class
            access =
                innerClassList.getShortAt(
                    i + InnerClassAttributeOffset.innerClassAccessFlagsOffset);
            break;
          }
        }
      } // for inner classes
    }

    // Remember to strip ACC_SUPER bit
    return (access & (~JVM_ACC_SUPER)) & JVM_ACC_WRITTEN_FLAGS;
  }
 public FieldType(Symbol signature) {
   this.signature = signature;
   this.first = (char) signature.getByteAt(0);
   if (Assert.ASSERTS_ENABLED) {
     switch (this.first) {
       case 'B':
       case 'C':
       case 'D':
       case 'F':
       case 'I':
       case 'J':
       case 'S':
       case 'Z':
       case 'L':
       case '[':
         break; // Ok. signature char known
       default:
         Assert.that(
             false,
             "Unknown char in field signature \"" + signature.asString() + "\": " + this.first);
     }
   }
 }
  public void decodeFile(String encodedFileName, String decodedFileName) {
    try {
      byte[] encodedFileAsBytes = getFileAsByteArray(encodedFileName);

      // Generating the Symbol & Code ArrayList
      ArrayList<Symbol> symbols = getSymbolTable(encodedFileAsBytes);

      //            // Generating CodeTree
      //            Node codeTree = CodeTree.makeCodeTree(symbols);
      //            // Logging the CodeTree whether it have been generated correctly or not.
      //            String code = "";
      //            CodeTree.getCodeOfSymbol(CodeTree.Node.ROOT, symbols.get(2).getIdentifier(),
      // code);
      //            System.out.println("Symbol: " + symbols.get(2) + " Code_Retrived: " + code);

      // Decoding the content
      int dividerIndex = getDividerIndexInArray(encodedFileAsBytes);

      byte[] encodedMessage = new byte[encodedFileAsBytes.length - dividerIndex];
      for (int j = 0, i = dividerIndex + 1; i < encodedFileAsBytes.length; i++) {
        encodedMessage[j++] = encodedFileAsBytes[i];
      }
      String message = ByteUtils.toBinary(encodedMessage);

      System.out.println("Encoded Message In File: " + message);
      Symbol.symbolListToString(symbols);

      StringBuilder decodedMessage = new StringBuilder("");
      while (message.length() != 0) {
        //                Loggin the Messages
        //                System.out.println("");
        //                logger.info("Meesage: " + message);
        //                logger.info("Message Decoded: " + decodedMessage);

        boolean flag = false;
        for (Symbol symbol : symbols) {
          if (message.startsWith(symbol.getCode())) {
            decodedMessage.append(symbol.getIdentifier());
            message = message.substring(symbol.getCode().length(), message.length());
            flag = true;
            break;
          }
        }
        /*
         * We are checking that if no symbol is there in the symbol list
         * then it is the EOF as some padding is done by the String to
         * Byte & Byte to String conversion
         */
        if (!flag) {
          break;
        }
      }
      System.out.println("Decoded Message: " + decodedMessage);

      // Writing the decoded Message in the Output File
      File file = new File(decodedFileName);
      FileOutputStream fos = new FileOutputStream(file);
      fos.write(decodedMessage.toString().getBytes());
    } catch (Exception ex) {
      logger.log(Level.WARNING, ex.toString());
      ex.printStackTrace();
    }
  }
Example #10
0
  public void writeBytes(OutputStream os) throws IOException {
    // Map between any modified UTF-8 and it's constant pool index.
    Map utf8ToIndex = new HashMap();
    DataOutputStream dos = new DataOutputStream(os);
    TypeArray tags = getTags();
    int len = (int) getLength();
    int ci = 0; // constant pool index

    // collect all modified UTF-8 Strings from Constant Pool

    for (ci = 1; ci < len; ci++) {
      byte cpConstType = tags.getByteAt(ci);
      if (cpConstType == JVM_CONSTANT_Utf8) {
        Symbol sym = getSymbolAt(ci);
        utf8ToIndex.put(sym.asString(), new Short((short) ci));
      } else if (cpConstType == JVM_CONSTANT_Long || cpConstType == JVM_CONSTANT_Double) {
        ci++;
      }
    }

    for (ci = 1; ci < len; ci++) {
      int cpConstType = (int) tags.getByteAt(ci);
      // write cp_info
      // write constant type
      switch (cpConstType) {
        case JVM_CONSTANT_Utf8:
          {
            dos.writeByte(cpConstType);
            Symbol sym = getSymbolAt(ci);
            dos.writeShort((short) sym.getLength());
            dos.write(sym.asByteArray());
            if (DEBUG) debugMessage("CP[" + ci + "] = modified UTF-8 " + sym.asString());
            break;
          }

        case JVM_CONSTANT_Unicode:
          throw new IllegalArgumentException("Unicode constant!");

        case JVM_CONSTANT_Integer:
          dos.writeByte(cpConstType);
          dos.writeInt(getIntAt(ci));
          if (DEBUG) debugMessage("CP[" + ci + "] = int " + getIntAt(ci));
          break;

        case JVM_CONSTANT_Float:
          dos.writeByte(cpConstType);
          dos.writeFloat(getFloatAt(ci));
          if (DEBUG) debugMessage("CP[" + ci + "] = float " + getFloatAt(ci));
          break;

        case JVM_CONSTANT_Long:
          {
            dos.writeByte(cpConstType);
            long l = getLongAt(ci);
            // long entries occupy two pool entries
            ci++;
            dos.writeLong(l);
            break;
          }

        case JVM_CONSTANT_Double:
          dos.writeByte(cpConstType);
          dos.writeDouble(getDoubleAt(ci));
          // double entries occupy two pool entries
          ci++;
          break;

        case JVM_CONSTANT_Class:
          {
            dos.writeByte(cpConstType);
            // Klass already resolved. ConstantPool constains klassOop.
            Klass refKls = (Klass) getObjAt(ci);
            String klassName = refKls.getName().asString();
            Short s = (Short) utf8ToIndex.get(klassName);
            dos.writeShort(s.shortValue());
            if (DEBUG) debugMessage("CP[" + ci + "] = class " + s);
            break;
          }

          // case JVM_CONSTANT_ClassIndex:
        case JVM_CONSTANT_UnresolvedClass:
          {
            dos.writeByte(JVM_CONSTANT_Class);
            String klassName = getSymbolAt(ci).asString();
            Short s = (Short) utf8ToIndex.get(klassName);
            dos.writeShort(s.shortValue());
            if (DEBUG) debugMessage("CP[" + ci + "] = class " + s);
            break;
          }

        case JVM_CONSTANT_String:
          {
            dos.writeByte(cpConstType);
            String str = OopUtilities.stringOopToString(getObjAt(ci));
            Short s = (Short) utf8ToIndex.get(str);
            dos.writeShort(s.shortValue());
            if (DEBUG) debugMessage("CP[" + ci + "] = string " + s);
            break;
          }

          // case JVM_CONSTANT_StringIndex:
        case JVM_CONSTANT_UnresolvedString:
          {
            dos.writeByte(JVM_CONSTANT_String);
            String val = getSymbolAt(ci).asString();

            Short s = (Short) utf8ToIndex.get(val);
            dos.writeShort(s.shortValue());
            if (DEBUG) debugMessage("CP[" + ci + "] = string " + s);
            break;
          }

          // all external, internal method/field references
        case JVM_CONSTANT_Fieldref:
        case JVM_CONSTANT_Methodref:
        case JVM_CONSTANT_InterfaceMethodref:
          {
            dos.writeByte(cpConstType);
            int value = getIntAt(ci);
            short klassIndex = (short) extractLowShortFromInt(value);
            short nameAndTypeIndex = (short) extractHighShortFromInt(value);
            dos.writeShort(klassIndex);
            dos.writeShort(nameAndTypeIndex);
            if (DEBUG)
              debugMessage(
                  "CP[" + ci + "] = ref klass = " + klassIndex + ", N&T = " + nameAndTypeIndex);
            break;
          }

        case JVM_CONSTANT_NameAndType:
          {
            dos.writeByte(cpConstType);
            int value = getIntAt(ci);
            short nameIndex = (short) extractLowShortFromInt(value);
            short signatureIndex = (short) extractHighShortFromInt(value);
            dos.writeShort(nameIndex);
            dos.writeShort(signatureIndex);
            if (DEBUG)
              debugMessage(
                  "CP[" + ci + "] = N&T name = " + nameIndex + ", type = " + signatureIndex);
            break;
          }
      } // switch
    }
    dos.flush();
    return;
  }
  private boolean isInInnerClasses(Symbol sym, boolean includeLocals) {
    TypeArray innerClassList = getInnerClasses();
    int length = (innerClassList == null) ? 0 : (int) innerClassList.getLength();
    if (length > 0) {
      if (Assert.ASSERTS_ENABLED) {
        Assert.that(length % InnerClassAttributeOffset.innerClassNextOffset == 0, "just checking");
      }
      for (int i = 0; i < length; i += InnerClassAttributeOffset.innerClassNextOffset) {
        int ioff =
            innerClassList.getShortAt(i + InnerClassAttributeOffset.innerClassInnerClassInfoOffset);
        // 'ioff' can be zero.
        // refer to JVM spec. section 4.7.5.
        if (ioff != 0) {
          Oop iclassInfo = getConstants().getObjAt(ioff);
          Symbol innerName = null;
          if (iclassInfo instanceof Klass) {
            innerName = ((Klass) iclassInfo).getName();
          } else if (iclassInfo instanceof Symbol) {
            innerName = (Symbol) iclassInfo;
          } else {
            throw new RuntimeException("should not reach here");
          }

          Symbol myname = getName();
          int ooff =
              innerClassList.getShortAt(
                  i + InnerClassAttributeOffset.innerClassOuterClassInfoOffset);
          // for anonymous classes inner_name_index of InnerClasses
          // attribute is zero.
          int innerNameIndex =
              innerClassList.getShortAt(i + InnerClassAttributeOffset.innerClassInnerNameOffset);
          // if this is not a member (anonymous, local etc.), 'ooff' will be zero
          // refer to JVM spec. section 4.7.5.
          if (ooff == 0) {
            if (includeLocals) {
              // does it looks like my local class?
              if (innerName.equals(sym) && innerName.asString().startsWith(myname.asString())) {
                // exclude anonymous classes.
                return (innerNameIndex != 0);
              }
            }
          } else {
            Oop oclassInfo = getConstants().getObjAt(ooff);
            Symbol outerName = null;
            if (oclassInfo instanceof Klass) {
              outerName = ((Klass) oclassInfo).getName();
            } else if (oclassInfo instanceof Symbol) {
              outerName = (Symbol) oclassInfo;
            } else {
              throw new RuntimeException("should not reach here");
            }

            // include only if current class is outer class.
            if (outerName.equals(myname) && innerName.equals(sym)) {
              return true;
            }
          }
        }
      } // for inner classes
      return false;
    } else {
      return false;
    }
  }
  /**
   * Main method.
   *
   * @param args
   * @throws IOException
   */
  public static void main(String[] args) throws IOException {

    Scanner scanner = new Scanner(System.in);
    String newInput = " ";
    File f = null;
    boolean loopForFileName = true;
    boolean loopForFileLocation = true;
    // Looping to get correct input
    while (loopForFileLocation == true) {

      while (loopForFileName == true) {
        System.out.print("Please enter a filename: ");
        newInput = scanner.nextLine();
        if (newInput.length() == 0) {
          System.out.println("");
          System.out.println("You must enter a file name. ");
          System.out.println("");
        } else {
          loopForFileName = false;
        }
      }

      File file = new File(newInput);
      if (file.exists() == false) {
        System.out.println("");
        System.out.println("The file you entered was not found.");
        System.out.println("");
        loopForFileName = true;
      } else {
        loopForFileLocation = false;
        f = file;
      }
    }
    scanner.close();

    System.out.println("");

    // Character is the Key and Symbol is the Value
    HashMap<Character, Symbol> Letters = new HashMap<Character, Symbol>();
    String line;
    BufferedReader reader = new BufferedReader(new FileReader(f));
    // Reading data and putting it into the HashMap
    while ((line = reader.readLine()) != null) {

      for (int i = 0; i < line.length(); i++) {

        char c = line.charAt(i);
        Symbol s = Letters.get(c);
        if (s == null) {
          s = new Symbol(c, 0);
          Letters.put(c, s);
        }
        s.addToFrequency();
      }
    }
    reader.close();

    ArrayHeap<Node> arrayHeap = new ArrayHeap<Node>();
    // Adding to the ArrayHeap of Nodes
    for (Symbol s : Letters.values()) {
      Node n = new Node();
      n.addSymbols(s);
      arrayHeap.add(n);
    }

    ArrayHeap<Node> arrayOfNodes = arrayHeap;
    Node results = new Node();

    int counter = 0;
    // Calculating code words using Nodes
    while (arrayOfNodes.isEmpty() == false) {

      Node rightNode = arrayOfNodes.removeMin();
      if (arrayOfNodes.isEmpty()) {

        if (counter == 0) {
          rightNode.createNewCodeWord("1");
        }
        results = rightNode;
      } else {
        Node leftNode = arrayOfNodes.removeMin();
        rightNode.createNewCodeWord("0");
        leftNode.createNewCodeWord("1");
        leftNode.addNode(rightNode);
        arrayOfNodes.add(leftNode);
      }
      counter++;
    }
    // Displaying output
    System.out.println("Variable Length Code Output");
    System.out.println("____________________________________________________");
    for (Symbol s : results.getSymbols()) {

      System.out.printf(
          "Symbol: %3s  Codeword: %10s  Frequency: %5d",
          s.getCharacter(), s.getCodeWord(), s.getFrequency());
      System.out.print("\n");
    }

    System.out.println("");
    System.out.println(
        "Average VLC codeword length: "
            + String.format("%.2f", results.getAvgVlcLength())
            + " bits per symbol");

    System.out.println(
        "Average Fixed length codeword length: "
            + String.format("%.2f", results.getAvgFixedLength())
            + " bits per symbol");
    System.out.println("");
  }