Introduction

C-Talk support integer, real, string, associative array, thread and mutex types. There is no structures, classes, unions and pointers. Structures can be emulated by associative array, for example the expression x.foo is equivalent to x["foo"] and access element of associative array with key "foo".

C-Talk provides very simple interface with C and C++. Programmer can easily define various primitives which can be called from the C-Talk as normal functions.

C-Talk is intented to be used in the same area as Perl, VB-Script, Java-Script languages. It is for the people who are familiar with C and prefer it's syntax to something else. The other advantage of C-Talk is that it is open source free software. It is distributed under MIT license - almost no restrictions on using this language in any project (unlike GPL). Also C-Talk is very simple and compact language, only - 6000 lines of code. It very simple to extend the language with new primitives and types needed for your application.

Syntax

program: import-list {stmt}
import-list: "import" module {"," module}
module: identifier
func-def: "function" func-name "(" params-list ")" block-stmt
func-name: identifier
params-list: empty | intentifier { "," intentifier }
stmt: ";" | expr ";" | block-stmt
      | while-stmt | do-while-stmt | for-stmt | if-stmt | break-stmt | continue-stmt 
      | return-stmt | throw-stmt | try-catch-stmt 
while-stmt: "while" "(" condition ")" stmt
do-while-stmt: "do" stmt "while" "(" condition ")" ";"
for-stmt: "for" "(" opt-expr ";" opt-expr ";" opt-expr ")" stmt
if-stmt: "if" "(" condition ")" stmt ["else" stmt]
condition: expr
opt-expr: empty | expr
break-stmt: "break" ";"
continue-stmt: "continue" ";"
throw-stmt: "throw" expr ";"
return-stmt: "return" opt-expr ";"
try-catch-stmt: "try" stmt "catch" "(" exception-var ")" stmt
exception-var: identifier
block-stmt: "{" { stmt } "}"
expr: literal | func-call | start-thread  | binary-expr | unary-expr | 
      "(" expr ")" | | variable | index-expr | env-var
literal: string | integer | real | array-constructor
variable: identifier
index-expr: expr "[" expr "]" | expr "." identifier
env-var: "$" identifier
array-constructor: "[" empty | array-elem { "," array-elem } "]" 
array-elem: expr ":" expr
func-call: expr "(" expr-list ")"
start-thread: "par" func-call
expr-list: empty | expr { "," expr }
binary-expr: expr bin-op expr
unary-expr: unary-op expr
bin-op: "+" | "-" | "/" | "*" | ">>" | "<<" | ">>>" | "|" | "&" | "^" |
	| "+=" | "-=" | "/=" | "*=" | ">>=" | "<<=" | "|=" | "&=" | "^=" | "=" 
        | "==" | ">" | ">=" | "<" | "<=" | "!=" 
unary-op: "~" | "!" | "-" | "+" 

• C-Talk has no preprocessor
• C-Talk has "function" keyword
• C-Talk treats " and ' equally, so "ok" and 'ok' means the same string character constant
• C-Talk program consist of modules loaded by "import" construction
• C-Talk expression a.x is syntax sugar for a["x"] and is treated as associative array access operation
• C-Talk variable has no types - so no function return type, formal parameter type or variable type should not (and can not) be specified.
• C-Talk has no goto construction
• C-Talk has "par" construction for starting thread

Types

• Integer (32 bit signed integer type with operations similar to C, but shift right operation is unsigned - doesn't replicate the sign bit)
• Real (32 bit ANSI double type)
• String (+ operator)
• Associative array (index of the array can be object of any type, for example a["foo"])
• Raw pointer (used only by primitives, C-Talk can only store such value to variables and pass them to the functions, example is C FILE* type)
• Thread type (with associated FIFO queue)
• Function type (function is first class value and can assigned to variable and passed as parameter to other function)

String operations

Arrays operations

Mutex operations

Thread operations

IO operations:

Type check operations:

Miscellaneous

Program execution

$ ctalk file-1 file-2 ...

hello = "Hello World";

foo(hello);

foo(s) { 
	println(s);
}

C-Talk primitives

CtkObject foo_func(int nArgs, CtkObject args[]) { ... }
REGISTER(foo_func, "foo");

C-Talk provide even more convinient weay for checking types passed arguments. Function ctkParseArguments takes format string and optional list of arguments palceholder and perform necessary checks and conversions.

void ctkParseArguments(int nArgs, CtkObject* args, char const* format, ...);

Parameters:

nArgs - number of arguments passed to the function (first parameter of any primitive)

args - array of arguments passed to the function (second parameter of any primitive)

format - format string specifying number and types of expected arguments.
In format string each character describes one correpondent parameter.
Upercase character in format string cause checking of the argument type and copying CtkObject to the placeholder.
Lowercase character in format string cause checking and storing arguments in native C format.
',' character in format string split mandatory and optional parameters.
If type or number of parameters doesn't match, exception is thrown.

Format symbol	Expected C-Talk type of argument	Type of placeholder for parameter value
o	any	CtkObject
i	CTK_INTEGER	ctk_integer
r	CTK_REAL	ctk_real
p	CTK_RAW_POINTER or CTK_NULL	void*
P	CTK_RAW_POINTER	CtkObject
s	CTK_STRING or CTK_NULL	char*
S	CTK_STRING	CtkObject
a	CTK_ARRAY or CTK_NULL	CtkArray*
A	CTK_ARRAY	CtkObject
f	CTK_FILE or CTK_NULL	CtkFile*
F	CTK_FILE	CtkObject
m	CTK_MUTEX or CTK_NULL	CtkMutex*
M	CTK_MUTEX	CtkObject
t	CTK_THREAD or CTK_NULL	CtkThread*
T	CTK_THREAD	CtkObject
l	CTK_FUNCTION or CTK_NULL	CtkFunction*
L	CTK_FUNCTION	CtkObject
u	CTK_USER_TYPE or CTK_NULL	void*
U	CTK_USER_TYPE	CtkObject

Example:

CtkObject myPrimitive(int nArgs, CtkObject* args) {
    char*       s;
    ctk_integer i;
    ctk_real    r;
    CtkObject   o;

    ctkParseArguments(nArgs, args, "siro", &s, &i, &r, &o);
    ...
}