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