1.1. Introduction

main gtk_window_set_title SDL_SetVideoMode glPushMatrix define-abbrev-table

: <Person p> drives <Car c> (at <real speed = 50.0> { km/h | mph }) :

(Bob) drives (some car) ; (Bob) drives (Bob's car) at 60.0 mph

Dave drives some car at 150.0 km/h

1.2. Features

1.3. Why the name "Argile" ?

Argile means clay, which is often plastic and can take any shape. Since the main feature of Argile programming language is to be polymorphic, Clay would have been a well-suited name. However, this word is too common, and a Clay programming language already exists (according to web search engines).

4.1. Requirements

To compile argile compiler, you will need: GCC, GNU make, GNU bash.

To modify and/or recompile the argile compiler, you will also need: automake, autoconf, libtool, GNU bison, flex.

4.2. Extracting the sources

Start by extracting the source tree from the archive; in a terminal, type:

tar -xzvf /path/to/argile-2.1.0.tar.gz && cd ./argile-2.1.0

Then, either make a system-wide installation, or a user local home installation as follows;

4.3. User local home directory installation

First, compile by typing the following commands in a console or terminal:

./configure --prefix=$HOME && make

Optionally, you can recompile the compiler with itself (very slow) by typing:

make backup && make re

Then, install with the command:

make install

4.4. System-wide installation

First, compile by typing the following commands in a console or terminal:

./configure && make

Then, as administrator (super user or root), install with the command:

make install

(note: on MinGW or Cygwin, there is no need to be administrator)

4.5. Files installed (non-exhaustive list)

('/usr' should be replaced by the value you gave to the --prefix option of the configure script, if you did, or '/usr/local')

• The command line compiler:

  /usr/bin/arc

• A compilation dependency resolving script (needs GNU bash):

  /usr/bin/arc-make.sh

• Runtime library:

  /usr/lib/libargrt*

• Interfaces and C headers of runtime library modules:

  /usr/include/argile/argrt/*

• Detailed documentation files:

  /usr/share/doc/argile/*

• Emacs Lisp script of a major mode for Argile language:

  /usr/share/argile/argile.el

4.6. Testing the installation

arc --version

arc (Argile Compiler) version 2.1.0
Copyright (C) 2009,2010,2011,2014 the Argile authors
(see the AUTHORS file distributed along with this software).
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

arc --line='use std; print "Hello, world!"'

#include "/usr/include/argile/argrt/std.h"

int main(int argc, char **argv)
{
  printf("%s\n", "Hello, world!");
  return 0;
}

4.7. Uninstallation

In the source directory where you compiled argile, type:

make uninstall

and it will uninstall what it has installed (if you installed system-wide, you will need root privileges again)

5.1. Argile language reference

Language reference can be found here.

5.2. Installed documentation

This documentation is installed in PREFIX/share/doc/argile, where PREFIX is either /usr, your HOME directory, or any other value you gave to the --prefix= option of the configure script:

• Argile.txt : A limited description of Argile programming language
• home_dot_emacs_addon.txt : How to add support for Argile major mode in Emacs
• Using_std.txt : How to write an argile program using std.arg
• File_pathes.txt : Which files are loaded, how are they searched, ...
• How_to_distribute_argile_sources.txt : Describes how to distribute a portable software written in Argile, so that it can be compiled even if the Argile compiler and runtime is missing on the host system.

5.3. Embedded documentation

• Help on command line options:

  arc --help

  gives:

  Usage: arc [options...] [--] [file]
  Options help:
  -a --max-match-rec <max> : Limit syntax match depth; 0 = no limit (may take ages)
                             (default is 500)
  -A --add-dir       <dir> : Add directory to file path list
  -b --bind-doc     <name> : Finds documentation of binding (e.g std/print)
  -B --double-source-lines : Generate line numbers of both argile and C sources
  -c --max-comp-rec  <max> : Limit compilation depth; 0 = no limit (may take ages)
                             (default is 1000)
  -C --concat              : Concatenate main codes in main function
  -d --dump                : Dump precompiled code on stdout
  -D --debug-comp          : Dump compilation process
  -e --env-help            : Show the environment variables help
  -g --max-gen-rec   <max> : Limit gencode depth; 0 = no limit (may crash)
                             (default is 500)
  -G --get-defs   <syntax> : Get definitions matching syntax
  -h --help                : Show this help
  -H --header       <file> : Generate C Header in file
  -i --indent              : Code dumping is indentation-based
  -I --include-dir   <dir> : Add directory to system include path list
  -l --line <string>       : Parse string instead of file or stdin
  -L --source-lines        : Generate source line numbers for C preprocessor
  -m --module       <file> : Generate modularized argile header in file
  -M --no-main             : Generate NO main function
  -n --no-color            : Don't use colors (for errors and dumping)
  -N --no-auto-use         : Disable auto use file list
  -o --output       <file> : Generate C code in file instead of stdout
  -O --operators    <file> : Set extra operators file (see --extract-operators)
                             (each line is 1 or 2 hexadecimal numbers: start end)
  -p --deps         <file> : Generate Makefile dependencies in file
  -P --proto-syntax        : Generate syntax comment for functions prototypes
  -r --max-rejects   <max> : Limit reject history; 0 = no limit
                             (default is 5)
  -R --show-progress       : Show progress percentage during compilation
  -S --stats               : Print compilation statistics when dumping
  -t --col-per-tab  <cols> : Set number of columns per tabulation (default = 8)
  -T --daltonism           : Print symbols corresponding to colors (dumping)
  -u --utf8                : Use UTF-8 for column counting and $ARGILE_OPERATORS
  -U --use          <file> : Use file (preload)
  -v --verbose             : Print additional informations
  -V --version             : Show version information and exit
  -x --hexa-string         : Use hexadecimal sequences for non-ascii strings
  -X --extract-operators   : Get default extra operators file content
  

• Help on environment variables:

  arc --env-help

  gives:

  Environment variables help:
  ARGILE_AUTO_USE      : list of  files separated by ':' (see --use)
  ARGILE_COLOR         : 0 or 1 (opposite of --no-color)
  ARGILE_COLPERTAB     : integer (see --col-per-tab)
  ARGILE_DALTONISM     : 0 or 1 (see --daltonism)
  ARGILE_FILE_PATH     : list of pathes separated by ':' (see --add-dir)
  ARGILE_HEXASTR       : 0 or 1 (see --hexa-string)
  ARGILE_INDENT_STYLE  : 0 or 1 (see --indent)
  ARGILE_LINENUMS      : 0, 1 or 2 (see --source-lines and --double-source-lines)
  ARGILE_MAXCOMP       : integer (see --max-comp-rec)
  ARGILE_MAXGEN        : integer (see --max-gen-rec)
  ARGILE_MAXMATCH      : integer (see --max-match-rec)
  ARGILE_MAXREJECTS    : integer (see --max-rejects)
  ARGILE_OPERATORS_FILE: (see --operators and --extract-operators)
  ARGILE_OPERATORS     : string of additional operator characters (or ranges)
                         (ex: "!#-'*-/<-@[-`|~" : '-' sign delimits a range;
                          so  "<-@" means from '<' character to '@')
  ARGILE_UTF8          : 0 or 1 (see --utf8)
  HOME                 : when no ARGILE_FILE_PATH is set, $HOME/include/argile/
                         $HOME/include/argile/argrt/ , /usr/include/argile/ ,
                         /usr/include/argile/argrt/ and `./'
                         are also added to the file path.
  

• Documentation on bindings:

  arc --bind-doc "std/*"

  [gives this long result]

  arc --bind-doc std/print

  gives:

  ==========================
  std/print :
  ==========================
  Print its arguments without spaces between them using printf() and supports
  formatting for the basic types (int, nat, real, word, text, syntax);
  for other types, it prints a pointer address (%p format).
  It can also print spaces between arguments, if the bind option `spaced'
  is specified. If the bind option `error' is set, it will print on
  standard error rather than the default standard output.
  Only the first syntax parameter is considered, but it can be in a list.
  Syntax requirements
    :<any>:
    :[<any>...]:
  
  ==========================
  

5.4.1. Hello world

use std
print "hello, world!"
printf "Hello world\n"
echo Hello World "!"

5.4.2. Hello world without std.arg

print "Hello, world!"
bind :print [<anything> ... 1,]: to std/print
bind :anything: to std/anything

5.4.3. Overloading and definitions order

use std;

print x
let x = 0
print x
let x = 1
let x = 2
print x
let x = 3

(: this will print:
  0
  0
  2
:)

5.4.4. Arithmetics

use std

(: arith. operators macros priority results from their order in std.arg ;
   also, they use unions, so int/nat must be explicited :)
let int x = 1 + 3 * 4 / 2     (: 1 + ((3 * 4) / 2) :)

print x     (: prints 7 :)

let int y = (x * 2 + 3)
(:
  = (x) * (2 + 3) !!!! (x) is detected after (2+3) since
  it is shorter, and constant literals are immediately detected as such;
  so when doing arithmetics on non-constant, adding some parenthesis is
  good practice.
:)
let int y = (x * 2) + 3

5.4.5. Functions and Macros

use std
.:first function:. -> nat {
  let nat N = 13
  sub function
  sub function
  if N == 13
    return 1
  .:sub function:.
    a macro N
  =:a macro <nat &x>:= {x *= 2} (: takes a reference to a natural :)
  N
}
print first function
(: will print 52 :)

(actually, argile macros are some kind of inline functions)

When compiled, this generates the following C code:

#include "/usr/include/argile/argrt/std.h"

unsigned int first_function();

static void sub_function(unsigned int * N);

unsigned int first_function()
{
  unsigned int N = 13;

  sub_function(&N);
  sub_function(&N);
  if ((N == 13)) {
    return 1;
  } //;
  return N;
}

static void sub_function(unsigned int * N)
{
  *N *= 2;
}

int main(int argc, char **argv)
{
  printf("%u\n", first_function());
  return 0;
}

5.4.6. Classes

use std

class	Foobar
  int    i
  nat    n
  text   t
  Foobar f
(:
  In class code, calls are not compiled normally, the class binding
  of the std module wants them to match this syntax
  :<type> <word> (/<nat>):
  (the natural integer can be used to specify a bit size)
:)


(: some kind of method :)
.: <Foobar me>.increment :. {me.i++ ; me.n++ ; me.t++}

let Foobar@ F               (: @ is for raw value, rather than pointer :)
F.t = "some foobar text"
prints (F.i) (F.t) (F.f)
F.increment
prints (F.i) (F.t) (F.f)

class Dummy_Inherits_Foobar <- Foobar
  real r

let D = new Dummy_Inherits_Foobar
D.increment
prints D.r D.i
del D

class Kornholyo {any TP}

class :Manual Multi Inheritance: {
  Foobar@	foobar_parent
  Kornholyo@	kornholyo_parent
}
autocast Manual Multi Inheritance -> Foobar;
autocast Manual Multi Inheritance -> Kornholyo {
  Manual Multi Inheritance.kornholyo_parent (: it's not the first field :)
}

let Manual Multi Inheritance@ M
M.increment (: auto cast to Foobar :)
M.TP = nil  (: auto cast to Kornholyo :)

5.4.7. Some source code from Argile runtime library

• std.arg : Standard definitions
  • std.argl (library interface)
• array.arg : Arrays and pointers
  • array.argl (library interface)
• list.arg : Chained lists
  • list.argl (library interface)
• hash.arg : Hash tables
  • hash.argl (library interface)
• regex.arg : Regular expressions (POSIX)
  • regex.argl (library interface)
• math.arg : Math functions
  • math.argl (library interface)
• asm.arg : wrapper for GCC inline assembly
  • asm.argl (library interface)
• dbg.arg : Memory debugging functions
  • dbg.argl (library interface)