cli.c

自动联想命令行处理代码

     return NULL;
}

void CLI_SubCmdHint( unsigned long mode )
{
	UART_Printf( "\r\n[\r\n" );
    switch( mode )
    {
        case COMMAND_TYPE_IP:
			UART_Printf( "IP Address" );
			break;

        case COMMAND_TYPE_MASK:
			UART_Printf( "IP Mask" );
            break;

        case COMMAND_TYPE_DATE:
			UART_Printf( "Date YEAR-MON-DAY" );
            break;

        case COMMAND_TYPE_TIME:
			UART_Printf( "Time HOUR:MINUTE:SECOND" );
            break;

        case COMMAND_TYPE_HEX:
			UART_Printf( "HEX" );
            break;

        case COMMAND_TYPE_FLOAT:
			UART_Printf( "FLOAT" );
            break;
            
        case COMMAND_TYPE_MAC:
			UART_Printf( "MAC" );
            break;
            
        case COMMAND_TYPE_ULONG:
			UART_Printf( "Unsigned long" );
            break;
            
        case COMMAND_TYPE_LONG:
			UART_Printf( "Long" );
            break;

        case COMMAND_TYPE_STRING:
			UART_Printf( "String" );
        	break;
        	
        default:
        	break;
    }
    
    UART_Printf( "\r\n]\r\n" );
}

unsigned char CLI_GetLine( char *str, unsigned char len, unsigned char pos, unsigned char mode, unsigned char *mkey )
{
    unsigned char i = pos, process = 1;
    int key, k;
	
	*mkey = 0;

    for( ; process == 1; )
    {
		if( UART_kbhit( COM0 ))
		{
	    	key = (unsigned char)UART_getchar( COM0 );
	    }
	    else
	    {
#if !BASIC_BIOS
			OSTimeDly(1);
#endif		    
	    	continue;
	    }

lp:
        switch( key )
        {
            case K_ESC:
	            *mkey = (unsigned char)key;
                return 0;

            case '?':
            	CLI_SubCmdHint( mode );
            	UART_Printf( "%s", hint );

                for( k = 0; k < COMMAND_PARA_NUM; k++ )
                {
                    if( CLI_CmdBuffer[k][0] == '\0' )
                    	break;

                	if( k == COMMAND_PARA_NUM - 1 )
                	{
                    	UART_Printf( "%s", CLI_CmdBuffer[k] );
                    	break;                    	
                	}

            	   	UART_Printf( "%s ", CLI_CmdBuffer[k] );
                }

   				if( i != 0 )
   					UART_Printf( "\b" );
   					
                break;

            case K_ENTER:
	            key = ' ';
	            goto lp;
                break;

            case ' ':
                if( str[0] != '\0')
                {
                    switch( mode )
                    {
                        case COMMAND_TYPE_IP:
                        case COMMAND_TYPE_MASK:
                            if( VerifyIPAddress( str ))
                            {
					            *mkey = K_ENTER;
                                return 1;
                            }

                            break;

                        case COMMAND_TYPE_DATE:
                            if( VerifyDate( str ))
                            {
					            *mkey = K_ENTER;
                                return 1;
                            }

                            break;

                        case COMMAND_TYPE_TIME:
                            if( VerifyTime( str ))
                            {
                                UART_Puts("OK");
                                return 1;
                            }
                             UART_Puts("FAIL");
                            break;

                        case COMMAND_TYPE_HEX:
                        case COMMAND_TYPE_FLOAT:
                        case COMMAND_TYPE_MAC:
                        case COMMAND_TYPE_ULONG:
                        case COMMAND_TYPE_LONG:
                        case COMMAND_TYPE_STRING:
                        default:
				            //*mkey = K_ENTER;
                            return 1;
                    }
                }
                break;

            case '\b':
                if( i > 0 )
                {
                   str[i-1] = '\0';
                   i--;
                   UART_putchar( 0,  '\b' );
                   UART_putchar( 0,  ' ' );
                   UART_putchar( 0,  '\b' );
                }
                else
                {
					*mkey = (unsigned char)key;
                    return 0;
                }
                break;

            default:
                if( isprint( key ))
                {
                    switch( mode )
                    {
                        case COMMAND_TYPE_ULONG:
                            if( isdigit( key ))
                            {
                            }
                            else
                            {
                                continue;
                            }
                            break;

                        case COMMAND_TYPE_LONG:
                            if( isdigit( key ) || key == '-' && i == 0 )
                            {
                            }
                            else
                            {
                                continue;
                            }
                            break;

                        case COMMAND_TYPE_HEX:
                            if( isxdigit( key ) )
                            {
                            }
                            else
                            {
                                continue;
                            }
                            break;

                        case COMMAND_TYPE_DATE:
                            if( isdigit( key ) || key == '-' && i != 0 )
                            {
                            }
                            else
                            {                                
                                continue;
                            }
                            break;

                        case COMMAND_TYPE_TIME:
                            if( isdigit( key ) || key == ':' && i != 0 )
                            {
                            }
                            else
                            {
                                UART_putchar( 0, (unsigned char)key );
                                continue;
                            }
                            break;

                        case COMMAND_TYPE_FLOAT:
                            if( isdigit( key ) || key == '.' || key == '-' )
                            {
                            }
                            else
                            {
                                continue;
                            }
                            break;

                        case COMMAND_TYPE_STRING:
                            break;

                        case COMMAND_TYPE_IP:
                        case COMMAND_TYPE_MASK:
                            if( isdigit( key ) || key == '.'  )
                            {
                            }
                            else
                            {
                                continue;
                            }
                            break;

                        case COMMAND_TYPE_MAC:
                            if( isxdigit( key ) || key == '-'  )
                            {
                            }
                            else
                            {
                                continue;
                            }
                            break;

                        default:
                            break;
                    }

                    if( i < len - 1 )
                    {
                        str[i++] = (unsigned char)tolower( key );
                        str[i] = '\0';
                        UART_putchar( COM0, (unsigned char)key );
                    }

                    break;
                }
                
                break;
        }
    }

    return 0;
}

