src/st-compiler.c

   1
   2 #include "st-compiler.h"
   3 #include "st-symbol.h"
   4 #include "st-universe.h"
   5 #include "st-dictionary.h"
   6 #include "st-behavior.h"
   7 #include "st-input.h"
   8 #include "st-node.h"
   9
  10 #include "st-lexer.h"
  11 #include "st-array.h"
  12
  13 #include <stdlib.h>
  14 #include <ctype.h>
  15 #include <string.h>
  16
  17
  18 typedef struct {
  19
  20     const char *filename;
  21     st_input    *input;
  22
  23     int line;
  24
  25 } FileInParser;
  26
  27 /*
  28  * st_compile_string:
  29  * @class: The class for which the compiled method will be bound.
  30  * @string: Source code for the method
  31  * @error: return location for errors
  32  *
  33  * This function will compile a source string into a new CompiledMethod,
  34  * and place the method in the methodDictionary of the given class.
  35  */
  36 bool
  37 st_compile_string (st_oop class, const char *string, st_compiler_error *error)
  38 {
  39     st_node  *node;
  40     st_oop   method;
  41     st_lexer *lexer;
  42
  43     st_assert (class != ST_NIL);
  44
  45     lexer = st_lexer_new (string);
  46     if (!lexer)
  47         return false;
  48
  49     node = st_parser_parse (lexer, error);
  50     st_lexer_destroy (lexer);
  51
  52     if (!node)
  53         return false;
  54
  55     method = st_generate_method (class, node, error);
  56     if (method == ST_NIL) {
  57         st_node_destroy (node);
  58         return false;
  59     }
  60
  61     st_dictionary_at_put (ST_BEHAVIOR (class)->method_dictionary,
  62                           node->method.selector,
  63                           method);
  64
  65     st_node_destroy (node);
  66
  67     return true;
  68 }
  69
  70 static void
  71 filein_error (FileInParser *parser, st_token *token, const char *message)
  72 {
  73     fprintf (stderr, "%s: %i: %s\n", parser->filename, parser->line + ((token) ? st_token_get_line (token) : -90), message);
  74     exit (1);
  75 }
  76
  77
  78 static st_token *
  79 next_token (FileInParser *parser, st_lexer *lexer)
  80 {
  81     st_token *token;
  82
  83     token = st_lexer_next_token (lexer);
  84
  85     if (st_token_get_type (token) == ST_TOKEN_COMMENT)
  86         return next_token (parser, lexer);
  87     else if (st_token_get_type (token) == ST_TOKEN_INVALID)
  88         filein_error (parser, token, st_lexer_error_message (lexer));
  89
  90     return token;
  91 }
  92
  93
  94 static st_lexer *
  95 next_chunk (FileInParser *parser)
  96 {
  97     st_lexer *lexer;
  98     char *chunk;
  99
 100     parser->line = st_input_get_line (parser->input);
 101
 102     chunk = st_input_next_chunk (parser->input);
 103     if (!chunk)
 104         return NULL;
 105
 106     lexer = st_lexer_new (chunk);
 107
 108     st_free (chunk);
 109     return lexer;
 110 }
 111
 112 static void
 113 parse_method (FileInParser *parser,
 114               st_lexer      *lexer,
 115               char         *class_name,
 116               bool          class_method)
 117 {
 118     st_token *token = NULL;
 119     st_oop   class;
 120     st_compiler_error error;
 121
 122     st_lexer_destroy (lexer);
 123
 124     /* get class or metaclass */
 125     class = st_global_get (class_name);
 126     if (class == ST_NIL)
 127         filein_error (parser, token, "undefined class");
 128
 129     if (class_method)
 130         class = st_object_class (class);
 131
 132     /* parse method chunk */
 133     lexer = next_chunk (parser);
 134     if (!lexer)
 135         filein_error (parser, token, "expected method definition");
 136
 137     st_node *node;
 138     st_oop method;
 139
 140     node = st_parser_parse (lexer, &error);
 141     if (node == NULL)
 142         goto error;
 143     if (node->type != ST_METHOD_NODE)
 144         printf ("%i\n", node->type);
 145
 146     method = st_generate_method (class, node, &error);
 147     if (method == ST_NIL)
 148         goto error;
 149
 150     st_dictionary_at_put (ST_BEHAVIOR (class)->method_dictionary,
 151                           node->method.selector,
 152                           method);
 153
 154
 155     st_node_destroy (node);
 156     st_lexer_destroy (lexer);
 157     st_free (class_name);
 158
 159     return;
 160
 161 error:
 162     st_node_destroy (node);
 163     fprintf (stderr, "%s:%i: %s\n", parser->filename,
 164              parser->line + error.line - 1 ,
 165              error.message);
 166     exit (1);
 167 }
 168
 169 static void
 170 parse_class (FileInParser *parser, st_lexer *lexer, char *name)
 171 {
 172
 173
 174 }
 175
 176 static void
 177 parse_chunk (FileInParser *parser, st_lexer *lexer)
 178 {
 179     st_token *token;
 180     char *name;
 181
 182     token = next_token (parser, lexer);
 183
 184     if (st_token_get_type (token) == ST_TOKEN_IDENTIFIER) {
 185
 186         name = st_strdup (st_token_get_text (token));
 187
 188         token = next_token (parser, lexer);
 189
 190         if (st_token_get_type (token) == ST_TOKEN_IDENTIFIER
 191             && (streq (st_token_get_text (token), "method")))
 192
 193             parse_method (parser, lexer, name, false);
 194
 195         else if (st_token_get_type (token) == ST_TOKEN_IDENTIFIER
 196                  || streq (st_token_get_text (token), "classMethod"))
 197
 198             parse_method (parser, lexer, name, true);
 199
 200         else if (st_token_get_type (token) == ST_TOKEN_KEYWORD_SELECTOR
 201                  && streq (st_token_get_text (token), "subclass:"))
 202
 203             parse_class (parser, lexer, name);
 204
 205         else if (streq (name, "Annotation") &&
 206                  st_token_get_type (token) == ST_TOKEN_KEYWORD_SELECTOR &&
 207                  streq (st_token_get_text (token), "key:")) {
 208
 209             return;
 210
 211         }
 212         else
 213             goto error;
 214
 215     } else
 216         goto error;
 217
 218     return;
 219
 220 error:
 221
 222     filein_error (parser, token, "unrecognised syntax");
 223 }
 224
 225 static void
 226 parse_chunks (FileInParser *parser)
 227 {
 228     st_lexer *lexer;
 229
 230     while (st_input_look_ahead (parser->input, 1) != ST_INPUT_EOF) {
 231
 232         lexer = next_chunk (parser);
 233         if (!lexer)
 234             continue;
 235
 236         parse_chunk (parser, lexer);
 237     }
 238 }
 239
 240 /* isn't declared in glibc string.h */
 241 char * basename (const char *FILENAME);
 242
 243 void
 244 st_compile_file_in (const char *filename)
 245 {
 246     char *buffer;
 247     FileInParser *parser;
 248
 249     st_assert (filename != NULL);
 250
 251     if (!st_file_get_contents (filename, &buffer)) {
 252         return;
 253     }
 254
 255     parser = st_new0 (FileInParser);
 256
 257     parser->input = st_input_new (buffer);
 258     if (!parser->input) {
 259         fprintf (stderr, "could not validate input file '%s'", filename);
 260         return;
 261     }
 262
 263     parser->filename = basename (filename);
 264     parser->line     = 1;
 265
 266     parse_chunks (parser);
 267
 268     st_free (buffer);
 269     st_input_destroy (parser->input);
 270     st_free (parser);
 271 }