alda.parser.parse-events — alda/core 0.6.4

alda-event clj multimethod

alda-event-with-metadata clj

(alda-event-with-metadata {:keys [position] :as event})

append-to-current-event clj

(append-to-current-event {:keys [stack] :as parser} event)

append-to-parent clj

(append-to-parent {:keys [stack] :as parser} & [value])

Given a stack like [[:event-seq] [:note ...]],

if no value arg is provided, appends the top of the stack to the event below: [[:event-seq [:note ...]]]

if a value arg is provided, pops the stack and appends the custom value to the item below: [[:event-seq 'some-custom-value]]

assert-repeat-num clj

(assert-repeat-num parser token)

continue-parsing-chord clj

(continue-parsing-chord p t)

continue-parsing-instrument-call clj

(continue-parsing-instrument-call parser token)

current-event clj

(current-event {:keys [stack] :as parser})

current-event-content clj

(current-event-content {:keys [stack] :as parser})

current-event-type clj

(current-event-type {:keys [stack] :as parser})

disambiguate-name clj

(disambiguate-name p t)

emit! clj

(emit! {:keys [events-ch] :as parser} x)

emit-error! clj

(emit-error! parser e-or-msg)

emit-event! clj

(emit-event! parser event)

ensure-parsing clj

(ensure-parsing {:keys [state] :as parser})

If the parser's state is not :parsing, short-circuits the parser so that the current state is passed through until the end.

Otherwise returns nil so that parsing will continue.

finish-parsing clj

(finish-parsing {:keys [stack] :as parser} token)

finish-parsing-cram clj

(finish-parsing-cram parser token)

finish-parsing-event-seq clj

(finish-parsing-event-seq parser token)

handle-newline clj

(handle-newline parser token)

ignore-comment clj

(ignore-comment parser token)

initial-parser-state clj

(initial-parser-state)

last-open-event clj

(last-open-event {:keys [stack] :as parser})

open-current-event clj

(open-current-event {:keys [stack] :as parser})

parse-accidentals clj

(parse-accidentals parser token)

parse-at-marker clj

(parse-at-marker parser token)

parse-barline clj

(parse-barline parser token)

parse-clj-expr clj

(parse-clj-expr parser token)

parse-colon clj

(parse-colon parser token)

parse-marker clj

(parse-marker parser token)

parse-name clj

(parse-name parser token)

parse-nickname clj

(parse-nickname parser token)

parse-note-length clj

(parse-note-length parser token)

parse-octave-change clj

(parse-octave-change parser token)

parse-repeat clj

(parse-repeat {:keys [stack] :as parser} token)

parse-repeat-num clj

(parse-repeat-num {:keys [stack] :as parser} token)

parse-tie clj

(parse-tie parser token)

parse-voice clj

(parse-voice parser token)

parser clj

(parser events-ch)

pop-and-emit-event! clj

(pop-and-emit-event! {:keys [stack] :as parser})

previous-event clj

(previous-event {:keys [stack] :as parser})

previous-event-content clj

(previous-event-content {:keys [stack] :as parser})

previous-event-type clj

(previous-event-type {:keys [stack] :as parser})

propagate-error clj

(propagate-error parser token)

If there was an error in a previous stage of the parsing pipeline, propagate it through and stop parsing.

push-cram clj

push-event clj

(push-event {:keys [stack] :as parser} event)

push-event-seq clj

push-event-when clj

(push-event-when parser token expected-token)

push-instrument-call clj

(push-instrument-call {:keys [stack] :as parser})

push-set-variable clj

(push-set-variable parser)

read-token! clj

(read-token! p t)

Reads one token t and updates parser p.

Puts events on (:events-ch p) as they are parsed.

rename-current-event clj

(rename-current-event {:keys [stack] :as parser} new-name)

repeatable? clj

start-parsing-chord clj

(start-parsing-chord parser token)

start-parsing-cram clj

(start-parsing-cram parser token)

start-parsing-event-seq clj

(start-parsing-event-seq parser token)

start-parsing-instrument-call clj

(start-parsing-instrument-call parser)

start-parsing-note clj

(start-parsing-note {:keys [chord?] :as parser} token)

start-parsing-rest clj

(start-parsing-rest {:keys [chord?] :as parser} token)

start-parsing-set-variable clj

(start-parsing-set-variable parser token)

token-content clj

(token-content [_ _ content :as token])

token-is clj

(token-is token-type token)

token-position clj

(token-position [_ [line column] _ :as token])

token-type clj

(token-type token)

unexpected-token-error clj

(unexpected-token-error parser token)

validate-variable-event clj

(validate-variable-event var-name [line column])