Programmiersprache in Blitz

Übersicht Sonstiges Projekte

Gehe zu Seite 1, 2  Weiter

Neue Antwort erstellen

Vertex

Betreff: Programmiersprache in Blitz

 BeitragFr, Okt 29, 2004 17:49
Antworten mit Zitat
Benutzer-Profile anzeigen
Hi!

Arbeite z. Z. an einer Programmiersprache genannt Adagio Mini. Es ist die einzigste Hochsprache für die Pokemon Mini Konsole. Sie soll die Spieleentwicklung mit der Konsole wesentlich erleichtern.

So sieht das kleine Ding aus:
user posted image

Beim erzeugen einer ausführbaren Datei werden folgende Schritte durchgeführt:

Analyse / Frontend

Lexikalische Analyse
Zerteilt den Quellcode in zusammenhängende Token und gibt dann ein Tokenstream zurück. Dies geschieht über ein Lexer.

Syntaktische Analyse
Prüft den Tokenstream auf syntaktische Korrektheit. Dies geschieht über ein Parser.

Semantische Analyse
Prüft auf statische Semantik(erkennt z. B. ob eine Variable nicht deklariert wurden ist).

Synthese / Backend

Optimierung
Hier wird der Code optimiert(z. B. nicht benutzte Variablen werden gelöscht).

Codegenerierung
Der syntaktisch sowie statisch semantisch korrekte und optimierte Tokenstream wird in eine Zielsprache(bei mir Machinensprache) übersetzt.

Bis jetzt läuft der Lexer schon ganz gut, habe bisher noch keine Fehler gehabt. Er wandelt schon automatisch Hexadezimal- und Binärwerte in Dezimalwerte um, erkennt einzelne Symbole, kann "<=", "=<", ">=", "=>", "<>" und "><" zusammenfassen und ignoriert Kommentare.

Token sind so aufgebaut:

    - tokenType: Typ des Tokens, z. B. TOK_MATHADD für Plus
    - tokenContent$: hier steht der Quellcode des Tokens drin z. B. "+"
    - tokenValue: bei Hexadezimal- und Binärwerten steht hier der Dezimalwert drin
    - tokenRow: Zeile im Quellcode des Token
    - tokenBeginCol: Spalte im Quellcode wo Token anfängt
    - tokenEndCol: Spalte im Quellcode wo Token aufhört


Über tokenRow, tokenBeginCol und tokenEndCol kann man dann später direkt die Stelle im Quellcode markieren, die Fehlerhaft ist.

Den Compiler mit oder ohne Optimierung(mal schauen) werden ich vieleicht für 10 Euro verkaufen. Lexer und Parser bleiben jedoch Open Source, damit man die Sprache auch auf andere Platformen portieren kann. Somit wäre auch eine Scriptsprache für Blitz einfach zu realisieren.

Hier ein Beispielcode test.am:
Code: [AUSKLAPPEN]
; Adagio Mini by Vertex

; arithmetische Operatoren:
;  +   Addition
;  -   Subtraktion
;  *   Multplikation
;  /   Division
;  ^   Potenzieren
;  mod Modulo

; logische Operatoren:
;  and UND
;  or  inklusives ODER
;  xor exklusives ODER
;  not NICHT

; Vergleichsoperatoren
;  == gleich
;  <> ungleich
;  <  kleiner als
;  <= kleiner gleich
;  >  größer als
;  => größer gleich

; bitweise Operatoren:
;  & UND
;  | inklusiv ODER
;  ! exklusiv ODER
;  ~ NICHT

; Präfixe für Zahlensysteme:
;  $ Hexadezimalsystem
;  % Binärsystem

; Typecasting:
;  int    val(string var) String  -> Integer
;  string str(int var)    Integer -> String

; Compilerdirektiven:
;  #include Einbindung von anderen verwirrst
;  #title   Titel des Programms max. 12 Zeichen lang
;  #code    Code des Programmes konst 4 Zeichen lang
;  :        Trennung zwischen 2 Anweisung auf einer Zeile

#title "Name"
#code  "xxxx"

; Kommentar

; Konstanten
const KEYPAD         = $2052
const LCD_CONTROL0   = $2080
const LCD_CONTROL1   = $2081
const ENABLE_MAP     = %0000010
const ENABLE_SPRITES = %00000100

; Struktur
struct sTest
{
   byte  abc
   short def
   int   ghi
}

; statsiche Variablen
static byte   a = 10
static short  b = 20
static int    c = 30
static string d = "test"
static sTest  e = 1, 2, 3

; dynamische Variablen
byte   f = 10
short  g = 20
int    h = 30
string i = "test"
sTest  j

j.abc = 4 : j.def = 5 : j.ghi = 6

; pointer
static byte  *pa = @a;
       short *pb = @b;

; Arrays
static byte k[3][3][3] = {{0, 1, 2}, {3, 4, 5}, {6, 7, 8}}
       byte l[10][10][10] ; dynamisches, 3 dimensionales Array

; zählgeprüfte Schleife
for a = 1 to 8 step 2
{
   ; ...
}


; anfangsgeprüfte Schleife
while(a <> 1)
{
   a = a-1
   ; ...
}

; endgeprüfte Schleife
repeat
{
   a = a+1
   ; ...
} until(a > 10)

; bedingungslose Schleife
repeat
{
   a = a+1
   if(a == 100) exit
} forever

; einzeilige Wenn-Anweisung
if(a == 10) ; ...

; mehrzeilige Wenn-Anweisung
if(a == 10)
{
   ; ...
}
elseif(b == 10)
{
   ; ...
}
else
{
   ; ...
}

; merhseitige Auswahl
select(a)
{
   case 1:
      ; ...

   case 2:
      ; ...

   case 3:
      ; ...

   else:
      ; ...
}

; Sprünge
Gosub label1
Goto  label2

; Sprungmarke
label1:
; ...
Return

; Sprungmarke
label2:
; ...

label3:
static #incbin "test.bin" ; einbinden einer binären Datei


Die Syntax soll eine Verbindung aus BASIC und C sein/werden.


Der Lexer:
Code: [AUSKLAPPEN]
; Type für alle Zeilen im Quellcode
Type sLine_t
   Field content$
   Field row
End Type

; Datei in Type auslesen
stream = ReadFile("test.am")
While Not Eof(stream)
   count = count+1
   sLine.sLine_t = New sLine_t
   sLine\content$ = ReadLine(stream)
   sLine\row = count
Wend
CloseFile stream

; Type für Token
Type sToken_t
   Field tokenType
   Field tokenContent$
   Field tokenValue
   Field tokenRow
   Field tokenBeginCol
   Field tokenEndCol
End Type

