|
#REDIRECT [[Christophe de Dinechin]]
'''XL''' stands for eXtensible Language. It is a [[computer programming|computer]] [[programming language]] designed to support [[concept programming]].
{{R from merge}}
XL features programmer-reconfigurable syntax and semantics. Compiler '''plug-ins''' can be used to add new features to the language. A base set of plug-ins offer a relatively standard [[imperative programming|imperative language]]. Programmers can write their own plug-ins to implement application-specific notations, such as [[derivative|symbolic differentiation]], which can then be used similarly to built-in language features.
== Language ==
XL is defined at three different levels:
* XL0 defines how an input text is transformed into a [[parse tree]].
* XL1 defines a base language with features comparable to [[C_plus_plus|C++]]
* XL2 defines the standard library, which includes common data types and operators.
XL has no [[primitive types]] nor keywords. All useful operators and data types, like integers or addition, are defined in the standard library (XL2). XL1 is [[Porting|portable]] between different execution environments. There is no such guarantee for XL2: if a particular [[central processing unit|CPU]] does not implement floating-point multiplication, the corresponding operator definition may be missing from the standard library, and using a floating-point multiply may result in a [[compile-time]] error.
The [[Hello World]] program in XL looks like the following:
import IO = XL.TEXT_IO
IO.WriteLn "Hello World"
== Syntax ==
Syntax is defined at the XL0 level. The XL0 phase of the compiler can be configured using a syntax description file, where properties like the text representation and precedence of operators are defined. A basic syntax file defines common mathematical notations, like + for addition, with the usually accepted [[order of operations]].
The parse tree consists of 7 node types, 4 [[leaf node]] types (integer, real, text and symbol) and 3 [[internal node]] types (infix, prefix and block).
* ''integer'' nodes represent an integer [[literal]], such as <code>2</code>. The <code>#</code> sign can be used to specify a base other than 10, as in (<code>2#1001</code>). A separating underscore can be used to improve readability, as in <code>1_000_000</code>.
* ''real'' nodes represent non-integral numbers, such as <code>2.5</code>. Based-notations and separators can be used, as for integer nodes, for example <code>16#F.FFF#E-10</code> is a valid real literal.
* ''text'' nodes represent textual contents. They are normally surrounded by simple or double quotes, like <code>"Hello"</code> or <code>'a'</code>, but the syntax file can be used to add other separators, including for multi-line textual contents.
* ''symbol'' nodes represent names or operators. Names are sequence of alphanumeric characters beginning with a letter, like <code>Hello</code>. XL0 preserves case, but XL1 ignores case and underscores, so that <code>JohnDoe</code> and <code>john_doe</code> are the same name. Symbols are sequence of non-alphanumeric characters, like <code>*</code> or <code>=/=</code>.
* ''infix'' nodes represent two nodes related by an infix symbol, like <code>A+1</code> or <code>2 and 3</code>. Infix nodes are in particular used to separate lines, with an infix "new-line" symbol.
* ''prefix'' nodes represent two consecutive nodes, like <code>Write "Hello"</code>. It is also used for postfix notations, like <code>3!</code> or <code>Open?</code>.
* ''block'' nodes represent a node surrounded by grouping symbols, like <code>(A)</code>, <code>[Index]</code>. Indentation is internally represented by a block node.
With the default syntax file, the following is valid XL0, irrespective of any semantics.
A = B + "Hello"
It parses as:
infix("=",
symbol("A"),
infix("+",
symbol("B"), text("Hello")))
== Semantics ==
The XL1 phase is defined as a sequence of operations on the XL0 parse tree. These operations are provided by various compiler plug-ins, that are triggered based on the shape of the parse tree.
Special constructs, <code>translate</code> and <code>translation</code>, are provided by a plug-in designed to facilitate the writing of other plug-ins. The <code>quote</code> construct generates a parse tree. Here is how these notation can be used to implement a plug-in called <code>ZeroRemoval</code> that eliminates superfluous additions and multiplications by zero.
translation ZeroRemoval
when
'X' + 0
then
return X
when
'X' * 0
then
return quote(0)
The XL1 phase contains a large set of plug-ins, notably <code>XLSemantics</code>, that provide common abstractions like [[subroutine]], [[data type]] and [[variable]] [[declaration]] and [[definition]], as well as basic [[structured programming]] statements, like conditionals or loops.
== External links ==
[http://xlr.sf.net The SourceForge development page]
| 