xdpw Download - xdpw Quellcode herunterladen

xdpw

Delphi-Quellcode

1.0.0

Herunterladen

XD Pascal für Fenster

Ich widmete meinen Vater Mikhail Tereshkov, der mir einen Vorgeschmack auf Ingenieurwesen vermittelt hat

Zusammenfassung

XD Pascal ist ein kleiner eingebettbarer Selbsthost-Compiler für einen Pascal-Sprachdialekt. Kommentare, Vorschläge oder Fehlerberichte werden geschätzt. Wenden Sie sich an den Autor unter Github oder per E-Mail an [email protected]. Genießen.

Merkmale

GO-Style-Methoden und Schnittstellen
Native X86 -Codegenerierung (32 Bit Windows Executables)
Unterstützung sowohl für Konsolen- als auch für GUI -Anwendungen
Kein externer Assembler oder Linker benötigt
Schwimmpunktarithmetik mit der X87-FPU
Integration in die Raylib Game Development Library
Integration mit Geany IDE
Compilerquelle für Delphi 6/7, Free Pascal und XD Pascal selbst (Delphi 2009+ Migration ist einfach)

Detaillierte Beschreibung

Verwendung

Geben Sie die Eingabeaufforderung ein:

 xdpw <file.pas>

Die Quelldatei sollte mit seiner Erweiterung (.pas) angegeben werden.

Sprache

XD Pascal ähnelt Delphi 6/7 und Free Pascal mit den folgenden Änderungen:

Verbesserungen

Der Compiler veranstaltet sich selbst
Der Compiler ist extrem kompakt (~ 10000 Linien) und kann leicht in größere Systeme eingebettet werden
GO-Style-Methoden und Schnittstellen werden unterstützt

Unterschiede

Saiten sind null-terminierte Arrays von Charakteren (C-Stil), aber aus 1 für Pascal-Kompatibilität indiziert
Der Text entspricht der file . Es kann sowohl für Text als auch für nicht typeded Dateien verwendet werden
Methodenaufrufe und prozedurale Variablenaufrufe erfordern Klammern auch für leere Parameterlisten

Einschränkungen

Keine klassische (C ++/Delphi-Stil) objektorientierte Programmierung
Keine visuellen Komponenten
Einheiten können nicht separat zusammengestellt werden
Nur Pephole -Optimierungen
Extended ist gleichbedeutend mit Double
Keine High und Low Funktionen für offene Arrays. Offene Arraylänge sollte ausdrücklich an eine Unterroutine übergeben werden
Anweisungsbezeichnungen können nicht numerisch sein

Formelle Grammatik

 ProgramOrUnit = [("program" | "unit") Ident ";"] 
                ["interface"] [UsesClause] Block "." .
                
UsesClause = "uses" Ident {"," Ident} ";" .                

Block = { Declarations } (CompoundStatement | "end") .

Declarations = DeclarationSection ["implementation" DeclarationSection] .

DeclarationSection = LabelDeclarations |
                     ConstDeclarations | 
                     TypeDeclarations |
                     VarDeclarations |
                     ProcFuncDeclarations .
                     
Initializer = ConstExpression |
              StringLiteral |
              "(" Initializer {"," Initializer} ")" |
              "(" Ident ":" Initializer {";" Ident ":" Initializer} ")" |
              SetConstructor .                     
               
LabelDeclarations = "label" Ident {"," Ident} ";"               
             
ConstDeclarations = (UntypedConstDeclaration | TypedConstDeclaration)
               {";" (UntypedConstDeclaration | TypedConstDeclaration)} .

UntypedConstDeclaration = "const" Ident "=" ConstExpression .
                                 
TypedConstDeclaration = "const" Ident ":" Type "=" Initializer .

TypeDeclarations = "type" Ident "=" Type ";" {Ident "=" Type ";"} .

VarDeclarations = "var" IdentList ":" Type ["=" Initializer] ";" 
                       {IdentList ":" Type ["=" Initializer] ";"} .

ProcFuncDeclarations = ("procedure" | "function") Ident 
                       [Receiver] [FormalParams] [":" TypeIdent] 
                       [CallModifier] ";" [(Directive | Block) ";"] .

Receiver = "for" Ident ":" TypeIdent .

CallModifier = "stdcall" | "cdecl" .

Directive = "forward" | "external" ConstExpression .         

ActualParams = "(" [ (Expression | Designator) |
                {"," (Expression | Designator)} ] ")" .

FormalParams = "(" FormalParamList {";" FormalParamList} ")" .
              
