Cours Initialisation Coroutines en Lua en PDF


Télécharger Cours Initialisation Coroutines en Lua en PDF

★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


Cours Initialisation Coroutines en Lua [Eng]

...

Lua est un langage de programmation d'extension conçu pour prendre en charge la programmation procédurale générale avec des fonctionnalités de description de données. Il offre également un bon support pour la programmation orientée objet, la programmation fonctionnelle et la programmation pilotée par les données. Lua est destiné à être utilisé comme un langage de script puissant et léger pour tout programme qui en a besoin. Lua est implémenté comme une bibliothèque, écrite en C propre (c'est-à-dire, dans le sous-ensemble commun de ANSI C et C ++).

En tant que langage d'extension, Lua n'a pas la notion d'un programme "principal": il ne fonctionne que dans un client hôte, appelé programme d'intégration ou simplement l'hôte. Ce programme hôte peut appeler des fonctions pour exécuter un morceau de code Lua, écrire et lire des variables Lua et enregistrer des fonctions C appelées par le code Lua. Grâce à l'utilisation des fonctions C, Lua peut être étendu pour faire face à un large éventail de domaines différents, créant ainsi des langages de programmation personnalisés partageant un cadre syntaxique. La distribution Lua comprend un exemple de programme hôte appelé lua, qui utilise la bibliothèque Lua pour offrir un interpréteur Lua complet et autonome.

Lua est un logiciel libre, et est fourni comme d'habitude sans garantie, comme indiqué dans sa licence. La mise en œuvre décrite dans ce manuel est disponible sur le site officiel de Lua, www.lua.org.

Comme tout autre manuel de référence, ce document est sec par endroit. Pour une discussion des décisions derrière la conception de Lua, voir les documents techniques disponibles sur le site Web de Lua. Pour une introduction détaillée à la programmation de Lua, voir le livre de Roberto, Programming in Lua (Deuxième édition).

2 - La langue

Cette section décrit le lexique, la syntaxe et la sémantique de Lua. En d'autres termes, cette section décrit quels jetons sont valides, comment ils peuvent être combinés et ce que signifient leurs combinaisons.

Les constructions de langage seront expliquées en utilisant la notation BNF étendue habituelle, dans laquelle {a} signifie 0 ou plus, et [a] signifie un optionnel a. Les non-terminaux sont montrés comme non-terminaux, les mots-clés sont montrés comme kword, et d'autres symboles terminaux sont montrés comme `= '. La syntaxe complète de Lua peut être trouvée au §8 à la fin de ce manuel.

2.1 - Conventions lexicales

Les noms (également appelés identifiants) dans Lua peuvent être n'importe quelle chaîne de lettres, de chiffres et de traits de soulignement, ne commençant pas par un chiffre. Cela coïncide avec la définition des noms dans la plupart des langues. (La définition de la lettre dépend des paramètres régionaux actuels: tout caractère considéré comme alphabétique par les paramètres régionaux actuels peut être utilisé dans un identificateur.) Les identificateurs sont utilisés pour nommer les variables et les champs de table.

Les mots clés suivants sont réservés et ne peuvent pas être utilisés comme noms:

     et casser autrement elseif

     fin faux pour la fonction si

     en local nul ou

     répéter le retour puis vrai jusqu'à ce que tout

Lua est un langage sensible à la casse: et est un mot réservé, mais And et AND sont deux noms différents et valides. En tant que convention, les noms commençant par un trait de soulignement suivi de majuscules (comme _VERSION) sont réservés aux variables globales internes utilisées par Lua.

Les chaînes suivantes indiquent d'autres jetons:

     + - * /% ^ #

     == ~ = <=> = <> =

     () {} []

     ; :,. .. ...

Les chaînes littérales peuvent être délimitées en faisant correspondre des guillemets simples ou doubles, et peuvent contenir les séquences d'échappement de type C suivantes: '\ a' (cloche), '\ b' (retour arrière), '\ f' (saut de page), '\ n '(nouvelle ligne),' \ r '(retour chariot),' \ t '(onglet horizontal),' \ v '(onglet vertical),' \\ '(barre oblique inverse),' \ "'(guillemets doubles quote]), et '\' (apostrophe [guillemet simple]) .En outre, une barre oblique inversée suivie d'un retour à la ligne réel entraîne un saut de ligne dans la chaîne.Un caractère dans une chaîne peut également être spécifié par sa valeur numérique sequence \ ddd, où ddd est une suite de trois chiffres décimaux maximum. (Notez que si un échappement numérique doit être suivi d'un chiffre, il doit être exprimé avec exactement trois chiffres.) Les chaînes de Lua peuvent contenir n'importe quel caractère 8 bits valeur, y compris les zéros incorporés, qui peuvent être spécifiés comme '\ 0'.

