eqi.h

Go to the documentation of this file.

 
#ifndef MUTT_MUTT_EQI_H
#define MUTT_MUTT_EQI_H
 
#include <stdbool.h>
#include <stdint.h>
#include <string.h>

static inline uint64_t make_lowercase_mask(uint64_t x, int bytenum)
{
  const char ch = x >> (bytenum * 8);
  const uint64_t mask = ((ch >= 'a') && (ch <= 'z')) ? 0x20 : 0;
  return mask << (bytenum * 8);
}

static inline bool eqi1(const char *a, const char b[1])
{
  uint8_t b8 = b[0];
  return (*a | make_lowercase_mask(b8, 0)) == (unsigned char) b[0];
}

static inline bool eqi2(const char *a, const char b[2])
{
  uint16_t a16, b16;
  memcpy(&a16, a, sizeof(a16));
  memcpy(&b16, b, sizeof(b16));
  const uint16_t lowercase_mask = make_lowercase_mask(b16, 0) |
                                  make_lowercase_mask(b16, 1);
  return (a16 | lowercase_mask) == b16;
}

static inline bool eqi4(const char *a, const char b[4])
{
  uint32_t a32, b32;
  memcpy(&a32, a, sizeof(a32));
  memcpy(&b32, b, sizeof(b32));
  const uint32_t lowercase_mask = make_lowercase_mask(b32, 0) |
                                  make_lowercase_mask(b32, 1) |
                                  make_lowercase_mask(b32, 2) |
                                  make_lowercase_mask(b32, 3);
  return (a32 | lowercase_mask) == b32;
}

static inline bool eqi8(const char *a, const char b[8])
{
  uint64_t a64, b64;
  memcpy(&a64, a, sizeof(a64));
  memcpy(&b64, b, sizeof(b64));
  const uint64_t lowercase_mask = make_lowercase_mask(b64, 0) |
                                  make_lowercase_mask(b64, 1) |
                                  make_lowercase_mask(b64, 2) |
                                  make_lowercase_mask(b64, 3) |
                                  make_lowercase_mask(b64, 4) |
                                  make_lowercase_mask(b64, 5) |
                                  make_lowercase_mask(b64, 6) |
                                  make_lowercase_mask(b64, 7);
  return (a64 | lowercase_mask) == b64;
}
 
/* various helpers for increased readability */
 
/* there's no eqi3(); consider using eqi4() instead if you can */

static inline bool eqi5(const char *a, const char b[5])
{
  return eqi4(a, b) && eqi1(a + 1, b + 1);
}

static inline bool eqi6(const char *a, const char b[6])
{
  return eqi4(a, b) && eqi2(a + 4, b + 4);
}
 
/* there's no eqi7(); consider using eqi8() instead if you can */

static inline bool eqi9(const char *a, const char b[9])
{
  return eqi8(a, b) && eqi1(a + 8, b + 8);
}

static inline bool eqi10(const char *a, const char b[10])
{
  return eqi8(a, b) && eqi2(a + 8, b + 8);
}

static inline bool eqi11(const char *a, const char b[11])
{
  return eqi8(a, b) && eqi4(a + 7, b + 7);
}

static inline bool eqi12(const char *a, const char b[12])
{
  return eqi8(a, b) && eqi4(a + 8, b + 8);
}

static inline bool eqi13(const char *a, const char b[13])
{
  return eqi8(a, b) && eqi8(a + 5, b + 5);
}

static inline bool eqi14(const char *a, const char b[14])
{
  return eqi8(a, b) && eqi8(a + 6, b + 6);
}

static inline bool eqi15(const char *a, const char b[15])
{
  return eqi8(a, b) && eqi8(a + 7, b + 7);
}

static inline bool eqi16(const char *a, const char b[16])
{
  return eqi8(a, b) && eqi8(a + 8, b + 8);
}

static inline bool eqi17(const char *a, const char b[17])
{
  return eqi16(a, b) && eqi1(a + 16, b + 16);
}
 
#endif /* MUTT_MUTT_EQI_H */