← Back to branch summary

~ubuntu-branches/ubuntu/quantal/aspectc++/quantal

« back to all changes in this revision

Viewing changes to Puma/src/parser/cparser/CSyntax.cc

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2008-04-10 17:40:52 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20080410174052-xdnsm7oi8hauyyf1
Tags: 1.0pre4~svn.20080409+dfsg-3
Fix another missing include, this time in Ag++/StdSystem.cc

Show diffs side-by-side

added added

removed removed

Lines of Context:
Puma/src/parser/cparser/CSyntax.cc
59
59
  while ((current = token_provider->current ())) {
60
60
    token = current->type ();
61
61
    
62
 
    // only declaration
63
 
    if (token == TOK_SEMI_COLON || 
64
 
        token == TOK_COMMA ||
65
 
        // TODO: checking the AspectC++ tokens here is really bad style
66
 
        token == TOK_ADVICE ||
67
 
        token == TOK_POINTCUT ||
68
 
        token == TOK_SLICE ||
69
 
        // --
70
 
        (! braces && token == TOK_ASSIGN)) {
71
 
      break;
72
 
    // operator name
73
 
    } else if (token == TOK_OPERATOR) {
74
 
      skip (TOK_OPEN_ROUND, false);
75
 
    // function `try' block, function body..
76
 
    } else if (token == TOK_TRY || (braces && 
77
 
               (token == TOK_OPEN_CURLY || token == TOK_COLON))) {
78
 
      result = true;
79
 
      break;
80
 
    // class definition in function return type
81
 
    } else if (token == TOK_OPEN_CURLY && ! braces) {
 
62
    // before function parameter list
 
63
    if (! braces) {
 
64
      // only declaration
 
65
      if (token == TOK_SEMI_COLON || 
 
66
          token == TOK_COMMA ||
 
67
          token == TOK_ASSIGN ||
 
68
          token == TOK_TYPEDEF) {
 
69
        break;
 
70
      // structure definition in function return type
 
71
      } else if (token == TOK_OPEN_CURLY) {
 
72
        skip_curly_block ();
 
73
      // array delimiter in return type
 
74
      } else if (token == TOK_OPEN_SQUARE) {
 
75
        skip_block (TOK_OPEN_SQUARE, TOK_CLOSE_SQUARE);
 
76
      // function parameter list
 
77
      } else if (token == TOK_OPEN_ROUND) {
 
78
        skip_round_block ();
 
79
        braces = true;
 
80
      // names etc.
 
81
      } else {
 
82
        token_provider->next ();
 
83
        locate_token ();
 
84
      }    
 
85
    // after function parameter list
 
86
    } else {
 
87
      // only declaration
 
88
      if (token == TOK_SEMI_COLON || 
 
89
          token == TOK_COMMA ||
 
90
          token == TOK_OPEN_ROUND) {
 
91
        break;
 
92
      // asm declaration specifier
 
93
      } else if (token == TOK_ASM) {
 
94
        skip ();
 
95
        skip_round_block ();
 
96
      // function body..
 
97
      } else if (token == TOK_OPEN_CURLY) {
 
98
        result = true;
 
99
        break;
 
100
      // K&R function parameter declaration
 
101
      } else {
 
102
        static int stop_tokens[] = { TOK_SEMI_COLON, 0 };
 
103
        skip (stop_tokens, true);
 
104
      }
 
105
    }
 
106
  }
 
107
 
 
108
  token_provider->set_state (s);
 
109
  return result;
 
110
}
 
