Xavier Nayrac

Rubyiste accro au TDD, serial blogger, apprenti data scientist, heureux utilisateur de Vim, accordéoniste.
Si vous vous sentez particulièrement généreux, suivez moi sur Twitter.

Implémenter un langage sur Parrot - partie 9: la syntaxe

| Comments

Après avoir écrit un tokenizer, avoir produit les unités lexicales et avoir défini une grammaire pour le langage Naam, je passe maintenant à la vérification de la syntaxe.

La vérification de la syntaxe se passe dans la classe Compiler. - C’est pas le meilleur choix de nom et ça changera par la suite -. Basiquement, cette classe ne fait que suivre la logique de la grammaire.

lib/naam/compiler.rb
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
class Compiler

  # units - Array of LexicalUnits
  def compile units
    @units = units
    program
  end

  private

  def program
    while @units.size > 0
      case @units.first.type
      when :eol then accept(:eol)
      else
        instruction
      end
    end
  end

  def instruction
    case @units.first.type
    when :keyword then print_statement
    when :word then function_def
    else
      raise Error
    end
  end

  def print_statement
    accept(:keyword, 'print')
    accept_series(:word, :paro, :int, :parc, :eol)
  end

  def function_def
    accept_series(:word, :paro, :word, :parc, :affect, :eol)
    if_clause while if_clause?
    else_clause
  end

  def if_clause
    accept(:int)
    accept(:keyword, 'if')
    test
    accept(:eol)
  end

  def else_clause
    accept(:int)
    accept(:keyword, 'else')
    accept(:eol)
  end

  def test
    accept_series(:word, :op, :int)
  end

  def accept(type, value = '')
    unit = @units.slice!(0)
    raise Error unless unit.type == type
    if value != ''
      raise Error unless unit.value == value
    end
  end

  def accept_series(*args)
    args.each {|arg| accept(arg) }
  end

  def if_clause?
    @units[1].type == :keyword && @units[1].value == 'if'
  end
end

Quelques commentaires sur ce code:

1
2
3
4
5
6
def instruction
  # ...
  else
    raise Error
  end
end

Plusieurs fois j’utilise la classe Error, qui n’existe pas. C’est parce que je ne veux pas encore réfléchir à la gestion des erreurs. Les seuls cas qui m’intéressent pour l’instant sont ceux où ça fonctionne.

1
2
3
4
5
6
7
def accept(type, value = '')
  unit = @units.slice!(0)
  raise Error unless unit.type == type
  if value != ''
    raise Error unless unit.value == value
  end
end

C’est la méthode accept, toute simple, qui effectue la vérification de la syntaxe en comparant l’unité lexicale attendue avec celle réellement disponible. On constate que les unités lexicales (représentées par @units) sont détruites au fur et à mesure de leur consommation.

La prochaine, il sera enfin temps d’émettre le code PIR.

À demain.

Articles connexes

Commentaires