include_c "stdlib.h";

/* Conversion functions */

extern "C" fun i2s(int i) -> string@;
extern "C" fun s2i(string s) -> int@;

extern "C" fun f2s(float f) -> string@;
extern "C" fun s2f(string s) -> float@;

extern "C" fun d2s(double f) -> string@;
extern "C" fun s2d(string s) -> double@;

extern "C" fun print(string s);
extern "C" fun fprint(string f, string s);

extern "C" fun f2d(float f) -> double@;
extern "C" fun d2f(double d) -> float@;

extern "C" fun i2d(int i) -> double@;
extern "C" fun d2i(double i) -> int@;
extern "C" fun i2f(int i) -> float@;
extern "C" fun f2i(float i) -> int@;

primitive +(int,int) -> int@;
primitive +(short,short) -> short@;
primitive +(float,float) -> float@;
primitive +(double,double) -> double@;

extern "C" fun str_cat(string,string) -> string@;

primitive -(int,int) -> int@;
primitive -(short,short) -> short@;
primitive -(float,float) -> float@;
primitive -(double,double) -> double@;

primitive *(int,int) -> int@;
primitive *(short,short) -> short@;
primitive *(float,float) -> float@;
primitive *(double,double) -> double@;

primitive /(int,int) -> int@;
primitive /(short,short) -> short@;
primitive /(float,float) -> float@;
primitive /(double,double) -> double@;

primitive %(int,int) -> int@;
primitive %(short,short) -> short@;

primitive negate(int) -> int@;
primitive negate(short) -> short@;
primitive negate(float) -> float@;
primitive negate(double) -> double@;

primitive >>(int,int) -> int@;
primitive <<(int,int) -> int@;

primitive .*<T>(T*) -> T!;
primitive .*<T>(T const*) -> T;

primitive &<T>(T) -> T const*@;
primitive &<T>(T!) -> T*@;

primitive ++<T>(T*!) -> T*!;
primitive ++(int!) -> int!;

primitive --<T>(T*!) -> T*!;
primitive --(int!) -> int!;

primitive +<T>(T*,int) -> T*@;
primitive -<T>(T*,int) -> T*@;
primitive -<T>(T*,T*) -> int@;

primitive []<T>(T const*,int) -> T;
primitive []<T>(T*,int) -> T!;

primitive ==(int,int) -> bool@;
primitive ==(short,short) -> bool@;
primitive ==(float,float) -> bool@;
primitive ==(double,double) -> bool@;
primitive ==(bool,bool) -> bool@;
primitive ==(char,char) -> bool@;
primitive ==<T>(T*,T*) -> bool@;
extern "C" fun str_eq(string,string) -> bool@;

primitive !=(int,int) -> bool@;
primitive !=(short,short) -> bool@;
primitive !=(float,float) -> bool@;
primitive !=(double,double) -> bool@;
primitive !=(bool,bool) -> bool@;
primitive !=(char,char) -> bool@;
primitive !=<T>(T*,T*) -> bool@;
extern "C" fun str_neq(string,string) -> bool@;

primitive <(int,int) -> bool@;
primitive <(short,short) -> bool@;
primitive <(float,float) -> bool@;
primitive <(double,double) -> bool@;
primitive <(bool,bool) -> bool@;
primitive <(char,char) -> bool@;
primitive < <T>(T*,T*) -> bool@;

primitive <=(int,int) -> bool@;
primitive <=(short,short) -> bool@;
primitive <=(float,float) -> bool@;
primitive <=(double,double) -> bool@;
primitive <=(bool,bool) -> bool@;
primitive <=(char,char) -> bool@;
primitive <= <T>(T*,T*) -> bool@;

primitive >(int,int) -> bool@;
primitive >(short,short) -> bool@;
primitive >(float,float) -> bool@;
primitive >(double,double) -> bool@;
primitive >(bool,bool) -> bool@;
primitive >(char,char) -> bool@;
primitive > <T>(T*,T*) -> bool@;

primitive >=(int,int) -> bool@;
primitive >=(short,short) -> bool@;
primitive >=(float,float) -> bool@;
primitive >=(double,double) -> bool@;
primitive >=(bool,bool) -> bool@;
primitive >=(char,char) -> bool@;
primitive >= <T>(T*,T*) -> bool@;

primitive and(bool,bool) -> bool@;
primitive or(bool,bool) -> bool@;
primitive not(bool) -> bool@;

primitive =<T>(T*!,T*) -> T*!;
primitive =(int!,int) -> int!;
primitive =(short!,short) -> short!;
primitive =(float!,float) -> float!;
primitive =(double!,double) -> double!;
primitive =(char!,char) -> char!;
primitive =(string!,string) -> string!;
/* What about function objects? Shoot, have to special case those? */
fun __assign += primitive =;
/* Don't want to add totally generic version of primitive assignment,
   so this comes after the addition to the overloads for __assign. */
primitive =<T>(T!,T) -> T!;

/* Default Constructing */
primitive @<T>() -> T@;
primitive new<T>() -> T*@;
primitive new GC<T>() -> T*@;

/* Placement Default Constructing */
primitive placement_new <T>(void*) -> T*@;

/*primitive new @[]<T>(int) -> T*@;*/
primitive new[]<T>(int) -> T*@;
primitive new GC[]<T>(int) -> T*@;

/* Copy Constructing */
primitive @<T>(T) -> T@;
primitive new<T>(T) -> T*@;
primitive new GC<T>(T) -> T*@;

/* Placement Copy Constructing */
primitive placement_new<T>(void*,T) -> T*@;

primitive delete<T>(T*);
primitive destroy<T>(T*);

primitive cast<T>(...) -> T!;

primitive sizeof<T>(T) -> size_t@;
primitive sizeof<T>() -> size_t@;

fun __input += primitive>>;
fun __output += primitive<<;
fun __add += primitive +;
fun __add += str_cat;
fun __increment += primitive ++;
fun __decrement += primitive --;
fun __sub += primitive -;
fun __star += primitive *;
fun __div += primitive /;
fun __mod += primitive %;
fun __sub += primitive negate;
fun __star += primitive .*;
fun __equal += primitive ==;
fun __equal += str_eq;
fun __not_equal += primitive !=;
fun __not_equal += str_neq;
fun __less_than += primitive <;
fun __less_equal += primitive <=;
fun __greater_than += primitive >;
fun __greater_equal += primitive >=;
fun __arrayelt += primitive [];
fun __and += primitive and;
fun __or += primitive or;
fun __not += primitive not;
fun __addressof += primitive &;


/* Builtin concepts and models */

concept DefaultConstructible<U>
{
  fun new_on_stack() -> U@;
  fun new_on_heap() -> U*@;
  fun new_on_gc() -> U*@;
  fun new_placement(void*) -> U*@;
  fun new_array_on_heap(int n) -> U*@;
  fun new_array_on_gc(int n) -> U*@;
};

concept Regular<T>
{
  fun operator =(T!,T) -> T!;
  fun new_on_stack(T) -> T@;
  fun new_on_heap(T) -> T*@;
  fun new_on_gc(T) -> T*@;
  //  fun new_placement(void*, T) -> T*@;
  fun cleanup(T*);
  fun wipeout(T*);
};

concept SizeOf<T>
{
  fun size_of() -> size_t@;
};
concept AddressOf<T>
{
  fun __addressof(T!) -> T*@;
  fun __addressof(T) -> T const*@;
};

concept POD<T> {};