144 lines
4.3 KiB
C++
144 lines
4.3 KiB
C++
/*
|
|
* 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);
|
|
}
|