coffeescript.coffee

{Lexer}       = require './lexer'
{parser}      = require './parser'
helpers       = require './helpers'
SourceMap     = require './sourcemap'

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

exports.VERSION = packageJson.version

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

exports.helpers = helpers

{getSourceMap, registerCompiled} = SourceMap

exports.registerCompiled = registerCompiled

base64encode = (src) -> switch
  when typeof Buffer is 'function'
    Buffer.from(src).toString('base64')
  when typeof btoa is 'function'

    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.')

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

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

  options = Object.assign {}, options

  generateSourceMap = options.sourceMap or options.inlineMap or not options.filename?
  filename = options.filename or helpers.anonymousFileName()

  checkShebangLine filename, code

  map = new SourceMap if generateSourceMap

  tokens = lexer.tokenize code, options

  options.referencedVars = (
    token[1] for token in tokens when token[0] is 'IDENTIFIER'
  )

  unless options.bare? and options.bare is yes
    for token in tokens
      if token[0] in ['IMPORT', 'EXPORT']
        options.bare = yes
        break

  nodes = parser.parse tokens

  if options.ast
    nodes.allCommentTokens = helpers.extractAllCommentTokens tokens
    sourceCodeNumberOfLines = (code.match(/\r?\n/g) or '').length + 1
    sourceCodeLastLine = /.*$/.exec(code)[0] # `.*` matches all but line break characters.
    ast = nodes.ast options
    range = [0, code.length]
    ast.start = ast.program.start = range[0]
    ast.end = ast.program.end = range[1]
    ast.range = ast.program.range = range
    ast.loc.start = ast.program.loc.start = {line: 1, column: 0}
    ast.loc.end.line = ast.program.loc.end.line = sourceCodeNumberOfLines
    ast.loc.end.column = ast.program.loc.end.column = sourceCodeLastLine.length
    ast.tokens = tokens
    return ast

  fragments = nodes.compileToFragments options

  currentLine = 0
  currentLine += 1 if options.header
  currentLine += 1 if options.shiftLine
  currentColumn = 0
  js = ""
  for fragment in fragments

    if generateSourceMap

      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

    js += fragment.code

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

  if generateSourceMap
    v3SourceMap = map.generate options, code

  if options.transpile
    if typeof options.transpile isnt 'object'

      throw new Error 'The transpile option must be given an object with options to pass to Babel'

    transpiler = options.transpile.transpile
    delete options.transpile.transpile

    transpilerOptions = Object.assign {}, options.transpile

    if v3SourceMap and not transpilerOptions.inputSourceMap?
      transpilerOptions.inputSourceMap = v3SourceMap
    transpilerOutput = transpiler js, transpilerOptions
    js = transpilerOutput.code
    if v3SourceMap and transpilerOutput.map
      v3SourceMap = transpilerOutput.map

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

  registerCompiled filename, code, map

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

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

exports.nodes = withPrettyErrors (source, options) ->
  source = lexer.tokenize source, options if typeof source is 'string'
  parser.parse source

exports.run = exports.eval = exports.register = ->
  throw new Error 'require index.coffee, not this file'

lexer = new Lexer

parser.lexer =
  yylloc:
    range: []
  options:
    ranges: yes
  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: -> ''

parser.yy = require './nodes'

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

  {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

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

exports.patchStackTrace = ->

  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()

      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

  getSourceMapping = (filename, line, column) ->
    sourceMap = getSourceMap filename, line, column

    answer = sourceMap.sourceLocation [line - 1, column - 1] if sourceMap?
    if answer? then [answer[0] + 1, answer[1] + 1] else null

  Error.prepareStackTrace = (err, stack) ->
    frames = for frame in stack

      break if frame.getFunction() is exports.run
      "    at #{formatSourcePosition frame, getSourceMapping}"

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

checkShebangLine = (file, input) ->
  firstLine = input.split(/$/m, 1)[0]
  rest = firstLine?.match(/^#!\s*([^\s]+\s*)(.*)/)
  args = rest?[2]?.split(/\s/).filter (s) -> s isnt ''
  if args?.length > 1
    console.error '''
      The script to be run begins with a shebang line with more than one
      argument. This script will fail on platforms such as Linux which only
      allow a single argument.
    '''
    console.error "The shebang line was: '#{firstLine}' in file '#{file}'"
    console.error "The arguments were: #{JSON.stringify args}"