                      ͻ
                       
                    
                     
   ͻ        ͼ
                  ۰
                  ۰
       ͼ   ۰
                                 ۰
                           ۰
                      ۰
                       ۰
                          ۰
                                        ۰ 
                                                   ۰
ͻ                              ۰
DIE WELT DES                                ۰
GESCHWINDIG-                     ۰
KEITSRAUSCHES                             
ͼ                   
   ͻ                                       
   PART V                                      
   ͼ                                       


 Liebe Zielgruppe!

 Hier ist also Part V des ASM-Kurses, etwas versptet, sorry.

 
 =-> SCHLEIFEN
 -------------

 Der Wiederholungsfaktor einer Schleife wird durch den Inhalt des CX-
 Registers bestimmt. Wenn CX=0100h, wird der Inhalt der Schleife also
 256 mal wiederholt.

 Befehl: loop marke
         loopz/loope marke
         loopnz/loopne marke

 Die Marke kann bis zu 127 Byte hinter und 128 Byte vor dem LOOP stehen.

 Bsp.:
 -----

 mov cx,0010h                ; die Schleife soll 10x wiederholt werden
 marke:
 mov ax,0e07h                ; beep
 int 10h
 loop marke                  ; cx=cx-1; wenn cx<>0, dann gehe zu marke
 mov ah,4ch                  ; Ende
 int 21h

 Fr LOOP gilt also        : cx=cx-1; wenn cx<>0, dann gehe zu marke
 Fr LOOPZ und LOOPE gilt  : cx=cx-1; wenn cx<>0 und ZF=1 dann gehe zu marke
 Fr LOOPNZ und LOOPNE gilt: cx=cx-1; wenn cx<>0 und ZF=0 dann gehe zu marke

 CX wird also bei jedem LOOP um eins erniedrigt, man sollte darauf achten,
 da CX in der Schleife nicht (unerwscht) verndert wird, wie z.B. nach
 dem Aufruf einer DOS- oder BIOS-Funktion. Wer sicher gehen will, PUSHt und
 POPt CX.

 Bsp.:
 -----

 mov cx,XXXX
 marke:
 push cx
 .
 .
 .
 pop cx
 loop marke
 .
 .
 .

 
 =-> SHIFT-BEFEHLE
 -----------------

 Durch Shift-Befehle werden die Bits eines Bytes nach links oder rechts ver-
 schoben. Das aus dem Byte 'herausgeschobene' Bit wird in CF geschoben. Das
 letzte Bit wird auf 0 gesetzt.

 Format: Shift-Befehl REGISTER,1  (die Bits des Registers werden um EINE
                                   Position verschoben)
         Shift-Befehl REGISTER,CL (die Bits des Registers werden um die in
                                   CL gegebene Anzahl verschoben)
         Shift-Befehl MEM,1       (siehe REGISTER,1; aber mit einem Speicher-
                                   wert)
         Shift-Befehl MEM,CL      (siehe REGISTER,CL; aber mit einem
                                   Speicherwert)

 Befehle: SHL/SAL - Verschiebe nach links
          
          z.B. mov al,010h
               shl al,1

           vorher (binr):  CF:X  AL:00010000
           
           CF      AL
          Ŀ   Ŀ
           0 <ĳ00100000< 0
             

           nachher (binr):  CF:0  AL:00100000


          SHR - Verschiebe nach rechts

          z.B. mov al,064h
               shr al,1

           vorher (binr):  CF:X  AL:01100100
          
                  AL                  CF
                 Ŀ   Ŀ
           0 > 00110010> 0 
                    

           nachher (binr):  CF:0  AL:00110010
          
          
          SAR - Verschiebe arithmetisch nach rechts
                das letzte Bit wird NICHT verndert

          z.B. mov al,0afh
               sar al,1
                  
           vorher (binr):  CF:X  AL:10101111      
                  
                  AL                  CF
                 Ŀ   Ŀ
               >11010111> 1 
                   
               

           nachher (binr):  CF:1  AL:11010111


 Welchen Nutzen hat man nun von Shift-Befehlen? Die einfache Verschiebung
 nach links entspricht einer Multiplikation mit 2, eine doppelte einer
 vervierfachung usw.

 mov al,xx
 shl al,1  -> al=al*2

 Und die Verschiebung nach rechts entspricht einer Division durch 2...
 (Achtung, es wird gerundet.)

 mov al,xx
 mov cl,02h
 shr al,cl  -> al=al/4


 =-> ROTATIONS-BEFEHLE
 ---------------------

 Durch Rotations-Befehle werden die Bits eines Bytes nach links oder rechts
 rotiert, d.h. da das aus dem Byte 'herausgeschobene' Bit nach CF geschoben 
 wird und das letzte Bit den Wert des ersten erhlt.

 Format: siehe Shift-Befehle

 Befehle: ROL - rotiere nach links

          z.B. mov al,010h
               rol al,1

           vorher (binr):  CF:X  AL:00010000
           
           CF      AL
          Ŀ   Ŀ
           0 <ĳ00100000<Ŀ
               
                   

           nachher (binr):  CF:0  AL:00100000


          ROR - rotiere nach rechts

          z.B. mov al,065h
               ror al,1

           vorher (binr):  CF:X  AL:01100101
           
              AL                  CF
             Ŀ   Ŀ
          >10110010> 1 
               
          

           nachher (binr):  CF:1  AL:10110010


          RCL - Rotiere nach links ber Carry-Flag
                das letzte Byte wird vom CF bernommen

          z.B. mov al,064h
               rcl al,1

           vorher (binr):  CF:X  AL:01100100
           
              CF      AL
             Ŀ   Ŀ
            ڴ 0 <ĳ1100100X<Ŀ
                 
            

           nachher (binr):  CF:0  AL:1100100X


          RCR - Rotiere nach rechts ber Carry-Flag
                das letzte Byte wird vom CF bernommen
          
          z.B. mov al,065h
               rcr al,1

           vorher (binr):  CF:X  AL:01100101
           
              AL                  CF
             Ŀ   Ŀ
          >X0110010> 1 
               
          

           nachher (binr):  CF:1  AL:X0110010
 
 
 So, das war's fr heute.
 
 Ŀ
  Wer mir eine (besser zwei) Disk(s) zusendet und das Stichwort 'Assembler'
  irgendwo auf/im Brief vermerkt, bekommt seine Disk(s) randvoll mit       
  SW/PD/FW-Tools (A86, D86...) zum Thema Assembler zurck. Dazu gibt's die 
  ASM-Kurs-Parts!                                                          
                                                                           
  Bei leerer Disk gilt: Rckporto und Rckumschlag nicht vergessen!        
 

 
 Master YODA (Manuel Mbes, Lahnstr.4, 06846 Dessau)
 
 
 NOTE: Ŀ
        Wer die letzten Parts des ASM-Kurses verpasst hat, sollte sich  
                                                                        
                              das nchste SKYLINE                       
                                                                        
        besorgen, da der erste Part dort erscheinen soll (natrlich mit 
         dem Einverstndnis von SolarDesign). Das SKYLINE-DiskMag be-   
          kommt Ihr z.B. bei KILLER TAIFUN (Addy siehe ADDY, logisch)   
                        oder auch bei meiner Wenigkeit.                 
       

 NOTE3: Die einzelnen Parts gibt's natrlich auch bei mir, gegen Disk, Rck-
        umschlag und Porto.

 NOTE2: Sollte jemand Fehler in meinen Geschreibsel finden, mich loben,
        korrigieren, oder beschimpfen wollen, soll er mir seine Meinung mit-
        teilen!


   

