git.roojs.org Git - roojspacker/blob - roojspacker/Lang.vala

   1 //<script type="text/javscript">
   2
   3 /**
   4         @namespace
   5 */
   6 // test
   7 // valac gitlive/app.Builder.js/JsRender/Lang.vala --pkg gee-1.0 -o /tmp/Lang ;/tmp/Lang
   8
   9 /*
  10 void main () {
  11     new JsRender.Lang_Class();
  12     print(JsRender.Lang.keyword("delete") + "\n");
  13 }
  14 */
  15
  16
  17 namespace JSDOC {
  18
  19         public errordomain LangError {
  20             ArgumentError
  21     }
  22
  23     public Lang_Class Lang = null;
  24
  25     public class Lang_Class : Object {
  26
  27         GLib.List<string> coreObjects;
  28         Gee.HashMap<string,string> whitespaceNames;
  29         Gee.HashMap<string,string> newlineNames;
  30
  31
  32
  33         public Lang_Class ()
  34         {
  35             if (Lang != null) {
  36                 //print("lang not null\n");
  37                 return;
  38             }
  39             //print("init\n");
  40             this.init();
  41             //print("init Lang");
  42             Lang = this;
  43             Lang.ref();
  44
  45         }
  46
  47
  48         public bool isBuiltin(string  name) {
  49             return (this.coreObjects.index(name) > -1);
  50         }
  51
  52         public string whitespace (string ch) {
  53             return this.whitespaceNames.get(ch);
  54         }
  55         public string  newline (string ch) {
  56             return this.newlineNames.get(ch);
  57         }
  58         public TokenName keyword(string word) throws LangError {
  59
  60                 switch(word) {
  61                             case "break": return TokenName.BREAK;
  62                                 case "case": return TokenName.CASE;
  63                                 case "catch": return TokenName.CATCH;
  64                                 case "const": return TokenName.VAR;
  65                                 case "continue": return TokenName.CONTINUE;
  66                                 case "default": return TokenName.DEFAULT;
  67                                 case "delete": return TokenName.DELETE;
  68                                 case "do": return TokenName.DO;
  69                                 case "else": return TokenName.ELSE;
  70                                 case "eval": return TokenName.EVAL;
  71                                 case "false": return TokenName.FALSE;
  72                                 case "finally": return TokenName.FINALLY;
  73                                 case "for": return TokenName.FOR;
  74                                 case "function": return TokenName.FUNCTION;
  75                                 case "if": return TokenName.IF;
  76                                 case "in": return TokenName.IN;
  77                                 case "instanceof": return TokenName.INSTANCEOF;
  78                                 case "new": return TokenName.NEW;
  79                                 case "null": return TokenName.NULL;
  80                                 case "return": return TokenName.RETURN;
  81                                 case "switch": return TokenName.SWITCH;
  82                                 case "this": return TokenName.THIS;
  83                                 case "throw": return TokenName.THROW;
  84                                 case "true": return TokenName.TRUE;
  85                                 case "try": return TokenName.TRY;
  86                                 case "typeof": return TokenName.TYPEOF;
  87                                 case "void": return TokenName.VOID;
  88                                 case "while": return TokenName.WHILE;
  89                                 case "with": return TokenName.WITH;
  90                                 case "var": return TokenName.VAR;
  91
  92
  93                                 default:
  94                                         throw new LangError.ArgumentError("invalid keyword : %s", word);
  95                         }
  96
  97         }
  98
  99         public TokenName? matching(TokenName name) throws LangError
 100         {
 101
 102
 103             switch(name) {
 104                                 case TokenName.LEFT_PAREN: return TokenName.RIGHT_PAREN;
 105                                 case TokenName.RIGHT_PAREN: return TokenName.LEFT_PAREN;
 106                                 case TokenName.LEFT_CURLY: return TokenName.RIGHT_CURLY;
 107                                 case TokenName.RIGHT_CURLY: return TokenName.LEFT_CURLY;
 108                                 case TokenName.LEFT_BRACE: return TokenName.RIGHT_BRACE;
 109                                 case TokenName.RIGHT_BRACE: return TokenName.LEFT_BRACE;
 110                default:
 111                        throw new LangError.ArgumentError("invalid matching character : %s", name.to_string());
 112
 113            };
 114
 115             //return this.matchingNames.get(name);
 116         }
 117
 118         public bool isKeyword(string word) {
 119                 try {
 120                          this.keyword(word);
 121                                 return true;
 122             } catch (LangError e) {
 123                         return false;
 124                 }
 125         }
 126         /*
 127                 public TokenName punc (string ch) throws LangError
 128                 {
 129                         var x = this.puncNull(ch);
 130                         if (x == null) {
 131                                 throw new LangError.ArgumentError("invalid punctuation character : %s",ch);
 132                         }
 133                         return x;
 134
 135         }
 136         public bool isPunc(string ch) {
 137                 return this.puncNull(ch) != null;
 138         }
 139         */
 140         public TokenName puncFirstString (char ch)
 141         {
 142
 143                 switch(ch) {
 144                                 case ';': return TokenName.SEMICOLON;
 145                                 case ',': return TokenName.COMMA;
 146                                 case '?': return TokenName.HOOK;
 147                                 case ':': return TokenName.COLON;
 148                                 case '|': return TokenName.BITWISE_OR;
 149                                 case '^': return TokenName.BITWISE_XOR;
 150                                 case '&': return TokenName.BITWISE_AND;
 151                                 case '=': return TokenName.ASSIGN;
 152                                 case '<': return TokenName.LT;
 153                                 case '>': return TokenName.GT;
 154                                 case '+': return TokenName.PLUS;
 155                                 case '-': return TokenName.MINUS;
 156                                 case '*': return TokenName.MUL;
 157                                 case '/': return TokenName.DIV;
 158                                 case '%': return TokenName.MOD;
 159                                 case '!': return TokenName.NOT;
 160                                 case '~': return TokenName.BITWISE_NOT;
 161                                 case '0': return TokenName.DOT;
 162                                 case '[': return TokenName.LEFT_BRACE;
 163                                 case ']': return TokenName.RIGHT_BRACE;
 164                                 case '{': return TokenName.LEFT_CURLY;
 165                                 case '}': return TokenName.RIGHT_CURLY;
 166                                 case '(': return TokenName.LEFT_PAREN;
 167                                 case ')': return TokenName.RIGHT_PAREN;
 168                         }
 169                         return TokenName.UNKNOWN;
 170                 }
 171         public TokenName puncString (string ch)
 172         {
 173
 174                 switch(ch) {
 175
 176                                 case "||": return TokenName.OR;
 177                                 case "&&": return TokenName.AND;
 178                                 case "==": return TokenName.EQ;
 179                                 case "!=": return TokenName.NE;
 180                                 case "<<": return TokenName.LSH;
 181                                 case "<=": return TokenName.LE;
 182                                 case ">>": return TokenName.RSH;
 183                                 case ">=": return TokenName.GE;
 184                                 case "++": return TokenName.INCREMENT;
 185                                 case "--": return TokenName.DECREMENT;
 186
 187
 188                                 case "===": return TokenName.STRICT_EQ;
 189                                 case "!==": return TokenName.STRICT_NE;
 190                                 case ">>>": return TokenName.URSH;
 191
 192
 193                         default:
 194                                 return TokenName.UNKNOWN;
 195
 196
 197                         }
 198
 199         }
 200
 201
 202
 203         public bool isNumber (string str) {
 204             return Regex.match_simple("^(\\.[0-9]|[0-9]+\\.|[0-9])[0-9]*([eE][+-]?[0-9]+)?$",str);
 205         }
 206
 207         public bool  isHexDec (string str) {
 208             return Regex.match_simple("^0x[0-9A-Fa-f]+$",str);
 209         }
 210
 211         public bool isWordString (string str) {
 212             return Regex.match_simple("^[a-zA-Z0-9$_.]+$", str);
 213         }
 214         public bool isWordChar (char  c) {
 215                 return
 216                         (c >= 'a' && c <= 'z')
 217                         ||
 218                         (c >= 'A' && c <= 'Z')
 219                         ||
 220                         (c >= '0' && c <= '9')
 221                         ||
 222                         c == '$' || c == '.' || c == '_' ;
 223         }
 224
 225         public bool isSpace (string str) {
 226             return this.whitespaceNames.get(str) != null;
 227         }
 228             public bool isSpaceC (char str) {
 229                         var s = str.to_string();
 230             return this.whitespaceNames.get(s) != null;
 231         }
 232
 233         public bool isNewline (string str) {
 234             return this.newlineNames.get(str) != null;
 235                 }
 236         public bool isNewlineC (char str) {
 237                 var s =str.to_string();
 238             return this.newlineNames.get(s) != null;
 239         }
 240             public bool isBoolean (string str) {
 241                         var ss = str.down();
 242             return ss == "false" || ss == "true";
 243         }
 244
 245
 246
 247         void init() {
 248
 249             this.coreObjects = new GLib.List<string>();
 250
 251             this.whitespaceNames = new Gee.HashMap<string,string>();
 252             this.newlineNames = new Gee.HashMap<string,string>();
 253
 254
 255
 256
 257
 258
 259             string[] co = { "_global_", "Array", "Boolean", "Date", "Error",
 260                 "Function", "Math", "Number", "Object", "RegExp", "String" };
 261             for(var i =0; i< co.length;i++ ) {
 262                 this.coreObjects.append(co[i]);
 263                 //this.match_strings.add(co[i]);
 264             }
 265             string[] ws =  {
 266                 " :SPACE",
 267                 "\f:FORMFEED",
 268                 "\t:TAB" //,
 269               //  "\u0009:UNICODE_TAB",
 270               //  "\u000A:UNICODE_NBR",
 271               //  "\u0008:VERTICAL_TAB"
 272             };
 273             for(var i =0; i< ws.length;i++ ) {
 274                 var x = ws[i].split(":");
 275                 this.whitespaceNames.set(x[0],x[1]);
 276             }
 277
 278             ws = {
 279                 "\n:NEWLINE",
 280                 "\r:RETURN" //,
 281     //            "\u000A:UNICODE_LF",
 282       //          "\u000D:UNICODE_CR",
 283         //        "\u2029:UNICODE_PS",
 284           //      "\u2028:UNICODE_LS"
 285             };
 286             for(var i =0; i< ws.length;i++ ) {
 287                 var x = ws[i].split(":");
 288                 this.newlineNames.set(x[0],x[1]);
 289             }
 290
 291
 292                 // << was keywords here...
 293                 //this.match_strings.add(x[0].substring(1));
 294
 295
 296
 297
 298
 299
 300
 301
 302
 303         }
 304
 305
 306     }
 307 }