caraway/caraway/parse.y

%{

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "caraway.h"
#include "node.h"

#define NO_INDENT               0
#define CLASS_INDENT            1
#define PATTERN_INDENT  2
#define METHOD_INDENT           3
#define INCINDENT do { indentlv++; preindent = -1; } while (0)
#define DECINDENT do { indentlv--; preindent = -1; } while (0)


static int cldesc;
static int indentlv;
static int current_indent;
static int preindent;
static int in_def;
static int next_indent;
static int next_list_end;
static int next_pattern;
static int next_pattern_end;
static int next_class_end;
static int indent_stack[3];

#define IS_NO_LV       (indentlv == NO_INDENT)
#define IS_CLASS_LV    (indentlv == CLASS_INDENT)
#define IS_PATTERN_LV  (indentlv == PATTERN_INDENT)
#define IS_METHOD_LV   (indentlv == METHOD_INDENT)
#define HAS_PREINDENT  (preindent > 0)

#define class_indent_size   indent_stack[0]
#define pattern_indent_size indent_stack[1]
#define method_indent_size  indent_stack[2]

static tree_node make_expr_node( node_type nodeType,
                                 tree_node receiver,
                                 OOP selector,
                                 tree_node expression );
static tree_node make_tree_node( node_type nodeType );
static tree_node make_symbol( char *sval );
static tree_node make_char( char cval );
static tree_node make_string( char *sval );
static tree_node make_int( long ival );
static tree_node make_large_int( char *sval );
static tree_node make_float( double fval );
static tree_node make_decimal( char *sval );
static tree_node make_data( char *sval );
static tree_node make_uri( char *sval );
static tree_node make_binding( tree_node variables );

static tree_node make_array( tree_node aval );
static tree_node make_array_elt( tree_node elt );
static tree_node make_dynamic_array( tree_node statements );
static tree_node make_variable( char *name );
static tree_node make_pseudo_variable( int pseudoType );

static tree_node make_assign( tree_node variables,
                              tree_node expression );
static tree_node make_assignment_list( tree_node variable );
static tree_node make_return( tree_node expression );
static tree_node make_keyword_expr( tree_node receiver,
                                    tree_node keywordMessage );
static tree_node make_keyword_list( char *keyword,
                                    tree_node expression );
static tree_node make_statement_list( tree_node expression );
static tree_node make_unary_expr( tree_node receiver,
                                  char *unarySelectorExpr );
static tree_node make_binary_expr( tree_node receiver,
                                   char *binaryOp,
                                   tree_node argument );
static tree_node make_cascaded_message( tree_node messageExpr,
                                        tree_node cascadedMessages );
static tree_node make_block( tree_node arguments,
                             tree_node temporaries,
                             tree_node statements );
static tree_node make_message_list( tree_node messageElt );

static tree_node make_variable_list( tree_node variable );
static tree_node make_list_node( node_type nodeType,
                                 char *name,
                                 tree_node value );
static void add_node( tree_node n1, tree_node n2 );

%}

/* definition of YYSTYPE */
%union{
  char    cval;
  double fval;
  long    ival;
  char    *sval;
  OOP    oval;
  tree_node  node;
}

/* single definite characters */     
%token PRIMITIVE_START "<primitive: ...>"
%token INTERNAL_TOKEN
%token SCOPE_SEPARATOR "'.' or '::'"
%token ASSIGNMENT "'_' or ':='"

/* larger lexical items */
%token <sval> IDENTIFIER
%token <sval> KEYWORD
%token <sval> INHERIT_KEYWORD
%token <sval> CATEGORY_KEYWORD
%token <sval> FIELDS_KEYWORD
%token <sval> INST_VARS_KEYWORD
%token <sval> CLASS_VARS_KEYWORD
%token <sval> INST_METHODS_KEYWORD
%token <sval> CLASS_METHODS_KEYWORD
%token <sval> SHARED_VARS_KEYWORD
%token <sval> TIMESTAMP_KEYWORD
%token <sval> STRING_LITERAL
%token <sval> SYMBOL_KEYWORD
%token <sval> BINOP
%token <sval> '|'
%token <ival> INTEGER_LITERAL
%token <sval> HEX_STRING
%token <sval> LARGE_INTEGER_LITERAL
%token <fval> FLOAT_LITERAL
%token <cval> CHAR_LITERAL
%token <sval> DECIMAL_LITERAL
%token <sval> URI
%token METHOD_END
%token METHOD_LIST_END
%token CLASS_START
%token MODULE_START
%token CLASS_END
%token MESSAGE_PATTERN_END
%token TERMINATE
%token DATA_START
%token TRUE
%token FALSE
%token NIL
%token SELF
%token SUPER
%token THIS_CONTEXT
// <boval>
%type <node> method message_pattern variable_name keyword_variable_list
  temporaries variable_names statements 
  statements.1 statement expression return_statement assigns
  primary number symbol uri character string dictionary data
  array array_body array_list array_elt
  dynamic_array dynamic_array dynamic_array_list
  block opt_block_variables block_variable_list
  unary_expression binary_expression
  keyword_expression keyword_binary_object_description_list
  cascaded_message_expression semi_message_list
  message_elt simple_expression message_expression
  unary_object_description
  binary_object_description
  pseudo_variables literal dynamic_literal static_literal
  variable_binding variable_primary
