diff options
Diffstat (limited to 'Master/texmf-dist/source/latex/babel')
| -rw-r--r-- | Master/texmf-dist/source/latex/babel/babel.dtx | 7306 | ||||
| -rw-r--r-- | Master/texmf-dist/source/latex/babel/babel.ins | 288 | ||||
| -rw-r--r-- | Master/texmf-dist/source/latex/babel/bbcompat.dtx | 272 | ||||
| -rw-r--r-- | Master/texmf-dist/source/latex/babel/bbidxglo.dtx | 124 | ||||
| -rw-r--r-- | Master/texmf-dist/source/latex/babel/bbplain.dtx | 728 | ||||
| -rw-r--r-- | Master/texmf-dist/source/latex/babel/bbunicode.dtx | 180 |
6 files changed, 8898 insertions, 0 deletions
diff --git a/Master/texmf-dist/source/latex/babel/babel.dtx b/Master/texmf-dist/source/latex/babel/babel.dtx new file mode 100644 index 00000000000..ccb3254716c --- /dev/null +++ b/Master/texmf-dist/source/latex/babel/babel.dtx @@ -0,0 +1,7306 @@ +% \iffalse meta-comment +% +% Copyright 2012-2013 Javier Bezos and Johannes L. Braams. +% Copyright 1989-2012 Johannes L. Braams and any individual authors +% listed elsewhere in this file. +% All rights reserved. +% +% This file is part of the Babel system. +% -------------------------------------- +% +% It may be distributed and/or modified under the +% conditions of the LaTeX Project Public License, either version 1.3 +% of this license or (at your option) any later version. +% The latest version of this license is in +% http://www.latex-project.org/lppl.txt +% and version 1.3 or later is part of all distributions of LaTeX +% version 2003/12/01 or later. +% +% This work has the LPPL maintenance status "maintained". +% +% The Current Maintainer of this work is Javier Bezos. +% +% The list of all files belonging to the Babel system is +% given in the file `manifest.bbl. See also `legal.bbl' for additional +% information. +% +% The list of derived (unpacked) files belonging to the distribution +% and covered by LPPL is defined by the unpacking scripts (with +% extension .ins) which are part of the distribution. +% \fi +% \CheckSum{5011} +% +% \def\filename{babel.dtx} +% \let\thisfilename\filename +% +%\iffalse +% \changes{babel~3.5g}{1996/10/10}{We need at least \LaTeX\ from +% December 1994} +% \changes{babel~3.6k}{1999/03/18}{We need at least \LaTeX\ from +% June 1998} +% \begin{macrocode} +%<package>\NeedsTeXFormat{LaTeX2e}[2005/12/01] +% \end{macrocode} +% +%% File 'babel.dtx' +%\fi +%%\ProvidesFile{babel.dtx}[2013/04/15 v3.9e The Babel package] +%\iffalse +% +% Babel DOCUMENT-STYLE option for LaTeX version 2.09 or plain TeX; +%% Babel package for LaTeX2e. +% +%% Copyright (C) 1989 -- 2008 by Johannes Braams, +%% TeXniek +%% all rights reserved. +%% Copyright (C) 2013 by Johannes Braams +%% TeXniek +%% by Javier Bezos +%% all rights reserved. +% +%<*filedriver> +\documentclass{ltxdoc} +\raggedright +\addtolength{\textwidth}{25pt} +\font\manual=logo10 % font used for the METAFONT logo, etc. +\newcommand*\MF{{\manual META}\-{\manual FONT}} +\newcommand*\babel{\textsf{babel}} +\newcommand*\Babel{\textsf{Babel}} +\newcommand*\xetex{\textsf{xetex}} +\newcommand*\luatex{\textsf{luatex}} +\newcommand*\nb[1]{} +\newcommand*\m[1]{\mbox{$\langle$\normalfont\itshape#1\/$\rangle$}} +\newcommand*\langlist{% + \meta{language}\texttt{,}\meta{language}\texttt{,}...} +\newcommand*\langvar{\m{lang}} +\newcommand*\note[1]{} +\newcommand*\bsl{\protect\bslash} +\newcommand*\Lopt[1]{\textsf{#1}} +\newcommand*\Lenv[1]{\textsf{#1}} +\newcommand*\menv[1]{\char`\{#1\char`\}} +\newcommand*\Eenv[1]{% + \quad\ldots\quad + \texttt{\color{thered}\string\end\menv{#1}}} +\newcommand*\file[1]{\texttt{#1}} +\newcommand*\cls[1]{\texttt{#1}} +\newcommand*\pkg[1]{\texttt{#1}} +\addtolength{\oddsidemargin}{1em} +\lefthyphenmin=2 +\righthyphenmin=3 +% Stolen and adapted from microtype: +\usepackage{color} +\definecolor{thered} {rgb}{0.65,0.04,0.07} +\definecolor{thegreen}{rgb}{0.06,0.44,0.08} +\definecolor{thegrey} {gray}{0.8} +\definecolor{theshade}{rgb}{1,1,0.97} +\definecolor{theframe}{gray}{0.6} +\definecolor{lightgray}{gray}{0.95} +\IfFileExists{listings.sty}{ + \usepackage{listings} + \lstset{ + % gobble=1, + columns=flexible, + keepspaces, + basicstyle=\MacroFont, + keywords=[0]{\selectlanguage,\foreignlanguage,\defineshorthand, + \babelhyphen,\babelhyphenation,\spanishhyphenmins,\addto, + \StartBabelCommands,\SetString,\EndBabelCommands,\shorthandoff, + \languageshorthands,\useshorthands,\AddBabelHook,\SetStringLoop, + \SetCase,\AfterBabelLanguage}, + keywordstyle=[0]\color{thered}, + keywords=[1]{ngerman,italian,dutch,english,main,esperanto, + frenchb,shorthands,extrasfrench,extrasrussian,extrasenglish, + stringprocess,afterextras,latin,medieval,spanish,notilde, + lcroman,danish}, + keywordstyle=[1]\color{thegreen}, + comment=[l]\%, + commentstyle=\color{thegrey}\itshape, + alsoother={0123456789_}, + frame=single, + backgroundcolor=\color{theshade}, + rulecolor=\color{theframe}, + framerule=\fboxrule, + } + \let\verbatim\relax + \lstnewenvironment{verbatim}[1][]{\lstset{##1}}{} +}{} +\def\PrintDescribeMacro#1{% + \strut\MacroFont\color{thered}\normalsize\string#1} +\def\Describe#1{% + \par\penalty-500\vskip3ex\noindent + \DescribeMacro{#1}\args} +\def\DescribeOther{\vskip-4ex\Describe} +\makeatletter +\def\args#1{% + \def\bbl@tempa{#1}% + \ifx\bbl@tempa\@empty\else#1\vskip1ex\fi\ignorespaces} +\makeatother +\begin{document} +\title{Babel, a multilingual package for use with \LaTeX's standard + document classes\thanks{During the development ideas from Nico + Poppelier, Piet van Oostrum and many others have been used. + Bernd Raichle has provided many helpful suggestions.}} +\author{Johannes Braams\\ + Kersengaarde 33\\ + 2723 BP Zoetermeer\\ + The Netherlands\\ + \normalsize For version 3.9, Javier Bezos\\ + \normalsize \texttt{www.tex-tipografia.com}} + +\date{Typeset \today} + +\maketitle + +\begin{abstract} + The standard distribution of \LaTeX\ contains a number of document + classes that are meant to be used, but also serve as examples for + other users to create their own document classes. These document + classes have become very popular among \LaTeX\ users. But it should + be kept in mind that they were designed for American tastes and + typography. At one time they even contained a number of hard-wired + texts. + + This report describes \babel{}, a package that makes use of the + capabilities of \TeX\ version 3 and, to some extent, \xetex{} and + \luatex, to provide an environment in which documents can be typeset + in a language other than US English, or in more than one language. + However, no attempt has been done to take full advantage of the + features provided by the latter, which would require a completely + new core (as for example \file{polyglossia} or as part of \LaTeX3). +\end{abstract} + +\tableofcontents + +\section{The user interface}\label{U-I} + +The user interface of this package is quite simple. It consists of a +set of commands that switch from one language to another, and a set of +commands that deal with shorthands. It is also possible to find out +what the current language is. + +In \LaTeX2e\ the preamble of the document: +\begin{verbatim} +\documentclass{article} +\usepackage[dutch,english]{babel} +\end{verbatim} +would tell \LaTeX\ that the document would be written in two +languages, Dutch and English, and that English would be the first +language in use, and the main one. You can also set the main language +explicitly: +\begin{verbatim} +\documentclass{article} +\usepackage[main=english,dutch]{babel} +\end{verbatim} +Another approach is making \Lopt{dutch} and \Lopt{english} global +options in order to let other packages detect and use them: + +\begin{verbatim} +\documentclass[dutch,english]{article} +\usepackage{babel} +\usepackage{varioref} +\end{verbatim} + +In this last example, the package \texttt{varioref} will also see +the options and will be able to use them. + +Languages may be set as global and as package option at the same +time, but in such a case you should set explicitly the main language +with the package option |main|: +\begin{verbatim} +\documentclass[italian]{babel} +\usepackage[ngerman,main=italian]{babel} +\end{verbatim} + +\fbox{New 3.9c} The basic behaviour of some languages can be modified +when loading \babel. Modifiers are set after the language name, and +are prefixed with a dot (only when the language is set as package +option -- neither global options nor the |main| key accept them). An +example is (spaces are not significant and it can be written closed, +too): +\begin{verbatim} +\usepackage[latin .medieval, spanish .notilde .lcroman, danish]{babel} +\end{verbatim} + +Attributes (described below) are considered modifiers, ie, you can +set an attribute by including it in the modifiers list. However, +modifiers is a more general mechanism. + +Currently \babel{} provides no standard interface for +scripts. Languages sharing the same non-Latin script may define macros +to switch them (eg, |\textcyrillic|), but be aware they may also set +the language to a certain default. (Future versions might add such an +interface.) + +Because of the way \babel{} has evolved, ``language'' can refer to (1) +a set of hyphenation patters as preloaded into the format, (2) a +package option, (3) an |ldf| file, and (4) a name used in the document +to select a language or dialect. So, a package option refers to a +language in a generic way -- sometimes it is the actual language name +used to select it, sometimes it is a file name loading a language with +a different name, sometimes it is a file name loading several +languages. Please, read the documentation for specific languages for +further info. + +Loading directly |sty| files in \LaTeX{} (ie, +|\usepackage|\marg{language}) is deprected and you will get the error +``You have used an old interface to call babel''. + +In Plain, load languages styles with |\input| and then use +|\begindocument| (the latter is defined by \babel): +\begin{verbatim} +\input estonian.sty +\begindocument +\end{verbatim} +Note not all languages provide a |sty| file and some of them are +not compatible with Plain. + +\subsection{Selecting languages} + +The main language is selected automatically when the |document| +environment begins. + +\Describe\selectlanguage{\marg{language}} +When a user wants to switch from one language to another he can +do so using the macro |\selectlanguage|. This macro takes the +language, defined previously by a language definition file, as +its argument. It calls several macros that should be defined in +the language definition files to activate the special definitions +for the language chosen. + +If used inside braces there might be some non-local changes, as this +would be roughly equivalent to: +\begin{verbatim} +{\selectlanguage{<inner-language>} ...}\selectlanguage{<outer-language>} +\end{verbatim} +If you want a change which is really local, you must enclose this +code with an additional grouping, like braces |{}|. + +This command can be used as environment, too. + +\Describe{\begin\menv{otherlanguage}}{\marg{language}\Eenv{otherlanguage}} + +The environment \Lenv{otherlanguage} does basically the same as +|\selectlanguage|, except the language change is (mostly) local to the +environment. This environment is required for intermixing +left-to-right typesetting with right-to-left typesetting. +The language to switch to is specified as an +argument to |\begin{otherlanguage}|. + +Actually, there might be some non-local changes, as this environment +is roughly equivalent to: +\begin{verbatim} +\begingroup +\selectlanguage{<inner-language>} +... +\endgroup +\selectlanguage{<outer-language>} +\end{verbatim} +If you want a change which is really local, you must enclose this +environment with and additional grouping, like braces |{}|. + +Spaces after the environment are ignored. + +\Describe\foreignlanguage{\oarg{language}\marg{text}} +The command |\foreignlanguage| takes two arguments; the second +argument is a phrase to be typeset according to the rules of the +language named in its first argument. This command (1) only +switches the extra definitions and the hyphenation rules for the +language, \emph{not} the names and dates, (2) does not send +information about the language to auxiliary files (i.e., the +surrounding language is still in force), and (3) it works even if +the language has not been set as package option (but in such a +case it only sets the hyphenation patterns). + +\Describe{\begin\menv{otherlanguage*}}% +{\marg{language}\Eenv{otherlanguage*}} + +Same as |\foreignlanguage| but as environment. Spaces after the +environment are \textit{not} ignored. + +\Describe\languagename{} +The control sequence |\languagename| contains the name of the +current language. However, due to some internal inconsistencies in +catcodes it should \textit{not} be used to test its value (use +\textsf{iflang}, by Heiko Oberdiek). + +\Describe\iflanguage{\marg{language}\marg{true}\marg{false}} + +If more than one language is used, it might be necessary to know which +language is active at a specific time. This can be checked by a call +to |\iflanguage|, but note here ``language'' is used in the \TeX\ +sense, as a set of hyphenation patterns, and \textit{not} as its +\textsf{babel} name. This macro takes three arguments. The first +argument is the name of a language; the second and third arguments are +the actions to take if the result of the test is true or false +respectively. The advice about |\languagename| also applies here -- +use \textsf{iflang} instead of |\iflanguage| if possible. + +\Describe{\begin\menv{hyphenrules}}{\marg{language}\Eenv{hyphenrules}} + +The environment \Lenv{hyphenrules} can be used to select \emph{only} +the hyphenation rules to be used (it can be used as command, +too). This can for instance be used to select `nohyphenation', +provided that in \file{language.dat} the `language' +\textsf{nohyphenation} is defined by loading \file{zerohyph.tex}. It +deactivates language shorthands, too (but not user shorthands). + +Except for these simple uses, |hyphenrules| is discouraged and +|otherlanguage*| (the starred version) is preferred, as the former +does not take into account possible changes in encodings or characters +like, say, |'| done by some languages (eg, \textsf{italian}, +\textsf{frenchb}, \textsf{ukraineb}). To set hyphenation exceptions, +use |\babelhyphenation| (see below). + +\subsection{Shorthands} + +A \textit{shorthand} is a sequence of one or two characters that +expands to arbitrary \TeX{} code. + +Shorthands can be used for different kinds of things, as for example: +(1) in some languages shorthands such as |"a| are defined to be able +to hyphenate the word if the encoding is OT1; (2) in some languages +shorthands such as |!| are used to insert the right amount of white +space; (3) several kinds of discretionaries and breaks can be inserted +easily with |"-|, |"=|, etc. + +The package \textsf{inputenc} as well as \xetex{} an \luatex{} have +alleviated entering non-ASCII characters, but minority languages and +some texts can still require characters not directly available in the +keyboards (and sometimes not even as separated or precomposed Unicode +characters). As to the point 2, now \textsf{pdfTeX} provides +|\knbccode|. Tools of point 3 can be still very useful in general. + +There are three levels of shorthands: \textit{user}, +\textit{language}, and \textit{system} (by order of +precedence). Version 3.9 introduces the \textit{language user} +level on top of the user level, as described below. In most +cases, you will use only shorthands provided by languages. + +Please, note the following: +\begin{enumerate} +\item Activated chars used for two-char shorthands cannot be + followed by a closing brace |}| and the spaces following are + gobbled. With one-char shorthands (eg, |:|), they are preserved. +\item If on a certain level (system, language, user) there is a + one-char shorthand, two-char ones starting with that + char and on the same level are ignored. +\end{enumerate} + +\Describe{\shorthandon}{\marg{shorthands-list}} +\DescribeOther{\shorthandoff}{% +\colorbox{thegrey}{\ttfamily\hskip-.2em*\hskip-.2em}% +\marg{shorthands-list}} +It is sometimes necessary to switch a shorthand +character off temporarily, because it must be used in an +entirely different way. For this purpose, the user commands +|\shorthandoff| and |\shorthandon| are provided. They each take a +list of characters as their arguments. + +The command |\shorthandoff| sets the |\catcode| for each of the +characters in its argument to other (12); the command |\shorthandon| +sets the |\catcode| to active (13). Both commands only work on `known' +shorthand characters. If a character is not known to be a shorthand +character its category code will be left unchanged. + +\fbox{New 3.9} Note however, |\shorthandoff| does not behave as +you would expect with characters like |~| or |^|, because they +usually are not ``other''. For them |\shorthandoff*| is provided, +so that with +\begin{verbatim} +\shorthandoff*{~^} +\end{verbatim} +|~| is still active, very likely with the meaning of a non-breaking +space, and |^| is the superscript character. The catcodes used are +those when the shorthands are defined, usually when language files are +loaded. + +\Describe{\useshorthands}{% +\colorbox{thegrey}{\ttfamily\hskip-.2em*\hskip-.2em}% +\marg{char}} + +The command |\useshorthands| initiates the definition of user-defined +shorthand sequences. It has one argument, the character that starts +these personal shorthands. + +\fbox{New 3.9} However, user shorthands are not always alive, as they +may be deactivated by languages (for example, if you use |"| for your +user shorthands and switch from \textsf{german} to \textsf{french}, +they stop working). Therefore, a starred version +|\useshorthands*|\marg{char} is provided, which makes sure shorthands +are always activated. + +Currently, if the option |shorthands| is used, you must include any +character to be activated with |\useshorthands|. This restriction will +be lifted in a future release. + +\Describe\defineshorthand{\texttt{[}\langlist\texttt{]}%^^A + \marg{shorthand}\marg{code}} + +The command |\defineshorthand| takes two arguments: the first is +a one- or two-character shorthand sequence, and the second is the +code the shorthand should expand to. + +\fbox{New 3.9} An optional argument allows to (re)define language +and system shorthands (some languages do not activate shorthands, +so you may want to add |\languageshorthands|\marg{lang} to the +corresponding |\extras|\m{lang}). By default, user shorthands are +(re)defined. + +User shorthands override language ones, which in turn override +system shorthands. Language-dependent user shorthands (new in +3.9) take precedence over ``normal'' user shorthands. + +As an example of their applications, let's assume you want a +unified set of shorthand for discretionaries (languages do not +define shorthands consistently, and |"-|, |\-|, |"=| have +different meanings). You could start with, say: +\begin{verbatim} +\useshorthands*{"} +\defineshorthand{"*}{\babelhyphen{soft}} +\defineshorthand{"-}{\babelhyphen{hard}} +\end{verbatim} +However, behaviour of hyphens is language dependent. For example, in +languages like Polish and Portugese, a hard hyphen inside compound +words are repeated at the beginning of the next line. You could set: +\begin{verbatim} +\defineshorthand[*polish,*portugese]{"-}{\babelhyphen{repeat}} +\end{verbatim} +Here, options with |*| set a language-dependent user shorthand, which +means the generic one above only applies for the rest of languages; +without |*| they would (re)define the language shorthands instead, +which are overriden by user ones. + +Now, you have a single unified shorthand (|"-|), with a content-based +meaning (`compound word hyphen') whose visual behavior is that +expected in each context. + +\Describe\aliasshorthand{\marg{original}\marg{alias}} + +The command |\aliasshorthand| can be used to let another +character perform the same functions as the default shorthand +character. If one prefers for example to use the character |/| +over |"| in typing Polish texts, this can be achieved by entering +|\aliasshorthand{"}{/}|. \emph{Please note} the substitute +character must \textit{not} have been declared before as +shorthand (in such case, |\aliashorthands| is ignored). + +The following example shows how to replace a shorthand by another +\begin{verbatim} +\aliasshorthand{~}{^} +\AtBeginDocument{\shorthandoff*{~}} +\end{verbatim} +However, shorthands remember somehow the original character, and the +fallback value is that of the latter. So, in this example, if no +shorthand if found, |^| expands to a non-breaking space, because this +is the value of |~| (internally, |^| calls |\active@char~| or +|\normal@char~|). Furthermore, if you change the |system| value of |^| +with |\defineshorthand| nothing happens. + +\Describe\languageshorthands{\marg{language}} The command +|\languageshorthands| can be used to switch the shorthands on the +language level. It takes one argument, the name of a language or +|none| (the latter does what its name suggests).\footnote{Actually, +any name not corresponding to a language group does the same as +\texttt{none}. However, follow this convention because it might be +enforced in future releases of \babel{} to catch possible errors.} +Note that for this to work the language should have been specified as +an option when loading the \babel\ package. For example, you can use +in \textsf{english} the shorthands defined by \textsf{ngerman} with +\begin{verbatim} +\addto\extrasenglish{\languageshorthands{ngerman}} +\end{verbatim} + +Very often, this is a more convenient way to deactivate shorthands +than |\shorthandoff|, as for example if you want to define a macro +to easy typing phonetic characters with \textsf{tipa}: +\begin{verbatim} +\newcommand{\myipa}[1]{{\languageshorthands{none}\tipaencoding#1}} +\end{verbatim} + +\Describe\babelshorthand{\marg{shorthand}} +With this command you can use shorthands even if (1) not activated in +\texttt{shorthands} (in this case only shorthands for the current +language are taken into account, ie, not user shorthands), (2) turned +off with |\shorthandoff| or (3) deactivated with |\bbl@deactivate|; +for example, \verb|\babelshorthand{"u}| or \verb|\babelshorthand{:}|. +(You can conveniently define your own macros, or even you own user +shorthands provided they do not ovelap.) + +For your records, here is a list of shorthands, but you must check +them, as they may change:\footnote{Thanks to Enrico Gregorio} + +\begin{description} +\itemsep=-\parskip +\item[Languages with no shorthands] Croatian, English (any variety), + Indonesian, Hebrew, Interlingua, Irish, Lower Sorbian, Malaysian, + North Sami, Romanian, Scottish, Welsh +\item[Languages with only \texttt{"} as defined shorthand character] + Albanian, Bulgarian, Danish, Dutch, Finnish, German (old and new + orthography, also Austrian), Icelandic, Italian, Norwegian, Polish, + Portuguese (also Brazilian), Russian, Serbian (with Latin script), + Slovene, Swedish, Ukrainian, Upper Sorbian +\item[Basque] |" ' ~| +\item[Breton] |: ; ? !| +\item[Catalan] |" ' `| +\item[Czech] |" -| +\item[Esperanto] |^| +\item[Estonian] |" ~| +\item[French] (all varieties) |: ; ? !| +\item[Galician] |" . ' ~ < >| +\item[Greek] |~| +\item[Hungarian] |`| +\item[Kurmanji] |^| +\item[Latin] |" ^ =| +\item[Slovak] |" ^ ' -| +\item[Spanish] |" . < > '| +\item[Turkish] |: ! =| +\end{description} +In addition, the \babel{} core declares |~| as a one-char shorthand +which is let, like the standard |~|, to a non breaking +space.\footnote{This declaration serves to nothing, but it is +preserved for backward compatibility.} + + +\subsection{Package options} + +\fbox{New 3.9} +These package options are processed before language options, so +that they are taken into account irrespective of its order. + +\Describe{shorthands=}{\meta{char}\meta{char}... +$\string|$ \texttt{off}} +The only language shorthands activated +are those given, like, eg: +\begin{verbatim} +\usepackage[esperanto,frenchb,shorthands=:;!?]{babel} +\end{verbatim} +If \verb|'| is included, \texttt{activeacute} is set; if \verb|`| +is included, \texttt{activegrave} is set. Active characters (like +\verb|~|) should be preceded by \verb|\string| (otherwise they +will be expanded by \LaTeX{} before they are passed to the package +and therefore they will not be recognized); however, |t| is provided +for the common case of |~| (as well as |c| for the comma). + +With |shorthands=off| no language shorthands are defined, +As some languages use this mechanism for tools not available +otherwise, a macro \verb|\babelshorthand| is defined, which allows +using them; see above. + +\Describe{safe=}{\texttt{none} $\string|$ \texttt{ref} +$\string|$ \texttt{bib}} +Some \LaTeX{} macros are redefined so that using +shorthands is safe. With \texttt{safe=bib} only |\nocite|, |\bibcite| and +|\bibitem| are redefined. With |safe=ref| only |\newlabel|, |\ref| +and |\pageref| are redefined (as well as a few macros from +\textsf{varioref} and \textsf{ifthen}). With |safe=none| no macro is +redefined. Of course, in such a case you cannot use shorthands in +these macros. + +\Describe{math=}{\texttt{active} $\string|$ \texttt{normal}} +Shorthands are mainly intended for text, not for math. By setting this +option with the value |normal| they are deactivated in math mode +(default is |active|) and things like |${a'}$| (a closing brace after +a shorthand) are not a source of trouble any more. + +\Describe{config=}{\meta{file}} Instead of loading |bblopts.cfg|, +the file \meta{file}\texttt{.cfg} is loaded. + +\Describe{main=}{\meta{language}} Sets the main language, as +explained above, ie, this language is always the last loaded. The +language may be also given as package or global option or not. + +\Describe{headfoot=}{\meta{language}} By default, headlines and footlines are +not touched (only marks), and if they contain language dependent +macros (which is not usual) there may be unexpected results. With +this option you may set the language in heads and foots. + +\Describe{noconfigs}{} Global and +language default config files are not loaded, so you can make sure +your document is not spoilt by an unexpected \texttt{.cfg} +file. The key |config| still works. + +\Describe{showlanguages}{} Prints to the log the list of languages +loaded when the format was created: number (remember dialects can +share it), name, hyphenation file and exceptions file. + +\Describe{strings=}{\texttt{generic} $\string|$ \texttt{unicode} +$\string|$ \texttt{encoded} $\string|$ \meta{label} $\string|$ \meta{font encoding}} +Selects the encoding +of strings in languages supporting this feature. Predefined labels +are |generic| (for traditional \TeX), |unicode| (for engines like +\xetex{} and \luatex) and |encoded| (for special cases requiring mixed +encodings). Other allowed values are font encoding codes (|T1|, |T2A|, +|LGR|, |L7X|...), but only in languages supporting them. + +\vspace{3ex} +(The following three options have been available in previous versions +of \babel.) + +\Describe{KeepShorthandsActive}{} +Tells babel not to deactivate shorthands after loading a language +file, so that they are also availabe in the preamble. + +\Describe{activeacute}{} For some languages \babel\ supports this +options to set |'| as a shorthand in case it is not done by default. + +\Describe{activegrave}{} +Same for |`|. + +\subsection{The \texttt{base} option} + +With this package option \babel{} just loads some basic macros (those +in |switch.def|), defines |\AfterBabelLanguage| and exits. It also +selects the hyphenations patterns for the last language passed as +option (by its name in |language.dat|). There are two main uses: +classes and packages, and as a last resort in case there are, for some +reason, incompatible languages. It can be used if you just want to +select the hyphenations patterns of a single language. + +\Describe\AfterBabelLanguage{\marg{option-name}\marg{code}} + +This command is currently the only provided by |base|. Executes +\meta{code} when the file loaded by the corresponding package option +is finished (at |\ldf@finish|). The setting is global. So +\begin{verbatim} +\AfterBabelLanguage{frenchb}{...} +\end{verbatim} +does ... at the end of |frenchb.ldf|. It can be used in |ldf| files, +too, but in such a case the code is executed only if +\meta{option-name} is the same as |\CurrentOption| (which could not +be the same as the option name as set in |\usepackage|!). + +For example, consider two languages \textsf{foo} and \textsf{bar} +defining the same |\macro| with |\newcommand|. An error is raised if +you attempt to load both. Here is a way to overcome this problem: +\begin{verbatim} +\usepackage[base]{babel} +\AfterBabelLanguage{foo}{% + \let\macroFoo\macro + \let\macro\relax} +\usepackage[foo,bar]{babel} +\end{verbatim} + +\subsection{Hooks} + +\fbox{New 3.9} A hook is code to be executed at certain events. Some +hooks are predefined when \luatex{} and \xetex{} are used. + +\Describe\AddBabelHook{\marg{name}\marg{event}\marg{code}} + +The same name can be applied to several events. Hooks may be enabled +and disabled for all defined events with +|\EnableBabelHook|\marg{name}, |\DisableBabelHook|\marg{name} + +Current events are: |adddialect|, |write|, |beforeextras|, +|afterextras|, |patterns|, |hyphenation|, |defaultcommands|, |encodedcommands|, +|stopcommands| and |stringprocess|. Four events are used in +\file{hyphen.cfg}, which are handled in a quite different way for +efficiency reasons -- these are |everylanguage|, |loadkernel|, +|loadpatterns| and |loadexceptions|, which, unlike the precedent ones, +only have a single hook and replace a default definition. (Names +containing the string |babel| are reserved; they are used, for +example, by |\useshortands*| to add a hook for the event +|afterextras|.) + +In some of them you can use one or two \TeX{} parameters (|#1|, |#2|), +with the meaning given below: +\begin{description} +\renewcommand\makelabel[1]{% + \hspace\labelsep\normalfont\ttfamily\color{thered}#1} +\itemsep=-\parskip +\item[everylanguage] (language) Executed before patterns are loaded. +\item[loadkernel] (file) By default loads |switch.def|. It can be used + to load a different version of this files or to load nothing. +\item[loadpatterns] (patterns file) Loads the patterns file. Used by + \file{luababel.def}. +\item[loadexceptions] (exceptions file) Loads the exceptions + file. Used by \file{luababel.def}. +\item[adddialect] (language name, dialect name) Used by + \file{luababel.def} to load the patterns if not preloaded. +\item[patterns] (language name, language with encoding) Executed just + after the |\language| has been set. The second argument has the + patterns name actually selected (in the form of either |lang:ENC| or + |lang|). +\item[hyphenation] (language name, language with encoding) Executed + locally just before exceptions given in |\babelhyphenation| are + actually set. +\item[defaultcommands] Used (locally) in |\StartBabelCommands|. +\item[encodedcommands] (input, font encodings) Used (locally) in + |\StartBabelCommands|. Both \xetex{} and \luatex{} make sure the + encoded text is read correctly. +\item[stopcommands] Used to reset the the above, if necessary. +\item[write] This event comes just after the switching commands are + written to the |aux| file. +\item[beforeextras] Just before executing |\extras|\m{language}. This + event and the next one should not contain language-dependent code + (for that, add it to |\extras|\m{language}). +\item[afterextras] Just after executing |\extras|\m{language}. For + example, the following deactivates shorthands in all languages: +\begin{verbatim} +\AddBabelHook{noshort}{afterextras}{\languageshorthands{none}} +\end{verbatim} +\item[stringprocess] Intead of a parameter, you can manipulate the + macro |\BabelString| containing the string to be defined with + |\SetString|. For example, to use an expanded version of the string + in the definition, write: +\begin{verbatim} +\AddBabelHook{myhook}{stringprocess}{% + \protected@edef\BabelString{\BabelString}} +\end{verbatim} +\end{description} + +\subsection{Hyphen tools} + +\Describe\babelhyphen{% + \colorbox{thegrey}{\ttfamily\hskip-.2em*\hskip-.2em}\marg{type}} +\DescribeOther\babelhyphen{% + \colorbox{thegrey}{\ttfamily\hskip-.2em*\hskip-.2em}\marg{text}} + +\fbox{New 3.9} It is customary to classify hyphens in two types: (1) +\textit{explicit} or \textit{hard hyphens}, which in \TeX\ are +entered as \verb|-|, and (2) \textit{optional} or \textit{soft +hyphens}, which are entered as \verb|\-|. Strictly, a \textit{soft +hyphen} is not a hyphen, but just a breaking oportunity or, in +\TeX\ terms, a ``discretionary''; a \textit{hard hyphen} is a hyphen +with a breaking oportunity after it. A further type is a +\textit{non-breaking hyphen}, a hyphen without a breaking +oportunity. + +In \TeX, \verb|-| and \verb|\-| forbid further breaking oportunities +in the word. This is the desired behaviour very often, but not +always, and therefore many languages provide shorthands for these +cases. Unfortunately, this has not been done consistently: for +example, in Dutch, Portugese, Catalan or Danish, \verb|"-| is a hard +hyphen, while in German, Spanish, Norwegian, Slovak or Russian, it +is a soft hyphen. Furthermore, some of them even redefine |\-|, so +that you cannot insert a soft hyphen without breaking oportunities +in the rest of the word. + +Therefore, some macros are provide with a set of basic ``hyphens'' +which can be used by themselves, to define a user shorthand, or even +in language files. +\begin{itemize} +\item |\babelhyphen{soft}| and |\babelhyphen{hard}| are self + explanatory. +\item |\babelhyphen{repeat}| inserts a hard hyphen which is repeated + at the beginning of the next line, as done in languages like + Polish, Portugese and Spanish. +\item |\babelhyphen{nobreak}| inserts a hard hyphen without a break + after it (even if a space follows). +\item |\babelhyphen{empty}| inserts a break oportunity without + a hyphen at all. +\item |\babelhyphen|\marg{text} is a hard ``hyphen'' using \m{text} + instead. A typical case is |\babelhyphen{/}|. +\end{itemize} +With all of them hyphenation in the rest of the word is enabled. If +you don't want enabling it, there is a starred counterpart: +|\babelhyphen*{soft}| (which in most cases is equivalent to the +original |\-|), |\babelhyphen*{hard}|, etc. + +Note |hard| is also good for isolated prefixes (eg, \textit{anti-}) +and |nobreak| for isolated suffixes (eg, \textit{-ism}), but in both +cases |\babelhyphen*{nobreak}| is usually better. + +There are also some differences with \LaTeX: (1) the character used is +that set for the current font, while in \LaTeX{} it is hardwired to +|-| (a typical value); (2) the hyphen to be used in fonts with a +negative |\hyphenchar| is |-|, like in \LaTeX, but it can be changed to +another value by redefining |\babelnullhyphen|; (3) a break after the +hyphen is forbidden if preceded by a glue ${>}0$~pt (at the beginning +of a word, provided it is not immediately preceded by, say, a +parenthesis). + +\Describe\babelhyphenation{\texttt{[}\langlist\texttt{]}%^^A + \marg{exceptions}} + +\fbox{New 3.9} Sets hyphenation exceptions for the languages given +or, without the optional argument, for \textit{all} languages (eg, +proper nouns or common loan words, and of course monolingual +documents). Language exceptions take precedence over global ones. + +It can be used only in the preamble, and exceptions are set when the +language is first selected, thus taking into account changes of +|\lccodes|'s done in |\extras|\m{lang} as well as the script specific +encoding (not set in the preamble by default). Multiple +|\babelhyphenation|'s are allowed. For example: +\begin{verbatim} +\babelhyphenation{Wal-hal-la Dar-bhan-ga} +\end{verbatim} + +Listed words are saved expanded and therefore it relies on the +LICR. Of course, it also works without the LICR if the input and the +font encondings are the same, like in Unicode based engines. + +\subsection{Language attributes} + +\DescribeMacro{\languageattribute} +This is a user-level command, to be used in the preamble of a +document (after |\usepackage[...]{babel}|), that declares which +attributes are to be used for a given language. It takes two +arguments: the first is the name of the language; the second, +a (list of) attribute(s) to be used. Attributes must be set in the +preamble and only once -- they cannot be turned on and off. +The command checks whether the language is known in this document +and whether the attribute(s) are known for this language. + +Several language definition files use their own methods to set +options. For example, \textsf{frenchb} uses |\frenchbsetup|, +\textsf{magyar} (1.5) uses |\magyarOptions| and \textsf{spanish} +a set of package options (eg, |es-nolayout|). Macros settting +options are also used (eg, |\ProsodicMarksOn| in \textsf{latin}). + +\subsection{Languages supported by \babel} + +In the following table most of the languages supported by \babel\ are +listed, together with the names of the options which you can load +\babel\ with for each language. Note this list is open and the +current options may be different. + +\begin{description} +\itemsep=-\parskip +\sffamily +\item[Afrikaans] afrikaans +\item[Bahasa] bahasa, indonesian, indon, bahasai, + bahasam, malay, meyalu +\item[Basque] basque +\item[Breton] breton +\item[Bulgarian] bulgarian +\item[Catalan] catalan +\item[Croatian] croatian +\item[Czech] czech +\item[Danish] danish +\item[Dutch] dutch +\item[English] english, USenglish, american, UKenglish, + british, canadian, australian, newzealand +\item[Esperanto] esperanto +\item[Estonian] estonian +\item[Finnish] finnish +\item[French] french, francais, canadien, acadian +\item[Galician] galician +\item[German] austrian, german, germanb, ngerman, naustrian +\item[Greek] greek, polutonikogreek +\item[Hebrew] hebrew +\item[Icelandic] icelandic +\item[Interlingua] interlingua +\item[Irish Gaelic] irish +\item[Italian] italian +\item[Latin] latin +\item[Lower Sorbian] lowersorbian +\item[North Sami] samin +\item[Norwegian] norsk, nynorsk +\item[Polish] polish +\item[Portuguese] portuges, portuguese, brazilian, brazil +\item[Romanian] romanian +\item[Russian] russian +\item[Scottish Gaelic] scottish +\item[Spanish] spanish +\item[Slovakian] slovak +\item[Slovenian] slovene +\item[Swedish] swedish +\item[Serbian] serbian +\item[Turkish] turkish +\item[Ukrainian] ukrainian +\item[Upper Sorbian] uppersorbian +\item[Welsh] welsh +\end{description} + +There are more languages not listed above, including \textsf{hindi, +thai, thaicjk, latvian, turkmen, magyar, mongolian, romansh, +lithuanian, spanglish, vietnamese, japanese, pinyin, arabic, farsi, +ibygreek, bgreek, serbianc, frenchle, ethiop} and \textsf{friulan}. + +Most of them work out of the box, but some may require extra fonts, +encoding files, a preprocessor or even a complete framework (like +CJK). For example, if your have the \textsf{velthuis/devnag} package, +you can create a file with extension |.dn|: +\begin{verbatim} +\documentclass{article} +\usepackage[hindi]{babel} +\begin{document} +{\dn devaanaa.m priya.h} +\end{document} +\end{verbatim} +Then you preprocess it with |devnag| \m{file}, which creates +\m{file}|.tex|; you can then typeset the latter with \LaTeX. + +\subsection{Tips, workarounds and know issues} + +\begin{itemize} +\item If you use the document class \cls{book} \emph{and} you use + |\ref| inside the argument of |\chapter| (or just use |\ref| inside + |\MakeUppercase|), \LaTeX\ will keep complaining about an undefined + label. To prevent such problems, you could revert to using + uppercase labels, you can use |\lowercase{\ref{foo}}| inside the + argument of |\chapter|, or, if you will not use shorthands in + labels, set the |safe| option to |none| or |bib|. + +\item\catcode`\|=12\relax Both \textsf{ltxdoc} and \textsf{babel} use + \verb|\AtBeginDocument| to change some catcodes, and babel reloads + \textsf{hhline} to make sure \verb|:| has the right one, so if you + want to change the catcode of \verb/|/ it has to be done using the + same method at the proper place, with +\begin{verbatim} +\AtBeginDocument{\DeleteShortVerb{\|}} +\end{verbatim} + \textit{before} loading babel. This way, when the document begins + the sequence is (1) make \verb/|/ active (\textsf{ltxdoc}); (2) make + it unactive (your settings); (3) make babel shorthands active + (\textsf{babel)}; (4) reload \textsf{hhline} (\textsf{babel}, now + with the correct catcodes for \verb/|/ and + \verb|:|).\catcode`\|=\active + +\item Documents with several input encodings are not frequent, but + sometimes are useful. You can set different encodings for different + languages as the following example shows: +\begin{verbatim} +\addto\extrasfrench{\inputencoding{latin1}} +\addto\extrasrussian{\inputencoding{koi8-r}} +\end{verbatim} + (A recent version of \textsf{inputenc} is required.) + \item For the hyphenation to work correctly, lccodes cannot change, + because \TeX{} only takes into account the values when the + paragraph is hyphenated, i.e., when it has been + finished.\footnote{This explains why \LaTeX{} assumes the lowercase + mapping of T1 and does not provide a tool for multiple + mappings. Unfortunately, \cs{savinghyphcodes} is not a solution + either, because lccodes for hyphenation are frozen in the format + and cannot be changed.} So, if you write a chunk of French text + with |\foreinglanguage|, the apostrophes might not be taken into + account. This is a limitation of \TeX, not of + \babel. Alternatively, you may use |\useshorthands| to activate |'| + and |\defineshorthand|, or redefine |\textquoteright| (the latter + is called by the non-ASCII right quote). +\item \verb|\bibitem| is out of sync with \verb|\selectlanguage| in + the \file{.aux} file. The reason is \verb|\bibitem| uses + \verb|\immediate| (and others, in fact), while + \verb|\selectlanguage| doesn't. There is no known workaround. +\item Babel does not take into account |\normalsfcodes| and + (non-)French spacing is not always properly (un)set by + languages. However, problems are unlikely to happen and therefore + this part remains untouched in version 3.9 (but it is in the `to + do' list). +\item Using a character mathematically active (ie, with math code + |"8000|) as a shorthand can make \TeX{} enter in an infinite + loop. (Another issue in the `to do' list, although there is a + partial solution.) +\item Also in the `to do' list is a common interface to switch + scripts, to avoid the current problem of languages trying to define + |\text|\m{script} in different ways. +\end{itemize} + +\section{Preloading languages with \file{language.dat}} + +\TeX{} and most engines based on it (pdf\TeX, \xetex, $\epsilon$-\TeX, +the main exception being \luatex) require hyphenation patterns to be +loaded when a format is created (eg, \LaTeX, Xe\LaTeX, +pdf\LaTeX). \babel{} provides a tool which has become standand in many +distributions and based on a ``configuration file'' named +\file{language.dat}. The exact way this file is used depends on the +distribution, so please, read the documentation for the latter (note +also some distributions generate the file with some tool). + +In that file the person who maintains a \TeX\ environment has to record +for which languages he has hyphenation patterns \emph{and} in which +files these are stored\footnote{This is because different operating +systems sometimes use \emph{very} different file-naming +conventions.}. When hyphenation exceptions are stored in a separate +file this can be indicated by naming that file \emph{after} the file +with the hyphenation patterns. + +The file can contain empty lines and comments, as well as lines which +start with an equals (\texttt{=}) sign. Such a line will instruct +\LaTeX\ that the hyphenation patterns just processed have to be known +under an alternative name. Here is an example: +\begin{verbatim} +% File : language.dat +% Purpose : tell iniTeX what files with patterns to load. +english english.hyphenations +=british + +dutch hyphen.dutch exceptions.dutch % Nederlands +german hyphen.ger +\end{verbatim} + +You may also set the font encoding the patterns are +intended for by following the language name by a colon and the encoding +code.\footnote{This in not a new feature, but in former +versions it didn't work correctly.} For example: +\begin{verbatim} +german:T1 hyphenT1.ger +german hyphen.ger +\end{verbatim} +With the previous settings, if the enconding when the language is +selected is |T1| then the patterns in \file{hyphenT1.ger} are +used, but otherwise use those in \file{hyphen.ger} (note the encoding +could be set in |\extras|\m{lang}). + +A typical error when using \babel{} is the following: +\begin{verbatim} +No hyphenation patterns were preloaded for +the language `<lang>' into the format. +Please, configure your TeX system to add them and +rebuild the format. Now I will use the patterns +preloaded for english instead}} +\end{verbatim} +It simply means you must reconfigure \file{language.dat}, either by +hand or with the tools provided by your distribution. + +\section{The interface between the core of \babel{} and the language +definition files} + +The \textit{language definition files} (ldf) must conform to a +number of conventions, because these files have to fill in the gaps +left by the common code in \file{babel.def}, i.\,e., the +definitions of the macros that produce texts. Also the +language-switching possibility which has been built into the +\babel{} system has its implications. + +The following assumptions are made: +\begin{itemize} +\item Some of the language-specific definitions might be used by plain + \TeX\ users, so the files have to be coded so that they can be read + by both \LaTeX\ and plain \TeX. The current format can be checked by + looking at the value of the macro |\fmtname|. +\item The common part of the \babel{} system redefines a number of + macros and environments (defined previously in the document style) + to put in the names of macros that replace the previously hard-wired + texts. These macros have to be defined in the language definition + files. +\item The language definition files must define five macros, used to + activate and deactivate the language-specific definitions. These + macros are |\|\langvar|hyphenmins|, |\captions|\langvar, + |\date|\langvar, |\extras|\langvar\ and |\noextras|\langvar (the + last two may be left empty); where \langvar\ is either the name of + the language definition file or the name of the \LaTeX\ option that + is to be used. These macros and their functions are discussed + below. You must define all or none for a language (or a dialect); + defining, say, |\date|\langvar\ but not |\captions|\langvar\ does + not raise an error but can lead to unexpected results. +\item When a language definition file is loaded, it can define + |\l@|\langvar\ to be a dialect of |\language0| when |\l@|\langvar\ + is undefined. +\item Language names must be all lowercase. If an unknow language is + selected, \babel{} will attempt setting it after lowercasing its name. +\end{itemize} + +Some recommendations: +\begin{itemize} +\item The preferred shorthand is |"|, which is not used in \LaTeX{} + (quotes are entered as |``| and |''|). Other good choices are + characters which are not used in a certain context (eg, |=| in an + ancient language). Note however |=|, |<|, |>|, |:| and the like + can be dangerous, because they may be used as part of the syntax + of some elements (numeric expressions, key/value pairs, etc.). +\item Captions should not contain shorthands or encoding dependent + commands (the latter is not always possible, but should be clearly + documented). They should be defined using the LICR. You may + also use the new tools for encoded strings, described below. +\item Avoid adding things to |\noextras|\m{lang} except for umlauthigh + and friends, |\bbl@deactivate|, |\bbl@(non)frenchspacing|, and + language specific macros. Use always, if possible, |\bbl@save| and + |\bbl@savevariable| (except if you still want to have access to the + previous value). +\end{itemize} + +There are no special requirements for documenting your language +files. Now they are not included in the base \babel{} manual, so +provide a standalone document suited for your needs (and the +corresponding PDF, if you like), as well as other files you think can +be useful (eg, samples, readme). + +\subsection{Basic macros} + +In the core of the \babel{} system, several macros are defined for use +in language definition files. Their purpose is to make a new language +known. The first two are related to hyphenation patterns. + +\DescribeMacro{\addlanguage} +The macro |\addlanguage| is a non-outer version of the macro +|\newlanguage|, defined in \file{plain.tex} version~3.x. For older +versions of \file{plain.tex} and \file{lplain.tex} a substitute +definition is used. Here ``language'' is used in the \TeX{} sense of +set of hyphenation patterns. + +\DescribeMacro{\adddialect} +The macro |\adddialect| can be used when two languages can (or +must) use the same hyphenation patterns. This can also be useful +for languages for which no patterns are preloaded in the +format. In such cases the default behaviour of the \babel{} +system is to define this language as a `dialect' of the language +for which the patterns were loaded as |\language0|. Here +``language'' is used in the \TeX{} sense of set of hyphenation +patterns. + +\DescribeMacro{\<lang>hyphenmins} +The macro |\|\langvar|hyphenmins| is used to store the values of +the |\lefthyphenmin| and |\righthyphenmin|. Redefine this macro +to set your own values, with two numbers corresponding to these +two parameters. For example: +\begin{verbatim} +\renewcommand\spanishhyphenmins{34} +\end{verbatim} +(Assigning |\lefthyphenmin| and |\righthyphenmin| directly in +|\extras<lang>| has no effect.) + +\DescribeMacro{\providehyphenmins} +The macro |\providehyphenmins| should be used in the language +definition files to set |\lefthyphenmin| and +|\righthyphenmin|. This macro will check whether these parameters +were provided by the hyphenation file before it takes any action. +If these values have been already set, this command is ignored +(currenty, default pattern files do \textit{not} set them). + +\DescribeMacro{\captions<lang>} +The macro |\captions|\langvar\ defines the macros that +hold the texts to replace the original hard-wired texts. + +\DescribeMacro{\date<lang>} +The macro |\date|\langvar\ defines |\today|. + +\DescribeMacro{\extras<lang>} +The macro |\extras|\langvar\ contains all the extra definitions needed +for a specific language. This macro, like the following, is a hook -- +you can add thing to it, but it must not be used directly. + +\DescribeMacro{\noextras<lang>} +Because we want to let the user switch +between languages, but we do not know what state \TeX\ might be in +after the execution of |\extras|\langvar, a macro that brings +\TeX\ into a predefined state is needed. It will be no surprise +that the name of this macro is |\noextras|\langvar. + +\DescribeMacro{\bbl@declare@ttribute} +This is a command to be used in the language definition files for +declaring a language attribute. It takes three arguments: the +name of the language, the attribute to be defined, and the code +to be executed when the attribute is to be used. + +\DescribeMacro{\main@language} +To postpone the activation of the definitions needed for a +language until the beginning of a document, all language +definition files should use |\main@language| instead of +|\selectlanguage|. This will just store the name of the language, +and the proper language will be activated at the start of the +document. + +\DescribeMacro{\ProvidesLanguage} +The macro |\ProvidesLanguage| should be used to identify the +language definition files. Its syntax is similar to the syntax +of the \LaTeX\ command |\ProvidesPackage|. + +\DescribeMacro{\LdfInit} +The macro |\LdfInit| performs a couple of standard checks that +must be made at the beginning of a language definition file, +such as checking the category code of the @-sign, preventing +the \file{.ldf} file from being processed twice, etc. + +\DescribeMacro{\ldf@quit} +The macro |\ldf@quit| does work needed +if a \file{.ldf} file was processed +earlier. This includes resetting the category code +of the @-sign, preparing the language to be activated at +|\begin{document}| time, and ending the input stream. + +\DescribeMacro{\ldf@finish} +The macro |\ldf@finish| does work needed +at the end of each \file{.ldf} file. This +includes resetting the category code of the @-sign, +loading a local configuration file, and preparing the language +to be activated at |\begin{document}| time. + +\DescribeMacro{\loadlocalcfg} +After processing a language definition file, +\LaTeX\ can be instructed to load a local configuration +file. This file can, for instance, be used to add strings to +|\captions|\langvar\ to support local document +classes. The user will be informed that this +configuration file has been loaded. This macro is called by +|\ldf@finish|. + +\DescribeMacro{\substitutefontfamily} +(Deprecated.) This command takes three arguments, a font encoding and +two font family names. It creates a font description file for the +first font in the given encoding. This \file{.fd} file will instruct +\LaTeX\ to use a font from the second family when a font from the +first family in the given encoding seems to be needed. + +\subsection{Skeleton} + +Here is the basic structure of an |ldf| file, with a language, a +dialect and an attribute. + +\begin{verbatim} +\ProvidesLanguage{<language>} + [2013/04/22 v0.0 <Language> support from the babel system] +\LdfInit{<language>}{captions<language>} + +\ifx\undefined\l@<language> + \@nopatterns{<Language>} + \adddialect\l@<language>0 +\fi + +\adddialect\l@<dialect>\l@<language> + +\bbl@declare@ttribute{<language>}{<attrib>}{% + \expandafter\addto\expandafter\extras<language> + \expandafter{\extras<attrib><language>}% + \let\captions<language>\captions<attrib><language>} + +\providehyphenmins{<language>}{\tw@\thr@@} + +\def\captions<language>{} +\let\captions<dialect>\captions<language> + +\def\date<language>{} +\def\date<dialect>{} + +\addto\extras<language>{} +\addto\noextras<language>{} +\let\extras<dialect>\extras<language> +\let\noextras<dialect>\noextras<language> + +\ldf@finish{<language>} +\end{verbatim} + +\subsection{Support for active characters} + +In quite a number of language definition files, active characters are +introduced. To facilitate this, some support macros are provided. + +\DescribeMacro{\initiate@active@char} +The internal macro |\initiate@active@char| is used in language +definition files to instruct \LaTeX\ to give a character the category +code `active'. When a character has been made active it will remain +that way until the end of the document. Its definition may vary. + +\DescribeMacro{\bbl@activate} +\DescribeMacro{\bbl@deactivate} +The command |\bbl@activate| is used to change the way an active +character expands. |\bbl@activate| `switches on' the active behaviour +of the character. |\bbl@deactivate| lets the active character expand +to its former (mostly) non-active self. + +\DescribeMacro{\declare@shorthand} +The macro |\declare@shorthand| is used to define the various +shorthands. It takes three arguments: the name for the collection of +shorthands this definition belongs to; the character (sequence) that +makes up the shorthand, i.e.\ |~| or |"a|; and the code to be executed +when the shorthand is encountered. (It does \textit{not} raise an +error if the shorthand character has not been ``initiated''.) + +\DescribeMacro{\bbl@add@special} +\DescribeMacro{\bbl@remove@special} +The \TeX book states: ``Plain \TeX\ includes a macro called +|\dospecials| that is essentially a set macro, representing the set of +all characters that have a special category code.'' \cite[p.~380]{DEK} +It is used to set text `verbatim'. To make this work if more +characters get a special category code, you have to add this character +to the macro |\dospecial|. \LaTeX\ adds another macro called +|\@sanitize| representing the same character set, but without the +curly braces. The macros |\bbl@add@special|\meta{char} and +|\bbl@remove@special|\meta{char} add and remove the character +\meta{char} to these two sets. + +\subsection{Support for saving macro definitions} + +Language definition files may want to \emph{re}define macros that +already exist. Therefor a mechanism for saving (and restoring) the +original definition of those macros is provided. We provide two macros +for this\footnote{This mechanism was introduced by Bernd Raichle.}. + +\DescribeMacro{\babel@save} +To save the current meaning of any control sequence, the macro +|\babel@save| is provided. It takes one argument, \meta{csname}, the +control sequence for which the meaning has to be saved. + +\DescribeMacro{\babel@savevariable} +A second macro is provided to save the current value of a variable. +In this context, anything that is allowed after the |\the| primitive +is considered to be a variable. The macro takes one argument, the +\meta{variable}. + +The effect of the preceding macros is to append a piece of code to +the current definition of |\originalTeX|. When |\originalTeX| is +expanded, this code restores the previous definition of the control +sequence or the previous value of the variable. + +\subsection{Support for extending macros} + +\DescribeMacro{\addto} +The macro |\addto{|\meta{control sequence}|}{|\meta{\TeX\ code}|}| can +be used to extend the definition of a macro. The macro need not be +defined (ie, it can be undefined or |\relax|). This macro can, for +instance, be used in adding instructions to a macro like +|\extrasenglish|. + +Be careful when using this macro, because depending on the case the +assignment could be either global (usually) or local (sometimes). That +does not seems very consistent, but this behaviour is preserved for +backward compatibility. If you are using \pkg{etoolbox}, by Philipp +Lehman, consider using the tools provided by this package instead of +|\addto|. + +\subsection{Macros common to a number of languages} + +\DescribeMacro{\bbl@allowhyphens} +In several languages compound words are used. This means that when +\TeX\ has to hyphenate such a compound word, it only does so at the +`\texttt{-}' that is used in such words. To allow hyphenation in the +rest of such a compound word, the macro |\bbl@allowhyphens| can be +used. + +\DescribeMacro{\allowhyphens} +Same as |\bbl@allowhyphens|, but does nothing if the encoding is +|T1|. It is intended mainly for characters provided as real glyphs by +this encoding but constructed with |\accent| in |OT1|. + +Note the previous command (|\bbl@allowhyphens|) has different +applications (hyphens and discretionaries) than this one (composite +chars). Note also prior to version 3.7, |\allowhyphens| had the +behaviour of |\bbl@allowhyphens|. + +\DescribeMacro{\set@low@box} +For some languages, quotes need to be lowered to the baseline. For +this purpose the macro |\set@low@box| is available. It takes one +argument and puts that argument in an |\hbox|, at the baseline. The +result is available in |\box0| for further processing. + +\DescribeMacro{\save@sf@q} +Sometimes it is necessary to preserve the |\spacefactor|. For this +purpose the macro |\save@sf@q| is available. It takes one argument, +saves the current spacefactor, executes the argument, and restores the +spacefactor. + +\DescribeMacro{\bbl@frenchspacing} +\DescribeMacro{\bbl@nonfrenchspacing} +The commands |\bbl@frenchspacing| and |\bbl@nonfrenchspacing| can be +used to properly switch French spacing on and off. + +\subsection{Encoding-dependent strings} + +\fbox{New 3.9} Babel 3.9 provides a way of defining strings in several +encodings, intended mainly for \luatex{} and \xetex. This is the only new +feature requiring changes in language files if you want to make use of +it. + +Furthermore, it must be activated explicitly, with the package option +|strings|. If there is no |strings|, these blocks are ignored, except +|\SetCase|s (and except if forced with |\UseStrings|, see +below). In other words, the old way of defining/switching strings still +works and it's used by default. + +It consist is a series of blocks started with +|\StartBabelCommands|. The last block is closed with +|\EndBabelCommands|. Each block is a single group (ie, local +declarations apply until the next |\StartBabelCommands| or +|\EndBabelCommands|). An |ldf| may contain several series of this +kind. + +Thanks to this new feature, string values and string language +switching are not mixed any more. No need of |\addto|. If the language +is german, just redefine |\germanchaptername|. + +\Describe\StartBabelCommands + {\marg{language-list}\marg{category}\oarg{selector}} + +The \m{language-list} specifies which languages the block is intended +for. A block is taken into account only if the |\CurrentOption| is +listed here. + +A ``selector'' is a name to be used as value in package option +|strings|, optionally followed by extra info about the encodings to be +used. The name |unicode| must be used for \xetex{} and \luatex{} (the +key |strings| has also other two special values: |generic| and +|encoded|). + +If a string is set several times (because several blocks are read), +the first one take precedence (ie, it works much like +|\providecommand|). + +Encoding info is |charset=| followed by a charset, which if given sets +how the strings should be traslated to the internal representation +used by the engine, typically |utf8|, which is the only value +supported currently (default is no traslations). + +A list of font encodings which the strings are expected to work with +can be given after |fontenc=| (separated with spaces, if two or more) -- +recommended, but not mandatory, although blocks without this key are +not taken into account if you have requested |strings=encoded|. + +Blocks without a selector are read always if the key |strings| has +been used. They provide fallback values, and therefore must be the +last blocks; they should be provided always if possible and all +strings should be defined somehow inside it; they can be the only +blocks (mainly LGC scripts using the LICR). Blocks without a selector +can be activated explicitly with |strings=generic| (no block is taken +into account except those). With |strings=encoded|, strings in those +blocks are set as default (internally, |?|). If there is no key +|strings|, string definitions are ignored, but |\SetCase|s are still +honoured (an a |encoded| way). + +The \m{category} is either |captions|, |date| or |extras|. You must +stick to these three categories, even if no error is raised when using +other name.\footnote{In future releases further categories may be +added.\nb{like `monetary', `time', `address', `name', `case' or +`numeric'}} It may be empty, too, but in such a case using +|\SetString| is an error (but not |\SetCase|). + +\begin{verbatim} +\StartBabelCommands\CurrentOption{captions} + [unicode, fontenc=EU1 EU2, charset=utf8] +\SetString{\chaptername}{utf8-string} + +\StartBabelCommands\CurrentOption{captions} +\SetString{\chaptername}{ascii-maybe-LICR-string} + +\EndBabelCommands +\end{verbatim} + +A real example is: +\begin{verbatim}[escapechar=\&] +\StartBabelCommands{austrian}{date} + [unicode, fontenc=EU1 EU2, charset=utf8] + \SetString\monthiname{J&\"a&nner} + +\StartBabelCommands{german,austrian}{date} + [unicode, fontenc=EU1 EU2, charset=utf8] + \SetString\monthiiiname{M&\"a&rz} + +\StartBabelCommands{austrian}{date} + \SetString\monthiname{J\"{a}nner} + +\StartBabelCommands{german}{date} + \SetString\monthiname{Januar} + +\StartBabelCommands{german,austrian}{date} + \SetString\monthiiname{Februar} + \SetString\monthiiiname{M\"{a}rz} + \SetString\monthivname{April} + \SetString\monthvname{Mai} + \SetString\monthviname{Juni} + \SetString\monthviiname{Juli} + \SetString\monthviiiname{August} + \SetString\monthixname{September} + \SetString\monthxname{Oktober} + \SetString\monthxiname{November} + \SetString\monthxiiname{Dezenber} + \SetString\today{\number\day.~% + \csname month\romannumeral\month name\endcsname\space + \number\year} + +\StartBabelCommands{german,austrian}{captions} + \SetString\prefacename{Vorwort} + [etc.] + +\EndBabelCommands +\end{verbatim} + +When used in |ldf| files, previous values of |\|\m{category}\m{language} +are overriden, which means the old way to define strings still works +and used by default (to be precise, is first set to undefined and then +strings are added). However, when used in the preamble or in a +package, new settings are added to the previous ones, if the language +exists (in the \babel{} sense, ie, if |\date|\m{language} exists). + +\Describe\EndBabelCommands{} +Marks the end of the series of blocks. + +\Describe\UseStrings{} +You may also want to omit the old way of defining define strings +altogether. Just add |\UseStrings| after the first +|\StartBabelCommands| and the generic branchs will be taken into +account even if there is no |strings| key. This directive applies to +all subsequent blocks, until |\EndBabelCommands|. + +\Describe\SetString{\marg{macro-name}\marg{string}} +Adds \meta{macro-name} to the current category, and defines globally +\meta{lang-macro-name} to \meta{code} (after applying the +transformation corresponding to the current charset or defined with +the hook |stringprocess|). + +Use this command to define strings, without including any ``logic'' if +possible, which should be a separated macro. See the example above for +the date. + +\Describe\SetStringLoop{\marg{macro-name}\marg{string-list}} +A convenient way to define several ordered names at once. For example, +to define |\abmoniname|, |\abmoniiname|, etc. (and similarly with +|abday|): +\begin{verbatim} +\SetStringLoop{abmon#1name}{en,fb,mr,ab,my,jn,jl,ag,sp,oc,nv,dc} +\SetStringLoop{abday#1name}{lu,ma,mi,ju,vi,sa,do} +\end{verbatim} +|#1| is replaced by the roman numeral. + +\Describe\SetCase{\oarg{map-list}\marg{toupper-code}\marg{tolower-code}} +Sets globally code to be executed at |\MakeUppercase| and +|\MakeLowercase|. The code would be typically things like |\let\BB\bb| +and |\uccode| or |\lccode| (although for the reasons explained above, +changes in lc/uc codes may not work). A \meta{map-list} is a series of +macros using the internal format of |\@uclclist| (eg, +|\bb\BB\cc\CC|). The mandatory arguments take precedence over the +optional one. This command, unlike |\SetString|, is executed always +(even without |strings|), and it is intented for minor readjustments +only. + +For example, as |T1| is the default case mapping in \LaTeX, we could +set for Turkish: +\begin{verbatim}[escapechar=\&] +\StartBabelCommands{turkish}{}[ot1enc, fontenc=OT1] +\SetCase + {\uccode"10=`I\relax} + {\lccode`I="10\relax} + +\StartBabelCommands{turkish}{}[unicode, fontenc=EU1 EU2, charset=utf8] +\SetCase + {\uccode`i=`&\rmfamily\.{\ttfamily I}&\relax + \uccode`&\i&=`I\relax} + {\lccode`&\rmfamily\.{\ttfamily I}&=`i\relax + \lccode`I=`&\i&\relax} + +\StartBabelCommands{turkish}{} +\SetCase + {\uccode`i="9D\relax + \uccode"19=`I\relax} + {\lccode"9D=`i\relax + \lccode`I="19\relax} + +\EndBabelCommands +\end{verbatim} +(Note the mapping for |OT1| is not complete.) + +\section{Compatibility and changes} + +\subsection{Compatibility with \file{german.sty}}\label{l-h} + +The file \file{german.sty} has been one of the sources of inspiration +for the \babel{} system. Because of this I wanted to include +\file{german.sty} in the \babel{} system. To be able to do that I had +to allow for one incompatibility: in the definition of the macro +|\selectlanguage| in \file{german.sty} the argument is used as the +{$\langle \it number \rangle$} for an |\ifcase|. So in this case a +call to |\selectlanguage| might look like |\selectlanguage{\german}|. + +In the definition of the macro |\selectlanguage| in \file{babel.def} +the argument is used as a part of other macronames, so a call to +|\selectlanguage| now looks like |\selectlanguage{german}|. Notice +the absence of the escape character. As of version~3.1a of \babel{} +both syntaxes are allowed. + +All other features of the original \file{german.sty} have been copied +into a new file, called \file{germanb.sty}\footnote{The `b' is added +to the name to distinguish the file from Partls' file.}. + +Although the \babel{} system was developed to be used with \LaTeX, +some of the features implemented in the language definition files +might be needed by plain \TeX\ users. Care has been taken that all +files in the system can be processed by plain \TeX. + +\subsection{Compatibility with \file{ngerman.sty}} + +When used with the options \Lopt{ngerman} or \Lopt{naustrian}, +\babel{} will provide all features of the package \pkg{ngerman}. +There is however one exception: The commands for special hyphenation +of double consonants (|"ff| etc.) and ck (|"ck|), which are no longer +required with the new German orthography, are undefined. With the +\pkg{ngerman} package, however, these commands will generate +appropriate warning messages only. + +\subsection{Compatibility with the \pkg{french} package} + +It has been reported to me that the package \pkg{french} by Bernard +Gaulle (\texttt{gaulle@idris.fr}) works together with \babel. On the +other hand, it seems \emph{not} to work well together with a lot of +other packages. Therefore I have decided to no longer load +\file{french.ldf} by default. Instead, when you want to use the +package by Bernard Gaulle, you will have to request it specifically, +by passing either \Lopt{frenchle} or \Lopt{frenchpro} as an option to +\babel. + +\subsection{Changes in \babel\ version 3.9} + +Most of changes in version 3.9 are related to bugs, either to fix them +(there were lots), or to provide some alternatives. Even new features +like |\babelhyphen| are intended to solve a certain problem (in this +case, the lacking of a uniform syntax and behaviour for shorthands +across languages). These changes are described in this manual in the +correspondin place. + +\subsection{Changes in \babel\ version 3.7} + +In \babel\ version 3.7 a number of bugs that were found in +version~3.6 are fixed. Also a number of changes and additions +have occurred: +\begin{itemize} +\item Shorthands are expandable again. The disadvantage is that + one has to type |'{}a| when the acute accent is used as a + shorthand character. The advantage is that a number of other + problems (such as the breaking of ligatures, etc.) have + vanished. +\item Two new commands, |\shorthandon| and |\shorthandoff| have + been introduced to enable to temporarily switch off one or more + shorthands. +\item Support for typesetting Greek has been enhanced. Code from + the \pkg{kdgreek} package (suggested by the author) was added + and |\greeknumeral| has been added. +\item Support for typesetting Basque is now available thanks to + Juan Aguirregabiria. +\item Support for typesetting Serbian with Latin script is now + available thanks to Dejan Muhamedagi\'{c} and Jankovic + Slobodan. +\item Support for typesetting Hebrew (and potential support for + typesetting other right-to-left written languages) is now + available thanks to Rama Porrat and Boris Lavva. +\item Support for typesetting Bulgarian is now available thanks to + Georgi Boshnakov. +\item Support for typesetting Latin is now available, thanks to + Claudio Beccari and Krzysztof Konrad \.Zelechowski. +\item Support for typesetting North Sami is now available, thanks + to Regnor Jernsletten. +\item The options \Lopt{canadian}, \Lopt{canadien} and + \Lopt{acadien} have been added for Canadian English and French + use. +\item A language attribute has been added to the |\mark...| + commands in order to make sure that a Greek header line comes + out right on the last page before a language switch. +\item Hyphenation pattern files are now read \emph{inside a + group}; therefore any changes a pattern file needs to make to + lowercase codes, uppercase codes, and category codes are kept + local to that group. If they are needed for the language, these + changes will need to be repeated and stored in |\extras...| +\item The concept of language attributes is introduced. It is + intended to give the user some control over the + features a language-definition file provides. Its + first use is for the Greek language, where the user can choose + the $\pi o\lambda\upsilon\tau o\nu\kappa\acute{o}$ + (``Polutoniko'' or multi-accented) Greek way of typesetting + texts. These attributes will possibly find wider use in future + releases. +\item The environment \Lenv{hyphenrules} is introduced. +\item The syntax of the file \file{language.dat} has been + extended to allow (optionally) specifying the font + encoding to be used while processing the patterns file. +\item The command |\providehyphenmins| should now be used in + language definition files in order to be able to keep any + settings provided by the pattern file. +\end{itemize} + +\subsection{Changes in \babel\ version 3.6} + +In \babel\ version 3.6 a number of bugs that were found in +version~3.5 are fixed. Also a number of changes and additions +have occurred: +\begin{itemize} +\item A new environment \Lenv{otherlanguage*} is introduced. it + only switches the `specials', but leaves the `captions' + untouched. +\item The shorthands are no longer fully expandable. Some + problems could only be solved by peeking at the token following + an active character. The advantage is that |'{}a| works as + expected for languages that have the |'| active. +\item Support for typesetting french texts is much enhanced; the + file \file{francais.ldf} is now replaced by \file{frenchb.ldf} + which is maintained by Daniel Flipo. +\item Support for typesetting the russian language is again + available. The language definition file was originally + developed by Olga Lapko from CyrTUG. The fonts needed to + typeset the russian language are now part of the \babel\ + distribution. The support is not yet up to the level which is + needed according to Olga, but this is a start. +\item Support for typesetting greek texts is now also + available. What is offered in this release is a first attempt; + it will be enhanced later on by Yannis Haralambous. +\item in \babel\ 3.6j some hooks have been added for the + development of support for Hebrew typesetting. +\item Support for typesetting texts in Afrikaans (a variant of + Dutch, spoken in South Africa) has been added to + \file{dutch.ldf}. +\item Support for typesetting Welsh texts is now available. +\item A new command |\aliasshorthand| is introduced. It seems + that in Poland various conventions are used to type the + necessary Polish letters. It is now possible to use the + character~|/| as a shorthand character instead of the + character~|"|, by issuing the command |\aliasshorthand{"}{/}|. +\item The shorthand mechanism now deals correctly with characters + that are already active. +\item Shorthand characters are made active at |\begin{document}|, + not earlier. This is to prevent problems with other packages. +\item A \emph{preambleonly} command |\substitutefontfamily| has + been added to create \file{.fd} files on the fly when the font + families of the Latin text differ from the families used for + the Cyrillic or Greek parts of the text. +\item Three new commands |\LdfInit|, |\ldf@quit| and + |\ldf@finish| are introduced that perform a number of standard + tasks. +\item In babel 3.6k the language Ukrainian has been added and the + support for Russian typesetting has been adapted to the package + 'cyrillic' to be released with the December 1998 release of + \LaTeXe. +\end{itemize} + +\subsection{Changes in \babel\ version 3.5} + +In \babel\ version 3.5 a lot of changes have been made when compared +with the previous release. Here is a list of the most important ones: +\begin{itemize} +\item the selection of the language is delayed until + |\begin{document}|, which means you must add appropriate + |\selectlanguage| commands if you include |\hyphenation| lists in + the preamble of your document. +\item \babel\ now has a \Lenv{language} environment and a new + command |\foreignlanguage|; +\item the way active characters are dealt with is completely + changed. They are called `shorthands'; one can have three + levels of shorthands: on the user level, the language level, + and on `system level'. A consequence of the new way of handling + active characters is that they are now written to auxiliary + files `verbatim'; +\item A language change now also writes information in the + \file{.aux} file, as the change might also affect typesetting + the table of contents. The consequence is that an \file{.aux} file + generated by a LaTeX format with babel preloaded gives errors + when read with a LaTeX format without babel; but I think this + probably doesn't occur; +\item \babel\ is now compatible with the \pkg{inputenc} and + \pkg{fontenc} packages; +\item the language definition files now have a new extension, + \file{ldf}; +\item the syntax of the file \file{language.dat} is extended to + be compatible with the \pkg{french} package by Bernard Gaulle; +\item each language definition file looks for a configuration + file which has the same name, but the extension \file{.cfg}. It +can contain any valid \LaTeX\ code. +\end{itemize} + +\DocInput{babel.dtx} +\DocInput{bbplain.dtx} +\DocInput{bbunicode.dtx} + +\section{Conclusion} + +A system of document options has been presented that enable the user +of \LaTeX\ to adapt the standard document classes of \LaTeX\ to the +language he or she prefers to use. These options offer the possibility +of switching between languages in one document. The basic interface +consists of using one option, which is the same for \emph{all} +standard document classes. + +In some cases the language definition files provide macros that can be +useful to plain \TeX\ users as well as to \LaTeX\ users. The \babel{} +system has been implemented so that it can be used by both groups of +users. + +\section{Acknowledgements} + +I would like to thank all who volunteered as $\beta$-testers for their +time. I would like to mention Julio Sanchez who supplied the option +file for the Spanish language and Maurizio Codogno who supplied the +option file for the Italian language. Michel Goossens supplied +contributions for most of the other languages. Nico Poppelier helped +polish the text of the documentation and supplied parts of the macros +for the Dutch language. Paul Wackers and Werenfried Spit helped find +and repair bugs. + +During the further development of the babel system I received much +help from Bernd Raichle, for which I am grateful. + +\begin{thebibliography}{9} + \bibitem{DEK} Donald E. Knuth, + \emph{The \TeX book}, Addison-Wesley, 1986. + \bibitem{LLbook} Leslie Lamport, + \emph{\LaTeX, A document preparation System}, Addison-Wesley, + 1986. + \bibitem{treebus} K.F. Treebus. + \emph{Tekstwijzer, een gids voor het grafisch verwerken van + tekst.} + SDU Uitgeverij ('s-Gravenhage, 1988). A Dutch book on layout + design and typography. + \bibitem{HP} Hubert Partl, + \emph{German \TeX}, \emph{TUGboat} 9 (1988) \#1, p.~70--72. + \bibitem{LLth} Leslie Lamport, + in: \TeX hax Digest, Volume 89, \#13, 17 February 1989. + \bibitem{BEP} Johannes Braams, Victor Eijkhout and Nico Poppelier, + \emph{The development of national \LaTeX\ styles}, + \emph{TUGboat} 10 (1989) \#3, p.~401--406. + \bibitem{ilatex} Joachim Schrod, + \emph{International \LaTeX\ is ready to use}, + \emph{TUGboat} 11 (1990) \#1, p.~87--90. +\end{thebibliography} +\end{document} +%</filedriver> +%\fi +% \changes{babel~3.7a}{1997/04/16}{Make multiple loading of +% \file{babel.def} impossible} +% \changes{babel~3.9a}{2012/05/16}{Now using \cs{ldf@quit} for the test} +% \begin{macrocode} +%<*core> +\ifx\ldf@quit\@undefined +\else + \expandafter\endinput +\fi +%</core> +% \end{macrocode} +%<*dtx> +\ProvidesFile{babel.dtx} +%</dtx> +%\fi +% +% \GetFileInfo{babel.dtx} +% +% \changes{babel~2.0a}{1990/04/02}{Added text about \file{german.sty}} +% \changes{babel~2.0b}{1990/04/18}{Changed order of code to prevent +% plain \TeX from seeing all of it} +% \changes{babel~2.1}{1990/04/24}{Modified user interface, +% \cs{langTeX} no longer necessary} +% \changes{babel~2.1a}{1990/05/01}{Incorporated Nico's comments} +% \changes{babel~2.1b}{1990/05/01}{rename \cs{language} to +% \cs{current@language}} +% \changes{babel~2.1c}{1990/05/22}{abstract for report fixed, missing +% \texttt{\}}, found by Nicolas Brouard} +% \changes{babel~2.1d}{1990/07/04}{Missing right brace in definition of +% abstract environment, found by Werenfried Spit} +% \changes{babel~2.1e}{1990/07/16}{Incorporated more comments from +% Nico} +% \changes{babel~2.2}{1990/07/17}{Renamed \cs{newlanguage} to +% \cs{addlanguage}} +% \changes{babel~2.2a}{1990/08/27}{Modified the documentation +% somewhat} +% \changes{babel~3.0}{1991/04/23}{Moved part of the code to hyphen.doc +% in preparation for \TeX~3.0} +% \changes{babel~3.0a}{1991/05/21}{Updated comments in various places} +% \changes{babel~3.0b}{1991/05/25}{Removed some problems in change log} +% \changes{babel~3.0c}{1991/07/15}{Renamed \file{babel.sty} and +% \file{latexhax.sty} to \file{.com}} +% \changes{babel~3.1}{1991/10/31}{Added the support for active +% characters and for extending a macro} +% \changes{babel~3.1}{1991/11/05}{Removed the need for +% \file{latexhax}} +% \changes{babel~3.2}{1991/11/10}{Some Changes by br} +% \changes{babel~3.2a}{1992/02/15}{Fixups of the code and +% documentation} +% \changes{babel~3.3}{1993/07/06}{Included driver file, and prepared +% for distribution} +% \changes{babel~3.4}{1994/01/30}{Updated for \LaTeXe} +% \changes{babel~3.4}{1994/02/28}{Added language definition file for +% bahasa} +% \changes{babel~3.4b}{1994/05/18}{Added a small driver to be able to +% process just this file} +% \changes{babel~3.5a}{1995/02/03}{Provided common code to handle the +% active double quote} +% \changes{babel~3.5c}{1995/06/14}{corrected a few typos (PR1652)} +% \changes{babel~3.5d}{1995/07/02}{Merged glyphs.dtx into this file} +% \changes{babel~3.5f}{1995/07/13}{repaired a typo} +% \changes{babel~3.5f}{1996/01/09}{replaced \cs{tmp}, \cs{bbl@tmp} and +% \cs{bbl@temp} with \cs{bbl@tempa}} +% \changes{babel~3.5g}{1996/07/09}{replaced \cs{undefined} with +% \cs{@undefined} to be consistent with \LaTeX} +% \changes{babel~3.7d}{1999/05/05}{Fixed a few typos in \cs{changes} +% entries which made typesetting the code impossible} +% \changes{babel~3.7h}{2001/03/01}{Added a number of missing comment +% characters which caused spurious white space} +% \changes{babel~3.8e}{2005/03/24}{Many enhancements to the text by +% Andrew Young} +% \changes{babel~3.9c}{2013/04/04}{Added the ``modifiers'' mechanism} +% +% \section{Identification and loading of required files} +% +% \textit{Code documentation is still under revision.} +% +% The file \file{babel.sty}\footnote{The file described in this +% section is called \texttt{\filename}, has version +% number~\fileversion\ and was last revised on~\filedate.} is meant +% for \LaTeXe, therefor we make sure that the format file used is +% the right one. +% +% \begin{macro}{\ProvidesLanguage} +% \changes{babel~3.7a}{1997/03/18}{Added macro to prevent problems +% with unexpected \cs{ProvidesFile} in plain formats because of +% \babel.} +% The identification code for each file is something that was +% introduced in \LaTeXe. When the command |\ProvidesFile| does not +% exist, a dummy definition is provided temporarily. For use in the +% language definition file the command |\ProvidesLanguage| is +% defined by \babel. +% \changes{babel~3.4e}{1994/06/24}{Redid the identification code, +% provided dummy definition of \cs{ProvidesFile} for plain \TeX} +% \changes{babel~3.5f}{1995/07/26}{Store version in \cs{fileversion}} +% \changes{babel~3.5f}{1995/12/18}{Need to temporarily change the +% definition of \cs{ProvidesFile} for December 1995 release} +% \changes{babel~3.5g}{1996/07/09}{Save a few csnames; use +% \cs{bbl@tempa} instead of \cs{\@ProvidesFile} and store message +% in \cs{toks8}} +% \changes{babel~3.9a}{2012/12/09}{Save info about the babel version +% in the format (switch.def) so that it can be checked later if +% necessary} +% \begin{macrocode} +%<*kernel> +\def\bbl@version{3.9e} +\def\bbl@date{2013/04/15} +%</kernel> +%<*patterns> +\xdef\bbl@format{\jobname} +%</patterns> +%<*core|kernel|patterns> +\ifx\ProvidesFile\@undefined + \def\ProvidesFile#1[#2 #3 #4]{% + \wlog{File: #1 #4 #3 <#2>}% + \let\ProvidesFile\@undefined + } +%</core|kernel|patterns> +% \end{macrocode} +% As an alternative for |\ProvidesFile| we define +% |\ProvidesLanguage| here to be used in the language definition +% files. +% \begin{macrocode} +%<*kernel> + \def\ProvidesLanguage#1[#2 #3 #4]{% + \wlog{Language: #1 #4 #3 <#2>}% + } +\else +% \end{macrocode} +% When |\ProvidesFile| is defined we give |\ProvidesLanguage| a +% similar definition. +% \begin{macrocode} + \def\ProvidesLanguage#1{% + \begingroup + \catcode`\ 10 % + \@makeother\/% + \@ifnextchar[%] + {\@provideslanguage{#1}}{\@provideslanguage{#1}[]}} + \def\@provideslanguage#1[#2]{% + \wlog{Language: #1 #2}% + \expandafter\xdef\csname ver@#1.ldf\endcsname{#2}% + \endgroup} +%</kernel> +%<*core|kernel|patterns> +\fi +%</core|kernel|patterns> +% \end{macrocode} +% \end{macro} +% +% Identify each file that is produced from this source file. +% \changes{babel~3.4c}{1995/04/28}{lhyphen.cfg has become +% lthyphen.cfg} +% \changes{babel~3.5b}{1995/01/25}{lthyphen.cfg has become hyphen.cfg} +% \begin{macrocode} +%<package>\ProvidesPackage{babel} +%<core>\ProvidesFile{babel.def} +%<patterns>\ProvidesFile{hyphen.cfg} +%<kernel>\ProvidesFile{switch.def} +%<nil>\ProvidesLanguage{nil} +%<driver&!user>\ProvidesFile{babel.drv} +%<driver&user>\ProvidesFile{user.drv} + [2013/04/15 v3.9e % +%<package> The Babel package] +%<core> Babel common definitions] +%<kernel|patterns> Babel language switching mechanism] +%<nil> Nil language] +%<driver>] +% \end{macrocode} +% +% Now we make sure all required files are loaded. When the command +% |\AtBeginDocument| doesn't exist we assume that we are dealing +% with a plain-based format or \LaTeX2.09. In that case the file +% \file{plain.def} is needed (which also defines +% |\AtBeginDocument|, and therefore it is not loaded twice). We +% need the first part when the format is created, and |\orig@dump| +% is used as a flag. Otherwise, we need to use the second part, so +% |\orig@dump| is not defined (\file{plain.def} undefines it). +% +% \changes{babel~3.9a}{2012/12/21}{Use \cs{orig@dump} as flag instead +% of \cs{adddialect}} +%\begingroup +% \catcode`&=\active +% \gdef\MakePrivateLetters{\catcode`@=11\relax\catcode`&=\active}% +% \gdef&{\quad\colorbox{thegrey}{\textsf{#1}}} +%\endgroup +% \begin{macrocode} +%<*core|kernel|patterns> +\ifx\AtBeginDocument\@undefined +%</core|kernel|patterns> +%<*patterns> + \let\orig@dump\dump +%</patterns> +%<*core|kernel|patterns> + \input plain.def\relax +\fi +%</core|kernel|patterns> +% \end{macrocode} +% +% Check if the current version of \file{switch.def} has been +% previously loaded (mainly, \file{hyphen.cfg}). If not, load it +% now. We cannot load |babel.def| here because we first need to +% declare and process the package options. +% \changes{babel~3.0d}{1991/10/29}{Removed use of \cs{@ifundefined}} +% \changes{babel~3.9a}{2012/08/11}{Now switch.def is loaded always, so +% that there is no need to rebuild formats just to update babel} +% \changes{babel~3.9a}{2012/12/13}{But switch.def is loaded only if +% loaded in a different version (or not loaded)} +% \changes{babel~3.9a}{2013/01/14}{Added the debug option} +% \changes{babel~3.9a}{2013/02/05}{Added \cs{bbl@add}} +% \begin{macrocode} +%<*package> +\@ifpackagewith{babel}{debug} + {\let\bbl@tempa\relax} + {\def\bbl@tempa{3.9e}}% +%</package> +%<*core> +\def\bbl@tempa{3.9e} +%</core> +%<*core|package> +\ifx\bbl@version\bbl@tempa\else + \input switch.def\relax +\fi +% \end{macrocode} +% The following macros just make the code cleaner. |\bbl@add| is +% now used internally instead of |\addto| because of the +% unpredictable behaviour of the latter. (There are some +% duplications, but, you know, I [JBL] never rememer where the code +% ends up when intermingled with docstrip.) +% \begin{macrocode} +\def\bbl@for#1#2#3{\@for#1:=#2\do{\ifx#1\@empty\else#3\fi}} +\def\bbl@add#1#2{% + \@ifundefined{\expandafter\@gobble\string#1}% + {\def#1{#2}}% + {\expandafter\def\expandafter#1\expandafter{#1#2}}} +\def\bbl@csarg#1#2{\expandafter#1\csname bbl@#2\endcsname}% +\long\def\bbl@afterelse#1\else#2\fi{\fi#1} +\long\def\bbl@afterfi#1\fi{\fi#1} +%</core|package> +% \end{macrocode} +% \changes{babel~3.6a}{1996/11/02}{Removed \cs{babel@core@loaded}, no +% longer needed with the advent of \cs{LdfInit}} +% +% \section{The Package File} +% +% In order to make use of the features of \LaTeXe, the \babel\ +% system contains a package file, \file{babel.sty}. This file is +% loaded by the |\usepackage| command and defines all the language +% options whose name is different from that of the |.ldf| file +% (like variant spellings). It also takes care of a number of +% compatibility issues with other packages an defines a few +% aditional package options. +% +% +% Apart from all the language options below we also have a few options +% that influence the behaviour of language definition files. +% +% Many of the following options don't do anything themselves, they +% are just defined in order to make it possible for babel and +% language definition files to check if one of them was specified +% by the user. +% +% \subsection{\texttt{base}} +% +% The first option to be processed is |base|, which set the +% hyphenation patterns then resets |ver@babel.sty| so that +% LaTeX forgets about the first loading. After |switch.def| has +% been loaded (above) and |\AfterBabelLanguage| defined, exits. +% +% \changes{babel~3.5d}{1995/07/04}{Added options to influence +% behaviour of active acute and grave accents} +% \changes{babel~3.9a}{2012/10/05}{preset option started, +% party stolen from fontenc} +% \changes{babel~3.9a}{2012/10/17}{Hooks started} +% \changes{babel~3.9a}{2013/02/07}{Rejected preset, and replaced by +% base} +% \begin{macrocode} +%<*package> +\def\AfterBabelLanguage#1{% + \global\expandafter\bbl@add\csname#1.ldf-h@@k\endcsname}% +\@ifpackagewith{babel}{base}{% + \DeclareOption*{\bbl@patterns{\CurrentOption}}% + \DeclareOption{base}{}% + \ProcessOptions + \global\expandafter\let\csname opt@babel.sty\endcsname\relax + \global\expandafter\let\csname ver@babel.sty\endcsname\relax + \global\let\@ifl@ter@@\@ifl@ter + \def\@ifl@ter#1#2#3#4#5{\global\let\@ifl@ter\@ifl@ter@@}% + \endinput}{}% +% \end{macrocode} +% +% \subsection{\texttt{key=value} options and other general option} +% +% The following macros extract language modifiers, and only real +% package options are kept in the option list. Modifiers are saved +% and assigned to |\BabelModifiers| at |\bbl@load@language|; when +% no modifiers have been given, the former is |\relax|. How +% modifiers are handled are left to language styles; they can use +% |\in@|, loop them with |\@for| o load |keyval|). +% \changes{babel~3.9e}{2013/04/15}{Bug fixed - a dot was added in +% key=value pairs} +% +% \begin{macrocode} +\bbl@csarg\let{tempa\expandafter}\csname opt@babel.sty\endcsname +\def\bbl@tempb#1.#2{% + #1\ifx\@empty#2\else,\bbl@afterfi\bbl@tempb#2\fi}% +\def\bbl@tempd#1.#2\@nnil{% + \ifx\@empty#2% + \edef\bbl@tempc{\ifx\bbl@tempc\@empty\else\bbl@tempc,\fi#1}% + \else + \in@{=}{#1}\ifin@ + \edef\bbl@tempc{\ifx\bbl@tempc\@empty\else\bbl@tempc,\fi#1.#2}% + \else + \edef\bbl@tempc{\ifx\bbl@tempc\@empty\else\bbl@tempc,\fi#1}% + \bbl@csarg\edef{mod@#1}{\bbl@tempb#2}% + \fi + \fi} +\let\bbl@tempc\@empty +\bbl@for\bbl@tempa\bbl@tempa{% + \expandafter\bbl@tempd\bbl@tempa.\@empty\@nnil} +\expandafter\let\csname opt@babel.sty\endcsname\bbl@tempc +% \end{macrocode} +% +% \begin{macrocode} +\DeclareOption{activeacute}{} +\DeclareOption{activegrave}{} +% \end{macrocode} +% The next option tells \babel\ to leave shorthand characters +% active at the end of processing the package. This is \emph{not} +% the default as it can cause problems with other packages, but for +% those who want to use the shorthand characters in the preamble of +% their documents this can help. +% \changes{babel~3.6f}{1997/01/14}{Added option +% \Lopt{KeepShorthandsActive}} +% \changes{babel~3.7a}{1997/03/21}{No longer define the control +% sequence \cs{KeepShorthandsActive}} +% \begin{macrocode} +\DeclareOption{KeepShorthandsActive}{} +% \end{macrocode} +% \changes{babel~3.9a}{2012/08/14}{Implemented the \texttt{noconfigs} +% option} +% \changes{babel~3.9a}{2012/09/26}{Implemented the +% \texttt{showlanguages} option} +% \begin{macrocode} +\DeclareOption{debug}{} +\DeclareOption{noconfigs}{} +\DeclareOption{showlanguages}{} +\DeclareOption{shorthands=off}{\bbl@tempa shorthands=\bbl@tempa} +\DeclareOption{strings}{\def\bbl@opt@strings{\BabelStringsDefault}} +\DeclareOption{strings=encoded}{\let\bbl@opt@strings\relax} +\DeclareOption{safe=none}{\let\bbl@opt@safe\@empty} +\DeclareOption{safe=bib}{\def\bbl@opt@safe{B}} +\DeclareOption{safe=ref}{\def\bbl@opt@safe{R}} +\DeclareOption{math=active}{} +\DeclareOption{math=normal}{\def\bbl@mathnormal{\noexpand\textormath}} +\def\BabelStringsDefault{generic} +% \end{macrocode} +% +% Handling of package options is done in three passes. (I [JBL] am not +% very happy with the idea, anyway.) The first one processes +% options which has been declared above or follow the syntax +% |<key>=<value>|, the second one +% loads the requested languages, except the main one if set with +% the key |main|, and the third one loads the latter. First, we +% ``flag'' valid keys with a nil value. +% \changes{babel~3.9a}{2012/08/10}{Added the `safe' key, including code +% below for selecting the redefined macros} +% \begin{macrocode} +\let\bbl@opt@shorthands\@nnil +\let\bbl@opt@config\@nnil +\let\bbl@opt@main\@nnil +\let\bbl@opt@strings\@nnil +\let\bbl@opt@headfoot\@nnil +% \end{macrocode} +% The following tool is defined temporarily to store the values of +% options. +% \begin{macrocode} +\def\bbl@tempa#1=#2\bbl@tempa{% + \expandafter\ifx\csname bbl@opt@#1\endcsname\@nnil + \expandafter\edef\csname bbl@opt@#1\endcsname{#2}% + \else + \bbl@error{% + Bad option `#1=#2'. Either you have misspelled the\\% + key or there is a previous setting of `#1'}{% + Valid keys are `shorthands', `config', `strings', `main',\\% + `headfoot', `safe', `math'} + \fi} +% \end{macrocode} +% Now the option list is processed, taking into account only +% currently declared options (including those declared with a |=|), +% and |<key>=<value>| options (the former take precedence). +% Unrecognized options are saved in |\bbl@language@opts|, because +% they are language options. +% \begin{macrocode} +\let\bbl@language@opts\@empty +\DeclareOption*{% + \@expandtwoargs\in@{\string=}{\CurrentOption}% + \ifin@ + \expandafter\bbl@tempa\CurrentOption\bbl@tempa + \else + \edef\bbl@language@opts{% + \ifx\bbl@language@opts\@empty\else\bbl@language@opts,\fi + \CurrentOption}% + \fi} +% \end{macrocode} +% Now we finish the first pass (and start over). +% \begin{macrocode} +\ProcessOptions* +% \end{macrocode} +% +% \subsection{Conditional loading of shorthands} +% +% If there is no |shorthands=<chars>|, the original \textsf{babel} +% macros are left untouched, but if there is, these macros are +% wrapped (in |babel.def|) to define only those given. +% +% A bit of optimization: if there is no |shorthands=|, then +% |\bbl@ifshorthands| is always true, and it is always false if +% |shorthands| is empty. Also, some code makes sense only with +% |shorthands=...|. +% \changes{babel~3.9c}{2013/04/07}{Added t and c for tilde and comma} +% \begin{macrocode} +\def\bbl@sh@string#1{% + \ifx#1\@empty\else + \ifx#1t\string~% + \else\ifx#1c\string,% + \else\string#1% + \fi\fi + \expandafter\bbl@sh@string + \fi} +\ifx\bbl@opt@shorthands\@nnil + \def\bbl@ifshorthand#1#2#3{#2}% +\else\ifx\bbl@opt@shorthands\@empty + \def\bbl@ifshorthand#1#2#3{#3}% +\else +% \end{macrocode} +% The following macro tests if a shortand is one of the allowed +% ones. +% \begin{macrocode} + \def\bbl@ifshorthand#1{% + \@expandtwoargs\in@{\string#1}{\bbl@opt@shorthands}% + \ifin@ + \expandafter\@firstoftwo + \else + \expandafter\@secondoftwo + \fi} +% \end{macrocode} +% We make sure all chars in the string are `other', with the help +% of an auxiliary macro defined above (which also zaps spaces). +% \begin{macrocode} + \edef\bbl@opt@shorthands{% + \expandafter\bbl@sh@string\bbl@opt@shorthands\@empty}% +% \end{macrocode} + +% The following is ignored with |shorthands=off|, since it is +% intended to take some aditional actions for certain chars. +% \begin{macrocode} + \bbl@ifshorthand{'}% + {\PassOptionsToPackage{activeacute}{babel}}{} + \bbl@ifshorthand{`}% + {\PassOptionsToPackage{activegrave}{babel}}{} +\fi\fi +% \end{macrocode} +% \changes{babel~3.9a}{2012/07/30}{Code setting language in +% head/foots. Related to babel/3796} +% With |headfoot=lang| we can set the language used in heads/foots. +% For example, in babel/3796 just adds |headfoot=english|. It +% misuses \cs{@resetactivechars} but seems to work. +% \begin{macrocode} +\ifx\bbl@opt@headfoot\@nnil\else + \g@addto@macro\@resetactivechars{% + \set@typeset@protect + \expandafter\select@language@x\expandafter{\bbl@opt@headfoot}% + \let\protect\noexpand} +\fi +% \end{macrocode} +% For the option safe we use a different approach -- +% |\bbl@opt@safe| says which macros are redefined (B for bibs and R +% for refs). By default, both are set. +% \begin{macrocode} +\@ifundefined{bbl@opt@safe}{\def\bbl@opt@safe{BR}}{} +\ifx\bbl@opt@main\@nnil\else + \edef\bbl@language@opts{% + \ifx\bbl@language@opts\@empty\else\bbl@language@opts,\fi + \bbl@opt@main} +\fi +% \end{macrocode} +% If the format created a list of loaded languages (in +% |\bbl@languages|), get the name of the 0-th to show the actual +% language used. +% \begin{macrocode} +\ifx\bbl@languages\@undefined\else + \begingroup + \catcode`\^^I=12 + \@ifpackagewith{babel}{showlanguages}{% + \begingroup + \def\bbl@elt#1#2#3#4{\wlog{#2^^I#1^^I#3^^I#4}}% + \wlog{<*languages>}% + \bbl@languages + \wlog{</languages>}% + \endgroup}{} + \endgroup + \def\bbl@elt#1#2#3#4{% + \ifnum#2=\z@ + \gdef\bbl@nulllanguage{#1}% + \def\bbl@elt##1##2##3##4{}% + \fi}% + \bbl@languages +\fi +% \end{macrocode} +% +% \subsection{Language options} +% +% \changes{babel~3.6c}{1997/01/05}{When \cs{LdfInit} is undefined we +% need to load \file{babel.def} from \file{babel.sty}} +% \changes{babel~3.6l}{1999/04/03}{Don't load \file{babel.def} now, +% but rather define \cs{LdfInit} temporarily in order to load +% \file{babel.def} at the right time, preventing problems with the +% temporary definition of \cs{bbl@redefine}} +% \changes{babel~3.6r}{1999/04/12}{We \textbf{do} need to load +% \file{babel.def} right now as \cs{ProvidesLanguage} needs to be +% defined before the \file{.ldf} files are read and the reason for +% for 3.6l has been removed} +% \changes{babel~3.9a}{2012/06/15}{Rewritten the loading mechanism, so +% that languages not declared are also correctly recognized, even +% if given as global options} +% \changes{babel~3.9a}{2012/08/12}{Revised the loading mechanism} +% \changes{babel~3.5a}{1995/03/14}{Changed extension of language +% definition files to \texttt{ldf}} +% \changes{babel~3.5d}{1995/07/02}{Load language definition files +% \emph{after} the check for the hyphenation patterns} +% \changes{babel~3.5g}{1996/10/04}{Added option \Lopt{afrikaans}} +% \changes{babel~3.7g}{2001/02/09}{Added option \Lopt{acadian}} +% \changes{babel~3.8c}{2004/06/12}{Added option \Lopt{australian}} +% \changes{babel~3.8h}{2005/11/23}{Added option \Lopt{albanian}} +% \changes{babel~3.6i}{1997/02/20}{Added the \Lopt{Basque} option} +% \changes{babel~3.8h}{2005/11/23}{added synonyms \Lopt{indonesian}, +% \Lopt{indon} and \Lopt{bahasai} for the original bahasa +% (indonesia) support} +% \changes{babel~3.8h}{2005/11/23}{added \Lopt{malay}, \Lopt{meyaluy} +% and \Lopt{bahasam} for the Bahasa Malaysia support} +% \changes{babel~3.5b}{1995/05/25}{Added \Lopt{brazilian} as +% alternative for \Lopt{brazil}} +% \changes{babel~3.5d}{1995/07/02}{Added \Lopt{british} as an +% alternative for \Lopt{english} with a preference for british +% hyphenation} +% \changes{babel~3.7f}{2000/09/21}{Added the \Lopt{bulgarian} option} +% \changes{babel~3.7g}{2001/02/07}{Added option \Lopt{canadian}} +% \changes{babel~3.7g}{2001/02/09}{Added option \Lopt{canadien}} +% \changes{babel~3.5b}{1995/06/06}{Added the \Lopt{estonian} option} +% \changes{babel~3.5f}{1996/01/10}{Now use the file \file{frenchb.ldf} +% from Daniel Flipo for french support} +% \changes{babel~3.6e}{1997/01/08}{Added option \Lopt{frenchb} an +% alias for \Lopt{francais}} +% \changes{babel~3.5d}{1995/07/02}{Load \file{french.ldf} when it is +% found instead of \file{frenchb.ldf}} +% \changes{babel~3.7j}{2003/06/07}{\emph{only} load +% \file{frenchb.ldf}} +% \changes{babel~3.5f}{1996/05/31}{Added the \Lopt{greek} option} +% \changes{babel~3.7a}{1997/11/13}{Added the \Lopt{polutonikogreek} +% option} +% \changes{babel~3.7c}{1999/04/22}{set the correct language attribute +% for polutoniko greek} +% \changes{babel~3.7a}{1998/03/27}{Added the \Lopt{hebrew} option} +% \changes{babel~3.7b}{1998/06/25}{Added the \Lopt{latin} option} +% \changes{babel~3.7m}{2003/11/13}{Added the \Lopt{interlingua} +% option} +% \changes{babel~3.6p}{1999/04/10}{Added the \Lopt{ngerman} and +% \Lopt{naustrian} options} +% \changes{babel~3.7f}{2000/09/26}{Added the \Lopt{samin} option} +% \changes{babel~3.8c}{2004/06/12}{Added the \Lopt{newzealand} option} +% \changes{babel~3.6e}{1997/01/08}{Added options \Lopt{UKenglish} and +% \Lopt{USenglish}} +% +% Languages are loaded when processing the corresponding option +% \textit{except} if a |main| language has been set. In such a +% case, it is not loaded until all options has been processed. +% The following macro inputs the ldf file and does some additional +% checks (|\input| works, too, but possible errors are not catched). +% \begin{macrocode} +\let\bbl@afterlang\relax +\let\BabelModifiers\relax +\let\bbl@loaded\@empty +\def\bbl@load@language#1{% + \InputIfFileExists{#1.ldf}% + {\edef\bbl@loaded{\CurrentOption + \ifx\bbl@loaded\@empty\else,\bbl@loaded\fi}% + \expandafter\let\expandafter\bbl@afterlang + \csname\CurrentOption.ldf-h@@k\endcsname + \expandafter\let\expandafter\BabelModifiers + \csname bbl@mod@\CurrentOption\endcsname}% + {\bbl@error{% + Unknow option `\CurrentOption'. Either you misspelled it\\% + or the language definition file \CurrentOption.ldf was not found}{% + Valid options are: shorthands=..., KeepShorthandsActive,\\% + activeacute, activegrave, noconfigs, safe=, main=, math=\\% + headfoot=, strings=, config=, or a language name.}}} +% \end{macrocode} +% Now, we set language options whose names are different from |ldf| files. +% \begin{macrocode} +\DeclareOption{acadian}{\bbl@load@language{frenchb}} +\DeclareOption{afrikaans}{\bbl@load@language{dutch}} +\DeclareOption{american}{\bbl@load@language{english}} +\DeclareOption{australian}{\bbl@load@language{english}} +\DeclareOption{austrian}{\bbl@load@language{germanb}} +\DeclareOption{bahasa}{\bbl@load@language{bahasai}} +\DeclareOption{bahasai}{\bbl@load@language{bahasai}} +\DeclareOption{bahasam}{\bbl@load@language{bahasam}} +\DeclareOption{brazil}{\bbl@load@language{portuges}} +\DeclareOption{brazilian}{\bbl@load@language{portuges}} +\DeclareOption{british}{\bbl@load@language{english}} +\DeclareOption{canadian}{\bbl@load@language{english}} +\DeclareOption{canadien}{\bbl@load@language{frenchb}} +\DeclareOption{francais}{\bbl@load@language{frenchb}} +\DeclareOption{french}{\bbl@load@language{frenchb}}% +\DeclareOption{german}{\bbl@load@language{germanb}} +\DeclareOption{hebrew}{% + \input{rlbabel.def}% + \bbl@load@language{hebrew}} +\DeclareOption{hungarian}{\bbl@load@language{magyar}} +\DeclareOption{indon}{\bbl@load@language{bahasai}} +\DeclareOption{indonesian}{\bbl@load@language{bahasai}} +\DeclareOption{lowersorbian}{\bbl@load@language{lsorbian}} +\DeclareOption{malay}{\bbl@load@language{bahasam}} +\DeclareOption{meyalu}{\bbl@load@language{bahasam}} +\DeclareOption{naustrian}{\bbl@load@language{ngermanb}} +\DeclareOption{newzealand}{\bbl@load@language{english}} +\DeclareOption{ngerman}{\bbl@load@language{ngermanb}} +\DeclareOption{nynorsk}{\bbl@load@language{norsk}} +\DeclareOption{polutonikogreek}{% + \bbl@load@language{greek}% + \languageattribute{greek}{polutoniko}} +\DeclareOption{portuguese}{\bbl@load@language{portuges}} +\DeclareOption{russian}{\bbl@load@language{russianb}} +\DeclareOption{UKenglish}{\bbl@load@language{english}} +\DeclareOption{ukrainian}{\bbl@load@language{ukraineb}} +\DeclareOption{uppersorbian}{\bbl@load@language{usorbian}} +\DeclareOption{USenglish}{\bbl@load@language{english}} +% \end{macrocode} +% +% Another way to extend the list of `known' options for \babel\ is +% to create the file \file{bblopts.cfg} in which one can add option +% declarations. However, this mechanism is deprecated -- if you +% want an alternative name for a language, just create a new |.ldf| +% file loading the actual one. You can also set the name +% of the file with the package option |config=<name>|, which will +% load |<name>.cfg| instead. +% \changes{babel~3.6i}{1997/03/15}{Added the possibility to have a +% \file{bblopts.cfg} file with option declarations.} +% \changes{babel~3.9a}{2012/06/28}{Added the \cs{AfterBabelLanguage} +% mechanism, to be used mainly with the local cfg file.} +% \changes{babel~3.9a}{2012/06/31}{Now you can set the name of the +% local cfg file.} +% \begin{macrocode} +\ifx\bbl@opt@config\@nnil + \@ifpackagewith{babel}{noconfigs}{}% + {\InputIfFileExists{bblopts.cfg}% + {\typeout{*************************************^^J% + * Local config file bblopts.cfg used^^J% + *}}% + {}}% +\else + \InputIfFileExists{\bbl@opt@config.cfg}% + {\typeout{*************************************^^J% + * Local config file \bbl@opt@config.cfg used^^J% + *}}% + {\bbl@error{% + Local config file `\bbl@opt@config.cfg' not found}{% + Perhaps you misspelled it.}}% +\fi +% \end{macrocode} +% +% Recognizing global options in packages not having a closed set of +% them is not trivial, as for them to be processed they must be +% defined explicitly. So, package options not yet taken into +% account and stored in |bbl@language@opts| are assumed to be +% languages (note this list also contains the language given with +% |main|). If not declared above, the name of the option and the +% file are the same. +% \begin{macrocode} +\bbl@for\bbl@tempa\bbl@language@opts{% + \@ifundefined{ds@\bbl@tempa}% + {\edef\bbl@tempb{% + \noexpand\DeclareOption + {\bbl@tempa}% + {\noexpand\bbl@load@language{\bbl@tempa}}}% + \bbl@tempb}% + \@empty} +% \end{macrocode} +% Now, we make sure an option is explicitly declared for any +% language set as global option, by checking if an |ldf| +% exists. The previous step was, in fact, somewhat redundant, but +% that way we minimize accesing the file system just to see if the +% option could be a language. +% \begin{macrocode} +\bbl@for\bbl@tempa\@classoptionslist{% + \@ifundefined{ds@\bbl@tempa}% + {\IfFileExists{\bbl@tempa.ldf}% + {\edef\bbl@tempb{% + \noexpand\DeclareOption + {\bbl@tempa}% + {\noexpand\bbl@load@language{\bbl@tempa}}}% + \bbl@tempb}% + \@empty}% + \@empty} +% \end{macrocode} +% If a main language has been set, store it for the third pass. +% \begin{macrocode} +\ifx\bbl@opt@main\@nnil\else + \expandafter + \let\expandafter\bbl@loadmain\csname ds@\bbl@opt@main\endcsname + \DeclareOption{\bbl@opt@main}{} +\fi +% \end{macrocode} +% And we are done, because all options for this pass has been +% declared. Those already processed in the first pass are just ignored. +% \changes{babel~3.6i}{1997/03/12}{Added default option} +% \changes{babel~3.9a}{2012/12/22}{Default option does nothing} +% +% The options have to be processed in the order in which the user +% specified them (except, of course, global options, which \LaTeX{} +% processes before): +% \begin{macrocode} +\def\AfterBabelLanguage#1{% + \bbl@ifsamestring\CurrentOption{#1}{\global\bbl@add\bbl@afterlang}{}} +\DeclareOption*{} +\ProcessOptions* +% \end{macrocode} +% This finished the second pass. Now the third one begins, which +% loads the main language set with the key |main|. A warning is +% raised if the main language is not the same as the last named +% one, or if the value of the key |main| is not a language. Then +% execute directly the option (because it could be used only in +% |main|). After loading all languages, we deactivate +% |\AfterBabelLanguage|. +% \begin{macrocode} +\ifx\bbl@opt@main\@nnil + \edef\bbl@tempa{\@classoptionslist,\bbl@language@opts} + \let\bbl@tempc\@empty + \bbl@for\bbl@tempb\bbl@tempa{% + \@expandtwoargs\in@{,\bbl@tempb,}{,\bbl@loaded,}% + \ifin@\edef\bbl@tempc{\bbl@tempb}\fi} + \def\bbl@tempa#1,#2\@nnil{\def\bbl@tempb{#1}} + \expandafter\bbl@tempa\bbl@loaded,\@nnil + \ifx\bbl@tempb\bbl@tempc\else + \bbl@warning{% + Last declared language option is `\bbl@tempc,\\% + but the last processed one was `\bbl@tempb'.\\% + The main language cannot be set as both a global\\% + and a package option. Use `main=\bbl@tempc' as\\% + option. Reported}% + \fi +\else + \DeclareOption{\bbl@opt@main}{\bbl@loadmain} + \ExecuteOptions{\bbl@opt@main} + \DeclareOption*{} + \ProcessOptions* +\fi +\def\AfterBabelLanguage{% + \bbl@error + {Too late for \string\AfterBabelLanguage}% + {Languages have been loaded, so I can do nothing}} +% \end{macrocode} +% \changes{babel~3.7c}{1999/03/13}{Added an error message for when no +% language option was specified} +% In order to catch the case where the user forgot to specify a +% language we check whether |\bbl@main@language|, has become +% defined. If not, no language has been loaded and an error +% message is displayed. +% \changes{babel~3.7c}{1999/04/09}{No longer us a redefinition of an +% internal macro, just check \cs{bbl@main@language} and load +% \file{babel.def}} +% \changes{babel~3.9a}{2012/06/24}{Now babel is not loaded to prevent +% the document from raising errors after fixing it} +% \begin{macrocode} +\ifx\bbl@main@language\@undefined + \bbl@error{% + You haven't specified a language option}{% + You need to specify a language, either as a global option\\% + or as an optional argument to the \string\usepackage\space + command;\\% + You shouldn't try to proceed from here, type x to quit.} +\fi +%</package> +% \end{macrocode} +% +% \section{The Kernel of Babel} +% +% The kernel of the \babel\ system is stored in either +% \file{hyphen.cfg} or \file{switch.def} and \file{babel.def}. The +% file \file{babel.def} contains most of the code, while +% \file{switch.def} defines the language switching commands; both +% can be read at run time. The file \file{hyphen.cfg} is a file +% that can be loaded into the format, which is necessary when you +% want to be able to switch hyphenation patterns (by default, it +% also inputs \file{switch.def}, for ``historical reasons'', but it +% is not necessary). When \file{babel.def} is loaded it checks if +% the current version of \file{switch.def} is in the format; if not +% it is loaded. A further file, \file{babel.sty}, contains +% \LaTeX-specific stuff. +% +% Because plain \TeX\ users might want to use some of the features +% of the \babel{} system too, care has to be taken that plain \TeX\ +% can process the files. For this reason the current format will +% have to be checked in a number of places. Some of the code below +% is common to plain \TeX\ and \LaTeX, some of it is for the +% \LaTeX\ case only. +% \changes{babel~3.9a}{2013/01/11}{Added \cs{bbl@for} for loops +% ignoring empties} +% \changes{babel~3.9c}{2013/04/06}{Normalize \cs{bbl@afterlang} to relax} +% +% \subsection{Tools} +% +% \begin{macrocode} +%<*core> +\ifx\bbl@opt@strings\@undefined + \def\bbl@opt@safe{BR} + \let\bbl@opt@strings\@nnil + \let\bbl@opt@shorthands\@nnil +\fi +\ifx\BabelModifiers\@undefined\let\BabelModifiers\relax\fi +\ifx\bbl@afterlang\@undefined\let\bbl@afterlang\relax\fi +\providecommand\AfterBabelLanguage[2]{} +\def\bbl@csarg#1#2{\expandafter#1\csname bbl@#2\endcsname}% +% \end{macrocode} +% +% \begin{macro}{\bbl@afterelse} +% \begin{macro}{\bbl@afterfi} +% Because the code that is used in the handling of active +% characters may need to look ahead, we take extra care to `throw' +% it over the |\else| and |\fi| parts of an +% |\if|-statement\footnote{This code is based on code presented in +% TUGboat vol. 12, no2, June 1991 in ``An expansion Power Lemma'' +% by Sonja Maus.}. These macros will break if another |\if...\fi| +% statement appears in one of the arguments and it is not enclosed +% in braces. +% \changes{babel~3.6i}{1997/02/20}{Made \cs{bbl@afterelse} and +% \cs{bbl@afterfi} \cs{long}} +% \begin{macrocode} +\long\def\bbl@afterelse#1\else#2\fi{\fi#1} +\long\def\bbl@afterfi#1\fi{\fi#1} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \changes{babel~3.9a}{2012/08/10}{Removed the \cs{peek@token} and +% \textsc{test@token} stuff} +% The macro |\initiate@active@char| takes all the necessary actions +% to make its argument a shorthand character. The real work is +% performed once for each character. +% \changes{babel~3.7c}{1999/04/30}{Only execute +% \cs{initiate@active@char} once for each character} +% \changes{babel~3.9a}{1999/04/30}{Added \cs{bbl@withactive}} +% \begin{macrocode} +\def\bbl@withactive#1#2{% + \begingroup + \lccode`~=`#2\relax + \lowercase{\endgroup#1~}} +% \end{macrocode} +% +% +% \begin{macro}{\bbl@redefine} +% \changes{babel~3.5f}{1995/11/15}{Macro added} +% To redefine a command, we save the old meaning of the macro. +% Then we redefine it to call the original macro with the +% `sanitized' argument. The reason why we do it this way is that +% we don't want to redefine the \LaTeX\ macros completely in case +% their definitions change (they have changed in the past). +% +% Because we need to redefine a number of commands we define the +% command |\bbl@redefine| which takes care of this. It creates a +% new control sequence, |\org@...| +% \begin{macrocode} +\def\bbl@redefine#1{% + \edef\bbl@tempa{\expandafter\@gobble\string#1}% + \expandafter\let\csname org@\bbl@tempa\endcsname#1% + \expandafter\def\csname\bbl@tempa\endcsname} +% \end{macrocode} +% +% This command should only be used in the preamble of the document. +% \begin{macrocode} +\@onlypreamble\bbl@redefine +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\bbl@redefine@long} +% \changes{babel~3.6f}{1997/01/14}{Macro added} +% This version of |\babel@redefine| can be used to redefine |\long| +% commands such as |\ifthenelse|. +% \begin{macrocode} +\def\bbl@redefine@long#1{% + \edef\bbl@tempa{\expandafter\@gobble\string#1}% + \expandafter\let\csname org@\bbl@tempa\endcsname#1% + \expandafter\long\expandafter\def\csname\bbl@tempa\endcsname} +\@onlypreamble\bbl@redefine@long +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\bbl@redefinerobust} +% \changes{babel~3.5f}{1995/11/15}{Macro added} +% \changes{babel~3.5f}{1996/04/09}{Define \cs*{foo } instead of +% \cs{foo}} +% For commands that are redefined, but which \textit{might} be +% robust we need a slightly more intelligent macro. A robust +% command |foo| is defined to expand to |\protect|\verb*|\foo |. So +% it is necessary to check whether \verb*|\foo | exists. The result +% is that the command that is being redefined is always robust +% afterwards. Therefor all we need to do now is define \verb*|\foo |. +% \begin{macrocode} +\def\bbl@redefinerobust#1{% + \edef\bbl@tempa{\expandafter\@gobble\string#1}% + \expandafter\ifx\csname\bbl@tempa\space\endcsname\relax + \expandafter\let\csname org@\bbl@tempa\endcsname#1% + \expandafter\edef\csname\bbl@tempa\endcsname{\noexpand\protect + \expandafter\noexpand\csname\bbl@tempa\space\endcsname}% + \else + \expandafter\let\csname org@\bbl@tempa\expandafter\endcsname + \csname\bbl@tempa\space\endcsname + \fi + \expandafter\def\csname\bbl@tempa\space\endcsname} +% \end{macrocode} +% +% This command should only be used in the preamble of the document. +% \begin{macrocode} +\@onlypreamble\bbl@redefinerobust +% \end{macrocode} +% \end{macro} +% +% \subsection{Encoding issues} +% +% The first thing we need to do is to determine, at +% |\begin{document}|, which latin fontencoding to use. +% +% \begin{macro}{\latinencoding} +% \changes{babel~3.6i}{1997/03/15}{Macro added, moved from +% \file{.ldf} files} +% When text is being typeset in an encoding other than `latin' +% (\texttt{OT1} or \texttt{T1}), it would be nice to still have +% Roman numerals come out in the Latin encoding. +% So we first assume that the current encoding at the end +% of processing the package is the Latin encoding. +% \begin{macrocode} +\AtEndOfPackage{\edef\latinencoding{\cf@encoding}} +% \end{macrocode} +% But this might be overruled with a later loading of the package +% \pkg{fontenc}. Therefor we check at the execution of +% |\begin{document}| whether it was loaded with the \Lopt{T1} +% option. The normal way to do this (using |\@ifpackageloaded|) is +% disabled for this package. Now we have to revert to parsing the +% internal macro |\@filelist| which contains all the filenames +% loaded. +% \changes{babel~3.6k}{1999/03/15}{Use T1 encoding when it is a known +% encoding} +% \changes{babel~3.6m}{1999/04/06}{Can't use \cs{@ifpackageloaded} +% need to parse \cs{@filelist}} +% \changes{babel~3.6n}{1999/04/07}{moved checking for fontenc right to +% the top of \file{babel.sty}} +% \changes{babel~3.6n}{1999/04/07}{Added a check for `manual' selection +% of \texttt{T1} encoding, without loading \pkg{fontenc}} +% \changes{babel~3.6q}{1999/04/12}{Better solution then parsing +% \cs{@filelist}, use \cs{@ifl@aded}} +% \changes{babel~3.6u}{1999/04/20}{Moved this code to +% \file{babel.def}} +% \begin{macrocode} +\AtBeginDocument{% + \gdef\latinencoding{OT1}% + \ifx\cf@encoding\bbl@t@one + \xdef\latinencoding{\bbl@t@one}% + \else + \@ifl@aded{def}{t1enc}{\xdef\latinencoding{\bbl@t@one}}{}% + \fi + } +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\latintext} +% \changes{babel~3.6i}{1997/03/15}{Macro added, moved from +% \file{.ldf} files} +% Then we can define the command |\latintext| which is a +% declarative switch to a latin font-encoding. +% \begin{macrocode} +\DeclareRobustCommand{\latintext}{% + \fontencoding{\latinencoding}\selectfont + \def\encodingdefault{\latinencoding}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\textlatin} +% \changes{babel~3.6i}{1997/03/15}{Macro added, moved from +% \file{.ldf} files} +% \changes{babel~3.7j}{2003/03/19}{added \cs{leavevmode} to prevent a +% paragraph starting \emph{inside} the group} +% \changes{babel~3.7k}{2003/10/12}{Use \cs{DeclareTextFontComand}} +% This command takes an argument which is then typeset using the +% requested font encoding. In order to avoid many encoding switches +% it operates in a local scope. +% \begin{macrocode} +\ifx\@undefined\DeclareTextFontCommand + \DeclareRobustCommand{\textlatin}[1]{\leavevmode{\latintext #1}} +\else + \DeclareTextFontCommand{\textlatin}{\latintext} +\fi +% \end{macrocode} +% +% The second version of this macro takes two arguments. The first +% argument is the name of the language that will be defined in the +% language definition file; the second argument is either a control +% sequence or a string from which a control sequence should be +% constructed. The existence of the control sequence indicates that +% the file has been processed before. +% +% At the start of processing a language definition file we always +% check the category code of the at-sign. We make sure that it is +% a `letter' during the processing of the file. We also save its +% name as the last called option, even if not loaded. +% +% Another character that needs to have the correct category code +% during processing of language definition files is the equals sign, +% `=', because it is sometimes used in constructions with the +% |\let| primitive. Therefor we store its current catcode and +% restore it later on. +% \changes{babel~3.7o}{2003/11/26}{make sure the equals sign has its +% default category code} +% +% Now we check whether we should perhaps stop the processing of +% this file. To do this we first need to check whether the second +% argument that is passed to |\LdfInit| is a control sequence. We +% do that by looking at the first token after passing |#2| through +% |string|. When it is equal to |\@backslashchar| we are dealing +% with a control sequence which we can compare with |\@undefined|. +% +% \changes{babel~3.9a}{2012/08/11}{\cs{ldf@quit} is not delayed any +% more after \cs{fi} , since \cs{endinput} is not executed immediately} +% If so, we call |\ldf@quit| to set the main language, restore the +% category code of the @-sign and call |\endinput| +% +% When |#2| was \emph{not} a control sequence we construct one and +% compare it with |\relax|. +% +% Finally we check |\originalTeX|. +% \begin{macrocode} +\def\LdfInit#1#2{% + \chardef\atcatcode=\catcode`\@ + \catcode`\@=11\relax + \chardef\eqcatcode=\catcode`\= + \catcode`\==12\relax + \expandafter\if\expandafter\@backslashchar + \expandafter\@car\string#2\@nil + \ifx#2\@undefined\else + \ldf@quit{#1}% + \fi + \else + \expandafter\ifx\csname#2\endcsname\relax\else + \ldf@quit{#1}% + \fi + \fi + \let\bbl@screset\@empty + \ifx\originalTeX\@undefined + \let\originalTeX\@empty + \else + \originalTeX + \fi} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\ldf@quit} +% \changes{babel~3.6a}{1996/10/29}{Macro added} +% This macro interrupts the processing of a language definition file. +% \changes{babel~3.7o}{2003/11/26}{Also restore the category code of +% the equals sign} +% \begin{macrocode} +\def\ldf@quit#1{% + \expandafter\main@language\expandafter{#1}% + \catcode`\@=\atcatcode \let\atcatcode\relax + \catcode`\==\eqcatcode \let\eqcatcode\relax + \endinput} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\ldf@finish} +% \changes{babel~3.6a}{1996/10/16}{Macro added} +% This macro takes one argument. It is the name of the language +% that was defined in the language definition file. +% +% We load the local configuration file if one is present, we set +% the main language (taking into account that the argument might be +% a control sequence that needs to be expanded) and reset the +% category code of the @-sign. +% \changes{babel~3.7o}{2003/11/26}{Also restore the category code of +% the equals sign} +% \changes{babel~3.9a}{2012/10/01}{Added \cs{bbl@afterlang} which +% executes the code delayed with \cs{AfterBabelLanguage}} +% \begin{macrocode} +\def\ldf@finish#1{% + \loadlocalcfg{#1}% + \bbl@afterlang + \let\bbl@afterlang\relax + \let\BabelModifiers\relax + \let\bbl@screset\relax + \expandafter\main@language\expandafter{#1}% + \catcode`\@=\atcatcode \let\atcatcode\relax + \catcode`\==\eqcatcode \let\eqcatcode\relax} +% \end{macrocode} +% \end{macro} +% +% After the preamble of the document the commands |\LdfInit|, +% |\ldf@quit| and |\ldf@finish| are no longer needed. Therefor +% they are turned into warning messages in \LaTeX. +% \begin{macrocode} +\@onlypreamble\LdfInit +\@onlypreamble\ldf@quit +\@onlypreamble\ldf@finish +% \end{macrocode} +% +% \begin{macro}{\main@language} +% \changes{babel~3.5a}{1995/02/17}{Macro added} +% \changes{babel~3.6a}{1996/10/16}{\cs{main@language} now also sets +% \cs{languagename} and \cs{l@languagename} for use by other +% packages in the preamble of a document} +% \begin{macro}{\bbl@main@language} +% \changes{babel~3.5a}{1995/02/17}{Macro added} +% This command should be used in the various language definition +% files. It stores its argument in |\bbl@main@language|; to be used +% to switch to the correct language at the beginning of the +% document. +% \changes{babel~3.8l}{2008/07/06}{Use \cs{bbl@patterns}} +% \begin{macrocode} +\def\main@language#1{% + \def\bbl@main@language{#1}% + \let\languagename\bbl@main@language + \bbl@patterns{\languagename}} +% \end{macrocode} +% +% We also have to make sure that some code gets executed at the +% beginning of the document. +% \begin{macrocode} +\AtBeginDocument{% + \expandafter\selectlanguage\expandafter{\bbl@main@language}} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \subsection{Support for active characters} +% +% \begin{macro}{\bbl@add@special} +% \changes{babel~3.2}{1991/11/10}{Added macro} +% The macro |\bbl@add@special| is used to add a new character (or +% single character control sequence) to the macro |\dospecials| +% (and |\@sanitize| if \LaTeX\ is used). +% +% To keep all changes local, we begin a new group. Then we +% redefine the macros |\do| and |\@makeother| to add themselves and +% the given character without expansion. +% +% To add the character to the macros, we expand the original macros +% with the additional character inside the redefinition of the +% macros. Because |\@sanitize| can be undefined, we put the +% definition inside a conditional. +% \begin{macrocode} +\def\bbl@add@special#1{% + \begingroup + \def\do{\noexpand\do\noexpand}% + \def\@makeother{\noexpand\@makeother\noexpand}% + \edef\x{\endgroup + \def\noexpand\dospecials{\dospecials\do#1}% + \expandafter\ifx\csname @sanitize\endcsname\relax \else + \def\noexpand\@sanitize{\@sanitize\@makeother#1}% + \fi}% + \x} +% \end{macrocode} +% The macro |\x| contains at this moment the following:\\ +% |\endgroup\def\dospecials{|\textit{old contents}% +% |\do|\meta{char}|}|.\\ +% If |\@sanitize| is defined, it contains an additional definition +% of this macro. The last thing we have to do, is the expansion of +% |\x|. Then |\endgroup| is executed, which restores the old +% meaning of |\x|, |\do| and |\@makeother|. After the group is +% closed, the new definition of |\dospecials| (and |\@sanitize|) is +% assigned. +% +% \end{macro} +% +% \begin{macro}{\bbl@remove@special} +% \changes{babel~3.2}{1991/11/10}{Added macro} +% The companion of the former macro is |\bbl@remove@special|. It +% is used to remove a character from the set macros |\dospecials| +% and |\@sanitize|. +% +% To keep all changes local, we begin a new group. Then we define +% a help macro |\x|, which expands to empty if the characters +% match, otherwise it expands to its nonexpandable input. Because +% \TeX\ inserts a |\relax|, if the corresponding |\else| or |\fi| +% is scanned before the comparison is evaluated, we provide a `stop +% sign' which should expand to nothing. +% +% With the help of this macro we define |\do| and |\make@other|. +% +% The rest of the work is similar to |\bbl@add@special|. +% \begin{macrocode} +\def\bbl@remove@special#1{% + \begingroup + \def\x##1##2{\ifnum`#1=`##2\noexpand\@empty + \else\noexpand##1\noexpand##2\fi}% + \def\do{\x\do}% + \def\@makeother{\x\@makeother}% + \edef\x{\endgroup + \def\noexpand\dospecials{\dospecials}% + \expandafter\ifx\csname @sanitize\endcsname\relax \else + \def\noexpand\@sanitize{\@sanitize}% + \fi}% + \x} +% \end{macrocode} +% \end{macro} +% +% \subsection{Shorthands} +% +% \begin{macro}{\initiate@active@char} +% \changes{babel~3.5a}{1995/02/11}{Added macro} +% \changes{babel~3.5b}{1995/03/03}{Renamed macro} +% A language definition file can call this macro to make a +% character active. This macro takes one argument, the character +% that is to be made active. When the character was already active +% this macro does nothing. Otherwise, this macro defines the +% control sequence |\normal@char|\m{char} to expand to the +% character in its `normal state' and it defines the active +% character to expand to |\normal@char|\m{char} by default +% (\m{char} being the character to be made active). Later its +% definition can be changed to expand to |\active@char|\m{char} +% by calling |\bbl@activate{|\m{char}|}|. +% +% For example, to make the double quote character active one could +% have |\initiate@active@char{"}| in a language definition file. +% This defines |"| as |\active@prefix "\active@char"| (where the +% first |"| is the character with its original catcode, when the +% shorthand is created, and |\active@char"| is a single token). In +% protected contexts, it expands to |\protect "| or |\noexpand "| +% (ie, with the original |"|); otherwise |\active@char"| is +% executed. This macro in turn expands to |\normal@char"| in +% ``safe'' contexts (eg, |\label|), but |\user@active"| in normal +% ``unsafe'' ones. The latter search a definition in the user, +% language and system levels, in this order, but if none is found, +% |\normal@char"| is used. However, a deactivated shorthand (with +% |\bbl@deactivate| is defined as |\active@prefix "\normal@char"|. +% +% The following macro is used to define shorthands in the three +% levels. It takes 4 arguments: the (string'ed) character, +% |\<level>@group|, |<level>@active| and |<next-level>@active| +% (except in |system|). +% \changes{babel~3.9a}{2012/08/18}{New macro, with code from +% \cs{@initiate@active@char}} +% \begin{macrocode} +\def\bbl@active@def#1#2#3#4{% + \@namedef{#3#1}{% + \expandafter\ifx\csname#2@sh@#1@\endcsname\relax + \bbl@afterelse\bbl@sh@select#2#1{#3@arg#1}{#4#1}% + \else + \bbl@afterfi\csname#2@sh@#1@\endcsname + \fi}% +% \end{macrocode} +% When there is also no current-level shorthand with an argument we +% will check whether there is a next-level defined shorthand for +% this active character. +% \changes{babel~3.7e}{1999/09/24}{pass the argument on with braces in +% order to prevent it from breaking up} +% \changes{babel~3.7f}{2000/02/18}{remove the braces again} +% \begin{macrocode} + \long\@namedef{#3@arg#1}##1{% + \expandafter\ifx\csname#2@sh@#1@\string##1@\endcsname\relax + \bbl@afterelse\csname#4#1\endcsname##1% + \else + \bbl@afterfi\csname#2@sh@#1@\string##1@\endcsname + \fi}}% +% \end{macrocode} +% \changes{babel~3.9a}{2012/08/18}{Removed an extra hash. Now calls +% \cs{@initiate@active@char} with 3 arguments.} +% |\initiate@active@char| calls |\@initiate@active@char| with 3 +% arguments. All of them are the same character with different +% catcodes: active, other (string'ed) and the original one. +% \begin{macrocode} +\def\initiate@active@char#1{% + \expandafter\ifx\csname active@char\string#1\endcsname\relax + \bbl@withactive + {\expandafter\@initiate@active@char\expandafter}#1\string#1#1% + \fi} +% \end{macrocode} +% \changes{babel~3.9e}{2012/08/18}{Introduced the 3-argument +% \cs{@initiate@active@char}, with different catcodes: active, +% string'ed, and original. Reorganized} +% \changes{babel~3.9a}{2012/08/19}{The catcode is saved} +% \changes{babel~3.9a}{2012/09/09}{The original definition is saved, +% too} +% \changes{babel~3.9a}{2012/12/27}{Take into account mathematically +% active chars, to avoid infinite loops} +% The very first thing to do is saving the original catcode and the +% original definition, even if not active, which is possible +% (undefined characters require a special treatement to avoid +% making them |\relax|). +% \begin{macrocode} +\def\@initiate@active@char#1#2#3{% + \expandafter\edef\csname bbl@oricat@#2\endcsname{% + \catcode`#2=\the\catcode`#2\relax}% + \ifx#1\@undefined + \expandafter\edef\csname bbl@oridef@#2\endcsname{% + \let\noexpand#1\noexpand\@undefined}% + \else + \expandafter\let\csname bbl@oridef@@#2\endcsname#1% + \expandafter\edef\csname bbl@oridef@#2\endcsname{% + \let\noexpand#1% + \expandafter\noexpand\csname bbl@oridef@@#2\endcsname}% + \fi +% \end{macrocode} +% If the character is already active we provide the default +% expansion under this shorthand mechanism. Otherwise we write a +% message in the transcript file, and define |\normal@char|\m{char} +% to expand to the character in its default state. If the character +% is mathematically active when \babel{} is loaded (for example +% |'|) the normal expansion is somewhat different to avoid an +% infinite loop (but it does not prevent the loop if the mathcode +% is set to |"8000| \textit{a posteriori}). +% \begin{macrocode} + \ifx#1#3\relax + \expandafter\let\csname normal@char#2\endcsname#3% + \else + \bbl@info{Making #2 an active character}% + \ifnum\mathcode`#2="8000 + \@namedef{normal@char#2}{% + \textormath{#3}{\csname bbl@oridef@@#2\endcsname}}% + \else + \@namedef{normal@char#2}{#3}% + \fi +% \end{macrocode} +% To prevent problems with the loading of other packages after +% \babel\ we reset the catcode of the character to the original one +% at the end of the package and of each language file (except with +% \textsf{KeepShorthandsActive}). It is re-activate again at +% |\begin{document}|. We also need to make sure that the +% shorthands are active during the processing of the \file{.aux} +% file. Otherwise some citations may give unexpected results in +% the printout when a shorthand was used in the optional argument +% of |\bibitem| for example. +% \changes{babel~3.6i}{1997/03/01}{Make shorthands active during +% \file{.aux} file processing}. Then we +% make it active (not strictly necessary, but done for backward +% compatibility). +% \changes{babel~3.5f}{1995/12/01}{Restore the category code of a +% shorthand char at end of package} +% \changes{babel~3.6f}{1997/01/14}{Made restoring of the category code +% of shorthand characters optional} +% \changes{babel~3.7a}{1997/03/21}{Use \cs{@ifpackagewith} to +% determine whether shorthand characters need to remain active} +% \begin{macrocode} + \bbl@restoreactive{#2}% + \AtBeginDocument{% + \catcode`#2\active + \if@filesw + \immediate\write\@mainaux{\catcode`\string#2\active}% + \fi}% + \expandafter\bbl@add@special\csname#2\endcsname + \catcode`#2\active + \fi +% \end{macrocode} +% Now we have set |\normal@char|\m{char}, we must define +% |\active@char|\m{char}, to be executed when the character is +% activated. We define the first level expansion of +% |\active@char|\m{char} to check the status of the |@safe@actives| +% flag. If it is set to true we expand to the `normal' version of +% this character, otherwise we call |\user@active|\m{char} to start +% the search of a definition in the user, language and system +% levels (or eventually |normal@char|\m{char}). +% \changes{babel~3.9a}{2012/12/27}{Added code for option math=normal} +% \begin{macrocode} + \let\bbl@tempa\@firstoftwo + \if\string^#2% + \def\bbl@tempa{\noexpand\textormath}% + \else + \ifx\bbl@mathnormal\@undefined\else + \let\bbl@tempa\bbl@mathnormal + \fi + \fi + \expandafter\edef\csname active@char#2\endcsname{% + \bbl@tempa + {\noexpand\if@safe@actives + \noexpand\expandafter + \expandafter\noexpand\csname normal@char#2\endcsname + \noexpand\else + \noexpand\expandafter + \expandafter\noexpand\csname user@active#2\endcsname + \noexpand\fi}% + {\expandafter\noexpand\csname normal@char#2\endcsname}}% +% \end{macrocode} +% +% \changes{babel~3.9a}{2012/12/27}{Shorthands are not defined +% directly, but with a couple of intermediate macros} +% +% We now define the default values which the shorthand is set to +% when activated or deactivated. It is set to the deactivated form +% (globally), so that the character expands to +% \begin{center} +% |\active@prefix| \m{char} |\normal@char|\m{char} +% \end{center} +% (where |\active@char|\m{char} is \emph{one} control sequence!). +% +% \begin{macrocode} + \bbl@csarg\edef{active@#2}{% + \noexpand\active@prefix\noexpand#1% + \expandafter\noexpand\csname active@char#2\endcsname}% + \bbl@csarg\edef{normal@#2}{% + \noexpand\active@prefix\noexpand#1% + \expandafter\noexpand\csname normal@char#2\endcsname}% + \expandafter\let\expandafter#1\csname bbl@normal@#2\endcsname +% \end{macrocode} +% The next level of the code checks whether a user has defined a +% shorthand for himself with this character. First we check for a +% single character shorthand. If that doesn't exist we check for a +% shorthand with an argument. +% \changes{babel~3.5d}{1995/07/02}{Skip the user-level active char +% with argument if no shorthands with arguments were defined} +% \changes{babel~3.8b}{2004/04/19}{Now use \cs{bbl@sh@select}} +% \changes{babel~3.9a}{2012/08/18}{Instead of the ``copy-paste pattern'' +% a new macro is used} +% \begin{macrocode} + \bbl@active@def#2\user@group{user@active}{language@active}% + \bbl@active@def#2\language@group{language@active}{system@active}% + \bbl@active@def#2\system@group{system@active}{normal@char}% +% \end{macrocode} +% In order to do the right thing when a shorthand with an argument +% is used by itself at the end of the line we provide a definition +% for the case of an empty argument. For that case we let the +% shorthand character expand to its non-active self. Also, When a +% shorthand combination such as |''| ends up in a heading \TeX\ +% would see |\protect'\protect'|. To prevent this from happening a +% couple of shorthand needs to be defined at user level. +% \changes{babel~3.7f}{1999/12/09}{Added an extra shorthand +% combination on user level to catch an interfering \cs{protect}} +% \changes{babel~3.9a}{2012/8/18}{Use \cs{user@group}, as above, +% instead of the hardwired \texttt{user}} +% \begin{macrocode} + \expandafter\edef\csname\user@group @sh@#2@@\endcsname + {\expandafter\noexpand\csname normal@char#2\endcsname}% + \expandafter\edef\csname\user@group @sh@#2@\string\protect@\endcsname + {\expandafter\noexpand\csname user@active#2\endcsname}% +% \end{macrocode} +% Finally, a couple of special cases are taken care of. (1) If we +% are making the right quote (|'|) active we need to change |\pr@m@s| as +% well. Also, make sure that a single |'| in math mode `does the +% right thing'. (2) If we are using the caret (|^|) as a shorthand +% character special care should be taken to make sure math still +% works. Therefor an extra level of expansion is introduced with a +% check for math mode on the upper level. +% +% \changes{babel~3.7f}{1999/12/18}{Insert a check for math mode in +% the definition of \cs{normal@char'}} +% \changes{babel~3.7g}{2000/10/02}{use \cs{textormath} to get rid +% of the \cs{fi} (PR 3266)} +% \changes{babel~3.7f}{1999/12/18}{The redefinition needs to take +% place one level higher, \cs{prim@s} needs to be redefined.} +% \changes{babel~3.7f}{1999/12/18}{Introduced an extra +% level of expansion in the definition of an active caret} +% \changes{babel~3.7f}{2000/09/25}{Make an exception for the active +% caret which needs an extra level of expansion} +% \changes{babel~3.9a}{2012/09/11}{The output routine resets the quote +% to \cs{active@math@prime}, so we redefine the latter with the new +% ``normal'' value} +% \changes{babel~3.9a}{2012/06/20}{Added a couple of missing +% comment characters (PR 4146)} +% \changes{babel~3.9a}{2012/07/29}{Use \cs{textormath} instead of +% \cs{ifmath}} +% \changes{babel~3.9a}{2012/11/26}{Compare the char, irrespective of +% its catcode.} +% \changes{babel~3.9a}{2012/12/27}{Removed the redeclaration of +% \cs{normal@char'} because it is handled in a generic way above} +% \changes{babel~3.9a}{2012/12/29}{Removed the intermediate step of +% \cs{bbl@act@caret} and moved above} +% \begin{macrocode} + \if\string'#2% + \let\prim@s\bbl@prim@s + \let\active@math@prime#1% + \fi} +% \end{macrocode} +% +% Initiating a shorthand makes active the char. That is not +% strictly necessary but it is still done for backward +% compatibility. So we need to restore the original catcode at the +% end of package \textit{and} and the end of the |ldf|. +% +% \changes{babel~3.9a}{2012/07/04}{Catcodes are also restored after +% each language, to prevent incompatibilities. Use \cs{string} instead +% of \cs{noexpand} and add \cs{relax}} +% \changes{babel~3.9a}{2012/10/18}{Catcodes are deactivated in a separate +% macro, which is made no-op when babel exits} +% +% \begin{macrocode} +\@ifpackagewith{babel}{KeepShorthandsActive}% + {\let\bbl@restoreactive\@gobble}% + {\def\bbl@restoreactive#1{% + \edef\bbl@tempa{% + \noexpand\AfterBabelLanguage\noexpand\CurrentOption + {\catcode`#1=\the\catcode`#1\relax}% + \noexpand\AtEndOfPackage{\catcode`#1=\the\catcode`#1\relax}}% + \bbl@tempa}% + \AtEndOfPackage{\let\bbl@restoreactive\@gobble}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\bbl@sh@select} +% This command helps the shorthand supporting macros to select how +% to proceed. Note that this macro needs to be expandable as do all +% the shorthand macros in order for them to work in expansion-only +% environments such as the argument of |\hyphenation|. +% +% This macro expects the name of a group of shorthands in its first +% argument and a shorthand character in its second argument. It +% will expand to either |\bbl@firstcs| or |\bbl@scndcs|. Hence two +% more arguments need to follow it. +% \changes{babel~3.8b}{2004/04/19}{Added command} +% \changes{babel~3.9a}{2012/08/18}{Removed \cs{string}s, because the +% char are already string'ed} +% \begin{macrocode} +\def\bbl@sh@select#1#2{% + \expandafter\ifx\csname#1@sh@#2@sel\endcsname\relax + \bbl@afterelse\bbl@scndcs + \else + \bbl@afterfi\csname#1@sh@#2@sel\endcsname + \fi} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\active@prefix} +% The command |\active@prefix| which is used in the expansion of +% active characters has a function similar to |\OT1-cmd| in that it +% |\protect|s the active character whenever |\protect| is +% \emph{not} |\@typeset@protect|. +% \changes{babel~3.5d}{1995/07/02}{\cs{@protected@cmd} has vanished +% from \file{ltoutenc.dtx}} +% \changes{babel~3.7o}{2003/11/17}{Added handling of the situation +% where \cs{protect} is set to \cs{@unexpandable@protect}} +% \begin{macrocode} +\def\active@prefix#1{% + \ifx\protect\@typeset@protect + \else +% \end{macrocode} +% When |\protect| is set to |\@unexpandable@protect| we make sure +% that the active character is als \emph{not} expanded by inserting +% |\noexpand| in front of it. The |\@gobble| is needed to remove +% a token such as |\activechar:| (when the double colon was the +% active character to be dealt with). +% \begin{macrocode} + \ifx\protect\@unexpandable@protect + \noexpand#1% + \else + \protect#1% + \fi + \expandafter\@gobble + \fi} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\if@safe@actives} +% In some circumstances it is necessary to be able to change the +% expansion of an active character on the fly. For this purpose the +% switch |@safe@actives| is available. The setting of this switch +% should be checked in the first level expansion of +% |\active@char|\m{char}. +% \begin{macrocode} +\newif\if@safe@actives +\@safe@activesfalse +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\bbl@restore@actives} +% \changes{babel~3.7m}{2003/11/15}{New macro added} +% When the output routine kicks in while the +% active characters were made ``safe'' this must be undone in +% the headers to prevent unexpected typeset results. For this +% situation we define a command to make them ``unsafe'' again. +% \begin{macrocode} +\def\bbl@restore@actives{\if@safe@actives\@safe@activesfalse\fi} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\bbl@activate} +% \begin{macro}{\bbl@deactivate} +% \changes{babel~3.5a}{1995/02/11}{Added macro} +% \changes{babel~3.9a}{2013/01/11}{\cs{bbl@withactive} makes sure the +% catcode is active} +% Both macros take one argument, like |\initiate@active@char|. The +% macro is used to change the definition of an active character to +% expand to |\active@char|\m{char} in the case of |\bbl@activate|, +% or |\normal@char|\m{char} in the case of +% |\bbl@deactivate|. +% \begin{macrocode} +\def\bbl@activate#1{% + \bbl@withactive{\expandafter\let\expandafter}#1% + \csname bbl@active@\string#1\endcsname} +\def\bbl@deactivate#1{% + \bbl@withactive{\expandafter\let\expandafter}#1% + \csname bbl@normal@\string#1\endcsname} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\bbl@firstcs} +% \begin{macro}{\bbl@scndcs} +% These macros have two arguments. They use one of their arguments +% to build a control sequence from. +% \begin{macrocode} +\def\bbl@firstcs#1#2{\csname#1\endcsname} +\def\bbl@scndcs#1#2{\csname#2\endcsname} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\declare@shorthand} +% The command |\declare@shorthand| is used to declare a shorthand +% on a certain level. It takes three arguments: +% \begin{enumerate} +% \item a name for the collection of shorthands, i.e. `system', or +% `dutch'; +% \item the character (sequence) that makes up the shorthand, +% i.e. |~| or |"a|; +% \item the code to be executed when the shorthand is encountered. +% \end{enumerate} +% \changes{babel~3.5d}{1995/07/02}{Make a `note' when a shorthand with +% an argument is defined.} +% \changes{babel~3.6i}{1997/02/23}{Make it possible to distinguish the +% constructed control sequences for the case with argument} +% \changes{babel~3.8b}{2004/04/19}{We need to support shorthands with +% and without argument in different groups; added the name of the +% group to the storage macro} +% \changes{babel~3.9a}{2012/07/03}{Check if shorthands are redefined} +% \begin{macrocode} +\def\declare@shorthand#1#2{\@decl@short{#1}#2\@nil} +\def\@decl@short#1#2#3\@nil#4{% + \def\bbl@tempa{#3}% + \ifx\bbl@tempa\@empty + \expandafter\let\csname #1@sh@\string#2@sel\endcsname\bbl@scndcs + \@ifundefined{#1@sh@\string#2@}{}% + {\def\bbl@tempa{#4}% + \expandafter\ifx\csname#1@sh@\string#2@\endcsname\bbl@tempa + \else + \bbl@info + {Redefining #1 shorthand \string#2\\% + in language \CurrentOption}% + \fi}% + \@namedef{#1@sh@\string#2@}{#4}% + \else + \expandafter\let\csname #1@sh@\string#2@sel\endcsname\bbl@firstcs + \@ifundefined{#1@sh@\string#2@\string#3@}{}% + {\def\bbl@tempa{#4}% + \expandafter\ifx\csname#1@sh@\string#2@\string#3@\endcsname\bbl@tempa + \else + \bbl@info + {Redefining #1 shorthand \string#2\string#3\\% + in language \CurrentOption}% + \fi}% + \@namedef{#1@sh@\string#2@\string#3@}{#4}% + \fi} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\textormath} +% Some of the shorthands that will be declared by the language +% definition files have to be usable in both text and mathmode. To +% achieve this the helper macro |\textormath| is provided. +% \changes{babel~3.9a}{2012/12/29}{Failed if an argument had a +% condicional. Use the more robust mechanism of \cs{XXXoftwo}} +% \begin{macrocode} +\def\textormath{% + \ifmmode + \expandafter\@secondoftwo + \else + \expandafter\@firstoftwo + \fi} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\user@group} +% \begin{macro}{\language@group} +% \begin{macro}{\system@group} +% The current concept of `shorthands' supports three levels or +% groups of shorthands. For each level the name of the level or +% group is stored in a macro. The default is to have a user group; +% use language group `english' and have a system group called +% `system'. +% \changes{babel~3.6i}{1997/02/24}{Have a user group called `user' by +% default} +% \begin{macrocode} +\def\user@group{user} +\def\language@group{english} +\def\system@group{system} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\useshorthands} +% This is the user level command to tell \LaTeX\ that user level +% shorthands will be used in the document. It takes one argument, +% the character that starts a shorthand. First note that this is +% user level, and then initialize and activate the character for +% use as a shorthand character (ie, it's active in the +% preamble). Languages can deactivate shorthands, so a starred +% version is also provided which activates them always after the +% language has been switched. +% +% \changes{babel~3.7j}{2001/11/11}{When \TeX\ has seen a character +% its category code is fixed; need to use a `stand-in' for the +% call of \cs{bbl@activate}} +% \changes{babel~3.7j}{2003/09/11}{The change from 11/112001 was +% incomplete} +% \changes{babel~3.9a}{2012/08/05}{Now \cs{bbl@activate} makes sure +% the catcode is active, so this part is simplified} +% \changes{babel~3.9a}{2012/08/12}{User shorhands can be +% defined even with shorthands=off} +% \begin{macrocode} +\def\useshorthands{% + \@ifstar\bbl@usesh@s{\bbl@usesh@x{}}} +\def\bbl@usesh@s#1{% + \bbl@usesh@x + {\AddBabelHook{babel-sh-\string#1}{afterextras}{\bbl@activate{#1}}}% + {#1}} +\def\bbl@usesh@x#1#2{% + \bbl@ifshorthand{#2}% + {\def\user@group{user}% + \initiate@active@char{#2}% + #1% + \bbl@activate{#2}}% + {\bbl@error + {Cannot declare a shorthand turned off (\string#2)} + {Sorry, but you cannot use shorthands which have been\\% + turned off in the package options}}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\defineshorthand} +% \changes{babel~3.9a}{2012/08/05}{Added optional argument, to provide +% a way to (re)define language shorthands} +% \changes{babel~3.9a}{2012/08/25}{Extended for language-dependent +% user macros, with two new auxiliary macros} +% Currently we only support two groups of user level shorthands, +% named internally |user| and |user@<lang>| (language-dependent +% user shorthands). By default, only the first one is taken into +% account, but if the former is also used (in the optional argument +% of |\defineshorthand|) a new level is inserted for it +% (|user@generic|, done by |\bbl@set@user@generic|); we make also +% sure |{}| and |\protect| are taken into account in this new top +% level. +% \begin{macrocode} +\def\user@language@group{user@\language@group} +\def\bbl@set@user@generic#1#2{% + \@ifundefined{user@generic@active#1}% + {\bbl@active@def#1\user@language@group{user@active}{user@generic@active}% + \bbl@active@def#1\user@group{user@generic@active}{language@active}% + \expandafter\edef\csname#2@sh@#1@@\endcsname{% + \expandafter\noexpand\csname normal@char#1\endcsname}% + \expandafter\edef\csname#2@sh@#1@\string\protect@\endcsname{% + \expandafter\noexpand\csname user@active#1\endcsname}}% + \@empty} +\newcommand\defineshorthand[3][user]{% + \edef\bbl@tempa{\zap@space#1 \@empty}% + \bbl@for\bbl@tempb\bbl@tempa{% + \if*\expandafter\@car\bbl@tempb\@nil + \edef\bbl@tempb{user@\expandafter\@gobble\bbl@tempb}% + \@expandtwoargs + \bbl@set@user@generic{\expandafter\string\@car#2\@nil}\bbl@tempb + \fi + \declare@shorthand{\bbl@tempb}{#2}{#3}}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\languageshorthands} +% A user level command to change the language from which shorthands +% are used. Unfortunately, \babel{} currently does not keep track +% of defined groups, and therefore there is no way to catch a +% possible change in casing. +% \begin{macrocode} +\def\languageshorthands#1{\def\language@group{#1}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\aliasshorthand} +% \changes{babel~3.5f}{1996/01/25}{New command} +% First the new shorthand needs to be initialized, +% \begin{macrocode} +\def\aliasshorthand#1#2{% + \bbl@ifshorthand{#2}% + {\expandafter\ifx\csname active@char\string#2\endcsname\relax + \ifx\document\@notprerr + \@notshorthand{#2}% + \else + \initiate@active@char{#2}% +% \end{macrocode} +% \changes{babel~3.9a}{2012/08/06}{Instead of letting the new shorthand to +% the original char, which very often didn't work, we define it +% directly} +% \changes{babel~3.9a}{2012/08/20}{Make sure both characters (old an +% new) are active} +% Then, we define the new shorthand in terms of the original +% one, but note with |\aliasshorthands{"}{/}| is +% |\active@prefix /\active@char/|, so we still need to let the +% lattest to |\active@char"|. +% \begin{macrocode} + \expandafter\let\csname active@char\string#2\expandafter\endcsname + \csname active@char\string#1\endcsname + \expandafter\let\csname normal@char\string#2\expandafter\endcsname + \csname normal@char\string#1\endcsname + \bbl@activate{#2}% + \fi + \fi}% + {\bbl@error + {Cannot declare a shorthand turned off (\string#2)} + {Sorry, but you cannot use shorthands which have been\\% + turned off in the package options}}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\@notshorthand} +% \changes{v3.8d}{2004/11/20}{Error message added} +% +% \begin{macrocode} +\def\@notshorthand#1{% + \bbl@error{% + The character `\string #1' should be made a shorthand character;\\% + add the command \string\useshorthands\string{#1\string} to + the preamble.\\% + I will ignore your instruction}{}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\shorthandon} +% \changes{babel~3.7a}{1998/06/07}{Added command} +% \begin{macro}{\shorthandoff} +% \changes{babel~3.7a}{1998/06/07}{Added command} +% \changes{babel~3.9a}{2012/09/08}{Added code fo the starred variant +% of \cs{shorthandoff}} +% The first level definition of these macros just passes the +% argument on to |\bbl@switch@sh|, adding |\@nil| at the end to +% denote the end of the list of characters. +% \begin{macrocode} +\newcommand*\shorthandon[1]{\bbl@switch@sh\@ne#1\@nnil} +\DeclareRobustCommand*\shorthandoff{% + \@ifstar{\bbl@shorthandoff\tw@}{\bbl@shorthandoff\z@}} +\def\bbl@shorthandoff#1#2{\bbl@switch@sh#1#2\@nnil} +% \end{macrocode} +% +% \begin{macro}{\bbl@switch@sh} +% \changes{babel~3.7a}{1998/06/07}{Added command} +% \changes{babel~3.9a}{2013/02/21}{Code revised} +% The macro |\bbl@switch@sh| takes the list of characters apart one +% by one and subsequently switches the category code of the +% shorthand character according to the first argument of +% |\bbl@switch@sh|. +% +% But before any of this switching takes place we make sure that +% the character we are dealing with is known as a shorthand +% character. If it is, a macro such as |\active@char"| should +% exist. +% +% Switching off and on is easy -- we just set the category +% code to `other' (12) and |\active|. With the starred version, the +% original catcode and the original definition, saved +% in |@initiate@active@char|, are restored. +% +% \begin{macrocode} +\def\bbl@switch@sh#1#2{% + \ifx#2\@nnil\else + \@ifundefined{bbl@active@\string#2}% + {\bbl@error + {I cannot switch `\string#2' on or off--not a shorthand}% + {This character is not a shorthand. Maybe you made\\% + a typing mistake? I will ignore your instruction}}% + {\ifcase#1% + \catcode`#212\relax + \or + \catcode`#2\active + \or + \csname bbl@oricat@\string#2\endcsname + \csname bbl@oridef@\string#2\endcsname + \fi}% + \bbl@afterfi\bbl@switch@sh#1% + \fi} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% \subsection{Conditional loading of shorthands} +% +% \changes{babel~3.9a}{2012/06/16}{Added code} +% +% Note the value is that at the expansion time, eg, in the preample +% shorhands are usually deactivated. +% \begin{macrocode} +\def\babelshorthand{\active@prefix\babelshorthand\bbl@putsh} +\def\bbl@putsh#1{% + \@ifundefined{bbl@active@\string#1}% + {\bbl@putsh@i#1\@empty\@nnil}% + {\csname bbl@active@\string#1\endcsname}} +\def\bbl@putsh@i#1#2\@nnil{% + \csname\languagename @sh@\string#1@% + \ifx\@empty#2\else\string#2@\fi\endcsname} +\ifx\bbl@opt@shorthands\@nnil\else + \let\bbl@s@initiate@active@char\initiate@active@char + \def\initiate@active@char#1{% + \bbl@ifshorthand{#1}{\bbl@s@initiate@active@char{#1}}{}} + \let\bbl@s@switch@sh\bbl@switch@sh + \def\bbl@switch@sh#1#2{% + \ifx#2\@nnil\else + \bbl@afterfi + \bbl@ifshorthand{#2}{\bbl@s@switch@sh#1{#2}}{\bbl@switch@sh#1}% + \fi} + \let\bbl@s@activate\bbl@activate + \def\bbl@activate#1{% + \bbl@ifshorthand{#1}{\bbl@s@activate{#1}}{}} + \let\bbl@s@deactivate\bbl@deactivate + \def\bbl@deactivate#1{% + \bbl@ifshorthand{#1}{\bbl@s@deactivate{#1}}{}} +\fi +% \end{macrocode} +% +% \changes{babel~3.9a}{2012/12/27}{Removed redundant system declarations} +% +% \begin{macro}{\bbl@prim@s} +% \changes{babel~3.7f}{1999/12/01}{Need to redefine \cs{prim@s} as +% well as plain \TeX's definition uses \cs{next}} +% \begin{macro}{\bbl@pr@m@s} +% \changes{babel~3.5a}{1995/03/10}{Added macro} +% \changes{babel~3.9a}{2012/07/29}{\cs{bbl@pr@m@s} rewritten to +% take into account catcodes for both the quote and the hat} +% One of the internal macros that are involved in substituting +% |\prime| for each right quote in mathmode is |\prim@s|. This +% checks if the next character is a right quote. When the right +% quote is active, the definition of this macro needs to be adapted +% to look also for an active right quote; the hat could be active, +% too. +% \begin{macrocode} +\def\bbl@prim@s{% + \prime\futurelet\@let@token\bbl@pr@m@s} +\def\bbl@if@primes#1#2{% + \ifx#1\@let@token + \expandafter\@firstoftwo + \else\ifx#2\@let@token + \bbl@afterelse\expandafter\@firstoftwo + \else + \bbl@afterfi\expandafter\@secondoftwo + \fi\fi} +\begingroup + \catcode`\^=7 \catcode`\*=\active \lccode`\*=`\^ + \catcode`\'=12 \catcode`\"=\active \lccode`\"=`\' + \lowercase{% + \gdef\bbl@pr@m@s{% + \bbl@if@primes"'% + \pr@@@s + {\bbl@if@primes*^\pr@@@t\egroup}}} +\endgroup +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% Usually the |~| is active and expands to \verb*=\penalty\@M\ =. +% When it is written to the \file{.aux} file it is written +% expanded. To prevent that and to be able to use the character |~| +% as a start character for a shorthand, it is redefined here as a +% one character shorthand on system level. The system declaration +% is in most cases redundant (when |~| is still a non-break space), +% and in some cases is inconvenient (if |~| has been redefined); +% however, for backward compatibility it is maintained (some +% existing documents may rely on the \babel{} value). +% \begin{macrocode} +\initiate@active@char{~} +\declare@shorthand{system}{~}{\leavevmode\nobreak\ } +\bbl@activate{~} +% \end{macrocode} +% +% \begin{macro}{\OT1dqpos} +% \begin{macro}{\T1dqpos} +% The position of the double quote character is different for the +% OT1 and T1 encodings. It will later be selected using the +% |\f@encoding| macro. Therefor we define two macros here to store +% the position of the character in these encodings. +% \begin{macrocode} +\expandafter\def\csname OT1dqpos\endcsname{127} +\expandafter\def\csname T1dqpos\endcsname{4} +% \end{macrocode} +% When the macro |\f@encoding| is undefined (as it is in plain +% \TeX) we define it here to expand to \texttt{OT1} +% \begin{macrocode} +\ifx\f@encoding\@undefined + \def\f@encoding{OT1} +\fi +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \subsection{Language attributes} +% +% Language attributes provide a means to give the user control over +% which features of the language definition files he wants to +% enable. +% \changes{babel~3.7c}{1998/07/02}{Added support for language +% attributes} +% \begin{macro}{\languageattribute} +% \changes{babel~3.9a}{2012/09/07}{Use \cs{@expandtwoargs} with \cs{in@}} +% The macro |\languageattribute| checks whether its arguments are +% valid and then activates the selected language attribute. +% First check whether the language is known, and then process each +% attribute in the list. +% \begin{macrocode} +\newcommand\languageattribute[2]{% + \def\bbl@tempc{#1}% + \bbl@fixname\bbl@tempc + \bbl@iflanguage\bbl@tempc{% + \@for\bbl@attr:=#2\do{% +% \end{macrocode} +% We want to make sure that each attribute is selected only once; +% therefor we store the already selected attributes in +% |\bbl@known@attribs|. When that control sequence is not yet +% defined this attribute is certainly not selected before. +% \begin{macrocode} + \ifx\bbl@known@attribs\@undefined + \in@false + \else +% \end{macrocode} +% Now we need to see if the attribute occurs in the list of +% already selected attributes. +% \begin{macrocode} + \@expandtwoargs\in@{,\bbl@tempc-\bbl@attr,}{,\bbl@known@attribs,}% + \fi +% \end{macrocode} +% When the attribute was in the list we issue a warning; this might +% not be the users intention. +% \begin{macrocode} + \ifin@ + \bbl@warning{% + You have more than once selected the attribute '\bbl@attr'\\% + for language #1}% + \else +% \end{macrocode} +% When we end up here the attribute is not selected before. So, we +% add it to the list of selected attributes and execute the +% associated \TeX-code. +% \begin{macrocode} + \edef\bbl@tempa{% + \noexpand\bbl@add@list + \noexpand\bbl@known@attribs{\bbl@tempc-\bbl@attr}}% + \bbl@tempa + \edef\bbl@tempa{\bbl@tempc-\bbl@attr}% + \expandafter\bbl@ifknown@ttrib\expandafter{\bbl@tempa}\bbl@attributes% + {\csname\bbl@tempc @attr@\bbl@attr\endcsname}% + {\@attrerr{\bbl@tempc}{\bbl@attr}}% + \fi}}} +% \end{macrocode} +% This command should only be used in the preamble of a document. +% \begin{macrocode} +\@onlypreamble\languageattribute +% \end{macrocode} +% The error text to be issued when an unknown attribute is +% selected. +% \begin{macrocode} +\newcommand*{\@attrerr}[2]{% + \bbl@error + {The attribute #2 is unknown for language #1.}% + {Your command will be ignored, type <return> to proceed}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\bbl@declare@ttribute} +% This command adds the new language/attribute combination to the +% list of known attributes. +% +% Then it defines a control sequence to be executed when the +% attribute is used in a document. The result of this should be +% that the macro |\extras...| for the current language is extended, +% otherwise the attribute will not work as its code is removed from +% memory at |\begin{document}|. +% \begin{macrocode} +\def\bbl@declare@ttribute#1#2#3{% + \@expandtwoargs\in@{,#2,}{,\BabelModifiers,}% + \ifin@ + \AfterBabelLanguage{#1}{\languageattribute{#1}{#2}}% + \fi + \bbl@add@list\bbl@attributes{#1-#2}% + \expandafter\def\csname#1@attr@#2\endcsname{#3}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\bbl@ifattributeset} +% \changes{babel~3.7f}{2000/02/12}{macro added} +% This internal macro has 4 arguments. It can be used to interpret +% \TeX\ code based on whether a certain attribute was set. This +% command should appear inside the argument to |\AtBeginDocument| +% because the attributes are set in the document preamble, +% \emph{after} \babel\ is loaded. +% +% The first argument is the language, the second argument the +% attribute being checked, and the third and fourth arguments are +% the true and false clauses. +% \begin{macrocode} +\def\bbl@ifattributeset#1#2#3#4{% +% \end{macrocode} +% First we need to find out if any attributes were set; if not +% we're done. +% \begin{macrocode} + \ifx\bbl@known@attribs\@undefined + \in@false + \else +% \end{macrocode} +% The we need to check the list of known attributes. +% \begin{macrocode} + \@expandtwoargs\in@{,#1-#2,}{,\bbl@known@attribs,}% + \fi +% \end{macrocode} +% When we're this far |\ifin@| has a value indicating if the +% attribute in question was set or not. Just to be safe the code to +% be executed is `thrown over the |\fi|'. +% \begin{macrocode} + \ifin@ + \bbl@afterelse#3% + \else + \bbl@afterfi#4% + \fi + } +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\bbl@add@list} +% This internal macro adds its second argument to a comma +% separated list in its first argument. When the list is not +% defined yet (or empty), it will be initiated +% \begin{macrocode} +\def\bbl@add@list#1#2{% + \ifx#1\@undefined + \def#1{#2}% + \else + \ifx#1\@empty + \def#1{#2}% + \else + \edef#1{#1,#2}% + \fi + \fi + } +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\bbl@ifknown@ttrib} +% An internal macro to check whether a given language/attribute is +% known. The macro takes 4 arguments, the language/attribute, the +% attribute list, the \TeX-code to be executed when the attribute +% is known and the \TeX-code to be executed otherwise. +% \begin{macrocode} +\def\bbl@ifknown@ttrib#1#2{% +% \end{macrocode} +% We first assume the attribute is unknown. +% \begin{macrocode} + \let\bbl@tempa\@secondoftwo +% \end{macrocode} +% Then we loop over the list of known attributes, trying to find a +% match. +% \begin{macrocode} + \@for\bbl@tempb:=#2\do{% + \expandafter\in@\expandafter{\expandafter,\bbl@tempb,}{,#1,}% + \ifin@ +% \end{macrocode} +% When a match is found the definition of |\bbl@tempa| is changed. +% \begin{macrocode} + \let\bbl@tempa\@firstoftwo + \else + \fi}% +% \end{macrocode} +% Finally we execute |\bbl@tempa|. +% \begin{macrocode} + \bbl@tempa +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\bbl@clear@ttribs} +% This macro removes all the attribute code from \LaTeX's memory at +% |\begin{document}| time (if any is present). +% \changes{babel~3.7e}{1999/09/24}{When \cs{bbl@attributes} is +% undefined this should be a no-op} +% \begin{macrocode} +\def\bbl@clear@ttribs{% + \ifx\bbl@attributes\@undefined\else + \@for\bbl@tempa:=\bbl@attributes\do{% + \expandafter\bbl@clear@ttrib\bbl@tempa. + }% + \let\bbl@attributes\@undefined + \fi + } +\def\bbl@clear@ttrib#1-#2.{% + \expandafter\let\csname#1@attr@#2\endcsname\@undefined} +\AtBeginDocument{\bbl@clear@ttribs} +% \end{macrocode} +% \end{macro} +% +% \subsection{Support for saving macro definitions} +% +% To save the meaning of control sequences using |\babel@save|, we +% use temporary control sequences. To save hash table entries for +% these control sequences, we don't use the name of the control +% sequence to be saved to construct the temporary name. Instead we +% simply use the value of a counter, which is reset to zero each time +% we begin to save new values. This works well because we release +% the saved meanings before we begin to save a new set of control +% sequence meanings (see |\selectlanguage| and |\originalTeX|). Note +% undefined macros are not undefined any more when saved -- they are +% |\relax|'ed. +% +% \begin{macro}{\babel@savecnt} +% \changes{babel~3.2}{1991/11/10}{Added macro} +% \begin{macro}{\babel@beginsave} +% \changes{babel~3.2}{1991/11/10}{Added macro} +% The initialization of a new save cycle: reset the counter to +% zero. +% \begin{macrocode} +\def\babel@beginsave{\babel@savecnt\z@} +% \end{macrocode} +% Before it's forgotten, allocate the counter and initialize all. +% \begin{macrocode} +\newcount\babel@savecnt +\babel@beginsave +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\babel@save} +% \changes{babel~3.2}{1991/11/10}{Added macro} +% The macro |\babel@save|\meta{csname} saves the current meaning of +% the control sequence \meta{csname} to +% |\originalTeX|\footnote{\cs{originalTeX} has to be +% expandable, i.\,e.\ you shouldn't let it to \cs{relax}.}. +% To do this, we let the current meaning to a temporary control +% sequence, the restore commands are appended to |\originalTeX| and +% the counter is incremented. +% \changes{babel~3.2c}{1992/03/17}{missing backslash led to errors +% when executing \cs{originalTeX}} +% \changes{babel~3.2d}{1992/07/02}{saving in \cs{babel@i} and +% restoring from \cs{@babel@i} doesn't work very well...} +% \begin{macrocode} +\def\babel@save#1{% + \expandafter\let\csname babel@\number\babel@savecnt\endcsname#1\relax + \begingroup + \toks@\expandafter{\originalTeX\let#1=}% + \edef\x{\endgroup + \def\noexpand\originalTeX{\the\toks@ \expandafter\noexpand + \csname babel@\number\babel@savecnt\endcsname\relax}}% + \x + \advance\babel@savecnt\@ne} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\babel@savevariable} +% \changes{babel~3.2}{1991/11/10}{Added macro} +% The macro |\babel@savevariable|\meta{variable} saves the value of +% the variable. \meta{variable} can be anything allowed after the +% |\the| primitive. +% \begin{macrocode} +\def\babel@savevariable#1{\begingroup + \toks@\expandafter{\originalTeX #1=}% + \edef\x{\endgroup + \def\noexpand\originalTeX{\the\toks@ \the#1\relax}}% + \x} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\bbl@frenchspacing} +% \begin{macro}{\bbl@nonfrenchspacing} +% Some languages need to have |\frenchspacing| in effect. Others +% don't want that. The command |\bbl@frenchspacing| switches it on +% when it isn't already in effect and |\bbl@nonfrenchspacing| +% switches it off if necessary. +% \begin{macrocode} +\def\bbl@frenchspacing{% + \ifnum\the\sfcode`\.=\@m + \let\bbl@nonfrenchspacing\relax + \else + \frenchspacing + \let\bbl@nonfrenchspacing\nonfrenchspacing + \fi} +\let\bbl@nonfrenchspacing\nonfrenchspacing +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \subsection{Support for extending macros} +% +% \begin{macro}{\addto} +% For each language four control sequences have to be defined that +% control the language-specific definitions. To be able to add +% something to these macro once they have been defined the macro +% |\addto| is introduced. It takes two arguments, a \meta{control +% sequence} and \TeX-code to be added to the \meta{control +% sequence}. +% +% If the \meta{control sequence} has not been defined before it is +% defined now. The control sequence could also expand to |\relax|, +% in which case a circular definition results. The net result is a +% stack overflow. Otherwise the replacement text for the +% \meta{control sequence} is expanded and stored in a token +% register, together with the \TeX-code to be added. Finally the +% \meta{control sequence} is \emph{re}defined, using the contents +% of the token register. +% +% \changes{babel~3.1}{1991/11/05}{Added macro} +% \changes{babel~3.4}{1994/02/04}{Changed to use toks register} +% \changes{babel~3.6b}{1996/12/30}{Also check if control sequence +% expands to \cs{relax}} +% \begin{macrocode} +\def\addto#1#2{% + \ifx#1\@undefined + \def#1{#2}% + \else + \ifx#1\relax + \def#1{#2}% + \else + {\toks@\expandafter{#1#2}% + \xdef#1{\the\toks@}}% + \fi + \fi} +% \end{macrocode} +% \end{macro} +% +% \subsection{Hyphens} +% +% \begin{macro}{\babelhyphenation} +% +% \changes{babel~3.9a}{2012/08/28}{Macro added} +% +% This macro saves hyphenation exceptions. Two macros are used to +% store them: |\bbl@hyphenation@| for the global ones and +% |\bbl@hyphenation<lang>| for language ones. See |\bbl@patterns| +% above for further details. We make sure there is a space between +% words when multiple commands are used. +% +% \begin{macrocode} +\@onlypreamble\babelhyphenation +\AtEndOfPackage{% + \newcommand\babelhyphenation[2][\@empty]{% + \ifx\bbl@hyphenation@\relax + \let\bbl@hyphenation@\@empty + \fi + \ifx\bbl@hyphlist\@empty\else + \bbl@warning{% + You must not intermingle \string\selectlanguage\space and\\% + \string\babelhyphenation\space or some exception will not\\% + be taken into account. Reported}% + \fi + \ifx\@empty#1% + \protected@edef\bbl@hyphenation@{\bbl@hyphenation@\space#2}% + \else + \edef\bbl@tempb{\zap@space#1 \@empty}% + \bbl@for\bbl@tempa\bbl@tempb{% + \bbl@fixname\bbl@tempa + \bbl@iflanguage\bbl@tempa{% + \bbl@csarg\protected@edef{hyphenation@\bbl@tempa}{% + \@ifundefined{bbl@hyphenation@\bbl@tempa}% + \@empty + {\csname bbl@hyphenation@\bbl@tempa\endcsname\space}% + #2}}}% + \fi}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\bbl@allowhyphens} +% \changes{babel~3.2b}{1992/02/16}{Moved macro from language +% definition files} +% \changes{babel~3.7a}{1998/03/12}{Make \cs{allowhyphens} a no-op for +% T1 fontencoding} +% \changes{babel-3.9a}{2012/07/28}{Replaced many \cs{allowhyphens} by +% \cs{bbl@allowhyphen}. They were either no-op or executed always.} +% This macro makes hyphenation possible. Basically its definition +% is nothing more than |\nobreak| |\hskip| \texttt{0pt plus +% 0pt}\footnote{\TeX\ begins and ends a word for hyphenation at a +% glue node. The penalty prevents a linebreak at this glue node.}. +% \begin{macrocode} +\def\bbl@allowhyphens{\nobreak\hskip\z@skip} +\def\bbl@t@one{T1} +\def\allowhyphens{\ifx\cf@encoding\bbl@t@one\else\bbl@allowhyphens\fi} +% \end{macrocode} +% \end{macro} +% +% \changes{babel-3.9a}{2012/08/27}{Added \cs{babelhyphen} and related +% macros} +% \begin{macro}{\babelhyphen} +% Macros to insert common hyphens. Note the space before |@| in +% |\babelhyphen|. Instead of protecting it with +% |\DeclareRobustCommand|, which could insert a |\relax|, we use +% the same procedure as shorthands. +% \begin{macrocode} +\newcommand\babelnullhyphen{\char\hyphenchar\font} +\def\babelhyphen{\active@prefix\babelhyphen\bbl@hyphen} +\def\bbl@hyphen{% + \@ifstar{\bbl@hyphen@i @}{\bbl@hyphen@i\@empty}} +\def\bbl@hyphen@i#1#2{% + \@ifundefined{bbl@hy@#1#2\@empty}% + {\csname bbl@#1usehyphen\endcsname{\discretionary{#2}{}{#2}}}% + {\csname bbl@hy@#1#2\@empty\endcsname}} +% \end{macrocode} +% The following two commands are used to wrap the ``hyphen'' and +% set the behaviour of the rest of the word -- the version with a +% single |@| is used when further hyphenation is allowed, while +% that with |@@| if no more hyphen are allowed. In both cases, if +% the hyphen is preceded by a positive space, breaking after the +% hyphen is disallowed. +% +% There should not be a discretionaty after a hyphen at the +% beginning of a word, so it is prevented if preceded by a +% skip. Unfortunately, this does handle cases like ``(-suffix)''. +% |\nobreak| is always preceded by |\leavevmode|, in case the +% shorthand starts a paragraph. +% \begin{macrocode} +\def\bbl@usehyphen#1{% + \leavevmode + \ifdim\lastskip>\z@\mbox{#1}\nobreak\else\nobreak#1\fi + \hskip\z@skip} +\def\bbl@@usehyphen#1{% + \leavevmode\ifdim\lastskip>\z@\mbox{#1}\else#1\fi} +% \end{macrocode} +% The following macro inserts the hyphen char. +% \begin{macrocode} +\def\bbl@hyphenchar{% + \ifnum\hyphenchar\font=\m@ne + \babelnullhyphen + \else + \char\hyphenchar\font + \fi} +% \end{macrocode} +% Finally, we define the hyphen ``types''. Their names will not +% change, so you may use them in |ldf|'s. +% \begin{macrocode} +\def\bbl@hy@soft{\bbl@usehyphen{\discretionary{\bbl@hyphenchar}{}{}}} +\def\bbl@hy@@soft{\bbl@@usehyphen{\discretionary{\bbl@hyphenchar}{}{}}} +\def\bbl@hy@hard{\bbl@usehyphen\bbl@hyphenchar} +\def\bbl@hy@@hard{\bbl@@usehyphen\bbl@hyphenchar} +\def\bbl@hy@nobreak{\bbl@usehyphen{\mbox{\bbl@hyphenchar}\nobreak}} +\def\bbl@hy@@nobreak{\mbox{\bbl@hyphenchar}} +\def\bbl@hy@repeat{% + \bbl@usehyphen{% + \discretionary{\bbl@hyphenchar}{\bbl@hyphenchar}{\bbl@hyphenchar}% + \nobreak}} +\def\bbl@hy@@repeat{% + \bbl@@usehyphen{% + \discretionary{\bbl@hyphenchar}{\bbl@hyphenchar}{\bbl@hyphenchar}}} +\def\bbl@hy@empty{\hskip\z@skip} +\def\bbl@hy@@empty{\discretionary{}{}{}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\bbl@disc} +% \changes{babel~3.5f}{1996/01/24}{Macro moved from language +% definition files} +% For some languages the macro |\bbl@disc| is used to ease the +% insertion of discretionaries for letters that behave `abnormally' +% at a breakpoint. +% \begin{macrocode} +\def\bbl@disc#1#2{\nobreak\discretionary{#2-}{}{#1}\bbl@allowhyphens} +% \end{macrocode} +% \end{macro} +% +% \subsection{Macros common to a number of languages} +% +% \begin{macro}{\set@low@box} +% \changes{babel~3.2b}{1992/02/16}{Moved macro from language +% definition files} +% The following macro is used to lower quotes to the same level as +% the comma. It prepares its argument in box register~0. +% \begin{macrocode} +\def\set@low@box#1{\setbox\tw@\hbox{,}\setbox\z@\hbox{#1}% + \dimen\z@\ht\z@ \advance\dimen\z@ -\ht\tw@% + \setbox\z@\hbox{\lower\dimen\z@ \box\z@}\ht\z@\ht\tw@ \dp\z@\dp\tw@} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\save@sf@q} +% \changes{babel~3.2b}{1992/02/16}{Moved macro from language +% definition files} +% The macro |\save@sf@q| is used to save and reset the current +% space factor. +% \changes{babel~3.7f}{2000/09/19}{PR3119, don't start a paragraph in +% a local group} +% \begin{macrocode} +\def\save@sf@q#1{\leavevmode + \begingroup + \edef\@SF{\spacefactor\the\spacefactor}#1\@SF + \endgroup} +% \end{macrocode} +% \end{macro} +% +% \changes{babel~3.5c}{1995/06/14}{Repaired a typo (itlaic, PR1652)} +% +% \subsection{Making glyphs available} +% +% The file \file{\filename}\footnote{The file described in this +% section has version number \fileversion, and was last revised on +% \filedate.} makes a number of glyphs available that either do not +% exist in the \texttt{OT1} encoding and have to be `faked', or +% that are not accessible through \file{T1enc.def}. +% +% \subsection{Quotation marks} +% +% \begin{macro}{\quotedblbase} +% In the \texttt{T1} encoding the opening double quote at the +% baseline is available as a separate character, accessible via +% |\quotedblbase|. In the \texttt{OT1} encoding it is not +% available, therefor we make it available by lowering the normal +% open quote character to the baseline. +% \begin{macrocode} +\ProvideTextCommand{\quotedblbase}{OT1}{% + \save@sf@q{\set@low@box{\textquotedblright\/}% + \box\z@\kern-.04em\bbl@allowhyphens}} +% \end{macrocode} +% Make sure that when an encoding other than \texttt{OT1} or +% \texttt{T1} is used this glyph can still be typeset. +% \begin{macrocode} +\ProvideTextCommandDefault{\quotedblbase}{% + \UseTextSymbol{OT1}{\quotedblbase}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\quotesinglbase} +% We also need the single quote character at the baseline. +% \begin{macrocode} +\ProvideTextCommand{\quotesinglbase}{OT1}{% + \save@sf@q{\set@low@box{\textquoteright\/}% + \box\z@\kern-.04em\bbl@allowhyphens}} +% \end{macrocode} +% Make sure that when an encoding other than \texttt{OT1} or +% \texttt{T1} is used this glyph can still be typeset. +% \begin{macrocode} +\ProvideTextCommandDefault{\quotesinglbase}{% + \UseTextSymbol{OT1}{\quotesinglbase}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\guillemotleft} +% \begin{macro}{\guillemotright} +% The guillemet characters are not available in \texttt{OT1} +% encoding. They are faked. +% \begin{macrocode} +\ProvideTextCommand{\guillemotleft}{OT1}{% + \ifmmode + \ll + \else + \save@sf@q{\nobreak + \raise.2ex\hbox{$\scriptscriptstyle\ll$}\bbl@allowhyphens}% + \fi} +\ProvideTextCommand{\guillemotright}{OT1}{% + \ifmmode + \gg + \else + \save@sf@q{\nobreak + \raise.2ex\hbox{$\scriptscriptstyle\gg$}\bbl@allowhyphens}% + \fi} +% \end{macrocode} +% Make sure that when an encoding other than \texttt{OT1} or +% \texttt{T1} is used these glyphs can still be typeset. +% \begin{macrocode} +\ProvideTextCommandDefault{\guillemotleft}{% + \UseTextSymbol{OT1}{\guillemotleft}} +\ProvideTextCommandDefault{\guillemotright}{% + \UseTextSymbol{OT1}{\guillemotright}} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\guilsinglleft} +% \begin{macro}{\guilsinglright} +% The single guillemets are not available in \texttt{OT1} +% encoding. They are faked. +% \begin{macrocode} +\ProvideTextCommand{\guilsinglleft}{OT1}{% + \ifmmode + <% + \else + \save@sf@q{\nobreak + \raise.2ex\hbox{$\scriptscriptstyle<$}\bbl@allowhyphens}% + \fi} +\ProvideTextCommand{\guilsinglright}{OT1}{% + \ifmmode + >% + \else + \save@sf@q{\nobreak + \raise.2ex\hbox{$\scriptscriptstyle>$}\bbl@allowhyphens}% + \fi} +% \end{macrocode} +% Make sure that when an encoding other than \texttt{OT1} or +% \texttt{T1} is used these glyphs can still be typeset. +% \begin{macrocode} +\ProvideTextCommandDefault{\guilsinglleft}{% + \UseTextSymbol{OT1}{\guilsinglleft}} +\ProvideTextCommandDefault{\guilsinglright}{% + \UseTextSymbol{OT1}{\guilsinglright}} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% +% \subsection{Letters} +% +% \begin{macro}{\ij} +% \begin{macro}{\IJ} +% The dutch language uses the letter `ij'. It is available in +% \texttt{T1} encoded fonts, but not in the \texttt{OT1} encoded +% fonts. Therefor we fake it for the \texttt{OT1} encoding. +% \changes{dutch-3.7a}{1995/02/04}{Changed the kerning in the faked ij +% to match the dc-version of it} +% \changes{babel~3.9a}{2012/07/28}{Removed the first \cs{allowhyphens}. +% Moved the second one just after the kern.} +% \begin{macrocode} +\DeclareTextCommand{\ij}{OT1}{% + i\kern-0.02em\bbl@allowhyphens j} +\DeclareTextCommand{\IJ}{OT1}{% + I\kern-0.02em\bbl@allowhyphens J} +\DeclareTextCommand{\ij}{T1}{\char188} +\DeclareTextCommand{\IJ}{T1}{\char156} +% \end{macrocode} +% Make sure that when an encoding other than \texttt{OT1} or +% \texttt{T1} is used these glyphs can still be typeset. +% \begin{macrocode} +\ProvideTextCommandDefault{\ij}{% + \UseTextSymbol{OT1}{\ij}} +\ProvideTextCommandDefault{\IJ}{% + \UseTextSymbol{OT1}{\IJ}} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\dj} +% \begin{macro}{\DJ} +% The croatian language needs the letters |\dj| and |\DJ|; they are +% available in the \texttt{T1} encoding, but not in the +% \texttt{OT1} encoding by default. +% +% Some code to construct these glyphs for the \texttt{OT1} encoding +% was made available to me by Stipcevic Mario, +% (\texttt{stipcevic@olimp.irb.hr}). +% \changes{babel~3.5f}{1996/03/28}{New definition of \cs{dj}, see PR +% 2058} +% \begin{macrocode} +\def\crrtic@{\hrule height0.1ex width0.3em} +\def\crttic@{\hrule height0.1ex width0.33em} +\def\ddj@{% + \setbox0\hbox{d}\dimen@=\ht0 + \advance\dimen@1ex + \dimen@.45\dimen@ + \dimen@ii\expandafter\rem@pt\the\fontdimen\@ne\font\dimen@ + \advance\dimen@ii.5ex + \leavevmode\rlap{\raise\dimen@\hbox{\kern\dimen@ii\vbox{\crrtic@}}}} +\def\DDJ@{% + \setbox0\hbox{D}\dimen@=.55\ht0 + \dimen@ii\expandafter\rem@pt\the\fontdimen\@ne\font\dimen@ + \advance\dimen@ii.15ex % correction for the dash position + \advance\dimen@ii-.15\fontdimen7\font % correction for cmtt font + \dimen\thr@@\expandafter\rem@pt\the\fontdimen7\font\dimen@ + \leavevmode\rlap{\raise\dimen@\hbox{\kern\dimen@ii\vbox{\crttic@}}}} +% +\DeclareTextCommand{\dj}{OT1}{\ddj@ d} +\DeclareTextCommand{\DJ}{OT1}{\DDJ@ D} +% \end{macrocode} +% Make sure that when an encoding other than \texttt{OT1} or +% \texttt{T1} is used these glyphs can still be typeset. +% \begin{macrocode} +\ProvideTextCommandDefault{\dj}{% + \UseTextSymbol{OT1}{\dj}} +\ProvideTextCommandDefault{\DJ}{% + \UseTextSymbol{OT1}{\DJ}} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\SS} +% For the \texttt{T1} encoding |\SS| is defined and selects a +% specific glyph from the font, but for other encodings it is not +% available. Therefor we make it available here. +% \begin{macrocode} +\DeclareTextCommand{\SS}{OT1}{SS} +\ProvideTextCommandDefault{\SS}{\UseTextSymbol{OT1}{\SS}} +% \end{macrocode} +% \end{macro} +% +% \subsection{Shorthands for quotation marks} +% +% Shorthands are provided for a number of different quotation +% marks, which make them usable both outside and inside mathmode. +% +% \begin{macro}{\glq} +% \begin{macro}{\grq} +% \changes{babel~3.7a}{1997/04/25}{Make the definition of \cs{grq} +% dependent on the font encoding} +% \changes{babel~3.8b}{2004/05/02}{Made \cs{glq} fontencoding +% dependent as well} +% The `german' single quotes. +% \begin{macrocode} +\ProvideTextCommand{\glq}{OT1}{% + \textormath{\quotesinglbase}{\mbox{\quotesinglbase}}} +\ProvideTextCommand{\glq}{T1}{% + \textormath{\quotesinglbase}{\mbox{\quotesinglbase}}} +\ProvideTextCommandDefault{\glq}{\UseTextSymbol{OT1}\glq} +% \end{macrocode} +% The definition of |\grq| depends on the fontencoding. With +% \texttt{T1} encoding no extra kerning is needed. +% \begin{macrocode} +\ProvideTextCommand{\grq}{T1}{% + \textormath{\textquoteleft}{\mbox{\textquoteleft}}} +\ProvideTextCommand{\grq}{OT1}{% + \save@sf@q{\kern-.0125em% + \textormath{\textquoteleft}{\mbox{\textquoteleft}}% + \kern.07em\relax}} +\ProvideTextCommandDefault{\grq}{\UseTextSymbol{OT1}\grq} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\glqq} +% \begin{macro}{\grqq} +% \changes{babel~3.7a}{1997/04/25}{Make the definition of \cs{grqq} +% dependent on the font encoding} +% \changes{babel~3.8b}{2004/05/02}{Made \cs{grqq} fontencoding +% dependent as well} +% The `german' double quotes. +% \begin{macrocode} +\ProvideTextCommand{\glqq}{OT1}{% + \textormath{\quotedblbase}{\mbox{\quotedblbase}}} +\ProvideTextCommand{\glqq}{T1}{% + \textormath{\quotedblbase}{\mbox{\quotedblbase}}} +\ProvideTextCommandDefault{\glqq}{\UseTextSymbol{OT1}\glqq} +% \end{macrocode} +% The definition of |\grqq| depends on the % fontencoding. With +% \texttt{T1} encoding no extra kerning is needed. +% \begin{macrocode} +\ProvideTextCommand{\grqq}{T1}{% + \textormath{\textquotedblleft}{\mbox{\textquotedblleft}}} +\ProvideTextCommand{\grqq}{OT1}{% + \save@sf@q{\kern-.07em% + \textormath{\textquotedblleft}{\mbox{\textquotedblleft}}% + \kern.07em\relax}} +\ProvideTextCommandDefault{\grqq}{\UseTextSymbol{OT1}\grqq} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\flq} +% \begin{macro}{\frq} +% \changes{babel~3.5f}{1995/08/07}{corrected spelling of +% \cs{quilsingl...}} +% \changes{babel~3.5f}{1995/09/05}{now use \cs{textormath} in these +% definitions} +% \changes{babel~3.8b}{2004/05/02}{Made \cs{flq} and \cs{frq} +% fontencoding dependent} +% The `french' single guillemets. +% \begin{macrocode} +\ProvideTextCommand{\flq}{OT1}{% + \textormath{\guilsinglleft}{\mbox{\guilsinglleft}}} +\ProvideTextCommand{\flq}{T1}{% + \textormath{\guilsinglleft}{\mbox{\guilsinglleft}}} +\ProvideTextCommandDefault{\flq}{\UseTextSymbol{OT1}\flq} +% \end{macrocode} +% +% \begin{macrocode} +\ProvideTextCommand{\frq}{OT1}{% + \textormath{\guilsinglright}{\mbox{\guilsinglright}}} +\ProvideTextCommand{\frq}{T1}{% + \textormath{\guilsinglright}{\mbox{\guilsinglright}}} +\ProvideTextCommandDefault{\frq}{\UseTextSymbol{OT1}\frq} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\flqq} +% \begin{macro}{\frqq} +% \changes{babel~3.5f}{1995/08/07}{corrected spelling of +% \cs{quillemot...}} +% \changes{babel~3.5f}{1995/09/05}{now use \cs{textormath} in these +% definitions} +% \changes{babel~3.8b}{2004/05/02}{Made \cs{flqq} and \cs{frqq} +% fontencoding dependent} +% The `french' double guillemets. +% \begin{macrocode} +\ProvideTextCommand{\flqq}{OT1}{% + \textormath{\guillemotleft}{\mbox{\guillemotleft}}} +\ProvideTextCommand{\flqq}{T1}{% + \textormath{\guillemotleft}{\mbox{\guillemotleft}}} +\ProvideTextCommandDefault{\flqq}{\UseTextSymbol{OT1}\flqq} +% \end{macrocode} +% +% \begin{macrocode} +\ProvideTextCommand{\frqq}{OT1}{% + \textormath{\guillemotright}{\mbox{\guillemotright}}} +\ProvideTextCommand{\frqq}{T1}{% + \textormath{\guillemotright}{\mbox{\guillemotright}}} +\ProvideTextCommandDefault{\frqq}{\UseTextSymbol{OT1}\frqq} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \subsection{Umlauts and trema's} +% +% The command |\"| needs to have a different effect for different +% languages. For German for instance, the `umlaut' should be +% positioned lower than the default position for placing it over +% the letters a, o, u, A, O and U. When placed over an e, i, E or I +% it can retain its normal position. For Dutch the same glyph is +% always placed in the lower position. +% +% \begin{macro}{\umlauthigh} +% \changes{v3.8a}{2004/02/19}{Use \cs{leavevmode}\cs{bgroup} to +% prevent problems when this command occurs in vertical mode.} +% \begin{macro}{\umlautlow} +% To be able to provide both positions of |\"| we provide two +% commands to switch the positioning, the default will be +% |\umlauthigh| (the normal positioning). +% \begin{macrocode} +\def\umlauthigh{% + \def\bbl@umlauta##1{\leavevmode\bgroup% + \expandafter\accent\csname\f@encoding dqpos\endcsname + ##1\bbl@allowhyphens\egroup}% + \let\bbl@umlaute\bbl@umlauta} +\def\umlautlow{% + \def\bbl@umlauta{\protect\lower@umlaut}} +\def\umlautelow{% + \def\bbl@umlaute{\protect\lower@umlaut}} +\umlauthigh +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\lower@umlaut} +% The command |\lower@umlaut| is used to position the |\"| closer +% the the letter. +% +% We want the umlaut character lowered, nearer to the letter. To do +% this we need an extra \meta{dimen} register. +% \begin{macrocode} +\expandafter\ifx\csname U@D\endcsname\relax + \csname newdimen\endcsname\U@D +\fi +% \end{macrocode} +% The following code fools \TeX's \texttt{make\_accent} procedure +% about the current x-height of the font to force another placement +% of the umlaut character. +% First we have to save the current x-height of the font, because +% we'll change this font dimension and this is always done +% globally. +% \changes{v3.8a}{2004/02/19}{Use \cs{leavevmode}\cs{bgroup} to +% prevent problems when this command occurs in vertical mode.} +% +% Then we compute the new x-height in such a way that the umlaut +% character is lowered to the base character. The value of +% \texttt{.45ex} depends on the \MF\ parameters with which the +% fonts were built. (Just try out, which value will look best.) +% If the new x-height is too low, it is not changed. +% Finally we call the |\accent| primitive, reset the old x-height +% and insert the base character in the argument. +% \changes{babel~3.5f}{1996/04/02}{Added a \cs{allowhyphens}} +% \changes{babel~3.5f}{1996/06/25}{removed \cs{allowhyphens}} +% \begin{macrocode} +\def\lower@umlaut#1{% + \leavevmode\bgroup + \U@D 1ex% + {\setbox\z@\hbox{% + \expandafter\char\csname\f@encoding dqpos\endcsname}% + \dimen@ -.45ex\advance\dimen@\ht\z@ + \ifdim 1ex<\dimen@ \fontdimen5\font\dimen@ \fi}% + \expandafter\accent\csname\f@encoding dqpos\endcsname + \fontdimen5\font\U@D #1% + \egroup} +% \end{macrocode} +% \end{macro} +% +% For all vowels we declare |\"| to be a composite command which +% uses |\bbl@umlauta| or |\bbl@umlaute| to position the umlaut +% character. We need to be sure that these definitions override the +% ones that are provided when the package \pkg{fontenc} with +% option \Lopt{OT1} is used. Therefor these declarations are +% postponed until the beginning of the document. Note these +% definitions only apply to some languages, but +% babel sets them for \textit{all} languages -- you may want to +% redefine |\bbl@umlauta| and/or |\bbl@umlaute| for a language +% in the corresponding |ldf| (using the babel switching mechanism, +% of course). +% \begin{macrocode} +\AtBeginDocument{% + \DeclareTextCompositeCommand{\"}{OT1}{a}{\bbl@umlauta{a}}% + \DeclareTextCompositeCommand{\"}{OT1}{e}{\bbl@umlaute{e}}% + \DeclareTextCompositeCommand{\"}{OT1}{i}{\bbl@umlaute{\i}}% + \DeclareTextCompositeCommand{\"}{OT1}{\i}{\bbl@umlaute{\i}}% + \DeclareTextCompositeCommand{\"}{OT1}{o}{\bbl@umlauta{o}}% + \DeclareTextCompositeCommand{\"}{OT1}{u}{\bbl@umlauta{u}}% + \DeclareTextCompositeCommand{\"}{OT1}{A}{\bbl@umlauta{A}}% + \DeclareTextCompositeCommand{\"}{OT1}{E}{\bbl@umlaute{E}}% + \DeclareTextCompositeCommand{\"}{OT1}{I}{\bbl@umlaute{I}}% + \DeclareTextCompositeCommand{\"}{OT1}{O}{\bbl@umlauta{O}}% + \DeclareTextCompositeCommand{\"}{OT1}{U}{\bbl@umlauta{U}}% +} +% \end{macrocode} +% \subsection{Multiencoding strings} +% +% \changes{babel~3.9a}{2012/09/05}{Added tentative code for string +% declarations} +% \changes{babel~3.9a}{2012/12/24}{Added hooks} +% +% The aim following commands is to provide a commom interface for +% strings in several encodings. They also contains several hooks which +% can be ued by \luatex{} and \xetex. +% +% This is the main command. With the first use it is redefined to +% omit the basic setup in subsequent blocks. We make sure strings +% contain actual letters in the range 128-255, not active characters. +% \begin{macrocode} +\def\bbl@recatcode#1{% + \@tempcnta="7F + \def\bbl@tempa{% + \ifnum\@tempcnta>"FF\else + \catcode\@tempcnta=#1\relax + \advance\@tempcnta\@ne + \expandafter\bbl@tempa + \fi}% + \bbl@tempa} +\@onlypreamble\StartBabelCommands +\def\StartBabelCommands{% + \begingroup + \bbl@recatcode{11}% + \def\bbl@scuse{% + \ifx\bbl@opt@strings\@nnil\def\bbl@opt@strings{generic}\fi}% + \def\UseStrings{\bbl@scuse\aftergroup\bbl@scuse}% + \def\SetStringLoop{\afterassignment\bbl@sclp\def\bbl@templ####1}% + \def\bbl@sclp##1{% + \count@\z@ % dangerous if a hook is used + \@for\bbl@tempm:=##1\do{% + \advance\count@\@ne + \toks@\expandafter{\bbl@tempm}% + \edef\bbl@tempn{% + \expandafter\noexpand + \csname\bbl@templ{\romannumeral\count@}\endcsname% + {\the\toks@}}% + \expandafter\SetString\bbl@tempn}}% + \def\SetCase{% + \@ifundefined{bbl@tolower}{% + \g@addto@macro\@uclclist{% + \reserved@b{\reserved@b\@gobble}% stops processing the list + \@ifundefined{\languagename @bbl@uclc}% and resumes it + {\reserved@a}% + {\csname\languagename @bbl@uclc\endcsname}% + {\bbl@tolower\@empty}{\bbl@toupper\@empty}}% + \gdef\bbl@tolower{\csname\languagename @bbl@lc\endcsname}% + \gdef\bbl@toupper{\csname\languagename @bbl@uc\endcsname}}{}% + \let\SetCase\bbl@setcase + \SetCase}% + \def\bbl@provstring##1{% + \@ifundefined{\expandafter\@gobble\string##1}{\gdef##1}\@gobble}% + \def\bbl@dftstring##1##2{% + \@dec@text@cmd\gdef##1?{##2}% + \global\let##1##1}% + \def\bbl@encstring##1##2{% + \bbl@for\bbl@tempc\bbl@sc@fontenc{% + \@ifundefined{T@\bbl@tempc}% + \@empty + {\@dec@text@cmd\gdef##1\bbl@tempc{##2}% + \global\let##1##1}}}% + \let\StartBabelCommands\bbl@startcmds + \begingroup + \let\bbl@screset\@nnil % local flag - disable 1st stopcommands + \StartBabelCommands} +\def\bbl@startcmds#1#2{% + \ifx\bbl@screset\@nnil\else + \bbl@usehooks{stopcommands}{}% + \fi + \endgroup + \begingroup + \edef\bbl@L{\zap@space#1 \@empty}% + \edef\bbl@G{\zap@space#2 \@empty}% + \let\bbl@sc@charset\space + \let\bbl@sc@fontenc\space + \let\SetString\@gobbletwo + \let\bbl@stringdef\@gobbletwo + \bbl@startcmds@i} +% \end{macrocode} +% Parse the encoding info to get the label, input, and font parts. +% +% Select the behaviour of |\SetString|. Thre are two main cases: +% |*| blocks, which are always taken into account, and labelled +% blocks, which are not always taken into account. With |*| and +% |strings| set to |encoded| or |generic|, strings are defined +% always; otherwise, they are set only if they are still undefined +% (ie, fallback values). With labelled blocks and +% |strings=encoded|, define the strings, but with another value, +% define strings only if the current label or font encoding is the +% value of |strings|; otherwise (ie, no |strings| or a block whose +% label is not in |strings=|) do nothing. +% +% We presume the current block is not loaded, and therefore set +% (above) a couple of default values to gobble the arguments. Then, +% these macros are redefined if necessary according to several +% parameters. +% +% \begin{macrocode} +\newcommand\bbl@startcmds@i[1][\@empty]{% + \ifx\@empty#1% + \def\bbl@sc@label{generic}% + \bbl@scswitch{% + \ifx\bbl@opt@strings\@nnil + \let\bbl@stringdef\bbl@dftstring + \else\ifx\bbl@opt@strings\relax + \let\SetString\bbl@setstring + \let\bbl@stringdef\bbl@dftstring + \else + \let\SetString\bbl@setstring + \let\bbl@stringdef\bbl@provstring + \fi\fi}% + \@expandtwoargs + \bbl@usehooks{defaultcommands}{}% + \else + \def\bbl@tempa##1=##2\@nil{% + \bbl@csarg\edef{sc@\zap@space##1 \@empty}{##2 }}% + \bbl@for\bbl@tempb{label=#1}{\expandafter\bbl@tempa\bbl@tempb\@nil}% + \def\bbl@tempa##1 ##2{% + ##1% + \ifx\@empty##2\else\ifx,##1,\else,\fi\bbl@afterfi\bbl@tempa##2\fi}% + \edef\bbl@sc@fontenc{\expandafter\bbl@tempa\bbl@sc@fontenc\@empty}% + \edef\bbl@sc@label{\expandafter\zap@space\bbl@sc@label\@empty}% + \edef\bbl@sc@charset{\expandafter\zap@space\bbl@sc@charset\@empty}% + \bbl@scswitch{% + \ifx\bbl@opt@strings\@nnil + \let\bbl@stringdef\bbl@encstring + \else\ifx\bbl@opt@strings\relax + \let\SetString\bbl@setstring + \let\bbl@stringdef\bbl@encstring + \else + \@expandtwoargs + \in@{,\bbl@opt@strings,}{,\bbl@sc@label,\bbl@sc@fontenc,}% + \ifin@ + \let\SetString\bbl@setstring + \let\bbl@stringdef\bbl@provstring + \fi\fi\fi}% + \@expandtwoargs + \bbl@usehooks{encodedcommands}{{\bbl@sc@charset}{\bbl@sc@fontenc}}% + \fi} +% \end{macrocode} +% +% There are two versions of |\bbl@scswitch|. The first version +% is used when |ldf|s are read, and with it blocks not intented for +% the current language (as set in |\CurrentOption|) are ignored; it +% also makes sure |\|\m{group}\m{language} is reset, but only once +% (|\bbl@screset| is used to keep track of this). The second version +% is used in the preamble and packages loaded after \babel{} and +% defines strings for all known languages. +% +% \begin{macrocode} +\def\bbl@scswitch#1{% + \@expandtwoargs\in@{,\CurrentOption,}{,\bbl@L,}% + \ifin@ + \let\bbl@L\CurrentOption + #1\relax + \bbl@scswitch@i + \ifx\bbl@G\@empty\else + \ifx\SetString\@gobbletwo\else + \edef\bbl@GL{\bbl@G\bbl@L}% + \@expandtwoargs\in@{,\bbl@GL,}{,\bbl@screset,}% + \ifin@\else + \global\expandafter\let\csname\bbl@GL\endcsname\@undefined + \xdef\bbl@screset{\bbl@screset,\bbl@GL}% + \fi + \fi + \fi + \fi} +\def\bbl@scswitch@i{% + \ifx\bbl@G\@empty + \def\SetString##1##2{% + \bbl@error{Missing group for string \string##1}% + {You must assign strings to some category, typically\\% + captions or extras, but you set none}}% + \fi} +\AtEndOfPackage{\def\bbl@scswitch#1{#1\relax\bbl@scswitch@i}} +\@onlypreamble\EndBabelCommands +\def\EndBabelCommands{% + \bbl@usehooks{stopcommands}{}% + \endgroup + \endgroup} +% \end{macrocode} +% +% First save the ``switcher''. Create it if undefined. Strings are +% defined only if undefined (ie, like |\providescommmand|). With +% the event |stringprocess| you can preprocess the string by +% manipulating the value of |\BabelString|. If there are several +% hooks assigned to this event, preprocessing is done in the same +% order as defined. Finally, the string is set. +% +% \begin{macrocode} +\def\bbl@scset#1#2{\def#1{#2}} +\def\bbl@setstring#1#2{% + \bbl@for\bbl@tempa\bbl@L{% + \edef\bbl@LC{\bbl@tempa\expandafter\@gobble\string#1}% + \@ifundefined{\bbl@LC}% eg, \germanchaptername + {\global\expandafter + \bbl@add\csname\bbl@G\bbl@tempa\expandafter\endcsname\expandafter + {\expandafter\bbl@scset\expandafter#1\csname\bbl@LC\endcsname}}% + {}% + \def\BabelString{#2}% + \bbl@usehooks{stringprocess}{}% + \expandafter\bbl@stringdef + \csname\bbl@LC\expandafter\endcsname\expandafter{\BabelString}}} +\newcommand\bbl@setcase[3][]{% + \bbl@for\bbl@tempa\bbl@L{% + \expandafter\bbl@stringdef + \csname\bbl@tempa @bbl@uclc\endcsname{\reserved@a#1}% + \expandafter\bbl@stringdef + \csname\bbl@tempa @bbl@uc\endcsname{#2}% + \expandafter\bbl@stringdef + \csname\bbl@tempa @bbl@lc\endcsname{#3}}} +% \end{macrocode} +% +% \subsection{Hooks} +% +% Note they are loaded in babel.def. switch.def only provides a +% ``hook'' for hooks (with a default value which is a no-op, +% below). Admittedly, the current implementation is a somewhat +% simplistic and does vety little to catch errors, but it is intended +% for developpers, after all. |\bbl@usehooks| is the commands used by +% babel to execute hooks defined for an event. +% +% \begin{macrocode} +\def\AddBabelHook#1#2{% + \@ifundefined{bbl@hk@#1}{\EnableBabelHook{#1}}{}% + \def\bbl@tempa##1,#2=##2,##3\@empty{\def\bbl@tempb{##2}}% + \expandafter\bbl@tempa\bbl@evargs,#2=,\@empty + \@ifundefined{bbl@ev@#1@#2}% + {\bbl@csarg\bbl@add{ev@#2}{\bbl@elt{#1}}% + \bbl@csarg\newcommand}% + {\bbl@csarg\renewcommand}% + {ev@#1@#2}[\bbl@tempb]} +\def\EnableBabelHook#1{\bbl@csarg\let{hk@#1}\@firstofone} +\def\DisableBabelHook#1{\bbl@csarg\let{hk@#1}\@gobble} +\def\bbl@usehooks#1#2{% + \def\bbl@elt##1{% + \@nameuse{bbl@hk@##1}{\@nameuse{bbl@ev@##1@#1}#2}}% + \@nameuse{bbl@ev@#1}} +% \end{macrocode} +% To ensure forward compatibility, arguments in hooks are set +% implicitly. So, if a further argument is added in the future, +% there is no need to change the existing code. Note events +% intended for \textsf{hyphen.cfg} are also loaded (just in +% case you need them). +% \begin{macrocode} +\def\bbl@evargs{,% don't delete the comma + everylanguage=1,loadkernel=1,loadpatterns=1,loadexceptions=1,% + adddialect=2,patterns=2,defaultcommands=0,encodedcommands=2,write=0,% + beforeextras=0,afterextras=0,stopcommands=0,stringprocess=0,% + hyphenation=2} +\ifx\directlua\@undefined + \ifx\XeTeXinputencoding\@undefined\else + \input xebabel.def + \fi +\else + \input luababel.def +\fi +% \end{macrocode} +% +% \subsection{The redefinition of the style commands} +% +% The rest of the code in this file can only be processed by +% \LaTeX, so we check the current format. If it is plain \TeX, +% processing should stop here. But, because of the need to limit +% the scope of the definition of |\format|, a macro that is used +% locally in the following |\if|~statement, this comparison is done +% inside a group. To prevent \TeX\ from complaining about an +% unclosed group, the processing of the command |\endinput| is +% deferred until after the group is closed. This is accomplished by +% the command |\aftergroup|. +% \begin{macrocode} +{\def\format{lplain} +\ifx\fmtname\format +\else + \def\format{LaTeX2e} + \ifx\fmtname\format + \else + \aftergroup\endinput + \fi +\fi} +% \end{macrocode} +% +% \subsection{Cross referencing macros} +% +% The \LaTeX\ book states: +% \begin{quote} +% The \emph{key} argument is any sequence of letters, digits, and +% punctuation symbols; upper- and lowercase letters are regarded as +% different. +% \end{quote} +% When the above quote should still be true when a document is +% typeset in a language that has active characters, special care +% has to be taken of the category codes of these characters when +% they appear in an argument of the cross referencing macros. +% +% When a cross referencing command processes its argument, all +% tokens in this argument should be character tokens with category +% `letter' or `other'. +% +% The only way to accomplish this in most cases is to use the trick +% described in the \TeX book~\cite{DEK} (Appendix~D, page~382). +% The primitive |\meaning| applied to a token expands to the +% current meaning of this token. For example, `|\meaning\A|' with +% |\A| defined as `|\def\A#1{\B}|' expands to the characters +% `|macro:#1->\B|' with all category codes set to `other' or +% `space'. +% \begin{macro}{\newlabel} +% \changes{babel~3.5f}{1995/11/15}{Now use \cs{bbl@redefine}} +% The macro |\label| writes a line with a |\newlabel| command +% into the |.aux| file to define labels. +% \begin{macrocode} +%\bbl@redefine\newlabel#1#2{% +% \@safe@activestrue\org@newlabel{#1}{#2}\@safe@activesfalse} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\@newl@bel} +% \changes{babel~3.6i}{1997/03/01}{Now redefine \cs{@newl@bel} instead +% of \cs{@lbibitem} and \cs{newlabel}} +% We need to change the definition of the \LaTeX-internal macro +% |\@newl@bel|. This is needed because we need to make sure that +% shorthand characters expand to their non-active version. +% +% First we open a new group to keep the changed setting of +% |\protect| local and then we set the |@safe@actives| switch to +% true to make sure that any shorthand that appears in any of the +% arguments immediately expands to its non-active self. +% \changes{babel~3.7a}{1997/12/19}{Call \cs{@safe@activestrue} +% directly} +% \begin{macrocode} +\ifx\bbl@opt@safe\@empty\else + \def\@newl@bel#1#2#3{% + {\@safe@activestrue + \@ifundefined{#1@#2}% + \relax + {\gdef\@multiplelabels{% + \@latex@warning@no@line{There were multiply-defined labels}}% + \@latex@warning@no@line{Label `#2' multiply defined}}% + \global\@namedef{#1@#2}{#3}}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\@testdef} +% An internal \LaTeX\ macro used to test if the labels that have +% been written on the |.aux| file have changed. It is called by +% the |\enddocument| macro. This macro needs to be completely +% rewritten, using |\meaning|. The reason for this is that in some +% cases the expansion of |\#1@#2| contains the same characters as +% the |#3|; but the character codes differ. Therefor \LaTeX\ keeps +% reporting that the labels may have changed. +% \changes{babel~3.4g}{1994/08/30}{Moved the \cs{def} inside the +% macrocode environment} +% \changes{babel~3.5f}{1995/11/15}{Now use \cs{bbl@redefine}} +% \changes{babel~3.5f}{1996/01/09}{Complete rewrite of this macro as +% the same character ended up with different category codes in the +% labels that are being compared. Now use \cs{meaning}} +% \changes{babel~3.5f}{1996/01/16}{Use \cs{strip@prefix} only on +% \cs{bbl@tempa} when it is not \cs{relax}} +% \changes{babel~3.6i}{1997/02/28}{Make sure that shorthands don't get +% expanded at the wrong moment.} +% \changes{babel~3.6i}{1997/03/01}{\cs{@safe@activesfalse} is now +% part of the label definition} +% \changes{babel~3.7a}{1998/03/13}{Removed \cs{@safe@activesfalse} +% from the label definition} +% \begin{macrocode} + \CheckCommand*\@testdef[3]{% + \def\reserved@a{#3}% + \expandafter\ifx\csname#1@#2\endcsname\reserved@a + \else + \@tempswatrue + \fi} +% \end{macrocode} +% Now that we made sure that |\@testdef| still has the same +% definition we can rewrite it. First we make the shorthands +% `safe'. +% \begin{macrocode} + \def\@testdef#1#2#3{% + \@safe@activestrue +% \end{macrocode} +% Then we use |\bbl@tempa| as an `alias' for the macro that +% contains the label which is being checked. +% \begin{macrocode} + \expandafter\let\expandafter\bbl@tempa\csname #1@#2\endcsname +% \end{macrocode} +% Then we define |\bbl@tempb| just as |\@newl@bel| does it. +% \begin{macrocode} + \def\bbl@tempb{#3}% + \@safe@activesfalse +% \end{macrocode} +% When the label is defined we replace the definition of +% |\bbl@tempa| by its meaning. +% \begin{macrocode} + \ifx\bbl@tempa\relax + \else + \edef\bbl@tempa{\expandafter\strip@prefix\meaning\bbl@tempa}% + \fi +% \end{macrocode} +% We do the same for |\bbl@tempb|. +% \begin{macrocode} + \edef\bbl@tempb{\expandafter\strip@prefix\meaning\bbl@tempb}% +% \end{macrocode} +% If the label didn't change, |\bbl@tempa| and |\bbl@tempb| should +% be identical macros. +% \begin{macrocode} + \ifx\bbl@tempa\bbl@tempb + \else + \@tempswatrue + \fi} +\fi +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\ref} +% \begin{macro}{\pageref} +% The same holds for the macro |\ref| that references a label +% and |\pageref| to reference a page. So we redefine |\ref| and +% |\pageref|. While we change these macros, we make them robust as +% well (if they weren't already) to prevent problems if they should +% become expanded at the wrong moment. +% \changes{babel~3.5b}{1995/03/07}{Made \cs{ref} and \cs{pageref} +% robust (PR1353)} +% \changes{babel~3.5d}{1995/07/04}{use a different control sequence +% while making \cs{ref} and \cs{pageref} robust} +% \changes{babel~3.5f}{1995/11/06}{redefine \cs*{ref } if it exists +% instead of \cs{ref}} +% \changes{babel~3.5f}{1995/11/15}{Now use \cs{bbl@redefinerobust}} +% \changes{babel~3.5f}{1996/01/19}{redefine \cs{\@setref} instead of +% \cs{ref} and \cs{pageref} in \LaTeXe.} +% \changes{babel~3.5f}{1996/01/21}{Reverse the previous change as it +% inhibits the use of active characters in labels} +% \begin{macrocode} +\@expandtwoargs\in@{R}\bbl@opt@safe +\ifin@ + \bbl@redefinerobust\ref#1{% + \@safe@activestrue\org@ref{#1}\@safe@activesfalse} + \bbl@redefinerobust\pageref#1{% + \@safe@activestrue\org@pageref{#1}\@safe@activesfalse} +\else + \let\org@ref\ref + \let\org@pageref\pageref +\fi +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\@citex} +% \changes{babel~3.5f}{1995/11/15}{Now use \cs{bbl@redefine}} +% The macro used to cite from a bibliography, |\cite|, uses an +% internal macro, |\@citex|. +% It is this internal macro that picks up the argument(s), +% so we redefine this internal macro and leave |\cite| alone. The +% first argument is used for typesetting, so the shorthands need +% only be deactivated in the second argument. +% \changes{babel~3.7g}{2000/10/01}{The shorthands need to be +% deactivated for the second argument of \cs{@citex} only.} +% \begin{macrocode} +\@expandtwoargs\in@{B}\bbl@opt@safe +\ifin@ + \bbl@redefine\@citex[#1]#2{% + \@safe@activestrue\edef\@tempa{#2}\@safe@activesfalse + \org@@citex[#1]{\@tempa}} +% \end{macrocode} +% Unfortunately, the packages \pkg{natbib} and \pkg{cite} need a +% different definition of |\@citex|... +% To begin with, \pkg{natbib} has a definition for |\@citex| with +% \emph{three} arguments... We only know that a package is loaded +% when |\begin{document}| is executed, so we need to postpone the +% different redefinition. +% \begin{macrocode} + \AtBeginDocument{% + \@ifpackageloaded{natbib}{% +% \end{macrocode} +% Notice that we use |\def| here instead of |\bbl@redefine| because +% |\org@@citex| is already defined and we don't want to overwrite +% that definition (it would result in parameter stack overflow +% because of a circular definition). +% +% (Recent versions of natbib change dynamically |\@citex|, so PR4087 +% doesn't seem fixable in a simple way. Just load natbib before.) +% \begin{macrocode} + \def\@citex[#1][#2]#3{% + \@safe@activestrue\edef\@tempa{#3}\@safe@activesfalse + \org@@citex[#1][#2]{\@tempa}}% + }{}} +% \end{macrocode} +% The package \pkg{cite} has a definition of |\@citex| where the +% shorthands need to be turned off in both arguments. +% \begin{macrocode} + \AtBeginDocument{% + \@ifpackageloaded{cite}{% + \def\@citex[#1]#2{% + \@safe@activestrue\org@@citex[#1]{#2}\@safe@activesfalse}% + }{}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\nocite} +% \changes{babel~3.5f}{1995/11/15}{Now use \cs{bbl@redefine}} +% The macro |\nocite| which is used to instruct BiB\TeX\ to +% extract uncited references from the database. +% \begin{macrocode} + \bbl@redefine\nocite#1{% + \@safe@activestrue\org@nocite{#1}\@safe@activesfalse} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\bibcite} +% \changes{babel~3.5f}{1995/11/15}{Now use \cs{bbl@redefine}} +% The macro that is used in the |.aux| file to define citation +% labels. When packages such as \pkg{natbib} or \pkg{cite} are not +% loaded its second argument is used to typeset the citation +% label. In that case, this second argument can contain active +% characters but is used in an environment where +% |\@safe@activestrue| is in effect. This switch needs to be reset +% inside the |\hbox| which contains the citation label. In order to +% determine during \file{.aux} file processing which definition of +% |\bibcite| is needed we define |\bibcite| in such a way that it +% redefines itself with the proper definition. +% \changes{babel~3.6s}{1999/04/13}{Need to determine `online' which +% definition of \cs{bibcite} is needed} +% \changes{babel~3.6v}{1999/04/21}{Also check for \pkg{cite} it can't +% handle \cs{@safe@activesfalse} in its second argument} +% \begin{macrocode} + \bbl@redefine\bibcite{% +% \end{macrocode} +% We call |\bbl@cite@choice| to select the proper definition for +% |\bibcite|. This new definition is then activated. +% \begin{macrocode} + \bbl@cite@choice + \bibcite} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\bbl@bibcite} +% \changes{babel~3.6v}{1999/04/21}{Macro \cs{bbl@bibcite} added} +% The macro |\bbl@bibcite| holds the definition of |\bibcite| +% needed when neither \pkg{natbib} nor \pkg{cite} is loaded. +% \begin{macrocode} + \def\bbl@bibcite#1#2{% + \org@bibcite{#1}{\@safe@activesfalse#2}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\bbl@cite@choice} +% \changes{babel~3.6v}{1999/04/21}{Macro \cs{bbl@cite@choice} added} +% The macro |\bbl@cite@choice| determines which definition of +% |\bibcite| is needed. +% \begin{macrocode} + \def\bbl@cite@choice{% +% \end{macrocode} +% First we give |\bibcite| its default definition. +% \begin{macrocode} + \global\let\bibcite\bbl@bibcite +% \end{macrocode} +% Then, when \pkg{natbib} is loaded we restore the original +% definition of |\bibcite| . +% \begin{macrocode} + \@ifpackageloaded{natbib}{\global\let\bibcite\org@bibcite}{}% +% \end{macrocode} +% For \pkg{cite} we do the same. +% \begin{macrocode} + \@ifpackageloaded{cite}{\global\let\bibcite\org@bibcite}{}% +% \end{macrocode} +% Make sure this only happens once. +% \begin{macrocode} + \global\let\bbl@cite@choice\relax} +% \end{macrocode} +% +% When a document is run for the first time, no \file{.aux} file is +% available, and |\bibcite| will not yet be properly defined. In +% this case, this has to happen before the document starts. +% \begin{macrocode} + \AtBeginDocument{\bbl@cite@choice} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\@bibitem} +% \changes{babel~3.5f}{1995/11/15}{Now use \cs{bbl@redefine}} +% One of the two internal \LaTeX\ macros called by |\bibitem| +% that write the citation label on the |.aux| file. +% \begin{macrocode} + \bbl@redefine\@bibitem#1{% + \@safe@activestrue\org@@bibitem{#1}\@safe@activesfalse} +\else + \let\org@nocite\nocite + \let\org@@citex\@citex + \let\org@bibcite\bibcite + \let\org@@bibitem\@bibitem +\fi +% \end{macrocode} +% \end{macro} +% +% \subsection{Marks} +% +% \begin{macro}{\markright} +% \changes{babel~3.6i}{1997/03/15}{Added redefinition of \cs{mark...} +% commands} +% Because the output routine is asynchronous, we must +% pass the current language attribute to the head lines, together +% with the text that is put into them. To achieve this we need to +% adapt the definition of |\markright| and |\markboth| somewhat. +% \changes{babel~3.7c}{1999/04/08}{Removed the use of \cs{head@lang} +% (PR 2990)} +% \changes{babel~3.7c}{1999/04/09}{Avoid expanding the arguments by +% storing them in token registers} +% \changes{babel~3.7m}{2003/11/15}{added \cs{bbl@restore@actives} to +% the mark} +% \changes{babel~3.8c}{2004/05/26}{No need to add \emph{anything} to +% an empty mark; prevented this by checking the contents of the +% argument} +% \changes{babel~3.8f}{2005/05/15}{Make the definition independent of +% the original definition; expand \cs{languagename} before passing +% it into the token registers} +% \begin{macrocode} +\bbl@redefine\markright#1{% +% \end{macrocode} +% First of all we temporarily store the language switching command, +% using an expanded definition in order to get the current value of +% |\languagename|. +% \begin{macrocode} + \edef\bbl@tempb{\noexpand\protect + \noexpand\foreignlanguage{\languagename}}% +% \end{macrocode} +% Then, we check whether the argument is empty; if it is, we +% just make sure the scratch token register is empty. +% \begin{macrocode} + \def\bbl@arg{#1}% + \ifx\bbl@arg\@empty + \toks@{}% + \else +% \end{macrocode} +% Next, we store the argument to |\markright| in the scratch token +% register, together with the expansion of |\bbl@tempb| (containing +% the language switching command) as defined before. This way +% these commands will not be expanded by using |\edef| later +% on, and we make sure that the text is typeset using the +% correct language settings. While doing so, we make sure that +% active characters that may end up in the mark are not disabled by +% the output routine kicking in while \cs{@safe@activestrue} is in +% effect. +% \begin{macrocode} + \expandafter\toks@\expandafter{% + \bbl@tempb{\protect\bbl@restore@actives#1}}% + \fi +% \end{macrocode} +% Then we define a temporary control sequence using |\edef|. +% \begin{macrocode} + \edef\bbl@tempa{% +% \end{macrocode} +% When |\bbl@tempa| is executed, only |\languagename| will be +% expanded, because of the way the token register was filled. +% \begin{macrocode} + \noexpand\org@markright{\the\toks@}}% + \bbl@tempa +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\markboth} +% \begin{macro}{\@mkboth} +% The definition of |\markboth| is equivalent to that of +% |\markright|, except that we need two token registers. The +% documentclasses \cls{report} and \cls{book} define and set the +% headings for the page. While doing so they also store a copy of +% |\markboth| in |\@mkboth|. Therefor we need to check whether +% |\@mkboth| has already been set. If so we neeed to do that again +% with the new definition of |\makrboth|. +% \changes{babel~3.7m}{2003/11/15}{added \cs{bbl@restore@actives} to +% the mark} +% \changes{babel~3.8c}{2004/05/26}{No need to add \emph{anything} to +% an empty mark, prevented this by checking the contents of the +% arguments} +% \changes{babel~3.8f}{2005/05/15}{Make the definition independent of +% the original definition; expand \cs{languagename} before passing +% it into the token registers} +% \changes{babel~3.8j}{2008/03/21}{Added setting of \cs{@mkboth} (PR +% 3826)} +% \begin{macrocode} +\ifx\@mkboth\markboth + \def\bbl@tempc{\let\@mkboth\markboth} +\else + \def\bbl@tempc{} +\fi +% \end{macrocode} +% Now we can start the new definition of |\markboth| +% \begin{macrocode} +\bbl@redefine\markboth#1#2{% + \edef\bbl@tempb{\noexpand\protect + \noexpand\foreignlanguage{\languagename}}% + \def\bbl@arg{#1}% + \ifx\bbl@arg\@empty + \toks@{}% + \else + \expandafter\toks@\expandafter{% + \bbl@tempb{\protect\bbl@restore@actives#1}}% + \fi + \def\bbl@arg{#2}% + \ifx\bbl@arg\@empty + \toks8{}% + \else + \expandafter\toks8\expandafter{% + \bbl@tempb{\protect\bbl@restore@actives#2}}% + \fi + \edef\bbl@tempa{% + \noexpand\org@markboth{\the\toks@}{\the\toks8}}% + \bbl@tempa +} +% \end{macrocode} +% and copy it to |\@mkboth| if necesary. +% \begin{macrocode} +\bbl@tempc +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \subsection{Preventing clashes with other packages} +% +% \subsubsection{\pkg{ifthen}} +% +% \begin{macro}{\ifthenelse} +% \changes{babel~3.5g}{1996/08/11}{Redefinition of \cs{ifthenelse} +% added to circumvent problems with \cs{pageref} in the argument of +% \cs{isodd}} +% \changes{babel~3.9a}{2012/09/07}{Redefine only if `ref' is `safe'}% +% \changes{babel~3.9a}{2013/01/03}{Moved to babel.def} +% Sometimes a document writer wants to create a special effect +% depending on the page a certain fragment of text appears on. This +% can be achieved by the following piece of code: +% \begin{verbatim} +% \ifthenelse{\isodd{\pageref{some:label}}} +% {code for odd pages} +% {code for even pages} +%\end{verbatim} +% In order for this to work the argument of |\isodd| needs to be +% fully expandable. With the above redefinition of |\pageref| it is +% not in the case of this example. To overcome that, we add some +% code to the definition of |\ifthenelse| to make things work. +% +% The first thing we need to do is check if the package +% \pkg{ifthen} is loaded. This should be done at |\begin{document}| +% time. +% \begin{macrocode} +\@expandtwoargs\in@{R}\bbl@opt@safe +\ifin@ + \AtBeginDocument{% + \@ifpackageloaded{ifthen}{% +% \end{macrocode} +% Then we can redefine |\ifthenelse|: +% \changes{babel~3.6f}{1997/01/14}{\cs{ifthenelse} needs to be long} +% \changes{babel~3.9a}{2012/06/22}{\cs{ref} is also taken into account} +% \begin{macrocode} + \bbl@redefine@long\ifthenelse#1#2#3{% +% \end{macrocode} +% We want to revert the definition of |\pageref| and |\ref| to +% their original definition for the duration of |\ifthenelse|, +% so we first need to store their current meanings. +% \begin{macrocode} + \let\bbl@tempa\pageref + \let\pageref\org@pageref + \let\bbl@tempb\ref + \let\ref\org@ref +% \end{macrocode} +% Then we can set the |\@safe@actives| switch and call the original +% |\ifthenelse|. In order to be able to use shorthands in the +% second and third arguments of |\ifthenelse| the resetting of the +% switch \emph{and} the definition of |\pageref| happens inside +% those arguments. When the package wasn't loaded we do nothing. +% \changes{babel~3.6i}{1997/02/25}{Now reset the @safe@actives switch +% inside the 2nd and 3rd arguments of \cs{ifthenelse}} +% \changes{babel~3.7f}{2000/06/29}{\cs{pageref} needs to have its +% babel definition reinstated in the second and third arguments} +% \begin{macrocode} + \@safe@activestrue + \org@ifthenelse{#1}{% + \let\pageref\bbl@tempa + \let\ref\bbl@tempb + \@safe@activesfalse + #2}{% + \let\pageref\bbl@tempa + \let\ref\bbl@tempb + \@safe@activesfalse + #3}% + }% + }{}% + } +% \end{macrocode} +% \end{macro} +% +% \subsubsection{\pkg{varioref}} +% +% \begin{macro}{\@@vpageref} +% \changes{babel~3.6a}{1996/10/29}{Redefinition of \cs{@@vpageref} +% added to circumvent problems with active \texttt{:} in the +% argument of \cs{vref} when \pkg{varioref} is used} +% \begin{macro}{\vrefpagenum} +% \changes{babel~3.7o}{2003/11/18}{Added redefinition of +% \cs{vrefpagenum} which deals with ranges of pages} +% \begin{macro}{\Ref} +% \changes{babel~3.8g}{2005/05/21}{We also need to adapt \cs{Ref} +% which needs to be able to uppercase the first letter of the +% expansion of \cs{ref}} +% When the package varioref is in use we need to modify its +% internal command |\@@vpageref| in order to prevent problems when +% an active character ends up in the argument of |\vref|. +% \begin{macrocode} + \AtBeginDocument{% + \@ifpackageloaded{varioref}{% + \bbl@redefine\@@vpageref#1[#2]#3{% + \@safe@activestrue + \org@@@vpageref{#1}[#2]{#3}% + \@safe@activesfalse}% +% \end{macrocode} +% The same needs to happen for |\vrefpagenum|. +% \begin{macrocode} + \bbl@redefine\vrefpagenum#1#2{% + \@safe@activestrue + \org@vrefpagenum{#1}{#2}% + \@safe@activesfalse}% +% \end{macrocode} +% The package \pkg{varioref} defines |\Ref| to be a robust command +% wich uppercases the first character of the reference text. In +% order to be able to do that it needs to access the exandable form +% of |\ref|. So we employ a little trick here. We redefine the +% (internal) command \verb*|\Ref | to call |\org@ref| instead of +% |\ref|. The disadvantgage of this solution is that whenever the +% derfinition of |\Ref| changes, this definition needs to be updated +% as well. +% \begin{macrocode} + \expandafter\def\csname Ref \endcsname#1{% + \protected@edef\@tempa{\org@ref{#1}}\expandafter\MakeUppercase\@tempa} + }{}% + } +\fi +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% \subsubsection{\pkg{hhline}} +% +% \begin{macro}{\hhline} +% Delaying the activation of the shorthand characters has introduced +% a problem with the \pkg{hhline} package. The reason is that it +% uses the `:' character which is made active by the french support +% in \babel. Therefor we need to \emph{reload} the package when +% the `:' is an active character. +% +% So at |\begin{document}| we check whether \pkg{hhline} is loaded. +% \begin{macrocode} +\AtEndOfPackage{% + \AtBeginDocument{% + \@ifpackageloaded{hhline}% +% \end{macrocode} +% Then we check whether the expansion of |\normal@char:| is not +% equal to |\relax|. +% \changes{babel~3.8b}{2004/04/19}{added \cs{string} to prevent +% unwanted expansion of the colon} +% \begin{macrocode} + {\expandafter\ifx\csname normal@char\string:\endcsname\relax + \else +% \end{macrocode} +% In that case we simply reload the package. Note that this happens +% \emph{after} the category code of the @-sign has been changed to +% other, so we need to temporarily change it to letter again. +% \begin{macrocode} + \makeatletter + \def\@currname{hhline}\input{hhline.sty}\makeatother + \fi}% + {}}} +% \end{macrocode} +% \end{macro} +% +% \subsubsection{\pkg{hyperref}} +% +% \begin{macro}{\pdfstringdefDisableCommands} +% \changes{babel~3.8j}{2008/03/16}{Inform \pkg{hyperref} to use +% shorthands at system level (PR4006)} +% +% A number of interworking problems between \pkg{babel} and +% \pkg{hyperref} are tackled by \pkg{hyperref} itself. The +% following code was introduced to prevent some annoying warnings +% but it broke bookmarks. This was quickly fixed in \pkg{hyperref}, +% which essentially made it no-op. However, it will not removed for +% the moment because \pkg{hyperref} is expecting it, . +% +% \begin{macrocode} +\AtBeginDocument{% + \@ifundefined{pdfstringdefDisableCommands}% + {}% + {\pdfstringdefDisableCommands{% + \languageshorthands{system}}% + }% +} +% \end{macrocode} +% \end{macro} +% +% \subsubsection{\pkg{fancyhdr}} +% +% \begin{macro}{\FOREIGNLANGUAGE} +% The package \pkg{fancyhdr} treats the running head and fout lines +% somewhat differently as the standard classes. A symptom of this is +% that the command |\foreignlanguage| which \babel\ adds to the +% marks can end up inside the argument of |\MakeUppercase|. To +% prevent unexpected results we need to define |\FOREIGNLANGUAGE| +% here. +% \changes{babel~3.7j}{2003/05/23}{Define \cs{FOREIGNLANGUAGE} +% unconditionally} +% \begin{macrocode} +\DeclareRobustCommand{\FOREIGNLANGUAGE}[1]{% + \lowercase{\foreignlanguage{#1}}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\substitutefontfamily} +% The command |\substitutefontfamily| creates an +% \file{.fd} file on the fly. The first argument is an encoding +% mnemonic, the second and third arguments are font family names. +% \changes{babel~3.7j}{2003/06/15}{create file with lowercase name} +% \begin{macrocode} +\def\substitutefontfamily#1#2#3{% + \lowercase{\immediate\openout15=#1#2.fd\relax}% + \immediate\write15{% + \string\ProvidesFile{#1#2.fd}% + [\the\year/\two@digits{\the\month}/\two@digits{\the\day} + \space generated font description file]^^J + \string\DeclareFontFamily{#1}{#2}{}^^J + \string\DeclareFontShape{#1}{#2}{m}{n}{<->ssub * #3/m/n}{}^^J + \string\DeclareFontShape{#1}{#2}{m}{it}{<->ssub * #3/m/it}{}^^J + \string\DeclareFontShape{#1}{#2}{m}{sl}{<->ssub * #3/m/sl}{}^^J + \string\DeclareFontShape{#1}{#2}{m}{sc}{<->ssub * #3/m/sc}{}^^J + \string\DeclareFontShape{#1}{#2}{b}{n}{<->ssub * #3/bx/n}{}^^J + \string\DeclareFontShape{#1}{#2}{b}{it}{<->ssub * #3/bx/it}{}^^J + \string\DeclareFontShape{#1}{#2}{b}{sl}{<->ssub * #3/bx/sl}{}^^J + \string\DeclareFontShape{#1}{#2}{b}{sc}{<->ssub * #3/bx/sc}{}^^J + }% + \closeout15 + } +% \end{macrocode} +% This command should only be used in the preamble of a document. +% \begin{macrocode} +\@onlypreamble\substitutefontfamily +% \end{macrocode} +% \end{macro} +% +% \subsection{Encoding issues (part 2)} +% +% \changes{babel~3.7c}{1999/04/16}{Removed redefinition of \cs{@roman} +% and \cs{@Roman}} +% +% \begin{macro}{\TeX} +% \begin{macro}{\LaTeX} +% \changes{babel~3.7a}{1998/03/12}{Make \TeX\ and \LaTeX\ logos +% encoding-independent} +% Because documents may use font encodings other than one of the +% latin encodings, we make sure that the logos of \TeX\ and +% \LaTeX\ always come out in the right encoding. +% \begin{macrocode} +\bbl@redefine\TeX{\textlatin{\org@TeX}} +\bbl@redefine\LaTeX{\textlatin{\org@LaTeX}} +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\nfss@catcodes} +% \changes{babel~3.5g}{1996/08/18}{Need to add the double quote and +% acute characters to \cs{nfss@catcodes} to prevent problems when +% reading in .fd files} +% \LaTeX's font selection scheme sometimes wants to read font +% definition files in the middle of processing the document. In +% order to guard against any characters having the wrong +% |\catcode|s it always calls |\nfss@catcodes| before loading a +% file. Unfortunately, the characters |"| and |'| are not dealt +% with. Therefor we have to add them until \LaTeX\ does that +% itself. +% \begin{macrocode} +\bbl@add\nfss@catcodes{% + \@makeother\'% + \@makeother\"} +% \end{macrocode} +% \end{macro} +% +% \subsection{Local Language Configuration} +% +% \begin{macro}{\loadlocalcfg} +% At some sites it may be necessary to add site-specific actions to +% a language definition file. This can be done by creating a file +% with the same name as the language definition file, but with the +% extension \file{.cfg}. For instance the file \file{norsk.cfg} +% will be loaded when the language definition file \file{norsk.ldf} +% is loaded. +% +% \changes{babel~3.5d}{1995/06/22}{Added macro} +% For plain-based formats we don't want to override the definition +% of |\loadlocalcfg| from \file{plain.def}. +% \begin{macrocode} +\ifx\loadlocalcfg\@undefined + \@ifpackagewith{babel}{noconfigs}% + {\let\loadlocalcfg\@gobble}% + {\def\loadlocalcfg#1{% + \InputIfFileExists{#1.cfg}% + {\typeout{*************************************^^J% + * Local config file #1.cfg used^^J% + *}}% + \@empty}} +\fi +% \end{macrocode} +% Just to be compatible with \LaTeX$\:$2.09 we add a few more lines +% of code: +% \begin{macrocode} +\ifx\@unexpandable@protect\@undefined + \def\@unexpandable@protect{\noexpand\protect\noexpand} + \long\def\protected@write#1#2#3{% + \begingroup + \let\thepage\relax + #2% + \let\protect\@unexpandable@protect + \edef\reserved@a{\write#1{#3}}% + \reserved@a + \endgroup + \if@nobreak\ifvmode\nobreak\fi\fi} +\fi +% \end{macrocode} +% Finally, the default is to use English as the main language. +% \changes{babel~3.6c}{1997/01/05}{When \file{hyphen.cfg} is not +% loaded in the format \cs{l@english} might not be defined; assume +% english is language 0} +% \changes{babel~3.9a}{2012-05-17}{Languages are best assigned with +% \cs{chardef}, not \cs{let}} +% \begin{macrocode} +\ifx\l@english\@undefined + \chardef\l@english\z@ +\fi +\main@language{english} +%</core> +% \end{macrocode} +% \end{macro} +% +% +% Now that we're sure that the code is seen by \LaTeX\ only, we +% have to find out what the main (primary) document style is +% because we want to redefine some macros. This is only necessary +% for releases of \LaTeX\ dated before December~1991. Therefor +% this part of the code can optionally be included in +% \file{babel.def} by specifying the \texttt{docstrip} option +% \texttt{names}. +% \begin{macrocode} +%<*names> +% \end{macrocode} +% +% The standard styles can be distinguished by checking whether some +% macros are defined. In table~\ref{styles} an overview is given of +% the macros that can be used for this purpose. +% \begin{table}[htb] +% \begin{center} +% \DeleteShortVerb{\|} +% \begin{tabular}{|lcp{8cm}|} +% \hline +% article & : & both the \verb+\chapter+ and \verb+\opening+ +% macros are undefined\\ +% report and book & : & the \verb+\chapter+ macro is defined and +% the \verb+\opening+ is undefined\\ +% letter & : & the \verb+\chapter+ macro is undefined and +% the \verb+\opening+ is defined\\ +% \hline +% \end{tabular} +% \caption{How to determine the main document style}\label{styles} +% \MakeShortVerb{\|} +% \end{center} +% \end{table} +% +% \noindent The macros that have to be redefined for the +% \texttt{report} and \texttt{book} document styles happen to be +% the same, so there is no need to distinguish between those two +% styles. +% +% \begin{macro}{\doc@style} +% First a parameter |\doc@style| is defined to identify the current +% document style. This parameter might have been defined by a +% document style that already uses macros instead of hard-wired +% texts, such as \file{artikel1.sty}~\cite{BEP}, so the existence of +% |\doc@style| is checked. If this macro is undefined, i.\,e., if +% the document style is unknown and could therefore contain +% hard-wired texts, |\doc@style| is defined to the default +% value~`0'. +% \changes{babel~3.0d}{1991/10/29}{Removed use of \cs{@ifundefined}} +% \begin{macrocode} +\ifx\@undefined\doc@style + \def\doc@style{0}% +% \end{macrocode} +% This parameter is defined in the following \texttt{if} +% construction (see table~\ref{styles}): +% +% \begin{macrocode} + \ifx\@undefined\opening + \ifx\@undefined\chapter + \def\doc@style{1}% + \else + \def\doc@style{2}% + \fi + \else + \def\doc@style{3}% + \fi% +\fi% +% \end{macrocode} +% \end{macro} +% +% \changes{babel~3.1}{1991/11/05}{Removed definition of +% \cs{if@restonecol}} +% +% \subsubsection{Redefinition of macros} +% +% Now here comes the real work: we start to redefine things and +% replace hard-wired texts by macros. These redefinitions should be +% carried out conditionally, in case it has already been done. +% +% For the \texttt{figure} and \texttt{table} environments we have +% in all styles: +% \begin{macrocode} +\@ifundefined{figurename}{\def\fnum@figure{\figurename{} \thefigure}}{} +\@ifundefined{tablename}{\def\fnum@table{\tablename{} \thetable}}{} +% \end{macrocode} +% +% The rest of the macros have to be treated differently for each +% style. When |\doc@style| still has its default value nothing +% needs to be done. +% \begin{macrocode} +\ifcase \doc@style\relax +\or +% \end{macrocode} +% +% This means that \file{babel.def} is read after the +% \texttt{article} style, where no |\chapter| and |\opening| +% commands are defined\footnote{A fact that was pointed out to me +% by Nico Poppelier and was already used in Piet van Oostrum's +% document style option~\texttt{nl}.}. +% +% First we have the |\tableofcontents|, +% |\listoffigures| and |\listoftables|: +% \begin{macrocode} +\@ifundefined{contentsname}% + {\def\tableofcontents{\section*{\contentsname\@mkboth + {\uppercase{\contentsname}}{\uppercase{\contentsname}}}% + \@starttoc{toc}}}{} +\@ifundefined{listfigurename}% + {\def\listoffigures{\section*{\listfigurename\@mkboth + {\uppercase{\listfigurename}}{\uppercase{\listfigurename}}}% + \@starttoc{lof}}}{} +\@ifundefined{listtablename}% + {\def\listoftables{\section*{\listtablename\@mkboth + {\uppercase{\listtablename}}{\uppercase{\listtablename}}}% + \@starttoc{lot}}}{} +% \end{macrocode} +% +% Then the |\thebibliography| and |\theindex| environments. +% +% \begin{macrocode} +\@ifundefined{refname}% + {\def\thebibliography#1{\section*{\refname + \@mkboth{\uppercase{\refname}}{\uppercase{\refname}}}% + \list{[\arabic{enumi}]}{\settowidth\labelwidth{[#1]}% + \leftmargin\labelwidth + \advance\leftmargin\labelsep + \usecounter{enumi}}% + \def\newblock{\hskip.11em plus.33em minus.07em}% + \sloppy\clubpenalty4000\widowpenalty\clubpenalty + \sfcode`\.=1000\relax}}{} +\@ifundefined{indexname}% + {\def\theindex{\@restonecoltrue\if@twocolumn\@restonecolfalse\fi + \columnseprule \z@ + \columnsep 35pt\twocolumn[\section*{\indexname}]% + \@mkboth{\uppercase{\indexname}}{\uppercase{\indexname}}% + \thispagestyle{plain}% + \parskip\z@ plus.3pt\parindent\z@\let\item\@idxitem}}{} +% \end{macrocode} +% +% The |abstract| environment: +% +% \begin{macrocode} +\@ifundefined{abstractname}% + {\def\abstract{\if@twocolumn + \section*{\abstractname}% + \else \small + \begin{center}% + {\bf \abstractname\vspace{-.5em}\vspace{\z@}}% + \end{center}% + \quotation + \fi}}{} +% \end{macrocode} +% +% And last but not least, the macro |\part|: +% +% \begin{macrocode} +\@ifundefined{partname}% +{\def\@part[#1]#2{\ifnum \c@secnumdepth >\m@ne + \refstepcounter{part}% + \addcontentsline{toc}{part}{\thepart + \hspace{1em}#1}\else + \addcontentsline{toc}{part}{#1}\fi + {\parindent\z@ \raggedright + \ifnum \c@secnumdepth >\m@ne + \Large \bf \partname{} \thepart + \par \nobreak + \fi + \huge \bf + #2\markboth{}{}\par}% + \nobreak + \vskip 3ex\@afterheading}% +}{} +% \end{macrocode} +% +% This is all that needs to be done for the \texttt{article} style. +% +% \begin{macrocode} +\or +% \end{macrocode} +% +% The next case is formed by the two styles \texttt{book} and +% \texttt{report}. Basically we have to do the same as for the +% \texttt{article} style, except now we must also change the +% |\chapter| command. +% +% The tables of contents, figures and tables: +% \begin{macrocode} +\@ifundefined{contentsname}% + {\def\tableofcontents{\@restonecolfalse + \if@twocolumn\@restonecoltrue\onecolumn + \fi\chapter*{\contentsname\@mkboth + {\uppercase{\contentsname}}{\uppercase{\contentsname}}}% + \@starttoc{toc}% + \csname if@restonecol\endcsname\twocolumn + \csname fi\endcsname}}{} +\@ifundefined{listfigurename}% + {\def\listoffigures{\@restonecolfalse + \if@twocolumn\@restonecoltrue\onecolumn + \fi\chapter*{\listfigurename\@mkboth + {\uppercase{\listfigurename}}{\uppercase{\listfigurename}}}% + \@starttoc{lof}% + \csname if@restonecol\endcsname\twocolumn + \csname fi\endcsname}}{} +\@ifundefined{listtablename}% + {\def\listoftables{\@restonecolfalse + \if@twocolumn\@restonecoltrue\onecolumn + \fi\chapter*{\listtablename\@mkboth + {\uppercase{\listtablename}}{\uppercase{\listtablename}}}% + \@starttoc{lot}% + \csname if@restonecol\endcsname\twocolumn + \csname fi\endcsname}}{} +% \end{macrocode} +% +% Again, the |bibliography| and |index| environments; notice that +% in this case we use |\bibname| instead of |\refname| as in the +% definitions for the \texttt{article} style. The reason for this +% is that in the \texttt{article} document style the term +% `References' is used in the definition of |\thebibliography|. In +% the \texttt{report} and \texttt{book} document styles the term +% `Bibliography' is used. +% \begin{macrocode} +\@ifundefined{bibname}% + {\def\thebibliography#1{\chapter*{\bibname + \@mkboth{\uppercase{\bibname}}{\uppercase{\bibname}}}% + \list{[\arabic{enumi}]}{\settowidth\labelwidth{[#1]}% + \leftmargin\labelwidth \advance\leftmargin\labelsep + \usecounter{enumi}}% + \def\newblock{\hskip.11em plus.33em minus.07em}% + \sloppy\clubpenalty4000\widowpenalty\clubpenalty + \sfcode`\.=1000\relax}}{} +\@ifundefined{indexname}% + {\def\theindex{\@restonecoltrue\if@twocolumn\@restonecolfalse\fi + \columnseprule \z@ + \columnsep 35pt\twocolumn[\@makeschapterhead{\indexname}]% + \@mkboth{\uppercase{\indexname}}{\uppercase{\indexname}}% + \thispagestyle{plain}% + \parskip\z@ plus.3pt\parindent\z@ \let\item\@idxitem}}{} +% \end{macrocode} +% +% Here is the |abstract| environment: +% \begin{macrocode} +\@ifundefined{abstractname}% + {\def\abstract{\titlepage + \null\vfil + \begin{center}% + {\bf \abstractname}% + \end{center}}}{} +% \end{macrocode} +% +% And last but not least the |\chapter|, |\appendix| and +% |\part| macros. +% \begin{macrocode} +\@ifundefined{chaptername}{\def\@chapapp{\chaptername}}{} +% +\@ifundefined{appendixname}% + {\def\appendix{\par + \setcounter{chapter}{0}% + \setcounter{section}{0}% + \def\@chapapp{\appendixname}% + \def\thechapter{\Alph{chapter}}}}{} +% +\@ifundefined{partname}% + {\def\@part[#1]#2{\ifnum \c@secnumdepth >-2\relax + \refstepcounter{part}% + \addcontentsline{toc}{part}{\thepart + \hspace{1em}#1}\else + \addcontentsline{toc}{part}{#1}\fi + \markboth{}{}% + {\centering + \ifnum \c@secnumdepth >-2\relax + \huge\bf \partname{} \thepart + \par + \vskip 20pt \fi + \Huge \bf + #1\par}\@endpart}}{}% +% \end{macrocode} +% +% \begin{macrocode} +\or +% \end{macrocode} +% +% Now we address the case where \file{babel.def} is read after the +% \texttt{letter} style. The \texttt{letter} document style +% defines the macro |\opening| and some other macros that are +% specific to \texttt{letter}. This means that we have to redefine +% other macros, compared to the previous two cases. +% +% First two macros for the material at the end of a letter, the +% |\cc| and |\encl| macros. +% \begin{macrocode} +\@ifundefined{ccname}% + {\def\cc#1{\par\noindent + \parbox[t]{\textwidth}% + {\@hangfrom{\rm \ccname : }\ignorespaces #1\strut}\par}}{} +\@ifundefined{enclname}% + {\def\encl#1{\par\noindent + \parbox[t]{\textwidth}% + {\@hangfrom{\rm \enclname : }\ignorespaces #1\strut}\par}}{} +% \end{macrocode} +% +% The last thing we have to do here is to redefine the +% \texttt{headings} pagestyle: +% \changes{babel~3.3}{1993/07/11}{\cs{headpagename} should be +% \cs{pagename}} +% \begin{macrocode} +\@ifundefined{headtoname}% + {\def\ps@headings{% + \def\@oddhead{\sl \headtoname{} \ignorespaces\toname \hfil + \@date \hfil \pagename{} \thepage}% + \def\@oddfoot{}}}{} +% \end{macrocode} +% +% This was the last of the four standard document styles, so if +% |\doc@style| has another value we do nothing and just close the +% \texttt{if} construction. +% \begin{macrocode} +\fi +%</names> +% \end{macrocode} +% Here ends the code that can be optionally included when a version +% of \LaTeX\ is in use that is dated \emph{before} December~1991. +% +% +% We also need to redefine a number of commands to ensure that the +% right font encoding is used, but this can't be done before +% \file{babel.def} is loaded. +% \changes{babel~3.6o}{1999/04/07}{Moved the rest of the font encoding +% related definitions to their original place} +% +% \subsection{Multiple languages} +% +% \begin{macro}{\language} +% Plain \TeX\ version~3.0 provides the primitive |\language| that +% is used to store the current language. When used with a pre-3.0 +% version this function has to be implemented by allocating a +% counter. +% \begin{macrocode} +%<*kernel|patterns> +\ifx\language\@undefined + \csname newcount\endcsname\language +\fi +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\last@language} +% Another counter is used to store the last language defined. For +% pre-3.0 formats an extra counter has to be allocated. +% +% \begin{macro}{\addlanguage} +% +% To add languages to \TeX's memory plain \TeX\ version~3.0 +% supplies |\newlanguage|, in a pre-3.0 environment a similar macro +% has to be provided. For both cases a new macro is defined here, +% because the original |\newlanguage| was defined to be |\outer|. +% +% For a format based on plain version~2.x, the definition of +% |\newlanguage| can not be copied because |\count 19| is used for +% other purposes in these formats. Therefor |\addlanguage| is +% defined using a definition based on the macros used to define +% |\newlanguage| in plain \TeX\ version~3.0. +% \changes{babel~3.2}{1991/11/11}{Added a \texttt{\%}, removed +% \texttt{by}} +% +% For formats based on plain version~3.0 the definition of +% |\newlanguage| can be simply copied, removing |\outer|. +% \begin{macrocode} +\ifx\newlanguage\@undefined + \csname newcount\endcsname\last@language + \def\addlanguage#1{% + \global\advance\last@language\@ne + \ifnum\last@language<\@cclvi + \else + \errmessage{No room for a new \string\language!}% + \fi + \global\chardef#1\last@language + \wlog{\string#1 = \string\language\the\last@language}} +% \end{macrocode} +% plain \TeX\ version 3.0 uses |\count 19| for this purpose. +% \begin{macrocode} +\else + \countdef\last@language=19 + \def\addlanguage{\alloc@9\language\chardef\@cclvi} +\fi +%</kernel|patterns> +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% \begin{macro}{\adddialect} +% The macro |\adddialect| can be used to add the name of a dialect +% or variant language, for which an already defined hyphenation +% table can be used. +% \changes{babel~3.2}{1991/11/11}{Added \cs{relax}} +% \begin{macrocode} +%<*kernel> +\def\adddialect#1#2{% + \global\chardef#1#2\relax + \bbl@usehooks{adddialect}{{#1}{#2}}% + \wlog{\string#1 = a dialect from \string\language#2}} +% \end{macrocode} +% \end{macro} +% \changes{babel~3.9a}{2012/09/07}{Added macro} +% \changes{babel~3.9a}{2013/01/23}{New macro to normalize +% a macro (eg, \cs{languagename}) to lowercase if necessary} +% +% |\bbl@iflanguage| executes code only of the language +% exists. Otherwise raises and error. +% +% The argument of |\bbl@fixname| has to be a macro name, as it may get +% ``fixed'' if casing (lc/uc) is wrong. It's intented to fix a +% long-standing bug when |\foreignlanguage| and the like appear in +% a |\MakeXXXcase|. However, a lowercase form is not imposed to +% improve backward compatibility (perhaps you defined a language +% named |MYLANG|, but unfortunately mixed case names cannot be +% trapped). +% \begin{macrocode} +\def\bbl@fixname#1{% + \begingroup + \def\bbl@tempe{l@}% + \edef\bbl@tempd{\noexpand\@ifundefined{\noexpand\bbl@tempe#1}}% + \bbl@tempd + {\lowercase\expandafter{\bbl@tempd}% + {\uppercase\expandafter{\bbl@tempd}% + \@empty + {\edef\bbl@tempd{\def\noexpand#1{#1}}% + \uppercase\expandafter{\bbl@tempd}}}% + {\edef\bbl@tempd{\def\noexpand#1{#1}}% + \lowercase\expandafter{\bbl@tempd}}}% + \@empty + \edef\bbl@tempd{\endgroup\def\noexpand#1{#1}}% + \bbl@tempd} +\def\bbl@iflanguage#1{% + \@ifundefined{l@#1}{\@nolanerr{#1}\@gobble}\@firstofone} +% \end{macrocode} +% +% \begin{macro}{\iflanguage} +% Users might want to test (in a private package for instance) +% which language is currently active. For this we provide a test +% macro, |\iflanguage|, that has three arguments. It checks +% whether the first argument is a known language. If so, it +% compares the first argument with the value of |\language|. Then, +% depending on the result of the comparison, it executes either the +% second or the third argument. +% \changes{babel~3.2}{1991/11/11}{Rephrased \cs{ifnum} test} +% \changes{babel~3.7a}{1998/06/10}{Now evaluate the \cs{ifnum} test +% \emph{after} the \cs{fi} from the \cs{ifx} test and use +% \cs{@firstoftwo} and \cs{@secondoftwo}} +% \begin{macrocode} +\def\iflanguage#1{% + \bbl@iflanguage{#1}{% + \ifnum\csname l@#1\endcsname=\language + \expandafter\@firstoftwo + \else + \expandafter\@secondoftwo + \fi}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\selectlanguage} +% The macro |\selectlanguage| checks whether the language is +% already defined before it performs its actual task, which is to +% update |\language| and activate language-specific definitions. +% +% To allow the call of |\selectlanguage| either with a control +% sequence name or with a simple string as argument, we have to use +% a trick to delete the optional escape character. +% +% To convert a control sequence to a string, we use the |\string| +% primitive. Next we have to look at the first character of this +% string and compare it with the escape character. Because this +% escape character can be changed by setting the internal integer +% |\escapechar| to a character number, we have to compare this +% number with the character of the string. To do this we have to +% use \TeX's backquote notation to specify the character as a +% number. +% +% If the first character of the |\string|'ed argument is the +% current escape character, the comparison has stripped this +% character and the rest in the `then' part consists of the rest of +% the control sequence name. Otherwise we know that either the +% argument is not a control sequence or |\escapechar| is set to a +% value outside of the character range~$0$--$255$. +% +% If the user gives an empty argument, we provide a default +% argument for |\string|. This argument should expand to nothing. +% +% \changes{babel~3.0c}{1991/06/06}{Made \cs{selectlanguage} +% robust} +% \changes{babel~3.2}{1991/11/11}{Modified to allow arguments that +% start with an escape character} +% \changes{babel~3.2a}{1991/11/17}{Simplified the modification to +% allow the use in a \cs{write} command} +% \changes{babel~3.5b}{1995/05/13}{Store the name of the current +% language in a control sequence instead of passing the whole macro +% construct to strip the escape character in the argument of +% \cs{selectlanguage }.} +% \changes{babel~3.5f}{1995/11/16}{Moved check for escape character +% one level down in the expansion} +% \changes{babel~3.9a}{2012/11/16}{\cs{bbl@select@type} keep tracks of +% the selection method: 0 is select, 1 is foreign} +% \begin{macrocode} +\let\bbl@select@type\z@ +\edef\selectlanguage{% + \noexpand\protect + \expandafter\noexpand\csname selectlanguage \endcsname} +% \end{macrocode} +% Because the command |\selectlanguage| could be used in a moving +% argument it expands to \verb*=\protect\selectlanguage =. +% Therefor, we have to make sure that a macro |\protect| exists. +% If it doesn't it is |\let| to |\relax|. +% \begin{macrocode} +\ifx\@undefined\protect\let\protect\relax\fi +% \end{macrocode} +% As \LaTeX$\:$2.09 writes to files \textit{expanded} whereas +% \LaTeXe\ takes care \textit{not} to expand the arguments of +% |\write| statements we need to be a bit clever about the way we +% add information to \file{.aux} files. Therefor we introduce the +% macro |\xstring| which should expand to the right amount of +% |\string|'s. +% \begin{macrocode} +\ifx\documentclass\@undefined + \def\xstring{\string\string\string} +\else + \let\xstring\string +\fi +% \end{macrocode} +% \end{macro} +% +% \changes{babel~3.5b}{1995/03/04}{Changed the name of the internal +% macro to \cs{selectlanguage }.} +% \changes{babel~3.5b}{1995/03/05}{Added an extra level of expansion to +% separate the switching mechanism from writing to aux files} +% \changes{babel~3.7f}{2000/09/25}{Use \cs{aftergroup} to keep the +% language grouping correct in auxiliary files {PR3091}} +% Since version 3.5 \babel\ writes entries to the auxiliary files in +% order to typeset table of contents etc. in the correct language +% environment. +% \begin{macro}{\bbl@pop@language} +% \emph{But} when the language change happens \emph{inside} a group +% the end of the group doesn't write anything to the auxiliary +% files. Therefor we need \TeX's |aftergroup| mechanism to help +% us. The command |\aftergroup| stores the token immediately +% following it to be executed when the current group is closed. So +% we define a temporary control sequence |\bbl@pop@language| to be +% executed at the end of the group. It calls |\bbl@set@language| +% with the name of the current language as its argument. +% +% \changes{babel~3.7j}{2003/03/18}{Introduce the language stack +% mechanism} +% \begin{macro}{\bbl@language@stack} +% The previous solution works for one level of nesting groups, but +% as soon as more levels are used it is no longer adequate. For +% that case we need to keep track of the nested languages using a +% stack mechanism. This stack is called |\bbl@language@stack| and +% initially empty. +% \begin{macrocode} +\def\bbl@language@stack{} +% \end{macrocode} +% When using a stack we need a mechanism to push an element on the +% stack and to retrieve the information afterwards. +% \begin{macro}{\bbl@push@language} +% \begin{macro}{\bbl@pop@language} +% The stack is simply a list of languagenames, separated with a `+' +% sign; the push function can be simple: +% \begin{macrocode} +\def\bbl@push@language{% + \xdef\bbl@language@stack{\languagename+\bbl@language@stack}} +% \end{macrocode} +% Retrieving information from the stack is a little bit less simple, +% as we need to remove the element from the stack while storing it +% in the macro |\languagename|. For this we first define a helper function. +% \begin{macro}{\bbl@pop@lang} +% This macro stores its first element (which is delimited by the +% `+'-sign) in |\languagename| and stores the rest of the string +% (delimited by `-') in its third argument. +% \begin{macrocode} +\def\bbl@pop@lang#1+#2-#3{% + \edef\languagename{#1}\xdef#3{#2}} +% \end{macrocode} +% \end{macro} +% The reason for the somewhat weird arrangement of arguments to the +% helper function is the fact it is called in the following way. +% This means that before |\bbl@pop@lang| is executed \TeX\ first +% \emph{expands} the stack, stored in |\bbl@language@stack|. The +% result of that is that the argument string of |\bbl@pop@lang| +% contains one or more language names, each followed by a `+'-sign +% (zero language names won't occur as this macro will only be +% called after something has been pushed on the stack) followed by +% the `-'-sign and finally the reference to the stack. +% \begin{macrocode} +\def\bbl@pop@language{% + \expandafter\bbl@pop@lang\bbl@language@stack-\bbl@language@stack + \expandafter\bbl@set@language\expandafter{\languagename}} +% \end{macrocode} +% Once the name of the previous language is retrieved from the stack, +% it is fed to |\bbl@set@language| to do the actual work of +% switching everything that needs switching. +% \end{macro} +% \end{macro} +% \end{macro} +% +% \changes{babel~3.7j}{2003/03/18}{Now use the language stack mechanism} +% \begin{macrocode} +\expandafter\def\csname selectlanguage \endcsname#1{% + \bbl@push@language + \aftergroup\bbl@pop@language + \bbl@set@language{#1}} +% \end{macrocode} +% \changes{babel~3.7m}{2003/11/12}{Removed the superfluous empty +% definition of \cs{bbl@pop@language}} +% \end{macro} +% +% \begin{macro}{\bbl@set@language} +% \changes{babel~3.7f}{2000/09/25}{Macro \cs{bbl@set@language} +% introduced} +% +% The macro |\bbl@set@language| takes care of switching the +% language environment \emph{and} of writing entries on the +% auxiliary files. For historial reasons, language names can be +% either |language| of |\language|. To catch either form a trick is +% used, but unfortunately as a side effect the catcodes of letters +% in |\languagename| are not well defined. The list of auxiliary +% files can be extended by redefining |\BabelContentsFiles|, but +% make sure they are loaded inside a group (as |aux|, |toc|, +% |lof|, and |lot| do) or the last language of the document will +% remain active afterwards. +% +% We also write a command to change the current language in the +% auxiliary files. +% \changes{babel~3.5a}{1995/02/17}{Write the language change to the +% auxiliary files} +% \changes{babel~3.9a}{2012/09/09}{Added hook} +% \changes{babel~3.9a}{2012/11/07}{Use a loop for contents files, with +% the help of \cs{BabelContentsFiles}} +% \changes{babel~3.9a}{2013/03/08}{Don't write to aux if language is +% unknown} +% \begin{macrocode} +\def\BabelContentsFiles{toc,lof,lot}% +\def\bbl@set@language#1{% + \edef\languagename{% + \ifnum\escapechar=\expandafter`\string#1\@empty + \else\string#1\@empty\fi}% + \select@language{\languagename}% + \expandafter\ifx\csname date\languagename\endcsname\relax\else + \if@filesw + \protected@write\@auxout{}{\string\select@language{\languagename}}% + \bbl@for\bbl@tempa\BabelContentsFiles{% + \addtocontents{\bbl@tempa}{\xstring\select@language{\languagename}}}% + \bbl@usehooks{write}{}% + \fi + \fi} +\def\select@language#1{% + \edef\languagename{#1}% + \bbl@fixname\languagename + \bbl@iflanguage\languagename{% + \expandafter\ifx\csname date\languagename\endcsname\relax + \bbl@error + {You haven't loaded the language #1\space yet}% + {You may proceed, but expect unexpected results}% + \else + \let\bbl@select@type\z@ + \expandafter\bbl@switch\expandafter{\languagename}% + \fi}} +% A bit of optmization: +\def\select@language@x#1{% + \ifcase\bbl@select@type + \bbl@ifsamestring\languagename{#1}{}{\select@language{#1}}% + \else + \select@language{#1}% + \fi} +% \end{macrocode} +% \end{macro} +% +% First, check if the user asks for a known language. If so, +% update the value of |\language| and call |\originalTeX| +% to bring \TeX\ in a certain pre-defined state. +% \changes{babel~3.0a}{1991/05/29}{Added \cs{@bsphack} and +% \cs{@esphack}} +% \changes{babel~3.0d}{1991/08/08}{Removed superfluous +% \cs{expandafter}} +% \changes{babel~3.0d}{1991/10/07}{Removed space hacks and use of +% \cs{@ifundefined}} +% \changes{babel~3.2a}{1991/11/17}{Added \cs{relax} as first command +% to stop an expansion if \cs{protect} is empty} +% \changes{babel~3.6a}{1996/11/07}{Check for the existence of +% \cs{date...} instead of \cs{l@...}} +% \changes{babel~3.7m}{2003/11/16}{Check for the existence of both +% \cs{l@...} and \cs{date...}} +% \changes{babel~3.8l}{2008/07/06}{Use \cs{bbl@patterns}} +% \changes{babel~3.9a}{2012/07/27}{Moved \cs{bbl@patterns} to the +% correct place, after setting the extras for the current +% language} +% \changes{babel~3.9a}{2012/08/01}{Created \cs{bbl@swith} with code +% shared by \cs{select@language} and \cs{foreing@language}} +% \begin{macrocode} +% \end{macrocode} +% The name of the language is stored in the control sequence +% |\languagename|. +% +% Then we have to \emph{re}define |\originalTeX| to compensate for +% the things that have been activated. To save memory space for +% the macro definition of |\originalTeX|, we construct the control +% sequence name for the |\noextras|\langvar\ command at definition +% time by expanding the |\csname| primitive. +% +% Now activate the language-specific definitions. This is done by +% constructing the names of three macros by concatenating three +% words with the argument of |\selectlanguage|, and calling these +% macros. \nb{What if \cs{hyphenation} was used in |extras|? Patch +% temply set@hyphenmins and hyphenation. It can be done in hooks if +% necessary.} +% \changes{babel~3.5b}{1995/05/13}{Separated the setting of the +% hyphenmin values}% +% \changes{babel~3.9c}{2013/04/08}{Removed an extra empty line} +% +% The switching of the values of |\lefthyphenmin| and +% |\righthyphenmin| is somewhat different. First we save their +% current values, then we check if |\|\langvar|hyphenmins| is +% defined. If it is not, we set default values (2 and 3), otherwise +% the values in |\|\langvar|hyphenmins| will be used. +% \changes{babel~3.5b}{1995/06/05}{Addedd default setting of hyphenmin +% parameters} +% \changes{babel~3.9a}{2012/08/01}{Adddd \cs{bbl@iflanguagename} and +% \cs{select@language@x}, which is no-op if the language is the same} +% \changes{babel~3.9a}{2013/01/23}{\cs{select@language} sets +% \textsc{languagename} so that it has the correct value in the aux +% file (eg, shorthand expansion was wrong)} +% \changes{babel~3.0a}{1991/06/06}{Replaced \cs{gdef} with \cs{def}} +% \changes{babel~3.1}{1991/10/31}{\cs{originalTeX} should only be +% executed once} +% \changes{babel~3.2a}{1991/11/17}{Added three \cs{expandafter}s +% to save macro space for \cs{originalTeX}} +% \changes{babel~3.2a}{1991/11/20}{Moved definition of +% \cs{originalTeX} before \cs{extras\langvar}} +% \changes{babel~3.2a}{1991/11/24}{Set \cs{originalTeX} to +% \cs{empty}, because it should be expandable.} +% \changes{babel~3.6d}{1997/01/07}{set the language shorthands to +% `none' before switching on the extras} +% \changes{babel~3.9a}{2012/08/14}{Make sure the save counter is reset +% even in \cs{originalTeX} is used in other contexts} +% \begin{macrocode} +\def\bbl@switch#1{% + \originalTeX + \expandafter\def\expandafter\originalTeX\expandafter{% + \csname noextras#1\endcsname + \let\originalTeX\@empty + \babel@beginsave}% + \languageshorthands{none}% + \ifcase\bbl@select@type + \csname captions#1\endcsname + \csname date#1\endcsname + \fi + \bbl@usehooks{beforeextras}{}% + \csname extras#1\endcsname\relax + \bbl@usehooks{afterextras}{}% + \bbl@patterns{#1}% + \babel@savevariable\lefthyphenmin + \babel@savevariable\righthyphenmin + \expandafter\ifx\csname #1hyphenmins\endcsname\relax + \set@hyphenmins\tw@\thr@@\relax + \else + \expandafter\expandafter\expandafter\set@hyphenmins + \csname #1hyphenmins\endcsname\relax + \fi} +% \end{macrocode} +% \begin{macrocode} +\def\bbl@ifsamestring#1#2{% + \protected@edef\bbl@tempb{#1}% + \edef\bbl@tempb{\expandafter\strip@prefix\meaning\bbl@tempb}% + \protected@edef\bbl@tempc{#2}% + \edef\bbl@tempc{\expandafter\strip@prefix\meaning\bbl@tempc}% + \ifx\bbl@tempb\bbl@tempc + \expandafter\@firstoftwo + \else + \expandafter\@secondoftwo + \fi} +% \end{macrocode} +% +% \begin{environment}{otherlanguage} +% The \Lenv{otherlanguage} environment can be used as an +% alternative to using the |\selectlanguage| declarative +% command. When you are typesetting a document which mixes +% left-to-right and right-to-left typesetting you have to use this +% environment in order to let things work as you expect them to. +% +% The first thing this environment does is store the name of the +% language in |\languagename|; it then calls +% \verb*=\selectlanguage = to switch on everything that is needed for +% this language The |\ignorespaces| command is necessary to hide +% the environment when it is entered in horizontal mode. +% \changes{babel~3.5d}{1995/06/22}{environment added} +% \changes{babel~3.5e}{1995/07/07}{changed name} +% \changes{babel~3.7j}{2003/03/18}{rely on \cs{selectlanguage } to +% keep track of the nesting} +% \changes{babel~3.9a}{2012/07/31}{Removed \cs{originalTeX}} +% \begin{macrocode} +\long\def\otherlanguage#1{% + \csname selectlanguage \endcsname{#1}% + \ignorespaces} +% \end{macrocode} +% The |\endotherlanguage| part of the environment tries to hide +% itself when it is called in horizontal mode. +% \begin{macrocode} +\long\def\endotherlanguage{% + \global\@ignoretrue\ignorespaces} +% \end{macrocode} +% \end{environment} +% +% \begin{environment}{otherlanguage*} +% The \Lenv{otherlanguage} environment is meant to be used when a +% large part of text from a different language needs to be typeset, +% but without changing the translation of words such as `figure'. +% This environment makes use of |\foreign@language|. +% \changes{babel~3.5f}{1996/05/29}{environment added} +% \changes{babel~3.6d}{1997/01/07}{Introduced \cs{foreign@language}} +% \begin{macrocode} +\expandafter\def\csname otherlanguage*\endcsname#1{% + \foreign@language{#1}} +% \end{macrocode} +% At the end of the environment we need to switch off the extra +% definitions. The grouping mechanism of the environment will take +% care of resetting the correct hyphenation rules and ``extras''. +% \begin{macrocode} +\expandafter\let\csname endotherlanguage*\endcsname\relax +% \end{macrocode} +% \end{environment} +% +% \begin{macro}{\foreignlanguage} +% The |\foreignlanguage| command is another substitute for the +% |\selectlanguage| command. This command takes two arguments, the +% first argument is the name of the language to use for typesetting +% the text specified in the second argument. +% +% Unlike |\selectlanguage| this command doesn't switch +% \emph{everything}, it only switches the hyphenation rules and the +% extra definitions for the language specified. It does this within +% a group and assumes the |\extras|\langvar\ command doesn't make +% any |\global| changes. The coding is very similar to part of +% |\selectlanguage|. +% \changes{babel~3.5d}{1995/06/22}{Macro added} +% \changes{babel~3.6d}{1997/01/07}{Introduced \cs{foreign@language}} +% \changes{babel~3.7a}{1998/03/12}{Added executing \cs{originalTeX}} +% \changes{babel~3.9a}{2012/07/30}{Removed unnecesary \cs{noextras} +% just before closing the group} +% \changes{babel~3.9a}{2012/07/31}{Moved \cs{originalTeX} to +% \cs{foreing@language} so that it's also used in +% \texttt{otherlanguage*}} +% \changes{babel~3.9a}{2012/12/24}{\cs{foreignlanguage} defined +% similarly to \cs{selectlanguage}, protecting the whole macro} +% \begin{macrocode} +\edef\foreignlanguage{% + \noexpand\protect + \expandafter\noexpand\csname foreignlanguage \endcsname} +\expandafter\def\csname foreignlanguage \endcsname#1#2{% + \begingroup + \foreign@language{#1}% + #2% + \endgroup} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\foreign@language} +% \changes{babel~3.6d}{1997/01/07}{New macro} This macro does the +% work for |\foreignlanguage| and the \Lenv{otherlanguage*} +% environment. First we need to store the name of the language and +% check that it is a known language. Then it just calls +% |bbl@switch|. +% \begin{macrocode} +\def\foreign@language#1{% + \edef\languagename{#1}% + \bbl@fixname\languagename + \bbl@iflanguage\languagename{% + \expandafter\ifx\csname date\languagename\endcsname\relax + \bbl@warning + {You haven't loaded the language #1\space yet\\% + I'll proceed, but expect unexpected results.\\% + Reported}% + \fi + \let\bbl@select@type\@ne + \expandafter\bbl@switch\expandafter{\languagename}}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\bbl@patterns} +% \changes{babel~3.8l}{2008/07/06}{Macro added} +% \changes{babel~3.9a}{2012/08/28}{Extended to set hyphenation +% exceptions as defined with \cs{babelhyphenation}} +% This macro selects the hyphenation patterns by changing the +% \cs{language} register. If special hyphenation patterns +% are available specifically for the current font encoding, +% use them instead of the default. +% +% It also sets hyphenation exceptions, but only once, because they +% are global (here language |\lccode|'s has been set, +% too). |\bbl@hyphenation@| is set to relax until the very first +% |\babelhyphenation|, so do nothing with this value. If the +% exceptions for a language (by its number, not its name, so that +% |:ENC| is taken into account) has been set, then use +% |\hyphenation| with both global and language exceptions and empty +% the latter to mark they must not be set again. +% \begin{macrocode} +\let\bbl@hyphlist\@empty +\let\bbl@hyphenation@\relax +\def\bbl@patterns#1{% + \language=\expandafter\ifx\csname l@#1:\f@encoding\endcsname\relax + \csname l@#1\endcsname + \edef\bbl@tempa{#1}% + \else + \csname l@#1:\f@encoding\endcsname + \edef\bbl@tempa{#1:\f@encoding}% + \fi\relax + \@expandtwoargs\bbl@usehooks{patterns}{{#1}{\bbl@tempa}}% + \@ifundefined{bbl@hyphenation@}{}{% + \begingroup + \@expandtwoargs\in@{,\number\language,}{,\bbl@hyphlist}% + \ifin@\else + \@expandtwoargs\bbl@usehooks{hyphenation}{{#1}{\bbl@tempa}}% + \hyphenation{% + \bbl@hyphenation@ + \@ifundefined{bbl@hyphenation@#1}% + \@empty + {\space\csname bbl@hyphenation@#1\endcsname}}% + \xdef\bbl@hyphlist{\bbl@hyphlist\number\language,}% + \fi + \endgroup}} +% \end{macrocode} +% \end{macro} +% +% \begin{environment}{hyphenrules} +% \changes{babel~3.7e}{2000/01/28}{Added environment hyphenrules} +% The environment \Lenv{hyphenrules} can be used to select +% \emph{just} the hyphenation rules. This environment does +% \emph{not} change |\languagename| and when the hyphenation rules +% specified were not loaded it has no effect. Note however, +% |\lccode|'s and font encodings are not set at all, so in most +% cases you should use |otherlanguage*|. +% \changes{babel~3.8j}{2008/03/16}{Also set the hyphenmin parameters to +% the correct value (PR3997)} +% \changes{babel~3.8l}{2008/07/06}{Use \cs{bbl@patterns}} +% \begin{macrocode} +\def\hyphenrules#1{% + \edef\languagename{#1}% + \bbl@fixname\languagename + \bbl@iflanguage\languagename{% + \expandafter\bbl@patterns\expandafter{\languagename}% + \languageshorthands{none}% + \expandafter\ifx\csname\languagename hyphenmins\endcsname\relax + \set@hyphenmins\tw@\thr@@\relax + \else + \expandafter\expandafter\expandafter\set@hyphenmins + \csname\languagename hyphenmins\endcsname\relax + \fi}} +\let\endhyphenrules\@empty +% \end{macrocode} +% \end{environment} +% +% \begin{macro}{\providehyphenmins} +% \changes{babel~3.7f}{2000/02/18}{added macro} +% The macro |\providehyphenmins| should be used in the language +% definition files to provide a \emph{default} setting for the +% hyphenation parameters |\lefthyphenmin| and |\righthyphenmin|. If +% the macro |\|\langvar|hyphenmins| is already defined this command +% has no effect. +% \begin{macrocode} +\def\providehyphenmins#1#2{% + \expandafter\ifx\csname #1hyphenmins\endcsname\relax + \@namedef{#1hyphenmins}{#2}% + \fi} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\set@hyphenmins} +% This macro sets the values of |\lefthyphenmin| and +% |\righthyphenmin|. It expects two values as its argument. +% \begin{macrocode} +\def\set@hyphenmins#1#2{\lefthyphenmin#1\relax\righthyphenmin#2\relax} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\LdfInit} +% \changes{babel~3.6a}{1996/10/16}{Macro added} +% This macro is defined in two versions. The first version is to be +% part of the `kernel' of \babel, ie. the part that is loaded in +% the format; the second version is defined in \file{babel.def}. +% The version in the format just checks the category code of the +% ampersand and then loads \file{babel.def}. +% +% The category code of the ampersand is restored and the macro +% calls itself again with the new definition from +% \file{babel.def} +% \begin{macrocode} +\def\LdfInit{% + \chardef\atcatcode=\catcode`\@ + \catcode`\@=11\relax + \input babel.def\relax + \catcode`\@=\atcatcode \let\atcatcode\relax + \LdfInit} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\originalTeX} +% The macro|\originalTeX| should be known to \TeX\ at this moment. +% As it has to be expandable we |\let| it to |\@empty| instead of +% |\relax|. +% \changes{babel~3.2a}{1991/11/24}{Set \cs{originalTeX} to +% \cs{empty}, because it should be expandable.} +% \begin{macrocode} +\ifx\originalTeX\@undefined\let\originalTeX\@empty\fi +% \end{macrocode} +% Because this part of the code can be included in a format, we +% make sure that the macro which initialises the save mechanism, +% |\babel@beginsave|, is not considered to be undefined. +% \begin{macrocode} +\ifx\babel@beginsave\@undefined\let\babel@beginsave\relax\fi +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\@nolanerr} +% \changes{babel~3.4e}{1994/06/25}{Use \cs{PackageError} in \LaTeXe\ +% mode} +% \begin{macro}{\@nopatterns} +% \changes{babel~3.4e}{1994/06/25}{Macro added} +% The \babel\ package will signal an error when a documents tries +% to select a language that hasn't been defined earlier. When a +% user selects a language for which no hyphenation patterns were +% loaded into the format he will be given a warning about that +% fact. We revert to the patterns for |\language|=0 in that case. +% In most formats that will be (US)english, but it might also be +% empty. +% \begin{macro}{\@noopterr} +% \changes{babel~3.7m}{2003/11/16}{Macro added} +% When the package was loaded without options not everything will +% work as expected. An error message is issued in that case. +% +% When the format knows about |\PackageError| it must be \LaTeXe, +% so we can safely use its error handling interface. Otherwise +% we'll have to `keep it simple'. +% \changes{babel~3.0d}{1991/10/07}{Added a percent sign to remove +% unwanted white space} +% \changes{babel~3.5a}{1995/02/15}{Added \cs{@activated} to log active +% characters} +% \changes{babel~3.5c}{1995/06/19}{Added missing closing brace} +% \changes{babel~3.9a}{2012/07/30}{\cs{newcommand}s replaced by +% \cs{def}'s, so that the file can be loaded twice} +% \changes{babel~3.9a}{2013/01/26}{Define generic variants instead of +% duplicating each predefined message} +% \begin{macrocode} +\edef\bbl@nulllanguage{\string\language=0} +\ifx\PackageError\@undefined + \def\bbl@error#1#2{% + \begingroup + \newlinechar=`\^^J + \def\\{^^J(babel) }% + \errhelp{#2}\errmessage{\\#1}% + \endgroup} + \def\bbl@warning#1{% + \begingroup + \newlinechar=`\^^J + \def\\{^^J(babel) }% + \message{\\#1}% + \endgroup} + \def\bbl@info#1{% + \begingroup + \newlinechar=`\^^J + \def\\{^^J}% + \wlog{#1}% + \endgroup} +\else + \def\bbl@error#1#2{% + \begingroup + \def\\{\MessageBreak}% + \PackageError{babel}{#1}{#2}% + \endgroup} + \def\bbl@warning#1{% + \begingroup + \def\\{\MessageBreak}% + \PackageWarning{babel}{#1}% + \endgroup} + \def\bbl@info#1{% + \begingroup + \def\\{\MessageBreak}% + \PackageInfo{babel}{#1}% + \endgroup} +\fi +\def\@nolanerr#1{% + \bbl@error + {You haven't defined the language #1\space yet}% + {Your command will be ignored, type <return> to proceed}} +\def\@nopatterns#1{% + \bbl@warning + {No hyphenation patterns were preloaded for\\% + the language `#1' into the format.\\% + Please, configure your TeX system to add them and\\% + rebuild the format. Now I will use the patterns\\% + preloaded for \bbl@nulllanguage\space instead}} +\let\bbl@usehooks\@gobbletwo +%</kernel> +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% The following code is meant to be read by ini\TeX\ because it +% should instruct \TeX\ to read hyphenation patterns. To this end +% the \texttt{docstrip} option \texttt{patterns} can be used to +% include this code in the file \file{hyphen.cfg}. Code is at lower +% level than the rest. +% +% |toks8| stores info to be shown when the program is run. +% +% \begin{macrocode} +%<*patterns> +\toks8{Babel <3.9e> and hyphenation patterns for }% +% \end{macrocode} +% +% \changes{babel~3.5g}{1996/07/09}{Removed the use of +% \cs{patterns@loaded} altogether} +% +% \begin{macro}{\process@line} +% \changes{babel~3.5b}{1995/04/28}{added macro} +% Each line in the file \file{language.dat} is processed by +% |\process@line| after it is read. The first thing this macro does +% is to check whether the line starts with \texttt{=}. +% When the first token of a line is an \texttt{=}, the macro +% |\process@synonym| is called; otherwise the macro +% |\process@language| will continue. +% \changes{babel~3.5g}{1996/07/09}{Simplified code, removing +% \cs{bbl@eq@}} +% \changes{babel~3.9a}{2012/12/12}{Use spaces as delimiters, to avoid +% extra spaces. Once parsed, pass them in the traditional way} +% \begin{macrocode} +\def\process@line#1#2 #3 #4 {% + \ifx=#1% + \process@synonym{#2}% + \else + \process@language{#1#2}{#3}{#4}% + \fi + \ignorespaces} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\process@synonym} +% \changes{babel~3.5b}{1995/04/28}{added macro} +% \changes{babel~3.7c}{1999/04/27}{Use a token register to temporarily +% store a command to set hyphenmin parameters for the synonym which +% is defined \emph{before} the first pattern file is processed} +% +% This macro takes care of the lines which start with an +% \texttt{=}. It needs an empty token register to begin with. +% |\bbl@languages| is also set to empty. +% \begin{macrocode} +\toks@{} +\def\bbl@languages{} +% \end{macrocode} +% When no languages have been loaded yet, the name following the +% \texttt{=} will be a synonym for hyphenation register 0. So, it is stored +% in a token register and executed when the first pattern file has +% been processed. (The |\relax| just helps to the |\if| below +% catching synonyms without a language.) +% +% Otherwise the name will be a synonym for the language loaded last. +% +% We also need to copy the hyphenmin parameters for the synonym. +% \changes{babel~3.7c}{1999/04/22}{Now also store hyphenmin parameters +% for language synonyms} +% \changes{babel~3.9a}{2012/06/25}{Added \cs{bbl@languages}} +% \begin{macrocode} +\def\process@synonym#1{% + \ifnum\last@language=\m@ne + \toks@\expandafter{\the\toks@\relax\process@synonym{#1}}% + \else + \expandafter\chardef\csname l@#1\endcsname\last@language + \wlog{\string\l@#1=\string\language\the\last@language}% + \expandafter\let\csname #1hyphenmins\expandafter\endcsname + \csname\languagename hyphenmins\endcsname + \let\bbl@elt\relax + \edef\bbl@languages{\bbl@languages\bbl@elt{#1}{\the\last@language}{}{}}% + \fi} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\process@language} +% The macro |\process@language| is used to process a non-empty line +% from the `configuration file'. It has three arguments, each +% delimited by white space. The first argument is the `name' of a +% language; the second is the name of the file that contains the +% patterns. The optional third argument is the name of a file +% containing hyphenation exceptions. +% +% The first thing to do is call |\addlanguage| to allocate a +% pattern register and to make that register `active'. +% \changes{babel~3.0d}{1991/08/08}{Removed superfluous +% \cs{expandafter}} +% \changes{babel~3.0d}{1991/08/21}{Reinserted \cs{expandafter}} +% \changes{babel~3.0d}{1991/10/27}{Added the collection of pattern +% names.} +% \changes{babel~3.7c}{1999/04/22}{Also store \cs{languagename} for +% possible later use in \cs{process@synonym}} +% Then the `name' of the language that will be loaded now is +% added to the token register |\toks8|. and finally +% the pattern file is read. +% \changes{babel~3.7f}{2000/02/18}{Allow for the encoding to be used +% as part of the language name} +% \changes{babel~3.9a}{2012/12/10}{Removed \cs{selectfont} (I presume +% it was intended to catch wrong encoding codes, but I don't think +% this is necessary and as a side effect it might preload fonts)} +% +% For some hyphenation patterns it is needed to load them with a +% specific font encoding selected. This can be specified in the +% file \file{language.dat} by adding for instance `\texttt{:T1}' to +% the name of the language. The macro |\bbl@get@enc| extracts the +% font encoding from the language name and stores it in +% |\bbl@hyph@enc|. The latter can be used in hyphenation files if +% you need to set a behaviour depending on the given encoding (it +% is set to empty if no encoding is given). +% +% \changes{babel~3.4e}{1994/06/24}{Added code to detect assignments to +% left- and righthyphenmin in the patternfile.} +% \changes{babel~3.7a}{1998/03/27}{Read pattern files in a group} +% \changes{babel~3.7c}{1999/04/05}{need to set hyphenmin values +% globally} +% \changes{babel~3.7c}{1999/04/22}{Set \cs{lefthyphenmin} to \cs{m@ne} +% \emph{inside} the group; explicitly set the hyphenmin parameters +% for language 0} +% \changes{babel~3.7c}{1999/04/25}{Only set hyphenmin values when the +% pattern file changed them} +% Pattern files may contain assignments to |\lefthyphenmin| and +% |\righthyphenmin|. \TeX\ does not keep track of these +% assignments. Therefor we try to detect such assignments and +% store them in the |\|\langvar|hyphenmins| macro. When no +% assignments were made we provide a default setting. +% +% Some pattern files contain changes to the |\lccode| en |\uccode| +% arrays. Such changes should remain local to the language; +% therefor we process the pattern file in a group; the |\patterns| +% command acts globally so its effect will be remembered. +% +% Then we globally store the settings of |\lefthyphenmin| and +% |\righthyphenmin| and close the group. +% +% When the hyphenation patterns have been processed we need to see +% if a file with hyphenation exceptions needs to be read. This is +% the case when the third argument is not empty and when it does +% not contain a space token. (Note however there is no need to save +% hyphenation exceptions into the format.) +% \changes{babel~3.5b}{1995/04/28}{Added optional reading of file with +% hyphenation exceptions} +% \changes{babel~3.5f}{1995/07/25}{Use \cs{empty} instead of +% \cs{@empty} as the latter is unknown in plain} +% +% \changes{babel~3.9a}{2012/06/25}{Added \cs{bbl@languages}} +% \cs{bbl@languages} saves a snapshot of the loaded languagues in the +% form \cs{bbl@elt}\marg{language-name}\marg{number}% +% \marg{patterns-file}\marg{exceptions-file}. Note the last 2 +% arguments are empty in `dialects' defined in |language.dat| with +% |=|. Note also the language name can have encoding info. +% +% \changes{babel~3.7c}{1999/04/27}{Added the execution of the contents +% of \cs{toks@}} +% Finally, if the counter |\language| is equal to zero we execute the +% synonyms stored. +% \begin{macrocode} +\def\process@language#1#2#3{% + \expandafter\addlanguage\csname l@#1\endcsname + \expandafter\language\csname l@#1\endcsname + \edef\languagename{#1}% + \bbl@hook@everylanguage{#1}% + \bbl@get@enc#1::\@@@ + \begingroup + \lefthyphenmin\m@ne + \bbl@hook@loadpatterns{#2}% + \ifnum\lefthyphenmin=\m@ne + \else + \expandafter\xdef\csname #1hyphenmins\endcsname{% + \the\lefthyphenmin\the\righthyphenmin}% + \fi + \endgroup + \def\bbl@tempa{#3}% + \ifx\bbl@tempa\@empty\else + \bbl@hook@loadexceptions{#3}% + \fi + \let\bbl@elt\relax + \edef\bbl@languages{% + \bbl@languages\bbl@elt{#1}{\the\language}{#2}{\bbl@tempa}}% + \ifnum\the\language=\z@ + \the\toks@ + \toks@{}% + \fi} +% \end{macrocode} +% +% \begin{macro}{\bbl@get@enc} +% \changes{babel~3.7f}{2000/02/18}{Added macro} +% \changes{babel~3.9a}{2012/12/11}{Code much simplified} +% \begin{macro}{\bbl@hyph@enc} +% The macro |\bbl@get@enc| extracts the font encoding from the +% language name and stores it in |\bbl@hyph@enc|. It uses delimited +% arguments to achieve this. +% \begin{macrocode} +\def\bbl@get@enc#1:#2:#3\@@@{\def\bbl@hyph@enc{#2}} +% \end{macrocode} +% \end{macro} +% \end{macro} +% \end{macro} +% +% Now, hooks are defined. For efficiency reasons, they are dealt +% here in a special way. Besides \luatex, format specific +% configuration files are taken into account. +% \changes{babel~3.9b}{2013/03/25}{Fixed an idiot slip: \cs{def} +% intead of \cs{let}} +% \begin{macrocode} +\def\bbl@hook@everylanguage#1{} +\def\bbl@hook@loadpatterns#1{\input #1\relax} +\let\bbl@hook@loadexceptions\bbl@hook@loadpatterns +\let\bbl@hook@loadkernel\bbl@hook@loadpatterns +\begingroup + \def\AddBabelHook#1#2{% + \expandafter\ifx\csname bbl@hook@#2\endcsname\relax + \def\next{\toks1}% + \else + \def\next{\expandafter\gdef\csname bbl@hook@#2\endcsname####1}% + \fi + \next} + \ifx\directlua\@undefined + \ifx\XeTeXinputencoding\@undefined\else + \input xebabel.def + \fi + \else + \input luababel.def + \fi + \openin1 = babel-\bbl@format.cfg + \ifeof1 + \else + \input babel-\bbl@format.cfg\relax + \fi + \closein1 +\endgroup +\bbl@hook@loadkernel{switch.def} +% \end{macrocode} +% \begin{macro}{\readconfigfile} +% The configuration file can now be opened for reading. +% \begin{macrocode} +\openin1 = language.dat +% \end{macrocode} +% +% See if the file exists, if not, use the default hyphenation file +% \file{hyphen.tex}. The user will be informed about this. +% +% \begin{macrocode} +\def\languagename{english}% +\ifeof1 + \message{I couldn't find the file language.dat,\space + I will try the file hyphen.tex} + \input hyphen.tex\relax + \chardef\l@english\z@ +\else +% \end{macrocode} +% +% Pattern registers are allocated using count register +% |\last@language|. Its initial value is~0. The definition of the +% macro |\newlanguage| is such that it first increments the count +% register and then defines the language. In order to have the +% first patterns loaded in pattern register number~0 we initialize +% |\last@language| with the value~$-1$. +% +% \changes{babel~3.1}{1991/05/21}{Removed use of \cs{toks0}} +% \begin{macrocode} + \last@language\m@ne +% \end{macrocode} +% +% We now read lines from the file until the end is found +% +% \begin{macrocode} + \loop +% \end{macrocode} +% +% While reading from the input, it is useful to switch off +% recognition of the end-of-line character. This saves us stripping +% off spaces from the contents of the control sequence. +% +% \begin{macrocode} + \endlinechar\m@ne + \read1 to \bbl@line + \endlinechar`\^^M +% \end{macrocode} +% +% \changes{babel~3.9a}{2012/12/14}{Test simplified and moved} +% \changes{babel~3.9a}{2012/12/12}{Use only spaces as delimiters and +% not /, as previouly done} +% +% If the file has reached its end, exit from the loop here. If not, +% empty lines are skipped. Add 3 space characters to the end of +% |\bbl@line|. This is needed to be able to recognize the arguments +% of |\process@line| later on. The default language should be the +% very first one. +% +% \begin{macrocode} + \if T\ifeof1F\fi T\relax + \ifx\bbl@line\@empty\else + \edef\bbl@line{\bbl@line\space\space\space}% + \expandafter\process@line\bbl@line\relax + \fi + \repeat +% \end{macrocode} +% +% Check for the end of the file. We must reverse the test for +% |\ifeof| without |\else|. Then reactivate the default patterns, +% \changes{babel~3.8m}{2008/07/08}{Also restore the name of the +% language in \cs{languagename} (PR 4039)} +% \begin{macrocode} + \begingroup + \def\bbl@elt#1#2#3#4{% + \global\language=#2\relax + \gdef\languagename{#1}% + \def\bbl@elt##1##2##3##4{}}% + \bbl@languages + \endgroup +\fi +% \end{macrocode} +% and close the configuration file. +% \changes{babel~3.2a}{1991/11/20}{Free macro space for +% \cs{process@language}} +% \begin{macrocode} +\closein1 +% \end{macrocode} +% +% \changes{babel~3.5f}{1995/11/08}{Moved the fiddling with \cs{dump} +% to \file{bbplain.dtx} as it is no longer needed for \LaTeX} +% We add a message about the fact that babel is loaded in the +% format and with which language patterns to the \cs{everyjob} +% register. +% \changes{babel~3.6h}{1997/01/23}{Added a couple of \cs{expandafter}s +% to copy the contents of \cs{toks8} into \cs{everyjob} instead of +% the reference} +% \changes{babel~3.9a}{2012/09/25}{The list of languages is not +% printed every job any more (it is saved in \cs{bbl@languages}).} +% \begin{macrocode} +\if/\the\toks@/\else + \errhelp{language.dat loads no language, only synonyms} + \errmessage{Orphan language synonym} +\fi +\ifx\addto@hook\@undefined +\else + \edef\bbl@tempa{% + \noexpand\typeout{\the\toks8 \the\last@language\space languages + loaded.}}% + \expandafter\addto@hook\expandafter\everyjob\expandafter{\bbl@tempa} +\fi +% \end{macrocode} +% Also remove some macros from memory and raise an error +% if |\toks@| is not empty. Finally load \file{switch.def}, but the +% letter is not required and the line inputting it may be commented out. +% \changes{babel~3.9a}{2012/12/11}{Raise error if there are synonyms +% without languages} +% \begin{macrocode} +\let\bbl@line\@undefined +\let\process@line\@undefined +\let\process@synonym\@undefined +\let\process@language\@undefined +\let\bbl@get@enc\@undefined +\let\bbl@hyph@enc\@undefined +\let\bbl@tempa\@undefined +\let\bbl@hook@loadkernel\@undefined +\let\bbl@hook@everylanguage\@undefined +\let\bbl@hook@loadpatterns\@undefined +\let\bbl@hook@loadexceptions\@undefined +%</patterns> +% \end{macrocode} +% Here the code for ini\TeX\ ends. +% \end{macro} +% +% \section{The `nil' language} +% +% This `language' does nothing, except setting the hyphenation patterns to +% nohyphenation. +% +% For this language currently no special definitions are needed or +% available. +% +% The macro |\LdfInit| takes care of preventing that this file is +% loaded more than once, checking the category code of the +% \texttt{@} sign, etc. +% \begin{macrocode} +%<*nil> +\LdfInit{nil}{datenil} +% \end{macrocode} +% +% When this file is read as an option, i.e. by the |\usepackage| +% command, \texttt{nil} could be an `unknown' language in which +% case we have to make it known. +% \begin{macrocode} +\ifx\l@nohyphenation\@undefined + \@nopatterns{nil} + \adddialect\l@nil0 +\else + \let\l@nil\l@nohyphenation +\fi +% \end{macrocode} +% This macro is used to store the values of the hyphenation +% parameters |\lefthyphenmin| and |\righthyphenmin|. +% \begin{macrocode} +\providehyphenmins{\CurrentOption}{\m@ne\m@ne} +% \end{macrocode} +% +% The next step consists of defining commands to switch to (and +% from) the `nil' language. +% \begin{macro}{\captionnil} +% \begin{macro}{\datenil} +% \begin{macrocode} +\let\captionsnil\@empty +\let\datenil\@empty +% \end{macrocode} +% \end{macro} +% \end{macro} +% +% The macro |\ldf@finish| takes care of looking for a +% configuration file, setting the main language to be switched on +% at |\begin{document}| and resetting the category code of +% \texttt{@} to its original value. +% \begin{macrocode} +\ldf@finish{nil} +%</nil> +% \end{macrocode} +% +% \Finale +% +%% +%% \CharacterTable +%% {Upper-case \A\B\C\D\E\F\G\H\I\J\K\L\M\N\O\P\Q\R\S\T\U\V\W\X\Y\Z +%% Lower-case \a\b\c\d\e\f\g\h\i\j\k\l\m\n\o\p\q\r\s\t\u\v\w\x\y\z +%% Digits \0\1\2\3\4\5\6\7\8\9 +%% Exclamation \! Double quote \" Hash (number) \# +%% Dollar \$ Percent \% Ampersand \& +%% Acute accent \' Left paren \( Right paren \) +%% Asterisk \* Plus \+ Comma \, +%% Minus \- Point \. Solidus \/ +%% Colon \: Semicolon \; Less than \< +%% Equals \= Greater than \> Question mark \? +%% Commercial at \@ Left bracket \[ Backslash \\ +%% Right bracket \] Circumflex \^ Underscore \_ +%% Grave accent \` Left brace \{ Vertical bar \| +%% Right brace \} Tilde \~} +\endinput diff --git a/Master/texmf-dist/source/latex/babel/babel.ins b/Master/texmf-dist/source/latex/babel/babel.ins new file mode 100644 index 00000000000..1ddc7d9f07f --- /dev/null +++ b/Master/texmf-dist/source/latex/babel/babel.ins @@ -0,0 +1,288 @@ +%% +%% This file will generate fast loadable files and documentation +%% driver files from the doc files in this package when run through +%% LaTeX or TeX. +%% +%% Copyright 2012-2013 Javier Bezos and Johannes L. Braams. +%% Copyright 1989-2008 Johannes L. Braams and any individual authors +%% listed elsewhere in this file. All rights reserved. +%% +%% This file is part of the Babel system. +%% -------------------------------------- +%% +%% It may be distributed and/or modified under the +%% conditions of the LaTeX Project Public License, either version 1.3 +%% of this license or (at your option) any later version. +%% The latest version of this license is in +%% http://www.latex-project.org/lppl.txt +%% and version 1.3 or later is part of all distributions of LaTeX +%% version 2003/12/01 or later. +%% +%% This work has the LPPL maintenance status "maintained". +%% +%% The Current Maintainer of this work is Javier Bezos. +%% +%% The list of all files belonging to the LaTeX base distribution is +%% given in the file `manifest.bbl. See also `legal.bbl' for additional +%% information. +%% +%% The list of derived (unpacked) files belonging to the distribution +%% and covered by LPPL is defined by the unpacking scripts (with +%% extension .ins) which are part of the distribution. +%% +%% --------------- start of docstrip commands ------------------ +%% +%% Copyright 2012-2013 Javier Bezos and Johannes L. Braams. +%% Copyright 2005-2008 Johannes L. Braams +%% +%% This file is part of the `babel' system. +%% +%% You are allowed to distribute this file together with all files +%% mentioned in manifest.bbl. +%% +%% You are not allowed to modify its contents. +%% +\def\filedate{2013/04/10} +\def\batchfile{babel.ins} +\input docstrip.tex + +{\ifx\generate\undefined +\Msg{**********************************************} +\Msg{*} +\Msg{* This installation requires docstrip} +\Msg{* version 2.3c or later.} +\Msg{*} +\Msg{* An older version of docstrip has been input} +\Msg{*} +\Msg{**********************************************} +\errhelp{Move or rename old docstrip.tex.} +\errmessage{Old docstrip in input path} +\batchmode +\csname @@end\endcsname +\fi} + +\declarepreamble\mainpreamble +This is a generated file. + +Copyright 2012-2013 Javier Bezos and Johannes L. Braams. +Copyright 1989-2008 Johannes L. Braams and any individual authors +listed elsewhere in this file. All rights reserved. + +This file was generated from file(s) of the Babel system. +--------------------------------------------------------- + +It may be distributed and/or modified under the +conditions of the LaTeX Project Public License, either version 1.3 +of this license or (at your option) any later version. +The latest version of this license is in + http://www.latex-project.org/lppl.txt +and version 1.3 or later is part of all distributions of LaTeX +version 2003/12/01 or later. + +This work has the LPPL maintenance status "maintained". + +The Current Maintainer of this work is Javier Bezos. + +This file may only be distributed together with a copy of the Babel +system. You may however distribute the Babel system without +such generated files. + +The list of all files belonging to the Babel distribution is +given in the file `manifest.bbl'. See also `legal.bbl for additional +information. + +The list of derived (unpacked) files belonging to the distribution +and covered by LPPL is defined by the unpacking scripts (with +extension .ins) which are part of the distribution. +\endpreamble + +\declarepreamble\fdpreamble +This is a generated file. + +Copyright 2012-2013 Javier Bezos and Johannes L. Braams. +Copyright 1989-2008 Johannes L. Braams and any individual authors +listed elsewhere in this file. All rights reserved. + +This file was generated from file(s) of the Babel system. +--------------------------------------------------------- + +It may be distributed and/or modified under the +conditions of the LaTeX Project Public License, either version 1.3 +of this license or (at your option) any later version. +The latest version of this license is in + http://www.latex-project.org/lppl.txt +and version 1.3 or later is part of all distributions of LaTeX +version 2003/12/01 or later. + +This work has the LPPL maintenance status "maintained". + +The Current Maintainer of this work is Javier Bezos. + +This file may only be distributed together with a copy of the Babel +system. You may however distribute the Babel system without +such generated files. + +The list of all files belonging to the Babel distribution is +given in the file `manifest.bbl'. See also `legal.bbl for additional +information. + +In particular, permission is granted to customize the declarations in +this file to serve the needs of your installation. + +However, NO PERMISSION is granted to distribute a modified version +of this file under its original name. + +\endpreamble + +\declarepreamble\drvpreamble + +This file was generated from file(s) of the Babel system. +--------------------------------------------------------- + +Copyright 2012-2013 Javier Bezos and Johannes L. Braams. +Copyright (C) 2008 Johannes Braams. All rights reserved. + +To produce the documentation in the way you like you are allowed +to change this driver file. + +\endpreamble + +\declarepreamble\istpreamble +This file was generated from file(s) of the Babel system. +--------------------------------------------------------- + +Copyright 2012-2013 Javier Bezos and Johannes L. Braams. +Copyright (C) 2008 Johannes Braams. All rights reserved. + +This file is a style file for the MakeIndex program + +\endpreamble + +\declarepostamble\istpost +\endpostamble + +\keepsilent +\askonceonly + +\usepreamble\mainpreamble +\usedir{tex/generic/babel} + +\askforoverwritefalse + +\generate{\file{babel.sty}{\from{babel.dtx}{package}} + \file{babel.def}{\from{babel.dtx}{core}} + \file{switch.def}{\from{babel.dtx}{kernel}} + \file{hyphen.cfg}{\from{babel.dtx}{patterns}} + \file{nil.ldf}{\from{babel.dtx}{nil}} + } +% Support for plain users +\generate{\file{plain.def}{\from{bbplain.dtx}{code}} + \file{bplain.tex}{\from{bbplain.dtx}{bplain}} + \file{blplain.tex}{\from{bbplain.dtx}{blplain}} + } +% Support for Unicode-based engines +\generate{\file{xebabel.def}{\from{bbunicode.dtx}{xetex}} + \file{luababel.def}{\from{bbunicode.dtx}{luatex}} + } + +% compatibility files + +\usepreamble\mainpreamble + +\def\compatfile#1{\file{#1.sty}{\from{bbcompat.dtx}{#1}}} + +\generate{% + \compatfile{esperanto} + \compatfile{afrikaans} + \compatfile{dutch} + \compatfile{american} + \compatfile{british} + \compatfile{english} + \compatfile{UKenglish} + \compatfile{USenglish} + \compatfile{germanb} + \compatfile{austrian} + \compatfile{ngermanb} + \compatfile{naustrian} + \compatfile{irish} + \compatfile{scottish} + \compatfile{welsh} + \compatfile{breton} + } +\generate{% + \compatfile{francais} + \compatfile{italian} + \compatfile{portuges} + \compatfile{spanish} + \compatfile{catalan} + \compatfile{galician} + \compatfile{danish} + \compatfile{norsk} + \compatfile{swedish} + \compatfile{finnish} + \compatfile{magyar} + \compatfile{greek} + \compatfile{croatian} + \compatfile{czech} + \compatfile{slovak} + \compatfile{polish} + } +\generate{% + \compatfile{estonian} + \compatfile{romanian} + \compatfile{slovene} + \compatfile{russianb} + \compatfile{ukraineb} + \compatfile{turkish} + \compatfile{lsorbian} + \compatfile{usorbian} + \compatfile{bahasa} + \compatfile{hebrew} + %\compatfile{sanskrit} + \compatfile{basque} + \compatfile{latin} + \compatfile{icelandic} + \compatfile{serbian} + \compatfile{bulgarian} + } +\generate{% + \compatfile{samin} + \compatfile{interlingua} + \compatfile{albanian} + \compatfile{bahasam} + } + +% MakeIndex style files + +\usepreamble\istpreamble +\usepostamble\istpost +\usedir{makeindex/babel} + +\generate{\file{bbind.ist}{\from{bbidxglo.dtx}{idx}} + \file{bbglo.ist}{\from{bbidxglo.dtx}{glo}}} + +\Msg{***********************************************************} +\Msg{*} +\Msg{* To finish the installation you have to move all the files} +\Msg{* with names ending in .ldf, .sty, .def or .fd into a} +\Msg{* directory searched by TeX} +\Msg{*} +\Msg{* For making a format the following files have to be in a} +\Msg{* directory which is searched by IniTeX:} +\Msg{* \space\space hyphen.cfg} +\Msg{* \space\space language.dat} +\Msg{* \space\space and files with hyphenation patterns} +\Msg{*} +\Msg{* To produce source listings you can run files with names} +\Msg{* ending in .dtx and/or .drv through LaTeX} +\Msg{*} +\Msg{* To produce the complete source listing MakeIndex needs to be} +\Msg{* able to find the following files} +\Msg{* \space\space bbind.ist} +\Msg{* \space\space bbglo.ist} +\Msg{*} +\Msg{* Happy TeXing} +\Msg{*} +\Msg{***********************************************************} + + diff --git a/Master/texmf-dist/source/latex/babel/bbcompat.dtx b/Master/texmf-dist/source/latex/babel/bbcompat.dtx new file mode 100644 index 00000000000..bf9c637eaeb --- /dev/null +++ b/Master/texmf-dist/source/latex/babel/bbcompat.dtx @@ -0,0 +1,272 @@ +% \iffalse meta-comment +% +% Copyright 1989-2008 Johannes L. Braams and any individual authors +% listed elsewhere in this file. All rights reserved. +% +% This file is part of the Babel system. +% -------------------------------------- +% +% It may be distributed and/or modified under the +% conditions of the LaTeX Project Public License, either version 1.3 +% of this license or (at your option) any later version. +% The latest version of this license is in +% http://www.latex-project.org/lppl.txt +% and version 1.3 or later is part of all distributions of LaTeX +% version 2003/12/01 or later. +% +% This work has the LPPL maintenance status "maintained". +% +% The Current Maintainer of this work is Javier Bezos. +% +% The list of all files belonging to the Babel system is +% given in the file `manifest.bbl. See also `legal.bbl' for additional +% information. +% +% The list of derived (unpacked) files belonging to the distribution +% and covered by LPPL is defined by the unpacking scripts (with +% extension .ins) which are part of the distribution. +% \fi +% \CheckSum{263} +% +% \iffalse +%<*dtx> +\ProvidesFile{bbcompat.dtx}[2008/07/06 v1.2k] +%</dtx> +% +%% File 'bbcompat.dtx' +%% Copyright (C) 1989 -- 2008 by Johannes Braams, +%% TeXniek +%% all rights reserved. +% +%% Please report errors to: J.L. Braams +%% babel at braams dot xs4all dot nl +%<*filedriver> +\documentclass{ltxdoc} +\newcommand*\TeXhax{\TeX hax} +\newcommand*\babel{\textsf{babel}} +\newcommand*\Lopt[1]{\textsf{#1}} +\newcommand*\file[1]{\texttt{#1}} +\newcommand*\pkg[1]{\texttt{#1}} +\begin{document} + \DocInput{bbcompat.dtx} +\end{document} +%</filedriver> +% \fi +% +% \GetFileInfo{bbcompat.dtx} +% \changes{bbcompat-1.2j}{2006/06/05}{Small documentation fix} +% +% \StopEventually{} +% +% \changes{bbcompat-1.2}{1996/11/02}{Added the check for \cs{LdfInit}} +% \changes{bbcompat-1.2d}{1999/04/12}{When these files are read by a +% non-babel plain format the @ has still category code `other' so +% can't use \cs{@undefined}} +% \begin{macrocode} +\ifx\LdfInit\undefined + \def\LdfInit{% + \chardef\atcatcode=\catcode`\@ + \catcode`\@=11\relax + \input babel.def\relax + \catcode`\@=\atcatcode \let\atcatcode\relax + \LdfInit} +\fi +% \end{macrocode} +% It seems that these files, although meant for compatibility with +% \file{plain.tex} are also used as packages in \LaTeXe. The +% disadvantage of that is that a number of compatibility measures +% with other packages that are part of \file{babel.sty} are not +% present. Therefore we issue an error and then load +% \file{babel.def} to let the user continue processing his +% document (at his own risk). +% +% First we determine whether we are loaded from \LaTeX\ by checking +% whether |\PackageError| is defined. +% \begin{macrocode} +\ifx\PackageError\undefined +% \end{macrocode} +% In this case we are not being loaded by \LaTeXe, so just define +% |\ProvidesLanguage| to prevent an error when the \file{.ldf} file +% is loaded. +% \begin{macrocode} + \def\ProvidesLanguage#1[#2 #3 #4]{% + \wlog{Language: #1 #4 #3 <#2>}}% +\else +% \end{macrocode} +% Now we define an error message which `deletes' itself from +% memory. +% \begin{macrocode} + \def\bblstyerror{% + \PackageError{babel}% + {You have used an old interface to call babel\MessageBreak + You may expect compatibility problems wit other packages}% + {You could proceed but don't complain if you run into errors}% + \let\bblstyerror\@undefined + } +% \end{macrocode} +% Now we can issue the error, it should appear when these files are +% loaded from \LaTeXe, with \emph{or} without \file{hyphen.cfg} +% preloaded in the format. +% \changes{bbcompat-1.2e}{1999/04/20}{Added a check for +% \cs{ProvidesLanguage}} +% \begin{macrocode} + \ifx\ProvidesLanguage\undefined +% \end{macrocode} +% In this case \file{hyphen.cfg} wasn't loaded in the \LaTeXe\ +% format so we also need to provide a suitable definition for +% |\ProvidesLanguage|. +% \begin{macrocode} + \bblstyerror + \def\ProvidesLanguage{% + \chardef\atcatcode=\catcode`\@ + \catcode`\@=11\relax + \input babel.def\relax + \catcode`\@=\atcatcode \let\atcatcode\relax + \ProvidesLanguage} +% \end{macrocode} +% When we end up here, \file{hyphen.cfg} was loaded into the +% format; we only need to issue the error from \LaTeXe. +% \begin{macrocode} + \else + \bblstyerror + \fi +\fi +% \end{macrocode} +% \changes{bbcompat-1.2}{1996/07/13}{Added \file{.sty} files and +% definition of \cs{CurrentOption} for language definition files +% that are loaded by more than one option.} +% \changes{bbcompat-1.2}{1996/12/14}{Added \file{welsh.sty}} +% \changes{bbcompat-1.2b}{1997/02/07}{Added \file{sanskrit.sty}} +% \changes{bbcompat-1.2c}{1998/03/24}{Added \file{hebrew.sty}} +% \changes{bbcompat-1.2d}{1999/03/09}{Added \file{ukraineb.sty}} +% \changes{bbcompat-1.2d}{1999/04/10}{Added \file{ngerman.sty} and +% \file{naustrian.sty}} +% \changes{bbcompat-1.2f}{2000/09/26}{Added \file{icelandic.sty}, +% \file{bulgarian.sty} and \file{samin.sty}} +% \changes{bbcompat-1.2f}{2000/09/27}{Define \cs{CurrentOption} in +% each file} +% \changes{bbcompat-1.2g}{2001/01/19}{Added code for usenglish and +% ukenglish.sty} +% \changes{bbcompat-1.2h}{2003/11/13}{Added \file{interlingua.sty}} +% \changes{bbcompat-1.2i}{2005/11/23}{Added \file{albanian.sty} and +% \file{bahasam.sty}} +% \changes{bbcompat-1.2k}{2008/07/06}{Added \file{latin.sty}} +% \begin{macrocode} +%<+albanian>\def\CurrentOption{albanian} +%<+albanian>\input albanian.ldf\relax +%<+american>\def\CurrentOption{american} +%<+USenglish>\def\CurrentOption{USenglish} +%<+british>\def\CurrentOption{british} +%<+english>\def\CurrentOption{english} +%<+UKenglish>\def\CurrentOption{UKenglish} +%<american|british|english|UKenglish|USenglish>\input english.ldf\relax +%<+bahasa>\def\CurrentOption{bahasai} +%<+bahasa>\input bahasai.ldf\relax +%<+bahasam>\def\CurrentOption{bahasam} +%<+bahasam>\input bahasam.ldf\relax +%<+breton>\def\CurrentOption{breton} +%<+breton>\input breton.ldf\relax +%<+bulgarian>\def\CurrentOption{bulgarian} +%<+bulgarian>\input bulgarian.ldf\relax +%<+catalan>\def\CurrentOption{catalan} +%<+catalan>\input catalan.ldf\relax +%<+croatian>\def\CurrentOption{croatian} +%<+croatian>\input croatian.ldf\relax +%<+czech>\def\CurrentOption{czech} +%<+czech>\input czech.ldf\relax +%<+danish>\def\CurrentOption{danish} +%<+danish>\input danish.ldf\relax +%<+afrikaans>\def\CurrentOption{afrikaans} +%<+dutch>\def\CurrentOption{dutch} +%<+afrikaans|dutch>\input dutch.ldf\relax +%<+esperanto>\def\CurrentOption{esperanto} +%<+esperanto>\input esperanto.ldf\relax +%<+estonian>\def\CurrentOption{estonian} +%<+estonian>\input estonian.ldf\relax +%<+finnish>\def\CurrentOption{finnish} +%<+finnish>\input finnish.ldf\relax +%<+francais>\def\CurrentOption{francais} +%<+french>\def\CurrentOption{french} +%<+francais|french>\input frenchb.ldf\relax +%<+galician>\def\CurrentOption{galician} +%<+galician>\input galician.ldf\relax +%<+austrian>\def\CurrentOption{austrian} +%<+german>\def\CurrentOption{german} +%<+germanb>\def\CurrentOption{german} +%<+austrian|german|germanb>\input germanb.ldf\relax +%<+naustrian>\def\CurrentOption{naustrian} +%<+ngerman>\def\CurrentOption{ngerman} +%<+naustrian|ngerman>\input ngermanb.ldf\relax +%<+greek>\def\CurrentOption{greek} +%<+greek>\input greek.ldf\relax +%<+icelandic>\def\CurrentOption{icelandic} +%<+icelandic>\input icelandic.ldf\relax +%<+interlingua>\def\CurrentOption{interlingua} +%<+interlingua>\input interlingua.ldf\relax +%<+irish>\def\CurrentOption{irish} +%<+irish>\input irish.ldf\relax +%<+italian>\def\CurrentOption{italian} +%<+italian>\input italian.ldf\relax +%<+latin>\def\CurrentOption{latin} +%<+latin>\input latin.ldf\relax +%<+lsorbian>\def\CurrentOption{lsorbian} +%<+lsorbian>\input lsorbian.ldf\relax +%<+magyar>\def\CurrentOption{magyar} +%<+hungarian>\def\CurrentOption{hungarian} +%<+magyar|hungarian>\input magyar.ldf\relax +%<+norsk>\def\CurrentOption{norsk} +%<+nynorsk>\def\CurrentOption{nynorsk} +%<+norsk|nynorsk>\input norsk.ldf\relax +%<+polish>\def\CurrentOption{polish} +%<+polish>\input polish.ldf\relax +%<+portuges>\def\CurrentOption{portuges} +%<+portuguese>\def\CurrentOption{portuguese} +%<+brazil>\def\CurrentOption{brazil} +%<+brazilian>\def\CurrentOption{brazilian} +%<+portuges|portuguese|brazil|brazilian>\input portuges.ldf\relax +%<+romanian>\def\CurrentOption{romanian} +%<+romanian>\input romanian.ldf\relax +%<+russianb>\def\CurrentOption{russianb} +%<+russianb>\input russianb.ldf\relax +%<+ukraineb>\def\CurrentOption{ukraineb} +%<+ukraineb>\input ukraineb.ldf\relax +%<+samin>\def\CurrentOption{samin} +%<+samin>\input samin.ldf\relax +%<+sanskrit>\def\CurrentOption{sanskrit} +%<+sanskrit>\input sanskrit.ldf\relax +%<+scottish>\def\CurrentOption{scottish} +%<+scottish>\input scottish.ldf\relax +%<+slovak>\def\CurrentOption{slovak} +%<+slovak>\input slovak.ldf\relax +%<+slovene>\def\CurrentOption{slovene} +%<+slovene>\input slovene.ldf\relax +%<+spanish>\def\CurrentOption{spanish} +%<+spanish>\input spanish.ldf\relax +%<+swedish>\def\CurrentOption{swedish} +%<+swedish>\input swedish.ldf\relax +%<+turkish>\def\CurrentOption{turkish} +%<+turkish>\input turkish.ldf\relax +%<+usorbian>\def\CurrentOption{usorbian} +%<+usorbian>\input usorbian.ldf\relax +%<+welsh>\def\CurrentOption{welsh} +%<+welsh>\input welsh.ldf\relax +%<+hebrew>\def\CurrentOption{hebrew} +%<+hebrew>\input rlbabel.def\input hebrew.ldf\relax +% \end{macrocode} +%% +%% \CharacterTable +%% {Upper-case \A\B\C\D\E\F\G\H\I\J\K\L\M\N\O\P\Q\R\S\T\U\V\W\X\Y\Z +%% Lower-case \a\b\c\d\e\f\g\h\i\j\k\l\m\n\o\p\q\r\s\t\u\v\w\x\y\z +%% Digits \0\1\2\3\4\5\6\7\8\9 +%% Exclamation \! Double quote \" Hash (number) \# +%% Dollar \$ Percent \% Ampersand \& +%% Acute accent \' Left paren \( Right paren \) +%% Asterisk \* Plus \+ Comma \, +%% Minus \- Point \. Solidus \/ +%% Colon \: Semicolon \; Less than \< +%% Equals \= Greater than \> Question mark \? +%% Commercial at \@ Left bracket \[ Backslash \\ +%% Right bracket \] Circumflex \^ Underscore \_ +%% Grave accent \` Left brace \{ Vertical bar \| +%% Right brace \} Tilde \~} +\endinput diff --git a/Master/texmf-dist/source/latex/babel/bbidxglo.dtx b/Master/texmf-dist/source/latex/babel/bbidxglo.dtx new file mode 100644 index 00000000000..58a43d9adbf --- /dev/null +++ b/Master/texmf-dist/source/latex/babel/bbidxglo.dtx @@ -0,0 +1,124 @@ +% \iffalse meta-comment +% +% Copyright 1989-2008 Johannes L. Braams and any individual authors +% listed elsewhere in this file. All rights reserved. +% +% This file is part of the Babel system. +% -------------------------------------- +% +% It may be distributed and/or modified under the +% conditions of the LaTeX Project Public License, either version 1.3 +% of this license or (at your option) any later version. +% The latest version of this license is in +% http://www.latex-project.org/lppl.txt +% and version 1.3 or later is part of all distributions of LaTeX +% version 2003/12/01 or later. +% +% This work has the LPPL maintenance status "maintained". +% +% The Current Maintainer of this work is Javier Bezos. +% +% The list of all files belonging to the Babel system is +% given in the file `manifest.bbl. See also `legal.bbl' for additional +% information. +% +% The list of derived (unpacked) files belonging to the distribution +% and covered by LPPL is defined by the unpacking scripts (with +% extension .ins) which are part of the distribution. +% \fi +% \CheckSum{66} +% +% \iffalse +% +% \begin{macrocode} +%<*driver> +\ProvidesFile{bbidxglo.drv}[2008/03/21 v1.0b] +\documentclass{ltxdoc} +\GetFileInfo{bbidxglo.drv} +\newcommand{\babel}{\textsf{babel}} +\newcommand{\mkidx}{\texttt{MakeIndex}} +\newcommand{\file}[1]{\texttt{#1}} +\newcommand{\Lopt}[1]{\textsf{#1}} +\begin{document} +\DocInput{bbidxglo.dtx} +\end{document} +%</driver> +% \end{macrocode} +% +% \fi +% \title{Generating the index and chage log for the Babel system} +% \author{Johannes Braams} +% \date{\filedate} +% \maketitle +% +% \section{Description} +% +% This file contains the source for the style files for the \mkidx\ +% program. These are needed to produce the index for the complete +% source listing and to produce the listing of the changes. +% +% \StopEventually{} +% +% \section{The index and the list of changes } Most of the entries are +% the same as in the files \file{gind.ist} and \file{gglo.ist} from +% the \Lopt{doc} package. +% +% \begin{macrocode} +%<*idx|glo> +actual '=' +quote '!' +level '>' +%</idx|glo> +% \end{macrocode} +% +% Because the \babel\ system consists of so many files the default +% codeline numbering scheme of the \Lopt{doc} package has been +% adapted. The line numbers consist of two parts seperated with a +% dot. This has to made known to the \mkidx\ program when it +% produces the index. +% +% \begin{macrocode} +%<+idx>page_compositor "." +% \end{macrocode} +% +% Any further entries are again copied from \file{gind.ist} and +% \file{gglo.ist}. +% +% \begin{macrocode} +%<*idx> +preamble +"\n \\begin{theindex} \n \\makeatletter\\scan@allowedfalse\n" +postamble +"\n\n \\end{theindex}\n" +%</idx> +%<*glo> +preamble +"\n \\begin{theglossary} \n + \\makeatletter\\scan@allowedfalse\n" +postamble +"\n\n \\end{theglossary}\n" +keyword "\\glossaryentry" +%</glo> +%<+idx|glo>item_x1 "\\efill \n \\subitem " +%<+idx>item_x2 "\\efill \n \\subsubitem " +%<+glo>item_x2 "\\ " +%<*idx|glo> +delim_0 "\\pfill " +delim_1 "\\pfill " +delim_2 "\\pfill " +% The next lines will produce some warnings when +% running Makeindex as they try to cover two different +% versions of the program: +lethead_prefix "{\\bfseries\\hfil " +lethead_suffix "\\hfil}\\nopagebreak\n" +%</idx|glo> +%<+idx>lethead_flag 1 +%<+glo>lethead_flag 0 +%<*idx|glo> +heading_prefix "{\\bfseries\\hfil " +heading_suffix "\\hfil}\\nopagebreak\n" +%</idx|glo> +%<+idx>headings_flag 1 +%<+glo>headings_flag 0 +% \end{macrocode} +% diff --git a/Master/texmf-dist/source/latex/babel/bbplain.dtx b/Master/texmf-dist/source/latex/babel/bbplain.dtx new file mode 100644 index 00000000000..b454b897fd6 --- /dev/null +++ b/Master/texmf-dist/source/latex/babel/bbplain.dtx @@ -0,0 +1,728 @@ +% \iffalse meta-comment +% +% Copyright 2012-2013 Javier Bezos and Johannes L. Braams. +% Copyright 1989-2008 Johannes L. Braams and any individual authors +% listed elsewhere in this file. All rights reserved. +% +% This file is part of the Babel system. +% -------------------------------------- +% +% It may be distributed and/or modified under the +% conditions of the LaTeX Project Public License, either version 1.3 +% of this license or (at your option) any later version. +% The latest version of this license is in +% http://www.latex-project.org/lppl.txt +% and version 1.3 or later is part of all distributions of LaTeX +% version 2003/12/01 or later. +% +% This work has the LPPL maintenance status "maintained". +% +% The Current Maintainer of this work is Javier Bezos. +% +% The list of all files belonging to the Babel system is +% given in the file `manifest.bbl. See also `legal.bbl' for additional +% information. +% +% The list of derived (unpacked) files belonging to the distribution +% and covered by LPPL is defined by the unpacking scripts (with +% extension .ins) which are part of the distribution. +% \fi +% \CheckSum{795} +% +% \iffalse +%<*dtx> +\ProvidesFile{bbplain.dtx} + [2013/04/10 v1.0t Babel support for plain-based formats] +%</dtx> +% +%% File `bbplain.dtx' +%% Babel package for LaTeX version 2e +%% Copyright (C) 1989 - 2008 +%% by Johannes Braams +%% Copyright (C) 2013 by Johannes Braams +%% TeXniek +%% by Javier Bezos +%% all rights reserved. +% +% +% This file is part of the babel system, it provides the source +% code for the extra definitions needed to be able to use babel +% with a plain-based format. +%<*filedriver> +\documentclass{ltxdoc} +\font\manual=logo10 % font used for the METAFONT logo, etc. +\newcommand*\MF{{\manual META}\-{\manual FONT}} +\newcommand*{\babel}{\textsf{babel}} +\newcommand*{\langvar}{$\langle \it lang \rangle$} +\newcommand*{\note}[1]{} +\newcommand*{\pkg}[1]{\textsf{#1}} +\newcommand*{\Lopt}[1]{\textsf{#1}} +\newcommand*{\file}[1]{\texttt{#1}} +\begin{document} + \DocInput{bbplain.dtx} +\end{document} +%</filedriver> +% \fi +% +% \GetFileInfo{bbplain.dtx} +% \StopEventually{} +% \changes{bbplain-1.0n}{1998/06/08}{Added the source for the format +% wrapper files} +% +% \section{Support for Plain \TeX} +% +% \subsection{Not renaming \file{hyphen.tex}} +% As Don Knuth has declared that the filename \file{hyphen.tex} may +% only be used to designate \emph{his} version of the american +% English hyphenation patterns, a new solution has to be found in +% order to be able to load hyphenation patterns for other languages +% in a plain-based \TeX-format. +% When asked he responded: +% \begin{quote} +% That file name is "sacred", and if anybody changes it they will +% cause severe upward/downward compatibility headaches. +% +% People can have a file localhyphen.tex or whatever they like, +% but they mustn't diddle with hyphen.tex (or plain.tex except to +% preload additional fonts). +% \end{quote} +% +% The files \file{bplain.tex} and \file{blplain.tex} can be used as +% replacement wrappers around \file{plain.tex} and +% \file{lplain.tex} to acheive the desired effect, based on the +% \pkg{babel} package. If you load each of them with ini\TeX, you +% will get a file called either \file{bplain.fmt} or +% \file{blplain.fmt}, which you can use as replacements for +% \file{plain.fmt} and \file{lplain.fmt}. +% +% As these files are going to be read as the first thing ini\TeX\ +% sees, we need to set some category codes just to be able to +% change the definition of |\input| +% \begin{macrocode} +%<*bplain|blplain> +\catcode`\{=1 % left brace is begin-group character +\catcode`\}=2 % right brace is end-group character +\catcode`\#=6 % hash mark is macro parameter character +% \end{macrocode} +% Now let's see if a file called \file{hyphen.cfg} can be found +% somewhere on \TeX's input path by trying to open it for +% reading... +% \begin{macrocode} +\openin 0 hyphen.cfg +% \end{macrocode} +% If the file wasn't found the following test turns out true. +% \begin{macrocode} +\ifeof0 +\else +% \end{macrocode} +% When \file{hyphen.cfg} could be opened we make sure that +% \emph{it} will be read instead of the file \file{hyphen.tex} +% which should (according to Don Knuth's ruling) contain the +% american English hyphenation patterns and nothing else. +% +% We do this by first saving the original meaning of |\input| (and +% I use a one letter control sequence for that so as not to waste +% multi-letter control sequence on this in the format). +% \begin{macrocode} + \let\a\input +% \end{macrocode} +% Then |\input| is defined to forget about its argument and load +% \file{hyphen.cfg} instead. +% \begin{macrocode} + \def\input #1 {% + \let\input\a + \a hyphen.cfg +% \end{macrocode} +% Once that's done the original meaning of |\input| can be restored +% and the definition of |\a| can be forgotten. +% \begin{macrocode} + \let\a\undefined + } +\fi +%</bplain|blplain> +% \end{macrocode} +% Now that we have made sure that \file{hyphen.cfg} will be loaded +% at the right moment it is time to load \file{plain.tex}. +% \begin{macrocode} +%<bplain>\a plain.tex +%<blplain>\a lplain.tex +% \end{macrocode} +% Finally we change the contents of |\fmtname| to indicate that +% this is \emph{not} the plain format, but a format based on plain +% with the \pkg{babel} package preloaded. +% \begin{macrocode} +%<bplain>\def\fmtname{babel-plain} +%<blplain>\def\fmtname{babel-lplain} +% \end{macrocode} +% +% When you are using a different format, based on plain.tex you can +% make a copy of blplain.tex, rename it and replace \file{plain.tex} +% with the name of your format file. +% +% \subsection{Emulating some \LaTeX{} features} +% +% The following code duplicates or emulates parts of \LaTeXe\ that +% are needed for \babel. +% +% \changes{bbplain-1.0f}{1996/07/09}{Consistently use \cs{@undefined} +% instead of \cs{undefined}} +% \changes{bbplain-1.0f}{1996/07/09}{added \cs{@empty}} +% \changes{bbplain-1.0h}{1996/10/07}{Only load the necessary parts +% into the format, let this file be read agian by babel.def} +% \changes{bbplain-1.0h}{2012/12/21}{Use \cs{orig@dump} as flag to +% decide if we are building the format, defined in hyphen.cfg} +% +% When |\adddialect| is still undefined we are making a +% format. In that case only the first part of this file is needed. +% \begin{macrocode} +%<*code> +\def\@empty{} +\ifx\orig@dump\@undefined\else +% \end{macrocode} +% +% \changes{bbplain-1.0c}{1995/11/08}{Moved the \cs{dump} code here from +% \file{babel.dtx}} +% \changes{bbplain-0.1}{1991/10/31}{Added redefinition of \cs{dump} to +% add a message to \cs{everyjob}} +% We want to add a message to the message \LaTeX$\:$2.09 puts in +% the |\everyjob| register. This could be done by the following +% code: +% \begin{verbatim} +% \let\orgeveryjob\everyjob +% \def\everyjob#1{% +% \orgeveryjob{#1}% +% \orgeveryjob\expandafter{\the\orgeveryjob\immediate\write16{% +% hyphenation patterns for \the\loaded@patterns loaded.}}% +% \let\everyjob\orgeveryjob\let\orgeveryjob\@undefined} +% \end{verbatim} +% The code above redefines the control sequence \cs{everyjob} +% in order to be able to add something to the current contents of +% the register. This is necessary because the processing of +% hyphenation patterns happens long before \LaTeX\ fills the +% register. +% +% There are some problems with this approach though. +% \begin{itemize} +% \item When someone wants to use several hyphenation patterns with +% \SliTeX\ the above scheme won't work. The reason is that \SliTeX\ +% overwrites the contents of the |\everyjob| register with its own +% message. +% \item Plain \TeX\ does not use the |\everyjob| register so the +% message would not be displayed. +% \end{itemize} +% To circumvent this a `dirty trick' can be used. As this code is +% only processed when creating a new format file there is one +% command that is sure to be used, |\dump|. Therefore the original +% |\dump| is saved in |\org@dump| and a new definition is supplied. +% +% To make sure that \LaTeX$\:$2.09 executes the +% |\@begindocumenthook| we would want to alter |\begin{document}|, +% but as this done too often already, we add the new code at the +% front of |\@preamblecmds|. But we can only do that after it has +% been defined, so we add this piece of code to |\dump|. +% \changes{bbplain-1.0c}{1995/11/19}{Add execution of +% \cs{@begindocumenthook} to \cs{@preamblecmds}} +% \changes{bbplain-1.0i}{1997/01/02}{\cs{document} is not a +% \LaTeX2.09-only command; AMS\TeX defines it too; now use +% \cs{@ztryfc} to detect \LaTeX2.09} +% \changes{bbplain-1.0j}{1997/01/07}{Add the definition of +% \cs{@begindocumenthook} to the \LaTeX2.09 format} +% \begin{macrocode} + \def\dump{% + \ifx\@ztryfc\@undefined + \else + \toks0=\expandafter{\@preamblecmds} + \edef\@preamblecmds{\noexpand\@begindocumenthook\the\toks0} + \def\@begindocumenthook{} + \fi +% \end{macrocode} +% This new definition starts by adding an instruction to write a +% message on the terminal and in the transcript file to inform the +% user of the preloaded hyphenation patterns. +% \changes{bbplain-1.0f}{1996/07/09}{Use \cs{toks8} instead of +% \cs{patterns@loaded}} +% \begin{macrocode} + \everyjob\expandafter{\the\everyjob% + \immediate\write16{\the\toks8 loaded.}}% +% \end{macrocode} +% Then everything is restored to the old situation and the format +% is dumped. +% \begin{macrocode} + \let\dump\orig@dump\let\orig@dump\@undefined\dump} + \expandafter\endinput +\fi +% \end{macrocode} +% The rest of this file is not processed by ini\TeX\ but during the +% normal document run. +% +% We need to define |\loadlocalcfg| for plain users as the +% \LaTeX\ definition uses |\InputIfFileExists|. We have to execute +% \cs{@endofldf} in this case. +% \changes{bbplain-1.0c}{1995/07/26}{Added definition of +% \cs{loadlocalcfg}} +% \changes{bbplain-1.0d}{1996/01/08}{Also reset category codes after +% loading the configuration file as \cs{AtEndOfPackage} is +% undefined in this case} +% \changes{bbplain-1.0s}{2012/12/21}{\cs{loadlocalcfg} not loaded in +% the format} +% \begin{macrocode} +\def\loadlocalcfg#1{% + \openin0#1.cfg + \ifeof0 + \closein0 + \else + \closein0 + {\immediate\write16{*************************************}% + \immediate\write16{* Local config file #1.cfg used}% + \immediate\write16{*}% + } + \input #1.cfg\relax + \fi + \@endofldf} +% \end{macrocode} +% +% A number of \LaTeX\ macro's that are needed later on. +% \changes{bbplain-1.0n}{1998/06/10}{Added \cs{@secondoftwo}} +% \changes{bbplain-1.0q}{1999/09/16}{Added \cs{@ifundefined}} +% \changes{bbplain-1.0t}{2013/04/10}{Added \cs{@expandtwoargs}} +% \begin{macrocode} +\long\def\@firstofone#1{#1} +\long\def\@firstoftwo#1#2{#1} +\long\def\@secondoftwo#1#2{#2} +\def\@ifstar#1{\@ifnextchar *{\@firstoftwo{#1}}} +\def\@star@or@long#1{% + \@ifstar + {\let\l@ngrel@x\relax#1}% + {\let\l@ngrel@x\long#1}} +\let\l@ngrel@x\relax +\def\@car#1#2\@nil{#1} +\def\@cdr#1#2\@nil{#2} +\let\@typeset@protect\relax +\long\def\@gobble#1{} +\edef\@backslashchar{\expandafter\@gobble\string\\} +\def\strip@prefix#1>{} +\def\g@addto@macro#1#2{{% + \toks@\expandafter{#1#2}% + \xdef#1{\the\toks@}}} +\def\@namedef#1{\expandafter\def\csname #1\endcsname} +\def\@nameuse#1{\csname #1\endcsname} +\def\@ifundefined#1{% + \expandafter\ifx\csname#1\endcsname\relax + \expandafter\@firstoftwo + \else + \expandafter\@secondoftwo + \fi} +\def\@expandtwoargs#1#2#3{% + \edef\reserved@a{\noexpand#1{#2}{#3}}\reserved@a} +% \end{macrocode} +% \LaTeXe\ has the command |\@onlypreamble| which adds commands to +% a list of commands that are no longer needed after +% |\begin{document}|. +% \begin{macrocode} +\ifx\@preamblecmds\@undefined + \def\@preamblecmds{} +\fi +\def\@onlypreamble#1{% + \expandafter\gdef\expandafter\@preamblecmds\expandafter{% + \@preamblecmds\do#1}} +\@onlypreamble\@onlypreamble +% \end{macrocode} +% Mimick \LaTeX's |\AtBeginDocument|; for this to work the user +% needs to add |\begindocument| to his file. +% \begin{macrocode} +\def\begindocument{% + \@begindocumenthook + \global\let\@begindocumenthook\@undefined + \def\do##1{\global\let ##1\@undefined}% + \@preamblecmds + \global\let\do\noexpand + } +% \end{macrocode} +% +% \changes{bbplain-1.0j}{1997/01/07}{\cs{@begindocumenthook} might +% already be defined} +% \changes{bbplain-1.0k}{1997/01/14}{missing \cs{@undefined} added} +% \begin{macrocode} +\ifx\@begindocumenthook\@undefined + \def\@begindocumenthook{} +\fi +\@onlypreamble\@begindocumenthook +\def\AtBeginDocument{\g@addto@macro\@begindocumenthook} +% \end{macrocode} +% We also have to mimick \LaTeX's |\AtEndOfPackage|. Our +% replacement macro is much simpler; it stores its argument in +% |\@endofldf|. +% \begin{macrocode} +\def\AtEndOfPackage#1{\g@addto@macro\@endofldf{#1}} +\@onlypreamble\AtEndOfPackage +\def\@endofldf{} +\@onlypreamble\@endofldf +\let\bbl@afterlang\@empty +% \end{macrocode} +% \LaTeX\ needs to be able to switch off writing to its auxiliary +% files; plain doesn't have them by default. +% \changes{bbplain-1.0m}{1997/04/28}{Set \cs{if@filesw} to +% \cs{iffalse} only for plain \TeX} +% \changes{bbplain-1.0n}{1997/09/11}{Repaired typo and added missing +% \cs{endcsname}} +% \begin{macrocode} +\ifx\if@filesw\@undefined + \expandafter\let\csname if@filesw\expandafter\endcsname + \csname iffalse\endcsname +\fi +% \end{macrocode} +% Mimick \LaTeX's commands to define control sequences. +% \changes{bbplain-1.0e}{1996/02/22}{Provide a more complete emulation +% of \cs{DeclareRobustCommand} and \cs{newcommand}} +% \begin{macrocode} +\def\newcommand{\@star@or@long\new@command} +\def\new@command#1{% + \@testopt{\@newcommand#1}0} +\def\@newcommand#1[#2]{% + \@ifnextchar [{\@xargdef#1[#2]}% + {\@argdef#1[#2]}} +\long\def\@argdef#1[#2]#3{% + \@yargdef#1\@ne{#2}{#3}} +\long\def\@xargdef#1[#2][#3]#4{% + \expandafter\def\expandafter#1\expandafter{% + \expandafter\@protected@testopt\expandafter #1% + \csname\string#1\expandafter\endcsname{#3}}% + \expandafter\@yargdef \csname\string#1\endcsname + \tw@{#2}{#4}} +\long\def\@yargdef#1#2#3{% + \@tempcnta#3\relax + \advance \@tempcnta \@ne + \let\@hash@\relax + \edef\reserved@a{\ifx#2\tw@ [\@hash@1]\fi}% + \@tempcntb #2% + \@whilenum\@tempcntb <\@tempcnta + \do{% + \edef\reserved@a{\reserved@a\@hash@\the\@tempcntb}% + \advance\@tempcntb \@ne}% + \let\@hash@##% + \l@ngrel@x\expandafter\def\expandafter#1\reserved@a} +\let\providecommand\newcommand +% \end{macrocode} +% +% \begin{macrocode} +\def\DeclareRobustCommand{\@star@or@long\declare@robustcommand} +\def\declare@robustcommand#1{% + \edef\reserved@a{\string#1}% + \def\reserved@b{#1}% + \edef\reserved@b{\expandafter\strip@prefix\meaning\reserved@b}% + \edef#1{% + \ifx\reserved@a\reserved@b + \noexpand\x@protect + \noexpand#1% + \fi + \noexpand\protect + \expandafter\noexpand\csname + \expandafter\@gobble\string#1 \endcsname + }% + \expandafter\new@command\csname + \expandafter\@gobble\string#1 \endcsname +} +\def\x@protect#1{% + \ifx\protect\@typeset@protect\else + \@x@protect#1% + \fi +} +\def\@x@protect#1\fi#2#3{% + \fi\protect#1% +} +% \end{macrocode} +% +% The following little macro |\in@| is taken from latex.ltx; it +% checks whether its first argument is part of its second +% argument. It uses the boolean |\in@|; allocating a new boolean +% inside conditionally executed code is not possible, hence the +% construct with the temporary definition of |\bbl@tempa|. +% \changes{bbplain-1.0o}{1998/07/02}{Added definition of \cs{in@}} +% \changes{bbplain-1.0s}{2013/01/15}{Use \cs{bbl@tempa} as documented} +% \begin{macrocode} +\def\bbl@tempa{\csname newif\endcsname\ifin@} +\ifx\in@\@undefined + \def\in@#1#2{% + \def\in@@##1#1##2##3\in@@{% + \ifx\in@##2\in@false\else\in@true\fi}% + \in@@#2#1\in@\in@@} +\else + \let\bbl@tempa\@empty +\fi +\bbl@tempa +% \end{macrocode} +% +% \LaTeX\ has a macro to check whether a certain package was loaded +% with specific options. The command has two extra arguments which +% are code to be executed in either the true or false case. +% This is used to detect whether the document needs one of the +% accents to be activated (\Lopt{activegrave} and +% \Lopt{activeacute}). For plain \TeX\ we assume that the user +% wants them to be active by default. Therefore the only thing we +% do is execute the third argument (the code for the true case). +% +% \begin{macrocode} +\def\@ifpackagewith#1#2#3#4{% + #3} +% \end{macrocode} +% The \LaTeX\ macro |\@ifl@aded| checks whether a file was +% loaded. This functionality is not needed for plain \TeX\ but we +% need the macro to be defined as a no-op. +% \changes{bbplain-1.0p}{1999/04/27}{Added \cs{@ifl@aded} as a no-op} +% \begin{macrocode} +\def\@ifl@aded#1#2#3#4{} +% \end{macrocode} +% +% \changes{bbplain-1.0e}{1996/01/15}{Added the \cs{newcommand} code} +% For the following code we need to make sure that the commands +% |\newcommand| and |\providecommand| exist with some sensible +% definition. They are not fully equivalent to their \LaTeXe\ +% versions; just enough to make things work in plain~\TeX +% environments. +% +% \changes{bbplain-1.0k}{1997/01/14}{\cs{newcount} is an \cs{outer} +% command, can't use it inside an \cs{if} construct} +% \changes{bbplain-1.0l}{1997/01/19}{Mixed up the definition of +% \cs{@tempcntb}} +% \begin{macrocode} +\ifx\@tempcnta\@undefined + \csname newcount\endcsname\@tempcnta\relax +\fi +\ifx\@tempcntb\@undefined + \csname newcount\endcsname\@tempcntb\relax +\fi +% \end{macrocode} +% To prevent wasting two counters in \LaTeX$\:$2.09 (because +% counters with the same name are allocated later by it) we reset +% the counter that holds the next free counter (|\count10|). +% \begin{macrocode} +\ifx\bye\@undefined + \advance\count10 by -2\relax +\fi +\ifx\@ifnextchar\@undefined + \def\@ifnextchar#1#2#3{% + \let\reserved@d=#1% + \def\reserved@a{#2}\def\reserved@b{#3}% + \futurelet\@let@token\@ifnch} + \def\@ifnch{% + \ifx\@let@token\@sptoken + \let\reserved@c\@xifnch + \else + \ifx\@let@token\reserved@d + \let\reserved@c\reserved@a + \else + \let\reserved@c\reserved@b + \fi + \fi + \reserved@c} + \def\:{\let\@sptoken= } \: % this makes \@sptoken a space token + \def\:{\@xifnch} \expandafter\def\: {\futurelet\@let@token\@ifnch} +\fi +\def\@testopt#1#2{% + \@ifnextchar[{#1}{#1[#2]}} +\def\@protected@testopt#1{%% + \ifx\protect\@typeset@protect + \expandafter\@testopt + \else + \@x@protect#1% + \fi} +\long\def\@whilenum#1\do #2{\ifnum #1\relax #2\relax\@iwhilenum{#1\relax + #2\relax}\fi} +\long\def\@iwhilenum#1{\ifnum #1\expandafter\@iwhilenum + \else\expandafter\@gobble\fi{#1}} +% \end{macrocode} +% Code from \file{ltoutenc.dtx}, adapted for use in the plain \TeX\ +% environment. +% \begin{macrocode} +\def\DeclareTextCommand{% + \@dec@text@cmd\providecommand +} +\def\ProvideTextCommand{% + \@dec@text@cmd\providecommand +} +\def\DeclareTextSymbol#1#2#3{% + \@dec@text@cmd\chardef#1{#2}#3\relax +} +\def\@dec@text@cmd#1#2#3{% + \expandafter\def\expandafter#2% + \expandafter{% + \csname#3-cmd\expandafter\endcsname + \expandafter#2% + \csname#3\string#2\endcsname + }% +% \let\@ifdefinable\@rc@ifdefinable + \expandafter#1\csname#3\string#2\endcsname +} +\def\@current@cmd#1{% + \ifx\protect\@typeset@protect\else + \noexpand#1\expandafter\@gobble + \fi +} +\def\@changed@cmd#1#2{% + \ifx\protect\@typeset@protect + \expandafter\ifx\csname\cf@encoding\string#1\endcsname\relax + \expandafter\ifx\csname ?\string#1\endcsname\relax + \expandafter\def\csname ?\string#1\endcsname{% + \@changed@x@err{#1}% + }% + \fi + \global\expandafter\let + \csname\cf@encoding \string#1\expandafter\endcsname + \csname ?\string#1\endcsname + \fi + \csname\cf@encoding\string#1% + \expandafter\endcsname + \else + \noexpand#1% + \fi +} +\def\@changed@x@err#1{% + \errhelp{Your command will be ignored, type <return> to proceed}% + \errmessage{Command \protect#1 undefined in encoding \cf@encoding}} +\def\DeclareTextCommandDefault#1{% + \DeclareTextCommand#1?% +} +\def\ProvideTextCommandDefault#1{% + \ProvideTextCommand#1?% +} +\expandafter\let\csname OT1-cmd\endcsname\@current@cmd +\expandafter\let\csname?-cmd\endcsname\@changed@cmd +\def\DeclareTextAccent#1#2#3{% + \DeclareTextCommand#1{#2}[1]{\accent#3 ##1} +} +\def\DeclareTextCompositeCommand#1#2#3#4{% + \expandafter\let\expandafter\reserved@a\csname#2\string#1\endcsname + \edef\reserved@b{\string##1}% + \edef\reserved@c{% + \expandafter\@strip@args\meaning\reserved@a:-\@strip@args}% + \ifx\reserved@b\reserved@c + \expandafter\expandafter\expandafter\ifx + \expandafter\@car\reserved@a\relax\relax\@nil + \@text@composite + \else + \edef\reserved@b##1{% + \def\expandafter\noexpand + \csname#2\string#1\endcsname####1{% + \noexpand\@text@composite + \expandafter\noexpand\csname#2\string#1\endcsname + ####1\noexpand\@empty\noexpand\@text@composite + {##1}% + }% + }% + \expandafter\reserved@b\expandafter{\reserved@a{##1}}% + \fi + \expandafter\def\csname\expandafter\string\csname + #2\endcsname\string#1-\string#3\endcsname{#4} + \else + \errhelp{Your command will be ignored, type <return> to proceed}% + \errmessage{\string\DeclareTextCompositeCommand\space used on + inappropriate command \protect#1} + \fi +} +\def\@text@composite#1#2#3\@text@composite{% + \expandafter\@text@composite@x + \csname\string#1-\string#2\endcsname +} +\def\@text@composite@x#1#2{% + \ifx#1\relax + #2% + \else + #1% + \fi +} +% +\def\@strip@args#1:#2-#3\@strip@args{#2} +\def\DeclareTextComposite#1#2#3#4{% + \def\reserved@a{\DeclareTextCompositeCommand#1{#2}{#3}}% + \bgroup + \lccode`\@=#4% + \lowercase{% + \egroup + \reserved@a @% + }% +} +% +\def\UseTextSymbol#1#2{% +% \let\@curr@enc\cf@encoding +% \@use@text@encoding{#1}% + #2% +% \@use@text@encoding\@curr@enc +} +\def\UseTextAccent#1#2#3{% +% \let\@curr@enc\cf@encoding +% \@use@text@encoding{#1}% +% #2{\@use@text@encoding\@curr@enc\selectfont#3}% +% \@use@text@encoding\@curr@enc +} +\def\@use@text@encoding#1{% +% \edef\f@encoding{#1}% +% \xdef\font@name{% +% \csname\curr@fontshape/\f@size\endcsname +% }% +% \pickup@font +% \font@name +% \@@enc@update +} +\def\DeclareTextSymbolDefault#1#2{% + \DeclareTextCommandDefault#1{\UseTextSymbol{#2}#1}% +} +\def\DeclareTextAccentDefault#1#2{% + \DeclareTextCommandDefault#1{\UseTextAccent{#2}#1}% +} +\def\cf@encoding{OT1} +% \end{macrocode} +% Currently we only use the \LaTeXe\ method for accents for those +% that are known to be made active in \emph{some} language +% definition file. +% \begin{macrocode} +\DeclareTextAccent{\"}{OT1}{127} +\DeclareTextAccent{\'}{OT1}{19} +\DeclareTextAccent{\^}{OT1}{94} +\DeclareTextAccent{\`}{OT1}{18} +\DeclareTextAccent{\~}{OT1}{126} +% \end{macrocode} +% The following control sequences are used in \file{babel.def} +% but are not defined for \textsc{plain} \TeX. +% \changes{bbplain-1.0f}{1996/07/10}{Added \cs{textquotedblright} and +% \cs{textquoteright}} +% \changes{bbplain-1.0g}{1996/08/15}{Added \cs{ss} and \cs{i}} +% \changes{bbplain-1.0r}{2000/10/02}{Added \cs{textquotedblleft} and +% \cs{textquoteleft}} +% \begin{macrocode} +\DeclareTextSymbol{\textquotedblleft}{OT1}{92} +\DeclareTextSymbol{\textquotedblright}{OT1}{`\"} +\DeclareTextSymbol{\textquoteleft}{OT1}{`\`} +\DeclareTextSymbol{\textquoteright}{OT1}{`\'} +\DeclareTextSymbol{\i}{OT1}{16} +\DeclareTextSymbol{\ss}{OT1}{25} +% \end{macrocode} +% For a couple of languages we need the \LaTeX-control sequence +% |\scriptsize| to be available. Because plain \TeX\ doesn't have +% such a sofisticated font mechanism as \LaTeX\ has, we just |\let| +% it to |\sevenrm|. +% \changes{bbplain-1.0f}{1996/07/10}{Added definition of +% \cs{scriptsize}} +% \begin{macrocode} +\ifx\scriptsize\@undefined + \let\scriptsize\sevenrm +\fi +%</code> +% \end{macrocode} +% +\endinput +%% +%% \CharacterTable +%% {Upper-case \A\B\C\D\E\F\G\H\I\J\K\L\M\N\O\P\Q\R\S\T\U\V\W\X\Y\Z +%% Lower-case \a\b\c\d\e\f\g\h\i\j\k\l\m\n\o\p\q\r\s\t\u\v\w\x\y\z +%% Digits \0\1\2\3\4\5\6\7\8\9 +%% Exclamation \! Double quote \" Hash (number) \# +%% Dollar \$ Percent \% Ampersand \& +%% Acute accent \' Left paren \( Right paren \) +%% Asterisk \* Plus \+ Comma \, +%% Minus \- Point \. Solidus \/ +%% Colon \: Semicolon \; Less than \< +%% Equals \= Greater than \> Question mark \? +%% Commercial at \@ Left bracket \[ Backslash \\ +%% Right bracket \] Circumflex \^ Underscore \_ +%% Grave accent \` Left brace \{ Vertical bar \| +%% Right brace \} Tilde \~} diff --git a/Master/texmf-dist/source/latex/babel/bbunicode.dtx b/Master/texmf-dist/source/latex/babel/bbunicode.dtx new file mode 100644 index 00000000000..79677ae1edb --- /dev/null +++ b/Master/texmf-dist/source/latex/babel/bbunicode.dtx @@ -0,0 +1,180 @@ +% \iffalse meta-comment +% +% Copyright 2013 Javier Bezos and any individual authors +% listed elsewhere in this file. All rights reserved. +% +% This file is part of the Babel system. +% -------------------------------------- +% +% It may be distributed and/or modified under the +% conditions of the LaTeX Project Public License, either version 1.3 +% of this license or (at your option) any later version. +% The latest version of this license is in +% http://www.latex-project.org/lppl.txt +% and version 1.3 or later is part of all distributions of LaTeX +% version 2003/12/01 or later. +% +% This work has the LPPL maintenance status "maintained". +% +% The Current Maintainer of this work is Javier Bezos. +% +% The list of all files belonging to the Babel system is +% given in the file `manifest.bbl. See also `legal.bbl' for additional +% information. +% +% The list of derived (unpacked) files belonging to the distribution +% and covered by LPPL is defined by the unpacking scripts (with +% extension .ins) which are part of the distribution. +% \fi +% \CheckSum{795} +% +% \iffalse +%<*dtx> +\ProvidesFile{bbunicode.dtx} + [2013/04/22 v1.0b Babel hooks for Unicode engines] +%</dtx> +% +%% File `bbunicode.dtx' +%% Babel package for LaTeX version 2e +%% Copyright (C) 2103 +%% by Javier Bezos +% +%<*filedriver> +\documentclass{ltxdoc} +\font\manual=logo10 % font used for the METAFONT logo, etc. +\newcommand*\MF{{\manual META}\-{\manual FONT}} +\newcommand*{\babel}{\textsf{babel}} +\newcommand*{\langvar}{$\langle \it lang \rangle$} +\newcommand*{\note}[1]{} +\newcommand*{\pkg}[1]{\textsf{#1}} +\newcommand*{\Lopt}[1]{\textsf{#1}} +\newcommand*{\file}[1]{\texttt{#1}} +\begin{document} + \DocInput{bbunicode.dtx} +\end{document} +%</filedriver> +% \fi +% +% \GetFileInfo{bbunicode.dtx} +% \StopEventually{} +% +% \section{Hooks for XeTeX and LuaTeX} +% +% \subsection{XeTeX} +% +% Unfortunately, the current encoding cannot be retrieved and +% therefore it is reset always to |utf8|, which seems a sensible default. +% \begin{macrocode} +%<*xetex> +\def\BabelStringsDefault{unicode} +\let\xebbl@stop\relax +\AddBabelHook{xetex}{encodedcommands}{% + \def\bbl@tempa{#1}% + \ifx\bbl@tempa\@empty + \XeTeXinputencoding"bytes"% + \else + \XeTeXinputencoding"#1"% + \fi + \def\xebbl@stop{\XeTeXinputencoding"utf8"}} +\AddBabelHook{xetex}{stopcommands}{% + \xebbl@stop + \let\xebbl@stop\relax} +%</xetex> +% \end{macrocode} +% \subsection{LuaTeX} +% +% This part relies on the |lua| stripts in \pkg{luatex-hyphen} by Khaled +% Hosny, \'{E}lie Roux, and Manuel +% P\'{e}gouri\'{e}-Gonnard. \'{E}lie also improved the code below. +% \changes{bbunicode~1.0b}{2013/04/22}{luatex-hyphen is loaded +% with require. Changes supplied by \'{E}lie Roux.} +% +% \begin{macrocode} +%<*luatex> +\directlua{% + require("luatex-hyphen") + Babel = {} + function Babel.bytes(line) + return line:gsub("(.)", + function (chr) return unicode.utf8.char(string.byte(chr)) end) + end + function Babel.begin_process_input() + if luatexbase and luatexbase.add_to_callback then + luatexbase.add_to_callback('process_input_buffer',Babel.bytes,'Babel.bytes') + else + Babel.callback = callback.find('process_input_buffer') + callback.register('process_input_buffer',Babel.bytes) + end + end + function Babel.end_process_input () + if luatexbase and luatexbase.remove_from_callback then + luatexbase.remove_from_callback('process_input_buffer','Babel.bytes') + else + callback.register('process_input_buffer',Babel.callback) + end + end +} +\def\BabelStringsDefault{unicode} +\let\luabbl@stop\relax +\AddBabelHook{luatex}{encodedcommands}{% + \def\bbl@tempa{utf8}\def\bbl@tempb{#1}% + \ifx\bbl@tempa\bbl@tempb\else + \directlua{Babel.begin_process_input()}% + \def\luabbl@stop{% + \directlua{Babel.end_process_input()}}% + \fi}% +\AddBabelHook{luatex}{stopcommands}{% + \luabbl@stop + \let\luabbl@stop\relax} +\AddBabelHook{luatex}{patterns}{% + \ifx\directlua\relax\else + \ifcsname lu@texhyphen@loaded@\the\language\endcsname \else + \global\@namedef{lu@texhyphen@loaded@\the\language}{}% + \directlua{ + luatexhyphen.loadlanguage('\luatexluaescapestring{\string#1}', + '\the\language')}% + \fi + \fi} +\AddBabelHook{luatex}{adddialect}{% + \ifx\directlua\relax\else + \directlua{ + luatexhyphen.adddialect('\luatexluaescapestring{\string#1}', + '\luatexluaescapestring{\string#2}') + }% + \fi} +\AddBabelHook{luatex}{everylanguage}{% + \directlua{ + processnow = (tex.language == 0) or + (luatexhyphen.lookupname('\luatexluaescapestring{\string#1}') == nil)}% + \ifnum0=\directlua{tex.sprint(processnow and "0" or "1")}\relax + \global\@namedef{lu@texhyphen@loaded@\the\language}{}% + \fi} +\AddBabelHook{luatex}{loadpatterns}{% + \ifnum0=\directlua{tex.sprint(processnow and "0" or "1")}\relax + \input #1\relax + \fi} +\AddBabelHook{luatex}{loadexceptions}{% + \ifnum0=\directlua{tex.sprint(processnow and "0" or "1")}\relax + \input #1\relax + \fi + \directlua{processnow = nil}} +%</luatex> +% \end{macrocode} +% +\endinput +%% +%% \CharacterTable +%% {Upper-case \A\B\C\D\E\F\G\H\I\J\K\L\M\N\O\P\Q\R\S\T\U\V\W\X\Y\Z +%% Lower-case \a\b\c\d\e\f\g\h\i\j\k\l\m\n\o\p\q\r\s\t\u\v\w\x\y\z +%% Digits \0\1\2\3\4\5\6\7\8\9 +%% Exclamation \! Double quote \" Hash (number) \# +%% Dollar \$ Percent \% Ampersand \& +%% Acute accent \' Left paren \( Right paren \) +%% Asterisk \* Plus \+ Comma \, +%% Minus \- Point \. Solidus \/ +%% Colon \: Semicolon \; Less than \< +%% Equals \= Greater than \> Question mark \? +%% Commercial at \@ Left bracket \[ Backslash \\ +%% Right bracket \] Circumflex \^ Underscore \_ +%% Grave accent \` Left brace \{ Vertical bar \| +%% Right brace \} Tilde \~} |