#include <neo-c.h>

class sData
{
    int a;
    int b;
    
    void show()
    {
        printf("a %d b %d\n", self.a, self.b);
    }
};

class sData2 extends sData
{
    int c;
    
    void show()
    {
        printf("a %d b %d c %d\n", self.a, self.b, self.c);
    }
};

int main() 
{
    var data = new sData2 { a:123, b:234, c:345 };
    
    data.show();  // a 123 b 234 c 345
    
    puts("HO!" * 3);             // HO!HO!HO!\n

    return 0;
}

list<T>*% initialize(list<T>*% self);

var li = new list<int>.initialize();
li.add(1).add(2).add(3);

var li2 = new list<int>();
li2.add(1).add(2).add(3);

list<T>*% initialize_with_values(list<T>*% self, int num_value, T^* values) 

int values[3] = { 1, 2, 3 };

var li = new list<int>.initialize_with_values(3, values);

void finalize(list<T>* self) 

list<int>* li = borrow new list<int>();
li.add(1).add(2).add(3);
delete li;  // finalize is called. finalizeが呼ばれる

list<T>*% clone(list<T>* self)

var li = [1,2,3,4,5];
var li2 = clone li;   // cloneがよばれる

var li = [1,2,3,4,5];
var li2 = li;

var li = [1,2,3,4,5];
list<int>* li2 = borrow li;

list<T>* add(list<T>* self, T item)

var li = [s"ABC", s"DEF", s"GHQ"]:
li.add(s"OPQ");

T pop_front(list<T>* self) 

list<T>* push_back(list<T>* self, T item)

string to_string(list<T>* self)

    var li = ["ABC", "DEF", "GHQ"];
    puts(li.to_string());

T^ begin(list<T>* self) 
T^ next(list<T>* self) 
bool end(list<T>* self) 

list<T>* each(list<T>* self, void* parent, void (*block)(void*, T^,int,bool*)) 

    var li = ["ABC", "DEF", "GHI"];
    
    li.each {
        puts(it);
    }

T item(list<T>* self, int position, T default_value) 

    var li = ["ABC", "DEF", "GHI"];
    puts(li.item(0, null)); // ABC
    puts(li.item(-1, null)); // GHI
    puts(li.item(-9999, "")); // ""

int length(list<T>* self)

    var li = [1,2,3];
    puts(li.length().to_string()); // 3

list<T>* insert(list<T>* self, int position, T item)

    var li = [1,2,3];
    
    li.insert(1@position, 5@item); // [1,5,2,3]

list<T>* reset(list<T>* self) 

    var li = [1,2,3];
    
    li.reset();
    
    li.length().to_string().puts(); // 0

list<T>* remove(list<T>* self, T^ item, bool by_pointer=false);

    var li = [1,2,3];
    
    li.remove(3); // [1,2]
    
    li.to_string().puts();

list<T>* delete(list<T>* self, int head, int tail)

    var li = [1,2,3,4,5];
    
    li.delete(3,-1); // [1,2,3]
    li.delete(0,1); // [2,3];

list<T>* replace(list<T>* self, int position, T item)

    var li = [1,2,3,4,5];
    
    li.replace(1, 7); // [1,7,3,4,5]

int find(list<T>* self, T^ item, int default_value, bool by_pointer=false)

    var li = [1,2,3,4,5];
    
    li.find(3, -1@default_value); // 2

vector<T>*% to_vector(list<T>* self)

    var li = [1,2,3];
    var v = li.to_vector();
    v.to_string().puts(); // v[1,2,3]

bool equals(list<T>* left, list<T>* right)

    [1,2,3].equals([1,2,3]).to_string().puts(); // true

list<T>*% sublist(list<T>* self, int begin, int tail) 

    [1,2,3,4,5].sublist(0,2); // [1,2]
    [1,2,3,4,5].sublist(3,-1); // [4,5]
    [1,2,3,4,5].sublist(3,-2); // [4]

T operator_load_element(list<T>* self, int position) 

    var li = [1,2,3,4,5];
    
    printf("%d\n", li[3]); // 4
    printf("%d\n", li[-1]); // 5
    printf("%d\n", li[-9999]); // 0

