Skip to content

GitLab

Commit 44d33206 authored by Pietro Abate's avatar Pietro Abate
Browse files

[r2003-03-16 17:34:54 by cvscast] Revu gration du site 

Original author: cvscast
Date: 2003-03-16 17:35:11+00:00
parent c1eed545
Expand all Hide whitespace changes
Inline Side-by-side
web/cduce.css
View file @ 44d33206
......@@ -12,23 +12,23 @@ a:link:hover, a:visited:hover {
}
h1 {
color: #FF0000;
color: #aa0000;
text-align: center;
font: bold 200% helvetica;
margin: 0ex 0em 0ex 0em;
padding: 0ex;
font: bold 200% helvetica;
}
h2 {
background: #FFF0F0;
color: #0000FF;
font: bold 102% helvetica;
padding: 0.5ex 0 0.5ex 1em;
margin: 0 0 0 0;
font: bold 102% helvetica;
}
h3 {
font: bold 60% sans-serif;
padding: 0 0 0 2em;
margin: 0 0 0 0;
font: bold 60% sans-serif;
}
h4 {
font: bold 100% helvetica;
......@@ -40,6 +40,9 @@ p {
text-align: justify;
margin: 1ex 1em 0 1em;
}
pre {
margin: 1ex 1em 0 1em;
}
div.abstract {
......@@ -48,19 +51,44 @@ div.abstract {
padding: 1ex 1em 1ex 1em;
background: #F0F0F0;
}
div.abstract p {
font: 100% sans-serif;
}
#Sidelog {
position: absolute;
top: 10px;
left: 10px;
width: 190px;
background-color: #ffcd72;
border: 1px dashed black;
padding: 5px 5px 0px 5px;
font-size:11px;
font-family: arial, helvetica, sans-serif;
color: black;
}
#Content {
margin:10px 1em 10px 225px;
padding:10px 20px 10px 20px;
color:black;
background-color:#fccead;
border:1px solid black;
}
div.box {
background: #FFFFFF;
border: solid 2px #000000;
margin: 2ex 1em 0 1em;
margin: 2ex 1em 2ex 1em;
padding: 0ex 0ex 0.5em 0ex;
}
div.title {
background: #FFFFFF;
border: solid 2px #000000;
margin: 2ex 1em 0 1em;
margin:10px 1em 10px 225px;
padding: 0ex 0ex 0ex 0ex;
}
div.meta {
......@@ -73,6 +101,7 @@ div.meta {
}
@media screen {
body {
background: #BBDDFF;
background: #fcb333;
}
}
web/cduce2.css deleted 100644 → 0
View file @ c1eed545
body {
background: #BBDDFF;
color: #000000;
margin: 1ex 0 1ex 0;
padding: 0;
}
a:link:hover, a:visited:hover {
text-decoration: none;
background: #FFFFD0;
color: #FF0000;
}
h1 {
color: #aa0000;
text-align: center;
margin: 0ex 0em 0ex 0em;
padding: 0ex;
font: bold 200% helvetica;
}
h2 {
background: #FFF0F0;
color: #0000FF;
padding: 0.5ex 0 0.5ex 1em;
margin: 0 0 0 0;
font: bold 102% helvetica;
}
h3 {
padding: 0 0 0 2em;
margin: 0 0 0 0;
font: bold 60% sans-serif;
}
h4 {
font: bold 100% helvetica;
color: #008000;
padding: 0 0 0 1em;
margin: 1em 0 0 0;
}
p {
text-align: justify;
margin: 1ex 1em 0 1em;
}
pre {
margin: 1ex 1em 0 1em;
}
div.abstract {
font: bold 80% helvetica;
margin: 1ex 1em 1ex 1em;
padding: 1ex 1em 1ex 1em;
background: #F0F0F0;
}
div.abstract p {
font: 100% sans-serif;
}
#Sidelog {
position: absolute;
top: 10px;
left: 10px;
width: 190px;
background-color: #ffcd72;
border: 1px dashed black;
padding: 5px 5px 0px 5px;
font-size:11px;
font-family: arial, helvetica, sans-serif;
color: black;
}
#Content {
margin:10px 1em 10px 225px;
padding:10px 20px 10px 20px;
color:black;
background-color:#fccead;
border:1px solid black;
}
div.box {
background: #FFFFFF;
border: solid 2px #000000;
margin: 2ex 1em 2ex 1em;
padding: 0ex 0ex 0.5em 0ex;
}
div.title {
background: #FFFFFF;
border: solid 2px #000000;
margin:10px 1em 10px 225px;
padding: 0ex 0ex 0ex 0ex;
}
div.meta {
background: #E0E0E0;
margin: 4ex 0.5em 0 0.5em;
border: solid 1px #B0B0B0;
padding: 0.5ex;
font-size: 80%;
font-family: sans-serif;
}
@media screen {
body {
background: #fcb333;
}
}
web/macros.cd deleted 100644 → 0
View file @ c1eed545
type XML_elem = <(_)>XML;;
type XML = [ (XML_elem | Char)* ];;
let fun banner (title : Any, subtitle : Any) : XML =
[<div class="title">[
!(match title with t & XML \ [] -> [<h1>t] | _ -> [])
!(match subtitle with t & XML \ [] -> [<h3>t] | _ -> [])
]];;
let fun box (title : Any, subtitle : Any, name : Any, content : XML) : XML =
[<div class="box">[
!(match name with String \ [] -> [<a name=name>[]] | _ -> [])
!(match title with t & XML \ [] -> [<h2>t] | _ -> [])
!(match subtitle with t & XML \ [] -> [<h3>t] | _ -> [])
!content
]];;
let fun convert (XML_elem | Char | XML -> XML)
| <box ({ title=t }
& ({ subtitle=st } | (st := `nil))
& ({ link=name } | (name := `nil)) )>x ->
box (t,st,name,convert x)
| <banner ({ title=t } & ({ subtitle=st } | (st := `nil)))>x ->
banner (t,st)
| <(tag) (attr)>x -> [<(tag) (attr)>(convert x)]
| c & Char -> [c]
| seq -> transform seq with x -> convert x;;
let src =
match [ (load_xml "index.xml") ] with
| XML & x -> x
| _ -> raise ("Invalid input ...");;
let conv : XML = convert src;;
let out : String =
[ '<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">' ]
@
(transform convert src with x -> print_xml x);;
dump_to_file "index.html" out;;
web/macros2.cd deleted 100644 → 0
View file @ c1eed545
type XML_elem = <(_)>XML;;
type XML = [ (XML_elem | Char)* ];;
type PHP = <php>String;;
let fun banner (title : Any, subtitle : Any) : XML =
[<div class="title">[
!(match title with t & XML \ [] -> [<p>[] <h1>t] | _ -> [])
!(match subtitle with t & XML \ [] -> [<h3>t] | _ -> [])
]];;
let fun box (title : Any, subtitle : Any, name : Any, content : XML) : XML =
[<div class="box">[
!(match name with String \ [] -> [<a name=name>[]] | _ -> [])
!(match title with t & XML \ [] -> [<h2>t] | _ -> [])
!(match subtitle with t & XML \ [] -> [<h3>t] | _ -> [])
!content
]];;
let fun convert (XML_elem | Char | XML | PHP -> XML)
| (<php>_) & x -> [ x ]
| <box ({ title=t }
& ({ subtitle=st } | (st := `nil))
& ({ link=name } | (name := `nil)) )>x ->
box (t,st,name,convert x)
| <banner ({ title=t } & ({ subtitle=st } | (st := `nil)) & {src=s} & {style=sty})>x ->
banner (([<img {src=s; title=t; alt=t; style=sty}>[]]),st)
| <banner ({ title=t } & ({ subtitle=st } | (st := `nil)))>x ->
banner (t,st)
| <(tag) (attr)>x -> [<(tag) (attr)>(convert x)]
| c & Char -> [c]
| seq -> transform seq with x -> convert x;;
let src =
match [ (load_xml "index2.xml") ] with
| XML & x -> x
| _ -> raise ("Invalid input ...");;
let conv : XML = convert src;;
let out : String =
[ '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">' ]
@
(transform convert src with
x -> print_xml x);;
dump_to_file "index.php" out;;
web/site.cd 0 → 100644
View file @ 44d33206
include "xhtml-strict.cd";;
include "xhtml-categ.cd";;
type Page = <page>[
<title>String
<banner>[InlineText*]
<navig>[ NavigBox* ] <main>[ Box* ] ];;
type Author = <author>String;;
type Paper =
<paper file=?String>[
<title>String
Author+
<comment>[InlineText*]
<abstract>Content ];;
type Slides =
<slides file=String>[
<title>String
Author+
<comment>[InlineText*]
];;
type Link =
<link url=String; title=String>[InlineText*];;
type Content =
[ ( <p {||}>[InlineText*]
| <ul {||}>[<li {||}>Content +]
| <section title=String>Content
| Paper | Slides | Link | InlineText )* ];;
type InlineText =
Char
| <(`b|`i) {||}>[InlineText*]
| Xa
| Ximg
;;
type Box = <box title=String; subtitle=?String; link=String>Content
| <meta>Content;;
type NavigBox = <box>Content | <toc>[];;
let fun authors ([Author+] -> String)
| [ <author>a ] -> a
| [ <author>a1 <author>a2 ] -> a1 @ ", and " @ a2
| [ <author>a; rem ] -> a @ ", " @ authors rem;;
let fun content (t : Content) : Flow =
transform t with
| <section title=title>c -> [ <h4>title !(content c) ]
| <paper (r)>[ <title>tit aut::Author* <comment>com <abstract>ab ] ->
[
(match r with
| { file = f } -> <a href=f>tit
| _ -> <b>tit
) '. '
!(authors aut) '. '
!com
<div class="abstract">[ 'Abstract:' !(content ab) ]
]
| <slides file=f>[ <title>tit aut::Author* <comment>com ] ->
[ <a href=f>tit '. ' !(authors aut) '. ' !com ]
| <link url=url; title=title>com ->
[ <a href=url>title '. ' !com ]
| <ul>lis -> [ <ul>(map lis with <li>x -> <li>(content x)) ]
| x -> [ x ];;
let fun main2html (Box -> Flow)
<box (r)>c ->
[ <div class="box">[
<h2>(r.title)
!(match r with { subtitle = t } -> [<b>t] | _ -> [])
<a name=r.link>[]
!(content c) ] ]
| <meta>c -> [ <div class="meta">(content c) ];;
let fun page2html (Page -> Xhtml)
<page>[ <title>title <banner>banner <navig>navig <main>main ] ->
let toc =
transform main with <box title=t; link=l>_ -> [ <li>[ <a href=('#',l)>t ] ] in
let toc = match toc with [] -> [] | lis -> [ <ul>lis ] in
let navig : Flow = transform navig with
| <box>c -> [ <div class="box">(content c) ]
| <toc>[] -> [ <div class="box">toc ]
in
<html>[
<head>[
<title>title
<meta content="text/html; charset=iso-8859-1"; http-equiv="Content-Type">[]
<link rel="stylesheet"; href="cduce.css"; type="text/css"> []
]
<body>[
<div class="title">[ <h1>banner ]
<div id="Sidelog">navig
<div id="Content">(transform main with b -> main2html b)
]
];;
let page : Page = match load_xml "site.xml" with
| Page & p -> p
| _ -> raise "Invalid input document";;
let out : String =
[ '<?xml version="1.0" encoding="iso-8859-1"?>'
'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"'
' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">'
!(print_xml (page2html page)) ];;
dump_to_file "index.html" out;;
web/site.xml 0 → 100644
View file @ 44d33206
<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
<page>
<title>CDuce</title>
<banner>
<img title="CDuce" src="img/cduce_logo.jpg" width="400" height="206"
alt="CDuce"/>
</banner>
<!-- ********* Left panel ********* -->
<navig>
<toc/>
<box>
<p> CDuce ("seduce") is a new typed functional language with
innovative features: </p>
<ul>
<li> a rich <b>type algebra</b>, with recursive types and arbitrary
boolean combinations (union, intersection, complement); </li>
<li> a natural notion of <b>subtyping</b>, which allows to use a value
of a given type where a value of a supertype is expected; </li>
<li> <b>overloaded functions</b> with late binding (dynamic dispatch);
</li>
<li> a powerful <b>pattern matching</b> operation, with dynamic
dispatch ontypes and recursive patterns. </li>
</ul>
<p> Although CDuce is a general programming language, it features
several characteristics that make it adapted to XML documents
manipulation (transformation, extraction of information, creation of
documents).
<a href="http://www.w3.org/XML/">XML</a> is a syntax to
describe tree-like documents (aka semi-structured data), and XML
documents often come with a description of their type. The type is
expressed in a system like DTD, or
<a href="http://www.w3.org/XML/Schema">XML Schema</a>. </p>
<p> Our point of view and our guideline for the design of CDuce is
that a programming language for XML should take XML types into account
to allow: </p>
<ul>
<li> <b>static verifications</b> of properties for the applications
(for instance, ensuring that a transformation produces a document of
the expected type);</li>
<li> good <b>integration in a general purpose typed programming
language</b>;</li>
<li> static <b>optimizations</b> of applications and storage (knowing
the type of a document seems important to store and extract
information efficiently).</li>
</ul>
</box>
<box>
<p> <b>CDuce</b> is developped by the
<a href="http://www.di.ens.fr/~castagna/EQUIPE"><b>Languages</b></a>
group of ENS in Paris and the
<a href="http://www.lri.fr/bd"><b>Databases</b></a> group of LRI in
Orsay, two <a href="http://www.cnrs.fr">CNRS</a> labs.
</p>
</box>
<box>
<p> This page was automatically generated from an XML description of
the content by a CDuce program.
<img src="img/cducepower2.jpg" alt="Powered by CDuce"/></p>
</box>
<toc/>
</navig>
<!-- ********* Main panel ********* -->
<main>
<box title="Give it a try!" link="proto">
<section title="Online running prototype">
<p> The only available implementation of CDuce is an <a
href="cgi-bin/cduce">online prototype</a>. To get a feeling of CDuce,
you can try the examples and play with them, or have a look at this <a
href="memento.html">memento</a> which briefly explains the syntax of
the language. </p>
</section>
</box>
<box title="Papers" link="papers">
<section title="Language Description">
<ul>
<li>
<paper file="papers/cduce-wp.ps.gz">
<title>CDuce: a white paper</title>
<author>V. Benzaken</author>
<author>G. Castagna</author>
<author>A. Frisch</author>
<comment>
A preliminary and abriged version of this work was presented at the workshop
<i>PLAN-X: Programming Language Technologies for XML</i>
Pittsburgh PA, Oct. 2002.
</comment>
<abstract> <p> In this paper, we present the functional language CDuce,
discuss some design issues, and show its adequacy for working with
XML documents. Peculiar features of CDuce are a powerful pattern
matching, first class functions, overloaded functions, a very rich
type system (arrows, sequences, pairs, records, intersections,
unions, differences), precise type inference and a natural
interpretation of types as sets of values. We also discuss how to add
constructs for programming XML queries in a declarative (and, thus,
optimizable) way and finally sketch a dispatch algorithm to
demonstrate how static type information can be used in efficient
compilation schemas. </p> </abstract>
</paper>
</li>
</ul>
</section>
<section title="Theoretical foundations">
<ul>
<li>
<paper file="papers/lics02.ps.gz">
<title>Semantic subtyping</title>
<author>A. Frisch</author>
<author>G. Castagna</author>
<author>V. Benzaken</author>
<comment> In <i>LICS 2002</i>. </comment>
<abstract> <p> Usually subtyping relations are defined either
syntactically by a formal system or semantically by an interpretation
of types in an untyped denotational model. In this work we show how
to define a subtyping relation semantically, for a language whose
<i>operational</i> semantics is <i>driven by types</i>; we consider a
rich type algebra, with product, arrow, recursive, intersection,
union and complement types. Our approach is to "bootstrap" the
subtyping relation through a notion of set-theoretic model <i>of the
type algebra</i>. </p>
<p> The advantages of the semantic approach are manifold. Foremost we
get "for free" many properties (e.g., the transitivity of subtyping)
that, with axiomatized subtyping, would require tedious and error
prone proofs. Equally important is that the semantic approach allows
one to <i>derive</i> complete algorithms for the subtyping relation
or the propagation of types through patterns. As the subtyping
relation has a natural (inasmuch as semantic) interpretation, the
type system can give informative error messages when static
type-checking fails. Last but not least the approach has an immediate
impact in the definition <i>and the implementation</i> of languages
manipulating XML documents, as this was our original motivation.
</p> </abstract>
</paper>
</li>
<li>
<paper file="papers/itrs02.ps.gz">
<title>The Relevance of Semantic Subtyping</title>
<author>M. Dezani-Ciancaglini</author>
<author>A. Frisch</author>
<author>E. Giovannetti</author>
<author>Y. Motohama</author>
<comment>
In <i>Electronic Notes in Theoretical Computer Science 70 No.1 (2002)</i>.
</comment>
<abstract> <p> We compare Meyer and Routley's minimal relevant logic
B+ with the recent semantics-based approach to subtyping introduced
by Frisch, Castagna and Benzaken in the definition of a type system
with intersection and union. We show that - for the functional core
of the system - such notion of subtyping, which is defined in purely
set-theoretical terms, coincides with the relevant entailment of the
logic B+. </p> </abstract>
</paper>
</li>
<li>
<paper file="papers/dea.ps.gz">
<title>Types récursifs, combinaisons booléennes et fonctions
surchargées: application au typage de XML</title>
<author>A. Frisch</author>
<comment>In french. Mémoire du DEA « Programmation: Sémantique,
Preuves et Langages » (Paris VII) </comment>
<abstract> <p> Nous étudions un lambda-calcul typé avec une opération
de filtrage qui permet d'exprimer des fonctions
surchargées. L'algèbre de types a des types de base, les types
produit et flèche, les types récursifs, les combinaisons booléennes
finies arbitraires. Nous considérons une notion de sous-typage
sémantique, issue de l'interprétation des types comme ensembles de
valeurs du langage. </p>
<p> Les caractéristiques présentes dans le calcul et l'algèbre de
types sont motivées par l'utilisation du calcul comme un noyau pour
un langage adapté à la manipulation de documents XML. </p>
<p> Nous utilisons une approche sémantique pour étudier l'algèbre de
types, tout en conservant une preuve syntaxique de préservation du
typage par réduction. </p> </abstract>
</paper>
</li>
</ul>
</section>
<section title="Security">
<ul>
<li>
<paper file="papers/sec.ps.gz">
<title>Security analysis for XML transformations</title>
<author>M. Burelle</author>
<author>V. Benzaken</author>
<author>G. Castagna</author>
<comment> <a href="http://www.myths.eu.org">MyThS</a> technical
report. </comment>
<abstract> <p> In this article we give a formal definition of
information flows in the context of XML transformations and, more
generally, in the presence of type dependent computations. We
formalize a sound technique to detect XML document transformations
that may leak private or confidential information. By defining
security annotations and by relating various kind of analyses to
different query scenarios, we also establish a general framework for
checking middleware-located information flows. </p> </abstract>
</paper>
</li>
</ul>
</section>
</box>