| /** \file |
| * Contains default functions for creating and destroying as well as |
| * otherwise handling ANTLR3 standard exception structures. |
| */ |
| |
| // [The "BSD licence"] |
| // Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC |
| // http://www.temporal-wave.com |
| // http://www.linkedin.com/in/jimidle |
| // |
| // All rights reserved. |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions |
| // are met: |
| // 1. Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // 2. Redistributions in binary form must reproduce the above copyright |
| // notice, this list of conditions and the following disclaimer in the |
| // documentation and/or other materials provided with the distribution. |
| // 3. The name of the author may not be used to endorse or promote products |
| // derived from this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| #include <antlr3exception.h> |
| |
| static void antlr3ExceptionPrint(pANTLR3_EXCEPTION ex); |
| static void antlr3ExceptionFree (pANTLR3_EXCEPTION ex); |
| |
| /** |
| * \brief |
| * Creates a new ANTLR3 exception structure |
| * |
| * \param[in] exception |
| * One of the ANTLR3_xxx_EXCEPTION indicators such as #ANTLR3_RECOGNITION_EXCEPTION |
| * |
| * \param[in] message |
| * Pointer to message string |
| * |
| * \param[in] freeMessage |
| * Set to ANTLR3_TRUE if the message parameter should be freed by a call to |
| * ANTLR3_FREE() when the exception is destroyed. |
| * |
| * \returns |
| * Pointer to newly initialized exception structure, or an ANTLR3_ERR_xx defined value |
| * upon failure. |
| * |
| * An exception is 'thrown' by a recognizer when input is seen that is not predicted by |
| * the grammar productions or when some other error condition occurs. In C we do not have |
| * the luxury of try and catch blocks, so exceptions are added in the order they occur to |
| * a list in the baserecognizer structure. The last one to be thrown is inserted at the head of |
| * the list and the one currently installed is pointed to by the newly installed exception. |
| * |
| * \remarks |
| * After an exception is created, you may add a pointer to your own structure and a pointer |
| * to a function to free this structure when the exception is destroyed. |
| * |
| * \see |
| * ANTLR3_EXCEPTION |
| */ |
| pANTLR3_EXCEPTION |
| antlr3ExceptionNew(ANTLR3_UINT32 exception, void * name, void * message, ANTLR3_BOOLEAN freeMessage) |
| { |
| pANTLR3_EXCEPTION ex; |
| |
| /* Allocate memory for the structure |
| */ |
| ex = (pANTLR3_EXCEPTION) ANTLR3_CALLOC(1, sizeof(ANTLR3_EXCEPTION)); |
| |
| /* Check for memory allocation |
| */ |
| if (ex == NULL) |
| { |
| return NULL; |
| } |
| |
| ex->name = name; /* Install exception name */ |
| ex->type = exception; /* Install the exception number */ |
| ex->message = message; /* Install message string */ |
| |
| /* Indicate whether the string should be freed if exception is destroyed |
| */ |
| ex->freeMessage = freeMessage; |
| |
| /* Install the API |
| */ |
| ex->print = antlr3ExceptionPrint; |
| ex->freeEx = antlr3ExceptionFree; |
| |
| return ex; |
| } |
| |
| /** |
| * \brief |
| * Prints out the message in all the exceptions in the supplied chain. |
| * |
| * \param[in] ex |
| * Pointer to the exception structure to print. |
| * |
| * \remarks |
| * You may wish to override this function by installing a pointer to a new function |
| * in the base recognizer context structure. |
| * |
| * \see |
| * ANTLR3_BASE_RECOGNIZER |
| */ |
| static void |
| antlr3ExceptionPrint(pANTLR3_EXCEPTION ex) |
| { |
| /* Ensure valid pointer |
| */ |
| while (ex != NULL) |
| { |
| /* Number if no message, else the message |
| */ |
| if (ex->message == NULL) |
| { |
| ANTLR3_FPRINTF(stderr, "ANTLR3_EXCEPTION number %d (%08X).\n", ex->type, ex->type); |
| } |
| else |
| { |
| ANTLR3_FPRINTF(stderr, "ANTLR3_EXCEPTION: %s\n", (char *)(ex->message)); |
| } |
| |
| /* Move to next in the chain (if any) |
| */ |
| ex = ex->nextException; |
| } |
| |
| return; |
| } |
| |
| /** |
| * \brief |
| * Frees up a chain of ANTLR3 exceptions |
| * |
| * \param[in] ex |
| * Pointer to the first exception in the chain to free. |
| * |
| * \see |
| * ANTLR3_EXCEPTION |
| */ |
| static void |
| antlr3ExceptionFree(pANTLR3_EXCEPTION ex) |
| { |
| pANTLR3_EXCEPTION next; |
| |
| /* Ensure valid pointer |
| */ |
| while (ex != NULL) |
| { |
| /* Pick up anythign following now, before we free the |
| * current memory block. |
| */ |
| next = ex->nextException; |
| |
| /* Free the message pointer if advised to |
| */ |
| if (ex->freeMessage == ANTLR3_TRUE) |
| { |
| ANTLR3_FREE(ex->message); |
| } |
| |
| /* Call the programmer's custom free routine if advised to |
| */ |
| if (ex->freeCustom != NULL) |
| { |
| ex->freeCustom(ex->custom); |
| } |
| |
| /* Free the actual structure itself |
| */ |
| ANTLR3_FREE(ex); |
| |
| ex = next; |
| } |
| |
| return; |
| } |
| |