Vcsos.Komponent.Akku Class Reference

Akku des Virtualen SoCs More...

Public Member Functions
	Akku (Core pCpu)
	Konstruktor des Akkus More...
void	MoveAX (Int32 data)
	Weist dem CPU-Register AX ein wert zu More...
int	MoveFromAX ()
	lese die Daten aus dem Register AX More...
int	MoveFromBX ()
	lese die Daten aus dem Register BX More...
int	Add (int data)
	Addiere den Wert aus Parameter mit dem Register AX More...
int	Dec (int data)
	Decriment der Daten More...
int	Inc (int data)
	Increnent More...
int	CmplTwo (int data)
	Berechne das 2er Kompliment More...
int	Mul (int data)
	Multipliziere Data mit Register AX More...
int	Mul (int a, int data)
int	Div (int data)
int	Div (int a, int data)
int	Sub (int data)
	Subtration vom Register AX More...
int	Sub (int a, int b)
int	Add (int A, int B)
	Addition zweier Zahlen (32bit) More...

Detailed Description

Akku des Virtualen SoCs

Constructor & Destructor Documentation

Akku()

Vcsos.Komponent.Akku.Akku

(

Core

pCpu

)

Konstruktor des Akkus

Parameters

pCpu	Der zu verwendene CPU

        {
            m_pCpu = pCpu;
        }

Member Function Documentation

Add() [1/2]

int Vcsos.Komponent.Akku.Add

(

int

data

)

Addiere den Wert aus Parameter mit dem Register AX

Parameters

data

Returns

Die Summe der Addition

        {
            int result = 0;
            int carry = (int)(m_pCpu.Register.CarryFlag ? 1 : 0);

            m_pCpu.Register.OverFlow = Add (m_pCpu.Register.ax, data, ref carry, ref result);
            m_pCpu.Register.ax = result;
            m_pCpu.Register.CarryFlag = carry == 1;
            m_pCpu.Register.UnderFlow = false;

            return result;
        }

Add() [2/2]

int Vcsos.Komponent.Akku.Add	(	int	A,
		int	B
	)

Addition zweier Zahlen (32bit)

Parameters

A	Erster Summand der Addition
B	Zweiter Summand der Addition

Returns

Ergebniss der Addition von A und B

        {
            int result = 0;
            int carry = (int)(m_pCpu.Register.CarryFlag ? 1 : 0);

            m_pCpu.Register.OverFlow = Add (A, B, ref carry, ref result);
            m_pCpu.Register.CarryFlag = carry == 1;
            return result;
        }

CmplTwo()

int Vcsos.Komponent.Akku.CmplTwo

(

int

data

)

Berechne das 2er Kompliment

Parameters

data	Die Daten von denen das 2er Kompliment erstellt werden soll

Returns

Das 2er Kompliment

        {
            return ~data + 1;
        }

Dec()

int Vcsos.Komponent.Akku.Dec

(

int

data

)

Decriment der Daten

Parameters

data	Die zu Decrimente Zahl

Returns

Das ergebniss

        {
            return Add (data, -1);
        }

Div() [1/2]

int Vcsos.Komponent.Akku.Div

(

int

data

)

Dividiere Register AX mit data

Parameters

data

Returns

Das ergebniss der Operation

        {
            if (m_pCpu.Register.ax == 0) // Ist Register AX gleich 0...
            {
                // Setze Flag DivByZero
                m_pCpu.Register.DivByZero = true;
                // gebe null zurück
                return 0;
            }
            // Ist data positive dann setze AkkuHelp auf true
            m_pCpu.Register.AkkuHelp = (data > 0);
            // weise data zu - Ist AkkuHelp true dann das 2er Kompliment sonst data
            data = (!m_pCpu.Register.AkkuHelp) ? CmplTwo(data) : data;

            // Weise dem Register CX den Wert aus Register AX zu
            m_pCpu.Register.cx = m_pCpu.Register.ax;
            // Weise dem Register BX zu - Ist Register AX negative das 2er Kompliment von Register AX
            // sonst den Wert aus Register AX
            m_pCpu.Register.bx = (m_pCpu.Register.ax < 0) ? 
                CmplTwo(m_pCpu.Register.ax) : m_pCpu.Register.ax;
            // Weise dem Register AX null zu
            m_pCpu.Register.ax = 0;

            // Führe die Division als Addition durch 
            while (m_pCpu.Register.bx >= data) { // solange wie Register BX größer data ist 
                // Weise dem Register BX das Ergebniss aus der Addition von Register BX und
                // dem 2er Kompliment von data zu
                m_pCpu.Register.bx = Add(m_pCpu.Register.bx, ~data + 1);
                // Weise dem Carry Flag false zu
                m_pCpu.Register.CarryFlag = false;
                // Addiere auf Register AX eine 1 
                Add(1);
            }
            // Weise dem Register AX das Ergebniss der Division zu
            m_pCpu.Register.ax = (!m_pCpu.Register.AkkuHelp ^ !(m_pCpu.Register.cx > 0)) ? CmplTwo( m_pCpu.Register.ax) 
                : m_pCpu.Register.ax;
            
            // Gebe das Ergebniss aus dem Register AX zurück
            return m_pCpu.Register.ax;
        }

