ll_platform_generic.h

#ifndef LL_PLATFORM_GENERIC_H
#define LL_PLATFORM_GENERIC_H
 
#include <stdio.h>
#include <stdint.h>
#include <stdarg.h>
#include "assert.h"
#include "unistd.h"
 
#if LL_ARDUINO
#include "Arduino.h"
#endif
 
#if LL_FAKE_ARDUINO
#include <string.h>
 
unsigned long millis();
unsigned long micros();
void delay_ms(unsigned long ms);
 
static void delay(unsigned long ms) { delay_ms(ms); }
 
typedef uint8_t byte;
 
class LL_String {
public:
 
  LL_String()                           { ptr = 0;  set(""); }
  LL_String(const char *other)          { ptr = 0;  set(other);  }
  LL_String(const char *other, int n)   { ptr = 0;  set(other, n);  }
  LL_String(const LL_String &other)     { ptr = 0;  set(other.ptr);  }
  
  ~LL_String()  { if (ptr) { delete[] ptr;  ptr = 0; } }
 
  void set(const char *s) { set(s, strlen(s)); }
 
  void set(const char *s, int n) {
    if (ptr) { delete[] ptr;  ptr = 0; }
    char *p = ptr = new char[n + 1];
    while (n--) *p++ = *s++;
    *p = '\0';
  }
  
  LL_String concat(const char *s1, const char *s2) {
    int n1 = strlen(s1);
    int n2 = strlen(s2);
    char *s3 = new char[n1 + n2 + 1];
 
    char *p = s3;
    while (n1--) *p++ = *s1++;
    while (n2--) *p++ = *s2++;
    *p = '\0';
    return s3;
  }
 
  LL_String &append(const char *s1) {
    const char *s0 = ptr;
    int n0 = s0 ? strlen(s0) : 0;
    int n1 = strlen(s1);
    char *s2 = new char[n0 + n1 + 1];
 
    char *p = s2;
    while (n0--) *p++ = *s0++;
    while (n1--) *p++ = *s1++;
    *p = '\0';
    
    if (ptr) { delete[] ptr;  ptr = 0; }
    ptr = s2;
    return *this;
  }
 
  LL_String substring(int start, int len)       { return LL_String(&(ptr[start]), len); }
  
  LL_String &operator=(const char *other)       { set(other); return *this; }
  LL_String &operator=(const LL_String &other)  { set(other.ptr); return *this; }
 
  bool operator==(const char *other)            { return strcmp(ptr, other) == 0; }
  bool operator!=(const char *other)            { return strcmp(ptr, other) != 0; }
  bool operator==(const LL_String &other)       { return strcmp(ptr, other.ptr) == 0; }
  bool operator!=(const LL_String &other)       { return strcmp(ptr, other.ptr) != 0; }
  char &operator[](int ix)                      { return ptr[ix]; }
 
  LL_String operator+(const char *other)        { return concat(ptr, other); }
  LL_String operator+(const LL_String &other)   { return concat(ptr, other.ptr); }
  LL_String operator+(char c)                   { char cstr[2];  cstr[0] = c;  cstr[1] = '\0';  return concat(ptr, cstr); }
 
  LL_String &operator+=(const char *other)      { return append(other); }
  LL_String &operator+=(const LL_String &other) { return append(other.ptr); }
  LL_String &operator+=(char c)                 { char cstr[2];  cstr[0] = c;  cstr[1] = '\0';  return append(cstr); }
  
  char *c_str() const   { return ptr; }
  int length()  { return strlen(ptr); }  
  
private:
  char *ptr;
};
 
typedef LL_String String;
#endif

#define NOTUSED __attribute__((__unused__))                     
#define INLINE __attribute__((__inline__))                      
#define NOINLINE __attribute__((__noinline__))                  
#define CHECKPRINTF __attribute__((format(printf, 1, 2)))       
#define CHECKPRINTF_pos2 __attribute__((format(printf, 2, 3)))  
#define CHECKPRINTF_pos3 __attribute__((format(printf, 3, 4)))  
#define CHECKPRINTF_pos4 __attribute__((format(printf, 4, 5)))  

