libs/iovm/source/IoCompiler.c

   1
   2 //metadoc Compiler copyright Steve Dekorte 2002
   3 //metadoc Compiler license BSD revised
   4 /*metadoc Compiler description
   5 Contains methods related to the compiling code.
   6 */
   7 //metadoc Compiler category Core
   8
   9 #include "IoCompiler.h"
  10 #include "IoNumber.h"
  11 #include "IoMessage_parser.h"
  12 #include "IoLexer.h"
  13 #include "IoToken.h"
  14 #include "IoList.h"
  15
  16 IoObject *IoCompiler_proto(void *state)
  17 {
  18         IoMethodTable methodTable[] = {
  19         {"tokensForString", IoObject_tokensForString},
  20         //{"messageForTokens", IoObject_messageForTokens},
  21         {"messageForString", IoObject_messageForString},
  22         {"messageForString2", IoObject_messageForString2},
  23         {NULL, NULL},
  24         };
  25
  26         IoObject *self = IoObject_new(state);
  27         IoObject_setSlot_to_(self, IOSYMBOL("type"), IOSYMBOL("Compiler"));
  28         IoObject_addMethodTable_(self, methodTable);
  29
  30         return self;
  31 }
  32
  33 IoObject *IoObject_tokensForString(IoObject *self, IoObject *locals, IoMessage *m)
  34 {
  35         /*doc Compiler tokensForString(aString)
  36         Returns a list of token objects lexed from the input string.
  37 */
  38
  39         IoSymbol *text = IoMessage_locals_seqArgAt_(m, locals, 0);
  40         IoList *tokensList = IoList_new(IOSTATE);
  41         IoLexer *lexer = IoLexer_new();
  42         IoSymbol *name = IOSYMBOL("name");
  43         IoSymbol *line = IOSYMBOL("line");
  44         IoSymbol *character = IOSYMBOL("character");
  45         IoSymbol *type = IOSYMBOL("type");
  46
  47         IoLexer_string_(lexer, CSTRING(text));
  48         IoLexer_lex(lexer);
  49
  50         if (IoLexer_errorToken(lexer))
  51         {
  52                 IoSymbol *errorString  = IOSYMBOL(IoLexer_errorDescription(lexer));
  53                 IoLexer_free(lexer);
  54                 IoState_error_(IOSTATE, NULL, "compile error: %s", CSTRING(errorString));
  55         }
  56         else
  57         {
  58                 IoToken *t;
  59
  60                 while ((t = IoLexer_pop(lexer)))
  61                 {
  62                         IoObject *tokenObject = IoObject_new(IOSTATE);
  63
  64                         IoObject_setSlot_to_(tokenObject, name, IOSYMBOL(IoToken_name(t)));
  65                         IoObject_setSlot_to_(tokenObject, line, IONUMBER(IoToken_lineNumber(t)));
  66                         IoObject_setSlot_to_(tokenObject, character, IONUMBER(IoToken_charNumber(t)));
  67                         IoObject_setSlot_to_(tokenObject, type, IOSYMBOL(IoToken_typeName(t)));
  68
  69                         IoList_rawAppend_(tokensList, tokenObject);
  70                 }
  71         }
  72
  73         IoLexer_free(lexer);
  74
  75         return tokensList;
  76 }
  77
  78 IoObject *IoObject_messageForTokens(IoObject *self, IoObject *locals, IoMessage *m)
  79 {
  80         /*doc Compiler messageForTokens(aList)
  81         Returns the compiled message object for the given token list.
  82         */
  83
  84         return m;
  85 }
  86
  87 IoObject *IoObject_messageForString(IoObject *self, IoObject *locals, IoMessage *m)
  88 {
  89         /*doc Compiler messageForString(aString, optionalLabelString)
  90         Returns the compiled message object for aString.
  91         */
  92
  93         IoSymbol *string = IoMessage_locals_seqArgAt_(m, locals, 0);
  94         IoSymbol *label  = IoMessage_rawLabel(m);
  95         IoObject *result = IONIL(self);
  96
  97         if (IoMessage_argCount(m) > 1)
  98         {
  99                 label = IoMessage_locals_symbolArgAt_(m, locals, 1);
 100         }
 101
 102         return IoMessage_newFromText_labelSymbol_(IOSTATE, CSTRING((IoSymbol *)string), (IoSymbol *)label);
 103 }
 104
 105
 106 IoObject *IoObject_messageForString2(IoObject *self, IoObject *locals, IoMessage *m)
 107 {
 108         IoLexer *lexer = IoLexer_new();
 109         char *text = IoMessage_locals_cStringArgAt_(m, locals, 0);
 110         IoMessage *msg;
 111
 112         IoLexer_string_(lexer, text);
 113         IoLexer_lex(lexer);
 114
 115         msg = IoMessage_newParse(IOSTATE, lexer);
 116
 117         IoLexer_free(lexer);
 118         return msg;
 119 }