Line data    Source code

       1             : /******************************************************************************
       2             :  *
       3             :  * Purpose:  Functions to convert an ascii string to an integer value.
       4             :  *
       5             :  ******************************************************************************
       6             :  * Copyright (c) 2011
       7             :  * PCI Geomatics, 90 Allstate Parkway, Markham, Ontario, Canada.
       8             :  *
       9             :  * SPDX-License-Identifier: MIT
      10             :  ****************************************************************************/
      11             : 
      12             : #ifndef PCIDSK_SCANINT_H
      13             : #define PCIDSK_SCANINT_H
      14             : 
      15             : #include "pcidsk_config.h"
      16             : #include <cassert>
      17             : #include <cmath>
      18             : 
      19             : namespace PCIDSK
      20             : {
      21             : 
      22             : extern const int16 ganCharTo1[256];
      23             : extern const int16 ganCharTo10[256];
      24             : extern const int16 ganCharTo100[256];
      25             : extern const int16 ganCharTo1000[256];
      26             : extern const int32 ganCharTo10000[256];
      27             : extern const int32 ganCharTo100000[256];
      28             : extern const int32 ganCharTo1000000[256];
      29             : extern const int32 ganCharTo10000000[256];
      30             : extern const int32 ganCharTo100000000[256];
      31             : extern const int64 ganCharTo1000000000[256];
      32             : extern const int64 ganCharTo10000000000[256];
      33             : extern const int64 ganCharTo100000000000[256];
      34             : 
      35             : inline int16 ScanInt1(const uint8 * string)
      36             : {
      37             :     if (*string != '-')
      38             :     {
      39             :         int16 nValue =
      40             :             (ganCharTo1 [*(string)]);
      41             : 
      42             :         return nValue;
      43             :     }
      44             :     else
      45             :     {
      46             :         return 0;
      47             :     }
      48             : }
      49             : 
      50             : inline int16 ScanInt2(const uint8 * string)
      51             : {
      52             :     if (*string != '-')
      53             :     {
      54             :         int16 nValue =
      55             :             (ganCharTo10[*(string    )] +
      56             :              ganCharTo1 [*(string + 1)]);
      57             : 
      58             :         return nValue;
      59             :     }
      60             :     else
      61             :     {
      62             :         return ganCharTo1[*(string + 1)] * -1;
      63             :     }
      64             : }
      65             : 
      66          24 : inline int16 ScanInt3(const uint8 * string)
      67             : {
      68          24 :     int16 nValue =
      69          24 :         (ganCharTo100[*(string    )] +
      70          24 :          ganCharTo10 [*(string + 1)] +
      71          24 :          ganCharTo1  [*(string + 2)]);
      72             : 
      73          24 :     if (nValue < 0)
      74             :     {
      75           0 :         const uint8 * pbyIter = string;
      76           0 :         while (*pbyIter != '-')
      77           0 :             ++pbyIter;
      78           0 :         return (int16) -std::pow((double) 10,
      79           0 :                                  2 - (int) (pbyIter - string)) - nValue;
      80             :     }
      81             : 
      82          24 :     return nValue;
      83             : }
      84             : 
      85         102 : inline int16 ScanInt4(const uint8 * string)
      86             : {
      87         102 :     int16 nValue =
      88         102 :         (ganCharTo1000[*(string    )] +
      89         102 :          ganCharTo100 [*(string + 1)] +
      90         102 :          ganCharTo10  [*(string + 2)] +
      91         102 :          ganCharTo1   [*(string + 3)]);
      92             : 
      93         102 :     if (nValue < 0)
      94             :     {
      95           0 :         const uint8 * pbyIter = string;
      96           0 :         while (*pbyIter != '-')
      97           0 :             ++pbyIter;
      98           0 :         return (int16) -std::pow((double) 10,
      99           0 :                                  3 - (int) (pbyIter - string)) - nValue;
     100             :     }
     101             : 
     102         102 :     return nValue;
     103             : }
     104             : 
     105             : inline int32 ScanInt5(const uint8 * string)
     106             : {
     107             :     int32 nValue =
     108             :         (ganCharTo10000[*(string    )] +
     109             :          ganCharTo1000 [*(string + 1)] +
     110             :          ganCharTo100  [*(string + 2)] +
     111             :          ganCharTo10   [*(string + 3)] +
     112             :          ganCharTo1    [*(string + 4)]);
     113             : 
     114             :     if (nValue < 0)
     115             :     {
     116             :         const uint8 * pbyIter = string;
     117             :         while (*pbyIter != '-')
     118             :             ++pbyIter;
     119             :         return (int32) -std::pow((double) 10,
     120             :                                  4 - (int) (pbyIter - string)) - nValue;
     121             :     }
     122             : 
     123             :     return nValue;
     124             : }
     125             : 
     126             : inline int32 ScanInt6(const uint8 * string)
     127             : {
     128             :     int32 nValue =
     129             :         (ganCharTo100000[*(string    )] +
     130             :          ganCharTo10000 [*(string + 1)] +
     131             :          ganCharTo1000  [*(string + 2)] +
     132             :          ganCharTo100   [*(string + 3)] +
     133             :          ganCharTo10    [*(string + 4)] +
     134             :          ganCharTo1     [*(string + 5)]);
     135             : 
     136             :     if (nValue < 0)
     137             :     {
     138             :         const uint8 * pbyIter = string;
     139             :         while (*pbyIter != '-')
     140             :             ++pbyIter;
     141             :         return (int32) -std::pow((double) 10,
     142             :                                  5 - (int) (pbyIter - string)) - nValue;
     143             :     }
     144             : 
     145             :     return nValue;
     146             : }
     147             : 
     148             : inline int32 ScanInt7(const uint8 * string)
     149             : {
     150             :     int32 nValue =
     151             :         (ganCharTo1000000[*(string    )] +
     152             :          ganCharTo100000 [*(string + 1)] +
     153             :          ganCharTo10000  [*(string + 2)] +
     154             :          ganCharTo1000   [*(string + 3)] +
     155             :          ganCharTo100    [*(string + 4)] +
     156             :          ganCharTo10     [*(string + 5)] +
     157             :          ganCharTo1      [*(string + 6)]);
     158             : 
     159             :     if (nValue < 0)
     160             :     {
     161             :         const uint8 * pbyIter = string;
     162             :         while (*pbyIter != '-')
     163             :             ++pbyIter;
     164             :         return (int32) -std::pow((double) 10,
     165             :                                  6 - (int) (pbyIter - string)) - nValue;
     166             :     }
     167             : 
     168             :     return nValue;
     169             : }
     170             : 
     171         248 : inline int32 ScanInt8(const uint8 * string)
     172             : {
     173         248 :     int32 nValue =
     174         248 :         (ganCharTo10000000[*(string    )] +
     175         248 :          ganCharTo1000000 [*(string + 1)] +
     176         248 :          ganCharTo100000  [*(string + 2)] +
     177         248 :          ganCharTo10000   [*(string + 3)] +
     178         248 :          ganCharTo1000    [*(string + 4)] +
     179         248 :          ganCharTo100     [*(string + 5)] +
     180         248 :          ganCharTo10      [*(string + 6)] +
     181         248 :          ganCharTo1       [*(string + 7)]);
     182             : 
     183         248 :     if (nValue < 0)
     184             :     {
     185          10 :         const uint8 * pbyIter = string;
     186          70 :         while (*pbyIter != '-')
     187          60 :             ++pbyIter;
     188          20 :         return (int32) -std::pow((double) 10,
     189          10 :                                  7 - (int) (pbyIter - string)) - nValue;
     190             :     }
     191             : 
     192         238 :     return nValue;
     193             : }
     194             : 
     195             : inline int32 ScanInt9(const uint8 * string)
     196             : {
     197             :     int32 nValue =
     198             :         (ganCharTo100000000[*(string    )] +
     199             :          ganCharTo10000000 [*(string + 1)] +
     200             :          ganCharTo1000000  [*(string + 2)] +
     201             :          ganCharTo100000   [*(string + 3)] +
     202             :          ganCharTo10000    [*(string + 4)] +
     203             :          ganCharTo1000     [*(string + 5)] +
     204             :          ganCharTo100      [*(string + 6)] +
     205             :          ganCharTo10       [*(string + 7)] +
     206             :          ganCharTo1        [*(string + 8)]);
     207             : 
     208             :     if (nValue < 0)
     209             :     {
     210             :         const uint8 * pbyIter = string;
     211             :         while (*pbyIter != '-')
     212             :             ++pbyIter;
     213             :         return (int32) -std::pow((double) 10,
     214             :                                  8 - (int) (pbyIter - string)) - nValue;
     215             :     }
     216             : 
     217             :     return nValue;
     218             : }
     219             : 
     220             : inline int64 ScanInt10(const uint8 * string)
     221             : {
     222             :     int64 nValue =
     223             :         (ganCharTo1000000000[*(string    )] +
     224             :          ganCharTo100000000 [*(string + 1)] +
     225             :          ganCharTo10000000  [*(string + 2)] +
     226             :          ganCharTo1000000   [*(string + 3)] +
     227             :          ganCharTo100000    [*(string + 4)] +
     228             :          ganCharTo10000     [*(string + 5)] +
     229             :          ganCharTo1000      [*(string + 6)] +
     230             :          ganCharTo100       [*(string + 7)] +
     231             :          ganCharTo10        [*(string + 8)] +
     232             :          ganCharTo1         [*(string + 9)]);
     233             : 
     234             :     if (nValue < 0)
     235             :     {
     236             :         const uint8 * pbyIter = string;
     237             :         while (*pbyIter != '-')
     238             :             ++pbyIter;
     239             :         return (int64) -std::pow((double) 10,
     240             :                                  9 - (int) (pbyIter - string)) - nValue;
     241             :     }
     242             : 
     243             :     return nValue;
     244             : }
     245             : 
     246             : inline int64 ScanInt11(const uint8 * string)
     247             : {
     248             :     int64 nValue =
     249             :         (ganCharTo10000000000[*(string    )] +
     250             :          ganCharTo1000000000 [*(string + 1)] +
     251             :          ganCharTo100000000  [*(string + 2)] +
     252             :          ganCharTo10000000   [*(string + 3)] +
     253             :          ganCharTo1000000    [*(string + 4)] +
     254             :          ganCharTo100000     [*(string + 5)] +
     255             :          ganCharTo10000      [*(string + 6)] +
     256             :          ganCharTo1000       [*(string + 7)] +
     257             :          ganCharTo100        [*(string + 8)] +
     258             :          ganCharTo10         [*(string + 9)] +
     259             :          ganCharTo1          [*(string + 10)]);
     260             : 
     261             :     if (nValue < 0)
     262             :     {
     263             :         const uint8 * pbyIter = string;
     264             :         while (*pbyIter != '-')
     265             :             ++pbyIter;
     266             :         return (int64) -std::pow((double) 10,
     267             :                                  10 - (int) (pbyIter - string)) - nValue;
     268             :     }
     269             : 
     270             :     return nValue;
     271             : }
     272             : 
     273          26 : inline int64 ScanInt12(const uint8 * string)
     274             : {
     275          26 :     int64 nValue =
     276          26 :         (ganCharTo100000000000[*(string    )] +
     277          26 :          ganCharTo10000000000 [*(string + 1)] +
     278          26 :          ganCharTo1000000000  [*(string + 2)] +
     279          26 :          ganCharTo100000000   [*(string + 3)] +
     280          26 :          ganCharTo10000000    [*(string + 4)] +
     281          26 :          ganCharTo1000000     [*(string + 5)] +
     282          26 :          ganCharTo100000      [*(string + 6)] +
     283          26 :          ganCharTo10000       [*(string + 7)] +
     284          26 :          ganCharTo1000        [*(string + 8)] +
     285          26 :          ganCharTo100         [*(string + 9)] +
     286          26 :          ganCharTo10          [*(string + 10)] +
     287          26 :          ganCharTo1           [*(string + 11)]);
     288             : 
     289          26 :     if (nValue < 0)
     290             :     {
     291           0 :         const uint8 * pbyIter = string;
     292           0 :         while (*pbyIter != '-')
     293           0 :             ++pbyIter;
     294           0 :         return (int64) -std::pow((double) 10,
     295           0 :                                  11 - (int) (pbyIter - string)) - nValue;
     296             :     }
     297             : 
     298          26 :     return nValue;
     299             : }
     300             : 
     301             : } // namespace PCIDSK
     302             : 
     303             : #endif