Coding Update 05/2023

Voor ik verder ga met de eigenlijke ontwikkeling van de assembler wil ik hem eerst aanpassen. De refactor gaat erom om het ene bestand assembler.c op te splitsen in een general, processing, matching en output bestanden. Zodat de code ook beter te lezen is voor anderen.

Hiervoor moet ik dus eerst de functie tree maken, deze bevat de functie aanroepen in het main gedeelte en alle functies die deze op hun beurt weer aanroepen. Ik ben begonnen met de eerste functie namelijk gdb_ProcessMainFile(). Deze is bijna afgerond en tot nu toe heb ik het volgende opgemaakt.

    int gdb_CheckFileExists(char *filename)
            => 0
            
    void gdb_ProcessMainFile(void)
            => g_temp_text
            => static void ProcessFile(char *filename)
                => static void ClearLine()
                    => g_code_line
                => static void ClearTempText()
                    => g_temp_text
                => static void AddData()
                    => g_code_line
                    => g_temp_text
                => static void AddLineToSegment()
                    => g_code_line
                    => static void AddHeadSegment()
                        => g_head_segment
                        => g_code_line
                    => static int IsExtern(char *mnemonic)
                    => static void AddExternSegment()
                        => g_code_line
                        => g_macros
                        => static int LastIndexOfExternSegment(struct Macros *segment_array)
                    => static int IsData(char *mnemonic)
                    => static void AddDataSegment()
                        => g_code_line
                        => g_data_segment
                        => static int LastIndexOfDataSegment(struct line *segment_array)
                    => static int IsHead(char *mnemonic)
                    => static int IsBlankLine(char *mnemonic)
                    => static void AddCodeSegment()
                        => g_code_line
                        => g_code_segment
                        => static int LastIndexOfCodeSegment(struct line *segment_array)
                => static void AddLabel()
                    => g_code_line
                    => static int LastIndexOfLabels()
                        => g_labels
                    => static char * ToLowerCase(char *input)
                        => g_to_lowercase
                => static void AddMnemonic()
                    => g_code_line
                    => g_temp_text
                    => static char * ToLowerCase(char *input)
                        => g_to_lowercase
                    => static int IsHead(char *mnemonic)
                => static void AddLeftOperand(int line)
                    => g_code_line
                    => g_temp_text
                    => static int IsDecimal()
                        => g_temp_text
                    => static char * RemoveSuffix(char *value_string, char *g_temp_text)
                        => g_temp_text
                    => gdb_DecimalToHex (tohex.c)
                    => static void ConvertToLittleEndian(struct Value *value, char *hex_value, int line)
                    => static int IsBinair()
                        => g_temp_text
                    => gdb_BinairToHex
                    => static char * ToLowerCase(char *input)
                        => g_to_lowercase
                    => static int IsLabel(char *operand)
                        => g_labels
                => static void AddRightOperand(int line)
                    => g_code_line
                    => g_temp_text
                    => static int IsDecimal()
                        => g_temp_text
                    => static char * RemoveSuffix(char *value_string, char *g_temp_text)
                        => g_temp_text
                    => gdb_DecimalToHex (tohex.c)
                    => static void ConvertToLittleEndian(struct Value *value, char *hex_value, int line)
                    => static int IsBinair()
                        => g_temp_text
                    => gdb_BinairToHex
                    => static char * ToLowerCase(char *input)
                        => g_to_lowercase

Als deze tree gemaakt is begin ik aan de volgende tot ik alle functies in main heb in kaart gebracht. Dan kan ik ze beginnen aanpassen en opsplitsen. De bedoeling is om dan ook de meeste globale variabelen en structs via calloc een geheugen plaats te geven en deze dan telkens door te geven via parameters.

Coding Update 02/2023

Als eerste heb ik de layout van de opcodes veranderd, nu is er tussen elke versie een spatie en staat er aan het begin altijd welke opdracht het juist is. Dit is om te kunnen vergelijken met het zakboekje Z80.

