ly.lex package
**************


Module contents
===============

This module is built on top of slexer and can parse LilyPond input and
other formats.

The base functionality is delegated to modules with an underscore in
this package. The modules describing parsing modes (filetypes) are the
files without underscore.

Currently available are modes for lilypond, latex, html, texinfo,
scheme, and docbook.

The 'underscored' modules should not be imported in application code.
What is needed from them is available here, in the ly.lex namespace.

If you add new files for parsing other file types, you should add them
in _mode.py. The _token.py module contains base Token types and Token
mixin classes.

The State, Parser, FallthroughParser and Fridge classes from slexer
are all slightly extended here,

Usage:

   >>> import ly.lex
   >>> txt = r"\relative c' { c d e f-^ g }"
   >>> s = ly.lex.state("lilypond")
   >>> for t in s.tokens(txt):
   ...     print(t, t.__class__.__name__)
   \relative Command
     Space
   c Name
   ' Unparsed
     Space
   { SequentialStart
     Space
   c Note
     Space
   d Note
     Space
   e Note
     Space
   f Note
   - Direction
   ^ ScriptAbbreviation
     Space
   g Note
     Space
   } SequentialEnd

A State() is used to parse text. The text is given to the tokens()
method, that returns an iterator iterating over Token instances as
they are found. Each token has a 'pos' and an 'end' attribute
describing its position in the original string.

While iterating over the tokens(), the State maintains information
about what kind of text is parsed. (So don't iterate over more than
one call to tokens() of the same State object at the same time.)

Use ly.lex.state("name") to get a state for a specific mode to start
parsing with. If you don't know the type of text, you can use
ly.lex.guessState(text), where text is the text you want to parse. A
quick heuristic is then used to determine the type of the text.

See for more information the documentation of the slexer module.

class ly.lex.State(initialParserClass)

   Bases: "ly.slexer.State"

   endArgument()

      Decrease argcount and leave the parser if it would reach 0.

   mode()

      Returns the mode attribute of the first parser (from current
      parser) that has it.

class ly.lex.Parser(argcount=None)

   Bases: "ly.slexer.Parser"

   argcount = 0

   default

      alias of "ly.lex._token.Unparsed"

   freeze()

      Return our instance values as a hashable tuple.

   mode = None

   re_flags = 40

class ly.lex.FallthroughParser(argcount=None)

   Bases: "ly.lex.Parser", "ly.slexer.FallthroughParser"

class ly.lex.Fridge(stateClass=<class 'ly.lex.State'>)

   Bases: "ly.slexer.Fridge"

ly.lex.guessMode(text)

   Tries to guess the type of the input text, using a quite fast
   heuristic.

   Returns one of the strings also present as key in the modes
   dictionary.

ly.lex.state(mode)

   Returns a State instance for the given mode.

ly.lex.guessState(text)

   Returns a State instance, guessing the type of text.

class ly.lex.Token

   Bases: "ly.slexer.Token"

   end

   pos

class ly.lex.Unparsed

   Bases: "ly.lex._token.Token"

   Represents an unparsed piece of input text.

   end

   pos

class ly.lex.Space

   Bases: "ly.lex._token.Token"

   A token containing whitespace.

   end

   pos

   rx = '\\s+'

class ly.lex.Newline

   Bases: "ly.lex._token.Space"

   A token that is a single newline.

   end

   pos

   rx = '\\n'

class ly.lex.Comment

   Bases: "ly.lex._token.Token"

   Base class for tokens that belong to a comment.

   end

   pos

class ly.lex.LineComment

   Bases: "ly.lex._token.Comment"

   Base class for items that are a whole line comment.

   end

   pos

class ly.lex.BlockComment

   Bases: "ly.lex._token.Comment"

   Base class for tokens that belong to a block/multiline comment.

   end

   pos

class ly.lex.BlockCommentStart

   Bases: "ly.lex._token.BlockComment"

   Base class for tokens that start a block/multiline comment.

   end

   pos

class ly.lex.BlockCommentEnd

   Bases: "ly.lex._token.BlockComment"

   Base class for tokens that end a block/multiline comment.

   end

   pos

class ly.lex.String

   Bases: "ly.lex._token.Token"

   Base class for tokens that belong to a quote-delimited string.

   end

   pos

class ly.lex.StringStart

   Bases: "ly.lex._token.String"

   Base class for tokens that start a quote-delimited string.

   end

   pos

class ly.lex.StringEnd

   Bases: "ly.lex._token.String"

   Base class for tokens that end a quote-delimited string.

   end

   pos

class ly.lex.Character

   Bases: "ly.lex._token.Token"

   Base class for tokens that are an (escaped) character.

   end

   pos

class ly.lex.Numeric

   Bases: "ly.lex._token.Token"

   Base class for tokens that are a numerical value.

   end

   pos

class ly.lex.Error

   Bases: "ly.lex._token.Token"

   Base class for tokens that represent erroneous input.

   end

   pos

class ly.lex.MatchStart

   Bases: "object"

   Mixin class for tokens that have a matching token forward in the
   text.

   The matchname attribute should give a unique name.

   matchname = ''

class ly.lex.MatchEnd

   Bases: "object"

   Mixin class for tokens that have a matching token backward in the
   text.

   The matchname attribute should give a unique name.

   matchname = ''

class ly.lex.Indent

   Bases: "object"

   Mixin class for tokens that have the text on the next line indent
   more.

class ly.lex.Dedent

   Bases: "object"

   Mixin class for tokens that have the text on the next line indent
   less.


Submodules
==========


ly.lex.docbook module
=====================

Parses and tokenizes DocBook input, recognizing LilyPond in DocBook.

class ly.lex.docbook.ParseDocBook(argcount=None)

   Bases: "ly.lex.Parser"

   items = (<class 'ly.lex._token.Space'>,)

   mode = 'docbook'

   pattern = re.compile('(?P<g_0>\\s+)', re.MULTILINE)


ly.lex.html module
==================

Parses and tokenizes HTML input, recognizing LilyPond in HTML.

class ly.lex.html.AttrName

   Bases: "ly.lex._token.Token"

   end

   pos

   rx = '\\w+([-_:]\\w+)?'

class ly.lex.html.Comment

   Bases: "ly.lex._token.Comment"

   end

   pos

class ly.lex.html.CommentEnd

   Bases: "ly.lex.html.Comment", "ly.lex._token.Leaver",
   "ly.lex._token.BlockCommentEnd"

   end

   pos

   rx = '-->'

class ly.lex.html.CommentStart

   Bases: "ly.lex.html.Comment", "ly.lex._token.BlockCommentStart"

   end

   pos

   rx = '<!--'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.html.EntityRef

   Bases: "ly.lex._token.Character"

   end

   pos

   rx = '\\&(#\\d+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);'

class ly.lex.html.EqualSign

   Bases: "ly.lex._token.Token"

   end

   pos

   rx = '='

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.html.LilyPondCloseTag

   Bases: "ly.lex.html.LilyPondTag", "ly.lex._token.Leaver"

   end

   pos

   rx = '</lilypond>'

class ly.lex.html.LilyPondFileTag

   Bases: "ly.lex.html.LilyPondTag"

   end

   pos

   rx = '</?lilypondfile\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.html.LilyPondFileTagEnd

   Bases: "ly.lex.html.LilyPondTag", "ly.lex._token.Leaver"

   end

   pos

   rx = '/?>'

class ly.lex.html.LilyPondInlineTag

   Bases: "ly.lex.html.LilyPondTag"

   end

   pos

   rx = '<lilypond\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.html.LilyPondInlineTagEnd

   Bases: "ly.lex.html.LilyPondTag", "ly.lex._token.Leaver"

   end

   pos

   rx = '/?>'

class ly.lex.html.LilyPondTag

   Bases: "ly.lex.html.Tag"

   end

   pos

class ly.lex.html.LilyPondTagEnd

   Bases: "ly.lex.html.LilyPondTag"

   end

   pos

   rx = '>'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.html.LilyPondVersionTag

   Bases: "ly.lex.html.LilyPondTag"

   end

   pos

   rx = '<lilypondversion/?>'

class ly.lex.html.ParseAttr(argcount=None)

   Bases: "ly.lex.Parser"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.html.TagEnd'>, <class 'ly.lex.html.AttrName'>, <class 'ly.lex.html.EqualSign'>, <class 'ly.lex.html.StringDQStart'>, <class 'ly.lex.html.StringSQStart'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>/?>)|(?P<g_2>\\w+([-_:]\\w+)?)|(?P<g_3>=)|(?P<g_4>")|(?P<g_5>\')', re.MULTILINE)

class ly.lex.html.ParseComment(argcount=None)

   Bases: "ly.lex.Parser"

   default

      alias of "Comment"

   items = (<class 'ly.lex.html.CommentEnd'>,)

   pattern = re.compile('(?P<g_0>-->)', re.MULTILINE)

