比较文本

查找两个文本文件之间的差异

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

工具

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

Untitled diff

Created 8 years agoDiff never expires

Lines
Total
Removed

Words
Total
Removed

To continue using this feature, upgrade to Diffchecker Pro View Pricing

362 lines

Lines
Total
Added

Words
Total
Added

To continue using this feature, upgrade to Diffchecker Pro View Pricing

378 lines

# CoffeeScript can be used both on the server, as a command-line compiler based

# on Node.js/V8, or to run CoffeeScript directly in the browser. This module

# contains the main entry functions for tokenizing, parsing, and compiling

# source CoffeeScript into JavaScript.

fs = require 'fs'

vm = require 'vm'

path = require 'path'

{Lexer} = require './lexer'

{parser} = require './parser'

helpers = require './helpers'

SourceMap = require './sourcemap'

# Require `package.json`, which is two levels above this file, as this file is

# evaluated from `lib/coffee-script`.

packageJson = require '../../package.json'

# The current CoffeeScript version number.

exports.VERSION = '1.12.1'

exports.VERSION = packageJson.version

exports.FILE_EXTENSIONS = ['.coffee', '.litcoffee', '.coffee.md']

# Expose helpers for testing.

exports.helpers = helpers

# Function that allows for btoa in both nodejs and the browser.

base64encode = (src) -> switch

when typeof Buffer is 'function'

new Buffer(src).toString('base64')

when typeof btoa is 'function'

# The contents of a `<script>` block are encoded via UTF-16, so if any extended

# characters are used in the block, btoa will fail as it maxes out at UTF-8.

# See https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding#The_Unicode_Problem

# for the gory details, and for the solution implemented here.

btoa encodeURIComponent(src).replace /%([0-9A-F]{2})/g, (match, p1) ->

String.fromCharCode '0x' + p1

else

throw new Error('Unable to base64 encode inline sourcemap.')

# Function wrapper to add source file information to SyntaxErrors thrown by the

# lexer/parser/compiler.

withPrettyErrors = (fn) ->

(code, options = {}) ->

try

fn.call @, code, options

catch err

throw err if typeof code isnt 'string' # Support `CoffeeScript.nodes(tokens)`.

throw helpers.updateSyntaxError err, code, options.filename

# Compile CoffeeScript code to JavaScript, using the Coffee/Jison compiler.

# If `options.sourceMap` is specified, then `options.filename` must also be specified. All

# options that can be passed to `SourceMap#generate` may also be passed here.

# This returns a javascript string, unless `options.sourceMap` is passed,

# in which case this returns a `{js, v3SourceMap, sourceMap}`

# object, where sourceMap is a sourcemap.coffee#SourceMap object, handy for doing programatic

# lookups.

exports.compile = compile = withPrettyErrors (code, options) ->

{merge, extend} = helpers

options = extend {}, options

generateSourceMap = options.sourceMap or options.inlineMap

if generateSourceMap

map = new SourceMap

tokens = lexer.tokenize code, options

# Pass a list of referenced variables, so that generated variables won't get

# the same name.

options.referencedVars = (

token[1] for token in tokens when token[0] is 'IDENTIFIER'

)

# Check for import or export; if found, force bare mode

unless options.bare? and options.bare is yes

for token in tokens

if token[0] in ['IMPORT', 'EXPORT']

options.bare = yes

break

fragments = parser.parse(tokens).compileToFragments options

currentLine = 0

currentLine += 1 if options.header

currentLine += 1 if options.shiftLine

currentColumn = 0

js = ""

for fragment in fragments

# Update the sourcemap with data from each fragment

if generateSourceMap

# Do not include empty, whitespace, or semicolon-only fragments.

if fragment.locationData and not /^[;\s]*$/.test fragment.code

map.add(

[fragment.locationData.first_line, fragment.locationData.first_column]

[currentLine, currentColumn]

{noReplace: true})

newLines = helpers.count fragment.code, "\n"

