TEX编程笔记：从入门到精通

需积分: 3 178 浏览量更新于2024-07-05 收藏 367KB PDF 举报

"Notes On Programming in TEX" 这是一份关于在TEX中编程的笔记文档，适合对TEX编程感兴趣的初学者和有经验的TEX专家。虽然它不是一份完整的参考文献或手册，但提供了大量的实例，帮助读者入门并深入了解TEX编程的细节。 1 引言在开始TEX编程之前，这份文档提供了必要的背景知识和基础概念。它旨在帮助读者建立对TEX语言的基本理解，无论你是初次接触还是寻求深入理解。 2 在TEX中编程 2.1 变量与寄存器在TEX中，变量通常存储在寄存器中。寄存器是用于存储数据的特殊位置。 2.1.1 分配寄存器 TEX默认提供了256个寄存器，但可以通过特定命令来扩展这个限制，以便处理更多的数据。 2.1.2 使用超过256个寄存器当需要更多寄存器时，可以使用扩展技术，如定义新的控制序列来管理额外的存储空间。 2.2 TEX中的算术运算 TEX支持基本的算术运算，如加减乘除，可以在编程过程中进行数值计算。 2.3 扩展控制 2.3.1 宏宏是TEX编程的核心，它们允许创建可重用的代码块，简化和组织复杂的文档结构。 2.3.2 令牌寄存器令牌寄存器用于存储一系列的命令和字符，可用于控制文本处理和延迟执行。 2.3.3 宏定义命令概览文档列出了常见的宏定义命令，便于读者理解和应用。 2.3.4 调试工具了解并追踪TEX的执行过程是调试的关键，文档提到了一些帮助理解和调试TEX代码的工具。 2.4 变量的作用域 2.4.1 全局变量全局变量在整个文档中有效，不受局部组的限制。 2.4.2 将变化传播到外部组在局部组内的更改可以被设计为影响外部组，这是通过特定的命令实现的。 2.5 分支 2.5.1 布尔变量布尔变量用于条件判断，可以设置为真或假，决定代码执行路径。 2.5.2 条件语句的特殊情况文档还讨论了条件语句的一些特殊用法，以适应更复杂的逻辑控制。 2.6 循环 2.6.1 计数循环在TEX中可以实现计数循环，用于迭代特定次数的操作。 2.6.2 遍历列表的循环 TEX允许对列表进行循环操作，这在处理数据集合时非常有用。这份文档提供了TEX编程的全面概述，从基本的变量管理到复杂的控制结构，都是学习和提升TEX编程技能的重要参考资料。虽然它不是一个详尽无遗的指南，但其丰富的示例和解释足以让读者逐步掌握TEX编程的精髓。

\multiplyhregisteri byhintegeri

The value is now -420.

\count0=42

\multiply\count0 by -10

The value is now \the\count0.

The value is now 10.0pt.

\dimen0=0.5pt

\multiply\dimen0 by 20

The value is now \the\dimen0.

\dividehregisteri byhintegeri

This allows integer division by hintegeri with truncation.

The value is now 2.

\count0=5

\divide\count0 by 2

The value is now \the\count0.

Scaling of \dimen registers:

The value is now 0.5pt.

\dimen0=10pt

\divide\dimen0 by 20

The value is now \the\dimen0.

It is impossible to divide by some non–integer number.

\dimenhnumberi=hﬁxed point number without uniti\dimenhnumberi

This allows ﬁxed point multiplication in \dimen registers.

The value is now 30.0003pt.

\dimen1=50pt

\dimen0=0.6\dimen1

The value is now \the\dimen0.

This is actually all that T

X allows. One needs powerful macro packages like pgf with its

\pgfmathparse{hexpressioni} to do some “real” arithmetics.

Note that the limited number range of these registers also applies to the result of any numerical operation.

2.3 Expansion Control

Expansion is what T

X does all the time. Thus, expansion control is a key concept for understanding how

to program in T

The ﬁrst thing to know is: T

X deals the input as a long, long sequence of “tokens”. A token is the

smallest unit which is understood by T

X. Each character becomes a token the ﬁrst time it is seen by T

Every macro becomes a (single!) token the ﬁrst time it is seen by T

The second thing to know is what characters are before T

X has seen them. Although this knowledge