const unsigned long toString_MAX_LENGTH = 8192;         
String toString(const char *fmt, ...) CHECKPRINTF;      
 
 
#define ME(_me_) NOTUSED const char me[] = _me_                 
#define isdef(sym) (#sym[0])                                    
 
void global_printf(const char *fmt, ...);               


 
typedef unsigned char Byte_t;   
typedef bool Bool_t;            
typedef char Char_t;            
 
typedef Char_t const *Charst_t;         
typedef Byte_t const *Bytest_t;         
typedef Char_t *CharVec_t;              
typedef Byte_t *ByteVec_t;              
 
#if LL_AMD64
typedef unsigned long Word_t;   
typedef int Int_t;              
typedef double Real_t;          
typedef void *Ptr_t;            
#endif
 
#if LL_ARM64
typedef unsigned long Word_t;   
typedef int Int_t;              
typedef float Real_t;           
typedef void *Ptr_t;            
#endif
 
#if LL_ESP32
typedef unsigned Word_t;        
typedef int Int_t;              
typedef double Real_t;          
typedef void *Ptr_t;            
#endif
 
static_assert(sizeof(Word_t) == sizeof(Ptr_t), "Word_t size must be == Ptr_t size\n");
static_assert(sizeof(Word_t) >= sizeof(Int_t), "Word_t size must be >= Int_t size\n");
static_assert(sizeof(Real_t) <= 2*sizeof(Word_t), "Real_t size must be <= 2 * Word_t size\n");
 
//The AsciiConverter class mitigates printf formatting problems caused by different int sizes on different processors, when using printf-style format string (%u, %d %lu %ld etc).
class AsciiConverter {
public:
 
  char *dec(Word_t n) {
    Int_t ix  = buffer_size - 1;
    char *ptr = &(buffer[ix]);
 
    *ptr = '\0';
    do {
      Word_t d = n % 10;
      n /= 10;
      char c = d + '0';
      *--ptr = c;
    } while (n);
    return ptr;
  }
 
  char *dec(Int_t n) {
    if (n >= 0) return dec((Word_t) n);
    n = -n;
    char *ptr = dec((Word_t) n);
    *--ptr = '-';
    return ptr;
  }
 
  char *hex(Word_t n) {
    Int_t ix   = buffer_size - 1;
    char *ptr  = &(buffer[ix]);
    Int_t nibs = sizeof(Word_t) * 2;
 
    *ptr = '\0';
    while (nibs--) {
      Word_t d = n & 0x0f;
      n >>= 4;
      char c = (d < 10) ? (d + '0') : (d - 10 + 'a');
      *--ptr = c;
    }
    return ptr;
 
  }
 
  char *dec(Real_t n) {
    snprintf(buffer, buffer_size, "%f", (double) n);
    return buffer;
  }
 
private:
  static const Int_t buffer_size = 128;
  char buffer[buffer_size];
};
 
extern AsciiConverter ascii;
  
class LambPlatform {
public:

  LambPlatform() {}
  ~LambPlatform() { end(); }
 
  void begin(void);
  void loop(void);                      
  void end(void);
  
  void reboot(void);
  
  const char *name();                   
  void identification(void);            
 
  Int_t free_heap();                    
  Int_t free_stack();                   
  Bool_t heap_integrity_check(Bool_t complain=false);   

  Real_t rand11() {
    const int max_int = (~((unsigned int) 0)) >> 1;
    const int min_int = -max_int - 1;
    const Real_t min  = (Real_t) min_int;
    
    Int_t n;
    rand((byte *) &n, sizeof(n));
    return (n / min);
  }
  
  Real_t rand01()                       { return (rand11() + 1.0) / 2.0; }
 
  void rand(byte *buf, Int_t len);      
  void rand11(Real_t *buf, Int_t n)     { while (n--) *buf++ = rand11(); }
  void rand01(Real_t *buf, Int_t n)     { while (n--) *buf++ = rand01(); }
 
