Major code style change to rename all files to lower case.
diff --git a/ndn-cpp/c/encoding/binary-xml-decoder.c b/ndn-cpp/c/encoding/binary-xml-decoder.c
new file mode 100644
index 0000000..7e2140d
--- /dev/null
+++ b/ndn-cpp/c/encoding/binary-xml-decoder.c
@@ -0,0 +1,292 @@
+/**
+ * @author: Jeff Thompson
+ * Derived from BinaryXMLDecoder.js by Meki Cheraoui.
+ * See COPYING for copyright and distribution information.
+ */
+
+#include "binary-xml.h"
+#include "binary-xml-decoder.h"
+
+/**
+ * Return the octet at self->offset, converting to unsigned int. Increment self->offset.
+ * This does not check for reading past the end of the input, so this is called "unsafe".
+ */
+static inline unsigned int unsafeReadOctet(struct ndn_BinaryXmlDecoder *self)
+{
+ return (unsigned int)(self->input[self->offset++] & 0xff);
+}
+
+/**
+ * Return the octet at self->offset, converting to unsigned int. Do not increment self->offset.
+ * This does not check for reading past the end of the input, so this is called "unsafe".
+ */
+static inline unsigned int unsafeGetOctet(struct ndn_BinaryXmlDecoder *self)
+{
+ return (unsigned int)(self->input[self->offset] & 0xff);
+}
+
+/**
+ * Parse the value as a decimal unsigned integer. This does not check for whitespace or + sign.
+ * If valueLength is 0, this succeeds with resultOut 0.
+ * @param value
+ * @param valueLength
+ * @param resultOut output the parsed integer.
+ * @return 0 for success, else an error code, including if an element of value is not a decimal digit.
+ */
+static ndn_Error parseUnsignedDecimalInt(unsigned char *value, unsigned int valueLength, unsigned int *resultOut)
+{
+ unsigned int result = 0;
+
+ unsigned int i;
+ for (i = 0; i < valueLength; ++i) {
+ unsigned char digit = value[i];
+ if (!(digit >= '0' && digit <= '9'))
+ return NDN_ERROR_element_of_value_is_not_a_decimal_digit;
+
+ result *= 10;
+ result += (unsigned int)(digit - '0');
+ }
+
+ *resultOut = result;
+ return 0;
+}
+
+ndn_Error ndn_BinaryXmlDecoder_decodeTypeAndValue(struct ndn_BinaryXmlDecoder *self, unsigned int *type, unsigned int *valueOut)
+{
+ unsigned int value = 0;
+ int gotFirstOctet = 0;
+
+ while (1) {
+ if (self->offset >= self->inputLength)
+ return NDN_ERROR_read_past_the_end_of_the_input;
+
+ unsigned int octet = unsafeReadOctet(self);
+
+ if (!gotFirstOctet) {
+ if (octet == 0)
+ return NDN_ERROR_the_first_header_octet_may_not_be_zero;
+
+ gotFirstOctet = 1;
+ }
+
+ if (octet & ndn_BinaryXml_TT_FINAL) {
+ // Finished.
+ *type = octet & ndn_BinaryXml_TT_MASK;
+ value = (value << ndn_BinaryXml_TT_VALUE_BITS) | ((octet >> ndn_BinaryXml_TT_BITS) & ndn_BinaryXml_TT_VALUE_MASK);
+ break;
+ }
+
+ value = (value << ndn_BinaryXml_REGULAR_VALUE_BITS) | (octet & ndn_BinaryXml_REGULAR_VALUE_MASK);
+ }
+
+ *valueOut = value;
+ return 0;
+}
+
+ndn_Error ndn_BinaryXmlDecoder_readElementStartDTag(struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag)
+{
+ ndn_Error error;
+ unsigned int type;
+ unsigned int value;
+ if (error = ndn_BinaryXmlDecoder_decodeTypeAndValue(self, &type, &value))
+ return error;
+
+ if (type != ndn_BinaryXml_DTAG)
+ return NDN_ERROR_header_type_is_not_a_DTAG;
+
+ if (value != expectedTag)
+ return NDN_ERROR_did_not_get_the_expected_DTAG;
+
+ return 0;
+}
+
+ndn_Error ndn_BinaryXmlDecoder_readElementClose(struct ndn_BinaryXmlDecoder *self)
+{
+ if (self->offset >= self->inputLength)
+ return NDN_ERROR_read_past_the_end_of_the_input;
+
+ if (unsafeReadOctet(self) != ndn_BinaryXml_CLOSE)
+ return NDN_ERROR_did_not_get_the_expected_element_close;
+
+ return 0;
+}
+
+ndn_Error ndn_BinaryXmlDecoder_peekDTag(struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, int *gotExpectedTag)
+{
+ // Default to 0.
+ *gotExpectedTag = 0;
+
+ // First check if it is an element close (which cannot be the expected tag).
+ if (self->offset >= self->inputLength)
+ return NDN_ERROR_read_past_the_end_of_the_input;
+ if (unsafeGetOctet(self) == 0)
+ return 0;
+
+ unsigned int type;
+ unsigned int value;
+ unsigned int saveOffset = self->offset;
+ ndn_Error error = ndn_BinaryXmlDecoder_decodeTypeAndValue(self, &type, &value);
+ // Restore offset.
+ self->offset = saveOffset;
+
+ if (error)
+ return error;
+
+ if (type == ndn_BinaryXml_DTAG && value == expectedTag)
+ *gotExpectedTag = 1;
+
+ return 0;
+}
+
+ndn_Error ndn_BinaryXmlDecoder_readBinaryDTagElement
+ (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, int allowNull, unsigned char **value, unsigned int *valueLength)
+{
+ ndn_Error error;
+ if (error = ndn_BinaryXmlDecoder_readElementStartDTag(self, expectedTag))
+ return error;
+
+ if (allowNull) {
+ if (self->offset >= self->inputLength)
+ return NDN_ERROR_read_past_the_end_of_the_input;
+
+ if (unsafeGetOctet(self) == ndn_BinaryXml_CLOSE) {
+ // The binary item is missing, and this is allowed, so read the element close and return a null value.
+ ++self->offset;
+ *value = 0;
+ *valueLength = 0;
+ return 0;
+ }
+ }
+
+ unsigned int itemType;
+ if (error = ndn_BinaryXmlDecoder_decodeTypeAndValue(self, &itemType, valueLength))
+ return error;
+ // Ignore itemType.
+ *value = self->input + self->offset;
+ self->offset += *valueLength;
+
+ if (error = ndn_BinaryXmlDecoder_readElementClose(self))
+ return error;
+
+ return 0;
+}
+
+ndn_Error ndn_BinaryXmlDecoder_readOptionalBinaryDTagElement
+ (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, int allowNull, unsigned char **value, unsigned int *valueLength)
+{
+ ndn_Error error;
+ int gotExpectedTag;
+ if (error = ndn_BinaryXmlDecoder_peekDTag(self, expectedTag, &gotExpectedTag))
+ return error;
+ if (gotExpectedTag) {
+ if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement(self, expectedTag, allowNull, value, valueLength))
+ return error;
+ }
+ else {
+ *value = 0;
+ *valueLength = 0;
+ }
+
+ return 0;
+}
+
+ndn_Error ndn_BinaryXmlDecoder_readUDataDTagElement
+ (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, unsigned char **value, unsigned int *valueLength)
+{
+ ndn_Error error;
+ if (error = ndn_BinaryXmlDecoder_readElementStartDTag(self, expectedTag))
+ return error;
+
+ unsigned int itemType;
+ if (error = ndn_BinaryXmlDecoder_decodeTypeAndValue(self, &itemType, valueLength))
+ return error;
+ if (itemType != ndn_BinaryXml_UDATA)
+ return NDN_ERROR_item_is_not_UDATA;
+ *value = self->input + self->offset;
+ self->offset += *valueLength;
+
+ if (error = ndn_BinaryXmlDecoder_readElementClose(self))
+ return error;
+
+ return 0;
+}
+
+ndn_Error ndn_BinaryXmlDecoder_readUnsignedIntegerDTagElement
+ (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, unsigned int *value)
+{
+ unsigned char *udataValue;
+ unsigned int udataValueLength;
+ ndn_Error error;
+ if (error = ndn_BinaryXmlDecoder_readUDataDTagElement(self, expectedTag, &udataValue, &udataValueLength))
+ return error;
+
+ if (error = parseUnsignedDecimalInt(udataValue, udataValueLength, value))
+ return error;
+
+ return 0;
+}
+
+ndn_Error ndn_BinaryXmlDecoder_readOptionalUnsignedIntegerDTagElement
+ (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, int *value)
+{
+ int gotExpectedTag;
+ ndn_Error error;
+ if (error = ndn_BinaryXmlDecoder_peekDTag(self, expectedTag, &gotExpectedTag))
+ return error;
+
+ if (!gotExpectedTag) {
+ *value = -1;
+ return 0;
+ }
+
+ unsigned int unsignedValue;
+ if (error = ndn_BinaryXmlDecoder_readUnsignedIntegerDTagElement(self, expectedTag, &unsignedValue))
+ return error;
+
+ *value = (int)unsignedValue;
+ return 0;
+}
+
+ndn_Error ndn_BinaryXmlDecoder_readTimeMillisecondsDTagElement
+ (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, double *milliseconds)
+{
+ ndn_Error error;
+ unsigned char *bytes;
+ unsigned int bytesLength;
+ if (error = ndn_BinaryXmlDecoder_readBinaryDTagElement(self, expectedTag, 0, &bytes, &bytesLength))
+ return error;
+
+ *milliseconds = 1000.0 * ndn_BinaryXmlDecoder_unsignedBigEndianToDouble(bytes, bytesLength) / 4096.0;
+ return 0;
+}
+
+ndn_Error ndn_BinaryXmlDecoder_readOptionalTimeMillisecondsDTagElement
+ (struct ndn_BinaryXmlDecoder *self, unsigned int expectedTag, double *milliseconds)
+{
+ int gotExpectedTag;
+ ndn_Error error;
+ if (error = ndn_BinaryXmlDecoder_peekDTag(self, expectedTag, &gotExpectedTag))
+ return error;
+
+ if (!gotExpectedTag) {
+ *milliseconds = -1.0;
+ return 0;
+ }
+
+ if (error = ndn_BinaryXmlDecoder_readTimeMillisecondsDTagElement(self, expectedTag, milliseconds))
+ return error;
+
+ return 0;
+}
+
+double ndn_BinaryXmlDecoder_unsignedBigEndianToDouble(unsigned char *bytes, unsigned int bytesLength)
+{
+ double result = 0.0;
+ unsigned int i;
+ for (i = 0; i < bytesLength; ++i) {
+ result *= 256.0;
+ result += (double)bytes[i];
+ }
+
+ return result;
+}