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_CoreAudio.h"
  24 #include "SC_HiddenWorld.h"
  25 #include "SC_Graph.h"
  26 #include "SC_GraphDef.h"
  27 #include "SC_Group.h"
  28 #include "SC_UnitDef.h"
  29 #include <stdexcept>
  30 #include "SC_Lib_Cintf.h"
  31 #include "SC_SequencedCommand.h"
  32 #include <new>
  33 #include "SC_Prototypes.h"
  34 #include "scsynthsend.h"
  35 #include "SC_WorldOptions.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
1087         Node *prevNode = 0;
1088         Node *node = 0;
1089
1090         sc_msg_iter msg(inSize, inData);
1091         int32 addAction = msg.geti();
1092
1093         // place the first node in the list based on target and addAction
1094         switch (addAction) {
1095                 case 0 : {
1096                         Group *group = Msg_GetGroup(inWorld, msg);
1097                         if (!group) return kSCErr_GroupNotFound;
1098                         while(!node && msg.remain()) {
1099                                 node = Msg_GetNode(inWorld, msg);
1100                                 if(!node) scprintf("Warning Node not found\n");
1101                         }
1102                         if (!node) return kSCErr_NodeNotFound;
1103
1104                         Group *prevGroup = node->mParent;
1105
1106                         Node_Remove(node);
1107
1108                         Group_AddHead(group, node);
1109
1110                         if (group != prevGroup) {
1111                                 Node_StateMsg(node, kNode_Move);
1112                         }
1113
1114                         prevNode = node;
1115
1116                 } break;
1117                 case 1 : {
1118                         Group *group = Msg_GetGroup(inWorld, msg);
1119                         if (!group) return kSCErr_GroupNotFound;
1120                         while(!node && msg.remain()) {
1121                                 node = Msg_GetNode(inWorld, msg);
1122                                 if(!node) scprintf("Warning Node not found\n");
1123                         }
1124                         if (!node) return kSCErr_NodeNotFound;
1125
1126                         Group *prevGroup = node->mParent;
1127
1128                         Node_Remove(node);
1129
1130                         Group_AddTail(group, node);
1131
1132                         if (group != prevGroup) {
1133                                 Node_StateMsg(node, kNode_Move);
1134                         }
1135
1136                         prevNode = node;
1137
1138                 } break;
1139                 case 2 : {
1140                         Node *beforeNode = Msg_GetNode(inWorld, msg);
1141                         if (!beforeNode) return kSCErr_TargetNodeNotFound;
1142                         while(!node && msg.remain()) {
1143                                 node = Msg_GetNode(inWorld, msg);
1144                                 if(!node) scprintf("Warning Node not found\n");
1145                         }
1146                         if (!node) return kSCErr_NodeNotFound;
1147
1148
1149                         Node_Remove(node);
1150                         Node_AddBefore(node, beforeNode);
1151                         Node_StateMsg(node, kNode_Move);
1152
1153                         prevNode = node;
1154                 } break;
1155                 case 3 : {
1156                         Node *afterNode = Msg_GetNode(inWorld, msg);
1157                         if (!afterNode) return kSCErr_TargetNodeNotFound;
1158                         while(!node && msg.remain()) {
1159                                 node = Msg_GetNode(inWorld, msg);
1160                                 if(!node) scprintf("Warning Node not found\n");
1161                         }
1162                         if (!node) return kSCErr_NodeNotFound;
1163
1164
1165                         Node_Remove(node);
1166                         Node_AddAfter(node, afterNode);
1167                         Node_StateMsg(node, kNode_Move);
1168
1169                         prevNode = node;
1170                 } break;
1171                 default: return kSCErr_Failed;
1172         }
1173
1174         // now iterate through in order
1175         while (msg.remain()) {
1176                 node = Msg_GetNode(inWorld, msg);
1177                 if(!node) {
1178                         scprintf("Warning Node not found\n");
1179                         continue;
1180                 }
1181                 Node_Remove(node);
1182                 Node_AddAfter(node, prevNode);
1183                 Node_StateMsg(node, kNode_Move);
1184
1185                 prevNode = node;
1186         }
1187
1188         return kSCErr_None;
1189 }
1190
1191 SCErr meth_g_head(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1192 SCErr meth_g_head(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1193 {
1194         sc_msg_iter msg(inSize, inData);
1195         while (msg.remain()) {
1196                 Group *group = Msg_GetGroup(inWorld, msg);
1197                 if (!group) return kSCErr_GroupNotFound;
1198
1199                 Node *node = Msg_GetNode(inWorld, msg);
1200                 if (!node) return kSCErr_NodeNotFound;
1201
1202                 Group *prevGroup = node->mParent;
1203
1204                 Node_Remove(node);
1205
1206                 Group_AddHead(group, node);
1207
1208                 if (group != prevGroup) {
1209                         Node_StateMsg(node, kNode_Move);
1210                 }
1211         }
1212         return kSCErr_None;
1213 }
1214
1215 SCErr meth_g_tail(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1216 SCErr meth_g_tail(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1217 {
1218         sc_msg_iter msg(inSize, inData);
1219         while (msg.remain()) {
1220                 Group *group = Msg_GetGroup(inWorld, msg);
1221                 if (!group) return kSCErr_GroupNotFound;
1222
1223                 Node *node = Msg_GetNode(inWorld, msg);
1224                 if (!node) return kSCErr_NodeNotFound;
1225
1226                 //Group *prevGroup = node->mParent;
1227
1228                 Node_Remove(node);
1229                 Group_AddTail(group, node);
1230
1231                 //if (group != prevGroup) {
1232                         Node_StateMsg(node, kNode_Move);
1233                 //}
1234         }
1235         return kSCErr_None;
1236 }
1237
1238 SCErr meth_g_insert(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1239 SCErr meth_g_insert(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1240 {
1241         sc_msg_iter msg(inSize, inData);
1242         while (msg.remain()) {
1243                 Group *group = Msg_GetGroup(inWorld, msg);
1244                 if (!group) return kSCErr_GroupNotFound;
1245
1246                 Node *node = Msg_GetNode(inWorld, msg);
1247                 if (!node) return kSCErr_NodeNotFound;
1248
1249                 Group *prevGroup = node->mParent;
1250
1251                 int index = msg.geti();
1252
1253                 Node_Remove(node);
1254                 Group_Insert(group, node, index);
1255
1256                 if (group != prevGroup) {
1257                         Node_StateMsg(node, kNode_Move);
1258                 }
1259         }
1260         return kSCErr_None;
1261 }
1262
1263 SCErr meth_g_freeAll(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1264 SCErr meth_g_freeAll(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1265 {
1266         sc_msg_iter msg(inSize, inData);
1267         while (msg.remain()) {
1268                 Group *group = Msg_GetGroup(inWorld, msg);
1269                 if (!group) return kSCErr_GroupNotFound;
1270
1271                 Group_DeleteAll(group);
1272         }
1273         return kSCErr_None;
1274 }
1275
1276 SCErr meth_g_deepFree(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1277 SCErr meth_g_deepFree(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1278 {
1279         sc_msg_iter msg(inSize, inData);
1280         while (msg.remain()) {
1281                 Group *group = Msg_GetGroup(inWorld, msg);
1282                 if (!group) return kSCErr_GroupNotFound;
1283
1284                 Group_DeepFreeGraphs(group);
1285         }
1286         return kSCErr_None;
1287 }
1288
1289
1290
1291 SCErr meth_status(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1292 SCErr meth_status(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
1293 {
1294         CallSequencedCommand(AudioStatusCmd, inWorld, inSize, inData, inReply);
1295         return kSCErr_None;
1296 }
1297
1298 SCErr meth_quit(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1299 SCErr meth_quit(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
1300 {
1301         CallSequencedCommand(AudioQuitCmd, inWorld, inSize, inData, inReply);
1302         return kSCErr_None;
1303 }
1304
1305 SCErr meth_clearSched(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1306 SCErr meth_clearSched(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
1307 {
1308         if(inWorld->mRealTime){
1309                 inWorld->hw->mAudioDriver->ClearSched();
1310         }
1311         return kSCErr_None;
1312 }
1313
1314 SCErr meth_dumpOSC(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1315 SCErr meth_dumpOSC(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
1316 {
1317         sc_msg_iter msg(inSize, inData);
1318         inWorld->mDumpOSC = msg.geti();
1319         return kSCErr_None;
1320 }
1321
1322 SCErr meth_b_set(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1323 SCErr meth_b_set(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1324 {
1325         sc_msg_iter msg(inSize, inData);
1326         int bufindex = msg.geti();
1327         SndBuf* buf = World_GetBuf(inWorld, bufindex);
1328         if (!buf) return kSCErr_Failed;
1329
1330         float *data = buf->data;
1331         uint32 numSamples = buf->samples;
1332
1333         while (msg.remain() >= 8)
1334         {
1335                 uint32 sampleIndex = msg.geti();
1336                 float32 value = msg.getf();
1337                 if (sampleIndex < numSamples)
1338                 {
1339                         data[sampleIndex] = value;
1340                 } else return kSCErr_IndexOutOfRange;
1341
1342         }
1343         return kSCErr_None;
1344 }
1345
1346 SCErr meth_b_setn(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1347 SCErr meth_b_setn(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1348 {
1349         sc_msg_iter msg(inSize, inData);
1350         int bufindex = msg.geti();
1351         SndBuf* buf = World_GetBuf(inWorld, bufindex);
1352         if (!buf) return kSCErr_Failed;
1353
1354         float *data = buf->data;
1355         int numSamples = buf->samples;
1356
1357         while (msg.remain()) {
1358                 int32 start = msg.geti();
1359                 int32 n = msg.geti();
1360                 int32 end = start+n-1;
1361
1362                 if (end < 0 || start >= numSamples) continue;
1363
1364                 start = sc_clip(start, 0, numSamples-1);
1365                 end   = sc_clip(end,   0, numSamples-1);
1366
1367                 for (int i=start; msg.remain() && i<=end; ++i) {
1368                         float32 value = msg.getf();
1369                         data[i] = value;
1370                 }
1371         }
1372
1373         return kSCErr_None;
1374 }
1375
1376
1377 SCErr meth_b_fill(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1378 SCErr meth_b_fill(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1379 {
1380         sc_msg_iter msg(inSize, inData);
1381         int bufindex = msg.geti();
1382         SndBuf* buf = World_GetBuf(inWorld, bufindex);
1383         if (!buf) return kSCErr_Failed;
1384
1385         float *data = buf->data;
1386         int numSamples = buf->samples;
1387
1388         while (msg.remain() >= 12)
1389         {
1390                 int32 start = msg.geti();
1391                 int32 n = msg.geti();
1392                 float32 value = msg.getf();
1393                 int32 end = start+n-1;
1394
1395                 if (end < 0 || start >= numSamples) continue;
1396
1397                 start = sc_clip(start, 0, numSamples-1);
1398                 end   = sc_clip(end,   0, numSamples-1);
1399
1400                 for (int i=start; i<=end; ++i) data[i] = value;
1401         }
1402
1403         return kSCErr_None;
1404 }
1405
1406 SCErr meth_b_gen(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1407 SCErr meth_b_gen(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
1408 {
1409         CallSequencedCommand(BufGenCmd, inWorld, inSize, inData, inReply);
1410
1411         return kSCErr_None;
1412 }
1413
1414
1415 SCErr meth_c_set(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1416 SCErr meth_c_set(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1417 {
1418         sc_msg_iter msg(inSize, inData);
1419
1420         float *data = inWorld->mControlBus;
1421         int32 *touched = inWorld->mControlBusTouched;
1422         int32 bufCounter = inWorld->mBufCounter;
1423         uint32 maxIndex = inWorld->mNumControlBusChannels;
1424
1425         while (msg.remain() >= 8)
1426         {
1427                 uint32 index = msg.geti();
1428                 float32 value = msg.getf();
1429                 if (index < maxIndex)
1430                 {
1431                         data[index] = value;
1432                         touched[index] = bufCounter;
1433                 } else return kSCErr_IndexOutOfRange;
1434
1435         }
1436         return kSCErr_None;
1437 }
1438
1439 SCErr meth_c_setn(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1440 SCErr meth_c_setn(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1441 {
1442         sc_msg_iter msg(inSize, inData);
1443
1444         float *data = inWorld->mControlBus;
1445         int32 *touched = inWorld->mControlBusTouched;
1446         int32 bufCounter = inWorld->mBufCounter;
1447         int maxIndex = inWorld->mNumControlBusChannels;
1448
1449         while (msg.remain()) {
1450                 int32 start = msg.geti();
1451                 int32 n = msg.geti();
1452                 int32 end = start+n-1;
1453
1454                 if (start < 0 || end >= maxIndex || start > end)
1455                         return kSCErr_IndexOutOfRange;
1456
1457                 for (int i=start; msg.remain() && i<=end; ++i) {
1458                         float32 value = msg.getf();
1459                         data[i] = value;
1460                         touched[i] = bufCounter;
1461                 }
1462         }
1463
1464         return kSCErr_None;
1465 }
1466
1467
1468 SCErr meth_c_get(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1469 SCErr meth_c_get(World *inWorld, int inSize, char *inData, ReplyAddress* inReply)
1470 {
1471         sc_msg_iter msg(inSize, inData);
1472
1473         float *data = inWorld->mControlBus;
1474         uint32 maxIndex = inWorld->mNumControlBusChannels;
1475
1476         int numheads = msg.remain() >> 2;
1477
1478         big_scpacket packet;
1479         packet.adds("/c_set");
1480         packet.maketags(numheads * 2 + 1);
1481         packet.addtag(',');
1482
1483         while (msg.remain() >= 4)
1484         {
1485                 uint32 index = msg.geti();
1486                 if (index >= maxIndex)
1487                         return kSCErr_IndexOutOfRange;
1488                 packet.addtag('i');
1489                 packet.addtag('f');
1490                 packet.addi(index);
1491                 packet.addf(data[index]);
1492         }
1493
1494         if (packet.size()) {
1495                 CallSequencedCommand(SendReplyCmd, inWorld, packet.size(), packet.data(), inReply);
1496         }
1497
1498         return kSCErr_None;
1499 }
1500
1501 SCErr meth_c_getn(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1502 SCErr meth_c_getn(World *inWorld, int inSize, char *inData, ReplyAddress* inReply)
1503 {
1504         sc_msg_iter msg(inSize, inData);
1505
1506         float *data = inWorld->mControlBus;
1507         int maxIndex = inWorld->mNumControlBusChannels;
1508
1509         // figure out how many tags to allocate
1510         int numcontrols = 0;
1511         int numheads = msg.remain() >> 3;
1512
1513         while (msg.remain()) {
1514                 msg.geti(); // skip start
1515                 int32 n = msg.geti();
1516                 numcontrols += n;
1517         }
1518
1519         big_scpacket packet;
1520         packet.adds("/c_setn");
1521         packet.maketags(numheads * 2 + numcontrols + 1);
1522         packet.addtag(',');
1523
1524         // start over at beginning of message
1525         msg.init(inSize, inData);
1526
1527         while (msg.remain()) {
1528                 int32 start = msg.geti();
1529                 int32 n = msg.geti();
1530                 int32 end = start+n-1;
1531
1532                 if (start < 0 || end >= maxIndex || start > end)
1533                         return kSCErr_IndexOutOfRange;
1534
1535                 packet.addtag('i');
1536                 packet.addtag('i');
1537                 packet.addi(start);
1538                 packet.addi(n);
1539
1540                 for (int i=start; i<=end; ++i) {
1541                         packet.addtag('f');
1542                         packet.addf(data[i]);
1543                 }
1544         }
1545
1546         if (packet.size()) {
1547                 CallSequencedCommand(SendReplyCmd, inWorld, packet.size(), packet.data(), inReply);
1548         }
1549
1550         return kSCErr_None;
1551 }
1552
1553
1554 SCErr meth_c_fill(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1555 SCErr meth_c_fill(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1556 {
1557         sc_msg_iter msg(inSize, inData);
1558
1559         float *data = inWorld->mControlBus;
1560         int32 *touched = inWorld->mControlBusTouched;
1561         int32 bufCounter = inWorld->mBufCounter;
1562         int maxIndex = inWorld->mNumControlBusChannels;
1563
1564         while (msg.remain() >= 12)
1565         {
1566                 int32 start = msg.geti();
1567                 int32 n = msg.geti();
1568                 float32 value = msg.getf();
1569                 int32 end = start+n-1;
1570
1571                 if (end < 0 || start >= maxIndex) continue;
1572
1573                 start = sc_clip(start, 0, maxIndex-1);
1574                 end   = sc_clip(end,   0, maxIndex-1);
1575
1576                 for (int i=start; i<=end; ++i) {
1577                         data[i] = value;
1578                         touched[i] = bufCounter;
1579                 }
1580         }
1581
1582         return kSCErr_None;
1583 }
1584
1585
1586
1587 SCErr meth_b_get(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1588 SCErr meth_b_get(World *inWorld, int inSize, char *inData, ReplyAddress* inReply)
1589 {
1590         sc_msg_iter msg(inSize, inData);
1591         int bufindex = msg.geti();
1592         SndBuf* buf = World_GetBuf(inWorld, bufindex);
1593         if (!buf) return kSCErr_Failed;
1594
1595         float *data = buf->data;
1596         uint32 maxIndex = buf->samples;
1597
1598         int numheads = msg.remain() >> 2;
1599
1600         big_scpacket packet;
1601         packet.adds("/b_set");
1602         packet.maketags(numheads * 2 + 2);
1603         packet.addtag(',');
1604         packet.addtag('i');
1605         packet.addi(bufindex);
1606
1607         while (msg.remain() >= 4)
1608         {
1609                 uint32 index = msg.geti();
1610                 if (index >= maxIndex)
1611                         return kSCErr_IndexOutOfRange;
1612                 packet.addtag('i');
1613                 packet.addtag('f');
1614                 packet.addi(index);
1615                 packet.addf(data[index]);
1616         }
1617
1618         if (packet.size()) {
1619                 CallSequencedCommand(SendReplyCmd, inWorld, packet.size(), packet.data(), inReply);
1620         }
1621
1622         return kSCErr_None;
1623 }
1624
1625 SCErr meth_b_getn(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1626 SCErr meth_b_getn(World *inWorld, int inSize, char *inData, ReplyAddress* inReply)
1627 {
1628         sc_msg_iter msg(inSize, inData);
1629         int bufindex = msg.geti();
1630         SndBuf* buf = World_GetBuf(inWorld, bufindex);
1631         if (!buf) return kSCErr_Failed;
1632
1633         float *data = buf->data;
1634         int32 maxIndex = buf->samples;
1635
1636         // figure out how many tags to allocate
1637         int numcontrols = 0;
1638         int numheads = msg.remain() >> 3;
1639
1640         while (msg.remain()) {
1641                 msg.geti(); // skip start
1642                 int32 n = msg.geti();
1643                 numcontrols += n;
1644         }
1645
1646         big_scpacket packet;
1647         packet.adds("/b_setn");
1648         packet.maketags(numheads * 2 + numcontrols + 2);
1649         packet.addtag(',');
1650
1651         // start over at beginning of message
1652         msg.init(inSize, inData);
1653         msg.geti(); // skip buf index
1654
1655         packet.addtag('i');
1656         packet.addi(bufindex);
1657
1658         while (msg.remain()) {
1659                 int32 start = msg.geti();
1660                 int32 n = msg.geti();
1661                 int32 end = start+n-1;
1662
1663                 if (start < 0 || end >= maxIndex || start > end)
1664                         return kSCErr_IndexOutOfRange;
1665
1666                 packet.addtag('i');
1667                 packet.addtag('i');
1668                 packet.addi(start);
1669                 packet.addi(n);
1670
1671                 for (int i=start; i<=end; ++i) {
1672                         packet.addtag('f');
1673                         packet.addf(data[i]);
1674                 }
1675         }
1676
1677         if (packet.size()) {
1678                 CallSequencedCommand(SendReplyCmd, inWorld, packet.size(), packet.data(), inReply);
1679         }
1680
1681         return kSCErr_None;
1682 }
1683
1684
1685 SCErr meth_s_get(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1686 SCErr meth_s_get(World *inWorld, int inSize, char *inData, ReplyAddress* inReply)
1687 {
1688         sc_msg_iter msg(inSize, inData);
1689
1690         Graph *graph = Msg_GetGraph(inWorld, msg);
1691         if (!graph) return kSCErr_NodeNotFound;
1692
1693         int numheads = msg.tags ? strlen(msg.tags) - 1 : msg.remain() >> 2;
1694
1695         big_scpacket packet;
1696         packet.adds("/n_set");
1697         packet.maketags(numheads * 2 + 2);
1698         packet.addtag(',');
1699         packet.addtag('i');
1700         packet.addi(graph->mNode.mID);
1701
1702         while (msg.remain() >= 4) {
1703                 if (msg.nextTag('i') == 's') {
1704                         int32* name = msg.gets4();
1705                         int32 hash = Hash(name);
1706                         float32 value = 0.f;
1707                         Graph_GetControl(graph, hash, name, 0, value);
1708                         packet.addtag('s');
1709                         packet.addtag('f');
1710                         packet.adds((char*)name);
1711                         packet.addf(value);
1712                 } else {
1713                         int32 index = msg.geti();
1714                         float32 value = 0.f;
1715                         Graph_GetControl(graph, index, value);
1716                         packet.addtag('i');
1717                         packet.addtag('f');
1718                         packet.addi(index);
1719                         packet.addf(value);
1720                 }
1721         }
1722
1723         if (packet.size()) {
1724                 CallSequencedCommand(SendReplyCmd, inWorld, packet.size(), packet.data(), inReply);
1725         }
1726
1727         return kSCErr_None;
1728 }
1729
1730 SCErr meth_s_getn(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1731 SCErr meth_s_getn(World *inWorld, int inSize, char *inData, ReplyAddress* inReply)
1732 {
1733         sc_msg_iter msg(inSize, inData);
1734
1735         Graph *graph = Msg_GetGraph(inWorld, msg);
1736         if (!graph) return kSCErr_NodeNotFound;
1737
1738         // figure out how many tags to allocate
1739         int numcontrols = 0;
1740         int numheads = msg.tags ? strlen(msg.tags) - 1 >> 1 : msg.remain() >> 3;
1741
1742         while (msg.remain()) {
1743                 msg.geti(); // skip start
1744                 int32 n = msg.geti();
1745                 numcontrols += n;
1746         }
1747
1748         big_scpacket packet;
1749         packet.adds("/n_setn");
1750         packet.maketags(numheads * 2 + numcontrols + 2);
1751         packet.addtag(',');
1752
1753         // start over at beginning of message
1754         msg.init(inSize, inData);
1755         msg.geti(); // skip buf index
1756
1757         packet.addtag('i');
1758         packet.addi(graph->mNode.mID);
1759
1760         while (msg.remain()) {
1761                 if (msg.nextTag('i') == 's') {
1762                         int32* name = msg.gets4();
1763                         int32 hash = Hash(name);
1764                         int32 n = msg.geti();
1765                         packet.addtag('s');
1766                         packet.addtag('i');
1767                         packet.adds((char*)name);
1768                         packet.addi(n);
1769                         for (int i=0; i<n; ++i) {
1770                                 float32 value = 0.f;
1771                                 Graph_GetControl(graph, hash, name, i, value);
1772                                 packet.addtag('f');
1773                                 packet.addf(value);
1774                         }
1775                 } else {
1776                         int32 index = msg.geti();
1777                         int32 n = msg.geti();
1778                         packet.addtag('i');
1779                         packet.addtag('i');
1780                         packet.addi(index);
1781                         packet.addi(n);
1782                         for (int i=0; i<n; ++i) {
1783                                 float32 value = 0.f;
1784                                 Graph_GetControl(graph, index+i, value);
1785                                 packet.addtag('f');
1786                                 packet.addf(value);
1787                         }
1788                 }
1789         }
1790
1791         if (packet.size()) {
1792                 CallSequencedCommand(SendReplyCmd, inWorld, packet.size(), packet.data(), inReply);
1793         }
1794
1795         return kSCErr_None;
1796 }
1797
1798
1799
1800 SCErr meth_s_noid(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1801 SCErr meth_s_noid(World *inWorld, int inSize, char *inData, ReplyAddress* inReply)
1802 {
1803         sc_msg_iter msg(inSize, inData);
1804         while (msg.remain()) {
1805
1806                 Graph *graph = Msg_GetGraph(inWorld, msg);
1807                 if (!graph) continue;
1808
1809                 Graph_RemoveID(inWorld, graph);
1810         }
1811
1812         return kSCErr_None;
1813 }
1814
1815
1816 SCErr meth_notify(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1817 SCErr meth_notify(World *inWorld, int inSize, char *inData, ReplyAddress *inReply)
1818 {
1819         CallSequencedCommand(NotifyCmd, inWorld, inSize, inData, inReply);
1820         return kSCErr_None;
1821 }
1822
1823 SCErr meth_error(World *inWorld, int inSize, char *inData, ReplyAddress *inReply);
1824 SCErr meth_error(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
1825 {
1826         sc_msg_iter msg(inSize, inData);
1827         int mode = msg.geti();
1828
1829 //      inWorld->mLocalErrorNotification = mode;
1830 //              // if non-zero, new state should be saved permanently
1831 //      if(mode) { inWorld->mErrorNotification = mode; };
1832
1833         // -1 = bundle off, -2 = bundle on, 0 = permanent off, 1 = permanent on
1834         switch(mode) {
1835                 case -1:        inWorld->mLocalErrorNotification += 1;
1836                                         break;
1837                 case -2:        inWorld->mLocalErrorNotification -= 1;
1838                                         break;
1839                 case 0:         inWorld->mErrorNotification = 0;
1840                                         break;
1841                 case 1:         inWorld->mErrorNotification = 1;
1842         };
1843         return kSCErr_None;
1844 }
1845
1846 #define NEW_COMMAND(name) NewCommand(#name, cmd_##name, meth_##name)
1847
1848 void initMiscCommands();
1849 void initMiscCommands()
1850 {
1851
1852 // nrt
1853         NEW_COMMAND(none);
1854         NEW_COMMAND(notify);
1855         NEW_COMMAND(status);
1856         NEW_COMMAND(quit);
1857         NEW_COMMAND(clearSched);
1858
1859         NEW_COMMAND(d_recv);
1860         NEW_COMMAND(d_load);
1861         NEW_COMMAND(d_loadDir);
1862         NEW_COMMAND(d_freeAll);
1863         NEW_COMMAND(d_free);
1864
1865         NEW_COMMAND(s_new);
1866         NEW_COMMAND(s_newargs);
1867
1868         NEW_COMMAND(n_trace);
1869         NEW_COMMAND(n_free);
1870         NEW_COMMAND(n_run);
1871
1872         NEW_COMMAND(u_cmd);
1873         NEW_COMMAND(cmd);
1874
1875         //NEW_COMMAND(n_cmd);
1876         NEW_COMMAND(n_map);
1877         NEW_COMMAND(n_mapn);
1878         NEW_COMMAND(n_mapa);
1879         NEW_COMMAND(n_mapan);
1880         NEW_COMMAND(n_set);
1881         NEW_COMMAND(n_setn);
1882         NEW_COMMAND(n_fill);
1883
1884         NEW_COMMAND(n_before);
1885         NEW_COMMAND(n_after);
1886         NEW_COMMAND(n_order);
1887
1888         NEW_COMMAND(g_new);
1889         NEW_COMMAND(g_head);
1890         NEW_COMMAND(g_tail);
1891         NEW_COMMAND(g_freeAll);
1892         NEW_COMMAND(g_deepFree);
1893
1894         NEW_COMMAND(p_new);
1895
1896         NEW_COMMAND(b_alloc);
1897         NEW_COMMAND(b_allocRead);
1898         NEW_COMMAND(b_allocReadChannel);
1899
1900         NEW_COMMAND(b_read);
1901         NEW_COMMAND(b_readChannel);
1902         NEW_COMMAND(b_write);
1903
1904         NEW_COMMAND(b_free);
1905         NEW_COMMAND(b_close);
1906
1907         NEW_COMMAND(b_zero);
1908         NEW_COMMAND(b_set);
1909         NEW_COMMAND(b_setn);
1910         NEW_COMMAND(b_fill);
1911         NEW_COMMAND(b_gen);
1912
1913         NEW_COMMAND(c_set);
1914         NEW_COMMAND(c_setn);
1915         NEW_COMMAND(c_fill);
1916
1917         NEW_COMMAND(dumpOSC);
1918
1919         NEW_COMMAND(c_get);
1920         NEW_COMMAND(c_getn);
1921         NEW_COMMAND(b_get);
1922         NEW_COMMAND(b_getn);
1923         NEW_COMMAND(s_get);
1924         NEW_COMMAND(s_getn);
1925
1926         NEW_COMMAND(n_query);
1927         NEW_COMMAND(b_query);
1928
1929         NEW_COMMAND(s_noid);
1930         NEW_COMMAND(sync);
1931         NEW_COMMAND(g_dumpTree);
1932         NEW_COMMAND(g_queryTree);
1933
1934         NEW_COMMAND(error);
1935 }
1936
1937