currentLine += newLines

if newLines

currentColumn = fragment.code.length - (fragment.code.lastIndexOf("\n") + 1)

else

currentColumn += fragment.code.length

# Copy the code from each fragment into the final JavaScript.

js += fragment.code

if options.header

header = "Generated by CoffeeScript #{@VERSION}"

js = "// #{header}\n#{js}"

if generateSourceMap

v3SourceMap = map.generate(options, code)

if options.inlineMap

encoded = base64encode JSON.stringify v3SourceMap

sourceMapDataURI = "//# sourceMappingURL=data:application/json;base64,#{encoded}"

sourceURL = "//# sourceURL=#{options.filename ? 'coffeescript'}"

js = "#{js}\n#{sourceMapDataURI}\n#{sourceURL}"

if options.sourceMap

{

sourceMap: map

v3SourceMap: JSON.stringify v3SourceMap, null, 2

}

else

# Tokenize a string of CoffeeScript code, and return the array of tokens.

exports.tokens = withPrettyErrors (code, options) ->

lexer.tokenize code, options

# Parse a string of CoffeeScript code or an array of lexed tokens, and

# return the AST. You can then compile it by calling `.compile()` on the root,

# or traverse it by using `.traverseChildren()` with a callback.

exports.nodes = withPrettyErrors (source, options) ->

if typeof source is 'string'

parser.parse lexer.tokenize source, options

else

parser.parse source

# Compile and execute a string of CoffeeScript (on the server), correctly

# setting `__filename`, `__dirname`, and relative `require()`.

exports.run = (code, options = {}) ->

mainModule = require.main

# Set the filename.

mainModule.filename = process.argv[1] =

if options.filename then fs.realpathSync(options.filename) else '.'

# Clear the module cache.

mainModule.moduleCache and= {}

# Assign paths for node_modules loading

dir = if options.filename

path.dirname fs.realpathSync options.filename

else

fs.realpathSync '.'

mainModule.paths = require('module')._nodeModulePaths dir

# Compile.

if not helpers.isCoffee(mainModule.filename) or require.extensions

answer = compile code, options

code = answer.js ? answer

mainModule._compile code, mainModule.filename

# Compile and evaluate a string of CoffeeScript (in a Node.js-like environment).

# The CoffeeScript REPL uses this to run the input.

exports.eval = (code, options = {}) ->

return unless code = code.trim()

createContext = vm.Script.createContext ? vm.createContext

isContext = vm.isContext ? (ctx) ->

options.sandbox instanceof createContext().constructor

if createContext

if options.sandbox?

if isContext options.sandbox

sandbox = options.sandbox

else

sandbox = createContext()

sandbox[k] = v for own k, v of options.sandbox

sandbox.global = sandbox.root = sandbox.GLOBAL = sandbox

else

sandbox = global

sandbox.__filename = options.filename || 'eval'

sandbox.__dirname = path.dirname sandbox.__filename

# define module/require only if they chose not to specify their own

unless sandbox isnt global or sandbox.module or sandbox.require

Module = require 'module'

sandbox.module = _module = new Module(options.modulename || 'eval')

sandbox.require = _require = (path) -> Module._load path, _module, true

_module.filename = sandbox.__filename

for r in Object.getOwnPropertyNames require when r not in ['paths', 'arguments', 'caller']

_require[r] = require[r]

# use the same hack node currently uses for their own REPL

_require.paths = _module.paths = Module._nodeModulePaths process.cwd()

_require.resolve = (request) -> Module._resolveFilename request, _module

o = {}

o[k] = v for own k, v of options

o.bare = on # ensure return value

js = compile code, o

if sandbox is global

vm.runInThisContext js

else

vm.runInContext js, sandbox

exports.register = -> require './register'

# Throw error with deprecation warning when depending upon implicit `require.extensions` registration

if require.extensions

for ext in @FILE_EXTENSIONS then do (ext) ->

