Add parsing "extern" declarations, reorder the tokens alphabetically.

SquiLu/squirrel/sqcompiler.cpp

@@ -19,9 +19,10 @@
 #define BASE   3
 #define LOCAL  4
 #define OUTER  5
+#define EXPR_STATEMENT  6 //we start from statement state
 
 struct SQExpState {
-  SQInteger  etype;       /* expr. type; one of EXPR, OBJECT, BASE, OUTER or LOCAL */
+  SQInteger  etype;       /* expr. type; one of EXPR, OBJECT, BASE, OUTER, LOCAL or EXPR_STATEMENT */
   SQInteger  epos;        /* expr. location on stack; -1 for OBJECT and BASE */
   bool       donot_get;   /* signal not to deref the next value */
 };
@@ -95,10 +96,14 @@ struct SQScope {
 		case TK_LOCAL_DOUBLE_T: \
 		case TK_LOCAL_LONG_DOUBLE_T
 
-#define CASE_TK_LOCAL_TYPES \
-		CASE_TK_LOCAL_CHAR_TYPES: \
+#define CASE_TK_NUMBER_TYPES \
 		CASE_TK_LOCAL_FLOAT_TYPES: \
 		CASE_TK_LOCAL_INT_TYPES: \
+		case TK_LOCAL_NUMBER_T
+
+#define CASE_TK_LOCAL_TYPES \
+		CASE_TK_LOCAL_CHAR_TYPES: \
+		CASE_TK_NUMBER_TYPES: \
 		case TK_LOCAL_BOOL_T: \
 		case TK_LOCAL_TABLE_T: \
 		case TK_LOCAL_ARRAY_T: \
@@ -132,8 +137,10 @@ public:
 		_compilererror = NULL;
         _globals = SQTable::Create(_ss(_vm),0);
         _type_names = SQTable::Create(_ss(_vm),0);
+        _extern_names = SQTable::Create(_ss(_vm),0);
         _max_nested_includes = max_nested_includes;
         _nested_includes_count = 0;
+        _is_parsing_extern = false;
 	}
 	~SQCompiler(){
         _table(_globals)->Finalize();
@@ -173,16 +180,52 @@ public:
 	    return found;
 	}
 
+	int CheckExternName(const SQObject &name, bool addIfNotExists=false){
+	    SQObjectPtr orefcount;
+	    int found = _table(_extern_names)->Get(name, orefcount);
+	    if(addIfNotExists && !found) {
+	        SQObjectPtr oname = name;
+	        _integer(orefcount) = 1; //1 means only declared, 2 declared and assigned
+	        _table(_extern_names)->NewSlot(oname, orefcount);
+	        _table(_globals)->NewSlot(oname, orefcount);
+	    }
+	    return found ? _integer(orefcount) : 0;
+	}
+	int ExternNameSetRefCount(const SQObject &name)
+	{
+	    int ref_count = CheckExternName(name);
+	    if(ref_count == 1)
+        {
+            SQObjectPtr orefcount;
+            _integer(orefcount) = ref_count = 2;
+            _table(_extern_names)->Set(name, orefcount);
+        }
+        return ref_count;
+	}
+
+	void AddGlobalName(const SQObject &name)
+	{
+        SQObjectPtr oname = name, otrue = true;
+        _table(_globals)->NewSlot(oname, otrue);
+	}
+
 	void CheckGlobalName(const SQObject &name, bool addIfNotExists=false, bool checkLocals=true){
-	    if(_table(_globals)->Exists(name)){
-            if(checkLocals) Error(_SC("global '%s' already declared"), _stringval(name));
-            else Warning(_SC("%s:%d:%d warning global '%s' already declared will be shadowed\n"),
-                        _stringval(_sourcename), _lex._currentline, _lex._currentcolumn, _stringval(name));
+	    const SQChar *found = NULL;
+	    if(CheckExternName(name)){
+            found = _SC("extern");
+	    }
+	    else if(_table(_globals)->Exists(name)){
+            found = _SC("global");
+	    }
+	    if(found) {
+            if(checkLocals) Error(_SC("%s '%s' already declared"), found, _stringval(name));
+            else Warning(_SC("%s:%d:%d warning %s '%s' already declared will be shadowed\n"),
+                        _stringval(_sourcename), _lex._currentline, _lex._currentcolumn,
+                         found, _stringval(name));
 	    }
 	    else if(checkLocals) CheckLocalNameScope(name, -1, false);
 	    if(addIfNotExists) {
-	        SQObjectPtr oname = name, otrue = true;
-	        _table(_globals)->NewSlot(oname, otrue);
+            AddGlobalName(name);
 	    }
 	}
 
@@ -496,6 +539,7 @@ public:
 	}
 	void Statement(bool closeframe = true)
 	{
+	    _es.etype = EXPR_STATEMENT;
 	    SQObject id;
 		_fs->AddLineInfos(_lex._currentline, _lineinfo);
     start_again:
@@ -515,6 +559,9 @@ public:
             }
             Lex(); //ignore it only to allow run some C/C++ code
             goto start_again;