class ly.lex.html.ParseHTML(argcount=None)

   Bases: "ly.lex.Parser"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.html.LilyPondVersionTag'>, <class 'ly.lex.html.LilyPondFileTag'>, <class 'ly.lex.html.LilyPondInlineTag'>, <class 'ly.lex.html.CommentStart'>, <class 'ly.lex.html.TagStart'>, <class 'ly.lex.html.EntityRef'>)

   mode = 'html'

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1><lilypondversion/?>)|(?P<g_2></?lilypondfile\\b)|(?P<g_3><lilypond\\b)|(?P<g_4><!--)|(?P<g_5></?\\w[-_:\\w]*\\b)|(?P<g_6>\\&(#\\d+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);)', re.MULTILINE)

class ly.lex.html.ParseLilyPond(argcount=None)

   Bases: "ly.lex.lilypond.ParseGlobal"

   items = (<class 'ly.lex.html.LilyPondCloseTag'>, <class 'ly.lex.lilypond.Book'>, <class 'ly.lex.lilypond.BookPart'>, <class 'ly.lex.lilypond.Score'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.Paper'>, <class 'ly.lex.lilypond.Header'>, <class 'ly.lex.lilypond.Layout'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.Partial'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>, <class 'ly.lex.lilypond.Name'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.DecimalValue'>)

   pattern = re.compile('(?P<g_0></lilypond>)|(?P<g_1>\\\\book\\b)|(?P<g_2>\\\\bookpart\\b)|(?P<g_3>\\\\score\\b)|(?P<g_4>\\\\markup(?![_-]?[^\\W\\d]))|(?P<g_5>\\\\markuplines(?![_-]?[^\\W\\d]))|(?P<g_6>\\\\markuplist(?![_-], re.MULTILINE)

class ly.lex.html.ParseLilyPondAttr(argcount=None)

   Bases: "ly.lex.Parser"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.html.AttrName'>, <class 'ly.lex.html.EqualSign'>, <class 'ly.lex.html.StringDQStart'>, <class 'ly.lex.html.StringSQStart'>, <class 'ly.lex.html.LilyPondTagEnd'>, <class 'ly.lex.html.SemiColon'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>\\w+([-_:]\\w+)?)|(?P<g_2>=)|(?P<g_3>")|(?P<g_4>\')|(?P<g_5>>)|(?P<g_6>:)', re.MULTILINE)

class ly.lex.html.ParseLilyPondFileOptions(argcount=None)

   Bases: "ly.lex.Parser"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.html.AttrName'>, <class 'ly.lex.html.EqualSign'>, <class 'ly.lex.html.StringDQStart'>, <class 'ly.lex.html.StringSQStart'>, <class 'ly.lex.html.LilyPondFileTagEnd'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>\\w+([-_:]\\w+)?)|(?P<g_2>=)|(?P<g_3>")|(?P<g_4>\')|(?P<g_5>/?>)', re.MULTILINE)

class ly.lex.html.ParseLilyPondInline(argcount=None)

   Bases: "ly.lex.lilypond.ParseMusic"

   items = (<class 'ly.lex.html.LilyPondInlineTagEnd'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.Dynamic'>, <class 'ly.lex.lilypond.Skip'>, <class 'ly.lex.lilypond.Spacer'>, <class 'ly.lex.lilypond.Q'>, <class 'ly.lex.lilypond.Rest'>, <class 'ly.lex.lilypond.Note'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.Octave'>, <class 'ly.lex.lilypond.OctaveCheck'>, <class 'ly.lex.lilypond.AccidentalCautionary'>, <class 'ly.lex.lilypond.AccidentalReminder'>, <class 'ly.lex.lilypond.PipeSymbol'>, <class 'ly.lex.lilypond.VoiceSeparator'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SequentialEnd'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.SimultaneousEnd'>, <class 'ly.lex.lilypond.ChordStart'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.SlurStart'>, <class 'ly.lex.lilypond.SlurEnd'>, <class 'ly.lex.lilypond.PhrasingSlurStart'>, <class 'ly.lex.lilypond.PhrasingSlurEnd'>, <class 'ly.lex.lilypond.Tie'>, <class 'ly.lex.lilypond.BeamStart'>, <class 'ly.lex.lilypond.BeamEnd'>, <class 'ly.lex.lilypond.LigatureStart'>, <class 'ly.lex.lilypond.LigatureEnd'>, <class 'ly.lex.lilypond.Direction'>, <class 'ly.lex.lilypond.StringNumber'>, <class 'ly.lex.lilypond.IntegerValue'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.Partial'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>, <class 'ly.lex.lilypond.TremoloColon'>)

   pattern = re.compile('(?P<g_0>/?>)|(?P<g_1>\\s+)|(?P<g_2>%{)|(?P<g_3>%.*$)|(?P<g_4>[#$](?![{}]))|(?P<g_5>")|(?P<g_6>\\\\[<!>]|\\\\(f{1,5}|p{1,5}|mf|mp|fp|spp?|sff?|sfz|rfz|cresc|decresc|dim|cr|decr)(?![A-Za-z]))|(?P<g_7>\, re.MULTILINE)

class ly.lex.html.ParseStringDQ(argcount=None)

   Bases: "ly.lex.Parser"

   default

      alias of "String"

   items = (<class 'ly.lex.html.StringDQEnd'>, <class 'ly.lex.html.EntityRef'>)

   pattern = re.compile('(?P<g_0>")|(?P<g_1>\\&(#\\d+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);)', re.MULTILINE)

class ly.lex.html.ParseStringSQ(argcount=None)

   Bases: "ly.lex.Parser"

   default

      alias of "String"

   items = (<class 'ly.lex.html.StringSQEnd'>, <class 'ly.lex.html.EntityRef'>)

   pattern = re.compile("(?P<g_0>')|(?P<g_1>\\&(#\\d+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);)", re.MULTILINE)

class ly.lex.html.ParseValue(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   Finds a value or drops back.

   fallthrough(state)

      Called when no match is returned by parse().

      This implementation leaves the current parser and returns None
      (causing the State to continue parsing).

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.html.Value'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>\\w+)', re.MULTILINE)

class ly.lex.html.SemiColon

   Bases: "ly.lex._token.Token"

   end

   pos

   rx = ':'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.html.String

   Bases: "ly.lex._token.String"

   end

   pos

class ly.lex.html.StringDQEnd

   Bases: "ly.lex.html.String", "ly.lex._token.StringEnd",
   "ly.lex._token.Leaver"

   end

   pos

   rx = '"'

class ly.lex.html.StringDQStart

   Bases: "ly.lex.html.String", "ly.lex._token.StringStart"

   end

   pos

   rx = '"'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.html.StringSQEnd

   Bases: "ly.lex.html.String", "ly.lex._token.StringEnd",
   "ly.lex._token.Leaver"

   end

   pos

   rx = "'"

class ly.lex.html.StringSQStart

   Bases: "ly.lex.html.String", "ly.lex._token.StringStart"

   end

   pos

   rx = "'"

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.html.Tag

   Bases: "ly.lex._token.Token"

   end

   pos

class ly.lex.html.TagEnd

   Bases: "ly.lex.html.Tag", "ly.lex._token.Leaver"

   end

   pos

   rx = '/?>'

class ly.lex.html.TagStart

   Bases: "ly.lex.html.Tag"

   end

   pos

   rx = '</?\\w[-_:\\w]*\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.html.Value

   Bases: "ly.lex._token.Leaver"

   end

   pos

   rx = '\\w+'


ly.lex.latex module
===================

Parses and tokenizes LaTeX input, recognizing LilyPond in LaTeX.

class ly.lex.latex.ParseLaTeX(argcount=None)

   Bases: "ly.lex.Parser"

   items = (<class 'ly.lex._token.Space'>,)

   mode = 'latex'

   pattern = re.compile('(?P<g_0>\\s+)', re.MULTILINE)


ly.lex.lilypond module
======================

Parses and tokenizes LilyPond input.

class ly.lex.lilypond.Accidental

   Bases: "ly.lex._token.Token"

   end

   pos

class ly.lex.lilypond.AccidentalCautionary

   Bases: "ly.lex.lilypond.Accidental"

   end

   pos

   rx = '\\?'

class ly.lex.lilypond.AccidentalReminder

   Bases: "ly.lex.lilypond.Accidental"

   end

   pos

   rx = '!'

class ly.lex.lilypond.AccidentalStyle

   Bases: "ly.lex.lilypond.Command"

   end

   pos

   rx = '\\\\accidentalStyle\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.AccidentalStyleSpecifier

   Bases: "ly.lex.lilypond.Specifier"

   end

   pos

   rx = '\\b(default|voice|modern|modern-cautionary|modern-voice|modern-voice-cautionary|piano|piano-cautionary|neo-modern|neo-modern-cautionary|neo-modern-voice|neo-modern-voice-cautionary|dodecaphonic|teaching|no-reset|forget)(?!-?\\w)'

class ly.lex.lilypond.AlterBroken

   Bases: "ly.lex.lilypond.Command"

   end

   pos

   rx = '\\\\alterBroken\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.Articulation

   Bases: "ly.lex._token.Token"

   Base class for articulation things.

   end

   pos

class ly.lex.lilypond.ArticulationCommand

   Bases: "ly.lex.lilypond.Articulation",
   "ly.lex.lilypond.IdentifierRef"

   end

   pos

   classmethod test_match(match)

      Should return True if the match should indeed instantiate this
      class.

      This class method is only called if multiple Token classes in
      the Parser's items list have the same rx attribute. This method
      is then called for every matching Token subclass until one
      returns True. That token is then instantiated. (The method is
      not called for the last class in the list that have the same rx
      attribute, and also not if there is only one class with that rx
      attribute.)

      The default implementation always returns True.

class ly.lex.lilypond.BackSlashedContextName

   Bases: "ly.lex.lilypond.ContextName"

   end

   pos

   rx = '\\\\(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianTranscriptionVoice|KievanStaff|KievanVoice|Lyrics|MensuralStaff|MensuralVoice|NoteNames|NullVoice|PetrucciStaff|PetrucciVoice|PianoStaff|RhythmicStaff|Score|Staff|StaffGroup|TabStaff|TabVoice|Timing|VaticanaStaff|VaticanaVoice|Voice)\\b'

class ly.lex.lilypond.Beam

   Bases: "ly.lex._token.Token"

   end

   pos

class ly.lex.lilypond.BeamEnd

   Bases: "ly.lex.lilypond.Beam", "ly.lex._token.MatchEnd"

   end

   matchname = 'beam'

   pos

   rx = '\\]'

class ly.lex.lilypond.BeamStart

   Bases: "ly.lex.lilypond.Beam", "ly.lex._token.MatchStart"

   end

   matchname = 'beam'

   pos

   rx = '\\['

class ly.lex.lilypond.BlockComment

   Bases: "ly.lex.lilypond.Comment", "ly.lex._token.BlockComment"

   end

   pos

class ly.lex.lilypond.BlockCommentEnd

   Bases: "ly.lex.lilypond.Comment", "ly.lex._token.BlockCommentEnd",
   "ly.lex._token.Leaver"

   end

   pos

   rx = '%}'

class ly.lex.lilypond.BlockCommentStart

   Bases: "ly.lex.lilypond.Comment", "ly.lex._token.BlockCommentStart"

   end

   pos

   rx = '%{'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.Book

   Bases: "ly.lex.lilypond.Keyword"

   end

   pos

   rx = '\\\\book\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.BookPart

   Bases: "ly.lex.lilypond.Keyword"

   end

   pos

   rx = '\\\\bookpart\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.Change

   Bases: "ly.lex.lilypond.Translator"

   end

   pos

   rx = '\\\\change\\b'

class ly.lex.lilypond.Chord

   Bases: "ly.lex._token.Token"

   Base class for Chord delimiters.

   end

   pos

class ly.lex.lilypond.ChordEnd

   Bases: "ly.lex.lilypond.Chord", "ly.lex._token.Leaver"

   end

   pos

   rx = '>'

class ly.lex.lilypond.ChordItem

   Bases: "ly.lex._token.Token"

   Base class for chordmode items.

   end

   pos

class ly.lex.lilypond.ChordMode

   Bases: "ly.lex.lilypond.InputMode"

   end

   pos

   rx = '\\\\(chords|chordmode)\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.ChordModifier

   Bases: "ly.lex.lilypond.ChordItem"

   end

   pos

   rx = '((?<![a-z])|^)(aug|dim|sus|min|maj|m)(?![a-z])'

class ly.lex.lilypond.ChordSeparator

   Bases: "ly.lex.lilypond.ChordItem"

   end

   pos

   rx = ':|\\^|/\\+?'

class ly.lex.lilypond.ChordStart

   Bases: "ly.lex.lilypond.Chord"

   end

   pos

   rx = '<'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.ChordStepNumber

   Bases: "ly.lex.lilypond.ChordItem"

   end

   pos

   rx = '\\d+[-+]?'

class ly.lex.lilypond.Clef

   Bases: "ly.lex.lilypond.Command"

   end

   pos

   rx = '\\\\clef\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.ClefSpecifier

   Bases: "ly.lex.lilypond.Specifier"

   end

   pos

   rx = '\\b(alto|baritone|bass|C|F|french|G|GG|mezzosoprano|percussion|soprano|subbass|tab|tenor|tenorG|treble|varbaritone|varC|varpercussion|violin)\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.CloseBracket

   Bases: "ly.lex.lilypond.Delimiter", "ly.lex._token.MatchEnd",
   "ly.lex._token.Dedent"

   end

   matchname = 'bracket'

   pos

   rx = '\\}'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.CloseBracketMarkup

   Bases: "ly.lex.lilypond.CloseBracket"

   end

   pos

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.CloseSimultaneous

   Bases: "ly.lex.lilypond.Delimiter", "ly.lex._token.MatchEnd",
   "ly.lex._token.Dedent"

   end

   matchname = 'simultaneous'

   pos

   rx = '>>'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.Command

   Bases: "ly.lex._token.Item", "ly.lex.lilypond.IdentifierRef"

   end

   pos

   classmethod test_match(match)

      Should return True if the match should indeed instantiate this
      class.

      This class method is only called if multiple Token classes in
      the Parser's items list have the same rx attribute. This method
      is then called for every matching Token subclass until one
      returns True. That token is then instantiated. (The method is
      not called for the last class in the list that have the same rx
      attribute, and also not if there is only one class with that rx
      attribute.)

      The default implementation always returns True.

class ly.lex.lilypond.Comment

   Bases: "ly.lex._token.Comment"

   end

   pos

class ly.lex.lilypond.Context

   Bases: "ly.lex.lilypond.Translator"

   end

   pos

   rx = '\\\\context\\b'

class ly.lex.lilypond.ContextName

   Bases: "ly.lex._token.Token"

   end

   pos

   rx = '\\b(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianTranscriptionVoice|KievanStaff|KievanVoice|Lyrics|MensuralStaff|MensuralVoice|NoteNames|NullVoice|PetrucciStaff|PetrucciVoice|PianoStaff|RhythmicStaff|Score|Staff|StaffGroup|TabStaff|TabVoice|Timing|VaticanaStaff|VaticanaVoice|Voice)\\b'

class ly.lex.lilypond.ContextProperty

   Bases: "ly.lex.lilypond.Variable"

   end

   pos

   rx = '\\b(aDueText|accidentalGrouping|additionalPitchPrefix|alignAboveContext|alignBassFigureAccidentals|alignBelowContext|alternativeNumberingStyle|associatedVoice|autoAccidentals|autoBeamCheck|autoBeaming|autoCautionaries|automaticBars|barAlways|barCheckSynchronize|barNumberFormatter|barNumberVisibility|baseMoment|bassFigureFormatFunction|bassStaffProperties|beamExceptions|beamHalfMeasure|beatStructure|chordChanges|chordNameExceptions|chordNameExceptionsFull|chordNameExceptionsPartial|chordNameFunction|chordNameLowercaseMinor|chordNameSeparator|chordNoteNamer|chordPrefixSpacer|chordRootNamer|clefGlyph|clefPosition|clefTransposition|clefTranspositionFormatter|clefTranspositionStyle|completionBusy|completionUnit|connectArpeggios|countPercentRepeats|createKeyOnClefChange|createSpacing|crescendoSpanner|crescendoText|cueClefGlyph|cueClefPosition|cueClefTransposition|cueClefTranspositionFormatter|cueClefTranspositionStyle|currentBarNumber|decrescendoSpanner|decrescendoText|defaultBarType|defaultStrings|doubleRepeatSegnoType|doubleRepeatType|doubleSlurs|drumPitchTable|drumStyleTable|endRepeatSegnoType|endRepeatType|explicitClefVisibility|explicitCueClefVisibility|explicitKeySignatureVisibility|extendersOverRests|extraNatural|figuredBassAlterationDirection|figuredBassCenterContinuations|figuredBassFormatter|figuredBassPlusDirection|fingeringOrientations|firstClef|followVoice|fontSize|forbidBreak|forceClef|fretLabels|glissandoMap|gridInterval|handleNegativeFrets|harmonicAccidentals|harmonicDots|highStringOne|ignoreBarChecks|ignoreFiguredBassRest|ignoreMelismata|implicitBassFigures|implicitTimeSignatureVisibility|includeGraceNotes|instrumentCueName|instrumentEqualizer|instrumentName|instrumentTransposition|internalBarNumber|keepAliveInterfaces|keyAlterationOrder|keySignature|lyricMelismaAlignment|majorSevenSymbol|markFormatter|maximumFretStretch|measureLength|measurePosition|melismaBusyProperties|metronomeMarkFormatter|middleCClefPosition|middleCCuePosition|middleCOffset|middleCPosition|midiBalance|midiChannelMapping|midiChorusLevel|midiInstrument|midiMaximumVolume|midiMergeUnisons|midiMinimumVolume|midiPanPosition|midiReverbLevel|minimumFret|minimumPageTurnLength|minimumRepeatLengthForPageTurn|minorChordModifier|noChordSymbol|noteToFretFunction|ottavation|output|partCombineTextsOnNote|pedalSostenutoStrings|pedalSostenutoStyle|pedalSustainStrings|pedalSustainStyle|pedalUnaCordaStrings|pedalUnaCordaStyle|predefinedDiagramTable|printKeyCancellation|printOctaveNames|printPartCombineTexts|proportionalNotationDuration|rehearsalMark|repeatCommands|repeatCountVisibility|restCompletionBusy|restNumberThreshold|restrainOpenStrings|searchForVoice|segnoType|shapeNoteStyles|shortInstrumentName|shortVocalName|skipBars|skipTypesetting|slashChordSeparator|soloIIText|soloText|squashedPosition|staffLineLayoutFunction|stanza|startRepeatSegnoType|startRepeatType|stemLeftBeamCount|stemRightBeamCount|strictBeatBeaming|stringNumberOrientations|stringOneTopmost|stringTunings|strokeFingerOrientations|subdivideBeams|suggestAccidentals|supportNonIntegerFret|systemStartDelimiter|systemStartDelimiterHierarchy|tabStaffLineLayoutFunction|tablatureFormat|tempoHideNote|tempoWholesPerMinute|tieWaitForNote|timeSignatureFraction|timeSignatureSettings|timing|tonic|topLevelAlignment|trebleStaffProperties|tremoloFlags|tupletFullLength|tupletFullLengthNote|tupletSpannerDuration|useBassFigureExtenders|vocalName|voltaSpannerDuration|whichBar)\\b'

class ly.lex.lilypond.DecimalValue

   Bases: "ly.lex.lilypond.Value"

   end

   pos

   rx = '-?\\d+(\\.\\d+)?'

class ly.lex.lilypond.Delimiter

   Bases: "ly.lex._token.Token"

   end

   pos

class ly.lex.lilypond.Direction

   Bases: "ly.lex._token.Token"

   end

   pos

   rx = '[-_^]'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.Dot

   Bases: "ly.lex.lilypond.Duration"

   end

   pos

   rx = '\\.'

class ly.lex.lilypond.DotChord

   Bases: "ly.lex.lilypond.ChordItem"

   end

   pos

   rx = '\\.'

class ly.lex.lilypond.DotPath

   Bases: "ly.lex.lilypond.Delimiter"

   A dot in dotted path notation.

   end

   pos

   rx = '\\.'

class ly.lex.lilypond.DrumChordEnd

   Bases: "ly.lex.lilypond.ChordEnd"

   end

   pos

class ly.lex.lilypond.DrumChordStart

   Bases: "ly.lex.lilypond.ChordStart"

   end

   pos

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.DrumMode

   Bases: "ly.lex.lilypond.InputMode"

   end

   pos

   rx = '\\\\(drums|drummode)\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.DrumNote

   Bases: "ly.lex.lilypond.MusicItem"

   end

   pos

   rx = '[a-z]+(?![A-Za-z])'

class ly.lex.lilypond.Duration

   Bases: "ly.lex._token.Token"

   end

   pos

class ly.lex.lilypond.Dynamic

   Bases: "ly.lex._token.Token"

   end

   pos

   rx = '\\\\[<!>]|\\\\(f{1,5}|p{1,5}|mf|mp|fp|spp?|sff?|sfz|rfz|cresc|decresc|dim|cr|decr)(?![A-Za-z])'

class ly.lex.lilypond.EqualSign

   Bases: "ly.lex._token.Token"

   end

   pos

   rx = '='

class ly.lex.lilypond.Error

   Bases: "ly.lex._token.Error"

   end

   pos

class ly.lex.lilypond.ErrorInChord

   Bases: "ly.lex.lilypond.Error"

   end

   pos

   rx = '[-_^][_.>|!+^-]|<<|>>|\\\\[\\\\\\]\\[\\(\\)()]|(\\\\(maxima|longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?!\\d))|\\*[\\t ]*\\d+(/\\d+)?'

class ly.lex.lilypond.ExpectBook(argcount=None)

   Bases: "ly.lex.lilypond.ExpectOpenBracket"

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)', re.MULTILINE)

   replace

      alias of "ParseBook"

class ly.lex.lilypond.ExpectBookPart(argcount=None)

   Bases: "ly.lex.lilypond.ExpectOpenBracket"

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)', re.MULTILINE)

   replace

      alias of "ParseBookPart"

class ly.lex.lilypond.ExpectChordMode(argcount=None)

   Bases: "ly.lex.lilypond.ExpectMusicList"

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)|(?P<g_4><<)|(?P<g_5>\\\\(simultaneous|sequential)\\b)', re.MULTILINE)

   replace

      alias of "ParseChordMode"

