Add KBOOT.

apps/elftosb/common/Version.cpp

@@ -0,0 +1,143 @@
+/*
+ * File:	Version.cpp
+ *
+ * Copyright (c) Freescale Semiconductor, Inc. All rights reserved.
+ * See included license file for license details.
+ */
+
+#include "Version.h"
+#include "EndianUtilities.h"
+
+using namespace elftosb;
+
+/*!
+ * Parses a string in the form "xxx.xxx.xxx" (where x is a digit) into
+ * three version fields for major, minor, and revision. The output is
+ * right aligned BCD in host-natural byte order.
+ *
+ * \param versionString String containing the version.
+ */
+void version_t::set(const std::string &versionString)
+{
+    size_t length = versionString.size();
+    unsigned version = 0;
+    unsigned index = 0;
+
+    typedef enum
+    {
+        kVersionStateNone,
+        kVersionStateMajor,
+        kVersionStateMinor,
+        kVersionStateRevision
+    } VersionParseState;
+
+    // set initial versions to 0s
+    m_major = 0;
+    m_minor = 0;
+    m_revision = 0;
+
+    VersionParseState parseState = kVersionStateNone;
+    bool done = false;
+    for (; index < length && !done; ++index)
+    {
+        char c = versionString[index];
+
+        if (isdigit(c))
+        {
+            switch (parseState)
+            {
+                case kVersionStateNone:
+                    parseState = kVersionStateMajor;
+                    version = c - '0';
+                    break;
+                case kVersionStateMajor:
+                case kVersionStateMinor:
+                case kVersionStateRevision:
+                    version = (version << 4) | (c - '0');
+                    break;
+            }
+        }
+        else if (c == '.')
+        {
+            switch (parseState)
+            {
+                case kVersionStateNone:
+                    parseState = kVersionStateNone;
+                    break;
+                case kVersionStateMajor:
+                    m_major = version;
+                    version = 0;
+                    parseState = kVersionStateMinor;
+                    break;
+                case kVersionStateMinor:
+                    m_minor = version;
+                    version = 0;
+                    parseState = kVersionStateRevision;
+                    break;
+                case kVersionStateRevision:
+                    m_revision = version;
+                    version = 0;
+                    done = true;
+                    break;
+            }
+        }
+        else
+        {
+            switch (parseState)
+            {
+                case kVersionStateNone:
+                    parseState = kVersionStateNone;
+                    break;
+                case kVersionStateMajor:
+                    m_major = version;
+                    done = true;
+                    break;
+                case kVersionStateMinor:
+                    m_minor = version;
+                    done = true;
+                    break;
+                case kVersionStateRevision:
+                    m_revision = version;
+                    done = true;
+                    break;
+            }
+        }
+    }
+
+    switch (parseState)
+    {
+        case kVersionStateMajor:
+            m_major = version;
+            break;
+        case kVersionStateMinor:
+            m_minor = version;
+            break;
+        case kVersionStateRevision:
+            m_revision = version;
+            break;
+        default:
+            // do nothing
+            break;
+    }
+}
+
+//! \brief Converts host endian BCD version values to the equivalent big-endian BCD values.
+//!
+//! The output is a half-word. And BCD is inherently big-endian, or byte ordered, if
+//! you prefer to think of it that way. So for little endian systems, we need to convert
+//! the output half-word in reverse byte order. When it is written to disk or a
+//! buffer it will come out big endian.
+//!
+//! For example:
+//!     - The input is BCD in host endian format, so 0x1234. Written to a file, this would
+//!       come out as 0x34 0x12, reverse of what we want.
+//!     - The desired BCD output is the two bytes 0x12 0x34.
+//!     - So the function's uint16_t result must be 0x3412 on a little-endian host.
+//!
+//! On big endian hosts, we don't have to worry about byte swapping.
+void version_t::fixByteOrder()
+{
+    m_major = ENDIAN_HOST_TO_BIG_U16(m_major);
+    m_minor = ENDIAN_HOST_TO_BIG_U16(m_minor);
+    m_revision = ENDIAN_HOST_TO_BIG_U16(m_revision);
+}