+
+        case TK_EXTERN: ExternDeclStatement();	break;
+
 		CASE_TK_LOCAL_TYPES:
 		//case TK_CONST:
 		case TK_LOCAL:		LocalDeclStatement();	break;
@@ -704,6 +751,11 @@ public:
 		_es.etype     = EXPR;
 		_es.epos      = -1;
 		_es.donot_get = false;
+		SQObject id;
+		if((_token == TK_IDENTIFIER) && (es.etype == EXPR_STATEMENT))
+        {
+            id = _fs->CreateString(_lex._svalue);
+        }
 		LogicalOrExp();
 		switch(_token)  {
 		case _SC('='):
@@ -723,8 +775,10 @@ public:
 
 			switch(op){
 			case TK_NEWSLOT:
-				if(ds == OBJECT || ds == BASE)
+				if(ds == OBJECT || ds == BASE) {
 					EmitDerefOp(_OP_NEWSLOT);
+                    if((_es.epos == -1) && (es.etype == EXPR_STATEMENT)) AddGlobalName(id);
+				}
 				else //if _derefstate != DEREF_NO_DEREF && DEREF_FIELD so is the index of a local
 					Error(_SC("can't 'create' a local slot"));
 				break;
@@ -741,7 +795,7 @@ public:
 					break;
 				case OBJECT:
 				case BASE:
-					EmitDerefOp(_OP_SET);
+                    EmitDerefOp(_OP_SET);
 					break;
 				case OUTER:
 					{
@@ -1437,6 +1491,13 @@ function_params_decl:
 			_fs->SetIntructionParam(tpos, 1, nkeys);
 		Lex();
 	}
+	void ExternDeclStatement()
+	{
+	    _is_parsing_extern = true;
+	    Lex();
+	    LocalDeclStatement();
+	    _is_parsing_extern = false;
+	}
 	void LocalDeclStatement()
 	{
 		SQObject varname;
@@ -1456,6 +1517,11 @@ function_params_decl:
 			_fs->PushLocalVariable(varname, _scope.nested, _VAR_CLOSURE); //add function name to find it as outer var if needed
 			//-1 to compensate default parameters when relocating
 			CreateFunction(varname,false, -1);
+			if(_is_parsing_extern) {
+                Expect(_SC(';'));
+                CheckExternName(varname, true);
+                return;
+			}
 			_fs->AddInstruction(_OP_CLOSURE, _fs->PushTarget(), _fs->_functions.size() - 1, 0);
 			//rellocate any stack operation (default parameters & _OP_Closure)
 			for(int i=old_pos+1, curr_pos = _fs->GetCurrentPos(); i <= curr_pos; ++i){
@@ -1485,6 +1551,10 @@ function_params_decl:
                 goto function_params_decl;
 			}
 			else if(_token == _SC('=')) {
+                if(_is_parsing_extern)
+                {
+                    Error(_SC("can not make assignment in external declarations"));
+                }
 				Lex(); Expression();
 				SQInteger src = _fs->PopTarget();
 				SQInteger dest = _fs->PushTarget();
@@ -1493,50 +1563,61 @@ function_params_decl:
 			}
 			else if(is_const_declaration || is_reference_declaration)
                 Error(_SC("const/reference '%s' need an initializer"), _stringval(varname));
-			else{
-			    SQInteger dest = _fs->PushTarget();
-			    switch(declType){
-                    CASE_TK_LOCAL_CHAR_TYPES:
-                        _fs->AddInstruction(_OP_LOADNULLS, dest,1);
-                        declType = _VAR_STRING;
-                        break;
+			else {
+                if(!_is_parsing_extern) {
+                    SQInteger dest = _fs->PushTarget();
+                    switch(declType){
+                        CASE_TK_LOCAL_CHAR_TYPES:
+                            _fs->AddInstruction(_OP_LOADNULLS, dest,1);
+                            declType = _VAR_STRING;
+                            break;
 
-                    case TK_LOCAL_BOOL_T:
-                        //default value false
-                        _fs->AddInstruction(_OP_LOADBOOL, dest,0);
-                        declType = _VAR_BOOL;
-                        break;
+                        case TK_LOCAL_BOOL_T:
+                            //default value false
+                            _fs->AddInstruction(_OP_LOADBOOL, dest,0);
+                            declType = _VAR_BOOL;
+                            break;
 
-                    case TK_LOCAL_TABLE_T:
-                        _fs->AddInstruction(_OP_LOADNULLS, dest,1);
-                        declType = _VAR_TABLE;
-                        break;
-                    case TK_LOCAL_ARRAY_T:
-                        _fs->AddInstruction(_OP_LOADNULLS, dest,1);
-                        declType = _VAR_ARRAY;
-                        break;
+                        case TK_LOCAL_TABLE_T:
+                            _fs->AddInstruction(_OP_LOADNULLS, dest,1);
+                            declType = _VAR_TABLE;
+                            break;
+                        case TK_LOCAL_ARRAY_T:
+                            _fs->AddInstruction(_OP_LOADNULLS, dest,1);
+                            declType = _VAR_ARRAY;
+                            break;
 
-                    CASE_TK_LOCAL_INT_TYPES:
-                        //default value 0
-                        _fs->AddInstruction(_OP_LOADINT, dest,0);
-                        declType = _VAR_INTEGER;
-                        break;
-                    CASE_TK_LOCAL_FLOAT_TYPES:
-                        //default value 0.0
-                        //_OP_LOADFLOAT is only valid when SQFloat size == SQInt32 size
-                        _fs->AddInstruction(_OP_LOADINT, dest,0);
-                        declType = _VAR_FLOAT;
-                        break;
-                    //case TK_LOCAL:
-                    default:
-                        //default value null
-                        _fs->AddInstruction(_OP_LOADNULLS, dest,1);
-                        declType = _VAR_ANY;
-			    }
+                        CASE_TK_LOCAL_INT_TYPES:
+                            //default value 0
+                            _fs->AddInstruction(_OP_LOADINT, dest,0);
+                            declType = _VAR_INTEGER;
+                            break;
+                        CASE_TK_LOCAL_FLOAT_TYPES:
+                        case TK_LOCAL_NUMBER_T: //start numbers as floats
+                            //default value 0.0
+                            //_OP_LOADFLOAT is only valid when SQFloat size == SQInt32 size
+                            _fs->AddInstruction(_OP_LOADINT, dest,0);
+                            declType = _VAR_FLOAT;
+                            break;
+                        //case TK_LOCAL:
+                        default:
+                            //default value null
+                            _fs->AddInstruction(_OP_LOADNULLS, dest,1);
+                            declType = _VAR_ANY;
+                    }
+                }
+			}
+			if(_is_parsing_extern) {
+                if(CheckExternName(varname, true))
+                {
+                    Error(_SC("extern %s already declared"), varname);
+                }
+			}
+			else {
+                _fs->PopTarget();
+                _fs->PushLocalVariable(varname, _scope.nested, (is_const_declaration ? _VAR_CONST : declType)
+                              | (is_reference_declaration ? _VAR_REFERENCE : 0));
 			}
-			_fs->PopTarget();
-			_fs->PushLocalVariable(varname, _scope.nested, (is_const_declaration ? _VAR_CONST : declType)
-                          | (is_reference_declaration ? _VAR_REFERENCE : 0));
 			if(_token == _SC(',')) Lex(); else break;
 		} while(1);
 	}
@@ -2144,6 +2225,11 @@ error:
 			_fs->PopTarget();
 		}
 
+        if(_is_parsing_extern) {
+            _fs->PopChildState();
+            return;
+        }
+
 		SQFuncState *currchunk = _fs;
 		_fs = funcstate;
 		if(lambda) {
@@ -2192,6 +2278,7 @@ private:
 	bool _lineinfo;
 	bool _raiseerror;
 	bool _show_warnings;
+	bool _is_parsing_extern;
 	SQInteger _debugline;
 	SQInteger _debugop;
 	SQExpState   _es;
@@ -2202,6 +2289,7 @@ private:
 	SQObjectPtrVec _scope_consts;
 	SQObjectPtr _globals;
 	SQObjectPtr _type_names; //to allow C/C++ style instance declarations
+	SQObjectPtr _extern_names; //to allow C/C++ style extern declarations
 	SQChar error_buf[MAX_COMPILER_ERROR_LEN];
 	SQInteger _max_nested_includes, _nested_includes_count;
 };

SquiLu/squirrel/sqcompiler.h

@@ -5,107 +5,109 @@
 struct SQVM;
 
 #define SQ_KEYWORDS_LIST() \
-    ENUM_TK(IDENTIFIER)\
-    ENUM_TK(STRING_LITERAL)\
-    ENUM_TK(INTEGER)\
-    ENUM_TK(FLOAT)\
-    ENUM_TK(BASE)\
-    ENUM_TK(DELETE)\
-    ENUM_TK(EQ)\
-    ENUM_TK(EQ_IDENTITY)\
-    ENUM_TK(NE)\
-    ENUM_TK(NE_IDENTITY)\
-    ENUM_TK(LE)\
-    ENUM_TK(GE)\
-    ENUM_TK(SWITCH)\
-    ENUM_TK(ARROW)\
+    ENUM_TK(3WAYSCMP)\
     ENUM_TK(AND)\
-    ENUM_TK(OR)\
-    ENUM_TK(IF)\
-    ENUM_TK(ELSE)\
-    ENUM_TK(WHILE)\
+    ENUM_TK(ARROW)\
+    ENUM_TK(ATTR_CLOSE)\
+    ENUM_TK(ATTR_OPEN)\
+    ENUM_TK(BASE)\
+    ENUM_TK(BIT_AND_EQ)\
+    ENUM_TK(BIT_OR_EQ)\
+    ENUM_TK(BIT_SHIFT_LEFT_EQ)\
+    ENUM_TK(BIT_SHIFT_RIGHT_EQ)\
+    ENUM_TK(BIT_XOR_EQ)\
     ENUM_TK(BREAK)\
-    ENUM_TK(FOR)\
-    ENUM_TK(DO)\
-    ENUM_TK(NULL)\
-    ENUM_TK(FOREACH)\
-    ENUM_TK(IN)\
-    ENUM_TK(NEWSLOT)\
-    ENUM_TK(MODULO)\
-    ENUM_TK(LOCAL)\
-    ENUM_TK(CLONE)\
-    ENUM_TK(FUNCTION)\
-    ENUM_TK(RETURN)\
-    ENUM_TK(TYPEOF)\
-    ENUM_TK(UMINUS)\
-    ENUM_TK(PLUSEQ)\
-    ENUM_TK(MINUSEQ)\
-    ENUM_TK(CONTINUE)\
-    ENUM_TK(YIELD)\
-    ENUM_TK(TRY)\
-    ENUM_TK(CATCH)\
-    ENUM_TK(THROW)\
-    ENUM_TK(SHIFTL)\
-    ENUM_TK(SHIFTR)\
-    ENUM_TK(RESUME)\
-    ENUM_TK(DOUBLE_COLON)\
     ENUM_TK(CASE)\
-    ENUM_TK(DEFAULT)\
-    ENUM_TK(THIS)\
-    ENUM_TK(PLUSPLUS)\
-    ENUM_TK(MINUSMINUS)\
-    ENUM_TK(3WAYSCMP)\
-    ENUM_TK(USHIFTR)\
+    ENUM_TK(CATCH)\
     ENUM_TK(CLASS)\
-    ENUM_TK(EXTENDS)\
+    ENUM_TK(CLONE)\
+    ENUM_TK(CONST)\
     ENUM_TK(CONSTRUCTOR)\
+    ENUM_TK(CONTINUE)\
+    ENUM_TK(DEFAULT)\
+    ENUM_TK(DELETE)\
     ENUM_TK(DESTRUCTOR)\
-    ENUM_TK(INSTANCEOF)\
-    ENUM_TK(VARPARAMS)\
-    ENUM_TK(TRUE)\
-    ENUM_TK(FALSE)\
-    ENUM_TK(MULEQ)\
     ENUM_TK(DIVEQ)\
-    ENUM_TK(MODEQ)\
-    ENUM_TK(ATTR_OPEN)\
-    ENUM_TK(ATTR_CLOSE)\
-    ENUM_TK(STATIC)\
+    ENUM_TK(DO)\
+    ENUM_TK(DOUBLE_COLON)\
+    ENUM_TK(ELSE)\
     ENUM_TK(ENUM)\
-    ENUM_TK(CONST)\
-    ENUM_TK(__LINE__)\
-    ENUM_TK(__FUNCTION__)\
+    ENUM_TK(EQ)\
+    ENUM_TK(EQ_IDENTITY)\
+    ENUM_TK(EXTENDS)\
+    ENUM_TK(EXTERN) \
+    ENUM_TK(FALSE)\
     ENUM_TK(__FILE__)\
-    ENUM_TK(PRIVATE)\
-    ENUM_TK(PUBLIC)\
+    ENUM_TK(FLOAT)\
+    ENUM_TK(FOR)\
+    ENUM_TK(FOREACH)\
+    ENUM_TK(__FUNCTION__)\
+    ENUM_TK(FUNCTION)\
+    ENUM_TK(GE)\
+    ENUM_TK(IDENTIFIER)\
+    ENUM_TK(IF)\
     ENUM_TK(IGNORE)\
-    ENUM_TK(LOCAL_STRING_T)\
-    ENUM_TK(LOCAL_CHAR_T)\
-    ENUM_TK(LOCAL_WCHAR_T)\
-    ENUM_TK(LOCAL_BOOL_T)\
-    ENUM_TK(LOCAL_TABLE_T)\
+    ENUM_TK(IN)\
+    ENUM_TK(INSTANCEOF)\
+    ENUM_TK(INTEGER)\
+    ENUM_TK(LE)\
+    ENUM_TK(__LINE__)\
+    ENUM_TK(LOCAL)\
     ENUM_TK(LOCAL_ARRAY_T)\
-    ENUM_TK(LOCAL_INT8_T)\
+    ENUM_TK(LOCAL_BOOL_T)\
+    ENUM_TK(LOCAL_CHAR_T)\
+    ENUM_TK(LOCAL_DOUBLE_T)\
+    ENUM_TK(LOCAL_FLOAT_T)\
     ENUM_TK(LOCAL_INT16_T)\
     ENUM_TK(LOCAL_INT32_T)\
     ENUM_TK(LOCAL_INT64_T)\
+    ENUM_TK(LOCAL_INT8_T)\
     ENUM_TK(LOCAL_INT_T)\
-    ENUM_TK(LOCAL_UINT8_T)\
+    ENUM_TK(LOCAL_LONG_DOUBLE_T)\
+    ENUM_TK(LOCAL_NUMBER_T)\
+    ENUM_TK(LOCAL_STRING_T)\
+    ENUM_TK(LOCAL_TABLE_T)\
     ENUM_TK(LOCAL_UINT16_T)\
     ENUM_TK(LOCAL_UINT32_T)\
     ENUM_TK(LOCAL_UINT64_T)\
+    ENUM_TK(LOCAL_UINT8_T)\
     ENUM_TK(LOCAL_UINT_T)\
-    ENUM_TK(LOCAL_FLOAT_T)\
-    ENUM_TK(LOCAL_DOUBLE_T)\
-    ENUM_TK(LOCAL_LONG_DOUBLE_T)\
-    ENUM_TK(LOCAL_VOID_T)\
     ENUM_TK(LOCAL_VOIDPTR_T)\
-    ENUM_TK(BIT_AND_EQ)\
-    ENUM_TK(BIT_OR_EQ)\
-    ENUM_TK(BIT_XOR_EQ)\
-    ENUM_TK(BIT_SHIFT_LEFT_EQ)\
-    ENUM_TK(BIT_SHIFT_RIGHT_EQ)\
+    ENUM_TK(LOCAL_VOID_T)\
+    ENUM_TK(LOCAL_WCHAR_T)\
+    ENUM_TK(MINUSEQ)\
+    ENUM_TK(MINUSMINUS)\
+    ENUM_TK(MODEQ)\
+    ENUM_TK(MODULO)\
+    ENUM_TK(MULEQ)\
+    ENUM_TK(NE)\
+    ENUM_TK(NE_IDENTITY)\
+    ENUM_TK(NEWSLOT)\
+    ENUM_TK(NULL)\
+    ENUM_TK(OR)\
+    ENUM_TK(PLUSEQ)\
+    ENUM_TK(PLUSPLUS)\
     ENUM_TK(PRAGMA)\
-    ENUM_TK(STRUCT)
+    ENUM_TK(PRIVATE)\
+    ENUM_TK(PUBLIC)\
+    ENUM_TK(RESUME)\
+    ENUM_TK(RETURN)\
+    ENUM_TK(SHIFTL)\
+    ENUM_TK(SHIFTR)\
+    ENUM_TK(STATIC)\
+    ENUM_TK(STRING_LITERAL)\
+    ENUM_TK(STRUCT) \
+    ENUM_TK(SWITCH)\
+    ENUM_TK(THIS)\
+    ENUM_TK(THROW)\
+    ENUM_TK(TRUE)\
+    ENUM_TK(TRY)\
+    ENUM_TK(TYPEOF)\
+    ENUM_TK(UMINUS)\
+    ENUM_TK(USHIFTR)\
+    ENUM_TK(VARPARAMS)\
+    ENUM_TK(WHILE)\
+    ENUM_TK(YIELD)
     //ENUM_TK(VARGC)
     //ENUM_TK(VARGV)
 

SquiLu/squirrel/sqlexer.cpp

@@ -51,80 +51,76 @@ SQInteger SQLexer::ResetReader(SQLEXREADFUNC rg, SQUserPointer up, SQInteger lin
 SQTable * SQLexer::GetKeywords()
 {
 	SQTable *tbl = SQTable::Create(_sharedstate, (TK_LAST_ENUM_TOKEN - TK_FIRST_ENUM_TOKEN - 1) /*26*/);
-	ADD_KEYWORD(while, TK_WHILE);
-	ADD_KEYWORD(do, TK_DO);
-	ADD_KEYWORD(if, TK_IF);
-	ADD_KEYWORD(else, TK_ELSE);
+	ADD_KEYWORD(array_t, TK_LOCAL_ARRAY_T);
+	ADD_KEYWORD(auto, TK_LOCAL);
+	ADD_KEYWORD(base, TK_BASE);
+	ADD_KEYWORD(bool_t, TK_LOCAL_BOOL_T);
 	ADD_KEYWORD(break, TK_BREAK);
+	ADD_KEYWORD(case, TK_CASE);
+	ADD_KEYWORD(catch, TK_CATCH);
+	ADD_KEYWORD(char_t, TK_LOCAL_CHAR_T);
+	ADD_KEYWORD(class,TK_CLASS);
+	ADD_KEYWORD(clone, TK_CLONE);
+	ADD_KEYWORD(constructor,TK_CONSTRUCTOR);
+	ADD_KEYWORD(const,TK_CONST);
 	ADD_KEYWORD(continue, TK_CONTINUE);
-	ADD_KEYWORD(return, TK_RETURN);
-	ADD_KEYWORD(null, TK_NULL);
-	ADD_KEYWORD(NULL, TK_NULL);
+	ADD_KEYWORD(default, TK_DEFAULT);
+	ADD_KEYWORD(delete, TK_DELETE);
+	ADD_KEYWORD(destructor,TK_DESTRUCTOR);
+	ADD_KEYWORD(do, TK_DO);
+	ADD_KEYWORD(double_t, TK_LOCAL_DOUBLE_T);
+	ADD_KEYWORD(else, TK_ELSE);
+	ADD_KEYWORD(enum,TK_ENUM);
+	ADD_KEYWORD(extends,TK_EXTENDS);
+	ADD_KEYWORD(extern,TK_EXTERN);
+	ADD_KEYWORD(false,TK_FALSE);
+	ADD_KEYWORD(__FILE__,TK___FILE__);
+	ADD_KEYWORD(float_t, TK_LOCAL_FLOAT_T);
+	ADD_KEYWORD(foreach, TK_FOREACH);
+	ADD_KEYWORD(for, TK_FOR);
 	ADD_KEYWORD(function, TK_FUNCTION);
-	ADD_KEYWORD(local, TK_LOCAL);
-	ADD_KEYWORD(var, TK_LOCAL);
-	ADD_KEYWORD(auto, TK_LOCAL);
-	ADD_KEYWORD(let, TK_LOCAL);
-
-	ADD_KEYWORD(string_t, TK_LOCAL_STRING_T);
-	ADD_KEYWORD(char_t, TK_LOCAL_CHAR_T);
-	ADD_KEYWORD(wchar_t, TK_LOCAL_WCHAR_T);
-
-	ADD_KEYWORD(bool_t, TK_LOCAL_BOOL_T);
-	ADD_KEYWORD(table_t, TK_LOCAL_TABLE_T);
-	ADD_KEYWORD(array_t, TK_LOCAL_ARRAY_T);
-
-	ADD_KEYWORD(int8_t, TK_LOCAL_INT8_T);
+	ADD_KEYWORD(__FUNCTION__,TK___FUNCTION__);
+	ADD_KEYWORD(if, TK_IF);
+	ADD_KEYWORD(instanceof,TK_INSTANCEOF);
 	ADD_KEYWORD(int16_t, TK_LOCAL_INT16_T);
 	ADD_KEYWORD(int32_t, TK_LOCAL_INT32_T);
 	ADD_KEYWORD(int64_t, TK_LOCAL_INT64_T);
+	ADD_KEYWORD(int8_t, TK_LOCAL_INT8_T);
+	ADD_KEYWORD(in, TK_IN);
 	ADD_KEYWORD(int_t, TK_LOCAL_INT_T);
-
-	ADD_KEYWORD(uint8_t, TK_LOCAL_UINT8_T);
+	ADD_KEYWORD(let, TK_LOCAL);
+	ADD_KEYWORD(__LINE__,TK___LINE__);
+	ADD_KEYWORD(local, TK_LOCAL);
+	ADD_KEYWORD(long_double_t, TK_LOCAL_LONG_DOUBLE_T);
+	ADD_KEYWORD(new,TK_IGNORE);
+	ADD_KEYWORD(number_t, TK_LOCAL_NUMBER_T);
+	ADD_KEYWORD(null, TK_NULL);
+	ADD_KEYWORD(NULL, TK_NULL);
+	ADD_KEYWORD(private,TK_PRIVATE);
+	ADD_KEYWORD(public,TK_PUBLIC);
+	ADD_KEYWORD(resume, TK_RESUME);
+	ADD_KEYWORD(return, TK_RETURN);
+	ADD_KEYWORD(static,TK_STATIC);
+	ADD_KEYWORD(string_t, TK_LOCAL_STRING_T);
+	ADD_KEYWORD(struct,TK_STRUCT);
+	ADD_KEYWORD(switch, TK_SWITCH);
+	ADD_KEYWORD(table_t, TK_LOCAL_TABLE_T);
+	ADD_KEYWORD(this, TK_THIS);
+	ADD_KEYWORD(throw, TK_THROW);
+	ADD_KEYWORD(true,TK_TRUE);
+	ADD_KEYWORD(try, TK_TRY);
+	ADD_KEYWORD(typeof, TK_TYPEOF);
 	ADD_KEYWORD(uint16_t, TK_LOCAL_UINT16_T);
 	ADD_KEYWORD(uint32_t, TK_LOCAL_UINT32_T);
 	ADD_KEYWORD(uint64_t, TK_LOCAL_UINT64_T);
+	ADD_KEYWORD(uint8_t, TK_LOCAL_UINT8_T);
 	ADD_KEYWORD(uint_t, TK_LOCAL_UINT_T);
-
-	ADD_KEYWORD(float_t, TK_LOCAL_FLOAT_T);
-	ADD_KEYWORD(double_t, TK_LOCAL_DOUBLE_T);
-	ADD_KEYWORD(long_double_t, TK_LOCAL_LONG_DOUBLE_T);
-	ADD_KEYWORD(void_t, TK_LOCAL_VOID_T);
+	ADD_KEYWORD(var, TK_LOCAL);
 	ADD_KEYWORD(void_ptr_t, TK_LOCAL_VOIDPTR_T);
-
-	ADD_KEYWORD(for, TK_FOR);
-	ADD_KEYWORD(foreach, TK_FOREACH);
-	ADD_KEYWORD(in, TK_IN);
-	ADD_KEYWORD(typeof, TK_TYPEOF);
-	ADD_KEYWORD(base, TK_BASE);
-	ADD_KEYWORD(delete, TK_DELETE);
-	ADD_KEYWORD(try, TK_TRY);
-	ADD_KEYWORD(catch, TK_CATCH);
-	ADD_KEYWORD(throw, TK_THROW);
-	ADD_KEYWORD(clone, TK_CLONE);
+	ADD_KEYWORD(void_t, TK_LOCAL_VOID_T);
+	ADD_KEYWORD(wchar_t, TK_LOCAL_WCHAR_T);
+	ADD_KEYWORD(while, TK_WHILE);
 	ADD_KEYWORD(yield, TK_YIELD);
-	ADD_KEYWORD(resume, TK_RESUME);
-	ADD_KEYWORD(switch, TK_SWITCH);
-	ADD_KEYWORD(case, TK_CASE);
-	ADD_KEYWORD(default, TK_DEFAULT);
-	ADD_KEYWORD(this, TK_THIS);
-	ADD_KEYWORD(class,TK_CLASS);
-	ADD_KEYWORD(struct,TK_STRUCT);
-	ADD_KEYWORD(extends,TK_EXTENDS);
-	ADD_KEYWORD(constructor,TK_CONSTRUCTOR);
-	ADD_KEYWORD(destructor,TK_DESTRUCTOR);
-	ADD_KEYWORD(instanceof,TK_INSTANCEOF);
-	ADD_KEYWORD(true,TK_TRUE);
-	ADD_KEYWORD(false,TK_FALSE);
-	ADD_KEYWORD(static,TK_STATIC);
-	ADD_KEYWORD(enum,TK_ENUM);
-	ADD_KEYWORD(const,TK_CONST);
-	ADD_KEYWORD(__LINE__,TK___LINE__);
-	ADD_KEYWORD(__FUNCTION__,TK___FUNCTION__);
-	ADD_KEYWORD(__FILE__,TK___FILE__);
-	ADD_KEYWORD(private,TK_PRIVATE);
-	ADD_KEYWORD(public,TK_PUBLIC);
-	ADD_KEYWORD(new,TK_IGNORE);
 
 	return tbl;
 }