Verder heb ik een paar versies toevegoegd voor de LD opcode. De bedoeling is dat ik deze nu dus eerst afmaak met alle versies. Daarna ga ik de functie voor het matchen van een versie maken waarbij de rechter operand een waarde of label is.

Een laatste toevoeging dat ik heb gedaan is de value_has_braces variabele aan de opcodes. Dit is om bijvoorbeeld

    LD HL, (nn)

te kunnen doen werken, want er bestaat ook een versie zonder de haakjes.

Coding Update 52/2022

De laatste coding update van 2022 ;-)

De BASIC assembler die ik aan het programmeren ben is aangepast voor Visual Studio 2022 op mijn Windows Laptop. Het heeft wat voeten in de aarde gehad, maar het is gelukt. Nu ben ik bij op de Windows Laptop en mijn MacBook Pro.

XCode op macintosh is meer vergevingsgezind dan Visual Studio op Windows. Uiteindelijk denk ik voort te gaan op Windows en dan telkens ook te checken in Xcode, gewoon om te zorgen dat ik niet te veel ineens moet aanpassen aan de een of andere omgeving.

Verder op de planning staat de opcodes die ik nu al heb op te kuisen en nog iets toe te voegen. Vanaf dat dit in orde is, dit zou niet langer dan een uurtje moeten duren, dan ga ik de volgende match maken waarbij de rechter operand een waarde of label is. Maar dat is voor volgend jaar.

Een goed einde van 2022 gewenst en een goed 2023!

Coding Update 50/2022

Zoals je weet ben ik aan het programmeren in C, en dat doe ik totnutoe op macOS. Nu heb ik een Windows 11 laptop tot mijn beschikking en wou hier ook op programmeren maar dan in Visual Studio. Dus heb ik de code van mijn macbook pro overgezet naar windows. Bij de eerste compilatie had ik 120 fouten.

Dit was veel en ik dacht dat als ik de eerste fout oplos de rest ook zou volgen, en dit was waar. De fout in windows was geen fout in macOS, daar werkte alles goed.

    size_t input_length = strlen(input)
    int temp_string[input_length];

De fout was dat in het definieren van de array een constante moet worden gebruikt en dus niet zoals ik het hierboven doe.

Nadat dit was gefixt, verdwenen de fouten allemaal, maar er zaten nog bugs in het programma. Die bugs ben ik nu aan het verwijderen.

Nu is de vraag of ik verder ga met programmeren op de Windows laptop of op mijn macbook pro. To be continued….

Coding Update 37/2022

Allereerst heb ik functies gemaakt voor het checken of de linker- of rechteroperand een label bevat, dit heb ik nodig bij het matchen van mnemonics en hun versies. Daarna ben ik begonnen met een functie

    void gdb_Match(void);

deze functie matcht eerst de mnemonic van het code segment met die van een mnemonic in de array die alle mnemonics en hun versies bevat. Als deze check succesvol is dan gaat het verder met het matchen van de operands.

Daar ben ik begonnen met het matchen van de linker- en rechteroperand, dit is het geval als er geen waarde of label aanwezig is in de operanden. De volgende stap is het matchen van de linkeroperand als de rechteroperand een waarde of label bevat.

Coding Update 33/2022

Ik ben begonnen met het toevoegen van mnemonics en hun operand versies. Hiervoor had ik een aparte .c en .h bestand nodig waarin de struct zit en een functie die alle mnemonics teruggeeft.

de opcodes.h bestand bevat volgende opbouw van structs.

    struct Opcodes {
        char *opcode;
    };

    struct Versions {
        char *left_operand;
        char *right_operand;
        int has_value;
        int bytes;
        struct Opcodes opcodes[3];
    };

    struct Mnemonics {
        char *mnemonic;
        int versions;
        struct Versions version[];
    };

    struct MnemonicsArray {
        struct Mnemonics mnemonics[71];
    };

Dit zou normaal moeten voldoen. De volgende functie heb ik toegevoegd aan operands.c

    struct MnemonicsArray gdb_LoadMnemonics(void);

