path: root/o3d/compiler/technique/technique_error.cc

/*
 * Copyright 2009, Google Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * 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.
 *     * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "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 COPYRIGHT
 * OWNER OR CONTRIBUTORS 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.
 */

//
// Custom error reporting functon for the Technique parser, as described in
// the Antlr3 documention for the C Runtime at
// http://www.antlr.org/api/C/using.html
//
// NOTE: These error functions are only designed to work with 8-bit
// token streams.

#include "core/cross/types.h"
#include "compiler/technique/technique_error.h"

namespace o3d {
String* error_string;

void TechniqueSetErrorString(String* e) {
  error_string = e;
}

void TechniqueError(pANTLR3_BASE_RECOGNIZER recognizer,
                    pANTLR3_UINT8 * tokenNames) {
  // If the error string pointer has not been set, bail now.
  if (!error_string) return;

  pANTLR3_PARSER parser;
  pANTLR3_STRING token_text;
  pANTLR3_EXCEPTION exception;
  pANTLR3_COMMON_TOKEN token;
  pANTLR3_BASE_TREE theBaseTree;
  pANTLR3_COMMON_TREE theCommonTree;

  // Retrieve some info for easy reading.
  exception = recognizer->state->exception;
  token_text = NULL;

  pANTLR3_COMMON_TOKEN exception_token =
      static_cast<pANTLR3_COMMON_TOKEN>(exception->token);
  if (exception_token && exception_token->custom) {
    // The filename is retrieved from the "custom" field of the token, which
    // was put there by the lexer.  The lexer gets it from the #line directives
    // in the pre-processed output.
    pANTLR3_STRING filename =
        static_cast<pANTLR3_STRING>(exception_token->custom);
    *error_string += reinterpret_cast<char*>(filename->chars);
  } else {
    if (exception_token && exception_token->type == ANTLR3_TOKEN_EOF) {
      *error_string += "End of input";
    } else {
      *error_string += "Unknown source";
    }
  }

  // Next comes the line number
  char buffer[10];
  base::snprintf(buffer, sizeof(buffer), "%d", exception->line);
  *error_string += "(";
  *error_string += buffer;
  *error_string += ")";

  *error_string += ": Error: ";
  *error_string += reinterpret_cast<char*>(exception->message);

  // Find out what part of the system raised the error.
  switch (recognizer->type) {
    case ANTLR3_TYPE_PARSER: {
      // This is a normal Parser error. Prepare the information we have
      // available.
      parser = (pANTLR3_PARSER)(recognizer->super);
      token = (pANTLR3_COMMON_TOKEN)(exception->token);

      *error_string += ", at offset ";
      base::snprintf(buffer, sizeof(buffer), "%d",
                     exception->charPositionInLine);
      *error_string += buffer;
      if (token != NULL) {
        if (token->type == ANTLR3_TOKEN_EOF) {
          ANTLR3_FPRINTF(stderr, ", at <EOF>");
        } else {
          token_text = token->getText(token);
          if (token_text != NULL) {
            *error_string += " near \"";
            *error_string += reinterpret_cast<const char*>(token_text->chars);
            *error_string += "\"";
          }
        }
      }
      break;
    }
    case  ANTLR3_TYPE_LEXER: {
      *error_string += "lexer error.";
      break;
    }
    case ANTLR3_TYPE_TREE_PARSER: {
      // Tree parsers not supported. Exit.
      DLOG(FATAL) << "Technique error should never see a Tree Parser.";
      return;
    }
    default: {
      // Parser type was not recognised. Exit.
      DLOG(FATAL) << "Technique error called by an unknown Parser type.";
      return;
    }
  }

#if 0
  // Although this function should generally be provided by the
  // implementation, this one should be as helpful as possible for grammar
  // developers and serve as an example of what you can do with each
  // exception type. In general, when you make up your 'real' handler, you
  // should debug the routine with all possible errors you expect which will
  // then let you be as specific as possible about all circumstances.
  //
  // Note that in the general case, errors thrown by tree parsers indicate a
  // problem with the output of the parser or with the tree grammar
  // itself. The job of the parser is to produce a perfect (in traversal
  // terms) syntactically correct tree, so errors at that stage should
  // really be semantic errors that your own code determines and handles in
  // whatever way is appropriate.
  switch (exception->type) {
    case ANTLR3_UNWANTED_TOKEN_EXCEPTION:
      // Indicates that the recognizer was fed a token which seesm to be
      // spurious input. We can detect this when the token that follows
      // this unwanted token would normally be part of the syntactically
      // correct stream. Then we can see that the token we are looking at
      // is just something that should not be there and throw this exception.
      if (tokenNames == NULL) {
        ANTLR3_FPRINTF(stderr, " : Extraneous input...");
      } else {
        if (exception->expecting == ANTLR3_TOKEN_EOF) {
          ANTLR3_FPRINTF(stderr, " : Extraneous input - expected <EOF>\n");
        } else {
          ANTLR3_FPRINTF(stderr,
                         " : Extraneous input - expected %s ...\n",
                         tokenNames[exception->expecting]);
        }
      }
      break;
    case ANTLR3_MISSING_TOKEN_EXCEPTION:
      // Indicates that the recognizer detected that the token we just
      // hit would be valid syntactically if preceeded by a particular
      // token. Perhaps a missing ';' at line end or a missing ',' in an
      // expression list, and such like.
      if (tokenNames == NULL) {
        ANTLR3_FPRINTF(stderr,
                       " : Missing token (%d)...\n",
                       exception->expecting);
      } else {
        if (exception->expecting == ANTLR3_TOKEN_EOF) {
          ANTLR3_FPRINTF(stderr, " : Missing <EOF>\n");
        } else {
          ANTLR3_FPRINTF(stderr,
                         " : Missing %s \n",
                         tokenNames[exception->expecting]);
        }
      }
      break;
    case ANTLR3_RECOGNITION_EXCEPTION:
      // Indicates that the recognizer received a token
      // in the input that was not predicted. This is the basic exception type
      // from which all others are derived. So we assume it was a syntax error.
      // You may get this if there are not more tokens and more are needed
      // to complete a parse for instance.
      ANTLR3_FPRINTF(stderr, " : syntax error...\n");
      break;
    case ANTLR3_MISMATCHED_TOKEN_EXCEPTION:
      // We were expecting to see one thing and got another. This is the
      // most common error if we coudl not detect a missing or unwanted token.
      // Here you can spend your efforts to
      // derive more useful error messages based on the expected
      // token set and the last token and so on. The error following
      // bitmaps do a good job of reducing the set that we were looking
      // for down to something small. Knowing what you are parsing may be
      // able to allow you to be even more specific about an error.
      if (tokenNames == NULL) {
        ANTLR3_FPRINTF(stderr, " : syntax error...\n");
      } else {
        if (exception->expecting == ANTLR3_TOKEN_EOF) {
          ANTLR3_FPRINTF(stderr, " : expected <EOF>\n");
        } else {
          ANTLR3_FPRINTF(stderr,
                         " : expected %s ...\n",
                         tokenNames[exception->expecting]);
        }
      }
      break;
    case ANTLR3_NO_VIABLE_ALT_EXCEPTION:
      // We could not pick any alt decision from the input given
      // so god knows what happened - however when you examine your grammar,
      // you should. It means that at the point where the current token occurred
      // that the DFA indicates nowhere to go from here.
      ANTLR3_FPRINTF(stderr, " : cannot match to any predicted input...\n");
      break;
    case ANTLR3_MISMATCHED_SET_EXCEPTION: {
      ANTLR3_UINT32 count;
      ANTLR3_UINT32 bit;
      ANTLR3_UINT32 size;
      ANTLR3_UINT32 numbits;
      pANTLR3_BITSET errBits;

      // This means we were able to deal with one of a set of
      // possible tokens at this point, but we did not see any
      // member of that set.
      ANTLR3_FPRINTF(stderr, " : unexpected input...\n  expected one of : ");

      // What tokens could we have accepted at this point in the
      // parse?
      count = 0;
      errBits = antlr3BitsetLoad(exception->expectingSet);
      numbits = errBits->numBits(errBits);
      size = errBits->size(errBits);

      if (size > 0) {
        // However many tokens we could have dealt with here, it is usually
        // not useful to print ALL of the set here. I arbitrarily chose 8
        // here, but you should do whatever makes sense for you of course.
        // No token number 0, so look for bit 1 and on.
        for  (bit = 1; bit < numbits && count < 8 && count < size; bit++) {
          // TODO: This doesn't look right - should be asking if the bit is set!
          if (tokenNames[bit]) {
            ANTLR3_FPRINTF(stderr,
                           "%%s", count > 0 ? ", " : "",
                           tokenNames[bit]);
            count++;
          }
        }
        ANTLR3_FPRINTF(stderr, "\n");
      } else {
        ANTLR3_FPRINTF(stderr,
                       "Could not work out which set element was missing.\n");
      }
      break;
    }
    case ANTLR3_EARLY_EXIT_EXCEPTION:
      // We entered a loop requiring a number of token sequences
      // but found a token that ended that sequence earlier than
      // we should have done.
      ANTLR3_FPRINTF(stderr, " : missing elements...\n");
      break;
    default:
      // We don't handle any other exceptions here, but you can
      // if you wish. If we get an exception that hits this point
      // then we are just going to report what we know about the
      // token.
      ANTLR3_FPRINTF(stderr, " : syntax not recognized...\n");
      break;
  }
#endif  // end #if 0

  *error_string += "\n";

  DLOG(INFO) << "parse error:  " << error_string->c_str();
}
}  // namespace o3d