home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 1 / crawlyvol1.bin / bbs / jet_conf / misc.s < prev    next >
Text File  |  1993-05-06  |  15KB  |  502 lines
  1. *
  2. * miscellaneous assembler routines to use with semper.prg
  3. * author     : Jan Kriesten
  4. * last change: 12.04.1993
  5. *
  6.  
  7. *** Globale Variablen:
  8.  
  9.     .EXPORT clip
  10.         
  11.     .IMPORT desk, vdi_myhandle
  12.  
  13. *** Globale Funktionen:
  14.  
  15.     ;*** MYDIAL-Routinen:
  16.     .IMPORT hide_mouse, show_mouse, rect2array, xywh2array
  17.     .IMPORT myrc_intersect
  18.  
  19.     ;*** Bibliotheksroutinen:
  20.     .IMPORT vs_clip, vro_cpyfm, wind_update, itoa
  21.  
  22. ***-----------------------------------------------------------------------------
  23. *** Funktionsname:    get_tos
  24. ***        ->    a0:    Zeiger Variable, wo TOS-Version gesichert werden soll
  25. ***        <-    nichts
  26. ***
  27. *** Die Funktion holt die TOS-Version über den _sysbase-Vektor des Betriebs-
  28. *** systems.
  29. ***
  30. get_tos:
  31.         xdef        get_tos                ; Funktion exportieren
  32.         move.l        a3, -(sp)            ; Register retten
  33.         movea.l        a0, a3                ; hierhin muß das Ergebnis
  34.         
  35.         pea            .get_tos            ; aufzurufende Funktion
  36.         move.w        #38, -(sp)            ; Supexec (XBIOS 38)
  37.         trap        #14                    ; XBIOS-Trap
  38.         addq.l        #6, sp                ; Stack aufräumen
  39.  
  40.         movea.l        (sp)+, a3            ; Register restaurieren
  41.         rts                                ; und zurück
  42.  
  43. .get_tos:
  44.         movea.l        ($04f2), a0            ; (_sysbase-Vektor)->OSHEADER-Struktur
  45.         move.w        2(a0), (a3)            ; TOS-Version sichern
  46.         rts                                ; und zurück
  47.         
  48. ***-----------------------------------------------------------------------------
  49. *** Funktionsname:    do_bcd
  50. ***        ->    d0: BCD-Zahl
  51. ***            a0:    Zeiger auf char[4], wo ASCII gesichert werden soll
  52. ***        <-    nichts
  53. ***
  54. *** Die Funktion macht aus einer 3-stelligen BCD-Zahl einen ASCII-String.
  55. ***
  56. do_bcd:
  57.         xdef        do_bcd                ; Funktion exportieren
  58.         clr.w        6(a0)                ; String nullterminiert
  59.  
  60.         move.b        d0, d1                ; letzte BCD-Zahl nach d1
  61.         and.w        #$000f, d1            ; auf Wortlänge erweitern
  62.         add.w        #$30, d1            ; das ist jetzt ASCII
  63.         lsl.w        #8, d1                ; das ist zweite Nachkomma
  64.         move.w        d1, 2(a0)            ; nach help
  65.         
  66.         lsr.w        #4, d0                ; d0 ein Byte nach links
  67.         move.b        d0, d1                ; nächstes Byte
  68.         and.w        #$000f, d1            ; auf Wortlänge bringen
  69.         add.w        #$30, d1            ; das ist jetzt ASCII
  70.  
  71.         lsr.w        #4, d0                ; d0 ein Byte nach links
  72.         add            #$30, d0            ; ebenfalls ASCII
  73.         lsl.w        #8, d0                ; das kommt ins high-Byte
  74.         or.w        d0, d1                ; in d1 vereinigen
  75.         move.w        d1, (a0)            ; nach help
  76.  
  77.         rts                                ; und zurück
  78.  
  79. ***-----------------------------------------------------------------------------
  80. *** Funktionsname:    normkey
  81. ***        ->    d0:    kstate (aus evnt_multi)
  82. ***            d1: kreturn (aus evnt_multi)
  83. ***        <-    d0: normalisierten Tastaturcode
  84. *** Die Funktion bereitet die Rückgabe von pks und pkr eines Evnt-Multi für 
  85. *** den Aufruf von nkc_tconv auf, die einen TOS-Key folgenden aussehens
  86. *** erwartet:
  87. ***
  88. ***        Bit 0-7:        ASCII-Code
  89. ***        Bit 8-15:        nichts
  90. ***        Bit 16-23:        SCAN-Code
  91. ***        Bit 24-31:        Keyboard-State
  92. ***
  93. *** Zudem werden beide Shift-Bits gesetzt, wenn nur einer gesetzt war, und das
  94. *** CapsLock-Bit und das NKCC-reservierte Bit werden ausgeblendet
  95. normkey:
  96.         xdef        normkey                ; Funktion exportieren
  97.         move.w        d3, -(sp)            ; Register retten
  98.         move.w        d0, d3                ; Keyboard-State nach d3
  99.  
  100.         ;*** Keyboard-Return umwandeln:        
  101.         move.w        d1, d0                ; Keyboard-Return nach d1 kopieren
  102.         andi.l        #$000000FF, d0        ; Scancode ausblenden
  103.         andi.l        #$0000FF00, d1        ; dort den ASCII-Code ausblenden
  104.         lsl.l        #8, d1                ; der soll nach TOS-Manier in das obere Word
  105.         or.l        d1, d0                ; und wieder zusammensetzen;
  106.         
  107.         ;*** Keyboard-State umwandeln:
  108.         moveq.l        #24, d1                ; um die Anzahl soll verschoben werden
  109.         lsl.l        d1, d3                ; d3 schieben
  110.         or.l        d3, d0                ; das fassen wir jetzt alles in d0 zusammen
  111.         
  112.         ;*** NKCC aufrufen:
  113.         import        nkc_tconv            ; Funktionsadresse importieren
  114.         jsr            nkc_tconv            ; daraus jetzt den normalisierten Code
  115.  
  116.         ;*** entsprechende Bits setzen/löschen:
  117.         andi.w        #$bfff, d0            ; das von NKCC reservierte Bit wird ausgeblendet
  118.         
  119.         move.w        d0, d1                ; nochmal nach d1 zum testen
  120.         andi.w        #$0300, d1            ; alles außer NKF_RSH und NKF_LSH aublenden
  121.         beq.b        no_or                ; wenn keins von beiden gesetzt, dann kein or
  122.         or.w        #$0300, d0            ; sonst beide Shift-Codes setzen
  123.  
  124. no_or:
  125.         andi.w        #$efff, d0            ; CapsLock-Code ausblenden
  126.  
  127.         move.w        (sp)+, d3            ; Stack restaurieren
  128.         rts                                ; und zurück
  129.  
  130. ***-------------------------------------------------------------------------------
  131. *** Funktionsname:    scroll_area
  132. ***        ->    a0:    Zeiger auf RECT für den Bereich
  133. ***            d0:    delta
  134. ***        <-    nichts.
  135. ***
  136. *** Die Funktion verschiebt den Bereich, auf den a0 zeigt um delta in 
  137. *** vertikaler Richtung.
  138. scroll_area:
  139.         xdef        scroll_area            ; Funktion exportieren
  140.         move.l        d3, -(sp)            ; Register retten
  141.         move.l        a3, -(sp)            ; "
  142.         
  143.         link.w        a4, #-64            ; Lokale Variablen anlegen
  144.                 SMFDB    .EQU    -20        ; Offsets der Variablen
  145.                 DMFDB    .EQU    -40        ;
  146.                 XY        .EQU    -56        ;
  147.                 DST        .EQU    -64        ;
  148.         move.l        d0, d3                ; delta retten
  149.         movea.l        a0, a3                ; Zeiger auf RECT retten
  150.         
  151.         ;*** Bildschirm sperren und Mauszeiger löschen:
  152.         moveq.l        #1, d0                ; BEG_UPDATE
  153.         jsr            wind_update            ; AES-Funktion ausführen
  154.         jsr            hide_mouse            ; MYDIAL: Mauszeiger verstecken
  155.  
  156.         clr.l        SMFDB(a4)            ; Bildschirmadresse erzwingen
  157.         clr.l        DMFDB(a4)            ; "
  158.  
  159.         lea            XY(a4), a1            ; dummy
  160.         movea.l        a3, a0                ; zu verschiebender Bereich
  161.         jsr            rect2array            ; in array wandeln
  162.  
  163.         lea            XY(a4), a0            ; Adresse von xy nach a0
  164.         move.l        (a0), 8(a0)            ; xy[0], xy[1] hochkopieren
  165.         move.l        4(a0), 12(a0)        ; xy[2], xy[3] hochkopieren
  166.                 
  167.         sub.w        d3, 10(a0)            ; Clippingbereich berechnen
  168.         sub.w        d3, 14(a0)            ; "
  169.         
  170.         lea            DST(a4), a1            ; dst-Adresse
  171.         lea            8(a0), a0            ; Scrollbereich
  172.         jsr            array2rect            ; in Array wandeln
  173.         
  174.         lea            DST(a4), a1            ; dst-Adresse
  175.         lea            desk, a0            ; Desktop-Ausmaße
  176.         jsr            myrc_intersect        ; Überschneidung mit Desktop-Bereich
  177.         
  178.         tst.w        d0                    ; Überschneidung vorhanden?
  179.         beq            sa_ende                ; wenn nicht, dann Ende
  180.  
  181.         ;*** Clipping setzen:
  182.         lea            DST(a4), a0            ; RECT für das Clipping
  183.         moveq.l        #1, d0                ; TRUE (Clipping setzen)
  184.         bsr            set_clip            ; setzen ...
  185.         
  186.         pea            DMFDB(a4)            ; Adresse des 2. MFDB-Blocks
  187.         lea            SMFDB(a4), a1        ; Adresse des 1. MFDB-Blocks
  188.         lea            XY(a4), a0            ; zu verschiebender Bereich
  189.         moveq.l        #3, d1                ; S_ONLY (Zielpixel = Quellpixel)
  190.         move.w        vdi_myhandle, d0    ; vdi-handle
  191.         jsr            vro_cpyfm            ; VDI-Funktion ausführen
  192.         addq.l        #4, sp                ; Stack restaurieren
  193.         
  194. sa_ende:
  195.  
  196.         jsr            show_mouse            ; MYDIAL: Mauszeiger zeigen
  197.         clr.w        d0                    ; END_UPDATE
  198.         jsr            wind_update            ; AES-Funktion ausführen
  199.  
  200.         unlk        a4                    ; Lokale Variablen entfernen        
  201.         movea.l        (sp)+, a3            ; Register restaurieren
  202.         move.l        (sp)+, d3            ; "
  203.  
  204.         rts
  205.  
  206. ***-------------------------------------------------------------------------------
  207. *** Funktionsname:    set_clip
  208. ***        ->    a0:    Zeiger auf Clipping-Bereich
  209. ***            d0:    Clipflag
  210. ***        <-    nichts.
  211. ***
  212. *** Die Funktion setzt das Clipping auf den Bereich a0
  213. set_clip:
  214.         xdef        set_clip            ; Funktion exportieren
  215.         move.l        d3, -(sp)            ; Register retten
  216.         move.l        a3, -(sp)            ; "
  217.         
  218.         link.w        a4, #-16            ; Lokale Variablen für 2 RECTS
  219.                 XYWH    .EQU    -16        ; Offsets der Variablen
  220.                 DEST    .EQU    -8        ; 
  221.  
  222.         move.w        d0, d3                ; Clipflag retten
  223.         movea.l        a0, a3                ; Zeiger auf RECT retten
  224.         
  225.         cmpa.l        #0, a3                ; ist überhaupt ein Bereich angegeben
  226.         bne            .size                ; wenn ja, dann weiter bei .size
  227.         
  228.         ;*** sonst Desktop nehmen:
  229.         lea            DEST(a4), a1        ; hier rein kopieren
  230.         lea            desk, a0            ; Desktop-Ausdehnung
  231.         move.l        (a0), (a1)            ; x, y kopieren
  232.         move.l        4(a0), 4(a1)        ; w, h kopieren
  233.         
  234.         bra            .cont1                ; weiter bei .cont1
  235.  
  236. .size:
  237.         ;*** RECT nehmen:
  238.         lea            DEST(a4), a1        ; hier rein kopieren
  239.         move.l        (a3), (a1)            ; x, y kopieren
  240.         move.l        4(a3), 4(a1)        ; w, h kopieren
  241.                 
  242. .cont1:
  243.         ;*** Werte in globaler Clipping-Variable sichern:
  244.         lea            clip, a0            ; Adresse der Clipping-Variable
  245.         move.l        (a1), (a0)            ; x, y kopieren
  246.         move.l        4(a1), 4(a0)        ; w, h kopieren
  247.         
  248.         ;*** Desktop-Überschneidung bestimmen:
  249.         lea            desk, a0            ; Desktop-Bereich
  250.         jsr            myrc_intersect        ; bestimmen ...
  251.         
  252.         tst.w        d0                    ; im Desktop-Bereich?
  253.         beq            .cont2                ; wenn nicht, dann nichts zeichnen
  254.         
  255.         ;*** in Array wandeln:
  256.         lea            XYWH(a4), a1        ; hier rein ...
  257.         lea            DEST(a4), a0        ; diese Koordinaten
  258.         jsr            rect2array            ; umwandeln
  259.         
  260.         bra            .clip                ; Clipping setzen
  261.         
  262. .cont2:
  263.         ;*** nichts zeichnen:
  264.         lea            XYWH(a4), a0        ; hier rein ...
  265.         clr.w        -(sp)                ; 0
  266.         clr.w        d2                    ; 0
  267.         clr.w        d1                    ; 0
  268.         clr.w        d0                    ; 0
  269.         jsr            xywh2array            ; umwandeln
  270.         addq.l        #2, sp                ; Stack aufräumen
  271.         
  272. .clip:
  273.         lea            XYWH(a4), a0        ; Adresse vom Bereich
  274.         move.w        d3, d1                ; Clipflag (TRUE oder FALSE)
  275.         move.w        vdi_myhandle, d0    ; VDI-Handle
  276.         jsr            vs_clip                ; VDI-Funktion ausführen
  277.         
  278.         unlk        a4                    ; Lokale Variablen entfernen
  279.         movea.l        (sp)+, a3            ; Register restaurieren
  280.         move.l        (sp)+, d3            ; "
  281.         rts                                ;
  282.  
  283. ***-------------------------------------------------------------------------------
  284. *** Funktionsname:    array2rect
  285. ***        ->    a0:    Ausgangsarray
  286. ***            a1:    Zielrect
  287. ***        <-    nichts.
  288. ***
  289. *** Die Funktion wandelt ein Array in Rect
  290. array2rect:
  291.         xdef        array2rect            ; Funktion exportieren
  292.         move.w        (a0), d0            ; array[0] nach d0
  293.         move.w        4(a0), d1            ; array[2] nach d1
  294.         
  295.         cmp.w        d0, d1                ; Vergleichen, welches von beiden größer
  296.         bpl            .umgek1                ; wenn positiv, dann war array[2] größer
  297.  
  298.         ;*** Kleineres nach rext.x, größeres nach rect.w:        
  299.         move.w        d1, (a1)            ;
  300.         move.w        d0, 4(a1)            ;
  301.         bra            .next1                ;
  302. .umgek1:
  303.         move.w        d0, (a1)            ;
  304.         move.w        d1, 4(a1)            ;
  305.         
  306. .next1:
  307.         move.w        2(a0), d0            ; array[1] nach d0
  308.         move.w        6(a0), d1            ; array[3] nach d1
  309.         
  310.         cmp.w        d0, d1                ; Vergleichen, welches von beiden größer
  311.         bpl            .umgek2                ; wenn positiv, dann war array[3] größer
  312.  
  313.         ;*** Kleineres nach rect.y, größeres nach rect.h:        
  314.         move.w        d1, 2(a1)            ;
  315.         move.w        d0, 6(a1)            ;
  316.         bra            .next2                ;
  317. .umgek2:
  318.         move.w        d0, 2(a1)            ;
  319.         move.w        d1, 6(a1)            ;
  320.         
  321. .next2:
  322.         ;*** rect.w korrigieren:
  323.         move.w        (a1), d0            ; rect.x holen
  324.         sub.w        d0, 4(a1)            ; rect.w - rect.x
  325.         addi.w        #1, 4(a1)            ; + 1
  326.         
  327.         ;*** rect.h korrigieren:
  328.         move.w        2(a1), d0            ; rect.y holen
  329.         sub.w        d0, 6(a1)            ; rect.h - rect.y
  330.         addi.w        #1, 6(a1)            ; + 1
  331.         
  332.         rts                                ; und zurück ...
  333.  
  334. ;-------------------------------------------------------------------------------
  335. ; select_file ruft Fileselctor auf;
  336. ;    -> a0:        Zeiger auf String mit/für Pfad
  337. ;       a1:        Zeiger auf String mit/für Name
  338. ;       Stack:    Zeiger auf String mit Label für Fileselector
  339. ;    <- d0:        gedrückter Button (0: Abbruch, 1: OK)
  340. ;
  341. select_file:
  342.         xdef        select_file            ; Funktion exportieren
  343.         xref        tos                    ; Variable importieren
  344.         xref        strlen                ; Funktionen importieren
  345.         xref        fsel_input            ;
  346.         xref        fsel_exinput        ;
  347.         
  348.         move.l        a3, -(sp)            ; Register retten
  349.  
  350.         move.l        a0, a3                ; Adresse des Pfades retten
  351.         link        a2, #-2                ; Lokale Variable anlegen
  352.                 OKs            .EQU    -2    ; Offset für lokale Variable
  353.  
  354.         ;*** Parameter für Fileselector setzen:
  355.         move.l        12(a2), -(sp)        ; Label
  356.         pea            OKs(a2)                ; pbutton
  357.  
  358.         ;*** fsel_exinput möglich?
  359.         cmpi.w        #$0140, tos            ; tos >= 0x140?
  360.         bpl            .exin                ; wenn ja, dann ist es möglich
  361.  
  362. .fselin:
  363.         ;*** nur fsel_input möglich:
  364.         jsr            fsel_input            ; AES-Funktion ausführen
  365.         bra            .weiter                ; weiter bei .weiter
  366.  
  367. .exin:
  368.         ;*** fsel_exinput möglich:
  369.         jsr            fsel_exinput        ; AES-Funktion ausführen
  370.  
  371. .weiter:
  372.         addq.l        #8, sp                ; Stack korrigieren
  373.         
  374.         ;*** vom Pfad das *.* abschneiden:
  375.         move.l        a3, a0                ; Adresse des Pfades nach a0
  376.         jsr            strlen                ; und Stringlänge ermitteln
  377.  
  378.         bra            .loop        
  379. .while:
  380.         subq.l        #1, d0                ; Counter erniedrigen
  381. .loop:
  382.         cmpi.b        #'\', (a3, d0.l)    ; ist das Zeichen ein Backslash?
  383.         bne            .while                ; wenn nein, dann weiter
  384.         
  385.         addq.l        #1, d0                ; d0 + 1 muß auf 0 gesetzt werden
  386.         clr.b        (a3, d0.l)            ; Byte löschen
  387.         
  388.         move.w        OKs(a2), d0            ; Rückgabe des gedrückten Buttons
  389.  
  390. .sf_ende:
  391.         unlk        a2                    ; Lokale Variablen entfernen
  392.         move.l        (sp)+, a3            ; Register restaurieren
  393.         rts
  394.  
  395. ;-------------------------------------------------------------------------------
  396. ; time_date holt Zeit und Datum in String;
  397. ;    -> a0:        Zeiger auf String für Zeit (5 Byte)
  398. ;       a1:        Zeiger auf String für Datum (7Byte)
  399. ;    <- nichts.
  400. ;
  401. time_date:
  402.         xdef        time_date            ; Funktion exportieren
  403.         movem.l        a3/a4/d3, -(sp)        ; Register retten
  404.         
  405.         movea.l        a0, a4                ; Übergabe sichern
  406.         movea.l        a1, a3
  407.         
  408.         *** Zeit und Datum holen:
  409.         move.w        #23, -(sp)            ; Gettime (XBIOS 32)
  410.         trap        #14                    ; XBIOS-Trap
  411.         addq.l        #2, sp                ; Stack restaurieren
  412.         
  413.         move.l        d0, d3                ; Rückgabe sichern
  414.  
  415.         ;*** Zeit in String wandeln:
  416.         move.w        #11, d1                ; gleich 11 nach rechts schieben
  417.         lsr.w        d1, d0                ; in d0 Stunden.
  418.         movea.l        a4, a0                ; hierhin wandeln
  419.         move.w        #10, d1                ; Basis 10
  420.         bsr            itoa                ; wandeln
  421.  
  422.         tst.b        1(a2)                ; ist Ergebnis nur 1-stellig?
  423.         bne            .t1                    ; wenn nicht, dann weiter bei .t1
  424.  
  425.         move.b        (a4), 1(a4)            ; an die Zweite Stelle schieben
  426.         move.b        #32, (a4)            ; Blank einfügen
  427.         
  428. .t1:        
  429.         move.w        d3, d0                ; jetzt Minuten wandeln
  430.         lsr.w        #5, d0                ; Sekunden ausblenden
  431.         andi.w        #$003F, d0            ; Stunden ausblenden
  432.         lea            2(a4), a0            ; hierhin wandeln
  433.         move.w        #10, d1                ; Basis 10
  434.         bsr            itoa                ; wandeln
  435.         
  436.         tst.b        3(a4)                ; ist Ergebnis nur 1-stellig?
  437.         bne            .t2                    ; wenn nicht, dann weiter bei .t2
  438.  
  439.         move.b        2(a4), 3(a4)        ; an die Zweite Stelle schieben
  440.         move.b        #48, 2(a4)            ; Null einfügen
  441.  
  442. .t2:
  443.         ;*** Datum in String wandeln:
  444.         swap.w        d3                    ; jetzt ist das Datum dran
  445.         
  446.         move.w        d3, d0                ; in d0 wird gearbeitet
  447.         andi.w        #$001F, d0            ; Monat und Jahr ausblenden
  448.         movea.l        a3, a0                ; hierhin wandeln
  449.         move.w        #10, d1                ; Basis 10
  450.         bsr            itoa                ; wandeln
  451.  
  452.         tst.b        1(a3)                ; ist Ergebnis nur 1-stellig?
  453.         bne            .d1                    ; wenn nicht, dann weiter bei .d1
  454.  
  455.         move.b        (a3), 1(a3)            ; an die Zweite Stelle schieben
  456.         move.b        #48, (a3)            ; Null einfügen
  457.         
  458. .d1:
  459.         move.w        d3, d0                ; jetzt Monat wandeln
  460.         lsr.w        #5, d0                ; Tag ausblenden
  461.         andi.w        #$000F, d0            ; Jahr ausblenden
  462.         lea            2(a3), a0            ; hierhin wandeln
  463.         move.w        #10, d1                ; Basis 10
  464.         bsr            itoa                ; wandeln
  465.         
  466.         tst.b        3(a3)                ; ist Ergebnis nur 1-stellig?
  467.         bne            .d2                    ; wenn nicht, dann weiter bei .d2
  468.  
  469.         move.b        2(a3), 3(a3)        ; an die Zweite Stelle schieben
  470.         move.b        #48, 2(a3)            ; Null einfügen
  471.  
  472. .d2:
  473.         move.w        d3, d0                ; jetzt Jahr wandeln
  474.         move.w        #9, d1                ; um 9 verschieben
  475.         lsr.w        d1, d0                ; Monat und Tag ausblenden
  476.         add.w        #80, d0                ; + 80
  477.         lea            4(a3), a0            ; hierhin wandeln
  478.         move.w        #10, d1                ; Basis 10
  479.         bsr            itoa                ; wandeln
  480.         
  481.         move.b        #0, 4(a4)            ; Strings mit Null enden lassen
  482.         move.b        #0, 6(a3)
  483.         
  484.         movem.l        (sp)+, a3/a4/d3        ; Register restaurieren
  485.         rts                                ; und zurück ...
  486.  
  487. *****************************************************************************
  488.  
  489.         .DATA
  490.         .EVEN
  491.  
  492. *****************************************************************************
  493.  
  494.         .BSS
  495.         .EVEN
  496.  
  497. *** Globale Clipping-Variable:
  498. clip:    ds.w    4
  499.  
  500.         .END
  501.  
  502.