"Zeichen" im Integer

[jmd anders]

ich hab mal ein bißchen rumgetestet, auch mit assembler, bisher aber nur für 32bit integer.

Delphi-Quellcode:

function InlineAsm(x:integer) : integer;
const e=1;
      z=10;
      h=100;
      t=1000;
     zt=10000;
     ht=100000;
      m=1000000;
     zm=10000000;
     hm=100000000;
     md=1000000000;
    zmd=10000000000;
asm
  MOV EDX, EAX
  JMP @Ret1

  @Ret1            :
    CMP EDX,z
    JAE @Ret10
    MOV EAX, 1
    JMP @Ende;
  @Ret10           :
    CMP EDX,h
    JAE @Ret100
    MOV EAX, 2
    JMP @Ende;
  @Ret100          :
    CMP EDX,t
    JAE @Ret1000
    MOV EAX, 3
    JMP @Ende;
  @Ret1000         :
    CMP EDX,zt
    JAE @Ret10000
    MOV EAX, 4
    JMP @Ende;
  @Ret10000       :
    CMP EDX,ht
    JAE @Ret100000;
    MOV EAX, 5
    JMP @Ende;
  @Ret100000       :
    CMP EDX,m
    JAE @Ret1000000
    MOV EAX, 6
    JMP @Ende;
  @Ret1000000      :
    CMP EDX,zm
    JAE @Ret10000000
    MOV EAX, 7
    JMP @Ende;
  @Ret10000000     :
    CMP EDX,hm
    JAE @Ret100000000
    MOV EAX, 8
    JMP @Ende;
  @Ret100000000    :
    CMP EDX,md
    JAE @Ret100000000
    MOV EAX, 9
    JMP @Ende;
  @Ret1000000000    :
    MOV EAX, 10
    JMP @Ende;

 @Ende :
end;

das ist dabei rausgekommen, sehr ähnlich zu jason's asm funktion, nur ohne irgendwelche schleifen.
ich hab jason's asm funktion nicht getestet, aber seine delphi funktion, die war extrem schnell(7-8mal schneller als die asm funktion von 3_of_8).
ich hatte das gefühl, dass meine funktion einen tick schneller ist als die delphi funktion von jason(ich glaub nicht mal 1%)