Return to parser.h CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Compiler

BUG#: 4573

TITLE: cimmof include file search path processing is inadequate

DESCRIPTION: changed the include file search processing logic.
  The new procssing is based on the include file processing
  behaviour used by the C compiler.

      The search path for included files previously was:
          1. try to open the file in the current working directory.
          2. process the include path array from the cimof(l) cmdline
             processing which always include "dot" as a default search
             path and then any paths specified on the command line
             with the -I option.

      The search path for included files now is:
          1. try to open the file in the same directory as the current
             file being processed.
          2. process the include path array from the cimof(l) cmdline
             processing which only includes paths specified on the
             command line with the -I option.

//%2005////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation, The Open Group.
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; VERITAS Software Corporation; The Open Group.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//==============================================================================
//
// Author: Bob Blair (bblair@bmc.com)
//
// Modified By:
//              Jim Wunderlich (Jim_Wunderlich@prodigy.net)
//
//%/////////////////////////////////////////////////////////////////////////////


//
// Header for a class to generate CIMValue objects from String values
//
//
//
// This is a generic parser class from which controllers for particular
// yacc parsers can be derived.  It keeps enough state information that
// you should be able to get by without a reentrant parser.  You should
// compile both parser and lexer with a C++ compiler, although there
// is no need to generate a C++ lexer.
//
// The include file and compile-from-String techniques used here are
// supported only by bison and flex.
//

#ifndef _PARSER_H_
#define _PARSER_H_

#include <Pegasus/Common/Config.h>
#include <cstdio>
#include <Pegasus/Common/String.h>
#include <Pegasus/Common/Stack.h>
#include <Pegasus/Compiler/Linkage.h>
#include <Pegasus/Common/FileSystem.h>


PEGASUS_USING_STD;
PEGASUS_USING_PEGASUS;

#define CIMMOF_CONSTANT_VALUE  1
#define CIMMOF_ARRAY_VALUE     2
#define CIMMOF_REFERENCE_VALUE 3
#define CIMMOF_NULL_VALUE      4

// #define  DEBUG_INCLUDE // enables include file processing debug printout

typedef struct typedInitializerValue {
    Uint16 type;
    const String *value;
    } TYPED_INITIALIZER_VALUE;

struct bufstate {
	void *buffer_state; // the YY_BUFFER_STATE of the stacked context
	String filename;    // the name of the file open in the stacked context
	int    lineno;      // the line number of the file
	String filenamePath; //the path of the file open in the stacked context
};

class PEGASUS_COMPILER_LINKAGE  parser {
 private:
  unsigned int _buffer_size;   // the value of the YY_BUFFER_SIZE macro
  Stack<bufstate*> _include_stack;  // a stack of YY_BUFFER_STATEs
  String _current_filename; // name of the file being parsed
  unsigned int _lineno;     // current line number in the file 
  String _current_filenamePath; // path of the file being parsed
 protected:
  void push_statebuff(bufstate *statebuff) { _include_stack.push(statebuff); }
  bufstate *pop_statebuff();
 public:

  // Constructor, destructor
  parser() : _buffer_size(16384), _lineno(0) {;}
  virtual ~parser() {;}

  virtual int parse() = 0;    // call the parser main yy_parse()
  virtual int wrap();         // handle the end of the current stream

  int setInputBufferFromName(const String &filename); // start parsing this file
  virtual int setInputBuffer(const FILE *f, 
                       Boolean closeCurrent) = 0;  // start parsing this handle
  //  int setInputBuffer(const char *buf);   // start parsing this String
  virtual int setInputBuffer(void *buffstate,
                       Boolean closeCurrent) = 0; // start parsing this buffer

  // given a file stream, treat it as an include file
  virtual int enterInlineInclude(const FILE *f) = 0;
  virtual int wrapCurrentBuffer() = 0;

  unsigned int get_buffer_size() { return _buffer_size; }
  void set_buffer_size(unsigned int siz) { _buffer_size = siz; }

  // We keep track of the filename associated with the current input
  // buffer so we can report on it.
  void set_current_filename(const String &filename)
  	{ 
	  _current_filename = filename;

#ifdef DEBUG_INCLUDE
	  cout << "cimmof parser - setting path = " << get_current_filenamePath() << endl; // DEBUG
#endif // DEBUG_INCLUDE

	  String includePathTemp = FileSystem::extractFilePath(filename);
	  
	  // ************************************************************
	  // if the filename path consisted of just the file name 
	  // becasue it is in the current directory then extractFilePath
	  // returns just the filename rather than "dot". The following 
	  // test is to prevent adding file names to the include path.
	  // ****************************************************************
	  if (includePathTemp == filename)
	    {
	      includePathTemp = ".";
	    }

	    set_current_filenamePath(includePathTemp);	  

#ifdef DEBUG_INCLUDE
	    cout << "cimmof parser set filename = " << filename 
                 << " include path = " << get_current_filenamePath()
		 << endl; // DEBUG
#endif //  DEBUG_INCLUDE
	}

  const String &get_current_filename() const { return _current_filename; }

  // We keep track of the filename path associated with the current input
  // buffer so we can use it to search for include files in that same directory
  void set_current_filenamePath(const String &filenamePath)
  	{ _current_filenamePath = filenamePath; }

  const String &get_current_filenamePath() const { return _current_filenamePath; }

  // Ditto the line number
  void set_lineno(int n) { _lineno = n; }
  void increment_lineno() { ++_lineno; }
  unsigned int get_lineno() const { return _lineno; }

  // This is the main entry point for parser error logging
  virtual void log_parse_error(char *token, const char *errmsg) const;
};
#endif