Class: Antelope::Ace::Compiler

Inherits:
Object
  • Object
show all
Defined in:
lib/antelope/ace/compiler.rb

Overview

Compiles a set of tokens generated by Scanner. These tokens may not nessicarily have been generated by Scanner, however the tokens must follow the same rules even still.

A list of all tokens that this compiler accepts:

  • :directive (2 arguments)
  • :copy (1 argument)
  • :second (no arguments)
  • :label (1 argument)
  • :part (1 argument)
  • :or (no arguments)
  • :prec (1 argument)
  • :block (1 argument)
  • :third (no arguments)
  • :body (1 argument)

The tokens are handled by methods that follow the rule compile_<token name>.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(tokens) ⇒ Compiler

Initialize the compiler. The compiler keeps track of a state; this state is basically which part of the file we're in. The state can be :first, :second, or :third; some tokens may not exist in certain states.

Parameters:

  • tokens (Array<Array<(Symbol, Object, ...)>>) —

    the tokens from the Scanner.



88
89
90
91
92
93
94
95
96
 
# File 'lib/antelope/ace/compiler.rb', line 88

def initialize(tokens)
  @tokens   = tokens
  @body     = ""
  @state    = :first
  @rules    = []
  @current  = nil
  @current_label = nil
  @options  = { :terminals => [], :prec => [], :extra => {} }
end

Instance Attribute Details

#body ⇒ String

The body of the output compiler. This should be formatted in the language that the parser is to be written in. Some output generators may have special syntax that allows the parser to be put in the body; see the output generators for more.

Returns:

  • (String) 


35
36
37
 
# File 'lib/antelope/ace/compiler.rb', line 35

def body
  @body
end

#options ⇒ Hash

Options defined by directives in the first part of the file.

  • :terminals (Array<Symbol, String?)>) — A list of all of the terminals in the language. If this is not properly defined, the grammar will throw an error saying that a symbol used in the grammar is not defined.
  • :prec (Array<(Symbol, Array<Symbol>)>) — A list of the precedence rules of the grammar. The first element of each element is the type of precedence (and should be any of :left, :right, or :nonassoc), and the second element should be the symbols that are on that level.
  • :type (String) — The type of generator to generate; this should be a language.
  • :extra (Hash<Symbol, Array<Object>>) — Extra options that are not defined here.

Returns:

  • (Hash) 


70
71
72
 
# File 'lib/antelope/ace/compiler.rb', line 70

def options
  @options
end

#rules ⇒ Array<Hash>

A list of all the rules that are defined in the file. The rules are defined as such:

  • label (Symbol) — The left-hand side of the rule; this is the nonterminal that the right side reduces to.
  • set (Array<Symbol>) — The right-hand side of the rule. This is a combination of terminals and nonterminals.
  • block (String) — The code to be run on a reduction. this should be formatted in the language that the output parser is written in. Optional; default value is "".
  • prec (String) — The precedence level for the rule. This should be a nonterminal or terminal. Optional; default value is "".

Returns:

  • (Array<Hash>) 


52
53
54
 
# File 'lib/antelope/ace/compiler.rb', line 52

def rules
  @rules
end

Class Method Details

.compile(tokens) ⇒ Compiler

Creates a compiler, and then runs the compiler.

Parameters:

  • tokens (Array<Array<(Symbol, Object, ...)>>) —

    the tokens from the Scanner.

Returns:

See Also:



77
78
79
 
# File 'lib/antelope/ace/compiler.rb', line 77

def self.compile(tokens)
  new(tokens).compile
end

Instance Method Details

#compare_versions(required) ⇒ void (private)

This method returns an undefined value.

Compares the required version and the Antelope version.

Raises:



285
286
287
288
289
290
291
292
293
294
 
# File 'lib/antelope/ace/compiler.rb', line 285

def compare_versions(required)
  antelope_version = Gem::Version.new(Antelope::VERSION)
  required_version = Gem::Requirement.new(required)

  unless required_version =~ antelope_version
    raise IncompatibleVersionError,
      "Grammar requires #{required}, " \
      "have #{Antelope::VERSION}"
  end
end

#compile ⇒ self

Runs the compiler on the input tokens. For each token, it calls compile_<type> with <type> being the first element of the token, with the remaining part of the array passed as arguments.

Returns:

  • (self) 


111
112
113
114
115
116
117
 
# File 'lib/antelope/ace/compiler.rb', line 111

def compile
  @tokens.each do |token|
    send(:"compile_#{token[0]}", *token[1..-1])
  end

  self
end

#compile_block(block) ⇒ void

This method returns an undefined value.

Compiles a block. This should only occur in a rule definition, and in the second part. It sets the block on the current rule.

Parameters:

  • block (String) —

    the block.



248
249
250
251
 
# File 'lib/antelope/ace/compiler.rb', line 248

def compile_block(block)
  require_state! :second
  @current[:block] = block
end

#compile_copy(body) ⇒ void

This method returns an undefined value.

