rocm-systems/ext-profiler/inspector/json.cc

#include "json.h"
#include <assert.h>
#include <math.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

const char* jsonErrorString(jsonResult_t res) {
  switch (res) {
  case jsonSuccess:
    return "jsonSuccess";
  case jsonFileError:
    return "jsonFileError";
  case jsonUnknownStateError:
    return "jsonUnknownStateError";
  case jsonEmptyStateError:
    return "jsonEmptyStateError";
  case jsonExpectedNonNoneStateError:
    return "jsonExpectedNonNoneStateError";
  case jsonMemoryError:
    return "jsonMemoryError";
  case jsonStringOverflowError:
    return "jsonStringOverflowError";
  case jsonStringBadChar:
    return "jsonStringBadChar";
  case jsonLockError:
    return "jsonLockError";
  default:
    return "unknown json error";
  }
}

// We use these statics to mantain a stack of states where we are writing.
typedef struct jsonFileOutput {
  jsonState_t* states;
  size_t state_cap; // Allocated stack capacity
  size_t state_n;   // # of items in the stack.
  FILE* fp;
  pthread_mutex_t mutex;
} jsonFileOutput;

jsonResult_t jsonInitFileOutput(jsonFileOutput** jfo, const char* outfile) {
  jsonFileOutput* new_jfo = (jsonFileOutput*)malloc(sizeof(jsonFileOutput));
  if (new_jfo == NULL) {
    return jsonMemoryError;
  }
  if (pthread_mutex_init(&new_jfo->mutex, NULL) != 0) {
    free(new_jfo);
    *jfo = 0;
    return jsonLockError;
  }
  new_jfo->states = NULL;
  new_jfo->state_cap = 0;
  new_jfo->state_n = 0;
  new_jfo->fp = fopen(outfile, "w");
  if (new_jfo->fp == NULL) {
    free(new_jfo);
    *jfo = 0;
    return jsonFileError;
  }
  *jfo = new_jfo;
  return jsonSuccess;
}

jsonResult_t jsonNewline(jsonFileOutput* jfo) {
  fprintf(jfo->fp, "\n");
  return jsonSuccess;
}

jsonResult_t jsonFlushOutput(jsonFileOutput* jfo) {
  fflush(jfo->fp);
  return jsonSuccess;
}

jsonResult_t jsonLockOutput(jsonFileOutput* jfo) {
  if (pthread_mutex_lock(&jfo->mutex) != 0) {
    return jsonLockError;
  }
  return jsonSuccess;
}

jsonResult_t jsonUnlockOutput(jsonFileOutput* jfo) {
  if (pthread_mutex_unlock(&jfo->mutex) != 0) {
    return jsonLockError;
  }
  return jsonSuccess;
}

jsonResult_t jsonFinalizeFileOutput(jsonFileOutput* jfo) {
  // Really should probably complain if we aren't in a valid state

  if (pthread_mutex_destroy(&jfo->mutex) != 0) {
    free(jfo);
    return jsonLockError;
  }
  if (jfo->states != NULL) {
    free(jfo->states);
  }
  jfo->states = NULL;
  jfo->state_cap = 0;
  jfo->state_n = 0;
  if (jfo->fp) {
    fclose(jfo->fp);
    jfo->fp = 0;
  }

  free(jfo);
  return jsonSuccess;
}

static int utf8copy(unsigned char* out, int out_lim, const unsigned char* in) {
  int copy_len;
  if ((in[0] & 0xE0) == 0xC0) {
    // 2-byte sequence
    if ((in[1] & 0xC0) != 0x80 || out_lim < 2) {
      return 0;
    }
    copy_len = 2;
  } else if ((in[0] & 0xF0) == 0xE0) {
    // 3-byte sequence
    if ((in[1] & 0xC0) != 0x80 || (in[2] & 0xC0) != 0x80 || out_lim < 3) {
      return 0;
    }
    copy_len = 3;
  } else if ((in[0] & 0xF8) == 0xF0) {
    // 4-byte sequence
    if ((in[1] & 0xC0) != 0x80 || (in[2] & 0xC0) != 0x80 || (in[3] & 0xC0) != 0x80 || out_lim < 4) {
      return 0;
    }
    copy_len = 4;
  } else {
    // Invalid start byte
    return 0;
  }

  for (int i = 0; i < copy_len; ++i) {
    out[i] = in[i];
  }

  return copy_len;
}

