BUG in DDD with french source code files

[Yves Boyadjian]

Hi,

I found a bug in DDD.

When i read a source code file that contains
characters whith accents in his comments
(Like a source code file whith french comments),
the debugger stops reading the file where the
accent is.

Please find an attached example of such a file.

Best regards.

Yves BOYADJIAN

Tech-Advantage

Rueil-Malmaison

France

/*================================================== Beicip-Franlab - CVS 
header =====

  MODULE : SIMView DB / Implémentation HDF-VSet

  AUTHOR : Eric Vives / Loïc Guidoni / Olivier Erb

  FILE   : EGA_baseelem_impl.c

  PURPOSE: Implémemtation du baseelem en HDF/VSET.

  
====================================================================================*/

//____includes DB 
implémentation_____________________________________________________
#include "EGA_baseelem_impl.h"
#include "EGA_impl_tools.h"
#include <EGA_lib.h>
//____includes 
standards_____________________________________________________________
#ifndef MAKEDEPEND
#include <sys/types.h>
#include <sys/stat.h>
#include <GdkBase/Gdkfstream.h>

#ifndef _WIN32
#include <unistd.h>
#include <signal.h>
#else
#include <direct.h>
#define F_OK 0
#define access(a,b) _access(a,b)
#endif
#endif
/*------------------------------------------------------------------------------------
  MEMBER : base_delete
  CLASS  : EGA_BaseElem_impl
  PURPOSE: Destruction physique de l'élément. Il s'agit en particulier de 
supprimer
           les fichiers "externes" copiés sous DBlinks.
  
------------------------------------------------------------------------------------*/
void EGA_BaseElem_impl::base_delete()
{
  BF_GROUP grp = get_link_group(0);
  if (!grp) return;

  char *buffer=NULL;
  char* filename=NULL;
  char* path=NULL;
  char* copy=NULL;
  
  if (VQueryref(grp->vg)!=FAIL)
    {
      // VGROUP
      int nb_attr=Vnattrs(grp->vg);
      int32 data_type,count,size;
      int status;
      char name[VGNAMELENMAX];
      for (int attr_index=0;attr_index<nb_attr;attr_index++)
        {
          status=Vattrinfo(grp->vg,attr_index,name,&data_type,&count,&size);
          if (data_type!=DFNT_CHAR)
            continue;
          buffer=new char[count+1];
          filename=new char[count+1];
          path=new char[count+1];
          copy=new char[count+1];
          status=Vgetattr(grp->vg,attr_index,(VOIDP) buffer);
          sscanf(buffer,"<%[^>]><%[^>]><%[^>]>",path,filename,copy);
          if (copy)
            if (strcmp(copy,"COPY")==0)
              remove(path);
          // ICI SUPPRESSION DE L'ATTRIBUT
          memset(buffer,0,count);
          status=Vsetattr(grp->vg,name,DFNT_CHAR,count,buffer);
          if (buffer)   delete[] buffer;
          if (filename) delete[] filename;
          if (copy)     delete[] copy;
      }
  }
  else
  {
      // SDS
      int status;
      char name[VGNAMELENMAX];
      int32 rank, data_type, nattrs, dim[5];
      status=SDgetinfo(grp->vg,name,&rank,dim,&data_type,&nattrs);
      for (int attr_index=0;attr_index<nattrs;attr_index++)
        {
          int32 count;
          status=SDattrinfo(grp->vg,attr_index,name,&data_type,&count);
          if (data_type!=DFNT_CHAR)
            continue;
          buffer=new char[count+1];
          filename=new char[count+1];
          path=new char[count+1];
          copy=new char[count+1];
          status=SDreadattr(grp->vg,attr_index,(VOIDP) buffer);
          sscanf(buffer,"<%[^>]><%[^>]><%[^>]>",path,filename,copy);
          if (copy)
            if (strcmp(copy,"COPY")==0)
              {
                remove(path);
              }
          // ICI SUPPRESSION DE L'ATTRIBUT
          memset(buffer,0,count);
          status=SDsetattr(grp->vg,name,DFNT_CHAR,count,buffer);
          if (buffer)   delete[] buffer;
          if (filename) delete[] filename;
          if (copy)     delete[] copy;
        }
  }
}

