path390.cpp

来自「IBM的解析xml的工具Xerces的源代码」· C++ 代码 · 共 568 行 · 第 1/2 页

/*
 * Copyright 2002,2004 The Apache Software Foundation.
 * 
 * Licensed 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.
 */

/*
 * $Id: Path390.cpp,v 1.3 2004/09/08 13:56:41 peiyongz Exp $
 */

//#include "stdafx.h"
#include <fstream.h>
#include <stdio.h>
#include <ctype.h>
#include <typeinfo>
#define _XOPEN_SOURCE_EXTENDED 1
#include <stdlib.h>
#include <string.h>
#include "Path390.hpp"
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/framework/MemoryManager.hpp>


XERCES_CPP_NAMESPACE_BEGIN

//Constructors:
Path390::Path390() {
   _error = 0;
   _absolute = false;
   _dsnabsolute = false;
   _parsestate=PARSE_NONE;
   _orgparms=0;
   _resultpath=0;
   _orgpath=0;
}
Path390::Path390(char * s) {
   _error = 0;
   _absolute = false;
   _dsnabsolute = false;
   _parsestate=PARSE_NONE;
   _orgparms=0;
   _resultpath=0;
   _orgpath=0;
   setPath(s);
}


//Destructor:
Path390::~Path390() {
   if (_orgparms)
      XMLPlatformUtils::fgMemoryManager->deallocate(_orgparms);//free (_orgparms);
   if (_resultpath)
      XMLPlatformUtils::fgMemoryManager->deallocate(_resultpath);//free(_resultpath);
   if (_orgpath)
      XMLPlatformUtils::fgMemoryManager->deallocate(_orgpath);//free(_orgpath);
}

// This path parser is state driven in order to support an incremental parse of the input path.
// This is so that, for example, someone only wants to determine whether the path is absolute or
// relative, then it will only parse sufficient information to determine this. This information
// is saved in the object so that this does not need to be re-parsed if later one wanted to
// retrieve, for example, the parameters.
// The states are:
//    PARSE_NONE - initial state, nothing is parsed.
//    PARSE_ABSOLUTE_URI - Absolute or relative path has been determined.
//    PARSE_PATHTYPE - The type of the path has been determined
//    PARSE_PUNCT - The important delimiters have been located to make later parsing simpler.
//    PARSE_PARMS - The parms have been located and retrieved.
//    PARSE_PARSED - The path has been fully parsed.
//
// Each of the following methods handle the parsing corresponding to each state.
//




// Determine if the path is absolute or relative.
void Path390::_determine_uri_abs() {
   if (_parsestate == PARSE_NONE) {
      if (*_curpos == '/') {
         _uriabsolute=true;
         _curpos++;
      } else
         _uriabsolute=false;
      _parsestate = PARSE_ABSOLUTE_URI;
   }
}


// Determine the path type. This could be:
//    PATH390_HFS - format is hfs:/xxx/xxx...
//    PATH390_DSN1 - format is dsn:/xxx/xxx...
//    PATH390_DSN2 - format is dsn://xxxxx...
//    PATH390_DD - format is dd:xxx...
//    PATH390_OTHER - format is any other paths.
void Path390::_determine_type() {
   char firstfour[5];
   if (_parsestate == PARSE_ABSOLUTE_URI) {
      char * ff=firstfour;
      int ffi=0;
      while ((_curpos[ffi]) && (ffi<4)) {ff[ffi] = toupper(_curpos[ffi]); ffi++;}

      if ( (ffi>=4) && !strncmp(firstfour,"DSN:",4) ) {
         _pathtype = PATH390_DSN1;
         _curpos+=4;
         _absolute = true;
         if ( ((*_curpos) && (*_curpos == '/')) && ((*(_curpos+1)) && (*(_curpos+1) == '/')) ) {
            _pathtype = PATH390_DSN2;
            }
         }
      else if ( (ffi>=4) && !strncmp(firstfour,"HFS:",4) ) {
         _pathtype = PATH390_HFS;
         _curpos+=4;
         if (*_curpos == '/')
            _absolute = true;
         else
            _absolute = false;
         }
      else if ( (ffi>=3) && !strncmp(firstfour,"DD:",3) ) {
         _absolute = true;
         _pathtype = PATH390_DD;
         _curpos+=3;
         }
      else {
         _pathtype = PATH390_OTHER;
         if (_uriabsolute)
            _curpos--;
         }
      _parsestate = PARSE_PATHTYPE;
   }
}

