/***************************************************************************
  
  gb_reserved_keyword.h
  
  (c) Benoît Minisini <benoit.minisini@gambas-basic.org>

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2, or (at your option)
  any later version.
  
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  MA 02110-1301, USA.
  
***************************************************************************/

#ifndef __GB_RESERVED_KEYWORD_H
#define __GB_RESERVED_KEYWORD_H

COMP_INFO COMP_res_info[] =
{
	{ "" },

	{ "Boolean",      RSF_TYPE,                 T_BOOLEAN,  RSJ_DATATYPE     },
	{ "Byte",         RSF_TYPE,                 T_BYTE,     RSJ_DATATYPE     },
	{ "Date",         RSF_TYPE,                 T_DATE,     RSJ_DATATYPE     },
	{ "Single",       RSF_TYPE,                 T_SINGLE,   RSJ_DATATYPE     },
	{ "Float",        RSF_TYPE,                 T_FLOAT,    RSJ_DATATYPE     },
	{ "Integer",      RSF_TYPE,                 T_INTEGER,  RSJ_DATATYPE     },
	{ "Long",         RSF_TYPE,                 T_LONG,     RSJ_DATATYPE     },
	{ "Short",        RSF_TYPE,                 T_SHORT,    RSJ_DATATYPE     },
	{ "String",       RSF_TYPE,                 T_STRING,   RSJ_DATATYPE     },
	{ "Variant",      RSF_TYPE,                 T_VARIANT,  RSJ_DATATYPE     },
	{ "Object",       RSF_TYPE,                 T_OBJECT,   RSJ_DATATYPE     },
	{ "Pointer",      RSF_TYPE,                 T_POINTER,  RSJ_DATATYPE     },
	{ "Class",        RSF_CLASS|RSF_AS,         0,          RSJ_CLASS        },
	{ "Function",     RSF_IDENT,                0,          RSJ_SUB          },
	{ "Struct",       RSF_PREV,                 0,          RSJ_STRUCT       },
	{ "Const",        RSF_IDENT,                0,          RSJ_CONST        },
	{ "Private",      RSF_IDENT|RSF_PUB,                                     },
	{ "Public",       RSF_IDENT|RSF_PUB,                                     },
	{ "Static",       RSF_PUB                                                },
	{ "Fast",         RSF_PUB                                                },
	{ "Unsafe",       RSF_PUB                                                },
	{ "Property",     RSF_IDENT                                              },
	{ "Event",        RSF_IDENT                                              },
	{ "Inherits",     RSF_CLASS|RSF_AS                                       },
	{ "Implements"                                                           },
	{ "Export"                                                               },
	{ "As",           RSF_AS                                                 },
	{ "Of"                                                                   },
	{ "Dim",          RSF_IDENT,                                             },
	{ "New",          RSF_AS,                   0,          RSJ_ME           },
	{ "Procedure",    RSF_IDENT,                0,          RSJ_SUB          },
	{ "Sub",          RSF_IDENT,                0,          RSJ_SUB          },
	{ "Return",       0,                        0,          RSJ_STATEMENT    },
	{ "Optional",     0,                        0,          RSJ_OPTIONAL     },
	{ "Output"                                                               },
	{ "Do"                                                                   },
	{ "Loop"                                                                 },
	{ "While"                                                                },
	{ "Until"                                                                },
	{ "Repeat"                                                               },
	{ "Wend"                                                                 },
	{ "If"                                                                   },
	{ "Then"                                                                 },
	{ "Else"                                                                 },
	{ "Endif"                                                                },
	{ "End"                                                                  },
	{ "For"                                                                  },
	{ "To"                                                                   },
	{ "DownTo"                                                               },
	{ "From"                                                                 },
	{ "Step"                                                                 },
	{ "Next"                                                                 },
	{ "Select"                                                               },
	{ "Case"                                                                 },
	{ "Exit"                                                                 },
	{ "Break",        0,                        0,          RSJ_STATEMENT    },
	{ "Continue",     0,                        0,          RSJ_STATEMENT    },
	{ "Goto"                                                                 },
	{ "GoSub"                                                                },
	{ "On",           0,                        0,          RSJ_STATEMENT    },
	{ "Me",           0,                        0,          RSJ_ME           },
	{ "Last",         0,                        0,          RSJ_ME           },
	{ "Try",          0,                        0,          RSJ_STATEMENT    },
	{ "Finally",      0,                        0,          RSJ_BEGIN_LINE   },
	{ "Catch",        0,                        0,          RSJ_BEGIN_LINE },
	{ "With"                                                                 },
	{ "True",         0,                        0,          RSJ_ME           },
	{ "False",        0,                        0,          RSJ_ME           },
	{ "Swap",         0,                        0,          RSJ_STATEMENT    },
	{ "Null",         0,                        0,          RSJ_ME           },
	{ "Extern",       RSF_IDENT,                0,          RSJ_CONST        },
	{ "Each"                                                                 },
	{ "In"                                                                   },
	{ "Default"                                                              },
	{ "Stop",         0,                        0,          RSJ_STATEMENT    },
	{ "Quit",         0,                        0,          RSJ_STATEMENT    },
	{ "Raise",        RSF_IDENT                                              },
	{ "Error",        0,                        0,          RSJ_ERROR        },
	{ "Super",        0,                        0,          RSJ_ME           },
	{ "Enum",         RSF_IDENT,                0,          RSJ_ENUM         },
	{ "Let",          0,                        0,          RSJ_STATEMENT    },
	{ "+Inf"                                                                 },
	{ "-Inf"                                                                 },
	{ "Use"                                                                  },

	{ "Print",        0,                        0,          RSJ_STATEMENT    },
	{ "Input"                                                                },
	{ "Read",         RSF_PREV,                 0,          RSJ_READ         },
	{ "Peek",         0,                        0,          RSJ_EQUAL_STMT   },
	{ "Write",        RSF_PREV,                 0,          RSJ_READ         },
	{ "Open",         0,                        0,          RSJ_EQUAL_STMT   },
	{ "Close",        0,                        0,          RSJ_EQUAL_STMT   },
	{ "Seek",         0,                        0,          RSJ_EQUAL_STMT   },
	{ "Append"                                                               },
	{ "Create"                                                               },
	{ "Binary"                                                               },
	{ "Line"                                                                 },
	{ "Flush",        0,                        0,          RSJ_STATEMENT    },
	{ "Exec",         0,                        0,          RSJ_EXEC         },
	{ "Shell",        0,                        0,          RSJ_EQUAL_STMT   },
	{ "Wait"                                                                 },
	{ "Sleep",        0,                        0,          RSJ_STATEMENT    },
	{ "Kill"                                                                 },
	{ "Move",         0,                        0,          RSJ_STATEMENT    },
	{ "Copy",         0,                        0,          RSJ_STATEMENT    },
	{ "Inc",          0,                        0,          RSJ_STATEMENT    },
	{ "Dec",          0,                        0,          RSJ_STATEMENT    },
	{ "Mkdir",        0,                        0,          RSJ_STATEMENT    },
	{ "Rmdir",        0,                        0,          RSJ_STATEMENT    },
	{ "Watch"                                                                },
	{ "Link",         0,                        0,          RSJ_STATEMENT    },
	{ "Lock",         0,                        0,          RSJ_EQUAL_STMT   },
	{ "Unlock",       0,                        0,          RSJ_STATEMENT    },
	{ "Library"                                                              },
	{ "Debug",        0,                        0,          RSJ_STATEMENT    },
	{ "Assert",       0,                        0,          RSJ_STATEMENT    },
	{ "Pipe"                                                                 },
	{ "Randomize",    0,                        0,          RSJ_STATEMENT    },
	{ "ByRef",        0,                        0,          RSJ_BYREF        },
	{ "Memory"                                                               },
	{ "Chmod",        0,                        0,          RSJ_STATEMENT    },
	{ "Chown",        0,                        0,          RSJ_STATEMENT    },
	{ "Chgrp",        0,                        0,          RSJ_STATEMENT    },
	{ "After",        0,                        0,          RSJ_STATEMENT    },
	{ "Every",        0,                        0,          RSJ_STATEMENT    },
	
	{ "#If",          RSF_PREP,                                              },
	{ "#Else",        RSF_PREP,                                              },
	{ "#Endif",       RSF_PREP,                                              },
	{ "#Const",       RSF_PREP,                                              },
	{ "#Line",        RSF_PREP,                                              },
	{ "#Include",     RSF_PREP,                                              },
	{ "#Script",      RSF_PREP,                                              },

	{ ":",            RSF_NONE,                 OP_COLON,   0,   0,    T_OBJECT                     },  // Use for the immediate collection syntax
	{ ";"                                                                                           },
	{ ","                                                                                           },
	{ "..."                                                                                         },
	{ "#"                                                                                           },
	{ "@"                                                                                           },
	{ "?"                                                                                           },
	{ "{"                                                                                           },
	{ "}"                                                                                           },
	{ "=",            RSF_OP2S,                 OP_EQUAL,   0,   4,   T_BOOLEAN,      C_EQ          },
	{ "==",           RSF_OP2S,                 OP_NEAR,    0,   4,   T_BOOLEAN,      C_NEAR        },
	{ "(",            RSF_OPP,                  OP_LBRA,    0,   19                                 },
	{ ")",                                                                                          },
	{ ".",            RSF_OP2|RSF_POINT,        OP_PT,      0,   20,  T_VARIANT                     },
	{ "!",            RSF_OP2|RSF_POINT,        OP_EXCL,    0,   20,  T_VARIANT                     },
	{ "+",            RSF_OP2,                  OP_PLUS,    0,   5,   RST_ADD,        C_ADD         },
	{ "-",            RSF_OP2,                  OP_MINUS,   0,   5,   RST_ADD,        C_SUB         },
	{ "*",            RSF_OP2,                  OP_STAR,    0,   8,   RST_ADD,        C_MUL         },
	{ "/",            RSF_OP2,                  OP_SLASH,   0,   8,   RST_DIV,        C_DIV         },
	{ "^",            RSF_OP2S,                 OP_FLEX,    0,   12,  RST_FLEX,       C_POW         },
	{ "&",            RSF_OPN,                  OP_AMP,     0,   11,  T_STRING,       C_CAT         },
	{ "&/",           RSF_OPN,                  OP_FILE,    0,   10,  T_STRING,       C_FILE        },
	{ ">",            RSF_OP2S,                 OP_GT,      0,   4,   T_BOOLEAN,      C_GT          },
	{ "<",            RSF_OP2S,                 OP_LT,      0,   4,   T_BOOLEAN,      C_LT          },
	{ ">=",           RSF_OP2S,                 OP_GE,      0,   4,   T_BOOLEAN,      C_GE          },
	{ "<=",           RSF_OP2S,                 OP_LE,      0,   4,   T_BOOLEAN,      C_LE          },
	{ "<>",           RSF_OP2S,                 OP_NE,      0,   4,   T_BOOLEAN,      C_NE          },
	{ "[",            RSF_OPP,                  OP_LSQR,    0,   18,  RST_GET                       },
	{ "]",            RSF_NONE,                 OP_RSQR,    0,   0,   T_OBJECT                      },  // Use for the immediate array syntax
	{ "And",          RSF_OP2SM,                OP_AND,     0,   2,   RST_AND,        C_AND         },
	{ "Or",           RSF_OP2SM,                OP_OR,      0,   2,   RST_AND,        C_OR          },
	{ "Not",          RSF_OP1,                  OP_NOT,     0,   14,  RST_NOT,        C_NOT         },
	{ "Xor",          RSF_OP2SM,                OP_XOR,     0,   2,   RST_AND,        C_XOR         },
	{ "Shl",          RSF_OP2,                  OP_SHL,     0,   2,   RST_BCLR,       C_BCLR, 5     },
	{ "Asl",          RSF_OP2,                  OP_SHL,     0,   2,   RST_BCLR,       C_BCLR, 5     },
	{ "<<",           RSF_OP2,                  OP_SHL,     0,   2,   RST_BCLR,       C_BCLR, 5     },
	{ "Shr",          RSF_OP2,                  OP_SHL,     0,   2,   RST_BCLR,       C_BCLR, 6     },
	{ "Asr",          RSF_OP2,                  OP_SHL,     0,   2,   RST_BCLR,       C_BCLR, 6     },
	{ ">>",           RSF_OP2,                  OP_SHL,     0,   2,   RST_BCLR,       C_BCLR, 6     },
	{ "Rol",          RSF_OP2,                  OP_SHL,     0,   2,   RST_BCLR,       C_BCLR, 7     },
	{ "Ror",          RSF_OP2,                  OP_SHL,     0,   2,   RST_BCLR,       C_BCLR, 8     },
	{ "Lsl",          RSF_OP2,                  OP_SHL,     0,   2,   RST_BCLR,       C_BCLR, 9     },
	{ "Lsr",          RSF_OP2,                  OP_SHL,     0,   2,   RST_BCLR,       C_BCLR, 10    },
	{ ">>>",          RSF_OP2,                  OP_SHL,     0,   2,   RST_BCLR,       C_BCLR, 10    },
	{ "\\",           RSF_OP2S,                 OP_DIV,     0,   7,   T_INTEGER,      C_QUO         },
	{ "Div",          RSF_OP2S,                 OP_DIV,     0,   7,   T_INTEGER,      C_QUO         },
	{ "%",            RSF_OP2S,                 OP_MOD,     0,   6,   RST_MOD,        C_REM         },
	{ "Mod",          RSF_OP2S,                 OP_MOD,     0,   6,   RST_MOD,        C_REM         },
	{ "Is",           RSF_OP2|RSF_AS|RSF_NOT,   OP_IS,      0,   16,  T_BOOLEAN,      C_IS,   0     },
	{ "",             RSF_OP2|RSF_AS,           OP_IS,      0,   16,  T_BOOLEAN,      C_IS,   1     },
	{ "Like",         RSF_OP2S|RSF_NOT,         OP_LIKE,    0,   4,   RST_LIKE,       C_LIKE, 0     },
	{ "",             RSF_OP2S,                 OP_LIKE,    0,   4,   RST_LIKE,       C_LIKE, 4     }, // NOT LIKE
	{ "Begins",       RSF_OP2S|RSF_NOT,         OP_LIKE,    0,   4,   RST_LIKE,       C_LIKE, 1     },
	{ "",             RSF_OP2S,                 OP_LIKE,    0,   4,   RST_LIKE,       C_LIKE, 5     }, // NOT BEGINS
	{ "Ends",         RSF_OP2S|RSF_NOT,         OP_LIKE,    0,   4,   RST_LIKE,       C_LIKE, 2     },
	{ "",             RSF_OP2S,                 OP_LIKE,    0,   4,   RST_LIKE,       C_LIKE, 6     }, // NOT ENDS
	{ "Match",        RSF_OP2S|RSF_NOT,         OP_LIKE,    0,   4,   RST_LIKE,       C_LIKE, 3     },
	{ "",             RSF_OP2S,                 OP_LIKE,    0,   4,   RST_LIKE,       C_LIKE, 7     }, // NOT MATCH

	{ "+=",           RSF_ASGN,                 RS_PLUS                                             },
	{ "-=",           RSF_ASGN,                 RS_MINUS                                            },
	{ "*=",           RSF_ASGN,                 RS_STAR                                             },
	{ "/=",           RSF_ASGN,                 RS_SLASH                                            },
	{ "\\=",          RSF_ASGN,                 RS_BSLASH                                           },
	{ "%=",           RSF_ASGN,                 RS_PERCENT                                          },
	{ "&=",           RSF_ASGN,                 RS_AMP                                              },
	{ "&/=",          RSF_ASGN,                 RS_FILE                                             },
	{ "^=",           RSF_ASGN,                 RS_FLEX                                             },
	{ "<<=",          RSF_ASGN,                 RS_SHL                                              },
	{ ">>=",          RSF_ASGN,                 RS_SHR                                              },
	{ ">>>=",         RSF_ASGN,                 RS_LSR                                              },

	{ "%>"                                                                                          }, // Webpage delimiter

	{ NULL }
};