; Tokentyp-Konstanten
Const TOK_DIRECTIVE = $01 ; Kompilerdirektive
Const TOK_STRING    = $02 ; Zeichenkette
Const TOK_NUMBER    = $03 ; Zahlenwert
Const TOK_HEXADEC   = $04 ; Hexadezimalwert
Const TOK_BINARY    = $05 ; Binärwert
Const TOK_MATHEQL   = $06 ; =
Const TOK_MATHLOW   = $07 ; <
Const TOK_MATHLWEQL = $08 ; <=
Const TOK_MATHGREAT = $09 ; >
Const TOK_MATHGREQL = $0A ; =>
Const TOK_MATHADD   = $0B ; +
Const TOK_MATHSUB   = $0C ; -
Const TOK_MATHMUL   = $0D ; *
Const TOK_MATHDIV   = $0E ; /
Const TOK_MATHPOW   = $0F ; ^
Const TOK_MATHNTEQL = $10 ; <>
Const TOK_MATH2EQL  = $11 ; ==
Const TOK_MATHAND   = $12 ; &
Const TOK_MATHOR    = $13 ; |
Const TOK_MATHXOR   = $14 ; !
Const TOK_MATHNOT   = $15 ; ~
Const TOK_MATHBRKOP = $16 ; (
Const TOK_MATHBRKCL = $17 ; )
Const TOK_SYMCOLON  = $18 ; :
Const TOK_SYMCOMMA  = $19 ; ,
Const TOK_SYMQUOTE  = $1A ; "
Const TOK_SYMADDR   = $1B ; @
Const TOK_SYMARROP  = $1C ; [
Const TOK_SYMARRCL  = $1D ; ]
Const TOK_SYMBEGIN  = $1E ; {
Const TOK_SYMEND    = $1F ; }

; Globale Variablen für den Lexer
Global lineContent$, lineRow, lineLength
Global lexCharPos, lexChar$, lexBeginToken, lexEndToken, lexToken$, lexQuote
Global lexTokenCount, lexError$

; Alle Zeilen durchgehen
For sLine = Each sLine_t
   lineContent$ = sLine\content$
   lineRow      = sLine\row
   lineLength   = Len(lineContent$)
   lexCharPos   = 1
   
   ; Solange bis Zeilenende erreicht ist
   While lexCharPos<lineLength+1
      sToken.sToken_t = New sToken_t
      sToken\tokenRow = lineRow

      lexToken$ = ""
      lexChar$  = Mid$(lineContent$, lexCharPos, 1)   

      ; Leerraum
      If lexChar$ = " " Or lexChar$ = "   " Then
         Delete sToken
         sToken     = Null
         lexCharPos = lexCharPos+1
         
      ; Kompilerdirektive
      ElseIf lexChar$ = "#" Then
         getToken()
         sToken\tokenType     = TOK_DIRECTIVE
         sToken\tokenContent$ = lexToken$
         sToken\tokenBeginCol = lexBeginToken
         sToken\tokenEndCol   = lexEndToken
      
      ; Zeichenkette   
      ElseIf Asc(Lower$(lexChar$))>96 And Asc(Lower$(lexChar$))<122 Then
         getToken()
         sToken\tokenType     = TOK_STRING
         sToken\tokenContent$ = lexToken$
         sToken\tokenBeginCol = lexBeginToken
         sToken\tokenEndCol   = lexEndToken

      ; Zahl
      ElseIf Asc(Lower$(lexChar$))>47 And Asc(Lower$(lexChar$))<58 Then
         getToken()
         sToken\tokenType     = TOK_NUMBER
         sToken\tokenContent$ = lexToken$
         sToken\tokenBeginCol = lexBeginToken
         sToken\tokenEndCol   = lexEndToken

      ; Hexadezimalwert
      ElseIf lexChar$ = "$" Then
         getToken()
         sToken\tokenType     = TOK_HEXADEC
         sToken\tokenContent$ = lexToken$
         sToken\tokenBeginCol = lexBeginToken
         sToken\tokenEndCol   = lexEndToken

      ; Binärwert
      ElseIf lexChar$ = "%" Then
         getToken()
         sToken\tokenType     = TOK_BINARY
         sToken\tokenContent$ = lexToken$
         sToken\tokenBeginCol = lexBeginToken
         sToken\tokenEndCol   = lexEndToken
         
      ; Gleichheitszeichen
      ElseIf lexChar$ = "=" Then
         sToken\tokenType     = TOK_MATHEQL
         sToken\tokenContent$ = "="
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1
         
      ; kleiner als
      ElseIf lexChar$ = "<" Then
         sToken\tokenType     = TOK_MATHLOW
         sToken\tokenContent$ = "<"
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1
         
      ; größer als
      ElseIf lexChar$ = ">" Then
         sToken\tokenType     = TOK_MATHGREAT
         sToken\tokenContent$ = ">"
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1
         
      ; Plus
      ElseIf lexChar$ = "+" Then
         sToken\tokenType     = TOK_MATHADD
         sToken\tokenContent$ = "+"
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1

      ; Minus
      ElseIf lexChar$ = "-" Then
         sToken\tokenType     = TOK_MATHSUB
         sToken\tokenContent$ = "-"
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1

      ; Mal
      ElseIf lexChar$ = "*" Then
         sToken\tokenType     = TOK_MATHMUL
         sToken\tokenContent$ = "*"
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1

      ; Durch
      ElseIf lexChar$ = "/" Then
         sToken\tokenType     = TOK_MATHDIV
         sToken\tokenContent$ = "/"
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1

      ; Hoch
      ElseIf lexChar$ = "^" Then
         sToken\tokenType     = TOK_MATHPOW
         sToken\tokenContent$ = "^"
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1
         
      ; bitweise UND
      ElseIf lexChar$ = "&" Then
         sToken\tokenType     = TOK_MATHAND
         sToken\tokenContent$ = "&"
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1

      ; bitweise inklusiv ODER
      ElseIf lexChar$ = "|" Then
         sToken\tokenType     = TOK_MATHWOR
         sToken\tokenContent$ = "|"
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1

      ; bitweise exklusiv ODER
      ElseIf lexChar$ = "!" Then
         sToken\tokenType     = TOK_MATHXOR
         sToken\tokenContent$ = "!"
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1

      ; bitweise NICHT
      ElseIf lexChar$ = "~" Then
         sToken\tokenType     = TOK_MATHNOT
         sToken\tokenContent$ = "~"
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1

      ; runde Klammer auf
      ElseIf lexChar$ = "(" Then
         sToken\tokenType     = TOK_MATHBRKOP
         sToken\tokenContent$ = "("
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1

      ; runde Klammer zu
      ElseIf lexChar$ = ")" Then
         sToken\tokenType     = TOK_MATHBRKCL
         sToken\tokenContent$ = ")"
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1
         
      ; Doppelpunkt
      ElseIf lexChar$ = ":" Then
         sToken\tokenType     = TOK_SYMCOLON
         sToken\tokenContent$ = ":"
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1
         

      ; Komma
      ElseIf lexChar$ = "," Then
         sToken\tokenType     = TOK_SYMCOMMA
         sToken\tokenContent$ = ","
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1

      ; Anführungszeichen
      ElseIf lexChar$ = Chr$(34) Then
         lexQuote             = Not lexQuote
         sToken\tokenType     = TOK_SYMQUOTE
         sToken\tokenContent$ = Chr$(34)
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1
         
      ; Adressoperator
      ElseIf lexChar$ = "@" Then
         sToken\tokenType     = TOK_SYMADDR
         sToken\tokenContent$ = "@"
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1

      ; eckige Klammer auf
      ElseIf lexChar$ = "[" Then
         sToken\tokenType     = TOK_SYMARROP
         sToken\tokenContent$ = "["
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1

      ; eckige Klammer zu
      ElseIf lexChar$ = "]" Then
         sToken\tokenType     = TOK_SYMARRCL
         sToken\tokenContent$ = "]"
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1
      
      ; geschweifte Klammer auf
      ElseIf lexChar$ = "{" Then
         sToken\tokenType     = TOK_SYMBEGIN
         sToken\tokenContent$ = "{"
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1

      ; geschweifte Klammer zu
      ElseIf lexChar$ = "}" Then
         sToken\tokenType     = TOK_SYMEND
         sToken\tokenContent$ = "}"
         sToken\tokenBeginCol = lexCharPos
         sToken\tokenEndCol   = lexCharPos
         lexCharPos           = lexCharPos+1

      ; Kommentar
      ElseIf lexChar$ = ";" Then
         Delete sToken
         sToken     = Null
         lexCharPos = lineLength+1
      
      ; Fehler
      Else
         lexError$ = "Fehler in Zeile "+sToken\tokenRow+", Zeichen "+lexCharPos+" :"
         lexError$ = lexError$+Chr$(13)+Chr$(10)+" unerlaubtes Zeichen"
         RuntimeError lexError$
      EndIf
      
      If sToken <> Null Then
         lexTokenCount = lexTokenCount+1
      EndIf
   Wend