Deze functie geeft dus alle mnemonics en hun operand versies terug, waarmee ik dan kan matchen.

Nu heb ik al 1 mnemonic volledig toegevoegd en dat is ADC, dit is de eerste van 71 mnemonics. Ook ben ik begonnen met het toevoegen van LD, dit om al een functie te maken die coderegels matcht met hun mnemonics en hun operand versies. Als dit gedaan is dan kan ik voortgaan met het toevoegen van mnemonics.

Coding Update 32/2022

Voor ik kon verdergaan met het toevoegen van alle mnemonics en hun opcodes, moest ik iets verzinnen om het gebruik van hoofd- of kleine letters toe te laten. Dit was een doelstelling omdat ik niet aan de programmeur wou opleggen of hij/zij nu hoofdletters of kleine letters moest gebruiken voor mnemonics of operands en labels.

Dus had ik besloten om een functie te maken

    static char * ToLowerCase(char *input)

Deze zou dus een input krijgen en alle letters zouden naar kleine letters omgezet worden. Als de input iets anders zou bevatten dan hoofdletters wordt dit gewoon genegeerd. Nu was ook de vraag of ik deze functie zou gebruiken als ik coderegels probeer te matchen met opcodes of ervoor al, op het moment dat ik de mnemonics, labels of operands toevoeg aan de segmenten.

Ik heb voor dit laatste gekozen omdat dit in mijn ogen beter zou zijn, hierdoor kan ik waarschijnlijk ook sommige functies verkleinen door niet meer te controleren op zowel de hoofdletter als kleine letter variant. Dit is bijvoorbeeld zo bij het controleren of de extern keyword gebruikt is.

De volgende stap is het toevoegen van de opcodes aan een struct en dan een functie schrijven die een match probeert te vinden voor een mnemonic. Later zou ook gezocht moeten worden naar een match tussen de operands.

Coding Update 30-31/2022

De afgelopen twee weken heb ik minder tijd gehad om te programmeren, maar ik heb toch voortgang geboekt.

Als eerste heb ik de code opgeschoond (dingen verwijderd die niet meer nodig waren), commentaren toegevoegd en de ‘functions.md’ een update gegeven. Dit soort karweitjhes probeer ik regelmatig te doen om zo de code overzichtelijk te houden.

Voorts heb ik volgende functies toegevoegd

    gdb_ShowExtern
    gdb_ShowCodeSegment

Nu kan ik altijd deze functies aanroepen om info te geven over wat er juist in een segment zit. Samen met de vorige functies heb ik deze dus geimplementeerd.

    void gdb_ShowLabels(void)
    void gdb_ShowHeadSegment(void)
    void gdb_ShowDataSegment(void)
    void gdb_ShowExternSegment(void)
    void gdb_ShowCodeSegment(void)

Het volgende op het schema is de

    struct line

aanpassen om het aantal opcode bytes te bevatten die nodig zijn voor die code regel alsook hun waarde. Daarna kan ik al een paar opcodes maken waartegen het eerste Hello World programma kan afgezet worden. Dit om de code te testen. Dus ga ik in eerste instantie enkel de mnemonics die ik gebruik in het Hello World programma aanmaken zodat ik kan testen.

Coding Update 27-28-29/2022

Door omstandigheden heb ik de laatste paar weken niet gepost. Dus deze week een recap van de voorbije weken.

Allereerst heb ik het ‘toHex’ bibliotheek bestand aangepast naar de conventies die ik gebruik, zodat alles gelijk is. Daarna heb ik dit aangepast bestand gekopieerd naar het Boomer assembler project.

Het volgende wat ik gedaan heb was

    struct Label {
        char label[MAX_LENGTH_LABEL];
        char start_address[4];
        int has_label;
    };

een struct aangemaakt die de naam van het label bevat en zijn start adres. Daarna heb ik een functie geschreven om deze aan te passen met de waarden die een ‘EQU’ regel bevat.