SUBR_INFO COMP_subr_info[] =
{
	{ "Left$",              0,  0, T_STRING,             1,  2 },
	{ "Left",               0,  0, T_STRING,             1,  2 },
                                                       
	{ "Mid$",               1,  0, T_STRING,             2,  3 },
	{ "Mid",                1,  0, T_STRING,             2,  3 },
                                                       
	{ "Right$",             2,  0, T_STRING,             1,  2 },
	{ "Right",              2,  0, T_STRING,             1,  2 },
                                                       
	{ "Len",                3,  0, T_INTEGER,            1     },
                                                       
	{ "Space$",             4,  0, T_STRING,             1     },
	{ "Space",              4,  0, T_STRING,             1     },
                                                       
	{ "String$",            5,  0, T_STRING,             2     },
	{ "String",             5,  0, T_STRING,             2     },
                                                       
	{ "Trim$",              6,  0, T_STRING,             1     },
	{ "Trim",               6,  0, T_STRING,             1     },
                                                       
	{ "LTrim$",             6,  1, T_STRING,             1     },
	{ "LTrim",              6,  1, T_STRING,             1     },
                                                       
	{ "RTrim$",             6,  2, T_STRING,             1     },
	{ "RTrim",              6,  2, T_STRING,             1     },
                                                       
	{ "Upper$",             7,  0, T_STRING,             1     },
	{ "Upper",              7,  0, T_STRING,             1     },
	{ "UCase$",             7,  0, T_STRING,             1     },
	{ "UCase",              7,  0, T_STRING,             1     },
                                                       
	{ "Lower$",             7,  1, T_STRING,             1     },
	{ "Lower",              7,  1, T_STRING,             1     },
	{ "LCase$",             7,  1, T_STRING,             1     },
	{ "LCase",              7,  1, T_STRING,             1     },
	                                                     
	{ "Oct$",               8,  0, T_STRING,             1,  2 },  // CODE_OCT
	{ "Oct",                8,  0, T_STRING,             1,  2 },
                                                       
	{ "Chr$",               9,  0, T_STRING,             1     },
	{ "Chr",                9,  0, T_STRING,             1     },
                                                       
	{ "Asc",               10,  0, T_INTEGER,            1,  2 },
                                                       
	{ "InStr",             11,  0, T_INTEGER,            2,  4 },
                                                       
	{ "RInStr",            12,  0, T_INTEGER,            2,  4 },   // CODE_RINSTR
                                                       
	{ "Subst$",            13,  0, T_STRING,             1, 63 },
	{ "Subst",             13,  0, T_STRING,             1, 63 },
                                                       
	{ "Replace$",          14,  0, T_STRING,             3,  4 },
	{ "Replace",           14,  0, T_STRING,             3,  4 },
                                                       
	{ "Split",             15,  0, RST_STRINGARRAY,      1,  5 },
                                                       
	{ "Scan",              16,  0, RST_STRINGARRAY,      2     },
                                                       
	{ "Comp",              17,  0, T_INTEGER,            2,  3 },
                                                       
	{ "Conv",              18,  0, T_STRING,             3     },
	{ "Conv$",             18,  0, T_STRING,             3     },
                                                       
	{ "SConv",             19,  0, T_STRING,             1     },
	{ "SConv$",            19,  0, T_STRING,             1     },
	{ "DConv",             19,  1, T_STRING,             1     },
	{ "DConv$",            19,  1, T_STRING,             1     },
                                                       
	{ "Abs",               20,  0, RST_ABS,              1     },   // CODE_ABS
                                                       
	{ "Int",               21,  0, RST_SAME,             1     },
	{ "Fix",               21,  8, RST_SAME,             1     },
                                                       
	{ "#Fix",              22,  0, RST_SAME,             1     },
	{ "NInStr",            22,  0, T_INTEGER,            2, 3  },
                                                       
	{ "Sgn",               23,  0, T_INTEGER,            1     },
                                                       
	{ "Frac",              24,  1, T_FLOAT,              1     },
	{ "Log",               24,  2, T_FLOAT,              1     },
	{ "Exp",               24,  3, T_FLOAT,              1     },
	{ "Sqr",               24,  4, T_FLOAT,              1     },
	{ "Sin",               24,  5, T_FLOAT,              1     },
	{ "Cos",               24,  6, T_FLOAT,              1     },
	{ "Tan",               24,  7, T_FLOAT,              1     },
	{ "Atn",               24,  8, T_FLOAT,              1     },
	{ "ATan",              24,  8, T_FLOAT,              1     },
	{ "Asn",               24,  9, T_FLOAT,              1     },
	{ "ASin",              24,  9, T_FLOAT,              1     },
	{ "Acs",               24, 10, T_FLOAT,              1     },
	{ "ACos",              24, 10, T_FLOAT,              1     },
	{ "Deg",               24, 11, T_FLOAT,              1     },
	{ "Rad",               24, 12, T_FLOAT,              1     },
	{ "Log10",             24, 13, T_FLOAT,              1     },
	{ "Sinh",              24, 14, T_FLOAT,              1     },
	{ "Cosh",              24, 15, T_FLOAT,              1     },
	{ "Tanh",              24, 16, T_FLOAT,              1     },
	{ "Asnh",              24, 17, T_FLOAT,              1     },
	{ "ASinh",             24, 17, T_FLOAT,              1     },
	{ "Acsh",              24, 18, T_FLOAT,              1     },
	{ "ACosh",             24, 18, T_FLOAT,              1     },
	{ "Atnh",              24, 19, T_FLOAT,              1     },
	{ "ATanh",             24, 19, T_FLOAT,              1     },
	{ "Exp2",              24, 20, T_FLOAT,              1     },
	{ "Exp10",             24, 21, T_FLOAT,              1     },
	{ "Log2",              24, 22, T_FLOAT,              1     },
	{ "Cbr",               24, 23, T_FLOAT,              1     },
	{ "Expm",              24, 24, T_FLOAT,              1     },
	{ "Logp",              24, 25, T_FLOAT,              1     },
	{ "Floor",             24, 26, T_FLOAT,              1     },
	{ "Ceil",              24, 27, T_FLOAT,              1     },
	{ "Pi",                24, 28, T_FLOAT,              1     },
                                                       
	{ "#Pi",               25,  0, T_FLOAT,              0,  1 },
	{ "Base",              25,  2, T_STRING,             2     },
	{ "Base$",             25,  2, T_STRING,             2     },
	{ "Dec",               25,  3, T_INTEGER,            2     },
	{ "FromBase",          25,  3, T_INTEGER,            2     },
                                                       
	{ "Round",             26,  0, T_FLOAT,              1,  2 },
#ifndef __EVAL_RESERVED_C                              
	{ ".Randomize",        27,  0, T_VOID,               0,  1 },
#endif                                                 
	{ "Rnd",               28,  0, T_FLOAT,              0,  2 },
                                                       
	{ "Min",               29,  0, RST_MIN,              2,    },
                                                       
	{ "Max",               30,  0, RST_MIN,              2,    },   // CODE_MAX
                                                       
	{ "If",                31,  0, T_VARIANT,            3,    },
	{ "IIf",               31,  0, T_VARIANT,            3,    },
                                                       
	{ "Choose",            32,  0, T_VARIANT,            1, 63 },
                                                       
	{ ".Array",            33,  0, T_OBJECT,             0, 63 },   // Needed for Eval("[...]")
                                                       
	{ "ATan2",             34,  1, T_FLOAT,              2     },
	{ "Atn2",              34,  1, T_FLOAT,              2     },
	{ "Ang",               34,  2, T_FLOAT,              2     },
	{ "Hyp",               34,  3, T_FLOAT,              2     },
	{ "Mag",               34,  3, T_FLOAT,              2     },
                                                       
	{ "IsAscii",           35,  1, T_BOOLEAN,            1     },
	{ "IsLetter",          35,  2, T_BOOLEAN,            1     },
	{ "IsLCase",           35,  3, T_BOOLEAN,            1     },
	{ "IsLower",           35,  3, T_BOOLEAN,            1     },
	{ "IsUCase",           35,  4, T_BOOLEAN,            1     },
	{ "IsUpper",           35,  4, T_BOOLEAN,            1     },
	{ "IsDigit",           35,  5, T_BOOLEAN,            1     },
	{ "IsHexa",            35,  6, T_BOOLEAN,            1     },
	{ "IsSpace",           35,  7, T_BOOLEAN,            1     },
	{ "IsBlank",           35,  8, T_BOOLEAN,            1     },
	{ "IsPunct",           35,  9, T_BOOLEAN,            1     },
	{ "IsAlnum",           35, 10, T_BOOLEAN,            1     },
                                                       
	{ "BClr",              36,  1, RST_BCLR,             2     },   // CODE_BCLR
	{ "BSet",              36,  2, RST_BCLR,             2     },
	{ "BTst",              36,  3, RST_BCLR,             2     },
	{ "BChg",              36,  4, RST_BCLR,             2     },
	{ "Shl",               36,  5, RST_BCLR,             2     },
	{ "Asl",               36,  5, RST_BCLR,             2     },
	{ "Shr",               36,  6, RST_BCLR,             2     },
	{ "Asr",               36,  6, RST_BCLR,             2     },
	{ "Rol",               36,  7, RST_BCLR,             2     },
	{ "Ror",               36,  8, RST_BCLR,             2     },
	{ "Lsl",               36,  9, RST_BCLR,             2     },
	{ "Lsr",               36, 10, RST_BCLR,             2     },
                                                       
	{ "IsBoolean",         37,  1, T_BOOLEAN,            1     },
	{ "IsInteger",         37,  4, T_BOOLEAN,            1     },
	{ "IsLong",            37,  5, T_BOOLEAN,            1     },
	{ "IsFloat",           37,  7, T_BOOLEAN,            1     },
	{ "IsDate",            37,  8, T_BOOLEAN,            1     },
	{ "IsNumber",          37, 14, T_BOOLEAN,            1     },
	{ "IsNull",            37, 15, T_BOOLEAN,            1     },
                                                       
	{ "TypeOf",            38,  0, T_INTEGER,            1     },
	{ "SizeOf",            38,  1, T_INTEGER,            1     },
                                                       
	{ "CBool",             39,  1, T_BOOLEAN,            1     },  // CODE_CONV
	{ "CBoolean",          39,  1, T_BOOLEAN,            1     },
	{ "CByte",             39,  2, T_BYTE,               1     },
	{ "CShort",            39,  3, T_SHORT,              1     },
	{ "CInt",              39,  4, T_INTEGER,            1     },
	{ "CInteger",          39,  4, T_INTEGER,            1     },
	{ "CLong",             39,  5, T_LONG,               1     },
	{ "CSingle",           39,  6, T_SINGLE,             1     },
	{ "CFloat",            39,  7, T_FLOAT,              1     },
	{ "CDate",             39,  8, T_DATE,               1     },
	{ "CStr",              39,  9, T_STRING,             1     },
	{ "CString",           39,  9, T_STRING,             1     },
	{ "CPointer",          39, 11, T_POINTER,            1     },
	{ "CVariant",          39, 12, T_VARIANT,            1     },
                                                       
	{ "Bin$",              40,  0, T_STRING,             1,  2 },  // CODE_BIN
	{ "Bin",               40,  0, T_STRING,             1,  2 },
                                                       
	{ "Hex$",              41,  0, T_STRING,             1,  2 },  // CODE_HEX
	{ "Hex",               41,  0, T_STRING,             1,  2 },
                                                       
	{ "Val",               42,  0, T_VARIANT,            1     },
                                                       
	{ "Str$",              43,  0, T_STRING,             1     },
	{ "Str",               43,  0, T_STRING,             1     },
                                                       
	{ "Format$",           44,  0, T_STRING,             1,  2 },
	{ "Format",            44,  0, T_STRING,             1,  2 },
                                                       
	{ "Timer",             45,  0, T_FLOAT,              0     },
                                                       
	{ "Now",               46,  0, T_DATE,               0     },
                                                       
	{ "Year",              47,  1, T_INTEGER,            1     },
	{ "Month",             47,  2, T_INTEGER,            1     },
	{ "Day",               47,  3, T_INTEGER,            1     },
	{ "Hour",              47,  4, T_INTEGER,            1     },
	{ "Minute",            47,  5, T_INTEGER,            1     },
	{ "Second",            47,  6, T_INTEGER,            1     },
	{ "WeekDay",           47,  7, T_INTEGER,            1     },
                                                       
	{ "Week",              48,  0, T_INTEGER,            0,  3 },
                                                       
	{ "Date",              49,  0, T_DATE,               0,  7 },
                                                       
	{ "Time",              50,  0, T_DATE,               0,  4 },
                                                       
	{ "DateAdd",           51,  0, T_DATE,               3     },
	{ "DateDiff",          51,  1, T_INTEGER,            3     },
                                                       
	{ "Eval",              52,  0, T_VARIANT,            1,  2 },
                                                       
#ifndef __EVAL_RESERVED_C                              
	{ ".Error",            53,  0, T_BOOLEAN,            0     },
                                                       
	{ ".Debug",            54,  0, T_VOID,               0,  1 },  // CODE_DEBUG
                                                       
	{ ".Wait",             55,  0, T_VOID,               0     },
	{ ".WaitDelay",        55,  1, T_VOID,               1     },
	{ ".WaitNext",         55,  2, T_VOID,               0     },
                                                       
	{ ".Open",             56,  0, T_OBJECT,             2     },
	{ ".OpenMemory",       56,  1, T_OBJECT,             2     },
                                                       
	{ ".Close",            57,  0, T_VOID,               1     },
	{ ".Flush",            57,  1, T_VOID,               1     },
	{ ".InputFrom",        57,  2, T_VOID,               1     },
	{ ".OutputTo",         57,  3, T_VOID,               1     },
	{ ".ErrorTo",          57,  4, T_VOID,               1     },
	{ ".LineInput",        57,  5, T_STRING,             1     },
	{ ".Lock",             57,  6, T_OBJECT,             1     },
	{ ".Unlock",           57,  7, T_VOID,               1     },
	{ ".LockWait",         57,  8, T_VOID,               2     },
                                                       
	{ ".Input",            58,  0, T_STRING,             0,  1 },
                                                       
	{ "#.LineInput",       59,  0, T_STRING,             1     },
	{ "Clamp",             59, 15, RST_CLAMP,            3     },
                                                       
	{ ".Print",            60,  0, T_VOID,               1, 63 },
                                                       
	{ ".Read",             61,  0, RST_READ,             2,    },
	{ ".ReadBytes",        61,  1, T_STRING,             2,    },
	{ ".Peek",             61,  2, T_STRING,             2,    },
                                                       
	{ ".Write",            62,  0, T_VOID,               3,    },
	{ ".WriteBytes",       62,  1, T_VOID,               3,    },
                                                       
	{ "#.Flush",           63,  0, T_VOID,               1     },
	{ "Tokenize",          63,  0, RST_STRINGARRAY,      1, 5  },
                                                       
	{ "#.Lock",            64,  0, T_OBJECT,             1     },
	{ "#.Unlock",          64,  1, T_VOID,               1     },
	{ "#.LockWait",        64,  2, T_VOID,               2     },
                                                       
	{ "#.InputFrom",       65,  0, T_VOID,               1     },
	{ "#.OutputTo",        65,  1, T_VOID,               1     },
	{ "#.ErrorTo",         65,  2, T_VOID,               1     },
#endif                                                 
                                                       
	{ "Eof",               66,  0, T_BOOLEAN,            0,  1 },
                                                       
	{ "Lof",               67,  0, T_LONG,               0,  1 },
                                                       
	{ "Seek",              68,  0, T_LONG,               1,  3 },
                                                       
#ifndef __EVAL_RESERVED_C                              
	{ ".Kill",             69,  0, T_VOID,               1     },
	{ ".Mkdir",            69,  1, T_VOID,               1     },
	{ ".Rmdir",            69,  2, T_VOID,               1     },
#endif                                                 
                                                       
//{ ".Mkdir",            70,  0,                       1     }, // The old Mkdir from 3.0
	{ "Even",              70,  1, T_BOOLEAN,            1     },
	{ "Odd",               70,  2, T_BOOLEAN,            1     },
                                                       
//{ ".Rmdir",            71,  0,                       1     }, // The old Rmdir from 3.0
	{ "Rand",              71,  0, T_INTEGER,            1,  2 },
#ifndef __EVAL_RESERVED_C                              
	{ ".Move",             72,  0, T_VOID,               2     },
	{ ".Copy",             72,  1, T_VOID,               2     },
	{ ".Link",             72,  2, T_VOID,               2     },
	{ ".Chmod",            72,  3, T_VOID,               2     },
	{ ".Chown",            72,  4, T_VOID,               2     },
	{ ".Chgrp",            72,  5, T_VOID,               2     },
	{ ".MoveKill",         72,  6, T_VOID,               2     },
#endif                                                 
	{ "Swap",              73,  0, T_STRING,             1,  2 }, // at least one argument, because 73 is a deprecated Copy() too.
	{ "Swap$",             73,  0, T_STRING,             1,  2 },
	                                                     
	{ "IsNan",             74,  1, T_BOOLEAN,            1     },
	{ "IsInf",             74,  2, T_BOOLEAN,            1     },
	                                                     
	{ "Exist",             75,  0, T_BOOLEAN,            1,  2 },
                                                       
	{ "Access",            76,  0, T_BOOLEAN,            1,  2 },
                                                       
	{ "Stat",              77,  0, T_OBJECT,             1,  2 },
                                                       
	{ "Dfree",             78,  0, T_LONG,               1     },
                                                       
	{ "Temp",              79,  0, T_STRING,             0,  1 },
	{ "Temp$",             79,  0, T_STRING,             0,  1 },
                                                       
	{ "IsDir",             80,  0, T_BOOLEAN,            1     },
                                                       
	{ "Dir",               81,  0, RST_STRINGARRAY,      1,  3 },
                                                       
	{ "RDir",              82,  0, RST_STRINGARRAY,      1,  4 },
                                                       
#ifndef __EVAL_RESERVED_C                              
	{ ".Exec",             83,  0, RST_EXEC,             4     },
	{ ".Shell",            83,  1, RST_EXEC,             4     },
#endif                                                 
                                                       
	{ "Alloc",             84,  0, T_POINTER,            1,  2 },
                                                       
	{ "Free",              85,  0, T_VOID,               1     },
                                                       
	{ "Realloc",           86,  0, T_POINTER,            2,  3 },
                                                       
	{ "Str@",              87,  0, T_STRING,             1,  2 },
	{ "String@",           87,  0, T_STRING,             1,  2 },
                                                       
#ifndef __EVAL_RESERVED_C                              
	{ ".Sleep",            88,  0, T_VOID,               1     },
	{ ".Use",              88,  1, T_VOID,               1     },
	{ ".CheckExec",        88,  2, T_VOID,               1     },
#endif                                                 
                                                       
	{ "VarPtr",            89,  0, T_POINTER,            1     },
	{ "IsMissing",         89,  1, T_BOOLEAN,            1     },
                                                       
	{ ".Collection",       90,  0, RST_COLLECTION,       1, 63 },
	                                                     
	{ "Tr",                91,  0, T_STRING,             1     },  // can merge 91, 92, 93 and 94
	{ "Tr$",               91,  0, T_STRING,             1     },
	                                                     
	{ "Quote",             92,  0, T_STRING,             1     },
	{ "Quote$",            92,  0, T_STRING,             1     },
	{ "Shell",             92,  1, T_STRING,             1     },
	{ "Shell$",            92,  1, T_STRING,             1     },
	{ "Html",              92,  2, T_STRING,             1     },
	{ "Html$",             92,  2, T_STRING,             1     },
	{ "Base64",            92,  3, T_STRING,             1     },
	{ "Base64$",           92,  3, T_STRING,             1     },
	{ "Url",               92,  4, T_STRING,             1     },
	{ "Url$",              92,  4, T_STRING,             1     },
                                                       
	{ "UnQuote",           93,  0, T_STRING,             1     },
	{ "UnQuote$",          93,  0, T_STRING,             1     },
	{ "UnBase64",          93,  1, T_STRING,             1     },
	{ "UnBase64$",         93,  1, T_STRING,             1     },
	{ "FromBase64",        93,  1, T_STRING,             1     },
	{ "FromBase64$",       93,  1, T_STRING,             1     },
	{ "FromUrl",           93,  2, T_STRING,             1     },
	{ "FromUrl$",          93,  2, T_STRING,             1     },
	{ "FromHtml",          93,  3, T_STRING,             1     },
	{ "FromHtml$",         93,  3, T_STRING,             1     },
                                                       
	{ "MkBool",            94,  1, T_STRING,             1     },
	{ "MkBool$",           94,  1, T_STRING,             1     },
	{ "MkBoolean",         94,  1, T_STRING,             1     },
	{ "MkBoolean$",        94,  1, T_STRING,             1     },
	{ "MkByte",            94,  2, T_STRING,             1     },
	{ "MkByte$",           94,  2, T_STRING,             1     },
	{ "MkShort",           94,  3, T_STRING,             1     },
	{ "MkShort$",          94,  3, T_STRING,             1     },
	{ "MkInt",             94,  4, T_STRING,             1     },
	{ "MkInt$",            94,  4, T_STRING,             1     },
	{ "MkInteger",         94,  4, T_STRING,             1     },
	{ "MkInteger$",        94,  4, T_STRING,             1     },
	{ "MkLong",            94,  5, T_STRING,             1     },
	{ "MkLong$",           94,  5, T_STRING,             1     },
	{ "MkSingle",          94,  6, T_STRING,             1     },
	{ "MkSingle$",         94,  6, T_STRING,             1     },
	{ "MkFloat",           94,  7, T_STRING,             1     },
	{ "MkFloat$",          94,  7, T_STRING,             1     },
	{ "MkDate",            94,  8, T_STRING,             1     },
	{ "MkDate$",           94,  8, T_STRING,             1     },
	{ "MkPointer",         94, 11, T_STRING,             1     },
	{ "MkPointer$",        94, 11, T_STRING,             1     },
                                                       
	{ "Bool@",             95,  1, T_BOOLEAN,            1     },
	{ "Boolean@",          95,  1, T_BOOLEAN,            1     },
	{ "Byte@",             95,  2, T_BYTE,               1     },
	{ "Short@",            95,  3, T_SHORT,              1     },
	{ "Int@",              95,  4, T_INTEGER,            1     },
	{ "Integer@",          95,  4, T_INTEGER,            1     },
	{ "Long@",             95,  5, T_LONG,               1     },
	{ "Single@",           95,  6, T_SINGLE,             1     },
	{ "Float@",            95,  7, T_FLOAT,              1     },
	{ "Date@",             95,  8, T_DATE,               1     },
	{ "Pointer@",          95, 11, T_POINTER,            1     },

	{ NULL }
};

#endif