// This takes one pass through the path any determines the location of important delimiters
// including / ; . and (
// It will also detect some error conditions
void Path390::_determine_punct() {

   if (_parsestate == PARSE_PATHTYPE) {
      char * source = _curpos;
      _lastsemi = 0;
      _lastslash = 0;
      _lastparen = 0;
      _parmStart = 0;
      _pathEnd = 0;
      _numperiods = 0;
      _numsemicolons = 0;
      _extStart = 0;
      while (*source) {
         switch (*source) {
            case ';':
               _lastsemi = source;
               _parmStart = source+1;
               _numsemicolons++;
               break;
            case '/':
               _lastslash = source;
               _pathEnd = source;
               break;
            case '.':
               _extStart = source+1;
               _numperiods++;
               break;
            case '(':
               _lastparen = source+1;
               break;
         }
         *source++;
      }
      if ( (_parmStart) && (_parmStart<=_pathEnd) ) {
         _error = ERROR_SEMICOLON_NOT_ALLOWED;
         _lastsemi = 0;
         _parmStart = 0;
      }
      if ( ((_pathtype == PATH390_DD) || (_pathtype == PATH390_DSN1) || (_pathtype == PATH390_DSN1)) &&
           (_extStart <= _pathEnd) ) {
         if (_extStart)
            _error = ERROR_PERIOD_NOT_ALLOWED;
         _extStart = 0;
      }
      if (_extStart < _lastparen)
         _extStart = 0;
      _parsestate = PARSE_PUNCT;
   }
}

// This extracts the parameters from the path if there are any. It also determines if the parameters
// contain type=record
void Path390::_determine_parms() {

   if (_parsestate == PARSE_PUNCT) {
      char * tr = 0;
      if (_parmStart) {
         _orgparmlen = strlen(_parmStart)+1;
         _orgparms = (char*) XMLPlatformUtils::fgMemoryManager->allocate(_orgparmlen * sizeof(char));// (char *) malloc(_orgparmlen);
         char * ts=_parmStart;
         char * td=_orgparms;
         while (*ts)
           *td++ = tolower(*ts++);
         *td = 0;
         *_lastsemi = 0;
         tr = strstr(_orgparms,"type=record");
      }
      if (tr)
        _typerecord = tr - _orgparms;
      else
        _typerecord = -1;

      _parsestate = PARSE_PARMS;
   }
}

// Complete the rest of the parse.
void Path390::_parse_rest() {

   if (_parsestate == PARSE_PARMS) {
      char *source;
      char *dest;
      char * filename_start;
      char * tmpPos;
      int pathlen = strlen(_curpos);
      _resultpath = (char*) XMLPlatformUtils::fgMemoryManager->allocate((pathlen+10) * sizeof(char));//(char *) malloc(pathlen+10);

      source = _curpos;
      dest = _resultpath;

      switch (_pathtype) {
         case PATH390_DSN1:
            // This format needs to be mangled from a hierarchical (hfs style) path to the
            // traditional MVS format. First check for some errors.
            if (_lastparen) {
               _error = ERROR_NO_PAREN_ALLOWED;
               break;
            }

            if ((_uriabsolute) && (!_absolute)) {
               _error = ERROR_ABS_PATH_REQUIRED;
               break;
            }

            if ( ((_extStart) && (_numperiods > 1)) ||
                 ((!_extStart) && (_numperiods)) ) {
               _error = ERROR_NO_EXTRA_PERIODS_ALLOWED;
               break;
            }

            if ( ((_parmStart) && (_numsemicolons > 1)) ||
                 ((!_parmStart) && (_numsemicolons)) ) {
               _error = ERROR_NO_EXTRA_SEMIS_ALLOWED;
               break;
            }

            // start out the result with //
            *dest++ = '/';
            *dest++ = '/';
            // If the input path starts with a / then it is absolute and it must be
            // enclosed in 's
            _dsnabsolute = false;
            if (*source == '/') {
              _dsnabsolute = true;
              source++;
            } else if (_uriabsolute) {
               _error = ERROR_MUST_BE_ABSOLUTE;
               break;
            }

            char * pathstart;
            pathstart = source;

            // Add in the ' if this is an absolute path'
            if (_dsnabsolute) *dest++ = '\'';

            // If there is a / in the path....
            tmpPos = source;