学习编程：Forth语言解析

需积分: 10 19 浏览量更新于2024-07-26 收藏 723KB PDF 举报

"ProgramForth是一本关于学习编程语言Forth的书籍，由Stephen Pelc撰写。本书涵盖了Forth的关键概念、交互性、开发、测试和调试，还涉及Forth的实现以及特定的MPEisms。" 在编程领域，Forth是一种简洁而高效的编程语言，特别适合嵌入式系统和低级别的硬件控制。"Programming Forth"这本书旨在帮助读者理解和掌握这种语言。作者在书中详细介绍了Forth的基础知识和关键概念，让读者能够快速上手并深入理解Forth的编程方式。 1. 关于本书： "Programming Forth"不仅适合初学者，也对有经验的程序员有价值，因为它提供了一个清晰的视角来看待编程过程。书中的内容受到了Peter Knaggs, Chris E. Bailey, Bill Stoddart, Bob Marchbanks, Hans Bezemer等人的影响和贡献，他们对Forth的深入理解和实践经验使得这本书更加丰富。 2. Forth为何重要： Forth以其简洁的语法和直接的机器码生成能力而著称，这使得它在实时系统和资源有限的环境中非常有用。书中的“Key concepts”部分将探讨Forth的核心特性，如堆栈操作和词（words）的概念，这些是Forth编程的基础。 3. 交互性、开发、测试和调试： Forth的交互性是其一大特点，允许程序员即时测试代码片段。书中的“Interactivity, Development, Testing and Debugging”章节将深入讲解如何利用这一特性进行高效编程。此外，作者还将讨论如何在Forth环境中编写和调试程序，这对于学习者来说是非常实用的。 4. 写作Forth程序： Forth程序通常需要配合特定的编辑器来编写。书中提到的“Editors”部分将指导读者选择和使用适合Forth编程的工具，以提高编程效率。 5. Forth的实现：每个Forth系统都有其特定的实现方式，这部分内容会介绍不同Forth系统的差异和特性，帮助读者理解如何在不同的平台上使用和移植Forth程序。 6. MPEisms： "MPEisms"可能是指作者所在公司MicroProcessor Engineering Limited的一些特定实践或扩展。这部分内容将揭示一些专有的或者与MPE相关的Forth实现细节和技巧。 7. 体系结构：最后，书中还涉及到“Architecture”，这部分可能会探讨Forth如何与不同的计算机架构相互作用，包括如何在各种微处理器上运行Forth代码。通过阅读"Programming Forth"，读者不仅可以学习到Forth语言本身，还能了解其背后的原理和实践，从而成为一个熟练的Forth程序员，能够在各种应用场景中发挥Forth的优势。

Introduction

Forth Implementation

As with all computer languages, Forth has evolved over time. This book assumes the

use of an ANS Forth which conforms to the ANS Forth standard published in 1994.

At the time of writing in 2005, the ANS Forth standard is the most widely used.

Modern Forth implementations usually generate optimised native code, and the good

ones produce code of the same quality as the good C compilers. For those CPUs in

the embedded world where code density is more important than performance,

threaded code (interpreted code) implementations are still used, often with limited

peephole optimisation.

The different implementation strategies are discussed in the Forth internals chapter.

MPEisms

Because this book was written at MPE using MPE’s VFX Forth for Windows for

testing the code, it inevitably suffers from the use of a few idioms which are specific

to MPE’s implementations. I have tried to avoid these and where appropriate they are

marked. For example,

MPEism: MPE implementations of Forth do not care about the case of characters in

Forth word names. CAT is the same as cat is the same as Cat. Embedded comments

may be as long as you wish without a space or speed penalty in the compiled code.

Architecture of Forth

The SENDIT VM looks remarkably similar to other stack machine CPUs derived

from a Forth architecture and designed to execute C efficiently.

Several implementations of dual stack architectures have been produced in silicon for

use in hard real-time embedded systems, for which the best definition comes from

Bernd Paysan - “Late answers are wrong answers”. On some occasions early answers

are also wrong answers.

Because dual-stack processors have very few registers, interrupt response is

excellent. A 10 MHz RTX2000 has an interrupt response of four cycles, 400ns, and

we have seen a video application with a 1 MHz (not a typo) interrupt rate. Because of

this, stack CPUs with apparently low clock rates are used in specialised application

areas.

Stacks and postfix notation

Forth contains two stacks, one for storing return addresses (what was I doing

last/where do I go back to?), and one for storing data. The first stack is called the return

stack, and the second is called the data or parameter stack. Where we just refer to “the

stack” we nearly always mean the data stack, as this is the one the programmer uses

most.

The return stack holds the return addresses of all the words that have been called, but

have not yet been left. The return stack is also used for storing temporary data that

would only get in the way if kept on the data stack. This sort of data includes loop

limits and indices, and data taken off the data stack to reduce the amount of stack

manipulation that would otherwise occur. There is a set of words used for transferring

data between the stacks.

The data stack is an efficient method of passing data between the words that make up a

Forth program. Any word that needs data takes it from the top of the stack, and puts

any results back on top of the stack. The word .S can be used to display the contents

of the stack without destroying them. It is a useful debugging tool. Nearly all modern

processors provide for the use of stacks, so stack operations are very fast.

CPU

Main Memory

including

Frame Stack

Data

Stack

Return

Stack

SENDIT VM and registers

PC = program counter

PSP = parameter stack pointer

RSP = return stack pointer

FP = frame pointer

FEP = frame end pointer

