libs/iovm/source/IoMessage.c

   1 /*#io
   2 Message ioDoc(
   3               docCopyright("Steve Dekorte", 2002)
   4               docLicense("BSD revised")
   5               docObject("Message")
   6               docDescription("""A Message object encapsulates the action of a message send. Blocks are composed of a Message and its children.
   7
   8 Terminology
   9
  10 Example;
  11 A B(C D); E F
  12 In the above example:
  13 ...
  14
  15
  16 Important; Modifying the message tree of a block currently in use may cause
  17 a crash if a garbage collection cycle occurs. If the implementation were
  18 changed to retain every called message, this could be avoided.
  19 But the cost to performance seems to outweigh the need to cover this case for now.
  20 """)
  21 docCategory("Core")
  22 */
  23
  24 #include "IoObject.h"
  25 #define IOMESSAGE_C
  26 #include "IoMessage.h"
  27 #undef IOMESSAGE_C
  28 #include "IoSeq.h"
  29 #include "IoMap.h"
  30 #include "IoNumber.h"
  31 #include "IoState.h"
  32 #include "IoCFunction.h"
  33 #include "IoBlock.h"
  34 #include "IoList.h"
  35 #include "IoDate.h"
  36 #include "IoSeq.h"
  37 #include <ctype.h>
  38 #include <stdarg.h>
  39 #include "IoMessage_parser.h"
  40 #include "IoMessage_opShuffle.h"
  41
  42 #define DATA(self) ((IoMessageData *)IoObject_dataPointer(self))
  43
  44 void IoMessage_writeToStream_(IoMessage *self, BStream *stream)
  45 {
  46         UArray *ba = IoMessage_description(self);
  47         BStream_writeTaggedUArray_(stream, ba);
  48         UArray_free(ba);
  49 }
  50
  51 void IoMessage_readFromStream_(IoMessage *self, BStream *stream)
  52 {
  53         const char *code = BStream_readTaggedCString(stream);
  54         IoMessage *m = IoMessage_newFromText_label_(IOSTATE, (char *)code, "[from store]");
  55         IoMessage_copy_(self, m);
  56 }
  57
  58 IoObject *IoMessage_activate(IoMessage *self, IoObject *target, IoObject *locals, IoMessage *m, IoObject *slotContext)
  59 {
  60         //printf("activating self %s\n", CSTRING(IoMessage_name(self)));
  61         //printf("activating m %s\n", CSTRING(IoMessage_name(m)));
  62
  63         return IoMessage_locals_performOn_(self, locals, locals);
  64         //return IoObject_perform(locals, locals, self);
  65 }
  66
  67 IoTag *IoMessage_newTag(void *state)
  68 {
  69         IoTag *tag = IoTag_newWithName_("Message");
  70         IoTag_state_(tag, state);
  71         IoTag_cloneFunc_(tag, (IoTagCloneFunc *)IoMessage_rawClone);
  72         IoTag_freeFunc_(tag, (IoTagFreeFunc *)IoMessage_free);
  73         IoTag_markFunc_(tag, (IoTagMarkFunc *)IoMessage_mark);
  74         IoTag_writeToStreamFunc_(tag, (IoTagWriteToStreamFunc *)IoMessage_writeToStream_);
  75         IoTag_readFromStreamFunc_(tag, (IoTagReadFromStreamFunc *)IoMessage_readFromStream_);
  76         IoTag_activateFunc_(tag, (IoTagActivateFunc *)IoMessage_activate);
  77         return tag;
  78 }
  79
  80 IoMessage *IoMessage_proto(void *state)
  81 {
  82         IoMethodTable methodTable[] = {
  83         {"clone", IoMessage_clone},
  84
  85         {"name", IoMessage_protoName},
  86         {"setName", IoMessage_protoSetName},
  87
  88         {"next", IoMessage_next},
  89         {"setNext", IoMessage_setNext},
  90         {"isEndOfLine", IoMessage_isEOL},
  91         {"nextIgnoreEndOfLines", IoMessage_nextIgnoreEOLs},
  92         {"last", IoMessage_last},
  93         {"lastBeforeEndOfLine", IoMessage_lastBeforeEOL},
  94
  95         {"argAt", IoMessage_argAt},
  96         {"arguments", IoMessage_arguments},
  97         {"setArguments", IoMessage_setArguments},
  98         {"appendArg", IoMessage_appendArg},
  99         {"appendCachedArg", IoMessage_appendCachedArg},
 100         {"argCount", IoMessage_argCount_},
 101
 102         {"cachedResult", IoMessage_cachedResult},
 103         {"setCachedResult", IoMessage_setCachedResult},
 104         {"removeCachedResult", IoMessage_removeCachedResult},
 105         {"hasCachedResult", IoMessage_hasCachedResult},
 106
 107         {"lineNumber", IoMessage_lineNumber},
 108         {"setLineNumber", IoMessage_setLineNumber},
 109
 110         {"characterNumber", IoMessage_characterNumber},
 111         {"setCharacterNumber", IoMessage_setCharacterNumber},
 112
 113         {"label", IoMessage_label},
 114         {"setLabel", IoMessage_setLabel},
 115
 116         {"code", IoMessage_descriptionString},
 117         {"doInContext", IoMessage_doInContext},
 118         {"fromString", IoMessage_fromString},
 119         {"argsEvaluatedIn", IoMessage_argsEvaluatedIn},
 120         {"asString", IoMessage_asString},
 121
 122         {"asMessageWithEvaluatedArgs", IoMessage_asMessageWithEvaluatedArgs},
 123
 124         {"opShuffle", IoMessage_opShuffle},
 125         {"opShuffleC", IoMessage_opShuffle},
 126
 127         {NULL, NULL},
 128         };
 129
 130         IoObject *self = IoObject_new(state);
 131         IoMessageData *d;
 132         IoObject_setDataPointer_(self, io_calloc(1, sizeof(IoMessageData)));
 133         d = IoObject_dataPointer(self);
 134
 135         IoObject_tag_(self, IoMessage_newTag(state));
 136         d->args  = List_new();
 137         d->name  = IOSYMBOL("[unnamed]");
 138         d->label = IOSYMBOL("[unlabeled]");
 139         //d->charNumber = -1;
 140         d->lineNumber = -1;
 141         IoState_registerProtoWithFunc_((IoState *)state, self, IoMessage_proto);
 142
 143         IoObject_addMethodTable_(self, methodTable);
 144         return self;
 145 }
 146
 147 IoMessage *IoMessage_rawClone(IoMessage *proto)
 148 {
 149         IoObject *self = IoObject_rawClonePrimitive(proto);
 150
 151         IoObject_setDataPointer_(self, io_calloc(1, sizeof(IoMessageData)));
 152         DATA(self)->args = List_new();
 153         DATA(self)->name = DATA(proto)->name;
 154         DATA(self)->label = DATA(proto)->label;
 155         /* any clone really needs to be a deep copy */
 156         return self;
 157 }
 158
 159 IoMessage *IoMessage_new(void *state)
 160 {
 161         IoObject *proto = IoState_protoWithInitFunction_((IoState *)state, IoMessage_proto);
 162         IoObject *self = IOCLONE(proto);
 163         return self;
 164 }
 165
 166 // Message shallowCopy := method(Message clone setName(name) setArguments(arguments))
 167
 168 void IoMessage_copy_(IoMessage *self, IoMessage *other)
 169 {
 170         DATA(self)->name = IOREF(DATA(other)->name);
 171
 172         {
 173                 List *l1 = DATA(self)->args;
 174                 List *l2 = DATA(other)->args;
 175                 int i, max = List_size(l2);
 176                 List_removeAll(l1);
 177
 178                 for (i = 0; i < max; i ++)
 179                 {
 180                         List_append_(l1, IOREF(List_rawAt_(l2, i)));
 181                 }
 182         }
 183
 184
 185         if (DATA(other)->next) IOREF(DATA(other)->next);
 186         DATA(self)->next = DATA(other)->next;
 187
 188         if (DATA(other)->cachedResult) IOREF(DATA(other)->cachedResult);
 189         DATA(self)->cachedResult = DATA(other)->cachedResult;
 190
 191         //DATA(self)->charNumber = DATA(other)->charNumber;
 192         DATA(self)->lineNumber = DATA(other)->lineNumber;
 193
 194         if (DATA(other)->label) IOREF(DATA(other)->label);
 195         DATA(self)->label = DATA(other)->label;
 196 }
 197
 198 IoMessage *IoMessage_deepCopyOf_(IoMessage *self)
 199 {
 200         IoMessage *child = IoMessage_new(IOSTATE);
 201         int i;
 202
 203         /*printf("deep copying: %s\n", UArray_asCString(IoMessage_description(self)));*/
 204         for (i = 0; i < IoMessage_argCount(self); i ++)
 205         {
 206                 List_append_(DATA(child)->args,
 207                                    IOREF(IoMessage_deepCopyOf_(LIST_AT_(DATA(self)->args, i))));
 208         }
 209
 210         DATA(child)->name = IOREF(DATA(self)->name);
 211         IoMessage_cachedResult_(child, (IoObject *)DATA(self)->cachedResult);
 212
 213         if (DATA(self)->next)
 214         {
 215                 DATA(child)->next = IOREF(IoMessage_deepCopyOf_(DATA(self)->next));
 216         }
 217         /*printf("deep copy result: %s\n", UArray_asCString(IoMessage_description(child)));*/
 218         return child;
 219 }
 220
 221 IoMessage *IoMessage_newWithName_(void *state, IoSymbol *symbol)
 222 {
 223         IoMessage *self = IoMessage_new(state);
 224         DATA(self)->name = IOREF(symbol);
 225         return self;
 226 }
 227
 228 IoMessage *IoMessage_newWithName_label_(void *state, IoSymbol *symbol, IoSymbol *label)
 229 {
 230         IoMessage *self = IoMessage_new(state);
 231         DATA(self)->name  = IOREF(symbol);
 232         DATA(self)->label = IOREF(label);
 233         return self;
 234 }
 235
 236 IoMessage *IoMessage_newWithName_returnsValue_(void *state, IoSymbol *symbol, IoObject *v)
 237 {
 238         IoMessage *self = IoMessage_new(state);
 239         DATA(self)->name         = IOREF(symbol);
 240         DATA(self)->cachedResult = IOREF(v);
 241         return self;
 242 }
 243
 244 IoMessage *IoMessage_newWithName_andCachedArg_(void *state, IoSymbol *symbol, IoObject *arg)
 245 {
 246         IoMessage *self = IoMessage_newWithName_(state, symbol);
 247         IoMessage_addCachedArg_(self, arg);
 248         return self;
 249 }
 250
 251 void IoMessage_mark(IoMessage *self)
 252 {
 253         IoObject_shouldMarkIfNonNull(DATA(self)->name);
 254
 255         if (DATA(self)->args)
 256         {
 257                 LIST_FOREACH(DATA(self)->args, i, v, IoObject_shouldMark(v));
 258         }
 259
 260         IoObject_shouldMarkIfNonNull(DATA(self)->cachedResult);
 261         IoObject_shouldMarkIfNonNull((IoObject *)DATA(self)->next);
 262         IoObject_shouldMarkIfNonNull((IoObject *)DATA(self)->label);
 263 }
 264
 265 void IoMessage_free(IoMessage *self)
 266 {
 267         if (DATA(self)->args)
 268         {
 269                 List_free(DATA(self)->args);
 270         }
 271
 272         io_free(IoObject_dataPointer(self));
 273 }
 274
 275 List *IoMessage_args(IoMessage *self)
 276 {
 277         return DATA(self)->args;
 278 }
 279
 280 void IoMessage_cachedResult_(IoMessage *self, IoObject *v)
 281 {
 282         DATA(self)->cachedResult = v ? IOREF(v) : NULL;
 283 }
 284
 285 void IoMessage_label_(IoMessage *self, IoSymbol *ioSymbol) /* sets label for children too */
 286 {
 287         DATA(self)->label = IOREF(ioSymbol);
 288         List_do_with_(DATA(self)->args, (ListDoWithCallback *)IoMessage_label_, ioSymbol);
 289
 290         if (DATA(self)->next)
 291         {
 292                 IoMessage_label_(DATA(self)->next, ioSymbol);
 293         }
 294 }
 295
 296 int IoMessage_rawLineNumber(IoMessage *self)
 297 {
 298         return DATA(self)->lineNumber;
 299 }
 300
 301 void IoMessage_rawSetLineNumber_(IoMessage *self, int n)
 302 {
 303         DATA(self)->lineNumber = n;
 304 }
 305
 306 void IoMessage_rawSetCharNumber_(IoMessage *self, int n)
 307 {
 308         //DATA(self)->charNumber = n;
 309 }
 310
 311 int IoMessage_rawCharNumber(IoMessage *self)
 312 {
 313         return 0; //DATA(self)->charNumber;
 314 }
 315
 316 List *IoMessage_rawArgList(IoMessage *self)
 317 {
 318         return DATA(self)->args;
 319 }
 320
 321 unsigned char IoMessage_isNotCached(IoMessage *self)
 322 {
 323         return !(DATA(self)->cachedResult);
 324 }
 325
 326 unsigned char IoMessage_needsEvaluation(IoMessage *self)
 327 {
 328         List *args = DATA(self)->args;
 329         int a = List_detect_(args, (ListDetectCallback *)IoMessage_isNotCached) != NULL;
 330
 331         if (a)
 332         {
 333                 return 1;
 334         }
 335
 336         if (DATA(self)->next && IoMessage_needsEvaluation(DATA(self)->next))
 337         {
 338                 return 1;
 339         }
 340
 341         return 0;
 342 }
 343
 344 void IoMessage_addCachedArg_(IoMessage *self, IoObject *v)
 345 {
 346         IoMessage *m = IoMessage_new(IOSTATE);
 347         IoMessage_cachedResult_(m, v);
 348         IoMessage_addArg_(self, m);
 349 }
 350
 351 void IoMessage_setCachedArg_to_(IoMessage *self, int n, IoObject *v)
 352 {
 353         IoMessage *arg;
 354
 355         while (!(arg = List_at_(DATA(self)->args, n)))
 356         {
 357                 IoMessage_addArg_(self, IoMessage_new(IOSTATE));
 358         }
 359
 360         IoMessage_cachedResult_(arg, v);
 361 }
 362
 363 void IoMessage_setCachedArg_toInt_(IoMessage *self, int n, int anInt)
 364 {
 365         // optimized to avoid creating a number unless necessary
 366
 367         IoMessage *arg = NULL;
 368
 369         while (!(arg = List_at_(DATA(self)->args, n)))
 370         {
 371                 List_append_(DATA(self)->args, IOREF(IoMessage_new(IOSTATE)));
 372         }
 373
 374         DATA(arg)->cachedResult = IOREF(IONUMBER(anInt));
 375 }
 376
 377 IoObject *IoMessage_lineNumber(IoMessage *self, IoObject *locals, IoMessage *m)
 378 {
 379         /*#io
 380         docSlot("lineNumber",
 381                    "Returns the line number of the message. The charcter number
 382 is typically the line number in the source text from with the message was read. ")
 383         */
 384
 385         return IONUMBER(DATA(self)->lineNumber);
 386 }
 387
 388 IoObject *IoMessage_setLineNumber(IoMessage *self, IoObject *locals, IoMessage *m)
 389 {
 390         /*#io
 391         docSlot("setLineNumber(aNumber)", "Sets the line number of the message. Returns self.")
 392         */
 393
 394         DATA(self)->lineNumber = IoMessage_locals_intArgAt_(m , locals, 0);
 395         return self;
 396 }
 397
 398 IoObject *IoMessage_characterNumber(IoMessage *self, IoObject *locals, IoMessage *m)
 399 {
 400         /*#io
 401         docSlot("characterNumber",
 402                    "Returns the message character number. The charcter number is typically
 403 the beggining character index in the source text from with the message was read. ")
 404         */
 405
 406         return IONUMBER(0);
 407         //return IONUMBER(DATA(self)->charNumber);
 408 }
 409
 410 IoObject *IoMessage_setCharacterNumber(IoMessage *self, IoObject *locals, IoMessage *m)
 411 {
 412         /*#io
 413         docSlot("setCharacterNumber(aNumber)",
 414                    "Sets the character number of the message. Returns self.")
 415         */
 416
 417         //DATA(self)->charNumber = IoMessage_locals_intArgAt_(m , locals, 0);
 418         return self;
 419 }
 420
 421 IoObject *IoMessage_label(IoMessage *self, IoObject *locals, IoMessage *m)
 422 {
 423         /*#io
 424         docSlot("label",
 425                    "Returns the message label. The label is typically set the the
 426 name of the file from which the source code for the message was read.")
 427         */
 428
 429         return DATA(self)->label;
 430 }
 431
 432 IoObject *IoMessage_setLabel(IoMessage *self, IoObject *locals, IoMessage *m)
 433 {
 434         /*#io
 435         docSlot("setLabel(aString)", "Sets the label of the message and its children. Returns self.")
 436         */
 437
 438         IoMessage_label_(self, IoMessage_locals_symbolArgAt_(m , locals, 0));
 439         return self;
 440 }
 441
 442 // --- perform --------------------------------------------------------
 443
 444 IoObject *IoMessage_doInContext(IoMessage *self, IoObject *locals, IoMessage *m)
 445 {
 446         /*
 447         docSlot("doInContext(anObject, locals)", "Evaluates the receiver in the context of anObject. ")
 448         */
 449
 450         IoObject *context = IoMessage_locals_valueArgAt_(m, (IoObject *)locals, 0);
 451         if (IoMessage_argCount(m) >= 2)
 452         {
 453                 locals = IoMessage_locals_valueArgAt_(m, (IoObject *)locals, 1);
 454         }
 455         else
 456         {
 457                 // Default to using the context as the locals so that the common case of,
 458                 // call argAt(2) doInContext(call sender) is easier.
 459                 locals = context;
 460         }
 461         return IoMessage_locals_performOn_(self, locals, context);
 462 }
 463
 464 //#define IO_DEBUG_STACK
 465
 466 IoObject *IoMessage_locals_performOn_(IoMessage *self, IoObject *locals, IoObject *target)
 467 {
 468         IoState *state = IOSTATE;
 469         IoMessage *m = self;
 470         IoObject *result = target;
 471         //IoObject *semicolonSymbol = state->semicolonSymbol;
 472         //IoMessageData *md;
 473         IoMessageData *md;
 474
 475         do
 476         {
 477                 //md = DATA(m);
 478                 //printf("%s %i\n", CSTRING(IoMessage_name(m)), state->stopStatus);
 479                 //printf("%s\n", CSTRING(IoMessage_name(m)));
 480                 md = DATA(m);
 481
 482                 if(md->name == state->semicolonSymbol)
 483                 {
 484                         target = locals;
 485                 }
 486                 else
 487                 {
 488                         result = md->cachedResult; // put it on the stack?
 489                         /*
 490                         if(state->debugOn)
 491                         {
 492                                 char *s = CSTRING(DATA(m)->name);
 493                                 printf("%s\n", s);
 494                                 if (strcmp(s, "clone") == 0)
 495                                 {
 496                                         printf("found '%s'\n", s);
 497                                 }
 498                         }
 499                         */
 500
 501                         if (!result)
 502                         {
 503                                 IoState_pushRetainPool(state);
 504 #ifdef IOMESSAGE_INLINE_PERFORM
 505                                 if(IoObject_tag(target)->performFunc == NULL)
 506                                 {
 507                                         result = IoObject_perform(target, locals, m);
 508                                 }
 509                                 else
 510                                 {
 511                                         result = IoObject_tag(target)->performFunc(target, locals, m);
 512                                 }
 513 #else
 514                                 result = IoObject_tag(target)->performFunc(target, locals, m);
 515 #endif
 516                                 IoState_popRetainPoolExceptFor_(state, result);
 517                         }
 518
 519                         //IoObject_freeIfUnreferenced(target);
 520                         target = result;
 521
 522                         if (state->stopStatus != MESSAGE_STOP_STATUS_NORMAL)
 523                         {
 524                                         return state->returnValue;
 525                                         /*
 526                                         result = state->returnValue;
 527
 528                                         if (result)
 529                                         {
 530                                                 //IoState_stackRetain_(state, result);
 531                                                 return result;
 532                                         }
 533                                         printf("IoBlock no result!\n");
 534                                         return state->ioNil;
 535                                         */
 536                         }
 537                 }
 538         } while (m = md->next);
 539
 540         return result;
 541 }
 542
 543 // getting arguments ---------------------------
 544
 545 int IoMessage_argCount(IoMessage *self)
 546 {
 547         return List_size(DATA(self)->args);
 548 }
 549
 550 void IoMessage_assertArgCount_receiver_(IoMessage *self, int n, IoObject *receiver)
 551 {
 552         if (List_size(DATA(self)->args) < n)
 553         {
 554                 IoState_error_(IOSTATE, self, "[%s %s] requires %i arguments\n",
 555                                                           IoObject_name(receiver), CSTRING(DATA(self)->name), n);
 556         }
 557 }
 558
 559 void IoMessage_locals_numberArgAt_errorForType_(IoMessage *self,
 560                                                                            IoObject *locals,
 561                                                                            int n,
 562                                                                            const char *typeName)
 563 {
 564         IoObject *v = IoMessage_locals_valueArgAt_(self, locals, n);
 565         IoState_error_(IOSTATE, self, "argument %i to method '%s' must be a %s, not a '%s'",
 566                                                   n, CSTRING(DATA(self)->name), typeName, IoObject_name(v));
 567 }
 568
 569 IoObject *IoMessage_locals_numberArgAt_(IoMessage *self, IoObject *locals, int n)
 570 {
 571         IoObject *v = IoMessage_locals_valueArgAt_(self, locals, n);
 572
 573         if (!ISNUMBER(v))
 574         {
 575                 IoMessage_locals_numberArgAt_errorForType_(self, locals, n, "Number");
 576         }
 577
 578         return v;
 579 }
 580
 581 int IoMessage_locals_intArgAt_(IoMessage *self, IoObject *locals, int n)
 582 {
 583         return IoNumber_asInt(IoMessage_locals_numberArgAt_(self, locals, n));
 584 }
 585
 586 long IoMessage_locals_longArgAt_(IoMessage *self, IoObject *locals, int n)
 587 {
 588         return IoNumber_asLong(IoMessage_locals_numberArgAt_(self, locals, n));
 589 }
 590
 591 size_t IoMessage_locals_sizetArgAt_(IoMessage *self, IoObject *locals, int n)
 592 {
 593         long v = IoNumber_asLong(IoMessage_locals_numberArgAt_(self, locals, n));
 594
 595         if(v < 0)
 596         {
 597                 IoState_error_(IOSTATE, self, "IoMessage_locals_sizetArgAt_ attempt to get size_t value from negative number %i", v);
 598                 return 0;
 599         }
 600
 601         return v;
 602 }
 603
 604 double IoMessage_locals_doubleArgAt_(IoMessage *self, IoObject *locals, int n)
 605 {
 606         return IoNumber_asDouble(IoMessage_locals_numberArgAt_(self, locals, n));
 607 }
 608
 609 float IoMessage_locals_floatArgAt_(IoMessage *self, IoObject *locals, int n)
 610 {
 611         return (float)IoNumber_asDouble(IoMessage_locals_numberArgAt_(self, locals, n));
 612 }
 613
 614 char *IoMessage_locals_cStringArgAt_(IoMessage *self, IoObject *locals, int n)
 615 {
 616         return CSTRING(IoMessage_locals_symbolArgAt_(self, locals, n));
 617 }
 618
 619 IoObject *IoMessage_locals_seqArgAt_(IoMessage *self, IoObject *locals, int n)
 620 {
 621         IoObject *v = IoMessage_locals_valueArgAt_(self, locals, n);
 622
 623         if (!ISSEQ(v))
 624         {
 625                 IoMessage_locals_numberArgAt_errorForType_(self, locals, n, "Sequence");
 626         }
 627
 628         return v;
 629 }
 630
 631 IoObject *IoMessage_locals_valueAsStringArgAt_(IoMessage *self, IoObject *locals, int n)
 632 {
 633         return IoObject_asString_(IoMessage_locals_valueArgAt_(self, locals, n), self);
 634 }
 635
 636 IoObject *IoMessage_locals_symbolArgAt_(IoMessage *self, IoObject *locals, int n)
 637 {
 638         IoObject *v = IoMessage_locals_valueArgAt_(self, locals, n);
 639
 640         if (!ISSEQ(v))
 641         {
 642                 IoMessage_locals_numberArgAt_errorForType_(self, locals, n, "Sequence");
 643         }
 644
 645         return IoSeq_rawAsSymbol(v);
 646 }
 647
 648 IoObject *IoMessage_locals_mutableSeqArgAt_(IoMessage *self, IoObject *locals, int n)
 649 {
 650         IoObject *v = IoMessage_locals_valueArgAt_(self, locals, n);
 651
 652         if (!ISMUTABLESEQ(v))
 653         {
 654                 IoMessage_locals_numberArgAt_errorForType_(self, locals, n, "mutable Sequence");
 655         }
 656
 657         return v;
 658 }
 659
 660 IoObject *IoMessage_locals_blockArgAt_(IoMessage *self, IoObject *locals, int n)
 661 {
 662         IoObject *v = IoMessage_locals_valueArgAt_(self, locals, n);
 663         if (!ISBLOCK(v)) IoMessage_locals_numberArgAt_errorForType_(self, locals, n, "Block");
 664         return v;
 665 }
 666
 667 IoObject *IoMessage_locals_dateArgAt_(IoMessage *self, IoObject *locals, int n)
 668 {
 669         IoObject *v = IoMessage_locals_valueArgAt_(self, locals, n);
 670         if (!ISDATE(v)) IoMessage_locals_numberArgAt_errorForType_(self, locals, n, "Date");
 671         return v;
 672 }
 673
 674 IoObject *IoMessage_locals_messageArgAt_(IoMessage *self, IoObject *locals, int n)
 675 {
 676         IoObject *v = IoMessage_locals_valueArgAt_(self, locals, n);
 677         if (!ISMESSAGE(v)) IoMessage_locals_numberArgAt_errorForType_(self, locals, n, "Message");
 678         return v;
 679 }
 680
 681 IoObject *IoMessage_locals_listArgAt_(IoMessage *self, IoObject *locals, int n)
 682 {
 683         IoObject *v = IoMessage_locals_valueArgAt_(self, locals, n);
 684         if (!ISLIST(v)) IoMessage_locals_numberArgAt_errorForType_(self, locals, n, "List");
 685         return v;
 686 }
 687
 688 IoObject *IoMessage_locals_mapArgAt_(IoMessage *self, IoObject *locals, int n)
 689 {
 690         IoObject *v = IoMessage_locals_valueArgAt_(self, locals, n);
 691         if (!ISMAP(v)) IoMessage_locals_numberArgAt_errorForType_(self, locals, n, "Map");
 692         return v;
 693 }
 694
 695 // printing
 696
 697 void IoMessage_print(IoMessage *self)
 698 {
 699         UArray *ba = IoMessage_description(self);
 700
 701         //printf("%s\n", UArray_asCString(ba));
 702         IoState_print_(IOSTATE, UArray_asCString(ba));
 703         UArray_free(ba);
 704 }
 705
 706 void IoMessage_printWithReturn(IoMessage *self)
 707 {
 708         IoMessage_print(self);
 709         IoState_print_(IOSTATE, "\n");
 710 }
 711
 712 UArray *IoMessage_description(IoMessage *self)
 713 {
 714         UArray *ba = UArray_new();
 715         IoMessage_appendDescriptionTo_follow_(self, ba, 1);
 716         return ba;
 717 }
 718
 719 UArray *IoMessage_descriptionJustSelfAndArgs(IoMessage *self)
 720 {
 721         UArray *ba = UArray_new();
 722         IoMessage_appendDescriptionTo_follow_(self, ba, 0);
 723         return ba;
 724 }
 725
 726 IoObject *IoMessage_asString(IoMessage *self, IoObject *locals, IoMessage *m)
 727 {
 728         /*#io
 729         docSlot("asString", "Same as code().")
 730         */
 731
 732         return IoMessage_descriptionString(self, locals, m);
 733 }
 734
 735 void IoMessage_appendDescriptionTo_follow_(IoMessage *self, UArray *ba, int follow)
 736 {
 737         do {
 738                 IoMessageData *data = DATA(self);
 739
 740                 UArray_appendCString_(ba, CSTRING(data->name));
 741
 742                 {
 743                         int i, max = List_size(DATA(self)->args);
 744
 745                         if (max > 0)
 746                         {
 747                                 UArray_appendCString_(ba, "(");
 748
 749                                 for (i = 0; i < max; i ++)
 750                                 {
 751                                         IoMessage *arg = List_at_(DATA(self)->args, i);
 752                                         IoMessage_appendDescriptionTo_follow_(arg, ba, 1);
 753
 754                                         if (i != max - 1)
 755                                         {
 756                                                 UArray_appendCString_(ba, ", ");
 757                                         }
 758                                 }
 759
 760                                 UArray_appendCString_(ba, ")");
 761                         }
 762                 }
 763
 764                 if (!follow)
 765                 {
 766                         return;
 767                 }
 768
 769                 if (DATA(self)->next && DATA(self)->name != IOSTATE->semicolonSymbol) UArray_appendCString_(ba, " ");
 770                 if (DATA(self)->name == IOSTATE->semicolonSymbol) UArray_appendCString_(ba, "\n");
 771         } while (self = DATA(self)->next);
 772 }
 773
 774 //  methods ---------------------------------------------------
 775
 776 IoObject *IoMessage_clone(IoMessage *self, IoObject *locals, IoMessage *m)
 777 {
 778         /*#io
 779         docSlot("clone", "Returns a Message that is a deep copy of the receiver. ")
 780         */
 781
 782         return IoMessage_deepCopyOf_(self);
 783 }
 784
 785 IoObject *IoMessage_protoName(IoMessage *self, IoObject *locals, IoMessage *m)
 786 {
 787         /*#io
 788         docSlot("name", "Returns the name of the receiver. ")
 789         */
 790
 791         IoObject *s = DATA(self)->name;
 792         return s;
 793 }
 794
 795 IoObject *IoMessage_protoSetName(IoMessage *self, IoObject *locals, IoMessage *m)
 796 {
 797         /*#io
 798         docSlot("setName(aString)", "Sets the name of the receiver. Returns self. ")
 799         */
 800
 801         DATA(self)->name = IOREF(IoMessage_locals_symbolArgAt_(m, locals, 0));
 802     //IoMessage_cacheIfPossible(self);
 803         return self;
 804 }
 805
 806 IoObject *IoMessage_descriptionString(IoMessage *self, IoObject *locals, IoMessage *m)
 807 {
 808         /*#io
 809         docSlot("code",
 810                    "Returns a String containing a decompiled code representation of the receiver.")
 811         */
 812
 813         UArray *ba = IoMessage_description(self); /* me must io_free the returned UArray */
 814         return IoState_symbolWithUArray_copy_(IOSTATE, ba, 0);
 815 }
 816
 817
 818 // next -------------------------
 819
 820 IoObject *IoMessage_next(IoMessage *self, IoObject *locals, IoMessage *m)
 821 {
 822         /*#io
 823         docSlot("next",
 824                    "Returns the next message in the message chain or nil if there is no next message. ")
 825         */
 826
 827         return DATA(self)->next ? (IoObject *)DATA(self)->next : IONIL(self);
 828 }
 829
 830 IoMessage *IoMessage_rawNext(IoMessage *self)
 831 {
 832         return DATA(self)->next;
 833 }
 834
 835 IoObject *IoMessage_setNext(IoMessage *self, IoObject *locals, IoMessage *m)
 836 {
 837         /*#io
 838         docSlot("setNextMessage(aMessageOrNil)",
 839                    "Sets the next message in the message chain to a deep copy of
 840 aMessage or it removes the next message if aMessage is nil. ")
 841         */
 842
 843         IoObject *v = IoMessage_locals_valueArgAt_(m , locals, 0);
 844         IOASSERT(ISMESSAGE(v) || ISNIL(v), "argument must be Message or Nil");
 845
 846         if (ISNIL(v))
 847         {
 848                 v = NULL;
 849         }
 850
 851         IoMessage_rawSetNext(self, v);
 852         return self;
 853 }
 854
 855 void IoMessage_rawSetNext(IoMessage *self, IoMessage *m)
 856 {
 857         DATA(self)->next = m ? IOREF(m) : NULL;
 858
 859 #ifdef IOMESSAGE_HASPREV
 860
 861         if(m)
 862         {
 863                 DATA(m)->previous = self;
 864         }
 865 #endif
 866 }
 867
 868 IoObject *IoMessage_isEOL(IoMessage *self, IoObject *locals, IoMessage *m)
 869 {
 870         /*#io
 871         docSlot("isEndOfLine", "Returns true if the message marks the end of the line. A ';' message.")
 872         */
 873
 874         return IOBOOL(self, IoMessage_rawIsEOL(self));
 875 }
 876
 877 int IoMessage_rawIsEOL(IoMessage *self)
 878 {
 879     return IoMessage_name(self) == IOSTATE->semicolonSymbol;
 880 }
 881
 882 IoMessage *IoMessage_rawNextIgnoreEOLs(IoMessage *self)
 883 {
 884         IoMessage *next = IoMessage_rawNext(self);
 885
 886         while (next && IoMessage_rawIsEOL(next))
 887         {
 888                 next = IoMessage_rawNext(next);
 889         }
 890
 891         return next;
 892 }
 893
 894 IoObject *IoMessage_nextIgnoreEOLs(IoMessage *self, IoObject *locals, IoMessage *m)
 895 {
 896         /*#io
 897         docSlot("nextIgnoreEndOfLines",
 898            "Returns the next message in the message chain which is not an EndOfLine or nil if there is no next message. ")
 899         */
 900
 901         IoMessage *next = IoMessage_rawNextIgnoreEOLs(self);
 902         return next ? next : IONIL(self);
 903 }
 904
 905 IoMessage *IoMessage_rawLastBeforeEOL(IoMessage *self)
 906 {
 907         IoMessage *last = self;
 908         IoMessage *next;
 909
 910         while (next = IoMessage_rawNext(last))
 911         {
 912                 if (IoMessage_rawIsEOL(next))
 913                 {
 914                         break;
 915                 }
 916                 last = next;
 917         }
 918
 919         return last;
 920 }
 921
 922 IoObject *IoMessage_lastBeforeEOL(IoMessage *self, IoObject *locals, IoMessage *m)
 923 {
 924         /*#io
 925         docSlot("lastBeforeEndOfLine",
 926            "Returns the last message in the chain before the EndOfLine or nil.")
 927         */
 928
 929         return IoMessage_rawLastBeforeEOL(self);
 930 }
 931
 932 IoMessage *IoMessage_rawLast(IoMessage *self)
 933 {
 934         IoMessage *last = self;
 935         IoMessage *next;
 936
 937         while (next = IoMessage_rawNext(last))
 938         {
 939                 last = next;
 940         }
 941
 942         return last;
 943 }
 944
 945 IoObject *IoMessage_last(IoMessage *self, IoObject *locals, IoMessage *m)
 946 {
 947         /*#io
 948         docSlot("last",
 949            "Returns the last message in the chain.")
 950         */
 951
 952         return IoMessage_rawLast(self);
 953 }
 954
 955 // previous -------------------------
 956
 957 IoObject *IoMessage_previous(IoMessage *self, IoObject *locals, IoMessage *m)
 958 {
 959         /*#io
 960         docSlot("previous",
 961                    "Returns the previous message in the message chain or Nil if there is no previous message. ")
 962         */
 963 #ifdef IOMESSAGE_HASPREV
 964         return DATA(self)->previous ? (IoObject *)DATA(self)->previous : IONIL(self);
 965 #else
 966         return IONIL(self);
 967 #endif
 968 }
 969
 970 IoMessage *IoMessage_rawPrevious(IoMessage *self)
 971 {
 972 #ifdef IOMESSAGE_HASPREV
 973         return DATA(self)->previous;
 974 #else
 975         return IONIL(self);
 976 #endif
 977 }
 978
 979 IoObject *IoMessage_setPrevious(IoMessage *self, IoObject *locals, IoMessage *m)
 980 {
 981         /*#io
 982         docSlot("setPrevious(aMessageOrNil)",
 983                    "Sets the previous message in the message chain to a deep copy of
 984 aMessage or it removes the previous message if aMessage is Nil. ")
 985         */
 986
 987         IoObject *v = IoMessage_locals_valueArgAt_(m , locals, 0);
 988         IOASSERT(ISMESSAGE(v) || ISNIL(v), "argument must be Message or Nil");
 989
 990         if (ISNIL(v))
 991         {
 992                 v = NULL;
 993         }
 994
 995         IoMessage_rawSetPrevious(self, v);
 996
 997         return self;
 998 }
 999