%type <sval> unary_selector keyword reserved_keyword binary_selector
   primitive symbol_body
%%

program
  : file_in_list
  ;

file_in_list
  : file_in_list file_in
  | /* empty */
  ;

file_in
  : doit
  | class_module_declaration
  ;

doit
  : temporaries
    {
      in_def = 1;
    }
    terminate toplevel_statements
  ;

toplevel_statements
  : toplevel_statements statement '.'
  | /* empty */
  ;

class_module_declaration
  : class_module_start class_name
    {
      printf("=== class module declaration start ===\n");
      cldesc = 1;
      INCINDENT;
      class_indent_size = -1;
      pattern_indent_size = -1;
      method_indent_size = -1;
      in_def = 1;
    }
    subclass terminate class_description
    {
      cldesc = 0;
    }
    attr_declarations class_end
  ;

class_end
  : CLASS_END
    {
      printf("=== class end ===\n");
      DECINDENT;
    }
  ;

class_module_start
  : CLASS_START
  | MODULE_START
  ;

class_name
  : IDENTIFIER
  ;

subclass
  : ':' class_name
  | /* empty */
  ;

terminate
  : TERMINATE
  ;

class_description
  : string
    {
      printf("=== comment ===\n");
      in_def = 1;
    }
    terminate
  | /* empty */
  ;

attr_declarations
  : attr_declarations
    {
      printf("=== attr declaration start ===\n");
      in_def = 1;
    }
    attr_declaration
    {
      if (class_indent_size < 0)
        class_indent_size = current_indent;
    }
    terminate
  | terminate
  | /* empty */
  ;

attr_declaration
  : category
  | instance_variables
  | class_instance_variables
  | instance_method_list
  | class_method_list
  | shared_variable_list
  ;

category
  : CATEGORY_KEYWORD string
  ;

instance_variables
  : INST_VARS_KEYWORD string
  ;

class_instance_variables
  : CLASS_VARS_KEYWORD string
  ;

instance_method_list
  : INST_METHODS_KEYWORD generic_method_list
  ;

class_method_list
  : CLASS_METHODS_KEYWORD generic_method_list
  ;

generic_method_list
  : method_category
    {
      printf("=== method list start ===\n");
      next_list_end = 0;
      INCINDENT;
      next_pattern = 0;
    }
    terminate
    method_list method_list_end
  ;

method_category
  : string
  | /* empty */
  ;

method_list
  : method
  | method_list method
  ;

method_list_end
  : METHOD_LIST_END
    {
      printf("=== method list end ===\n");
      DECINDENT;
    }
  ;

method
  : message_pattern message_pattern_end
    temporaries primitive statements method_end
  ;

method_end
  : METHOD_END
    {
      DECINDENT;
      printf("=== method end ===\n");
    }
  ;

message_pattern
  : unary_selector
  {
    $$ = make_unary_expr(NULL, $1); 
  }
  | binary_selector variable_name
  {
    $$ = make_binary_expr(NULL, $1, $2); 
  }
  | keyword_variable_list
  {
    $$ = make_keyword_expr(NULL, $1); 
  }
  ;


message_pattern_end 
  : MESSAGE_PATTERN_END
    {
      INCINDENT;
      printf("=== message pattern end ===\n");
      if (pattern_indent_size < 0)
        pattern_indent_size = current_indent;
    }
  ;

shared_variable_list
  : SHARED_VARS_KEYWORD method_category
    {
      printf("=== shared variable list start ===\n");
      next_list_end = 0;
      INCINDENT;
      next_pattern = 0;
    }
    terminate shared_variable_list_body shared_variable_list_body_end
  ;

shared_variable_list_body
  : shared_variable
  | shared_variable_list_body shared_variable
  ;

shared_variable_list_body_end
  : METHOD_LIST_END
    {
      printf("=== shared variable lisst body end ===\n");
      DECINDENT;
    }
  ;