  Int_t loop_elapsed_ms()       { return millis() - loop_start_ms; }    
  Int_t loop_elapsed_us()       { return micros() - loop_start_us; }    

 
private:
  Int_t loop_start_ms;
  Int_t loop_start_us;
};
 
extern LambPlatform lambPlatform;

#if LL_SPIFFS
#include "SPIFFS.h"
typedef File File_Native;
#endif
 
#if LL_POSIX
#include <stdio.h>
typedef FILE* File_Native;
#endif

class LL_File {
public:
 
  LL_File();
  ~LL_File();
 
  bool isOpen() { return _path != ""; }
  int read(void);
  int write(byte b);
  int seek(unsigned long target, int whence=SEEK_SET);
  int tell();
  int size();
  int close();
 
  int read(byte *b, int n) {
    Int_t nread = 0;
    while (n--) {
      int ch = read();
      if (ch == EOF) return nread;
      b[nread++] = ch;
    }
    return nread;
  }
  
  int read(char *s, int n) { return read((byte *) s, n); }  
  int write(const byte *b, int n) { while (n--) write(*b++); return n; }
  int write(const char *s, int n) { while (n--) write((byte) *s++); return n; }
  int peek();
  
  File_Native _theFile;
  String _path;
  String _mode;
 
private:
 
};


class LL_File_System {
public:
  LL_File *open(const char *path, const char *mode);
  int rm(const char *path);
  int mv(const char *from, const char *to);  
 
private:
};
 
extern LL_File_System ll_file_system;

#if LL_WIRE
#include "Wire.h"
extern TwoWire *LL_Wire;
#endif
 
#if LL_WIFI
#include "WiFi.h"
extern WiFiClass *LL_WiFi;
#endif

class LambStdioClass {
public:
  int setTxBufferSize(int n);
  int setRxBufferSize(int n);
  
  void begin(void) { begin(115200); }
  void begin(unsigned long baudrate);
  void end();
  int available(void);
  int availableForWrite(void);
  int read(void);
  int write(uint8_t c);
  int write(char c) { return write((uint8_t) c); }
  
  void flush(void);
 
  int read(byte *buf, int max) {
    int nread = 0;
    while (max--) {
      int b = read();
      if (b == EOF) break;
      *buf++ = b;
    }
    return nread;
  }
 
  int read(char *s, int max)            { return read((uint8_t *) s, max); }
  int write(const char *s, int n)       { return write((uint8_t *) s, n); }
  int write(const byte *b, size_t n)    { int i=n;  while (i--) write(*b++);  return n; }
  int write(const char *s)              { int i=0;  while (*s) { write(*s++); i++; }  return i; }
  
  operator bool() { return true; }
};
 
extern LambStdioClass LambStdio;
 
typedef byte uuid_t[16];

#define once(_once_something) do {              \
    static bool _visited_ = false;              \
    if (!_visited_) {                           \
      _visited_ = true;                         \
      { _once_something; }                      \
    }                                           \
  } while (0)                                   \
    //
//

#define every(_every_so_often_ms, _every_something_to_do) do {  \
    static unsigned long _every_next = 0;                       \
    unsigned long _every_now = millis();                        \
    if (_every_now >= _every_next) {                            \
      { _every_something_to_do; }                               \
      _every_next = _every_now + (_every_so_often_ms);          \
    }                                                           \
  } while (0)                                                   \
    //
//

void embedded_debug_catcher();
#define ll_debug_catcher embedded_debug_catcher()
//#define ll_debug_catcher ll_term.flush()

#define ll_try try
 
#define ll_catch(__code_before_rethrow__)                               \
  catch (Sexpr_t __err__) {                                             \
    if (__err__->type() != Cell::T_ERROR)                               \
      throw NIL->mk_error("ll_catch() BUG in %s bad type %s", me, __err__->dump().c_str()); \
                                                                        \
    global_printf("\r[%d] %s ll_catch(): %s\n", millis(), me, __err__->error_get_chars()); \
                                                                        \
    ll_debug_catcher;                                                   \
    __code_before_rethrow__;                                            \
    throw __err__;                                                      \
  }                                                                     \
  //
 
 
#endif