Next

; Auf hexadezimale und binäre Werte durchsuchen
For sToken = Each sToken_t
   ; Hexadezimalzahl in Dezimalzahl umwandeln
   If sToken\tokenType = TOK_HEXADEC Then
      sToken\tokenValue = hex2dec(sToken\tokenContent$)
      If sToken\tokenValue = -1 Then
         lexError$ = "Fehler in Zeile "+sToken\tokenRow+", Zeichen "+sToken\tokenBeginCol+" :"
         lexError$ = lexError$+Chr$(13)+Chr$(10)+" unerlaubtes Zeichen"
         RuntimeError lexError$
      EndIf
   EndIf

   ; Binärzahl in Dezimalzahl umwandeln
   If sToken\tokenType = TOK_BINARY Then
      sToken\tokenValue = bin2dec(sToken\tokenContent$)
      If sToken\tokenValue = -1 Then
         lexError$ = "Fehler in Zeile "+sToken\tokenRow+", Zeichen "+sToken\tokenBeginCol+" :"
         lexError$ = lexError$+Chr$(13)+Chr$(10)+" unerlaubtes Zeichen"
         RuntimeError lexError$
      EndIf
   EndIf
Next

; <=, =<, >=, =>, <>, ><, und == heraussuchen und ersetzen
For sToken = Each sToken_t
   nextToken.sToken_t = After sToken
   If nextToken <> Null Then
      If sToken\tokenType = TOK_MATHLOW And nextToken\tokenType = TOK_MATHEQL Then
         Delete nextToken
         sToken\tokenType     = TOK_MATHLWEQL
         sToken\tokenContent$ = "<="
         
      ElseIf sToken\tokenType = TOK_MATHEQL And nextToken\tokenType = TOK_MATHLOW Then
         Delete nextToken
         sToken\tokenType     = TOK_MATHLWEQL
         sToken\tokenContent$ = "=<"
         
      ElseIf sToken\tokenType = TOK_MATHGREAT And nextToken\tokenType = TOK_MATHEQL Then
         Delete nextToken
         sToken\tokenType     = TOK_MATHGREQL
         sToken\tokenContent$ = ">="
         
      ElseIf sToken\tokenType = TOK_MATHEQL And nextToken\tokenType = TOK_MATHGREAT Then
         Delete nextToken
         sToken\tokenType     = TOK_MATHLWEQL
         sToken\tokenContent$ = "=>"
         
      ElseIf sToken\tokenType = TOK_MATHLOW And nextToken\tokenType = TOK_MATHGREAT Then
         Delete nextToken
         sToken\tokenType     = TOK_MATHNEQL
         sToken\tokenContent$ = "<>"
         
      ElseIf sToken\tokenType = TOK_MATHGREAT And nextToken\tokenType = TOK_MATHLOW Then
         Delete nextToken
         sToken\tokenType     = TOK_MATHNEQL
         sToken\tokenContent$ = "><"
               
      ElseIf sToken\tokenType = TOK_MATHEQL And nextToken\tokenType = TOK_MATHEQL Then
         Delete nextToken
         sToken\tokenType     = TOK_MATH2EQL
         sToken\tokenContent$ = "=="
      EndIf
   EndIf
Next

For sToken = Each sToken_t
   DebugLog sToken\tokenContent$
Next


; Funktion zum filtern von Tokens
Function getToken()
   Local lexQuit = False

   lexToken$     = Mid$(lineContent$, lexCharPos, 1)
   lexBeginToken = lexCharPos
   lexCharPos    = lexCharPos+1
   
   ; Steht die Zeichenkette in Anführungszeichen?
   If lexQuote = True Then
      While lexCharPos<lineLength+1 And lexQuit = False
         lexChar$ = Mid$(lineContent$, lexCharPos, 1)
         If lexChar$ = Chr$(34) Then
            lexQuit = True
            lexEndToken = lexCharPos+1
         Else
            lexToken$ = lexToken$+lexChar$
            lexCharPos = lexCharPos+1
         EndIf
      Wend
   Else
      While lexCharPos<lineLength+1 And lexQuit = False
         lexChar$ = Mid$(lineContent$, lexCharPos, 1)
         ; Endzeichen erkennen
         Select lexChar$
            Case " "
                 lexQuit = True
               lexEndToken = lexCharPos
               lexCharPos = lexCharPos+1
            Case Chr$(9)
                 lexQuit = True
               lexEndToken = lexCharPos
               lexCharPos = lexCharPos+1
            Case "$"      : lexQuit = True : lexEndToken = lexCharPos
            Case "%"      : lexQuit = True : lexEndToken = lexCharPos
            Case "="      : lexQuit = True : lexEndToken = lexCharPos
            Case "<"      : lexQuit = True : lexEndToken = lexCharPos
            Case ">"      : lexQuit = True : lexEndToken = lexCharPos
            Case "+"      : lexQuit = True : lexEndToken = lexCharPos
            Case "-"      : lexQuit = True : lexEndToken = lexCharPos
            Case "*"      : lexQuit = True : lexEndToken = lexCharPos
            Case "/"      : lexQuit = True : lexEndToken = lexCharPos
            Case "^"      : lexQuit = True : lexEndToken = lexCharPos
            Case "&"      : lexQuit = True : lexEndToken = lexCharPos
            Case "|"      : lexQuit = True : lexEndToken = lexCharPos
            Case "!"      : lexQuit = True : lexEndToken = lexCharPos
            Case "~"      : lexQuit = True : lexEndToken = lexCharPos
            Case "("      : lexQuit = True : lexEndToken = lexCharPos
            Case ")"      : lexQuit = True : lexEndToken = lexCharPos
            Case ":"      : lexQuit = True : lexEndToken = lexCharPos
            Case ","      : lexQuit = True : lexEndToken = lexCharPos
            Case Chr$(34) : lexQuit = True : lexEndToken = lexCharPos
            Case "@"      : lexQuit = True : lexEndToken = lexCharPos
            Case "["      : lexQuit = True : lexEndToken = lexCharPos
            Case "]"      : lexQuit = True : lexEndToken = lexCharPos
            Case "{"      : lexQuit = True : lexEndToken = lexCharPos
            Case "}"      : lexQuit = True : lexEndToken = lexCharPos
         
            ; Bei Buchstaben oder Zahlen
            Default
               lexToken$ = lexToken$+lexChar$
               lexCharPos = lexCharPos+1
         End Select
      Wend
   EndIf
