X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;ds=sidebyside;f=src%2FgdcmDocument.cxx;h=5b79c5f8dca126fa23f51cc451fbce1e1e995ff3;hb=14900333988858a95935ec735224433cf308c21c;hp=834a3d1ee13b168e63cf21c765698512da512624;hpb=2012716d624d631dcdb825fdd4470908e115a717;p=gdcm.git

diff --git a/src/gdcmDocument.cxx b/src/gdcmDocument.cxx
index 834a3d1e..5b79c5f8 100644
--- a/src/gdcmDocument.cxx
+++ b/src/gdcmDocument.cxx
@@ -3,8 +3,8 @@
   Program:   gdcm
   Module:    $RCSfile: gdcmDocument.cxx,v $
   Language:  C++
-  Date:      $Date: 2004/06/20 18:08:47 $
-  Version:   $Revision: 1.19 $
+  Date:      $Date: 2004/07/16 15:18:05 $
+  Version:   $Revision: 1.49 $
                                                                                 
   Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
   l'Image). All rights reserved. See Doc/License.txt or
@@ -66,7 +66,7 @@
 #define UI1_2_840_10008_1_2_4_91 "1.2.840.10008.1.2.4.91"
 // RLE Lossless
 #define UI1_2_840_10008_1_2_5    "1.2.840.10008.1.2.5"
-
+// UI1_1_2_840_10008_1_2_5
 #define str2num(str, typeNum) *((typeNum *)(str))
 
 //-----------------------------------------------------------------------------
@@ -74,9 +74,8 @@
 const unsigned int gdcmDocument::HEADER_LENGTH_TO_READ = 256;
 
 // Refer to gdcmDocument::SetMaxSizeLoadEntry()
-const unsigned int gdcmDocument::MAX_SIZE_LOAD_ELEMENT_VALUE = 4096;
-
-const unsigned int gdcmDocument::MAX_SIZE_PRINT_ELEMENT_VALUE = 64;
+const unsigned int gdcmDocument::MAX_SIZE_LOAD_ELEMENT_VALUE = 0xfff; // 4096
+const unsigned int gdcmDocument::MAX_SIZE_PRINT_ELEMENT_VALUE = 0x7fffffff;
 
 //-----------------------------------------------------------------------------
 // Constructor / Destructor
@@ -95,23 +94,25 @@ const unsigned int gdcmDocument::MAX_SIZE_PRINT_ELEMENT_VALUE = 64;
  *          with a FALSE value for the 'enable_sequence' param.
  *          ('public elements' may be embedded in 'shadow Sequences')
  */
-gdcmDocument::gdcmDocument(const char *inFilename, 
-                       bool exception_on_error,
-                       bool enable_sequences,
-                       bool ignore_shadow) 
-              : gdcmElementSet(-1)   {
-   enableSequences=enable_sequences;
-   ignoreShadow   =ignore_shadow;
-   
+gdcmDocument::gdcmDocument(std::string const & inFilename, 
+                           bool exception_on_error,
+                           bool enable_sequences,
+                           bool ignore_shadow) 
+              : gdcmElementSet(-1)
+{
+   IgnoreShadow = ignore_shadow;
+   //enableSequences=enable_sequences;
+   (void)enable_sequences;
+   enableSequences = true; // JPR // TODO : remove params out of the constructor
    SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE); 
-   filename = inFilename;
+   Filename = inFilename;
    Initialise();
 
    if ( !OpenFile(exception_on_error))
       return;
    
    dbg.Verbose(0, "gdcmDocument::gdcmDocument: starting parsing of file: ",
-                  filename.c_str());
+                  Filename.c_str());
    rewind(fp);
    
    fseek(fp,0L,SEEK_END);
