rune.h

Go to the documentation of this file.

#pragma once
#include <picofuse/sys.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef int32_t rune_t;

#define RUNE_ERROR ((rune_t)0xFFFD)

extern const char *sys_rune_next(const char *str, rune_t *rune);

extern size_t sys_rune_count(const char *str);

extern bool sys_rune_valid(const char *str);

// CLASSIFICATION
//
// These classify ASCII plus the Latin-1 Supplement block (0x80-0xFF) -
// accented Western European letters and their punctuation/space/control
// characters are recognized, but every other script (Greek, Cyrillic, CJK,
// etc.) is out of scope and reports false from all of them.

static inline bool sys_rune_is_digit(rune_t r) { return r >= '0' && r <= '9'; }

static inline bool sys_rune_is_space(rune_t r) {
  switch (r) {
  case ' ':
  case '\t':
  case '\n':
  case '\v':
  case '\f':
  case '\r':
  case 0x0085: // NEL
  case 0x00A0: // NBSP
    return true;
  default:
    return false;
  }
}

static inline bool sys_rune_is_upper(rune_t r) {
  if (r >= 'A' && r <= 'Z') {
    return true;
  }
  if (r >= 0x00C0 && r <= 0x00D6) { // A grave - O diaeresis
    return true;
  }
  if (r >= 0x00D8 && r <= 0x00DE) { // O stroke - Thorn
    return true;
  }
  return false;
}

static inline bool sys_rune_is_lower(rune_t r) {
  if (r >= 'a' && r <= 'z') {
    return true;
  }
  if (r == 0x00DF) { // sharp s
    return true;
  }
  if (r >= 0x00E0 && r <= 0x00F6) { // a grave - o diaeresis
    return true;
  }
  if (r >= 0x00F8 && r <= 0x00FF) { // o stroke - y diaeresis
    return true;
  }
  return false;
}

static inline bool sys_rune_is_alpha(rune_t r) {
  return sys_rune_is_upper(r) || sys_rune_is_lower(r);
}

static inline rune_t sys_rune_to_upper(rune_t r) {
  if (r >= 'a' && r <= 'z') {
    return r - 32;
  }
  if (r >= 0x00E0 && r <= 0x00F6) { // a grave - o diaeresis
    return r - 0x20;
  }
  if (r >= 0x00F8 && r <= 0x00FE) { // o stroke - thorn
    return r - 0x20;
  }
  return r;
}

static inline rune_t sys_rune_to_lower(rune_t r) {
  if (r >= 'A' && r <= 'Z') {
    return r + 32;
  }
  if (r >= 0x00C0 && r <= 0x00D6) { // A grave - O diaeresis
    return r + 0x20;
  }
  if (r >= 0x00D8 && r <= 0x00DE) { // O stroke - Thorn
    return r + 0x20;
  }
  return r;
}

static inline bool sys_rune_is_punct(rune_t r) {
  switch (r) {
  case '!':
  case '"':
  case '#':
  case '%':
  case '&':
  case '\'':
  case '(':
  case ')':
  case '*':
  case ',':
  case '-':
  case '.':
  case '/':
  case ':':
  case ';':
  case '?':
  case '@':
  case '[':
  case '\\':
  case ']':
  case '_':
  case '{':
  case '}':
  case 0x00A1: // inverted exclamation mark
  case 0x00A7: // section sign
  case 0x00B6: // pilcrow sign
  case 0x00B7: // middle dot
  case 0x00BF: // inverted question mark
    return true;
  default:
    return false;
  }
}

static inline bool sys_rune_is_symbol(rune_t r) {
  switch (r) {
  case '$':
  case '+':
  case '<':
  case '=':
  case '>':
  case '^':
  case '`':
  case '|':
  case '~':
  case 0x00A2: // cent sign
  case 0x00A3: // pound sign
  case 0x00A4: // currency sign
  case 0x00A5: // yen sign
  case 0x00A6: // broken bar
  case 0x00A8: // diaeresis
  case 0x00A9: // copyright sign
  case 0x00AC: // not sign
  case 0x00AE: // registered sign
  case 0x00AF: // macron
  case 0x00B0: // degree sign
  case 0x00B1: // plus-minus sign
  case 0x00B4: // acute accent
  case 0x00B8: // cedilla
  case 0x00D7: // multiplication sign
  case 0x00F7: // division sign
    return true;
  default:
    return false;
  }
}

static inline bool sys_rune_is_control(rune_t r) {
  if (r >= 0x00 && r <= 0x1F) {
    return true;
  }
  if (r == 0x7F) { // DEL
    return true;
  }
  if (r >= 0x80 && r <= 0x9F) { // C1 controls
    return true;
  }
  return false;
}

// TOKENIZATION

typedef enum {
  sys_rune_other = 0, 
  sys_rune_space,      
  sys_rune_digit,      
  sys_rune_alpha,      
  sys_rune_punct,      
  sys_rune_symbol,     
  sys_rune_control,    
} sys_rune_class_t;

extern sys_rune_class_t sys_rune_isa(rune_t r);

typedef struct sys_rune_tokenize_t {
  sys_iostream_t *stream; 
  ptrdiff_t start;        
  size_t bytes;           
  size_t runes;           
  sys_rune_class_t isa;   
} sys_rune_tokenize_t;

extern sys_rune_tokenize_t sys_rune_tokenize_init(sys_iostream_t *stream);

extern bool sys_rune_tokenize_next(sys_rune_tokenize_t *it);

extern size_t sys_rune_tokenize_token(sys_rune_tokenize_t *it, char *buf,
                                      size_t cap);


#ifdef __cplusplus
}
#endif