class ly.lex.lilypond.ExpectContext(argcount=None)

   Bases: "ly.lex.lilypond.ExpectOpenBracket"

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)', re.MULTILINE)

   replace

      alias of "ParseContext"

class ly.lex.lilypond.ExpectDrumMode(argcount=None)

   Bases: "ly.lex.lilypond.ExpectMusicList"

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)|(?P<g_4><<)|(?P<g_5>\\\\(simultaneous|sequential)\\b)', re.MULTILINE)

   replace

      alias of "ParseDrumMode"

class ly.lex.lilypond.ExpectFigureMode(argcount=None)

   Bases: "ly.lex.lilypond.ExpectMusicList"

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)|(?P<g_4><<)|(?P<g_5>\\\\(simultaneous|sequential)\\b)', re.MULTILINE)

   replace

      alias of "ParseFigureMode"

class ly.lex.lilypond.ExpectGrobProperty(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.GrobProperty'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\b([a-z]+|[XY])(-([a-z]+|[XY]))*(?![\\w]))', re.MULTILINE)

   update_state(state, token)

      Called by the default implementation of Token.update_state().

      Does nothing by default.

class ly.lex.lilypond.ExpectHeader(argcount=None)

   Bases: "ly.lex.lilypond.ExpectOpenBracket"

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)', re.MULTILINE)

   replace

      alias of "ParseHeader"

class ly.lex.lilypond.ExpectLayout(argcount=None)

   Bases: "ly.lex.lilypond.ExpectOpenBracket"

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)', re.MULTILINE)

   replace

      alias of "ParseLayout"

class ly.lex.lilypond.ExpectLyricMode(argcount=None)

   Bases: "ly.lex.lilypond.ExpectMusicList"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.OpenBracket'>, <class 'ly.lex.lilypond.OpenSimultaneous'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.Name'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)|(?P<g_4><<)|(?P<g_5>[#$](?![{}]))|(?P<g_6>")|(?P<g_7>(?<![^\\W\\d])[^\\W\\d_]+([_-][^\\W\\d_]+)*(?![_-]?[^\\W\\d]))|(?P<g_8>\\\\(simultaneous|sequ, re.MULTILINE)

   replace

      alias of "ParseLyricMode"

class ly.lex.lilypond.ExpectMidi(argcount=None)

   Bases: "ly.lex.lilypond.ExpectOpenBracket"

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)', re.MULTILINE)

   replace

      alias of "ParseMidi"

class ly.lex.lilypond.ExpectMusicList(argcount=None)

   Bases: "ly.lex.FallthroughParser", "ly.lex.lilypond.ParseLilyPond"

   Waits for an OpenBracket or << and then replaces the parser with
   the class set in the replace attribute.

   Subclass this to set the destination for the OpenBracket.

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.OpenBracket'>, <class 'ly.lex.lilypond.OpenSimultaneous'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)|(?P<g_4><<)|(?P<g_5>\\\\(simultaneous|sequential)\\b)', re.MULTILINE)

   update_state(state, token)

      Called by the default implementation of Token.update_state().

      Does nothing by default.

class ly.lex.lilypond.ExpectNoteMode(argcount=None)

   Bases: "ly.lex.lilypond.ExpectMusicList"

   replace

      alias of "ParseNoteMode"

class ly.lex.lilypond.ExpectOpenBracket(argcount=None)

   Bases: "ly.lex.FallthroughParser", "ly.lex.lilypond.ParseLilyPond"

   Waits for an OpenBracket and then replaces the parser with the
   class set in the replace attribute.

   Subclass this to set the destination for the OpenBracket.

   default

      alias of "Error"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.OpenBracket'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\{)', re.MULTILINE)

   update_state(state, token)

      Called by the default implementation of Token.update_state().

      Does nothing by default.

class ly.lex.lilypond.ExpectPaper(argcount=None)

   Bases: "ly.lex.lilypond.ExpectOpenBracket"

   replace

      alias of "ParsePaper"

class ly.lex.lilypond.ExpectScore(argcount=None)

   Bases: "ly.lex.lilypond.ExpectOpenBracket"

   replace

      alias of "ParseScore"

class ly.lex.lilypond.ExpectTranslatorId(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.EqualSign'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>=)', re.MULTILINE)

   update_state(state, token)

      Called by the default implementation of Token.update_state().

      Does nothing by default.

class ly.lex.lilypond.ExpectWith(argcount=None)

   Bases: "ly.lex.lilypond.ExpectOpenBracket"

   replace

      alias of "ParseWith"

class ly.lex.lilypond.Figure

   Bases: "ly.lex._token.Token"

   Base class for Figure items.

   end

   pos

class ly.lex.lilypond.FigureAccidental

   Bases: "ly.lex.lilypond.Figure"

   A figure accidental.

   end

   pos

   rx = '[-+!]+'

class ly.lex.lilypond.FigureBracket

   Bases: "ly.lex.lilypond.Figure"

   end

   pos

   rx = '[][]'

class ly.lex.lilypond.FigureEnd

   Bases: "ly.lex.lilypond.Figure", "ly.lex._token.Leaver"

   end

   pos

   rx = '>'

class ly.lex.lilypond.FigureMode

   Bases: "ly.lex.lilypond.InputMode"

   end

   pos

   rx = '\\\\(figures|figuremode)\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.FigureModifier

   Bases: "ly.lex.lilypond.Figure"

   A figure modifier.

   end

   pos

   rx = '\\\\[\\\\!+]|/'

class ly.lex.lilypond.FigureStart

   Bases: "ly.lex.lilypond.Figure"

   end

   pos

   rx = '<'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.FigureStep

   Bases: "ly.lex.lilypond.Figure"

   A step figure number or the underscore.

   end

   pos

   rx = '_|\\d+'

class ly.lex.lilypond.Fingering

   Bases: "ly.lex.lilypond.Articulation", "ly.lex._token.Leaver"

   end

   pos

   rx = '\\d+'

class ly.lex.lilypond.Fraction

   Bases: "ly.lex.lilypond.Value"

   end

   pos

   rx = '\\d+/\\d+'

class ly.lex.lilypond.GrobName

   Bases: "ly.lex._token.Token"

   end

   pos

   rx = '\\b(Accidental|AccidentalCautionary|AccidentalPlacement|AccidentalSuggestion|Ambitus|AmbitusAccidental|AmbitusLine|AmbitusNoteHead|Arpeggio|BalloonTextItem|BarLine|BarNumber|BassFigure|BassFigureAlignment|BassFigureAlignmentPositioning|BassFigureBracket|BassFigureContinuation|BassFigureLine|Beam|BendAfter|BreakAlignGroup|BreakAlignment|BreathingSign|ChordName|Clef|ClefModifier|ClusterSpanner|ClusterSpannerBeacon|CombineTextScript|CueClef|CueEndClef|Custos|DotColumn|Dots|DoublePercentRepeat|DoublePercentRepeatCounter|DoubleRepeatSlash|DynamicLineSpanner|DynamicText|DynamicTextSpanner|Episema|Fingering|FingeringColumn|Flag|FootnoteItem|FootnoteSpanner|FretBoard|Glissando|GraceSpacing|GridLine|GridPoint|Hairpin|HorizontalBracket|InstrumentName|InstrumentSwitch|KeyCancellation|KeySignature|KievanLigature|LaissezVibrerTie|LaissezVibrerTieColumn|LedgerLineSpanner|LeftEdge|LigatureBracket|LyricExtender|LyricHyphen|LyricSpace|LyricText|MeasureCounter|MeasureGrouping|MelodyItem|MensuralLigature|MetronomeMark|MultiMeasureRest|MultiMeasureRestNumber|MultiMeasureRestText|NonMusicalPaperColumn|NoteCollision|NoteColumn|NoteHead|NoteName|NoteSpacing|OttavaBracket|PaperColumn|ParenthesesItem|PercentRepeat|PercentRepeatCounter|PhrasingSlur|PianoPedalBracket|RehearsalMark|RepeatSlash|RepeatTie|RepeatTieColumn|Rest|RestCollision|Script|ScriptColumn|ScriptRow|Slur|SostenutoPedal|SostenutoPedalLineSpanner|SpacingSpanner|SpanBar|SpanBarStub|StaffGrouper|StaffSpacing|StaffSymbol|StanzaNumber|Stem|StemStub|StemTremolo|StringNumber|StrokeFinger|SustainPedal|SustainPedalLineSpanner|System|SystemStartBar|SystemStartBrace|SystemStartBracket|SystemStartSquare|TabNoteHead|TextScript|TextSpanner|Tie|TieColumn|TimeSignature|TrillPitchAccidental|TrillPitchGroup|TrillPitchHead|TrillSpanner|TupletBracket|TupletNumber|UnaCordaPedal|UnaCordaPedalLineSpanner|VaticanaLigature|VerticalAlignment|VerticalAxisGroup|VoiceFollower|VoltaBracket|VoltaBracketSpanner)\\b'

class ly.lex.lilypond.GrobProperty

   Bases: "ly.lex.lilypond.Variable"

   end

   pos

   rx = '\\b([a-z]+|[XY])(-([a-z]+|[XY]))*(?![\\w])'

class ly.lex.lilypond.Header

   Bases: "ly.lex.lilypond.Keyword"

   end

   pos

   rx = '\\\\header\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.HeaderVariable

   Bases: "ly.lex.lilypond.Variable"

   A variable inside Header. Always follow this one by UserVariable.

   end

   pos

   classmethod test_match(match)

      Should return True if the match should indeed instantiate this
      class.

      This class method is only called if multiple Token classes in
      the Parser's items list have the same rx attribute. This method
      is then called for every matching Token subclass until one
      returns True. That token is then instantiated. (The method is
      not called for the last class in the list that have the same rx
      attribute, and also not if there is only one class with that rx
      attribute.)

      The default implementation always returns True.

class ly.lex.lilypond.Hide

   Bases: "ly.lex.lilypond.Keyword"

   end

   pos

   rx = '\\\\hide\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.Identifier

   Bases: "ly.lex._token.Token"

   A variable name, like "some-variable".

   end

   pos

   rx = '(?<![^\\W\\d])[^\\W\\d_]+([_-][^\\W\\d_]+)*(?![_-]?[^\\W\\d])'

class ly.lex.lilypond.IdentifierRef

   Bases: "ly.lex._token.Token"

   A reference to an identifier, e.g. "\some-variable".

   end

   pos

   rx = '\\\\[^\\W\\d_]+([_-][^\\W\\d_]+)*(?![_-]?[^\\W\\d])'

class ly.lex.lilypond.InputMode

   Bases: "ly.lex.lilypond.Command"

   end

   pos

class ly.lex.lilypond.IntegerValue

   Bases: "ly.lex.lilypond.DecimalValue"

   end

   pos

   rx = '\\d+'

class ly.lex.lilypond.KeySignatureMode

   Bases: "ly.lex.lilypond.Command"

   end

   pos

   rx = '\\\\(major|minor|ionian|dorian|phrygian|lydian|mixolydian|aeolian|locrian)(?![A-Za-z])'