void operator_store_element(list<T>* self, int position, T item) 

    var li = [1,2,3,4,5];
    
    li[0] = 123; // [123,2,3,4,5]

list<T>*% operator_load_range_element(list<T>* self, int begin, int tail) 

    var li = [1,2,3,4,5];
    
    li[0..2].to_string().puts(); // [1,2]
    li[3..-1].to_string().puts(); // [4,5]

bool operator_equals(list<T>* self, list<T>* right) 

    [1,2,3] === [1,2,3]; // true
    [1,2,2] === [1,2,3]; // false

bool operator_not_equals(list<T>* left, list<T>* right) 

    [1,2,3] !== [1,2,3]; // false
    [1,2,2] !== [1,2,3]; // true

bool contained(list<T>* self, T^ item, bool by_pointer=false);

    [1,2,3].contained(3); // true
    [1,2,3].contained(4); // false

list<T>*% merge_list_with_lambda(list<T>* left, list<T>* right, int (*compare)(T^,T^)) 
list<T>*% merge_sort_with_lambda(list<T>* self, int (*compare)(T^,T^)) 
list<T>*% sort_with_lambda(list<T>* self, int (*compare)(T^,T^)) 

    [3,7,2,5].sort_with_lambda(int lambda(int left, int right) {
        if(left < right) {
            return -1;
        }
        else if(left > right) {
            return 1;
        }
        else {
            return 0;
        }
        
        return 0;
    }); // [2,3,5,7]

list<T>*% merge_list(list<T>* left, list<T>* right) 
list<T>*% merge_sort(list<T>* self) 
list<T>*% sort(list<T>* self) 

    [3,7,2,5].sort(); // [2,3,5,7]

template<R> list<R>*% map(list<T>* self, void* parent, R (*block)(void*, T^))

    ["1","2","3"].map { atoi(it) }  // [1,2,3]

list<T>*% reverse(list<T>* self) 

    [1,2,3].reverse(); // [3,2,1]

list<T>*% uniq(list<T>* self, bool by_pointer=false);

    [8,8,2,2,3,3].uniq(); // [8,2,3]

list<T>*% filter(list<T>* self, void* parent, bool (*block)(void*, T^))

    [1,2,3,4,5].filter { it > 2 };  // [3,4,5]

    var li = [1,2,3,4,5].filter { it % 2 == 1 };

    li.count();                          // 3
    li.any { it == 3 };                 // true
    li.all { it < 6 };                  // true
    li.position(-1) { it == 3 };        // 1
    li.find_value(-1) { it > 3 };       // 5
    li.nth(-1, -1);                     // 5
    li.last(-1);                        // 5
    li.sum();                           // 9
    li.product();                       // 15
    li.min(-1);                         // 1
    li.max(-1);                         // 5

list<T>*% operator_add(list<T>*% left, list<T>*% right) 

    [1,2,3] + [4,5]; // [1,2,3,4,5]

list<T>*% operator_mult(list<T>* left, int right) 

    [1,2,3] * 2; // [1,2,3,1,2,3]

string join(list<T>* self, char* sep=" ") 

    [1,2,3].join("+");    // 1+2+3

var v = v[1,2,3];
v.to_string().puts();   // v[1,2,3]

vector<T>*% initialize(vector<T>*% self);

var v = new vector<int>.initialize();
v.add(1).add(2).add(3);

var v2 = new vector<int>();
v2.add(1).add(2).add(3);

vector<T>*% initialize_with_values(vector<T>*% self, int num_value, T^* values)

int values[3] = { 1, 2, 3 };

var v = new vector<int>.initialize_with_values(3, values);
var v2 = v[1,2,3];

void finalize(vector<T>* self)

vector<int>* v = borrow new vector<int>();
v.add(1).add(2).add(3);
delete v;  // finalize is called. finalizeが呼ばれる

vector<T>*% clone(vector<T>* self)

var v = new vector<int>.initialize();
v.add(1).add(2).add(3);

var v2 = clone v;

vector<T>* add(vector<T>* self, T item)

