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                                 return null;
 114            };
 115
 116             //return this.matchingNames.get(name);
 117         }
 118
 119         public bool isKeyword(string word) {
 120                 try {
 121                         var x = this.keyword(word);
 122                                 return true;
 123             } catch (LangError e) {
 124                         return false;
 125                 }
 126         }
 127         /*
 128                 public TokenName punc (string ch) throws LangError
 129                 {
 130                         var x = this.puncNull(ch);
 131                         if (x == null) {
 132                                 throw new LangError.ArgumentError("invalid punctuation character : %s",ch);
 133                         }
 134                         return x;
 135
 136         }
 137         public bool isPunc(string ch) {
 138                 return this.puncNull(ch) != null;
 139         }
 140         */
 141         public TokenName puncFirstString (char ch)
 142         {
 143
 144                 switch(ch) {
 145                                 case ';': return TokenName.SEMICOLON;
 146                                 case ',': return TokenName.COMMA;
 147                                 case '?': return TokenName.HOOK;
 148                                 case ':': return TokenName.COLON;
 149                                 case '|': return TokenName.BITWISE_OR;
 150                                 case '^': return TokenName.BITWISE_XOR;
 151                                 case '&': return TokenName.BITWISE_AND;
 152                                 case '=': return TokenName.ASSIGN;
 153                                 case '<': return TokenName.LT;
 154                                 case '>': return TokenName.GT;
 155                                 case '+': return TokenName.PLUS;
 156                                 case '-': return TokenName.MINUS;
 157                                 case '*': return TokenName.MUL;
 158                                 case '/': return TokenName.DIV;
 159                                 case '%': return TokenName.MOD;
 160                                 case '!': return TokenName.NOT;
 161                                 case '~': return TokenName.BITWISE_NOT;
 162                                 case '0': return TokenName.DOT;
 163                                 case '[': return TokenName.LEFT_BRACE;
 164                                 case ']': return TokenName.RIGHT_BRACE;
 165                                 case '{': return TokenName.LEFT_CURLY;
 166                                 case '}': return TokenName.RIGHT_CURLY;
 167                                 case '(': return TokenName.LEFT_PAREN;
 168                                 case ')': return TokenName.RIGHT_PAREN;
 169                         }
 170                         return TokenName.UNKNOWN;
 171                 }
 172         public TokenName puncString (string ch)
 173         {
 174
 175                 switch(ch) {
 176
 177                                 case "||": return TokenName.OR;
 178                                 case "&&": return TokenName.AND;
 179                                 case "==": return TokenName.EQ;
 180                                 case "!=": return TokenName.NE;
 181                                 case "<<": return TokenName.LSH;
 182                                 case "<=": return TokenName.LE;
 183                                 case ">>": return TokenName.RSH;
 184                                 case ">=": return TokenName.GE;
 185                                 case "++": return TokenName.INCREMENT;
 186                                 case "--": return TokenName.DECREMENT;
 187
 188
 189                                 case "===": return TokenName.STRICT_EQ;
 190                                 case "!==": return TokenName.STRICT_NE;
 191                                 case ">>>": return TokenName.URSH;
 192
 193
 194                         default:
 195                                 return TokenName.UNKNOWN;
 196
 197
 198                         }
 199
 200         }
 201
 202
 203
 204         public bool isNumber (string str) {
 205             return Regex.match_simple("^(\\.[0-9]|[0-9]+\\.|[0-9])[0-9]*([eE][+-]?[0-9]+)?$",str);
 206         }
 207
 208         public bool  isHexDec (string str) {
 209             return Regex.match_simple("^0x[0-9A-Fa-f]+$",str);
 210         }
 211
 212         public bool isWordString (string str) {
 213             return Regex.match_simple("^[a-zA-Z0-9$_.]+$", str);
 214         }
 215         public bool isWordChar (char  c) {
 216                 return
 217                         (c >= 'a' && c <= 'z')
 218                         ||
 219                         (c >= 'A' && c <= 'Z')
 220                         ||
 221                         (c >= '0' && c <= '9')
 222                         ||
 223                         c == '$' || c == '.' || c == '_' ;
 224         }
 225
 226         public bool isSpace (string str) {
 227             return this.whitespaceNames.get(str) != null;
 228         }
 229             public bool isSpaceC (char str) {
 230                         var s = str.to_string();
 231             return this.whitespaceNames.get(s) != null;
 232         }
 233
 234         public bool isNewline (string str) {
 235             return this.newlineNames.get(str) != null;
 236                 }
 237         public bool isNewlineC (char str) {
 238                 var s =str.to_string();
 239             return this.newlineNames.get(s) != null;
 240         }
 241             public bool isBoolean (string str) {
 242                         var ss = str.down();
 243             return ss == "false" || ss == "true";
 244         }
 245
 246
 247
 248         void init() {
 249
 250             this.coreObjects = new GLib.List<string>();
 251
 252             this.whitespaceNames = new Gee.HashMap<string,string>();
 253             this.newlineNames = new Gee.HashMap<string,string>();
 254
 255
 256
 257
 258
 259
 260             string[] co = { "_global_", "Array", "Boolean", "Date", "Error",
 261                 "Function", "Math", "Number", "Object", "RegExp", "String" };
 262             for(var i =0; i< co.length;i++ ) {
 263                 this.coreObjects.append(co[i]);
 264                 //this.match_strings.add(co[i]);
 265             }
 266             string[] ws =  {
 267                 " :SPACE",
 268                 "\f:FORMFEED",
 269                 "\t:TAB" //,
 270               //  "\u0009:UNICODE_TAB",
 271               //  "\u000A:UNICODE_NBR",
 272               //  "\u0008:VERTICAL_TAB"
 273             };
 274             for(var i =0; i< ws.length;i++ ) {
 275                 var x = ws[i].split(":");
 276                 this.whitespaceNames.set(x[0],x[1]);
 277             }
 278
 279             ws = {
 280                 "\n:NEWLINE",
 281                 "\r:RETURN" //,
 282     //            "\u000A:UNICODE_LF",
 283       //          "\u000D:UNICODE_CR",
 284         //        "\u2029:UNICODE_PS",
 285           //      "\u2028:UNICODE_LS"
 286             };
 287             for(var i =0; i< ws.length;i++ ) {
 288                 var x = ws[i].split(":");
 289                 this.newlineNames.set(x[0],x[1]);
 290             }
 291
 292
 293                 // << was keywords here...
 294                 //this.match_strings.add(x[0].substring(1));
 295
 296
 297
 298
 299
 300
 301
 302
 303
 304         }
 305
 306
 307     }
 308 }