FormalParamList = ["const" | "var"] IdentList [":" ["array" "of"] TypeIdent] 
                                              ["=" ConstExpression] .             

IdentList = Ident {"," Ident} .

Type = "(" Ident {"," Ident} ")" |
       "^" TypeIdent |
       ["packed"] "array" "[" Type {"," Type} "]" "of" Type |
       ["packed"] "record" Fields "end" |
       ["packed"] "interface" FixedFields "end" |
       ["packed"] "set" "of" Type |
       ["packed"] "string" [ "[" ConstExpression "]" ] |
       ["packed"] "file" ["of" Type] |
       ConstExpression ".." ConstExpression |
       ("procedure" | "function") [FormalParams] [":" TypeIdent] [CallModifier] |
       Ident .
       
Fields = FixedFields 
           ["case" [Ident ":"] Type "of" 
               ConstExpression {"," ConstExpression} ":" "(" Fields ")"
          {";" ConstExpression {"," ConstExpression} ":" "(" Fields ")"}] [";"] .       
       
FixedFields = IdentList ":" Type {";" IdentList ":" Type} .       
       
TypeIdent = "string" | "file" | Ident .       

Designator = BasicDesignator {Selector} .

BasicDesignator = Ident |
                  Ident [ActualParams] |
                  Ident "(" Expression ")" .

Selector = "^" | 
           "[" Expression {"," Expression} "]" | 
           "." Ident | 
           "(" ActualParams ")".

Statement = [Label ":"] [ (Designator | Ident) ":=" Expression | 
                          (Designator | Ident) [ActualParams] {Selector} |
                          CompoundStatement |
                          IfStatement |
                          CaseStatement |
                          WhileStatement |
                          RepeatStatement | 
                          ForStatement |
                          GotoStatement |
                          WithStatement ] .
                          
Label = Ident .                          

StatementList = Statement {";" Statement} .

CompoundStatement = "begin" StatementList "end" .

IfStatement = "if" Expression "then" Statement ["else" Statement] .

CaseStatement = "case" Expression "of" CaseElement {";" CaseElement} 
                    [";"] ["else" StatementList] [";"] "end" .
                    
WhileStatement = "while" Expression "do" Statement .

RepeatStatement = "repeat" StatementList "until" Expression .

ForStatement = "for" Ident ":=" Expression ("to" | "downto") Expression "do" Statement.

GotoStatement = "goto" Label .

WithStatement = "with" Designator {"," Designator} "do" Statement .                    
 
CaseElement = CaseLabel {"," CaseLabel} ":" Statement .

CaseLabel = ConstExpression [".." ConstExpression] .

ConstExpression = Expression .

Expression = SimpleExpression [("="|"<>"|"<"|"<="|">"|">="|"in") SimpleExpression] .

SimpleExpression = ["+"|"-"] Term {("+"|"-"|"or"|"xor") Term}.

Term = Factor {("*"|"/"|"div"|"mod"|"shl"|"shr"|"and") Factor}.

Factor = (Designator | Ident) [ActualParams] {Selector} |
         Designator |
         "@" Designator | 
         Number | 
         CharLiteral |
         StringLiteral |  
         "(" Expression ")" | 
         "not" Factor |
         SetConstructor |
         "nil" |
         Ident "(" Expression ")" {Selector} .
         
SetConstructor = "[" [Expression [".." Expression] 
                     {"," Expression [".." Expression]}] "]" .         

Ident = (Letter | "_") {Letter | "_" | Digit}.

Number = "$" HexDigit {HexDigit} | 
         Digit {Digit} ["." {Digit}] ["e" ["+" | "-"] Digit {Digit}] .

CharLiteral = "'" (Character | "'" "'") "'" | 
              "#" Number .

StringLiteral = "'" {Character | "'" "'"} "'".

Compiler

Der Compiler basiert auf einem rekursiven Abstiegsparser. Es erstellt direkt eine Windows Pe -ausführbare Datei, ohne einen externen Assembler oder Linker zu verwenden.

Richtlinien

$APPTYPE - Anwendungstyp festlegen. Beispiele: {$APPTYPE GUI} , {$APPTYPE CONSOLE}
$UNITPATH - Legen Sie den zusätzlichen Einheits -Suchpfad fest. Beispiel: {$UNITPATH ..units}

Optimierungen

Einige einfache Optimierungen für Gieselloch werden durchgeführt:

