Référence de l'API Haxe
L'API publique complète du runtime Loreline pour chaque langage supporté.
Vous débutez avec Loreline en Haxe ? Commencez par le guide d'intégration. Cette page est la référence exhaustive.
Cette référence est plus large que les autres. Loreline est écrit en Haxe, et toutes les autres cibles sont compilées à partir de ce code : les classes ci-dessous comprennent toute la hiérarchie des nœuds de l'AST et l'état d'exécution de l'interpréteur, que les wrappers des autres langages n'exposent pas.
Vue d'ensemble
Loreline
L'API publique principale du runtime Loreline. Elle donne un accès simple aux fonctions de base pour analyser et exécuter des scripts Loreline.
parse
public static function parse(input:String, ?filePath:String, ?handleFile:ImportsFileHandler, ?callback:(script:Script)->Void):Null<Script>
Analyse le texte fourni et en crée une instance Script exécutable.
| Paramètre | Type | Description |
|---|---|---|
input |
String |
Le contenu du script Loreline sous forme de chaîne (format .lor)
|
filePath |
String |
Chemin optionnel du fichier analysé. S'il est fourni, handleFile doit l'être aussi.
|
handleFile |
ImportsFileHandler |
Handler optionnel qui lit les fichiers importés. S'il est asynchrone, parse() renvoie null : utilisez alors l'argument callback.
|
callback |
(script:Script)->Void |
S'il est fourni, il est appelé avec le script obtenu. Utile surtout quand les imports sont lus de façon asynchrone. |
Retourne
Null<Script>
Le script analysé, une instance Script de l'AST (si le chargement est synchrone)
Lève Si le script contient des erreurs de syntaxe ou d'autres problèmes d'analyse
C'est la première étape pour utiliser un script Loreline. L'objet Script renvoyé se passe ensuite à play() ou à resume().
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
play
public static function play(script:Script, handleDialogue:DialogueHandler, handleChoice:ChoiceHandler, handleFinish:FinishHandler, ?beatName:String, ?options:InterpreterOptions):Interpreter
Démarre l'exécution d'un script Loreline depuis le début ou depuis un beat précis.
| Paramètre | Type | Description |
|---|---|---|
script |
Script |
Le script analysé (résultat de parse())
|
handleDialogue |
DialogueHandler |
Fonction appelée quand un texte de dialogue doit être affiché |
handleChoice |
ChoiceHandler |
Fonction appelée quand le joueur doit faire un choix |
handleFinish |
FinishHandler |
Fonction appelée quand l'exécution du script se termine |
beatName |
String |
Nom optionnel d'un beat précis par lequel démarrer (par défaut, le premier beat) |
options |
InterpreterOptions |
Options supplémentaires |
Retourne
Interpreter
L'instance d'interpréteur qui exécute le script
Cette fonction se charge d'initialiser l'interpréteur et de démarrer l'exécution immédiatement. Vous devrez fournir des handlers pour les dialogues, les choix et la fin du script.
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
resume
public static function resume(script:Script, handleDialogue:DialogueHandler, handleChoice:ChoiceHandler, handleFinish:FinishHandler, saveData:SaveData, ?beatName:String, ?options:InterpreterOptions):Interpreter
Reprend un script Loreline à partir d'une sauvegarde.
| Paramètre | Type | Description |
|---|---|---|
script |
Script |
Le script analysé (résultat de parse())
|
handleDialogue |
DialogueHandler |
Fonction appelée quand un texte de dialogue doit être affiché |
handleChoice |
ChoiceHandler |
Fonction appelée quand le joueur doit faire un choix |
handleFinish |
FinishHandler |
Fonction appelée quand l'exécution du script se termine |
saveData |
SaveData |
Les données de sauvegarde (en général, celles renvoyées par interpreter.save())
|
beatName |
String |
Nom optionnel d'un beat où reprendre, à la place du point sauvegardé |
options |
InterpreterOptions |
Options de configuration de l'interpréteur (optionnelles) |
Retourne
Interpreter
L'instance d'interpréteur qui exécute le script
Cela permet de continuer une histoire exactement là où elle a été sauvegardée, en restaurant toutes les variables d'état, les choix et la progression du joueur.
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
extractTranslations
public static function extractTranslations(script:Script):Map<String, NStringLiteral>
Extrait les traductions d'un script de traduction analysé.
| Paramètre | Type | Description |
|---|---|---|
script |
Script |
Le script de traduction analysé (résultat de parse() sur un fichier .XX.lor)
|
Retourne
Map<String, NStringLiteral>
Les traductions, à passer dans InterpreterOptions.translations
À partir d'un fichier de traduction analysé avec parse(), renvoie les traductions, à passer dans options.translations de play() ou de resume().
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
loadLocale
public static function loadLocale(locale:String, script:Script, ?filePath:String, ?handleFile:ImportsFileHandler, ?callback:(translations:Map<String, NStringLiteral>)->Void):Null<Map<String, NStringLiteral>>
Charge les traductions d'une langue donnée, en parcourant tout l'arbre d'imports du script.
| Paramètre | Type | Description |
|---|---|---|
locale |
String |
Le code de langue (par exemple "fr")
|
script |
Script |
Le script source analysé (analysé avec un chemin de fichier, sinon fournissez filePath)
|
filePath |
String |
Emplacement optionnel où chercher les fichiers de traduction (par défaut, script.filePath). Peut être un chemin de fichier .lor/.lor.txt ou un dossier.
|
handleFile |
ImportsFileHandler |
Handler de fichiers utilisé pour lire les fichiers de traduction |
callback |
(translations:Map<String, NStringLiteral>)->Void |
Appelé avec les traductions fusionnées. Requis si handleFile est asynchrone.
|
Retourne
Null<Map<String, NStringLiteral>>
Les traductions fusionnées (renvoyées directement quand handleFile est synchrone), ou null si un fichier de traduction existe mais est invalide. Les fichiers de traduction absents restent ignorés sans erreur. lastError() n'est renseignée que lorsqu'un fichier est présent mais illisible (.lor cassé, .po/.xliff/.csv malformé, etc.).
Pour chaque fichier du script (le fichier racine et tous ceux qu'il importe, directement ou non), Loreline cherche le fichier de traduction correspondant en insérant .<locale> avant l'extension (par exemple characters.lor -> characters.fr.lor). Les fichiers de traduction absents sont ignorés sans erreur.
Chaque clé de traduction est enregistrée sous deux formes :
- une clé globale
<id>(la première occurrence l'emporte, priorité au fichier racine) - une clé propre au fichier
<chemin-source-relatif>#<id>(toujours renseignée, permet de remplacer la clé globale)
Pour trouver une traduction, l'interpréteur cherche d'abord la clé propre au fichier.
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
translationFormat
public static function translationFormat(name:String, enabled:Bool):Void
Active ou désactive la prise en charge d'un autre format de fichier de traduction.
| Paramètre | Type | Description |
|---|---|---|
name |
String |
L'identifiant de format (voir ci-dessus) |
enabled |
Bool |
True pour activer le format, false pour le désactiver |
Retourne
Void
Par défaut, loadLocale n'essaie que les fichiers .<locale>.lor. Appelez cette méthode pour activer d'autres formats. Noms connus :
"po": GNU gettext PO (.po)"xliff": XLIFF 1.2 / 2.x (.xliff,.xlf)"csv": CSV / TSV (.csv,.tsv)
Les noms inconnus sont acceptés sans erreur, pour rester compatible avec de futurs formats.
Un fichier malformé dans un format activé (par exemple du XML cassé dans un .xliff, ou un .po avec une chaîne entre guillemets jamais fermée) fait lever une loreline.Error par loadLocale : avec try/catch en mode synchrone, ou avec Loreline.lastError() quand le callback reçoit null en mode asynchrone.
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
lastError
public static function lastError():Null<Error>
Renvoie l'erreur du dernier appel échoué à parse() ou loadLocale(), ou null en cas de succès.
Retourne
Null<Error>
En mode asynchrone (avec callback), le callback reçoit null en cas d'échec et cette méthode indique ce qui n'a pas fonctionné. En mode synchrone, l'appel lève une exception, et cette méthode renvoie la même erreur, consultable après le catch.
Pas thread-safe : à lire immédiatement après le retour de l'appel.
JavaScript TypeScript C# C++ Java PHP Python Lua Haxe
print
public static function print(script:Script, ?indent:String, ?newline:String):String
Régénère le code source Loreline à partir d'un script analysé.
| Paramètre | Type | Description |
|---|---|---|
script |
Script |
Le script analysé (résultat de parse())
|
indent |
String |
La chaîne d'indentation à utiliser (par défaut, deux espaces) |
newline |
String |
La chaîne de saut de ligne à utiliser (par défaut "\n") |
Retourne
String
Le code source régénéré, sous forme de chaîne
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
update
public static function update(delta:Float):Void
Fait avancer les timers wait() en attente. À appeler depuis votre boucle de jeu à chaque frame. Le premier appel active le mode différé non bloquant pour wait() sur les cibles système ; avant cet appel, wait() retombe sur un Sys.sleep() bloquant, ce qui convient aux outils en ligne de commande.
| Paramètre | Type | Description |
|---|---|---|
delta |
Float |
Temps écoulé depuis la frame précédente, en secondes |
Retourne
Void
generateTranslationFile
public static function generateTranslationFile(script:Script, ?existing:Map<String, NStringLiteral>, ?format:String, ?locale:String):String
Génère le contenu d'un fichier de traduction pour le script source donné.
| Paramètre | Type | Description |
|---|---|---|
script |
Script |
Le script source analysé |
existing |
Map<String, NStringLiteral> |
(optionnel) Traductions existantes à préserver lors de la fusion |
format |
String |
|
locale |
String |
Retourne
String
Le contenu du fichier de traduction, sous forme de chaîne, prêt à être écrit sur disque
Chaque chaîne traduisible de la source qui porte un marqueur #id devient une entrée de la sortie. Si existing est fourni (typiquement le résultat de extractTranslations sur un fichier de traduction déjà enregistré), les entrées déjà remplies y sont préservées telles quelles ; sinon, chaque entrée est pré-remplie avec le texte source.
Équivalent de la commande loreline translate ... --lang xx en ligne de commande.
insertLocalizationKeys
public static function insertLocalizationKeys(content:String, script:Script, ?includeImports:Bool = true, ?reservedIds:Map<String, Bool>):String
Insère un marqueur #id après chaque chaîne traduisible de content qui n'en a pas déjà un. script doit être l'AST analysé depuis ce même content. Renvoie le contenu réécrit.
| Paramètre | Type | Description |
|---|---|---|
content |
String |
|
script |
Script |
|
includeImports |
Bool |
|
reservedIds |
Map<String, Bool> |
Retourne
String
Quand includeImports vaut false, les scripts importés sont ignorés : leurs positions en octets se rapportent au contenu d'autres fichiers et corrompraient content. Un outil qui parcourt les imports lui-même doit passer false.
Si reservedIds est fourni, cette fonction l'utilise et le complète comme ensemble des identifiants déjà pris, partagé d'un appel à l'autre. Utile pour coordonner la génération d'identifiants sur plusieurs fichiers, afin que les identifiants automatiques du fichier B évitent tous ceux du fichier A. Les identifiants existants issus des tags de traduction de ce fichier y sont ajoutés, tout comme ceux nouvellement générés.
Équivalent de l'option --auto-ids de la commande loreline translate.
collectHashIds
public static function collectHashIds(content:String, ?out:Map<String, Bool>):Map<String, Bool>
Analyse lexicale seule de content, à la recherche de tous les identifiants #xxxx. Peu coûteux comparé à une analyse complète. Lance le lexer sur le texte et en extrait chaque charge utile CommentHash. À utiliser pour construire des registres d'identifiants réservés à l'échelle d'un projet.
| Paramètre | Type | Description |
|---|---|---|
content |
String |
|
out |
Map<String, Bool> |
Retourne
Map<String, Bool>
Remplit et renvoie out (ou un nouveau dictionnaire si out vaut null).
removeLocalizationKeys
public static function removeLocalizationKeys(content:String, script:Script):String
Opération inverse de insertLocalizationKeys : retire tous les marqueurs #id (y compris ceux écrits à la main). Renvoie le contenu réécrit. Équivalent de l'option --clear de la commande loreline translate.
| Paramètre | Type | Description |
|---|---|---|
content |
String |
|
script |
Script |
Retourne
String
extractTranslatableEntries
public static function extractTranslatableEntries(script:Script):Array<{ str:NStringLiteral, id:String }>
Renvoie chaque chaîne traduisible de script marquée d'un #id, associée à son identifiant. Les chaînes SANS marqueur #id sont écartées. Utilisez hasUntaggedTranslatableStrings pour les détecter.
| Paramètre | Type | Description |
|---|---|---|
script |
Script |
Retourne
Array<{ str:NStringLiteral, id:String }>
hasUntaggedTranslatableStrings
public static function hasUntaggedTranslatableStrings(script:Script):Bool
Renvoie true si script contient au moins une chaîne traduisible (instruction de texte, dialogue ou option de choix) sans #id. Ne modifie rien : se contente d'inspecter l'AST. Sert aux outils pour savoir s'il faut proposer "Ajouter des tags ?" avant de générer les fichiers de traduction.
| Paramètre | Type | Description |
|---|---|---|
script |
Script |
Retourne
Bool
Interpreter
Classe principale de l'interpréteur Loreline. Elle exécute un script analysé, gère l'état d'exécution et communique avec l'application hôte par des fonctions handler.
new
public function new(script:Script, handleDialogue:DialogueHandler, handleChoice:ChoiceHandler, handleFinish:FinishHandler, ?options:InterpreterOptions)
Crée un nouvel interpréteur de script Loreline.
| Paramètre | Type | Description |
|---|---|---|
script |
Script |
Le script analysé à exécuter |
handleDialogue |
DialogueHandler |
Fonction appelée pour afficher un texte de dialogue |
handleChoice |
ChoiceHandler |
Fonction appelée pour présenter des choix |
handleFinish |
FinishHandler |
Fonction appelée quand l'exécution se termine |
options |
InterpreterOptions |
Options supplémentaires |
JavaScript TypeScript C# Java Python Haxe
start
public function start(?beatName:String):Void
Démarre l'exécution du script depuis le début ou depuis un beat précis.
| Paramètre | Type | Description |
|---|---|---|
beatName |
String |
Nom optionnel du beat par lequel démarrer. Si null, l'exécution démarre au premier beat, ou au beat nommé "_" s'il existe. |
Retourne
Void
Lève RuntimeError Si le beat indiqué n'existe pas ou si le script ne contient aucun beat
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
save
public function save():SaveData
Sauvegarde l'état courant de l'interpréteur. Cela comprend toutes les variables d'état, l'état des personnages et la pile d'exécution, ce qui permet de reprendre l'exécution plus tard exactement au même point.
Retourne
SaveData
Un objet SaveData contenant l'état sérialisé
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
restore
public function restore(saveData:SaveData):Void
Restaure l'état de l'interpréteur à partir d'un objet SaveData, pour reprendre l'exécution là où elle avait été sauvegardée.
| Paramètre | Type | Description |
|---|---|---|
saveData |
SaveData |
L'objet SaveData contenant l'état sérialisé |
Retourne
Void
Lève RuntimeError Si la version des données de sauvegarde est incompatible
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
resume
public function resume():Void
Reprend l'exécution après la restauration de l'état. À appeler après restore() pour poursuivre l'exécution.
Retourne
Void
JavaScript TypeScript C# Java PHP Python Lua Haxe
getCharacter
public function getCharacter(name:String):Any
Renvoie un personnage par son nom.
| Paramètre | Type | Description |
|---|---|---|
name |
String |
Le nom du personnage à récupérer |
Retourne
Any
Les propriétés du personnage, ou null si le personnage n'existe pas
JavaScript TypeScript C# Java PHP Python Lua Haxe
getCharacterField
public function getCharacterField(character:String, name:String):Any
Renvoie une propriété précise d'un personnage.
| Paramètre | Type | Description |
|---|---|---|
character |
String |
Le nom du personnage |
name |
String |
Le nom de la propriété à lire |
Retourne
Any
La valeur de la propriété, ou null si le personnage ou la propriété n'existe pas
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
setCharacterField
public function setCharacterField(character:String, name:String, value:Any):Void
Modifie une propriété d'un personnage.
| Paramètre | Type | Description |
|---|---|---|
character |
String |
Le nom du personnage |
name |
String |
Le nom de la propriété à modifier |
value |
Any |
La nouvelle valeur |
Retourne
Void
JavaScript TypeScript GDScript C++ Java PHP Python Lua Haxe
getStateField
public function getStateField(name:String):Any
Renvoie une propriété de l'état par son nom, en cherchant d'abord dans la portée courante, puis dans les portées englobantes.
| Paramètre | Type | Description |
|---|---|---|
name |
String |
Le nom de la propriété à lire |
Retourne
Any
La valeur de la propriété, ou null si la propriété est introuvable
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
setStateField
public function setStateField(name:String, value:Any):Void
Modifie une propriété de l'état par son nom, en cherchant depuis la portée courante vers l'extérieur. Parcourt la pile d'exécution de la portée la plus interne vers la plus externe pour trouver la propriété, puis retombe sur l'état de premier niveau si elle est introuvable.
| Paramètre | Type | Description |
|---|---|---|
name |
String |
Le nom de la propriété à modifier |
value |
Any |
La nouvelle valeur |
Retourne
Void
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
getTopLevelStateField
public function getTopLevelStateField(name:String):Any
Renvoie directement une propriété de l'état de premier niveau.
| Paramètre | Type | Description |
|---|---|---|
name |
String |
Le nom de la propriété à lire |
Retourne
Any
La valeur de la propriété, ou null si la propriété n'existe pas
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
setTopLevelStateField
public function setTopLevelStateField(name:String, value:Any):Void
Modifie directement une propriété de l'état de premier niveau.
| Paramètre | Type | Description |
|---|---|---|
name |
String |
Le nom de la propriété à modifier |
value |
Any |
La nouvelle valeur |
Retourne
Void
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
currentNode
public function currentNode():AstNode
Renvoie le nœud en cours d'exécution. Pendant un callback de dialogue, renvoie le nœud de l'instruction de dialogue. Pendant un callback de choix, renvoie le nœud de l'instruction de choix.
Retourne
AstNode
Le nœud d'AST courant, ou null si aucun nœud n'est en cours d'exécution
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
currentNodeFilePath
public function currentNodeFilePath(rootPath:String):String
Renvoie le chemin du fichier qui contient le nœud courant. Utilise le Lens pour remonter les instructions d'import et calculer ce chemin à partir du chemin du fichier racine fourni.
| Paramètre | Type | Description |
|---|---|---|
rootPath |
String |
Le chemin du fichier du script racine |
Retourne
String
Le chemin du fichier contenant le nœud courant, ou rootPath si ce nœud est dans le fichier racine
JavaScript TypeScript Haxe
translations
public var translations:Null<Map<String, NStringLiteral>>
Dictionnaire de traductions optionnel (clé de localisation -> littéral de chaîne traduit). Quand il est renseigné, evaluateString() remplace le texte marqué par sa traduction.
Retourne
Null<Map<String, NStringLiteral>>
stringLiteralProcessors
public var stringLiteralProcessors:Array<(str:NStringLiteral)->NStringLiteral> = []
Processeurs à brancher, qui transforment les littéraux de chaîne avant leur évaluation. Chaque processeur reçoit un NStringLiteral et renvoie un NStringLiteral, éventuellement transformé.
Retourne
Array<(str:NStringLiteral)->NStringLiteral>
resolveBeatByName
public function resolveBeatByName(name:String, ?scopeLevel:Int = -1):Null<NBeatDecl>
Résout un beat par son nom en parcourant les portées telles qu'elles existent à l'EXÉCUTION (d'abord les beats imbriqués enregistrés, puis ceux de premier niveau). Utilisé uniquement en repli dans les contextes sans nœud (code de fonction, utilitaires du moteur) ; la résolution ancrée sur un nœud passe par resolveBeatRefFromNode (lexicale).
| Paramètre | Type | Description |
|---|---|---|
name |
String |
|
scopeLevel |
Int |
Retourne
Null<NBeatDecl>
resolveBeatRefByName
public function resolveBeatRefByName(name:String):Null<RuntimeBeatRef>
Résout un beat par son nom comme resolveBeatByName, mais construit aussi la chaîne de portées à capturer pour une référence de beat : le chemin de résolution depuis la racine jusqu'à la portée qui déclare le beat, incluse (vide pour les beats de premier niveau). Sert à créer des valeurs RuntimeBeatRef.
| Paramètre | Type | Description |
|---|---|---|
name |
String |
Retourne
Null<RuntimeBeatRef>
resolveBeatRefFromNode
public function resolveBeatRefFromNode(name:String, node:Node):Null<RuntimeBeatRef>
Résout un beat par son nom depuis la position LEXICALE du nœud donné, avec la même résolution que l'éditeur (Lens) : du beat englobant le plus interne vers l'extérieur, sans dépendre de l'ordre, les beats imbriqués masquant ceux de l'extérieur et de premier niveau. Quand la portée qui déclare le beat résolu est encore présente sur la pile, la référence renvoyée capture cette chaîne de portées (comme le font les références de beat), pour que le beat garde son contexte lexical quand il est appelé.
| Paramètre | Type | Description |
|---|---|---|
name |
String |
Le nom du beat à résoudre |
node |
Node |
Le nœud servant d'ancrage lexical (null dans les contextes sans nœud) |
Retourne
Null<RuntimeBeatRef>
Ne retombe sur le parcours des portées à l'exécution que lorsqu'aucun nœud n'est disponible (code de fonction et utilitaires du moteur).
Script
Représente le nœud racine de l'AST d'un script Loreline.
body
public var body:Array<AstNode>
Tableau des déclarations de premier niveau du script.
Retourne
Array<AstNode>
JavaScript TypeScript Haxe
filePath
public var filePath:String = null
Le chemin du fichier d'origine de ce script. Null si le script a été analysé sans chemin de fichier.
Retourne
String
JavaScript TypeScript Haxe
fromJson
public static function fromJson(json:Dynamic):Script
Reconstruit un Script depuis sa représentation JSON.
| Paramètre | Type | Description |
|---|---|---|
json |
Dynamic |
L'objet JSON (tel que renvoyé par script.toJson())
|
Retourne
Script
Le Script reconstruit
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
indentSize
public var indentSize:Int = 2
La taille d'indentation détectée dans la source (par exemple 2 ou 4 espaces).
Retourne
Int
new
public function new(id:NodeId, pos:Position, body:Array<AstNode>)
Crée un nouveau nœud racine de script.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
L'identifiant de nœud de ce script |
pos |
Position |
Position du début de ce script dans le code source |
body |
Array<AstNode> |
Tableau des déclarations de premier niveau |
eachExcludingImported
public function eachExcludingImported(handleNode:(node:Node, parent:Node)->Void):Void
| Paramètre | Type | Description |
|---|---|---|
handleNode |
(node:Node, parent:Node)->Void |
Retourne
Void
iterator
public function iterator():ScriptBodyIterator
Retourne
ScriptBodyIterator
Node
Classe de base de tous les nœuds de l'AST. Contient les informations de position et la conversion JSON de base.
id
public var id:NodeId = NodeId.UNDEFINED
Un identifiant unique pour ce nœud au sein de l'AST, qui permet de le distinguer des autres nœuds du script.
Retourne
NodeId
JavaScript TypeScript C# Java Haxe
pos
public var pos:Position
Position de ce nœud dans le code source.
Retourne
Position
JavaScript TypeScript Haxe
type
public function type():String
Renvoie le type de ce nœud.
Retourne
String
Le type du nœud, sous forme de chaîne
JavaScript TypeScript C# C++ Java PHP Python Lua Haxe
toJson
public override function toJson():Dynamic
Convertit le script en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant toutes les données du script
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
fromJson
public static function fromJson(json:Dynamic):Node
Reconstruit un nœud d'AST depuis sa représentation JSON.
| Paramètre | Type | Description |
|---|---|---|
json |
Dynamic |
L'objet JSON (tel que renvoyé par node.toJson())
|
Retourne
Node
Le Node reconstruit
JavaScript TypeScript C# Java PHP Python Lua Haxe
each
public function each(handleNode:(node:Node, parent:Node)->Void):Void
Parcourt tous les nœuds enfants de ce nœud.
| Paramètre | Type | Description |
|---|---|---|
handleNode |
(node:Node, parent:Node)->Void |
Fonction appelée pour chaque nœud enfant |
Retourne
Void
JavaScript TypeScript Haxe
new
public function new(id:NodeId, pos:Position)
Crée un nouveau nœud d'AST.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de ce nœud dans le code source |
toJson
public function toJson():Dynamic
Convertit le nœud en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant le type et la position du nœud
InterpreterOptions
Options de configuration du comportement de l'interpréteur Loreline
functions
public var functions:FunctionsMap = null
Dictionnaire optionnel de fonctions supplémentaires que le script pourra appeler
Retourne
FunctionsMap
JavaScript TypeScript C# GDScript C++ Java Haxe
strictAccess
public var strictAccess:Bool = false
Indique si l'accès est strict ou non. Si true, lire ou écrire une variable non définie lève une erreur.
Retourne
Bool
JavaScript TypeScript C# GDScript C++ Java Haxe
customCreateFields
public var customCreateFields:(interpreter:Interpreter, type:String, node:Node)->Any = null
Un instanciateur personnalisé pour les objets qui contiennent les propriétés.
Retourne
(interpreter:Interpreter, type:String, node:Node)->Any
JavaScript TypeScript C# Java Haxe
translations
public var translations:Map<String, NStringLiteral> = null
Dictionnaire de traductions optionnel (clé de localisation -> littéral de chaîne traduit). Construit par AstUtils.extractTranslations() à partir d'un fichier de traduction analysé.
Retourne
Map<String, NStringLiteral>
JavaScript TypeScript C# GDScript C++ Java Haxe
stringLiteralProcessors
public var stringLiteralProcessors:Array<(str:NStringLiteral)->NStringLiteral> = null
Processeurs de littéraux de chaîne personnalisés (optionnels), qui s'ajoutent au processeur intégré des pluriels avec |. Chaque processeur reçoit un NStringLiteral et renvoie un NStringLiteral (éventuellement transformé).
Retourne
Array<(str:NStringLiteral)->NStringLiteral>
ChoiceOption
Représente une option de choix présentée au joueur.
text
public var text:String
Le texte de l'option de choix.
Retourne
String
JavaScript TypeScript C# C++ Java PHP Python Haxe
tags
public var tags:Array<TextTag>
Les tags éventuellement associés au texte du choix.
Retourne
Array<TextTag>
JavaScript TypeScript C# C++ Java PHP Python Haxe
enabled
public var enabled:Bool
Indique si cette option de choix est actuellement activée.
Retourne
Bool
JavaScript TypeScript C# C++ Java PHP Python Haxe
TextTag
Représente un tag dans un contenu textuel, utilisable pour la mise en forme ou à d'autres fins.
closing
public var closing:Bool
Indique s'il s'agit d'un tag fermant.
Retourne
Bool
JavaScript TypeScript C# C++ Java PHP Python Haxe
value
public var value:String
La valeur ou le nom du tag.
Retourne
String
JavaScript TypeScript C# C++ Java PHP Python Haxe
offset
public var offset:Int
La position de ce tag dans le texte.
Retourne
Int
JavaScript TypeScript C# C++ Java PHP Python Haxe
DialogueHandler
typedef DialogueHandler = (interpreter:Interpreter, character:String, text:String, tags:Array<TextTag>, callback:()->Void)->VoidType de handler pour l'affichage de texte, avec callback. Appelé quand le script doit afficher du texte au joueur.
ChoiceHandler
typedef ChoiceHandler = (interpreter:Interpreter, options:Array<ChoiceOption>, callback:(index:Int)->Void)->VoidType de handler pour la présentation des choix, avec callback. Appelé quand le script doit présenter des choix au joueur.
FinishHandler
typedef FinishHandler = (interpreter:Interpreter)->VoidType de handler appelé quand l'exécution se termine.
FunctionsMap
typedef FunctionsMap = Map<String, Any>Dictionnaire qui associe des noms de fonctions à leur implémentation
NodeId
abstract NodeId(Int64)Représente un identifiant unique de nœud au sein de l'AST. Utilise un système d'identifiants structuré en section, branche, bloc et nœud.
toString
public function toString():String
Convertit le NodeId en représentation textuelle.
Retourne
String
Chaîne au format "section.branch.block.node"
JavaScript TypeScript C# Haxe
toInt64
public inline function toInt64():Int64
Convertit le NodeId en Int64.
Retourne
Int64
La valeur Int64 de ce NodeId
JavaScript TypeScript Haxe
UNDEFINED
public static final UNDEFINED:NodeId = new NodeId(0, 0, 0, 0)
Retourne
NodeId
new
public function new(section:Int, branch:Int, block:Int, node:Int)
| Paramètre | Type | Description |
|---|---|---|
section |
Int |
|
branch |
Int |
|
block |
Int |
|
node |
Int |
fromInt64
public static function fromInt64(value:Int64):NodeId
| Paramètre | Type | Description |
|---|---|---|
value |
Int64 |
Retourne
NodeId
fromString
public static function fromString(str:String):NodeId
| Paramètre | Type | Description |
|---|---|---|
str |
String |
Retourne
NodeId
fromTwoInt32
public static function fromTwoInt32(high:Int, low:Int):NodeId
| Paramètre | Type | Description |
|---|---|---|
high |
Int |
|
low |
Int |
Retourne
NodeId
section
public var section(get, set):Int
Retourne
Int
branch
public var branch(get, set):Int
Retourne
Int
block
public var block(get, set):Int
Retourne
Int
node
public var node(get, set):Int
Retourne
Int
nextSection
public function nextSection():NodeId
Retourne
NodeId
nextBranch
public function nextBranch():NodeId
Retourne
NodeId
nextBlock
public function nextBlock():NodeId
Retourne
NodeId
nextNode
public function nextNode():NodeId
Retourne
NodeId
Fields
Interface de base des objets qui contiennent des valeurs Loreline. Elle permet de relier les propriétés des objets Loreline à des objets propres au jeu.
lorelineCreate
function lorelineCreate(interpreter:Interpreter):Void
Appelé quand l'objet a été créé depuis un interpréteur
| Paramètre | Type | Description |
|---|---|---|
interpreter |
Interpreter |
Retourne
Void
JavaScript TypeScript C# Haxe
lorelineGet
function lorelineGet(interpreter:Interpreter, key:String):Any
Renvoie la valeur associée à la clé de propriété donnée
| Paramètre | Type | Description |
|---|---|---|
interpreter |
Interpreter |
|
key |
String |
Retourne
Any
JavaScript TypeScript C# Haxe
lorelineSet
function lorelineSet(interpreter:Interpreter, key:String, value:Any):Void
Modifie la valeur associée à la clé de propriété donnée
| Paramètre | Type | Description |
|---|---|---|
interpreter |
Interpreter |
|
key |
String |
|
value |
Any |
Retourne
Void
JavaScript TypeScript C# Haxe
lorelineExists
function lorelineExists(interpreter:Interpreter, key:String):Bool
Vérifie si une valeur existe pour la clé donnée
| Paramètre | Type | Description |
|---|---|---|
interpreter |
Interpreter |
|
key |
String |
Retourne
Bool
JavaScript TypeScript C# Haxe
lorelineFields
function lorelineFields(interpreter:Interpreter):Array<String>
Renvoie toutes les propriétés de cet objet
| Paramètre | Type | Description |
|---|---|---|
interpreter |
Interpreter |
Retourne
Array<String>
JavaScript TypeScript C# Haxe
lorelineRemove
function lorelineRemove(interpreter:Interpreter, key:String):Bool
Supprime la propriété associée à la clé donnée
| Paramètre | Type | Description |
|---|---|---|
interpreter |
Interpreter |
L'instance d'interpréteur |
key |
String |
La clé de la propriété à supprimer |
Retourne
Bool
True si la clé a été trouvée et supprimée, false sinon
C# Haxe
RuntimeState
Un état utilisé pendant l'exécution d'un script Loreline. Les états contiennent des valeurs de propriétés que l'on peut lire et modifier pendant l'exécution.
scope
public var scope:Int = -1
Si la valeur est > 0, cet état est temporaire et lié à une portée. Chaque entrée dans un nouveau nœud de bloc ouvre une nouvelle portée, identifiée par un entier unique. À la sortie de cette portée, les états temporaires associés sont détruits.
Retourne
Int
fields
public var fields(default, null):Any
Les propriétés de cet état. Contient les données réellement stockées.
Retourne
Any
originalFields
public var originalFields(default, null):Any
Les valeurs d'origine des propriétés, telles que déclarées dans le script, quand elles ne dépendent pas d'autres valeurs d'état. Servent de comparaison à la sérialisation, pour ne pas enregistrer les valeurs inchangées.
Retourne
Any
new
public function new(interpreter:Interpreter, node:Node, fields:Any, originalFields:Any)
Crée un nouvel état d'exécution, éventuellement avec des valeurs initiales pour ses propriétés.
| Paramètre | Type | Description |
|---|---|---|
interpreter |
Interpreter |
|
node |
Node |
|
fields |
Any |
Valeurs initiales des propriétés, ou null pour créer des propriétés vides |
originalFields |
Any |
Valeurs d'origine des propriétés pour la comparaison, ou null pour créer des propriétés d'origine vides |
clear
public function clear(interpreter:Interpreter, node:Node):Void
Supprime toutes les propriétés de cet état.
| Paramètre | Type | Description |
|---|---|---|
interpreter |
Interpreter |
|
node |
Node |
Retourne
Void
RuntimeCharacter
Variante d'état d'exécution réservée aux personnages. Les personnages sont des entités particulières des scripts Loreline : ils peuvent avoir leurs propres propriétés et être désignés dans les instructions de dialogue.
new
public function new(interpreter:Interpreter, node:AstNode, fields:Any, originalFields:Any)
Crée un nouvel état d'exécution de personnage, éventuellement avec des valeurs initiales pour ses propriétés.
| Paramètre | Type | Description |
|---|---|---|
interpreter |
Interpreter |
|
node |
AstNode |
|
fields |
Any |
|
originalFields |
Any |
RuntimeAccess
Représente les différentes manières d'accéder aux valeurs d'exécution d'un script Loreline. Utilisé en interne par l'interpréteur pour résoudre les accès aux variables et aux tableaux, les références aux personnages et les appels de fonctions.
FieldAccess
FieldAccess(pos:Position, obj:Any, name:String)
Représente l'accès à une propriété d'un objet.
| Paramètre | Type | Description |
|---|---|---|
pos |
Position |
Position de cet accès dans le code source |
obj |
Any |
L'objet auquel on accède |
name |
String |
Le nom de la propriété à laquelle accéder |
ArrayAccess
ArrayAccess(pos:Position, array:Any, index:Int)
Représente l'accès à un élément de tableau par son indice.
| Paramètre | Type | Description |
|---|---|---|
pos |
Position |
Position de cet accès dans le code source |
array |
Any |
Le tableau auquel on accède |
index |
Int |
L'indice dans le tableau |
CharacterAccess
CharacterAccess(pos:Position, name:String)
Représente l'accès à un personnage par son nom.
| Paramètre | Type | Description |
|---|---|---|
pos |
Position |
Position de cet accès dans le code source |
name |
String |
Le nom du personnage auquel accéder |
FunctionAccess
FunctionAccess(pos:Position, name:String)
Représente l'accès à une fonction intégrée ou définie par l'utilisateur.
| Paramètre | Type | Description |
|---|---|---|
pos |
Position |
Position de cet accès dans le code source |
name |
String |
Le nom de la fonction à laquelle accéder |
BeatAccess
BeatAccess(pos:Position, ref:RuntimeBeatRef)
Représente une référence de beat résolue par son nom.
| Paramètre | Type | Description |
|---|---|---|
pos |
Position |
Position de cet accès dans le code source |
ref |
RuntimeBeatRef |
RuntimeScope
Représente une portée dans la pile d'exécution d'un script Loreline. Chaque entrée dans un nouveau nœud de bloc ouvre une nouvelle portée, identifiée par un entier unique. À la sortie de cette portée, les états temporaires qui lui sont associés sont détruits.
id
public var id:Int = -1
L'identifiant de la portée, un entier unique dans la pile.
Retourne
Int
beat
public var beat:NBeatDecl
Le beat parent où se trouve cette portée. Peut être un beat de premier niveau ou un beat imbriqué.
Retourne
NBeatDecl
node
public var node:AstNode
Le nœud auquel cette portée est attachée.
Retourne
AstNode
beats
public var beats:Array<NBeatDecl> = null
Les déclarations de beats imbriqués trouvées dans cette portée, s'il y en a.
Retourne
Array<NBeatDecl>
state
public var state:RuntimeState = null
L'état temporaire associé à cette portée, s'il y en a un.
Retourne
RuntimeState
head
public var head:AstNode = null
Le cas échéant, le nœud où se trouve la "tête de lecture" de cette portée. Sert à suivre la position d'exécution courante dans la portée.
Retourne
AstNode
insertion
public var insertion:RuntimeInsertion = null
Les données d'exécution de l'insertion qui a créé cette portée, s'il y en a une.
Retourne
RuntimeInsertion
captured
public var captured:Array<RuntimeScope> = null
La chaîne de portées capturée à la création de la référence (fermeture), quand cette portée exécute un beat appelé par une référence de beat. La résolution des noms dans cette portée parcourt cette chaîne au lieu des portées situées en dessous dans la pile, puis saute au premier niveau.
Retourne
Array<RuntimeScope>
beatByName
public function beatByName(name:String):Null<NBeatDecl>
Cherche dans cette portée une déclaration de beat imbriqué portant le nom donné.
| Paramètre | Type | Description |
|---|---|---|
name |
String |
Le nom du beat recherché |
Retourne
Null<NBeatDecl>
La déclaration de beat si elle est trouvée, null sinon
RuntimeBeatRef
Une référence de beat de première classe : le beat, accompagné de la chaîne de portées capturée là où la référence a été créée (de la racine jusqu'à la portée qui déclare le beat incluse ; vide pour les beats de premier niveau). Produite chaque fois qu'une expression lit un identifiant qui se résout en un beat.
beat
public var beat(default, null):NBeatDecl
La déclaration de beat référencée.
Retourne
NBeatDecl
stack
public var stack(default, null):Array<RuntimeScope>
La chaîne de portées capturée (fermeture). Vide pour les beats de premier niveau.
Retourne
Array<RuntimeScope>
new
public function new(beat:NBeatDecl, stack:Array<RuntimeScope>)
| Paramètre | Type | Description |
|---|---|---|
beat |
NBeatDecl |
|
stack |
Array<RuntimeScope> |
beatOf
public static function beatOf(value:Any):Null<NBeatDecl>
Renvoie le beat sous-jacent si la valeur d'exécution donnée est une déclaration ou une référence de beat, null sinon.
| Paramètre | Type | Description |
|---|---|---|
value |
Any |
Retourne
Null<NBeatDecl>
beatNameOf
public static function beatNameOf(value:Any):Null<String>
Renvoie le nom du beat si la valeur d'exécution donnée est une déclaration ou une référence de beat, null sinon. Utilisé par les bindings hôtes : côté hôte, un beat est représenté par son nom.
| Paramètre | Type | Description |
|---|---|---|
value |
Any |
Retourne
Null<String>
RuntimeInsertion
Données à conserver avec une portée quand un beat est inséré dans un choix
id
public var id:Int
L'identifiant de l'insertion, un entier unique parmi toutes les insertions.
Retourne
Int
origin
public var origin:NInsertion
Le nœud à l'origine de cette insertion
Retourne
NInsertion
options
public var options:Array<ChoiceOption> = null
Les options de choix insérées, ou null si rien n'est encore inséré
Retourne
Array<ChoiceOption>
stack
public var stack:Array<RuntimeScope> = []
La pile d'appels de cette insertion, qui sert à reprendre l'exécution au bon endroit quand une de ses options est choisie
Retourne
Array<RuntimeScope>
parentPartialOptions
public var parentPartialOptions:Array<ChoiceOption> = null
Copie des options de choix collectées pour le choix parent AVANT que cette insertion commence son évaluation. Sert à la sauvegarde et à la restauration pendant la phase 1, pour que celle-ci reprenne sans réexécuter les insertions précédentes.
Retourne
Array<ChoiceOption>
parentNextOptionIndex
public var parentNextOptionIndex:Int = 0
L'indice de la prochaine option dans le choix parent après cette insertion. Utilisé avec parentPartialOptions pour reprendre la phase 1 à la bonne position après une restauration.
Retourne
Int
new
public function new(id:Int, origin:NInsertion)
| Paramètre | Type | Description |
|---|---|---|
id |
Int |
|
origin |
NInsertion |
RuntimeError
Erreur pouvant survenir pendant l'exécution d'un script.
new
public function new(message:String, ?pos:Position)
| Paramètre | Type | Description |
|---|---|---|
message |
String |
|
pos |
Position |
EvalNext
Classe utilitaire pour gérer l'étape d'évaluation suivante. Sert à décider si cette étape s'exécute de façon synchrone ou asynchrone.
sync
public var sync:Bool = true
Indique si l'étape suivante doit s'exécuter de façon synchrone.
Retourne
Bool
cb
public var cb:()->Void = null
Le callback à exécuter pour l'étape suivante.
Retourne
()->Void
new
public function new()
Crée une nouvelle instance d'EvalNext.
NodeIdStep
enum abstract NodeIdStep(Int)SECTION
SECTION = 1
Retourne
NodeIdStep
BRANCH
BRANCH = 2
Retourne
NodeIdStep
BLOCK
BLOCK = 3
Retourne
NodeIdStep
NODE
NODE = 4
Retourne
NodeIdStep
NodeIdMap
new
public inline function new()
get
public inline function get(key:NodeId):Null<V>
| Paramètre | Type | Description |
|---|---|---|
key |
NodeId |
Retourne
Null<V>
set
public inline function set(key:NodeId, value:V):Void
| Paramètre | Type | Description |
|---|---|---|
key |
NodeId |
|
value |
V |
Retourne
Void
remove
public inline function remove(key:NodeId):Void
| Paramètre | Type | Description |
|---|---|---|
key |
NodeId |
Retourne
Void
exists
public inline function exists(key:NodeId):Bool
| Paramètre | Type | Description |
|---|---|---|
key |
NodeId |
Retourne
Bool
clear
public inline function clear():Void
Retourne
Void
iterator
public inline function iterator():NodeIdMapIterator<V>
Retourne
NodeIdMapIterator<V>
keys
public inline function keys():NodeIdMapKeyIterator<V>
Retourne
NodeIdMapKeyIterator<V>
keyValueIterator
public inline function keyValueIterator():NodeIdMapKeyValueIterator<V>
Retourne
NodeIdMapKeyValueIterator<V>
NodeIdMapKeyVal
typedef NodeIdMapKeyVal<V> = { value:V, key:NodeId }Comment
Représente un nœud de commentaire dans l'AST. Contient le texte du commentaire et indique s'il est multiligne.
content
public var content:String
Le texte du commentaire.
Retourne
String
multiline
public var multiline:Bool
Indique s'il s'agit d'un commentaire sur plusieurs lignes (/* ... */) ou sur une seule ligne (//).
Retourne
Bool
isHash
public var isHash:Bool
Indique s'il s'agit d'un tag de traduction (#identifiant).
Retourne
Bool
new
public function new(id:NodeId, pos:Position, content:String, multiline:Bool, ?isHash:Bool = false)
Crée un nouveau nœud de commentaire.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de ce commentaire dans le code source |
content |
String |
Le texte du commentaire |
multiline |
Bool |
Indique s'il s'agit d'un commentaire sur plusieurs lignes |
isHash |
Bool |
Indique s'il s'agit d'un tag de traduction |
toJson
public override function toJson():Dynamic
Convertit le nœud de commentaire en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données du commentaire
AstNode
Classe de base des nœuds d'AST pouvant porter des commentaires. Étend Node avec la prise en charge des commentaires avant et après.
leadingComments
public var leadingComments:Null<Array<Comment>>
Commentaires qui précèdent ce nœud.
Retourne
Null<Array<Comment>>
trailingComments
public var trailingComments:Null<Array<Comment>>
Commentaires qui suivent ce nœud.
Retourne
Null<Array<Comment>>
new
public function new(id:NodeId, pos:Position, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud acceptant des commentaires.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de ce nœud dans le code source |
leadingComments |
Array<Comment> |
Tableau optionnel des commentaires précédant le nœud |
trailingComments |
Array<Comment> |
Tableau optionnel des commentaires suivant le nœud |
eachComment
public function eachComment(handleComment:(node:AstNode, comment:Comment)->Void):Void
| Paramètre | Type | Description |
|---|---|---|
handleComment |
(node:AstNode, comment:Comment)->Void |
Retourne
Void
toJson
public override function toJson():Dynamic
Convertit le nœud et ses commentaires en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données du nœud et ses commentaires
NExpr
Classe de base de tous les nœuds d'expression de l'AST.
new
public function new(id:NodeId, pos:Position, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
|
leadingComments |
Array<Comment> |
|
trailingComments |
Array<Comment> |
toJson
public override function toJson():Dynamic
Convertit le nœud d'expression en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données de l'expression
NStateDecl
Représente un nœud de déclaration d'état dans l'AST. Un état est soit temporaire (new state), soit permanent (state).
temporary
public var temporary:Bool
Indique si cet état est temporaire (déclaré avec new state).
Retourne
Bool
fields
public var fields:Array<NObjectField>
Propriétés définies pour cet état.
Retourne
Array<NObjectField>
style
public var style:BlockStyle
Style de bloc de cet état
Retourne
BlockStyle
new
public function new(id:NodeId, pos:Position, temporary:Bool, fields:Array<NObjectField>, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud de déclaration d'état.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de cet état dans le code source |
temporary |
Bool |
Indique s'il s'agit d'un état temporaire |
fields |
Array<NObjectField> |
Tableau des définitions de propriétés |
leadingComments |
Array<Comment> |
Commentaires optionnels avant l'état |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'état |
get
public function get(name:String):NExpr
| Paramètre | Type | Description |
|---|---|---|
name |
String |
Retourne
NExpr
toJson
public override function toJson():Dynamic
Convertit la déclaration d'état en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données de l'état
NObjectField
Représente une propriété de dictionnaire dans l'AST (paire nom-valeur).
name
public var name:String
Nom de la propriété.
Retourne
String
value
public var value:NExpr
Expression de la valeur de la propriété.
Retourne
NExpr
new
public function new(id:NodeId, pos:Position, name:String, value:NExpr, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud de propriété de dictionnaire.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de cette propriété dans le code source |
name |
String |
Nom de la propriété |
value |
NExpr |
Expression de la valeur de la propriété |
leadingComments |
Array<Comment> |
Commentaires optionnels avant la propriété |
trailingComments |
Array<Comment> |
Commentaires optionnels après la propriété |
toJson
public override function toJson():Dynamic
Convertit la propriété de dictionnaire en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données de la propriété
NCharacterDecl
Représente une déclaration de personnage dans l'AST.
name
public var name:String
Nom du personnage.
Retourne
String
namePos
public var namePos:Position
Position du nom du personnage.
Retourne
Position
fields
public var fields:Array<NObjectField>
Propriétés définies pour ce personnage.
Retourne
Array<NObjectField>
style
public var style:BlockStyle
Style de bloc de ce personnage
Retourne
BlockStyle
new
public function new(id:NodeId, pos:Position, name:String, namePos:Position, fields:Array<NObjectField>, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud de déclaration de personnage.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de la déclaration de ce personnage dans le code source |
name |
String |
Nom du personnage |
namePos |
Position |
|
fields |
Array<NObjectField> |
Tableau des définitions de propriétés |
leadingComments |
Array<Comment> |
Commentaires optionnels avant le personnage |
trailingComments |
Array<Comment> |
Commentaires optionnels après le personnage |
get
public function get(name:String):NExpr
| Paramètre | Type | Description |
|---|---|---|
name |
String |
Retourne
NExpr
toJson
public override function toJson():Dynamic
Convertit la déclaration de personnage en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données du personnage
NBeatParam
Un paramètre d'une déclaration de beat, par exemple name ou mood = "happy" dans beat Greet(name, mood = "happy").
name
public var name:String
Nom du paramètre.
Retourne
String
namePos
public var namePos:Position
Position du nom du paramètre dans le code source.
Retourne
Position
defaultValue
public var defaultValue:Null<NExpr>
Expression optionnelle de la valeur par défaut, évaluée quand aucun argument n'est fourni.
Retourne
Null<NExpr>
new
public function new(name:String, namePos:Position, ?defaultValue:NExpr)
| Paramètre | Type | Description |
|---|---|---|
name |
String |
|
namePos |
Position |
|
defaultValue |
NExpr |
toJson
public function toJson():Dynamic
Retourne
Dynamic
NBeatDecl
Représente une déclaration de beat (scène) dans l'AST.
name
public var name:String
Nom du beat.
Retourne
String
body
public var body:Array<AstNode>
Tableau des nœuds qui composent le contenu du beat.
Retourne
Array<AstNode>
style
public var style:BlockStyle
Style de bloc de ce beat
Retourne
BlockStyle
params
public var params:Null<Array<NBeatParam>> = null
Paramètres de ce beat, s'il en a (null quand la déclaration n'a pas de parenthèses). À l'exécution, ils deviennent des propriétés temporaires de l'état, limitées au beat.
Retourne
Null<Array<NBeatParam>>
new
public function new(id:NodeId, pos:Position, name:String, body:Array<AstNode>, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud de déclaration de beat.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de ce beat dans le code source |
name |
String |
Nom du beat |
body |
Array<AstNode> |
Tableau des nœuds composant le contenu du beat |
leadingComments |
Array<Comment> |
Commentaires optionnels avant le beat |
trailingComments |
Array<Comment> |
Commentaires optionnels après le beat |
toJson
public override function toJson():Dynamic
Convertit la déclaration de beat en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données du beat
StringPartType
Représente les différents types de parties pouvant apparaître dans un littéral de chaîne.
Raw
Raw(text:String)
Texte brut.
| Paramètre | Type | Description |
|---|---|---|
text |
String |
Expr
Expr(expr:NExpr)
Expression interpolée (${...} ou $identifiant).
| Paramètre | Type | Description |
|---|---|---|
expr |
NExpr |
Tag
Tag(closing:Bool, expr:NStringLiteral)
Tag de mise en forme du texte (
| Paramètre | Type | Description |
|---|---|---|
closing |
Bool |
|
expr |
NStringLiteral |
BlockStyle
enum abstract BlockStyle(Int)Plain
Plain = 0
Retourne
BlockStyle
Braces
Braces = 1
Retourne
BlockStyle
toString
public function toString():String
Retourne
String
ConditionStyle
enum abstract ConditionStyle(Int)Plain
Plain = 0
Retourne
ConditionStyle
Parens
Parens = 2
Retourne
ConditionStyle
toString
public function toString():String
Retourne
String
AlternativeMode
enum abstract AlternativeMode(Int)Représente le mode d'un bloc d'alternatives.
Sequence
Sequence = 0
Retourne
AlternativeMode
Cycle
Cycle = 1
Retourne
AlternativeMode
Once
Once = 2
Retourne
AlternativeMode
Pick
Pick = 3
Retourne
AlternativeMode
Shuffle
Shuffle = 4
Retourne
AlternativeMode
toString
public function toString():String
Retourne
String
NStringPart
Représente une partie pouvant apparaître dans un littéral de chaîne.
partType
public var partType:StringPartType
Le type de la partie de chaîne
Retourne
StringPartType
new
public function new(id:NodeId, pos:Position, partType:StringPartType, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud de partie de chaîne.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de cette partie de chaîne dans le code source |
partType |
StringPartType |
|
leadingComments |
Array<Comment> |
Commentaires optionnels avant la chaîne |
trailingComments |
Array<Comment> |
Commentaires optionnels après la chaîne |
toJson
public override function toJson():Dynamic
Convertit la partie de chaîne en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données de la partie de chaîne
NStringLiteral
Représente un littéral de chaîne dans l'AST, avec prise en charge de l'interpolation et des tags.
parts
public var parts:Array<NStringPart>
Tableau des parties qui composent ce littéral de chaîne.
Retourne
Array<NStringPart>
quotes
public var quotes:Quotes
Le type de guillemets utilisé pour ce littéral de chaîne
Retourne
Quotes
new
public function new(id:NodeId, pos:Position, quotes:Quotes, parts:Array<NStringPart>, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud de littéral de chaîne.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de cette chaîne dans le code source |
quotes |
Quotes |
|
parts |
Array<NStringPart> |
Tableau des parties de chaîne (texte brut, interpolations et tags) |
leadingComments |
Array<Comment> |
Commentaires optionnels avant la chaîne |
trailingComments |
Array<Comment> |
Commentaires optionnels après la chaîne |
toJson
public override function toJson():Dynamic
Convertit le littéral de chaîne en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données de la chaîne et ses parties
NTextStatement
Représente une instruction de texte dans l'AST.
content
public var content:NStringLiteral
Le contenu de l'instruction de texte.
Retourne
NStringLiteral
condition
public var condition:Null<NExpr>
Condition optionnelle qui doit être vraie pour que ce texte s'affiche.
Retourne
Null<NExpr>
conditionStyle
public var conditionStyle:ConditionStyle
Le style de la condition (sans parenthèses ou entre parenthèses).
Retourne
ConditionStyle
conditionPos
public var conditionPos:Null<Position>
Position de la clause "if condition" en fin de ligne (du mot-clé if à la fin de la condition).
Retourne
Null<Position>
new
public function new(id:NodeId, pos:Position, content:NStringLiteral, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud d'instruction de texte.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de ce texte dans le code source |
content |
NStringLiteral |
Littéral de chaîne contenant le texte |
leadingComments |
Array<Comment> |
Commentaires optionnels avant le texte |
trailingComments |
Array<Comment> |
Commentaires optionnels après le texte |
toJson
public override function toJson():Dynamic
Convertit l'instruction de texte en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données du texte
NDialogueStatement
Représente une instruction de dialogue dans l'AST (personnage: "texte").
character
public var character:String
Nom du personnage qui parle.
Retourne
String
characterPos
public var characterPos:Position
Position du nom du personnage
Retourne
Position
content
public var content:NStringLiteral
Contenu de la réplique.
Retourne
NStringLiteral
condition
public var condition:Null<NExpr>
Condition optionnelle qui doit être vraie pour que cette réplique s'affiche.
Retourne
Null<NExpr>
conditionStyle
public var conditionStyle:ConditionStyle
Le style de la condition (sans parenthèses ou entre parenthèses).
Retourne
ConditionStyle
conditionPos
public var conditionPos:Null<Position>
Position de la clause "if condition" en fin de ligne (du mot-clé if à la fin de la condition).
Retourne
Null<Position>
new
public function new(id:NodeId, pos:Position, character:String, characterPos:Position, content:NStringLiteral, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud d'instruction de dialogue.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de cette réplique dans le code source |
character |
String |
Nom du personnage qui parle |
characterPos |
Position |
Position du nom du personnage |
content |
NStringLiteral |
Littéral de chaîne contenant le texte de la réplique |
leadingComments |
Array<Comment> |
Commentaires optionnels avant la réplique |
trailingComments |
Array<Comment> |
Commentaires optionnels après la réplique |
toJson
public override function toJson():Dynamic
Convertit l'instruction de dialogue en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données du dialogue
NChoiceStatement
Représente une instruction de choix dans l'AST.
options
public var options:Array<NChoiceOption>
Tableau des options disponibles dans ce choix.
Retourne
Array<NChoiceOption>
style
public var style:BlockStyle
Le style de bloc de l'instruction de choix
Retourne
BlockStyle
new
public function new(id:NodeId, pos:Position, options:Array<NChoiceOption>, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud d'instruction de choix.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de ce choix dans le code source |
options |
Array<NChoiceOption> |
Tableau des options de choix disponibles |
leadingComments |
Array<Comment> |
Commentaires optionnels avant le choix |
trailingComments |
Array<Comment> |
Commentaires optionnels après le choix |
toJson
public override function toJson():Dynamic
Convertit l'instruction de choix en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données du choix
NChoiceOption
Représente une option au sein d'une instruction de choix.
text
public var text:NStringLiteral
Le texte affiché pour cette option.
Retourne
NStringLiteral
insertion
public var insertion:NInsertion
Insertion utilisée à la place du texte, le cas échéant.
Retourne
NInsertion
condition
public var condition:Null<NExpr>
Condition optionnelle qui doit être vraie pour que cette option soit disponible.
Retourne
Null<NExpr>
conditionStyle
public var conditionStyle:ConditionStyle
Le style de la condition (sans parenthèses ou entre parenthèses).
Retourne
ConditionStyle
conditionPos
public var conditionPos:Null<Position>
Position de la clause "if condition" en fin de ligne (du mot-clé if à la fin de la condition).
Retourne
Null<Position>
body
public var body:Array<AstNode>
Tableau des nœuds à exécuter quand cette option est choisie.
Retourne
Array<AstNode>
style
public var style:BlockStyle
Le style de bloc du corps
Retourne
BlockStyle
once
public var once:Bool
Indique si cette option ne peut être choisie qu'une fois (elle disparaît après sélection).
Retourne
Bool
new
public function new(id:NodeId, pos:Position, text:NStringLiteral, insertion:NInsertion, condition:Null<NExpr>, conditionStyle:ConditionStyle, body:Array<AstNode>, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud d'option de choix.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de cette option dans le code source |
text |
NStringLiteral |
Littéral de chaîne contenant le texte de l'option |
insertion |
NInsertion |
|
condition |
Null<NExpr> |
Condition optionnelle pour que l'option soit disponible |
conditionStyle |
ConditionStyle |
Le style de la condition (sans parenthèses ou entre parenthèses) |
body |
Array<AstNode> |
Tableau des nœuds à exécuter quand l'option est choisie |
leadingComments |
Array<Comment> |
Commentaires optionnels avant l'option |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'option |
toJson
public override function toJson():Dynamic
Convertit l'option de choix en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données de l'option
NBlock
Représente un bloc contenant une séquence de nœuds.
body
public var body:Array<AstNode>
Tableau des nœuds qui composent le contenu du beat.
Retourne
Array<AstNode>
style
public var style:BlockStyle
Le style de bloc du corps.
Retourne
BlockStyle
new
public function new(id:NodeId, pos:Position, body:Array<AstNode>, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud de bloc.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de ce beat dans le code source |
body |
Array<AstNode> |
Tableau des nœuds composant le contenu du bloc |
leadingComments |
Array<Comment> |
Commentaires optionnels avant le beat |
trailingComments |
Array<Comment> |
Commentaires optionnels après le beat |
toJson
public override function toJson():Dynamic
Convertit la déclaration de beat en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données du beat
NIfStatement
Représente une instruction if dans l'AST, avec une branche else optionnelle.
condition
public var condition:NExpr
La condition à évaluer.
Retourne
NExpr
conditionStyle
public var conditionStyle:ConditionStyle
Le style de la condition (sans parenthèses ou entre parenthèses).
Retourne
ConditionStyle
thenBranch
public var thenBranch:NBlock
Tableau des nœuds à exécuter si la condition est vraie.
Retourne
NBlock
elseBranch
public var elseBranch:Null<NBlock>
Tableau optionnel des nœuds à exécuter si la condition est fausse.
Retourne
Null<NBlock>
elseLeadingComments
public var elseLeadingComments:Null<Array<Comment>>
Commentaires qui précèdent le mot-clé else.
Retourne
Null<Array<Comment>>
elseTrailingComments
public var elseTrailingComments:Null<Array<Comment>>
Commentaires qui suivent le mot-clé else.
Retourne
Null<Array<Comment>>
new
public function new(id:NodeId, pos:Position, condition:NExpr, conditionStyle:ConditionStyle, thenBranch:NBlock, elseBranch:Null<NBlock>, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>, ?elseLeadingComments:Array<Comment>, ?elseTrailingComments:Array<Comment>)
Crée un nouveau nœud d'instruction if.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de cette instruction if dans le code source
|
condition |
NExpr |
Expression à évaluer |
conditionStyle |
ConditionStyle |
Le style de la condition (sans parenthèses ou entre parenthèses) |
thenBranch |
NBlock |
Nœuds à exécuter si la condition est vraie |
elseBranch |
Null<NBlock> |
Nœuds à exécuter si la condition est fausse (optionnel) |
leadingComments |
Array<Comment> |
Commentaires optionnels avant le if
|
trailingComments |
Array<Comment> |
Commentaires optionnels après le if
|
elseLeadingComments |
Array<Comment> |
Commentaires optionnels avant le else
|
elseTrailingComments |
Array<Comment> |
Commentaires optionnels après le else
|
toJson
public override function toJson():Dynamic
Convertit l'instruction if en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données de l'instruction if
NAlternative
Représente un bloc d'alternatives (sequence, cycle, once, pick, shuffle).
mode
public var mode:AlternativeMode
Le mode de l'alternative (sequence, cycle, once, pick, shuffle).
Retourne
AlternativeMode
items
public var items:Array<NBlock>
Tableau des éléments de l'alternative. Chaque élément est un bloc d'instructions.
Retourne
Array<NBlock>
style
public var style:BlockStyle
Le style de bloc (indenté ou entre accolades).
Retourne
BlockStyle
separatorComments
public var separatorComments:Null<Array<Array<Comment>>>
Commentaires qui précèdent les séparateurs.
Retourne
Null<Array<Array<Comment>>>
new
public function new(id:NodeId, pos:Position, mode:AlternativeMode, items:Array<NBlock>, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud de bloc d'alternatives.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
L'identifiant du nœud |
pos |
Position |
Position de cette alternative dans le code source |
mode |
AlternativeMode |
Le mode de l'alternative |
items |
Array<NBlock> |
Tableau des éléments de l'alternative |
leadingComments |
Array<Comment> |
Commentaires optionnels avant l'alternative |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'alternative |
toJson
public override function toJson():Dynamic
Convertit le bloc d'alternatives en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données de l'alternative
NCall
Représente une expression d'appel de fonction dans l'AST.
target
public var target:NExpr
L'expression appelée.
Retourne
NExpr
args
public var args:Array<NExpr>
Tableau des expressions passées en arguments à l'appel.
Retourne
Array<NExpr>
new
public function new(id:NodeId, pos:Position, target:NExpr, args:Array<NExpr>, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud d'expression d'appel.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de cet appel dans le code source |
target |
NExpr |
Expression appelée |
args |
Array<NExpr> |
Tableau des expressions passées en arguments |
leadingComments |
Array<Comment> |
Commentaires optionnels avant l'appel |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'appel |
toJson
public override function toJson():Dynamic
Convertit l'expression d'appel en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données de l'appel
NTransition
Représente une transition vers un autre beat (->).
target
public var target:String
Nom du beat cible (null quand la cible est dynamique, voir targetExpr).
Retourne
String
targetPos
public var targetPos:Position
Position de la cible dans la transition
Retourne
Position
targetExpr
public var targetExpr:Null<NExpr> = null
Expression de la cible dynamique, issue de la forme -> beat(expr). Quand elle est définie, target vaut null et l'expression est résolue à l'exécution.
Retourne
Null<NExpr>
args
public var args:Null<Array<NExpr>> = null
Arguments optionnels passés au beat cible, issus de -> SomeBeat(args...) ou -> beat(expr, args...).
Retourne
Null<Array<NExpr>>
new
public function new(id:NodeId, pos:Position, target:String, targetPos:Position, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud de transition.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de cette transition dans le code source |
target |
String |
Nom du beat cible |
targetPos |
Position |
Position de la cible dans la transition |
leadingComments |
Array<Comment> |
Commentaires optionnels avant la transition |
trailingComments |
Array<Comment> |
Commentaires optionnels après la transition |
toJson
public override function toJson():Dynamic
Convertit la transition en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données de la transition
NInsertion
Représente l'insertion d'un autre beat (+).
target
public var target:String
Nom du beat cible (null quand la cible est dynamique, voir targetExpr).
Retourne
String
targetPos
public var targetPos:Position
Position de la cible dans l'insertion
Retourne
Position
targetExpr
public var targetExpr:Null<NExpr> = null
Expression de la cible dynamique, issue de la forme + beat(expr). Quand elle est définie, target vaut null et l'expression est résolue à l'exécution.
Retourne
Null<NExpr>
args
public var args:Null<Array<NExpr>> = null
Arguments optionnels passés au beat cible, issus de + SomeBeat(args...) ou + beat(expr, args...).
Retourne
Null<Array<NExpr>>
new
public function new(id:NodeId, pos:Position, target:String, targetPos:Position, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud d'insertion.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de cette insertion dans le code source |
target |
String |
Nom du beat cible |
targetPos |
Position |
Position de la cible dans l'insertion |
leadingComments |
Array<Comment> |
Commentaires optionnels avant l'insertion |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'insertion |
toJson
public override function toJson():Dynamic
Convertit l'insertion en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données de l'insertion
NBeatCall
Représente une instruction d'appel de beat dynamique : beat(expr, args...). La cible est résolue à l'exécution, puis le beat est exécuté comme un appel qui conserve la pile (comme un appel statique SomeBeat(args...)).
targetExpr
public var targetExpr:NExpr
Expression de cible, résolue à l'exécution en un beat (un nom sous forme de chaîne, une valeur de beat ou une référence de beat).
Retourne
NExpr
targetPos
public var targetPos:Position
Position de la partie cible beat(...).
Retourne
Position
args
public var args:Null<Array<NExpr>> = null
Arguments optionnels passés au beat cible.
Retourne
Null<Array<NExpr>>
new
public function new(id:NodeId, pos:Position, targetExpr:NExpr, targetPos:Position, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud d'appel de beat dynamique.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de cet appel dans le code source |
targetExpr |
NExpr |
Expression qui se résout en beat cible |
targetPos |
Position |
Position de la cible |
leadingComments |
Array<Comment> |
Commentaires optionnels avant l'appel |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'appel |
toJson
public override function toJson():Dynamic
Convertit l'appel de beat en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données de l'appel de beat
NFunctionDecl
Représente une fonction appelable dans l'AST.
name
public var name:Null<String>
Le nom de la fonction (s'il y en a un)
Retourne
Null<String>
args
public var args:Array<String>
Noms des arguments
Retourne
Array<String>
code
public var code:String
Le code de la fonction (signature comprise)
Retourne
String
external
public var external:Bool
Indique s'il s'agit d'une fonction externe (donc d'une simple déclaration sans implémentation)
Retourne
Bool
new
public function new(id:NodeId, pos:Position, name:Null<String>, args:Array<String>, code:String, external:Bool, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud de fonction.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de cette fonction dans le code source |
name |
Null<String> |
Le nom de la fonction (s'il y en a un) |
args |
Array<String> |
Noms des arguments |
code |
String |
Le code de la fonction (signature comprise) |
external |
Bool |
Indique s'il s'agit d'une fonction externe (donc d'une simple déclaration sans implémentation) |
leadingComments |
Array<Comment> |
Commentaires optionnels avant la fonction |
trailingComments |
Array<Comment> |
Commentaires optionnels après la fonction |
toJson
public override function toJson():Dynamic
Convertit le littéral en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données du littéral
NLiteral
Représente les valeurs littérales dans l'AST (nombres, booléens, tableaux, dictionnaires).
value
public var value:Any
La valeur littérale.
Retourne
Any
literalType
public var literalType:LiteralType
Type de la valeur littérale.
Retourne
LiteralType
new
public function new(id:NodeId, pos:Position, value:Any, literalType:LiteralType, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud de littéral.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de ce littéral dans le code source |
value |
Any |
La valeur littérale |
literalType |
LiteralType |
|
leadingComments |
Array<Comment> |
Commentaires optionnels avant le littéral |
trailingComments |
Array<Comment> |
Commentaires optionnels après le littéral |
toJson
public override function toJson():Dynamic
Convertit le littéral en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données du littéral
LiteralType
Types possibles des valeurs littérales.
Number
Number
Littéral numérique
Boolean
Boolean
Littéral booléen
Null
Null
Littéral null
Array
Array
Littéral de tableau
Object
Object(style:BlockStyle)
Littéral de dictionnaire
| Paramètre | Type | Description |
|---|---|---|
style |
BlockStyle |
NAccess
Représente une expression d'accès à une propriété (obj.field).
target
public var target:Null<NExpr>
Objet cible de l'accès (optionnel).
Retourne
Null<NExpr>
name
public var name:String
Nom de la propriété à laquelle on accède.
Retourne
String
new
public function new(id:NodeId, pos:Position, target:Null<NExpr>, name:String, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud d'accès à une propriété.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de cet accès dans le code source |
target |
Null<NExpr> |
Expression optionnelle de l'objet cible |
name |
String |
Nom de la propriété à laquelle on accède |
leadingComments |
Array<Comment> |
Commentaires optionnels avant l'accès |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'accès |
toJson
public override function toJson():Dynamic
Convertit l'accès à la propriété en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données de l'accès
NAssign
Représente une expression d'affectation (a = b, a += b, etc.).
target
public var target:NExpr
Expression cible de l'affectation.
Retourne
NExpr
op
public var op:TokenType
Type d'opérateur d'affectation.
Retourne
TokenType
value
public var value:NExpr
Valeur affectée.
Retourne
NExpr
new
public function new(id:NodeId, pos:Position, target:NExpr, op:TokenType, value:NExpr, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud d'affectation.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de cette affectation dans le code source |
target |
NExpr |
Expression cible de l'affectation |
op |
TokenType |
Type d'opérateur d'affectation |
value |
NExpr |
Valeur affectée |
leadingComments |
Array<Comment> |
Commentaires optionnels avant l'affectation |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'affectation |
toJson
public override function toJson():Dynamic
Convertit l'affectation en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données de l'affectation
NArrayAccess
Représente une expression d'accès à un tableau (array[index]).
target
public var target:NExpr
Tableau cible de l'accès.
Retourne
NExpr
index
public var index:NExpr
Expression d'indice.
Retourne
NExpr
new
public function new(id:NodeId, pos:Position, target:NExpr, index:NExpr, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud d'accès à un tableau.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de cet accès dans le code source |
target |
NExpr |
Expression du tableau cible |
index |
NExpr |
Expression d'indice |
leadingComments |
Array<Comment> |
Commentaires optionnels avant l'accès |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'accès |
toJson
public override function toJson():Dynamic
Convertit l'accès au tableau en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données de l'accès au tableau
NBinary
Représente une expression d'opération binaire (a + b, a && b, etc.).
left
public var left:NExpr
Expression de l'opérande gauche.
Retourne
NExpr
op
public var op:TokenType
Type d'opérateur.
Retourne
TokenType
right
public var right:NExpr
Expression de l'opérande droit.
Retourne
NExpr
new
public function new(id:NodeId, pos:Position, left:NExpr, op:TokenType, right:NExpr, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud d'opération binaire.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de cette opération dans le code source |
left |
NExpr |
Expression de l'opérande gauche |
op |
TokenType |
Type d'opérateur binaire |
right |
NExpr |
Expression de l'opérande droit |
leadingComments |
Array<Comment> |
Commentaires optionnels avant l'opération |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'opération |
toJson
public override function toJson():Dynamic
Convertit l'opération binaire en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données de l'opération
NUnary
Représente une expression d'opération unaire (!x, -x, etc.).
op
public var op:TokenType
Type d'opérateur.
Retourne
TokenType
operand
public var operand:NExpr
Expression de l'opérande.
Retourne
NExpr
new
public function new(id:NodeId, pos:Position, op:TokenType, operand:NExpr, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud d'opération unaire.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de cette opération dans le code source |
op |
TokenType |
Type d'opérateur unaire |
operand |
NExpr |
Expression de l'opérande |
leadingComments |
Array<Comment> |
Commentaires optionnels avant le nœud |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'opération |
toJson
public override function toJson():Dynamic
Convertit l'opération unaire en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données de l'opération
NTernary
Représente une expression conditionnelle ternaire (condition ? trueExpr : falseExpr).
condition
public var condition:NExpr
L'expression de condition.
Retourne
NExpr
trueExpr
public var trueExpr:NExpr
L'expression à évaluer si la condition est vraie.
Retourne
NExpr
falseExpr
public var falseExpr:NExpr
L'expression à évaluer si la condition est fausse.
Retourne
NExpr
new
public function new(id:NodeId, pos:Position, condition:NExpr, trueExpr:NExpr, falseExpr:NExpr, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud d'expression ternaire.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
Identifiant du nœud |
pos |
Position |
Position de cette expression dans le code source |
condition |
NExpr |
L'expression de condition |
trueExpr |
NExpr |
Expression évaluée quand la condition est vraie |
falseExpr |
NExpr |
Expression évaluée quand la condition est fausse |
leadingComments |
Array<Comment> |
Commentaires optionnels avant le nœud |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'expression |
toJson
public override function toJson():Dynamic
Convertit l'expression ternaire en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données de l'expression ternaire
NImportStatement
Représente une instruction d'import.
path
public var path:NStringLiteral
Le chemin relatif du fichier à importer
Retourne
NStringLiteral
script
public var script:Script
L'AST importé
Retourne
Script
new
public function new(id:NodeId, pos:Position, path:NStringLiteral, script:Script, ?leadingComments:Array<Comment>, ?trailingComments:Array<Comment>)
Crée un nouveau nœud d'instruction d'import.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position de cet import dans le code source |
path |
NStringLiteral |
Le chemin relatif du fichier à importer |
script |
Script |
L'AST importé |
leadingComments |
Array<Comment> |
Commentaires optionnels avant le nœud |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'opération |
Générée depuis Loreline v0.10.0.