NAME

uniclient - execute aime programs against a TCP server

SYNOPSIS

uniclient [OPTIONS] PATH|PORT PROGRAM [ARGUMENT]...

DESCRIPTION

uniclient connects to a local TCP (UNIX) or a TCP/IP (INET) server and executes the PROGRAM. The local TCP server is assumed receiving connection requests on PATH while the TCP/IP server is assumed running on local host and PORT port.

uniclient executes programs written in aime, a C like programming language.

All the aime language and library features are available for executed programs.

The connection to the server is available for the programs as one read file (incoming, also aliased as is) and one write file (outgoing, also aliased as os).

Due to output buffering calling f_flush on the output connection may be required.

OPTIONS

-c

Execute the PROGRAM program instead the program read from the PROGRAM file.

-i, --inet

Connect to the INET server.

-n, --host HOST

Connect to the INET server at HOST. Default is the local host.

-u, --unix

Connect to the UNIX server (default).

--list

List available functions and exit with a status code indicating success.

--help

Print a usage message and exit with a status code indicating success.

--version

Print version information on standard output then exit.

PROGRAM SYNTAX

The interpreted syntax is much resembling the C syntax. It allows for prefix unary and common syntax binary operators, functions and variables. The supported types are the trivial cardinal (integral, positive), integer (integral), real (real) and text (string), along the complex date (calendar date), file (UNIX file), list (heterogenous collection) and time (duration). void is allowed for function type.

The C if, else, while, do while and break statements are supported, their syntax and semantics being pretty much the same as in C. An extra elif statement is borrowed from the C preprocessor, yet its syntax is C inspired. The opening and closing block braces are mandatory. The declarations must precede statements within a block. The variable initialization is disallowed.

A more formal syntax definition is:

program: block

block: declarations_section statements_section

declarations_section:

| declarations_line declarations_section

declarations_line: type name subsequent_name

;

subsequent_name:

| , name subsequent_name

statements_section:

| statement_line statements_section

statement_line: ;

| expression ;

| do { break_block } while ( expression ) ;

| if ( expression ) { block } elif_block_list else_block

| while ( expression ) { break_block }

elif_block_list:

| elif_block elif_block_list

elif_block: elif ( expression ) {

block }

else_block:

| else { block }

break_block: declarations_section

break_statements_section

break_statements_section:

| break_statement_line break_statements_section

break_statement_line: break ;

| statement_line

Functions and variables do not share the same name space, thus using a function name for a variable is allowed. The break, do, elif, if, else and while keywords and the cardinal, integer, real and text type names are however restricted for variable naming.

The expression syntax is much resembling the C expression syntax.

Most of prefix unary and common syntax binary C operators are supported (including unary !, +, - and ~ and binary *, /, %, +, -, <<, >>, <, >, !=, ==, &, ^, |, &&, ||, =, +=, -=, *=, /=, %=, &=, ^=, |=, <<= and >>=), the semantics and precedence being the same or at least very close to those of their C counterparts.

A secondary syntax allows for functions. Function definition syntax is much the C syntax. One main function, returning integer and having a void argument list, is expected.

The formal syntax definition is:

program: function subsequent_function

function: definition

| declaration

definition: void name ( arguments_list

) { block }

| type_other_than_void name ( arguments_list ) { block_return }

block_return: block return expression ;

declaration: type name ( arguments_bill

) ;

arguments_list: void

| variables_list

variables_list: variable subsequent_variable

variable: type reference_class name

arguments_bill: void

| positions_bill

positions_bill: position subsequent_position

position: type reference_class

| type reference_class name

reference_class:

| &

subsequent_variable:

| , variable subsequent_variable

subsequent_position:

| , position subsequent_position

subsequent_function:

| function subsequent_function

Functions may return no value, integer and real only (i.e. the return type of functions may only be one of cardinal, integer, real and void).

OUTPUT FUNCTIONS

Standard output formatting functions include:

void o_byte(integer c);

outputs the c code character

void o_integer(integer m);

outputs m

void o_real(integer d, real x);

outputs x with no more than d digits if d is not less than 0, does nothing otherwise

void o_text(text s);

outputs s

ERROR FUNCTIONS

Standard error formatting functions include:

void v_byte(integer c);

outputs the c code character

void v_integer(integer m);

outputs m

void v_real(integer d, real x);

outputs x with no more than d digits if d is not less than 0, does nothing otherwise

void v_text(text s);

outputs s

MISCELLANEOUS FUNCTIONS

Interpreter specific functions:

integer argc(void);

is the number of program arguments

text argv(void i);

is the i indexed program argument, the name of the program being the first

void exit(integer e);

terminates program execution

void sleep(integer s);

arranges for a s seconds sleep if s is greater than 0, does nothing otherwise

void usleep(integer u);

arranges for a u microseconds sleep if u is greater than 0, does nothing otherwise

RETURN VALUE

uniclient returns non zero for non successful program execution. For successful program execution uniclient returns the value of the exit argument if exit was called, the return of main for procedural programs and zero for non procedural programs otherwise.

SEE ALSO

aime(1), express17(1)

AUTHORS

Ciprian Niculescu