var v = new vector<int>();
v.add(1).add(2).add(3);

T item(vector<T>* self, int index, T default_value)

int values[3] = { 10, 20, 30 };
var v = new vector<int>.initialize_with_values(3, values);

printf("%d\n", v.item(0, 0));   // 10
printf("%d\n", v.item(-1, 0));  // 30
printf("%d\n", v.item(99, -1)); // -1

bool equals(vector<T>* left, vector<T>* right)

var v = new vector<int>();
v.add(1).add(2).add(3);

var v2 = new vector<int>();
v2.add(1).add(2).add(3);

v.equals(v2).to_string().puts();   // true

void replace(vector<T>* self, int index, T value)

int values[3] = { 1, 2, 3 };
var v = new vector<int>.initialize_with_values(3, values);

v.replace(1, 7);   // v[1,7,3]
v.replace(-1, 9);  // v[1,7,9]

int find(vector<T>* self, T^ item, int default_value)

int values[5] = { 1, 2, 3, 4, 5 };
var v = new vector<int>.initialize_with_values(5, values);

printf("%d\n", v.find(3, -1));   // 2
printf("%d\n", v.find(99, -1));  // -1

int values[4] = { 1, 2, 3, 4 };
var v = new vector<int>.initialize_with_values(4, values);

printf("%d\n", v.count());                    // 4
printf("%d\n", v.position(-1) { it == 3 });  // 2
printf("%d\n", v.last(-1));                  // 4
printf("%d\n", v.sum());                     // 10

int length(vector<T>* self)

int values[3] = { 1, 2, 3 };
var v = new vector<int>.initialize_with_values(3, values);

printf("%d\n", v.length());   // 3

int alloc_size(vector<T>* self)

int values[3] = { 1, 2, 3 };
var v = new vector<int>.initialize_with_values(3, values);

printf("%d\n", v.alloc_size());

void reset(vector<T>* self)

int values[3] = { 1, 2, 3 };
var v = new vector<int>.initialize_with_values(3, values);

v.reset();
printf("%d\n", v.length());   // 0

T^ begin(vector<T>* self)
T^ next(vector<T>* self)
bool end(vector<T>* self)

T operator_load_element(vector<T>* self, int position)

int values[5] = { 1, 2, 3, 4, 5 };
var v = new vector<int>.initialize_with_values(5, values);

printf("%d\n", v[0]);      // 1
printf("%d\n", v[-1]);     // 5
printf("%d\n", v[9999]);   // 0

void operator_store_element(vector<T>* self, int index, T item)

int values[3] = { 1, 2, 3 };
var v = new vector<int>.initialize_with_values(3, values);

v[0] = 123;   // v[123,2,3]

vector<T>*% operator_load_range_element(vector<T>* self, int begin, int tail)

int values[5] = { 1, 2, 3, 4, 5 };
var v = new vector<int>.initialize_with_values(5, values);

v[0..2].to_string().puts();   // v[1,2]
v[3..-1].to_string().puts();  // v[4,5]

bool operator_equals(vector<T>* left, vector<T>* right)

int a[3] = { 1, 2, 3 };
int b[3] = { 1, 2, 3 };
int c[3] = { 1, 2, 4 };

var v1 = new vector<int>.initialize_with_values(3, a);
var v2 = new vector<int>.initialize_with_values(3, b);
var v3 = new vector<int>.initialize_with_values(3, c);

printf("%s\n", (v1 === v2).to_string());   // true
printf("%s\n", (v1 === v3).to_string());   // false

bool operator_not_equals(vector<T>* left, vector<T>* right)

int a[3] = { 1, 2, 3 };
int b[3] = { 1, 2, 4 };

var v1 = new vector<int>.initialize_with_values(3, a);
var v2 = new vector<int>.initialize_with_values(3, b);

printf("%s\n", (v1 !== v2).to_string());   // true

vector<T>*% operator_add(vector<T>* left, vector<T>* right)

int a[2] = { 1, 2 };
int b[2] = { 3, 4 };

