* File: ElftosbLexer.cpp

/*
* File: ElftosbLexer.cpp
*
* Copyright (c) Freescale Semiconductor, Inc. All rights reserved.
* See included license file for license details.
*/
#include "ElftosbLexer.h"
#include <algorithm>
#include "HexValues.h"

using namespace elftosb;

ElftosbLexer::ElftosbLexer(istream & inputStream)
: yyFlexLexer(&inputStream), m_line(1), m_blob(0), m_blobFirstLine(0)
{
}

void ElftosbLexer::getSymbolValue(YYSTYPE * value)
{
if (!value)
{
return;
}
*value = m_symbolValue;
}

void ElftosbLexer::addSourceName(std::string * ident)
{
m_sources.push_back(*ident);
}

bool ElftosbLexer::isSourceName(std::string * ident)
{
string_vector_t::iterator it = find(m_sources.begin(), m_sources.end(), *ident);
return it != m_sources.end();
}

void ElftosbLexer::LexerError(const char * msg)
{
throw elftosb::lexical_error(msg);
}

//! Reads the \a in string and writes to the \a out string. These strings can be the same
//! string since the read head is always in front of the write head.
//!
//! \param[in] in Input string containing C-style escape sequences.
//! \param[out] out Output string. All escape sequences in the input string have been converted
//! to the actual characters. May point to the same string as \a in.
//! \return The length of the resulting \a out string. This length is necessary because
//! the string may have contained escape sequences that inserted null characters.
int ElftosbLexer::processStringEscapes(const char * in, char * out)
{
int count = 0;
while (*in)
{
switch (*in)
{
case '\\':
{
// start of an escape sequence
char c = *++in;
switch (c)
{
case 0: // end of the string, bail
break;
case 'x':
{
// start of a hex char escape sequence

// read high and low nibbles, checking for end of string
char hi = *++in;
if (hi == 0) break;
char lo = *++in;
if (lo == 0) break;

if (isHexDigit(hi) && isHexDigit(lo))
{
if (hi >= '0' && hi <= '9')
c = (hi - '0') << 4;
else if (hi >= 'A' && hi <= 'F')
c = (hi - 'A' + 10) << 4;
else if (hi >= 'a' && hi <= 'f')
c = (hi - 'a' + 10) << 4;

if (lo >= '0' && lo <= '9')
c |= lo - '0';
else if (lo >= 'A' && lo <= 'F')
c |= lo - 'A' + 10;
else if (lo >= 'a' && lo <= 'f')
c |= lo - 'a' + 10;

*out++ = c;
count++;
}
else
{
// not hex digits, the \x must have wanted an 'x' char
*out++ = 'x';
*out++ = hi;
*out++ = lo;
count += 3;
}
break;
}
case 'n':
*out++ = '\n';
count++;
break;
case 't':
*out++ = '\t';
count++;
break;
case 'r':
*out++ = '\r';
count++;
break;
case 'b':
*out++ = '\b';
count++;
break;
case 'f':
*out++ = '\f';
count++;
break;
case '0':
*out++ = '\0';
count++;
break;
default:
*out++ = c;
count++;
break;
}
break;
}

default:
// copy all other chars directly
*out++ = *in++;
count++;
}
}

// place terminating null char on output
*out = 0;
return count;
}