htmlc-1.0/doc_src/Includes/findepage-fra.html 000644 057275 000037 00000000076 07547123274 021225 0 ustar 00weis caml 000000 335606
htmlc-1.0/doc_src/Includes/hautdepage-fra.html 000644 057275 000037 00000000145 07547123274 021410 0 ustar 00weis caml 000000 335607 Contacter l'auteur Pierre.Weis@inria.fr
htmlc-1.0/doc_src/Includes/maquette-eng.html 000644 057275 000037 00000000215 07547123274 021114 0 ustar 00weis caml 000000 343410
htmlc-1.0/doc_src/Includes/maquette-fra.html 000644 057275 000037 00000000214 07547123274 021113 0 ustar 00weis caml 000000 343411
htmlc-1.0/doc_src/Includes/topofpage-eng.html 000644 057275 000037 00000000145 07547123274 021257 0 ustar 00weis caml 000000 343412 Contact the author Pierre.Weis@inria.fr
htmlc-1.0/doc_src/htmlc-eng.html 000644 057275 000037 00000042252 07547123273 016720 0 ustar 00weis caml 000000 2651030
Htmlc
File created the 10 of April 2000.
Htmlc : an HTML files generator
What is it ?
htmlc
is used to produce regular HTML pages from
source files that contain text fragments that require some computation
to be written. Those text fragments can be for instance the last
modification date of a page, or parts of HTML pages that must be
systematically included in all the pages of an entire WEB site (for
example a header or footer section for each page). Providing automatic
inclusion of those text fragments into your HTML source pages,
htmlc
offers a server independant way of defining
templates to factorize the repetitive parts of HTML pages.
I How does it work ?
To generate HTML pages with htmlc
, you simply write
directives into your source pages; those directives are HTML
comments that htmlc
is able to find, interpret and
execute to include the results of execution into the output file.
Directives for htmlc
have the same syntax as
directives for Apache servers (when corresponding directives exist for
Apache). htmlc
is thus a kind of compiler for HTML pages
served by the HTTP server, since htmlc
expands the server
side macros written in the HTML source files. This way, the Apache
server needs no more to parse files looking for directives: this has
been done once and for all by htmlc
. Furthermore, errors
are detected during the expansion phase, not when pages are served
(which is too late, since the erroneous page has already been served
to the client anyway).
As an additional benefit, your source files are no more related to
a specific HTTP server: htmlc
directives need not to be
rewritten when you change your HTTP server.
Not only your source files, but also the pages produced by
htmlc
are independant from any HTTP server. This is a
desirable property that is mandatory if you want to browse your WEB
site locally, even if no connection to the network is available. For
instance, using htmlc
, you obtain a WEB site that is
directly usable on a CD-ROM: the pages expanded by htmlc
are readable with any WEB browser, even if there is no HTTP server
running on the user's computer.
II How can one use it ?
- When writing HTML pages
-
- Texts inclusion: where you want to include
some text, write a directive to include the file containing that text.
Such a directive is a single line with the name of the file to be included:
<!--#include virtual="name of the file to be included"-->
where ``name of the file to be included
'' is the name of the
file that contains the text.
Examples: systematic inclusion of the
document type, or the page foot.
Search for files to be included: files are searched
into a directory list, starting from the current directory. This list
is modified using command line options for htmlc
,
-I directory_name
that adds
directory_name
in front of the directory list.
- Including text with no modification
(programs for instance): HTML special characters are
correctly escaped, such that the original ASCII text is readable
into the HTML result (for instance
<
is expanded as
<
).
To include such a verbatim text, write
<!--#include verbatim="name of the file to be included"-->
where ``name of the file to be included
'' is the name of the
file that contains the text.
Examples: including programs.
Search for verbatim files: those files are searched
in the same directory list (search path) as other files to include.
- Last modification date of the source file: write
<!--#echo var="LAST_MODIFIED"-->
and this comment is replaced by the date of the last modification of
this source file.
Internationalization: htmlc
tries to figure out the language of the source file, in order to
include the dates in the corresponding language. The language is
obtained from the name of the source file. The rules are the following:
- the name of the file is pattern matched against the pattern:
filename-lang.extension
(or
filename.lang.extension
), where
filename
is a sequel of letters (the name
of the file),
- followed by the character
-
or
.
,
- followed by a language marker
lang
, having
2 or 3 letters,
- followed by a
.
character,
- followed by a file
extension
(generally
the 4 characters html
).
Then the language is the lang
part of the file name,
interpreted as Internet conventions for country names. If this
interpretation fails, the language is supposed to be English.
- If the field
lang
is absent, and the
extension is found, then filename
is supposed to be the
language indication.
- If the language cannot be found, it defaults to English.
- In this version of
htmlc
, supported languages
are restricted to French and English. You're welcome to help me to add
any additional language you want to.
- Examples:
htmlc-eng.html
has eng
as language indication; this is interpreted as en
, hence
the document is supposed to be written in English.
Similarly, htmlc.eng.html
, eng.html
,
en.html
, or en.ml
are all supposed to be
written in English.
- During generation of final HTML pages
-
The HTML page generator is a command that treats files whose names
are given on the command line. By default, result is written on the
standard output; an output file can be specified using the option
-t
(or -to
) followed by the file name of the
output file.
Input file can be specified using the option -f
(or
-from
) followed by the input file name.
Usage: htmlc [-I] [include-dir] <source> <destination>
or htmlc <source>
or htmlc [-i|-f|-from] <source> [-o|-t|-to] <destination>
III How to use htmlc
to handle a bundle of
HTML files ?
First of all, we have to distinguish between sources of
HTML files, and objects: sources are unexpanded files (those
that we must edit), and objects are expanded files (those that we do
not edit and that are automatically produced by htmlc
).
We use the following conventions:
- a source file has suffix
.html
,
- an object file has suffix
.htm
.
A very good idea to manage the complexity of dealing with a lot of
HTML files to expand is to carefully separate source and object files:
object files belong to a directory that is accessible to the HTTP
server (sometimes also called the WEB server), and we name it
the WEB
directory, since the files it contains are those
sent to the net by the WEB server; on the other hand, source files
belong to a directory that is only used by the WEB site
editors, let's name it the SRC
directory.
To handle all those files, the method we propose is to set up two
Makefiles:
- the file
SRC/Makefile
manage the expansion of source
files to corresponding objects files.
- the file
WEB/Makefile
handle the copy of the
expanded object files from the SRC
directory to the
WEB
directory.
Note that the WEB
directory only contains the minimum
set of files necessary to consult the WEB site. By contrast, the
SRC
directory has both source and objects files. Also,
the SRC
directory has a sub-directory for the files to
include; we suppose that this sub-directory is named
Includes
; hence the expansion command will systematically
have an additional option -I Includes
.
- Here is an example for the Makefile in the
SRC
directory
FILES=htmlc-fra.html htmlc-eng.html
HTMLC=htmlc -I Includes
OBJS=$(FILES:.html=.htm)
all: $(OBJS)
clean:
/bin/rm -f $(OBJS)
.SUFFIXES:
.SUFFIXES: .htm .html
.html.htm:
$(HTMLC) -f $< -t $@
To use this Makefile, you just have to fill in the
FILES
variable to specify the list of source files you need
(the list written here corresponds to the htmlc
documentation). If necessary, you can also specify the include
directory by modifying the -I Includes
option of the
HTMLC
variable.
- Here is an example for the Makefile in the
WEB
directory
SRC=../doc_src
FILES=htmlc-fra.htm htmlc-eng.htm
AUTO=.Makefile.auto
all: $(AUTO) expand $(FILES)
expand:
cd $(SRC); make
clean: $(AUTO)
cd $(SRC); make clean
/bin/rm -f $(FILES)
.Makefile.auto : auto
auto:
/bin/rm -f $(AUTO)
for i in $(FILES); do \
j=`basename $$i .htm`; \
echo $$i: $(SRC)/$$j.htm >> $(AUTO); \
echo " cp -p $(SRC)/$$j.htm $$j.htm" >> $(AUTO); \
done
include $(AUTO)
To use it, you just have to fill in the SRC
and
FILES
variables to respectively specify the source
directory and the list of source files you use. The method to build
the site is to copy the object files from the $(SRC)
directory. To achieve this goal the Makefile builds the set of copy
rules corresponding to the set of files to create. Those rules are
then automatically included into the Makefile by the last line
(include $(AUTO)
). So you need to initiate this process
when installing the Makefile somewhere: you have first to create an
empty set of rules, in order to be able to then run make to create the
relevant rules; at first usage of the Makefile, type in:
touch .Makefile.auto
make auto
that creates the empty set of rule .Makefile.auto
, and
then allows the computation of the relevant set of rules (make
auto
).
Discussion
This organization into two separate directories has many
advantages: the WEB site is clean, having a minimum set of files, and
all the necessary auxiliary files are kept in the SRC
directory; moreover changes to the source files are not immediately
effective and visible from outside: source pages can be modified then
expanded and verified before commitment to the online WEB site. And
this commitment is easy: a simple make
command in the
WEB
directory publishes all the modifications at once in
a coherent way.
This setting has proved to be extremely efficient to write and
develop the set of HTML pages that is the Caml language FAQ.
IV Examples
- Including a header
- To include the document type, you may just write as
first line of your file:
<!--#include virtual="doctype" -->
This directive includes the text of the file named doctype
.
If the file doctype
contains:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
"http://www.w3.org/TR/REC-html40/loose.dtd">
then the file
<!--#include virtual="doctype" -->
<HTML>
<HEAD>
<TITLE>Frequently asked questions about Caml</TITLE>
</HEAD>
becomes
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
"http://www.w3.org/TR/REC-html40/loose.dtd">
<HTML>
<HEAD>
<TITLE>Frequently asked questions about Caml</TITLE>
</HEAD>
- Including a footer
- If we suppose the footer to be written in the file
endofpage-eng.html
, then just write:
<!--#include virtual="endofpage-eng.html"-->
to include the footer in your HTML page.
Then, if the file endofpage-eng.html
contains:
<P>
<HR>
<EM>Last modified: </EM>
<!--#echo var="LAST_MODIFIED" -->
<BR>
<A HREF="copyright-eng.html">Copyright</A>
© 1997 - 2000 INRIA, all rights reserved.
the source file
<!--#include virtual="endofpage-eng.html"-->
</BODY>
</HTML>
is then compiled by htmlc
into:
<P>
<HR>
<EM>Last modified: </EM>
<!--#echo var="LAST_MODIFIED" -->
Tuesday February 15 2000
<BR>
<A HREF="copyright-eng.html">Copyright</A>
© 1997 - 2000 INRIA, all rights reserved.
</BODY>
</HTML>
- Including a program
- To include the program text contained into the file
exemple_caml.ml
, just write:
<!--#include verbatim="exemple_caml.ml"-->
Then, if exemple_caml.ml
contains:
let succ x = x + 1;;
succ : int -> int = <fun>
the directive is replaced by:
let succ x = x + 1;;
succ : int -> int = <fun>
- HTML page templates
- To facilitate the edition of the HTML pages of a WEB site, you
can define a set of templates with include directives.
For instance, the following template defines the standard
document type, footer and header:
<!--#include virtual="beforetitle-eng.html"-->
<!--#include virtual="aftertitle-eng.html"-->
<!--#include virtual="endofpage-eng.html"-->
The page writer just writes the page title to obtain the following
correct HTML file:
<!--#include virtual="beforetitle-eng.html"-->
The <CODE>htmlc</CODE> expander
<!--#include virtual="aftertitle-eng.html"-->
<H2 ALIGN=LEFT>What is it ?</H2>
<P>One uses ...
<!--#include virtual="endofpage-eng.html"-->
Since, if we suppose that:
- the file
beforetitle-eng.html
contains:
<!--#include virtual="doctype" -->
<!-- File beforetitle-eng.html included before the page's title -->
<HTML>
<HEAD>
<TITLE>
- the file
aftertitle-eng.html
contains:
<!-- File aftertitle-eng.html included after the page's title -->
</TITLE>
</HEAD>
<BODY BGCOLOR="#FFFFFF">
<!--#include virtual="hautdepage-eng.html"-->
- the file
endofpage-eng.html
contains:
<!-- File endofpage-eng.html included at the last line of the page -->
<P>
<HR>
<EM>Last modification: </EM>
<!--#echo var="LAST_MODIFIED" -->
</BODY>
</HTML>
- the file
hautdepage-eng.html
contains:
<ADDRESS>Contact the author <A HREF="mailto:Pierre.Weis@inria.fr">Pierre.Weis@inria.fr</A></ADDRESS>
- and files
doctype
and
endofpage-eng.html
are as described above
Then from the file:
<!--#include virtual="beforetitle-eng.html"-->
The <CODE>htmlc</CODE> expander
<!--#include virtual="aftertitle-eng.html"-->
<H2 ALIGN=LEFT>What is it ?</H2>
<P>One uses ...
<!--#include virtual="endofpage-eng.html"-->
we get:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
"http://www.w3.org/TR/REC-html40/loose.dtd">
<!-- File beforetitle-eng.html included before the page's title -->
<HTML>
<HEAD>
<TITLE>
The <CODE>htmlc</CODE> expander
<!-- File aftertitle-eng.html included after the page's title -->
</TITLE>
</HEAD>
<BODY BGCOLOR="#FFFFFF">
<ADDRESS>Contact the author <A HREF="mailto:Pierre.Weis@inria.fr">Pierre.Weis@inria.fr</A></ADDRESS>
<H2 ALIGN=LEFT>What is it ?</H2>
<P>One uses ...
<!-- File endofpage-eng.html included at the last line of the page -->
<P>
<HR>
<EM>Last modification: </EM>
<!--#echo var="LAST_MODIFIED" -->
mardi 15 février 2000
<BR>
<A HREF="copyright-eng.html">Copyright</A>
© 1997 - 2000 INRIA, all rights reserved.
</BODY>
</HTML>
htmlc-1.0/doc_src/htmlc-fra.html 000644 057275 000037 00000044321 07547123273 016722 0 ustar 00weis caml 000000 2654400
Htmlc
Fichier créé le 20 février 2000.
Htmlc
: un générateur de fichiers HTML
De quoi s'agit-il ?
On utilise htmlc
pour produire des pages HTML dont
certaines parties doivent être calculées à la demande (par exemple la
date de dernière modification de la page) ou bien incluses
systématiquement dans toutes les pages d'un site (par exemple une
entête ou un pied de page). À partir d'un fichier source annoté,
htmlc
produit un fichier HTML parfaitement normal qui
intègre les parties calculées du fichier source. htmlc
vous offre ainsi le moyen de gérer un site WEB en définissant un
ensemble de modèles de pages qui factorise une bonne fois pour toutes
l'écriture des parties répétitives des pages HTML.
I Principe
Pour diriger la génération des pages HTML on utilise des
directives pour htmlc
; ces directives sont des
commentaires HTML présents dans le fichier source HTML, et
htmlc
les exécute et écrit leur résultat dans le fichier
de sortie.
Les directives pour htmlc
ont la syntaxe des
directives des serveurs Apache (lorsque les directives Apache
correspondantes existent). htmlc
est donc une sorte de
compilateur des pages HTML servies par le serveur, puisque les macros
sont complètement expansées dans les fichiers produits par
htmlc
. L'intérêt de cette pratique est évidemment que le
serveur Apache n'a plus à faire dynamiquement l'analyse des fichiers
qu'il sert à la recherche des directives: le travail est réalisé statiquement
lors de la génération de la page. Avantage supplémentaire: on détecte
les erreurs très tôt, pendant la phase d'expansion des directives, au
lieu de découvrir ces erreurs lors du service des pages (ce qui est de
toutes façons trop tard puisque la page erronée est déjà parvenue au
client).
De plus, vos pages sources ne sont plus dépendantes d'un serveur
HTTP: les directive htmlc
n'ont pas à être réécrites si
vous changez votre serveur ou sa configuration.
Bien plus, les pages produites par htmlc
aussi
complètement indépendantes d'un serveur HTTP. C'est une propriété
souhaitable, mais surtout indispenable dès qu'il s'agit de de produire
un site WEB consultable localement, en dehors de tout accès réseau.
Par exemple, un site dont les pages sont expansées par
htmlc
est directement utilisable sur CD-ROM, ses pages
sont lisibles par tout navigateur, sans nécessiter l'installation d'un
serveur HTTP sur l'ordinateur de l'utilisateur.
II Comment s'en servir ?
- Lors de l'écriture des pages HTML
-
- Inclusion de textes: à l'endroit où l'on veut
inclure le texte, on écrit une directive d'inclusion du fichier
contenant ce texte. Cette directive consiste en une seule ligne
contenant le nom du fichier à inclure:
<!--#include virtual="nom du fichier à inclure"-->
où «nom du fichier à inclure
» est le nom du fichier
contenant le texte à inclure.
Exemples: inclusion systématique
du type du document, ou du pied
de page.
Recherche des fichiers à inclure: les fichiers à inclure
sont recherchés dans une liste de répertoires commençant par le
répertoire courant. On modifie cette liste en appelant le générateur
avec une ou des options -I nom_de_répertoire
qui ajoute
nom_de_répertoire
à la liste des répertoires où chercher
les fichiers à inclure.
- Inclusion de textes sans modifications
(programmes): les caractères spéciaux de HTML sont
automatiquement échappés (par exemple
<
devient
<
dans le texte inclus, et sera de la sorte
correctement compris par le navigateur).
À l'endroit où l'on veut inclure le texte, on écrit
<!--#include verbatim="nom du fichier à inclure"-->
où «nom du fichier à inclure
» est le nom du fichier
contenant le texte à inclure.
Exemples: inclusion de programmes.
Recherche des fichiers verbatims à inclure: les
fichiers à inclure sont aussi recherchés dans la liste des répertoires
d'inclusion.
- Inclusion de la date de modification du
fichier: on écrit
<!--#echo var="LAST_MODIFIED"-->
et cette remarque est remplacée dans le fichier par la date en clair
de la dernière modification du fichier.
Internationalisation: htmlc
tente de déterminer le langage utilisé par le fichier source afin
d'inclure la date dans la langue du fichier source (et non pas
systématiquement en anglais). La langue est déterminée d'après le nom
du fichier traité. Les règles utilisées sont les suivantes:
- le nom du fichier est mis sous la forme
nompropre-lang.extension
(ou bien
nompropre.lang.extension
), où
nompropre
est une suite de lettres (le nom
particulier au fichier),
- suivi d'un caractère
-
ou d'un caractère
.
,
- suivi d'une indication de langue
lang
de deux ou
trois lettres,
- suivie d'un caractère
.
,
- suivi d'une
extension
(en général
html
).
Alors la langue est la partie lang
du nom du
fichier, qui est interprétée comme le fait Internet pour les noms de
pays. Si cette interprétation échoue, la langue du fichier
est supposée être l'anglais.
- Si le champ
lang
n'existe pas, mais que
l'extension existe, on tente d'interpréter le nompropre
comme l'indication de langue.
- Par défaut la langue du fichier est supposée être l'anglais.
- Dans cette version de
htmlc
les langues
reconnues sont uniquement le français et l'anglais.
- Exemples:
htmlc-fra.html
a pour indication de langue
fra
, comprise comme fr
, c'est donc supposé
être un document écrit en français. De même pour
htmlc.fra.html
ou fra.html
ou
fr.html
ou même fr.ml
.
- Lors de la génération des pages HTML définitives
-
Le générateur de pages HTML est une commande qui traite les noms de
fichiers donnés en argument sur sa ligne de commande, expansant les
directives qu'ils contiennent. Par défaut le résultat est écrit sur la
sortie standard. On précise le fichier de sortie à l'aide de l'option
-t
(ou -to
) suivie du nom du fichier de sortie.
On précise le fichier d'entrée à l'aide de l'option -f
(ou
-from
) suivie du nom du fichier d'entrée.
Usage: htmlc [-I] [include-dir] <source> <destination>
or htmlc <source>
or htmlc [-i|-f|-from] <source> [-o|-t|-to] <destination>
III Comment utiliser htmlc
pour gérer un grand
nombre de fichiers ?
La méthode la plus simple est de bien distinguer entre les
sources des fichiers HTML et les objets: les sources
sont les fichiers non expansés (ceux qu'on édite), et les objets sont
les fichiers expansés (ceux qu'on n'édite pas et qui sont produits
automatiquement par htmlc
).
On adopte les conventions suivantes:
- un fichier source porte le suffix
.html
,
- un fichier objet porte le suffix
.htm
.
Les fichiers objets seront placés dans un répertoire accessible au
serveur HTTP (quelquefois appelé aussi serveur WEB),
nommons-le répertoire WEB
, puisque ce sont précisément
ces fichiers que le serveur HTTP enverra sur le réseau. En revanche
les fichiers sources seront placés dans un répertoire gérés
par les éditeurs du site, nommons-le répertoire SRC
, qui
sera sans doute inaccessible au serveur WEB.
La méthode préconisée consiste à utiliser deux Makefiles pour
gérer le site:
- le fichier
SRC/Makefile
gère l'expansion de
l'ensemble des fichiers sources en les fichiers objets correspondants.
- le fichier
WEB/Makefile
recopie les fichiers
expansés du répertoire SRC
dans le répertoire WEB
.
On remarque donc que le répertoire WEB
ne comporte que
les fichiers strictement nécessaires à la consultation des pages HTML,
tandis que le répertoire SRC
comporte à la fois les
sources de ces pages et leurs objets. Le répertoire SRC
comporte aussi un sous-répertoire pour les fichiers à inclure; on
supposera dans la suite que ce répertoire s'appelle Includes
,
et la commande d'expansion des fichiers sources comportera donc
systématiquement l'option -I Includes
.
- Voici un exemple de fichier Make pour le répertoire
SRC
FILES=htmlc-fra.html htmlc-eng.html
HTMLC=htmlc -I Includes
OBJS=$(FILES:.html=.htm)
all: $(OBJS)
clean:
/bin/rm -f $(OBJS)
.SUFFIXES:
.SUFFIXES: .htm .html
.html.htm:
$(HTMLC) -f $< -t $@
Pour utiliser ce fichier, il suffit de modifier la variable
FILES
pour y mettre la liste des fichiers source (la
liste donnée ici correspond à la propre documentation de Htmlc
).
- Voici un exemple de fichier Make pour le répertoire
WEB
SRC=../doc_src
FILES=htmlc-fra.htm htmlc-eng.htm
AUTO=.Makefile.auto
all: $(AUTO) expand $(FILES)
expand:
cd $(SRC); make
clean: $(AUTO)
cd $(SRC); make clean
/bin/rm -f $(FILES)
.Makefile.auto : auto
auto:
/bin/rm -f $(AUTO)
for i in $(FILES); do \
j=`basename $$i .htm`; \
echo $$i: $(SRC)/$$j.htm >> $(AUTO); \
echo " cp -p $(SRC)/$$j.htm $$j.htm" >> $(AUTO); \
done
include $(AUTO)
Pour utiliser ce fichier, il suffit de modifier les variables
SRC
et FILES
pour y mettre respectivement
l'adresse du répertoire des sources et la liste des fichiers objets
désirés. La méthode de construction consiste à copier les fichiers du
répertoire $(SRC)
dans le répertoire des objets. Pour
cela le Makefile fabrique l'ensemble des règles de copie correspondant
aux fichiers à créer. Ces règles sont alors incluses automatiquement
par la dernière ligne du fichier. Cela explique pourquoi, il faut
initialiser le processus lors de l'installation de ce Makefile, en
tapant
touch .Makefile.auto
make auto
ce qui crée le fichier de règles vide .Makefile.auto
, ce
qui permet ensuite de lancer le Makefile pour créer les règles
nécessaires (make auto
).
Discussion
Cette organisation en deux répertoires séparés présente de nombreux
avantages: le site proprement dit ne comporte que les fichiers
strictement nécessaires, les fichiers auxiliaires ne se trouvant que
dans le répertoire SRC
; en outre les modifications
apportées au site ne sont pas immédiatement effectives et visibles de
l'ensemble des lecteurs du site Web: on peut modifier les pages
sources et même les expanser et les examiner à loisir sans troubler
les utilisateurs du site; après toutes les vérifications utiles, une
simple commande make
exécutée dans le répertoire
WEB
publie ces modifications en les rendant accessibles
au server WEB.
Cette organisation s'est révélée extrêmement efficace
pour l'écriture et le développement de l'ensemble des pages HTML de la
FAQ du langage Caml.
IV Exemples
- Inclusion d'entêtes
- Pour inclure systématiquement le type du document, on écrira en
première ligne de chaque fichier:
<!--#include virtual="doctype" -->
ce qui ordonne l'inclusion du texte du fichier doctype
dans le fichier.
Si le fichier doctype
contient:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
"http://www.w3.org/TR/REC-html40/loose.dtd">
alors le fichier
<!--#include virtual="doctype" -->
<HTML>
<HEAD>
<TITLE>Foire aux questions au sujet de Caml</TITLE>
</HEAD>
devient
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
"http://www.w3.org/TR/REC-html40/loose.dtd">
<HTML>
<HEAD>
<TITLE>Foire aux questions au sujet de Caml</TITLE>
</HEAD>
- Inclusion d'un pied de page
- Pour inclure dans une page HTML, un pied de page défini une fois
pour toutes dans le fichier
basdepage-fra.html
, il suffit
d'écrire, la ligne:
<!--#include virtual="basdepage-fra.html"-->
Alors, si le fichier basdepage-fra.html
contient:
<P>
<HR>
<EM>Dernière modification: </EM>
<!--#echo var="LAST_MODIFIED" -->
<BR>
<A HREF="copyright-fra.html">Copyright</A>
© 1997 - 2000 INRIA, tous droits réservés.
le fichier source
<!--#include virtual="basdepage-fra.html"-->
</BODY>
</HTML>
est transformé par htmlc
en:
<P>
<HR>
<EM>Dernière modification: </EM>
<!--#echo var="LAST_MODIFIED" -->
mardi 15 février 2000
<BR>
<A HREF="copyright-fra.html">Copyright</A>
© 1997 - 2000 INRIA, tous droits réservés.
</BODY>
</HTML>
- Inclusion d'un programe
- Pour inclure dans votre texte le programme Caml contenu dans le
fichier
exemple_caml.ml
, il suffit
d'écrire, la ligne:
<!--#include verbatim="exemple_caml.ml"-->
Alors, si le fichier exemple_caml.ml
contient:
let succ x = x + 1;;
succ : int -> int = <fun>
la ligne d'inclusion sera remplacé par:
let succ x = x + 1;;
succ : int -> int = <fun>
- Maquettes de pages HTML
- Pour alléger l'écriture des pages d'un site WEB, on peut très
bien définir un ensemble de maquettes comportant des inclusions
prédéfinies.
Par exemple, le fichier maquette de trois lignes suivant, permet
d'abstraire le type du document, son entête et son pied de page:
<!--#include virtual="avanttitre-fra.html"-->
<!--#include virtual="aprestitre-fra.html"-->
<!--#include virtual="findepage-fra.html"-->
Le créateur des pages html n'a plus qu'à mettre le titre de la page
entre les deux lignes d'inclusion pour obtenir un fichier HTML complet:
<!--#include virtual="avanttitre-fra.html"-->
L'expanseur <CODE>htmlc</CODE>
<!--#include virtual="aprestitre-fra.html"-->
<H2 ALIGN=LEFT>De quoi s'agit-il ?</H2>
<P>On utilise ...
<!--#include virtual="findepage-fra.html"-->
En effet, si l'on suppose que
- le fichier
avanttitre-fra.html
contient:
<!--#include virtual="doctype" -->
<!-- Fichier avanttitre-fra.html inclus avant le titre de la page -->
<HTML>
<HEAD>
<TITLE>
- le fichier
aprestitre-fra.html
contient:
<!-- Fichier aprestitre-fra.html inclus après le titre de la page -->
</TITLE>
</HEAD>
<BODY BGCOLOR="#FFFFFF">
<!--#include virtual="hautdepage-fra.html"-->
- le fichier
findepage-fra.html
contient:
<!-- Fichier findepage-fra.html inclus à la dernière ligne de la page -->
<P>
<HR>
<EM>Dernière modification: </EM>
<!--#echo var="LAST_MODIFIED" -->
</BODY>
</HTML>
- le fichier
hautdepage-fra.html
contient:
<ADDRESS>Contacter l'auteur <A HREF="mailto:Pierre.Weis@inria.fr">Pierre.Weis@inria.fr</A></ADDRESS>
- tandis que les fichiers
doctype
et
findepage-fra.html
ont le même contenu que ci-dessus
Alors le fichier:
<!--#include virtual="avanttitre-fra.html"-->
L'expanseur <CODE>htmlc</CODE>
<!--#include virtual="aprestitre-fra.html"-->
<H2 ALIGN=LEFT>De quoi s'agit-il ?</H2>
<P>On utilise ...
<!--#include virtual="findepage-fra.html"-->
est expansé par htmlc
en le fichier:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
"http://www.w3.org/TR/REC-html40/loose.dtd">
<!-- Fichier avanttitre-fra.html inclus avant le titre de la page -->
<HTML>
<HEAD>
<TITLE>
L'expanseur <CODE>htmlc</CODE>
<!-- Fichier aprestitre-fra.html inclus après le titre de la page -->
</TITLE>
</HEAD>
<BODY BGCOLOR="#FFFFFF">
<ADDRESS>Contacter l'auteur <A HREF="mailto:Pierre.Weis@inria.fr">Pierre.Weis@inria.fr</A></ADDRESS>
<H2 ALIGN=LEFT>De quoi s'agit-il ?</H2>
<P>On utilise ...
<!-- Fichier findepage-fra.html inclus à la dernière ligne de la page -->
<P>
<HR>
<EM>Dernière modification: </EM>
<!--#echo var="LAST_MODIFIED" -->
mardi 15 février 2000
<BR>
<A HREF="copyright-fra.html">Copyright</A>
© 1997 - 2000 INRIA, tous droits réservés.
</BODY>
</HTML>
htmlc-1.0/doc_src/htmlc-index.html 000644 057275 000037 00000000775 07547123273 017301 0 ustar 00weis caml 000000 2630777
Htmlc
Fichier créé le 11 septembre 2000.
Htmlc
Click here to select the English
version.
Cliquez ici pour sélectionner la version
Française.
La méthode de construction consiste à copier les fichiers du
répertoire $(SRC)
dans le répertoire des objets. Pour
cela le Makefile fabrique l'ensemble des règles de copie correspondant
aux fichiers à créer. Ces règles sont alors incluses automatiquement
par la dernière ligne du fichier. Cela explique pourquoi, il faut
initialiser le processus lors de l'installation de ce Makefile, en
tapant
touch .Makefile.auto
make auto
ce qui crée le fichier de règles vide .Makefile.auto
, ce
qui permet ensuite de lancer le Makefile pour créer les règles
nécessaires (make auto
).
Discussion
Cette organisation en deux répertoires séparés présente de nombreux
avantages: le site proprement dit ne comporte que les fichiers
strictement nécessaires, les fichiers auxiliaires ne se trouvant que
dans le répertoire SRC
; en outre les modifications
apportées au site ne sont pas immédiatement effectives et visibles de
l'ensemble des lecteurs du site Web: on peut modifier les pages
sources et même les expanser et les examiner à loisir sans troubler
les utilisateurs du site; après toutes les vérifications utiles, une
simple commande make
exécutée dans le répertoire
WEB
publie ces modifications en les rendant accessibles
au server WEB.
Cette organisation s'est révélée extrêmement efficace
pour l'écriture et le développement de l'ensemble des pages HTML de la
FAQ du langage Caml.
IV Exemples
- Inclusion d'entêtes
- Pour inclure systématiquement le type du document, on écrira en
première ligne de chaque fichier:
<!--#include virtual="doctype" -->
ce qui ordonne l'inclusion du texte du fichier doctype
dans le fichier.
Si le fichier doctype
contient:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
"http://www.w3.org/TR/REC-html40/loose.dtd">
alors le fichier
<!--#include virtual="doctype" -->
<HTML>
<HEAD>
<TITLE>Foire aux questions au sujet de Caml</TITLE>
</HEAD>
devient
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
"http://www.w3.org/TR/REC-html40/loose.dtd">
<HTML>
<HEAD>
<TITLE>Foire aux questions au sujet de Caml</TITLE>
</HEAD>
- Inclusion d'un pied de page
- Pour inclure dans une page HTML, un pied de page défini une fois
pour toutes dans le fichier
basdepage-fra.html
, il suffit
d'écrire, la ligne:
<!--#include virtual="basdepage-fra.html"-->
Alors, si le fichier basdepage-fra.html
contient:
<P>
<HR>
<EM>Dernière modification: </EM>
<!--#echo var="LAST_MODIFIED" -->
<BR>
<A HREF="copyright-fra.html">Copyright</A>
© 1997 - 2000 INRIA, tous droits réservés.
le fichier source
<!--#include virtual="basdepage-fra.html"-->
</BODY>
</HTML>
est transformé par htmlc
en:
<P>
<HR>
<EM>Dernière modification: </EM>
<!--#echo var="LAST_MODIFIED" -->
mardi 15 février 2000
<BR>
<A HREF="copyright-fra.html">Copyright</A>
© 1997 - 2000 INRIA, tous droits réservés.
</BODY>
</HTML>
- Inclusion d'un programe
- Pour inclure dans votre texte le programme Caml contenu dans le
fichier
exemple_caml.ml
, il suffit
d'écrire, la ligne:
<!--#include verbatim="exemple_caml.ml"-->
Alors, si le fichier exemple_caml.ml
contient:
let succ x = x + 1;;
succ : int -> int = <fun>
la ligne d'inclusion sera remplacé par:
let succ x = x + 1;;
succ : int -> int = <fun>
- Maquettes de pages HTML
- Pour alléger l'écriture des pages d'un site WEB, on peut très
bien définir un ensemble de maquettes comportant des inclusions
prédéfinies.
Par exemple, le fichier maquette de trois lignes suivant, permet
d'abstraire le type du document, son entête et son pied de page:
<!--#include virtual="avanttitre-fra.html"-->
<!--#include virtual="aprestitre-fra.html"-->
<!--#include virtual="findepage-fra.html"-->
Le créateur des pages html n'a plus qu'à mettre le titre de la page
entre les deux lignes d'inclusion pour obtenir un fichier HTML complet:
<!--#include virtual="avanttitre-fra.html"-->
L'expanseur <CODE>htmlc</CODE>
<!--#include virtual="aprestitre-fra.html"-->
<H2 ALIGN=LEFT>De quoi s'agit-il ?</H2>
<P>On utilise ...
<!--#include virtual="findepage-fra.html"-->
En effet, si l'on suppose que
- le fichier
avanttitre-fra.html
contient:
<!--#include virtual="doctype" -->
<!-- Fichier avanttitre-fra.html inclus avant le titre de la page -->
<HTML>
<HEAD>
<TITLE>
- le fichier
aprestitre-fra.html
contient:
<!-- Fichier aprestitre-fra.html inclus après le titre de la page -->
</TITLE>
</HEAD>
<BODY BGCOLOR="#FFFFFF">
<!--#include virtual="hautdepage-fra.html"-->
- le fichier
findepage-fra.html
contient:
<!-- Fichier findepage-fra.html inclus à la dernière ligne de la page -->
<P>
<HR>
<EM>Dernière modification: </EM>
<!--#echo var="LAST_MODIFIED" -->
</BODY>
</HTML>
- le fichier
hautdepage-fra.html
contient:
<ADDRESS>Contacter l'auteur <A HREF="mailto:Pierre.Weis@inria.fr">Pierre.Weis@inria.fr</A></ADDRESS>
- tandis que les fichiers
doctype
et
findepage-fra.html
ont le même contenu que ci-dessus
Alors le fichier:
<!--#include virtual="avanttitre-fra.html"-->
L'expanseur <CODE>htmlc</CODE>
<!--#include virtual="aprestitre-fra.html"-->
<H2 ALIGN=LEFT>De quoi s'agit-il ?</H2>
<P>On utilise ...
<!--#include virtual="findepage-fra.html"-->
est expansé par htmlc
en le fichier:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
"http://www.w3.org/TR/REC-html40/loose.dtd">
<!-- Fichier avanttitre-fra.html inclus avant le titre de la page -->
<HTML>
<HEAD>
<TITLE>
L'expanseur <CODE>htmlc</CODE>
<!-- Fichier aprestitre-fra.html inclus après le titre de la page -->
</TITLE>
</HEAD>
<BODY BGCOLOR="#FFFFFF">
<ADDRESS>Contacter l'auteur <A HREF="mailto:Pierre.Weis@inria.fr">Pierre.Weis@inria.fr</A></ADDRESS>
<H2 ALIGN=LEFT>De quoi s'agit-il ?</H2>
<P>On utilise ...
<!-- Fichier findepage-fra.html inclus à la dernière ligne de la page -->
<P>
<HR>
<EM>Dernière modification: </EM>
<!--#echo var="LAST_MODIFIED" -->
mardi 15 février 2000
<BR>
<A HREF="copyright-fra.html">Copyright</A>
© 1997 - 2000 INRIA, tous droits réservés.
</BODY>
</HTML>
htmlc-1.0/doc_src/htmlc-index.html 000644 057275 000037 00000000775 07547123273 017301 0 ustar 00weis caml 000000 2630777
Htmlc
Fichier créé le 11 septembre 2000.
Htmlc
Click here to select the English
version.
Cliquez ici pour sélectionner la version
Française.