fileutil.c

来自「好记星的控件,包括button,list,对文件操作」· C语言 代码 · 共 1,674 行 · 第 1/5 页

/*** victor for UNICODE
        * Convert to upper letter *
        if ( (*disk_fnam >= 'a') && (*disk_fnam <= 'z') )
            c1 = (UINT8) ('A' + *disk_fnam - 'a');
        else
            c1 = *disk_fnam;

        * Convert to upper letter *
        if ( (*in_fnam >= 'a') && (*in_fnam <= 'z') )
            c2 = (UINT8) ('A' + *in_fnam - 'a');
        else
            c2 = *in_fnam;

        if (c1 != c2 )
            if (c2 != '?')  * ? is wild card * */
        /* Convert to upper letter */
        if ( (*disk_fnam >= 'a') && (*disk_fnam <= 'z') )
            c1 = (UINT16) ('A' + *disk_fnam - 'a');
        else if (*disk_fnam > 0x7f)
        {
            c1 = (UINT16)*disk_fnam<<8;
            disk_fnam++;
            c1 += *disk_fnam;
        }
        else
            c1 = (UINT16)*disk_fnam;

        /* Convert to upper letter */
        if ( (*in_fnam >= 'a') && (*in_fnam <= 'z') )
            c2 = (UINT16) ('A' + *in_fnam - 'a');
        else if (*in_fnam > 0x7f)
        {
            c2 = (UINT16)*in_fnam<<8;
            in_fnam++;
            c2 += *in_fnam;
        }
        else
            c2 = (UINT16)*in_fnam;

        if (c1 != c2 )
            if (c2 != (UINT16)'?')  /* ? is wild card */
/****/
                return(NO);
        disk_fnam++;
        in_fnam++;
    }
}


/************************************************************************
* FUNCTION                                                              
*                                                                       
*       pc_strcat                                                       
*                                                                       
* DESCRIPTION                                                           
*                                                                       
*       strcat                                                          
*                                                                       
* AUTHOR                                                                
*                                                                       
*       Kyoichiro Toda
*                                                                       
* INPUTS                                                                
*                                                                       
*       to                          To data buffer                      
*       from                        From data buffer                    
*                                                                       
* OUTPUTS                                                               
*                                                                       
*       None.                                                           
*                                                                       
*************************************************************************/
VOID pc_strcat(UINT8 *to, UINT8 *from)
{

    while (*to)  to++;
    while (*from) *to++ = *from++;
    *to = '\0';
}


/************************************************************************
* FUNCTION                                                              
*                                                                       
*       pc_usewdcard                                                    
*                                                                       
* DESCRIPTION                                                           
*                                                                       
*       Check the use wild card.                                        
*                                                                       
* AUTHOR                                                                
*                                                                       
*       Kyoichiro Toda
*                                                                       
* INPUTS                                                                
*                                                                       
*       code                                name                        
*                                                                       
* OUTPUTS                                                               
*                                                                       
*       YES                                 Use the wild card.          
*       NO                                  Not use the wild card.      
*                                                                       
*************************************************************************/
INT pc_use_wdcard(UINT8 *code)
{

    while (*code)
    {
        if ( (*code == '*') || (*code == '?') )
            return(YES);
/*** victor for UNICODE */
        if ( *code > 0x7f )
            code++;
/****/

        code++;
    }
    return(NO);
}


/************************************************************************
* FUNCTION                                                              
*                                                                       
*       pc_use_upperbar                                                 
*                                                                       
* DESCRIPTION                                                           
*                                                                       
*       Check the use upperbar name.                                    
*       ' '(space), '.'(period), '=', '[', ']', ';', ':', '+', ','      
*                                                                       
* AUTHOR                                                                
*                                                                       
*       Kyoichiro Toda
*                                                                       
* INPUTS                                                                
*                                                                       
*       code                        File name or File extension         
*                                                                       
* OUTPUTS                                                               
*                                                                       
*       YES                                 Use the upperbar name.      
*       NO                                  Not use the upperbar name.  
*                                                                       
*************************************************************************/
INT pc_use_upperbar(UINT8 *code)
{
UINT16      n, j;
UINT16      period = 0;


    n = j = 0;

    while (*code)
    {
        switch (*code)
        {
        case ' ':
        case '=':
        case '[':
        case ']':
        case ';':
        case '+':
        case ',':
            return(YES);

        case '.':
        {
            /* filename.... or extension..... */
            if (*(code+1) == '\0')
            {
                period = j = 0;
            }
            else
            {
                period++;
            }
            break;
        }
        default:
            break;
        }

        /* Check the number of extension */
        if (period)
        {
            if (j++ > 3)
                return(YES);
        }
        /* Check the number of filename */
        else
        {
            n++;
            if (n > 8)
                return(YES);
        }
/*** victor for UNICODE */
        if( *code > 0x7f)
            return(YES);
/****/
        code++;
    }

    /* Another differentiate filename and extension ? */
    if (period > 1)
        return(YES);

    return(NO);
}


/************************************************************************
* FUNCTION                                                              
*                                                                       
*       pc_checkpath                                                    
*                                                                       
* DESCRIPTION                                                           
*                                                                       
*       Check the path name or Volume lable.                            
*                                                                       
* AUTHOR                                                                
*                                                                       
*       Kyoichiro Toda
*                                                                       
* INPUTS                                                                
*                                                                       
*       code                                Path name or Volume lable.  
*       vol                                 YES : Volume lable          
*                                           NO  : Path name             
*                                                                       
* OUTPUTS                                                               
*                                                                       
*       YES                                 Success.                    
*       NO                                  Path name error.            
*                                                                       
*************************************************************************/
INT pc_checkpath(UINT8 *code, INT vol)
{
UINT16      n = 0;


    if (!code)
        return(YES);

    while (code[n])
    {
/*** victor for UNICODE
        if ( (code[n] < 0x20) || (code[n] > 0x7E) )*/
        if ( code[n] < 0x20 )
/****/
            return(NO);

        if (!vol)
        {
            if (code[n] == ':')
            {
                if ( (n != 1) || (code[n+1] != BACKSLASH) )
                    return(NO);
            }

            if (code[n] == BACKSLASH)
            {
                if (code[n+1] == BACKSLASH)
                    return(NO);
            }
        }
        else
        {
            switch (code[n])
            {
            case '.':
            case ':':
            case '=':
            case '[':
            case '\\':
            case ']':
                return(NO);

            default:
                break;
            }
        }

        switch (code[n])
        {
        case '"':
        case '*':
        case ',':
        case '/':
        case ';':
        case '<':
        case '>':
        case '?':
        case '|':
            return(NO);

        default:
            break;
        }

/*** victor for UNICODE */
        if ( code[n] > 0x7f )
            n++;
/****/
        n++;
    }

    return(YES);
}


/************************************************************************
* FUNCTION                                                              
*                                                                       
*       _swap16                                                         
*                                                                       
* DESCRIPTION                                                           
*                                                                       
*       Convert a 16 bit intel item to a portable 16 bit.               
*                                                                       
* AUTHOR                                                                
*                                                                       
*       Takahiro Takahashi
*                                                                       
* INPUTS                                                                
*                                                                       
*       *to                                 After Convert data.         
*       *from                               Before Convert data.        
*                                                                       
* OUTPUTS                                                               
*                                                                       
*       None.                                                           
*