Thema: Ein paar Fragen...

[PMTheQuick]

Hi,

also ich hab jetzt nen funktionierenden C++-Kernel dank einem Tutorial... (PS: http://biehler-josef.de/ Echt gut, sogar nen Tutorial wie man nen Brainfuck-Interpreter schreibt... )... Nun, das geht ja alles... Hab auch nen Befehl um Texte auszugeben und Texte einzulesen (Solange einlesen bis Enter gedrückt wird...) Nun, jetzt habe ich nen paar Fragen:

1. Bei jeder Compilierung mit dem TurboC++-Compiler gibts ne Warnung aus:

Code: [Auswählen]

Turbo C  Version 2.01  Copyright (c) 1987, 1988 Borland International
kernel.cpp:
Warning kernel.cpp 16: Non-portable pointer assignment in function main

        Available memory 434810
2. Wenn man beim eingeben die RückTaste drückt, geht nur der Cursor zurück, der Text bleibt also... Beispiel:

Cursor ganz hinten: PMTheQuick_
Jetzt drück ich die Rücktaste nen paar mal: PMTheQuick
Es sollte aber so aussehen: PMTheQ_

3. Nach einigen Zeichen bleibt es auf einmal hängen und geht nicht mehr weiter... Ich will aber auch lange Strings ermitteln können! Was ist das Problem

4. Sollte ich noch irgendetwas verbessern daran?

Meine Proggis:
NASM
Turbo C++ Compiler 2.01
JLoc

So... Und nun noch mein Code:

start.asm

Code: [Auswählen]

[BITS 16]
EXTERN _main
start:

jmp 07c0h:main_entry

main_entry:
mov ax,cs
mov ds,ax
mov es,ax
cli
mov ss,ax
mov sp,9000h
sti


mov ah,02h
mov al,1
mov cl,2
mov ch,0
mov dl,0
mov dh,0
lea bx,[kernel]
int 13h


call _main
jmp $

;##Funktion zur Stringausgabe / Begrenzungszeichen: ASCII 0
GLOBAL _boot
_boot db "QuickOS 1.00",13,10,0
GLOBAL _enter
_enter db "ENTER",13,10,0
GLOBAL _newline
_newline db 13,10,0

GLOBAL _prnt
_prnt:
push bp
mov bp, sp
push ax
push si
mov ax, [bp + 4]
mov si,ax

prnt1:
mov al,[si]
cmp al,0
JE prnte
inc si
mov ah,0eh
int 10h
jmp prnt1

prnte:
pop si
pop ax
pop bp
ret

GLOBAL _strget
_strget:
       xor ah,ah ; Funktion 00h
       int 16h     ; Ausfüren
       cmp al, 0Dh ; Enter
       je short str_get_end ; Wenn Enter dann beenden
          mov [si], al   ; Speichere Zeichen
          inc SI
              mov ah, 0Eh   ; Ausgabe
              mov bx, 0007h
              int 10h
       jmp _strget          ; Neustart
       str_get_end:         ; String mit 0 Beenden
       xor al,al
       mov [si], al
       ret

times 510-($-$$) db 0 ;wichtig: Hier die Datei mit so vielen Bytes füllen, bis es genau 510 sind
dw 0aa55h ;Bootsignatur anhängen
kernel:
kernel.cpp

Code: [Auswählen]

extern prnt(char *var);
extern strget();
extern char boot;
extern char enter;
extern char newline;

int main()
{
char *str;
char key[2];
int i;
str=&boot;
prnt(str);

while(1) {
str=strget();
prnt(str);
prnt(&newline);
}

}
make.txt

Code: [Auswählen]

ALL:
start.obj
kernel.obj
DATA: 0F0000 MAIN.after MAIN.i_after
*,DGROUP
,,,FONT
FINAL: 0F0000 100000-FINAL.length FINAL.start-0F0000
*,kernel.obj
MAIN: 0F0000 0F0000 0
*
compile.bat

Code: [Auswählen]

@echo OFF
nasm -f obj start.asm -o start.obj
tcc -c kernel.cpp
jloc make.txt kernel.bin
PAUSE
So... Danke im vorraus,

Gruss
PMTheQuick

EDIT: Ich will es mit dem C++ Kernel übrigens UNBEDINGT so lassen, das Booten & Funktionen in ASM und Funktionen-Aufrufe in C++ sind.... 

[bitmaster]

Du fängst die Backspace Taste ja gar nicht ab. So müsste es aussehen:

Code: [Auswählen]

GLOBAL _strget
_strget:
       xor ah,ah ; Funktion 00h
       int 16h     ; Ausfüren
       cmp al, 0Dh ; Enter
       je short str_get_end ; Wenn Enter dann beenden
       cmp al, 08h ; Backspace
       jne .1
       dec si
       mov ax,0E08h
       int 10h ;ein Zeichen zurück
       mov ax,0E20h
       int 10h ;Zeichen löschen
       mov ax,0E08h
       int 10h ;ein Zeichen zurück
       jmp _strget
          .1:
          mov [si], al   ; Speichere Zeichen
          inc SI
              mov ah, 0Eh   ; Ausgabe
              mov bx, 0007h
              int 10h
       jmp _strget          ; Neustart, <- hier würde ich ein loop _strget setzten und über _strget in cx die Anzahl der max. einzulesenden Zeichen schreiben
       str_get_end:         ; String mit 0 Beenden
       xor al,al
       mov [si], al
       ret
Also stürtzt dein Programm wahrscheinlich ab, weil du unendlich viel eintippen kannst, die Zeichenkette aber nicht unendlich groß ist (bei C/C++ Code kann ich dir allerdings nicht helfen).

bitmaster

[PMTheQuick]

Ok Danke. Das geht nunmal. Zu Limit stimmt es kommt immer "CS.Limit" und anderes bei Bochs... Wie muss ich es proggen, das das Limit weg ist und ich unendliche Zeichenketten kann speichern?

Gruss
PMTheQuick

[bitmaster]

Ok Danke. Das geht nunmal. Zu Limit stimmt es kommt immer "CS.Limit" und anderes bei Bochs... Wie muss ich es proggen, das das Limit weg ist und ich unendliche Zeichenketten kann speichern?

Gruss
PMTheQuick

Also vorweg sei gesagt, das unendlich nicht möglich ist. Da du noch im RM bist, sogar sehr weit von unendlich entfernt. Also du kannst max. ca. 640 KByte Adressieren. Du könntest also den RAM in z.B. 4 KByte Blöcke aufteilen und in einer Bitmap schreiben, in welche 1 für belegt und 0 für frei steht. Aber willst du wirklich eine Eingabe von ca. 600.000 Byte ermöglichen und für den Rest deines OS keinen Platz mehr zur Verfügung haben? Nicht wirklich, oder? Also ich würde erstmal 255 Zeichen empfehlen + Enter (sprich 0) = 256. Dann schreibst du vor den Aufruf der Funktion 255 in cx und rufst die Funktion auf (statt jmp dann natürlich loop in der Funktion). Also in Assembler kannst du eine Zeichenkette z.B. so erstellen:

Zeichenkette: times 256 db 0

Und dann natürlich noch vor dem Aufruf "mov si,Zeichenkette" oder wenn du es in C/C++ machen willst, dann halt so. Aber eine unendliche Eingabe gibt es wirklich nicht. Ich denke mal in Word wird dafür keine feste Zeichenkette Verwendet sondern ein Zeiger auf eine virt. Adresse, und wenn Speicher benötigt wird, wird er reserviert. Solltest du also einen 1 GByte RAM PC haben wird spätestens bei ca. 1 Milliarden Eingaben Schluss (bzw. noch weniger da Speicher für Windows reserviert wird, für Word und für die Schriftformatierung). Ich weiß, ich habe jetzt viel erzählt und du wolltest es evt. gar nicht so genau wisse. Aber das nur, damit du dir vorstellen kannst, dass es kein unendlich gibt. Obwohl mir fällt gerade ein, Windows lagert dann ja auf die Festplatte aus (du hast also mehr als 1 GByte). ^^ Naja, ich höre jetzt am besten mal auf.

bitmaster

[PMTheQuick]

Danke Danke Danke  Habs jetzt geschafft mit nur folgenden Zeilen:

1x im Code

Code: [Auswählen]

_times db 2562x im Code

Code: [Auswählen]

mov cx,_times
Weiss jemand jetzt noch was der C++ Fehler bedeutet?

Gruss
PMTheQuick 

EDIT: Und jetzt versuch ich mal in den Protected Mode zu wechseln ...

[kevin]

Weiss jemand jetzt noch was der C++ Fehler bedeutet?

Das ist kein Fehler, sondern eine Warnung. Und die kommt vermutlich davon, daß du einem char* einen int zuweist, was eben keine allgemeingültige Annahme ist. Versuch es mal damit:

Code: [Auswählen]

extern char* strget();

[PMTheQuick]

DANKE!  Ihr seid einfach super  Es geht jetzt ohne Probleme, und ich baue gerade den ersten Befehl ein... Und dann versuche ich den Protected Mode... Also, noch nen schönen Tag,

Gruss
PMTheQuick 

[bitmaster]

Und dann versuche ich den Protected Mode

Ich weiß nicht ob du das schon weißt, aber die BIOS Interrupts kannst du dann nicht mehr nutzen. Also eine Ausgabe mittels "int 10h" und eine Eingabe mittels "int 16h" ist dann nicht mehr möglich (na ja nichts ganz, du kannst natürlich eigenen Code für diese Interrupts schreiben und sie dann verwenden ^^).

bitmaster