class ly.lex.lilypond.Keyword

   Bases: "ly.lex._token.Item", "ly.lex.lilypond.IdentifierRef"

   end

   pos

   classmethod test_match(match)

      Should return True if the match should indeed instantiate this
      class.

      This class method is only called if multiple Token classes in
      the Parser's items list have the same rx attribute. This method
      is then called for every matching Token subclass until one
      returns True. That token is then instantiated. (The method is
      not called for the last class in the list that have the same rx
      attribute, and also not if there is only one class with that rx
      attribute.)

      The default implementation always returns True.

class ly.lex.lilypond.Layout

   Bases: "ly.lex.lilypond.Keyword"

   end

   pos

   rx = '\\\\layout\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.LayoutContext

   Bases: "ly.lex.lilypond.Keyword"

   end

   pos

   rx = '\\\\context\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.LayoutVariable

   Bases: "ly.lex.lilypond.Variable"

   A variable inside Header. Always follow this one by UserVariable.

   end

   pos

   classmethod test_match(match)

      Should return True if the match should indeed instantiate this
      class.

      This class method is only called if multiple Token classes in
      the Parser's items list have the same rx attribute. This method
      is then called for every matching Token subclass until one
      returns True. That token is then instantiated. (The method is
      not called for the last class in the list that have the same rx
      attribute, and also not if there is only one class with that rx
      attribute.)

      The default implementation always returns True.

class ly.lex.lilypond.Length

   Bases: "ly.lex.lilypond.Duration"

   end

   pos

   rx = '(\\\\(maxima|longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?!\\d))'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.Ligature

   Bases: "ly.lex._token.Token"

   end

   pos

class ly.lex.lilypond.LigatureEnd

   Bases: "ly.lex.lilypond.Ligature", "ly.lex._token.MatchEnd"

   end

   matchname = 'ligature'

   pos

   rx = '\\\\\\]'

class ly.lex.lilypond.LigatureStart

   Bases: "ly.lex.lilypond.Ligature", "ly.lex._token.MatchStart"

   end

   matchname = 'ligature'

   pos

   rx = '\\\\\\['

class ly.lex.lilypond.LineComment

   Bases: "ly.lex.lilypond.Comment", "ly.lex._token.LineComment"

   end

   pos

   rx = '%.*$'

class ly.lex.lilypond.Lyric

   Bases: "ly.lex._token.Item"

   Base class for Lyric items.

   end

   pos

class ly.lex.lilypond.LyricExtender

   Bases: "ly.lex.lilypond.Lyric"

   end

   pos

   rx = '__(?=($|[\\s\\\\]))'

class ly.lex.lilypond.LyricHyphen

   Bases: "ly.lex.lilypond.Lyric"

   end

   pos

   rx = '--(?=($|[\\s\\\\]))'

class ly.lex.lilypond.LyricMode

   Bases: "ly.lex.lilypond.InputMode"

   end

   pos

   rx = '\\\\(lyricmode|((old)?add)?lyrics|lyricsto)\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.LyricSkip

   Bases: "ly.lex.lilypond.Lyric"

   end

   pos

   rx = '_(?=($|[\\s\\\\]))'

class ly.lex.lilypond.LyricText

   Bases: "ly.lex.lilypond.Lyric"

   end

   pos

   rx = '[^\\\\\\s\\d\\"]+'

class ly.lex.lilypond.Markup

   Bases: "ly.lex._token.Item"

   Base class for all markup commands.

   end

   pos

class ly.lex.lilypond.MarkupCommand

   Bases: "ly.lex.lilypond.Markup", "ly.lex.lilypond.IdentifierRef"

   A markup command.

   end

   pos

   classmethod test_match(match)

      Should return True if the match should indeed instantiate this
      class.

      This class method is only called if multiple Token classes in
      the Parser's items list have the same rx attribute. This method
      is then called for every matching Token subclass until one
      returns True. That token is then instantiated. (The method is
      not called for the last class in the list that have the same rx
      attribute, and also not if there is only one class with that rx
      attribute.)

      The default implementation always returns True.

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.MarkupLines

   Bases: "ly.lex.lilypond.Markup"

   end

   pos

   rx = '\\\\markuplines(?![_-]?[^\\W\\d])'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.MarkupList

   Bases: "ly.lex.lilypond.Markup"

   end

   pos

   rx = '\\\\markuplist(?![_-]?[^\\W\\d])'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.MarkupScore

   Bases: "ly.lex.lilypond.Markup"

   end

   pos

   rx = '\\\\score\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.MarkupStart

   Bases: "ly.lex.lilypond.Markup", "ly.lex.lilypond.Command"

   end

   pos

   rx = '\\\\markup(?![_-]?[^\\W\\d])'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.MarkupUserCommand

   Bases: "ly.lex.lilypond.Markup", "ly.lex.lilypond.IdentifierRef"

   A user-defined markup (i.e. not in the words markupcommands list).

   end

   pos

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.MarkupWord

   Bases: "ly.lex._token.Item"

   end

   pos

   rx = '[^{}"\\\\\\s#%]+'

class ly.lex.lilypond.Midi

   Bases: "ly.lex.lilypond.Keyword"

   end

   pos

   rx = '\\\\midi\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.MusicItem

   Bases: "ly.lex._token.Token"

   A note, rest, spacer, "\skip" or "q".

   end

   pos

class ly.lex.lilypond.Name

   Bases: "ly.lex.lilypond.UserVariable"

   A variable name without prefix.

   end

   pos

class ly.lex.lilypond.New

   Bases: "ly.lex.lilypond.Translator"

   end

   pos

   rx = '\\\\new\\b'

class ly.lex.lilypond.Note

   Bases: "ly.lex.lilypond.MusicItem"

   end

   pos

   rx = '[a-x]+(?![A-Za-z])'

class ly.lex.lilypond.NoteMode

   Bases: "ly.lex.lilypond.InputMode"

   end

   pos

   rx = '\\\\(notes|notemode)\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.Octave

   Bases: "ly.lex._token.Token"

   end

   pos

   rx = ",+|'+"

class ly.lex.lilypond.OctaveCheck

   Bases: "ly.lex._token.Token"

   end

   pos

   rx = "=(,+|'+)?"

class ly.lex.lilypond.Omit

   Bases: "ly.lex.lilypond.Keyword"

   end

   pos

   rx = '\\\\omit\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.OpenBracket

   Bases: "ly.lex.lilypond.Delimiter", "ly.lex._token.MatchStart",
   "ly.lex._token.Indent"

   An open bracket, does not enter different parser, subclass or
   reimplement Parser.update_state().

   end

   matchname = 'bracket'

   pos

   rx = '\\{'

class ly.lex.lilypond.OpenBracketMarkup

   Bases: "ly.lex.lilypond.OpenBracket"

   end

   pos

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.OpenSimultaneous

   Bases: "ly.lex.lilypond.Delimiter", "ly.lex._token.MatchStart",
   "ly.lex._token.Indent"

   An open double French quote, does not enter different parser,
   subclass or reimplement Parser.update_state().

   end

   matchname = 'simultaneous'

   pos

   rx = '<<'

class ly.lex.lilypond.Override

   Bases: "ly.lex.lilypond.Keyword"

   end

   pos

   rx = '\\\\override\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.Paper

   Bases: "ly.lex.lilypond.Keyword"

   end

   pos

   rx = '\\\\paper\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.PaperVariable

   Bases: "ly.lex.lilypond.Variable"

   A variable inside Paper. Always follow this one by UserVariable.

   end

   pos

   classmethod test_match(match)

      Should return True if the match should indeed instantiate this
      class.

      This class method is only called if multiple Token classes in
      the Parser's items list have the same rx attribute. This method
      is then called for every matching Token subclass until one
      returns True. That token is then instantiated. (The method is
      not called for the last class in the list that have the same rx
      attribute, and also not if there is only one class with that rx
      attribute.)

      The default implementation always returns True.