Div() [2/2]

int Vcsos.Komponent.Akku.Div	(	int	a,
		int	data
	)

        {
            if (a == 0) // Ist a gleich 0...
            {
                // Setze Flag DivByZero
                m_pCpu.Register.DivByZero = true;
                // gebe null zurück
                return 0;
            }
            // Ist data positive dann setze AkkuHelp auf true
            m_pCpu.Register.AkkuHelp = (data > 0);
            // weise data zu - Ist AkkuHelp true dann das 2er Kompliment sonst data
            data = (!m_pCpu.Register.AkkuHelp) ? CmplTwo(data) : data;

            // Weise dem Register CX den Wert a zu
            m_pCpu.Register.cx = a;
            // Weise dem Register BX zu - Ist a negative das 2er Kompliment von a
            // sonst a
            m_pCpu.Register.bx = (a < 0) ?
                CmplTwo(a) : a;
            // Weise dem Register a null zu
            a = 0;

            // Führe die Division als Addition durch 
            while (m_pCpu.Register.bx >= data)
            { // solange wie Register BX größer data ist 
              // Weise dem Register BX das Ergebniss aus der Addition von Register BX und
              // dem 2er Kompliment von data zu
                m_pCpu.Register.bx = Add(m_pCpu.Register.bx, ~data + 1);
                // Weise dem Carry Flag false zu
                m_pCpu.Register.CarryFlag = false;
                // Addiere auf a eine 1 
                Add(a, 1);
            }
            // gibt das Ergebniss der Division zu
            return (!m_pCpu.Register.AkkuHelp ^ !(m_pCpu.Register.cx > 0)) ? CmplTwo(a) : a;
        }

Inc()

int Vcsos.Komponent.Akku.Inc

(

int

data

)

Increnent

Parameters

data	die zu Incremierende Daten

Returns

        {
            return Add (data, +1);
        }

MoveAX()

void Vcsos.Komponent.Akku.MoveAX

(

Int32

data

)

Weist dem CPU-Register AX ein wert zu

Parameters

data

        {
            m_pCpu.Register.ax = data;
        }

MoveFromAX()

int Vcsos.Komponent.Akku.MoveFromAX

(

)

lese die Daten aus dem Register AX

Returns

Daten aus dem Register AX

        {
            return m_pCpu.Register.ax;
        }

MoveFromBX()

int Vcsos.Komponent.Akku.MoveFromBX

(

)

lese die Daten aus dem Register BX

Returns

Daten aus dem Register BX

        {
            return m_pCpu.Register.bx;
        }

Mul() [1/2]

int Vcsos.Komponent.Akku.Mul

(

int

data

)

Multipliziere Data mit Register AX

Parameters

data

Returns

Das Ergebniss der Multiplikation

        {
            //AkkuHelp Flag (intern) zuweisen
            m_pCpu.Register.AkkuHelp = (data > 0);
            // Testen ob AkkuHelp true ist dann erstelle das 2er Kompliment von data und weise
            // es data zu (2er Kompliment wenn data eine positive zahl enthält)
            data = (!m_pCpu.Register.AkkuHelp) ? CmplTwo(data) : data;

            // Weise dem Register BX den Wert aus dem Register BX zu
            m_pCpu.Register.bx = m_pCpu.Register.ax;
        
            // Addiere Register AX mit Register BX per Schleife (data-1)
            for (uint i = 0; i < data -1; i++) {
                m_pCpu.Register.ax = Add (m_pCpu.Register.bx, m_pCpu.Register.ax);
            }
            // Wenn Register AX kleiner als Register BX ist dann liegt ein Overflow vor
            m_pCpu.Register.OverFlow = (m_pCpu.Register.ax < m_pCpu.Register.bx);
            // Wenn Register AkkuHelp false ist erstelle das 2er Compliment vom Register AX 
            // und weise dies Register AX ist sonst Weise Register AX Revister AX zu
            m_pCpu.Register.ax = (!m_pCpu.Register.AkkuHelp) ? CmplTwo( m_pCpu.Register.ax) 
                : m_pCpu.Register.ax;
            
            // Return das Etgebnoss der Multiplikation
            return m_pCpu.Register.ax;
        }

