kotovalexarian-likes-github
/
jashkenas--coffeescript
mirror of https://github.com/jashkenas/coffeescript.git
1
0
Fork 0
Code Releases Activity

finished commenting everything but the nodes -- they're up next

This commit is contained in:
Jeremy Ashkenas 2009-12-17 22:54:24 -05:00
parent 77704d24a2
commit d124f7fc0d
5 changed files with 525 additions and 486 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
lib/coffee_script/lexer.rb
View File

@ -1,7 +1,11 @@
module CoffeeScript
# The lexer reads a stream of CoffeeScript and divvys it up into tagged
# tokens. A minor bit of the ambiguity in the grammar has been avoided by
# pushing some extra smarts into the Lexer.
class Lexer
# The list of keywords passed verbatim to the parser.
KEYWORDS = ["if", "else", "then", "unless",
"true", "false", "null",
"and", "or", "is", "aint", "not",
@ -13,6 +17,7 @@ module CoffeeScript
"super",
"delete"]
# Token matching regexes.
IDENTIFIER = /\A([a-zA-Z$_]\w*)/
NUMBER = /\A\b((0(x|X)[0-9a-fA-F]+)|([0-9]+(\.[0-9]+)?(e[+\-]?[0-9]+)?))\b/i
STRING = /\A("(.*?)[^\\]"|'(.*?)[^\\]')/m
@ -24,19 +29,22 @@ module CoffeeScript
CODE = /\A(=>)/
REGEX = /\A(\/(.*?)[^\\]\/[imgy]{0,4})/
# Token cleaning regexes.
JS_CLEANER = /(\A`|`\Z)/
MULTILINER = /[\r\n]/
# Tokens that always constitute the start of an expression.
EXP_START = ['{', '(', '[']
# Tokens that always constitute the end of an expression.
EXP_END = ['}', ')', ']']
# This is how to implement a very simple scanner.
# Scan one caracter at the time until you find something to parse.
# Scan by attempting to match tokens one character at a time. Slow and steady.
def tokenize(code)
@code = code.chomp # Cleanup code by remove extra line breaks
@i = 0 # Current character position we're parsing
@line = 1 # The current line.
@tokens = [] # Collection of all parsed tokens in the form [:TOKEN_TYPE, value]
@code = code.chomp # Cleanup code by remove extra line breaks
@i = 0 # Current character position we're parsing
@line = 1 # The current line.
@tokens = [] # Collection of all parsed tokens in the form [:TOKEN_TYPE, value]
while @i < @code.length
@chunk = @code[@i..-1]
extract_next_token
@ -44,6 +52,8 @@ module CoffeeScript
@tokens
end
# At every position, run this list of match attempts, short-circuiting if
# any of them succeed.
def extract_next_token
return if identifier_token
return if number_token
@ -55,7 +65,7 @@ module CoffeeScript
return literal_token
end
# Matching if, print, method names, etc.
# Matches identifying literals: variables, keywords, method names, etc.
def identifier_token
return false unless identifier = @chunk[IDENTIFIER, 1]
# Keywords are special identifiers tagged with their own name, 'if' will result
@ -66,12 +76,14 @@ module CoffeeScript
@i += identifier.length
end
# Matches numbers, including decimals, hex, and exponential notation.
def number_token
return false unless number = @chunk[NUMBER, 1]
token(:NUMBER, number)
@i += number.length
end
# Matches strings, including multi-line strings.
def string_token
return false unless string = @chunk[STRING, 1]
escaped = string.gsub(MULTILINER) do |match|
@ -82,24 +94,27 @@ module CoffeeScript
@i += string.length
end
# Matches interpolated JavaScript.
def js_token
return false unless script = @chunk[JS, 1]
token(:JS, script.gsub(JS_CLEANER, ''))
@i += script.length
end
# Matches regular expression literals.
def regex_token
return false unless regex = @chunk[REGEX, 1]
token(:REGEX, regex)
@i += regex.length
end
# Matches and consumes comments.
def remove_comment
return false unless comment = @chunk[COMMENT, 1]
@i += comment.length
end
# Ignore whitespace
# Matches and consumes non-meaningful whitespace.
def whitespace_token
return false unless whitespace = @chunk[WHITESPACE, 1]
@i += whitespace.length
@ -107,7 +122,7 @@ module CoffeeScript
# We treat all other single characters as a token. Eg.: ( ) , . !
# Multi-character operators are also literal tokens, so that Racc can assign
# the proper order of operations. Multiple newlines get merged.
# the proper order of operations. Multiple newlines get merged together.
def literal_token
value = @chunk[NEWLINE, 1]
if value
@ -124,16 +139,20 @@ module CoffeeScript
@i += value.length
end
# Add a token to the results, taking note of the line number for syntax
# errors later in the parse.
def token(tag, value)
@tokens << [tag, Value.new(value, @line)]
end
# Peek at the previous token.
def last_value
@tokens.last && @tokens.last[1]
end
# The main source of ambiguity in our grammar was Parameter lists (as opposed
# to argument lists in method calls). Tag parameter identifiers to avoid this.
# A source of ambiguity in our grammar was parameter lists in function
# definitions (as opposed to argument lists in function calls). Tag
# parameter identifiers in order to avoid this.
def tag_parameters
index = 0
loop do
@ -144,6 +163,7 @@ module CoffeeScript
end
end
# Consume and ignore newlines immediately after this point.
def skip_following_newlines
newlines = @code[(@i+1)..-1][NEWLINE, 1]
if newlines
@ -152,6 +172,7 @@ module CoffeeScript
end
end
# Discard newlines immediately before this point.
def remove_leading_newlines
@tokens.pop if last_value == "\n"
end

