/*============================================================================
  CMake - Cross Platform Makefile Generator
  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium

  Distributed under the OSI-approved BSD License (the "License");
  see accompanying file Copyright.txt for details.

  This software is distributed WITHOUT ANY WARRANTY; without even the
  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  See the License for more information.
============================================================================*/

#include "cmCTestMemCheckHandler.h"
#include "cmXMLParser.h"
#include "cmCTest.h"
#include "cmake.h"
#include "cmGeneratedFileStream.h"
#include <cmsys/Process.h>
#include <cmsys/RegularExpression.hxx>
#include <cmsys/Base64.h>
#include <cmsys/Glob.hxx>
#include <cmsys/FStream.hxx>
#include "cmMakefile.h"
#include "cmXMLSafe.h"

#include <stdlib.h>
#include <math.h>
#include <float.h>

struct CatToErrorType
{
  const char* ErrorCategory;
  int ErrorCode;
};


static CatToErrorType cmCTestMemCheckBoundsChecker[] = {
  // Error tags
  {"Write Overrun", cmCTestMemCheckHandler::ABW},
  {"Read Overrun",  cmCTestMemCheckHandler::ABR},
  {"Memory Overrun", cmCTestMemCheckHandler::ABW},
  {"Allocation Conflict",  cmCTestMemCheckHandler::FMM},
  {"Bad Pointer Use", cmCTestMemCheckHandler::FMW},
  {"Dangling Pointer", cmCTestMemCheckHandler::FMR},
  {0,0}
};

static void xmlReportError(int line, const char* msg, void* data)
{
  cmCTest* ctest = (cmCTest*)data;
  cmCTestLog(ctest, ERROR_MESSAGE,
             "Error parsing XML in stream at line "
             << line << ": " << msg << std::endl);
}

// parse the xml file containing the results of last BoundsChecker run
class cmBoundsCheckerParser : public cmXMLParser
{
public:
  cmBoundsCheckerParser(cmCTest* c)
    {
      this->CTest = c;
      this->SetErrorCallback(xmlReportError, (void*)c);
    }
  void StartElement(const std::string& name, const char** atts)
    {
      if(name == "MemoryLeak" ||
         name == "ResourceLeak")
        {
        this->Errors.push_back(cmCTestMemCheckHandler::MLK);
        }
      else if(name == "Error" ||
              name == "Dangling Pointer")
        {
        this->ParseError(atts);
        }
      // Create the log
      cmOStringStream ostr;
      ostr << name << ":\n";
      int i = 0;
      for(; atts[i] != 0; i+=2)
        {
        ostr << "   " << cmXMLSafe(atts[i])
             << " - " << cmXMLSafe(atts[i+1]) << "\n";
        }
      ostr << "\n";
      this->Log += ostr.str();
    }
  void EndElement(const std::string& )
    {
    }

  const char* GetAttribute(const char* name, const char** atts)
    {
      int i = 0;
      for(; atts[i] != 0; ++i)
        {
        if(strcmp(name, atts[i]) == 0)
          {
          return atts[i+1];
          }
        }
      return 0;
    }
  void ParseError(const char** atts)
    {
      CatToErrorType* ptr = cmCTestMemCheckBoundsChecker;
      const char* cat = this->GetAttribute("ErrorCategory", atts);
      if(!cat)
        {
        this->Errors.push_back(cmCTestMemCheckHandler::ABW); // do not know
        cmCTestLog(this->CTest, ERROR_MESSAGE,
                   "No Category found in Bounds checker XML\n" );
        return;
        }
      while(ptr->ErrorCategory && cat)
        {
        if(strcmp(ptr->ErrorCategory, cat) == 0)
          {
          this->Errors.push_back(ptr->ErrorCode);
          return; // found it we are done
          }
        ptr++;
        }
      if(ptr->ErrorCategory)
        {
        this->Errors.push_back(cmCTestMemCheckHandler::ABW); // do not know
        cmCTestLog(this->CTest, ERROR_MESSAGE,
                   "Found unknown Bounds Checker error "
                   << ptr->ErrorCategory << std::endl);
        }
    }
  cmCTest* CTest;
  std::vector<int> Errors;
  std::string Log;
};

#define BOUNDS_CHECKER_MARKER \
"******######*****Begin BOUNDS CHECKER XML******######******"



//----------------------------------------------------------------------
cmCTestMemCheckHandler::cmCTestMemCheckHandler()
{
  this->MemCheck = true;
  this->CustomMaximumPassedTestOutputSize = 0;
  this->CustomMaximumFailedTestOutputSize = 0;
  this->LogWithPID = false;
}

//----------------------------------------------------------------------
void cmCTestMemCheckHandler::Initialize()
{
  this->Superclass::Initialize();
  this->LogWithPID = false;
  this->CustomMaximumPassedTestOutputSize = 0;
  this->CustomMaximumFailedTestOutputSize = 0;
  this->MemoryTester = "";
  this->MemoryTesterDynamicOptions.clear();
  this->MemoryTesterOptions.clear();
  this->MemoryTesterStyle = UNKNOWN;
  this->MemoryTesterOutputFile = "";
}

//----------------------------------------------------------------------
int cmCTestMemCheckHandler::PreProcessHandler()
{
  if ( !this->InitializeMemoryChecking() )
    {
    return 0;
    }

  if ( !this->ExecuteCommands(this->CustomPreMemCheck) )
    {
    cmCTestLog(this->CTest, ERROR_MESSAGE,
      "Problem executing pre-memcheck command(s)." << std::endl);
    return 0;
    }
  return 1;
}

//----------------------------------------------------------------------
int cmCTestMemCheckHandler::PostProcessHandler()
{
  if ( !this->ExecuteCommands(this->CustomPostMemCheck) )
    {
    cmCTestLog(this->CTest, ERROR_MESSAGE,
      "Problem executing post-memcheck command(s)." << std::endl);
    return 0;
    }
  return 1;
}

//----------------------------------------------------------------------
void cmCTestMemCheckHandler::GenerateTestCommand(
  std::vector<std::string>& args, int test)
{
  std::vector<std::string>::size_type pp;
  std::string index;
  cmOStringStream stream;
  std::string memcheckcommand
    = cmSystemTools::ConvertToOutputPath(this->MemoryTester.c_str());
  stream << test;
  index = stream.str();
  for ( pp = 0; pp < this->MemoryTesterDynamicOptions.size(); pp ++ )
    {
    std::string arg = this->MemoryTesterDynamicOptions[pp];
    std::string::size_type pos = arg.find("??");
    if (pos != std::string::npos)
      {
      arg.replace(pos, 2, index);
      }
    args.push_back(arg);
    memcheckcommand += " \"";
    memcheckcommand += arg;
    memcheckcommand += "\"";
    }
  // Create a copy of the memory tester environment variable.
  // This is used for memory testing programs that pass options
  // via environment varaibles.
  std::string memTesterEnvironmentVariable =
    this->MemoryTesterEnvironmentVariable;
  for ( pp = 0; pp < this->MemoryTesterOptions.size(); pp ++ )
    {
    if(memTesterEnvironmentVariable.size())
      {
      // If we are using env to pass options, append all the options to
      // this string with space separation.
      memTesterEnvironmentVariable += " " + this->MemoryTesterOptions[pp];
      }
    // for regular options just add them to args and memcheckcommand
    // which is just used for display
    else
      {
      args.push_back(this->MemoryTesterOptions[pp]);
      memcheckcommand += " \"";
      memcheckcommand += this->MemoryTesterOptions[pp];
      memcheckcommand += "\"";
      }
    }
  // if this is an env option type, then add the env string as a single
  // argument.
  if(memTesterEnvironmentVariable.size())
    {
    std::string::size_type pos = memTesterEnvironmentVariable.find("??");
    if (pos != std::string::npos)
      {
      memTesterEnvironmentVariable.replace(pos, 2, index);
      }
    memcheckcommand += " " + memTesterEnvironmentVariable;
    args.push_back(memTesterEnvironmentVariable);
    }
  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Memory check command: "
    << memcheckcommand << std::endl);
}

//----------------------------------------------------------------------
void cmCTestMemCheckHandler::InitializeResultsVectors()
{
  // fill these members
//  cmsys::vector<std::string> ResultStrings;
//  cmsys::vector<std::string> ResultStringsLong;
//  cmsys::vector<int>         GlobalResults;
  this->ResultStringsLong.clear();
  this->ResultStrings.clear();
  this->GlobalResults.clear();
  // If we are working with style checkers that dynamically fill
  // the results strings then return.
  if(this->MemoryTesterStyle > cmCTestMemCheckHandler::BOUNDS_CHECKER)
    {
    return;
    }

  // define the standard set of errors
  //----------------------------------------------------------------------
  static const char* cmCTestMemCheckResultStrings[] = {
    "ABR",
    "ABW",
    "ABWL",
    "COR",
    "EXU",
    "FFM",
    "FIM",
    "FMM",
    "FMR",
    "FMW",
    "FUM",
    "IPR",
    "IPW",
    "MAF",
    "MLK",
    "MPK",
    "NPR",
    "ODS",
    "PAR",
    "PLK",
    "UMC",
    "UMR",
    0
  };
//----------------------------------------------------------------------
  static const char* cmCTestMemCheckResultLongStrings[] = {
    "Threading Problem",
    "ABW",
    "ABWL",
    "COR",
    "EXU",
    "FFM",
    "FIM",
    "Mismatched deallocation",
    "FMR",
    "FMW",
    "FUM",
    "IPR",
    "IPW",
    "MAF",
    "Memory Leak",
    "Potential Memory Leak",
    "NPR",
    "ODS",
    "Invalid syscall param",
    "PLK",
    "Uninitialized Memory Conditional",
    "Uninitialized Memory Read",
    0
  };
  this->GlobalResults.clear();
  for(int i =0; cmCTestMemCheckResultStrings[i] != 0; ++i)
    {
    this->ResultStrings.push_back(cmCTestMemCheckResultStrings[i]);
    this->ResultStringsLong.push_back(cmCTestMemCheckResultLongStrings[i]);
    this->GlobalResults.push_back(0);
    }
}

//----------------------------------------------------------------------
void cmCTestMemCheckHandler::PopulateCustomVectors(cmMakefile *mf)
{
  this->cmCTestTestHandler::PopulateCustomVectors(mf);
  this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_PRE_MEMCHECK",
                                this->CustomPreMemCheck);
  this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_POST_MEMCHECK",
                                this->CustomPostMemCheck);

  this->CTest->PopulateCustomVector(mf,
                             "CTEST_CUSTOM_MEMCHECK_IGNORE",
                             this->CustomTestsIgnore);
  std::string cmake = cmSystemTools::GetCMakeCommand();
  this->CTest->SetCTestConfiguration("CMakeCommand", cmake.c_str());
}

//----------------------------------------------------------------------
void cmCTestMemCheckHandler::GenerateDartOutput(std::ostream& os)
{
  if ( !this->CTest->GetProduceXML() )
    {
    return;
    }
  this->CTest->StartXML(os, this->AppendXML);
  os << "<DynamicAnalysis Checker=\"";
  switch ( this->MemoryTesterStyle )
    {
    case cmCTestMemCheckHandler::VALGRIND:
      os << "Valgrind";
      break;
    case cmCTestMemCheckHandler::PURIFY:
      os << "Purify";
      break;
    case cmCTestMemCheckHandler::BOUNDS_CHECKER:
      os << "BoundsChecker";
      break;
    case cmCTestMemCheckHandler::ADDRESS_SANITIZER:
      os << "AddressSanitizer";
      break;
    case cmCTestMemCheckHandler::THREAD_SANITIZER:
      os << "ThreadSanitizer";
      break;
    case cmCTestMemCheckHandler::MEMORY_SANITIZER:
      os << "MemorySanitizer";
      break;
    case cmCTestMemCheckHandler::UB_SANITIZER:
      os << "UndefinedBehaviorSanitizer";
      break;
    default:
      os << "Unknown";
    }
  os << "\">" << std::endl;

  os << "\t<StartDateTime>" << this->StartTest << "</StartDateTime>\n"
     << "\t<StartTestTime>" << this->StartTestTime << "</StartTestTime>\n"
     << "\t<TestList>\n";
  cmCTestMemCheckHandler::TestResultsVector::size_type cc;
  for ( cc = 0; cc < this->TestResults.size(); cc ++ )
    {
    cmCTestTestResult *result = &this->TestResults[cc];
    std::string testPath = result->Path + "/" + result->Name;
    os << "\t\t<Test>" << cmXMLSafe(
      this->CTest->GetShortPathToFile(testPath.c_str()))
      << "</Test>" << std::endl;
    }
  os << "\t</TestList>\n";
  cmCTestLog(this->CTest, HANDLER_OUTPUT,
    "-- Processing memory checking output: ");
  size_t total = this->TestResults.size();
  size_t step = total / 10;
  size_t current = 0;
  for ( cc = 0; cc < this->TestResults.size(); cc ++ )
    {
    cmCTestTestResult *result = &this->TestResults[cc];
    std::string memcheckstr;
    std::vector<int> memcheckresults(this->ResultStrings.size(), 0);
    bool res = this->ProcessMemCheckOutput(result->Output, memcheckstr,
      memcheckresults);
    if ( res && result->Status == cmCTestMemCheckHandler::COMPLETED )
      {
      continue;
      }
    this->CleanTestOutput(memcheckstr,
      static_cast<size_t>(this->CustomMaximumFailedTestOutputSize));
    this->WriteTestResultHeader(os, result);
    os << "\t\t<Results>" << std::endl;
    for(std::vector<int>::size_type kk = 0;
        kk < memcheckresults.size(); ++kk)
      {
      if ( memcheckresults[kk] )
        {
        os << "\t\t\t<Defect type=\"" << this->ResultStringsLong[kk]
          << "\">"
           << memcheckresults[kk]
           << "</Defect>" << std::endl;
        }
      this->GlobalResults[kk] += memcheckresults[kk];
      }

    std::string logTag;
    if(this->CTest->ShouldCompressMemCheckOutput())
      {
      this->CTest->CompressString(memcheckstr);
      logTag = "\t<Log compression=\"gzip\" encoding=\"base64\">\n";
      }
    else
      {
      logTag = "\t<Log>\n";
      }

    os
      << "\t\t</Results>\n"
      << logTag << cmXMLSafe(memcheckstr) << std::endl
      << "\t</Log>\n";
    this->WriteTestResultFooter(os, result);
    if ( current < cc )
      {
      cmCTestLog(this->CTest, HANDLER_OUTPUT, "#" << std::flush);
      current += step;
      }
    }
  cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
  cmCTestLog(this->CTest, HANDLER_OUTPUT, "Memory checking results:"
    << std::endl);
  os << "\t<DefectList>" << std::endl;
  for ( cc = 0; cc < this->GlobalResults.size(); cc ++ )
    {
    if ( this->GlobalResults[cc] )
      {
#ifdef cerr
#  undef cerr
#endif
      std::cerr.width(35);
#define cerr no_cerr
      cmCTestLog(this->CTest, HANDLER_OUTPUT,
        this->ResultStringsLong[cc] << " - "
        << this->GlobalResults[cc] << std::endl);
      os << "\t\t<Defect Type=\"" << this->ResultStringsLong[cc]
        << "\"/>" << std::endl;
      }
    }
  os << "\t</DefectList>" << std::endl;

  os << "\t<EndDateTime>" << this->EndTest << "</EndDateTime>" << std::endl;
  os << "\t<EndTestTime>" << this->EndTestTime
     << "</EndTestTime>" << std::endl;
  os << "<ElapsedMinutes>"
     << static_cast<int>(this->ElapsedTestingTime/6)/10.0
     << "</ElapsedMinutes>\n";

  os << "</DynamicAnalysis>" << std::endl;
  this->CTest->EndXML(os);
}

//----------------------------------------------------------------------
bool cmCTestMemCheckHandler::InitializeMemoryChecking()
{
  this->MemoryTesterEnvironmentVariable = "";
  this->MemoryTester = "";
  // Setup the command
  if ( cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
        "MemoryCheckCommand").c_str()) )
    {
    this->MemoryTester
      = this->CTest->GetCTestConfiguration("MemoryCheckCommand").c_str();
    std::string testerName =
      cmSystemTools::GetFilenameName(this->MemoryTester);
    // determine the checker type
    if ( testerName.find("valgrind") != std::string::npos ||
         this->CTest->GetCTestConfiguration("MemoryCheckType")
         == "Valgrind")
      {
        this->MemoryTesterStyle = cmCTestMemCheckHandler::VALGRIND;
      }
    else if ( testerName.find("purify") != std::string::npos )
      {
      this->MemoryTesterStyle = cmCTestMemCheckHandler::PURIFY;
      }
    else if ( testerName.find("BC") != std::string::npos )
      {
      this->MemoryTesterStyle = cmCTestMemCheckHandler::BOUNDS_CHECKER;
      }
    else
      {
      this->MemoryTesterStyle = cmCTestMemCheckHandler::UNKNOWN;
      }
    }
  else if ( cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
        "PurifyCommand").c_str()) )
    {
    this->MemoryTester
      = this->CTest->GetCTestConfiguration("PurifyCommand").c_str();
    this->MemoryTesterStyle = cmCTestMemCheckHandler::PURIFY;
    }
  else if ( cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
        "ValgrindCommand").c_str()) )
    {
    this->MemoryTester
      = this->CTest->GetCTestConfiguration("ValgrindCommand").c_str();
    this->MemoryTesterStyle = cmCTestMemCheckHandler::VALGRIND;
    }
  else if ( cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
        "BoundsCheckerCommand").c_str()) )
    {
    this->MemoryTester
      = this->CTest->GetCTestConfiguration("BoundsCheckerCommand").c_str();
    this->MemoryTesterStyle = cmCTestMemCheckHandler::BOUNDS_CHECKER;
    }
  if ( this->CTest->GetCTestConfiguration("MemoryCheckType")
       == "AddressSanitizer")
    {
    this->MemoryTester
      = this->CTest->GetCTestConfiguration("CMakeCommand").c_str();
    this->MemoryTesterStyle = cmCTestMemCheckHandler::ADDRESS_SANITIZER;
    this->LogWithPID = true; // even if we give the log file the pid is added
    }
  if ( this->CTest->GetCTestConfiguration("MemoryCheckType")
       == "ThreadSanitizer")
    {
    this->MemoryTester
      = this->CTest->GetCTestConfiguration("CMakeCommand").c_str();
    this->MemoryTesterStyle = cmCTestMemCheckHandler::THREAD_SANITIZER;
    this->LogWithPID = true; // even if we give the log file the pid is added
    }
  if ( this->CTest->GetCTestConfiguration("MemoryCheckType")
       == "MemorySanitizer")
    {
    this->MemoryTester
      = this->CTest->GetCTestConfiguration("CMakeCommand").c_str();
    this->MemoryTesterStyle = cmCTestMemCheckHandler::MEMORY_SANITIZER;
    this->LogWithPID = true; // even if we give the log file the pid is added
    }
  if ( this->CTest->GetCTestConfiguration("MemoryCheckType")
       == "UndefinedBehaviorSanitizer")
    {
    this->MemoryTester
      = this->CTest->GetCTestConfiguration("CMakeCommand").c_str();
    this->MemoryTesterStyle = cmCTestMemCheckHandler::UB_SANITIZER;
    this->LogWithPID = true; // even if we give the log file the pid is added
    }
  // Check the MemoryCheckType
  if(this->MemoryTesterStyle == cmCTestMemCheckHandler::UNKNOWN)
    {
    std::string checkType =
      this->CTest->GetCTestConfiguration("MemoryCheckType");
    if(checkType == "Purify")
      {
      this->MemoryTesterStyle = cmCTestMemCheckHandler::PURIFY;
      }
    else if(checkType == "BoundsChecker")
      {
      this->MemoryTesterStyle = cmCTestMemCheckHandler::BOUNDS_CHECKER;
      }
    else if(checkType == "Valgrind")
      {
      this->MemoryTesterStyle = cmCTestMemCheckHandler::VALGRIND;
      }
    }
  if(this->MemoryTester.size() == 0 )
    {
    cmCTestLog(this->CTest, WARNING,
               "Memory checker (MemoryCheckCommand) "
               "not set, or cannot find the specified program."
               << std::endl);
    return false;
    }

  // Setup the options
  std::string memoryTesterOptions;
  if ( this->CTest->GetCTestConfiguration(
      "MemoryCheckCommandOptions").size() )
    {
    memoryTesterOptions = this->CTest->GetCTestConfiguration(
      "MemoryCheckCommandOptions");
    }
  else if ( this->CTest->GetCTestConfiguration(
      "ValgrindCommandOptions").size() )
    {
    memoryTesterOptions = this->CTest->GetCTestConfiguration(
      "ValgrindCommandOptions");
    }
  this->MemoryTesterOptions
    = cmSystemTools::ParseArguments(memoryTesterOptions.c_str());

  this->MemoryTesterOutputFile
    = this->CTest->GetBinaryDir()
    + "/Testing/Temporary/MemoryChecker.??.log";

  switch ( this->MemoryTesterStyle )
    {
    case cmCTestMemCheckHandler::VALGRIND:
      {
      if ( this->MemoryTesterOptions.empty() )
        {
        this->MemoryTesterOptions.push_back("-q");
        this->MemoryTesterOptions.push_back("--tool=memcheck");
        this->MemoryTesterOptions.push_back("--leak-check=yes");
        this->MemoryTesterOptions.push_back("--show-reachable=yes");
        this->MemoryTesterOptions.push_back("--num-callers=50");
        }
      if ( this->CTest->GetCTestConfiguration(
          "MemoryCheckSuppressionFile").size() )
        {
        if ( !cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
              "MemoryCheckSuppressionFile").c_str()) )
          {
          cmCTestLog(this->CTest, ERROR_MESSAGE,
            "Cannot find memory checker suppression file: "
            << this->CTest->GetCTestConfiguration(
              "MemoryCheckSuppressionFile") << std::endl);
          return false;
          }
        std::string suppressions = "--suppressions="
          + this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile");
        this->MemoryTesterOptions.push_back(suppressions);
        }
      std::string outputFile = "--log-file="
        + this->MemoryTesterOutputFile;
      this->MemoryTesterDynamicOptions.push_back(outputFile);
      break;
      }
    case cmCTestMemCheckHandler::PURIFY:
      {
      std::string outputFile;
#ifdef _WIN32
      if( this->CTest->GetCTestConfiguration(
            "MemoryCheckSuppressionFile").size() )
        {
        if( !cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
                                       "MemoryCheckSuppressionFile").c_str()) )
          {
          cmCTestLog(this->CTest, ERROR_MESSAGE,
                     "Cannot find memory checker suppression file: "
                     << this->CTest->GetCTestConfiguration(
                       "MemoryCheckSuppressionFile").c_str() << std::endl);
          return false;
          }
        std::string filterFiles = "/FilterFiles="
          + this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile");
        this->MemoryTesterOptions.push_back(filterFiles);
        }
      outputFile = "/SAVETEXTDATA=";
#else
      outputFile = "-log-file=";
#endif
      outputFile += this->MemoryTesterOutputFile;
      this->MemoryTesterDynamicOptions.push_back(outputFile);
      break;
      }
    case cmCTestMemCheckHandler::BOUNDS_CHECKER:
      {
      this->BoundsCheckerXMLFile = this->MemoryTesterOutputFile;
      std::string dpbdFile = this->CTest->GetBinaryDir()
        + "/Testing/Temporary/MemoryChecker.??.DPbd";
      this->BoundsCheckerDPBDFile = dpbdFile;
      this->MemoryTesterDynamicOptions.push_back("/B");
      this->MemoryTesterDynamicOptions.push_back(dpbdFile);
      this->MemoryTesterDynamicOptions.push_back("/X");
      this->MemoryTesterDynamicOptions.push_back(this->MemoryTesterOutputFile);
      this->MemoryTesterOptions.push_back("/M");
      break;
      }
      // these are almost the same but the env var used is different
    case cmCTestMemCheckHandler::ADDRESS_SANITIZER:
    case cmCTestMemCheckHandler::THREAD_SANITIZER:
    case cmCTestMemCheckHandler::MEMORY_SANITIZER:
    case cmCTestMemCheckHandler::UB_SANITIZER:
      {
      // To pass arguments to ThreadSanitizer the environment variable
      // TSAN_OPTIONS is used. This is done with the cmake -E env command.
      // The MemoryTesterDynamicOptions is setup with the -E env
      // Then the MemoryTesterEnvironmentVariable gets the
      // TSAN_OPTIONS string with the log_path in it.
      this->MemoryTesterDynamicOptions.push_back("-E");
      this->MemoryTesterDynamicOptions.push_back("env");
      std::string envVar;
      std::string extraOptions =
        this->CTest->GetCTestConfiguration("MemoryCheckSanitizerOptions");
      if(this->MemoryTesterStyle == cmCTestMemCheckHandler::ADDRESS_SANITIZER)
        {
        envVar = "ASAN_OPTIONS";
        extraOptions += " detect_leaks=1";
        }
      else if(this->MemoryTesterStyle ==
              cmCTestMemCheckHandler::THREAD_SANITIZER)
        {
        envVar = "TSAN_OPTIONS";
        }
      else if(this->MemoryTesterStyle ==
              cmCTestMemCheckHandler::MEMORY_SANITIZER)
        {
        envVar = "MSAN_OPTIONS";
        }
      else if(this->MemoryTesterStyle == cmCTestMemCheckHandler::UB_SANITIZER)
        {
        envVar = "UBSAN_OPTIONS";
        }
      std::string outputFile = envVar + "=log_path=\""
        + this->MemoryTesterOutputFile + "\" ";
      this->MemoryTesterEnvironmentVariable = outputFile + extraOptions;
      break;
      }
    default:
      cmCTestLog(this->CTest, ERROR_MESSAGE,
        "Do not understand memory checker: " << this->MemoryTester
        << std::endl);
      return false;
    }

  this->InitializeResultsVectors();
  // std::vector<std::string>::size_type cc;
  // for ( cc = 0; cmCTestMemCheckResultStrings[cc]; cc ++ )
  //   {
  //   this->MemoryTesterGlobalResults[cc] = 0;
  //   }
  return true;
}

//----------------------------------------------------------------------
bool cmCTestMemCheckHandler::
ProcessMemCheckOutput(const std::string& str,
                      std::string& log, std::vector<int>& results)
{
  if ( this->MemoryTesterStyle == cmCTestMemCheckHandler::VALGRIND )
    {
    return this->ProcessMemCheckValgrindOutput(str, log, results);
    }
  else if ( this->MemoryTesterStyle == cmCTestMemCheckHandler::PURIFY )
    {
    return this->ProcessMemCheckPurifyOutput(str, log, results);
    }
  else if ( this->MemoryTesterStyle ==
            cmCTestMemCheckHandler::ADDRESS_SANITIZER ||
            this->MemoryTesterStyle ==
            cmCTestMemCheckHandler::THREAD_SANITIZER ||
            this->MemoryTesterStyle ==
            cmCTestMemCheckHandler::MEMORY_SANITIZER ||
            this->MemoryTesterStyle ==
            cmCTestMemCheckHandler::UB_SANITIZER)
    {
    return this->ProcessMemCheckSanitizerOutput(str, log, results);
    }
  else if ( this->MemoryTesterStyle ==
    cmCTestMemCheckHandler::BOUNDS_CHECKER )
    {
    return this->ProcessMemCheckBoundsCheckerOutput(str, log, results);
    }
  else
    {
    log.append("\nMemory checking style used was: ");
    log.append("None that I know");
    log = str;
    }
  return true;
}

std::vector<int>::size_type cmCTestMemCheckHandler::FindOrAddWarning(
  const std::string& warning)
{
  for(std::vector<std::string>::size_type i =0;
      i < this->ResultStrings.size(); ++i)
    {
    if(this->ResultStrings[i] == warning)
      {
      return i;
      }
    }
  this->GlobalResults.push_back(0); // this must stay the same size
  this->ResultStrings.push_back(warning);
  this->ResultStringsLong.push_back(warning);
  return this->ResultStrings.size()-1;
}
//----------------------------------------------------------------------
bool cmCTestMemCheckHandler::ProcessMemCheckSanitizerOutput(
  const std::string& str, std::string& log,
  std::vector<int>& result)
{
  std::string regex;
  switch ( this->MemoryTesterStyle )
    {
    case cmCTestMemCheckHandler::ADDRESS_SANITIZER:
      regex = "ERROR: AddressSanitizer: (.*) on.*";
      break;
    case cmCTestMemCheckHandler::THREAD_SANITIZER:
      regex = "WARNING: ThreadSanitizer: (.*) \\(pid=.*\\)";
      break;
    case cmCTestMemCheckHandler::MEMORY_SANITIZER:
      regex = "WARNING: MemorySanitizer: (.*)";
      break;
    case cmCTestMemCheckHandler::UB_SANITIZER:
      regex = "runtime error: (.*)";
      break;
    default:
      break;
    }
  cmsys::RegularExpression sanitizerWarning(regex);
  cmsys::RegularExpression leakWarning("(Direct|Indirect) leak of .*");
  int defects = 0;
  std::vector<std::string> lines;
  cmSystemTools::Split(str.c_str(), lines);
  cmOStringStream ostr;
  log = "";
  for( std::vector<std::string>::iterator i = lines.begin();
       i != lines.end(); ++i)
    {
    std::string resultFound;
    if(leakWarning.find(*i))
      {
      resultFound = leakWarning.match(1)+" leak";
      }
    else if (sanitizerWarning.find(*i))
      {
      resultFound = sanitizerWarning.match(1);
      }
    if(resultFound.size())
      {
      std::vector<int>::size_type idx = this->FindOrAddWarning(resultFound);
      if(result.size() == 0 || idx > result.size()-1)
        {
        result.push_back(1);
        }
      else
        {
        result[idx]++;
        }
      defects++;
      ostr << "<b>" <<  this->ResultStrings[idx] << "</b> ";
      }
    ostr << cmXMLSafe(*i) << std::endl;
    }
  log = ostr.str();
  if(defects)
    {
    return false;
    }
  return true;
}
//----------------------------------------------------------------------
bool cmCTestMemCheckHandler::ProcessMemCheckPurifyOutput(
  const std::string& str, std::string& log,
  std::vector<int>& results)
{
  std::vector<std::string> lines;
  cmSystemTools::Split(str.c_str(), lines);
  cmOStringStream ostr;
  log = "";

  cmsys::RegularExpression pfW("^\\[[WEI]\\] ([A-Z][A-Z][A-Z][A-Z]*): ");

  int defects = 0;

  for( std::vector<std::string>::iterator i = lines.begin();
       i != lines.end(); ++i)
    {
    std::vector<int>::size_type failure = this->ResultStrings.size();
    if ( pfW.find(*i) )
      {
      std::vector<int>::size_type cc;
      for ( cc = 0; cc < this->ResultStrings.size(); cc ++ )
        {
        if ( pfW.match(1) == this->ResultStrings[cc] )
          {
          failure = cc;
          break;
          }
        }
      if ( cc == this->ResultStrings.size() )
        {
        cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown Purify memory fault: "
          << pfW.match(1) << std::endl);
        ostr << "*** Unknown Purify memory fault: " << pfW.match(1)
          << std::endl;
        }
      }
    if ( failure != this->ResultStrings.size() )
      {
      ostr << "<b>" <<  this->ResultStrings[failure] << "</b> ";
      results[failure] ++;
      defects ++;
      }
    ostr << cmXMLSafe(*i) << std::endl;
    }

  log = ostr.str();
  if ( defects )
    {
    return false;
    }
  return true;
}

//----------------------------------------------------------------------
bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput(
  const std::string& str, std::string& log,
  std::vector<int>& results)
{
  std::vector<std::string> lines;
  cmSystemTools::Split(str.c_str(), lines);
  bool unlimitedOutput = false;
  if(str.find("CTEST_FULL_OUTPUT") != str.npos ||
    this->CustomMaximumFailedTestOutputSize == 0)
    {
    unlimitedOutput = true;
    }

  std::string::size_type cc;

  cmOStringStream ostr;
  log = "";

  int defects = 0;

  cmsys::RegularExpression valgrindLine("^==[0-9][0-9]*==");

  cmsys::RegularExpression vgFIM(
    "== .*Invalid free\\(\\) / delete / delete\\[\\]");
  cmsys::RegularExpression vgFMM(
    "== .*Mismatched free\\(\\) / delete / delete \\[\\]");
  cmsys::RegularExpression vgMLK1(
    "== .*[0-9,]+ bytes in [0-9,]+ blocks are definitely lost"
   " in loss record [0-9,]+ of [0-9,]+");
  cmsys::RegularExpression vgMLK2(
    "== .*[0-9,]+ \\([0-9,]+ direct, [0-9,]+ indirect\\)"
    " bytes in [0-9,]+ blocks are definitely lost"
    " in loss record [0-9,]+ of [0-9,]+");
  cmsys::RegularExpression vgPAR(
    "== .*Syscall param .* (contains|points to) unaddressable byte\\(s\\)");
  cmsys::RegularExpression vgMPK1(
    "== .*[0-9,]+ bytes in [0-9,]+ blocks are possibly lost in"
    " loss record [0-9,]+ of [0-9,]+");
  cmsys::RegularExpression vgMPK2(
    "== .*[0-9,]+ bytes in [0-9,]+ blocks are still reachable"
    " in loss record [0-9,]+ of [0-9,]+");
  cmsys::RegularExpression vgUMC(
    "== .*Conditional jump or move depends on uninitialised value\\(s\\)");
  cmsys::RegularExpression vgUMR1(
    "== .*Use of uninitialised value of size [0-9,]+");
  cmsys::RegularExpression vgUMR2("== .*Invalid read of size [0-9,]+");
  cmsys::RegularExpression vgUMR3("== .*Jump to the invalid address ");
  cmsys::RegularExpression vgUMR4("== .*Syscall param .* contains "
    "uninitialised or unaddressable byte\\(s\\)");
  cmsys::RegularExpression vgUMR5("== .*Syscall param .* uninitialised");
  cmsys::RegularExpression vgIPW("== .*Invalid write of size [0-9,]+");
  cmsys::RegularExpression vgABR("== .*pthread_mutex_unlock: mutex is "
    "locked by a different thread");
  std::vector<std::string::size_type> nonValGrindOutput;
  double sttime = cmSystemTools::GetTime();
  cmCTestLog(this->CTest, DEBUG, "Start test: " << lines.size() << std::endl);
  std::string::size_type totalOutputSize = 0;
  for ( cc = 0; cc < lines.size(); cc ++ )
    {
    cmCTestLog(this->CTest, DEBUG, "test line "
               << lines[cc] << std::endl);

    if ( valgrindLine.find(lines[cc]) )
      {
      cmCTestLog(this->CTest, DEBUG, "valgrind  line "
                 << lines[cc] << std::endl);
      int failure = cmCTestMemCheckHandler::NO_MEMORY_FAULT;
      if ( vgFIM.find(lines[cc]) )
        {
        failure = cmCTestMemCheckHandler::FIM;
        }
      else if ( vgFMM.find(lines[cc]) )
        {
        failure = cmCTestMemCheckHandler::FMM;
        }
      else if ( vgMLK1.find(lines[cc]) )
        {
        failure = cmCTestMemCheckHandler::MLK;
        }
      else if ( vgMLK2.find(lines[cc]) )
        {
        failure = cmCTestMemCheckHandler::MLK;
        }
      else if ( vgPAR.find(lines[cc]) )
        {
        failure = cmCTestMemCheckHandler::PAR;
        }
      else if ( vgMPK1.find(lines[cc]) )
        {
        failure = cmCTestMemCheckHandler::MPK;
        }
      else if ( vgMPK2.find(lines[cc]) )
        {
        failure = cmCTestMemCheckHandler::MPK;
        }
      else if ( vgUMC.find(lines[cc]) )
        {
        failure = cmCTestMemCheckHandler::UMC;
        }
      else if ( vgUMR1.find(lines[cc]) )
        {
        failure = cmCTestMemCheckHandler::UMR;
        }
      else if ( vgUMR2.find(lines[cc]) )
        {
        failure = cmCTestMemCheckHandler::UMR;
        }
      else if ( vgUMR3.find(lines[cc]) )
        {
        failure = cmCTestMemCheckHandler::UMR;
        }
      else if ( vgUMR4.find(lines[cc]) )
        {
        failure = cmCTestMemCheckHandler::UMR;
        }
      else if ( vgUMR5.find(lines[cc]) )
        {
        failure = cmCTestMemCheckHandler::UMR;
        }
      else if ( vgIPW.find(lines[cc]) )
        {
        failure = cmCTestMemCheckHandler::IPW;
        }
      else if ( vgABR.find(lines[cc]) )
        {
        failure = cmCTestMemCheckHandler::ABR;
        }

      if ( failure != cmCTestMemCheckHandler::NO_MEMORY_FAULT )
        {
        ostr << "<b>" << this->ResultStrings[failure] << "</b> ";
        results[failure] ++;
        defects ++;
        }
      totalOutputSize += lines[cc].size();
      ostr << cmXMLSafe(lines[cc]) << std::endl;
      }
    else
      {
      nonValGrindOutput.push_back(cc);
      }
    }
  // Now put all all the non valgrind output into the test output
  // This should be last in case it gets truncated by the output
  // limiting code
  for(std::vector<std::string::size_type>::iterator i =
        nonValGrindOutput.begin(); i != nonValGrindOutput.end(); ++i)
    {
    totalOutputSize += lines[*i].size();
    cmCTestLog(this->CTest, DEBUG, "before xml safe "
               << lines[*i] << std::endl);
    cmCTestLog(this->CTest, DEBUG, "after  xml safe "
               <<  cmXMLSafe(lines[*i]) << std::endl);
    ostr << cmXMLSafe(lines[*i]) << std::endl;
    if(!unlimitedOutput && totalOutputSize >
       static_cast<size_t>(this->CustomMaximumFailedTestOutputSize))
      {
      ostr << "....\n";
      ostr << "Test Output for this test has been truncated see testing"
        " machine logs for full output,\n";
      ostr << "or put CTEST_FULL_OUTPUT in the output of "
        "this test program.\n";
      break;  // stop the copy of output if we are full
      }
    }
  cmCTestLog(this->CTest, DEBUG, "End test (elapsed: "
             << (cmSystemTools::GetTime() - sttime) << std::endl);
  log = ostr.str();
  if ( defects )
    {
    return false;
    }
  return true;
}



//----------------------------------------------------------------------
bool cmCTestMemCheckHandler::ProcessMemCheckBoundsCheckerOutput(
  const std::string& str, std::string& log,
  std::vector<int>& results)
{
  log = "";
  double sttime = cmSystemTools::GetTime();
  std::vector<std::string> lines;
  cmSystemTools::Split(str.c_str(), lines);
  cmCTestLog(this->CTest, DEBUG, "Start test: " << lines.size() << std::endl);
  std::vector<std::string>::size_type cc;
  for ( cc = 0; cc < lines.size(); cc ++ )
    {
    if(lines[cc] == BOUNDS_CHECKER_MARKER)
      {
      break;
      }
    }
  cmBoundsCheckerParser parser(this->CTest);
  parser.InitializeParser();
  if(cc < lines.size())
    {
    for(cc++; cc < lines.size(); ++cc)
      {
      std::string& theLine = lines[cc];
      // check for command line arguments that are not escaped
      // correctly by BC
      if(theLine.find("TargetArgs=") != theLine.npos)
        {
        // skip this because BC gets it wrong and we can't parse it
        }
      else if(!parser.ParseChunk(theLine.c_str(), theLine.size()))
        {
        cmCTestLog(this->CTest, ERROR_MESSAGE,
                   "Error in ParseChunk: " << theLine
                   << std::endl);
        }
      }
    }
  int defects = 0;
  for(cc =0; cc < parser.Errors.size(); ++cc)
    {
    results[parser.Errors[cc]]++;
    defects++;
    }
  cmCTestLog(this->CTest, DEBUG, "End test (elapsed: "
    << (cmSystemTools::GetTime() - sttime) << std::endl);
  if(defects)
    {
    // only put the output of Bounds Checker if there were
    // errors or leaks detected
    log = parser.Log;
    return false;
    }
  return true;
}

// PostProcessTest memcheck results
void
cmCTestMemCheckHandler::PostProcessTest(cmCTestTestResult& res,
                                        int test)
{
  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
             "PostProcessTest memcheck results for : "
             << res.Name << std::endl);
  if(this->MemoryTesterStyle
     == cmCTestMemCheckHandler::BOUNDS_CHECKER)
    {
    this->PostProcessBoundsCheckerTest(res, test);
    }
  else
    {
    std::vector<std::string> files;
    this->TestOutputFileNames(test, files);
    for(std::vector<std::string>::iterator i = files.begin();
        i != files.end(); ++i)
      {
      this->AppendMemTesterOutput(res, *i);
      }
    }
}


// This method puts the bounds checker output file into the output
// for the test
void
cmCTestMemCheckHandler::PostProcessBoundsCheckerTest(cmCTestTestResult& res,
                                                     int test)
{
  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
             "PostProcessBoundsCheckerTest for : "
             << res.Name << std::endl);
  std::vector<std::string> files;
  this->TestOutputFileNames(test, files);
  if ( files.size() == 0 )
    {
    return;
    }
  std::string ofile = files[0];
  if ( ofile.empty() )
    {
    return;
    }
  // put a scope around this to close ifs so the file can be removed
  {
  cmsys::ifstream ifs(ofile.c_str());
  if ( !ifs )
    {
    std::string log = "Cannot read memory tester output file: " + ofile;
    cmCTestLog(this->CTest, ERROR_MESSAGE, log.c_str() << std::endl);
    return;
    }
  res.Output += BOUNDS_CHECKER_MARKER;
  res.Output += "\n";
  std::string line;
  while ( cmSystemTools::GetLineFromStream(ifs, line) )
    {
    res.Output += line;
    res.Output += "\n";
    }
  }
  cmSystemTools::Delay(1000);
  cmSystemTools::RemoveFile(this->BoundsCheckerDPBDFile);
  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Remove: "
    << this->BoundsCheckerDPBDFile << std::endl);
  cmSystemTools::RemoveFile(this->BoundsCheckerXMLFile);
  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Remove: "
    << this->BoundsCheckerXMLFile << std::endl);
}

void
cmCTestMemCheckHandler::AppendMemTesterOutput(cmCTestTestResult& res,
                                              std::string const& ofile)
{
  if ( ofile.empty() )
    {
    return;
    }
  // put ifs in scope so file can be deleted if needed
  {
  cmsys::ifstream ifs(ofile.c_str());
  if ( !ifs )
    {
    std::string log = "Cannot read memory tester output file: " + ofile;
    cmCTestLog(this->CTest, ERROR_MESSAGE, log.c_str() << std::endl);
    return;
    }
  std::string line;
  while ( cmSystemTools::GetLineFromStream(ifs, line) )
    {
    res.Output += line;
    res.Output += "\n";
    }
  }
  if(this->LogWithPID)
    {
    cmSystemTools::RemoveFile(ofile);
    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Remove: "<< ofile <<"\n");
    }
}

void cmCTestMemCheckHandler::TestOutputFileNames(int test,
                                                 std::vector<std::string>&
                                                 files)
{
  std::string index;
  cmOStringStream stream;
  stream << test;
  index = stream.str();
  std::string ofile = this->MemoryTesterOutputFile;
  std::string::size_type pos = ofile.find("??");
  ofile.replace(pos, 2, index);
  if(this->LogWithPID)
    {
    ofile += ".*";
    cmsys::Glob g;
    g.FindFiles(ofile);
    if(g.GetFiles().size() == 0)
      {
      std::string log = "Cannot find memory tester output file: "
        + ofile;
      cmCTestLog(this->CTest, ERROR_MESSAGE, log.c_str() << std::endl);
      ofile = "";
      }
    else
      {
      files = g.GetFiles();
      return;
      }
    }
  else if ( !cmSystemTools::FileExists(ofile.c_str()) )
    {
    std::string log = "Cannot find memory tester output file: "
      + ofile;
    cmCTestLog(this->CTest, ERROR_MESSAGE, log.c_str() << std::endl);
    ofile = "";
    }
  files.push_back(ofile);
}
8' href='#n978'>978</a>
<a id='n979' href='#n979'>979</a>
<a id='n980' href='#n980'>980</a>
<a id='n981' href='#n981'>981</a>
<a id='n982' href='#n982'>982</a>
<a id='n983' href='#n983'>983</a>
<a id='n984' href='#n984'>984</a>
<a id='n985' href='#n985'>985</a>
<a id='n986' href='#n986'>986</a>
<a id='n987' href='#n987'>987</a>
<a id='n988' href='#n988'>988</a>
<a id='n989' href='#n989'>989</a>
<a id='n990' href='#n990'>990</a>
<a id='n991' href='#n991'>991</a>
<a id='n992' href='#n992'>992</a>
<a id='n993' href='#n993'>993</a>
<a id='n994' href='#n994'>994</a>
<a id='n995' href='#n995'>995</a>
<a id='n996' href='#n996'>996</a>
<a id='n997' href='#n997'>997</a>
<a id='n998' href='#n998'>998</a>
<a id='n999' href='#n999'>999</a>
<a id='n1000' href='#n1000'>1000</a>
<a id='n1001' href='#n1001'>1001</a>
<a id='n1002' href='#n1002'>1002</a>
<a id='n1003' href='#n1003'>1003</a>
<a id='n1004' href='#n1004'>1004</a>
<a id='n1005' href='#n1005'>1005</a>
<a id='n1006' href='#n1006'>1006</a>
<a id='n1007' href='#n1007'>1007</a>
<a id='n1008' href='#n1008'>1008</a>
<a id='n1009' href='#n1009'>1009</a>
<a id='n1010' href='#n1010'>1010</a>
<a id='n1011' href='#n1011'>1011</a>
<a id='n1012' href='#n1012'>1012</a>
<a id='n1013' href='#n1013'>1013</a>
<a id='n1014' href='#n1014'>1014</a>
<a id='n1015' href='#n1015'>1015</a>
<a id='n1016' href='#n1016'>1016</a>
<a id='n1017' href='#n1017'>1017</a>
<a id='n1018' href='#n1018'>1018</a>
<a id='n1019' href='#n1019'>1019</a>
<a id='n1020' href='#n1020'>1020</a>
<a id='n1021' href='#n1021'>1021</a>
<a id='n1022' href='#n1022'>1022</a>
<a id='n1023' href='#n1023'>1023</a>
<a id='n1024' href='#n1024'>1024</a>
<a id='n1025' href='#n1025'>1025</a>
<a id='n1026' href='#n1026'>1026</a>
<a id='n1027' href='#n1027'>1027</a>
<a id='n1028' href='#n1028'>1028</a>
<a id='n1029' href='#n1029'>1029</a>
<a id='n1030' href='#n1030'>1030</a>
<a id='n1031' href='#n1031'>1031</a>
<a id='n1032' href='#n1032'>1032</a>
<a id='n1033' href='#n1033'>1033</a>
<a id='n1034' href='#n1034'>1034</a>
<a id='n1035' href='#n1035'>1035</a>
<a id='n1036' href='#n1036'>1036</a>
<a id='n1037' href='#n1037'>1037</a>
<a id='n1038' href='#n1038'>1038</a>
<a id='n1039' href='#n1039'>1039</a>
<a id='n1040' href='#n1040'>1040</a>
<a id='n1041' href='#n1041'>1041</a>
<a id='n1042' href='#n1042'>1042</a>
<a id='n1043' href='#n1043'>1043</a>
<a id='n1044' href='#n1044'>1044</a>
<a id='n1045' href='#n1045'>1045</a>
<a id='n1046' href='#n1046'>1046</a>
<a id='n1047' href='#n1047'>1047</a>
<a id='n1048' href='#n1048'>1048</a>
<a id='n1049' href='#n1049'>1049</a>
<a id='n1050' href='#n1050'>1050</a>
<a id='n1051' href='#n1051'>1051</a>
<a id='n1052' href='#n1052'>1052</a>
<a id='n1053' href='#n1053'>1053</a>
<a id='n1054' href='#n1054'>1054</a>
<a id='n1055' href='#n1055'>1055</a>
<a id='n1056' href='#n1056'>1056</a>
<a id='n1057' href='#n1057'>1057</a>
<a id='n1058' href='#n1058'>1058</a>
<a id='n1059' href='#n1059'>1059</a>
<a id='n1060' href='#n1060'>1060</a>
<a id='n1061' href='#n1061'>1061</a>
<a id='n1062' href='#n1062'>1062</a>
<a id='n1063' href='#n1063'>1063</a>
<a id='n1064' href='#n1064'>1064</a>
<a id='n1065' href='#n1065'>1065</a>
<a id='n1066' href='#n1066'>1066</a>
<a id='n1067' href='#n1067'>1067</a>
<a id='n1068' href='#n1068'>1068</a>
<a id='n1069' href='#n1069'>1069</a>
<a id='n1070' href='#n1070'>1070</a>
<a id='n1071' href='#n1071'>1071</a>
<a id='n1072' href='#n1072'>1072</a>
<a id='n1073' href='#n1073'>1073</a>
<a id='n1074' href='#n1074'>1074</a>
<a id='n1075' href='#n1075'>1075</a>
<a id='n1076' href='#n1076'>1076</a>
<a id='n1077' href='#n1077'>1077</a>
<a id='n1078' href='#n1078'>1078</a>
<a id='n1079' href='#n1079'>1079</a>
<a id='n1080' href='#n1080'>1080</a>
<a id='n1081' href='#n1081'>1081</a>
<a id='n1082' href='#n1082'>1082</a>
<a id='n1083' href='#n1083'>1083</a>
<a id='n1084' href='#n1084'>1084</a>
<a id='n1085' href='#n1085'>1085</a>
<a id='n1086' href='#n1086'>1086</a>
<a id='n1087' href='#n1087'>1087</a>
<a id='n1088' href='#n1088'>1088</a>
<a id='n1089' href='#n1089'>1089</a>
<a id='n1090' href='#n1090'>1090</a>
<a id='n1091' href='#n1091'>1091</a>
<a id='n1092' href='#n1092'>1092</a>
<a id='n1093' href='#n1093'>1093</a>
<a id='n1094' href='#n1094'>1094</a>
<a id='n1095' href='#n1095'>1095</a>
<a id='n1096' href='#n1096'>1096</a>
<a id='n1097' href='#n1097'>1097</a>
<a id='n1098' href='#n1098'>1098</a>
<a id='n1099' href='#n1099'>1099</a>
<a id='n1100' href='#n1100'>1100</a>
<a id='n1101' href='#n1101'>1101</a>
<a id='n1102' href='#n1102'>1102</a>
<a id='n1103' href='#n1103'>1103</a>
<a id='n1104' href='#n1104'>1104</a>
<a id='n1105' href='#n1105'>1105</a>
<a id='n1106' href='#n1106'>1106</a>
<a id='n1107' href='#n1107'>1107</a>
<a id='n1108' href='#n1108'>1108</a>
<a id='n1109' href='#n1109'>1109</a>
<a id='n1110' href='#n1110'>1110</a>
<a id='n1111' href='#n1111'>1111</a>
<a id='n1112' href='#n1112'>1112</a>
<a id='n1113' href='#n1113'>1113</a>
<a id='n1114' href='#n1114'>1114</a>
<a id='n1115' href='#n1115'>1115</a>
<a id='n1116' href='#n1116'>1116</a>
<a id='n1117' href='#n1117'>1117</a>
<a id='n1118' href='#n1118'>1118</a>
<a id='n1119' href='#n1119'>1119</a>
<a id='n1120' href='#n1120'>1120</a>
<a id='n1121' href='#n1121'>1121</a>
<a id='n1122' href='#n1122'>1122</a>
<a id='n1123' href='#n1123'>1123</a>
<a id='n1124' href='#n1124'>1124</a>
<a id='n1125' href='#n1125'>1125</a>
<a id='n1126' href='#n1126'>1126</a>
<a id='n1127' href='#n1127'>1127</a>
<a id='n1128' href='#n1128'>1128</a>
<a id='n1129' href='#n1129'>1129</a>
<a id='n1130' href='#n1130'>1130</a>
<a id='n1131' href='#n1131'>1131</a>
<a id='n1132' href='#n1132'>1132</a>
<a id='n1133' href='#n1133'>1133</a>
<a id='n1134' href='#n1134'>1134</a>
<a id='n1135' href='#n1135'>1135</a>
<a id='n1136' href='#n1136'>1136</a>
<a id='n1137' href='#n1137'>1137</a>
<a id='n1138' href='#n1138'>1138</a>
<a id='n1139' href='#n1139'>1139</a>
<a id='n1140' href='#n1140'>1140</a>
<a id='n1141' href='#n1141'>1141</a>
<a id='n1142' href='#n1142'>1142</a>
<a id='n1143' href='#n1143'>1143</a>
<a id='n1144' href='#n1144'>1144</a>
<a id='n1145' href='#n1145'>1145</a>
<a id='n1146' href='#n1146'>1146</a>
<a id='n1147' href='#n1147'>1147</a>
<a id='n1148' href='#n1148'>1148</a>
<a id='n1149' href='#n1149'>1149</a>
<a id='n1150' href='#n1150'>1150</a>
<a id='n1151' href='#n1151'>1151</a>
<a id='n1152' href='#n1152'>1152</a>
<a id='n1153' href='#n1153'>1153</a>
<a id='n1154' href='#n1154'>1154</a>
<a id='n1155' href='#n1155'>1155</a>
<a id='n1156' href='#n1156'>1156</a>
<a id='n1157' href='#n1157'>1157</a>
<a id='n1158' href='#n1158'>1158</a>
<a id='n1159' href='#n1159'>1159</a>
<a id='n1160' href='#n1160'>1160</a>
<a id='n1161' href='#n1161'>1161</a>
<a id='n1162' href='#n1162'>1162</a>
<a id='n1163' href='#n1163'>1163</a>
<a id='n1164' href='#n1164'>1164</a>
<a id='n1165' href='#n1165'>1165</a>
<a id='n1166' href='#n1166'>1166</a>
<a id='n1167' href='#n1167'>1167</a>
<a id='n1168' href='#n1168'>1168</a>
<a id='n1169' href='#n1169'>1169</a>
<a id='n1170' href='#n1170'>1170</a>
<a id='n1171' href='#n1171'>1171</a>
<a id='n1172' href='#n1172'>1172</a>
<a id='n1173' href='#n1173'>1173</a>
<a id='n1174' href='#n1174'>1174</a>
<a id='n1175' href='#n1175'>1175</a>
<a id='n1176' href='#n1176'>1176</a>
<a id='n1177' href='#n1177'>1177</a>
<a id='n1178' href='#n1178'>1178</a>
<a id='n1179' href='#n1179'>1179</a>
<a id='n1180' href='#n1180'>1180</a>
<a id='n1181' href='#n1181'>1181</a>
<a id='n1182' href='#n1182'>1182</a>
<a id='n1183' href='#n1183'>1183</a>
<a id='n1184' href='#n1184'>1184</a>
<a id='n1185' href='#n1185'>1185</a>
<a id='n1186' href='#n1186'>1186</a>
<a id='n1187' href='#n1187'>1187</a>
<a id='n1188' href='#n1188'>1188</a>
<a id='n1189' href='#n1189'>1189</a>
<a id='n1190' href='#n1190'>1190</a>
<a id='n1191' href='#n1191'>1191</a>
<a id='n1192' href='#n1192'>1192</a>
<a id='n1193' href='#n1193'>1193</a>
<a id='n1194' href='#n1194'>1194</a>
<a id='n1195' href='#n1195'>1195</a>
<a id='n1196' href='#n1196'>1196</a>
<a id='n1197' href='#n1197'>1197</a>
<a id='n1198' href='#n1198'>1198</a>
<a id='n1199' href='#n1199'>1199</a>
<a id='n1200' href='#n1200'>1200</a>
<a id='n1201' href='#n1201'>1201</a>
<a id='n1202' href='#n1202'>1202</a>
<a id='n1203' href='#n1203'>1203</a>
<a id='n1204' href='#n1204'>1204</a>
<a id='n1205' href='#n1205'>1205</a>
<a id='n1206' href='#n1206'>1206</a>
<a id='n1207' href='#n1207'>1207</a>
<a id='n1208' href='#n1208'>1208</a>
<a id='n1209' href='#n1209'>1209</a>
<a id='n1210' href='#n1210'>1210</a>
<a id='n1211' href='#n1211'>1211</a>
<a id='n1212' href='#n1212'>1212</a>
<a id='n1213' href='#n1213'>1213</a>
<a id='n1214' href='#n1214'>1214</a>
<a id='n1215' href='#n1215'>1215</a>
<a id='n1216' href='#n1216'>1216</a>
<a id='n1217' href='#n1217'>1217</a>
<a id='n1218' href='#n1218'>1218</a>
<a id='n1219' href='#n1219'>1219</a>
<a id='n1220' href='#n1220'>1220</a>
<a id='n1221' href='#n1221'>1221</a>
<a id='n1222' href='#n1222'>1222</a>
<a id='n1223' href='#n1223'>1223</a>
<a id='n1224' href='#n1224'>1224</a>
<a id='n1225' href='#n1225'>1225</a>
<a id='n1226' href='#n1226'>1226</a>
<a id='n1227' href='#n1227'>1227</a>
<a id='n1228' href='#n1228'>1228</a>
<a id='n1229' href='#n1229'>1229</a>
<a id='n1230' href='#n1230'>1230</a>
<a id='n1231' href='#n1231'>1231</a>
<a id='n1232' href='#n1232'>1232</a>
<a id='n1233' href='#n1233'>1233</a>
<a id='n1234' href='#n1234'>1234</a>
<a id='n1235' href='#n1235'>1235</a>
<a id='n1236' href='#n1236'>1236</a>
<a id='n1237' href='#n1237'>1237</a>
<a id='n1238' href='#n1238'>1238</a>
<a id='n1239' href='#n1239'>1239</a>
<a id='n1240' href='#n1240'>1240</a>
<a id='n1241' href='#n1241'>1241</a>
<a id='n1242' href='#n1242'>1242</a>
<a id='n1243' href='#n1243'>1243</a>
<a id='n1244' href='#n1244'>1244</a>
<a id='n1245' href='#n1245'>1245</a>
<a id='n1246' href='#n1246'>1246</a>
<a id='n1247' href='#n1247'>1247</a>
<a id='n1248' href='#n1248'>1248</a>
<a id='n1249' href='#n1249'>1249</a>
<a id='n1250' href='#n1250'>1250</a>
<a id='n1251' href='#n1251'>1251</a>
<a id='n1252' href='#n1252'>1252</a>
<a id='n1253' href='#n1253'>1253</a>
<a id='n1254' href='#n1254'>1254</a>
<a id='n1255' href='#n1255'>1255</a>
<a id='n1256' href='#n1256'>1256</a>
<a id='n1257' href='#n1257'>1257</a>
<a id='n1258' href='#n1258'>1258</a>
<a id='n1259' href='#n1259'>1259</a>
<a id='n1260' href='#n1260'>1260</a>
<a id='n1261' href='#n1261'>1261</a>
<a id='n1262' href='#n1262'>1262</a>
<a id='n1263' href='#n1263'>1263</a>
<a id='n1264' href='#n1264'>1264</a>
<a id='n1265' href='#n1265'>1265</a>
<a id='n1266' href='#n1266'>1266</a>
<a id='n1267' href='#n1267'>1267</a>
<a id='n1268' href='#n1268'>1268</a>
<a id='n1269' href='#n1269'>1269</a>
<a id='n1270' href='#n1270'>1270</a>
<a id='n1271' href='#n1271'>1271</a>
<a id='n1272' href='#n1272'>1272</a>
<a id='n1273' href='#n1273'>1273</a>
<a id='n1274' href='#n1274'>1274</a>
<a id='n1275' href='#n1275'>1275</a>
<a id='n1276' href='#n1276'>1276</a>
<a id='n1277' href='#n1277'>1277</a>
<a id='n1278' href='#n1278'>1278</a>
<a id='n1279' href='#n1279'>1279</a>
<a id='n1280' href='#n1280'>1280</a>
<a id='n1281' href='#n1281'>1281</a>
<a id='n1282' href='#n1282'>1282</a>
<a id='n1283' href='#n1283'>1283</a>
<a id='n1284' href='#n1284'>1284</a>
<a id='n1285' href='#n1285'>1285</a>
<a id='n1286' href='#n1286'>1286</a>
<a id='n1287' href='#n1287'>1287</a>
<a id='n1288' href='#n1288'>1288</a>
<a id='n1289' href='#n1289'>1289</a>
<a id='n1290' href='#n1290'>1290</a>
<a id='n1291' href='#n1291'>1291</a>
<a id='n1292' href='#n1292'>1292</a>
<a id='n1293' href='#n1293'>1293</a>
<a id='n1294' href='#n1294'>1294</a>
<a id='n1295' href='#n1295'>1295</a>
<a id='n1296' href='#n1296'>1296</a>
<a id='n1297' href='#n1297'>1297</a>
<a id='n1298' href='#n1298'>1298</a>
<a id='n1299' href='#n1299'>1299</a>
<a id='n1300' href='#n1300'>1300</a>
<a id='n1301' href='#n1301'>1301</a>
<a id='n1302' href='#n1302'>1302</a>
<a id='n1303' href='#n1303'>1303</a>
<a id='n1304' href='#n1304'>1304</a>
<a id='n1305' href='#n1305'>1305</a>
<a id='n1306' href='#n1306'>1306</a>
<a id='n1307' href='#n1307'>1307</a>
<a id='n1308' href='#n1308'>1308</a>
<a id='n1309' href='#n1309'>1309</a>
<a id='n1310' href='#n1310'>1310</a>
<a id='n1311' href='#n1311'>1311</a>
<a id='n1312' href='#n1312'>1312</a>
<a id='n1313' href='#n1313'>1313</a>
<a id='n1314' href='#n1314'>1314</a>
<a id='n1315' href='#n1315'>1315</a>
<a id='n1316' href='#n1316'>1316</a>
<a id='n1317' href='#n1317'>1317</a>
<a id='n1318' href='#n1318'>1318</a>
<a id='n1319' href='#n1319'>1319</a>
<a id='n1320' href='#n1320'>1320</a>
<a id='n1321' href='#n1321'>1321</a>
<a id='n1322' href='#n1322'>1322</a>
<a id='n1323' href='#n1323'>1323</a>
<a id='n1324' href='#n1324'>1324</a>
<a id='n1325' href='#n1325'>1325</a>
<a id='n1326' href='#n1326'>1326</a>
<a id='n1327' href='#n1327'>1327</a>
<a id='n1328' href='#n1328'>1328</a>
<a id='n1329' href='#n1329'>1329</a>
<a id='n1330' href='#n1330'>1330</a>
<a id='n1331' href='#n1331'>1331</a>
<a id='n1332' href='#n1332'>1332</a>
<a id='n1333' href='#n1333'>1333</a>
<a id='n1334' href='#n1334'>1334</a>
<a id='n1335' href='#n1335'>1335</a>
<a id='n1336' href='#n1336'>1336</a>
<a id='n1337' href='#n1337'>1337</a>
<a id='n1338' href='#n1338'>1338</a>
<a id='n1339' href='#n1339'>1339</a>
<a id='n1340' href='#n1340'>1340</a>
<a id='n1341' href='#n1341'>1341</a>
<a id='n1342' href='#n1342'>1342</a>
<a id='n1343' href='#n1343'>1343</a>
<a id='n1344' href='#n1344'>1344</a>
<a id='n1345' href='#n1345'>1345</a>
<a id='n1346' href='#n1346'>1346</a>
<a id='n1347' href='#n1347'>1347</a>
<a id='n1348' href='#n1348'>1348</a>
<a id='n1349' href='#n1349'>1349</a>
<a id='n1350' href='#n1350'>1350</a>
<a id='n1351' href='#n1351'>1351</a>
<a id='n1352' href='#n1352'>1352</a>
<a id='n1353' href='#n1353'>1353</a>
<a id='n1354' href='#n1354'>1354</a>
<a id='n1355' href='#n1355'>1355</a>
<a id='n1356' href='#n1356'>1356</a>
<a id='n1357' href='#n1357'>1357</a>
<a id='n1358' href='#n1358'>1358</a>
<a id='n1359' href='#n1359'>1359</a>
<a id='n1360' href='#n1360'>1360</a>
<a id='n1361' href='#n1361'>1361</a>
<a id='n1362' href='#n1362'>1362</a>
<a id='n1363' href='#n1363'>1363</a>
<a id='n1364' href='#n1364'>1364</a>
<a id='n1365' href='#n1365'>1365</a>
<a id='n1366' href='#n1366'>1366</a>
<a id='n1367' href='#n1367'>1367</a>
<a id='n1368' href='#n1368'>1368</a>
<a id='n1369' href='#n1369'>1369</a>
<a id='n1370' href='#n1370'>1370</a>
<a id='n1371' href='#n1371'>1371</a>
<a id='n1372' href='#n1372'>1372</a>
<a id='n1373' href='#n1373'>1373</a>
<a id='n1374' href='#n1374'>1374</a>
<a id='n1375' href='#n1375'>1375</a>
<a id='n1376' href='#n1376'>1376</a>
<a id='n1377' href='#n1377'>1377</a>
<a id='n1378' href='#n1378'>1378</a>
<a id='n1379' href='#n1379'>1379</a>
<a id='n1380' href='#n1380'>1380</a>
<a id='n1381' href='#n1381'>1381</a>
<a id='n1382' href='#n1382'>1382</a>
<a id='n1383' href='#n1383'>1383</a>
<a id='n1384' href='#n1384'>1384</a>
<a id='n1385' href='#n1385'>1385</a>
<a id='n1386' href='#n1386'>1386</a>
<a id='n1387' href='#n1387'>1387</a>
<a id='n1388' href='#n1388'>1388</a>
<a id='n1389' href='#n1389'>1389</a>
<a id='n1390' href='#n1390'>1390</a>
<a id='n1391' href='#n1391'>1391</a>
<a id='n1392' href='#n1392'>1392</a>
<a id='n1393' href='#n1393'>1393</a>
<a id='n1394' href='#n1394'>1394</a>
<a id='n1395' href='#n1395'>1395</a>
<a id='n1396' href='#n1396'>1396</a>
<a id='n1397' href='#n1397'>1397</a>
<a id='n1398' href='#n1398'>1398</a>
<a id='n1399' href='#n1399'>1399</a>
<a id='n1400' href='#n1400'>1400</a>
<a id='n1401' href='#n1401'>1401</a>
<a id='n1402' href='#n1402'>1402</a>
<a id='n1403' href='#n1403'>1403</a>
<a id='n1404' href='#n1404'>1404</a>
<a id='n1405' href='#n1405'>1405</a>
<a id='n1406' href='#n1406'>1406</a>
<a id='n1407' href='#n1407'>1407</a>
<a id='n1408' href='#n1408'>1408</a>
<a id='n1409' href='#n1409'>1409</a>
<a id='n1410' href='#n1410'>1410</a>
<a id='n1411' href='#n1411'>1411</a>
<a id='n1412' href='#n1412'>1412</a>
<a id='n1413' href='#n1413'>1413</a>
<a id='n1414' href='#n1414'>1414</a>
<a id='n1415' href='#n1415'>1415</a>
<a id='n1416' href='#n1416'>1416</a>
<a id='n1417' href='#n1417'>1417</a>
<a id='n1418' href='#n1418'>1418</a>
<a id='n1419' href='#n1419'>1419</a>
<a id='n1420' href='#n1420'>1420</a>
<a id='n1421' href='#n1421'>1421</a>
<a id='n1422' href='#n1422'>1422</a>
<a id='n1423' href='#n1423'>1423</a>
<a id='n1424' href='#n1424'>1424</a>
<a id='n1425' href='#n1425'>1425</a>
<a id='n1426' href='#n1426'>1426</a>
<a id='n1427' href='#n1427'>1427</a>
<a id='n1428' href='#n1428'>1428</a>
<a id='n1429' href='#n1429'>1429</a>
<a id='n1430' href='#n1430'>1430</a>
<a id='n1431' href='#n1431'>1431</a>
<a id='n1432' href='#n1432'>1432</a>
<a id='n1433' href='#n1433'>1433</a>
<a id='n1434' href='#n1434'>1434</a>
<a id='n1435' href='#n1435'>1435</a>
<a id='n1436' href='#n1436'>1436</a>
<a id='n1437' href='#n1437'>1437</a>
<a id='n1438' href='#n1438'>1438</a>
<a id='n1439' href='#n1439'>1439</a>
<a id='n1440' href='#n1440'>1440</a>
<a id='n1441' href='#n1441'>1441</a>
<a id='n1442' href='#n1442'>1442</a>
<a id='n1443' href='#n1443'>1443</a>
<a id='n1444' href='#n1444'>1444</a>
<a id='n1445' href='#n1445'>1445</a>
<a id='n1446' href='#n1446'>1446</a>
<a id='n1447' href='#n1447'>1447</a>
<a id='n1448' href='#n1448'>1448</a>
<a id='n1449' href='#n1449'>1449</a>
<a id='n1450' href='#n1450'>1450</a>
<a id='n1451' href='#n1451'>1451</a>
<a id='n1452' href='#n1452'>1452</a>
<a id='n1453' href='#n1453'>1453</a>
<a id='n1454' href='#n1454'>1454</a>
<a id='n1455' href='#n1455'>1455</a>
<a id='n1456' href='#n1456'>1456</a>
<a id='n1457' href='#n1457'>1457</a>
<a id='n1458' href='#n1458'>1458</a>
<a id='n1459' href='#n1459'>1459</a>
<a id='n1460' href='#n1460'>1460</a>
<a id='n1461' href='#n1461'>1461</a>
<a id='n1462' href='#n1462'>1462</a>
<a id='n1463' href='#n1463'>1463</a>
<a id='n1464' href='#n1464'>1464</a>
<a id='n1465' href='#n1465'>1465</a>
<a id='n1466' href='#n1466'>1466</a>
<a id='n1467' href='#n1467'>1467</a>
<a id='n1468' href='#n1468'>1468</a>
<a id='n1469' href='#n1469'>1469</a>
<a id='n1470' href='#n1470'>1470</a>
<a id='n1471' href='#n1471'>1471</a>
<a id='n1472' href='#n1472'>1472</a>
<a id='n1473' href='#n1473'>1473</a>
<a id='n1474' href='#n1474'>1474</a>
<a id='n1475' href='#n1475'>1475</a>
<a id='n1476' href='#n1476'>1476</a>
<a id='n1477' href='#n1477'>1477</a>
<a id='n1478' href='#n1478'>1478</a>
<a id='n1479' href='#n1479'>1479</a>
<a id='n1480' href='#n1480'>1480</a>
<a id='n1481' href='#n1481'>1481</a>
<a id='n1482' href='#n1482'>1482</a>
<a id='n1483' href='#n1483'>1483</a>
<a id='n1484' href='#n1484'>1484</a>
<a id='n1485' href='#n1485'>1485</a>
<a id='n1486' href='#n1486'>1486</a>
<a id='n1487' href='#n1487'>1487</a>
<a id='n1488' href='#n1488'>1488</a>
<a id='n1489' href='#n1489'>1489</a>
<a id='n1490' href='#n1490'>1490</a>
<a id='n1491' href='#n1491'>1491</a>
<a id='n1492' href='#n1492'>1492</a>
<a id='n1493' href='#n1493'>1493</a>
<a id='n1494' href='#n1494'>1494</a>
<a id='n1495' href='#n1495'>1495</a>
<a id='n1496' href='#n1496'>1496</a>
<a id='n1497' href='#n1497'>1497</a>
<a id='n1498' href='#n1498'>1498</a>
<a id='n1499' href='#n1499'>1499</a>
<a id='n1500' href='#n1500'>1500</a>
<a id='n1501' href='#n1501'>1501</a>
<a id='n1502' href='#n1502'>1502</a>
<a id='n1503' href='#n1503'>1503</a>
<a id='n1504' href='#n1504'>1504</a>
<a id='n1505' href='#n1505'>1505</a>
<a id='n1506' href='#n1506'>1506</a>
<a id='n1507' href='#n1507'>1507</a>
<a id='n1508' href='#n1508'>1508</a>
<a id='n1509' href='#n1509'>1509</a>
<a id='n1510' href='#n1510'>1510</a>
<a id='n1511' href='#n1511'>1511</a>
<a id='n1512' href='#n1512'>1512</a>
<a id='n1513' href='#n1513'>1513</a>
<a id='n1514' href='#n1514'>1514</a>
<a id='n1515' href='#n1515'>1515</a>
<a id='n1516' href='#n1516'>1516</a>
<a id='n1517' href='#n1517'>1517</a>
<a id='n1518' href='#n1518'>1518</a>
<a id='n1519' href='#n1519'>1519</a>
<a id='n1520' href='#n1520'>1520</a>
<a id='n1521' href='#n1521'>1521</a>
<a id='n1522' href='#n1522'>1522</a>
<a id='n1523' href='#n1523'>1523</a>
<a id='n1524' href='#n1524'>1524</a>
<a id='n1525' href='#n1525'>1525</a>
<a id='n1526' href='#n1526'>1526</a>
<a id='n1527' href='#n1527'>1527</a>
<a id='n1528' href='#n1528'>1528</a>
<a id='n1529' href='#n1529'>1529</a>
<a id='n1530' href='#n1530'>1530</a>
<a id='n1531' href='#n1531'>1531</a>
<a id='n1532' href='#n1532'>1532</a>
<a id='n1533' href='#n1533'>1533</a>
<a id='n1534' href='#n1534'>1534</a>
<a id='n1535' href='#n1535'>1535</a>
<a id='n1536' href='#n1536'>1536</a>
<a id='n1537' href='#n1537'>1537</a>
<a id='n1538' href='#n1538'>1538</a>
<a id='n1539' href='#n1539'>1539</a>
<a id='n1540' href='#n1540'>1540</a>
<a id='n1541' href='#n1541'>1541</a>
<a id='n1542' href='#n1542'>1542</a>
<a id='n1543' href='#n1543'>1543</a>
<a id='n1544' href='#n1544'>1544</a>
<a id='n1545' href='#n1545'>1545</a>
<a id='n1546' href='#n1546'>1546</a>
<a id='n1547' href='#n1547'>1547</a>
<a id='n1548' href='#n1548'>1548</a>
<a id='n1549' href='#n1549'>1549</a>
<a id='n1550' href='#n1550'>1550</a>
<a id='n1551' href='#n1551'>1551</a>
<a id='n1552' href='#n1552'>1552</a>
<a id='n1553' href='#n1553'>1553</a>
<a id='n1554' href='#n1554'>1554</a>
<a id='n1555' href='#n1555'>1555</a>
<a id='n1556' href='#n1556'>1556</a>
<a id='n1557' href='#n1557'>1557</a>
<a id='n1558' href='#n1558'>1558</a>
<a id='n1559' href='#n1559'>1559</a>
<a id='n1560' href='#n1560'>1560</a>
<a id='n1561' href='#n1561'>1561</a>
<a id='n1562' href='#n1562'>1562</a>
<a id='n1563' href='#n1563'>1563</a>
<a id='n1564' href='#n1564'>1564</a>
<a id='n1565' href='#n1565'>1565</a>
<a id='n1566' href='#n1566'>1566</a>
<a id='n1567' href='#n1567'>1567</a>
<a id='n1568' href='#n1568'>1568</a>
<a id='n1569' href='#n1569'>1569</a>
<a id='n1570' href='#n1570'>1570</a>
<a id='n1571' href='#n1571'>1571</a>
<a id='n1572' href='#n1572'>1572</a>
<a id='n1573' href='#n1573'>1573</a>
<a id='n1574' href='#n1574'>1574</a>
<a id='n1575' href='#n1575'>1575</a>
<a id='n1576' href='#n1576'>1576</a>
<a id='n1577' href='#n1577'>1577</a>
<a id='n1578' href='#n1578'>1578</a>
<a id='n1579' href='#n1579'>1579</a>
<a id='n1580' href='#n1580'>1580</a>
<a id='n1581' href='#n1581'>1581</a>
<a id='n1582' href='#n1582'>1582</a>
<a id='n1583' href='#n1583'>1583</a>
<a id='n1584' href='#n1584'>1584</a>
<a id='n1585' href='#n1585'>1585</a>
<a id='n1586' href='#n1586'>1586</a>
<a id='n1587' href='#n1587'>1587</a>
<a id='n1588' href='#n1588'>1588</a>
<a id='n1589' href='#n1589'>1589</a>
<a id='n1590' href='#n1590'>1590</a>
<a id='n1591' href='#n1591'>1591</a>
<a id='n1592' href='#n1592'>1592</a>
<a id='n1593' href='#n1593'>1593</a>
<a id='n1594' href='#n1594'>1594</a>
<a id='n1595' href='#n1595'>1595</a>
<a id='n1596' href='#n1596'>1596</a>
<a id='n1597' href='#n1597'>1597</a>
<a id='n1598' href='#n1598'>1598</a>
<a id='n1599' href='#n1599'>1599</a>
<a id='n1600' href='#n1600'>1600</a>
<a id='n1601' href='#n1601'>1601</a>
<a id='n1602' href='#n1602'>1602</a>
<a id='n1603' href='#n1603'>1603</a>
<a id='n1604' href='#n1604'>1604</a>
<a id='n1605' href='#n1605'>1605</a>
<a id='n1606' href='#n1606'>1606</a>
<a id='n1607' href='#n1607'>1607</a>
<a id='n1608' href='#n1608'>1608</a>
<a id='n1609' href='#n1609'>1609</a>
<a id='n1610' href='#n1610'>1610</a>
<a id='n1611' href='#n1611'>1611</a>
<a id='n1612' href='#n1612'>1612</a>
<a id='n1613' href='#n1613'>1613</a>
<a id='n1614' href='#n1614'>1614</a>
<a id='n1615' href='#n1615'>1615</a>
<a id='n1616' href='#n1616'>1616</a>
<a id='n1617' href='#n1617'>1617</a>
<a id='n1618' href='#n1618'>1618</a>
<a id='n1619' href='#n1619'>1619</a>
<a id='n1620' href='#n1620'>1620</a>
<a id='n1621' href='#n1621'>1621</a>
<a id='n1622' href='#n1622'>1622</a>
<a id='n1623' href='#n1623'>1623</a>
<a id='n1624' href='#n1624'>1624</a>
<a id='n1625' href='#n1625'>1625</a>
<a id='n1626' href='#n1626'>1626</a>
<a id='n1627' href='#n1627'>1627</a>
<a id='n1628' href='#n1628'>1628</a>
<a id='n1629' href='#n1629'>1629</a>
<a id='n1630' href='#n1630'>1630</a>
<a id='n1631' href='#n1631'>1631</a>
<a id='n1632' href='#n1632'>1632</a>
<a id='n1633' href='#n1633'>1633</a>
<a id='n1634' href='#n1634'>1634</a>
<a id='n1635' href='#n1635'>1635</a>
<a id='n1636' href='#n1636'>1636</a>
<a id='n1637' href='#n1637'>1637</a>
<a id='n1638' href='#n1638'>1638</a>
<a id='n1639' href='#n1639'>1639</a>
<a id='n1640' href='#n1640'>1640</a>
<a id='n1641' href='#n1641'>1641</a>
<a id='n1642' href='#n1642'>1642</a>
<a id='n1643' href='#n1643'>1643</a>
<a id='n1644' href='#n1644'>1644</a>
<a id='n1645' href='#n1645'>1645</a>
<a id='n1646' href='#n1646'>1646</a>
<a id='n1647' href='#n1647'>1647</a>
<a id='n1648' href='#n1648'>1648</a>
<a id='n1649' href='#n1649'>1649</a>
<a id='n1650' href='#n1650'>1650</a>
<a id='n1651' href='#n1651'>1651</a>
<a id='n1652' href='#n1652'>1652</a>
<a id='n1653' href='#n1653'>1653</a>
<a id='n1654' href='#n1654'>1654</a>
<a id='n1655' href='#n1655'>1655</a>
<a id='n1656' href='#n1656'>1656</a>
<a id='n1657' href='#n1657'>1657</a>
<a id='n1658' href='#n1658'>1658</a>
<a id='n1659' href='#n1659'>1659</a>
<a id='n1660' href='#n1660'>1660</a>
<a id='n1661' href='#n1661'>1661</a>
<a id='n1662' href='#n1662'>1662</a>
<a id='n1663' href='#n1663'>1663</a>
<a id='n1664' href='#n1664'>1664</a>
<a id='n1665' href='#n1665'>1665</a>
<a id='n1666' href='#n1666'>1666</a>
<a id='n1667' href='#n1667'>1667</a>
<a id='n1668' href='#n1668'>1668</a>
<a id='n1669' href='#n1669'>1669</a>
<a id='n1670' href='#n1670'>1670</a>
<a id='n1671' href='#n1671'>1671</a>
<a id='n1672' href='#n1672'>1672</a>
<a id='n1673' href='#n1673'>1673</a>
<a id='n1674' href='#n1674'>1674</a>
<a id='n1675' href='#n1675'>1675</a>
<a id='n1676' href='#n1676'>1676</a>
<a id='n1677' href='#n1677'>1677</a>
<a id='n1678' href='#n1678'>1678</a>
<a id='n1679' href='#n1679'>1679</a>
<a id='n1680' href='#n1680'>1680</a>
<a id='n1681' href='#n1681'>1681</a>
<a id='n1682' href='#n1682'>1682</a>
<a id='n1683' href='#n1683'>1683</a>
<a id='n1684' href='#n1684'>1684</a>
<a id='n1685' href='#n1685'>1685</a>
<a id='n1686' href='#n1686'>1686</a>
<a id='n1687' href='#n1687'>1687</a>
<a id='n1688' href='#n1688'>1688</a>
<a id='n1689' href='#n1689'>1689</a>
<a id='n1690' href='#n1690'>1690</a>
<a id='n1691' href='#n1691'>1691</a>
<a id='n1692' href='#n1692'>1692</a>
<a id='n1693' href='#n1693'>1693</a>
<a id='n1694' href='#n1694'>1694</a>
<a id='n1695' href='#n1695'>1695</a>
<a id='n1696' href='#n1696'>1696</a>
<a id='n1697' href='#n1697'>1697</a>
<a id='n1698' href='#n1698'>1698</a>
<a id='n1699' href='#n1699'>1699</a>
<a id='n1700' href='#n1700'>1700</a>
<a id='n1701' href='#n1701'>1701</a>
<a id='n1702' href='#n1702'>1702</a>
<a id='n1703' href='#n1703'>1703</a>
<a id='n1704' href='#n1704'>1704</a>
<a id='n1705' href='#n1705'>1705</a>
<a id='n1706' href='#n1706'>1706</a>
<a id='n1707' href='#n1707'>1707</a>
<a id='n1708' href='#n1708'>1708</a>
<a id='n1709' href='#n1709'>1709</a>
<a id='n1710' href='#n1710'>1710</a>
<a id='n1711' href='#n1711'>1711</a>
<a id='n1712' href='#n1712'>1712</a>
<a id='n1713' href='#n1713'>1713</a>
<a id='n1714' href='#n1714'>1714</a>
<a id='n1715' href='#n1715'>1715</a>
<a id='n1716' href='#n1716'>1716</a>
<a id='n1717' href='#n1717'>1717</a>
<a id='n1718' href='#n1718'>1718</a>
<a id='n1719' href='#n1719'>1719</a>
<a id='n1720' href='#n1720'>1720</a>
<a id='n1721' href='#n1721'>1721</a>
<a id='n1722' href='#n1722'>1722</a>
<a id='n1723' href='#n1723'>1723</a>
<a id='n1724' href='#n1724'>1724</a>
<a id='n1725' href='#n1725'>1725</a>
<a id='n1726' href='#n1726'>1726</a>
<a id='n1727' href='#n1727'>1727</a>
<a id='n1728' href='#n1728'>1728</a>
<a id='n1729' href='#n1729'>1729</a>
<a id='n1730' href='#n1730'>1730</a>
<a id='n1731' href='#n1731'>1731</a>
<a id='n1732' href='#n1732'>1732</a>
<a id='n1733' href='#n1733'>1733</a>
<a id='n1734' href='#n1734'>1734</a>
<a id='n1735' href='#n1735'>1735</a>
<a id='n1736' href='#n1736'>1736</a>
<a id='n1737' href='#n1737'>1737</a>
<a id='n1738' href='#n1738'>1738</a>
<a id='n1739' href='#n1739'>1739</a>
<a id='n1740' href='#n1740'>1740</a>
<a id='n1741' href='#n1741'>1741</a>
<a id='n1742' href='#n1742'>1742</a>
<a id='n1743' href='#n1743'>1743</a>
<a id='n1744' href='#n1744'>1744</a>
<a id='n1745' href='#n1745'>1745</a>
<a id='n1746' href='#n1746'>1746</a>
<a id='n1747' href='#n1747'>1747</a>
<a id='n1748' href='#n1748'>1748</a>
<a id='n1749' href='#n1749'>1749</a>
<a id='n1750' href='#n1750'>1750</a>
<a id='n1751' href='#n1751'>1751</a>
<a id='n1752' href='#n1752'>1752</a>
<a id='n1753' href='#n1753'>1753</a>
<a id='n1754' href='#n1754'>1754</a>
<a id='n1755' href='#n1755'>1755</a>
<a id='n1756' href='#n1756'>1756</a>
<a id='n1757' href='#n1757'>1757</a>
<a id='n1758' href='#n1758'>1758</a>
<a id='n1759' href='#n1759'>1759</a>
<a id='n1760' href='#n1760'>1760</a>
<a id='n1761' href='#n1761'>1761</a>
<a id='n1762' href='#n1762'>1762</a>
<a id='n1763' href='#n1763'>1763</a>
<a id='n1764' href='#n1764'>1764</a>
<a id='n1765' href='#n1765'>1765</a>
<a id='n1766' href='#n1766'>1766</a>
<a id='n1767' href='#n1767'>1767</a>
<a id='n1768' href='#n1768'>1768</a>
<a id='n1769' href='#n1769'>1769</a>
<a id='n1770' href='#n1770'>1770</a>
<a id='n1771' href='#n1771'>1771</a>
<a id='n1772' href='#n1772'>1772</a>
<a id='n1773' href='#n1773'>1773</a>
<a id='n1774' href='#n1774'>1774</a>
<a id='n1775' href='#n1775'>1775</a>
<a id='n1776' href='#n1776'>1776</a>
<a id='n1777' href='#n1777'>1777</a>
<a id='n1778' href='#n1778'>1778</a>
<a id='n1779' href='#n1779'>1779</a>
<a id='n1780' href='#n1780'>1780</a>
<a id='n1781' href='#n1781'>1781</a>
<a id='n1782' href='#n1782'>1782</a>
<a id='n1783' href='#n1783'>1783</a>
<a id='n1784' href='#n1784'>1784</a>
<a id='n1785' href='#n1785'>1785</a>
<a id='n1786' href='#n1786'>1786</a>
<a id='n1787' href='#n1787'>1787</a>
<a id='n1788' href='#n1788'>1788</a>
<a id='n1789' href='#n1789'>1789</a>
<a id='n1790' href='#n1790'>1790</a>
<a id='n1791' href='#n1791'>1791</a>
<a id='n1792' href='#n1792'>1792</a>
<a id='n1793' href='#n1793'>1793</a>
<a id='n1794' href='#n1794'>1794</a>
<a id='n1795' href='#n1795'>1795</a>
<a id='n1796' href='#n1796'>1796</a>
<a id='n1797' href='#n1797'>1797</a>
<a id='n1798' href='#n1798'>1798</a>
<a id='n1799' href='#n1799'>1799</a>
<a id='n1800' href='#n1800'>1800</a>
<a id='n1801' href='#n1801'>1801</a>
<a id='n1802' href='#n1802'>1802</a>
<a id='n1803' href='#n1803'>1803</a>
<a id='n1804' href='#n1804'>1804</a>
<a id='n1805' href='#n1805'>1805</a>
<a id='n1806' href='#n1806'>1806</a>
<a id='n1807' href='#n1807'>1807</a>
<a id='n1808' href='#n1808'>1808</a>
<a id='n1809' href='#n1809'>1809</a>
<a id='n1810' href='#n1810'>1810</a>
<a id='n1811' href='#n1811'>1811</a>
<a id='n1812' href='#n1812'>1812</a>
<a id='n1813' href='#n1813'>1813</a>
<a id='n1814' href='#n1814'>1814</a>
<a id='n1815' href='#n1815'>1815</a>
<a id='n1816' href='#n1816'>1816</a>
<a id='n1817' href='#n1817'>1817</a>
<a id='n1818' href='#n1818'>1818</a>
<a id='n1819' href='#n1819'>1819</a>
<a id='n1820' href='#n1820'>1820</a>
<a id='n1821' href='#n1821'>1821</a>
<a id='n1822' href='#n1822'>1822</a>
<a id='n1823' href='#n1823'>1823</a>
<a id='n1824' href='#n1824'>1824</a>
<a id='n1825' href='#n1825'>1825</a>
<a id='n1826' href='#n1826'>1826</a>
<a id='n1827' href='#n1827'>1827</a>
<a id='n1828' href='#n1828'>1828</a>
<a id='n1829' href='#n1829'>1829</a>
<a id='n1830' href='#n1830'>1830</a>
<a id='n1831' href='#n1831'>1831</a>
<a id='n1832' href='#n1832'>1832</a>
<a id='n1833' href='#n1833'>1833</a>
<a id='n1834' href='#n1834'>1834</a>
<a id='n1835' href='#n1835'>1835</a>
<a id='n1836' href='#n1836'>1836</a>
<a id='n1837' href='#n1837'>1837</a>
<a id='n1838' href='#n1838'>1838</a>
<a id='n1839' href='#n1839'>1839</a>
<a id='n1840' href='#n1840'>1840</a>
<a id='n1841' href='#n1841'>1841</a>
<a id='n1842' href='#n1842'>1842</a>
<a id='n1843' href='#n1843'>1843</a>
<a id='n1844' href='#n1844'>1844</a>
<a id='n1845' href='#n1845'>1845</a>
<a id='n1846' href='#n1846'>1846</a>
<a id='n1847' href='#n1847'>1847</a>
<a id='n1848' href='#n1848'>1848</a>
<a id='n1849' href='#n1849'>1849</a>
<a id='n1850' href='#n1850'>1850</a>
<a id='n1851' href='#n1851'>1851</a>
<a id='n1852' href='#n1852'>1852</a>
<a id='n1853' href='#n1853'>1853</a>
<a id='n1854' href='#n1854'>1854</a>
<a id='n1855' href='#n1855'>1855</a>
<a id='n1856' href='#n1856'>1856</a>
<a id='n1857' href='#n1857'>1857</a>
<a id='n1858' href='#n1858'>1858</a>
<a id='n1859' href='#n1859'>1859</a>
<a id='n1860' href='#n1860'>1860</a>
<a id='n1861' href='#n1861'>1861</a>
<a id='n1862' href='#n1862'>1862</a>
<a id='n1863' href='#n1863'>1863</a>
<a id='n1864' href='#n1864'>1864</a>
<a id='n1865' href='#n1865'>1865</a>
<a id='n1866' href='#n1866'>1866</a>
<a id='n1867' href='#n1867'>1867</a>
<a id='n1868' href='#n1868'>1868</a>
<a id='n1869' href='#n1869'>1869</a>
<a id='n1870' href='#n1870'>1870</a>
<a id='n1871' href='#n1871'>1871</a>
<a id='n1872' href='#n1872'>1872</a>
<a id='n1873' href='#n1873'>1873</a>
<a id='n1874' href='#n1874'>1874</a>
<a id='n1875' href='#n1875'>1875</a>
<a id='n1876' href='#n1876'>1876</a>
<a id='n1877' href='#n1877'>1877</a>
<a id='n1878' href='#n1878'>1878</a>
<a id='n1879' href='#n1879'>1879</a>
<a id='n1880' href='#n1880'>1880</a>
<a id='n1881' href='#n1881'>1881</a>
<a id='n1882' href='#n1882'>1882</a>
<a id='n1883' href='#n1883'>1883</a>
<a id='n1884' href='#n1884'>1884</a>
<a id='n1885' href='#n1885'>1885</a>
<a id='n1886' href='#n1886'>1886</a>
<a id='n1887' href='#n1887'>1887</a>
<a id='n1888' href='#n1888'>1888</a>
<a id='n1889' href='#n1889'>1889</a>
<a id='n1890' href='#n1890'>1890</a>
<a id='n1891' href='#n1891'>1891</a>
<a id='n1892' href='#n1892'>1892</a>
<a id='n1893' href='#n1893'>1893</a>
<a id='n1894' href='#n1894'>1894</a>
<a id='n1895' href='#n1895'>1895</a>
<a id='n1896' href='#n1896'>1896</a>
<a id='n1897' href='#n1897'>1897</a>
<a id='n1898' href='#n1898'>1898</a>
<a id='n1899' href='#n1899'>1899</a>
<a id='n1900' href='#n1900'>1900</a>
<a id='n1901' href='#n1901'>1901</a>
<a id='n1902' href='#n1902'>1902</a>
<a id='n1903' href='#n1903'>1903</a>
<a id='n1904' href='#n1904'>1904</a>
<a id='n1905' href='#n1905'>1905</a>
<a id='n1906' href='#n1906'>1906</a>
<a id='n1907' href='#n1907'>1907</a>
<a id='n1908' href='#n1908'>1908</a>
<a id='n1909' href='#n1909'>1909</a>
<a id='n1910' href='#n1910'>1910</a>
<a id='n1911' href='#n1911'>1911</a>
<a id='n1912' href='#n1912'>1912</a>
<a id='n1913' href='#n1913'>1913</a>
<a id='n1914' href='#n1914'>1914</a>
<a id='n1915' href='#n1915'>1915</a>
<a id='n1916' href='#n1916'>1916</a>
<a id='n1917' href='#n1917'>1917</a>
<a id='n1918' href='#n1918'>1918</a>
<a id='n1919' href='#n1919'>1919</a>
<a id='n1920' href='#n1920'>1920</a>
<a id='n1921' href='#n1921'>1921</a>
<a id='n1922' href='#n1922'>1922</a>
<a id='n1923' href='#n1923'>1923</a>
<a id='n1924' href='#n1924'>1924</a>
<a id='n1925' href='#n1925'>1925</a>
<a id='n1926' href='#n1926'>1926</a>
<a id='n1927' href='#n1927'>1927</a>
<a id='n1928' href='#n1928'>1928</a>
<a id='n1929' href='#n1929'>1929</a>
<a id='n1930' href='#n1930'>1930</a>
<a id='n1931' href='#n1931'>1931</a>
<a id='n1932' href='#n1932'>1932</a>
<a id='n1933' href='#n1933'>1933</a>
<a id='n1934' href='#n1934'>1934</a>
<a id='n1935' href='#n1935'>1935</a>
<a id='n1936' href='#n1936'>1936</a>
<a id='n1937' href='#n1937'>1937</a>
<a id='n1938' href='#n1938'>1938</a>
<a id='n1939' href='#n1939'>1939</a>
<a id='n1940' href='#n1940'>1940</a>
<a id='n1941' href='#n1941'>1941</a>
<a id='n1942' href='#n1942'>1942</a>
<a id='n1943' href='#n1943'>1943</a>
<a id='n1944' href='#n1944'>1944</a>
<a id='n1945' href='#n1945'>1945</a>
<a id='n1946' href='#n1946'>1946</a>
<a id='n1947' href='#n1947'>1947</a>
<a id='n1948' href='#n1948'>1948</a>
<a id='n1949' href='#n1949'>1949</a>
<a id='n1950' href='#n1950'>1950</a>
<a id='n1951' href='#n1951'>1951</a>
<a id='n1952' href='#n1952'>1952</a>
<a id='n1953' href='#n1953'>1953</a>
<a id='n1954' href='#n1954'>1954</a>
<a id='n1955' href='#n1955'>1955</a>
<a id='n1956' href='#n1956'>1956</a>
<a id='n1957' href='#n1957'>1957</a>
<a id='n1958' href='#n1958'>1958</a>
<a id='n1959' href='#n1959'>1959</a>
<a id='n1960' href='#n1960'>1960</a>
<a id='n1961' href='#n1961'>1961</a>
<a id='n1962' href='#n1962'>1962</a>
<a id='n1963' href='#n1963'>1963</a>
<a id='n1964' href='#n1964'>1964</a>
<a id='n1965' href='#n1965'>1965</a>
<a id='n1966' href='#n1966'>1966</a>
<a id='n1967' href='#n1967'>1967</a>
<a id='n1968' href='#n1968'>1968</a>
<a id='n1969' href='#n1969'>1969</a>
<a id='n1970' href='#n1970'>1970</a>
<a id='n1971' href='#n1971'>1971</a>
<a id='n1972' href='#n1972'>1972</a>
<a id='n1973' href='#n1973'>1973</a>
<a id='n1974' href='#n1974'>1974</a>
<a id='n1975' href='#n1975'>1975</a>
<a id='n1976' href='#n1976'>1976</a>
<a id='n1977' href='#n1977'>1977</a>
<a id='n1978' href='#n1978'>1978</a>
<a id='n1979' href='#n1979'>1979</a>
<a id='n1980' href='#n1980'>1980</a>
<a id='n1981' href='#n1981'>1981</a>
<a id='n1982' href='#n1982'>1982</a>
<a id='n1983' href='#n1983'>1983</a>
<a id='n1984' href='#n1984'>1984</a>
<a id='n1985' href='#n1985'>1985</a>
<a id='n1986' href='#n1986'>1986</a>
<a id='n1987' href='#n1987'>1987</a>
<a id='n1988' href='#n1988'>1988</a>
<a id='n1989' href='#n1989'>1989</a>
<a id='n1990' href='#n1990'>1990</a>
<a id='n1991' href='#n1991'>1991</a>
<a id='n1992' href='#n1992'>1992</a>
<a id='n1993' href='#n1993'>1993</a>
<a id='n1994' href='#n1994'>1994</a>
<a id='n1995' href='#n1995'>1995</a>
<a id='n1996' href='#n1996'>1996</a>
<a id='n1997' href='#n1997'>1997</a>
<a id='n1998' href='#n1998'>1998</a>
<a id='n1999' href='#n1999'>1999</a>
<a id='n2000' href='#n2000'>2000</a>
<a id='n2001' href='#n2001'>2001</a>
<a id='n2002' href='#n2002'>2002</a>
<a id='n2003' href='#n2003'>2003</a>
<a id='n2004' href='#n2004'>2004</a>
<a id='n2005' href='#n2005'>2005</a>
<a id='n2006' href='#n2006'>2006</a>
<a id='n2007' href='#n2007'>2007</a>
<a id='n2008' href='#n2008'>2008</a>
<a id='n2009' href='#n2009'>2009</a>
<a id='n2010' href='#n2010'>2010</a>
<a id='n2011' href='#n2011'>2011</a>
<a id='n2012' href='#n2012'>2012</a>
<a id='n2013' href='#n2013'>2013</a>
<a id='n2014' href='#n2014'>2014</a>
<a id='n2015' href='#n2015'>2015</a>
<a id='n2016' href='#n2016'>2016</a>
<a id='n2017' href='#n2017'>2017</a>
<a id='n2018' href='#n2018'>2018</a>
<a id='n2019' href='#n2019'>2019</a>
<a id='n2020' href='#n2020'>2020</a>
<a id='n2021' href='#n2021'>2021</a>
<a id='n2022' href='#n2022'>2022</a>
<a id='n2023' href='#n2023'>2023</a>
<a id='n2024' href='#n2024'>2024</a>
<a id='n2025' href='#n2025'>2025</a>
<a id='n2026' href='#n2026'>2026</a>
<a id='n2027' href='#n2027'>2027</a>
<a id='n2028' href='#n2028'>2028</a>
<a id='n2029' href='#n2029'>2029</a>
<a id='n2030' href='#n2030'>2030</a>
<a id='n2031' href='#n2031'>2031</a>
<a id='n2032' href='#n2032'>2032</a>
<a id='n2033' href='#n2033'>2033</a>
<a id='n2034' href='#n2034'>2034</a>
<a id='n2035' href='#n2035'>2035</a>
<a id='n2036' href='#n2036'>2036</a>
<a id='n2037' href='#n2037'>2037</a>
<a id='n2038' href='#n2038'>2038</a>
<a id='n2039' href='#n2039'>2039</a>
<a id='n2040' href='#n2040'>2040</a>
<a id='n2041' href='#n2041'>2041</a>
<a id='n2042' href='#n2042'>2042</a>
<a id='n2043' href='#n2043'>2043</a>
<a id='n2044' href='#n2044'>2044</a>
<a id='n2045' href='#n2045'>2045</a>
<a id='n2046' href='#n2046'>2046</a>
<a id='n2047' href='#n2047'>2047</a>
<a id='n2048' href='#n2048'>2048</a>
<a id='n2049' href='#n2049'>2049</a>
<a id='n2050' href='#n2050'>2050</a>
<a id='n2051' href='#n2051'>2051</a>
<a id='n2052' href='#n2052'>2052</a>
<a id='n2053' href='#n2053'>2053</a>
<a id='n2054' href='#n2054'>2054</a>
<a id='n2055' href='#n2055'>2055</a>
<a id='n2056' href='#n2056'>2056</a>
<a id='n2057' href='#n2057'>2057</a>
<a id='n2058' href='#n2058'>2058</a>
<a id='n2059' href='#n2059'>2059</a>
<a id='n2060' href='#n2060'>2060</a>
<a id='n2061' href='#n2061'>2061</a>
<a id='n2062' href='#n2062'>2062</a>
<a id='n2063' href='#n2063'>2063</a>
<a id='n2064' href='#n2064'>2064</a>
<a id='n2065' href='#n2065'>2065</a>
<a id='n2066' href='#n2066'>2066</a>
<a id='n2067' href='#n2067'>2067</a>
<a id='n2068' href='#n2068'>2068</a>
<a id='n2069' href='#n2069'>2069</a>
<a id='n2070' href='#n2070'>2070</a>
<a id='n2071' href='#n2071'>2071</a>
<a id='n2072' href='#n2072'>2072</a>
<a id='n2073' href='#n2073'>2073</a>
<a id='n2074' href='#n2074'>2074</a>
<a id='n2075' href='#n2075'>2075</a>
<a id='n2076' href='#n2076'>2076</a>
<a id='n2077' href='#n2077'>2077</a>
<a id='n2078' href='#n2078'>2078</a>
<a id='n2079' href='#n2079'>2079</a>
<a id='n2080' href='#n2080'>2080</a>
<a id='n2081' href='#n2081'>2081</a>
<a id='n2082' href='#n2082'>2082</a>
<a id='n2083' href='#n2083'>2083</a>
<a id='n2084' href='#n2084'>2084</a>
<a id='n2085' href='#n2085'>2085</a>
<a id='n2086' href='#n2086'>2086</a>
<a id='n2087' href='#n2087'>2087</a>
<a id='n2088' href='#n2088'>2088</a>
<a id='n2089' href='#n2089'>2089</a>
<a id='n2090' href='#n2090'>2090</a>
<a id='n2091' href='#n2091'>2091</a>
<a id='n2092' href='#n2092'>2092</a>
<a id='n2093' href='#n2093'>2093</a>
<a id='n2094' href='#n2094'>2094</a>
<a id='n2095' href='#n2095'>2095</a>
<a id='n2096' href='#n2096'>2096</a>
<a id='n2097' href='#n2097'>2097</a>
<a id='n2098' href='#n2098'>2098</a>
<a id='n2099' href='#n2099'>2099</a>
<a id='n2100' href='#n2100'>2100</a>
<a id='n2101' href='#n2101'>2101</a>
<a id='n2102' href='#n2102'>2102</a>
<a id='n2103' href='#n2103'>2103</a>
<a id='n2104' href='#n2104'>2104</a>
<a id='n2105' href='#n2105'>2105</a>
<a id='n2106' href='#n2106'>2106</a>
<a id='n2107' href='#n2107'>2107</a>
<a id='n2108' href='#n2108'>2108</a>
<a id='n2109' href='#n2109'>2109</a>
<a id='n2110' href='#n2110'>2110</a>
<a id='n2111' href='#n2111'>2111</a>
<a id='n2112' href='#n2112'>2112</a>
<a id='n2113' href='#n2113'>2113</a>
<a id='n2114' href='#n2114'>2114</a>
<a id='n2115' href='#n2115'>2115</a>
<a id='n2116' href='#n2116'>2116</a>
<a id='n2117' href='#n2117'>2117</a>
<a id='n2118' href='#n2118'>2118</a>
<a id='n2119' href='#n2119'>2119</a>
<a id='n2120' href='#n2120'>2120</a>
<a id='n2121' href='#n2121'>2121</a>
<a id='n2122' href='#n2122'>2122</a>
<a id='n2123' href='#n2123'>2123</a>
<a id='n2124' href='#n2124'>2124</a>
<a id='n2125' href='#n2125'>2125</a>
<a id='n2126' href='#n2126'>2126</a>
<a id='n2127' href='#n2127'>2127</a>
<a id='n2128' href='#n2128'>2128</a>
<a id='n2129' href='#n2129'>2129</a>
<a id='n2130' href='#n2130'>2130</a>
<a id='n2131' href='#n2131'>2131</a>
<a id='n2132' href='#n2132'>2132</a>
<a id='n2133' href='#n2133'>2133</a>
<a id='n2134' href='#n2134'>2134</a>
<a id='n2135' href='#n2135'>2135</a>
<a id='n2136' href='#n2136'>2136</a>
<a id='n2137' href='#n2137'>2137</a>
<a id='n2138' href='#n2138'>2138</a>
<a id='n2139' href='#n2139'>2139</a>
<a id='n2140' href='#n2140'>2140</a>
<a id='n2141' href='#n2141'>2141</a>
<a id='n2142' href='#n2142'>2142</a>
<a id='n2143' href='#n2143'>2143</a>
<a id='n2144' href='#n2144'>2144</a>
<a id='n2145' href='#n2145'>2145</a>
<a id='n2146' href='#n2146'>2146</a>
<a id='n2147' href='#n2147'>2147</a>
<a id='n2148' href='#n2148'>2148</a>
<a id='n2149' href='#n2149'>2149</a>
<a id='n2150' href='#n2150'>2150</a>
<a id='n2151' href='#n2151'>2151</a>
<a id='n2152' href='#n2152'>2152</a>
<a id='n2153' href='#n2153'>2153</a>
<a id='n2154' href='#n2154'>2154</a>
<a id='n2155' href='#n2155'>2155</a>
<a id='n2156' href='#n2156'>2156</a>
<a id='n2157' href='#n2157'>2157</a>
<a id='n2158' href='#n2158'>2158</a>
<a id='n2159' href='#n2159'>2159</a>
<a id='n2160' href='#n2160'>2160</a>
<a id='n2161' href='#n2161'>2161</a>
<a id='n2162' href='#n2162'>2162</a>
<a id='n2163' href='#n2163'>2163</a>
<a id='n2164' href='#n2164'>2164</a>
<a id='n2165' href='#n2165'>2165</a>
<a id='n2166' href='#n2166'>2166</a>
<a id='n2167' href='#n2167'>2167</a>
<a id='n2168' href='#n2168'>2168</a>
<a id='n2169' href='#n2169'>2169</a>
<a id='n2170' href='#n2170'>2170</a>
<a id='n2171' href='#n2171'>2171</a>
<a id='n2172' href='#n2172'>2172</a>
<a id='n2173' href='#n2173'>2173</a>
<a id='n2174' href='#n2174'>2174</a>
<a id='n2175' href='#n2175'>2175</a>
<a id='n2176' href='#n2176'>2176</a>
<a id='n2177' href='#n2177'>2177</a>
<a id='n2178' href='#n2178'>2178</a>
<a id='n2179' href='#n2179'>2179</a>
<a id='n2180' href='#n2180'>2180</a>
<a id='n2181' href='#n2181'>2181</a>
<a id='n2182' href='#n2182'>2182</a>
<a id='n2183' href='#n2183'>2183</a>
<a id='n2184' href='#n2184'>2184</a>
<a id='n2185' href='#n2185'>2185</a>
<a id='n2186' href='#n2186'>2186</a>
<a id='n2187' href='#n2187'>2187</a>
<a id='n2188' href='#n2188'>2188</a>
<a id='n2189' href='#n2189'>2189</a>
<a id='n2190' href='#n2190'>2190</a>
<a id='n2191' href='#n2191'>2191</a>
<a id='n2192' href='#n2192'>2192</a>
<a id='n2193' href='#n2193'>2193</a>
<a id='n2194' href='#n2194'>2194</a>
<a id='n2195' href='#n2195'>2195</a>
<a id='n2196' href='#n2196'>2196</a>
<a id='n2197' href='#n2197'>2197</a>
<a id='n2198' href='#n2198'>2198</a>
<a id='n2199' href='#n2199'>2199</a>
<a id='n2200' href='#n2200'>2200</a>
<a id='n2201' href='#n2201'>2201</a>
<a id='n2202' href='#n2202'>2202</a>
<a id='n2203' href='#n2203'>2203</a>
<a id='n2204' href='#n2204'>2204</a>
<a id='n2205' href='#n2205'>2205</a>
<a id='n2206' href='#n2206'>2206</a>
<a id='n2207' href='#n2207'>2207</a>
<a id='n2208' href='#n2208'>2208</a>
<a id='n2209' href='#n2209'>2209</a>
<a id='n2210' href='#n2210'>2210</a>
<a id='n2211' href='#n2211'>2211</a>
<a id='n2212' href='#n2212'>2212</a>
<a id='n2213' href='#n2213'>2213</a>
<a id='n2214' href='#n2214'>2214</a>
<a id='n2215' href='#n2215'>2215</a>
<a id='n2216' href='#n2216'>2216</a>
<a id='n2217' href='#n2217'>2217</a>
<a id='n2218' href='#n2218'>2218</a>
<a id='n2219' href='#n2219'>2219</a>
<a id='n2220' href='#n2220'>2220</a>
<a id='n2221' href='#n2221'>2221</a>
<a id='n2222' href='#n2222'>2222</a>
<a id='n2223' href='#n2223'>2223</a>
<a id='n2224' href='#n2224'>2224</a>
<a id='n2225' href='#n2225'>2225</a>
<a id='n2226' href='#n2226'>2226</a>
<a id='n2227' href='#n2227'>2227</a>
<a id='n2228' href='#n2228'>2228</a>
<a id='n2229' href='#n2229'>2229</a>
<a id='n2230' href='#n2230'>2230</a>
<a id='n2231' href='#n2231'>2231</a>
<a id='n2232' href='#n2232'>2232</a>
<a id='n2233' href='#n2233'>2233</a>
<a id='n2234' href='#n2234'>2234</a>
<a id='n2235' href='#n2235'>2235</a>
<a id='n2236' href='#n2236'>2236</a>
<a id='n2237' href='#n2237'>2237</a>
<a id='n2238' href='#n2238'>2238</a>
<a id='n2239' href='#n2239'>2239</a>
<a id='n2240' href='#n2240'>2240</a>
<a id='n2241' href='#n2241'>2241</a>
<a id='n2242' href='#n2242'>2242</a>
<a id='n2243' href='#n2243'>2243</a>
<a id='n2244' href='#n2244'>2244</a>
<a id='n2245' href='#n2245'>2245</a>
<a id='n2246' href='#n2246'>2246</a>
<a id='n2247' href='#n2247'>2247</a>
<a id='n2248' href='#n2248'>2248</a>
<a id='n2249' href='#n2249'>2249</a>
<a id='n2250' href='#n2250'>2250</a>
<a id='n2251' href='#n2251'>2251</a>
<a id='n2252' href='#n2252'>2252</a>
<a id='n2253' href='#n2253'>2253</a>
<a id='n2254' href='#n2254'>2254</a>
<a id='n2255' href='#n2255'>2255</a>
<a id='n2256' href='#n2256'>2256</a>
<a id='n2257' href='#n2257'>2257</a>
<a id='n2258' href='#n2258'>2258</a>
<a id='n2259' href='#n2259'>2259</a>
<a id='n2260' href='#n2260'>2260</a>
<a id='n2261' href='#n2261'>2261</a>
<a id='n2262' href='#n2262'>2262</a>
<a id='n2263' href='#n2263'>2263</a>
<a id='n2264' href='#n2264'>2264</a>
<a id='n2265' href='#n2265'>2265</a>
<a id='n2266' href='#n2266'>2266</a>
<a id='n2267' href='#n2267'>2267</a>
<a id='n2268' href='#n2268'>2268</a>
<a id='n2269' href='#n2269'>2269</a>
<a id='n2270' href='#n2270'>2270</a>
<a id='n2271' href='#n2271'>2271</a>
<a id='n2272' href='#n2272'>2272</a>
<a id='n2273' href='#n2273'>2273</a>
<a id='n2274' href='#n2274'>2274</a>
<a id='n2275' href='#n2275'>2275</a>
<a id='n2276' href='#n2276'>2276</a>
<a id='n2277' href='#n2277'>2277</a>
<a id='n2278' href='#n2278'>2278</a>
<a id='n2279' href='#n2279'>2279</a>
<a id='n2280' href='#n2280'>2280</a>
<a id='n2281' href='#n2281'>2281</a>
<a id='n2282' href='#n2282'>2282</a>
<a id='n2283' href='#n2283'>2283</a>
<a id='n2284' href='#n2284'>2284</a>
<a id='n2285' href='#n2285'>2285</a>
<a id='n2286' href='#n2286'>2286</a>
<a id='n2287' href='#n2287'>2287</a>
<a id='n2288' href='#n2288'>2288</a>
<a id='n2289' href='#n2289'>2289</a>
<a id='n2290' href='#n2290'>2290</a>
<a id='n2291' href='#n2291'>2291</a>
<a id='n2292' href='#n2292'>2292</a>
<a id='n2293' href='#n2293'>2293</a>
<a id='n2294' href='#n2294'>2294</a>
<a id='n2295' href='#n2295'>2295</a>
<a id='n2296' href='#n2296'>2296</a>
<a id='n2297' href='#n2297'>2297</a>
<a id='n2298' href='#n2298'>2298</a>
<a id='n2299' href='#n2299'>2299</a>
<a id='n2300' href='#n2300'>2300</a>
<a id='n2301' href='#n2301'>2301</a>
<a id='n2302' href='#n2302'>2302</a>
<a id='n2303' href='#n2303'>2303</a>
<a id='n2304' href='#n2304'>2304</a>
<a id='n2305' href='#n2305'>2305</a>
<a id='n2306' href='#n2306'>2306</a>
<a id='n2307' href='#n2307'>2307</a>
<a id='n2308' href='#n2308'>2308</a>
<a id='n2309' href='#n2309'>2309</a>
<a id='n2310' href='#n2310'>2310</a>
<a id='n2311' href='#n2311'>2311</a>
<a id='n2312' href='#n2312'>2312</a>
<a id='n2313' href='#n2313'>2313</a>
<a id='n2314' href='#n2314'>2314</a>
<a id='n2315' href='#n2315'>2315</a>
<a id='n2316' href='#n2316'>2316</a>
<a id='n2317' href='#n2317'>2317</a>
<a id='n2318' href='#n2318'>2318</a>
<a id='n2319' href='#n2319'>2319</a>
<a id='n2320' href='#n2320'>2320</a>
<a id='n2321' href='#n2321'>2321</a>
<a id='n2322' href='#n2322'>2322</a>
<a id='n2323' href='#n2323'>2323</a>
<a id='n2324' href='#n2324'>2324</a>
<a id='n2325' href='#n2325'>2325</a>
<a id='n2326' href='#n2326'>2326</a>
<a id='n2327' href='#n2327'>2327</a>
<a id='n2328' href='#n2328'>2328</a>
<a id='n2329' href='#n2329'>2329</a>
<a id='n2330' href='#n2330'>2330</a>
<a id='n2331' href='#n2331'>2331</a>
<a id='n2332' href='#n2332'>2332</a>
<a id='n2333' href='#n2333'>2333</a>
<a id='n2334' href='#n2334'>2334</a>
<a id='n2335' href='#n2335'>2335</a>
<a id='n2336' href='#n2336'>2336</a>
<a id='n2337' href='#n2337'>2337</a>
<a id='n2338' href='#n2338'>2338</a>
<a id='n2339' href='#n2339'>2339</a>
<a id='n2340' href='#n2340'>2340</a>
<a id='n2341' href='#n2341'>2341</a>
<a id='n2342' href='#n2342'>2342</a>
<a id='n2343' href='#n2343'>2343</a>
<a id='n2344' href='#n2344'>2344</a>
<a id='n2345' href='#n2345'>2345</a>
<a id='n2346' href='#n2346'>2346</a>
<a id='n2347' href='#n2347'>2347</a>
<a id='n2348' href='#n2348'>2348</a>
<a id='n2349' href='#n2349'>2349</a>
<a id='n2350' href='#n2350'>2350</a>
<a id='n2351' href='#n2351'>2351</a>
<a id='n2352' href='#n2352'>2352</a>
<a id='n2353' href='#n2353'>2353</a>
<a id='n2354' href='#n2354'>2354</a>
<a id='n2355' href='#n2355'>2355</a>
<a id='n2356' href='#n2356'>2356</a>
<a id='n2357' href='#n2357'>2357</a>
<a id='n2358' href='#n2358'>2358</a>
<a id='n2359' href='#n2359'>2359</a>
<a id='n2360' href='#n2360'>2360</a>
<a id='n2361' href='#n2361'>2361</a>
<a id='n2362' href='#n2362'>2362</a>
<a id='n2363' href='#n2363'>2363</a>
<a id='n2364' href='#n2364'>2364</a>
<a id='n2365' href='#n2365'>2365</a>
<a id='n2366' href='#n2366'>2366</a>
<a id='n2367' href='#n2367'>2367</a>
<a id='n2368' href='#n2368'>2368</a>
<a id='n2369' href='#n2369'>2369</a>
<a id='n2370' href='#n2370'>2370</a>
<a id='n2371' href='#n2371'>2371</a>
<a id='n2372' href='#n2372'>2372</a>
<a id='n2373' href='#n2373'>2373</a>
<a id='n2374' href='#n2374'>2374</a>
<a id='n2375' href='#n2375'>2375</a>
<a id='n2376' href='#n2376'>2376</a>
<a id='n2377' href='#n2377'>2377</a>
<a id='n2378' href='#n2378'>2378</a>
<a id='n2379' href='#n2379'>2379</a>
<a id='n2380' href='#n2380'>2380</a>
<a id='n2381' href='#n2381'>2381</a>
<a id='n2382' href='#n2382'>2382</a>
<a id='n2383' href='#n2383'>2383</a>
<a id='n2384' href='#n2384'>2384</a>
<a id='n2385' href='#n2385'>2385</a>
<a id='n2386' href='#n2386'>2386</a>
<a id='n2387' href='#n2387'>2387</a>
<a id='n2388' href='#n2388'>2388</a>
<a id='n2389' href='#n2389'>2389</a>
<a id='n2390' href='#n2390'>2390</a>
<a id='n2391' href='#n2391'>2391</a>
<a id='n2392' href='#n2392'>2392</a>
<a id='n2393' href='#n2393'>2393</a>
<a id='n2394' href='#n2394'>2394</a>
<a id='n2395' href='#n2395'>2395</a>
<a id='n2396' href='#n2396'>2396</a>
<a id='n2397' href='#n2397'>2397</a>
<a id='n2398' href='#n2398'>2398</a>
<a id='n2399' href='#n2399'>2399</a>
<a id='n2400' href='#n2400'>2400</a>
<a id='n2401' href='#n2401'>2401</a>
<a id='n2402' href='#n2402'>2402</a>
<a id='n2403' href='#n2403'>2403</a>
<a id='n2404' href='#n2404'>2404</a>
<a id='n2405' href='#n2405'>2405</a>
<a id='n2406' href='#n2406'>2406</a>
<a id='n2407' href='#n2407'>2407</a>
<a id='n2408' href='#n2408'>2408</a>
<a id='n2409' href='#n2409'>2409</a>
<a id='n2410' href='#n2410'>2410</a>
<a id='n2411' href='#n2411'>2411</a>
<a id='n2412' href='#n2412'>2412</a>
<a id='n2413' href='#n2413'>2413</a>
<a id='n2414' href='#n2414'>2414</a>
<a id='n2415' href='#n2415'>2415</a>
<a id='n2416' href='#n2416'>2416</a>
<a id='n2417' href='#n2417'>2417</a>
<a id='n2418' href='#n2418'>2418</a>
<a id='n2419' href='#n2419'>2419</a>
<a id='n2420' href='#n2420'>2420</a>
<a id='n2421' href='#n2421'>2421</a>
<a id='n2422' href='#n2422'>2422</a>
<a id='n2423' href='#n2423'>2423</a>
<a id='n2424' href='#n2424'>2424</a>
<a id='n2425' href='#n2425'>2425</a>
<a id='n2426' href='#n2426'>2426</a>
<a id='n2427' href='#n2427'>2427</a>
<a id='n2428' href='#n2428'>2428</a>
<a id='n2429' href='#n2429'>2429</a>
<a id='n2430' href='#n2430'>2430</a>
<a id='n2431' href='#n2431'>2431</a>
<a id='n2432' href='#n2432'>2432</a>
<a id='n2433' href='#n2433'>2433</a>
<a id='n2434' href='#n2434'>2434</a>
<a id='n2435' href='#n2435'>2435</a>
<a id='n2436' href='#n2436'>2436</a>
<a id='n2437' href='#n2437'>2437</a>
<a id='n2438' href='#n2438'>2438</a>
<a id='n2439' href='#n2439'>2439</a>
<a id='n2440' href='#n2440'>2440</a>
<a id='n2441' href='#n2441'>2441</a>
<a id='n2442' href='#n2442'>2442</a>
<a id='n2443' href='#n2443'>2443</a>
<a id='n2444' href='#n2444'>2444</a>
<a id='n2445' href='#n2445'>2445</a>
<a id='n2446' href='#n2446'>2446</a>
<a id='n2447' href='#n2447'>2447</a>
<a id='n2448' href='#n2448'>2448</a>
<a id='n2449' href='#n2449'>2449</a>
<a id='n2450' href='#n2450'>2450</a>
<a id='n2451' href='#n2451'>2451</a>
<a id='n2452' href='#n2452'>2452</a>
<a id='n2453' href='#n2453'>2453</a>
<a id='n2454' href='#n2454'>2454</a>
<a id='n2455' href='#n2455'>2455</a>
<a id='n2456' href='#n2456'>2456</a>
<a id='n2457' href='#n2457'>2457</a>
<a id='n2458' href='#n2458'>2458</a>
<a id='n2459' href='#n2459'>2459</a>
<a id='n2460' href='#n2460'>2460</a>
<a id='n2461' href='#n2461'>2461</a>
<a id='n2462' href='#n2462'>2462</a>
<a id='n2463' href='#n2463'>2463</a>
<a id='n2464' href='#n2464'>2464</a>
<a id='n2465' href='#n2465'>2465</a>
<a id='n2466' href='#n2466'>2466</a>
<a id='n2467' href='#n2467'>2467</a>
<a id='n2468' href='#n2468'>2468</a>
<a id='n2469' href='#n2469'>2469</a>
<a id='n2470' href='#n2470'>2470</a>
<a id='n2471' href='#n2471'>2471</a>
<a id='n2472' href='#n2472'>2472</a>
<a id='n2473' href='#n2473'>2473</a>
<a id='n2474' href='#n2474'>2474</a>
<a id='n2475' href='#n2475'>2475</a>
<a id='n2476' href='#n2476'>2476</a>
<a id='n2477' href='#n2477'>2477</a>
<a id='n2478' href='#n2478'>2478</a>
<a id='n2479' href='#n2479'>2479</a>
<a id='n2480' href='#n2480'>2480</a>
<a id='n2481' href='#n2481'>2481</a>
<a id='n2482' href='#n2482'>2482</a>
<a id='n2483' href='#n2483'>2483</a>
<a id='n2484' href='#n2484'>2484</a>
<a id='n2485' href='#n2485'>2485</a>
<a id='n2486' href='#n2486'>2486</a>
<a id='n2487' href='#n2487'>2487</a>
<a id='n2488' href='#n2488'>2488</a>
<a id='n2489' href='#n2489'>2489</a>
<a id='n2490' href='#n2490'>2490</a>
<a id='n2491' href='#n2491'>2491</a>
<a id='n2492' href='#n2492'>2492</a>
<a id='n2493' href='#n2493'>2493</a>
<a id='n2494' href='#n2494'>2494</a>
<a id='n2495' href='#n2495'>2495</a>
<a id='n2496' href='#n2496'>2496</a>
<a id='n2497' href='#n2497'>2497</a>
<a id='n2498' href='#n2498'>2498</a>
<a id='n2499' href='#n2499'>2499</a>
<a id='n2500' href='#n2500'>2500</a>
<a id='n2501' href='#n2501'>2501</a>
<a id='n2502' href='#n2502'>2502</a>
<a id='n2503' href='#n2503'>2503</a>
<a id='n2504' href='#n2504'>2504</a>
<a id='n2505' href='#n2505'>2505</a>
<a id='n2506' href='#n2506'>2506</a>
<a id='n2507' href='#n2507'>2507</a>
<a id='n2508' href='#n2508'>2508</a>
<a id='n2509' href='#n2509'>2509</a>
<a id='n2510' href='#n2510'>2510</a>
<a id='n2511' href='#n2511'>2511</a>
<a id='n2512' href='#n2512'>2512</a>
<a id='n2513' href='#n2513'>2513</a>
<a id='n2514' href='#n2514'>2514</a>
<a id='n2515' href='#n2515'>2515</a>
<a id='n2516' href='#n2516'>2516</a>
<a id='n2517' href='#n2517'>2517</a>
<a id='n2518' href='#n2518'>2518</a>
<a id='n2519' href='#n2519'>2519</a>
<a id='n2520' href='#n2520'>2520</a>
<a id='n2521' href='#n2521'>2521</a>
<a id='n2522' href='#n2522'>2522</a>
<a id='n2523' href='#n2523'>2523</a>
<a id='n2524' href='#n2524'>2524</a>
<a id='n2525' href='#n2525'>2525</a>
<a id='n2526' href='#n2526'>2526</a>
<a id='n2527' href='#n2527'>2527</a>
<a id='n2528' href='#n2528'>2528</a>
<a id='n2529' href='#n2529'>2529</a>
<a id='n2530' href='#n2530'>2530</a>
<a id='n2531' href='#n2531'>2531</a>
<a id='n2532' href='#n2532'>2532</a>
<a id='n2533' href='#n2533'>2533</a>
<a id='n2534' href='#n2534'>2534</a>
<a id='n2535' href='#n2535'>2535</a>
<a id='n2536' href='#n2536'>2536</a>
<a id='n2537' href='#n2537'>2537</a>
<a id='n2538' href='#n2538'>2538</a>
<a id='n2539' href='#n2539'>2539</a>
<a id='n2540' href='#n2540'>2540</a>
<a id='n2541' href='#n2541'>2541</a>
<a id='n2542' href='#n2542'>2542</a>
<a id='n2543' href='#n2543'>2543</a>
<a id='n2544' href='#n2544'>2544</a>
<a id='n2545' href='#n2545'>2545</a>
<a id='n2546' href='#n2546'>2546</a>
<a id='n2547' href='#n2547'>2547</a>
<a id='n2548' href='#n2548'>2548</a>
<a id='n2549' href='#n2549'>2549</a>
<a id='n2550' href='#n2550'>2550</a>
<a id='n2551' href='#n2551'>2551</a>
<a id='n2552' href='#n2552'>2552</a>
<a id='n2553' href='#n2553'>2553</a>
<a id='n2554' href='#n2554'>2554</a>
<a id='n2555' href='#n2555'>2555</a>
<a id='n2556' href='#n2556'>2556</a>
<a id='n2557' href='#n2557'>2557</a>
<a id='n2558' href='#n2558'>2558</a>
<a id='n2559' href='#n2559'>2559</a>
<a id='n2560' href='#n2560'>2560</a>
<a id='n2561' href='#n2561'>2561</a>
<a id='n2562' href='#n2562'>2562</a>
<a id='n2563' href='#n2563'>2563</a>
<a id='n2564' href='#n2564'>2564</a>
<a id='n2565' href='#n2565'>2565</a>
<a id='n2566' href='#n2566'>2566</a>
<a id='n2567' href='#n2567'>2567</a>
<a id='n2568' href='#n2568'>2568</a>
<a id='n2569' href='#n2569'>2569</a>
<a id='n2570' href='#n2570'>2570</a>
<a id='n2571' href='#n2571'>2571</a>
<a id='n2572' href='#n2572'>2572</a>
<a id='n2573' href='#n2573'>2573</a>
<a id='n2574' href='#n2574'>2574</a>
<a id='n2575' href='#n2575'>2575</a>
<a id='n2576' href='#n2576'>2576</a>
<a id='n2577' href='#n2577'>2577</a>
<a id='n2578' href='#n2578'>2578</a>
<a id='n2579' href='#n2579'>2579</a>
<a id='n2580' href='#n2580'>2580</a>
<a id='n2581' href='#n2581'>2581</a>
<a id='n2582' href='#n2582'>2582</a>
<a id='n2583' href='#n2583'>2583</a>
<a id='n2584' href='#n2584'>2584</a>
<a id='n2585' href='#n2585'>2585</a>
<a id='n2586' href='#n2586'>2586</a>
<a id='n2587' href='#n2587'>2587</a>
<a id='n2588' href='#n2588'>2588</a>
<a id='n2589' href='#n2589'>2589</a>
<a id='n2590' href='#n2590'>2590</a>
<a id='n2591' href='#n2591'>2591</a>
<a id='n2592' href='#n2592'>2592</a>
<a id='n2593' href='#n2593'>2593</a>
<a id='n2594' href='#n2594'>2594</a>
<a id='n2595' href='#n2595'>2595</a>
<a id='n2596' href='#n2596'>2596</a>
<a id='n2597' href='#n2597'>2597</a>
<a id='n2598' href='#n2598'>2598</a>
<a id='n2599' href='#n2599'>2599</a>
<a id='n2600' href='#n2600'>2600</a>
<a id='n2601' href='#n2601'>2601</a>
<a id='n2602' href='#n2602'>2602</a>
<a id='n2603' href='#n2603'>2603</a>
<a id='n2604' href='#n2604'>2604</a>
<a id='n2605' href='#n2605'>2605</a>
<a id='n2606' href='#n2606'>2606</a>
<a id='n2607' href='#n2607'>2607</a>
<a id='n2608' href='#n2608'>2608</a>
<a id='n2609' href='#n2609'>2609</a>
<a id='n2610' href='#n2610'>2610</a>
<a id='n2611' href='#n2611'>2611</a>
<a id='n2612' href='#n2612'>2612</a>
<a id='n2613' href='#n2613'>2613</a>
<a id='n2614' href='#n2614'>2614</a>
<a id='n2615' href='#n2615'>2615</a>
<a id='n2616' href='#n2616'>2616</a>
<a id='n2617' href='#n2617'>2617</a>
<a id='n2618' href='#n2618'>2618</a>
<a id='n2619' href='#n2619'>2619</a>
<a id='n2620' href='#n2620'>2620</a>
<a id='n2621' href='#n2621'>2621</a>
<a id='n2622' href='#n2622'>2622</a>
<a id='n2623' href='#n2623'>2623</a>
<a id='n2624' href='#n2624'>2624</a>
<a id='n2625' href='#n2625'>2625</a>
<a id='n2626' href='#n2626'>2626</a>
<a id='n2627' href='#n2627'>2627</a>
<a id='n2628' href='#n2628'>2628</a>
<a id='n2629' href='#n2629'>2629</a>
<a id='n2630' href='#n2630'>2630</a>
<a id='n2631' href='#n2631'>2631</a>
<a id='n2632' href='#n2632'>2632</a>
<a id='n2633' href='#n2633'>2633</a>
<a id='n2634' href='#n2634'>2634</a>
<a id='n2635' href='#n2635'>2635</a>
<a id='n2636' href='#n2636'>2636</a>
<a id='n2637' href='#n2637'>2637</a>
<a id='n2638' href='#n2638'>2638</a>
<a id='n2639' href='#n2639'>2639</a>
<a id='n2640' href='#n2640'>2640</a>
<a id='n2641' href='#n2641'>2641</a>
<a id='n2642' href='#n2642'>2642</a>
<a id='n2643' href='#n2643'>2643</a>
<a id='n2644' href='#n2644'>2644</a>
<a id='n2645' href='#n2645'>2645</a>
<a id='n2646' href='#n2646'>2646</a>
<a id='n2647' href='#n2647'>2647</a>
<a id='n2648' href='#n2648'>2648</a>
<a id='n2649' href='#n2649'>2649</a>
<a id='n2650' href='#n2650'>2650</a>
<a id='n2651' href='#n2651'>2651</a>
<a id='n2652' href='#n2652'>2652</a>
<a id='n2653' href='#n2653'>2653</a>
<a id='n2654' href='#n2654'>2654</a>
<a id='n2655' href='#n2655'>2655</a>
<a id='n2656' href='#n2656'>2656</a>
<a id='n2657' href='#n2657'>2657</a>
<a id='n2658' href='#n2658'>2658</a>
<a id='n2659' href='#n2659'>2659</a>
<a id='n2660' href='#n2660'>2660</a>
<a id='n2661' href='#n2661'>2661</a>
<a id='n2662' href='#n2662'>2662</a>
<a id='n2663' href='#n2663'>2663</a>
<a id='n2664' href='#n2664'>2664</a>
<a id='n2665' href='#n2665'>2665</a>
<a id='n2666' href='#n2666'>2666</a>
<a id='n2667' href='#n2667'>2667</a>
<a id='n2668' href='#n2668'>2668</a>
<a id='n2669' href='#n2669'>2669</a>
<a id='n2670' href='#n2670'>2670</a>
<a id='n2671' href='#n2671'>2671</a>
<a id='n2672' href='#n2672'>2672</a>
<a id='n2673' href='#n2673'>2673</a>
<a id='n2674' href='#n2674'>2674</a>
<a id='n2675' href='#n2675'>2675</a>
<a id='n2676' href='#n2676'>2676</a>
<a id='n2677' href='#n2677'>2677</a>
<a id='n2678' href='#n2678'>2678</a>
<a id='n2679' href='#n2679'>2679</a>
<a id='n2680' href='#n2680'>2680</a>
<a id='n2681' href='#n2681'>2681</a>
<a id='n2682' href='#n2682'>2682</a>
<a id='n2683' href='#n2683'>2683</a>
<a id='n2684' href='#n2684'>2684</a>
<a id='n2685' href='#n2685'>2685</a>
<a id='n2686' href='#n2686'>2686</a>
<a id='n2687' href='#n2687'>2687</a>
<a id='n2688' href='#n2688'>2688</a>
<a id='n2689' href='#n2689'>2689</a>
<a id='n2690' href='#n2690'>2690</a>
<a id='n2691' href='#n2691'>2691</a>
<a id='n2692' href='#n2692'>2692</a>
<a id='n2693' href='#n2693'>2693</a>
<a id='n2694' href='#n2694'>2694</a>
<a id='n2695' href='#n2695'>2695</a>
<a id='n2696' href='#n2696'>2696</a>
<a id='n2697' href='#n2697'>2697</a>
<a id='n2698' href='#n2698'>2698</a>
<a id='n2699' href='#n2699'>2699</a>
<a id='n2700' href='#n2700'>2700</a>
<a id='n2701' href='#n2701'>2701</a>
<a id='n2702' href='#n2702'>2702</a>
<a id='n2703' href='#n2703'>2703</a>
<a id='n2704' href='#n2704'>2704</a>
<a id='n2705' href='#n2705'>2705</a>
<a id='n2706' href='#n2706'>2706</a>
<a id='n2707' href='#n2707'>2707</a>
<a id='n2708' href='#n2708'>2708</a>
<a id='n2709' href='#n2709'>2709</a>
<a id='n2710' href='#n2710'>2710</a>
<a id='n2711' href='#n2711'>2711</a>
<a id='n2712' href='#n2712'>2712</a>
<a id='n2713' href='#n2713'>2713</a>
<a id='n2714' href='#n2714'>2714</a>
<a id='n2715' href='#n2715'>2715</a>
<a id='n2716' href='#n2716'>2716</a>
<a id='n2717' href='#n2717'>2717</a>
<a id='n2718' href='#n2718'>2718</a>
<a id='n2719' href='#n2719'>2719</a>
<a id='n2720' href='#n2720'>2720</a>
<a id='n2721' href='#n2721'>2721</a>
<a id='n2722' href='#n2722'>2722</a>
<a id='n2723' href='#n2723'>2723</a>
<a id='n2724' href='#n2724'>2724</a>
<a id='n2725' href='#n2725'>2725</a>
<a id='n2726' href='#n2726'>2726</a>
<a id='n2727' href='#n2727'>2727</a>
<a id='n2728' href='#n2728'>2728</a>
<a id='n2729' href='#n2729'>2729</a>
<a id='n2730' href='#n2730'>2730</a>
<a id='n2731' href='#n2731'>2731</a>
<a id='n2732' href='#n2732'>2732</a>
<a id='n2733' href='#n2733'>2733</a>
<a id='n2734' href='#n2734'>2734</a>
<a id='n2735' href='#n2735'>2735</a>
<a id='n2736' href='#n2736'>2736</a>
<a id='n2737' href='#n2737'>2737</a>
<a id='n2738' href='#n2738'>2738</a>
<a id='n2739' href='#n2739'>2739</a>
<a id='n2740' href='#n2740'>2740</a>
<a id='n2741' href='#n2741'>2741</a>
<a id='n2742' href='#n2742'>2742</a>
<a id='n2743' href='#n2743'>2743</a>
<a id='n2744' href='#n2744'>2744</a>
<a id='n2745' href='#n2745'>2745</a>
<a id='n2746' href='#n2746'>2746</a>
<a id='n2747' href='#n2747'>2747</a>
<a id='n2748' href='#n2748'>2748</a>
<a id='n2749' href='#n2749'>2749</a>
<a id='n2750' href='#n2750'>2750</a>
<a id='n2751' href='#n2751'>2751</a>
<a id='n2752' href='#n2752'>2752</a>
<a id='n2753' href='#n2753'>2753</a>
<a id='n2754' href='#n2754'>2754</a>
<a id='n2755' href='#n2755'>2755</a>
<a id='n2756' href='#n2756'>2756</a>
<a id='n2757' href='#n2757'>2757</a>
<a id='n2758' href='#n2758'>2758</a>
<a id='n2759' href='#n2759'>2759</a>
<a id='n2760' href='#n2760'>2760</a>
<a id='n2761' href='#n2761'>2761</a>
<a id='n2762' href='#n2762'>2762</a>
<a id='n2763' href='#n2763'>2763</a>
<a id='n2764' href='#n2764'>2764</a>
<a id='n2765' href='#n2765'>2765</a>
<a id='n2766' href='#n2766'>2766</a>
<a id='n2767' href='#n2767'>2767</a>
<a id='n2768' href='#n2768'>2768</a>
<a id='n2769' href='#n2769'>2769</a>
<a id='n2770' href='#n2770'>2770</a>
<a id='n2771' href='#n2771'>2771</a>
<a id='n2772' href='#n2772'>2772</a>
<a id='n2773' href='#n2773'>2773</a>
<a id='n2774' href='#n2774'>2774</a>
<a id='n2775' href='#n2775'>2775</a>
<a id='n2776' href='#n2776'>2776</a>
<a id='n2777' href='#n2777'>2777</a>
<a id='n2778' href='#n2778'>2778</a>
<a id='n2779' href='#n2779'>2779</a>
<a id='n2780' href='#n2780'>2780</a>
<a id='n2781' href='#n2781'>2781</a>
<a id='n2782' href='#n2782'>2782</a>
<a id='n2783' href='#n2783'>2783</a>
<a id='n2784' href='#n2784'>2784</a>
<a id='n2785' href='#n2785'>2785</a>
<a id='n2786' href='#n2786'>2786</a>
<a id='n2787' href='#n2787'>2787</a>
<a id='n2788' href='#n2788'>2788</a>
<a id='n2789' href='#n2789'>2789</a>
<a id='n2790' href='#n2790'>2790</a>
<a id='n2791' href='#n2791'>2791</a>
<a id='n2792' href='#n2792'>2792</a>
<a id='n2793' href='#n2793'>2793</a>
<a id='n2794' href='#n2794'>2794</a>
<a id='n2795' href='#n2795'>2795</a>
<a id='n2796' href='#n2796'>2796</a>
<a id='n2797' href='#n2797'>2797</a>
<a id='n2798' href='#n2798'>2798</a>
<a id='n2799' href='#n2799'>2799</a>
<a id='n2800' href='#n2800'>2800</a>
<a id='n2801' href='#n2801'>2801</a>
<a id='n2802' href='#n2802'>2802</a>
<a id='n2803' href='#n2803'>2803</a>
<a id='n2804' href='#n2804'>2804</a>
<a id='n2805' href='#n2805'>2805</a>
<a id='n2806' href='#n2806'>2806</a>
<a id='n2807' href='#n2807'>2807</a>
<a id='n2808' href='#n2808'>2808</a>
<a id='n2809' href='#n2809'>2809</a>
<a id='n2810' href='#n2810'>2810</a>
<a id='n2811' href='#n2811'>2811</a>
<a id='n2812' href='#n2812'>2812</a>
<a id='n2813' href='#n2813'>2813</a>
<a id='n2814' href='#n2814'>2814</a>
<a id='n2815' href='#n2815'>2815</a>
<a id='n2816' href='#n2816'>2816</a>
<a id='n2817' href='#n2817'>2817</a>
<a id='n2818' href='#n2818'>2818</a>
<a id='n2819' href='#n2819'>2819</a>
<a id='n2820' href='#n2820'>2820</a>
<a id='n2821' href='#n2821'>2821</a>
<a id='n2822' href='#n2822'>2822</a>
<a id='n2823' href='#n2823'>2823</a>
<a id='n2824' href='#n2824'>2824</a>
<a id='n2825' href='#n2825'>2825</a>
<a id='n2826' href='#n2826'>2826</a>
<a id='n2827' href='#n2827'>2827</a>
<a id='n2828' href='#n2828'>2828</a>
<a id='n2829' href='#n2829'>2829</a>
<a id='n2830' href='#n2830'>2830</a>
<a id='n2831' href='#n2831'>2831</a>
<a id='n2832' href='#n2832'>2832</a>
<a id='n2833' href='#n2833'>2833</a>
<a id='n2834' href='#n2834'>2834</a>
<a id='n2835' href='#n2835'>2835</a>
<a id='n2836' href='#n2836'>2836</a>
<a id='n2837' href='#n2837'>2837</a>
<a id='n2838' href='#n2838'>2838</a>
<a id='n2839' href='#n2839'>2839</a>
<a id='n2840' href='#n2840'>2840</a>
<a id='n2841' href='#n2841'>2841</a>
<a id='n2842' href='#n2842'>2842</a>
<a id='n2843' href='#n2843'>2843</a>
<a id='n2844' href='#n2844'>2844</a>
<a id='n2845' href='#n2845'>2845</a>
<a id='n2846' href='#n2846'>2846</a>
<a id='n2847' href='#n2847'>2847</a>
<a id='n2848' href='#n2848'>2848</a>
<a id='n2849' href='#n2849'>2849</a>
<a id='n2850' href='#n2850'>2850</a>
<a id='n2851' href='#n2851'>2851</a>
<a id='n2852' href='#n2852'>2852</a>
<a id='n2853' href='#n2853'>2853</a>
<a id='n2854' href='#n2854'>2854</a>
<a id='n2855' href='#n2855'>2855</a>
<a id='n2856' href='#n2856'>2856</a>
<a id='n2857' href='#n2857'>2857</a>
<a id='n2858' href='#n2858'>2858</a>
<a id='n2859' href='#n2859'>2859</a>
<a id='n2860' href='#n2860'>2860</a>
<a id='n2861' href='#n2861'>2861</a>
<a id='n2862' href='#n2862'>2862</a>
<a id='n2863' href='#n2863'>2863</a>
<a id='n2864' href='#n2864'>2864</a>
<a id='n2865' href='#n2865'>2865</a>
<a id='n2866' href='#n2866'>2866</a>
<a id='n2867' href='#n2867'>2867</a>
<a id='n2868' href='#n2868'>2868</a>
<a id='n2869' href='#n2869'>2869</a>
<a id='n2870' href='#n2870'>2870</a>
<a id='n2871' href='#n2871'>2871</a>
<a id='n2872' href='#n2872'>2872</a>
<a id='n2873' href='#n2873'>2873</a>
<a id='n2874' href='#n2874'>2874</a>
<a id='n2875' href='#n2875'>2875</a>
<a id='n2876' href='#n2876'>2876</a>
<a id='n2877' href='#n2877'>2877</a>
<a id='n2878' href='#n2878'>2878</a>
<a id='n2879' href='#n2879'>2879</a>
<a id='n2880' href='#n2880'>2880</a>
<a id='n2881' href='#n2881'>2881</a>
<a id='n2882' href='#n2882'>2882</a>
<a id='n2883' href='#n2883'>2883</a>
<a id='n2884' href='#n2884'>2884</a>
<a id='n2885' href='#n2885'>2885</a>
<a id='n2886' href='#n2886'>2886</a>
<a id='n2887' href='#n2887'>2887</a>
<a id='n2888' href='#n2888'>2888</a>
<a id='n2889' href='#n2889'>2889</a>
<a id='n2890' href='#n2890'>2890</a>
<a id='n2891' href='#n2891'>2891</a>
<a id='n2892' href='#n2892'>2892</a>
<a id='n2893' href='#n2893'>2893</a>
<a id='n2894' href='#n2894'>2894</a>
<a id='n2895' href='#n2895'>2895</a>
<a id='n2896' href='#n2896'>2896</a>
<a id='n2897' href='#n2897'>2897</a>
<a id='n2898' href='#n2898'>2898</a>
<a id='n2899' href='#n2899'>2899</a>
<a id='n2900' href='#n2900'>2900</a>
<a id='n2901' href='#n2901'>2901</a>
<a id='n2902' href='#n2902'>2902</a>
<a id='n2903' href='#n2903'>2903</a>
<a id='n2904' href='#n2904'>2904</a>
<a id='n2905' href='#n2905'>2905</a>
<a id='n2906' href='#n2906'>2906</a>
<a id='n2907' href='#n2907'>2907</a>
<a id='n2908' href='#n2908'>2908</a>
<a id='n2909' href='#n2909'>2909</a>
<a id='n2910' href='#n2910'>2910</a>
<a id='n2911' href='#n2911'>2911</a>
<a id='n2912' href='#n2912'>2912</a>
<a id='n2913' href='#n2913'>2913</a>
<a id='n2914' href='#n2914'>2914</a>
<a id='n2915' href='#n2915'>2915</a>
<a id='n2916' href='#n2916'>2916</a>
<a id='n2917' href='#n2917'>2917</a>
<a id='n2918' href='#n2918'>2918</a>
<a id='n2919' href='#n2919'>2919</a>
<a id='n2920' href='#n2920'>2920</a>
<a id='n2921' href='#n2921'>2921</a>
<a id='n2922' href='#n2922'>2922</a>
<a id='n2923' href='#n2923'>2923</a>
<a id='n2924' href='#n2924'>2924</a>
<a id='n2925' href='#n2925'>2925</a>
<a id='n2926' href='#n2926'>2926</a>
<a id='n2927' href='#n2927'>2927</a>
<a id='n2928' href='#n2928'>2928</a>
<a id='n2929' href='#n2929'>2929</a>
<a id='n2930' href='#n2930'>2930</a>
<a id='n2931' href='#n2931'>2931</a>
<a id='n2932' href='#n2932'>2932</a>
<a id='n2933' href='#n2933'>2933</a>
<a id='n2934' href='#n2934'>2934</a>
<a id='n2935' href='#n2935'>2935</a>
<a id='n2936' href='#n2936'>2936</a>
<a id='n2937' href='#n2937'>2937</a>
<a id='n2938' href='#n2938'>2938</a>
<a id='n2939' href='#n2939'>2939</a>
<a id='n2940' href='#n2940'>2940</a>
<a id='n2941' href='#n2941'>2941</a>
<a id='n2942' href='#n2942'>2942</a>
<a id='n2943' href='#n2943'>2943</a>
<a id='n2944' href='#n2944'>2944</a>
<a id='n2945' href='#n2945'>2945</a>
<a id='n2946' href='#n2946'>2946</a>
<a id='n2947' href='#n2947'>2947</a>
<a id='n2948' href='#n2948'>2948</a>
<a id='n2949' href='#n2949'>2949</a>
<a id='n2950' href='#n2950'>2950</a>
<a id='n2951' href='#n2951'>2951</a>
<a id='n2952' href='#n2952'>2952</a>
<a id='n2953' href='#n2953'>2953</a>
<a id='n2954' href='#n2954'>2954</a>
<a id='n2955' href='#n2955'>2955</a>
<a id='n2956' href='#n2956'>2956</a>
<a id='n2957' href='#n2957'>2957</a>
<a id='n2958' href='#n2958'>2958</a>
<a id='n2959' href='#n2959'>2959</a>
<a id='n2960' href='#n2960'>2960</a>
<a id='n2961' href='#n2961'>2961</a>
<a id='n2962' href='#n2962'>2962</a>
<a id='n2963' href='#n2963'>2963</a>
<a id='n2964' href='#n2964'>2964</a>
<a id='n2965' href='#n2965'>2965</a>
<a id='n2966' href='#n2966'>2966</a>
<a id='n2967' href='#n2967'>2967</a>
<a id='n2968' href='#n2968'>2968</a>
<a id='n2969' href='#n2969'>2969</a>
<a id='n2970' href='#n2970'>2970</a>
<a id='n2971' href='#n2971'>2971</a>
<a id='n2972' href='#n2972'>2972</a>
<a id='n2973' href='#n2973'>2973</a>
<a id='n2974' href='#n2974'>2974</a>
<a id='n2975' href='#n2975'>2975</a>
<a id='n2976' href='#n2976'>2976</a>
<a id='n2977' href='#n2977'>2977</a>
<a id='n2978' href='#n2978'>2978</a>
<a id='n2979' href='#n2979'>2979</a>
<a id='n2980' href='#n2980'>2980</a>
<a id='n2981' href='#n2981'>2981</a>
<a id='n2982' href='#n2982'>2982</a>
<a id='n2983' href='#n2983'>2983</a>
<a id='n2984' href='#n2984'>2984</a>
<a id='n2985' href='#n2985'>2985</a>
<a id='n2986' href='#n2986'>2986</a>
<a id='n2987' href='#n2987'>2987</a>
<a id='n2988' href='#n2988'>2988</a>
<a id='n2989' href='#n2989'>2989</a>
<a id='n2990' href='#n2990'>2990</a>
<a id='n2991' href='#n2991'>2991</a>
<a id='n2992' href='#n2992'>2992</a>
<a id='n2993' href='#n2993'>2993</a>
<a id='n2994' href='#n2994'>2994</a>
<a id='n2995' href='#n2995'>2995</a>
<a id='n2996' href='#n2996'>2996</a>
<a id='n2997' href='#n2997'>2997</a>
<a id='n2998' href='#n2998'>2998</a>
<a id='n2999' href='#n2999'>2999</a>
<a id='n3000' href='#n3000'>3000</a>
<a id='n3001' href='#n3001'>3001</a>
<a id='n3002' href='#n3002'>3002</a>
<a id='n3003' href='#n3003'>3003</a>
<a id='n3004' href='#n3004'>3004</a>
<a id='n3005' href='#n3005'>3005</a>
<a id='n3006' href='#n3006'>3006</a>
<a id='n3007' href='#n3007'>3007</a>
<a id='n3008' href='#n3008'>3008</a>
<a id='n3009' href='#n3009'>3009</a>
<a id='n3010' href='#n3010'>3010</a>
<a id='n3011' href='#n3011'>3011</a>
<a id='n3012' href='#n3012'>3012</a>
<a id='n3013' href='#n3013'>3013</a>
<a id='n3014' href='#n3014'>3014</a>
<a id='n3015' href='#n3015'>3015</a>
<a id='n3016' href='#n3016'>3016</a>
<a id='n3017' href='#n3017'>3017</a>
<a id='n3018' href='#n3018'>3018</a>
<a id='n3019' href='#n3019'>3019</a>
<a id='n3020' href='#n3020'>3020</a>
<a id='n3021' href='#n3021'>3021</a>
<a id='n3022' href='#n3022'>3022</a>
<a id='n3023' href='#n3023'>3023</a>
<a id='n3024' href='#n3024'>3024</a>
<a id='n3025' href='#n3025'>3025</a>
<a id='n3026' href='#n3026'>3026</a>
<a id='n3027' href='#n3027'>3027</a>
<a id='n3028' href='#n3028'>3028</a>
<a id='n3029' href='#n3029'>3029</a>
<a id='n3030' href='#n3030'>3030</a>
<a id='n3031' href='#n3031'>3031</a>
<a id='n3032' href='#n3032'>3032</a>
<a id='n3033' href='#n3033'>3033</a>
<a id='n3034' href='#n3034'>3034</a>
<a id='n3035' href='#n3035'>3035</a>
<a id='n3036' href='#n3036'>3036</a>
<a id='n3037' href='#n3037'>3037</a>
<a id='n3038' href='#n3038'>3038</a>
<a id='n3039' href='#n3039'>3039</a>
<a id='n3040' href='#n3040'>3040</a>
<a id='n3041' href='#n3041'>3041</a>
<a id='n3042' href='#n3042'>3042</a>
<a id='n3043' href='#n3043'>3043</a>
<a id='n3044' href='#n3044'>3044</a>
<a id='n3045' href='#n3045'>3045</a>
<a id='n3046' href='#n3046'>3046</a>
<a id='n3047' href='#n3047'>3047</a>
<a id='n3048' href='#n3048'>3048</a>
<a id='n3049' href='#n3049'>3049</a>
<a id='n3050' href='#n3050'>3050</a>
<a id='n3051' href='#n3051'>3051</a>
<a id='n3052' href='#n3052'>3052</a>
<a id='n3053' href='#n3053'>3053</a>
<a id='n3054' href='#n3054'>3054</a>
<a id='n3055' href='#n3055'>3055</a>
<a id='n3056' href='#n3056'>3056</a>
<a id='n3057' href='#n3057'>3057</a>
<a id='n3058' href='#n3058'>3058</a>
<a id='n3059' href='#n3059'>3059</a>
<a id='n3060' href='#n3060'>3060</a>
<a id='n3061' href='#n3061'>3061</a>
<a id='n3062' href='#n3062'>3062</a>
<a id='n3063' href='#n3063'>3063</a>
<a id='n3064' href='#n3064'>3064</a>
<a id='n3065' href='#n3065'>3065</a>
<a id='n3066' href='#n3066'>3066</a>
<a id='n3067' href='#n3067'>3067</a>
<a id='n3068' href='#n3068'>3068</a>
<a id='n3069' href='#n3069'>3069</a>
<a id='n3070' href='#n3070'>3070</a>
<a id='n3071' href='#n3071'>3071</a>
<a id='n3072' href='#n3072'>3072</a>
<a id='n3073' href='#n3073'>3073</a>
<a id='n3074' href='#n3074'>3074</a>
<a id='n3075' href='#n3075'>3075</a>
<a id='n3076' href='#n3076'>3076</a>
<a id='n3077' href='#n3077'>3077</a>
<a id='n3078' href='#n3078'>3078</a>
<a id='n3079' href='#n3079'>3079</a>
<a id='n3080' href='#n3080'>3080</a>
<a id='n3081' href='#n3081'>3081</a>
<a id='n3082' href='#n3082'>3082</a>
<a id='n3083' href='#n3083'>3083</a>
<a id='n3084' href='#n3084'>3084</a>
<a id='n3085' href='#n3085'>3085</a>
<a id='n3086' href='#n3086'>3086</a>
<a id='n3087' href='#n3087'>3087</a>
<a id='n3088' href='#n3088'>3088</a>
<a id='n3089' href='#n3089'>3089</a>
<a id='n3090' href='#n3090'>3090</a>
<a id='n3091' href='#n3091'>3091</a>
<a id='n3092' href='#n3092'>3092</a>
<a id='n3093' href='#n3093'>3093</a>
<a id='n3094' href='#n3094'>3094</a>
<a id='n3095' href='#n3095'>3095</a>
<a id='n3096' href='#n3096'>3096</a>
<a id='n3097' href='#n3097'>3097</a>
<a id='n3098' href='#n3098'>3098</a>
<a id='n3099' href='#n3099'>3099</a>
<a id='n3100' href='#n3100'>3100</a>
<a id='n3101' href='#n3101'>3101</a>
<a id='n3102' href='#n3102'>3102</a>
<a id='n3103' href='#n3103'>3103</a>
<a id='n3104' href='#n3104'>3104</a>
<a id='n3105' href='#n3105'>3105</a>
<a id='n3106' href='#n3106'>3106</a>
<a id='n3107' href='#n3107'>3107</a>
<a id='n3108' href='#n3108'>3108</a>
<a id='n3109' href='#n3109'>3109</a>
<a id='n3110' href='#n3110'>3110</a>
<a id='n3111' href='#n3111'>3111</a>
<a id='n3112' href='#n3112'>3112</a>
<a id='n3113' href='#n3113'>3113</a>
<a id='n3114' href='#n3114'>3114</a>
<a id='n3115' href='#n3115'>3115</a>
<a id='n3116' href='#n3116'>3116</a>
<a id='n3117' href='#n3117'>3117</a>
<a id='n3118' href='#n3118'>3118</a>
<a id='n3119' href='#n3119'>3119</a>
<a id='n3120' href='#n3120'>3120</a>
<a id='n3121' href='#n3121'>3121</a>
<a id='n3122' href='#n3122'>3122</a>
<a id='n3123' href='#n3123'>3123</a>
<a id='n3124' href='#n3124'>3124</a>
<a id='n3125' href='#n3125'>3125</a>
<a id='n3126' href='#n3126'>3126</a>
<a id='n3127' href='#n3127'>3127</a>
<a id='n3128' href='#n3128'>3128</a>
<a id='n3129' href='#n3129'>3129</a>
<a id='n3130' href='#n3130'>3130</a>
<a id='n3131' href='#n3131'>3131</a>
<a id='n3132' href='#n3132'>3132</a>
<a id='n3133' href='#n3133'>3133</a>
<a id='n3134' href='#n3134'>3134</a>
<a id='n3135' href='#n3135'>3135</a>
<a id='n3136' href='#n3136'>3136</a>
<a id='n3137' href='#n3137'>3137</a>
<a id='n3138' href='#n3138'>3138</a>
<a id='n3139' href='#n3139'>3139</a>
<a id='n3140' href='#n3140'>3140</a>
<a id='n3141' href='#n3141'>3141</a>
<a id='n3142' href='#n3142'>3142</a>
<a id='n3143' href='#n3143'>3143</a>
<a id='n3144' href='#n3144'>3144</a>
<a id='n3145' href='#n3145'>3145</a>
<a id='n3146' href='#n3146'>3146</a>
<a id='n3147' href='#n3147'>3147</a>
<a id='n3148' href='#n3148'>3148</a>
<a id='n3149' href='#n3149'>3149</a>
<a id='n3150' href='#n3150'>3150</a>
<a id='n3151' href='#n3151'>3151</a>
<a id='n3152' href='#n3152'>3152</a>
<a id='n3153' href='#n3153'>3153</a>
<a id='n3154' href='#n3154'>3154</a>
<a id='n3155' href='#n3155'>3155</a>
<a id='n3156' href='#n3156'>3156</a>
<a id='n3157' href='#n3157'>3157</a>
<a id='n3158' href='#n3158'>3158</a>
<a id='n3159' href='#n3159'>3159</a>
<a id='n3160' href='#n3160'>3160</a>
<a id='n3161' href='#n3161'>3161</a>
<a id='n3162' href='#n3162'>3162</a>
<a id='n3163' href='#n3163'>3163</a>
<a id='n3164' href='#n3164'>3164</a>
<a id='n3165' href='#n3165'>3165</a>
<a id='n3166' href='#n3166'>3166</a>
<a id='n3167' href='#n3167'>3167</a>
<a id='n3168' href='#n3168'>3168</a>
<a id='n3169' href='#n3169'>3169</a>
<a id='n3170' href='#n3170'>3170</a>
<a id='n3171' href='#n3171'>3171</a>
<a id='n3172' href='#n3172'>3172</a>
<a id='n3173' href='#n3173'>3173</a>
<a id='n3174' href='#n3174'>3174</a>
<a id='n3175' href='#n3175'>3175</a>
<a id='n3176' href='#n3176'>3176</a>
<a id='n3177' href='#n3177'>3177</a>
<a id='n3178' href='#n3178'>3178</a>
<a id='n3179' href='#n3179'>3179</a>
<a id='n3180' href='#n3180'>3180</a>
<a id='n3181' href='#n3181'>3181</a>
<a id='n3182' href='#n3182'>3182</a>
<a id='n3183' href='#n3183'>3183</a>
<a id='n3184' href='#n3184'>3184</a>
<a id='n3185' href='#n3185'>3185</a>
<a id='n3186' href='#n3186'>3186</a>
<a id='n3187' href='#n3187'>3187</a>
<a id='n3188' href='#n3188'>3188</a>
<a id='n3189' href='#n3189'>3189</a>
<a id='n3190' href='#n3190'>3190</a>
<a id='n3191' href='#n3191'>3191</a>
<a id='n3192' href='#n3192'>3192</a>
<a id='n3193' href='#n3193'>3193</a>
<a id='n3194' href='#n3194'>3194</a>
<a id='n3195' href='#n3195'>3195</a>
<a id='n3196' href='#n3196'>3196</a>
<a id='n3197' href='#n3197'>3197</a>
<a id='n3198' href='#n3198'>3198</a>
<a id='n3199' href='#n3199'>3199</a>
<a id='n3200' href='#n3200'>3200</a>
<a id='n3201' href='#n3201'>3201</a>
<a id='n3202' href='#n3202'>3202</a>
<a id='n3203' href='#n3203'>3203</a>
<a id='n3204' href='#n3204'>3204</a>
<a id='n3205' href='#n3205'>3205</a>
<a id='n3206' href='#n3206'>3206</a>
<a id='n3207' href='#n3207'>3207</a>
<a id='n3208' href='#n3208'>3208</a>
<a id='n3209' href='#n3209'>3209</a>
<a id='n3210' href='#n3210'>3210</a>
<a id='n3211' href='#n3211'>3211</a>
<a id='n3212' href='#n3212'>3212</a>
<a id='n3213' href='#n3213'>3213</a>
<a id='n3214' href='#n3214'>3214</a>
<a id='n3215' href='#n3215'>3215</a>
<a id='n3216' href='#n3216'>3216</a>
<a id='n3217' href='#n3217'>3217</a>
<a id='n3218' href='#n3218'>3218</a>
<a id='n3219' href='#n3219'>3219</a>
<a id='n3220' href='#n3220'>3220</a>
<a id='n3221' href='#n3221'>3221</a>
<a id='n3222' href='#n3222'>3222</a>
<a id='n3223' href='#n3223'>3223</a>
<a id='n3224' href='#n3224'>3224</a>
<a id='n3225' href='#n3225'>3225</a>
<a id='n3226' href='#n3226'>3226</a>
<a id='n3227' href='#n3227'>3227</a>
<a id='n3228' href='#n3228'>3228</a>
<a id='n3229' href='#n3229'>3229</a>
<a id='n3230' href='#n3230'>3230</a>
<a id='n3231' href='#n3231'>3231</a>
<a id='n3232' href='#n3232'>3232</a>
<a id='n3233' href='#n3233'>3233</a>
<a id='n3234' href='#n3234'>3234</a>
<a id='n3235' href='#n3235'>3235</a>
<a id='n3236' href='#n3236'>3236</a>
<a id='n3237' href='#n3237'>3237</a>
<a id='n3238' href='#n3238'>3238</a>
<a id='n3239' href='#n3239'>3239</a>
<a id='n3240' href='#n3240'>3240</a>
<a id='n3241' href='#n3241'>3241</a>
<a id='n3242' href='#n3242'>3242</a>
<a id='n3243' href='#n3243'>3243</a>
<a id='n3244' href='#n3244'>3244</a>
<a id='n3245' href='#n3245'>3245</a>
<a id='n3246' href='#n3246'>3246</a>
<a id='n3247' href='#n3247'>3247</a>
<a id='n3248' href='#n3248'>3248</a>
<a id='n3249' href='#n3249'>3249</a>
<a id='n3250' href='#n3250'>3250</a>
<a id='n3251' href='#n3251'>3251</a>
<a id='n3252' href='#n3252'>3252</a>
<a id='n3253' href='#n3253'>3253</a>
<a id='n3254' href='#n3254'>3254</a>
<a id='n3255' href='#n3255'>3255</a>
<a id='n3256' href='#n3256'>3256</a>
<a id='n3257' href='#n3257'>3257</a>
<a id='n3258' href='#n3258'>3258</a>
<a id='n3259' href='#n3259'>3259</a>
<a id='n3260' href='#n3260'>3260</a>
<a id='n3261' href='#n3261'>3261</a>
<a id='n3262' href='#n3262'>3262</a>
<a id='n3263' href='#n3263'>3263</a>
<a id='n3264' href='#n3264'>3264</a>
<a id='n3265' href='#n3265'>3265</a>
<a id='n3266' href='#n3266'>3266</a>
<a id='n3267' href='#n3267'>3267</a>
<a id='n3268' href='#n3268'>3268</a>
<a id='n3269' href='#n3269'>3269</a>
<a id='n3270' href='#n3270'>3270</a>
<a id='n3271' href='#n3271'>3271</a>
<a id='n3272' href='#n3272'>3272</a>
<a id='n3273' href='#n3273'>3273</a>
<a id='n3274' href='#n3274'>3274</a>
<a id='n3275' href='#n3275'>3275</a>
<a id='n3276' href='#n3276'>3276</a>
<a id='n3277' href='#n3277'>3277</a>
<a id='n3278' href='#n3278'>3278</a>
<a id='n3279' href='#n3279'>3279</a>
<a id='n3280' href='#n3280'>3280</a>
<a id='n3281' href='#n3281'>3281</a>
<a id='n3282' href='#n3282'>3282</a>
<a id='n3283' href='#n3283'>3283</a>
<a id='n3284' href='#n3284'>3284</a>
<a id='n3285' href='#n3285'>3285</a>
<a id='n3286' href='#n3286'>3286</a>
<a id='n3287' href='#n3287'>3287</a>
<a id='n3288' href='#n3288'>3288</a>
<a id='n3289' href='#n3289'>3289</a>
<a id='n3290' href='#n3290'>3290</a>
<a id='n3291' href='#n3291'>3291</a>
<a id='n3292' href='#n3292'>3292</a>
<a id='n3293' href='#n3293'>3293</a>
<a id='n3294' href='#n3294'>3294</a>
<a id='n3295' href='#n3295'>3295</a>
<a id='n3296' href='#n3296'>3296</a>
<a id='n3297' href='#n3297'>3297</a>
<a id='n3298' href='#n3298'>3298</a>
<a id='n3299' href='#n3299'>3299</a>
<a id='n3300' href='#n3300'>3300</a>
<a id='n3301' href='#n3301'>3301</a>
<a id='n3302' href='#n3302'>3302</a>
<a id='n3303' href='#n3303'>3303</a>
<a id='n3304' href='#n3304'>3304</a>
<a id='n3305' href='#n3305'>3305</a>
<a id='n3306' href='#n3306'>3306</a>
<a id='n3307' href='#n3307'>3307</a>
<a id='n3308' href='#n3308'>3308</a>
<a id='n3309' href='#n3309'>3309</a>
<a id='n3310' href='#n3310'>3310</a>
<a id='n3311' href='#n3311'>3311</a>
<a id='n3312' href='#n3312'>3312</a>
<a id='n3313' href='#n3313'>3313</a>
<a id='n3314' href='#n3314'>3314</a>
<a id='n3315' href='#n3315'>3315</a>
<a id='n3316' href='#n3316'>3316</a>
<a id='n3317' href='#n3317'>3317</a>
<a id='n3318' href='#n3318'>3318</a>
<a id='n3319' href='#n3319'>3319</a>
<a id='n3320' href='#n3320'>3320</a>
<a id='n3321' href='#n3321'>3321</a>
<a id='n3322' href='#n3322'>3322</a>
<a id='n3323' href='#n3323'>3323</a>
<a id='n3324' href='#n3324'>3324</a>
<a id='n3325' href='#n3325'>3325</a>
<a id='n3326' href='#n3326'>3326</a>
<a id='n3327' href='#n3327'>3327</a>
<a id='n3328' href='#n3328'>3328</a>
<a id='n3329' href='#n3329'>3329</a>
<a id='n3330' href='#n3330'>3330</a>
<a id='n3331' href='#n3331'>3331</a>
<a id='n3332' href='#n3332'>3332</a>
<a id='n3333' href='#n3333'>3333</a>
<a id='n3334' href='#n3334'>3334</a>
<a id='n3335' href='#n3335'>3335</a>
<a id='n3336' href='#n3336'>3336</a>
<a id='n3337' href='#n3337'>3337</a>
<a id='n3338' href='#n3338'>3338</a>
<a id='n3339' href='#n3339'>3339</a>
<a id='n3340' href='#n3340'>3340</a>
<a id='n3341' href='#n3341'>3341</a>
<a id='n3342' href='#n3342'>3342</a>
<a id='n3343' href='#n3343'>3343</a>
<a id='n3344' href='#n3344'>3344</a>
<a id='n3345' href='#n3345'>3345</a>
<a id='n3346' href='#n3346'>3346</a>
<a id='n3347' href='#n3347'>3347</a>
<a id='n3348' href='#n3348'>3348</a>
<a id='n3349' href='#n3349'>3349</a>
<a id='n3350' href='#n3350'>3350</a>
<a id='n3351' href='#n3351'>3351</a>
<a id='n3352' href='#n3352'>3352</a>
<a id='n3353' href='#n3353'>3353</a>
<a id='n3354' href='#n3354'>3354</a>
<a id='n3355' href='#n3355'>3355</a>
<a id='n3356' href='#n3356'>3356</a>
<a id='n3357' href='#n3357'>3357</a>
<a id='n3358' href='#n3358'>3358</a>
<a id='n3359' href='#n3359'>3359</a>
<a id='n3360' href='#n3360'>3360</a>
<a id='n3361' href='#n3361'>3361</a>
<a id='n3362' href='#n3362'>3362</a>
<a id='n3363' href='#n3363'>3363</a>
<a id='n3364' href='#n3364'>3364</a>
<a id='n3365' href='#n3365'>3365</a>
<a id='n3366' href='#n3366'>3366</a>
<a id='n3367' href='#n3367'>3367</a>
<a id='n3368' href='#n3368'>3368</a>
<a id='n3369' href='#n3369'>3369</a>
<a id='n3370' href='#n3370'>3370</a>
<a id='n3371' href='#n3371'>3371</a>
<a id='n3372' href='#n3372'>3372</a>
<a id='n3373' href='#n3373'>3373</a>
<a id='n3374' href='#n3374'>3374</a>
<a id='n3375' href='#n3375'>3375</a>
<a id='n3376' href='#n3376'>3376</a>
<a id='n3377' href='#n3377'>3377</a>
<a id='n3378' href='#n3378'>3378</a>
<a id='n3379' href='#n3379'>3379</a>
<a id='n3380' href='#n3380'>3380</a>
<a id='n3381' href='#n3381'>3381</a>
<a id='n3382' href='#n3382'>3382</a>
<a id='n3383' href='#n3383'>3383</a>
<a id='n3384' href='#n3384'>3384</a>
<a id='n3385' href='#n3385'>3385</a>
<a id='n3386' href='#n3386'>3386</a>
<a id='n3387' href='#n3387'>3387</a>
<a id='n3388' href='#n3388'>3388</a>
<a id='n3389' href='#n3389'>3389</a>
<a id='n3390' href='#n3390'>3390</a>
<a id='n3391' href='#n3391'>3391</a>
<a id='n3392' href='#n3392'>3392</a>
<a id='n3393' href='#n3393'>3393</a>
<a id='n3394' href='#n3394'>3394</a>
<a id='n3395' href='#n3395'>3395</a>
<a id='n3396' href='#n3396'>3396</a>
<a id='n3397' href='#n3397'>3397</a>
<a id='n3398' href='#n3398'>3398</a>
<a id='n3399' href='#n3399'>3399</a>
<a id='n3400' href='#n3400'>3400</a>
<a id='n3401' href='#n3401'>3401</a>
<a id='n3402' href='#n3402'>3402</a>
<a id='n3403' href='#n3403'>3403</a>
<a id='n3404' href='#n3404'>3404</a>
<a id='n3405' href='#n3405'>3405</a>
<a id='n3406' href='#n3406'>3406</a>
<a id='n3407' href='#n3407'>3407</a>
<a id='n3408' href='#n3408'>3408</a>
<a id='n3409' href='#n3409'>3409</a>
<a id='n3410' href='#n3410'>3410</a>
<a id='n3411' href='#n3411'>3411</a>
<a id='n3412' href='#n3412'>3412</a>
<a id='n3413' href='#n3413'>3413</a>
<a id='n3414' href='#n3414'>3414</a>
<a id='n3415' href='#n3415'>3415</a>
<a id='n3416' href='#n3416'>3416</a>
<a id='n3417' href='#n3417'>3417</a>
<a id='n3418' href='#n3418'>3418</a>
<a id='n3419' href='#n3419'>3419</a>
<a id='n3420' href='#n3420'>3420</a>
<a id='n3421' href='#n3421'>3421</a>
<a id='n3422' href='#n3422'>3422</a>
<a id='n3423' href='#n3423'>3423</a>
<a id='n3424' href='#n3424'>3424</a>
<a id='n3425' href='#n3425'>3425</a>
<a id='n3426' href='#n3426'>3426</a>
<a id='n3427' href='#n3427'>3427</a>
<a id='n3428' href='#n3428'>3428</a>
<a id='n3429' href='#n3429'>3429</a>
<a id='n3430' href='#n3430'>3430</a>
<a id='n3431' href='#n3431'>3431</a>
<a id='n3432' href='#n3432'>3432</a>
<a id='n3433' href='#n3433'>3433</a>
<a id='n3434' href='#n3434'>3434</a>
<a id='n3435' href='#n3435'>3435</a>
<a id='n3436' href='#n3436'>3436</a>
<a id='n3437' href='#n3437'>3437</a>
<a id='n3438' href='#n3438'>3438</a>
<a id='n3439' href='#n3439'>3439</a>
<a id='n3440' href='#n3440'>3440</a>
<a id='n3441' href='#n3441'>3441</a>
<a id='n3442' href='#n3442'>3442</a>
<a id='n3443' href='#n3443'>3443</a>
<a id='n3444' href='#n3444'>3444</a>
<a id='n3445' href='#n3445'>3445</a>
<a id='n3446' href='#n3446'>3446</a>
<a id='n3447' href='#n3447'>3447</a>
<a id='n3448' href='#n3448'>3448</a>
<a id='n3449' href='#n3449'>3449</a>
<a id='n3450' href='#n3450'>3450</a>
<a id='n3451' href='#n3451'>3451</a>
<a id='n3452' href='#n3452'>3452</a>
<a id='n3453' href='#n3453'>3453</a>
<a id='n3454' href='#n3454'>3454</a>
<a id='n3455' href='#n3455'>3455</a>
<a id='n3456' href='#n3456'>3456</a>
<a id='n3457' href='#n3457'>3457</a>
<a id='n3458' href='#n3458'>3458</a>
<a id='n3459' href='#n3459'>3459</a>
<a id='n3460' href='#n3460'>3460</a>
<a id='n3461' href='#n3461'>3461</a>
<a id='n3462' href='#n3462'>3462</a>
<a id='n3463' href='#n3463'>3463</a>
<a id='n3464' href='#n3464'>3464</a>
<a id='n3465' href='#n3465'>3465</a>
<a id='n3466' href='#n3466'>3466</a>
<a id='n3467' href='#n3467'>3467</a>
<a id='n3468' href='#n3468'>3468</a>
<a id='n3469' href='#n3469'>3469</a>
<a id='n3470' href='#n3470'>3470</a>
<a id='n3471' href='#n3471'>3471</a>
<a id='n3472' href='#n3472'>3472</a>
<a id='n3473' href='#n3473'>3473</a>
<a id='n3474' href='#n3474'>3474</a>
<a id='n3475' href='#n3475'>3475</a>
<a id='n3476' href='#n3476'>3476</a>
<a id='n3477' href='#n3477'>3477</a>
<a id='n3478' href='#n3478'>3478</a>
<a id='n3479' href='#n3479'>3479</a>
<a id='n3480' href='#n3480'>3480</a>
<a id='n3481' href='#n3481'>3481</a>
<a id='n3482' href='#n3482'>3482</a>
<a id='n3483' href='#n3483'>3483</a>
<a id='n3484' href='#n3484'>3484</a>
<a id='n3485' href='#n3485'>3485</a>
<a id='n3486' href='#n3486'>3486</a>
<a id='n3487' href='#n3487'>3487</a>
<a id='n3488' href='#n3488'>3488</a>
<a id='n3489' href='#n3489'>3489</a>
<a id='n3490' href='#n3490'>3490</a>
<a id='n3491' href='#n3491'>3491</a>
<a id='n3492' href='#n3492'>3492</a>
<a id='n3493' href='#n3493'>3493</a>
<a id='n3494' href='#n3494'>3494</a>
<a id='n3495' href='#n3495'>3495</a>
<a id='n3496' href='#n3496'>3496</a>
<a id='n3497' href='#n3497'>3497</a>
<a id='n3498' href='#n3498'>3498</a>
<a id='n3499' href='#n3499'>3499</a>
<a id='n3500' href='#n3500'>3500</a>
<a id='n3501' href='#n3501'>3501</a>
<a id='n3502' href='#n3502'>3502</a>
<a id='n3503' href='#n3503'>3503</a>
<a id='n3504' href='#n3504'>3504</a>
<a id='n3505' href='#n3505'>3505</a>
<a id='n3506' href='#n3506'>3506</a>
<a id='n3507' href='#n3507'>3507</a>
<a id='n3508' href='#n3508'>3508</a>
<a id='n3509' href='#n3509'>3509</a>
<a id='n3510' href='#n3510'>3510</a>
<a id='n3511' href='#n3511'>3511</a>
<a id='n3512' href='#n3512'>3512</a>
<a id='n3513' href='#n3513'>3513</a>
<a id='n3514' href='#n3514'>3514</a>
<a id='n3515' href='#n3515'>3515</a>
<a id='n3516' href='#n3516'>3516</a>
<a id='n3517' href='#n3517'>3517</a>
<a id='n3518' href='#n3518'>3518</a>
<a id='n3519' href='#n3519'>3519</a>
<a id='n3520' href='#n3520'>3520</a>
<a id='n3521' href='#n3521'>3521</a>
<a id='n3522' href='#n3522'>3522</a>
<a id='n3523' href='#n3523'>3523</a>
<a id='n3524' href='#n3524'>3524</a>
<a id='n3525' href='#n3525'>3525</a>
<a id='n3526' href='#n3526'>3526</a>
<a id='n3527' href='#n3527'>3527</a>
<a id='n3528' href='#n3528'>3528</a>
<a id='n3529' href='#n3529'>3529</a>
<a id='n3530' href='#n3530'>3530</a>
<a id='n3531' href='#n3531'>3531</a>
<a id='n3532' href='#n3532'>3532</a>
<a id='n3533' href='#n3533'>3533</a>
<a id='n3534' href='#n3534'>3534</a>
<a id='n3535' href='#n3535'>3535</a>
<a id='n3536' href='#n3536'>3536</a>
<a id='n3537' href='#n3537'>3537</a>
<a id='n3538' href='#n3538'>3538</a>
<a id='n3539' href='#n3539'>3539</a>
<a id='n3540' href='#n3540'>3540</a>
<a id='n3541' href='#n3541'>3541</a>
<a id='n3542' href='#n3542'>3542</a>
<a id='n3543' href='#n3543'>3543</a>
<a id='n3544' href='#n3544'>3544</a>
<a id='n3545' href='#n3545'>3545</a>
<a id='n3546' href='#n3546'>3546</a>
<a id='n3547' href='#n3547'>3547</a>
<a id='n3548' href='#n3548'>3548</a>
<a id='n3549' href='#n3549'>3549</a>
<a id='n3550' href='#n3550'>3550</a>
<a id='n3551' href='#n3551'>3551</a>
<a id='n3552' href='#n3552'>3552</a>
<a id='n3553' href='#n3553'>3553</a>
<a id='n3554' href='#n3554'>3554</a>
<a id='n3555' href='#n3555'>3555</a>
<a id='n3556' href='#n3556'>3556</a>
<a id='n3557' href='#n3557'>3557</a>
<a id='n3558' href='#n3558'>3558</a>
<a id='n3559' href='#n3559'>3559</a>
<a id='n3560' href='#n3560'>3560</a>
<a id='n3561' href='#n3561'>3561</a>
<a id='n3562' href='#n3562'>3562</a>
<a id='n3563' href='#n3563'>3563</a>
<a id='n3564' href='#n3564'>3564</a>
<a id='n3565' href='#n3565'>3565</a>
<a id='n3566' href='#n3566'>3566</a>
<a id='n3567' href='#n3567'>3567</a>
<a id='n3568' href='#n3568'>3568</a>
<a id='n3569' href='#n3569'>3569</a>
<a id='n3570' href='#n3570'>3570</a>
<a id='n3571' href='#n3571'>3571</a>
<a id='n3572' href='#n3572'>3572</a>
<a id='n3573' href='#n3573'>3573</a>
<a id='n3574' href='#n3574'>3574</a>
<a id='n3575' href='#n3575'>3575</a>
<a id='n3576' href='#n3576'>3576</a>
<a id='n3577' href='#n3577'>3577</a>
<a id='n3578' href='#n3578'>3578</a>
<a id='n3579' href='#n3579'>3579</a>
<a id='n3580' href='#n3580'>3580</a>
<a id='n3581' href='#n3581'>3581</a>
<a id='n3582' href='#n3582'>3582</a>
<a id='n3583' href='#n3583'>3583</a>
<a id='n3584' href='#n3584'>3584</a>
<a id='n3585' href='#n3585'>3585</a>
<a id='n3586' href='#n3586'>3586</a>
<a id='n3587' href='#n3587'>3587</a>
<a id='n3588' href='#n3588'>3588</a>
<a id='n3589' href='#n3589'>3589</a>
<a id='n3590' href='#n3590'>3590</a>
<a id='n3591' href='#n3591'>3591</a>
<a id='n3592' href='#n3592'>3592</a>
<a id='n3593' href='#n3593'>3593</a>
<a id='n3594' href='#n3594'>3594</a>
<a id='n3595' href='#n3595'>3595</a>
<a id='n3596' href='#n3596'>3596</a>
<a id='n3597' href='#n3597'>3597</a>
<a id='n3598' href='#n3598'>3598</a>
<a id='n3599' href='#n3599'>3599</a>
<a id='n3600' href='#n3600'>3600</a>
<a id='n3601' href='#n3601'>3601</a>
<a id='n3602' href='#n3602'>3602</a>
<a id='n3603' href='#n3603'>3603</a>
<a id='n3604' href='#n3604'>3604</a>
<a id='n3605' href='#n3605'>3605</a>
<a id='n3606' href='#n3606'>3606</a>
<a id='n3607' href='#n3607'>3607</a>
<a id='n3608' href='#n3608'>3608</a>
<a id='n3609' href='#n3609'>3609</a>
<a id='n3610' href='#n3610'>3610</a>
<a id='n3611' href='#n3611'>3611</a>
<a id='n3612' href='#n3612'>3612</a>
<a id='n3613' href='#n3613'>3613</a>
<a id='n3614' href='#n3614'>3614</a>
<a id='n3615' href='#n3615'>3615</a>
<a id='n3616' href='#n3616'>3616</a>
<a id='n3617' href='#n3617'>3617</a>
<a id='n3618' href='#n3618'>3618</a>
<a id='n3619' href='#n3619'>3619</a>
<a id='n3620' href='#n3620'>3620</a>
<a id='n3621' href='#n3621'>3621</a>
<a id='n3622' href='#n3622'>3622</a>
<a id='n3623' href='#n3623'>3623</a>
<a id='n3624' href='#n3624'>3624</a>
<a id='n3625' href='#n3625'>3625</a>
<a id='n3626' href='#n3626'>3626</a>
<a id='n3627' href='#n3627'>3627</a>
<a id='n3628' href='#n3628'>3628</a>
<a id='n3629' href='#n3629'>3629</a>
<a id='n3630' href='#n3630'>3630</a>
<a id='n3631' href='#n3631'>3631</a>
<a id='n3632' href='#n3632'>3632</a>
<a id='n3633' href='#n3633'>3633</a>
<a id='n3634' href='#n3634'>3634</a>
<a id='n3635' href='#n3635'>3635</a>
<a id='n3636' href='#n3636'>3636</a>
<a id='n3637' href='#n3637'>3637</a>
<a id='n3638' href='#n3638'>3638</a>
<a id='n3639' href='#n3639'>3639</a>
<a id='n3640' href='#n3640'>3640</a>
<a id='n3641' href='#n3641'>3641</a>
<a id='n3642' href='#n3642'>3642</a>
<a id='n3643' href='#n3643'>3643</a>
<a id='n3644' href='#n3644'>3644</a>
<a id='n3645' href='#n3645'>3645</a>
<a id='n3646' href='#n3646'>3646</a>
<a id='n3647' href='#n3647'>3647</a>
<a id='n3648' href='#n3648'>3648</a>
<a id='n3649' href='#n3649'>3649</a>
<a id='n3650' href='#n3650'>3650</a>
<a id='n3651' href='#n3651'>3651</a>
<a id='n3652' href='#n3652'>3652</a>
<a id='n3653' href='#n3653'>3653</a>
<a id='n3654' href='#n3654'>3654</a>
<a id='n3655' href='#n3655'>3655</a>
<a id='n3656' href='#n3656'>3656</a>
<a id='n3657' href='#n3657'>3657</a>
<a id='n3658' href='#n3658'>3658</a>
<a id='n3659' href='#n3659'>3659</a>
<a id='n3660' href='#n3660'>3660</a>
<a id='n3661' href='#n3661'>3661</a>
<a id='n3662' href='#n3662'>3662</a>
<a id='n3663' href='#n3663'>3663</a>
<a id='n3664' href='#n3664'>3664</a>
<a id='n3665' href='#n3665'>3665</a>
<a id='n3666' href='#n3666'>3666</a>
<a id='n3667' href='#n3667'>3667</a>
<a id='n3668' href='#n3668'>3668</a>
<a id='n3669' href='#n3669'>3669</a>
<a id='n3670' href='#n3670'>3670</a>
<a id='n3671' href='#n3671'>3671</a>
<a id='n3672' href='#n3672'>3672</a>
<a id='n3673' href='#n3673'>3673</a>
<a id='n3674' href='#n3674'>3674</a>
<a id='n3675' href='#n3675'>3675</a>
<a id='n3676' href='#n3676'>3676</a>
<a id='n3677' href='#n3677'>3677</a>
<a id='n3678' href='#n3678'>3678</a>
<a id='n3679' href='#n3679'>3679</a>
<a id='n3680' href='#n3680'>3680</a>
<a id='n3681' href='#n3681'>3681</a>
<a id='n3682' href='#n3682'>3682</a>
<a id='n3683' href='#n3683'>3683</a>
<a id='n3684' href='#n3684'>3684</a>
<a id='n3685' href='#n3685'>3685</a>
<a id='n3686' href='#n3686'>3686</a>
<a id='n3687' href='#n3687'>3687</a>
<a id='n3688' href='#n3688'>3688</a>
<a id='n3689' href='#n3689'>3689</a>
<a id='n3690' href='#n3690'>3690</a>
<a id='n3691' href='#n3691'>3691</a>
<a id='n3692' href='#n3692'>3692</a>
<a id='n3693' href='#n3693'>3693</a>
<a id='n3694' href='#n3694'>3694</a>
<a id='n3695' href='#n3695'>3695</a>
<a id='n3696' href='#n3696'>3696</a>
<a id='n3697' href='#n3697'>3697</a>
<a id='n3698' href='#n3698'>3698</a>
<a id='n3699' href='#n3699'>3699</a>
<a id='n3700' href='#n3700'>3700</a>
<a id='n3701' href='#n3701'>3701</a>
<a id='n3702' href='#n3702'>3702</a>
<a id='n3703' href='#n3703'>3703</a>
<a id='n3704' href='#n3704'>3704</a>
<a id='n3705' href='#n3705'>3705</a>
<a id='n3706' href='#n3706'>3706</a>
<a id='n3707' href='#n3707'>3707</a>
<a id='n3708' href='#n3708'>3708</a>
<a id='n3709' href='#n3709'>3709</a>
<a id='n3710' href='#n3710'>3710</a>
<a id='n3711' href='#n3711'>3711</a>
<a id='n3712' href='#n3712'>3712</a>
<a id='n3713' href='#n3713'>3713</a>
<a id='n3714' href='#n3714'>3714</a>
<a id='n3715' href='#n3715'>3715</a>
<a id='n3716' href='#n3716'>3716</a>
<a id='n3717' href='#n3717'>3717</a>
<a id='n3718' href='#n3718'>3718</a>
<a id='n3719' href='#n3719'>3719</a>
<a id='n3720' href='#n3720'>3720</a>
<a id='n3721' href='#n3721'>3721</a>
<a id='n3722' href='#n3722'>3722</a>
<a id='n3723' href='#n3723'>3723</a>
<a id='n3724' href='#n3724'>3724</a>
<a id='n3725' href='#n3725'>3725</a>
<a id='n3726' href='#n3726'>3726</a>
<a id='n3727' href='#n3727'>3727</a>
<a id='n3728' href='#n3728'>3728</a>
<a id='n3729' href='#n3729'>3729</a>
<a id='n3730' href='#n3730'>3730</a>
<a id='n3731' href='#n3731'>3731</a>
<a id='n3732' href='#n3732'>3732</a>
<a id='n3733' href='#n3733'>3733</a>
<a id='n3734' href='#n3734'>3734</a>
<a id='n3735' href='#n3735'>3735</a>
<a id='n3736' href='#n3736'>3736</a>
<a id='n3737' href='#n3737'>3737</a>
<a id='n3738' href='#n3738'>3738</a>
<a id='n3739' href='#n3739'>3739</a>
<a id='n3740' href='#n3740'>3740</a>
<a id='n3741' href='#n3741'>3741</a>
<a id='n3742' href='#n3742'>3742</a>
<a id='n3743' href='#n3743'>3743</a>
<a id='n3744' href='#n3744'>3744</a>
<a id='n3745' href='#n3745'>3745</a>
<a id='n3746' href='#n3746'>3746</a>
<a id='n3747' href='#n3747'>3747</a>
<a id='n3748' href='#n3748'>3748</a>
<a id='n3749' href='#n3749'>3749</a>
<a id='n3750' href='#n3750'>3750</a>
<a id='n3751' href='#n3751'>3751</a>
<a id='n3752' href='#n3752'>3752</a>
<a id='n3753' href='#n3753'>3753</a>
<a id='n3754' href='#n3754'>3754</a>
<a id='n3755' href='#n3755'>3755</a>
<a id='n3756' href='#n3756'>3756</a>
<a id='n3757' href='#n3757'>3757</a>
<a id='n3758' href='#n3758'>3758</a>
<a id='n3759' href='#n3759'>3759</a>
<a id='n3760' href='#n3760'>3760</a>
<a id='n3761' href='#n3761'>3761</a>
<a id='n3762' href='#n3762'>3762</a>
<a id='n3763' href='#n3763'>3763</a>
<a id='n3764' href='#n3764'>3764</a>
<a id='n3765' href='#n3765'>3765</a>
<a id='n3766' href='#n3766'>3766</a>
<a id='n3767' href='#n3767'>3767</a>
<a id='n3768' href='#n3768'>3768</a>
<a id='n3769' href='#n3769'>3769</a>
<a id='n3770' href='#n3770'>3770</a>
<a id='n3771' href='#n3771'>3771</a>
<a id='n3772' href='#n3772'>3772</a>
<a id='n3773' href='#n3773'>3773</a>
<a id='n3774' href='#n3774'>3774</a>
<a id='n3775' href='#n3775'>3775</a>
<a id='n3776' href='#n3776'>3776</a>
<a id='n3777' href='#n3777'>3777</a>
<a id='n3778' href='#n3778'>3778</a>
<a id='n3779' href='#n3779'>3779</a>
<a id='n3780' href='#n3780'>3780</a>
<a id='n3781' href='#n3781'>3781</a>
<a id='n3782' href='#n3782'>3782</a>
<a id='n3783' href='#n3783'>3783</a>
<a id='n3784' href='#n3784'>3784</a>
<a id='n3785' href='#n3785'>3785</a>
<a id='n3786' href='#n3786'>3786</a>
<a id='n3787' href='#n3787'>3787</a>
<a id='n3788' href='#n3788'>3788</a>
<a id='n3789' href='#n3789'>3789</a>
<a id='n3790' href='#n3790'>3790</a>
<a id='n3791' href='#n3791'>3791</a>
<a id='n3792' href='#n3792'>3792</a>
<a id='n3793' href='#n3793'>3793</a>
<a id='n3794' href='#n3794'>3794</a>
<a id='n3795' href='#n3795'>3795</a>
<a id='n3796' href='#n3796'>3796</a>
<a id='n3797' href='#n3797'>3797</a>
<a id='n3798' href='#n3798'>3798</a>
<a id='n3799' href='#n3799'>3799</a>
<a id='n3800' href='#n3800'>3800</a>
<a id='n3801' href='#n3801'>3801</a>
<a id='n3802' href='#n3802'>3802</a>
<a id='n3803' href='#n3803'>3803</a>
<a id='n3804' href='#n3804'>3804</a>
<a id='n3805' href='#n3805'>3805</a>
<a id='n3806' href='#n3806'>3806</a>
<a id='n3807' href='#n3807'>3807</a>
<a id='n3808' href='#n3808'>3808</a>
<a id='n3809' href='#n3809'>3809</a>
<a id='n3810' href='#n3810'>3810</a>
<a id='n3811' href='#n3811'>3811</a>
<a id='n3812' href='#n3812'>3812</a>
<a id='n3813' href='#n3813'>3813</a>
<a id='n3814' href='#n3814'>3814</a>
<a id='n3815' href='#n3815'>3815</a>
<a id='n3816' href='#n3816'>3816</a>
<a id='n3817' href='#n3817'>3817</a>
<a id='n3818' href='#n3818'>3818</a>
<a id='n3819' href='#n3819'>3819</a>
<a id='n3820' href='#n3820'>3820</a>
<a id='n3821' href='#n3821'>3821</a>
<a id='n3822' href='#n3822'>3822</a>
<a id='n3823' href='#n3823'>3823</a>
<a id='n3824' href='#n3824'>3824</a>
<a id='n3825' href='#n3825'>3825</a>
<a id='n3826' href='#n3826'>3826</a>
<a id='n3827' href='#n3827'>3827</a>
<a id='n3828' href='#n3828'>3828</a>
<a id='n3829' href='#n3829'>3829</a>
<a id='n3830' href='#n3830'>3830</a>
<a id='n3831' href='#n3831'>3831</a>
<a id='n3832' href='#n3832'>3832</a>
<a id='n3833' href='#n3833'>3833</a>
<a id='n3834' href='#n3834'>3834</a>
<a id='n3835' href='#n3835'>3835</a>
<a id='n3836' href='#n3836'>3836</a>
<a id='n3837' href='#n3837'>3837</a>
<a id='n3838' href='#n3838'>3838</a>
<a id='n3839' href='#n3839'>3839</a>
<a id='n3840' href='#n3840'>3840</a>
<a id='n3841' href='#n3841'>3841</a>
<a id='n3842' href='#n3842'>3842</a>
<a id='n3843' href='#n3843'>3843</a>
<a id='n3844' href='#n3844'>3844</a>
<a id='n3845' href='#n3845'>3845</a>
<a id='n3846' href='#n3846'>3846</a>
<a id='n3847' href='#n3847'>3847</a>
<a id='n3848' href='#n3848'>3848</a>
<a id='n3849' href='#n3849'>3849</a>
<a id='n3850' href='#n3850'>3850</a>
<a id='n3851' href='#n3851'>3851</a>
<a id='n3852' href='#n3852'>3852</a>
<a id='n3853' href='#n3853'>3853</a>
<a id='n3854' href='#n3854'>3854</a>
<a id='n3855' href='#n3855'>3855</a>
<a id='n3856' href='#n3856'>3856</a>
<a id='n3857' href='#n3857'>3857</a>
<a id='n3858' href='#n3858'>3858</a>
<a id='n3859' href='#n3859'>3859</a>
<a id='n3860' href='#n3860'>3860</a>
<a id='n3861' href='#n3861'>3861</a>
<a id='n3862' href='#n3862'>3862</a>
<a id='n3863' href='#n3863'>3863</a>
<a id='n3864' href='#n3864'>3864</a>
<a id='n3865' href='#n3865'>3865</a>
<a id='n3866' href='#n3866'>3866</a>
<a id='n3867' href='#n3867'>3867</a>
<a id='n3868' href='#n3868'>3868</a>
<a id='n3869' href='#n3869'>3869</a>
<a id='n3870' href='#n3870'>3870</a>
<a id='n3871' href='#n3871'>3871</a>
<a id='n3872' href='#n3872'>3872</a>
<a id='n3873' href='#n3873'>3873</a>
<a id='n3874' href='#n3874'>3874</a>
<a id='n3875' href='#n3875'>3875</a>
<a id='n3876' href='#n3876'>3876</a>
<a id='n3877' href='#n3877'>3877</a>
<a id='n3878' href='#n3878'>3878</a>
<a id='n3879' href='#n3879'>3879</a>
<a id='n3880' href='#n3880'>3880</a>
<a id='n3881' href='#n3881'>3881</a>
<a id='n3882' href='#n3882'>3882</a>
<a id='n3883' href='#n3883'>3883</a>
<a id='n3884' href='#n3884'>3884</a>
<a id='n3885' href='#n3885'>3885</a>
<a id='n3886' href='#n3886'>3886</a>
<a id='n3887' href='#n3887'>3887</a>
<a id='n3888' href='#n3888'>3888</a>
<a id='n3889' href='#n3889'>3889</a>
<a id='n3890' href='#n3890'>3890</a>
<a id='n3891' href='#n3891'>3891</a>
<a id='n3892' href='#n3892'>3892</a>
<a id='n3893' href='#n3893'>3893</a>
<a id='n3894' href='#n3894'>3894</a>
<a id='n3895' href='#n3895'>3895</a>
<a id='n3896' href='#n3896'>3896</a>
<a id='n3897' href='#n3897'>3897</a>
<a id='n3898' href='#n3898'>3898</a>
<a id='n3899' href='#n3899'>3899</a>
<a id='n3900' href='#n3900'>3900</a>
<a id='n3901' href='#n3901'>3901</a>
<a id='n3902' href='#n3902'>3902</a>
<a id='n3903' href='#n3903'>3903</a>
<a id='n3904' href='#n3904'>3904</a>
<a id='n3905' href='#n3905'>3905</a>
<a id='n3906' href='#n3906'>3906</a>
<a id='n3907' href='#n3907'>3907</a>
<a id='n3908' href='#n3908'>3908</a>
<a id='n3909' href='#n3909'>3909</a>
<a id='n3910' href='#n3910'>3910</a>
<a id='n3911' href='#n3911'>3911</a>
<a id='n3912' href='#n3912'>3912</a>
<a id='n3913' href='#n3913'>3913</a>
<a id='n3914' href='#n3914'>3914</a>
<a id='n3915' href='#n3915'>3915</a>
<a id='n3916' href='#n3916'>3916</a>
<a id='n3917' href='#n3917'>3917</a>
<a id='n3918' href='#n3918'>3918</a>
<a id='n3919' href='#n3919'>3919</a>
<a id='n3920' href='#n3920'>3920</a>
<a id='n3921' href='#n3921'>3921</a>
<a id='n3922' href='#n3922'>3922</a>
<a id='n3923' href='#n3923'>3923</a>
<a id='n3924' href='#n3924'>3924</a>
<a id='n3925' href='#n3925'>3925</a>
<a id='n3926' href='#n3926'>3926</a>
<a id='n3927' href='#n3927'>3927</a>
<a id='n3928' href='#n3928'>3928</a>
<a id='n3929' href='#n3929'>3929</a>
<a id='n3930' href='#n3930'>3930</a>
<a id='n3931' href='#n3931'>3931</a>
<a id='n3932' href='#n3932'>3932</a>
<a id='n3933' href='#n3933'>3933</a>
<a id='n3934' href='#n3934'>3934</a>
<a id='n3935' href='#n3935'>3935</a>
<a id='n3936' href='#n3936'>3936</a>
<a id='n3937' href='#n3937'>3937</a>
<a id='n3938' href='#n3938'>3938</a>
<a id='n3939' href='#n3939'>3939</a>
<a id='n3940' href='#n3940'>3940</a>
<a id='n3941' href='#n3941'>3941</a>
<a id='n3942' href='#n3942'>3942</a>
<a id='n3943' href='#n3943'>3943</a>
<a id='n3944' href='#n3944'>3944</a>
<a id='n3945' href='#n3945'>3945</a>
<a id='n3946' href='#n3946'>3946</a>
<a id='n3947' href='#n3947'>3947</a>
<a id='n3948' href='#n3948'>3948</a>
<a id='n3949' href='#n3949'>3949</a>
<a id='n3950' href='#n3950'>3950</a>
<a id='n3951' href='#n3951'>3951</a>
<a id='n3952' href='#n3952'>3952</a>
<a id='n3953' href='#n3953'>3953</a>
<a id='n3954' href='#n3954'>3954</a>
<a id='n3955' href='#n3955'>3955</a>
<a id='n3956' href='#n3956'>3956</a>
<a id='n3957' href='#n3957'>3957</a>
<a id='n3958' href='#n3958'>3958</a>
<a id='n3959' href='#n3959'>3959</a>
<a id='n3960' href='#n3960'>3960</a>
<a id='n3961' href='#n3961'>3961</a>
<a id='n3962' href='#n3962'>3962</a>
<a id='n3963' href='#n3963'>3963</a>
<a id='n3964' href='#n3964'>3964</a>
<a id='n3965' href='#n3965'>3965</a>
<a id='n3966' href='#n3966'>3966</a>
<a id='n3967' href='#n3967'>3967</a>
<a id='n3968' href='#n3968'>3968</a>
<a id='n3969' href='#n3969'>3969</a>
<a id='n3970' href='#n3970'>3970</a>
<a id='n3971' href='#n3971'>3971</a>
<a id='n3972' href='#n3972'>3972</a>
<a id='n3973' href='#n3973'>3973</a>
<a id='n3974' href='#n3974'>3974</a>
<a id='n3975' href='#n3975'>3975</a>
<a id='n3976' href='#n3976'>3976</a>
<a id='n3977' href='#n3977'>3977</a>
<a id='n3978' href='#n3978'>3978</a>
<a id='n3979' href='#n3979'>3979</a>
<a id='n3980' href='#n3980'>3980</a>
<a id='n3981' href='#n3981'>3981</a>
<a id='n3982' href='#n3982'>3982</a>
<a id='n3983' href='#n3983'>3983</a>
<a id='n3984' href='#n3984'>3984</a>
<a id='n3985' href='#n3985'>3985</a>
<a id='n3986' href='#n3986'>3986</a>
<a id='n3987' href='#n3987'>3987</a>
<a id='n3988' href='#n3988'>3988</a>
<a id='n3989' href='#n3989'>3989</a>
<a id='n3990' href='#n3990'>3990</a>
<a id='n3991' href='#n3991'>3991</a>
<a id='n3992' href='#n3992'>3992</a>
<a id='n3993' href='#n3993'>3993</a>
<a id='n3994' href='#n3994'>3994</a>
<a id='n3995' href='#n3995'>3995</a>
<a id='n3996' href='#n3996'>3996</a>
<a id='n3997' href='#n3997'>3997</a>
<a id='n3998' href='#n3998'>3998</a>
<a id='n3999' href='#n3999'>3999</a>
<a id='n4000' href='#n4000'>4000</a>
<a id='n4001' href='#n4001'>4001</a>
<a id='n4002' href='#n4002'>4002</a>
<a id='n4003' href='#n4003'>4003</a>
<a id='n4004' href='#n4004'>4004</a>
<a id='n4005' href='#n4005'>4005</a>
<a id='n4006' href='#n4006'>4006</a>
<a id='n4007' href='#n4007'>4007</a>
<a id='n4008' href='#n4008'>4008</a>
<a id='n4009' href='#n4009'>4009</a>
<a id='n4010' href='#n4010'>4010</a>
<a id='n4011' href='#n4011'>4011</a>
<a id='n4012' href='#n4012'>4012</a>
<a id='n4013' href='#n4013'>4013</a>
<a id='n4014' href='#n4014'>4014</a>
<a id='n4015' href='#n4015'>4015</a>
<a id='n4016' href='#n4016'>4016</a>
<a id='n4017' href='#n4017'>4017</a>
<a id='n4018' href='#n4018'>4018</a>
<a id='n4019' href='#n4019'>4019</a>
<a id='n4020' href='#n4020'>4020</a>
<a id='n4021' href='#n4021'>4021</a>
<a id='n4022' href='#n4022'>4022</a>
<a id='n4023' href='#n4023'>4023</a>
<a id='n4024' href='#n4024'>4024</a>
<a id='n4025' href='#n4025'>4025</a>
<a id='n4026' href='#n4026'>4026</a>
<a id='n4027' href='#n4027'>4027</a>
<a id='n4028' href='#n4028'>4028</a>
<a id='n4029' href='#n4029'>4029</a>
<a id='n4030' href='#n4030'>4030</a>
<a id='n4031' href='#n4031'>4031</a>
<a id='n4032' href='#n4032'>4032</a>
<a id='n4033' href='#n4033'>4033</a>
<a id='n4034' href='#n4034'>4034</a>
<a id='n4035' href='#n4035'>4035</a>
<a id='n4036' href='#n4036'>4036</a>
<a id='n4037' href='#n4037'>4037</a>
<a id='n4038' href='#n4038'>4038</a>
<a id='n4039' href='#n4039'>4039</a>
<a id='n4040' href='#n4040'>4040</a>
<a id='n4041' href='#n4041'>4041</a>
<a id='n4042' href='#n4042'>4042</a>
<a id='n4043' href='#n4043'>4043</a>
<a id='n4044' href='#n4044'>4044</a>
<a id='n4045' href='#n4045'>4045</a>
<a id='n4046' href='#n4046'>4046</a>
<a id='n4047' href='#n4047'>4047</a>
<a id='n4048' href='#n4048'>4048</a>
<a id='n4049' href='#n4049'>4049</a>
<a id='n4050' href='#n4050'>4050</a>
<a id='n4051' href='#n4051'>4051</a>
<a id='n4052' href='#n4052'>4052</a>
<a id='n4053' href='#n4053'>4053</a>
<a id='n4054' href='#n4054'>4054</a>
<a id='n4055' href='#n4055'>4055</a>
<a id='n4056' href='#n4056'>4056</a>
<a id='n4057' href='#n4057'>4057</a>
<a id='n4058' href='#n4058'>4058</a>
<a id='n4059' href='#n4059'>4059</a>
<a id='n4060' href='#n4060'>4060</a>
<a id='n4061' href='#n4061'>4061</a>
<a id='n4062' href='#n4062'>4062</a>
<a id='n4063' href='#n4063'>4063</a>
<a id='n4064' href='#n4064'>4064</a>
<a id='n4065' href='#n4065'>4065</a>
<a id='n4066' href='#n4066'>4066</a>
<a id='n4067' href='#n4067'>4067</a>
<a id='n4068' href='#n4068'>4068</a>
<a id='n4069' href='#n4069'>4069</a>
<a id='n4070' href='#n4070'>4070</a>
<a id='n4071' href='#n4071'>4071</a>
<a id='n4072' href='#n4072'>4072</a>
<a id='n4073' href='#n4073'>4073</a>
<a id='n4074' href='#n4074'>4074</a>
<a id='n4075' href='#n4075'>4075</a>
<a id='n4076' href='#n4076'>4076</a>
<a id='n4077' href='#n4077'>4077</a>
<a id='n4078' href='#n4078'>4078</a>
<a id='n4079' href='#n4079'>4079</a>
<a id='n4080' href='#n4080'>4080</a>
<a id='n4081' href='#n4081'>4081</a>
<a id='n4082' href='#n4082'>4082</a>
<a id='n4083' href='#n4083'>4083</a>
<a id='n4084' href='#n4084'>4084</a>
<a id='n4085' href='#n4085'>4085</a>
<a id='n4086' href='#n4086'>4086</a>
<a id='n4087' href='#n4087'>4087</a>
<a id='n4088' href='#n4088'>4088</a>
<a id='n4089' href='#n4089'>4089</a>
<a id='n4090' href='#n4090'>4090</a>
<a id='n4091' href='#n4091'>4091</a>
<a id='n4092' href='#n4092'>4092</a>
<a id='n4093' href='#n4093'>4093</a>
<a id='n4094' href='#n4094'>4094</a>
<a id='n4095' href='#n4095'>4095</a>
<a id='n4096' href='#n4096'>4096</a>
<a id='n4097' href='#n4097'>4097</a>
<a id='n4098' href='#n4098'>4098</a>
<a id='n4099' href='#n4099'>4099</a>
<a id='n4100' href='#n4100'>4100</a>
<a id='n4101' href='#n4101'>4101</a>
<a id='n4102' href='#n4102'>4102</a>
<a id='n4103' href='#n4103'>4103</a>
<a id='n4104' href='#n4104'>4104</a>
<a id='n4105' href='#n4105'>4105</a>
<a id='n4106' href='#n4106'>4106</a>
<a id='n4107' href='#n4107'>4107</a>
<a id='n4108' href='#n4108'>4108</a>
<a id='n4109' href='#n4109'>4109</a>
<a id='n4110' href='#n4110'>4110</a>
<a id='n4111' href='#n4111'>4111</a>
<a id='n4112' href='#n4112'>4112</a>
<a id='n4113' href='#n4113'>4113</a>
<a id='n4114' href='#n4114'>4114</a>
<a id='n4115' href='#n4115'>4115</a>
<a id='n4116' href='#n4116'>4116</a>
<a id='n4117' href='#n4117'>4117</a>
<a id='n4118' href='#n4118'>4118</a>
<a id='n4119' href='#n4119'>4119</a>
<a id='n4120' href='#n4120'>4120</a>
<a id='n4121' href='#n4121'>4121</a>
<a id='n4122' href='#n4122'>4122</a>
<a id='n4123' href='#n4123'>4123</a>
<a id='n4124' href='#n4124'>4124</a>
<a id='n4125' href='#n4125'>4125</a>
<a id='n4126' href='#n4126'>4126</a>
<a id='n4127' href='#n4127'>4127</a>
<a id='n4128' href='#n4128'>4128</a>
<a id='n4129' href='#n4129'>4129</a>
<a id='n4130' href='#n4130'>4130</a>
<a id='n4131' href='#n4131'>4131</a>
<a id='n4132' href='#n4132'>4132</a>
<a id='n4133' href='#n4133'>4133</a>
<a id='n4134' href='#n4134'>4134</a>
<a id='n4135' href='#n4135'>4135</a>
<a id='n4136' href='#n4136'>4136</a>
<a id='n4137' href='#n4137'>4137</a>
<a id='n4138' href='#n4138'>4138</a>
<a id='n4139' href='#n4139'>4139</a>
</pre></td>
<td class='lines'><pre><code><span class="hl com">/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *</span>
<span class="hl com"> * Copyright by the Board of Trustees of the University of Illinois.         *</span>
<span class="hl com"> * All rights reserved.                                                      *</span>
<span class="hl com"> *                                                                           *</span>
<span class="hl com"> * This file is part of HDF5.  The full HDF5 copyright notice, including     *</span>
<span class="hl com"> * terms governing use, modification, and redistribution, is contained in    *</span>
<span class="hl com"> * the files COPYING and Copyright.html.  COPYING can be found at the root   *</span>
<span class="hl com"> * of the source code distribution tree; Copyright.html can be found at the  *</span>
<span class="hl com"> * root level of an installed copy of the electronic HDF5 document set and   *</span>
<span class="hl com"> * is linked from the top-level documents page.  It can also be found at     *</span>
<span class="hl com"> * http://hdf.ncsa.uiuc.edu/HDF5/doc/Copyright.html.  If you do not have     *</span>
<span class="hl com"> * access to either file, you may request a copy from hdfhelp&#64;ncsa.uiuc.edu. *</span>
<span class="hl com"> * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */</span>

<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> *</span>
<span class="hl com"> * Created:	H5G.c</span>
<span class="hl com"> *		Jul 18 1997</span>
<span class="hl com"> *		Robb Matzke &lt;matzke&#64;llnl.gov&gt;</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Symbol table functions.	 The functions that begin with</span>
<span class="hl com"> *		`H5G_stab_' don't understand the naming system; they operate</span>
<span class="hl com"> * 		on a single symbol table at a time.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		The functions that begin with `H5G_node_' operate on the leaf</span>
<span class="hl com"> *		nodes of a symbol table B-tree.  They should be defined in</span>
<span class="hl com"> *		the H5Gnode.c file.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		The remaining functions know how to traverse the group</span>
<span class="hl com"> *		directed graph.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Names:	Object names are a slash-separated list of components.  If</span>
<span class="hl com"> *		the name begins with a slash then it's absolute, otherwise</span>
<span class="hl com"> *		it's relative (&quot;/foo/bar&quot; is absolute while &quot;foo/bar&quot; is</span>
<span class="hl com"> *		relative).  Multiple consecutive slashes are treated as</span>
<span class="hl com"> *		single slashes and trailing slashes are ignored.  The special</span>
<span class="hl com"> *		case `/' is the root group.  Every file has a root group.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		API functions that look up names take a location ID and a</span>
<span class="hl com"> *		name.  The location ID can be a file ID or a group ID and the</span>
<span class="hl com"> *		name can be relative or absolute.</span>
<span class="hl com"> *</span>
<span class="hl com"> *              +--------------+----------- +--------------------------------+</span>
<span class="hl com"> * 		| Location ID  | Name       | Meaning                        |</span>
<span class="hl com"> *              +--------------+------------+--------------------------------+</span>
<span class="hl com"> * 		| File ID      | &quot;/foo/bar&quot; | Find `foo' within `bar' within |</span>
<span class="hl com"> *		|              |            | the root group of the specified|</span>
<span class="hl com"> *		|              |            | file.                          |</span>
<span class="hl com"> *              +--------------+------------+--------------------------------+</span>
<span class="hl com"> * 		| File ID      | &quot;foo/bar&quot;  | Find `foo' within `bar' within |</span>
<span class="hl com"> *		|              |            | the current working group of   |</span>
<span class="hl com"> *		|              |            | the specified file.            |</span>
<span class="hl com"> *              +--------------+------------+--------------------------------+</span>
<span class="hl com"> * 		| File ID      | &quot;/&quot;        | The root group of the specified|</span>
<span class="hl com"> *		|              |            | file.                          |</span>
<span class="hl com"> *              +--------------+------------+--------------------------------+</span>
<span class="hl com"> * 		| File ID      | &quot;.&quot;        | The current working group of   |</span>
<span class="hl com"> *		|              |            | the specified file.            |</span>
<span class="hl com"> *              +--------------+------------+--------------------------------+</span>
<span class="hl com"> * 		| Group ID     | &quot;/foo/bar&quot; | Find `foo' within `bar' within |</span>
<span class="hl com"> *		|              |            | the root group of the file     |</span>
<span class="hl com"> *		|              |            | containing the specified group.|</span>
<span class="hl com"> *              +--------------+------------+--------------------------------+</span>
<span class="hl com"> * 		| Group ID     | &quot;foo/bar&quot;  | File `foo' within `bar' within |</span>
<span class="hl com"> *		|              |            | the specified group.           |</span>
<span class="hl com"> *              +--------------+------------+--------------------------------+</span>
<span class="hl com"> * 		| Group ID     | &quot;/&quot;        | The root group of the file     |</span>
<span class="hl com"> *		|              |            | containing the specified group.|</span>
<span class="hl com"> *              +--------------+------------+--------------------------------+</span>
<span class="hl com"> * 		| Group ID     | &quot;.&quot;        | The specified group.           |</span>
<span class="hl com"> *              +--------------+------------+--------------------------------+</span>
<span class="hl com"> *</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Robb Matzke, 5 Aug 1997</span>
<span class="hl com"> *	Added calls to H5E.</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Robb Matzke, 30 Aug 1997</span>
<span class="hl com"> *	Added `Errors:' field to function prologues.</span>
<span class="hl com"> *</span>
<span class="hl com"> *      Pedro Vicente, 22 Aug 2002</span>
<span class="hl com"> *      Added `id to name' support.</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl ppc">#define H5G_PACKAGE</span>     <span class="hl com">/*suppress error message about including H5Gpkg.h */</span><span class="hl ppc"></span>
<span class="hl ppc">#define H5F_PACKAGE</span>     <span class="hl com">/*suppress error about including H5Fpkg	  */</span><span class="hl ppc"></span>

<span class="hl com">/* Interface initialization */</span>
<span class="hl ppc">#define H5_INTERFACE_INIT_FUNC	H5G_init_interface</span>


<span class="hl com">/* Packages needed by this file... */</span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;H5private.h&quot;</span><span class="hl ppc"></span>		<span class="hl com">/* Generic Functions			*/</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;H5Aprivate.h&quot;</span><span class="hl ppc"></span>		<span class="hl com">/* Attributes				*/</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;H5Bprivate.h&quot;</span><span class="hl ppc"></span>		<span class="hl com">/* B-link trees				*/</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;H5Dprivate.h&quot;</span><span class="hl ppc"></span>		<span class="hl com">/* Datasets				*/</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;H5Eprivate.h&quot;</span><span class="hl ppc"></span>		<span class="hl com">/* Error handling		  	*/</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;H5Fpkg.h&quot;</span><span class="hl ppc"></span>		<span class="hl com">/* File access				*/</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;H5FLprivate.h&quot;</span><span class="hl ppc"></span>	<span class="hl com">/* Free Lists                           */</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;H5Gpkg.h&quot;</span><span class="hl ppc"></span>		<span class="hl com">/* Groups		  		*/</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;H5HLprivate.h&quot;</span><span class="hl ppc"></span>	<span class="hl com">/* Local Heaps				*/</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;H5Iprivate.h&quot;</span><span class="hl ppc"></span>		<span class="hl com">/* IDs			  		*/</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;H5MMprivate.h&quot;</span><span class="hl ppc"></span>	<span class="hl com">/* Memory management			*/</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;H5Pprivate.h&quot;</span><span class="hl ppc"></span>         <span class="hl com">/* Property lists                       */</span><span class="hl ppc"></span>

<span class="hl com">/* Local macros */</span>
<span class="hl ppc">#define H5G_INIT_HEAP		8192</span>
<span class="hl ppc">#define H5G_RESERVED_ATOMS	0</span>
<span class="hl ppc">#define H5G_SIZE_HINT   256</span>             <span class="hl com">/*default root grp size hint         */</span><span class="hl ppc"></span>

<span class="hl com">/*</span>
<span class="hl com"> * During name lookups (see H5G_namei()) we sometimes want information about</span>
<span class="hl com"> * a symbolic link or a mount point.  The normal operation is to follow the</span>
<span class="hl com"> * symbolic link or mount point and return information about its target.</span>
<span class="hl com"> */</span>
<span class="hl ppc">#define H5G_TARGET_NORMAL	0x0000</span>
<span class="hl ppc">#define H5G_TARGET_SLINK	0x0001</span>
<span class="hl ppc">#define H5G_TARGET_MOUNT	0x0002</span>
<span class="hl ppc">#define H5G_CRT_INTMD_GROUP	0x0004</span>

<span class="hl com">/* Local typedefs */</span>

<span class="hl com">/* Struct only used by change name callback function */</span>
<span class="hl kwc">typedef</span> <span class="hl kwb">struct</span> H5G_names_t <span class="hl opt">{</span>
    H5G_entry_t	<span class="hl opt">*</span>loc<span class="hl opt">;</span>
    H5RS_str_t <span class="hl opt">*</span>src_name<span class="hl opt">;</span>
    H5G_entry_t	<span class="hl opt">*</span>src_loc<span class="hl opt">;</span>
    H5RS_str_t <span class="hl opt">*</span>dst_name<span class="hl opt">;</span>
    H5G_entry_t	<span class="hl opt">*</span>dst_loc<span class="hl opt">;</span>
    H5G_names_op_t op<span class="hl opt">;</span>
<span class="hl opt">}</span> H5G_names_t<span class="hl opt">;</span>

<span class="hl com">/* Enum for H5G_namei actions */</span>
<span class="hl kwc">typedef</span> <span class="hl kwb">enum</span> <span class="hl opt">{</span>
    H5G_NAMEI_TRAVERSE<span class="hl opt">,</span>         <span class="hl com">/* Just traverse groups */</span>
    H5G_NAMEI_INSERT            <span class="hl com">/* Insert entry in group */</span>
<span class="hl opt">}</span> H5G_namei_act_t <span class="hl opt">;</span>

<span class="hl com">/*</span>
<span class="hl com"> * This table contains a list of object types, descriptions, and the</span>
<span class="hl com"> * functions that determine if some object is a particular type.  The table</span>
<span class="hl com"> * is allocated dynamically.</span>
<span class="hl com"> */</span>
<span class="hl kwc">typedef</span> <span class="hl kwb">struct</span> H5G_typeinfo_t <span class="hl opt">{</span>
    H5G_obj_t 	type<span class="hl opt">;</span>			        <span class="hl com">/*one of the public H5G_* types	     */</span>
    <span class="hl kwd">htri_t</span>	<span class="hl opt">(*</span>isa<span class="hl opt">)(</span>H5G_entry_t<span class="hl opt">*,</span> hid_t<span class="hl opt">);</span>	<span class="hl com">/*function to determine type	     */</span>
    <span class="hl kwb">char</span>	<span class="hl opt">*</span>desc<span class="hl opt">;</span>			        <span class="hl com">/*description of object type	     */</span>
<span class="hl opt">}</span> H5G_typeinfo_t<span class="hl opt">;</span>

<span class="hl com">/* Local variables */</span>
<span class="hl kwb">static</span> H5G_typeinfo_t <span class="hl opt">*</span>H5G_type_g <span class="hl opt">=</span> NULL<span class="hl opt">;</span>	<span class="hl com">/*object typing info	*/</span>
<span class="hl kwb">static size_t</span> H5G_ntypes_g <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>			<span class="hl com">/*entries in type table	*/</span>
<span class="hl kwb">static size_t</span> H5G_atypes_g <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>			<span class="hl com">/*entries allocated	*/</span>
<span class="hl kwb">static char</span> <span class="hl opt">*</span>H5G_comp_g <span class="hl opt">=</span> NULL<span class="hl opt">;</span>                 <span class="hl com">/*component buffer      */</span>
<span class="hl kwb">static size_t</span> H5G_comp_alloc_g <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>             <span class="hl com">/*sizeof component buffer */</span>

<span class="hl com">/* Declare a free list to manage the H5G_t struct */</span>
<span class="hl kwd">H5FL_DEFINE</span><span class="hl opt">(</span>H5G_t<span class="hl opt">);</span>
<span class="hl kwd">H5FL_DEFINE</span><span class="hl opt">(</span>H5G_shared_t<span class="hl opt">);</span>

<span class="hl com">/* Declare extern the PQ free list for the wrapped strings */</span>
<span class="hl kwd">H5FL_BLK_EXTERN</span><span class="hl opt">(</span>str_buf<span class="hl opt">);</span>

<span class="hl com">/* Private prototypes */</span>
<span class="hl kwb">static</span> herr_t <span class="hl kwd">H5G_register_type</span><span class="hl opt">(</span>H5G_obj_t type<span class="hl opt">,</span> <span class="hl kwd">htri_t</span><span class="hl opt">(*</span>isa<span class="hl opt">)(</span>H5G_entry_t<span class="hl opt">*,</span> hid_t<span class="hl opt">),</span>
				 <span class="hl kwb">const char</span> <span class="hl opt">*</span>desc<span class="hl opt">);</span>
<span class="hl kwb">static const char</span> <span class="hl opt">*</span> <span class="hl kwd">H5G_component</span><span class="hl opt">(</span><span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> <span class="hl kwb">size_t</span> <span class="hl opt">*</span>size_p<span class="hl opt">);</span>
<span class="hl kwb">static const char</span> <span class="hl opt">*</span> <span class="hl kwd">H5G_basename</span><span class="hl opt">(</span><span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> <span class="hl kwb">size_t</span> <span class="hl opt">*</span>size_p<span class="hl opt">);</span>
<span class="hl kwb">static char</span> <span class="hl opt">*</span> <span class="hl kwd">H5G_normalize</span><span class="hl opt">(</span><span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">);</span>
<span class="hl kwb">static</span> herr_t <span class="hl kwd">H5G_namei</span><span class="hl opt">(</span><span class="hl kwb">const</span> H5G_entry_t <span class="hl opt">*</span>loc_ent<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span>
    <span class="hl kwb">const char</span> <span class="hl opt">**</span>rest<span class="hl com">/*out*/</span><span class="hl opt">,</span> H5G_entry_t <span class="hl opt">*</span>grp_ent<span class="hl com">/*out*/</span><span class="hl opt">,</span> H5G_entry_t <span class="hl opt">*</span>obj_ent<span class="hl com">/*out*/</span><span class="hl opt">,</span>
    <span class="hl kwb">unsigned</span> target<span class="hl opt">,</span> <span class="hl kwb">int</span> <span class="hl opt">*</span>nlinks<span class="hl com">/*out*/</span><span class="hl opt">,</span> H5G_namei_act_t action<span class="hl opt">,</span>
    H5G_entry_t <span class="hl opt">*</span>ent<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">);</span>
<span class="hl kwb">static</span> herr_t <span class="hl kwd">H5G_traverse_slink</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>grp_ent<span class="hl com">/*in,out*/</span><span class="hl opt">,</span>
    H5G_entry_t <span class="hl opt">*</span>obj_ent<span class="hl com">/*in,out*/</span><span class="hl opt">,</span> <span class="hl kwb">int</span> <span class="hl opt">*</span>nlinks<span class="hl com">/*in,out*/</span><span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">);</span>
<span class="hl kwb">static</span> H5G_t <span class="hl opt">*</span><span class="hl kwd">H5G_create</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>loc<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> <span class="hl kwb">size_t</span> size_hint<span class="hl opt">,</span>
    hid_t dxpl_id<span class="hl opt">,</span> hid_t gcpl_id<span class="hl opt">,</span> hid_t gapl_id<span class="hl opt">);</span>
<span class="hl kwb">static</span> htri_t <span class="hl kwd">H5G_isa</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>ent<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">);</span>
<span class="hl kwb">static</span> htri_t <span class="hl kwd">H5G_link_isa</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>ent<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">);</span>
<span class="hl kwb">static</span> H5G_t <span class="hl opt">*</span> <span class="hl kwd">H5G_open_oid</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>ent<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">);</span>
<span class="hl kwb">static</span> H5G_t <span class="hl opt">*</span><span class="hl kwd">H5G_rootof</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">);</span>
<span class="hl kwb">static</span> herr_t <span class="hl kwd">H5G_link</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>cur_loc<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>cur_name<span class="hl opt">,</span>
    H5G_entry_t <span class="hl opt">*</span>new_loc<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>new_name<span class="hl opt">,</span> H5G_link_t type<span class="hl opt">,</span>
    <span class="hl kwb">unsigned</span> namei_flags<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">);</span>
<span class="hl kwb">static</span> herr_t <span class="hl kwd">H5G_get_num_objs</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>grp<span class="hl opt">,</span> hsize_t <span class="hl opt">*</span>num_objs<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">);</span>
<span class="hl kwb">static</span> ssize_t <span class="hl kwd">H5G_get_objname_by_idx</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>loc<span class="hl opt">,</span> hsize_t idx<span class="hl opt">,</span> <span class="hl kwb">char</span><span class="hl opt">*</span> name<span class="hl opt">,</span> <span class="hl kwb">size_t</span> size<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">);</span>
<span class="hl kwb">static</span> H5G_obj_t <span class="hl kwd">H5G_get_objtype_by_idx</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>loc<span class="hl opt">,</span> hsize_t idx<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">);</span>
<span class="hl kwb">static</span> herr_t <span class="hl kwd">H5G_linkval</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>loc<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> <span class="hl kwb">size_t</span> size<span class="hl opt">,</span>
    <span class="hl kwb">char</span> <span class="hl opt">*</span>buf<span class="hl com">/*out*/</span><span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">);</span>
<span class="hl kwb">static</span> herr_t <span class="hl kwd">H5G_set_comment</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>loc<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>buf<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">);</span>
<span class="hl kwb">static int</span> <span class="hl kwd">H5G_get_comment</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>loc<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span>
    <span class="hl kwb">size_t</span> bufsize<span class="hl opt">,</span> <span class="hl kwb">char</span> <span class="hl opt">*</span>buf<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">);</span>
<span class="hl kwb">static</span> herr_t <span class="hl kwd">H5G_unlink</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>loc<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">);</span>
<span class="hl kwb">static</span> herr_t <span class="hl kwd">H5G_move</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>src_loc<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>src_name<span class="hl opt">,</span>
    H5G_entry_t <span class="hl opt">*</span>dst_loc<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>dst_name<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">);</span>
<span class="hl kwb">static</span> htri_t <span class="hl kwd">H5G_common_path</span><span class="hl opt">(</span><span class="hl kwb">const</span> H5RS_str_t <span class="hl opt">*</span>fullpath_r<span class="hl opt">,</span>
    <span class="hl kwb">const</span> H5RS_str_t <span class="hl opt">*</span>prefix_r<span class="hl opt">);</span>
<span class="hl kwb">static</span> H5RS_str_t <span class="hl opt">*</span><span class="hl kwd">H5G_build_fullpath</span><span class="hl opt">(</span><span class="hl kwb">const</span> H5RS_str_t <span class="hl opt">*</span>prefix_r<span class="hl opt">,</span> <span class="hl kwb">const</span> H5RS_str_t <span class="hl opt">*</span>name_r<span class="hl opt">);</span>
<span class="hl kwb">static int</span> <span class="hl kwd">H5G_replace_ent</span><span class="hl opt">(</span><span class="hl kwb">void</span> <span class="hl opt">*</span>obj_ptr<span class="hl opt">,</span> hid_t obj_id<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>key<span class="hl opt">);</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5Gcreate</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Creates a new group relative to LOC_ID and gives it the</span>
<span class="hl com"> *		specified NAME.  The group is opened for write access</span>
<span class="hl com"> *		and it's object ID is returned.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		The optional SIZE_HINT specifies how much file space to</span>
<span class="hl com"> *		reserve to store the names that will appear in this</span>
<span class="hl com"> *		group. If a non-positive value is supplied for the SIZE_HINT</span>
<span class="hl com"> *		then a default size is chosen.</span>
<span class="hl com"> *</span>
<span class="hl com"> * See also:	H5Gset(), H5Gpush(), H5Gpop()</span>
<span class="hl com"> *</span>
<span class="hl com"> * Errors:</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	The object ID of a new, empty group open for</span>
<span class="hl com"> *				writing.  Call H5Gclose() when finished with</span>
<span class="hl com"> *				the group.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	FAIL</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *		Wednesday, September 24, 1997</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
hid_t
<span class="hl kwd">H5Gcreate</span><span class="hl opt">(</span>hid_t loc_id<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> <span class="hl kwb">size_t</span> size_hint<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_entry_t		   <span class="hl opt">*</span>loc <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    H5G_t		   <span class="hl opt">*</span>grp <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    hid_t		    ret_value<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_ENTER_API</span><span class="hl opt">(</span>H5Gcreate<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>
    <span class="hl kwd">H5TRACE3</span><span class="hl opt">(</span><span class="hl str">&quot;i&quot;</span><span class="hl opt">,</span><span class="hl str">&quot;isz&quot;</span><span class="hl opt">,</span>loc_id<span class="hl opt">,</span>name<span class="hl opt">,</span>size_hint<span class="hl opt">);</span>

    <span class="hl com">/* Check arguments */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>loc<span class="hl opt">=</span><span class="hl kwd">H5G_loc</span> <span class="hl opt">(</span>loc_id<span class="hl opt">)))</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;not a location&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>name <span class="hl opt">|| !*</span>name<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;no name given&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Create the group */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL <span class="hl opt">== (</span>grp <span class="hl opt">=</span> <span class="hl kwd">H5G_create</span><span class="hl opt">(</span>loc<span class="hl opt">,</span> name<span class="hl opt">,</span> size_hint<span class="hl opt">,</span> H5AC_dxpl_id<span class="hl opt">,</span>
            H5P_GROUP_CREATE_DEFAULT<span class="hl opt">,</span> H5P_DEFAULT<span class="hl opt">)))</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to create group&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">((</span>ret_value <span class="hl opt">=</span> <span class="hl kwd">H5I_register</span><span class="hl opt">(</span>H5I_GROUP<span class="hl opt">,</span> grp<span class="hl opt">)) &lt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ATOM<span class="hl opt">,</span> H5E_CANTREGISTER<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to register group&quot;</span><span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>ret_value<span class="hl opt">&lt;</span><span class="hl num">0</span><span class="hl opt">) {</span>
        <span class="hl kwa">if</span><span class="hl opt">(</span>grp<span class="hl opt">!=</span>NULL<span class="hl opt">)</span>
            <span class="hl kwd">H5G_close</span><span class="hl opt">(</span>grp<span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>

    <span class="hl kwd">FUNC_LEAVE_API</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5Gcreate_expand</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Creates a new group relative to LOC_ID and gives it the</span>
<span class="hl com"> *		specified NAME, and creation property list GCPL_ID and access</span>
<span class="hl com"> *              property list GAPL_ID.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		The optional SIZE_HINT specifies how much file space to</span>
<span class="hl com"> *		reserve to store the names that will appear in this</span>
<span class="hl com"> *		group. If a non-positive value is supplied for the SIZE_HINT</span>
<span class="hl com"> *		then a default size is chosen.</span>
<span class="hl com"> *</span>
<span class="hl com"> *              Given the default setting, H5Gcreate_expand() will have the</span>
<span class="hl com"> *              same function of H5Gcreate()</span>
<span class="hl com"> *</span>
<span class="hl com"> * See also:	H5Gcreate(), H5Dcreate_expand()</span>
<span class="hl com"> *</span>
<span class="hl com"> * Errors:</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	The object ID of a new, empty group open for</span>
<span class="hl com"> *				writing.  Call H5Gclose() when finished with</span>
<span class="hl com"> *				the group.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	FAIL</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:  Peter Cao</span>
<span class="hl com"> *	        May 08, 2005</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
hid_t
<span class="hl kwd">H5Gcreate_expand</span><span class="hl opt">(</span>hid_t loc_id<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> <span class="hl kwb">size_t</span> size_hint<span class="hl opt">,</span> hid_t gcpl_id<span class="hl opt">,</span> hid_t gapl_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_entry_t		   <span class="hl opt">*</span>loc <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    H5G_t		   <span class="hl opt">*</span>grp <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    hid_t		    ret_value<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_ENTER_API</span><span class="hl opt">(</span>H5Gcreate_expand<span class="hl opt">,</span> FAIL<span class="hl opt">)</span>

    <span class="hl com">/* Check arguments */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>loc<span class="hl opt">=</span><span class="hl kwd">H5G_loc</span> <span class="hl opt">(</span>loc_id<span class="hl opt">)))</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;not a location&quot;</span><span class="hl opt">)</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>name <span class="hl opt">|| !*</span>name<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;no name given&quot;</span><span class="hl opt">)</span>

    <span class="hl com">/* Check group creation property list */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>H5P_DEFAULT <span class="hl opt">==</span> gcpl_id<span class="hl opt">)</span>
        gcpl_id <span class="hl opt">=</span> H5P_GROUP_CREATE_DEFAULT<span class="hl opt">;</span>
    <span class="hl kwa">else</span>
        <span class="hl kwa">if</span><span class="hl opt">(</span>TRUE <span class="hl opt">!=</span> <span class="hl kwd">H5P_isa_class</span><span class="hl opt">(</span>gcpl_id<span class="hl opt">,</span> H5P_GROUP_CREATE<span class="hl opt">))</span>
            <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;not group create property list&quot;</span><span class="hl opt">)</span>

<span class="hl ppc">#ifdef LATER</span>
    <span class="hl com">/* Check the group access property list */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>H5P_DEFAULT <span class="hl opt">==</span> gapl_id<span class="hl opt">)</span>
        gapl_id <span class="hl opt">=</span> H5P_GROUP_ACCESS_DEFAULT<span class="hl opt">;</span>
    <span class="hl kwa">else</span>
        <span class="hl kwa">if</span><span class="hl opt">(</span>TRUE <span class="hl opt">!=</span> <span class="hl kwd">H5P_isa_class</span><span class="hl opt">(</span>gapl_id<span class="hl opt">,</span> H5P_GROUP_ACCESS<span class="hl opt">))</span>
            <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;not group access property list&quot;</span><span class="hl opt">)</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* LATER */</span><span class="hl ppc"></span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL <span class="hl opt">== (</span>grp <span class="hl opt">=</span> <span class="hl kwd">H5G_create</span><span class="hl opt">(</span>loc<span class="hl opt">,</span> name<span class="hl opt">,</span> size_hint<span class="hl opt">,</span> H5AC_dxpl_id<span class="hl opt">,</span> gcpl_id<span class="hl opt">,</span> gapl_id<span class="hl opt">)))</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to create group&quot;</span><span class="hl opt">)</span>
    <span class="hl kwa">if</span> <span class="hl opt">((</span>ret_value <span class="hl opt">=</span> <span class="hl kwd">H5I_register</span><span class="hl opt">(</span>H5I_GROUP<span class="hl opt">,</span> grp<span class="hl opt">)) &lt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ATOM<span class="hl opt">,</span> H5E_CANTREGISTER<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to register group&quot;</span><span class="hl opt">)</span>

done<span class="hl opt">:</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>ret_value<span class="hl opt">&lt;</span><span class="hl num">0</span><span class="hl opt">) {</span>
        <span class="hl kwa">if</span><span class="hl opt">(</span>grp<span class="hl opt">!=</span>NULL<span class="hl opt">)</span>
            <span class="hl kwd">H5G_close</span><span class="hl opt">(</span>grp<span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>

    <span class="hl kwd">FUNC_LEAVE_API</span><span class="hl opt">(</span>ret_value<span class="hl opt">)</span>
<span class="hl opt">}</span> <span class="hl com">/* end H5Gcreate_expand() */</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5Gopen</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Opens an existing group for modification.  When finished,</span>
<span class="hl com"> *		call H5Gclose() to close it and release resources.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Errors:</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	Object ID of the group.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	FAIL</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *		Wednesday, December 31, 1997</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
hid_t
<span class="hl kwd">H5Gopen</span><span class="hl opt">(</span>hid_t loc_id<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">)</span>
<span class="hl opt">{</span>
    hid_t       ret_value <span class="hl opt">=</span> FAIL<span class="hl opt">;</span>
    H5G_t       <span class="hl opt">*</span>grp <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    H5G_entry_t	<span class="hl opt">*</span>loc <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    H5G_entry_t	 ent<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_ENTER_API</span><span class="hl opt">(</span>H5Gopen<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>
    <span class="hl kwd">H5TRACE2</span><span class="hl opt">(</span><span class="hl str">&quot;i&quot;</span><span class="hl opt">,</span><span class="hl str">&quot;is&quot;</span><span class="hl opt">,</span>loc_id<span class="hl opt">,</span>name<span class="hl opt">);</span>

    <span class="hl com">/* Check args */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>loc<span class="hl opt">=</span><span class="hl kwd">H5G_loc</span><span class="hl opt">(</span>loc_id<span class="hl opt">)))</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;not a location&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>name <span class="hl opt">|| !*</span>name<span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;no name&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Open the parent group, making sure it's a group */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_find</span><span class="hl opt">(</span>loc<span class="hl opt">,</span> name<span class="hl opt">,</span> NULL<span class="hl opt">, &amp;</span>ent<span class="hl com">/*out*/</span><span class="hl opt">,</span> H5AC_dxpl_id<span class="hl opt">) &lt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;group not found&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Open the group */</span>
    <span class="hl kwa">if</span> <span class="hl opt">((</span>grp <span class="hl opt">=</span> <span class="hl kwd">H5G_open</span><span class="hl opt">(&amp;</span>ent<span class="hl opt">,</span> H5AC_dxpl_id<span class="hl opt">))==</span>NULL<span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTOPENOBJ<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to open group&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Register an atom for the group */</span>
    <span class="hl kwa">if</span> <span class="hl opt">((</span>ret_value <span class="hl opt">=</span> <span class="hl kwd">H5I_register</span><span class="hl opt">(</span>H5I_GROUP<span class="hl opt">,</span> grp<span class="hl opt">)) &lt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ATOM<span class="hl opt">,</span> H5E_CANTREGISTER<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to register group&quot;</span><span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>ret_value<span class="hl opt">&lt;</span><span class="hl num">0</span><span class="hl opt">) {</span>
        <span class="hl kwa">if</span><span class="hl opt">(</span>grp<span class="hl opt">!=</span>NULL<span class="hl opt">)</span>
            <span class="hl kwd">H5G_close</span><span class="hl opt">(</span>grp<span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>

    <span class="hl kwd">FUNC_LEAVE_API</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5Gclose</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Closes the specified group.  The group ID will no longer be</span>
<span class="hl com"> *		valid for accessing the group.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Non-negative on success/Negative on failure</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *		Wednesday, December 31, 1997</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
herr_t
<span class="hl kwd">H5Gclose</span><span class="hl opt">(</span>hid_t group_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_API</span><span class="hl opt">(</span>H5Gclose<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>
    <span class="hl kwd">H5TRACE1</span><span class="hl opt">(</span><span class="hl str">&quot;e&quot;</span><span class="hl opt">,</span><span class="hl str">&quot;i&quot;</span><span class="hl opt">,</span>group_id<span class="hl opt">);</span>

    <span class="hl com">/* Check args */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL <span class="hl opt">==</span> <span class="hl kwd">H5I_object_verify</span><span class="hl opt">(</span>group_id<span class="hl opt">,</span>H5I_GROUP<span class="hl opt">))</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;not a group&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Decrement the counter on the group atom.	 It will be freed if the count</span>
<span class="hl com">     * reaches zero.</span>
<span class="hl com">     */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5I_dec_ref</span><span class="hl opt">(</span>group_id<span class="hl opt">) &lt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to close group&quot;</span><span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_API</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5Giterate</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Iterates over the entries of a group.  The LOC_ID and NAME</span>
<span class="hl com"> *		identify the group over which to iterate and IDX indicates</span>
<span class="hl com"> *		where to start iterating (zero means at the beginning).	 The</span>
<span class="hl com"> *		OPERATOR is called for each member and the iteration</span>
<span class="hl com"> *		continues until the operator returns non-zero or all members</span>
<span class="hl com"> *		are processed. The operator is passed a group ID for the</span>
<span class="hl com"> *		group being iterated, a member name, and OP_DATA for each</span>
<span class="hl com"> *		member.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	The return value of the first operator that</span>
<span class="hl com"> *				returns non-zero, or zero if all members were</span>
<span class="hl com"> *				processed with no operator returning non-zero.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	Negative if something goes wrong within the</span>
<span class="hl com"> *				library, or the negative value returned by one</span>
<span class="hl com"> *				of the operators.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *		Monday, March 23, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
herr_t
<span class="hl kwd">H5Giterate</span><span class="hl opt">(</span>hid_t loc_id<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> <span class="hl kwb">int</span> <span class="hl opt">*</span>idx_p<span class="hl opt">,</span>
	    H5G_iterate_t op<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>op_data<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5O_stab_t		stab_mesg<span class="hl opt">;</span>		<span class="hl com">/*info about B-tree	*/</span>
    <span class="hl kwb">int</span>			idx<span class="hl opt">;</span>
    H5G_bt_ud2_t	udata<span class="hl opt">;</span>
    H5G_t		<span class="hl opt">*</span>grp <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    herr_t		ret_value<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_ENTER_API</span><span class="hl opt">(</span>H5Giterate<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>
    <span class="hl kwd">H5TRACE5</span><span class="hl opt">(</span><span class="hl str">&quot;e&quot;</span><span class="hl opt">,</span><span class="hl str">&quot;is*Isxx&quot;</span><span class="hl opt">,</span>loc_id<span class="hl opt">,</span>name<span class="hl opt">,</span>idx_p<span class="hl opt">,</span>op<span class="hl opt">,</span>op_data<span class="hl opt">);</span>

    <span class="hl com">/* Check args */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>name <span class="hl opt">|| !*</span>name<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;no name specified&quot;</span><span class="hl opt">);</span>
    idx <span class="hl opt">= (</span>idx_p <span class="hl opt">==</span> NULL ? <span class="hl num">0</span> <span class="hl opt">: *</span>idx_p<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>idx_p<span class="hl opt">)</span>
        idx_p <span class="hl opt">= &amp;</span>idx<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>idx<span class="hl opt">&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;invalid index specified&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>op<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;no operator specified&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Open the group on which to operate.  We also create a group ID which</span>
<span class="hl com">     * we can pass to the application-defined operator.</span>
<span class="hl com">     */</span>
    <span class="hl kwa">if</span> <span class="hl opt">((</span>udata<span class="hl opt">.</span>group_id <span class="hl opt">=</span> <span class="hl kwd">H5Gopen</span> <span class="hl opt">(</span>loc_id<span class="hl opt">,</span> name<span class="hl opt">)) &lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTOPENOBJ<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to open group&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">((</span>grp<span class="hl opt">=</span><span class="hl kwd">H5I_object</span><span class="hl opt">(</span>udata<span class="hl opt">.</span>group_id<span class="hl opt">))==</span>NULL<span class="hl opt">) {</span>
        <span class="hl kwd">H5Gclose</span><span class="hl opt">(</span>udata<span class="hl opt">.</span>group_id<span class="hl opt">);</span>
        <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ATOM<span class="hl opt">,</span> H5E_BADATOM<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;bad group atom&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/* Get the B-tree info */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==</span><span class="hl kwd">H5O_read</span> <span class="hl opt">(&amp;(</span>grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">),</span> H5O_STAB_ID<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">, &amp;</span>stab_mesg<span class="hl opt">,</span> H5AC_dxpl_id<span class="hl opt">))</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to determine local heap address&quot;</span><span class="hl opt">)</span>

    <span class="hl com">/* Build udata to pass through H5B_iterate() to H5G_node_iterate() */</span>
    udata<span class="hl opt">.</span>skip <span class="hl opt">=</span> idx<span class="hl opt">;</span>
    udata<span class="hl opt">.</span>stab <span class="hl opt">= &amp;</span>stab_mesg<span class="hl opt">;</span>
    udata<span class="hl opt">.</span>op <span class="hl opt">=</span> op<span class="hl opt">;</span>
    udata<span class="hl opt">.</span>op_data <span class="hl opt">=</span> op_data<span class="hl opt">;</span>

    <span class="hl com">/* Set the number of entries looked at to zero */</span>
    udata<span class="hl opt">.</span>final_ent <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>

    <span class="hl com">/* Iterate over the group members */</span>
    <span class="hl kwa">if</span> <span class="hl opt">((</span>ret_value <span class="hl opt">=</span> <span class="hl kwd">H5B_iterate</span> <span class="hl opt">(</span><span class="hl kwd">H5G_fileof</span><span class="hl opt">(</span>grp<span class="hl opt">),</span> H5AC_dxpl_id<span class="hl opt">,</span> H5B_SNODE<span class="hl opt">,</span>
              H5G_node_iterate<span class="hl opt">,</span> stab_mesg<span class="hl opt">.</span>btree_addr<span class="hl opt">, &amp;</span>udata<span class="hl opt">))&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwd">HERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTNEXT<span class="hl opt">,</span> <span class="hl str">&quot;iteration operator failed&quot;</span><span class="hl opt">);</span>

    <span class="hl kwd">H5I_dec_ref</span> <span class="hl opt">(</span>udata<span class="hl opt">.</span>group_id<span class="hl opt">);</span> <span class="hl com">/*also closes 'grp'*/</span>

    <span class="hl com">/* Check for too high of a starting index (ex post facto :-) */</span>
    <span class="hl com">/* (Skipping exactly as many entries as are in the group is currently an error) */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>idx<span class="hl opt">&gt;</span><span class="hl num">0</span> <span class="hl opt">&amp;&amp;</span> idx<span class="hl opt">&gt;=</span>udata<span class="hl opt">.</span>final_ent<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;invalid index specified&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Set the index we stopped at */</span>
    <span class="hl opt">*</span>idx_p<span class="hl opt">=</span>udata<span class="hl opt">.</span>final_ent<span class="hl opt">;</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_API</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5Gget_num_objs</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:     Returns the number of objects in the group.  It iterates</span>
<span class="hl com"> *              all B-tree leaves and sum up total number of group members.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:        Non-negative</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	Negative</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Raymond Lu</span>
<span class="hl com"> *	        Nov 20, 2002</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
herr_t
<span class="hl kwd">H5Gget_num_objs</span><span class="hl opt">(</span>hid_t loc_id<span class="hl opt">,</span> hsize_t <span class="hl opt">*</span>num_objs<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_entry_t		<span class="hl opt">*</span>loc <span class="hl opt">=</span> NULL<span class="hl opt">;</span>    <span class="hl com">/* Pointer to symbol table entry */</span>
    herr_t		ret_value<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_ENTER_API</span><span class="hl opt">(</span>H5Gget_num_objs<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>
    <span class="hl kwd">H5TRACE2</span><span class="hl opt">(</span><span class="hl str">&quot;e&quot;</span><span class="hl opt">,</span><span class="hl str">&quot;i*h&quot;</span><span class="hl opt">,</span>loc_id<span class="hl opt">,</span>num_objs<span class="hl opt">);</span>

    <span class="hl com">/* Check args */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>loc<span class="hl opt">=</span><span class="hl kwd">H5G_loc</span> <span class="hl opt">(</span>loc_id<span class="hl opt">)))</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;not a location ID&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5G_get_type</span><span class="hl opt">(</span>loc<span class="hl opt">,</span>H5AC_ind_dxpl_id<span class="hl opt">)!=</span>H5G_GROUP<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;not a group&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>num_objs<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;nil pointer&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Call private function. */</span>
    ret_value <span class="hl opt">=</span> <span class="hl kwd">H5G_get_num_objs</span><span class="hl opt">(</span>loc<span class="hl opt">,</span> num_objs<span class="hl opt">,</span> H5AC_ind_dxpl_id<span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_API</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5Gget_objname_by_idx</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:     Returns the name of objects in the group by giving index.</span>
<span class="hl com"> *              If `name' is non-NULL then write up to `size' bytes into that</span>
<span class="hl com"> *              buffer and always return the length of the entry name.</span>
<span class="hl com"> *              Otherwise `size' is ignored and the function does not store the name,</span>
<span class="hl com"> *              just returning the number of characters required to store the name.</span>
<span class="hl com"> *              If an error occurs then the buffer pointed to by `name' (NULL or non-NULL)</span>
<span class="hl com"> *              is unchanged and the function returns a negative value.</span>
<span class="hl com"> *              If a zero is returned for the name's length, then there is no name</span>
<span class="hl com"> *              associated with the ID.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:        Non-negative</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	Negative</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Raymond Lu</span>
<span class="hl com"> *	        Nov 20, 2002</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
ssize_t
<span class="hl kwd">H5Gget_objname_by_idx</span><span class="hl opt">(</span>hid_t loc_id<span class="hl opt">,</span> hsize_t idx<span class="hl opt">,</span> <span class="hl kwb">char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> <span class="hl kwb">size_t</span> size<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_entry_t		<span class="hl opt">*</span>loc <span class="hl opt">=</span> NULL<span class="hl opt">;</span>    <span class="hl com">/* Pointer to symbol table entry */</span>
    ssize_t		ret_value <span class="hl opt">=</span> FAIL<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_ENTER_API</span><span class="hl opt">(</span>H5Gget_objname_by_idx<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>
    <span class="hl kwd">H5TRACE4</span><span class="hl opt">(</span><span class="hl str">&quot;Zs&quot;</span><span class="hl opt">,</span><span class="hl str">&quot;ihsz&quot;</span><span class="hl opt">,</span>loc_id<span class="hl opt">,</span>idx<span class="hl opt">,</span>name<span class="hl opt">,</span>size<span class="hl opt">);</span>

    <span class="hl com">/* Check args */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>loc<span class="hl opt">=</span><span class="hl kwd">H5G_loc</span> <span class="hl opt">(</span>loc_id<span class="hl opt">)))</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;not a location ID&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5G_get_type</span><span class="hl opt">(</span>loc<span class="hl opt">,</span>H5AC_ind_dxpl_id<span class="hl opt">)!=</span>H5G_GROUP<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;not a group&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/*call private function*/</span>
    ret_value <span class="hl opt">=</span> <span class="hl kwd">H5G_get_objname_by_idx</span><span class="hl opt">(</span>loc<span class="hl opt">,</span> idx<span class="hl opt">,</span> name<span class="hl opt">,</span> size<span class="hl opt">,</span> H5AC_ind_dxpl_id<span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_API</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5Gget_objtype_by_idx</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:     Returns the type of objects in the group by giving index.</span>
<span class="hl com"> *</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:        H5G_GROUP(1), H5G_DATASET(2), H5G_TYPE(3)</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	H5G_UNKNOWN</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Raymond Lu</span>
<span class="hl com"> *	        Nov 20, 2002</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
H5G_obj_t
<span class="hl kwd">H5Gget_objtype_by_idx</span><span class="hl opt">(</span>hid_t loc_id<span class="hl opt">,</span> hsize_t idx<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_entry_t		<span class="hl opt">*</span>loc <span class="hl opt">=</span> NULL<span class="hl opt">;</span>    <span class="hl com">/* Pointer to symbol table entry */</span>
    H5G_obj_t		ret_value<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_ENTER_API</span><span class="hl opt">(</span>H5Gget_objtype_by_idx<span class="hl opt">,</span> H5G_UNKNOWN<span class="hl opt">);</span>
    <span class="hl kwd">H5TRACE2</span><span class="hl opt">(</span><span class="hl str">&quot;Go&quot;</span><span class="hl opt">,</span><span class="hl str">&quot;ih&quot;</span><span class="hl opt">,</span>loc_id<span class="hl opt">,</span>idx<span class="hl opt">);</span>

    <span class="hl com">/* Check args */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>loc<span class="hl opt">=</span><span class="hl kwd">H5G_loc</span> <span class="hl opt">(</span>loc_id<span class="hl opt">)))</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> H5G_UNKNOWN<span class="hl opt">,</span> <span class="hl str">&quot;not a location ID&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5G_get_type</span><span class="hl opt">(</span>loc<span class="hl opt">,</span>H5AC_ind_dxpl_id<span class="hl opt">)!=</span>H5G_GROUP<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> H5G_UNKNOWN<span class="hl opt">,</span> <span class="hl str">&quot;not a group&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/*call private function*/</span>
    ret_value <span class="hl opt">=</span> <span class="hl kwd">H5G_get_objtype_by_idx</span><span class="hl opt">(</span>loc<span class="hl opt">,</span> idx<span class="hl opt">,</span> H5AC_ind_dxpl_id<span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_API</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>

<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5Gmove2</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Renames an object within an HDF5 file.  The original name SRC</span>
<span class="hl com"> *		is unlinked from the group graph and the new name DST is</span>
<span class="hl com"> *		inserted as an atomic operation.  Both names are interpreted</span>
<span class="hl com"> *		relative to SRC_LOC_ID and DST_LOC_ID, which are either a file</span>
<span class="hl com"> *		ID or a group ID.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Non-negative on success/Negative on failure</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Monday, April  6, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Raymond Lu</span>
<span class="hl com"> *		Thursday, April 18, 2002</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
herr_t
<span class="hl kwd">H5Gmove2</span><span class="hl opt">(</span>hid_t src_loc_id<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>src_name<span class="hl opt">,</span> hid_t dst_loc_id<span class="hl opt">,</span>
	 <span class="hl kwb">const char</span> <span class="hl opt">*</span>dst_name<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_entry_t		<span class="hl opt">*</span>src_loc<span class="hl opt">=</span>NULL<span class="hl opt">;</span>
    H5G_entry_t		<span class="hl opt">*</span>dst_loc<span class="hl opt">=</span>NULL<span class="hl opt">;</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_API</span><span class="hl opt">(</span>H5Gmove2<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>
    <span class="hl kwd">H5TRACE4</span><span class="hl opt">(</span><span class="hl str">&quot;e&quot;</span><span class="hl opt">,</span><span class="hl str">&quot;isis&quot;</span><span class="hl opt">,</span>src_loc_id<span class="hl opt">,</span>src_name<span class="hl opt">,</span>dst_loc_id<span class="hl opt">,</span>dst_name<span class="hl opt">);</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>src_loc_id <span class="hl opt">!=</span> H5G_SAME_LOC <span class="hl opt">&amp;&amp;</span> NULL<span class="hl opt">==(</span>src_loc<span class="hl opt">=</span><span class="hl kwd">H5G_loc</span><span class="hl opt">(</span>src_loc_id<span class="hl opt">)))</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;not a location&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>dst_loc_id <span class="hl opt">!=</span> H5G_SAME_LOC <span class="hl opt">&amp;&amp;</span> NULL<span class="hl opt">==(</span>dst_loc<span class="hl opt">=</span><span class="hl kwd">H5G_loc</span><span class="hl opt">(</span>dst_loc_id<span class="hl opt">)))</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;not a location&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>src_name <span class="hl opt">|| !*</span>src_name<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;no current name specified&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>dst_name <span class="hl opt">|| !*</span>dst_name<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;no new name specified&quot;</span><span class="hl opt">);</span>

    <span class="hl kwa">if</span><span class="hl opt">(</span>src_loc_id <span class="hl opt">==</span> H5G_SAME_LOC <span class="hl opt">&amp;&amp;</span> dst_loc_id <span class="hl opt">==</span> H5G_SAME_LOC<span class="hl opt">) {</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;source and destination should not be both H5G_SAME_LOC&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl kwa">else if</span><span class="hl opt">(</span>src_loc_id <span class="hl opt">==</span> H5G_SAME_LOC<span class="hl opt">) {</span>
	src_loc <span class="hl opt">=</span> dst_loc<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">else if</span><span class="hl opt">(</span>dst_loc_id <span class="hl opt">==</span> H5G_SAME_LOC<span class="hl opt">) {</span>
	dst_loc <span class="hl opt">=</span> src_loc<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">else if</span><span class="hl opt">(</span>src_loc<span class="hl opt">-&gt;</span>file <span class="hl opt">!=</span> dst_loc<span class="hl opt">-&gt;</span>file<span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;source and destination should be in the same file.&quot;</span><span class="hl opt">);</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_move</span><span class="hl opt">(</span>src_loc<span class="hl opt">,</span> src_name<span class="hl opt">,</span> dst_loc<span class="hl opt">,</span> dst_name<span class="hl opt">,</span> H5AC_dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to change object name&quot;</span><span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_API</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5Glink2</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Creates a link of the specified type from NEW_NAME to</span>
<span class="hl com"> *		CUR_NAME.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		If TYPE is H5G_LINK_HARD then CUR_NAME must name an existing</span>
<span class="hl com"> *		object.  CUR_NAME and NEW_NAME are interpreted relative to</span>
<span class="hl com"> *		CUR_LOC_ID and NEW_LOC_ID, which is either a file ID or a</span>
<span class="hl com"> *		group ID.</span>
<span class="hl com"> *</span>
<span class="hl com"> * 		If TYPE is H5G_LINK_SOFT then CUR_NAME can be anything and is</span>
<span class="hl com"> *		interpreted at lookup time relative to the group which</span>
<span class="hl com"> *		contains the final component of NEW_NAME.  For instance, if</span>
<span class="hl com"> *		CUR_NAME is `./foo' and NEW_NAME is `./x/y/bar' and a request</span>
<span class="hl com"> *		is made for `./x/y/bar' then the actual object looked up is</span>
<span class="hl com"> *		`./x/y/./foo'.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Non-negative on success/Negative on failure</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Monday, April  6, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
herr_t
<span class="hl kwd">H5Glink2</span><span class="hl opt">(</span>hid_t cur_loc_id<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>cur_name<span class="hl opt">,</span> H5G_link_t type<span class="hl opt">,</span>
	 hid_t new_loc_id<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>new_name<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_entry_t	<span class="hl opt">*</span>cur_loc <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    H5G_entry_t <span class="hl opt">*</span>new_loc <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_API</span><span class="hl opt">(</span>H5Glink2<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>
    <span class="hl kwd">H5TRACE5</span><span class="hl opt">(</span><span class="hl str">&quot;e&quot;</span><span class="hl opt">,</span><span class="hl str">&quot;isGlis&quot;</span><span class="hl opt">,</span>cur_loc_id<span class="hl opt">,</span>cur_name<span class="hl opt">,</span>type<span class="hl opt">,</span>new_loc_id<span class="hl opt">,</span>new_name<span class="hl opt">);</span>

    <span class="hl com">/* Check arguments */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>cur_loc_id <span class="hl opt">!=</span> H5G_SAME_LOC <span class="hl opt">&amp;&amp;</span> NULL<span class="hl opt">==(</span>cur_loc<span class="hl opt">=</span><span class="hl kwd">H5G_loc</span><span class="hl opt">(</span>cur_loc_id<span class="hl opt">)))</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;not a location&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>new_loc_id <span class="hl opt">!=</span> H5G_SAME_LOC <span class="hl opt">&amp;&amp;</span> NULL<span class="hl opt">==(</span>new_loc<span class="hl opt">=</span><span class="hl kwd">H5G_loc</span><span class="hl opt">(</span>new_loc_id<span class="hl opt">)))</span>
        <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;not a location&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>type<span class="hl opt">!=</span>H5G_LINK_HARD <span class="hl opt">&amp;&amp;</span> type<span class="hl opt">!=</span>H5G_LINK_SOFT<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unrecognized link type&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>cur_name <span class="hl opt">|| !*</span>cur_name<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;no current name specified&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>new_name <span class="hl opt">|| !*</span>new_name<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;no new name specified&quot;</span><span class="hl opt">);</span>

    <span class="hl kwa">if</span><span class="hl opt">(</span>cur_loc_id <span class="hl opt">==</span> H5G_SAME_LOC <span class="hl opt">&amp;&amp;</span> new_loc_id <span class="hl opt">==</span> H5G_SAME_LOC<span class="hl opt">) {</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;source and destination should not be both H5G_SAME_LOC&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">else if</span><span class="hl opt">(</span>cur_loc_id <span class="hl opt">==</span> H5G_SAME_LOC<span class="hl opt">) {</span>
        cur_loc <span class="hl opt">=</span> new_loc<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">else if</span><span class="hl opt">(</span>new_loc_id <span class="hl opt">==</span> H5G_SAME_LOC<span class="hl opt">) {</span>
   	new_loc <span class="hl opt">=</span> cur_loc<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">else if</span><span class="hl opt">(</span>cur_loc<span class="hl opt">-&gt;</span>file <span class="hl opt">!=</span> new_loc<span class="hl opt">-&gt;</span>file<span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;source and destination should be in the same file.&quot;</span><span class="hl opt">);</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_link</span><span class="hl opt">(</span>cur_loc<span class="hl opt">,</span> cur_name<span class="hl opt">,</span> new_loc<span class="hl opt">,</span> new_name<span class="hl opt">,</span> type<span class="hl opt">,</span> H5G_TARGET_NORMAL<span class="hl opt">,</span> H5AC_dxpl_id<span class="hl opt">) &lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_LINK<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to create link&quot;</span><span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_API</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5Gunlink</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Removes the specified NAME from the group graph and</span>
<span class="hl com"> *		decrements the link count for the object to which NAME</span>
<span class="hl com"> *		points.  If the link count reaches zero then all file-space</span>
<span class="hl com"> *		associated with the object will be reclaimed (but if the</span>
<span class="hl com"> *		object is open, then the reclamation of the file space is</span>
<span class="hl com"> *		delayed until all handles to the object are closed).</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Non-negative on success/Negative on failure</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Monday, April  6, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
herr_t
<span class="hl kwd">H5Gunlink</span><span class="hl opt">(</span>hid_t loc_id<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_entry_t	<span class="hl opt">*</span>loc <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_API</span><span class="hl opt">(</span>H5Gunlink<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>
    <span class="hl kwd">H5TRACE2</span><span class="hl opt">(</span><span class="hl str">&quot;e&quot;</span><span class="hl opt">,</span><span class="hl str">&quot;is&quot;</span><span class="hl opt">,</span>loc_id<span class="hl opt">,</span>name<span class="hl opt">);</span>

    <span class="hl com">/* Check arguments */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>loc<span class="hl opt">=</span><span class="hl kwd">H5G_loc</span><span class="hl opt">(</span>loc_id<span class="hl opt">)))</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;not a location&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>name <span class="hl opt">|| !*</span>name<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;no name&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Unlink */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_unlink</span><span class="hl opt">(</span>loc<span class="hl opt">,</span> name<span class="hl opt">,</span> H5AC_dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to unlink object&quot;</span><span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_API</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5Gget_objinfo</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Returns information about an object.  If FOLLOW_LINK is</span>
<span class="hl com"> *		non-zero then all symbolic links are followed; otherwise all</span>
<span class="hl com"> *		links except the last component of the name are followed.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Non-negative on success, with the fields of STATBUF (if</span>
<span class="hl com"> *              non-null) initialized. Negative on failure.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Monday, April 13, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
herr_t
<span class="hl kwd">H5Gget_objinfo</span><span class="hl opt">(</span>hid_t loc_id<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> hbool_t follow_link<span class="hl opt">,</span>
	       H5G_stat_t <span class="hl opt">*</span>statbuf<span class="hl com">/*out*/</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_entry_t	<span class="hl opt">*</span>loc <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_API</span><span class="hl opt">(</span>H5Gget_objinfo<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>
    <span class="hl kwd">H5TRACE4</span><span class="hl opt">(</span><span class="hl str">&quot;e&quot;</span><span class="hl opt">,</span><span class="hl str">&quot;isbx&quot;</span><span class="hl opt">,</span>loc_id<span class="hl opt">,</span>name<span class="hl opt">,</span>follow_link<span class="hl opt">,</span>statbuf<span class="hl opt">);</span>

    <span class="hl com">/* Check arguments */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>loc<span class="hl opt">=</span><span class="hl kwd">H5G_loc</span> <span class="hl opt">(</span>loc_id<span class="hl opt">)))</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;not a location&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>name <span class="hl opt">|| !*</span>name<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;no name specified&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Get info */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_get_objinfo</span> <span class="hl opt">(</span>loc<span class="hl opt">,</span> name<span class="hl opt">,</span> follow_link<span class="hl opt">,</span> statbuf<span class="hl opt">,</span> H5AC_ind_dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;cannot stat object&quot;</span><span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_API</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5Gget_linkval</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Returns the value of a symbolic link whose name is NAME.  At</span>
<span class="hl com"> *		most SIZE characters (counting the null terminator) are</span>
<span class="hl com"> *		copied to the BUF result buffer.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	Non-negative with the link value in BUF.</span>
<span class="hl com"> *</span>
<span class="hl com"> * 		Failure:	Negative</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Monday, April 13, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
herr_t
<span class="hl kwd">H5Gget_linkval</span><span class="hl opt">(</span>hid_t loc_id<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> <span class="hl kwb">size_t</span> size<span class="hl opt">,</span> <span class="hl kwb">char</span> <span class="hl opt">*</span>buf<span class="hl com">/*out*/</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_entry_t	<span class="hl opt">*</span>loc <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_API</span><span class="hl opt">(</span>H5Gget_linkval<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>
    <span class="hl kwd">H5TRACE4</span><span class="hl opt">(</span><span class="hl str">&quot;e&quot;</span><span class="hl opt">,</span><span class="hl str">&quot;iszx&quot;</span><span class="hl opt">,</span>loc_id<span class="hl opt">,</span>name<span class="hl opt">,</span>size<span class="hl opt">,</span>buf<span class="hl opt">);</span>

    <span class="hl com">/* Check arguments */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>loc<span class="hl opt">=</span><span class="hl kwd">H5G_loc</span> <span class="hl opt">(</span>loc_id<span class="hl opt">)))</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;not a location&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>name <span class="hl opt">|| !*</span>name<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;no name specified&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Get the link value */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_linkval</span> <span class="hl opt">(</span>loc<span class="hl opt">,</span> name<span class="hl opt">,</span> size<span class="hl opt">,</span> buf<span class="hl opt">,</span> H5AC_ind_dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to get link value&quot;</span><span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_API</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5Gset_comment</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:     Gives the specified object a comment.  The COMMENT string</span>
<span class="hl com"> *		should be a null terminated string.  An object can have only</span>
<span class="hl com"> *		one comment at a time.  Passing NULL for the COMMENT argument</span>
<span class="hl com"> *		will remove the comment property from the object.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Non-negative on success/Negative on failure</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Monday, July 20, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
herr_t
<span class="hl kwd">H5Gset_comment</span><span class="hl opt">(</span>hid_t loc_id<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>comment<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_entry_t	<span class="hl opt">*</span>loc <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_API</span><span class="hl opt">(</span>H5Gset_comment<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>
    <span class="hl kwd">H5TRACE3</span><span class="hl opt">(</span><span class="hl str">&quot;e&quot;</span><span class="hl opt">,</span><span class="hl str">&quot;iss&quot;</span><span class="hl opt">,</span>loc_id<span class="hl opt">,</span>name<span class="hl opt">,</span>comment<span class="hl opt">);</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>loc<span class="hl opt">=</span><span class="hl kwd">H5G_loc</span><span class="hl opt">(</span>loc_id<span class="hl opt">)))</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;not a location&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>name <span class="hl opt">|| !*</span>name<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;no name specified&quot;</span><span class="hl opt">);</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_set_comment</span><span class="hl opt">(</span>loc<span class="hl opt">,</span> name<span class="hl opt">,</span> comment<span class="hl opt">,</span> H5AC_dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to set comment value&quot;</span><span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_API</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5Gget_comment</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Return at most BUFSIZE characters of the comment for the</span>
<span class="hl com"> *		specified object.  If BUFSIZE is large enough to hold the</span>
<span class="hl com"> *		entire comment then the comment string will be null</span>
<span class="hl com"> *		terminated, otherwise it will not.  If the object does not</span>
<span class="hl com"> *		have a comment value then no bytes are copied to the BUF</span>
<span class="hl com"> *		buffer.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	Number of characters in the comment counting</span>
<span class="hl com"> *				the null terminator.  The value returned may</span>
<span class="hl com"> *				be larger than the BUFSIZE argument.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	Negative</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Monday, July 20, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">int</span>
<span class="hl kwd">H5Gget_comment</span><span class="hl opt">(</span>hid_t loc_id<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> <span class="hl kwb">size_t</span> bufsize<span class="hl opt">,</span> <span class="hl kwb">char</span> <span class="hl opt">*</span>buf<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_entry_t	<span class="hl opt">*</span>loc <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl kwb">int</span>	ret_value<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_ENTER_API</span><span class="hl opt">(</span>H5Gget_comment<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>
    <span class="hl kwd">H5TRACE4</span><span class="hl opt">(</span><span class="hl str">&quot;Is&quot;</span><span class="hl opt">,</span><span class="hl str">&quot;iszs&quot;</span><span class="hl opt">,</span>loc_id<span class="hl opt">,</span>name<span class="hl opt">,</span>bufsize<span class="hl opt">,</span>buf<span class="hl opt">);</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>loc<span class="hl opt">=</span><span class="hl kwd">H5G_loc</span><span class="hl opt">(</span>loc_id<span class="hl opt">)))</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;not a location&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>name <span class="hl opt">|| !*</span>name<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;no name specified&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>bufsize<span class="hl opt">&gt;</span><span class="hl num">0</span> <span class="hl opt">&amp;&amp; !</span>buf<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;no buffer specified&quot;</span><span class="hl opt">);</span>

    <span class="hl kwa">if</span> <span class="hl opt">((</span>ret_value<span class="hl opt">=</span><span class="hl kwd">H5G_get_comment</span><span class="hl opt">(</span>loc<span class="hl opt">,</span> name<span class="hl opt">,</span> bufsize<span class="hl opt">,</span> buf<span class="hl opt">,</span> H5AC_ind_dxpl_id<span class="hl opt">))&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to get comment value&quot;</span><span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_API</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> *   N O   A P I   F U N C T I O N S   B E Y O N D   T H I S   P O I N T</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>

<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_init_interface</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Initializes the H5G interface.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Non-negative on success/Negative on failure</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *		Monday, January	 5, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> herr_t
<span class="hl kwd">H5G_init_interface</span><span class="hl opt">(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
    herr_t          ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>
    H5P_genclass_t  <span class="hl opt">*</span>crt_pclass<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT</span><span class="hl opt">(</span>H5G_init_interface<span class="hl opt">);</span>

    <span class="hl com">/* Initialize the atom group for the group IDs */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5I_register_type</span><span class="hl opt">(</span>H5I_GROUP<span class="hl opt">, (</span><span class="hl kwb">size_t</span><span class="hl opt">)</span>H5I_GROUPID_HASHSIZE<span class="hl opt">,</span> H5G_RESERVED_ATOMS<span class="hl opt">,</span>
		       <span class="hl opt">(</span>H5I_free_t<span class="hl opt">)</span>H5G_close<span class="hl opt">) &lt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to initialize interface&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Initialize the type info table.  Begin with the most general types and</span>
<span class="hl com">     * end with the most specific. For instance, any object that has a data</span>
<span class="hl com">     * type message is a datatype but only some of them are datasets.</span>
<span class="hl com">     */</span>
    <span class="hl kwd">H5G_register_type</span><span class="hl opt">(</span>H5G_TYPE<span class="hl opt">,</span>    H5T_isa<span class="hl opt">,</span>  <span class="hl str">&quot;datatype&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">H5G_register_type</span><span class="hl opt">(</span>H5G_GROUP<span class="hl opt">,</span>   H5G_isa<span class="hl opt">,</span>  <span class="hl str">&quot;group&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">H5G_register_type</span><span class="hl opt">(</span>H5G_DATASET<span class="hl opt">,</span> H5D_isa<span class="hl opt">,</span>  <span class="hl str">&quot;dataset&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">H5G_register_type</span><span class="hl opt">(</span>H5G_LINK<span class="hl opt">,</span>    H5G_link_isa<span class="hl opt">,</span>  <span class="hl str">&quot;link&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* ========== group Creation Property Class Initialization ============*/</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>H5P_CLS_GROUP_CREATE_g<span class="hl opt">!=-</span><span class="hl num">1</span><span class="hl opt">);</span>

    <span class="hl com">/* Get the pointer to group creation class */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>NULL <span class="hl opt">== (</span>crt_pclass <span class="hl opt">=</span> <span class="hl kwd">H5I_object</span><span class="hl opt">(</span>H5P_CLS_GROUP_CREATE_g<span class="hl opt">)))</span>
         <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;not a property list class&quot;</span><span class="hl opt">)</span>

    <span class="hl com">/* Put group creation property insertion code here when it's needed. */</span>
    <span class="hl com">/* (See example in H5D_init_interface() ) */</span>

    <span class="hl com">/* Only register the default property list if it hasn't been created yet */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>H5P_LST_GROUP_CREATE_g<span class="hl opt">==(-</span><span class="hl num">1</span><span class="hl opt">)) {</span>
        <span class="hl com">/* Register the default group creation property list */</span>
        <span class="hl kwa">if</span><span class="hl opt">((</span>H5P_LST_GROUP_CREATE_g <span class="hl opt">=</span> <span class="hl kwd">H5P_create_id</span><span class="hl opt">(</span>crt_pclass<span class="hl opt">))&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
             <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_PLIST<span class="hl opt">,</span> H5E_CANTREGISTER<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;can't insert property into class&quot;</span><span class="hl opt">)</span>
    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_term_interface</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Terminates the H5G interface</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	Positive if anything is done that might</span>
<span class="hl com"> *				affect other interfaces; zero otherwise.</span>
<span class="hl com"> *</span>
<span class="hl com"> * 		Failure:	Negative.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *		Monday, January	 5, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *              Robb Matzke, 2002-03-28</span>
<span class="hl com"> *              Free the global component buffer.</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">int</span>
<span class="hl kwd">H5G_term_interface</span><span class="hl opt">(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">size_t</span>	i<span class="hl opt">;</span>
    <span class="hl kwb">int</span>	n<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">;</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT_NOFUNC</span><span class="hl opt">(</span>H5G_term_interface<span class="hl opt">);</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>H5_interface_initialize_g<span class="hl opt">) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">((</span>n<span class="hl opt">=</span><span class="hl kwd">H5I_nmembers</span><span class="hl opt">(</span>H5I_GROUP<span class="hl opt">))) {</span>
	    <span class="hl kwd">H5I_clear_type</span><span class="hl opt">(</span>H5I_GROUP<span class="hl opt">,</span> FALSE<span class="hl opt">);</span>
	<span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	    <span class="hl com">/* Empty the object type table */</span>
	    <span class="hl kwa">for</span> <span class="hl opt">(</span>i<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">;</span> i<span class="hl opt">&lt;</span>H5G_ntypes_g<span class="hl opt">;</span> i<span class="hl opt">++)</span>
		<span class="hl kwd">H5MM_xfree</span><span class="hl opt">(</span>H5G_type_g<span class="hl opt">[</span>i<span class="hl opt">].</span>desc<span class="hl opt">);</span>
	    H5G_ntypes_g <span class="hl opt">=</span> H5G_atypes_g <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	    H5G_type_g <span class="hl opt">=</span> <span class="hl kwd">H5MM_xfree</span><span class="hl opt">(</span>H5G_type_g<span class="hl opt">);</span>

	    <span class="hl com">/* Destroy the group object id group */</span>
	    <span class="hl kwd">H5I_dec_type_ref</span><span class="hl opt">(</span>H5I_GROUP<span class="hl opt">);</span>

            <span class="hl com">/* Free the global component buffer */</span>
            H5G_comp_g <span class="hl opt">=</span> <span class="hl kwd">H5MM_xfree</span><span class="hl opt">(</span>H5G_comp_g<span class="hl opt">);</span>
            H5G_comp_alloc_g <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>

	    <span class="hl com">/* Mark closed */</span>
	    H5_interface_initialize_g <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
	    n <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span> <span class="hl com">/*H5I*/</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>

    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>n<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_register_type</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Register a new object type so H5G_get_type() can detect it.</span>
<span class="hl com"> *		One should always register a general type before a more</span>
<span class="hl com"> *		specific type.  For instance, any object that has a datatype</span>
<span class="hl com"> *		message is a datatype, but only some of those objects are</span>
<span class="hl com"> *		datasets.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	Non-negative</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	Negative</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Wednesday, November  4, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> herr_t
<span class="hl kwd">H5G_register_type</span><span class="hl opt">(</span>H5G_obj_t type<span class="hl opt">,</span> <span class="hl kwd">htri_t</span><span class="hl opt">(*</span>isa<span class="hl opt">)(</span>H5G_entry_t<span class="hl opt">*,</span> hid_t<span class="hl opt">),</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>_desc<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">char</span>	<span class="hl opt">*</span>desc <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl kwb">size_t</span>	i<span class="hl opt">;</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT</span><span class="hl opt">(</span>H5G_register_type<span class="hl opt">);</span>

    <span class="hl kwa">assert</span><span class="hl opt">(</span>type<span class="hl opt">&gt;=</span><span class="hl num">0</span><span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>isa<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>_desc<span class="hl opt">);</span>

    <span class="hl com">/* Copy the description */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>desc<span class="hl opt">=</span><span class="hl kwd">H5MM_strdup</span><span class="hl opt">(</span>_desc<span class="hl opt">)))</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_RESOURCE<span class="hl opt">,</span> H5E_NOSPACE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;memory allocation failed for object type description&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * If the type is already registered then just update its entry without</span>
<span class="hl com">     * moving it to the end</span>
<span class="hl com">     */</span>
    <span class="hl kwa">for</span> <span class="hl opt">(</span>i<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">;</span> i<span class="hl opt">&lt;</span>H5G_ntypes_g<span class="hl opt">;</span> i<span class="hl opt">++) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>H5G_type_g<span class="hl opt">[</span>i<span class="hl opt">].</span>type<span class="hl opt">==</span>type<span class="hl opt">) {</span>
	    H5G_type_g<span class="hl opt">[</span>i<span class="hl opt">].</span>isa <span class="hl opt">=</span> isa<span class="hl opt">;</span>
	    <span class="hl kwd">H5MM_xfree</span><span class="hl opt">(</span>H5G_type_g<span class="hl opt">[</span>i<span class="hl opt">].</span>desc<span class="hl opt">);</span>
	    H5G_type_g<span class="hl opt">[</span>i<span class="hl opt">].</span>desc <span class="hl opt">=</span> desc<span class="hl opt">;</span>
            <span class="hl kwd">HGOTO_DONE</span><span class="hl opt">(</span>SUCCEED<span class="hl opt">);</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>

    <span class="hl com">/* Increase table size */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>H5G_ntypes_g<span class="hl opt">&gt;=</span>H5G_atypes_g<span class="hl opt">) {</span>
	<span class="hl kwb">size_t</span> n <span class="hl opt">=</span> <span class="hl kwd">MAX</span><span class="hl opt">(</span><span class="hl num">32</span><span class="hl opt">,</span> <span class="hl num">2</span><span class="hl opt">*</span>H5G_atypes_g<span class="hl opt">);</span>
	H5G_typeinfo_t <span class="hl opt">*</span>x <span class="hl opt">=</span> <span class="hl kwd">H5MM_realloc</span><span class="hl opt">(</span>H5G_type_g<span class="hl opt">,</span>
					 n<span class="hl opt">*</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span>H5G_typeinfo_t<span class="hl opt">));</span>
	<span class="hl kwa">if</span> <span class="hl opt">(!</span>x<span class="hl opt">)</span>
	    <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_RESOURCE<span class="hl opt">,</span> H5E_NOSPACE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;memory allocation failed for objec type table&quot;</span><span class="hl opt">);</span>
	H5G_atypes_g <span class="hl opt">=</span> n<span class="hl opt">;</span>
	H5G_type_g <span class="hl opt">=</span> x<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/* Add a new entry */</span>
    H5G_type_g<span class="hl opt">[</span>H5G_ntypes_g<span class="hl opt">].</span>type <span class="hl opt">=</span> type<span class="hl opt">;</span>
    H5G_type_g<span class="hl opt">[</span>H5G_ntypes_g<span class="hl opt">].</span>isa <span class="hl opt">=</span> isa<span class="hl opt">;</span>
    H5G_type_g<span class="hl opt">[</span>H5G_ntypes_g<span class="hl opt">].</span>desc <span class="hl opt">=</span> desc<span class="hl opt">;</span> <span class="hl com">/*already copied*/</span>
    H5G_ntypes_g<span class="hl opt">++;</span>

done<span class="hl opt">:</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>ret_value<span class="hl opt">&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwd">H5MM_xfree</span><span class="hl opt">(</span>desc<span class="hl opt">);</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_component</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Returns the pointer to the first component of the</span>
<span class="hl com"> *		specified name by skipping leading slashes.  Returns</span>
<span class="hl com"> *		the size in characters of the component through SIZE_P not</span>
<span class="hl com"> *		counting leading slashes or the null terminator.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Errors:</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	Ptr into NAME.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	Ptr to the null terminator of NAME.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *		matzke&#64;llnl.gov</span>
<span class="hl com"> *		Aug 11 1997</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static const char</span> <span class="hl opt">*</span>
<span class="hl kwd">H5G_component</span><span class="hl opt">(</span><span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> <span class="hl kwb">size_t</span> <span class="hl opt">*</span>size_p<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl com">/* Use FUNC_ENTER_NOAPI_NOINIT_NOFUNC here to avoid performance issues */</span>
    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT_NOFUNC</span><span class="hl opt">(</span>H5G_component<span class="hl opt">);</span>

    <span class="hl kwa">assert</span><span class="hl opt">(</span>name<span class="hl opt">);</span>

    <span class="hl kwa">while</span> <span class="hl opt">(</span><span class="hl str">'/'</span> <span class="hl opt">== *</span>name<span class="hl opt">)</span>
        name<span class="hl opt">++;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>size_p<span class="hl opt">)</span>
        <span class="hl opt">*</span>size_p <span class="hl opt">=</span> <span class="hl kwd">HDstrcspn</span><span class="hl opt">(</span>name<span class="hl opt">,</span> <span class="hl str">&quot;/&quot;</span><span class="hl opt">);</span>

    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>name<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_basename</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Returns a pointer to the last component of the specified</span>
<span class="hl com"> *		name. The length of the component is returned through SIZE_P.</span>
<span class="hl com"> *		The base name is followed by zero or more slashes and a null</span>
<span class="hl com"> *		terminator, but SIZE_P does not count the slashes or the null</span>
<span class="hl com"> *		terminator.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Note:	The base name of the root directory is a single slash.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	Ptr to base name.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	Ptr to the null terminator.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Thursday, September 17, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static const char</span> <span class="hl opt">*</span>
<span class="hl kwd">H5G_basename</span><span class="hl opt">(</span><span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> <span class="hl kwb">size_t</span> <span class="hl opt">*</span>size_p<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">size_t</span>	i<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT_NOFUNC</span><span class="hl opt">(</span>H5G_basename<span class="hl opt">);</span>

    <span class="hl com">/* Find the end of the base name */</span>
    i <span class="hl opt">=</span> <span class="hl kwd">HDstrlen</span><span class="hl opt">(</span>name<span class="hl opt">);</span>
    <span class="hl kwa">while</span> <span class="hl opt">(</span>i<span class="hl opt">&gt;</span><span class="hl num">0</span> <span class="hl opt">&amp;&amp;</span> <span class="hl str">'/'</span><span class="hl opt">==</span>name<span class="hl opt">[</span>i<span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">])</span>
        <span class="hl opt">--</span>i<span class="hl opt">;</span>

    <span class="hl com">/* Skip backward over base name */</span>
    <span class="hl kwa">while</span> <span class="hl opt">(</span>i<span class="hl opt">&gt;</span><span class="hl num">0</span> <span class="hl opt">&amp;&amp;</span> <span class="hl str">'/'</span><span class="hl opt">!=</span>name<span class="hl opt">[</span>i<span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">])</span>
        <span class="hl opt">--</span>i<span class="hl opt">;</span>

    <span class="hl com">/* Watch out for root special case */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl str">'/'</span><span class="hl opt">==</span>name<span class="hl opt">[</span>i<span class="hl opt">] &amp;&amp;</span> size_p<span class="hl opt">)</span>
        <span class="hl opt">*</span>size_p <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>

    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>name<span class="hl opt">+</span>i<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_normalize</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Returns a pointer to a new string which has duplicate and</span>
<span class="hl com"> *              trailing slashes removed from it.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	Ptr to normalized name.</span>
<span class="hl com"> *		Failure:	NULL</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Quincey Koziol</span>
<span class="hl com"> *              Saturday, August 16, 2003</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static char</span> <span class="hl opt">*</span>
<span class="hl kwd">H5G_normalize</span><span class="hl opt">(</span><span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">char</span> <span class="hl opt">*</span>norm<span class="hl opt">;</span>         <span class="hl com">/* Pointer to the normalized string */</span>
    <span class="hl kwb">size_t</span>	s<span class="hl opt">,</span>d<span class="hl opt">;</span>    <span class="hl com">/* Positions within the strings */</span>
    <span class="hl kwb">unsigned</span>    last_slash<span class="hl opt">;</span>     <span class="hl com">/* Flag to indicate last character was a slash */</span>
    <span class="hl kwb">char</span> <span class="hl opt">*</span>ret_value<span class="hl opt">;</span>    <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT</span><span class="hl opt">(</span>H5G_normalize<span class="hl opt">);</span>

    <span class="hl com">/* Sanity check */</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>name<span class="hl opt">);</span>

    <span class="hl com">/* Duplicate the name, to return */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>norm<span class="hl opt">=</span><span class="hl kwd">H5MM_strdup</span><span class="hl opt">(</span>name<span class="hl opt">)))</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_RESOURCE<span class="hl opt">,</span> H5E_NOSPACE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;memory allocation failed for normalized string&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Walk through the characters, omitting duplicated '/'s */</span>
    s<span class="hl opt">=</span>d<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">;</span>
    last_slash<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl kwa">while</span><span class="hl opt">(</span>name<span class="hl opt">[</span>s<span class="hl opt">]!=</span><span class="hl str">'\0'</span><span class="hl opt">) {</span>
        <span class="hl kwa">if</span><span class="hl opt">(</span>name<span class="hl opt">[</span>s<span class="hl opt">]==</span><span class="hl str">'/'</span><span class="hl opt">)</span>
            <span class="hl kwa">if</span><span class="hl opt">(</span>last_slash<span class="hl opt">)</span>
                <span class="hl opt">;</span>
            <span class="hl kwa">else</span> <span class="hl opt">{</span>
                norm<span class="hl opt">[</span>d<span class="hl opt">++]=</span>name<span class="hl opt">[</span>s<span class="hl opt">];</span>
                last_slash<span class="hl opt">=</span><span class="hl num">1</span><span class="hl opt">;</span>
            <span class="hl opt">}</span> <span class="hl com">/* end else */</span>
        <span class="hl kwa">else</span> <span class="hl opt">{</span>
            norm<span class="hl opt">[</span>d<span class="hl opt">++]=</span>name<span class="hl opt">[</span>s<span class="hl opt">];</span>
            last_slash<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">;</span>
        <span class="hl opt">}</span> <span class="hl com">/* end else */</span>
        s<span class="hl opt">++;</span>
    <span class="hl opt">}</span> <span class="hl com">/* end while */</span>

    <span class="hl com">/* Terminate normalized string */</span>
    norm<span class="hl opt">[</span>d<span class="hl opt">]=</span><span class="hl str">'\0'</span><span class="hl opt">;</span>

    <span class="hl com">/* Check for final '/' on normalized name &amp; eliminate it */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>d<span class="hl opt">&gt;</span><span class="hl num">1</span> <span class="hl opt">&amp;&amp;</span> last_slash<span class="hl opt">)</span>
        norm<span class="hl opt">[</span>d<span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">]=</span><span class="hl str">'\0'</span><span class="hl opt">;</span>

    <span class="hl com">/* Set return value */</span>
    ret_value<span class="hl opt">=</span>norm<span class="hl opt">;</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span> <span class="hl com">/* end H5G_normalize() */</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_namei</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Translates a name to a symbol table entry.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		If the specified name can be fully resolved, then this</span>
<span class="hl com"> *		function returns the symbol table entry for the named object</span>
<span class="hl com"> *		through the OBJ_ENT argument. The symbol table entry for the</span>
<span class="hl com"> *		group containing the named object is returned through the</span>
<span class="hl com"> *		GRP_ENT argument if it is non-null.  However, if the name</span>
<span class="hl com"> *		refers to the root object then the GRP_ENT will be</span>
<span class="hl com"> *		initialized with an undefined object header address.  The</span>
<span class="hl com"> *		REST argument, if present, will point to the null terminator</span>
<span class="hl com"> *		of NAME.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		If the specified name cannot be fully resolved, then OBJ_ENT</span>
<span class="hl com"> *		is initialized with the undefined object header address. The</span>
<span class="hl com"> *		REST argument will point into the NAME argument to the start</span>
<span class="hl com"> *		of the component that could not be located.  The GRP_ENT will</span>
<span class="hl com"> *		contain the entry for the symbol table that was being</span>
<span class="hl com"> *		searched at the time of the failure and will have an</span>
<span class="hl com"> *		undefined object header address if the search failed at the</span>
<span class="hl com"> *		root object. For instance, if NAME is `/foo/bar/baz' and the</span>
<span class="hl com"> *		root directory exists and contains an entry for `foo', and</span>
<span class="hl com"> *		foo is a group that contains an entry for bar, but bar is not</span>
<span class="hl com"> *		a group, then the results will be that REST points to `baz',</span>
<span class="hl com"> *		OBJ_ENT has an undefined object header address, and GRP_ENT</span>
<span class="hl com"> *		is the symbol table entry for `bar' in `/foo'.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Every file has a root group whose name is `/'.  Components of</span>
<span class="hl com"> *		a name are separated from one another by one or more slashes</span>
<span class="hl com"> *		(/).  Slashes at the end of a name are ignored.  If the name</span>
<span class="hl com"> *		begins with a slash then the search begins at the root group</span>
<span class="hl com"> *		of the file containing LOC_ENT. Otherwise it begins at</span>
<span class="hl com"> *		LOC_ENT.  The component `.' is a no-op, but `..' is not</span>
<span class="hl com"> *		understood by this function (unless it appears as an entry in</span>
<span class="hl com"> *		the symbol table).</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Symbolic links are followed automatically, but if TARGET</span>
<span class="hl com"> *		includes the H5G_TARGET_SLINK bit and the last component of</span>
<span class="hl com"> *		the name is a symbolic link then that link is not followed.</span>
<span class="hl com"> *		The *NLINKS value is decremented each time a link is followed</span>
<span class="hl com"> *		and link traversal fails if the value would become negative.</span>
<span class="hl com"> *		If NLINKS is the null pointer then a default value is used.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Mounted files are handled by calling H5F_mountpoint() after</span>
<span class="hl com"> *		each step of the translation.  If the input argument to that</span>
<span class="hl com"> *		function is a mount point then the argument shall be replaced</span>
<span class="hl com"> *		with information about the root group of the mounted file.</span>
<span class="hl com"> *		But if TARGET includes the H5G_TARGET_MOUNT bit and the last</span>
<span class="hl com"> *		component of the name is a mount point then H5F_mountpoint()</span>
<span class="hl com"> *		is not called and information about the mount point itself is</span>
<span class="hl com"> *		returned.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Errors:</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	Non-negative if name can be fully resolved.</span>
<span class="hl com"> *				See above for values of REST, GRP_ENT, and</span>
<span class="hl com"> *				OBJ_ENT.  NLINKS has been decremented for</span>
<span class="hl com"> *				each symbolic link that was followed.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	Negative if the name could not be fully</span>
<span class="hl com"> *				resolved. See above for values of REST,</span>
<span class="hl com"> *				GRP_ENT, and OBJ_ENT.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *		matzke&#64;llnl.gov</span>
<span class="hl com"> *		Aug 11 1997</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *      Robb Matzke, 2002-03-28</span>
<span class="hl com"> *      The component name buffer on the stack has been replaced by</span>
<span class="hl com"> *      a dynamically allocated buffer on the heap in order to</span>
<span class="hl com"> *      remove limitations on the length of a name component.</span>
<span class="hl com"> *      There are two reasons that the buffer pointer is global:</span>
<span class="hl com"> *        (1) We want to be able to reuse the buffer without</span>
<span class="hl com"> *            allocating and freeing it each time this function is</span>
<span class="hl com"> *            called.</span>
<span class="hl com"> *        (2) We need to be able to free it from H5G_term_interface()</span>
<span class="hl com"> *            when the library terminates.</span>
<span class="hl com"> *</span>
<span class="hl com"> *      Pedro Vicente, &lt;pvn&#64;ncsa.uiuc.edu&gt; 22 Aug 2002</span>
<span class="hl com"> *      Modified to deep copies of symbol table entries</span>
<span class="hl com"> *      Added `id to name' support.</span>
<span class="hl com"> *</span>
<span class="hl com"> *      Quincey Koziol, 2003-01-06</span>
<span class="hl com"> *      Added &quot;action&quot; and &quot;ent&quot; parameters to allow different actions when</span>
<span class="hl com"> *      working on the last component of a name.  (Specifically, this allows</span>
<span class="hl com"> *      inserting an entry into a group, instead of trying to look it up)</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> herr_t
<span class="hl kwd">H5G_namei</span><span class="hl opt">(</span><span class="hl kwb">const</span> H5G_entry_t <span class="hl opt">*</span>loc_ent<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">**</span>rest<span class="hl com">/*out*/</span><span class="hl opt">,</span>
	  H5G_entry_t <span class="hl opt">*</span>grp_ent<span class="hl com">/*out*/</span><span class="hl opt">,</span> H5G_entry_t <span class="hl opt">*</span>obj_ent<span class="hl com">/*out*/</span><span class="hl opt">,</span>
	  <span class="hl kwb">unsigned</span> target<span class="hl opt">,</span> <span class="hl kwb">int</span> <span class="hl opt">*</span>nlinks<span class="hl com">/*out*/</span><span class="hl opt">,</span> H5G_namei_act_t action<span class="hl opt">,</span>
          H5G_entry_t <span class="hl opt">*</span>ent<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_entry_t		  _grp_ent<span class="hl opt">;</span>     <span class="hl com">/*entry for current group	*/</span>
    H5G_entry_t		  _obj_ent<span class="hl opt">;</span>     <span class="hl com">/*entry found			*/</span>
    <span class="hl kwb">size_t</span>		  nchars<span class="hl opt">;</span>	<span class="hl com">/*component name length		*/</span>
    <span class="hl kwb">int</span>			  _nlinks <span class="hl opt">=</span> H5G_NLINKS<span class="hl opt">;</span>
    <span class="hl kwb">const char</span>		   <span class="hl opt">*</span>s <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl kwb">unsigned</span> null_obj<span class="hl opt">;</span>          <span class="hl com">/* Flag to indicate this function was called with obj_ent set to NULL */</span>
    <span class="hl kwb">unsigned</span> null_grp<span class="hl opt">;</span>          <span class="hl com">/* Flag to indicate this function was called with grp_ent set to NULL */</span>
    <span class="hl kwb">unsigned</span> obj_copy <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>      <span class="hl com">/* Flag to indicate that the object entry is copied */</span>
    <span class="hl kwb">unsigned</span> group_copy <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>    <span class="hl com">/* Flag to indicate that the group entry is copied */</span>
    <span class="hl kwb">unsigned</span> last_comp <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>     <span class="hl com">/* Flag to indicate that a component is the last component in the name */</span>
    <span class="hl kwb">unsigned</span> did_insert <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>    <span class="hl com">/* Flag to indicate that H5G_stab_insert was called */</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT</span><span class="hl opt">(</span>H5G_namei<span class="hl opt">);</span>

    <span class="hl com">/* Set up &quot;out&quot; parameters */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>rest<span class="hl opt">)</span>
        <span class="hl opt">*</span>rest <span class="hl opt">=</span> name<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>grp_ent<span class="hl opt">) {</span>
        grp_ent <span class="hl opt">= &amp;</span>_grp_ent<span class="hl opt">;</span>
        null_grp <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
    <span class="hl kwa">else</span>
        null_grp <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>obj_ent<span class="hl opt">) {</span>
        obj_ent <span class="hl opt">= &amp;</span>_obj_ent<span class="hl opt">;</span>
        null_obj <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
    <span class="hl kwa">else</span>
        null_obj <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>nlinks<span class="hl opt">)</span>
        nlinks <span class="hl opt">= &amp;</span>_nlinks<span class="hl opt">;</span>

    <span class="hl com">/* Check args */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>name <span class="hl opt">|| !*</span>name<span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;no name given&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>loc_ent<span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;no current working group&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Where does the searching start?  For absolute names it starts at the</span>
<span class="hl com">     * root of the file; for relative names it starts at CWG.</span>
<span class="hl com">     */</span>
    <span class="hl com">/* Check if we need to get the root group's entry */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl str">'/'</span> <span class="hl opt">== *</span>name<span class="hl opt">) {</span>
        H5G_t <span class="hl opt">*</span>tmp_grp<span class="hl opt">;</span>         <span class="hl com">/* Temporary pointer to root group of file */</span>

        tmp_grp<span class="hl opt">=</span><span class="hl kwd">H5G_rootof</span><span class="hl opt">(</span>loc_ent<span class="hl opt">-&gt;</span>file<span class="hl opt">);</span>
        <span class="hl kwa">assert</span><span class="hl opt">(</span>tmp_grp<span class="hl opt">);</span>

        <span class="hl com">/* Set the location entry to the root group's entry*/</span>
        loc_ent<span class="hl opt">=&amp;(</span>tmp_grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>

    <span class="hl com">/* Deep copy of the symbol table entry (duplicates strings) */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_ent_copy</span><span class="hl opt">(</span>obj_ent<span class="hl opt">,</span> loc_ent<span class="hl opt">,</span>H5G_COPY_DEEP<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_DATATYPE<span class="hl opt">,</span> H5E_CANTOPENOBJ<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to copy entry&quot;</span><span class="hl opt">);</span>
    obj_copy <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>

    <span class="hl kwd">H5G_ent_reset</span><span class="hl opt">(</span>grp_ent<span class="hl opt">);</span>

    <span class="hl com">/* traverse the name */</span>
    <span class="hl kwa">while</span> <span class="hl opt">((</span>name <span class="hl opt">=</span> <span class="hl kwd">H5G_component</span><span class="hl opt">(</span>name<span class="hl opt">, &amp;</span>nchars<span class="hl opt">)) &amp;&amp; *</span>name<span class="hl opt">) {</span>
        <span class="hl com">/* Update the &quot;rest of name&quot; pointer */</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>rest<span class="hl opt">)</span>
            <span class="hl opt">*</span>rest <span class="hl opt">=</span> name<span class="hl opt">;</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * Copy the component name into a null-terminated buffer so</span>
<span class="hl com">	 * we can pass it down to the other symbol table functions.</span>
<span class="hl com">	 */</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>nchars<span class="hl opt">+</span><span class="hl num">1</span> <span class="hl opt">&gt;</span> H5G_comp_alloc_g<span class="hl opt">) {</span>
            H5G_comp_alloc_g <span class="hl opt">=</span> <span class="hl kwd">MAX3</span><span class="hl opt">(</span><span class="hl num">1024</span><span class="hl opt">,</span> <span class="hl num">2</span><span class="hl opt">*</span>H5G_comp_alloc_g<span class="hl opt">,</span> nchars<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">);</span>
            H5G_comp_g <span class="hl opt">=</span> <span class="hl kwd">H5MM_realloc</span><span class="hl opt">(</span>H5G_comp_g<span class="hl opt">,</span> H5G_comp_alloc_g<span class="hl opt">);</span>
            <span class="hl kwa">if</span> <span class="hl opt">(!</span>H5G_comp_g<span class="hl opt">) {</span>
                H5G_comp_alloc_g <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
                <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOSPACE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to allocate component buffer&quot;</span><span class="hl opt">);</span>
            <span class="hl opt">}</span>
        <span class="hl opt">}</span>
	<span class="hl kwd">HDmemcpy</span><span class="hl opt">(</span>H5G_comp_g<span class="hl opt">,</span> name<span class="hl opt">,</span> nchars<span class="hl opt">);</span>
	H5G_comp_g<span class="hl opt">[</span>nchars<span class="hl opt">] =</span> <span class="hl str">'\0'</span><span class="hl opt">;</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * The special name `.' is a no-op.</span>
<span class="hl com">	 */</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl str">'.'</span> <span class="hl opt">==</span> H5G_comp_g<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] &amp;&amp; !</span>H5G_comp_g<span class="hl opt">[</span><span class="hl num">1</span><span class="hl opt">]) {</span>
	    name <span class="hl opt">+=</span> nchars<span class="hl opt">;</span>
	    <span class="hl kwa">continue</span><span class="hl opt">;</span>
	<span class="hl opt">}</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * Advance to the next component of the name.</span>
<span class="hl com">	 */</span>
        <span class="hl com">/* If we've already copied a new entry into the group entry,</span>
<span class="hl com">         * it needs to be freed before overwriting it with another entry</span>
<span class="hl com">         */</span>
	<span class="hl kwa">if</span><span class="hl opt">(</span>group_copy<span class="hl opt">)</span>
            <span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(</span>grp_ent<span class="hl opt">);</span>

        <span class="hl com">/* Transfer &quot;ownership&quot; of the entry's information to the group entry */</span>
        <span class="hl kwd">H5G_ent_copy</span><span class="hl opt">(</span>grp_ent<span class="hl opt">,</span>obj_ent<span class="hl opt">,</span>H5G_COPY_SHALLOW<span class="hl opt">);</span>
        <span class="hl kwd">H5G_ent_reset</span><span class="hl opt">(</span>obj_ent<span class="hl opt">);</span>

	<span class="hl com">/* Set flag that we've copied a new entry into the group entry */</span>
	group_copy <span class="hl opt">=</span><span class="hl num">1</span><span class="hl opt">;</span>

        <span class="hl com">/* Check if this is the last component of the name */</span>
        <span class="hl kwa">if</span><span class="hl opt">(!((</span>s<span class="hl opt">=</span><span class="hl kwd">H5G_component</span><span class="hl opt">(</span>name<span class="hl opt">+</span>nchars<span class="hl opt">,</span> NULL<span class="hl opt">)) &amp;&amp; *</span>s<span class="hl opt">))</span>
            last_comp<span class="hl opt">=</span><span class="hl num">1</span><span class="hl opt">;</span>

        <span class="hl kwa">switch</span><span class="hl opt">(</span>action<span class="hl opt">) {</span>
            <span class="hl kwa">case</span> H5G_NAMEI_TRAVERSE<span class="hl opt">:</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_stab_find</span><span class="hl opt">(</span>grp_ent<span class="hl opt">,</span> H5G_comp_g<span class="hl opt">,</span> obj_ent<span class="hl com">/*out*/</span><span class="hl opt">,</span> dxpl_id <span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">) {</span>
                    <span class="hl com">/*</span>
<span class="hl com">                     * Component was not found in the current symbol table, possibly</span>
<span class="hl com">                     * because GRP_ENT isn't a symbol table.</span>
<span class="hl com">                     */</span>
                    <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;component not found&quot;</span><span class="hl opt">);</span>
                <span class="hl opt">}</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>

            <span class="hl kwa">case</span> H5G_NAMEI_INSERT<span class="hl opt">:</span>
                <span class="hl kwa">if</span><span class="hl opt">(!</span>last_comp<span class="hl opt">) {</span>
                    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_stab_find</span><span class="hl opt">(</span>grp_ent<span class="hl opt">,</span> H5G_comp_g<span class="hl opt">,</span> obj_ent<span class="hl com">/*out*/</span><span class="hl opt">,</span> dxpl_id <span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">) {</span>
                        <span class="hl com">/* If an intermediate group doesn't exist &amp; flag is set, create the group */</span>
                        <span class="hl kwa">if</span> <span class="hl opt">(</span>target <span class="hl opt">&amp;</span> H5G_CRT_INTMD_GROUP<span class="hl opt">) {</span>
                            H5G_entry_t new_ent<span class="hl opt">;</span>

                            <span class="hl com">/* Reset group entry */</span>
                            <span class="hl kwd">H5G_ent_reset</span><span class="hl opt">(&amp;</span>new_ent<span class="hl opt">);</span>

                            <span class="hl com">/* Create the intermediate group */</span>
                            <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_stab_create</span><span class="hl opt">(</span>grp_ent<span class="hl opt">-&gt;</span>file<span class="hl opt">,</span> dxpl_id<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">, &amp;</span>new_ent<span class="hl com">/*out*/</span><span class="hl opt">) &lt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
                                <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;can't create grp&quot;</span><span class="hl opt">);</span>

                            <span class="hl com">/* Insert new group into current group's symbol table */</span>
                            <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_stab_insert</span><span class="hl opt">(</span>grp_ent<span class="hl opt">,</span> H5G_comp_g<span class="hl opt">, &amp;</span>new_ent<span class="hl opt">,</span> TRUE<span class="hl opt">,</span> dxpl_id<span class="hl opt">))</span>
                                <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINSERT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to insert intermediate group&quot;</span><span class="hl opt">);</span>

                            <span class="hl com">/* Keep newly created group's entry, so we can traverse into it */</span>
                            <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_ent_copy</span><span class="hl opt">(</span>obj_ent<span class="hl opt">, &amp;</span>new_ent<span class="hl opt">,</span> H5G_COPY_DEEP<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
                                <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_DATATYPE<span class="hl opt">,</span> H5E_CANTOPENOBJ<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to copy entry&quot;</span><span class="hl opt">);</span>

                            <span class="hl com">/* Close new group */</span>
                            <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5O_close</span><span class="hl opt">(&amp;</span>new_ent<span class="hl opt">) &lt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
                                <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to close&quot;</span><span class="hl opt">);</span>
                        <span class="hl opt">}</span>
                        <span class="hl kwa">else</span>
                            <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;component not found&quot;</span><span class="hl opt">);</span>
                    <span class="hl opt">}</span>
                <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
                <span class="hl kwa">else</span> <span class="hl opt">{</span>
                    did_insert <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
                    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_stab_insert</span><span class="hl opt">(</span>grp_ent<span class="hl opt">,</span> H5G_comp_g<span class="hl opt">,</span> ent<span class="hl opt">,</span> TRUE<span class="hl opt">,</span> dxpl_id<span class="hl opt">) &lt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
                        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINSERT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to insert name&quot;</span><span class="hl opt">);</span>
                    <span class="hl kwd">HGOTO_DONE</span><span class="hl opt">(</span>SUCCEED<span class="hl opt">);</span>
                <span class="hl opt">}</span> <span class="hl com">/* end else */</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
        <span class="hl opt">}</span> <span class="hl com">/* end switch */</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * If we found a symbolic link then we should follow it.  But if this</span>
<span class="hl com">	 * is the last component of the name and the H5G_TARGET_SLINK bit of</span>
<span class="hl com">	 * TARGET is set then we don't follow it.</span>
<span class="hl com">	 */</span>
	<span class="hl kwa">if</span><span class="hl opt">(</span>H5G_CACHED_SLINK<span class="hl opt">==</span>obj_ent<span class="hl opt">-&gt;</span>type <span class="hl opt">&amp;&amp;</span>
                <span class="hl opt">(</span><span class="hl num">0</span><span class="hl opt">==(</span>target <span class="hl opt">&amp;</span> H5G_TARGET_SLINK<span class="hl opt">) || !</span>last_comp<span class="hl opt">)) {</span>
	    <span class="hl kwa">if</span> <span class="hl opt">((*</span>nlinks<span class="hl opt">)-- &lt;=</span> <span class="hl num">0</span><span class="hl opt">)</span>
		<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_SLINK<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;too many links&quot;</span><span class="hl opt">);</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_traverse_slink</span> <span class="hl opt">(</span>grp_ent<span class="hl opt">,</span> obj_ent<span class="hl opt">,</span> nlinks<span class="hl opt">,</span> dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
		<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;symbolic link traversal failed&quot;</span><span class="hl opt">);</span>
	<span class="hl opt">}</span>

	<span class="hl com">/*</span>
<span class="hl com">	 * Resolve mount points to the mounted group.  Do not do this step if</span>
<span class="hl com">	 * the H5G_TARGET_MOUNT bit of TARGET is set and this is the last</span>
<span class="hl com">	 * component of the name.</span>
<span class="hl com">	 */</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl num">0</span><span class="hl opt">==(</span>target <span class="hl opt">&amp;</span> H5G_TARGET_MOUNT<span class="hl opt">) || !</span>last_comp<span class="hl opt">)</span>
	    <span class="hl kwd">H5F_mountpoint</span><span class="hl opt">(</span>obj_ent<span class="hl com">/*in,out*/</span><span class="hl opt">);</span>

	<span class="hl com">/* next component */</span>
	name <span class="hl opt">+=</span> nchars<span class="hl opt">;</span>
    <span class="hl opt">}</span> <span class="hl com">/* end while */</span>

    <span class="hl com">/* Update the &quot;rest of name&quot; pointer */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>rest<span class="hl opt">)</span>
        <span class="hl opt">*</span>rest <span class="hl opt">=</span> name<span class="hl opt">;</span> <span class="hl com">/*final null */</span>

    <span class="hl com">/* If this was an insert, make sure that the insert function was actually</span>
<span class="hl com">     * called (this catches no-op names like &quot;.&quot; and &quot;/&quot;) */</span>
     <span class="hl kwa">if</span><span class="hl opt">(</span>action <span class="hl opt">==</span> H5G_NAMEI_INSERT <span class="hl opt">&amp;&amp; !</span>did_insert<span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;group already exists&quot;</span><span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl com">/* If we started with a NULL obj_ent, free the entry information */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>null_obj <span class="hl opt">|| (</span>ret_value <span class="hl opt">&lt;</span> <span class="hl num">0</span> <span class="hl opt">&amp;&amp;</span> obj_copy<span class="hl opt">))</span>
        <span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(</span>obj_ent<span class="hl opt">);</span>
    <span class="hl com">/* If we started with a NULL grp_ent and we copied something into it, free the entry information */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>null_grp <span class="hl opt">&amp;&amp;</span> group_copy<span class="hl opt">)</span>
        <span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(</span>grp_ent<span class="hl opt">);</span>

   <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_traverse_slink</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Traverses symbolic link.  The link head appears in the group</span>
<span class="hl com"> *		whose entry is GRP_ENT and the link head entry is OBJ_ENT.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	Non-negative, OBJ_ENT will contain information</span>
<span class="hl com"> *				about the object to which the link points and</span>
<span class="hl com"> *				GRP_ENT will contain the information about</span>
<span class="hl com"> *				the group in which the link tail appears.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	Negative</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Friday, April 10, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *      Pedro Vicente, &lt;pvn&#64;ncsa.uiuc.edu&gt; 22 Aug 2002</span>
<span class="hl com"> *      Added `id to name' support.</span>
<span class="hl com"> *</span>
<span class="hl com"> *	John Mainzer - 6/8/05</span>
<span class="hl com"> *      Modified function to use the new dirtied parmeter of</span>
<span class="hl com"> *      H5AC_unprotect(), which allows management of the is_dirty</span>
<span class="hl com"> *      field of the cache info to be moved into the cache code.</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> herr_t
<span class="hl kwd">H5G_traverse_slink</span> <span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>grp_ent<span class="hl com">/*in,out*/</span><span class="hl opt">,</span>
		    H5G_entry_t <span class="hl opt">*</span>obj_ent<span class="hl com">/*in,out*/</span><span class="hl opt">,</span>
		    <span class="hl kwb">int</span> <span class="hl opt">*</span>nlinks<span class="hl com">/*in,out*/</span><span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5O_stab_t		stab_mesg<span class="hl opt">;</span>		<span class="hl com">/*info about local heap	*/</span>
    <span class="hl kwb">const char</span>		<span class="hl opt">*</span>clv <span class="hl opt">=</span> NULL<span class="hl opt">;</span>		<span class="hl com">/*cached link value	*/</span>
    <span class="hl kwb">char</span>		<span class="hl opt">*</span>linkval <span class="hl opt">=</span> NULL<span class="hl opt">;</span>	<span class="hl com">/*the copied link value	*/</span>
    H5G_entry_t         tmp_grp_ent<span class="hl opt">;</span>            <span class="hl com">/* Temporary copy of group entry */</span>
    H5RS_str_t          <span class="hl opt">*</span>tmp_user_path_r<span class="hl opt">=</span>NULL<span class="hl opt">, *</span>tmp_canon_path_r<span class="hl opt">=</span>NULL<span class="hl opt">;</span> <span class="hl com">/* Temporary pointer to object's user path &amp; canonical path */</span>
    <span class="hl kwb">const</span> H5HL_t        <span class="hl opt">*</span>heap<span class="hl opt">;</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT</span><span class="hl opt">(</span>H5G_traverse_slink<span class="hl opt">);</span>

    <span class="hl com">/* Portably initialize the temporary group entry */</span>
    <span class="hl kwd">H5G_ent_reset</span><span class="hl opt">(&amp;</span>tmp_grp_ent<span class="hl opt">);</span>

    <span class="hl com">/* Get the link value */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==</span><span class="hl kwd">H5O_read</span> <span class="hl opt">(</span>grp_ent<span class="hl opt">,</span> H5O_STAB_ID<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">, &amp;</span>stab_mesg<span class="hl opt">,</span> dxpl_id<span class="hl opt">))</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to determine local heap address&quot;</span><span class="hl opt">);</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL <span class="hl opt">== (</span>heap <span class="hl opt">=</span> <span class="hl kwd">H5HL_protect</span><span class="hl opt">(</span>grp_ent<span class="hl opt">-&gt;</span>file<span class="hl opt">,</span> dxpl_id<span class="hl opt">,</span> stab_mesg<span class="hl opt">.</span>heap_addr<span class="hl opt">)))</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to read protect link value&quot;</span><span class="hl opt">)</span>

    clv <span class="hl opt">=</span> <span class="hl kwd">H5HL_offset_into</span><span class="hl opt">(</span>grp_ent<span class="hl opt">-&gt;</span>file<span class="hl opt">,</span> heap<span class="hl opt">,</span> obj_ent<span class="hl opt">-&gt;</span>cache<span class="hl opt">.</span>slink<span class="hl opt">.</span>lval_offset<span class="hl opt">);</span>

    linkval <span class="hl opt">=</span> <span class="hl kwd">H5MM_xstrdup</span> <span class="hl opt">(</span>clv<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>linkval<span class="hl opt">);</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5HL_unprotect</span><span class="hl opt">(</span>grp_ent<span class="hl opt">-&gt;</span>file<span class="hl opt">,</span> dxpl_id<span class="hl opt">,</span> heap<span class="hl opt">,</span> stab_mesg<span class="hl opt">.</span>heap_addr<span class="hl opt">,</span> H5AC__NO_FLAGS_SET<span class="hl opt">) &lt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to read unprotect link value&quot;</span><span class="hl opt">)</span>

    <span class="hl com">/* Hold the entry's name (&amp; old_name) to restore later */</span>
    tmp_user_path_r<span class="hl opt">=</span>obj_ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">;</span>
    obj_ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">=</span>NULL<span class="hl opt">;</span>
    tmp_canon_path_r<span class="hl opt">=</span>obj_ent<span class="hl opt">-&gt;</span>canon_path_r<span class="hl opt">;</span>
    obj_ent<span class="hl opt">-&gt;</span>canon_path_r<span class="hl opt">=</span>NULL<span class="hl opt">;</span>

    <span class="hl com">/* Free the names for the group entry */</span>
    <span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(</span>grp_ent<span class="hl opt">);</span>

    <span class="hl com">/* Clone the group entry, so we can track the names properly */</span>
    <span class="hl kwd">H5G_ent_copy</span><span class="hl opt">(&amp;</span>tmp_grp_ent<span class="hl opt">,</span>grp_ent<span class="hl opt">,</span>H5G_COPY_DEEP<span class="hl opt">);</span>

    <span class="hl com">/* Traverse the link */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_namei</span> <span class="hl opt">(&amp;</span>tmp_grp_ent<span class="hl opt">,</span> linkval<span class="hl opt">,</span> NULL<span class="hl opt">,</span> grp_ent<span class="hl opt">,</span> obj_ent<span class="hl opt">,</span> H5G_TARGET_NORMAL<span class="hl opt">,</span> nlinks<span class="hl opt">,</span> H5G_NAMEI_TRAVERSE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> dxpl_id<span class="hl opt">))</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to follow symbolic link&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Free the entry's names, we will use the original name for the object */</span>
    <span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(</span>obj_ent<span class="hl opt">);</span>

    <span class="hl com">/* Restore previous name for object */</span>
    obj_ent<span class="hl opt">-&gt;</span>user_path_r <span class="hl opt">=</span> tmp_user_path_r<span class="hl opt">;</span>
    tmp_user_path_r<span class="hl opt">=</span>NULL<span class="hl opt">;</span>
    obj_ent<span class="hl opt">-&gt;</span>canon_path_r <span class="hl opt">=</span> tmp_canon_path_r<span class="hl opt">;</span>
    tmp_canon_path_r<span class="hl opt">=</span>NULL<span class="hl opt">;</span>

done<span class="hl opt">:</span>
    <span class="hl com">/* Error cleanup */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>tmp_user_path_r<span class="hl opt">)</span>
        <span class="hl kwd">H5RS_decr</span><span class="hl opt">(</span>tmp_user_path_r<span class="hl opt">);</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>tmp_canon_path_r<span class="hl opt">)</span>
        <span class="hl kwd">H5RS_decr</span><span class="hl opt">(</span>tmp_canon_path_r<span class="hl opt">);</span>

    <span class="hl com">/* Release cloned copy of group entry */</span>
    <span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(&amp;</span>tmp_grp_ent<span class="hl opt">);</span>

    <span class="hl kwd">H5MM_xfree</span> <span class="hl opt">(</span>linkval<span class="hl opt">);</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_mkroot</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Creates a root group in an empty file and opens it.  If a</span>
<span class="hl com"> *		root group is already open then this function immediately</span>
<span class="hl com"> *		returns.   If ENT is non-null then it's the symbol table</span>
<span class="hl com"> *		entry for an existing group which will be opened as the root</span>
<span class="hl com"> *		group.  Otherwise a new root group is created and then</span>
<span class="hl com"> *		opened.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Non-negative on success/Negative on failure</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *		matzke&#64;llnl.gov</span>
<span class="hl com"> *		Aug 11 1997</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *      Pedro Vicente, &lt;pvn&#64;ncsa.uiuc.edu&gt; 22 Aug 2002</span>
<span class="hl com"> *      Added `id to name' support.</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
herr_t
<span class="hl kwd">H5G_mkroot</span> <span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> H5G_entry_t <span class="hl opt">*</span>ent<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_entry_t	new_root<span class="hl opt">;</span>		<span class="hl com">/*new root object		*/</span>
    H5O_stab_t	stab<span class="hl opt">;</span>			<span class="hl com">/*symbol table message		*/</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI</span><span class="hl opt">(</span>H5G_mkroot<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>

    <span class="hl com">/* check args */</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>f<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>f<span class="hl opt">-&gt;</span>shared<span class="hl opt">-&gt;</span>root_grp<span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_DONE</span><span class="hl opt">(</span>SUCCEED<span class="hl opt">);</span>

    <span class="hl com">/* Create information needed for group nodes */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5G_node_init</span><span class="hl opt">(</span>f<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to create group node info&quot;</span><span class="hl opt">)</span>

    <span class="hl com">/*</span>
<span class="hl com">     * If there is no root object then create one. The root group always has</span>
<span class="hl com">     * a hard link count of one since it's pointed to by the boot block.</span>
<span class="hl com">     */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>ent<span class="hl opt">) {</span>
	ent <span class="hl opt">= &amp;</span>new_root<span class="hl opt">;</span>
        <span class="hl kwd">H5G_ent_reset</span><span class="hl opt">(</span>ent<span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_stab_create</span> <span class="hl opt">(</span>f<span class="hl opt">,</span> dxpl_id<span class="hl opt">, (</span><span class="hl kwb">size_t</span><span class="hl opt">)</span>H5G_SIZE_HINT<span class="hl opt">,</span> ent<span class="hl com">/*out*/</span><span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	    <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to create root group&quot;</span><span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl num">1</span> <span class="hl opt">!=</span> <span class="hl kwd">H5O_link</span> <span class="hl opt">(</span>ent<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">,</span> dxpl_id<span class="hl opt">))</span>
	    <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_LINK<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;internal error (wrong link count)&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	<span class="hl com">/*</span>
<span class="hl com">	 * Open the root object as a group.</span>
<span class="hl com">	 */</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5O_open</span> <span class="hl opt">(</span>ent<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	    <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTOPENOBJ<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to open root group&quot;</span><span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==</span><span class="hl kwd">H5O_read</span> <span class="hl opt">(</span>ent<span class="hl opt">,</span> H5O_STAB_ID<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">, &amp;</span>stab<span class="hl opt">,</span> dxpl_id<span class="hl opt">)) {</span>
	    <span class="hl kwd">H5O_close</span><span class="hl opt">(</span>ent<span class="hl opt">);</span>
	    <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;root object is not a group&quot;</span><span class="hl opt">);</span>
	<span class="hl opt">}</span>
	<span class="hl kwd">H5O_reset</span> <span class="hl opt">(</span>H5O_STAB_ID<span class="hl opt">, &amp;</span>stab<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/* Create the path names for the root group's entry */</span>
    ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">=</span><span class="hl kwd">H5RS_create</span><span class="hl opt">(</span><span class="hl str">&quot;/&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">);</span>
    ent<span class="hl opt">-&gt;</span>canon_path_r<span class="hl opt">=</span><span class="hl kwd">H5RS_create</span><span class="hl opt">(</span><span class="hl str">&quot;/&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>canon_path_r<span class="hl opt">);</span>
    ent<span class="hl opt">-&gt;</span>user_path_hidden<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">;</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Create the group pointer.  Also decrement the open object count so we</span>
<span class="hl com">     * don't count the root group as an open object.  The root group will</span>
<span class="hl com">     * never be closed.</span>
<span class="hl com">     */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>f<span class="hl opt">-&gt;</span>shared<span class="hl opt">-&gt;</span>root_grp <span class="hl opt">=</span> <span class="hl kwd">H5FL_CALLOC</span> <span class="hl opt">(</span>H5G_t<span class="hl opt">)))</span>
        <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_RESOURCE<span class="hl opt">,</span> H5E_NOSPACE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;memory allocation failed&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>f<span class="hl opt">-&gt;</span>shared<span class="hl opt">-&gt;</span>root_grp<span class="hl opt">-&gt;</span>shared <span class="hl opt">=</span> <span class="hl kwd">H5FL_CALLOC</span> <span class="hl opt">(</span>H5G_shared_t<span class="hl opt">))) {</span>
        <span class="hl kwd">H5FL_FREE</span><span class="hl opt">(</span>H5G_t<span class="hl opt">,</span> f<span class="hl opt">-&gt;</span>shared<span class="hl opt">-&gt;</span>root_grp<span class="hl opt">);</span>
        <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_RESOURCE<span class="hl opt">,</span> H5E_NOSPACE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;memory allocation failed&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>
    f<span class="hl opt">-&gt;</span>shared<span class="hl opt">-&gt;</span>root_grp<span class="hl opt">-&gt;</span>ent <span class="hl opt">= *</span>ent<span class="hl opt">;</span>
    f<span class="hl opt">-&gt;</span>shared<span class="hl opt">-&gt;</span>root_grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">-&gt;</span>fo_count <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
    <span class="hl kwa">assert</span> <span class="hl opt">(</span><span class="hl num">1</span><span class="hl opt">==</span>f<span class="hl opt">-&gt;</span>nopen_objs<span class="hl opt">);</span>
    f<span class="hl opt">-&gt;</span>nopen_objs <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_create</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Creates a new empty group with the specified name. The name</span>
<span class="hl com"> *		is either an absolute name or is relative to LOC.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Errors:</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	A handle for the group.	 The group is opened</span>
<span class="hl com"> *				and should eventually be close by calling</span>
<span class="hl com"> *				H5G_close().</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	NULL</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *		matzke&#64;llnl.gov</span>
<span class="hl com"> *		Aug 11 1997</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *      Pedro Vicente, &lt;pvn&#64;ncsa.uiuc.edu&gt; 18 Sep 2002</span>
<span class="hl com"> *      Added `id to name' support.</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> H5G_t <span class="hl opt">*</span>
<span class="hl kwd">H5G_create</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>loc<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> <span class="hl kwb">size_t</span> size_hint<span class="hl opt">,</span>
                  hid_t dxpl_id<span class="hl opt">,</span> hid_t gcpl_id<span class="hl opt">,</span> hid_t UNUSED gapl_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_t	<span class="hl opt">*</span>grp <span class="hl opt">=</span> NULL<span class="hl opt">;</span>	<span class="hl com">/*new group			*/</span>
    H5F_t       <span class="hl opt">*</span>file <span class="hl opt">=</span> NULL<span class="hl opt">;</span>   <span class="hl com">/* File new group will be in    */</span>
    H5P_genplist_t  <span class="hl opt">*</span>gc_plist<span class="hl opt">;</span>  <span class="hl com">/* Property list created */</span>
    <span class="hl kwb">unsigned</span>    stab_init<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">;</span>    <span class="hl com">/* Flag to indicate that the symbol table was created successfully */</span>
    H5G_t	<span class="hl opt">*</span>ret_value<span class="hl opt">;</span>	<span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT</span><span class="hl opt">(</span>H5G_create<span class="hl opt">);</span>

    <span class="hl com">/* check args */</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>loc<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>name <span class="hl opt">&amp;&amp; *</span>name<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>gcpl_id <span class="hl opt">!=</span> H5P_DEFAULT<span class="hl opt">);</span>
<span class="hl ppc">#ifdef LATER</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>gapl_id <span class="hl opt">!=</span> H5P_DEFAULT<span class="hl opt">);</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* LATER */</span><span class="hl ppc"></span>

    <span class="hl com">/* create an open group */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>grp <span class="hl opt">=</span> <span class="hl kwd">H5FL_CALLOC</span><span class="hl opt">(</span>H5G_t<span class="hl opt">)))</span>
        <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_RESOURCE<span class="hl opt">,</span> H5E_NOSPACE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;memory allocation failed&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>grp<span class="hl opt">-&gt;</span>shared <span class="hl opt">=</span> <span class="hl kwd">H5FL_CALLOC</span><span class="hl opt">(</span>H5G_t<span class="hl opt">)))</span>
        <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_RESOURCE<span class="hl opt">,</span> H5E_NOSPACE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;memory allocation failed&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* What file is the group being added to? */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>file<span class="hl opt">=</span><span class="hl kwd">H5G_insertion_file</span><span class="hl opt">(</span>loc<span class="hl opt">,</span> name<span class="hl opt">,</span> dxpl_id<span class="hl opt">)))</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;unable to locate insertion point&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Create the group entry */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_stab_create</span><span class="hl opt">(</span>file<span class="hl opt">,</span> dxpl_id<span class="hl opt">,</span> size_hint<span class="hl opt">, &amp;(</span>grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">)</span><span class="hl com">/*out*/</span><span class="hl opt">) &lt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;can't create grp&quot;</span><span class="hl opt">);</span>
    stab_init<span class="hl opt">=</span><span class="hl num">1</span><span class="hl opt">;</span>    <span class="hl com">/* Indicate that the symbol table information is valid */</span>

    <span class="hl com">/* Get the property list */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL <span class="hl opt">== (</span>gc_plist <span class="hl opt">=</span> <span class="hl kwd">H5I_object</span><span class="hl opt">(</span>gcpl_id<span class="hl opt">)))</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;not a property list&quot;</span><span class="hl opt">)</span>

    <span class="hl com">/* insert child name into parent */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5G_insert</span><span class="hl opt">(</span>loc<span class="hl opt">,</span>name<span class="hl opt">,&amp;(</span>grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">),</span> dxpl_id<span class="hl opt">,</span> gc_plist<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINSERT<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;can't insert group&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Add group to list of open objects in file */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5FO_insert</span><span class="hl opt">(</span>grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">.</span>file<span class="hl opt">,</span> grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">.</span>header<span class="hl opt">,</span> grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINSERT<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;can't insert group into list of open objects&quot;</span><span class="hl opt">)</span>

    grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">-&gt;</span>fo_count <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>

    <span class="hl com">/* Set return value */</span>
    ret_value<span class="hl opt">=</span>grp<span class="hl opt">;</span>

done<span class="hl opt">:</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>ret_value<span class="hl opt">==</span>NULL<span class="hl opt">) {</span>
        <span class="hl com">/* Check if we need to release the file-oriented symbol table info */</span>
        <span class="hl kwa">if</span><span class="hl opt">(</span>stab_init<span class="hl opt">) {</span>
            <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5O_close</span><span class="hl opt">(&amp;(</span>grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">))&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
                <span class="hl kwd">HDONE_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CLOSEERROR<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;unable to release object header&quot;</span><span class="hl opt">);</span>
            <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5O_delete</span><span class="hl opt">(</span>file<span class="hl opt">,</span> dxpl_id<span class="hl opt">,</span>grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">.</span>header<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
                <span class="hl kwd">HDONE_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTDELETE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;unable to delete object header&quot;</span><span class="hl opt">);</span>
        <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
        <span class="hl kwa">if</span><span class="hl opt">(</span>grp<span class="hl opt">!=</span>NULL<span class="hl opt">) {</span>
            <span class="hl kwa">if</span><span class="hl opt">(</span>grp<span class="hl opt">-&gt;</span>shared <span class="hl opt">!=</span> NULL<span class="hl opt">)</span>
                <span class="hl kwd">H5FL_FREE</span><span class="hl opt">(</span>H5G_shared_t<span class="hl opt">,</span> grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">);</span>
            <span class="hl kwd">H5FL_FREE</span><span class="hl opt">(</span>H5G_t<span class="hl opt">,</span>grp<span class="hl opt">);</span>
        <span class="hl opt">}</span>
    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>

    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_isa</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Determines if an object has the requisite messages for being</span>
<span class="hl com"> *		a group.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	TRUE if the required group messages are</span>
<span class="hl com"> *				present; FALSE otherwise.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	FAIL if the existence of certain messages</span>
<span class="hl com"> *				cannot be determined.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Monday, November  2, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> htri_t
<span class="hl kwd">H5G_isa</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>ent<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    htri_t	ret_value<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT</span><span class="hl opt">(</span>H5G_isa<span class="hl opt">);</span>

    <span class="hl kwa">assert</span><span class="hl opt">(</span>ent<span class="hl opt">);</span>

    <span class="hl kwa">if</span> <span class="hl opt">((</span>ret_value<span class="hl opt">=</span><span class="hl kwd">H5O_exists</span><span class="hl opt">(</span>ent<span class="hl opt">,</span> H5O_STAB_ID<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> dxpl_id<span class="hl opt">))&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to read object header&quot;</span><span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_link_isa</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Determines if an object has the requisite form for being</span>
<span class="hl com"> *		a soft link.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	TRUE if the symbol table entry is of type</span>
<span class="hl com"> *				H5G_LINK; FALSE otherwise.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	Shouldn't fail.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Quincey Koziol</span>
<span class="hl com"> *              Wednesday, June 23, 2004</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> htri_t
<span class="hl kwd">H5G_link_isa</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>ent<span class="hl opt">,</span> hid_t UNUSED dxpl_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    htri_t	ret_value<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT_NOFUNC</span><span class="hl opt">(</span>H5G_link_isa<span class="hl opt">);</span>

    <span class="hl kwa">assert</span><span class="hl opt">(</span>ent<span class="hl opt">);</span>

    <span class="hl kwa">if</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>type <span class="hl opt">==</span> H5G_CACHED_SLINK<span class="hl opt">)</span>
        ret_value<span class="hl opt">=</span>TRUE<span class="hl opt">;</span>
    <span class="hl kwa">else</span>
        ret_value<span class="hl opt">=</span>FALSE<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span> <span class="hl com">/* end H5G_link_isa() */</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_open</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Opens an existing group.  The group should eventually be</span>
<span class="hl com"> *		closed by calling H5G_close().</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	Ptr to a new group.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	NULL</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *		Monday, January	 5, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *      Modified to call H5G_open_oid - QAK - 3/17/99</span>
<span class="hl com"> *</span>
<span class="hl com"> *      Pedro Vicente, &lt;pvn&#64;ncsa.uiuc.edu&gt; 18 Sep 2002</span>
<span class="hl com"> *      Added `id to name' support.</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
H5G_t <span class="hl opt">*</span>
<span class="hl kwd">H5G_open</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>ent<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_t           <span class="hl opt">*</span>grp <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    H5G_shared_t    <span class="hl opt">*</span>shared_fo<span class="hl opt">=</span>NULL<span class="hl opt">;</span>
    H5G_t           <span class="hl opt">*</span>ret_value<span class="hl opt">=</span>NULL<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI</span><span class="hl opt">(</span>H5G_open<span class="hl opt">,</span> NULL<span class="hl opt">);</span>

    <span class="hl com">/* Check args */</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>ent<span class="hl opt">);</span>

    <span class="hl com">/* Check if group was already open */</span>
    <span class="hl kwa">if</span><span class="hl opt">((</span>shared_fo<span class="hl opt">=</span><span class="hl kwd">H5FO_opened</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>file<span class="hl opt">,</span> ent<span class="hl opt">-&gt;</span>header<span class="hl opt">))==</span>NULL<span class="hl opt">) {</span>

        <span class="hl com">/* Clear any errors from H5FO_opened() */</span>
        <span class="hl kwd">H5E_clear_stack</span><span class="hl opt">(</span>NULL<span class="hl opt">);</span>

        <span class="hl com">/* Open the group object */</span>
        <span class="hl kwa">if</span> <span class="hl opt">((</span>grp<span class="hl opt">=</span><span class="hl kwd">H5G_open_oid</span><span class="hl opt">(</span>ent<span class="hl opt">,</span> dxpl_id<span class="hl opt">)) ==</span>NULL<span class="hl opt">)</span>
            <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;not found&quot;</span><span class="hl opt">);</span>

        <span class="hl com">/* Add group to list of open objects in file */</span>
        <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5FO_insert</span><span class="hl opt">(</span>grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">.</span>file<span class="hl opt">,</span> grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">.</span>header<span class="hl opt">,</span> grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl opt">{</span>
            <span class="hl kwd">H5FL_FREE</span><span class="hl opt">(</span>H5G_shared_t<span class="hl opt">,</span> grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">);</span>
            <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINSERT<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;can't insert group into list of open objects&quot;</span><span class="hl opt">)</span>
        <span class="hl opt">}</span>

        <span class="hl com">/* Set open object count */</span>
        grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">-&gt;</span>fo_count <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">else</span> <span class="hl opt">{</span>
        <span class="hl kwa">if</span><span class="hl opt">(</span>NULL <span class="hl opt">== (</span>grp <span class="hl opt">=</span> <span class="hl kwd">H5FL_CALLOC</span><span class="hl opt">(</span>H5G_t<span class="hl opt">)))</span>
            <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_RESOURCE<span class="hl opt">,</span> H5E_NOSPACE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;can't allocate space for group&quot;</span><span class="hl opt">)</span>

        <span class="hl com">/* Shallow copy (take ownership) of the group entry object */</span>
        <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5G_ent_copy</span><span class="hl opt">(&amp;(</span>grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">),</span> ent<span class="hl opt">,</span> H5G_COPY_SHALLOW<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
            <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTCOPY<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;can't copy group entry&quot;</span><span class="hl opt">)</span>

        <span class="hl com">/* Point to shared group info */</span>
        grp<span class="hl opt">-&gt;</span>shared <span class="hl opt">=</span> shared_fo<span class="hl opt">;</span>

        <span class="hl com">/* Increment shared reference count */</span>
        shared_fo<span class="hl opt">-&gt;</span>fo_count<span class="hl opt">++;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/* Set return value */</span>
    ret_value <span class="hl opt">=</span> grp<span class="hl opt">;</span>

done<span class="hl opt">:</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>ret_value <span class="hl opt">&amp;&amp;</span> grp<span class="hl opt">)</span>
        <span class="hl kwd">H5FL_FREE</span><span class="hl opt">(</span>H5G_t<span class="hl opt">,</span>grp<span class="hl opt">);</span>

    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_open_oid</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Opens an existing group.  The group should eventually be</span>
<span class="hl com"> *		closed by calling H5G_close().</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	Ptr to a new group.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	NULL</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Quincey Koziol</span>
<span class="hl com"> *	    Wednesday, March	17, 1999</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *      Pedro Vicente, &lt;pvn&#64;ncsa.uiuc.edu&gt; 22 Aug 2002</span>
<span class="hl com"> *      Added a deep copy of the symbol table entry</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> H5G_t <span class="hl opt">*</span>
<span class="hl kwd">H5G_open_oid</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>ent<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_t		<span class="hl opt">*</span>grp <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    H5G_t		<span class="hl opt">*</span>ret_value <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    H5O_stab_t		mesg<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT</span><span class="hl opt">(</span>H5G_open_oid<span class="hl opt">);</span>

    <span class="hl com">/* Check args */</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>ent<span class="hl opt">);</span>

    <span class="hl com">/* Open the object, making sure it's a group */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>grp <span class="hl opt">=</span> <span class="hl kwd">H5FL_CALLOC</span><span class="hl opt">(</span>H5G_t<span class="hl opt">)))</span>
        <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_RESOURCE<span class="hl opt">,</span> H5E_NOSPACE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;memory allocation failed&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>grp<span class="hl opt">-&gt;</span>shared <span class="hl opt">=</span> <span class="hl kwd">H5FL_CALLOC</span><span class="hl opt">(</span>H5G_shared_t<span class="hl opt">)))</span>
        <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_RESOURCE<span class="hl opt">,</span> H5E_NOSPACE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;memory allocation failed&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Copy over (take ownership) of the group entry object */</span>
    <span class="hl kwd">H5G_ent_copy</span><span class="hl opt">(&amp;(</span>grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">),</span>ent<span class="hl opt">,</span>H5G_COPY_SHALLOW<span class="hl opt">);</span>

    <span class="hl com">/* Grab the object header */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5O_open</span><span class="hl opt">(&amp;(</span>grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">)) &lt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTOPENOBJ<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;unable to open group&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==</span><span class="hl kwd">H5O_read</span> <span class="hl opt">(&amp;(</span>grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">),</span> H5O_STAB_ID<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">, &amp;</span>mesg<span class="hl opt">,</span> dxpl_id<span class="hl opt">)) {</span>
        <span class="hl kwd">H5O_close</span><span class="hl opt">(&amp;(</span>grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">));</span>
        <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTOPENOBJ<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;not a group&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/* Set return value */</span>
    ret_value <span class="hl opt">=</span> grp<span class="hl opt">;</span>

done<span class="hl opt">:</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>ret_value <span class="hl opt">&amp;&amp;</span> grp<span class="hl opt">) {</span>
        <span class="hl kwa">if</span><span class="hl opt">(</span>grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">)</span>
            <span class="hl kwd">H5FL_FREE</span><span class="hl opt">(</span>H5G_shared_t<span class="hl opt">,</span> grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">);</span>
        <span class="hl kwd">H5FL_FREE</span><span class="hl opt">(</span>H5G_t<span class="hl opt">,</span>grp<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_close</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Closes the specified group.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Non-negative on success/Negative on failure</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *		Monday, January	 5, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
herr_t
<span class="hl kwd">H5G_close</span><span class="hl opt">(</span>H5G_t <span class="hl opt">*</span>grp<span class="hl opt">)</span>
<span class="hl opt">{</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI</span><span class="hl opt">(</span>H5G_close<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>

    <span class="hl com">/* Check args */</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>grp <span class="hl opt">&amp;&amp;</span> grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">-&gt;</span>fo_count <span class="hl opt">&gt;</span> <span class="hl num">0</span><span class="hl opt">);</span>

    <span class="hl opt">--</span>grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">-&gt;</span>fo_count<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl num">0</span> <span class="hl opt">==</span> grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">-&gt;</span>fo_count<span class="hl opt">) {</span>
        <span class="hl kwa">assert</span> <span class="hl opt">(</span>grp<span class="hl opt">!=</span><span class="hl kwd">H5G_rootof</span><span class="hl opt">(</span><span class="hl kwd">H5G_fileof</span><span class="hl opt">(</span>grp<span class="hl opt">)));</span>

        <span class="hl com">/* Remove the dataset from the list of opened objects in the file */</span>
        <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5FO_delete</span><span class="hl opt">(</span>grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">.</span>file<span class="hl opt">,</span> H5AC_dxpl_id<span class="hl opt">,</span> grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">.</span>header<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
            <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTRELEASE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;can't remove group from list of open objects&quot;</span><span class="hl opt">)</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5O_close</span><span class="hl opt">(&amp;(</span>grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">)) &lt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
            <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to close&quot;</span><span class="hl opt">);</span>
        <span class="hl kwd">H5FL_FREE</span> <span class="hl opt">(</span>H5G_shared_t<span class="hl opt">,</span> grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
        <span class="hl com">/* If this group is a mount point and the mount point is the last open</span>
<span class="hl com">         * reference to the group, then attempt to close down the file hierarchy</span>
<span class="hl com">         */</span>
        <span class="hl kwa">if</span><span class="hl opt">(</span>grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">-&gt;</span>mounted <span class="hl opt">&amp;&amp;</span> grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">-&gt;</span>fo_count <span class="hl opt">==</span> <span class="hl num">1</span><span class="hl opt">) {</span>
            <span class="hl com">/* Attempt to close down the file hierarchy */</span>
            <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5F_try_close</span><span class="hl opt">(</span>grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">.</span>file<span class="hl opt">) &lt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
                <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_FILE<span class="hl opt">,</span> H5E_CANTCLOSEFILE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;problem attempting file close&quot;</span><span class="hl opt">)</span>
        <span class="hl opt">}</span> <span class="hl com">/* end if */</span>

        <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(&amp;(</span>grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">))&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl opt">{</span>
            <span class="hl kwd">H5FL_FREE</span> <span class="hl opt">(</span>H5G_t<span class="hl opt">,</span>grp<span class="hl opt">);</span>
            <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;can't free group entry name&quot;</span><span class="hl opt">);</span>
        <span class="hl opt">}</span>
    <span class="hl opt">}</span>

    <span class="hl kwd">H5FL_FREE</span> <span class="hl opt">(</span>H5G_t<span class="hl opt">,</span>grp<span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span> <span class="hl com">/* end H5G_close() */</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:    H5G_free</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Free memory used by an H5G_t struct (and its H5G_shared_t).</span>
<span class="hl com"> *          Does not close the group or decrement the reference count.</span>
<span class="hl com"> *          Used to free memory used by the root group.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:  Success:    Non-negative</span>
<span class="hl com"> *	        Failure:    Negative</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:  James Laird</span>
<span class="hl com"> *              Tuesday, September 7, 2004</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
herr_t
<span class="hl kwd">H5G_free</span><span class="hl opt">(</span>H5G_t <span class="hl opt">*</span>grp<span class="hl opt">)</span>
<span class="hl opt">{</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI</span><span class="hl opt">(</span>H5G_free<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>

    <span class="hl kwa">assert</span><span class="hl opt">(</span>grp <span class="hl opt">&amp;&amp;</span> grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">);</span>

    <span class="hl kwd">H5FL_FREE</span><span class="hl opt">(</span>H5G_shared_t<span class="hl opt">,</span> grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">);</span>
    <span class="hl kwd">H5FL_FREE</span><span class="hl opt">(</span>H5G_t<span class="hl opt">,</span> grp<span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_rootof</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Return a pointer to the root group of the file.  If the file</span>
<span class="hl com"> *		is part of a virtual file then the root group of the virtual</span>
<span class="hl com"> *		file is returned.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	Ptr to the root group of the file.  Do not</span>
<span class="hl com"> *				free the pointer -- it points directly into</span>
<span class="hl com"> *				the file struct.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	NULL</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Tuesday, October 13, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> H5G_t <span class="hl opt">*</span>
<span class="hl kwd">H5G_rootof</span><span class="hl opt">(</span>H5F_t <span class="hl opt">*</span>f<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT_NOFUNC</span><span class="hl opt">(</span>H5G_rootof<span class="hl opt">);</span>

    <span class="hl kwa">while</span> <span class="hl opt">(</span>f<span class="hl opt">-&gt;</span>mtab<span class="hl opt">.</span>parent<span class="hl opt">)</span>
        f <span class="hl opt">=</span> f<span class="hl opt">-&gt;</span>mtab<span class="hl opt">.</span>parent<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>f<span class="hl opt">-&gt;</span>shared<span class="hl opt">-&gt;</span>root_grp<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_insert</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Inserts a symbol table entry into the group graph.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Errors:</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Non-negative on success/Negative on failure</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *		Friday, September 19, 1997</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *      Pedro Vicente, &lt;pvn&#64;ncsa.uiuc.edu&gt; 18 Sep 2002</span>
<span class="hl com"> *      Added `id to name' support.</span>
<span class="hl com"> *</span>
<span class="hl com"> *      Peter Cao</span>
<span class="hl com"> *      May 09, 2005</span>
<span class="hl com"> *      Add flag 'crt_intmd_group' to support creating missing groups</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
herr_t
<span class="hl kwd">H5G_insert</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>loc<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> H5G_entry_t <span class="hl opt">*</span>ent<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">,</span> H5P_genplist_t <span class="hl opt">*</span>oc_plist<span class="hl opt">)</span>
<span class="hl opt">{</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>
    <span class="hl kwb">unsigned</span>    target<span class="hl opt">=</span>H5G_TARGET_NORMAL<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI</span><span class="hl opt">(</span>H5G_insert<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>

    <span class="hl com">/* Check args. */</span>
    <span class="hl kwa">assert</span> <span class="hl opt">(</span>loc<span class="hl opt">);</span>
    <span class="hl kwa">assert</span> <span class="hl opt">(</span>name <span class="hl opt">&amp;&amp; *</span>name<span class="hl opt">);</span>
    <span class="hl kwa">assert</span> <span class="hl opt">(</span>ent<span class="hl opt">);</span>

    <span class="hl com">/* Check for intermediate group creation flag present */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>oc_plist <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
        <span class="hl kwb">unsigned</span> crt_intmd_group<span class="hl opt">;</span>

        <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5P_get</span><span class="hl opt">(</span>oc_plist<span class="hl opt">,</span> H5G_CRT_INTERMEDIATE_GROUP_NAME<span class="hl opt">, &amp;</span>crt_intmd_group<span class="hl opt">) &lt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
            <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_PLIST<span class="hl opt">,</span> H5E_CANTGET<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;can't get property value for creating missing groups&quot;</span><span class="hl opt">);</span>

        <span class="hl kwa">if</span> <span class="hl opt">(</span>crt_intmd_group <span class="hl opt">&gt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
            target <span class="hl opt">|=</span> H5G_CRT_INTMD_GROUP<span class="hl opt">;</span>
    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Lookup and insert the name -- it shouldn't exist yet.</span>
<span class="hl com">     */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_namei</span><span class="hl opt">(</span>loc<span class="hl opt">,</span> name<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> target<span class="hl opt">,</span> NULL<span class="hl opt">,</span> H5G_NAMEI_INSERT<span class="hl opt">,</span> ent<span class="hl opt">,</span> dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_EXISTS<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;already exists&quot;</span><span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_find</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Finds an object with the specified NAME at location LOC.  On</span>
<span class="hl com"> *		successful return, GRP_ENT (if non-null) will be initialized</span>
<span class="hl com"> *		with the symbol table information for the group in which the</span>
<span class="hl com"> *		object appears (it will have an undefined object header</span>
<span class="hl com"> *		address if the object is the root object) and OBJ_ENT will be</span>
<span class="hl com"> *		initialized with the symbol table entry for the object</span>
<span class="hl com"> *		(OBJ_ENT is optional when the caller is interested only in</span>
<span class="hl com"> * 		the existence of the object).</span>
<span class="hl com"> *</span>
<span class="hl com"> * Errors:</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	Non-negative, see above for values of GRP_ENT</span>
<span class="hl com"> *				and OBJ_ENT.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	Negative</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *		matzke&#64;llnl.gov</span>
<span class="hl com"> *		Aug 12 1997</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
herr_t
<span class="hl kwd">H5G_find</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>loc<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span>
	 H5G_entry_t <span class="hl opt">*</span>grp_ent<span class="hl com">/*out*/</span><span class="hl opt">,</span> H5G_entry_t <span class="hl opt">*</span>obj_ent<span class="hl com">/*out*/</span><span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI</span><span class="hl opt">(</span>H5G_find<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>

    <span class="hl com">/* check args */</span>
    <span class="hl kwa">assert</span> <span class="hl opt">(</span>loc<span class="hl opt">);</span>
    <span class="hl kwa">assert</span> <span class="hl opt">(</span>name <span class="hl opt">&amp;&amp; *</span>name<span class="hl opt">);</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_namei</span><span class="hl opt">(</span>loc<span class="hl opt">,</span> name<span class="hl opt">,</span> NULL<span class="hl opt">,</span> grp_ent<span class="hl opt">,</span> obj_ent<span class="hl opt">,</span> H5G_TARGET_NORMAL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> H5G_NAMEI_TRAVERSE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;object not found&quot;</span><span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_entof</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Returns a pointer to the entry for a group.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	Ptr to group entry</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	NULL</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Tuesday, March 24, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
H5G_entry_t <span class="hl opt">*</span>
<span class="hl kwd">H5G_entof</span> <span class="hl opt">(</span>H5G_t <span class="hl opt">*</span>grp<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl com">/* Use FUNC_ENTER_NOAPI_NOINIT_NOFUNC here to avoid performance issues */</span>
    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT_NOFUNC</span><span class="hl opt">(</span>H5G_entof<span class="hl opt">);</span>

    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>grp ? <span class="hl opt">&amp;(</span>grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">) :</span> NULL<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_fileof</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Returns the file to which the specified group belongs.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	File pointer.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	NULL</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Tuesday, March 24, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
H5F_t <span class="hl opt">*</span>
<span class="hl kwd">H5G_fileof</span> <span class="hl opt">(</span>H5G_t <span class="hl opt">*</span>grp<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl com">/* Use FUNC_ENTER_NOAPI_NOINIT_NOFUNC here to avoid performance issues */</span>
    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT_NOFUNC</span><span class="hl opt">(</span>H5G_fileof<span class="hl opt">);</span>

    <span class="hl kwa">assert</span> <span class="hl opt">(</span>grp<span class="hl opt">);</span>

    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>grp<span class="hl opt">-&gt;</span>ent<span class="hl opt">.</span>file<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_loc</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Given an object ID return a symbol table entry for the</span>
<span class="hl com"> *		object.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	Group pointer.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	NULL</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Tuesday, March 24, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
H5G_entry_t <span class="hl opt">*</span>
<span class="hl kwd">H5G_loc</span> <span class="hl opt">(</span>hid_t loc_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5F_t	<span class="hl opt">*</span>f<span class="hl opt">;</span>
    H5G_entry_t	<span class="hl opt">*</span>ret_value<span class="hl opt">=</span>NULL<span class="hl opt">;</span>
    H5G_t	<span class="hl opt">*</span>group<span class="hl opt">=</span>NULL<span class="hl opt">;</span>
    H5T_t	<span class="hl opt">*</span>dt<span class="hl opt">=</span>NULL<span class="hl opt">;</span>
    H5D_t	<span class="hl opt">*</span>dset<span class="hl opt">=</span>NULL<span class="hl opt">;</span>
    H5A_t	<span class="hl opt">*</span>attr<span class="hl opt">=</span>NULL<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI</span><span class="hl opt">(</span>H5G_loc<span class="hl opt">,</span> NULL<span class="hl opt">);</span>

    <span class="hl kwa">switch</span> <span class="hl opt">(</span><span class="hl kwd">H5I_get_type</span><span class="hl opt">(</span>loc_id<span class="hl opt">)) {</span>
        <span class="hl kwa">case</span> H5I_FILE<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>f<span class="hl opt">=</span><span class="hl kwd">H5I_object</span> <span class="hl opt">(</span>loc_id<span class="hl opt">)))</span>
                <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;invalid file ID&quot;</span><span class="hl opt">);</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>ret_value<span class="hl opt">=</span><span class="hl kwd">H5G_entof</span><span class="hl opt">(</span><span class="hl kwd">H5G_rootof</span><span class="hl opt">(</span>f<span class="hl opt">))))</span>
                <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;unable to get symbol table entry for root group&quot;</span><span class="hl opt">);</span>

            <span class="hl com">/* Patch up root group's symbol table entry to reflect this file */</span>
            <span class="hl com">/* (Since the root group info is only stored once for files which</span>
<span class="hl com">             *  share an underlying low-level file)</span>
<span class="hl com">             */</span>
            <span class="hl com">/* (but only for non-mounted files) */</span>
            <span class="hl kwa">if</span><span class="hl opt">(!</span>f<span class="hl opt">-&gt;</span>mtab<span class="hl opt">.</span>parent<span class="hl opt">)</span>
                ret_value<span class="hl opt">-&gt;</span>file <span class="hl opt">=</span> f<span class="hl opt">;</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>

        <span class="hl kwa">case</span> H5I_GENPROP_CLS<span class="hl opt">:</span>
        <span class="hl kwa">case</span> H5I_GENPROP_LST<span class="hl opt">:</span>
            <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;unable to get symbol table entry of property list&quot;</span><span class="hl opt">);</span>

        <span class="hl kwa">case</span> H5I_ERROR_CLASS<span class="hl opt">:</span>
        <span class="hl kwa">case</span> H5I_ERROR_MSG<span class="hl opt">:</span>
        <span class="hl kwa">case</span> H5I_ERROR_STACK<span class="hl opt">:</span>
            <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;unable to get symbol table entry of error class, message or stack&quot;</span><span class="hl opt">);</span>

        <span class="hl kwa">case</span> H5I_GROUP<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>group<span class="hl opt">=</span><span class="hl kwd">H5I_object</span> <span class="hl opt">(</span>loc_id<span class="hl opt">)))</span>
                <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;invalid group ID&quot;</span><span class="hl opt">);</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>ret_value<span class="hl opt">=</span><span class="hl kwd">H5G_entof</span><span class="hl opt">(</span>group<span class="hl opt">)))</span>
                <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;unable to get symbol table entry of group&quot;</span><span class="hl opt">);</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>

        <span class="hl kwa">case</span> H5I_DATATYPE<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>dt<span class="hl opt">=</span><span class="hl kwd">H5I_object</span><span class="hl opt">(</span>loc_id<span class="hl opt">)))</span>
                <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;invalid type ID&quot;</span><span class="hl opt">);</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>ret_value<span class="hl opt">=</span><span class="hl kwd">H5T_entof</span><span class="hl opt">(</span>dt<span class="hl opt">)))</span>
                <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;unable to get symbol table entry of datatype&quot;</span><span class="hl opt">);</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>

        <span class="hl kwa">case</span> H5I_DATASPACE<span class="hl opt">:</span>
            <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;unable to get symbol table entry of dataspace&quot;</span><span class="hl opt">);</span>

        <span class="hl kwa">case</span> H5I_DATASET<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>dset<span class="hl opt">=</span><span class="hl kwd">H5I_object</span><span class="hl opt">(</span>loc_id<span class="hl opt">)))</span>
                <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;invalid data ID&quot;</span><span class="hl opt">);</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>ret_value<span class="hl opt">=</span><span class="hl kwd">H5D_entof</span><span class="hl opt">(</span>dset<span class="hl opt">)))</span>
                <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;unable to get symbol table entry of dataset&quot;</span><span class="hl opt">);</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>

        <span class="hl kwa">case</span> H5I_ATTR<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>attr<span class="hl opt">=</span><span class="hl kwd">H5I_object</span><span class="hl opt">(</span>loc_id<span class="hl opt">)))</span>
                <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;invalid attribute ID&quot;</span><span class="hl opt">);</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>ret_value<span class="hl opt">=</span><span class="hl kwd">H5A_entof</span><span class="hl opt">(</span>attr<span class="hl opt">)))</span>
                <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;unable to get symbol table entry of attribute&quot;</span><span class="hl opt">);</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>

        <span class="hl kwa">case</span> H5I_REFERENCE<span class="hl opt">:</span>
            <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;unable to get symbol table entry of reference&quot;</span><span class="hl opt">);</span>

        <span class="hl kwa">default</span><span class="hl opt">:</span>
            <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;invalid object ID&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_link</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Creates a link from NEW_NAME to CUR_NAME.  See H5Glink() for</span>
<span class="hl com"> *		full documentation.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Non-negative on success/Negative on failure</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Monday, April  6, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *      Pedro Vicente, &lt;pvn&#64;ncsa.uiuc.edu&gt; 18 Sep 2002</span>
<span class="hl com"> *      Added `id to name' support.</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> herr_t
<span class="hl kwd">H5G_link</span> <span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>cur_loc<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>cur_name<span class="hl opt">,</span> H5G_entry_t <span class="hl opt">*</span>new_loc<span class="hl opt">,</span>
	  <span class="hl kwb">const char</span> <span class="hl opt">*</span>new_name<span class="hl opt">,</span> H5G_link_t type<span class="hl opt">,</span> <span class="hl kwb">unsigned</span> namei_flags<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_entry_t		cur_obj<span class="hl opt">;</span>	<span class="hl com">/*entry for the link tail	*/</span>
    <span class="hl kwb">unsigned</span>            cur_obj_init<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">;</span> <span class="hl com">/* Flag to indicate that the current object is initialized */</span>
    H5G_entry_t		grp_ent<span class="hl opt">;</span>	<span class="hl com">/*ent for grp containing link hd*/</span>
    H5O_stab_t		stab_mesg<span class="hl opt">;</span>	<span class="hl com">/*symbol table message		*/</span>
    <span class="hl kwb">const char</span>		<span class="hl opt">*</span>rest <span class="hl opt">=</span> NULL<span class="hl opt">;</span>	<span class="hl com">/*last component of new name	*/</span>
    <span class="hl kwb">char</span>		<span class="hl opt">*</span>norm_cur_name <span class="hl opt">=</span> NULL<span class="hl opt">;</span>	<span class="hl com">/* Pointer to normalized current name */</span>
    <span class="hl kwb">char</span>		<span class="hl opt">*</span>norm_new_name <span class="hl opt">=</span> NULL<span class="hl opt">;</span>	<span class="hl com">/* Pointer to normalized current name */</span>
    <span class="hl kwb">size_t</span>		nchars<span class="hl opt">;</span>		<span class="hl com">/*characters in component	*/</span>
    <span class="hl kwb">size_t</span>		offset<span class="hl opt">;</span>		<span class="hl com">/*offset to sym-link value	*/</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT</span><span class="hl opt">(</span>H5G_link<span class="hl opt">);</span>

    <span class="hl com">/* Check args */</span>
    <span class="hl kwa">assert</span> <span class="hl opt">(</span>cur_loc<span class="hl opt">);</span>
    <span class="hl kwa">assert</span> <span class="hl opt">(</span>new_loc<span class="hl opt">);</span>
    <span class="hl kwa">assert</span> <span class="hl opt">(</span>cur_name <span class="hl opt">&amp;&amp; *</span>cur_name<span class="hl opt">);</span>
    <span class="hl kwa">assert</span> <span class="hl opt">(</span>new_name <span class="hl opt">&amp;&amp; *</span>new_name<span class="hl opt">);</span>

    <span class="hl com">/* Get normalized copies of the current and new names */</span>
    <span class="hl kwa">if</span><span class="hl opt">((</span>norm_cur_name<span class="hl opt">=</span><span class="hl kwd">H5G_normalize</span><span class="hl opt">(</span>cur_name<span class="hl opt">))==</span>NULL<span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;can't normalize name&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span><span class="hl opt">((</span>norm_new_name<span class="hl opt">=</span><span class="hl kwd">H5G_normalize</span><span class="hl opt">(</span>new_name<span class="hl opt">))==</span>NULL<span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;can't normalize name&quot;</span><span class="hl opt">);</span>

    <span class="hl kwa">switch</span> <span class="hl opt">(</span>type<span class="hl opt">) {</span>
        <span class="hl kwa">case</span> H5G_LINK_SOFT<span class="hl opt">:</span>
            <span class="hl com">/*</span>
<span class="hl com">             * Lookup the the new_name so we can get the group which will contain</span>
<span class="hl com">             * the new entry.  The entry shouldn't exist yet.</span>
<span class="hl com">             */</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_namei</span><span class="hl opt">(</span>new_loc<span class="hl opt">,</span> norm_new_name<span class="hl opt">, &amp;</span>rest<span class="hl opt">, &amp;</span>grp_ent<span class="hl opt">,</span> NULL<span class="hl opt">,</span>
                            H5G_TARGET_NORMAL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> H5G_NAMEI_TRAVERSE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> dxpl_id<span class="hl opt">)&gt;=</span><span class="hl num">0</span><span class="hl opt">)</span>
                <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_EXISTS<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;already exists&quot;</span><span class="hl opt">);</span>
            <span class="hl kwd">H5E_clear_stack</span> <span class="hl opt">(</span>NULL<span class="hl opt">);</span> <span class="hl com">/*it's okay that we didn't find it*/</span>
            rest <span class="hl opt">=</span> <span class="hl kwd">H5G_component</span> <span class="hl opt">(</span>rest<span class="hl opt">, &amp;</span>nchars<span class="hl opt">);</span>

            <span class="hl com">/*</span>
<span class="hl com">             * There should be one component left.  Make sure it's null</span>
<span class="hl com">             * terminated and that `rest' points to it.</span>
<span class="hl com">             */</span>
            <span class="hl kwa">assert</span><span class="hl opt">(!</span>rest<span class="hl opt">[</span>nchars<span class="hl opt">]);</span>

            <span class="hl com">/*</span>
<span class="hl com">             * Add the link-value to the local heap for the symbol table which</span>
<span class="hl com">             * will contain the link.</span>
<span class="hl com">             */</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==</span><span class="hl kwd">H5O_read</span> <span class="hl opt">(&amp;</span>grp_ent<span class="hl opt">,</span> H5O_STAB_ID<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">, &amp;</span>stab_mesg<span class="hl opt">,</span> dxpl_id<span class="hl opt">))</span>
                <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to determine local heap address&quot;</span><span class="hl opt">);</span>
            <span class="hl kwa">if</span> <span class="hl opt">((</span><span class="hl kwb">size_t</span><span class="hl opt">)(-</span><span class="hl num">1</span><span class="hl opt">)==(</span>offset<span class="hl opt">=</span><span class="hl kwd">H5HL_insert</span> <span class="hl opt">(</span>grp_ent<span class="hl opt">.</span>file<span class="hl opt">,</span> dxpl_id<span class="hl opt">,</span>
                   stab_mesg<span class="hl opt">.</span>heap_addr<span class="hl opt">,</span> <span class="hl kwd">HDstrlen</span><span class="hl opt">(</span>norm_cur_name<span class="hl opt">)+</span><span class="hl num">1</span><span class="hl opt">,</span> norm_cur_name<span class="hl opt">)))</span>
                <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to write link value to local heap&quot;</span><span class="hl opt">);</span>
            <span class="hl kwd">H5O_reset</span> <span class="hl opt">(</span>H5O_STAB_ID<span class="hl opt">, &amp;</span>stab_mesg<span class="hl opt">);</span>

            <span class="hl com">/*</span>
<span class="hl com">             * Create a symbol table entry for the link.  The object header is</span>
<span class="hl com">             * undefined and the cache contains the link-value offset.</span>
<span class="hl com">             */</span>
            <span class="hl kwd">H5G_ent_reset</span><span class="hl opt">(&amp;</span>cur_obj<span class="hl opt">);</span>
            cur_obj<span class="hl opt">.</span>file <span class="hl opt">=</span> grp_ent<span class="hl opt">.</span>file<span class="hl opt">;</span>
            cur_obj<span class="hl opt">.</span>type <span class="hl opt">=</span> H5G_CACHED_SLINK<span class="hl opt">;</span>
            cur_obj<span class="hl opt">.</span>cache<span class="hl opt">.</span>slink<span class="hl opt">.</span>lval_offset <span class="hl opt">=</span> offset<span class="hl opt">;</span>
            cur_obj_init<span class="hl opt">=</span><span class="hl num">1</span><span class="hl opt">;</span>     <span class="hl com">/* Indicate that the cur_obj struct is initialized */</span>

            <span class="hl com">/*</span>
<span class="hl com">             * Insert the link head in the symbol table.  This shouldn't ever</span>
<span class="hl com">             * fail because we've already checked that the link head doesn't</span>
<span class="hl com">             * exist and the file is writable (because the local heap is</span>
<span class="hl com">             * writable).  But if it does, the only side effect is that the local</span>
<span class="hl com">             * heap has some extra garbage in it.</span>
<span class="hl com">             *</span>
<span class="hl com">             * Note: We don't increment the link count of the destination object</span>
<span class="hl com">             */</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_stab_insert</span> <span class="hl opt">(&amp;</span>grp_ent<span class="hl opt">,</span> rest<span class="hl opt">, &amp;</span>cur_obj<span class="hl opt">,</span> FALSE<span class="hl opt">,</span> dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
                <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to create new name/link for object&quot;</span><span class="hl opt">);</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>

        <span class="hl kwa">case</span> H5G_LINK_HARD<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_namei</span><span class="hl opt">(</span>cur_loc<span class="hl opt">,</span> norm_cur_name<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">, &amp;</span>cur_obj<span class="hl opt">,</span> namei_flags<span class="hl opt">,</span> NULL<span class="hl opt">,</span> H5G_NAMEI_TRAVERSE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
                <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;source object not found&quot;</span><span class="hl opt">);</span>
            cur_obj_init<span class="hl opt">=</span><span class="hl num">1</span><span class="hl opt">;</span>     <span class="hl com">/* Indicate that the cur_obj struct is initialized */</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_insert</span> <span class="hl opt">(</span>new_loc<span class="hl opt">,</span> norm_new_name<span class="hl opt">, &amp;</span>cur_obj<span class="hl opt">,</span> dxpl_id<span class="hl opt">,</span> NULL<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
                <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to create new name/link for object&quot;</span><span class="hl opt">);</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>

        <span class="hl kwa">default</span><span class="hl opt">:</span>
            <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unrecognized link type&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>

done<span class="hl opt">:</span>
    <span class="hl com">/* Free the group's ID to name buffer, if creating a soft link */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>type <span class="hl opt">==</span> H5G_LINK_SOFT<span class="hl opt">)</span>
        <span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(&amp;</span>grp_ent<span class="hl opt">);</span>

    <span class="hl com">/* Free the ID to name buffer */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>cur_obj_init<span class="hl opt">)</span>
        <span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(&amp;</span>cur_obj<span class="hl opt">);</span>

    <span class="hl com">/* Free the normalized path names */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>norm_cur_name<span class="hl opt">)</span>
        <span class="hl kwd">H5MM_xfree</span><span class="hl opt">(</span>norm_cur_name<span class="hl opt">);</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>norm_new_name<span class="hl opt">)</span>
        <span class="hl kwd">H5MM_xfree</span><span class="hl opt">(</span>norm_new_name<span class="hl opt">);</span>

    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_get_type</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Returns the type of object pointed to by `ent'.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	An object type defined in H5Gpublic.h</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	H5G_UNKNOWN</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Wednesday, November  4, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
H5G_obj_t
<span class="hl kwd">H5G_get_type</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>ent<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    htri_t	isa<span class="hl opt">;</span>
    <span class="hl kwb">size_t</span>	i<span class="hl opt">;</span>
    H5G_obj_t   ret_value<span class="hl opt">=</span>H5G_UNKNOWN<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI</span><span class="hl opt">(</span>H5G_get_type<span class="hl opt">,</span> H5G_UNKNOWN<span class="hl opt">);</span>

    <span class="hl kwa">for</span> <span class="hl opt">(</span>i<span class="hl opt">=</span>H5G_ntypes_g<span class="hl opt">;</span> i<span class="hl opt">&gt;</span><span class="hl num">0</span><span class="hl opt">; --</span>i<span class="hl opt">) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">((</span>isa<span class="hl opt">=(</span>H5G_type_g<span class="hl opt">[</span>i<span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">].</span>isa<span class="hl opt">)(</span>ent<span class="hl opt">,</span> dxpl_id<span class="hl opt">))&lt;</span><span class="hl num">0</span><span class="hl opt">) {</span>
	    <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> H5G_UNKNOWN<span class="hl opt">,</span> <span class="hl str">&quot;unable to determine object type&quot;</span><span class="hl opt">);</span>
	<span class="hl opt">}</span> <span class="hl kwa">else if</span> <span class="hl opt">(</span>isa<span class="hl opt">) {</span>
	    <span class="hl kwd">HGOTO_DONE</span><span class="hl opt">(</span>H5G_type_g<span class="hl opt">[</span>i<span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">].</span>type<span class="hl opt">);</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl num">0</span><span class="hl opt">==</span>i<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> H5G_UNKNOWN<span class="hl opt">,</span> <span class="hl str">&quot;unable to determine object type&quot;</span><span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_get_objinfo</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Returns information about an object.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	Non-negative with info about the object</span>
<span class="hl com"> *				returned through STATBUF if it isn't the null</span>
<span class="hl com"> *				pointer.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	Negative</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Monday, April 13, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *      Pedro Vicente, &lt;pvn&#64;ncsa.uiuc.edu&gt; 18 Sep 2002</span>
<span class="hl com"> *      Added `id to name' support.</span>
<span class="hl com"> *</span>
<span class="hl com"> *	John Mainzer - 6/8/05</span>
<span class="hl com"> *      Modified function to use the new dirtied parmeter of</span>
<span class="hl com"> *      H5AC_unprotect(), which allows management of the is_dirty</span>
<span class="hl com"> *      field of the cache info to be moved into the cache code.</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
herr_t
<span class="hl kwd">H5G_get_objinfo</span> <span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>loc<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> hbool_t follow_link<span class="hl opt">,</span>
		 H5G_stat_t <span class="hl opt">*</span>statbuf<span class="hl com">/*out*/</span><span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_entry_t		grp_ent<span class="hl opt">,</span> obj_ent<span class="hl opt">;</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI</span><span class="hl opt">(</span>H5G_get_objinfo<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>

    <span class="hl kwa">assert</span> <span class="hl opt">(</span>loc<span class="hl opt">);</span>
    <span class="hl kwa">assert</span> <span class="hl opt">(</span>name <span class="hl opt">&amp;&amp; *</span>name<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>statbuf<span class="hl opt">)</span> <span class="hl kwd">HDmemset</span> <span class="hl opt">(</span>statbuf<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> <span class="hl kwa">sizeof</span> <span class="hl opt">*</span>statbuf<span class="hl opt">);</span>

    <span class="hl com">/* Find the object's symbol table entry */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_namei</span><span class="hl opt">(</span>loc<span class="hl opt">,</span> name<span class="hl opt">,</span> NULL<span class="hl opt">, &amp;</span>grp_ent<span class="hl com">/*out*/</span><span class="hl opt">, &amp;</span>obj_ent<span class="hl com">/*out*/</span><span class="hl opt">,</span>
		   <span class="hl opt">(</span><span class="hl kwb">unsigned</span><span class="hl opt">)(</span>follow_link?H5G_TARGET_NORMAL<span class="hl opt">:</span>H5G_TARGET_SLINK<span class="hl opt">),</span> NULL<span class="hl opt">,</span> H5G_NAMEI_TRAVERSE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to stat object&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Initialize the stat buf.  Symbolic links aren't normal objects and</span>
<span class="hl com">     * therefore don't have much of the normal info.  However, the link value</span>
<span class="hl com">     * length is specific to symbolic links.</span>
<span class="hl com">     */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>statbuf<span class="hl opt">) {</span>
        <span class="hl com">/* Common code to retrieve the file's fileno */</span>
        <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5F_get_fileno</span><span class="hl opt">(</span>obj_ent<span class="hl opt">.</span>file<span class="hl opt">,&amp;</span>statbuf<span class="hl opt">-&gt;</span>fileno<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
            <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_FILE<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to read fileno&quot;</span><span class="hl opt">);</span>

        <span class="hl com">/* Retrieve information specific to each type of entry */</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>H5G_CACHED_SLINK<span class="hl opt">==</span>obj_ent<span class="hl opt">.</span>type<span class="hl opt">) {</span>
            H5O_stab_t	stab_mesg<span class="hl opt">;</span>      <span class="hl com">/* Symbol table message info */</span>
            <span class="hl kwb">const char</span>	<span class="hl opt">*</span>s<span class="hl opt">;</span>             <span class="hl com">/* Pointer to link value */</span>
            <span class="hl kwb">const</span> H5HL_t <span class="hl opt">*</span>heap<span class="hl opt">;</span>         <span class="hl com">/* Pointer to local heap for group */</span>

	    <span class="hl com">/* Named object is a symbolic link */</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL <span class="hl opt">==</span> <span class="hl kwd">H5O_read</span><span class="hl opt">(&amp;</span>grp_ent<span class="hl opt">,</span> H5O_STAB_ID<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">, &amp;</span>stab_mesg<span class="hl opt">,</span> dxpl_id<span class="hl opt">))</span>
		<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to read symbolic link value&quot;</span><span class="hl opt">)</span>

            <span class="hl com">/* Lock the local heap */</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL <span class="hl opt">== (</span>heap <span class="hl opt">=</span> <span class="hl kwd">H5HL_protect</span><span class="hl opt">(</span>grp_ent<span class="hl opt">.</span>file<span class="hl opt">,</span> dxpl_id<span class="hl opt">,</span> stab_mesg<span class="hl opt">.</span>heap_addr<span class="hl opt">)))</span>
                <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to read protect link value&quot;</span><span class="hl opt">)</span>

            s <span class="hl opt">=</span> <span class="hl kwd">H5HL_offset_into</span><span class="hl opt">(</span>grp_ent<span class="hl opt">.</span>file<span class="hl opt">,</span> heap<span class="hl opt">,</span> obj_ent<span class="hl opt">.</span>cache<span class="hl opt">.</span>slink<span class="hl opt">.</span>lval_offset<span class="hl opt">);</span>

	    statbuf<span class="hl opt">-&gt;</span>u<span class="hl opt">.</span>slink<span class="hl opt">.</span>linklen <span class="hl opt">=</span> <span class="hl kwd">HDstrlen</span><span class="hl opt">(</span>s<span class="hl opt">) +</span> <span class="hl num">1</span><span class="hl opt">;</span> <span class="hl com">/*count the null terminator*/</span>

            <span class="hl com">/* Release the local heap */</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5HL_unprotect</span><span class="hl opt">(</span>grp_ent<span class="hl opt">.</span>file<span class="hl opt">,</span> dxpl_id<span class="hl opt">,</span> heap<span class="hl opt">,</span> stab_mesg<span class="hl opt">.</span>heap_addr<span class="hl opt">,</span> H5AC__NO_FLAGS_SET<span class="hl opt">) &lt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
                <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to read unprotect link value&quot;</span><span class="hl opt">)</span>

            <span class="hl com">/* Set object type */</span>
	    statbuf<span class="hl opt">-&gt;</span>type <span class="hl opt">=</span> H5G_LINK<span class="hl opt">;</span>
	<span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	    <span class="hl com">/* Some other type of object */</span>
	    statbuf<span class="hl opt">-&gt;</span>u<span class="hl opt">.</span>obj<span class="hl opt">.</span>objno <span class="hl opt">=</span> obj_ent<span class="hl opt">.</span>header<span class="hl opt">;</span>
	    statbuf<span class="hl opt">-&gt;</span>u<span class="hl opt">.</span>obj<span class="hl opt">.</span>nlink <span class="hl opt">=</span> <span class="hl kwd">H5O_link</span> <span class="hl opt">(&amp;</span>obj_ent<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> dxpl_id<span class="hl opt">);</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==</span><span class="hl kwd">H5O_read</span><span class="hl opt">(&amp;</span>obj_ent<span class="hl opt">,</span> H5O_MTIME_ID<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">, &amp;(</span>statbuf<span class="hl opt">-&gt;</span>u<span class="hl opt">.</span>obj<span class="hl opt">.</span>mtime<span class="hl opt">),</span> dxpl_id<span class="hl opt">)) {</span>
                <span class="hl kwd">H5E_clear_stack</span><span class="hl opt">(</span>NULL<span class="hl opt">);</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==</span><span class="hl kwd">H5O_read</span><span class="hl opt">(&amp;</span>obj_ent<span class="hl opt">,</span> H5O_MTIME_NEW_ID<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">, &amp;(</span>statbuf<span class="hl opt">-&gt;</span>u<span class="hl opt">.</span>obj<span class="hl opt">.</span>mtime<span class="hl opt">),</span> dxpl_id<span class="hl opt">)) {</span>
                    <span class="hl kwd">H5E_clear_stack</span><span class="hl opt">(</span>NULL<span class="hl opt">);</span>
                    statbuf<span class="hl opt">-&gt;</span>u<span class="hl opt">.</span>obj<span class="hl opt">.</span>mtime <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
                <span class="hl opt">}</span>
	    <span class="hl opt">}</span>
            <span class="hl com">/* Get object type */</span>
	    statbuf<span class="hl opt">-&gt;</span>type <span class="hl opt">=</span> <span class="hl kwd">H5G_get_type</span><span class="hl opt">(&amp;</span>obj_ent<span class="hl opt">,</span> dxpl_id<span class="hl opt">);</span>
	    <span class="hl kwd">H5E_clear_stack</span><span class="hl opt">(</span>NULL<span class="hl opt">);</span> <span class="hl com">/*clear errors resulting from checking type*/</span>

            <span class="hl com">/* Get object header information */</span>
            <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5O_get_info</span><span class="hl opt">(&amp;</span>obj_ent<span class="hl opt">, &amp;(</span>statbuf<span class="hl opt">-&gt;</span>u<span class="hl opt">.</span>obj<span class="hl opt">.</span>ohdr<span class="hl opt">),</span> dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
                <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTGET<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to get object header information&quot;</span><span class="hl opt">)</span>
	<span class="hl opt">}</span>
    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>

done<span class="hl opt">:</span>
    <span class="hl com">/* Free the ID to name buffers */</span>
    <span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(&amp;</span>grp_ent<span class="hl opt">);</span>
    <span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(&amp;</span>obj_ent<span class="hl opt">);</span>

    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_get_num_objs</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:     Private function for H5Gget_num_objs.  Returns the number</span>
<span class="hl com"> *              of objects in the group.  It iterates all B-tree leaves</span>
<span class="hl com"> *              and sum up total number of group members.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:        Non-negative</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	Negative</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Raymond Lu</span>
<span class="hl com"> *	        Nov 20, 2002</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> herr_t
<span class="hl kwd">H5G_get_num_objs</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>loc<span class="hl opt">,</span> hsize_t <span class="hl opt">*</span>num_objs<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5O_stab_t		stab_mesg<span class="hl opt">;</span>		<span class="hl com">/*info about B-tree	*/</span>
    herr_t		ret_value<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT</span><span class="hl opt">(</span>H5G_get_num_objs<span class="hl opt">);</span>

    <span class="hl com">/* Sanity check */</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>loc<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>num_objs<span class="hl opt">);</span>

    <span class="hl com">/* Reset the number of objects in the group */</span>
    <span class="hl opt">*</span>num_objs <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>

    <span class="hl com">/* Get the B-tree info */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==</span><span class="hl kwd">H5O_read</span> <span class="hl opt">(</span>loc<span class="hl opt">,</span> H5O_STAB_ID<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">, &amp;</span>stab_mesg<span class="hl opt">,</span> dxpl_id<span class="hl opt">))</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to determine local heap address&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Iterate over the group members */</span>
    <span class="hl kwa">if</span> <span class="hl opt">((</span>ret_value <span class="hl opt">=</span> <span class="hl kwd">H5B_iterate</span> <span class="hl opt">(</span>loc<span class="hl opt">-&gt;</span>file<span class="hl opt">,</span> dxpl_id<span class="hl opt">,</span> H5B_SNODE<span class="hl opt">,</span>
              H5G_node_sumup<span class="hl opt">,</span> stab_mesg<span class="hl opt">.</span>btree_addr<span class="hl opt">,</span> num_objs<span class="hl opt">))&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwd">HERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> <span class="hl str">&quot;iteration operator failed&quot;</span><span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_get_objname_by_idx</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:     Private function for H5Gget_objname_by_idx.</span>
<span class="hl com"> *              Returns the name of objects in the group by giving index.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:        Non-negative</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	Negative</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Raymond Lu</span>
<span class="hl com"> *	        Nov 20, 2002</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> ssize_t
<span class="hl kwd">H5G_get_objname_by_idx</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>loc<span class="hl opt">,</span> hsize_t idx<span class="hl opt">,</span> <span class="hl kwb">char</span><span class="hl opt">*</span> name<span class="hl opt">,</span> <span class="hl kwb">size_t</span> size<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5O_stab_t		stab_mesg<span class="hl opt">;</span>	<span class="hl com">/*info about local heap	&amp; B-tree */</span>
    H5G_bt_ud3_t	udata<span class="hl opt">;</span>          <span class="hl com">/* Iteration information */</span>
    ssize_t		ret_value<span class="hl opt">;</span>      <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT</span><span class="hl opt">(</span>H5G_get_objname_by_idx<span class="hl opt">);</span>

    <span class="hl com">/* Sanity check */</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>loc<span class="hl opt">);</span>

    <span class="hl com">/* Get the B-tree &amp; local heap info */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==</span><span class="hl kwd">H5O_read</span> <span class="hl opt">(</span>loc<span class="hl opt">,</span> H5O_STAB_ID<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">, &amp;</span>stab_mesg<span class="hl opt">,</span> dxpl_id<span class="hl opt">))</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to determine local heap address&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Set iteration information */</span>
    udata<span class="hl opt">.</span>idx <span class="hl opt">=</span> idx<span class="hl opt">;</span>
    udata<span class="hl opt">.</span>num_objs <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    udata<span class="hl opt">.</span>mesg <span class="hl opt">= &amp;</span>stab_mesg<span class="hl opt">;</span>
    udata<span class="hl opt">.</span>name <span class="hl opt">=</span> NULL<span class="hl opt">;</span>

    <span class="hl com">/* Iterate over the group members */</span>
    <span class="hl kwa">if</span> <span class="hl opt">((</span>ret_value <span class="hl opt">=</span> <span class="hl kwd">H5B_iterate</span> <span class="hl opt">(</span>loc<span class="hl opt">-&gt;</span>file<span class="hl opt">,</span> dxpl_id<span class="hl opt">,</span> H5B_SNODE<span class="hl opt">,</span>
              H5G_node_name<span class="hl opt">,</span> stab_mesg<span class="hl opt">.</span>btree_addr<span class="hl opt">, &amp;</span>udata<span class="hl opt">))&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;iteration operator failed&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* If we don't know the name now, we almost certainly went out of bounds */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>udata<span class="hl opt">.</span>name<span class="hl opt">==</span>NULL<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;index out of bound&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Get the length of the name */</span>
    ret_value <span class="hl opt">= (</span>ssize_t<span class="hl opt">)</span><span class="hl kwd">HDstrlen</span><span class="hl opt">(</span>udata<span class="hl opt">.</span>name<span class="hl opt">);</span>

    <span class="hl com">/* Copy the name into the user's buffer, if given */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>name<span class="hl opt">) {</span>
        <span class="hl kwd">HDstrncpy</span><span class="hl opt">(</span>name<span class="hl opt">,</span> udata<span class="hl opt">.</span>name<span class="hl opt">,</span> <span class="hl kwd">MIN</span><span class="hl opt">((</span><span class="hl kwb">size_t</span><span class="hl opt">)(</span>ret_value<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">),</span>size<span class="hl opt">));</span>
        <span class="hl kwa">if</span><span class="hl opt">((</span><span class="hl kwb">size_t</span><span class="hl opt">)</span>ret_value <span class="hl opt">&gt;=</span> size<span class="hl opt">)</span>
            name<span class="hl opt">[</span>size<span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">]=</span><span class="hl str">'\0'</span><span class="hl opt">;</span>
    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>

done<span class="hl opt">:</span>
    <span class="hl com">/* Free the duplicated name */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>udata<span class="hl opt">.</span>name<span class="hl opt">!=</span>NULL<span class="hl opt">)</span>
        <span class="hl kwd">H5MM_xfree</span><span class="hl opt">(</span>udata<span class="hl opt">.</span>name<span class="hl opt">);</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_get_objtype_by_idx</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:     Private function for H5Gget_objtype_by_idx.</span>
<span class="hl com"> *              Returns the type of objects in the group by giving index.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:        H5G_GROUP(1), H5G_DATASET(2), H5G_TYPE(3)</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	UNKNOWN</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Raymond Lu</span>
<span class="hl com"> *	        Nov 20, 2002</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> H5G_obj_t
<span class="hl kwd">H5G_get_objtype_by_idx</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>loc<span class="hl opt">,</span> hsize_t idx<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5O_stab_t		stab_mesg<span class="hl opt">;</span>	<span class="hl com">/*info about local heap	&amp; B-tree */</span>
    H5G_bt_ud3_t	udata<span class="hl opt">;</span>          <span class="hl com">/* User data for B-tree callback */</span>
    H5G_obj_t		ret_value<span class="hl opt">;</span>      <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT</span><span class="hl opt">(</span>H5G_get_objtype_by_idx<span class="hl opt">);</span>

    <span class="hl com">/* Sanity check */</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>loc<span class="hl opt">);</span>

    <span class="hl com">/* Get the B-tree &amp; local heap info */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==</span><span class="hl kwd">H5O_read</span> <span class="hl opt">(</span>loc<span class="hl opt">,</span> H5O_STAB_ID<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">, &amp;</span>stab_mesg<span class="hl opt">,</span> dxpl_id<span class="hl opt">))</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to determine local heap address&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Set iteration information */</span>
    udata<span class="hl opt">.</span>idx <span class="hl opt">=</span> idx<span class="hl opt">;</span>
    udata<span class="hl opt">.</span>num_objs <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    udata<span class="hl opt">.</span>mesg <span class="hl opt">= &amp;</span>stab_mesg<span class="hl opt">;</span>
    udata<span class="hl opt">.</span>type <span class="hl opt">=</span> H5G_UNKNOWN<span class="hl opt">;</span>

    <span class="hl com">/* Iterate over the group members */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5B_iterate</span> <span class="hl opt">(</span>loc<span class="hl opt">-&gt;</span>file<span class="hl opt">,</span> dxpl_id<span class="hl opt">,</span> H5B_SNODE<span class="hl opt">,</span>
              H5G_node_type<span class="hl opt">,</span> stab_mesg<span class="hl opt">.</span>btree_addr<span class="hl opt">, &amp;</span>udata<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> H5G_UNKNOWN<span class="hl opt">,</span> <span class="hl str">&quot;iteration operator failed&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* If we don't know the type now, we almost certainly went out of bounds */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>udata<span class="hl opt">.</span>type<span class="hl opt">==</span>H5G_UNKNOWN<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> H5G_UNKNOWN<span class="hl opt">,</span> <span class="hl str">&quot;index out of bound&quot;</span><span class="hl opt">);</span>

    ret_value <span class="hl opt">=</span> udata<span class="hl opt">.</span>type<span class="hl opt">;</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_linkval</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Returns the value of a symbolic link.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	Non-negative, with at most SIZE bytes of the</span>
<span class="hl com"> *				link value copied into the BUF buffer.  If the</span>
<span class="hl com"> *				link value is larger than SIZE characters</span>
<span class="hl com"> *				counting the null terminator then the BUF</span>
<span class="hl com"> *				result will not be null terminated.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	Negative</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Monday, April 13, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *      Pedro Vicente, &lt;pvn&#64;ncsa.uiuc.edu&gt; 18 Sep 2002</span>
<span class="hl com"> *      Added `id to name' support.</span>
<span class="hl com"> *</span>
<span class="hl com"> *	John Mainzer - 6/8/05</span>
<span class="hl com"> *      Modified function to use the new dirtied parmeter of</span>
<span class="hl com"> *      H5AC_unprotect(), which allows management of the is_dirty</span>
<span class="hl com"> *      field of the cache info to be moved into the cache code.</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> herr_t
<span class="hl kwd">H5G_linkval</span> <span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>loc<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> <span class="hl kwb">size_t</span> size<span class="hl opt">,</span> <span class="hl kwb">char</span> <span class="hl opt">*</span>buf<span class="hl com">/*out*/</span><span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">const char</span>		<span class="hl opt">*</span>s <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    H5G_entry_t		grp_ent<span class="hl opt">,</span> obj_ent<span class="hl opt">;</span>
    H5O_stab_t		stab_mesg<span class="hl opt">;</span>
    <span class="hl kwb">const</span> H5HL_t        <span class="hl opt">*</span>heap<span class="hl opt">;</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT</span><span class="hl opt">(</span>H5G_linkval<span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Get the symbol table entry for the link head and the symbol table</span>
<span class="hl com">     * entry for the group in which the link head appears.</span>
<span class="hl com">     */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_namei</span><span class="hl opt">(</span>loc<span class="hl opt">,</span> name<span class="hl opt">,</span> NULL<span class="hl opt">, &amp;</span>grp_ent<span class="hl com">/*out*/</span><span class="hl opt">, &amp;</span>obj_ent<span class="hl com">/*out*/</span><span class="hl opt">,</span>
		   H5G_TARGET_SLINK<span class="hl opt">,</span> NULL<span class="hl opt">,</span> H5G_NAMEI_TRAVERSE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;symbolic link was not found&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>H5G_CACHED_SLINK<span class="hl opt">!=</span>obj_ent<span class="hl opt">.</span>type<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;object is not a symbolic link&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/*</span>
<span class="hl com">     * Get the address of the local heap for the link value and a pointer</span>
<span class="hl com">     * into that local heap.</span>
<span class="hl com">     */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==</span><span class="hl kwd">H5O_read</span> <span class="hl opt">(&amp;</span>grp_ent<span class="hl opt">,</span> H5O_STAB_ID<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">, &amp;</span>stab_mesg<span class="hl opt">,</span> dxpl_id<span class="hl opt">))</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to determine local heap address&quot;</span><span class="hl opt">);</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL <span class="hl opt">== (</span>heap <span class="hl opt">=</span> <span class="hl kwd">H5HL_protect</span><span class="hl opt">(</span>grp_ent<span class="hl opt">.</span>file<span class="hl opt">,</span> dxpl_id<span class="hl opt">,</span> stab_mesg<span class="hl opt">.</span>heap_addr<span class="hl opt">)))</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to read protect link value&quot;</span><span class="hl opt">)</span>

    s <span class="hl opt">=</span> <span class="hl kwd">H5HL_offset_into</span><span class="hl opt">(</span>grp_ent<span class="hl opt">.</span>file<span class="hl opt">,</span> heap<span class="hl opt">,</span> obj_ent<span class="hl opt">.</span>cache<span class="hl opt">.</span>slink<span class="hl opt">.</span>lval_offset<span class="hl opt">);</span>

    <span class="hl com">/* Copy to output buffer */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>size<span class="hl opt">&gt;</span><span class="hl num">0</span> <span class="hl opt">&amp;&amp;</span> buf<span class="hl opt">)</span>
	<span class="hl kwd">HDstrncpy</span> <span class="hl opt">(</span>buf<span class="hl opt">,</span> s<span class="hl opt">,</span> size<span class="hl opt">);</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5HL_unprotect</span><span class="hl opt">(</span>grp_ent<span class="hl opt">.</span>file<span class="hl opt">,</span> dxpl_id<span class="hl opt">,</span> heap<span class="hl opt">,</span> stab_mesg<span class="hl opt">.</span>heap_addr<span class="hl opt">,</span> H5AC__NO_FLAGS_SET<span class="hl opt">) &lt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to read unprotect link value&quot;</span><span class="hl opt">)</span>

done<span class="hl opt">:</span>
    <span class="hl com">/* Free the ID to name buffers */</span>
    <span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(&amp;</span>grp_ent<span class="hl opt">);</span>
    <span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(&amp;</span>obj_ent<span class="hl opt">);</span>

    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_set_comment</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	(Re)sets the comment for an object.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Non-negative on success/Negative on failure</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Monday, July 20, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *      Pedro Vicente, &lt;pvn&#64;ncsa.uiuc.edu&gt; 18 Sep 2002</span>
<span class="hl com"> *      Added `id to name' support.</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> herr_t
<span class="hl kwd">H5G_set_comment</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>loc<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>buf<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_entry_t	obj_ent<span class="hl opt">;</span>
    H5O_name_t	comment<span class="hl opt">;</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT</span><span class="hl opt">(</span>H5G_set_comment<span class="hl opt">);</span>

    <span class="hl com">/* Get the symbol table entry for the object */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_namei</span><span class="hl opt">(</span>loc<span class="hl opt">,</span> name<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">, &amp;</span>obj_ent<span class="hl com">/*out*/</span><span class="hl opt">,</span> H5G_TARGET_NORMAL<span class="hl opt">,</span>
		  NULL<span class="hl opt">,</span> H5G_NAMEI_TRAVERSE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;object not found&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Remove the previous comment message if any */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5O_remove</span><span class="hl opt">(&amp;</span>obj_ent<span class="hl opt">,</span> H5O_NAME_ID<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwd">H5E_clear_stack</span><span class="hl opt">(</span>NULL<span class="hl opt">);</span>

    <span class="hl com">/* Add the new message */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>buf <span class="hl opt">&amp;&amp; *</span>buf<span class="hl opt">) {</span>
	comment<span class="hl opt">.</span>s <span class="hl opt">=</span> <span class="hl kwd">H5MM_xstrdup</span><span class="hl opt">(</span>buf<span class="hl opt">);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5O_modify</span><span class="hl opt">(&amp;</span>obj_ent<span class="hl opt">,</span> H5O_NAME_ID<span class="hl opt">,</span> H5O_NEW_MESG<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> H5O_UPDATE_TIME<span class="hl opt">, &amp;</span>comment<span class="hl opt">,</span> dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	    <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_OHDR<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to set comment object header message&quot;</span><span class="hl opt">);</span>
	<span class="hl kwd">H5O_reset</span><span class="hl opt">(</span>H5O_NAME_ID<span class="hl opt">, &amp;</span>comment<span class="hl opt">);</span>
    <span class="hl opt">}</span>

done<span class="hl opt">:</span>
    <span class="hl com">/* Free the ID to name buffer */</span>
    <span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(&amp;</span>obj_ent<span class="hl opt">);</span>

    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_get_comment</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Get the comment value for an object.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	Number of bytes in the comment including the</span>
<span class="hl com"> *				null terminator.  Zero if the object has no</span>
<span class="hl com"> *				comment.</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	Negative</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Monday, July 20, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *      Pedro Vicente, &lt;pvn&#64;ncsa.uiuc.edu&gt; 18 Sep 2002</span>
<span class="hl com"> *      Added `id to name' support.</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static int</span>
<span class="hl kwd">H5G_get_comment</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>loc<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> <span class="hl kwb">size_t</span> bufsize<span class="hl opt">,</span> <span class="hl kwb">char</span> <span class="hl opt">*</span>buf<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5O_name_t	comment<span class="hl opt">;</span>
    H5G_entry_t	obj_ent<span class="hl opt">;</span>
    <span class="hl kwb">int</span>	ret_value<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT</span><span class="hl opt">(</span>H5G_get_comment<span class="hl opt">);</span>

    <span class="hl com">/* Get the symbol table entry for the object */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_namei</span><span class="hl opt">(</span>loc<span class="hl opt">,</span> name<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">, &amp;</span>obj_ent<span class="hl com">/*out*/</span><span class="hl opt">,</span> H5G_TARGET_NORMAL<span class="hl opt">,</span>
		  NULL<span class="hl opt">,</span> H5G_NAMEI_TRAVERSE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;object not found&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Get the message */</span>
    comment<span class="hl opt">.</span>s <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==</span><span class="hl kwd">H5O_read</span><span class="hl opt">(&amp;</span>obj_ent<span class="hl opt">,</span> H5O_NAME_ID<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">, &amp;</span>comment<span class="hl opt">,</span> dxpl_id<span class="hl opt">)) {</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>buf <span class="hl opt">&amp;&amp;</span> bufsize<span class="hl opt">&gt;</span><span class="hl num">0</span><span class="hl opt">)</span>
            buf<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] =</span> <span class="hl str">'\0'</span><span class="hl opt">;</span>
	ret_value <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
        <span class="hl kwa">if</span><span class="hl opt">(</span>buf <span class="hl opt">&amp;&amp;</span> bufsize<span class="hl opt">)</span>
	   <span class="hl kwd">HDstrncpy</span><span class="hl opt">(</span>buf<span class="hl opt">,</span> comment<span class="hl opt">.</span>s<span class="hl opt">,</span> bufsize<span class="hl opt">);</span>
	ret_value <span class="hl opt">= (</span><span class="hl kwb">int</span><span class="hl opt">)</span><span class="hl kwd">HDstrlen</span><span class="hl opt">(</span>comment<span class="hl opt">.</span>s<span class="hl opt">);</span>
	<span class="hl kwd">H5O_reset</span><span class="hl opt">(</span>H5O_NAME_ID<span class="hl opt">, &amp;</span>comment<span class="hl opt">);</span>
    <span class="hl opt">}</span>

done<span class="hl opt">:</span>
    <span class="hl com">/* Free the ID to name buffer */</span>
    <span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(&amp;</span>obj_ent<span class="hl opt">);</span>

    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_unlink</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Unlink a name from a group.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Non-negative on success/Negative on failure</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Thursday, September 17, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *      Pedro Vicente, &lt;pvn&#64;ncsa.uiuc.edu&gt; 18 Sep 2002</span>
<span class="hl com"> *      Added `id to name' support.</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> herr_t
<span class="hl kwd">H5G_unlink</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>loc<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_entry_t		grp_ent<span class="hl opt">,</span> obj_ent<span class="hl opt">;</span>
    <span class="hl kwb">const char</span>		<span class="hl opt">*</span>base<span class="hl opt">=</span>NULL<span class="hl opt">;</span>
    <span class="hl kwb">char</span>		<span class="hl opt">*</span>norm_name <span class="hl opt">=</span> NULL<span class="hl opt">;</span>	<span class="hl com">/* Pointer to normalized name */</span>
    H5G_obj_t           obj_type<span class="hl opt">;</span>       <span class="hl com">/* Object type */</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT</span><span class="hl opt">(</span>H5G_unlink<span class="hl opt">);</span>

    <span class="hl com">/* Sanity check */</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>loc<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>name <span class="hl opt">&amp;&amp; *</span>name<span class="hl opt">);</span>

    <span class="hl com">/* Get normalized copy of the name */</span>
    <span class="hl kwa">if</span><span class="hl opt">((</span>norm_name<span class="hl opt">=</span><span class="hl kwd">H5G_normalize</span><span class="hl opt">(</span>name<span class="hl opt">))==</span>NULL<span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_BADVALUE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;can't normalize name&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Reset the group entries to known values in a portable way */</span>
    <span class="hl kwd">H5G_ent_reset</span><span class="hl opt">(&amp;</span>grp_ent<span class="hl opt">);</span>
    <span class="hl kwd">H5G_ent_reset</span><span class="hl opt">(&amp;</span>obj_ent<span class="hl opt">);</span>

    <span class="hl com">/* Get the entry for the group that contains the object to be unlinked */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_namei</span><span class="hl opt">(</span>loc<span class="hl opt">,</span> norm_name<span class="hl opt">,</span> NULL<span class="hl opt">, &amp;</span>grp_ent<span class="hl opt">, &amp;</span>obj_ent<span class="hl opt">,</span>
		  H5G_TARGET_SLINK<span class="hl opt">|</span>H5G_TARGET_MOUNT<span class="hl opt">,</span> NULL<span class="hl opt">,</span> H5G_NAMEI_TRAVERSE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;object not found&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">H5F_addr_defined</span><span class="hl opt">(</span>grp_ent<span class="hl opt">.</span>header<span class="hl opt">))</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;no containing group specified&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>base<span class="hl opt">=</span><span class="hl kwd">H5G_basename</span><span class="hl opt">(</span>norm_name<span class="hl opt">,</span> NULL<span class="hl opt">)) ||</span> <span class="hl str">'/'</span><span class="hl opt">==*</span>base<span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;problems obtaining object base name&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Get object type before unlink */</span>
    <span class="hl kwa">if</span><span class="hl opt">((</span>obj_type <span class="hl opt">=</span> <span class="hl kwd">H5G_get_type</span><span class="hl opt">(&amp;</span>obj_ent<span class="hl opt">,</span> dxpl_id<span class="hl opt">)) &lt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;can't determine object type&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Remove the name from the symbol table */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_stab_remove</span><span class="hl opt">(&amp;</span>grp_ent<span class="hl opt">,</span> base<span class="hl opt">,</span> dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTDELETE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to unlink name from symbol table&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Search the open IDs and replace names for unlinked object */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_replace_name</span><span class="hl opt">(</span>obj_type<span class="hl opt">, &amp;</span>obj_ent<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> OP_UNLINK <span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTDELETE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to replace name&quot;</span><span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl com">/* Free the ID to name buffers */</span>
    <span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(&amp;</span>grp_ent<span class="hl opt">);</span>
    <span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(&amp;</span>obj_ent<span class="hl opt">);</span>

    <span class="hl com">/* Free the normalized path name */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>norm_name<span class="hl opt">)</span>
        <span class="hl kwd">H5MM_xfree</span><span class="hl opt">(</span>norm_name<span class="hl opt">);</span>

    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_move</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Atomically rename an object.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Non-negative on success/Negative on failure</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Friday, September 25, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *	Raymond Lu</span>
<span class="hl com"> *	Thursday, April 18, 2002</span>
<span class="hl com"> *</span>
<span class="hl com"> *      Pedro Vicente, &lt;pvn&#64;ncsa.uiuc.edu&gt; 22 Aug 2002</span>
<span class="hl com"> *      Added `id to name' support.</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> herr_t
<span class="hl kwd">H5G_move</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>src_loc<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>src_name<span class="hl opt">,</span> H5G_entry_t <span class="hl opt">*</span>dst_loc<span class="hl opt">,</span>
		<span class="hl kwb">const char</span> <span class="hl opt">*</span>dst_name<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_stat_t		sb<span class="hl opt">;</span>
    <span class="hl kwb">char</span>		<span class="hl opt">*</span>linkval<span class="hl opt">=</span>NULL<span class="hl opt">;</span>
    <span class="hl kwb">size_t</span>		lv_size<span class="hl opt">=</span><span class="hl num">32</span><span class="hl opt">;</span>
    H5G_entry_t         obj_ent<span class="hl opt">;</span>        <span class="hl com">/* Object entry for object being moved */</span>
    H5RS_str_t         <span class="hl opt">*</span>src_name_r<span class="hl opt">;</span>     <span class="hl com">/* Ref-counted version of src name */</span>
    H5RS_str_t         <span class="hl opt">*</span>dst_name_r<span class="hl opt">;</span>     <span class="hl com">/* Ref-counted version of dest name */</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>      <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT</span><span class="hl opt">(</span>H5G_move<span class="hl opt">);</span>

    <span class="hl com">/* Sanity check */</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>src_loc<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>dst_loc<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>src_name <span class="hl opt">&amp;&amp; *</span>src_name<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>dst_name <span class="hl opt">&amp;&amp; *</span>dst_name<span class="hl opt">);</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_get_objinfo</span><span class="hl opt">(</span>src_loc<span class="hl opt">,</span> src_name<span class="hl opt">,</span> FALSE<span class="hl opt">, &amp;</span>sb<span class="hl opt">,</span> dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;object not found&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>H5G_LINK<span class="hl opt">==</span>sb<span class="hl opt">.</span>type<span class="hl opt">) {</span>
	<span class="hl com">/*</span>
<span class="hl com">	 * When renaming a symbolic link we rename the link but don't change</span>
<span class="hl com">	 * the value of the link.</span>
<span class="hl com">	 */</span>
	<span class="hl kwa">do</span> <span class="hl opt">{</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span>linkval<span class="hl opt">=</span><span class="hl kwd">H5MM_realloc</span><span class="hl opt">(</span>linkval<span class="hl opt">,</span> <span class="hl num">2</span><span class="hl opt">*</span>lv_size<span class="hl opt">)))</span>
		<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_RESOURCE<span class="hl opt">,</span> H5E_NOSPACE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to allocate space for symbolic link value&quot;</span><span class="hl opt">);</span>
	    linkval<span class="hl opt">[</span>lv_size<span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">] =</span> <span class="hl str">'\0'</span><span class="hl opt">;</span>
	    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_linkval</span><span class="hl opt">(</span>src_loc<span class="hl opt">,</span> src_name<span class="hl opt">,</span> lv_size<span class="hl opt">,</span> linkval<span class="hl opt">,</span> dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
		<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to read symbolic link value&quot;</span><span class="hl opt">);</span>
	<span class="hl opt">}</span> <span class="hl kwa">while</span> <span class="hl opt">(</span>linkval<span class="hl opt">[</span>lv_size<span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">]);</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_link</span><span class="hl opt">(</span>src_loc<span class="hl opt">,</span> linkval<span class="hl opt">,</span> dst_loc<span class="hl opt">,</span> dst_name<span class="hl opt">,</span> H5G_LINK_SOFT<span class="hl opt">,</span>
		     H5G_TARGET_NORMAL<span class="hl opt">,</span> dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	    <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to rename symbolic link&quot;</span><span class="hl opt">);</span>
	<span class="hl kwd">H5MM_xfree</span><span class="hl opt">(</span>linkval<span class="hl opt">);</span>

    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
	<span class="hl com">/*</span>
<span class="hl com">	 * Rename the object.</span>
<span class="hl com">	 */</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_link</span><span class="hl opt">(</span>src_loc<span class="hl opt">,</span> src_name<span class="hl opt">,</span> dst_loc<span class="hl opt">,</span> dst_name<span class="hl opt">,</span> H5G_LINK_HARD<span class="hl opt">,</span>
		     H5G_TARGET_MOUNT<span class="hl opt">,</span> dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	    <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to register new name for object&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/* Search the open ID list and replace names for the move operation</span>
<span class="hl com">     * This has to be done here because H5G_link and H5G_unlink have</span>
<span class="hl com">     * internal object entries, and do not modify the entries list</span>
<span class="hl com">    */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_namei</span><span class="hl opt">(</span>src_loc<span class="hl opt">,</span> src_name<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">, &amp;</span>obj_ent<span class="hl opt">,</span> H5G_TARGET_NORMAL<span class="hl opt">|</span>H5G_TARGET_SLINK<span class="hl opt">,</span> NULL<span class="hl opt">,</span> H5G_NAMEI_TRAVERSE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> dxpl_id<span class="hl opt">))</span>
	<span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to follow symbolic link&quot;</span><span class="hl opt">);</span>
    src_name_r<span class="hl opt">=</span><span class="hl kwd">H5RS_wrap</span><span class="hl opt">(</span>src_name<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>src_name_r<span class="hl opt">);</span>
    dst_name_r<span class="hl opt">=</span><span class="hl kwd">H5RS_wrap</span><span class="hl opt">(</span>dst_name<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>dst_name_r<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_replace_name</span><span class="hl opt">(</span>sb<span class="hl opt">.</span>type<span class="hl opt">, &amp;</span>obj_ent<span class="hl opt">,</span> src_name_r<span class="hl opt">,</span> src_loc<span class="hl opt">,</span> dst_name_r<span class="hl opt">,</span> dst_loc<span class="hl opt">,</span> OP_MOVE <span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to replace name &quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">H5RS_decr</span><span class="hl opt">(</span>src_name_r<span class="hl opt">);</span>
    <span class="hl kwd">H5RS_decr</span><span class="hl opt">(</span>dst_name_r<span class="hl opt">);</span>
    <span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(&amp;</span>obj_ent<span class="hl opt">);</span>

    <span class="hl com">/* Remove the old name */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_unlink</span><span class="hl opt">(</span>src_loc<span class="hl opt">,</span> src_name<span class="hl opt">,</span> dxpl_id<span class="hl opt">)&lt;</span><span class="hl num">0</span><span class="hl opt">)</span>
	<span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unable to deregister old object name&quot;</span><span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_insertion_file</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Given a location and name that specifies a not-yet-existing</span>
<span class="hl com"> *		object return the file into which the object is about to be</span>
<span class="hl com"> *		inserted.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success:	File pointer</span>
<span class="hl com"> *</span>
<span class="hl com"> *		Failure:	NULL</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Robb Matzke</span>
<span class="hl com"> *              Wednesday, October 14, 1998</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *      Pedro Vicente, &lt;pvn&#64;ncsa.uiuc.edu&gt; 18 Sep 2002</span>
<span class="hl com"> *      Added `id to name' support.</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
H5F_t <span class="hl opt">*</span>
<span class="hl kwd">H5G_insertion_file</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>loc<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> hid_t dxpl_id<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5F_t      <span class="hl opt">*</span>ret_value<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI</span><span class="hl opt">(</span>H5G_insertion_file<span class="hl opt">,</span> NULL<span class="hl opt">);</span>

    <span class="hl kwa">assert</span><span class="hl opt">(</span>loc<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>name <span class="hl opt">&amp;&amp; *</span>name<span class="hl opt">);</span>

    <span class="hl com">/* Check if the location the object will be inserted into is part of a</span>
<span class="hl com">     * file mounting chain (either a parent or a child) and perform a more</span>
<span class="hl com">     * rigorous determination of the location's file (which traverses into</span>
<span class="hl com">     * mounted files, etc.).</span>
<span class="hl com">     */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5F_has_mount</span><span class="hl opt">(</span>loc<span class="hl opt">-&gt;</span>file<span class="hl opt">) ||</span> <span class="hl kwd">H5F_is_mount</span><span class="hl opt">(</span>loc<span class="hl opt">-&gt;</span>file<span class="hl opt">)) {</span>
        <span class="hl kwb">const char</span>	<span class="hl opt">*</span>rest<span class="hl opt">;</span>
        H5G_entry_t	grp_ent<span class="hl opt">;</span>
        <span class="hl kwb">size_t</span>	size<span class="hl opt">;</span>

        <span class="hl com">/*</span>
<span class="hl com">         * Look up the name to get the containing group and to make sure the name</span>
<span class="hl com">         * doesn't already exist.</span>
<span class="hl com">         */</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">H5G_namei</span><span class="hl opt">(</span>loc<span class="hl opt">,</span> name<span class="hl opt">, &amp;</span>rest<span class="hl opt">, &amp;</span>grp_ent<span class="hl opt">,</span> NULL<span class="hl opt">,</span> H5G_TARGET_NORMAL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> H5G_NAMEI_TRAVERSE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> dxpl_id<span class="hl opt">)&gt;=</span><span class="hl num">0</span><span class="hl opt">) {</span>
            <span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(&amp;</span>grp_ent<span class="hl opt">);</span>
            <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_EXISTS<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;name already exists&quot;</span><span class="hl opt">);</span>
        <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
        <span class="hl kwd">H5E_clear_stack</span><span class="hl opt">(</span>NULL<span class="hl opt">);</span>

        <span class="hl com">/* Make sure only the last component wasn't resolved */</span>
        rest <span class="hl opt">=</span> <span class="hl kwd">H5G_component</span><span class="hl opt">(</span>rest<span class="hl opt">, &amp;</span>size<span class="hl opt">);</span>
        <span class="hl kwa">assert</span><span class="hl opt">(*</span>rest <span class="hl opt">&amp;&amp;</span> size<span class="hl opt">&gt;</span><span class="hl num">0</span><span class="hl opt">);</span>
        rest <span class="hl opt">=</span> <span class="hl kwd">H5G_component</span><span class="hl opt">(</span>rest<span class="hl opt">+</span>size<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(*</span>rest<span class="hl opt">) {</span>
            <span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(&amp;</span>grp_ent<span class="hl opt">);</span>
            <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_NOTFOUND<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;insertion point not found&quot;</span><span class="hl opt">);</span>
        <span class="hl opt">}</span> <span class="hl com">/* end if */</span>

        <span class="hl com">/* Set return value */</span>
        ret_value<span class="hl opt">=</span>grp_ent<span class="hl opt">.</span>file<span class="hl opt">;</span>

        <span class="hl com">/* Free the ID to name buffer */</span>
        <span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(&amp;</span>grp_ent<span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
    <span class="hl kwa">else</span>
        <span class="hl com">/* Use the location's file */</span>
        ret_value<span class="hl opt">=</span>loc<span class="hl opt">-&gt;</span>file<span class="hl opt">;</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_free_grp_name</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Free the 'ID to name' buffers.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Non-negative on success/Negative on failure</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer: Pedro Vicente, pvn&#64;ncsa.uiuc.edu</span>
<span class="hl com"> *</span>
<span class="hl com"> * Date: August 22, 2002</span>
<span class="hl com"> *</span>
<span class="hl com"> * Comments: Used now only on the root group close, in H5F_close()</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
herr_t
<span class="hl kwd">H5G_free_grp_name</span><span class="hl opt">(</span>H5G_t <span class="hl opt">*</span>grp<span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_entry_t <span class="hl opt">*</span>ent<span class="hl opt">;</span>           <span class="hl com">/* Group object's entry */</span>
    herr_t ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>   <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI</span><span class="hl opt">(</span>H5G_free_grp_name<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>

    <span class="hl com">/* Check args */</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>grp <span class="hl opt">&amp;&amp;</span> grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">-&gt;</span>fo_count <span class="hl opt">&gt;</span> <span class="hl num">0</span><span class="hl opt">);</span>

    <span class="hl com">/* Get the entry for the group */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>NULL<span class="hl opt">==(</span> ent <span class="hl opt">=</span> <span class="hl kwd">H5G_entof</span><span class="hl opt">(</span>grp<span class="hl opt">)))</span>
        <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_CANTINIT<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;cannot get entry&quot;</span><span class="hl opt">);</span>

    <span class="hl com">/* Free the entry */</span>
    <span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(</span>ent<span class="hl opt">);</span>

done<span class="hl opt">:</span>
     <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_free_ent_name</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Free the 'ID to name' buffers.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Success</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer: Pedro Vicente, pvn&#64;ncsa.uiuc.edu</span>
<span class="hl com"> *</span>
<span class="hl com"> * Date: August 22, 2002</span>
<span class="hl com"> *</span>
<span class="hl com"> * Comments:</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
herr_t
<span class="hl kwd">H5G_free_ent_name</span><span class="hl opt">(</span>H5G_entry_t <span class="hl opt">*</span>ent<span class="hl opt">)</span>
<span class="hl opt">{</span>
    herr_t      ret_value<span class="hl opt">=</span>SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI</span><span class="hl opt">(</span>H5G_free_ent_name<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>

    <span class="hl com">/* Check args */</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>ent<span class="hl opt">);</span>

    <span class="hl kwa">if</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">) {</span>
        <span class="hl kwd">H5RS_decr</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">);</span>
        ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">=</span>NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>canon_path_r<span class="hl opt">) {</span>
        <span class="hl kwd">H5RS_decr</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>canon_path_r<span class="hl opt">);</span>
        ent<span class="hl opt">-&gt;</span>canon_path_r<span class="hl opt">=</span>NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function: H5G_replace_name</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose: Search the list of open IDs and replace names according to a</span>
<span class="hl com"> *              particular operation.  The operation occured on the LOC</span>
<span class="hl com"> *              entry, which had SRC_NAME previously.  The new name (if there</span>
<span class="hl com"> *              is one) is DST_NAME.  Additional entry location information</span>
<span class="hl com"> *              (currently only needed for the 'move' operation) is passed</span>
<span class="hl com"> *              in SRC_LOC and DST_LOC.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return: Success: 0, Failure: -1</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer: Pedro Vicente, pvn&#64;ncsa.uiuc.edu</span>
<span class="hl com"> *</span>
<span class="hl com"> * Date: June 11, 2002</span>
<span class="hl com"> *</span>
<span class="hl com"> * Comments:</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
herr_t
<span class="hl kwd">H5G_replace_name</span><span class="hl opt">(</span>H5G_obj_t type<span class="hl opt">,</span> H5G_entry_t <span class="hl opt">*</span>loc<span class="hl opt">,</span>
    H5RS_str_t <span class="hl opt">*</span>src_name<span class="hl opt">,</span> H5G_entry_t <span class="hl opt">*</span>src_loc<span class="hl opt">,</span>
    H5RS_str_t <span class="hl opt">*</span>dst_name<span class="hl opt">,</span> H5G_entry_t <span class="hl opt">*</span>dst_loc<span class="hl opt">,</span> H5G_names_op_t op <span class="hl opt">)</span>
<span class="hl opt">{</span>
    H5G_names_t names<span class="hl opt">;</span>          <span class="hl com">/* Structure to hold operation information for callback */</span>
    <span class="hl kwb">unsigned</span> search_group<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">;</span>    <span class="hl com">/* Flag to indicate that groups are to be searched */</span>
    <span class="hl kwb">unsigned</span> search_dataset<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">;</span>  <span class="hl com">/* Flag to indicate that datasets are to be searched */</span>
    <span class="hl kwb">unsigned</span> search_datatype<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">;</span> <span class="hl com">/* Flag to indicate that datatypes are to be searched */</span>
    herr_t  ret_value <span class="hl opt">=</span> SUCCEED<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI</span><span class="hl opt">(</span>H5G_replace_name<span class="hl opt">,</span> FAIL<span class="hl opt">);</span>

    <span class="hl com">/* Set up common information for callback */</span>
    names<span class="hl opt">.</span>src_name<span class="hl opt">=</span>src_name<span class="hl opt">;</span>
    names<span class="hl opt">.</span>dst_name<span class="hl opt">=</span>dst_name<span class="hl opt">;</span>
    names<span class="hl opt">.</span>loc<span class="hl opt">=</span>loc<span class="hl opt">;</span>
    names<span class="hl opt">.</span>src_loc<span class="hl opt">=</span>src_loc<span class="hl opt">;</span>
    names<span class="hl opt">.</span>dst_loc<span class="hl opt">=</span>dst_loc<span class="hl opt">;</span>
    names<span class="hl opt">.</span>op<span class="hl opt">=</span>op<span class="hl opt">;</span>

    <span class="hl com">/* Determine which types of IDs need to be operated on */</span>
    <span class="hl kwa">switch</span><span class="hl opt">(</span>type<span class="hl opt">) {</span>
        <span class="hl com">/* Object is a group  */</span>
        <span class="hl kwa">case</span> H5G_GROUP<span class="hl opt">:</span>
            <span class="hl com">/* Search and replace names through group IDs */</span>
            search_group<span class="hl opt">=</span><span class="hl num">1</span><span class="hl opt">;</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>

        <span class="hl com">/* Object is a dataset */</span>
        <span class="hl kwa">case</span> H5G_DATASET<span class="hl opt">:</span>
            <span class="hl com">/* Search and replace names through dataset IDs */</span>
            search_dataset<span class="hl opt">=</span><span class="hl num">1</span><span class="hl opt">;</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>

        <span class="hl com">/* Object is a named datatype */</span>
        <span class="hl kwa">case</span> H5G_TYPE<span class="hl opt">:</span>
            <span class="hl com">/* Search and replace names through datatype IDs */</span>
            search_datatype<span class="hl opt">=</span><span class="hl num">1</span><span class="hl opt">;</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>

        <span class="hl kwa">case</span> H5G_UNKNOWN<span class="hl opt">:</span>   <span class="hl com">/* We pass H5G_UNKNOWN as object type when we need to search all IDs */</span>
        <span class="hl kwa">case</span> H5G_LINK<span class="hl opt">:</span>      <span class="hl com">/* Symbolic links might resolve to any object, so we need to search all IDs */</span>
            <span class="hl com">/* Check if we will need to search groups */</span>
            <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5I_nmembers</span><span class="hl opt">(</span>H5I_GROUP<span class="hl opt">)&gt;</span><span class="hl num">0</span><span class="hl opt">)</span>
                search_group<span class="hl opt">=</span><span class="hl num">1</span><span class="hl opt">;</span>

            <span class="hl com">/* Check if we will need to search datasets */</span>
            <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5I_nmembers</span><span class="hl opt">(</span>H5I_DATASET<span class="hl opt">)&gt;</span><span class="hl num">0</span><span class="hl opt">)</span>
                search_dataset<span class="hl opt">=</span><span class="hl num">1</span><span class="hl opt">;</span>

            <span class="hl com">/* Check if we will need to search datatypes */</span>
            <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5I_nmembers</span><span class="hl opt">(</span>H5I_DATATYPE<span class="hl opt">)&gt;</span><span class="hl num">0</span><span class="hl opt">)</span>
                search_datatype<span class="hl opt">=</span><span class="hl num">1</span><span class="hl opt">;</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>

        <span class="hl kwa">default</span><span class="hl opt">:</span>
            <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_DATATYPE<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;not valid object type&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl com">/* end switch */</span>

    <span class="hl com">/* Search through group IDs */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>search_group<span class="hl opt">)</span>
        <span class="hl kwd">H5I_search</span><span class="hl opt">(</span>H5I_GROUP<span class="hl opt">,</span> H5G_replace_ent<span class="hl opt">, &amp;</span>names<span class="hl opt">);</span>

    <span class="hl com">/* Search through dataset IDs */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>search_dataset<span class="hl opt">)</span>
        <span class="hl kwd">H5I_search</span><span class="hl opt">(</span>H5I_DATASET<span class="hl opt">,</span> H5G_replace_ent<span class="hl opt">, &amp;</span>names<span class="hl opt">);</span>

    <span class="hl com">/* Search through datatype IDs */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>search_datatype<span class="hl opt">)</span>
        <span class="hl kwd">H5I_search</span><span class="hl opt">(</span>H5I_DATATYPE<span class="hl opt">,</span> H5G_replace_ent<span class="hl opt">, &amp;</span>names<span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function: H5G_common_path</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose: Determine if one path is a valid prefix of another path</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return: TRUE for valid prefix, FALSE for not a valid prefix, FAIL</span>
<span class="hl com"> *              on error</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer: Quincey Koziol, koziol&#64;ncsa.uiuc.edu</span>
<span class="hl com"> *</span>
<span class="hl com"> * Date: September 24, 2002</span>
<span class="hl com"> *</span>
<span class="hl com"> * Comments:</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> htri_t
<span class="hl kwd">H5G_common_path</span><span class="hl opt">(</span><span class="hl kwb">const</span> H5RS_str_t <span class="hl opt">*</span>fullpath_r<span class="hl opt">,</span> <span class="hl kwb">const</span> H5RS_str_t <span class="hl opt">*</span>prefix_r<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>fullpath<span class="hl opt">;</span>       <span class="hl com">/* Pointer to actual fullpath string */</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>prefix<span class="hl opt">;</span>         <span class="hl com">/* Pointer to actual prefix string */</span>
    <span class="hl kwb">size_t</span>  nchars1<span class="hl opt">,</span>nchars2<span class="hl opt">;</span>    <span class="hl com">/* Number of characters in components */</span>
    htri_t ret_value<span class="hl opt">=</span>FALSE<span class="hl opt">;</span>     <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT_NOFUNC</span><span class="hl opt">(</span>H5G_common_path<span class="hl opt">);</span>

    <span class="hl com">/* Get component of each name */</span>
    fullpath<span class="hl opt">=</span><span class="hl kwd">H5RS_get_str</span><span class="hl opt">(</span>fullpath_r<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>fullpath<span class="hl opt">);</span>
    fullpath<span class="hl opt">=</span><span class="hl kwd">H5G_component</span><span class="hl opt">(</span>fullpath<span class="hl opt">,&amp;</span>nchars1<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>fullpath<span class="hl opt">);</span>
    prefix<span class="hl opt">=</span><span class="hl kwd">H5RS_get_str</span><span class="hl opt">(</span>prefix_r<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>prefix<span class="hl opt">);</span>
    prefix<span class="hl opt">=</span><span class="hl kwd">H5G_component</span><span class="hl opt">(</span>prefix<span class="hl opt">,&amp;</span>nchars2<span class="hl opt">);</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>prefix<span class="hl opt">);</span>

    <span class="hl com">/* Check if we have a real string for each component */</span>
    <span class="hl kwa">while</span><span class="hl opt">(*</span>fullpath <span class="hl opt">&amp;&amp; *</span>prefix<span class="hl opt">) {</span>
        <span class="hl com">/* Check that the components we found are the same length */</span>
        <span class="hl kwa">if</span><span class="hl opt">(</span>nchars1<span class="hl opt">==</span>nchars2<span class="hl opt">) {</span>
            <span class="hl com">/* Check that the two components are equal */</span>
            <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">HDstrncmp</span><span class="hl opt">(</span>fullpath<span class="hl opt">,</span>prefix<span class="hl opt">,</span>nchars1<span class="hl opt">)==</span><span class="hl num">0</span><span class="hl opt">) {</span>
                <span class="hl com">/* Advance the pointers in the names */</span>
                fullpath<span class="hl opt">+=</span>nchars1<span class="hl opt">;</span>
                prefix<span class="hl opt">+=</span>nchars2<span class="hl opt">;</span>

                <span class="hl com">/* Get next component of each name */</span>
                fullpath<span class="hl opt">=</span><span class="hl kwd">H5G_component</span><span class="hl opt">(</span>fullpath<span class="hl opt">,&amp;</span>nchars1<span class="hl opt">);</span>
                <span class="hl kwa">assert</span><span class="hl opt">(</span>fullpath<span class="hl opt">);</span>
                prefix<span class="hl opt">=</span><span class="hl kwd">H5G_component</span><span class="hl opt">(</span>prefix<span class="hl opt">,&amp;</span>nchars2<span class="hl opt">);</span>
                <span class="hl kwa">assert</span><span class="hl opt">(</span>prefix<span class="hl opt">);</span>
            <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
            <span class="hl kwa">else</span>
                <span class="hl kwd">HGOTO_DONE</span><span class="hl opt">(</span>FALSE<span class="hl opt">);</span>
        <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
        <span class="hl kwa">else</span>
            <span class="hl kwd">HGOTO_DONE</span><span class="hl opt">(</span>FALSE<span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl com">/* end while */</span>

    <span class="hl com">/* If we reached the end of the prefix path to check, it must be a valid prefix */</span>
    <span class="hl kwa">if</span><span class="hl opt">(*</span>prefix<span class="hl opt">==</span><span class="hl str">'\0'</span><span class="hl opt">)</span>
        ret_value<span class="hl opt">=</span>TRUE<span class="hl opt">;</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function: H5G_build_fullpath</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose: Build a full path from a prefix &amp; base pair of reference counted</span>
<span class="hl com"> *              strings</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return: Pointer to reference counted string on success, NULL on error</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer: Quincey Koziol, koziol&#64;ncsa.uiuc.edu</span>
<span class="hl com"> *</span>
<span class="hl com"> * Date: August 19, 2005</span>
<span class="hl com"> *</span>
<span class="hl com"> * Comments:</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> H5RS_str_t <span class="hl opt">*</span>
<span class="hl kwd">H5G_build_fullpath</span><span class="hl opt">(</span><span class="hl kwb">const</span> H5RS_str_t <span class="hl opt">*</span>prefix_r<span class="hl opt">,</span> <span class="hl kwb">const</span> H5RS_str_t <span class="hl opt">*</span>name_r<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>prefix<span class="hl opt">;</span>         <span class="hl com">/* Pointer to raw string of prefix */</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">;</span>           <span class="hl com">/* Pointer to raw string of name */</span>
    <span class="hl kwb">char</span> <span class="hl opt">*</span>full_path<span class="hl opt">;</span>            <span class="hl com">/* Full user path built */</span>
    <span class="hl kwb">size_t</span> path_len<span class="hl opt">;</span>            <span class="hl com">/* Length of the path */</span>
    <span class="hl kwb">unsigned</span> need_sep<span class="hl opt">;</span>          <span class="hl com">/* Flag to indicate if separator is needed */</span>
    H5RS_str_t <span class="hl opt">*</span>ret_value<span class="hl opt">;</span>      <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT</span><span class="hl opt">(</span>H5G_build_fullpath<span class="hl opt">)</span>

    <span class="hl com">/* Get the pointer to the prefix */</span>
    prefix<span class="hl opt">=</span><span class="hl kwd">H5RS_get_str</span><span class="hl opt">(</span>prefix_r<span class="hl opt">);</span>

    <span class="hl com">/* Get the length of the prefix */</span>
    path_len<span class="hl opt">=</span><span class="hl kwd">HDstrlen</span><span class="hl opt">(</span>prefix<span class="hl opt">);</span>

    <span class="hl com">/* Determine if there is a trailing separator in the name */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>prefix<span class="hl opt">[</span>path_len<span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">]==</span><span class="hl str">'/'</span><span class="hl opt">)</span>
        need_sep<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl kwa">else</span>
        need_sep<span class="hl opt">=</span><span class="hl num">1</span><span class="hl opt">;</span>

    <span class="hl com">/* Get the pointer to the raw src user path */</span>
    name<span class="hl opt">=</span><span class="hl kwd">H5RS_get_str</span><span class="hl opt">(</span>name_r<span class="hl opt">);</span>

    <span class="hl com">/* Add in the length needed for the '/' separator and the relative path */</span>
    path_len<span class="hl opt">+=</span><span class="hl kwd">HDstrlen</span><span class="hl opt">(</span>name<span class="hl opt">)+</span>need_sep<span class="hl opt">;</span>

    <span class="hl com">/* Allocate space for the path */</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>NULL<span class="hl opt">==(</span>full_path <span class="hl opt">=</span> <span class="hl kwd">H5FL_BLK_MALLOC</span><span class="hl opt">(</span>str_buf<span class="hl opt">,</span>path_len<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">)))</span>
        <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_RESOURCE<span class="hl opt">,</span> H5E_NOSPACE<span class="hl opt">,</span> NULL<span class="hl opt">,</span> <span class="hl str">&quot;memory allocation failed&quot;</span><span class="hl opt">)</span>

    <span class="hl com">/* Build full path */</span>
    <span class="hl kwd">HDstrcpy</span><span class="hl opt">(</span>full_path<span class="hl opt">,</span>prefix<span class="hl opt">);</span>
    <span class="hl kwa">if</span><span class="hl opt">(</span>need_sep<span class="hl opt">)</span>
        <span class="hl kwd">HDstrcat</span><span class="hl opt">(</span>full_path<span class="hl opt">,</span><span class="hl str">&quot;/&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">HDstrcat</span><span class="hl opt">(</span>full_path<span class="hl opt">,</span>name<span class="hl opt">);</span>

    <span class="hl com">/* Create reference counted string for path */</span>
    ret_value<span class="hl opt">=</span><span class="hl kwd">H5RS_own</span><span class="hl opt">(</span>full_path<span class="hl opt">);</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">)</span>
<span class="hl opt">}</span> <span class="hl com">/* end H5G_build_fullpath() */</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function: H5G_replace_ent</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose: H5I_search callback function to replace group entry names</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return: Success: 0, Failure: -1</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer: Pedro Vicente, pvn&#64;ncsa.uiuc.edu</span>
<span class="hl com"> *</span>
<span class="hl com"> * Date: June 5, 2002</span>
<span class="hl com"> *</span>
<span class="hl com"> * Comments:</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
<span class="hl kwb">static int</span>
<span class="hl kwd">H5G_replace_ent</span><span class="hl opt">(</span><span class="hl kwb">void</span> <span class="hl opt">*</span>obj_ptr<span class="hl opt">,</span> hid_t obj_id<span class="hl opt">,</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>key<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">const</span> H5G_names_t <span class="hl opt">*</span>names <span class="hl opt">= (</span><span class="hl kwb">const</span> H5G_names_t <span class="hl opt">*)</span>key<span class="hl opt">;</span>        <span class="hl com">/* Get operation's information */</span>
    H5G_entry_t <span class="hl opt">*</span>ent <span class="hl opt">=</span> NULL<span class="hl opt">;</span>    <span class="hl com">/* Group entry for object that the ID refers to */</span>
    H5F_t <span class="hl opt">*</span>top_ent_file<span class="hl opt">;</span>        <span class="hl com">/* Top file in entry's mounted file chain */</span>
    H5F_t <span class="hl opt">*</span>top_loc_file<span class="hl opt">;</span>        <span class="hl com">/* Top file in location's mounted file chain */</span>
    herr_t      ret_value <span class="hl opt">=</span> SUCCEED<span class="hl opt">;</span>       <span class="hl com">/* Return value */</span>

    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT</span><span class="hl opt">(</span>H5G_replace_ent<span class="hl opt">);</span>

    <span class="hl kwa">assert</span><span class="hl opt">(</span>obj_ptr<span class="hl opt">);</span>

    <span class="hl com">/* Get the symbol table entry */</span>
    <span class="hl kwa">switch</span><span class="hl opt">(</span><span class="hl kwd">H5I_get_type</span><span class="hl opt">(</span>obj_id<span class="hl opt">)) {</span>
        <span class="hl kwa">case</span> H5I_GROUP<span class="hl opt">:</span>
            ent <span class="hl opt">=</span> <span class="hl kwd">H5G_entof</span><span class="hl opt">((</span>H5G_t<span class="hl opt">*)</span>obj_ptr<span class="hl opt">);</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>

        <span class="hl kwa">case</span> H5I_DATASET<span class="hl opt">:</span>
            ent <span class="hl opt">=</span> <span class="hl kwd">H5D_entof</span><span class="hl opt">((</span>H5D_t<span class="hl opt">*)</span>obj_ptr<span class="hl opt">);</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>

        <span class="hl kwa">case</span> H5I_DATATYPE<span class="hl opt">:</span>
            <span class="hl com">/* Avoid non-named datatypes */</span>
            <span class="hl kwa">if</span><span class="hl opt">(!</span><span class="hl kwd">H5T_is_named</span><span class="hl opt">((</span>H5T_t<span class="hl opt">*)</span>obj_ptr<span class="hl opt">))</span>
                <span class="hl kwd">HGOTO_DONE</span><span class="hl opt">(</span>SUCCEED<span class="hl opt">);</span> <span class="hl com">/* Do not exit search over IDs */</span>

            ent <span class="hl opt">=</span> <span class="hl kwd">H5T_entof</span><span class="hl opt">((</span>H5T_t<span class="hl opt">*)</span>obj_ptr<span class="hl opt">);</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>

        <span class="hl kwa">default</span><span class="hl opt">:</span>
            <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;unknown data object&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl com">/* end switch */</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>ent<span class="hl opt">);</span>

    <span class="hl kwa">switch</span><span class="hl opt">(</span>names<span class="hl opt">-&gt;</span>op<span class="hl opt">) {</span>
        <span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com">        * OP_MOUNT</span>
<span class="hl com">        *-------------------------------------------------------------------------</span>
<span class="hl com">        */</span>
        <span class="hl kwa">case</span> OP_MOUNT<span class="hl opt">:</span>
	    <span class="hl kwa">if</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">) {</span>
		<span class="hl kwa">if</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>file<span class="hl opt">-&gt;</span>mtab<span class="hl opt">.</span>parent <span class="hl opt">&amp;&amp;</span> <span class="hl kwd">H5RS_cmp</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">,</span>ent<span class="hl opt">-&gt;</span>canon_path_r<span class="hl opt">)) {</span>
		    <span class="hl com">/* Find the &quot;top&quot; file in the chain of mounted files */</span>
		    top_ent_file<span class="hl opt">=</span>ent<span class="hl opt">-&gt;</span>file<span class="hl opt">-&gt;</span>mtab<span class="hl opt">.</span>parent<span class="hl opt">;</span>
		    <span class="hl kwa">while</span><span class="hl opt">(</span>top_ent_file<span class="hl opt">-&gt;</span>mtab<span class="hl opt">.</span>parent<span class="hl opt">!=</span>NULL<span class="hl opt">)</span>
			top_ent_file<span class="hl opt">=</span>top_ent_file<span class="hl opt">-&gt;</span>mtab<span class="hl opt">.</span>parent<span class="hl opt">;</span>
		<span class="hl opt">}</span> <span class="hl com">/* end if */</span>
		<span class="hl kwa">else</span>
		    top_ent_file<span class="hl opt">=</span>ent<span class="hl opt">-&gt;</span>file<span class="hl opt">;</span>

		<span class="hl com">/* Check for entry being in correct file (or mounted file) */</span>
		<span class="hl kwa">if</span><span class="hl opt">(</span>top_ent_file<span class="hl opt">-&gt;</span>shared <span class="hl opt">==</span> names<span class="hl opt">-&gt;</span>loc<span class="hl opt">-&gt;</span>file<span class="hl opt">-&gt;</span>shared<span class="hl opt">) {</span>
		    <span class="hl com">/* Check if the source is along the entry's path */</span>
		    <span class="hl com">/* (But not actually the entry itself) */</span>
		    <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5G_common_path</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">,</span>names<span class="hl opt">-&gt;</span>src_name<span class="hl opt">) &amp;&amp;</span>
			    <span class="hl kwd">H5RS_cmp</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">,</span>names<span class="hl opt">-&gt;</span>src_name<span class="hl opt">)!=</span><span class="hl num">0</span><span class="hl opt">) {</span>
			<span class="hl com">/* Hide the user path */</span>
			ent<span class="hl opt">-&gt;</span>user_path_hidden<span class="hl opt">++;</span>
		    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
		<span class="hl opt">}</span> <span class="hl com">/* end if */</span>
	    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>

        <span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com">        * OP_UNMOUNT</span>
<span class="hl com">        *-------------------------------------------------------------------------</span>
<span class="hl com">        */</span>
        <span class="hl kwa">case</span> OP_UNMOUNT<span class="hl opt">:</span>
	    <span class="hl kwa">if</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">) {</span>
		<span class="hl kwa">if</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>file<span class="hl opt">-&gt;</span>mtab<span class="hl opt">.</span>parent<span class="hl opt">) {</span>
		    <span class="hl com">/* Find the &quot;top&quot; file in the chain of mounted files for the entry */</span>
		    top_ent_file<span class="hl opt">=</span>ent<span class="hl opt">-&gt;</span>file<span class="hl opt">-&gt;</span>mtab<span class="hl opt">.</span>parent<span class="hl opt">;</span>
		    <span class="hl kwa">while</span><span class="hl opt">(</span>top_ent_file<span class="hl opt">-&gt;</span>mtab<span class="hl opt">.</span>parent<span class="hl opt">!=</span>NULL<span class="hl opt">)</span>
			top_ent_file<span class="hl opt">=</span>top_ent_file<span class="hl opt">-&gt;</span>mtab<span class="hl opt">.</span>parent<span class="hl opt">;</span>
		<span class="hl opt">}</span> <span class="hl com">/* end if */</span>
		<span class="hl kwa">else</span>
		    top_ent_file<span class="hl opt">=</span>ent<span class="hl opt">-&gt;</span>file<span class="hl opt">;</span>

		<span class="hl kwa">if</span><span class="hl opt">(</span>names<span class="hl opt">-&gt;</span>loc<span class="hl opt">-&gt;</span>file<span class="hl opt">-&gt;</span>mtab<span class="hl opt">.</span>parent<span class="hl opt">) {</span>
		    <span class="hl com">/* Find the &quot;top&quot; file in the chain of mounted files for the location */</span>
		    top_loc_file<span class="hl opt">=</span>names<span class="hl opt">-&gt;</span>loc<span class="hl opt">-&gt;</span>file<span class="hl opt">-&gt;</span>mtab<span class="hl opt">.</span>parent<span class="hl opt">;</span>
		    <span class="hl kwa">while</span><span class="hl opt">(</span>top_loc_file<span class="hl opt">-&gt;</span>mtab<span class="hl opt">.</span>parent<span class="hl opt">!=</span>NULL<span class="hl opt">)</span>
			top_loc_file<span class="hl opt">=</span>top_loc_file<span class="hl opt">-&gt;</span>mtab<span class="hl opt">.</span>parent<span class="hl opt">;</span>
		<span class="hl opt">}</span> <span class="hl com">/* end if */</span>
		<span class="hl kwa">else</span>
		    top_loc_file<span class="hl opt">=</span>names<span class="hl opt">-&gt;</span>loc<span class="hl opt">-&gt;</span>file<span class="hl opt">;</span>

		<span class="hl com">/* If the ID's entry is not in the file we operated on, skip it */</span>
		<span class="hl kwa">if</span><span class="hl opt">(</span>top_ent_file<span class="hl opt">-&gt;</span>shared <span class="hl opt">==</span> top_loc_file<span class="hl opt">-&gt;</span>shared<span class="hl opt">) {</span>
		    <span class="hl kwa">if</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>user_path_hidden<span class="hl opt">) {</span>
			<span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5G_common_path</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">,</span>names<span class="hl opt">-&gt;</span>src_name<span class="hl opt">)) {</span>
			    <span class="hl com">/* Un-hide the user path */</span>
			    ent<span class="hl opt">-&gt;</span>user_path_hidden<span class="hl opt">--;</span>
			<span class="hl opt">}</span> <span class="hl com">/* end if */</span>
		    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
		    <span class="hl kwa">else</span> <span class="hl opt">{</span>
			<span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5G_common_path</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">,</span>names<span class="hl opt">-&gt;</span>src_name<span class="hl opt">)) {</span>
			    <span class="hl com">/* Free user path */</span>
			    <span class="hl kwd">H5RS_decr</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">);</span>
			    ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">=</span>NULL<span class="hl opt">;</span>
			<span class="hl opt">}</span> <span class="hl com">/* end if */</span>
		    <span class="hl opt">}</span> <span class="hl com">/* end else */</span>
		<span class="hl opt">}</span> <span class="hl com">/* end if */</span>
	    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>

        <span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com">        * OP_UNLINK</span>
<span class="hl com">        *-------------------------------------------------------------------------</span>
<span class="hl com">        */</span>
        <span class="hl kwa">case</span> OP_UNLINK<span class="hl opt">:</span>
            <span class="hl com">/* If the ID's entry is not in the file we operated on, skip it */</span>
            <span class="hl kwa">if</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>file<span class="hl opt">-&gt;</span>shared <span class="hl opt">==</span> names<span class="hl opt">-&gt;</span>loc<span class="hl opt">-&gt;</span>file<span class="hl opt">-&gt;</span>shared <span class="hl opt">&amp;&amp;</span> 
                    names<span class="hl opt">-&gt;</span>loc<span class="hl opt">-&gt;</span>canon_path_r <span class="hl opt">&amp;&amp;</span> ent<span class="hl opt">-&gt;</span>canon_path_r <span class="hl opt">&amp;&amp;</span> ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">) {</span>
                <span class="hl com">/* Check if we are referring to the same object */</span>
                <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5F_addr_eq</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>header<span class="hl opt">,</span> names<span class="hl opt">-&gt;</span>loc<span class="hl opt">-&gt;</span>header<span class="hl opt">)) {</span>
                    <span class="hl com">/* Check if the object was opened with the same canonical path as the one being moved */</span>
                    <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5RS_cmp</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>canon_path_r<span class="hl opt">,</span>names<span class="hl opt">-&gt;</span>loc<span class="hl opt">-&gt;</span>canon_path_r<span class="hl opt">)==</span><span class="hl num">0</span><span class="hl opt">) {</span>
                        <span class="hl com">/* Free user path */</span>
			<span class="hl kwd">H5RS_decr</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">);</span>
			ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">=</span>NULL<span class="hl opt">;</span>
                    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
                <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
                <span class="hl kwa">else</span> <span class="hl opt">{</span>
                    <span class="hl com">/* Check if the location being unlinked is in the canonical path for the current object */</span>
                    <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5G_common_path</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>canon_path_r<span class="hl opt">,</span>names<span class="hl opt">-&gt;</span>loc<span class="hl opt">-&gt;</span>canon_path_r<span class="hl opt">)) {</span>
                        <span class="hl com">/* Free user path */</span>
			<span class="hl kwd">H5RS_decr</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">);</span>
			ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">=</span>NULL<span class="hl opt">;</span>
                    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
                <span class="hl opt">}</span> <span class="hl com">/* end else */</span>
            <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>

        <span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com">        * OP_MOVE</span>
<span class="hl com">        *-------------------------------------------------------------------------</span>
<span class="hl com">        */</span>
        <span class="hl kwa">case</span> OP_MOVE<span class="hl opt">:</span> <span class="hl com">/* H5Gmove case, check for relative names case */</span>
            <span class="hl com">/* If the ID's entry is not in the file we operated on, skip it */</span>
            <span class="hl kwa">if</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>file<span class="hl opt">-&gt;</span>shared <span class="hl opt">==</span> names<span class="hl opt">-&gt;</span>loc<span class="hl opt">-&gt;</span>file<span class="hl opt">-&gt;</span>shared<span class="hl opt">) {</span>
		<span class="hl kwa">if</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>user_path_r <span class="hl opt">&amp;&amp;</span> names<span class="hl opt">-&gt;</span>loc<span class="hl opt">-&gt;</span>user_path_r <span class="hl opt">&amp;&amp;</span>
			names<span class="hl opt">-&gt;</span>src_loc<span class="hl opt">-&gt;</span>user_path_r <span class="hl opt">&amp;&amp;</span> names<span class="hl opt">-&gt;</span>dst_loc<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">) {</span>
		    H5RS_str_t <span class="hl opt">*</span>src_path_r<span class="hl opt">;</span> <span class="hl com">/* Full user path of source name */</span>
		    H5RS_str_t <span class="hl opt">*</span>dst_path_r<span class="hl opt">;</span> <span class="hl com">/* Full user path of destination name */</span>
		    H5RS_str_t <span class="hl opt">*</span>canon_src_path_r<span class="hl opt">;</span>   <span class="hl com">/* Copy of canonical part of source path */</span>
		    H5RS_str_t <span class="hl opt">*</span>canon_dst_path_r<span class="hl opt">;</span>   <span class="hl com">/* Copy of canonical part of destination path */</span>

		    <span class="hl com">/* Sanity check */</span>
		    <span class="hl kwd">HDassert</span><span class="hl opt">(</span>names<span class="hl opt">-&gt;</span>src_name<span class="hl opt">);</span>
		    <span class="hl kwd">HDassert</span><span class="hl opt">(</span>names<span class="hl opt">-&gt;</span>dst_name<span class="hl opt">);</span>

		    <span class="hl com">/* Make certain that the source and destination names are full (not relative) paths */</span>
		    <span class="hl kwa">if</span><span class="hl opt">(*(</span><span class="hl kwd">H5RS_get_str</span><span class="hl opt">(</span>names<span class="hl opt">-&gt;</span>src_name<span class="hl opt">))!=</span><span class="hl str">'/'</span><span class="hl opt">) {</span>
			<span class="hl com">/* Create reference counted string for full src path */</span>
			<span class="hl kwa">if</span><span class="hl opt">((</span>src_path_r <span class="hl opt">=</span> <span class="hl kwd">H5G_build_fullpath</span><span class="hl opt">(</span>names<span class="hl opt">-&gt;</span>src_loc<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">,</span> names<span class="hl opt">-&gt;</span>src_name<span class="hl opt">)) ==</span> NULL<span class="hl opt">)</span>
			    <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_PATH<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;can't build source path name&quot;</span><span class="hl opt">)</span>
		    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
		    <span class="hl kwa">else</span>
                        src_path_r<span class="hl opt">=</span><span class="hl kwd">H5RS_dup</span><span class="hl opt">(</span>names<span class="hl opt">-&gt;</span>src_name<span class="hl opt">);</span>
		    <span class="hl kwa">if</span><span class="hl opt">(*(</span><span class="hl kwd">H5RS_get_str</span><span class="hl opt">(</span>names<span class="hl opt">-&gt;</span>dst_name<span class="hl opt">))!=</span><span class="hl str">'/'</span><span class="hl opt">) {</span>
			<span class="hl com">/* Create reference counted string for full dst path */</span>
			<span class="hl kwa">if</span><span class="hl opt">((</span>dst_path_r <span class="hl opt">=</span> <span class="hl kwd">H5G_build_fullpath</span><span class="hl opt">(</span>names<span class="hl opt">-&gt;</span>dst_loc<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">,</span> names<span class="hl opt">-&gt;</span>dst_name<span class="hl opt">)) ==</span> NULL<span class="hl opt">)</span>
			    <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_SYM<span class="hl opt">,</span> H5E_PATH<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;can't build destination path name&quot;</span><span class="hl opt">)</span>
		    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
		    <span class="hl kwa">else</span>
                        dst_path_r<span class="hl opt">=</span><span class="hl kwd">H5RS_dup</span><span class="hl opt">(</span>names<span class="hl opt">-&gt;</span>dst_name<span class="hl opt">);</span>

		    <span class="hl com">/* Get the canonical parts of the source and destination names */</span>

		    <span class="hl com">/* Check if the object being moved was accessed through a mounted file */</span>
		    <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5RS_cmp</span><span class="hl opt">(</span>names<span class="hl opt">-&gt;</span>loc<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">,</span>names<span class="hl opt">-&gt;</span>loc<span class="hl opt">-&gt;</span>canon_path_r<span class="hl opt">)!=</span><span class="hl num">0</span><span class="hl opt">) {</span>
			<span class="hl kwb">size_t</span> non_canon_name_len<span class="hl opt">;</span>   <span class="hl com">/* Length of non-canonical part of name */</span>

			<span class="hl com">/* Get current string lengths */</span>
			non_canon_name_len<span class="hl opt">=</span><span class="hl kwd">H5RS_len</span><span class="hl opt">(</span>names<span class="hl opt">-&gt;</span>loc<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">)-</span><span class="hl kwd">H5RS_len</span><span class="hl opt">(</span>names<span class="hl opt">-&gt;</span>loc<span class="hl opt">-&gt;</span>canon_path_r<span class="hl opt">);</span>

			canon_src_path_r<span class="hl opt">=</span><span class="hl kwd">H5RS_create</span><span class="hl opt">(</span><span class="hl kwd">H5RS_get_str</span><span class="hl opt">(</span>src_path_r<span class="hl opt">)+</span>non_canon_name_len<span class="hl opt">);</span>
			canon_dst_path_r<span class="hl opt">=</span><span class="hl kwd">H5RS_create</span><span class="hl opt">(</span><span class="hl kwd">H5RS_get_str</span><span class="hl opt">(</span>dst_path_r<span class="hl opt">)+</span>non_canon_name_len<span class="hl opt">);</span>
		    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
		    <span class="hl kwa">else</span> <span class="hl opt">{</span>
			canon_src_path_r<span class="hl opt">=</span><span class="hl kwd">H5RS_dup</span><span class="hl opt">(</span>src_path_r<span class="hl opt">);</span>
			canon_dst_path_r<span class="hl opt">=</span><span class="hl kwd">H5RS_dup</span><span class="hl opt">(</span>dst_path_r<span class="hl opt">);</span>
		    <span class="hl opt">}</span> <span class="hl com">/* end else */</span>

		    <span class="hl com">/* Check if the link being changed in the file is along the canonical path for this object */</span>
		    <span class="hl kwa">if</span><span class="hl opt">(</span><span class="hl kwd">H5G_common_path</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>canon_path_r<span class="hl opt">,</span>canon_src_path_r<span class="hl opt">)) {</span>
			<span class="hl kwb">size_t</span> user_dst_len<span class="hl opt">;</span>    <span class="hl com">/* Length of destination user path */</span>
			<span class="hl kwb">size_t</span> canon_dst_len<span class="hl opt">;</span>   <span class="hl com">/* Length of destination canonical path */</span>
			<span class="hl kwb">const char</span> <span class="hl opt">*</span>old_user_path<span class="hl opt">;</span>    <span class="hl com">/* Pointer to previous user path */</span>
			<span class="hl kwb">char</span> <span class="hl opt">*</span>new_user_path<span class="hl opt">;</span>    <span class="hl com">/* Pointer to new user path */</span>
			<span class="hl kwb">char</span> <span class="hl opt">*</span>new_canon_path<span class="hl opt">;</span>   <span class="hl com">/* Pointer to new canonical path */</span>
			<span class="hl kwb">const char</span> <span class="hl opt">*</span>tail_path<span class="hl opt">;</span>  <span class="hl com">/* Pointer to &quot;tail&quot; of path */</span>
			<span class="hl kwb">size_t</span> tail_len<span class="hl opt">;</span>    <span class="hl com">/* Pointer to &quot;tail&quot; of path */</span>
			<span class="hl kwb">char</span> <span class="hl opt">*</span>src_canon_prefix<span class="hl opt">;</span>     <span class="hl com">/* Pointer to source canonical path prefix of component which is moving */</span>
			<span class="hl kwb">size_t</span> src_canon_prefix_len<span class="hl opt">;</span><span class="hl com">/* Length of the source canonical path prefix */</span>
			<span class="hl kwb">char</span> <span class="hl opt">*</span>dst_canon_prefix<span class="hl opt">;</span>     <span class="hl com">/* Pointer to destination canonical path prefix of component which is moving */</span>
			<span class="hl kwb">size_t</span> dst_canon_prefix_len<span class="hl opt">;</span><span class="hl com">/* Length of the destination canonical path prefix */</span>
			<span class="hl kwb">char</span> <span class="hl opt">*</span>user_prefix<span class="hl opt">;</span>      <span class="hl com">/* Pointer to user path prefix of component which is moving */</span>
			<span class="hl kwb">size_t</span> user_prefix_len<span class="hl opt">;</span> <span class="hl com">/* Length of the user path prefix */</span>
			<span class="hl kwb">char</span> <span class="hl opt">*</span>src_comp<span class="hl opt">;</span>     <span class="hl com">/* The source name of the component which is actually changing */</span>
			<span class="hl kwb">char</span> <span class="hl opt">*</span>dst_comp<span class="hl opt">;</span>     <span class="hl com">/* The destination name of the component which is actually changing */</span>
			<span class="hl kwb">const char</span> <span class="hl opt">*</span>canon_src_path<span class="hl opt">;</span>   <span class="hl com">/* pointer to canonical part of source path */</span>
			<span class="hl kwb">const char</span> <span class="hl opt">*</span>canon_dst_path<span class="hl opt">;</span>   <span class="hl com">/* pointer to canonical part of destination path */</span>

			<span class="hl com">/* Get the pointers to the raw strings */</span>
			canon_src_path<span class="hl opt">=</span><span class="hl kwd">H5RS_get_str</span><span class="hl opt">(</span>canon_src_path_r<span class="hl opt">);</span>
			canon_dst_path<span class="hl opt">=</span><span class="hl kwd">H5RS_get_str</span><span class="hl opt">(</span>canon_dst_path_r<span class="hl opt">);</span>

			<span class="hl com">/* Get the source &amp; destination components */</span>
			src_comp<span class="hl opt">=</span><span class="hl kwd">HDstrrchr</span><span class="hl opt">(</span>canon_src_path<span class="hl opt">,</span><span class="hl str">'/'</span><span class="hl opt">);</span>
			<span class="hl kwa">assert</span><span class="hl opt">(</span>src_comp<span class="hl opt">);</span>
			dst_comp<span class="hl opt">=</span><span class="hl kwd">HDstrrchr</span><span class="hl opt">(</span>canon_dst_path<span class="hl opt">,</span><span class="hl str">'/'</span><span class="hl opt">);</span>
			<span class="hl kwa">assert</span><span class="hl opt">(</span>dst_comp<span class="hl opt">);</span>

			<span class="hl com">/* Find the canonical prefixes for the entry */</span>
			src_canon_prefix_len<span class="hl opt">=</span><span class="hl kwd">HDstrlen</span><span class="hl opt">(</span>canon_src_path<span class="hl opt">)-</span><span class="hl kwd">HDstrlen</span><span class="hl opt">(</span>src_comp<span class="hl opt">);</span>
			<span class="hl kwa">if</span><span class="hl opt">(</span>NULL<span class="hl opt">==(</span>src_canon_prefix <span class="hl opt">=</span> <span class="hl kwd">H5MM_malloc</span><span class="hl opt">(</span>src_canon_prefix_len<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">)))</span>
			    <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_RESOURCE<span class="hl opt">,</span> H5E_NOSPACE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;memory allocation failed&quot;</span><span class="hl opt">);</span>
			<span class="hl kwd">HDstrncpy</span><span class="hl opt">(</span>src_canon_prefix<span class="hl opt">,</span>canon_src_path<span class="hl opt">,</span>src_canon_prefix_len<span class="hl opt">);</span>
			src_canon_prefix<span class="hl opt">[</span>src_canon_prefix_len<span class="hl opt">]=</span><span class="hl str">'\0'</span><span class="hl opt">;</span>

			dst_canon_prefix_len<span class="hl opt">=</span><span class="hl kwd">HDstrlen</span><span class="hl opt">(</span>canon_dst_path<span class="hl opt">)-</span><span class="hl kwd">HDstrlen</span><span class="hl opt">(</span>dst_comp<span class="hl opt">);</span>
			<span class="hl kwa">if</span><span class="hl opt">(</span>NULL<span class="hl opt">==(</span>dst_canon_prefix <span class="hl opt">=</span> <span class="hl kwd">H5MM_malloc</span><span class="hl opt">(</span>dst_canon_prefix_len<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">)))</span>
			    <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_RESOURCE<span class="hl opt">,</span> H5E_NOSPACE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;memory allocation failed&quot;</span><span class="hl opt">);</span>
			<span class="hl kwd">HDstrncpy</span><span class="hl opt">(</span>dst_canon_prefix<span class="hl opt">,</span>canon_dst_path<span class="hl opt">,</span>dst_canon_prefix_len<span class="hl opt">);</span>
			dst_canon_prefix<span class="hl opt">[</span>dst_canon_prefix_len<span class="hl opt">]=</span><span class="hl str">'\0'</span><span class="hl opt">;</span>

			<span class="hl com">/* Hold this for later use */</span>
			old_user_path<span class="hl opt">=</span><span class="hl kwd">H5RS_get_str</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">);</span>

			<span class="hl com">/* Find the user prefix for the entry */</span>
			user_prefix_len<span class="hl opt">=</span><span class="hl kwd">HDstrlen</span><span class="hl opt">(</span>old_user_path<span class="hl opt">)-</span><span class="hl kwd">H5RS_len</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>canon_path_r<span class="hl opt">);</span>
			<span class="hl kwa">if</span><span class="hl opt">(</span>NULL<span class="hl opt">==(</span>user_prefix <span class="hl opt">=</span> <span class="hl kwd">H5MM_malloc</span><span class="hl opt">(</span>user_prefix_len<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">)))</span>
			    <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_RESOURCE<span class="hl opt">,</span> H5E_NOSPACE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;memory allocation failed&quot;</span><span class="hl opt">);</span>
			<span class="hl kwd">HDstrncpy</span><span class="hl opt">(</span>user_prefix<span class="hl opt">,</span>old_user_path<span class="hl opt">,</span>user_prefix_len<span class="hl opt">);</span>
			user_prefix<span class="hl opt">[</span>user_prefix_len<span class="hl opt">]=</span><span class="hl str">'\0'</span><span class="hl opt">;</span>

			<span class="hl com">/* Set the tail path info */</span>
			tail_path<span class="hl opt">=</span>old_user_path<span class="hl opt">+</span>user_prefix_len<span class="hl opt">+</span>src_canon_prefix_len<span class="hl opt">+</span><span class="hl kwd">HDstrlen</span><span class="hl opt">(</span>src_comp<span class="hl opt">);</span>
			tail_len<span class="hl opt">=</span><span class="hl kwd">HDstrlen</span><span class="hl opt">(</span>tail_path<span class="hl opt">);</span>

			<span class="hl com">/* Get the length of the destination paths */</span>
			user_dst_len<span class="hl opt">=</span>user_prefix_len<span class="hl opt">+</span>dst_canon_prefix_len<span class="hl opt">+</span><span class="hl kwd">HDstrlen</span><span class="hl opt">(</span>dst_comp<span class="hl opt">)+</span>tail_len<span class="hl opt">;</span>
			canon_dst_len<span class="hl opt">=</span>dst_canon_prefix_len<span class="hl opt">+</span><span class="hl kwd">HDstrlen</span><span class="hl opt">(</span>dst_comp<span class="hl opt">)+</span>tail_len<span class="hl opt">;</span>

			<span class="hl com">/* Allocate space for the new user path */</span>
			<span class="hl kwa">if</span><span class="hl opt">(</span>NULL<span class="hl opt">==(</span>new_user_path <span class="hl opt">=</span> <span class="hl kwd">H5FL_BLK_MALLOC</span><span class="hl opt">(</span>str_buf<span class="hl opt">,</span>user_dst_len<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">)))</span>
			    <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_RESOURCE<span class="hl opt">,</span> H5E_NOSPACE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;memory allocation failed&quot;</span><span class="hl opt">);</span>

			<span class="hl com">/* Allocate space for the new canonical path */</span>
			<span class="hl kwa">if</span><span class="hl opt">(</span>NULL<span class="hl opt">==(</span>new_canon_path <span class="hl opt">=</span> <span class="hl kwd">H5FL_BLK_MALLOC</span><span class="hl opt">(</span>str_buf<span class="hl opt">,</span>canon_dst_len<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">)))</span>
			    <span class="hl kwd">HGOTO_ERROR</span> <span class="hl opt">(</span>H5E_RESOURCE<span class="hl opt">,</span> H5E_NOSPACE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;memory allocation failed&quot;</span><span class="hl opt">);</span>

			<span class="hl com">/* Create the new names */</span>
			<span class="hl kwd">HDstrcpy</span><span class="hl opt">(</span>new_user_path<span class="hl opt">,</span>user_prefix<span class="hl opt">);</span>
			<span class="hl kwd">HDstrcat</span><span class="hl opt">(</span>new_user_path<span class="hl opt">,</span>dst_canon_prefix<span class="hl opt">);</span>
			<span class="hl kwd">HDstrcat</span><span class="hl opt">(</span>new_user_path<span class="hl opt">,</span>dst_comp<span class="hl opt">);</span>
			<span class="hl kwd">HDstrcat</span><span class="hl opt">(</span>new_user_path<span class="hl opt">,</span>tail_path<span class="hl opt">);</span>
			<span class="hl kwd">HDstrcpy</span><span class="hl opt">(</span>new_canon_path<span class="hl opt">,</span>dst_canon_prefix<span class="hl opt">);</span>
			<span class="hl kwd">HDstrcat</span><span class="hl opt">(</span>new_canon_path<span class="hl opt">,</span>dst_comp<span class="hl opt">);</span>
			<span class="hl kwd">HDstrcat</span><span class="hl opt">(</span>new_canon_path<span class="hl opt">,</span>tail_path<span class="hl opt">);</span>

			<span class="hl com">/* Release the old user &amp; canonical paths */</span>
			<span class="hl kwd">H5RS_decr</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">);</span>
			<span class="hl kwd">H5RS_decr</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>canon_path_r<span class="hl opt">);</span>

			<span class="hl com">/* Take ownership of the new user &amp; canonical paths */</span>
			ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">=</span><span class="hl kwd">H5RS_own</span><span class="hl opt">(</span>new_user_path<span class="hl opt">);</span>
			ent<span class="hl opt">-&gt;</span>canon_path_r<span class="hl opt">=</span><span class="hl kwd">H5RS_own</span><span class="hl opt">(</span>new_canon_path<span class="hl opt">);</span>

			<span class="hl com">/* Free the extra paths allocated */</span>
			<span class="hl kwd">H5MM_xfree</span><span class="hl opt">(</span>src_canon_prefix<span class="hl opt">);</span>
			<span class="hl kwd">H5MM_xfree</span><span class="hl opt">(</span>dst_canon_prefix<span class="hl opt">);</span>
			<span class="hl kwd">H5MM_xfree</span><span class="hl opt">(</span>user_prefix<span class="hl opt">);</span>
		    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>


		    <span class="hl com">/* Free the extra paths allocated */</span>
		    <span class="hl kwd">H5RS_decr</span><span class="hl opt">(</span>src_path_r<span class="hl opt">);</span>
		    <span class="hl kwd">H5RS_decr</span><span class="hl opt">(</span>dst_path_r<span class="hl opt">);</span>
		    <span class="hl kwd">H5RS_decr</span><span class="hl opt">(</span>canon_src_path_r<span class="hl opt">);</span>
		    <span class="hl kwd">H5RS_decr</span><span class="hl opt">(</span>canon_dst_path_r<span class="hl opt">);</span>
		<span class="hl opt">}</span> <span class="hl com">/* end if */</span>
		<span class="hl kwa">else</span> <span class="hl opt">{</span>
		    <span class="hl com">/* Release the old user path */</span>
		    <span class="hl kwa">if</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">) {</span>
			<span class="hl kwd">H5RS_decr</span><span class="hl opt">(</span>ent<span class="hl opt">-&gt;</span>user_path_r<span class="hl opt">);</span>
			ent<span class="hl opt">-&gt;</span>user_path_r <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
		    <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
		<span class="hl opt">}</span> <span class="hl com">/* end else */</span>
            <span class="hl opt">}</span> <span class="hl com">/* end if */</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>

        <span class="hl kwa">default</span><span class="hl opt">:</span>
            <span class="hl kwd">HGOTO_ERROR</span><span class="hl opt">(</span>H5E_ARGS<span class="hl opt">,</span> H5E_BADTYPE<span class="hl opt">,</span> FAIL<span class="hl opt">,</span> <span class="hl str">&quot;invalid call&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span> <span class="hl com">/* end switch */</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>ret_value<span class="hl opt">);</span>
<span class="hl opt">}</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_get_shared_count</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Queries the group object's &quot;shared count&quot;</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Non-negative on success/Negative on failure</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Quincey Koziol</span>
<span class="hl com"> *		Tuesday, July	 5, 2005</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
herr_t
<span class="hl kwd">H5G_get_shared_count</span><span class="hl opt">(</span>H5G_t <span class="hl opt">*</span>grp<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT_NOFUNC</span><span class="hl opt">(</span>H5G_get_shared_count<span class="hl opt">);</span>

    <span class="hl com">/* Check args */</span>
    <span class="hl kwd">HDassert</span><span class="hl opt">(</span>grp <span class="hl opt">&amp;&amp;</span> grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">);</span>

    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">-&gt;</span>fo_count<span class="hl opt">);</span>
<span class="hl opt">}</span> <span class="hl com">/* end H5G_get_shared_count() */</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_mount</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Sets the 'mounted' flag for a group</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Non-negative on success/Negative on failure</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Quincey Koziol</span>
<span class="hl com"> *		Tuesday, July 19, 2005</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
herr_t
<span class="hl kwd">H5G_mount</span><span class="hl opt">(</span>H5G_t <span class="hl opt">*</span>grp<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT_NOFUNC</span><span class="hl opt">(</span>H5G_mount<span class="hl opt">);</span>

    <span class="hl com">/* Check args */</span>
    <span class="hl kwd">HDassert</span><span class="hl opt">(</span>grp <span class="hl opt">&amp;&amp;</span> grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">);</span>
    <span class="hl kwd">HDassert</span><span class="hl opt">(</span>grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">-&gt;</span>mounted <span class="hl opt">==</span> FALSE<span class="hl opt">);</span>

    <span class="hl com">/* Set the 'mounted' flag */</span>
    grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">-&gt;</span>mounted <span class="hl opt">=</span> TRUE<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>SUCCEED<span class="hl opt">);</span>
<span class="hl opt">}</span> <span class="hl com">/* end H5G_mount() */</span>


<span class="hl com">/*-------------------------------------------------------------------------</span>
<span class="hl com"> * Function:	H5G_unmount</span>
<span class="hl com"> *</span>
<span class="hl com"> * Purpose:	Resets the 'mounted' flag for a group</span>
<span class="hl com"> *</span>
<span class="hl com"> * Return:	Non-negative on success/Negative on failure</span>
<span class="hl com"> *</span>
<span class="hl com"> * Programmer:	Quincey Koziol</span>
<span class="hl com"> *		Tuesday, July 19, 2005</span>
<span class="hl com"> *</span>
<span class="hl com"> * Modifications:</span>
<span class="hl com"> *</span>
<span class="hl com"> *-------------------------------------------------------------------------</span>
<span class="hl com"> */</span>
herr_t
<span class="hl kwd">H5G_unmount</span><span class="hl opt">(</span>H5G_t <span class="hl opt">*</span>grp<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwd">FUNC_ENTER_NOAPI_NOINIT_NOFUNC</span><span class="hl opt">(</span>H5G_unmount<span class="hl opt">);</span>

    <span class="hl com">/* Check args */</span>
    <span class="hl kwd">HDassert</span><span class="hl opt">(</span>grp <span class="hl opt">&amp;&amp;</span> grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">);</span>
    <span class="hl kwd">HDassert</span><span class="hl opt">(</span>grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">-&gt;</span>mounted <span class="hl opt">==</span> TRUE<span class="hl opt">);</span>

    <span class="hl com">/* Reset the 'mounted' flag */</span>
    grp<span class="hl opt">-&gt;</span>shared<span class="hl opt">-&gt;</span>mounted <span class="hl opt">=</span> FALSE<span class="hl opt">;</span>

    <span class="hl kwd">FUNC_LEAVE_NOAPI</span><span class="hl opt">(</span>SUCCEED<span class="hl opt">);</span>
<span class="hl opt">}</span> <span class="hl com">/* end H5G_unmount() */</span>

</code></pre></td></tr></table>
</div> <!-- class=content -->
<div class='footer'>generated by <a href='http://git.zx2c4.com/cgit/about/'>cgit v0.12</a> at 2024-11-14 23:25:58 (GMT)</div>
</div> <!-- id=cgit -->
</body>
</html>