/***************************************************************************

  gb_reserved_keyword.h

  (c) 2000-2010 Benoît Minisini <gambas@users.sourceforge.net>

  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., 675 Mass Ave, Cambridge, MA 02139, USA.

***************************************************************************/

#ifndef __GB_RESERVED_KEYWORD_H
#define __GB_RESERVED_KEYWORD_H

COMP_INFO COMP_res_info[] =
{
  { "" },

  { "Boolean",      RSF_TYPE,     T_BOOLEAN         },
  { "Byte",         RSF_TYPE,     T_BYTE            },
  { "Date",         RSF_TYPE,     T_DATE            },
  { "Single",       RSF_TYPE,     T_SINGLE          },
  { "Float",        RSF_TYPE,     T_FLOAT           },
  { "Integer",      RSF_TYPE,     T_INTEGER         },
  { "Long",         RSF_TYPE,     T_LONG            },
  { "Short",        RSF_TYPE,     T_SHORT           },
  { "String",       RSF_TYPE,     T_STRING          },
  { "Variant",      RSF_TYPE,     T_VARIANT         },
  { "Object",       RSF_TYPE,     T_OBJECT          },
  { "Pointer",      RSF_TYPE,     T_POINTER         },
  { "Class",        RSF_ILD                         },
  { "Function",     RSF_ILF                         },
  { "Struct",       RSF_ILD                         },
  { "Const"                                         },
  { "Private",      RSF_ILD                         },
  { "Public",       RSF_ILD                         },
  { "Static"                                        },
  { "Property",     RSF_ILD                         },
  { "Event",        RSF_ILF                         },
  { "Inherits",     RSF_ILC                         },
  { "Implements"                                    },
  { "Export"                                        },
  { "As",           RSF_ILT                         },
  { "Of"                                            },
  { "Dim",          RSF_ILD                         },
  { "New",          RSF_ILT                         },
  { "Procedure",    RSF_ILF                         },
  { "Sub",          RSF_ILF                         },
  { "Return"                                        },
  { "Optional"                                      },
  { "Output"                                        },
  { "Do"                                            },
  { "Loop"                                          },
  { "While"                                         },
  { "Until"                                         },
  { "Repeat"                                        },
  { "Wend"                                          },
  { "If"                                            },
  { "Then"                                          },
  { "Else"                                          },
  { "Endif"                                         },
  { "End"                                           },
  { "For"                                           },
  { "To"                                            },
  { "From"                                          },
  { "Step"                                          },
  { "Next"                                          },
  { "Select"                                        },
  { "Case"                                          },
  { "Exit"                                          },
  { "Break"                                         },
  { "Continue"                                      },
  { "Goto"                                          },
  { "Me"                                            },
  { "Last"                                          },
  { "Try"                                           },
  { "Finally"                                       },
  { "Catch"                                         },
  { "With"                                          },
  { "True"                                          },
  { "False"                                         },
  { "Swap"                                          },
  { "Null"                                          },
  { "Extern"                                        },
  { "Each"                                          },
  { "In"                                            },
  { "Default"                                       },
  { "Stop"                                          },
  { "Quit"                                          },
  { "Raise",        RSF_ILF                         },
  { "Error"                                         },
  { "Super"                                         },
  { "Enum"                                          },
	{ "Let"                                           },

  { "Print"                                         },
  { "Input"                                         },
  { "Read",         RSF_ILDD                        },
  { "Write"                                         },
  { "Open"                                          },
  { "Close"                                         },
  { "Seek"                                          },
  { "Append"                                        },
  { "Create"                                        },
  { "Binary"                                        },
  { "Line"                                          },
  { "Flush"                                         },
  { "Exec"                                          },
  { "Shell"                                         },
  { "Wait"                                          },
  { "Sleep"                                         },
  { "Kill"                                          },
  { "Move"                                          },
  { "Copy"                                          },
  { "Inc"                                           },
  { "Dec"                                           },
  { "Mkdir"                                         },
  { "Rmdir"                                         },
  { "Watch"                                         },
  { "Link"                                          },
  { "Lock"                                          },
  { "Unlock"                                        },
  { "Library"                                       },
  { "Debug"                                         },
  { "Pipe"                                          },
  { "Randomize"                                     },
  { "ByRef"                                         },
  { "Memory"                                        },

  { ":",            RSF_NONE,               OP_COLON                          },  // Use for the immediate collection syntax
  { ";"                                                                       },
  { ","                                                                       },
  { "..."                                                                     },
  { "#"                                                                       },
  { "@"                                                                       },
  { "?"                                                                       },
  { "{"                                                                       },
  { "}"                                                                       },
  { "=",            RSF_OP2S,               OP_EQUAL,     4,    C_EQ          },
  { "==",           RSF_OP2S,               OP_NEAR,      4,    C_NEAR        },
  { "(",            RSF_OPP,                OP_LBRA,      12                  },
  { ")",                                                                      },
  { ".",            RSF_OP2|RSF_INF,        OP_PT,        20                  },
  { "!",            RSF_OP2|RSF_INF,        OP_EXCL,      20                  },
  { "+",            RSF_OP2,                OP_PLUS,      5,    C_ADD         },
  { "-",            RSF_OP2,                OP_MINUS,     5,    C_SUB         },
  { "*",            RSF_OP2,                OP_STAR,      6,    C_MUL         },
  { "/",            RSF_OP2,                OP_SLASH,     6,    C_DIV         },
  { "^",            RSF_OP2S,               OP_FLEX,      7,    C_POW         },
  { "&",            RSF_OPN,                OP_AMP,       9,    C_CAT         },
  { ">",            RSF_OP2S,               OP_GT,        4,    C_GT          },
  { "<",            RSF_OP2S,               OP_LT,        4,    C_LT          },
  { ">=",           RSF_OP2S,               OP_GE,        4,    C_GE          },
  { "<=",           RSF_OP2S,               OP_LE,        4,    C_LE          },
  { "<>",           RSF_OP2S,               OP_NE,        4,    C_NE          },
  { "[",            RSF_OPP,                OP_LSQR,      12                  },
  { "]",            RSF_NONE,               OP_RSQR                           },  // Use for the immediate array syntax
  { "And",          RSF_OP2SM,              OP_AND,       2,    C_AND         },
  { "Or",           RSF_OP2SM,              OP_OR,        2,    C_OR          },
  { "Not",          RSF_OP1,                OP_NOT,       10,   C_NOT         },
  { "Xor",          RSF_OP2SM,              OP_XOR,       2,    C_XOR         },
  { "\\",           RSF_OP2S,               OP_DIV,       6,    C_QUO         },
  { "Div",          RSF_OP2S,               OP_DIV,       6,    C_QUO         },
  { "Mod",          RSF_OP2S,               OP_MOD,       6,    C_REM         },
  { "Is",           RSF_OP2|RSF_ILT,        OP_IS,        11,   C_IS          },
  { "Like",         RSF_OP2S,               OP_LIKE,      4,    C_LIKE, 0     },
  { "Begins",       RSF_OP2S,               OP_LIKE,      4,    C_LIKE, 1     },
  { "Ends",         RSF_OP2S,               OP_LIKE,      4,    C_LIKE, 2     },
  { "&/",           RSF_OPN,                OP_FILE,      8,    C_FILE        },

  { "+=",           RSF_ASGN,               RS_PLUS                           },
  { "-=",           RSF_ASGN,               RS_MINUS                          },
  { "*=",           RSF_ASGN,               RS_STAR                           },
  { "/=",           RSF_ASGN,               RS_SLASH                          },
  { "\\=",          RSF_ASGN,               RS_BSLASH                         },
  { "&=",           RSF_ASGN,               RS_AMP                            },
  { "&/=",          RSF_ASGN,               RS_FILE                           },
  { "^=",           RSF_ASGN,               RS_FLEX                           },

  { NULL }
};

#endif