server/scsynth/SC_MiscCmds.cpp

   1 /*
   2         SuperCollider real time audio synthesis system
   3     Copyright (c) 2002 James McCartney. All rights reserved.
   4         http://www.audiosynth.com
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  19 */
  20
  21
  22 #include "SC_Lib.h"
  23 #include "SC_ComPort.h"
  24 #include "SC_CoreAudio.h"
  25 #include "SC_HiddenWorld.h"
  26 #include "SC_Graph.h"
  27 #include "SC_GraphDef.h"
  28 #include "SC_Group.h"
  29 #include "SC_UnitDef.h"
  30 #include <stdexcept>
  31 #include "SC_Lib_Cintf.h"
  32 #include "SC_SequencedCommand.h"
  33 #include <new>
  34 #include "SC_Prototypes.h"
  35 #include "scsynthsend.h"
  36
  37 extern int gMissingNodeID;
  38
  39 // returns number of bytes in an OSC string.
  40 int OSCstrlen(char *strin);
  41
  42 Node* Msg_GetNode(World *inWorld, sc_msg_iter& msg)
  43 {
  44         Node *node;
  45         if (msg.nextTag('i') == 's')
  46         {
  47                 const char* loc = msg.gets();
  48                 int32 nodeID = msg.geti();
  49                 gMissingNodeID = nodeID;
  50                 node = World_GetNode(inWorld, nodeID);
  51                 while (*loc)
  52                 {
  53                         if (!node) return 0;
  54                         switch (*loc)
  55                         {
  56                                 case 'h' :
  57                                         if (!node->mIsGroup) return 0;
  58                                         node = ((Group*)node)->mHead;
  59                                         break;
  60                                 case 't' :
  61                                         if (!node->mIsGroup) return 0;
  62                                         node = ((Group*)node)->mTail;
  63                                         break;
  64                                 case 'u' :
  65                                         node = &node->mParent->mNode;
  66                                         break;
  67                                 case 'p' :
  68                                         node = node->mPrev;
  69                                         break;
  70                                 case 'n' :
  71                                         node = node->mNext;
  72                                         break;
  73                         }
  74                         loc++;
  75                 }
  76         }
  77         else
  78         {
  79                 int32 nodeID = msg.geti();
  80                 gMissingNodeID = nodeID;
  81                 node = World_GetNode(inWorld, nodeID);
  82         }
  83         return node;
  84 }
  85
  86 Group* Msg_GetGroup(World *inWorld, sc_msg_iter& msg)
  87 {
  88         Node* node = Msg_GetNode(inWorld, msg);
  89         return node && node->mIsGroup ? (Group*)node : 0;
  90 }
  91
  92 Graph* Msg_GetGraph(World *inWorld, sc_msg_iter& msg)
  93 {
  94         Node* node = Msg_GetNode(inWorld, msg);
  95         return !node || node->mIsGroup ? 0 : (Graph*)node;
  96 }
  97
  98 SCErr meth_none(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
  99 SCErr meth_none(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
 100 {
 101         return kSCErr_None;
 102 }
 103
 104 SCErr meth_sync(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 105 SCErr meth_sync(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
 106 {
 107         CallSequencedCommand(SyncCmd, inWorld, inSize, inData, inReply);
 108         return kSCErr_None;
 109 }
 110
 111 SCErr meth_b_alloc(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 112 SCErr meth_b_alloc(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
 113 {
 114         CallSequencedCommand(BufAllocCmd, inWorld, inSize, inData, inReply);
 115         return kSCErr_None;
 116 }
 117
 118 SCErr meth_b_free(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 119 SCErr meth_b_free(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
 120 {
 121         CallSequencedCommand(BufFreeCmd, inWorld, inSize, inData, inReply);
 122
 123         return kSCErr_None;
 124 }
 125
 126 SCErr meth_b_close(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 127 SCErr meth_b_close(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
 128 {
 129         CallSequencedCommand(BufCloseCmd, inWorld, inSize, inData, inReply);
 130
 131         return kSCErr_None;
 132 }
 133
 134 SCErr meth_b_allocRead(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 135 SCErr meth_b_allocRead(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
 136 {
 137         CallSequencedCommand(BufAllocReadCmd, inWorld, inSize, inData, inReply);
 138
 139         return kSCErr_None;
 140 }
 141
 142 SCErr meth_b_read(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 143 SCErr meth_b_read(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
 144 {
 145         CallSequencedCommand(BufReadCmd, inWorld, inSize, inData, inReply);
 146
 147         return kSCErr_None;
 148 }
 149
 150 SCErr meth_b_allocReadChannel(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 151 SCErr meth_b_allocReadChannel(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
 152 {
 153         CallSequencedCommand(BufAllocReadChannelCmd, inWorld, inSize, inData, inReply);
 154
 155         return kSCErr_None;
 156 }
 157
 158 SCErr meth_b_readChannel(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 159 SCErr meth_b_readChannel(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
 160 {
 161         CallSequencedCommand(BufReadChannelCmd, inWorld, inSize, inData, inReply);
 162
 163         return kSCErr_None;
 164 }
 165
 166 SCErr meth_b_write(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 167 SCErr meth_b_write(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
 168 {
 169         CallSequencedCommand(BufWriteCmd, inWorld, inSize, inData, inReply);
 170
 171         return kSCErr_None;
 172 }
 173
 174 SCErr meth_b_zero(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 175 SCErr meth_b_zero(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
 176 {
 177         CallSequencedCommand(BufZeroCmd, inWorld, inSize, inData, inReply);
 178         return kSCErr_None;
 179 }
 180
 181
 182 SCErr meth_u_cmd(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 183 SCErr meth_u_cmd(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
 184 {
 185         return Unit_DoCmd(inWorld, inSize, inData);
 186 };
 187
 188 SCErr meth_cmd(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 189 SCErr meth_cmd(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
 190 {
 191         return PlugIn_DoCmd(inWorld, inSize, inData, inReply);
 192 };
 193
 194
 195 /*
 196 SCErr meth_n_cmd(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 197 SCErr meth_n_cmd(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
 198 {
 199         sc_msg_iter msg(inSize, inData);
 200         Node *node = Msg_GetNode(inWorld, msg);
 201         if (!node) return kSCErr_NodeNotFound;
 202
 203         char *args = msg.rdpos;
 204         int arglen = msg.remain();
 205
 206 //!!    (node->mDef->fNodeCmd)(node, arglen, args);
 207
 208         return kSCErr_None;
 209 }
 210 */
 211
 212 SCErr meth_n_trace(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 213 SCErr meth_n_trace(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
 214 {
 215         sc_msg_iter msg(inSize, inData);
 216         while (msg.remain()) {
 217                 Node *node = Msg_GetNode(inWorld, msg);
 218                 if (!node) return kSCErr_NodeNotFound;
 219
 220                 Node_Trace(node);
 221         }
 222
 223         return kSCErr_None;
 224 }
 225
 226 SCErr meth_g_dumpTree(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 227 SCErr meth_g_dumpTree(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
 228 {
 229         sc_msg_iter msg(inSize, inData);
 230         while (msg.remain()) {
 231                 Group *group = Msg_GetGroup(inWorld, msg);
 232                 if (!group) return kSCErr_GroupNotFound;
 233                 int32 flag = msg.geti();
 234                 if(flag) {
 235                         Group_DumpTreeAndControls(group);
 236                 } else {
 237                         Group_DumpTree(group);
 238                 }
 239         }
 240
 241         return kSCErr_None;
 242 }
 243
 244 //SCErr meth_g_queryTree(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 245 //SCErr meth_g_queryTree(World *inWorld, int inSize, char *inData, ReplyAddress* inReply)
 246 //{
 247 //      sc_msg_iter msg(inSize, inData);
 248 //      while (msg.remain()) {
 249 //              Group *group = Msg_GetGroup(inWorld, msg);
 250 //              if (!group) return kSCErr_GroupNotFound;
 251 //
 252 //              // first count the total number of nodes to know how many tags the packet should have
 253 //              int numNodes = 1; // include this one
 254 //
 255 //              Group_CountNodes(group, &numNodes);
 256 //
 257 //              big_scpacket packet;
 258 //              packet.adds("/g_queryTree.reply");
 259 //              packet.maketags(numNodes * 3 + 1);
 260 //              packet.addtag(',');
 261 //
 262 //              Group_QueryTree(group, &packet);
 263 //
 264 //              if (packet.size()) {
 265 //                      CallSequencedCommand(SendReplyCmd, inWorld, packet.size(), packet.data(), inReply);
 266 //              }
 267 //      }
 268 //      return kSCErr_None;
 269 //}
 270
 271 SCErr meth_g_queryTree(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 272 SCErr meth_g_queryTree(World *inWorld, int inSize, char *inData, ReplyAddress* inReply)
 273 {
 274         sc_msg_iter msg(inSize, inData);
 275         while (msg.remain()) {
 276                 Group *group = Msg_GetGroup(inWorld, msg);
 277                 if (!group) return kSCErr_GroupNotFound;
 278                 big_scpacket packet;
 279                 packet.adds("/g_queryTree.reply");
 280                 int32 flag = msg.geti();
 281                 if(flag) {
 282                         // first count the total number of nodes to know how many tags the packet should have
 283                         int numNodes = 1; // include this one
 284                         int numControlsAndDefs = 0;
 285                         Group_CountNodeAndControlTags(group, &numNodes, &numControlsAndDefs);
 286                         // nodeID and numChildren + numControlsAndDefs + controlFlag
 287                         packet.maketags(numNodes * 2 + numControlsAndDefs + 2);
 288                         packet.addtag(',');
 289                         packet.addtag('i');
 290                         packet.addi(1); // include controls flag
 291                         Group_QueryTreeAndControls(group, &packet);
 292                 } else {
 293                         // first count the total number of nodes to know how many tags the packet should have
 294                         int numNodeTags = 2; // include this one
 295                         Group_CountNodeTags(group, &numNodeTags);
 296                         packet.maketags(numNodeTags + 2); // nodeID and numChildren
 297                         packet.addtag(',');
 298                         packet.addtag('i');
 299                         packet.addi(0); // include controls flag
 300                         Group_QueryTree(group, &packet);
 301                 }
 302
 303                 if (packet.size()) {
 304                         CallSequencedCommand(SendReplyCmd, inWorld, packet.size(), packet.data(), inReply);
 305                 }
 306         }
 307         return kSCErr_None;
 308 }
 309
 310
 311
 312 SCErr meth_n_run(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 313 SCErr meth_n_run(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
 314 {
 315         sc_msg_iter msg(inSize, inData);
 316
 317         while (msg.remain()) {
 318                 Node *node = Msg_GetNode(inWorld, msg);
 319                 if (!node) return kSCErr_NodeNotFound;
 320
 321                 int32 run = msg.geti();
 322
 323                 Node_SetRun(node, run);
 324         }
 325
 326         return kSCErr_None;
 327 }
 328
 329 SCErr meth_n_map(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 330 SCErr meth_n_map(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
 331 {
 332         sc_msg_iter msg(inSize, inData);
 333         Node *node = Msg_GetNode(inWorld, msg);
 334         if (!node) return kSCErr_NodeNotFound;
 335
 336         while (msg.remain() >= 8) {
 337                 if (msg.nextTag('i') == 's') {
 338                         int32* name = msg.gets4();
 339                         int bus = msg.geti();
 340                         Node_MapControl(node, Hash(name), name, 0, bus);
 341                 } else {
 342                         int32 index = msg.geti();
 343                         int32 bus = msg.geti();
 344                         Node_MapControl(node, index, bus);
 345                 }
 346         }
 347         return kSCErr_None;
 348 }
 349
 350 SCErr meth_n_mapn(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 351 SCErr meth_n_mapn(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
 352 {
 353         sc_msg_iter msg(inSize, inData);
 354         Node *node = Msg_GetNode(inWorld, msg);
 355         if (!node) return kSCErr_NodeNotFound;
 356
 357         while (msg.remain() >= 12) {
 358                 if (msg.nextTag('i') == 's') {
 359                         int32* name = msg.gets4();
 360                         int32 hash = Hash(name);
 361                         int bus = msg.geti();
 362                         int n = msg.geti();
 363                         for (int i=0; i<n; ++i) {
 364                                 Node_MapControl(node, hash, name, i, bus == -1 ? -1 : bus+i);
 365                         }
 366                 } else {
 367                         int32 index = msg.geti();
 368                         int32 bus = msg.geti();
 369                         int n = msg.geti();
 370                         for (int i=0; i<n; ++i) {
 371                                 Node_MapControl(node, index+i, bus == -1 ? -1 : bus+i);
 372                         }
 373                 }
 374         }
 375         return kSCErr_None;
 376 }
 377
 378 SCErr meth_n_mapa(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 379 SCErr meth_n_mapa(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
 380 {
 381     sc_msg_iter msg(inSize, inData);
 382     Node *node = Msg_GetNode(inWorld, msg);
 383     if (!node) return kSCErr_NodeNotFound;
 384
 385     while (msg.remain() >= 8) {
 386         if (msg.nextTag('i') == 's') {
 387             int32* name = msg.gets4();
 388             int bus = msg.geti();
 389             Node_MapAudioControl(node, Hash(name), name, 0, bus);
 390         } else {
 391             int32 index = msg.geti();
 392             int32 bus = msg.geti();
 393             Node_MapAudioControl(node, index, bus);
 394         }
 395     }
 396     return kSCErr_None;
 397 }
 398
 399 SCErr meth_n_mapan(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 400 SCErr meth_n_mapan(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
 401 {
 402     sc_msg_iter msg(inSize, inData);
 403     Node *node = Msg_GetNode(inWorld, msg);
 404     if (!node) return kSCErr_NodeNotFound;
 405
 406     while (msg.remain() >= 12) {
 407         if (msg.nextTag('i') == 's') {
 408             int32* name = msg.gets4();
 409             int32 hash = Hash(name);
 410             int bus = msg.geti();
 411             int n = msg.geti();
 412             for (int i=0; i<n; ++i) {
 413                 Node_MapAudioControl(node, hash, name, i, bus == -1 ? -1 : bus+i);
 414             }
 415         } else {
 416             int32 index = msg.geti();
 417             int32 bus = msg.geti();
 418             int n = msg.geti();
 419             for (int i=0; i<n; ++i) {
 420                 Node_MapAudioControl(node, index+i, bus == -1 ? -1 : bus+i);
 421             }
 422         }
 423     }
 424     return kSCErr_None;
 425 }
 426
 427 SCErr meth_n_set(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 428 SCErr meth_n_set(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
 429 {
 430     sc_msg_iter msg(inSize, inData);
 431     Node *node = Msg_GetNode(inWorld, msg);
 432     if (!node) return kSCErr_NodeNotFound;
 433     while( msg.remain()>=8) {
 434             int i = 0;
 435             int loop = 0;
 436             if (msg.nextTag('i') == 's') {
 437                 int32* name = msg.gets4();
 438                 int32 hash = Hash(name);
 439                 do {
 440                         switch (msg.nextTag('f') ) {
 441                         case  'f' :
 442                         case  'i' :
 443                         {
 444                                 float32 value = msg.getf();
 445                                 Node_SetControl(node, hash, name, i, value);
 446                                 ++i;
 447                                 break;
 448                         }
 449                         case 's' :
 450                         {
 451                                 const char* string = msg.gets();
 452                                 if ( *string == 'c') {
 453                                         int bus = sc_atoi(string+1);
 454                                         Node_MapControl(node, hash, name, i, bus);
 455                                         ++i;
 456                                 }
 457                             if ( *string == 'a') {
 458                                 int bus = sc_atoi(string+1);
 459                                 Node_MapAudioControl(node, hash, name, i, bus);
 460                                 ++i;
 461                             }
 462                             break;
 463                         }
 464                         case ']':
 465                             msg.count++;
 466                             loop--;
 467                             break;
 468                         case '[':
 469                             msg.count++;
 470                             loop++;
 471                             break;
 472                     }
 473                 }
 474                 while (loop);
 475             } else {
 476                 int32 index = msg.geti();
 477                 do {
 478                     switch (msg.nextTag('f') ) {
 479                         case  'f' :
 480                         case  'i' :
 481                         {
 482                                 float32 value = msg.getf();
 483                                 Node_SetControl(node, index + i, value);
 484                                 ++i;
 485                                 break;
 486                         }
 487                         case 's' :
 488                         {
 489                                 const char* string = msg.gets();
 490                                 if ( *string == 'c') {
 491                                     int bus = sc_atoi(string+1);
 492                                     Node_MapControl(node, index + i, bus);
 493                                     ++i;
 494                                 }
 495                                 if ( *string == 'a') {
 496                                     int bus = sc_atoi(string+1);
 497                                     Node_MapAudioControl(node, index + i, bus);
 498                                     ++i;
 499                                 }
 500                             break;
 501                         }
 502                         case ']':
 503                             msg.count++;
 504                             loop--;
 505                             break;
 506                         case '[':
 507                             msg.count++;
 508                             loop++;
 509                             break;
 510                     }
 511                 }
 512                 while (loop);
 513             }
 514         }
 515
 516         //{
 517 //      int i = 0;
 518 //      int loop = 0;
 519 //      if (msg.nextTag('i') == 's') {
 520 //          int32* name = msg.gets4();
 521 //          int32 hash = Hash(name);
 522 //          if (msg.nextTag('f') == '[' ) {
 523 //              msg.count++;
 524 //              loop = 1;
 525 //          }
 526 //          do {
 527 //              if (msg.nextTag('f') == 's' ) {
 528 //                  const char* string = msg.gets();
 529 //                  if ( *string == 'c') {
 530 //                      int bus = sc_atoi(string+1);
 531 //                      Node_MapControl(node, hash, name, i, bus);
 532 //                  }
 533 //              } else {
 534 //                  if (msg.nextTag('f') == ']' ) {
 535 //                      msg.count++;
 536 //                      loop = 0;
 537 //                  } else {
 538 //                      float32 value = msg.getf();
 539 //                      Node_SetControl(node, hash, name, i, value);
 540 //                  }
 541 //              }
 542 //              ++i;
 543 //          }
 544 //          while (loop);
 545 //      } else {
 546 //          int32 index = msg.geti();
 547 //          if (msg.nextTag('f') == '[' ) {
 548 //              msg.count++;
 549 //              loop = 1;
 550 //          }
 551 //          do {
 552 //              if (msg.nextTag('f') == 's') {
 553 //                  const char* string = msg.gets();
 554 //                  if (*string == 'c') {
 555 //                      int bus = sc_atoi(string+1);
 556 //                      Node_MapControl(node, index + i, bus);
 557 //                  }
 558 //              } else {
 559 //                  if (msg.nextTag('f') == ']' ) {
 560 //                      msg.count++;
 561 //                      loop = 0;
 562 //                  } else {
 563 //                      float32 value = msg.getf();
 564 //                      Node_SetControl(node, index + i, value);
 565 //                  }
 566 //              }
 567 //              ++i;
 568 //          }
 569 //          while (loop);
 570 //      }
 571 //    }
 572     return kSCErr_None;
 573 }
 574
 575 SCErr meth_n_setn(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 576 SCErr meth_n_setn(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
 577 {
 578         sc_msg_iter msg(inSize, inData);
 579         Node *node = Msg_GetNode(inWorld, msg);
 580         if (!node) return kSCErr_NodeNotFound;
 581
 582         while (msg.remain()) {
 583                 if (msg.nextTag('i') == 's') {
 584                         int32* name = msg.gets4();
 585                         int32 hash = Hash(name);
 586                         int32 n = msg.geti();
 587                         for (int i=0; msg.remain() && i<n; ++i) {
 588                                 if (msg.nextTag('f') == 's') {
 589                                         const char* string = msg.gets();
 590                                         if (*string == 'c') {
 591                                                 int bus = sc_atoi(string+1);
 592                                                 Node_MapControl(node, hash, name, i, bus);
 593                                         }
 594                                         if (*string == 'a') {
 595                                             int bus = sc_atoi(string+1);
 596                                             Node_MapAudioControl(node, hash, name, i, bus);
 597                                         }
 598
 599                                 } else {
 600                                         float32 value = msg.getf();
 601                                         Node_SetControl(node, hash, name, i, value);
 602                                 }
 603                         }
 604                 } else {
 605                         int32 index = msg.geti();
 606                         int32 n = msg.geti();
 607                         for (int i=0; msg.remain() && i<n; ++i) {
 608                                 if (msg.nextTag('f') == 's') {
 609                                         const char* string = msg.gets();
 610                                         if (*string == 'c') {
 611                                                 int bus = sc_atoi(string+1);
 612                                                 Node_MapControl(node, index+i, bus);
 613                                         }
 614                                         if (*string == 'a') {
 615                                             int bus = sc_atoi(string+1);
 616                                             Node_MapAudioControl(node, index+i, bus);
 617                                         }
 618                                 } else {
 619                                         float32 value = msg.getf();
 620                                         Node_SetControl(node, index+i, value);
 621                                 }
 622                         }
 623                 }
 624         }
 625         return kSCErr_None;
 626 }
 627
 628 SCErr meth_n_fill(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 629 SCErr meth_n_fill(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
 630 {
 631         sc_msg_iter msg(inSize, inData);
 632         Node *node = Msg_GetNode(inWorld, msg);
 633         if (!node) return kSCErr_NodeNotFound;
 634
 635         while (msg.remain() >= 12)
 636         {
 637                 if (msg.nextTag('i') == 's') {
 638                         int32* name = msg.gets4();
 639                         int32 hash = Hash(name);
 640                         int32 n = msg.geti();
 641                         float32 value = msg.getf();
 642
 643                         for (int i=0; i<n; ++i) {
 644                                 Node_SetControl(node, hash, name, i, value);
 645                         }
 646
 647                         if (msg.nextTag('f') == 's') {
 648                                 const char* string = msg.gets();
 649                                 if (*string == 'c') {
 650                                         int bus = sc_atoi(string+1);
 651                                         for (int i=0; i<n; ++i) {
 652                                                 Node_MapControl(node, hash, name, i, bus+i);
 653                                         }
 654                                 }
 655                         } else {
 656                                 float32 value = msg.getf();
 657                                 for (int i=0; i<n; ++i) {
 658                                         Node_SetControl(node, hash, name, i, value);
 659                                 }
 660                         }
 661                 } else {
 662                         int32 index = msg.geti();
 663                         int32 n = msg.geti();
 664                         float32 value = msg.getf();
 665
 666                         for (int i=0; i<n; ++i) {
 667                                 Node_SetControl(node, index+i, value);
 668                         }
 669                         if (msg.nextTag('f') == 's') {
 670                                 const char* string = msg.gets();
 671                                 if (*string == 'c') {
 672                                         int bus = sc_atoi(string+1);
 673                                         for (int i=0; i<n; ++i) {
 674                                                 Node_MapControl(node, index+i, bus+i);
 675                                         }
 676                                 }
 677                         } else {
 678                                 float32 value = msg.getf();
 679                                 for (int i=0; i<n; ++i) {
 680                                         Node_SetControl(node, index+i, value);
 681                                 }
 682                         }
 683                 }
 684         }
 685
 686         return kSCErr_None;
 687 }
 688
 689
 690 SCErr meth_n_query(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 691 SCErr meth_n_query(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
 692 {
 693         sc_msg_iter msg(inSize, inData);
 694
 695         while (msg.remain()) {
 696                 Node *node = Msg_GetNode(inWorld, msg);
 697                 if (!node) return kSCErr_NodeNotFound;
 698
 699                 Node_StateMsg(node, kNode_Info);
 700         }
 701         return kSCErr_None;
 702 }
 703
 704 SCErr meth_b_query(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 705 SCErr meth_b_query(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
 706 {
 707         sc_msg_iter msg(inSize, inData);
 708
 709         small_scpacket packet;
 710
 711         int numbufs = msg.remain() >> 2;
 712         packet.adds("/b_info");
 713         packet.maketags(numbufs * 4 + 1);
 714         packet.addtag(',');
 715
 716         while (msg.remain()) {
 717                 int bufindex = msg.geti();
 718                 SndBuf* buf = World_GetBuf(inWorld, bufindex);
 719
 720                 packet.addtag('i');
 721                 packet.addtag('i');
 722                 packet.addtag('i');
 723                 packet.addtag('f');
 724                 packet.addi(bufindex);
 725                 packet.addi(buf->frames);
 726                 packet.addi(buf->channels);
 727                 packet.addf(buf->samplerate);
 728         }
 729
 730         if (packet.size()) {
 731                 CallSequencedCommand(SendReplyCmd, inWorld, packet.size(), packet.data(), inReply);
 732         }
 733
 734         return kSCErr_None;
 735 }
 736
 737
 738
 739 SCErr meth_d_load(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 740 SCErr meth_d_load(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
 741 {
 742         CallSequencedCommand(LoadSynthDefCmd, inWorld, inSize, inData, inReply);
 743
 744         return kSCErr_None;
 745
 746 }
 747
 748 SCErr meth_d_recv(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 749 SCErr meth_d_recv(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
 750 {
 751         CallSequencedCommand(RecvSynthDefCmd, inWorld, inSize, inData, inReply);
 752
 753         return kSCErr_None;
 754
 755 }
 756
 757 SCErr meth_d_loadDir(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 758 SCErr meth_d_loadDir(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
 759 {
 760         CallSequencedCommand(LoadSynthDefDirCmd, inWorld, inSize, inData, inReply);
 761
 762         return kSCErr_None;
 763 }
 764
 765 SCErr meth_d_freeAll(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 766 SCErr meth_d_freeAll(World *inWorld, int /*inSize*/, char * /*inData*/, ReplyAddress* /*inReply*/)
 767 {
 768         World_FreeAllGraphDefs(inWorld);
 769         return kSCErr_None;
 770 }
 771
 772 SCErr meth_d_free(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 773 SCErr meth_d_free(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
 774 {
 775         sc_msg_iter msg(inSize, inData);
 776         while (msg.remain()) {
 777                 int32* defname = msg.gets4();
 778                 if (!defname) return kSCErr_SynthDefNotFound;
 779                 GraphDef_Remove(inWorld, defname);
 780         }
 781         return kSCErr_None;
 782 }
 783
 784
 785 SCErr meth_s_new(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 786 SCErr meth_s_new(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
 787 {
 788         SCErr err;
 789         sc_msg_iter msg(inSize, inData);
 790         int32 *defname = msg.gets4();
 791         if (!defname) return kSCErr_WrongArgType;
 792
 793         int32 nodeID = msg.geti();
 794         int32 addAction = msg.geti();
 795
 796         GraphDef *def = World_GetGraphDef(inWorld, defname);
 797         if (!def) {
 798                 scprintf("*** ERROR: SynthDef %s not found\n", (char*)defname);
 799                 return kSCErr_SynthDefNotFound;
 800         }
 801
 802         Graph *graph = 0;
 803         switch (addAction) {
 804                 case 0 : {
 805                         Group *group = Msg_GetGroup(inWorld, msg);
 806                         if (!group) return kSCErr_GroupNotFound;
 807                         err = Graph_New(inWorld, def, nodeID, &msg, &graph,true);//true for normal args
 808                         if (err) return err;
 809                         if (!graph) return kSCErr_Failed;
 810                         Group_AddHead(group, &graph->mNode);
 811                 } break;
 812                 case 1 : {
 813                         Group *group = Msg_GetGroup(inWorld, msg);
 814                         if (!group) return kSCErr_GroupNotFound;
 815                         err = Graph_New(inWorld, def, nodeID, &msg, &graph,true);
 816                         if (err) return err;
 817                         Group_AddTail(group, &graph->mNode);
 818                 } break;
 819                 case 2 : {
 820                         Node *beforeThisNode = Msg_GetNode(inWorld, msg);
 821                         if (!beforeThisNode) return kSCErr_NodeNotFound;
 822                         err = Graph_New(inWorld, def, nodeID, &msg, &graph,true);
 823                         if (err) return err;
 824                         Node_AddBefore(&graph->mNode, beforeThisNode);
 825                 } break;
 826                 case 3 : {
 827                         Node *afterThisNode = Msg_GetNode(inWorld, msg);
 828                         if (!afterThisNode) return kSCErr_NodeNotFound;
 829                         err = Graph_New(inWorld, def, nodeID, &msg, &graph,true);
 830                         if (err) return err;
 831                         Node_AddAfter(&graph->mNode, afterThisNode);
 832                 } break;
 833                 case 4 : {
 834                         Node *replaceThisNode = Msg_GetNode(inWorld, msg);
 835                         if (!replaceThisNode) return kSCErr_NodeNotFound;
 836                         err = Graph_New(inWorld, def, nodeID, &msg, &graph,true);
 837                         if (err) return err;
 838                         Node_Replace(&graph->mNode, replaceThisNode);
 839                 } break;
 840                 default: return kSCErr_Failed;
 841         }
 842         Node_StateMsg(&graph->mNode, kNode_Go);
 843         return kSCErr_None;
 844 }
 845
 846 SCErr meth_s_newargs(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 847 SCErr meth_s_newargs(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
 848 {
 849         SCErr err;
 850         sc_msg_iter msg(inSize, inData);
 851         int32 *defname = msg.gets4();
 852         if (!defname) return kSCErr_WrongArgType;
 853
 854         int32 nodeID = msg.geti();
 855         int32 addAction = msg.geti();
 856
 857         GraphDef *def = World_GetGraphDef(inWorld, defname);
 858         if (!def) {
 859                 scprintf("*** ERROR: SynthDef %s not found\n", (char*)defname);
 860                 return kSCErr_SynthDefNotFound;
 861         }
 862
 863         Graph *graph = 0;
 864         switch (addAction) {
 865                 case 0 : {
 866                         Group *group = Msg_GetGroup(inWorld, msg);
 867                         if (!group) return kSCErr_GroupNotFound;
 868                         err = Graph_New(inWorld, def, nodeID, &msg, &graph,false);//false for setn type args
 869                         if (err) return err;
 870                         if (!graph) return kSCErr_Failed;
 871                         Group_AddHead(group, &graph->mNode);
 872                 } break;
 873                 case 1 : {
 874                         Group *group = Msg_GetGroup(inWorld, msg);
 875                         if (!group) return kSCErr_GroupNotFound;
 876                         err = Graph_New(inWorld, def, nodeID, &msg, &graph,false);
 877                         if (err) return err;
 878                         Group_AddTail(group, &graph->mNode);
 879                 } break;
 880                 case 2 : {
 881                         Node *beforeThisNode = Msg_GetNode(inWorld, msg);
 882                         if (!beforeThisNode) return kSCErr_NodeNotFound;
 883                         err = Graph_New(inWorld, def, nodeID, &msg, &graph,false);
 884                         if (err) return err;
 885                         Node_AddBefore(&graph->mNode, beforeThisNode);
 886                 } break;
 887                 case 3 : {
 888                         Node *afterThisNode = Msg_GetNode(inWorld, msg);
 889                         if (!afterThisNode) return kSCErr_NodeNotFound;
 890                         err = Graph_New(inWorld, def, nodeID, &msg, &graph,false);
 891                         if (err) return err;
 892                         Node_AddAfter(&graph->mNode, afterThisNode);
 893                 } break;
 894                 case 4 : {
 895                         Node *replaceThisNode = Msg_GetNode(inWorld, msg);
 896                         if (!replaceThisNode) return kSCErr_NodeNotFound;
 897                         err = Graph_New(inWorld, def, nodeID, &msg, &graph,false);
 898                         if (err) return err;
 899                         Node_Replace(&graph->mNode, replaceThisNode);
 900                 } break;
 901                 default: return kSCErr_Failed;
 902         }
 903         Node_StateMsg(&graph->mNode, kNode_Go);
 904         return kSCErr_None;
 905 }
 906
 907 SCErr meth_g_new(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 908 SCErr meth_g_new(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
 909 {
 910         SCErr err;
 911
 912         sc_msg_iter msg(inSize, inData);
 913         while (msg.remain()) {
 914                 int32 newGroupID = msg.geti();
 915                 int32 addAction = msg.geti();
 916
 917                 Group *newGroup = 0;
 918                 switch (addAction) {
 919                         case 0 : {
 920                                 Group *group = Msg_GetGroup(inWorld, msg);
 921                                 if (!group) return kSCErr_GroupNotFound;
 922                                 err = Group_New(inWorld, newGroupID, &newGroup);
 923                                 if (err) {
 924                                         if (err == kSCErr_DuplicateNodeID) {
 925                                                 newGroup = World_GetGroup(inWorld, newGroupID);
 926                                                 if (!newGroup || !newGroup->mNode.mParent || newGroup->mNode.mParent != group)
 927                                                         return err;
 928                                         } else return err;
 929                                 } else {
 930                                         Group_AddHead(group, &newGroup->mNode);
 931                                 }
 932                         } break;
 933                         case 1 : {
 934                                 Group *group = Msg_GetGroup(inWorld, msg);
 935                                 if (!group) return kSCErr_GroupNotFound;
 936                                 err = Group_New(inWorld, newGroupID, &newGroup);
 937                                 if (err) {
 938                                         if (err == kSCErr_DuplicateNodeID) {
 939                                                 newGroup = World_GetGroup(inWorld, newGroupID);
 940                                                 if (!newGroup || !newGroup->mNode.mParent || newGroup->mNode.mParent != group)
 941                                                         return err;
 942                                         } else return err;
 943                                 } else {
 944                                         Group_AddTail(group, &newGroup->mNode);
 945                                 }
 946                         } break;
 947                         case 2 : {
 948                                 Node *beforeThisNode = Msg_GetNode(inWorld, msg);
 949                                 if (!beforeThisNode) return kSCErr_TargetNodeNotFound;
 950                                 err = Group_New(inWorld, newGroupID, &newGroup);
 951                                 if (err) {
 952                                         if (err == kSCErr_DuplicateNodeID) {
 953                                                 newGroup = World_GetGroup(inWorld, newGroupID);
 954                                                 if (!newGroup || !newGroup->mNode.mParent || newGroup->mNode.mParent->mNode.mID != beforeThisNode->mParent->mNode.mID)
 955                                                         return err;
 956                                         } else return err;
 957                                 } else {
 958                                         Node_AddBefore(&newGroup->mNode, beforeThisNode);
 959                                 }
 960                         } break;
 961                         case 3 : {
 962                                 Node *afterThisNode = Msg_GetNode(inWorld, msg);
 963                                 if (!afterThisNode) return kSCErr_TargetNodeNotFound;
 964                                 err = Group_New(inWorld, newGroupID, &newGroup);
 965                                 if (err) {
 966                                         if (err == kSCErr_DuplicateNodeID) {
 967                                                 newGroup = World_GetGroup(inWorld, newGroupID);
 968                                                 if (!newGroup || !newGroup->mNode.mParent || newGroup->mNode.mParent->mNode.mID != afterThisNode->mParent->mNode.mID)
 969                                                         return err;
 970                                         } else return err;
 971                                 } else {
 972                                         Node_AddAfter(&newGroup->mNode, afterThisNode);
 973                                 }
 974                         } break;
 975                         case 4 : {
 976                                 Node *replaceThisNode = Msg_GetNode(inWorld, msg);
 977                                 if (!replaceThisNode) return kSCErr_TargetNodeNotFound;
 978                                 err = Group_New(inWorld, newGroupID, &newGroup);
 979                                 if (err) return err;
 980                                 Node_Replace(&newGroup->mNode, replaceThisNode);
 981                         } break;
 982                         default: return kSCErr_Failed;
 983                 }
 984
 985                 Node_StateMsg(&newGroup->mNode, kNode_Go);
 986         }
 987
 988         return kSCErr_None;
 989 }
 990
 991 SCErr meth_p_new(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 992 SCErr meth_p_new(World *inWorld, int inSize, char *inData, ReplyAddress* inReply)
 993 {
 994         /* we emulate the concept of parallel groups by using sequential groups */
 995         return meth_g_new(inWorld, inSize, inData, inReply);
 996 }
 997
 998 SCErr meth_n_free(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
 999 SCErr meth_n_free(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1000 {
1001         sc_msg_iter msg(inSize, inData);
1002
1003         while (msg.remain()) {
1004                 Node *node = Msg_GetNode(inWorld, msg);
1005                 if (!node) return kSCErr_NodeNotFound;
1006
1007                 Node_Delete(node);
1008         }
1009
1010         return kSCErr_None;
1011 }
1012
1013 SCErr meth_n_before(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1014 SCErr meth_n_before(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1015 {
1016         sc_msg_iter msg(inSize, inData);
1017
1018         Node *prevNode = 0;
1019         Node *prevTarget = 0;
1020         while (msg.remain()) {
1021                 Node *node = Msg_GetNode(inWorld, msg);
1022                 Node *target = Msg_GetNode(inWorld, msg);
1023
1024                 if (!node || !target) continue; // tolerate failure
1025
1026                 if (prevNode && prevNode != node)
1027                 {
1028                         // move the last pair that succeeded
1029                         Node_Remove(prevNode);
1030                         Node_AddBefore(prevNode, prevTarget);
1031                         Node_StateMsg(prevNode, kNode_Move);
1032                 }
1033
1034                 prevNode = node;
1035                 prevTarget = target;
1036         }
1037         if (prevNode && prevNode != prevTarget)
1038         {
1039                 // move the last pair that succeeded
1040                 Node_Remove(prevNode);
1041                 Node_AddBefore(prevNode, prevTarget);
1042                 Node_StateMsg(prevNode, kNode_Move);
1043         }
1044
1045         return kSCErr_None;
1046 }
1047
1048 SCErr meth_n_after(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1049 SCErr meth_n_after(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1050 {
1051         sc_msg_iter msg(inSize, inData);
1052
1053         Node *prevNode = 0;
1054         Node *prevTarget = 0;
1055         while (msg.remain()) {
1056                 Node *node = Msg_GetNode(inWorld, msg);
1057                 Node *target = Msg_GetNode(inWorld, msg);
1058
1059                 if (!node || !target) continue; // tolerate failure
1060
1061                 if (prevNode && prevNode != node)
1062                 {
1063                         // move the last pair that succeeded
1064                         Node_Remove(prevNode);
1065                         Node_AddAfter(prevNode, prevTarget);
1066                         Node_StateMsg(prevNode, kNode_Move);
1067                 }
1068
1069                 prevNode = node;
1070                 prevTarget = target;
1071         }
1072         if (prevNode)
1073         {
1074                 // move the last pair that succeeded
1075                 Node_Remove(prevNode);
1076                 Node_AddAfter(prevNode, prevTarget);
1077                 Node_StateMsg(prevNode, kNode_Move);
1078         }
1079
1080         return kSCErr_None;
1081 }
1082
1083 SCErr meth_n_order(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1084 SCErr meth_n_order(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1085 {
1086         SCErr err;
1087
1088         Node *prevNode = 0;
1089         Node *node = 0;
1090
1091         sc_msg_iter msg(inSize, inData);
1092         int32 addAction = msg.geti();
1093
1094         // place the first node in the list based on target and addAction
1095         switch (addAction) {
1096                 case 0 : {
1097                         Group *group = Msg_GetGroup(inWorld, msg);
1098                         if (!group) return kSCErr_GroupNotFound;
1099                         while(!node && msg.remain()) {
1100                                 node = Msg_GetNode(inWorld, msg);
1101                                 if(!node) scprintf("Warning Node not found\n");
1102                         }
1103                         if (!node) return kSCErr_NodeNotFound;
1104
1105                         Group *prevGroup = node->mParent;
1106
1107                         Node_Remove(node);
1108
1109                         Group_AddHead(group, node);
1110
1111                         if (group != prevGroup) {
1112                                 Node_StateMsg(node, kNode_Move);
1113                         }
1114
1115                         prevNode = node;
1116
1117                 } break;
1118                 case 1 : {
1119                         Group *group = Msg_GetGroup(inWorld, msg);
1120                         if (!group) return kSCErr_GroupNotFound;
1121                         while(!node && msg.remain()) {
1122                                 node = Msg_GetNode(inWorld, msg);
1123                                 if(!node) scprintf("Warning Node not found\n");
1124                         }
1125                         if (!node) return kSCErr_NodeNotFound;
1126
1127                         Group *prevGroup = node->mParent;
1128
1129                         Node_Remove(node);
1130
1131                         Group_AddTail(group, node);
1132
1133                         if (group != prevGroup) {
1134                                 Node_StateMsg(node, kNode_Move);
1135                         }
1136
1137                         prevNode = node;
1138
1139                 } break;
1140                 case 2 : {
1141                         Node *beforeNode = Msg_GetNode(inWorld, msg);
1142                         if (!beforeNode) return kSCErr_TargetNodeNotFound;
1143                         while(!node && msg.remain()) {
1144                                 node = Msg_GetNode(inWorld, msg);
1145                                 if(!node) scprintf("Warning Node not found\n");
1146                         }
1147                         if (!node) return kSCErr_NodeNotFound;
1148
1149
1150                         Node_Remove(node);
1151                         Node_AddBefore(node, beforeNode);
1152                         Node_StateMsg(node, kNode_Move);
1153
1154                         prevNode = node;
1155                 } break;
1156                 case 3 : {
1157                         Node *afterNode = Msg_GetNode(inWorld, msg);
1158                         if (!afterNode) return kSCErr_TargetNodeNotFound;
1159                         while(!node && msg.remain()) {
1160                                 node = Msg_GetNode(inWorld, msg);
1161                                 if(!node) scprintf("Warning Node not found\n");
1162                         }
1163                         if (!node) return kSCErr_NodeNotFound;
1164
1165
1166                         Node_Remove(node);
1167                         Node_AddAfter(node, afterNode);
1168                         Node_StateMsg(node, kNode_Move);
1169
1170                         prevNode = node;
1171                 } break;
1172                 default: return kSCErr_Failed;
1173         }
1174
1175         // now iterate through in order
1176         while (msg.remain()) {
1177                 node = Msg_GetNode(inWorld, msg);
1178                 if(!node) {
1179                         scprintf("Warning Node not found\n");
1180                         continue;
1181                 }
1182                 Node_Remove(node);
1183                 Node_AddAfter(node, prevNode);
1184                 Node_StateMsg(node, kNode_Move);
1185
1186                 prevNode = node;
1187         }
1188
1189         return kSCErr_None;
1190 }
1191
1192 SCErr meth_g_head(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1193 SCErr meth_g_head(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1194 {
1195         sc_msg_iter msg(inSize, inData);
1196         while (msg.remain()) {
1197                 Group *group = Msg_GetGroup(inWorld, msg);
1198                 if (!group) return kSCErr_GroupNotFound;
1199
1200                 Node *node = Msg_GetNode(inWorld, msg);
1201                 if (!node) return kSCErr_NodeNotFound;
1202
1203                 Group *prevGroup = node->mParent;
1204
1205                 Node_Remove(node);
1206
1207                 Group_AddHead(group, node);
1208
1209                 if (group != prevGroup) {
1210                         Node_StateMsg(node, kNode_Move);
1211                 }
1212         }
1213         return kSCErr_None;
1214 }
1215
1216 SCErr meth_g_tail(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1217 SCErr meth_g_tail(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1218 {
1219         sc_msg_iter msg(inSize, inData);
1220         while (msg.remain()) {
1221                 Group *group = Msg_GetGroup(inWorld, msg);
1222                 if (!group) return kSCErr_GroupNotFound;
1223
1224                 Node *node = Msg_GetNode(inWorld, msg);
1225                 if (!node) return kSCErr_NodeNotFound;
1226
1227                 //Group *prevGroup = node->mParent;
1228
1229                 Node_Remove(node);
1230                 Group_AddTail(group, node);
1231
1232                 //if (group != prevGroup) {
1233                         Node_StateMsg(node, kNode_Move);
1234                 //}
1235         }
1236         return kSCErr_None;
1237 }
1238
1239 SCErr meth_g_insert(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1240 SCErr meth_g_insert(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1241 {
1242         sc_msg_iter msg(inSize, inData);
1243         while (msg.remain()) {
1244                 Group *group = Msg_GetGroup(inWorld, msg);
1245                 if (!group) return kSCErr_GroupNotFound;
1246
1247                 Node *node = Msg_GetNode(inWorld, msg);
1248                 if (!node) return kSCErr_NodeNotFound;
1249
1250                 Group *prevGroup = node->mParent;
1251
1252                 int index = msg.geti();
1253
1254                 Node_Remove(node);
1255                 Group_Insert(group, node, index);
1256
1257                 if (group != prevGroup) {
1258                         Node_StateMsg(node, kNode_Move);
1259                 }
1260         }
1261         return kSCErr_None;
1262 }
1263
1264 SCErr meth_g_freeAll(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1265 SCErr meth_g_freeAll(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1266 {
1267         sc_msg_iter msg(inSize, inData);
1268         while (msg.remain()) {
1269                 Group *group = Msg_GetGroup(inWorld, msg);
1270                 if (!group) return kSCErr_GroupNotFound;
1271
1272                 Group_DeleteAll(group);
1273         }
1274         return kSCErr_None;
1275 }
1276
1277 SCErr meth_g_deepFree(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1278 SCErr meth_g_deepFree(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1279 {
1280         sc_msg_iter msg(inSize, inData);
1281         while (msg.remain()) {
1282                 Group *group = Msg_GetGroup(inWorld, msg);
1283                 if (!group) return kSCErr_GroupNotFound;
1284
1285                 Group_DeepFreeGraphs(group);
1286         }
1287         return kSCErr_None;
1288 }
1289
1290
1291
1292 SCErr meth_status(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1293 SCErr meth_status(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
1294 {
1295         CallSequencedCommand(AudioStatusCmd, inWorld, inSize, inData, inReply);
1296         return kSCErr_None;
1297 }
1298
1299 SCErr meth_quit(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1300 SCErr meth_quit(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
1301 {
1302         CallSequencedCommand(AudioQuitCmd, inWorld, inSize, inData, inReply);
1303         return kSCErr_None;
1304 }
1305
1306 SCErr meth_clearSched(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1307 SCErr meth_clearSched(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
1308 {
1309         if(inWorld->mRealTime){
1310                 inWorld->hw->mAudioDriver->ClearSched();
1311         }
1312         return kSCErr_None;
1313 }
1314
1315 SCErr meth_dumpOSC(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1316 SCErr meth_dumpOSC(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
1317 {
1318         sc_msg_iter msg(inSize, inData);
1319         inWorld->mDumpOSC = msg.geti();
1320         return kSCErr_None;
1321 }
1322
1323 SCErr meth_b_set(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1324 SCErr meth_b_set(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1325 {
1326         sc_msg_iter msg(inSize, inData);
1327         int bufindex = msg.geti();
1328         SndBuf* buf = World_GetBuf(inWorld, bufindex);
1329         if (!buf) return kSCErr_Failed;
1330
1331         float *data = buf->data;
1332         uint32 numSamples = buf->samples;
1333
1334         while (msg.remain() >= 8)
1335         {
1336                 uint32 sampleIndex = msg.geti();
1337                 float32 value = msg.getf();
1338                 if (sampleIndex < numSamples)
1339                 {
1340                         data[sampleIndex] = value;
1341                 } else return kSCErr_IndexOutOfRange;
1342
1343         }
1344         return kSCErr_None;
1345 }
1346
1347 SCErr meth_b_setn(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1348 SCErr meth_b_setn(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1349 {
1350         sc_msg_iter msg(inSize, inData);
1351         int bufindex = msg.geti();
1352         SndBuf* buf = World_GetBuf(inWorld, bufindex);
1353         if (!buf) return kSCErr_Failed;
1354
1355         float *data = buf->data;
1356         int numSamples = buf->samples;
1357
1358         while (msg.remain()) {
1359                 int32 start = msg.geti();
1360                 int32 n = msg.geti();
1361                 int32 end = start+n-1;
1362
1363                 if (end < 0 || start >= numSamples) continue;
1364
1365                 start = sc_clip(start, 0, numSamples-1);
1366                 end   = sc_clip(end,   0, numSamples-1);
1367
1368                 for (int i=start; msg.remain() && i<=end; ++i) {
1369                         float32 value = msg.getf();
1370                         data[i] = value;
1371                 }
1372         }
1373
1374         return kSCErr_None;
1375 }
1376
1377
1378 SCErr meth_b_fill(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1379 SCErr meth_b_fill(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1380 {
1381         sc_msg_iter msg(inSize, inData);
1382         int bufindex = msg.geti();
1383         SndBuf* buf = World_GetBuf(inWorld, bufindex);
1384         if (!buf) return kSCErr_Failed;
1385
1386         float *data = buf->data;
1387         int numSamples = buf->samples;
1388
1389         while (msg.remain() >= 12)
1390         {
1391                 int32 start = msg.geti();
1392                 int32 n = msg.geti();
1393                 float32 value = msg.getf();
1394                 int32 end = start+n-1;
1395
1396                 if (end < 0 || start >= numSamples) continue;
1397
1398                 start = sc_clip(start, 0, numSamples-1);
1399                 end   = sc_clip(end,   0, numSamples-1);
1400
1401                 for (int i=start; i<=end; ++i) data[i] = value;
1402         }
1403
1404         return kSCErr_None;
1405 }
1406
1407 SCErr meth_b_gen(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1408 SCErr meth_b_gen(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
1409 {
1410         CallSequencedCommand(BufGenCmd, inWorld, inSize, inData, inReply);
1411
1412         return kSCErr_None;
1413 }
1414
1415
1416 SCErr meth_c_set(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1417 SCErr meth_c_set(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1418 {
1419         sc_msg_iter msg(inSize, inData);
1420
1421         float *data = inWorld->mControlBus;
1422         int32 *touched = inWorld->mControlBusTouched;
1423         int32 bufCounter = inWorld->mBufCounter;
1424         uint32 maxIndex = inWorld->mNumControlBusChannels;
1425
1426         while (msg.remain() >= 8)
1427         {
1428                 uint32 index = msg.geti();
1429                 float32 value = msg.getf();
1430                 if (index < maxIndex)
1431                 {
1432                         data[index] = value;
1433                         touched[index] = bufCounter;
1434                 } else return kSCErr_IndexOutOfRange;
1435
1436         }
1437         return kSCErr_None;
1438 }
1439
1440 SCErr meth_c_setn(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1441 SCErr meth_c_setn(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1442 {
1443         sc_msg_iter msg(inSize, inData);
1444
1445         float *data = inWorld->mControlBus;
1446         int32 *touched = inWorld->mControlBusTouched;
1447         int32 bufCounter = inWorld->mBufCounter;
1448         int maxIndex = inWorld->mNumControlBusChannels;
1449
1450         while (msg.remain()) {
1451                 int32 start = msg.geti();
1452                 int32 n = msg.geti();
1453                 int32 end = start+n-1;
1454
1455                 if (start < 0 || end >= maxIndex || start > end)
1456                         return kSCErr_IndexOutOfRange;
1457
1458                 for (int i=start; msg.remain() && i<=end; ++i) {
1459                         float32 value = msg.getf();
1460                         data[i] = value;
1461                         touched[i] = bufCounter;
1462                 }
1463         }
1464
1465         return kSCErr_None;
1466 }
1467
1468
1469 SCErr meth_c_get(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1470 SCErr meth_c_get(World *inWorld, int inSize, char *inData, ReplyAddress* inReply)
1471 {
1472         sc_msg_iter msg(inSize, inData);
1473
1474         float *data = inWorld->mControlBus;
1475         uint32 maxIndex = inWorld->mNumControlBusChannels;
1476
1477         int numheads = msg.remain() >> 2;
1478
1479         big_scpacket packet;
1480         packet.adds("/c_set");
1481         packet.maketags(numheads * 2 + 1);
1482         packet.addtag(',');
1483
1484         while (msg.remain() >= 4)
1485         {
1486                 uint32 index = msg.geti();
1487                 if (index >= maxIndex)
1488                         return kSCErr_IndexOutOfRange;
1489                 packet.addtag('i');
1490                 packet.addtag('f');
1491                 packet.addi(index);
1492                 packet.addf(data[index]);
1493         }
1494
1495         if (packet.size()) {
1496                 CallSequencedCommand(SendReplyCmd, inWorld, packet.size(), packet.data(), inReply);
1497         }
1498
1499         return kSCErr_None;
1500 }
1501
1502 SCErr meth_c_getn(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1503 SCErr meth_c_getn(World *inWorld, int inSize, char *inData, ReplyAddress* inReply)
1504 {
1505         sc_msg_iter msg(inSize, inData);
1506
1507         float *data = inWorld->mControlBus;
1508         int maxIndex = inWorld->mNumControlBusChannels;
1509
1510         // figure out how many tags to allocate
1511         int numcontrols = 0;
1512         int numheads = msg.remain() >> 3;
1513
1514         while (msg.remain()) {
1515                 msg.geti(); // skip start
1516                 int32 n = msg.geti();
1517                 numcontrols += n;
1518         }
1519
1520         big_scpacket packet;
1521         packet.adds("/c_setn");
1522         packet.maketags(numheads * 2 + numcontrols + 1);
1523         packet.addtag(',');
1524
1525         // start over at beginning of message
1526         msg.init(inSize, inData);
1527
1528         while (msg.remain()) {
1529                 int32 start = msg.geti();
1530                 int32 n = msg.geti();
1531                 int32 end = start+n-1;
1532
1533                 if (start < 0 || end >= maxIndex || start > end)
1534                         return kSCErr_IndexOutOfRange;
1535
1536                 packet.addtag('i');
1537                 packet.addtag('i');
1538                 packet.addi(start);
1539                 packet.addi(n);
1540
1541                 for (int i=start; i<=end; ++i) {
1542                         packet.addtag('f');
1543                         packet.addf(data[i]);
1544                 }
1545         }
1546
1547         if (packet.size()) {
1548                 CallSequencedCommand(SendReplyCmd, inWorld, packet.size(), packet.data(), inReply);
1549         }
1550
1551         return kSCErr_None;
1552 }
1553
1554
1555 SCErr meth_c_fill(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1556 SCErr meth_c_fill(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1557 {
1558         sc_msg_iter msg(inSize, inData);
1559
1560         float *data = inWorld->mControlBus;
1561         int32 *touched = inWorld->mControlBusTouched;
1562         int32 bufCounter = inWorld->mBufCounter;
1563         int maxIndex = inWorld->mNumControlBusChannels;
1564
1565         while (msg.remain() >= 12)
1566         {
1567                 int32 start = msg.geti();
1568                 int32 n = msg.geti();
1569                 float32 value = msg.getf();
1570                 int32 end = start+n-1;
1571
1572                 if (end < 0 || start >= maxIndex) continue;
1573
1574                 start = sc_clip(start, 0, maxIndex-1);
1575                 end   = sc_clip(end,   0, maxIndex-1);
1576
1577                 for (int i=start; i<=end; ++i) {
1578                         data[i] = value;
1579                         touched[i] = bufCounter;
1580                 }
1581         }
1582
1583         return kSCErr_None;
1584 }
1585
1586
1587
1588 SCErr meth_b_get(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1589 SCErr meth_b_get(World *inWorld, int inSize, char *inData, ReplyAddress* inReply)
1590 {
1591         sc_msg_iter msg(inSize, inData);
1592         int bufindex = msg.geti();
1593         SndBuf* buf = World_GetBuf(inWorld, bufindex);
1594         if (!buf) return kSCErr_Failed;
1595
1596         float *data = buf->data;
1597         uint32 maxIndex = buf->samples;
1598
1599         int numheads = msg.remain() >> 2;
1600
1601         big_scpacket packet;
1602         packet.adds("/b_set");
1603         packet.maketags(numheads * 2 + 2);
1604         packet.addtag(',');
1605         packet.addtag('i');
1606         packet.addi(bufindex);
1607
1608         while (msg.remain() >= 4)
1609         {
1610                 uint32 index = msg.geti();
1611                 if (index >= maxIndex)
1612                         return kSCErr_IndexOutOfRange;
1613                 packet.addtag('i');
1614                 packet.addtag('f');
1615                 packet.addi(index);
1616                 packet.addf(data[index]);
1617         }
1618
1619         if (packet.size()) {
1620                 CallSequencedCommand(SendReplyCmd, inWorld, packet.size(), packet.data(), inReply);
1621         }
1622
1623         return kSCErr_None;
1624 }
1625
1626 SCErr meth_b_getn(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1627 SCErr meth_b_getn(World *inWorld, int inSize, char *inData, ReplyAddress* inReply)
1628 {
1629         sc_msg_iter msg(inSize, inData);
1630         int bufindex = msg.geti();
1631         SndBuf* buf = World_GetBuf(inWorld, bufindex);
1632         if (!buf) return kSCErr_Failed;
1633
1634         float *data = buf->data;
1635         int32 maxIndex = buf->samples;
1636
1637         // figure out how many tags to allocate
1638         int numcontrols = 0;
1639         int numheads = msg.remain() >> 3;
1640
1641         while (msg.remain()) {
1642                 msg.geti(); // skip start
1643                 int32 n = msg.geti();
1644                 numcontrols += n;
1645         }
1646
1647         big_scpacket packet;
1648         packet.adds("/b_setn");
1649         packet.maketags(numheads * 2 + numcontrols + 2);
1650         packet.addtag(',');
1651
1652         // start over at beginning of message
1653         msg.init(inSize, inData);
1654         msg.geti(); // skip buf index
1655
1656         packet.addtag('i');
1657         packet.addi(bufindex);
1658
1659         while (msg.remain()) {
1660                 int32 start = msg.geti();
1661                 int32 n = msg.geti();
1662                 int32 end = start+n-1;
1663
1664                 if (start < 0 || end >= maxIndex || start > end)
1665                         return kSCErr_IndexOutOfRange;
1666
1667                 packet.addtag('i');
1668                 packet.addtag('i');
1669                 packet.addi(start);
1670                 packet.addi(n);
1671
1672                 for (int i=start; i<=end; ++i) {
1673                         packet.addtag('f');
1674                         packet.addf(data[i]);
1675                 }
1676         }
1677
1678         if (packet.size()) {
1679                 CallSequencedCommand(SendReplyCmd, inWorld, packet.size(), packet.data(), inReply);
1680         }
1681
1682         return kSCErr_None;
1683 }
1684
1685
1686 SCErr meth_s_get(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1687 SCErr meth_s_get(World *inWorld, int inSize, char *inData, ReplyAddress* inReply)
1688 {
1689         sc_msg_iter msg(inSize, inData);
1690
1691         Graph *graph = Msg_GetGraph(inWorld, msg);
1692         if (!graph) return kSCErr_NodeNotFound;
1693
1694         int numheads = msg.tags ? strlen(msg.tags) - 1 : msg.remain() >> 2;
1695
1696         big_scpacket packet;
1697         packet.adds("/n_set");
1698         packet.maketags(numheads * 2 + 2);
1699         packet.addtag(',');
1700         packet.addtag('i');
1701         packet.addi(graph->mNode.mID);
1702
1703         while (msg.remain() >= 4) {
1704                 if (msg.nextTag('i') == 's') {
1705                         int32* name = msg.gets4();
1706                         int32 hash = Hash(name);
1707                         float32 value = 0.f;
1708                         Graph_GetControl(graph, hash, name, 0, value);
1709                         packet.addtag('s');
1710                         packet.addtag('f');
1711                         packet.adds((char*)name);
1712                         packet.addf(value);
1713                 } else {
1714                         int32 index = msg.geti();
1715                         float32 value = 0.f;
1716                         Graph_GetControl(graph, index, value);
1717                         packet.addtag('i');
1718                         packet.addtag('f');
1719                         packet.addi(index);
1720                         packet.addf(value);
1721                 }
1722         }
1723
1724         if (packet.size()) {
1725                 CallSequencedCommand(SendReplyCmd, inWorld, packet.size(), packet.data(), inReply);
1726         }
1727
1728         return kSCErr_None;
1729 }
1730
1731 SCErr meth_s_getn(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1732 SCErr meth_s_getn(World *inWorld, int inSize, char *inData, ReplyAddress* inReply)
1733 {
1734         sc_msg_iter msg(inSize, inData);
1735
1736         Graph *graph = Msg_GetGraph(inWorld, msg);
1737         if (!graph) return kSCErr_NodeNotFound;
1738
1739         // figure out how many tags to allocate
1740         int numcontrols = 0;
1741         int numheads = msg.tags ? strlen(msg.tags) - 1 >> 1 : msg.remain() >> 3;
1742
1743         while (msg.remain()) {
1744                 msg.geti(); // skip start
1745                 int32 n = msg.geti();
1746                 numcontrols += n;
1747         }
1748
1749         big_scpacket packet;
1750         packet.adds("/n_setn");
1751         packet.maketags(numheads * 2 + numcontrols + 2);
1752         packet.addtag(',');
1753
1754         // start over at beginning of message
1755         msg.init(inSize, inData);
1756         msg.geti(); // skip buf index
1757
1758         packet.addtag('i');
1759         packet.addi(graph->mNode.mID);
1760
1761         while (msg.remain()) {
1762                 if (msg.nextTag('i') == 's') {
1763                         int32* name = msg.gets4();
1764                         int32 hash = Hash(name);
1765                         int32 n = msg.geti();
1766                         packet.addtag('s');
1767                         packet.addtag('i');
1768                         packet.adds((char*)name);
1769                         packet.addi(n);
1770                         for (int i=0; i<n; ++i) {
1771                                 float32 value = 0.f;
1772                                 Graph_GetControl(graph, hash, name, i, value);
1773                                 packet.addtag('f');
1774                                 packet.addf(value);
1775                         }
1776                 } else {
1777                         int32 index = msg.geti();
1778                         int32 n = msg.geti();
1779                         packet.addtag('i');
1780                         packet.addtag('i');
1781                         packet.addi(index);
1782                         packet.addi(n);
1783                         for (int i=0; i<n; ++i) {
1784                                 float32 value = 0.f;
1785                                 Graph_GetControl(graph, index+i, value);
1786                                 packet.addtag('f');
1787                                 packet.addf(value);
1788                         }
1789                 }
1790         }
1791
1792         if (packet.size()) {
1793                 CallSequencedCommand(SendReplyCmd, inWorld, packet.size(), packet.data(), inReply);
1794         }
1795
1796         return kSCErr_None;
1797 }
1798
1799
1800
1801 SCErr meth_s_noid(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1802 SCErr meth_s_noid(World *inWorld, int inSize, char *inData, ReplyAddress* inReply)
1803 {
1804         sc_msg_iter msg(inSize, inData);
1805         while (msg.remain()) {
1806
1807                 Graph *graph = Msg_GetGraph(inWorld, msg);
1808                 if (!graph) continue;
1809
1810                 Graph_RemoveID(inWorld, graph);
1811         }
1812
1813         return kSCErr_None;
1814 }
1815
1816
1817 SCErr meth_notify(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1818 SCErr meth_notify(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
1819 {
1820         CallSequencedCommand(NotifyCmd, inWorld, inSize, inData, inReply);
1821         return kSCErr_None;
1822 }
1823
1824 SCErr meth_error(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1825 SCErr meth_error(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1826 {
1827         sc_msg_iter msg(inSize, inData);
1828         int mode = msg.geti();
1829
1830 //      inWorld->mLocalErrorNotification = mode;
1831 //              // if non-zero, new state should be saved permanently
1832 //      if(mode) { inWorld->mErrorNotification = mode; };
1833
1834         // -1 = bundle off, -2 = bundle on, 0 = permanent off, 1 = permanent on
1835         switch(mode) {
1836                 case -1:        inWorld->mLocalErrorNotification += 1;
1837                                         break;
1838                 case -2:        inWorld->mLocalErrorNotification -= 1;
1839                                         break;
1840                 case 0:         inWorld->mErrorNotification = 0;
1841                                         break;
1842                 case 1:         inWorld->mErrorNotification = 1;
1843         };
1844         return kSCErr_None;
1845 }
1846
1847 #define NEW_COMMAND(name) NewCommand(#name, cmd_##name, meth_##name)
1848
1849 void initMiscCommands();
1850 void initMiscCommands()
1851 {
1852
1853 // nrt
1854         NEW_COMMAND(none);
1855         NEW_COMMAND(notify);
1856         NEW_COMMAND(status);
1857         NEW_COMMAND(quit);
1858         NEW_COMMAND(clearSched);
1859
1860         NEW_COMMAND(d_recv);
1861         NEW_COMMAND(d_load);
1862         NEW_COMMAND(d_loadDir);
1863         NEW_COMMAND(d_freeAll);
1864         NEW_COMMAND(d_free);
1865
1866         NEW_COMMAND(s_new);
1867         NEW_COMMAND(s_newargs);
1868
1869         NEW_COMMAND(n_trace);
1870         NEW_COMMAND(n_free);
1871         NEW_COMMAND(n_run);
1872
1873         NEW_COMMAND(u_cmd);
1874         NEW_COMMAND(cmd);
1875
1876         //NEW_COMMAND(n_cmd);
1877         NEW_COMMAND(n_map);
1878         NEW_COMMAND(n_mapn);
1879         NEW_COMMAND(n_mapa);
1880         NEW_COMMAND(n_mapan);
1881         NEW_COMMAND(n_set);
1882         NEW_COMMAND(n_setn);
1883         NEW_COMMAND(n_fill);
1884
1885         NEW_COMMAND(n_before);
1886         NEW_COMMAND(n_after);
1887         NEW_COMMAND(n_order);
1888
1889         NEW_COMMAND(g_new);
1890         NEW_COMMAND(g_head);
1891         NEW_COMMAND(g_tail);
1892         NEW_COMMAND(g_freeAll);
1893         NEW_COMMAND(g_deepFree);
1894
1895         NEW_COMMAND(p_new);
1896
1897         NEW_COMMAND(b_alloc);
1898         NEW_COMMAND(b_allocRead);
1899         NEW_COMMAND(b_allocReadChannel);
1900
1901         NEW_COMMAND(b_read);
1902         NEW_COMMAND(b_readChannel);
1903         NEW_COMMAND(b_write);
1904
1905         NEW_COMMAND(b_free);
1906         NEW_COMMAND(b_close);
1907
1908         NEW_COMMAND(b_zero);
1909         NEW_COMMAND(b_set);
1910         NEW_COMMAND(b_setn);
1911         NEW_COMMAND(b_fill);
1912         NEW_COMMAND(b_gen);
1913
1914         NEW_COMMAND(c_set);
1915         NEW_COMMAND(c_setn);
1916         NEW_COMMAND(c_fill);
1917
1918         NEW_COMMAND(dumpOSC);
1919
1920         NEW_COMMAND(c_get);
1921         NEW_COMMAND(c_getn);
1922         NEW_COMMAND(b_get);
1923         NEW_COMMAND(b_getn);
1924         NEW_COMMAND(s_get);
1925         NEW_COMMAND(s_getn);
1926
1927         NEW_COMMAND(n_query);
1928         NEW_COMMAND(b_query);
1929
1930         NEW_COMMAND(s_noid);
1931         NEW_COMMAND(sync);
1932         NEW_COMMAND(g_dumpTree);
1933         NEW_COMMAND(g_queryTree);
1934
1935         NEW_COMMAND(error);
1936 }
1937
1938