Virtual Pascal et Delphi

**Roland Chastain** · 13/09/2012, 04h18

Bonjour !

Je m'intéresse depuis quelque temps à la programmation Win32 que j'ai essayée, avec VP d'un côté, avec Delphi de l'autre. Maintenant j'essaie de fondre les deux versions de mes programmes dans un seul fichier.

Je n'ai pas trouvé comment compiler un fichier PAS avec Delphi ; en revanche j'ai constaté que Virtual Pascal compile les fichiers DPR.

Je vous propose un programme qui affiche la date de Pâques pour l'année courante (à partir d'une table contenant les années 1900 à 2199). La compilation a été testée avec Virtual Pascal 2.1 et Delphi 6.

La seule partie du code que j'ai dédoublée est relative à l'année courante. Virtual Pascal ne reconnaissant pas, apparemment, le type SystemTime, j'ai bricolé ce que j'ai pu provisoirement.

Autre chose que je n'ai pas trouvée, l'équivalent Delphi du $IfDef VPascal ou du $IfDef FPC. J'ai vu comment on pouvait indiquer une version de Delphi mais pas l'environnement Delphi en général.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
// PAQUES.DPR
// Delphi 6, Free Pascal 2.6, Virtual Pascal 2.1
 
program Paques;
 
{$IFDEF VPASCAL}
  {&PMTYPE PM}
{$ELSE}
  {$APPTYPE GUI}
{$ENDIF}
 
uses
  Windows, Messages, SysUtils;
 
{$I Paques.inc}
{$I Couleurs.inc}
 
var
  t: tSystemTime;
  c: array[0..99] of char;
 
procedure MainPaint(hWindow: HWND; ps: TPaintStruct);
 
  function f(s: string): string;
  var
    temp: string;
  begin
    temp := Copy(s, 1, 1);
    if temp = 'M' then temp := 'mars' else temp := 'avril';
    temp := Copy(s, 2, 2) + ' ' + temp;
    f := temp;
  end;
 
var
  NewFont, OldFont: hFont;
  s: string;
  r: tRect;
 
begin
  NewFont := CreateFont(20,
                        0,0,0,
                        FW_LIGHT,
                        0,0,0,
                        DEFAULT_CHARSET,
                        0,0,0,0,
                        'Courier New');
 
  OldFont := SelectObject(ps.hdc, NewFont);
 
  SetTextColor(ps.hdc, White);
  SetBkMode(ps.hdc, Transparent);
 
  GetLocalTime(t);
 
  s := 'En '
     + IntToStr(t.wYear)
     + ', le dimanche de Pâques est le '
     + f(DateDePaques[t.wYear])
     + '.'
     ;
 
  StrPCopy(c, s);
  SetRect(r, 10, 10, 640-20, 300-20);
  DrawText(ps.hdc, c, StrLen(c), r, DT_LEFT);
  DeleteObject(SelectObject(ps.hdc, OldFont));
end;
 
procedure MainDestroy(hWindow: HWND);
begin
  PostQuitMessage(0);
end;
 
function MainWndProc(hWindow: HWND; Msg: UINT; WParam: WPARAM;
                     LParam: LPARAM): LRESULT; stdcall; export;
var
  ps: TPaintStruct;
begin
  MainWndProc := 0;
  case Msg of
    WM_PAINT: begin
                BeginPaint(hWindow, ps);
                MainPaint(hWindow, ps);
                EndPaint(hWindow, ps);
              end;
    WM_DESTROY: MainDestroy(hWindow);
  else begin
         MainWndProc := DefWindowProc(hWindow, Msg, wParam, lParam);
         Exit;
       end;
  end;
end;
 
var
  wc: TWndClass;
  hWindow: HWND;
  Msg: TMsg;
 
begin
  wc.lpszClassName := 'GenericAppClass';
  wc.lpfnWndProc := @MainWndProc;
  wc.style := CS_VREDRAW or CS_HREDRAW;
  wc.hInstance := hInstance;
  wc.hIcon := LoadIcon(0, IDI_APPLICATION);
  wc.hCursor := LoadCursor(0, IDC_ARROW);
  wc.hbrBackground := CreateSolidBrush(RoyalBlue);
  wc.lpszMenuName := nil;
  wc.cbClsExtra := 0;
  wc.cbWndExtra := 0;
  RegisterClass(wc);
  hWindow := CreateWindowEx(WS_EX_OVERLAPPEDWINDOW,
                            wc.lpszClassName,
                            'Date de Pâques',
                            WS_OVERLAPPEDWINDOW,
                            10,
                            10,
                            640+16,
                            300+38,
                            0,
                            0,
                            hInstance,
                            nil);
  ShowWindow(hWindow, CmdShow);
  UpDateWindow(hWindow);
  while GetMessage(Msg, 0, 0, 0) do
  begin
    TranslateMessage(Msg);
    DispatchMessage(Msg);
  end;
  Halt(Msg.wParam);
