@andrivet/z80-assembler 1.0.0 → 1.2.0

package/lib/compiler/Assets.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Z80 Assembler in Typescript
+ *
+ * File:        Assets.ts
+ * Description: Assets used by the compiler and packaged by Vite
+ * Author:			Sebastien Andrivet
+ * License:			GPLv3
+ * Copyrights: 	Copyright (C) 2023 Sebastien Andrivet
+ */
+/**
+ * Assembler Z80 en Typescript
+ *
+ * Fichier:     Assets.ts
+ * Description: Ressources utilisées par le compilateur and emballées par Vite
+ * Author:			Sebastien Andrivet
+ * License:			GPLv3
+ * Copyrights: 	Copyright (C) 2023 Sebastien Andrivet
+ */
+import assetCharacters from '../assets/code/characters.zx81?raw';
+import assetSystemVariables from '../assets/code/system-variables.zx81?raw';
+import assetBasicLine1 from '../assets/code/basic-line1.zx81?raw';
+import assetBasicLine2 from '../assets/code/basic-line2.zx81?raw';
+import assetDisplay from '../assets/code/display.zx81?raw';
+import assetBasicEnd from '../assets/code/basic-end.zx81?raw';
+export { assetCharacters, assetSystemVariables, assetBasicLine1, assetBasicLine2, assetDisplay, assetBasicEnd };

package/lib/compiler/Ast.d.ts

@@ -7,21 +7,42 @@
  * License:			GPLv3
  * Copyrights: 	Copyright (C) 2023 Sebastien Andrivet
  */
+/**
+ * Assembler Z80 en Typescript
+ *
+ * Fichier:     Ast.ts
+ * Description: Types pour construire un arbre syntaxique abstrait.
+ * Author:			Sebastien Andrivet
+ * License:			GPLv3
+ * Copyrights: 	Copyright (C) 2023 Sebastien Andrivet
+ */
 import { bytes } from '../types/Types';
 import { ByteValue, Expression, PosInfo, WordValue } from "../grammar/z80";
 /**
- * A function taking no argument and returning a number (if it is known) or null (if it is unknown)
+ * A function taking no argument and returning a number (if it is known) or null (if it is unknown).
+ * Une function qui ne prend pas d'argument et qui retourne un nombre (s'il est connu) ou null (s'il est inconnu).
  */
 export type EvalFunc = () => number | null;
 /**
- * An abstract element generated by the parser
+ * An abstract element generated by the parser.
+ * Un élément abstrait générà par l'analyseur.
  */
 export interface AstBase {
+    /**
+     * The number of bytes that will be generated by this element.
+     * Le nombre d'octets générés par cet élément.
+     */
     get size(): number;
+    /**
+     * Generate actual bytes.
+     * Génération des octets
+     * @param instructionAddress Address of the next byte to generate,
+     *                           Adresse du prochain octet à générer.
+     */
     generate(instructionAddress: number): bytes;
 }
 /**
- * An AST element is either a number (the raw byte value) or derived from AstBase
+ * An AST element is either a number (the raw byte value) or derived from AstBase.
  */
 export type AstElement = number | AstBase;
 /**
@@ -65,22 +86,22 @@ interface InnerExpression<E extends Evaluable> {
 /**
  * A Binary operation interface, i.e. a function with two arguments and that returns a number.
  */
-interface BinaryOperation {
-    (a: number, b: number): number;
-}
+type BinaryOperation = (a: number, b: number) => number;
 /**
  * A Unary operation interface, i.e. a function with one argument and that returns a number.
  */
-interface UnaryOperation {
-    (a: number): number;
-}
+type UnaryOperation = (a: number) => number;
 /**
- * A Binary function such as: 2 * 4 * 2.
- * @param left Left side of the binary function (an array of operands).
+ * A Binary operation such as: 2 * 4.
+ * Une expression binaire telle que: 2 * 4.
+ * @param left Left side of the binary function.
+ *             Le coté gauche de l'opération binaire.
  * @param right Right side of the binary function.
+ *              Le coté droit de l'opération binaire
  * @param op Operation to be applied to the left and right side.
+ *           L'opération à appliquer aux opérandes
  */