var v1 = new vector<int>.initialize_with_values(2, a);
var v2 = new vector<int>.initialize_with_values(2, b);

(v1 + v2).to_string().puts();   // v[1,2,3,4]

vector<T>*% operator_mult(vector<T>* left, int n)

int a[2] = { 1, 2 };
var v = new vector<int>.initialize_with_values(2, a);

(v * 3).to_string().puts();   // v[1,2,1,2,1,2]

vector<T>* sort_with_lambda(vector<T>* self, int (*compare)(T^, T^))

int values[4] = { 3, 7, 2, 5 };
var v = new vector<int>.initialize_with_values(4, values);

v.sort_with_lambda(int lambda(int left, int right) {
    if(left < right) {
        return -1;
    }
    else if(left > right) {
        return 1;
    }
    else {
        return 0;
    }
});

vector<T>* sort(vector<T>* self)

int values[4] = { 3, 7, 2, 5 };
var v = new vector<int>.initialize_with_values(4, values);

v.sort().to_string().puts();   // v[2,3,5,7]

string to_string(vector<T>* self)

int values[3] = { 1, 2, 3 };
var v = new vector<int>.initialize_with_values(3, values);

v.to_string().puts();   // v[1,2,3]

span<T*>*% to_span(vector<T>* self)

int values[3] = { 1, 2, 3 };
var v = new vector<int>.initialize_with_values(3, values);
var s = v.to_span();
printf("%d\n", s[1]);   // 2

map<T,T2>*% initialize(map<T,T2>*% self)

var ma = new map<char*,int>();
ma.insert("AAA", 1);
ma.insert("BBB", 2);
ma.insert("CCC", 3).insert("DDD", 4);

map<T,T2>*% initialize_with_values(map<T,T2>*% self, int num_keys, T^* keys, T2^* values) 

void finalize(map<T,T2>* self)

map<T, T2>*% clone(map<T, T2>* self)

string to_string(map<T,T2>* self)

T2 at(map<T, T2>* self, T^ key, T2 default_value, bool by_pointer=false);

map<T,T2>* remove(map<T, T2>* self, T key, bool by_pointer=false);

T^ begin(map<T, T2>* self)
T^ next(map<T, T2>* self) 
bool end(map<T, T2>* self) 

var ma = [3:30, 1:10, 4:40];

printf("%d\n", ma.count());                    // 3
printf("%d\n", ma.position(-1) { it == 1 });  // 1
printf("%d\n", ma.last(-1));                  // 4
printf("%d\n", ma.sum());                     // 8

void rehash(map<T,T2>* self) 

map<T,T2>* insert(map<T,T2>* self, T key, T2 item, bool by_pointer=false);
map<T,T2>* put(map<T,T2>* self, T key, T2 item, bool by_pointer=false);

T2 operator_load_element(map<T, T2>* self, T^ key) 

void operator_store_element(map<T, T2>* self, T key, T2 item) 

bool equals(map<T, T2>* left, map<T, T2>* right)

bool operator_equals(map<T, T2>* left, map<T,T2>* right) 

bool operator_not_equals(map<T, T2>* left, map<T,T2>* right) 

bool find(map<T, T2>* self, T^ key, bool by_pointer=false);

map<T,T2>*% operator_add(map<T,T2>* left, map<T,T2>* right) 

map<T,T2>*% operator_mult(map<T,T2>* left, int right) 

list<T>*% keys(map<T, T2>* self)

list<T2>*% values(map<T, T2>* self) 

vector<T>*% to_vector(map<T, T>* self)

    var ma = [1:10, 2:20, 3:30];
    ma.to_vector().to_string().puts(); // v[1,10,2,20,3,30]

buffer*% buffer*::initialize(buffer*% self);

void buffer*::finalize(buffer* self);

buffer*% buffer*::clone(buffer* self);

int buffer*::length(buffer* self);

void buffer*::reset(buffer* self);

void buffer*::trim(buffer* self, int len);

buffer* buffer*::append(buffer* self, char* mem, size_t size);