end.

**Alcatîz** · 13/09/2012, 20h54

Bonjour,

Le type TSystemTime est défini ainsi dans la RTL de Virtual Pascal :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
  PSystemTime = ^TSystemTime;
  TSystemTime = record
    wYear:         SmallWord;
    wMonth:        SmallWord;
    wDayOfWeek:    SmallWord;
    wDay:          SmallWord;
    wHour:         SmallWord;
    wMinute:       SmallWord;
    wSecond:       SmallWord;
    wMilliseconds: SmallWord;
  end;

Et j'ai trouvé cette remarque dans l'aide de Delphi 7 :

Use TSystemTime to represent SYSTEMTIME values when making Windows 32 API function calls.

Ceci pourrait peut-être t'aider ?

Pour une directive genre $IFDEF Delphi, je n'ai rien trouvé non plus.

**Roland Chastain** · 14/09/2012, 01h55

Envoyé par Alcatîz

Ceci pourrait peut-être t'aider ?

Cela résout parfaitement le problème. Merci pour l'indication.

J'ai écrit un petit programme en mode console pour essayer la chose, et effectivement ça fonctionne aussi avec Delphi et FreePascal sans qu'on ait à changer quoi que ce soit.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
{ Delphi 6 - Free Pascal 2.6 - Virtual Pascal 2.1 }
 
program HeureLocale; {.DPR }
 
{$IFDEF VPASCAL}
  {&PMTYPE VIO}
{$ELSE}
  {$APPTYPE CONSOLE}
{$ENDIF}
 
uses
  Windows, SysUtils;
 
var
  t: tSystemTime;
 