End Function

; Funktion zum umwandeln von Hexadezimalwerten in Dezimalwerte
Function hex2dec(hexvalue$)
   Local decvalue, length, i, tetrad
   
   length = Len(hexvalue$)
   For i = length To 2 Step -1
      tetrad = Asc(Upper$(Mid$(hexvalue$, i, 1)))
      
      ; 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
      If tetrad>47 And tetrad<58 Then
         tetrad   = tetrad-48
         decvalue = decvalue+tetrad*16^(length-i)
               
      ; A, B, C, D, E, F
      ElseIf tetrad>64 And tetrad<71
         tetrad   = tetrad-55
         decvalue = decvalue+tetrad*16^(length-i)
         
      ; Unerlaubtes Zeichen
      Else
         Return -1
      EndIf
   Next
   
   Return decvalue
End Function

; Funktion zum umwandeln von Binärwerten in Dezimalwerte
Function bin2dec(binvalue$)
   Local decvalue, length, i, bit
   
   length = Len(binvalue$)
   For i = length To 2 Step -1
      bit = Asc(Mid$(binvalue$, i, 1))
      ; 0, 1
      If bit = 48 Or bit = 49 Then
         bit = bit-48
         decvalue = decvalue+bit*2^(length-i)
         
      ; Unerlaubtes Zeichen
      Else
         Return -1
      EndIf
      
   Next
   
   Return decvalue
End Function


Der obrige Quellcode als Tokenstream:
Zitat:
#title
"
Name
"
#code
"
xxxx
"
const
KEYPAD
=
$2052
const
LCD_CONTROL0
=
$2080
const
LCD_CONTROL1
=
$2081
const
ENABLE_MAP
=
%0000010
const
ENABLE_SPRITES
=
%00000100
struct
sTest
{
byte
abc
short
def
int
ghi
}
static
byte
a
=
10
static
short
b
=
20
static
int
c
=
30
static
string
d
=
"
test
"
static
sTest
e
=
1
,
2
,
3
byte
f
=
10
short
g
=
20
int
h
=
30
string
i
=
"
test
"
sTest
j
j.abc
=
4
:
j.def
=
5
:
j.ghi
=
6
static
byte
*
pa
=
@
a;
short
*
pb
=
@
b;
static
byte
k
[
3
]
[
3
]
[
3
]
=
{
{
0
,
1
,
2
}
,
{
3
,
4
,
5
}
,
{
6
,
7
,
8
}
}
byte
l
[
10
]
[
10
]
[
10
]
for
a
=
1
to
8
step
2
{
}
while
(
a
<>
1
)
{
a
=
a
-
1
}
repeat
{
a
=
a
+
1
}
until
(
a
>
10
)
repeat
{
a
=
a
+
1
if
(
a
==
100
)
exit
}
forever
if
(
a
==
10
)
if
(
a
==
10
)
{
}
elseif
(
b
==
10
)
{
}
else
{
}
select
(
a
)
{
case
1
:
case
2
:
case
3
:
else
:
}
Gosub
label1
Goto
label2
label1
:
Return
label2
:
label3
:
static
#incbin
"
test.bin
"


mfg olli
vertex.dreamfall.at | GitHub
  • Zuletzt bearbeitet von Vertex am Fr, Okt 29, 2004 20:28, insgesamt einmal bearbeitet

Plasma(alt)

Betreff: @vertex

 BeitragFr, Okt 29, 2004 18:02
Antworten mit Zitat
Benutzer-Profile anzeigen
junge junge du machst ja ernst !
respekt!
DIV is dead !

Paul

 BeitragFr, Okt 29, 2004 18:55
Antworten mit Zitat
Benutzer-Profile anzeigen
Shocked

Paul
Stratocaster black - Roland MicroCube
User posted image
Girgl-World, wer's nich kennt, is' blöd!
 

Blitzkrieg Bop

 BeitragFr, Okt 29, 2004 19:10
Antworten mit Zitat
Benutzer-Profile anzeigen
Very Happy Du machst mir Angst Laughing
~ Hey Ho Let's Go ~
 

Kekskiller

 BeitragFr, Okt 29, 2004 19:36
Antworten mit Zitat
Benutzer-Profile anzeigen
Klasse Vertex, du bist wirklich ein echter Tausendsasser ^_^ .
Fand schon die Sache mit dem Pokemon Mini Tutorial klasse, aber das
hier ist noch viel toller. Nur werde ich wohl damit nicht viel anfangen
können, da ich 1. kaum Emus laufen bekomme und 2. erstmal die PC-
Programmierung meistern muss. Aber gebookmarked habe ich den
anderen Kram schon, jetzt muss Keks nur noch anfangen zu lernen ^^ .
Sehr klasse Sache, Meister.

joachim_neu

 BeitragFr, Okt 29, 2004 20:22
Antworten mit Zitat
Benutzer-Profile anzeigen
ich habe mal mit BB eine Sprache geschrieben (oder besser gesagt, ich bin noch halb dabei), mit der man ein Betriebssystem leichter programmieren kann. Ist so eine Mischung aus C, Pascal, Basic und ASM. das ganze wird in ASM umgewandelt und kann dann kompiliert werden. wers nicht glauben will/kann soll mal hier gucken: www.boscl.de.vu Ich weiß, jetzt kommen wieder welche, die mir sagen, das funktioniert net, usw. denen sage ich nur: ich benutze sie, und bei mir geht es, und ich habe schon mein OS!!! probiert es doch erstmal aus, bevor ihr kommentare abgebt, die nicht stimmen! ich wette, die, die meckern, haben sich noch nie wirklich mit OS-Coding abgegeben!!!
http://www.joachim-neu.de | http://www.orbitalpirates.de | http://www.middleageworld.de

Plasma(alt)

Betreff: ja ja

 BeitragFr, Okt 29, 2004 22:00
Antworten mit Zitat
Benutzer-Profile anzeigen
os coden wollen aber falsch verlinken (file not found ) Wink
DIV is dead !

joachim_neu

 BeitragFr, Okt 29, 2004 23:36
Antworten mit Zitat
Benutzer-Profile anzeigen
stimmt! muss ich nochmal hochladen! müsst bis morgen warten!
http://www.joachim-neu.de | http://www.orbitalpirates.de | http://www.middleageworld.de

