2024-09-21, heute und gestern

#!/bin/bash

name="Vajda"
firstname="David"

if [[ "$name" == "$2" && "$firstname" == "$1" ]]
then
    echo "Das bin ich"
elif [[ "$name" == "$1" && -z "$2" ]]
then
    echo "Das koennte ich sein"
else
    echo "hallo welt"

    i=0
    while [ $i -lt 10 ]
    do
        echo "Hallo zum $(($i+1))."
        i=$(($i+1))
    done
    M=(a b c d)
    M+=(e f g h)
    i=0
    while [ $i -lt 8 ]
    do
        echo "${M[$i]}"
        i=$(($i+1))
    done
    i=0
    for s in "${M[@]}"
    do
        echo "$s"
    done
    l=$(ls)
    for s in $l
    do
        if [ $i -eq 8 ]
        then
            break
        fi
        echo $s
        i=$(($i+1))
    done

    /bin/bash "$0" "David" "Vajda"
    /bin/bash "$0" "Vajda"
fi

Der Assembler Quelltext

;; ich weiss jetzt wie es richtig geht. Es ist mir erstens an entsprechender Stelle aufgefallen
;; wenn man hier den String anguckt, er ist verkehrt herum

david@work:~$ /bin/bash assemble.sh mmxsort20240919d
Aber    Hallo   Welt    sagt    David   Vajda   Vajda   David   sagt    Welt    Hallo   Aber    david@work:~$

Wie kommt das? Ganz einfach. So wie ich mir dachte laedt MOVQ von der Addresse. Weil ich lade ja das Datum in der Variable
Hier vergleicht er die Addresse von EDI und ESI macht desswgen verkehrt
Gut, packed und unpacked hat nichts mit bitfeld und float zu tun. sprich Saturation oder nicht Wir hatten das in der Pruefung. Waehrend ich genau eine IEEE754 floating Point zahl selber binaer darstellen kann, hier hat es etwas gehapert .Aber Packed gibt es auch bei BCD. Ich mache wieder die Aufgaben zu IEEE lohnt sich und das hier auch. Aber - das hat damit nichts zu tun

Allerdins stoerte das B am Ende des Befehl

Es steht fue Byte

Der Befehl P  CMP P GT D
pcmpgtd
oder
pcmpgtdb
Byte st
steht am Ende, p und cmp und gt - greater. ich brauche aber ganze zahlen

            global      _start
            section     .data
            str:        db "Aber    ", "Hallo   ", "Welt    ", "sagt    ", "David   ", "Vajda   "

            section     .text
_start:

            mov ecx, str
            call printstart

            mov edi, str
sortloop1:  mov eax, edi
            cmp eax, str + 8*7
            jge sortloop1end
            mov esi, edi
sortloop2:  add esi, 8
            mov eax, esi
            cmp eax, str + 8*7
            jge sortloop2end
            movq mm0, [esi]
            movq mm1, [edi]
            pcmpgtd mm0, mm1
            jge noexchange
            movq mm0, [esi]
            movq mm1, [edi]
            movq [esi], mm1
            movq [edi], mm0
noexchange:
            jmp sortloop2
sortloop2end:
            add edi, 8
            jmp sortloop1
sortloop1end:

            mov ecx, str
            call printstart

            mov ebx, 0
            mov eax, 1
            int 80h

printstart:

            cmp ecx, str + 7*8
            jge printend

            mov edx, 8
            mov ebx, 1
            mov eax, 4
            int 0x80
            add ecx, 8
            jmp printstart

printend:   ret

wir fangen an, ieee-754 um zu rechnen

#include <stdio.h>

int main (void) {
    int x = 1234;
    int sh = 0;
    int b = 0;

    while (x != 0) {
        if ((x % 2) == 1)
            b = b | (1 << sh);
        x = x/2;
        sh ++;
    }
    printf ("%i\n", b);
return 0;
}

Und weiter

#include <stdio.h>
#include <string.h>

