1aime(1) General Commands Manual aime(1)
2
6 aime - interpret programs
7
9 aime [OPTIONS] PROGRAM [TYPE NAME VALUE]...
10
12 aime executes PROGRAM. The TYPE NAME VALUE definitions introduce pro‐
13 gram accessible constants. TYPE may be one of cardinal (integral, pos‐
14 itive), integer (integral), real (real) and text (string).
15
17 -B, --reference-bail-out DUE
18 Stop reference tracing when determining reachability after DUE
19 examined links. The determination is attempted every time a
20 reference is removed. The objects deemed unreachable are
21 destroyed. The objects for which the determination cannot be
22 made in DUE reference examinations are recorded and their reach‐
23 ability status is determined later in a consolidated fashion. A
24 zero value for DUE instructs aime to make the determination
25 right away and no matter how many links need to be examined. A
26 non zero value makes the transition from proper immediate dis‐
27 posal to consolidated disposal. The default value for DUE is 4.
28 -D, --reference-bail-set SET
30 Clear bailed out references when they are SET many (the reacha‐
31 bility of objects recorded for later determination is triggered
32 when their number reaches SET).
33 -S, --initial INDEX
35 Start numbering lines when error reporting from INDEX. Default
36 is 1.
37 -W, --cpp COMMAND
39 Set source preprocessing command to COMMAND. The command reads
40 the standard input and writes standard output. The default
41 value is cpp. Alternatives known to work include gcc -E - and
42 mcpp.
43 -a Make program arguments available as argc() / argv() / args().
45 The program arguments will not be interpreted as TYPE NAME VALUE
46 triplets. See MISCELLANEOUS FUNCTIONS for more information.
47 -c Execute the PROGRAM program instead the program read from the
49 PROGRAM file.
50 -f, --framed
52 Expand function calls in a hierarchical fashion. Faster than
53 the default sequenced execution, the stack based execution can‐
54 not execute programs if the call stack gets too deep.
55 -p, --preprocess
57 Run source through the C preprocessor.
58 Comments in preprocessed sources should follow the preprocessor
60 comment syntax.
61 Source preprocessing is as of yet experimental. The preproces‐
63 sor error messages are dissimilar to the aime error messages.
64 -s, --sequenced
66 Execute program step by step, flattening the call hierarchy.
67 Slightly slower than the stack based execution, the sequenced
68 execution can execute programs no matter how deep the call stack
69 gets. Default.
70 --ignore-child-exits
72 Do not fail when child processes exit with a code other than 0.
73 Does not apply to processes waited via aime library routines,
74 like xs_spend.
75 --list List available functions and exit with a status code indicating
77 success.
78 --help Print a usage message and exit with a status code indicating
80 success.
81 --version
83 Print version information on standard output then exit.
84
86 The interpreted syntax is much resembling the C syntax. It allows for
87 prefix unary and common syntax binary operators, functions and vari‐
88 ables. The supported types include the immediate cardinal (integral,
89 positive), integer (integral), real (real) and text (string), along the
90 referable data (byte array), date (calendar date), file (UNIX file),
91 list (heterogenous sequence), record (string key heterogenous associate
92 table), time (duration), etc. void is allowed for function type.
93 The C if, else, while, do while and break statements are supported,
95 their syntax and semantics being pretty much the same as in C. An
96 extra elif statement is borrowed from the C preprocessor, yet its syn‐
97 tax is C inspired. The for statement is for collection traversals,
98 with its first iterator variable always indicating the position and the
99 optional second the data in that position. The opening and closing
100 block braces are mandatory. The declarations must precede statements
101 within a block. The variable initialization is disallowed.
102 A more formal syntax definition is:
104 program: block
106 block: declarations_section statements_section
108 declarations_section:
110 | declarations_line declarations_section
111 declarations_line: type name subsequent_name ;
113 subsequent_name:
115 | , name subsequent_name
116 statements_section:
118 | statement_line statements_section
119 statement_line: ;
121 | expression ;
122 | do { break_block } while ( expression ) ;
123 | if ( expression ) { block } elif_block_list else_block
124 | for ( variable1 [variable2] in collection ) { break_block }
125 | while ( expression ) { break_block }
126 elif_block_list:
128 | elif_block elif_block_list
129 elif_block: elif ( expression ) { block }
131 else_block:
133 | else { block }
134 collection: expression
136 break_block: declarations_section break_statements_section
138 break_statements_section:
140 | break_statement_line break_statements_section
141 break_statement_line: break ;
143 | statement_line
144 Functions and variables do not share the same name space, thus using a
146 function name for a variable is allowed. The break, do, elif, if, else
147 and while keywords and the cardinal, integer, real and text type names
148 are however restricted for variable naming.
149 The expression syntax is much resembling the C expression syntax.
151 Most of prefix unary and common syntax binary C operators are supported
153 (including unary !, +, - and ~ and binary *, /, %, +, -, <<, >>, <, >,
154 <=, >=, !=, ==, &, ^, |, &&, ||, =, +=, -=, *=, /=, %=, &=, ^=, |=, <<=
155 and >>=), the semantics and precedence being the same or at least very
156 close to those of their C counterparts.
157 A secondary syntax allows for functions. Function definition syntax is
159 much the C syntax. One main function, returning integer and having a
160 void argument list, is expected.
161 The formal syntax definition is:
163 program: function subsequent_function
165 function: definition
167 | declaration
168 definition: void name ( arguments_list ) { block }
170 | type_other_than_void name ( arguments_list ) { block_return }
171 arguments_list: void
173 | ...
174 | argument subsequent_argument
175 | argument subsequent_argument , ...
176 argument: type reference_class name
178 block_return: block return expression ;
180 declaration: type name ( positions_list ) ;
182 positions_list: void
184 | ...
185 | position subsequent_position
186 | position subsequent_position , ...
187 position: type reference_class
189 | type reference_class name
190 reference_class:
192 | &
193 subsequent_position:
195 | , position subsequent_position
196 subsequent_argument:
198 | , argument subsequent_argument
199 subsequent_function:
201 | function subsequent_function
202 Functions may return no value, integer and real only (i.e. the return
204 type of functions may only be one of cardinal, integer, real and void).
205
207 Standard output formatting functions include:
208 void o_byte(integer c);
210 outputs the c code character
211 void o_flush(void);
213 flushes standard output
214 void o_integer(integer m);
216 outputs m
217 void o_real(integer d, real x);
219 outputs x with no more than d digits if d is not less than 0,
220 does nothing otherwise
221 void o_text(text s);
223 outputs s
224
226 Standard error formatting functions include:
227 void v_byte(integer c);
229 outputs the c code character
230 void v_flush(void);
232 flushes standard error
233 void v_integer(integer m);
235 outputs m
236 void v_real(integer d, real x);
238 outputs x with no more than d digits if d is not less than 0,
239 does nothing otherwise
240 void v_text(text s);
242 outputs s
243
245 Interpreter specific functions:
246 integer argc(void);
248 is the number of program arguments.
249 text argv(integer i);
251 is the i indexed program argument, the name of the program being
252 the first. Negative indices are interpreted with respect to the
253 end of arguments list.
254 list args(integer i);
256 is a new list of the program arguments, starting with the i
257 indexed one. A 0 i gives all the arguments, including the pro‐
258 gram name. A 1 i has the latter skipped.
259 void exit(integer e);
261 terminates program execution, tells aime to exit e.
262 The argc(), argv(), args() functions are only available if so
264 requested, via the -a option.
265
267 aime waits for the child processes started through the process library,
268 etc.
269
271 aime returns non zero for non successful program execution. For suc‐
272 cessful program execution aime returns the value of the exit argument
273 if exit was called, the return of main for procedural programs and
274 zero for non procedural programs otherwise.
275
277 cpp(1), express17(1), gcc(1), mcpp(1)
278
280 Ciprian Niculescu
281 May 2019 aime(1)