unsigned char CLI_AddCommandLine( CommandNode **cmd )
{
    unsigned long i;
    CommandNode *current, *p;
    current = &CLI_Head;

//    for( i = 0; i < num; i++ )
    for( i = 0; cmd[ i ] != NULL; i++ )
    {
//        p = CLI_SearchFirst( current, ((CommandNode*)cmd[ i ])->CmdKey, SEARCH_FULL );
        p = CLI_SearchFirst( current, cmd[ i ]->CmdKey, SEARCH_FULL );
        if( p != NULL )
        {
            current = p;
        }
        else
        {
            if( current->Down == NULL )
            {
                current->Down = cmd[ i ];
                current = current->Down;
            }
            else
            {
                p = CLI_SearchFirst( current, "", SEARCH_FULL );

                p = current = current->Down;
                for( ; p != NULL  ; )
                {
                    p = CLI_SearchNext( current, "", SEARCH_FULL );
                    if( p == NULL )
                    {
                        current->Right = cmd[ i ];
                        current = current->Right;
                    }
                    else
                    {
                        current = p;
                    }
                }
            }
        }
    }

    return 0;
}

void CLI_ListHelp( void )
{
    CommandNode *nownode = NULL;
    CommandNode *ptmp = NULL;

    nownode = &CLI_Head;

    ptmp = CLI_SearchFirst( nownode, "", SEARCH_PART );

    UART_Printf( "\r\n[ " );

    for( ;ptmp != NULL; )
    {
        UART_Printf( "\r\n%-15s", ptmp->CmdKey );

        if( ptmp->Help != NULL )
        {
            UART_Printf( ":%s ", ptmp->Help );
        }

        ptmp = CLI_SearchNext( ptmp, "", SEARCH_PART );
    }

    UART_Printf( "\r\n]\r\n" );
}

