Обработка структурированного текста

#include <stdio.h>
#include <stdlib.h>
#include <regex.h>
#include <stdbool.h>
#include <string.h>
 
#define BUFFER 30 // one word length
#define TOTAL 10000 // words amount
 
void cpystr(char *array1, char *array2){
  int i = 0;
  for (i = 0; i < array2[i] != '\0'; i++) {
    array1[i] = array2[i];
  }
  array1[i] = '\0';
}
 
bool opened_tag_checker(char current_tag[BUFFER]){
  regex_t temp;
  regmatch_t pmatch[1];
  regcomp(&temp, "^<[^/][^>/]*>$", REG_EXTENDED);
  if (regexec(&temp, current_tag, 1, pmatch , 0) == 0)
  {
    regfree(&temp);
    return true;
  }
  else{
    regfree(&temp);
    return false;
  }
}
 
bool closed_tag_checker(char current_tag[BUFFER]){
  regex_t temp;
  regmatch_t pmatch[1];
  regcomp(&temp, "^</[^>]*>$", REG_EXTENDED);
  if (regexec(&temp, current_tag, 1, pmatch , 0) == 0)
  {
    regfree(&temp);
    return true;
  }
  else{
    regfree(&temp);
    return false;
  }
}
 
bool no_end_tag_checker(char current_tag[BUFFER]){
  regex_t temp;
  regmatch_t pmatch[1];
  regcomp(&temp, "^<[^/][^>]*/>$", REG_EXTENDED);
  if (regexec(&temp, current_tag, 1, pmatch , 0) == 0)
  {
    regfree(&temp);
    return true;
  }
  else{
    regfree(&temp);
    return false;
  }
}
 
bool find_tag(char input[TOTAL], int *start, int *end){
  regex_t temp;
  regmatch_t pmatch[1];
  regcomp(&temp, "</?[^>]*/?>", REG_EXTENDED);
  if (regexec(&temp, input, 1, pmatch , 0) == 0)
  {
    *start = pmatch[0].rm_so;
    *end = pmatch[0].rm_eo-1;
    regfree(&temp);
    return true;
  }
  else{
    regfree(&temp);
    return false;
  }
}
 
void pop_substring(char *array1, char *array2, int start, int end){
  int temp_i = 0;
  for (int i = start; i < end+1; i++) {
    array1[temp_i] = array2[i];
    temp_i++;
  }
  array1[temp_i] = '\0';
  memmove(&array2[start], &array2[end + 1], strlen(array2) - start);
}
void get_tag_name(char *tag, char *tag_name){
  int size = 0;
  for (int i = 1; i < strlen(tag) - 1; i++) {
    if (tag[i] != '/') {
        tag_name[size] = tag[i];
        size++;
    }
  }
  tag_name[size] = '\0';
}
 
void get_tag_name_par(char *tag, char *tag_name){
  int size = 0;
  for (int i = 1; i < strlen(tag) - 1; i++) {
    if (i == 1 && tag[i] == '/') {}else{
      if (tag[i] == ' ') {
        break;
      }
      tag_name[size] = tag[i];
      size++;
    }
  }
  tag_name[size] = '\0';
}
 
 
void get_parameter_value(char char_value[BUFFER], char current_tag[BUFFER]){
  int start, end = 0;
  regex_t temp;
  regmatch_t pmatch[1];
  regcomp(&temp, "="[^"]*"", REG_EXTENDED);
  if (regexec(&temp, current_tag, 1, pmatch , 0) == 0)
  {
    start = pmatch[0].rm_so+2;
    end = pmatch[0].rm_eo-1;
    int size = 0;
    for (int i = start; i < end; i++) {
      char_value[size] = current_tag[i];
      size++;
    }
    char_value[size] = '\0';
    regfree(&temp);
  }
}
 
bool find_parameters(char current_tag[BUFFER], int *start, int *end){
  regex_t temp;
  regmatch_t pmatch[1];
  regcomp(&temp, " [^=]*="[^"]*"", REG_EXTENDED);
  if (regexec(&temp, current_tag, 1, pmatch , 0) == 0)
  {
    *start = pmatch[0].rm_so+1;
    *end = pmatch[0].rm_eo-1;
    regfree(&temp);
    return true;
  }
  else{
    regfree(&temp);
    return false;
  }
}
 
bool compair_tags(char *tag1, char *tag2){
  char tag1_name[BUFFER];
  get_tag_name(tag1, tag1_name);
  char tag2_name[BUFFER];
  get_tag_name(tag2, tag2_name);
  if (strcmp(tag1_name, tag2_name) == 0) {
    return true;
  }
  return false;
}
 
struct Variables{
  char var_name[TOTAL][BUFFER];
  int var_value[100];
  int var_count;
};
 
void load_file(char *array)
{
  char c;
  int size = 0;
  while (EOF != (c = fgetc(stdin))) {
    array[size] = c;
    size++;
  }
  array[size] = '\0';
}
int main(){
  char input[TOTAL];
  char tags_array[TOTAL][BUFFER];
  int start = 0;
  int end = 0;
  int size = 0;
  int tags_counter = 0;
  char stack[TOTAL][BUFFER];
  load_file(input);
  while (find_tag(input, &start, &end)) {
    pop_substring(tags_array[size], input, start, end);
    size++;
  }
  int stack_size = 0;
  struct Variables Variable;
  Variable.var_count = 0;
  for (int i = 0; i < size; i++) {
    char *current_tag = tags_array[i];
    if (no_end_tag_checker(current_tag)) {
      tags_counter++;
 
      if (find_parameters(current_tag, &start, &end)){
        char tag_name[BUFFER];
        get_tag_name_par(current_tag, tag_name);
 
        if (strcmp(tag_name, "add") == 0){
          char value[BUFFER];
          get_parameter_value(value, current_tag);
          Variable.var_value[Variable.var_count] += atoi(value);
        }else if(strcmp(tag_name, "sub") == 0){
          char value[BUFFER];
          get_parameter_value(value, current_tag);
          Variable.var_value[Variable.var_count] -= atoi(value);
        }
      }
    }
    if (opened_tag_checker(current_tag)) {
      cpystr(stack[stack_size], current_tag);
      stack_size++;
      tags_counter++;
 
      if (find_parameters(current_tag, &start, &end)){
        char tag_name[BUFFER];
        get_tag_name_par(current_tag, tag_name);
 
        if (strcmp(tag_name, "equation") == 0){
          char value[BUFFER];
          get_parameter_value(value, current_tag);
          cpystr(Variable.var_name[Variable.var_count], value);
          Variable.var_value[Variable.var_count] = 0;
        }
      }
    }
    if (closed_tag_checker(current_tag)){
      char temp[BUFFER];
      stack_size--;
      if (find_parameters(stack[stack_size], &start, &end)){
        pop_substring(temp, stack[stack_size], 0, start-1);
      }else{
        pop_substring(temp, stack[stack_size], 0, strlen(stack[stack_size])-1);
      }
      if (compair_tags(current_tag, temp) != true) {
        printf("текст валидный\n");
        return 100;
      }else{
        if (strcmp(temp, "<equation ") == 0){
          Variable.var_count++;
        }
      }
    }
  }
  if (stack_size != 0){
    printf("текст валидный\n");
    return 100;
  }
  for (int i = 0; i < Variable.var_count; i++) {
    printf("%s=%d\n", Variable.var_name[i], Variable.var_value[i]);
  }
  printf("количество тегов: %d\n", tags_counter);
  printf("текст валидный\n");
  return 0;
}