--- /dev/null
+/// \file\r
+/// Provides the debugging functions invoked by a recognizer\r
+/// built using the debug generator mode of the antlr tool.\r
+/// See antlr3debugeventlistener.h for documentation.\r
+///\r
+\r
+// [The "BSD licence"]\r
+// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC\r
+// http://www.temporal-wave.com\r
+// http://www.linkedin.com/in/jimidle\r
+//\r
+// All rights reserved.\r
+//\r
+// Redistribution and use in source and binary forms, with or without\r
+// modification, are permitted provided that the following conditions\r
+// are met:\r
+// 1. Redistributions of source code must retain the above copyright\r
+// notice, this list of conditions and the following disclaimer.\r
+// 2. Redistributions in binary form must reproduce the above copyright\r
+// notice, this list of conditions and the following disclaimer in the\r
+// documentation and/or other materials provided with the distribution.\r
+// 3. The name of the author may not be used to endorse or promote products\r
+// derived from this software without specific prior written permission.\r
+//\r
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\r
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\r
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\r
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\r
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\r
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\r
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+\r
+#include <antlr3.h>\r
+\r
+// Not everyone wishes to include the debugger stuff in their final deployment because\r
+// it will then rely on being linked with the socket libraries. Hence if the programmer turns\r
+// off the debugging, we do some dummy stuff that satifies compilers etc but means there is\r
+// no debugger and no reliance on the socket librarires. If you set this flag, then using the -debug\r
+// option to generate your code will produce code that just crashes, but then I presme you are smart\r
+// enough to realize that building the libraries without debugger support means you can't call the\r
+// debugger ;-)\r
+// \r
+#ifdef ANTLR3_NODEBUGGER\r
+ANTLR3_API pANTLR3_DEBUG_EVENT_LISTENER\r
+antlr3DebugListenerNew()\r
+{\r
+ ANTLR3_PRINTF("C runtime was compiled without debugger support. This program will crash!!");\r
+ return NULL;\r
+}\r
+#else\r
+\r
+static ANTLR3_BOOLEAN handshake (pANTLR3_DEBUG_EVENT_LISTENER delboy);\r
+static void enterRule (pANTLR3_DEBUG_EVENT_LISTENER delboy, const char * grammarFileName, const char * ruleName);\r
+static void enterAlt (pANTLR3_DEBUG_EVENT_LISTENER delboy, int alt);\r
+static void exitRule (pANTLR3_DEBUG_EVENT_LISTENER delboy, const char * grammarFileName, const char * ruleName);\r
+static void enterSubRule (pANTLR3_DEBUG_EVENT_LISTENER delboy, int decisionNumber);\r
+static void exitSubRule (pANTLR3_DEBUG_EVENT_LISTENER delboy, int decisionNumber);\r
+static void enterDecision (pANTLR3_DEBUG_EVENT_LISTENER delboy, int decisionNumber);\r
+static void exitDecision (pANTLR3_DEBUG_EVENT_LISTENER delboy, int decisionNumber);\r
+static void consumeToken (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_COMMON_TOKEN t);\r
+static void consumeHiddenToken (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_COMMON_TOKEN t);\r
+static void LT (pANTLR3_DEBUG_EVENT_LISTENER delboy, int i, pANTLR3_COMMON_TOKEN t);\r
+static void mark (pANTLR3_DEBUG_EVENT_LISTENER delboy, ANTLR3_MARKER marker);\r
+static void rewindMark (pANTLR3_DEBUG_EVENT_LISTENER delboy, ANTLR3_MARKER marker);\r
+static void rewindLast (pANTLR3_DEBUG_EVENT_LISTENER delboy);\r
+static void beginBacktrack (pANTLR3_DEBUG_EVENT_LISTENER delboy, int level);\r
+static void endBacktrack (pANTLR3_DEBUG_EVENT_LISTENER delboy, int level, ANTLR3_BOOLEAN successful);\r
+static void location (pANTLR3_DEBUG_EVENT_LISTENER delboy, int line, int pos);\r
+static void recognitionException (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_EXCEPTION e);\r
+static void beginResync (pANTLR3_DEBUG_EVENT_LISTENER delboy);\r
+static void endResync (pANTLR3_DEBUG_EVENT_LISTENER delboy);\r
+static void semanticPredicate (pANTLR3_DEBUG_EVENT_LISTENER delboy, ANTLR3_BOOLEAN result, const char * predicate);\r
+static void commence (pANTLR3_DEBUG_EVENT_LISTENER delboy);\r
+static void terminate (pANTLR3_DEBUG_EVENT_LISTENER delboy);\r
+static void consumeNode (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t);\r
+static void LTT (pANTLR3_DEBUG_EVENT_LISTENER delboy, int i, pANTLR3_BASE_TREE t);\r
+static void nilNode (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t);\r
+static void errorNode (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t);\r
+static void createNode (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t);\r
+static void createNodeTok (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE node, pANTLR3_COMMON_TOKEN token);\r
+static void becomeRoot (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE newRoot, pANTLR3_BASE_TREE oldRoot);\r
+static void addChild (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE root, pANTLR3_BASE_TREE child);\r
+static void setTokenBoundaries (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t, ANTLR3_MARKER tokenStartIndex, ANTLR3_MARKER tokenStopIndex);\r
+static void ack (pANTLR3_DEBUG_EVENT_LISTENER delboy);\r
+\r
+/// Create and initialize a new debug event listener that can be connected to\r
+/// by ANTLRWorks and any other debugger via a socket.\r
+///\r
+ANTLR3_API pANTLR3_DEBUG_EVENT_LISTENER\r
+antlr3DebugListenerNew()\r
+{\r
+ pANTLR3_DEBUG_EVENT_LISTENER delboy;\r
+\r
+ delboy = ANTLR3_CALLOC(1, sizeof(ANTLR3_DEBUG_EVENT_LISTENER));\r
+\r
+ if (delboy == NULL)\r
+ {\r
+ return NULL;\r
+ }\r
+\r
+ // Initialize the API\r
+ //\r
+ delboy->addChild = addChild;\r
+ delboy->becomeRoot = becomeRoot;\r
+ delboy->beginBacktrack = beginBacktrack;\r
+ delboy->beginResync = beginResync;\r
+ delboy->commence = commence;\r
+ delboy->consumeHiddenToken = consumeHiddenToken;\r
+ delboy->consumeNode = consumeNode;\r
+ delboy->consumeToken = consumeToken;\r
+ delboy->createNode = createNode;\r
+ delboy->createNodeTok = createNodeTok;\r
+ delboy->endBacktrack = endBacktrack;\r
+ delboy->endResync = endResync;\r
+ delboy->enterAlt = enterAlt;\r
+ delboy->enterDecision = enterDecision;\r
+ delboy->enterRule = enterRule;\r
+ delboy->enterSubRule = enterSubRule;\r
+ delboy->exitDecision = exitDecision;\r
+ delboy->exitRule = exitRule;\r
+ delboy->exitSubRule = exitSubRule;\r
+ delboy->handshake = handshake;\r
+ delboy->location = location;\r
+ delboy->LT = LT;\r
+ delboy->LTT = LTT;\r
+ delboy->mark = mark;\r
+ delboy->nilNode = nilNode;\r
+ delboy->recognitionException = recognitionException;\r
+ delboy->rewind = rewindMark;\r
+ delboy->rewindLast = rewindLast;\r
+ delboy->semanticPredicate = semanticPredicate;\r
+ delboy->setTokenBoundaries = setTokenBoundaries;\r
+ delboy->terminate = terminate;\r
+ delboy->errorNode = errorNode;\r
+\r
+ delboy->PROTOCOL_VERSION = 2; // ANTLR 3.1 is at protocol version 2\r
+\r
+ delboy->port = DEFAULT_DEBUGGER_PORT;\r
+\r
+ return delboy;\r
+}\r
+\r
+pANTLR3_DEBUG_EVENT_LISTENER\r
+antlr3DebugListenerNewPort(ANTLR3_UINT32 port)\r
+{\r
+ pANTLR3_DEBUG_EVENT_LISTENER delboy;\r
+\r
+ delboy = antlr3DebugListenerNew();\r
+\r
+ if (delboy != NULL)\r
+ {\r
+ delboy->port = port;\r
+ }\r
+\r
+ return delboy;\r
+}\r
+\r
+//--------------------------------------------------------------------------------\r
+// Support functions for sending stuff over the socket interface\r
+//\r
+static int \r
+sockSend(SOCKET sock, const char * ptr, int len)\r
+{\r
+ int sent;\r
+ int thisSend;\r
+\r
+ sent = 0;\r
+ \r
+ while (sent < len)\r
+ {\r
+ // Send as many bytes as we can\r
+ //\r
+ thisSend = send(sock, ptr, len - sent, 0);\r
+\r
+ // Check for errors and tell the user if we got one\r
+ //\r
+ if (thisSend == -1)\r
+ {\r
+ return ANTLR3_FALSE;\r
+ }\r
+\r
+ // Increment our offset by how many we were able to send\r
+ //\r
+ ptr += thisSend;\r
+ sent += thisSend;\r
+ }\r
+ return ANTLR3_TRUE;\r
+}\r
+\r
+static ANTLR3_BOOLEAN \r
+handshake (pANTLR3_DEBUG_EVENT_LISTENER delboy)\r
+{\r
+ /// Connection structure with which to wait and accept a connection from\r
+ /// a debugger.\r
+ ///\r
+ SOCKET serverSocket;\r
+\r
+ // Connection structures to deal with the client after we accept the connection\r
+ // and the server while we accept a connection.\r
+ //\r
+ ANTLR3_SOCKADDRT client;\r
+ ANTLR3_SOCKADDRT server;\r
+\r
+ // Buffer to construct our message in\r
+ //\r
+ char message[256];\r
+\r
+ // Specifies the length of the connection structure to accept()\r
+ // Windows use int, everyone else uses size_t\r
+ //\r
+ ANTLR3_SALENT sockaddr_len;\r
+\r
+ // Option holder for setsockopt()\r
+ //\r
+ int optVal;\r
+\r
+ if (delboy->initialized == ANTLR3_FALSE)\r
+ {\r
+ // Windows requires us to initialize WinSock.\r
+ //\r
+#ifdef ANTLR3_WINDOWS\r
+ {\r
+ WORD wVersionRequested;\r
+ WSADATA wsaData;\r
+ int err; // Return code from WSAStartup\r
+\r
+ // We must initialise the Windows socket system when the DLL is loaded.\r
+ // We are asking for Winsock 1.1 or better as we don't need anything\r
+ // too complicated for this.\r
+ //\r
+ wVersionRequested = MAKEWORD( 1, 1);\r
+\r
+ err = WSAStartup( wVersionRequested, &wsaData );\r
+\r
+ if ( err != 0 ) \r
+ {\r
+ // Tell the user that we could not find a usable\r
+ // WinSock DLL\r
+ //\r
+ return FALSE;\r
+ }\r
+ }\r
+#endif\r
+\r
+ // Create the server socket, we are the server because we just wait until\r
+ // a debugger connects to the port we are listening on.\r
+ //\r
+ serverSocket = socket(AF_INET, SOCK_STREAM, 0);\r
+\r
+ if (serverSocket == INVALID_SOCKET)\r
+ {\r
+ return ANTLR3_FALSE;\r
+ }\r
+\r
+ // Set the listening port\r
+ //\r
+ server.sin_port = htons((unsigned short)delboy->port);\r
+ server.sin_family = AF_INET;\r
+ server.sin_addr.s_addr = htonl (INADDR_ANY);\r
+\r
+ // We could allow a rebind on the same addr/port pair I suppose, but\r
+ // I imagine that most people will just want to start debugging one parser at once.\r
+ // Maybe change this at some point, but rejecting the bind at this point will ensure\r
+ // that people realize they have left something running in the background.\r
+ //\r
+ if (bind(serverSocket, (pANTLR3_SOCKADDRC)&server, sizeof(server)) == -1)\r
+ {\r
+ return ANTLR3_FALSE;\r
+ }\r
+\r
+ // We have bound the socket to the port and address so we now ask the TCP subsystem\r
+ // to start listening on that address/port\r
+ //\r
+ if (listen(serverSocket, 1) == -1)\r
+ {\r
+ // Some error, just fail\r
+ //\r
+ return ANTLR3_FALSE;\r
+ }\r
+\r
+ // Now we can try to accept a connection on the port\r
+ //\r
+ sockaddr_len = sizeof(client);\r
+ delboy->socket = accept(serverSocket, (pANTLR3_SOCKADDRC)&client, &sockaddr_len);\r
+\r
+ // Having accepted a connection, we can stop listening and close down the socket\r
+ //\r
+ shutdown (serverSocket, 0x02);\r
+ ANTLR3_CLOSESOCKET (serverSocket);\r
+\r
+ if (delboy->socket == -1)\r
+ {\r
+ return ANTLR3_FALSE;\r
+ }\r
+\r
+ // Disable Nagle as this is essentially a chat exchange\r
+ //\r
+ optVal = 1;\r
+ setsockopt(delboy->socket, SOL_SOCKET, TCP_NODELAY, (const void *)&optVal, sizeof(optVal));\r
+ \r
+ }\r
+\r
+ // We now have a good socket connection with the debugging client, so we\r
+ // send it the protocol version we are using and what the name of the grammar\r
+ // is that we represent.\r
+ //\r
+ sprintf (message, "ANTLR %d\n", delboy->PROTOCOL_VERSION);\r
+ sockSend (delboy->socket, message, (int)strlen(message));\r
+ sprintf (message, "grammar \"%s\n", delboy->grammarFileName->chars);\r
+ sockSend (delboy->socket, message, (int)strlen(message));\r
+ ack (delboy);\r
+\r
+ delboy->initialized = ANTLR3_TRUE;\r
+\r
+ return ANTLR3_TRUE;\r
+}\r
+\r
+// Send the supplied text and wait for an ack from the client\r
+static void\r
+transmit(pANTLR3_DEBUG_EVENT_LISTENER delboy, const char * ptr)\r
+{\r
+ sockSend(delboy->socket, ptr, (int)strlen(ptr));\r
+ ack(delboy);\r
+}\r
+\r
+static void\r
+ack (pANTLR3_DEBUG_EVENT_LISTENER delboy)\r
+{\r
+ // Local buffer to read the next character in to\r
+ //\r
+ char buffer;\r
+ int rCount;\r
+\r
+ // Ack terminates in a line feed, so we just wait for\r
+ // one of those. Speed is not of the essence so we don't need\r
+ // to buffer the input or anything.\r
+ //\r
+ do\r
+ {\r
+ rCount = recv(delboy->socket, &buffer, 1, 0);\r
+ }\r
+ while (rCount == 1 && buffer != '\n');\r
+\r
+ // If the socket ws closed on us, then we will get an error or\r
+ // (with a graceful close), 0. We can assume the the debugger stopped for some reason\r
+ // (such as Java crashing again). Therefore we just exit the program\r
+ // completely if we don't get the terminating '\n' for the ack.\r
+ //\r
+ if (rCount != 1)\r
+ {\r
+ ANTLR3_PRINTF("Exiting debugger as remote client closed the socket\n");\r
+ ANTLR3_PRINTF("Received char count was %d, and last char received was %02X\n", rCount, buffer);\r
+ exit(0);\r
+ }\r
+}\r
+\r
+// Given a buffer string and a source string, serialize the\r
+// text, escaping any newlines and linefeeds. We have no need\r
+// for speed here, this is the debugger.\r
+//\r
+void\r
+serializeText(pANTLR3_STRING buffer, pANTLR3_STRING text)\r
+{\r
+ ANTLR3_UINT32 c;\r
+ ANTLR3_UCHAR character;\r
+\r
+ // strings lead in with a "\r
+ //\r
+ buffer->append(buffer, " \"");\r
+\r
+ if (text == NULL)\r
+ {\r
+ return;\r
+ }\r
+\r
+ // Now we replace linefeeds, newlines and the escape\r
+ // leadin character '%' with their hex equivalents\r
+ // prefixed by '%'\r
+ //\r
+ for (c = 0; c < text->len; c++)\r
+ {\r
+ switch (character = text->charAt(text, c))\r
+ {\r
+ case '\n':\r
+\r
+ buffer->append(buffer, "%0A");\r
+ break;\r
+\r
+ case '\r':\r
+ \r
+ buffer->append(buffer, "%0D");\r
+ break;\r
+\r
+ case '\\':\r
+\r
+ buffer->append(buffer, "%25");\r
+ break;\r
+\r
+ // Other characters: The Song Remains the Same.\r
+ //\r
+ default:\r
+ \r
+ buffer->addc(buffer, character);\r
+ break;\r
+ }\r
+ }\r
+}\r
+\r
+// Given a token, create a stringified version of it, in the supplied\r
+// buffer. We create a string for this in the debug 'object', if there \r
+// is not one there already, and then reuse it here if asked to do this\r
+// again.\r
+//\r
+pANTLR3_STRING\r
+serializeToken(pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_COMMON_TOKEN t)\r
+{\r
+ // Do we already have a serialization buffer?\r
+ //\r
+ if (delboy->tokenString == NULL)\r
+ {\r
+ // No, so create one, using the string factory that\r
+ // the grammar name used, which is guaranteed to exist.\r
+ // 64 bytes will do us here for starters. \r
+ //\r
+ delboy->tokenString = delboy->grammarFileName->factory->newSize(delboy->grammarFileName->factory, 64);\r
+ }\r
+\r
+ // Empty string\r
+ //\r
+ delboy->tokenString->set(delboy->tokenString, (const char *)"");\r
+\r
+ // Now we serialize the elements of the token.Note that the debugger only\r
+ // uses 32 bits.\r
+ //\r
+ delboy->tokenString->addi(delboy->tokenString, (ANTLR3_INT32)(t->getTokenIndex(t)));\r
+ delboy->tokenString->addc(delboy->tokenString, ' ');\r
+ delboy->tokenString->addi(delboy->tokenString, (ANTLR3_INT32)(t->getType(t)));\r
+ delboy->tokenString->addc(delboy->tokenString, ' ');\r
+ delboy->tokenString->addi(delboy->tokenString, (ANTLR3_INT32)(t->getChannel(t)));\r
+ delboy->tokenString->addc(delboy->tokenString, ' ');\r
+ delboy->tokenString->addi(delboy->tokenString, (ANTLR3_INT32)(t->getLine(t)));\r
+ delboy->tokenString->addc(delboy->tokenString, ' ');\r
+ delboy->tokenString->addi(delboy->tokenString, (ANTLR3_INT32)(t->getCharPositionInLine(t)));\r
+\r
+ // Now send the text that the token represents.\r
+ //\r
+ serializeText(delboy->tokenString, t->getText(t));\r
+\r
+ // Finally, as the debugger is a Java program it will expect to get UTF-8\r
+ // encoded strings. We don't use UTF-8 internally to the C runtime, so we \r
+ // must force encode it. We have a method to do this in the string class, but\r
+ // it returns malloc space that we must free afterwards.\r
+ //\r
+ return delboy->tokenString->toUTF8(delboy->tokenString);\r
+}\r
+\r
+// Given a tree node, create a stringified version of it in the supplied\r
+// buffer.\r
+//\r
+pANTLR3_STRING\r
+serializeNode(pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE node)\r
+{\r
+ pANTLR3_COMMON_TOKEN token;\r
+\r
+\r
+ // Do we already have a serialization buffer?\r
+ //\r
+ if (delboy->tokenString == NULL)\r
+ {\r
+ // No, so create one, using the string factory that\r
+ // the grammar name used, which is guaranteed to exist.\r
+ // 64 bytes will do us here for starters. \r
+ //\r
+ delboy->tokenString = delboy->grammarFileName->factory->newSize(delboy->grammarFileName->factory, 64);\r
+ }\r
+\r
+ // Empty string\r
+ //\r
+ delboy->tokenString->set(delboy->tokenString, (const char *)"");\r
+\r
+ // Protect against bugs/errors etc\r
+ //\r
+ if (node == NULL)\r
+ {\r
+ return delboy->tokenString;\r
+ }\r
+\r
+ // Now we serialize the elements of the node.Note that the debugger only\r
+ // uses 32 bits.\r
+ //\r
+ delboy->tokenString->addc(delboy->tokenString, ' ');\r
+\r
+ // Adaptor ID\r
+ //\r
+ delboy->tokenString->addi(delboy->tokenString, delboy->adaptor->getUniqueID(delboy->adaptor, node));\r
+ delboy->tokenString->addc(delboy->tokenString, ' ');\r
+\r
+ // Type of the current token (which may be imaginary)\r
+ //\r
+ delboy->tokenString->addi(delboy->tokenString, delboy->adaptor->getType(delboy->adaptor, node));\r
+\r
+ // See if we have an actual token or just an imaginary\r
+ //\r
+ token = delboy->adaptor->getToken(delboy->adaptor, node);\r
+\r
+ delboy->tokenString->addc(delboy->tokenString, ' ');\r
+ if (token != NULL)\r
+ {\r
+ // Real token\r
+ //\r
+ delboy->tokenString->addi(delboy->tokenString, (ANTLR3_INT32)(token->getLine(token)));\r
+ delboy->tokenString->addc(delboy->tokenString, ' ');\r
+ delboy->tokenString->addi(delboy->tokenString, (ANTLR3_INT32)(token->getCharPositionInLine(token)));\r
+ }\r
+ else\r
+ {\r
+ // Imaginary tokens have no location\r
+ //\r
+ delboy->tokenString->addi(delboy->tokenString, -1);\r
+ delboy->tokenString->addc(delboy->tokenString, ' ');\r
+ delboy->tokenString->addi(delboy->tokenString, -1);\r
+ }\r
+\r
+ // Start Index of the node\r
+ //\r
+ delboy->tokenString->addc(delboy->tokenString, ' ');\r
+ delboy->tokenString->addi(delboy->tokenString, (ANTLR3_UINT32)(delboy->adaptor->getTokenStartIndex(delboy->adaptor, node)));\r
+\r
+ // Now send the text that the node represents.\r
+ //\r
+ serializeText(delboy->tokenString, delboy->adaptor->getText(delboy->adaptor, node));\r
+\r
+ // Finally, as the debugger is a Java program it will expect to get UTF-8\r
+ // encoded strings. We don't use UTF-8 internally to the C runtime, so we \r
+ // must force encode it. We have a method to do this in the string class, but\r
+ // there is no utf8 string implementation as of yet\r
+ //\r
+ return delboy->tokenString->toUTF8(delboy->tokenString);\r
+}\r
+\r
+//------------------------------------------------------------------------------------------------------------------\r
+// EVENTS\r
+//\r
+static void\r
+enterRule (pANTLR3_DEBUG_EVENT_LISTENER delboy, const char * grammarFileName, const char * ruleName)\r
+{\r
+ char buffer[512];\r
+\r
+ // Create the message (speed is not of the essence)\r
+ //\r
+ sprintf(buffer, "enterRule %s %s\n", grammarFileName, ruleName);\r
+ transmit(delboy, buffer);\r
+}\r
+\r
+static void \r
+enterAlt (pANTLR3_DEBUG_EVENT_LISTENER delboy, int alt)\r
+{\r
+ char buffer[512];\r
+\r
+ // Create the message (speed is not of the essence)\r
+ //\r
+ sprintf(buffer, "enterAlt %d\n", alt);\r
+ transmit(delboy, buffer);\r
+}\r
+\r
+static void \r
+exitRule (pANTLR3_DEBUG_EVENT_LISTENER delboy, const char * grammarFileName, const char * ruleName)\r
+{\r
+ char buffer[512];\r
+\r
+ // Create the message (speed is not of the essence)\r
+ //\r
+ sprintf(buffer, "enterRule %s %s\n", grammarFileName, ruleName);\r
+ transmit(delboy, buffer);\r
+}\r
+\r
+static void \r
+enterSubRule (pANTLR3_DEBUG_EVENT_LISTENER delboy, int decisionNumber)\r
+{\r
+ char buffer[512];\r
+\r
+ // Create the message (speed is not of the essence)\r
+ //\r
+ sprintf(buffer, "enterSubRule %d\n", decisionNumber);\r
+ transmit(delboy, buffer);\r
+}\r
+\r
+static void \r
+exitSubRule (pANTLR3_DEBUG_EVENT_LISTENER delboy, int decisionNumber)\r
+{\r
+ char buffer[512];\r
+\r
+ // Create the message (speed is not of the essence)\r
+ //\r
+ sprintf(buffer, "exitSubRule %d\n", decisionNumber);\r
+ transmit(delboy, buffer);\r
+}\r
+\r
+static void \r
+enterDecision (pANTLR3_DEBUG_EVENT_LISTENER delboy, int decisionNumber)\r
+{\r
+ char buffer[512];\r
+\r
+ // Create the message (speed is not of the essence)\r
+ //\r
+ sprintf(buffer, "enterDecision %d\n", decisionNumber);\r
+ transmit(delboy, buffer);\r
+\r
+}\r
+\r
+static void \r
+exitDecision (pANTLR3_DEBUG_EVENT_LISTENER delboy, int decisionNumber)\r
+{\r
+ char buffer[512];\r
+\r
+ // Create the message (speed is not of the essence)\r
+ //\r
+ sprintf(buffer, "exitDecision %d\n", decisionNumber);\r
+ transmit(delboy, buffer);\r
+}\r
+\r
+static void \r
+consumeToken (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_COMMON_TOKEN t)\r
+{\r
+ pANTLR3_STRING msg;\r
+\r
+ // Create the serialized token\r
+ //\r
+ msg = serializeToken(delboy, t);\r
+\r
+ // Insert the debug event indicator\r
+ //\r
+ msg->insert8(msg, 0, "consumeToken ");\r
+\r
+ msg->addc(msg, '\n');\r
+\r
+ // Transmit the message and wait for ack\r
+ //\r
+ transmit(delboy, (const char *)(msg->chars));\r
+}\r
+\r
+static void \r
+consumeHiddenToken (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_COMMON_TOKEN t)\r
+{\r
+ pANTLR3_STRING msg;\r
+\r
+ // Create the serialized token\r
+ //\r
+ msg = serializeToken(delboy, t);\r
+\r
+ // Insert the debug event indicator\r
+ //\r
+ msg->insert8(msg, 0, "consumeHiddenToken ");\r
+\r
+ msg->addc(msg, '\n');\r
+\r
+ // Transmit the message and wait for ack\r
+ //\r
+ transmit(delboy, (const char *)(msg->chars));\r
+}\r
+\r
+// Looking at the next token event.\r
+//\r
+static void \r
+LT (pANTLR3_DEBUG_EVENT_LISTENER delboy, int i, pANTLR3_COMMON_TOKEN t)\r
+{\r
+ pANTLR3_STRING msg;\r
+\r
+ if (t != NULL)\r
+ {\r
+ // Create the serialized token\r
+ //\r
+ msg = serializeToken(delboy, t);\r
+\r
+ // Insert the index parameter\r
+ //\r
+ msg->insert8(msg, 0, " ");\r
+ msg->inserti(msg, 0, i);\r
+\r
+ // Insert the debug event indicator\r
+ //\r
+ msg->insert8(msg, 0, "LT ");\r
+\r
+ msg->addc(msg, '\n');\r
+\r
+ // Transmit the message and wait for ack\r
+ //\r
+ transmit(delboy, (const char *)(msg->chars));\r
+ }\r
+}\r
+\r
+static void \r
+mark (pANTLR3_DEBUG_EVENT_LISTENER delboy, ANTLR3_MARKER marker)\r
+{\r
+ char buffer[128];\r
+\r
+ sprintf(buffer, "mark %d\n", (ANTLR3_UINT32)(marker & 0xFFFFFFFF));\r
+\r
+ // Transmit the message and wait for ack\r
+ //\r
+ transmit(delboy, buffer);\r
+}\r
+\r
+static void \r
+rewindMark (pANTLR3_DEBUG_EVENT_LISTENER delboy, ANTLR3_MARKER marker)\r
+{\r
+ char buffer[128];\r
+\r
+ sprintf(buffer, "rewind %d\n", (ANTLR3_UINT32)(marker & 0xFFFFFFFF));\r
+\r
+ // Transmit the message and wait for ack\r
+ //\r
+ transmit(delboy, buffer);\r
+\r
+}\r
+\r
+static void \r
+rewindLast (pANTLR3_DEBUG_EVENT_LISTENER delboy)\r
+{\r
+ transmit(delboy, (const char *)"rewind\n");\r
+}\r
+\r
+static void \r
+beginBacktrack (pANTLR3_DEBUG_EVENT_LISTENER delboy, int level)\r
+{\r
+ char buffer[128];\r
+\r
+ sprintf(buffer, "beginBacktrack %d\n", (ANTLR3_UINT32)(level & 0xFFFFFFFF));\r
+\r
+ // Transmit the message and wait for ack\r
+ //\r
+ transmit(delboy, buffer);\r
+}\r
+\r
+static void \r
+endBacktrack (pANTLR3_DEBUG_EVENT_LISTENER delboy, int level, ANTLR3_BOOLEAN successful)\r
+{\r
+ char buffer[128];\r
+\r
+ sprintf(buffer, "endBacktrack %d %d\n", level, successful);\r
+\r
+ // Transmit the message and wait for ack\r
+ //\r
+ transmit(delboy, buffer);\r
+}\r
+\r
+static void \r
+location (pANTLR3_DEBUG_EVENT_LISTENER delboy, int line, int pos)\r
+{\r
+ char buffer[128];\r
+\r
+ sprintf(buffer, "location %d %d\n", line, pos);\r
+\r
+ // Transmit the message and wait for ack\r
+ //\r
+ transmit(delboy, buffer);\r
+}\r
+\r
+static void \r
+recognitionException (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_EXCEPTION e)\r
+{\r
+ char buffer[256];\r
+\r
+ sprintf(buffer, "exception %s %d %d %d\n", (char *)(e->name), (ANTLR3_INT32)(e->index), e->line, e->charPositionInLine);\r
+\r
+ // Transmit the message and wait for ack\r
+ //\r
+ transmit(delboy, buffer);\r
+}\r
+\r
+static void \r
+beginResync (pANTLR3_DEBUG_EVENT_LISTENER delboy)\r
+{\r
+ transmit(delboy, (const char *)"beginResync\n");\r
+}\r
+\r
+static void \r
+endResync (pANTLR3_DEBUG_EVENT_LISTENER delboy)\r
+{\r
+ transmit(delboy, (const char *)"endResync\n");\r
+}\r
+\r
+static void \r
+semanticPredicate (pANTLR3_DEBUG_EVENT_LISTENER delboy, ANTLR3_BOOLEAN result, const char * predicate)\r
+{\r
+ unsigned char * buffer;\r
+ unsigned char * out;\r
+\r
+ if (predicate != NULL)\r
+ {\r
+ buffer = (unsigned char *)ANTLR3_MALLOC(64 + 2*strlen(predicate));\r
+\r
+ if (buffer != NULL)\r
+ {\r
+ out = buffer + sprintf((char *)buffer, "semanticPredicate %s ", result == ANTLR3_TRUE ? "true" : "false");\r
+\r
+ while (*predicate != '\0')\r
+ {\r
+ switch(*predicate)\r
+ {\r
+ case '\n':\r
+ \r
+ *out++ = '%';\r
+ *out++ = '0';\r
+ *out++ = 'A';\r
+ break;\r
+\r
+ case '\r':\r
+\r
+ *out++ = '%';\r
+ *out++ = '0';\r
+ *out++ = 'D';\r
+ break;\r
+\r
+ case '%':\r
+\r
+ *out++ = '%';\r
+ *out++ = '0';\r
+ *out++ = 'D';\r
+ break;\r
+\r
+\r
+ default:\r
+\r
+ *out++ = *predicate;\r
+ break;\r
+ }\r
+\r
+ predicate++;\r
+ }\r
+ *out++ = '\n';\r
+ *out++ = '\0';\r
+ }\r
+\r
+ // Send it and wait for the ack\r
+ //\r
+ transmit(delboy, (const char *)buffer);\r
+ }\r
+}\r
+\r
+#ifdef ANTLR3_WINDOWS\r
+#pragma warning (push)\r
+#pragma warning (disable : 4100)\r
+#endif\r
+\r
+static void \r
+commence (pANTLR3_DEBUG_EVENT_LISTENER delboy)\r
+{\r
+ // Nothing to see here\r
+ //\r
+}\r
+\r
+#ifdef ANTLR3_WINDOWS\r
+#pragma warning (pop)\r
+#endif\r
+\r
+static void \r
+terminate (pANTLR3_DEBUG_EVENT_LISTENER delboy)\r
+{\r
+ // Terminate sequence\r
+ //\r
+ sockSend(delboy->socket, "terminate\n", 10); // Send out the command\r
+}\r
+\r
+//----------------------------------------------------------------\r
+// Tree parsing events\r
+//\r
+static void \r
+consumeNode (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t)\r
+{\r
+ pANTLR3_STRING buffer;\r
+\r
+ buffer = serializeNode (delboy, t);\r
+\r
+ // Now prepend the command\r
+ //\r
+ buffer->insert8 (buffer, 0, "consumeNode ");\r
+ buffer->addc (buffer, '\n');\r
+\r
+ // Send to the debugger and wait for the ack\r
+ //\r
+ transmit (delboy, (const char *)(delboy->tokenString->toUTF8(delboy->tokenString)->chars));\r
+}\r
+\r
+static void \r
+LTT (pANTLR3_DEBUG_EVENT_LISTENER delboy, int i, pANTLR3_BASE_TREE t)\r
+{\r
+ pANTLR3_STRING buffer;\r
+\r
+ buffer = serializeNode (delboy, t);\r
+\r
+ // Now prepend the command\r
+ //\r
+ buffer->insert8 (buffer, 0, " ");\r
+ buffer->inserti (buffer, 0, i);\r
+ buffer->insert8 (buffer, 0, "LN ");\r
+ buffer->addc (buffer, '\n');\r
+\r
+ // Send to the debugger and wait for the ack\r
+ //\r
+ transmit (delboy, (const char *)(delboy->tokenString->toUTF8(delboy->tokenString)->chars));\r
+}\r
+\r
+static void \r
+nilNode (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t)\r
+{\r
+ char buffer[128];\r
+ sprintf(buffer, "nilNode %d\n", delboy->adaptor->getUniqueID(delboy->adaptor, t));\r
+ transmit(delboy, buffer);\r
+}\r
+\r
+static void \r
+createNode (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t)\r
+{\r
+ // Do we already have a serialization buffer?\r
+ //\r
+ if (delboy->tokenString == NULL)\r
+ {\r
+ // No, so create one, using the string factory that\r
+ // the grammar name used, which is guaranteed to exist.\r
+ // 64 bytes will do us here for starters. \r
+ //\r
+ delboy->tokenString = delboy->grammarFileName->factory->newSize(delboy->grammarFileName->factory, 64);\r
+ }\r
+\r
+ // Empty string\r
+ //\r
+ delboy->tokenString->set8(delboy->tokenString, (const char *)"createNodeFromTokenElements ");\r
+\r
+ // Now we serialize the elements of the node.Note that the debugger only\r
+ // uses 32 bits.\r
+ //\r
+ // Adaptor ID\r
+ //\r
+ delboy->tokenString->addi(delboy->tokenString, delboy->adaptor->getUniqueID(delboy->adaptor, t));\r
+ delboy->tokenString->addc(delboy->tokenString, ' ');\r
+\r
+ // Type of the current token (which may be imaginary)\r
+ //\r
+ delboy->tokenString->addi(delboy->tokenString, delboy->adaptor->getType(delboy->adaptor, t));\r
+\r
+ // The text that this node represents\r
+ //\r
+ serializeText(delboy->tokenString, delboy->adaptor->getText(delboy->adaptor, t));\r
+ delboy->tokenString->addc(delboy->tokenString, '\n');\r
+\r
+ // Finally, as the debugger is a Java program it will expect to get UTF-8\r
+ // encoded strings. We don't use UTF-8 internally to the C runtime, so we \r
+ // must force encode it. We have a method to do this in the string class, but\r
+ // there is no utf8 string implementation as of yet\r
+ //\r
+ transmit(delboy, (const char *)(delboy->tokenString->toUTF8(delboy->tokenString)->chars));\r
+\r
+}\r
+static void\r
+errorNode (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t)\r
+{\r
+ // Do we already have a serialization buffer?\r
+ //\r
+ if (delboy->tokenString == NULL)\r
+ {\r
+ // No, so create one, using the string factory that\r
+ // the grammar name used, which is guaranteed to exist.\r
+ // 64 bytes will do us here for starters. \r
+ //\r
+ delboy->tokenString = delboy->grammarFileName->factory->newSize(delboy->grammarFileName->factory, 64);\r
+ }\r
+\r
+ // Empty string\r
+ //\r
+ delboy->tokenString->set8(delboy->tokenString, (const char *)"errorNode ");\r
+\r
+ // Now we serialize the elements of the node.Note that the debugger only\r
+ // uses 32 bits.\r
+ //\r
+ // Adaptor ID\r
+ //\r
+ delboy->tokenString->addi(delboy->tokenString, delboy->adaptor->getUniqueID(delboy->adaptor, t));\r
+ delboy->tokenString->addc(delboy->tokenString, ' ');\r
+\r
+ // Type of the current token (which is an error)\r
+ //\r
+ delboy->tokenString->addi(delboy->tokenString, ANTLR3_TOKEN_INVALID);\r
+\r
+ // The text that this node represents\r
+ //\r
+ serializeText(delboy->tokenString, delboy->adaptor->getText(delboy->adaptor, t));\r
+ delboy->tokenString->addc(delboy->tokenString, '\n');\r
+\r
+ // Finally, as the debugger is a Java program it will expect to get UTF-8\r
+ // encoded strings. We don't use UTF-8 internally to the C runtime, so we \r
+ // must force encode it. We have a method to do this in the string class, but\r
+ // there is no utf8 string implementation as of yet\r
+ //\r
+ transmit(delboy, (const char *)(delboy->tokenString->toUTF8(delboy->tokenString)->chars));\r
+\r
+}\r
+\r
+static void \r
+createNodeTok (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE node, pANTLR3_COMMON_TOKEN token)\r
+{\r
+ char buffer[128];\r
+\r
+ sprintf(buffer, "createNode %d %d\n", delboy->adaptor->getUniqueID(delboy->adaptor, node), (ANTLR3_UINT32)token->getTokenIndex(token));\r
+\r
+ transmit(delboy, buffer);\r
+}\r
+\r
+static void \r
+becomeRoot (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE newRoot, pANTLR3_BASE_TREE oldRoot)\r
+{\r
+ char buffer[128];\r
+\r
+ sprintf(buffer, "becomeRoot %d %d\n", delboy->adaptor->getUniqueID(delboy->adaptor, newRoot),\r
+ delboy->adaptor->getUniqueID(delboy->adaptor, oldRoot)\r
+ );\r
+ transmit(delboy, buffer);\r
+}\r
+\r
+\r
+static void \r
+addChild (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE root, pANTLR3_BASE_TREE child)\r
+{\r
+ char buffer[128];\r
+\r
+ sprintf(buffer, "addChild %d %d\n", delboy->adaptor->getUniqueID(delboy->adaptor, root),\r
+ delboy->adaptor->getUniqueID(delboy->adaptor, child)\r
+ );\r
+ transmit(delboy, buffer);\r
+}\r
+\r
+static void \r
+setTokenBoundaries (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t, ANTLR3_MARKER tokenStartIndex, ANTLR3_MARKER tokenStopIndex)\r
+{\r
+ char buffer[128];\r
+\r
+ sprintf(buffer, "becomeRoot %d %d %d\n", delboy->adaptor->getUniqueID(delboy->adaptor, t),\r
+ (ANTLR3_UINT32)tokenStartIndex,\r
+ (ANTLR3_UINT32)tokenStopIndex\r
+ );\r
+ transmit(delboy, buffer);\r
+}\r
+#endif\r
+\r
Code Review / simantics / platform.git / blobdiff