Skapade en htoi()

[Icecap]

Ja, hur ofta har man inte behövd att kunde omvandla ett HEX värde i strängform till ett verkligt värde?

För mig sker det ganska ofta och jag har haltat mig igenom med fungerande rutiner som jag skapade varje gång.

Nu behövde jag igen den funktion och beslöt mig för att det fick vara nog! Inte mer halvgjort men en "äkta" rutin!

Så jag gjorde en rutin som:
* Spolar whitespace innan festen börjar. (alltså hoppar över mellanslag och vertikal tab)
* Kastar bort inledande "0x" eller 0X" om de finns.
* Omvandlar till en icke-hex karaktär finns och returnerar resultatet.
* Returnerar 0 om inget var hittat.

Men det var ju bara det halva av vad jag egentligen behöver kom jag på!
Jag behöver ju också en rutin som jag kan ge meddelandet om att det ska vara upp till X tecken som ska omvandlas.

Jag moddade min rutin så att den i grunden kan ta antal tecken också - men om antalet anges till 0 kör den som vanligt.

Så nu har jag en htoi.c som innehåller:
* unsigned short htoi(char* Text)
* unsigned long htol(char* Text)
* unsigned long long htoll(char* Text)
* unsigned short htoin(char* Text, unsigned char Chars)
* unsigned long htoln(char* Text, unsigned char Chars)
* unsigned long long htolln(char* Text, unsigned char Chars)

Alla dessa rutiner anropar unsigned long long htolln(char* Text, unsigned char Chars) och rensar lite i dess resultat innan det skickas tillbaka.

Lite extra jobb nu men mycket sparat i längden.

[zealotry]

Var är koden?

[lillahuset]

Jag har ungefär hälften.

[Icecap]

OK då.

Kod: Markera allt

unsigned long long htolln(const char* Data, unsigned short Chars)
  {
  // The Chars counts actual HEX characters to be converted
  unsigned long long Result;
  unsigned short Ctr;
  if(!Data) return 0;
  Result = 0;
  Ctr    = Chars;
  if(!Chars) Ctr = 1; // Anything but zero
  while((*Data == ' ') || (*Data == '\t'))
    {
    Data++; // Skip whitespaces
    }
  if((*Data == '0') && ((*(Data + 1) == 'x') || (*(Data + 1) == 'X')))
    {
    Data += 2; // Skip past any leading "0x" or "0X"
    }
  while(Ctr)
    {
    if(Chars) Ctr--;
    if((*Data >= '0') && (*Data <= '9'))
      {
      Result <<= 4;
      Result += *Data - '0';
      }
    else if((*Data >= 'A') && (*Data <= 'F'))
      {
      Result <<= 4;
      Result += (*Data - 'A') + 10;
      }
    else if((*Data >= 'a') && (*Data <= 'f'))
      {
      Result <<= 4;
      Result += (*Data - 'a') + 10;
      }
    else return Result; // A non-HEX char has occured, we're done!
    Data++;
    }
  return Result;
  }

Alla andra rutinerna kallar denna. Jag har inte testat den men är skaplig säker på att den fungerar.

EDIT1: Ändrat pga. bugg rapporterat av johano.
EDIT2: Återställd då det inte var någon bugg.
EDIT3: Ändrat så att den faktisk stegar genom datasträngen. Tack Mr Andersson.

[Wedge]

Du startar alltså den här tråden för att tala om att du skrivit nåt, men inte testat det???

[Icecap]

Wedge: kompilerar OK men ja, jag har inte hunnit kolla att det fungerar. Men skulle någon annan behöva att använda den funktion och det visar sig vara knas med den är jag ganska säker på att jag får veta det snabbt.

[johano]

Här får du en buggrapport: koden nedan borde skrivit ut 0 men skriver istället 15.
Felet ligger i koden som kollar mot '0x', den checkar efterkommande tecken utan att
kolla mot Chars att bufferten verkligen är så stor att den säkert kan flytta fram pekaren 1och2 steg

Kod: Markera allt

int main()
{
char a = '0';
char b = 'X';
char c = 'F';

printf("%lld", htolln(&a,1));

return 0;
}

/j

[Icecap]

Just fan. Har nu ändrat koden, även i mitt inlägg ovan.

[sodjan]

Är det fortfarande otestat? Jag får i alla fall fortfarande svaret 0.
Sen så förstår jag i och för sig inte heller denna del:

Kod: Markera allt

char a = '0';
char b = 'X';
char c = 'F';

printf("%lld\n", htolln(&a,1));

Räcker det att skiicka en pekare till a? Kräver inte
det att b och c ligger direkt efter a för att fungera?
Ska det inte vara en stäng "0XF" som pekar en ska peka till?

[sodjan]

Fungerear med denna testkod:

Kod: Markera allt

int main()
{
  char *d = "0xF";
  printf("%lld\n", htolln(d,1));
  return 0;
}

$ r HTOLLN
15
$

[Lennart Aspenryd]

Det är väl detta som Sef skall vara till !

En Mjuk vara kan vara lika värdefull som en Hård vara!

Och tankar och idéer mår bäst av att förökas, det tror jag även de kritiska kan hålla med om!

Och Hextals omvandling till Integer är ofta behövligt.

[sodjan]

Ja, gärna mer innehåll i denna "mjuka" sida av EF!
Personligen även mer databas relaterade saker...

[X-IL]

Är det fortfarande otestat? Jag får i alla fall fortfarande svaret 0.
Sen så förstår jag i och för sig inte heller denna del:

Kod: Markera allt

char a = '0';
char b = 'X';
char c = 'F';

printf("%lld\n", htolln(&a,1));

Räcker det att skiicka en pekare till a? Kräver inte
det att b och c ligger direkt efter a för att fungera?
Ska det inte vara en stäng "0XF" som pekar en ska peka till?

Jag kanske missförtod men det var väl det som var buggen, att den fortsatte läsa förbi det angivna antalet tecken. Så den läste nästa minnesposition trots att johano angivit ett teckens längd.

[sodjan]

Så buggen var i johanos testkod, inte i Icecaps funktion?

Nu så körde jag senast i och för sig med den kod som Icecap anser
sig ha ändrat, så jag vet inte. Men det fungerade ändå inte med
johanos ursprungliga kod med tre separata variabler. Jag fick göra
en "sträng" istället, då fungerar det.

Jag misstänker att a, b och c kommer att "alignas" på jämna
64 bitars adresser och pekaren stegar nog i bytes. Kanske att
johanos kod förutsätter en 8-bitars arkitektur (?).

[Wedge]

Fungerear med denna testkod:

Kod: Markera allt

int main()
{
  char *d = "0xF";
  printf("%lld\n", htolln(d,1));
  return 0;
}

$ r HTOLLN
15
$

Om man konverterar ETT tecken ska det bli 0,oavsett vad som följer efter nollan. Icecaps kod läser utanför spelplanen, ergo bugg.