babel-bridge

Rule = require './Rule' {getLineColumn, getLineColumnString} = require './Tools' {Node} = require './Nodes' NonMatch = require './NonMatch' Stats = require './Stats' { isFunction, peek, log, isPlainObject, isPlainArray, merge, compactFlatten, objectLength, inspect, inspectLean pluralize isClass isPlainArray upperCamelCase mergeInto objectWithout uniqueValues formattedInspect max inspect pushIfNotPresent uniqueValues objectHasKeys } = require 'art-standard-lib' BabelBridgeCompileError = require './BabelBridgeCompileError' module.exports = class Parser extends require("art-class-system").BaseClass @repl: -> (require './Repl').babelBridgeRepl @ @parse: (@_source, options = {})-> (new @).parse @_source, options @classGetter rootRuleName: -> @_rootRuleName || "root" rootRule: -> @getRules()[@_rootRuleName] @extendableProperty rules: {} , (extendableRules, newRules) -> for ruleName, newRule of a extendableRules[ruleName] = newRule.clone() newRule @addRule: (ruleName, definitions, nodeBaseClass = @getNodeBaseClass()) -> rule = @extendRules()[ruleName] ||= new Rule ruleName, @ if definitions.root throw new Error "root rule already defined! was: #{@_rootRuleName}, wanted: #{ruleName}" if @_rootRuleName @_rootRuleName = ruleName definitions = [definitions] unless isPlainArray array = definitions if definitions.length > 1 && isPlainObject(last = peek definitions) && !last.pattern [definitions..., commonNodeProps] = definitions else commonNodeProps = {} commonNodeProps.nodeBaseClass ||= nodeBaseClass for definition in definitions definition = pattern: definition unless isPlainObject definition if isPlainArray patterns = definition.pattern for pattern in patterns rule.addVariant merge commonNodeProps, definition, {pattern} else rule.addVariant merge commonNodeProps, definition ### IN: rules: plain object mapping rule-names to definitions nodeClass: optional, must extend BabelBridge.Node or be a plain object ### @rule: rulesFunction = (a, b)-> if isClass a sharedNodeBaseClass = a rules = b else rules = a sharedNodeBaseClass = b if isPlainObject sharedNodeBaseClass sharedNodeBaseClass = @getNodeBaseClass().createSubclass sharedNodeBaseClass for ruleName, definition of rules @addRule ruleName, definition, sharedNodeBaseClass || @getNodeBaseClass() @rules: rulesFunction rule: instanceRulesFunction = (a, b) -> @class.rule a, b rules: instanceRulesFunction @getNodeBaseClass: -> @_nodeBaseClass ||= if isPlainObject @nodeBaseClass log create: @getName() + "NodeBaseClass" Node.createSubclass merge name: @getName() + "NodeBaseClass" @nodeBaseClass else @nodeBaseClass || Node @property "subparseInfo options" @getter "source parser", rootRuleName: -> @class.getRootRuleName() rootRule: -> @class.getRootRule() nextOffset: -> 0 rootParser: -> @parentParser?.rootParser || @ ancestors: (into) -> into.push @ into parseInfo: -> "Parser" constructor: -> super @_options = null @_parser = @ @_source = null @_resetParserTracking() @_pluralNames = {} @pluralize: (name) -> @_pluralNames[name] ||= pluralize name pluralize: (name) -> @class.pluralize name ### IN: subsource: any string what-so-ever options: [all of @parse's options plus:] parentNode: (required) the resulting Node's parent originalMatchLength: (required) matchLength from @source that subsource was generated from. originalOffset: starting offset in parentParser.source sourceMap: (subsourceOffset) -> parentSourceOffset The original source we are sub-parsing from must be: parentNode.getNextText originalMatchLength OUT: a Node with offset and matchLength ### subparse: (subsource, options = {}) -> Stats.add "subparse" # log subparse: START: {subsource, options} subparser = new @class {originalMatchLength, parentNode, sourceMap, originalOffset} = options options.parentParser = @ if match = subparser.parse subsource, merge(options, isSubparse: true, logParsingFailures: @_logParsingFailures) {offset, matchLength, source, parser} = match # log subsource: SUCCESS: {offset, matchLength, source, parser} match.subparseInfo = {offset, matchLength, source, parser} # if options.allowPartialMatch was requested - and the match was partial... if match.matchLength < subsource.length if match.text != parentNode.getNextText match.matchLength throw new Error "INTERNAL TODO: SubParse was a partial match, but a source-map is required to determine the matchLength in the original source." originalMatchLength = match.matchLength match.offset = parentNode.nextOffset match.matchLength = originalMatchLength match._parent = parentNode match else failureIndex = subparser.failureIndexInParentParser # log subparse: FAILURE: {failureIndex, originalOffset, subFailureIndex: subparser.failureIndex} for k, nonMatch of subparser._nonMatches rootNode = nonMatch.node # throw new Error "A" if rootNode == parentNode while rootNode != parentNode && rootNode.parent instanceof Node rootNode = rootNode.parent # throw new Error "B" if rootNode == parentNode rootNode._parent = parentNode if rootNode != parentNode if @_logParsingFailures @_addNonMatch failureIndex, nonMatch else @_failureIndex = max @_failureIndex, failureIndex null offsetInParentParserSource: (suboffset) -> {sourceMap, originalOffset = 0} = @options if sourceMap sourceMap suboffset else if @parentParser @options.originalOffset + suboffset else suboffset offsetInRootParserSource: (suboffset) -> if @parentParser @parentParser.offsetInRootParserSource @offsetInParentParserSource suboffset else suboffset @getter failureIndexInParentParser: -> @offsetInParentParserSource @_failureIndex colorString: (clr, str)-> if @options.color "#{str}"[clr] else str ### OUT: on success, root Node of the parse tree, else null options: allowPartialMatch: true/false ### parse: (@_source, @options = {})-> {@parentParser, allowPartialMatch, rule, isSubparse, logParsingFailures} = @options startRule = @getRule rule @_resetParserTracking() @_logParsingFailures = logParsingFailures if (result = startRule.parse @) && ( result.matchLength == @_source.length || (allowPartialMatch && result.matchLength > 0) ) result.applyLabels() unless isSubparse result else unless isSubparse if logParsingFailures throw new BabelBridgeCompileError( if result [ @colorString "gray", "#{@class.name} only parsed: " + @colorString "black", "#{result.matchLength} of #{@_source.length} " + @colorString "gray", "characters" @getParseFailureInfo @options ].join "\n" else @getParseFailureInfo @options @parseFailureInfoObject ) else # rerun parse with parsing-failure-logging # NOTE: we could speed this up by not completely trashing the cache @parse @_source, merge @options, logParsingFailures: true getRule: (ruleName) -> ruleName ||= @rootRuleName throw new Error "No root rule defined." unless ruleName unless rule = @rules[ruleName] throw new Error "Could not find rule: #{ruleName}" rule addToExpectingInfo = (node, into, value) -> if node.parent into = addToExpectingInfo node.parent, into into[node.parseInfo] ||= if value value else p = {} if (pm = node.presentMatches)?.length > 0 p.matches = (m.parseInfo for m in pm) p lastLines = (string, count = 5) -> a = string.split "\n" a.slice max(0, a.length - count), a.length .join "\n" firstLines = (string, count = 5) -> a = string.split "\n" a.slice 0, count .join "\n" ################## # Parsing Failure Info ################## @getter "nonMatches", failureUrl: -> "#{@options.sourceFile || ''}:#{getLineColumnString @_source, @_failureIndex}" parseFailureInfoObject: -> merge sourceFile: @options.sourceFile failureIndex: @_failureIndex location: @failureUrl getLineColumn @_source, @_failureIndex parseFailureInfo: (options)-> return unless @_source verbose = options?.verbose sourceBefore = lastLines left = @_source.slice 0, @_failureIndex sourceAfter = firstLines right = @_source.slice @_failureIndex out = compactFlatten [ "" @colorString "gray", "Parsing error at #{@colorString "red", @failureUrl}" "" @colorString "gray", "Source:" @colorString "gray", "..." "#{sourceBefore}#{@colorString "red", "<HERE>"}#{sourceAfter.replace /[\s\n]+$/, ''}" @colorString "gray", "..." "" @getExpectingInfo options if verbose formattedInspect ("partial-parse-tree": @partialParseTree), options "" ] out.join "\n" partialParseTreeLeafNodes: -> return @_partialParseTreeNodes if @_partialParseTreeNodes @getPartialParseTree() @_partialParseTreeNodes partialParseTree: -> return @_partialParseTree if @_partialParseTree expectingInfoTree = {} @_partialParseTreeNodes = for k, {patternElement, node} of @_nonMatches #when (node.getPresent() || node.getPresent == Node.prototype.getPresent) addToExpectingInfo node, expectingInfoTree, patternElement.pattern.toString() n = new Node node n.pattern = patternElement rootNode = n._addToParentAsNonMatch() n @_partialParseTree = rootNode expectingInfo: (options)-> return null unless objectLength(@_nonMatches) > 0 ### I know how to do this right! 1) I want to add all the non-match nodes to the parse-tree 2) I want to further improve the parse-tree inspect - it may be time to do a custom inspect ### partialMatchingParents = [] for node in @partialParseTreeLeafNodes {firstPartialMatchParent} = node pushIfNotPresent partialMatchingParents, firstPartialMatchParent couldMatchRuleNames = [] expecting = {} for pmp in partialMatchingParents for child in pmp.matches when child.isNonMatch && child.nonMatchingLeaf couldMatchRuleNames.push ruleName if ruleName = child.nonMatchingLeaf.ruleNameOrNull expecting[child.nonMatchingLeaf.ruleNameOrPattern] = "to-continue": pmp.ruleName "started-at": getLineColumnString @_source, pmp.absoluteOffset expecting = if objectHasKeys expecting out = {expecting} if couldMatchRuleNames.length > 1 out.rules = {} for ruleName in couldMatchRuleNames for v in @rules[ruleName]._variants out.rules[ruleName] = v.patternString out else expecting: "end of input" formattedInspect expecting, options tryPatternElement: (patternElement, parseIntoNode, ruleVariant) -> Stats.add "tryPatternElement" if patternElement.parseInto parseIntoNode true else @_logParsingFailure parseIntoNode, patternElement false ################## # PRIVATE ################## _getRuleParseCache: (ruleName) -> @_parseCache[ruleName] ||= {} _cached: (ruleName, offset) -> @_getRuleParseCache(ruleName)[offset] _cacheMatch: (ruleName, matchingNode) -> Stats.add "cacheMatch" @_getRuleParseCache(ruleName)[matchingNode.offset] = matchingNode matchingNode _cacheNoMatch: (ruleName, offset) -> Stats.add "cacheNoMatch" @_getRuleParseCache(ruleName)[offset] = "no_match" null _resetParserTracking: -> @_activeRuleVariantParserOffsets = {} @_subparseInfo = null @_logParsingFailures = false @_partialParseTreeNodes = null @_partialParseTree = null @_matchingNegativeDepth = 0 @_parsingDidNotMatchEntireInput = false @_failureIndex = 0 @_nonMatches = {} @_parseCache = {} @_parentParserRootOffset = null @getter "activeRuleVariantParserOffsets activeRuleVariantParserAreLeftRecursive failureIndex", isMatchingNegative: -> @_matchingNegativeDepth > 0 _matchNegative: (f) -> @_matchingNegativeDepth++ result = f() @_matchingNegativeDepth-- result _logParsingFailure: (parseIntoNode, patternElement) -> return unless @_matchingNegativeDepth == 0 && parseIntoNode.offset >= @_failureIndex && patternElement.isTokenPattern {offset} = parseIntoNode # log _logParsingFailures: {offset} if @_logParsingFailures parseIntoNode = parseIntoNode.getRealNode() @_addNonMatch offset, new NonMatch parseIntoNode, patternElement else @_failureIndex = offset _addNonMatch: (offset, nonMatch) -> if offset > @_failureIndex @_failureIndex = offset @_nonMatches = {} @_nonMatches[nonMatch] = nonMatch