rvtr/twl_wrapsdk
1
Fork 0
mirror of https://github.com/rvtr/twl_wrapsdk.git synced 2025-10-31 06:11:10 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity
0351a4cfd1
twl_wrapsdk/build/libraries/fatfs/ARM7/csunicod.c
shirait 0351a4cfd1 add cs library (translator to unicode) 
git-svn-id: file:///Users/lillianskinner/Downloads/platinum/twl/twl_wrapsdk/trunk@195 4ee2a332-4b2b-5046-8439-1ba90f034370
2007-07-19 11:30:26 +00:00

724 lines
18 KiB
C
Raw Blame History

/*
* EBS - RTFS (Real Time File Manager)
*
* Copyright EBS Inc. 2002
* All rights reserved.
* This code may not be redistributed in source or linkable object form
* without the consent of its author.
*/
/* UNICODE.C - Contains UNCICODE string manipulation and character conversion routines */
#include <rtfs.h>
#if (INCLUDE_CS_UNICODE)
BOOLEAN _illegal_alias_char(byte ch);
#if (KS_LITTLE_ENDIAN)
#define BYTE_LOW 1 /* Numeric low byte of a character */
#define BYTE_HIGH 0 /* Numeric high byte of a character */
#else
#define BYTE_LOW 0 /* Numeric low byte of a character */
#define BYTE_HIGH 1 /* Numeric high byte of a character */
#endif
void pc_ascii_byte2upper(byte *to, byte *from)
{
byte c;
c = *from;
if ((c >= 'a') && (c <= 'z'))
c = (byte) ('A' + c - 'a');
*to = c;
}
void pc_unicode_byte2upper(byte *to, byte *from) /* __fn__*/
{
byte c;
if (*(from+BYTE_LOW)==0)
{
c = *(from+BYTE_HIGH);
if ((c >= 'a') && (c <= 'z'))
c = (byte) ('A' + c - 'a');
*(to+BYTE_LOW)= 0;
*(to+BYTE_HIGH)= c;
}
else
{
*to++ = *from++;
*to = *from;
}
}
int unicode_ascii_index(byte *p, byte base)
{
byte c[2];
int index;
pc_unicode_byte2upper(c, p);
if (c[BYTE_LOW]==0)
{
index = (int) (c[BYTE_HIGH] - base);
}
else
{
index = c[BYTE_HIGH];
index <<= 8;
index += c[BYTE_LOW];
}
return(index);
}
int unicode_compare(byte *p1, byte *p2)
{
if (*p1 == *p2 && *(p1+1) == *(p2+1))
return(1);
else
return(0);
}
int ascii_compare_nc(byte *p1, byte *p2)
{
byte c,d;
if (*p1 == *p2)
return(1);
else
{
pc_ascii_byte2upper(&c, p1);
pc_ascii_byte2upper(&d, p2);
return(c == d);
}
}
int unicode_compare_nc(byte *p1, byte *p2)
{
byte cp1[2];
byte cp2[2];
pc_unicode_byte2upper(cp1,p1);
pc_unicode_byte2upper(cp2,p2);
if (unicode_compare(cp1, cp2))
return(1);
else
return(0);
}
byte *unicode_goto_eos(byte *p)
{
while ((*p) || *(p+1)) p+=2;
return(p);
}
void unicode_drno_to_letter(byte *p,int driveno)
{
driveno += (int) 'A';
*(p+BYTE_LOW) = 0;
*(p+BYTE_HIGH) = (byte) driveno;
}
int unicode_cmp_to_ascii_char(byte *p, byte c)
{
if (*(p+BYTE_LOW) == 0)
return ( c ==*(p+BYTE_HIGH) );
return(0);
}
void unicode_assign_ascii_char(byte *p, byte c)
{
*(p+BYTE_LOW) = 0;
*(p+BYTE_HIGH) = c;
}
void map_ascii_to_unicode(byte *unicode_to, byte *ascii_from)
{
byte *p;
p = unicode_to;
while (*ascii_from)
{
*(p+BYTE_LOW) = 0;
*(p+BYTE_HIGH) = *ascii_from++;
p+= 2;
}
*p++ = 0;
*p++ = 0;
}
void map_unicode_to_ascii(byte *to, byte *from)
{
while (*from || *(from+1))
{
if (*(from+BYTE_LOW) == 0)
*to++ = *(from+BYTE_HIGH);
else
*to++ = '_';
from += 2;
}
*to = 0;
}
void pc_ascii_strn2upper(byte *to, byte *from, int n) /* __fn__*/
{
int i;
byte c;
for (i = 0; i < n; i++)
{
c = *from++;
if ((c >= 'a') && (c <= 'z'))
c = (byte) ('A' + c - 'a');
*to++ = c;
}
}
void pc_ascii_str2upper(byte *to, byte *from) /* __fn__*/
{
byte c;
while(*from)
{
c = *from++;
if ((c >= 'a') && (c <= 'z'))
c = (byte) ('A' + c - 'a');
*to++ = c;
}
*to = '\0';
}
byte * rtfs_cs_strcat(byte * targ, byte * src) /*__fn__*/
{
byte *p;
p = unicode_goto_eos(targ);
rtfs_cs_strcpy(p, src);
return targ;
}
int rtfs_cs_strcmp(byte * s1, byte * s2)
{
word w1, w2;
while (CS_OP_IS_NOT_EOS(s1) && CS_OP_IS_NOT_EOS(s2) && unicode_compare(s1, s2))
{
s1 += 2;
s2 += 2;
}
w1 = (word)*(s1+BYTE_HIGH); w1 = (word) w1 << 8; w1 = (word)w1 + (word) *(s1+BYTE_LOW);
w2 = (word)*(s2+BYTE_HIGH); w2 = (word) w2 << 8; w2 = (word)w2 + (word) *(s2+BYTE_LOW);
if (w1 == w2) return 0;
else if (w1 < w2) return -1;
else return 1;
}
int rtfs_cs_strcpy(byte * targ, byte * src)
{
int loop_count = 0;
while (CS_OP_IS_NOT_EOS(src))
{
*targ++ = *src++;
*targ++ = *src++;
loop_count++;
}
*targ++ = 0;
*targ = 0;
return (loop_count);
}
/* return number of unicode chars in a string */
int rtfs_cs_strlen(byte * string) /*__fn__*/
{
int len;
len = 0;
while (CS_OP_IS_NOT_EOS(string))
{
len += 1;
string += 2;
}
return (len);
}
BOOLEAN validate_filename(byte * name, byte * ext)
{
int len;
byte *pa, *pu, uni_buffer[16], ascii_buffer[8];
RTFS_ARGSUSED_PVOID((void *) ext);
/* Check short filenames to see if they are reserved names, The test
is done in ascii because we use this for aliases */
len = 0;
pu = uni_buffer; pa = name;
/* Make a unicode string up to DOT or Zero */
while (CS_OP_IS_NOT_EOS(pa))
{
if (CS_OP_CMP_ASCII(pa,'.'))
break;
CS_OP_CP_CHR(pu, pa);
CS_OP_INC_PTR(pu);
CS_OP_INC_PTR(pa);
CS_OP_TERM_STRING(pu);
len += 1;
if (len > 4)
break;
}
if (len && len <= 4)
{
map_unicode_to_ascii(ascii_buffer, uni_buffer);
if(name_is_reserved(ascii_buffer)) return(FALSE);
}
if (*(name+BYTE_LOW)==0)
if (*(name+BYTE_HIGH) == ' ')
return(FALSE);
len = 1;
name += 2;
while (CS_OP_IS_NOT_EOS(name))
{
if (*(name+BYTE_LOW)==0)
if (_illegal_lfn_char(*(name+BYTE_HIGH)))
return(FALSE);
name += 2;
len += 1;
}
if(len > 255) return(FALSE);
return(TRUE);
}
BOOLEAN pc_ascii_malias(byte *alias, byte *input_file, int try);
/* UNICODE Version */
BOOLEAN pc_cs_malias(byte *alias, byte *input_file, int try) /*__fn__*/
{
BLKBUFF *scratch;
BLKBUFF *scratch1;
byte *ascii_input_file;
byte *ascii_alias;
BOOLEAN ret_val = FALSE;
/* We know UNICODE file names aren't legal aliases */
if(try == -1)
return(FALSE);
scratch = scratch1 = 0;
scratch = pc_scratch_blk();
scratch1 = pc_scratch_blk();
if (!scratch || !scratch1)
goto ex_it;
ascii_input_file = scratch->data;
ascii_alias = scratch1->data;
/* Map the unicode to ascii and create an ascii alias */
map_unicode_to_ascii(ascii_input_file, input_file);
if (!pc_ascii_malias(ascii_alias, ascii_input_file, try))
goto ex_it;
/* Now back to unicode */
map_ascii_to_unicode(alias, ascii_alias);
ret_val = TRUE;
ex_it:
if (scratch)
pc_free_scratch_blk(scratch);
if (scratch1)
pc_free_scratch_blk(scratch1);
return(ret_val);
}
BOOLEAN pc_patcmp_8(byte *p, byte *pattern, BOOLEAN dowildcard) /* __fn__*/
{
byte ascii_pattern[9];
int size = 8;
map_unicode_to_ascii(ascii_pattern, pattern);
pattern = ascii_pattern;
/* Kludge. never match a deleted file */
if (*p == PCDELETE)
return (FALSE);
else if (*pattern == PCDELETE) /* But E5 in the Pattern matches 0x5 */
{
if (*p == 0x5)
{
size -= 1;
p++;
pattern++;
}
else
return (FALSE);
}
while (size--)
{
if(dowildcard)
{
if (*pattern == '*') /* '*' matches the rest of the name */
return (TRUE);
if (*pattern != '?' && !ascii_compare_nc(pattern,p))
return (FALSE);
}
else
{
if (!ascii_compare_nc(pattern,p))
return (FALSE);
}
p++;
pattern++;
}
return (TRUE);
}
BOOLEAN pc_patcmp_3(byte *p, byte *pattern, BOOLEAN dowildcard) /* __fn__*/
{
byte ascii_pattern[9];
int size = 3;
map_unicode_to_ascii(ascii_pattern, pattern);
pattern = ascii_pattern;
while (size--)
{
if(dowildcard)
{
if (*pattern == '*') /* '*' matches the rest of the name */
return (TRUE);
if (*pattern != '?' && !ascii_compare_nc(pattern,p))
return (FALSE);
}
else
{
if (!ascii_compare_nc(pattern,p))
return (FALSE);
}
p++;
pattern++;
}
return (TRUE);
}
void lfn_chr_to_unicode(byte *to, byte *fr)
{
#if (KS_LITTLE_ENDIAN)
*to = *fr++;
*(to+1) = *fr;
#else /* make sure UNICODE str is in Intel byte order on disk */
*(to+1) = *fr++;
*to = *fr;
#endif
}
void unicode_chr_to_lfn(byte *to, byte *fr)
{
#if (KS_LITTLE_ENDIAN)
*to = *fr++;
*(to+1) = *fr;
#else /* make sure UNICODE str is in Intel byte order on disk */
*(to+1) = *fr++;
*to = *fr;
#endif
}
byte *pc_ascii_mfile(byte *to, byte *filename, byte *ext);
/* Version of MFILE that converts path from byte orientation to
native char set before returning. */
byte *pc_cs_mfile(byte *to, byte *filename, byte *ext)
{
byte temp_to[13];
pc_ascii_mfile(temp_to, filename, ext);
map_ascii_to_unicode(to, temp_to);
return(to);
}
/***************************************************************************
PC_FILEPARSE - Parse a file xxx.yyy into filename/pathname
Description
Take a file named XXX.YY and return SPACE padded NULL terminated
filename [XXX ] and fileext [YY ] components. If the name or ext are
less than [8,3] characters the name/ext is space filled and null termed.
If the name/ext is greater than [8,3] the name/ext is truncated. '.'
is used to seperate file from ext, the special cases of . and .. are
also handled.
Returns
Returns TRUE
****************************************************************************/
/* UNICODE - Called by pc_malias not by others if vfat - Okay as ascii */
/* UNICODE - pc_enum usage is probably incorrect */
/* Take a string xxx[.yy] and put it into filename and fileext */
/* Note: add a check legal later */
BOOLEAN pc_ascii_fileparse(byte *filename, byte *fileext, byte *p) /* __fn__*/
{
int i;
/* Defaults */
rtfs_memset(filename, ' ', 8);
filename[8] = '\0';
rtfs_memset(fileext, ' ', 3);
fileext[3] = '\0';
/* Special cases of . and .. */
if (*p == '.')
{
*filename = '.';
if (*(p+1) == '.')
{
*(++filename) = '.';
return (TRUE);
}
else if (*(p + 1) == '\0')
return (TRUE);
else
return (FALSE);
}
i = 0;
while (*p)
{
if (*p == '.')
{
p++;
break;
}
else
if (i++ < 8)
*filename++ = *p;
p++;
}
i = 0;
while (*p)
{
if (i++ < 3)
*fileext++ = *p;
p++;
}
return (TRUE);
}
/***************************************************************************
PC_MFILE - Build a file spec (xxx.yyy) from a file name and extension
Description
Fill in to with a concatenation of file and ext. File and ext are
not assumed to be null terminated but must be blank filled to [8,3]
chars respectively. 'to' will be a null terminated string file.ext.
ASCII character function only. Unicode not required
Returns
A pointer to 'to'.
This is byte oriented. See pc_cs_mfile() for unicode oriented.
****************************************************************************/
byte *pc_ascii_mfile(byte *to, byte *filename, byte *ext)
{
byte *p;
int i;
byte *retval = to;
p = filename;
i = 0;
while(*p)
{
if (*p == ' ')
break;
else
{
*to++ = *p++;
i++;
}
if (i == 8)
break;
}
if (p != filename)
{
p = ext;
if (*p && *p != ' ')
*to++ = '.';
i = 0;
while(p && *p)
{
if (*p == ' ')
break;
else
{
*to++ = *p++;
i++;
}
if (i == 3)
break;
}
}
*to = '\0';
return (retval);
}
BOOLEAN pc_valid_ascii_sfn(byte *filename);
BOOLEAN pc_ascii_malias(byte *alias, byte *input_file, int try)
{
int n,i,s;
byte filename[9],fileext[4];
/* Fill filename[8] with spaces before we start. */
rtfs_memset(filename, ' ', 8);
/* See if no change necessary! */
if(try == -1)
return(pc_valid_ascii_sfn((byte *)input_file));
/* Process the ASCII alias name */
while(*input_file=='.' || *input_file==' ') input_file++;
/* find extension start */
for(n=0,i=0; input_file[n]!=0; n++) /* i holds the position right */
{ /* after the last period */
if(input_file[n]=='.') i=n+1;
}
if(i>0 && input_file[i]!=0){
/* copy extension to fileext[] */
for(n=i,s=0; input_file[n]!=0 && s<3; n++)
{
if(input_file[n]!=' ')
{
if(_illegal_alias_char(input_file[n]))
{
fileext[s++] = '_';
}
else
fileext[s++] = input_file[n];
}
}
fileext[s]=0;} else { i=512; fileext[0]=0; } /* null terminate */
/* copy file name to filename[], filtering out spaces, periods and
replacing characters illegal in alias names with '_' */
for(n=0,s=0; n<i && input_file[n]!=0 && s<8; n++)
{
if(input_file[n]!=' ' && input_file[n]!='.')
{
if(_illegal_alias_char(input_file[n]) || input_file[n]>127)
{
filename[s++] = '_';
}
else
filename[s++] = input_file[n];
}
}
for(;s<8;s++) /* pad with spaces */
{
filename[s] = ' ';
}
filename[8]=0; /* null terminate filename[] */
pc_ascii_str2upper(filename,filename);
pc_ascii_str2upper(fileext,fileext);
/* append (TEXT[])i to filename[] */
for(n=7,s=try; s>0 && n>0; s/=10,n--)
{
filename[n] = (byte)(((byte)s%10)+'0');
}
if(n==0 && s>0)
return(FALSE);
else
filename[n]='~';
/* copy filename[] to alias[], filtering out spaces */
for(n=0,s=0; s<8; s++)
{
if(filename[s]!=' ')
alias[n++]=filename[s];
}
if(fileext[0] != 0)
{
alias[n++]='.'; /* insert separating period */
/* copy fileext[] to alias[] */
for(s=0; fileext[s]!=0; s++,n++)
{
alias[n]=fileext[s];
}
}
alias[n]=0; /* null terminate alias[] */
return(TRUE);
}
/***************************************************************************
PC_VALID_SFN - See if filename is a valid short file name
Description
Determines validity of a short file name based on the following criteria:
- the file name must be between 0 and 8 characters
- the file extension must be between 0 and 3 characters
- the file name must not begin with a period
- it must not be a reserved DOS file name
- it must not contain any characters that are illegal within sfn's
Returns
TRUE if filename is a valid sfn, FALSE otherwise
****************************************************************************/
BOOLEAN pc_valid_ascii_sfn(byte *filename)
{
int len,period_count,ext_start;
BOOLEAN badchar;
if(name_is_reserved(filename)) return(FALSE);
for(len=0,badchar=FALSE,period_count=0,ext_start=0; filename[len]!=0; len++)
{
if(_illegal_alias_char(filename[len])) badchar = TRUE;
if(filename[len] == '.')
{
ext_start = len+1;
period_count++;
}
}
if( (filename[0] == ' ') || /* 1st char is a space */
(len == 0) || /* no name */
badchar || /* contains illegal chars */
(period_count > 1) || /* contains more than one extension */
((len-ext_start)>3 && period_count>0) || /* extension is longer than 3 chars */
(period_count==0 && len > 8) || /* name is longer than 8 chars */
(ext_start > 9) || /* name is longer than 8 chars */
(ext_start==1) ) return(FALSE); /* no name; 1st char is a period */
return(TRUE);
}
byte print_buffer[132];
/* Take a string the may be either ASCI unicode '\0''C' or just asci 'C'
and return an asci printable version of the string */
byte *unicode_make_printable(byte *p)
{
int i;
byte c;
//int is_unicode; //ctr modified
// is_unicode = 0; //ctr modified
if (*(p+BYTE_LOW)!=0) /* Most likely it is ascii */
{
rtfs_strcpy(print_buffer, p);
return(&print_buffer[0]);
}
i = 0;
for (;;)
{
if (*(p+BYTE_LOW)==0)
{
c = *(p+BYTE_HIGH);
if (c == 0)
break;
else
print_buffer[i++] = c;
}
p += 2;
}
print_buffer[i] = 0;
return (&print_buffer[0]);
}
#endif
Reference in New Issue View Git Blame Copy Permalink