#       DEMO     : Using GNU Assembler & BASELIB (base6.o)
#       Compile  : as this.asm -o this.o
#       Link     : ld this.o base6.o -o this
.data
.align 16
        num: .quad 0x45,0x56
        xyz: .double 0f+456.4456

.text
.global _start
_start:
        mov     $_start,%rax
        mov     $num,%rbx
        call    dumpreg
        
        push    (num+8)
        mov     $10,%rax
        call    stackview
        
        mov     (xyz),%rax
        call    prndbl
        call    exitx
.end

These comments are ignored by the assembler after the .end directive. 
Now I am free to write some notes for this little code outside the busy coding 
area. AT&T syntax is confusing. This is within the same source    

Note that all fasm versions since the beginning respect the actual EOF byte or a null byte to terminate the file. If the editor you use is able to handle inserting such bytes in a middle of text, you can use them for such purpose.

text.

Text after control characters.    

While some editors can do such tricks, it is not common. And it isn't potable. If someone posts code here using the EOF byte a lot of people won't be able to properly use it or see it. Copy and paste will be difficult.

macro footnote
{
These comments are ignored by the assembler after the .end directive. 
Now I am free to write some notes for this little code outside the busy coding 
area. AT&T syntax is confusing. This is within the same source
}    

;...
<<<<< ;start the comment
Random comments go here
end if }}}}}} <--- these won't cause any problem
macro ignored {}
rept 999999999 {display 'blah'}
rb -1
err
mov al,0xFFFFFFFF
db "unfinished string
>>>>> ;finish the comment    

Block have been discussed here in the past, a few times.

I am in favour of some repeating characters for start/end

Code:

;...
<<<<< ;start the comment
Random comments go here
end if }}}}}} <--- these won't cause any problem
macro ignored {}
rept 999999999 {display 'blah'}
rb -1
err
mov al,0xFFFFFFFF
db "unfinished string
>>>>> ;finish the comment    

Of course this is still vulnerable to the sequence ">>>>>" appearing in the comment field.

#
#  For Win32. Demo using GAS and CPULIB (cpu32.dll)
#  as this.asm -o this.obj --32
#  gcc -m32 this.obj cpu32.dll -o this.exe
#
        .code32             #force 32-bit code
        .globl _WinMain@16  #entry point for C

        .section .data
        .align 4
hello:  .asciz "Hello World\n"

        .section .text
_WinMain@16:
        push    %ebp
        mov     %esp,%ebp
        push    $hello
        call    _printf
        add     $4,%esp
        call    _dumpreg
        pop     %ebp
        ret
.end

Free-flowing notes:

        Manglish is the best English syntax in the world.
        come try lah!

        Basic skeleton for a 32-bit GAS on Win32
        mov <source>,<destination>
        No "db", "dw" etc. Sorry
        Registers come with % prefix. Ask Oracle for reference

        add esp,4 is CDECL stack cleanup and convention

        Can I just use .text instead of .section .text?
        I DON'T KNOW, ADRIANNNNN!!!

        int main()
        {
                printf("Hello World\n");
                return 0;
        }

        Equivalent Intel Syntax for "terrer" people
                push    ebp
                mov     ebp,esp
                push    hello
                call    _printf
                add     esp,4
                call    _dumpreg
                pop     ebp
                ret

output:
Hello World
EAX|0000000C EBX|00000001 ECX|76EBC620
EDX|77A36BF4 ESI|00890F30 EDI|00000007
EBP|0022FE98 ESP|0022FE98 EIP|00401580    

You don't have to worry about anything at all.

fasmnewbie wrote:

You don't have to worry about anything at all.

It would be nice if the editor can recognise the comment correctly and render it like other comments. That way it is less likely a tired programmer will mistakenly think there is active code there and start to edit/debug/extend it.

while not .stop or EOF or end-of-source
    keep assembling...
endwhile    

is it difficult to ask the assembler to stop parsing / tokenizing a source or whatever it is called after like, ".stop" sign? In my cluless opinion, it's just a matter of text processing.