/*
 * Copyright 2009-2012, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */

#include "AbbreviationTable.h"

#include <stdio.h>

#include <new>


AbbreviationTable::AbbreviationTable(off_t offset)
	:
	fOffset(offset),
	fData(NULL),
	fSize(0)
{
}


AbbreviationTable::~AbbreviationTable()
{
	AbbreviationTableEntry* entry = fEntryTable.Clear(true);
	while (entry != NULL) {
		AbbreviationTableEntry* next = entry->next;
		delete entry;
		entry = next;
	}
}


status_t
AbbreviationTable::Init(const void* section, off_t sectionSize)
{
	if (fOffset < 0 || fOffset >= sectionSize)
		return B_BAD_DATA;

	fData = (uint8*)section + fOffset;
	fSize = sectionSize - fOffset;
		// That's only the maximum size. Will be adjusted at the end.

	status_t error = fEntryTable.Init();
	if (error != B_OK)
		return error;

	DataReader abbrevReader(fData, fSize, 4, false);
		// address size and endianness don't matter here

	while (true) {
		bool nullEntry;
		status_t error = _ParseAbbreviationEntry(abbrevReader, nullEntry);
		if (error != B_OK)
			return error;

		if (nullEntry)
			break;
	}

	fSize -= abbrevReader.BytesRemaining();

	return B_OK;
}


bool
AbbreviationTable::GetAbbreviationEntry(uint32 code, AbbreviationEntry& entry)
{
	AbbreviationTableEntry* tableEntry = fEntryTable.Lookup(code);
	if (tableEntry == NULL)
		return false;

	entry.SetTo(code, fData + tableEntry->offset, tableEntry->size);
	return true;
}


status_t
AbbreviationTable::_ParseAbbreviationEntry(DataReader& abbrevReader,
	bool& _nullEntry)
{
	uint32 code = abbrevReader.ReadUnsignedLEB128(0);
	if (code == 0) {
		if (abbrevReader.HasOverflow()) {
			fprintf(stderr, "Invalid abbreviation table 1!\n");
			return B_BAD_DATA;
		}
		_nullEntry = true;
		return B_OK;
	}

	off_t remaining = abbrevReader.BytesRemaining();

/*	uint32 tag =*/ abbrevReader.ReadUnsignedLEB128(0);
/*	uint8 hasChildren =*/ abbrevReader.Read<uint8>(DW_CHILDREN_no);

//	printf("entry: %" B_PRIu32 ", tag: %" B_PRIu32 ", children: %d\n", code, tag,
//		hasChildren);

	// parse attribute specifications
	while (true) {
		uint32 attributeName = abbrevReader.ReadUnsignedLEB128(0);
		uint32 attributeForm = abbrevReader.ReadUnsignedLEB128(0);
		if (abbrevReader.HasOverflow()) {
			fprintf(stderr, "Invalid abbreviation table 2!\n");
			return B_BAD_DATA;
		}

		if (attributeName == 0 && attributeForm == 0)
			break;

		if (attributeForm == DW_FORM_implicit_const)
			abbrevReader.ReadSignedLEB128(0);

//		printf("  attr: name: %" B_PRIu32 ", form: %" B_PRIu32 "\n", attributeName,
//			attributeForm);
	}

	// create the entry
	if (fEntryTable.Lookup(code) == NULL) {
		AbbreviationTableEntry* entry = new(std::nothrow)
			AbbreviationTableEntry(code, fSize - remaining,
				remaining - abbrevReader.BytesRemaining());
		if (entry == NULL)
			return B_NO_MEMORY;

		fEntryTable.Insert(entry);
	} else {
		fprintf(stderr, "Duplicate abbreviation table entry %" B_PRIu32 "!\n",
			code);
	}

	_nullEntry = false;
	return B_OK;
}