shared_variable
  : variable_name shared_variable_pattern_end
    statements method_end
  ;

shared_variable_pattern_end
  : MESSAGE_PATTERN_END
    {
      INCINDENT;
      printf("=== shared variable pattern end ===\n");
      if (pattern_indent_size < 0)
        pattern_indent_size = current_indent;
    }
  ;


unary_selector
  : IDENTIFIER
  ;

binary_selector
  : BINOP
  | '|'
  ;

variable_name
  : IDENTIFIER
  {
    $$ = make_variable($1);
  }
  ;

keyword_variable_list
  : keyword variable_name
  {
    $$ = make_keyword_list($1, $2); 
  }
  | keyword_variable_list keyword variable_name
  {
    add_node($1, make_keyword_list($2, $3));
    $$ = $1; 
  }
  ;

optional_terminate
  : terminate
  | /* empty */
  ;

keyword
  : KEYWORD
  | reserved_keyword
  ;

reserved_keyword
  : INHERIT_KEYWORD
  | CATEGORY_KEYWORD
  | TIMESTAMP_KEYWORD
  | FIELDS_KEYWORD
  | INST_VARS_KEYWORD
  | CLASS_VARS_KEYWORD
  | INST_METHODS_KEYWORD
  | CLASS_METHODS_KEYWORD
  ;

primitive
  : /* empty */                              { $$ = 0; }
  | PRIMITIVE_START IDENTIFIER primitive_end { $$ = $2; }
  ;

primitive_end
  : BINOP
  {
    if (strcmp($1, ">") != 0) yyerror("primitive end must be '>'"); 
  }
  ;

temporaries
  : /* empty */            { $$ = NULL; }
  | '|' '|'                { $$ = NULL; }
  | '|' variable_names '|' { $$ = $2; }
  ;

variable_names
  : variable_name
  {
    $$ = make_variable_list($1); 
  }
  | variable_names variable_name
  {
    add_node($1, make_variable_list($2));
    $$ = $1; 
  }
  ;

statements
  : /* empty */                    { $$ = NULL; }
  | return_statement optional_dot  { $$ = $1; }
  | statements.1 optional_dot      { $$ = $1; }
  | statements.1 '.' return_statement optional_dot
  {
    add_node ($1, $3);
    $$ = $1;
  }
  ;

statements.1
  : statement { $$ = $1; }
  | statements.1 '.' statement
  {
    add_node($1, $3); 
    $$ = $1;
  }
  | statements.1 '.' error
  {
    $$ = $1;
    yyerrok;
  }
  ;
  
optional_dot
  : /* empty */
  | '.'
  ;

statement
  : expression { $$ = make_statement_list($1); }
  ;

return_statement
  : '^' expression
  {
    $$ = make_statement_list(make_return($2));
  }
  ;

expression
  : simple_expression
  | assigns simple_expression { $$ = make_assign($1, $2); }
  ;

assigns
  : variable_primary ASSIGNMENT
  {
    $$ = make_assignment_list($1); 
  }
  | assigns variable_primary ASSIGNMENT
  {
    add_node($1, make_assignment_list($2));
    $$ = $1; 
  }
  ;

simple_expression
  : primary
  | message_expression
  | cascaded_message_expression
  ;

primary
  : variable_primary
  | literal
  | pseudo_variables
  | '(' error ')'
  {
    yyerrok;
    $$ = NULL; 
  }
  | '(' expression ')' { $$ = $2; }
  ;

variable_primary
  : IDENTIFIER
  {
    $$ = make_variable($1); 
  }
  | variable_primary SCOPE_SEPARATOR IDENTIFIER
  {
    add_node($1, make_variable($3));
  }
  ;

literal
  : static_literal
  | dynamic_literal
  ;

static_literal
  : number
  | symbol
  | character
  | string
  | array
  | data
  | uri
  | variable_binding
  ;

dynamic_literal
  : dynamic_array
  | dictionary
  | block
  ;

number
  : INTEGER_LITERAL       { $$ = make_int($1); }
  | FLOAT_LITERAL         { $$ = make_float($1); }
  | LARGE_INTEGER_LITERAL { $$ = make_large_int($1); }
  | DECIMAL_LITERAL       { $$ = make_decimal($1); }
  ;

symbol
  : '#' symbol_body     { $$ = make_symbol($2); }
  | '#' STRING_LITERAL  { $$ = make_symbol($2); }
  ;

symbol_body
  : IDENTIFIER
  | binary_selector
  | SYMBOL_KEYWORD
  | KEYWORD
  ;

character
  : CHAR_LITERAL { $$ = make_char($1); }
  ;

