Assemblerseite von Marcus Roming

Version 2.0 Aktualisiert: 30.03.04

Die Idee für diese Programm ist mir gekommen, als ich an diese Homepage gearbeitet hab. In HTML sollte man die Umlaute ja bekanntlich besser "Maskieren". Wenn man nun seine Homepage mit dem mächtigen Notepad-Tool erstellt darf man wegen jedem noch so dummen ä ein ä schreiben, das Gleiche gilt für ü,ö usw. Was liegt nun also näher, als ein Konvertierungsprogramm zu schreiben, das alle ü´s und ä´s usw. durch ü´s und ä´s usw. ersetzt. Das Programm wird über sogennante Kommandozeilenparameter gesteuert, d.h. der Pfad und der Dateiname wird nach dem eigentlichen Programmnamen eingegeben:
Konvert [LW:\][Pfad\]Dateiname.ext . Alles was in [] steht ist wieder optional. Das Programm kopiert dann die Datei Byte für Byte [ziemlich langsam, aber für Internetprojekte duchaus schnell genug, da diese meist (was den Text angeht)<< 1 MB sind] und ersetzt gegebenenfalls Zeichen durch Textstrings. Die so konvertierte Datei wird mit gleicher Erweiterung aber mit leicht verändertem Dateinamen abgespeichert und muss nun nur noch ggf. umbenannt werden. Die Kommandozeile wird dem Programm über das sogenannte PSP (Programm Segment Präfix) übergeben. Das PSP ist 256 Bytes gross (100h) und beinhaltet diverse Informationen, bei COM- Dateien befindet es sich immer direkt davor deshalb das ORG 100h ! Beim Programmstart zeigen bei einer COM- und EXE-Dateien ES und DS auf den Anfang des PSP´s oder genauer ES:0000 bzw. DS:0000. Die Kommandozeile, also der Textstring den der User nach dem eigentlichen Namen der EXE- bzw. COM-Datei eingibt befindet sich, inklusive des Leerzeichens zwischen dem Dateinamen und der Kommandozeile, im PSP ab der Adresse 81h, d.h. da man das Leerzeichen meist nicht will ab der Adresse 82h. Die Länge der Kommandozeile (auch wieder plus Leerzeichen) befindet sich in dem Byte bei 80h. Zuerst werden die Kommandozeilen-Daten in einer Variablen im Datensegment mit rep movsb abgespeichert. Diese Variable ist mit 0 (Ascii 00h) vorbelegt, so dass am Ende auf jeden Fall eine 0 steht.

Aufbau des Programms:

Die Kommandozeile wird in der Variable CommandTail gespeichert.
Die Eingabe wird rudimentär auf Fehler überprüft:
Wenn die Kommandozeile kleiner oder gleich 4 Zeichen ist wird zu NoTail gesprungen, die
Fehlermeldung Msg2 ausgegeben und das Programm beendet.
Der Textstring mit dem Label Message wird ausgegeben.
Die durch die Kommandozeile spezifizierte Datei wird im "nur lesen Modus" geöffnet.
Wenn dies nicht klappt, wird zum Label Ende gesprungen, die Fehlermeldung Msg3 ausgegeben
und das Programm beendet.
Das Handle der vorher geöffneten Datei wird in der Variable Datei1 gespeichert.
Es wird eine zweite Datei erstellt (da kommt der konvertierte Text rein). Der Name dieser
Datei wird aus dem Namen der ersten Datei erstellt, welcher allerdings vorher wie folgt
verändert wird: Das Zeichen an der 5. Stelle von hinten (das ist das Zeichen vor dem
Punkt) wird durch eine "0" ersetzt oder falls er da schon eine "0" hat duch ein "X". Dazu
nimmt man die Startadresse von CommandTail in bx und die Länge in di. Von di wird nun
6 abgezogen (5 Zeichen zurück + 1 Leerzeichen). Nun kann man das Zeichen über die indirekte
Registeradressierung (hier: [bx+di]) überprüfen und verändern.
Das Handle der neuen Datei wird in der Variable Datei2 gespeichert.
Aus der ersten Datei wird ein Byte gelesen.
In mehreren aufeinanderfolgenden Schritten wird nun das Byte überprüft und ggf. ersetzt.
Wenn es kein Umlaut ist, wird das Orginalbyte geschrieben.
-> Schritt 8 und 9 werden so lange wiederholt, bis die Datei vollständig konvertiert wurde.
(Siehe Code!)

--> Das Programm funktioniert nur bei Texten, die mit einem Windows (Ansi) Editor gemacht
wurden. Um es für DOS umzubauen, muss man nur die Ansi-Zahlen durch DOS Zeichen ersetzen !
Also z.B.: statt 252 schreibt man ´ü´ !

Und hier das Programm als EXE:

                     .MODEL SMALL
                     .STACK 100h
                     .DATA
CommandTail          DB   126 DUP (0)
Puffer1              DB   ?
Datei1               DW   ?
Datei2               DW   ?
KleinUE              DB   "&uuml;"
GrossUE              DB   "&Uuml;"
KleinOE              DB   "&ouml;"
GrossOE              DB   "&Ouml;"
KleinAE              DB   "&auml;"
GrossAE              DB   "&Auml;"
CountIt              DW   ?
Message              DB   "HTML Textkonverter WIN Ver 1.00 (c) 1998 by Marcus Roming$"
Msg2                 DB   "Kein oder falscher Parameter. Syntax: Winkonv [LW:\][Path\]FileName."
                     DB   "Ext $"                 ;<-- Fortsetzung