Mul() [2/2]

int Vcsos.Komponent.Akku.Mul	(	int	a,
		int	data
	)

        {
            //AkkuHelp Flag (intern) zuweisen
            m_pCpu.Register.AkkuHelp = (data > 0);
            // Testen ob AkkuHelp true ist dann erstelle das 2er Kompliment von data und weise
            // es data zu (2er Kompliment wenn data eine positive zahl enthält)
            data = (!m_pCpu.Register.AkkuHelp) ? CmplTwo(data) : data;

            // Weise dem Register BX den Wert aus dem Register BX zu
            m_pCpu.Register.bx = a;

            // Addiere Register AX mit Register BX per Schleife (data-1)
            for (uint i = 0; i < data - 1; i++)
            {
                a = Add(m_pCpu.Register.bx, a);
            }
            // Wenn Register AX kleiner als Register BX ist dann liegt ein Overflow vor
            m_pCpu.Register.OverFlow = (a < m_pCpu.Register.bx);
            // Wenn Register AkkuHelp false ist erstelle das 2er Compliment vom Register AX 
            // und weise dies Register AX ist sonst Weise Register AX Revister AX zu
            return (!m_pCpu.Register.AkkuHelp) ? CmplTwo(a)
                : a;
        }

Sub() [1/2]

int Vcsos.Komponent.Akku.Sub

(

int

data

)

Subtration vom Register AX

Parameters

data	Die Zahl die von AX subrrahiert werden soll

Returns

Ergebniss der Subtration

        {
            int result = 0; // result : speichern des Ergebnisses
            int carry = (int)(m_pCpu.Register.CarryFlag ? 1 : 0); // carry : carry-flag als int from bool

            // Subtraction per Zweiterkompliment und Addition
            // benutze old carry und speichere das ergebniss in result
            m_pCpu.Register.OverFlow = Add (m_pCpu.Register.ax, ~data + 1, ref carry, ref result);
            // speichern des Ergebnisses der Addition in den Register AX
            m_pCpu.Register.ax = result;
            // speichern des Carry Flags
            m_pCpu.Register.CarryFlag = carry == 1;

            // ist OverFlow (OF) flag gesetzt...
            if (m_pCpu.Register.OverFlow) {
                // Dann löscbe das Flag
                m_pCpu.Register.OverFlow = false;
            }
            else
                // Wenn nicht dann schaue ob underflow vorliegt (TODO)
                m_pCpu.Register.UnderFlow = (result <= int.MaxValue);

            // rückgabe der variable result
            return result;
        }

Sub() [2/2]

int Vcsos.Komponent.Akku.Sub	(	int	a,
		int	b
	)

        {
            int result = 0; // result : speichern des Ergebnisses
            int carry = (int)(m_pCpu.Register.CarryFlag ? 1 : 0); // carry : carry-flag als int from bool

            // Subtraction per Zweiterkompliment und Addition
            // benutze old carry und speichere das ergebniss in result
            m_pCpu.Register.OverFlow = Add(a, ~b + 1, ref carry, ref result);

            // speichern des Carry Flags
            m_pCpu.Register.CarryFlag = carry == 1;

            // ist OverFlow (OF) flag gesetzt...
            if (m_pCpu.Register.OverFlow)
            {
                // Dann löscbe das Flag
                m_pCpu.Register.OverFlow = false;
            }
            else
                // Wenn nicht dann schaue ob underflow vorliegt (TODO)
                m_pCpu.Register.UnderFlow = (result <= int.MaxValue);

            // rückgabe der variable result
            return result;
        }

---

The documentation for this class was generated from the following file:

• src/Akku.cs