string
  : STRING_LITERAL { $$ = make_string($1); }
  ;

array
  : '#' array_body { $$ = $2; }
  ;

array_body
  : '(' ')'            { $$ = make_array(NULL); }
  | '(' array_list ')' { $$ = make_array($2); }
  | '(' error ')'
  {
    yyerrok;
    //_gst_had_error = true;
    $$ = NULL; 
  }
  ;

array_list
  : array_elt { $$ = make_array_elt($1); }
  | array_list array_elt
  {
    add_node($1, make_array_elt($2));
    $$ = $1; 
  }
  ;

array_elt
  : static_literal
  | pseudo_variables
  ;

pseudo_variables
  : TRUE         { $$ = make_pseudo_variable(PSEUDO_TRUE); }
  | FALSE        { $$ = make_pseudo_variable(PSEUDO_FALSE); }
  | NIL          { $$ = make_pseudo_variable(PSEUDO_NIL); }
  | SELF         { $$ = make_pseudo_variable(PSEUDO_SELF); }
  | SUPER        { $$ = make_pseudo_variable(PSEUDO_SUPER); }
  | THIS_CONTEXT { $$ = make_pseudo_variable(PSEUDO_CONTEXT); }
  ;

data
  : DATA_START HEX_STRING
  {
    $$ = make_data($2);
    in_data = 0;
  }
  ;

uri
  : URI { $$ = make_uri($1); }
  ;

variable_binding
  : '#' '{' error '}'
  {
    yyerrok;
    //_gst_had_error = true;
    $$ = NULL; 
  }
  | '#' '{' variable_primary '}'
  {
    $$ = make_binding($3); 
    if (!$$) {
      //_gst_errorf ("invalid variable binding");
      YYERROR;
    }
  }
  ;

dynamic_array
  : '{' error '}'
  {
    yyerrok;
    $$ = NULL;
  }
  | '{' dynamic_array_list '}' { $$ = make_dynamic_array($2); }
  ;

dynamic_array_list
  : statement                        { $$ = $1; }
  | statement ',' dynamic_array_list { add_node($1, $3); }
  ;

dictionary
  : '{' ':' '}'          { $$ = NULL; }
  | '{' associations '}' { $$ = NULL; }
  ;

associations
  : association
  | association ',' associations
  ;

association
  : statement ':' statement
  ;

block
  : '[' error ']'
  {
    yyerrok;
    $$ = NULL; 
  }
  | '[' opt_block_variables temporaries statements ']'
  {
    $$ = make_block($2, $3, $4); 
  }
  ;

opt_block_variables
  : /* empty */ { $$ = NULL; }
  | block_variable_list binary_selector
  {
    if ($2[0] != '|') {
      yyerror("block variables end must be '|'");
    } else if ($2[1] == '\0') { /* | */
    } else if ($2[1] == '|') {   /* || */
      //_gst_unread_char('|');
    }
  }
  ;

block_variable_list
  : ':' variable_name
  {
    $$ = make_variable_list($2); 
  }
  | block_variable_list ':' variable_name
  {
    add_node($1, make_variable_list($3));
    $$ = $1; 
  }
  ;

message_expression
  : unary_expression
  | binary_expression
  | keyword_expression
  ;

unary_expression
  : unary_object_description unary_selector
  {
    $$ = make_unary_expr($1, $2); 
  }
  ;

unary_object_description
  : primary
  | unary_expression
  ;

binary_expression
  : binary_object_description binary_selector unary_object_description
  {
    $$ = make_binary_expr($1, $2, $3); 
  }
  ;

binary_object_description
  : unary_object_description
  | binary_expression
  ;

keyword_expression
  : binary_object_description keyword_binary_object_description_list
  {
    $$ = make_keyword_expr($1, $2); 
  }
  ;

keyword_binary_object_description_list
  : keyword binary_object_description
  {
    $$ = make_keyword_list($1, $2); 
  }
  | keyword_binary_object_description_list keyword
    binary_object_description
  {
    add_node($1, make_keyword_list($2, $3));
    $$ = $1; 
  }
  ;

cascaded_message_expression
  : message_expression semi_message_list
  {
    $$ = make_cascaded_message($1, $2); 
  }
  ;

semi_message_list
  : ';' message_elt
  {
    $$ = make_message_list($2); 
  }
  | semi_message_list ';' message_elt
  {
    add_node($1, make_message_list($3));
    $$ = $1; 
  }
  ;

