Routines prédéfinies
Cette page décrit toutes les procédures et fonctions prédéfinies ("Built-In") dans MPW Pascal, à l'exception des procédures et fonctions d'entrée/sortie décrites dans la page Fichiers et entrée/sortie. Les routines décrites dans l'annexe La bibliothèque SANE sont contenues dans les bibliothèques SANE, plutôt que d'être implémentées par le compilateur MPW Pascal ou la bibliothèque PasLib.
Le Macintosh dispose également de plus de 500 routines ROM disponibles, décrites dans Inside Macintosh. Ces routines facilitent la mise en oeuvre de l'interface utilisateur Macintosh et fournissent des services aux programmes.
Les procédures et fonctions standard sont prédéclarées. Les entités prédéfinies agissent comme si elles étaient déclarées dans un bloc entourant le programme, donc aucun conflit ne surgit d'une déclaration redéfinissant le même identificateur au sein du programme.
Remarque : les procédures et fonctions prédéfinies ne peuvent pas être utilisées comme paramètres réels pour les procédures et fonctions.
Procédures Exit et Halt
Deux procédures, Exit et Halt, vous permettent de terminer sans condition l'exécution du programme en cours.
La procédure Exit
La procédure Exit quitte immédiatement une procédure ou une fonction spécifiée ou le programme principal.
| Exit((id | PROGRAM}); |
Le paramètre id est l'identificateur d'une procédure ou d'une fonction, ou du programme principal, dans le cadre de l'appel Exit. Vous pouvez également utiliser le mot réservé PROGRAM pour identifier le programme en cours d'exécution.
L'appel Exit(id) provoque une sortie immédiate de id. Essentiellement, cela provoque un saut à la fin de id. La routine identifiée par id doit faire partie de la chaîne d'appel dynamique actuelle.
Exit(PROGRAM) met la variable MPW {status} à zéro.
La procédure Halt
| Halt; |
L'arrêt (sans paramètre) provoque une sortie immédiate du programme principal et définit la variable MPW {status} sur un.
Procédures d'allocation dynamique
Ces procédures sont utilisées pour gérer la mémoire de tas, une zone mémoire au sein de la zone de tas d'application. La procédure PLHEAPINIT vous permet de spécifier la taille de la mémoire de tas que vous souhaitez utiliser avec votre programme. Les procédures PLSetNonCont, PLSetMErrProc et PLSetHeapType vous permettent de contrôler les caractéristiques de la mémoire de tas. La procédure New est utilisée pour toute allocation d'espace tas par le programme. Les procédures Mark et Release sont utilisées ensemble pour libérer la totalité d'une partie marquée de l'espace de la mémoire de tas. La procédure Dispose est utilisée pour désallouer une seule variable identifiée. La fonction Heapresult est utilisée pour renvoyer l'état de l'opération d'allocation dynamique précédente.
Remarque : Les routines dont les noms commencent par PL se trouvent dans PasLibIntf.p.
Sauf lorsqu'il s'agit de types d'objets, la procédure NewHandle de la ROM Macintosh peut également être utilisée pour allouer de l'espace dans la mémoire de tas. NewHandle renvoie un descripteur de mémoire (doubles pointeurs indirects) plutôt que des pointeurs ordinaires. Le gestionnaire de mémoire peut ensuite conserver l'espace de mémoire pour vous, en le compactant si nécessaire et en allouant plus efficacement l'espace mémoire. Lors de la création de nouveaux objets, utilisez toujours la procédure New décrite ici ; il appelle NewHandle avec les paramètres appropriés. Les objets sont toujours déplaçables.
Sauf lors de la création d'objets, les procédures d'allocation décrites ici allouent des blocs non relocalisables dans la mémoire de tas. Le gestionnaire de mémoire ne peut pas déplacer ces blocs afin de libérer des blocs contigus plus grands pour une allocation ultérieure. La procédure New présente l'avantage de vous permettre d'allouer de l'espace de segmentation sans avoir à spécifier sa taille.
La procédure PLHeapInit
| Procedure PLHeapinit(sizeHeap:LonqInt;heapDelta:LonqInt;memerrProc:UNIV PascalPointer,aJlowNonConl:Boolean;forDispose:Boolean); |
La procédure PLHeapinit initialise la mémoire de tas, en utilisant les informations que vous fournissez pour déterminer les caractéristiques de mémoire de tas.
Le paramètre sizeHeap prend une valeur LongInt représentant la taille de la mémoire de tas. La routine d'initialisation de mémoire de tas intégrée de MPW Pascal alloue automatiquement 5 000 octets d'espace de mémoire de tas. À l'aide de PLHEAPINIT, vous pouvez spécifier une taille de segment autre que 5 000 octets.
Le paramètre heapDelta spécifie la taille en octets de l'espace supplémentaire à ajouter à la mémoire de tas si AllowNonCont est true. Les nouvelles allocations ne peuvent pas être adjacentes au tas existant.
Le paramètre memerrProc est un pointeur de procédure vous permettant de spécifier une routine à exécuter si une erreur de mémoire, telle qu'un débordement de la mémoire de tas, se produit.
Le paramètre allowNonCont est une valeur booléenne. S'il est défini sur true, un espace de la mémoire de tas supplémentaire égal au paramètre donné à heapDelta sera alloué lorsque l'espace de la mémoire de tas initial est épuisé. S'il est défini sur false, PLHeapinit ignorera heapDelta et aucun espace supplémentaire n'est alloué.
Le paramètre forDispose est également une valeur booléenne. Le paramètre forDispose doit être défini sur true si vous souhaitez utiliser la procédure Dispose. Sinon, une erreur se produit si vous tentez d'appeler Dispose. Le paramètre par défaut est false.
Le PLHeapinit doit être appelé par votre programme principal.
La procédure PLSetHeapCheck
| Procedure PLSetHeapCheck(DoIt:Boolean); |
Chaque fois que de l'espace de la mémoire de tas est alloué ou libéré, une vérification de cohérence est normalement effectuée sur la mémoire de tas. La procédure PLSetHeapCheck permet de suspendre ce processus de vérification en définissant le paramètre booléen DoIt sur false. Il reste suspendu jusqu'à ce qu'une procédure PLSetHeapCheck ultérieure soit effectuée avec DoIt à true.
PLSetHeapCheck doit être appelé par votre programme principal.
La procédure PLSetNonCont
| Procedure PLSetNonCont(allowNonCont:Boolean); |
La procédure PLSetNoncont vous permet de définir le drapeau d'espace de segment supplémentaire sans appeler PLHeapinit. Le paramètre AllowNonCont a une valeur booléenne. S'il est défini sur true, un espace de m?moire de tas supplémentaire sera alloué si la mémoire de tas actuel est plein et ne peut pas être étendu.
La procédure PLSetMErrProc
| Procedure PLSetMErrProc(memerrProc:univ PascalPointer); |
La procédure PLSetMErrProc permet de spécifier une procédure à exécuter en cas d'erreur mémoire. Le paramètre memerrProc pointe vers la procédure.
La procédure PLSetHeapType
| Procedure PLSetHeapType(forDispose:Boolean); |
La procédure PLSetHeapType vous permet de spécifier, sans accéder à PLHeapinit, si l'utilisation de la procédure Dispose doit être autorisée ou non dans votre programme. Si le booléen/ou Dispose est true, Dispose est autorisé.
Remarque : soyez prudent si vous modifiez le type de la mémoire de tas au milieu du programme. Les pointeurs alloués pour un type de la mémoire de tas ne sont pas compatibles avec les pointeurs alloués pour l'autre type de mémoire de tas.
La procédure New
| Procedure New(p[, t1,...,tn]); |
La procédure New alloue une nouvelle variable dynamique et définit une variable pointeur pour pointer vers elle.
Le paramètre p est une référence de variable faisant référence à une variable de n'importe quel type de pointeur. Il peut également s'agir d'une variable de référence de type d'objet, auquel cas New crée un nouvel objet de ce type. Le paramètre est un paramètre variable ; il peut s'agir d'une variable de pointeur ou d'une variable de référence de type objet de n'importe quel type.
Les paramètres optionnels t1,..., tn sont des constantes, utilisées uniquement lors de l'allocation d'une variable de type enregistrement avec variantes (voir ci-dessous).
Si p est une variable pointeur, New(p) alloue une nouvelle variable du type de base de p et fait pointer p vers elle. La variable peut être référencée comme P^.
Remarque : La procédure New n'est pas la même que la fonction NewPtr décrite dans Inside Macintosh. Lorsque vous appelez NewPtr, vous donnez une valeur de taille et le résultat n'a pas de type. Le résultat de New pointe toujours vers une variable identifiée d'un type spécifique.
Si p est une variable de référence de type objet, un espace est alloué pour un objet du type de la variable et un descripteur (un double pointeur indirect) est attribué en haut. Toutefois, vous n'utilisez pas de symboles de pointeur pour référencer les valeurs se trouvant dans les champs du nouvel objet. Vous référencez des champs d'objets comme s'il s'agissait de champs d'enregistrements ordinaires. Les appels successifs n'attribuent pas nécessairement des zones contiguës. En général, les objets peuvent bouger lorsque la mémoire de tas est compacté.
Si la mémoire de tas ne contient pas suffisamment d'espace libre pour allouer la nouvelle variable, p est défini sur NIL et un appel ultérieur à la fonction Heapresult renverra un résultat différent de zéro.
Si le type de base de p est un type d'enregistrement avec des variantes, New(p) alloue suffisamment d'espace pour autoriser la plus grande variante. Le format suivant :
| Procedure New(p, t1,...,tn); |
alloue une variable avec un espace pour les variantes spécifiées par les valeurs de balise t1,..., tn (au lieu de suffisamment d'espace pour les plus grandes variantes). Les valeurs des balises doivent être constantes ; ils doivent être répertoriés de manière contiguë et dans l'ordre de leur déclaration. Les valeurs de balise ne sont pas affectées aux champs de balise par cette procédure.
Les valeurs des balises de fin peuvent être omises. L'espace alloué permet les plus grandes variantes pour toutes les valeurs de balise n'étant pas spécifiées.
Avertissement : lorsqu'une variable d'enregistrement est allouée dynamiquement avec des valeurs de balise explicites, comme indiqué ci-dessus, vous ne devez effectuer aucune affectation à des champs de variantes n'étant pas sélectionnés par les valeurs de balise. Vous ne devez pas non plus attribuer un enregistrement entier à cet enregistrement. Si vous effectuez l'une de ces opérations, d'autres données peuvent être écrasées sans qu'aucune erreur ne soit détectée au moment de la compilation.
La procédure Dispose
| Procedure Dispose(P); |
La procédure Dispose libère une variable identifiée ou un objet.
Le paramètre p est une référence de variable faisant référence à une variable de n'importe quelle variable de référence de type pointeur ou de type objet. C'est un paramètre variable.
Dispose libère l'espace alloué à une variable ou un objet dynamique. C'est une erreur si pis n'est pas défini ou NIL. Après l'exécution de Dispose, la valeur de P n'est pas définie. Toutes les autres références à la variable ou à l'objet identifié ayant été atteints via p sont également indéfinies.
Remarque : vous devez utiliser la procédure PLHeapinit ou PLSetHeapType, décrite ci-dessus, pour définir allowDisposeflag sur true avant d'utiliser la procédure Dispose. De plus, le drapeau allowDispose devait être true au moment où p a été établi par un appel à New.
La fonction Heapresult
| Function Heapresult:Integer; |
La fonction Heapresult renvoie un entier représentant l'état de l'opération d'allocation dynamique la plus récente.
La fonction Heapresult renvoie un code entier reflétant l'état de l'appel le plus récent sur New, Mark, Release, Memavail ou PLHeapinit. Les codes sont donnés ci-dessous :
| Code | Description |
|---|---|
| 0 | Opération réussie |
| -1051 | Demande de taille illégale (plus grande que l'espace total de la mémoire de tas). |
| -1052 | Pointeur invalide |
| -1053 | Espace insuffisant dans la mémoire de tas. |
La procédure Mark
| Procedure Mark(p); |
La procédure Mark définit un pointeur vers une zone de la mémoire de tas.
Le paramètre p est une référence de variable faisant référence à une variable de n'importe quel type de pointeur. C'est un paramètre variable.
Mark(p) fait pointer le pointeur p vers le début de la zone libre actuelle dans la mémoire de tas. Le pointeur est également placé sur une liste en forme de pile pour une utilisation ultérieure avec la procédure Release (voir ci-dessous).
La procédure Release
| Procedure Release(p); |
La procédure Release libère toutes les variables dans une zone de mémoire de tas marquée.
Le paramètre p est une référence de variable faisant référence à une variable pointeur. Il doit s'agir d'un pointeur préalablement défini avec la procédure Mark.
Release(p) libère toutes les zones allouées depuis que le pointeur p a été passé à la procédure Mark.
La fonction MemAvail
| Function MemAvail:LongInt; |
La fonction MemAvail renvoie un entier long donnant la quantité maximale possible d'espace de segment disponible. Il n'a aucun paramètre.
Memavail renvoie le nombre maximum de mots (et non d'octets) d'espace de mémoire de tas pouvant actuellement être mis à la disposition de la procédure New (en supposant que la taille du tas Pascal peut croître). Notez que le résultat de MemAvail peut changer au fil du temps même si le programme n'alloue aucun espace de mémoire, en raison d'autres activités de gestion de la mémoire.
Fonctions de transfert
Les fonctions de transfert transfèrent une valeur d'une expression d'un type à une expression d'un autre type.
La fonction Trunc
| Function Trunc(X:Extended):LongInt; |
La fonction Trunc convertit une valeur Extended en valeur LongInt. Son paramètre x est une expression avec une valeur de type Extended. Trunc(X) renvoie un résultat entier long étant la valeur de x arrondie au plus grand nombre entier entre zéro et x (inclus).
La fonction Round
| Function Round(X:Extended):LongInt; |
La fonction Round convertit une valeur Extended en valeur LongInt. Son paramètre x est une expression avec une valeur de type Extended. Si x est exactement à mi-chemin entre deux nombres entiers, le résultat est le nombre entier de plus grande grandeur absolue.
La fonction Ord4
| Function Ord4(X):LongInt; |
La fonction Ord4 convertit une valeur de type scalaire ou de type pointeur en type LongInt. Son paramètre x est une expression avec une valeur de type scalaire ou de type pointeur. Ord4(x) renvoie la valeur de x, convertie en type LongInt.
Si x est de type LongInt, le résultat est le même que x.
Si x est de type pointeur, le résultat est l'adresse physique correspondante de type LongInt.
Si x est de type Integer, le résultat est la même valeur numérique représentée par x mais de type LongInt. Ceci est utile dans les expressions arithmétiques. Par exemple, considérons l'expression :
- abc*xyz
où abc et xyz sont de type Integer. Lors d'une multiplication des deux Integer abc par xyz, on obtient un type Integer de 16 bits. Si le produit mathématique de abc et xyz ne peut pas être représenté sur 16 bits, le résultat est les 16 bits de poids faible. Pour éviter cela, l'expression peut s'écrire :
- Ord4(abc)*xyz
Cette expression entraîne l'utilisation d'une arithmétique de 32 bits et le résultat est une valeur LongInt de 32 bits.
Si x est d'un type scalaire autre qu'un entier ou un LongInt, la valeur numérique du résultat est le nombre ordinal déterminé en cartographiant les valeurs du type sur des entiers consécutifs non négatifs commençant à zéro.
La fonction Pointer
| Function Pointer(X:Integer):pointeur; |
| Function Pointer(X:LongInt):pointeur; |
La fonction Pointer convertit une valeur Integer ou un LongInt en type pointeur. Son paramètre x est une expression avec une valeur de type Integer.Pointer(X) ou LongInt.Pointer(X) renvoie une valeur de pointeur correspondant à l'adresse physique x. Ce pointeur est du même type que NIL et est compatible avec tout type de pointeur. La valeur de Pointer(0) est NIL.
Fonctions arithmétiques
Les fonctions arithmétiques MPW Pascal prenant des paramètres de types réels résident dans la ROM Macintosh et/ou dans le 68881. Le compilateur Pascal génère le code nécessaire pour les appeler à partir du texte source Pascal. Pour plus d'informations sur les limites et la précision de ces fonctions, consultez le manuel Apple Numerics. Pour plus d'informations sur les fonctions 68881, consultez le manuel d'utilisation du coprocesseur à virgule flottante MC68881 de Motorola. En général, tout résultat renvoyé par une fonction arithmétique est une approximation, bien que le résultat de la fonction Abs soit exact.
Les fonctions n'ayant pas de paramètres de types réels sont implémentées par le code généré par le compilateur.
Dans cette section, une valeur numérique est définie comme une expression impliquant des constantes et des variables de types Extended, Double, Real, Comp, LongInt ou Integer. Les valeurs numériques sont donc de type Extended, LongInt ou Integer.
Lorsque vous définissez l'option -MC68881, le compilateur génère des appels directs au 68881 pour plusieurs des fonctions décrites ci-dessous.
La fonction Odd
| Function Odd(X:Integer):Boolean; |
| Function Odd(X:LongInt):Boolean; |
La fonction Odd teste si une valeur entière est impaire, en renvoyant une valeur Boolean. Son paramètre x est une expression avec une valeur de type Integer ou LongInt. Odd(x) renvoie true si x est impair ; sinon, cela donne false.
La fonction Abs
| Function Abs(x:nombre):nombre; |
La fonction Abs renvoie la valeur absolue d'une valeur numérique. Son paramètre x est une valeur numérique. Abs(X) renvoie la valeur absolue de x, avec le même type.
La fonction Sqr
| Function Sqr(X:nombre):nombre; |
La fonction Sqr renvoie le carré d'une valeur numérique. Son paramètre x est une valeur numérique. Sqr(x) renvoie le carré de x.
Si x est d'un type réel, le résultat est étendu ; si x est de type LongInt, le résultat est LongInt ; et si x est de type Integer, le résultat peut être soit un Integer, soit un LongInt.
Si x est de type réel et un débordement en virgule flottante se produisent, le résultat est +inf.
La fonction Sin
| Function Sin(X:nombre):Extended; |
La fonction Sin renvoie une valeur Extended étant le sinus d'une valeur numérique. Son paramètre x est une valeur numérique. Cette valeur est supposée représenter un angle en radians. Si x est infini, un NAN de diagnostic est produit et le signal de fonctionnement invalide est défini.
La fonction Cos
| Function Cos(X:nombre):Extended; |
La fonction Cos renvoie une valeur Extended étant le cosinus d'une valeur numérique. Son paramètre x est une valeur numérique. Cette valeur est supposée représenter un angle en radians. Si x est infini, un NAN de diagnostic est produit et le signal de fonctionnement invalide est défini.
La fonction Exp
| Function Exp(X:nombre):Extended; |
La fonction Exp renvoie une valeur Extended étant l'exponentielle naturelle d'une valeur numérique. Son paramètre x est une valeur numérique. Toutes les valeurs possibles sont valides. Exp(x) renvoie la valeur de ex, où e est la base du logarithme népérien. Si un dépassement en virgule flottante se produit, le résultat est +∞.
La fonction Ln
| Function Ln(X:nombre):Extended; |
La fonction Ln renvoie une valeur Extended étant le logarithme népérien d'une valeur numérique. Son paramètre x est une valeur numérique.
Si x est non négatif, Ln(x) renvoie le logarithme népérien (loge) de x. Si x est négatif, un NAN de diagnostic est produit et le signal de fonctionnement invalide est défini.
La fonction Sqrt
| Function Sqrt(X:nombre):Extended; |
La fonction Sqrt renvoie une valeur étendue étant la racine carrée d'une valeur numérique. Son paramètre x est une valeur numérique.
Si x est non négatif, Sqrt(x) renvoie la racine carrée positive de x. Si x est négatif, un NAN de diagnostic est produit et le signal de fonctionnement invalide est défini.
La fonction Arctan
| Function Arctan(X:nombre):Extended; |
La fonction Arctan renvoie une valeur Extended étant la valeur principale, en radians, de l'arctangente d'une valeur numérique. Son paramètre x est une valeur numérique. Toutes les valeurs numériques de x sont valides, y compris ±∞
Fonctions ordinales
Les fonctions ordinales opèrent sur la valeur ordinale des types scalaires et de pointeurs.
La fonction Ord
| Function Ord(X:valeur):ordinal; |
La fonction Ord renvoie le nombre ordinal d'une valeur de type scalaire ou de type pointeur. Son paramètre x est une expression avec une valeur de type scalaire ou de type pointeur.
Si x est de type Integer ou LongInt, le résultat est le même que x.
Si x est de type pointeur, le résultat est l'adresse physique correspondante de type LongInt.
Si x est d'un autre type scalaire, le résultat est le nombre ordinal déterminé en cartographiant les valeurs du type sur des nombres entiers consécutifs non négatifs commençant à zéro.
Pour un paramètre de type Char, le résultat est le code ASCII correspondant. Pour un paramètre de type booléen :
- Ord(false) renvoie zéro
- Ord(true) en renvoie un
La fonction Chr
| Function Chr(x:Integer):Char; |
| Function Chr(x:LongInt):Char; |
La fonction Chr renvoie la valeur char correspondant à une valeur entière. Son paramètre x est une expression avec une valeur Integer ou LongInt. La fonction Chr(x) renvoie la valeur char dont le numéro ordinal (c'est-à-dire son code ASCII) correspond, si x est dans l'intervalle 0..255. Si x n'est pas compris dans l'intervalle 0..255, la valeur renvoyée n'est pas dans l'intervalle du type char et toute tentative de l'attribuer à une variable de type char provoquera une erreur.
Pour toute valeur char de ch, ce qui suit est vrai :
- Chr(Ord(Ch))=Ch
La fonction Succ
| Function Succ(X:scalaire):scalaire; |
La fonction Succ renvoie le successeur de son paramètre x, une valeur de type scalaire. Succ(x) renvoie le successeur de x si une telle valeur existe selon l'ordre inhérent des valeurs dans le type de x.
Si x est la dernière valeur du type de x, elle n'a pas de successeur. Dans ce cas, la valeur renvoyée n'est pas dans l'intervalle du type de x, et toute tentative de l'attribuer à une variable de ce type entraînera des résultats non spécifiés.
La fonction Pred
| Function Pred(X:scalaire):scalaire; |
La fonction Pred renvoie le prédécesseur de son paramètre x, une valeur de type scalaire. Pred(x) renvoie le prédécesseur de x si une telle valeur existe selon l'ordre inhérent des valeurs dans le type de x.
Si x est la première valeur du type de x, il n'a pas de prédécesseur. Dans ce cas, la valeur renvoyée n'est pas dans l'intervalle du type de x, et toute tentative de l'attribuer à une variable de ce type entraînera des résultats non spécifiés.
Procédures et fonctions de chaîne de caractères
Les procédures et fonctions de chaîne de caractères n'acceptent pas les paramètres de caractères PACKED ARRAY OF, ni les paramètres de chaîne de caractères indexés.
La fonction Length
| Function Length(Str:String):Integer; |
La fonction Length renvoie une valeur entière correspondant à la longueur actuelle de son paramètre Str, devant avoir une valeur de type STRING.
La fonction Pos
| Function Pos(substr,str:String):Integer; |
La fonction Pos recherche substr dans str et renvoie une valeur entière étant l'index du premier caractère de substr dans str. Les deux paramètres doivent être de type STRING. Si substr n'est pas trouvé, Pos renvoie zéro.
La fonction Concat
| Function Concat(str1,str2,[str3,...,strn]:String):String; |
La fonction Concat concatène tous les paramètres dans l'ordre dans lequel ils sont écrits et renvoie la chaîne de caractères concaténée. Les constantes de caractères et les chaînes de caractères peuvent être mélangées. Chaque paramètre est une expression avec une valeur de type STRING. N'importe quel nombre de paramètres peut être transmis. Notez que le nombre de caractères dans le résultat ne peut pas dépasser 255.
La fonction Copy
| Function Copy(Source:String;Index,Count:Integer):String; |
La fonctiopn Copy renvoie une chaîne de caractères contenant le nombre de caractères de la source, en commençant à la source [index].
Le paramètre source est une expression avec une valeur de type STRING. L'index du paramètre est une expression avec une valeur Integer comprise entre 1 et 255. Le paramètre count est une expression avec une valeur Integer comprise entre 1 et 255.
Si les valeurs d'index ou de count sont hors limites ou s'il n'y a pas de caractères de count dans la source à partir de la source [index], la copie renvoie la chaîne de caractères nulle.
La procédure Delete
| Procedure Delete(Var dest:String;index,count:Integer); |
La procedure Delete supprime le nombre de caractères de la valeur de dest, en commençant à dest[index]. Le paramètre dest est une référence de variable faisant référence à une variable de type STRING. C'est un paramètre variable. L'index du paramètre est une expression avec une valeur entière comprise entre 1 et 255. Le paramètre count est une expression avec une valeur entière comprise entre 1 et 255.
Si les valeurs de l'index ou du nombre sont hors limites ou si l'index est supérieur à la longueur (dest), la suppression est ignorée. Si la tentative de suppression s'étend au-delà de la fin de dest, dest est tronqué à l'index -1.
La procédure Insert
| Procedure Insert(Source:String;Var dest:String;index:Integer); |
Insérer insère la source dans la destination. Le premier caractère de source devient dest[index]. Le paramètre source est une expression avec une valeur de type STRING. Le paramètre dest est une référence de variable faisant référence à une variable de type STRING. C'est un paramètre variable. L'index du paramètre est une expression avec une valeur entière comprise entre 1 et 255. Si la valeur de l'index est hors de l'intervalle, Insert est ignoré.
Procédures et fonctions orientées octets
Les procédures orientées octets permettent à un programme de traiter une variable de programme comme une séquence d'octets, sans tenir compte des types de données.
Ces procédures n'effectuent aucune vérification de type sur leurs paramètres source ou dest actuel. Cependant, comme il s'agit de paramètres variables, ils ne peuvent pas être indexés s'ils sont compressés. Si un "tableau d'octets" décompressé est souhaité, alors une variable du type :
doit être utilisé pour la source ou la destination. Les éléments d'un tableau de ce type sont entreposés dans des octets contigus; comme il est décompressé, un tableau de ce type peut être utilisé avec un index comme paramètre réel pour ces routines.
Remarque : Un tableau décompressé contenant des éléments de type 0..255 ou de type char a ses éléments entreposés en mots et non en octets. Un mot fait deux octets.
La procédure MoveLeft
| Procedure Moveleft(Var source,dest;count:Integer); |
La procédure MoveLeft copie un nombre spécifié d'octets contigus d'un intervalle source vers un intervalle de destination (en commençant à l'adresse la plus basse). Ses paramètres sont les suivants :
- Source est une référence de variable faisant référence à une variable de n'importe quel type, à l'exception d'un type de fichier ou d'un type structuré contenant un type de fichier. C'est un paramètre variable. Le premier octet alloué à la source (adresse la plus basse dans la source) est le premier octet de l'intervalle source.
- Dest est une référence de variable faisant référence à une variable de n'importe quel type, à l'exception d'un type de fichier ou d'un type structuré contenant un type de fichier. C'est un paramètre variable. Le premier octet alloué à dest (adresse la plus basse dans dest) est le premier octet de l'intervalle de destination.
- Count est une expression avec une valeur entière. L'intervalle source et l'intervalle de destination comptent chacune des octets. L'intervalle du paramètre count n'est pas vérifiée.
La procédure Moveright
| Procedure Moveright(Var source,dest;count:Integer); |
Moveright est exactement comme Moveleft, sauf qu'il commence à l'extrémité "droite" de l'intervalle source (adresse la plus élevée). Il procède vers la «gauche» (adresses inférieures), copiant les octets dans la plage de destination, en commençant à l'adresse la plus élevée de l'intervalle de destination.
La raison pour laquelle Moveleft et Moveright sont utilisés est que les intervalles source et destination peuvent se chevaucher. S'ils se chevauchent, l'ordre dans lequel les octets sont déplacés est critique : chaque octet doit être déplacé avant d'être écrasé par un autre octet.
La fonction Sizeof
| Function Sizeof(id [,t1,...,tn]):LongInt; |
La fonction Sizeof renvoie une valeur LongInt correspondant au nombre d'octets occupés par une variable spécifiée ou par toute variable d'un type spécifié. Son identificateur de paramètre est soit un identifiant de variable, soit un identifiant de type. Les paramètres facultatifs t1,..., tn sont des valeurs de balise spécifiées uniquement pour obtenir la taille d'un enregistrement de variante et ne peuvent être spécifiées que si le premier paramètre est un identifiant de type.
Sizeof renvoie le nombre d'octets occupés par id, si id est un identifiant de variable ; si id est un identifiant de type, Sizeof renvoie le nombre d'octets occupés par toute variable de type id. Si l'identificateur de type est un enregistrement contenant des variantes, vous pouvez spécifier les valeurs de balise (devant être des constantes répertoriées de manière contiguë et dans l'ordre de leur déclaration). Dans ce cas, la fonction Sizeof renvoie la taille de l'enregistrement avec les variantes spécifiées. La valeur de Sizeof est déterminée par le compilateur, la traitant ensuite comme une constante au moment de la compilation.
Routines de tableaux de caractères compactés
Les routines décrites dans cette section fonctionnent uniquement sur des tableaux de type PACKED ARRAY OF char. Lorsqu'ils sont utilisés comme paramètres, ces tableaux ne peuvent pas être indexés ; les routines décrites ci-dessous commencent toujours par leur premier caractère.
La fonction Scaneq
| Function Scaneq(limit:Integer;ch:Char;Var paoc:Packed Array of Char):Integer; |
| Function Scaneq(limit:LongInt;ch:Char;Var paoc:Packed Array of Char):Integer; |
La fonction scaneq balaye paoc, à la recherche de la première occurrence de ch. L'analyse commence par le premier caractère de paoc. Si le caractère n'est pas trouvé dans la limite de caractères depuis le début de paoc, la valeur retourne est un entier égal à limit. Sinon, la valeur renvoyée est un entier donnant le nombre de caractères analysés avant que ch ne soit trouvé. Les paramètres de scaneq ont ces types :
- Limit est une expression avec une valeur de type Integer ou LongInt. Il est tronqué à 16 bits et l'intervalle n'est pas vérifiée.
- Ch est une expression avec une valeur de type char.
- Paoc est une expression avec une valeur de type PACKED ARRAY OF char. C'est un paramètre variable.
La fonction Scanne
| Function Scanne(limit:Integer;ch:Char;Var paoc:Packed Array of Char):Integer; |
| Function Scanne(limit:LongInt;ch:Char;Var paoc:Packed Array of Char):Integer; |
La fonction Scanne est exactement comme Scaneq, sauf qu'elle recherche un caractère ne correspondant pas au paramètre ch.
La procédure Fillchar
| Procedure FillChar(Var Paoc:Packed Array of Char;Count:Integer;ch:Char); |
| Procedure FillChar(Var Paoc:Packed Array of Char;Count:LongInt;ch:Char); |
La procédure FillChar remplit un nombre spécifié de caractères dans un PACKED ARRAY OF char avec un caractère spécifié. Il a les paramètres suivants :
- Paoc est une expression avec une valeur de type PACKED ARRAY OF char. C'est un paramètre variable.
- Count est une expression avec une valeur de type Integer ou LongInt. Il est tronqué à 16 bits et l'intervalle n'est pas vérifiée.
- Ch est une expression avec une valeur de type char.
FillChar écrit la valeur de ch dans le nombre d'octets contigus de mémoire, en commençant au premier octet de paoc. Étant donné que l'intervalle du paramètre count n'est pas vérifiée, il est possible d'écrire dans la mémoire en dehors de paoc, avec des résultats non spécifiés.
Fonctions et procédures des bits logiques
Cette section décrit un ensemble de procédures et de fonctions pour les manipulations de bits. Ces routines correspondent à un ensemble d'instructions essentiellement identiques au Motorola 68000.
La plupart des routines présentées ici correspondent aux routines Inside Macintosh. Cependant, MPW Pascal génère du code plus efficace que les appels à ces routines, vous devez donc utiliser les identifiants donnés ici de préférence aux routines ROM du Macintosh.
Si le type d'un paramètre est spécifié comme scalaire, le paramètre peut être une valeur entière de n'importe quelle taille, de 1 à 32 bits (un bit à un LongInt). Si le paramètre scalaire est inférieur à 32 bits, du code est généré pour étendre le paramètre à 32 bits mais sans extension de signe (des zéros sont ajoutés à gauche pour constituer une valeur de 32 bits).
Remarque : La numérotation des bits de ces routines suit la convention du microprocesseur 68000, et non celle utilisée dans Inside Macintosh. Le bit 0 est le bit de poids faible ; le bit 31 est le bit de poids fort.
Le tableau suivant résume les fonctions et procédures de manipulation de bits :
| Nom du MPW | Code opérationnel MC68000 | Premier paramètre | Deuxième paramètre | Résultat | Genre |
|---|---|---|---|---|---|
| BAND | AND.L | Scalaire | Scalaire | LongInt | Function |
| BOR | OR.L | Scalaire | Scalaire | LongInt | Function |
| BXOR | EOR | Scalaire | Scalaire | LongInt | Function |
| BNOT | NOT.L | Scalaire | LongInt | Function | |
| BSL | LSL.L | Scalaire | Integer | Longint | Function |
| BSR | LSR.L | Scalaire | Integer | Longint | Function |
| BRotL | ROL.L | Scalaire | Integer | LongInt | Function |
| BRotR | ROR.L | Scalaire | Integer | LongInt | Function |
| BTst | BTST.L | Scalaire | Integer | Boolean | Function |
| HIWrd | Scalaire | Integer | Function | ||
| LOWrd | Scalaire | Integer | Function | ||
| BClr | BCLR.L | LongInt (VAR) | Integer | Procedure | |
| BSet | BSET.L | LongInt (VAR) | Integer | Procedure |
Ces routines ont généralement une fonction identique à un ensemble correspondant de routines décrites dans Inside Macintosh. Cependant, ces routines sont plus efficaces car elles sont implémentées par le compilateur sous la forme de 68 000 instructions, tandis que les routines Inside Macintosh sont des appels à la ROM. Les routines BTst, BClr et BSet, bien que fonctionnellement similaires aux trois routines Inside Macintosh, ont des paramètres différents.
La syntaxe de chaque routine de manipulation de bits est décrite ci-dessous.
La fonction BAND
| Function BAND(arg1, arg2:scalaire):LongInt; |
BAND renvoie le AND logique de ses deux paramètres.
La fonction BOR
| Function BOR(arg1, arg2:scalaire):LongInt; |
BOR renvoie le OR logique de ses deux paramètres.
La fonction BXOR
| Function BXOR(arg1, arg2:scalaire):LongInt; |
BXOR renvoie le Ou exclusif logique de ses deux paramètres.
La fonction BNOT
| Function BNOT(arg:scalaire):LongInt; |
BNOT renvoie le complément à 1 de son paramètre.
Fonction BSL
| Function BSL(arg:scalaire;count:Integer):LongInt; |
BSL décale vers la gauche les bits de arg du nombre de bits spécifié dans count, modulo 64. Les zéros sont décalés vers le bit de poids faible.
La fonction BSR
| Function BSR(arg:scalaire;count:Integer):LongInt; |
BSR décale vers la droite les bits de arg du nombre de bits spécifié dans count, modulo 64. Les zéros sont décalés vers le bit de poids fort.
La fonction BRotL
| Function BRotL(arg:scalaire;count:Integer):LongInt; |
BRotL fait pivoter à gauche les bits de arg du nombre de bits spécifié dans count, modulo 64. Les bits décalés hors de la position d'ordre supérieur retournent à la position d'ordre inférieur.
La fonction BRotR
| Function BRotR(arg:scalaire;count:Integer):LongInt; |
BRotR fait pivoter à droite les bits de arg du nombre de bits spécifié dans count, modulo 64. Les bits décalés hors de la position d'ordre inférieur reviennent à la position d'ordre supérieur.
La fonction BTst
| Function BTst(arg:scalaire;bitNfm:Integer):LongInt; |
Le paramètre bitNbr est un entier indiquant le bit de arg à tester. BTst renvoie true si le bit spécifié a la valeur un et renvoie false s'il a la valeur zéro. Étant donné que cette fonction correspond directement à l'instruction 68000, les bits sont numérotés de la manière conventionnelle dans le 68000 : 0 à 31, bit de poids faible vers bit de poids fort.
La fonction HlWrd
| Function HiWrd(arg:scalaire):Integer; |
HiWrd renvoie le mot de poids fort de arg. Si arg n'est pas un LongInt, HiWrd renvoie zéro. Lorsque le paramètre est un simple accès à une variable ou à un tableau, aucun code n'est généré par cette fonction car le paramètre est simplement adressé et utilisé comme un entier.
La fonction LoWrd
| Function LoWrd(arg:scalaire):Integer; |
LoWrd renvoie le mot de poids faible de arg. Lorsque le paramètre est un simple accès à une variable ou à un tableau, aucun code n'est généré par cette fonction car l'argument est simplement adressé et utilisé comme un entier.
La procédure BClr
| Procedure BClr(Var arg:LongInt;bitNlm:Integer); |
BClr efface le bit bitNbr dans arg. La valeur de bitNbr est réduite modulo 32.
La procédure BSet
| Procedure BSet(Var arg:LongInt;bitNlm:Integer); |
BSet définit le bit bitNbr dans arg. La valeur de bitNbris réduite modulo 32.