style-script 1.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/LICENSE +22 -0
- data/bin/style +5 -0
- data/examples/blocks.style +57 -0
- data/examples/code.style +173 -0
- data/examples/hello.style +1 -0
- data/examples/poignant.style +186 -0
- data/examples/potion.style +205 -0
- data/examples/underscore.style +603 -0
- data/lib/style-script.rb +21 -0
- data/lib/style_script/command_line.rb +235 -0
- data/lib/style_script/grammar.y +491 -0
- data/lib/style_script/lexer.js +363 -0
- data/lib/style_script/lexer.rb +272 -0
- data/lib/style_script/nodes.js +756 -0
- data/lib/style_script/nodes.rb +1079 -0
- data/lib/style_script/parse_error.rb +29 -0
- data/lib/style_script/parser.js +544 -0
- data/lib/style_script/parser.rb +2716 -0
- data/lib/style_script/repl.js +33 -0
- data/lib/style_script/rewriter.js +377 -0
- data/lib/style_script/rewriter.rb +289 -0
- data/lib/style_script/runner.js +11 -0
- data/lib/style_script/scope.js +129 -0
- data/lib/style_script/scope.rb +95 -0
- data/lib/style_script/std/style-script.js +96 -0
- data/lib/style_script/style-script.js +50 -0
- data/lib/style_script/value.rb +64 -0
- data/package.json +8 -0
- data/style-script.gemspec +21 -0
- metadata +93 -0
data/lib/style-script.rb
ADDED
@@ -0,0 +1,21 @@
|
|
1
|
+
$LOAD_PATH.unshift(File.dirname(__FILE__))
|
2
|
+
require "style_script/lexer"
|
3
|
+
require "style_script/parser"
|
4
|
+
require "style_script/nodes"
|
5
|
+
require "style_script/value"
|
6
|
+
require "style_script/scope"
|
7
|
+
require "style_script/rewriter"
|
8
|
+
require "style_script/parse_error"
|
9
|
+
|
10
|
+
# Namespace for all StyleScript internal classes.
|
11
|
+
module StyleScript
|
12
|
+
|
13
|
+
VERSION = '1.0.0' # Keep in sync with the gemspec.
|
14
|
+
|
15
|
+
# Compile a script (String or IO) to JavaScript.
|
16
|
+
def self.compile(script, options={})
|
17
|
+
script = script.read if script.respond_to?(:read)
|
18
|
+
Parser.new.parse(script).compile(options)
|
19
|
+
end
|
20
|
+
|
21
|
+
end
|
@@ -0,0 +1,235 @@
|
|
1
|
+
require 'optparse'
|
2
|
+
require 'fileutils'
|
3
|
+
require 'open3'
|
4
|
+
begin
|
5
|
+
require File.expand_path(File.dirname(__FILE__) + '/../style-script')
|
6
|
+
rescue LoadError => e
|
7
|
+
puts(e.message)
|
8
|
+
puts("use \"rake build:parser\" to regenerate parser.rb")
|
9
|
+
exit(1)
|
10
|
+
end
|
11
|
+
|
12
|
+
module StyleScript
|
13
|
+
|
14
|
+
# The CommandLine handles all of the functionality of the `style`
|
15
|
+
# utility.
|
16
|
+
class CommandLine
|
17
|
+
|
18
|
+
BANNER = <<-EOS
|
19
|
+
style compiles StyleScript source files into JavaScript.
|
20
|
+
|
21
|
+
Usage:
|
22
|
+
style path/to/script.style
|
23
|
+
EOS
|
24
|
+
|
25
|
+
# Seconds to pause between checks for changed source files.
|
26
|
+
WATCH_INTERVAL = 0.5
|
27
|
+
|
28
|
+
# Path to the root of the StyleScript install.
|
29
|
+
ROOT = File.expand_path(File.dirname(__FILE__) + '/../..')
|
30
|
+
|
31
|
+
# Commands to execute StyleScripts.
|
32
|
+
RUNNERS = {
|
33
|
+
:node => "node #{ROOT}/lib/style_script/runner.js",
|
34
|
+
:std => "std -p #{ROOT} -e 'require(\"style-script\").run(system.args);'"
|
35
|
+
}
|
36
|
+
|
37
|
+
# Run the CommandLine off the contents of ARGV.
|
38
|
+
def initialize
|
39
|
+
@mtimes = {}
|
40
|
+
parse_options
|
41
|
+
return launch_repl if @options[:interactive]
|
42
|
+
return eval_scriptlet if @options[:eval]
|
43
|
+
check_sources
|
44
|
+
return run_scripts if @options[:run]
|
45
|
+
@sources.each {|source| compile_javascript(source) }
|
46
|
+
watch_style_scripts if @options[:watch]
|
47
|
+
end
|
48
|
+
|
49
|
+
# The "--help" usage message.
|
50
|
+
def usage
|
51
|
+
puts "\n#{@option_parser}\n"
|
52
|
+
exit
|
53
|
+
end
|
54
|
+
|
55
|
+
|
56
|
+
private
|
57
|
+
|
58
|
+
# Compiles (or partially compiles) the source StyleScript file, returning
|
59
|
+
# the desired JS, tokens, or lint results.
|
60
|
+
def compile_javascript(source)
|
61
|
+
script = File.read(source)
|
62
|
+
return tokens(script) if @options[:tokens]
|
63
|
+
js = compile(script, source)
|
64
|
+
return unless js
|
65
|
+
return puts(js) if @options[:print]
|
66
|
+
return lint(js) if @options[:lint]
|
67
|
+
File.open(path_for(source), 'w+') {|f| f.write(js) }
|
68
|
+
end
|
69
|
+
|
70
|
+
# Spins up a watcher thread to keep track of the modification times of the
|
71
|
+
# source files, recompiling them whenever they're saved.
|
72
|
+
def watch_style_scripts
|
73
|
+
watch_thread = Thread.start do
|
74
|
+
loop do
|
75
|
+
@sources.each do |source|
|
76
|
+
mtime = File.stat(source).mtime
|
77
|
+
@mtimes[source] ||= mtime
|
78
|
+
if mtime > @mtimes[source]
|
79
|
+
@mtimes[source] = mtime
|
80
|
+
compile_javascript(source)
|
81
|
+
end
|
82
|
+
end
|
83
|
+
sleep WATCH_INTERVAL
|
84
|
+
end
|
85
|
+
end
|
86
|
+
Signal.trap("INT") { watch_thread.kill }
|
87
|
+
watch_thread.join
|
88
|
+
end
|
89
|
+
|
90
|
+
# Ensure that all of the source files exist.
|
91
|
+
def check_sources
|
92
|
+
usage if @sources.empty?
|
93
|
+
missing = @sources.detect {|s| !File.exists?(s) }
|
94
|
+
if missing
|
95
|
+
STDERR.puts("File not found: '#{missing}'")
|
96
|
+
exit(1)
|
97
|
+
end
|
98
|
+
end
|
99
|
+
|
100
|
+
# Pipe compiled JS through JSLint (requires a working 'jsl' command).
|
101
|
+
def lint(js)
|
102
|
+
stdin, stdout, stderr = Open3.popen3('jsl -nologo -stdin')
|
103
|
+
stdin.write(js)
|
104
|
+
stdin.close
|
105
|
+
puts stdout.read.tr("\n", '')
|
106
|
+
errs = stderr.read.chomp
|
107
|
+
puts errs unless errs.empty?
|
108
|
+
stdout.close and stderr.close
|
109
|
+
end
|
110
|
+
|
111
|
+
# Eval a little piece of StyleScript directly from the command line.
|
112
|
+
def eval_scriptlet
|
113
|
+
script = STDIN.tty? ? @sources.join(' ') : STDIN.read
|
114
|
+
return tokens(script) if @options[:tokens]
|
115
|
+
js = compile(script)
|
116
|
+
return lint(js) if @options[:lint]
|
117
|
+
puts js
|
118
|
+
end
|
119
|
+
|
120
|
+
# Use Node.js or Narwhal to run an interactive StyleScript session.
|
121
|
+
def launch_repl
|
122
|
+
exec "#{RUNNERS[@options[:runner]]}"
|
123
|
+
rescue Errno::ENOENT
|
124
|
+
puts "Error: #{@options[:runner]} must be installed to use the interactive REPL."
|
125
|
+
exit(1)
|
126
|
+
end
|
127
|
+
|
128
|
+
# Use Node.js or Narwhal to compile and execute StyleScripts.
|
129
|
+
def run_scripts
|
130
|
+
sources = @sources.join(' ')
|
131
|
+
exec "#{RUNNERS[@options[:runner]]} #{sources}"
|
132
|
+
rescue Errno::ENOENT
|
133
|
+
puts "Error: #{@options[:runner]} must be installed in order to execute scripts."
|
134
|
+
exit(1)
|
135
|
+
end
|
136
|
+
|
137
|
+
# Print the tokens that the lexer generates from a source script.
|
138
|
+
def tokens(script)
|
139
|
+
puts Lexer.new.tokenize(script).inspect
|
140
|
+
end
|
141
|
+
|
142
|
+
# Compile a single source file to JavaScript.
|
143
|
+
def compile(script, source='error')
|
144
|
+
begin
|
145
|
+
options = {}
|
146
|
+
options[:no_wrap] = true if @options[:no_wrap]
|
147
|
+
options[:globals] = true if @options[:globals]
|
148
|
+
StyleScript.compile(script, options)
|
149
|
+
rescue StyleScript::ParseError => e
|
150
|
+
STDERR.puts "#{source}: #{e.message}"
|
151
|
+
exit(1) unless @options[:watch]
|
152
|
+
nil
|
153
|
+
end
|
154
|
+
end
|
155
|
+
|
156
|
+
# Write out JavaScript alongside StyleScript unless an output directory
|
157
|
+
# is specified.
|
158
|
+
def path_for(source)
|
159
|
+
filename = File.basename(source, File.extname(source)) + '.js'
|
160
|
+
dir = @options[:output] || File.dirname(source)
|
161
|
+
File.join(dir, filename)
|
162
|
+
end
|
163
|
+
|
164
|
+
# Install the StyleScript TextMate bundle to ~/Library.
|
165
|
+
def install_bundle
|
166
|
+
bundle_dir = File.expand_path('~/Library/Application Support/TextMate/Bundles/')
|
167
|
+
FileUtils.cp_r("#{ROOT}/extras/StyleScript.tmbundle", bundle_dir)
|
168
|
+
end
|
169
|
+
|
170
|
+
# Use OptionParser for all the options.
|
171
|
+
def parse_options
|
172
|
+
@options = {:runner => :node}
|
173
|
+
@option_parser = OptionParser.new do |opts|
|
174
|
+
opts.on('-i', '--interactive', 'run an interactive StyleScript REPL') do |i|
|
175
|
+
@options[:interactive] = true
|
176
|
+
end
|
177
|
+
opts.on('-r', '--run', 'compile and run a StyleScript') do |r|
|
178
|
+
@options[:run] = true
|
179
|
+
end
|
180
|
+
opts.on('-o', '--output [DIR]', 'set the directory for compiled JavaScript') do |d|
|
181
|
+
@options[:output] = d
|
182
|
+
FileUtils.mkdir_p(d) unless File.exists?(d)
|
183
|
+
end
|
184
|
+
opts.on('-w', '--watch', 'watch scripts for changes, and recompile') do |w|
|
185
|
+
@options[:watch] = true
|
186
|
+
end
|
187
|
+
opts.on('-p', '--print', 'print the compiled JavaScript to stdout') do |d|
|
188
|
+
@options[:print] = true
|
189
|
+
end
|
190
|
+
opts.on('-l', '--lint', 'pipe the compiled JavaScript through JSLint') do |l|
|
191
|
+
@options[:lint] = true
|
192
|
+
end
|
193
|
+
opts.on('-e', '--eval', 'compile a cli scriptlet or read from stdin') do |e|
|
194
|
+
@options[:eval] = true
|
195
|
+
end
|
196
|
+
opts.on('-t', '--tokens', 'print the tokens that the lexer produces') do |t|
|
197
|
+
@options[:tokens] = true
|
198
|
+
end
|
199
|
+
opts.on('-v', '--verbose', 'print at every step of code generation') do |v|
|
200
|
+
ENV['VERBOSE'] = 'true'
|
201
|
+
end
|
202
|
+
opts.on('-n', '--no-wrap', 'raw output, no function safety wrapper') do |n|
|
203
|
+
@options[:no_wrap] = true
|
204
|
+
end
|
205
|
+
opts.on('-g', '--globals', 'attach all top-level variable as globals') do |n|
|
206
|
+
@options[:globals] = true
|
207
|
+
end
|
208
|
+
opts.on_tail('--std', 'use STD instead of Node.js') do |n|
|
209
|
+
@options[:runner] = :std
|
210
|
+
end
|
211
|
+
opts.on_tail('--install-bundle', 'install the StyleScript TextMate bundle') do |i|
|
212
|
+
install_bundle
|
213
|
+
exit
|
214
|
+
end
|
215
|
+
opts.on_tail('--version', 'display StyleScript version') do
|
216
|
+
puts "StyleScript version #{StyleScript::VERSION}"
|
217
|
+
exit
|
218
|
+
end
|
219
|
+
opts.on_tail('-h', '--help', 'display this help message') do
|
220
|
+
usage
|
221
|
+
end
|
222
|
+
end
|
223
|
+
@option_parser.banner = BANNER
|
224
|
+
begin
|
225
|
+
@option_parser.parse!(ARGV)
|
226
|
+
rescue OptionParser::InvalidOption => e
|
227
|
+
puts e.message
|
228
|
+
exit(1)
|
229
|
+
end
|
230
|
+
@sources = ARGV
|
231
|
+
end
|
232
|
+
|
233
|
+
end
|
234
|
+
|
235
|
+
end
|
@@ -0,0 +1,491 @@
|
|
1
|
+
class Parser
|
2
|
+
|
3
|
+
# Declare terminal tokens produced by the lexer.
|
4
|
+
token IF ELSE UNLESS
|
5
|
+
token NUMBER STRING REGEX
|
6
|
+
token TRUE FALSE YES NO ON OFF
|
7
|
+
token IDENTIFIER PROPERTY_ACCESS PROTOTYPE_ACCESS SOAK_ACCESS
|
8
|
+
token CODE PARAM_START PARAM PARAM_END NEW RETURN
|
9
|
+
token CALL_START CALL_END INDEX_START INDEX_END
|
10
|
+
token TRY CATCH FINALLY THROW
|
11
|
+
token BREAK CONTINUE
|
12
|
+
token FOR IN OF BY WHEN WHILE UNTIL
|
13
|
+
token SWITCH LEADING_WHEN
|
14
|
+
token DELETE INSTANCEOF TYPEOF
|
15
|
+
token SUPER EXTENDS
|
16
|
+
token ASSIGN RETURN
|
17
|
+
token NEWLINE
|
18
|
+
token COMMENT
|
19
|
+
token JS
|
20
|
+
token INDENT OUTDENT
|
21
|
+
|
22
|
+
# Declare order of operations.
|
23
|
+
prechigh
|
24
|
+
left '?'
|
25
|
+
nonassoc UMINUS UPLUS NOT '!' '!!' '~' '++' '--'
|
26
|
+
left '*' '/' '%' '.'
|
27
|
+
left '+' '-'
|
28
|
+
left '<<' '>>' '>>>' '&' '|' '^'
|
29
|
+
left '<=' '<' '>' '>='
|
30
|
+
right '==' '!=' IS ISNT
|
31
|
+
left '&&' '||' AND OR
|
32
|
+
right '-=' '+=' '/=' '*=' '%=' '||=' '&&=' '?='
|
33
|
+
right DELETE INSTANCEOF TYPEOF
|
34
|
+
right INDENT
|
35
|
+
left OUTDENT
|
36
|
+
right WHEN LEADING_WHEN IN OF BY
|
37
|
+
right THROW FOR NEW SUPER
|
38
|
+
left EXTENDS
|
39
|
+
right ASSIGN RETURN
|
40
|
+
right '->' '=>' UNLESS IF ELSE WHILE UNTIL
|
41
|
+
preclow
|
42
|
+
|
43
|
+
rule
|
44
|
+
|
45
|
+
# All parsing will end in this rule, being the trunk of the AST.
|
46
|
+
Root:
|
47
|
+
/* nothing */ { result = Expressions.new }
|
48
|
+
| Terminator { result = Expressions.new }
|
49
|
+
| Expressions { result = val[0] }
|
50
|
+
| Block Terminator { result = val[0] }
|
51
|
+
;
|
52
|
+
|
53
|
+
# Any list of expressions or method body, seperated by line breaks or semis.
|
54
|
+
Expressions:
|
55
|
+
Expression { result = Expressions.wrap(val) }
|
56
|
+
| Expressions Terminator Expression { result = val[0] << val[2] }
|
57
|
+
| Expressions Terminator { result = val[0] }
|
58
|
+
;
|
59
|
+
|
60
|
+
# All types of expressions in our language. The basic unit of StyleScript
|
61
|
+
# is the expression.
|
62
|
+
Expression:
|
63
|
+
Value
|
64
|
+
| Call
|
65
|
+
| Code
|
66
|
+
| Operation
|
67
|
+
| Assign
|
68
|
+
| If
|
69
|
+
| Try
|
70
|
+
| Throw
|
71
|
+
| Return
|
72
|
+
| While
|
73
|
+
| Until
|
74
|
+
| For
|
75
|
+
| Switch
|
76
|
+
| Extends
|
77
|
+
| Splat
|
78
|
+
| Existence
|
79
|
+
| Comment
|
80
|
+
;
|
81
|
+
|
82
|
+
# A block of expressions. Note that the Rewriter will convert some postfix
|
83
|
+
# forms into blocks for us, by altering the token stream.
|
84
|
+
Block:
|
85
|
+
INDENT Expressions OUTDENT { result = val[1] }
|
86
|
+
| INDENT OUTDENT { result = Expressions.new }
|
87
|
+
;
|
88
|
+
|
89
|
+
# Tokens that can terminate an expression.
|
90
|
+
Terminator:
|
91
|
+
"\n"
|
92
|
+
| ";"
|
93
|
+
;
|
94
|
+
|
95
|
+
# All hard-coded values. These can be printed straight to JavaScript.
|
96
|
+
Literal:
|
97
|
+
NUMBER { result = LiteralNode.new(val[0]) }
|
98
|
+
| STRING { result = LiteralNode.new(val[0]) }
|
99
|
+
| JS { result = LiteralNode.new(val[0]) }
|
100
|
+
| REGEX { result = LiteralNode.new(val[0]) }
|
101
|
+
| BREAK { result = LiteralNode.new(val[0]) }
|
102
|
+
| CONTINUE { result = LiteralNode.new(val[0]) }
|
103
|
+
| TRUE { result = LiteralNode.new(Value.new(true)) }
|
104
|
+
| FALSE { result = LiteralNode.new(Value.new(false)) }
|
105
|
+
| YES { result = LiteralNode.new(Value.new(true)) }
|
106
|
+
| NO { result = LiteralNode.new(Value.new(false)) }
|
107
|
+
| ON { result = LiteralNode.new(Value.new(true)) }
|
108
|
+
| OFF { result = LiteralNode.new(Value.new(false)) }
|
109
|
+
;
|
110
|
+
|
111
|
+
# Assignment to a variable (or index).
|
112
|
+
Assign:
|
113
|
+
Value ASSIGN Expression { result = AssignNode.new(val[0], val[2]) }
|
114
|
+
;
|
115
|
+
|
116
|
+
# Assignment within an object literal (can be quoted).
|
117
|
+
AssignObj:
|
118
|
+
IDENTIFIER ASSIGN Expression { result = AssignNode.new(ValueNode.new(val[0]), val[2], :object) }
|
119
|
+
| STRING ASSIGN Expression { result = AssignNode.new(ValueNode.new(LiteralNode.new(val[0])), val[2], :object) }
|
120
|
+
| NUMBER ASSIGN Expression { result = AssignNode.new(ValueNode.new(LiteralNode.new(val[0])), val[2], :object) }
|
121
|
+
| Comment { result = val[0] }
|
122
|
+
;
|
123
|
+
|
124
|
+
# A return statement.
|
125
|
+
Return:
|
126
|
+
RETURN Expression { result = ReturnNode.new(val[1]) }
|
127
|
+
| RETURN { result = ReturnNode.new(ValueNode.new(Value.new('null'))) }
|
128
|
+
;
|
129
|
+
|
130
|
+
# A comment.
|
131
|
+
Comment:
|
132
|
+
COMMENT { result = CommentNode.new(val[0]) }
|
133
|
+
;
|
134
|
+
|
135
|
+
# Arithmetic and logical operators
|
136
|
+
# For Ruby's Operator precedence, see:
|
137
|
+
# https://www.cs.auckland.ac.nz/references/ruby/ProgrammingRuby/language.html
|
138
|
+
Operation:
|
139
|
+
'!' Expression { result = OpNode.new(val[0], val[1]) }
|
140
|
+
| '!!' Expression { result = OpNode.new(val[0], val[1]) }
|
141
|
+
| '-' Expression = UMINUS { result = OpNode.new(val[0], val[1]) }
|
142
|
+
| '+' Expression = UPLUS { result = OpNode.new(val[0], val[1]) }
|
143
|
+
| NOT Expression { result = OpNode.new(val[0], val[1]) }
|
144
|
+
| '~' Expression { result = OpNode.new(val[0], val[1]) }
|
145
|
+
| '--' Expression { result = OpNode.new(val[0], val[1]) }
|
146
|
+
| '++' Expression { result = OpNode.new(val[0], val[1]) }
|
147
|
+
| DELETE Expression { result = OpNode.new(val[0], val[1]) }
|
148
|
+
| TYPEOF Expression { result = OpNode.new(val[0], val[1]) }
|
149
|
+
| Expression '--' { result = OpNode.new(val[1], val[0], nil, true) }
|
150
|
+
| Expression '++' { result = OpNode.new(val[1], val[0], nil, true) }
|
151
|
+
|
152
|
+
| Expression '*' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
153
|
+
| Expression '/' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
154
|
+
| Expression '%' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
155
|
+
|
156
|
+
| Expression '+' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
157
|
+
| Expression '-' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
158
|
+
|
159
|
+
| Expression '<<' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
160
|
+
| Expression '>>' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
161
|
+
| Expression '>>>' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
162
|
+
|
163
|
+
| Expression '&' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
164
|
+
| Expression '|' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
165
|
+
| Expression '^' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
166
|
+
|
167
|
+
| Expression '<=' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
168
|
+
| Expression '<' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
169
|
+
| Expression '>' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
170
|
+
| Expression '>=' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
171
|
+
|
172
|
+
| Expression '==' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
173
|
+
| Expression '!=' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
174
|
+
| Expression IS Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
175
|
+
| Expression ISNT Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
176
|
+
|
177
|
+
| Expression '&&' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
178
|
+
| Expression '||' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
179
|
+
| Expression AND Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
180
|
+
| Expression OR Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
181
|
+
| Expression '?' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
182
|
+
|
183
|
+
| Expression '-=' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
184
|
+
| Expression '+=' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
185
|
+
| Expression '/=' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
186
|
+
| Expression '*=' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
187
|
+
| Expression '%=' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
188
|
+
| Expression '||=' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
189
|
+
| Expression '&&=' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
190
|
+
| Expression '?=' Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
191
|
+
|
192
|
+
| Expression INSTANCEOF Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
193
|
+
| Expression IN Expression { result = OpNode.new(val[1], val[0], val[2]) }
|
194
|
+
;
|
195
|
+
|
196
|
+
# The existence operator.
|
197
|
+
Existence:
|
198
|
+
Expression '?' { result = ExistenceNode.new(val[0]) }
|
199
|
+
;
|
200
|
+
|
201
|
+
# Function definition.
|
202
|
+
Code:
|
203
|
+
PARAM_START ParamList PARAM_END
|
204
|
+
FuncGlyph Block { result = CodeNode.new(val[1], val[4], val[3]) }
|
205
|
+
| FuncGlyph Block { result = CodeNode.new([], val[1], val[0]) }
|
206
|
+
;
|
207
|
+
|
208
|
+
# The symbols to signify functions, and bound functions.
|
209
|
+
FuncGlyph:
|
210
|
+
'->' { result = :func }
|
211
|
+
| '=>' { result = :boundfunc }
|
212
|
+
;
|
213
|
+
|
214
|
+
# The parameters to a function definition.
|
215
|
+
ParamList:
|
216
|
+
Param { result = val }
|
217
|
+
| ParamList "," Param { result = val[0] << val[2] }
|
218
|
+
;
|
219
|
+
|
220
|
+
# A Parameter (or ParamSplat) in a function definition.
|
221
|
+
Param:
|
222
|
+
PARAM
|
223
|
+
| PARAM "." "." "." { result = SplatNode.new(val[0]) }
|
224
|
+
;
|
225
|
+
|
226
|
+
# A regular splat.
|
227
|
+
Splat:
|
228
|
+
Expression "." "." "." { result = SplatNode.new(val[0]) }
|
229
|
+
;
|
230
|
+
|
231
|
+
# Expressions that can be treated as values.
|
232
|
+
Value:
|
233
|
+
IDENTIFIER { result = ValueNode.new(val[0]) }
|
234
|
+
| Literal { result = ValueNode.new(val[0]) }
|
235
|
+
| Array { result = ValueNode.new(val[0]) }
|
236
|
+
| Object { result = ValueNode.new(val[0]) }
|
237
|
+
| Parenthetical { result = ValueNode.new(val[0]) }
|
238
|
+
| Range { result = ValueNode.new(val[0]) }
|
239
|
+
| This { result = ValueNode.new(val[0]) }
|
240
|
+
| Value Accessor { result = val[0] << val[1] }
|
241
|
+
| Invocation Accessor { result = ValueNode.new(val[0], [val[1]]) }
|
242
|
+
;
|
243
|
+
|
244
|
+
# Accessing into an object or array, through dot or index notation.
|
245
|
+
Accessor:
|
246
|
+
PROPERTY_ACCESS IDENTIFIER { result = AccessorNode.new(val[1]) }
|
247
|
+
| PROTOTYPE_ACCESS IDENTIFIER { result = AccessorNode.new(val[1], :prototype) }
|
248
|
+
| SOAK_ACCESS IDENTIFIER { result = AccessorNode.new(val[1], :soak) }
|
249
|
+
| Index { result = val[0] }
|
250
|
+
| Slice { result = SliceNode.new(val[0]) }
|
251
|
+
;
|
252
|
+
|
253
|
+
# Indexing into an object or array.
|
254
|
+
Index:
|
255
|
+
INDEX_START Expression INDEX_END { result = IndexNode.new(val[1]) }
|
256
|
+
;
|
257
|
+
|
258
|
+
# An object literal.
|
259
|
+
Object:
|
260
|
+
"{" AssignList "}" { result = ObjectNode.new(val[1]) }
|
261
|
+
;
|
262
|
+
|
263
|
+
# Assignment within an object literal (comma or newline separated).
|
264
|
+
AssignList:
|
265
|
+
/* nothing */ { result = [] }
|
266
|
+
| AssignObj { result = val }
|
267
|
+
| AssignList "," AssignObj { result = val[0] << val[2] }
|
268
|
+
| AssignList Terminator AssignObj { result = val[0] << val[2] }
|
269
|
+
| AssignList ","
|
270
|
+
Terminator AssignObj { result = val[0] << val[3] }
|
271
|
+
| INDENT AssignList OUTDENT { result = val[1] }
|
272
|
+
;
|
273
|
+
|
274
|
+
# All flavors of function call (instantiation, super, and regular).
|
275
|
+
Call:
|
276
|
+
Invocation { result = val[0] }
|
277
|
+
| NEW Invocation { result = val[1].new_instance }
|
278
|
+
| Super { result = val[0] }
|
279
|
+
;
|
280
|
+
|
281
|
+
# Extending an object's prototype.
|
282
|
+
Extends:
|
283
|
+
Value EXTENDS Value { result = ExtendsNode.new(val[0], val[2]) }
|
284
|
+
;
|
285
|
+
|
286
|
+
# A generic function invocation.
|
287
|
+
Invocation:
|
288
|
+
Value Arguments { result = CallNode.new(val[0], val[1]) }
|
289
|
+
| Invocation Arguments { result = CallNode.new(val[0], val[1]) }
|
290
|
+
;
|
291
|
+
|
292
|
+
# The list of arguments to a function invocation.
|
293
|
+
Arguments:
|
294
|
+
CALL_START ArgList CALL_END { result = val[1] }
|
295
|
+
;
|
296
|
+
|
297
|
+
# Calling super.
|
298
|
+
Super:
|
299
|
+
SUPER CALL_START ArgList CALL_END { result = CallNode.new(Value.new('super'), val[2]) }
|
300
|
+
;
|
301
|
+
|
302
|
+
# This references, either naked or to a property.
|
303
|
+
This:
|
304
|
+
'@' { result = ThisNode.new }
|
305
|
+
| '@' IDENTIFIER { result = ThisNode.new(val[1]) }
|
306
|
+
;
|
307
|
+
|
308
|
+
# The range literal.
|
309
|
+
Range:
|
310
|
+
"[" Expression
|
311
|
+
"." "." Expression "]" { result = RangeNode.new(val[1], val[4]) }
|
312
|
+
| "[" Expression
|
313
|
+
"." "." "." Expression "]" { result = RangeNode.new(val[1], val[5], true) }
|
314
|
+
;
|
315
|
+
|
316
|
+
# The slice literal.
|
317
|
+
Slice:
|
318
|
+
INDEX_START Expression "." "."
|
319
|
+
Expression INDEX_END { result = RangeNode.new(val[1], val[4]) }
|
320
|
+
| INDEX_START Expression "." "." "."
|
321
|
+
Expression INDEX_END { result = RangeNode.new(val[1], val[5], true) }
|
322
|
+
;
|
323
|
+
|
324
|
+
# The array literal.
|
325
|
+
Array:
|
326
|
+
"[" ArgList "]" { result = ArrayNode.new(val[1]) }
|
327
|
+
;
|
328
|
+
|
329
|
+
# A list of arguments to a method call, or as the contents of an array.
|
330
|
+
ArgList:
|
331
|
+
/* nothing */ { result = [] }
|
332
|
+
| Expression { result = val }
|
333
|
+
| INDENT Expression { result = [val[1]] }
|
334
|
+
| ArgList "," Expression { result = val[0] << val[2] }
|
335
|
+
| ArgList Terminator Expression { result = val[0] << val[2] }
|
336
|
+
| ArgList "," Terminator Expression { result = val[0] << val[3] }
|
337
|
+
| ArgList "," INDENT Expression { result = val[0] << val[3] }
|
338
|
+
| ArgList OUTDENT { result = val[0] }
|
339
|
+
;
|
340
|
+
|
341
|
+
# Just simple, comma-separated, required arguments (no fancy syntax).
|
342
|
+
SimpleArgs:
|
343
|
+
Expression { result = val[0] }
|
344
|
+
| SimpleArgs "," Expression { result = ([val[0]] << val[2]).flatten }
|
345
|
+
;
|
346
|
+
|
347
|
+
# Try/catch/finally exception handling blocks.
|
348
|
+
Try:
|
349
|
+
TRY Block Catch { result = TryNode.new(val[1], val[2][0], val[2][1]) }
|
350
|
+
| TRY Block FINALLY Block { result = TryNode.new(val[1], nil, nil, val[3]) }
|
351
|
+
| TRY Block Catch
|
352
|
+
FINALLY Block { result = TryNode.new(val[1], val[2][0], val[2][1], val[4]) }
|
353
|
+
;
|
354
|
+
|
355
|
+
# A catch clause.
|
356
|
+
Catch:
|
357
|
+
CATCH IDENTIFIER Block { result = [val[1], val[2]] }
|
358
|
+
;
|
359
|
+
|
360
|
+
# Throw an exception.
|
361
|
+
Throw:
|
362
|
+
THROW Expression { result = ThrowNode.new(val[1]) }
|
363
|
+
;
|
364
|
+
|
365
|
+
# Parenthetical expressions.
|
366
|
+
Parenthetical:
|
367
|
+
"(" Expression ")" { result = ParentheticalNode.new(val[1], val[0].line) }
|
368
|
+
;
|
369
|
+
|
370
|
+
# The while loop. (there is no do..while).
|
371
|
+
While:
|
372
|
+
WHILE Expression Block { result = WhileNode.new(val[1], val[2]) }
|
373
|
+
| WHILE Expression { result = WhileNode.new(val[1], nil) }
|
374
|
+
| Expression WHILE Expression { result = WhileNode.new(val[2], Expressions.wrap(val[0])) }
|
375
|
+
;
|
376
|
+
|
377
|
+
# The until loop.
|
378
|
+
Until:
|
379
|
+
UNTIL Expression Block { result = UntilNode.new(val[1], val[2]) }
|
380
|
+
| UNTIL Expression { result = UntilNode.new(val[1], nil) }
|
381
|
+
| Expression UNTIL Expression { result = UntilNode.new(val[2], Expressions.wrap(val[0])) }
|
382
|
+
;
|
383
|
+
|
384
|
+
# Array comprehensions, including guard and current index.
|
385
|
+
# Looks a little confusing, check nodes.rb for the arguments to ForNode.
|
386
|
+
For:
|
387
|
+
Expression FOR
|
388
|
+
ForVariables ForSource { result = ForNode.new(val[0], val[3], val[2][0], val[2][1]) }
|
389
|
+
| FOR ForVariables ForSource Block { result = ForNode.new(val[3], val[2], val[1][0], val[1][1]) }
|
390
|
+
;
|
391
|
+
|
392
|
+
# An array comprehension has variables for the current element and index.
|
393
|
+
ForVariables:
|
394
|
+
IDENTIFIER { result = val }
|
395
|
+
| IDENTIFIER "," IDENTIFIER { result = [val[0], val[2]] }
|
396
|
+
;
|
397
|
+
|
398
|
+
# The source of the array comprehension can optionally be filtered.
|
399
|
+
ForSource:
|
400
|
+
IN Expression { result = {:source => val[1]} }
|
401
|
+
| OF Expression { result = {:source => val[1], :object => true} }
|
402
|
+
| ForSource
|
403
|
+
WHEN Expression { result = val[0].merge(:filter => val[2]) }
|
404
|
+
| ForSource
|
405
|
+
BY Expression { result = val[0].merge(:step => val[2]) }
|
406
|
+
;
|
407
|
+
|
408
|
+
# Switch/When blocks.
|
409
|
+
Switch:
|
410
|
+
SWITCH Expression INDENT
|
411
|
+
Whens OUTDENT { result = val[3].rewrite_condition(val[1]) }
|
412
|
+
| SWITCH Expression INDENT
|
413
|
+
Whens ELSE Block OUTDENT { result = val[3].rewrite_condition(val[1]).add_else(val[5]) }
|
414
|
+
;
|
415
|
+
|
416
|
+
# The inner list of whens.
|
417
|
+
Whens:
|
418
|
+
When { result = val[0] }
|
419
|
+
| Whens When { result = val[0] << val[1] }
|
420
|
+
;
|
421
|
+
|
422
|
+
# An individual when.
|
423
|
+
When:
|
424
|
+
LEADING_WHEN SimpleArgs Block { result = IfNode.new(val[1], val[2], nil, {:statement => true}) }
|
425
|
+
| LEADING_WHEN SimpleArgs Block
|
426
|
+
Terminator { result = IfNode.new(val[1], val[2], nil, {:statement => true}) }
|
427
|
+
| Comment Terminator When { result = val[2].add_comment(val[0]) }
|
428
|
+
;
|
429
|
+
|
430
|
+
# The most basic form of "if".
|
431
|
+
IfBlock:
|
432
|
+
IF Expression Block { result = IfNode.new(val[1], val[2]) }
|
433
|
+
;
|
434
|
+
|
435
|
+
# An elsif portion of an if-else block.
|
436
|
+
ElsIf:
|
437
|
+
ELSE IfBlock { result = val[1].force_statement }
|
438
|
+
;
|
439
|
+
|
440
|
+
# Multiple elsifs can be chained together.
|
441
|
+
ElsIfs:
|
442
|
+
ElsIf { result = val[0] }
|
443
|
+
| ElsIfs ElsIf { result = val[0].add_else(val[1]) }
|
444
|
+
;
|
445
|
+
|
446
|
+
# Terminating else bodies are strictly optional.
|
447
|
+
ElseBody
|
448
|
+
/* nothing */ { result = nil }
|
449
|
+
| ELSE Block { result = val[1] }
|
450
|
+
;
|
451
|
+
|
452
|
+
# All the alternatives for ending an if-else block.
|
453
|
+
IfEnd:
|
454
|
+
ElseBody { result = val[0] }
|
455
|
+
| ElsIfs ElseBody { result = val[0].add_else(val[1]) }
|
456
|
+
;
|
457
|
+
|
458
|
+
# The full complement of if blocks, including postfix one-liner ifs and unlesses.
|
459
|
+
If:
|
460
|
+
IfBlock IfEnd { result = val[0].add_else(val[1]) }
|
461
|
+
| Expression IF Expression { result = IfNode.new(val[2], Expressions.wrap(val[0]), nil, {:statement => true}) }
|
462
|
+
| Expression UNLESS Expression { result = IfNode.new(val[2], Expressions.wrap(val[0]), nil, {:statement => true, :invert => true}) }
|
463
|
+
;
|
464
|
+
|
465
|
+
end
|
466
|
+
|
467
|
+
---- header
|
468
|
+
module StyleScript
|
469
|
+
|
470
|
+
---- inner
|
471
|
+
# Lex and parse a StyleScript.
|
472
|
+
def parse(code)
|
473
|
+
# Uncomment the following line to enable grammar debugging, in combination
|
474
|
+
# with the -g flag in the Rake build task.
|
475
|
+
# @yydebug = true
|
476
|
+
@tokens = Lexer.new.tokenize(code)
|
477
|
+
do_parse
|
478
|
+
end
|
479
|
+
|
480
|
+
# Retrieve the next token from the list.
|
481
|
+
def next_token
|
482
|
+
@tokens.shift
|
483
|
+
end
|
484
|
+
|
485
|
+
# Raise a custom error class that knows about line numbers.
|
486
|
+
def on_error(error_token_id, error_value, value_stack)
|
487
|
+
raise ParseError.new(token_to_str(error_token_id), error_value, value_stack)
|
488
|
+
end
|
489
|
+
|
490
|
+
---- footer
|
491
|
+
end
|