message_elt
  : unary_selector
  {
    $$ = make_unary_expr(NULL, $1); 
  }
  | binary_selector unary_object_description
  {
    $$ = make_binary_expr(NULL, $1, $2); 
  }
  | keyword_binary_object_description_list
  {
    $$ = make_keyword_expr(NULL, $1); 
  }
  ;


%%
static char *lex_str = NULL;
static char *token = NULL;
static int lex_p;
static int lex_pend;
static int token_index;
static int token_size;
static int in_data;

#define peek(c)       (lex_p != lex_pend && (c) == lex_str[lex_p])
#define peekc         lex_str[lex_p]
#define tokencmp(str) (strcmp(token, str) == 0)

static int
peek_str( const char *str )
{
  int i;

  for (i = 0; i < strlen(str); i++) {
    if (peek(str[i]))
      return 1;
  }
  return 0;
}

static inline int nextc()
{
  if (lex_p == lex_pend)
    return -1;
  return lex_str[lex_p++];
}

static void
pushback( int c )
{
  if (c == -1) return;
  lex_p--;
}

static char *newtoken()
{
  token_index = 0;
  if (!token) {
    token_size = 60;
    token = malloc(sizeof(char) * 60);
  }
  if (token_size > 4096) {
    token_size = 60;
    realloc(token, sizeof(char) * 60);
  }
  return token;
}

static void tokenadd( char c )
{
  token[token_index++] = c;
  if (token_index >= token_size) {
    token_size *= 2;
    token = realloc(token, sizeof(char) * token_size);
  }
  token[token_index] = '\0';
}

void setindent( int newsize )
{
  int size;

  size = indent_stack[indentlv-1];
  if (size < 0)
    indent_stack[indentlv-1] = newsize;
  else if (size) {
  }
}

/*
 * identifier, operator, colon, term,
 * $B%7%s%\%k!"8GDjG[Ns!"J8;z(B
 */
