24.1 : Source

24.1.1 : Source inclusions

Source inclusion collects the source lines which make up a program. This process is controled by the following system commands:

• #include "file-name"
#reinclude "file-name"
  These commands collect the lines from the named file. If a given file has already been included, then subsequent include commands for that file have no effect. A reinclude command always includes the file, whether or not it has already been included.

  The includer tries to find the file relative to the directory of the current source file and then in a sequence of user-specified and platform-specific directories.

• #assert identifier
  #unassert identifier
  These commands turn on or off named properties which may be tested for conditional source inclusion.
• #if identifier
  #elseif identifier
  #else
#endif
  These commands provide conditional source inclusion.
• #! text
  #
  Lines are ignored if they begin with ``#!'' or begin with ``#'' and contain only white space.

24.1.2 : Prepared source

The following commands allow source to be prepared by another program.

• #line line-number ["file-name"]
  The next line is recorded as occurring at the given line number in the named file. The first line of a file is line number 1. If the file name is missing, then the current file name is used.
• #error text
  An error is considered to have occurred at the position of the system command line and the given text is used as the message.

24.1.3 : Other system commands

Other system commands control the environment:

24.2 : Lexical structure

24.2.1 : Characters

The standard Aldor character set contains the following 97 characters:

• the blank, tab and newline characters
• the Roman letters: a-z A-Z
• the digits: 0-9
• and the following special characters:
  

  (	left parenthesis	)	right parenthesis
  [	left bracket	]	right bracket
  {	left brace	}	right brace
  <	less than	>	greater than
  ,	comma	.	period
  ;	semicolon	:	colon
  ?	question mark	!	exclamation mark
  =	equals	_	underscore
  +	plus	-	minus (hypen)
  &	ampersand	*	asterisk
  /	slash	\	back-slash
  '	apostrophe (quote)	`	grave (back-quote)
  "	double quote	|	vertical bar
  ^	circumflex	~	tilde
  @	commercial at	#	sharp
  $	dollar	%	percent

24.2.2 : The escape character

Underscore is used as an ``escape'' character, which alters the meaning of the following text. The nature of the change depends on the context in which the underscore appears.

An escaped underscore is not an escape character.

An escape character followed by one or more white space characters causes the white space to be ignored. The remainder of this section assumes that escaped white space has been removed from the source.

24.2.3 : Tokens

The sequence of source characters is partitioned into tokens. The longest possible match is always used.

The tokens are classified as follows:

• the following language-defined keywords:

  add     and      break    default  define   do        
  else    export   extend   for      fluid    free      
  from    generate goto     has      if       import    
  in      inline   iterate  local    macro    never     
  not     of       or       pretend  repeat   return    
  then    to       where    while    with     yield
  
  .       ,        ;        :        ::       :*       
  :=      ==       ==>      +->      |        =>       
  '       $        @        (   )    [   ]    {   }
  

  The characters in a keyword cannot be escaped. That is, if a character is escaped, the token is not treated as a keyword.

• the following are not defined by the language but are reserved words for future use:

  always  assert   but      delay    except   fix      
  is      isnt     let      rule     select   try       
  
  `       &        ||       (|  |)   [|  |]   {|   |}
  

• the following set of definable operators:

  by      case     mod      quo      rem
  
  #        +       -        +-       ~        ^
  *        **      ..       =        ~=       ^=   
  /  \     /\  \/  <   >    <=  >=   <<  >>   <-   ->
  

  The characters in an operator cannot be escaped.
• identifiers:
  0
1
[%a-zA-Z][%?!a-zA-Z0-9]*
  Any non-white space standard character may be included in an identifer by escaping it. Thus ``a'', ``_#'', ``a_*'' and ``_if'' are all identifiers. The escape character is not part of the identifier so ``ab'' ``_a_b'' represent the same identifier. Identifiers are the only tokens for which the leading character may be escaped.
• string-style literals:

  `"'[^"]*`"'

  An underscore or double quote may be included in a string-style literal by escaping it.
• integer-style literals:

  [2-9]:
  [0-9][0-9]+
  [0-9]+`r'[0-9A-Z]+

  Escape characters are ignored in integer-style literals and so may be used to group digits.
• floating point-style literals:

  [0-9]*`.'[0-9]+{[eE]{[+-]}[0-9]+}
  [0-9]+`.'[0-9]*{[eE]{[+-]}[0-9]+}
  [0-9]+[eE]{[+-]}[0-9]+
  [0-9]+`r'[0-9A-Z]*`.'[0-9A-Z]+{e{[+-]}[0-9]+}
  [0-9]+`r'[0-9A-Z]+`.'[0-9A-Z]*{e{[+-]}[0-9]+}
  [0-9]+`r'[0-9A-Z]+`e'{[+-]}[0-9]+
  

  Escape characters are ignored in floating point-style literals and so may be used to group digits.

  Certain lexical contexts restrict the form of floats allowed. This distinguishes cases such as sin 1.2 vs m.1.2. A floating point literal may not

  • begin with ``.'', unless the preceding token is a keyword other than ``)'', ``|)'', ``]'' or ``}'',
  • contain ``.'', if the preceding token is ``.'',
  • end with ``.'', if the following character is ``.''.
• comments:
  The two characters ``--'' and all characters up to the end of the line. Underscores are not treated as escape characters in comments.
• documentation:
  The two characters ``++'' and all characters up to the end of the line. Underscores are not treated as escape characters in documentation.
• leading white space:
  a sequence of blanks or tabs at the beginning of a line.
• embedded white space:
  a sequence of blanks or tabs not at the beginning of a line.
• newline:
  a newline character.
• layout markers:
  SETTAB BACKSET BACKTAB
  These do not appear in a source program but may be used to represent a linearized from of the token sequence.

24.3 : Layout

Indentation sensitivity may be turned off by enclosing source in a ``{''/``}'' pair. Within braces all white space -- leading, embedded, and newlines -- is ignored. This is a non-piling context. Piling and non-piling contexts may be nested.

The layout of a program in a piling context is understood by converting leading white space and newlines to special markers which are part of the language syntax.

This conversion follows the linearization rules:

• Blank lines are ignored.
• Consecutive lines indented the same ammount form a pile.
• The pile is enclosed in a SETTAB-BACKTAB pair if
  • the pile has more than one line, or
  • the pile has only one line and the last token of the line before the pile is ``then'', ``else'', ``with'' or ``add''.
• The pile lines are joined to form a single line. A BACKSET inserted between adjacent pair of lines, unless
  • the first contains only comments or documentation, or
  • the first ends with ``('', ``['', ``{'' or ``,'', or the second begins with ``in'', ``then'', ``else'', ``)'', ``]'' or ``}''.
• A line is joined to the previous line if it is indented with respect to it, forming a new single line.