844
lib/coffee_script/nodes.rb
View File

@ -1,469 +1,473 @@
class Node
# Tabs are two spaces for pretty-printing.
TAB = ' '
module CoffeeScript
def flatten; self; end
def line_ending; ';'; end
def statement?; false; end
def custom_return?; false; end
def custom_assign?; false; end
class Node
# Tabs are two spaces for pretty-printing.
TAB = ' '
def compile(indent='', scope=nil, opts={}); end
end
def flatten; self; end
def line_ending; ';'; end
def statement?; false; end
def custom_return?; false; end
def custom_assign?; false; end
# Collection of nodes each one representing an expression.
class Nodes < Node
attr_reader :nodes
def self.wrap(node)
node.is_a?(Nodes) ? node : Nodes.new([node])
def compile(indent='', scope=nil, opts={}); end
end
def initialize(nodes)
@nodes = nodes
end
# Collection of nodes each one representing an expression.
class Nodes < Node
attr_reader :nodes
def <<(node)
@nodes << node
self
end
def self.wrap(node)
node.is_a?(Nodes) ? node : Nodes.new([node])
end
def flatten
@nodes.length == 1 ? @nodes.first : self
end
def initialize(nodes)
@nodes = nodes
end
def begin_compile
"(function(){\n#{compile(TAB, Scope.new)}\n})();"
end
def <<(node)
@nodes << node
self
end
def statement?
true
end
def flatten
@nodes.length == 1 ? @nodes.first : self
end
# Fancy to handle pushing down returns recursively to the final lines of
# inner statements (to make expressions out of them).
def compile(indent='', scope=nil, opts={})
return begin_compile unless scope
@nodes.map { |n|
if opts[:return] && n == @nodes.last
if n.statement? || n.custom_return?
"#{indent}#{n.compile(indent, scope, opts)}#{n.line_ending}"
def begin_compile
"(function(){\n#{compile(TAB, Scope.new)}\n})();"
end
def statement?
true
end
# Fancy to handle pushing down returns recursively to the final lines of
# inner statements (to make expressions out of them).
def compile(indent='', scope=nil, opts={})
return begin_compile unless scope
@nodes.map { |n|
if opts[:return] && n == @nodes.last
if n.statement? || n.custom_return?
"#{indent}#{n.compile(indent, scope, opts)}#{n.line_ending}"
else
"#{indent}return #{n.compile(indent, scope, opts)}#{n.line_ending}"
end
else
"#{indent}return #{n.compile(indent, scope, opts)}#{n.line_ending}"
"#{indent}#{n.compile(indent, scope)}#{n.line_ending}"
end
else
"#{indent}#{n.compile(indent, scope)}#{n.line_ending}"
}.join("\n")
end
end
# Literals are static values that have a Ruby representation, eg.: a string, a number,
# true, false, nil, etc.
class LiteralNode < Node
STATEMENTS = ['break', 'continue']
def initialize(value)
@value = value
end
def statement?
STATEMENTS.include?(@value.to_s)
end
def compile(indent, scope, opts={})
@value.to_s
end
end
class ReturnNode < Node
def initialize(expression)
@expression = expression
end
def statement?
true
end
def custom_return?
true
end
def compile(indent, scope, opts={})
return @expression.compile(indent, scope, opts.merge(:return => true)) if @expression.custom_return?
compiled = @expression.compile(indent, scope)
@expression.statement? ? "#{compiled}\n#{indent}return null" : "return #{compiled}"
end
end
# Node of a method call or local variable access, can take any of these forms:
#
# method # this form can also be a local variable
# method(argument1, argument2)
# receiver.method
# receiver.method(argument1, argument2)
#
class CallNode < Node
LEADING_DOT = /\A\./
def initialize(variable, arguments=[])
@variable, @arguments = variable, arguments
end
def new_instance
@new = true
self
end
def super?
@variable == :super
end
def compile(indent, scope, opts={})
args = @arguments.map{|a| a.compile(indent, scope, :no_paren => true) }.join(', ')
return compile_super(args, indent, scope, opts) if super?
prefix = @new ? "new " : ''
"#{prefix}#{@variable.compile(indent, scope)}(#{args})"
end
def compile_super(args, indent, scope, opts)
methname = opts[:last_assign].sub(LEADING_DOT, '')
"this.constructor.prototype.#{methname}.call(this, #{args})"
end
end
class ValueNode < Node
attr_reader :last
def initialize(name, properties=[])
@name, @properties = name, properties
end
def <<(other)
@properties << other
self
end
def properties?
return !@properties.empty?
end
def compile(indent, scope, opts={})
parts = [@name, @properties].flatten.map do |v|
v.respond_to?(:compile) ? v.compile(indent, scope) : v.to_s
end
}.join("\n")
end
end
# Literals are static values that have a Ruby representation, eg.: a string, a number,
# true, false, nil, etc.
class LiteralNode < Node
STATEMENTS = ['break', 'continue']
def initialize(value)
@value = value
end
def statement?
STATEMENTS.include?(@value.to_s)
end
def compile(indent, scope, opts={})
@value.to_s
end
end
class ReturnNode < Node
def initialize(expression)
@expression = expression
end
def statement?
true
end
def custom_return?
true
end
def compile(indent, scope, opts={})
return @expression.compile(indent, scope, opts.merge(:return => true)) if @expression.custom_return?
compiled = @expression.compile(indent, scope)
@expression.statement? ? "#{compiled}\n#{indent}return null" : "return #{compiled}"
end
end
# Node of a method call or local variable access, can take any of these forms:
#
# method # this form can also be a local variable
# method(argument1, argument2)
# receiver.method
# receiver.method(argument1, argument2)
#
class CallNode < Node
LEADING_DOT = /\A\./
def initialize(variable, arguments=[])
@variable, @arguments = variable, arguments
end
def new_instance
@new = true
self
end
def super?
@variable == :super
end
def compile(indent, scope, opts={})
args = @arguments.map{|a| a.compile(indent, scope, :no_paren => true) }.join(', ')
return compile_super(args, indent, scope, opts) if super?
prefix = @new ? "new " : ''
"#{prefix}#{@variable.compile(indent, scope)}(#{args})"
end
def compile_super(args, indent, scope, opts)
methname = opts[:last_assign].sub(LEADING_DOT, '')
"this.constructor.prototype.#{methname}.call(this, #{args})"
end
end
class ValueNode < Node
attr_reader :last
def initialize(name, properties=[])
@name, @properties = name, properties
end
def <<(other)
@properties << other
self
end
def properties?
return !@properties.empty?
end
def compile(indent, scope, opts={})
parts = [@name, @properties].flatten.map do |v|
v.respond_to?(:compile) ? v.compile(indent, scope) : v.to_s
@last = parts.last
parts.join('')
end
@last = parts.last
parts.join('')
end
end
class AccessorNode
def initialize(name)
@name = name
end
def compile(indent, scope, opts={})
".#{@name}"
end
end
class IndexNode
def initialize(index)
@index = index
end
def compile(indent, scope, opts={})
"[#{@index.compile(indent, scope)}]"
end
end
class SliceNode
def initialize(from, to)
@from, @to = from, to
end
def compile(indent, scope, opts={})
".slice(#{@from.compile(indent, scope, opts)}, #{@to.compile(indent, scope, opts)} + 1)"
end
end
# Setting the value of a local variable.
class AssignNode < Node
def initialize(variable, value, context=nil)
@variable, @value, @context = variable, value, context
end
def custom_return?
true
end
def statement?
true
end
def compile(indent, scope, opts={})
name = @variable.compile(indent, scope) if @variable.respond_to?(:compile)
last = @variable.respond_to?(:last) ? @variable.last : name
opts = opts.merge({:assign => name, :last_assign => last})
value = @value.compile(indent + TAB, scope, opts)
return "#{@variable}: #{value}" if @context == :object
return "#{name} = #{value}" if @variable.properties?
defined = scope.find(name)
postfix = !defined && opts[:return] ? ";\n#{indent}return #{name}" : ''
def_part = defined ? "" : "var #{name};\n#{indent}"
return def_part + @value.compile(indent, scope, opts) if @value.custom_assign?
def_part = defined ? name : "var #{name}"
"#{def_part} = #{@value.compile(indent, scope, opts)}#{postfix}"
end
end
# Simple Arithmetic and logical operations
class OpNode < Node
CONVERSIONS = {
"==" => "===",
"!=" => "!==",
'and' => '&&',
'or' => '||',
'is' => '===',
"aint" => "!==",
'not' => '!',
}
CONDITIONALS = ['||=', '&&=']
def initialize(operator, first, second=nil)
@first, @second = first, second
@operator = CONVERSIONS[operator] || operator
end
def unary?
@second.nil?
end
def compile(indent, scope, opts={})
return compile_conditional(indent, scope) if CONDITIONALS.include?(@operator)
return compile_unary(indent, scope) if unary?
"#{@first.compile(indent, scope)} #{@operator} #{@second.compile(indent, scope)}"
end
def compile_conditional(indent, scope)
first, second = @first.compile(indent, scope), @second.compile(indent, scope)
sym = @operator[0..1]
"#{first} = #{first} #{sym} #{second}"
end
def compile_unary(indent, scope)
space = @operator == 'delete' ? ' ' : ''
"#{@operator}#{space}#{@first.compile(indent, scope)}"
end
end
# Method definition.
class CodeNode < Node
def initialize(params, body)
@params = params
@body = body
end
def compile(indent, scope, opts={})
scope = Scope.new(scope)
@params.each {|id| scope.find(id) }
opts = opts.merge(:return => true)
code = @body.compile(indent + TAB, scope, opts)
"function(#{@params.join(', ')}) {\n#{code}\n#{indent}}"
end
end
class ObjectNode < Node
def initialize(properties = [])
@properties = properties
end
def compile(indent, scope, opts={})
props = @properties.map {|p| indent + TAB + p.compile(indent, scope) }.join(",\n")
"{\n#{props}\n#{indent}}"
end
end
class ArrayNode < Node
def initialize(objects=[])
@objects = objects
end
def compile(indent, scope, opts={})
objects = @objects.map {|o| o.compile(indent, scope) }.join(', ')
"[#{objects}]"
end
end
class WhileNode < Node
def initialize(condition, body)
@condition, @body = condition, body
end
def line_ending
''
end
def statement?
true
end
def compile(indent, scope, opts={})
"while (#{@condition.compile(indent, scope, :no_paren => true)}) {\n#{@body.compile(indent + TAB, scope)}\n#{indent}}"
end
end
class ForNode < Node
def initialize(body, source, name, index=nil)
@body, @source, @name, @index = body, source, name, index
end
def line_ending
''
end
def custom_return?
true
end
def custom_assign?
true
end
def statement?
true
end
def compile(indent, scope, opts={})
svar = scope.free_variable
ivar = scope.free_variable
lvar = scope.free_variable
name_part = scope.find(@name) ? @name : "var #{@name}"
index_name = @index ? (scope.find(@index) ? @index : "var #{@index}") : nil
source_part = "var #{svar} = #{@source.compile(indent, scope)};"
for_part = "var #{ivar}=0, #{lvar}=#{svar}.length; #{ivar}<#{lvar}; #{ivar}++"
var_part = "\n#{indent + TAB}#{name_part} = #{svar}[#{ivar}];\n"
index_part = @index ? "#{indent + TAB}#{index_name} = #{ivar};\n" : ''
set_result = ''
save_result = ''
return_result = ''
if opts[:return] || opts[:assign]
rvar = scope.free_variable
set_result = "var #{rvar} = [];\n#{indent}"
save_result = "#{rvar}[#{ivar}] = "
return_result = rvar
return_result = "#{opts[:assign]} = #{return_result}" if opts[:assign]
return_result = "return #{return_result}" if opts[:return]
return_result = "\n#{indent}#{return_result}"
class AccessorNode
def initialize(name)
@name = name
end
body = @body.compile(indent + TAB, scope)
"#{source_part}\n#{indent}#{set_result}for (#{for_part}) {#{var_part}#{index_part}#{indent + TAB}#{save_result}#{body};\n#{indent}}#{return_result}"
end
end
class TryNode < Node
def initialize(try, error, recovery, finally=nil)
@try, @error, @recovery, @finally = try, error, recovery, finally
def compile(indent, scope, opts={})
".#{@name}"
end
end
def line_ending
''
class IndexNode
def initialize(index)
@index = index
end
def compile(indent, scope, opts={})
"[#{@index.compile(indent, scope)}]"
end
end
def statement?
true
class SliceNode
def initialize(from, to)
@from, @to = from, to
end
def compile(indent, scope, opts={})
".slice(#{@from.compile(indent, scope, opts)}, #{@to.compile(indent, scope, opts)} + 1)"
end
end
def compile(indent, scope, opts={})
catch_part = @recovery && " catch (#{@error}) {\n#{@recovery.compile(indent + TAB, scope, opts)}\n#{indent}}"
finally_part = @finally && " finally {\n#{@finally.compile(indent + TAB, scope, opts)}\n#{indent}}"
"try {\n#{@try.compile(indent + TAB, scope, opts)}\n#{indent}}#{catch_part}#{finally_part}"
end
end
# Setting the value of a local variable.
class AssignNode < Node
def initialize(variable, value, context=nil)
@variable, @value, @context = variable, value, context
end
class ThrowNode < Node
def initialize(expression)
@expression = expression
def custom_return?
true
end
def statement?
true
end
def compile(indent, scope, opts={})
name = @variable.compile(indent, scope) if @variable.respond_to?(:compile)
last = @variable.respond_to?(:last) ? @variable.last : name
opts = opts.merge({:assign => name, :last_assign => last})
value = @value.compile(indent + TAB, scope, opts)
return "#{@variable}: #{value}" if @context == :object
return "#{name} = #{value}" if @variable.properties?
defined = scope.find(name)
postfix = !defined && opts[:return] ? ";\n#{indent}return #{name}" : ''
def_part = defined ? "" : "var #{name};\n#{indent}"
return def_part + @value.compile(indent, scope, opts) if @value.custom_assign?
def_part = defined ? name : "var #{name}"
"#{def_part} = #{@value.compile(indent, scope, opts)}#{postfix}"
end
end
def statement?
true
# Simple Arithmetic and logical operations
class OpNode < Node
CONVERSIONS = {
"==" => "===",
"!=" => "!==",
'and' => '&&',
'or' => '||',
'is' => '===',
"aint" => "!==",
'not' => '!',
}
CONDITIONALS = ['||=', '&&=']
def initialize(operator, first, second=nil)
@first, @second = first, second
@operator = CONVERSIONS[operator] || operator
end
def unary?
@second.nil?
end
def compile(indent, scope, opts={})
return compile_conditional(indent, scope) if CONDITIONALS.include?(@operator)
return compile_unary(indent, scope) if unary?
"#{@first.compile(indent, scope)} #{@operator} #{@second.compile(indent, scope)}"
end
def compile_conditional(indent, scope)
first, second = @first.compile(indent, scope), @second.compile(indent, scope)
sym = @operator[0..1]
"#{first} = #{first} #{sym} #{second}"
end
def compile_unary(indent, scope)
space = @operator == 'delete' ? ' ' : ''
"#{@operator}#{space}#{@first.compile(indent, scope)}"
end
end
def compile(indent, scope, opts={})
"throw #{@expression.compile(indent, scope)}"
end
end
# Method definition.
class CodeNode < Node
def initialize(params, body)
@params = params
@body = body
end
class ParentheticalNode < Node
def initialize(expressions)
@expressions = expressions
def compile(indent, scope, opts={})
scope = Scope.new(scope)
@params.each {|id| scope.find(id) }
opts = opts.merge(:return => true)
code = @body.compile(indent + TAB, scope, opts)
"function(#{@params.join(', ')}) {\n#{code}\n#{indent}}"
end
end
def compile(indent, scope, opts={})
compiled = @expressions.flatten.compile(indent, scope)
compiled = compiled[0...-1] if compiled[-1..-1] == ';'
opts[:no_paren] ? compiled : "(#{compiled})"
end
end
class ObjectNode < Node
def initialize(properties = [])
@properties = properties
end
# "if-else" control structure. Look at this node if you want to implement other control
# structures like while, for, loop, etc.
class IfNode < Node
def initialize(condition, body, else_body=nil, tag=nil)
@condition = condition
@body = body && body.flatten
@else_body = else_body && else_body.flatten
@condition = OpNode.new("!", @condition) if tag == :invert
def compile(indent, scope, opts={})
props = @properties.map {|p| indent + TAB + p.compile(indent, scope) }.join(",\n")
"{\n#{props}\n#{indent}}"
end
end
def <<(else_body)
eb = else_body.flatten
@else_body ? @else_body << eb : @else_body = eb
self
class ArrayNode < Node
def initialize(objects=[])
@objects = objects
end
def compile(indent, scope, opts={})
objects = @objects.map {|o| o.compile(indent, scope) }.join(', ')
"[#{objects}]"
end
end
# Rewrite a chain of IfNodes with their switch condition for equality.
def rewrite_condition(expression)
@condition = OpNode.new("is", expression, @condition)
@else_body.rewrite_condition(expression) if chain?
self
class WhileNode < Node
def initialize(condition, body)
@condition, @body = condition, body
end
def line_ending
''
end
def statement?
true
end
def compile(indent, scope, opts={})
"while (#{@condition.compile(indent, scope, :no_paren => true)}) {\n#{@body.compile(indent + TAB, scope)}\n#{indent}}"
end
end
# Rewrite a chain of IfNodes to add a default case as the final else.
def add_else(expressions)
chain? ? @else_body.add_else(expressions) : @else_body = expressions
self
class ForNode < Node
def initialize(body, source, name, index=nil)
@body, @source, @name, @index = body, source, name, index
end
def line_ending
''
end
def custom_return?
true
end
def custom_assign?
true
end
def statement?
true
end
def compile(indent, scope, opts={})
svar = scope.free_variable
ivar = scope.free_variable
lvar = scope.free_variable
name_part = scope.find(@name) ? @name : "var #{@name}"
index_name = @index ? (scope.find(@index) ? @index : "var #{@index}") : nil
source_part = "var #{svar} = #{@source.compile(indent, scope)};"
for_part = "var #{ivar}=0, #{lvar}=#{svar}.length; #{ivar}<#{lvar}; #{ivar}++"
var_part = "\n#{indent + TAB}#{name_part} = #{svar}[#{ivar}];\n"
index_part = @index ? "#{indent + TAB}#{index_name} = #{ivar};\n" : ''
set_result = ''
save_result = ''
return_result = ''
if opts[:return] || opts[:assign]
rvar = scope.free_variable
set_result = "var #{rvar} = [];\n#{indent}"
save_result = "#{rvar}[#{ivar}] = "
return_result = rvar
return_result = "#{opts[:assign]} = #{return_result}" if opts[:assign]
return_result = "return #{return_result}" if opts[:return]
return_result = "\n#{indent}#{return_result}"
end
body = @body.compile(indent + TAB, scope)
"#{source_part}\n#{indent}#{set_result}for (#{for_part}) {#{var_part}#{index_part}#{indent + TAB}#{save_result}#{body};\n#{indent}}#{return_result}"
end
end
def chain?
@chain ||= @else_body && @else_body.is_a?(IfNode)
class TryNode < Node
def initialize(try, error, recovery, finally=nil)
@try, @error, @recovery, @finally = try, error, recovery, finally
end
def line_ending
''
end
def statement?
true
end
def compile(indent, scope, opts={})
catch_part = @recovery && " catch (#{@error}) {\n#{@recovery.compile(indent + TAB, scope, opts)}\n#{indent}}"
finally_part = @finally && " finally {\n#{@finally.compile(indent + TAB, scope, opts)}\n#{indent}}"
"try {\n#{@try.compile(indent + TAB, scope, opts)}\n#{indent}}#{catch_part}#{finally_part}"
end
end
def statement?
@is_statement ||= (@body.statement? || (@else_body && @else_body.statement?))
class ThrowNode < Node
def initialize(expression)
@expression = expression
end
def statement?
true
end
def compile(indent, scope, opts={})
"throw #{@expression.compile(indent, scope)}"
end
end
def line_ending
statement? ? '' : ';'
class ParentheticalNode < Node
def initialize(expressions)
@expressions = expressions
end
def compile(indent, scope, opts={})
compiled = @expressions.flatten.compile(indent, scope)
compiled = compiled[0...-1] if compiled[-1..-1] == ';'
opts[:no_paren] ? compiled : "(#{compiled})"
end
end
def compile(indent, scope, opts={})
statement? ? compile_statement(indent, scope, opts) : compile_ternary(indent, scope)
# "if-else" control structure. Look at this node if you want to implement other control
# structures like while, for, loop, etc.
class IfNode < Node
def initialize(condition, body, else_body=nil, tag=nil)
@condition = condition
@body = body && body.flatten
@else_body = else_body && else_body.flatten
@condition = OpNode.new("!", @condition) if tag == :invert
end
def <<(else_body)
eb = else_body.flatten
@else_body ? @else_body << eb : @else_body = eb
self
end
# Rewrite a chain of IfNodes with their switch condition for equality.
def rewrite_condition(expression)
@condition = OpNode.new("is", expression, @condition)
@else_body.rewrite_condition(expression) if chain?
self
end
# Rewrite a chain of IfNodes to add a default case as the final else.
def add_else(expressions)
chain? ? @else_body.add_else(expressions) : @else_body = expressions
self
end
def chain?
@chain ||= @else_body && @else_body.is_a?(IfNode)
end
def statement?
@is_statement ||= (@body.statement? || (@else_body && @else_body.statement?))
end
def line_ending
statement? ? '' : ';'
end
def compile(indent, scope, opts={})
statement? ? compile_statement(indent, scope, opts) : compile_ternary(indent, scope)
end
def compile_statement(indent, scope, opts)
if_part = "if (#{@condition.compile(indent, scope, :no_paren => true)}) {\n#{Nodes.wrap(@body).compile(indent + TAB, scope, opts)}\n#{indent}}"
else_part = @else_body ? " else {\n#{Nodes.wrap(@else_body).compile(indent + TAB, scope, opts)}\n#{indent}}" : ''
if_part + else_part
end
def compile_ternary(indent, scope)
if_part = "#{@condition.compile(indent, scope)} ? #{@body.compile(indent, scope)}"
else_part = @else_body ? "#{@else_body.compile(indent, scope)}" : 'null'
"#{if_part} : #{else_part}"
end
end
def compile_statement(indent, scope, opts)
if_part = "if (#{@condition.compile(indent, scope, :no_paren => true)}) {\n#{Nodes.wrap(@body).compile(indent + TAB, scope, opts)}\n#{indent}}"
else_part = @else_body ? " else {\n#{Nodes.wrap(@else_body).compile(indent + TAB, scope, opts)}\n#{indent}}" : ''
if_part + else_part
end
def compile_ternary(indent, scope)
if_part = "#{@condition.compile(indent, scope)} ? #{@body.compile(indent, scope)}"
else_part = @else_body ? "#{@else_body.compile(indent, scope)}" : 'null'
"#{if_part} : #{else_part}"
end
end
end