buffer* buffer*::append_char(buffer* self, char c);
buffer* buffer*::append_str(buffer* self, char* str);
buffer* buffer*::append_nullterminated_str(buffer* self, char* str);
buffer* buffer*::append_int(buffer* self, int value);
buffer* buffer*::append_long(buffer* self, long value);
buffer* buffer*::append_short(buffer* self, short value);

buffer* buffer*::alignment(buffer* self);

int buffer*::compare(buffer* left, buffer* right);

buffer*% string::to_buffer(char* self);
buffer*% char*::to_buffer(char* self);

string buffer*::to_string(buffer* self);

static inline buffer*% char[]::to_buffer(char* self, size_t len) ;
static inline buffer*% short[]::to_buffer(short* self, size_t len) ;
static inline buffer*% int[]::to_buffer(int* self, size_t len) ;
static inline buffer*% long[]::to_buffer(long* self, size_t len) ;
static inline buffer*% float[]::to_buffer(float* self, size_t len) ;
static inline buffer*% double[]::to_buffer(double* self, size_t len) ;

    char a[4] = { 'A', 'B', 'C', '\0' };
    
    var buf = a.to_buffer(4);
    
    puts(buf.to_string()); // ABC

static inline list<char>*% char[]::to_list(char* self, size_t len) ;
static inline list<short>*% short[]::to_list(short* self, size_t len) ;
static inline list<int>*% int[]::to_list(int* self, size_t len) ;
static inline list<long>*% long[]::to_list(long* self, size_t len) ;
static inline list<float>*% float[]::to_list(float* self, size_t len) ;
static inline list<double>*% double[]::to_list(double* self, size_t len) ;

    int a[3] = { 3, 2, 1 };
    
    a.to_list(3).sort().each {
        printf("%d\n", it);
    }

int string::length(char* str);

int char*::length(char* str);

string char*::substring(char* str, int head, int tail);
string string::substring(char* str, int head, int tail);

string string::operator_load_range_element(char* str, int head, int tail);
string char*::operator_load_range_element(char* str, int head, int tail);

string char*::reverse(char* str) ;
string string::reverse(char* str) ;

string xsprintf(char* msg, ...);

static inline string string::xsprintf(char* self, char* msg, ...)
static inline string char*::xsprintf(char* self, char* msg, ...)

static inline string int::xsprintf(int self, char* msg, ...)

string char*::delete(char* str, int head, int tail) ;
string string::delete(char* str, int head, int tail);

list<string>*% string::split_char(char* self, char c) ;
list<string>*% char*::split_char(char* self, char c);

    s"A,B,C".split_char(','); // [A,B,C]

string xrealpath(char* path);

xrealpath("/aaa/../bbb"); // /bbb

string xbasename(char* path);

string xextname(char* path);

string xdirname(char* path);

string xnoextname(char* path);

int FILE*::write(FILE* f, char* str);

string FILE*::read(FILE* f);

int FILE*::fclose(FILE* f) ;

int* FILE*::fprintf(FILE* f, const char* msg, ...);

list<string>*% FILE*::readlines(FILE* f);

int string::write(char* self, char* file_name, bool append=false);
int char*::write(char* self, char* file_name, bool append=false) ;

string char*::read(char* file_name) ;
string string::read(char* file_name) ;

    "ABC".write("FILE-NAME", append:true);
    "ABC".write("FILE-NAME", append:true);
    "ABC".write("FILE-NAME", append:true);
    
    "FILE-NAME".read().puts(); // ABC\nABC\nABC

#include<stdio.h>

int fun(int x = 123, int y = 345, int z = 456) 
{
    printf("x %d y %d z %d\n", x, y, z);
}

struct sData 
{
    int x;
    int y;
    int z;
};

int sData*::fun(sData* self, int x = 123, int y = 345, int z = 456)
{
    self.x = x;
    self.y = y;
    self.z = z;
}

void sData*::show(sData* self)
{
    printf("x %d y %d z %d\n", self.x, self.y, self.z);
}

