src/st-parser.c

   1 /*
   2  * st-parser.c
   3  *
   4  * Copyright (C) 2008 Vincent Geddes
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23 */
  24
  25 #include "st-compiler.h"
  26 #include "st-types.h"
  27 #include "st-lexer.h"
  28 #include "st-utils.h"
  29 #include "st-primitives.h"
  30 #include "st-array.h"
  31 #include "st-symbol.h"
  32 #include "st-float.h"
  33 #include "st-large-integer.h"
  34 #include "st-universe.h"
  35 #include "st-object.h"
  36 #include "st-array.h"
  37 #include "st-character.h"
  38 #include "st-unicode.h"
  39 #include "st-behavior.h"
  40
  41 #include <tommath.h>
  42 #include <errno.h>
  43 #include <stdlib.h>
  44 #include <setjmp.h>
  45
  46
  47 typedef struct
  48 {
  49     st_lexer  *lexer;
  50     bool      in_block;
  51
  52     st_compiler_error *error;
  53     jmp_buf   jmploc;
  54 } st_parser;
  55
  56 static void
  57 parse_error (st_parser   *parser,
  58              const char *message,
  59              st_token    *token)
  60 {
  61     if (parser->error) {
  62         strncpy (parser->error->message, message, 255);
  63         parser->error->line   = st_token_get_line (token);
  64         parser->error->column = st_token_get_column (token);
  65     }
  66
  67     longjmp (parser->jmploc, 0);
  68 }
  69
  70 /* adaptor for st_lexer_next_token(). Catches lexer errors and filters out comments
  71  */
  72 static st_token *
  73 next (st_parser *parser)
  74 {
  75     st_token     *token;
  76     st_token_type type;
  77
  78     token = st_lexer_next_token (parser->lexer);
  79     type  = st_token_get_type (token);
  80
  81     if (type == ST_TOKEN_COMMENT)
  82         return next (parser);
  83     else if (type == ST_TOKEN_INVALID)
  84         parse_error (parser, st_lexer_error_message (parser->lexer), token);
  85
  86     return token;
  87 }
  88
  89 static st_token *
  90 current (st_lexer *lexer)
  91 {
  92     return st_lexer_current_token (lexer);
  93 }
  94
  95 static st_node *parse_statements     (st_parser *parser);
  96 static st_node *parse_temporaries    (st_parser *parser);
  97 static st_node *parse_subexpression  (st_parser *parser);
  98 static st_node *parse_expression     (st_parser *parser);
  99 static int      parse_primitive      (st_parser *parser);
 100
 101 static st_node *
 102 parse_block_arguments (st_parser *parser)
 103 {
 104     st_token *token;
 105     st_node  *arguments = NULL, *node;
 106
 107     token = current (parser->lexer);
 108
 109     while (st_token_get_type (token) == ST_TOKEN_COLON) {
 110
 111         token = next (parser);
 112         if (st_token_get_type (token) != ST_TOKEN_IDENTIFIER)
 113             parse_error (parser,"expected identifier", token);
 114
 115         node = st_node_new (ST_VARIABLE_NODE);
 116         node->line = st_token_get_line (token);
 117         node->variable.name = st_strdup (st_token_get_text (token));
 118         arguments = st_node_list_append (arguments, node);
 119
 120         token = next (parser);
 121     }
 122
 123     if (st_token_get_type (token) != ST_TOKEN_BINARY_SELECTOR ||
 124         !streq (st_token_get_text (token), "|"))
 125         parse_error (parser,"expected ':' or '|'", token);
 126
 127     next (parser);
 128
 129     return arguments;
 130 }
 131
 132
 133 static st_node *
 134 parse_block (st_parser *parser)
 135 {
 136     st_token *token;
 137     st_node  *node;
 138     bool     nested;
 139
 140     node = st_node_new (ST_BLOCK_NODE);
 141
 142     // parse block arguments
 143     token = next (parser);
 144
 145     node->line = st_token_get_line (token);
 146
 147     if (st_token_get_type (token) == ST_TOKEN_COLON)
 148         node->block.arguments = parse_block_arguments (parser);
 149
 150     token = current (parser->lexer);
 151     if (st_token_get_type (token) == ST_TOKEN_BINARY_SELECTOR
 152         && streq (st_token_get_text (token), "|"))
 153         node->block.temporaries = parse_temporaries (parser);
 154
 155     nested = parser->in_block;
 156     parser->in_block = true;
 157
 158     node->block.statements = parse_statements (parser);
 159
 160     if (nested == false)
 161         parser->in_block = false;
 162
 163     token = current (parser->lexer);
 164     if (st_token_get_type (token) != ST_TOKEN_BLOCK_END)
 165         parse_error (parser,"expected ']'", token);
 166     next (parser);
 167
 168     return node;
 169 }
 170
 171 static st_node *
 172 parse_number (st_parser *parser)
 173 {
 174     int      radix;
 175     int      sign;
 176     int      exponent;
 177     char    *number, *p;
 178     st_node  *node;
 179     st_token *token;
 180
 181     token = current (parser->lexer);
 182
 183     sign     = st_number_token_negative (token) ? -1 : 1;
 184     radix    = st_number_token_radix (token);
 185     exponent = st_number_token_exponent (token);
 186
 187     p = number = st_number_token_number (token);
 188
 189     node = st_node_new (ST_LITERAL_NODE);
 190     node->line = st_token_get_line (token);
 191
 192     /* check if there is a decimal point */
 193     while (*p && *p != '.')
 194         ++p;
 195
 196     if (*p == '.' || exponent != 0) {
 197
 198         char *format;
 199
 200         if (radix != 10)
 201             parse_error (parser,"only base-10 floats are supported at the moment", token);
 202
 203         format = st_strdup_printf ("%se%i", number, exponent);
 204
 205         node->literal.value = st_float_new (sign * strtod (format, NULL));
 206
 207         st_free (format);
 208
 209     } else {
 210
 211         errno = 0;
 212         long int integer = sign * strtol (number, NULL, radix);
 213
 214         /* check for overflow */
 215         if (errno == ERANGE
 216             || integer < ST_SMALL_INTEGER_MIN || integer > ST_SMALL_INTEGER_MAX) {
 217
 218             mp_int value;
 219             int    result;
 220
 221             result = mp_init (&value);
 222             if (result != MP_OKAY)
 223                 parse_error (parser,"memory exhausted while trying parse LargeInteger", token);
 224
 225             result = mp_read_radix (&value, number, radix);
 226             if (result != MP_OKAY)
 227                 parse_error (parser,"memory exhausted while trying parse LargeInteger", token);
 228
 229             if (sign == -1)
 230                 mp_neg (&value, &value);
 231
 232             node->literal.value = st_large_integer_new (&value);
 233
 234         } else {
 235             node->literal.value = st_smi_new (integer);
 236         }
 237     }
 238
 239     next (parser);
 240
 241     return node;
 242 }
 243
 244 static st_node *parse_primary (st_parser *parser);
 245
 246 static st_node *
 247 parse_tuple (st_parser *parser)
 248 {
 249     st_token *token;
 250     st_node *node;
 251     st_list *items = NULL;
 252
 253     token = next (parser);
 254     while (true) {
 255
 256         switch (st_token_get_type (token)) {
 257         case ST_TOKEN_NUMBER_CONST:
 258         case ST_TOKEN_STRING_CONST:
 259         case ST_TOKEN_SYMBOL_CONST:
 260         case ST_TOKEN_CHARACTER_CONST:
 261             node = parse_primary (parser);
 262             items = st_list_prepend (items, (st_pointer) node->literal.value);
 263             st_node_destroy (node);
 264             break;
 265
 266         case ST_TOKEN_LPAREN:
 267             node = parse_tuple (parser);
 268             items = st_list_prepend (items, (st_pointer) node->literal.value);
 269             st_node_destroy (node);
 270             break;
 271
 272         default:
 273             if (st_token_get_type (token) == ST_TOKEN_RPAREN) {
 274                 goto out;
 275             } else
 276                 parse_error (parser,"expected ')'", token);
 277         }
 278
 279         token = current (parser->lexer);
 280     }
 281
 282  out:
 283     token = next (parser);
 284     st_oop tuple;
 285
 286     items = st_list_reverse (items);
 287
 288     tuple = st_object_new_arrayed (ST_ARRAY_CLASS, st_list_length (items));
 289
 290     int i = 1;
 291     for (st_list *l = items; l; l = l->next)
 292         st_array_at_put (tuple, i++, (st_oop) l->data);
 293
 294     node = st_node_new (ST_LITERAL_NODE);
 295     node->literal.value = tuple;
 296     node->line = st_token_get_line (token);
 297
 298     st_list_destroy (items);
 299
 300     return node;
 301 }
 302
 303
 304 /* identifiers, literals, blocks */
 305 static st_node *
 306 parse_primary (st_parser *parser)
 307 {
 308     st_node *node = NULL;
 309     st_token *token;
 310
 311     token = current (parser->lexer);
 312
 313     switch (st_token_get_type (token)) {
 314
 315     case ST_TOKEN_IDENTIFIER:
 316
 317         node = st_node_new (ST_VARIABLE_NODE);
 318         node->line = st_token_get_line (token);
 319         node->variable.name = st_strdup (st_token_get_text (token));
 320
 321         next (parser);
 322         break;
 323
 324     case ST_TOKEN_NUMBER_CONST:
 325
 326         node = parse_number (parser);
 327         break;
 328
 329     case ST_TOKEN_STRING_CONST:
 330
 331         node = st_node_new (ST_LITERAL_NODE);
 332         node->line = st_token_get_line (token);
 333         node->literal.value = st_string_new (st_token_get_text (token));
 334
 335         next (parser);
 336         break;
 337
 338     case ST_TOKEN_SYMBOL_CONST:
 339
 340         node = st_node_new (ST_LITERAL_NODE);
 341         node->line = st_token_get_line (token);
 342         node->literal.value = st_symbol_new (st_token_get_text (token));
 343
 344         next (parser);
 345         break;
 346
 347     case ST_TOKEN_CHARACTER_CONST:
 348
 349         node = st_node_new (ST_LITERAL_NODE);
 350         node->line = st_token_get_line (token);
 351         node->literal.value = st_character_new (st_utf8_get_unichar (st_token_get_text (token)));
 352
 353         next (parser);
 354         break;
 355
 356     case ST_TOKEN_BLOCK_BEGIN:
 357
 358         node = parse_block (parser);
 359         break;
 360
 361     case ST_TOKEN_TUPLE_BEGIN:
 362
 363         node = parse_tuple (parser);
 364         break;
 365
 366     default:
 367         parse_error (parser,"expected expression", token);
 368     }
 369
 370     return node;
 371 }
 372
 373 static st_node *
 374 parse_unary_message (st_parser *parser, st_node *receiver)
 375 {
 376     st_token *token;
 377     st_node  *node;
 378
 379     token = current (parser->lexer);
 380
 381     node = st_node_new (ST_MESSAGE_NODE);
 382     node->line = st_token_get_line (token);
 383     node->message.precedence = ST_UNARY_PRECEDENCE;
 384     node->message.receiver = receiver;
 385     node->message.selector = st_symbol_new (st_token_get_text (token));
 386     node->message.arguments = NULL;
 387
 388     next (parser);
 389
 390     return node;
 391 }
 392
 393 static st_node *
 394 parse_binary_argument (st_parser *parser, st_node *receiver)
 395 {
 396     st_node  *node;
 397     st_token *token;
 398
 399     token = current (parser->lexer);
 400     if (st_token_get_type (token) != ST_TOKEN_IDENTIFIER)
 401         return receiver;
 402
 403     node = parse_unary_message (parser, receiver);
 404
 405     return parse_binary_argument (parser, node);
 406 }
 407
 408 static st_node *
 409 parse_binary_message (st_parser *parser, st_node *receiver)
 410 {
 411     st_node  *node, *argument;
 412     st_token *token;
 413     char     *selector;
 414
 415     token = current (parser->lexer);
 416
 417     selector = st_token_get_text (token);
 418
 419     /* parse the primary */
 420     token = next (parser);
 421     if (st_token_get_type (token) == ST_TOKEN_LPAREN)
 422         argument = parse_subexpression (parser);
 423     else
 424         argument = parse_primary (parser);
 425
 426     argument = parse_binary_argument (parser, argument);
 427
 428     node = st_node_new (ST_MESSAGE_NODE);
 429
 430     node->message.precedence = ST_BINARY_PRECEDENCE;
 431     node->message.receiver   = receiver;
 432     node->message.selector   = st_symbol_new (selector);
 433     node->message.arguments  = argument;
 434
 435     return node;
 436 }
 437
 438
 439 static st_node *
 440 parse_keyword_argument (st_parser *parser, st_node *receiver)
 441 {
 442     st_token *token;
 443
 444     token = current (parser->lexer);
 445
 446     if (receiver == NULL) {
 447         /* parse the primary */
 448         if (st_token_get_type (token) == ST_TOKEN_LPAREN)
 449             receiver = parse_subexpression (parser);
 450         else
 451             receiver = parse_primary (parser);
 452
 453     } else if (st_token_get_type (token) == ST_TOKEN_IDENTIFIER) {
 454         receiver = parse_unary_message (parser, receiver);
 455
 456     } else if (st_token_get_type (token) == ST_TOKEN_BINARY_SELECTOR && !streq (st_token_get_text (token), "!")) {
 457         receiver = parse_binary_message (parser, receiver);
 458
 459     } else {
 460         return receiver;
 461     }
 462
 463     return parse_keyword_argument (parser, receiver);
 464 }
 465
 466 static st_node *
 467 parse_keyword_message (st_parser *parser, st_node *receiver)
 468 {
 469     st_token *token;
 470     st_node  *node, *arguments = NULL, *arg;
 471     char *temp, *string = st_strdup ("");
 472
 473     token = current (parser->lexer);
 474
 475     while (st_token_get_type (token) == ST_TOKEN_KEYWORD_SELECTOR) {
 476
 477         temp = st_strconcat (string, st_token_get_text (token), NULL);
 478         st_free (string);
 479         string = temp;
 480
 481         token = next (parser);
 482         arg = parse_keyword_argument (parser, NULL);
 483         arguments = st_node_list_append (arguments, arg);
 484
 485         token = current (parser->lexer);
 486     }
 487
 488     node = st_node_new (ST_MESSAGE_NODE);
 489
 490     node->message.precedence = ST_KEYWORD_PRECEDENCE;
 491     node->message.receiver = receiver;
 492     node->message.selector = st_symbol_new (string);
 493     node->message.arguments = arguments;
 494
 495     st_free (string);
 496
 497     return node;
 498 }
 499
 500 /*
 501  * parses an expression from left to right, by recursively parsing subexpressions
 502  */
 503 static st_node *
 504 parse_message (st_parser *parser, st_node *receiver)
 505 {
 506     st_node  *message = NULL;
 507     st_token *token;
 508     st_token_type type;
 509
 510     /* Before parsing messages, check if expression is simply a variable.
 511      * This is the case if token is ')' or '.'
 512      */
 513     token = current (parser->lexer);
 514     type = st_token_get_type (token);
 515
 516     if (type == ST_TOKEN_PERIOD || type == ST_TOKEN_RPAREN || type == ST_TOKEN_SEMICOLON
 517         || type == ST_TOKEN_EOF || type == ST_TOKEN_BLOCK_END
 518         || (type == ST_TOKEN_BINARY_SELECTOR && streq (st_token_get_text (token), "!")))
 519         return receiver;
 520
 521     if (type == ST_TOKEN_IDENTIFIER)
 522         message = parse_unary_message (parser, receiver);
 523
 524     else if (type == ST_TOKEN_BINARY_SELECTOR)
 525         message = parse_binary_message (parser, receiver);
 526
 527     else if (type == ST_TOKEN_KEYWORD_SELECTOR)
 528         message = parse_keyword_message (parser, receiver);
 529
 530     else
 531         parse_error (parser,"nothing more expected", token);
 532
 533     return parse_message (parser, message);
 534 }
 535
 536 static st_node *
 537 parse_assign (st_parser *parser, st_node *assignee)
 538 {
 539     st_token *token;
 540     st_node *node, *expression;
 541
 542     token = next (parser);
 543
 544     expression = parse_expression (parser);
 545
 546     node = st_node_new (ST_ASSIGN_NODE);
 547     node->line = st_token_get_line (token);
 548     node->assign.assignee = assignee;
 549     node->assign.expression = expression;
 550
 551     return node;
 552 }
 553
 554 static st_node *
 555 parse_cascade (st_parser *parser, st_node *first_message)
 556 {
 557     st_token *token;
 558     st_node *message, *node;
 559     bool super_send = first_message->message.super_send;
 560
 561     token = current (parser->lexer);
 562
 563     node = st_node_new (ST_CASCADE_NODE);
 564     node->line = st_token_get_line (token);
 565
 566     node->cascade.receiver = first_message->message.receiver;
 567     node->cascade.messages = st_list_append (node->cascade.messages, first_message);
 568
 569     first_message->message.receiver = NULL;
 570
 571     while (st_token_get_type (token) == ST_TOKEN_SEMICOLON) {
 572
 573         next (parser);
 574
 575         message = parse_message (parser, NULL);
 576
 577         if (message == NULL)
 578             parse_error (parser,"expected cascade", token);
 579
 580         message->message.super_send = super_send;
 581
 582         node->cascade.messages = st_list_append (node->cascade.messages, message);
 583         token = current (parser->lexer);
 584     }
 585
 586     return node;
 587 }
 588
 589 static st_node *
 590 parse_expression (st_parser *parser)
 591 {
 592     st_node   *receiver = NULL;
 593     st_node   *message, *cascade;
 594     st_token  *token;
 595     bool super_send =false;
 596
 597     token = current (parser->lexer);
 598
 599     switch (st_token_get_type (token)) {
 600     case ST_TOKEN_NUMBER_CONST:
 601     case ST_TOKEN_STRING_CONST:
 602     case ST_TOKEN_SYMBOL_CONST:
 603     case ST_TOKEN_CHARACTER_CONST:
 604     case ST_TOKEN_BLOCK_BEGIN:
 605     case ST_TOKEN_TUPLE_BEGIN:
 606
 607         receiver = parse_primary (parser);
 608         break;
 609
 610     case ST_TOKEN_IDENTIFIER:
 611
 612         receiver = parse_primary (parser);
 613
 614         if (st_token_get_type (current (parser->lexer)) == ST_TOKEN_ASSIGN)
 615             return parse_assign (parser, receiver);
 616
 617         break;
 618
 619     case ST_TOKEN_LPAREN:
 620
 621         receiver = parse_subexpression (parser);
 622         break;
 623
 624     default:
 625         parse_error (parser,"expected expression", token);
 626     }
 627
 628     /* check if receiver is pseudo-variable 'super' */
 629     if (receiver->type == ST_VARIABLE_NODE
 630         && streq (receiver->variable.name, "super"))
 631         super_send = true;
 632
 633     message = parse_message (parser, receiver);
 634     message->message.super_send = super_send;
 635
 636     token = current (parser->lexer);
 637     if (st_token_get_type (token) == ST_TOKEN_SEMICOLON)
 638         return parse_cascade (parser, message);
 639     else
 640         return message;
 641 }
 642
 643 static st_node *
 644 parse_subexpression (st_parser *parser)
 645 {
 646     st_token *token;
 647     st_node  *expression;
 648
 649     next (parser);
 650
 651     expression = parse_expression (parser);
 652
 653     token = current (parser->lexer);
 654     if (st_token_get_type (token) != ST_TOKEN_RPAREN)
 655         parse_error (parser,"expected ')' after expression", token);
 656
 657     next (parser);
 658
 659     return expression;
 660 }
 661
 662 static st_node *
 663 parse_return (st_parser *parser)
 664 {
 665     st_node *node;
 666     st_token *token;
 667
 668     token = next (parser);
 669
 670     node = st_node_new (ST_RETURN_NODE);
 671     node->line = st_token_get_line (token);
 672     node->retrn.expression = parse_expression (parser);
 673
 674     return node;
 675 }
 676
 677 static st_node *
 678 parse_statement (st_parser *parser)
 679 {
 680     st_token *token;
 681
 682     token = current (parser->lexer);
 683
 684     if (st_token_get_type (token) == ST_TOKEN_RETURN)
 685         return parse_return (parser);
 686     else
 687         return parse_expression (parser);
 688 }
 689
 690 static st_node *
 691 parse_statements (st_parser *parser)
 692 {
 693     st_token *token;
 694     st_node  *expression = NULL, *statements = NULL;
 695
 696     token = current (parser->lexer);
 697
 698     while (st_token_get_type (token) != ST_TOKEN_EOF
 699            && st_token_get_type (token) != ST_TOKEN_BLOCK_END) {
 700
 701         /* check for unreachable statements */
 702         if (expression && expression->type == ST_RETURN_NODE) {
 703             /* first check that unreachable statement is valid ! */
 704             parse_statement (parser);
 705             parse_error (parser,"statement is unreachable", token);
 706         }
 707
 708         expression = parse_statement (parser);
 709         statements = st_node_list_append (statements, expression);
 710
 711         /* Consume statement delimiter ('.') if there is one.
 712          *
 713          * If the current token is a wrongly placed/mismatched
 714          * closing token (')' or ']'), then parse_expression() will handle
 715          * that.
 716          */
 717         token = current (parser->lexer);
 718         if (st_token_get_type (token) == ST_TOKEN_PERIOD) {
 719             token = next (parser);
 720         }
 721
 722     }
 723
 724     for (st_node *node = statements; node; node = node->next) {
 725         if (parser->in_block && node->type == ST_MESSAGE_NODE && node->next != NULL)
 726             node->message.is_statement = true;
 727         else if ((!parser->in_block) && node->type == ST_MESSAGE_NODE)
 728             node->message.is_statement = true;
 729
 730         if (parser->in_block && node->type == ST_CASCADE_NODE && node->next != NULL)
 731             node->cascade.is_statement = true;
 732         else if ((!parser->in_block) && node->type == ST_CASCADE_NODE)
 733             node->cascade.is_statement = true;
 734     }
 735
 736     return statements;
 737 }
 738
 739
 740 static int
 741 parse_primitive (st_parser *parser)
 742 {
 743     st_token *token;
 744     int      index = -1;
 745
 746     token = current (parser->lexer);
 747     if (st_token_get_type (token) != ST_TOKEN_BINARY_SELECTOR
 748         || !streq (st_token_get_text (token), "<"))
 749         return -1;
 750
 751     token = next (parser);
 752     if (st_token_get_type (token) == ST_TOKEN_KEYWORD_SELECTOR
 753         && streq (st_token_get_text (token), "primitive:")) {
 754
 755         token = next (parser);
 756         if (st_token_get_type (token) != ST_TOKEN_STRING_CONST)
 757             parse_error (parser,"expected string literal", token);
 758
 759         index = st_primitive_index_for_name (st_token_get_text (token));
 760         if (index < 0)
 761             parse_error (parser,"unknown primitive", token);
 762
 763         token = next (parser);
 764         if (st_token_get_type (token) != ST_TOKEN_BINARY_SELECTOR
 765             || !streq (st_token_get_text (token), ">"))
 766             parse_error (parser,"expected '>'", token);
 767
 768         next (parser);
 769
 770     } else {
 771         parse_error (parser,"expected primitive declaration", token);
 772     }
 773
 774     return index;
 775 }
 776
 777 /*
 778  * '|' identifier* '|'
 779  */
 780 static st_node *
 781 parse_temporaries (st_parser *parser)
 782 {
 783     st_token *token;
 784     st_node *temporaries = NULL, *temp;
 785
 786     token = current (parser->lexer);
 787
 788     if (st_token_get_type (token) != ST_TOKEN_BINARY_SELECTOR
 789         || !streq (st_token_get_text (token), "|"))
 790         return NULL;
 791
 792     token = next (parser);
 793     while (st_token_get_type (token) == ST_TOKEN_IDENTIFIER) {
 794
 795         temp = st_node_new (ST_VARIABLE_NODE);
 796         temp->line = st_token_get_line (token);
 797         temp->variable.name = st_strdup (st_token_get_text (token));
 798
 799         temporaries = st_node_list_append (temporaries, temp);
 800
 801         token = next (parser);
 802     }
 803
 804     if (st_token_get_type (token) != ST_TOKEN_BINARY_SELECTOR
 805         || !streq (st_token_get_text (token), "|"))
 806         parse_error (parser,"expected '|'", token);
 807
 808     token = next (parser);
 809
 810     return temporaries;
 811 }
 812
 813 static void
 814 parse_message_pattern (st_parser *parser, st_node *method)
 815 {
 816     st_token      *token;
 817     st_token_type  type;
 818     st_node *arguments = NULL;
 819
 820     token = next (parser);
 821     type  = st_token_get_type (token);
 822
 823     if (type == ST_TOKEN_IDENTIFIER) {
 824
 825         method->method.selector = st_symbol_new (st_token_get_text (token));
 826         method->method.precedence = ST_UNARY_PRECEDENCE;
 827
 828         next (parser);
 829
 830     } else if (type == ST_TOKEN_BINARY_SELECTOR) {
 831
 832         method->method.selector = st_symbol_new (st_token_get_text (token));
 833
 834         token = next (parser);
 835         if (st_token_get_type (token) != ST_TOKEN_IDENTIFIER)
 836             parse_error (parser,"argument name expected after binary selector", token);
 837
 838         arguments = st_node_new (ST_VARIABLE_NODE);
 839         arguments->line = st_token_get_line (token);
 840         arguments->variable.name = st_strdup (st_token_get_text (token));
 841
 842         method->method.precedence = ST_BINARY_PRECEDENCE;
 843
 844         next (parser);
 845
 846     } else if (type == ST_TOKEN_KEYWORD_SELECTOR) {
 847
 848         char *temp, *string = st_strdup ("");
 849         st_node  *arg;
 850
 851         while (st_token_get_type (token) == ST_TOKEN_KEYWORD_SELECTOR) {
 852
 853             temp = st_strconcat (string, st_token_get_text (token), NULL);
 854             st_free (string);
 855             string = temp;
 856
 857             token = next (parser);
 858             if (st_token_get_type (token) != ST_TOKEN_IDENTIFIER)
 859                 parse_error (parser,"argument name expected after keyword", token);
 860
 861             arg = st_node_new (ST_VARIABLE_NODE);
 862             arg->line = st_token_get_line (token);
 863             arg->variable.name = st_strdup (st_token_get_text (token));
 864             arguments = st_node_list_append (arguments, arg);
 865
 866             token = next (parser);
 867         }
 868
 869         method->method.selector = st_symbol_new (string);
 870         method->method.precedence = ST_KEYWORD_PRECEDENCE;
 871         st_free (string);
 872
 873     } else {
 874         parse_error (parser,"invalid message pattern", token);
 875     }
 876
 877     method->method.arguments = arguments;
 878 }
 879
 880 static st_node *
 881 parse_method (st_parser *parser)
 882 {
 883     st_node *node;
 884
 885     parser->in_block = false;
 886
 887     node = st_node_new (ST_METHOD_NODE);
 888
 889     node->method.primitive = -1;
 890
 891     parse_message_pattern (parser, node);
 892
 893     node->method.temporaries = parse_temporaries (parser);
 894     node->method.primitive   = parse_primitive (parser);
 895     node->method.statements  = parse_statements (parser);
 896
 897     st_assert (node->type == ST_METHOD_NODE);
 898
 899     return node;
 900 }
 901
 902 st_node *
 903 st_parser_parse (st_lexer *lexer,
 904                  st_compiler_error *error)
 905 {
 906     st_parser *parser;
 907     st_node   *method;
 908
 909     st_assert (lexer != NULL);
 910
 911     parser = st_new0 (st_parser);
 912
 913     parser->lexer = lexer;
 914     parser->error = error;
 915     parser->in_block = false;
 916
 917     if (!setjmp (parser->jmploc)) {
 918         method = parse_method (parser);
 919     } else {
 920         method = NULL;
 921     }
 922
 923     st_free (parser);
 924
 925     return method;
 926 }
 927