alda.parser.tokenize — alda/core 0.4.0

add-current-buffer-to-last clj

(add-current-buffer-to-last {:keys [stack] :as parser})

advance clj

(advance parser x & [size])

append-to-current-buffer clj

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

current-token-content clj

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

current-token-type clj

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

currently-parsing? clj

(currently-parsing? parser token)

discard-buffer clj

(discard-buffer parser)

emit! clj

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

emit-error! clj

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

emit-token! clj

(emit-token! parser & {:keys [token content pop-stack?]})

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 parser character)

finish-parsing-clj-sexp clj

(finish-parsing-clj-sexp parser character)

ignore-carriage-return clj

(ignore-carriage-return parser character)

initial-parser-state clj

last-token-content clj

(last-token-content {:keys [stack] :as parser})

last-token-type clj

(last-token-type {:keys [stack] :as parser})

new-buffer clj

(new-buffer {:keys [line column] :as parser} token)

next-column clj

(next-column parser)

next-line clj

(next-line parser)

parse-accidentals clj

(parse-accidentals parser character)

parse-at-marker clj

(parse-at-marker parser character)

parse-barline clj

(parse-barline parser character)

parse-clj-char clj

(parse-clj-char parser character)

parse-clj-sexp clj

(parse-clj-sexp p c)

parse-clj-string clj

(parse-clj-string parser character)

parse-colon clj

(parse-colon parser character)

parse-comment clj

(parse-comment parser character)

parse-cram-close clj

(parse-cram-close parser character)

parse-cram-open clj

(parse-cram-open parser character)

parse-duration clj

(parse-duration p c)

parse-equals clj

(parse-equals parser character)

parse-event-seq-close clj

(parse-event-seq-close parser character)

parse-event-seq-open clj

(parse-event-seq-open parser character)

parse-marker clj

(parse-marker parser character)

parse-name clj

(parse-name parser character)

parse-newline clj

(parse-newline parser character)

parse-nickname clj

(parse-nickname parser character)

parse-note clj

(parse-note parser character)

parse-note-length clj

(parse-note-length parser character)

parse-note-rest-or-name clj

(parse-note-rest-or-name parser character)

Parse a character that could be part of:

• a variable name
• a note
• a rest
• an instrument call

parse-octave-change clj

(parse-octave-change parser character)

parse-repeat clj

(parse-repeat parser character)

parse-rest clj

(parse-rest parser character)

parse-slash clj

(parse-slash parser character)

parse-tie clj

(parse-tie parser character)

parse-voice clj

(parse-voice parser character)

parser clj

(parser tokens-ch)

pop-stack clj

(pop-stack parser)

read-character! clj

(read-character! p c)

Reads one character c and updates parser p.

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

read-chars clj

(read-chars parser character whitelist)

read-to-buffer clj

(read-to-buffer parser x & [size])

read-to-new-buffer clj

(read-to-new-buffer parser token x & [size])

reject-chars clj

(reject-chars parser character blacklist)

rename-current-token clj

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

skip-whitespace clj

(skip-whitespace parser character)

start-parsing clj

(start-parsing parser
               character
               token
               &
               [{:keys [start-char ignore-first-char buffer-first-char]}])

start-parsing-accidentals clj

(start-parsing-accidentals p c)

start-parsing-at-marker clj

(start-parsing-at-marker p c)

start-parsing-clj-char clj

(start-parsing-clj-char p c)

start-parsing-clj-sexp clj

(start-parsing-clj-sexp p c)

start-parsing-clj-string clj

(start-parsing-clj-string p c)

start-parsing-comment clj

(start-parsing-comment p c)

start-parsing-duration clj

(start-parsing-duration p c)

start-parsing-marker clj

(start-parsing-marker p c)

start-parsing-nickname clj

(start-parsing-nickname p c)

start-parsing-note-length clj

(start-parsing-note-length p c)

start-parsing-note-rest-or-name clj

(start-parsing-note-rest-or-name p c)

start-parsing-octave-change clj

(start-parsing-octave-change p c)

start-parsing-repeat clj

(start-parsing-repeat p c)

start-parsing-voice clj

(start-parsing-voice p c)

starting-line-and-column clj

(starting-line-and-column {:keys [stack] :as parser})

token-names clj

unexpected-char-error clj

(unexpected-char-error {:keys [line column] :as parser} character)