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

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