void EGA_BaseElem_impl::set_status() {}
long EGA_BaseElem_impl::read_status() { return -1; }


/*------------------------------------------------------------------------------------
  MEMBER : link_file
  CLASS  : EGA_BaseElem_impl
  PURPOSE: Ajout d'un lien symbolique sous le groupe FILE_LINKS.
  
------------------------------------------------------------------------------------*/
int  EGA_BaseElem_impl::link_file( char *code,  char *path )
{
  BF_GROUP grp = get_link_group(1);

  if(!grp)
    return ELEMLINK_NOTIMPLEMENTED;
  
  char* buffer=new char[2000];
  
  char* code_impl=new char[strlen(code)+6];
  sprintf(code_impl,"LINK_%s",code);

  sprintf(buffer,"<%s><%s><LINK>\0",path,path);
  int status;
  if (VQueryref(grp->vg)!=FAIL)
    status=Vsetattr(grp->vg,code_impl,DFNT_CHAR,2000,buffer);
  else
    status=SDsetattr(grp->vg,code_impl,DFNT_CHAR,strlen(buffer),buffer);

  if (buffer)    delete[] buffer;
  if (code_impl) delete[] code_impl;
  
  return ELEMLINK_NOERROR;
}

/*------------------------------------------------------------------------------------
  MEMBER : copy_file
  CLASS  : EGA_BaseElem_impl
  PURPOSE: Ajout d'un lien symbolique sous le groupe FILE_LINKS, avec copie 
physique
           du fichier dans le répertoire de la base (sous DBlinks) avec un nom
           "temporaire".
  
------------------------------------------------------------------------------------*/
int EGA_BaseElem_impl::copy_file( char *code, char *path , char* cas_name)
{
  BF_GROUP grp=get_link_group(1);

  if (!grp)
    return ELEMLINK_NOTIMPLEMENTED;

  char *tmpp;
  char cmd[1200];
  char newf[1200];
  tmpp=tmpnam(NULL );
  sprintf(newf,"%s/DBlinks",SessionManager::get_db_dired());
  if(access(newf, F_OK)!=0)
    {
#ifndef _WIN32
      mkdir(newf, 0777);
      chmod(newf,  S_IRWXO | S_IRWXU | S_IRWXG );
#else
      _mkdir(newf);
      _chmod(newf,  _S_IREAD | _S_IWRITE);
#endif
    }

  sprintf(newf,"%s/DBlinks/%s",SessionManager::get_db_dired(),cas_name);
   if(access(newf, F_OK)!=0)
    {
#ifndef _WIN32
      mkdir(newf, 0777);
      chmod(newf,  S_IRWXO | S_IRWXU | S_IRWXG );
#else
      _mkdir(newf);
      _chmod(newf,  _S_IREAD | _S_IWRITE);
#endif
    }

   // Pour compatibilite entre les differents systemes
   // P_tmpdir sous Linux  /tmp
   //          sous SUN    /var/tmp/
   if (P_tmpdir[strlen(P_tmpdir)-1]=='/')
     sprintf(newf,"%s/DBlinks/%s/%s%s",SessionManager::get_db_dired(),cas_name,
             SessionManager::get_db_name(),tmpp+strlen(P_tmpdir));
   else
     sprintf(newf,"%s/DBlinks/%s/%s%s",SessionManager::get_db_dired(),cas_name,
             SessionManager::get_db_name(),tmpp+1+strlen(P_tmpdir));
   
  sprintf(cmd,"cp %s %s",path,newf);
#ifdef linux
    //DEBUG system linux
    signal(SIGCHLD,SIG_DFL);
#endif
  system(cmd);

#ifndef _WIN32
  chmod(newf,  S_IRWXO | S_IRWXU | S_IRWXG );
#else
  _chmod(newf,  _S_IREAD | _S_IWRITE);
#endif
  
  char* buffer=new char[2000];
  sprintf(buffer,"<%s><%s><COPY>\0",newf,path);
  int status;

  char* code_impl=new char[strlen(code)+6];
  sprintf(code_impl,"LINK_%s",code);
  
  if (VQueryref(grp->vg)!=FAIL)
    status=Vsetattr(grp->vg,code_impl,DFNT_CHAR,2000,buffer);
  else
    status=SDsetattr(grp->vg,code_impl,DFNT_CHAR,strlen(buffer),buffer);

  if (buffer)    delete[] buffer;
  if (code_impl) delete[] code_impl;

  return ELEMLINK_NOERROR;
}