// This tries to sanitize/quote a string from 'in' into 'out',
// assuming 'out' has length 'lim'.  We mainly quote ",/,\,\t,\n, and
// bail if we encounter non-printable stuff or non-ASCII stuff.
// 'in' should be null-terminated, of course.
//
// We return false if we were not able to copy all of 'in', either for
// length reasons or for unhandled characters.
static jsonResult_t sanitizeJson(unsigned char out[], int lim, const unsigned char* in) {
  int c = 0;
  while (*in) {
    if (c + 1 >= lim) {
      out[c] = 0;
      return jsonStringOverflowError;
    }
    switch (*in) {
    case '"':
    case '\\':
    case '/':
    case '\t':
    case '\n':
      if (c + 2 > lim) {
        out[c] = 0;
        return jsonStringOverflowError;
      }

      out[c++] = '\\';
      if (*in == '\n') {
        out[c++] = 'n';
      } else if (*in == '\t') {
        out[c++] = 't';
      } else {
        out[c++] = *in;
      }
      ++in;
      break;
    default:
      if (*in <= 0x1F) {
        out[c] = 0;
        return jsonStringBadChar;
      } else if (*in <= 0x7F) {
        out[c++] = *in;
        ++in;
      } else {
        const int utf8len = utf8copy(out + c, lim - c - 1, in);
        if (utf8len == 0) {
          out[c] = 0;
          return jsonStringBadChar;
        }
        c += utf8len;
        in += utf8len;
      }
      break;
    }
  }
  out[c] = 0;
  return jsonSuccess;
}

static size_t max(size_t a, size_t b) {
  if (a < b) {
    return b;
  }
  return a;
}

// Push state onto the state stack. Reallocate for extra storage if needed.
// Because JSON_NONE is a pseudo-state, don't allow it to be pushed.
static jsonResult_t jsonPushState(jsonFileOutput* jfo, jsonState_t state) {
  if (state == JSON_NONE) {
    return jsonExpectedNonNoneStateError;
  }
  if (jfo->state_cap <= (jfo->state_n + 1)) {
    jfo->state_cap = max((size_t)16, jfo->state_cap * 2);
    jfo->states = (jsonState_t*)realloc(jfo->states, sizeof(jsonState_t) * jfo->state_cap);
    if (jfo->states == 0) {
      return jsonMemoryError;
    }
  }
  jfo->states[jfo->state_n++] = state;
  return jsonSuccess;
}

// Return the current state at the top of the stack
static jsonState_t jsonCurrState(const jsonFileOutput* jfo) {
  if (jfo->state_n == 0) {
    return JSON_NONE;
  }
  return jfo->states[jfo->state_n - 1];
}

// Replace the stack with state (equivalent to a pop & push if stack is not empty)
static jsonResult_t jsonReplaceState(jsonFileOutput* jfo, jsonState_t state) {
  if (state == JSON_NONE) {
    return jsonExpectedNonNoneStateError;
  }
  if (jfo->state_n == 0) {
    return jsonEmptyStateError;
  }
  jfo->states[jfo->state_n - 1] = state;
  return jsonSuccess;
}

// Pop the top state off the stack, or return that the state is empty
static jsonState_t jsonPopState(jsonFileOutput* jfo) {
  if (jfo->state_n == 0) {
    return JSON_NONE;
  }
  return jfo->states[--jfo->state_n];
}

