sloghex.cpp

pc loader for 8051 based microcomputers

// SlogHEX.cpp: implementation of the CSlogHEX class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "SlogHEX.h"

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

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

CSlogHEX::CSlogHEX()
: duzina_m(0)
, adresa_m(0)
, tip_m(UNDEFINED)
, kontrolnaSuma_m(0)
{
}

CSlogHEX::~CSlogHEX()
{

}

bool CSlogHEX::Inicijalizuj
    (
    PRG::tBajt duzina,
    PRG::tAdresa adresa,
    ETip tip,
    PRG::tBajt* pPodaci,
    UINT duzinaPodatka,
    PRG::tBajt suma
    )
{
    bool bOK = true;

    duzina_m = duzina;
    adresa_m = adresa;
    tip_m = tip;
    // isprazni stare i napuni nove podatke
    podaci_m.clear();
    for (UINT i=0; i<duzinaPodatka; ++i) {
        podaci_m.push_back(pPodaci[i]);
    }
    kontrolnaSuma_m = suma;

    return bOK;
}

bool CSlogHEX::Inicijalizuj
    (
    PRG::tBajt duzina,
    PRG::tAdresa adresa,
    PRG::tBajt tip,
    PRG::tBajt* pPodaci,
    UINT duzinaPodatka,
    PRG::tBajt suma
    )
{
    return Inicijalizuj
        (
        duzina,
        adresa,
        BajtUTip(tip),
        pPodaci,
        duzinaPodatka,
        suma
        );
}

void CSlogHEX::Isprazni(void)
{
    Inicijalizuj(0, 0, UNDEFINED, 0, 0, 0);
}

bool CSlogHEX::ProveriKontrolnuSumu(void)
{
    // Za nedefinisani slog, sumu ne proveravam (uvek je OK)
    if (tip_m == UNDEFINED) return true;
    // Za sve ostale tipove suma se proverava na isti nacin
    return (kontrolnaSuma_m == SracunajSumu());
}

bool CSlogHEX::DajBajt(int redBr, PRG::tBajt& bajt, PRG::tAdresa& adresa)
{
    bool bOK = true;

    try {
        bajt = podaci_m.at(redBr);
        adresa = adresa_m + redBr;
    }
    catch (...) {
        bOK = false;
    }

    return bOK;
}

bool CSlogHEX::DataSlog(void)
{
    return (tip_m == DATA);
}

PRG::tBajt CSlogHEX::Duzina(void)
{
    return duzina_m;
}

bool CSlogHEX::EOFSlog(void)
{
    return (tip_m == END_OF_FILE);
}

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

CSlogHEX::ETip CSlogHEX::BajtUTip(PRG::tBajt bajt)
{
    ETip tip = UNDEFINED;
    switch (bajt) {
        case DATA:
        case END_OF_FILE:
        case EXTENDED_SEGMENT:
        case EXTENDED_LINEAR:
            tip = static_cast<ETip>(bajt);
            break;
        default:
            tip = UNDEFINED;
            break;
    }
    return tip;
}

PRG::tBajt CSlogHEX::SracunajSumu(void)
{
    // Za nedefinisani slog ne racunam sumu (suma je 0)
    if (tip_m == UNDEFINED) return 0;

    // Za ostale slogove suma se racuna kao dvojicni komplement 
    // zbira svih bajtova po modulu 256 :
    //  cc = 01H + NOT((ll + aa + aa + tt + dd + ...)mod256)
    using namespace PRG;
    tBajt cc = 0;
    //  - duzina (ll)
    cc += duzina_m;
    //  - adresa (aa + aa)
    tBajt adresaHI;
    tBajt adresaLO;
    RasclaniAdresuNaBajtove(adresaHI, adresaLO);
    cc += adresaHI;
    cc += adresaLO;
    //  - tip (tt)
    cc += tip_m;
    //  - podaci (dd + ...)
    tNizBajtova::const_iterator d_iterEnd = podaci_m.end();
    for (tNizBajtova::const_iterator d_iter = podaci_m.begin(); d_iter != d_iterEnd; ++d_iter) {
        cc += (*d_iter);
    }
    // mod 256
    cc = cc % 256;
    // dvojicni komplement
    cc = 0x01 + (~cc);

    return cc;
}

void CSlogHEX::RasclaniAdresuNaBajtove(PRG::tBajt& adresaHI, PRG::tBajt& adresaLO)
{
    adresaHI = (adresa_m >> 8) & 0xff;
    adresaLO = adresa_m & 0xff;
}