view release on metacpan or  search on metacpan

lib/LaTeXML/Package/TeX.pool.ltxml  view on Meta::CPAN

    EndSemiverbatim();
    return $arg; },
  beforeDigest => sub {
    $_[0]->bgroup;
    MergeFont(family => 'typewriter'); },
  afterDigest => sub {
    $_[0]->egroup; },
  reversion => sub { (T_BEGIN, Revert($_[0]), T_END); });

# Read Verbatim, but allows expanding command sequences
DefParameterType('HyperVerbatim', sub {
    my ($gullet) = @_;
    $gullet->readUntil(T_BEGIN);
    StartSemiverbatim('%');
    DefMacroI('\%',              undef, T_OTHER('%'), scope => 'local');
    DefMacroI('\#',              undef, T_OTHER('#'), scope => 'local');
    DefMacroI('\&',              undef, T_OTHER('&'), scope => 'local');
    DefMacroI('\textunderscore', undef, T_OTHER('_'), scope => 'local');
    Let('\_', '\textunderscore');
    DefMacroI('\hyper@tilde', undef, T_OTHER('~'), scope => 'local');
    Let('\~',              '\hyper@tilde');
    Let('\textasciitilde', '\hyper@tilde');
    Let('\\\\',            '\@backslashchar');
    my $arg = $gullet->readBalanced(1);
    EndSemiverbatim();
    return $arg; },
  beforeDigest => sub {
    $_[0]->bgroup;
    MergeFont(family => 'typewriter'); },
  afterDigest => sub {
    $_[0]->egroup; },
  reversion => sub { (T_BEGIN, Revert($_[0]), T_END); });

# Read an argument that will not be digested.
DefParameterType('Undigested', sub { $_[0]->readArg; }, undigested => 1,
  reversion => sub { (T_BEGIN, Revert($_[0]), T_END); });

# Read a LaTeX-style optional argument (ie. in []), but it will not be digested.
DefParameterType('OptionalUndigested', sub { $_[0]->readOptional; },
  undigested => 1, optional => 1,
  reversion  => sub { ($_[0] ? (T_OTHER('['), Revert($_[0]), T_OTHER(']')) : ()); });

# Read a keyword value (KeyVals), that will not be digested.
DefParameterType('UndigestedKey', sub { $_[0]->readArg; }, undigested => 1);
DefParameterType('UndigestedDefKey', sub {
    $_[0]->readArg->packParameters; }, undigested => 1);

# Read a token as used when defining it, ie. it may be enclosed in braces.
DefParameterType('DefToken', sub {
    my ($gullet) = @_;
    my $token = $gullet->readToken;
    while ($token && ($token->getCatcode == CC_BEGIN)) {
      my $cc;
      my @toks = grep { ($cc = $$_[1]) && ($cc != CC_SPACE) && ($cc != CC_COMMENT); }
        $gullet->readBalanced->unlist;
      $token = shift(@toks);
      $gullet->unread(@toks); }
    $token; },
  undigested => 1);

# Stub register for misdefinitions, to avoid a cascade of Errors.
DefRegisterI('\lx@DUMMY@REGISTER', undef, Tokens());

# Read a variable, ie. a token (after expansion) that is a writable register.
DefParameterType('Variable', sub {
    my ($gullet) = @_;
    my $token    = $gullet->readXToken;
    my $defn     = $token && LookupDefinition($token);
    if ((defined $defn) && $defn->isRegister && !$defn->isReadonly) {
      [$defn, ($$defn{parameters} ? $$defn{parameters}->readArguments($gullet) : ())]; }
    else {
      DefRegisterI($token, undef, Dimension(0));    # Don't really know what KIND of variable!
      if ($token && ($token->getCatcode == CC_CS)) {
        Error('expected', '<variable>', $gullet,
          "A <variable> was supposed to be here", "Got " . Stringify($token),
          "Defining it now.");
        DefRegisterI($token, undef, Dimension(0));    # Dimension, or what?
        return [LookupDefinition($token)]; }
      else {
        Error('expected', '<variable>', $gullet,
          "A <variable> was supposed to be here", "Got " . Stringify($token),
          "But it is not even definable.");
        return [LookupDefinition(T_CS('\lx@DUMMY@REGISTER'))]; } } },
  reversion => sub {
    my ($var) = @_;
    my ($defn, @args) = @$var;
    my $params = $defn->getParameters;
    return Tokens($defn->getCS, ($params ? $params->revertArguments(@args) : ())); });

# Same, but not necessarily writable
DefParameterType('Register', sub {
    my ($gullet) = @_;
    my $token    = $gullet->readXToken;
    my $defn     = $token && LookupDefinition($token);
    if ((defined $defn) && $defn->isRegister) {
      [$defn, ($$defn{parameters} ? $$defn{parameters}->readArguments($gullet) : ())]; }
    else {
      if ($token && ($token->getCatcode == CC_CS)) {
        if ($token->getString eq '\font') {
          # \font is a bit of a register-like exception
          return [$defn]; }
        Error('expected', '<register>', $gullet,
          "A <register> was supposed to be here", "Got " . Stringify($token),
          "Defining it now.");
        DefRegisterI($token, undef, Dimension(0));    # Dimension, or what?
        return [LookupDefinition($token)]; }
      else {
        Error('expected', '<register>', $gullet,
          "A <register> was supposed to be here", "Got " . Stringify($token),
          "But it is not even definable.");
        return [LookupDefinition(T_CS('\lx@DUMMY@REGISTER'))]; } } },
  reversion => sub {
    my ($var) = @_;
    my ($defn, @args) = @$var;
    my $params = $defn->getParameters;
    return Tokens($defn->getCS, ($params ? $params->revertArguments(@args) : ())); });

DefParameterType('TeXFileName', sub {
    my ($gullet) = @_;
    my ($token, $cc, @tokens) = ();
    $gullet->skipSpaces;