Vertex

 BeitragSa, Okt 30, 2004 0:57
Antworten mit Zitat
Benutzer-Profile anzeigen
Hmm für OS Dev eine Sprache ich weiss nicht, normalerweise schreibt man sich Sachen wie Bootloader in Asm und den Rest in C. Bin mal gespannt wenn ich herunterladen kann. Mit 14 eine Sprache zum entwickeln von Betriebsystemen zu schreiben, ist jedoch viel Respekt wert.

Ich habe jetzt den Lexer abgekapselt, für spätere Includes, er erzeugt jetzt Tokendateien, und es ist ein Bug behoben wo früher
Code: [AUSKLAPPEN]
string blub = "}"
nicht ging.


Main.bb(später mal für IDE):
Code: [AUSKLAPPEN]
Include "Lexer.bb"

; Fehlernachricht-Konstanten
Const ERR_SELECTLINE   = $0
Const ERR_SELECTCUTOUT = $1
Const ERR_UNSELECT     = $2

; globale Fehlervariablen
Global errorType, errorMessage$, errorRow, errorBeginCol, errorEndCol

; Funktion zur Ausgabe eines Fehlers
Function displayError()
   Select errorType
      Case ERR_SELECTLINE
         Print "Fehler in Zeile "+errorRow+":"
         Print errorMessage$
         
      Case ERR_SELECTCUTOUT
         Print "Fehler in Zeile "+errorRow+", Spalte "+errorBeginCol+":"
         Print errorMessage$

      Case ERR_UNSELECT
         Print "Fehler:"
         Print errorMessage$
         
   End Select
End Function

If lexFile("test.am", "test.token") = False Then
   displayError()
Else
   Print "Fertig"
EndIf


und der neue Lexer:
Code: [AUSKLAPPEN]
; Type für alle Zeilen im Quellcode
Type lexLine_t
   Field content$
   Field row
End Type

; Type für Token
Type lexToken_t
   Field tokenType
   Field tokenContent$
   Field tokenValue
   Field tokenRow
   Field tokenBeginCol
   Field tokenEndCol
End Type

; Tokentyp-Konstanten
Const TOK_NEWLINE   = $00 ; Neue Zeile
Const TOK_DIRECTIVE = $01 ; Kompilerdirektive
Const TOK_STRING    = $02 ; Zeichenkette
Const TOK_NUMBER    = $03 ; Zahlenwert
Const TOK_HEXADEC   = $04 ; Hexadezimalwert
Const TOK_BINARY    = $05 ; Binärwert
Const TOK_MATHEQL   = $06 ; =
Const TOK_MATHLW    = $07 ; <
Const TOK_MATHLWEQL = $08 ; <=
Const TOK_MATHGR    = $09 ; >
Const TOK_MATHGREQL = $0A ; =>
Const TOK_MATHADD   = $0B ; +
Const TOK_MATHSUB   = $0C ; -
Const TOK_MATHMUL   = $0D ; *
Const TOK_MATHDIV   = $0E ; /
Const TOK_MATHPOW   = $0F ; ^
Const TOK_MATHNTEQL = $10 ; <>
Const TOK_MATH2EQL  = $11 ; ==
Const TOK_MATHAND   = $12 ; &
Const TOK_MATHOR    = $13 ; |
Const TOK_MATHXOR   = $14 ; !
Const TOK_MATHNOT   = $15 ; ~
Const TOK_MATHBRKOP = $16 ; (
Const TOK_MATHBRKCL = $17 ; )
Const TOK_SYMCOLON  = $18 ; :
Const TOK_SYMCOMMA  = $19 ; ,
Const TOK_SYMQUOTE  = $1A ; "
Const TOK_SYMADDR   = $1B ; @
Const TOK_SYMARROP  = $1C ; [
Const TOK_SYMARRCL  = $1D ; ]
Const TOK_SYMBEGIN  = $1E ; {
Const TOK_SYMEND    = $1F ; }

; gloable Lexervariablen
Global lexLineLength, lexCharPos, lexRow, lexBeginToken, lexEndToken
Global lexTmpToken$,  lexQuote

