include 'linux.asm'
include 'record-def.asm'

        format ELF

        section '.data' 

        ;; Constant data of the records we want to write.
        ;; Each text data item is padded to the proper length
        ;; with NULL bytes

record1:

        ;; First name
        db 'Fredrick\0'

        ;; pad it for 40 bytes total
        repeat 32
                db 0
        end repeat

        ;; Last name
        db 'Bartlett\0'
        repeat 31
                db 0
        end repeat

        ;; Address
        db '4242 S Prairie\nTulsa, OK 55555\0'
        repeat 209
                db 0
        end repeat

        dd 45

record2:
        db 'Marilyn\0'
        repeat 32
                db 0
        end repeat

        db 'Taylor\0'
        repeat 33
                db 0
        end repeat

        db '2224 S Johannan St\nChicago, IL, 12345\0'
        repeat 203
                db 0
        end repeat

        dd 29

record3:
        db 'Derrick\0'
        repeat 32
                db 0
        end repeat

        db 'McIntire\0'
        repeat 32
                db 0
        end repeat

        db '500 W Oakland\nSan Diego, CA 54321'
        repeat 206
                db 0
        end repeat

        dd 36

        ;; Name of the file we will write to
file_name:
        db 'test.dat\0'

                
        ST_FD equ -4
        section '.code' executable
_start:
        
        
        ;; Copy stack pointer to ebp
        mov ebp, esp
        sub esp, 4              ;allocate some space to hold fd

        ;; open the file
        mov eax, SYS_OPEN
        mov ebx, file_name
        mov ecx, 0101           ;create if doesn't exist, open for writing
        mov edx, 0666
        int LINUX_SYSCALL

        ;; Store fd
        mov eax, [ebp+ST_FD]

        ;; How would I push a "record" based on loop counter?
        ;; edi is our increment counter
        xor edi, edi            ;zero it out

write_record_loop:

        ;; Write the record
        push word [ebp+ST_FD]

        jmp push_proper_record  ;find the record to push
after_push:
        call write_record
        add esp, 8
        inc edi                 ;increment our counter

        cmp edi, 3              ;reached end?
        jae done_loop

        ;; Nope, loop again
        jmp write_record_loop

done_loop:
        ;; close fd
        mov eax, SYS_CLOSE
        mov ebx, [ebp+ST_FD]
        int LINUX_SYSCALL

        ;; Exit program
        mov eax, SYS_EXIT
        mov ebx, 0
        int LINUX_SYSCALL
        
        ;; ok, kind of useless, but oh well
push_proper_record:
        cmp edi, 0
        je push_record_one

        cmp edi, 1
        je push_record_two

        cmp edi, 2
        je push_record_three

        jmp after_push          ;this won't happen, unless eic > 2

push_record_one:
        push record1
        jmp after_push
push_record_two:
        push record2
        jmp after_push
push_record_three:
        push record3
        jmp after_push


        ;; This function writes a record to the given file descriptor
        ;; INPUT: File descriptor, buffer
        ;; OUTPUT: Produces a status code (when're we gonna start printing?)

        section '.data'
        restore ST_WRITE_BUF
        restore ST_FD
        
        ST_WRITE_BUF equ -8
        ST_FD equ -12

        section '.code' 
        ;; @function write_record
write_record:
        push ebp
        mov ebp, esp

        push ebx                ;save ebx
        mov eax, SYS_WRITE
        mov ebx, [ebp+ST_FD]
        mov ecx, [ebp+ST_WRITE_BUF]
        mov edx, RECORD_SIZE
        int LINUX_SYSCALL

        ;; Note: eax has return value, which we will give back
        ;; to our calling program
        pop ebx

        mov esp, ebp
        pop ebp
        ret
    

Anyone? I keep getting Segmentation Faults if I use "format ELF", but don't if I use "format ELF executable"... however, with the "executable", I can't use sections like '.bss'... how would I do this?