int
yylex()
{
  int c, i, len, isbase = 0, isfloat = 0, isscaled = 0, isexp = 0, returns;

  if (next_list_end == 1) {
    next_list_end = 2;
    return METHOD_LIST_END;
  } else if (next_list_end == 2) {
    next_list_end = 0;
    return TERMINATE;
  }

  if (in_data) {
    newtoken();
    while (1) {
      switch (c = nextc()) {
      case '>':
        yylval.sval = token;
        return HEX_STRING;

      case '0': case '1': case '2': case '3': case '4':
      case '5': case '6': case '7': case '8': case '9':
      case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
      case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
        tokenadd(c);
        break;

      case ' ': case '\r': case '\n': case '\t':
        break;

      default:
        printf("* byte error %d\n", c);
        return 0;
      }
    }
  }

  while (1) {
    switch (c = nextc()) {
    case '\0':    /* NULL */
    case '\004':  /* ^D */
    case '\032':  /* ^Z */
      return 0;

    case -1: /* end of script. */
      if (indentlv > NO_INDENT)
        return CLASS_END;
      return 0;

    /* comment */
    case '"':
      while (nextc() != '"');
      nextc();
      while ((c = nextc()) != '\r' && c != '\n' && c != -1);
      pushback(c);
      break;

    /* return */
    case '\r': case '\n':
      if (indentlv == NO_INDENT) {
        while (peek('\r') || peek('\n'))
          nextc();
        if (in_def) {
          in_def = 0;
          return TERMINATE;
        }
        break;
      } else if (indentlv > NO_INDENT && !peek('\r') && !peek('\n') &&
                 !peek(' ')) {
        return CLASS_END;
      }
      if (c == '\r' && peek('\n')) nextc();
      next_indent = 1;
      if (in_def) {
        in_def = 0;
        printf("terminate = %d\n", indentlv);
        return TERMINATE;
      } else if (IS_PATTERN_LV && next_pattern) {
        next_pattern_end = 1;
      }
      break;

    /* white space or indent */
    case ' ':
      if (!next_indent) {
        while ((c = nextc()) == ' ');
        pushback(c);
        break;
      }
      next_indent = 0;
      current_indent = 1;
      while ((c = nextc()) == ' ')
        current_indent++;
      pushback(c);
      if (peek('\r') || peek('\n'))
        break;
      setindent(current_indent);
      printf("* lv:%d [%d %d %d], current = %d, pre = %d\n", indentlv,
             class_indent_size, pattern_indent_size, method_indent_size,
             current_indent, preindent);
      if (next_pattern_end) {
        if (current_indent == pattern_indent_size)
          break;
        else if (current_indent > pattern_indent_size) {
          next_pattern_end = 0;
          return MESSAGE_PATTERN_END;
        }
      }
      if (IS_METHOD_LV && current_indent < method_indent_size) {
        if (current_indent <= class_indent_size)
          next_list_end = 1;
        return METHOD_END;
      }
      break;

    /* white spaces */
    case '\t': case '\f': case '\13': /* '\v' */
      break;

    /* char */
    case '$':
      newtoken();
      if (c = nextc()) {
        tokenadd(c);
        yylval.cval = c;
        return CHAR_LITERAL;
      } else {
        printf("* char error\n");
        return 0;
      }

    /* string */
    case '\'':
      newtoken();
      if ((c = nextc()) == '\'' && peek('\'')) {
        // ''' string '''
        nextc();
        nextc();
        int prec;
        while ((c = nextc()) != 0) {
          prec = c;
          if (c == '\'') {
            if ((c = nextc()) == '\'' && peek('\'')) {
              nextc();
              printf("* string - %s\n", token);
              yylval.sval = token;
              return STRING_LITERAL;
            } else
              pushback(c);
          }
          tokenadd(prec);
        }
      }
      pushback(c);
      while ((c = nextc()) != '\'')
        tokenadd(c);
      printf("* string - %s\n", token);
      yylval.sval = token;
      return STRING_LITERAL;

    /* digit */
    case '0': case '1': case '2': case '3': case '4':
    case '5': case '6': case '7': case '8': case '9':
      newtoken();
      tokenadd(c);
      while (c = nextc()) {
        switch (c) {
        case '0': case '1': case '2': case '3': case '4':
        case '5': case '6': case '7': case '8': case '9':
          tokenadd(c);
          break;

        case 'r':
          if (isbase || isfloat || isscaled) {
            printf("* error base\n");
            return 0;
          }
          tokenadd(c);
          isbase = 1;
          break;

        case '.':
          if (isbase || isfloat || isscaled) {
            printf("* error float\n");
            return 0;
          }
          tokenadd(c);
          isfloat = 1;
          break;

        case 'e':
          tokenadd(c);
          if (!isbase) isexp = 1;
          break;

        case 's':
          tokenadd(c);
          isscaled = 1;
          break;

        case '-':
          if (!isexp) {
            printf("* error decimal\n");
            return 0;
          }
          tokenadd(c);
          break;

        case 'a': case 'b': case 'c': case 'd': case 'f':
        case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
          if (!isbase) {
            printf("* error base\n");
            return 0;
          }
          tokenadd(c);
          break;

        default:
          pushback(c);
          if (isfloat) {
            yylval.fval = strtod(token, NULL);
            return FLOAT_LITERAL;
          } else if (isscaled) {
            yylval.sval = token;
            return DECIMAL_LITERAL;
          } else {
            yylval.ival = strtol(token, NULL, 10);
            if (yylval.ival == LONG_MAX || yylval.ival == LONG_MIN)
              return LARGE_INTEGER_LITERAL;
            else
              return INTEGER_LITERAL;
          }
        }
      }

    case ':':
      c = nextc();
      if (c == '=')
        return ASSIGNMENT;
      else if (c == ':')
        return SCOPE_SEPARATOR;
      pushback(c);
      return ':';

    case '#':
      if ((c = nextc()) == '<') {
        in_data = 1;
        return DATA_START;
      }
      pushback(c);
      return '#';

    case '.': case ';': case '^': case '|': case ',':
    case '(': case ')': case '[': case ']': case '{': case '}':
      return c;

    /* binary operators */
    case '!': case '%': case '&': case '*': case '+': case '-':
    case '/': case '<': case '=': case '>': case '?':
    case '@': case '\\': case '~':
      newtoken();
      tokenadd(c);
      while (peek_str("!%&*+-,/<=>?@\\~"))
        tokenadd(nextc());
      printf("* binary op = %s\n", token);
      yylval.sval = token;
      return BINOP;

    default:
      /* uri */
      len = 1;
      newtoken();
      while (c != -1 && (isalnum(c) || c == '+' || c == '-' || c == '.')) {
        tokenadd(c);
        len++;
        c = nextc();
      }
      if (c == ':') {
        if ((c = nextc()) == '/') {
          if ((c = nextc()) == '/') {
            tokenadd(':');
            tokenadd('/');
            tokenadd('/');
            while (isalnum(peekc) || peek_str("%:/?#[]@!$&()'*+,;=-._~"))
              tokenadd(nextc());
            yylval.sval = token;
            return URI;
          }
          pushback('/');
          pushback('/');
          len -= 2;
        }
        pushback(':');
      }
      for (i = 0; i < len; i++)
        pushback(0);

      /* identifier, etc. */
      newtoken();
      while (!peek_str(" \t\f\r\n\13'\"|0123456789.:;$!?+-*/<>=[](){}"))
        tokenadd(nextc());
      if (IS_PATTERN_LV && next_pattern == 0)
        next_pattern = 1;
      if (peek(':')) {
        tokenadd(nextc());
        printf("* keyword - %s\n", token);
      if (tokencmp("category:"))
          return CATEGORY_KEYWORD;
        else if (tokencmp("timestamp:"))
          return TIMESTAMP_KEYWORD;
        else if (tokencmp("fields:"))
          return FIELDS_KEYWORD;
        else if (tokencmp("instanceVariableNames:"))
          return INST_VARS_KEYWORD;
        else if (tokencmp("classInstanceVariableNames:"))
          return CLASS_VARS_KEYWORD;
        else if (tokencmp("methodsFor:") || tokencmp("instanceMethodsFor:"))
          return INST_METHODS_KEYWORD;
        else if (tokencmp("classMethodsFor:"))
          return CLASS_METHODS_KEYWORD;
        else if (tokencmp("sharedVariablesFor:"))
          return SHARED_VARS_KEYWORD;
        else
          return KEYWORD;
      }
      if (IS_NO_LV) {
        if (tokencmp("class"))
          return CLASS_START;
        else if (tokencmp("module"))
          return MODULE_START;
      }
      printf("* identifier - %s\n", token);
      yylval.sval = token;
      if (tokencmp("true"))             return TRUE;
      else if (tokencmp("false"))       return FALSE;
      else if (tokencmp("nil"))         return NIL;
      else if (tokencmp("self"))        return SELF;
      else if (tokencmp("super"))       return SUPER;
      else if (tokencmp("thisContext")) return THIS_CONTEXT;
      return IDENTIFIER;
    }
  }
  //printf("* Invalid char `\\%03o'\n", c);
  return;
}

