vala/valatokentype.vala

   1 /* valatokentype.vala
   2  *
   3  * Copyright (C) 2008  Jürg Billeter
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  18  *
  19  * Author:
  20  *      Jürg Billeter <j@bitron.ch>
  21  */
  22
  23 using GLib;
  24
  25 public enum Vala.TokenType {
  26         NONE,
  27         ABSTRACT,
  28         AS,
  29         ASSIGN,
  30         ASSIGN_ADD,
  31         ASSIGN_BITWISE_AND,
  32         ASSIGN_BITWISE_OR,
  33         ASSIGN_BITWISE_XOR,
  34         ASSIGN_DIV,
  35         ASSIGN_MUL,
  36         ASSIGN_PERCENT,
  37         ASSIGN_SHIFT_LEFT,
  38         ASSIGN_SUB,
  39         BASE,
  40         BITWISE_AND,
  41         BITWISE_OR,
  42         BREAK,
  43         CARRET,
  44         CASE,
  45         CATCH,
  46         CHARACTER_LITERAL,
  47         CLASS,
  48         CLOSE_BRACE,
  49         CLOSE_BRACKET,
  50         CLOSE_PARENS,
  51         COLON,
  52         COMMA,
  53         CONST,
  54         CONSTRUCT,
  55         CONTINUE,
  56         DEFAULT,
  57         DELEGATE,
  58         DELETE,
  59         DIV,
  60         DO,
  61         DOUBLE_COLON,
  62         DOT,
  63         DYNAMIC,
  64         ELLIPSIS,
  65         ELSE,
  66         ENUM,
  67         ENSURES,
  68         ERRORDOMAIN,
  69         EOF,
  70         EXTERN,
  71         FALSE,
  72         FINALLY,
  73         FOR,
  74         FOREACH,
  75         GET,
  76         HASH,
  77         IDENTIFIER,
  78         IF,
  79         IN,
  80         INLINE,
  81         INTEGER_LITERAL,
  82         INTERFACE,
  83         INTERNAL,
  84         INTERR,
  85         IS,
  86         LAMBDA,
  87         LOCK,
  88         MINUS,
  89         NAMESPACE,
  90         NEW,
  91         NULL,
  92         OUT,
  93         OP_AND,
  94         OP_DEC,
  95         OP_EQ,
  96         OP_GE,
  97         OP_GT,
  98         OP_INC,
  99         OP_LE,
 100         OP_LT,
 101         OP_NE,
 102         OP_NEG,
 103         OP_OR,
 104         OP_PTR,
 105         OP_SHIFT_LEFT,
 106         OPEN_BRACE,
 107         OPEN_BRACKET,
 108         OPEN_PARENS,
 109         OVERRIDE,
 110         OWNED,
 111         PARAMS,
 112         PERCENT,
 113         PLUS,
 114         PRIVATE,
 115         PROTECTED,
 116         PUBLIC,
 117         REAL_LITERAL,
 118         REF,
 119         REQUIRES,
 120         RETURN,
 121         SEMICOLON,
 122         SET,
 123         SIGNAL,
 124         SIZEOF,
 125         STAR,
 126         STATIC,
 127         STRING_LITERAL,
 128         STRUCT,
 129         SWITCH,
 130         THIS,
 131         THROW,
 132         THROWS,
 133         TILDE,
 134         TRUE,
 135         TRY,
 136         TYPEOF,
 137         UNOWNED,
 138         USING,
 139         VAR,
 140         VERBATIM_STRING_LITERAL,
 141         VIRTUAL,
 142         VOID,
 143         VOLATILE,
 144         WEAK,
 145         WHILE,
 146         YIELD,
 147         YIELDS;
 148
 149         public weak string to_string () {
 150                 switch (this) {
 151                 case ABSTRACT: return "`abstract'";
 152                 case AS: return "`as'";
 153                 case ASSIGN: return "`='";
 154                 case ASSIGN_ADD: return "`+='";
 155                 case ASSIGN_BITWISE_AND: return "`&='";
 156                 case ASSIGN_BITWISE_OR: return "`|='";
 157                 case ASSIGN_BITWISE_XOR: return "`^='";
 158                 case ASSIGN_DIV: return "`/='";
 159                 case ASSIGN_MUL: return "`*='";
 160                 case ASSIGN_PERCENT: return "`%='";
 161                 case ASSIGN_SHIFT_LEFT: return "`<<='";
 162                 case ASSIGN_SUB: return "`-='";
 163                 case BASE: return "`base'";
 164                 case BITWISE_AND: return "`&'";
 165                 case BITWISE_OR: return "`|'";
 166                 case BREAK: return "`break'";
 167                 case CARRET: return "`^'";
 168                 case CASE: return "`case'";
 169                 case CATCH: return "`catch'";
 170                 case CHARACTER_LITERAL: return "character literal";
 171                 case CLASS: return "`class'";
 172                 case CLOSE_BRACE: return "`}'";
 173                 case CLOSE_BRACKET: return "`]'";
 174                 case CLOSE_PARENS: return "`)'";
 175                 case COLON: return "`:'";
 176                 case COMMA: return "`,'";
 177                 case CONST: return "`const'";
 178                 case CONSTRUCT: return "`construct'";
 179                 case CONTINUE: return "`continue'";
 180                 case DEFAULT: return "`default'";
 181                 case DELEGATE: return "`delegate'";
 182                 case DELETE: return "`delete'";
 183                 case DIV: return "`/'";
 184                 case DO: return "`do'";
 185                 case DOT: return "`.'";
 186                 case ELLIPSIS: return "`...'";
 187                 case ELSE: return "`else'";
 188                 case ENUM: return "`enum'";
 189                 case ENSURES: return "`ensures'";
 190                 case ERRORDOMAIN: return "`errordomain'";
 191                 case EOF: return "end of file";
 192                 case FALSE: return "`false'";
 193                 case FINALLY: return "`finally'";
 194                 case FOR: return "`for'";
 195                 case FOREACH: return "`foreach'";
 196                 case GET: return "`get'";
 197                 case HASH: return "`hash'";
 198                 case IDENTIFIER: return "identifier";
 199                 case IF: return "`if'";
 200                 case IN: return "`in'";
 201                 case INLINE: return "`inline'";
 202                 case INTEGER_LITERAL: return "integer literal";
 203                 case INTERFACE: return "`interface'";
 204                 case INTERNAL: return "`internal'";
 205                 case INTERR: return "`?'";
 206                 case IS: return "`is'";
 207                 case LAMBDA: return "`=>'";
 208                 case LOCK: return "`lock'";
 209                 case MINUS: return "`-'";
 210                 case NAMESPACE: return "`namespace'";
 211                 case NEW: return "`new'";
 212                 case NULL: return "`null'";
 213                 case OUT: return "`out'";
 214                 case OP_AND: return "`&&'";
 215                 case OP_DEC: return "`--'";
 216                 case OP_EQ: return "`=='";
 217                 case OP_GE: return "`>='";
 218                 case OP_GT: return "`>'";
 219                 case OP_INC: return "`++'";
 220                 case OP_LE: return "`<='";
 221                 case OP_LT: return "`<'";
 222                 case OP_NE: return "`!='";
 223                 case OP_NEG: return "`!'";
 224                 case OP_OR: return "`||'";
 225                 case OP_PTR: return "`->'";
 226                 case OP_SHIFT_LEFT: return "`<<'";
 227                 case OPEN_BRACE: return "`{'";
 228                 case OPEN_BRACKET: return "`['";
 229                 case OPEN_PARENS: return "`('";
 230                 case OVERRIDE: return "`override'";
 231                 case OWNED: return "`owned'";
 232                 case PARAMS: return "`params'";
 233                 case PERCENT: return "`%'";
 234                 case PLUS: return "`+'";
 235                 case PRIVATE: return "`private'";
 236                 case PROTECTED: return "`protected'";
 237                 case PUBLIC: return "`public'";
 238                 case REAL_LITERAL: return "real literal";
 239                 case REF: return "`ref'";
 240                 case REQUIRES: return "`requires'";
 241                 case RETURN: return "`return'";
 242                 case SEMICOLON: return "`;'";
 243                 case SET: return "`set'";
 244                 case SIGNAL: return "`signal'";
 245                 case SIZEOF: return "`sizeof'";
 246                 case STAR: return "`*'";
 247                 case STATIC: return "`static'";
 248                 case STRING_LITERAL: return "string literal";
 249                 case STRUCT: return "`struct'";
 250                 case SWITCH: return "`switch'";
 251                 case THIS: return "`this'";
 252                 case THROW: return "`throw'";
 253                 case THROWS: return "`throws'";
 254                 case TILDE: return "`~'";
 255                 case TRUE: return "`true'";
 256                 case TRY: return "`try'";
 257                 case TYPEOF: return "`typeof'";
 258                 case UNOWNED: return "`unowned'";
 259                 case USING: return "`using'";
 260                 case VAR: return "`var'";
 261                 case VIRTUAL: return "`virtual'";
 262                 case VOID: return "`void'";
 263                 case VOLATILE: return "`volatile'";
 264                 case WEAK: return "`weak'";
 265                 case WHILE: return "`while'";
 266                 case YIELD: return "`yield'";
 267                 case YIELDS: return "`yields'";
 268                 default: return "unknown token";
 269                 }
 270         }
 271 }
 272