Les chaînes littérales peuvent également être définies en utilisant un long format entouré de longues parenthèses. Nous définissons une parenthèse longue d'ouverture de niveau n comme un crochet carré d'ouverture suivi de n signes égaux suivis d'un autre crochet d'ouverture. Ainsi, une parenthèse d'ouverture de niveau 0 s'écrit [[, une parenthèse d'ouverture de niveau 1 s'écrit [= [, et ainsi de suite. Une longue parenthèse de fermeture est définie de manière similaire; par exemple, une parenthèse de fermeture de niveau 4 est écrite comme] ====]. Une longue chaîne commence par une longue parenthèse d'ouverture de n'importe quel niveau et se termine à la première longue parenthèse fermante du même niveau. Les littéraux de cette forme entre crochets peuvent s'exécuter sur plusieurs lignes, n'interpréter aucune séquence d'échappement et ignorer les longues parenthèses de tout autre niveau. Ils peuvent contenir n'importe quoi sauf un crochet de fermeture du niveau approprié.

Pour plus de commodité, lorsque la parenthèse d'ouverture longue est immédiatement suivie d'une nouvelle ligne, la nouvelle ligne n'est pas incluse dans la chaîne. A titre d'exemple, dans un système utilisant ASCII (dans lequel 'a' est codé 97, newline est codé 10 et '1' est codé 49), les cinq chaînes littérales ci-dessous désignent la même chaîne:

     a = 'alo \ n123' '

     a = "alo \ n123 \" "

     a = '\ 97lo \ 10 \ 04923 "'

     a = [[alo

     123 "]]

     a = [== [

     alo

     123 "] ==]

Une constante numérique peut être écrite avec une partie décimale optionnelle et un exposant décimal optionnel. Lua accepte aussi les constantes hexadécimales entières, en les préfixant avec 0x. Des exemples de constantes numériques valides sont

     3 3,0 3,1416 314,16e-2 0,31416E1 0xff 0x56

Un commentaire commence par un double trait d'union (-) n'importe où en dehors d'une chaîne. Si le texte immédiatement après - n'est pas une parenthèse d'ouverture longue, le commentaire est un court commentaire, qui court jusqu'à la fin de la ligne. Dans le cas contraire, il s'agit d'un commentaire long, qui s'exécute jusqu'à la parenthèse de fermeture correspondante. Les longs commentaires sont fréquemment utilisés pour désactiver le code temporairement.

2.2 - Valeurs et types

Lua est un langage dynamiquement typé. Cela signifie que les variables n'ont pas de types; seules les valeurs le font. Il n'y a aucune définition de type dans la langue. Toutes les valeurs portent leur propre type.

Toutes les valeurs dans Lua sont des valeurs de première classe. Cela signifie que toutes les valeurs peuvent être stockées dans des variables, passées en arguments à d'autres fonctions et renvoyées en tant que résultats.

Il existe huit types de base dans Lua: nil, booléen, nombre, chaîne, fonction, données utilisateur, thread et table. Nil est le type de la valeur nulle, dont la propriété principale est d'être différente de toute autre valeur; il représente généralement l'absence d'une valeur utile. Boolean est le type des valeurs false et true. Les deux nil et faux rendent une condition fausse; toute autre valeur le rend vrai. Nombre représente les nombres réels (en virgule flottante double précision). (Il est facile de construire des interpréteurs Lua qui utilisent d'autres représentations internes pour des nombres, tels que float à simple précision ou entiers longs, voir le fichier luaconf.h.) String représente des tableaux de caractères. Lua est propre à 8 bits: les chaînes peuvent contenir n'importe quel caractère de 8 bits, y compris les zéros incorporés ('\ 0') (voir §2.1).



Lua peut appeler (et manipuler) les fonctions écrites en Lua et les fonctions écrites en C (voir §2.5.8).

Le type userdata est fourni pour permettre le stockage de données C arbitraires dans des variables Lua. Ce type correspond à un bloc de mémoire brute et n'a pas d'opérations prédéfinies dans Lua, à l'exception des tests d'affectation et d'identité. Cependant, en utilisant des métabalises, le programmeur peut définir des opérations pour les valeurs de données utilisateur (voir §2.8). Les valeurs UserData ne peuvent pas être créées ou modifiées dans Lua, uniquement via l'API C. Cela garantit l'intégrité des données appartenant au programme hôte.

Le thread de type représente des threads d'exécution indépendants et il est utilisé pour implémenter des coroutines (voir §2.11). Ne confondez pas les threads Lua avec les threads du système d'exploitation. Lua supporte les coroutines sur tous les systèmes, même ceux qui ne supportent pas les threads.

La table de types implémente des tableaux associatifs, c'est-à-dire des tableaux qui peuvent être indexés non seulement avec des nombres, mais avec n'importe quelle valeur (sauf nil). Les tables peuvent être hétérogènes; c'est-à-dire qu'ils peuvent contenir des valeurs de tous les types (sauf nil). Les tables sont le seul mécanisme de structuration des données de Lua; ils peuvent être utilisés pour représenter des tableaux ordinaires, des tables de symboles, des ensembles, des enregistrements, des graphiques, des arbres, etc. Pour représenter des enregistrements, Lua utilise le nom de champ comme index. Le langage supporte cette représentation en fournissant a.name comme sucre syntaxique pour un ["nom"]. Il y a plusieurs manières commodes de créer des tables dans Lua (voir §2.5.7).

Comme les indices, la valeur d'un champ de table peut être de n'importe quel type (sauf nul). En particulier, comme les fonctions sont des valeurs de première classe, les champs de table peuvent contenir des fonctions. Ainsi, les tables peuvent également porter des méthodes (voir §2.5.9).

Les tables, les fonctions, les threads et les valeurs de données utilisateur (complètes) sont des objets: les variables ne contiennent pas réellement ces valeurs, seulement des références à celles-ci. Les affectations, les passages de paramètres et les retours de fonctions manipulent toujours des références à de telles valeurs; ces opérations n'impliquent aucun type de copie.

Le type de fonction de bibliothèque renvoie une chaîne décrivant le type d'une valeur donnée.

2.2.1 - Coercition

Lua fournit une conversion automatique entre les valeurs de chaîne et de nombre lors de l'exécution. Toute opération arithmétique appliquée à une chaîne tente de convertir cette chaîne en un nombre, en suivant les règles de conversion habituelles. Inversement, chaque fois qu'un nombre est utilisé où une chaîne est attendue, le nombre est converti en une chaîne, dans un format raisonnable. Pour un contrôle complet sur la façon dont les nombres sont convertis en chaînes, utilisez la fonction format de la bibliothèque de chaînes (voir string.format).

2.3 - Variables

Les variables sont des lieux qui stockent des valeurs. Il y a trois types de variables dans Lua: les variables globales, les variables locales et les champs de table.

Un seul nom peut désigner une variable globale ou une variable locale (ou le paramètre formel d'une fonction, qui est un type particulier de variable locale):

var :: = Nom

Le nom dénote des identifiants, comme défini au §2.1.

Toute variable est supposée être globale à moins qu'elle ne soit explicitement déclarée comme locale (voir § 2.4.7). Les variables locales ont une portée lexicale: les variables locales peuvent être librement accédées par des fonctions définies dans leur portée (voir §2.6).

Avant la première affectation à une variable, sa valeur est nulle.

Les crochets sont utilisés pour indexer une table:

var :: = prefixexp `['exp`]'

La signification des accès aux variables globales et aux champs de la table peut être modifiée via des métabalises. Un accès à une variable indexée t [i] est équivalent à un appel gettable_event (t, i). (Voir §2.8 pour une description complète de la fonction gettable_event Cette fonction n'est pas définie ou appelable dans Lua Nous l'utilisons ici uniquement à titre explicatif.)

La syntaxe var.Name est juste du sucre syntaxique pour var ["Name"]:

var :: = prefixexp `.'Nom

Toutes les variables globales vivent sous forme de champs dans des tables Lua ordinaires, appelées tables d'environnement ou simplement environnements (voir §2.9). Chaque fonction a sa propre référence à un environnement, de sorte que toutes les variables globales de cette fonction se réfèrent à cette table d'environnement. Lorsqu'une fonction est créée, elle hérite de l'environnement de la fonction qui l'a créée. Pour obtenir la table d'environnement d'une fonction Lua, vous appelez getfenv. Pour le remplacer, vous appelez setfenv. (Vous ne pouvez manipuler l'environnement des fonctions C qu'à travers la bibliothèque de débogage (voir §5.9).)

Un accès à une variable globale x est équivalent à _env.x, ce qui équivaut à

     gettable_event (_env, "x")

où _env est l'environnement de la fonction en cours d'exécution. (Voir §2.8 pour une description complète de la fonction gettable_event Cette fonction n'est pas définie ou invoquable dans Lua De même, la variable _env n'est pas définie dans Lua Nous les utilisons ici uniquement à titre explicatif.)

2.4 - Les déclarations

Lua prend en charge un ensemble d'instructions presque classique, similaire à Pascal ou C. Cet ensemble comprend des affectations, des structures de contrôle, des appels de fonctions et des déclarations de variables.

2.4.1 - Morceaux

L'unité d'exécution de Lua est appelée un morceau. Un morceau est simplement une séquence d'instructions qui sont exécutées séquentiellement. Chaque instruction peut être éventuellement suivie d'un point-virgule:

chunk :: = {stat [`; ']}

Il n'y a pas de déclaration vide et donc ';;' n'est pas légal.

Lua gère un morceau comme le corps d'une fonction anonyme avec un nombre variable d'arguments (voir §2.5.9). En tant que tels, les morceaux peuvent définir des variables locales, recevoir des arguments et renvoyer des valeurs.

Un fragment peut être stocké dans un fichier ou dans une chaîne dans le programme hôte. Pour exécuter un bloc, Lua commence par pré-compiler le bloc en instructions pour une machine virtuelle, puis exécute le code compilé avec un interpréteur pour la machine virtuelle.

Les morceaux peuvent également être pré-compilés sous forme binaire; voir le programme luac pour plus de détails. Les programmes dans les sources et les formes compilées sont interchangeables; Lua détecte automatiquement le type de fichier et agit en conséquence.

2.4.2 - Blocs

Un bloc est une liste d'instructions; syntaxiquement, un bloc est identique à un bloc:

block :: = bloc

Un bloc peut être explicitement délimité pour produire une seule instruction:

stat :: = faire une fin de bloc

Les blocs explicites sont utiles pour contrôler la portée des déclarations de variables. Des blocs explicites sont aussi parfois utilisés pour ajouter une déclaration de retour ou de pause au milieu d'un autre bloc (voir § 2.4.4).

2.4.3 - Affectation

Lua permet plusieurs affectations. Par conséquent, la syntaxe pour l'affectation définit une liste de variables sur le côté gauche et une liste d'expressions sur le côté droit. Les éléments des deux listes sont séparés par des virgules:

stat :: = varlist `= 'explist

varlist :: = var {`, 'var}

explist :: = exp {`, 'exp}

Les expressions sont discutées au § 2.5.

Avant l'affectation, la liste des valeurs est ajustée à la longueur de la liste des variables. S'il y a plus de valeurs que nécessaire, les valeurs en excès sont rejetées. S'il y a moins de valeurs que nécessaire, la liste est étendue avec autant de valeurs nulles que nécessaire. Si la liste d'expressions se termine par un appel de fonction, alors toutes les valeurs renvoyées par cet appel entrent dans la liste des valeurs, avant l'ajustement (sauf si l'appel est entre parenthèses, voir §2.5).



L'instruction d'affectation évalue d'abord toutes ses expressions et ce n'est qu'alors que les affectations sont exécutées. Ainsi le code

     i = 3

     je, a [i] = i + 1, 20

définit un [3] à 20, sans affecter un [4] parce que le i dans un [i] est évalué (à 3) avant d'être affecté 4. De même, la ligne

     x, y = y, x

échange les valeurs de x et y, et

     x, y, z = y, z, x

permute cycliquement les valeurs de x, y et z.

La signification des affectations aux variables globales et aux champs de table peut être modifiée via des métabalises. Une affectation à une variable indexée t [i] = val est équivalente à settable_event (t, i, val). (Voir §2.8 pour une description complète de la fonction settable_event Cette fonction n'est pas définie ou appelable dans Lua Nous l'utilisons ici uniquement à titre explicatif.)

Une affectation à une variable globale x = val est équivalente à l'affectation _env.x = val, qui à son tour est équivalente à

     settable_event (_env, "x", val)

où _env est l'environnement de la fonction en cours d'exécution. (La variable _env n'est pas définie dans Lua. Nous l'utilisons ici uniquement à des fins explicatives.)

2.4.4 - Structures de contrôle

Les structures de contrôle si, tandis que, et répétez ont la signification habituelle et la syntaxe familière:

stat :: = alors que exp fait la fin du bloc

stat :: = répète le bloc jusqu'à exp

stat :: = if exp puis block {elseif exp puis block} [else block] end

Lua a aussi une déclaration for, en deux saveurs (voir § 2.4.5).

L'expression de condition d'une structure de contrôle peut renvoyer n'importe quelle valeur. Les deux faux et nul sont considérés comme faux. Toutes les valeurs différentes de nil et false sont considérées comme vraies (en particulier, le nombre 0 et la chaîne vide sont également vrais).

Dans la boucle repeat-until, le bloc interne ne se termine pas au mot-clé until, mais seulement après la condition. Ainsi, la condition peut se référer à des variables locales déclarées à l'intérieur du bloc de boucle.

L'instruction return est utilisée pour renvoyer des valeurs d'une fonction ou d'un morceau (qui n'est qu'une fonction). Les fonctions et les blocs peuvent renvoyer plusieurs valeurs, ainsi la syntaxe de l'instruction return est

stat :: = return [explist]

L'instruction break est utilisée pour terminer l'exécution d'un while, repeat ou for loop, en passant à l'instruction suivante après la boucle:

stat :: = pause

Une pause termine la boucle d'enfermement la plus profonde.

Les instructions return et break ne peuvent être écrites que comme la dernière instruction d'un bloc. S'il est vraiment nécessaire de retourner ou de casser au milieu d'un bloc, alors un bloc interne explicite peut être utilisé, comme dans les idiomes retournent la fin et font la fin, parce que maintenant le retour et le break sont les dernières ) des blocs.

2.4.5 - Pour déclaration

L'instruction for a deux formes: une numérique et une générique.

La boucle numérique pour répète un bloc de code pendant qu'une variable de contrôle parcourt une progression arithmétique. Il a la syntaxe suivante:

stat :: = pour Name `= 'exp`,' exp [`, 'exp]

Le bloc est répété pour le nom commençant à la valeur de la première exp, jusqu'à ce qu'il passe la deuxième exp par les étapes de la troisième exp. Plus précisément, une déclaration pour comme

     pour v = e1, e2, e3 faire une fin de bloc

est équivalent au code:

     faire

       var local, limite, pas = tonumber (e1), tonumber (e2), tonumber (e3)

       sinon (var et limit et step) then error () fin

       while (étape> 0 et var <= limite) ou (étape <= 0 et var> = limite)

         local v = var

         bloc

         var = var + étape

       fin

     fin

Notez ce qui suit:

  • Les trois expressions de contrôle ne sont évaluées qu'une seule fois avant le démarrage de la boucle. Ils doivent tous entraîner des nombres.
  • var, limit et step sont des variables invisibles. Les noms indiqués ici sont à titre explicatif seulement.
  • Si la troisième expression (l'étape) est absente, un pas de 1 est utilisé.
  • Vous pouvez utiliser break pour quitter une boucle for.
  • La variable de boucle v est locale à la boucle; vous ne pouvez pas utiliser sa valeur après la fin for ou est cassé. Si vous avez besoin de cette valeur, assignez-la à une autre variable avant de rompre ou de quitter la boucle.

L'instruction générique for fonctionne sur les fonctions, appelées itérateurs. À chaque itération, la fonction itérateur est appelée pour produire une nouvelle valeur, en s'arrêtant lorsque cette nouvelle valeur est nulle. La boucle générique pour a la syntaxe suivante:

stat :: = pour namelist dans explist

namelist :: = Nom {`, 'Nom}

A pour une déclaration comme

     pour var_1, ···, var_n dans explist faire la fin du bloc

est équivalent au code:

     faire

       local f, s, var = explist

       alors que vrai

         local var_1, ···, var_n = f (s, var)

         var = var_1

         si var == nul alors casse la fin

         bloc

       fin

     fin



109