3
lib/coffee_script/parse_error.rb
View File

@ -1,5 +1,8 @@
module CoffeeScript
# Racc will raise this Exception whenever a syntax error occurs. The main
# benefit over the Racc::ParseError is that the CoffeeScript::ParseError is
# line-number aware.
class ParseError < Racc::ParseError
def initialize(token_id, value, stack)

57
lib/coffee_script/scope.rb
View File

@ -1,33 +1,40 @@
# A class to handle lookups for lexically scoped variables.
class Scope
module CoffeeScript
attr_reader :parent, :temp_variable
# Scope objects form a tree corresponding to the shape of the function
# definitions present in the script. They provide lexical scope, to determine
# whether a variable has been seen before or if it needs to be declared.
class Scope
def initialize(parent=nil)
@parent = parent
@variables = {}
@temp_variable = @parent ? @parent.temp_variable : 'a'
end
attr_reader :parent, :temp_variable
# Look up a variable in lexical scope, or declare it if not found.
def find(name, remote=false)
found = check(name, remote)
return found if found || remote
@variables[name] = true
found
end
# Initialize a scope with its parent, for lookups up the chain.
def initialize(parent=nil)
@parent = parent
@variables = {}
@temp_variable = @parent ? @parent.temp_variable : 'a'
end
# Just check for the pre-definition of a variable.
def check(name, remote=false)
return true if @variables[name]
@parent && @parent.find(name, true)
end
# Look up a variable in lexical scope, or declare it if not found.
def find(name, remote=false)
found = check(name, remote)
return found if found || remote
@variables[name] = true
found
end
# Just check to see if a variable has already been declared.
def check(name, remote=false)
return true if @variables[name]
@parent && @parent.find(name, true)
end
# Find an available, short, name for a compiler-generated variable.
def free_variable
@temp_variable.succ! while check(@temp_variable)
@variables[@temp_variable] = true
@temp_variable.dup
end
# Find an available, short variable name.
def free_variable
@temp_variable.succ! while check(@temp_variable)
@variables[@temp_variable] = true
@temp_variable.dup
end
end

64
lib/coffee_script/value.rb
View File

@ -1,34 +1,38 @@
# Instead of producing raw Ruby objects, the Lexer produces values of this
# class, tagged with line number information.
class Value
attr_reader :line
module CoffeeScript
def initialize(value, line)
@value, @line = value, line
# Instead of producing raw Ruby objects, the Lexer produces values of this
# class, wrapping native objects tagged with line number information.
class Value
attr_reader :line
def initialize(value, line)
@value, @line = value, line
end
def to_str
@value.to_s
end
alias_method :to_s, :to_str
def inspect
@value.inspect
end
def ==(other)
@value == other
end
def [](index)
@value[index]
end
def eql?(other)
@value.eql?(other)
end
def hash
@value.hash
end
end
def to_str
@value.to_s
end
alias_method :to_s, :to_str
def inspect
@value.inspect
end
def ==(other)
@value == other
end
def [](index)
@value[index]
end
def eql?(other)
@value.eql?(other)
end
def hash
@value.hash
end
end