mst.c

#include "mst.h"
#include <ctype.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
PRIVATE int parser_space(MST_Object* mst, int idx, SPACE* space, int mode);
PRIVATE int parser_array(MST_Object* mst, int idx, Array* arr);
/// 放置一个token到token链表中
/// \param buf token名称
/// \param t 标记的类型
/// \param mst miniset对象
PRIVATE void put_token(char* buf, TOKEN_TYPE t, MST_Object* mst) {
  TOKEN* tok = malloc(sizeof(TOKEN));
  tok->t = t;
  tok->tok = buf;
  list_add_val((uintptr_t) tok, mst->token);
}
/// 找到最近的空格或缩进
/// \param buf 文本
/// \return 下一个空格或缩进的起始地址
PRIVATE char* __next(char* buf) {
  char *x, *y;
  x = strchr(buf, ' ');   // 找到最近的空格
  y = strchr(buf, '\t');  // 找到最近的缩进
  /*
    如果x、y都不为零，那就取小的那个
    如果x、y都为0，那就返回0
    若是x、y其中一个为0，那就返回不为0的那个
  */
  return x < y ? (x != 0 ? x : y) : (y != 0 ? y : x);
}
/// 在上面函数的基础上找到最近的空格或缩进或换行
/// \param buf
/// \return
PRIVATE char* _next(char* buf) {
  if (buf[0] == '#') {  // 是注释，我们不用做任何事情
    return buf;         // do nothing
  }
  char *x, *y;
  /* 下一个token的分隔符是\n还是空格或缩进，因此执行一遍__next函数*/
  x = __next(buf);
  y = strchr(buf, '\n');
  return x < y ? (x != 0 ? x : y) : (y != 0 ? y : x);
}
/// 在上面的基础上跳过注释
/// \param buf
/// \return
PRIVATE char* next1(char* buf) {
  char* p = _next(buf);
  if (!(p))
    return 0;
  while (p[0] == '#') {  // 跳过注释，下面的代码执行后，p指针就会指向下一行，因此，只要下一行不是注释，就可以退出循环了
    p = strchr(p, '\n');  // 下一行
    if (p) {
      p++;  // 此时*p是'\n'我们需要跳过一格，然后才是下一行的起始位置
      if (!(*p)) {  // 遇到了字符串结束符，也相当于没有token了，返回0
        return 0;
      }
    } else {
      return 0;
    }
  }
  while (*p == ' ' || *p == '\t' || *p == '\n') {  // 找到有字符的地方
    p++;
  }
  if (*p) {                // 如果字符串没到结尾
    while (p[0] == '#') {  // 继续跳过注释
      p = strchr(p, '\n');
      if (p) {
        p++;
        if (!(*p)) {
          return 0;
        }
      } else {
        return 0;
      }
    }
    while ((*p == ' ' || *p == '\t' || *p == '\n') && *p) {  // 继续跳过没字符的地方，于是我们就到了下一个有字符的地方
      p++;
    }
    return *p ? p : 0;
  } else
    return 0;
}
/// 在上面的基础上处理其他情况的注释
/// \param buf
/// \return
PRIVATE char* next(char* buf) {
  char* p = next1(buf);  // 其实上面注释什么的还没有处理完，所以现在我们进行下一步处理
  // next1函数处理的是注释符号在行的开头的情况，我们现在要处理注释和正常字符混合在一起的情况
  if (!p) {  // 上一步都没返回成功，直接0了
    return 0;
  }
  char* p1 = p;
  int fg = 0;  // 字符串标识符，这里是为了防止字符串里的注释也被误判
  int start = 1;
  while (((*p != '#' && fg) && *p != ' ' && *p) || start) {
    if (*p == '\"') {
      fg = !fg;
    }
    p++;
    start = 0;
  }
  // 此时p代表的就是下一个注释的起始位置
  if (*p != '#') {  // 没有注释？直接返回了
    return p1;
  } else {
    while (*p != '\n' && *p != '\0') {  // 把这个注释删了
      *p = ' ';
      p++;
    }
    return p1;
  }
}
/// 从next返回的token中获取有效字符串
/// \param text 需要进行解析的文本
/// \param p 解析完某个有效字符串之后，接下来的文本的起始地址（二级指针）
/// \return 有效字符串的地址（使用完成需要进行free）
PRIVATE char* get_str(char* text,char** p) {
  assert(text && p);
  size_t len = 0;
  char* src = text;
  char* result;
  int flag_str = 0;   // 字符串标识
  int flag_str1 = 0;  // 字符串内转义字符标识
  int flag_op = 0;    // 数组标识
  // 截取真正字符串的内容，并将其放到len变量里面
  while (*text) {
    len++; // 内容有一个字符就加1
    if (!flag_str &&  *text == '[') {  // 不在字符串内并且是数组的开始，设置flag_op标识(+1 代表嵌套的层数)
      flag_op++;
    }
    if (!flag_str && *text == ']') {  // 不在字符串内并且是数组的结束，结束flag_op标识（-1 少一个嵌套的层数）
      if (!flag_op) {  // 只有闭合，没有开始，报错
        return NULL;
      }
      flag_op--;
    }
    /* 处理字符串 */
    if (!flag_op) { // 如果不是数组就处理字符串
      if (*text == '\\') { // 转义字符
        flag_str1 = !flag_str1;
      } else if (flag_str1) {
        flag_str1 = 0;
      } else {
        if (*text == '\"') { // 如果这里之前有过转义字符，例如："\""，在碰到反斜杠后面的这个双引号的时候就不会将flag_str设置
          flag_str = !flag_str;
        }
      }
    }
    if (*text == '#' || *text == ' ' || *text == '\n') { // 遇到注释，空格（分隔符），换行符
      if (flag_str == 0 && flag_op == 0) { // 不在任何一个有效内容范围内
        break;
      }
    }
    text++;
  }
  if (flag_op + flag_str1 + flag_str != 0) { // 即判断这三个变量是不是为0，如果不是 说明出问题了
    return NULL;
  }
  // 拷贝
  result = (char*)malloc(len + 1);
  assert(result);
  result[len] = 0;
  memcpy(result, src, len);
  *p = text;
  return result;
}
/// 获取一个字符串变量的长度，s的格式："\"%s\""
/// \param s
/// \return 描述中%s这个占位符的长度
PRIVATE size_t token_strlen(char* s) {
  size_t result = 0; // 返回值记录
  int flag = 0; // 是否有转义字符
  if (*s != '\"') { // 不是一个有效的字符串
    return 0;
  }
  s++; // 跳过第一个双引号
  while (*s) {
    /* 处理转义字符 */
    if (*s == '\\') flag = !flag;
    else if (flag) flag = 0;
    else if(*s == '\"') break;
    result++;
    s++;
  }
  return result;
}
/// 将一个格式为"%s"的字符串放置到token链表中
/// \param p1 字符串
/// \param mst miniset对象
/// \return 成功返回长度，失败返回0
PRIVATE int token_put_string(char* p1, MST_Object* mst) {
  if(p1[0] != '\"') // 不是一个有效的字符串
    return 0;
  char* result;
  result = malloc(token_strlen(p1) + 1); // 先获取长度
  TOKEN_TYPE tt;
  size_t length = strlen(p1); // 然后获取总长度
  int flag = 0;
  tt = TK_STRING; // 设置token type
  int j = 0;
  for (int i = 1; i < length; i++) {
    if (p1[i] == '\"' && !flag) {
      break;
    }
    // 处理转义字符
    if (flag) {
      flag = 0;
    }
    if (p1[i] == '\\') {
      flag = 1;
    }
    // 装入result
    result[j++] = p1[i];
  }
  result[j] = 0;
  // 一切准备就绪，调用put_token，放置token到链表
  put_token(result, tt, mst);
  return j + 1;
}
/// 将数字token放入链表
/// \param p1
/// \param mst
/// \return 放置token的长度
PRIVATE int token_put_integer(char* p1, MST_Object* mst) {
  char* result;
  result = malloc(strlen(p1) + 1);
  size_t length = strlen(p1);
  int j = 0;
  if (p1[0] == '-') { // 因为下面调用了isdigit 所以这里要避开
    result[j++] = p1[0];
    p1++;
    length--;
  }
  for (int i = 0; i < length; i++) {
    // 只拷贝是数字的
    if (isdigit(p1[i])) {
      result[j++] = p1[i];
    } else {
      break;
    }
  }
  result[j] = 0;
  put_token(result, TK_NUMBER, mst);
  return j - 1;
}
/// 放入一个文本，判断类型并放置进token链表
/// \param p1
/// \param mst
PRIVATE void auto_put_token(char* p1, MST_Object* mst) {
  size_t length = strlen(p1); // 先获取长度
  for (int i = 0; i < length; i++) {
    switch (p1[i]) { // 然后我们一个个判断
      // token put .......函数返回的都是长度，所以i+....就是代表往后移动多少个字符
      case '\"':
        // 这里之所以能肯定字符串一定有效，是因为前面lexer过程已经帮我们过滤过了
        i = i + token_put_string(p1 + i, mst); // 把字符串扔进去
        break;
      case '[': { // 数组开头
        char* r = malloc(2);
        r[1] = 0;
        r[0] = '[';
        put_token(r, TK_ARRAY_START, mst);
        break;
      }
      case ']': { // 数组结尾
        char* r = malloc(2);
        r[1] = 0;
        r[0] = ']';
        put_token(r, TK_ARRAY_END, mst);
        break;
      }
      case '{': { // SPACE开头
        char* r = malloc(2);
        r[1] = 0;
        r[0] = '{';
        put_token(r, TK_SPACE_START, mst);
        break;
      }
      case '}': { // SPACE结尾
        char* r = malloc(2);
        r[1] = 0;
        r[0] = '}';
        put_token(r, TK_SPACE_END, mst);
        break;
      }
      case '=': {
        char* r = malloc(2);
        r[1] = 0;
        r[0] = '=';
        put_token(r, TK_OP, mst);
        break;
      }
      // 这些都可以是有效分隔符
      case ' ':
      case '\r':
      case '\n':
      case ',':
      case '\t':
        break;
      default: {
        if (isdigit(p1[i]) || p1[i] == '-') {
          i = i + token_put_integer(p1 + i, mst);
        } else {
          mst->err = UNKNOW_TOKEN;
          return;
        }
        break;
      }
    }
  }
}
PRIVATE void Mst_lexer(char* buffer, MST_Object* mst) {
  char* start = buffer;
  char* p = start;
  while (p) {
    if (p[0] != '#') { // 如果是注释就直接跳过
      char* p1 = get_str(p, &p);
      if (!p1) {
        mst->err = STRING_OP_ERROR;
        return;
      }
      auto_put_token(p1, mst);
      free(p1);
      if (mst->err) {
        return;
      }
    }
    p = next(p);  // next
  }
}
PRIVATE void process_token(MST_Object* mobj) {
  TOKEN* t_bmp[2];
  int idx = 0;
  for (int i = 1; list_search_by_count(i, mobj->token) != NULL; i++) {
    TOKEN* t = (TOKEN*) list_search_by_count(i, mobj->token)->val;
    t_bmp[idx] = t;
    if (idx) {
      if (t_bmp[0]->t == TK_STRING &&
          (t_bmp[1]->t == TK_OP && t_bmp[1]->tok[0] == '=')) {
        t_bmp[0]->t = TK_WORD;
      } else if (t_bmp[1]->t == TK_STRING) {
        t_bmp[0] = t_bmp[1];
        idx = 0;
      }
    }
    idx = !idx;
  }
}
PRIVATE int parser_array(MST_Object* mst, int idx, Array* arr) {
  int i = idx;
  for (; list_search_by_count(i, mst->token) != NULL; i++) {
    TOKEN* t = (TOKEN*) list_search_by_count(i, mst->token)->val;
    if (t->t == TK_ARRAY_END) {
      break;
    }
    if (t->t == TK_SPACE_START) {
      //     printf("Array:Found a SPACE\n");
      Array_data* v = (Array_data*)malloc(sizeof(Array_data));
      v->vt = VAR_SPACE;
      v->obj = (SPACE*)malloc(sizeof(Array));
      SPACE* sp = (SPACE*)v->obj;
      sp->the_space = list_new();
      i = parser_space(mst, i + 1, sp, 0);
      if (i == -1) {
        free_space(sp);
        list_delete(sp->the_space);
        free(v->obj);
        free(v);
        return -1;
      }
      v->this_list = list_add_val((uintptr_t) v, arr->the_array);
    } else if (t->t == TK_ARRAY_START) {
      Array_data* v = (Array_data*)malloc(sizeof(Array_data));
      v->vt = VAR_ARRAY;
      v->obj = (Array*)malloc(sizeof(Array));
      Array* arr1 = (Array*)v->obj;
      arr1->the_array = list_new();
      i = parser_array(mst, i + 1, arr1);
      if (i == -1) {
        free_arr(arr1);
        list_delete(arr1->the_array);
        free(v->obj);
        free(v);
        return -1;
      }
      v->this_list = list_add_val((uintptr_t) v, arr->the_array);
    } else if (t->t == VAR_INTEGER) {
      Array_data* v = (Array_data*)malloc(sizeof(Array_data));
      v->vt = VAR_INTEGER;
      v->obj = (Integer*)malloc(sizeof(Integer));
      Integer* number = (Integer*)v->obj;
      number->num = strtol(t->tok, NULL, 10);
      v->this_list = list_add_val((uintptr_t) v, arr->the_array);
    } else if (t->t == TK_STRING) {
      Array_data* v = (Array_data*)malloc(sizeof(Array_data));
      v->vt = VAR_STRING;
      v->obj = (String*)malloc(sizeof(String));
      String* str = (String*)v->obj;
      str->str = t->tok;
      v->this_list = list_add_val((uintptr_t) v, arr->the_array);
    } else {
      mst->err = ERROR_TOKEN;
      return -1;
    }
  }
  return i;
}
PUBLIC void free_arr(Array* arr) {
  int i = 1;
  for (; list_search_by_count(i, arr->the_array) != NULL; i++) {
    Array_data* v = (Array_data*) list_search_by_count(i, arr->the_array)->val;
    switch (v->vt) {
      case VAR_INTEGER:
        free(v->obj);
        break;
      case VAR_STRING:
        free(v->obj);
        break;
      case VAR_SPACE:
        free_space((SPACE*)v->obj);
        list_delete(((SPACE *) v->obj)->the_space);
        free(v->obj);
        break;
      case VAR_ARRAY:
        free_arr((Array*)v->obj);
        list_delete(((Array *) v->obj)->the_array);
        free(v->obj);
        break;
      default:
        break;
    }
    free(v);
  }
}
PUBLIC void free_space(SPACE* space) {
  int i = 1;
  if (!space) {
    return;
  }
  for (; list_search_by_count(i, space->the_space) != NULL; i++) {
    Var* v = (Var*) list_search_by_count(i, space->the_space)->val;
    switch (v->vt) {
      case VAR_INTEGER:
        free(v->obj);
        break;
      case VAR_STRING:
        free(v->obj);
        break;
      case VAR_SPACE:
        free_space((SPACE*)v->obj);
        list_delete(((SPACE *) v->obj)->the_space);
        free(v->obj);
        break;
      case VAR_ARRAY:
        free_arr((Array*)v->obj);
        list_delete(((Array *) v->obj)->the_array);
        free(v->obj);
        break;
      default:
        break;
    }
    free(v);
  }
}
PRIVATE int parser_space(MST_Object* mst, int idx, SPACE* space, int mode) {
  int i = idx;
  int flag = 0;
  for (; list_search_by_count(i, mst->token) != NULL; i++) {
    TOKEN* t = (TOKEN*) list_search_by_count(i, mst->token)->val;
    if (!mode && t->t == TK_SPACE_END) {
      flag = 1;
      break;
    }
    if (t->t == TK_WORD) {
      Var* v = (Var*)malloc(sizeof(Var));
      assert(v);
      v->name = t->tok;
      List* tk_list1 = list_search_by_count(i + 1, mst->token);
      if (!tk_list1) {
        mst->err = SYNTAX_ERROR;
        return -1;
      }
      TOKEN* t2 = (TOKEN*)tk_list1->val;
      if (t2->t != TK_OP) {
        free(v);
        mst->err = SYNTAX_ERROR;
        return -1;
      }
      List* tk_list2 = list_search_by_count(i + 2, mst->token);
      if (!tk_list2) {
        mst->err = SYNTAX_ERROR;
        return -1;
      }
      TOKEN* t1 = (TOKEN*)tk_list2->val;
      if (t1->t == TK_SPACE_START) {
        v->vt = VAR_SPACE;
        v->obj = (SPACE*)malloc(sizeof(SPACE));
        SPACE* sp = (SPACE*)v->obj;
        sp->the_space = list_new();
        i = parser_space(mst, i + 3, sp, 0);
        if (i == -1) {
          free_space(sp);
          list_delete(sp->the_space);
          free(v->obj);
          free(v);
          return -1;
        }
        // i += 2;
      } else if (t1->t == TK_ARRAY_START) {
        v->vt = VAR_ARRAY;
        v->obj = (Array*)malloc(sizeof(Array));
        Array* arr = (Array*)v->obj;
        arr->the_array = list_new();
        i = parser_array(mst, i + 3, arr);
        if (i == -1) {
          free_arr(arr);
          list_delete(arr->the_array);
          free(v->obj);
          free(v);
          return -1;
        }
      } else if (t1->t == VAR_INTEGER) {
        v->vt = VAR_INTEGER;
        v->obj = (Integer*)malloc(sizeof(Integer));
        Integer* number = (Integer*)v->obj;
        number->num = strtol(t1->tok, NULL, 10);
        i += 2;
      } else if (t1->t == TK_STRING) {
        v->vt = VAR_STRING;
        v->obj = (String*)malloc(sizeof(String));
        String* str = (String*)v->obj;
        str->str = t1->tok;
        i += 2;
      }
      v->this_list = list_add_val((uintptr_t) v, space->the_space);
    } else {
      mst->err = SYNTAX_ERROR;
      return -1;
    }
  }
  if (!flag && space != MST_get_root_space(mst)) {
    // printf("fatal error: Couldn't find the end of opcode\n");
    // exit(-1);
    mst->err = SYNTAX_ERROR;
    return -1;
  }
  return i;
}
PUBLIC MST_API MST_Object* MST_init(char* string) {
  MST_Object* result = (MST_Object*)malloc(sizeof(MST_Object));
  result->string = malloc(strlen(string) + 1);
  result->err = 0;
  result->root_space = NULL;
  strcpy(result->string, string);
  result->token = list_new();
  Mst_lexer(result->string, result);
  if (!result->err) {
    process_token(result);
    result->root_space = (SPACE*)malloc(sizeof(SPACE));
    result->root_space->the_space = list_new();
    // printf("%08x\n",result->root_space->the_space);
    parser_space(result, 1, result->root_space, 1);
  }
  return result;
}
PUBLIC MST_API Var* MST_get_var(char* name, SPACE* space) {
  for (int i = 1; list_search_by_count(i, space->the_space) != NULL; i++) {
    Var* sp = (Var*) list_search_by_count(i, space->the_space)->val;
    if (strcmp(name, sp->name) == 0) {
      return sp;
    }
  }
  return NULL;
}
PUBLIC MST_API int MST_space_get_integer(Var* var) {
  if (var->vt != VAR_INTEGER) {
    return -1;
  }
  Integer* n = (Integer*)var->obj;
  assert(n);
  return n->num;
}
PUBLIC MST_API SPACE* MST_space_get_space(Var* var) {
  if (var->vt != VAR_SPACE) {
    return NULL;
  }
  SPACE* n = (SPACE*)var->obj;
  return n;
}
PUBLIC MST_API Array* MST_space_get_array(Var* var) {
  if (var->vt != VAR_ARRAY) {
    return NULL;
  }
  Array* n = (Array*)var->obj;
  return n;
}
PUBLIC MST_API char* MST_space_get_str(Var* var) {
  if (var->vt != VAR_STRING) {
    return NULL;
  }
  String* n = (String*)var->obj;
  return n->str;
}
PUBLIC MST_API Array_data* MST_array_get_data(Array* arr, int idx) {
  if (list_search_by_count(idx + 1, arr->the_array) == NULL) {
    return NULL;
  }
  return (Array_data*) list_search_by_count(idx + 1, arr->the_array)->val;
}
PUBLIC MST_API int MST_array_get_integer(Array_data* ad) {
  if (ad->vt != VAR_INTEGER) {
    return -1;
  }
  Integer* n = (Integer*)ad->obj;
  return n->num;
}
PUBLIC MST_API char* MST_array_get_str(Array_data* ad) {
  if (ad->vt != VAR_STRING) {
    return NULL;
  }
  String* n = (String*)ad->obj;
  return n->str;
}
PUBLIC MST_API SPACE* MST_array_get_space(Array_data* ad) {
  if (ad->vt != VAR_SPACE) {
    return NULL;
  }
  SPACE* n = (SPACE*)ad->obj;
  return n;
}
PUBLIC MST_API Array* MST_array_get_array(Array_data* ad) {
  if (ad->vt != VAR_ARRAY) {
    return NULL;
  }
  Array* n = (Array*)ad->obj;
  return n;
}
PUBLIC MST_API void MST_free(MST_Object* mst) {
  free(mst->string);
  for (int i = 1; list_search_by_count(i, mst->token) != NULL; i++) {
    TOKEN* t = (TOKEN*) list_search_by_count(i, mst->token)->val;
    free(t->tok);
    free(t);
  }
  list_delete(mst->token);

  if (mst->root_space) {
    free_space(mst->root_space);
    list_delete(mst->root_space->the_space);
    free(mst->root_space);
  }
  free(mst);
#if MEM_LEAK_CHECK
  stb_leakcheck_dumpmem();
#endif
}
PUBLIC MST_API const char* MST_strerror(MST_Object* mst) {
  switch (mst->err) {
    case STRING_OP_ERROR:
      return "fatal error: string not closed or operator error";
    case UNKNOW_TOKEN:
      return "fatal error: An unknown token was detected.";
    case ERROR_TOKEN:
      return "fatal error: The token contained an error.";
    case SYNTAX_ERROR:
      return "fatal error: A syntax error has occurred.";
    default:
      return "(null)";
  }
}