/*------------------------------------------------------------------------------------
  MEMBER : get_file_path
  CLASS  : EGA_BaseElem_impl
  PURPOSE: Retourne le chemin complet (physique) pour un FILE_LINKS.
  
------------------------------------------------------------------------------------*/
int  EGA_BaseElem_impl::get_file_path( char *code, char *path, int )
{
  if (!get_root_group())
    return ELEMLINK_NOTIMPLEMENTED;

  BF_GROUP grp=get_link_group(0);

  if(!grp)
      return ELEMLINK_INVALIDCODE;

  char* code_impl=new char[strlen(code)+6];
  sprintf(code_impl,"LINK_%s",code);
  
  int32 index;
  if (VQueryref(grp->vg)!=FAIL)
    index=Vfindattr(grp->vg,code_impl);
  else
    index=SDfindattr(grp->vg,code_impl);
  
  if (index==FAIL)
    {
      if (code_impl) delete[] code_impl;
      return ELEMLINK_INVALIDCODE;
    }

  char* buffer=new char[2000];
  char* filename=new char[2000];
  char* copy=new char[2000];

  int status;
  if (VQueryref(grp->vg)!=FAIL)
    status=Vgetattr(grp->vg,index,(VOIDP) buffer);
  else
    status=SDreadattr(grp->vg,index,(VOIDP) buffer);

  sscanf(buffer,"<%[^>]><%[^>]><%[^>]>",path,filename,copy);

  if (buffer)    delete[] buffer;
  if (filename)  delete[] filename;
  if (copy)      delete[] copy;
  if (code_impl) delete[] code_impl;
  
  return ELEMLINK_NOERROR;
}

/*------------------------------------------------------------------------------------
  MEMBER : get_file_name
  CLASS  : EGA_BaseElem_impl
  PURPOSE: Retourne le nom de fichier utilisateur pour un FILE_LINKS.
  
------------------------------------------------------------------------------------*/
int EGA_BaseElem_impl::get_file_name( char *code, char *name, int )
{
  if (get_root_group() == NULL)
    return ELEMLINK_NOTIMPLEMENTED;

  BF_GROUP grp=get_link_group(0);
  if(grp == NULL)
    return ELEMLINK_INVALIDCODE;

  char* code_impl=new char[strlen(code)+6];
  sprintf(code_impl,"LINK_%s",code);
  
  int32 index;
  if (VQueryref(grp->vg)!=FAIL)
    index=Vfindattr(grp->vg,code_impl);
  else
    index=SDfindattr(grp->vg,code_impl);
  
  if (index==FAIL)
    {
      if (code_impl) delete[] code_impl;
      return ELEMLINK_INVALIDCODE;
    }

  char* buffer=new char[2000];
  char* path=new char[2000];
  char* copy=new char[2000];

  int status;

  if (VQueryref(grp->vg)!=FAIL)
    status=Vgetattr(grp->vg,index,(VOIDP) buffer);
  else
    status=SDreadattr(grp->vg,index,(VOIDP) buffer);

  sscanf(buffer,"<%[^>]><%[^>]><%[^>]>",path,name,copy);

  if (buffer)    delete[] buffer;
  if (path)      delete[] path;
  if (copy)      delete[] copy;
  if (code_impl) delete[] code_impl;
  
  return ELEMLINK_NOERROR;
} 