111
 
 
112
bool CSyntax::is_ass_expr () {
 
113
  // result cache!
 
114
  static Token *last_token = 0;
 
115
  static bool last_result = false;
 
116
  
 
117
  Token *current = token_provider->current ();
 
118
  if (! current)
 
119
    return false;
 
120
 
 
121
  // return the last result if we check the same token
 
122
  if (last_token == current)
 
123
    return last_result;
 
124
  
 
125
  last_token = current;
 
126
  last_result = false;
 
127
  int token;
 
128
  State s = token_provider->get_state ();
 
129
 
 
130
  while ((current = token_provider->current ())) {
 
131
    token = current->type ();
 
132
 
 
133
    if (token == TOK_SEMI_COLON || token == TOK_COMMA ||
 
134
        token == TOK_CLOSE_CURLY || token == TOK_CLOSE_ROUND ||
 
135
        token == TOK_CLOSE_SQUARE || token == TOK_COLON ||
 
136
        token == TOK_QUESTION) {
 
137
      break;
 
138
    } else if (token == TOK_OPEN_CURLY) {
82
139
      skip_curly_block ();
83
 
    // member initialization list
84
 
    } else if (token == TOK_COLON && braces) {
85
 
      skip (TOK_OPEN_CURLY, false);
86
 
    // array delimiter
 
140
    } else if (token == TOK_OPEN_ROUND) {
 
141
      skip_round_block ();
87
142
    } else if (token == TOK_OPEN_SQUARE) {
88
143
      skip_block (TOK_OPEN_SQUARE, TOK_CLOSE_SQUARE);
89
 
    // template-id
90
 
    } else if (token == TOK_LESS) {
91
 
      skip_block (TOK_LESS, TOK_GREATER);
92
 
    // function parameter list
93
 
    } else if (token == TOK_OPEN_ROUND) {
94
 
      skip_round_block ();
95
 
      braces = true;
96
 
    // throw expression
97
 
    } else if (token == TOK_THROW) {
 
144
    } else if (token == TOK_ASSIGN || token == TOK_MUL_EQ ||
 
145
               token == TOK_DIV_EQ || token == TOK_MOD_EQ ||
 
146
               token == TOK_ADD_EQ || token == TOK_SUB_EQ ||
 
147
               token == TOK_RSH_EQ || token == TOK_LSH_EQ ||
 
148
               token == TOK_AND_EQ || token == TOK_XOR_EQ || 
 
149
               token == TOK_IOR_EQ) {
 
150
      last_result = true;
 
151
      break;
 
152
    } else {
98
153
      skip ();
99
 
      skip_round_block (); 
100
 
    // names etc.
101
 
    } else {
102
 
      token_provider->next ();
103
 
      locate_token ();
104
154
    }
105
155
  }
106
156
 
107
157
  token_provider->set_state (s);
108
 
  return result;
 
158
  return last_result;
109
159
}
110
160
 
111
161
/*****************************************************************************/
289
339
}
290
340
 
291
341
CTree *CSyntax::rule_cmpd_literal () { 
 
342
  // 5 : (  type_id  )  {  }
292
343
  // 6 : (  type_id  )  {  init_list  }
293
344
  consume (); // already checked by lookahead
294
345
  return (parse (&CSyntax::type_id) && 
295
346
          parse (TOK_CLOSE_ROUND) && 
296
 
          parse (TOK_OPEN_CURLY) && parse (&CSyntax::init_list) && 
 
347
          parse (TOK_OPEN_CURLY) && opt (parse (&CSyntax::init_list)) && 
297
348
          parse (TOK_CLOSE_CURLY)) ?
298
349
    builder ().cmpd_literal () : (CTree*)0;
299
350
}
379
430
}
380
431
 
381
432
CTree *CSyntax::cast_expr () { 
382
 
  // 1 : unary_expr
383
 
  // 2+: cast_expr1... unary_expr
384
 
  return /* (parse (&CSyntax::unary_expr) || */
385
 
          (opt (seq (&CSyntax::cast_expr1)) && parse (&CSyntax::unary_expr)) ?
 
433
  // 1: cast_expr1
 
434
  // 1: unary_expr
 
435
  return (parse (&CSyntax::cast_expr1) || parse (&CSyntax::unary_expr)) ?
386
436
    builder ().cast_expr () : (CTree*)0;
387
437
}
388
438
 
389
439
CTree *CSyntax::cast_expr1 () { 
390
 
  // 3: (  type_id  )
391
 
  return (parse (TOK_OPEN_ROUND) && parse (&CSyntax::type_id) && 
392
 
          parse (TOK_CLOSE_ROUND)) ?
 
440
  // 2+: cast_expr2... unary_expr
 
441
  return (seq (&CSyntax::cast_expr2) && parse (&CSyntax::unary_expr)) ?
393
442
    builder ().cast_expr1 () : (CTree*)0;
394
443
}
395
444
 
 
445
CTree *CSyntax::cast_expr2 () { 
 
446
  // 3: (  type_id  )
 
447
  return (parse (TOK_OPEN_ROUND) && parse (&CSyntax::type_id) && 
 
448
          parse (TOK_CLOSE_ROUND)) ?
 
449
    builder ().cast_expr2 () : (CTree*)0;
 
450
}
 
451
 
396
452
CTree *CSyntax::mul_expr () { 
397
453
  // 1 : cast_expr
398
454
  // 3+: cast_expr  any_mul_op  cast_expr ...
490
546
  static int any_ass_op[] = { TOK_ASSIGN, TOK_MUL_EQ, TOK_DIV_EQ, TOK_MOD_EQ, 
491
547
                              TOK_ADD_EQ, TOK_SUB_EQ, TOK_RSH_EQ, TOK_LSH_EQ,
492
548
                              TOK_AND_EQ, TOK_XOR_EQ, TOK_IOR_EQ, 0 };
493
 
  return (parse (&CSyntax::unary_expr) && parse (any_ass_op)) ? 
 
549
  return (is_ass_expr () && parse (&CSyntax::unary_expr) && parse (any_ass_op)) ? 
494
550
    builder ().ass_expr1 () : (CTree*)0;
495
551
}
496
552
 
666
722
  // 1: block_decl
667
723
  // 1: fct_def