-export declare function binaryOperation<Operation extends BinaryOperation, Inner extends Evaluable, Left extends InnerExpression<Inner>, Right extends Evaluable>(left: Left[], right: Right, op: Operation): EvalFunc;
+export declare function binaryOperation<Operation extends BinaryOperation, Inner extends Evaluable, Left extends InnerExpression<Inner>, Right extends Evaluable>(left: Left | null, right: Right, op: Operation): EvalFunc;
 /**
  * A map of strings versus binary operations. For example: '*' => operatorMul
  */
@@ -94,18 +115,22 @@ type UnaryOperationsMap = {
     [key: string]: UnaryOperation;
 };
 /**
- * A Inner Operator i.e. that extends an Inner Expression, itself extending an Evaluable.
+ * An Inner Operator i.e. that extends an Inner Expression, itself extending an Evaluable.
  */
 interface InnerOp<E extends Evaluable> extends InnerExpression<E> {
     op: string;
 }
 /**
- * A Binary function such as: 2 * 4 * 2.
- * @param left Left side of the binary function (an array of operands).
+ * A Binary operation such as: 2 * 4.
+ * Une expression binaire telle que: 2 * 4.
+ * @param left Left side of the binary function.
+ *             Le coté gauche de l'opération binaire.
  * @param right Right side of the binary function.
+ *              Le coté droit de l'opération binaire
  * @param map Map the operations to be applied to the left and right side.
+ *            Une correspondance pour les opérations à appliquer aux opérandes.
  */
