Why did the original code for FIND.COM use lop as a label instead of loop?


A few years ago, I left you with an exercise: Given the code

        mov     dx,st_length            ;length of the string arg.
        dec     dx                      ;adjust for later use
        mov     di, line_buffer
lop:
        inc     dx
        mov     si,offset st_buffer     ;pointer to beg. of string argument

comp_next_char:
        lodsb
        cmp     al,byte ptr [di]
        jnz     no_match

        dec     dx
        jz      a_matchk                ; no chars left: a match!
        call    next_char               ; updates di
        jc      no_match                ; end of line reached
        jmp     comp_next_char          ; loop if chars left in arg.

why is the loop label called lop instead of loop?

The answer is that calling it loop would create ambiguity with the 8086 instruction loop.

Now, you might say (if your name is Worf), that there is no ambiguity. "Every line consists of up to four things (all optional). A label, an instruction/pseudo-instruction, operands, and comments. The label is optionally followed by a colon. If there is no label, then the line must start with whitespace."

If those were the rules, then there would indeed be no ambiguity.

But those aren't the rules. Leading whitespace is not mandatory. If you are so inclined, you can choose to begin your instructions all in column zero.

mov dx,st_length
dec dx
mov di, line_buffer
lop:
inc dx
mov si,offset st_buffer
comp_next_char:
lodsb
cmp al,byte ptr [di]
jnz no_match
dec dx
jz a_matchk
call next_char
jc no_match
jmp comp_next_char

It's not recommended, but it's legal. (I have been known to do this when hard-coding breakpoints for debugging purposes. That way, a search for /^int 3/ will find all of my breakpoints.)

Since you can put the opcode in column zero, a line like this would be ambiguous:

loop ret

This could be parsed as "Label this line loop and execute a ret instruction." Or it could be parsed as "This is an unlabeled line, consisting of a loop instruction that jumps to the label ret."

Label Opcode Operand
loop ret
– or –
loop ret

Disallowing instruction names as labels or macros or equates is the simplest way out of this predicament. Besides, you probably shouldn't be doing it anyway. Imagine the havoc if you did

or equ and
Comments (4)
  1. Brian_EE says:

    Having spent two full semesters of my college EE career learning assembly language on 8086 XT machines (after having spent a semester learning 8085 assembly language on embedded dev kit boards) I knew the answer before reading the article.

    This was a course-work plus lab experience class. There were a whole series of labs we did where the user feedback was making the PC speaker beep (by programming the 8254(?) ). Nothing like 12 computers beeping for a whole hour while you and your classmates debug your programs.

  2. NotThisMind says:

    Damn, i cringe everytime i see code like that with or without my lens…

  3. Spire says:

    But isn't "loop ret" unambiguously a loop instruction because there isn't a colon after "loop"?

    [But the colon is optional, so in the absence of a colon, you don't know whether you are in the "There definitely is no colon here" case or the "There might be a missing colon here" case. -Raymond]
  4. Spire says:

    I've programmed my share of x86 assembly, but I didn't know that the colon after a label was optional. Thanks.

Comments are closed.

Skip to main content