Référence de l'API Haxe
L'API publique complète du runtime Loreline.
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. Haxe est le langage dans lequel Loreline est écrit, et toutes les autres cibles en sont compilées : 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. Donne accès simplement aux fonctionnalités 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 est requis également.
|
handleFile |
ImportsFileHandler |
Handler de fichiers optionnel pour lire les imports. Si ce handler est asynchrone, parse() renverra null et l'argument callback devra être utilisé
|
callback |
(script:Script)->Void |
S'il est fourni, sera appelé avec le script résultant en argument. Utile surtout quand les imports de fichiers sont lus de façon asynchrone |
Retourne
Null<Script>
Le script analysé, sous forme d'instance AST Script (s'il a été chargé de façon synchrone)
Lève Si le script contient des erreurs de syntaxe ou d'autres problèmes d'analyse
C'est la première étape du travail avec un script Loreline. L'objet Script renvoyé peut ensuite être passé aux méthodes 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):InterpreterDémarre la lecture 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):InterpreterReprend un script Loreline précédemment sauvegardé depuis son état enregistré.
| 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 (typiquement issues de interpreter.save())
|
beatName |
String |
Nom de beat optionnel pour choisir où reprendre |
options |
InterpreterOptions |
Options optionnelles pour configurer le comportement de l'interpréteur |
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>
Une table de traductions à passer comme InterpreterOptions.translations
À partir d'un fichier de traduction analysé avec parse(), renvoie une table de traductions qui peut être passée comme options.translations à play() ou 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é (il doit avoir été analysé avec un chemin de fichier, ou filePath doit être fourni)
|
filePath |
String |
Emplacement de remplacement 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 la table de traductions fusionnée. Requis si handleFile est asynchrone.
|
Retourne
Null<Map<String, NStringLiteral>>
La table de traductions fusionnée (de façon synchrone, quand handleFile est synchrone), ou null si un fichier de traduction existe mais est invalide. Les fichiers de traduction absents restent ignorés silencieusement. lastError() n'est renseignée que lorsqu'un fichier est présent mais illisible (.lor cassé, .po/.xliff/.csv malformé, etc.).
Pour chaque fichier concerné par le script (racine + imports transitifs), le fichier de traduction correspondant est recherché en insérant .<locale> avant l'extension (par exemple characters.lor -> characters.fr.lor). Les fichiers de traduction absents sont ignorés silencieusement.
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é locale
<chemin-source-relatif>#<id>(toujours renseignée par fichier, permet la surcharge)
L'interpréteur privilégie la clé locale lors de la recherche d'une traduction.
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
translationFormat
public static function translationFormat(name:String, enabled:Bool):VoidActive ou désactive la prise en charge d'un format de fichier de traduction alternatif.
| 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 silencieusement (compatibilité avec de futurs formats).
Un fichier malformé dans un format activé (XML cassé dans un .xliff, .po avec une chaîne entre guillemets non terminée) remonte sous forme de loreline.Error depuis loadLocale, à attraper par try/catch en mode synchrone, ou via Loreline.lastError() après un callback déclenché avec 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 se déclenche avec 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 valeur porte la même erreur pour pouvoir être consultée 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):StringRé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 produit, sous forme de chaîne
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
update
public static function update(delta:Float):VoidFait 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):StringGénère le corps 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 corps 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 amorcée 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>):StringInsè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.
Quand reservedIds est fourni, il sert (et est modifié) d'ensemble partagé des identifiants déjà pris entre les appels. 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 commentaires de hachage 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 de commentaire de hachage (#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 une table neuve quand out vaut null).
removeLocalizationKeys
public static function removeLocalizationKeys(content:String, script:Script):StringRetire tous les marqueurs #id produits par insertLocalizationKeys (ou écrits à la main). L'opération inverse. 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):BoolRenvoie true si script contient au moins une chaîne traduisible (instruction de texte, dialogue ou option de choix) sans commentaire de hachage #id. Sans effet de bord, purement une inspection de l'AST. Utilisé par l'outillage pour décider 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 d'interprétation des scripts Loreline. Cette classe exécute un script Loreline analysé, gère l'état d'exécution et dialogue avec l'application hôte via des fonctions de 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 à appeler pour afficher un texte de dialogue |
handleChoice |
ChoiceHandler |
Fonction à appeler pour présenter des choix |
handleFinish |
FinishHandler |
Fonction à appeler quand l'exécution se termine |
options |
InterpreterOptions |
Options supplémentaires |
JavaScript TypeScript C# Java Python Haxe
start
public function start(?beatName:String):VoidDé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 aucun beat n'est trouvé dans le script
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
save
public function save():SaveDataSauvegarde 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):VoidRestaure l'état de l'interpréteur depuis un objet SaveData. Cela permet de reprendre l'exécution depuis un état précédemment sauvegardé.
| 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():VoidReprend 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):AnyRécupère un personnage par son nom.
| Paramètre | Type | Description |
|---|---|---|
name |
String |
Le nom du personnage à récupérer |
Retourne
Any
Les champs 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):AnyRécupère un champ précis d'un personnage.
| Paramètre | Type | Description |
|---|---|---|
character |
String |
Le nom du personnage |
name |
String |
Le nom du champ à lire |
Retourne
Any
La valeur du champ, ou null si le personnage ou le champ n'existe pas
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
setCharacterField
public function setCharacterField(character:String, name:String, value:Any):VoidÉcrit un champ précis sur un personnage.
| Paramètre | Type | Description |
|---|---|---|
character |
String |
Le nom du personnage |
name |
String |
Le nom du champ à écrire |
value |
Any |
La valeur à écrire |
Retourne
Void
JavaScript TypeScript GDScript C++ Java PHP Python Lua Haxe
getStateField
public function getStateField(name:String):AnyLit un champ d'état par son nom, en résolvant depuis la portée courante vers l'extérieur.
| Paramètre | Type | Description |
|---|---|---|
name |
String |
Le nom du champ à lire |
Retourne
Any
La valeur du champ, ou null si elle est introuvable
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
setStateField
public function setStateField(name:String, value:Any):VoidÉcrit un champ d'état par son nom, en résolvant 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 le champ, puis retombe sur l'état de premier niveau s'il est introuvable.
| Paramètre | Type | Description |
|---|---|---|
name |
String |
Le nom du champ à écrire |
value |
Any |
La valeur à écrire |
Retourne
Void
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
getTopLevelStateField
public function getTopLevelStateField(name:String):AnyLit directement un champ de l'état de premier niveau.
| Paramètre | Type | Description |
|---|---|---|
name |
String |
Le nom du champ à lire |
Retourne
Any
La valeur du champ, ou null si le champ n'existe pas
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
setTopLevelStateField
public function setTopLevelStateField(name:String, value:Any):VoidÉcrit directement un champ sur l'état de premier niveau.
| Paramètre | Type | Description |
|---|---|---|
name |
String |
Le nom du champ à écrire |
value |
Any |
La valeur à écrire |
Retourne
Void
JavaScript TypeScript C# GDScript C++ Java PHP Python Lua Haxe
currentNode
public function currentNode():AstNodeRenvoie 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 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):StringRenvoie le chemin du fichier contenant le nœud courant. Utilise le Lens pour remonter les instructions d'import et résoudre le chemin relativement au chemin 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 l'on se trouve dans le fichier racine
JavaScript TypeScript Haxe
translations
public var translations:Null<Map<String, NStringLiteral>>Table de traductions optionnelle (clé de localisation -> littéral de chaîne traduit). Quand elle est renseignée, evaluateString() substitue au texte marqué sa version traduite.
Retourne
Null<Map<String, NStringLiteral>>
stringLiteralProcessors
public var stringLiteralProcessors:Array<(str:NStringLiteral)->NStringLiteral> = []Processeurs enfichables qui transforment les littéraux de chaîne avant é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 selon le parcours des portées à l'EXÉCUTION (d'abord les beats imbriqués enregistrés, puis les beats 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 déclarante 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 déclarante du beat résolu est vivante 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), de sorte que le beat conserve son contexte lexical à l'invocation.
| 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 = nullLe chemin du fichier depuis lequel ce script a été analysé. Peut être null si le script a été analysé sans chemin de fichier.
Retourne
String
JavaScript TypeScript Haxe
fromJson
public static function fromJson(json:Dynamic):ScriptReconstruit 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 = 2La 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 dans la source où ce script commence |
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():ScriptBodyIteratorRetourne
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.UNDEFINEDUn 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:PositionPosition dans le code source où ce nœud apparaît.
Retourne
Position
JavaScript TypeScript Haxe
type
public function type():StringRenvoie le type de ce nœud.
Retourne
String
Représentation textuelle du type de nœud
JavaScript TypeScript C# C++ Java PHP Python Lua Haxe
toJson
public override function toJson():DynamicConvertit 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):NodeReconstruit 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):VoidParcourt tous les nœuds enfants de ce nœud.
| Paramètre | Type | Description |
|---|---|---|
handleNode |
(node:Node, parent:Node)->Void |
Fonction à appeler 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 dans la source où ce nœud apparaît |
toJson
public function toJson():DynamicConvertit 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 = nullTable optionnelle de fonctions supplémentaires à rendre disponibles au script
Retourne
FunctionsMap
JavaScript TypeScript C# GDScript C++ Java Haxe
strictAccess
public var strictAccess:Bool = falseIndique 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 = nullUn instanciateur personnalisé pour créer les objets de champs.
Retourne
(interpreter:Interpreter, type:String, node:Node)->Any
JavaScript TypeScript C# Java Haxe
translations
public var translations:Map<String, NStringLiteral> = nullTable de traductions optionnelle (clé de localisation -> littéral de chaîne traduit). Construite à partir d'un fichier de traduction analysé avec AstUtils.extractTranslations().
Retourne
Map<String, NStringLiteral>
JavaScript TypeScript C# GDScript C++ Java Haxe
stringLiteralProcessors
public var stringLiteralProcessors:Array<(str:NStringLiteral)->NStringLiteral> = nullProcesseurs de littéraux de chaîne personnalisés, optionnels, ajoutés à côté du processeur intégré du pipe de pluriel. 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 à l'utilisateur.
text
public var text:StringLe 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:BoolIndique 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:BoolIndique s'il s'agit d'un tag fermant.
Retourne
Bool
JavaScript TypeScript C# C++ Java PHP Python Haxe
value
public var value:StringLa valeur ou le nom du tag.
Retourne
String
JavaScript TypeScript C# C++ Java PHP Python Haxe
offset
public var offset:IntLa position dans le texte où ce tag apparaît.
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 la sortie de texte avec callback. Appelé quand le script doit afficher du texte à l'utilisateur.
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 à l'utilisateur.
FinishHandler
typedef FinishHandler = (interpreter:Interpreter)->VoidType de handler appelé quand l'exécution se termine.
FunctionsMap
typedef FunctionsMap = Map<String, Any>Table associant 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():StringConvertit 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():Int64Convertit le NodeId en sa représentation 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):IntRetourne
Int
branch
public var branch(get, set):IntRetourne
Int
block
public var block(get, set):IntRetourne
Int
node
public var node(get, set):IntRetourne
Int
nextSection
public function nextSection():NodeIdRetourne
NodeId
nextBranch
public function nextBranch():NodeIdRetourne
NodeId
nextBlock
public function nextBlock():NodeIdRetourne
NodeId
nextNode
public function nextNode():NodeIdRetourne
NodeId
Fields
Interface de base pour contenir des valeurs loreline. Cette interface permet de relier les champs d'objets loreline à des objets propres au jeu.
lorelineCreate
function lorelineCreate(interpreter:Interpreter):VoidAppelé 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):AnyLit la valeur associée à la clé de champ 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Écrit la valeur associée à la clé de champ 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):BoolVé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>Récupère tous les champs de cet objet
| Paramètre | Type | Description |
|---|---|---|
interpreter |
Interpreter |
Retourne
Array<String>
JavaScript TypeScript C# Haxe
lorelineRemove
function lorelineRemove(interpreter:Interpreter, key:String):BoolSupprime le champ associé à la clé donnée
| Paramètre | Type | Description |
|---|---|---|
interpreter |
Interpreter |
L'instance d'interpréteur |
key |
String |
La clé du champ à supprimer |
Retourne
Bool
True si la clé a été trouvée et supprimée, false sinon
C# Haxe
RuntimeState
Un état pendant l'exécution d'un script loreline. Les états contiennent des valeurs de champs qu'on peut lire et modifier pendant l'exécution.
scope
public var scope:Int = -1Si la valeur est > 0, cet état est temporaire et lié à une portée. Chaque fois qu'on entre dans un nouveau nœud de bloc, on entre dans une nouvelle portée identifiée par un entier unique. En quittant cette portée, les états temporaires associés sont détruits.
Retourne
Int
fields
public var fields(default, null):AnyLes champs de cet état. Contient les données réellement stockées.
Retourne
Any
originalFields
public var originalFields(default, null):AnyLes valeurs d'origine des champs, telles que déclarées initialement dans le script, tant qu'elles ne dépendent pas d'autres valeurs d'état. Servent de point de comparaison à la sérialisation pour éviter d'enregistrer des 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 avec des valeurs de champs initiales optionnelles.
| Paramètre | Type | Description |
|---|---|---|
interpreter |
Interpreter |
|
node |
Node |
|
fields |
Any |
Valeurs initiales des champs, ou null pour créer des champs vides |
originalFields |
Any |
Valeurs d'origine des champs pour la comparaison, ou null pour créer des champs d'origine vides |
clear
public function clear(interpreter:Interpreter, node:Node):VoidVide tous les champs 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 avec des valeurs de champs initiales optionnelles.
| 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, aux tableaux, aux personnages et les appels de fonctions.
FieldAccess
FieldAccess(pos:Position, obj:Any, name:String)Représente l'accès à un champ d'un objet.
| Paramètre | Type | Description |
|---|---|---|
pos |
Position |
Position dans le code source où cet accès a lieu |
obj |
Any |
L'objet auquel on accède |
name |
String |
Le nom du champ auquel accéder |
ArrayAccess
ArrayAccess(pos:Position, array:Any, index:Int)Représente l'accès à un élément de tableau par son index.
| Paramètre | Type | Description |
|---|---|---|
pos |
Position |
Position dans le code source où cet accès a lieu |
array |
Any |
Le tableau auquel on accède |
index |
Int |
L'index 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 dans le code source où cet accès a lieu |
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 dans le code source où cet accès a lieu |
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 dans le code source où cet accès a lieu |
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 = -1L'identifiant de la portée, un entier unique dans la pile.
Retourne
Int
beat
public var beat:NBeatDeclLe 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:AstNodeLe nœud auquel cette portée est attachée.
Retourne
AstNode
beats
public var beats:Array<NBeatDecl> = nullLes déclarations de beats imbriqués, s'il y en a, trouvées dans cette portée.
Retourne
Array<NBeatDecl>
state
public var state:RuntimeState = nullL'état temporaire associé à cette portée, s'il y en a un.
Retourne
RuntimeState
head
public var head:AstNode = nullLe 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 = nullSi cette portée a été créée depuis une insertion, les données d'exécution de cette insertion.
Retourne
RuntimeInsertion
captured
public var captured:Array<RuntimeScope> = nullSi cette portée exécute un beat invoqué par une référence de beat, la chaîne de portées capturée à la création de la référence (fermeture). 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>Trouve dans cette portée une déclaration de beat imbriqué portant le nom donné, s'il y en a une.
| Paramètre | Type | Description |
|---|---|---|
name |
String |
Le nom du beat à trouver |
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 plus la chaîne de portées capturée à l'endroit 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):NBeatDeclLa 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, où les valeurs de beat franchissent la frontière sous forme de 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:IntL'identifiant de l'insertion, un entier unique parmi toutes les insertions.
Retourne
Int
origin
public var origin:NInsertionLe nœud d'origine à l'origine de cette insertion
Retourne
NInsertion
options
public var options:Array<ChoiceOption> = nullLes 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, utilisée pour reprendre l'exécution au bon endroit une fois qu'un de ses choix a été sélectionné
Retourne
Array<RuntimeScope>
parentPartialOptions
public var parentPartialOptions:Array<ChoiceOption> = nullInstantané 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 = 0L'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 d'exécution 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 = trueIndique si l'étape suivante doit s'exécuter de façon synchrone.
Retourne
Bool
cb
public var cb:()->Void = nullLe 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 = 1Retourne
NodeIdStep
BRANCH
BRANCH = 2Retourne
NodeIdStep
BLOCK
BLOCK = 3Retourne
NodeIdStep
NODE
NODE = 4Retourne
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():VoidRetourne
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:StringLe contenu textuel du commentaire.
Retourne
String
multiline
public var multiline:BoolIndique s'il s'agit d'un commentaire multiligne (/* ... */) ou d'une seule ligne (//).
Retourne
Bool
isHash
public var isHash:BoolIndique s'il s'agit d'un commentaire de hachage (#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 dans la source où ce commentaire apparaît |
content |
String |
Le contenu textuel du commentaire |
multiline |
Bool |
Indique s'il s'agit d'un commentaire multiligne |
isHash |
Bool |
Indique s'il s'agit d'un commentaire de hachage |
toJson
public override function toJson():DynamicConvertit 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 dans la source où ce nœud apparaît |
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():DynamicConvertit 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():DynamicConvertit 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 (nouvel état), soit permanent.
temporary
public var temporary:BoolIndique si cet état est temporaire (nouvel état).
Retourne
Bool
fields
public var fields:Array<NObjectField>Champs définis pour cet état.
Retourne
Array<NObjectField>
style
public var style:BlockStyleStyle 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 dans la source où cet état apparaît |
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():DynamicConvertit la déclaration d'état en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données de l'état
NObjectField
Représente un champ d'objet dans l'AST (paire nom-valeur).
name
public var name:StringNom du champ.
Retourne
String
value
public var value:NExprExpression de la valeur du champ.
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 champ d'objet.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position dans la source où ce champ apparaît |
name |
String |
Nom du champ |
value |
NExpr |
Expression de la valeur du champ |
leadingComments |
Array<Comment> |
Commentaires optionnels avant le champ |
trailingComments |
Array<Comment> |
Commentaires optionnels après le champ |
toJson
public override function toJson():DynamicConvertit le champ d'objet en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données du champ
NCharacterDecl
Représente une déclaration de personnage dans l'AST.
name
public var name:StringNom du personnage.
Retourne
String
namePos
public var namePos:PositionPosition de la partie nom.
Retourne
Position
fields
public var fields:Array<NObjectField>Champs définis pour ce personnage.
Retourne
Array<NObjectField>
style
public var style:BlockStyleStyle 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 dans la source où ce personnage apparaît |
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():DynamicConvertit 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:StringNom du paramètre.
Retourne
String
namePos
public var namePos:PositionPosition du nom du paramètre dans la source.
Retourne
Position
defaultValue
public var defaultValue:Null<NExpr>Expression de valeur par défaut optionnelle, é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():DynamicRetourne
Dynamic
NBeatDecl
Représente une déclaration de beat (scène) dans l'AST.
name
public var name:StringNom 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:BlockStyleStyle de bloc de ce beat
Retourne
BlockStyle
params
public var params:Null<Array<NBeatParam>> = nullParamètres optionnels de ce beat (null quand la déclaration n'a pas de parenthèses). À l'exécution, ils deviennent des champs d'état temporaires à la portée du 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 dans la source où ce beat apparaît |
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():DynamicConvertit 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)Contenu 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 = 0Retourne
BlockStyle
Braces
Braces = 1Retourne
BlockStyle
toString
public function toString():StringRetourne
String
ConditionStyle
enum abstract ConditionStyle(Int)Plain
Plain = 0Retourne
ConditionStyle
Parens
Parens = 2Retourne
ConditionStyle
toString
public function toString():StringRetourne
String
AlternativeMode
enum abstract AlternativeMode(Int)Représente le mode d'un bloc d'alternatives.
Sequence
Sequence = 0Retourne
AlternativeMode
Cycle
Cycle = 1Retourne
AlternativeMode
Once
Once = 2Retourne
AlternativeMode
Pick
Pick = 3Retourne
AlternativeMode
Shuffle
Shuffle = 4Retourne
AlternativeMode
toString
public function toString():StringRetourne
String
NStringPart
Représente une partie pouvant apparaître dans un littéral de chaîne.
partType
public var partType:StringPartTypeLe 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 dans la source où cette partie de chaîne apparaît |
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():DynamicConvertit 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:QuotesLe type de guillemets utilisés 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 dans la source où cette chaîne apparaît |
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():DynamicConvertit 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:NStringLiteralLe 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:ConditionStyleLe style de la condition (nue ou entre parenthèses).
Retourne
ConditionStyle
conditionPos
public var conditionPos:Null<Position>Position de la clause « if condition » finale (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 dans la source où ce texte apparaît |
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():DynamicConvertit 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:StringNom du personnage qui parle.
Retourne
String
characterPos
public var characterPos:PositionPosition de l'étiquette du personnage
Retourne
Position
content
public var content:NStringLiteralContenu du dialogue.
Retourne
NStringLiteral
condition
public var condition:Null<NExpr>Condition optionnelle qui doit être vraie pour que ce dialogue s'affiche.
Retourne
Null<NExpr>
conditionStyle
public var conditionStyle:ConditionStyleLe style de la condition (nue ou entre parenthèses).
Retourne
ConditionStyle
conditionPos
public var conditionPos:Null<Position>Position de la clause « if condition » finale (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 dans la source où ce dialogue apparaît |
character |
String |
Nom du personnage qui parle |
characterPos |
Position |
Position de l'étiquette du personnage |
content |
NStringLiteral |
Littéral de chaîne contenant le texte du dialogue |
leadingComments |
Array<Comment> |
Commentaires optionnels avant le dialogue |
trailingComments |
Array<Comment> |
Commentaires optionnels après le dialogue |
toJson
public override function toJson():DynamicConvertit 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:BlockStyleLe 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 dans la source où ce choix apparaît |
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():DynamicConvertit 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:NStringLiteralLe texte affiché pour cette option.
Retourne
NStringLiteral
insertion
public var insertion:NInsertionÀ la place d'un texte, ce peut aussi être une insertion
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:ConditionStyleLe style de la condition (nue ou entre parenthèses).
Retourne
ConditionStyle
conditionPos
public var conditionPos:Null<Position>Position de la clause « if condition » finale (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:BlockStyleLe style de bloc du corps
Retourne
BlockStyle
once
public var once:BoolIndique 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 dans la source où cette option apparaît |
text |
NStringLiteral |
Littéral de chaîne contenant le texte de l'option |
insertion |
NInsertion |
|
condition |
Null<NExpr> |
Condition optionnelle de disponibilité de l'option |
conditionStyle |
ConditionStyle |
Le style de la condition (nue ou entre parenthèses) |
body |
Array<AstNode> |
Tableau des nœuds à exécuter quand elle est choisie |
leadingComments |
Array<Comment> |
Commentaires optionnels avant l'option |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'option |
toJson
public override function toJson():DynamicConvertit 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:BlockStyleLe 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 dans la source où ce beat apparaît |
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():DynamicConvertit 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:NExprLa condition à évaluer.
Retourne
NExpr
conditionStyle
public var conditionStyle:ConditionStyleLe style de la condition (nue ou entre parenthèses).
Retourne
ConditionStyle
thenBranch
public var thenBranch:NBlockTableau 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 dans la source où cette instruction if apparaît |
condition |
NExpr |
Expression à évaluer |
conditionStyle |
ConditionStyle |
Le style de la condition (nue ou entre parenthèses) |
thenBranch |
NBlock |
Nœuds à exécuter si la condition est vraie |
elseBranch |
Null<NBlock> |
Nœuds optionnels à exécuter si la condition est fausse |
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():DynamicConvertit 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:AlternativeModeLe mode d'alternative (sequence, cycle, once, pick, shuffle).
Retourne
AlternativeMode
items
public var items:Array<NBlock>Tableau des blocs d'éléments. Chaque élément est un bloc d'instructions.
Retourne
Array<NBlock>
style
public var style:BlockStyleLe 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 dans la source où cette alternative apparaît |
mode |
AlternativeMode |
Le mode d'alternative |
items |
Array<NBlock> |
Tableau des blocs d'éléments |
leadingComments |
Array<Comment> |
Commentaires optionnels avant l'alternative |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'alternative |
toJson
public override function toJson():DynamicConvertit 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:NExprL'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 dans la source où cet appel apparaît |
target |
NExpr |
Expression appelée |
args |
Array<NExpr> |
Tableau des expressions d'arguments |
leadingComments |
Array<Comment> |
Commentaires optionnels avant l'appel |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'appel |
toJson
public override function toJson():DynamicConvertit 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:StringNom du beat cible (null quand la cible est dynamique, voir targetExpr).
Retourne
String
targetPos
public var targetPos:PositionPosition de la partie cible de la transition
Retourne
Position
targetExpr
public var targetExpr:Null<NExpr> = nullExpression de 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>> = nullArguments 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 dans la source où cette transition apparaît |
target |
String |
Nom du beat cible |
targetPos |
Position |
Position de la partie cible de la transition |
leadingComments |
Array<Comment> |
Commentaires optionnels avant la transition |
trailingComments |
Array<Comment> |
Commentaires optionnels après la transition |
toJson
public override function toJson():DynamicConvertit 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:StringNom du beat cible (null quand la cible est dynamique, voir targetExpr).
Retourne
String
targetPos
public var targetPos:PositionPosition de la partie cible de l'insertion
Retourne
Position
targetExpr
public var targetExpr:Null<NExpr> = nullExpression de 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>> = nullArguments 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 dans la source où cette insertion apparaît |
target |
String |
Nom du beat cible |
targetPos |
Position |
Position de la partie cible de l'insertion |
leadingComments |
Array<Comment> |
Commentaires optionnels avant l'insertion |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'insertion |
toJson
public override function toJson():DynamicConvertit 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...). Exécute le beat résolu comme un appel qui préserve la pile (comme un appel statique SomeBeat(args...)), la cible étant résolue à l'exécution.
targetExpr
public var targetExpr:NExprExpression 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:PositionPosition de la partie cible beat(...).
Retourne
Position
args
public var args:Null<Array<NExpr>> = nullArguments 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 dans la source où cet appel apparaît |
targetExpr |
NExpr |
Expression résolvant vers le beat cible |
targetPos |
Position |
Position de la partie cible |
leadingComments |
Array<Comment> |
Commentaires optionnels avant l'appel |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'appel |
toJson
public override function toJson():DynamicConvertit 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:StringLe code de la fonction (signature comprise)
Retourne
String
external
public var external:BoolIndique 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 dans la source où cette fonction apparaît |
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():DynamicConvertit 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, objets).
value
public var value:AnyLa valeur littérale.
Retourne
Any
literalType
public var literalType:LiteralTypeType 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 dans la source où ce littéral apparaît |
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():DynamicConvertit 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
NumberLittéral numérique
Boolean
BooleanLittéral booléen
Null
NullLittéral null
Array
ArrayLittéral de tableau
Object
Object(style:BlockStyle)Littéral d'objet
| Paramètre | Type | Description |
|---|---|---|
style |
BlockStyle |
NAccess
Représente une expression d'accès à un champ (obj.field).
target
public var target:Null<NExpr>Objet cible optionnel de l'accès.
Retourne
Null<NExpr>
name
public var name:StringNom du champ accédé.
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 à un champ.
| Paramètre | Type | Description |
|---|---|---|
id |
NodeId |
|
pos |
Position |
Position dans la source où cet accès apparaît |
target |
Null<NExpr> |
Expression optionnelle de l'objet cible |
name |
String |
Nom du champ accédé |
leadingComments |
Array<Comment> |
Commentaires optionnels avant l'accès |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'accès |
toJson
public override function toJson():DynamicConvertit l'accès au champ 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:NExprExpression cible de l'affectation.
Retourne
NExpr
op
public var op:TokenTypeType d'opérateur d'affectation.
Retourne
TokenType
value
public var value:NExprValeur 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 dans la source où cette affectation apparaît |
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():DynamicConvertit 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:NExprTableau cible de l'accès.
Retourne
NExpr
index
public var index:NExprExpression 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 dans la source où cet accès apparaît |
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():DynamicConvertit 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:NExprExpression de l'opérande gauche.
Retourne
NExpr
op
public var op:TokenTypeType d'opérateur.
Retourne
TokenType
right
public var right:NExprExpression 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 dans la source où cette opération apparaît |
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():DynamicConvertit 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:TokenTypeType d'opérateur.
Retourne
TokenType
operand
public var operand:NExprExpression 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 dans la source où cette opération apparaît |
op |
TokenType |
Type d'opérateur unaire |
operand |
NExpr |
Expression de l'opérande |
leadingComments |
Array<Comment> |
Commentaires optionnels avant |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'opération |
toJson
public override function toJson():DynamicConvertit 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:NExprL'expression de condition.
Retourne
NExpr
trueExpr
public var trueExpr:NExprL'expression à évaluer si la condition est vraie.
Retourne
NExpr
falseExpr
public var falseExpr:NExprL'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 dans la source où cette expression apparaît |
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 |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'expression |
toJson
public override function toJson():DynamicConvertit l'expression ternaire en représentation JSON.
Retourne
Dynamic
Objet dynamique contenant les données du ternaire
NImportStatement
Représente une instruction d'import
path
public var path:NStringLiteralLe chemin relatif du fichier à importer
Retourne
NStringLiteral
script
public var script:ScriptL'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 dans la source où cet import apparaît |
path |
NStringLiteral |
Le chemin relatif du fichier à importer |
script |
Script |
L'AST importé |
leadingComments |
Array<Comment> |
Commentaires optionnels avant |
trailingComments |
Array<Comment> |
Commentaires optionnels après l'opération |
Générée depuis Loreline v0.10.0.