Ada Specifications and Declarations

This file is an Ada package specification (a .ads file). The content is limited to specifications and declarations: "basic_declarative_item" (i.e. not procedure or function body, etc.)
27
Dec

AAda Compiler UCS4 Character to Uppercase

1
2
3
4
5
6
7
8
9
10
-- auto-generated by Generate Unicode Uppercase
-- see: http://aada.m2osw.com/compiler/compiler-tools/generate-unicode-uppercase
with aada_compiler_ucs4_character;
use aada_compiler_ucs4_character;
 
package aada_compiler_ucs4_character_to_uppercase is
  -- used by ucs4_string_to_normalized_uppercase()
  -- for any lone character
  function ucs4_to_upper(u: ucs4_character) return ucs4_character;
end aada_compiler_ucs4_character_to_uppercase;
27
Dec

AAda Compiler UCS4 Character to CCC

1
2
3
4
5
6
7
8
9
10
11
12
13
-- auto-generated by Generate Unicode Uppercase
-- see: http://aada.m2osw.com/compiler/compiler-tools/generate-unicode-uppercase
with aada_compiler_ucs4_character;
use aada_compiler_ucs4_character;
 
package aada_compiler_ucs4_character_to_ccc is
  -- the range is really 0 to 255, but only 0 to 240
  -- are currently used so to detect potential errors...
  type ccc_type is range 0 .. 240;
 
  -- used by ucs4_string_to_normalized_uppercase()
  function ucs4_to_ccc(u: ucs4_character) return ccc_type;
end aada_compiler_ucs4_character_to_ccc;
27
Dec

AAda Compiler UCS4 String Normalized Uppercase

1
2
3
4
5
6
7
8
9
-- auto-generated by Generate Unicode Uppercase
-- see: http://aada.m2osw.com/compiler/compiler-tools/generate-unicode-uppercase
with aada_compiler_ucs4_character;
use aada_compiler_ucs4_character;
 
package aada_compiler_ucs4_string_normalized_uppercase is
  -- transform a ucs4_vstring to uppercase
  procedure ucs4_string_to_normalized_uppercase(s: in out ucs4_vstring);
end aada_compiler_ucs4_string_normalized_uppercase;
20
Mar

AAda Compiler UCS4 Character

1
2
3
4
5
6
7
8
9
10
11
-- UCS-4 characters are the base type in the AAda Compiler base
-- (i.e. the lexer) It is the most practical type to handle any
-- Unicode character since Unicode allows characters from 0 to
-- 16#0010_FFFF#. Once the lexer is done, the characters are
-- transformed to UTF-8 and most of the remainder of the compiler
-- handles "regular" strings
--
-- By default, the AAda compiler accepts the Unicode range of
-- characters, but it can support 31 bit characters; all characters
-- are accepted except NUL (0) and any character that end with
-- 16#FFFE# and 16#FFFF#. The ucs4_character
13
Mar

AAda Character Categories

1
2
3
4
5
6
7
8
9
10
11
12
13
-- AAda Character Categories
-- This file was auto-generated, do not edit directly
with aada_compiler_ucs4_character;
use aada_compiler_ucs4_character;
 
package aada_character_categories is
  -- this categorization is limited to what is necessary to the
  -- compiler see section 2.1 for more info
  --  unknown -- characters that are not 'valid' or 'unnormalized'
  --  invalid -- a character that is not acceptable in an identifier
  --  letter -- see 2.1(8/2) Lu, 2.1(9/2) Ll, 2.1(9.1/2) Lt,
  --                2.1(9.2/2) Lm, 2.1(9.3/2) Lo, 2.1(10.1/2) Nl
  --  other -- see
24
Feb

AAda Compiler Configuration

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package aada_compiler_configuration is
  -- when you request the configuration path or something in the
  -- configuration folder, you get this exception if it somehow
  -- cannot find the information
  cannot_find_self_error: exception;
 
  -- function used to find the destination of a symbolic link
  procedure aada_readlink(path: in string; destination: out string; status: out integer);
 
  -- get a path to the configuration files of the compiler
  function aada_configuration_path return string;
 
--private
 
end aada_compiler_configuration;
8
Feb

AAda Compiler Parser Package

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
with aada_compiler_token_package;
with aada_text_input_package;
with aada_compiler_error_package;
 
package aada_compiler_parser_package is
  -- trying to unget too many tokens
  parser_unget_buffer_full_error: exception;
 
  type compiler_parser_type is limited private;
  type unget_index is range 0 .. 3;
 
  procedure next_token(p: in out compiler_parser_type;
                       t: out aada_compiler_token_package.compiler_token_type);
  procedure unget_token(p: in out compiler_parser_type;
                        t: in aada_compiler_token_package.compiler_token_type);
 
 
4
Feb

AAda Compiler Parser Expression

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
with aada_compiler_parser_package;
with aada_compiler_token_package;
with aada_compiler_node_package;
 
use aada_compiler_parser_package;
use aada_compiler_token_package;
use aada_compiler_node_package;
 
package aada_compiler_parser_expression is
 
procedure expression(p: in out compiler_parser_type;
                     t: in out compiler_token_type;
                     n: out compiler_node_handle);
 
-- i.e. <expr> .. <expr>
procedure expr_range(p: in out compiler_parser_type;
                     t: in out compiler_token_type;
                     n: out compiler_node_handle);
 
-- i.e. ...</expr></expr>
2
Feb

AAda Compiler Parser Pragma

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
with aada_compiler_parser_package;
with aada_compiler_token_package;
with aada_compiler_node_package;
 
use aada_compiler_parser_package;
use aada_compiler_token_package;
use aada_compiler_node_package;
 
package aada_compiler_parser_pragma is
 
procedure parse_pragma(p: in out compiler_parser_type;
                       t: in out compiler_token_type;
                       n: out compiler_node_handle);
 
--private
 
end aada_compiler_parser_pragma;
28
Jan

AAda Compiler Node Package

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
-- manage the node tree
with aada_compiler_token_package;
 
package aada_compiler_node_package is
 
  type compiler_node_index is range 0 .. 3;
  type compiler_node(children: compiler_node_index := 0) is limited private;
  type compiler_node_access is access compiler_node;
  type compiler_node_access_array is array(compiler_node_index range <>)
                                            of compiler_node_access;
  type compiler_node_handle is private;
 
  -- initialize the node token
  procedure init(node: in out compiler_node;
                 token: in ...</>