Figure 3: Sendit VM and registers

Architecture of Forth

By keeping parameters and temporary data on the data stack, the return stack is not

affected by the number of items passed into or returned from a function (word). This

means that the C equivalent of varargs is efficiently handled, and also that a function

can efficiently return more than one item without resorting to pointers and temporary

data structures. Consequently, words that return more than one item are common in

Forth.

Because stacks are used for data handling, the use of postfix, or Reverse Polish

Notation (RPN), is very suitable. In this form of writing arithmetic expressions,

operands (the data used) come before the operators (how you use the data), for

example:

The normal algebraic notation :-

at**2 + bt + c

is better expressed for computer evaluation as :-

(at + b)t + c

which is then expressed in Reverse Polish Notation (RPN) as :-

a t * b + t * c +

Notice that the use of brackets becomes unnecessary. This is because of the use of the

stack to hold intermediate results. Although the use of a stack is intimidating at first,

after a while it becomes natural, and eventually it is only noticeable on rare occasions.

Remembering that the word . is used to print what is on the top of the stack you can

try a few bits of arithmetic.

1 2 + .

4 5 * .

9 3 / .

1 2 + 3 * .

1 2 3 + * .

1 2 3 * + .

Nearly all Forth words remove their data from the top of the stack, and leave the result

behind. Words like + and * remove two items, and leave one behind. There is a Forth

word .S which prints out the contents of the stack without destroying the contents. Use

it whenever you want to see what is on the stack. So far, we have executed words by

typing their names at the keyboard.

Data types

Forths are often characterised by the size of an item on the data stack, which is

usually 32 bits or 16 bits. Several 64 and 8 bit Forths also exist, as well as 4, 20 and

24 bit systems. Forth is an untyped language, so there is nothing to stop you adding a

character to a number. No casts are necessary. The amount of memory needed to

store a stack item is called a cell.

Words that operate on stack items will just assume that the data is appropriate. Most

Forth compilers do not check the data types at all.

An integer occupies a single cell on the stack, as does an address. If you need larger

integers, use a double integer which occupies two cells on the data stack, most

significant half topmost.

A character is smaller than (or the same size as) an integer, and is zero extended to

fill a cell.

Architecture of Forth

Two different floating point implementations are described by the ANS standard. In

one, known as a separated float stack, floating point numbers are held on a separate

stack reserved for floating point numbers. Floating point operations that require

integer parameters take them from the data stack. The second form uses a combined

stack, in which floating point numbers share the data stack.

Words and Numbers

All text entered to Forth is treated either as a number (literal, e.g. 1234) or a word

(function). A unit of text is separated by spaces or line breaks. These units are either

interpreted or compiled. That’s all. Although this is a very simple process, it is a key

to the use of Forth.

Interpreting and compiling

Forth contains both an interpreter and a compiler. Interpreting means taking the text

fed in, converting it into a form the machine can execute, executing that form, and then

discarding the executable form.

Compiling means taking the input text, completely converting it into a machine

executable form, keeping the executable form, and discarding the text. This can

produce a program that runs very fast, but you cannot change anything without first

editing the source text, then compiling it (using a separate program called a compiler),

and then loading the executable code when you want to run it.

Any text fed to Forth, either from the keyboard or from mass storage, is executed or

compiled. Remember, all commands to Forth are pre-defined 'words' in its

'vocabularies', consequently Forth can look up the address of a given word for later

execution. Some words in Forth change the way the compiler section deals with text.

For instance we could define a word that squares the value given to it.

: squared( n1 -- n1^2 )

dup * ;

The address of the word : is found and : is executed; the action of : is to tell the

compiler section to start defining a new word whose name comes next, squared, and

then compile into the new word the actions of the words that follow. This would carry

on for ever unless we had a way of stopping it, and this is provided by 'immediate'

words such as ; which are always executed, regardless of what the compiler would

otherwise be doing.

The action of ; is to stop the compiler compiling word addresses, and return it to the

mode of executing the addresses instead. There are other words (defining words) which

are used to create words such as : - these are one of the keys to advanced use of Forth.

At all times remember, however, that the basis of Forth is always very simple. Forth is

a language built from a number of very simple ideas, rather than one founded on a few

complex systems.

Defining Words and Immediate words

Some words such as : in the previous section, are called defining words, because they

are used to define new words (squared in the previous section); these words are one

of the keys to the power of Forth. The word : creates a new word in the dictionary and

switches Forth from being an interpreter to being a compiler. Any word names met

from now on will not be executed, but will be found and compiled into the dictionary.

This process repeats until stopped, but it can only be stopped by the execution of

剩余191页未读，继续阅读

eephy

粉丝: 1
资源: 2

学习编程：Forth语言解析

江西财经大学在广东2021-2024各专业最低录取分数及位次表.pdf

仿真模拟电击穿路径的模型，可以自定义模型形状，利用有限元comsol相场法模拟，采用PDE模块自定义方程，通过求解偏微分方程来实

Java课程设计-学生成绩管理系统-Swing+MySQL.zip

中央财经大学在北京2021-2024各专业最低录取分数及位次表.pdf

APS课程设计后端部分.zip

吉林师范大学在广东2021-2024各专业最低录取分数及位次表.pdf

华南师范大学在广东2021-2024各专业最低录取分数及位次表.pdf

软件工程课程设计——图书借阅管理系统（springboot+mybatis+layui）.zip

字典，Fuzz，超级全面

中南民族大学在广东2021-2024各专业最低录取分数及位次表.pdf

最新资源