-*- Text -*-
This is the file .../MOOSE/info/Clibs.nfo, which contains info
about C libraries used while programming MOOSE.


File: CLibs.nfo	Node: Top	Up:(MOOSE.nfo)

* Menu:

* Intro::			An introduction to those C libraries.

Generic Libraries:
* Genericity::			How is genericity possible in C ?
* GError:(GError.nfo).		A Generic Error Handling Library.
* GSeq:(GSeq.nfo).		A library to implement sequences automatically.
				Sequences include stacks, queues, files,
				ring buffers, and the like.

Object Libraries:
* Objects::			What are objects and their semantics.
* Implementation::		How are objects implemented for this nth time.
* Classes:(O_Class.nfo).	Class objects.
* MThread:(O_Thread.nfo).	Objects for doing multithreading.
* IO:(O_IO.nfo).		Objects for input and output.
* Symbols:(O_Symbol.nfo).	Objects for maintaining symbol tables.
* Parsing:(O_Parse.nfo).	Objects for parsing a file.

Interface MOOSE C programs with the outside world:
* stdlib::			Interface with the C standard library.
* Unix::			Interface with Unix objects.
* DOS::				Simulating Unix objects under DOS.
* C-HLL::			Interface between C and the MOOSE HLL.
* C-OSL::			Interface between C and the MOOSE OSL.

File: Clibs.nfo, Node: Genericity, Next: Objects, Prev: Top, Up: Top

   Genericity is describing not a particular object, but a whole class of
similar objects, that you can particularize in any way, or manipulate as such.
Thus, when you code something, you musn't rewrite it each time you change a
detail, or write inefficient code.

   Of course, C is a too low level language to allow describing classes of
objects; with C, you tell the compiler exactly what to do in what order at
the byte level (the compiler may ``optimize'' but the transformations are done
essentially at a very low level and won't change much the program's structure).

   But, C provides a preprocessor (not powerful at all, but that's better than
the no-preprocessor offered by most other languages) that'll allow us a
(limited) genericity with some bulky syntax (of course, we could have used an
external preprocessor, but that's incompatible with the wante portability of
C).

   Why the C preprocessor is not powerful at all: it's not even recursive.
Macros can't call themselves recursively; they aren't expanded before the
preprocessor reads directives or their arguments. See m4 for a true
preprocessor.