; Funktion zum lexen eines Quellcodes in eine Datei
Function lexFile(codeFile$, tokenFile$)
   Local fStream, lexLine.lexLine_t, fLineCount, lexToken.lexToken_t
   Local lexChar$, lexSymbol, nextToken.lexToken_t, lexCount
   
   
   ; Datei auslesen
   fStream = ReadFile(codeFile$)
   
   If fStream = 0 Then
      errorType     = ERR_UNSELECT
      errorMessage$ = "Datei konnte nicht geöffnet werden"
      Return False
   EndIf
   
   While Not Eof(fStream)
      fLineCount       = fLineCount+1
      lexLine          = New lexLine_t
      lexLine\content$ = ReadLine$(fStream)
      lexLine\row      = fLineCount
   Wend
   
   CloseFile fStream
   
   
   ; Code analysieren
   For lexLine = Each lexLine_t
      lexRow        = lexLine\row
      lexLineLength = Len(lexLine\content$)
      lexCharPos    = 1
      
      ; bis Zeilenende erreicht ist/gesetzt wurde
      While lexCharPos < lexLineLength+1
         lexTmpToken$      = ""
         lexToken          = New lexToken_t
         lexToken\tokenRow = lexRow
         lexChar           = Mid$(lexLine\content$, lexCharPos, 1)
         lexSymbol         = False
         
         
         ; Kommentar
         If lexChar$ = ";" Then
            Delete lexToken
            lexToken   = Null
            lexCharPos = lexLineLength+1
         
         ; Leerraum
         ElseIf lexChar$ = " " Or lexChar$ = "   " Then
            Delete lexToken
            lexToken   = Null
            lexCharPos = lexCharPos+1
         
         ; Kompilerdirektive
         ElseIf lexChar$ = "#" Then
            getToken(lexLine\content$)
            lexToken\tokenType = TOK_DIRECTIVE
         
         ; Zeichenkette
         ElseIf Asc(Lower$(lexChar$))>96 And Asc(Lower$(lexChar$))<122 Then
            getToken(lexLine\content$)
            lexToken\tokenType = TOK_STRING
         
         ; Zahl
         ElseIf Asc(Lower$(lexChar$))>47 And Asc(Lower$(lexChar$))<58 Then
            getToken(lexLine\content$)
            lexToken\tokenType = TOK_NUMBER
         
         ; Hexadezimalzahl   
         ElseIf lexChar$ = "$" Then
            getToken(lexLine\content$)
            lexToken\tokenType = TOK_HEXADEC
         
         ; Binärzahl   
         ElseIf lexChar$ = "%" Then
            getToken(lexLine\content$)
            lexToken\tokenType = TOK_BINARY

         ; Symbol
         ElseIf lexChar$ = "=" Then
            lexSymbol          = True
            lexToken\tokenType = TOK_MATHEQL

         ; Symbol   
         ElseIf lexChar$ = "<" Then
            lexSymbol          = True
            lexToken\tokenType = TOK_MATHLW

         ; Symbol   
         ElseIf lexChar$ = ">" Then
            lexSymbol          = True
            lexToken\tokenType = TOK_MATHGR
            
         ; Symbol   
         ElseIf lexChar$ = "+" Then
            lexSymbol          = True
            lexToken\tokenType = TOK_MATHADD
            
         ; Symbol
         ElseIf lexChar$ = "-" Then
            lexSymbol          = True
            lexToken\tokenType = TOK_MATHSUB
         
         ; Symbol
         ElseIf lexChar$ = "*" Then
            lexSymbol          = True
            lexToken\tokenType = TOK_MATHMUL

         ; Symbol
         ElseIf lexChar$ = "/" Then
            lexSymbol          = True
            lexToken\tokenType = TOK_MATHDIV

         ; Symbol
         ElseIf lexChar$ = "^" Then
            lexSymbol          = True
            lexToken\tokenType = TOK_MATHPOW

         ; Symbol
         ElseIf lexChar$ = "&" Then
            lexSymbol          = True
            lexToken\tokenType = TOK_MATHAND
   
         ; Symbol
         ElseIf lexChar$ = "|" Then
            lexSymbol          = True
            lexToken\tokenType = TOK_MATHOR

         ; Symbol
         ElseIf lexChar$ = "!" Then
            lexSymbol          = True
            lexToken\tokenType = TOK_MATHXOR

         ; Symbol
         ElseIf lexChar$ = "~" Then
            lexSymbol          = True
            lexToken\tokenType = TOK_MATHNOT
   
         ; Symbol
         ElseIf lexChar$ = "(" Then
            lexSymbol          = True
            lexToken\tokenType = TOK_MATHBRKOP

         ; Symbol
         ElseIf lexChar$ = ")" Then
            lexSymbol          = True
            lexToken\tokenType = TOK_MATHBRKCL

         ; Symbol
         ElseIf lexChar$ = ":" Then
            lexSymbol          = True
            lexToken\tokenType = TOK_SYMCOLON
         
         ; Symbol   
         ElseIf lexChar$ = "," Then
            lexSymbol          = True
            lexToken\tokenType = TOK_SYMCOMMA
         
         ; Symbol "   
         ElseIf lexChar$ = Chr$(34) Then
            lexQuote           = Not lexQuote
            lexSymbol          = True
            lexToken\tokenType = TOK_SYMQUOTE
         
         ; Symbol
         ElseIf lexChar$ = "@" Then
            lexSymbol          = True
            lexToken\tokenType = TOK_SYMADDR
         
         ; Symbol   
         ElseIf lexChar$ = "[" Then
            lexSymbol          = True
            lexToken\tokenType = TOK_SYMARROP
            
         ; Symbol
         ElseIf lexChar$ = "]" Then
            lexSymbol          = True
            lexToken\tokenType = TOK_SYMARRCL
         
         ; Symbol   
         ElseIf lexChar$ = "{" Then
            lexSymbol          = True
            lexToken\tokenType = TOK_SYMBEGIN
         
         ; Symbol   
         ElseIf lexChar$ = "}" Then
            lexSymbol          = True
            lexToken\tokenType = TOK_SYMEND
            
         ; Fehler
         Else
            errorType     = ERR_SELECTCUTOUT
            errorRow      = lexRow
            errorBeginCol = lexCharPos-1
            errorEndCol   = lexCharPos
            errorMessage$ = "unerlaubtes Zeichen"
            Return False
         EndIf
         
         If lexToken <> Null Then
            If lexSymbol = True Then
               ; Symbol
               If lexChar$ = Chr$(34) And lexQuote = True Then
                  ; Wenn es ein " ist, und eine Zeichenkette folgt
                  lexToken\tokenContent$ = lexChar$
                  lexToken\tokenBeginCol = lexCharPos
                  lexToken\tokenEndCol   = lexCharPos
                  lexCharPos             = lexCharPos+1
                  
                  ; Zeichenkette seperat als Token speichern
                  lexToken = New lexToken_t
                  getToken(lexLine\content$)
                  lexToken\tokenType     = TOK_STRING
                  lexToken\tokenContent$ = lexTmpToken$
                  lexToken\tokenRow      = lexRow
                  lexToken\tokenBeginCol = lexBeginToken
                  lexToken\tokenEndCol   = lexEndToken
                  
               Else
                  lexToken\tokenContent$ = lexChar$
                  lexToken\tokenBeginCol = lexCharPos
                  lexToken\tokenEndCol   = lexCharPos
                  lexCharPos             = lexCharPos+1
               EndIf
            Else
               ; normales Token
               If lexQuote = True Then
                  errorType     = ERR_SELECTCUTOUT
                  errorRow      = lexRow
                  errorBeginCol = lexBeginToken
                  errorEndCol   = lexLineLength
                  errorMessage$ = "fehlendes "+Chr$(34)
                  Return False
               EndIf
               
               lexToken\tokenContent$ = lexTmpToken$
               lexToken\tokenBeginCol = lexBeginToken
               lexToken\tokenEndCol   = lexEndToken
            EndIf
         EndIf
      Wend
      
      ; Token für eine neue Zeile
      lexToken = New lexToken_t
      lexToken\tokenType     = TOK_NEWLINE
      lexToken\tokenContent$ = "\n"
      lexToken\tokenRow      = lexRow
      
      ; Zeile aus dem Speicher nehmen
      Delete lexLine
   Next
   
   
   For lexToken = Each lexToken_t
      ; Textzahl in Wert umwandeln
      If lexToken\tokenType = TOK_NUMBER Then
         lexToken\tokenValue = str2dec(lexToken\tokenContent$)
         If lexToken\tokenValue = -1 Then
            errorType     = ERR_SELECTCUTOUT
            errorRow      = lexToken\tokenRow
            errorBeginCol = lexToken\tokenBeginCol-1
            errorEndCol   = lexToken\tokenEndCol
            errorMessage$ = "unerlaubtes Zeichen"
            Return False
         EndIf
      EndIf

      ; Hexadezimalwerte in Dezimalwerte umwandeln
      If lexToken\tokenType = TOK_HEXADEC Then
         lexToken\tokenValue = hex2dec(lexToken\tokenContent$)
         If lexToken\tokenValue = -1 Then
            errorType     = ERR_SELECTCUTOUT
            errorRow      = lexToken\tokenRow
            errorBeginCol = lexToken\tokenBeginCol-1
            errorEndCol   = lexToken\tokenEndCol
            errorMessage$ = "unerlaubtes Zeichen"
            Return False
         EndIf
      EndIf
      
      ; Binärwerte in Dezimalwerte umwandeln
      If lexToken\tokenType = TOK_BINARY Then
         lexToken\tokenValue = bin2dec(lexToken\tokenContent$)
         If lexToken\tokenValue = -1 Then
            errorType     = ERR_SELECTCUTOUT
            errorRow      = lexToken\tokenRow
            errorBeginCol = lexToken\tokenBeginCol-1
            errorEndCol   = lexToken\tokenEndCol
            errorMessage$ = "unerlaubtes Zeichen"
            Return False
         EndIf
      EndIf
   Next
   
   
   For lexToken = Each lexToken_t
      nextToken = After lexToken
      
      If nextToken <> Null Then
         If lexToken\tokenContent$ = "<" And nextToken\tokenContent$ = "=" Then
            Delete nextToken
            lexToken\tokenType     = TOK_MATHLWEQL
            lexToken\tokenContent$ = "<="
            
         ElseIf lexToken\tokenContent$ = "=" And nextToken\tokenContent$ = "<" Then
            Delete nextToken
            lexToken\tokenType     = TOK_MATHLWEQL
            lexToken\tokenContent$ = "=<"
            
         ElseIf lexToken\tokenContent$ = "=" And nextToken\tokenContent$ = ">" Then
            Delete nextToken
            lexToken\tokenType     = TOK_MATHGREQL
            lexToken\tokenContent$ = "=>"
            
         ElseIf lexToken\tokenContent$ = ">" And nextToken\tokenContent$ = "=" Then
            Delete nextToken
            lexToken\tokenType     = TOK_MATHLWEQL
            lexToken\tokenContent$ = ">="
            
         ElseIf lexToken\tokenContent$ = "<" And nextToken\tokenContent$ = ">" Then
            Delete nextToken
            lexToken\tokenType     = TOK_MATHNEQL
            lexToken\tokenContent$ = "<>"
            
         ElseIf lexToken\tokenContent$ = ">" And nextToken\tokenContent$ = "<" Then
            Delete nextToken
            lexToken\tokenType     = TOK_MATHNEQL
            lexToken\tokenContent$ = "><"
         
         ElseIf lexToken\tokenContent$ = "=" And nextToken\tokenContent$ = "=" Then
            Delete nextToken
            lexToken\tokenType     = TOK_MATH2EQL
            lexToken\tokenContent$ = "=="
         EndIf
      EndIf
   Next
   

   fStream = WriteFile(tokenFile$)
   
   If fStream = 0 Then
      errorType     = ERR_UNSELECTABLE
      errorMessage$ = "Datei konnte nicht geöffnet werden"
      Return False
   EndIf
   
   For lexToken = Each lexToken_t
      lexCount = lexCount+1
      WriteInt    fStream, lexToken\tokenType
      WriteString fStream, lexToken\tokenContent$
      WriteInt    fStream, lexToken\tokenValue
      WriteInt    fStream, lexToken\tokenRow
      WriteInt    fStream, lexToken\tokenBeginCol
      WriteInt    fStream, lexToken\tokenEndCol
      Delete lexToken
   Next
   
   SeekFile fStream, 0
   WriteInt fStream, lexCount
   CloseFile fStream
   
   
   Return True
