cbsatplugin/atmisccmdplugin/src/atcommandparser.cpp
branchRCL_3
changeset 72 4b59561a31c0
parent 64 1934667b0e2b
equal deleted inserted replaced
64:1934667b0e2b 72:4b59561a31c0
    56     _LIT8(KAtClck, "AT+CLCK");
    56     _LIT8(KAtClck, "AT+CLCK");
    57     _LIT8(KAtCpwd, "AT+CPWD");
    57     _LIT8(KAtCpwd, "AT+CPWD");
    58     _LIT8(KAtCpin, "AT+CPIN");
    58     _LIT8(KAtCpin, "AT+CPIN");
    59     _LIT8(KAtCusd, "AT+CUSD");
    59     _LIT8(KAtCusd, "AT+CUSD");
    60     _LIT8(KAtCnum, "AT+CNUM");
    60     _LIT8(KAtCnum, "AT+CNUM");
    61 	_LIT8(KAtCmee, "AT+CMEE");
    61     _LIT8(KAtCmee, "AT+CMEE");
    62     _LIT8(KAtHver, "AT^HVER");
       
    63     _LIT8(KAtCgsn, "AT+CGSN");
       
    64     _LIT8(KAtCgmr, "AT+CGMR");
       
    65     _LIT8(KAtCgmi, "AT+CGMI");
       
    66     _LIT8(KAtCmgw, "AT+CMGW");
       
    67 	_LIT8(KAtCmgd, "AT+CMGD");
       
    68 	_LIT8(KAtCmgf, "AT+CMGF");
       
    69 	_LIT8(KAtiBase, "ATI");
       
    70 	_LIT8(KAti0, "ATI0");
       
    71 	_LIT8(KAti1, "ATI1");
       
    72 	_LIT8(KAti2, "ATI2");
       
    73 	_LIT8(KAti3, "ATI3");
       
    74 	_LIT8(KAti4, "ATI4");
       
    75 	_LIT8(KAtGmr, "AT+GMR");
       
    76 	_LIT8(KAtGmi, "AT+GMI");
       
    77 	_LIT8(KAtGsn, "AT+GSN");
       
    78 	_LIT8(KAtCgmm, "AT+CGMM");
       
    79 	_LIT8(KAtGmm, "AT+GMM");
       
    80 	_LIT8(KAtScpbr, "AT^SCPBR");
       
    81 	_LIT8(KAtScpbw, "AT^SCPBW");
       
    82     
    62     
    83     Trace(KDebugPrintS, "token: ", &token);
    63     Trace(KDebugPrintS, "token: ", &token);
    84     // Determine the AT command type
    64     // Determine the AT command type
    85     if(!token.CompareF(KAtCfun))
    65     if(!token.CompareF(KAtCfun))
    86         {
    66         {
   108         }
    88         }
   109     else if(!token.CompareF(KAtCnum))
    89     else if(!token.CompareF(KAtCnum))
   110         {
    90         {
   111         iCmdType = ECmdAtCnum;
    91         iCmdType = ECmdAtCnum;
   112         }
    92         }
   113     else if(!token.CompareF(KAtCmee))
    93     else if(!token.Compare(KAtCmee))
   114         {
    94         {
   115         iCmdType = ECmdAtCmee;
    95         iCmdType = ECmdAtCmee;
   116 		}
       
   117     else if(!token.CompareF(KAtHver))
       
   118         {
       
   119         iCmdType = ECmdAtHver;
       
   120         }
       
   121     else if(!token.CompareF(KAtCgsn))
       
   122         {
       
   123         iCmdType = ECmdAtCgsn;
       
   124         }
       
   125     else if(!token.CompareF(KAtGsn))
       
   126         {
       
   127         iCmdType = ECmdAtGsn;
       
   128         }
       
   129     else if(!token.CompareF(KAtCgmr))
       
   130         {
       
   131         iCmdType = ECmdAtCgmr;
       
   132         }
       
   133     else if(!token.CompareF(KAtGmr))
       
   134         {
       
   135         iCmdType = ECmdAtGmr;
       
   136         }
       
   137     else if(!token.CompareF(KAtCgmi))
       
   138         {
       
   139         iCmdType = ECmdAtCgmi;
       
   140         }    
       
   141     else if(!token.CompareF(KAtGmi))
       
   142         {
       
   143         iCmdType = ECmdAtGmi;
       
   144         } 
       
   145     else if(!token.CompareF(KAtCmgw))
       
   146         {
       
   147         iCmdType = ECmdAtCmgw;
       
   148         }
       
   149     else if(!token.CompareF(KAtCmgd))
       
   150         {
       
   151         iCmdType = ECmdAtCmgd;
       
   152         }
       
   153     else if(!token.CompareF(KAtCmgf))
       
   154         {
       
   155         iCmdType = ECmdAtCmgf;
       
   156         }
       
   157     else if(!token.CompareF(KAtCgmm))
       
   158         {
       
   159         iCmdType = ECmdAtCgmm;
       
   160         }
       
   161     else if(!token.CompareF(KAtGmm))
       
   162         {
       
   163         iCmdType = ECmdAtGmm;
       
   164         }
       
   165     else if(!token.CompareF(KAtiBase))
       
   166         {
       
   167         iCmdType = ECmdAtI;
       
   168         }
       
   169     else if(!token.CompareF(KAti0))
       
   170         {
       
   171         iCmdType = ECmdAtI0;
       
   172         }
       
   173     else if(!token.CompareF(KAti1))
       
   174         {
       
   175         iCmdType = ECmdAtI1;
       
   176         }
       
   177     else if(!token.CompareF(KAti2))
       
   178         {
       
   179         iCmdType = ECmdAtI2;
       
   180         }
       
   181     else if(!token.CompareF(KAti3))
       
   182         {
       
   183         iCmdType = ECmdAtI3;
       
   184         }
       
   185     else if(!token.CompareF(KAti4))
       
   186         {
       
   187         iCmdType = ECmdAtI4;
       
   188         }
       
   189 	else if(!token.CompareF(KAtScpbr))
       
   190         {
       
   191         iCmdType = ECmdAtScpbr;
       
   192         } 
       
   193     else if(!token.CompareF(KAtScpbw))
       
   194         {
       
   195         iCmdType = ECmdAtScpbw;
       
   196         }
    96         }
   197     else
    97     else
   198         {
    98         {
   199         iCmdType = EUnknown;
    99         iCmdType = EUnknown;
   200         TRACE_FUNC_EXIT
   100         TRACE_FUNC_EXIT
   252     TChar chr = 0;
   152     TChar chr = 0;
   253     
   153     
   254     if(!iCmd.Eos())
   154     if(!iCmd.Eos())
   255         {
   155         {
   256         chr = iCmd.Peek();
   156         chr = iCmd.Peek();
   257         while(!iCmd.Eos() && chr != ',' && !chr.IsControl())
   157         while(!iCmd.Eos() && chr != ',' && !chr.IsSpace() && !chr.IsControl())
   258             {// Stop at any comma or control character
   158             {// Stop at any of those chars: comma, space or control
   259             iCmd.Inc();
   159             iCmd.Inc();
   260             chr = iCmd.Peek();
   160             chr = iCmd.Peek();
   261             }
   161             }
   262         }
   162         }
   263     
   163     
   264     // Extract the token at this point            
   164     // Extract the token at this point            
   265     TPtrC8 retVal = iCmd.MarkedToken();
   165     TPtrC8 retVal = iCmd.MarkedToken();
   266     
   166     
   267 	//ignore all space characters at the end
       
   268     if(retVal.Length() > 1)
       
   269     {
       
   270         TInt pos = retVal.Length() - 1; 
       
   271         for ( ; pos >= 0; pos-- )
       
   272             {
       
   273             const TChar ch( retVal[pos] );
       
   274             if( !ch.IsSpace() )
       
   275                 {
       
   276                 break;
       
   277                 }
       
   278             }
       
   279         retVal.Set( retVal.Mid( 0, pos + 1 ) );
       
   280     }
       
   281     
       
   282     
       
   283     // Skip comma, space and control chars
   167     // Skip comma, space and control chars
   284     do
   168     while(!iCmd.Eos() && (chr == ',' || chr.IsSpace() || chr.IsControl()))
   285       {
   169         {
   286       iCmd.Inc();
   170         iCmd.Inc();
   287       chr = iCmd.Peek();
   171         chr = iCmd.Peek();
   288       }
   172         }
   289     while(!iCmd.Eos() && (chr.IsSpace() || chr.IsControl()));
       
   290     
       
   291     TRACE_FUNC_EXIT
   173     TRACE_FUNC_EXIT
   292     return retVal;
   174     return retVal;
   293     }
   175     }
   294 
   176 
   295 TInt TAtCommandParser::NextTextParam(TPtrC8& aParam)
   177 TInt TAtCommandParser::NextTextParam(TPtrC8& aParam)
   326         {
   208         {
   327         retVal = KErrNotFound;
   209         retVal = KErrNotFound;
   328         }
   210         }
   329     else
   211     else
   330         {
   212         {
   331         //check if param contains only digits - TLex doesn't do that
   213         TLex8 lex(param);
   332         for(TInt pos = param.Length() - 1; pos >= 0; pos--)
   214         retVal = lex.Val(aValue);
   333             {
       
   334             if(( param[pos] < '0' ) || ( param[pos] > '9' ))
       
   335                 {
       
   336                 retVal = KErrArgument;
       
   337                 break;
       
   338                 }
       
   339             }
       
   340         
       
   341         if(retVal == KErrNone)
       
   342             {
       
   343             TLex8 lex(param);
       
   344             retVal = lex.Val(aValue);
       
   345             }
       
   346         }
   215         }
   347     TRACE_FUNC_EXIT
   216     TRACE_FUNC_EXIT
   348     return retVal;
   217     return retVal;
   349     }
   218     }
   350 
   219