| /********************************************************************** |
| // @@@ START COPYRIGHT @@@ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| // @@@ END COPYRIGHT @@@ |
| // |
| **********************************************************************/ |
| /* -*-C++-*- |
| ***************************************************************************** |
| * |
| * File: ParserMsg.C |
| * RCS: $Id: ParserMsg.cpp,v 1.13 1998/08/25 17:19:09 Exp $ |
| * Description: This file contains the shared routines for the parsers in sqlci |
| * and compiler (i.e. parser directory) |
| * |
| * Created: 12/11/96 |
| * Modified: $ $Date: 1998/08/25 17:19:09 $ (GMT) |
| * Language: C++ |
| * Status: $State: Exp $ |
| * |
| * |
| ***************************************************************************** |
| */ |
| |
| #include <ctype.h> |
| #include <string.h> |
| #if !defined(__GNUC__) || __GNUC__ < 3 |
| #include <strstream.h> |
| #endif |
| #include "NAWinNT.h" |
| #include "ComDiags.h" |
| #include "wstr.h" |
| #include "nawstring.h" |
| #include "NLSConversion.h" |
| #include "ErrorMessage.h" |
| #include "ParserMsg.h" // header for StoreSyntaxError, implemented herein |
| #include "csconvert.h" |
| |
| |
| // This function takes as an argument a pointer to a ComCondition object. |
| // This function accesses the global variables: input_str, input_pos in |
| // order to format a string indicating where in the given SQL statement |
| // a syntax error occurred. |
| // |
| // This routine prints out each format-line of the buffer until the line |
| // is reached which contains the error position. That line is the last |
| // line printed. |
| // |
| // Then the next line output consists of a sequence of zero or more spaces |
| // and then a caret. This gives the appearance of the caret indicating |
| // where in the buffer's text the error has been detected. |
| // |
| // Finally, if there is even one more format-line in the buffer then |
| // a line is output saying "further output omitted," rather than actually |
| // continually printing the lines. |
| // |
| // A format-line is determined as follows. It is a line ending at a newline |
| // character. It is a line ending at the end of the buffer (that would |
| // be the last format-line of the buffer). It is a line that ends after |
| // running for some number of characters, MAX_FORMAT_LINE. Therefore, |
| // in effect, you can see that the final rule defining a format-line |
| // is due to the line-wrapping effect on a terminal or printer, and essentially |
| // inserts artificial linebreaks into the buffer. If the user doesn't |
| // like this, then the work around is to supply input that has newlines to |
| // the user's liking in the first place. |
| // |
| // Implementation Tricks: |
| // In the case that the input_pos was at the end of |
| // the buffer, we slide it back by a single character. This should have no |
| // ill-effects on the user detecting where the problem is, and it eliminates |
| // us having to specially handle this case beyond what we are doing here. |
| // |
| // The rest of the routine is fairly straightforward --- particularly if you |
| // read above about the purpose of this function. |
| |
| |
| void StoreSyntaxError(const char *input_str, Int32 input_pos, |
| ComDiagsArea& diags, Int32 dgStrNum, |
| CharInfo::CharSet input_str_cs, |
| CharInfo::CharSet terminal_cs) |
| { |
| if (!input_str) return; |
| |
| NAWchar wCharBuffer[ErrorMessage::MSG_BUF_SIZE+1]; // extra space for NULL |
| Int32 slen = strlen(input_str); |
| |
| Int32 input_pos_in_numOfNAWchars = input_pos; |
| if (input_str_cs != CharInfo::ISO88591) |
| { |
| // Compute to get the input position in number of NAWcharacters |
| enum cnv_charset eCnvCS = convertCharsetEnum((Int32)input_str_cs); |
| char * p1stUnstranslatedChar = NULL; |
| UInt32 outputOctetLen = 0; |
| UInt32 translatedCharCount = 0; |
| Int32 cnvErrStatus = LocaleToUTF16( |
| cnv_version1 // in - const enum cnv_version version |
| , input_str // in - const char *in_bufr |
| , input_pos // in - const int input_str_octet_len |
| , (const char *)wCharBuffer // out - const char *out_bufr |
| , ErrorMessage::MSG_BUF_SIZE * sizeof(NAWchar) // no NULL terminator |
| // in - const int out_bufr_max_octet_len |
| , eCnvCS // in - enum cnv_charset charset |
| , p1stUnstranslatedChar // out - char * & first_untranslated_char |
| , &outputOctetLen // out - unsigned int *output_data_len_p |
| , 0 // in - const int cnv_flags |
| , (const Int32)FALSE // in - const int addNullAtEnd_flag |
| , &translatedCharCount // out - unsigned int * translated_char_cnt_p |
| ); |
| if (outputOctetLen > 0) |
| input_pos_in_numOfNAWchars = (Int32)((outputOctetLen - 1) / sizeof(NAWchar)); |
| } |
| |
| Int32 ulen = LocaleStringToUnicode(input_str_cs, input_str, slen, |
| wCharBuffer, ErrorMessage::MSG_BUF_SIZE+1, TRUE); |
| |
| if ( ulen == 0 || ( input_str_cs == CharInfo::ISO88591 && ulen < slen ) ) |
| cerr << input_str << endl; |
| else |
| StoreSyntaxError(wCharBuffer, input_pos_in_numOfNAWchars, diags, dgStrNum, terminal_cs); |
| |
| } // StoreSyntaxError, single-byte version |
| |
| static const size_t MAX_FORMAT_LINE = 79; |
| static const size_t MAX_DGSTRING_SIZE = |
| MINOF(ErrorMessage::MSG_BUF_SIZE,1024) - MAX_FORMAT_LINE; |
| |
| void StoreSyntaxError(const NAWchar *input_str, Int32 input_pos, |
| ComDiagsArea& diags, Int32 dgStrNum, |
| CharInfo::CharSet charset) |
| { |
| if (!input_str) return; |
| |
| NAWString errMsg; |
| NABoolean internalError = FALSE; |
| |
| Int32 buffLen = na_wcslen(input_str); |
| if (buffLen == 0) { |
| errMsg.append(WIDE_("\n;\n^")); |
| } |
| else { |
| if (input_pos > buffLen) { |
| if (input_pos > buffLen+1) { |
| cerr << "*** StoreSyntaxError: (input_pos > buffLen): " |
| << input_pos << " " << buffLen; |
| internalError = TRUE; |
| } |
| input_pos = buffLen; |
| } |
| else if (input_pos < 0) |
| input_pos = 0; |
| |
| // in case there was any text prior on the current line |
| errMsg.append(WIDE_("\n")); // Start errMsg with a '\n' |
| const NAWchar *errPos = input_str+input_pos; |
| if (input_pos == buffLen) |
| errPos--; |
| |
| const NAWchar *right = input_str; |
| const NAWchar *left = NULL; |
| |
| while (errPos >= right) { |
| left = right; |
| size_t charCount = 0; |
| while ( 1 ) { |
| charCount++; |
| right++; |
| if (*right == '\n' || |
| *right == 0 || |
| charCount == MAX_FORMAT_LINE) |
| break; |
| } |
| |
| // At this point, *right is a null char, a newline char, or |
| // the char at (MAX_FORMAT_LINE+1). We want to print the chars |
| // from left up to but not include right. That's very easy to write |
| // as a loop! Then, we want to output a newline char. Finally, |
| // if (*right == newline char) then increment right. |
| // |
| // We are careful not to touch (left) in here because we may need |
| // it later in order to determine the number of chars to space over |
| // from the start of the final line to where the caret belongeth. |
| |
| // 3/20/98: Replaced this codeblock: |
| // const char *currency = left; |
| // while (currency != right) |
| // errMsg << *currency++; |
| // with this: |
| errMsg.append(left, right - left); |
| errMsg.append(WIDE_("\n")); |
| |
| if (*right == '\n') |
| right++; |
| } |
| // The number given by (errPos - left) tells us exactly how many |
| // characters we must space over before printing the caret. |
| // We print the spaces, the caret, and then a newline. |
| { |
| |
| size_t charCount = errPos - left; |
| assert(charCount < MAX_FORMAT_LINE); |
| |
| // 3/20/98: Since the WCHAR version of the SQl text can contain |
| // half or full width characters, we need to get the exact length |
| // of the last WCHAR string segment in current locale, then pump that |
| // many of WCHAR space characters into the buffer. |
| // Assumption: the fonts used are fixed width! |
| // Thus, replaced this codeblock: |
| // while (charCount-- != 0) |
| // errMsg << ' '; |
| // with this: |
| |
| char bufferInLocale[(MAX_FORMAT_LINE+1)*8]; // allow for utf8 characters |
| Int32 byteCount = UnicodeStringToLocale(charset, (NAWchar*)left, charCount, |
| bufferInLocale, (MAX_FORMAT_LINE+1)*8 |
| ); |
| |
| |
| for (Int32 i=0; i<byteCount; i++) |
| errMsg.append(WIDE_(" ")); |
| |
| errMsg.append(WIDE_("^ (")); |
| char bytestr_str[10]; |
| // get the size of the error offset as a string input_pos is 0 based |
| str_itoa( input_pos+1, bytestr_str); |
| NAWString wBytestr_str(CharInfo::ISO88591,bytestr_str); |
| errMsg.append(wBytestr_str); |
| errMsg.append(L" characters from start of SQL statement)"); |
| } |
| |
| // Don't do this; it looks crappy: |
| //if (right-input_str != buffLen) |
| // errMsg << endl << "..."; // to indicate rest of SQL stmt not shown |
| } |
| |
| NAWchar * const entireBuf = (NAWchar *)errMsg.data(); |
| NAWchar *diagBuf = entireBuf; |
| |
| // If this is too big, truncate to fit. |
| // Align to next newline if at least two complete lines will still appear. |
| // |
| size_t len = errMsg.length(); |
| if (len > MAX_DGSTRING_SIZE) |
| { |
| diagBuf += len - MAX_DGSTRING_SIZE; |
| NAWchar *newline = na_wcschr(diagBuf, L'\n'); |
| if (newline && na_wcschr(newline, L'\n')) |
| diagBuf = newline; // Start errMsg with a '\n' |
| else |
| diagBuf[0] = L'\n'; // Start errmsg with a '\n' |
| diagBuf[1] = L'.'; // Interpolate an ellipsis |
| diagBuf[2] = L'.'; |
| diagBuf[3] = L'.'; |
| } |
| |
| // convert tabs (but not newlines) to spaces so the caret aligns correctly |
| for (NAWchar *d = diagBuf; *d; d++) |
| if (*d == NAWchar('\t')) |
| *d = ' '; |
| |
| if (dgStrNum == 0) |
| diags << DgWString0(diagBuf); |
| else |
| diags << DgWString1(diagBuf); |
| |
| if (internalError) { |
| |
| char bufferInLocale[MAX_DGSTRING_SIZE]; |
| Lng32 len = UnicodeStringToLocale(charset, entireBuf, na_wcslen(entireBuf), |
| bufferInLocale, MAX_DGSTRING_SIZE |
| ); |
| |
| if (len>0) { |
| cerr << bufferInLocale << endl; |
| } |
| } |
| |
| } // StoreSyntaxError, Unicode version |
| |
