source/shapesparser.yy

   1 /* This file is part of Shapes.
   2  *
   3  * Shapes is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * any later version.
   7  *
   8  * Shapes is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with Shapes.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  * Copyright 2008 Henrik Tidefelt
  17  */
  18
  19 /* File: shapesparser.y
  20  * --------------
  21  * Yacc input file to generate the parser for the Shapes language
  22  */
  23
  24 %{
  25
  26 /* Just like lex, the text within this first region delimited by %{ and %}
  27  * is assumed to be C/C++ code and will be copied verbatim to the y.tab.c
  28  * file ahead of the definitions of the yyparse() function. Add other header
  29  * file inclusions or C++ variable declarations/prototypes that are needed
  30  * by your code here.
  31  */
  32 #include "shapestypes.h"
  33 #include "ast.h"
  34 #include "astflow.h"
  35 #include "astexprs.h"
  36 #include "astfun.h"
  37 #include "astvalues.h"
  38 #include "astvar.h"
  39 #include "astidentifier.h"
  40 #include "astclass.h"
  41 #include "shapesexceptions.h"
  42 #include "consts.h"
  43 #include "charptrless.h"
  44 #include "autoonoff.h"
  45 #include "shapescore.h"
  46 #include "texlabelmanager.h"
  47
  48 using namespace Shapes;
  49 #include "yyltype.h"
  50 extern YYLTYPE shapeslloc;
  51
  52 #ifdef yylex
  53         /* This is ugly.
  54          * Warning! Warning! Warning!
  55          * We'll soon use that yylex was defined as
  56          *       #define yylex shapeslex
  57          * in order to reset it after we're done with the inclusion.
  58          */
  59 #undef yylex
  60 #include "globals.h"
  61 #include "shapesscanner.h"
  62 int shapeslex( )
  63 {
  64         return Ast::theShapesScanner.yylex( );
  65 }
  66 #define yylex shapeslex
  67 #endif
  68
  69 #include "refcount.h"
  70
  71 #include <list>
  72 #include <map>
  73 #include <sstream>
  74
  75 using namespace std;
  76
  77
  78 int shapeslex( );
  79
  80
  81 void shapeserror( RefCountPtr< const char > msg )
  82 {
  83         throw Exceptions::ParserError( shapeslloc, msg );
  84 }
  85
  86 void shapeserror( char * msg )
  87 {
  88         shapeserror( strrefdup( msg ) );
  89 }
  90
  91
  92 %}
  93
  94 /*
  95  * The section before the first %% is the Definitions section of the yacc
  96  * input file. Here is where you declare tokens and types, add precedence
  97  * and associativity options, and so on.
  98  */
  99
 100 /*
 101  * yylval
 102  * ------
 103  * Here we define the type of the yylval global variable that is used by
 104  * the scanner to store attibute information about the token just scanned
 105  * and thus communicate that information to the parser. You will need to
 106  * add new fields to this union as you add different attributes to your
 107  * non-terminal symbols.
 108  */
 109
 110 %union {
 111         Ast::Expression * expr;
 112         Ast::Node * node;
 113         Ast::MethodIdExpr * methodId;
 114         std::list< Ast::Node * > * nodeList;
 115         std::list< Ast::Expression * > * exprList;
 116         std::list< RefCountPtr< const char > > * strList;
 117         std::map< const char *, Ast::Expression *, charPtrLess > * namedExprMap;
 118         Kernel::Formals * formals;
 119         std::list< Kernel::Formals * > * formalsList;
 120         Ast::ArgListExprs * argList;
 121         Ast::SplitDefineVariables * splitFormals;
 122         int intVal;
 123         double floatVal;
 124         bool boolVal;
 125         char * str;
 126         int tokenID;
 127         std::list< const Ast::CallExpr * > * callExprList;
 128         std::list< Ast::ClassSection * > * classSectionList;
 129         Ast::ClassSection * classSection;
 130         Ast::MemberSection * memberSection;
 131         Ast::MemberDeclaration * memberDeclaration;
 132         Ast::StateReference * stateReference;
 133         Ast::MemberMode memberMode;
 134         Ast::ClassMode classMode;
 135         Ast::FunctionMode functionMode;
 136 }
 137
 138
 139 /* Tokens
 140  * ------
 141  * Here we tell yacc about all the token types that we are using.
 142  * Yacc will assign unique numbers to these and export the #define
 143  * in the generated y.tab.h header file.
 144  */
 145
 146 %token <tokenID> T_EOF T_minusminus T_plusplus T_ddot T_dddot T_assign T_eqeq T_eqneq T_atat T_projection T_angle T_ampersandMore
 147 %token <tokenID> T_cycle T_and T_or T_xor T_not T_mapsto T_emptybrackets T_dddotbrackets T_bangbrackets T_bangdddotbrackets T_compose T_surrounding T_lesseq T_greatereq T_llthan T_ggthan T_declaretype T_bangbang
 148 %token <tokenID> T_tex T_dynamic T_continuation T_continue T_esc_continuation T_esc_continue
 149 %token <tokenID> T_class T_members T_prepare T_abstract T_overrides T_gr__
 150 %token <tokenID> T_split T_splitLeft T_splitRight T_unionLeft T_unionRight
 151  // %token <tokenID>    T_letdst T_plusassign T_minusassign T_starassign T_slashassign
 152
 153 %token <intVal> T_int
 154 %token <floatVal> T_float T_length
 155 %token <expr> T_speciallength
 156 %token <boolVal> T_bool
 157 %token <str> T_string T_identifier T_dynamic_identifier T_state_identifier T_dynamic_state_identifier T_typename
 158
 159 /* Non-terminal types
 160  * ------------------
 161  * In order for yacc to assign/access the correct field of $$, $1, we
 162  * must to declare which field is appropriate for the non-terminal.
 163  * As an example, this first type declaration establishes that the DeclList
 164  * non-terminal uses the field named "declList" in the yylval union. This
 165  * means that when we are setting $$ for a reduction for DeclList ore reading
 166  * $n which corresponds to a DeclList nonterminal we are accessing the field
 167  * of the union named "declList" which is of type List<Decl*>.
 168  * pp2: You'll need to add many of these of your own.
 169  */
 170
 171 %type <expr> Program Expr ExprExceptConstStrings DynamicBinding CallExpr CurryCallExpr MutateExpr Function OperatorFunction Class ConstantExceptStrings Coords PolarHandle
 172 %type <expr> CodeBracket SuperCall SuperMemberReference
 173 %type <exprList> InsertionSequence
 174 %type <node> GroupElem
 175 %type <nodeList> Group OneOrMoreGroupElems
 176 %type <strList> OrderedFormals OneOrMoreOrderedFormals
 177 %type <formals> Formals OneOrMoreFormalsItems
 178  //                                     %type <formalsList> NamedFormalsWithOrder OneOrMoreNamedFormalsWithOrder
 179 %type <argList> ArgList OneOrMoreArgListItems
 180 %type <methodId> MethodIdentifier
 181 %type <callExprList> ListOfParentsWithInitargs;
 182 %type <classSectionList> ClassSections OneOrMoreClassSections
 183 %type <classSection> ClassSection
 184 %type <memberSection> MemberDeclarations OneOrMoreMemberDeclarations
 185 %type <memberSection> MethodDeclarations OneOrMoreMethodDeclarations
 186 %type <memberDeclaration> MemberDeclaration MethodDeclaration
 187 %type <memberMode> MemberAccessList MemberAccessSpecifier
 188 %type <classMode> ClassModeList ClassModeSpecifier OneOrMoreClassModeSpecifiers
 189 %type <functionMode> FunctionModeList OneOrMoreFunctionModeSpecifiers FunctionModeSpecifier
 190 %type <expr> Split
 191 %type <stateReference> StateReference
 192 %type <splitFormals> SplitFormals OneOrMoreSplitFormals
 193
 194 %nonassoc T_assign ':'
 195 %left ']' T_splitRight
 196 %left T_llthan
 197 %nonassoc T_bangbang
 198 %right '|'
 199 %right T_mapsto T_emptybrackets T_bangbrackets
 200 %left T_dddotbrackets T_bangdddotbrackets
 201 %left T_ampersandMore
 202 %left '&'
 203 %nonassoc T_dynamiccolon
 204 %left T_or T_xor
 205 %left T_and
 206 %left T_not
 207 %nonassoc T_eqeq T_eqneq
 208 %left T_plusplus T_minusminus
 209 %left '<' '>'
 210 %nonassoc T_lesseq T_greatereq
 211 %left '+' '-'
 212 %nonassoc T_angle
 213 %left '*' '/' T_projection
 214 %left '~'
 215 %left T_compose
 216 %left '[' '.' T_splitLeft
 217 %left '#'
 218 %left T_split
 219 %left T_atat T_surrounding
 220
 221 %nonassoc ')'
 222 %left ','
 223
 224 %start Program
 225
 226 %name-prefix="shapes"
 227
 228 %%
 229 /*
 230  * All productions and actions should be placed between the start and stop
 231  * %% markers which delimit the Rules section.
 232  */
 233
 234 Program
 235 : Group T_EOF
 236 {
 237         $$ = new Ast::CodeBracket( @1, $1 );
 238         Ast::theProgram = $$;
 239         YYACCEPT;
 240 }
 241 | Group error
 242 {
 243         shapeserror( "Expecting end of file." );
 244 }
 245 ;
 246
 247
 248 Coords
 249 : '(' Expr ',' Expr ')'
 250 {
 251         Ast::ArgListExprs * args = new Ast::ArgListExprs( true );
 252         args->orderedExprs_->push_back( $2 );
 253         args->orderedExprs_->push_back( $4 );
 254         $$ = new Ast::CallExpr( @$,
 255                                                                                                         Ast::THE_FUNCTION_coords2D,
 256                                                                                                         args );
 257 }
 258 | '(' Expr ',' Expr '^' Expr ')'
 259 {
 260         Ast::ArgListExprs * args = new Ast::ArgListExprs( true );
 261         args->orderedExprs_->push_back( $2 );
 262         args->orderedExprs_->push_back( $4 );
 263         args->orderedExprs_->push_back( $6 );
 264         $$ = new Ast::CallExpr( @$,
 265                                                                                                         Ast::THE_FUNCTION_cornercoords2D,
 266                                                                                                         args );
 267 }
 268 | '(' Expr ',' Expr '^' ')'
 269 {
 270         Ast::ArgListExprs * args = new Ast::ArgListExprs( true );
 271         args->orderedExprs_->push_back( $2 );
 272         args->orderedExprs_->push_back( $4 );
 273         $$ = new Ast::CallExpr( @$,
 274                                                                                                         Ast::THE_FUNCTION_cornercoords2D,
 275                                                                                                         args );
 276 }
 277 | '(' Expr ',' Expr ',' Expr ')'
 278 {
 279         Ast::ArgListExprs * args = new Ast::ArgListExprs( true );
 280         args->orderedExprs_->push_back( $2 );
 281         args->orderedExprs_->push_back( $4 );
 282         args->orderedExprs_->push_back( $6 );
 283         $$ = new Ast::CallExpr( @$,
 284                                                                                                         Ast::THE_FUNCTION_coords3D,
 285                                                                                                         args );
 286 }
 287 ;
 288
 289
 290 PolarHandle
 291 : '(' Expr '^' Expr ')'
 292 {
 293         $$ = new Ast::PolarHandle2DExpr( @$, $2, $4 );
 294 }
 295 | '(' Expr '^' ')'
 296 {
 297         $$ = new Ast::PolarHandle2DExprFree_a( @$, $2 );
 298 }
 299 | '(' '^' Expr ')'
 300 {
 301         Ast::ArgListExprs * args = new Ast::ArgListExprs( true );
 302         args->orderedExprs_->push_back( $3 );
 303         $$ = new Ast::CallExpr( @$,
 304                                                                                                         Ast::THE_FUNCTION_polarHandle2DFree_r,
 305                                                                                                         args );
 306 }
 307 | '(' '^' ')'
 308 {
 309         Ast::ArgListExprs * args = new Ast::ArgListExprs( true );
 310         $$ = new Ast::CallExpr( @$,
 311                                                                                                         Ast::THE_FUNCTION_polarHandle2DFree_ra,
 312                                                                                                         args );
 313 }
 314 ;
 315
 316 StateReference
 317 : T_state_identifier
 318 {
 319         $$ = new Ast::LexiographicState( @1, $1, new Kernel::Environment::LexicalKey * ( 0 ) );
 320 }
 321 | T_dynamic_state_identifier
 322 {
 323         $$ = new Ast::DynamicState( @1, $1 );
 324 }
 325 ;
 326
 327 ArgList
 328 :
 329 {
 330         $$ = new Ast::ArgListExprs( true );
 331 }
 332 | OneOrMoreArgListItems
 333 ;
 334
 335 OneOrMoreArgListItems
 336 : Expr
 337 {
 338         $$ = new Ast::ArgListExprs( true );
 339         $$->orderedExprs_->push_back( $1 );
 340 }
 341 | StateReference
 342 {
 343         $$ = new Ast::ArgListExprs( true );
 344         $$->orderedStates_->push_back( $1 );
 345 }
 346 | T_identifier ':' Expr
 347 {
 348         $$ = new Ast::ArgListExprs( true );
 349         (*$$->namedExprs_)[ $1 ] = $3;
 350 }
 351 | T_state_identifier ':' StateReference
 352 {
 353         $$ = new Ast::ArgListExprs( true );
 354         (*$$->namedStates_)[ $1 ] = $3;
 355 }
 356 | OneOrMoreArgListItems Expr
 357 {
 358         $$ = $1;
 359         if( ! $$->namedExprs_->empty( ) )
 360                 {
 361                         Ast::theAnalysisErrorsList.push_back( new Exceptions::ParserError( @2, strrefdup( "Unnamed expressions may not appear among named expressions." ) ) );
 362                 }
 363         $$->orderedExprs_->push_back( $2 );
 364 }
 365 | OneOrMoreArgListItems StateReference
 366 {
 367         $$ = $1;
 368         if( ! $$->namedStates_->empty( ) )
 369                 {
 370                         Ast::theAnalysisErrorsList.push_back( new Exceptions::ParserError( @2, strrefdup( "Unnamed states may not appear among named states." ) ) );
 371                 }
 372         $$->orderedStates_->push_back( $2 );
 373 }
 374 | OneOrMoreArgListItems T_identifier ':' Expr
 375 {
 376         $$ = $1;
 377         if( $$->namedExprs_->find( $2 ) != $$->namedExprs_->end( ) )
 378                 {
 379                         Ast::theAnalysisErrorsList.push_back( new Exceptions::RepeatedFormal( @2, $2 ) );
 380                 }
 381         (*$$->namedExprs_)[ $2 ] = $4;
 382 }
 383 | OneOrMoreArgListItems T_state_identifier ':' StateReference
 384 {
 385         $$ = $1;
 386         if( $$->namedStates_->find( $2 ) != $$->namedStates_->end( ) )
 387                 {
 388                         Ast::theAnalysisErrorsList.push_back( new Exceptions::RepeatedFormal( @2, $2 ) );
 389                 }
 390         (*$$->namedStates_)[ $2 ] = $4;
 391 }
 392 ;
 393
 394
 395 CallExpr
 396 : '[' Expr ArgList ']'
 397 {
 398         $$ = new Ast::CallExpr( @$, $2, $3 );
 399 }
 400 | Expr T_emptybrackets Expr
 401 {
 402         Ast::ArgListExprs * args = new Ast::ArgListExprs( true );
 403         args->orderedExprs_->push_back( $3 );
 404         $$ = new Ast::CallExpr( @$,
 405                                                                                                         $1,
 406                                                                                                         args );
 407 }
 408 | Expr T_emptybrackets Split
 409 {
 410         $$ = new Ast::CallSplitExpr( @$,
 411                                                                                                                          $1,
 412                                                                                                                          $3 );
 413 }
 414 | Expr T_dddotbrackets Expr
 415 {
 416         Ast::ArgListExprs * args = new Ast::ArgListExprs( true );
 417         args->orderedExprs_->push_back( $3 );
 418         $$ = new Ast::CallExpr( @$,
 419                                                                                                         $1,
 420                                                                                                         args,
 421                                                                                                         true ); /* true means Curry */
 422 }
 423 | Expr T_dddotbrackets T_identifier ':' Expr %prec T_dynamiccolon
 424 {
 425         Ast::ArgListExprs * args = new Ast::ArgListExprs( true );
 426         (*args->namedExprs_)[ $3 ] = $5;
 427         $$ = new Ast::CallExpr( @$,
 428                                                                                                         $1,
 429                                                                                                         args,
 430                                                                                                         true ); /* true means Curry */
 431 }
 432 | Expr T_dddotbrackets Split
 433 {
 434         $$ = new Ast::CallSplitExpr( @$,
 435                                                                                                                          $1,
 436                                                                                                                          $3,
 437                                                                                                                          true );        /* true means Curry */
 438 }
 439 | '[' '!' Expr ArgList ']'
 440 {
 441         $$ = new Ast::CallExpr( @$, $3, $4, false, true );      /* false for no curry, true for procedural */
 442 }
 443 | Expr T_bangbrackets Expr
 444 {
 445         Ast::ArgListExprs * args = new Ast::ArgListExprs( true );
 446         args->orderedExprs_->push_back( $3 );
 447         $$ = new Ast::CallExpr( @$,
 448                                                                                                         $1,
 449                                                                                                         args,
 450                                                                                                         false,  /* false means no curry */
 451                                                                                                         true ); /* true means procedural */
 452 }
 453 | Expr T_bangbrackets Split
 454 {
 455         $$ = new Ast::CallSplitExpr( @$,
 456                                                                                                                          $1,
 457                                                                                                                          $3,
 458                                                                                                                          false, /* false means no curry */
 459                                                                                                                          true ); /* true means procedural */
 460 }
 461 | Expr T_bangdddotbrackets Expr
 462 {
 463         Ast::ArgListExprs * args = new Ast::ArgListExprs( true );
 464         args->orderedExprs_->push_back( $3 );
 465         $$ = new Ast::CallExpr( @$,
 466                                                                                                         $1,
 467                                                                                                         args,
 468                                                                                                         true,   /* true means Curry */
 469                                                                                                         true ); /* true means procedural */
 470 }
 471 | Expr T_bangdddotbrackets Split
 472 {
 473         $$ = new Ast::CallSplitExpr( @$,
 474                                                                                                                          $1,
 475                                                                                                                          $3,
 476                                                                                                                          true, /* false means no curry */
 477                                                                                                                          true ); /* true means procedural */
 478 }
 479 ;
 480
 481
 482 CurryCallExpr
 483 : '[' Expr ArgList T_dddot ']'
 484 {
 485         $$ = new Ast::CallExpr( @$, $2, $3, true ); /* true means Curry */
 486 }
 487 ;
 488
 489 MutateExpr
 490 : StateReference '.' '[' T_identifier ArgList ']'
 491 {
 492         Ast::CallExpr * res =
 493                 new Ast::CallExpr( @$,
 494                                                                                          new Ast::MutatorReference( @4, $1, $4 ),
 495                                                                                          $5 );
 496         res->setMutatorSelf( $1 );
 497         $$ = res;
 498 }
 499
 500
 501 Formals
 502 :
 503 {
 504         $$ = new Kernel::Formals( );
 505         $$->setLoc( @$ );
 506 }
 507 | T_split T_identifier
 508 {
 509         $$ = new Kernel::Formals( );
 510         $$->argumentOrder_->insert( std::pair< const char *, size_t >( $2, $$->defaultExprs_.size( ) ) );
 511         /* Note that we do not push a default expression (not even a null pointer) for the sink.
 512          * This way, the length of defaultExprs_ allways gives the number of non-sink arguments.
 513          * The default value for the sink is taken care of in a non-standard way anyway.
 514          */
 515         $$->setLoc( @$ );
 516         $$->sink_ = $2;
 517 }
 518 | OneOrMoreFormalsItems
 519 {
 520         $$ = $1;
 521         $$->setLoc( @$ );
 522 }
 523 | OneOrMoreFormalsItems T_split T_identifier
 524 {
 525         $$ = $1;
 526         $$->argumentOrder_->insert( std::pair< const char *, size_t >( $3, $$->defaultExprs_.size( ) ) );
 527         /* Note that we do not push a default expression (not even a null pointer) for the sink.
 528          * This way, the length of defaultExprs_ allways gives the number of non-sink arguments.
 529          * The default value for the sink is taken care of in a non-standard way anyway.
 530          */
 531         $$->setLoc( @$ );
 532         $$->sink_ = $3;
 533 }
 534 ;
 535
 536 OneOrMoreFormalsItems
 537 : T_identifier
 538 {
 539         $$ = new Kernel::Formals( );
 540         $$->argumentOrder_->insert( std::pair< const char *, size_t >( $1, $$->defaultExprs_.size( ) ) );
 541         $$->defaultExprs_.push_back( 0 );
 542 }
 543 | T_identifier ':' Expr
 544 {
 545         $$ = new Kernel::Formals( );
 546         $$->argumentOrder_->insert( std::pair< const char *, size_t >( $1, $$->defaultExprs_.size( ) ) );
 547         $$->defaultExprs_.push_back( $3 );
 548 }
 549 | T_state_identifier
 550 {
 551         $$ = new Kernel::Formals( );
 552         $$->stateOrder_->insert( std::pair< const char *, size_t >( $1, $$->stateOrder_->size( ) ) );
 553 }
 554 | OneOrMoreFormalsItems T_identifier
 555 {
 556         $$ = $1;
 557         if( $$->seenDefault_ )
 558                 {
 559                         Ast::theAnalysisErrorsList.push_back( new Exceptions::ParserError( @2, strrefdup( "Order-based formals may not appear among named formals." ) ) );
 560                 }
 561         if( $$->argumentOrder_->find( $2 ) != $$->argumentOrder_->end( ) )
 562                 {
 563                         Ast::theAnalysisErrorsList.push_back( new Exceptions::RepeatedFormal( @2, $2 ) );
 564                 }
 565         $$->argumentOrder_->insert( std::pair< const char *, size_t >( $2, $$->defaultExprs_.size( ) ) );
 566         $$->defaultExprs_.push_back( 0 );
 567 }
 568 | OneOrMoreFormalsItems T_identifier ':' Expr
 569 {
 570         $$ = $1;
 571         $$->seenDefault_ = true;
 572         if( $$->argumentOrder_->find( $2 ) != $$->argumentOrder_->end( ) )
 573                 {
 574                         Ast::theAnalysisErrorsList.push_back( new Exceptions::RepeatedFormal( @2, $2 ) );
 575                 }
 576         $$->argumentOrder_->insert( std::pair< const char *, size_t >( $2, $$->defaultExprs_.size( ) ) );
 577         $$->defaultExprs_.push_back( $4 );
 578 }
 579 | OneOrMoreFormalsItems T_state_identifier
 580 {
 581         $$ = $1;
 582         if( $$->stateOrder_->find( $2 ) != $$->stateOrder_->end( ) )
 583                 {
 584                         Ast::theAnalysisErrorsList.push_back( new Exceptions::RepeatedFormal( @2, $2 ) );
 585                 }
 586         $$->stateOrder_->insert( std::pair< const char *, size_t >( $2, $$->stateOrder_->size( ) ) );
 587 }
 588 ;
 589
 590
 591 SplitFormals
 592 :
 593 {
 594         Ast::theAnalysisErrorsList.push_back( new Exceptions::ParserError( @$, strrefdup( "The list of split assignment variables must not be empty." ) ) );
 595         $$ = new Ast::SplitDefineVariables( );
 596 }
 597 | T_split T_identifier
 598 {
 599         Ast::theAnalysisErrorsList.push_back( new Exceptions::ParserError( @$, strrefdup( "Just a sink in a split assignment formals list makes no sense." ) ) );
 600         $$ = new Ast::SplitDefineVariables( );
 601 }
 602 | OneOrMoreSplitFormals
 603 {
 604         $$ = $1;
 605 }
 606 | OneOrMoreSplitFormals T_split T_identifier
 607 {
 608         $$ = $1;
 609         Ast::StructSplitSink * expr = new Ast::StructSplitSink( );
 610         size_t ** pos = new size_t * ( 0 );
 611         $$->sinkDefine_ = new Ast::DefineVariable( @3, $3, expr, pos );
 612         $$->sinkExpr_ = expr;
 613 }
 614 ;
 615
 616 OneOrMoreSplitFormals
 617 : T_identifier
 618 {
 619         $$ = new Ast::SplitDefineVariables( );
 620         typedef typeof $$->exprs_ ListType;
 621         size_t ** pos = new size_t * ( 0 );
 622         Ast::StructSplitReference * ref = new Ast::StructSplitReference( @1, static_cast< size_t >( 0 ), 0 );
 623         $$->exprs_.push_back( ListType::value_type( new Ast::DefineVariable( @1, $1, ref, pos ),
 624                                                                                                                                                                                          ref ) );
 625 }
 626 | T_identifier ':' Expr
 627 {
 628         $$ = new Ast::SplitDefineVariables( );
 629         typedef typeof $$->exprs_ ListType;
 630         size_t ** pos = new size_t * ( 0 );
 631         Ast::StructSplitReference * ref = new Ast::StructSplitReference( @1, static_cast< size_t >( 0 ), $3 );
 632         $$->exprs_.push_back( ListType::value_type( new Ast::DefineVariable( @1, $1, ref, pos ),
 633                                                                                                                                                                                          ref ) );
 634 }
 635 | T_identifier ':' '.' T_identifier
 636 {
 637         $$ = new Ast::SplitDefineVariables( );
 638         typedef typeof $$->exprs_ ListType;
 639         size_t ** pos = new size_t * ( 0 );
 640         Ast::StructSplitReference * ref = new Ast::StructSplitReference( @4, $4, 0 );
 641         $$->exprs_.push_back( ListType::value_type( new Ast::DefineVariable( @1, $1, ref, pos ),
 642                                                                                                                                                                                          ref ) );
 643 }
 644 | T_identifier ':' '.' T_identifier ':' Expr
 645 {
 646         $$ = new Ast::SplitDefineVariables( );
 647         typedef typeof $$->exprs_ ListType;
 648         size_t ** pos = new size_t * ( 0 );
 649         Ast::StructSplitReference * ref = new Ast::StructSplitReference( @4, $4, $6 );
 650         $$->exprs_.push_back( ListType::value_type( new Ast::DefineVariable( @1, $1, ref, pos ),
 651                                                                                                                                                                                          ref ) );
 652 }
 653 | T_identifier ':' '.' '\"'
 654 {
 655         $$ = new Ast::SplitDefineVariables( );
 656         typedef typeof $$->exprs_ ListType;
 657         size_t ** pos = new size_t * ( 0 );
 658         Ast::StructSplitReference * ref = new Ast::StructSplitReference( @4, strdup( $1 ), 0 );
 659         $$->exprs_.push_back( ListType::value_type( new Ast::DefineVariable( @1, $1, ref, pos ),
 660                                                                                                                                                                                          ref ) );
 661 }
 662 | T_identifier ':' '.' '\"' ':' Expr
 663 {
 664         $$ = new Ast::SplitDefineVariables( );
 665         typedef typeof $$->exprs_ ListType;
 666         size_t ** pos = new size_t * ( 0 );
 667         Ast::StructSplitReference * ref = new Ast::StructSplitReference( @4, strdup( $1 ), $6 );
 668         $$->exprs_.push_back( ListType::value_type( new Ast::DefineVariable( @1, $1, ref, pos ),
 669                                                                                                                                                                                          ref ) );
 670 }
 671 | OneOrMoreSplitFormals T_identifier
 672 {
 673         $$ = $1;
 674         if( $$->seenNamed_ )
 675                 {
 676                         Ast::theAnalysisErrorsList.push_back( new Exceptions::ParserError( @2, strrefdup( "Order-based formals may not appear among named formals." ) ) );
 677                 }
 678         if( $$->seenDefault_ )
 679                 {
 680                         Ast::theAnalysisErrorsList.push_back( new Exceptions::ParserError( @2, strrefdup( "All order-based formals without default values must be placed before those with default values." ) ) );
 681                 }
 682         typedef typeof $$->exprs_ ListType;
 683         size_t ** pos = new size_t * ( 0 );
 684         Ast::StructSplitReference * ref = new Ast::StructSplitReference( @2, $$->exprs_.size( ), 0 );
 685         $$->exprs_.push_back( ListType::value_type( new Ast::DefineVariable( @2, $2, ref, pos ),
 686                                                                                                                                                                                          ref ) );
 687 }
 688 | OneOrMoreSplitFormals T_identifier ':' Expr
 689 {
 690         $$ = $1;
 691         if( $$->seenNamed_ )
 692                 {
 693                         Ast::theAnalysisErrorsList.push_back( new Exceptions::ParserError( @2, strrefdup( "Order-based formals may not appear among named formals." ) ) );
 694                 }
 695         $$->seenDefault_ = true;
 696         typedef typeof $$->exprs_ ListType;
 697         size_t ** pos = new size_t * ( 0 );
 698         Ast::StructSplitReference * ref = new Ast::StructSplitReference( @2, $$->exprs_.size( ), $4 );
 699         $$->exprs_.push_back( ListType::value_type( new Ast::DefineVariable( @2, $2, ref, pos ),
 700                                                                                                                                                                                          ref ) );
 701 }
 702 | OneOrMoreSplitFormals T_identifier ':' '.' T_identifier
 703 {
 704         $$ = $1;
 705         $$->seenNamed_ = true;
 706         typedef typeof $$->exprs_ ListType;
 707         size_t ** pos = new size_t * ( 0 );
 708         Ast::StructSplitReference * ref = new Ast::StructSplitReference( @5, $5, 0 );
 709         $$->exprs_.push_back( ListType::value_type( new Ast::DefineVariable( @2, $2, ref, pos ),
 710                                                                                                                                                                                          ref ) );
 711 }
 712 | OneOrMoreSplitFormals T_identifier ':' '.' T_identifier ':' Expr
 713 {
 714         $$ = $1;
 715         $$->seenNamed_ = true;
 716         typedef typeof $$->exprs_ ListType;
 717         size_t ** pos = new size_t * ( 0 );
 718         Ast::StructSplitReference * ref = new Ast::StructSplitReference( @5, $5, $7 );
 719         $$->exprs_.push_back( ListType::value_type( new Ast::DefineVariable( @2, $2, ref, pos ),
 720                                                                                                                                                                                          ref ) );
 721 }
 722 | OneOrMoreSplitFormals T_identifier ':' '.' '\"'
 723 {
 724         $$ = $1;
 725         $$->seenNamed_ = true;
 726         typedef typeof $$->exprs_ ListType;
 727         size_t ** pos = new size_t * ( 0 );
 728         Ast::StructSplitReference * ref = new Ast::StructSplitReference( @5, strdup( $2 ), 0 );
 729         $$->exprs_.push_back( ListType::value_type( new Ast::DefineVariable( @2, $2, ref, pos ),
 730                                                                                                                                                                                          ref ) );
 731 }
 732 | OneOrMoreSplitFormals T_identifier ':' '.' '\"' ':' Expr
 733 {
 734         $$ = $1;
 735         $$->seenNamed_ = true;
 736         typedef typeof $$->exprs_ ListType;
 737         size_t ** pos = new size_t * ( 0 );
 738         Ast::StructSplitReference * ref = new Ast::StructSplitReference( @5, strdup( $2 ), $7 );
 739         $$->exprs_.push_back( ListType::value_type( new Ast::DefineVariable( @2, $2, ref, pos ),
 740                                                                                                                                                                                          ref ) );
 741 }
 742 ;
 743
 744
 745 Function
 746 : '\\' Formals T_mapsto FunctionModeList Expr
 747 {
 748         Ast::ArgListExprs * args = new Ast::ArgListExprs( false );
 749         Ast::FunctionFunction * res = new Ast::FunctionFunction( @$, $2, $5, $4 );
 750         res->push_exprs( args );
 751         $$ = new Ast::CallExpr( @$,
 752                                                                                                         RefCountPtr< const Lang::Function >( res ),
 753                                                                                                         args );
 754 }
 755 | '(' OperatorFunction ')'
 756 {
 757         $$ = $2;
 758 }
 759 ;
 760
 761 OrderedFormals
 762 :
 763 {
 764         $$ = new list< RefCountPtr< const char > >( );
 765 }
 766 | OneOrMoreOrderedFormals
 767 ;
 768
 769 OneOrMoreOrderedFormals
 770 : T_identifier
 771 {
 772         $$ = new list< RefCountPtr< const char > >( );
 773         $$->push_back( strrefdup( $1 ) );
 774 }
 775 | OneOrMoreOrderedFormals T_identifier
 776 {
 777         $$ = $1;
 778         $$->push_back( strrefdup( $2 ) );
 779 }
 780 ;
 781
 782 OperatorFunction
 783 : T_minusminus
 784 {
 785         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_OPERATOR_MINUSMINUS ) );
 786 }
 787 | T_plusplus
 788 {
 789         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_OPERATOR_PLUSPLUS ) );
 790 }
 791 | '&'
 792 {
 793         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_OPERATOR_AMPERSAND ) );
 794 }
 795 | '+'
 796 {
 797         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_OPERATOR_PLUS ) );
 798 }
 799 | '-'
 800 {
 801         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_OPERATOR_MINUS ) );
 802 }
 803 | '*'
 804 {
 805         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_OPERATOR_STAR ) );
 806 }
 807 | '/'
 808 {
 809         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_OPERATOR_SLASH ) );
 810 }
 811 | T_projection
 812 {
 813         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_OPERATOR_PROJECTION ) );
 814 }
 815 | T_angle
 816 {
 817         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_OPERATOR_ANGLE ) );
 818 }
 819 | T_ampersandMore
 820 {
 821         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_OPERATOR_AMPERSAND_MORE ) );
 822 }
 823 | '~'
 824 {
 825         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_OPERATOR_NEG ) );
 826 }
 827 | T_compose
 828 {
 829         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_OPERATOR_COMPOSE ) );
 830 }
 831 | '<'
 832 {
 833         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_OPERATOR_LESS ) );
 834 }
 835 | '>'
 836 {
 837         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_OPERATOR_GREATER ) );
 838 }
 839 | T_eqeq
 840 {
 841         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_OPERATOR_EQEQ ) );
 842 }
 843 | T_eqneq
 844 {
 845         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_OPERATOR_EQNEQ ) );
 846 }
 847 | T_lesseq
 848 {
 849         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_OPERATOR_LESSEQ ) );
 850 }
 851 | T_greatereq
 852 {
 853         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_OPERATOR_GREATEREQ ) );
 854 }
 855 | T_not
 856 {
 857         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_OPERATOR_NOT ) );
 858 }
 859 | T_and
 860 {
 861         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_FUNCTION_AND ) );
 862 }
 863 | T_or
 864 {
 865         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_FUNCTION_OR ) );
 866 }
 867 | T_xor
 868 {
 869         $$ = new Ast::Constant( @$, static_cast< RefCountPtr< const Lang::Value > >( Lang::THE_OPERATOR_XOR ) );
 870 }
 871 ;
 872
 873 Expr
 874 : ExprExceptConstStrings
 875 | T_string
 876 {
 877         $$ = new Ast::Constant( @1, new Lang::String( $1, false ) );
 878 }
 879 ;
 880
 881 ExprExceptConstStrings
 882 : ConstantExceptStrings
 883 | Coords
 884 | PolarHandle
 885 | '(' T_tex ExprExceptConstStrings ')'
 886 {
 887         Ast::ArgListExprs * args = new Ast::ArgListExprs( true );
 888         args->orderedExprs_->push_back( $3 );
 889         $$ = new Ast::CallExpr( @$,
 890                                                                                                         Ast::THE_FUNCTION_TeX,
 891                                                                                                         args );
 892 }
 893 | '(' T_tex T_string ')'
 894 {
 895         Kernel::theTeXLabelManager.announce( string( $3 ), @3 );
 896         Ast::ArgListExprs * args = new Ast::ArgListExprs( true );
 897         args->orderedExprs_->push_back( new Ast::Constant( @3, new Lang::String( $3, false ) ) );
 898         $$ = new Ast::CallExpr( @$,
 899                                                                                                         Ast::THE_FUNCTION_TeX,
 900                                                                                                         args );
 901 }
 902 | T_bangbang Expr
 903 {
 904         $$ = $2;
 905         $$->immediate_ = true;
 906 }
 907 | CallExpr
 908 | CurryCallExpr
 909 | SuperCall
 910 | SuperMemberReference
 911 | T_speciallength
 912 | '(' Expr ')'
 913 {
 914         $$ = $2;
 915 }
 916 | '(' '-' Expr ')'
 917 {
 918         $$ = new Ast::NegExpr( @$, @2, $3 );
 919 }
 920 | '(' '+' Expr ')'
 921 {
 922         $$ = new Ast::RelativeExpr( @$, @2, $3 );
 923 }
 924 | '(' ')'
 925 {
 926         $$ = new Ast::EmptyExpression( @$ );
 927 }
 928 | '(' Expr T_llthan InsertionSequence ')'
 929 {
 930         std::list< Ast::Node * > * bracket = new std::list< Ast::Node * >( );
 931
 932         size_t ** pos = new size_t * ( 0 );
 933         Ast::StateReference * dst = new Ast::LexiographicState( @2, strdup( Kernel::SEQUENTIAL_EXPR_VAR_ID ), new Kernel::Environment::LexicalKey * ( 0 ) );
 934
 935         bracket->push_back( new Ast::IntroduceState( @3,
 936                                                                                                                                                                                          strdup( Kernel::SEQUENTIAL_EXPR_VAR_ID ),
 937                                                                                                                                                                                          $2,
 938                                                                                                                                                                                          pos ) );
 939         for( std::list< Ast::Expression * >::const_iterator i = $4->begin( ); i != $4->end( ); ++i )
 940                 {
 941                         bracket->push_back( new Ast::Insertion( dst, *i ) );
 942                 }
 943         bracket->push_back( new Ast::Freeze( @3, strdup( Kernel::SEQUENTIAL_EXPR_VAR_ID ), pos ) );
 944         $$ = new Ast::CodeBracket( @$, bracket );
 945 }
 946 | T_surrounding Expr
 947 {
 948         $$ = new Ast::EvalOutsideExpr( @$, $2 );
 949 }
 950 | CodeBracket
 951 | Function
 952 | Class
 953 | T_identifier
 954 {
 955         Kernel::Environment::LexicalKey ** key = new Kernel::Environment::LexicalKey * ( 0 );
 956         $$ = new Ast::LexiographicVariable( @$, $1, key );
 957 }
 958 | T_atat Expr
 959 {
 960         Ast::ArgListExprs * args = new Ast::ArgListExprs( false );
 961         Ast::EvalSymbolFunction * res = new Ast::EvalSymbolFunction( @$, $2 );
 962         res->push_exprs( args );
 963         $$ = new Ast::CallExpr( @$,
 964                                                                                                         RefCountPtr< const Lang::Function >( res ),
 965                                                                                                         args );
 966 }
 967 | T_dynamic_identifier
 968 {
 969         $$ = new Ast::DynamicVariable( @$, $1 );
 970 }
 971 | '(' StateReference ')'
 972 {
 973         $$ = new Ast::Peek( @$, $2 );
 974 }
 975 | MutateExpr
 976 | Expr '.' T_identifier
 977 {
 978         Ast::ArgListExprs * args = new Ast::ArgListExprs( false );
 979         Ast::MemberReferenceFunction * res = new Ast::MemberReferenceFunction( @$, $1, $3 );
 980         res->push_exprs( args );
 981         $$ = new Ast::CallExpr( @$,
 982                                                                                                         RefCountPtr< const Lang::Function >( res ),
 983                                                                                                         args );
 984 }
 985 | Expr '.' MethodIdentifier
 986 {
 987         Ast::ArgListExprs * args = new Ast::ArgListExprs( false );
 988         Ast::PublicMethodReferenceFunction * res = new Ast::PublicMethodReferenceFunction( @$, $1, $3 );
 989         res->push_exprs( args );
 990         $$ = new Ast::CallExpr( @$,
 991                                                                                                         RefCountPtr< const Lang::Function >( res ),
 992                                                                                                         args );
 993 }
 994 | DynamicBinding
 995 | '(' T_esc_continuation T_identifier Expr ')'
 996 {
 997         $$ = new Ast::LetDynamicECExpr( @$, @3, $3, $4 );
 998 }
 999 | '(' T_esc_continue T_identifier Expr ')'
