Vos propres générateurs
Un générateur transforme le modèle en fichiers : du code, de la configuration
ou des documents. archec fournit environ vingt-cinq cibles intégrées, comme C,
Rust, Go, DBC, ARXML et ROS 2 (archec gen --list). Votre entreprise peut en
avoir besoin d’autres : sa propre glue d’exécution, la configuration d’un banc
de test, un document dans sa propre mise en page. Une déclaration generator
en ajoute une, et vous la lancez comme une cible intégrée.
Un premier générateur#
Voici un modèle avec deux messages, et un générateur fait d’un seul gabarit :
message BRAKE_CMD "Brake command" {
field force: float32 [N]
field urgent: bool
}
message SPEED "Speed" {
field kmh: float32
}
system Car {
}
generator msgs "Message structs" {
templates "generators/msgs"
}
Le dossier generators/msgs/ contient un seul fichier, messages.h. Ce qui
se trouve entre {{ et }} est rempli à partir du modèle :
/* {{ project.name }}: its messages. */
{{#each messages}}
typedef struct {
{{#each fields}}
{{ type | ctype }} {{ id | snake }};
{{/each}}
} {{ id | snake }}_t;
{{/each}}
Lancez-le :
archec gen main.arche --target msgs -o generated
generated/msgs/messages.h
generated/msgs/messages.h contient :
/* car: its messages. */
typedef struct {
float force;
bool urgent;
} brake_cmd_t;
typedef struct {
float kmh;
} speed_t;
Ici, le projet se trouve dans un dossier nommé car : le nom du projet est
celui de son dossier.
Pour aller plus vite, archec generator new écrit un générateur qui
fonctionne déjà :
archec generator new rte --templates # or --script, or --command
✓ generator rte (templates) → main.arche, generators/rte/messages.md, generators/rte/parts.txt
archec gen main.arche --target rte · archec generator model main.arche · docs/generators.md
Comment fonctionne un générateur#
Un générateur lit le modèle de générateur et renvoie des fichiers. Le
modèle de générateur, c’est le projet sous forme de JSON simple.
archec generator model main.arche l’affiche.
Un générateur prend l’une de ces trois formes :
- des gabarits : un dossier de fichiers texte avec des emplacements
{{ }}; - un script : une fonction JavaScript ou TypeScript ;
- une commande : un programme dans n’importe quel langage, qui lit le modèle en JSON.
Les trois formes lisent le même modèle.
Un générateur a deux cousins :
- un
importerlit un fichier d’un autre outil et le fait entrer dans arche-lang ; - un
exporterécrit le modèle sous forme de fichier d’un autre outil.
Les trois peuvent être réunis dans un plugin : un dossier fourni par le projet, par un paquet du Store ou par archec lui-même (plugins).
Les générateurs déclarent leurs options, peuvent partir d’un autre générateur
(from) et peuvent s’exécuter après une cible intégrée pour modifier ses
fichiers (les hooks). Les sections suivantes présentent chacun de ces points.
Le modèle de générateur#
Le modèle de générateur, c’est le projet sous forme de JSON simple, en
version 1. Son schéma est schemas/generator-model.v1.json. Tous les noms y
sont résolus et toutes les valeurs calculées. Ce qu’un générateur devrait
sinon calculer lui-même l’est déjà :
| Clé | Ce qu’elle contient |
|---|---|
project |
name, version, root |
options |
les options du générateur, telles que le projet les fixe |
messages |
id, label, fields (type, unité, plage), layout : bytes et les signals sur le fil — scalaire, décalage, unité, libellé et, pour un message doté d’un format de trame, ses bits, son ordre, son facteur d’échelle, son décalage, sa somme de contrôle |
types |
kind (type, enum, struct, union), literals avec leurs valeurs, fields, underlying ; exception: true pour une exception ; native pour un type … native : son name en c, cpp, rust, go, avec l’include ou l’import qui le déclare |
exceptions |
les identifiants des types exception |
interfaces |
operations (params avec leur direction quand elle vaut out ou inout, result, oneway, raises), attributes (type, readonly), extends, messages |
constants, parameters |
les valeurs calculées (value) et telles qu’écrites (source) |
components |
les définitions : ports (direction, type, messages envoyés et reçus, corps onReceive et onDeadline, interfaces qu’il fournit (provides) et requiert (requires), son pattern, topic et topicParts, service, dataflow, les handlers qui traitent ce qu’il reçoit : { message, function }), functions (un corps en langage d’action avec ses versions Python, C, C++, Rust et Go ; params avec leur direction), variables, machine (états, transitions avec déclencheur, garde, action), lifecycle (les corps init, start, stop et release), parts, props, les requirements qui le tracent |
systems, parts |
les systèmes — chaque lien avec son pattern et ce qu’en disent ses deux extrémités et lui-même (topic, service, dataflow, timeout, async, deferred) — et chaque part par son chemin (Car.brakes.mcu), avec sa définition, les params avec lesquels elle est créée, les values initiales de ses variables et celles qu’elle redéfinit (overrides) |
requirements |
identifiant, libellé, texte et toutes les propriétés |
deployment |
le déploiement actif (ou --deployment) : binaries avec leur processeur (chemin, libellé, carte, OS) et leurs threads (période, priorité, parts et fonctions qu’ils exécutent, le step appelé à chaque période : part.fn), buses avec les frames CAN que chacun transporte (identifiant, message, émetteur, destinataire, fd, periodNs tiré de la period du message), containers |
deployment (exécution et mémoire) |
pour chaque thread, son process, sa queue, son affinity et les ports qu’il exécute ; pour chaque binaire, ses options (celles du générateur en cours : celles du projet, puis le bloc options <generator> { … } du binaire), les memories de son processeur et ses processes avec leurs propres options ; allocators (type, blockBytes, blocks, alignement, mémoire, parent, binaire ou processus qui les contient) ; placements : chaque part qui s’exécute, son execution (active, passive, protected), son thread, son processus, sa memory par usage (hrt, lrt, saved, tmp, comm) et ses ports (le thread qui en exécute un, sa mémoire, son buffering). Voir Déploiement |
components[].algorithm |
un kind algorithm : ses stereotypes, ses parameters (instanciation, configuration, internes), son workingMemory, les fonctions cycle qu’il possède, les metrics qu’il publie et lit ; pour un composite, son composite (L1, LN), ses roles (définition, stéréotypes, after, arguments, configuration), ses delegations et ses connections. Le buffering d’un port |
metrics |
les messages de kind metric : leur paquet, leurs champs, et le topic sur lequel chaque part les publie |
Chaque élément possède at : le fichier et la ligne où il est écrit. Quand un
générateur trouve un problème, il le signale sur l’élément. archec affiche le
problème à cette ligne, et VS Code le montre dans Problems.
- Un élément placé dans un paquet possède
package. - Un élément qui a des lignes
attr key = valueles retrouve dansattrs. Unattrcontient ce que le langage ne sait pas dire, comme l’identifiant ou le nom donné par un autre outil. Un exporteur les réécrit, et peut garder un identifiantattrcomme identifiant propre de l’élément. - Les parts, threads, binaires, processus, allocateurs, mémoires et
placements ont aussi des
attrs.
Le modèle ne fait que s’enrichir au sein de la version 1 : ajouter un champ
ne change pas de version. Un générateur indique la version qu’il lit avec
api 1.
Corps en C, Rust et Go#
Un corps, c’est le code d’une fonction, du onEnter ou du onExit d’un
état, du onReceive ou du onDeadline d’un port, ou du lifecycle d’un
composant. Dans le modèle, chaque corps possède :
source, tel qu’écrit ;python;c,cpp,rustetgo, produits par les mêmes traducteurs que les cibles intégrées.cppest écrit comme l’écrit--target cpp(this->n).
Un corps écrit en Python est lui aussi traduit quand le langage d’action peut
exprimer la même chose, comme le font les cibles C et Go. Sinon, c, rust
et go sont absents.
La traduction ne peut pas connaître votre runtime. Ce que le corps fait vers l’extérieur est donc écrit comme l’écrivent les cibles intégrées, et c’est à votre générateur de fournir ces noms :
| Le corps contient | c |
rust |
go |
|---|---|---|---|
une variable n |
self->n |
self.n |
self.n |
send tx GO { … } |
pump_send_tx(self, &(go_t){ … }); (pump_send_tx_go quand le port envoie plusieurs messages) |
_out.send_tx(Go { … }).await; |
self.Send("tx", GO{…}) |
goto Running |
pump_goto(self, PUMP_RUNNING); |
self.sm.goto_name("Running"); |
self.Goto(Pump_Running) |
state == Running |
pump_in(self, PUMP_RUNNING) |
self.sm.state.is_in("Running") |
self.In(Pump_Running) |
un appel de la fonction f() de la part |
pump_f(self) |
self.f(_out).await |
self.F() |
un appel à travers un port, brake.apply(2.5) |
comme l’écrit la cible C | _out.call_brake_apply(2.5).await |
comme l’écrit la cible Go |
wait 10ms, now() |
arche_wait_ns(…), arche_now_ns() |
embassy_time::Timer::after(…), Instant::now() |
archeWait(…), archeNow() |
log a, b |
arche_log("%g %ld", …) |
un commentaire | archeLog(a, b) |
Les types sont nommés comme les nomment les cibles : go_t en C, Go en
Rust, GO en Go. Les durées sont en nanosecondes (uint64_t, u64,
int64). Dans une part sans machine à états, un goto est écrit en
commentaire.
Le modèle suffit. examples/generators/dbc.js ne lit rien d’autre que le
modèle, et écrit les mêmes fichiers DBC que --target dbc, à l’octet près.
Les tests le vérifient.
Gabarits#
Un générateur à gabarits est un dossier de fichiers texte. Chaque fichier est
un gabarit : ce qui se trouve entre {{ et }} est rempli à partir du
modèle. Le fichier écrit porte le nom du gabarit, sans le suffixe .tpl s’il
en a un.
/* {{ project.name }}: its messages. */
{{#each messages where layout.bytes}}
typedef struct {
{{#each fields}}
{{ type | ctype @root.options.prefix }} {{ id | snake }};{{#if unit}} /* {{ unit }} */{{/if}}
{{/each}}
} {{ @root.options.prefix }}{{ id | snake }}_t;
{{/each}}
| Écrit | Effet |
|---|---|
{{ name }}, {{ a.b }} |
une valeur : celle de l’élément courant ; sinon celle de la boucle qui l’entoure, et ainsi de suite jusqu’au modèle |
{{ .name }}, {{ ../name }}, {{ @root.name }} |
celle de l’élément courant seulement ; celle de la boucle qui l’entoure ; celle du modèle |
{{ x | snake | default "none" }} |
des filtres, appliqués l’un après l’autre |
{{#each list where field=a,b and other}} … {{else}} … {{/each}} |
une fois par élément (@index, @number, @first, @last) ; {{else}} quand il n’y en a aucun |
{{#if cond}} … {{else}} … {{/if}}, {{#unless cond}} |
field, field=a,b, field!=a, field~text, field>3, reliés par and |
{{#with element}} … {{/with}} |
à l’intérieur d’un seul élément |
{{#file "src/{{ id | snake }}.c"}} … {{/file}} |
un fichier à part — dans un #each, un par élément |
{{> name}} |
un autre gabarit du dossier, dont le nom commence par _ (un partiel, pas un fichier) |
{{ keep }} |
une fois écrit, le fichier est à vous : archec ne l’écrase plus |
{{#region "{{ id }}.init"}} … {{/region}} |
une région USER CODE. Son contenu sert de valeur par défaut. Le code que le développeur y place est conservé chaque fois que le fichier est réécrit (régénération). Le style de commentaire suit le nom du fichier, ou bien "c", "line" ou "hash" placé après l’identifiant. "user-code" écrit des marqueurs // -- start of user code: name (régénération). |
{{! … }}, {{!-- … --}} |
un commentaire ; le second peut contenir {{ }} |
Une ligne qui ne contient qu’une balise de bloc ({{#each …}}, {{/if}},
{{else}}…) ne laisse rien derrière elle, pas même son saut de ligne. Un
gabarit de code se lit donc comme le code qu’il produit.
Les filtres transforment une valeur. Les voici :
- noms :
snake,camel,pascal,kebab,constant(BRAKE_CMD),upper,lower; - types :
ctype,rusttype,pytypedonnent un type du modèle dans ce langage, en suivant ses alias.ctype "acme_"écrit un type déclaré sous la formeacme_name_t; - valeurs :
hex(hex 4→0x00FF),json,quote,default "x"; - listes :
join ", ",map "id",sort "id",length,first,last; - texte :
indent 4,replace "a" "b",trim,pad 12.
Un argument de filtre écrit sans guillemets est un nom lu dans le modèle
(ctype @root.options.prefix).
Un script#
generator can-db "CAN databases" { script "dbc.js"; needs deployment }
module.exports = function generate(model, ctx) {
const files = {};
for (const m of model.messages) {
if (m.layout.problem) { ctx.warn(m, `${m.id} has no fixed layout`); continue; }
files[`${ctx.filters.snake(m.id)}.txt`] = m.layout.signals.map((s) => s.name).join('\n');
}
return { files }; // { "path": "text" }, or { "path": { text, keep: true } }
};
export default function generate… fonctionne aussi. Le script renvoie ses
fichiers ; il ne les écrit pas. ctx fournit :
options;readFile(rel): un fichier du dossier du script ;render(template, data): le langage de gabarits ;region(id, default, style): une région USER CODE autour du code par défaut, conservée quand le fichier est réécrit (régénération).stylevaut"c","line","hash"ou un nom de fichier."user-code"écrit les marqueurs// -- start of user code: <name>; le nom de fichier passe alors en cinquième argument ;filters;note(msg);warn(where, msg)eterror(where, msg).whereest un élément du modèle, un chemin ou un identifiant, ou{ file, line };builtin(target, { deployment, trace, monitors }): les fichiers d’une cible intégrée, sous la forme{ "path": "text" }(voir plus bas) ;- pour un hook (
after c) :target,files({ "path": "text" }) etkept(les chemins marquéskeep).
En TypeScript#
script "gen.ts" (ou .mts, .cts) est du TypeScript. archec retire les
types et exécute le reste comme n’importe quel script.
- Node 22.13, 23.2 et les versions suivantes retirent eux-mêmes les types.
Les lignes restent à leur place : la ligne d’une erreur est donc celle du
fichier
.ts. Unenumou unnamespaceest réécrit, et ses lignes peuvent bouger. - Sur une version plus ancienne de node, esbuild ou typescript s’en chargent, si le projet ou archec a l’un des deux installé. Sinon, l’erreur le dit.
Le fichier generator-model.v1.d.ts donne les types du modèle et de ctx.
archec generator types l’écrit. archec generator new rte --script --ts
écrit un script et ce fichier côte à côte :
import type { GeneratorContext, GeneratorModel, GeneratorResult } from './generator-model.v1';
export default function generate(model: GeneratorModel, ctx: GeneratorContext): GeneratorResult {
const files: Record<string, string> = {};
for (const m of model.messages) files[`${m.id}.txt`] = m.fields.map((f) => f.id).join('\n');
return { files };
}
export function generate fonctionne aussi. archec se contente de retirer
les types ; il ne les vérifie jamais. Lancez tsc --noEmit dans votre
éditeur ou en CI pour les vérifier.
Le bac à sable#
Le script s’exécute dans un bac à sable : du JavaScript pur, sans rien de
node ni de npm. Il n’a pas de process, pas de système de fichiers au-delà
de son propre dossier, et pas de réseau. Un script qui boucle sans fin est
arrêté au bout de 30 s.
Un script peut tenir en plusieurs fichiers. import { view } from './core/view'
(ou require('./core/view')) charge l’un de ses propres modules, .ts ou
.js, avec export comme d’habitude. Un module vient du dossier du script ;
dans un plugin ou une bibliothèque, il peut venir de n’importe où à
l’intérieur. Un module situé en dehors, ou un module de node ou de npm
(import fs from 'fs'), est une erreur.
Une commande, dans n’importe quel langage#
generator icd-md "ICD" { command "python3 icd.py"; output "docs" }
La commande s’exécute dans le dossier du fichier où le générateur est déclaré. Elle lit le modèle en JSON sur son entrée standard (stdin). Elle écrit ce JSON sur sa sortie standard (stdout) :
{ "files": [{ "path": "icd.md", "text": "…", "keep": false }],
"notes": ["9 messages"],
"errors": [{ "where": "BRAKE_CMD", "message": "…", "severity": "warning" }] }
Ce qu’elle écrit sur stderr est affiché sous forme de notes. C’est une erreur quand la commande se termine en erreur, ou quand elle écrit autre chose que ce JSON.
Options, et un générateur à partir d’un autre#
options { … } est un enregistrement, et le champ options du modèle le
contient. --option prefix=acme_ modifie une option le temps d’une
exécution. Pour d’autres valeurs à chaque fois, écrivez un autre générateur
à partir du premier, avec from :
generator rte-bench "RTE for the bench" from rte { options { prefix "bench_" } }
Une option que le premier générateur n’a pas déclenche un avertissement
(generator-option).
Options déclarées, avec leur type#
Un générateur peut déclarer ses options. C’est surtout utile pour un générateur fourni par une bibliothèque :
generator rte "Our RTE glue" {
templates "generators/rte"
option prefix "The prefix of the C names" { type string; default "acme_" }
option os "The RTOS it runs on" { type string; values posix, freertos; default posix }
option depth "Queue depth" { type int; default 8 }
}
typevautstring,int,float,booloulist. Sanstype, toute valeur est acceptée.valuesdonne les seules valeurs que l’option accepte.defaultest la valeur quand rien ne la fixe. Le champoptionsdu modèle la contient.
archec check vérifie alors ce que fixe un générateur qui part de lui avec
from (generator-option) :
- une option qu’il ne déclare pas donne un avertissement ;
- une valeur d’un autre type, ou absente de ses
values, donne une erreur sur la valeur.
--option est lu selon le type de l’option et vérifié de la même façon.
--option prefix=12 donne la chaîne "12" ; --option list=a,b donne une
liste.
archec gen --list liste les options de chaque générateur. Dans VS Code,
options { } complète leurs noms puis leurs valeurs, et le survol de l’une
d’elles indique ce qu’elle est.
Les fichiers d’une cible intégrée#
Un générateur veut souvent ce qu’écrit une cible intégrée, avec un petit
supplément. Par exemple, le C de --target c avec un fichier de glue, ou le
DBC dans une autre mise en page. Le générateur lit les fichiers de la cible
au lieu de les réécrire.
Un script appelle ctx.builtin :
module.exports = function generate(model, ctx) {
const c = ctx.builtin('c'); // { "c/arche_types.h": "…", … }
const files = {};
for (const [p, text] of Object.entries(c)) files[p] = `#pragma once_ours\n${text}`;
files['c/glue.c'] = ctx.render('…', model);
return { files };
};
Un gabarit ou une commande nomme les cibles qu’il lit avec builtins. Le
champ builtins du modèle contient alors leurs fichiers, sous la forme
{ "c": [{ "path", "text", "keep" }] } :
generator listing "What C writes" { templates "listing"; builtins c, dbc }
{{#each builtins.c}}{{ path }}: {{ text | length }} characters
{{/each}}
Ce sont les fichiers que la cible écrit avant tout hook, pour le déploiement
de l’exécution (--deployment). freertos, zephyr, posix et
components ne sont pas disponibles, car c’est Arche qui les écrit.
Hooks : après une cible#
Un hook est un générateur qui s’exécute après une cible (after) et
modifie ses fichiers. Par exemple, une entreprise place son en-tête de
licence sur chaque fichier qu’elle livre. Elle n’a pas besoin pour cela d’un
générateur complet, ni d’une retouche à la main après chaque exécution. Elle
écrit un hook :
generator license "Our license header" { script "license.js"; after c, go }
module.exports = function (model, ctx) {
const files = {};
for (const [p, text] of Object.entries(ctx.files))
if (/\.[ch]$/.test(p)) files[p] = `/* (c) ACME. All rights reserved. */\n${text}`;
files['LICENSE'] = ctx.readFile('LICENSE');
return { files };
};
archec gen --target c écrit alors les fichiers de la cible en passant par
le hook. Un hook ne renvoie que ce qu’il modifie :
- un chemin avec son texte remplace ce fichier, ou l’ajoute ;
- un chemin avec
nullsupprime le fichier ; - un fichier qu’il ne nomme pas reste tel quel.
Un hook de type commande lit la même chose dans le champ after du modèle :
{ "target": "c", "files": [{ "path", "text", "keep" }] }. Pour supprimer
un fichier, il écrit { "files": [{ "path": "c/x.h", "text": null }] }.
- Ordre : les hooks d’une cible s’exécutent dans l’ordre où ils sont
écrits. Un hook placé dans un fichier inclus compte à l’endroit où ce
fichier est inclus. Chaque hook travaille sur les fichiers que le précédent
a laissés.
archec gen --listmontre les hooks (after c). - Chemins : ils sont tels qu’écrits sous
-o(c/arche_types.h), et non sous un dossier propre au hook. - keep : un fichier marqué
keepest à vous une fois écrit. Quand la cible marque un fichierkeep, il reste marqué si un hook le modifie. Ce que le hook lui fait ne compte qu’à la première écriture du fichier.ctx.keptliste ces fichiers. - Un hook est un script ou une commande, pas des gabarits.
- Un hook ne s’exécute qu’à travers sa cible.
archec gen --target licensele signale. La cible peut être n’importe quelle cible intégrée, ou l’un des générateurs du projet.--no-hookslaisse les hooks de côté. - Le hook d’une bibliothèque ne s’exécute qu’une fois approuvé, comme ses autres scripts.
Où vont les fichiers#
Les fichiers vont dans <-o>/<output>/ :
- par défaut,
<output>est l’identifiant du générateur ; output "dir"choisit un autre dossier ;output "."écrit directement dans le dossier-o.
Un chemin qui sortirait de ce dossier est refusé. Un fichier marqué keep
est écrit une fois, puis plus jamais. --check indique ce qui changerait et
n’écrit rien.
Tester un générateur#
Commencez par approuver la sortie telle qu’elle est :
archec generator test main.arche rte --update
✓ 2 file(s) approved → expected/rte
Ensuite, comparez la sortie avec les fichiers approuvés :
archec generator test main.arche rte
✓ rte: 2 file(s) as approved
En cas d’écart, la commande liste les fichiers manquants, modifiés (à la première ligne qui diffère) et nouveaux.
Les fichiers approuvés sont rangés dans expected/<id>/, à côté de la
déclaration. Committez-les. Une modification du modèle ou du générateur
apparaît alors comme une différence en CI.
Depuis une bibliothèque, depuis le Store#
Une bibliothèque peut fournir des générateurs. Leurs chemins sont relatifs
aux fichiers de la bibliothèque. Un paquet du Store peut être de type
generator. uses acme-gen "^1.0" et include "acme-gen/generators.arche"
font de ses générateurs des cibles du projet. Un paquet de type plugin n’a
pas besoin d’include : uses suffit, et il peut aussi apporter des
importeurs et des exporteurs (plugins).
Les gabarits d’une bibliothèque s’exécutent tels quels, car ils n’exécutent aucun code. Le script ou la commande d’une bibliothèque s’exécute sur la machine de la personne qui construit le projet. Il ne s’exécute donc qu’une fois approuvé par le projet :
archec generator approve main.arche rte # lists the code it runs, then records it
L’approbation est enregistrée dans arche.lock, avec l’empreinte actuelle de
la bibliothèque. arche.lock est commité et relu avec le reste. Si la
bibliothèque change, le générateur est refusé jusqu’à une nouvelle
approbation.
--revokeretire une approbation.archec auditliste le JavaScript d’un générateur, avec le reste du code que le projet fait entrer.
Le bac à sable n’est pas une frontière de sécurité : le vm de node n’en est
pas une. C’est pourquoi l’approbation est ce qui décide.
Ce qui est vérifié#
| Code | |
|---|---|
generator |
plusieurs formes ou aucune ; un dossier ou un fichier qui n’existe pas ; un from vers un générateur qui n’existe pas, ou une chaîne qui tourne en rond ; une api que cet archec ne fournit pas ; un builtins ou un after qui nomme autre chose qu’une cible ; un hook fait de gabarits |
generator-option |
une option que ni lui, ni le générateur dont il part, ne déclare (un avertissement) ; une valeur d’un autre type, absente des values de l’option, ou une valeur par défaut qui ne correspond pas à son type (des erreurs) |
Dans VS Code#
- Exécution : une lentille ▶ Generate se trouve au-dessus de chaque générateur. Generate code… liste les générateurs du projet après les cibles intégrées. Ce que signale un générateur apparaît dans Problems, à la ligne de l’élément. La lentille d’un hook (▶ Generate c) exécute sa cible, et Generate code… exécute une cible en passant par ses hooks.
- Écriture : après
from, la complétion propose les générateurs du projet. Dansoptions { }, elle propose les options déclarées, puis leurs valeurs ; le survol indique à quoi sert chacune. Dans un fichier d’un dossiertemplates:{{propose les noms du modèle ;{{#propose les blocs ;|propose les filtres ;- le survol de chacun d’eux indique ce qu’il est.
Limites#
- Un hook est un script ou une commande. Un hook fait de gabarits est signalé (
generator). - Un hook déclaré par un plugin intégré ne s’exécute pas.
builtinsne peut pas lirefreertos,zephyr,posixnicomponents: c’est Arche qui les écrit, pas archec.- Le bac à sable n’est pas une frontière de sécurité. Le script ou la commande d’une bibliothèque ne s’exécute qu’une fois approuvé, et c’est l’approbation qui vous protège.
- archec retire les types d’un script TypeScript mais ne les vérifie jamais.
- Le C, le Rust et le Go d’un corps nomment les fonctions de votre runtime
comme le font les cibles intégrées ; c’est votre générateur qui les
fournit. Un corps Python que le langage d’action ne peut pas exprimer n’a
ni
c, nirust, nigo.