static tree_node make_expr_node( node_type nodeType,
                                 tree_node receiver,
                                 OOP selector,
                                 tree_node expression )
{
  tree_node result;

  result = make_tree_node(nodeType);
  result->v_expr.receiver = receiver;
  result->v_expr.selector = selector;
  result->v_expr.expression = expression;
  return result;
}

static tree_node make_tree_node( node_type nodeType )
{
  tree_node result;

  result = (tree_node)malloc(sizeof(struct tree_node));
  result->nodeType = nodeType;
  return result;
}

static tree_node make_symbol( char *sval )
{
  tree_node result;

  result = make_tree_node(TREE_CONST_EXPR);
  result->v_const.constType = CONST_SYMBOL;
  result->v_const.val.oopVal = cw_boot_intern(sval);

  return result;
}

static tree_node make_char( char cval )
{
  tree_node result;

  result = make_tree_node(TREE_CONST_EXPR);
  result->v_const.constType = CONST_OOP;
  result->v_const.val.oopVal = INT2CHAR(cval);

  return result;
}

static tree_node make_string( char *sval )
{
  tree_node result;

  result = make_tree_node(TREE_CONST_EXPR);
  result->v_const.constType = CONST_STRING;
  result->v_const.val.oopVal = cw_byte_string_new2(sval);

  return result;
}

static tree_node make_int( long ival )
{
  tree_node result;

  result = make_tree_node(TREE_CONST_EXPR);
  result->v_const.constType = CONST_INT;
  result->v_const.val.iVal = ival;

  return (result);
}

static tree_node make_float( double fval )
{
  tree_node result;

  result = make_tree_node(TREE_CONST_EXPR);
  result->v_const.constType = CONST_FLOAT;
  result->v_const.val.fVal = fval;

  return result;
}

static tree_node make_large_int( char *sval )
{
  tree_node result;

  result = make_tree_node(TREE_CONST_EXPR);
  result->v_const.constType = CONST_LARGE_INT;
  result->v_const.val.sVal = sval;

  return result;
}

static tree_node make_decimal( char *sval )
{
  tree_node result;

  result = make_tree_node(TREE_CONST_EXPR);
  result->v_const.constType = CONST_DECIMAL;
  result->v_const.val.sVal = sval;

  return result;
}

static tree_node make_array( tree_node aval )
{
  tree_node result;

  result = make_tree_node(TREE_CONST_EXPR);
  result->v_const.constType = CONST_ARRAY;
  result->v_const.val.aVal = aval;

  return result;
}

static tree_node make_array_elt( tree_node elt )
{
  return make_list_node(TREE_ARRAY_ELT_LIST, NULL, elt);
}

static tree_node make_dynamic_array( tree_node statements )
{
  tree_node result;

  result = make_tree_node(TREE_DYNAMIC_ARRAY);
  result->v_const.constType = CONST_ARRAY;
  result->v_const.val.aVal = statements;

  return result;
}

