606 lines
22 KiB
Java
606 lines
22 KiB
Java
/*
|
|
* Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
package javax.smartcardio;
|
|
|
|
import java.util.Arrays;
|
|
|
|
import java.nio.ByteBuffer;
|
|
|
|
/**
|
|
* A command APDU following the structure defined in ISO/IEC 7816-4.
|
|
* It consists of a four byte header and a conditional body of variable length.
|
|
* This class does not attempt to verify that the APDU encodes a semantically
|
|
* valid command.
|
|
*
|
|
* <p>Note that when the expected length of the response APDU is specified
|
|
* in the {@linkplain #CommandAPDU(int,int,int,int,int) constructors},
|
|
* the actual length (Ne) must be specified, not its
|
|
* encoded form (Le). Similarly, {@linkplain #getNe} returns the actual
|
|
* value Ne. In other words, a value of 0 means "no data in the response APDU"
|
|
* rather than "maximum length."
|
|
*
|
|
* <p>This class supports both the short and extended forms of length
|
|
* encoding for Ne and Nc. However, note that not all terminals and Smart Cards
|
|
* are capable of accepting APDUs that use the extended form.
|
|
*
|
|
* <p>For the header bytes CLA, INS, P1, and P2 the Java type <code>int</code>
|
|
* is used to represent the 8 bit unsigned values. In the constructors, only
|
|
* the 8 lowest bits of the <code>int</code> value specified by the application
|
|
* are significant. The accessor methods always return the byte as an unsigned
|
|
* value between 0 and 255.
|
|
*
|
|
* <p>Instances of this class are immutable. Where data is passed in or out
|
|
* via byte arrays, defensive cloning is performed.
|
|
*
|
|
* @see ResponseAPDU
|
|
*
|
|
* @since 1.6
|
|
* @author Andreas Sterbenz
|
|
* @author JSR 268 Expert Group
|
|
*/
|
|
public final class CommandAPDU implements java.io.Serializable {
|
|
|
|
private static final long serialVersionUID = 398698301286670877L;
|
|
|
|
private static final int MAX_APDU_SIZE = 65544;
|
|
|
|
/** @serial */
|
|
private byte[] apdu;
|
|
|
|
// value of nc
|
|
private transient int nc;
|
|
|
|
// value of ne
|
|
private transient int ne;
|
|
|
|
// index of start of data within the apdu array
|
|
private transient int dataOffset;
|
|
|
|
/**
|
|
* Constructs a CommandAPDU from a byte array containing the complete
|
|
* APDU contents (header and body).
|
|
*
|
|
* <p>Note that the apdu bytes are copied to protect against
|
|
* subsequent modification.
|
|
*
|
|
* @param apdu the complete command APDU
|
|
*
|
|
* @throws NullPointerException if apdu is null
|
|
* @throws IllegalArgumentException if apdu does not contain a valid
|
|
* command APDU
|
|
*/
|
|
public CommandAPDU(byte[] apdu) {
|
|
this.apdu = apdu.clone();
|
|
parse();
|
|
}
|
|
|
|
/**
|
|
* Constructs a CommandAPDU from a byte array containing the complete
|
|
* APDU contents (header and body). The APDU starts at the index
|
|
* <code>apduOffset</code> in the byte array and is <code>apduLength</code>
|
|
* bytes long.
|
|
*
|
|
* <p>Note that the apdu bytes are copied to protect against
|
|
* subsequent modification.
|
|
*
|
|
* @param apdu the complete command APDU
|
|
* @param apduOffset the offset in the byte array at which the apdu
|
|
* data begins
|
|
* @param apduLength the length of the APDU
|
|
*
|
|
* @throws NullPointerException if apdu is null
|
|
* @throws IllegalArgumentException if apduOffset or apduLength are
|
|
* negative or if apduOffset + apduLength are greater than apdu.length,
|
|
* or if the specified bytes are not a valid APDU
|
|
*/
|
|
public CommandAPDU(byte[] apdu, int apduOffset, int apduLength) {
|
|
checkArrayBounds(apdu, apduOffset, apduLength);
|
|
this.apdu = new byte[apduLength];
|
|
System.arraycopy(apdu, apduOffset, this.apdu, 0, apduLength);
|
|
parse();
|
|
}
|
|
|
|
private void checkArrayBounds(byte[] b, int ofs, int len) {
|
|
if ((ofs < 0) || (len < 0)) {
|
|
throw new IllegalArgumentException
|
|
("Offset and length must not be negative");
|
|
}
|
|
if (b == null) {
|
|
if ((ofs != 0) && (len != 0)) {
|
|
throw new IllegalArgumentException
|
|
("offset and length must be 0 if array is null");
|
|
}
|
|
} else {
|
|
if (ofs > b.length - len) {
|
|
throw new IllegalArgumentException
|
|
("Offset plus length exceed array size");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a CommandAPDU from the ByteBuffer containing the complete APDU
|
|
* contents (header and body).
|
|
* The buffer's <code>position</code> must be set to the start of the APDU,
|
|
* its <code>limit</code> to the end of the APDU. Upon return, the buffer's
|
|
* <code>position</code> is equal to its limit; its limit remains unchanged.
|
|
*
|
|
* <p>Note that the data in the ByteBuffer is copied to protect against
|
|
* subsequent modification.
|
|
*
|
|
* @param apdu the ByteBuffer containing the complete APDU
|
|
*
|
|
* @throws NullPointerException if apdu is null
|
|
* @throws IllegalArgumentException if apdu does not contain a valid
|
|
* command APDU
|
|
*/
|
|
public CommandAPDU(ByteBuffer apdu) {
|
|
this.apdu = new byte[apdu.remaining()];
|
|
apdu.get(this.apdu);
|
|
parse();
|
|
}
|
|
|
|
/**
|
|
* Constructs a CommandAPDU from the four header bytes. This is case 1
|
|
* in ISO 7816, no command body.
|
|
*
|
|
* @param cla the class byte CLA
|
|
* @param ins the instruction byte INS
|
|
* @param p1 the parameter byte P1
|
|
* @param p2 the parameter byte P2
|
|
*/
|
|
public CommandAPDU(int cla, int ins, int p1, int p2) {
|
|
this(cla, ins, p1, p2, null, 0, 0, 0);
|
|
}
|
|
|
|
/**
|
|
* Constructs a CommandAPDU from the four header bytes and the expected
|
|
* response data length. This is case 2 in ISO 7816, empty command data
|
|
* field with Ne specified. If Ne is 0, the APDU is encoded as ISO 7816
|
|
* case 1.
|
|
*
|
|
* @param cla the class byte CLA
|
|
* @param ins the instruction byte INS
|
|
* @param p1 the parameter byte P1
|
|
* @param p2 the parameter byte P2
|
|
* @param ne the maximum number of expected data bytes in a response APDU
|
|
*
|
|
* @throws IllegalArgumentException if ne is negative or greater than
|
|
* 65536
|
|
*/
|
|
public CommandAPDU(int cla, int ins, int p1, int p2, int ne) {
|
|
this(cla, ins, p1, p2, null, 0, 0, ne);
|
|
}
|
|
|
|
/**
|
|
* Constructs a CommandAPDU from the four header bytes and command data.
|
|
* This is case 3 in ISO 7816, command data present and Ne absent. The
|
|
* value Nc is taken as data.length. If <code>data</code> is null or
|
|
* its length is 0, the APDU is encoded as ISO 7816 case 1.
|
|
*
|
|
* <p>Note that the data bytes are copied to protect against
|
|
* subsequent modification.
|
|
*
|
|
* @param cla the class byte CLA
|
|
* @param ins the instruction byte INS
|
|
* @param p1 the parameter byte P1
|
|
* @param p2 the parameter byte P2
|
|
* @param data the byte array containing the data bytes of the command body
|
|
*
|
|
* @throws IllegalArgumentException if data.length is greater than 65535
|
|
*/
|
|
public CommandAPDU(int cla, int ins, int p1, int p2, byte[] data) {
|
|
this(cla, ins, p1, p2, data, 0, arrayLength(data), 0);
|
|
}
|
|
|
|
/**
|
|
* Constructs a CommandAPDU from the four header bytes and command data.
|
|
* This is case 3 in ISO 7816, command data present and Ne absent. The
|
|
* value Nc is taken as dataLength. If <code>dataLength</code>
|
|
* is 0, the APDU is encoded as ISO 7816 case 1.
|
|
*
|
|
* <p>Note that the data bytes are copied to protect against
|
|
* subsequent modification.
|
|
*
|
|
* @param cla the class byte CLA
|
|
* @param ins the instruction byte INS
|
|
* @param p1 the parameter byte P1
|
|
* @param p2 the parameter byte P2
|
|
* @param data the byte array containing the data bytes of the command body
|
|
* @param dataOffset the offset in the byte array at which the data
|
|
* bytes of the command body begin
|
|
* @param dataLength the number of the data bytes in the command body
|
|
*
|
|
* @throws NullPointerException if data is null and dataLength is not 0
|
|
* @throws IllegalArgumentException if dataOffset or dataLength are
|
|
* negative or if dataOffset + dataLength are greater than data.length
|
|
* or if dataLength is greater than 65535
|
|
*/
|
|
public CommandAPDU(int cla, int ins, int p1, int p2, byte[] data,
|
|
int dataOffset, int dataLength) {
|
|
this(cla, ins, p1, p2, data, dataOffset, dataLength, 0);
|
|
}
|
|
|
|
/**
|
|
* Constructs a CommandAPDU from the four header bytes, command data,
|
|
* and expected response data length. This is case 4 in ISO 7816,
|
|
* command data and Ne present. The value Nc is taken as data.length
|
|
* if <code>data</code> is non-null and as 0 otherwise. If Ne or Nc
|
|
* are zero, the APDU is encoded as case 1, 2, or 3 per ISO 7816.
|
|
*
|
|
* <p>Note that the data bytes are copied to protect against
|
|
* subsequent modification.
|
|
*
|
|
* @param cla the class byte CLA
|
|
* @param ins the instruction byte INS
|
|
* @param p1 the parameter byte P1
|
|
* @param p2 the parameter byte P2
|
|
* @param data the byte array containing the data bytes of the command body
|
|
* @param ne the maximum number of expected data bytes in a response APDU
|
|
*
|
|
* @throws IllegalArgumentException if data.length is greater than 65535
|
|
* or if ne is negative or greater than 65536
|
|
*/
|
|
public CommandAPDU(int cla, int ins, int p1, int p2, byte[] data, int ne) {
|
|
this(cla, ins, p1, p2, data, 0, arrayLength(data), ne);
|
|
}
|
|
|
|
private static int arrayLength(byte[] b) {
|
|
return (b != null) ? b.length : 0;
|
|
}
|
|
|
|
/**
|
|
* Command APDU encoding options:
|
|
*
|
|
* case 1: |CLA|INS|P1 |P2 | len = 4
|
|
* case 2s: |CLA|INS|P1 |P2 |LE | len = 5
|
|
* case 3s: |CLA|INS|P1 |P2 |LC |...BODY...| len = 6..260
|
|
* case 4s: |CLA|INS|P1 |P2 |LC |...BODY...|LE | len = 7..261
|
|
* case 2e: |CLA|INS|P1 |P2 |00 |LE1|LE2| len = 7
|
|
* case 3e: |CLA|INS|P1 |P2 |00 |LC1|LC2|...BODY...| len = 8..65542
|
|
* case 4e: |CLA|INS|P1 |P2 |00 |LC1|LC2|...BODY...|LE1|LE2| len =10..65544
|
|
*
|
|
* LE, LE1, LE2 may be 0x00.
|
|
* LC must not be 0x00 and LC1|LC2 must not be 0x00|0x00
|
|
*/
|
|
private void parse() {
|
|
if (apdu.length < 4) {
|
|
throw new IllegalArgumentException("apdu must be at least 4 bytes long");
|
|
}
|
|
if (apdu.length == 4) {
|
|
// case 1
|
|
return;
|
|
}
|
|
int l1 = apdu[4] & 0xff;
|
|
if (apdu.length == 5) {
|
|
// case 2s
|
|
this.ne = (l1 == 0) ? 256 : l1;
|
|
return;
|
|
}
|
|
if (l1 != 0) {
|
|
if (apdu.length == 4 + 1 + l1) {
|
|
// case 3s
|
|
this.nc = l1;
|
|
this.dataOffset = 5;
|
|
return;
|
|
} else if (apdu.length == 4 + 2 + l1) {
|
|
// case 4s
|
|
this.nc = l1;
|
|
this.dataOffset = 5;
|
|
int l2 = apdu[apdu.length - 1] & 0xff;
|
|
this.ne = (l2 == 0) ? 256 : l2;
|
|
return;
|
|
} else {
|
|
throw new IllegalArgumentException
|
|
("Invalid APDU: length=" + apdu.length + ", b1=" + l1);
|
|
}
|
|
}
|
|
if (apdu.length < 7) {
|
|
throw new IllegalArgumentException
|
|
("Invalid APDU: length=" + apdu.length + ", b1=" + l1);
|
|
}
|
|
int l2 = ((apdu[5] & 0xff) << 8) | (apdu[6] & 0xff);
|
|
if (apdu.length == 7) {
|
|
// case 2e
|
|
this.ne = (l2 == 0) ? 65536 : l2;
|
|
return;
|
|
}
|
|
if (l2 == 0) {
|
|
throw new IllegalArgumentException("Invalid APDU: length="
|
|
+ apdu.length + ", b1=" + l1 + ", b2||b3=" + l2);
|
|
}
|
|
if (apdu.length == 4 + 3 + l2) {
|
|
// case 3e
|
|
this.nc = l2;
|
|
this.dataOffset = 7;
|
|
return;
|
|
} else if (apdu.length == 4 + 5 + l2) {
|
|
// case 4e
|
|
this.nc = l2;
|
|
this.dataOffset = 7;
|
|
int leOfs = apdu.length - 2;
|
|
int l3 = ((apdu[leOfs] & 0xff) << 8) | (apdu[leOfs + 1] & 0xff);
|
|
this.ne = (l3 == 0) ? 65536 : l3;
|
|
} else {
|
|
throw new IllegalArgumentException("Invalid APDU: length="
|
|
+ apdu.length + ", b1=" + l1 + ", b2||b3=" + l2);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Constructs a CommandAPDU from the four header bytes, command data,
|
|
* and expected response data length. This is case 4 in ISO 7816,
|
|
* command data and Le present. The value Nc is taken as
|
|
* <code>dataLength</code>.
|
|
* If Ne or Nc
|
|
* are zero, the APDU is encoded as case 1, 2, or 3 per ISO 7816.
|
|
*
|
|
* <p>Note that the data bytes are copied to protect against
|
|
* subsequent modification.
|
|
*
|
|
* @param cla the class byte CLA
|
|
* @param ins the instruction byte INS
|
|
* @param p1 the parameter byte P1
|
|
* @param p2 the parameter byte P2
|
|
* @param data the byte array containing the data bytes of the command body
|
|
* @param dataOffset the offset in the byte array at which the data
|
|
* bytes of the command body begin
|
|
* @param dataLength the number of the data bytes in the command body
|
|
* @param ne the maximum number of expected data bytes in a response APDU
|
|
*
|
|
* @throws NullPointerException if data is null and dataLength is not 0
|
|
* @throws IllegalArgumentException if dataOffset or dataLength are
|
|
* negative or if dataOffset + dataLength are greater than data.length,
|
|
* or if ne is negative or greater than 65536,
|
|
* or if dataLength is greater than 65535
|
|
*/
|
|
public CommandAPDU(int cla, int ins, int p1, int p2, byte[] data,
|
|
int dataOffset, int dataLength, int ne) {
|
|
checkArrayBounds(data, dataOffset, dataLength);
|
|
if (dataLength > 65535) {
|
|
throw new IllegalArgumentException("dataLength is too large");
|
|
}
|
|
if (ne < 0) {
|
|
throw new IllegalArgumentException("ne must not be negative");
|
|
}
|
|
if (ne > 65536) {
|
|
throw new IllegalArgumentException("ne is too large");
|
|
}
|
|
this.ne = ne;
|
|
this.nc = dataLength;
|
|
if (dataLength == 0) {
|
|
if (ne == 0) {
|
|
// case 1
|
|
this.apdu = new byte[4];
|
|
setHeader(cla, ins, p1, p2);
|
|
} else {
|
|
// case 2s or 2e
|
|
if (ne <= 256) {
|
|
// case 2s
|
|
// 256 is encoded as 0x00
|
|
byte len = (ne != 256) ? (byte)ne : 0;
|
|
this.apdu = new byte[5];
|
|
setHeader(cla, ins, p1, p2);
|
|
this.apdu[4] = len;
|
|
} else {
|
|
// case 2e
|
|
byte l1, l2;
|
|
// 65536 is encoded as 0x00 0x00
|
|
if (ne == 65536) {
|
|
l1 = 0;
|
|
l2 = 0;
|
|
} else {
|
|
l1 = (byte)(ne >> 8);
|
|
l2 = (byte)ne;
|
|
}
|
|
this.apdu = new byte[7];
|
|
setHeader(cla, ins, p1, p2);
|
|
this.apdu[5] = l1;
|
|
this.apdu[6] = l2;
|
|
}
|
|
}
|
|
} else {
|
|
if (ne == 0) {
|
|
// case 3s or 3e
|
|
if (dataLength <= 255) {
|
|
// case 3s
|
|
apdu = new byte[4 + 1 + dataLength];
|
|
setHeader(cla, ins, p1, p2);
|
|
apdu[4] = (byte)dataLength;
|
|
this.dataOffset = 5;
|
|
System.arraycopy(data, dataOffset, apdu, 5, dataLength);
|
|
} else {
|
|
// case 3e
|
|
apdu = new byte[4 + 3 + dataLength];
|
|
setHeader(cla, ins, p1, p2);
|
|
apdu[4] = 0;
|
|
apdu[5] = (byte)(dataLength >> 8);
|
|
apdu[6] = (byte)dataLength;
|
|
this.dataOffset = 7;
|
|
System.arraycopy(data, dataOffset, apdu, 7, dataLength);
|
|
}
|
|
} else {
|
|
// case 4s or 4e
|
|
if ((dataLength <= 255) && (ne <= 256)) {
|
|
// case 4s
|
|
apdu = new byte[4 + 2 + dataLength];
|
|
setHeader(cla, ins, p1, p2);
|
|
apdu[4] = (byte)dataLength;
|
|
this.dataOffset = 5;
|
|
System.arraycopy(data, dataOffset, apdu, 5, dataLength);
|
|
apdu[apdu.length - 1] = (ne != 256) ? (byte)ne : 0;
|
|
} else {
|
|
// case 4e
|
|
apdu = new byte[4 + 5 + dataLength];
|
|
setHeader(cla, ins, p1, p2);
|
|
apdu[4] = 0;
|
|
apdu[5] = (byte)(dataLength >> 8);
|
|
apdu[6] = (byte)dataLength;
|
|
this.dataOffset = 7;
|
|
System.arraycopy(data, dataOffset, apdu, 7, dataLength);
|
|
if (ne != 65536) {
|
|
int leOfs = apdu.length - 2;
|
|
apdu[leOfs] = (byte)(ne >> 8);
|
|
apdu[leOfs + 1] = (byte)ne;
|
|
} // else le == 65536: no need to fill in, encoded as 0
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void setHeader(int cla, int ins, int p1, int p2) {
|
|
apdu[0] = (byte)cla;
|
|
apdu[1] = (byte)ins;
|
|
apdu[2] = (byte)p1;
|
|
apdu[3] = (byte)p2;
|
|
}
|
|
|
|
/**
|
|
* Returns the value of the class byte CLA.
|
|
*
|
|
* @return the value of the class byte CLA.
|
|
*/
|
|
public int getCLA() {
|
|
return apdu[0] & 0xff;
|
|
}
|
|
|
|
/**
|
|
* Returns the value of the instruction byte INS.
|
|
*
|
|
* @return the value of the instruction byte INS.
|
|
*/
|
|
public int getINS() {
|
|
return apdu[1] & 0xff;
|
|
}
|
|
|
|
/**
|
|
* Returns the value of the parameter byte P1.
|
|
*
|
|
* @return the value of the parameter byte P1.
|
|
*/
|
|
public int getP1() {
|
|
return apdu[2] & 0xff;
|
|
}
|
|
|
|
/**
|
|
* Returns the value of the parameter byte P2.
|
|
*
|
|
* @return the value of the parameter byte P2.
|
|
*/
|
|
public int getP2() {
|
|
return apdu[3] & 0xff;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of data bytes in the command body (Nc) or 0 if this
|
|
* APDU has no body. This call is equivalent to
|
|
* <code>getData().length</code>.
|
|
*
|
|
* @return the number of data bytes in the command body or 0 if this APDU
|
|
* has no body.
|
|
*/
|
|
public int getNc() {
|
|
return nc;
|
|
}
|
|
|
|
/**
|
|
* Returns a copy of the data bytes in the command body. If this APDU as
|
|
* no body, this method returns a byte array with length zero.
|
|
*
|
|
* @return a copy of the data bytes in the command body or the empty
|
|
* byte array if this APDU has no body.
|
|
*/
|
|
public byte[] getData() {
|
|
byte[] data = new byte[nc];
|
|
System.arraycopy(apdu, dataOffset, data, 0, nc);
|
|
return data;
|
|
}
|
|
|
|
/**
|
|
* Returns the maximum number of expected data bytes in a response
|
|
* APDU (Ne).
|
|
*
|
|
* @return the maximum number of expected data bytes in a response APDU.
|
|
*/
|
|
public int getNe() {
|
|
return ne;
|
|
}
|
|
|
|
/**
|
|
* Returns a copy of the bytes in this APDU.
|
|
*
|
|
* @return a copy of the bytes in this APDU.
|
|
*/
|
|
public byte[] getBytes() {
|
|
return apdu.clone();
|
|
}
|
|
|
|
/**
|
|
* Returns a string representation of this command APDU.
|
|
*
|
|
* @return a String representation of this command APDU.
|
|
*/
|
|
public String toString() {
|
|
return "CommmandAPDU: " + apdu.length + " bytes, nc=" + nc + ", ne=" + ne;
|
|
}
|
|
|
|
/**
|
|
* Compares the specified object with this command APDU for equality.
|
|
* Returns true if the given object is also a CommandAPDU and its bytes are
|
|
* identical to the bytes in this CommandAPDU.
|
|
*
|
|
* @param obj the object to be compared for equality with this command APDU
|
|
* @return true if the specified object is equal to this command APDU
|
|
*/
|
|
public boolean equals(Object obj) {
|
|
if (this == obj) {
|
|
return true;
|
|
}
|
|
if (obj instanceof CommandAPDU == false) {
|
|
return false;
|
|
}
|
|
CommandAPDU other = (CommandAPDU)obj;
|
|
return Arrays.equals(this.apdu, other.apdu);
|
|
}
|
|
|
|
/**
|
|
* Returns the hash code value for this command APDU.
|
|
*
|
|
* @return the hash code value for this command APDU.
|
|
*/
|
|
public int hashCode() {
|
|
return Arrays.hashCode(apdu);
|
|
}
|
|
|
|
private void readObject(java.io.ObjectInputStream in)
|
|
throws java.io.IOException, ClassNotFoundException {
|
|
apdu = (byte[])in.readUnshared();
|
|
// initialize transient fields
|
|
parse();
|
|
}
|
|
|
|
}
|