// Emit a key and separator. Santize the key.
// This is only acceptable if the top state is an object
// Emit a ',' separator of we aren't the first item.
jsonResult_t jsonKey(jsonFileOutput* jfo, const char* name) {
  switch (jsonCurrState(jfo)) {
  case JSON_OBJECT_EMPTY:
    jsonReplaceState(jfo, JSON_OBJECT_SOME);
    break;
  case JSON_OBJECT_SOME:
    fprintf(jfo->fp, ",");
    break;
  default:
    return jsonUnknownStateError;
  }
  unsigned char tmp[2048];
  const jsonResult_t res = sanitizeJson(tmp, sizeof(tmp), (const unsigned char*)name);
  if (res != jsonSuccess) {
    return res;
  }
  fprintf(jfo->fp, "\"%s\":", tmp);
  jsonPushState(jfo, JSON_KEY);
  return jsonSuccess;
}

// Helper function for inserting values.
// Only acceptable after keys, top-level, or in lists.
// Emit preceeding ',' if in a list and not first item.
static jsonResult_t jsonValHelper(jsonFileOutput* jfo) {
  switch (jsonCurrState(jfo)) {
  case JSON_LIST_EMPTY:
    jsonReplaceState(jfo, JSON_LIST_SOME);
    break;
  case JSON_LIST_SOME:
    fprintf(jfo->fp, ",");
    break;
  case JSON_KEY:
    jsonPopState(jfo);
    break;
  case JSON_NONE:
    break;
  default:
    return jsonUnknownStateError;
  }
  return jsonSuccess;
}

// Start an object
jsonResult_t jsonStartObject(jsonFileOutput* jfo) {
  const jsonResult_t res = jsonValHelper(jfo);
  if (res != jsonSuccess) {
    return res;
  }
  fprintf(jfo->fp, "{");
  return jsonPushState(jfo, JSON_OBJECT_EMPTY);
}

// Close an object
jsonResult_t jsonFinishObject(jsonFileOutput* jfo) {
  switch (jsonPopState(jfo)) {
  case JSON_OBJECT_EMPTY:
  case JSON_OBJECT_SOME:
    break;
  default:
    return jsonUnknownStateError;
  }
  fprintf(jfo->fp, "}");
  return jsonSuccess;
}

// Start a list
jsonResult_t jsonStartList(jsonFileOutput* jfo) {
  const jsonResult_t res = jsonValHelper(jfo);
  if (res != jsonSuccess) {
    return res;
  }
  fprintf(jfo->fp, "[");
  return jsonPushState(jfo, JSON_LIST_EMPTY);
}

// Close a list
jsonResult_t jsonFinishList(jsonFileOutput* jfo) {
  switch (jsonPopState(jfo)) {
  case JSON_LIST_EMPTY:
  case JSON_LIST_SOME:
    break;
  default:
    return jsonUnknownStateError;
  }
  fprintf(jfo->fp, "]");
  return jsonSuccess;
}

// Write a null value
jsonResult_t jsonNull(jsonFileOutput* jfo) {
  const jsonResult_t res = jsonValHelper(jfo);
  if (res != jsonSuccess) {
    return res;
  }
  fprintf(jfo->fp, "null");
  return jsonSuccess;
}

// Write a (sanititzed) string
jsonResult_t jsonStr(jsonFileOutput* jfo, const char* str) {
  if (str == NULL) {
    jsonNull(jfo);
    return jsonSuccess;
  }
  const jsonResult_t res = jsonValHelper(jfo);
  if (res != jsonSuccess) {
    return res;
  }
  unsigned char tmp[2048];
  const jsonResult_t san_res = sanitizeJson(tmp, sizeof(tmp), (const unsigned char*)str);
  if (san_res != jsonSuccess) {
    return san_res;
  }
  fprintf(jfo->fp, "\"%s\"", tmp);
  return jsonSuccess;
}

// Write a bool as "true" or "false" strings.
jsonResult_t jsonBool(jsonFileOutput* jfo, bool val) {
  return jsonStr(jfo, val ? "true" : "false");
}

// Write an integer value
jsonResult_t jsonInt(jsonFileOutput* jfo, const int val) {
  const jsonResult_t res = jsonValHelper(jfo);
  if (res != jsonSuccess) {
    return res;
  }
  fprintf(jfo->fp, "%d", val);
  return jsonSuccess;
}

