home *** CD-ROM | disk | FTP | other *** search
/ ST-Computer Leser 2002 January / STC_CD_01_2002.iso / APP / TRAIL_PG / GEMJING / GEMJ136.LZH / Develop / PCSTARTB.S < prev    next >
Text File  |  1998-03-17  |  11KB  |  313 lines
  1. ;Tabulatorgrö₧e:    3
  2. ;Kommentare:                                                                ;ab Spalte 60
  3.  
  4. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  5. ;    Pure C Startup Code
  6. ;
  7. ;    ARGV und die Übergabe langer Dateinamen in Hochkommata wird unterstützt.
  8. ;  (c) und alle Rechte by Behne und Behne Software, Wunstorf.
  9. ;
  10. ;    07.10.95
  11. ;
  12. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  13. ;zu exportierende Referenzen
  14.  
  15.                         EXPORT    exit                                        ;void    exit( WORD status );
  16.                         EXPORT    __exit
  17.             
  18.                         EXPORT    _BasPag                                    ;Adresse der Baspage
  19.                         EXPORT    _StkLim                                    ;Untergrenze des Stacks
  20.                         EXPORT    _PgmSize                                    ;Grö₧e des Programms (TPA)
  21.                         EXPORT    _app                                        ;Flag für Accessory (0) oder Applikation (1)
  22.                         EXPORT    errno                                        ;globale Fehlervariable
  23.                         EXPORT    _AtExitVec
  24.                         EXPORT    _FilSysVec
  25.                         EXPORT    _RedirTab
  26.             
  27.                         EXPORT    __text
  28.                         EXPORT    __data
  29.                         EXPORT    __bss
  30.  
  31. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  32. ;zu importierende Referenzen
  33.  
  34.                         IMPORT    main                                        ;WORD main( WORD argc, BYTE **argv, BYTE **envp );
  35.                         IMPORT    _fpumode                                    ;Art der FPU
  36.                         IMPORT    _StkSize                                    ;Grö₧e des Stacks
  37.                         IMPORT    _FreeAll                                    ;Funktion zur Speicherfreigabe
  38.  
  39. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  40. ;die BASEPAGE-Struktur
  41.  
  42.                         OFFSET    0
  43.  
  44. p_lowtpa:            ds.l    1                                                ;Adresse der TPA
  45. p_hitpa:                ds.l    1                                                ;erstes Byte nach der TPA
  46.  
  47. p_tbase:                ds.l    1                                                ;Adresse des TEXT-Segements
  48. p_tlen:                ds.l    1                                                ;Länge des TEXT-Segments
  49.  
  50. p_dbase:                ds.l    1                                                ;Adresse des DATA-Segments
  51. p_dlen:                ds.l    1                                                ;Länge des DATA-Segments
  52.  
  53. p_bbase:                ds.l    1                                                ;Adresse des BSS-Segments
  54. p_blen:                ds.l    1                                                ;Länge des BSS-Segments
  55.  
  56. p_dta:                ds.l    1                                                ;Zeiger auf die Default-DTA
  57.  
  58. p_parent:            ds.l    1                                                ;Zeiger auf die Basepage des aufrufenden Prozesses
  59.  
  60. p_resrvd0:            ds.l    1                                                ;reserviert
  61.  
  62. p_env:                ds.l    1                                                ;Zeiger auf die Environment-Strings
  63. p_resrvd1:            ds.b    80                                                ;reserviert
  64. p_cmdlin:            ds.b    128                                            ;Kommandozeile
  65.  
  66. sizeof_BASEPAGE:    
  67.  
  68. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  69.  
  70.                         TEXT
  71. __text:                                                                        ;Startadresse des TEXT-Segments
  72.  
  73.                         bra.b        start_me_up                                ;den Header überspringen
  74.  
  75.                         dc.l        _RedirTab                                ;Zeiger auf die Umlenkungstabelle
  76.                         dc.l        _StkSize                                    ;Grö₧e des Stacks
  77.  
  78.                         ALIGN    16
  79.  
  80.                         dc.b    'Pure C 2.0',0                                    ;Copyright-Hinweis
  81.  
  82.                         ALIGN    16
  83.  
  84. start_me_up:        move.l    a0,d0                                        ;Accessory?
  85.                         bne.b        is_acc
  86.  
  87.                         move.l    4(sp),a3                                    ;Zeiger auf die Basepage
  88.                         moveq        #1,d0                                        ;Applikation
  89.                         bra.b        is_app
  90.  
  91. is_acc:                movea.l    a0,a3                                        ;Zeiger auf die Basepage
  92.                         clr.w        d0                                            ;Accessory
  93.  
  94. is_app:                move.l    a3,_BasPag                                ;Zeiger auf die Basepage
  95.                         move.w    d0,_app                                    ;Flag Accessory/Applikation
  96.  
  97. ;Speicherbedarf ermitteln
  98.  
  99.                         move.l    p_tlen(a3),d1                            ;Länge des TEXT-Segments
  100.                         add.l        p_dlen(a3),d1                            ;Länge des DATA-Segments
  101.                         add.l        p_blen(a3),d1                            ;Länge des BSS-Segments
  102.                         add.l        #sizeof_BASEPAGE,d1                    ;Länge der Basepage
  103.                         move.l    d1,_PgmSize                                ;Programmlänge
  104.  
  105. ;Stack setzen
  106.                         move.l    d1,d2                                        ;Länge
  107.                         add.l        a3,d2                                        ;Zeiger auf die Basepage
  108.                         and.b        #$fc,d2                                    ;auf Langwortgrenze abrunden
  109.                         move.l    d2,sp                                        ;Adresse des Stacks
  110.  
  111.                         tst.w        d0                                            ;Accessory?
  112.                         beq        chk_fpu
  113.  
  114. ;Speicher freigeben
  115.  
  116.                         move.l    d1,-(sp)                                    ;Speicherbedarf
  117.                         move.l    a3,-(sp)                                    ;Adresse der Basepage
  118.                         clr.w        -(sp)                                        ;reserviert
  119.                         move.w    #74,-(sp)                                ;Mshrink
  120.                         trap        #1
  121.                         lea.l        12(sp),sp
  122.  
  123. ;Environment-Strings untersuchen
  124.  
  125.                         move.l    sp,d0
  126.                         sub.l        #_StkSize-4,d0
  127.                         and.b        #$fc,d0                                    ;auf Langwortgrenze ausrichten
  128.                         movea.l    d0,a1                                        ;envp[] beginnt bei der niedrigsten Stackadresse
  129.                         move.l    a1,a4                                        ;merken
  130.                         move.l    p_env(a3),a2                            ;Zeiger auf die Environment-Strings
  131.  
  132. scan_env_loop:        move.l    a2,(a1)+                                    ;Adresse in envp[] sichern
  133.                         movea.l    a2,a5                                        ;Adresse sichern
  134.                         tst.b        (a2)+                                        ;Ende der Environment-Strings?
  135.                         beq.b        scan_env_end
  136.                         
  137. scan_env_str:        tst.b        (a2)+                                        ;bis zum String-Ende
  138.                         bne.b        scan_env_str
  139.  
  140.                         movep.w    0(a5),d0
  141.                         swap        d0
  142.                         movep.w    1(a5),d0                                    ;'ARGV' ergibt in diesem Fall 'AGRV'
  143.                         cmpi.l    #'AGRV',d0                                ;'ARGV' ergibt in diesem Fall 'AGRV'
  144.                         bne.b        scan_env_loop
  145.                         cmpi.b    #'=',4(a5)                                ;'=' ?
  146.                         bne.b        scan_env_loop
  147.                         cmpi.b    #127,p_cmdlin(a3)                        ;Kommandozeile 127 Bytes lang?
  148.                         bne.b        scan_env_loop
  149.  
  150.                         clr.b        (a5)                                        ;Environment terminieren (ARGV entfernen)
  151.                         clr.l        -4(a1)                                    ;letzten envp[] löschen 
  152.                         movea.l    a1,a5                                        ;argv[] beginnt direkt hinter envp[]
  153.                         moveq        #0,d3                                        ;argc ist 0
  154.                         move.l    a2,(a1)+                                    ;Zeiger auf den ersten String
  155.  
  156. scan_ARGV:            tst.b        (a2)+                                        ;Ende des Strings suchen
  157.                         bne.b        scan_ARGV
  158.                         
  159.                         move.l    a2,(a1)+                                    ;Zeiger auf das nächste Argument
  160.                         addq.w    #1,d3                                        ;argc hochzählen
  161.                         tst.b        (a2)                                        ;letzter Environment-String?
  162.                         bne.b        scan_ARGV
  163.  
  164.                         bra        scan_end
  165.  
  166. scan_env_end:        clr.l        -4(a1)                                    ;letzten envp[] löschen
  167.  
  168. ;Kommandozeile untersuchen
  169.  
  170. scan_cmd_line:        lea        p_cmdlin(a3),a0                        ;Zeiger auf die Kommandozeile
  171.                         move.b    (a0),d1                                    ;Länge der Kommandozeile
  172.                         ext.w        d1
  173.                         movea.l    a1,a5                                        ;argv[] merken
  174.  
  175.                         move.l    a0,(a1)+                                    ;argv[0]: Zeiger auf der ersten String
  176.                         clr.b        (a0)+                                        ;Leerstring
  177.                         moveq        #1,d3                                        ;argc
  178.                         move.l    a0,(a1)+                                    ;argv[1]: Zeiger auf den zweiten String
  179.  
  180.                         moveq        #' ',d4                                    ;Leerzeichen
  181.                         moveq        #39,d5                                    ;Hochkomma
  182.                         moveq        #'"',d6                                    ;Anführungszeichen
  183.                         
  184.                         bra.b        scan_next
  185.                         
  186. scan_cmd_loop:        move.b    (a0)+,d0
  187.                         cmp.b        d4,d0                                        ;Leer- oder Trennzeichen?
  188.                         bhi.b        scan_squote
  189.     
  190.                         tst.b        -2(a0)                                    ;ist das vorhergehende Byte ein Nullbyte?
  191.                         bne.b        scan_eos                                    ;Ende eines Strings
  192.  
  193.                         addq.l    #1,-4(a1)                                ;Adresse des Strings korrigieren
  194.                         bra.b        scan_term                                ;dann das Leerzeichen ignorieren
  195.                         
  196. scan_squote:        cmp.b        d5,d0                                        ;Dateiname in ' Hochkommata?
  197.                         bne.b        scan_dquote
  198.  
  199.                         move.l    -4(a1),d0
  200.                         addq.l    #1,d0
  201.                         cmp.l        d0,a0                                        ;Hochkomma mitten im Text?
  202.                         bne.b        scan_dquote
  203.  
  204.                         addq.l    #1,-4(a1)                                ;Adresse des Strings korrigieren
  205.  
  206. scan_snglquote:    cmp.b        (a0)+,d5                                    ;' Hochkomma?
  207.                         dbeq        d1,scan_snglquote
  208.                         subq.w    #1,d1                                        ;Ende des Strings?
  209.                         bmi.b        scan_end
  210.                         beq.b        scan_eos                                    ;es folgen keine weiteren Zeichen
  211.  
  212.                         cmp.b        (a0),d5                                    ;zusätzliches Hochkomma?
  213.                         bne.b        scan_eos                                    ;sonst Ende des Dateinamens?
  214.                         
  215.                         movea.l    -(a1),a2                                    ;Zeiger auf den Anfang des Strings                        
  216.                         movea.l    a0,a3                                        ;Zeiger auf das zweite Hochkomma
  217.                         
  218. scan_move_args:    move.b    -2(a3),-(a3)                            ;String um ein Byte verschieben
  219.                         cmpa.l    a2,a3
  220.                         bhi.b        scan_move_args
  221.  
  222.                         addq.l    #1,a0                                        ;Zeiger hinter das zweite Hochkomma
  223.                         subq.w    #1,d1                                        ;Länge der Kommandozeile verringern
  224.                         addq.l    #1,(a1)+                                    ;Adresse des Strings korrigieren
  225.                         bra.b        scan_snglquote                            ;nach dem nächsten Hochkomma suchen
  226.  
  227. scan_dquote:        cmp.b        d6,d0                                        ;Dateiname in Anführungszeichen?
  228.                         bne.b        scan_next
  229.  
  230.                         addq.l    #1,-4(a1)                                ;Adresse des Strings korrigieren
  231.  
  232. scan_dblquote:        cmp.b        (a0)+,d6                                    ;Anführungszeichen?
  233.                         dbeq        d1,scan_dblquote
  234.                         subq.w    #1,d1                                        ;Ende des Strings?
  235.                         bmi.b        scan_end
  236.  
  237. scan_eos:            move.l    a0,(a1)+                                    ;Startadresse des neuen Strings                
  238.                         addq.w    #1,d3                                        ;argc erhöhen
  239. scan_term:            clr.b        -1(a0)                                    ;String terminieren
  240.                         
  241. scan_next:            subq.w    #1,d1
  242.                         bpl.b        scan_cmd_loop
  243.  
  244.                         tst.b        -1(a0)                                    ;ist letzte Byte ein Nullbyte?
  245.                         beq.b        scan_end                                    ;dann das Leerzeichen ignorieren
  246.  
  247.                         addq.w    #1,d3                                        ;argc erhöhen
  248.                         clr.b        (a0)                                        ;String terminieren
  249.                         addq.l    #4,a1
  250.  
  251. scan_end:            movea.l    a1,a6                                        ;untere Stackgrenze, stack limit
  252.                         clr.l        -(a1)                                        ;letzten argv[] löschen
  253.  
  254. chk_fpu:                clr.w        _fpumode                                    ;keine Atari FPU
  255.  
  256.                         lea        256(a6),a6                                ;256 Bytes für Aufrufe der Libraries addieren
  257.                         move.l    a6,_StkLim                                ;niedrigste Stackadresse
  258.  
  259.                         clr.w        errno                                        ;globale Fehlervariable (extlib) löschen
  260.                         clr.l        _AtExitVec                                ;Vektor für atexit() (stdlib-Funktion) löschen
  261.                         clr.l        _FilSysVec                                ;Vektor fürs Terminieren des Dateisystems löschen
  262.  
  263. ;main() anspringen
  264.  
  265.                         move.w    d3,d0                                        ;argc
  266.                         movea.l    a5,a0                                        ;argv
  267.                         movea.l    a4,a1                                        ;envp
  268.                         
  269.                         jsr        main                                        ;WORD    main( WORD argc, BYTE **argv, BYTE **envp );
  270.  
  271.  
  272. ;void    exit( WORD status );
  273.  
  274. exit:                    move.w    d0,-(sp)                                    ;Rückgabewert für Pterm() sichern
  275.  
  276.                         move.l    _AtExitVec,d0                            ;sind mit atexit() Funktionen eingetragen worden?
  277.                         beq.b        __exit
  278.             
  279.                         movea.l    d0,a0
  280.                         jsr        (a0)
  281.  
  282. __exit:                move.l    _FilSysVec,d0                            ;müssen noch Dateien geschlossen oder zurückgeschrieben werden?
  283.                         beq.b        exit_free
  284.             
  285.                         movea.l    d0,a0
  286.                         jsr        (a0)                                        ;Datei-Funktionen aufrufen
  287.  
  288. exit_free:            jsr        _FreeAll                                    ;Speicherblöcke freigeben
  289.  
  290.                         move.w    #76,-(sp)                                ;Pterm()
  291.                         trap        #1
  292.  
  293.  
  294. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  295.                         DATA
  296. __data:                                                                        ;Startadresse des DATA-Segments
  297.  
  298. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  299.                         BSS
  300. __bss:                                                                        ;Startadresse des BSS-Segments
  301.  
  302. _BasPag:                ds.l    1                                                ;Zeiger auf die Basepage
  303. _app:                    ds.w    1                                                ;Flag 0: Accessory / 1: Applikation
  304. _StkLim:                ds.l    1                                                ;untere Stackgrenze
  305. _PgmSize:            ds.l    1                                                ;Länge des Programms (der TPA)
  306. _RedirTab:            ds.l    6                                                ;Tabelle für Ausgabe-Umlenkung
  307.  
  308. errno:                ds.w    1                                                ;globale Fehlervariable (extlib)
  309. _AtExitVec:            ds.l    1                                                ;Vektor für atexit() (stdlib-Funktion)
  310. _FilSysVec:            ds.l    1                                                ;Vektor fürs Terminieren des Dateisystems
  311.  
  312.                         END
  313.