/*------------------------------------------------------------------------------------
  MEMBER : remove_link
  CLASS  : EGA_BaseElem_impl
  PURPOSE: Suppression d'un fichier/lien sous un FILE_LINKS
  
------------------------------------------------------------------------------------*/
int  EGA_BaseElem_impl::remove_link(  char *code )
{
  BF_GROUP grp = get_link_group(0);
  if (!grp) return ELEMLINK_NOTIMPLEMENTED;

  char* code_impl=new char[strlen(code)+6];
  sprintf(code_impl,"LINK_%s",code);
  
  int32 index;
  if (VQueryref(grp->vg)!=FAIL)
    index=Vfindattr(grp->vg,code_impl);
  else
    index=SDfindattr(grp->vg,code_impl);

  if (index==FAIL)
    {
      if (code_impl) delete[] code_impl;
      return ELEMLINK_INVALIDCODE;
    }
  
  char* buffer=new char[2000];
  char* filename=new char[2000];
  char* path=new char[2000];
  char* type=new char[2000];
  char* copy=new char[2000];
  
  int status;
  if (VQueryref(grp->vg)!=FAIL)
    status=Vgetattr(grp->vg,index,(VOIDP) buffer);
  else
    status=SDreadattr(grp->vg,index,(VOIDP) buffer);
  
  sscanf(buffer,"<%[^>]><%[^>]><%[^>]><%[^>]>",path,filename,type,copy);

   if (strcmp(copy,"COPY")==0)
     remove(path);

  if (buffer)    delete[] buffer;
  if (filename)  delete[] filename;
  if (type)      delete[] type;
  if (copy)      delete[] copy;
  if (code_impl) delete[] code_impl;

  // ICI SUPPRESSION DE L'ATTRIBUT
  return ELEMLINK_NOERROR;
}

/*===< EGA >============================================================*/
void
EGA_BaseElem_impl::set_misc_data( void *data, int len, const char *code )
{
  BF_GROUP grp=get_misc_group(1);
  if(!grp) return;

  char* code_impl=new char[strlen(code)+6];
  sprintf(code_impl,"MISC_%s",code);

  int status;
  if (VQueryref(grp->vg)!=FAIL)
    status=Vsetattr(grp->vg,code_impl,DFNT_CHAR,len,data);
  else
    status=SDsetattr(grp->vg,code_impl,DFNT_CHAR,len,data);
  
  if (code_impl) delete[] code_impl;
  Commit_Group(grp);
}

/*------------------------------------------------------------------------------------
  MEMBER : get_misc_data
  CLASS  : EGA_BaseElem_impl
  PURPOSE: Retourne un MiscData pour un code donné.
  <!><!> : On prend garde à ne pas créer un VGROUP/VDATA "fantôme" dans le
           fichier si le code n'existe pas.
           Si le vecteur data est Null on retoune simplement la taille 
necessaire.
  
------------------------------------------------------------------------------------*/
int EGA_BaseElem_impl::get_misc_data( void *data, const char *code )
{
  BF_GROUP grp=get_misc_group(1);
  if(!grp) return ELEMLINK_NOTIMPLEMENTED;
  
  char* code_impl=new char[strlen(code)+6];
  sprintf(code_impl,"MISC_%s",code);
  
  int32 count=0;
  if (VQueryref(grp->vg)!=FAIL)
    {
      int32 index=Vfindattr(grp->vg,code_impl);
      if (index==FAIL)
        {
          if (code_impl) delete[] code_impl;
          return ELEMLINK_INVALIDCODE;
        }
      int32 data_type,size;
      char name[VGNAMELENMAX];
      int status=Vattrinfo(grp->vg,index,name,&data_type,&count,&size);
      if (data)
        status=Vgetattr(grp->vg,index,data);
    }
  else
    {
      int32 index=SDfindattr(grp->vg,code_impl);
      if (index==FAIL)
        {
          if (code_impl) delete[] code_impl;
          return ELEMLINK_INVALIDCODE;
        }
      int32 data_type;
      char name[VGNAMELENMAX];
      int status=SDattrinfo(grp->vg,index,name,&data_type,&count);
      if (data)
        status=SDreadattr(grp->vg,index,data);
    }
  if (code_impl) delete[] code_impl;
Commit_Group(grp);
  return count;
}