Msg3                 DB   10,13,"Fehler beim oeffnen. Syntax: Winkonv [LW:\][Path\]FileName.Ext$"
                     .CODE
                     mov  ax,@data                ;Beim Start zeigen es u. ds aufs PSP 
                     mov  es,ax                   ;ES zeigt nun aufs Datensegment 
                     mov  cl,byte ptr ds:[0080h]  ;So lang ist der Tail (Tail = Kommandozeile)
                     xor  ch,ch                   ;Die groesse des Tails ist nun in CX
                     push cx                      ;Fuer spaeter !!                   
                     cmp  cx,04h
                     jnle KeinFehler              ;Jump not less equal
                     jmp  NoTail
KeinFehler:          sub  cx,1                    ;1 weniger, weil ich den Abstand nicht will
                     mov  si,82h                  ;Quelle: DS:SI, DS zeigt (noch) aufs PSP
                     mov  di,OFFSET CommandTail   ;Ziel: ES:DI ES zeigt aufs Datensegment. 
                     rep  movsb                   ;Tail ins Datensegment
                     mov  ax,@data
                     mov  ds,ax
                     lea  dx,Message
                     mov  ah,09h
                     int  21h
                     mov  ax,3D00h                ;Datei oeffnen nur lesen
                     lea  dx,CommandTail
                     int  21h
                     jnc  Ziel1
                     jmp  Ende
Ziel1:               mov  [Datei1],ax             ;Handle 1 Sichern die [] ist optional
                     mov  bx,ax
                  
                     mov  ah,3Ch                  ;Datei erstellen
                     lea  dx,CommandTail
                     pop  di
                     sub  di,6                    ;6 abziehen
                     mov  bx,dx
                     cmp  byte ptr [bx+di],'0'    ;Ist das Zeichen eine 0 ?
                     je   GehtNicht
                     mov  byte ptr [bx+di],'0'    ;Name abaendern
                     jmp  OK
GehtNicht:           mov  byte ptr [bx+di],'X'    ;Alternativzeichen
Ok:                  int  21h
                     jnc  Ziel2
                     jmp  Fertig
Ziel2:               mov  [Datei2],ax             ;Handle 2 sichern
DoLoop:                                           ;Anfang der Schleife

                     mov  bx,[Datei1]             ;Datei 1 lesen
                     mov  ah,3Fh
                     mov  cx,01h                  ;1 Byte
                     lea  dx,Puffer1
                     int  21h
                     cmp  ax,00h                  ;Wenn AX=0 dann wurde kein Zeichen 
                     jne  Ziel3                   ;gelesen --> Ende! (ganz raus aus der Schleife)
                     jmp  Fertig
Ziel3:
                     cmp  byte ptr [Puffer1],252  ;Ansi-Zahl fuer ü 
                     jne  Weiter1                 ;Wenn nicht gleich auf den naechsten Pruefen
                     mov  ah,40h                  ;Wenn gleich die Daten aus KleiUE schreiben
                     mov  cx,06h
                     lea  dx,KleinUE
                     mov  bx,[Datei2]             
                     int  21h
                     jmp  Raus                    ;Es wurde ein ü gefunden, es kann also kein 
                                                  ;anderes mehr kommen--> Sprung ans Ende der 
                                                  ;Schleife (nicht ganz raus !!))
Weiter1:
                     cmp  byte ptr [Puffer1],220  ;Ansi-Zahl fuer Ü
                     jne  Weiter2
                     mov  ah,40h
                     mov  cx,06h
                     lea  dx,GrossUE
                     mov  bx,[Datei2]
                     int  21h
                     jmp  Raus
Weiter2:
                     cmp  byte ptr [Puffer1],228
                     jne  Weiter3
                     mov  ah,40h
                     mov  cx,06h
                     lea  dx,KleinAE
                     mov  bx,[Datei2]
                     int  21h
                     jmp  Raus
Weiter3:             

                     cmp  byte ptr [Puffer1],196
                     jne  Weiter4
                     mov  ah,40h
                     mov  cx,06h
                     lea  dx,GrossAE
                     mov  bx,[Datei2]
                     int  21h
                     jmp  Raus

Weiter4:
                     cmp  byte ptr [Puffer1],246
                     jne  Weiter5
                     mov  ah,40h
                     mov  cx,06h
                     lea  dx,KleinOE
                     mov  bx,[Datei2]
                     int  21h
                     jmp  Raus

Weiter5:
                     cmp  byte ptr [Puffer1],214
                     jne  Weiter6
                     mov  ah,40h
                     mov  cx,06h
                     lea  dx,GrossOE
                     mov  bx,[Datei2]
                     int  21h
                     jmp  Raus
                     
Weiter6:                   
                     mov  bx,[Datei2]
                     mov  ah,40h
                     mov  cx,01h
                     lea  dx,Puffer1
                     int  21h
Raus:               
                     jmp  DoLoop            ;Unbedingter Sprung nach DoLoop

Fertig:
                     mov  bx,[Datei1]
                     mov  ah,3Eh
                     int  21h

                     mov  bx,[Datei2]
                     mov  ah,3Eh
                     int  21h
                     jmp  GanzFertig
NoTail:
                     mov  ax,@data           ;Noch schnell nachholen
                     mov  ds,ax
                     lea  dx,Msg2
                     mov  ah,09h
                     int  21h                ;Fehlermeldung ausgeben
                     jmp  GanzFertig

Ende:
                     lea  dx,Msg3         
                     mov  ah,09h 
                     int  21h                ;Fehlermedung ausgeben
GanzFertig:
                     mov  ah,4Ch
                     int  21h

                     END

--> Syntax Beispiel: Winkonv new.txt 
    Beispiel 2     : Winkonv d:\temp\win.htm

Download:
Konverter für Windows (ASM): Winkonv ASM 
Konverter für Windows (EXE): Winkonv EXE

Nun werde ich die bisher verwendeten Interruptfunktionen noch einmal auflisten.

Zurück Weiter Inhalt