End Function

; Funktion zum filtern von Tokens
Function getToken(content$)
   Local quit = False, char$
   
   lexTmpToken$  = Mid$(content$, lexCharPos, 1)
   lexBeginToken = lexCharPos
   lexCharPos    = lexCharPos+1
   
   If lexQuote = True Then
      ; Wenn Zeichenkette in Anführungszeichen steht
      While lexCharPos < lexLineLength+1 And quit = False
         char$ = Mid$(content$, lexCharPos, 1)
         
         If char$ = Chr$(34) Then
            quit        = True
            lexEndToken = lexCharPos+1
         Else
            lexTmpToken$ = lexTmpToken$+char$
            lexCharPos   = lexCharPos+1
         EndIf
      Wend
   Else
      ; Wenn nicht
      While lexCharPos < lexLineLength+1 And quit = False
         char$ = Mid$(content$, lexCharPos, 1)
         
         Select char$
            Case " "
                 quit        = True
               lexEndToken = lexCharPos
               lexCharPos  = lexCharPos+1
            
            Case Chr$(9)
                 quit        = True
               lexEndToken = lexCharPos
               lexCharPos  = lexCharPos+1
            
            Case ";"      : quit = True : lexEndToken = lexCharPos
            Case "$"      : quit = True : lexEndToken = lexCharPos
            Case "%"      : quit = True : lexEndToken = lexCharPos
            Case "="      : quit = True : lexEndToken = lexCharPos
            Case "<"      : quit = True : lexEndToken = lexCharPos
            Case ">"      : quit = True : lexEndToken = lexCharPos
            Case "+"      : quit = True : lexEndToken = lexCharPos
            Case "-"      : quit = True : lexEndToken = lexCharPos
            Case "*"      : quit = True : lexEndToken = lexCharPos
            Case "/"      : quit = True : lexEndToken = lexCharPos
            Case "^"      : quit = True : lexEndToken = lexCharPos
            Case "&"      : quit = True : lexEndToken = lexCharPos
            Case "|"      : quit = True : lexEndToken = lexCharPos
            Case "!"      : quit = True : lexEndToken = lexCharPos
            Case "~"      : quit = True : lexEndToken = lexCharPos
            Case "("      : quit = True : lexEndToken = lexCharPos
            Case ")"      : quit = True : lexEndToken = lexCharPos
            Case ":"      : quit = True : lexEndToken = lexCharPos
            Case ","      : quit = True : lexEndToken = lexCharPos
            Case Chr$(34) : quit = True : lexEndToken = lexCharPos
            Case "@"      : quit = True : lexEndToken = lexCharPos
            Case "["      : quit = True : lexEndToken = lexCharPos
            Case "]"      : quit = True : lexEndToken = lexCharPos
            Case "{"      : quit = True : lexEndToken = lexCharPos
            Case "}"      : quit = True : lexEndToken = lexCharPos
            
            Default
               lexTmpToken$ = lexTmpToken$+char$
               lexCharPos   = lexCharPos+1
               
         End Select
      Wend
   EndIf
End Function

; Funktion zum umwandeln von Textzahl in Dezimalwerte
Function str2dec(strvalue$)
   Local decvalue, length, i, digit
   
   length = Len(strvalue$)
   For i = length To 1 Step -1
      digit = Asc(Upper$(Mid$(strvalue$, i, 1)))
       
      ; 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
      If digit>47 And digit<58 Then
         digit    = digit-48
         decvalue = decvalue+digit*10^(length-i)
         
      ; Unerlaubtes Zeichen
      Else
         Return -1
      EndIf
   Next

   
   Return decvalue
End Function

; Funktion zum umwandeln von Hexadezimalwerten in Dezimalwerte
Function hex2dec(hexvalue$)
   Local decvalue, length, i, tetrad
   
   length = Len(hexvalue$)
   For i = length To 2 Step -1
      tetrad = Asc(Upper$(Mid$(hexvalue$, i, 1)))
       
      ; 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
      If tetrad>47 And tetrad<58 Then
         tetrad   = tetrad-48
         decvalue = decvalue+tetrad*16^(length-i)
               
      ; A, B, C, D, E, F
      ElseIf tetrad>64 And tetrad<71
         tetrad   = tetrad-55
         decvalue = decvalue+tetrad*16^(length-i)
         
      ; Unerlaubtes Zeichen
      Else
         Return -1
      EndIf
   Next

   
   Return decvalue
End Function