668
724
  return (is_fct_def () ? parse (&CSyntax::fct_def) :
669
 
          (parse (&CSyntax::block_decl)/* ||
670
 
           parse (&CSyntax::fct_def)*/)) ? 
 
725
          (parse (&CSyntax::block_decl) ||
 
726
           parse (&CSyntax::fct_def))) ? 
671
727
    builder ().decl () : (CTree*)0;
672
728
}
673
729
 
674
730
CTree *CSyntax::block_decl () { 
675
731
  // 1: simple_decl
676
 
  return parse (&CSyntax::simple_decl) ? 
 
732
  // 1: asm_def
 
733
  return (parse (&CSyntax::simple_decl) ||
 
734
          parse (&CSyntax::asm_def))? 
677
735
    builder ().block_decl () : (CTree*)0;
678
736
}
679
737
 
682
740
  // 2: decl_spec_seq  ;
683
741
  // 3: decl_spec_seq  init_declarator_list  ;
684
742
  if (parse (TOK_SEMI_COLON) ||
685
 
      ((parse (&CSyntax::decl_spec_seq) ||
686
 
        semantic ().implicit_int ()) && 
687
 
             ((!look_ahead (TOK_SEMI_COLON) && 
 
743
      ((parse (&CSyntax::decl_spec_seq) || semantic ().implicit_int ()) && 
 
744
       ((! look_ahead (TOK_SEMI_COLON) && 
688
745
         parse (&CSyntax::init_declarator_list)),
689
746
        parse (TOK_SEMI_COLON)))) {
690
 
  semantic ().finish_decl ();
691
 
  return builder ().simple_decl ();
692
 
    }
693
 
    else
694
 
      return (CTree*)0;
 
747
    semantic ().finish_decl ();
 
748
    return builder ().simple_decl ();
 
749
  }
 
750
  return (CTree*)0;
695
751
}
696
752
 
697
753
void CSyntax::init_decl_spec () {
909
965
    semantic ().introduce_enumerator () : (CTree*)0;
910
966
}
911
967
 
 
968
CTree *CSyntax::asm_def () {
 
969
  // 1: ASM  (  str_literal  )  ;
 
970
  return (parse (TOK_ASM) && 
 
971
          parse (TOK_OPEN_ROUND) && str_literal () && 
 
972
          parse (TOK_CLOSE_ROUND) && parse (TOK_SEMI_COLON)) ?
 
973
    builder ().asm_def () : (CTree*)0;
 
974
}
 
975
 
912
976
/*****************************************************************************/
913
977
/*                                                                           */
914
978
/*                     A . 7   D e c l a r a t o r s                         */
922
986
    builder ().init_declarator_list () : (CTree*)0;
923
987
}
924
988
 
 
989
// this is only a hook for optional extension introduced by aspects
 
990
// TODO: better decouple syntax and semantic completely and weave advice
 
991
//       without hook
 
992
CTree *CSyntax::init_declarator_ext () {
 
993
  return 0; 
 
994
}
 
995
 
925
996
CTree *CSyntax::init_declarator () { 
926
997
  // 1: declarator
927
998
  // 2: declarator  init
 
999
  // 2: declarator  init_declarator_ext_list
 
1000
  // 3: declarator  init_declarator_ext_list init
928
1001
  if (! parse (&CSyntax::declarator)) {
929
1002
    semantic ().finish_declarator ();
930
1003
    return (CTree*)0;
931
1004
  }
932
1005
  
 
1006
  // parse optional init declarator extensions, such as GNU asm("symbol")
 
1007
  parse (&CSyntax::init_declarator_ext);
 
1008
 
933
1009
  // first introduce the new name (if any) 
934
1010
  // before parsing the intializer
935
1011
  CTree* id;
973
1049
 
974
1050
CTree *CSyntax::rule_direct_declarator1 () { 
975
1051
  // 3: [  array_delim  ]
976
 
  // 3: (  param_decl_clause  )
977
1052
  // 3: (  identifier_list  )
 
1053
  // 3: (  param_decl_clause  )
978
1054
  return ((look_ahead () == TOK_OPEN_ROUND && consume ()) ? 
979
1055
          ((parse (&CSyntax::identifier_list) ||
980
1056
            parse (&CSyntax::param_decl_clause)) &&
1174
1250
}
1175
1251
 
1176
1252
CTree *CSyntax::fct_def () { 
 
1253
  // 2: declarator  fct_body
1177
1254
  // 3: decl_spec_seq  declarator  fct_body
1178
1255
  // 4: decl_spec_seq  declarator  arg_decl_seq  fct_body
1179
 
  if (! (parse (&CSyntax::decl_spec_seq) && parse (&CSyntax::declarator))) {
 
1256
  if (! ((parse (&CSyntax::decl_spec_seq) || semantic ().implicit_int ()) && 
 
1257
         parse (&CSyntax::declarator))) {
1180
1258
    semantic ().finish_declarator ();
1181
1259
    return (CTree*)0;
1182
1260
  }