qatcli.h

 
#ifndef QATCLI_H
    #define QATCLI_H
 
    #include "qtypes.h"
    #include "qioutils.h"
 
    #ifdef __cplusplus
    extern "C" {
    #endif
 
    #ifndef Q_ATCLI
        #define Q_ATCLI     ( 1 )
    #endif
 
    typedef enum {
        qATCLI_ERROR = -32767,      
        qATCLI_NOTALLOWED = -32766, 
        qATCLI_NORESPONSE = 0,      
        qATCLI_OK = 1,              
        qATCLI_DEVID = 32765,       
        qATCLI_NOTFOUND = 32766,    
        qATCLI_OUTPUT = 32767       
    }
    qATCLI_Response_t;
 
    #define     qATCLI_ERROR_CODE(ecode)     (-(ecode) )
 
 
    typedef volatile struct _qATCLI_Input_s { // skipcq: CXX-E2000
        char *storage;              /*< Points to the user-defined storage area for the input. */
        volatile qIndex_t index;    /*< Used to hold the index of the current input-buffer. */
        qIndex_t maxIndex;          /*< Max index  = (Size - 1) */
        size_t size;                /*< The size of the input buffer. */
        volatile qBool_t ready;     /*< A flag that indicates when the input is ready to parse. */
    }
    qATCLI_Input_t;
 
    #define QATCLI_CMDTYPE_UNDEF    ( 0x0000 )
    #define QATCLI_CMDTYPE_PARA     ( 0x0100 )
    #define QATCLI_CMDTYPE_TEST     ( 0x0200 )
    #define QATCLI_CMDTYPE_READ     ( 0x0400 )
    #define QATCLI_CMDTYPE_ACT      ( 0x0800 )
 
    #define QATCLI_CMDTYPE_SET      ( QATCLI_CMDTYPE_PARA )
    #define QATCLI_CMDTYPE_CHECK    ( QATCLI_CMDTYPE_ACT )
 
    typedef enum {
        qATCLI_CMDTYPE_UNDEF = QATCLI_CMDTYPE_UNDEF, 
        qATCLI_CMDTYPE_PARA  = QATCLI_CMDTYPE_PARA,  
        qATCLI_CMDTYPE_TEST  = QATCLI_CMDTYPE_TEST,  
        qATCLI_CMDTYPE_READ  = QATCLI_CMDTYPE_READ,  
        qATCLI_CMDTYPE_ACT   = QATCLI_CMDTYPE_ACT    
    }
    qATCLI_CommandType_t;
 
    typedef struct _qATCLI_PublicData_s { // skipcq: CXX-E2000
        void *Command;
        char *StrData;
        char* (*GetArgPtr)( qIndex_t n );
        int (*GetArgInt)( qIndex_t n );
        qFloat32_t (*GetArgFlt)( qIndex_t n );
        qUINT32_t (*GetArgHex)( qIndex_t n );
        char* (*GetArgString)( qIndex_t n, char* pOut );
        void (*putch)( const char c );
        void (*puts)( const char *s );
        char *Output;
        void *Data;
        size_t StrLen;
        size_t NumArgs;
        qATCLI_CommandType_t Type;
    }
    #ifdef DOXYGEN
    qATCLI_Handler_t;
    #else
    _qATCLI_PublicData_t; // skipcq: CXX-E2000
    typedef _qATCLI_PublicData_t* qATCLI_Handler_t;
    #endif
 
    typedef struct _qATCLI_ControlBlock_s { // skipcq: CXX-E2000
        struct _qATCLI_Private_s { // skipcq: CXX-E2000
            void *first;                                                    /*< Points to the first command*/
            const char *ok_rsp;                                             /*< The response printed when OK is needed. */
            const char *er_rsp;                                             /*< The response printed when ERROR is needed. */
            const char *nf_rsp;                                             /*< The response printed when NOTFOUND is needed. */
            const char *id_rsp;                                             /*< The response printed when the "ATID" command has been entered. */
            const char *eol;                                                /*< The End Of Line string after a command response */
            qPutChar_t outputFcn;                                           /*< Points to the user-supplied function to write a single byte to the output. */
            void (*xNotifyFcn)(struct _qATCLI_ControlBlock_s * const arg);  /*< Used to notify the attached task if available*/
            size_t sizeOutput;                                              /*< The size of Output. */
            qATCLI_Input_t xInput;                                          /*< The input of the CLI. */
            _qATCLI_PublicData_t xPublic;                                   /*< External accessible through the qATCLI_Handler_t*/
            void *owner;
        }
        qPrivate;
    }
    qATCLI_t;
 
    typedef qATCLI_Response_t (*qATCLI_CommandCallback_t)(qATCLI_Handler_t arg1);
 
    typedef qUINT16_t qATCLI_Options_t;
 
    typedef struct _qATCLI_Command_s { // skipcq: CXX-E2000
        struct _qATCLI_Command_Private_s {              /*< Linked-list pointers. */ // skipcq: CXX-E2000
            qATCLI_CommandCallback_t cmdCallback;       /*< The command callback. */
            struct _qATCLI_Command_s *next;             /*< Points to the next command in the list. */
            qATCLI_Options_t cmdOpt;                    /*< The command options. */
            size_t cmdLen;                              /*< The command length. */
        }
        qPrivate;
        void *param;                                    
        char *Text;                                     
    }
    qATCLI_Command_t;
 
    typedef enum {
        QATCLI_BUILTIN_STR_IDENTIFIER,                  
        QATCLI_BUILTIN_STR_OK_RESPONSE,                 
        QATCLI_BUILTIN_STR_ERROR_RESPONSE,              
        QATCLI_BUILTIN_STR_NOTFOUND_RESPONSE,           
        QATCLI_BUILTIN_STR_TERM_EOL,                    
    }
    qATCLI_BuiltInString_t;
 
    qBool_t qATCLI_SetBuiltInString( qATCLI_t * const cli,
                                     qATCLI_BuiltInString_t which,
                                     const char *str );
 
    qBool_t qATCLI_Setup( qATCLI_t * const cli,
                          const qPutChar_t outFcn,
                          char *pInput,
                          const size_t sizeInput,
                          char *pOutput,
                          const size_t sizeOutput );
 
    qBool_t qATCLI_CmdSubscribe( qATCLI_t * const cli,
                                 qATCLI_Command_t * const cmd,
                                 char *textCommand,
                                 const qATCLI_CommandCallback_t cFcn,
                                 qATCLI_Options_t cmdOpt,
                                 void *param );
 
    qATCLI_Command_t* qATCLI_CmdIterate( const qATCLI_t * const cli,
                                         const qBool_t reload );
 
    qBool_t qATCLI_ISRHandler( qATCLI_t * const cli,
                               const char c );
 
    qBool_t qATCLI_ISRHandlerBlock( qATCLI_t * const cli,
                                    char *pData,
                                    const size_t n );
 
    qBool_t qATCLI_Raise( qATCLI_t * const cli,
                          const char *cmd );
 
    qATCLI_Response_t qATCLI_Exec( qATCLI_t * const cli,
                                   char *cmd );
 
    qBool_t qATCLI_Input_Flush( qATCLI_t * const cli );
 
    qBool_t qATCLI_Run( qATCLI_t * const cli );
 
    #ifdef __cplusplus
    }
    #endif
 
#endif