Chika
1.0.0
Chika est un langage de programmation ciblant à la fois Arduino en tant que micrologiciel ou Linux en tant qu'exécutable. Il facilite la multitâche à robin routier de haut niveau, le chargement des programmes à partir d'un système de fichiers SD ou de Linux.
Son objectif est de se pencher vers l'agilité sur la vitesse et l'empreinte de la mémoire, avec un modèle de mémoire de pile unique, une syntaxe inspirée de LISP et une messagerie interne de style MQTT.
Son esprit est: découpler tout grâce à la communication inter-tâches.
Visitez le site Web pour plus d'informations , y compris la justification, les comparaisons avec d'autres projets, photos, etc.
Visitez la discorde pour discuter.
Voir Core.chi et le reste du corpus pour plus d'exemples réalistes.
Remarque : ;//… est utilisé pour utiliser la mise en évidence de la syntaxe de Clojure; Les commentaires dans Chika sont juste //… .
; //Calculates Nth term of Fibonacci Sequence
( fn fib n
( if ( < n 3 ) 1 i
( + ( fib ( - n 1 )) ( fib ( - n 2 )))))
( fib 35 ) => 9227465
; //LED blink program for Arduino
( p-mode 32 T)
( fn heartbeat on
( dig-w 32 on)
( sleep 1000 w)
( ! on))
; //Prints `15`
( print
( do a= + b= 10 c= 5
( a b c)))
; //Prints `Hello!`
( fn my-print
( print str))
( do str= " Hello! "
( my-print ))
; //Filter function, found in core.chi
; //Note: `empty?`, `st`, `append`, and `odd?` are all implemented in Chika in core.chi
; //Note: `out` is an optional argument, as `append` accepts nil as a vector
( fn filter f v ; ; out
( if ( empty? v)
out
( do next= ( st v)
( recur f ( sect v)
( if ( f next)
( append out next)
out)))))
( filter odd? [ 0 1 2 3 ]) => [ 1 3 ]
; //Returns [15 9], using an inline-function with one argument - `#`
( map {# 12 3 } [+ -])
; //Subscribes to all inter-program messages to do with displays, and prints their payloads
( sub " display/+ " {print # 1 }) Ouvrez Chika_Arduino.ino dans Arduino IDE, téléchargez sur votre Arduino.
Assurez-vous qu'il existe une carte SD insérée avec le fichier init.kua . D'autres programmes doivent être chargés dans le fichier init.kua avec l'opération load .
Appareils appropriés:
Il existe actuellement quelques options pour compiler et exécuter Chika sur Linux.
Dans le terminal, vous pouvez exécuter ./compile.sh pour recompiler Chika VM pour votre machine, qui utilise également le compilateur natif pour recompiler corpus/programs/init.chi .
Pour exécuter un fichier source Chika .chi ou .kua compilé, vous pouvez invoquer l'exécutable chika avec son chemin, tel que: ./chika ../corpus/programs/fibonacci.chi . Cela compilera fibonacci.chi en tant que fibonacci.kua dans le répertoire de travail de l'exécutable.
Les fichiers source peuvent être admis avec un shebang à l'exécutable Chika pour exécuter directement un fichier .chi .
Sur PC: Invoquez l'exécutable chika tel que ./chika c source.chi . Invoquez sans l'indicateur c pour compiler, puis exécutez le fichier résultant.
Sur PC / Arduino: utilisez la comp dans Chika pour compiler les fichiers source .chi .
Remarque: cela peut prendre un certain temps sur l'Arduino car il se compile avec une mémoire très limitée, écrivant principalement un octet dans un fichier à la fois.
Remarque: La compilation émet de nombreux fichiers temporaires, qui doivent être supprimés après une compilation réussie.
Chaque programme chargé dans la machine virtuelle a une durée de vie de:
Tous ces éléments sont facultatifs, mais au moins un battement de cœur ou une entrée doit être spécifié dans un programme.
L'entrée est le code exécuté au début du programme, avant tout battement de cœur ou messages, et n'est contenu dans aucune fonction. Il peut appeler les fonctions avant même leur déclaration dans le fichier source. La dernière entrée a renvoyé les graines de l'article l'état du programme. Le code d'entrée est déchargé après utilisation, il ne peut donc pas être appelé par la suite.
Les battements cardiaques sont nécessaires pour arrêter un programme se terminant immédiatement après l'entrée, en incluant une fonction appelée heartbeat . Ceci est exécuté à plat par programme, la fonction de battement de cœur, style rond. La fonction heartbeat est transmise à l'état persistant du programme en tant que paramètre, et le retour est persisté comme le nouvel état.
Les messages sont diffusés dans toute la machine virtuelle et exécutent toutes les fonctions de rappel, ont également passé l'état du programme et renvoyant le nouvel état.
Les étiquettes et les noms de fonction peuvent inclure (presque) tous les caractères excluant les espaces blancs.
Les noms de fonction ne doivent pas commencer par un chiffre.
#num : première ligne de fichier uniquement (ou seconde si un shebang est présent). Informe la machine virtuelle du nombre d'octets de RAM ( num jusqu'à 64KIB) sera utilisé par le programme. Sinon, un maximum par défaut est utilisé.
(func[ N args]) : une forme, avec une fonction dans la position de la tête, et des arguments 0-n séparés par des espaces. Les arguments peuvent être des formulaires.
Remarque: func peut être une opération native, une fonction de programme, une fonction en ligne, une liaison, une liaison étendue, un paramètre ou un paramètre étendu.
(fn func-name[ N params] [1-N forms]) : une définition de fonction, avec des symboles de paramètres 0-n séparés par des espaces et des formulaires 1-n.
Remarque: l'appel d'une fonction sans formulaires ne renvoie pas.
{form} : une fonction en ligne, composée comme une forme.
Remarque: Les paramètres des fonctions environnants ne peuvent pas être référencés dans les fonctions en ligne. Considérez plutôt en utilisant une liaison.
Remarque: les fonctions en ligne imbriquées sont interdites.
# : une référence de paramètre, au premier paramètre d'une fonction.
$ : une référence de paramètre étendue, au premier paramètre de la fonction de l'appelant d'une fonction.
#N et $N : une référence de paramètre, au Nth Paramètre, par exemple #3 ou $3 pour le quatrième paramètre de la fonction ou de la fonction de l'appelant de la fonction.
Remarque: l'utilisation $ en cas de fonction d'appel n'est pas un comportement non défini.
Remarque: Les références de valeur $ peuvent être effacées par optimisation de l'appel de queue.
//… : un commentaire, qui peut être adapté sur une nouvelle ligne ou à la fin d'un.
/*…*/ : Un commentaire multiligne. Remarque: une instance de */ mettra fin à un commentaire immédiatement et ne peut pas être contenue dans un commentaire multiligne lui-même
; : Un point-virgule, traité comme un espace blanc.
, : une virgule, traitée comme un espace et un espace blanc après son effacement.
…= : Liant, par lequel … est une étiquette.
… : Référence de liaison ou référence des paramètres en fonction du contexte, où … est son étiquette.
.… : Une référence contraignante étendue, où … est son étiquette. Il fait référence à l'instance précédente d'une liaison sur la pile.
Remarque: les paramètres ont du précédent sur les liaisons par fonction.
Remarque: Lors de la redéfinition des liaisons, il faut utiliser une liaison étendue, donc la machine virtuelle saute l'instance précédente. Considérez: a= (+ 1 .a) , de sorte que a ne fait pas référence à l'élément suivant sur la pile à ce moment - 1 .
Les fonctions if , && , or , et case ne peuvent pas être représentées dans une liaison ou un paramètre.
Comme les fonctions ne doivent contenir que les formulaires assurez-vous que les rendements utilisent val .
Remarque: les entiers sont soit au format hexadécimal décimal ou grand-endian.
"…" : String, par lequel … sont 0 à 128 caractères ASCII, ou "" pour vide." et str pour les doubles quotations, car les chaînes ne fournissent pas de caractères échappés.0 ou 0x00 : entier non signé 8 bits.0w ou 0x0000 : entier non signé 16 bits.0i ou 0x00000000 : entier signé 32 bits.c : caractère ASCII. Étendu: nl newline, sp espace.[…] : Vector, par lequel … sont 0 à 2 ^ 16 éléments délimités par l'espace, ou [] pour vide. Sucre syntaxique pour (vec …) args : émet un vecteur d'arguments de fonction.T : littéral booléen vraiF : False booléen littéralN : littéral nil Remarque: [square brackets] indiquent des arguments facultatifs.
Mathématique
+ / - / * / / / % / ** /
& / | / ^ / << / >> n arg:
Renvoie la somme / soustraction / multiplication / division / module / augmentation à la puissance /
Et / ou / xor / décalage de gauche / droite de n entiers.
Zero Args renvoie nul. Jetera tous les paramètres comme le type du premier argument.
~ n : retourne bitwise pas de n .
Exemples: (+ 1 1) => 2 , (+ 155 200) => 100 , (+ 155w 200) => 355w
rand : Renvoie un pseudo-aléatoire booléen.
rand b : Renvoie un entier pseudo-aléatoire de 0 à b exclusif.
rand ab : Renvoie un entier pseudo-aléatoire d' a exclusif inclusif à b
Remarque: a ou b négatifs les font être compris comme 1.
Conditionnel
if cond if-true : évalue et revient if-true si cond est vraie, sinon.
if cond if-true if-false : évalue et revient if-true si cond est vrai, sinon if-false .
case match … N pairs … [default] : évalue match , puis se compare au 1er de chaque paire d'arguments, renvoyant le 2e si le 1er correspond; Si aucune correspondance n'est faite default ou nulle n'est renvoyée.
! i : Nie logiquement l'élément i .
or n arg: renvoie la première vérité arg.
&& n arg: renvoie vrai si tous les args vérité.
= N arg: égalité, vrai si tous les args sont du même type, longueur et égalité d'octets. Compare les INTS par valeur.
!= N arg: égalité négative.
== N Arg: Equity, Renvoie True si n éléments sont d'égalité d'octets.
!== N Arg: Équité négative.
< / <= / > / >= N arg: Renvoie True si n les éléments sont en augmentation monotone / non décroissante / décroissante / non croissante.
Fonction liée
return[ val] : quittez une fonction tôt, en évaluant Nil ou val .
recur n Arg: Sur la pile, remplacez les paramètres par N arguments et rappelez la fonction.
val 1-n Arg: renvoie son premier argument.
do 1-n Arg: renvoie son dernier argument.
Chaîne, vecteur et blob lié
vec 0 Arg: Renvoie un vecteur vide.
vec n Arg: renvoie le vecteur de ses arguments.
nth N i : Renvoie un élément ou un caractère à l'index N de Vector ou String i , ou NIL si N est dans une plage inappropriée.
str 0 arg: renvoie la chaîne vide.
str N Arg: renvoie la concaténation de n arguments en tant que chaîne.
len i : Renvoie le vecteur, la chaîne ou la longueur interne de l'élément.
sect v : Renvoie v avec le premier élément (si vecteur) ou le caractère (si String) omis;
sect v skip : retourne v avec les premiers éléments / personnages skip omis;
sect v skip take : Returns v avec take longueur et les premiers éléments / caractères skip ;
..sect : Identique à sect mais renvoie des éléments / caractères.
blob ls : Renvoie une goutte de longueur l avec tous les octets définis sur s .
get oltb : Renvoie l'élément de type t et Longueur l à partir des octets OFT o de l'article b .
get ob : Renvoie une valeur U08 d'octet à Offset o Bytes de l'article b .
set oib : Renvoie Blob b avec Offset o octets définis sur les octets de l'article i .
Remarque: les deux get et set le retour nil si le décalage + Len est demandé dépasserait la taille du blob.
Remarque: les deux acceptent une référence comme b (par exemple *binding ), et inspectera / modifieront plutôt les octets de l'élément de référence d'origine, set le renvoi de la référence ou nul.
.. v : éclate un vecteur ou une chaîne v sur la pile d'argument sous forme d'éléments de vecteur ou d'éléments de caractère.
Remarque: Comme dans Clojure inversé, apply par exemple (+ (.. [1 2 3]) (.. [4 5 6])) => 21 .
Remarque: Si son argument n'est pas un vecteur, il ne laisse aucun objet sur la pile.
binds : déduplique toutes les liaisons dans ses arguments, favorisant les plus récentes, puis vectorisant les restes.
Exemple: (binds a= 1 b= 2 a= 3) => [b= 2 a= 3]
GPIO lié
Remarque: Ceux-ci n'ont aucun effet sur PC.
p-mode pin mode : Définit le mode de la pin du numéro de broche sur le mode booléen - vraie comme entrée, false comme sortie; Renvoie NIL.
dig-r pin : Renvoie l'état d'entrée numérique de pin du numéro de broche.
dig-w [1-N pin val] : par pin val , successivement, définit l'état de sortie numérique de la pin du numéro de broche à la val booléenne - vraie ou non nulle comme haut, zéro ou bien bas; Renvoie NIL.
ana-r pin : Renvoie l'état d'entrée analogique de pin du numéro de broche.
ana-w [1-N pin val] : par pin val , successivement, définit l'état de sortie analogique / PWM de pin de numéro de broche à la val entière 16 bits; Renvoie NIL.
ana-r pin : Renvoie une entrée entière 16 bits analogique de pin de numéro de broche.
Fichier lié à IO
Remarque: sur les fichiers Arduino ne doivent avoir pas plus de trois caractères.
file-r path : renvoie le blob du contenu des fichiers entiers.
file-r path T : renvoie la taille du fichier.
file-r path offset : renvoie le blob du contenu du fichier entre les octets de décalage et EOF.
file-r path offset count : Renvoie un blob de contenu de fichier entre le décalage et jusqu'à compter les octets.
Tous renvoient à nulle en cas de défaillance.
file-a path content : Ajoute un blob ou un élément sous forme de chaîne dans le fichier.
file-w path content[ offset] : écrit un blob ou un élément sous forme de chaîne dans un fichier, éventuellement avec un décalage d'octet (sinon 0); Renvoie le succès en tant que booléen.
Les deux retournent le succès en tant que booléen.
Remarque: les chaînes sont écrites sans terminateur nul.
file-d path : supprime le fichier sur path ; Renvoie le succès en tant que booléen.
Types et casting
type i : Renvoie le code de type de l'article i .
type ab : Renvoie le code de type des éléments a & b s'ils sont égaux, sinon nil .
cast it : renvoie l'article i lance comme code de type t .
Remarque: plus fin à un fin sera tronqué, plus mince à plus large sera à zéro;
La chaîne à blob manquera de terminaison nul; Les moulages aux chaînes seront annexés avec une terminaison nul.
Itération
reduce f[ s*N] i : Renvoie la réduction du vecteur ou de la chaîne i à f , avec des graines de 0-N. f IS (item acc) => acc .
map fv*N : retourne mappage des vecteurs 1-n via f , où f est (item*N) => mapped .
Exemple: (map str [a b c] [1 2 3]) => [a1 b2 c3]
for fv*N : renvoie le mappage itératif des vecteurs 1-n via f , où f (item*N) => mapped .
Exemple: (for str [a b c] [1 2 3]) => [a1 a2 a3 b1 b2 b3 c1 c2 c3]
loop nf : répète n nombre 16 bits de fois la fonction f , où f est (0…n) => any ; Renvoie le dernier retour de f .
loop seed nf : Identique à ci-dessus, mais f est (acc 0…n) => any où acc est d'abord seed puis le retour de l'itération précédente.
loop seed abf : Identique à ci-dessus, sauf que n varie de a à b .
Exemple: (loop 2 {print "hello" #}) imprime "Hello0" et "Hello1", renvoie nil.
Exemple: (loop 0 5 +) => 10 .
Exemple: (loop 0 5 10 +) => 35
Lié au message
Les sujets sont des chaînes délimitées en avant ( / ). Les sujets de l'ONU / d'abonnement utilisent les wildcards /+/ pour n'importe quel et /# pour toute suite .
Exemple: La house/kitchen/fridge correspond à la house/+/fridge ou house/# ou +/kitchen/+ ou # , mais pas garage/# ou house/bedroom/fridge ou house/+/sink .
pub topic[ payload] : Envoyez un message dans toute la machine virtuelle avec le topic de la rubrique String, et éventuellement une payload utile (sinon nulle) de tout type;
Renvoie NIL, ou si le message a provoqué un autre programme à publier un message auquel le programme de publication original a été abonné,
Renvoie l'État renvoyé par le gestionnaire d'abonnement du programme de publication original.
Remarque: La publication est immédiate et synchrone - votre programme devra attendre pendant que les abonnés traitent le message.
f -sujet f topic sub topic f[ provide-topic]
où si provide-topic est la vérité f est (state topic payload) => new-state ,
else (par défaut) f est (state payload) => new-state ; Renvoie NIL.
Remarque: seules les fonctions du programme sont acceptées comme f - pour utiliser une opération native Utilisez une fonction en ligne.
unsub topic : supprimer l'abonnement précédent du topic ; Renvoie NIL.
unsub : supprimer tous les abonnements du programme; Renvoie NIL.
Système et programme liés
ms-now : retourne les millisecondes depuis l'initialisation CHVM.
sleep ms : reporte le prochain rythme cardiaque du programme pour ms Miliseconds; Renvoie NIL.
print 0-n Arg: Imprime le résultat de str de n args; Renvoie NIL.
load path : charge le programme CHIKA compilé sur path (sans extension de fichier); Renvoie la bobe du succès du chargement du programme.
comp path-in[ path-out] : compile un fichier source (idiomatiquement *.chi ) à path-in en tant que binaire chika, soit enregistré sur le même chemin avec l'extension changée en .kua ou sur path-out (idiomatiquement *.kua ).
halt : termine immédiatement le programme Chika.
Un binaire Chika compilé est composé uniquement de fonctions . Les fonctions contiennent des formulaires . Les formulaires contiennent des args (qui peuvent également être des formulaires) et se terminent avec une opération . Les formats d'octets hexadécimaux sont:
fonction
NNNNLLLL…
NNNN , uint16_t ID de fonction d'incrémentation; LLLL , uint16_t Longueur du corps de la fonction; … , LLLL -Llegth Function Body.
formulaire
00…args…OO
00 , marqueur de formulaire; [args] , 0-n args; OO une opération.
arg
ou 00… , un formulaire
AA , uint8_t arg-code; … Corps d'argument sur mesure de taille variable.
opération
OO
OO , Uint8_t OP-code.
00 FRM Formulaire
FAIRE
FAIRE
