ASSIRIS
langage assembleur pour les plateformes Iris 50 et Felix C
From Wikipedia, the free encyclopedia
L'expression ASSIRIS est un mot abrégé de « Assembleur de Système SIRIS ». Initialement, elle désignait le compilateur du assembleur du système d'exploitation de l'ordinateur Iris 50 (y compris la série romaine Felix C). Au fil du temps, son sens a évolué et elle désigne désormais plus particulièrement le langage assembleur de ces ordinateurs[1],[2].
| Langage ASSIRIS | |
| Date de première version | 1966 |
|---|---|
| Paradigme | impérative |
| Auteur | SDS |
| Développeur | CII, INRIA |
| Influencé par | IBM |
| Implémentations | Iris 50 |
| Système d'exploitation | SIRIS 3 |
modifier  |
|
Histoire
Le langage a été conçu par Scientific Data Systems (SDS) pour son processeur 32 bits Sigma 7, sorti en 1966, compatible avec le système IBM 360, dont il était un concurrent[3]. Son développement fut repris par la CII, puis, à partir de 1967, par l'INRIA, et appliqué aux ordinateurs Iris 50 dont l'assembleur était ASSIRIS.
Description
Comme tout langage assembleur, il vise à rendre les instructions du code machine plus lisibles par l'humain. À l'exception des macros, chaque instruction ASSIRIS est convertie par l'assembleur en une seule instruction de code machine[4]. De ce fait, les commandes peuvent exploiter avec précision et intégralement les capacités du jeu d'instructions « cablées » de l'ordinateur[5].
Le format du texte source
À l'origine, les programmes sources étaient saisis sur des cartes IBM à_80_colonnes, une instruction par carte. Les 72 premières colonnes contenaient plusieurs zones, chacune se terminant par au moins un espace (le séparateur de zones). Le contenu des cartes pouvait être rangées dans des fichiers situés dans « bibliothèques de code source », sur support magnétique ; c'était la méthode de travail habituelle des programmeurs de grands logiciels[6].
Les zones d'instructions sur cartes (ligne de programme) sont les suivantes[6] :
- « Zone d'étiquette », contenant soit un identificateur converti en adresse relative (déplacement), soit le nom d'un élément de données. Si l'identificateur est absent, la zone doit contenir au moins un espace (le séparateur).
- « Zone de commande », obligatoire, contenant le nom de la directive ou la commande de l'instruction ou de la macro.
- « Zone d'arguments », contenant les arguments de l'instruction ou de la macro.
- « Zone de commentaires », facultative, se terminant avant la colonne 72 et contenant tout caractère reconnu. Elle contient généralement des explications à l'intention du programmeur sur le fonctionnement de l'instruction. Si le premier caractère d'une ligne est « * », la ligne entière est considérée comme un commentaire. Les lignes vides sont également considérées comme des commentaires. Les commentaires sont ignorés par l'assembleur.
- « Zone de continuation », colonne 72 : si le caractère « * » est présent, les colonnes 22 à 71 de la carte (ligne de programme) suivante sont considérées comme juxtaposées au dernier caractère non vide de la zone de commentaire de la carte précédente.
- « Zone de séquence », optionnelle, composée des 8 dernières colonnes, contient une numérotation des cartes permettant de rétablir la séquence correcte en cas de mélange.
Drapeaux
Le système Iris 50 possède quatre drapeaux (indicateurs de condition), situés dans les bits 36 à 39 du registre d'état du système. Il s'agit, dans l'ordre[7],[8],[9] :
- Z, positionné en cas de résultat nul (« Zéro ») ;
- S, positionné en cas de résultat négatif (« Signe ») ;
- D, positionné en cas de dépassement de capacité binaire (les retenues des bits 0 et 1 diffèrent) ;
- C, positionné en cas de retenue du bit 0 (« Carry »).
Les bits 32 à 35 du registre d'état (« EP ») contiennent les masques de débordement, DS, DI, DD, DB, pour les débordements supérieur, inférieur, décimal et binaire, respectivement[7],[8],[9].
Constantes ASSIRIS
Dans le langage ASSIRIS, il existe 8 types de constantes[10],[5] :
- Constantes chaîne de caractère : toute chaîne de caractères de 256 caractères maximum (EBCDIC), placée entre guillemets simples. Exemples :
'ABC'ouC'ABC'.
- Si la chaîne contient elle-même des guillemets simples, elle doit être déclarée avec « C », et les guillemets simples de la chaîne doivent être doublés. Par exemple, la chaîne
A'BC'est déclarée commeC'A''BC'''.
- Constantes entières : toute chaîne de chiffres décimaux signés (le signe « + » peut être omis). La chaîne peut être placée entre guillemets simples et précédée du caractère « I ». Exemples : 1234, +1234, −567, I'1234'.
- Constantes hexadécimales : toute chaîne de 255 caractères hexadécimaux maximum, placée entre guillemets simples et précédée des caractères « X » ou « S ». Exemples : X'FFFF', S'3A4F52', −X'3A4F52'.
- Constantes octales : toute chaîne de caractères d’au maximum 255 chiffres octaux, placée entre guillemets simples et précédée du caractère « O ». Exemples : O’777’, O’347’, −O’34725107’.
- Constantes décimales : toute chaîne de caractères d’au maximum 31 chiffres décimaux, éventuellement précédée ou suivie des signes « − » ou « + », placée entre guillemets simples et précédée du caractère « D ». Exemples : D’3456’, D’+3456’, D’3456+’, D’−3456’, D’908−’.
- Constantes à virgule fixe : une séquence de caractères de la forme FX'±z1.z2 Eα Bβ', où « z1.z2 » est un nombre décimal, « Eα » est l'exposant décimal en notation E, et « Bβ » est le facteur d'échelle (également un exposant, comme E) nécessaire pour ramener le nombre à une valeur inférieure à l'unité. Exemples : FX'2.56E−1B2', FX'2.56', FX'256.E−3B4'.
- Constantes à virgule flottante hexadécimale courte : séquence de caractères de la forme FS'±z1.z2 Eα', où « z1.z2 » est un nombre décimal et « Eα » est l'exposant décimal en notation E. Exemples : FS'5.7E10', FS'5.E−10', FS'−5.7+2'.
- Constantes virgule flottante hexadécimale longue : séquence de caractères de la forme FL'±z1.z2 Eα' (avec un « E », et non un « D »), où « z1.z2 » est un nombre décimal et « Eα » est l'exposant décimal en notation E. Exemples : FL'5.7E10', FL'5.E−10', FL'−5.7+2'.
Les instructions du langage
Les instructions du langage peuvent être de trois types[11] :
- Directives d'assemblage ;
- Instructions exécutables ;
- Macro-instructions.
Directives d'assemblage
Les directives d'assemblage sont des commandes qui communiquent diverses informations à l'assembleur. Ces directives sont présentées dans le tableau suivant[12].
| Directive | Fonction |
|---|---|
| DATA | Déclaration permettant de générer des constantes dont les valeurs sont données dans la zone d'arguments. |
| GEN | Identique à la DATA, pour les constantes binaires. |
| TEXT | Identique à la DATA, pour les chaînes de caractères EBCDIC. |
| TEXTC | Identique à la TEXT, de plus, générer la longueur de la chaîne dans un octet avant le texte (max. 256 caractères). |
| COM | Définit une commande utilisateur. |
| EQU | Attribue une valeur d'adresse à une étiquette. |
| RES | Réserver un espace mémoire. |
| ORG | Attribue une valeur d'adresse au compteur de position. |
| BOUND | Aligne le compteur de position sur un multiple de 2, 4 ou 8. |
| FETCHS | Charge le programme source à partir d'une bibliothèque (au lieu de cartes). |
| CSECT | Définit le début et le type d'une section. Une section peut être de type programme (argument : P), données (D) ou commun (C). Si l'argument est absent, la section est considérée comme un programme. |
| DSECT | Définit le début d'une section factice. Une section factice peut contenir les directives RES, ORG, BOUND, EQU, TITLE, PAGE, LIST, NLIST, SPACE. |
| DEF | Déclare une liste d'identificateurs comme références externes (qui sont également reconnus par d'autres sections). |
| REF | Déclare une liste d'identificateurs comme références externes (utilise des identificateurs déclarés dans d'autres sections). |
| SEGREF | Déclare une liste d'identificateurs comme noms de segments (implicit références externes). |
| ENTREF | Déclare une liste d'identificateurs à la fois comme références externes et comme points d'entrée dans le segment. |
| USING | Attribue un registre de base à un segment externe. |
| USD | Attribue un registre de base à une section factice (nécessaire pour l'assemblage des identificateurs dans cette section). |
| GOTO | Détermine si l'assemblage se poursuit à partir de l'une des étiquettes spécifiées, en fonction d'un index. |
| DO / FIN | Génère un certain nombre de séquences consécutives d'instructions similaires, qui dépendent d'un compteur spécifié dans la zone d'arguments. |
| END | Signale à l'assembleur la fin du texte source de l'unité d'assemblage. |
| TITLE | Affiche dans la liste de sortie (avec le texte source du programme) un titre après chaque saut de page. |
| PAGE | Insère un saut de page dans la liste de résultats. |
| SPACE | Insére un saut de n lignes dans la liste de sortie (laisse n lignes vides). |
| LIST | Reprendre l'impression de la liste imprimée, interrompue par la directive NLIST. |
| NLIST | Arrête l'impression de la liste imprimée. |
Instructions exécutables
Chacune de ces instructions est convertie en une seule instruction de code machine.
Format des instructions en représentation interne (code machine)
Toutes les instructions sont représentées sur 32 bits (un « mot »). Leur format est le suivant[13],[14],[15],[16] :
1 3 4 1 7 16 (largeur, en bits) I B Q X F D 0 1 3 4 7 8 9 15 16 31 (index de bits)* * La documentation de CII numérote les bits de gauche à droite, de sorte que le bit le plus significatif soit le bit numéro 0.
La zone F contient le code de l'instruction à exécuter. Sur 7 bits, on peut représenter 128 instructions exécutables, mais le jeu d'instructions n'en compte que 102. Les 26 autres emplacements de code sont inutilisés[13],[16].
La zone B contient le numéro du registre de base avec un excédent de −8. Seuls les registres R9 à R15 pouvant servir de registres de base ; la zone B contient les 3 derniers bits de leur numéro. Si la zone B contient « 000 », la valeur de base prise en compte sera 0000000016 lors du calcul de l'adresse[13],[16].
La zone D contient le déplacement (adresse relative). Étant représentée sur 16 bits, elle peut avoir des valeurs couvrant une zone de mémoire de 64 Ki[13],[16].
La zone I contient le mode d'adressage. L'adressage direct est défini par 0, et l'adressage indirect par 1. En adressage direct, l'adresse calculée est la somme du contenu du registre de base utilisé (zone B) et du déplacement (zone D). En adressage indirect, l'adresse obtenue, comme en adressage direct, est l'adresse d'un mot mémoire qui, dans les zones I, B et D, contient les informations nécessaires au calcul d'une nouvelle adresse. Il existe cinq niveaux d'adressage indirect[13],[16].
La zone X contient le mode d'indexation. Pour 0, l'adressage est non indexé, et pour 1, indexé. En cas d'adressage non indexé, l'adresse est calculée comme est expliqué précédemment. En cas d'adressage indexé, le contenu du registre général (appelé ici « registre d'index ») dont le numéro est spécifié dans la zone Q est ajouté à l'adresse calculée. L'adressage indirect et l'adressage indexé peuvent être combinés, mais l'indexation est utilisée en dernier[13],[16].
La zone Q peut stocker diverses informations, en fonction du code d'opération : le numéro du registre d'index, un opérande, une constante ou un masque[13],[16].
Liste des instructions exécutables
La signification des symboles dans le tableau d'instructions est la suivante[17] :
| Equation: | Sintaxe: | ||
| C, D, S, Z | Drapeaux | A | Adresse (explicite ou implicite) |
| EP | Registre contenant l'état programme | L | Expression de longueur |
| ET | Intersection | M | Mnémonique |
| IC | Drapeaux (indicateurs de condition) | R | Expression de registre |
| OU | Réunion | V | Expression de valeur |
| P | Régistre d'adresse programmme | X | Expression d'index |
| Q | La zone Q d'une instruction | * | Signe d'adressage indirect |
| R | Un des régistres généraux | ||
| R5–7 | Les bits 5–7 d'un des régistres généraux | ||
| R0 | Registre général no. 0 | Option : | |
| R05–7 | Les bits 5–7 du registre général no. 0 | D | Opérateur de calcul décimal |
| Y | Adresse effective de l'instruction consideree | M | Protection mémoire |
| Y' | Adresse définie par le contenu de l'un des régistres généraux | S | Opérator de calcul en virgule flotante |
| Y8–31 | Les bits 8–31 de l'adresse Y | P | Instruction privillégiée |
| 21–31Y | Les bits 21–31 de l'adresse Y, pris pour opérande | ||
| → | rangér à, ou charger dans | Exemple: | |
| : : | Comparaison | (R0–7) : : (Y) →Z, C | |
| ⊕ | Disjonction exclusive | Le contenu des positions binaires 0–7 du registre R est comparé au contenu de l'adresse efectve Y. Le résultat est chargé dans les drapeaux Z et C. | |
| ( ) | Contenu de | ||
| (( )) | Contenu du contenu de | ||
Les 102 instructions de code machine exécutables sont[18],[19],[20] :
| Code hexa | Mnémo- nique | Fonction | Effet |
|---|---|---|---|
| 01 | EX2 | Intersection demi-mot | (R0–15) ET (Y) → R0–15 |
| 02 | EX4 | Intersection mot | (R0–31) ET (Y) → R0–31 |
| 05 | MG2 | Reunion demi-mot | (R0–15) OU (Y) → R0–15 |
| 06 | MG4 | Reunion mot | (R0–31) OU (Y) → R0–31 |
| 08 | LDL2 | Chargement demi-mot droit | (Y) → R16–31 et « 0 » → R0–15 |
| 09 | LDH2 | Chargement demi-mot gauche | (Y) → R0–15 |
| 0A | LD4 | Chargement mot | (Y) → R0–31 |
| 0B | LD8 | Chargement double-mot | (Y) → R0–63 |
| 0C | LAS | Chargement mot et marquage | (Y) → R0–31 et « 1 » → Y0 |
| 0D | EO2 | Disjunction exclusive demi-mot | (R0–15) ⊕ (Y) → R0–15 |
| 0E | EO4 | Disjunction exclusive mot | (R0–31) ⊕ (Y) → R0–31 |
| 10 | CP1 | Comparaison caractère | (R0–7) : : (Y) → Z, C |
| 11 | CP2 | Comparaison demi-mot | (R0–15) : : (Y) → Z, S, D, C |
| 12 | CP4 | Comparaison mot | (R0–31) : : (Y) → Z, S, D, C |
| 13 | CP8 | Comparaison double-mot | (R0–63) : : (Y) → Z, S, D, C |
| 15 | SBH2 | Soustraction demi-mot gauche | (R0–15) − (Y) → R0–15 |
| 16 | SB4 | Soustraction mot | (R0–31) − (Y) → R0–31 |
| 17 | SB8 | Soustraction double-mot | (R0–63) − (Y) → R0–63 |
| 18 | LD1 | Chargement caractère gauche | (Y) → R0–7 |
| 19 | LDC2 | Chargement opposé demi-mot | −(Y) → R0–15 |
| 1A | LDC4 | Chargement opposé mot | −(Y) → R0–31 |
| 1B | LDC8 | Chargement opposé double-mot | −(Y) → R0–63 |
| 1C | ADL2 | Addition demi-mot droit | (R0–31) + (Y) → R0–31 |
| 1D | ADH2 | Addition demi-mot gauche | (R0–15) + (Y) → R0–15 |
| 1E | AD4 | Addition mot | (R0–31) + (Y) → R0–31 |
| 1F | AD8 | Addition double-mot | (R0–63) + (Y) → R0–63 |
| 20 | SH2 | Décalage(a) demi-mot | (R0–15) → R0–15 |
| 21 | SH4 | Décalage (a) mot | (R0–31) → R0–31 |
| 22 | NF4 | Normalisation flottant court | (R0–31) → R0–31 (normalisé) |
| 24 | CP1I | Comparaison caractère immédiat | (R0–7) : : (24–31Y) → Z, C |
| 26 | SB4I | Soustraction mot immédiat | (R0–31) − (8–31Y) → R0–31 |
| 27 | AD4I | Addition mot immédiat | (R0–31) + (8–31Y) → R0–31 |
| 28 | LD1I | Chargement caractère immédiat | (24–31Y) → R0–7 |
| 29 | LD2I | Chargement demi-mot immédiat | (16–31Y) → R0–15 |
| 2A | LD4I | Chargement mot immédiat | (8–31Y) → R8–31 et « 0 » → R0–7 |
| 2B | LDDA | Chargement adresse décimale | Y → R014–31 et L → R04–7 |
| 2C | LDM | Chargement multiple | (Y) → R0, (Y+4) → R1, (Y+8) → R2 etc. |
| 2D | STM | Rangement multiple | (R0) → Y, (R1) → Y+4, (R2) → Y+8 etc. |
| (2E) | CSV | Appeler le superviseur | (Instruction inexistante, générant un déroutement.) |
| 30 | MP2 | Multiplication demi-mot | (R0–15) × (Y) → R0–30 |
| 31 | MPU2 | Multiplication arithmétique demi-mot | (R0–15) × (Y) → R0–31 |
| 32 | DV2 | Division(c) demi-mot | (R0–31) : (Y) → R0–31 |
| 33 | DVU2 | Division(b) arithmétique demi-mot | (R0–31) × (Y) → R0–31 |
| 34 | BCF | Branchement sur condition fause(b) | Y → P si Q ET (IC) = 0 |
| 35 | BCT | Branchement sur condition vraie(b) | Y → P si Q ET (IC) ≠ 0 |
| 36 | BDF | Branchement avec décrémentation sur condition fause | Y → P si (R4–7) ET (IC) = 0 et si (R8–31) − (R0–3) ≥ 0 |
| 37 | BDT | Branchement avec décrémentation sur condition vraie | Y → P si (R4–7) ET (IC) ≠ 0 et si (R8–31) − (R0–3) ≥ 0 |
| 38 | BRU | Branchement inconditionel | Y → P |
| 39 | BAL | Branchement avec enchainement | (P) + 4 → R0–31 puis Y → P |
| 3A | EXU | Execution | Y → P puis retour en séquence |
| 3C | ANALN | Analyse instruction normale | Extraire des informations des zones d'instruction |
| 3D | ANALD | Analyse instruction décimale | Extraire des informations des zones d'instruction |
| 40 | STTM | Rangement masques de débordement | (EP32–35) ET Q ou (Y0–3) ET Q → Y0–3 |
| 41 | LDTM | Chargement masques de débordement | (Y0–3) ET Q ou (EP32–35) ET Q → EP32–35 |
| 42 | STC | Rangement drapeaux | (IC) ET Q ou (Y0–3) ET Q → Y4–7 |
| 43 | LDC | Chargement drapeaux | (Y4–7) ET Q ou (IC) ET Q → IC |
| 44 | STS2 | Rangement sélectif demi-mot | (R0–15) ET (R32–47) → Y ou (Y) ET (R32–47) → Y |
| 45 | LDS2 | Chargement sélectif demi-mot | (Y) ET (R32–47) → R0–15 ou (R0–15) ET (R32–47) → R0–15 |
| 46 | IC2 | Incrémentation demi-mot | (Y) + Q → Y |
| 47 | IC4 | Incrémentation mot | (Y) + Q → Y |
| 48 | MVSL | Transfert d'une chaine de caractères de droite à gauche | (Y') → Y, (Y'−1) → Y−1, (Y'−2 ) → Y−2 etc. |
| 49 | MVSR | Transfert d'une chaine de caractères de gauche à droite | (Y') → Y, (Y'+1) → Y+1, (Y'+2 ) → Y+2 etc. |
| 4A | CYBL | Recopie d'un caractère dans une chaine de droite à gauche | (24–31Y) → R, (24–31Y) → R−1, (24–31Y) → R−2 etc. |
| 4B | CYBR | Recopie d'un caractère dans une chaine de gauche à droite | (24–31Y) → R, (24–31Y) → R+1, (24–31Y) → R+2 etc. |
| 4C | CPSL | Compaison de 2 chaines de caractères de droite à gauche | (Y') : : (Y) → Z, C |
| 4D | CPSR | Compaison de 2 chaines de caractères de gauche à droite | (Y') : : (Y) → Z, C |
| 4E | TRTL | Transcodage et test d'une chaine de caractères de droite à gauche | (Y') : : (Y) → Z, C |
| 4F | TRTR | Transcodage et test d'une chaine de caractères de gauche à droite | (Y') : : (Y) → Z, C |
| 50 | RD | Lecture directe | Instructions d'Entrée / Sortie |
| 51 | WD | Écriture directe | |
| 52 | SIO | Départ Entrée / Sortie | |
| 53 | HIO | Arrèt Entrée / Sortie | |
| 54 | TIO | Contrôle Entrée / Sortie | |
| 55 | TDV | Contrôle de périphérique | |
| 56 | AIO | Aquittement intrerrupt Entrée / Sortie | |
| 57 | WT | Attente | |
| 58 | ST1 | Rangement caractère gauche | (R0–7) → Y |
| 59 | ST2 | Rangement demi-mot gauche | (R0–15) → Y |
| 5A | ST4 | Rangement mot | (R0–31) → Y |
| 5B | ST8 | Rangement double-mot | (R0–63) → Y |
| 5C | STPA | Rangement adresse programme | (P8–29) → Y et „0” → Y30–31 |
| 5D | LPK | Chargement des clés de protection | (P8–29) → Y et „0” → Y30–31 |
| 5E | LPS | Chargement Etat-Programme | (Y) → EP0–63 |
| 5F | SHD | Décalage décimal | (Y') → Y (aprés décalage) |
| 60 | ZAD | Transfert décimal | (Y) → Y' |
| 61 | ADD | Addition décimale | (Y') + (Y) → Y' |
| 62 | SBD | Soustraction décimale | (Y') − (Y) → Y' |
| 63 | CPD | Comparaison décimale | (Y') : : (Y) → Z, S, D, C |
| 64 | MPD | Multiplication décimale | (Y') × (Y) → Y' |
| 65 | DVD | Division décimale | (Y') : (Y) → Y' |
| 66 | PACK | Condensation (décimale) | (Y') (dilaté) → Y (condensé) |
| 67 | UNPK | Dilatation (décimale) | Y (condensé) → (Y') (dilaté) |
| 68 | DV4 | Division fractionnaire(d) mot | (R0–63) : (Y) → R0–63 |
| 69 | MP4 | Multiplication fractionnaire mot | (R0–31) × (Y) → R0–62 |
| 6B | SH8 | Décalage(a) double-mot | (R0–63) → R0–63 |
| 6C | ADF4 | Addition flottant court | (R0–31) + (Y) → R0–31 |
| 6D | SBF4 | Soustraction flottant court | (R0–31) − (Y) → R0–31 |
| 6E | MPF4 | Multiplication flottant court | (R0–31) × (Y) → R0–31 |
| 6F | DVF4 | Division flottant court | (R0–31) : (Y) → R0–31 |
| 7C | ADF8 | Addition flottant long | (R0–63) + (Y) → R0–63 |
| 7D | SBF8 | Soustraction flottant long | (R0–63) − (Y) → R0–63 |
| 7E | MPF8 | Multiplication flottant long | (R0–63) × (Y) → R0–63 |
| 7F | DVF8 | Division flottant long | (R0–63) : (Y) → R0–63 |
- (a) Les décalages peuvent être logique, arithmétique, circulaire ou une normalisation, à droite ou à gauche, selon le contenu des bits 20 à 23 de la zone d'adresse. Le nombre de positions à déplacer est donné par le contenu des bits 26 à 31 de la zone d'adresse (63 positions maximum). Pour simplifier la déclaration des décalages, l'assembleur reconnaît 20 mnémoniques « étendues », exemples : SLL2, SRC4, SRA8, SN4 etc.
- (b) Pour simplifier la déclaration de branchements, l'assembleur reconnaît 11 mnémoniques « étendues », exemples : BZ, BLZ, BLEZ, BC, BNC, BOV etc.
- (c) Le quotient est dans R0–15, et le reste dans R16–31.
- (d) Le quotient est dans R0–31, et le reste dans R32–63.
Macro-instructions
Une macro-instruction transforme un mnémonique en une séquence d'instructions. Le langage ASSIRIS ne permet pas à l'utilisateur d'écrire ses propres macros, mais de nombreuses macros prédéfinies sont disponibles dans la bibliothèque du système d'exploitation. Pour les utiliser, il suffit de connaître les fonctions exécutées ; il n'est pas nécessaire de connaître les séquences générées. Le tableau suivant présente quelques exemples de macros ASSIRIS (cette liste n'est pas exhaustive)[4].
| Mnemo- nique | Effet |
|---|---|
| ABORT | Arrêt anormal de l'exécution du programme |
| ASSIGN | Associe les périphériques nécessaires à l'exécution d'un programme. |
| CALL | Charge un segment dans la mémoire de l'ordinateur et le lance en exécution. |
| CB | Fournit au superviseur un bloc de commande d'Entrée / Sortie |
| CLOSE | Ferme (interdit l'accès à) le fichier après avoir terminé les opérations en cours |
| DLT | Supprime (en plaçant un indicateur d'invalidation) le dernier article lu |
| EXUP | Demande au superviseur d'exécuter un programme d'Entrée / Sortie défini par l'utilisateur |
| GET | Lit l'article suivant d'un fichier séquentiel |
| IOC | Décrit le programme d'unité d'echange (pour les Entrées / Sorties) |
| LDSG | Charge un segment dans la mémoire de l'ordinateur |
| MST | Message destiné à un périphérique système, généralement la console (1) et l'imprimante (2). |
| OPEN | Ouvre (permet d'accéder à) un fichier |
| PUT | Écrit un article à la position suivante dans un fichier séquentiel |
| RELEASE | Libère les périphériques précédemment associés au programme par l'instruction ASSIGN |
| RPL | Remplace un article dans un fichier séquentiel ; le positionnement est effectué avec GET |
| RST | Reprend la séquence d'Entrée / Sortie bloquée. |
| SFD | Décrit un fichier séquentiel |
| SXR | Demande la gestion d'un événement exceptionnel via une séquence de retour exceptionnel |
| TERM | Arrêt normal de l'exécution du programme |
| TIME | Fournit l'heure (HMS) basée sur l'heure déclarée lors de l'initialisation du système. |
| TYPE | Demande l'exécution d'un programme d'Entrée / Sortie à console défini par l'utilisateur dans TWB |
| TWB | Fournit au superviseur un bloc de commande d'Entrée / Sortie pour la macro TYPE |
| VXR | Demande la fin de la séquence de retour exceptionnel et sa revalidation. |
| WAIT | Met le programme en attente jusqu'à ce qu'un événement externe se produise, généralement à la fin d'une opération d'Entrée / Sortie |
Exemple de séquence générée par la macro « LDSG nom, EB: adresse1, LA: adresse2 » :
LD4I,2 adresse1
LD4I,3 adresse2
CSV X'06', code
où :
- adresse1 est l'adresse du mot de commande permettant à l'utilisateur de contrôler lui-même le chargement ; si elle n'est pas nécessaire, la macro est utilisée avec l'argument « NEB », ce qui génère adresse1 = 0 ;
- adresse2 est l'adresse où le segment est chargé ; si c'est celle définie par l'éditeur de liens, la macro est utilisée avec l'argument « NLA », ce qui génère adresse2 = 0 ;
- code est le code d'identification du segment « nom ».
Exemple de programme en ASSIRIS
Exemple de programme « Hello World » :
* AFFICHER « BONJOUR LE MONDE » SUR LA CONSOLE DE L'OPERATEUR
DEBUT MST 1,MESSAGE ECRIRE LE MESSAGE SUR L'UNITE 1
WAIT 1 ATTENDEZ LA FIN DE L'UNITE 1
TERM 0 ARRET NORMAL DU PROGRAMME
MESSAGE DATA C'BONJOUR LE MONDE' TEXTE DU MESSAGE
END DEBUT FIN, ADRESSE DE LANCEMENT
En cet exemple, DEBUT et MESSAGE sont des identificateurs (qui seront convertis en adresses), MST, WAIT et TERM sont des macro-instructions, et DATA et END sont des directives. Le reste sont des commentaires.
