diff --git a/eci/clibrary.c b/eci/clibrary.c
index c252af6..4a6aa61 100644
--- a/eci/clibrary.c
+++ b/eci/clibrary.c
@@ -22,8 +22,8 @@ static int LittleEndian = 0;
 /* global initialisation for libraries */
 void LibraryInit() {
 	/* define the version number macro */
-	VersionString = TableStrRegister(PICOC_VERSION);
-	VariableDefinePlatformVar(NULL, "PICOC_VERSION", CharPtrType, (union AnyValue *)&VersionString, FALSE);
+	VersionString = TableStrRegister(ECI_VERSION);
+	VariableDefinePlatformVar(NULL, "ECI_VERSION", CharPtrType, (union AnyValue *)&VersionString, FALSE);
 	/* define endian-ness macros */
 	BigEndian = ((*(char*)&__ENDIAN_CHECK__) == 0);
 	LittleEndian = ((*(char*)&__ENDIAN_CHECK__) == 1);
@@ -32,7 +32,7 @@ void LibraryInit() {
 }
 
 /* add a library */
-void LibraryAdd(struct Table *GlobalTable, const char *LibraryName, struct LibraryFunction *FuncList) {
+void LibraryAdd(struct Table *_globalTable, const char *_libraryName, struct LibraryFunction *_funcList) {
 	struct ParseState Parser;
 	int Count;
 	char *Identifier;
@@ -41,83 +41,83 @@ void LibraryAdd(struct Table *GlobalTable, const char *LibraryName, struct Libra
 	void *Tokens;
 	const char *IntrinsicName = TableStrRegister("c library");
 	/* read all the library definitions */
-	for (Count = 0; FuncList[Count].Prototype != NULL; Count++) {
-		Tokens = LexAnalyse(IntrinsicName, FuncList[Count].Prototype, strlen((char *)FuncList[Count].Prototype), NULL);
-		LexInitParser(&Parser, FuncList[Count].Prototype, Tokens, IntrinsicName, TRUE);
+	for (Count = 0; _funcList[Count].Prototype != NULL; Count++) {
+		Tokens = LexAnalyse(IntrinsicName, _funcList[Count].Prototype, strlen((char *)_funcList[Count].Prototype), NULL);
+		LexInitParser(&Parser, _funcList[Count].Prototype, Tokens, IntrinsicName, TRUE);
 		TypeParse(&Parser, &ReturnType, &Identifier, NULL);
 		NewValue = ParseFunctionDefinition(&Parser, ReturnType, Identifier);
-		NewValue->Val->FuncDef.Intrinsic = FuncList[Count].Func;
+		NewValue->Val->FuncDef.Intrinsic = _funcList[Count].Func;
 		HeapFreeMem(Tokens);
 	}
 }
 
 /* print a type to a stream without using printf/sprintf */
-void PrintType(struct ValueType *Typ, IOFILE *Stream) {
-	switch (Typ->Base) {
+void PrintType(struct ValueType* _type, IOFILE *_stream) {
+	switch (_type->Base) {
 		case TypeVoid:
-			PrintStr("void", Stream);
+			PrintStr("void", _stream);
 			break;
 		case TypeInt:
-			PrintStr("int", Stream);
+			PrintStr("int", _stream);
 			break;
 		case TypeShort:
-			PrintStr("short", Stream);
+			PrintStr("short", _stream);
 			break;
 		case TypeChar:
-			PrintStr("char", Stream);
+			PrintStr("char", _stream);
 			break;
 		case TypeLong:
-			PrintStr("long", Stream);
+			PrintStr("long", _stream);
 			break;
 		case TypeUnsignedInt:
-			PrintStr("unsigned int", Stream);
+			PrintStr("unsigned int", _stream);
 			break;
 		case TypeUnsignedShort:
-			PrintStr("unsigned short", Stream);
+			PrintStr("unsigned short", _stream);
 			break;
 		case TypeUnsignedLong:
-			PrintStr("unsigned long", Stream);
+			PrintStr("unsigned long", _stream);
 			break;
 		case TypeFP:
-			PrintStr("double", Stream);
+			PrintStr("double", _stream);
 			break;
 		case TypeFunction:
-			PrintStr("function", Stream);
+			PrintStr("function", _stream);
 			break;
 		case TypeMacro:
-			PrintStr("macro", Stream);
+			PrintStr("macro", _stream);
 			break;
 		case TypePointer:
-			if (Typ->FromType) {
-				PrintType(Typ->FromType, Stream);
+			if (_type->FromType) {
+				PrintType(_type->FromType, _stream);
 			}
-			PrintCh('*', Stream);
+			PrintCh('*', _stream);
 			break;
 		case TypeArray:
-			PrintType(Typ->FromType, Stream);
-			PrintCh('[', Stream);
-			if (Typ->ArraySize != 0) {
-				PrintSimpleInt(Typ->ArraySize, Stream);
+			PrintType(_type->FromType, _stream);
+			PrintCh('[', _stream);
+			if (_type->ArraySize != 0) {
+				PrintSimpleInt(_type->ArraySize, _stream);
 			}
-			PrintCh(']', Stream);
+			PrintCh(']', _stream);
 			break;
 		case TypeStruct:
-			PrintStr("struct ", Stream);
-			PrintStr(Typ->Identifier, Stream);
+			PrintStr("struct ", _stream);
+			PrintStr(_type->Identifier, _stream);
 			break;
 		case TypeUnion:
-			PrintStr("union ", Stream);
-			PrintStr(Typ->Identifier, Stream);
+			PrintStr("union ", _stream);
+			PrintStr(_type->Identifier, _stream);
 			break;
 		case TypeEnum:
-			PrintStr("enum ", Stream);
-			PrintStr(Typ->Identifier, Stream);
+			PrintStr("enum ", _stream);
+			PrintStr(_type->Identifier, _stream);
 			break;
 		case TypeGotoLabel:
-			PrintStr("goto label ", Stream);
+			PrintStr("goto label ", _stream);
 			break;
 		case Type_Type:
-			PrintStr("type ", Stream);
+			PrintStr("type ", _stream);
 			break;
 	}
 }
diff --git a/eci/clibrary.h b/eci/clibrary.h
new file mode 100644
index 0000000..c0c5fcc
--- /dev/null
+++ b/eci/clibrary.h
@@ -0,0 +1,20 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2014, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE-2 (see license file)
+ */
+
+#ifndef __ECI_C_LIBRARY_H__
+#define __ECI_C_LIBRARY_H__
+
+
+
+void LibraryInit();
+void LibraryAdd(struct Table* _globalTable, const char* _libraryName, struct LibraryFunction* _funcList);
+void CLibraryInit();
+void PrintType(struct ValueType* _type, IOFILE* _stream);
+
+
+#endif
diff --git a/eci/cstdlib/ctype.c b/eci/cstdlib/ctype.c
index 2bbcc59..8a1f526 100644
--- a/eci/cstdlib/ctype.c
+++ b/eci/cstdlib/ctype.c
@@ -12,69 +12,69 @@
 
 #ifndef BUILTIN_MINI_STDLIB
 
-void StdIsalnum(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = isalnum(Param[0]->Val->Integer);
+void StdIsalnum(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = isalnum(_param[0]->Val->Integer);
 }
 
-void StdIsalpha(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = isalpha(Param[0]->Val->Integer);
+void StdIsalpha(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = isalpha(_param[0]->Val->Integer);
 }
 
-void StdIsblank(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	int ch = Param[0]->Val->Integer;
-	ReturnValue->Val->Integer = (ch == ' ') | (ch == '\t');
+void StdIsblank(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	int ch = _param[0]->Val->Integer;
+	_returnValue->Val->Integer = (ch == ' ') | (ch == '\t');
 }
 
-void StdIscntrl(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = iscntrl(Param[0]->Val->Integer);
+void StdIscntrl(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = iscntrl(_param[0]->Val->Integer);
 }
 
-void StdIsdigit(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = isdigit(Param[0]->Val->Integer);
+void StdIsdigit(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = isdigit(_param[0]->Val->Integer);
 }
 
-void StdIsgraph(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = isgraph(Param[0]->Val->Integer);
+void StdIsgraph(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = isgraph(_param[0]->Val->Integer);
 }
 
-void StdIslower(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = islower(Param[0]->Val->Integer);
+void StdIslower(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = islower(_param[0]->Val->Integer);
 }
 
-void StdIsprint(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = isprint(Param[0]->Val->Integer);
+void StdIsprint(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = isprint(_param[0]->Val->Integer);
 }
 
-void StdIspunct(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = ispunct(Param[0]->Val->Integer);
+void StdIspunct(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = ispunct(_param[0]->Val->Integer);
 }
 
-void StdIsspace(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = isspace(Param[0]->Val->Integer);
+void StdIsspace(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = isspace(_param[0]->Val->Integer);
 }
 
-void StdIsupper(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = isupper(Param[0]->Val->Integer);
+void StdIsupper(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = isupper(_param[0]->Val->Integer);
 }
 
-void StdIsxdigit(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = isxdigit(Param[0]->Val->Integer);
+void StdIsxdigit(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = isxdigit(_param[0]->Val->Integer);
 }
 
-void StdTolower(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = tolower(Param[0]->Val->Integer);
+void StdTolower(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = tolower(_param[0]->Val->Integer);
 }
 
-void StdToupper(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = toupper(Param[0]->Val->Integer);
+void StdToupper(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = toupper(_param[0]->Val->Integer);
 }
 
-void StdIsascii(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = isascii(Param[0]->Val->Integer);
+void StdIsascii(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = isascii(_param[0]->Val->Integer);
 }
 
-void StdToascii(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = toascii(Param[0]->Val->Integer);
+void StdToascii(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = toascii(_param[0]->Val->Integer);
 }
 
 /* all string.h functions */
diff --git a/eci/cstdlib/ctype.h b/eci/cstdlib/ctype.h
new file mode 100644
index 0000000..6ee406b
--- /dev/null
+++ b/eci/cstdlib/ctype.h
@@ -0,0 +1,15 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2014, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE-2 (see license file)
+ */
+
+#ifndef __ECI_C_TYPE_H__
+#define __ECI_C_TYPE_H__
+
+
+extern struct LibraryFunction StdCtypeFunctions[];
+
+#endif
diff --git a/eci/cstdlib/errno.h b/eci/cstdlib/errno.h
new file mode 100644
index 0000000..71bcaf6
--- /dev/null
+++ b/eci/cstdlib/errno.h
@@ -0,0 +1,14 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2014, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE-2 (see license file)
+ */
+
+#ifndef __ECI_ERRNO_H__
+#define __ECI_ERRNO_H__
+
+void StdErrnoSetupFunc();
+
+#endif
diff --git a/eci/cstdlib/math.c b/eci/cstdlib/math.c
index 60567ae..ed1d330 100644
--- a/eci/cstdlib/math.c
+++ b/eci/cstdlib/math.c
@@ -26,98 +26,98 @@ static double M_SQRT2Value =    1.41421356237309504880;  /* sqrt(2) */
 static double M_SQRT1_2Value =  0.70710678118654752440;  /* 1/sqrt(2) */
 
 
-void MathSin(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = sin(Param[0]->Val->FP);
+void MathSin(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = sin(_param[0]->Val->FP);
 }
 
-void MathCos(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs){
-	ReturnValue->Val->FP = cos(Param[0]->Val->FP);
+void MathCos(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs){
+	_returnValue->Val->FP = cos(_param[0]->Val->FP);
 }
 
-void MathTan(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = tan(Param[0]->Val->FP);
+void MathTan(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = tan(_param[0]->Val->FP);
 }
 
-void MathAsin(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = asin(Param[0]->Val->FP);
+void MathAsin(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = asin(_param[0]->Val->FP);
 }
 
-void MathAcos(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = acos(Param[0]->Val->FP);
+void MathAcos(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = acos(_param[0]->Val->FP);
 }
 
-void MathAtan(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = atan(Param[0]->Val->FP);
+void MathAtan(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = atan(_param[0]->Val->FP);
 }
 
-void MathAtan2(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = atan2(Param[0]->Val->FP, Param[1]->Val->FP);
+void MathAtan2(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = atan2(_param[0]->Val->FP, _param[1]->Val->FP);
 }
 
-void MathSinh(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = sinh(Param[0]->Val->FP);
+void MathSinh(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = sinh(_param[0]->Val->FP);
 }
 
-void MathCosh(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = cosh(Param[0]->Val->FP);
+void MathCosh(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = cosh(_param[0]->Val->FP);
 }
 
-void MathTanh(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = tanh(Param[0]->Val->FP);
+void MathTanh(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = tanh(_param[0]->Val->FP);
 }
 
-void MathExp(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = exp(Param[0]->Val->FP);
+void MathExp(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = exp(_param[0]->Val->FP);
 }
 
-void MathFabs(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = fabs(Param[0]->Val->FP);
+void MathFabs(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = fabs(_param[0]->Val->FP);
 }
 
-void MathFmod(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = fmod(Param[0]->Val->FP, Param[1]->Val->FP);
+void MathFmod(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = fmod(_param[0]->Val->FP, _param[1]->Val->FP);
 }
 
-void MathFrexp(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = frexp(Param[0]->Val->FP, Param[1]->Val->Pointer);
+void MathFrexp(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = frexp(_param[0]->Val->FP, _param[1]->Val->Pointer);
 }
 
-void MathLdexp(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = ldexp(Param[0]->Val->FP, Param[1]->Val->Integer);
+void MathLdexp(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = ldexp(_param[0]->Val->FP, _param[1]->Val->Integer);
 }
 
-void MathLog(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = log(Param[0]->Val->FP);
+void MathLog(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = log(_param[0]->Val->FP);
 }
 
-void MathLog10(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = log10(Param[0]->Val->FP);
+void MathLog10(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = log10(_param[0]->Val->FP);
 }
 
-void MathModf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = modf(Param[0]->Val->FP, Param[0]->Val->Pointer);
+void MathModf(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = modf(_param[0]->Val->FP, _param[0]->Val->Pointer);
 }
 
-void MathPow(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = pow(Param[0]->Val->FP, Param[1]->Val->FP);
+void MathPow(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = pow(_param[0]->Val->FP, _param[1]->Val->FP);
 }
 
-void MathSqrt(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = sqrt(Param[0]->Val->FP);
+void MathSqrt(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = sqrt(_param[0]->Val->FP);
 }
 
-void MathRound(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
+void MathRound(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
 	/* this awkward definition of "round()" due to it being inconsistently
 	 * declared in math.h */
-	ReturnValue->Val->FP = ceil(Param[0]->Val->FP - 0.5);
+	_returnValue->Val->FP = ceil(_param[0]->Val->FP - 0.5);
 }
 
-void MathCeil(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = ceil(Param[0]->Val->FP);
+void MathCeil(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = ceil(_param[0]->Val->FP);
 }
 
-void MathFloor(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = floor(Param[0]->Val->FP);
+void MathFloor(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = floor(_param[0]->Val->FP);
 }
 
 /* all math.h functions */
diff --git a/eci/cstdlib/math.h b/eci/cstdlib/math.h
new file mode 100644
index 0000000..1bef9a1
--- /dev/null
+++ b/eci/cstdlib/math.h
@@ -0,0 +1,16 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2014, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE-2 (see license file)
+ */
+
+#ifndef __ECI_MATH_H__
+#define __ECI_MATH_H__
+
+
+extern struct LibraryFunction MathFunctions[];
+void MathSetupFunc();
+
+#endif
diff --git a/eci/cstdlib/stdbool.h b/eci/cstdlib/stdbool.h
new file mode 100644
index 0000000..1a50f2a
--- /dev/null
+++ b/eci/cstdlib/stdbool.h
@@ -0,0 +1,16 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2014, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE-2 (see license file)
+ */
+
+#ifndef __ECI_STD_BOOL_H__
+#define __ECI_STD_BOOL_H__
+
+
+extern const char StdboolDefs[];
+void StdboolSetupFunc();
+
+#endif
diff --git a/eci/cstdlib/stdio.c b/eci/cstdlib/stdio.c
index 8f057de..ffc7597 100644
--- a/eci/cstdlib/stdio.c
+++ b/eci/cstdlib/stdio.c
@@ -47,8 +47,8 @@ typedef struct StdOutStreamStruct {
 
 /* our representation of varargs within picoc */
 struct StdVararg {
-	struct Value **Param;
-	int NumArgs;
+	struct Value **_param;
+	int _numArgs;
 };
 
 /* initialises the I/O system so error reporting works */
@@ -149,8 +149,8 @@ void StdioFprintfPointer(StdOutStream *Stream, const char *Format, void *Value)
 }
 
 /* internal do-anything v[s][n]printf() formatting system with output to strings or FILE * */
-int StdioBasePrintf(struct ParseState *Parser, FILE *Stream, char *StrOut, int StrOutLen, char *Format, struct StdVararg *Args) {
-	struct Value *ThisArg = Args->Param[0];
+int StdioBasePrintf(struct ParseState *_parser, FILE *Stream, char *StrOut, int StrOutLen, char *Format, struct StdVararg *Args) {
+	struct Value *ThisArg = Args->_param[0];
 	int ArgCount = 0;
 	char *FPos = Format;
 	char OneFormatBuf[MAX_FORMAT+1];
@@ -260,7 +260,7 @@ int StdioBasePrintf(struct ParseState *Parser, FILE *Stream, char *StrOut, int S
 			} while (    ShowType == NULL
 			          && OneFormatCount < MAX_FORMAT);
 			if (ShowType != &VoidType) {
-				if (ArgCount >= Args->NumArgs) {
+				if (ArgCount >= Args->_numArgs) {
 					StdioOutPuts("XXX", &SOStream);
 				} else {
 					/* null-terminate the buffer */
@@ -317,21 +317,21 @@ int StdioBasePrintf(struct ParseState *Parser, FILE *Stream, char *StrOut, int S
 }
 
 /* internal do-anything v[s][n]scanf() formatting system with input from strings or FILE * */
-int StdioBaseScanf(struct ParseState *Parser, FILE *Stream, char *StrIn, char *Format, struct StdVararg *Args) {
-	struct Value *ThisArg = Args->Param[0];
+int StdioBaseScanf(struct ParseState *_parser, FILE *Stream, char *StrIn, char *Format, struct StdVararg *Args) {
+	struct Value *ThisArg = Args->_param[0];
 	int ArgCount = 0;
 	void *ScanfArg[MAX_SCANF_ARGS];
-	if (Args->NumArgs > MAX_SCANF_ARGS) {
-		ProgramFail(Parser, "too many arguments to scanf() - %d max", MAX_SCANF_ARGS);
+	if (Args->_numArgs > MAX_SCANF_ARGS) {
+		ProgramFail(_parser, "too many arguments to scanf() - %d max", MAX_SCANF_ARGS);
 	}
-	for (ArgCount = 0; ArgCount < Args->NumArgs; ++ArgCount) {
+	for (ArgCount = 0; ArgCount < Args->_numArgs; ++ArgCount) {
 		ThisArg = (struct Value *)((char *)ThisArg + MEM_ALIGN(sizeof(struct Value) + TypeStackSizeValue(ThisArg)));
 		if (ThisArg->Typ->Base == TypePointer) {
 			ScanfArg[ArgCount] = ThisArg->Val->Pointer;
 		} else if (ThisArg->Typ->Base == TypeArray) {
 			ScanfArg[ArgCount] = &ThisArg->Val->ArrayMem[0];
 		} else {
-			ProgramFail(Parser, "non-pointer argument to scanf() - argument %d after format", ArgCount+1);
+			ProgramFail(_parser, "non-pointer argument to scanf() - argument %d after format", ArgCount+1);
 		}
 	}
 	if (Stream != NULL) {
@@ -342,211 +342,211 @@ int StdioBaseScanf(struct ParseState *Parser, FILE *Stream, char *StrIn, char *F
 }
 
 /* stdio calls */
-void StdioFopen(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = fopen(Param[0]->Val->Pointer, Param[1]->Val->Pointer);
+void StdioFopen(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = fopen(_param[0]->Val->Pointer, _param[1]->Val->Pointer);
 }
 
-void StdioFreopen(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = freopen(Param[0]->Val->Pointer, Param[1]->Val->Pointer, Param[2]->Val->Pointer);
+void StdioFreopen(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = freopen(_param[0]->Val->Pointer, _param[1]->Val->Pointer, _param[2]->Val->Pointer);
 }
 
-void StdioFclose(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = fclose(Param[0]->Val->Pointer);
+void StdioFclose(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = fclose(_param[0]->Val->Pointer);
 }
 
-void StdioFread(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = fread(Param[0]->Val->Pointer, Param[1]->Val->Integer, Param[2]->Val->Integer, Param[3]->Val->Pointer);
+void StdioFread(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = fread(_param[0]->Val->Pointer, _param[1]->Val->Integer, _param[2]->Val->Integer, _param[3]->Val->Pointer);
 }
 
-void StdioFwrite(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = fwrite(Param[0]->Val->Pointer, Param[1]->Val->Integer, Param[2]->Val->Integer, Param[3]->Val->Pointer);
+void StdioFwrite(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = fwrite(_param[0]->Val->Pointer, _param[1]->Val->Integer, _param[2]->Val->Integer, _param[3]->Val->Pointer);
 }
 
-void StdioFgetc(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = fgetc(Param[0]->Val->Pointer);
+void StdioFgetc(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = fgetc(_param[0]->Val->Pointer);
 }
 
-void StdioFgets(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = fgets(Param[0]->Val->Pointer, Param[1]->Val->Integer, Param[2]->Val->Pointer);
+void StdioFgets(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = fgets(_param[0]->Val->Pointer, _param[1]->Val->Integer, _param[2]->Val->Pointer);
 }
 
-void StdioRemove(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = remove(Param[0]->Val->Pointer);
+void StdioRemove(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = remove(_param[0]->Val->Pointer);
 }
 
-void StdioRename(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = rename(Param[0]->Val->Pointer, Param[1]->Val->Pointer);
+void StdioRename(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = rename(_param[0]->Val->Pointer, _param[1]->Val->Pointer);
 }
 
-void StdioRewind(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	rewind(Param[0]->Val->Pointer);
+void StdioRewind(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	rewind(_param[0]->Val->Pointer);
 }
 
-void StdioTmpfile(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = tmpfile();
+void StdioTmpfile(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = tmpfile();
 }
 
-void StdioClearerr(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	clearerr((FILE *)Param[0]->Val->Pointer);
+void StdioClearerr(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	clearerr((FILE *)_param[0]->Val->Pointer);
 }
 
-void StdioFeof(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = feof((FILE *)Param[0]->Val->Pointer);
+void StdioFeof(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = feof((FILE *)_param[0]->Val->Pointer);
 }
 
-void StdioFerror(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = ferror((FILE *)Param[0]->Val->Pointer);
+void StdioFerror(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = ferror((FILE *)_param[0]->Val->Pointer);
 }
 
-void StdioFileno(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = fileno(Param[0]->Val->Pointer);
+void StdioFileno(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = fileno(_param[0]->Val->Pointer);
 }
 
-void StdioFflush(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = fflush(Param[0]->Val->Pointer);
+void StdioFflush(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = fflush(_param[0]->Val->Pointer);
 }
 
-void StdioFgetpos(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = fgetpos(Param[0]->Val->Pointer, Param[1]->Val->Pointer);
+void StdioFgetpos(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = fgetpos(_param[0]->Val->Pointer, _param[1]->Val->Pointer);
 }
 
-void StdioFsetpos(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = fsetpos(Param[0]->Val->Pointer, Param[1]->Val->Pointer);
+void StdioFsetpos(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = fsetpos(_param[0]->Val->Pointer, _param[1]->Val->Pointer);
 }
 
-void StdioFputc(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = fputc(Param[0]->Val->Integer, Param[1]->Val->Pointer);
+void StdioFputc(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = fputc(_param[0]->Val->Integer, _param[1]->Val->Pointer);
 }
 
-void StdioFputs(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = fputs(Param[0]->Val->Pointer, Param[1]->Val->Pointer);
+void StdioFputs(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = fputs(_param[0]->Val->Pointer, _param[1]->Val->Pointer);
 }
 
-void StdioFtell(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = ftell(Param[0]->Val->Pointer);
+void StdioFtell(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = ftell(_param[0]->Val->Pointer);
 }
 
-void StdioFseek(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = fseek(Param[0]->Val->Pointer, Param[1]->Val->Integer, Param[2]->Val->Integer);
+void StdioFseek(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = fseek(_param[0]->Val->Pointer, _param[1]->Val->Integer, _param[2]->Val->Integer);
 }
 
-void StdioPerror(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	perror(Param[0]->Val->Pointer);
+void StdioPerror(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	perror(_param[0]->Val->Pointer);
 }
 
-void StdioPutc(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = putc(Param[0]->Val->Integer, Param[1]->Val->Pointer);
+void StdioPutc(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = putc(_param[0]->Val->Integer, _param[1]->Val->Pointer);
 }
 
-void StdioPutchar(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = putchar(Param[0]->Val->Integer);
+void StdioPutchar(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = putchar(_param[0]->Val->Integer);
 }
 
-void StdioSetbuf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	setbuf(Param[0]->Val->Pointer, Param[1]->Val->Pointer);
+void StdioSetbuf(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	setbuf(_param[0]->Val->Pointer, _param[1]->Val->Pointer);
 }
 
-void StdioSetvbuf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	setvbuf(Param[0]->Val->Pointer, Param[1]->Val->Pointer, Param[2]->Val->Integer, Param[3]->Val->Integer);
+void StdioSetvbuf(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	setvbuf(_param[0]->Val->Pointer, _param[1]->Val->Pointer, _param[2]->Val->Integer, _param[3]->Val->Integer);
 }
 
-void StdioUngetc(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = ungetc(Param[0]->Val->Integer, Param[1]->Val->Pointer);
+void StdioUngetc(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = ungetc(_param[0]->Val->Integer, _param[1]->Val->Pointer);
 }
 
-void StdioPuts(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = puts(Param[0]->Val->Pointer);
+void StdioPuts(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = puts(_param[0]->Val->Pointer);
 }
 
-void StdioGets(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = fgets(Param[0]->Val->Pointer, GETS_MAXValue, stdin);
-	if (ReturnValue->Val->Pointer != NULL) {
-		char *EOLPos = strchr(Param[0]->Val->Pointer, '\n');
+void StdioGets(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = fgets(_param[0]->Val->Pointer, GETS_MAXValue, stdin);
+	if (_returnValue->Val->Pointer != NULL) {
+		char *EOLPos = strchr(_param[0]->Val->Pointer, '\n');
 		if (EOLPos != NULL) {
 			*EOLPos = '\0';
 		}
 	}
 }
 
-void StdioGetchar(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = getchar();
+void StdioGetchar(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = getchar();
 }
 
-void StdioPrintf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
+void StdioPrintf(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
 	struct StdVararg PrintfArgs;
-	PrintfArgs.Param = Param;
-	PrintfArgs.NumArgs = NumArgs-1;
-	ReturnValue->Val->Integer = StdioBasePrintf(Parser, stdout, NULL, 0, Param[0]->Val->Pointer, &PrintfArgs);
+	PrintfArgs._param = _param;
+	PrintfArgs._numArgs = _numArgs-1;
+	_returnValue->Val->Integer = StdioBasePrintf(_parser, stdout, NULL, 0, _param[0]->Val->Pointer, &PrintfArgs);
 }
 
-void StdioVprintf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = StdioBasePrintf(Parser, stdout, NULL, 0, Param[0]->Val->Pointer, Param[1]->Val->Pointer);
+void StdioVprintf(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = StdioBasePrintf(_parser, stdout, NULL, 0, _param[0]->Val->Pointer, _param[1]->Val->Pointer);
 }
 
-void StdioFprintf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
+void StdioFprintf(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
 	struct StdVararg PrintfArgs;
-	PrintfArgs.Param = Param + 1;
-	PrintfArgs.NumArgs = NumArgs-2;
-	ReturnValue->Val->Integer = StdioBasePrintf(Parser, Param[0]->Val->Pointer, NULL, 0, Param[1]->Val->Pointer, &PrintfArgs);
+	PrintfArgs._param = _param + 1;
+	PrintfArgs._numArgs = _numArgs-2;
+	_returnValue->Val->Integer = StdioBasePrintf(_parser, _param[0]->Val->Pointer, NULL, 0, _param[1]->Val->Pointer, &PrintfArgs);
 }
 
-void StdioVfprintf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = StdioBasePrintf(Parser, Param[0]->Val->Pointer, NULL, 0, Param[1]->Val->Pointer, Param[2]->Val->Pointer);
+void StdioVfprintf(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = StdioBasePrintf(_parser, _param[0]->Val->Pointer, NULL, 0, _param[1]->Val->Pointer, _param[2]->Val->Pointer);
 }
 
-void StdioSprintf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
+void StdioSprintf(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
 	struct StdVararg PrintfArgs;
-	PrintfArgs.Param = Param + 1;
-	PrintfArgs.NumArgs = NumArgs-2;
-	ReturnValue->Val->Integer = StdioBasePrintf(Parser, NULL, Param[0]->Val->Pointer, -1, Param[1]->Val->Pointer, &PrintfArgs);
+	PrintfArgs._param = _param + 1;
+	PrintfArgs._numArgs = _numArgs-2;
+	_returnValue->Val->Integer = StdioBasePrintf(_parser, NULL, _param[0]->Val->Pointer, -1, _param[1]->Val->Pointer, &PrintfArgs);
 }
 
-void StdioSnprintf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
+void StdioSnprintf(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
 	struct StdVararg PrintfArgs;
-	PrintfArgs.Param = Param+2;
-	PrintfArgs.NumArgs = NumArgs-3;
-	ReturnValue->Val->Integer = StdioBasePrintf(Parser, NULL, Param[0]->Val->Pointer, Param[1]->Val->Integer, Param[2]->Val->Pointer, &PrintfArgs);
+	PrintfArgs._param = _param+2;
+	PrintfArgs._numArgs = _numArgs-3;
+	_returnValue->Val->Integer = StdioBasePrintf(_parser, NULL, _param[0]->Val->Pointer, _param[1]->Val->Integer, _param[2]->Val->Pointer, &PrintfArgs);
 }
 
-void StdioScanf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
+void StdioScanf(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
 	struct StdVararg ScanfArgs;
-	ScanfArgs.Param = Param;
-	ScanfArgs.NumArgs = NumArgs-1;
-	ReturnValue->Val->Integer = StdioBaseScanf(Parser, stdin, NULL, Param[0]->Val->Pointer, &ScanfArgs);
+	ScanfArgs._param = _param;
+	ScanfArgs._numArgs = _numArgs-1;
+	_returnValue->Val->Integer = StdioBaseScanf(_parser, stdin, NULL, _param[0]->Val->Pointer, &ScanfArgs);
 }
 
-void StdioFscanf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
+void StdioFscanf(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
 	struct StdVararg ScanfArgs;
-	ScanfArgs.Param = Param+1;
-	ScanfArgs.NumArgs = NumArgs-2;
-	ReturnValue->Val->Integer = StdioBaseScanf(Parser, Param[0]->Val->Pointer, NULL, Param[1]->Val->Pointer, &ScanfArgs);
+	ScanfArgs._param = _param+1;
+	ScanfArgs._numArgs = _numArgs-2;
+	_returnValue->Val->Integer = StdioBaseScanf(_parser, _param[0]->Val->Pointer, NULL, _param[1]->Val->Pointer, &ScanfArgs);
 }
 
-void StdioSscanf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
+void StdioSscanf(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
 	struct StdVararg ScanfArgs;
-	ScanfArgs.Param = Param+1;
-	ScanfArgs.NumArgs = NumArgs-2;
-	ReturnValue->Val->Integer = StdioBaseScanf(Parser, NULL, Param[0]->Val->Pointer, Param[1]->Val->Pointer, &ScanfArgs);
+	ScanfArgs._param = _param+1;
+	ScanfArgs._numArgs = _numArgs-2;
+	_returnValue->Val->Integer = StdioBaseScanf(_parser, NULL, _param[0]->Val->Pointer, _param[1]->Val->Pointer, &ScanfArgs);
 }
 
-void StdioVsprintf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = StdioBasePrintf(Parser, NULL, Param[0]->Val->Pointer, -1, Param[1]->Val->Pointer, Param[2]->Val->Pointer);
+void StdioVsprintf(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = StdioBasePrintf(_parser, NULL, _param[0]->Val->Pointer, -1, _param[1]->Val->Pointer, _param[2]->Val->Pointer);
 }
 
-void StdioVsnprintf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = StdioBasePrintf(Parser, NULL, Param[0]->Val->Pointer, Param[1]->Val->Integer, Param[2]->Val->Pointer, Param[3]->Val->Pointer);
+void StdioVsnprintf(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = StdioBasePrintf(_parser, NULL, _param[0]->Val->Pointer, _param[1]->Val->Integer, _param[2]->Val->Pointer, _param[3]->Val->Pointer);
 }
 
-void StdioVscanf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = StdioBaseScanf(Parser, stdin, NULL, Param[0]->Val->Pointer, Param[1]->Val->Pointer);
+void StdioVscanf(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = StdioBaseScanf(_parser, stdin, NULL, _param[0]->Val->Pointer, _param[1]->Val->Pointer);
 }
 
-void StdioVfscanf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = StdioBaseScanf(Parser, Param[0]->Val->Pointer, NULL, Param[1]->Val->Pointer, Param[2]->Val->Pointer);
+void StdioVfscanf(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = StdioBaseScanf(_parser, _param[0]->Val->Pointer, NULL, _param[1]->Val->Pointer, _param[2]->Val->Pointer);
 }
 
-void StdioVsscanf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = StdioBaseScanf(Parser, NULL, Param[0]->Val->Pointer, Param[1]->Val->Pointer, Param[2]->Val->Pointer);
+void StdioVsscanf(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = StdioBaseScanf(_parser, NULL, _param[0]->Val->Pointer, _param[1]->Val->Pointer, _param[2]->Val->Pointer);
 }
 
 /* handy structure definitions */
diff --git a/eci/cstdlib/stdio.h b/eci/cstdlib/stdio.h
new file mode 100644
index 0000000..d50ac77
--- /dev/null
+++ b/eci/cstdlib/stdio.h
@@ -0,0 +1,17 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2014, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE-2 (see license file)
+ */
+
+#ifndef __ECI_STDIO_H__
+#define __ECI_STDIO_H__
+
+
+extern const char StdioDefs[];
+extern struct LibraryFunction StdioFunctions[];
+void StdioSetupFunc();
+
+#endif
diff --git a/eci/cstdlib/stdlib.c b/eci/cstdlib/stdlib.c
index 247f7aa..5f59ed4 100644
--- a/eci/cstdlib/stdlib.c
+++ b/eci/cstdlib/stdlib.c
@@ -13,76 +13,76 @@
 
 static int ZeroValue = 0;
 
-void StdlibAtof(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = atof(Param[0]->Val->Pointer);
+void StdlibAtof(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = atof(_param[0]->Val->Pointer);
 }
 
-void StdlibAtoi(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = atoi(Param[0]->Val->Pointer);
+void StdlibAtoi(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = atoi(_param[0]->Val->Pointer);
 }
 
-void StdlibAtol(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = atol(Param[0]->Val->Pointer);
+void StdlibAtol(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = atol(_param[0]->Val->Pointer);
 }
 
-void StdlibStrtod(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = strtod(Param[0]->Val->Pointer, Param[1]->Val->Pointer);
+void StdlibStrtod(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = strtod(_param[0]->Val->Pointer, _param[1]->Val->Pointer);
 }
 
-void StdlibStrtol(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = strtol(Param[0]->Val->Pointer, Param[1]->Val->Pointer, Param[2]->Val->Integer);
+void StdlibStrtol(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = strtol(_param[0]->Val->Pointer, _param[1]->Val->Pointer, _param[2]->Val->Integer);
 }
 
-void StdlibStrtoul(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = strtoul(Param[0]->Val->Pointer, Param[1]->Val->Pointer, Param[2]->Val->Integer);
+void StdlibStrtoul(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = strtoul(_param[0]->Val->Pointer, _param[1]->Val->Pointer, _param[2]->Val->Integer);
 }
 
-void StdlibMalloc(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = malloc(Param[0]->Val->Integer);
+void StdlibMalloc(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = malloc(_param[0]->Val->Integer);
 }
 
-void StdlibCalloc(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = calloc(Param[0]->Val->Integer, Param[1]->Val->Integer);
+void StdlibCalloc(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = calloc(_param[0]->Val->Integer, _param[1]->Val->Integer);
 }
 
-void StdlibRealloc(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = realloc(Param[0]->Val->Pointer, Param[1]->Val->Integer);
+void StdlibRealloc(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = realloc(_param[0]->Val->Pointer, _param[1]->Val->Integer);
 }
 
-void StdlibFree(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	free(Param[0]->Val->Pointer);
+void StdlibFree(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	free(_param[0]->Val->Pointer);
 }
 
-void StdlibRand(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = rand();
+void StdlibRand(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = rand();
 }
 
-void StdlibSrand(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	srand(Param[0]->Val->Integer);
+void StdlibSrand(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	srand(_param[0]->Val->Integer);
 }
 
-void StdlibAbort(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ProgramFail(Parser, "abort");
+void StdlibAbort(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	ProgramFail(_parser, "abort");
 }
 
-void StdlibExit(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	PlatformExit(Param[0]->Val->Integer);
+void StdlibExit(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	PlatformExit(_param[0]->Val->Integer);
 }
 
-void StdlibGetenv(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = getenv(Param[0]->Val->Pointer);
+void StdlibGetenv(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = getenv(_param[0]->Val->Pointer);
 }
 
-void StdlibSystem(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = system(Param[0]->Val->Pointer);
+void StdlibSystem(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = system(_param[0]->Val->Pointer);
 }
 
-void StdlibAbs(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = abs(Param[0]->Val->Integer);
+void StdlibAbs(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = abs(_param[0]->Val->Integer);
 }
 
-void StdlibLabs(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = labs(Param[0]->Val->Integer);
+void StdlibLabs(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = labs(_param[0]->Val->Integer);
 }
 
 /* all stdlib.h functions */
diff --git a/eci/cstdlib/stdlib.h b/eci/cstdlib/stdlib.h
new file mode 100644
index 0000000..213235f
--- /dev/null
+++ b/eci/cstdlib/stdlib.h
@@ -0,0 +1,16 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2014, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE-2 (see license file)
+ */
+
+#ifndef __ECI_STD_LIB_H__
+#define __ECI_STD_LIB_H__
+
+
+extern struct LibraryFunction StdlibFunctions[];
+void StdlibSetupFunc();
+
+#endif
diff --git a/eci/cstdlib/string.c b/eci/cstdlib/string.c
index e4c4564..83f0287 100644
--- a/eci/cstdlib/string.c
+++ b/eci/cstdlib/string.c
@@ -13,108 +13,108 @@
 
 static int ZeroValue = 0;
 
-void StringStrcpy(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = strcpy(Param[0]->Val->Pointer, Param[1]->Val->Pointer);
+void StringStrcpy(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = strcpy(_param[0]->Val->Pointer, _param[1]->Val->Pointer);
 }
 
-void StringStrncpy(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = strncpy(Param[0]->Val->Pointer, Param[1]->Val->Pointer, Param[2]->Val->Integer);
+void StringStrncpy(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = strncpy(_param[0]->Val->Pointer, _param[1]->Val->Pointer, _param[2]->Val->Integer);
 }
 
-void StringStrcmp(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = strcmp(Param[0]->Val->Pointer, Param[1]->Val->Pointer);
+void StringStrcmp(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = strcmp(_param[0]->Val->Pointer, _param[1]->Val->Pointer);
 }
 
-void StringStrncmp(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = strncmp(Param[0]->Val->Pointer, Param[1]->Val->Pointer, Param[2]->Val->Integer);
+void StringStrncmp(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = strncmp(_param[0]->Val->Pointer, _param[1]->Val->Pointer, _param[2]->Val->Integer);
 }
 
-void StringStrcat(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = strcat(Param[0]->Val->Pointer, Param[1]->Val->Pointer);
+void StringStrcat(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = strcat(_param[0]->Val->Pointer, _param[1]->Val->Pointer);
 }
 
-void StringStrncat(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = strncat(Param[0]->Val->Pointer, Param[1]->Val->Pointer, Param[2]->Val->Integer);
+void StringStrncat(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = strncat(_param[0]->Val->Pointer, _param[1]->Val->Pointer, _param[2]->Val->Integer);
 }
 
-void StringIndex(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = index(Param[0]->Val->Pointer, Param[1]->Val->Integer);
+void StringIndex(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = index(_param[0]->Val->Pointer, _param[1]->Val->Integer);
 }
 
-void StringRindex(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = rindex(Param[0]->Val->Pointer, Param[1]->Val->Integer);
+void StringRindex(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = rindex(_param[0]->Val->Pointer, _param[1]->Val->Integer);
 }
 
-void StringStrlen(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = strlen(Param[0]->Val->Pointer);
+void StringStrlen(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = strlen(_param[0]->Val->Pointer);
 }
 
-void StringMemset(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = memset(Param[0]->Val->Pointer, Param[1]->Val->Integer, Param[2]->Val->Integer);
+void StringMemset(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = memset(_param[0]->Val->Pointer, _param[1]->Val->Integer, _param[2]->Val->Integer);
 }
 
-void StringMemcpy(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = memcpy(Param[0]->Val->Pointer, Param[1]->Val->Pointer, Param[2]->Val->Integer);
+void StringMemcpy(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = memcpy(_param[0]->Val->Pointer, _param[1]->Val->Pointer, _param[2]->Val->Integer);
 }
 
-void StringMemcmp(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = memcmp(Param[0]->Val->Pointer, Param[1]->Val->Pointer, Param[2]->Val->Integer);
+void StringMemcmp(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = memcmp(_param[0]->Val->Pointer, _param[1]->Val->Pointer, _param[2]->Val->Integer);
 }
 
-void StringMemmove(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = memmove(Param[0]->Val->Pointer, Param[1]->Val->Pointer, Param[2]->Val->Integer);
+void StringMemmove(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = memmove(_param[0]->Val->Pointer, _param[1]->Val->Pointer, _param[2]->Val->Integer);
 }
 
-void StringMemchr(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = memchr(Param[0]->Val->Pointer, Param[1]->Val->Integer, Param[2]->Val->Integer);
+void StringMemchr(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = memchr(_param[0]->Val->Pointer, _param[1]->Val->Integer, _param[2]->Val->Integer);
 }
 
-void StringStrchr(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = strchr(Param[0]->Val->Pointer, Param[1]->Val->Integer);
+void StringStrchr(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = strchr(_param[0]->Val->Pointer, _param[1]->Val->Integer);
 }
 
-void StringStrrchr(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = strrchr(Param[0]->Val->Pointer, Param[1]->Val->Integer);
+void StringStrrchr(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = strrchr(_param[0]->Val->Pointer, _param[1]->Val->Integer);
 }
 
-void StringStrcoll(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = strcoll(Param[0]->Val->Pointer, Param[1]->Val->Pointer);
+void StringStrcoll(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = strcoll(_param[0]->Val->Pointer, _param[1]->Val->Pointer);
 }
 
-void StringStrerror(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = strerror(Param[0]->Val->Integer);
+void StringStrerror(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = strerror(_param[0]->Val->Integer);
 }
 
-void StringStrspn(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = strspn(Param[0]->Val->Pointer, Param[1]->Val->Pointer);
+void StringStrspn(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = strspn(_param[0]->Val->Pointer, _param[1]->Val->Pointer);
 }
 
-void StringStrcspn(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = strcspn(Param[0]->Val->Pointer, Param[1]->Val->Pointer);
+void StringStrcspn(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = strcspn(_param[0]->Val->Pointer, _param[1]->Val->Pointer);
 }
 
-void StringStrpbrk(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = strpbrk(Param[0]->Val->Pointer, Param[1]->Val->Pointer);
+void StringStrpbrk(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = strpbrk(_param[0]->Val->Pointer, _param[1]->Val->Pointer);
 }
 
-void StringStrstr(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = strstr(Param[0]->Val->Pointer, Param[1]->Val->Pointer);
+void StringStrstr(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = strstr(_param[0]->Val->Pointer, _param[1]->Val->Pointer);
 }
 
-void StringStrtok(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = strtok(Param[0]->Val->Pointer, Param[1]->Val->Pointer);
+void StringStrtok(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = strtok(_param[0]->Val->Pointer, _param[1]->Val->Pointer);
 }
 
-void StringStrxfrm(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = strxfrm(Param[0]->Val->Pointer, Param[1]->Val->Pointer, Param[2]->Val->Integer);
+void StringStrxfrm(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = strxfrm(_param[0]->Val->Pointer, _param[1]->Val->Pointer, _param[2]->Val->Integer);
 }
 
-void StringStrdup(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = strdup(Param[0]->Val->Pointer);
+void StringStrdup(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = strdup(_param[0]->Val->Pointer);
 }
 
-void StringStrtok_r(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = strtok_r(Param[0]->Val->Pointer, Param[1]->Val->Pointer, Param[2]->Val->Pointer);
+void StringStrtok_r(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = strtok_r(_param[0]->Val->Pointer, _param[1]->Val->Pointer, _param[2]->Val->Pointer);
 }
 
 /* all string.h functions */
diff --git a/eci/cstdlib/string.h b/eci/cstdlib/string.h
new file mode 100644
index 0000000..d498bb3
--- /dev/null
+++ b/eci/cstdlib/string.h
@@ -0,0 +1,16 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2014, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE-2 (see license file)
+ */
+
+#ifndef __ECI_STRING_H__
+#define __ECI_STRING_H__
+
+
+extern struct LibraryFunction StringFunctions[];
+void StringSetupFunc();
+
+#endif
diff --git a/eci/cstdlib/time.c b/eci/cstdlib/time.c
index 018542f..b1f5f2f 100644
--- a/eci/cstdlib/time.c
+++ b/eci/cstdlib/time.c
@@ -22,53 +22,53 @@ static int CLK_PER_SECValue = CLK_PER_SEC;
 static int CLK_TCKValue = CLK_TCK;
 #endif
 
-void StdAsctime(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = asctime(Param[0]->Val->Pointer);
+void StdAsctime(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = asctime(_param[0]->Val->Pointer);
 }
 
-void StdClock(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = clock();
+void StdClock(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = clock();
 }
 
-void StdCtime(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = ctime(Param[0]->Val->Pointer);
+void StdCtime(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = ctime(_param[0]->Val->Pointer);
 }
 
-void StdDifftime(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->FP = difftime((time_t)Param[0]->Val->Integer, Param[1]->Val->Integer);
+void StdDifftime(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->FP = difftime((time_t)_param[0]->Val->Integer, _param[1]->Val->Integer);
 }
 
-void StdGmtime(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = gmtime(Param[0]->Val->Pointer);
+void StdGmtime(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = gmtime(_param[0]->Val->Pointer);
 }
 
-void StdGmtime_r(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = gmtime_r(Param[0]->Val->Pointer, Param[1]->Val->Pointer);
+void StdGmtime_r(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = gmtime_r(_param[0]->Val->Pointer, _param[1]->Val->Pointer);
 }
 
-void StdLocaltime(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = localtime(Param[0]->Val->Pointer);
+void StdLocaltime(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = localtime(_param[0]->Val->Pointer);
 }
 
-void StdMktime(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = mktime(Param[0]->Val->Pointer);
+void StdMktime(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = mktime(_param[0]->Val->Pointer);
 }
 
-void StdTime(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = time(Param[0]->Val->Pointer);
+void StdTime(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = time(_param[0]->Val->Pointer);
 }
 
-void StdStrftime(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = strftime(Param[0]->Val->Pointer, Param[1]->Val->Integer, Param[2]->Val->Pointer, Param[3]->Val->Pointer);
+void StdStrftime(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = strftime(_param[0]->Val->Pointer, _param[1]->Val->Integer, _param[2]->Val->Pointer, _param[3]->Val->Pointer);
 }
 
-void StdStrptime(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
+void StdStrptime(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
 	extern char *strptime(const char *s, const char *format, struct tm *tm);
-	ReturnValue->Val->Pointer = strptime(Param[0]->Val->Pointer, Param[1]->Val->Pointer, Param[2]->Val->Pointer);
+	_returnValue->Val->Pointer = strptime(_param[0]->Val->Pointer, _param[1]->Val->Pointer, _param[2]->Val->Pointer);
 }
 
-void StdTimegm(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = timegm(Param[0]->Val->Pointer);
+void StdTimegm(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = timegm(_param[0]->Val->Pointer);
 }
 
 /* handy structure definitions */
diff --git a/eci/cstdlib/time.h b/eci/cstdlib/time.h
new file mode 100644
index 0000000..7f01a57
--- /dev/null
+++ b/eci/cstdlib/time.h
@@ -0,0 +1,16 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2014, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE-2 (see license file)
+ */
+
+#ifndef __ECI_TIME_H__
+#define __ECI_TIME_H__
+
+extern const char StdTimeDefs[];
+extern struct LibraryFunction StdTimeFunctions[];
+void StdTimeSetupFunc();
+
+#endif
diff --git a/eci/cstdlib/unistd.c b/eci/cstdlib/unistd.c
index 58aabc1..3f014dd 100644
--- a/eci/cstdlib/unistd.c
+++ b/eci/cstdlib/unistd.c
@@ -16,268 +16,268 @@
 
 static int ZeroValue = 0;
 
-void UnistdAccess(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = access(Param[0]->Val->Pointer, Param[1]->Val->Integer);
+void UnistdAccess(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = access(_param[0]->Val->Pointer, _param[1]->Val->Integer);
 }
 
-void UnistdAlarm(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = alarm(Param[0]->Val->Integer);
+void UnistdAlarm(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = alarm(_param[0]->Val->Integer);
 }
 
-void UnistdChdir(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = chdir(Param[0]->Val->Pointer);
+void UnistdChdir(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = chdir(_param[0]->Val->Pointer);
 }
 
-void UnistdChroot(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = chroot(Param[0]->Val->Pointer);
+void UnistdChroot(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = chroot(_param[0]->Val->Pointer);
 }
 
-void UnistdChown(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = chown(Param[0]->Val->Pointer, Param[1]->Val->Integer, Param[2]->Val->Integer);
+void UnistdChown(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = chown(_param[0]->Val->Pointer, _param[1]->Val->Integer, _param[2]->Val->Integer);
 }
 
-void UnistdClose(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = close(Param[0]->Val->Integer);
+void UnistdClose(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = close(_param[0]->Val->Integer);
 }
 
-void UnistdConfstr(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = confstr(Param[0]->Val->Integer, Param[1]->Val->Pointer, Param[2]->Val->Integer);
+void UnistdConfstr(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = confstr(_param[0]->Val->Integer, _param[1]->Val->Pointer, _param[2]->Val->Integer);
 }
 
-void UnistdCtermid(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = ctermid(Param[0]->Val->Pointer);
+void UnistdCtermid(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = ctermid(_param[0]->Val->Pointer);
 }
 
-void UnistdDup(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = dup(Param[0]->Val->Integer);
+void UnistdDup(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = dup(_param[0]->Val->Integer);
 }
 
-void UnistdDup2(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = dup2(Param[0]->Val->Integer, Param[1]->Val->Integer);
+void UnistdDup2(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = dup2(_param[0]->Val->Integer, _param[1]->Val->Integer);
 }
 
-void Unistd_Exit(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	_exit(Param[0]->Val->Integer);
+void Unistd_Exit(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_exit(_param[0]->Val->Integer);
 }
 
-void UnistdFchown(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = fchown(Param[0]->Val->Integer, Param[1]->Val->Integer, Param[2]->Val->Integer);
+void UnistdFchown(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = fchown(_param[0]->Val->Integer, _param[1]->Val->Integer, _param[2]->Val->Integer);
 }
 
-void UnistdFchdir(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = fchdir(Param[0]->Val->Integer);
+void UnistdFchdir(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = fchdir(_param[0]->Val->Integer);
 }
 
-void UnistdFdatasync(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = fdatasync(Param[0]->Val->Integer);
+void UnistdFdatasync(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = fdatasync(_param[0]->Val->Integer);
 }
 
-void UnistdFork(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = fork();
+void UnistdFork(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = fork();
 }
 
-void UnistdFpathconf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = fpathconf(Param[0]->Val->Integer, Param[1]->Val->Integer);
+void UnistdFpathconf(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = fpathconf(_param[0]->Val->Integer, _param[1]->Val->Integer);
 }
 
-void UnistdFsync(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = fsync(Param[0]->Val->Integer);
+void UnistdFsync(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = fsync(_param[0]->Val->Integer);
 }
 
-void UnistdFtruncate(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = ftruncate(Param[0]->Val->Integer, Param[1]->Val->Integer);
+void UnistdFtruncate(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = ftruncate(_param[0]->Val->Integer, _param[1]->Val->Integer);
 }
 
-void UnistdGetcwd(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = getcwd(Param[0]->Val->Pointer, Param[1]->Val->Integer);
+void UnistdGetcwd(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = getcwd(_param[0]->Val->Pointer, _param[1]->Val->Integer);
 }
 
-void UnistdGetdtablesize(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = getdtablesize();
+void UnistdGetdtablesize(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = getdtablesize();
 }
 
-void UnistdGetegid(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = getegid();
+void UnistdGetegid(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = getegid();
 }
 
-void UnistdGeteuid(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = geteuid();
+void UnistdGeteuid(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = geteuid();
 }
 
-void UnistdGetgid(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = getgid();
+void UnistdGetgid(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = getgid();
 }
 
-void UnistdGethostid(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = gethostid();
+void UnistdGethostid(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = gethostid();
 }
 
-void UnistdGetlogin(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = getlogin();
+void UnistdGetlogin(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = getlogin();
 }
 
-void UnistdGetlogin_r(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = getlogin_r(Param[0]->Val->Pointer, Param[1]->Val->Integer);
+void UnistdGetlogin_r(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = getlogin_r(_param[0]->Val->Pointer, _param[1]->Val->Integer);
 }
 
-void UnistdGetpagesize(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = getpagesize();
+void UnistdGetpagesize(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = getpagesize();
 }
 
-void UnistdGetpass(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = getpass(Param[0]->Val->Pointer);
+void UnistdGetpass(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = getpass(_param[0]->Val->Pointer);
 }
 
-void UnistdGetpgrp(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = getpgrp();
+void UnistdGetpgrp(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = getpgrp();
 }
 
-void UnistdGetpid(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = getpid();
+void UnistdGetpid(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = getpid();
 }
 
-void UnistdGetppid(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = getppid();
+void UnistdGetppid(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = getppid();
 }
 
-void UnistdGetuid(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = getuid();
+void UnistdGetuid(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = getuid();
 }
 
-void UnistdGetwd(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = getcwd(Param[0]->Val->Pointer, PATH_MAX);
+void UnistdGetwd(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = getcwd(_param[0]->Val->Pointer, PATH_MAX);
 }
 
-void UnistdIsatty(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = isatty(Param[0]->Val->Integer);
+void UnistdIsatty(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = isatty(_param[0]->Val->Integer);
 }
 
-void UnistdLchown(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = lchown(Param[0]->Val->Pointer, Param[1]->Val->Integer, Param[2]->Val->Integer);
+void UnistdLchown(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = lchown(_param[0]->Val->Pointer, _param[1]->Val->Integer, _param[2]->Val->Integer);
 }
 
-void UnistdLink(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = link(Param[0]->Val->Pointer, Param[1]->Val->Pointer);
+void UnistdLink(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = link(_param[0]->Val->Pointer, _param[1]->Val->Pointer);
 }
 
-void UnistdLockf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = lockf(Param[0]->Val->Integer, Param[1]->Val->Integer, Param[2]->Val->Integer);
+void UnistdLockf(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = lockf(_param[0]->Val->Integer, _param[1]->Val->Integer, _param[2]->Val->Integer);
 }
 
-void UnistdLseek(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = lseek(Param[0]->Val->Integer, Param[1]->Val->Integer, Param[2]->Val->Integer);
+void UnistdLseek(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = lseek(_param[0]->Val->Integer, _param[1]->Val->Integer, _param[2]->Val->Integer);
 }
 
-void UnistdNice(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = nice(Param[0]->Val->Integer);
+void UnistdNice(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = nice(_param[0]->Val->Integer);
 }
 
-void UnistdPathconf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = pathconf(Param[0]->Val->Pointer, Param[1]->Val->Integer);
+void UnistdPathconf(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = pathconf(_param[0]->Val->Pointer, _param[1]->Val->Integer);
 }
 
-void UnistdPause(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = pause();
+void UnistdPause(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = pause();
 }
 
-void UnistdRead(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = read(Param[0]->Val->Integer, Param[1]->Val->Pointer, Param[2]->Val->Integer);
+void UnistdRead(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = read(_param[0]->Val->Integer, _param[1]->Val->Pointer, _param[2]->Val->Integer);
 }
 
-void UnistdReadlink(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = readlink(Param[0]->Val->Pointer, Param[1]->Val->Pointer, Param[2]->Val->Integer);
+void UnistdReadlink(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = readlink(_param[0]->Val->Pointer, _param[1]->Val->Pointer, _param[2]->Val->Integer);
 }
 
-void UnistdRmdir(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = rmdir(Param[0]->Val->Pointer);
+void UnistdRmdir(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = rmdir(_param[0]->Val->Pointer);
 }
 
-void UnistdSbrk(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = sbrk(Param[0]->Val->Integer);
+void UnistdSbrk(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = sbrk(_param[0]->Val->Integer);
 }
 
-void UnistdSetgid(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = setgid(Param[0]->Val->Integer);
+void UnistdSetgid(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = setgid(_param[0]->Val->Integer);
 }
 
-void UnistdSetpgid(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = setpgid(Param[0]->Val->Integer, Param[1]->Val->Integer);
+void UnistdSetpgid(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = setpgid(_param[0]->Val->Integer, _param[1]->Val->Integer);
 }
 
-void UnistdSetpgrp(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = setpgrp();
+void UnistdSetpgrp(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = setpgrp();
 }
 
-void UnistdSetregid(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = setregid(Param[0]->Val->Integer, Param[1]->Val->Integer);
+void UnistdSetregid(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = setregid(_param[0]->Val->Integer, _param[1]->Val->Integer);
 }
 
-void UnistdSetreuid(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = setreuid(Param[0]->Val->Integer, Param[1]->Val->Integer);
+void UnistdSetreuid(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = setreuid(_param[0]->Val->Integer, _param[1]->Val->Integer);
 }
 
-void UnistdSetsid(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = setsid();
+void UnistdSetsid(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = setsid();
 }
 
-void UnistdSetuid(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = setuid(Param[0]->Val->Integer);
+void UnistdSetuid(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = setuid(_param[0]->Val->Integer);
 }
 
-void UnistdSleep(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = sleep(Param[0]->Val->Integer);
+void UnistdSleep(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = sleep(_param[0]->Val->Integer);
 }
 
-void UnistdSymlink(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = symlink(Param[0]->Val->Pointer, Param[1]->Val->Pointer);
+void UnistdSymlink(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = symlink(_param[0]->Val->Pointer, _param[1]->Val->Pointer);
 }
 
-void UnistdSync(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
+void UnistdSync(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
 	sync();
 }
 
-void UnistdSysconf(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = sysconf(Param[0]->Val->Integer);
+void UnistdSysconf(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = sysconf(_param[0]->Val->Integer);
 }
 
-void UnistdTcgetpgrp(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = tcgetpgrp(Param[0]->Val->Integer);
+void UnistdTcgetpgrp(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = tcgetpgrp(_param[0]->Val->Integer);
 }
 
-void UnistdTcsetpgrp(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = tcsetpgrp(Param[0]->Val->Integer, Param[1]->Val->Integer);
+void UnistdTcsetpgrp(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = tcsetpgrp(_param[0]->Val->Integer, _param[1]->Val->Integer);
 }
 
-void UnistdTruncate(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = truncate(Param[0]->Val->Pointer, Param[1]->Val->Integer);
+void UnistdTruncate(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = truncate(_param[0]->Val->Pointer, _param[1]->Val->Integer);
 }
 
-void UnistdTtyname(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Pointer = ttyname(Param[0]->Val->Integer);
+void UnistdTtyname(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Pointer = ttyname(_param[0]->Val->Integer);
 }
 
-void UnistdTtyname_r(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = ttyname_r(Param[0]->Val->Integer, Param[1]->Val->Pointer, Param[2]->Val->Integer);
+void UnistdTtyname_r(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = ttyname_r(_param[0]->Val->Integer, _param[1]->Val->Pointer, _param[2]->Val->Integer);
 }
 
-void UnistdUalarm(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = ualarm(Param[0]->Val->Integer, Param[1]->Val->Integer);
+void UnistdUalarm(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = ualarm(_param[0]->Val->Integer, _param[1]->Val->Integer);
 }
 
-void UnistdUnlink(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = unlink(Param[0]->Val->Pointer);
+void UnistdUnlink(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = unlink(_param[0]->Val->Pointer);
 }
 
-void UnistdUsleep(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = usleep(Param[0]->Val->Integer);
+void UnistdUsleep(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = usleep(_param[0]->Val->Integer);
 }
 
-void UnistdVfork(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = vfork();
+void UnistdVfork(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = vfork();
 }
 
-void UnistdWrite(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) {
-	ReturnValue->Val->Integer = write(Param[0]->Val->Integer, Param[1]->Val->Pointer, Param[2]->Val->Integer);
+void UnistdWrite(struct ParseState *_parser, struct Value *_returnValue, struct Value **_param, int _numArgs) {
+	_returnValue->Val->Integer = write(_param[0]->Val->Integer, _param[1]->Val->Pointer, _param[2]->Val->Integer);
 }
 
 
diff --git a/eci/cstdlib/unistd.h b/eci/cstdlib/unistd.h
new file mode 100644
index 0000000..6cd20dd
--- /dev/null
+++ b/eci/cstdlib/unistd.h
@@ -0,0 +1,17 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2014, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE-2 (see license file)
+ */
+
+#ifndef __ECI_UNI_STD_H__
+#define __ECI_UNI_STD_H__
+
+
+extern const char UnistdDefs[];
+extern struct LibraryFunction UnistdFunctions[];
+void UnistdSetupFunc();
+
+#endif
diff --git a/eci/expression.c b/eci/expression.c
index cc28d64..f60a68a 100644
--- a/eci/expression.c
+++ b/eci/expression.c
@@ -99,58 +99,58 @@ static struct OpPrecedence OperatorPrecedence[] =
 	/* TokenCloseBracket, */ { 0, 15, 0, ")" }
 };
 
-void ExpressionParseFunctionCall(struct ParseState *_parser, struct ExpressionStack **StackTop, const char *FuncName, int RunIt);
+void ExpressionParseFunctionCall(struct ParseState *_parser, struct ExpressionStack **_stackTop, const char *_funcName, int _runIt);
 
 #ifdef DEBUG_EXPRESSIONS
 /* show the contents of the expression stack */
-void ExpressionStackShow(struct ExpressionStack *StackTop) {
-	printf("Expression stack [0x%lx,0x%lx]: ", (long)HeapStackTop, (long)StackTop);
+void ExpressionStackShow(struct ExpressionStack *_stackTop) {
+	printf("Expression stack [0x%lx,0x%lx]: ", (long)HeapStackTop, (long)_stackTop);
 	
-	while (StackTop != NULL) {
-		if (StackTop->Order == OrderNone) { 
+	while (_stackTop != NULL) {
+		if (_stackTop->Order == OrderNone) { 
 			/* it's a value */
-			if (StackTop->Val->IsLValue) {
+			if (_stackTop->Val->IsLValue) {
 				printf("lvalue=");
 			}else {
 				printf("value=");
 			}
-			switch (StackTop->Val->Typ->Base) {
+			switch (_stackTop->Val->Typ->Base) {
 				case TypeVoid:          printf("void"); break;
-				case TypeInt:           printf("%d:int", StackTop->Val->Val->Integer); break;
-				case TypeShort:         printf("%d:short", StackTop->Val->Val->ShortInteger); break;
-				case TypeChar:          printf("%d:char", StackTop->Val->Val->Character); break;
-				case TypeLong:          printf("%d:long", StackTop->Val->Val->LongInteger); break;
-				case TypeUnsignedShort: printf("%d:unsigned short", StackTop->Val->Val->UnsignedShortInteger); break;
-				case TypeUnsignedInt:   printf("%d:unsigned int", StackTop->Val->Val->UnsignedInteger); break;
-				case TypeUnsignedLong:  printf("%d:unsigned long", StackTop->Val->Val->UnsignedLongInteger); break;
-				case TypeFP:            printf("%f:fp", StackTop->Val->Val->FP); break;
-				case TypeFunction:      printf("%s:function", StackTop->Val->Val->Identifier); break;
-				case TypeMacro:         printf("%s:macro", StackTop->Val->Val->Identifier); break;
+				case TypeInt:           printf("%d:int", _stackTop->Val->Val->Integer); break;
+				case TypeShort:         printf("%d:short", _stackTop->Val->Val->ShortInteger); break;
+				case TypeChar:          printf("%d:char", _stackTop->Val->Val->Character); break;
+				case TypeLong:          printf("%d:long", _stackTop->Val->Val->LongInteger); break;
+				case TypeUnsignedShort: printf("%d:unsigned short", _stackTop->Val->Val->UnsignedShortInteger); break;
+				case TypeUnsignedInt:   printf("%d:unsigned int", _stackTop->Val->Val->UnsignedInteger); break;
+				case TypeUnsignedLong:  printf("%d:unsigned long", _stackTop->Val->Val->UnsignedLongInteger); break;
+				case TypeFP:            printf("%f:fp", _stackTop->Val->Val->FP); break;
+				case TypeFunction:      printf("%s:function", _stackTop->Val->Val->Identifier); break;
+				case TypeMacro:         printf("%s:macro", _stackTop->Val->Val->Identifier); break;
 				case TypePointer:
-					if (StackTop->Val->Val->Pointer == NULL)
+					if (_stackTop->Val->Val->Pointer == NULL)
 						printf("ptr(NULL)");
-					else if (StackTop->Val->Typ->FromType->Base == TypeChar)
-						printf("\"%s\":string", (char *)StackTop->Val->Val->Pointer);
+					else if (_stackTop->Val->Typ->FromType->Base == TypeChar)
+						printf("\"%s\":string", (char *)_stackTop->Val->Val->Pointer);
 					else
-						printf("ptr(0x%lx)", (long)StackTop->Val->Val->Pointer); 
+						printf("ptr(0x%lx)", (long)_stackTop->Val->Val->Pointer); 
 					break;
 				case TypeArray:   printf("array"); break;
-				case TypeStruct:  printf("%s:struct", StackTop->Val->Val->Identifier); break;
-				case TypeUnion:   printf("%s:union", StackTop->Val->Val->Identifier); break;
-				case TypeEnum:    printf("%s:enum", StackTop->Val->Val->Identifier); break;
-				case Type_Type:   PrintType(StackTop->Val->Val->Typ, CStdOut); printf(":type"); break;
+				case TypeStruct:  printf("%s:struct", _stackTop->Val->Val->Identifier); break;
+				case TypeUnion:   printf("%s:union", _stackTop->Val->Val->Identifier); break;
+				case TypeEnum:    printf("%s:enum", _stackTop->Val->Val->Identifier); break;
+				case Type_Type:   PrintType(_stackTop->Val->Val->Typ, CStdOut); printf(":type"); break;
 				default:          printf("unknown"); break;
 			}
-			printf("[0x%lx,0x%lx]", (long)StackTop, (long)StackTop->Val);
+			printf("[0x%lx,0x%lx]", (long)_stackTop, (long)_stackTop->Val);
 		} else {
 			/* it's an operator */
-			printf("op='%s' %s %d", OperatorPrecedence[(int)StackTop->Op].Name, 
-				(StackTop->Order == OrderPrefix) ? "prefix" : ((StackTop->Order == OrderPostfix) ? "postfix" : "infix"), 
-				StackTop->Precedence);
-			printf("[0x%lx]", (long)StackTop);
+			printf("op='%s' %s %d", OperatorPrecedence[(int)_stackTop->Op].Name, 
+				(_stackTop->Order == OrderPrefix) ? "prefix" : ((_stackTop->Order == OrderPostfix) ? "postfix" : "infix"), 
+				_stackTop->Precedence);
+			printf("[0x%lx]", (long)_stackTop);
 		}
-		StackTop = StackTop->Next;
-		if (StackTop != NULL) {
+		_stackTop = _stackTop->Next;
+		if (_stackTop != NULL) {
 			printf(", ");
 		}
 	}
@@ -158,143 +158,111 @@ void ExpressionStackShow(struct ExpressionStack *StackTop) {
 }
 #endif
 
-long ExpressionCoerceInteger(struct Value *Val) {
-	switch (Val->Typ->Base) {
+long ExpressionCoerceInteger(struct Value *_value) {
+	switch (_value->Typ->Base) {
 		case TypeInt:
-			return (long)Val->Val->Integer;
+			return (long)_value->Val->Integer;
 		case TypeChar:
-			return (long)Val->Val->Character;
+			return (long)_value->Val->Character;
 		case TypeShort:
-			return (long)Val->Val->ShortInteger;
+			return (long)_value->Val->ShortInteger;
 		case TypeLong:
-			return (long)Val->Val->LongInteger;
+			return (long)_value->Val->LongInteger;
 		case TypeUnsignedInt:
-			return (long)Val->Val->UnsignedInteger;
+			return (long)_value->Val->UnsignedInteger;
 		case TypeUnsignedShort:
-			return (long)Val->Val->UnsignedShortInteger;
+			return (long)_value->Val->UnsignedShortInteger;
 		case TypeUnsignedLong:
-			return (long)Val->Val->UnsignedLongInteger;
+			return (long)_value->Val->UnsignedLongInteger;
 		case TypePointer:
-			return (long)Val->Val->Pointer;
+			return (long)_value->Val->Pointer;
 		case TypeFP:
-			return (long)Val->Val->FP;
+			return (long)_value->Val->FP;
 		default:
 			return 0;
 	}
 }
 
-unsigned long ExpressionCoerceUnsignedInteger(struct Value *Val) {
-	switch (Val->Typ->Base) {
+unsigned long ExpressionCoerceUnsignedInteger(struct Value *_value) {
+	switch (_value->Typ->Base) {
 		case TypeInt:
-			return (unsigned long)Val->Val->Integer;
+			return (unsigned long)_value->Val->Integer;
 		case TypeChar:
-			return (unsigned long)Val->Val->Character;
+			return (unsigned long)_value->Val->Character;
 		case TypeShort:
-			return (unsigned long)Val->Val->ShortInteger;
+			return (unsigned long)_value->Val->ShortInteger;
 		case TypeLong:
-			return (unsigned long)Val->Val->LongInteger;
+			return (unsigned long)_value->Val->LongInteger;
 		case TypeUnsignedInt:
-			return (unsigned long)Val->Val->UnsignedInteger;
+			return (unsigned long)_value->Val->UnsignedInteger;
 		case TypeUnsignedShort:
-			return (unsigned long)Val->Val->UnsignedShortInteger;
+			return (unsigned long)_value->Val->UnsignedShortInteger;
 		case TypeUnsignedLong:
-			return (unsigned long)Val->Val->UnsignedLongInteger;
+			return (unsigned long)_value->Val->UnsignedLongInteger;
 		case TypePointer:
-			return (unsigned long)Val->Val->Pointer;
+			return (unsigned long)_value->Val->Pointer;
 		case TypeFP:
-			return (unsigned long)Val->Val->FP;
+			return (unsigned long)_value->Val->FP;
 		default:
 			return 0;
 	}
 }
 
-double ExpressionCoerceFP(struct Value *Val) {
-#ifndef BROKEN_FLOAT_CASTS
-	int IntVal;
-	unsigned UnsignedVal;
-	switch (Val->Typ->Base) {
+double ExpressionCoerceFP(struct Value *_value) {
+	switch (_value->Typ->Base) {
 		case TypeInt:
-			IntVal = Val->Val->Integer;
-			return (double)IntVal;
+			return (double)_value->Val->Integer;
 		case TypeChar:
-			IntVal = Val->Val->Character;
-			return (double)IntVal;
+			return (double)_value->Val->Character;
 		case TypeShort:
-			IntVal = Val->Val->ShortInteger;
-			return (double)IntVal;
+			return (double)_value->Val->ShortInteger;
 		case TypeLong:
-			IntVal = Val->Val->LongInteger;
-			return (double)IntVal;
+			return (double)_value->Val->LongInteger;
 		case TypeUnsignedInt:
-			UnsignedVal = Val->Val->UnsignedInteger;
-			return (double)UnsignedVal;
+			return (double)_value->Val->UnsignedInteger;
 		case TypeUnsignedShort:
-			UnsignedVal = Val->Val->UnsignedShortInteger;
-			return (double)UnsignedVal;
+			return (double)_value->Val->UnsignedShortInteger;
 		case TypeUnsignedLong:
-			UnsignedVal = Val->Val->UnsignedLongInteger;
-			return (double)UnsignedVal;
+			return (double)_value->Val->UnsignedLongInteger;
 		case TypeFP:
-			return Val->Val->FP;
+			return (double)_value->Val->FP;
 		default:
 			return 0.0;
 	}
-#else
-	switch (Val->Typ->Base) {
-		case TypeInt:
-			return (double)Val->Val->Integer;
-		case TypeChar:
-			return (double)Val->Val->Character;
-		case TypeShort:
-			return (double)Val->Val->ShortInteger;
-		case TypeLong:
-			return (double)Val->Val->LongInteger;
-		case TypeUnsignedInt:
-			return (double)Val->Val->UnsignedInteger;
-		case TypeUnsignedShort:
-			return (double)Val->Val->UnsignedShortInteger;
-		case TypeUnsignedLong:
-			return (double)Val->Val->UnsignedLongInteger;
-		case TypeFP:
-			return (double)Val->Val->FP;
-		default:
-			return 0.0;
-	}
-#endif
 }
 
 /* assign an integer value */
-long ExpressionAssignInt(struct ParseState *_parser, struct Value *DestValue, long FromInt, int After) {
+long ExpressionAssignInt(struct ParseState *_parser, struct Value *_destValue, long _fromInt, int _after) {
 	long Result;
-	if (!DestValue->IsLValue) {
+	if (!_destValue->IsLValue) {
 		ProgramFail(_parser, "can't assign to this"); 
 	}
-	if (After) {
-		Result = ExpressionCoerceInteger(DestValue);
+	if (_after) {
+		Result = ExpressionCoerceInteger(_destValue);
 	} else {
-		Result = FromInt;
+		Result = _fromInt;
 	}
-	switch (DestValue->Typ->Base) {
+	switch (_destValue->Typ->Base) {
 		case TypeInt:
-			DestValue->Val->Integer = FromInt;
+			_destValue->Val->Integer = _fromInt;
 			break;
 		case TypeShort:
-			DestValue->Val->ShortInteger = (short)FromInt;
+			_destValue->Val->ShortInteger = (short)_fromInt;
 			break;
 		case TypeChar:
-			DestValue->Val->Character = (unsigned char)FromInt;
+			_destValue->Val->Character = (unsigned char)_fromInt;
 			break;
 		case TypeLong:
-			DestValue->Val->LongInteger = (long)FromInt;
+			_destValue->Val->LongInteger = (long)_fromInt;
 			break;
 		case TypeUnsignedInt:
-			DestValue->Val->UnsignedInteger = (unsigned int)FromInt;
+			_destValue->Val->UnsignedInteger = (unsigned int)_fromInt;
 			break;
 		case TypeUnsignedShort:
-			DestValue->Val->UnsignedShortInteger = (unsigned short)FromInt;
+			_destValue->Val->UnsignedShortInteger = (unsigned short)_fromInt;
 			break;
 		case TypeUnsignedLong:
-			DestValue->Val->UnsignedLongInteger = (unsigned long)FromInt;
+			_destValue->Val->UnsignedLongInteger = (unsigned long)_fromInt;
 			break;
 		default:
 			break;
@@ -303,246 +271,279 @@ long ExpressionAssignInt(struct ParseState *_parser, struct Value *DestValue, lo
 }
 
 /* assign a floating point value */
-double ExpressionAssignFP(struct ParseState *_parser, struct Value *DestValue, double FromFP) {
-	if (!DestValue->IsLValue) {
+double ExpressionAssignFP(struct ParseState *_parser, struct Value *_destValue, double _fromFP) {
+	if (!_destValue->IsLValue) {
 		ProgramFail(_parser, "can't assign to this"); 
 	}
-	DestValue->Val->FP = FromFP;
-	return FromFP;
+	_destValue->Val->FP = _fromFP;
+	return _fromFP;
 }
 
 /* push a node on to the expression stack */
-void ExpressionStackPushValueNode(struct ParseState *_parser, struct ExpressionStack **StackTop, struct Value *ValueLoc) {
+void ExpressionStackPushValueNode(struct ParseState *_parser, struct ExpressionStack **_stackTop, struct Value *_valueLoc) {
 	struct ExpressionStack *StackNode = VariableAlloc(_parser, sizeof(struct ExpressionStack), FALSE);
-	StackNode->Next = *StackTop;
-	StackNode->Val = ValueLoc;
-	*StackTop = StackNode;
+	StackNode->Next = *_stackTop;
+	StackNode->Val = _valueLoc;
+	*_stackTop = StackNode;
 #ifdef FANCY_ERROR_MESSAGES
 	StackNode->Line = _parser->Line;
 	StackNode->CharacterPos = _parser->CharacterPos;
 #endif
 #ifdef DEBUG_EXPRESSIONS
-	ExpressionStackShow(*StackTop);
+	ExpressionStackShow(*_stackTop);
 #endif
 }
 
 /* push a blank value on to the expression stack by type */
-struct Value *ExpressionStackPushValueByType(struct ParseState *_parser, struct ExpressionStack **StackTop, struct ValueType *PushType) {
-	struct Value *ValueLoc = VariableAllocValueFromType(_parser, PushType, FALSE, NULL, FALSE);
-	ExpressionStackPushValueNode(_parser, StackTop, ValueLoc);
-	return ValueLoc;
+struct Value *ExpressionStackPushValueByType(struct ParseState *_parser,
+                                             struct ExpressionStack **_stackTop,
+                                             struct ValueType *_pushType) {
+	struct Value *valueLoc = VariableAllocValueFromType(_parser, _pushType, FALSE, NULL, FALSE);
+	ExpressionStackPushValueNode(_parser, _stackTop, valueLoc);
+	return valueLoc;
 }
 
 /* push a value on to the expression stack */
-void ExpressionStackPushValue(struct ParseState *_parser, struct ExpressionStack **StackTop, struct Value *PushValue) {
-	struct Value *ValueLoc = VariableAllocValueAndCopy(_parser, PushValue, FALSE);
-	ExpressionStackPushValueNode(_parser, StackTop, ValueLoc);
+void ExpressionStackPushValue(struct ParseState *_parser,
+                              struct ExpressionStack **_stackTop,
+                              struct Value *_pushValue) {
+	struct Value *valueLoc = VariableAllocValueAndCopy(_parser, _pushValue, FALSE);
+	ExpressionStackPushValueNode(_parser, _stackTop, valueLoc);
 }
 
-void ExpressionStackPushLValue(struct ParseState *_parser, struct ExpressionStack **StackTop, struct Value *PushValue, int Offset) {
-	struct Value *ValueLoc = VariableAllocValueShared(_parser, PushValue);
-	ValueLoc->Val = (void *)((char *)ValueLoc->Val + Offset);
-	ExpressionStackPushValueNode(_parser, StackTop, ValueLoc);
+void ExpressionStackPushLValue(struct ParseState *_parser,
+                               struct ExpressionStack **_stackTop,
+                               struct Value *_pushValue,
+                               int Offset) {
+	struct Value *valueLoc = VariableAllocValueShared(_parser, _pushValue);
+	valueLoc->Val = (void *)((char *)valueLoc->Val + Offset);
+	ExpressionStackPushValueNode(_parser, _stackTop, valueLoc);
 }
 
-void ExpressionStackPushDereference(struct ParseState *_parser, struct ExpressionStack **StackTop, struct Value *DereferenceValue) {
+void ExpressionStackPushDereference(struct ParseState *_parser,
+                                    struct ExpressionStack **_stackTop,
+                                    struct Value *_dereferenceValue) {
 	struct Value *DerefVal;
-	struct Value *ValueLoc;
+	struct Value *valueLoc;
 	int Offset;
 	struct ValueType *DerefType;
 	int DerefIsLValue;
-	void *DerefDataLoc = VariableDereferencePointer(_parser, DereferenceValue, &DerefVal, &Offset, &DerefType, &DerefIsLValue);
+	void *DerefDataLoc = VariableDereferencePointer(_parser, _dereferenceValue, &DerefVal, &Offset, &DerefType, &DerefIsLValue);
 	if (DerefDataLoc == NULL) {
 		ProgramFail(_parser, "NULL pointer dereference");
 	}
-	ValueLoc = VariableAllocValueFromExistingData(_parser, DerefType, (union AnyValue *)DerefDataLoc, DerefIsLValue, DerefVal);
-	ExpressionStackPushValueNode(_parser, StackTop, ValueLoc);
+	valueLoc = VariableAllocValueFromExistingData(_parser, DerefType, (union AnyValue *)DerefDataLoc, DerefIsLValue, DerefVal);
+	ExpressionStackPushValueNode(_parser, _stackTop, valueLoc);
 }
 
-void ExpressionPushInt(struct ParseState *_parser, struct ExpressionStack **StackTop, long IntValue) {
-	struct Value *ValueLoc = VariableAllocValueFromType(_parser, &IntType, FALSE, NULL, FALSE);
-	ValueLoc->Val->Integer = IntValue;
-	ExpressionStackPushValueNode(_parser, StackTop, ValueLoc);
+void ExpressionPushInt(struct ParseState *_parser,
+                       struct ExpressionStack **_stackTop,
+                       long _intValue) {
+	struct Value *valueLoc = VariableAllocValueFromType(_parser, &IntType, FALSE, NULL, FALSE);
+	valueLoc->Val->Integer = _intValue;
+	ExpressionStackPushValueNode(_parser, _stackTop, valueLoc);
 }
 
-void ExpressionPushFP(struct ParseState *_parser, struct ExpressionStack **StackTop, double FPValue) {
-	struct Value *ValueLoc = VariableAllocValueFromType(_parser, &FPType, FALSE, NULL, FALSE);
-	ValueLoc->Val->FP = FPValue;
-	ExpressionStackPushValueNode(_parser, StackTop, ValueLoc);
+void ExpressionPushFP(struct ParseState *_parser,
+                      struct ExpressionStack **_stackTop,
+                      double _fPValue) {
+	struct Value *valueLoc = VariableAllocValueFromType(_parser, &FPType, FALSE, NULL, FALSE);
+	valueLoc->Val->FP = _fPValue;
+	ExpressionStackPushValueNode(_parser, _stackTop, valueLoc);
 }
 
 /* assign to a pointer */
-void ExpressionAssignToPointer(struct ParseState *_parser, struct Value *ToValue, struct Value *FromValue, const char *FuncName, int ParamNo, int AllowPointerCoercion) {
-	struct ValueType *PointedToType = ToValue->Typ->FromType;
-	if (    FromValue->Typ == ToValue->Typ
-	     || FromValue->Typ == VoidPtrType
-	     || (    ToValue->Typ == VoidPtrType
-	          && FromValue->Typ->Base == TypePointer) ) {
+void ExpressionAssignToPointer(struct ParseState *_parser,
+                               struct Value *_toValue,
+                               struct Value *_fromValue,
+                               const char *_funcName,
+                               int _paramNo,
+                               int _allowPointerCoercion) {
+	struct ValueType *PointedToType = _toValue->Typ->FromType;
+	if (    _fromValue->Typ == _toValue->Typ
+	     || _fromValue->Typ == VoidPtrType
+	     || (    _toValue->Typ == VoidPtrType
+	          && _fromValue->Typ->Base == TypePointer) ) {
 		// plain old pointer assignment
-		ToValue->Val->Pointer = FromValue->Val->Pointer;
-	} else if (    FromValue->Typ->Base == TypeArray
-	            && (    PointedToType == FromValue->Typ->FromType
-	                 || ToValue->Typ == VoidPtrType) ) {
+		_toValue->Val->Pointer = _fromValue->Val->Pointer;
+	} else if (    _fromValue->Typ->Base == TypeArray
+	            && (    PointedToType == _fromValue->Typ->FromType
+	                 || _toValue->Typ == VoidPtrType) ) {
 		// the form is: blah *x = array of blah
-		ToValue->Val->Pointer = (void *)&FromValue->Val->ArrayMem[0];
-	} else if (    FromValue->Typ->Base == TypePointer
-	            && FromValue->Typ->FromType->Base == TypeArray
-	            && (    PointedToType == FromValue->Typ->FromType->FromType
-	                 || ToValue->Typ == VoidPtrType) ) {
+		_toValue->Val->Pointer = (void *)&_fromValue->Val->ArrayMem[0];
+	} else if (    _fromValue->Typ->Base == TypePointer
+	            && _fromValue->Typ->FromType->Base == TypeArray
+	            && (    PointedToType == _fromValue->Typ->FromType->FromType
+	                 || _toValue->Typ == VoidPtrType) ) {
 		// the form is: blah *x = pointer to array of blah
-		ToValue->Val->Pointer = VariableDereferencePointer(_parser, FromValue, NULL, NULL, NULL, NULL);
-	} else if (    IS_NUMERIC_COERCIBLE(FromValue)
-	            && ExpressionCoerceInteger(FromValue) == 0){
+		_toValue->Val->Pointer = VariableDereferencePointer(_parser, _fromValue, NULL, NULL, NULL, NULL);
+	} else if (    IS_NUMERIC_COERCIBLE(_fromValue)
+	            && ExpressionCoerceInteger(_fromValue) == 0){
 		// null pointer assignment
-		ToValue->Val->Pointer = NULL;
-	} else if (AllowPointerCoercion && IS_NUMERIC_COERCIBLE(FromValue)) {
+		_toValue->Val->Pointer = NULL;
+	} else if (_allowPointerCoercion && IS_NUMERIC_COERCIBLE(_fromValue)) {
 		// assign integer to native pointer
-		ToValue->Val->Pointer = (void *)(unsigned long)ExpressionCoerceUnsignedInteger(FromValue);
-	} else if (    AllowPointerCoercion
-	            && FromValue->Typ->Base == TypePointer) {
+		_toValue->Val->Pointer = (void *)(unsigned long)ExpressionCoerceUnsignedInteger(_fromValue);
+	} else if (    _allowPointerCoercion
+	            && _fromValue->Typ->Base == TypePointer) {
 		/* assign a pointer to a pointer to a different type */
-		ToValue->Val->Pointer = FromValue->Val->Pointer;
+		_toValue->Val->Pointer = _fromValue->Val->Pointer;
 	} else {
-		AssignFail(_parser, "%t from %t", ToValue->Typ, FromValue->Typ, 0, 0, FuncName, ParamNo); 
+		AssignFail(_parser, "%t from %t", _toValue->Typ, _fromValue->Typ, 0, 0, _funcName, _paramNo); 
 	}
 }
 
 /* assign any kind of value */
-void ExpressionAssign(struct ParseState *_parser, struct Value *DestValue, struct Value *SourceValue, int Force, const char *FuncName, int ParamNo, int AllowPointerCoercion) {
-	if (    !DestValue->IsLValue
-	     && !Force) {
-		AssignFail(_parser, "not an lvalue", NULL, NULL, 0, 0, FuncName, ParamNo); 
+void ExpressionAssign(struct ParseState *_parser,
+                      struct Value *_destValue,
+                      struct Value *_sourceValue,
+                      int _force,
+                      const char *_funcName,
+                      int _paramNo,
+                      int _allowPointerCoercion) {
+	if (    !_destValue->IsLValue
+	     && !_force) {
+		AssignFail(_parser, "not an lvalue", NULL, NULL, 0, 0, _funcName, _paramNo); 
 	}
-	if (    IS_NUMERIC_COERCIBLE(DestValue)
-	     && !IS_NUMERIC_COERCIBLE_PLUS_POINTERS(SourceValue, AllowPointerCoercion)) {
-		AssignFail(_parser, "%t from %t", DestValue->Typ, SourceValue->Typ, 0, 0, FuncName, ParamNo); 
+	if (    IS_NUMERIC_COERCIBLE(_destValue)
+	     && !IS_NUMERIC_COERCIBLE_PLUS_POINTERS(_sourceValue, _allowPointerCoercion)) {
+		AssignFail(_parser, "%t from %t", _destValue->Typ, _sourceValue->Typ, 0, 0, _funcName, _paramNo); 
 	}
-	switch (DestValue->Typ->Base) {
+	switch (_destValue->Typ->Base) {
 		case TypeInt:
-			DestValue->Val->Integer = ExpressionCoerceInteger(SourceValue);
+			_destValue->Val->Integer = ExpressionCoerceInteger(_sourceValue);
 			break;
 		case TypeShort:
-			DestValue->Val->ShortInteger = ExpressionCoerceInteger(SourceValue);
+			_destValue->Val->ShortInteger = ExpressionCoerceInteger(_sourceValue);
 			break;
 		case TypeChar:
-			DestValue->Val->Character = ExpressionCoerceUnsignedInteger(SourceValue);
+			_destValue->Val->Character = ExpressionCoerceUnsignedInteger(_sourceValue);
 			break;
 		case TypeLong:
-			DestValue->Val->LongInteger = ExpressionCoerceInteger(SourceValue);
+			_destValue->Val->LongInteger = ExpressionCoerceInteger(_sourceValue);
 			break;
 		case TypeUnsignedInt:
-			DestValue->Val->UnsignedInteger = ExpressionCoerceUnsignedInteger(SourceValue);
+			_destValue->Val->UnsignedInteger = ExpressionCoerceUnsignedInteger(_sourceValue);
 			break;
 		case TypeUnsignedShort:
-			DestValue->Val->UnsignedShortInteger = ExpressionCoerceUnsignedInteger(SourceValue);
+			_destValue->Val->UnsignedShortInteger = ExpressionCoerceUnsignedInteger(_sourceValue);
 			break;
 		case TypeUnsignedLong:
-			DestValue->Val->UnsignedLongInteger = ExpressionCoerceUnsignedInteger(SourceValue);
+			_destValue->Val->UnsignedLongInteger = ExpressionCoerceUnsignedInteger(_sourceValue);
 			break;
 		case TypeFP:
-			if (!IS_NUMERIC_COERCIBLE_PLUS_POINTERS(SourceValue, AllowPointerCoercion)) {
-				AssignFail(_parser, "%t from %t", DestValue->Typ, SourceValue->Typ, 0, 0, FuncName, ParamNo); 
+			if (!IS_NUMERIC_COERCIBLE_PLUS_POINTERS(_sourceValue, _allowPointerCoercion)) {
+				AssignFail(_parser, "%t from %t", _destValue->Typ, _sourceValue->Typ, 0, 0, _funcName, _paramNo); 
 			}
-			DestValue->Val->FP = ExpressionCoerceFP(SourceValue);
+			_destValue->Val->FP = ExpressionCoerceFP(_sourceValue);
 			break;
 		case TypePointer:
-			ExpressionAssignToPointer(_parser, DestValue, SourceValue, FuncName, ParamNo, AllowPointerCoercion);
+			ExpressionAssignToPointer(_parser, _destValue, _sourceValue, _funcName, _paramNo, _allowPointerCoercion);
 			break;
 		case TypeArray:
-			if (DestValue->Typ != SourceValue->Typ) {
-				AssignFail(_parser, "%t from %t", DestValue->Typ, SourceValue->Typ, 0, 0, FuncName, ParamNo); 
+			if (_destValue->Typ != _sourceValue->Typ) {
+				AssignFail(_parser, "%t from %t", _destValue->Typ, _sourceValue->Typ, 0, 0, _funcName, _paramNo); 
 			}
-			if (DestValue->Typ->ArraySize != SourceValue->Typ->ArraySize) {
-				AssignFail(_parser, "from an array of size %d to one of size %d", NULL, NULL, DestValue->Typ->ArraySize, SourceValue->Typ->ArraySize, FuncName, ParamNo);
+			if (_destValue->Typ->ArraySize != _sourceValue->Typ->ArraySize) {
+				AssignFail(_parser, "from an array of size %d to one of size %d", NULL, NULL, _destValue->Typ->ArraySize, _sourceValue->Typ->ArraySize, _funcName, _paramNo);
 			}
-			memcpy((void *)DestValue->Val, (void *)SourceValue->Val, TypeSizeValue(DestValue, FALSE));
+			memcpy((void *)_destValue->Val, (void *)_sourceValue->Val, TypeSizeValue(_destValue, FALSE));
 			break;
 		case TypeStruct:
 		case TypeUnion:
-			if (DestValue->Typ != SourceValue->Typ) {
-				AssignFail(_parser, "%t from %t", DestValue->Typ, SourceValue->Typ, 0, 0, FuncName, ParamNo); 
+			if (_destValue->Typ != _sourceValue->Typ) {
+				AssignFail(_parser, "%t from %t", _destValue->Typ, _sourceValue->Typ, 0, 0, _funcName, _paramNo); 
 			}
-			memcpy((void *)DestValue->Val, (void *)SourceValue->Val, TypeSizeValue(SourceValue, FALSE));
+			memcpy((void *)_destValue->Val, (void *)_sourceValue->Val, TypeSizeValue(_sourceValue, FALSE));
 			break;
 		default:
-			AssignFail(_parser, "%t", DestValue->Typ, NULL, 0, 0, FuncName, ParamNo); 
+			AssignFail(_parser, "%t", _destValue->Typ, NULL, 0, 0, _funcName, _paramNo); 
 			break;
 	}
 }
 
 /* evaluate the first half of a ternary operator x ? y : z */
-void ExpressionQuestionMarkOperator(struct ParseState *_parser, struct ExpressionStack **StackTop, struct Value *BottomValue, struct Value *TopValue) {
-	if (!IS_NUMERIC_COERCIBLE(TopValue)) {
+void ExpressionQuestionMarkOperator(struct ParseState *_parser,
+                                    struct ExpressionStack **_stackTop,
+                                    struct Value *_bottomValue,
+                                    struct Value *_topValue) {
+	if (!IS_NUMERIC_COERCIBLE(_topValue)) {
 		ProgramFail(_parser, "first argument to '?' should be a number");
 	}
-	if (ExpressionCoerceInteger(TopValue)) {
-		/* the condition's true, return the BottomValue */
-		ExpressionStackPushValue(_parser, StackTop, BottomValue);
+	if (ExpressionCoerceInteger(_topValue)) {
+		/* the condition's true, return the _bottomValue */
+		ExpressionStackPushValue(_parser, _stackTop, _bottomValue);
 	} else {
 		/* the condition's false, return void */
-		ExpressionStackPushValueByType(_parser, StackTop, &VoidType);
+		ExpressionStackPushValueByType(_parser, _stackTop, &VoidType);
 	}
 }
 
 /* evaluate the second half of a ternary operator x ? y : z */
-void ExpressionColonOperator(struct ParseState *_parser, struct ExpressionStack **StackTop, struct Value *BottomValue, struct Value *TopValue) {
-	if (TopValue->Typ->Base == TypeVoid) {
-		/* invoke the "else" part - return the BottomValue */
-		ExpressionStackPushValue(_parser, StackTop, BottomValue);
+void ExpressionColonOperator(struct ParseState *_parser,
+                             struct ExpressionStack **_stackTop,
+                             struct Value *_bottomValue,
+                             struct Value *_topValue) {
+	if (_topValue->Typ->Base == TypeVoid) {
+		/* invoke the "else" part - return the _bottomValue */
+		ExpressionStackPushValue(_parser, _stackTop, _bottomValue);
 	} else {
-		/* it was a "then" - return the TopValue */
-		ExpressionStackPushValue(_parser, StackTop, TopValue);
+		/* it was a "then" - return the _topValue */
+		ExpressionStackPushValue(_parser, _stackTop, _topValue);
 	}
 }
 
 /* evaluate a prefix operator */
-void ExpressionPrefixOperator(struct ParseState *_parser, struct ExpressionStack **StackTop, enum LexToken Op, struct Value *TopValue) {
+void ExpressionPrefixOperator(struct ParseState *_parser,
+                              struct ExpressionStack **_stackTop,
+                              enum LexToken _op,
+                              struct Value *_topValue) {
 	struct Value *Result;
 	union AnyValue *ValPtr;
 	debugf("ExpressionPrefixOperator()\n");
-	switch (Op) {
+	switch (_op) {
 		case TokenAmpersand:
-			if (!TopValue->IsLValue) {
+			if (!_topValue->IsLValue) {
 				ProgramFail(_parser, "can't get the address of this");
 			}
-			ValPtr = TopValue->Val;
-			Result = VariableAllocValueFromType(_parser, TypeGetMatching(_parser, TopValue->Typ, TypePointer, 0, StrEmpty, TRUE), FALSE, NULL, FALSE);
+			ValPtr = _topValue->Val;
+			Result = VariableAllocValueFromType(_parser, TypeGetMatching(_parser, _topValue->Typ, TypePointer, 0, StrEmpty, TRUE), FALSE, NULL, FALSE);
 			Result->Val->Pointer = (void *)ValPtr;
-			ExpressionStackPushValueNode(_parser, StackTop, Result);
+			ExpressionStackPushValueNode(_parser, _stackTop, Result);
 			break;
 		case TokenAsterisk:
-			ExpressionStackPushDereference(_parser, StackTop, TopValue);
+			ExpressionStackPushDereference(_parser, _stackTop, _topValue);
 			break;
 		case TokenSizeof:
 			/* return the size of the argument */
-			if (TopValue->Typ == &TypeType) {
-				ExpressionPushInt(_parser, StackTop, TypeSize(TopValue->Val->Typ, TopValue->Val->Typ->ArraySize, TRUE));
+			if (_topValue->Typ == &TypeType) {
+				ExpressionPushInt(_parser, _stackTop, TypeSize(_topValue->Val->Typ, _topValue->Val->Typ->ArraySize, TRUE));
 			} else {
-				ExpressionPushInt(_parser, StackTop, TypeSize(TopValue->Typ, TopValue->Typ->ArraySize, TRUE));
+				ExpressionPushInt(_parser, _stackTop, TypeSize(_topValue->Typ, _topValue->Typ->ArraySize, TRUE));
 			}
 			break;
 		default:
 			/* an arithmetic operator */
-			if (TopValue->Typ == &FPType) {
+			if (_topValue->Typ == &FPType) {
 				/* floating point prefix arithmetic */
 				double ResultFP = 0.0;
-				switch (Op) {
+				switch (_op) {
 					case TokenPlus:
-						ResultFP = TopValue->Val->FP;
+						ResultFP = _topValue->Val->FP;
 						break;
 					case TokenMinus:
-						ResultFP = -TopValue->Val->FP;
+						ResultFP = -_topValue->Val->FP;
 						break;
 					default:
 						ProgramFail(_parser, "invalid operation");
 						break;
 				}
-				ExpressionPushFP(_parser, StackTop, ResultFP);
-			} else if (IS_NUMERIC_COERCIBLE(TopValue)) {
+				ExpressionPushFP(_parser, _stackTop, ResultFP);
+			} else if (IS_NUMERIC_COERCIBLE(_topValue)) {
 				/* integer prefix arithmetic */
 				long ResultInt = 0;
-				long TopInt = ExpressionCoerceInteger(TopValue);
-				switch (Op) {
+				long TopInt = ExpressionCoerceInteger(_topValue);
+				switch (_op) {
 					case TokenPlus:
 						ResultInt = TopInt;
 						break;
@@ -550,10 +551,10 @@ void ExpressionPrefixOperator(struct ParseState *_parser, struct ExpressionStack
 						ResultInt = -TopInt;
 						break;
 					case TokenIncrement:
-						ResultInt = ExpressionAssignInt(_parser, TopValue, TopInt+1, FALSE);
+						ResultInt = ExpressionAssignInt(_parser, _topValue, TopInt+1, FALSE);
 						break;
 					case TokenDecrement:
-						ResultInt = ExpressionAssignInt(_parser, TopValue, TopInt-1, FALSE);
+						ResultInt = ExpressionAssignInt(_parser, _topValue, TopInt-1, FALSE);
 						break;
 					case TokenUnaryNot:
 						ResultInt = !TopInt;
@@ -565,31 +566,31 @@ void ExpressionPrefixOperator(struct ParseState *_parser, struct ExpressionStack
 						ProgramFail(_parser, "invalid operation");
 						break;
 				}
-				ExpressionPushInt(_parser, StackTop, ResultInt);
-			} else if (TopValue->Typ->Base == TypePointer) {
+				ExpressionPushInt(_parser, _stackTop, ResultInt);
+			} else if (_topValue->Typ->Base == TypePointer) {
 				/* pointer prefix arithmetic */
-				int Size = TypeSize(TopValue->Typ->FromType, 0, TRUE);
+				int Size = TypeSize(_topValue->Typ->FromType, 0, TRUE);
 				struct Value *StackValue;
 				void *ResultPtr;
-				if (TopValue->Val->Pointer == NULL) {
+				if (_topValue->Val->Pointer == NULL) {
 					ProgramFail(_parser, "invalid use of a NULL pointer");
 				}
-				if (!TopValue->IsLValue) {
+				if (!_topValue->IsLValue) {
 					ProgramFail(_parser, "can't assign to this"); 
 				}
-				switch (Op) {
+				switch (_op) {
 					case TokenIncrement:
-						TopValue->Val->Pointer = (void *)((char *)TopValue->Val->Pointer + Size);
+						_topValue->Val->Pointer = (void *)((char *)_topValue->Val->Pointer + Size);
 						break;
 					case TokenDecrement:
-						TopValue->Val->Pointer = (void *)((char *)TopValue->Val->Pointer - Size);
+						_topValue->Val->Pointer = (void *)((char *)_topValue->Val->Pointer - Size);
 						break;
 					default:
 						ProgramFail(_parser, "invalid operation");
 						break;
 				}
-				ResultPtr = TopValue->Val->Pointer;
-				StackValue = ExpressionStackPushValueByType(_parser, StackTop, TopValue->Typ);
+				ResultPtr = _topValue->Val->Pointer;
+				StackValue = ExpressionStackPushValueByType(_parser, _stackTop, _topValue->Typ);
 				StackValue->Val->Pointer = ResultPtr;
 			} else {
 				ProgramFail(_parser, "invalid operation");
@@ -599,17 +600,20 @@ void ExpressionPrefixOperator(struct ParseState *_parser, struct ExpressionStack
 }
 
 /* evaluate a postfix operator */
-void ExpressionPostfixOperator(struct ParseState *_parser, struct ExpressionStack **StackTop, enum LexToken Op, struct Value *TopValue) {
+void ExpressionPostfixOperator(struct ParseState *_parser,
+                               struct ExpressionStack **_stackTop,
+                               enum LexToken _op,
+                               struct Value *_topValue) {
 	debugf("ExpressionPostfixOperator()\n");
-	if (IS_NUMERIC_COERCIBLE(TopValue)) {
+	if (IS_NUMERIC_COERCIBLE(_topValue)) {
 		long ResultInt = 0;
-		long TopInt = ExpressionCoerceInteger(TopValue);
-		switch (Op) {
+		long TopInt = ExpressionCoerceInteger(_topValue);
+		switch (_op) {
 			case TokenIncrement:
-				ResultInt = ExpressionAssignInt(_parser, TopValue, TopInt+1, TRUE);
+				ResultInt = ExpressionAssignInt(_parser, _topValue, TopInt+1, TRUE);
 				break;
 			case TokenDecrement:
-				ResultInt = ExpressionAssignInt(_parser, TopValue, TopInt-1, TRUE);
+				ResultInt = ExpressionAssignInt(_parser, _topValue, TopInt-1, TRUE);
 				break;
 			case TokenRightSquareBracket:
 				ProgramFail(_parser, "not supported");
@@ -623,30 +627,30 @@ void ExpressionPostfixOperator(struct ParseState *_parser, struct ExpressionStac
 				ProgramFail(_parser, "invalid operation");
 				break;
 		}
-		ExpressionPushInt(_parser, StackTop, ResultInt);
-	} else if (TopValue->Typ->Base == TypePointer) {
+		ExpressionPushInt(_parser, _stackTop, ResultInt);
+	} else if (_topValue->Typ->Base == TypePointer) {
 		/* pointer postfix arithmetic */
-		int Size = TypeSize(TopValue->Typ->FromType, 0, TRUE);
+		int Size = TypeSize(_topValue->Typ->FromType, 0, TRUE);
 		struct Value *StackValue;
-		void *OrigPointer = TopValue->Val->Pointer;
-		if (TopValue->Val->Pointer == NULL) {
+		void *OrigPointer = _topValue->Val->Pointer;
+		if (_topValue->Val->Pointer == NULL) {
 			ProgramFail(_parser, "invalid use of a NULL pointer");
 		}
-		if (!TopValue->IsLValue) {
+		if (!_topValue->IsLValue) {
 			ProgramFail(_parser, "can't assign to this"); 
 		}
-		switch (Op) {
+		switch (_op) {
 			case TokenIncrement:
-				TopValue->Val->Pointer = (void *)((char *)TopValue->Val->Pointer + Size);
+				_topValue->Val->Pointer = (void *)((char *)_topValue->Val->Pointer + Size);
 				break;
 			case TokenDecrement:
-				TopValue->Val->Pointer = (void *)((char *)TopValue->Val->Pointer - Size);
+				_topValue->Val->Pointer = (void *)((char *)_topValue->Val->Pointer - Size);
 				break;
 			default:
 				ProgramFail(_parser, "invalid operation");
 				break;
 		}
-		StackValue = ExpressionStackPushValueByType(_parser, StackTop, TopValue->Typ);
+		StackValue = ExpressionStackPushValueByType(_parser, _stackTop, _topValue->Typ);
 		StackValue->Val->Pointer = OrigPointer;
 	} else {
 		ProgramFail(_parser, "invalid operation");
@@ -654,62 +658,66 @@ void ExpressionPostfixOperator(struct ParseState *_parser, struct ExpressionStac
 }
 
 /* evaluate an infix operator */
-void ExpressionInfixOperator(struct ParseState *_parser, struct ExpressionStack **StackTop, enum LexToken Op, struct Value *BottomValue, struct Value *TopValue) {
+void ExpressionInfixOperator(struct ParseState *_parser,
+                             struct ExpressionStack **_stackTop,
+                             enum LexToken _op,
+                             struct Value *_bottomValue,
+                             struct Value *_topValue) {
 	long ResultInt = 0;
 	struct Value *StackValue;
 	void *Pointer;
 	debugf("ExpressionInfixOperator()\n");
-	if (    BottomValue == NULL
-	     || TopValue == NULL) {
+	if (    _bottomValue == NULL
+	     || _topValue == NULL) {
 		ProgramFail(_parser, "invalid expression");
 	}
-	if (Op == TokenLeftSquareBracket) {
+	if (_op == TokenLeftSquareBracket) {
 		/* array index */
 		int ArrayIndex;
 		struct Value *Result = NULL;
-		if (!IS_NUMERIC_COERCIBLE(TopValue)) {
+		if (!IS_NUMERIC_COERCIBLE(_topValue)) {
 			ProgramFail(_parser, "array index must be an integer");
 		}
-		ArrayIndex = ExpressionCoerceInteger(TopValue);
+		ArrayIndex = ExpressionCoerceInteger(_topValue);
 		/* make the array element result */
-		switch (BottomValue->Typ->Base) {
+		switch (_bottomValue->Typ->Base) {
 			case TypeArray:
-				Result = VariableAllocValueFromExistingData(_parser, BottomValue->Typ->FromType, (union AnyValue *)(&BottomValue->Val->ArrayMem[0] + TypeSize(BottomValue->Typ, ArrayIndex, TRUE)), BottomValue->IsLValue, BottomValue->LValueFrom);
+				Result = VariableAllocValueFromExistingData(_parser, _bottomValue->Typ->FromType, (union AnyValue *)(&_bottomValue->Val->ArrayMem[0] + TypeSize(_bottomValue->Typ, ArrayIndex, TRUE)), _bottomValue->IsLValue, _bottomValue->LValueFrom);
 				break;
 			case TypePointer:
-				Result = VariableAllocValueFromExistingData(_parser, BottomValue->Typ->FromType, (union AnyValue *)((char *)BottomValue->Val->Pointer + TypeSize(BottomValue->Typ->FromType, 0, TRUE) * ArrayIndex), BottomValue->IsLValue, BottomValue->LValueFrom);
+				Result = VariableAllocValueFromExistingData(_parser, _bottomValue->Typ->FromType, (union AnyValue *)((char *)_bottomValue->Val->Pointer + TypeSize(_bottomValue->Typ->FromType, 0, TRUE) * ArrayIndex), _bottomValue->IsLValue, _bottomValue->LValueFrom);
 				break;
 			default:
-				ProgramFail(_parser, "this %t is not an array", BottomValue->Typ);
+				ProgramFail(_parser, "this %t is not an array", _bottomValue->Typ);
 		}
-		ExpressionStackPushValueNode(_parser, StackTop, Result);
-	} else if (Op == TokenQuestionMark) {
-		ExpressionQuestionMarkOperator(_parser, StackTop, TopValue, BottomValue);
-	} else if (Op == TokenColon) {
-		ExpressionColonOperator(_parser, StackTop, TopValue, BottomValue);
-	} else if (    (TopValue->Typ == &FPType && BottomValue->Typ == &FPType)
-	            || (TopValue->Typ == &FPType && IS_NUMERIC_COERCIBLE(BottomValue))
-	            || (IS_NUMERIC_COERCIBLE(TopValue) && BottomValue->Typ == &FPType) ) {
+		ExpressionStackPushValueNode(_parser, _stackTop, Result);
+	} else if (_op == TokenQuestionMark) {
+		ExpressionQuestionMarkOperator(_parser, _stackTop, _topValue, _bottomValue);
+	} else if (_op == TokenColon) {
+		ExpressionColonOperator(_parser, _stackTop, _topValue, _bottomValue);
+	} else if (    (_topValue->Typ == &FPType && _bottomValue->Typ == &FPType)
+	            || (_topValue->Typ == &FPType && IS_NUMERIC_COERCIBLE(_bottomValue))
+	            || (IS_NUMERIC_COERCIBLE(_topValue) && _bottomValue->Typ == &FPType) ) {
 		/* floating point infix arithmetic */
 		int ResultIsInt = FALSE;
 		double ResultFP = 0.0;
-		double TopFP = (TopValue->Typ == &FPType) ? TopValue->Val->FP : (double)ExpressionCoerceInteger(TopValue);
-		double BottomFP = (BottomValue->Typ == &FPType) ? BottomValue->Val->FP : (double)ExpressionCoerceInteger(BottomValue);
-		switch (Op) {
+		double TopFP = (_topValue->Typ == &FPType) ? _topValue->Val->FP : (double)ExpressionCoerceInteger(_topValue);
+		double BottomFP = (_bottomValue->Typ == &FPType) ? _bottomValue->Val->FP : (double)ExpressionCoerceInteger(_bottomValue);
+		switch (_op) {
 			case TokenAssign:
-				ResultFP = ExpressionAssignFP(_parser, BottomValue, TopFP);
+				ResultFP = ExpressionAssignFP(_parser, _bottomValue, TopFP);
 				break;
 			case TokenAddAssign:
-				ResultFP = ExpressionAssignFP(_parser, BottomValue, BottomFP + TopFP);
+				ResultFP = ExpressionAssignFP(_parser, _bottomValue, BottomFP + TopFP);
 				break;
 			case TokenSubtractAssign:
-				ResultFP = ExpressionAssignFP(_parser, BottomValue, BottomFP - TopFP);
+				ResultFP = ExpressionAssignFP(_parser, _bottomValue, BottomFP - TopFP);
 				break;
 			case TokenMultiplyAssign:
-				ResultFP = ExpressionAssignFP(_parser, BottomValue, BottomFP * TopFP);
+				ResultFP = ExpressionAssignFP(_parser, _bottomValue, BottomFP * TopFP);
 				break;
 			case TokenDivideAssign:
-				ResultFP = ExpressionAssignFP(_parser, BottomValue, BottomFP / TopFP);
+				ResultFP = ExpressionAssignFP(_parser, _bottomValue, BottomFP / TopFP);
 				break;
 			case TokenEqual:
 				ResultInt = BottomFP == TopFP;
@@ -752,49 +760,49 @@ void ExpressionInfixOperator(struct ParseState *_parser, struct ExpressionStack
 				break;
 		}
 		if (ResultIsInt) {
-			ExpressionPushInt(_parser, StackTop, ResultInt);
+			ExpressionPushInt(_parser, _stackTop, ResultInt);
 		} else {
-			ExpressionPushFP(_parser, StackTop, ResultFP);
+			ExpressionPushFP(_parser, _stackTop, ResultFP);
 		}
-	} else if (IS_NUMERIC_COERCIBLE(TopValue) && IS_NUMERIC_COERCIBLE(BottomValue)) {
+	} else if (IS_NUMERIC_COERCIBLE(_topValue) && IS_NUMERIC_COERCIBLE(_bottomValue)) {
 		/* integer operation */
-		long TopInt = ExpressionCoerceInteger(TopValue);
-		long BottomInt = ExpressionCoerceInteger(BottomValue);
-		switch (Op) {
+		long TopInt = ExpressionCoerceInteger(_topValue);
+		long BottomInt = ExpressionCoerceInteger(_bottomValue);
+		switch (_op) {
 			case TokenAssign:
-				ResultInt = ExpressionAssignInt(_parser, BottomValue, TopInt, FALSE);
+				ResultInt = ExpressionAssignInt(_parser, _bottomValue, TopInt, FALSE);
 				break;
 			case TokenAddAssign:
-				ResultInt = ExpressionAssignInt(_parser, BottomValue, BottomInt + TopInt, FALSE);
+				ResultInt = ExpressionAssignInt(_parser, _bottomValue, BottomInt + TopInt, FALSE);
 				break;
 			case TokenSubtractAssign:
-				ResultInt = ExpressionAssignInt(_parser, BottomValue, BottomInt - TopInt, FALSE);
+				ResultInt = ExpressionAssignInt(_parser, _bottomValue, BottomInt - TopInt, FALSE);
 				break;
 			case TokenMultiplyAssign:
-				ResultInt = ExpressionAssignInt(_parser, BottomValue, BottomInt * TopInt, FALSE);
+				ResultInt = ExpressionAssignInt(_parser, _bottomValue, BottomInt * TopInt, FALSE);
 				break;
 			case TokenDivideAssign:
-				ResultInt = ExpressionAssignInt(_parser, BottomValue, BottomInt / TopInt, FALSE);
+				ResultInt = ExpressionAssignInt(_parser, _bottomValue, BottomInt / TopInt, FALSE);
 				break;
 #ifndef NO_MODULUS
 			case TokenModulusAssign:
-				ResultInt = ExpressionAssignInt(_parser, BottomValue, BottomInt % TopInt, FALSE);
+				ResultInt = ExpressionAssignInt(_parser, _bottomValue, BottomInt % TopInt, FALSE);
 				break;
 #endif
 			case TokenShiftLeftAssign:
-				ResultInt = ExpressionAssignInt(_parser, BottomValue, BottomInt << TopInt, FALSE);
+				ResultInt = ExpressionAssignInt(_parser, _bottomValue, BottomInt << TopInt, FALSE);
 				break;
 			case TokenShiftRightAssign:
-				ResultInt = ExpressionAssignInt(_parser, BottomValue, BottomInt >> TopInt, FALSE);
+				ResultInt = ExpressionAssignInt(_parser, _bottomValue, BottomInt >> TopInt, FALSE);
 				break;
 			case TokenArithmeticAndAssign:
-				ResultInt = ExpressionAssignInt(_parser, BottomValue, BottomInt & TopInt, FALSE);
+				ResultInt = ExpressionAssignInt(_parser, _bottomValue, BottomInt & TopInt, FALSE);
 				break;
 			case TokenArithmeticOrAssign:
-				ResultInt = ExpressionAssignInt(_parser, BottomValue, BottomInt | TopInt, FALSE);
+				ResultInt = ExpressionAssignInt(_parser, _bottomValue, BottomInt | TopInt, FALSE);
 				break;
 			case TokenArithmeticExorAssign:
-				ResultInt = ExpressionAssignInt(_parser, BottomValue, BottomInt ^ TopInt, FALSE);
+				ResultInt = ExpressionAssignInt(_parser, _bottomValue, BottomInt ^ TopInt, FALSE);
 				break;
 			case TokenLogicalOr:
 				ResultInt = BottomInt || TopInt;
@@ -856,105 +864,108 @@ void ExpressionInfixOperator(struct ParseState *_parser, struct ExpressionStack
 				ProgramFail(_parser, "invalid operation");
 				break;
 		}
-		ExpressionPushInt(_parser, StackTop, ResultInt);
-	} else if (BottomValue->Typ->Base == TypePointer && IS_NUMERIC_COERCIBLE(TopValue)) {
+		ExpressionPushInt(_parser, _stackTop, ResultInt);
+	} else if (_bottomValue->Typ->Base == TypePointer && IS_NUMERIC_COERCIBLE(_topValue)) {
 		/* pointer/integer infix arithmetic */
-		long TopInt = ExpressionCoerceInteger(TopValue);
-		if (    Op == TokenEqual
-		     || Op == TokenNotEqual) {
+		long TopInt = ExpressionCoerceInteger(_topValue);
+		if (    _op == TokenEqual
+		     || _op == TokenNotEqual) {
 			/* comparison to a NULL pointer */
 			if (TopInt != 0) {
 				ProgramFail(_parser, "invalid operation");
 			}
-			if (Op == TokenEqual) {
-				ExpressionPushInt(_parser, StackTop, BottomValue->Val->Pointer == NULL);
+			if (_op == TokenEqual) {
+				ExpressionPushInt(_parser, _stackTop, _bottomValue->Val->Pointer == NULL);
 			} else {
-				ExpressionPushInt(_parser, StackTop, BottomValue->Val->Pointer != NULL);
+				ExpressionPushInt(_parser, _stackTop, _bottomValue->Val->Pointer != NULL);
 			}
-		} else if (    Op == TokenPlus
-		            || Op == TokenMinus) {
+		} else if (    _op == TokenPlus
+		            || _op == TokenMinus) {
 			/* pointer arithmetic */
-			int Size = TypeSize(BottomValue->Typ->FromType, 0, TRUE);
-			Pointer = BottomValue->Val->Pointer;
+			int Size = TypeSize(_bottomValue->Typ->FromType, 0, TRUE);
+			Pointer = _bottomValue->Val->Pointer;
 			if (Pointer == NULL) {
 				ProgramFail(_parser, "invalid use of a NULL pointer");
 			}
-			if (Op == TokenPlus) {
+			if (_op == TokenPlus) {
 				Pointer = (void *)((char *)Pointer + TopInt * Size);
 			} else {
 				Pointer = (void *)((char *)Pointer - TopInt * Size);
 			}
-			StackValue = ExpressionStackPushValueByType(_parser, StackTop, BottomValue->Typ);
+			StackValue = ExpressionStackPushValueByType(_parser, _stackTop, _bottomValue->Typ);
 			StackValue->Val->Pointer = Pointer;
-		} else if (    Op == TokenAssign
+		} else if (    _op == TokenAssign
 		            && TopInt == 0) {
 			/* assign a NULL pointer */
 			HeapUnpopStack(sizeof(struct Value));
-			ExpressionAssign(_parser, BottomValue, TopValue, FALSE, NULL, 0, FALSE);
-			ExpressionStackPushValueNode(_parser, StackTop, BottomValue);
-		} else if (    Op == TokenAddAssign
-		            || Op == TokenSubtractAssign) {
+			ExpressionAssign(_parser, _bottomValue, _topValue, FALSE, NULL, 0, FALSE);
+			ExpressionStackPushValueNode(_parser, _stackTop, _bottomValue);
+		} else if (    _op == TokenAddAssign
+		            || _op == TokenSubtractAssign) {
 			/* pointer arithmetic */
-			int Size = TypeSize(BottomValue->Typ->FromType, 0, TRUE);
-			Pointer = BottomValue->Val->Pointer;
+			int Size = TypeSize(_bottomValue->Typ->FromType, 0, TRUE);
+			Pointer = _bottomValue->Val->Pointer;
 			if (Pointer == NULL) {
 				ProgramFail(_parser, "invalid use of a NULL pointer");
 			}
-			if (Op == TokenAddAssign) {
+			if (_op == TokenAddAssign) {
 				Pointer = (void *)((char *)Pointer + TopInt * Size);
 			} else {
 				Pointer = (void *)((char *)Pointer - TopInt * Size);
 			}
 			HeapUnpopStack(sizeof(struct Value));
-			BottomValue->Val->Pointer = Pointer;
-			ExpressionStackPushValueNode(_parser, StackTop, BottomValue);
+			_bottomValue->Val->Pointer = Pointer;
+			ExpressionStackPushValueNode(_parser, _stackTop, _bottomValue);
 		} else {
 			ProgramFail(_parser, "invalid operation");
 		}
-	} else if (    BottomValue->Typ->Base == TypePointer
-	            && TopValue->Typ->Base == TypePointer
-	            && Op != TokenAssign) {
+	} else if (    _bottomValue->Typ->Base == TypePointer
+	            && _topValue->Typ->Base == TypePointer
+	            && _op != TokenAssign) {
 		/* pointer/pointer operations */
-		char *TopLoc = (char *)TopValue->Val->Pointer;
-		char *BottomLoc = (char *)BottomValue->Val->Pointer;
-		switch (Op) {
+		char *TopLoc = (char *)_topValue->Val->Pointer;
+		char *BottomLoc = (char *)_bottomValue->Val->Pointer;
+		switch (_op) {
 			case TokenEqual:
-				ExpressionPushInt(_parser, StackTop, BottomLoc == TopLoc);
+				ExpressionPushInt(_parser, _stackTop, BottomLoc == TopLoc);
 				break;
 			case TokenNotEqual:
-				ExpressionPushInt(_parser, StackTop, BottomLoc != TopLoc);
+				ExpressionPushInt(_parser, _stackTop, BottomLoc != TopLoc);
 				break;
 			case TokenMinus:
-				ExpressionPushInt(_parser, StackTop, BottomLoc - TopLoc);
+				ExpressionPushInt(_parser, _stackTop, BottomLoc - TopLoc);
 				break;
 			default:
 				ProgramFail(_parser, "invalid operation");
 				break;
 		}
-	} else if (Op == TokenAssign) {
+	} else if (_op == TokenAssign) {
 		/* assign a non-numeric type */
 		HeapUnpopStack(sizeof(struct Value));   /* XXX - possible bug if lvalue is a temp value and takes more than sizeof(struct Value) */
-		ExpressionAssign(_parser, BottomValue, TopValue, FALSE, NULL, 0, FALSE);
-		ExpressionStackPushValueNode(_parser, StackTop, BottomValue);
-	} else if (Op == TokenCast) {
+		ExpressionAssign(_parser, _bottomValue, _topValue, FALSE, NULL, 0, FALSE);
+		ExpressionStackPushValueNode(_parser, _stackTop, _bottomValue);
+	} else if (_op == TokenCast) {
 		/* cast a value to a different type */   /* XXX - possible bug if the destination type takes more than sizeof(struct Value) + sizeof(struct ValueType *) */
-		struct Value *ValueLoc = ExpressionStackPushValueByType(_parser, StackTop, BottomValue->Val->Typ);
-		ExpressionAssign(_parser, ValueLoc, TopValue, TRUE, NULL, 0, TRUE);
+		struct Value *valueLoc = ExpressionStackPushValueByType(_parser, _stackTop, _bottomValue->Val->Typ);
+		ExpressionAssign(_parser, valueLoc, _topValue, TRUE, NULL, 0, TRUE);
 	} else {
 		ProgramFail(_parser, "invalid operation");
 	}
 }
 
 /* take the contents of the expression stack and compute the top until there's nothing greater than the given precedence */
-void ExpressionStackCollapse(struct ParseState *_parser, struct ExpressionStack **StackTop, int Precedence, int *IgnorePrecedence) {
+void ExpressionStackCollapse(struct ParseState *_parser,
+                             struct ExpressionStack **_stackTop,
+                             int Precedence,
+                             int *IgnorePrecedence) {
 	int FoundPrecedence = Precedence;
-	struct Value *TopValue;
+	struct Value *topValue;
 	struct Value *BottomValue;
-	struct ExpressionStack *TopStackNode = *StackTop;
+	struct ExpressionStack *TopStackNode = *_stackTop;
 	struct ExpressionStack *TopOperatorNode;
 	debugf("ExpressionStackCollapse(%d):\n", Precedence);
 #ifdef DEBUG_EXPRESSIONS
-	ExpressionStackShow(*StackTop);
+	ExpressionStackShow(*_stackTop);
 #endif
 	while (TopStackNode != NULL && TopStackNode->Next != NULL && FoundPrecedence >= Precedence) {
 		/* find the top operator on the stack */
@@ -971,57 +982,57 @@ void ExpressionStackCollapse(struct ParseState *_parser, struct ExpressionStack
 				case OrderPrefix:
 					/* prefix evaluation */
 					debugf("prefix evaluation\n");
-					TopValue = TopStackNode->Val;
+					topValue = TopStackNode->Val;
 					/* pop the value and then the prefix operator - assume they'll still be there until we're done */
-					HeapPopStack(NULL, sizeof(struct ExpressionStack) + sizeof(struct Value) + TypeStackSizeValue(TopValue));
+					HeapPopStack(NULL, sizeof(struct ExpressionStack) + sizeof(struct Value) + TypeStackSizeValue(topValue));
 					HeapPopStack(TopOperatorNode, sizeof(struct ExpressionStack));
-					*StackTop = TopOperatorNode->Next;
+					*_stackTop = TopOperatorNode->Next;
 					/* do the prefix operation */
 					if (    _parser->Mode == RunModeRun
 					     && FoundPrecedence < *IgnorePrecedence) {
 						/* run the operator */
-						ExpressionPrefixOperator(_parser, StackTop, TopOperatorNode->Op, TopValue);
+						ExpressionPrefixOperator(_parser, _stackTop, TopOperatorNode->Op, topValue);
 					} else {
 						/* we're not running it so just return 0 */
-						ExpressionPushInt(_parser, StackTop, 0);
+						ExpressionPushInt(_parser, _stackTop, 0);
 					}
 					break;
 				case OrderPostfix:
 					/* postfix evaluation */
 					debugf("postfix evaluation\n");
-					TopValue = TopStackNode->Next->Val;
+					topValue = TopStackNode->Next->Val;
 					/* pop the postfix operator and then the value - assume they'll still be there until we're done */
 					HeapPopStack(NULL, sizeof(struct ExpressionStack));
-					HeapPopStack(TopValue, sizeof(struct ExpressionStack) + sizeof(struct Value) + TypeStackSizeValue(TopValue));
-					*StackTop = TopStackNode->Next->Next;
+					HeapPopStack(topValue, sizeof(struct ExpressionStack) + sizeof(struct Value) + TypeStackSizeValue(topValue));
+					*_stackTop = TopStackNode->Next->Next;
 					/* do the postfix operation */
 					if (    _parser->Mode == RunModeRun
 					     && FoundPrecedence < *IgnorePrecedence) {
 						/* run the operator */
-						ExpressionPostfixOperator(_parser, StackTop, TopOperatorNode->Op, TopValue);
+						ExpressionPostfixOperator(_parser, _stackTop, TopOperatorNode->Op, topValue);
 					} else {
 						/* we're not running it so just return 0 */
-						ExpressionPushInt(_parser, StackTop, 0);
+						ExpressionPushInt(_parser, _stackTop, 0);
 					}
 					break;
 				case OrderInfix:
 					/* infix evaluation */
 					debugf("infix evaluation\n");
-					TopValue = TopStackNode->Val;
-					if (TopValue != NULL) {
+					topValue = TopStackNode->Val;
+					if (topValue != NULL) {
 						BottomValue = TopOperatorNode->Next->Val;
 						/* pop a value, the operator and another value - assume they'll still be there until we're done */
-						HeapPopStack(NULL, sizeof(struct ExpressionStack) + sizeof(struct Value) + TypeStackSizeValue(TopValue));
+						HeapPopStack(NULL, sizeof(struct ExpressionStack) + sizeof(struct Value) + TypeStackSizeValue(topValue));
 						HeapPopStack(NULL, sizeof(struct ExpressionStack));
 						HeapPopStack(BottomValue, sizeof(struct ExpressionStack) + sizeof(struct Value) + TypeStackSizeValue(BottomValue));
-						*StackTop = TopOperatorNode->Next->Next;
+						*_stackTop = TopOperatorNode->Next->Next;
 						/* do the infix operation */
 						if (_parser->Mode == RunModeRun && FoundPrecedence <= *IgnorePrecedence) {
 							/* run the operator */
-							ExpressionInfixOperator(_parser, StackTop, TopOperatorNode->Op, BottomValue, TopValue);
+							ExpressionInfixOperator(_parser, _stackTop, TopOperatorNode->Op, BottomValue, topValue);
 						} else {
 							/* we're not running it so just return 0 */
-							ExpressionPushInt(_parser, StackTop, 0);
+							ExpressionPushInt(_parser, _stackTop, 0);
 						}
 					} else {
 						FoundPrecedence = -1;
@@ -1038,36 +1049,36 @@ void ExpressionStackCollapse(struct ParseState *_parser, struct ExpressionStack
 			}
 		}
 #ifdef DEBUG_EXPRESSIONS
-		ExpressionStackShow(*StackTop);
+		ExpressionStackShow(*_stackTop);
 #endif
-		TopStackNode = *StackTop;
+		TopStackNode = *_stackTop;
 	}
 	debugf("ExpressionStackCollapse() finished\n");
 #ifdef DEBUG_EXPRESSIONS
-	ExpressionStackShow(*StackTop);
+	ExpressionStackShow(*_stackTop);
 #endif
 }
 
 /* push an operator on to the expression stack */
-void ExpressionStackPushOperator(struct ParseState *_parser, struct ExpressionStack **StackTop, enum OperatorOrder Order, enum LexToken Token, int Precedence) {
+void ExpressionStackPushOperator(struct ParseState *_parser, struct ExpressionStack **_stackTop, enum OperatorOrder Order, enum LexToken Token, int Precedence) {
 	struct ExpressionStack *StackNode = VariableAlloc(_parser, sizeof(struct ExpressionStack), FALSE);
-	StackNode->Next = *StackTop;
+	StackNode->Next = *_stackTop;
 	StackNode->Order = Order;
 	StackNode->Op = Token;
 	StackNode->Precedence = Precedence;
-	*StackTop = StackNode;
+	*_stackTop = StackNode;
 	debugf("ExpressionStackPushOperator()\n");
 #ifdef FANCY_ERROR_MESSAGES
 	StackNode->Line = _parser->Line;
 	StackNode->CharacterPos = _parser->CharacterPos;
 #endif
 #ifdef DEBUG_EXPRESSIONS
-	ExpressionStackShow(*StackTop);
+	ExpressionStackShow(*_stackTop);
 #endif
 }
 
 /* do the '.' and '->' operators */
-void ExpressionGetStructElement(struct ParseState *_parser, struct ExpressionStack **StackTop, enum LexToken Token) {
+void ExpressionGetStructElement(struct ParseState *_parser, struct ExpressionStack **_stackTop, enum LexToken Token) {
 	struct Value *Ident;
 	/* get the identifier following the '.' or '->' */
 	if (LexGetToken(_parser, &Ident, TRUE) != TokenIdentifier) {
@@ -1075,7 +1086,7 @@ void ExpressionGetStructElement(struct ParseState *_parser, struct ExpressionSta
 	}
 	if (_parser->Mode == RunModeRun) {
 		/* look up the struct element */
-		struct Value *ParamVal = (*StackTop)->Val;
+		struct Value *ParamVal = (*_stackTop)->Val;
 		struct Value *StructVal = ParamVal;
 		struct ValueType *StructType = ParamVal->Typ;
 		char *DerefDataLoc = (char *)ParamVal->Val;
@@ -1093,10 +1104,10 @@ void ExpressionGetStructElement(struct ParseState *_parser, struct ExpressionSta
 		}
 		/* pop the value - assume it'll still be there until we're done */
 		HeapPopStack(ParamVal, sizeof(struct ExpressionStack) + sizeof(struct Value) + TypeStackSizeValue(StructVal));
-		*StackTop = (*StackTop)->Next;
+		*_stackTop = (*_stackTop)->Next;
 		/* make the result value for this member only */
 		Result = VariableAllocValueFromExistingData(_parser, MemberValue->Typ, (void *)(DerefDataLoc + MemberValue->Val->Integer), TRUE, (StructVal != NULL) ? StructVal->LValueFrom : NULL);
-		ExpressionStackPushValueNode(_parser, StackTop, Result);
+		ExpressionStackPushValueNode(_parser, _stackTop, Result);
 	}
 }
 
@@ -1109,7 +1120,7 @@ int ExpressionParse(struct ParseState *_parser, struct Value **Result) {
 	int LocalPrecedence;
 	int Precedence = 0;
 	int IgnorePrecedence = DEEP_PRECEDENCE;
-	struct ExpressionStack *StackTop = NULL;
+	struct ExpressionStack *_stackTop = NULL;
 	int TernaryDepth = 0;
 	debugf("ExpressionParse():\n");
 	do {
@@ -1135,8 +1146,8 @@ int ExpressionParse(struct ParseState *_parser, struct Value **Result) {
 					/* it's either a new bracket level or a cast */
 					enum LexToken BracketToken = LexGetToken(_parser, &LexValue, FALSE);
 					if (    IS_TYPE_TOKEN(BracketToken)
-					     && (    StackTop == NULL
-					          || StackTop->Op != TokenSizeof) ) {
+					     && (    _stackTop == NULL
+					          || _stackTop->Op != TokenSizeof) ) {
 						/* it's a cast - get the new type */
 						struct ValueType *CastType;
 						char *CastIdentifier;
@@ -1147,19 +1158,19 @@ int ExpressionParse(struct ParseState *_parser, struct Value **Result) {
 						}
 						// scan and collapse the stack to the precedence of this infix cast operator, then push
 						Precedence = BracketPrecedence + OperatorPrecedence[(int)TokenCast].PrefixPrecedence;
-						ExpressionStackCollapse(_parser, &StackTop, Precedence+1, &IgnorePrecedence);
+						ExpressionStackCollapse(_parser, &_stackTop, Precedence+1, &IgnorePrecedence);
 						CastTypeValue = VariableAllocValueFromType(_parser, &TypeType, FALSE, NULL, FALSE);
 						CastTypeValue->Val->Typ = CastType;
-						ExpressionStackPushValueNode(_parser, &StackTop, CastTypeValue);
-						ExpressionStackPushOperator(_parser, &StackTop, OrderInfix, TokenCast, Precedence);
+						ExpressionStackPushValueNode(_parser, &_stackTop, CastTypeValue);
+						ExpressionStackPushOperator(_parser, &_stackTop, OrderInfix, TokenCast, Precedence);
 					} else {
 						/* boost the bracket operator precedence */
 						BracketPrecedence += BRACKET_PRECEDENCE;
 					}
 				} else {
 					//scan and collapse the stack to the precedence of this operator, then push
-					ExpressionStackCollapse(_parser, &StackTop, Precedence, &IgnorePrecedence);
-					ExpressionStackPushOperator(_parser, &StackTop, OrderPrefix, Token, Precedence);
+					ExpressionStackCollapse(_parser, &_stackTop, Precedence, &IgnorePrecedence);
+					ExpressionStackPushOperator(_parser, &_stackTop, OrderPrefix, Token, Precedence);
 				}
 			} else {
 				// expect an infix or postfix operator
@@ -1173,15 +1184,15 @@ int ExpressionParse(struct ParseState *_parser, struct Value **Result) {
 								Done = TRUE;
 							} else {
 								// collapse to the bracket precedence
-								ExpressionStackCollapse(_parser, &StackTop, BracketPrecedence, &IgnorePrecedence);
+								ExpressionStackCollapse(_parser, &_stackTop, BracketPrecedence, &IgnorePrecedence);
 								BracketPrecedence -= BRACKET_PRECEDENCE;
 							}
 							break;
 						default:
 							// scan and collapse the stack to the precedence of this operator, then push
 							Precedence = BracketPrecedence + OperatorPrecedence[(int)Token].PostfixPrecedence;
-							ExpressionStackCollapse(_parser, &StackTop, Precedence, &IgnorePrecedence);
-							ExpressionStackPushOperator(_parser, &StackTop, OrderPostfix, Token, Precedence);
+							ExpressionStackCollapse(_parser, &_stackTop, Precedence, &IgnorePrecedence);
+							ExpressionStackPushOperator(_parser, &_stackTop, OrderPostfix, Token, Precedence);
 							break;
 					}
 				} else if (OperatorPrecedence[(int)Token].InfixPrecedence != 0) {
@@ -1190,19 +1201,19 @@ int ExpressionParse(struct ParseState *_parser, struct Value **Result) {
 					// for right to left order, only go down to the next higher precedence so we evaluate it in reverse order
 					// for left to right order, collapse down to this precedence so we evaluate it in forward order
 					if (IS_LEFT_TO_RIGHT(OperatorPrecedence[(int)Token].InfixPrecedence)) {
-						ExpressionStackCollapse(_parser, &StackTop, Precedence, &IgnorePrecedence);
+						ExpressionStackCollapse(_parser, &_stackTop, Precedence, &IgnorePrecedence);
 					} else {
-						ExpressionStackCollapse(_parser, &StackTop, Precedence+1, &IgnorePrecedence);
+						ExpressionStackCollapse(_parser, &_stackTop, Precedence+1, &IgnorePrecedence);
 					}
 					if (    Token == TokenDot
 					     || Token == TokenArrow) {
-						ExpressionGetStructElement(_parser, &StackTop, Token); /* this operator is followed by a struct element so handle it as a special case */
+						ExpressionGetStructElement(_parser, &_stackTop, Token); /* this operator is followed by a struct element so handle it as a special case */
 					} else {
 						/* if it's a && or || operator we may not need to evaluate the right hand side of the expression */
 						if (    (    Token == TokenLogicalOr
 						          || Token == TokenLogicalAnd)
-						     && IS_NUMERIC_COERCIBLE(StackTop->Val)) {
-							long LHSInt = ExpressionCoerceInteger(StackTop->Val);
+						     && IS_NUMERIC_COERCIBLE(_stackTop->Val)) {
+							long LHSInt = ExpressionCoerceInteger(_stackTop->Val);
 							if (    (    (    Token == TokenLogicalOr
 							               && LHSInt)
 							          || (    Token == TokenLogicalAnd
@@ -1211,7 +1222,7 @@ int ExpressionParse(struct ParseState *_parser, struct Value **Result) {
 								IgnorePrecedence = Precedence;
 						}
 						// push the operator on the stack
-						ExpressionStackPushOperator(_parser, &StackTop, OrderInfix, Token, Precedence);
+						ExpressionStackPushOperator(_parser, &_stackTop, OrderInfix, Token, Precedence);
 						PrefixState = TRUE;
 						switch (Token) {
 							case TokenQuestionMark:
@@ -1239,7 +1250,7 @@ int ExpressionParse(struct ParseState *_parser, struct Value **Result) {
 				ProgramFail(_parser, "identifier not expected here");
 			}
 			if (LexGetToken(_parser, NULL, FALSE) == TokenOpenBracket) {
-				ExpressionParseFunctionCall(_parser, &StackTop, LexValue->Val->Identifier, _parser->Mode == RunModeRun && Precedence < IgnorePrecedence);
+				ExpressionParseFunctionCall(_parser, &_stackTop, LexValue->Val->Identifier, _parser->Mode == RunModeRun && Precedence < IgnorePrecedence);
 			} else {
 				if (_parser->Mode == RunModeRun && Precedence < IgnorePrecedence) {
 					struct Value *VariableValue = NULL;
@@ -1256,15 +1267,15 @@ int ExpressionParse(struct ParseState *_parser, struct Value **Result) {
 						     || LexGetToken(&Macro_parser, NULL, FALSE) != TokenEndOfFunction) {
 							ProgramFail(&Macro_parser, "expression expected");
 						}
-						ExpressionStackPushValueNode(_parser, &StackTop, MacroResult);
+						ExpressionStackPushValueNode(_parser, &_stackTop, MacroResult);
 					} else if (VariableValue->Typ == TypeVoid) {
 						ProgramFail(_parser, "a void value isn't much use here");
 					} else {
-						ExpressionStackPushLValue(_parser, &StackTop, VariableValue, 0); /* it's a value variable */
+						ExpressionStackPushLValue(_parser, &_stackTop, VariableValue, 0); /* it's a value variable */
 					}
 				} else {
 					// push a dummy value
-					ExpressionPushInt(_parser, &StackTop, 0);
+					ExpressionPushInt(_parser, &_stackTop, 0);
 				}
 			}
 			// if we've successfully ignored the RHS turn ignoring off
@@ -1279,7 +1290,7 @@ int ExpressionParse(struct ParseState *_parser, struct Value **Result) {
 				ProgramFail(_parser, "value not expected here");
 			}
 			PrefixState = FALSE;
-			ExpressionStackPushValue(_parser, &StackTop, LexValue);
+			ExpressionStackPushValue(_parser, &_stackTop, LexValue);
 		} else if (IS_TYPE_TOKEN(Token)) {
 			/* it's a type. push it on the stack like a value. this is used in sizeof() */
 			struct ValueType *Typ;
@@ -1293,7 +1304,7 @@ int ExpressionParse(struct ParseState *_parser, struct Value **Result) {
 			TypeParse(_parser, &Typ, &Identifier, NULL);
 			TypeValue = VariableAllocValueFromType(_parser, &TypeType, FALSE, NULL, FALSE);
 			TypeValue->Val->Typ = Typ;
-			ExpressionStackPushValueNode(_parser, &StackTop, TypeValue);
+			ExpressionStackPushValueNode(_parser, &_stackTop, TypeValue);
 		} else {
 			// it isn't a token from an expression
 			ParserCopy(_parser, &PreState);
@@ -1305,31 +1316,31 @@ int ExpressionParse(struct ParseState *_parser, struct Value **Result) {
 		ProgramFail(_parser, "brackets not closed");
 	}
 	// scan and collapse the stack to precedence 0
-	ExpressionStackCollapse(_parser, &StackTop, 0, &IgnorePrecedence);
+	ExpressionStackCollapse(_parser, &_stackTop, 0, &IgnorePrecedence);
 	// fix up the stack and return the result if we're in run mode
-	if (StackTop != NULL) {
+	if (_stackTop != NULL) {
 		// all that should be left is a single value on the stack
 		if (_parser->Mode == RunModeRun) {
-			if (    StackTop->Order != OrderNone
-			     || StackTop->Next != NULL) {
+			if (    _stackTop->Order != OrderNone
+			     || _stackTop->Next != NULL) {
 				ProgramFail(_parser, "invalid expression");
 			}
-			*Result = StackTop->Val;
-			HeapPopStack(StackTop, sizeof(struct ExpressionStack));
+			*Result = _stackTop->Val;
+			HeapPopStack(_stackTop, sizeof(struct ExpressionStack));
 		} else {
-			HeapPopStack(StackTop->Val, sizeof(struct ExpressionStack) + sizeof(struct Value) + TypeStackSizeValue(StackTop->Val));
+			HeapPopStack(_stackTop->Val, sizeof(struct ExpressionStack) + sizeof(struct Value) + TypeStackSizeValue(_stackTop->Val));
 		}
 	}
 	debugf("ExpressionParse() done\n\n");
 #ifdef DEBUG_EXPRESSIONS
-	ExpressionStackShow(StackTop);
+	ExpressionStackShow(_stackTop);
 #endif
-	return StackTop != NULL;
+	return _stackTop != NULL;
 }
 
 
 /* do a parameterised macro call */
-void ExpressionParseMacroCall(struct ParseState *_parser, struct ExpressionStack **StackTop, const char *MacroName, struct MacroDef *MDef) {
+void ExpressionParseMacroCall(struct ParseState *_parser, struct ExpressionStack **_stackTop, const char *MacroName, struct MacroDef *MDef) {
 	struct Value *ReturnValue = NULL;
 	struct Value *Param;
 	struct Value **ParamArray = NULL;
@@ -1337,15 +1348,15 @@ void ExpressionParseMacroCall(struct ParseState *_parser, struct ExpressionStack
 	enum LexToken Token;
 	if (_parser->Mode == RunModeRun) {
 		/* create a stack frame for this macro */
-		ExpressionStackPushValueByType(_parser, StackTop, &FPType);  /* largest return type there is */
-		ReturnValue = (*StackTop)->Val;
+		ExpressionStackPushValueByType(_parser, _stackTop, &FPType);  /* largest return type there is */
+		ReturnValue = (*_stackTop)->Val;
 		HeapPushStackFrame();
 		ParamArray = HeapAllocStack(sizeof(struct Value *) * MDef->NumParams);	
 		if (ParamArray == NULL) {
 			ProgramFail(_parser, "out of memory");
 		}
 	} else {
-		ExpressionPushInt(_parser, StackTop, 0);
+		ExpressionPushInt(_parser, _stackTop, 0);
 	}
 	// parse arguments
 	ArgCount = 0;
@@ -1399,7 +1410,7 @@ void ExpressionParseMacroCall(struct ParseState *_parser, struct ExpressionStack
 }
 
 /* do a function call */
-void ExpressionParseFunctionCall(struct ParseState *_parser, struct ExpressionStack **StackTop, const char *FuncName, int RunIt) {
+void ExpressionParseFunctionCall(struct ParseState *_parser, struct ExpressionStack **_stackTop, const char *_funcName, int _runIt) {
 	struct Value *ReturnValue = NULL;
 	struct Value *FuncValue;
 	struct Value *Param;
@@ -1407,43 +1418,43 @@ void ExpressionParseFunctionCall(struct ParseState *_parser, struct ExpressionSt
 	int ArgCount;
 	enum LexToken Token = LexGetToken(_parser, NULL, TRUE);	/* open bracket */
 	enum RunMode OldMode = _parser->Mode;
-	if (RunIt) {
+	if (_runIt) {
 		/* get the function definition */
-		VariableGet(_parser, FuncName, &FuncValue);
+		VariableGet(_parser, _funcName, &FuncValue);
 		if (FuncValue->Typ->Base == TypeMacro) {
 			/* this is actually a macro, not a function */
-			ExpressionParseMacroCall(_parser, StackTop, FuncName, &FuncValue->Val->MacroDef);
+			ExpressionParseMacroCall(_parser, _stackTop, _funcName, &FuncValue->Val->MacroDef);
 			return;
 		}
 		if (FuncValue->Typ->Base != TypeFunction) {
 			ProgramFail(_parser, "%t is not a function - can't call", FuncValue->Typ);
 		}
-		ExpressionStackPushValueByType(_parser, StackTop, FuncValue->Val->FuncDef.ReturnType);
-		ReturnValue = (*StackTop)->Val;
+		ExpressionStackPushValueByType(_parser, _stackTop, FuncValue->Val->FuncDef.ReturnType);
+		ReturnValue = (*_stackTop)->Val;
 		HeapPushStackFrame();
 		ParamArray = HeapAllocStack(sizeof(struct Value *) * FuncValue->Val->FuncDef.NumParams);
 		if (ParamArray == NULL) {
 			ProgramFail(_parser, "out of memory");
 		}
 	} else {
-		ExpressionPushInt(_parser, StackTop, 0);
+		ExpressionPushInt(_parser, _stackTop, 0);
 		_parser->Mode = RunModeSkip;
 	}
 	// parse arguments
 	ArgCount = 0;
 	do {
-		if (    RunIt
+		if (    _runIt
 		     && ArgCount < FuncValue->Val->FuncDef.NumParams) {
 			ParamArray[ArgCount] = VariableAllocValueFromType(_parser, FuncValue->Val->FuncDef.ParamType[ArgCount], FALSE, NULL, FALSE);
 		}
 		if (ExpressionParse(_parser, &Param)) {
-			if (RunIt) {
+			if (_runIt) {
 				if (ArgCount < FuncValue->Val->FuncDef.NumParams) {
-					ExpressionAssign(_parser, ParamArray[ArgCount], Param, TRUE, FuncName, ArgCount+1, FALSE);
+					ExpressionAssign(_parser, ParamArray[ArgCount], Param, TRUE, _funcName, ArgCount+1, FALSE);
 					VariableStackPop(_parser, Param);
 				} else {
 					if (!FuncValue->Val->FuncDef.VarArgs) {
-						ProgramFail(_parser, "too many arguments to %s()", FuncName);
+						ProgramFail(_parser, "too many arguments to %s()", _funcName);
 					}
 				}
 			}
@@ -1460,20 +1471,20 @@ void ExpressionParseFunctionCall(struct ParseState *_parser, struct ExpressionSt
 			}
 		}
 	} while (Token != TokenCloseBracket);
-	if (RunIt) {
+	if (_runIt) {
 		/* run the function */
 		if (ArgCount < FuncValue->Val->FuncDef.NumParams) {
-			ProgramFail(_parser, "not enough arguments to '%s'", FuncName);
+			ProgramFail(_parser, "not enough arguments to '%s'", _funcName);
 		}
 		if (FuncValue->Val->FuncDef.Intrinsic == NULL) {
 			/* run a user-defined function */
 			struct ParseState FuncParser;
 			int Count;
 			if (FuncValue->Val->FuncDef.Body.Pos == NULL) {
-				ProgramFail(_parser, "'%s' is undefined", FuncName);
+				ProgramFail(_parser, "'%s' is undefined", _funcName);
 			}
 			ParserCopy(&FuncParser, &FuncValue->Val->FuncDef.Body);
-			VariableStackFrameAdd(_parser, FuncName, FuncValue->Val->FuncDef.Intrinsic ? FuncValue->Val->FuncDef.NumParams : 0);
+			VariableStackFrameAdd(_parser, _funcName, FuncValue->Val->FuncDef.Intrinsic ? FuncValue->Val->FuncDef.NumParams : 0);
 			TopStackFrame->NumParams = ArgCount;
 			TopStackFrame->ReturnValue = ReturnValue;
 			for (Count = 0; Count < FuncValue->Val->FuncDef.NumParams; ++Count) {
@@ -1482,7 +1493,7 @@ void ExpressionParseFunctionCall(struct ParseState *_parser, struct ExpressionSt
 			if (ParseStatement(&FuncParser, TRUE) != ParseResultOk) {
 				ProgramFail(&FuncParser, "function body expected");
 			}
-			if (RunIt) {
+			if (_runIt) {
 				if (    FuncParser.Mode == RunModeRun
 				     && FuncValue->Val->FuncDef.ReturnType != &VoidType) {
 					ProgramFail(&FuncParser, "no value returned from a function returning %t", FuncValue->Val->FuncDef.ReturnType);
diff --git a/eci/expression.h b/eci/expression.h
new file mode 100644
index 0000000..7a0cd88
--- /dev/null
+++ b/eci/expression.h
@@ -0,0 +1,19 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2014, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE-2 (see license file)
+ */
+
+#ifndef __ECI_EXPRESSION_H__
+#define __ECI_EXPRESSION_H__
+
+int ExpressionParse(struct ParseState *_parser, struct Value **_result);
+long ExpressionParseInt(struct ParseState *_parser);
+void ExpressionAssign(struct ParseState *_parser, struct Value *_destValue, struct Value *_sourceValue, int _force, const char *_funcName, int _paramNo, int _allowPointerCoercion);
+long ExpressionCoerceInteger(struct Value *_value);
+unsigned long ExpressionCoerceUnsignedInteger(struct Value *_value);
+double ExpressionCoerceFP(struct Value *_value);
+
+#endif
diff --git a/eci/heap.h b/eci/heap.h
new file mode 100644
index 0000000..93a8189
--- /dev/null
+++ b/eci/heap.h
@@ -0,0 +1,23 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2014, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE-2 (see license file)
+ */
+
+#ifndef __ECI_HEAP_H__
+#define __ECI_HEAP_H__
+
+
+void HeapInit(int _stackSize);
+void HeapCleanup();
+void *HeapAllocStack(int _size);
+int HeapPopStack(void *_addr, int _size);
+void HeapUnpopStack(int _size);
+void HeapPushStackFrame();
+int HeapPopStackFrame();
+void *HeapAllocMem(int _size);
+void HeapFreeMem(void *_mem);
+
+#endif
diff --git a/eci/include.h b/eci/include.h
new file mode 100644
index 0000000..874e6ca
--- /dev/null
+++ b/eci/include.h
@@ -0,0 +1,21 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2014, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE-2 (see license file)
+ */
+
+#ifndef __ECI_INCLUDE_H__
+#define __ECI_INCLUDE_H__
+
+
+void IncludeInit();
+void IncludeCleanup();
+void IncludeRegister(const char *_includeName, void (*_setupFunction)(void), struct LibraryFunction *_funcList, const char *_setupCSource);
+void IncludeFile(char *_filename);
+/* the following is defined in picoc.h:
+ * void PicocIncludeAllSystemHeaders(); */
+
+
+#endif
diff --git a/eci/interpreter.h b/eci/interpreter.h
index 3f9fa0b..3ae552a 100644
--- a/eci/interpreter.h
+++ b/eci/interpreter.h
@@ -336,18 +336,18 @@ extern IOFILE *CStdOut;
  * void PicocCleanup();
  * void PicocPlatformScanFile(const char *FileName);
  * extern int PicocExitValue; */
-void ProgramFail(struct ParseState *Parser, const char *Message, ...);
-void AssignFail(struct ParseState *Parser, const char *Format, struct ValueType *Type1, struct ValueType *Type2, int Num1, int Num2, const char *FuncName, int ParamNo);
-void LexFail(struct LexState *Lexer, const char *Message, ...);
+void ProgramFail(struct ParseState *_parser, const char *_message, ...);
+void AssignFail(struct ParseState *_parser, const char *_mormat, struct ValueType *_type1, struct ValueType *_type2, int _num1, int _num2, const char *_funcName, int _paramNo);
+void LexFail(struct LexState *_lexer, const char *_message, ...);
 void PlatformCleanup();
-char *PlatformGetLine(char *Buf, int MaxLen, const char *Prompt);
+char *PlatformGetLine(char *_buf, int _maxLen, const char *_prompt);
 int PlatformGetCharacter();
-void PlatformPutc(unsigned char OutCh, union OutputStreamInfo *);
-void PlatformErrorPrefix(struct ParseState *Parser);
-void PlatformPrintf(const char *Format, ...);
-void PlatformVPrintf(const char *Format, va_list Args);
-void PlatformExit(int ExitVal);
-char *PlatformMakeTempName(char *TempNameBuffer);
+void PlatformPutc(unsigned char _outCh, union OutputStreamInfo *);
+void PlatformErrorPrefix(struct ParseState *_parser);
+void PlatformPrintf(const char *_format, ...);
+void PlatformVPrintf(const char *_format, va_list _args);
+void PlatformExit(int _exitVal);
+char *PlatformMakeTempName(char *_tempNameBuffer);
 void PlatformLibraryInit();
 
 
diff --git a/eci/lex.c b/eci/lex.c
index 83856d5..5ca605e 100644
--- a/eci/lex.c
+++ b/eci/lex.c
@@ -8,12 +8,6 @@
 
 #include "interpreter.h"
 
-#ifdef NO_CTYPE
-#define isalpha(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z'))
-#define isdigit(c) ((c) >= '0' && (c) <= '9')
-#define isalnum(c) (isalpha(c) || isdigit(c))
-#define isspace(c) ((c) == ' ' || (c) == '\t' || (c) == '\r' || (c) == '\n')
-#endif
 #define isCidstart(c) (isalpha(c) || (c)=='_' || (c)=='#')
 #define isCident(c) (isalnum(c) || (c)=='_')
 
@@ -21,11 +15,11 @@
 #define IS_BASE_DIGIT(c,b) (((c) >= '0' && (c) < '0' + (((b)<10)?(b):10)) || (((b) > 10) ? IS_HEX_ALPHA_DIGIT(c) : FALSE))
 #define GET_BASE_DIGIT(c) (((c) <= '9') ? ((c) - '0') : (((c) <= 'F') ? ((c) - 'A' + 10) : ((c) - 'a' + 10)))
 
-#define NEXTIS(c,x,y) { if (NextChar == (c)) { LEXER_INC(Lexer); GotToken = (x); } else GotToken = (y); }
-#define NEXTIS3(c,x,d,y,z) { if (NextChar == (c)) { LEXER_INC(Lexer); GotToken = (x); } else NEXTIS(d,y,z) }
-#define NEXTIS4(c,x,d,y,e,z,a) { if (NextChar == (c)) { LEXER_INC(Lexer); GotToken = (x); } else NEXTIS3(d,y,e,z,a) }
-#define NEXTIS3PLUS(c,x,d,y,e,z,a) { if (NextChar == (c)) { LEXER_INC(Lexer); GotToken = (x); } else if (NextChar == (d)) { if (Lexer->Pos[1] == (e)) { LEXER_INCN(Lexer, 2); GotToken = (z); } else { LEXER_INC(Lexer); GotToken = (y); } } else GotToken = (a); }
-#define NEXTISEXACTLY3(c,d,y,z) { if (NextChar == (c) && Lexer->Pos[1] == (d)) { LEXER_INCN(Lexer, 2); GotToken = (y); } else GotToken = (z); }
+#define NEXTIS(c,x,y) { if (NextChar == (c)) { LEXER_INC(_lexer); GotToken = (x); } else GotToken = (y); }
+#define NEXTIS3(c,x,d,y,z) { if (NextChar == (c)) { LEXER_INC(_lexer); GotToken = (x); } else NEXTIS(d,y,z) }
+#define NEXTIS4(c,x,d,y,e,z,a) { if (NextChar == (c)) { LEXER_INC(_lexer); GotToken = (x); } else NEXTIS3(d,y,e,z,a) }
+#define NEXTIS3PLUS(c,x,d,y,e,z,a) { if (NextChar == (c)) { LEXER_INC(_lexer); GotToken = (x); } else if (NextChar == (d)) { if (_lexer->Pos[1] == (e)) { LEXER_INCN(_lexer, 2); GotToken = (z); } else { LEXER_INC(_lexer); GotToken = (y); } } else GotToken = (a); }
+#define NEXTISEXACTLY3(c,d,y,z) { if (NextChar == (c) && _lexer->Pos[1] == (d)) { LEXER_INCN(_lexer, 2); GotToken = (y); } else GotToken = (z); }
 
 #define LEXER_INC(l) ( (l)->Pos++, (l)->CharacterPos++ )
 #define LEXER_INCN(l, n) ( (l)->Pos+=(n), (l)->CharacterPos+=(n) )
@@ -34,7 +28,12 @@
 #define MAX_CHAR_VALUE 255	  /* maximum value which can be represented by a "char" data type */
 
 static union AnyValue LexAnyValue;
-static struct Value LexValue = { TypeVoid, &LexAnyValue, FALSE, FALSE };
+static struct Value LexValue = {
+	TypeVoid,
+	&LexAnyValue,
+	FALSE,
+	FALSE
+};
 
 struct ReservedWord {
 	const char *Word;
@@ -111,10 +110,10 @@ void LexCleanup() {
 }
 
 /* check if a word is a reserved word - used while scanning */
-enum LexToken LexCheckReservedWord(const char *Word) {
+enum LexToken LexCheckReservedWord(const char *_word) {
 	int Count;
 	for (Count = 0; Count < sizeof(ReservedWords) / sizeof(struct ReservedWord); Count++) {
-		if (Word == ReservedWords[Count].SharedWord) {
+		if (_word == ReservedWords[Count].SharedWord) {
 			return ReservedWords[Count].Token;
 		}
 	}
@@ -122,139 +121,139 @@ enum LexToken LexCheckReservedWord(const char *Word) {
 }
 
 /* get a numeric literal - used while scanning */
-enum LexToken LexGetNumber(struct LexState *Lexer, struct Value *Value) {
+enum LexToken LexGetNumber(struct LexState *_lexer, struct Value *_value) {
 	int Result = 0;
 	int Base = 10;
 	enum LexToken ResultToken;
 	double FPResult;
 	double FPDiv;
-	if (*Lexer->Pos == '0') {
+	if (*_lexer->Pos == '0') {
 		/* a binary, octal or hex literal */
-		LEXER_INC(Lexer);
-		if (Lexer->Pos != Lexer->End) {
-			if (    *Lexer->Pos == 'x'
-			     || *Lexer->Pos == 'X') {
+		LEXER_INC(_lexer);
+		if (_lexer->Pos != _lexer->End) {
+			if (    *_lexer->Pos == 'x'
+			     || *_lexer->Pos == 'X') {
 				Base = 16;
-				LEXER_INC(Lexer);
-			} else if (*Lexer->Pos == 'b' || *Lexer->Pos == 'B') {
+				LEXER_INC(_lexer);
+			} else if (*_lexer->Pos == 'b' || *_lexer->Pos == 'B') {
 				Base = 2;
-				LEXER_INC(Lexer);
-			} else if (*Lexer->Pos != '.') {
+				LEXER_INC(_lexer);
+			} else if (*_lexer->Pos != '.') {
 				Base = 8;
 			}
 		}
 	}
 	/* get the value */
-	for (; Lexer->Pos != Lexer->End && IS_BASE_DIGIT(*Lexer->Pos, Base); LEXER_INC(Lexer)) {
-		Result = Result * Base + GET_BASE_DIGIT(*Lexer->Pos);
+	for (; _lexer->Pos != _lexer->End && IS_BASE_DIGIT(*_lexer->Pos, Base); LEXER_INC(_lexer)) {
+		Result = Result * Base + GET_BASE_DIGIT(*_lexer->Pos);
 	}
 	if (Result >= 0 && Result <= MAX_CHAR_VALUE) {
-		Value->Typ = &CharType;
-		Value->Val->Character = Result;
+		_value->Typ = &CharType;
+		_value->Val->Character = Result;
 		ResultToken = TokenCharacterConstant;
 	} else {
-		Value->Typ = &IntType;
-		Value->Val->Integer = Result;
+		_value->Typ = &IntType;
+		_value->Val->Integer = Result;
 		ResultToken = TokenIntegerConstant;
 	}
-	if (Lexer->Pos == Lexer->End) {
+	if (_lexer->Pos == _lexer->End) {
 		return ResultToken;
 	}
-	if (    *Lexer->Pos == 'l'
-	     || *Lexer->Pos == 'L') {
-		LEXER_INC(Lexer);
+	if (    *_lexer->Pos == 'l'
+	     || *_lexer->Pos == 'L') {
+		LEXER_INC(_lexer);
 		return ResultToken;
 	}
-	if (    Lexer->Pos == Lexer->End
-	     || *Lexer->Pos != '.') {
+	if (    _lexer->Pos == _lexer->End
+	     || *_lexer->Pos != '.') {
 		return ResultToken;
 	}
-	Value->Typ = &FPType;
-	LEXER_INC(Lexer);
-	for (FPDiv = 1.0/Base, FPResult = (double)Result; Lexer->Pos != Lexer->End && IS_BASE_DIGIT(*Lexer->Pos, Base); LEXER_INC(Lexer), FPDiv /= (double)Base) {
-		FPResult += GET_BASE_DIGIT(*Lexer->Pos) * FPDiv;
+	_value->Typ = &FPType;
+	LEXER_INC(_lexer);
+	for (FPDiv = 1.0/Base, FPResult = (double)Result; _lexer->Pos != _lexer->End && IS_BASE_DIGIT(*_lexer->Pos, Base); LEXER_INC(_lexer), FPDiv /= (double)Base) {
+		FPResult += GET_BASE_DIGIT(*_lexer->Pos) * FPDiv;
 	}
 	
-	if (    Lexer->Pos != Lexer->End
-	     && (    *Lexer->Pos == 'e'
-	          || *Lexer->Pos == 'E') ) {
+	if (    _lexer->Pos != _lexer->End
+	     && (    *_lexer->Pos == 'e'
+	          || *_lexer->Pos == 'E') ) {
 		double ExponentMultiplier = 1.0;
-		LEXER_INC(Lexer);
-		if (Lexer->Pos != Lexer->End && *Lexer->Pos == '-') {
+		LEXER_INC(_lexer);
+		if (_lexer->Pos != _lexer->End && *_lexer->Pos == '-') {
 			ExponentMultiplier = -1.0;
-			LEXER_INC(Lexer);
+			LEXER_INC(_lexer);
 		}
-		for (Result = 0; Lexer->Pos != Lexer->End && IS_BASE_DIGIT(*Lexer->Pos, Base); LEXER_INC(Lexer)) {
-			Result = Result * (double)Base + GET_BASE_DIGIT(*Lexer->Pos);
+		for (Result = 0; _lexer->Pos != _lexer->End && IS_BASE_DIGIT(*_lexer->Pos, Base); LEXER_INC(_lexer)) {
+			Result = Result * (double)Base + GET_BASE_DIGIT(*_lexer->Pos);
 		}
 		FPResult *= pow((double)Base, (double)Result * ExponentMultiplier);
 	}
-	Value->Val->FP = FPResult;
+	_value->Val->FP = FPResult;
 	return TokenFPConstant;
 }
 
 /* get a reserved word or identifier - used while scanning */
-enum LexToken LexGetWord(struct LexState *Lexer, struct Value *Value) {
-	const char *StartPos = Lexer->Pos;
+enum LexToken LexGetWord(struct LexState *_lexer, struct Value *_value) {
+	const char *StartPos = _lexer->Pos;
 	enum LexToken Token;
 	do {
-		LEXER_INC(Lexer);
-	} while (    Lexer->Pos != Lexer->End
-	          && isCident((int)*Lexer->Pos));
-	Value->Typ = NULL;
-	Value->Val->Identifier = TableStrRegister2(StartPos, Lexer->Pos - StartPos);
-	Token = LexCheckReservedWord(Value->Val->Identifier);
+		LEXER_INC(_lexer);
+	} while (    _lexer->Pos != _lexer->End
+	          && isCident((int)*_lexer->Pos));
+	_value->Typ = NULL;
+	_value->Val->Identifier = TableStrRegister2(StartPos, _lexer->Pos - StartPos);
+	Token = LexCheckReservedWord(_value->Val->Identifier);
 	switch (Token) {
-		case TokenHashInclude: Lexer->Mode = LexModeHashInclude; break;
-		case TokenHashDefine: Lexer->Mode = LexModeHashDefine; break;
+		case TokenHashInclude: _lexer->Mode = LexModeHashInclude; break;
+		case TokenHashDefine: _lexer->Mode = LexModeHashDefine; break;
 		default: break;
 	}
 	if (Token != TokenNone) {
 		return Token;
 	}
-	if (Lexer->Mode == LexModeHashDefineSpace) {
-		Lexer->Mode = LexModeHashDefineSpaceIdent;
+	if (_lexer->Mode == LexModeHashDefineSpace) {
+		_lexer->Mode = LexModeHashDefineSpaceIdent;
 	}
 	return TokenIdentifier;
 }
 
 /* unescape a character from an octal character constant */
-unsigned char LexUnEscapeCharacterConstant(const char **From, const char *End, unsigned char FirstChar, int Base) {
-	unsigned char Total = GET_BASE_DIGIT(FirstChar);
+unsigned char LexUnEscapeCharacterConstant(const char** _from, const char* _end, unsigned char _firstChar, int _base) {
+	unsigned char total = GET_BASE_DIGIT(_firstChar);
 	int CCount;
-	for (CCount = 0; IS_BASE_DIGIT(**From, Base) && CCount < 2; CCount++, (*From)++) {
-		Total = Total * Base + GET_BASE_DIGIT(**From);
+	for (CCount = 0; IS_BASE_DIGIT(**_from, _base) && CCount < 2; CCount++, (*_from)++) {
+		total = total * _base + GET_BASE_DIGIT(**_from);
 	}
-	return Total;
+	return total;
 }
 
 /* unescape a character from a string or character constant */
-unsigned char LexUnEscapeCharacter(const char **From, const char *End) {
+unsigned char LexUnEscapeCharacter(const char **_from, const char *_end) {
 	unsigned char ThisChar;
-	while (    *From != End
-	        && **From == '\\'
-	        && &(*From)[1] != End
-	        && (*From)[1] == '\n' ) {
-		(*From) += 2;	   /* skip escaped end of lines with LF line termination */
+	while (    *_from != _end
+	        && **_from == '\\'
+	        && &(*_from)[1] != _end
+	        && (*_from)[1] == '\n' ) {
+		(*_from) += 2;	   /* skip escaped end of lines with LF line termination */
 	}
-	while (    *From != End
-	        && **From == '\\'
-	        && &(*From)[1] != End
-	        && &(*From)[2] != End
-	        && (*From)[1] == '\r'
-	        && (*From)[2] == '\n') {
-		(*From) += 3;	   /* skip escaped end of lines with CR/LF line termination */
+	while (    *_from != _end
+	        && **_from == '\\'
+	        && &(*_from)[1] != _end
+	        && &(*_from)[2] != _end
+	        && (*_from)[1] == '\r'
+	        && (*_from)[2] == '\n') {
+		(*_from) += 3;	   /* skip escaped end of lines with CR/LF line termination */
 	}
-	if (*From == End) {
+	if (*_from == _end) {
 		return '\\';
 	}
-	if (**From == '\\') {
+	if (**_from == '\\') {
 		/* it's escaped */
-		(*From)++;
-		if (*From == End) {
+		(*_from)++;
+		if (*_from == _end) {
 			return '\\';
 		}
-		ThisChar = *(*From)++;
+		ThisChar = *(*_from)++;
 		switch (ThisChar) {
 			case '\\':
 				return '\\'; 
@@ -280,56 +279,56 @@ unsigned char LexUnEscapeCharacter(const char **From, const char *End) {
 			case '1':
 			case '2':
 			case '3':
-				return LexUnEscapeCharacterConstant(From, End, ThisChar, 8);
+				return LexUnEscapeCharacterConstant(_from, _end, ThisChar, 8);
 			case 'x':
-				return LexUnEscapeCharacterConstant(From, End, '0', 16);
+				return LexUnEscapeCharacterConstant(_from, _end, '0', 16);
 			default:
 				return ThisChar;
 		}
 	} else {
-		return *(*From)++;
+		return *(*_from)++;
 	}
 }
 
 /* get a string constant - used while scanning */
-enum LexToken LexGetStringConstant(struct LexState *Lexer, struct Value *Value, char EndChar) {
+enum LexToken LexGetStringConstant(struct LexState *_lexer, struct Value *_value, char _endChar) {
 	int Escape = FALSE;
-	const char *StartPos = Lexer->Pos;
+	const char *StartPos = _lexer->Pos;
 	const char *EndPos;
 	char *EscBuf;
 	char *EscBufPos;
 	char *RegString;
 	struct Value *ArrayValue;
 	
-	while (    Lexer->Pos != Lexer->End
-	        && (    *Lexer->Pos != EndChar
+	while (    _lexer->Pos != _lexer->End
+	        && (    *_lexer->Pos != _endChar
 	             || Escape)) {
 		/* find the end */
 		if (Escape) {
-			if (    *Lexer->Pos == '\r'
-			     && Lexer->Pos+1 != Lexer->End) {
-				Lexer->Pos++;
+			if (    *_lexer->Pos == '\r'
+			     && _lexer->Pos+1 != _lexer->End) {
+				_lexer->Pos++;
 			}
-			if (    *Lexer->Pos == '\n'
-			     && Lexer->Pos+1 != Lexer->End) {
-				Lexer->Line++;
-				Lexer->Pos++;
-				Lexer->CharacterPos = 0;
-				Lexer->EmitExtraNewlines++;
+			if (    *_lexer->Pos == '\n'
+			     && _lexer->Pos+1 != _lexer->End) {
+				_lexer->Line++;
+				_lexer->Pos++;
+				_lexer->CharacterPos = 0;
+				_lexer->EmitExtraNewlines++;
 			}
 			Escape = FALSE;
-		} else if (*Lexer->Pos == '\\') {
+		} else if (*_lexer->Pos == '\\') {
 			Escape = TRUE;
 		}
-		LEXER_INC(Lexer);
+		LEXER_INC(_lexer);
 	}
-	EndPos = Lexer->Pos;
+	EndPos = _lexer->Pos;
 	EscBuf = HeapAllocStack(EndPos - StartPos);
 	if (EscBuf == NULL) {
-		LexFail(Lexer, "out of memory");
+		LexFail(_lexer, "out of memory");
 	}
-	for (EscBufPos = EscBuf, Lexer->Pos = StartPos; Lexer->Pos != EndPos;) {
-		*EscBufPos++ = LexUnEscapeCharacter(&Lexer->Pos, EndPos);
+	for (EscBufPos = EscBuf, _lexer->Pos = StartPos; _lexer->Pos != EndPos;) {
+		*EscBufPos++ = LexUnEscapeCharacter(&_lexer->Pos, EndPos);
 	}
 	/* try to find an existing copy of this string literal */
 	RegString = TableStrRegister2(EscBuf, EscBufPos - EscBuf);
@@ -343,104 +342,104 @@ enum LexToken LexGetStringConstant(struct LexState *Lexer, struct Value *Value,
 		VariableStringLiteralDefine(RegString, ArrayValue);
 	}
 	/* create the the pointer for this char* */
-	Value->Typ = CharPtrType;
-	Value->Val->Pointer = RegString;
-	if (*Lexer->Pos == EndChar) {
-		LEXER_INC(Lexer);
+	_value->Typ = CharPtrType;
+	_value->Val->Pointer = RegString;
+	if (*_lexer->Pos == _endChar) {
+		LEXER_INC(_lexer);
 	}
 	return TokenStringConstant;
 }
 
 /* get a character constant - used while scanning */
-enum LexToken LexGetCharacterConstant(struct LexState *Lexer, struct Value *Value) {
-	Value->Typ = &CharType;
-	Value->Val->Character = LexUnEscapeCharacter(&Lexer->Pos, Lexer->End);
-	if (Lexer->Pos != Lexer->End && *Lexer->Pos != '\'') {
-		LexFail(Lexer, "expected \"'\""); // "
+enum LexToken LexGetCharacterConstant(struct LexState *_lexer, struct Value *_value) {
+	_value->Typ = &CharType;
+	_value->Val->Character = LexUnEscapeCharacter(&_lexer->Pos, _lexer->End);
+	if (_lexer->Pos != _lexer->End && *_lexer->Pos != '\'') {
+		LexFail(_lexer, "expected \"'\""); // "
 	}
-	LEXER_INC(Lexer);
+	LEXER_INC(_lexer);
 	return TokenCharacterConstant;
 }
 
 /* skip a comment - used while scanning */
-void LexSkipComment(struct LexState *Lexer, char NextChar, enum LexToken *ReturnToken) {
-	if (NextChar == '*') {
+void LexSkipComment(struct LexState *_lexer, char _nextChar, enum LexToken *_returnToken) {
+	if (_nextChar == '*') {
 		/* conventional C comment */
-		while (Lexer->Pos != Lexer->End && (*(Lexer->Pos-1) != '*' || *Lexer->Pos != '/')) {
-			if (*Lexer->Pos == '\n') {
-				Lexer->EmitExtraNewlines++;
+		while (_lexer->Pos != _lexer->End && (*(_lexer->Pos-1) != '*' || *_lexer->Pos != '/')) {
+			if (*_lexer->Pos == '\n') {
+				_lexer->EmitExtraNewlines++;
 			}
-			LEXER_INC(Lexer);
+			LEXER_INC(_lexer);
 		}
-		if (Lexer->Pos != Lexer->End) {
-			LEXER_INC(Lexer);
+		if (_lexer->Pos != _lexer->End) {
+			LEXER_INC(_lexer);
 		}
-		Lexer->Mode = LexModeNormal;
+		_lexer->Mode = LexModeNormal;
 	} else {
 		/* C++ style comment */
-		while (    Lexer->Pos != Lexer->End
-		        && *Lexer->Pos != '\n') {
-			LEXER_INC(Lexer);
+		while (    _lexer->Pos != _lexer->End
+		        && *_lexer->Pos != '\n') {
+			LEXER_INC(_lexer);
 		}
 	}
 }
 
 /* get a single token from the source - used while scanning */
-enum LexToken LexScanGetToken(struct LexState *Lexer, struct Value **Value) {
+enum LexToken LexScanGetToken(struct LexState *_lexer, struct Value **_value) {
 	char ThisChar;
 	char NextChar;
 	enum LexToken GotToken = TokenNone;
 	/* handle cases line multi-line comments or string constants which mess up the line count */
-	if (Lexer->EmitExtraNewlines > 0) {
-		Lexer->EmitExtraNewlines--;
+	if (_lexer->EmitExtraNewlines > 0) {
+		_lexer->EmitExtraNewlines--;
 		return TokenEndOfLine;
 	}
 	/* scan for a token */
 	do {
-		*Value = &LexValue;
-		while (    Lexer->Pos != Lexer->End
-		        && isspace((int)*Lexer->Pos)) {
-			if (*Lexer->Pos == '\n') {
-				Lexer->Line++;
-				Lexer->Pos++;
-				Lexer->Mode = LexModeNormal;
-				Lexer->CharacterPos = 0;
+		*_value = &LexValue;
+		while (    _lexer->Pos != _lexer->End
+		        && isspace((int)*_lexer->Pos)) {
+			if (*_lexer->Pos == '\n') {
+				_lexer->Line++;
+				_lexer->Pos++;
+				_lexer->Mode = LexModeNormal;
+				_lexer->CharacterPos = 0;
 				return TokenEndOfLine;
-			} else if (    Lexer->Mode == LexModeHashDefine
-			            || Lexer->Mode == LexModeHashDefineSpace) {
-				Lexer->Mode = LexModeHashDefineSpace;
-			} else if (Lexer->Mode == LexModeHashDefineSpaceIdent) {
-				Lexer->Mode = LexModeNormal;
+			} else if (    _lexer->Mode == LexModeHashDefine
+			            || _lexer->Mode == LexModeHashDefineSpace) {
+				_lexer->Mode = LexModeHashDefineSpace;
+			} else if (_lexer->Mode == LexModeHashDefineSpaceIdent) {
+				_lexer->Mode = LexModeNormal;
 			}
-			LEXER_INC(Lexer);
+			LEXER_INC(_lexer);
 		}
-		if (    Lexer->Pos == Lexer->End
-		     || *Lexer->Pos == '\0') {
+		if (    _lexer->Pos == _lexer->End
+		     || *_lexer->Pos == '\0') {
 			return TokenEOF;
 		}
-		ThisChar = *Lexer->Pos;
+		ThisChar = *_lexer->Pos;
 		if (isCidstart((int)ThisChar)) {
-			return LexGetWord(Lexer, *Value);
+			return LexGetWord(_lexer, *_value);
 		}
 		if (isdigit((int)ThisChar)) {
-			return LexGetNumber(Lexer, *Value);
+			return LexGetNumber(_lexer, *_value);
 		}
-		NextChar = (Lexer->Pos+1 != Lexer->End) ? *(Lexer->Pos+1) : 0;
-		LEXER_INC(Lexer);
+		NextChar = (_lexer->Pos+1 != _lexer->End) ? *(_lexer->Pos+1) : 0;
+		LEXER_INC(_lexer);
 		switch (ThisChar) {
 			case '"':
-				GotToken = LexGetStringConstant(Lexer, *Value, '"');
+				GotToken = LexGetStringConstant(_lexer, *_value, '"');
 				break;
 			case '\'': //'
-				GotToken = LexGetCharacterConstant(Lexer, *Value);
+				GotToken = LexGetCharacterConstant(_lexer, *_value);
 				break;
 			case '(':
-				if (Lexer->Mode == LexModeHashDefineSpaceIdent) {
+				if (_lexer->Mode == LexModeHashDefineSpaceIdent) {
 					GotToken = TokenOpenMacroBracket;
 				} else {
 					GotToken = TokenOpenBracket;
 				}
-				Lexer->Mode = LexModeNormal;
+				_lexer->Mode = LexModeNormal;
 				break;
 			case ')': 
 				GotToken = TokenCloseBracket;
@@ -460,8 +459,8 @@ enum LexToken LexScanGetToken(struct LexState *Lexer, struct Value **Value) {
 			case '/':
 				if (    NextChar == '/'
 				     || NextChar == '*') {
-					LEXER_INC(Lexer);
-					LexSkipComment(Lexer, NextChar, &GotToken);
+					LEXER_INC(_lexer);
+					LexSkipComment(_lexer, NextChar, &GotToken);
 				} else {
 					NEXTIS('=', TokenDivideAssign, TokenSlash);
 				}
@@ -470,8 +469,8 @@ enum LexToken LexScanGetToken(struct LexState *Lexer, struct Value **Value) {
 				NEXTIS('=', TokenModulusAssign, TokenModulus);
 				break;
 			case '<':
-				if (Lexer->Mode == LexModeHashInclude) {
-					GotToken = LexGetStringConstant(Lexer, *Value, '>');
+				if (_lexer->Mode == LexModeHashInclude) {
+					GotToken = LexGetStringConstant(_lexer, *_value, '>');
 				} else {
 					NEXTIS3PLUS('=', TokenLessEqual, '<', TokenShiftLeft, '=', TokenShiftLeftAssign, TokenLessThan);
 				}
@@ -522,7 +521,7 @@ enum LexToken LexScanGetToken(struct LexState *Lexer, struct Value **Value) {
 				GotToken = TokenColon;
 				break;
 			default:
-				LexFail(Lexer, "illegal character '%c'", ThisChar);
+				LexFail(_lexer, "illegal character '%c'", ThisChar);
 				break;
 		}
 	} while (GotToken == TokenNone);
@@ -530,8 +529,8 @@ enum LexToken LexScanGetToken(struct LexState *Lexer, struct Value **Value) {
 }
 
 /* what size value goes with each token */
-int LexTokenSize(enum LexToken Token) {
-	switch (Token) {
+int LexTokenSize(enum LexToken _token) {
+	switch (_token) {
 		case TokenIdentifier:
 		case TokenStringConstant:
 			return sizeof(char *);
@@ -547,22 +546,22 @@ int LexTokenSize(enum LexToken Token) {
 }
 
 /* produce tokens from the lexer and return a heap buffer with the result - used for scanning */
-void *LexTokenise(struct LexState *Lexer, int *TokenLen) {
+void *LexTokenise(struct LexState *_lexer, int *_tokenLen) {
 	enum LexToken Token;
 	void *HeapMem;
 	struct Value *GotValue;
 	int MemUsed = 0;
 	int ValueSize;
-	int ReserveSpace = (Lexer->End - Lexer->Pos) * 4 + 16; 
+	int ReserveSpace = (_lexer->End - _lexer->Pos) * 4 + 16; 
 	void *TokenSpace = HeapAllocStack(ReserveSpace);
 	char *TokenPos = (char *)TokenSpace;
 	int LastCharacterPos = 0;
 	if (TokenSpace == NULL) {
-		LexFail(Lexer, "out of memory");
+		LexFail(_lexer, "out of memory");
 	}
 	do {
 		/* store the token at the end of the stack area */
-		Token = LexScanGetToken(Lexer, &GotValue);
+		Token = LexScanGetToken(_lexer, &GotValue);
 #ifdef DEBUG_LEXER
 		printf("Token: %02x\n", Token);
 #endif
@@ -579,11 +578,11 @@ void *LexTokenise(struct LexState *Lexer, int *TokenLen) {
 			TokenPos += ValueSize;
 			MemUsed += ValueSize;
 		}
-		LastCharacterPos = Lexer->CharacterPos;
+		LastCharacterPos = _lexer->CharacterPos;
 	} while (Token != TokenEOF);
 	HeapMem = HeapAllocMem(MemUsed);
 	if (HeapMem == NULL) {
-		LexFail(Lexer, "out of memory");
+		LexFail(_lexer, "out of memory");
 	}
 	assert(ReserveSpace >= MemUsed);
 	memcpy(HeapMem, TokenSpace, MemUsed);
@@ -598,59 +597,59 @@ void *LexTokenise(struct LexState *Lexer, int *TokenLen) {
 		printf("\n");
 	}
 #endif
-	if (TokenLen) {
-		*TokenLen = MemUsed;
+	if (_tokenLen) {
+		*_tokenLen = MemUsed;
 	}
 	return HeapMem;
 }
 
 /* lexically analyse some source text */
-void *LexAnalyse(const char *FileName, const char *Source, int SourceLen, int *TokenLen) {
+void *LexAnalyse(const char* _fileName, const char* _source, int _sourceLen, int *_tokenLen) {
 	struct LexState Lexer;
-	Lexer.Pos = Source;
-	Lexer.End = Source + SourceLen;
+	Lexer.Pos = _source;
+	Lexer.End = _source + _sourceLen;
 	Lexer.Line = 1;
-	Lexer.FileName = FileName;
+	Lexer.FileName = _fileName;
 	Lexer.Mode = LexModeNormal;
 	Lexer.EmitExtraNewlines = 0;
 	Lexer.CharacterPos = 1;
-	Lexer.SourceText = Source;
-	return LexTokenise(&Lexer, TokenLen);
+	Lexer.SourceText = _source;
+	return LexTokenise(&Lexer, _tokenLen);
 }
 
 /* prepare to parse a pre-tokenised buffer */
-void LexInitParser(struct ParseState *Parser, const char *SourceText, void *TokenSource, const char *FileName, int RunIt){
-	Parser->Pos = TokenSource;
-	Parser->Line = 1;
-	Parser->FileName = FileName;
-	Parser->Mode = RunIt ? RunModeRun : RunModeSkip;
-	Parser->SearchLabel = 0;
-	Parser->HashIfLevel = 0;
-	Parser->HashIfEvaluateToLevel = 0;
-	Parser->CharacterPos = 0;
-	Parser->SourceText = SourceText;
+void LexInitParser(struct ParseState* _parser, const char* _sourceText, void* _tokenSource, const char* _fileName, int _runIt){
+	_parser->Pos = _tokenSource;
+	_parser->Line = 1;
+	_parser->FileName = _fileName;
+	_parser->Mode = _runIt ? RunModeRun : RunModeSkip;
+	_parser->SearchLabel = 0;
+	_parser->HashIfLevel = 0;
+	_parser->HashIfEvaluateToLevel = 0;
+	_parser->CharacterPos = 0;
+	_parser->SourceText = _sourceText;
 }
 
 /* get the next token, without pre-processing */
-enum LexToken LexGetRawToken(struct ParseState *Parser, struct Value **Value, int IncPos) {
+enum LexToken LexGetRawToken(struct ParseState *_parser, struct Value **_value, int _incPos) {
 	enum LexToken Token = TokenNone;
 	int ValueSize;
 	char *Prompt = NULL;
 	do {
 		/* get the next token */
-		if (    Parser->Pos == NULL
+		if (    _parser->Pos == NULL
 		     && InteractiveHead != NULL) {
-			Parser->Pos = InteractiveHead->Tokens;
+			_parser->Pos = InteractiveHead->Tokens;
 		}
-		if (    Parser->FileName != StrEmpty
+		if (    _parser->FileName != StrEmpty
 		     || InteractiveHead != NULL) {
 			/* skip leading newlines */
-			while ((Token = (enum LexToken)*(unsigned char *)Parser->Pos) == TokenEndOfLine) {
-				Parser->Line++;
-				Parser->Pos += TOKEN_DATA_OFFSET;
+			while ((Token = (enum LexToken)*(unsigned char *)_parser->Pos) == TokenEndOfLine) {
+				_parser->Line++;
+				_parser->Pos += TOKEN_DATA_OFFSET;
 			}
 		}
-		if (    Parser->FileName == StrEmpty
+		if (    _parser->FileName == StrEmpty
 		     && (    InteractiveHead == NULL
 		          || Token == TokenEOF) ) {
 			/* we're at the end of an interactive input token list */
@@ -659,7 +658,7 @@ enum LexToken LexGetRawToken(struct ParseState *Parser, struct Value **Value, in
 			int LineBytes;
 			struct TokenLine *LineNode;
 			if (    InteractiveHead == NULL
-			     || (unsigned char *)Parser->Pos == &InteractiveTail->Tokens[InteractiveTail->NumBytes-TOKEN_DATA_OFFSET]) {
+			     || (unsigned char *)_parser->Pos == &InteractiveTail->Tokens[InteractiveTail->NumBytes-TOKEN_DATA_OFFSET]) {
 				/* get interactive input */
 				if (LexUseStatementPrompt) {
 					Prompt = INTERACTIVE_PROMPT_STATEMENT;
@@ -672,43 +671,43 @@ enum LexToken LexGetRawToken(struct ParseState *Parser, struct Value **Value, in
 				}
 				/* put the new line at the end of the linked list of interactive lines */
 				LineTokens = LexAnalyse(StrEmpty, &LineBuffer[0], strlen(LineBuffer), &LineBytes);
-				LineNode = VariableAlloc(Parser, sizeof(struct TokenLine), TRUE);
+				LineNode = VariableAlloc(_parser, sizeof(struct TokenLine), TRUE);
 				LineNode->Tokens = LineTokens;
 				LineNode->NumBytes = LineBytes;
 				if (InteractiveHead == NULL) {
 					/* start a new list */
 					InteractiveHead = LineNode;
-					Parser->Line = 1;
-					Parser->CharacterPos = 0;
+					_parser->Line = 1;
+					_parser->CharacterPos = 0;
 				} else {
 					InteractiveTail->Next = LineNode;
 				}
 				InteractiveTail = LineNode;
 				InteractiveCurrentLine = LineNode;
-				Parser->Pos = LineTokens;
+				_parser->Pos = LineTokens;
 			} else {
 				/* go to the next token line */
-				if (Parser->Pos != &InteractiveCurrentLine->Tokens[InteractiveCurrentLine->NumBytes-TOKEN_DATA_OFFSET]) {
+				if (_parser->Pos != &InteractiveCurrentLine->Tokens[InteractiveCurrentLine->NumBytes-TOKEN_DATA_OFFSET]) {
 					/* scan for the line */
-					for (InteractiveCurrentLine = InteractiveHead; Parser->Pos != &InteractiveCurrentLine->Tokens[InteractiveCurrentLine->NumBytes-TOKEN_DATA_OFFSET]; InteractiveCurrentLine = InteractiveCurrentLine->Next) {
+					for (InteractiveCurrentLine = InteractiveHead; _parser->Pos != &InteractiveCurrentLine->Tokens[InteractiveCurrentLine->NumBytes-TOKEN_DATA_OFFSET]; InteractiveCurrentLine = InteractiveCurrentLine->Next) {
 						assert(InteractiveCurrentLine->Next != NULL);
 					}
 				}
 				assert(InteractiveCurrentLine != NULL);
 				InteractiveCurrentLine = InteractiveCurrentLine->Next;
 				assert(InteractiveCurrentLine != NULL);
-				Parser->Pos = InteractiveCurrentLine->Tokens;
+				_parser->Pos = InteractiveCurrentLine->Tokens;
 			}
-			Token = (enum LexToken)*(unsigned char *)Parser->Pos;
+			Token = (enum LexToken)*(unsigned char *)_parser->Pos;
 		}
-	} while (    (    Parser->FileName == StrEmpty
+	} while (    (    _parser->FileName == StrEmpty
 	               && Token == TokenEOF)
 	          || Token == TokenEndOfLine);
-	Parser->CharacterPos = *((unsigned char *)Parser->Pos + 1);
+	_parser->CharacterPos = *((unsigned char *)_parser->Pos + 1);
 	ValueSize = LexTokenSize(Token);
 	if (ValueSize > 0) {
 		/* this token requires a value - unpack it */
-		if (Value != NULL) {
+		if (_value != NULL) {
 			switch (Token) {
 				case TokenStringConstant:
 					LexValue.Typ = CharPtrType;
@@ -728,212 +727,212 @@ enum LexToken LexGetRawToken(struct ParseState *Parser, struct Value **Value, in
 				default:
 					break;
 			}
-			memcpy((void *)LexValue.Val, (void *)((char *)Parser->Pos + TOKEN_DATA_OFFSET), ValueSize);
+			memcpy((void *)LexValue.Val, (void *)((char *)_parser->Pos + TOKEN_DATA_OFFSET), ValueSize);
 			LexValue.ValOnHeap = FALSE;
 			LexValue.ValOnStack = FALSE;
 			LexValue.IsLValue = FALSE;
 			LexValue.LValueFrom = NULL;
-			*Value = &LexValue;
+			*_value = &LexValue;
 		}
-		if (IncPos) {
-			Parser->Pos += ValueSize + TOKEN_DATA_OFFSET;
+		if (_incPos) {
+			_parser->Pos += ValueSize + TOKEN_DATA_OFFSET;
 		}
 	} else {
-		if (IncPos && Token != TokenEOF) {
-			Parser->Pos += TOKEN_DATA_OFFSET;
+		if (_incPos && Token != TokenEOF) {
+			_parser->Pos += TOKEN_DATA_OFFSET;
 		}
 	}
 #ifdef DEBUG_LEXER
-	printf("Got token=%02x inc=%d pos=%d\n", Token, IncPos, Parser->CharacterPos);
+	printf("Got token=%02x inc=%d pos=%d\n", Token, _incPos, _parser->CharacterPos);
 #endif
 	assert(Token >= TokenNone && Token <= TokenEndOfFunction);
 	return Token;
 }
 
 /* correct the token position depending if we already incremented the position */
-void LexHashIncPos(struct ParseState *Parser, int IncPos) {
-	if (!IncPos) {
-		LexGetRawToken(Parser, NULL, TRUE);
+void LexHashIncPos(struct ParseState *_parser, int _incPos) {
+	if (!_incPos) {
+		LexGetRawToken(_parser, NULL, TRUE);
 	}
 }
 
 /* handle a #ifdef directive */
-void LexHashIfdef(struct ParseState *Parser, int IfNot) {
+void LexHashIfdef(struct ParseState *_parser, int _ifNot) {
 	/* get symbol to check */
 	struct Value *IdentValue;
 	struct Value *SavedValue;
 	int IsDefined;
-	enum LexToken Token = LexGetRawToken(Parser, &IdentValue, TRUE);
+	enum LexToken Token = LexGetRawToken(_parser, &IdentValue, TRUE);
 	if (Token != TokenIdentifier) {
-		ProgramFail(Parser, "identifier expected");
+		ProgramFail(_parser, "identifier expected");
 	}
 	/* is the identifier defined? */
 	IsDefined = TableGet(&GlobalTable, IdentValue->Val->Identifier, &SavedValue, NULL, NULL, NULL);
-	if (    Parser->HashIfEvaluateToLevel == Parser->HashIfLevel
+	if (    _parser->HashIfEvaluateToLevel == _parser->HashIfLevel
 	     && (   (    IsDefined
-	              && !IfNot)
+	              && !_ifNot)
 	         || (    !IsDefined
-	               && IfNot) ) ) {
+	               && _ifNot) ) ) {
 		/* #if is active, evaluate to this new level */
-		Parser->HashIfEvaluateToLevel++;
+		_parser->HashIfEvaluateToLevel++;
 	}
-	Parser->HashIfLevel++;
+	_parser->HashIfLevel++;
 }
 
 /* handle a #if directive */
-void LexHashIf(struct ParseState *Parser) {
+void LexHashIf(struct ParseState *_parser) {
 	/* get symbol to check */
 	struct Value *IdentValue;
 	struct Value *SavedValue;
 	struct ParseState MacroParser;
-	enum LexToken Token = LexGetRawToken(Parser, &IdentValue, TRUE);
+	enum LexToken Token = LexGetRawToken(_parser, &IdentValue, TRUE);
 	if (Token == TokenIdentifier) {
 		/* look up a value from a macro definition */
 		if (!TableGet(&GlobalTable, IdentValue->Val->Identifier, &SavedValue, NULL, NULL, NULL)) {
-			ProgramFail(Parser, "'%s' is undefined", IdentValue->Val->Identifier);
+			ProgramFail(_parser, "'%s' is undefined", IdentValue->Val->Identifier);
 		}
 		if (SavedValue->Typ->Base != TypeMacro) {
-			ProgramFail(Parser, "value expected");
+			ProgramFail(_parser, "value expected");
 		}
 		ParserCopy(&MacroParser, &SavedValue->Val->MacroDef.Body);
 		Token = LexGetRawToken(&MacroParser, &IdentValue, TRUE);
 	}
 	if (Token != TokenCharacterConstant) {
-		ProgramFail(Parser, "value expected");
+		ProgramFail(_parser, "value expected");
 	}
 	/* is the identifier defined? */
-	if (Parser->HashIfEvaluateToLevel == Parser->HashIfLevel && IdentValue->Val->Character) {
+	if (_parser->HashIfEvaluateToLevel == _parser->HashIfLevel && IdentValue->Val->Character) {
 		/* #if is active, evaluate to this new level */
-		Parser->HashIfEvaluateToLevel++;
+		_parser->HashIfEvaluateToLevel++;
 	}
-	Parser->HashIfLevel++;
+	_parser->HashIfLevel++;
 }
 
 /* handle a #else directive */
-void LexHashElse(struct ParseState *Parser) {
-	if (Parser->HashIfEvaluateToLevel == Parser->HashIfLevel - 1) {
-		Parser->HashIfEvaluateToLevel++;	 /* #if was not active, make this next section active */
-	} else if (Parser->HashIfEvaluateToLevel == Parser->HashIfLevel) {
+void LexHashElse(struct ParseState *_parser) {
+	if (_parser->HashIfEvaluateToLevel == _parser->HashIfLevel - 1) {
+		_parser->HashIfEvaluateToLevel++;	 /* #if was not active, make this next section active */
+	} else if (_parser->HashIfEvaluateToLevel == _parser->HashIfLevel) {
 		/* #if was active, now go inactive */
-		if (Parser->HashIfLevel == 0) {
-			ProgramFail(Parser, "#else without #if");
+		if (_parser->HashIfLevel == 0) {
+			ProgramFail(_parser, "#else without #if");
 		}
-		Parser->HashIfEvaluateToLevel--;
+		_parser->HashIfEvaluateToLevel--;
 	}
 }
 
 /* handle a #endif directive */
-void LexHashEndif(struct ParseState *Parser) {
-	if (Parser->HashIfLevel == 0) {
-		ProgramFail(Parser, "#endif without #if");
+void LexHashEndif(struct ParseState *_parser) {
+	if (_parser->HashIfLevel == 0) {
+		ProgramFail(_parser, "#endif without #if");
 	}
-	Parser->HashIfLevel--;
-	if (Parser->HashIfEvaluateToLevel > Parser->HashIfLevel) {
-		Parser->HashIfEvaluateToLevel = Parser->HashIfLevel;
+	_parser->HashIfLevel--;
+	if (_parser->HashIfEvaluateToLevel > _parser->HashIfLevel) {
+		_parser->HashIfEvaluateToLevel = _parser->HashIfLevel;
 	}
 }
 
 /* get the next token given a parser state, pre-processing as we go */
-enum LexToken LexGetToken(struct ParseState *Parser, struct Value **Value, int IncPos) {
+enum LexToken LexGetToken(struct ParseState *_parser, struct Value **_value, int _incPos) {
 	enum LexToken Token;
 	int TryNextToken;
 	/* implements the pre-processor #if commands */
 	do {
 		int WasPreProcToken = TRUE;
-		Token = LexGetRawToken(Parser, Value, IncPos);
+		Token = LexGetRawToken(_parser, _value, _incPos);
 		switch (Token) {
 			case TokenHashIfdef:
-				LexHashIncPos(Parser, IncPos);
-				LexHashIfdef(Parser, FALSE);
+				LexHashIncPos(_parser, _incPos);
+				LexHashIfdef(_parser, FALSE);
 				break;
 			case TokenHashIfndef:
-				LexHashIncPos(Parser, IncPos);
-				LexHashIfdef(Parser, TRUE);
+				LexHashIncPos(_parser, _incPos);
+				LexHashIfdef(_parser, TRUE);
 				break;
 			case TokenHashIf:
-				LexHashIncPos(Parser, IncPos);
-				LexHashIf(Parser);
+				LexHashIncPos(_parser, _incPos);
+				LexHashIf(_parser);
 				break;
 			case TokenHashElse:
-				LexHashIncPos(Parser, IncPos);
-				LexHashElse(Parser);
+				LexHashIncPos(_parser, _incPos);
+				LexHashElse(_parser);
 				break;
 			case TokenHashEndif:
-				LexHashIncPos(Parser, IncPos);
-				LexHashEndif(Parser);
+				LexHashIncPos(_parser, _incPos);
+				LexHashEndif(_parser);
 				break;
 			default:
 				WasPreProcToken = FALSE;
 				break;
 		}
 		/* if we're going to reject this token, increment the token pointer to the next one */
-		TryNextToken = (Parser->HashIfEvaluateToLevel < Parser->HashIfLevel && Token != TokenEOF) || WasPreProcToken;
-		if (!IncPos && TryNextToken) {
-			LexGetRawToken(Parser, NULL, TRUE);
+		TryNextToken = (_parser->HashIfEvaluateToLevel < _parser->HashIfLevel && Token != TokenEOF) || WasPreProcToken;
+		if (!_incPos && TryNextToken) {
+			LexGetRawToken(_parser, NULL, TRUE);
 		}
 	} while (TryNextToken);
 	return Token;
 }
 
 /* take a quick peek at the next token, skipping any pre-processing */
-enum LexToken LexRawPeekToken(struct ParseState *Parser) {
-	return (enum LexToken)*(unsigned char *)Parser->Pos;
+enum LexToken LexRawPeekToken(struct ParseState *_parser) {
+	return (enum LexToken)*(unsigned char *)_parser->Pos;
 }
 
 /* find the end of the line */
-void LexToEndOfLine(struct ParseState *Parser) {
+void LexToEndOfLine(struct ParseState *_parser) {
 	while (TRUE) {
-		enum LexToken Token = (enum LexToken)*(unsigned char *)Parser->Pos;
+		enum LexToken Token = (enum LexToken)*(unsigned char *)_parser->Pos;
 		if (    Token == TokenEndOfLine
 		     || Token == TokenEOF) {
 			return;
 		} else {
-			LexGetRawToken(Parser, NULL, TRUE);
+			LexGetRawToken(_parser, NULL, TRUE);
 		}
 	}
 }
 
 /* copy the tokens from StartParser to EndParser into new memory, removing TokenEOFs and terminate with a TokenEndOfFunction */
-void *LexCopyTokens(struct ParseState *StartParser, struct ParseState *EndParser) {
+void *LexCopyTokens(struct ParseState* _startParser, struct ParseState* _endParser) {
 	int MemSize = 0;
 	int CopySize;
-	unsigned char *Pos = (unsigned char *)StartParser->Pos;
+	unsigned char *Pos = (unsigned char *)_startParser->Pos;
 	unsigned char *NewTokens;
 	unsigned char *NewTokenPos;
 	struct TokenLine *ILine;
 	if (InteractiveHead == NULL) {
 		/* non-interactive mode - copy the tokens */
-		MemSize = EndParser->Pos - StartParser->Pos;
-		NewTokens = VariableAlloc(StartParser, MemSize + TOKEN_DATA_OFFSET, TRUE);
-		memcpy(NewTokens, (void *)StartParser->Pos, MemSize);
+		MemSize = _endParser->Pos - _startParser->Pos;
+		NewTokens = VariableAlloc(_startParser, MemSize + TOKEN_DATA_OFFSET, TRUE);
+		memcpy(NewTokens, (void *)_startParser->Pos, MemSize);
 	} else {
 		/* we're in interactive mode - add up line by line */
 		for (InteractiveCurrentLine = InteractiveHead; InteractiveCurrentLine != NULL && (Pos < &InteractiveCurrentLine->Tokens[0] || Pos >= &InteractiveCurrentLine->Tokens[InteractiveCurrentLine->NumBytes]); InteractiveCurrentLine = InteractiveCurrentLine->Next)
 		{} /* find the line we just counted */
 		
-		if (EndParser->Pos >= StartParser->Pos && EndParser->Pos < &InteractiveCurrentLine->Tokens[InteractiveCurrentLine->NumBytes]) {
+		if (_endParser->Pos >= _startParser->Pos && _endParser->Pos < &InteractiveCurrentLine->Tokens[InteractiveCurrentLine->NumBytes]) {
 			/* all on a single line */
-			MemSize = EndParser->Pos - StartParser->Pos;
-			NewTokens = VariableAlloc(StartParser, MemSize + TOKEN_DATA_OFFSET, TRUE);
-			memcpy(NewTokens, (void *)StartParser->Pos, MemSize);
+			MemSize = _endParser->Pos - _startParser->Pos;
+			NewTokens = VariableAlloc(_startParser, MemSize + TOKEN_DATA_OFFSET, TRUE);
+			memcpy(NewTokens, (void *)_startParser->Pos, MemSize);
 		} else {
 			/* it's spread across multiple lines */
 			MemSize = &InteractiveCurrentLine->Tokens[InteractiveCurrentLine->NumBytes-TOKEN_DATA_OFFSET] - Pos;
-			for (ILine = InteractiveCurrentLine->Next; ILine != NULL && (EndParser->Pos < &ILine->Tokens[0] || EndParser->Pos >= &ILine->Tokens[ILine->NumBytes]); ILine = ILine->Next) {
+			for (ILine = InteractiveCurrentLine->Next; ILine != NULL && (_endParser->Pos < &ILine->Tokens[0] || _endParser->Pos >= &ILine->Tokens[ILine->NumBytes]); ILine = ILine->Next) {
 				MemSize += ILine->NumBytes - TOKEN_DATA_OFFSET;
 			}
 			assert(ILine != NULL);
-			MemSize += EndParser->Pos - &ILine->Tokens[0];
-			NewTokens = VariableAlloc(StartParser, MemSize + TOKEN_DATA_OFFSET, TRUE);
+			MemSize += _endParser->Pos - &ILine->Tokens[0];
+			NewTokens = VariableAlloc(_startParser, MemSize + TOKEN_DATA_OFFSET, TRUE);
 			CopySize = &InteractiveCurrentLine->Tokens[InteractiveCurrentLine->NumBytes-TOKEN_DATA_OFFSET] - Pos;
 			memcpy(NewTokens, Pos, CopySize);
 			NewTokenPos = NewTokens + CopySize;
-			for (ILine = InteractiveCurrentLine->Next; ILine != NULL && (EndParser->Pos < &ILine->Tokens[0] || EndParser->Pos >= &ILine->Tokens[ILine->NumBytes]); ILine = ILine->Next) {
+			for (ILine = InteractiveCurrentLine->Next; ILine != NULL && (_endParser->Pos < &ILine->Tokens[0] || _endParser->Pos >= &ILine->Tokens[ILine->NumBytes]); ILine = ILine->Next) {
 				memcpy(NewTokenPos, &ILine->Tokens[0], ILine->NumBytes - TOKEN_DATA_OFFSET);
 				NewTokenPos += ILine->NumBytes-TOKEN_DATA_OFFSET;
 			}
 			assert(ILine != NULL);
-			memcpy(NewTokenPos, &ILine->Tokens[0], EndParser->Pos - &ILine->Tokens[0]);
+			memcpy(NewTokenPos, &ILine->Tokens[0], _endParser->Pos - &ILine->Tokens[0]);
 		}
 	}
 	NewTokens[MemSize] = (unsigned char)TokenEndOfFunction;
@@ -941,22 +940,22 @@ void *LexCopyTokens(struct ParseState *StartParser, struct ParseState *EndParser
 }
 
 /* indicate that we've completed up to this point in the interactive input and free expired tokens */
-void LexInteractiveClear(struct ParseState *Parser) {
+void LexInteractiveClear(struct ParseState *_parser) {
 	while (InteractiveHead != NULL) {
 		struct TokenLine *NextLine = InteractiveHead->Next;
 		HeapFreeMem(InteractiveHead->Tokens);
 		HeapFreeMem(InteractiveHead);
 		InteractiveHead = NextLine;
 	}
-	if (Parser != NULL) {
-		Parser->Pos = NULL;
+	if (_parser != NULL) {
+		_parser->Pos = NULL;
 	}
 	InteractiveTail = NULL;
 }
 
 /* indicate that we've completed up to this point in the interactive input and free expired tokens */
-void LexInteractiveCompleted(struct ParseState *Parser) {
-	while (InteractiveHead != NULL && !(Parser->Pos >= &InteractiveHead->Tokens[0] && Parser->Pos < &InteractiveHead->Tokens[InteractiveHead->NumBytes])) {
+void LexInteractiveCompleted(struct ParseState *_parser) {
+	while (InteractiveHead != NULL && !(_parser->Pos >= &InteractiveHead->Tokens[0] && _parser->Pos < &InteractiveHead->Tokens[InteractiveHead->NumBytes])) {
 		/* this token line is no longer needed - free it */
 		struct TokenLine *NextLine = InteractiveHead->Next;
 		HeapFreeMem(InteractiveHead->Tokens);
@@ -964,7 +963,7 @@ void LexInteractiveCompleted(struct ParseState *Parser) {
 		InteractiveHead = NextLine;
 		if (InteractiveHead == NULL) {
 			// we've emptied the list
-			Parser->Pos = NULL;
+			_parser->Pos = NULL;
 			InteractiveTail = NULL;
 		}
 	}
diff --git a/eci/lex.h b/eci/lex.h
new file mode 100644
index 0000000..f6d2caa
--- /dev/null
+++ b/eci/lex.h
@@ -0,0 +1,25 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2014, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE-2 (see license file)
+ */
+
+#ifndef __ECI_LEX_H__
+#define __ECI_LEX_H__
+
+
+void LexInit();
+void LexCleanup();
+void* LexAnalyse(const char* _fileName, const char *_source, int _sourceLen, int *_tokenLen);
+void LexInitParser(struct ParseState* _parser, const char *_sourceText, void* _tokenSource, const char* _fileName, int _runIt);
+enum LexToken LexGetToken(struct ParseState* _parser, struct Value **_value, int _incPos);
+enum LexToken LexRawPeekToken(struct ParseState* _parser);
+void LexToEndOfLine(struct ParseState* _parser);
+void* LexCopyTokens(struct ParseState* _startParser, struct ParseState* _endParser);
+void LexInteractiveClear(struct ParseState* _parser);
+void LexInteractiveCompleted(struct ParseState* _parser);
+void LexInteractiveStatementPrompt();
+
+#endif
diff --git a/eci/parse.h b/eci/parse.h
new file mode 100644
index 0000000..21a7bed
--- /dev/null
+++ b/eci/parse.h
@@ -0,0 +1,22 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2014, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE-2 (see license file)
+ */
+
+#ifndef __ECI_PARSE_H__
+#define __ECI_PARSE_H__
+
+
+/* the following are defined in picoc.h:
+ * void PicocParse(const char *FileName, const char *Source, int SourceLen, int RunIt, int CleanupNow, int CleanupSource);
+ * void PicocParseInteractive(); */
+enum ParseResult ParseStatement(struct ParseState *_parser, int _checkTrailingSemicolon);
+struct Value *ParseFunctionDefinition(struct ParseState *_parser, struct ValueType *_returnType, char *_identifier);
+void ParseCleanup();
+void ParserCopyPos(struct ParseState *_to, struct ParseState *_from);
+void ParserCopy(struct ParseState *_to, struct ParseState *_from);
+
+#endif
diff --git a/eci/picoc.h b/eci/picoc.h
index 1ced5f1..795ac74 100644
--- a/eci/picoc.h
+++ b/eci/picoc.h
@@ -28,14 +28,14 @@ extern jmp_buf PicocExitBuf;
 #define PicocPlatformSetExitPoint() setjmp(PicocExitBuf)
 
 /* parse.c */
-void PicocParse(const char *FileName, const char *Source, int SourceLen, int RunIt, int CleanupNow, int CleanupSource);
+void PicocParse(const char *_fileName, const char *_source, int _sourceLen, int _runIt, int _cleanupNow, int _cleanupSource);
 void PicocParseInteractive();
 
 /* platform.c */
-void PicocCallMain(int argc, char **argv);
-void PicocInitialise(int StackSize);
+void PicocCallMain(int _argc, char **_argv);
+void PicocInitialise(int _stackSize);
 void PicocCleanup();
-void PicocPlatformScanFile(const char *FileName);
+void PicocPlatformScanFile(const char *_fileName);
 
 extern int PicocExitValue;
 
diff --git a/eci/platform.c b/eci/platform.c
index cff006d..403a1f9 100644
--- a/eci/platform.c
+++ b/eci/platform.c
@@ -119,16 +119,16 @@ void PrintSourceTextErrorLine(const char *FileName, const char *SourceText, int
 }
 
 /* display the source line and line number to identify an error */
-void PlatformErrorPrefix(struct ParseState *Parser) {
-	if (Parser != NULL) {
-		PrintSourceTextErrorLine(Parser->FileName, Parser->SourceText, Parser->Line, Parser->CharacterPos);
+void PlatformErrorPrefix(struct ParseState *_parser) {
+	if (_parser != NULL) {
+		PrintSourceTextErrorLine(_parser->FileName, _parser->SourceText, _parser->Line, _parser->CharacterPos);
 	}
 }
 
 /* exit with a message */
-void ProgramFail(struct ParseState *Parser, const char *Message, ...) {
+void ProgramFail(struct ParseState *_parser, const char *Message, ...) {
 	va_list Args;
-	PlatformErrorPrefix(Parser);
+	PlatformErrorPrefix(_parser);
 	va_start(Args, Message);
 	PlatformVPrintf(Message, Args);
 	va_end(Args);
@@ -137,8 +137,8 @@ void ProgramFail(struct ParseState *Parser, const char *Message, ...) {
 }
 
 /* like ProgramFail() but gives descriptive error messages for assignment */
-void AssignFail(struct ParseState *Parser, const char *Format, struct ValueType *Type1, struct ValueType *Type2, int Num1, int Num2, const char *FuncName, int ParamNo) {
-	PlatformErrorPrefix(Parser);
+void AssignFail(struct ParseState *_parser, const char *Format, struct ValueType *Type1, struct ValueType *Type2, int Num1, int Num2, const char *FuncName, int ParamNo) {
+	PlatformErrorPrefix(_parser);
 	PlatformPrintf("can't %s ", (FuncName == NULL) ? "assign" : "set");   
 	if (Type1 != NULL) {
 		PlatformPrintf(Format, Type1, Type2);
diff --git a/eci/table.h b/eci/table.h
new file mode 100644
index 0000000..a00e11d
--- /dev/null
+++ b/eci/table.h
@@ -0,0 +1,23 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2014, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE-2 (see license file)
+ */
+
+#ifndef __ECI_TABLE_H__
+#define __ECI_TABLE_H__
+
+
+void TableInit();
+char *TableStrRegister(const char *_str);
+char *TableStrRegister2(const char *_str, int Len);
+void TableInitTable(struct Table *_table, struct TableEntry **_hashTable, int _size, int _onHeap);
+int TableSet(struct Table *_tbl, char *_key, struct Value *_val, const char *_declFileName, int _declLine, int _declColumn);
+int TableGet(struct Table *_tbl, const char *_key, struct Value **_val, const char **_declFileName, int *_declLine, int *_declColumn);
+struct Value *TableDelete(struct Table *_tbl, const char *_key);
+char *TableSetIdentifier(struct Table *_tbl, const char *_ident, int _identLen);
+void TableStrFree();
+
+#endif
diff --git a/eci/type.c b/eci/type.c
index 0ea61d9..5144343 100644
--- a/eci/type.c
+++ b/eci/type.c
@@ -33,8 +33,8 @@ static int PointerAlignBytes;
 static int IntAlignBytes;
 
 /* add a new type to the set of types we know about */
-struct ValueType *TypeAdd(struct ParseState *Parser, struct ValueType *ParentType, enum BaseType Base, int ArraySize, const char *Identifier, int Sizeof, int AlignBytes) {
-	struct ValueType *NewType = VariableAlloc(Parser, sizeof(struct ValueType), TRUE);
+struct ValueType *TypeAdd(struct ParseState *_parser, struct ValueType *ParentType, enum BaseType Base, int ArraySize, const char *Identifier, int Sizeof, int AlignBytes) {
+	struct ValueType *NewType = VariableAlloc(_parser, sizeof(struct ValueType), TRUE);
 	NewType->Base = Base;
 	NewType->ArraySize = ArraySize;
 	NewType->Sizeof = Sizeof;
@@ -51,7 +51,7 @@ struct ValueType *TypeAdd(struct ParseState *Parser, struct ValueType *ParentTyp
 
 /* given a parent type, get a matching derived type and make one if necessary.
  * Identifier should be registered with the shared string table. */
-struct ValueType *TypeGetMatching(struct ParseState *Parser, struct ValueType *ParentType, enum BaseType Base, int ArraySize, const char *Identifier, int AllowDuplicates) {
+struct ValueType *TypeGetMatching(struct ParseState *_parser, struct ValueType *ParentType, enum BaseType Base, int ArraySize, const char *Identifier, int AllowDuplicates) {
 	int Sizeof;
 	int AlignBytes;
 	struct ValueType *ThisType = ParentType->DerivedTypeList;
@@ -65,7 +65,7 @@ struct ValueType *TypeGetMatching(struct ParseState *Parser, struct ValueType *P
 		if (AllowDuplicates) {
 			return ThisType;
 		} else {
-			ProgramFail(Parser, "data type '%s' is already defined", Identifier);
+			ProgramFail(_parser, "data type '%s' is already defined", Identifier);
 		}
 	}
 	switch (Base) {
@@ -87,7 +87,7 @@ struct ValueType *TypeGetMatching(struct ParseState *Parser, struct ValueType *P
 			break;
 			/* structs and unions will get bigger when we add members to them */
 	}
-	return TypeAdd(Parser, ParentType, Base, ArraySize, Identifier, Sizeof, AlignBytes);
+	return TypeAdd(_parser, ParentType, Base, ArraySize, Identifier, Sizeof, AlignBytes);
 }
 
 /* stack space used by a value */
@@ -211,7 +211,7 @@ void TypeCleanup() {
 }
 
 /* parse a struct or union declaration */
-void TypeParseStruct(struct ParseState *Parser, struct ValueType **Typ, int IsStruct) {
+void TypeParseStruct(struct ParseState *_parser, struct ValueType **Typ, int IsStruct) {
 	struct Value *LexValue;
 	struct ValueType *MemberType;
 	char *MemberIdentifier;
@@ -219,37 +219,37 @@ void TypeParseStruct(struct ParseState *Parser, struct ValueType **Typ, int IsSt
 	struct Value *MemberValue;
 	enum LexToken Token;
 	int AlignBoundary;
-	Token = LexGetToken(Parser, &LexValue, FALSE);
+	Token = LexGetToken(_parser, &LexValue, FALSE);
 	if (Token == TokenIdentifier) {
-		LexGetToken(Parser, &LexValue, TRUE);
+		LexGetToken(_parser, &LexValue, TRUE);
 		StructIdentifier = LexValue->Val->Identifier;
-		Token = LexGetToken(Parser, NULL, FALSE);
+		Token = LexGetToken(_parser, NULL, FALSE);
 	} else {
 		static char TempNameBuf[7] = "^s0000";
 		StructIdentifier = PlatformMakeTempName(TempNameBuf);
 	}
-	*Typ = TypeGetMatching(Parser, &UberType, IsStruct ? TypeStruct : TypeUnion, 0, StructIdentifier, Token != TokenLeftBrace);
-	Token = LexGetToken(Parser, NULL, FALSE);
+	*Typ = TypeGetMatching(_parser, &UberType, IsStruct ? TypeStruct : TypeUnion, 0, StructIdentifier, Token != TokenLeftBrace);
+	Token = LexGetToken(_parser, NULL, FALSE);
 	if (Token != TokenLeftBrace) {
 		/* use the already defined structure */
 		if ((*Typ)->Members == NULL) {
-			ProgramFail(Parser, "structure '%s' isn't defined", LexValue->Val->Identifier);
+			ProgramFail(_parser, "structure '%s' isn't defined", LexValue->Val->Identifier);
 		}
 		return;
 	}
 	if (TopStackFrame != NULL) {
-		ProgramFail(Parser, "struct/union definitions can only be globals");
+		ProgramFail(_parser, "struct/union definitions can only be globals");
 	}
-	LexGetToken(Parser, NULL, TRUE);
-	(*Typ)->Members = VariableAlloc(Parser, sizeof(struct Table) + STRUCT_TABLE_SIZE * sizeof(struct TableEntry), TRUE);
+	LexGetToken(_parser, NULL, TRUE);
+	(*Typ)->Members = VariableAlloc(_parser, sizeof(struct Table) + STRUCT_TABLE_SIZE * sizeof(struct TableEntry), TRUE);
 	(*Typ)->Members->HashTable = (struct TableEntry **)((char *)(*Typ)->Members + sizeof(struct Table));
 	TableInitTable((*Typ)->Members, (struct TableEntry **)((char *)(*Typ)->Members + sizeof(struct Table)), STRUCT_TABLE_SIZE, TRUE);
 	do {
-		TypeParse(Parser, &MemberType, &MemberIdentifier, NULL);
+		TypeParse(_parser, &MemberType, &MemberIdentifier, NULL);
 		if (MemberType == NULL || MemberIdentifier == NULL) {
-			ProgramFail(Parser, "invalid type in struct");
+			ProgramFail(_parser, "invalid type in struct");
 		}
-		MemberValue = VariableAllocValueAndData(Parser, sizeof(int), FALSE, NULL, TRUE);
+		MemberValue = VariableAllocValueAndData(_parser, sizeof(int), FALSE, NULL, TRUE);
 		MemberValue->Typ = MemberType;
 		if (IsStruct) {
 			/* allocate this member's location in the struct */
@@ -271,26 +271,26 @@ void TypeParseStruct(struct ParseState *Parser, struct ValueType **Typ, int IsSt
 			(*Typ)->AlignBytes = MemberValue->Typ->AlignBytes;
 		}
 		/* define it */
-		if (!TableSet((*Typ)->Members, MemberIdentifier, MemberValue, Parser->FileName, Parser->Line, Parser->CharacterPos)) {
-			ProgramFail(Parser, "member '%s' already defined", &MemberIdentifier);
+		if (!TableSet((*Typ)->Members, MemberIdentifier, MemberValue, _parser->FileName, _parser->Line, _parser->CharacterPos)) {
+			ProgramFail(_parser, "member '%s' already defined", &MemberIdentifier);
 		}
-		if (LexGetToken(Parser, NULL, TRUE) != TokenSemicolon) {
-			ProgramFail(Parser, "semicolon expected");
+		if (LexGetToken(_parser, NULL, TRUE) != TokenSemicolon) {
+			ProgramFail(_parser, "semicolon expected");
 		}
-	} while (LexGetToken(Parser, NULL, FALSE) != TokenRightBrace);
+	} while (LexGetToken(_parser, NULL, FALSE) != TokenRightBrace);
 	/* now align the structure to the size of its largest member's alignment */
 	AlignBoundary = (*Typ)->AlignBytes;
 	if (((*Typ)->Sizeof & (AlignBoundary-1)) != 0) {
 		(*Typ)->Sizeof += AlignBoundary - ((*Typ)->Sizeof & (AlignBoundary-1));
 	}
-	LexGetToken(Parser, NULL, TRUE);
+	LexGetToken(_parser, NULL, TRUE);
 }
 
 /* create a system struct which has no user-visible members */
-struct ValueType *TypeCreateOpaqueStruct(struct ParseState *Parser, const char *StructName, int Size) {
-	struct ValueType *Typ = TypeGetMatching(Parser, &UberType, TypeStruct, 0, StructName, FALSE);
+struct ValueType *TypeCreateOpaqueStruct(struct ParseState *_parser, const char *StructName, int Size) {
+	struct ValueType *Typ = TypeGetMatching(_parser, &UberType, TypeStruct, 0, StructName, FALSE);
 	/* create the (empty) table */
-	Typ->Members = VariableAlloc(Parser, sizeof(struct Table) + STRUCT_TABLE_SIZE * sizeof(struct TableEntry), TRUE);
+	Typ->Members = VariableAlloc(_parser, sizeof(struct Table) + STRUCT_TABLE_SIZE * sizeof(struct TableEntry), TRUE);
 	Typ->Members->HashTable = (struct TableEntry **)((char *)Typ->Members + sizeof(struct Table));
 	TableInitTable(Typ->Members, (struct TableEntry **)((char *)Typ->Members + sizeof(struct Table)), STRUCT_TABLE_SIZE, TRUE);
 	Typ->Sizeof = Size;
@@ -298,60 +298,60 @@ struct ValueType *TypeCreateOpaqueStruct(struct ParseState *Parser, const char *
 }
 
 /* parse an enum declaration */
-void TypeParseEnum(struct ParseState *Parser, struct ValueType **Typ) {
+void TypeParseEnum(struct ParseState *_parser, struct ValueType **Typ) {
 	struct Value *LexValue;
 	struct Value InitValue;
 	enum LexToken Token;
 	struct ValueType *EnumType;
 	int EnumValue = 0;
 	char *EnumIdentifier;
-	Token = LexGetToken(Parser, &LexValue, FALSE);
+	Token = LexGetToken(_parser, &LexValue, FALSE);
 	if (Token == TokenIdentifier) {
-		LexGetToken(Parser, &LexValue, TRUE);
+		LexGetToken(_parser, &LexValue, TRUE);
 		EnumIdentifier = LexValue->Val->Identifier;
-		Token = LexGetToken(Parser, NULL, FALSE);
+		Token = LexGetToken(_parser, NULL, FALSE);
 	} else {
 		static char TempNameBuf[7] = "^e0000";
 		EnumIdentifier = PlatformMakeTempName(TempNameBuf);
 	}
-	EnumType = TypeGetMatching(Parser, &UberType, TypeEnum, 0, EnumIdentifier, Token != TokenLeftBrace);
+	EnumType = TypeGetMatching(_parser, &UberType, TypeEnum, 0, EnumIdentifier, Token != TokenLeftBrace);
 	*Typ = &IntType;
 	if (Token != TokenLeftBrace) {
 		/* use the already defined enum */
 		if ((*Typ)->Members == NULL) {
-			ProgramFail(Parser, "enum '%s' isn't defined", EnumIdentifier);
+			ProgramFail(_parser, "enum '%s' isn't defined", EnumIdentifier);
 		}
 		return;
 	}
 	if (TopStackFrame != NULL) {
-		ProgramFail(Parser, "enum definitions can only be globals");
+		ProgramFail(_parser, "enum definitions can only be globals");
 	}
-	LexGetToken(Parser, NULL, TRUE);
+	LexGetToken(_parser, NULL, TRUE);
 	(*Typ)->Members = &GlobalTable;
 	memset((void *)&InitValue, '\0', sizeof(struct Value));
 	InitValue.Typ = &IntType;
 	InitValue.Val = (union AnyValue *)&EnumValue;
 	do {
-		if (LexGetToken(Parser, &LexValue, TRUE) != TokenIdentifier) {
-			ProgramFail(Parser, "identifier expected");
+		if (LexGetToken(_parser, &LexValue, TRUE) != TokenIdentifier) {
+			ProgramFail(_parser, "identifier expected");
 		}
 		EnumIdentifier = LexValue->Val->Identifier;
-		if (LexGetToken(Parser, NULL, FALSE) == TokenAssign) {
-			LexGetToken(Parser, NULL, TRUE);
-			EnumValue = ExpressionParseInt(Parser);
+		if (LexGetToken(_parser, NULL, FALSE) == TokenAssign) {
+			LexGetToken(_parser, NULL, TRUE);
+			EnumValue = ExpressionParseInt(_parser);
 		}
-		VariableDefine(Parser, EnumIdentifier, &InitValue, NULL, FALSE);
+		VariableDefine(_parser, EnumIdentifier, &InitValue, NULL, FALSE);
 		
-		Token = LexGetToken(Parser, NULL, TRUE);
+		Token = LexGetToken(_parser, NULL, TRUE);
 		if (Token != TokenComma && Token != TokenRightBrace) {
-			ProgramFail(Parser, "comma expected");
+			ProgramFail(_parser, "comma expected");
 		}
 		EnumValue++;
 	} while (Token == TokenComma);
 }
 
 /* parse a type - just the basic type */
-int TypeParseFront(struct ParseState *Parser, struct ValueType **Typ, int *IsStatic) {
+int TypeParseFront(struct ParseState *_parser, struct ValueType **Typ, int *IsStatic) {
 	struct ParseState Before;
 	struct Value *LexerValue;
 	enum LexToken Token;
@@ -360,8 +360,8 @@ int TypeParseFront(struct ParseState *Parser, struct ValueType **Typ, int *IsSta
 	int StaticQualifier = FALSE;
 	*Typ = NULL;
 	/* ignore leading type qualifiers */
-	ParserCopy(&Before, Parser);
-	Token = LexGetToken(Parser, &LexerValue, TRUE);
+	ParserCopy(&Before, _parser);
+	Token = LexGetToken(_parser, &LexerValue, TRUE);
 	while (    Token == TokenStaticType
 	        || Token == TokenAutoType
 	        || Token == TokenRegisterType
@@ -369,14 +369,14 @@ int TypeParseFront(struct ParseState *Parser, struct ValueType **Typ, int *IsSta
 		if (Token == TokenStaticType) {
 			StaticQualifier = TRUE;
 		}
-		Token = LexGetToken(Parser, &LexerValue, TRUE);
+		Token = LexGetToken(_parser, &LexerValue, TRUE);
 	}
 	if (IsStatic != NULL) {
 		*IsStatic = StaticQualifier;
 	}
 	/* handle signed/unsigned with no trailing type */
 	if (Token == TokenSignedType || Token == TokenUnsignedType) {
-		enum LexToken FollowToken = LexGetToken(Parser, &LexerValue, FALSE);
+		enum LexToken FollowToken = LexGetToken(_parser, &LexerValue, FALSE);
 		Unsigned = (Token == TokenUnsignedType);
 		if (    FollowToken != TokenIntType
 		     && FollowToken != TokenLongType
@@ -389,7 +389,7 @@ int TypeParseFront(struct ParseState *Parser, struct ValueType **Typ, int *IsSta
 			}
 			return TRUE;
 		}
-		Token = LexGetToken(Parser, &LexerValue, TRUE);
+		Token = LexGetToken(_parser, &LexerValue, TRUE);
 	}
 	switch (Token) {
 		case TokenIntType:
@@ -414,54 +414,54 @@ int TypeParseFront(struct ParseState *Parser, struct ValueType **Typ, int *IsSta
 		case TokenStructType:
 		case TokenUnionType:
 			if (*Typ != NULL) {
-				ProgramFail(Parser, "bad type declaration");
+				ProgramFail(_parser, "bad type declaration");
 			}
-			TypeParseStruct(Parser, Typ, Token == TokenStructType);
+			TypeParseStruct(_parser, Typ, Token == TokenStructType);
 			break;
 		case TokenEnumType:
 			if (*Typ != NULL) {
-				ProgramFail(Parser, "bad type declaration");
+				ProgramFail(_parser, "bad type declaration");
 			}
-			TypeParseEnum(Parser, Typ);
+			TypeParseEnum(_parser, Typ);
 			break;
 		case TokenIdentifier:
 			/* we already know it's a typedef-defined type because we got here */
-			VariableGet(Parser, LexerValue->Val->Identifier, &VarValue);
+			VariableGet(_parser, LexerValue->Val->Identifier, &VarValue);
 			*Typ = VarValue->Val->Typ;
 			break;
 		default:
-			ParserCopy(Parser, &Before);
+			ParserCopy(_parser, &Before);
 			return FALSE;
 	}
 	return TRUE;
 }
 
 /* parse a type - the part at the end after the identifier. eg. array specifications etc. */
-struct ValueType *TypeParseBack(struct ParseState *Parser, struct ValueType *FromType) {
+struct ValueType *TypeParseBack(struct ParseState *_parser, struct ValueType *FromType) {
 	enum LexToken Token;
 	struct ParseState Before;
-	ParserCopy(&Before, Parser);
-	Token = LexGetToken(Parser, NULL, TRUE);
+	ParserCopy(&Before, _parser);
+	Token = LexGetToken(_parser, NULL, TRUE);
 	if (Token == TokenLeftSquareBracket) {
 		/* add another array bound */
-		enum RunMode OldMode = Parser->Mode;
+		enum RunMode OldMode = _parser->Mode;
 		int ArraySize;
-		Parser->Mode = RunModeRun;
-		ArraySize = ExpressionParseInt(Parser);
-		Parser->Mode = OldMode;
-		if (LexGetToken(Parser, NULL, TRUE) != TokenRightSquareBracket) {
-			ProgramFail(Parser, "']' expected");
+		_parser->Mode = RunModeRun;
+		ArraySize = ExpressionParseInt(_parser);
+		_parser->Mode = OldMode;
+		if (LexGetToken(_parser, NULL, TRUE) != TokenRightSquareBracket) {
+			ProgramFail(_parser, "']' expected");
 		}
-		return TypeGetMatching(Parser, TypeParseBack(Parser, FromType), TypeArray, ArraySize, StrEmpty, TRUE);
+		return TypeGetMatching(_parser, TypeParseBack(_parser, FromType), TypeArray, ArraySize, StrEmpty, TRUE);
 	} else {
 		/* the type specification has finished */
-		ParserCopy(Parser, &Before);
+		ParserCopy(_parser, &Before);
 		return FromType;
 	}
 }
 
 /* parse a type - the part which is repeated with each identifier in a declaration list */
-void TypeParseIdentPart(struct ParseState *Parser, struct ValueType *BasicTyp, struct ValueType **Typ, char **Identifier) {
+void TypeParseIdentPart(struct ParseState *_parser, struct ValueType *BasicTyp, struct ValueType **Typ, char **Identifier) {
 	struct ParseState Before;
 	enum LexToken Token;
 	struct Value *LexValue;
@@ -469,51 +469,51 @@ void TypeParseIdentPart(struct ParseState *Parser, struct ValueType *BasicTyp, s
 	*Typ = BasicTyp;
 	*Identifier = StrEmpty;
 	while (!Done) {
-		ParserCopy(&Before, Parser);
-		Token = LexGetToken(Parser, &LexValue, TRUE);
+		ParserCopy(&Before, _parser);
+		Token = LexGetToken(_parser, &LexValue, TRUE);
 		switch (Token) {
 			case TokenOpenBracket:
 				if (*Typ != NULL) {
-					ProgramFail(Parser, "bad type declaration");
+					ProgramFail(_parser, "bad type declaration");
 				}
-				TypeParse(Parser, Typ, Identifier, NULL);
-				if (LexGetToken(Parser, NULL, TRUE) != TokenCloseBracket) {
-					ProgramFail(Parser, "')' expected");
+				TypeParse(_parser, Typ, Identifier, NULL);
+				if (LexGetToken(_parser, NULL, TRUE) != TokenCloseBracket) {
+					ProgramFail(_parser, "')' expected");
 				}
 				break;
 			case TokenAsterisk:
 				if (*Typ == NULL) {
-					ProgramFail(Parser, "bad type declaration");
+					ProgramFail(_parser, "bad type declaration");
 				}
-				*Typ = TypeGetMatching(Parser, *Typ, TypePointer, 0, StrEmpty, TRUE);
+				*Typ = TypeGetMatching(_parser, *Typ, TypePointer, 0, StrEmpty, TRUE);
 				break;
 			case TokenIdentifier:
 				if (    *Typ == NULL
 				     || *Identifier != StrEmpty) {
-					ProgramFail(Parser, "bad type declaration");
+					ProgramFail(_parser, "bad type declaration");
 				}
 				*Identifier = LexValue->Val->Identifier;
 				Done = TRUE;
 				break;
 			default:
-				ParserCopy(Parser, &Before);
+				ParserCopy(_parser, &Before);
 				Done = TRUE;
 				break;
 		}
 	}
 	if (*Typ == NULL) {
-		ProgramFail(Parser, "bad type declaration");
+		ProgramFail(_parser, "bad type declaration");
 	}
 	if (*Identifier != StrEmpty) {
 		/* parse stuff after the identifier */
-		*Typ = TypeParseBack(Parser, *Typ);
+		*Typ = TypeParseBack(_parser, *Typ);
 	}
 }
 
 /* parse a type - a complete declaration including identifier */
-void TypeParse(struct ParseState *Parser, struct ValueType **Typ, char **Identifier, int *IsStatic) {
+void TypeParse(struct ParseState *_parser, struct ValueType **Typ, char **Identifier, int *IsStatic) {
 	struct ValueType *BasicType;
-	TypeParseFront(Parser, &BasicType, IsStatic);
-	TypeParseIdentPart(Parser, BasicType, Typ, Identifier);
+	TypeParseFront(_parser, &BasicType, IsStatic);
+	TypeParseIdentPart(_parser, BasicType, Typ, Identifier);
 }
 
diff --git a/eci/type.h b/eci/type.h
new file mode 100644
index 0000000..3591bbc
--- /dev/null
+++ b/eci/type.h
@@ -0,0 +1,24 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2014, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE-2 (see license file)
+ */
+
+#ifndef __ECI_TYPE_H__
+#define __ECI_TYPE_H__
+
+void TypeInit();
+void TypeCleanup();
+int TypeSize(struct ValueType *_type, int _arraySize, int _compact);
+int TypeSizeValue(struct Value *_value, int _compact);
+int TypeStackSizeValue(struct Value *_value);
+int TypeLastAccessibleOffset(struct Value *_value);
+int TypeParseFront(struct ParseState *_parser, struct ValueType **_type, int *_isStatic);
+void TypeParseIdentPart(struct ParseState *_parser, struct ValueType *_basicTyp, struct ValueType **_type, char **_identifier);
+void TypeParse(struct ParseState *_parser, struct ValueType **_type, char **_identifier, int *_isStatic);
+struct ValueType *TypeGetMatching(struct ParseState *_parser, struct ValueType *_parentType, enum BaseType _base, int _arraySize, const char *_identifier, int _allowDuplicates);
+struct ValueType *TypeCreateOpaqueStruct(struct ParseState *_parser, const char *_structName, int _size);
+
+#endif
diff --git a/eci/variable.h b/eci/variable.h
new file mode 100644
index 0000000..497d12b
--- /dev/null
+++ b/eci/variable.h
@@ -0,0 +1,35 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2014, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE-2 (see license file)
+ */
+
+#ifndef __ECI_VARIABLE_H__
+#define __ECI_VARIABLE_H__
+
+
+void VariableInit();
+void VariableCleanup();
+void VariableFree(struct Value* _value);
+void VariableTableCleanup(struct Table* _hashTable);
+void *VariableAlloc(struct ParseState* _parser, int _size, int _onHeap);
+void VariableStackPop(struct ParseState *_parser, struct Value *_value);
+struct Value *VariableAllocValueAndData(struct ParseState* _parser, int _dataSize, int _isLValue, struct Value *_lValueFrom, int _onHeap);
+struct Value *VariableAllocValueAndCopy(struct ParseState* _parser, struct Value *_fromValue, int _onHeap);
+struct Value *VariableAllocValueFromType(struct ParseState *_parser, struct ValueType *_type, int _isLValue, struct Value *_lValueFrom, int _onHeap);
+struct Value *VariableAllocValueFromExistingData(struct ParseState *_parser, struct ValueType *_type, union AnyValue *_fromValue, int _isLValue, struct Value *_lValueFrom);
+struct Value *VariableAllocValueShared(struct ParseState *_parser, struct Value *_fromValue);
+struct Value *VariableDefine(struct ParseState *_parser, char *_ident, struct Value *_initValue, struct ValueType *_type, int _makeWritable);
+struct Value *VariableDefineButIgnoreIdentical(struct ParseState *_parser, char *_ident, struct ValueType *_type, int _isStatic, int *_firstVisit);
+int VariableDefined(const char *Ident);
+void VariableGet(struct ParseState *_parser, const char *_ident, struct Value **_lVal);
+void VariableDefinePlatformVar(struct ParseState *_parser, char *_ident, struct ValueType *_type, union AnyValue *_fromValue, int _isWritable);
+void VariableStackFrameAdd(struct ParseState *_parser, const char *_funcName, int _numParams);
+void VariableStackFramePop(struct ParseState *_parser);
+struct Value *VariableStringLiteralGet(char *_ident);
+void VariableStringLiteralDefine(char *_ident, struct Value *_value);
+void *VariableDereferencePointer(struct ParseState *_parser, struct Value *_pointerValue, struct Value **_dereferenceVal, int *_dereferenceOffset, struct ValueType **_dereferenceType, int *_derefIsLValue);
+
+#endif