punjachex.cpp

pc loader for 8051 based microcomputers

// PunjacHex.cpp: implementation of the CPunjacHex class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "PunjacHex.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CPunjacHex::CPunjacHex(const std::string& nazivFajla)
: CPunjacFajl(nazivFajla)
, indeksBajta_m(0)
{

}

CPunjacHex::CPunjacHex(CFile* pFajl)
: CPunjacFajl(pFajl)
, indeksBajta_m(0)
{
}

CPunjacHex::~CPunjacHex()
{

}

bool CPunjacHex::Start(
    PRG::tAdresa pocetnaAdresa,
    PRG::tAdresa zavrsnaAdresa,
    std::string& opis
    )
{
    PostaviOpsegAdresa(pocetnaAdresa, zavrsnaAdresa);

    if (PripremiFajlZaCitanje(opis)) {
        slogHEX_m.Isprazni();
        indeksBajta_m = 0;
        return true;
    }
    return false;
}

bool CPunjacHex::DajSledeciBajt(PRG::tBajt& bajt, PRG::tAdresa& adresa)
{
    // Proveri da li u tekucem slogu ima jos podataka (masinskih instrukcija)
    if (slogHEX_m.DataSlog()) {
        if (DajSledeciBajtDataSloga(bajt, adresa)){
            return true;
        }
    }
    // Ako nema vise bajtova u tekucem slogu, ucitaj novi slog
    while (ProcitajSlog()) {
        // Proveri kontrolnu sumu sloga
        if (!slogHEX_m.ProveriKontrolnuSumu()) {
            throw CProgramPunjac::CPunjacException("error in file: bad record checksum");
        }
        // Proveri tip sloga
        if (slogHEX_m.DataSlog()) { // DATA slog 
            if (DajSledeciBajtDataSloga(bajt, adresa)) {
                return true;
            }
            else {
                continue; // citaj sledeci slog
            }
        }
        else if (slogHEX_m.EOFSlog()) { // EOF slog
            return false;
        }
        else { // ostali tipovi slogova nisu podrzani
            throw CProgramPunjac::CPunjacException("unsupported record type");
        }
    }
    return false;
}

//////////////////////////////////////////////////////////////////////
// Pomocne funkcije
//////////////////////////////////////////////////////////////////////

bool CPunjacHex::ProcitajSlog(void)
{
    BYTE bajtNepotreban;

    // procitaj znak dve tacke (oznaka pocetka sloga)
    if (!ProcitajBajt(bajtNepotreban)) return false;

    // procitaj duzinu sloga
    PRG::tBajt duzina;
    if (!ProcitajASCII_HEX(duzina)) return false;

    // procitaj adresu (2 bajta)
    PRG::tBajt adresaHI;
    if (!ProcitajASCII_HEX(adresaHI)) return false;
    PRG::tBajt adresaLO;
    if (!ProcitajASCII_HEX(adresaLO)) return false;
    PRG::tAdresa adresa = FormirajAdresu(adresaHI, adresaLO);

    // procitaj tip sloga
    PRG::tBajt tip;
    if (!ProcitajASCII_HEX(tip)) return false;

    // procitaj podatke
    BYTE buffer[MAX_BYTES_SLOG];
    const int brojBajtova = duzina*2;
    if (!ProcitajBajtove(buffer, brojBajtova)) return false;
    // spoji svaka dva bajta podatka u jedan hex
    PRG::tBajt podaciHex[MAX_BYTES_SLOG];
    int podatakIndeks = 0;
    for (int i=0; i<brojBajtova; i+=2) {
        podaciHex[podatakIndeks] = FormirajASCII_HEX(buffer[i], buffer[i+1]);
        ++podatakIndeks;
    }

    // procitaj kontrolnu sumu
    PRG::tBajt suma;
    if (!ProcitajASCII_HEX(suma)) return false;

    // procitaj CR i LF (ako ima)
    if (ProcitajBajt(bajtNepotreban)) {
        ProcitajBajt(bajtNepotreban);
    }

    // Formiraj slog od procitanih podataka
    slogHEX_m.Inicijalizuj
        (
        duzina,
        adresa,
        tip,
        podaciHex,
        podatakIndeks,
        suma
        );

    // Resetuj indeks za obilazak data sloga
    indeksBajta_m = 0;

    return true;
}

bool CPunjacHex::ProcitajASCII_HEX(PRG::tBajt& bajt)
{
    BYTE visiNibl;
    if (!ProcitajBajt(visiNibl)) return false;
    BYTE niziNibl;
    if (!ProcitajBajt(niziNibl)) return false;

    bajt = FormirajASCII_HEX(visiNibl, niziNibl);

    return true;
}

BYTE CPunjacHex::KonvertujBajtASCII_HEX(BYTE bajt)
{
    BYTE hexBajt;
    if      (bajt >= '0' && bajt <= '9') {
        hexBajt = bajt - '0';
    }
    else if (bajt >= 'a' && bajt <= 'f') {
        hexBajt = bajt - 'a' + 0x0a;
    }
    else if (bajt >= 'A' && bajt <= 'F') {
        hexBajt = bajt - 'A' + 0x0a;
    }
    else {
        throw CProgramPunjac::CPunjacException("bad format");
    }
    return hexBajt;
}

PRG::tBajt CPunjacHex::FormirajASCII_HEX(BYTE visiNibl, BYTE niziNibl)
{
    PRG::tBajt bajt;
    BYTE visiNiblHex;
    BYTE niziNiblHex;

    visiNiblHex = KonvertujBajtASCII_HEX(visiNibl);
    niziNiblHex = KonvertujBajtASCII_HEX(niziNibl);
    bajt = niziNiblHex & 0x0f;
    bajt |= ((visiNiblHex << 4) & 0xf0);

    return bajt;
}

PRG::tAdresa CPunjacHex::FormirajAdresu(PRG::tBajt adresaHI, PRG::tBajt adresaLO)
{
    PRG::tAdresa adresa;

    adresa = (adresaLO & 0x00ff);
    adresa |= ((adresaHI << 8) & 0xff00);

    return adresa;
}

bool CPunjacHex::DajSledeciBajtDataSloga(PRG::tBajt& bajt, PRG::tAdresa& adresa)
{
    bool bajtProcitan = false;

    do {
        if (slogHEX_m.DajBajt(indeksBajta_m, bajt, adresa)) {
            bajtProcitan = true;
            ++indeksBajta_m;
        }
        else {
            bajtProcitan = false;
            break;
        }
    } while (!AdresaUZadatomOpsegu(adresa));

    return bajtProcitan;
}