Provided by: latexml_0.8.3-3_all bug

NAME

       "LaTeXML::Core::Stomach" - digests tokens into boxes, lists, etc.

DESCRIPTION

       "LaTeXML::Core::Stomach" digests tokens read from a LaTeXML::Core::Gullet (they will have
       already been expanded).

       It extends LaTeXML::Common::Object.

       There are basically four cases when digesting a LaTeXML::Core::Token:

       A plain character
           is simply converted to a LaTeXML::Core::Box recording the current
           LaTeXML::Common::Font.

       A primitive
           If a control sequence represents LaTeXML::Core::Definition::Primitive, the primitive
           is invoked, executing its stored subroutine.  This is typically done for side effect
           (changing the state in the LaTeXML::Core::State), although they may also contribute
           digested material.  As with macros, any arguments to the primitive are read from the
           LaTeXML::Core::Gullet.

       Grouping (or environment bodies)
           are collected into a LaTeXML::Core::List.

       Constructors
           A special class of control sequence, called a LaTeXML::Core::Definition::Constructor
           produces a LaTeXML::Core::Whatsit which remembers the control sequence and arguments
           that created it, and defines its own translation into "XML" elements, attributes and
           data.  Arguments to a constructor are read from the gullet and also digested.

   Digestion
       "$list = $stomach->digestNextBody;"
           Return the digested LaTeXML::Core::List after reading and digesting a `body' from the
           its Gullet.  The body extends until the current level of boxing or environment is
           closed.

       "$list = $stomach->digest($tokens);"
           Return the LaTeXML::Core::List resuting from digesting the given tokens.  This is
           typically used to digest arguments to primitives or constructors.

       "@boxes = $stomach->invokeToken($token);"
           Invoke the given (expanded) token.  If it corresponds to a Primitive or Constructor,
           the definition will be invoked, reading any needed arguments fromt he current input
           source.  Otherwise, the token will be digested.  A List of Box's, Lists, Whatsit's is
           returned.

       "@boxes = $stomach->regurgitate;"
           Removes and returns a list of the boxes already digested at the current level.  This
           peculiar beast is used by things like \choose (which is a Primitive in TeX, but a
           Constructor in LaTeXML).

   Grouping
       "$stomach->bgroup;"
           Begin a new level of binding by pushing a new stack frame, and a new level of boxing
           the digested output.

       "$stomach->egroup;"
           End a level of binding by popping the last stack frame, undoing whatever bindings
           appeared there, and also decrementing the level of boxing.

       "$stomach->begingroup;"
           Begin a new level of binding by pushing a new stack frame.

       "$stomach->endgroup;"
           End a level of binding by popping the last stack frame, undoing whatever bindings
           appeared there.

   Modes
       "$stomach->beginMode($mode);"
           Begin processing in $mode; one of 'text', 'display-math' or 'inline-math'.  This also
           begins a new level of grouping and switches to a font appropriate for the mode.

       "$stomach->endMode($mode);"
           End processing in $mode; an error is signalled if $stomach is not currently in $mode.
           This also ends a level of grouping.

AUTHOR

       Bruce Miller <bruce.miller@nist.gov>

COPYRIGHT

       Public domain software, produced as part of work done by the United States Government &
       not subject to copyright in the US.