Push/Pop -Eliminierung
FPU Push/Pop -Eliminierung
Lokale variable Ladeoptimierungen
Array -Element -Zugriffsoptimierungen
Aufzeichnungszugriffsoptimierungen aufnehmen
Zuweisungsoptimierungen
Vergleichsoptimierungen
Bedingungstestoptimierungen

Eingebrachte Verfahren und Funktionen

Die folgenden Kennungen werden als Teil des Compilers implementiert. Ihre Namen sind keine reservierten Wörter und können vom Benutzer lokal neu definiert werden.

 procedure Inc ( var x: Integer);
procedure Dec ( var x: Integer);
procedure Read ([ var F: file ;] var x1 { ; var xi } );
procedure Write ([ var F: file ;] x1[:w[:d]] { ; xi[:w[:d]] } );
procedure ReadLn ([ var F: file ;] var x1 { ; var xi } );
procedure WriteLn ([ var F: file ;] x1[:w[:d]] { ; xi[:w[:d]] } );
procedure New ( var P: Pointer);
procedure Dispose ( var P: Pointer);
procedure Break ;
procedure Continue ;
procedure Exit ;
procedure Halt [( const error: Integer)];
function SizeOf ( var x | T): Integer;
function Ord (x: T): Integer;
function Chr (x: Integer): Char;
function Low ( var x: T | T): T;
function High ( var x: T | T): T;
function Pred (x: T): T;
function Succ (x: T): T;
function Round (x: Real): Integer;
function Abs (x: T): T;
function Sqr (x: T): T;
function Sin (x: Real): Real;  
function Cos (x: Real): Real;  
function Arctan (x: Real): Real;  
function Exp (x: Real): Real;
function Ln (x: Real): Real;
function SqRt (x: Real): Real;

Standardbibliothek

Systemeinheit

 function Timer : Integer;
procedure GetMem ( var P: Pointer; Size: Integer);
procedure FreeMem ( var P: Pointer);
procedure Randomize ;
function Random : Real;
procedure Assign ( var F: file ; const Name : string);
procedure Rewrite ( var F: file [; BlockSize: Integer]);
procedure Reset ( var F: file [; BlockSize: Integer]);
procedure Close ( var F: file );
procedure BlockRead ( var F: file ; var Buf; Len: Integer; var LenRead: Integer);
procedure BlockWrite ( var F: file ; var Buf; Len: Integer);
procedure Seek ( var F: file ; Pos: Integer);
function FileSize ( var F: file ): Integer;
function FilePos ( var F: file ): Integer;
function EOF ( var F: file ): Boolean;
function IOResult : Integer;
function Length ( const s: string): Integer;
procedure Move ( var Source; var Dest; Count: Integer);
function Copy ( const S: string; Index, Count: Integer): string;
procedure FillChar ( var Data; Count: Integer; Value : Char);
function ParamCount : Integer;
function ParamStr (Index: Integer): string;
procedure Val ( const s: string; var Number: Real; var Code: Integer);
procedure Str (Number: Real; var s: string[; DecPlaces: Integer]);
procedure IVal ( const s: string; var Number: Integer; var Code: Integer);
procedure IStr (Number: Integer; var s: string);
function UpCase (ch: Char): Char;

SYSUTILS -Einheit

 function IntToStr (n: Integer): string;
function StrToInt ( const s: string): Integer;
function FloatToStr (x: Real): string;
function FloatToStrF (x: Real; Format: TFloatFormat; Precision, Digits: Integer): string;
function StrToFloat ( const s: string): Real;
function StrToPChar ( const s: string): PChar;
function PCharToStr (p: PChar): string;
function StrToPWideChar ( const s: string): PWideChar;
function PWideCharToStr (p: PWideChar): string;

Proben

factor.pas - Integer -Faktorisierungsdemo
lineq.pas - Lineargleichungslöser. Verwendet gauss.pas -Einheit. Erfordert eq.txt , eqerr.txt oder eine ähnliche Datendatei
life.pas - Das Spiel des Lebens
sort.pas - Array -Sortier -Demo
fft.pas - schnelle Fourier -Transformation Demo
inserr.pas - Inertial Navigation System Fehlerschätzung Demo. Verwendet kalman.pas Unit
list.pas - verknüpfte Listenoperationen Demo
map.pas - Heterogene List -Operationen und Kartenfunktion Demo. Demonstriert XD -Pascal -Methoden und Schnittstellen
gui.pas - GUI -Anwendung Demo. Verwendet windows.pas -Einheit
raytracer.pas - Raytracer Demo. Demonstriert XD -Pascal -Methoden und Schnittstellen. Äquivalent zu raytracer.go