require.extensions[ext] ?= ->

throw new Error """

Use CoffeeScript.register() or require the coffee-script/register module to require #{ext} files.

"""

# For each compiled file, save its source in memory in case we need to recompile it later.

# We might need to recompile if the first compilation didn’t create a source map (faster)

# but something went wrong and we need a stack trace. Assuming that most of the time, code

# isn’t throwing exceptions, it’s probably more efficient to compile twice only when we

# need a stack trace, rather than always generating a source map even when it’s not likely

# to be used.

compiledFiles = {}

exports._compileFile = (filename, sourceMap = no, inlineMap = no) ->

raw = fs.readFileSync filename, 'utf8'

# Strip the Unicode byte order mark, if this file begins with one.

stripped = if raw.charCodeAt(0) is 0xFEFF then raw.substring 1 else raw

compiledFiles[filename] = stripped

compileCode stripped, filename, sourceMap, inlineMap

compileCode = (code, filename, sourceMap = no, inlineMap = no) ->

try

answer = compile stripped, {

answer = compile code, {

filename, sourceMap, inlineMap

sourceFiles: [filename]

literate: helpers.isLiterate filename

}

catch err

# As the filename and code of a dynamically loaded file will be different

# from the original file compiled with CoffeeScript.run, add that

# information to error so it can be pretty-printed later.

throw helpers.updateSyntaxError err, stripped, filename

throw helpers.updateSyntaxError err, code, filename

answer

# Instantiate a Lexer for our use here.

lexer = new Lexer

# The real Lexer produces a generic stream of tokens. This object provides a

# thin wrapper around it, compatible with the Jison API. We can then pass it

# directly as a "Jison lexer".

parser.lexer =

lex: ->

token = parser.tokens[@pos++]

if token

[tag, @yytext, @yylloc] = token

parser.errorToken = token.origin or token

@yylineno = @yylloc.first_line

else

tag = ''

tag

setInput: (tokens) ->

parser.tokens = tokens

@pos = 0

upcomingInput: ->

# Make all the AST nodes visible to the parser.

parser.yy = require './nodes'

# Override Jison's default error handling function.

parser.yy.parseError = (message, {token}) ->

# Disregard Jison's message, it contains redundant line number information.

# Disregard the token, we take its value directly from the lexer in case

# the error is caused by a generated token which might refer to its origin.

{errorToken, tokens} = parser

[errorTag, errorText, errorLoc] = errorToken

errorText = switch

when errorToken is tokens[tokens.length - 1]

'end of input'

when errorTag in ['INDENT', 'OUTDENT']

'indentation'

when errorTag in ['IDENTIFIER', 'NUMBER', 'INFINITY', 'STRING', 'STRING_START', 'REGEX', 'REGEX_START']

errorTag.replace(/_START$/, '').toLowerCase()

else

helpers.nameWhitespaceCharacter errorText

# The second argument has a `loc` property, which should have the location

# data for this token. Unfortunately, Jison seems to send an outdated `loc`

# (from the previous token), so we take the location information directly

# from the lexer.

helpers.throwSyntaxError "unexpected #{errorText}", errorLoc

# Based on http://v8.googlecode.com/svn/branches/bleeding_edge/src/messages.js

# Modified to handle sourceMap

formatSourcePosition = (frame, getSourceMapping) ->

fileName = undefined

fileLocation = ''

if frame.isNative()

fileLocation = "native"

else

if frame.isEval()

fileName = frame.getScriptNameOrSourceURL()

fileLocation = "#{frame.getEvalOrigin()}, " unless fileName

else

fileName = frame.getFileName()

fileName or= "<anonymous>"

line = frame.getLineNumber()

column = frame.getColumnNumber()

# Check for a sourceMap position

source = getSourceMapping fileName, line, column

fileLocation =

if source

"#{fileName}:#{source[0]}:#{source[1]}"

else

"#{fileName}:#{line}:#{column}"

functionName = frame.getFunctionName()

isConstructor = frame.isConstructor()

isMethodCall = not (frame.isToplevel() or isConstructor)

if isMethodCall

methodName = frame.getMethodName()

typeName = frame.getTypeName()

if functionName

tp = as = ''

if typeName and functionName.indexOf typeName

tp = "#{typeName}."

if methodName and functionName.indexOf(".#{methodName}") isnt functionName.length - methodName.length - 1

as = " [as #{methodName}]"

"#{tp}#{functionName}#{as} (#{fileLocation})"

else

"#{typeName}.#{methodName or '<anonymous>'} (#{fileLocation})"

else if isConstructor

"new #{functionName or '<anonymous>'} (#{fileLocation})"

else if functionName

"#{functionName} (#{fileLocation})"

else

fileLocation

# Map of filenames -> sourceMap object.

# Map of filenames: sourceMap objects.

sourceMaps = {}

# Generates the source map for a coffee file and stores it in the local cache variable.

getSourceMap = (filename) ->

return sourceMaps[filename] if sourceMaps[filename]

if sourceMaps[filename]?

for ext in exports.FILE_EXTENSIONS

sourceMaps[filename]

if helpers.ends filename, ext

else if compiledFiles[filename]?

answer = exports._compileFile filename, true

answer = compileCode compiledFiles[filename], filename, yes, no

return sourceMaps[filename] = answer.sourceMap

sourceMaps[filename] = answer.sourceMap

return null

else

null

# Based on [michaelficarra/CoffeeScriptRedux](http://goo.gl/ZTx1p)

# NodeJS / V8 have no support for transforming positions in stack traces using

# sourceMap, so we must monkey-patch Error to display CoffeeScript source

# positions.

Error.prepareStackTrace = (err, stack) ->

getSourceMapping = (filename, line, column) ->

sourceMap = getSourceMap filename

answer = sourceMap.sourceLocation [line - 1, column - 1] if sourceMap

if answer then [answer[0] + 1, answer[1] + 1] else null

frames = for frame in stack

break if frame.getFunction() is exports.run

" at #{formatSourcePosition frame, getSourceMapping}"

"#{err.toString()}\n#{frames.join '\n'}\n"

已保存差异

原始文本

打开文件

# CoffeeScript can be used both on the server, as a command-line compiler based
# on Node.js/V8, or to run CoffeeScript directly in the browser. This module
# contains the main entry functions for tokenizing, parsing, and compiling
# source CoffeeScript into JavaScript.

# The current CoffeeScript version number.
exports.VERSION = '1.12.1'

exports.FILE_EXTENSIONS = ['.coffee', '.litcoffee', '.coffee.md']

# Expose helpers for testing.
exports.helpers = helpers

# Function that allows for btoa in both nodejs and the browser.
base64encode = (src) -> switch
  when typeof Buffer is 'function'
    new Buffer(src).toString('base64')
  when typeof btoa is 'function'
    # The contents of a `<script>` block are encoded via UTF-16, so if any extended
    # characters are used in the block, btoa will fail as it maxes out at UTF-8.
    # See https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding#The_Unicode_Problem
    # for the gory details, and for the solution implemented here.
    btoa encodeURIComponent(src).replace /%([0-9A-F]{2})/g, (match, p1) ->
      String.fromCharCode '0x' + p1
  else
    throw new Error('Unable to base64 encode inline sourcemap.')

# Function wrapper to add source file information to SyntaxErrors thrown by the
# lexer/parser/compiler.
withPrettyErrors = (fn) ->
  (code, options = {}) ->
    try
      fn.call @, code, options
    catch err
      throw err if typeof code isnt 'string' # Support `CoffeeScript.nodes(tokens)`.
      throw helpers.updateSyntaxError err, code, options.filename

# Compile CoffeeScript code to JavaScript, using the Coffee/Jison compiler.
#
# If `options.sourceMap` is specified, then `options.filename` must also be specified.  All
# options that can be passed to `SourceMap#generate` may also be passed here.
#
# This returns a javascript string, unless `options.sourceMap` is passed,
# in which case this returns a `{js, v3SourceMap, sourceMap}`
# object, where sourceMap is a sourcemap.coffee#SourceMap object, handy for doing programatic
# lookups.
exports.compile = compile = withPrettyErrors (code, options) ->
  {merge, extend} = helpers
  options = extend {}, options
  generateSourceMap = options.sourceMap or options.inlineMap

if generateSourceMap
    map = new SourceMap

tokens = lexer.tokenize code, options

# Pass a list of referenced variables, so that generated variables won't get
  # the same name.
  options.referencedVars = (
    token[1] for token in tokens when token[0] is 'IDENTIFIER'
  )

# Check for import or export; if found, force bare mode
  unless options.bare? and options.bare is yes
    for token in tokens
      if token[0] in ['IMPORT', 'EXPORT']
        options.bare = yes
        break

fragments = parser.parse(tokens).compileToFragments options

currentLine = 0
  currentLine += 1 if options.header
  currentLine += 1 if options.shiftLine
  currentColumn = 0
  js = ""
  for fragment in fragments
    # Update the sourcemap with data from each fragment
    if generateSourceMap
      # Do not include empty, whitespace, or semicolon-only fragments.
      if fragment.locationData and not /^[;\s]*$/.test fragment.code
        map.add(
          [fragment.locationData.first_line, fragment.locationData.first_column]
          [currentLine, currentColumn]
          {noReplace: true})
      newLines = helpers.count fragment.code, "\n"
      currentLine += newLines
      if newLines
        currentColumn = fragment.code.length - (fragment.code.lastIndexOf("\n") + 1)
      else
        currentColumn += fragment.code.length

# Copy the code from each fragment into the final JavaScript.
    js += fragment.code

if options.header
    header = "Generated by CoffeeScript #{@VERSION}"
    js = "// #{header}\n#{js}"

if generateSourceMap
    v3SourceMap = map.generate(options, code)

if options.inlineMap
    encoded = base64encode JSON.stringify v3SourceMap
    sourceMapDataURI = "//# sourceMappingURL=data:application/json;base64,#{encoded}"
    sourceURL = "//# sourceURL=#{options.filename ? 'coffeescript'}"
    js = "#{js}\n#{sourceMapDataURI}\n#{sourceURL}"

if options.sourceMap
    {
      js
      sourceMap: map
      v3SourceMap: JSON.stringify v3SourceMap, null, 2
    }
  else
    js

# Tokenize a string of CoffeeScript code, and return the array of tokens.
exports.tokens = withPrettyErrors (code, options) ->
  lexer.tokenize code, options

# Parse a string of CoffeeScript code or an array of lexed tokens, and
# return the AST. You can then compile it by calling `.compile()` on the root,
# or traverse it by using `.traverseChildren()` with a callback.
exports.nodes = withPrettyErrors (source, options) ->
  if typeof source is 'string'
    parser.parse lexer.tokenize source, options
  else
    parser.parse source

# Compile and execute a string of CoffeeScript (on the server), correctly
# setting `__filename`, `__dirname`, and relative `require()`.
exports.run = (code, options = {}) ->
  mainModule = require.main

# Set the filename.
  mainModule.filename = process.argv[1] =
    if options.filename then fs.realpathSync(options.filename) else '.'

# Clear the module cache.
  mainModule.moduleCache and= {}

# Assign paths for node_modules loading
  dir = if options.filename
    path.dirname fs.realpathSync options.filename
  else
    fs.realpathSync '.'
  mainModule.paths = require('module')._nodeModulePaths dir

# Compile.
  if not helpers.isCoffee(mainModule.filename) or require.extensions
    answer = compile code, options
    code = answer.js ? answer

mainModule._compile code, mainModule.filename

# Compile and evaluate a string of CoffeeScript (in a Node.js-like environment).
# The CoffeeScript REPL uses this to run the input.
exports.eval = (code, options = {}) ->
  return unless code = code.trim()
  createContext = vm.Script.createContext ? vm.createContext

isContext = vm.isContext ? (ctx) ->
    options.sandbox instanceof createContext().constructor

if createContext
    if options.sandbox?
      if isContext options.sandbox
        sandbox = options.sandbox
      else
        sandbox = createContext()
        sandbox[k] = v for own k, v of options.sandbox
      sandbox.global = sandbox.root = sandbox.GLOBAL = sandbox
    else
      sandbox = global
    sandbox.__filename = options.filename || 'eval'
    sandbox.__dirname  = path.dirname sandbox.__filename
    # define module/require only if they chose not to specify their own
    unless sandbox isnt global or sandbox.module or sandbox.require
      Module = require 'module'
      sandbox.module  = _module  = new Module(options.modulename || 'eval')
      sandbox.require = _require = (path) ->  Module._load path, _module, true
      _module.filename = sandbox.__filename
      for r in Object.getOwnPropertyNames require when r not in ['paths', 'arguments', 'caller']
        _require[r] = require[r]
      # use the same hack node currently uses for their own REPL
      _require.paths = _module.paths = Module._nodeModulePaths process.cwd()
      _require.resolve = (request) -> Module._resolveFilename request, _module
  o = {}
  o[k] = v for own k, v of options
  o.bare = on # ensure return value
  js = compile code, o
  if sandbox is global
    vm.runInThisContext js
  else
    vm.runInContext js, sandbox

exports.register = -> require './register'

# Throw error with deprecation warning when depending upon implicit `require.extensions` registration
if require.extensions
  for ext in @FILE_EXTENSIONS then do (ext) ->
    require.extensions[ext] ?= ->
      throw new Error """
      Use CoffeeScript.register() or require the coffee-script/register module to require #{ext} files.
      """

exports._compileFile = (filename, sourceMap = no, inlineMap = no) ->
  raw = fs.readFileSync filename, 'utf8'
  stripped = if raw.charCodeAt(0) is 0xFEFF then raw.substring 1 else raw

try
    answer = compile stripped, {
      filename, sourceMap, inlineMap
      sourceFiles: [filename]
      literate: helpers.isLiterate filename
    }
  catch err
    # As the filename and code of a dynamically loaded file will be different
    # from the original file compiled with CoffeeScript.run, add that
    # information to error so it can be pretty-printed later.
    throw helpers.updateSyntaxError err, stripped, filename

answer

# Instantiate a Lexer for our use here.
lexer = new Lexer

# The real Lexer produces a generic stream of tokens. This object provides a
# thin wrapper around it, compatible with the Jison API. We can then pass it
# directly as a "Jison lexer".
parser.lexer =
  lex: ->
    token = parser.tokens[@pos++]
    if token
      [tag, @yytext, @yylloc] = token
      parser.errorToken = token.origin or token
      @yylineno = @yylloc.first_line
    else
      tag = ''

tag
  setInput: (tokens) ->
    parser.tokens = tokens
    @pos = 0
  upcomingInput: ->
    ""
# Make all the AST nodes visible to the parser.
parser.yy = require './nodes'

# Override Jison's default error handling function.
parser.yy.parseError = (message, {token}) ->
  # Disregard Jison's message, it contains redundant line number information.
  # Disregard the token, we take its value directly from the lexer in case
  # the error is caused by a generated token which might refer to its origin.
  {errorToken, tokens} = parser
  [errorTag, errorText, errorLoc] = errorToken

errorText = switch
    when errorToken is tokens[tokens.length - 1]
      'end of input'
    when errorTag in ['INDENT', 'OUTDENT']
      'indentation'
    when errorTag in ['IDENTIFIER', 'NUMBER', 'INFINITY', 'STRING', 'STRING_START', 'REGEX', 'REGEX_START']
      errorTag.replace(/_START$/, '').toLowerCase()
    else
      helpers.nameWhitespaceCharacter errorText

# The second argument has a `loc` property, which should have the location
  # data for this token. Unfortunately, Jison seems to send an outdated `loc`
  # (from the previous token), so we take the location information directly
  # from the lexer.
  helpers.throwSyntaxError "unexpected #{errorText}", errorLoc

# Based on http://v8.googlecode.com/svn/branches/bleeding_edge/src/messages.js
# Modified to handle sourceMap
formatSourcePosition = (frame, getSourceMapping) ->
  fileName = undefined
  fileLocation = ''

if frame.isNative()
    fileLocation = "native"
  else
    if frame.isEval()
      fileName = frame.getScriptNameOrSourceURL()
      fileLocation = "#{frame.getEvalOrigin()}, " unless fileName
    else
      fileName = frame.getFileName()

fileName or= "<anonymous>"

line = frame.getLineNumber()
    column = frame.getColumnNumber()

# Check for a sourceMap position
    source = getSourceMapping fileName, line, column
    fileLocation =
      if source
        "#{fileName}:#{source[0]}:#{source[1]}"
      else
        "#{fileName}:#{line}:#{column}"

functionName = frame.getFunctionName()
  isConstructor = frame.isConstructor()
  isMethodCall = not (frame.isToplevel() or isConstructor)

if isMethodCall
    methodName = frame.getMethodName()
    typeName = frame.getTypeName()

if functionName
      tp = as = ''
      if typeName and functionName.indexOf typeName
        tp = "#{typeName}."
      if methodName and functionName.indexOf(".#{methodName}") isnt functionName.length - methodName.length - 1
        as = " [as #{methodName}]"

"#{tp}#{functionName}#{as} (#{fileLocation})"
    else
      "#{typeName}.#{methodName or '<anonymous>'} (#{fileLocation})"
  else if isConstructor
    "new #{functionName or '<anonymous>'} (#{fileLocation})"
  else if functionName
    "#{functionName} (#{fileLocation})"
  else
    fileLocation

# Map of filenames -> sourceMap object.
sourceMaps = {}

# Generates the source map for a coffee file and stores it in the local cache variable.
getSourceMap = (filename) ->
  return sourceMaps[filename] if sourceMaps[filename]
  for ext in exports.FILE_EXTENSIONS
    if helpers.ends filename, ext
      answer = exports._compileFile filename, true
      return sourceMaps[filename] = answer.sourceMap
  return null

# Based on [michaelficarra/CoffeeScriptRedux](http://goo.gl/ZTx1p)
# NodeJS / V8 have no support for transforming positions in stack traces using
# sourceMap, so we must monkey-patch Error to display CoffeeScript source
# positions.
Error.prepareStackTrace = (err, stack) ->
  getSourceMapping = (filename, line, column) ->
    sourceMap = getSourceMap filename
    answer = sourceMap.sourceLocation [line - 1, column - 1] if sourceMap
    if answer then [answer[0] + 1, answer[1] + 1] else null

frames = for frame in stack
    break if frame.getFunction() is exports.run
    "  at #{formatSourcePosition frame, getSourceMapping}"

"#{err.toString()}\n#{frames.join '\n'}\n"

更改后文本

打开文件

fs            = require 'fs'
vm            = require 'vm'
path          = require 'path'
{Lexer}       = require './lexer'
{parser}      = require './parser'
helpers       = require './helpers'
SourceMap     = require './sourcemap'
# Require `package.json`, which is two levels above this file, as this file is
# evaluated from `lib/coffee-script`.
packageJson   = require '../../package.json'

# The current CoffeeScript version number.
exports.VERSION = packageJson.version

exports.FILE_EXTENSIONS = ['.coffee', '.litcoffee', '.coffee.md']

# Expose helpers for testing.
exports.helpers = helpers

if generateSourceMap
    map = new SourceMap

tokens = lexer.tokenize code, options

# Pass a list of referenced variables, so that generated variables won't get
  # the same name.
  options.referencedVars = (
    token[1] for token in tokens when token[0] is 'IDENTIFIER'
  )

fragments = parser.parse(tokens).compileToFragments options

# Copy the code from each fragment into the final JavaScript.
    js += fragment.code

if options.header
    header = "Generated by CoffeeScript #{@VERSION}"
    js = "// #{header}\n#{js}"

if generateSourceMap
    v3SourceMap = map.generate(options, code)

if options.sourceMap
    {
      js
      sourceMap: map
      v3SourceMap: JSON.stringify v3SourceMap, null, 2
    }
  else
    js

# Tokenize a string of CoffeeScript code, and return the array of tokens.
exports.tokens = withPrettyErrors (code, options) ->
  lexer.tokenize code, options

# Set the filename.
  mainModule.filename = process.argv[1] =
    if options.filename then fs.realpathSync(options.filename) else '.'

# Clear the module cache.
  mainModule.moduleCache and= {}

# Compile.
  if not helpers.isCoffee(mainModule.filename) or require.extensions
    answer = compile code, options
    code = answer.js ? answer

mainModule._compile code, mainModule.filename

isContext = vm.isContext ? (ctx) ->
    options.sandbox instanceof createContext().constructor

exports.register = -> require './register'

# For each compiled file, save its source in memory in case we need to recompile it later.
# We might need to recompile if the first compilation didn’t create a source map (faster)
# but something went wrong and we need a stack trace. Assuming that most of the time, code
# isn’t throwing exceptions, it’s probably more efficient to compile twice only when we
# need a stack trace, rather than always generating a source map even when it’s not likely
# to be used.
compiledFiles = {}

exports._compileFile = (filename, sourceMap = no, inlineMap = no) ->
  raw = fs.readFileSync filename, 'utf8'
  # Strip the Unicode byte order mark, if this file begins with one.
  stripped = if raw.charCodeAt(0) is 0xFEFF then raw.substring 1 else raw
  compiledFiles[filename] = stripped
  compileCode stripped, filename, sourceMap, inlineMap

compileCode = (code, filename, sourceMap = no, inlineMap = no) ->
  try
    answer = compile code, {
      filename, sourceMap, inlineMap
      sourceFiles: [filename]
      literate: helpers.isLiterate filename
    }
  catch err
    # As the filename and code of a dynamically loaded file will be different
    # from the original file compiled with CoffeeScript.run, add that
    # information to error so it can be pretty-printed later.
    throw helpers.updateSyntaxError err, code, filename

answer

# Instantiate a Lexer for our use here.
lexer = new Lexer

tag
  setInput: (tokens) ->
    parser.tokens = tokens
    @pos = 0
  upcomingInput: ->
    ""
# Make all the AST nodes visible to the parser.
parser.yy = require './nodes'

fileName or= "<anonymous>"

line = frame.getLineNumber()
    column = frame.getColumnNumber()

functionName = frame.getFunctionName()
  isConstructor = frame.isConstructor()
  isMethodCall = not (frame.isToplevel() or isConstructor)

if isMethodCall
    methodName = frame.getMethodName()
    typeName = frame.getTypeName()

# Map of filenames: sourceMap objects.
sourceMaps = {}
# Generates the source map for a coffee file and stores it in the local cache variable.
getSourceMap = (filename) ->
  if sourceMaps[filename]?
    sourceMaps[filename]
  else if compiledFiles[filename]?
    answer = compileCode compiledFiles[filename], filename, yes, no
    sourceMaps[filename] = answer.sourceMap
  else
    null

frames = for frame in stack
    break if frame.getFunction() is exports.run
    "    at #{formatSourcePosition frame, getSourceMapping}"

"#{err.toString()}\n#{frames.join '\n'}\n"