replaceURL Perl script is online

Vandaag het Perl script replaceURL online gezet op replaceURL op Github. Dit is een kort script dat alle HTML bestanden in een folder en sub-folders langsgaat en waar nodig delen van een URL aanpassen. Dit script is er gekomen omdat ik met een project bezig ben om bepaalde websites offline toegankelijk te maken op mijn server.

Het was nodig om sommige URLs, en dan speciek de domeinnaam ,te veranderen naar die van mijn server zodat deze ook offline correct werken. Kijk eens naar volgende voorbeeld waar een URL moet vervangen worden door een andere URL.

https://www.msx.org/test.html 

moet vervangen worden door

http://endor-five.local/test.html

het gebruik van het script is dan het volgende

$ ./replaceURL -u "http://endor-five.local" -o "https://www.msx.org" -d "test" -b

Dit script gaat dus elke folder en sub-folder af en vervangt alle URLs in alle HTML bestanden door de nieuwe.

Voor meer info over het gebruik ga naar replaceURL op Github

Gepubliceerd op Tuesday 7 May, 2024

Blog verhuisd naar GitHub

Onlangs heb ik mijn blog verhuisd naar GitHub. Er is geen speciale reden voor, maar ik vond het idee om GitHub te gebruiken niet slecht, daar heb ik ook wat meer analytics. Ik snap wel dat om me te volgen op GitHub je een account moet aanmaken, maar gewoon lezen van de blog posts kan je zonder account.

Ik heb ook beslist om in het engels verder te gaan, gewoon om wat meer mensen te kunnen bereiken. Ik heb er wel een disclaimer bij gezet dat engels niet mijn moedertaal is en er dus fouten kunnen zitten in de blog posts.

Neem maar eens een kijkje op GitHub

Gepubliceerd op Thursday 4 January, 2024

Twee kleine scripts om het leven wat makkelijker te maken

Afgelopen weekend heb ik twee scripts gemaakt die het voor mij wat makkelijker maken. Het eerste is een script dat meerdere repositories pushed naar een git server. Dit maakt het voor mij sneller om te pushen, anders moest ik altijd de folder ingaan en dan pushen. Nu kan dit met 1 commando.

Het tweede script is om het IP adres van een server door te mailen bij startup dmv IFTTT. Dit is omdat soms mijn backup git server van IP adres veranderd, dan moet ik altijd inloggen op de computer zelf. Voor de backup git server is dit niet zo een probleem omdat dit een oude laptop is. Als dit gebeurt met mijn HP Proliant DL360 gen5 dan moet ik altijd een oude macbook uit 2006 uit de kast halen en op afstand inloggen, een heel gedoe dus.

git-push-script

mail-ip-script

Gepubliceerd op Monday 27 November, 2023

Update ToHex

Ik heb een update gedaan in het ToHex project. Nu kan je ook lowercase hexadecimale string omzetten naar decimaal. Voorheen was dit enkel uppercase. Voorts heb ik een fix gedocumenteerd voor de code op Windows Visual Studio. Er waren een paar fouten die het compileren niet mogelijk maakten, nu moet men eerst de twee fixes uitvoeren en dan werkt het ook op Windows.

Misschien kan ik hier nog een aanpassing doen om gewoon met een define regel het automatisch aanpassen door te voeren. Hierdoor moet je enkel de waarde in de define regel aanpassen en dan gaat dat automatisch doorgevoerd worden in de code.

Ook heb ik de README.md file aangepast zodat het nu de drie publiek toegankelijke functies omschrijft.

Gepubliceerd op Tuesday 31 October, 2023

DBWiki is af ;-)

Vorige week heb ik dbwiki template voor HUGO static website generator afgemaakt en online gezet op github. De layout kan helemaal aangepast worden voor eigen doeleinden via CSS. Je kan ook google webfonts of ttf fonts gebruiken. Op github staat ook een uitleg over hoe het template te gebruiken.

Gepubliceerd op Thursday 19 October, 2023

Git Backup Server (Acer Aspire One 532h)

Totnutoe had ik altijd een backup van mijn git projecten op een USB stick bij mij als ik wegging. Nu had ik hier nog een oude Acer Aspire One 532h liggen waar ik destijds nog een SSD had ingebouwd.

