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


#include "DisassembledCode.h"

#include <stdlib.h>
#include <string.h>

#include <new>

#include <String.h>

#include "SourceLanguage.h"
#include "Statement.h"


struct DisassembledCode::Line {
        BString                                 line;
        ContiguousStatement*    statement;

        Line(const BString& line, ContiguousStatement* statement)
                :
                line(line),
                statement(statement)
        {
        }
};


DisassembledCode::DisassembledCode(SourceLanguage* language)
        :
        fLanguage(language),
        fLines(20)
{
        fLanguage->AcquireReference();
}


DisassembledCode::~DisassembledCode()
{
        for (int32 i = 0; Statement* statement = fStatements.ItemAt(i); i++)
                statement->ReleaseReference();

        fLanguage->ReleaseReference();
}


bool
DisassembledCode::Lock()
{
        // We're immutable, so no locking required.
        return true;
}


void
DisassembledCode::Unlock()
{
}


SourceLanguage*
DisassembledCode::GetSourceLanguage() const
{
        return fLanguage;
}


int32
DisassembledCode::CountLines() const
{
        return fLines.CountItems();
}


const char*
DisassembledCode::LineAt(int32 index) const
{
        Line* line = fLines.ItemAt(index);
        return line != NULL ? line->line.String() : NULL;
}


int32
DisassembledCode::LineLengthAt(int32 index) const
{
        Line* line = fLines.ItemAt(index);
        return line != NULL ? line->line.Length() : 0;
}


bool
DisassembledCode::GetStatementLocationRange(const SourceLocation& location,
        SourceLocation& _start, SourceLocation& _end) const
{
        Line* line = fLines.ItemAt(location.Line());
        if (line == NULL || line->statement == NULL)
                return false;

        _start = line->statement->StartSourceLocation();
        _end = SourceLocation(_start.Line() + 1);
                // TODO: Multi-line instructions!
        return true;
}


LocatableFile*
DisassembledCode::GetSourceFile() const
{
        return NULL;
}


Statement*
DisassembledCode::StatementAtLocation(const SourceLocation& location) const
{
        Line* line = fLines.ItemAt(location.Line());
        return line != NULL ? line->statement : NULL;
}


Statement*
DisassembledCode::StatementAtAddress(target_addr_t address) const
{
        return fStatements.BinarySearchByKey(address, &_CompareAddressStatement);
}


TargetAddressRange
DisassembledCode::StatementAddressRange() const
{
        if (fStatements.IsEmpty())
                return TargetAddressRange();

        ContiguousStatement* first = fStatements.ItemAt(0);
        ContiguousStatement* last
                = fStatements.ItemAt(fStatements.CountItems() - 1);
        return TargetAddressRange(first->AddressRange().Start(),
                last->AddressRange().End());
}


bool
DisassembledCode::AddCommentLine(const BString& line)
{
        return _AddLine(line, NULL);
}


bool
DisassembledCode::AddInstructionLine(const BString& line, target_addr_t address,
        target_size_t size)
{
        int32 lineIndex = fLines.CountItems();

        ContiguousStatement* statement = new(std::nothrow) ContiguousStatement(
                SourceLocation(lineIndex), TargetAddressRange(address, size));
        if (statement == NULL)
                return false;

        if (!fStatements.AddItem(statement)) {
                delete statement;
                return false;
        }

        if (!_AddLine(line, statement))
                return false;

        return true;
}


bool
DisassembledCode::_AddLine(const BString& _line, ContiguousStatement* statement)
{
        Line* line = new(std::nothrow) Line(_line, statement);
        if (line == NULL)
                return false;

        if (!fLines.AddItem(line)) {
                delete line;
                return false;
        }

        return true;
}


/*static*/ int
DisassembledCode::_CompareAddressStatement(const target_addr_t* address,
        const ContiguousStatement* statement)
{
        const TargetAddressRange& range = statement->AddressRange();

        if (*address < range.Start())
                return -1;
        return *address < range.End() ? 0 : 1;
}