/afs/cs.wisc.edu/u/n/w/nwilliam/private/workspace/Quut/src/parser/SqlScanner.h

//
// Author: Jignesh M. Patel
//         EECS Department, University of Michigan
// Date:   August 2000
//

#ifndef SQL_SCANNER_H
#define SQL_SCANNER_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

extern void yyerror(const char*);

// TODO: Remove these global defines - JmP
#define PxxSCAN_MAXCHAR 1024  // size of buffer of strings
#define PxxSCAN_NPARAM  20    // max params per function (unused)

// Class encapsulating the Scanner support routines
class PxxScanner
{
private:
   char           _tokBuf[PxxSCAN_MAXCHAR];   // SQL token buffer, which also limits the size of the SQL query string
   unsigned int   _tokptr;                    // Pointer to current token area in tokBuf.
   char*          _varnames[PxxSCAN_NPARAM];  // Parameter names 
   bool           _debug;
   bool           _quit;
   bool           _verbose;
   
public: 
   
   PxxScanner() { Reset(); _debug = false;}
   
   void Reset()
   {
      _tokptr = 0;
      _quit = false;
      _verbose = false;
      // if (yyin) yyrestart(yyin);
   }   
   
   //
   // lcaseNcopy: copies src to dst, converting it to lowercase, stopping at the
   // end of src or after max characters.
   //
   // Returns: the length of dst (which may be less than the length of src, if src is too long).
   //
   int LcaseNcopy(char *dst, char *src, int max)
   {
      int len;
      
      for(len = 0; len < max && src[len] != '\0'; ++len) 
      {
         dst[len] = src[len];
         if (src[len] >= 'A' && src[len] <= 'Z') dst[len] += 'a' - 'A';
      }
      dst[len] = '\0';
      
      return len;
   }
   
   // Save the SQL Text
   char* SaveText(char *s, int slen, bool lower=false)
   {
      // Check if we have enough buffer area to hold this token.
      if (_tokptr+slen > PxxSCAN_MAXCHAR-1)
      {
         yyerror("Not enough buffer space");
         exit (1);
      }
      
      if (lower)
      {
         LcaseNcopy(_tokBuf+_tokptr, s, slen);
      }
      else
      {
         strncpy(_tokBuf+_tokptr, s, slen);
         _tokBuf[_tokptr+slen] = '\0';
      }
      
      if (_debug)
      {
         int i;
         for (i=0; i<PxxSCAN_MAXCHAR; i++) 
            if (_tokBuf[i] == '\0') std::cout << "- ";
            else                    std::cout << _tokBuf[i] << " ";
            std::cout << std::endl;
      }
      
      char* retStr = _tokBuf + _tokptr;
      _tokptr += slen+1;
      return retStr;
   }

   // Save the quoted string
   char* SaveQuotedText(char *qstring, int slen, bool lower=false)
   {  
      // copy everything following beginning quote
      return SaveText(qstring+1, slen-2, lower);
   }
   
   // Save a parameter reference  (unused until we use SQL Parameters)
   char* SaveParam(char *n)
   {
      int i;
      char pbuf[10];
      
      // look up the variable name in the table
      for(i = 1; i < PxxSCAN_NPARAM; i++) {
         if(!_varnames[i]) {
            // not there, enter it
            _varnames[i] = strdup(n);
            break;
         }
         
         if(!strcmp(_varnames[i],n))
            break; //already present
      }
      
      if(i >= PxxSCAN_NPARAM) {
         yyerror("Too many parameter references");
         exit(1);
      }
      
      // save #n referece by variable number
      sprintf(pbuf, " #%d", i);
      return SaveText(pbuf, strlen (pbuf) );    
   }      

   void SetVerbose(bool onoff) {_verbose = onoff;}
   void TriggerQuit() {_quit = true;}
   bool Quitting() {return _quit;}

   void PrintQuery() const
   {
      if (_verbose)
      {
         std::cout << "Query: ";
         unsigned i;
         bool space = false;
         for (i=0; i<_tokptr; i++)
            if (_tokBuf[i] == '\0') { std::cout << ""; }
            else if (_tokBuf[i] == '\t' || _tokBuf[i] == '\n' || _tokBuf[i] == ' ')  
                 { 
                    // deal with whitespace
                    if (!space) std::cout << " ";
                    space = true;
                 }
            else 
            {
               std::cout << _tokBuf[i];
               space = false;
            }
      }
      std::cout << std::endl;
   }
};

#endif