int main (void) {
    int x = 1234;
    int sh = 0;
    unsigned int b = 0;

    while (x != 0) {
        if ((x % 2) == 1)
            b = b | (1 << sh);
        x = x/2;
        sh ++;
    }
    printf ("%u\n", b);

    char *str = "1234";
    char *p;
    int base;

    printf ("sizeof float: %i\n", sizeof (float));

    for (p = str + strlen (str) -1, b = 0, base = 1;  p >= str;   p--, base = base * 10) {
            b = b + ((*p) - '0') * base;
    }

    printf ("%u\n", b);

return 0;
}

Und weiter

#include <stdio.h>
#include <string.h>

int main (void) {
    int x = 1234;
    int sh = 0;
    unsigned int b = 0;

    while (x != 0) {
        if ((x % 2) == 1)
            b = b | (1 << sh);
        x = x/2;
        sh ++;
    }
    printf ("%u\n", b);

    char *str = "1234";
    char *p;
    int base;

    printf ("sizeof float: %i\n", sizeof (float));

    for (p = str + strlen (str) -1, b = 0, base = 1;  p >= str;   p--, base = base * 10) {
            b = b + ((*p) - '0') * base;
    }

    printf ("%u\n", b);

    char *fstr = "1234.1234";
    char *s1;
    char *s2;
    unsigned m1, m2;
    int base1, base2;

    for (s1 = fstr;   (*s1 != 0) && (*s1 != '.');  s1++);

    if (*s1 == '.') {
        for (p = s1 -1, m1 = 0, base1 = 1;  p >= fstr;   p--, base1 = base1 * 10) {
            m1 = m1 + ((*p) - '0') * base1;
        }
        for (p = (fstr + strlen (fstr) - 1), base2 = 1, m2 = 0;  p >= (s1+1);  p--, base2 = base2 * 10)
            m2 = m2 + ((*p) - '0') * base2;
        printf ("%u.%u\n", m1, m2);
        printf ("%i %i\n", base1, base2);

    }

return 0;
}

/*

Ich denke, das sollte uns gelingen, geschriebene rationale Zahl im
entsprechenden Zahlenbereich in eine IEEE754 Flie"s, Zahl umzurechnen was
wir nat"urlich bedenken m"ussen ist am, dass wir es mit zweier Potenzen zu
tun haben. D.h. im ersten Schritt in mein Programm werden wir noch mal
brauchen Bei dem hinter dem Roma m"ussen wir nicht viel tun, au"ser dass wir
das ganze mit zwei multiplizieren soll hei"sen um eins nach links schifften
und dabei m"ussen wir eine Grenzzahl festlegen, weil wir sind ja hinter dem
Komma d.h. wir m"ussten hier  eigentlich eins nehmen da wir hier aber die
komplette Darstellung sozusagen wiederum einer ganzen Zahl haben. Hinter
dem Komma m"ussen wir einen Wert nehmen, dessen Basis genau eins dr"uber ist
und jedes Mal, wenn es "uberschritten wird, dann ziehen wir diese Basis ab
und schifften es weiter und dann merken wir uns eine eins das ist nicht
besonders kompliziert ebenso wenig kompliziert ist die erste eins vorne
abzuschneiden von dem Teil vor dem Komma vor der Mantisse. Wir m"ussen aber
hier im bin"aren Bereich denken und dementsprechend ist es nicht besonders
schwierig den Bias also die Verschiebung auszurechnen des +127 zu addieren
und dann haben wir eigentlich unsere Floating Point Zahl selber errechnet
ja gut. Viel mehr m"ussen wir nicht tun, denn die Umrechnung des Floating
Points unternimmt zun"achst einmal heutzutage zumindest die f"ur. Anders ist
es in Zeiten des sechs 8086 da haben wir vielleicht ein Coprozessor
installiert, oder wir m"ussen das selber umsetzen. Ich selber habe
Mainboards, da muss man die F PU per Hand einsetzen.
*/