1000 {
1001         Ast::ArgListExprs * args = new Ast::ArgListExprs( false );
1002         Ast::ContinueDynamicECFunction * res = new Ast::ContinueDynamicECFunction( @3, $3, $4 );
1003         res->push_exprs( args );
1004         $$ = new Ast::CallExpr( @$,
1005                                                                                                         RefCountPtr< const Lang::Function >( res ),
1006                                                                                                         args );
1007         /* This used to be immediate, but right now that seems utterly wrong!
1008          * Imagine choosing between two continuations; then both continuations would require invokation before being "passed" to the <if> function.
1009          * On the other hand, I can admit that it seems a bit uncanny to let the <if> function return the continuation invokations as thunks, not
1010          * knowing when they will be forced...  But I don't think there's a choice here anyway; this expression can't be immediate.
1011          */
1012 }
1013 | Expr '|' Expr
1014 {
1015         $$ = new Ast::WithDynamicExpr( @$, $1, $3 );
1016 }
1017 | T_unionLeft ArgList T_unionRight
1018 {
1019         $$ = new Ast::UnionExpr( @$, $2 );
1020 }
1021 | Expr T_minusminus T_cycle
1022 {
1023         $$ = new Ast::CycleExpr( @3, $1 );
1024 }
1025 | Expr T_minusminus Expr
1026 {
1027         $$ = new Ast::MinusMinusExpr( @2, $1, $3 );
1028 }
1029 | Expr T_plusplus Expr
1030 {
1031         $$ = new Ast::PlusPlusExpr( @2, $1, $3 );
1032 }
1033 | Expr '&' Expr
1034 {
1035         $$ = new Ast::AmpersandExpr( @2, $1, $3 );
1036 }
1037 | Expr '+' Expr
1038 {
1039         $$ = new Ast::PlusExpr( @2, $1, $3 );
1040 }
1041 | Expr '-' Expr
1042 {
1043         $$ = new Ast::MinusExpr( @2, $1, $3 );
1044 }
1045 | Expr T_angle Expr
1046 {
1047         $$ = new Ast::AngleExpr( @2, $1, $3 );
1048 }
1049 | Expr T_ampersandMore Expr
1050 {
1051         $$ = new Ast::AmpersandMoreExpr( @2, $1, $3 );
1052 }
1053 | Expr '*' Expr
1054 {
1055         $$ = new Ast::StarExpr( @2, $1, $3 );
1056 }
1057 | Expr T_projection Expr
1058 {
1059         $$ = new Ast::ProjectionExpr( @2, $1, $3 );
1060 }
1061 | Expr '/' Expr
1062 {
1063         $$ = new Ast::SlashExpr( @2, $1, $3 );
1064 }
1065 | '~' Expr
1066 {
1067         $$ = new Ast::NegExpr( @1, $2 );
1068 }
1069 | Expr T_compose Expr
1070 {
1071         $$ = new Ast::ComposeExpr( @2, $1, $3 );
1072 }
1073 | Expr '<' Expr
1074 {
1075         $$ = new Ast::LessExpr( @2, $1, $3 );
1076 }
1077 | Expr '>' Expr
1078 {
1079         $$ = new Ast::GreaterExpr( @2, $1, $3 );
1080 }
1081 | Expr T_eqeq Expr
1082 {
1083         $$ = new Ast::EqualExpr( @2, $1, $3 );
1084 }
1085 | Expr T_eqneq Expr
1086 {
1087         $$ = new Ast::NotEqualExpr( @2, $1, $3 );
1088 }
1089 | Expr T_lesseq Expr
1090 {
1091         $$ = new Ast::LessEqualExpr( @2, $1, $3 );
1092 }
1093 | Expr T_greatereq Expr
1094 {
1095         $$ = new Ast::GreaterEqualExpr( @2, $1, $3 );
1096 }
1097 | T_not Expr
1098 {
1099         $$ = new Ast::NotExpr( @1, $2 );
1100 }
1101 | Expr T_and Expr
1102 {
1103         //      $$ = new Ast::AndExpr( @2, $1, $3 );
1104
1105         Ast::ArgListExprs * args = new Ast::ArgListExprs( true );
1106         args->orderedExprs_->push_back( $1 );
1107         args->orderedExprs_->push_back( $3 );
1108         $$ = new Ast::CallExpr( @$,
1109                                                                                                         Lang::THE_FUNCTION_AND,
1110                                                                                                         args );
1111 }
1112 | Expr T_or Expr
1113 {
1114         //      $$ = new Ast::OrExpr( @2, $1, $3 );
1115
1116         Ast::ArgListExprs * args = new Ast::ArgListExprs( true );
1117         args->orderedExprs_->push_back( $1 );
1118         args->orderedExprs_->push_back( $3 );
1119         $$ = new Ast::CallExpr( @$,
1120                                                                                                         Lang::THE_FUNCTION_OR,
1121                                                                                                         args );
1122 }
1123 | Expr T_xor Expr
1124 {
1125         $$ = new Ast::XorExpr( @2, $1, $3 );
1126 }
1127 | T_typename
1128 {
1129         Kernel::Environment::LexicalKey ** key = new Kernel::Environment::LexicalKey * ( 0 );
1130         $$ = new Ast::LexiographicType( @$, $1, key );
1131 }
1132 ;
1133
1134
1135 DynamicBinding
1136 : T_dynamic_identifier ':' Expr %prec T_dynamiccolon
1137 {
1138         $$ = new Ast::DynamicBindingExpression( @$, $1, $3, new Kernel::Environment::LexicalKey * ( 0 ) );
1139 }
1140 | T_dynamic_identifier ':' T_dynamic Expr %prec T_dynamiccolon
1141 {
1142         $$ = new Ast::DynamicBindingExpression( @$, $1,
1143                                                                                                                                                                         new Ast::DynamicExpression( @4, $4 ),
1144                                                                                                                                                                         new Kernel::Environment::LexicalKey * ( 0 ) );
1145 }
1146 | T_dynamic_state_identifier ':' StateReference %prec T_dynamiccolon
1147 {
1148         $$ = new Ast::DynamicStateBindingExpression( @$, @1, $1, $3 );
1149 }
1150 ;
1151
1152
1153 ConstantExceptStrings
1154 : T_int
1155 {
1156         $$ = new Ast::Constant( @1, new Lang::Integer( $1 ) );
1157 }
1158 | T_float
1159 {
1160         $$ = new Ast::Constant( @1, new Lang::Float( $1 ) );
1161 }
1162 | T_length
1163 {
1164         $$ = new Ast::Constant( @1, new Lang::Length( $1 ) );
1165 }
1166 | T_bool
1167 {
1168         $$ = new Ast::Constant( @1, new Lang::Boolean( $1 ) );
1169 }
1170 | '\'' T_identifier
1171 {
1172         $$ = new Ast::Constant( @1, new Lang::Symbol( $2 ) );
1173 }
1174 ;
1175
1176 CodeBracket
1177 : '{' Group '}'
1178 {
1179         $$ = new Ast::CodeBracket( @$, $2 );
1180 }
1181 ;
1182
1183 GroupElem
1184 : Expr
1185 {
1186         $$ = $1;        // Explicit upcast avoids bison warning.
1187 }
1188 | T_identifier ':' Expr
1189 {
1190         size_t ** pos = new size_t * ( 0 );
1191         $$ = new Ast::DefineVariable( @1, $1, $3, pos );
1192 }
1193 | T_state_identifier ':' Expr
1194 {
1195         size_t ** pos = new size_t * ( 0 );
1196         $$ = new Ast::IntroduceState( @1, $1, $3, pos );
1197 }
1198 | T_state_identifier ';'
1199 {
1200         size_t ** pos = new size_t * ( 0 );
1201         $$ = new Ast::Freeze( @1, $1, pos );
1202 }
1203 | T_identifier ':' T_state_identifier ';'
1204 {
1205         size_t ** posVar = new size_t * ( 0 );
1206         size_t ** posState = new size_t * ( 0 );
1207         $$ = new Ast::DefineVariable( @1, $1, new Ast::Freeze( @3, $3, posState ), posVar );
1208 }
1209 | T_dynamic T_dynamic_identifier Expr Expr
1210 {
1211         $$ = new Ast::DynamicVariableDecl( @$, @2, $2, $3, $4 );
1212 }
1213 | T_dynamic T_dynamic_identifier Expr T_dynamic Expr
1214 {
1215         $$ = new Ast::DynamicVariableDecl( @$, @2, $2, $3,
1216                                                                                                                                                  new Ast::DynamicExpression( @5, $5 ) );
1217 }
1218 | T_dynamic T_dynamic_state_identifier StateReference
1219 {
1220         $$ = new Ast::DynamicStateDecl( @$, @2, $2, $3, new size_t * ( 0 ) );
1221 }
1222 | Expr '.' T_identifier T_llthan InsertionSequence
1223 {
1224         shapeserror( "MemberInsertionSequence not implemented" );
1225         //      $$ = new Ast::MemberInsertionSequence( @$, $1, $3, $5 );
1226 }
1227 | '(' '#' Expr ')' '.' T_identifier T_llthan InsertionSequence
1228 {
1229         shapeserror( "ProtectedMemberInsertionSequence not implemented" );
1230         //      $$ = new Ast::ProtectedMemberInsertionSequence( @$, @2, $3, $6, $8 );
1231 }
1232 ;
1233
1234 InsertionSequence
1235 : Expr
1236 {
1237         $$ = new std::list< Ast::Expression * >( );
1238         $$->push_back( $1 );
1239 }
1240 | InsertionSequence T_llthan Expr
1241 {
1242         $$ = $1;
1243         $$->push_back( $3 );
1244 }
1245 ;
1246
1247 OneOrMoreGroupElems
1248 : GroupElem
1249 {
1250         $$ = new list< Ast::Node * >( );
1251         $$->push_back( $1 );
1252 }
1253 | OneOrMoreGroupElems GroupElem
1254 {
1255         $$ = $1;
1256         $$->push_back( $2 );
1257 }
1258 | StateReference T_llthan InsertionSequence
1259 {
1260         $$ = new list< Ast::Node * >( );
1261         for( std::list< Ast::Expression * >::const_iterator i = $3->begin( ); i != $3->end( ); ++i )
1262                 {
1263                         $$->push_back( new Ast::Insertion( $1, *i ) );
1264                 }
1265 }
1266 | OneOrMoreGroupElems StateReference T_llthan InsertionSequence
1267 {
1268         $$ = $1;
1269         for( std::list< Ast::Expression * >::const_iterator i = $4->begin( ); i != $4->end( ); ++i )
1270                 {
1271                         $$->push_back( new Ast::Insertion( $2, *i ) );
1272                 }
1273 }
1274 | T_splitLeft SplitFormals T_splitRight ':' Expr
1275 {
1276         $$ = new list< Ast::Node * >( );
1277         size_t ** pos = new size_t * ( 0 );
1278
1279         $5->immediate_ = true;
1280         $$->push_back( new Ast::DefineVariable( @5, $2->newSplitVarId( ), $5, pos ) );
1281
1282         size_t orderedCount = 0;
1283
1284         typedef typeof $2->exprs_ ListType;
1285         for( ListType::iterator i = $2->exprs_.begin( ); i != $2->exprs_.end( ); ++i )
1286                 {
1287                         i->second->setStruct( @5, pos );
1288                         $$->push_back( i->first );
1289                         if( i->second->isOrdered( ) )
1290                                 {
1291                                         ++orderedCount;
1292                                 }
1293                 }
1294
1295         if( $2->sinkDefine_ != 0 )
1296                 {
1297                         $2->sinkExpr_->setStruct( @5, pos, orderedCount );
1298                         $$->push_back( $2->sinkDefine_ );
1299                 }
1300         else
1301                 {
1302                         $$->push_back( new Ast::AssertNoSinkNeeded( @2, orderedCount, @5, pos ) );
1303                 }
1304 }
1305 | T_splitLeft SplitFormals T_splitRight Expr
1306 {
1307         Ast::theAnalysisErrorsList.push_back( new Exceptions::ParserError( @4, strrefdup( "Expected ':'." ) ) );
1308         $$ = new list< Ast::Node * >( );
1309         $$->push_back( new Ast::ErrorExpression( @$ ) );
1310 }
1311 | OneOrMoreGroupElems T_splitLeft SplitFormals T_splitRight ':' Expr
1312 {
1313         $$ = $1;
1314         size_t ** pos = new size_t * ( 0 );
1315
1316         $6->immediate_ = true;
1317         $$->push_back( new Ast::DefineVariable( @6, $3->newSplitVarId( ), $6, pos ) );
1318
1319         size_t orderedCount = 0;
1320
1321         typedef typeof $3->exprs_ ListType;
1322         for( ListType::iterator i = $3->exprs_.begin( ); i != $3->exprs_.end( ); ++i )
1323                 {
1324                         i->second->setStruct( @6, pos );
1325                         $$->push_back( i->first );
1326                         if( i->second->isOrdered( ) )
1327                                 {
1328                                         ++orderedCount;
1329                                 }
1330                 }
1331
1332         if( $3->sinkDefine_ != 0 )
1333                 {
1334                         $3->sinkExpr_->setStruct( @6, pos, orderedCount );
1335                         $$->push_back( $3->sinkDefine_ );
1336                 }
1337         else
1338                 {
1339                         $$->push_back( new Ast::AssertNoSinkNeeded( @3, orderedCount, @6, pos ) );
1340                 }
1341 }
1342 | OneOrMoreGroupElems T_splitLeft SplitFormals T_splitRight Expr
1343 {
1344         Ast::theAnalysisErrorsList.push_back( new Exceptions::ParserError( @4, strrefdup( "Expected ':'." ) ) );
1345         $$ = $1;
1346         $$->push_back( new Ast::ErrorExpression( @$ ) );
1347 }
1348 ;
1349
1350 Group
1351 :
1352 {
1353         $$ = new list< Ast::Node * >( );
1354 }
1355 | OneOrMoreGroupElems
1356 ;
1357
1358
1359 SuperMemberReference
1360 : '(' '#' Expr ')' '.' T_identifier
1361 {
1362         Ast::ArgListExprs * args = new Ast::ArgListExprs( false );
1363         Ast::ProtectedMemberReferenceFunction * res = new Ast::ProtectedMemberReferenceFunction( @$, @2, $3, @6, $6 );
1364         res->push_exprs( args );
1365         $$ = new Ast::CallExpr( @$,
1366                                                                                                         RefCountPtr< const Lang::Function >( res ),
1367                                                                                                         args );
1368 }
1369 ;
1370
1371
1372 MethodIdentifier
1373 : T_identifier '#' T_identifier
1374 {
1375         Kernel::Environment::LexicalKey ** key = new Kernel::Environment::LexicalKey * ( 0 );
1376         $$ = new Ast::MethodIdExpr( @$, new Ast::LexiographicVariable( @1, $1, key ), $3 );
1377 }
1378 ;
1379
1380
1381 SuperCall
1382 : '[' '(' '#' Expr ')' '.' MethodIdentifier ArgList ']'
1383 {
1384         Ast::ArgListExprs * args = new Ast::ArgListExprs( false );
1385         Ast::ProtectedMethodReferenceFunction * res = new Ast::ProtectedMethodReferenceFunction( @$, @3, $4, $7 );
1386         res->push_exprs( args );
1387         $$ = new Ast::CallExpr( @$,
1388                                                                                                         new Ast::CallExpr( @3,
1389                                                                                                                                                                                  RefCountPtr< const Lang::Function >( res ),
1390                                                                                                                                                                                  args ),
1391                                                                                                         $8 );
1392 }
1393 | '[' '(' '#' ')' '.' MethodIdentifier ArgList ']'
1394 {
1395         Ast::ArgListExprs * args = new Ast::ArgListExprs( false );
1396         Ast::ProtectedMethodReferenceFunction * res = new Ast::ProtectedMethodReferenceFunction( @$, @3, 0, $6 );
1397         res->push_exprs( args );
1398         $$ = new Ast::CallExpr( @$,
1399                                                                                                         new Ast::CallExpr( @3,
1400                                                                                                                                                                                  RefCountPtr< const Lang::Function >( res ),
1401                                                                                                                                                                                  args ),
1402                                                                                                         $7 );
1403 }
1404 ;
1405
1406
1407 Class
1408 : '[' T_class '(' Expr Formals ')' T_identifier '(' ListOfParentsWithInitargs ')'
1409         ClassModeList
1410         ClassSections
1411         ']'
1412 {
1413         DeleteOnExit< char > isaDeleter( $7 );
1414         if( strcmp( $7, "isa" ) != 0 )
1415                 {
1416                         Ast::theAnalysisErrorsList.push_back( new Exceptions::ParserError( @7, strrefdup( "Expected \"isa\"." ) ) );
1417                 }
1418         if( ( $11 & Ast::CLASS_MODE_ABSTRACT ) != 0 && ( $11 & Ast::CLASS_MODE_FINAL ) != 0 )
1419                 {
1420                         Ast::theAnalysisErrorsList.push_back( new Exceptions::ParserError( @11, strrefdup( "Declaring a class both abstract and final is forbidden." ) ) );
1421                 }
1422
1423         Ast::ArgListExprs * args = new Ast::ArgListExprs( false );
1424         Ast::ClassFunction * res = new Ast::ClassFunction( @$, $4, $5, $9, $11, $12 );
1425         res->push_exprs( args );
1426         $$ = new Ast::CallExpr( @$,
1427                                                                                                         RefCountPtr< const Lang::Function >( res ),
1428                                                                                                         args );
1429 }
1430 ;
1431
1432 ListOfParentsWithInitargs
1433 : '(' Expr ArgList ')'
1434 {
1435         $$ = new std::list< const Ast::CallExpr * >;
1436         $$->push_back( new Ast::CallExpr( @$, $2, $3 ) );
1437 }
1438 | ListOfParentsWithInitargs '(' Expr ArgList ')'
1439 {
1440         $$ = $1;
1441         $$->push_back( new Ast::CallExpr( Ast::SourceLocation( @2, @5 ), $3, $4 ) );
1442 }
1443 ;
1444
1445 ClassModeList
1446 :
1447 {
1448         $$ = 0;
1449 }
1450 | OneOrMoreClassModeSpecifiers
1451 ;
1452
1453 OneOrMoreClassModeSpecifiers
1454 : ClassModeSpecifier
1455 | OneOrMoreClassModeSpecifiers ClassModeSpecifier
1456 {
1457         $$ = $1 | $2;
1458 }
1459 ;
1460
1461 ClassModeSpecifier
1462 : T_identifier
1463 {
1464         DeleteOnExit< char > strDeleter( $1 );
1465         $$ = 0;
1466         if( strcmp( $1, "abstract" ) == 0 )
1467                 {
1468                         $$ = Ast::CLASS_MODE_ABSTRACT;
1469                 }
1470         else if( strcmp( $1, "final" ) == 0 )
1471                 {
1472                         $$ = Ast::CLASS_MODE_FINAL;
1473                 }
1474         else
1475                 {
1476                         Ast::theAnalysisErrorsList.push_back( new Exceptions::ParserError( @$, strrefdup( "This is not a valid class mode specifier" ) ) );
1477                 }
1478 }
1479 ;
1480
1481 ClassSections
1482 :
1483 {
1484         $$ = new std::list< Ast::ClassSection * >;
1485 }
1486 | OneOrMoreClassSections
1487 ;
1488
1489 OneOrMoreClassSections
1490 : ClassSection
1491 {
1492         $$ = new std::list< Ast::ClassSection * >;
1493         $$->push_back( $1 );
1494 }
1495 | OneOrMoreClassSections ClassSection
1496 {
1497         $$ = $1;
1498         $$->push_back( $2 );
1499 }
1500 ;
1501
1502 ClassSection
1503 : '(' T_members MemberDeclarations ')'
1504 {
1505         $$ = $3;
1506 }
1507 | '(' T_prepare Group ')'
1508 {
1509         $$ = new Ast::PrepareSection( @$, $3 );
1510 }
1511 | '(' T_identifier MethodDeclarations ')'
1512 {
1513         DeleteOnExit< char > accessSpecDeleter( $2 );
1514         unsigned int accessSpec = 0;
1515         if( strcmp( $2, "__methods__" ) == 0    )
1516                 {
1517                         accessSpec = Ast::MEMBER_ACCESS_PUBLIC_GET | Ast::MEMBER_ACCESS_PROTECTED_GET;
1518                 }
1519         else if( strcmp( $2, "__abstract__" ) == 0      )
1520                 {
1521                         accessSpec = Ast::MEMBER_ACCESS_PUBLIC_GET | Ast::MEMBER_ACCESS_PROTECTED_GET | Ast::MEMBER_ABSTRACT;
1522                 }
1523         else if( strcmp( $2, "__final__" ) == 0 )
1524                 {
1525                         accessSpec = Ast::MEMBER_ACCESS_PUBLIC_GET | Ast::MEMBER_ACCESS_PROTECTED_GET | Ast::MEMBER_FINAL;
1526                 }
1527         else if( strcmp( $2, "__protected__" ) == 0 )
1528                 {
1529                         accessSpec = Ast::MEMBER_ACCESS_PROTECTED_GET;
1530                 }
1531         else if( strcmp( $2, "__private__" ) == 0 )
1532                 {
1533                         /* OK, no change */
1534                 }
1535         else
1536                 {
1537                         Ast::theAnalysisErrorsList.push_back( new Exceptions::ParserError( @2, strrefdup( "This is not a valid method access specifier." ) ) );
1538                 }
1539         $3->addModeBits( accessSpec );
1540         $$ = $3;
1541 }
1542 | '(' T_abstract OrderedFormals ')'
1543 {
1544         $$ = new Ast::AbstractSection( @$, $3 );
1545 }
1546 | '(' T_overrides Expr T_gr__ MethodDeclarations ')'
1547 {
1548         $$ = new Ast::OverridesSection( $3, $5 );
1549 }
1550 ;
1551
1552 MemberDeclarations
1553 :
1554 {
1555         $$ = new Ast::MemberSection;
1556 }
1557 | OneOrMoreMemberDeclarations
1558 ;
1559
1560 OneOrMoreMemberDeclarations
1561 : MemberDeclaration
1562 {
1563         $$ = new Ast::MemberSection;
1564         $$->push_back( $1 );
1565 }
1566 | OneOrMoreMemberDeclarations MemberDeclaration
1567 {
1568         $$ = $1;
1569         $$->push_back( $2 );
1570 }
1571 ;
1572
1573 MemberDeclaration
1574 : '(' T_identifier Expr ')'
1575 {
1576         $$ = new Ast::MemberDeclaration( @$, $2, $3, 0 );
1577 }
1578 | '(' T_identifier Expr MemberAccessList ')'
1579 {
1580         $$ = new Ast::MemberDeclaration( @$, $2, $3, $4 );
1581 }
1582 ;
1583
1584 MemberAccessList
1585 : MemberAccessSpecifier
1586 | MemberAccessList MemberAccessSpecifier
1587 {
1588         $$ = $1 | $2;
1589 }
1590 ;
1591
1592 MemberAccessSpecifier
1593 : '.'
1594 {
1595         $$ = Ast::MEMBER_ACCESS_PUBLIC_GET | Ast::MEMBER_ACCESS_PROTECTED_GET;
1596 }
1597 | T_llthan
1598 {
1599         $$ = Ast::MEMBER_ACCESS_PUBLIC_GET | Ast::MEMBER_ACCESS_PUBLIC_INSERT | Ast::MEMBER_ACCESS_PROTECTED_GET | Ast::MEMBER_ACCESS_PROTECTED_INSERT;
1600 }
1601 | '(' '#' '.' ')'
1602 {
1603         $$ = Ast::MEMBER_ACCESS_PROTECTED_GET;
1604 }
1605 | '(' '#' T_llthan ')'
1606 {
1607         $$ = Ast::MEMBER_ACCESS_PROTECTED_GET | Ast::MEMBER_ACCESS_PROTECTED_INSERT;
1608 }
1609 | '^'
1610 {
1611         $$ = Ast::MEMBER_TRANSFORMING;
1612 }
1613 ;
1614
1615 MethodDeclarations
1616 :
1617 {
1618         $$ = new Ast::MemberSection;
1619 }
1620 | OneOrMoreMethodDeclarations
1621 ;
1622
1623 OneOrMoreMethodDeclarations
1624 : MethodDeclaration
1625 {
1626         $$ = new Ast::MemberSection;
1627         $$->push_back( $1 );
1628 }
1629 | OneOrMoreMethodDeclarations MethodDeclaration
1630 {
1631         $$ = $1;
1632         $$->push_back( $2 );
1633 }
1634 ;
1635
1636 MethodDeclaration
1637 : '(' T_identifier Expr ')'
1638 {
1639         $$ = new Ast::MemberDeclaration( @$, $2, $3, Ast::MEMBER_CONST | Ast::MEMBER_METHOD );
1640 }
1641 | '(' '[' T_identifier Formals ']' FunctionModeList GroupElem ')'
1642 {
1643         Ast::Expression * body = dynamic_cast< Ast::Expression * >( $7 );
1644         if( body == 0 )
1645                 {
1646                         std::list< Ast::Node * > * bracket = new std::list< Ast::Node * >( );
1647                         bracket->push_back( $7 );
1648                         body = new Ast::CodeBracket( @7, bracket );
1649                 }
1650         Ast::ArgListExprs * args = new Ast::ArgListExprs( false );
1651         Ast::FunctionFunction * res = new Ast::FunctionFunction( @$, $4, body, $6 );
1652         res->push_exprs( args );
1653         $$ = new Ast::MemberDeclaration( @$, $3, new Ast::CallExpr( @$,
1654                                                                                                                                                                                                                                                         RefCountPtr< const Lang::Function >( res ),
1655                                                                                                                                                                                                                                                         args ),
1656                                                                                                                                          Ast::MEMBER_CONST | Ast::MEMBER_METHOD | ( (($6 & Ast::FUNCTION_TRANSFORMING) != 0) ? Ast::MEMBER_TRANSFORMING : 0 ) );
1657 }
1658 ;
1659
1660 FunctionModeList
1661 :
1662 {
1663         $$ = 0;
1664 }
1665 | OneOrMoreFunctionModeSpecifiers
1666 ;
1667
1668 OneOrMoreFunctionModeSpecifiers
1669 : FunctionModeSpecifier
1670 | OneOrMoreFunctionModeSpecifiers FunctionModeSpecifier
1671 {
1672         $$ = $1 | $2;
1673 }
1674 ;
1675
1676 FunctionModeSpecifier
1677 : '^'
1678 {
1679         $$ = Ast::FUNCTION_TRANSFORMING;
1680 }
1681 | '!'
1682 {
1683         $$ = Ast::FUNCTION_PROCEDURAL;
1684 }
1685 ;
1686
1687 Split
1688 : T_split Expr
1689 {
1690         $$ = $2;
1691 }
1692 ;
1693
1694 %%
1695
1696 /* The closing %% above marks the end of the Rules section and the beginning
1697  * of the User Subroutines section. All text from here to the end of the
1698  * file is copied verbatim to the end of the generated y.tab.c file.
1699  * This section is where you put definitions of helper functions.
1700  */
1701