Vervolgens heb ik een paar functies gemaakt die de index van het laatste element bevat in de verschillende segmenten (head, extern, data en labels)

    LastIndexOfDataSegment(struct line *segment_array)
    LastIndexOfSegmentArray(struct line *segment_array)
    LastIndexOfExternSegment(struct Macros *segment_array)
    LastIndexOfLabels()

Hier moet ik nog het code segment aanmaken, dat is het volgende op de planning, na het opschonen van de code en commentaar te schrijven.

Als laatste heb ik een paar functies geschreven die een overzicht geven van de inhoud van de vorige segmenten.

    gdb_ShowLabels();
    gdb_ShowHeadSegment();
    gdb_ShowDataSegment();

Dit heb ik gedaan om een snelle manier te hebben om te controleren of de inhoud wel klopt. Deze functies zullen behouden blijven in de definitieve versie, maar ze zullen niet aangeroepen worden.

Coding Update 26/2022

Volgende filters toegevoegd

    DEFS
    DEFB
    DEFW

Nu is het voorbereidende werk bijna gedaan. Eén van de grotere dingen die nog moet komen is het toevoegen van alle mnemonics en hun variaties. Dit zal een serieus werkje worden waar ik wel even zoet mee zal zijn.

Ook heb ik een array van labels gemaakt samen met hun start adres. Dit is om nadien de labels die als operand gebruikt worden te kunnen matchen met hun geheugen addressen.

Voorts heb ik de functie

    ConvertValueToString

verwijderd met al haar gerelateerde code. Uiteindelijk bleek ik die functie toch niet nodig te hebben dus verwijderen maar.

Als laatste heb ik in de ToHex bibliotheek bestand de functie

    HexToDecimal

gemaakt en geimplemnteerd. Dit was nodig om bijvoorbeeld de waarde van ORG om te zetten naar decimaal zodat ik deze kan gebruiken om de program counter te verhogen. De program counter is dan weer verantwoordelijk voor het bijhouden van de geheugen adressen bij het verwerken van de code. Dus dan kan ik bijvoorbeeld gemakkelijk de labels matchen.

        ld HL, MSG

    MSG: defm "Hello!"

Coding Update 25/2022

Ik ben begonnen met alle wiskunde van het middelbaar te bekijken en waar nodig bij te schaven. Ik heb indertijd niet alle wiskunde meegekregen door bepaalde redenen, dus ben ik daar nu maar mee begonnen. Ik heb me Pienter 1 aangeschaft en ben er stilletjes aan het doorwerken. De samenvattingen die ik maak wil ik duidelijk in 1 document hebben, en dus is mijn oog gevallen op LaTex dit is een ‘tekstverwerker’ waar je wiskundige formules kan inzetten op een redelijk eenvoudige manier. Dus ben ik deze week begonnen met het eerste hoofdstuk in Pienter 1, ik heb al van verschillende hoofdstukken samenvattingen, maar ben nu pas begonnen met ze om te zetten naar een LaTex document.

Dit is geen sinicuur werkje, de vorderingen lopen niet zo vlot omdat ik alles nog moet leren van LaTex, dus zit ik regelmatig te testen en op te zoeken op het internet. Maar dat gaat mettertijd wel beteren hoe verder ik geraak.

Voorts heb ik een bestand aangemaakt dat alle functies van ‘assembler.c’ bevat in volgorde, kwestie van snel te kunnen vinden waar een bepaalde functie staat in het programma.

Ook heb ik strcpy vervangen door strncpy kwestie van het beperken van buffer overflows in het programma. dit was een werkje van een tiental minuten.

Een voorlaatste dingetje dat ik heb aangepast is een definitie gemaak van hoe lang labels mogen zijn in het geheugen.

    #define MAX_LENGTH_LABEL 7

En als laatste heb ik de functie ‘AddDataSegment’ gemaakt. De eerste filter die ik daarvoor heb geschreven was om strings uit de operand te halen achter ‘defm’

    MSG: DEFM "Hello World!"

