| /******************************************************************************* |
| * Copyright (c) 2007 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - Initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.ptp.proxy.util; |
| |
| import java.math.BigInteger; |
| import java.nio.CharBuffer; |
| |
| import org.eclipse.ptp.proxy.packet.ProxyPacket; |
| |
| public class ProtocolUtil { |
| public final static int HEXADECIMAL = 0; |
| public final static int OCTAL = 1; |
| public final static int BINARY = 2; |
| public final static int DECIMAL = 3; |
| public final static int RAW = 4; |
| public final static int NATURAL = 5; |
| |
| public final static int FLOAT = 10; |
| public final static int ADDRESS = 11; |
| public final static int INSTRUCTION = 12; |
| public final static int CHAR = 13; |
| public final static int STRING = 14; |
| public final static int UNSIGNED = 15; |
| |
| /** |
| * Decode a string into a BigInteger |
| * |
| * @param address |
| * @return BigInteger |
| */ |
| public static BigInteger decodeAddress(String address) { |
| int index = 0; |
| int radix = 10; |
| boolean negative = false; |
| |
| // Handle zero length |
| address = address.trim(); |
| if (address.length() == 0) { |
| return BigInteger.ZERO; |
| } |
| |
| // Handle minus sign, if present |
| if (address.startsWith("-")) { |
| negative = true; |
| index++; |
| } |
| if (address.startsWith("0x", index) || address.startsWith("0X", index)) { |
| index += 2; |
| radix = 16; |
| } else if (address.startsWith("#", index)) { |
| index ++; |
| radix = 16; |
| } else if (address.startsWith("0", index) && address.length() > 1 + index) { |
| index ++; |
| radix = 8; |
| } |
| |
| if (index > 0) { |
| address = address.substring(index); |
| } |
| if (negative) { |
| address = "-" + address; |
| } |
| try { |
| return new BigInteger(address, radix); |
| } catch (NumberFormatException e) { |
| // ... |
| // What can we do ??? |
| } |
| return BigInteger.ZERO; |
| } |
| |
| /** |
| * Convert as sequence of hexadecimal values to a Java byte array. |
| * |
| * @param str |
| * @return byte array |
| */ |
| public static byte[] decodeBytes(String str) { |
| int len = str.length()/2; |
| byte[] strBytes = new byte[len]; |
| |
| for (int i = 0, p = 0; i < len; i++, p += 2) { |
| byte c = (byte) ((Character.digit(str.charAt(p), 16) & 0xf) << 4); |
| c |= (byte) ((Character.digit(str.charAt(p+1), 16) & 0xf)); |
| strBytes[i] = c; |
| } |
| |
| return strBytes; |
| } |
| |
| /** |
| * Convert a proxy representation of a string into a Java String |
| * |
| * @param buf |
| * @param start |
| * @return proxy string converted to Java String |
| */ |
| public static String decodeString(CharBuffer buf, int start) { |
| int end = start + ProxyPacket.PACKET_ARG_LEN_SIZE; |
| int len = Integer.parseInt(buf.subSequence(start, end).toString(), 16); |
| start = end + 1; // Skip ':' |
| end = start + len; |
| return buf.subSequence(start, end).toString(); |
| } |
| |
| /** |
| * Convert an integer to it's proxy representation |
| * |
| * @param val |
| * @param len |
| * @return proxy representation |
| */ |
| public static String encodeIntVal(int val, int len) { |
| char[] res = new char[len]; |
| String str = Integer.toHexString(val); |
| int rem = len - str.length(); |
| |
| for (int i = 0 ; i < len ; i++) { |
| if (i < rem) |
| res[i] = '0'; |
| else |
| res[i] = str.charAt(i - rem); |
| } |
| return String.valueOf(res); |
| } |
| |
| /** |
| * Encode a string into it's proxy representation |
| * |
| * @param str |
| * @return proxy representation |
| */ |
| public static String encodeString(String str) { |
| int len; |
| |
| if (str == null) { |
| len = 0; |
| str = ""; |
| } else { |
| len = str.length(); |
| } |
| |
| return encodeIntVal(len, ProxyPacket.PACKET_ARG_LEN_SIZE) + ":" + str; |
| } |
| |
| } |