Mode MacPas/fr

│ English (en) │ français (fr) │

  ----- A  F I N I R -----

Le mode MacPas essaie d'être compatible avec les dialects Pascal couramment utilisé sur Macintosh, ce sont THINK Pascal, Metrowerks Pascal et MPW Pascal. Pour des tuyaux sur le portage du traditionnel compilateur Mac Pascal vers Free Pascal, voir Porting from Mac Pascal

Différences comparées au Free PAscal standard

Ici sont litées les différences entre le dialecte Macintosh de Pascal et le dialecte standard de Free Pascal (qui est Turbo Pascal).

Implémentées (en 2.0.2)

• L'extension de fichier .p est supportée en mode MacPas.
• L'unité MacPas.pp est automatiquement incluse toutes les fois que le mode MacPas est utilisé. Il devrait contenir ce genre de choses qui est normalement intégrées dans le compilateur mac pascal.
• $CALLING MWPASCAL dit au compilateur d'utiliser les conventions d'appel prévalant en Pascal Metrowerks. Le seule différence par rapport au défaut est que, en MPASCAL, les paramètres enregistrement CONST sont toujours passés par référence.
• Le contrôle de type à la compilation des expressions (présentement ce n'est pas spécifique à MacPas).
• Les variables de compilation peuvent être données en ligne de commande, syntaxe -dMYCOMPVAR:=3 ou -dMYCOMPVAR2:=TRUE (sans espace). Les valeurs héxadécimale ne sont pas supportées, quoique.

Constructions de compilation

• Les variable de compilation son maintenant différentes des macros. Toutefois, elles sont reliées. Dans la documentation FPC, ce qui est écrit pour les macros est souvent aussi vrai pour les variables. La différence est la substitution de macro n'est vraiment faite qu'avec des vraies macros (lesquelles sont définies par $DEFINEC). Les variables de compilation sont définies par $SETC.
• Variables de compilation/macros exportables. Les variables de compilation et les macros définies dans la partie interface d'une unité sont exportées vers les autres unités MACPAS, de la même manière que les constructions ordinaires de Pascal. Voir plus bas sous Macros exportables.
• Les variables de compilation peuvent être affectées par un nombre héxadécimal, tel que $2345.
• $SETC <compvar>:= <expr> -- met une variable de comilation à une expression. ":=" aussi bien que "=" sont permis. Si non déjà défini, elle est définie.
• $DEFINEC <macro> <content> définit une macro dont le texte e substitution est <content>. -- comme sa contrepartie $DEFINE. Les macros paramétrées ne sont pas supportées.
• $IFC, $ELSEC, $ENDC -- comme leur contrepartie $IF, $ELSE, $END.
• La directive $ERRORC est similaire à $ERROR.
• UNDEFINED <compvar> -- dans les expressions de variables de compilation.
• Compile time function OPTION(X), which returns, whether the compiler option X is set. Works for one letter options only.
• TRUE, FALSE -- comme valeur dans les expressions de variable de compilation.
• Les directives de comilation $PUSH et $POP, qui sauve/restaure l'état de toutes les bascules locales du compilateur.
• L'option de compilation $J rend une variable externe.
• L'option de compilation $Z rend les variables et les procédures visible depuis l'extérieur.
• L'option de compilation $OV (+/-) actives le contrôle de dépassement (fpc 2.5.1).
• $ALIGN MAC68K, POWER, RESET (et aussi POWERPC comme équivalent de POWER dans fpc 2.5.1).
• La directive de compilation LibExport est reconnue mais ne fait rien pour le moment. Elle pourrait être implémentée dans le futur.
• Les directives de compilation Metrowerks $UNDEFC et $ELIFC.
• L'expression de compilation DEFINED <compvar>
• Support de certaines directives de compilation de Turbo/Delphi, aussi bien $DEFINE $UNDEF $IFDEF $IFNDEF $IF $ELSE $ENDIF $ELSEIF

Langage

• Object Pascal, style Mac. New, Dispose, Member sont supportés.
• Une procédure âssée comme paramètre peut être déclarée dans la liste de paramètres formel (types procédure anonyme).
• OTHERWISE dans la construction case (déjà supporté même dans Turbo Pascal)
• La procédure Leave fait la même chose que Break
• La procédure Cycle fait la même chose que Continue

• Procedure Exit(<procname>), which works like Exit, but accepts the procname as parameter. <procname> must be the name of the procedure, in which Exit is used in. Non-local exit (as allowed in some Mac pascal implementations) is not allowed. Exit with return value as a parameter is not allowed. You can use "return <exit_value>;" though, as in Metrowerks Pascal.

• Operators | and & (boolean operators, which are always evaluated as short-circuit boolean expressions)
• UNIV modifer for types in parameter lists is accepted, but does nothing (update, it has been implemented in fpc 2.5.1)
• C directive for procedure declarations. Same as CDECL.
• "..." in procedure declaration, denoting a C var arg style funtion.
• IMPLEMENTATION is not needed in units, if empty.
• External directive
• Procedures declared in the interface section, which do not have a counterpart in the implementation section, are considered external (we call them implicit externals). Their external name is prefixed with the C_prefix of the target. On Mac OS this is an empty string, whereas on Darwin/Mac OS X it is an underscore, so that it will properly link with Mac OS X' libraries (which are compiled with gcc).
• Ord function can take a pointer as argument
• Use of FourCharCode ( e. g. OSType, ResType) constants directly as parameters. This is done by an overloaded assignment operator defined in the file MacPas.pp
• Ord4
• All kinds of procedure variable stuff, compatible with Think Pascal and Metrowerks Pascal.

Implémenté (en 2.1.1)

• return <value>
• compile time expressions are now short circuit evaluated
• Bit-level packing of records and arrays

Prévu

• Nested procedure parameters (allowing a nested procedure to be actual parameter to another procedure) (update, it has been implemented in fpc 2.5.1)
• uses se propageant
• Open (pour les fichiers)
• HiWrd, LoWrd (depuis que supporté par les deux Think Pascal et Metrowerks)

Non supporté

Here is an (incomplete) list of mac pascal constructs which are not supported in mode mac at the moment, perhaps some of them will be supported in the future:

• StringOf
• HiWord, LoWord (same as HiWrd, LoWrd)
• Implicit forward declaration of objects (In an object declaration, one cannot refer to an object not yet declared)
• In object declarations, the method name cannot be preceeded with the class name (as in Think Pascal)
• Arithmetic compiler variable expressions
• Goto between different nesting levels (e.g., no goto from a nested procedure to a parent procedure)
• Exit between different nesting levels.
• Working implementation of UNIV keyword (update, it has been implemented in fpc 2.5.1)

Construction Free Pascal permises en mode MacPas

Free Pascal constructs which currently are allowed in Mode MacPas, but which actually are not in the Macintosh dialect. If conflicts arises, some of them might be disallowed in future. Traditionally some of this functionallity has been offered through Apples Universal Interfaces. The list is not complete.

• Assign(filename, file). In macintosh pascal the file name is given as an (optional) parameter directly to Reset(file, filename), Rewrite(file, filename) or Open(file, filename) (Open do open for both reading and writing).
• Bitwise operators "shr". "shl", "and", "or", "not" etc. In macintosh pascal the functions BSR, BSL, BAND, BOR, BNOT is used instead. (Boolean operators "and", "or", "not" is of course allowed in macintosh pascal)
• Assigned(pointer). An alternative is "pointer <> nil".
• Append, Blockread, BlockWrite, Erase (delete files from disk), Filesize, Flush, Rename, SeekEof, SeekEoln, SetTextBuf, Truncate.
• Addr, Compare*, *Seg, Fill*, Freemem, Getmem, High, Low, Move, MoveChar0, Ofs, Ptr (Note: In Apples Universal Interfaces, Ptr is a datatype describing a generic pointer) , ReAllocMem, Release.
• Hi, Lo. For convertion to 16 bit integers, in macinstosh pascal you can use HiWord, LoWord. Note that Hi/Lo work on 64, 32 and 16 bit integers and return the upper/lower 32/16/8 bits depending on the argument.
• Int
• BinStr, HexStr, OctStr, SetLength, SetString, StringOfChar, Val, Str
• ChDir, GetDir, MkDir, RmDir, Runerror
• Paramcount, Paramstr (since classic Mac OS does not have command line interface)
• Halt (param). Halt without parameter works in macintosh pascal.
• Assert
• Exclude, Include (for sets)
• LongJmp, SetJmp (exists in Metrowerks but not Think)
• Direct pointer arithmetics. In macintosh pascal, you must cast pointers to numbers before doing arithmetics.

Macros exportables

Only a mode MacPas unit will export macros and only a mode MacPas unit will import them. As before, MacPas and non-MacPas units can be used by each other but macros will then not be visible for use.

Macros will start to be exported right after the {$MODE MACPAS} directive. If no such directive is given, but -Mmacpas is given on the command line, macros will start to be exported right after the UNIT keyword.

To support this, for a unit, {$MODE MACPAS} if forbidden after the UNIT keyword. For other mode switches it is like before.

Caveat 1: If {$MODE MACPAS} is given before UNIT, the macros defined between this point and UNIT is exported, if the unit is compiled as part of a program or other unit, but is not exported if the unit is compiled from the commandline (at top level). To be deterministic, do not put macros before UNIT.

Caveat 2: Deviation from Think Pascal and Metrowerks Pascal: Macros from used units is not in effect until after the whole uses clause (incl semicolon) has been parsed.

Apple's Universal Interfaces

Starting with FPC 2.04, Apple's Universal interfaces are included with FPC. They are from the same source tree that is available at http://www.microbizz.nl/gpc.html, only a slightly more recent version (r165 as of 2.0.4).