-export declare function binaryOperations<Inner extends Evaluable, Left extends InnerOp<Inner>, Right extends Evaluable>(left: Left[], right: Right, map: BinaryOperationsMap): EvalFunc;
+export declare function binaryOperations<Inner extends Evaluable, Left extends InnerOp<Inner>, Right extends Evaluable>(left: Left | null, right: Right, map: BinaryOperationsMap): EvalFunc;
 /**
  * A Unary operation.
  * @param e The argument.
@@ -135,67 +160,97 @@ export declare const operatorInvert: (a: number) => number;
 export declare const operatorIdentity: (a: number) => number;
 /**
  * Returns an AST element that represents the low part of a little-endian 16-bit value.
+ * Retourne un élément de l'AST qui représente la partie basse d'une valeur 16 bits en petit boutiste.
  * @param pos The position of the element in the source.
- * @param e The little-endian 16-bit value
+ *            La position de l'élément dans le code source.
+ * @param e The 16-bit value.
+ *          La valeur 16-bit.
  */
 export declare function value16LE(pos: PosInfo, e: Expression): AstElement;
 /**
  * Returns an AST element that represents an 8-bit unsigned value.
+ * Retourne un élément de l'AST qui représente une valeur 8 bits.
  * @param pos The position of the element in the source.
- * @param e The 8-bit unsigned value
+ *            La position de l'élément dans le code source.
+ * @param e The 8-bit unsigned value.
+ *          La valeur 8-bit.
  */
 export declare function value8(pos: PosInfo, e: Expression): AstElement;
 /**
  * Returns an AST element that represents an 8-bit signed value.
+ * Retourne un élément de l'AST qui représente une valeur 8 bits signée.
  * @param pos The position of the element in the source.
+ *            La position de l'élément dans le code source.
  * @param s The sign of the value.
  * @param e The 8-bit signed value
+ *          La valeur 8-bit signée.
  */
 export declare function svalue8(pos: PosInfo, s: string, e: Expression): AstElement;
 /**
  * Returns an AST element that represents an offset for a JR (jump relative) opcode.
+ * Retourne un élément de l'AST qui représente un décalage pour un saut relatif JR.
  * @param pos The position of the element in the source.
- * @param e The offset value
+ *            La position de l'élément dans le code source.
+ * @param e The offset value.
+ *          La valeur du décalage.
  */
 export declare function jrOffset(pos: PosInfo, e: Expression): AstElement;
 /**
- * Returns an AST element that represents an offset for a JR (jump relative) opcode.
+ * Returns an AST element that represents an relative offset for a JR (jump relative) opcode.
+ * Retourne un élément de l'AST qui représente un décalage relatif pour un saut relatif JR.
  * @param pos The position of the element in the source.
+ *            La position de l'élément dans le code source.
  * @param label The label that will give the offset value
+ *              L'étiquette qui va donner la valeur du décalage.
  */
 export declare function jrRelativeOffset(pos: PosInfo, label: string): AstElement;
 /**
  * An Inner Byte, i.e. it contains an inner field that is a Byte value.
+ * Un octet interne, c.-à-d. qui contient un champ inner de type ByteValue.
  */
 export interface InnerByte {
     inner: ByteValue;
 }
 /**
  * An Inner Word, i.e. it contains an inner field that is a Word value.
+ * Un mot interne, c.-à-d. qui contient un champ inner de type WordValue.
  */
 export interface InnerWord {
     inner: WordValue;
 }
 /**
- * The bytes of a Byte directive
+ * The bytes of a Byte directive.
+ * Les octets d'une directive Byte.
  * @param _ The position of the bytes in the source code.
+ *          La position des octets dans le code source.
  * @param data0 The first byte.
+ *              Le premier octet.
  * @param data The other bytes.
+ *             Les autres octets.
  */
 export declare function dataBytes(_: PosInfo, data0: ByteValue, data: InnerByte[]): AstElements;
 /**
- * The words of a Word directive
+ * The words of a Word directive.
+ * Les mots d'une directive Word.
  * @param _ The position of the words in the source code.
+ *          La position des mots dans le code source.
  * @param data0 The first word.
+ *              Le premier mot.
  * @param data The other words.
+ *             Les autres mots.
  */
 export declare function dataWords(_: PosInfo, data0: WordValue, data: InnerWord[]): AstElements;
 /**
  * The parameters of a block of data.
+ * Les paramètres d'un bloc de données.
  * @param pos0 The position of the length in the source code.
+ *             La position de la taille dans le code source.
  * @param length The length (in bytes) of the block
+ *               La taille (en octets) du bloc.
  * @param pos1 The position of the value in the source code.
+ *             La position de la valeur dans le code source.
  * @param value The value used to initialize the block.
+ *              La valeur utilisée pour initialiser le bloc.
  */
 export declare function dataBlock(pos0: PosInfo, length: Expression, pos1: PosInfo | undefined, value: Expression | undefined): AstElement;
 export {};

package/lib/compiler/Compiler.d.ts

@@ -7,10 +7,20 @@
  * License:			GPLv3
  * Copyrights: 	Copyright (C) 2023 Sebastien Andrivet
  */
+/**
+ * Assembler Z80 en Typescript
+ *
+ * Fichier:     Compiler.ts
+ * Description: Compilateur (assembleur)
+ * Author:			Sebastien Andrivet
+ * License:			GPLv3
+ * Copyrights: 	Copyright (C) 2023 Sebastien Andrivet
+ */
 import { PosInfo } from "../grammar/z80";