// Write an integer value
jsonResult_t jsonUint32(jsonFileOutput* jfo, const uint32_t val) {
  const jsonResult_t res = jsonValHelper(jfo);
  if (res != jsonSuccess) {
    return res;
  }
  fprintf(jfo->fp, "%u", val);
  return jsonSuccess;
}


// Write an integer value
jsonResult_t jsonUint64(jsonFileOutput* jfo, const uint64_t val) {
  const jsonResult_t res = jsonValHelper(jfo);
  if (res != jsonSuccess) {
    return res;
  }
  fprintf(jfo->fp, "%lu", val);
  return jsonSuccess;
}

// Write a size_t value
jsonResult_t jsonSize_t(jsonFileOutput* jfo, const size_t val) {
  const jsonResult_t res = jsonValHelper(jfo);
  if (res != jsonSuccess) {
    return res;
  }
  fprintf(jfo->fp, "%zu", val);
  return jsonSuccess;
}

// Write a double value
jsonResult_t jsonDouble(jsonFileOutput* jfo, const double val) {
  const jsonResult_t res = jsonValHelper(jfo);
  if (res != jsonSuccess) {
    return res;
  }
  if (val != val) {
    fprintf(jfo->fp, "\"nan\"");
  } else {
    fprintf(jfo->fp, "%lf", val);
  }
  return jsonSuccess;
}

#ifdef DO_JSON_TEST
// compile with
// gcc json.cc -Iinclude/ -DDO_JSON_TEST -o json_test
// run with:
// ./json_test
// if something fails, it will print out the error
// if it all works, print out "output matches reference"
#define JSONCHECK(expr)                                                                            \
  do {                                                                                             \
    const jsonResult_t res = (expr);                                                               \
    if (res != jsonSuccess) {                                                                      \
      fprintf(stderr, "jsonError: %s\n", jsonErrorString(res));                                    \
      exit(1);                                                                                     \
    }                                                                                              \
  } while (0)

int main() {

  const char refstr[] =
      "{\"number\":123,\"utfstring\":\"∮ E⋅da = Q,  n → ∞, ∑ f(i) = ∏ g(i), ∀x∈ℝ: ⌈x⌉ = −⌊−x⌋, α ∧ "
      "¬β = ¬(¬α ∨ β),\",\"list\":[\"true\",null,9423812381231,3123111,0.694234]}";

  jsonFileOutput* jfo;
  JSONCHECK(jsonInitFileOutput(&jfo, "test.json"));
  JSONCHECK(jsonStartObject(jfo));
  JSONCHECK(jsonKey(jfo, "number"));
  JSONCHECK(jsonInt(jfo, 123));
  JSONCHECK(jsonKey(jfo, "utfstring"));
  JSONCHECK(
      jsonStr(jfo, "∮ E⋅da = Q,  n → ∞, ∑ f(i) = ∏ g(i), ∀x∈ℝ: ⌈x⌉ = −⌊−x⌋, α ∧ ¬β = ¬(¬α ∨ β),"));
  JSONCHECK(jsonKey(jfo, "list"));
  JSONCHECK(jsonStartList(jfo));
  JSONCHECK(jsonBool(jfo, true));
  JSONCHECK(jsonNull(jfo));
  JSONCHECK(jsonUint64(jfo, 9423812381231ULL));
  JSONCHECK(jsonSize_t(jfo, 3123111));
  JSONCHECK(jsonDouble(jfo, 0.69423413));
  JSONCHECK(jsonFinishList(jfo));
  JSONCHECK(jsonFinishObject(jfo));
  JSONCHECK(jsonFinalizeFileOutput(jfo));

  FILE* fp = fopen("test.json", "r");

  const size_t reflen = sizeof(refstr) / sizeof(char);

  char buffer[reflen];

  fread(buffer, sizeof(char), reflen, fp);

  fclose(fp);

  if (memcmp(buffer, refstr, reflen) == 0) {
    printf("output matches reference\n");
  } else {
    printf("output    %s\nreference %s\n", buffer, refstr);
    return 1;
  }

  return 0;
}

#endif