@@ -125,6 +126,27 @@ gdcmDocument::gdcmDocument(const char *inFilename,
    SQDepthLevel=0;
    
    long l=ParseDES( this, beg, lgt, false); // le Load sera fait a la volee
+   (void)l; //is l used anywhere ?
+
+   rewind(fp); 
+   
+   // Load 'non string' values
+      
+   std::string PhotometricInterpretation = GetEntryByNumber(0x0028,0x0004);   
+   if( PhotometricInterpretation == "PALETTE COLOR " )
+   {
+      LoadEntryVoidArea(0x0028,0x1200);  // gray LUT   
+      LoadEntryVoidArea(0x0028,0x1201);  // R    LUT
+      LoadEntryVoidArea(0x0028,0x1202);  // G    LUT
+      LoadEntryVoidArea(0x0028,0x1203);  // B    LUT
+      
+      LoadEntryVoidArea(0x0028,0x1221);  // Segmented Red   Palette Color LUT Data
+      LoadEntryVoidArea(0x0028,0x1222);  // Segmented Green Palette Color LUT Data
+      LoadEntryVoidArea(0x0028,0x1223);  // Segmented Blue  Palette Color LUT Data
+   } 
+   //FIXME later : how to use it?
+   LoadEntryVoidArea(0x0028,0x3006);  //LUT Data (CTX dependent) 
+
    CloseFile(); 
   
    // --------------------------------------------------------------
@@ -139,7 +161,7 @@ gdcmDocument::gdcmDocument(const char *inFilename,
        RecCode == "CANRME_AILIBOD1_1." )  // for brain-damaged softwares
                                           // with "little-endian strings"
    {
-         filetype = gdcmACR_LIBIDO; 
+         Filetype = gdcmACR_LIBIDO; 
          std::string rows    = GetEntryByNumber(0x0028, 0x0010);
          std::string columns = GetEntryByNumber(0x0028, 0x0011);
          SetEntryByNumber(columns, 0x0028, 0x0010);
@@ -155,9 +177,10 @@ gdcmDocument::gdcmDocument(const char *inFilename,
  * @param   exception_on_error
  */
 gdcmDocument::gdcmDocument(bool exception_on_error) 
-             :gdcmElementSet(-1)    {
+             :gdcmElementSet(-1)
+{
    (void)exception_on_error;
-   enableSequences=0;
+   //enableSequences=0; // ?!? JPR
 
    SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE);
    Initialise();
@@ -168,14 +191,16 @@ gdcmDocument::gdcmDocument(bool exception_on_error)
 /**
  * \brief   Canonical destructor.
  */
-gdcmDocument::~gdcmDocument (void) {
+gdcmDocument::~gdcmDocument ()
+{
    RefPubDict = NULL;
    RefShaDict = NULL;
 
    // Recursive clean up of sequences
-   for (TagDocEntryHT::iterator it = tagHT.begin(); it != tagHT.end(); ++it )
-   {
-      delete (it->second);
+   for (TagDocEntryHT::const_iterator it = tagHT.begin(); 
+                                      it != tagHT.end(); ++it )
+   { 
+      delete it->second;
    }
    tagHT.clear();
 }
@@ -187,7 +212,8 @@ gdcmDocument::~gdcmDocument (void) {
   * \brief   Prints The Dict Entries of THE public Dicom Dictionary
   * @return
   */  
-void gdcmDocument::PrintPubDict(std::ostream & os) {
+void gdcmDocument::PrintPubDict(std::ostream & os)
+{
    RefPubDict->Print(os);
 }
 
@@ -195,7 +221,8 @@ void gdcmDocument::PrintPubDict(std::ostream & os) {
   * \brief   Prints The Dict Entries of THE shadow Dicom Dictionary
   * @return
   */
-void gdcmDocument::PrintShaDict(std::ostream & os) {
+void gdcmDocument::PrintShaDict(std::ostream & os)
+{
    RefShaDict->Print(os);
 }
 
@@ -204,33 +231,37 @@ void gdcmDocument::PrintShaDict(std::ostream & os) {
 /**
  * \brief   Get the public dictionary used
  */
-gdcmDict *gdcmDocument::GetPubDict(void) {
-   return(RefPubDict);
+gdcmDict *gdcmDocument::GetPubDict()
+{
+   return RefPubDict;
 }
 
 /**
  * \brief   Get the shadow dictionary used
  */
-gdcmDict *gdcmDocument::GetShaDict(void) {
-   return(RefShaDict);
+gdcmDict *gdcmDocument::GetShaDict()
+{
+   return RefShaDict;
 }
 
 /**
  * \brief   Set the shadow dictionary used
  * \param   dict dictionary to use in shadow
  */
-bool gdcmDocument::SetShaDict(gdcmDict *dict){
-   RefShaDict=dict;
-   return(!RefShaDict);
+bool gdcmDocument::SetShaDict(gdcmDict *dict)
+{
+   RefShaDict = dict;
+   return !RefShaDict;
 }
 
 /**
  * \brief   Set the shadow dictionary used
  * \param   dictName name of the dictionary to use in shadow
  */
-bool gdcmDocument::SetShaDict(DictKey dictName){
-   RefShaDict=gdcmGlobal::GetDicts()->GetDict(dictName);
-   return(!RefShaDict);
+bool gdcmDocument::SetShaDict(DictKey dictName)
+{
+   RefShaDict = gdcmGlobal::GetDicts()->GetDict(dictName);
+   return !RefShaDict;
 }
 
 /**
@@ -241,20 +272,27 @@ bool gdcmDocument::SetShaDict(DictKey dictName){
  * @return true when gdcmDocument is the one of a reasonable Dicom/Acr file,
  *         false otherwise. 
  */
-bool gdcmDocument::IsReadable(void) { 
-   if(filetype==gdcmUnknown) {
+bool gdcmDocument::IsReadable()
+{
+   if( Filetype == gdcmUnknown)
+   {
+      std::cout << " gdcmDocument::IsReadable: Filetype " << Filetype
+               << " " << "gdcmUnknown " << gdcmUnknown << std::endl; //JPR
       dbg.Verbose(0, "gdcmDocument::IsReadable: wrong filetype");
-      return(false);
+      return false;
    }
-   if(!tagHT.empty()<=0) { 
+
+   if(tagHT.empty())
+   {
       dbg.Verbose(0, "gdcmDocument::IsReadable: no tags in internal"
                      " hash table.");
-      return(false);
+      return false;
    }
 
-   return(true);
+   return true;
 }
 
+
 /**
  * \brief   Internal function that checks whether the Transfer Syntax given
  *          as argument is the one present in the current document.
@@ -263,27 +301,32 @@ bool gdcmDocument::IsReadable(void) {
  *          the current document. False either when the document contains
  *          no Transfer Syntax, or when the Tranfer Syntaxes don't match.
  */
-bool gdcmDocument::IsGivenTransferSyntax(const std::string & SyntaxToCheck)
+bool gdcmDocument::IsGivenTransferSyntax(std::string const & syntaxToCheck)
 {
-   gdcmDocEntry *Entry = GetDocEntryByNumber(0x0002, 0x0010);
-   if ( !Entry )
+   gdcmDocEntry *entry = GetDocEntryByNumber(0x0002, 0x0010);
+   if ( !entry )
+   {
       return false;
+   }
 
    // The entry might be present but not loaded (parsing and loading
    // happen at differente stages): try loading and proceed with check...
-   LoadDocEntrySafe(Entry);
-   if (gdcmValEntry* ValEntry = dynamic_cast< gdcmValEntry* >(Entry) )
+   LoadDocEntrySafe(entry);
+   if (gdcmValEntry* valEntry = dynamic_cast< gdcmValEntry* >(entry) )
    {
-      std::string Transfer = ValEntry->GetValue();
+      std::string transfer = valEntry->GetValue();
+
       // The actual transfer (as read from disk) might be padded. We
       // first need to remove the potential padding. We can make the
       // weak assumption that padding was not executed with digits...
-      while ( ! isdigit(Transfer[Transfer.length()-1]) )
+      while ( ! isdigit(transfer[transfer.length()-1]) )
       {
-         Transfer.erase(Transfer.length()-1, 1);
+         transfer.erase(transfer.length()-1, 1);
       }
-      if ( Transfer == SyntaxToCheck )
+      if ( transfer == syntaxToCheck )
+      {
          return true;
+      }
    }
    return false;
 }
@@ -295,7 +338,7 @@ bool gdcmDocument::IsGivenTransferSyntax(const std::string & SyntaxToCheck)
  * \sa      \ref gdcmDocument::IsGivenTransferSyntax.
  * @return  True when ImplicitVRLittleEndian found. False in all other cases.
  */
-bool gdcmDocument::IsImplicitVRLittleEndianTransferSyntax(void)
+bool gdcmDocument::IsImplicitVRLittleEndianTransferSyntax()
 {
    return IsGivenTransferSyntax(UI1_2_840_10008_1_2);
 }
@@ -305,7 +348,7 @@ bool gdcmDocument::IsImplicitVRLittleEndianTransferSyntax(void)
  *          and if it corresponds to a ExplicitVRLittleEndian one.
  * @return  True when ExplicitVRLittleEndian found. False in all other cases.
  */
-bool gdcmDocument::IsExplicitVRLittleEndianTransferSyntax(void)
+bool gdcmDocument::IsExplicitVRLittleEndianTransferSyntax()
 {
    return IsGivenTransferSyntax(UI1_2_840_10008_1_2_1);
 }
@@ -315,7 +358,7 @@ bool gdcmDocument::IsExplicitVRLittleEndianTransferSyntax(void)
  *          and if it corresponds to a DeflatedExplicitVRLittleEndian one.
  * @return  True when DeflatedExplicitVRLittleEndian found. False in all other cases.
  */
-bool gdcmDocument::IsDeflatedExplicitVRLittleEndianTransferSyntax(void)
+bool gdcmDocument::IsDeflatedExplicitVRLittleEndianTransferSyntax()
 {
    return IsGivenTransferSyntax(UI1_2_840_10008_1_2_1_99);
 }
@@ -325,7 +368,7 @@ bool gdcmDocument::IsDeflatedExplicitVRLittleEndianTransferSyntax(void)
  *          and if it corresponds to a Explicit VR Big Endian one.
  * @return  True when big endian found. False in all other cases.
  */
-bool gdcmDocument::IsExplicitVRBigEndianTransferSyntax(void)
+bool gdcmDocument::IsExplicitVRBigEndianTransferSyntax()
 {
    return IsGivenTransferSyntax(UI1_2_840_10008_1_2_2);
 }
@@ -335,7 +378,7 @@ bool gdcmDocument::IsExplicitVRBigEndianTransferSyntax(void)
  *          and if it corresponds to a JPEGBaseLineProcess1 one.
  * @return  True when JPEGBaseLineProcess1found. False in all other cases.
  */
-bool gdcmDocument::IsJPEGBaseLineProcess1TransferSyntax(void)
+bool gdcmDocument::IsJPEGBaseLineProcess1TransferSyntax()
 {
    return IsGivenTransferSyntax(UI1_2_840_10008_1_2_4_50);
 }
@@ -345,7 +388,7 @@ bool gdcmDocument::IsJPEGBaseLineProcess1TransferSyntax(void)
  *          and if it corresponds to a JPEGExtendedProcess2-4 one.
  * @return  True when JPEGExtendedProcess2-4 found. False in all other cases.
  */
-bool gdcmDocument::IsJPEGExtendedProcess2_4TransferSyntax(void)
+bool gdcmDocument::IsJPEGExtendedProcess2_4TransferSyntax()
 {
    return IsGivenTransferSyntax(UI1_2_840_10008_1_2_4_51);
 }
@@ -355,7 +398,7 @@ bool gdcmDocument::IsJPEGExtendedProcess2_4TransferSyntax(void)
  *          and if it corresponds to a JPEGExtendeProcess3-5 one.
  * @return  True when JPEGExtendedProcess3-5 found. False in all other cases.
  */
-bool gdcmDocument::IsJPEGExtendedProcess3_5TransferSyntax(void)
+bool gdcmDocument::IsJPEGExtendedProcess3_5TransferSyntax()
 {
    return IsGivenTransferSyntax(UI1_2_840_10008_1_2_4_52);
 }
@@ -366,7 +409,7 @@ bool gdcmDocument::IsJPEGExtendedProcess3_5TransferSyntax(void)
  * @return  True when JPEGSpectralSelectionProcess6-8 found. False in all
  *          other cases.
  */
-bool gdcmDocument::IsJPEGSpectralSelectionProcess6_8TransferSyntax(void)
+bool gdcmDocument::IsJPEGSpectralSelectionProcess6_8TransferSyntax()
 {
    return IsGivenTransferSyntax(UI1_2_840_10008_1_2_4_53);
 }
@@ -377,7 +420,7 @@ bool gdcmDocument::IsJPEGSpectralSelectionProcess6_8TransferSyntax(void)
  * @return  True when RLE Lossless found. False in all
  *          other cases.
  */
-bool gdcmDocument::IsRLELossLessTransferSyntax(void)
+bool gdcmDocument::IsRLELossLessTransferSyntax()
 {
    return IsGivenTransferSyntax(UI1_2_840_10008_1_2_5);
 }
@@ -388,11 +431,12 @@ bool gdcmDocument::IsRLELossLessTransferSyntax(void)
  * @return  True when RLE Lossless found. False in all
  *          other cases.
  */
-bool gdcmDocument::IsJPEGLossless(void)
+ 
+bool gdcmDocument::IsJPEGLossless()
 {
    return (   IsGivenTransferSyntax(UI1_2_840_10008_1_2_4_55)
            || IsGivenTransferSyntax(UI1_2_840_10008_1_2_4_57)
-           || IsGivenTransferSyntax(UI1_2_840_10008_1_2_4_90) );
+           || IsGivenTransferSyntax(UI1_2_840_10008_1_2_4_70) );
 }
                                                                                 
 /**
@@ -401,7 +445,7 @@ bool gdcmDocument::IsJPEGLossless(void)
  * @return  True when JPEG2000 (Lossly or LossLess) found. False in all
  *          other cases.
  */
-bool gdcmDocument::IsJPEG2000(void)
+bool gdcmDocument::IsJPEG2000()
 {
    return (   IsGivenTransferSyntax(UI1_2_840_10008_1_2_4_90)
            || IsGivenTransferSyntax(UI1_2_840_10008_1_2_4_91) );
@@ -411,12 +455,13 @@ bool gdcmDocument::IsJPEG2000(void)
  * \brief   Predicate for dicom version 3 file.
  * @return  True when the file is a dicom version 3.
  */
-bool gdcmDocument::IsDicomV3(void) {
+bool gdcmDocument::IsDicomV3()
+{
    // Checking if Transfert Syntax exists is enough
    // Anyway, it's to late check if the 'Preamble' was found ...
    // And ... would it be a rich idea to check ?
    // (some 'no Preamble' DICOM images exist !)
-   return (GetDocEntryByNumber(0x0002, 0x0010) != NULL);
+   return GetDocEntryByNumber(0x0002, 0x0010) != NULL;
 }
 
 /**
@@ -424,8 +469,9 @@ bool gdcmDocument::IsDicomV3(void) {
  *         (ACR, ACR_LIBIDO, ExplicitVR, ImplicitVR, Unknown)
  * @return the FileType code
  */
-FileType gdcmDocument::GetFileType(void) {
-   return(filetype);
+FileType gdcmDocument::GetFileType()
+{
+   return Filetype;
 }
 
 /**
@@ -436,89 +482,83 @@ FileType gdcmDocument::GetFileType(void) {
 FILE *gdcmDocument::OpenFile(bool exception_on_error)
   throw(gdcmFileError) 
 {
-  fp=fopen(filename.c_str(),"rb");
+  fp = fopen(Filename.c_str(),"rb");
 
   if(!fp)
   {
-     if(exception_on_error) 
+     if(exception_on_error)
+     {
         throw gdcmFileError("gdcmDocument::gdcmDocument(const char *, bool)");
+     }
      else
      {
-        std::cout <<"gdcmDocument::OpenFile cannot open file: " 
-                  << filename.c_str() << std::endl;
         dbg.Verbose(0, "gdcmDocument::OpenFile cannot open file: ",
-                    filename.c_str());
-        return (NULL);
+                    Filename.c_str());
+        return NULL;
      }
   }
 
   if ( fp ) 
   {
-     guint16 zero;
+     uint16_t zero;
      fread(&zero,  (size_t)2, (size_t)1, fp);
 
     //ACR -- or DICOM with no Preamble --
     if( zero == 0x0008 || zero == 0x0800 || zero == 0x0002 || zero == 0x0200)
-       return(fp);
+    {
+       return fp;
+    }
 
     //DICOM
     fseek(fp, 126L, SEEK_CUR);
     char dicm[4];
     fread(dicm,  (size_t)4, (size_t)1, fp);
     if( memcmp(dicm, "DICM", 4) == 0 )
-       return(fp);
+    {
+       return fp;
+    }
 
     fclose(fp);
-    dbg.Verbose(0, "gdcmDocument::OpenFile not DICOM/ACR", filename.c_str());
+    dbg.Verbose(0, "gdcmDocument::OpenFile not DICOM/ACR", Filename.c_str());
   }
-  else {
-    dbg.Verbose(0, "gdcmDocument::OpenFile cannot open file", filename.c_str());
+  else
+  {
+    dbg.Verbose(0, "gdcmDocument::OpenFile cannot open file", Filename.c_str());
   }
-  return(NULL);
+
+  return 0;
 }
 
 /**
  * \brief closes the file  
  * @return  TRUE if the close was successfull 
  */
-bool gdcmDocument::CloseFile(void) {
+bool gdcmDocument::CloseFile()
+{
   int closed = fclose(fp);
   fp = (FILE *)0;
-  if (! closed)
-     return false;
-  return true;
+
+  return closed;
 }
 
 /**
  * \brief Writes in a file all the Header Entries (Dicom Elements) 
- *        of the Chained List
  * @param fp file pointer on an already open file
- * @param type Type of the File to be written 
+ * @param filetype Type of the File to be written 
  *          (ACR-NEMA, ExplicitVR, ImplicitVR)
  * \return Always true.
  */
-bool gdcmDocument::Write(FILE *fp, FileType type) {
-/// \todo
-///  ==============
-///      The stuff will have to be rewritten using the SeQuence based 
-///       tree-like stucture instead  of the chained list .
-///      (so we shall remove the Group*HT from the gdcmDocument)
-///      To be checked
-/// =============
-
+void gdcmDocument::Write(FILE* fp,FileType filetype)
+{
    /// \todo move the following lines (and a lot of others, to be written)
    /// to a future function CheckAndCorrectHeader
    
-   /// \todo
-   /// Question :
-   /// Comment pourrait-on savoir si le DcmHeader vient d'un fichier
-   /// DicomV3 ou non (FileType est un champ de gdcmDocument ...)
    /// WARNING : Si on veut ecrire du DICOM V3 a partir d'un DcmHeader ACR-NEMA
-   /// no way 
+   /// no way (check : FileType est un champ de gdcmDocument ...)
    /// a moins de se livrer a un tres complique ajout des champs manquants.
-   /// faire un CheckAndCorrectHeader (?)  
-
-   if (type == gdcmImplicitVR) 
+   /// faire un CheckAndCorrectHeader (?) 
+ 
+   if (filetype == gdcmImplicitVR) 
    {
       std::string implicitVRTransfertSyntax = UI1_2_840_10008_1_2;
       ReplaceOrCreateByNumber(implicitVRTransfertSyntax,0x0002, 0x0010);
@@ -526,12 +566,12 @@ bool gdcmDocument::Write(FILE *fp, FileType type) {
       /// \todo Refer to standards on page 21, chapter 6.2
       ///       "Value representation": values with a VR of UI shall be
       ///       padded with a single trailing null
-      ///       Dans le cas suivant on doit pader manuellement avec un 0
+      ///       in the following case we have to padd manually with a 0
       
       SetEntryLengthByNumber(18, 0x0002, 0x0010);
    } 
 
-   if (type == gdcmExplicitVR) 
+   if (filetype == gdcmExplicitVR)
    {
       std::string explicitVRTransfertSyntax = UI1_2_840_10008_1_2_1;
       ReplaceOrCreateByNumber(explicitVRTransfertSyntax,0x0002, 0x0010);
@@ -543,22 +583,21 @@ bool gdcmDocument::Write(FILE *fp, FileType type) {
       
       SetEntryLengthByNumber(20, 0x0002, 0x0010);
    }
-
+  
 /**
  * \todo rewrite later, if really usefull
+ *       - 'Group Length' element is optional in DICOM
+ *       - but un-updated odd groups lengthes can causes pb
+ *         (xmedcon breaker)
  *
- *       --> Warning : un-updated odd groups lengths can causes pb 
- *       -->           (xmedcon breaks)
- *       --> to be re- written with future org.
- *
- * if ( (type == ImplicitVR) || (type == ExplicitVR) )
- *    UpdateGroupLength(false,type);
- * if ( type == ACR)
+ * if ( (filetype == ImplicitVR) || (filetype == ExplicitVR) )
+ *    UpdateGroupLength(false,filetype);
+ * if ( filetype == ACR)
  *    UpdateGroupLength(true,ACR);
  */
+ 
+   gdcmElementSet::Write(fp,filetype); // This one is recursive
 
-   WriteEntries(fp,type);
-   return(true);
 }
 
 /**
@@ -572,25 +611,25 @@ bool gdcmDocument::Write(FILE *fp, FileType type) {
  */
   
 gdcmValEntry * gdcmDocument::ReplaceOrCreateByNumber(
-                                         std::string Value, 
-                                         guint16 Group, 
-                                         guint16 Elem ){
-   gdcmDocEntry* CurrentEntry;
-   gdcmValEntry* ValEntry;
-
-   CurrentEntry = GetDocEntryByNumber( Group, Elem);
-   if (!CurrentEntry)
+                                         std::string value, 
+                                         uint16_t group, 
+                                         uint16_t elem )
+{
+   gdcmValEntry* valEntry;
+
+   gdcmDocEntry* currentEntry = GetDocEntryByNumber( group, elem);
+   if (!currentEntry)
    {
       // The entry wasn't present and we simply create the required ValEntry:
-      CurrentEntry = NewDocEntryByNumber(Group, Elem);
-      if (!CurrentEntry)
+      currentEntry = NewDocEntryByNumber(group, elem);
+      if (!currentEntry)
       {
          dbg.Verbose(0, "gdcmDocument::ReplaceOrCreateByNumber: call to"
                         " NewDocEntryByNumber failed.");
-         return (gdcmValEntry *)0;
+         return NULL;
       }
-      ValEntry = new gdcmValEntry(CurrentEntry);
-      if ( !AddEntry(ValEntry))
+      valEntry = new gdcmValEntry(currentEntry);
+      if ( !AddEntry(valEntry))
       {
          dbg.Verbose(0, "gdcmDocument::ReplaceOrCreateByNumber: AddEntry"
                         " failed allthough this is a creation.");
@@ -598,29 +637,29 @@ gdcmValEntry * gdcmDocument::ReplaceOrCreateByNumber(
    }
    else
    {
-      ValEntry = dynamic_cast< gdcmValEntry* >(CurrentEntry);
-      if ( !ValEntry )
+      valEntry = dynamic_cast< gdcmValEntry* >(currentEntry);
+      if ( !valEntry )
       {
          // We need to promote the gdcmDocEntry to a gdcmValEntry:
-         ValEntry = new gdcmValEntry(CurrentEntry);
-         if (!RemoveEntry(CurrentEntry))
+         valEntry = new gdcmValEntry(currentEntry);
+         if (!RemoveEntry(currentEntry))
          {
             dbg.Verbose(0, "gdcmDocument::ReplaceOrCreateByNumber: removal"
                            " of previous DocEntry failed.");
-            return (gdcmValEntry *)0;
+            return NULL;
          }
-         if ( !AddEntry(ValEntry))
+         if ( !AddEntry(valEntry))
          {
             dbg.Verbose(0, "gdcmDocument::ReplaceOrCreateByNumber: adding"
                            " promoted ValEntry failed.");
-            return (gdcmValEntry *)0;
+            return NULL;
          }
       }
    }
 
-   SetEntryByNumber(Value, Group, Elem);
+   SetEntryByNumber(value, group, elem);
 
-   return ValEntry;
+   return valEntry;
 }   
 
 /*
@@ -635,25 +674,28 @@ gdcmValEntry * gdcmDocument::ReplaceOrCreateByNumber(
 gdcmBinEntry * gdcmDocument::ReplaceOrCreateByNumber(
                                          void *voidArea,
                                          int lgth, 
-                                         guint16 Group, 
-                                         guint16 Elem)
-{
-   gdcmDocEntry* a;
-   gdcmBinEntry* b;	
-   a = GetDocEntryByNumber( Group, Elem);
-   if (a == NULL) {
-      a =NewBinEntryByNumber(Group, Elem);
-      if (a == NULL) 
-         return NULL;
-		b = new gdcmBinEntry(a);			
+                                         uint16_t group, 
+                                         uint16_t elem)
+{
+   gdcmBinEntry* b = 0;
+   gdcmDocEntry* a = GetDocEntryByNumber( group, elem);
+   if (!a)
+   {
+      a = NewBinEntryByNumber(group, elem);
+      if (!a)
+      {
+         return 0;
+      }
+
+      b = new gdcmBinEntry(a);
       AddEntry(b);
+      b->SetVoidArea(voidArea);
    }   
-   SetEntryByNumber(voidArea, lgth, Group, Elem);
-   b->SetVoidArea(voidArea);
-   return (gdcmBinEntry*)b;
-}  
-
+   SetEntryByNumber(voidArea, lgth, group, elem);
+   //b->SetVoidArea(voidArea);  //what if b == 0 !!
 
+   return b;
+}  
 
 /**
  * \brief Set a new value if the invoked element exists
@@ -663,10 +705,11 @@ gdcmBinEntry * gdcmDocument::ReplaceOrCreateByNumber(
  * @param Elem element number of the Entry
  * \return  boolean 
  */
-bool gdcmDocument::ReplaceIfExistByNumber(char* Value, guint16 Group, guint16 Elem ) 
+bool gdcmDocument::ReplaceIfExistByNumber(const char* value, uint16_t group,
+                                          uint16_t elem ) 
 {
-   std::string v = Value;
-   SetEntryByNumber(v, Group, Elem);
+   std::string v = value;
+   SetEntryByNumber(v, group, elem);
    return true;
 } 
 
@@ -679,9 +722,10 @@ bool gdcmDocument::ReplaceIfExistByNumber(char* Value, guint16 Group, guint16 El
  * @param   element  Element number of the searched Dicom Element 
  * @return  number of occurences
  */
-int gdcmDocument::CheckIfEntryExistByNumber(guint16 group, guint16 element ) {
+int gdcmDocument::CheckIfEntryExistByNumber(uint16_t group, uint16_t element )
+{
    std::string key = gdcmDictEntry::TranslateToKey(group, element );
-   return (tagHT.count(key));
+   return tagHT.count(key);
 }
 
 /**
@@ -693,12 +737,15 @@ int gdcmDocument::CheckIfEntryExistByNumber(guint16 group, guint16 element ) {
  * @return  Corresponding element value when it exists,
  *          and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
  */
-std::string gdcmDocument::GetEntryByName(std::string tagName) {
+std::string gdcmDocument::GetEntryByName(TagName tagName)
+{
    gdcmDictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName); 
-   if( dictEntry == NULL)
+   if( !dictEntry )
+   {
       return GDCM_UNFOUND;
+   }
 
-   return(GetEntryByNumber(dictEntry->GetGroup(),dictEntry->GetElement()));  
+   return GetEntryByNumber(dictEntry->GetGroup(),dictEntry->GetElement());
 }
 
 /**
@@ -714,7 +761,8 @@ std::string gdcmDocument::GetEntryByName(std::string tagName) {
  * @return  Corresponding element value representation when it exists,
  *          and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
  */
-std::string gdcmDocument::GetEntryVRByName(std::string tagName) {
+std::string gdcmDocument::GetEntryVRByName(TagName tagName)
+{
    gdcmDictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName); 
    if( dictEntry == NULL)
       return GDCM_UNFOUND;
@@ -734,8 +782,10 @@ std::string gdcmDocument::GetEntryVRByName(std::string tagName) {
  * @return  Corresponding element value representation when it exists,
  *          and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
  */
-std::string gdcmDocument::GetEntryByNumber(guint16 group, guint16 element){
-   TagKey key = gdcmDictEntry::TranslateToKey(group, element);
+std::string gdcmDocument::GetEntryByNumber(uint16_t group, uint16_t element)
+{
+   gdcmTagKey key = gdcmDictEntry::TranslateToKey(group, element);
+   /// \todo use map methods, instead of multimap JPR
    if ( ! tagHT.count(key))
       return GDCM_UNFOUND;
    return ((gdcmValEntry *)tagHT.find(key)->second)->GetValue();
@@ -755,7 +805,8 @@ std::string gdcmDocument::GetEntryByNumber(guint16 group, guint16 element){
  * @return  Corresponding element value representation when it exists,
  *          and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
  */
-std::string gdcmDocument::GetEntryVRByNumber(guint16 group, guint16 element) {
+std::string gdcmDocument::GetEntryVRByNumber(uint16_t group, uint16_t element)
+{
    gdcmDocEntry* elem =  GetDocEntryByNumber(group, element);
    if ( !elem )
       return GDCM_UNFOUND;
@@ -770,7 +821,8 @@ std::string gdcmDocument::GetEntryVRByNumber(guint16 group, guint16 element) {
  * @param   element Element number of the searched tag.
  * @return  Corresponding element length; -2 if not found
  */
-int gdcmDocument::GetEntryLengthByNumber(guint16 group, guint16 element) {
+int gdcmDocument::GetEntryLengthByNumber(uint16_t group, uint16_t element)
+{
    gdcmDocEntry* elem =  GetDocEntryByNumber(group, element);
    if ( !elem )
       return -2;
@@ -782,13 +834,14 @@ int gdcmDocument::GetEntryLengthByNumber(guint16 group, guint16 element) {
  * @param   tagName name of the searched Dicom Element.
  * @return  true when found
  */
-bool gdcmDocument::SetEntryByName(std::string content,std::string tagName) {
+bool gdcmDocument::SetEntryByName(std::string content,std::string tagName)
+{
    gdcmDictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName); 
    if( dictEntry == NULL)
       return false;    
 
-   return(SetEntryByNumber(content,dictEntry->GetGroup(),
-                                   dictEntry->GetElement()));
+   return SetEntryByNumber(content,dictEntry->GetGroup(),
+                                   dictEntry->GetElement());
 }
 
 /**
@@ -800,8 +853,8 @@ bool gdcmDocument::SetEntryByName(std::string content,std::string tagName) {
  * @param   element element number of the Dicom Element to modify
  */
 bool gdcmDocument::SetEntryByNumber(std::string content, 
-                                  guint16 group,
-                                  guint16 element) 
+                                    uint16_t group,
+                                    uint16_t element) 
 {
    gdcmValEntry* ValEntry = GetValEntryByNumber(group, element);
    if (!ValEntry)
@@ -810,15 +863,14 @@ bool gdcmDocument::SetEntryByNumber(std::string content,
                      " ValEntry (try promotion first).");
       return false;
    }
-
    // Non even content must be padded with a space (020H).
-   if((content.length())%2)
+   if((content.length())%2) {
       content = content + '\0';
-      
+   }      
    ValEntry->SetValue(content);
    
    // Integers have a special treatement for their length:
-   VRKey vr = ValEntry->GetVR();
+   gdcmVRKey vr = ValEntry->GetVR();
    if( (vr == "US") || (vr == "SS") ) 
       ValEntry->SetLength(2);
    else if( (vr == "UL") || (vr == "SL") )
@@ -834,19 +886,21 @@ bool gdcmDocument::SetEntryByNumber(std::string content,
  *          through it's (group, element) and modifies it's content with
  *          the given value.
  * @param   content new value (void *) to substitute with
+ * @param   lgth new value length
  * @param   group     group number of the Dicom Element to modify
  * @param   element element number of the Dicom Element to modify
  */
 bool gdcmDocument::SetEntryByNumber(void *content,
-                                  int lgth, 
-                                  guint16 group,
-                                  guint16 element) 
+                                    int lgth, 
+                                    uint16_t group,
+                                    uint16_t element) 
 {
-   TagKey key = gdcmDictEntry::TranslateToKey(group, element);
+   (void)lgth;  //not used
+   gdcmTagKey key = gdcmDictEntry::TranslateToKey(group, element);
    if ( ! tagHT.count(key))
       return false;
-		
-/* Hope Binray field length is never wrong    
+
+/* Hope Binaray field length is *never* wrong    
    if(lgth%2) // Non even length are padded with a space (020H).
    {  
       lgth++;
@@ -871,11 +925,12 @@ bool gdcmDocument::SetEntryByNumber(void *content,
  * @param element element number of the Entry to modify
  * @return  true on success, false otherwise.
  */
-bool gdcmDocument::SetEntryLengthByNumber(guint32 l, 
-                                        guint16 group, 
-                                        guint16 element) 
+bool gdcmDocument::SetEntryLengthByNumber(uint32_t l, 
+                                          uint16_t group, 
+                                          uint16_t element) 
 {
-   TagKey key = gdcmDictEntry::TranslateToKey(group, element);
+   /// \todo use map methods, instead of multimap JPR
+   gdcmTagKey key = gdcmDictEntry::TranslateToKey(group, element);
    if ( ! tagHT.count(key))
       return false;
    if (l%2) l++; // length must be even
@@ -891,13 +946,12 @@ bool gdcmDocument::SetEntryLengthByNumber(guint32 l,
  * @param Elem  element number of the Entry
  * @return File Offset of the Element Value 
  */
-size_t gdcmDocument::GetEntryOffsetByNumber(guint16 Group, guint16 Elem) 
+size_t gdcmDocument::GetEntryOffsetByNumber(uint16_t Group, uint16_t Elem) 
 {
    gdcmDocEntry* Entry = GetDocEntryByNumber(Group, Elem);
    if (!Entry) 
    {
-      dbg.Verbose(1, "gdcmDocument::GetDocEntryByNumber",
-                      "failed to Locate gdcmDocEntry");
+      dbg.Verbose(1, "gdcmDocument::GetDocEntryByNumber: no entry present.");
       return (size_t)0;
    }
    return Entry->GetOffset();
@@ -910,13 +964,12 @@ size_t gdcmDocument::GetEntryOffsetByNumber(guint16 Group, guint16 Elem)
  * @param Elem  element number of the Entry
  * @return Pointer to the 'non string' area
  */
-void * gdcmDocument::GetEntryVoidAreaByNumber(guint16 Group, guint16 Elem) 
+void * gdcmDocument::GetEntryVoidAreaByNumber(uint16_t Group, uint16_t Elem) 
 {
    gdcmDocEntry* Entry = GetDocEntryByNumber(Group, Elem);
    if (!Entry) 
    {
-      dbg.Verbose(1, "gdcmDocument::GetDocEntryByNumber",
-                  "failed to Locate gdcmDocEntry");
+      dbg.Verbose(1, "gdcmDocument::GetDocEntryByNumber: no entry");
       return (NULL);
    }
    return ((gdcmBinEntry *)Entry)->GetVoidArea();
@@ -928,19 +981,45 @@ void * gdcmDocument::GetEntryVoidAreaByNumber(guint16 Group, guint16 Elem)
  * @param Group   group number of the Entry 
  * @param Elem  element number of the Entry
  */
-void *gdcmDocument::LoadEntryVoidArea(guint16 Group, guint16 Elem) 
+void *gdcmDocument::LoadEntryVoidArea(uint16_t Group, uint16_t Elem) 
 {
    gdcmDocEntry * Element= GetDocEntryByNumber(Group, Elem);
    if ( !Element )
       return NULL;
    size_t o =(size_t)Element->GetOffset();
    fseek(fp, o, SEEK_SET);
-   size_t l=Element->GetLength();
+   size_t l = Element->GetLength();
    char* a = new char[l];
-   if(!a) 
+   if(!a) {
+      dbg.Verbose(0, "gdcmDocument::LoadEntryVoidArea cannot allocate a");
       return NULL;
-
+   }
+   size_t l2 = fread(a, 1, l ,fp);
+   if(l != l2) 
+   {
+      delete[] a;
+      return NULL;
+   }
+   /// \todo Drop any allready existing void area! JPR
    SetEntryVoidAreaByNumber(a, Group, Elem);
+   return a;  
+}
+/**
+ * \brief         Loads (from disk) the element content 
+ *                when a string is not suitable
+ * @param Element  Entry whose voidArea is going to be loaded
+ */
+void *gdcmDocument::LoadEntryVoidArea(gdcmBinEntry *Element) 
+{
+   size_t o =(size_t)Element->GetOffset();
+   fseek(fp, o, SEEK_SET);
+   size_t l = Element->GetLength();
+   char* a = new char[l];
+   if(!a) {
+      dbg.Verbose(0, "gdcmDocument::LoadEntryVoidArea cannot allocate a");
+      return NULL;
+   }
+   Element->SetVoidArea((void *)a);
    /// \todo check the result 
    size_t l2 = fread(a, 1, l ,fp);
    if(l != l2) 
@@ -948,22 +1027,21 @@ void *gdcmDocument::LoadEntryVoidArea(guint16 Group, guint16 Elem)
       delete[] a;
       return NULL;
    }
-
    return a;  
 }
 
 /**
  * \brief   Sets a 'non string' value to a given Dicom Element
- * @param   area
+ * @param   area area containing the 'non string' value
  * @param   group     Group number of the searched Dicom Element 
  * @param   element Element number of the searched Dicom Element 
  * @return  
  */
 bool gdcmDocument::SetEntryVoidAreaByNumber(void * area,
-                                          guint16 group, 
-                                          guint16 element) 
+                                            uint16_t group, 
+                                            uint16_t element) 
 {
-   TagKey key = gdcmDictEntry::TranslateToKey(group, element);
+   gdcmTagKey key = gdcmDictEntry::TranslateToKey(group, element);
    if ( ! tagHT.count(key))
       return false;
       // This was for multimap ?
@@ -976,8 +1054,8 @@ bool gdcmDocument::SetEntryVoidAreaByNumber(void * area,
  * \brief   Update the entries with the shadow dictionary. 
  *          Only non even entries are analyzed       
  */
-void gdcmDocument::UpdateShaEntries(void) {
-   gdcmDictEntry *entry;
+void gdcmDocument::UpdateShaEntries() {
+   //gdcmDictEntry *entry;
    std::string vr;
    
    /// \todo TODO : still any use to explore recursively the whole structure?
@@ -1026,7 +1104,8 @@ void gdcmDocument::UpdateShaEntries(void) {
  * @return  Corresponding Dicom Element when it exists, and NULL
  *          otherwise.
  */
- gdcmDocEntry *gdcmDocument::GetDocEntryByName(std::string tagName) {
+gdcmDocEntry* gdcmDocument::GetDocEntryByName(std::string tagName)
+{
    gdcmDictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName); 
    if( dictEntry == NULL)
       return NULL;
@@ -1044,9 +1123,10 @@ void gdcmDocument::UpdateShaEntries(void) {
  * @param   element Element number of the searched Dicom Element 
  * @return  
  */
-gdcmDocEntry* gdcmDocument::GetDocEntryByNumber(guint16 group, guint16 element) 
+gdcmDocEntry* gdcmDocument::GetDocEntryByNumber(uint16_t group,
+                                                uint16_t element) 
 {
-   TagKey key = gdcmDictEntry::TranslateToKey(group, element);   
+   gdcmTagKey key = gdcmDictEntry::TranslateToKey(group, element);
    if ( ! tagHT.count(key))
       return NULL;
    return tagHT.find(key)->second;
@@ -1058,7 +1138,8 @@ gdcmDocEntry* gdcmDocument::GetDocEntryByNumber(guint16 group, guint16 element)
  *         ValEntry.
  * @return When present, the corresponding ValEntry. 
  */
-gdcmValEntry* gdcmDocument::GetValEntryByNumber(guint16 group, guint16 element)
+gdcmValEntry* gdcmDocument::GetValEntryByNumber(uint16_t group,
+                                                uint16_t element)
 {
   gdcmDocEntry* CurrentEntry = GetDocEntryByNumber(group, element);
   if (! CurrentEntry)
@@ -1078,248 +1159,20 @@ gdcmValEntry* gdcmDocument::GetValEntryByNumber(guint16 group, guint16 element)
  * @param entry   Header Entry whose value shall be loaded. 
  * @return  
  */
-void gdcmDocument::LoadDocEntrySafe(gdcmDocEntry * entry) {
+void gdcmDocument::LoadDocEntrySafe(gdcmDocEntry * entry)
+{
    long PositionOnEntry = ftell(fp);
    LoadDocEntry(entry);
    fseek(fp, PositionOnEntry, SEEK_SET);
 }
 
-
-/**
- * \brief Writes in a file (according to the requested format)
- *        the group, the element, the value representation and the length
- *        of a single gdcmDocEntry passed as argument.
- * @param tag  pointer on the gdcmDocEntry to be written
- * @param _fp  already open file pointer
- * @param type type of the File to be written 
- */
-void gdcmDocument::WriteEntryTagVRLength(gdcmDocEntry *tag,
-                                       FILE *_fp,
-                                       FileType type)
-{
-   guint16 group  = tag->GetGroup();
-   VRKey   vr     = tag->GetVR();
-   guint16 el     = tag->GetElement();
-   guint32 lgr    = tag->GetReadLength();
-
-   if ( (group == 0xfffe) && (el == 0x0000) ) 
-     // Fix in order to make some MR PHILIPS images e-film readable
-     // see gdcmData/gdcm-MR-PHILIPS-16-Multi-Seq.dcm:
-     // we just *always* ignore spurious fffe|0000 tag !   
-      return; 
-
-   fwrite ( &group,(size_t)2 ,(size_t)1 ,_fp);  //group
-   fwrite ( &el,(size_t)2 ,(size_t)1 ,_fp);     //element
-      
-   if ( type == gdcmExplicitVR ) {
-
-      // Special case of delimiters:
-      if (group == 0xfffe) {
-         // Delimiters have NO Value Representation and have NO length.
-         // Hence we skip writing the VR and length and we pad by writing
-         // 0xffffffff
-
-         int ff=0xffffffff;
-         fwrite (&ff,(size_t)4 ,(size_t)1 ,_fp);
-         return;
-      }
-
-      guint16 z=0;
-      guint16 shortLgr = lgr;
-      if (vr == "unkn") {     // Unknown was 'written'
-         // deal with Little Endian            
-         fwrite ( &shortLgr,(size_t)2 ,(size_t)1 ,_fp);
-         fwrite ( &z,  (size_t)2 ,(size_t)1 ,_fp);
-      } else {
-         fwrite (vr.c_str(),(size_t)2 ,(size_t)1 ,_fp);                     
-         if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") )
-         {
-            fwrite ( &z,  (size_t)2 ,(size_t)1 ,_fp);
-            fwrite ( &lgr,(size_t)4 ,(size_t)1 ,_fp);
-         } else {
-            fwrite ( &shortLgr,(size_t)2 ,(size_t)1 ,_fp);
-         }
-      }
-   } 
-   else // IMPLICIT VR 
-   { 
-      fwrite ( &lgr,(size_t)4 ,(size_t)1 ,_fp);
-   }
-}
-      
-/**
- * \brief Writes in a file (according to the requested format)
- *        the value of a single gdcmDocEntry passed as argument.
- * @param tag  Pointer on the gdcmDocEntry to be written
- * @param _fp  Already open file pointer
- * @param type type of the File to be written
- */
- 
-// \todo TODO : to be re -written recursively !
-void gdcmDocument::WriteEntryValue(gdcmDocEntry *tag, FILE *_fp,FileType type)
-{
-   (void)type;
-   guint16 group  = tag->GetGroup();
-   VRKey   vr     = tag->GetVR();
-   guint32 lgr    = tag->GetReadLength();
-
-   if (vr == "SQ")
-      // SeQuences have no value:
-      return;
-   if (group == 0xfffe)
-      // Delimiters have no associated value:
-      return;
-		
-		//--------------------------------
-		//
-		// FIXME :right now, both value and voidArea belong to gdcmValue
-		//
-		// -------------------------------
-		
-// if (gdcmBinEntry* BinEntry = dynamic_cast< gdcmBinEntry* >(tag) ) {
-      void *voidArea;
-      gdcmBinEntry *BinEntry= (gdcmBinEntry *)tag;;
-      voidArea = BinEntry->GetVoidArea();
-      if (voidArea != NULL) 
-      { // there is a 'non string' LUT, overlay, etc
-         fwrite ( voidArea,(size_t)lgr ,(size_t)1 ,_fp); // Elem value
-         return;            
-      }
-// } 
-
-   if (vr == "US" || vr == "SS") 
-   {
-      // some 'Short integer' fields may be mulivaluated
-      // each single value is separated from the next one by '\'
-      // we split the string and write each value as a short int
-      std::vector<std::string> tokens;
-      tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
-      Tokenize (((gdcmValEntry *)tag)->GetValue(), tokens, "\\");
-      for (unsigned int i=0; i<tokens.size();i++) 
-      {
-         guint16 val_uint16 = atoi(tokens[i].c_str());
-         void *ptr = &val_uint16;
-         fwrite ( ptr,(size_t)2 ,(size_t)1 ,_fp);
-      }
-      tokens.clear();
-      return;
-   }
-   if (vr == "UL" || vr == "SL") 
-   {
-      // Some 'Integer' fields may be multivaluated (multiple instances 
-      // of integers). But each single integer value is separated from the
-      // next one by '\' (backslash character). Hence we split the string
-      // along the '\' and write each value as an int:
-      std::vector<std::string> tokens;
-      tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
-      Tokenize (((gdcmValEntry *)tag)->GetValue(), tokens, "\\");
-      for (unsigned int i=0; i<tokens.size();i++) 
-      {
-         guint32 val_uint32 = atoi(tokens[i].c_str());
-         void *ptr = &val_uint32;
-         fwrite ( ptr,(size_t)4 ,(size_t)1 ,_fp);
-      }
-      tokens.clear();
-      return;
-   }           
-   fwrite (((gdcmValEntry *)tag)->GetValue().c_str(),
-           (size_t)lgr ,(size_t)1, _fp); // Elem value
-}
-
-/**
- * \brief Writes in a file (according to the requested format)
- *        a single gdcmDocEntry passed as argument.
- * \sa    WriteEntryValue, WriteEntryTagVRLength.
- * @param tag  Pointer on the gdcmDocEntry to be written
- * @param _fp  Already open file pointer
- * @param type type of the File to be written
- */
-
-bool gdcmDocument::WriteEntry(gdcmDocEntry *tag, FILE *_fp,FileType type)
-{
-   guint32 length = tag->GetLength();
-
-   if (gdcmValEntry* ValEntry = dynamic_cast< gdcmValEntry* >(tag) )
-   {
-      // The value of a tag MUST (see the DICOM norm) be an odd number of
-      // bytes. When this is not the case, pad with an additional byte:
-      if(length%2==1) {
-         ValEntry->SetValue(ValEntry->GetValue()+"\0");
-         ValEntry->SetLength(ValEntry->GetReadLength()+1);
-      }
-      WriteEntryTagVRLength(ValEntry, _fp, type);
-      WriteEntryValue(ValEntry, _fp, type);
-      return true;
-   }
-
-   if (gdcmBinEntry* BinEntry = dynamic_cast< gdcmBinEntry* >(tag) )
-   {
-      /// \todo FIXME : when voidArea belong to gdcmBinEntry only, fix
-      /// voidArea length
-      //
-      // The value of a tag MUST (see the DICOM norm) be an odd number of
-      // bytes. When this is not the case, pad with an additional byte:
-/*
-      if(length%2==1) { 
-         tag->SetValue(tag->GetValue()+"\0");
-         tag->SetLength(tag->GetReadLength()+1);
-      }
-*/
-      WriteEntryTagVRLength(tag, _fp, type);
-      WriteEntryValue(tag, _fp, type);
-      return true;
-   }
-}
-
-/**
- * \brief   writes on disc according to the requested format
- *          (ACR-NEMA, ExplicitVR, ImplicitVR) the image
- *          using the Chained List
- * \warning does NOT add the missing elements in the header :
- *           it's up to the user doing it !
- *           (function CheckHeaderCoherence to be written)
- * \warning DON'T try, right now, to write a DICOM image
- *           from an ACR Header (meta elements will be missing!)
- * @param   type type of the File to be written 
- *          (ACR-NEMA, ExplicitVR, ImplicitVR)
- * @param   _fp already open file pointer
- */
-
-bool gdcmDocument::WriteEntries(FILE *_fp,FileType type)
-{ 
-   /// \todo FIXME : explore recursively the whole structure...
-   /// \todo (?) check write failures (after *each* fwrite)
- 
-   dbg.Verbose(0, "gdcmDocument::WriteEntries: entering.");
-   for (TagDocEntryHT::iterator it = tagHT.begin(); it != tagHT.end(); ++it )
-   {
-      gdcmDocEntry * entry = it->second;
-
-      if ( type == gdcmACR ){ 
-         if (entry->GetGroup() < 0x0008)
-            // Ignore pure DICOM V3 groups
-            continue;
-         if (entry->GetGroup() %2)
-            // Ignore the "shadow" groups
-            continue;
-         if (entry->GetVR() == "SQ" ) // ignore Sequences
-            continue;    
-      } 
-      if (! WriteEntry(entry, _fp, type) ) {
-         dbg.Verbose(0, "gdcmDocument::WriteEntries: write failure.");
-         return false;
-      }
-   }
-   return true;
-}   
-
-
 /**
  * \brief   Swaps back the bytes of 4-byte long integer accordingly to
  *          processor order.
  * @return  The properly swaped 32 bits integer.
  */
-guint32 gdcmDocument::SwapLong(guint32 a) {
+uint32_t gdcmDocument::SwapLong(uint32_t a)
+{
    switch (sw) {
       case    0 :
          break;
@@ -1340,34 +1193,37 @@ guint32 gdcmDocument::SwapLong(guint32 a) {
          dbg.Error(" gdcmDocument::SwapLong : unset swap code");
          a=0;
    }
-   return(a);
-}
+   return a;
+} 
 
 /**
  * \brief   Unswaps back the bytes of 4-byte long integer accordingly to
  *          processor order.
  * @return  The properly unswaped 32 bits integer.
  */
-guint32 gdcmDocument::UnswapLong(guint32 a) {
-   return (SwapLong(a));
+uint32_t gdcmDocument::UnswapLong(uint32_t a)
+{
+   return SwapLong(a);
 }
 
 /**
  * \brief   Swaps the bytes so they agree with the processor order
  * @return  The properly swaped 16 bits integer.
  */
-guint16 gdcmDocument::SwapShort(guint16 a) {
+uint16_t gdcmDocument::SwapShort(uint16_t a)
+{
    if ( (sw==4321)  || (sw==2143) )
       a =(((a<<8) & 0x0ff00) | ((a>>8)&0x00ff));
-   return (a);
+   return a;
 }
 
 /**
  * \brief   Unswaps the bytes so they agree with the processor order
  * @return  The properly unswaped 16 bits integer.
  */
-guint16 gdcmDocument::UnswapShort(guint16 a) {
-   return (SwapShort(a));
+uint16_t gdcmDocument::UnswapShort(uint16_t a)
+{
+   return SwapShort(a);
 }
 
 //-----------------------------------------------------------------------------
@@ -1375,17 +1231,20 @@ guint16 gdcmDocument::UnswapShort(guint16 a) {
 
 /**
  * \brief   Parses a DocEntrySet (Zero-level DocEntries or SQ Item DocEntries)
- * @return  false if file is not ACR-NEMA / PAPYRUS / DICOM 
+ * @return  length of the parsed set. 
  */ 
 
-long gdcmDocument::ParseDES(gdcmDocEntrySet *set, long offset, long l_max, bool delim_mode) {
-
+long gdcmDocument::ParseDES(gdcmDocEntrySet *set,
+                            long offset,
+                            long l_max,
+                            bool delim_mode)
+{
    gdcmDocEntry *NewDocEntry = (gdcmDocEntry *)0;
    gdcmValEntry *NewValEntry = (gdcmValEntry *)0;
    gdcmBinEntry *bn;   
    gdcmSeqEntry *sq;
-   VRKey vr;
-   long l;
+   gdcmVRKey vr;
+   unsigned long l = 0;
    int depth; 
    
    depth = set->GetDepthLevel();     
@@ -1410,7 +1269,7 @@ long gdcmDocument::ParseDES(gdcmDocEntrySet *set, long offset, long l_max, bool
             NewValEntry->SetDepthLevel(depth);
             set->AddEntry(NewValEntry);
             LoadDocEntry(NewValEntry);
-            if (/*!delim_mode && */NewValEntry->isItemDelimitor())
+            if (NewValEntry->isItemDelimitor())
                break;
             if ( !delim_mode && ftell(fp)-offset >= l_max)
             {
@@ -1436,10 +1295,17 @@ long gdcmDocument::ParseDES(gdcmDocEntrySet *set, long offset, long l_max, bool
          if (NewDocEntry->GetGroup()   == 0x7fe0 && 
              NewDocEntry->GetElement() == 0x0010 )
          {
-             if (NewDocEntry->GetLength()==0xffffffff)
+             if (NewDocEntry->GetReadLength()==0xffffffff)
+             {
                 // Broken US.3405.1.dcm
                 Parse7FE0(); // to skip the pixels 
                              // (multipart JPEG/RLE are trouble makers)
+             }
+             else
+             {
+                SkipToNextDocEntry(NewDocEntry);
+                l = NewDocEntry->GetFullLength(); 
+             }
          }
          else
          {
@@ -1469,8 +1335,8 @@ long gdcmDocument::ParseDES(gdcmDocEntrySet *set, long offset, long l_max, bool
             long lgt = ParseSQ( sq, 
                                 NewDocEntry->GetOffset(),
                                 l, delim_mode);
+            (void)lgt;  //not used...
          }
-         // FIXME : on en fait quoi, de lgt ?
          set->AddEntry(sq);
          if ( !delim_mode && ftell(fp)-offset >= l_max)
          {
@@ -1479,7 +1345,7 @@ long gdcmDocument::ParseDES(gdcmDocEntrySet *set, long offset, long l_max, bool
       }
       delete NewDocEntry;
    }
-   return l; // ?? 
+   return l; // Probably useless 
 }
 
 /**
@@ -1490,19 +1356,22 @@ long gdcmDocument::ParseSQ(gdcmSeqEntry *set,
                            long offset, long l_max, bool delim_mode)
 {
    int SQItemNumber = 0;
-		
+
    gdcmDocEntry *NewDocEntry = (gdcmDocEntry *)0;
    gdcmSQItem *itemSQ;
    bool dlm_mod;
-   int lgr, l, lgth;
+   int lgr, lgth;
+   unsigned int l;
    int depth = set->GetDepthLevel();
+   (void)depth; //not used
 
    while (true) {
+
       NewDocEntry = ReadNextDocEntry();   
+      if (!NewDocEntry)
+         break;
       if(delim_mode) {   
          if (NewDocEntry->isSequenceDelimitor()) {
-            /// \todo add the Sequence Delimitor
-            /// \todo find the trick to put it properly !
             set->SetSequenceDelimitationItem(NewDocEntry);
             break;
           }
@@ -1513,7 +1382,6 @@ long gdcmDocument::ParseSQ(gdcmSeqEntry *set,
 
       itemSQ = new gdcmSQItem(set->GetDepthLevel());
       itemSQ->AddEntry(NewDocEntry);
-      /// \todo  no value, no voidArea. Think of it while printing !
       l= NewDocEntry->GetReadLength();
       
       if (l == 0xffffffff)
@@ -1523,14 +1391,14 @@ long gdcmDocument::ParseSQ(gdcmSeqEntry *set,
    
       lgr=ParseDES(itemSQ, NewDocEntry->GetOffset(), l, dlm_mod);
       
-      set->AddEntry(itemSQ,SQItemNumber);	 
+      set->AddEntry(itemSQ,SQItemNumber); 
       SQItemNumber ++;
       if (!delim_mode && (ftell(fp)-offset) >= l_max) {
          break;
       }
    }
    lgth = ftell(fp) - offset;
-   return(lgth);
+   return lgth;
 }
 
 /**
@@ -1538,12 +1406,12 @@ long gdcmDocument::ParseSQ(gdcmSeqEntry *set,
  *                the value specified with gdcmDocument::SetMaxSizeLoadEntry()
  * @param         Entry Header Entry (Dicom Element) to be dealt with
  */
-void gdcmDocument::LoadDocEntry(gdcmDocEntry *Entry)
+void gdcmDocument::LoadDocEntry(gdcmDocEntry* Entry)
 {
    size_t item_read;
-   guint16 group  = Entry->GetGroup();
-   std::string  vr= Entry->GetVR();
-   guint32 length = Entry->GetLength();
+   uint16_t group  = Entry->GetGroup();
+   std::string  vr = Entry->GetVR();
+   uint32_t length = Entry->GetLength();
 
    fseek(fp, (long)Entry->GetOffset(), SEEK_SET);
 
@@ -1551,16 +1419,15 @@ void gdcmDocument::LoadDocEntry(gdcmDocEntry *Entry)
    //          (fffe e000) tells us an Element is beginning
    //          (fffe e00d) tells us an Element just ended
    //          (fffe e0dd) tells us the current SeQuence just ended
-   if( group == 0xfffe ) {
+   if( group == 0xfffe )
+   {
       // NO more value field for SQ !
-      //Entry->SetValue("gdcm::Skipped");
-      // appel recursif de Load Value
-      // (meme pb que pour le parsing)
       return;
    }
 
    // When the length is zero things are easy:
-   if ( length == 0 ) {
+   if ( length == 0 )
+   {
       ((gdcmValEntry *)Entry)->SetValue("");
       return;
    }
@@ -1568,53 +1435,81 @@ void gdcmDocument::LoadDocEntry(gdcmDocEntry *Entry)
    // The elements whose length is bigger than the specified upper bound
    // are not loaded. Instead we leave a short notice of the offset of
    // the element content and it's length.
-   if (length > MaxSizeLoadEntry) {
+
+   std::ostringstream s;
+   if (length > MaxSizeLoadEntry)
+   {
+      if (gdcmBinEntry* BinEntryPtr = dynamic_cast< gdcmBinEntry* >(Entry) )
+      {         
+         s << "gdcm::NotLoaded (BinEntry)";
+         s << " Address:" << (long)Entry->GetOffset();
+         s << " Length:"  << Entry->GetLength();
+         s << " x(" << std::hex << Entry->GetLength() << ")";
+         BinEntryPtr->SetValue(s.str());
+      }
+      // to be sure we are at the end of the value ...
+      fseek(fp, (long)Entry->GetOffset()+(long)Entry->GetLength(), SEEK_SET);      
+      return;
+       // Be carefull : a BinEntry IS_A ValEntry ... 
       if (gdcmValEntry* ValEntryPtr = dynamic_cast< gdcmValEntry* >(Entry) )
       {
-         std::ostringstream s;
-         s << "gdcm::NotLoaded.";
+         s << "gdcm::NotLoaded. (ValEntry)";
          s << " Address:" << (long)Entry->GetOffset();
          s << " Length:"  << Entry->GetLength();
          s << " x(" << std::hex << Entry->GetLength() << ")";
          ValEntryPtr->SetValue(s.str());
       }
       // to be sure we are at the end of the value ...
-      fseek(fp,(long)Entry->GetOffset()+(long)Entry->GetLength(),SEEK_SET);
-      
+      fseek(fp,(long)Entry->GetOffset()+(long)Entry->GetLength(),SEEK_SET);      
+      return;
+   }
+
+   // When we find a BinEntry not very much can be done :
+   if (gdcmBinEntry* BinEntryPtr = dynamic_cast< gdcmBinEntry* >(Entry) )
+   {
+
+      LoadEntryVoidArea(BinEntryPtr);
+      s << "gdcm::Loaded (BinEntry)";
+      BinEntryPtr->SetValue(s.str());
       return;
    }
     
-   // Any compacter code suggested (?)
-   if ( IsDocEntryAnInteger(Entry) ) {   
-      guint32 NewInt;
+   /// \todo Any compacter code suggested (?)
+   if ( IsDocEntryAnInteger(Entry) )
+   {   
+      uint32_t NewInt;
       std::ostringstream s;
       int nbInt;
-   // When short integer(s) are expected, read and convert the following 
-   // n *two characters properly i.e. as short integers as opposed to strings.
-   // Elements with Value Multiplicity > 1
-   // contain a set of integers (not a single one)       
-      if (vr == "US" || vr == "SS") {
+      // When short integer(s) are expected, read and convert the following 
+      // n *two characters properly i.e. consider them as short integers as
+      // opposed to strings.
+      // Elements with Value Multiplicity > 1
+      // contain a set of integers (not a single one)       
+      if (vr == "US" || vr == "SS")
+      {
          nbInt = length / 2;
          NewInt = ReadInt16();
          s << NewInt;
-         if (nbInt > 1){
-            for (int i=1; i < nbInt; i++) {
+         if (nbInt > 1)
+         {
+            for (int i=1; i < nbInt; i++)
+            {
                s << '\\';
                NewInt = ReadInt16();
                s << NewInt;
             }
          }
       }
-   // When integer(s) are expected, read and convert the following 
-   // n * four characters properly i.e. as integers as opposed to strings.
-   // Elements with Value Multiplicity > 1
-   // contain a set of integers (not a single one)           
-      else if (vr == "UL" || vr == "SL") {
+      // See above comment on multiple integers (mutatis mutandis).
+      else if (vr == "UL" || vr == "SL")
+      {
          nbInt = length / 4;
          NewInt = ReadInt32();
          s << NewInt;
-         if (nbInt > 1) {
-            for (int i=1; i < nbInt; i++) {
+         if (nbInt > 1)
+         {
+            for (int i=1; i < nbInt; i++)
+            {
                s << '\\';
                NewInt = ReadInt32();
                s << NewInt;
@@ -1632,16 +1527,26 @@ void gdcmDocument::LoadDocEntry(gdcmDocEntry *Entry)
    // We need an additional byte for storing \0 that is not on disk
    std::string NewValue(length,0);
    item_read = fread(&(NewValue[0]), (size_t)length, (size_t)1, fp);
-   if ( item_read != 1 ) {
-      dbg.Verbose(1, "gdcmDocument::LoadElementValue","unread element value");
-      ((gdcmValEntry *)Entry)->SetValue("gdcm::UnRead");
-      return;
-   }
+   if (gdcmValEntry* ValEntry = dynamic_cast< gdcmValEntry* >(Entry) )
+   {  
+      if ( item_read != 1 )
+      {
+         dbg.Verbose(1, "gdcmDocument::LoadDocEntry",
+                        "unread element value");
+         ValEntry->SetValue("gdcm::UnRead");
+         return;
+      }
 
-   if( (vr == "UI") ) // Because of correspondance with the VR dic
-      ((gdcmValEntry *)Entry)->SetValue(NewValue.c_str());
+      if( (vr == "UI") ) // Because of correspondance with the VR dic
+         ValEntry->SetValue(NewValue.c_str());
+      else
+         ValEntry->SetValue(NewValue);
+   }
    else
-      ((gdcmValEntry *)Entry)->SetValue(NewValue);
+   {
+      dbg.Error(true, "gdcmDocument::LoadDocEntry"
+                      "Should have a ValEntry, here !");
+   }
 }
 
 
@@ -1649,14 +1554,14 @@ void gdcmDocument::LoadDocEntry(gdcmDocEntry *Entry)
  * \brief  Find the value Length of the passed Header Entry
  * @param  Entry Header Entry whose length of the value shall be loaded. 
  */
- void gdcmDocument::FindDocEntryLength (gdcmDocEntry *Entry) {
-   guint16 element = Entry->GetElement();
-   //guint16 group   = Entry->GetGroup(); //FIXME
+void gdcmDocument::FindDocEntryLength (gdcmDocEntry *Entry)
+{
+   uint16_t element = Entry->GetElement();
    std::string  vr = Entry->GetVR();
-   guint16 length16;
+   uint16_t length16;
        
    
-   if ( (filetype == gdcmExplicitVR) && (! Entry->IsImplicitVR()) ) 
+   if ( (Filetype == gdcmExplicitVR) && (! Entry->IsImplicitVR()) ) 
    {
       if ( (vr=="OB") || (vr=="OW") || (vr=="SQ") || (vr=="UN") ) 
       {
@@ -1664,11 +1569,27 @@ void gdcmDocument::LoadDocEntry(gdcmDocEntry *Entry)
          // 7.1.2 Data element structure with explicit vr p27) must be
          // skipped before proceeding on reading the length on 4 bytes.
          fseek(fp, 2L, SEEK_CUR);
-         guint32 length32 = ReadInt32();
+         uint32_t length32 = ReadInt32();
 
          if ( (vr == "OB") && (length32 == 0xffffffff) ) 
          {
-            Entry->SetLength(FindDocEntryLengthOB());
+            uint32_t LengthOB = FindDocEntryLengthOB();
+            if ( errno == 1 )
+            {
+               // Computing the length failed (this happens with broken
+               // files like gdcm-JPEG-LossLess3a.dcm). We still have a
+               // chance to get the pixels by deciding the element goes
+               // until the end of the file. Hence we artificially fix the
+               // the length and proceed.
+               long CurrentPosition = ftell(fp);
+               fseek(fp,0L,SEEK_END);
+               long LengthUntilEOF = ftell(fp) - CurrentPosition;
+               fseek(fp, CurrentPosition, SEEK_SET);
+               Entry->SetLength(LengthUntilEOF);
+               errno = 0;
+               return;
+            }
+            Entry->SetLength(LengthOB);
             return;
          }
          FixDocEntryFoundLength(Entry, length32); 
@@ -1717,8 +1638,8 @@ void gdcmDocument::LoadDocEntry(gdcmDocEntry *Entry)
          SwitchSwapToBigEndian();
          // Restore the unproperly loaded values i.e. the group, the element
          // and the dictionary entry depending on them.
-         guint16 CorrectGroup   = SwapShort(Entry->GetGroup());
-         guint16 CorrectElem    = SwapShort(Entry->GetElement());
+         uint16_t CorrectGroup   = SwapShort(Entry->GetGroup());
+         uint16_t CorrectElem    = SwapShort(Entry->GetElement());
          gdcmDictEntry * NewTag = GetDictEntryByNumber(CorrectGroup,
                                                        CorrectElem);
          if (!NewTag) 
@@ -1731,16 +1652,14 @@ void gdcmDocument::LoadDocEntry(gdcmDocEntry *Entry)
          Entry->SetDictEntry(NewTag);
       }
        
-      // Heuristic: well some files are really ill-formed.
+      // Heuristic: well, some files are really ill-formed.
       if ( length16 == 0xffff) 
       {
          length16 = 0;
-         //dbg.Verbose(0, "gdcmDocument::FindLength",
-         //            "Erroneous element length fixed.");
-         // Actually, length= 0xffff means that we deal with
-         // Unknown Sequence Length 
+         // Length16= 0xffff means that we deal with
+         // 'Unknown Length' Sequence  
       }
-      FixDocEntryFoundLength(Entry, (guint32)length16);
+      FixDocEntryFoundLength(Entry, (uint32_t)length16);
       return;
    }
    else
@@ -1763,7 +1682,7 @@ void gdcmDocument::LoadDocEntry(gdcmDocEntry *Entry)
  */
 void gdcmDocument::FindDocEntryVR( gdcmDocEntry *Entry) 
 {
-   if (filetype != gdcmExplicitVR)
+   if (Filetype != gdcmExplicitVR)
       return;
 
    char VR[3];
@@ -1802,7 +1721,7 @@ void gdcmDocument::FindDocEntryVR( gdcmDocEntry *Entry)
  * @return    false if the VR is incorrect of if the VR isn't referenced
  *            otherwise, it returns true
 */
-bool gdcmDocument::CheckDocEntryVR(gdcmDocEntry *Entry, VRKey vr)
+bool gdcmDocument::CheckDocEntryVR(gdcmDocEntry *Entry, gdcmVRKey vr)
 {
    char msg[100]; // for sprintf
    bool RealExplicit = true;
@@ -1837,7 +1756,7 @@ bool gdcmDocument::CheckDocEntryVR(gdcmDocEntry *Entry, VRKey vr)
                                    "UL","FIXME","Group Length");
          Entry->SetDictEntry(NewEntry);     
       }
-      return(false);
+      return false;
    }
 
    if ( Entry->IsVRUnknown() ) 
@@ -1861,7 +1780,7 @@ bool gdcmDocument::CheckDocEntryVR(gdcmDocEntry *Entry, VRKey vr)
                                  vr,"FIXME",Entry->GetName());
       Entry->SetDictEntry(NewEntry);
    }
-   return(true); 
+   return true; 
 }
 
 /**
@@ -1877,7 +1796,7 @@ std::string gdcmDocument::GetDocEntryValue(gdcmDocEntry *Entry)
    {
       std::string val=((gdcmValEntry *)Entry)->GetValue();
       std::string vr=Entry->GetVR();
-      guint32 length = Entry->GetLength();
+      uint32_t length = Entry->GetLength();
       std::ostringstream s;
       int nbInt;
 
@@ -1890,7 +1809,7 @@ std::string gdcmDocument::GetDocEntryValue(gdcmDocEntry *Entry)
    
       if (vr == "US" || vr == "SS")
       {
-         guint16 NewInt16;
+         uint16_t NewInt16;
 
          nbInt = length / 2;
          for (int i=0; i < nbInt; i++) 
@@ -1911,7 +1830,7 @@ std::string gdcmDocument::GetDocEntryValue(gdcmDocEntry *Entry)
    // contain a set of integers (not a single one) 
       else if (vr == "UL" || vr == "SL")
       {
-         guint32 NewInt32;
+         uint32_t NewInt32;
 
          nbInt = length / 4;
          for (int i=0; i < nbInt; i++) 
@@ -1927,10 +1846,10 @@ std::string gdcmDocument::GetDocEntryValue(gdcmDocEntry *Entry)
 #ifdef GDCM_NO_ANSI_STRING_STREAM
       s << std::ends; // to avoid oddities on Solaris
 #endif //GDCM_NO_ANSI_STRING_STREAM
-      return(s.str());
+      return s.str();
    }
 
-   return(((gdcmValEntry *)Entry)->GetValue());
+   return ((gdcmValEntry *)Entry)->GetValue();
 }
 
 /**
@@ -1951,7 +1870,7 @@ std::string gdcmDocument::GetDocEntryUnvalue(gdcmDocEntry *Entry)
 
       if (vr == "US" || vr == "SS") 
       {
-         guint16 NewInt16;
+         uint16_t NewInt16;
 
          tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
          Tokenize (((gdcmValEntry *)Entry)->GetValue(), tokens, "\\");
@@ -1964,7 +1883,7 @@ std::string gdcmDocument::GetDocEntryUnvalue(gdcmDocEntry *Entry)
       }
       if (vr == "UL" || vr == "SL") 
       {
-         guint32 NewInt32;
+         uint32_t NewInt32;
 
          tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
          Tokenize (((gdcmValEntry *)Entry)->GetValue(), tokens, "\\");
@@ -1980,10 +1899,10 @@ std::string gdcmDocument::GetDocEntryUnvalue(gdcmDocEntry *Entry)
 #ifdef GDCM_NO_ANSI_STRING_STREAM
       s << std::ends; // to avoid oddities on Solaris
 #endif //GDCM_NO_ANSI_STRING_STREAM
-      return(s.str());
+      return s.str();
    }
 
-   return(((gdcmValEntry *)Entry)->GetValue());
+   return ((gdcmValEntry *)Entry)->GetValue();
 }
 
 /**
@@ -2007,31 +1926,21 @@ void gdcmDocument::SkipToNextDocEntry(gdcmDocEntry *entry)
    (void)fseek(fp, (long)(entry->GetReadLength()), SEEK_CUR);
 }
 
-/**
- * \brief   Loads the value for a a given VLEntry 
- * \warning NOT end user intended method !
- * @param   entry 
- */
-void gdcmDocument::LoadVLEntry(gdcmDocEntry *entry) 
-{
-    //SkipBytes(entry->GetLength());
-    LoadDocEntry(entry);
-}
 /**
  * \brief   When the length of an element value is obviously wrong (because
  *          the parser went Jabberwocky) one can hope improving things by
  *          applying some heuristics.
  */
 void gdcmDocument::FixDocEntryFoundLength(gdcmDocEntry *Entry,
-                                          guint32 FoundLength)
+                                          uint32_t FoundLength)
 {
    Entry->SetReadLength(FoundLength); // will be updated only if a bug is found        
    if ( FoundLength == 0xffffffff) {
       FoundLength = 0;
    }
    
-   guint16 gr =Entry->GetGroup();
-   guint16 el =Entry->GetElement(); 
+   uint16_t gr =Entry->GetGroup();
+   uint16_t el =Entry->GetElement(); 
      
    if (FoundLength%2) {
       std::ostringstream s;
@@ -2102,10 +2011,10 @@ void gdcmDocument::FixDocEntryFoundLength(gdcmDocEntry *Entry,
  * @return  The result of the heuristical predicate.
  */
 bool gdcmDocument::IsDocEntryAnInteger(gdcmDocEntry *Entry) {
-   guint16 element = Entry->GetElement();
-   guint16 group   = Entry->GetGroup();
-   std::string  vr = Entry->GetVR();
-   guint32 length  = Entry->GetLength();
+   uint16_t element = Entry->GetElement();
+   uint16_t group   = Entry->GetGroup();
+   std::string  vr  = Entry->GetVR();
+   uint32_t length  = Entry->GetLength();
 
    // When we have some semantics on the element we just read, and if we
    // a priori know we are dealing with an integer, then we shall be
@@ -2145,14 +2054,14 @@ bool gdcmDocument::IsDocEntryAnInteger(gdcmDocEntry *Entry) {
  * @return 
  */
 
- guint32 gdcmDocument::FindDocEntryLengthOB(void)  {
+uint32_t gdcmDocument::FindDocEntryLengthOB()  {
    // See PS 3.5-2001, section A.4 p. 49 on encapsulation of encoded pixel data.
-   guint16 g;
-   guint16 n; 
+   uint16_t g;
+   uint16_t n; 
    long PositionOnEntry = ftell(fp);
    bool FoundSequenceDelimiter = false;
-   guint32 TotalLength = 0;
-   guint32 ItemLength;
+   uint32_t TotalLength = 0;
+   uint32_t ItemLength;
 
    while ( ! FoundSequenceDelimiter) 
    {
@@ -2160,31 +2069,30 @@ bool gdcmDocument::IsDocEntryAnInteger(gdcmDocEntry *Entry) {
       n = ReadInt16();   
       if (errno == 1)
          return 0;
-      TotalLength += 4;  // We even have to decount the group and element 
+
+     // We have to decount the group and element we just read
+      TotalLength += 4;
      
-      if ( g != 0xfffe && g!=0xb00c ) //for bogus header  
+      if (     ( g != 0xfffe )
+          || ( ( n != 0xe0dd ) && ( n != 0xe000 ) ) )
       {
-         char msg[100]; // for sprintf. Sorry
-         sprintf(msg,"wrong group (%04x) for an item sequence (%04x,%04x)\n",g, g,n);
-         dbg.Verbose(1, "gdcmDocument::FindLengthOB: ",msg); 
+         dbg.Verbose(1, "gdcmDocument::FindLengthOB: neither an Item tag "
+                        "nor a Sequence delimiter tag."); 
+         fseek(fp, PositionOnEntry, SEEK_SET);
          errno = 1;
          return 0;
       }
-      if ( n == 0xe0dd || ( g==0xb00c && n==0x0eb6 ) ) // for bogus header 
+
+      if ( n == 0xe0dd )
          FoundSequenceDelimiter = true;
-      else if ( n != 0xe000 )
-      {
-         char msg[100];  // for sprintf. Sorry
-         sprintf(msg,"wrong element (%04x) for an item sequence (%04x,%04x)\n",
-                      n, g,n);
-         dbg.Verbose(1, "gdcmDocument::FindLengthOB: ",msg);
-         errno = 1;
-         return 0;
-      }
+
       ItemLength = ReadInt32();
-      TotalLength += ItemLength + 4;  // We add 4 bytes since we just read
-                                      // the ItemLength with ReadInt32                                     
+      // We add 4 bytes since we just read the ItemLength with ReadInt32
+      TotalLength += ItemLength + 4;
       SkipBytes(ItemLength);
+      
+      if ( FoundSequenceDelimiter )
+         break;
    }
    fseek(fp, PositionOnEntry, SEEK_SET);
    return TotalLength;
@@ -2195,8 +2103,8 @@ bool gdcmDocument::IsDocEntryAnInteger(gdcmDocEntry *Entry) {
  *       (swaps it depending on processor endianity) 
  * @return read value
  */
-guint16 gdcmDocument::ReadInt16(void) {
-   guint16 g;
+uint16_t gdcmDocument::ReadInt16() {
+   uint16_t g;
    size_t item_read;
    item_read = fread (&g, (size_t)2,(size_t)1, fp);
    if ( item_read != 1 ) {
@@ -2215,8 +2123,8 @@ guint16 gdcmDocument::ReadInt16(void) {
  *         (swaps it depending on processor endianity)  
  * @return read value
  */
-guint32 gdcmDocument::ReadInt32(void) {
-   guint32 g;
+uint32_t gdcmDocument::ReadInt32() {
+   uint32_t g;
    size_t item_read;
    item_read = fread (&g, (size_t)4,(size_t)1, fp);
    if ( item_read != 1 ) { 
@@ -2235,7 +2143,7 @@ guint32 gdcmDocument::ReadInt32(void) {
  * \warning NOT end user intended method !
  * @return 
  */
-void gdcmDocument::SkipBytes(guint32 NBytes) {
+void gdcmDocument::SkipBytes(uint32_t NBytes) {
    //FIXME don't dump the returned value
    (void)fseek(fp, (long)NBytes, SEEK_CUR);
 }
@@ -2244,10 +2152,10 @@ void gdcmDocument::SkipBytes(guint32 NBytes) {
  * \brief Loads all the needed Dictionaries
  * \warning NOT end user intended method !   
  */
-void gdcmDocument::Initialise(void) 
+void gdcmDocument::Initialise() 
 {
    RefPubDict = gdcmGlobal::GetDicts()->GetDefaultPubDict();
-   RefShaDict = (gdcmDict*)0;
+   RefShaDict = NULL;
 }
 
 /**
@@ -2265,10 +2173,10 @@ bool gdcmDocument::CheckSwap() {
    // 0x00000004. Finding the swap code in then straigthforward. Trouble
    // occurs when we can't find such group...
    
-   guint32  x=4;  // x : for ntohs
+   uint32_t  x=4;  // x : for ntohs
    bool net2host; // true when HostByteOrder is the same as NetworkByteOrder
-   guint32  s32;
-   guint16  s16;
+   uint32_t  s32;
+   uint16_t  s16;
        
    int lgrLue;
    char *entCur;
@@ -2320,13 +2228,13 @@ bool gdcmDocument::CheckSwap() {
       // Use gdcmDocument::dicom_vr to test all the possibilities
       // instead of just checking for UL, OB and UI !? group 0000 
       {
-         filetype = gdcmExplicitVR;
+         Filetype = gdcmExplicitVR;
          dbg.Verbose(1, "gdcmDocument::CheckSwap:",
                      "explicit Value Representation");
       } 
       else 
       {
-         filetype = gdcmImplicitVR;
+         Filetype = gdcmImplicitVR;
          dbg.Verbose(1, "gdcmDocument::CheckSwap:",
                      "not an explicit Value Representation");
       }
@@ -2366,24 +2274,24 @@ bool gdcmDocument::CheckSwap() {
    // We assume the array of char we are considering contains the binary
    // representation of a 32 bits integer. Hence the following dirty
    // trick :
-   s32 = *((guint32 *)(entCur));
+   s32 = *((uint32_t *)(entCur));
       
    switch (s32) {
       case 0x00040000 :
          sw = 3412;
-         filetype = gdcmACR;
+         Filetype = gdcmACR;
          return true;
       case 0x04000000 :
          sw = 4321;
-         filetype = gdcmACR;
+         Filetype = gdcmACR;
          return true;
       case 0x00000400 :
          sw = 2143;
-         filetype = gdcmACR;
+         Filetype = gdcmACR;
          return true;
       case 0x00000004 :
          sw = 0;
-         filetype = gdcmACR;
+         Filetype = gdcmACR;
          return true;
       default :
 
@@ -2402,25 +2310,25 @@ bool gdcmDocument::CheckSwap() {
       //  the file IS NOT ACR-NEMA nor DICOM V3
       //  Find a trick to tell it the caller...
       
-      s16 = *((guint16 *)(deb));
+      s16 = *((uint16_t *)(deb));
       
       switch (s16) {
       case 0x0002 :
       case 0x0004 :
       case 0x0008 :      
          sw = 0;
-         filetype = gdcmACR;
+         Filetype = gdcmACR;
          return true;
       case 0x0200 :
       case 0x0400 :
       case 0x0800 : 
          sw = 4321;
-         filetype = gdcmACR;
+         Filetype = gdcmACR;
          return true;
       default :
          dbg.Verbose(0, "gdcmDocument::CheckSwap:",
                      "ACR/NEMA unfound swap info (Really hopeless !)"); 
-         filetype = gdcmUnknown;     
+         Filetype = gdcmUnknown;     
          return false;
       }
       
@@ -2437,7 +2345,7 @@ bool gdcmDocument::CheckSwap() {
  * \brief Restore the unproperly loaded values i.e. the group, the element
  *        and the dictionary entry depending on them. 
  */
-void gdcmDocument::SwitchSwapToBigEndian(void) 
+void gdcmDocument::SwitchSwapToBigEndian() 
 {
    dbg.Verbose(1, "gdcmDocument::SwitchSwapToBigEndian",
                   "Switching to BigEndian mode.");
@@ -2468,7 +2376,7 @@ void gdcmDocument::SetMaxSizeLoadEntry(long NewSize)
 {
    if (NewSize < 0)
       return;
-   if ((guint32)NewSize >= (guint32)0xffffffff) 
+   if ((uint32_t)NewSize >= (uint32_t)0xffffffff) 
    {
       MaxSizeLoadEntry = 0xffffffff;
       return;
@@ -2486,7 +2394,7 @@ void gdcmDocument::SetMaxSizePrintEntry(long NewSize)
 {
    if (NewSize < 0)
       return;
-   if ((guint32)NewSize >= (guint32)0xffffffff) 
+   if ((uint32_t)NewSize >= (uint32_t)0xffffffff) 
    {
       MaxSizePrintEntry = 0xffffffff;
       return;
@@ -2503,11 +2411,10 @@ void gdcmDocument::SetMaxSizePrintEntry(long NewSize)
  *          gets the VR, gets the length, gets the offset value)
  * @return  On succes the newly created DocEntry, NULL on failure.      
  */
-gdcmDocEntry *gdcmDocument::ReadNextDocEntry(void) {
-   guint16 g,n;
+gdcmDocEntry *gdcmDocument::ReadNextDocEntry() {
+   uint16_t g = ReadInt16();
+   uint16_t n = ReadInt16();
    gdcmDocEntry *NewEntry;
-   g = ReadInt16();
-   n = ReadInt16();
       
    if (errno == 1)
       // We reached the EOF (or an error occured) therefore 
@@ -2518,7 +2425,8 @@ gdcmDocEntry *gdcmDocument::ReadNextDocEntry(void) {
    FindDocEntryVR(NewEntry);
    FindDocEntryLength(NewEntry);
 
-   if (errno == 1) {
+   if (errno == 1)
+   {
       // Call it quits
       delete NewEntry;
       return NULL;
@@ -2527,221 +2435,46 @@ gdcmDocEntry *gdcmDocument::ReadNextDocEntry(void) {
    return NewEntry;
 }
 
-/**
- * \brief   Build a new Element Value from all the low level arguments. 
- *          Check for existence of dictionary entry, and build
- *          a default one when absent.
- * @param   Name    Name of the underlying DictEntry
- */
-gdcmDocEntry *gdcmDocument::NewDocEntryByName(std::string Name) 
-{
-   gdcmDictEntry *NewTag = GetDictEntryByName(Name);
-   if (!NewTag)
-      NewTag = NewVirtualDictEntry(0xffff, 0xffff, "LO", "unkn", Name);
-
-   gdcmDocEntry* NewEntry = new gdcmDocEntry(NewTag);
-   if (!NewEntry) 
-   {
-      dbg.Verbose(1, "gdcmDocument::ObtainDocEntryByName",
-                  "failed to allocate gdcmDocEntry");
-      return (gdcmDocEntry *)0;
-   }
-   return NewEntry;
-}  
-
-/**
- * \brief   Request a new virtual dict entry to the dict set
- * @param   group     group  number of the underlying DictEntry
- * @param   element  element number of the underlying DictEntry
- * @param   vr     VR of the underlying DictEntry
- * @param   fourth owner group
- * @param   name   english name
- */
-gdcmDictEntry *gdcmDocument::NewVirtualDictEntry(guint16 group, guint16 element,
-                                               std::string vr,
-                                               std::string fourth,
-                                               std::string name)
-{
-   return gdcmGlobal::GetDicts()->NewVirtualDictEntry(group,element,vr,fourth,name);
-}
-
-/**
- * \brief   Build a new Element Value from all the low level arguments. 
- *          Check for existence of dictionary entry, and build
- *          a default one when absent.
- * @param   Group group   number of the underlying DictEntry
- * @param   Elem  element number of the underlying DictEntry
- */
-gdcmDocEntry* gdcmDocument::NewDocEntryByNumber(guint16 Group, guint16 Elem) 
-{
-   // Find out if the tag we encountered is in the dictionaries:
-   gdcmDictEntry *DictEntry = GetDictEntryByNumber(Group, Elem);
-   if (!DictEntry)
-      DictEntry = NewVirtualDictEntry(Group, Elem);
-
-   gdcmDocEntry *NewEntry = new gdcmDocEntry(DictEntry);
-   if (!NewEntry) 
-   {
-      dbg.Verbose(1, "gdcmDocument::NewDocEntryByNumber",
-                  "failed to allocate gdcmDocEntry");
-      return (gdcmDocEntry*)0;
-   }
-   return NewEntry;
-}
-
-
-/**
- * \brief   Build a new Element Value from all the low level arguments. 
- *          Check for existence of dictionary entry, and build
- *          a default one when absent.
- * @param   Group group   number of the underlying DictEntry
- * @param   Elem  element number of the underlying DictEntry
- */
-gdcmValEntry *gdcmDocument::NewValEntryByNumber(guint16 Group, guint16 Elem) 
-{
-   // Find out if the tag we encountered is in the dictionaries:
-   gdcmDictEntry *DictEntry = GetDictEntryByNumber(Group, Elem);
-   if (!DictEntry)
-      DictEntry = NewVirtualDictEntry(Group, Elem);
-
-   gdcmValEntry *NewEntry = new gdcmValEntry(DictEntry);
-   if (!NewEntry) 
-   {
-      dbg.Verbose(1, "gdcmDocument::NewValEntryByNumber",
-                  "failed to allocate gdcmValEntry");
-      return NULL;
-   }
-   return NewEntry;
-}
-
-
-/**
- * \brief   Build a new Element Value from all the low level arguments. 
- *          Check for existence of dictionary entry, and build
- *          a default one when absent.
- * @param   Group group   number of the underlying DictEntry
- * @param   Elem  element number of the underlying DictEntry
- */
-gdcmBinEntry *gdcmDocument::NewBinEntryByNumber(guint16 Group, guint16 Elem) 
-{
-   // Find out if the tag we encountered is in the dictionaries:
-   gdcmDictEntry *DictEntry = GetDictEntryByNumber(Group, Elem);
-   if (!DictEntry)
-      DictEntry = NewVirtualDictEntry(Group, Elem);
-
-   gdcmBinEntry *NewEntry = new gdcmBinEntry(DictEntry);
-   if (!NewEntry) 
-   {
-      dbg.Verbose(1, "gdcmDocument::NewBinEntryByNumber",
-                  "failed to allocate gdcmBinEntry");
-      return NULL;
-   }
-   return NewEntry;
-}
 
 /**
- * \brief   Generate a free TagKey i.e. a TagKey that is not present
+ * \brief   Generate a free gdcmTagKey i.e. a gdcmTagKey that is not present
  *          in the TagHt dictionary.
  * @param   group The generated tag must belong to this group.  
  * @return  The element of tag with given group which is fee.
  */
-guint32 gdcmDocument::GenerateFreeTagKeyInGroup(guint16 group) 
+uint32_t gdcmDocument::GenerateFreeTagKeyInGroup(uint16_t group) 
 {
-   for (guint32 elem = 0; elem < UINT32_MAX; elem++) 
+   for (uint32_t elem = 0; elem < UINT32_MAX; elem++) 
    {
-      TagKey key = gdcmDictEntry::TranslateToKey(group, elem);
+      gdcmTagKey key = gdcmDictEntry::TranslateToKey(group, elem);
       if (tagHT.count(key) == 0)
          return elem;
    }
    return UINT32_MAX;
 }
 
-
-/**
- * \brief   Searches both the public and the shadow dictionary (when they
- *          exist) for the presence of the DictEntry with given name.
- *          The public dictionary has precedence on the shadow one.
- * @param   Name name of the searched DictEntry
- * @return  Corresponding DictEntry when it exists, NULL otherwise.
- */
-gdcmDictEntry *gdcmDocument::GetDictEntryByName(std::string Name) 
-{
-   gdcmDictEntry *found = (gdcmDictEntry *)0;
-   if (!RefPubDict && !RefShaDict) 
-   {
-      dbg.Verbose(0, "gdcmDocument::GetDictEntry",
-                     "we SHOULD have a default dictionary");
-   }
-   if (RefPubDict) 
-   {
-      found = RefPubDict->GetDictEntryByName(Name);
-      if (found)
-         return found;
-   }
-   if (RefShaDict) 
-   {
-      found = RefShaDict->GetDictEntryByName(Name);
-      if (found)
-         return found;
-   }
-   return found;
-}
-
-/**
- * \brief   Searches both the public and the shadow dictionary (when they
- *          exist) for the presence of the DictEntry with given
- *          group and element. The public dictionary has precedence on the
- *          shadow one.
- * @param   group   group number of the searched DictEntry
- * @param   element element number of the searched DictEntry
- * @return  Corresponding DictEntry when it exists, NULL otherwise.
- */
-gdcmDictEntry *gdcmDocument::GetDictEntryByNumber(guint16 group,guint16 element) 
-{
-   gdcmDictEntry *found = (gdcmDictEntry *)0;
-   if (!RefPubDict && !RefShaDict) 
-   {
-      dbg.Verbose(0, "gdcmDocument::GetDictEntry",
-                     "we SHOULD have a default dictionary");
-   }
-   if (RefPubDict) 
-   {
-      found = RefPubDict->GetDictEntryByNumber(group, element);
-      if (found)
-         return found;
-   }
-   if (RefShaDict) 
-   {
-      found = RefShaDict->GetDictEntryByNumber(group, element);
-      if (found)
-         return found;
-   }
-   return found;
-}
-
 /**
  * \brief   Assuming the internal file pointer \ref gdcmDocument::fp 
- *          is placed at the beginning of a tag (TestGroup, TestElement),
- *          read the length associated to the Tag.
+ *          is placed at the beginning of a tag check whether this
+ *          tag is (TestGroup, TestElement).
  * \warning On success the internal file pointer \ref gdcmDocument::fp
- *          is modified to point after the tag and it's length.
+ *          is modified to point after the tag.
  *          On failure (i.e. when the tag wasn't the expected tag
  *          (TestGroup, TestElement) the internal file pointer
  *          \ref gdcmDocument::fp is restored to it's original position.
  * @param   TestGroup   The expected group of the tag.
  * @param   TestElement The expected Element of the tag.
- * @return  On success returns the length associated to the tag. On failure
- *          returns 0.
+ * @return  True on success, false otherwise.
  */
-guint32 gdcmDocument::ReadTagLength(guint16 TestGroup, guint16 TestElement)
+bool gdcmDocument::ReadTag(uint16_t TestGroup, uint16_t TestElement)
 {
-   guint16 ItemTagGroup;
-   guint16 ItemTagElement; 
+   uint16_t ItemTagGroup;
+   uint16_t ItemTagElement; 
    long PositionOnEntry = ftell(fp);
    long CurrentPosition = ftell(fp);          // On debugging purposes
 
    //// Read the Item Tag group and element, and make
-   // sure they are respectively 0xfffe and 0xe000:
+   // sure they are what we expected:
    ItemTagGroup   = ReadInt16();
    ItemTagElement = ReadInt16();
    if ( (ItemTagGroup != TestGroup) || (ItemTagElement != TestElement ) )
@@ -2756,12 +2489,38 @@ guint32 gdcmDocument::ReadTagLength(guint16 TestGroup, guint16 TestElement)
       dbg.Verbose(0, "gdcmDocument::ReadItemTagLength: wrong Item Tag found:");
       dbg.Verbose(0, s.str().c_str());
       fseek(fp, PositionOnEntry, SEEK_SET);
+      return false;
+   }
+   return true;
+}
+
+/**
+ * \brief   Assuming the internal file pointer \ref gdcmDocument::fp 
+ *          is placed at the beginning of a tag (TestGroup, TestElement),
+ *          read the length associated to the Tag.
+ * \warning On success the internal file pointer \ref gdcmDocument::fp
+ *          is modified to point after the tag and it's length.
+ *          On failure (i.e. when the tag wasn't the expected tag
+ *          (TestGroup, TestElement) the internal file pointer
+ *          \ref gdcmDocument::fp is restored to it's original position.
+ * @param   TestGroup   The expected group of the tag.
+ * @param   TestElement The expected Element of the tag.
+ * @return  On success returns the length associated to the tag. On failure
+ *          returns 0.
+ */
+uint32_t gdcmDocument::ReadTagLength(uint16_t TestGroup, uint16_t TestElement)
+{
+   long PositionOnEntry = ftell(fp);
+   (void)PositionOnEntry;
+
+   if ( !ReadTag(TestGroup, TestElement) )
+   {
       return 0;
    }
                                                                                 
    //// Then read the associated Item Length
-   CurrentPosition=ftell(fp);
-   guint32 ItemLength;
+   long CurrentPosition = ftell(fp);
+   uint32_t ItemLength;
    ItemLength = ReadInt32();
    {
       std::ostringstream s;
@@ -2773,38 +2532,12 @@ guint32 gdcmDocument::ReadTagLength(guint16 TestGroup, guint16 TestElement)
    return ItemLength;
 }
 
-/**
- * \brief   Read the length of an exptected Item tag i.e. (0xfffe, 0xe000).
- * \sa      \ref gdcmDocument::ReadTagLength
- * \warning See warning of \ref gdcmDocument::ReadTagLength
- * @return  On success returns the length associated to the item tag.
- *          On failure returns 0.
- */ 
-guint32 gdcmDocument::ReadItemTagLength(void)
-{
-   return ReadTagLength(0xfffe, 0xe000);
-}
-
-/**
- * \brief   Read the length of an exptected Sequence Delimiter tag i.e.
- *          (0xfffe, 0xe0dd).
- * \sa      \ref gdcmDocument::ReadTagLength
- * \warning See warning of \ref gdcmDocument::ReadTagLength
- * @return  On success returns the length associated to the Sequence
- *          Delimiter tag. On failure returns 0.
- */
-guint32 gdcmDocument::ReadSequenceDelimiterTagLength(void)
-{
-   return ReadTagLength(0xfffe, 0xe0dd);
-}
-
-
 /**
  * \brief   Parse pixel data from disk for multi-fragment Jpeg/Rle files
  *          No other way so 'skip' the Data
  *
  */
-void gdcmDocument::Parse7FE0 (void)
+void gdcmDocument::Parse7FE0 ()
 {
    gdcmDocEntry* Element = GetDocEntryByNumber(0x0002, 0x0010);
    if ( !Element )
@@ -2815,11 +2548,11 @@ void gdcmDocument::Parse7FE0 (void)
        || IsExplicitVRBigEndianTransferSyntax() /// \todo 1.2.2 ??? A verifier !
        || IsDeflatedExplicitVRLittleEndianTransferSyntax() )
       return;
-      
+
    // ---------------- for Parsing : Position on begining of Jpeg/RLE Pixels 
 
    //// Read the Basic Offset Table Item Tag length...
-   guint32 ItemLength = ReadItemTagLength();
+   uint32_t ItemLength = ReadTagLength(0xfffe, 0xe000);
 
    //// ... and then read length[s] itself[themselves]. We don't use
    // the values read (BTW  what is the purpous of those lengths ?)
@@ -2827,9 +2560,9 @@ void gdcmDocument::Parse7FE0 (void)
       // BTW, what is the purpous of those length anyhow !? 
       char * BasicOffsetTableItemValue = new char[ItemLength + 1];
       fread(BasicOffsetTableItemValue, ItemLength, 1, fp); 
-      for (int i=0; i < ItemLength; i += 4){
-         guint32 IndividualLength;
-         IndividualLength = str2num(&BasicOffsetTableItemValue[i],guint32);
+      for (unsigned int i=0; i < ItemLength; i += 4){
+         uint32_t IndividualLength;
+         IndividualLength = str2num(&BasicOffsetTableItemValue[i],uint32_t);
          std::ostringstream s;
          s << "   Read one length: ";
          s << std::hex << IndividualLength << std::endl;
@@ -2842,11 +2575,10 @@ void gdcmDocument::Parse7FE0 (void)
       // JPEG Image
       
       //// We then skip (not reading them) all the fragments of images:
-      while ( ItemLength = ReadItemTagLength() )
+      while ( (ItemLength = ReadTagLength(0xfffe, 0xe000)) )
       {
          SkipBytes(ItemLength);
       } 
-
    }
    else
    {
@@ -2854,22 +2586,18 @@ void gdcmDocument::Parse7FE0 (void)
       long ftellRes;
       long RleSegmentLength[15], fragmentLength;
 
-      // while 'Sequence Delimiter Item' (fffe,e0dd) not found
-      while ( fragmentLength = ReadSequenceDelimiterTagLength() )
+      // While we find some items:
+      while ( (fragmentLength = ReadTagLength(0xfffe, 0xe000)) )
       { 
          // Parse fragments of the current Fragment (Frame)    
          //------------------ scanning (not reading) fragment pixels
-         guint32 nbRleSegments = ReadInt32();
-         printf("   Nb of RLE Segments : %d\n",nbRleSegments);
+         uint32_t nbRleSegments = ReadInt32();
  
          //// Reading RLE Segments Offset Table
-         guint32 RleSegmentOffsetTable[15];
+         uint32_t RleSegmentOffsetTable[15];
          for(int k=1; k<=15; k++) {
             ftellRes=ftell(fp);
             RleSegmentOffsetTable[k] = ReadInt32();
-            printf("        at : %x Offset Segment %d : %d (%x)\n",
-                    (unsigned)ftellRes,k,RleSegmentOffsetTable[k],
-                    RleSegmentOffsetTable[k]);
          }
 
          // skipping (not reading) RLE Segments
@@ -2878,9 +2606,6 @@ void gdcmDocument::Parse7FE0 (void)
                 RleSegmentLength[k]=   RleSegmentOffsetTable[k+1]
                                      - RleSegmentOffsetTable[k];
                 ftellRes=ftell(fp);
-                printf ("  Segment %d : Length = %d x(%x) Start at %x\n",
-                        k,(unsigned)RleSegmentLength[k],
-                       (unsigned)RleSegmentLength[k], (unsigned)ftellRes);
                 SkipBytes(RleSegmentLength[k]);    
              }
           }
@@ -2888,15 +2613,21 @@ void gdcmDocument::Parse7FE0 (void)
           RleSegmentLength[nbRleSegments]= fragmentLength 
                                          - RleSegmentOffsetTable[nbRleSegments];
           ftellRes=ftell(fp);
-          printf ("  Segment %d : Length = %d x(%x) Start at %x\n",
-                  nbRleSegments,(unsigned)RleSegmentLength[nbRleSegments],
-                  (unsigned)RleSegmentLength[nbRleSegments],(unsigned)ftellRes);
           SkipBytes(RleSegmentLength[nbRleSegments]); 
       } 
+
+      // Make sure that at the end of the item we encounter a 'Sequence
+      // Delimiter Item':
+      if ( ! ReadTag(0xfffe, 0xe0dd) )
+      {
+         dbg.Verbose(0, "gdcmDocument::Parse7FE0: no sequence delimiter item");
+         dbg.Verbose(0, "    at end of RLE item sequence");
+      }
    }
-   return;            
 }
 
+
+
 /**
  * \brief   Compares two documents, according to \ref gdcmDicomDir rules
  * \warning Does NOT work with ACR-NEMA files
@@ -2904,47 +2635,48 @@ void gdcmDocument::Parse7FE0 (void)
  * @param   document
  * @return  true if 'smaller'
  */
- bool gdcmDocument::operator<(gdcmDocument &document){
+bool gdcmDocument::operator<(gdcmDocument &document)
+{
    std::string s1,s2;
                                                                                 
    // Patient Name
    s1=this->GetEntryByNumber(0x0010,0x0010);
    s2=document.GetEntryByNumber(0x0010,0x0010);
    if(s1 < s2)
-      return(true);
+      return true;
    else if(s1 > s2)
-      return(false);
+      return false;
    else
    {
       // Patient ID
       s1=this->GetEntryByNumber(0x0010,0x0020);
       s2=document.GetEntryByNumber(0x0010,0x0020);
       if (s1 < s2)
-         return(true);
+         return true;
       else if (s1 > s2)
-         return(1);
+         return true;
       else
       {
          // Study Instance UID
          s1=this->GetEntryByNumber(0x0020,0x000d);
          s2=document.GetEntryByNumber(0x0020,0x000d);
          if (s1 < s2)
-            return(true);
+            return true;
          else if(s1 > s2)
-            return(false);
+            return false;
          else
          {
             // Serie Instance UID
             s1=this->GetEntryByNumber(0x0020,0x000e);
             s2=document.GetEntryByNumber(0x0020,0x000e);
             if (s1 < s2)
-               return(true);
+               return true;
             else if(s1 > s2)
-               return(false);
+               return false;
          }
       }
    }
-   return(false);
+   return false;
 }