; comment
; keys on root level
key1="some string value"
key2=1234 ; some number value in FASM format.
key3=#0f0a030405060708  ; binary field encoded in hex
dir1:
    key1="another key"   ; the full name is: /dir1/key1
    key2=1234
    dir2:
        key1=1234      ; /dir1/dir2/key1
        dir3:
            key1=1234  ; /dir1/dir2/dir3/key1
    key3=#010203    ; /dir1/key3
key4=1234      ; /key4 - on the root level.
    

; Arguments:
;   esi - pointer to the text of the database
;   edx - pointer to the path string
; Returns:
;   CF=0 if the path is found.
;     esi - pointer to the value.
;     ah=":" if the path is directory.
;     ah="=" if the path is data field.
;
;   CF=1 the path was not found.
;     esi - points to the first row after the end of the block where the path
;           is supposed to be (but is not).
;     edx - points to the remainder of the path that was not found.
proc __SearchData
begin
        mov     edi, edx
        xor     ebx, ebx        ; current block indent
        dec     ebx

.outer_loop:
; compute the line indent
        mov     ecx, esi

.scan_indent:
        lodsb
        test    al, al
        jz      .end_of_file

        cmp     al, ' '
        je      .scan_indent
        jb      .outer_loop

        cmp     al, ';'
        jne     .indent_ok

; skips to the end of the line.
.SkipIt:
        lodsb
        cmp     al, ' '
        jb      .outer_loop
        test    al, al
        jnz     .SkipIt

.end_of_file:
        dec      esi

.error:
        stc
        return

.indent_ok:
        dec     esi

        sub     ecx, esi
        neg     ecx

; Here the indent of the current line is in ECX.

        cmp     ecx, ebx
        jle     .error          ; if the current indent is less of equal than the block
                                ; indent, then the needed element can not be found.
        cmp     ecx, edi
        ja      .SkipIt         ; the current indent is above the current upper limit, so
                                ; the whole line have not to be processed.

        mov     edi, edx        ; the start of the current path

.key_loop:
        mov     al, [edi]
        inc     edi
        mov     ah, [esi]
        inc     esi

        test    al, al
        jz      .maybe_end_of_path
        cmp     al, '/'
        je      .key_maybe_found
        cmp     al, '\'
        je      .key_maybe_found

        test    ah, ah
        jz      .end_of_file

        cmp     al, ah
        je      .key_loop

; not this, so check the current line whether it is a directory.
.not_this:
        dec     esi

.dir_loop:
        lodsb
        test    al, al
        jz      .end_of_file

        cmp     al, ' '
        jb      .outer_loop
        je      .SkipIt
        cmp     al, '='
        je      .SkipIt
        cmp     al, ':'
        jne     .dir_loop

        mov     edi, ecx        ; it is a subdirectory, that is not in the path,
                                ; so set the upper limit.
        jmp     .SkipIt

.maybe_end_of_path:
        cmp     ah, '='
        je      .found

.key_maybe_found:
        cmp     ah, ':'
        jne     .not_this

        test    al, al
        jz      .found          ; the searched path is subdirectory, not a record.

        mov     edx, edi        ; the subdirectory was found. Set new path and block indent.
        mov     ebx, ecx
        jmp     .SkipIt

.found:                         ; the whole path was found.
        clc
        return
endp
    

Might be worthwhile to look at a binary format with ACID guarantees, that would (probably ) be something reasonably new.

f0dder wrote:

Might be worthwhile to look at a binary format with ACID guarantees, that would (probably ) be something reasonably new.

It is already invented: SQLite.

Anyway, every data structure can be represented in RDBS.