system error wrote:

It's not about beautiful looking code. It's about semantics. People created textual symbols and symbolic languages because they didn't want to get confused with similar-looking patterns which proven to be error-prone by the past machine coders.

It's like naming your kid as Tyrone, and his kids as Tyrone, and their next kids as all Tyrone. Is it wrong? No but it creates a very confusing semantics. Imagine the family name....

Sorry for going off-topic. (Perhaps this and my last post should be split off into the Heap.)

There's a lot that could be said on this, even though I'm no expert. Redundancy is bad when you're trying to be exact, but that's why there are many ways of identifying something, and context matters a lot. Generally speaking, the smaller number of reserved words, the better. But a lot of times "reserved", even in traditional programming languages, only applies to certain sections of the grammar. So you can't necessarily use "if" as a variable in C, but you can make a structure member (or indeed several, since C89 or MASMv6) named that. (Example omitted because it's pointless.)

That's not true. Things are clearly defined at the point you start the code, but not in the future, and that's the issue. Instructions and "reserved keywords" can be added. Look at the mess C++ is in.

The C++ Committee hates adding new keywords for the reason that they are "reserved" (which is a bad design to begin with, it should be deducible from context). Do you know "requires" is/will be a keyword in C++ now? It didn't use to be, so if you have any variable or function or struct or whatever called requires, it will fail to compile when you upgrade compilers and switch to new standard.

NASM allows you to use "reserved" keywords and deduce them from context, which is arguably better design, you don't risk of having your code fail to compile if you use a newer version of the assembler, because Intel or whoever decided to add an instruction that just so happens to coincide with a label name you used. It's as simple as that.

PS: Theoretically, you can compile most C code with a C++ compiler, however, you cannot compile the Linux Kernel with a C++ compiler. Because it uses the reserved word "class" and probably others. Imagine if C++ replaced C instead of being a new language. It's not unreasonable to use the word "class" for a variable or label at all. (e.g. class of the data code of your structure)

 
-,+[                         Read first character and start outer character reading loop
    -[                       Skip forward if character is 0
        >>++++[>++++++++<-]  Set up divisor (32) for division loop
                               (MEMORY LAYOUT: dividend copy remainder divisor quotient zero zero)
        <+<-[                Set up dividend (x minus 1) and enter division loop
            >+>+>-[>>>]      Increase copy and remainder / reduce divisor / Normal case: skip forward
            <[[>+<-]>>+>]    Special case: move remainder back to divisor and increase quotient
            <<<<<-           Decrement dividend
        ]                    End division loop
    ]>>>[-]+                 End skip loop; zero former divisor and reuse space for a flag
    >--[-[<->+++[-]]]<[         Zero that flag unless quotient was 2 or 3; zero quotient; check flag
        ++++++++++++<[       If flag then set up divisor (13) for second division loop
                               (MEMORY LAYOUT: zero copy dividend divisor remainder quotient zero zero)
            >-[>+>>]         Reduce divisor; Normal case: increase remainder
            >[+[<+>-]>+>>]   Special case: increase remainder / move it back to divisor / increase quotient
            <<<<<-           Decrease dividend
        ]                    End division loop
        >>[<+>-]             Add remainder back to divisor to get a useful 13
        >[                   Skip forward if quotient was 0
            -[               Decrement quotient and skip forward if quotient was 1
                -<<[-]>>     Zero quotient and divisor if quotient was 2
            ]<<[<<->>-]>>    Zero divisor and subtract 13 from copy if quotient was 1
        ]<<[<<+>>-]          Zero divisor and add 13 to copy if quotient was 0
    ]                        End outer skip loop (jump to here if ((character minus 1)/32) was not 2 or 3)
    <[-]                     Clear remainder from first division if second division was skipped
    <.[-]                    Output ROT13ed character from copy and clear it
    <-,+                     Read next character
]                            End character reading loop    

On the contrary, ASM's keywords are already and clearly defined in the manuals.

system error wrote:

On the contrary, ASM's keywords are already and clearly defined in the manuals.

Same with C++ at a certain point in time.

I'm talking about additions to the "language". In the case of asm, this means new instructions which are basically keywords. (in HLLs of course there's no instructions). Instructions that don't exist right now but might in the future. Nobody knows the future.

If you still can't see the point, read revolution's last post about crc32 instruction.

Would you name a label crc32 if it calculated the crc32 before the instruction was available? If so, your code would fail to compile in the future because of name clash with the crc32 instruction.

call crc32

crc32:
; ...    

So rewind back before crc32 instruction existed (Intel did not create it yet), you have this code:

Code:

call crc32

crc32:
; ...    

Code works fine, compiles. Both NASM and FASM compile it. All is good. At this point, your code is perfectly legal.

Years later, Intel add crc32 instruction, FASM makes it "reserved" on new version, now only NASM compiles your perfectly valid code you written, new versions of FASM don't anymore.

     call [crc32]
; ...
crc32 dd 0