Path: utzoo!utgpu!news-server.csri.toronto.edu!bonnie.concordia.ca!thunder.mcrcim.mcgill.edu!snorkelwacker.mit.edu!bloom-beacon!eru!hagbard!sunic!mcsun!ukc!mucs!cns!usenet
From: vanaards%t7@uk.ac.man.cs
Newsgroups: comp.sys.acorn,eunet.micro.acorn
Subject: Unix to Risc OS filenaming
Message-ID: <1991Jan21.084129.225@cns.umist.ac.uk>
Date: 21 Jan 91 08:41:29 GMT
Sender: usenet@cns.umist.ac.uk (News System)
Organization: Department of Computer Science, University of Manchester UK
Lines: 339



   Recetly I noticed a lot of talk about a routine to convert UNIX 
   filenames to RISC OS filenames, but as of yet no one has come up
   with the goods !
   
   So to start the ball rolling I'll post this rather awful routine
   which does the job. It's written in C and is probably too 
   unintelligible to be ported to any other language. I use it in my
   programs - which I've just posted, and it hasn't failed me yet.
   When compiling, try :
  
   cc c.ufn_rofn -DTEST 
   
   if you want to test it out.

   That's all folks !
   
   Steven van Aardt 

   (If we've any Dutch Users I'd like your opinion of the origins 
    of my surname, it apparently has an Afrikanns background.)
                        
-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.
| | | | | | | | | | | |  C U T   B E L O W  | | | | | | | | | | | | | | | | |
'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'


/*----------------------------------------------------*
 * Module : c.ufn_rofn
 * Purpose: Convert UNIX filenames to RiscOS filename
 * Author : Steven van Aardt
 *----------------------------------------------------*/

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

#define FALSE 0
#define TRUE (!FALSE)

#define MAX_FILENAME 10

/*---------------------------- Reverse ------------------------*
 * Purpose:   Reverse the character sequence within a string
 * Arguments: Pointer to string
 * Returns:   Pointer to the same string given as an argument.
 *-------------------------------------------------------------*/
static
char *reverse(char *string)
{
  int hd=0,tl=strlen(string);
  char tmp_c;
  /* reverse the name */
  while (--tl>hd) {                   /* work way back from end of string */
    tmp_c=string[hd];
    string[hd++]=string[tl];
    string[tl]=tmp_c;
  }
  return string;
}

/*---------------------------- isvowel --------------------------------*
 * Purpose:   Determines whether a character is an alphabetical vowel
 * Arguments: character (integer form)
 * Returns:   TRUE if vowel, otherwise FALSE.
 *---------------------------------------------------------------------*/
static
int isvowel(int c)
{
  int vowel=FALSE;
  switch (c) {
    case 'a': case 'A':             /* if c matches with */
    case 'e': case 'E':             /* any of these function */
    case 'i': case 'I':             /* will return TRUE */
    case 'o': case 'O':
    case 'u': case 'U': vowel=TRUE;
  }
  return vowel;
}

/*--------------------  squeeze  ------------------------*
 * Purpose:   remove any space characters from a string
 * Arguments: pointer to string
 * Returns:   pointer to a new string.
 *-------------------------------------------------------*/
static
char *squeeze(char *ptr)
{
   int  i=0,j=0;
   char *nn=NULL;
   /* squeeze in-place */
   for (i=j=0; ptr[i]!='\0';i++) if (ptr[i]!=' ') ptr[j++]=ptr[i];
   /* and copy into a new string */
   nn=calloc(j+2,sizeof(char)); /* allocate enough memory for new string */
   strncpy(nn,ptr,j);
   return nn;
}

/*---------------------------- rm_vowels -----------------------------*
 * Purpose:   removes some vowels from a string thus shortening it
 * Arguments: pointer to string
 * Returns:   pointer to a new string.
 *--------------------------------------------------------------------*/