/*------------------------------------------------------------------------------------
  MEMBER : set_float_misc_data
  CLASS  : EGA_BaseElem_impl
  PURPOSE: 
  
------------------------------------------------------------------------------------*/
void
EGA_BaseElem_impl::set_float_misc_data(float32 *data,
                                       int len,
                                       const char *code )
{
  BF_GROUP grp=get_misc_group(1);
  if(!grp) return;

  char* code_impl=new char[strlen(code)+6];
  sprintf(code_impl,"MISC_%s",code);

  int status;
  if (VQueryref(grp->vg)!=FAIL)
    status=Vsetattr(grp->vg,code_impl,DFNT_FLOAT32,len,(VOIDP) data);
  else
    status=SDsetattr(grp->vg,code_impl,DFNT_FLOAT32,len,(VOIDP) data);
  
  if (code_impl) delete[] code_impl;
}

/*------------------------------------------------------------------------------------
  MEMBER : get_misc_data
  CLASS  : EGA_BaseElem_impl
  PURPOSE: Retourne un MiscData pour un code donné.
  <!><!> : On prend garde à ne pas créer un VGROUP/VDATA "fantôme" dans le
           fichier si le code n'existe pas.
           Si le vecteur data est Null on retoune simplement la taille 
necessaire.
    
------------------------------------------------------------------------------------*/
int EGA_BaseElem_impl::get_float_misc_data(float32 *data, const char *code )
{
  BF_GROUP grp=get_misc_group(1);
  if(!grp) return ELEMLINK_NOTIMPLEMENTED;
  
  char* code_impl=new char[strlen(code)+6];
  sprintf(code_impl,"MISC_%s",code);
  
  int32 count;
  if (VQueryref(grp->vg)!=FAIL)
    {
      int32 index=Vfindattr(grp->vg,code_impl);
      if (index==FAIL)
        {
          if (code_impl) delete[] code_impl;
          return ELEMLINK_INVALIDCODE;
        }
      int32 data_type,size;
      char name[VGNAMELENMAX];
      int status=Vattrinfo(grp->vg,index,name,&data_type,&count,&size);
      if (data)
        status=Vgetattr(grp->vg,index,data);
    }
  else
    {
      int32 index=SDfindattr(grp->vg,code_impl);
      if (index==FAIL)
        {
          if (code_impl) delete[] code_impl;
          return ELEMLINK_INVALIDCODE;
        }
      int32 data_type;
      char name[VGNAMELENMAX];
      int status=SDattrinfo(grp->vg,index,name,&data_type,&count);
      if (data)
        status=SDreadattr(grp->vg,index,data);
    }
  if (code_impl) delete[] code_impl;
  return count;
}

/*------------------------------------------------------------------------------------
  MEMBER : get_root_group
  CLASS  : EGA_BaseElem_impl
  PURPOSE: Retourne l'adresse du BF_GROUP de l'objet, quand celui-ci existe.
  <!><!> : On retourne NULL par défaut: les classes utilisant un VGROUP en
           implémentation devront impérativment surcharger cette méthode.
           C'est le cas de la plupart des héritiers de BaseElem. Lorsqu'une
           classe retourne NULL, c'est qu'on ne peut pas lui adjoindre de
           MiscData ou de FileLink.
  
------------------------------------------------------------------------------------*/
BF_GROUP EGA_BaseElem_impl::get_root_group()
{
  return NULL;
}

/*------------------------------------------------------------------------------------
  MEMBER : get_misc_group
  CLASS  : EGA_BaseElem_impl
  PURPOSE: Retourne un pointeur sur le groupe contenant les miscdata.
           Si create==1, alors on crée ce groupe s'il n'existe pas.
  
------------------------------------------------------------------------------------*/
BF_GROUP EGA_BaseElem_impl::get_misc_group(unsigned short create)
{
  return get_root_group();
}