class ly.lex.lilypond.ParseAccidentalStyle(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.AccidentalStyleSpecifier'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\b(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianT, re.MULTILINE)

   update_state(state, token)

      Called by the default implementation of Token.update_state().

      Does nothing by default.

class ly.lex.lilypond.ParseAlterBroken(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.GrobProperty'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\b([a-z]+|[XY])(-([a-z]+|[XY]))*(?![\\w]))', re.MULTILINE)

   update_state(state, token)

      Called by the default implementation of Token.update_state().

      Does nothing by default.

class ly.lex.lilypond.ParseBlockComment(argcount=None)

   Bases: "ly.lex.Parser"

   default

      alias of "BlockComment"

   items = (<class 'ly.lex.lilypond.BlockCommentEnd'>,)

   pattern = re.compile('(?P<g_0>%})', re.MULTILINE)

class ly.lex.lilypond.ParseBook(argcount=None)

   Bases: "ly.lex.lilypond.ParseLilyPond"

   Parses the expression after "\book {", leaving at "}"

   items = (<class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.BookPart'>, <class 'ly.lex.lilypond.Score'>, <class 'ly.lex.lilypond.Paper'>, <class 'ly.lex.lilypond.Header'>, <class 'ly.lex.lilypond.Layout'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.Partial'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)

   pattern = re.compile('(?P<g_0>\\})|(?P<g_1>\\\\markup(?![_-]?[^\\W\\d]))|(?P<g_2>\\\\markuplines(?![_-]?[^\\W\\d]))|(?P<g_3>\\\\markuplist(?![_-]?[^\\W\\d]))|(?P<g_4>\\\\bookpart\\b)|(?P<g_5>\\\\score\\b)|(?P<g_6>\\\\pape, re.MULTILINE)

class ly.lex.lilypond.ParseBookPart(argcount=None)

   Bases: "ly.lex.lilypond.ParseLilyPond"

   Parses the expression after "\bookpart {", leaving at "}"

   items = (<class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.Score'>, <class 'ly.lex.lilypond.Paper'>, <class 'ly.lex.lilypond.Header'>, <class 'ly.lex.lilypond.Layout'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.Partial'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)

   pattern = re.compile('(?P<g_0>\\})|(?P<g_1>\\\\markup(?![_-]?[^\\W\\d]))|(?P<g_2>\\\\markuplines(?![_-]?[^\\W\\d]))|(?P<g_3>\\\\markuplist(?![_-]?[^\\W\\d]))|(?P<g_4>\\\\score\\b)|(?P<g_5>\\\\paper\\b)|(?P<g_6>\\\\header\, re.MULTILINE)

class ly.lex.lilypond.ParseChord(argcount=None)

   Bases: "ly.lex.lilypond.ParseMusic"

   LilyPond inside chords "< >"

   items = (<class 'ly.lex.lilypond.ErrorInChord'>, <class 'ly.lex.lilypond.ChordEnd'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.Dynamic'>, <class 'ly.lex.lilypond.Skip'>, <class 'ly.lex.lilypond.Spacer'>, <class 'ly.lex.lilypond.Q'>, <class 'ly.lex.lilypond.Rest'>, <class 'ly.lex.lilypond.Note'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.Octave'>, <class 'ly.lex.lilypond.OctaveCheck'>, <class 'ly.lex.lilypond.AccidentalCautionary'>, <class 'ly.lex.lilypond.AccidentalReminder'>, <class 'ly.lex.lilypond.PipeSymbol'>, <class 'ly.lex.lilypond.VoiceSeparator'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SequentialEnd'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.SimultaneousEnd'>, <class 'ly.lex.lilypond.ChordStart'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.SlurStart'>, <class 'ly.lex.lilypond.SlurEnd'>, <class 'ly.lex.lilypond.PhrasingSlurStart'>, <class 'ly.lex.lilypond.PhrasingSlurEnd'>, <class 'ly.lex.lilypond.Tie'>, <class 'ly.lex.lilypond.BeamStart'>, <class 'ly.lex.lilypond.BeamEnd'>, <class 'ly.lex.lilypond.LigatureStart'>, <class 'ly.lex.lilypond.LigatureEnd'>, <class 'ly.lex.lilypond.Direction'>, <class 'ly.lex.lilypond.StringNumber'>, <class 'ly.lex.lilypond.IntegerValue'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.Partial'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)

   pattern = re.compile('(?P<g_0>[-_^][_.>|!+^-]|<<|>>|\\\\[\\\\\\]\\[\\(\\)()]|(\\\\(maxima|longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?!\\d))|\\*[\\t ]*\\d+(/\\d+)?)|(?P<g_1>>)|(?P<g_2>\\s+)|(?P<g_3>%{)|(?P<g, re.MULTILINE)

class ly.lex.lilypond.ParseChordItems(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   items = (<class 'ly.lex.lilypond.ChordSeparator'>, <class 'ly.lex.lilypond.ChordModifier'>, <class 'ly.lex.lilypond.ChordStepNumber'>, <class 'ly.lex.lilypond.DotChord'>, <class 'ly.lex.lilypond.Note'>)

   pattern = re.compile('(?P<g_0>:|\\^|/\\+?)|(?P<g_1>((?<![a-z])|^)(aug|dim|sus|min|maj|m)(?![a-z]))|(?P<g_2>\\d+[-+]?)|(?P<g_3>\\.)|(?P<g_4>[a-x]+(?![A-Za-z]))', re.MULTILINE)

class ly.lex.lilypond.ParseChordMode(argcount=None)

   Bases: "ly.lex.lilypond.ParseInputMode",
   "ly.lex.lilypond.ParseMusic"

   Parser for "\chords" and "\chordmode".

   items = (<class 'ly.lex.lilypond.OpenBracket'>, <class 'ly.lex.lilypond.OpenSimultaneous'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.Dynamic'>, <class 'ly.lex.lilypond.Skip'>, <class 'ly.lex.lilypond.Spacer'>, <class 'ly.lex.lilypond.Q'>, <class 'ly.lex.lilypond.Rest'>, <class 'ly.lex.lilypond.Note'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.Octave'>, <class 'ly.lex.lilypond.OctaveCheck'>, <class 'ly.lex.lilypond.AccidentalCautionary'>, <class 'ly.lex.lilypond.AccidentalReminder'>, <class 'ly.lex.lilypond.PipeSymbol'>, <class 'ly.lex.lilypond.VoiceSeparator'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SequentialEnd'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.SimultaneousEnd'>, <class 'ly.lex.lilypond.ChordStart'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.SlurStart'>, <class 'ly.lex.lilypond.SlurEnd'>, <class 'ly.lex.lilypond.PhrasingSlurStart'>, <class 'ly.lex.lilypond.PhrasingSlurEnd'>, <class 'ly.lex.lilypond.Tie'>, <class 'ly.lex.lilypond.BeamStart'>, <class 'ly.lex.lilypond.BeamEnd'>, <class 'ly.lex.lilypond.LigatureStart'>, <class 'ly.lex.lilypond.LigatureEnd'>, <class 'ly.lex.lilypond.Direction'>, <class 'ly.lex.lilypond.StringNumber'>, <class 'ly.lex.lilypond.IntegerValue'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.Partial'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>, <class 'ly.lex.lilypond.ChordSeparator'>)

   pattern = re.compile('(?P<g_0>\\{)|(?P<g_1><<)|(?P<g_2>\\s+)|(?P<g_3>%{)|(?P<g_4>%.*$)|(?P<g_5>[#$](?![{}]))|(?P<g_6>")|(?P<g_7>\\\\[<!>]|\\\\(f{1,5}|p{1,5}|mf|mp|fp|spp?|sff?|sfz|rfz|cresc|decresc|dim|cr|decr)(?![A-Za-z], re.MULTILINE)

   update_state(state, token)

      Called by the default implementation of Token.update_state().

      Does nothing by default.

class ly.lex.lilypond.ParseClef(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   argcount = 1

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.ClefSpecifier'>, <class 'ly.lex.lilypond.StringQuotedStart'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\b(alto|baritone|bass|C|F|french|G|GG|mezzosoprano|percussion|soprano|subbass|tab|tenor|tenorG|treble|varbaritone|varC|varpercussion|violin)\\b)|(?P<g, re.MULTILINE)

class ly.lex.lilypond.ParseContext(argcount=None)

   Bases: "ly.lex.lilypond.ParseLilyPond"

   Parses the expression after ("\layout {") "\context {", leaving at
   "}"

   items = (<class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.BackSlashedContextName'>, <class 'ly.lex.lilypond.ContextProperty'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.Partial'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)

   pattern = re.compile('(?P<g_0>\\})|(?P<g_1>\\\\(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianTranscriptionVoice|KievanSt, re.MULTILINE)

class ly.lex.lilypond.ParseDecimalValue(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   Parses a decimal value without a # before it (if present).

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.DecimalValue'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\d+/\\d+)|(?P<g_4>-?\\d+(\\.\\d+)?)', re.MULTILINE)

class ly.lex.lilypond.ParseDrumChord(argcount=None)

   Bases: "ly.lex.lilypond.ParseMusic"

   LilyPond inside chords in drummode "< >"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.ErrorInChord'>, <class 'ly.lex.lilypond.DrumChordEnd'>, <class 'ly.lex.lilypond.Dynamic'>, <class 'ly.lex.lilypond.Skip'>, <class 'ly.lex.lilypond.Spacer'>, <class 'ly.lex.lilypond.Q'>, <class 'ly.lex.lilypond.Rest'>, <class 'ly.lex.lilypond.DrumNote'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.PipeSymbol'>, <class 'ly.lex.lilypond.VoiceSeparator'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SequentialEnd'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.SimultaneousEnd'>, <class 'ly.lex.lilypond.ChordStart'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.SlurStart'>, <class 'ly.lex.lilypond.SlurEnd'>, <class 'ly.lex.lilypond.PhrasingSlurStart'>, <class 'ly.lex.lilypond.PhrasingSlurEnd'>, <class 'ly.lex.lilypond.Tie'>, <class 'ly.lex.lilypond.BeamStart'>, <class 'ly.lex.lilypond.BeamEnd'>, <class 'ly.lex.lilypond.LigatureStart'>, <class 'ly.lex.lilypond.LigatureEnd'>, <class 'ly.lex.lilypond.Direction'>, <class 'ly.lex.lilypond.StringNumber'>, <class 'ly.lex.lilypond.IntegerValue'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.Partial'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>[#$](?![{}]))|(?P<g_4>")|(?P<g_5>[-_^][_.>|!+^-]|<<|>>|\\\\[\\\\\\]\\[\\(\\)()]|(\\\\(maxima|longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?, re.MULTILINE)

class ly.lex.lilypond.ParseDrumMode(argcount=None)

   Bases: "ly.lex.lilypond.ParseInputMode",
   "ly.lex.lilypond.ParseMusic"

   Parser for "\drums" and "\drummode".

   items = (<class 'ly.lex.lilypond.OpenBracket'>, <class 'ly.lex.lilypond.OpenSimultaneous'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.Dynamic'>, <class 'ly.lex.lilypond.Skip'>, <class 'ly.lex.lilypond.Spacer'>, <class 'ly.lex.lilypond.Q'>, <class 'ly.lex.lilypond.Rest'>, <class 'ly.lex.lilypond.DrumNote'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.PipeSymbol'>, <class 'ly.lex.lilypond.VoiceSeparator'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SequentialEnd'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.SimultaneousEnd'>, <class 'ly.lex.lilypond.DrumChordStart'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.SlurStart'>, <class 'ly.lex.lilypond.SlurEnd'>, <class 'ly.lex.lilypond.PhrasingSlurStart'>, <class 'ly.lex.lilypond.PhrasingSlurEnd'>, <class 'ly.lex.lilypond.Tie'>, <class 'ly.lex.lilypond.BeamStart'>, <class 'ly.lex.lilypond.BeamEnd'>, <class 'ly.lex.lilypond.LigatureStart'>, <class 'ly.lex.lilypond.LigatureEnd'>, <class 'ly.lex.lilypond.Direction'>, <class 'ly.lex.lilypond.StringNumber'>, <class 'ly.lex.lilypond.IntegerValue'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.Partial'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)

   pattern = re.compile('(?P<g_0>\\{)|(?P<g_1><<)|(?P<g_2>\\s+)|(?P<g_3>%{)|(?P<g_4>%.*$)|(?P<g_5>[#$](?![{}]))|(?P<g_6>")|(?P<g_7>\\\\[<!>]|\\\\(f{1,5}|p{1,5}|mf|mp|fp|spp?|sff?|sfz|rfz|cresc|decresc|dim|cr|decr)(?![A-Za-z], re.MULTILINE)

class ly.lex.lilypond.ParseDuration(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   fallthrough(state)

      Called when no match is returned by parse().

      This implementation leaves the current parser and returns None
      (causing the State to continue parsing).

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.Dot'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\.)', re.MULTILINE)

class ly.lex.lilypond.ParseDurationScaling(argcount=None)

   Bases: "ly.lex.lilypond.ParseDuration"

   fallthrough(state)

      Called when no match is returned by parse().

      This implementation leaves the current parser and returns None
      (causing the State to continue parsing).

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.Scaling'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\*[\\t ]*\\d+(/\\d+)?)', re.MULTILINE)

class ly.lex.lilypond.ParseFigure(argcount=None)

   Bases: "ly.lex.Parser"

   Parse inside "< >" in figure mode.

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.FigureEnd'>, <class 'ly.lex.lilypond.FigureBracket'>, <class 'ly.lex.lilypond.FigureStep'>, <class 'ly.lex.lilypond.FigureAccidental'>, <class 'ly.lex.lilypond.FigureModifier'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>[#$](?![{}]))|(?P<g_4>")|(?P<g_5>>)|(?P<g_6>[][])|(?P<g_7>_|\\d+)|(?P<g_8>[-+!]+)|(?P<g_9>\\\\[\\\\!+]|/)|(?P<g_10>\\\\markup(?![_-]?[^\\W\\d]))|(?P<g_, re.MULTILINE)

class ly.lex.lilypond.ParseFigureMode(argcount=None)

   Bases: "ly.lex.lilypond.ParseInputMode",
   "ly.lex.lilypond.ParseMusic"

   Parser for "\figures" and "\figuremode".

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.CloseSimultaneous'>, <class 'ly.lex.lilypond.OpenBracket'>, <class 'ly.lex.lilypond.OpenSimultaneous'>, <class 'ly.lex.lilypond.PipeSymbol'>, <class 'ly.lex.lilypond.FigureStart'>, <class 'ly.lex.lilypond.Skip'>, <class 'ly.lex.lilypond.Spacer'>, <class 'ly.lex.lilypond.Rest'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.Partial'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>[#$](?![{}]))|(?P<g_4>")|(?P<g_5>\\})|(?P<g_6>>>)|(?P<g_7>\\{)|(?P<g_8><<)|(?P<g_9>\\|)|(?P<g_10><)|(?P<g_11>\\\\skip(?![_-]?[^\\W\\d]))|(?P<g_12>s(?![, re.MULTILINE)

class ly.lex.lilypond.ParseGlobal(argcount=None)

   Bases: "ly.lex.lilypond.ParseLilyPond"

   Parses LilyPond from the toplevel of a file.

   items = (<class 'ly.lex.lilypond.Book'>, <class 'ly.lex.lilypond.BookPart'>, <class 'ly.lex.lilypond.Score'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.Paper'>, <class 'ly.lex.lilypond.Header'>, <class 'ly.lex.lilypond.Layout'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.Partial'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>, <class 'ly.lex.lilypond.Name'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.DecimalValue'>)

   pattern = re.compile('(?P<g_0>\\\\book\\b)|(?P<g_1>\\\\bookpart\\b)|(?P<g_2>\\\\score\\b)|(?P<g_3>\\\\markup(?![_-]?[^\\W\\d]))|(?P<g_4>\\\\markuplines(?![_-]?[^\\W\\d]))|(?P<g_5>\\\\markuplist(?![_-]?[^\\W\\d]))|(?P<g_6>, re.MULTILINE)

   update_state(state, token)

      Called by the default implementation of Token.update_state().

      Does nothing by default.

class ly.lex.lilypond.ParseGlobalAssignment(argcount=None)

   Bases: "ly.lex.FallthroughParser", "ly.lex.lilypond.ParseLilyPond"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.Skip'>, <class 'ly.lex.lilypond.Spacer'>, <class 'ly.lex.lilypond.Q'>, <class 'ly.lex.lilypond.Rest'>, <class 'ly.lex.lilypond.Note'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.DecimalValue'>, <class 'ly.lex.lilypond.Direction'>, <class 'ly.lex.lilypond.StringNumber'>, <class 'ly.lex.lilypond.Dynamic'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\\\skip(?![_-]?[^\\W\\d]))|(?P<g_4>s(?![A-Za-z]))|(?P<g_5>q(?![A-Za-z]))|(?P<g_6>[Rr](?![A-Za-z]))|(?P<g_7>[a-x]+(?![A-Za-z]))|(?P<g_8>(\\\\(maxima|lo, re.MULTILINE)

class ly.lex.lilypond.ParseGrobPropertyPath(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.DotPath'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\.)', re.MULTILINE)

   update_state(state, token)

      Called by the default implementation of Token.update_state().

      Does nothing by default.

class ly.lex.lilypond.ParseHeader(argcount=None)

   Bases: "ly.lex.lilypond.ParseLilyPond"

   Parses the expression after "\header {", leaving at "}"

   items = (<class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.HeaderVariable'>, <class 'ly.lex.lilypond.UserVariable'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.Partial'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)

   pattern = re.compile('(?P<g_0>\\})|(?P<g_1>\\\\markup(?![_-]?[^\\W\\d]))|(?P<g_2>\\\\markuplines(?![_-]?[^\\W\\d]))|(?P<g_3>\\\\markuplist(?![_-]?[^\\W\\d]))|(?P<g_4>(?<![^\\W\\d])[^\\W\\d_]+([_-][^\\W\\d_]+)*(?![_-]?[^\\, re.MULTILINE)

class ly.lex.lilypond.ParseHideOmit(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.GrobName'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\b(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianT, re.MULTILINE)

   update_state(state, token)

      Called by the default implementation of Token.update_state().

      Does nothing by default.

class ly.lex.lilypond.ParseInputMode(argcount=None)

   Bases: "ly.lex.lilypond.ParseLilyPond"

   Base class for parser for mode-changing music commands.

   classmethod update_state(state, token)

      Called by the default implementation of Token.update_state().

      Does nothing by default.

class ly.lex.lilypond.ParseLayout(argcount=None)

   Bases: "ly.lex.lilypond.ParseLilyPond"

   Parses the expression after "\layout {", leaving at "}"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.LayoutContext'>, <class 'ly.lex.lilypond.LayoutVariable'>, <class 'ly.lex.lilypond.UserVariable'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.DecimalValue'>, <class 'ly.lex.lilypond.Unit'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.Partial'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>[#$](?![{}]))|(?P<g_4>")|(?P<g_5>\\})|(?P<g_6>\\\\context\\b)|(?P<g_7>(?<![^\\W\\d])[^\\W\\d_]+([_-][^\\W\\d_]+)*(?![_-]?[^\\W\\d]))|(?P<g_8>=)|(?P<g_9, re.MULTILINE)

class ly.lex.lilypond.ParseLilyPond(argcount=None)

   Bases: "ly.lex.Parser"

   mode = 'lilypond'

class ly.lex.lilypond.ParseLyricMode(argcount=None)

   Bases: "ly.lex.lilypond.ParseInputMode"

   Parser for "\lyrics", "\lyricmode", "\addlyrics", etc.

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.CloseSimultaneous'>, <class 'ly.lex.lilypond.OpenBracket'>, <class 'ly.lex.lilypond.OpenSimultaneous'>, <class 'ly.lex.lilypond.PipeSymbol'>, <class 'ly.lex.lilypond.LyricHyphen'>, <class 'ly.lex.lilypond.LyricExtender'>, <class 'ly.lex.lilypond.LyricSkip'>, <class 'ly.lex.lilypond.LyricText'>, <class 'ly.lex.lilypond.Dynamic'>, <class 'ly.lex.lilypond.Skip'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.Partial'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>[#$](?![{}]))|(?P<g_4>")|(?P<g_5>\\})|(?P<g_6>>>)|(?P<g_7>\\{)|(?P<g_8><<)|(?P<g_9>\\|)|(?P<g_10>--(?=($|[\\s\\\\])))|(?P<g_11>__(?=($|[\\s\\\\])))|(?P, re.MULTILINE)

class ly.lex.lilypond.ParseMarkup(argcount=None)

   Bases: "ly.lex.Parser"

   items = (<class 'ly.lex.lilypond.MarkupScore'>, <class 'ly.lex.lilypond.MarkupCommand'>, <class 'ly.lex.lilypond.MarkupUserCommand'>, <class 'ly.lex.lilypond.OpenBracketMarkup'>, <class 'ly.lex.lilypond.CloseBracketMarkup'>, <class 'ly.lex.lilypond.MarkupWord'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>)

   pattern = re.compile('(?P<g_0>\\\\score\\b)|(?P<g_1>\\\\[^\\W\\d_]+([_-][^\\W\\d_]+)*(?![_-]?[^\\W\\d]))|(?P<g_2>\\{)|(?P<g_3>\\})|(?P<g_4>[^{}"\\\\\\s#%]+)|(?P<g_5>\\s+)|(?P<g_6>%{)|(?P<g_7>%.*$)|(?P<g_8>[#$](?![{}]))|(?, re.MULTILINE)

class ly.lex.lilypond.ParseMidi(argcount=None)

   Bases: "ly.lex.lilypond.ParseLilyPond"

   Parses the expression after "\midi {", leaving at "}"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.LayoutContext'>, <class 'ly.lex.lilypond.LayoutVariable'>, <class 'ly.lex.lilypond.UserVariable'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.DecimalValue'>, <class 'ly.lex.lilypond.Unit'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.Partial'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>[#$](?![{}]))|(?P<g_4>")|(?P<g_5>\\})|(?P<g_6>\\\\context\\b)|(?P<g_7>(?<![^\\W\\d])[^\\W\\d_]+([_-][^\\W\\d_]+)*(?![_-]?[^\\W\\d]))|(?P<g_8>=)|(?P<g_9, re.MULTILINE)

class ly.lex.lilypond.ParseMusic(argcount=None)

   Bases: "ly.lex.lilypond.ParseLilyPond"

   Parses LilyPond music expressions.

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.Dynamic'>, <class 'ly.lex.lilypond.Skip'>, <class 'ly.lex.lilypond.Spacer'>, <class 'ly.lex.lilypond.Q'>, <class 'ly.lex.lilypond.Rest'>, <class 'ly.lex.lilypond.Note'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.Octave'>, <class 'ly.lex.lilypond.OctaveCheck'>, <class 'ly.lex.lilypond.AccidentalCautionary'>, <class 'ly.lex.lilypond.AccidentalReminder'>, <class 'ly.lex.lilypond.PipeSymbol'>, <class 'ly.lex.lilypond.VoiceSeparator'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SequentialEnd'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.SimultaneousEnd'>, <class 'ly.lex.lilypond.ChordStart'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.SlurStart'>, <class 'ly.lex.lilypond.SlurEnd'>, <class 'ly.lex.lilypond.PhrasingSlurStart'>, <class 'ly.lex.lilypond.PhrasingSlurEnd'>, <class 'ly.lex.lilypond.Tie'>, <class 'ly.lex.lilypond.BeamStart'>, <class 'ly.lex.lilypond.BeamEnd'>, <class 'ly.lex.lilypond.LigatureStart'>, <class 'ly.lex.lilypond.LigatureEnd'>, <class 'ly.lex.lilypond.Direction'>, <class 'ly.lex.lilypond.StringNumber'>, <class 'ly.lex.lilypond.IntegerValue'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.Partial'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>, <class 'ly.lex.lilypond.TremoloColon'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>[#$](?![{}]))|(?P<g_4>")|(?P<g_5>\\\\[<!>]|\\\\(f{1,5}|p{1,5}|mf|mp|fp|spp?|sff?|sfz|rfz|cresc|decresc|dim|cr|decr)(?![A-Za-z]))|(?P<g_6>\\\\skip(?![_-, re.MULTILINE)

class ly.lex.lilypond.ParseNoteMode(argcount=None)

   Bases: "ly.lex.lilypond.ParseMusic"

   Parser for "\notes" and "\notemode". Same as Music itself.

class ly.lex.lilypond.ParseOverride(argcount=None)

   Bases: "ly.lex.lilypond.ParseLilyPond"

   argcount = 0

   items = (<class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.GrobProperty'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>)

   pattern = re.compile('(?P<g_0>\\b(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianTranscriptionVoice|KievanStaff|KievanVoic, re.MULTILINE)

   update_state(state, token)

      Called by the default implementation of Token.update_state().

      Does nothing by default.

class ly.lex.lilypond.ParsePaper(argcount=None)

   Bases: "ly.lex.lilypond.ParseLilyPond"

   Parses the expression after "\paper {", leaving at "}"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.PaperVariable'>, <class 'ly.lex.lilypond.UserVariable'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.DecimalValue'>, <class 'ly.lex.lilypond.Unit'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>[#$](?![{}]))|(?P<g_4>")|(?P<g_5>\\})|(?P<g_6>\\\\markup(?![_-]?[^\\W\\d]))|(?P<g_7>\\\\markuplines(?![_-]?[^\\W\\d]))|(?P<g_8>\\\\markuplist(?![_-]?[^, re.MULTILINE)

class ly.lex.lilypond.ParsePitchCommand(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   argcount = 1

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.Note'>, <class 'ly.lex.lilypond.Octave'>)

   pattern = re.compile("(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>[a-x]+(?![A-Za-z]))|(?P<g_4>,+|'+)", re.MULTILINE)

   update_state(state, token)

      Called by the default implementation of Token.update_state().

      Does nothing by default.

class ly.lex.lilypond.ParseRepeat(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.RepeatSpecifier'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.RepeatCount'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\b(unfold|percent|volta|tremolo)(?![A-Za-z]))|(?P<g_4>")|(?P<g_5>\\d+)', re.MULTILINE)

class ly.lex.lilypond.ParseRevert(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   parse the arguments of "\revert"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.GrobProperty'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\b(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianT, re.MULTILINE)

   update_state(state, token)

      Called by the default implementation of Token.update_state().

      Does nothing by default.

class ly.lex.lilypond.ParseScore(argcount=None)

   Bases: "ly.lex.lilypond.ParseLilyPond"

   Parses the expression after "\score {", leaving at "}"

   items = (<class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.Header'>, <class 'ly.lex.lilypond.Layout'>, <class 'ly.lex.lilypond.Midi'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.Partial'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)

   pattern = re.compile('(?P<g_0>\\})|(?P<g_1>\\\\header\\b)|(?P<g_2>\\\\layout\\b)|(?P<g_3>\\\\midi\\b)|(?P<g_4>\\\\with\\b)|(?P<g_5>\\s+)|(?P<g_6>%{)|(?P<g_7>%.*$)|(?P<g_8>[#$](?![{}]))|(?P<g_9>")|(?P<g_10>\\{)|(?P<g_11><<, re.MULTILINE)

class ly.lex.lilypond.ParseScriptAbbreviationOrFingering(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   argcount = 1

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.ScriptAbbreviation'>, <class 'ly.lex.lilypond.Fingering'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>[+|!>._^-])|(?P<g_4>\\d+)', re.MULTILINE)

class ly.lex.lilypond.ParseSet(argcount=None)

   Bases: "ly.lex.lilypond.ParseLilyPond"

   argcount = 0

   items = (<class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.ContextProperty'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.Name'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>)

   pattern = re.compile('(?P<g_0>\\b(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianTranscriptionVoice|KievanStaff|KievanVoic, re.MULTILINE)

   update_state(state, token)

      Called by the default implementation of Token.update_state().

      Does nothing by default.

class ly.lex.lilypond.ParseString(argcount=None)

   Bases: "ly.lex.Parser"

   default

      alias of "String"

   items = (<class 'ly.lex.lilypond.StringQuotedEnd'>, <class 'ly.lex.lilypond.StringQuoteEscape'>)

   pattern = re.compile('(?P<g_0>")|(?P<g_1>\\\\[\\\\"])', re.MULTILINE)

class ly.lex.lilypond.ParseTempo(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.EqualSign'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\\\markup(?![_-]?[^\\W\\d]))|(?P<g_4>")|(?P<g_5>[#$](?![{}]))|(?P<g_6>(\\\\(maxima|longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?!\\d)))|(, re.MULTILINE)

   update_state(state, token)

      Called by the default implementation of Token.update_state().

      Does nothing by default.

class ly.lex.lilypond.ParseTempoAfterEqualSign(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.IntegerValue'>, <class 'ly.lex.lilypond.TempoSeparator'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\d+)|(?P<g_4>[-~](?=\\s*\\d))', re.MULTILINE)

class ly.lex.lilypond.ParseTranslator(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.Name'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\b(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianT, re.MULTILINE)

   update_state(state, token)

      Called by the default implementation of Token.update_state().

      Does nothing by default.

class ly.lex.lilypond.ParseTranslatorId(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   argcount = 1

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.Name'>, <class 'ly.lex.lilypond.StringQuotedStart'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>(?<![^\\W\\d])[^\\W\\d_]+([_-][^\\W\\d_]+)*(?![_-]?[^\\W\\d]))|(?P<g_4>")', re.MULTILINE)

   update_state(state, token)

      Called by the default implementation of Token.update_state().

      Does nothing by default.

class ly.lex.lilypond.ParseTremolo(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   items = (<class 'ly.lex.lilypond.TremoloDuration'>,)

   pattern = re.compile('(?P<g_0>\\b(8|16|32|64|128|256|512|1024|2048)(?!\\d))', re.MULTILINE)

class ly.lex.lilypond.ParseTweak(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.GrobProperty'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\b(Accidental|AccidentalCautionary|AccidentalPlacement|AccidentalSuggestion|Ambitus|AmbitusAccidental|AmbitusLine|AmbitusNoteHead|Arpeggio|BalloonText, re.MULTILINE)

   update_state(state, token)

      Called by the default implementation of Token.update_state().

      Does nothing by default.

class ly.lex.lilypond.ParseTweakGrobProperty(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.DecimalValue'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\.)|(?P<g_4>-?\\d+(\\.\\d+)?)', re.MULTILINE)

   update_state(state, token)

      Called by the default implementation of Token.update_state().

      Does nothing by default.

class ly.lex.lilypond.ParseUnset(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.ContextProperty'>, <class 'ly.lex.lilypond.Name'>)

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>%{)|(?P<g_2>%.*$)|(?P<g_3>\\b(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianT, re.MULTILINE)

   update_state(state, token)

      Called by the default implementation of Token.update_state().

      Does nothing by default.

class ly.lex.lilypond.ParseWith(argcount=None)

   Bases: "ly.lex.lilypond.ParseLilyPond"

   Parses the expression after "\with {", leaving at "}"

   items = (<class 'ly.lex.lilypond.CloseBracket'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.ContextProperty'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.Partial'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>)

   pattern = re.compile('(?P<g_0>\\})|(?P<g_1>\\b(ChoirStaff|ChordNames|CueVoice|Devnull|DrumStaff|DrumVoice|Dynamics|FiguredBass|FretBoards|Global|GrandStaff|GregorianTranscriptionStaff|GregorianTranscriptionVoice|KievanSta, re.MULTILINE)

class ly.lex.lilypond.Partial

   Bases: "ly.lex.lilypond.Command"

   end

   pos

   rx = '\\\\partial\\b'

class ly.lex.lilypond.PhrasingSlurEnd

   Bases: "ly.lex.lilypond.SlurEnd"

   end

   matchname = 'phrasingslur'

   pos

   rx = '\\\\\\)'

class ly.lex.lilypond.PhrasingSlurStart

   Bases: "ly.lex.lilypond.SlurStart"

   end

   matchname = 'phrasingslur'

   pos

   rx = '\\\\\\('

class ly.lex.lilypond.PipeSymbol

   Bases: "ly.lex.lilypond.Delimiter"

   end

   pos

   rx = '\\|'

class ly.lex.lilypond.PitchCommand

   Bases: "ly.lex.lilypond.Command"

   end

   pos

   rx = '\\\\(relative|transpose|transposition|key|octaveCheck)\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.Q

   Bases: "ly.lex.lilypond.MusicItem"

   end

   pos

   rx = 'q(?![A-Za-z])'

class ly.lex.lilypond.Repeat

   Bases: "ly.lex.lilypond.Command"

   end

   pos

   rx = '\\\\repeat(?![A-Za-z])'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.RepeatCount

   Bases: "ly.lex.lilypond.IntegerValue", "ly.lex._token.Leaver"

   end

   pos

class ly.lex.lilypond.RepeatSpecifier

   Bases: "ly.lex.lilypond.Specifier"

   end

   pos

   rx = '\\b(unfold|percent|volta|tremolo)(?![A-Za-z])'

class ly.lex.lilypond.Rest

   Bases: "ly.lex.lilypond.MusicItem"

   end

   pos

   rx = '[Rr](?![A-Za-z])'

class ly.lex.lilypond.Revert

   Bases: "ly.lex.lilypond.Override"

   end

   pos

   rx = '\\\\revert\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.Scaling

   Bases: "ly.lex.lilypond.Duration"

   end

   pos

   rx = '\\*[\\t ]*\\d+(/\\d+)?'

class ly.lex.lilypond.SchemeStart

   Bases: "ly.lex._token.Item"

   end

   pos

   rx = '[#$](?![{}])'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.Score

   Bases: "ly.lex.lilypond.Keyword"

   end

   pos

   rx = '\\\\score\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.ScriptAbbreviation

   Bases: "ly.lex.lilypond.Articulation", "ly.lex._token.Leaver"

   end

   pos

   rx = '[+|!>._^-]'

class ly.lex.lilypond.SequentialEnd

   Bases: "ly.lex.lilypond.CloseBracket"

   end

   pos

class ly.lex.lilypond.SequentialStart

   Bases: "ly.lex.lilypond.OpenBracket"

   end

   pos

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.Set

   Bases: "ly.lex.lilypond.Override"

   end

   pos

   rx = '\\\\set\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.SimultaneousEnd

   Bases: "ly.lex.lilypond.CloseSimultaneous"

   end

   pos

class ly.lex.lilypond.SimultaneousOrSequentialCommand

   Bases: "ly.lex.lilypond.Keyword"

   end

   pos

   rx = '\\\\(simultaneous|sequential)\\b'

class ly.lex.lilypond.SimultaneousStart

   Bases: "ly.lex.lilypond.OpenSimultaneous"

   end

   pos

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.Skip

   Bases: "ly.lex.lilypond.MusicItem"

   end

   pos

   rx = '\\\\skip(?![_-]?[^\\W\\d])'

class ly.lex.lilypond.Slur

   Bases: "ly.lex._token.Token"

   end

   pos

class ly.lex.lilypond.SlurEnd

   Bases: "ly.lex.lilypond.Slur", "ly.lex._token.MatchEnd"

   end

   matchname = 'slur'

   pos

   rx = '\\)'

class ly.lex.lilypond.SlurStart

   Bases: "ly.lex.lilypond.Slur", "ly.lex._token.MatchStart"

   end

   matchname = 'slur'

   pos

   rx = '\\('

class ly.lex.lilypond.Spacer

   Bases: "ly.lex.lilypond.MusicItem"

   end

   pos

   rx = 's(?![A-Za-z])'

class ly.lex.lilypond.Specifier

   Bases: "ly.lex._token.Token"

   end

   pos

class ly.lex.lilypond.String

   Bases: "ly.lex._token.String"

   end

   pos

class ly.lex.lilypond.StringNumber

   Bases: "ly.lex.lilypond.Articulation"

   end

   pos

   rx = '\\\\\\d+'

class ly.lex.lilypond.StringQuoteEscape

   Bases: "ly.lex._token.Character"

   end

   pos

   rx = '\\\\[\\\\"]'

class ly.lex.lilypond.StringQuotedEnd

   Bases: "ly.lex.lilypond.String", "ly.lex._token.StringEnd"

   end

   pos

   rx = '"'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.StringQuotedStart

   Bases: "ly.lex.lilypond.String", "ly.lex._token.StringStart"

   end

   pos

   rx = '"'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.Tempo

   Bases: "ly.lex.lilypond.Command"

   end

   pos

   rx = '\\\\tempo\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.TempoSeparator

   Bases: "ly.lex.lilypond.Delimiter"

   end

   pos

   rx = '[-~](?=\\s*\\d)'

class ly.lex.lilypond.Tie

   Bases: "ly.lex.lilypond.Slur"

   end

   pos

   rx = '~'

class ly.lex.lilypond.Translator

   Bases: "ly.lex.lilypond.Command"

   end

   pos

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.Tremolo

   Bases: "ly.lex._token.Token"

   end

   pos

class ly.lex.lilypond.TremoloColon

   Bases: "ly.lex.lilypond.Tremolo"

   end

   pos

   rx = ':'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.TremoloDuration

   Bases: "ly.lex.lilypond.Tremolo", "ly.lex._token.Leaver"

   end

   pos

   rx = '\\b(8|16|32|64|128|256|512|1024|2048)(?!\\d)'

class ly.lex.lilypond.Tweak

   Bases: "ly.lex.lilypond.Keyword"

   end

   pos

   rx = '\\\\tweak\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.Unit

   Bases: "ly.lex.lilypond.Command"

   end

   pos

   rx = '\\\\(mm|cm|in|pt)\\b'

class ly.lex.lilypond.Unset

   Bases: "ly.lex.lilypond.Keyword"

   end

   pos

   rx = '\\\\unset\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.lilypond.UserCommand

   Bases: "ly.lex.lilypond.IdentifierRef"

   end

   pos

class ly.lex.lilypond.UserVariable

   Bases: "ly.lex.lilypond.Identifier"

   end

   pos

class ly.lex.lilypond.Value

   Bases: "ly.lex._token.Item", "ly.lex._token.Numeric"

   end

   pos

class ly.lex.lilypond.Variable

   Bases: "ly.lex.lilypond.Identifier"

   end

   pos

class ly.lex.lilypond.VoiceSeparator

   Bases: "ly.lex.lilypond.Delimiter"

   end

   pos

   rx = '\\\\\\\\'

class ly.lex.lilypond.With

   Bases: "ly.lex.lilypond.Keyword"

   end

   pos

   rx = '\\\\with\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.


ly.lex.scheme module
====================

Parses and tokenizes Scheme input.

class ly.lex.scheme.BlockComment

   Bases: "ly.lex.scheme.Comment", "ly.lex._token.BlockComment"

   end

   pos

class ly.lex.scheme.BlockCommentEnd

   Bases: "ly.lex.scheme.Comment", "ly.lex._token.BlockCommentEnd",
   "ly.lex._token.Leaver"

   end

   pos

   rx = '!#'

class ly.lex.scheme.BlockCommentStart

   Bases: "ly.lex.scheme.Comment", "ly.lex._token.BlockCommentStart"

   end

   pos

   rx = '#!'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.scheme.Bool

   Bases: "ly.lex.scheme.Scheme", "ly.lex._token.Item"

   end

   pos

   rx = '#[tf]\\b'

class ly.lex.scheme.Char

   Bases: "ly.lex.scheme.Scheme", "ly.lex._token.Item"

   end

   pos

   rx = '#\\\\([a-z]+|.)'

class ly.lex.scheme.CloseParen

   Bases: "ly.lex.scheme.Scheme", "ly.lex._token.MatchEnd",
   "ly.lex._token.Dedent"

   end

   matchname = 'schemeparen'

   pos

   rx = '\\)'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.scheme.Comment

   Bases: "ly.lex._token.Comment"

   end

   pos

class ly.lex.scheme.Constant

   Bases: "ly.lex.scheme.Word"

   end

   pos

   classmethod test_match(match)

      Should return True if the match should indeed instantiate this
      class.

      This class method is only called if multiple Token classes in
      the Parser's items list have the same rx attribute. This method
      is then called for every matching Token subclass until one
      returns True. That token is then instantiated. (The method is
      not called for the last class in the list that have the same rx
      attribute, and also not if there is only one class with that rx
      attribute.)

      The default implementation always returns True.

class ly.lex.scheme.Dot

   Bases: "ly.lex.scheme.Scheme"

   end

   pos

   rx = '\\.(?!\\S)'

class ly.lex.scheme.Float

   Bases: "ly.lex.scheme.Number"

   end

   pos

   rx = '-?((\\d+(\\.\\d*)|\\.\\d+)(E\\d+)?)(?=$|[)\\s])'

class ly.lex.scheme.Fraction

   Bases: "ly.lex.scheme.Number"

   end

   pos

   rx = '-?\\d+/\\d+(?=$|[)\\s])'

class ly.lex.scheme.Function

   Bases: "ly.lex.scheme.Word"

   end

   pos

   classmethod test_match(match)

      Should return True if the match should indeed instantiate this
      class.

      This class method is only called if multiple Token classes in
      the Parser's items list have the same rx attribute. This method
      is then called for every matching Token subclass until one
      returns True. That token is then instantiated. (The method is
      not called for the last class in the list that have the same rx
      attribute, and also not if there is only one class with that rx
      attribute.)

      The default implementation always returns True.

class ly.lex.scheme.Keyword

   Bases: "ly.lex.scheme.Word"

   end

   pos

   classmethod test_match(match)

      Should return True if the match should indeed instantiate this
      class.

      This class method is only called if multiple Token classes in
      the Parser's items list have the same rx attribute. This method
      is then called for every matching Token subclass until one
      returns True. That token is then instantiated. (The method is
      not called for the last class in the list that have the same rx
      attribute, and also not if there is only one class with that rx
      attribute.)

      The default implementation always returns True.

class ly.lex.scheme.LilyPond

   Bases: "ly.lex._token.Token"

   end

   pos

class ly.lex.scheme.LilyPondEnd

   Bases: "ly.lex.scheme.LilyPond", "ly.lex._token.Leaver",
   "ly.lex._token.MatchEnd", "ly.lex._token.Dedent"

   end

   matchname = 'schemelily'

   pos

   rx = '#}'

class ly.lex.scheme.LilyPondStart

   Bases: "ly.lex.scheme.LilyPond", "ly.lex._token.MatchStart",
   "ly.lex._token.Indent"

   end

   matchname = 'schemelily'

   pos

   rx = '#{'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.scheme.LineComment

   Bases: "ly.lex.scheme.Comment", "ly.lex._token.LineComment"

   end

   pos

   rx = ';.*$'

class ly.lex.scheme.Number

   Bases: "ly.lex._token.Item", "ly.lex._token.Numeric"

   end

   pos

   rx = '(-?\\d+|#(b[0-1]+|o[0-7]+|x[0-9a-fA-F]+)|[-+]inf.0|[-+]?nan.0)(?=$|[)\\s])'

class ly.lex.scheme.OpenParen

   Bases: "ly.lex.scheme.Scheme", "ly.lex._token.MatchStart",
   "ly.lex._token.Indent"

   end

   matchname = 'schemeparen'

   pos

   rx = '\\('

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.scheme.ParseBlockComment(argcount=None)

   Bases: "ly.lex.Parser"

   default

      alias of "BlockComment"

   items = (<class 'ly.lex.scheme.BlockCommentEnd'>,)

   pattern = re.compile('(?P<g_0>!#)', re.MULTILINE)

class ly.lex.scheme.ParseLilyPond(argcount=None)

   Bases: "ly.lex.lilypond.ParseMusic"

   items = (<class 'ly.lex.scheme.LilyPondEnd'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.Dynamic'>, <class 'ly.lex.lilypond.Skip'>, <class 'ly.lex.lilypond.Spacer'>, <class 'ly.lex.lilypond.Q'>, <class 'ly.lex.lilypond.Rest'>, <class 'ly.lex.lilypond.Note'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.Length'>, <class 'ly.lex.lilypond.Octave'>, <class 'ly.lex.lilypond.OctaveCheck'>, <class 'ly.lex.lilypond.AccidentalCautionary'>, <class 'ly.lex.lilypond.AccidentalReminder'>, <class 'ly.lex.lilypond.PipeSymbol'>, <class 'ly.lex.lilypond.VoiceSeparator'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SequentialEnd'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.SimultaneousEnd'>, <class 'ly.lex.lilypond.ChordStart'>, <class 'ly.lex.lilypond.ContextName'>, <class 'ly.lex.lilypond.GrobName'>, <class 'ly.lex.lilypond.SlurStart'>, <class 'ly.lex.lilypond.SlurEnd'>, <class 'ly.lex.lilypond.PhrasingSlurStart'>, <class 'ly.lex.lilypond.PhrasingSlurEnd'>, <class 'ly.lex.lilypond.Tie'>, <class 'ly.lex.lilypond.BeamStart'>, <class 'ly.lex.lilypond.BeamEnd'>, <class 'ly.lex.lilypond.LigatureStart'>, <class 'ly.lex.lilypond.LigatureEnd'>, <class 'ly.lex.lilypond.Direction'>, <class 'ly.lex.lilypond.StringNumber'>, <class 'ly.lex.lilypond.IntegerValue'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.Partial'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>, <class 'ly.lex.lilypond.TremoloColon'>)

   pattern = re.compile('(?P<g_0>#})|(?P<g_1>\\s+)|(?P<g_2>%{)|(?P<g_3>%.*$)|(?P<g_4>[#$](?![{}]))|(?P<g_5>")|(?P<g_6>\\\\[<!>]|\\\\(f{1,5}|p{1,5}|mf|mp|fp|spp?|sff?|sfz|rfz|cresc|decresc|dim|cr|decr)(?![A-Za-z]))|(?P<g_7>\\, re.MULTILINE)

class ly.lex.scheme.ParseScheme(argcount=None)

   Bases: "ly.lex.Parser"

   items = (<class 'ly.lex._token.Space'>, <class 'ly.lex.scheme.OpenParen'>, <class 'ly.lex.scheme.CloseParen'>, <class 'ly.lex.scheme.LineComment'>, <class 'ly.lex.scheme.BlockCommentStart'>, <class 'ly.lex.scheme.LilyPondStart'>, <class 'ly.lex.scheme.VectorStart'>, <class 'ly.lex.scheme.Dot'>, <class 'ly.lex.scheme.Bool'>, <class 'ly.lex.scheme.Char'>, <class 'ly.lex.scheme.Quote'>, <class 'ly.lex.scheme.Fraction'>, <class 'ly.lex.scheme.Float'>, <class 'ly.lex.scheme.Number'>, <class 'ly.lex.scheme.Constant'>, <class 'ly.lex.scheme.Keyword'>, <class 'ly.lex.scheme.Function'>, <class 'ly.lex.scheme.Variable'>, <class 'ly.lex.scheme.Word'>, <class 'ly.lex.scheme.StringQuotedStart'>)

   mode = 'scheme'

   pattern = re.compile('(?P<g_0>\\s+)|(?P<g_1>\\()|(?P<g_2>\\))|(?P<g_3>;.*$)|(?P<g_4>#!)|(?P<g_5>#{)|(?P<g_6>#\\()|(?P<g_7>\\.(?!\\S))|(?P<g_8>#[tf]\\b)|(?P<g_9>#\\\\([a-z]+|.))|(?P<g_10>[\'`,])|(?P<g_11>-?\\d+/\\d+(?=$|[), re.MULTILINE)

class ly.lex.scheme.ParseString(argcount=None)

   Bases: "ly.lex.Parser"

   default

      alias of "String"

   items = (<class 'ly.lex.scheme.StringQuotedEnd'>, <class 'ly.lex.scheme.StringQuoteEscape'>)

   pattern = re.compile('(?P<g_0>")|(?P<g_1>\\\\[\\\\"])', re.MULTILINE)

class ly.lex.scheme.Quote

   Bases: "ly.lex.scheme.Scheme"

   end

   pos

   rx = "['`,]"

class ly.lex.scheme.Scheme

   Bases: "ly.lex._token.Token"

   Baseclass for Scheme tokens.

   end

   pos

class ly.lex.scheme.String

   Bases: "ly.lex._token.String"

   end

   pos

class ly.lex.scheme.StringQuoteEscape

   Bases: "ly.lex._token.Character"

   end

   pos

   rx = '\\\\[\\\\"]'

class ly.lex.scheme.StringQuotedEnd

   Bases: "ly.lex.scheme.String", "ly.lex._token.StringEnd"

   end

   pos

   rx = '"'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.scheme.StringQuotedStart

   Bases: "ly.lex.scheme.String", "ly.lex._token.StringStart"

   end

   pos

   rx = '"'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.scheme.Variable

   Bases: "ly.lex.scheme.Word"

   end

   pos

   classmethod test_match(match)

      Should return True if the match should indeed instantiate this
      class.

      This class method is only called if multiple Token classes in
      the Parser's items list have the same rx attribute. This method
      is then called for every matching Token subclass until one
      returns True. That token is then instantiated. (The method is
      not called for the last class in the list that have the same rx
      attribute, and also not if there is only one class with that rx
      attribute.)

      The default implementation always returns True.

class ly.lex.scheme.VectorStart

   Bases: "ly.lex.scheme.OpenParen"

   end

   pos

   rx = '#\\('

class ly.lex.scheme.Word

   Bases: "ly.lex.scheme.Scheme", "ly.lex._token.Item"

   end

   pos

   rx = '[^()"{}\\s]+'


ly.lex.texinfo module
=====================

Parses and tokenizes Texinfo input, recognizing LilyPond in Texinfo.

class ly.lex.texinfo.Accent

   Bases: "ly.lex.texinfo.EscapeChar"

   end

   pos

   rx = '@[\'"\',=^`~](\\{[a-zA-Z]\\}|[a-zA-Z]\\b)'

class ly.lex.texinfo.Attribute

   Bases: "ly.lex._token.Token"

   end

   pos

class ly.lex.texinfo.Block

   Bases: "ly.lex._token.Token"

   end

   pos

class ly.lex.texinfo.BlockCommentEnd

   Bases: "ly.lex.texinfo.Comment", "ly.lex._token.Leaver",
   "ly.lex._token.BlockCommentEnd"

   end

   pos

   rx = '@end\\s+ignore\\b'

class ly.lex.texinfo.BlockCommentStart

   Bases: "ly.lex.texinfo.Comment", "ly.lex._token.BlockCommentStart"

   end

   pos

   rx = '@ignore\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.texinfo.BlockEnd

   Bases: "ly.lex.texinfo.Block", "ly.lex._token.Leaver"

   end

   pos

   rx = '\\}'

class ly.lex.texinfo.BlockStart

   Bases: "ly.lex.texinfo.Block"

   end

   pos

   rx = '@[a-zA-Z]+\\{'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.texinfo.Comment

   Bases: "ly.lex._token.Comment"

   end

   pos

class ly.lex.texinfo.EscapeChar

   Bases: "ly.lex._token.Character"

   end

   pos

   rx = '@[@{}]'

class ly.lex.texinfo.Keyword

   Bases: "ly.lex._token.Token"

   end

   pos

   rx = '@[a-zA-Z]+'

class ly.lex.texinfo.LilyPondAttrEnd

   Bases: "ly.lex.texinfo.Attribute", "ly.lex._token.Leaver"

   end

   pos

   rx = '\\]'

class ly.lex.texinfo.LilyPondAttrStart

   Bases: "ly.lex.texinfo.Attribute"

   end

   pos

   rx = '\\['

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.texinfo.LilyPondBlockEnd

   Bases: "ly.lex.texinfo.Block", "ly.lex._token.Leaver"

   end

   pos

   rx = '\\}'

class ly.lex.texinfo.LilyPondBlockStart

   Bases: "ly.lex.texinfo.Block"

   end

   pos

   rx = '@lilypond(?=(\\[[a-zA-Z,=0-9\\\\\\s]+\\])?\\{)'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.texinfo.LilyPondBlockStartBrace

   Bases: "ly.lex.texinfo.Block"

   end

   pos

   rx = '\\{'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.texinfo.LilyPondEnvEnd

   Bases: "ly.lex.texinfo.Keyword", "ly.lex._token.Leaver"

   end

   pos

   rx = '@end\\s+lilypond\\b'

class ly.lex.texinfo.LilyPondEnvStart

   Bases: "ly.lex.texinfo.Keyword"

   end

   pos

   rx = '@lilypond\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.texinfo.LilyPondFileStart

   Bases: "ly.lex.texinfo.Block"

   end

   pos

   rx = '@lilypondfile\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.texinfo.LilyPondFileStartBrace

   Bases: "ly.lex.texinfo.Block"

   end

   pos

   rx = '\\{'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.

class ly.lex.texinfo.LineComment

   Bases: "ly.lex.texinfo.Comment", "ly.lex._token.LineComment"

   end

   pos

   rx = '@c\\b.*$'

class ly.lex.texinfo.ParseBlock(argcount=None)

   Bases: "ly.lex.Parser"

   items = (<class 'ly.lex.texinfo.BlockEnd'>, <class 'ly.lex.texinfo.Accent'>, <class 'ly.lex.texinfo.EscapeChar'>, <class 'ly.lex.texinfo.BlockStart'>, <class 'ly.lex.texinfo.Keyword'>)

   pattern = re.compile('(?P<g_0>\\})|(?P<g_1>@[\'"\',=^`~](\\{[a-zA-Z]\\}|[a-zA-Z]\\b))|(?P<g_2>@[@{}])|(?P<g_3>@[a-zA-Z]+\\{)|(?P<g_4>@[a-zA-Z]+)', re.MULTILINE)

class ly.lex.texinfo.ParseComment(argcount=None)

   Bases: "ly.lex.Parser"

   default

      alias of "Comment"

   items = (<class 'ly.lex.texinfo.BlockCommentEnd'>,)

   pattern = re.compile('(?P<g_0>@end\\s+ignore\\b)', re.MULTILINE)

class ly.lex.texinfo.ParseLilyPondAttr(argcount=None)

   Bases: "ly.lex.Parser"

   default

      alias of "Attribute"

   items = (<class 'ly.lex.texinfo.LilyPondAttrEnd'>,)

   pattern = re.compile('(?P<g_0>\\])', re.MULTILINE)

class ly.lex.texinfo.ParseLilyPondBlock(argcount=None)

   Bases: "ly.lex.lilypond.ParseGlobal"

   items = (<class 'ly.lex.texinfo.LilyPondBlockEnd'>, <class 'ly.lex.lilypond.Book'>, <class 'ly.lex.lilypond.BookPart'>, <class 'ly.lex.lilypond.Score'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.Paper'>, <class 'ly.lex.lilypond.Header'>, <class 'ly.lex.lilypond.Layout'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.Partial'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>, <class 'ly.lex.lilypond.Name'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.DecimalValue'>)

   pattern = re.compile('(?P<g_0>\\})|(?P<g_1>\\\\book\\b)|(?P<g_2>\\\\bookpart\\b)|(?P<g_3>\\\\score\\b)|(?P<g_4>\\\\markup(?![_-]?[^\\W\\d]))|(?P<g_5>\\\\markuplines(?![_-]?[^\\W\\d]))|(?P<g_6>\\\\markuplist(?![_-]?[^\\W\\, re.MULTILINE)

class ly.lex.texinfo.ParseLilyPondBlockAttr(argcount=None)

   Bases: "ly.lex.Parser"

   items = (<class 'ly.lex.texinfo.LilyPondAttrStart'>, <class 'ly.lex.texinfo.LilyPondBlockStartBrace'>)

   pattern = re.compile('(?P<g_0>\\[)|(?P<g_1>\\{)', re.MULTILINE)

class ly.lex.texinfo.ParseLilyPondEnv(argcount=None)

   Bases: "ly.lex.lilypond.ParseGlobal"

   items = (<class 'ly.lex.texinfo.LilyPondEnvEnd'>, <class 'ly.lex.lilypond.Book'>, <class 'ly.lex.lilypond.BookPart'>, <class 'ly.lex.lilypond.Score'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.Paper'>, <class 'ly.lex.lilypond.Header'>, <class 'ly.lex.lilypond.Layout'>, <class 'ly.lex._token.Space'>, <class 'ly.lex.lilypond.BlockCommentStart'>, <class 'ly.lex.lilypond.LineComment'>, <class 'ly.lex.lilypond.SchemeStart'>, <class 'ly.lex.lilypond.StringQuotedStart'>, <class 'ly.lex.lilypond.SequentialStart'>, <class 'ly.lex.lilypond.SimultaneousStart'>, <class 'ly.lex.lilypond.Repeat'>, <class 'ly.lex.lilypond.PitchCommand'>, <class 'ly.lex.lilypond.Override'>, <class 'ly.lex.lilypond.Revert'>, <class 'ly.lex.lilypond.Set'>, <class 'ly.lex.lilypond.Unset'>, <class 'ly.lex.lilypond.Hide'>, <class 'ly.lex.lilypond.Omit'>, <class 'ly.lex.lilypond.Tweak'>, <class 'ly.lex.lilypond.New'>, <class 'ly.lex.lilypond.Context'>, <class 'ly.lex.lilypond.Change'>, <class 'ly.lex.lilypond.With'>, <class 'ly.lex.lilypond.Clef'>, <class 'ly.lex.lilypond.Tempo'>, <class 'ly.lex.lilypond.Partial'>, <class 'ly.lex.lilypond.KeySignatureMode'>, <class 'ly.lex.lilypond.AccidentalStyle'>, <class 'ly.lex.lilypond.AlterBroken'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.ChordMode'>, <class 'ly.lex.lilypond.DrumMode'>, <class 'ly.lex.lilypond.FigureMode'>, <class 'ly.lex.lilypond.LyricMode'>, <class 'ly.lex.lilypond.NoteMode'>, <class 'ly.lex.lilypond.MarkupStart'>, <class 'ly.lex.lilypond.MarkupLines'>, <class 'ly.lex.lilypond.MarkupList'>, <class 'ly.lex.lilypond.ArticulationCommand'>, <class 'ly.lex.lilypond.Keyword'>, <class 'ly.lex.lilypond.Command'>, <class 'ly.lex.lilypond.SimultaneousOrSequentialCommand'>, <class 'ly.lex.lilypond.UserCommand'>, <class 'ly.lex.lilypond.Name'>, <class 'ly.lex.lilypond.DotPath'>, <class 'ly.lex.lilypond.EqualSign'>, <class 'ly.lex.lilypond.Fraction'>, <class 'ly.lex.lilypond.DecimalValue'>)

   pattern = re.compile('(?P<g_0>@end\\s+lilypond\\b)|(?P<g_1>\\\\book\\b)|(?P<g_2>\\\\bookpart\\b)|(?P<g_3>\\\\score\\b)|(?P<g_4>\\\\markup(?![_-]?[^\\W\\d]))|(?P<g_5>\\\\markuplines(?![_-]?[^\\W\\d]))|(?P<g_6>\\\\markuplis, re.MULTILINE)

class ly.lex.texinfo.ParseLilyPondEnvAttr(argcount=None)

   Bases: "ly.lex.FallthroughParser"

   fallthrough(state)

      Called when no match is returned by parse().

      This implementation leaves the current parser and returns None
      (causing the State to continue parsing).

   items = (<class 'ly.lex.texinfo.LilyPondAttrStart'>,)

   pattern = re.compile('(?P<g_0>\\[)', re.MULTILINE)

class ly.lex.texinfo.ParseLilyPondFile(argcount=None)

   Bases: "ly.lex.Parser"

   items = (<class 'ly.lex.texinfo.LilyPondAttrStart'>, <class 'ly.lex.texinfo.LilyPondFileStartBrace'>)

   pattern = re.compile('(?P<g_0>\\[)|(?P<g_1>\\{)', re.MULTILINE)

class ly.lex.texinfo.ParseTexinfo(argcount=None)

   Bases: "ly.lex.Parser"

   items = (<class 'ly.lex.texinfo.LineComment'>, <class 'ly.lex.texinfo.BlockCommentStart'>, <class 'ly.lex.texinfo.Accent'>, <class 'ly.lex.texinfo.EscapeChar'>, <class 'ly.lex.texinfo.LilyPondBlockStart'>, <class 'ly.lex.texinfo.LilyPondEnvStart'>, <class 'ly.lex.texinfo.LilyPondFileStart'>, <class 'ly.lex.texinfo.BlockStart'>, <class 'ly.lex.texinfo.VerbatimStart'>, <class 'ly.lex.texinfo.Keyword'>)

   mode = 'texinfo'

   pattern = re.compile('(?P<g_0>@c\\b.*$)|(?P<g_1>@ignore\\b)|(?P<g_2>@[\'"\',=^`~](\\{[a-zA-Z]\\}|[a-zA-Z]\\b))|(?P<g_3>@[@{}])|(?P<g_4>@lilypond(?=(\\[[a-zA-Z,=0-9\\\\\\s]+\\])?\\{))|(?P<g_5>@lilypond\\b)|(?P<g_6>@lilypon, re.MULTILINE)

class ly.lex.texinfo.ParseVerbatim(argcount=None)

   Bases: "ly.lex.Parser"

   default

      alias of "Verbatim"

   items = (<class 'ly.lex.texinfo.VerbatimEnd'>,)

   pattern = re.compile('(?P<g_0>@end\\s+verbatim\\b)', re.MULTILINE)

class ly.lex.texinfo.Verbatim

   Bases: "ly.lex._token.Token"

   end

   pos

class ly.lex.texinfo.VerbatimEnd

   Bases: "ly.lex.texinfo.Keyword", "ly.lex._token.Leaver"

   end

   pos

   rx = '@end\\s+verbatim\\b'

class ly.lex.texinfo.VerbatimStart

   Bases: "ly.lex.texinfo.Keyword"

   end

   pos

   rx = '@verbatim\\b'

   update_state(state)

      Lets the token update the state, e.g. enter a different parser.

      This method is called by the State upon instantiation of the
      tokens.

      Don't use it later on to have a State follow already
      instantiated Tokens because the FallthroughParser type can also
      change the state without generating a Token. Use State.follow()
      to have a State follow instantiated Tokens.

      The default implementation lets the Parser decide on state
      change.
