Hier (6ème jour) était seiketkm's "[J'ai développé une application Robophone qui vient du futur](http://qiita.com/seiketkm/items/ C'était 46992f933294a7668dba) ". Cet article est l'article du 7ème jour du Tech-Circle Hands on Advent Calendar 2016.

Cette fois, je voudrais créer un langage original en utilisant PLY (lex + yacc), qui est une bibliothèque d'analyse de phrases / d'analyse syntaxique de Python.

En parlant du langage original, TrumpScript, un langage de programmation inspiré de Donald Trump, a déjà été publié. https://github.com/samshadwell/TrumpScript

TrumpScript a les fonctionnalités suivantes.

Le type à virgule flottante ne peut pas être utilisé, uniquement des entiers. L'Amérique ne fait pas des choses sans enthousiasme.
Le nombre doit être supérieur à 1 million. Les nombres plus petits que cela sont insignifiants.
l'importation ne peut pas être utilisée. Tous les codes doivent être fabriqués aux États-Unis.

Tel…. De cette manière, c'est un langage plein de sens qui reproduit fidèlement M. Donald Trump.

Donc, cette fois, contrairement à TrumpScript, "[PPAPScript](https://github.com/sakaro01/PPAPScript." Je vais créer "git)".

Spécifications de script PPAP

Assurez-vous de démarrer le programme avec "PPAP"
Seules les combinaisons de "stylo", "ananas" et "pomme" peuvent être utilisées (les cas sont ignorés)
Lors de la déclaration d'une variable, préfixez toujours la variable avec "I_have_a" ou "I_have_an" (par exemple I_have_a pen = 10)
La fonction de sortie est "Ah!" (Celui qui gémit lors de la fusion?) (Exemple: Ah! Apple + stylo)
Quatre règles ordinaires
Commentaire ordinaire (# pomme + stylo)

Les spécifications que j'ai proposées sont comme ça.

Qu'est-ce que le pli

Avant d'implémenter PPAPScript, j'expliquerai le ply utilisé cette fois. ply est une bibliothèque Python qui implémente lex et yacc en Python et les rassemble sous forme de module.

lex: outil d'analyse de phrase
yacc: un outil d'analyse syntaxique

Méthode d'introduction

L'installation du pli peut être faite avec pip. Il prend également en charge python3.

$ pip install ply

À partir de là, j'expliquerai l'utilisation minimale dans lex.py et yacc.py.

Explication de lex.py

Ceci est une explication de lex.py, qui est responsable de l'analyse des phrases.

1. Importez lex.

import ply.lex as lex

2. Définissez la phrase que vous souhaitez analyser dans une variable appelée "tokens" au format tapple.

tokens = (
    'NUMBER',
    'PLUS',
    'MINUS',
    'TIMES',
    'DIVIDE',
    'LPAREN',
    'RPAREN',
)

3. Définissez une règle d'analyse des phrases à l'aide d'expressions régulières.

Il y a deux manières de le définir. Dans les deux méthodes, la convention de dénomination des noms de variables et des noms de fonctions est définie sous la forme t_ (nom de jeton).

Définition de règles d'analyse de phrases simples

t_PLUS   = r'\+'
t_MINUS  = r'-'
t_TIMES  = r'\*'
t_DIVIDE = r'/'
t_LPAREN = r'\('
t_RPAREN = r'\)'

Lors du traitement pendant l'analyse de phrase

Définissez l'expression régulière sur la première ligne de la fonction. Un objet LexToken est toujours passé en argument. Ce sera l'objet de la phrase correspondante. Dans l'exemple suivant, la valeur de jeton qui correspond à la règle d'expression régulière est convertie en type int.

def t_NUMBER(t):
    r'\d+'
    t.value = int(t.value)
    return t

4. Ignorez les chaînes inutiles.

Une variable spéciale appelée t_ignore vous permet de sauter certaines chaînes. Dans l'exemple ci-dessous, les espaces et les tabulations sont ignorés.

t_ignore = ' \t'

5. Définissez la syntaxe de destruction des jetons.

Vous pouvez définir des règles d'expression régulière de commentaire à l'aide d'une variable spéciale appelée t_ignore_COMMENT.

t_ignore_COMMENT = r'\#.*'

6. Définissez la gestion des erreurs.

La fonction t_error sera appelée si aucune phrase ne correspond.

def t_error(t):
    print("Illegal character '%s'" % t.value[0])
    t.lexer.skip(t)

7. Construisez.

Construisez avec lex (). Ceci termine la préparation de l'analyse des phrases.

lex.lex()

Explication de yacc.py

Ceci est une description de yacc.py, qui est responsable de l'analyse syntaxique.

1. Importez yacc.

import ply.yacc as yacc

Notez que les jetons définis par lex sont chargés à ce stade.

2. Écrivez la règle d'analyse syntaxique.

L'exemple suivant définit une règle de syntaxe pour l'ajout.

def p_expression_minus(p):
    'expression : expression PLUS term'
    p[0] = p[1] - p[3]

Voici les règles de définition.

Les conventions de dénomination des fonctions commencent par p_.
Les règles de syntaxe sont définies dans la chaîne de document sur la première ligne de la fonction.
Les règles de syntaxe sont des symboles sans terminaison: symbole sans terminaison ou combinaison de symboles de terminaison

def p_expression_minus(p):
    'expression : expression MINUS term'
    #Symbole sans terminaison:Symbole sans terminaison終端記号 非終端記号

Un tableau de symboles définis dans la règle de syntaxe est passé à l'argument de la fonction définie. Les index correspondent dans l'ordre à partir de la gauche.
En affectant à p [0], la valeur sera renvoyée vers le symbole de départ.

def p_expression_minus(p):
    'expression : expression MINUS term'
    #  p[0]         p[1]     p[2] p[3]
 
    p[0] = p[1] - p[3]

Le symbole sans fin de la fonction définie en premier est le symbole de départ. Dans les cas suivants, l'instruction sera le symbole de début.

def p_statement_assign(p):
    """statement : NAME EQUALS expression"""
    names[p[1]] = p[3]


def p_expression_minus(p):
    'expression : expression MINUS term'
 
    p[0] = p[1] - p[3]

3. Synthétisez les règles de syntaxe.

Des règles de syntaxe similaires peuvent être regroupées, comme indiqué ci-dessous.

def p_expression_binop(p):
    """expression : expression PLUS expression
                  | expression MINUS expression
                  | expression TIMES expression
                  | expression DIVIDE expression"""
    if p[2] == '+':
        p[0] = p[1] + p[3]
    elif p[2] == '-':
        p[0] = p[1] - p[3]
    elif p[2] == '*':
        p[0] = p[1] * p[3]
    elif p[2] == '/':
        p[0] = p[1] / p[3]

4. Définissez la gestion des erreurs.

Similaire à lex, il est appelé lorsqu'aucune règle de syntaxe ne correspond.

def p_error(p):
    print "Syntax error in input"

5. Analyser.

Créez un objet paraser avec yacc () et effectuez une analyse de syntaxe avec parser.parse (). Passez la chaîne de caractères que vous souhaitez analyser comme argument.

parser = yacc.yacc()
parser.parse(data)

Implémenter le script PPAP

L'implémentation sera créée sur la base de l'exemple README dans le référentiel ply. https://github.com/dabeaz/ply/blob/master/README.md

Démarrez le programme avec "PPAP"

L'indicateur est contrôlé par la partie qui exécute yacc.parse ().

# Started flag is true by "PPAP" command
has_started = False

def parse(data, debug=0):
    if data == "PPAP":
        global has_started
        has_started = True
        print("Started PPAPScript!")
        return

    if has_started:
        return yacc.parse(data, debug=debug)
    else:
        print('PPAPScript run by "PPAP" command.')
        return

Créez un contournement qui ignore "PPAP" dans l'expression régulière car "PPAP" est intercepté par l'analyse de la phrase de la variable (t_NAME).

def t_NAME(t):
    r"""(?!PPAP)[a-zA-Z_][a-zA-Z0-9_]*"""
    return t

Seules les combinaisons de "stylo", "ananas" et "pomme" peuvent être utilisées (les cas sont ignorés)

Vous pouvez limiter le nom de la variable avec l'expression régulière lex, mais puisque vous souhaitez émettre un message d'erreur dédié, utilisez le module re pour gérer l'erreur.

def t_NAME(t):
    r"""(?!PPAP)[a-zA-Z_][a-zA-Z0-9_]*"""
    pattern = re.compile(r'^(apple|pineapple|pen)+', re.IGNORECASE)
    if pattern.match(t.value):
        return t
    else:
        print("This variable name can't be used '%s'.\n "
              "Variable can use 'apple', 'pineapple', 'pen'." % t.value)
        t.lexer.skip(t)

Assurez-vous d'ajouter "I_have_a" ou "I_have_an" à l'affectation de déclaration des variables.

La raison de définir avec def est de donner la priorité à l'analyse des phrases. (Lex a priorité dans l'ordre défini par def) Dans ce cas, la définition est requise avant t_NAME.

def t_DECLARE(t):
    r"""I_have_(an|a)"""
    return t

La fonction de sortie est "Ah!"

Lex et yacc ont tous deux des définitions ordinaires.

def t_PRINT(t):
    r"""Ah!"""
    return t

def p_statement_print_expr(p):
    """statement : PRINT expression"""
    print(p[2])

Exécution du script PPAP

Le produit fini est publié dans le référentiel suivant, je vais donc le cloner. PPAPScript

$ git clone https://github.com/sakaro01/PPAPScript.git

Installez le pli.

$ pip install -r requirements.txt

Exécutez PPAPScript.

$ python ppapscript.py

Jouons de manière interactive. (Actuellement uniquement interactif)

Résumé

J'ai pu créer facilement une langue originale en utilisant ply.
C'était un peu décevant de ne pas pouvoir penser à de nombreuses spécifications comme TrumpScript. (Ceux qui ont proposé des spécifications intéressantes, Issue, Pull Request, attendent)

la prochaine fois

Le prochain Tech-Circle Hands on Advent Calendar 2016 sera en charge de mon synchrone Koga Yuta est. Probablement un robot. Il peut être intéressant d'appliquer cet article pour créer un langage de commande de robot original.

référence

BppLOG: Le langage de programmation "TrumpScript" inspiré par Donald Trump est trop compliqué http://tkybpp.hatenablog.com/entry/2016/07/26/150000
Github: ply https://github.com/dabeaz/ply
TYPEA.INFO: Python PLY http://typea.info/tips/wiki.cgi?page=Python+PLY
Logiciel OKI: système de traitement Algol 60 réalisé avec LY (Python Lex-Yacc) http://www.oki-osk.jp/esc/ply-algol/

J'ai essayé de créer un langage original "PPAP Script" qui imagé PPAP (Pen Pineapple Appo Pen) avec Python