static tree_node make_data( char *sval )
{
  tree_node result;

  result = make_tree_node(TREE_CONST_EXPR);
  result->v_const.constType = CONST_DATA;
  result->v_const.val.sVal = sval;

  return result;
}

static tree_node make_uri( char *sval )
{
  tree_node result;

  result = make_tree_node(TREE_CONST_EXPR);
  result->v_const.constType = CONST_URI;
  result->v_const.val.sVal = sval;

  return result;
}

static tree_node make_binding( tree_node variables )
{
  tree_node result;

  result = make_tree_node(TREE_CONST_EXPR);
  result->v_const.constType = CONST_BINDING;
  result->v_const.val.aVal = variables;

  return result;
}

static tree_node make_pseudo_variable( int pseudoType )
{
  tree_node result;

  result = make_tree_node(TREE_CONST_EXPR);
  result->v_const.constType = pseudoType;

  return result;
}

static tree_node make_variable( char *name )
{
  return make_list_node(TREE_VARIABLE_NODE, name, NULL);
}

static tree_node make_assign( tree_node variables,
                              tree_node expression )
{
  return make_expr_node(TREE_ASSIGN_EXPR, variables, Pnil, expression);
}

static tree_node make_assignment_list( tree_node variable )
{
  return make_list_node(TREE_VAR_ASSIGN_LIST, NULL, variable);
}

static tree_node make_return( tree_node expression )
{
  return make_expr_node(TREE_RETURN_EXPR, expression, Pnil, NULL);
}

static tree_node make_keyword_expr( tree_node receiver,
                                    tree_node keywordMessage )
{
  return make_expr_node(TREE_KEYWORD_EXPR, receiver, Pnil, keywordMessage);
}

static tree_node make_keyword_list( char *keyword, tree_node expression )
{
  return make_list_node(TREE_KEYWORD_LIST, keyword, expression);
}

static tree_node make_statement_list( tree_node expression )
{
  return make_list_node(TREE_STATEMENT_LIST, NULL, expression);
}

static tree_node make_cascaded_message( tree_node messageExpr,
                                        tree_node cascadedMessages )
{
  return make_expr_node(TREE_CASCADE_EXPR,
                        messageExpr, NULL, cascadedMessages);
}

static tree_node make_unary_expr( tree_node receiver, char *unarySelectorExpr )
{
  OOP selector;

  selector = cw_boot_intern(unarySelectorExpr);
  return make_expr_node(TREE_UNARY_EXPR, receiver, selector, NULL);
}

static tree_node make_binary_expr( tree_node receiver,
                                   char *binaryOp,
                                   tree_node argument )
{
  OOP selector;

  selector = cw_boot_intern(binaryOp);
  return make_expr_node(TREE_BINARY_EXPR, receiver, selector, argument);
}

static tree_node make_message_list( tree_node messageElt )
{
  return make_list_node(TREE_MESSAGE_LIST, NULL, messageElt);
}

static tree_node make_block( tree_node arguments,
                             tree_node temporaries,
                             tree_node statements )
{
  tree_node result;

  result = make_tree_node(TREE_BLOCK_NODE);
  result->v_block.arguments = arguments;
  result->v_block.temporaries = temporaries;
  result->v_block.statements = statements;
  return result;
}

static tree_node make_variable_list( tree_node variable )
{
  variable->nodeType = TREE_VAR_DECL_LIST;
  return variable;
}

static tree_node make_list_node( node_type nodeType,
                                 char *name,
                                 tree_node value )
{
  tree_node result;

  result = make_tree_node(nodeType);
  result->v_list.name = name;
  result->v_list.value = value;
  result->v_list.next = NULL;
  result->v_list.nextAddr = &result->v_list.next;
  return result;
}

static void add_node( tree_node n1, tree_node n2 )
{
  *(n1->v_list.nextAddr) = n2;
  n1->v_list.nextAddr = n2->v_list.nextAddr;
}

int main( int argc, char **argv )
{
  FILE *fp;
  int c, val;
  long fsize;

  if ((fp=fopen(argv[1],"r"))==NULL) {
    printf("error: input file\n");
    exit(1);
  }

  cw_init_proto_oops();
  fseek(fp, 0, SEEK_END);
  fsize = ftell(fp);
  fseek(fp, 0, SEEK_SET);
  lex_str = malloc(fsize);
  fread(lex_str, sizeof(char), fsize, fp);
  fclose(fp);
  lex_p = 0;
  lex_pend = fsize;
  yyparse();

  return;
}