-import { LinesInfo, CompilationInfo } from "../types/Types";
+import { CompilationInfo, LinesInfo } from "../types/Types";
 /**
  * Type of the internal data.
+ * Type pour l'état interne.
  */
 interface ParseDate {
     outputName: string;
@@ -24,30 +34,45 @@ interface ParseDate {
  * Internal data (i.e. globals).
  * Unfortunately, tsPEG does not allow to declare a context for the parsing.
  * So instead, we use this ugly global.
+ * Données internes (c.-à-d. globales).
+ * Malheureusement, tsPEG ne permet pas de déclarer un contexte pour l'analyse.
+ * Donc à la place, j'utilise ces données globales assez horribles.
  */
 declare const parseData: ParseDate;
 /**
- * Set the outputs names (output directive)
+ * Set the outputs names (output directive).
+ * Définit les noms des fichiers de sortie (directive output).
  * @param filename Filename for the binary.
+ *                 Nom de fichier pour le binaire.
  * @param sld Filename for the SLD.
+ *            Nom de fichier pour le SLD.
  */
 declare function setOutputName(filename: string, sld?: string): void;
 /**
- * Set the name of the target (device directive).
+ * Set the name of the target (device directive)
+ * Définit le nom de la cible (directive device).
  * @param name The name of the device
+ *             Le nom de l'appareil.
  */
-declare function setDeviceName(name: string): void;
+declare function setDevice(name: string): void;
 /**
  * Include an assembly file (include directive).
+ * Inclut un fichier assembleur (directive include).
  * @param pos Position of the include directive.
+ *            Position de la directive.
  * @param filename The filename of the file to be included.
+ *                 Le nom du fichier à inclure.
  */
 declare function includeFile(pos: PosInfo, filename: string): LinesInfo;
 /**
  * Compile an assembly source code.
+ * Compile un fichier source assembleur.
  * @param filepath The file path of the source code.
+ *                 Le chemin du code source.
  * @param code The assembly source code.
+ *             Le code source assembleur.
  * @param getFileCode A function to get the content of included files.
+ *                    Une fonction pour obtenir le contenu d'un fichier inclus.
  */
 declare function compile(filepath: string, code: string, getFileCode: (filename: string) => string): CompilationInfo;
-export { parseData, compile, includeFile, setOutputName, setDeviceName };
+export { parseData, compile, includeFile, setOutputName, setDevice };

package/lib/compiler/Formatter.d.ts

@@ -1,5 +1,24 @@
 /**
- * Represents a chunk of data to display binary,
+ * Z80 Assembler in Typescript
+ *
+ * File:        Formatter.ts
+ * Description: Format bytes to display them easily
+ * Author:			Sebastien Andrivet
+ * License:			GPLv3
+ * Copyrights: 	Copyright (C) 2023 Sebastien Andrivet
+ */
+/**
+ * Assembler Z80 en Typescript
+ *
+ * Fichier:     Formatter.ts
+ * Description: Formattage d'octets pour les afficher facilement
+ * Author:			Sebastien Andrivet
+ * License:			GPLv3
+ * Copyrights: 	Copyright (C) 2023 Sebastien Andrivet
+ */
+/**
+ * Represents a chunk of data to display binary.
+ * Représente un morceau de données pour afficher un binaire.
  */
 interface Chunk {
     address: string;
@@ -7,8 +26,11 @@ interface Chunk {
 }
 /**
  * Format bytes to display them.
+ * Formate des octets pour les afficher.
  * @param bytes An array of bytes.
+ *              Un tableau d'octets.
  * @param perLine Number of bytes per line.
+ *                Le nombre d'octets par line.
  */
 declare function formatBytes(bytes: number[], perLine: number): Chunk[];
 export { formatBytes, Chunk };

package/lib/compiler/Generator.d.ts

@@ -7,10 +7,10 @@
  * License:			GPLv3
  * Copyrights: 	Copyright (C) 2023 Sebastien Andrivet
  */
-import { Lines } from "../grammar/z80";
 import { bytes, LinesInfo } from '../types/Types';
 /**
  * Information about a compiled program.
+ * Informations sur un programme compilé.
  */
 interface ProgramInfo {
     bytes: bytes;
@@ -21,21 +21,21 @@ interface ProgramInfo {
 /**
  * Compute, whenever possible, the value associated with labels.
  * @param address The starting address.
- * @param lines The lines (i.e. the AST)
- * @return the address that corresponds to the code after the lines (i.e the new starting address).
+ * @param infos The lines (i.e. the AST)
+ * @return the address that corresponds to the code after the lines (i.e. the new starting address).
  */
-declare function computeLabels(address: number, lines: Lines): number;
+declare function computeLabels(address: number, infos: LinesInfo[]): number;
+interface GenerationData {
+    bytes: bytes;
+    sld: string;
+    address: number;
+}
 /**
- * Generate machine code bytes for an array of lines (i.e. an AST)
+ * Generate machine code bytes and SLD for an array of lines (i.e. an AST)
+ * @param mainfile Main file name
  * @param address The current address.
- * @param lines The lines (i.e. the AST)
- * @return An array of bytes (numbers)
- */
-declare function generateLinesBytes(address: number, lines: Lines): bytes;
-/**
- * Generate debugging information (in Source Level Debugging format)
- * @param lines An array of lines with their associated filename
- * @return The debugging information (in Source Level Debugging format)
+ * @param infos The lines (i.e. the AST) with the associated filename
+ * @return An array of bytes (numbers), debug data and the next address
  */
-declare function generateSld(lines: LinesInfo): string;
-export { computeLabels, generateLinesBytes, generateSld, ProgramInfo };
+declare function generate(mainfile: string, address: number, infos: LinesInfo[]): GenerationData;
+export { computeLabels, generate, ProgramInfo };

package/lib/compiler/Labels.d.ts

@@ -7,40 +7,66 @@
  * License:			GPLv3
  * Copyrights: 	Copyright (C) 2023 Sebastien Andrivet
  */
+/**
+ * Assembler Z80 en Typescript
+ *
+ * Fichier:     Labels.ts
+ * Description: Etiquettes associées à des emplacements mémoire.
+ * Author:			Sebastien Andrivet
+ * License:			GPLv3
+ * Copyrights: 	Copyright (C) 2023 Sebastien Andrivet
+ */
 import { Expression, PosInfo } from "../grammar/z80";
 /**
  * Reset the labels.
+ * Supprime toutes les étiquettes.
  */
 declare function resetLabels(): void;
 /**
  * Add a label.
+ * Ajoute une étiquette.
  * @param pos The position of the label in the source code.
+ *            La position de l'étiquette dans le code source.
  * @param name The name of the label.
- * @param value The value of the label (if known) or null (if unknown)
+ *             Le nom de l'étiquette.
+ * @param value The value of the label (if known) or null (if unknown).
+ *              La valeur de l'étiquette (si connue) ou null (si inconnue).
  */
 declare function addLabel(pos: PosInfo, name: string, value: number | null): void;
 /**
  * Add a label and its associated expression.
+ * Ajoute une étiquette et son expression associée.
  * @param _ The position of the label in the source code.
+ *          La position de l'étiquette dans le code source.
  * @param name The name of the label.
+ *             Le nom de l'étiquette.
  * @param expression The expression that gives that value of the label.
+ *                   L'expression qui donne la valeur de l'étiquette.
  */
 declare function addLabelExpression(_: PosInfo, name: string, expression: Expression): void;
 /**
  * Get the value associated with a label.
+ * Obtient la valeur associée avec une étiquette.
  * @param name The name of the label.
+ *             Le nom de l'étiquette.
  * @param setUsed Set the used flag or not.
+ *                Est-ce que l'on doit lever le drapeau d'utilisation ?
  * @return The value associated with a label or null if it is unknown.
+ *         La valeur associée avec l'étiquette ou null si elle est inconnue.
  */
 declare function getLabelValue(name: string, setUsed?: boolean): number | null;
 /**
  * Is a label used in the program or only declared?
+ * Est-ce qu'une étiquette a été utilisée ou seulement déclarée ?
  * @param name The name of the label.
- * @return true if the label is used, false if it is unused or undeclared.
+ *             Le nom de l'étiquette.
+ * @return true if the label is used, false otherwise.
+ *         true si l'étiquette a été utilisée, false sinon.
  */
 declare function isLabelUsed(name: string): boolean | undefined;
 /**
  * Get the list of labels with an unknown value.
+ * Retourne la liste des étiquettes avec une valeur inconnue.
  */
 declare function getUnknownLabels(): string[];
 export { resetLabels, addLabel, addLabelExpression, getLabelValue, isLabelUsed, getUnknownLabels };

package/lib/grammar/LowLevel.d.ts

@@ -7,62 +7,99 @@
  * License:			GPLv3
  * Copyrights: 	Copyright (C) 2023 Sebastien Andrivet
  */
+/**
+ * Assembler Z80 en Typescript
+ *
+ * Fichier:     LoweLevel.ts
+ * Description: Fonctions de bas niveau pour l'analyseur.
+ * Author:			Sebastien Andrivet
+ * License:			GPLv3
+ * Copyrights: 	Copyright (C) 2023 Sebastien Andrivet
+ */
 import { byte } from "../types/Types";
 /**
  * Compute the binary representation of the r argument.
- * @param r The argument of the opcode
+ * Calcule la représentation binaire de l'argument r.
+ * @param r The argument of the opcode.
+ *          L'argument du code assembleur.
  * @param offset The number of bits to shift to the left.
+ *               Le nombre de bits à décaler vers la gauche.
  */
 export declare function r_bits(r: string, offset?: number): byte;
 /**
  * Compute the binary representation of the dd argument.
- * @param dd The argument of the opcode
+ * Calcule la représentation binaire de l'argument dd.
+ * @param dd The argument of the opcode.
+ *           L'argument du code assembleur.
  * @param offset The number of bits to shift to the left.
+ *               Le nombre de bits à décaler vers la gauche.
  */
 export declare function dd_bits(dd: string, offset?: number): byte;
 /**
  * Compute the binary representation of the qq argument.
- * @param qq The argument of the opcode
+ * Calcule la représentation binaire de l'argument qq.
+ * @param qq The argument of the opcode.
+ *           L'argument du code assembleur.
  * @param offset The number of bits to shift to the left.
+ *               Le nombre de bits à décaler vers la gauche.
  */
 export declare function qq_bits(qq: string, offset?: number): byte;
 /**
  * Compute the binary representation of the ss argument.
- * @param ss The argument of the opcode
+ * Calcule la représentation binaire de l'argument ss.
+ * @param ss The argument of the opcode.
+ *           L'argument du code assembleur.
  * @param offset The number of bits to shift to the left.
+ *               Le nombre de bits à décaler vers la gauche.
  */
 export declare function ss_bits(ss: string, offset?: number): byte;
 /**
  * Compute the binary representation of the pp argument.
- * @param pp The argument of the opcode
+ * Calcule la représentation binaire de l'argument pp.
+ * @param pp The argument of the opcode.
+ *           L'argument du code assembleur.
  * @param offset The number of bits to shift to the left.
+ *               Le nombre de bits à décaler vers la gauche.
  */
 export declare function pp_bits(pp: string, offset?: number): byte;
 /**
  * Compute the binary representation of the rr argument.
- * @param rr The argument of the opcode
+ * Calcule la représentation binaire de l'argument rr.
+ * @param rr The argument of the opcode.
+ *           L'argument du code assembleur.
  * @param offset The number of bits to shift to the left.
+ *               Le nombre de bits à décaler vers la gauche.
  */
 export declare function rr_bits(rr: string, offset?: number): byte;
 /**
  * Compute the binary representation of the cc argument.
- * @param cc The argument of the opcode
+ * Calcule la représentation binaire de l'argument cc.
+ * @param cc The argument of the opcode.
+ *           L'argument du code assembleur.
  * @param offset The number of bits to shift to the left.
+ *               Le nombre de bits à décaler vers la gauche.
  */
 export declare function cc_bits(cc: string, offset?: number): byte;
 /**
  * Compute the binary representation of the jj argument.
- * @param jj The argument of the opcode
+ * Calcule la représentation binaire de l'argument jj.
+ * @param jj The argument of the opcode.
+ *           L'argument du code assembleur.
  */
 export declare function jj_bits(jj?: string): byte;
 /**
  * Compute the binary representation of the p argument.
- * @param p The argument of the opcode
+ * Calcule la représentation binaire de l'argument p.
+ * @param p The argument of the opcode.
+ *          L'argument du code assembleur.
  * @param offset The number of bits to shift to the left.
+ *               Le nombre de bits à décaler vers la gauche.
  */
 export declare function p_bits(p: number, offset?: number): byte;
 /**
  * Compute the binary representation of the mode argument.
- * @param mode The argument of the opcode
+ * Calcule la représentation binaire de l'argument mode.
+ * @param mode The argument of the opcode.
+ *             L'argument du code assembleur.
  */
 export declare function imode(mode: string): byte;

package/lib/grammar/Parse.d.ts

@@ -1,38 +1,77 @@
+/**
+ * Z80 Assembler in Typescript
+ *
+ * File:        Parse.ts
+ * Description: Fonctions uses by the parser to convert strings
+ * Author:			Sebastien Andrivet
+ * License:			GPLv3
+ * Copyrights: 	Copyright (C) 2023 Sebastien Andrivet
+ */
+/**
+ * Assembler Z80 en Typescript
+ *
+ * Fichier:     Parse.ts
+ * Description: Fonctions de conversion de chaines de caractères pour l'analyseur.
+ * Author:			Sebastien Andrivet
+ * License:			GPLv3
+ * Copyrights: 	Copyright (C) 2023 Sebastien Andrivet
+ */
 import { PosInfo } from "./z80";
 /**
  * Parse a number.
+ * Analyse un nombre.
  * @param pos Position of the number in the source code.
+ *            Position du nombre dans le code source.
  * @param str The characters of the number.
+ *            Les caractères du nombre.
  * @param base The base of the number.
+ *             La base du nombre.
  * @param nbBytes The number of bytes to represent this number (1 or 2)
+ *                Le nombre d'octets pour représenter ce nombre (1 ou 2)
  */
 export declare function parseNumber(pos: PosInfo, str: string, base: number, nbBytes: number): number;
-/**
- * Parse a simple character, i.e. a character that is not escaped.
- * @param pos Position of the character in the source code.
- * @param raw Raw representation of the character.
- */
-export declare function parseSimpleChar(pos: PosInfo, raw: string): number[];
 /**
  * Parse a simple escape, i.e. a backslash followed by a character.
- * @param value The character after the backslash.
+ * Analyse un échappement simple, c.-à-d. une barre oblique inversée suivie d'un caractère.
+ * @param pos Position of the character in the source code.
+ *            Position du caractère dans le code source.
+ * @param c The character after the backslash.
+ *          Le caractère après la barre oblique inversée.
  */
-export declare function parseSimpleEscape(value: string): number[];
+export declare function parseSimpleEscape(pos: PosInfo, c: string): number[];
 /**
  * Parse an octal value.
+ * Analyse une valeur octale.
  * @param pos Position of the value in the source code.
+ *            Position de la valeur dans le code source.
  * @param value The characters representing the value.
+ *              Les caractères représentant la valeur.
  */
 export declare function parseOctalEscape(pos: PosInfo, value: string): number[];
 /**
  * Parse a hexadecimal value.
+ * Analyse une valeur hexadécimale.
  * @param pos Position of the value in the source code.
+ *            Position de la valeur dans le code source.
  * @param value The characters representing the value.
+ *              Les caractères représentant la valeur.
  */
 export declare function parseHexadecimalEscape(pos: PosInfo, value: string): number[];
+/**
+ * Parse a ZX81 character written in ASCII.
+ * Analyse un caractère ZX81 écrit en ASCII.
+ * @param pos Position of the character in the source code.
+ *            Position du caractère dans le code source.
+ * @param c The ASCII character.
+ *          Le caractère ASCII.
+ */
+export declare function parseZX81Char(pos: PosInfo, c: string): [number];
 /**
  * Parse a ZX81 string written in ASCII.
+ * Analyse un chaine ZX81 écrit en ASCII.
  * @param pos Position of the string in the source code.
+ *            Position de la chaine dans le code source.
  * @param str The ASCII string.
+ *            La chaine ASCII.
  */
 export declare function parseZX81String(pos: PosInfo, str: string): number[];