Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/c/generic/str.c

    rd7f6248 rc3d19ac  
    12911291}
    12921292
    1293 /** Convert string to uint8_t.
    1294  *
    1295  * @param nptr   Pointer to string.
    1296  * @param endptr If not NULL, pointer to the first invalid character
    1297  *               is stored here.
    1298  * @param base   Zero or number between 2 and 36 inclusive.
    1299  * @param strict Do not allow any trailing characters.
    1300  * @param result Result of the conversion.
    1301  *
    1302  * @return EOK if conversion was successful.
    1303  *
    1304  */
    1305 int str_uint8_t(const char *nptr, char **endptr, unsigned int base,
    1306     bool strict, uint8_t *result)
    1307 {
    1308         assert(result != NULL);
    1309        
    1310         bool neg;
    1311         char *lendptr;
    1312         uint64_t res;
    1313         int ret = str_uint(nptr, &lendptr, base, &neg, &res);
    1314        
    1315         if (endptr != NULL)
    1316                 *endptr = (char *) lendptr;
    1317        
    1318         if (ret != EOK)
    1319                 return ret;
    1320        
    1321         /* Do not allow negative values */
    1322         if (neg)
    1323                 return EINVAL;
    1324        
    1325         /* Check whether we are at the end of
    1326            the string in strict mode */
    1327         if ((strict) && (*lendptr != 0))
    1328                 return EINVAL;
    1329        
    1330         /* Check for overflow */
    1331         uint8_t _res = (uint8_t) res;
    1332         if (_res != res)
    1333                 return EOVERFLOW;
    1334        
    1335         *result = _res;
    1336        
    1337         return EOK;
    1338 }
    1339 
    1340 /** Convert string to uint16_t.
    1341  *
    1342  * @param nptr   Pointer to string.
    1343  * @param endptr If not NULL, pointer to the first invalid character
    1344  *               is stored here.
    1345  * @param base   Zero or number between 2 and 36 inclusive.
    1346  * @param strict Do not allow any trailing characters.
    1347  * @param result Result of the conversion.
    1348  *
    1349  * @return EOK if conversion was successful.
    1350  *
    1351  */
    1352 int str_uint16_t(const char *nptr, char **endptr, unsigned int base,
    1353     bool strict, uint16_t *result)
    1354 {
    1355         assert(result != NULL);
    1356        
    1357         bool neg;
    1358         char *lendptr;
    1359         uint64_t res;
    1360         int ret = str_uint(nptr, &lendptr, base, &neg, &res);
    1361        
    1362         if (endptr != NULL)
    1363                 *endptr = (char *) lendptr;
    1364        
    1365         if (ret != EOK)
    1366                 return ret;
    1367        
    1368         /* Do not allow negative values */
    1369         if (neg)
    1370                 return EINVAL;
    1371        
    1372         /* Check whether we are at the end of
    1373            the string in strict mode */
    1374         if ((strict) && (*lendptr != 0))
    1375                 return EINVAL;
    1376        
    1377         /* Check for overflow */
    1378         uint16_t _res = (uint16_t) res;
    1379         if (_res != res)
    1380                 return EOVERFLOW;
    1381        
    1382         *result = _res;
    1383        
    1384         return EOK;
    1385 }
    1386 
    1387 /** Convert string to uint32_t.
    1388  *
    1389  * @param nptr   Pointer to string.
    1390  * @param endptr If not NULL, pointer to the first invalid character
    1391  *               is stored here.
    1392  * @param base   Zero or number between 2 and 36 inclusive.
    1393  * @param strict Do not allow any trailing characters.
    1394  * @param result Result of the conversion.
    1395  *
    1396  * @return EOK if conversion was successful.
    1397  *
    1398  */
    1399 int str_uint32_t(const char *nptr, char **endptr, unsigned int base,
    1400     bool strict, uint32_t *result)
    1401 {
    1402         assert(result != NULL);
    1403        
    1404         bool neg;
    1405         char *lendptr;
    1406         uint64_t res;
    1407         int ret = str_uint(nptr, &lendptr, base, &neg, &res);
    1408        
    1409         if (endptr != NULL)
    1410                 *endptr = (char *) lendptr;
    1411        
    1412         if (ret != EOK)
    1413                 return ret;
    1414        
    1415         /* Do not allow negative values */
    1416         if (neg)
    1417                 return EINVAL;
    1418        
    1419         /* Check whether we are at the end of
    1420            the string in strict mode */
    1421         if ((strict) && (*lendptr != 0))
    1422                 return EINVAL;
    1423        
    1424         /* Check for overflow */
    1425         uint32_t _res = (uint32_t) res;
    1426         if (_res != res)
    1427                 return EOVERFLOW;
    1428        
    1429         *result = _res;
    1430        
    1431         return EOK;
    1432 }
    1433 
    14341293/** Convert string to uint64_t.
    14351294 *
Note: See TracChangeset for help on using the changeset viewer.