Fr alle, die ein Programm brauchen, das einen Reset auslst, sich jedoch
nicht mit ASS / Debug auskennen:
Startet zunchst den DOS-Editor, beispielsweise mit EDIT RESET.COM.
Dann gebt ihr das ASCII-Zeichen 234 ein: <Alt> drcken und gedrckt halten,
auf dem Ziffernblock 234 tippen und <Alt> loslassen. Dasselbe macht ihr dann
viermal hintereinander mit dem ASCII-Zeichen 240. Wenn ihr das nun speichert,
habt ihr ein 7 Byte langes Programm (der Editor klemmt noch zwei Bytes
hintendran, doch die sind bedeutungslos).
Fr ASS-Freax: Da man im Editor das Zeichen Nr. 255 ($FF) nicht eintippen 
kann, habe ich das JMP FFFF:0000 in JMP F0F0:F0F0 umgewandelt. Bewirkt im 
Endeffekt ja dasselbe. Die zwei Bytes vom Editor, ein simpler 
Zeilenvorschub, stellt zwar in der COM-Datei einen sinnlosen Befehl dar, doch
dieser Befehl wird nie ausgefhrt, weil davor der Reset ausgelst wird.

                 Cheers,
                       l'Original du PTPT

   

 ULLIX!

 Yep, fr das nexte PLATINUM werd' ich mal 'ne kleine Routine fr 'nen
 Scroller im Grafikmodus (320*200), mit SIN und ohne den Hintergrund zu
 beeinflussen, schreiben.

 Ich hab' allerdings keine Ahnung, wie das in 'professionellen' Demos
 gemacht wird (Unreal)! Werde das wie'n Sprite behandeln, sollte laufen.

 Warum nimmst Du nicht den Scroller vom PL13-Intro?

 Kenne leider keinen Char-Editor.

 Gru, Master YODA.

 PS: Wie macht man denn Sin-Scroller im Textmodus?

   

 An alle,

 hat schon wer von euch in OBERON programmiert ? Die Sprache  selbst  wre  ja
 nicht schwer, da sie ziemlich an Modula und Pascal angelehnt  ist,  aber  die
 beiden Compiler (POW!, ETH-Oberon), die ich da habe, sind reinster  Schwach-
 sinn, total benutzerfeindlich (besonders ETH) und mit Bugs  nur  so  gefllt.
 Die armen Studenten hier in Linz mssen ab diesem Semester mit dem Zeug  pro-
 grammieren. Ich brauche ihre Programme glcklicherweise dann  nur  verbessern
 und habe so mit dem Compilern wenig zu tun. Da ich mich aber trotzdem mit den
 Compilern ein wenig auskennen mu, habe ich mal eine kleine  bung  mit  POW!
 und ETH programmieren mssen. Dabei rgerte ich mich  grn  und  blau  damit.
 Sollten die diese Compiler nicht schleunigst  verbessert  werden,  wird  wohl
 Oberon schnell wieder verschwinden. Mir sind nmlich  keine  anderen  Oberon-
 Compiler bekannt.

 Rainer / SKYLINE

   
