lib/as3/parser.y

   1 %{
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4 #include <memory.h>
   5 #include "abc.h"
   6 #include "pool.h"
   7 #include "files.h"
   8 #include "tokenizer.h"
   9 #include "registry.h"
  10 %}
  11
  12 //%glr-parser
  13 //%expect-rr 1
  14 %error-verbose
  15
  16 %union tokenunion {
  17     tokenptr_t token;
  18     multiname_t*multiname;
  19     multiname_list_t*multiname_list;
  20 }
  21
  22
  23 %token<token> T_IDENTIFIER
  24 %token<token> T_STRING
  25 %token<token> T_REGEXP
  26 %token<token> T_IMPLEMENTS
  27 %token<token> T_NAMESPACE
  28 %token<token> T_PACKAGE
  29 %token<token> T_PROTECTED
  30 %token<token> T_PUBLIC
  31 %token<token> T_PRIVATE
  32 %token<token> T_UINT
  33 %token<token> T_USE
  34 %token<token> T_INTERNAL
  35 %token<token> T_INT
  36 %token<token> T_NEW
  37 %token<token> T_NATIVE
  38 %token<token> T_FUNCTION
  39 %token<token> T_FOR
  40 %token<token> T_CLASS
  41 %token<token> T_CONST
  42 %token<token> T_SET
  43 %token<token> T_STATIC
  44 %token<token> T_IMPORT
  45 %token<token> T_INTERFACE
  46 %token<token> T_NUMBER
  47 %token<token> T_NULL
  48 %token<token> T_FALSE
  49 %token<token> T_TRUE
  50 %token<token> T_BOOLEAN
  51 %token<token> T_VAR
  52 %token<token> T_DYNAMIC
  53 %token<token> T_OVERRIDE
  54 %token<token> T_FINAL
  55 %token<token> T_GET
  56 %token<token> T_EXTENDS
  57 %token<token> T_EMPTY
  58 %token<token> T_EQEQ "=="
  59 %token<token> T_LE "<="
  60 %token<token> T_GE ">="
  61 %token<token> T_DIVBY "/="
  62 %token<token> T_MODBY "%="
  63 %token<token> T_PLUSBY "+="
  64 %token<token> T_MINUSBY "-="
  65 %token<token> T_SHRBY ">>="
  66 %token<token> T_SHLBY "<<="
  67 %token<token> T_USHRBY ">>>="
  68 %token<token> T_OROR "||"
  69 %token<token> T_ANDAND "&&"
  70 %token<token> T_COLONCOLON "::"
  71 %token<token> T_MINUSMINUS "--"
  72 %token<token> T_PLUSPLUS "++"
  73 %token<token> T_DOTDOT ".."
  74 %token<token> T_SHL "<<"
  75 %token<token> T_USHR ">>>"
  76 %token<token> T_SHR ">>"
  77 %token<token> T_IS "is"
  78 %token<token> T_AS "as"
  79 %token<token> T_SEMICOLON ';'
  80 %token<token> T_STAR '*'
  81 %token<token> T_DOT '.'
  82
  83 // precendence: from low to high
  84 // http://livedocs.adobe.com/flash/9.0/main/wwhelp/wwhimpl/common/html/wwhelp.htm?context=LiveDocs_Parts&file=00000012.html
  85
  86 %right '?' ':'
  87 %nonassoc '='
  88 %nonassoc "/=" "%="
  89 %nonassoc "+=" "-="
  90 %nonassoc ">>="
  91 %nonassoc "<<="
  92 %nonassoc ">>>="
  93 %nonassoc "||"
  94 %nonassoc "&&"
  95 %nonassoc '|'
  96 %nonassoc '^'
  97 %nonassoc '&'
  98 %nonassoc "!=" "==" "<=" '<' ">=" '>' // TODO: support "a < b < c" syntax?
  99 %nonassoc "is"
 100 %left '-'
 101 %left '+'
 102 %left "<<"
 103 %left ">>>"
 104 %left ">>"
 105 %left '%'
 106 %left '/'
 107 %left '*'
 108 %left '!'
 109 %left '~'
 110 %left "--" "++"
 111 %left '['
 112 %nonassoc "as"
 113 %left '.' ".." "::"
 114 %left '('
 115
 116 %type <token> CODE
 117 %type <token> CODEPIECE
 118 %type <token> PACKAGE_DECLARATION
 119 %type <token> FUNCTION_DECLARATION
 120 %type <token> VARIABLE_DECLARATION
 121 %type <token> CLASS_DECLARATION
 122 %type <token> NAMESPACE_DECLARATION
 123 %type <token> INTERFACE_DECLARATION
 124 %type <token> EXPRESSION
 125 %type <token> E
 126 %type <token> CONSTANT
 127 %type <token> FOR
 128 %type <token> USE
 129 %type <token> ASSIGNMENT
 130 %type <token> IMPORT
 131 %type <multiname> MAYBETYPE
 132 %type <token> PACKAGESPEC
 133 %type <token> GETSET
 134 %type <token> PARAM
 135 %type <token> PARAMS
 136 %type <token> PARAM_LIST
 137 %type <token> MODIFIERS
 138 %type <token> MODIFIER_LIST
 139 %type <multiname_list> IMPLEMENTS_LIST
 140 %type <multiname> EXTENDS
 141 %type <multiname_list> EXTENDS_LIST
 142 %type <multiname> PACKAGEANDCLASS
 143 %type <multiname_list> PACKAGEANDCLASS_LIST
 144 %type <token> MULTILEVELIDENTIFIER
 145 %type <multiname> TYPE
 146 %type <token> VAR
 147 %type <token> VARIABLE
 148 %type <token> NEW
 149 %type <token> FUNCTIONCALL
 150 %type <token> X_IDENTIFIER
 151 %type <token> MODIFIER
 152 %type <token> PACKAGE
 153
 154
 155 %{
 156
 157 static int yyerror(char*s)
 158 {
 159    syntaxerror("%s", s);
 160 }
 161 static token_t* concat2(token_t* t1, token_t* t2)
 162 {
 163     NEW(token_t,t);
 164     int l1 = strlen(t1->text);
 165     int l2 = strlen(t2->text);
 166     t->text = malloc(l1+l2+1);
 167     memcpy(t->text   , t1->text, l1);
 168     memcpy(t->text+l1, t2->text, l2);
 169     t->text[l1+l2] = 0;
 170     return t;
 171 }
 172 static token_t* concat3(token_t* t1, token_t* t2, token_t* t3)
 173 {
 174     NEW(token_t,t);
 175     int l1 = strlen(t1->text);
 176     int l2 = strlen(t2->text);
 177     int l3 = strlen(t3->text);
 178     t->text = malloc(l1+l2+l3+1);
 179     memcpy(t->text   , t1->text, l1);
 180     memcpy(t->text+l1, t2->text, l2);
 181     memcpy(t->text+l1+l2, t3->text, l3);
 182     t->text[l1+l2+l3] = 0;
 183     return t;
 184 }
 185
 186 typedef struct _import {
 187     char*path;
 188 } import_t;
 189
 190 DECLARE_LIST(import);
 191
 192 typedef struct _state {
 193     abc_file_t*file;
 194     abc_script_t*init;
 195
 196     int level;
 197
 198     char*package;
 199     char*function;
 200     import_list_t*imports;
 201
 202     /* class data */
 203     char*classname;
 204     abc_class_t*cls;
 205
 206 } state_t;
 207
 208 static state_t* state = 0;
 209
 210 DECLARE_LIST(state);
 211
 212 static state_list_t*state_stack=0;
 213
 214 void initialize_state()
 215 {
 216     NEW(state_t, s);
 217     NEW(state_list_t, sl);
 218     state_stack = sl;
 219     state = sl->state = s;
 220
 221     state->file = abc_file_new();
 222     state->level = 0;
 223
 224     state->init = abc_initscript(state->file, 0, 0);
 225     abc_method_body_t*m = state->init->method->body;
 226     __ getlocal_0(m);
 227     __ pushscope(m);
 228 }
 229 void* finalize_state()
 230 {
 231     if(state->level) {
 232         syntaxerror("unexpected end of file");
 233     }
 234     abc_method_body_t*m = state->init->method->body;
 235     //__ popscope(m);
 236     __ returnvoid(m);
 237     return state->file;
 238 }
 239
 240 static void new_state()
 241 {
 242     NEW(state_t, s);
 243     NEW(state_list_t, sl);
 244     memcpy(s, state, sizeof(state_t)); //shallow copy
 245     sl->next = state_stack;
 246     sl->state = s;
 247     state_stack = sl;
 248     state = s;
 249     state->level++;
 250 }
 251 static void old_state()
 252 {
 253     if(!state_stack || !state_stack->next)
 254         syntaxerror("invalid nesting");
 255     state_t*oldstate = state;
 256     state_list_t*old = state_stack;
 257     state_stack = state_stack->next;
 258     free(old);
 259     state = state_stack->state;
 260 }
 261
 262 static void startpackage(token_t*t)
 263 {
 264     if(state->package) {
 265         syntaxerror("Packages can not be nested.");
 266     }
 267     new_state();
 268     char*name = t?t->text:"";
 269     printf("entering package \"%s\"\n", name);
 270     state->package = name;
 271 }
 272 static void endpackage()
 273 {
 274     printf("leaving package \"%s\"\n", state->package);
 275     old_state();
 276 }
 277
 278 static void startclass(token_t*modifiers, token_t*name, multiname_t*extends, multiname_list_t*implements)
 279 {
 280     if(state->cls) {
 281         syntaxerror("inner classes now allowed");
 282     }
 283     new_state();
 284     state->classname = name->text;
 285     printf("entering class %s\n", name->text);
 286     token_list_t*t=0;
 287     printf("  modifiers: ");for(t=modifiers->tokens;t;t=t->next) printf("%s ", t->token->text);printf("\n");
 288     printf("  extends: %s\n", multiname_tostring(extends));
 289
 290     multiname_list_t*mlist=0;
 291     printf("  implements (%d): ", list_length(implements));
 292     for(mlist=implements;mlist;mlist=mlist->next)  {
 293         printf("%s ", multiname_tostring(mlist->multiname));
 294     }
 295     printf("\n");
 296
 297     char public=0,internal=0,final=0,sealed=1;
 298     for(t=modifiers->tokens;t;t=t->next) {
 299         if(t->token->type == T_INTERNAL) {
 300             /* the programmer is being explicit-
 301                being internal is the default anyway */
 302             internal = 1;
 303         } else if(t->token->type == T_PUBLIC) {
 304             public = 1;
 305         } else if(t->token->type == T_FINAL) {
 306             final = 1;
 307         } else {
 308             syntaxerror("modifier \"%s\" not supported in class declaration", t->token->text);
 309         }
 310     }
 311     if(public&&internal)
 312         syntaxerror("public and internal not supported at the same time.");
 313
 314     /* create the class name, together with the proper attributes */
 315     multiname_t* classname = 0;
 316     if(!public && !state->package)
 317         classname = multiname_new(namespace_new_private(current_filename), state->classname);
 318     else if(!public && state->package)
 319         classname = multiname_new(namespace_new_packageinternal(state->package), state->classname);
 320     else if(state->package)
 321         classname = multiname_new(namespace_new_package(state->package), state->classname);
 322     else
 323         syntaxerror("public classes only allowed inside a package");
 324
 325     state->cls = abc_class_new(state->file, classname, extends);
 326     if(final) abc_class_final(state->cls);
 327     if(sealed) abc_class_sealed(state->cls);
 328
 329     for(mlist=implements;mlist;mlist=mlist->next) {
 330         abc_class_add_interface(state->cls, mlist->multiname);
 331     }
 332
 333     /* now write the construction code for this class */
 334     int slotindex = abc_initscript_addClassTrait(state->init, classname, state->cls);
 335
 336     abc_method_body_t*m = state->init->method->body;
 337     __ getglobalscope(m);
 338     multiname_t*s = extends;
 339     int count=0;
 340     while(s) {
 341         //TODO: invert
 342         //TODO: take a look at the current scope stack, maybe
 343         //      we can re-use something
 344         __ getlex2(m, s);
 345         __ pushscope(m);
 346         s = registry_getsuperclass(s);
 347         count++;
 348     }
 349     /* TODO: if this is one of *our* classes, we can also
 350              do a getglobalscope/getslot <nr> (which references
 351              the init function's slots) */
 352     __ getlex2(m, extends);
 353     __ newclass(m,state->cls);
 354
 355     while(count--) {
 356         __ popscope(m);
 357     }
 358     __ setslot(m, slotindex);
 359 }
 360
 361 static void endclass()
 362 {
 363     printf("leaving class %s\n", state->classname);
 364     old_state();
 365 }
 366 static void addimport(token_t*t)
 367 {
 368     NEW(import_t,i);
 369     i->path = t->text;
 370     list_append(state->imports, i);
 371 }
 372 static void print_imports()
 373 {
 374     import_list_t*l = state->imports;
 375     while(l) {
 376         printf("  import %s\n", l->import->path);
 377         l = l->next;
 378     }
 379 }
 380 static void startfunction(token_t*ns, token_t*mod, token_t*getset, token_t*name,
 381                           token_t*params, multiname_t*type)
 382 {
 383     token_list_t*t;
 384     new_state();
 385     state->function = name->text;
 386     printf("entering function %s\n", name->text);
 387     if(ns)
 388         printf("  namespace: %s\n", ns->text);
 389     printf("  getset: %s\n", getset->text);
 390     printf("  params: ");for(t=params->tokens;t;t=t->next) printf("%s ", t->token->text);printf("\n");
 391     printf("  mod: ");for(t=mod->tokens;t;t=t->next) printf("%s ", t->token->text);printf("\n");
 392     printf("  type: %s\n", multiname_tostring(type));
 393     print_imports();
 394
 395     abc_method_body_t* m=0;
 396     if(!strcmp(state->classname,name->text)) {
 397         m = abc_class_constructor(state->cls, type, 0);
 398     } else {
 399         m = abc_class_method(state->cls, type, name->text, 0);
 400     }
 401
 402 }
 403 static void endfunction()
 404 {
 405     printf("leaving function %s\n", state->function);
 406     old_state();
 407 }
 408 static int newvariable(token_t*mod, token_t*varconst, token_t*name, multiname_t*type)
 409 {
 410     token_list_t*t;
 411     printf("defining new variable %s\n", name->text);
 412     printf("  mod: ");for(t=mod->tokens;t;t=t->next) printf("%s ", t->token->text);printf("\n");
 413     printf("  access: ");printf("%s\n", varconst->text);
 414     printf("  type: ");printf("%s\n", multiname_tostring(type));
 415 }
 416 static token_t* empty_token()
 417 {
 418     NEW(token_t,t);
 419     t->type=T_EMPTY;
 420     t->text=0;
 421     return t;
 422 }
 423
 424 void extend(token_t*list, token_t*add) {
 425     list_append(list->tokens,add);
 426     if(!list->text)
 427         list->text = add->text;
 428 }
 429 void extend_s(token_t*list, char*seperator, token_t*add) {
 430     list_append(list->tokens,add);
 431     char*t1 = list->text;
 432     char*t2 = seperator;
 433     char*t3 = add->text;
 434     int l1 = strlen(t1);
 435     int l2 = strlen(t2);
 436     int l3 = strlen(t3);
 437     list->text = malloc(l1+l2+l3+1);
 438     strcpy(list->text, t1);
 439     strcpy(list->text+l1, t2);
 440     strcpy(list->text+l1+l2, t3);
 441     list->text[l1+l2+l3]=0;
 442 }
 443
 444 %}
 445
 446 %%
 447
 448 PROGRAM: MAYBECODE
 449
 450 MAYBECODE: CODE
 451 MAYBECODE:
 452
 453 CODE: CODE CODEPIECE {$$=$1;}
 454 CODE: CODEPIECE {$$=empty_token();}
 455
 456 CODEPIECE: ';'
 457 CODEPIECE: VARIABLE_DECLARATION {$$=$1;}
 458 CODEPIECE: PACKAGE_DECLARATION
 459 CODEPIECE: IMPORT
 460 CODEPIECE: NAMESPACE_DECLARATION
 461 CODEPIECE: CLASS_DECLARATION
 462 CODEPIECE: INTERFACE_DECLARATION
 463 CODEPIECE: FUNCTION_DECLARATION
 464 CODEPIECE: EXPRESSION
 465 CODEPIECE: FOR
 466 CODEPIECE: USE
 467 CODEPIECE: ASSIGNMENT
 468
 469 PACKAGE_DECLARATION : T_PACKAGE MULTILEVELIDENTIFIER '{' {startpackage($2)} MAYBECODE '}' {endpackage()}
 470 PACKAGE_DECLARATION : T_PACKAGE '{' {startpackage(0)} MAYBECODE '}' {endpackage()}
 471
 472 IMPORT : T_IMPORT PACKAGESPEC {addimport($2);}
 473
 474 TYPE : PACKAGEANDCLASS {$$=$1;}
 475      | '*'        {$$=registry_getanytype();}
 476      |  T_STRING  {$$=registry_getstringclass();}
 477      |  T_INT     {$$=registry_getintclass();}
 478      |  T_UINT    {$$=registry_getuintclass();}
 479      |  T_BOOLEAN {$$=registry_getbooleanclass();}
 480      |  T_NUMBER  {$$=registry_getnumberclass();}
 481
 482 MAYBETYPE: ':' TYPE {$$=$2;}
 483 MAYBETYPE:          {$$=0;}
 484
 485 //FUNCTION_HEADER:      NAMESPACE MODIFIERS T_FUNCTION GETSET T_IDENTIFIER '(' PARAMS ')'
 486 FUNCTION_HEADER:      MODIFIERS T_FUNCTION GETSET T_IDENTIFIER '(' PARAMS ')'
 487                       MAYBETYPE
 488 FUNCTION_DECLARATION: MODIFIERS T_FUNCTION GETSET T_IDENTIFIER '(' PARAMS ')'
 489                       MAYBETYPE '{' {startfunction(0,$1,$3,$4,$6,$8)} MAYBECODE '}' {endfunction()}
 490
 491 NAMESPACE_DECLARATION : MODIFIERS T_NAMESPACE T_IDENTIFIER
 492 NAMESPACE_DECLARATION : MODIFIERS T_NAMESPACE T_IDENTIFIER '=' T_IDENTIFIER
 493 NAMESPACE_DECLARATION : MODIFIERS T_NAMESPACE T_IDENTIFIER '=' T_STRING
 494
 495 //NAMESPACE :              {$$=empty_token();}
 496 //NAMESPACE : T_IDENTIFIER {$$=$1};
 497
 498 CONSTANT : T_NUMBER
 499 CONSTANT : T_STRING
 500 CONSTANT : T_TRUE
 501 CONSTANT : T_FALSE
 502 CONSTANT : T_NULL
 503
 504 VAR : T_CONST | T_VAR
 505
 506 // type annotation
 507 // TODO: NAMESPACE
 508
 509 VARIABLE_DECLARATION : MODIFIERS VAR T_IDENTIFIER MAYBETYPE {
 510     int i = newvariable($1,$2,$3,$4);
 511 }
 512 VARIABLE_DECLARATION : MODIFIERS VAR T_IDENTIFIER MAYBETYPE '=' EXPRESSION {
 513     int i = newvariable($1,$2,$3,$4);
 514     //setvariable(i,$6);
 515 }
 516
 517 EXPRESSION : E
 518
 519 E : CONSTANT
 520 E : VARIABLE
 521 E : NEW
 522 E : T_REGEXP
 523 E : FUNCTIONCALL
 524 E : E '<' E
 525 E : E '>' E
 526 E : E "<=" E
 527 E : E ">=" E
 528 E : E "==" E
 529 E : E '+' E
 530 E : E '-' E
 531 E : E '/' E
 532 E : E '%' E
 533 E : E '*' E
 534 E : E "++"
 535 E : E "--"
 536 E : E "as" TYPE
 537 E : E "is" TYPE
 538
 539 //E : '(' E ')'  // conflicts with function calls: "a=f(c++);"<->"a=f;(c++)"
 540 //E : '-' E      // conflicts with non-assignment statements: "a=3-1;"<->"a=3;-1"
 541
 542 NEW : T_NEW T_IDENTIFIER
 543     | T_NEW T_IDENTIFIER '(' ')'
 544     | T_NEW T_IDENTIFIER '(' EXPRESSION_LIST ')'
 545
 546 FUNCTIONCALL : VARIABLE '(' EXPRESSION_LIST ')'
 547 FUNCTIONCALL : VARIABLE '(' ')'
 548
 549 EXPRESSION_LIST : EXPRESSION
 550 EXPRESSION_LIST : EXPRESSION_LIST ',' EXPRESSION
 551
 552 VARIABLE : T_IDENTIFIER
 553 VARIABLE : VARIABLE '.' T_IDENTIFIER
 554 VARIABLE : VARIABLE ".." T_IDENTIFIER // descendants
 555 VARIABLE : VARIABLE "::" VARIABLE // namespace declaration
 556 VARIABLE : VARIABLE "::" '[' EXPRESSION ']' // qualified expression
 557 VARIABLE : VARIABLE '[' EXPRESSION ']' // unqualified expression
 558
 559 ASSIGNMENT :           VARIABLE           '=' EXPRESSION
 560 NEW_ASSIGNMENT : T_VAR VARIABLE MAYBETYPE '=' EXPRESSION
 561
 562 FOR : T_FOR '(' NEW_ASSIGNMENT ';' EXPRESSION ';' EXPRESSION ')' '{' MAYBECODE '}'
 563 FOR : T_FOR '(' ASSIGNMENT     ';' EXPRESSION ';' EXPRESSION ')' '{' MAYBECODE '}'
 564
 565 USE : T_USE T_NAMESPACE T_IDENTIFIER
 566
 567 // keywords which also may be identifiers
 568 X_IDENTIFIER : T_IDENTIFIER | T_PACKAGE
 569
 570 PACKAGESPEC : PACKAGESPEC '.' PACKAGESPEC {if($1->text[0]=='*') syntaxerror("wildcard in the middle of path");
 571                                            $$ = concat3($1,$2,$3);}
 572 PACKAGESPEC : X_IDENTIFIER                {$$=$1;}
 573 PACKAGESPEC : '*'                         {$$=$1;}
 574
 575 GETSET : T_GET {$$=$1;}
 576        | T_SET {$$=$1;}
 577        |       {$$=empty_token();}
 578
 579 CLASS_DECLARATION : MODIFIERS T_CLASS T_IDENTIFIER EXTENDS IMPLEMENTS_LIST '{' {startclass($1,$3,$4,$5);} MAYBE_DECLARATION_LIST '}' {endclass();}
 580 INTERFACE_DECLARATION : MODIFIERS T_INTERFACE T_IDENTIFIER EXTENDS_LIST '{' MAYBE_IDECLARATION_LIST '}'
 581
 582 PARAMS: {$$=empty_token();}
 583 PARAMS: PARAM_LIST {$$=$1;}
 584 PARAM_LIST: PARAM_LIST ',' PARAM {extend($1,$3);$$=$1;}
 585 PARAM_LIST: PARAM                {$$=empty_token();extend($$,$1);}
 586 PARAM:  T_IDENTIFIER ':' TYPE {$$=$1;}
 587
 588 MODIFIERS : {$$=empty_token();}
 589 MODIFIERS : MODIFIER_LIST {$$=$1}
 590 MODIFIER_LIST : MODIFIER MODIFIER_LIST {extend($2,$1);$$=$2;}
 591 MODIFIER_LIST : MODIFIER               {$$=empty_token();extend($$,$1);}
 592 MODIFIER : T_PUBLIC | T_PRIVATE | T_PROTECTED | T_STATIC | T_DYNAMIC | T_FINAL | T_OVERRIDE | T_NATIVE | T_INTERNAL
 593
 594 DECLARATION : VARIABLE_DECLARATION
 595 DECLARATION : FUNCTION_DECLARATION
 596
 597 IDECLARATION : VARIABLE_DECLARATION
 598 IDECLARATION : FUNCTION_DECLARATION
 599
 600 IMPLEMENTS_LIST : {$$=list_new();}
 601 IMPLEMENTS_LIST : T_IMPLEMENTS PACKAGEANDCLASS_LIST {$$=$2;}
 602
 603 EXTENDS : {$$=registry_getobjectclass();}
 604 EXTENDS : T_EXTENDS PACKAGEANDCLASS {$$=$2;}
 605
 606 EXTENDS_LIST : {$$=list_new();}
 607 EXTENDS_LIST : T_EXTENDS PACKAGEANDCLASS_LIST {$$=$2;}
 608
 609 //IDENTIFIER_LIST : T_IDENTIFIER ',' IDENTIFIER_LIST {extend($3,$1);$$=$3;}
 610 //IDENTIFIER_LIST : T_IDENTIFIER                     {$$=empty_token();extend($$,$1);}
 611
 612 PACKAGEANDCLASS : T_IDENTIFIER {$$ = registry_findclass(state->package, $1->text);}
 613 PACKAGEANDCLASS : PACKAGE '.' T_IDENTIFIER {$$ = registry_findclass($1->text, $3->text);}
 614 PACKAGE : X_IDENTIFIER
 615 PACKAGE : PACKAGE '.' X_IDENTIFIER {$$=$1;extend_s($$,".",$3);}
 616
 617 MULTILEVELIDENTIFIER : MULTILEVELIDENTIFIER '.' X_IDENTIFIER {$$=$1;extend_s($$, ".", $3)}
 618 MULTILEVELIDENTIFIER : T_IDENTIFIER                 {$$=$1;extend($$,$1)};
 619
 620 PACKAGEANDCLASS_LIST : PACKAGEANDCLASS {$$=list_new();list_append($$, $1);}
 621 PACKAGEANDCLASS_LIST : PACKAGEANDCLASS_LIST ',' PACKAGEANDCLASS {$$=$1;list_append($$,$3);}
 622
 623 MAYBE_DECLARATION_LIST :
 624 MAYBE_DECLARATION_LIST : DECLARATION_LIST
 625 DECLARATION_LIST : DECLARATION
 626 DECLARATION_LIST : DECLARATION_LIST DECLARATION
 627
 628 MAYBE_IDECLARATION_LIST :
 629 MAYBE_IDECLARATION_LIST : IDECLARATION_LIST
 630 IDECLARATION_LIST : IDECLARATION
 631 IDECLARATION_LIST : IDECLARATION_LIST FUNCTION_HEADER
 632
 633 // chapter 14
 634 // keywords: as break case catch class const continue default delete do else extends false finally for function if implements import in instanceof interface internal is native new null package private protected public return super switch this throw to true try typeof use var void while with
 635 // syntactic keywords: each get set namespace include dynamic final native override static
 636