xdpw

XD Pascal untuk Windows

Didedikasikan untuk ayah saya Mikhail Tereshkov, yang menanamkan dalam diri saya selera untuk teknik

Ringkasan

XD Pascal adalah kompiler hosting mandiri kecil yang dapat disematkan untuk dialek bahasa Pascal. Setiap komentar, saran, atau laporan bug dihargai. Jangan ragu untuk menghubungi penulis di GitHub atau melalui email [email protected]. Menikmati.

Fitur

• Metode dan antarmuka GO-style
• Native X86 Code Generation (32 bit Windows Executables)
• Dukungan untuk aplikasi konsol dan GUI
• Tidak diperlukan assembler eksternal atau linker
• Aritmatika titik mengambang menggunakan X87 FPU
• Integrasi dengan Perpustakaan Pengembangan Game Raylib
• Integrasi dengan IDE GEANY
• Sumber kompiler untuk Delphi 6/7, Pascal gratis dan XD Pascal itu sendiri (Delphi 2009+ Migrasi langsung)

Deskripsi terperinci

Penggunaan

Ketik prompt perintah:

 xdpw <file.pas>

File sumber harus ditentukan dengan ekstensi (.pas).

Bahasa

XD Pascal mirip dengan Delphi 6/7 dan Pascal gratis dengan perubahan berikut:

Peningkatan

• Kompilernya menjadi tuan rumah sendiri
• Kompilernya sangat kompak (~ 10000 baris) dan dapat dengan mudah tertanam ke dalam sistem yang lebih besar
• Metode dan antarmuka gaya go didukung

Perbedaan

• String adalah array karakter yang diakhiri nol (gaya C), tetapi diindeks dari 1 untuk kompatibilitas Pascal
• Jenis Text setara dengan file . Ini dapat digunakan untuk file teks dan tidak diketik
• Panggilan metode dan panggilan variabel prosedural memerlukan tanda kurung bahkan untuk daftar parameter kosong

Batasan

• Tidak ada pemrograman berorientasi objek klasik (C ++/Delphi)
• Tidak ada komponen visual
• Unit tidak dapat dikompilasi secara terpisah
• Hanya optimasi lubang intip
• Extended setara dengan Double
• Tidak ada fungsi High dan Low untuk array terbuka. Panjang array terbuka harus secara eksplisit diteruskan ke subrutin
• Label pernyataan tidak bisa numerik

Tata bahasa formal

 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 | "'" "'"} "'".

Penyusun

Kompiler didasarkan pada parser keturunan rekursif. Langsung membangun Windows PE yang dapat dieksekusi tanpa menggunakan assembler atau linker eksternal.

Arahan

• $APPTYPE - Setel jenis aplikasi. Contoh: {$APPTYPE GUI} , {$APPTYPE CONSOLE}
• $UNITPATH - Setel jalur pencarian unit tambahan. Contoh: {$UNITPATH ..units}

Optimisasi

Beberapa optimisasi lubang intip sederhana dilakukan:

• Eliminasi push/pop
• FPU PUSH/ELIMINASI POP
• Optimalisasi pemuatan variabel lokal
• Optimasi akses elemen array
• Rekam Optimalisasi Akses Bidang
• Optimasi penugasan
• Optimalisasi Perbandingan
• Optimalisasi Pengujian Kondisi

Prosedur dan fungsi yang diatur

Pengidentifikasi berikut diimplementasikan sebagai bagian dari kompiler. Nama mereka bukan kata -kata yang dipesan dan dapat didefinisikan ulang secara lokal oleh pengguna.

 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;

Perpustakaan Standar

Unit sistem

 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;

Unit Sysutils

 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;

Sampel

• factor.pas - demo faktorisasi integer
• lineq.pas - Solver Persamaan Linear. Menggunakan unit gauss.pas . Membutuhkan eq.txt , eqerr.txt , atau file data serupa
• life.pas - The Game of Life
• sort.pas - demo penyortiran array
• fft.pas - demo transformasi fourier cepat
• inserr.pas - Demo Estimasi Kesalahan Sistem Navigasi Inersia. Menggunakan unit kalman.pas
• list.pas - Demo Operasi Daftar Tertaut
• map.pas - Operasi Daftar Heterogen dan Demo Fungsi Peta. Menunjukkan metode dan antarmuka Pascal XD
• gui.pas - Demo Aplikasi GUI. Menggunakan unit windows.pas
• raytracer.pas - demo Raytracer. Menunjukkan metode dan antarmuka Pascal XD. Setara dengan raytracer.go

Masalah yang diketahui

Windows Defender Antivirus diketahui memberikan hasil positif palsu pada beberapa program yang dikompilasi dengan XD Pascal.