void CLI_ListTree( CommandNode *phead, unsigned char pos )
{
    unsigned long i;
    CommandNode *ptmp, *p;

    if( phead == NULL )
        return;

    pos++;

    ptmp = phead;
    p = ptmp = CLI_SearchFirst( ptmp, "", SEARCH_PART );
    if( p == NULL )
    {
        return;
    }

    for( ; ptmp != NULL; )
    {
        UART_putchar( 0, '\b');
        {
            char bb[20];
//            UART_Printf( "|%-15s", ptmp->CmdKey );
//            UART_Printf( "%s(%d,%d)", ptmp->CmdKey, ptmp->CmdValue, ptmp->Type );

            if( ptmp->CmdValue != NULL )
            {
                sprintf( bb, "%s(%d)", ptmp->CmdKey, ptmp->CmdValue );
            }
            else
            {
                sprintf( bb, "%s", ptmp->CmdKey );
            }

            if( pos == 1 )
                UART_Printf( "|%-15s", bb );
            else
                UART_Printf( "|%-15s", bb );
        }

        CLI_ListTree( ptmp, pos );

        ptmp = CLI_SearchNext( ptmp, "", SEARCH_PART );
        if( ptmp != NULL )
        {
            UART_Printf( "\r\n " );
            for( i = 0; i < pos-1L; i++ )
            {
                UART_Printf( "%-14c|", ' ' );
            }
        }
    }

    return;
}

CommandNode *CLI_SearchFirst( CommandNode *p, char *str, unsigned char part )
{
    unsigned int len = strlen(str);

    if( p == NULL )
        p = &CLI_Head;

    p = p->Down;

    for( ; p != NULL ; )
    {
        if( strncmp( p->CmdKey, str, len ) == 0 )
        {
            if( part == SEARCH_PART )
            {
                return p;
            }
            else
            {
                if( len == 0 || p->CmdKey[ len ] == '\0' )
                    return p;
            }
        }

        p = p->Right;
    }

    return NULL;
}

CommandNode *CLI_SearchNext( CommandNode *p, char *str, unsigned char part )
{
    unsigned int len = strlen(str);

    if( p == NULL )
        return NULL;

    p = p->Right;

    for( ; p != NULL ; )
    {
        if( strncmp( p->CmdKey, str, len ) == 0 )
        {
            if( part == SEARCH_PART )
            {
                return p;
            }
            else
            {
                if( len == 0 || p->CmdKey[ len ] == '\0' )
                return p;
            }
        }

        p = p->Right;
    }

    return NULL;
}

unsigned char VerifyDate( char *str )
{
    unsigned long year;
    unsigned long month;
    unsigned long day;
    const unsigned char DayPerMon[ 13 ] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

    if( sscanf( str, "%d-%d-%d", &year, &month, &day) != 3 )
    {
        return 0;
    }

    if( year < 2000 || year > 3000 || month == 0 || month > 12 )
    {
        return 0;
    }

    if( month == 2 )
    {
        if( ((year % 100) != 0  && (year % 4) == 0
            || (year % 100) == 0 && (year % 400) == 0 )
            && day == 29 )
        return 1;
    }

    if( day > DayPerMon[ month ] )
        return 0;

    return 1;
}

unsigned char VerifyTime( char *str )
{
    unsigned long hour;
    unsigned long minute;
    unsigned long second;

    if( sscanf(str, "%d:%d:%d", &hour, &minute, &second) != 3 )
    {
        return 0;
    }

    if( hour > 23 || minute > 59 || second > 59 )
    {
        return 0;
    }

    return 1;
}

unsigned char VerifyIPAddress( char *str )
{
    unsigned short a, b, c, d;

    if( sscanf( str, "%d.%d.%d.%d", &a, &b, &c, &d) == 4 )
    {
        if(a < 256 && b < 256 && c < 256 && d < 256)
        {
            return 1;
        }
    }

    return 0;
}

#endif