filename.c

Go to the documentation of this file.

#include "filename.h"

#include "error.h"
#include "defines.h"

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

void CreateFileName(char *path,char *name,char *suffix,char *ext,Tfilename *fn)
{
  char *p,*e;
  signed int len,lp,lPath,lName,lSuffix,lExt,slashPos,dotPos;

  /* The actual file name is the string between the last '/' in the input name 
     and the first '.' after the '/'
     The string before the '/' is part of the path and the string after the '.'
     is the extension. 
     The part is added to the global path and the extension is discarted
     if the user provides an extension as a parameter or used, otherwise.
  */
  len=strlen(name);
  
  /*look for the last '/' in the given name*/
  slashPos=len-1;
  while((slashPos>=0)&&(name[slashPos]!='/'))
    slashPos--;
  
  dotPos=slashPos;
  while((dotPos<len)&&(name[dotPos]!='.'))
    dotPos++;

  /*Set up the path = 'p' + part of the name till the last '/' */ 
  /*The path is either the given one or the one from the system*/
  if (name[0]=='/')
    {
      /*The given name is a full path name*/
      lPath=slashPos+1;
      NEW(fn->path,lPath+1,char);
      memcpy(fn->path,name,slashPos*sizeof(char));
    }
  else
    {
      if (path==NULL)
        p=getcwd(NULL,0);
      else 
        p=path;
      lp=strlen(p);
    
      lPath=lp+slashPos+2;
      if (lPath==0)
        Error("Empty file path");
      NEW(fn->path,lPath+1,char);
      memcpy(fn->path,p,lp*sizeof(char));
      fn->path[lp]='/';
      if (slashPos>=0)
        memcpy(&(fn->path[lp+1]),name,slashPos*sizeof(char));
      if (path==NULL)
        free(p);
    }
  if (fn->path[lPath-2]!='/')
    {
      fn->path[lPath-1]='/';
      fn->path[lPath]=0;
    }
  else
    fn->path[lPath-1]=0;

  /*Set up the name */
  if (suffix==NULL)
    lSuffix=0;
  else
    lSuffix=strlen(suffix);
  lName=dotPos-slashPos-1+lSuffix;
  if (lName==0)
    Error("Empty file name");
  NEW(fn->name,lName+1,char);
  memcpy(fn->name,&(name[slashPos+1]),lName*sizeof(char));
  if (lSuffix>0)
    memcpy(&(fn->name[dotPos-slashPos-1]),suffix,lSuffix*sizeof(char));
  fn->name[lName]=0;

  /*Set up the extension*/
  if (ext!=NULL)
    e=ext;
  else
    {
      if (dotPos==len)
        e=NULL;
      else
        e=&(name[dotPos+1]);
    }

  if (e==NULL) lExt=0;
  else lExt=strlen(e);

  if (lExt>0)
    {
      NEW(fn->ext,lExt+1,char);
      memcpy(fn->ext,e,lExt*sizeof(char));
      fn->ext[lExt]=0;
    }
  else
    fn->ext=NULL;

  /* concat everything but the extension in the basename */

  NEW(fn->baseName,lPath+lName+2,char);
  sprintf(fn->baseName,"%s%s",fn->path,fn->name);

  /* concat everything in the full name */
  NEW(fn->fullName,lPath+lName+lExt+2,char);
  if (lExt>0)
    sprintf(fn->fullName,"%s%s.%s",fn->path,fn->name,fn->ext);
  else
    sprintf(fn->fullName,"%s%s",fn->path,fn->name);
}

char *GetFileFullName(Tfilename *fn)
{
  return(fn->fullName);
}

char *GetFilePath(Tfilename *fn)
{
  return(fn->path);
}

char *GetFileName(Tfilename *fn)
{
  return(fn->name);
}

char *GetFileBaseName(Tfilename *fn)
{
  return(fn->baseName);
}

char *GetFileExtension(Tfilename *fn)
{
  return(fn->ext);
}

void DeleteFileName(Tfilename *fn)
{
  free(fn->path);
  free(fn->name);
  if (fn->ext!=NULL) free(fn->ext);
  free(fn->fullName);
}