Compiles a copy token. A copy token basically copies its argument directly into the body. Used in both the first and third parts.

Parameters:

  • body (String) —

    the string to copy into the body.



174
175
176
177
 
# File 'lib/antelope/ace/compiler.rb', line 174

def compile_copy(body)
  require_state! :first, :third
  @body << body
end

#compile_directive(name, args) ⇒ void

This method returns an undefined value.

Compiles a directive. This may only be triggered in the first section of the file. The directive accepts two arguments. The directive name can be any of the following:

  • :terminal — adds a terminal. Requires 1-2 arguments; the first argument is the terminal name, and the second argument is a string that can represent the terminal.
  • :require — requires a certain version of Antelope. Requires 1 argument. If the first argument is a version greater than the current version of Antelope, it raises an error.
  • :left — creates a new precedence level, with the argument values being the symbols. The precedence level is left associative.
  • :right — creates a new precedence level, with the argument valeus being the symbols. The precedence level is right associative.
  • :nonassoc — creates a nre precedence level, with the argument values being the symbols. The precedence level is nonassociative.
  • :type — the type of parser to generate. This should correspond to the output language of the parser.

Parameters:

  • name (String, Symbol) —

    the name of the directive. Accepts any of :terminal, :require, :left, :right, :nonassoc, and :type. Any other values produce an error on stderr and are put in the :extra hash on #options.

  • args (Array<String>) —

    the arguments to the directive.

See Also:



150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
 
# File 'lib/antelope/ace/compiler.rb', line 150

def compile_directive(name, args)
  require_state! :first
  name = name.intern
  case name
  when :terminal, :token
    @options[:terminals] << [args[0].intern, args[1]]
  when :require
    compare_versions(args[0])
  when :left, :right, :nonassoc
    @options[:prec] << [name, *args.map(&:intern)]
  when :type
    @options[:type] = args[0]
  else
    @options[:extra][name] = args
    $stderr.puts "Unknown Directive: #{name}"
  end
end

#compile_label(label) ⇒ void

This method returns an undefined value.

Compiles a label. This starts a rule definition. The token should only exist in the second part. A rule definition occurs by setting the @current_label to the first argument, and @current to a blank rule save the label set. If a rule definition was already in progress, it is completed.

Parameters:

  • label (String) —

    the left-hand side of the rule; it should be a nonterminal.



195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
 
# File 'lib/antelope/ace/compiler.rb', line 195

def compile_label(label)
  require_state! :second
  if @current
    @rules << @current
  end

  @current_label = label.intern

  @current = {
    label: @current_label,
    set:   [],
    block: "",
    prec:  ""
  }
end

#compile_or ⇒ void

This method returns an undefined value.

Compiles an or. This should only occur in a rule definition, and in the second part. It starts a new rule definition by calling #compile_label with the current label.

See Also:



227
228
229
 
# File 'lib/antelope/ace/compiler.rb', line 227

def compile_or
  compile_label(@current_label)
end

#compile_part(text) ⇒ Object

Compiles a part. This should only occur during a rule definition. The token should only exist in the second part. It adds the first argument to the set of the current rule.

Parameters:

  • text (String) —

    the symbol to append to the current rule.



216
217
218
219
 
# File 'lib/antelope/ace/compiler.rb', line 216

def compile_part(text)
  require_state! :second
  @current[:set] << text.intern
end

#compile_prec(prec) ⇒ void

This method returns an undefined value.

Compiles the precedence operator. This should only occur in a rule definition, and in the second part. It sets the precedence definition on the current rule.

Parameters:

  • prec (String) —

    the precedence of the rule.



237
238
239
240
 
# File 'lib/antelope/ace/compiler.rb', line 237

def compile_prec(prec)
  require_state! :second
  @current[:prec] = prec
end

#compile_second ⇒ void

This method returns an undefined value.

Sets the state to the second part.



182
183
184
 
# File 'lib/antelope/ace/compiler.rb', line 182

def compile_second
  @state = :second
end

#compile_third ⇒ void

This method returns an undefined value.

Sets the state to the third part. If a rule definition was in progress, it finishes the rule.



257
258
259
260
261
262
263
264
 
# File 'lib/antelope/ace/compiler.rb', line 257

def compile_third
  if @current
    @rules << @current
    @current_label = @current = nil
  end

  @state = :third
end

#inspect ⇒ String

Pretty inspect.

Returns:

  • (String) 


101
102
103
 
# File 'lib/antelope/ace/compiler.rb', line 101

def inspect
  "#<#{self.class} state=#{@state.inspect} options=#{@options.inspect}>"
end

#require_state!(*state) ⇒ void (private)

This method returns an undefined value.

Checks the current state against the given states.

Raises:



273
274
275
276
277
278
 
# File 'lib/antelope/ace/compiler.rb', line 273

def require_state!(*state)
  raise InvalidStateError,
    "In state #{@state}, " \
    "required state #{state.join(", ")}" \
    unless state.include?(@state)
end