Utilisez javascript pour écrire une analyse lexicale de quatre compilateurs arithmétiques

Il y a un cours appelé Compilation Principles dans notre première année, qui nous demande d'écrire nous-mêmes un compilateur simple. Eh bien, n'importe quel langage peut être utilisé, bien sûr, j'utilise js, c'est tellement élégant, même si je ne le fais pas. Je ne l'utilise pas beaucoup, grâce. Cela n'a rien à voir avec le langage, c'est juste que j'aime utiliser js, et il n'y a pas beaucoup de fonctionnalités js utilisées.

De plus, le code est un peu mauvais, alors ne vous plaignez pas.

Laissez-moi d'abord vous parler de tout mon processus

1. La première étape est l'analyse lexicale : vous devez écrire une expression régulière puis y mettre les mots et les chiffres. Découpez-les tous.

2. Construire des règles de grammaire. Ici, je choisis la grammaire LL(1). Concevez votre propre grammaire ici.

3. Construisez du code intermédiaire. Ici, j'ai utilisé un arbre de syntaxe.

4. Écrivez un programme de conversion, et quel type de phrase grammaticale correspond à quel type de programme.

Analyse lexicale :

1. Entrez une expression régulière et convertissez l'expression régulière en nfa->dfa-> ;dfa minimisé. Pour cette partie, accédez au compilateur NetEase Cloud Classroom qui utilise Java. Suivez simplement ce qui précède. J'ai suivi sa vidéo pour la partie nfa précédente.

2. Obtenez le tableau qui minimise DFA. Tout ce qui est nécessaire pour chaque expression régulière est ce tableau. Par conséquent, après avoir déterminé l’expression régulière, vous pouvez directement stocker la table sans la générer à chaque fois.

3. Ensuite, vous avez besoin d'un tas d'expressions régulières
   

1. numéro un

2. Un symbole

3. Un mot-clé

4. Un nom de variable

5. "n'importe quoi " (cela peut être utilisé pour gérer les erreurs. Si ce n'est pas 1-4 ci-dessus, alors vous pouvez utiliser 5 pour recevoir et exclure)

    var id_ = new build_rule();
    id_.build_from_str(id__str, 3);    //这个变量id__str就是那个已经生成字符串保存起来的dfa最小化的表
    //数字3就是id对应的名字，到时候用来判断来生成类型码的

    var key_word = new build_rule();
    key_word.build_from_str(key_word_str, 1);    //和上面一样

    var ops = new build_rule("{op}{op}*", 1);    //这个使用正则生成的规则的，需要经过nfa---dfa---最小化这几步的转化
    //1符号和关键字统称的类型


    var num = new build_rule("{float}", 4);    //同上

    var anything = new build_rule();
    anything.build_from_str(anything_str);
    anything.rule_name = 5;    //这个就是用来处理错误的，识别5这个类型时候就会出错，也可以记录这个出错让程序一直扫描到后面再输出错误

    //按照自己定义的规定的顺序进行添加规则，到时候就会按照这个顺序进行查找
    var qing = qingai(code);
    qing.add_rules(key_word);
    qing.add_rules(id_);
    qing.add_rules(ops);
    qing.add_rules(num);
    qing.add_rules(anything);
    qing.action();

1. Toutes les expressions régulières sont en ordre. Cela dépend de votre propre arrangement. Par exemple, la commande est :
   Nom de la variable——–>Mot clé————>Autres
   Dans ce cas, si "var" est reconnu, var sera considéré comme un nom de variable, car lorsque var n'est pas défini comme mot-clé, celui-ci peut être utilisé comme nom de variable légal.
   L'ordre doit donc être organisé par vous-même

2. Après avoir construit plusieurs expressions régulières et leur ordre, le travail commence.

3. Le code source est scanné depuis le début, et le pointeur principal pointe vers le début
   

1. Le pointeur pointe au début

2. Commencez par la première règle

3. Selon les règles de l'automate dfa, c'est-à-dire la table, si vous rencontrez un personnage , passez à cette ligne

4. Si vous pouvez encore sauter après avoir lu la suivante, passez à une autre ligne. S'il ne peut pas sauter, vérifiez si cette ligne a une marque de fin. Si c'est le cas, quittez en douceur sans chercher la règle suivante. Ajoutez ensuite la longueur de la chaîne trouvée au pointeur principal et enregistrez les informations de cette chaîne : Longueur, cela. ligne, cette colonne, quel type. Sinon, trouvez la règle suivante.

5. Parce qu'il existe une règle selon laquelle est tout , garantissant que chacun peut trouver des attributs.

6. Il y en aura encore qui ne seront pas trouvés car il y a des espaces et des sauts de ligne. Vous devez les vérifier à la fin et les filtrer.

4. Ensuite, sur la base du code source que vous avez écrit

a=7464;b=7465;a=b+7464*2;

vous pouvez obtenir une telle table 8. Le code de type suivant est le code de type qui doit être utilisé pour exprimer ce type de chaîne dans la grammaire. Plus tard, le côté grammaire utilisera le code de type pour déterminer si le symbole de phrase saisi n'est pas conforme à la grammaire donnée. Étant donné que différents mots-clés et symboles ont des significations différentes, les codes de type des mots-clés et des symboles sont différents. Mes noms de variables sont représentés par d

Étapes récapitulatives

1. <.>Entrez l'expression régulière

2. Remplacez la définition macro de l'expression régulière par des caractères normaux

3. Coupez l'expression régulière

4. Passez l'intégralité de l'expression coupée dans l'automate nfa pour construire le graphe nfa

5. Placez le nœud principal du graphe nfa Saisissez l'automate dfa pour construire la table dfa

6. et effectuez une minimisation dfa sur la table nfa pour obtenir la table minimisée dfa

7. Ceci complète une chaîne La construction de l'automate de recherche correspondant

8. répète 1 à 7 jusqu'à ce que toutes les expressions régulières soient converties. Après cela, il vous suffit de sauvegarder toutes les tables réduites et de charger cette table à chaque fois. Il n'est pas nécessaire de générer nfa, dfa ou similaire à chaque fois.

9. Mettez les règles dans le scanner dans l'ordre (en fait, il s'agit juste d'une boucle while qui écrit tous les caractères du programme source en même temps) et lancez l'analyse.

10. Obtenir la table des jetons

11. Fin

Articles associés :

Algorithmes et exemples d'analyse de quatre expressions arithmétiques en JavaScript

Analyse du principe de pré-compilation JavaScript

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!