Nu heb ik deze geinstalleerd met Ubuntu Server 22.04 en git erop gezet. Daar zit standaard gitweb bij om een web interface te hebben voor de projecten. Samen met lighttpd kun je dus bij je projecten vanaf de laptop opgestart is zonder zelf een web server te moeten activeren.

Dit heeft wel wat werk gekost omdat ik steeds een blank scherm kreeg en de pagina bleef laden. Dit bleek het ontbreken van een CGI.pm module te zijn. Wat opgelost kon worden met

     sudo apt install libcgi-pm-perl

Nu werkt alles correct en als ik wegga dan heb ik altijd een kopie van mijn software projecten bij me (Als ik de laptop niet vergeet natuurlijk ;-)).

Gepubliceerd op Saturday 12 August, 2023

Ubuntu Server op een QNAP Nas

Ik heb al een paar jaren een QNAP Nas staan, maar deze werd niet veel gebruikt. Het idee op zich is interessant, maar ik hou niet van het besturingssyteem dat QNAP of anderen op hun Nassen hebben staan. Ik geef de voorkeur aan een gewone Linux server. Nu heb ik ontdekt dat je op zo’n Nas ook gewoon een ander besturingssysteem kan zetten, in mijn geval dan Linux.

Als je Nas een hdmi poort heeft gaat dit vrij simpel. Nu als besturingssysteem kies ik voor Ubuntu server, en dan specifiek versie 22.04 LTS. Ik had versie 20.04 LTS al op een usb stick staan dus probeerde ik deze te installeren. Dit ging niet omdat de video verbinding met de monitor steeds uitviel en het toetsenbord ook niet meer reageerde. De volgende optie was 22.04 LTS op een stick zetten en hopen dat het dan wel lukt. Jammer, maar deze ging het ook niet worden. Tijdens het installeren gaf deze telkens een foutmelding. Dan gaan we maar terug in de tijd met versie 18.04 LTS en dit lukte wel goed. De volgende stap was na installatie van 18.04 LTS upgraden naar 20.04 LTS. Dit werkte goed en dus trok ik mijn stoute schoenen aan en upgrade ik ook naar 22.04 LTS. Ook dit werkte goed.

Dus nu staat Ubuntu server 22.04 LTS op de QNAP Nas. Ik heb ook een slim stopcontact aangesloten en merk dat de QNAP Nas maar 18 watt verbruikt. Dit is zelfs minder dan mijn HP Proliant server in standby verbruikt. Dit brengt me op een idee om de HP Proliant server binnen afzienbare tijd op pensioen te laten gaan ten voordele van een andere oplossing.

Ik ben al op zoek gegaan naar een tweedehands Nas, maar die kosten algauw rond de 250€. Dus nu ben ik aan het zien of ik voor een 600€ een eigen pc kan configureren die dienst zal doen als server voor filmen, series, git projecten en gewoon ook als file server. Als processor kijk ik naar een Intel Pentium deze hebben een laag verbruik. IK hoop op een maximum verbruik van 60 watt. Dan kan zowel mijn HP Proliant server als deze QNAP Nas uit dienst genomen worden.

Dus nu ga ik wat sparen voor die zelf gebouwde PC en als het zover is dan zul jet het hier wel kunnen lezen. (Het zal wel pas voor later dit jaar zijn)

Gepubliceerd op Sunday 26 March, 2023

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.

Gepubliceerd op Sunday 5 February, 2023

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.

Gepubliceerd op Saturday 14 January, 2023

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!

Gepubliceerd op Saturday 31 December, 2022

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….

Gepubliceerd op Thursday 15 December, 2022

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.

Gepubliceerd op Sunday 11 September, 2022

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.

Gepubliceerd op Sunday 21 August, 2022

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.

Gepubliceerd op Sunday 14 August, 2022

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.

Gepubliceerd op Sunday 7 August, 2022

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.

Gepubliceerd op Sunday 24 July, 2022

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!"
Gepubliceerd op Sunday 3 July, 2022

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.

Gepubliceerd op Sunday 26 June, 2022

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.

Gepubliceerd op Sunday 19 June, 2022

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.

Gepubliceerd op Sunday 12 June, 2022