int main(int argc, char** argv) 
{
    fun();           // x 123 y 345 z 456 are outputed
    fun(y:2);        // x 123 y 2 z 456
    
    fun(y:1, x:3);   // x 3 y 1 z 456
    
    fun(1);          // x 1 y 345 z 456
    fun(1,2);        // x 1 y 2 z 456
    
    sData data;
    (&data).fun(1,2,3);
    (&data).show();   // x 123 y 345 z 456
    
    (&data).fun(y:2); // x 123 y 2 z 456
    (&data).show();   // x 123 y 2 z 456
    
    (&data).fun(1);
    (&data).show();   // x 1 y 345 z 456
    
    return 0;
}

string char*::operator_mult(char* str, int n);
string string::operator_mult(char* str, int n);
bool char*::operator_equals(char* left, char* right);
bool string::operator_equals(char* left, char* right);

    "ABC" * 3  // => "ABCABCABC"
    [1,2] * 3  // => [1,2,1,2,1,2]
    "ABC" === "ABC" // => true
    "ABC !== "DEF" // => true
    [1,2] + [3] // => [1,2,3]
    
    auto ma1 = ["AAA":1, "BBB":2]
    
    xassert("map test", ma1["AAA"] == 1)
    ma1["CCC"] = 3

+ operator_add
- operator_sub
* operator_mult
/ operator_div
% operator_mod
=== operator_equals
!== operator_not_equals
> operator_gt
>= operator_gteq
< operator_le
<= operator_leeq
[x] = y operator_store_element
[x]  operator_load_element
! operator_logical_denial
<< operator_left_shift
>> operator_right_shift
& operator_and
^ operator_xor
| operator_or
~ operator_commplement

#include <stdio.h>

int fun(char* str) version 1
{
    puts(str);
    return 1;
}

int fun(char* str) version 2
{
    int n = inherit(str);

    return n + 1;
}

int fun(char* str) version 3
{
    int n = inherit(str);

    return n + 1;
}

int main()
{
    if(fun("HELLO MIXIN-LAYERS") == 3) {
        puts("OK");
    }

    return 0;
}

int fun(bool flag) 
{
    if(flag) {
        puts("TRUE");
    }
    else {
        puts("FALSE");
    }
}

int main()
{
    fun(false@flag);

    return 0;
}

#include <neo-c.h>

int, string fun(int n, string m) 
{
    return t(n, m);
}

int main(int argc, char** argv)
{
    var n, m = fun(1, string("AAA"));
    
    printf("n %d m %s\n", n, m);
    
    return 0;
}

#include <neo-c.h>

interface sBase
{
    void show();
};

struct sChildA
{
    int x;
    int y;
    int z;
    string str;
}

sChildA*% sChildA*::initialiize(sChildA*% self)
{
    self.x = 1;
    self.y = 2;
    self.z = 3;
    self.str = string("ABC");
    
    return self;
}

void sChildA*::show(sChildA* self)
{
    printf("x %d y %d z %d str %s\n", self.x, self.y, self.z, self.str);
}

struct sChildB
{
    int X;
    int Y;
    int Z;
};

sChildB*% sChildB*::initialize(sChildB*% self)
{
    self.X = 111;
    self.Y = 222;
    self.Z = 333;
    
    return self;
}

void sChildB*::show(sChildB* self)
{
    printf("X %d Y %d Z %d\n", self.X, self.Y, self.Z);
}

int main(int argc, char** argv)
{
    list<sBase*%>*% li = new list<sBase*%>();
    
    li.add(new sChildA() implements sBase);
    li.add(new sChildB() implements sBase);
    
    foreach(it, v) {
        it.show();
    }
    
    return 0;
}

#include <neo-c.h>

int main(int argc, char** argv)
{
    FILE* f = fopen("NOTHING", "r") or die("file not found");
    
    return 0;
}

#include <neo-c-str.h>

#include <neo-c.h>