Dit was wel even een zoekwerkje, want in het begin ging het fout bij de spatie in de tekst. Maar een paar minuten later had ik de boosdoener gevonden. Nu is het de bedoeling om de andere ‘def…' keywords te filteren en in een data segment array te zetten.

Coding Update 24/2022

Deze week voortgewerkt aan ‘AddHeadSegment’ en ‘AddExternSegment’ functies, welke nu werken. De eerste voegt de coderegel toe aan de ‘HEAD’ segment array als de mnemonic ‘equ’ of ‘org’ is. De tweede voegt de filename van een macro toe aan een array van macro’s. Als ondersteunde functie heb ik ook ‘IsExtern’ gemaakt, deze controleert of de mnemonic ‘extern’ is welke gevolgd wordt door de filename van de macro.

Als laatste heb ik bij ‘AddLeftOperand’ en ‘AddRightOperand’ de meest- en minst significante byte toegevoegd aan de coderegel. Ik moet nog wel het een en ander opkuisen, want bij die functies wordt de little endian waarde (struct) terug omgezet naar een string, en dat hoeft eigenlijk niet meer. Omdat de struct line nu aparte leden bevat voor de meest- en minstsignificante byte.

Coding Update 23/2022

Ik ben de week begonnen met oude comments en statements op te schonen. Ik probeer dit regelmatig te doen om zo de code proper te houden. Al bij al duurt dit werkje niet zo lang en ben ik dan begonnen om de lijnen code die gelezen worden toe te voegen aan de HEAD segment array. Daarbij stuitte ik op een probleem.

Als ik bijvoorbeeld een mnemonic toevoeg aan de code_line en daarna een left operand dan veranderde de waarde van de mnemonic in die van de left operand. Dit heeft wel even geduurd vooraleer ik de oplossing vond. Mijn eerste gedacht was dat ik een fout had gemaakt in het parsen van de regels code in het main.z80 bestand. Dit bleek niet het probleem te zijn, het parsen verliep zoals gepland.

Mijn tweede gedacht was dat de waarde in mnemonic gekoppeld was aan het geheugen adres van de variabele g_temp_text, dit bleek correct te zijn. Dus ik had het probleem gevonden. Het toekennen van waardes aan nieuwe strings gebeurde niet door hun waarde, maar door hun referentie. Kortom de nieuwe string bevatte dus een referentie naar de echte waarde.

Om dit op te lossen moest ik eigenlijk een kopie maken van de string en deze dan toevoegen aan bijvoorbeeld mnemonic. Voor dit geval bestaat er de functie strcpy welke een bron string kopieert in de nieuwe doel string. Na dit gedaan te hebben en alle code aan te passen werkt het perfect. Weeral iets bijgeleerd dus.

Als laatste heb ik nog commentaar toegevoegd aan de code. Dit probeer ik ook regelmatig te doen zodat het niet onoverzichtelijk wordt. Ik schrijf geen commentaar op het moment dat ik code aan het schrijven ben, ik doe dit dus achteraf.

Coding Update 22/2022

Deze week iets anders gedaan dan te werken aan de assembler. Vorige week maakte ik melding van een variabele die niet zichtbaar was buiten het if blok waarin het zat. Wel daar ben ik dieper op ingegaan deze week. Kijken hoe het geheugen juist werkt enzo in ANSI C. Ik heb ook een oplossing gevonden die geen gebruikt maakt van calloc.

Voor de rest heb ik de functies ‘AddMnemonic’ en ‘AddLabel’ afgewerkt. Dit was niet moeilijk en heb een nieuwe functie ontdekt om te testen op strings, namelijk strncmp. Het originele idee was gewoon een if statement te maken met == operator, maar deze gaf aan in xcode dat je best een speciale functie daarvoor gebruikt. Dus ben ik uitgekomen op strncmp.

Volgende week staat ,het toevoegen van de HEAD code aan een array, deze bevat mnemonics ORG, EXTERN en EQU, op het menu. De reden dat ik niet alles in 1 array gooi is dat er ook externe bestanden moeten verwerkt worden en dan is de oplossing van een head, een main en een data array de beste zet.