is rarely needed in every day’s life, it is nevertheless important. The characters which are in the input

document are nothing but characters at ﬁrst. Even the characters known to have a special meaning like ‘%’,

‘\’ or the braces ‘{}’ are not special – until they have been converted to a token. This happens when T

encounters them the ﬁrst time during its linear processing of the character stream. A token stays a token -

and it will remain the same token forever. If you manage to tell T

X that ‘\’ is a normal character and T

sees just one backslash, this backslash will be a normal character token – even if the meaning of all following

backslashes is again special.

Now, we are given a very long list of tokens htoken1ihtoken2 ihtoken3 ihtoken4 ihtoken5i· · · . T

X processes

these tokens one-by-one in linear sequence. If htoken1 i is a character token like ‘a’, it is typeset. This is not

what I want to write about here now; my main point is how to program in T

. So, the interesting thing

in these notes is when htoken1 i is a macro.

Of course, typesetting is an art in itself and there is a lot to read about it. Just not here in these notes.

2.3.1 Macros

We have already seen some applications of macros above. Actually, most users who are willing to read notes

about T

X programming will have seen macros and may have written some on their own – for example using

\newcommand (\newcommand is a “more high–level” version of \def used only in L

X).

A macro has a name and is treated as an elementary token in T

X (even if the name is very long).

A macro has replacement text. As soon as T

X encounters a macro, it replaces its occurrence with the

replacement text. Furthermore, a macro can consume one or more of the following tokens as arguments.

Executing it: ‘This here is actually the replacement text.’.

\def\macro{This here is actually the replacement text.}

Executing it: ‘\macro’.

Invoking it: replacement with ﬁrst argument=hello!.

\def\macro#1{replacement with first argument=#1}

Invoking it: \macro{hello!}.

This here is not really a surprise. What might come as a surprise is that the accepted arguments can be

pretty much anything.

Invoking it: replacement with arguments: ‘a’ and ‘sign’.

\def\macro#1-#2.{replacement with arguments: ‘#1’ and ‘#2’.}

Invoking it: \macro a-sign.

The last example \macro runs through the token list which follows the occurrence of \macro. This token list

is “a-sign.”. Macro expansion is greedy, that means the ﬁrst matching pattern is used. Now, our \macro

expected something, then a minus sign ‘-’, then another (possibly long) argument, then a period ‘.’. The

argument between \macro and the minus sign is available as #1 and the tokens between the minus sign and

the period as #2.

I found arguments ‘42’, ‘43’ and ‘44’.

\def\macro(#1,#2,#3){I found arguments ‘#1’, ‘#2’ and ‘#3’.}

\macro(42,43,44)

As we have seen, macros can be used to manipulate the input tokens by expansion: they take some input

arguments (maybe none) away and insert other tokens into the input token list. These tokens will be the

next to process. We will soon learn more about that.

There is a command which helps to understand what T

X does here:

\meaninghmacroi

This command expands to the contents of hmacroi as it is seen by T

\def\macro{Replacement \textmacro text \count0=42 \the\count0.}

\message{Debug message: ’\meaning\macro’}

As result, the log ﬁle and terminal output will contain

Debug message: ’macro:->Replacement \textmacro text \count 0=42 \the \count 0.’

The last example already shows something about \def: the replacement text can still contain other

macros.

\defh\macronameihargument patterni{hreplacement texti}

A new macro named hmacronamei will be deﬁned (or re-deﬁned). The {hreplacement texti} is the macro

body, whenever the macro is executed, it expands to {hreplacement texti}. The {hreplacement texti}

is a token list which can contain other macros. On the time of the deﬁnition, T

X does not process

(expand) the {hreplacement texti}.

The {hreplacement texti} will only be expanded if the macro is executed. This does also apply to any

macros which are inside of {hreplacement texti}.

Now, I execute it: Macro two contains This is macro one..

Now, I execute the second macro again: Macro two contains Redeﬁned macroone..

剩余25页未读，继续阅读

49407423

粉丝: 0
资源: 3

TEX编程笔记：从入门到精通

Notes on Programming of C++,by Alexander Stepanov

Notes on Functional Programming with Haskell

Steve also has some nice notes on echo cancellers in echo.h

pitchnames = sorted(set(item for item in notes))的意思

最新资源