; Funktion zum umwandeln von Binärwerten in Dezimalwerte
Function bin2dec(binvalue$)
   Local decvalue, length, i, bit
   
   length = Len(binvalue$)
   For i = length To 2 Step -1
      bit = Asc(Mid$(binvalue$, i, 1))
      ; 0, 1
      If bit = 48 Or bit = 49 Then
         bit = bit-48
         decvalue = decvalue+bit*2^(length-i)
         
      ; Unerlaubtes Zeichen
      Else
         Return -1
      EndIf
       
   Next
   

   Return decvalue
End Function


mfg olli
vertex.dreamfall.at | GitHub
 

ChristianH

 BeitragSa, Okt 30, 2004 1:17
Antworten mit Zitat
Benutzer-Profile anzeigen
Hi Vertex,

sehr schön, aber könntest du das ganze bitte auch in Dateien zum Download anbieten?

MFG Chris.

Vertex

 BeitragSa, Okt 30, 2004 1:43
Antworten mit Zitat
Benutzer-Profile anzeigen
unter http://vertex.art-fx.org/AdagioMini.zip 5 KB ist alles zusammengefasst.
mfg olli
vertex.dreamfall.at | GitHub
 

konstantin

 BeitragSa, Okt 30, 2004 9:11
Antworten mit Zitat
Benutzer-Profile anzeigen
vertex übertrumpht wieder mal alle. respekt, echt hübsche sache Smile

@joachim_neu: das ist vertex' thread, wenn du so stolz auf deine "sprache" bist, dann mach einen neuen thread auf oder lass es -_-.

joachim_neu

 BeitragSa, Okt 30, 2004 9:39
Antworten mit Zitat
Benutzer-Profile anzeigen
Alu hat Folgendes geschrieben:

@joachim_neu: das ist vertex' thread, wenn du so stolz auf deine "sprache" bist, dann mach einen neuen thread auf oder lass es -_-.


ich weiß! wollte es nurmal erwähnen.

@vertex: nicht schlecht! sauber!

EDIT:

für alle, die es interessiert: BOSCL kann man wieder downloaden!
http://www.joachim-neu.de | http://www.orbitalpirates.de | http://www.middleageworld.de

Vertex

 BeitragSo, Okt 31, 2004 15:16
Antworten mit Zitat
Benutzer-Profile anzeigen
joachim_neu: Ich schau mir das mal an, wenn ich dann nach Hause komme.

http://vertex.art-fx.org/AdagioMini.zip
Neue Version. Kann nun Includes mit lexex, und speichert diese sepperat als .token.tmpx ab. Kleinigkeit am Error System hinzugefügt, und ein paar Bugs auskoriert. Ihr wisst nicht, was das jetzt für eine Arbei war, die Includedirektive rekursiv einzubinden.
mfg olli
vertex.dreamfall.at | GitHub
 

konstantin

 BeitragSo, Okt 31, 2004 15:29
Antworten mit Zitat
Benutzer-Profile anzeigen
[quote="joachim_neu"]Alu hat Folgendes geschrieben:
EDIT:

für alle, die es interessiert: BOSCL kann man wieder downloaden!


sry wenn ich hier jetzt arg off topic gehe, aber ich muss schon sagen das das zeug von joachim da ganz nett aussieht. funktioniert sogar unter linux mit wine prächtig. allerdings wäre eine dokumentation sinnvoll.

@vertex: schaut sehr nett aus.

Vertex

 BeitragSo, Okt 31, 2004 20:18
Antworten mit Zitat
Benutzer-Profile anzeigen
So ich denke mal der Lexer ist jetzt fertig. Er erkennt automatisch, ob nicht eine Datei doppelt eingebunden wurde(das kann selbst Blitz nicht) und es werden nun Unterstriche unterstützt:
Code: [AUSKLAPPEN]
static byte k[3][3][3] = {{0, 1, 2}, _
                          {3, 4, 5}, _
                          {6, 7, 8}}

Das ist z. B. jetzt möglich. Dabei wird erkannt, ob es sich nicht um z. B. eine Variable mit Unterstrich im Namen handelt, oder ob ein Zeilenende kommen muss.

Code: [AUSKLAPPEN]
static byte k[3][3][3] = {{0, 1, 2}, _
                          {3, 4, 5}, abc_def
                          {6, 7, 8}}

wäre somit ein lexikalisch korrekter Ausdruck, der Parser muss dann diesen syntaktischen Fehler erkennen.

Ein Proble gibt es noch. Der Lexer kann nicht zwischen relativen und direkten Pfaden untrescheiden.
Code: [AUSKLAPPEN]
#include "test.am"
#include "..\AdagioMini\test.am"

Würde keinen Fehler verursachen, obwohl es die selben Dateien sind. Ich bräuchte also irgendeine Funktion die mir den relativen Pfad in einen direkten Pfad umwandelt. Muss mal in der WinAPI rumblättern.

mfg olli
vertex.dreamfall.at | GitHub
 

Nemesis

 BeitragSo, Okt 31, 2004 21:01
Antworten mit Zitat
Benutzer-Profile anzeigen
hmm. du includest die files im lexer?
wäre das nicht eher ne aufgabe für nen precompiler?
 

Kekskiller

 BeitragSo, Okt 31, 2004 21:19
Antworten mit Zitat
Benutzer-Profile anzeigen
Wollte gerade sagen,da man die Datei ersmal
komplett zusammenfassen müsste.

Vertex

 BeitragMo, Nov 01, 2004 0:02
Antworten mit Zitat
Benutzer-Profile anzeigen
Ist die einzigste Direktive, die ich direkt vom Lexer auswerten lasse. Dann kann ich mich beim Parser in Level 2 vollständig auf Syntaxbäume konzentrieren. Jedoch fällt mir gerade auf, das ich im Haupttokenstream vergessen habe, die Include-Dateinamen abzuspeichern, würde sich blöd machen beim parsen Smile
mfg olli

Edit: Alles behoben, der Includename wird nun als seperater Token dem TOK_INCFILE abgespeichert.
vertex.dreamfall.at | GitHub

regaa

 BeitragMo, Nov 01, 2004 2:08
Antworten mit Zitat
Benutzer-Profile anzeigen
Mal ganz dumm dahergefragt:
Wird der Prozessor den diese Konsole verwendet in irgendeiner Weise weiterentwickelt bzw. hat der Prozessortyp an sich ne Zukunft, so das auch die OP-Codes von den nächsten Generationen dieser Prozessoren verstanden werden? Weil wenn du ne Hochsprache für nen Handheld entwickelst der sowieso von seiner Beschaffenheit nur die nächsten 3 jahre aktuell ist, wäre es doch ziemlich schade, ansonsten Respekt, aber das hab ich dir schonmal gesagt.
UltraMixer Professional 3 - Download
QB,HTML,CSS,JS,PHP,SQL,>>B2D,B3D,BP,BlitzMax,C,C++,Java,C#,VB6 , C#, VB.Net

Gehe zu Seite 1, 2  Weiter

Neue Antwort erstellen


Übersicht Sonstiges Projekte

Nach Oben

Gehe zu:

Powered by phpBB © 2001 - 2006, phpBB Group