int main()
{
    xassert("char_match test", "ABC".match("A"));
    xassert("char_index test", "ABC".index("B", -1) == 1);
    xassert("char_rindex test", "ABCABC".rindex("B", -1) == 4);
    xassert("char_index_regex", "ABC".index_regex("B", -1) == 1);
    xassert("char_rindex_regex", "ABCABC".rindex_regex("B", -1) == 4);

    string str = string("ABC");

    str.replace(1, 'C');

    xassert("char_replace", str === "ACC"))
    xassert("char_multiply", "ABC".multiply(2) === "ABCABC");

    xassert("char_sub", "ABC".sub("B", "C" === "ACC");

    auto li = "ABC".scan(".");

    xassert("char_scan", li[0] === "A" && li[1] === "B" && li[2] === "C");

    auto li2 = "A,B,C".split(",");

    xassert("char_split", li2[0] === "A" && li2[1] === "B" && li2[2] == "C");

    auto li3 = "A,B,C".split_char(',');

    xassert("char_split_char", li3[0] === "A" && li3[1] === "B" && li3[2] === "C");
    
    auto li4 = "A,,B,,C".split_str(",,");

    xassert("char_split_str", li4[0] === "A" && li4[1] === "B" && li4[2] === "C");
    
    xassert("char_delete", "ABC".delete(0,1) === "BC);

    xassert("wchar_substring", wstring("ABC").substring(0,1) === wstring("A"));
    
    auto li6 = "A,B,C".split_str(",");
    
    xassert("join", li6.join(" ") === "A B C");
    
    auto li7 = "A,B,C".split(",");
    
    xassert("split test", li7[0] === "A" && li6[1] === "B" && li7[2] === "C");
    xassert("rindex_regex test", "ABCABC".rindex_regex("CBA", -1) == 5);
    xassert("sub_block test", "ABCABCABC".sub_block("ABC") { string("X"); } === "XXX");
    xassert("scan_block test", "123 456 789".scan_block("[0-9][0-9][0-9]") { it.substring(0, 1); }.join("") === "147");
    
    auto li8 = "ABC".scan(".");
    
    xassert("scan test", li8[0] === "A" && li8[1] === "B" && li8[2] === "C");
    
    var bufX = "ABC".to_buffer();
    bufX.append_str("DEF");
    
    xassert("to_buffer test", bufX.to_string() === "ABCDEF");
    xassert("split block test", "ABC,DEF,GHI".split_block(",") { it.substring(0,1); }.join("") === "ADG");
    xassert("regex test", "ABC".scan(".").join("") === "ABC");
    
    xassert("regex equals test", "aaa" === "aaa");
    
    return 0;
}

#include <neo-c-str.h>

int main()
{
    string a = xsprintf("%s %d", "value", 10);
    puts(a);
    
    return 0;
}

int char*::length(const char* str);
string char*::substring(const char* str, int head, int tail);
string char*::delete(char* str, int head, int tail);
string char*::reverse(const char* str);
string char*::printable(char* str);
string char*::sub_plain(char* self, char* str, char* replace);

#include <neo-c-str.h>

int main()
{
    puts("ABCDE".substring(1, 4));   // BCD
    puts("ABCDE".substring(-3, -1)); // CD
    puts("ABCDE".delete(1, 3));      // ADE
    puts("ABC".reverse());           // CBA
    puts("A\tB\n".printable());      // A\tB\n
    puts("abcabc".sub_plain("ab", "XY")); // XYcXYc
    
    return 0;
}

bool char*::match(char* self, const char* reg, bool ignore_case=false);
int char*::index_regex(const char* self, const char* reg, int default_value=-1, bool ignore_case=false);
int char*::rindex_regex(const char* self, const char* reg, int default_value=-1, bool ignore_case=false);
list<string>*% char*::scan(const char* self, const char* reg, bool ignore_case=false);
list<string>*% char*::split(const char* self, const char* reg, bool ignore_case=false);
list<string>*% char*::split_str(const char* self, const char* str);
list<string>*% char*::split_char(char* self, char c);
string char*::sub(char* self, const char* reg, const char* replace, bool global=true, bool ignore_case=false);
string char*::sub_block(char* self, const char* reg, bool global=true, bool ignore_case=false, void* parent, string (*block)(void* parent, char* match_string, list<string>* group_strings));
list<string>*% char*::scan_block(const char* self, const char* reg, bool ignore_case=false, void* parent, string (*block)(void* parent, char* match_string, list<string>* group_strings));