const
  NomDuJour: array[0..6] of string = ('dimanche',
                                      'lundi',
                                      'mardi',
                                      'mercredi',
                                      'jeudi',
                                      'vendredi',
                                      'samedi');
 
  NomDuMois: array[1..12] of string = ('janvier',
                                       'f'#130'vrier',
                                       'mars',
                                       'avril',
                                       'mai',
                                       'juin',
                                       'juillet',
                                       'ao'#150't',
                                       'septembre',
                                       'octobre',
                                       'novembre',
                                       'd'#130'cembre');
 
begin
  GetLocalTime(t);
 
  WriteLn(NomDuJour[ t.wDayOfWeek ]
          + ' ' +
          IntToStr( t.wDay )
          + ' ' +
          NomDuMois[ t.wMonth ]
          + ' ' +
          IntToStr( t.wYear )
          );
 
  ReadLn;
end.

**Roland Chastain** · 16/09/2012, 14h19

Bonjour !

Je continue mes recherches sur un style de programmation compatible avec les principaux compilateurs Pascal. Je trouve l'idée très intéressante et si je propose ici mes exemples, ce n'est pas que je prétende avoir quelque chose de neuf à proposer, mais c'est plutôt pour recueillir les connaissances des uns et des autres.

Voici un essai d'adaptation de l'exemple GENERIC.DPR de Delphi 1. (J'ai téléchargé Delphi 1 sur ce site.) J'ai refait le fichier "res", et remplacé les endroits du code qui ne passaient pas. Malheureusement, je n'ai pas réussi à compiler avec Free Pascal : pour certaines erreurs j'avais une solution mais pas pour toutes. Si vous y arrivez, faites-le moi savoir.

L'archive ci-jointe (9 Ko) contient l'exécutable, le code et les ressources.

**Roland Chastain** · 22/09/2012, 20h30

Bonsoir !

Voici un programme dans lequel j'ai voulu réunir quelques connaissances sur la ligne de commande.

Le programme s'utilise en faisant glisser au moyen de la souris un fichier texte sur l'exécutable. Une copie du fichier est produite, dans laquelle toutes les majuscules ont été remplacées... par des minuscules.

Le programme s'exécute sans ouvrir de console. Aucune unité n'a été déclarée, et le code se compile aussi bien avec TP7 (exécutable incroyablement petit par rapport aux autres !) qu'avec Delphi XE2. (Toutefois avec TP7 je n'ai pas trouvé comment empêcher la console de s'ouvrir.)

Pour éviter un avertissement de Delphi XE2 concernant la fonction Chr(), j'ai écrit une procédure de remplacement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
const
  alphabet_min: string = 'abcdefghijklmnopqrstuvwxyz';
  alphabet_maj: string = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';

Cela m'a rappelé de très justes observations qui m'avaient été faites sur ce sujet de la portabilité et de l'avantage d'employer des caractères entre guillemets plutôt que des codes.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
program Minuscules;
 
{$IfDef FPC}
{$AppType Gui}
{$EndIf}
 
{$IfDef Ver140}{$AppType Gui}{$EndIf}
{$IfDef Ver150}{$AppType Gui}{$EndIf}
{$IfDef Ver230}{$AppType Gui}{$EndIf}
 
{$IfDef VPascal}
{&PmType Pm}
{$Endif}
 
{$R Icone}
 
{$I Min.inc}
{$I Extract.inc}
 
var
  sPath: string; { 'C:\Atelier\Pascal\Minuscules\Sample.pas' }
  sDir : string; { 'C:\Atelier\Pascal\Minuscules\'           }
  sName: string; { 'Sample'                                  }
  sExt : string; { '.pas'                                    }
 
procedure FileProc(const nf1, nf2: string);
var
  t1, t2: text;
  s: string;
begin
  Assign(t1, nf1);
  Assign(t2, nf2);
  Reset(t1);
  Rewrite(t2);
  while not Eof(t1) do
  begin
    ReadLn(t1, s);
    Min(s);
    WriteLn(t2, s);
  end;
  Close(t1);
  Close(t2);
end;
 
begin
  if ParamCount > 0 then
  begin
    sPath := ParamStr(1);
    Extract(sPath, sDir, sName, sExt);
    FileProc(sDir + sName + sExt, sDir + sName);
  end;
end.

**Roland Chastain** · 12/02/2013, 19h15

Bonjour !

Je vous propose un nouvel exemple de code utilisant l'API win32. Comme dans l'exemple précédent, le programme affiche la date de Pâques pour l'année courante mais cette fois il va la lire directement dans le fichier texte que j'ai laissé tel quel.

J'ai refait aussi l'interface. A la place d'une fenêtre j'ai mis une simple boîte de message.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
program Easter;
 
{ Affiche la date de Pâques pour l'année courante, au moyen de la
  procédure MessageBox() de l'API win32. La date est tirée d'une table
  contenant les années 1900 à 2199.
  Compilation testée : Virtual Pascal 2.1, Delphi 6. }
 
{$IFDEF VPASCAL}
{$PMTYPE PM}
{$ELSE}
{$APPTYPE GUI}
{$ENDIF}
 
{$R delphi}
 
uses
  windows,{$IFDEF VPASCAL} strings,{$ELSE} sysutils,{$ENDIF} estr_tbl;
 
procedure ShowMessage(aMsg: string);
const
  ttl: pAnsiChar = '';
var
  msg: array[0..79] of char;
begin
  StrPCopy(msg, aMsg);
  MessageBox(0, msg, ttl, MB_OK);
end;
 
const
  s1 = 'En ';
  s2 = ', le dimanche de Pâques est le ';
  s3 = '.';
 
var
  t: tSystemTime;
  s: string;
 
begin
  GetLocalTime(t);
  Str(t.wYear, s);
  s := s1 + s + s2 + reader.EasterDate(t.wYear) + s3;
  ShowMessage(s);
end.

Envoyé par Roland Chastain

Je n'ai pas trouvé comment compiler un fichier PAS avec Delphi

Avec Delphi 6 on peut, en passant par le menu "Ouvrir un projet" et en choisissant l'option "projet Pascal".

**Roland Chastain** · 12/02/2013, 23h46

Pour ma procédure ShowMessage, je viens de trouver une variante qui me permet de ne pas utiliser l'unité Strings.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
procedure ShowMessage(msg: string);
const
  ttl: pAnsiChar = '';
begin
  msg := Concat(msg, #0);
  MessageBox(0, pAnsiChar(@msg[1]), ttl, MB_OK);
end;

J'ai trouvé la solution dans ce message.

**Paul TOTH** · 13/02/2013, 09h24

Envoyé par Roland Chastain

Pour ma procédure ShowMessage, je viens de trouver une variante qui me permet de ne pas utiliser l'unité Strings.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
procedure ShowMessage(msg: string);
const
  ttl: pAnsiChar = '';
begin
  msg := Concat(msg, #0);
  MessageBox(0, pAnsiChar(@msg[1]), ttl, MB_OK);
end;

J'ai trouvé la solution dans ce message.

alors Concat() existe, mais c'est tout simplement l'addition de strings

msg := msg + #0;

note que sous Delphi les strings sont des pointeurs qui possèdent déjà un #0 terminal (je ne sais pas si c'est le cas sous VP), tu peux donc tout simplement transtyper un string en PChar : PChar(msg).

et pour ttl, tu dois pouvoir passer "nil" à la place...oui la chaîne '' en dur qui sera traitée comme un PChar (par Delphi en tout cas)

**Roland Chastain** · 13/02/2013, 13h56

Merci Paul pour ces indications.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
program ShowMessage2;
 
{$IFDEF VPASCAL}
{&PMTYPE PM}
{$ELSE}
{$APPTYPE GUI}
{$ENDIF}
 
uses
  windows;
 
procedure ShowMessage(msg: string);
begin
  {$IFDEF VPASCAL}
  msg := msg + Chr(0);
  MessageBox(0, pAnsiChar(@msg[1]), '', MB_OK);
  {$ELSE}
  MessageBox(0, pAnsiChar(msg), '', MB_OK);
  {$ENDIF}
end;
 
var
  s: string;
 
begin
  s := 'Bonjour!';
  ShowMessage(s);
end.

**Roland Chastain** · 16/02/2013, 19h19

J'ai écrit un petit programme pour mémoriser les principales fonctions de l'unité Strings.

Ces fonctions (pardon si vous le savez déjà) sont disponibles dans Delphi. Il n'y a que le nom de l'unité qui soit différent. Au lieu de dédoubler la déclaration des unités, j'ai ajouté un alias dans les options de mon projet Delphi : Strings=SysUtils;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
{ D'après "La programmation Win32 en Virtual Pascal avec OWL" par Alcatîz. }
{ Compilateurs utilisés : VP 2.1, Delphi 6. }
 
{$IFDEF VPASCAL}{&PMTYPE VIO}{$ELSE}{$APPTYPE CONSOLE}{$ENDIF}
 
uses
  Strings;
 
procedure Traitement(p: pChar);
begin
end;
 
var
  chaine, chaine2: array[0..10] of char;
  pChaine: pChar;
  caractere: char;
  adresse: pChar;
  string1: string;
 
begin
{ Equivalences remarquables. }
  pChaine := chaine;
  pChaine := @chaine;
  pChaine := 'ab';
  caractere := chaine[6];
  caractere := pChaine[6];
  Traitement(chaine);
  Traitement(pChaine);
  Traitement('ab');
{ Fonctions de l'unité Strings/SysUtils. }
  StrCopy(chaine, 'abc');
  WriteLn(chaine);                               // abc
  chaine[2] := Chr(0);
  WriteLn(chaine);                               // ab
  WriteLn(StrLen(chaine));                       // 2
  StrCopy(chaine2, chaine);
  WriteLn(chaine2);                              // ab
  StrCopy(chaine2, chaine);
  WriteLn(chaine2);                              // ab
  WriteLn(StrComp(chaine,chaine2));              // 0
  StrCopy(chaine2, 'aB');
  WriteLn(chaine2);                              // aB
  WriteLn(chaine);                               // ab
  WriteLn(StrComp(chaine,chaine2));              // 32
  WriteLn(StrIComp(chaine,chaine2));             // 0
  WriteLn(StrPos(chaine,'b'));                   // b
  adresse := StrPos(chaine,'a');
  WriteLn(adresse-chaine);                       // 0
  StrCat(chaine,chaine2);
  WriteLn(chaine);                               // abaB
  StrLCat(chaine,'cccccccccc',SizeOf(chaine)-1);
  WriteLn(chaine);                               // abaBcccccc
  string1 := StrPas(chaine);
  WriteLn(string1);                              // abaBcccccc
  string1 := 'ab';
  StrPCopy(chaine, string1);
  WriteLn(chaine);                               // ab
  ReadLn;
end.

Virtual Pascal et Delphi

Contribuez Pascal

Vue hybride

Discussions similaires

Partager

Partager