xref: /src/external/bsd/elftosb/dist/elftosb2/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;
}