/*------------------------------------------------------------------------------------
  MEMBER : get_link_group
  CLASS  : EGA_BaseElem_impl
  PURPOSE: Retourne un pointeur sur le groupe contenant le Vgroup
  
------------------------------------------------------------------------------------*/
BF_GROUP EGA_BaseElem_impl::get_link_group(unsigned short create)
{
  return get_root_group();
}


void EGA_BaseElem_impl::export_misc_data(ostream& f)
{
  BF_GROUP grp=get_misc_group(1);
  if(!grp) return;

  int32 count;
  int32 data_type,size;
  char name[VGNAMELENMAX];
  int status;
  if (VQueryref(grp->vg)!=FAIL)
    {
      int nb_attr=Vnattrs(grp->vg);
      long nb_misc_data=0;

      // Calcul du nbre de misc data partmi les attributs
      int i;
      for (i=0;i<nb_attr;i++)
        {
          status=Vattrinfo(grp->vg,i,name,&data_type,&count,&size);
          if (strncmp(name,"MISC_",5)==0)
            nb_misc_data++;
        }
      f.write( (char *)&nb_misc_data, sizeof(long) );
      // export des misc_datas
      for (i=0;i<nb_attr;i++)
        {
          status=Vattrinfo(grp->vg,i,name,&data_type,&count,&size);
          if (strncmp(name,"MISC_",5)==0)
            {
              VOIDP data=NULL;
              data=new VOIDP[size];
              char type=0;
              if (data_type==DFNT_FLOAT32)
                type=1;
              else
                type=0;
              status=Vgetattr(grp->vg,i,data);
              f.write((char *) (name+5),VGNAMELENMAX-5);
              f.write((char *) &type,sizeof(char));
              f.write((char *) &size,sizeof(long));
              f.write((char *) data,size);
              if (data) delete[] data;
            }
        }
    }
  else
    {
      int32 nb_attr,rank,data_type;
      status=SDgetinfo(grp->vg,name,&rank,NULL,&data_type,&nb_attr);
      long nb_misc_data=0;
      
      // Calcul du nbre de misc data partmi les attributs
      int i;
      for ( i=0;i<nb_attr;i++)
        {
          int status=SDattrinfo(grp->vg,i,name,&data_type,&count);
          if (strncmp(name,"MISC_",5)==0)
            nb_misc_data++;
        }
      f.write( (char *)&nb_misc_data, sizeof(long) );
      // export des misc_datas
      for (i=0;i<nb_attr;i++)
        {
          int status=SDattrinfo(grp->vg,i,name,&data_type,&count);
          if (strncmp(name,"MISC_",5)==0)
            {
              VOIDP data=NULL;
              size=count*DFKNTsize(data_type);
              data=new VOIDP[size];
              status=SDreadattr(grp->vg,i,data);
              char type=0;
              if (data_type==DFNT_FLOAT32)
                type=1;
              else
                type=0;
              status=SDreadattr(grp->vg,i,data);
              f.write((char*) (name+5),VGNAMELENMAX-5);
              f.write((char*) &type,sizeof(char));
              f.write((char*) &size,sizeof(long));
              f.write((char*) data,size);
              if (data) delete[] data;
            }
        }
    }
}

void EGA_BaseElem_impl::import_misc_data(istream& f,EGA_BaseElem_impl* elem)
{
  long nb_misc_data=0;
  char name[VGNAMELENMAX];
  long size;
  char type;
  f.read((char*) &nb_misc_data, sizeof(long) );
  // export des misc_datas
  for (int i=0;i<nb_misc_data;i++)
    {
      f.read(name,VGNAMELENMAX-5);
      f.read((char*) &type,sizeof(char));
      f.read((char*) &size,sizeof(long));
      if (type==1)
        {
          float* data=new float[size/4];
          f.read((char*) data,size);
          elem->set_float_misc_data(data,size/4,name);
          if (data) delete[] data;
        }
      else
        {
          char * data=new char[size];
          f.read((char*) data,size);
          elem->set_misc_data(data,size,name);
          if (data) delete[] data;
        }
    }
}