static
char *rm_vowels(char *word,int maxlen)
{
  char *new_word=NULL;
  if (word) {
    int len=strlen(word);
    char *cpy=calloc(len+1,sizeof(char));
    strcpy(cpy,word);
    if (len>maxlen) { 
      /* remove every 2nd vowel */
      int i;
      len--;  /* leave last letter */
      for (i=1; i<len; i+=2) {
        while ((i<len) && (!isvowel(cpy[i]))) i++; /* skip non-vowels */ 
        if ((i<len) && (isvowel(cpy[i]))) cpy[i]=' '; /* overwrite vowels */
      }
    }
    new_word=squeeze(cpy); 
    free(cpy);
  }
  return new_word;
}

/*-------------------  shorten  ----------------------*
 * Purpose:   Shortens a string to a specified length
 * Arguments: pointer to string
 *            max length of string to be.
 * Returns: Pointer to new string
 *----------------------------------------------------*/
static
char *shorten(char *ptr,int maxlen)
{
  char *new_ptr;
  int l=strlen(ptr);
  if (l>maxlen) {
    /* quick shortening by removing a chunk from the middle */
    int num=l-maxlen; /* number to remove to get length of 10 */
    int i,j=0;
    for (i=(l-num)/2; j<num; j++) ptr[i+j]=' ';
  }
  new_ptr=squeeze(ptr);
  return new_ptr;
}



/*--------------------- ufn_rofn ------------------------*
 * Purpose:   Convert UNIX filename to RISC OS filename 
 * Arguments: pointer to UNIX filename string
 * Returns:   pointer to RISC OS filename
 *-------------------------------------------------------*/