Coding Update 21/2022

Deze week weeral niet veel gedaan, wegens persoonlijke verplichtingen, maar wel wat vooruitgang geboekt. De functies ‘AddLeftOperand’ en ‘AddRightOperand’ zijn nu klaar. Het heeft wel even geduurd, want ik had een rare bug. Om één of andere reden was een variabele enkel in een if block en niet in de gewone functie beschikbaar. Dit heb ik opgelost met geheugen te reserveren via calloc en nu werkt het prima.

Als laatste heb ik ook een refactor gedaan. Ik had in de functies ‘AddLeftOperand’ en ‘AddRightOperand’ een if/else constructie, maar ik ben geen voorstander van het else gedeelte. Je kan meestal een if/else blok veranderen naar enkel een if blok, dit heet Guard Clause al heb ik het in dit specifiek geval een beetje anders aangepakt. De line struct wordt eerst aangemaakt met de variabele die in g_temp_text zit, dit is de tijdelijke string die een waarde bevat die ingelezen is in de process functie. Daarna check ik of de string een waarde bevat (hexadecimaal in Little Endian), als dit waar is wordt de line struct opnieuw aangepast (de left of right operand in die struct).

De line struct wordt dus opgebouwd per lijn dat gelezen is. Als er een newline wordt gedecteerd dan zou de line_struct toegevoegd worden aan een array met de regels code die process functie aanmaakt. Maar zover zijn we nog niet.

De volgende stap is de rest van de line struct maken, dit wil zeggen de labels en mnemonics toevoegen. Daarna kan ik beginnen met de line struct toe te voegen aan een array lines die alle code regels bevatten. Dus dat staat op de planning.

Coding Update 20/2022

