Printing all permutations of digits of a number

Question

So, a long time ago, I've made a program that prints all the permutations of digits of a number in AEC. Now I have refactored it a bit, and I would be interested in what you think about it.

;Advanced example: implementing the permutation algorithm.
AsmStart
    debug=0
    macro pushIntegerToTheSystemStack x
    {
        sub esp,4
        fld dword [x]
        fistp dword [esp]
    }
    macro pushPointerToTheSystemStack x
    {
        sub esp,4
        lea ebx,[x]
        mov [esp],ebx
    }
    macro pushStringToTheSystemStack x
    {
        sub esp,4
        mov dword [esp],x
    }
    format PE console
    entry start

    include 'win32a.inc'

    section '.text' code executable
    start:
    jmp enterNumber$
        enterNumber db "Enter a whole number (1 - 1'000'000).",10,0
    enterNumber$:
    pushStringToTheSystemStack enterNumber
    call [printf]
    pushPointerToTheSystemStack original
    jmp floatSign$
        floatSign db "%f",0
    floatSign$:
    pushStringToTheSystemStack floatSign
    call [scanf]
    jmp permutationString$
        permutationString db "The permutations of its digits are:",10,0
    permutationString$:
    pushStringToTheSystemStack permutationString
    call [printf]
AsmEnd
numberOfPermutations:=0
numberOfDigits:=0
i:=0
While i<10
    countDigits[i] := 0
    i:=i+1
EndWhile
While original>0
    numberOfDigits := numberOfDigits + 1
    lastDigit := mod (original, 10)
    countDigits [lastDigit] := countDigits (lastDigit) + 1
    original := (original - lastDigit) / 10
EndWhile
AsmStart
    if debug=1
AsmEnd
        i:=0
        While i<10
            subscript:=4*i
            AsmStart
                fld dword [subscript]
                fistp dword [subscript]
                mov ebx,[subscript]
                pushIntegerToTheSystemStack (countDigits+ebx)
                pushStringToTheSystemStack integerSign
                call [printf]
            AsmEnd
            i:=i+1
        EndWhile
        AsmStart
            pushStringToTheSystemStack newLineString
            call [printf]
        AsmEnd
AsmStart
end if
AsmEnd
topOfMyStack:=1
myStack [ (numberOfDigits + 1) ] := 0
While topOfMyStack>0
    currentNumberOfDigits := myStack ( topOfMyStack * ( numberOfDigits + 1 ) )
    i:=0
    While i<currentNumberOfDigits
        currentNumber ( i ) := myStack ( topOfMyStack * ( numberOfDigits + 1 ) + ( i + 1 ) )
        i:=i+1
    EndWhile
    AsmStart
        if debug=1
    AsmEnd
            i:=0
            While i<currentNumberOfDigits
                subscript:=i*4
                AsmStart
                    fld dword [subscript]
                    fistp dword [subscript]
                    mov ebx,[subscript]
                    pushIntegerToTheSystemStack (currentNumber+ebx)
                    pushStringToTheSystemStack integerSign
                    call [printf]
                AsmEnd
                i:=i+1
            EndWhile
            AsmStart
                pushStringToTheSystemStack newLineString
                call [printf]
            AsmEnd
    AsmStart
        end if
    AsmEnd
    topOfMyStack:=topOfMyStack-1
    If currentNumberOfDigits=numberOfDigits
        numberOfPermutations:=numberOfPermutations+1
        i:=0
        While i<numberOfDigits
            subscript:=i*4
            AsmStart
                fld dword [subscript]
                fistp dword [subscript]
                mov ebx,[subscript]
                pushIntegerToTheSystemStack (currentNumber+ebx)
                pushStringToTheSystemStack integerSign
                call [printf]
            AsmEnd
            i:=i+1
        EndWhile
        AsmStart
            pushStringToTheSystemStack newLineString
            call [printf]
        AsmEnd
    Else
        i:=0
        While i<10
            counter:=0
            j:=0
            While j<currentNumberOfDigits
                If currentNumber(j)=i
                    counter:=counter+1
                EndIf
                j:=j+1
            EndWhile
            If counter < countDigits(i)
                topOfMyStack := topOfMyStack + 1
                myStack (topOfMyStack * (numberOfDigits + 1) ) := currentNumberOfDigits + 1
                j:=0
                While j < currentNumberOfDigits
                    myStack (topOfMyStack * (numberOfDigits + 1) + (j + 1)) := currentNumber (j)
                    j:=j+1
                EndWhile
                myStack (topOfMyStack * (numberOfDigits + 1) + (j + 1) ) := i
            EndIf
            i:=i+1
        EndWhile
    EndIf
EndWhile
AsmStart
    jmp numberOfPermutationsString$
    numberOfPermutationsString:
        db "The total number of permutations was: %d",10,0
    numberOfPermutationsString$:
    pushIntegerToTheSystemStack numberOfPermutations
    pushStringToTheSystemStack numberOfPermutationsString
    call [printf]
    invoke system,_pause
    invoke exit,0

    _pause db "PAUSE",0
    integerSign db "%d",0
    newLineString db 10,0

    section '.rdata' readable writable
        original dd ?
        result dd ?
        lastDigit dd ?
        numberOfDigits dd ?
        countDigits dd 11 dup(?)
        subscript dd ?
        myStack dd 1000 dup(?)
        topOfMyStack dd ?
        counter dd ?
        i dd ?
        currentNumber dd 11 dup(?)
        currentNumberOfDigits dd ?
        j dd ?
        numberOfPermutations dd ?


    section '.idata' data readable import
        library msvcrt,'msvcrt.dll'
            import msvcrt,printf,'printf',system,'system',exit,'exit',scanf,'scanf'
AsmEnd

The 32-bit Windows executable is available here, it's called permutations.exe.

Answer 1

Coding style

numberOfDigits:=0
numberOfDigits := numberOfDigits + 1
countDigits[i] := 0
countDigits [lastDigit] := countDigits (lastDigit) + 1
myStack [ (numberOfDigits + 1) ] := 0
myStack (topOfMyStack * (numberOfDigits + 1) ) := currentNumberOfDigits + 1

Throughout the program your use of whitespace and brackets is inconsistent.
Even if you have the choice between [] and () to address array elements, you should choose one of them and stick with your choice.
This fickleness is especially annoying in countDigits [lastDigit] := countDigits (lastDigit) + 1

Alternative

You can remove the high level subscript:=4*i if you use a scaled address form:

 i:=0
 While i<10
   AsmStart
     fld   dword [i]
     fistp dword [subscript]
     mov   ebx, [subscript]
     pushIntegerToTheSystemStack (countDigits + ebx * 4)
     ...

Warning

It's nice that you prompt the user for a non-zero number but your program should actually verify this.