extern
char *ufn_rofn(char *unix_name)
{
  typedef struct l List;         /* structure for constituent parts */
  struct l { char *ptr; struct l *last,*next; };
  int  len;
  char *uname=calloc(strlen(unix_name)+1,sizeof(char)),*rname=NULL,*ptr=NULL;
  List *lptr=NULL,*hdptr=NULL,*tlptr=NULL;
  while ((unix_name) && (*unix_name==' ')) unix_name++;
  if ((unix_name) && (*unix_name)) {
    strcpy(uname,unix_name);
    /* look for root directory '/' at beginning of unix filename */
    if (uname[0]=='/') {
      char *tmp=calloc(2,sizeof(char));
      strcpy(tmp,"$");
      lptr=(List *) malloc(sizeof(List));
      tlptr=lptr;         /* pointer to beginning of list */
      lptr->ptr=tmp;      
      lptr->next=NULL;
      lptr->last=hdptr;
      hdptr=lptr;         /* pointer to end of list */
    }
   /*
    *   Break down the name into its directory components - destroys uname
    */
    ptr=strtok(uname,"/");          /* ignores / if at beginning of list */
    while (ptr) {
      char *tmp=calloc(strlen(ptr)+1,sizeof(char));
      strcpy(tmp,ptr);
      lptr=(List *) malloc(sizeof(List));
      if (!tlptr) tlptr=lptr;      /* make pointer to beginning of list */
      if (hdptr) hdptr->next=lptr; /* link previous element onto this */
      lptr->ptr=tmp;
      lptr->next=NULL;   
      lptr->last=hdptr;  /* reverse chained list */
      hdptr=lptr;
      ptr=strtok(NULL,"/");        /* find next '/' */
    }
    /*
     *  Now go through each component looking for a '.' within each.
     */
    lptr=tlptr;                     /* beginning of list */
    while (lptr) {
      char *dp=NULL;                /* dot position */
      dp=strchr(lptr->ptr,'.');
      if (dp) {
        int len=strlen(lptr->ptr);
        /* 
         * special cases
         */
        /* if only 1 dot then refers to the UNIX csd */
        if (len==1) { 
          char *tmp=calloc(2,sizeof(char));
          strcpy(tmp,"@");
          lptr->ptr=tmp;
        } else {
          if (len==2) { 
            char *tmp=calloc(2,sizeof(char)); 
            strcpy(tmp,"^");
            lptr->ptr=tmp;
          } else {
            /* 
             * General case requires reversing of parts around '.'
             */
            List *dlptr=NULL, *dhdptr=NULL, *dtlptr=NULL,*tmp_next=lptr->next;
            char *dptr=NULL,*cpy=calloc(len+1,sizeof(char));

            strcpy(cpy,lptr->ptr);
            reverse(cpy);           /* reverse complete text */
            dptr=strtok(cpy,".");
            while (dptr) {
              char *tmp=calloc(strlen(dptr)+1,sizeof(char));  
              strcpy(tmp,dptr); /* make a copy of part */ 
              dlptr=(List *) malloc(sizeof(List));
              if (!dtlptr) dtlptr=dlptr;  /* remember beginning of this list */
              if (dhdptr) dhdptr->next=dlptr; /* link previous one onto this */
              dlptr->ptr=reverse(tmp); /* and reverse it's text back again */
              dlptr->next=NULL;
              dlptr->last=dhdptr;  /* reverse chaining  */
              dhdptr=dlptr;
              dptr=strtok(NULL,".");
            } /* endwhile */
            if (lptr->last) {
              free(lptr->ptr);       /* free text worked on by above */
              lptr=lptr->last;       /* move back */
              free(lptr->next);      /* free text's list element */
              lptr->next=dtlptr;     /* link */
              dtlptr->last=lptr;
              dlptr->next=tmp_next;
              if (tmp_next) { 
                tmp_next->last=dlptr;
                lptr=tmp_next->last;
              } else lptr=dlptr;
            } else {        /* case when this is the head of the list */
              free(lptr->ptr);
              free(lptr);
              lptr=dtlptr;
              tlptr=lptr;
              lptr->last=NULL;
              dlptr->next=tmp_next;
              if (tmp_next) {
                tmp_next->last=dlptr;
                lptr=tmp_next->last;
              } else lptr=dlptr;
            } /* endif */
          } /* endif */
        } /* endif */
      } /* endif */ 
      lptr=lptr->next; /* move onto next directory component in list */
    } /* endwhile */
    /* 
     *  Check the lengths of each component and adjust to that for RISC OS
     */
    lptr=tlptr;
    len=0;
    while (lptr) {
      char *new_ptr=NULL;
      if (lptr->next) len+=1;  /* for the RISC OS directory separator */
      new_ptr=rm_vowels(lptr->ptr,MAX_FILENAME);
      free(lptr->ptr);
      lptr->ptr=new_ptr;
      new_ptr=shorten(lptr->ptr,MAX_FILENAME);
      free(lptr->ptr);
      lptr->ptr=new_ptr;
      len+=strlen(lptr->ptr);
      lptr=lptr->next;
    }
    /*
     *  Copy linked list into result string
     */
    rname=calloc(len+1,sizeof(char)); /* make suitable string space */
    lptr=tlptr;
    len=0;
    while (lptr) {
      strcat((rname+len),lptr->ptr);
      free(lptr->ptr);     
      len=strlen(rname);
      lptr=lptr->next;
      if (lptr) strcat(rname,"."); /* append RISC OS directory separator */
    }
    /*
     *  Tidy up, by freeing memory used by list
     */
    lptr=tlptr;
    while (lptr) {
      List *tmp;
      tmp=lptr;
      lptr=lptr->next;
      free(tmp);
    }
  } /* endif */
  free(uname);
  return rname;
}




#ifdef TEST

int main(void) {
  char unix_filename[256],*riscos_filename;

  while (!feof(stdin)) {
     printf("Enter Unix filename : ");
     scanf("%s",&unix_filename);
     if (!feof(stdin)) {
       riscos_filename=ufn_rofn(unix_filename);
       printf("Risc OS filename    : %s\n",riscos_filename);
       free(riscos_filename);
     }
  }
  return 0;
}

#endif

+--------------------------------+-----------------------------------------+
|   ()()TEVEN         ()         |                                         |  
|  ()                ()()        |                                         |  
|   ()()   ()  ()AN ()  ()       |                                         |
|      ()   ()()   ()()()()      +-----------------------------------------+
|   ()()     ()   ()      ()ARDT |JANET E-mail : vanaards@uk.ac.man.cs.p4  |
+--------------------------------+-----------------------------------------+