bundles/org.simantics.databoard/cpp/DataBoardTest/libantlr3c-3.2/src/antlr3debughandlers.c

   1 /// \file
   2 /// Provides the debugging functions invoked by a recognizer
   3 /// built using the debug generator mode of the antlr tool.
   4 /// See antlr3debugeventlistener.h for documentation.
   5 ///
   6
   7 // [The "BSD licence"]
   8 // Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
   9 // http://www.temporal-wave.com
  10 // http://www.linkedin.com/in/jimidle
  11 //
  12 // All rights reserved.
  13 //
  14 // Redistribution and use in source and binary forms, with or without
  15 // modification, are permitted provided that the following conditions
  16 // are met:
  17 // 1. Redistributions of source code must retain the above copyright
  18 //    notice, this list of conditions and the following disclaimer.
  19 // 2. Redistributions in binary form must reproduce the above copyright
  20 //    notice, this list of conditions and the following disclaimer in the
  21 //    documentation and/or other materials provided with the distribution.
  22 // 3. The name of the author may not be used to endorse or promote products
  23 //    derived from this software without specific prior written permission.
  24 //
  25 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  26 // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  27 // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  28 // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  29 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  30 // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  31 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  32 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  33 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  34 // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35
  36 #include    <antlr3.h>
  37
  38 // Not everyone wishes to include the debugger stuff in their final deployment because
  39 // it will then rely on being linked with the socket libraries. Hence if the programmer turns
  40 // off the debugging, we do some dummy stuff that satifies compilers etc but means there is
  41 // no debugger and no reliance on the socket librarires. If you set this flag, then using the -debug
  42 // option to generate your code will produce code that just crashes, but then I presme you are smart
  43 // enough to realize that building the libraries without debugger support means you can't call the
  44 // debugger ;-)
  45 //
  46 #ifdef ANTLR3_NODEBUGGER
  47 ANTLR3_API pANTLR3_DEBUG_EVENT_LISTENER
  48 antlr3DebugListenerNew()
  49 {
  50                 ANTLR3_PRINTF("C runtime was compiled without debugger support. This program will crash!!");
  51                 return NULL;
  52 }
  53 #else
  54
  55 static  ANTLR3_BOOLEAN  handshake               (pANTLR3_DEBUG_EVENT_LISTENER delboy);
  56 static  void    enterRule                               (pANTLR3_DEBUG_EVENT_LISTENER delboy, const char * grammarFileName, const char * ruleName);
  57 static  void    enterAlt                                (pANTLR3_DEBUG_EVENT_LISTENER delboy, int alt);
  58 static  void    exitRule                                (pANTLR3_DEBUG_EVENT_LISTENER delboy, const char * grammarFileName, const char * ruleName);
  59 static  void    enterSubRule                    (pANTLR3_DEBUG_EVENT_LISTENER delboy, int decisionNumber);
  60 static  void    exitSubRule                             (pANTLR3_DEBUG_EVENT_LISTENER delboy, int decisionNumber);
  61 static  void    enterDecision                   (pANTLR3_DEBUG_EVENT_LISTENER delboy, int decisionNumber);
  62 static  void    exitDecision                    (pANTLR3_DEBUG_EVENT_LISTENER delboy, int decisionNumber);
  63 static  void    consumeToken                    (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_COMMON_TOKEN t);
  64 static  void    consumeHiddenToken              (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_COMMON_TOKEN t);
  65 static  void    LT                                              (pANTLR3_DEBUG_EVENT_LISTENER delboy, int i, pANTLR3_COMMON_TOKEN t);
  66 static  void    mark                                    (pANTLR3_DEBUG_EVENT_LISTENER delboy, ANTLR3_MARKER marker);
  67 static  void    rewindMark                              (pANTLR3_DEBUG_EVENT_LISTENER delboy, ANTLR3_MARKER marker);
  68 static  void    rewindLast                              (pANTLR3_DEBUG_EVENT_LISTENER delboy);
  69 static  void    beginBacktrack                  (pANTLR3_DEBUG_EVENT_LISTENER delboy, int level);
  70 static  void    endBacktrack                    (pANTLR3_DEBUG_EVENT_LISTENER delboy, int level, ANTLR3_BOOLEAN successful);
  71 static  void    location                                (pANTLR3_DEBUG_EVENT_LISTENER delboy, int line, int pos);
  72 static  void    recognitionException    (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_EXCEPTION e);
  73 static  void    beginResync                             (pANTLR3_DEBUG_EVENT_LISTENER delboy);
  74 static  void    endResync                               (pANTLR3_DEBUG_EVENT_LISTENER delboy);
  75 static  void    semanticPredicate               (pANTLR3_DEBUG_EVENT_LISTENER delboy, ANTLR3_BOOLEAN result, const char * predicate);
  76 static  void    commence                                (pANTLR3_DEBUG_EVENT_LISTENER delboy);
  77 static  void    terminate                               (pANTLR3_DEBUG_EVENT_LISTENER delboy);
  78 static  void    consumeNode                             (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t);
  79 static  void    LTT                                             (pANTLR3_DEBUG_EVENT_LISTENER delboy, int i, pANTLR3_BASE_TREE t);
  80 static  void    nilNode                                 (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t);
  81 static  void    errorNode                               (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t);
  82 static  void    createNode                              (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t);
  83 static  void    createNodeTok                   (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE node, pANTLR3_COMMON_TOKEN token);
  84 static  void    becomeRoot                              (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE newRoot, pANTLR3_BASE_TREE oldRoot);
  85 static  void    addChild                                (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE root, pANTLR3_BASE_TREE child);
  86 static  void    setTokenBoundaries              (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t, ANTLR3_MARKER tokenStartIndex, ANTLR3_MARKER tokenStopIndex);
  87 static  void    ack                                             (pANTLR3_DEBUG_EVENT_LISTENER delboy);
  88
  89 /// Create and initialize a new debug event listener that can be connected to
  90 /// by ANTLRWorks and any other debugger via a socket.
  91 ///
  92 ANTLR3_API pANTLR3_DEBUG_EVENT_LISTENER
  93 antlr3DebugListenerNew()
  94 {
  95         pANTLR3_DEBUG_EVENT_LISTENER    delboy;
  96
  97         delboy = ANTLR3_CALLOC(1, sizeof(ANTLR3_DEBUG_EVENT_LISTENER));
  98
  99         if      (delboy == NULL)
 100         {
 101                 return NULL;
 102         }
 103
 104         // Initialize the API
 105         //
 106         delboy->addChild                                = addChild;
 107         delboy->becomeRoot                              = becomeRoot;
 108         delboy->beginBacktrack                  = beginBacktrack;
 109         delboy->beginResync                             = beginResync;
 110         delboy->commence                                = commence;
 111         delboy->consumeHiddenToken              = consumeHiddenToken;
 112         delboy->consumeNode                             = consumeNode;
 113         delboy->consumeToken                    = consumeToken;
 114         delboy->createNode                              = createNode;
 115         delboy->createNodeTok                   = createNodeTok;
 116         delboy->endBacktrack                    = endBacktrack;
 117         delboy->endResync                               = endResync;
 118         delboy->enterAlt                                = enterAlt;
 119         delboy->enterDecision                   = enterDecision;
 120         delboy->enterRule                               = enterRule;
 121         delboy->enterSubRule                    = enterSubRule;
 122         delboy->exitDecision                    = exitDecision;
 123         delboy->exitRule                                = exitRule;
 124         delboy->exitSubRule                             = exitSubRule;
 125         delboy->handshake                               = handshake;
 126         delboy->location                                = location;
 127         delboy->LT                                              = LT;
 128         delboy->LTT                                             = LTT;
 129         delboy->mark                                    = mark;
 130         delboy->nilNode                                 = nilNode;
 131         delboy->recognitionException    = recognitionException;
 132         delboy->rewind                                  = rewindMark;
 133         delboy->rewindLast                              = rewindLast;
 134         delboy->semanticPredicate               = semanticPredicate;
 135         delboy->setTokenBoundaries              = setTokenBoundaries;
 136         delboy->terminate                               = terminate;
 137         delboy->errorNode                               = errorNode;
 138
 139         delboy->PROTOCOL_VERSION                = 2;    // ANTLR 3.1 is at protocol version 2
 140
 141         delboy->port                                    = DEFAULT_DEBUGGER_PORT;
 142
 143         return delboy;
 144 }
 145
 146 pANTLR3_DEBUG_EVENT_LISTENER
 147 antlr3DebugListenerNewPort(ANTLR3_UINT32 port)
 148 {
 149         pANTLR3_DEBUG_EVENT_LISTENER    delboy;
 150
 151         delboy           = antlr3DebugListenerNew();
 152
 153         if      (delboy != NULL)
 154         {
 155                 delboy->port = port;
 156         }
 157
 158         return delboy;
 159 }
 160
 161 //--------------------------------------------------------------------------------
 162 // Support functions for sending stuff over the socket interface
 163 //
 164 static int
 165 sockSend(SOCKET sock, const char * ptr, int len)
 166 {
 167         int             sent;
 168         int             thisSend;
 169
 170         sent    = 0;
 171
 172         while   (sent < len)
 173         {
 174                 // Send as many bytes as we can
 175                 //
 176                 thisSend =      send(sock, ptr, len - sent, 0);
 177
 178                 // Check for errors and tell the user if we got one
 179                 //
 180                 if      (thisSend       == -1)
 181                 {
 182                         return  ANTLR3_FALSE;
 183                 }
 184
 185                 // Increment our offset by how many we were able to send
 186                 //
 187                 ptr                     += thisSend;
 188                 sent            += thisSend;
 189         }
 190         return  ANTLR3_TRUE;
 191 }
 192
 193 static  ANTLR3_BOOLEAN
 194 handshake                               (pANTLR3_DEBUG_EVENT_LISTENER delboy)
 195 {
 196         /// Connection structure with which to wait and accept a connection from
 197         /// a debugger.
 198         ///
 199         SOCKET                          serverSocket;
 200
 201         // Connection structures to deal with the client after we accept the connection
 202         // and the server while we accept a connection.
 203         //
 204         ANTLR3_SOCKADDRT        client;
 205         ANTLR3_SOCKADDRT        server;
 206
 207         // Buffer to construct our message in
 208         //
 209         char    message[256];
 210
 211         // Specifies the length of the connection structure to accept()
 212         // Windows use int, everyone else uses size_t
 213         //
 214         ANTLR3_SALENT                           sockaddr_len;
 215
 216         // Option holder for setsockopt()
 217         //
 218         int             optVal;
 219
 220         if      (delboy->initialized == ANTLR3_FALSE)
 221         {
 222                 // Windows requires us to initialize WinSock.
 223                 //
 224 #ifdef ANTLR3_WINDOWS
 225                 {
 226                         WORD            wVersionRequested;
 227                         WSADATA         wsaData;
 228                         int                     err;                    // Return code from WSAStartup
 229
 230                         // We must initialise the Windows socket system when the DLL is loaded.
 231                         // We are asking for Winsock 1.1 or better as we don't need anything
 232                         // too complicated for this.
 233                         //
 234                         wVersionRequested = MAKEWORD( 1, 1);
 235
 236                         err = WSAStartup( wVersionRequested, &wsaData );
 237
 238                         if ( err != 0 )
 239                         {
 240                                 // Tell the user that we could not find a usable
 241                                 // WinSock DLL
 242                                 //
 243                                 return FALSE;
 244                         }
 245                 }
 246 #endif
 247
 248                 // Create the server socket, we are the server because we just wait until
 249                 // a debugger connects to the port we are listening on.
 250                 //
 251                 serverSocket    = socket(AF_INET, SOCK_STREAM, 0);
 252
 253                 if      (serverSocket == INVALID_SOCKET)
 254                 {
 255                         return ANTLR3_FALSE;
 256                 }
 257
 258                 // Set the listening port
 259                 //
 260                 server.sin_port                 = htons((unsigned short)delboy->port);
 261                 server.sin_family               = AF_INET;
 262                 server.sin_addr.s_addr  = htonl (INADDR_ANY);
 263
 264                 // We could allow a rebind on the same addr/port pair I suppose, but
 265                 // I imagine that most people will just want to start debugging one parser at once.
 266                 // Maybe change this at some point, but rejecting the bind at this point will ensure
 267                 // that people realize they have left something running in the background.
 268                 //
 269                 if      (bind(serverSocket, (pANTLR3_SOCKADDRC)&server, sizeof(server)) == -1)
 270                 {
 271                         return ANTLR3_FALSE;
 272                 }
 273
 274                 // We have bound the socket to the port and address so we now ask the TCP subsystem
 275                 // to start listening on that address/port
 276                 //
 277                 if      (listen(serverSocket, 1) == -1)
 278                 {
 279                         // Some error, just fail
 280                         //
 281                         return  ANTLR3_FALSE;
 282                 }
 283
 284                 // Now we can try to accept a connection on the port
 285                 //
 286                 sockaddr_len    = sizeof(client);
 287                 delboy->socket  = accept(serverSocket, (pANTLR3_SOCKADDRC)&client, &sockaddr_len);
 288
 289                 // Having accepted a connection, we can stop listening and close down the socket
 290                 //
 291                 shutdown                (serverSocket, 0x02);
 292                 ANTLR3_CLOSESOCKET              (serverSocket);
 293
 294                 if      (delboy->socket == -1)
 295                 {
 296                         return ANTLR3_FALSE;
 297                 }
 298
 299                 // Disable Nagle as this is essentially a chat exchange
 300                 //
 301                 optVal  = 1;
 302                 setsockopt(delboy->socket, SOL_SOCKET, TCP_NODELAY, (const void *)&optVal, sizeof(optVal));
 303
 304         }
 305
 306         // We now have a good socket connection with the debugging client, so we
 307         // send it the protocol version we are using and what the name of the grammar
 308         // is that we represent.
 309         //
 310         sprintf         (message, "ANTLR %d\n", delboy->PROTOCOL_VERSION);
 311         sockSend        (delboy->socket, message, (int)strlen(message));
 312         sprintf         (message, "grammar \"%s\n", delboy->grammarFileName->chars);
 313         sockSend        (delboy->socket, message, (int)strlen(message));
 314         ack                     (delboy);
 315
 316         delboy->initialized = ANTLR3_TRUE;
 317
 318         return  ANTLR3_TRUE;
 319 }
 320
 321 // Send the supplied text and wait for an ack from the client
 322 static void
 323 transmit(pANTLR3_DEBUG_EVENT_LISTENER delboy, const char * ptr)
 324 {
 325         sockSend(delboy->socket, ptr, (int)strlen(ptr));
 326         ack(delboy);
 327 }
 328
 329 static  void
 330 ack                                             (pANTLR3_DEBUG_EVENT_LISTENER delboy)
 331 {
 332         // Local buffer to read the next character in to
 333         //
 334         char    buffer;
 335         int             rCount;
 336
 337         // Ack terminates in a line feed, so we just wait for
 338         // one of those. Speed is not of the essence so we don't need
 339         // to buffer the input or anything.
 340         //
 341         do
 342         {
 343                 rCount = recv(delboy->socket, &buffer, 1, 0);
 344         }
 345         while   (rCount == 1 && buffer != '\n');
 346
 347         // If the socket ws closed on us, then we will get an error or
 348         // (with a graceful close), 0. We can assume the the debugger stopped for some reason
 349         // (such as Java crashing again). Therefore we just exit the program
 350         // completely if we don't get the terminating '\n' for the ack.
 351         //
 352         if      (rCount != 1)
 353         {
 354                 ANTLR3_PRINTF("Exiting debugger as remote client closed the socket\n");
 355                 ANTLR3_PRINTF("Received char count was %d, and last char received was %02X\n", rCount, buffer);
 356                 exit(0);
 357         }
 358 }
 359
 360 // Given a buffer string and a source string, serialize the
 361 // text, escaping any newlines and linefeeds. We have no need
 362 // for speed here, this is the debugger.
 363 //
 364 void
 365 serializeText(pANTLR3_STRING buffer, pANTLR3_STRING text)
 366 {
 367         ANTLR3_UINT32   c;
 368         ANTLR3_UCHAR    character;
 369
 370         // strings lead in with a "
 371         //
 372         buffer->append(buffer, " \"");
 373
 374         if      (text == NULL)
 375         {
 376                 return;
 377         }
 378
 379         // Now we replace linefeeds, newlines and the escape
 380         // leadin character '%' with their hex equivalents
 381         // prefixed by '%'
 382         //
 383         for     (c = 0; c < text->len; c++)
 384         {
 385                 switch  (character = text->charAt(text, c))
 386                 {
 387                         case    '\n':
 388
 389                                 buffer->append(buffer, "%0A");
 390                                 break;
 391
 392                         case    '\r':
 393
 394                                 buffer->append(buffer, "%0D");
 395                                 break;
 396
 397                         case    '\\':
 398
 399                                 buffer->append(buffer, "%25");
 400                                 break;
 401
 402                                 // Other characters: The Song Remains the Same.
 403                                 //
 404                         default:
 405
 406                                 buffer->addc(buffer, character);
 407                                 break;
 408                 }
 409         }
 410 }
 411
 412 // Given a token, create a stringified version of it, in the supplied
 413 // buffer. We create a string for this in the debug 'object', if there
 414 // is not one there already, and then reuse it here if asked to do this
 415 // again.
 416 //
 417 pANTLR3_STRING
 418 serializeToken(pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_COMMON_TOKEN t)
 419 {
 420         // Do we already have a serialization buffer?
 421         //
 422         if      (delboy->tokenString == NULL)
 423         {
 424                 // No, so create one, using the string factory that
 425                 // the grammar name used, which is guaranteed to exist.
 426                 // 64 bytes will do us here for starters.
 427                 //
 428                 delboy->tokenString = delboy->grammarFileName->factory->newSize(delboy->grammarFileName->factory, 64);
 429         }
 430
 431         // Empty string
 432         //
 433         delboy->tokenString->set(delboy->tokenString, (const char *)"");
 434
 435         // Now we serialize the elements of the token.Note that the debugger only
 436         // uses 32 bits.
 437         //
 438         delboy->tokenString->addi(delboy->tokenString, (ANTLR3_INT32)(t->getTokenIndex(t)));
 439         delboy->tokenString->addc(delboy->tokenString, ' ');
 440         delboy->tokenString->addi(delboy->tokenString, (ANTLR3_INT32)(t->getType(t)));
 441         delboy->tokenString->addc(delboy->tokenString, ' ');
 442         delboy->tokenString->addi(delboy->tokenString, (ANTLR3_INT32)(t->getChannel(t)));
 443         delboy->tokenString->addc(delboy->tokenString, ' ');
 444         delboy->tokenString->addi(delboy->tokenString, (ANTLR3_INT32)(t->getLine(t)));
 445         delboy->tokenString->addc(delboy->tokenString, ' ');
 446         delboy->tokenString->addi(delboy->tokenString, (ANTLR3_INT32)(t->getCharPositionInLine(t)));
 447
 448         // Now send the text that the token represents.
 449         //
 450         serializeText(delboy->tokenString, t->getText(t));
 451
 452         // Finally, as the debugger is a Java program it will expect to get UTF-8
 453         // encoded strings. We don't use UTF-8 internally to the C runtime, so we
 454         // must force encode it. We have a method to do this in the string class, but
 455         // it returns malloc space that we must free afterwards.
 456         //
 457         return delboy->tokenString->toUTF8(delboy->tokenString);
 458 }
 459
 460 // Given a tree node, create a stringified version of it in the supplied
 461 // buffer.
 462 //
 463 pANTLR3_STRING
 464 serializeNode(pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE node)
 465 {
 466         pANTLR3_COMMON_TOKEN    token;
 467
 468
 469         // Do we already have a serialization buffer?
 470         //
 471         if      (delboy->tokenString == NULL)
 472         {
 473                 // No, so create one, using the string factory that
 474                 // the grammar name used, which is guaranteed to exist.
 475                 // 64 bytes will do us here for starters.
 476                 //
 477                 delboy->tokenString = delboy->grammarFileName->factory->newSize(delboy->grammarFileName->factory, 64);
 478         }
 479
 480         // Empty string
 481         //
 482         delboy->tokenString->set(delboy->tokenString, (const char *)"");
 483
 484         // Protect against bugs/errors etc
 485         //
 486         if      (node == NULL)
 487         {
 488                 return delboy->tokenString;
 489         }
 490
 491         // Now we serialize the elements of the node.Note that the debugger only
 492         // uses 32 bits.
 493         //
 494         delboy->tokenString->addc(delboy->tokenString, ' ');
 495
 496         // Adaptor ID
 497         //
 498         delboy->tokenString->addi(delboy->tokenString, delboy->adaptor->getUniqueID(delboy->adaptor, node));
 499         delboy->tokenString->addc(delboy->tokenString, ' ');
 500
 501         // Type of the current token (which may be imaginary)
 502         //
 503         delboy->tokenString->addi(delboy->tokenString, delboy->adaptor->getType(delboy->adaptor, node));
 504
 505         // See if we have an actual token or just an imaginary
 506         //
 507         token   = delboy->adaptor->getToken(delboy->adaptor, node);
 508
 509         delboy->tokenString->addc(delboy->tokenString, ' ');
 510         if      (token != NULL)
 511         {
 512                 // Real token
 513                 //
 514                 delboy->tokenString->addi(delboy->tokenString, (ANTLR3_INT32)(token->getLine(token)));
 515                 delboy->tokenString->addc(delboy->tokenString, ' ');
 516                 delboy->tokenString->addi(delboy->tokenString, (ANTLR3_INT32)(token->getCharPositionInLine(token)));
 517         }
 518         else
 519         {
 520                 // Imaginary tokens have no location
 521                 //
 522                 delboy->tokenString->addi(delboy->tokenString, -1);
 523                 delboy->tokenString->addc(delboy->tokenString, ' ');
 524                 delboy->tokenString->addi(delboy->tokenString, -1);
 525         }
 526
 527         // Start Index of the node
 528         //
 529         delboy->tokenString->addc(delboy->tokenString, ' ');
 530         delboy->tokenString->addi(delboy->tokenString, (ANTLR3_UINT32)(delboy->adaptor->getTokenStartIndex(delboy->adaptor, node)));
 531
 532         // Now send the text that the node represents.
 533         //
 534         serializeText(delboy->tokenString, delboy->adaptor->getText(delboy->adaptor, node));
 535
 536         // Finally, as the debugger is a Java program it will expect to get UTF-8
 537         // encoded strings. We don't use UTF-8 internally to the C runtime, so we
 538         // must force encode it. We have a method to do this in the string class, but
 539         // there is no utf8 string implementation as of yet
 540         //
 541         return delboy->tokenString->toUTF8(delboy->tokenString);
 542 }
 543
 544 //------------------------------------------------------------------------------------------------------------------
 545 // EVENTS
 546 //
 547 static  void
 548 enterRule                               (pANTLR3_DEBUG_EVENT_LISTENER delboy, const char * grammarFileName, const char * ruleName)
 549 {
 550         char    buffer[512];
 551
 552         // Create the message (speed is not of the essence)
 553         //
 554         sprintf(buffer, "enterRule %s %s\n", grammarFileName, ruleName);
 555         transmit(delboy, buffer);
 556 }
 557
 558 static  void
 559 enterAlt                                (pANTLR3_DEBUG_EVENT_LISTENER delboy, int alt)
 560 {
 561         char    buffer[512];
 562
 563         // Create the message (speed is not of the essence)
 564         //
 565         sprintf(buffer, "enterAlt %d\n", alt);
 566         transmit(delboy, buffer);
 567 }
 568
 569 static  void
 570 exitRule                                (pANTLR3_DEBUG_EVENT_LISTENER delboy, const char * grammarFileName, const char * ruleName)
 571 {
 572         char    buffer[512];
 573
 574         // Create the message (speed is not of the essence)
 575         //
 576         sprintf(buffer, "enterRule %s %s\n", grammarFileName, ruleName);
 577         transmit(delboy, buffer);
 578 }
 579
 580 static  void
 581 enterSubRule                    (pANTLR3_DEBUG_EVENT_LISTENER delboy, int decisionNumber)
 582 {
 583         char    buffer[512];
 584
 585         // Create the message (speed is not of the essence)
 586         //
 587         sprintf(buffer, "enterSubRule %d\n", decisionNumber);
 588         transmit(delboy, buffer);
 589 }
 590
 591 static  void
 592 exitSubRule                             (pANTLR3_DEBUG_EVENT_LISTENER delboy, int decisionNumber)
 593 {
 594         char    buffer[512];
 595
 596         // Create the message (speed is not of the essence)
 597         //
 598         sprintf(buffer, "exitSubRule %d\n", decisionNumber);
 599         transmit(delboy, buffer);
 600 }
 601
 602 static  void
 603 enterDecision                   (pANTLR3_DEBUG_EVENT_LISTENER delboy, int decisionNumber)
 604 {
 605         char    buffer[512];
 606
 607         // Create the message (speed is not of the essence)
 608         //
 609         sprintf(buffer, "enterDecision %d\n", decisionNumber);
 610         transmit(delboy, buffer);
 611
 612 }
 613
 614 static  void
 615 exitDecision                    (pANTLR3_DEBUG_EVENT_LISTENER delboy, int decisionNumber)
 616 {
 617         char    buffer[512];
 618
 619         // Create the message (speed is not of the essence)
 620         //
 621         sprintf(buffer, "exitDecision %d\n", decisionNumber);
 622         transmit(delboy, buffer);
 623 }
 624
 625 static  void
 626 consumeToken                    (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_COMMON_TOKEN t)
 627 {
 628         pANTLR3_STRING msg;
 629
 630         // Create the serialized token
 631         //
 632         msg = serializeToken(delboy, t);
 633
 634         // Insert the debug event indicator
 635         //
 636         msg->insert8(msg, 0, "consumeToken ");
 637
 638         msg->addc(msg, '\n');
 639
 640         // Transmit the message and wait for ack
 641         //
 642         transmit(delboy, (const char *)(msg->chars));
 643 }
 644
 645 static  void
 646 consumeHiddenToken              (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_COMMON_TOKEN t)
 647 {
 648         pANTLR3_STRING msg;
 649
 650         // Create the serialized token
 651         //
 652         msg = serializeToken(delboy, t);
 653
 654         // Insert the debug event indicator
 655         //
 656         msg->insert8(msg, 0, "consumeHiddenToken ");
 657
 658         msg->addc(msg, '\n');
 659
 660         // Transmit the message and wait for ack
 661         //
 662         transmit(delboy, (const char *)(msg->chars));
 663 }
 664
 665 // Looking at the next token event.
 666 //
 667 static  void
 668 LT                                              (pANTLR3_DEBUG_EVENT_LISTENER delboy, int i, pANTLR3_COMMON_TOKEN t)
 669 {
 670         pANTLR3_STRING msg;
 671
 672         if      (t != NULL)
 673         {
 674                 // Create the serialized token
 675                 //
 676                 msg = serializeToken(delboy, t);
 677
 678                 // Insert the index parameter
 679                 //
 680                 msg->insert8(msg, 0, " ");
 681                 msg->inserti(msg, 0, i);
 682
 683                 // Insert the debug event indicator
 684                 //
 685                 msg->insert8(msg, 0, "LT ");
 686
 687                 msg->addc(msg, '\n');
 688
 689                 // Transmit the message and wait for ack
 690                 //
 691                 transmit(delboy, (const char *)(msg->chars));
 692         }
 693 }
 694
 695 static  void
 696 mark                                    (pANTLR3_DEBUG_EVENT_LISTENER delboy, ANTLR3_MARKER marker)
 697 {
 698         char buffer[128];
 699
 700         sprintf(buffer, "mark %d\n", (ANTLR3_UINT32)(marker & 0xFFFFFFFF));
 701
 702         // Transmit the message and wait for ack
 703         //
 704         transmit(delboy, buffer);
 705 }
 706
 707 static  void
 708 rewindMark                                      (pANTLR3_DEBUG_EVENT_LISTENER delboy, ANTLR3_MARKER marker)
 709 {
 710         char buffer[128];
 711
 712         sprintf(buffer, "rewind %d\n", (ANTLR3_UINT32)(marker & 0xFFFFFFFF));
 713
 714         // Transmit the message and wait for ack
 715         //
 716         transmit(delboy, buffer);
 717
 718 }
 719
 720 static  void
 721 rewindLast                              (pANTLR3_DEBUG_EVENT_LISTENER delboy)
 722 {
 723         transmit(delboy, (const char *)"rewind\n");
 724 }
 725
 726 static  void
 727 beginBacktrack                  (pANTLR3_DEBUG_EVENT_LISTENER delboy, int level)
 728 {
 729         char buffer[128];
 730
 731         sprintf(buffer, "beginBacktrack %d\n", (ANTLR3_UINT32)(level & 0xFFFFFFFF));
 732
 733         // Transmit the message and wait for ack
 734         //
 735         transmit(delboy, buffer);
 736 }
 737
 738 static  void
 739 endBacktrack                    (pANTLR3_DEBUG_EVENT_LISTENER delboy, int level, ANTLR3_BOOLEAN successful)
 740 {
 741         char buffer[128];
 742
 743         sprintf(buffer, "endBacktrack %d %d\n", level, successful);
 744
 745         // Transmit the message and wait for ack
 746         //
 747         transmit(delboy, buffer);
 748 }
 749
 750 static  void
 751 location                                (pANTLR3_DEBUG_EVENT_LISTENER delboy, int line, int pos)
 752 {
 753         char buffer[128];
 754
 755         sprintf(buffer, "location %d %d\n", line, pos);
 756
 757         // Transmit the message and wait for ack
 758         //
 759         transmit(delboy, buffer);
 760 }
 761
 762 static  void
 763 recognitionException    (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_EXCEPTION e)
 764 {
 765         char    buffer[256];
 766
 767         sprintf(buffer, "exception %s %d %d %d\n", (char *)(e->name), (ANTLR3_INT32)(e->index), e->line, e->charPositionInLine);
 768
 769         // Transmit the message and wait for ack
 770         //
 771         transmit(delboy, buffer);
 772 }
 773
 774 static  void
 775 beginResync                             (pANTLR3_DEBUG_EVENT_LISTENER delboy)
 776 {
 777         transmit(delboy, (const char *)"beginResync\n");
 778 }
 779
 780 static  void
 781 endResync                               (pANTLR3_DEBUG_EVENT_LISTENER delboy)
 782 {
 783         transmit(delboy, (const char *)"endResync\n");
 784 }
 785
 786 static  void
 787 semanticPredicate               (pANTLR3_DEBUG_EVENT_LISTENER delboy, ANTLR3_BOOLEAN result, const char * predicate)
 788 {
 789         unsigned char * buffer;
 790         unsigned char * out;
 791
 792         if      (predicate != NULL)
 793         {
 794                 buffer  = (unsigned char *)ANTLR3_MALLOC(64 + 2*strlen(predicate));
 795
 796                 if      (buffer != NULL)
 797                 {
 798                         out = buffer + sprintf((char *)buffer, "semanticPredicate %s ", result == ANTLR3_TRUE ? "true" : "false");
 799
 800                         while (*predicate != '\0')
 801                         {
 802                                 switch(*predicate)
 803                                 {
 804                                         case    '\n':
 805
 806                                                 *out++  = '%';
 807                                                 *out++  = '0';
 808                                                 *out++  = 'A';
 809                                                 break;
 810
 811                                         case    '\r':
 812
 813                                                 *out++  = '%';
 814                                                 *out++  = '0';
 815                                                 *out++  = 'D';
 816                                                 break;
 817
 818                                         case    '%':
 819
 820                                                 *out++  = '%';
 821                                                 *out++  = '0';
 822                                                 *out++  = 'D';
 823                                                 break;
 824
 825
 826                                         default:
 827
 828                                                 *out++  = *predicate;
 829                                                 break;
 830                                 }
 831
 832                                 predicate++;
 833                         }
 834                         *out++  = '\n';
 835                         *out++  = '\0';
 836                 }
 837
 838                 // Send it and wait for the ack
 839                 //
 840                 transmit(delboy, (const char *)buffer);
 841         }
 842 }
 843
 844 #ifdef ANTLR3_WINDOWS
 845 #pragma warning (push)
 846 #pragma warning (disable : 4100)
 847 #endif
 848
 849 static  void
 850 commence                                (pANTLR3_DEBUG_EVENT_LISTENER delboy)
 851 {
 852         // Nothing to see here
 853         //
 854 }
 855
 856 #ifdef ANTLR3_WINDOWS
 857 #pragma warning (pop)
 858 #endif
 859
 860 static  void
 861 terminate                               (pANTLR3_DEBUG_EVENT_LISTENER delboy)
 862 {
 863         // Terminate sequence
 864         //
 865         sockSend(delboy->socket, "terminate\n", 10);            // Send out the command
 866 }
 867
 868 //----------------------------------------------------------------
 869 // Tree parsing events
 870 //
 871 static  void
 872 consumeNode                             (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t)
 873 {
 874         pANTLR3_STRING  buffer;
 875
 876         buffer = serializeNode  (delboy, t);
 877
 878         // Now prepend the command
 879         //
 880         buffer->insert8 (buffer, 0, "consumeNode ");
 881         buffer->addc    (buffer, '\n');
 882
 883         // Send to the debugger and wait for the ack
 884         //
 885         transmit                (delboy, (const char *)(delboy->tokenString->toUTF8(delboy->tokenString)->chars));
 886 }
 887
 888 static  void
 889 LTT                                             (pANTLR3_DEBUG_EVENT_LISTENER delboy, int i, pANTLR3_BASE_TREE t)
 890 {
 891         pANTLR3_STRING  buffer;
 892
 893         buffer = serializeNode  (delboy, t);
 894
 895         // Now prepend the command
 896         //
 897         buffer->insert8 (buffer, 0, " ");
 898         buffer->inserti (buffer, 0, i);
 899         buffer->insert8 (buffer, 0, "LN ");
 900         buffer->addc    (buffer, '\n');
 901
 902         // Send to the debugger and wait for the ack
 903         //
 904         transmit                (delboy, (const char *)(delboy->tokenString->toUTF8(delboy->tokenString)->chars));
 905 }
 906
 907 static  void
 908 nilNode                                 (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t)
 909 {
 910         char    buffer[128];
 911         sprintf(buffer, "nilNode %d\n", delboy->adaptor->getUniqueID(delboy->adaptor, t));
 912         transmit(delboy, buffer);
 913 }
 914
 915 static  void
 916 createNode                              (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t)
 917 {
 918         // Do we already have a serialization buffer?
 919         //
 920         if      (delboy->tokenString == NULL)
 921         {
 922                 // No, so create one, using the string factory that
 923                 // the grammar name used, which is guaranteed to exist.
 924                 // 64 bytes will do us here for starters.
 925                 //
 926                 delboy->tokenString = delboy->grammarFileName->factory->newSize(delboy->grammarFileName->factory, 64);
 927         }
 928
 929         // Empty string
 930         //
 931         delboy->tokenString->set8(delboy->tokenString, (const char *)"createNodeFromTokenElements ");
 932
 933         // Now we serialize the elements of the node.Note that the debugger only
 934         // uses 32 bits.
 935         //
 936         // Adaptor ID
 937         //
 938         delboy->tokenString->addi(delboy->tokenString, delboy->adaptor->getUniqueID(delboy->adaptor, t));
 939         delboy->tokenString->addc(delboy->tokenString, ' ');
 940
 941         // Type of the current token (which may be imaginary)
 942         //
 943         delboy->tokenString->addi(delboy->tokenString, delboy->adaptor->getType(delboy->adaptor, t));
 944
 945         // The text that this node represents
 946         //
 947         serializeText(delboy->tokenString, delboy->adaptor->getText(delboy->adaptor, t));
 948         delboy->tokenString->addc(delboy->tokenString, '\n');
 949
 950         // Finally, as the debugger is a Java program it will expect to get UTF-8
 951         // encoded strings. We don't use UTF-8 internally to the C runtime, so we
 952         // must force encode it. We have a method to do this in the string class, but
 953         // there is no utf8 string implementation as of yet
 954         //
 955         transmit(delboy, (const char *)(delboy->tokenString->toUTF8(delboy->tokenString)->chars));
 956
 957 }
 958 static void
 959 errorNode                               (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t)
 960 {
 961         // Do we already have a serialization buffer?
 962         //
 963         if      (delboy->tokenString == NULL)
 964         {
 965                 // No, so create one, using the string factory that
 966                 // the grammar name used, which is guaranteed to exist.
 967                 // 64 bytes will do us here for starters.
 968                 //
 969                 delboy->tokenString = delboy->grammarFileName->factory->newSize(delboy->grammarFileName->factory, 64);
 970         }
 971
 972         // Empty string
 973         //
 974         delboy->tokenString->set8(delboy->tokenString, (const char *)"errorNode ");
 975
 976         // Now we serialize the elements of the node.Note that the debugger only
 977         // uses 32 bits.
 978         //
 979         // Adaptor ID
 980         //
 981         delboy->tokenString->addi(delboy->tokenString, delboy->adaptor->getUniqueID(delboy->adaptor, t));
 982         delboy->tokenString->addc(delboy->tokenString, ' ');
 983
 984         // Type of the current token (which is an error)
 985         //
 986         delboy->tokenString->addi(delboy->tokenString, ANTLR3_TOKEN_INVALID);
 987
 988         // The text that this node represents
 989         //
 990         serializeText(delboy->tokenString, delboy->adaptor->getText(delboy->adaptor, t));
 991         delboy->tokenString->addc(delboy->tokenString, '\n');
 992
 993         // Finally, as the debugger is a Java program it will expect to get UTF-8
 994         // encoded strings. We don't use UTF-8 internally to the C runtime, so we
 995         // must force encode it. We have a method to do this in the string class, but
 996         // there is no utf8 string implementation as of yet
 997         //
 998         transmit(delboy, (const char *)(delboy->tokenString->toUTF8(delboy->tokenString)->chars));
 999
1000 }
1001
1002 static  void
1003 createNodeTok                   (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE node, pANTLR3_COMMON_TOKEN token)
1004 {
1005         char    buffer[128];
1006
1007         sprintf(buffer, "createNode %d %d\n",   delboy->adaptor->getUniqueID(delboy->adaptor, node), (ANTLR3_UINT32)token->getTokenIndex(token));
1008
1009         transmit(delboy, buffer);
1010 }
1011
1012 static  void
1013 becomeRoot                              (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE newRoot, pANTLR3_BASE_TREE oldRoot)
1014 {
1015         char    buffer[128];
1016
1017         sprintf(buffer, "becomeRoot %d %d\n",   delboy->adaptor->getUniqueID(delboy->adaptor, newRoot),
1018                                                                                         delboy->adaptor->getUniqueID(delboy->adaptor, oldRoot)
1019                                                                                         );
1020         transmit(delboy, buffer);
1021 }
1022
1023
1024 static  void
1025 addChild                                (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE root, pANTLR3_BASE_TREE child)
1026 {
1027         char    buffer[128];
1028
1029         sprintf(buffer, "addChild %d %d\n",             delboy->adaptor->getUniqueID(delboy->adaptor, root),
1030                                                                                         delboy->adaptor->getUniqueID(delboy->adaptor, child)
1031                                                                                         );
1032         transmit(delboy, buffer);
1033 }
1034
1035 static  void
1036 setTokenBoundaries              (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t, ANTLR3_MARKER tokenStartIndex, ANTLR3_MARKER tokenStopIndex)
1037 {
1038         char    buffer[128];
1039
1040         sprintf(buffer, "becomeRoot %d %d %d\n",        delboy->adaptor->getUniqueID(delboy->adaptor, t),
1041                                                                                                 (ANTLR3_UINT32)tokenStartIndex,
1042                                                                                                 (ANTLR3_UINT32)tokenStopIndex
1043                                                                                         );
1044         transmit(delboy, buffer);
1045 }
1046 #endif
1047