1000 void IoMessage_rawSetPrevious(IoMessage *self, IoMessage *m)
1001 {
1002 #ifdef IOMESSAGE_HASPREV
1003         DATA(self)->previous = m ? IOREF(m) : NULL;
1004
1005         if(m)
1006         {
1007                 DATA(m)->next = self;
1008         }
1009 #endif
1010 }
1011
1012 // ------------------------------------------------------
1013
1014 IoObject *IoMessage_argAt(IoMessage *self, IoObject *locals, IoMessage *m)
1015 {
1016         /*#io
1017         docSlot("argAt(indexNumber)",
1018                    "Returns Message object for the specified argument or Nil if none exists.")
1019         */
1020
1021         int index =  IoNumber_asInt(IoMessage_locals_numberArgAt_(m , locals, 0));
1022         IoObject *v = List_at_(DATA(self)->args, index);
1023         return v ? v : IONIL(self);
1024 }
1025
1026 IoObject *IoMessage_arguments(IoMessage *self, IoObject *locals, IoMessage *m)
1027 {
1028         /*#io
1029         docSlot("arguments",
1030                    "Returns a list of the message objects that act as the
1031 receiver's arguments. Modifying this list will not alter the actual
1032 list of arguments. Use the arguments_() method to do that. ")
1033         */
1034
1035         IoList *argsList = IoList_new(IOSTATE);
1036         IoList_rawAddBaseList_(argsList, DATA(self)->args);
1037         return argsList;
1038 }
1039
1040 IoObject *IoMessage_setArguments(IoMessage *self, IoObject *locals, IoMessage *m)
1041 {
1042         /*#io
1043         docSlot("setArguments(aListOfMessages)",
1044                    "Sets the arguments of the receiver to deep copies of
1045 those contained in aListOfMessages.  Returns self.")
1046         */
1047
1048         IoList *ioList = IoMessage_locals_listArgAt_(m, locals, 0);
1049         List *newArgs = IoList_rawList(ioList);
1050
1051         List_removeAll(DATA(self)->args);
1052
1053         LIST_FOREACH(newArgs, i, argMessage,
1054
1055                 if (!ISMESSAGE((IoMessage *)argMessage))
1056                 {
1057                         IoState_error_(IOSTATE, m, "arguments_() takes a list containing only Message objects");
1058                 }
1059
1060                 List_append_(DATA(self)->args, IOREF((IoMessage *)argMessage));
1061         );
1062
1063         return self;
1064 }
1065
1066 IoObject *IoMessage_appendArg(IoMessage *self, IoObject *locals, IoMessage *m)
1067 {
1068         /*#io
1069         docSlot("appendArg(aMessage)",
1070                    """Adds aMessage to the argument list of receiver. Examples,
1071                    <pre>
1072                    Io> message(a) appendArg(message(b))
1073                    ==> a(b)
1074
1075                    Io> message(a(1,2)) appendArg(message(3))
1076                    ==> a(1, 2, 3)
1077                    </pre>""")
1078         */
1079
1080         IoMessage *msg = IoMessage_locals_messageArgAt_(m, locals, 0);
1081         IoMessage_addArg_(self, msg);
1082         return self;
1083 }
1084
1085 IoObject *IoMessage_appendCachedArg(IoMessage *self, IoObject *locals, IoMessage *m)
1086 {
1087         /*#io
1088         docSlot("appendCachedArg(aValue)",
1089                    """Adds aValue to the argument list of receiver as a cachedResult.""")
1090         */
1091
1092         IoObject *v = IoMessage_locals_valueArgAt_(m, locals, 0);
1093         IoMessage_addCachedArg_(self, v);
1094         return self;
1095 }
1096
1097 IoObject *IoMessage_argCount_(IoMessage *self, IoObject *locals, IoMessage *m)
1098 {
1099         /*#io
1100         docSlot("argCount",
1101                    """Returns the number of arguments this message has. A faster way to do, msg arguments size. Examples,
1102                    <pre>
1103                    Io> message(a(1,2,3)) argCount
1104                    ==> 3
1105
1106                    Io> message(a) argCount
1107                    ==> 0
1108                    </pre>""")
1109         */
1110
1111         return IONUMBER(IoMessage_argCount(self));
1112 }
1113
1114 IoObject *IoMessage_fromString(IoMessage *self, IoObject *locals, IoMessage *m)
1115 {
1116         /*#io
1117         docSlot("fromString(aString)",
1118                    "Returns a new Message object for the compiled(but not executed)
1119 result of aString. ")
1120         */
1121
1122         IoSymbol *string = IoMessage_locals_symbolArgAt_(m, locals, 0);
1123         IoSymbol *label = DATA(m)->label;
1124
1125         if (IoMessage_argCount(m) > 1)
1126         {
1127                 label = IoMessage_locals_symbolArgAt_(m, locals, 1);
1128         }
1129
1130         return IoMessage_newFromText_labelSymbol_(IOSTATE, CSTRING(string), label);
1131 }
1132
1133 IoObject *IoMessage_cachedResult(IoMessage *self, IoObject *locals, IoMessage *m)
1134 {
1135         /*#io
1136         docSlot("cachedResult",
1137                    "Returns the cached result of the Message or Nil if there is none.")
1138         */
1139
1140         return (DATA(self)->cachedResult ? DATA(self)->cachedResult : IONIL(self));
1141 }
1142
1143 IoObject *IoMessage_setCachedResult(IoMessage *self, IoObject *locals, IoMessage *m)
1144 {
1145         /*#io
1146         docSlot("setCachedResult(anObject)",
1147                    "Sets the cached result of the message. Returns self.")
1148         */
1149
1150         DATA(self)->cachedResult = IOREF(IoMessage_locals_valueArgAt_(m , locals, 0));
1151         return self;
1152 }
1153
1154 IoObject *IoMessage_removeCachedResult(IoMessage *self, IoObject *locals, IoMessage *m)
1155 {
1156         /*#io
1157         docSlot("removeCachedResult", "Removes the cached result of the Message.")
1158         */
1159
1160         DATA(self)->cachedResult = NULL;
1161         return self;
1162 }
1163
1164 IoObject *IoMessage_hasCachedResult(IoMessage *self, IoObject *locals, IoMessage *m)
1165 {
1166         /*#io
1167         docSlot("hasCachedResult",
1168                    "Returns true if there is a cached result. Nil is a valid cached result.")
1169         */
1170
1171         return IOBOOL(self, DATA(self)->cachedResult == NULL);
1172 }
1173
1174 IoObject *IoMessage_argsEvaluatedIn(IoMessage *self, IoObject *locals, IoMessage *m)
1175 {
1176         /*#io
1177         docSlot("argsEvaluatedIn(anObject)",
1178                    "Returns a List containing the argument messages evaluated in the
1179 context of anObject. ")
1180         */
1181
1182         IoObject *context = IoMessage_locals_valueArgAt_(m, locals, 0);
1183         IoList *args = IoList_new(IOSTATE);
1184         int i;
1185
1186         for (i = 0; i < List_size(DATA(self)->args); i ++)
1187         {
1188                 IoObject *arg = IoMessage_locals_valueArgAt_(self, context, i);
1189                 IoList_rawAppend_(args, arg);
1190         }
1191         return args;
1192 }
1193
1194 IoObject *IoMessage_evaluatedArgs(IoMessage *self, IoObject *locals, IoMessage *m)
1195 {
1196         /*
1197          docSlot("evaluatedArgs",
1198                     "Returns a List containing the argument messages evaluated in the context.")
1199          */
1200
1201         IoList *args = IoList_new(IOSTATE);
1202         int i;
1203
1204         for (i = 0; i < List_size(DATA(self)->args); i ++)
1205         {
1206                 IoObject *arg = IoMessage_locals_valueArgAt_(self, locals, i);
1207                 IoList_rawAppend_(args, arg);
1208         }
1209
1210         return args;
1211 }
1212
1213 // ------------------------------
1214
1215 /*
1216  IoSymbol *IoMessage_name(IoMessage *self)
1217  {
1218          return DATA(self)->name;
1219  }
1220  */
1221
1222 IoSymbol *IoMessage_rawLabel(IoMessage *self)
1223 {
1224         return DATA(self)->label;
1225 }
1226
1227 List *IoMessage_rawArgs(IoMessage *self)
1228 {
1229         return DATA(self)->args;
1230 }
1231
1232 IoMessage *IoMessage_rawArgAt_(IoMessage *self, int n)
1233 {
1234         IoMessage *result = List_at_(DATA(self)->args, n);
1235         IoState_stackRetain_(IOSTATE, result);
1236         return result;
1237 }
1238
1239 void IoMessage_addArg_(IoMessage *self, IoMessage *m)
1240 {
1241         List_append_(DATA(self)->args, IOREF(m));
1242 }
1243
1244 // -------------------------------
1245
1246 UArray *IoMessage_asMinimalStackEntryDescription(IoMessage *self)
1247 {
1248         IoSymbol *name = IoMessage_name(self);
1249         IoSymbol *label = IoMessage_rawLabel(self);
1250         int lineNumber = IoMessage_rawLineNumber(self);
1251         return UArray_newWithFormat_("%s:%i %s", CSTRING(label), lineNumber, CSTRING(name));
1252 }
1253
1254 void IoMessage_foreachArgs(IoMessage *self,
1255                            IoObject *receiver,
1256                            IoSymbol **indexSlotName,
1257                            IoSymbol **valueSlotName,
1258                            IoMessage **doMessage)
1259 {
1260         int offset;
1261
1262         IoMessage_assertArgCount_receiver_(self, 2, receiver);
1263
1264         if (IoMessage_argCount(self) > 2)
1265         {
1266                 *indexSlotName = IoMessage_name(IoMessage_rawArgAt_(self, 0));
1267                 offset = 1;
1268         }
1269         else
1270         {
1271                 *indexSlotName = NULL; //IONIL(self);
1272                 offset = 0;
1273         }
1274
1275         *valueSlotName = IoMessage_name(IoMessage_rawArgAt_(self, 0 + offset));
1276         *doMessage = IoMessage_rawArgAt_(self, 1 + offset);
1277 }
1278
1279 IoMessage *IoMessage_asMessageWithEvaluatedArgs(IoMessage *self, IoObject *locals, IoMessage *m)
1280 {
1281         IoState *state = IOSTATE;
1282         IoMessage *sendMessage;
1283         int i, max = IoMessage_argCount(self);
1284         IoObject *context = locals;
1285
1286         if (IoMessage_argCount(m) > 0)
1287         {
1288                 context = IoMessage_locals_valueArgAt_(m, locals, 0);
1289         }
1290
1291         if (IoMessage_needsEvaluation(self))
1292         {
1293                 sendMessage = IoMessage_newWithName_(state, IoMessage_name(self));
1294         }
1295         else
1296         {
1297                 sendMessage = self;
1298         }
1299
1300         for (i = 0; i < max; i ++)
1301         {
1302                 IoMessage *arg = IoMessage_rawArgAt_(self, i);
1303                 IoObject *result = IoMessage_locals_performOn_(arg, context, context);
1304                 IoMessage_setCachedArg_to_(sendMessage, i, result);
1305         }
1306
1307         return sendMessage;
1308 }
1309