Deze week heb ik niet veel tijd gehad om te programmeren, een heel week naar dokters aan het lopen :-( Toch heb ik gedaan gekregen wat ik wou. Allereerst heb ik de ‘ConvertToLittleEndian’ functie geschreven. Dit was wat tricky omdat er soms maar 1 of 3 hexadecimale karakters worden doorgegeven. Uiteindelijk is het gelukt.

Daarna heb ik de code voor ‘AddLeftOperand’ en ‘AddRightOperand’ opgekuist. Ervoor stonden in de checks voor ‘IsDecimal’, ‘IsBinair’ en ‘IsHexadecimal’ een geheugen toewijzing via calloc in elk van deze checks, nu staat dat in het begin van de functies. Dit is netter, dus vandaar de refactor.

Ook heb ik een bug opgelost in ‘IsDecimal’ functie. Als men in de z80 file een decimaal getal schrijft zonder de suffix ’d' of ‘D’ dan gaf deze toch waar terug terwijl dit niet waar moest zijn. Dit bleek op te lossen door een extra check te doen op ‘is_valid_decimal’ alleen.

En als laatste heb ik een fix gemaakt voor ‘IsHexadecimal’. Eerst mocht je enkel hoofdletters gebruiken voor de hexadecimale karakters, nu mag je ook kleine letters gebruiken. Het zijn die kleine dingen die mettertijd komen boven drijven en dan moet je die repareren.

Coding Update 19/2022

Om te beginnen heb ik de functies IsDecimal, IsBinair en IsHexadecimal herschreven zodat zij testen op de suffix. De suffix kan ‘h’,‘H’,’d',‘D’,‘b’ of ‘B’ zijn. Als de suffix gekend is, is de left- of rightoperand een waarde. Deze moet dan nog omgezet worden naar hexadecimaal in geval van decimale of binaire waarde, daarna moet deze omgezet worden naar little endian.

Bij de check op waarde functies zat een fout waardoor een enkel karakter door de mazen glipte en deze dus waar teruggaf bij de aangeroepen functie. Dit was doordat ik in de for loops ‘<’ gebruikte in plaats van ‘<=’. Eigenlijk een logisch probleem, maar het heeft wel een uurtje ofzo gekost om dit te vinden.

Ook heb ik de RemoveSuffix functie geschreven, deze verwijderd zoals de functie al zegt de suffix om dan de waarde alleen terug te geven. Dit is nodig om daarna de decimale en binaire waarde om te zetten naar een hexadecimale waarde.

Als laatste heb ik de conversie naar hexadecimaal toegevoegd aan de AddLeft- en AddRightOperand functies. De volgende stap is om de hexadedcimale waarde om te keren naar little endian en deze in een struct te zetten. De conversie geeft niet langer één string door, maar wel twee afzonderlijke strings.

Gelezen boeken April 2022

Deze maand heb ik vier boeken gelezen, 2 fictie en 2 non-fictie. Ik probeer die twee categoriën altijd af te wisselen. Eerst de non-fictie. Het eerste boek was Billion Dollar Loser over de op- en afgang van WeWork, meer bepaald zijn CEO Adam Nuemann, goed boek maar soms wat lastiger te volgen (kan ook zijn omdat het in het engels was). Als tweede non-fictie was Het Ondiepe aan de beurt. Daar had ik meer van verwacht, en het boek las ook niet zo vlot.

In de categorie fictie heb ik als eerste De Genesissleutel gelezen. Echt een goed boek en vlot leesbaar, de actie was ook goed beschreven en wat meer uitgerokken, wat niet slecht is. Het tweede boek was Geen Uitweg. Hier was ik vooraf niet zo happig op, maar toen ik eenmaal begon te lezen ging het vooruit. Het boek las zeer snel en zat heel goed in elkaar.

Zo dat waren de 4 boeken die ik in April 2022 gelezen heb. Dit was een uitzonderlijk goede maand, de volgende maanden zullen het minder boeken zijn die ik per maand lees.

Coding Update 18/2022

Deze week een rustige week, maar ik heb toch twee dingen gedaan gekregen. De eerste is het aanpassen van de code, van de MSX assembler die ik aan het maken ben, naar naamconventies. Zo heb ik de globale variabele van een prefix voorzien. De publieke functies zijn ook aangepast met een prefix. Ook heb ik de functies voorzien van TitleCase zodat elk woord een hoofdletter heeft.

Als tweede heb ik functies geschreven om te kijken of een linker- of rechter operand een waarde bevat. Dit kan zowel decimaal, binair en hexadecimaal zijn. Nu moet ik de aanroep nog aanpassen om wat meer clean code te krijgen. Als de waarde binair of decimaal is moet deze omgezet worden naar hexadecimaal. Ook moet de hexadecimale waarde dan omgezet worden naar Little Endian waarbij de minst significante byte eerst komt. Dit ga ik komende week doen waarschijnlijk. Stay Tuned!!

Coding update 17/2022

Hierbij geef ik een coding update voor week 17 van 2022. Wat heb ik de vorige week gedaan ivm programmeren. Wel niet heel veel, maar alle kleine beetjes helpen en zijn beter dan helemaal niets. Ik durf wel eens overweldigd geraken met hetgeen ik nog te doen heb en als gevolg daarvan stel ik dingen uit. Nu heb ik me voorgenomen om regelmatiger te programmeren, ik doe het nog altijd graag dus waarom niet op regelmatige basis wat programmeren.

Deze week heb ik de linker en rechter operand gefilterd. Op zich niet zo moeilijk, maar er zijn verschillende dingen waarmee ik moest rekening houden. Bijvoorbeeld bij de linker operand is er een spatie tussen de operand en de komma die de rechter operand scheidt? Zo van die dingen. Ook de commentaren heb ik gefilterd, deze kunnen voorkomen op hun eigen regel of achter code gezet worden, er kan wel geen commentaar voor code zijn op dezelfde regel.

Ik ben tevreden over de vorderingen en het volgende wat op het programma staat is kijken of de linker of rechter operand een waarde bevat dan wel iets anders. Dat zal voor komende week zijn en misschien begin ik met het toevoegen van de mnemonic lijst, dit wordt een struct om dit allemaal bij te houden.