Cleanup: style, use braces for blenkernel
[blender.git] / source / blender / blenkernel / intern / text.c
index 3ce60b6..9047aa5 100644 (file)
@@ -17,7 +17,8 @@
  * All rights reserved.
  */
 
-/** \file \ingroup bke
+/** \file
+ * \ingroup bke
  */
 
 #include <stdlib.h> /* abort */
@@ -52,9 +53,8 @@
 #include "BKE_text.h"
 #include "BKE_node.h"
 
-
 #ifdef WITH_PYTHON
-#include "BPY_extern.h"
+#  include "BPY_extern.h"
 #endif
 
 /*
  * undo position
  */
 
-
 /* Undo opcodes */
 
 enum {
-       /* Complex editing */
-       /* 1 - opcode is followed by 1 byte for ascii character and opcode (repeat)) */
-       /* 2 - opcode is followed by 2 bytes for utf-8 character and opcode (repeat)) */
-       /* 3 - opcode is followed by 3 bytes for utf-8 character and opcode (repeat)) */
-       /* 4 - opcode is followed by 4 bytes for unicode character and opcode (repeat)) */
-       UNDO_INSERT_1   = 013,
-       UNDO_INSERT_2   = 014,
-       UNDO_INSERT_3   = 015,
-       UNDO_INSERT_4   = 016,
-
-       UNDO_BS_1       = 017,
-       UNDO_BS_2       = 020,
-       UNDO_BS_3       = 021,
-       UNDO_BS_4       = 022,
-
-       UNDO_DEL_1      = 023,
-       UNDO_DEL_2      = 024,
-       UNDO_DEL_3      = 025,
-       UNDO_DEL_4      = 026,
-
-       /* Text block (opcode is followed
-        * by 4 character length ID + the text
-        * block itself + the 4 character length
-        * ID (repeat) and opcode (repeat)) */
-       UNDO_DBLOCK     = 027, /* Delete block */
-       UNDO_IBLOCK     = 030, /* Insert block */
-
-       /* Misc */
-       UNDO_INDENT     = 032,
-       UNDO_UNINDENT   = 033,
-       UNDO_COMMENT    = 034,
-       UNDO_UNCOMMENT  = 035,
-
-       UNDO_MOVE_LINES_UP      = 036,
-       UNDO_MOVE_LINES_DOWN    = 037,
-
-       UNDO_DUPLICATE  = 040,
+  /* Complex editing */
+  /* 1 - opcode is followed by 1 byte for ascii character and opcode (repeat)) */
+  /* 2 - opcode is followed by 2 bytes for utf-8 character and opcode (repeat)) */
+  /* 3 - opcode is followed by 3 bytes for utf-8 character and opcode (repeat)) */
+  /* 4 - opcode is followed by 4 bytes for unicode character and opcode (repeat)) */
+  UNDO_INSERT_1 = 013,
+  UNDO_INSERT_2 = 014,
+  UNDO_INSERT_3 = 015,
+  UNDO_INSERT_4 = 016,
+
+  UNDO_BS_1 = 017,
+  UNDO_BS_2 = 020,
+  UNDO_BS_3 = 021,
+  UNDO_BS_4 = 022,
+
+  UNDO_DEL_1 = 023,
+  UNDO_DEL_2 = 024,
+  UNDO_DEL_3 = 025,
+  UNDO_DEL_4 = 026,
+
+  /* Text block (opcode is followed
+   * by 4 character length ID + the text
+   * block itself + the 4 character length
+   * ID (repeat) and opcode (repeat)) */
+  UNDO_DBLOCK = 027, /* Delete block */
+  UNDO_IBLOCK = 030, /* Insert block */
+
+  /* Misc */
+  UNDO_INDENT = 032,
+  UNDO_UNINDENT = 033,
+  UNDO_COMMENT = 034,
+  UNDO_UNCOMMENT = 035,
+
+  UNDO_MOVE_LINES_UP = 036,
+  UNDO_MOVE_LINES_DOWN = 037,
+
+  UNDO_DUPLICATE = 040,
 };
 
 /***/
@@ -173,116 +172,118 @@ static bool undoing;
  */
 void BKE_text_free_lines(Text *text)
 {
-       for (TextLine *tmp = text->lines.first, *tmp_next; tmp; tmp = tmp_next) {
-               tmp_next = tmp->next;
-               MEM_freeN(tmp->line);
-               if (tmp->format) {
-                       MEM_freeN(tmp->format);
-               }
-               MEM_freeN(tmp);
-       }
+  for (TextLine *tmp = text->lines.first, *tmp_next; tmp; tmp = tmp_next) {
+    tmp_next = tmp->next;
+    MEM_freeN(tmp->line);
+    if (tmp->format) {
+      MEM_freeN(tmp->format);
+    }
+    MEM_freeN(tmp);
+  }
 
-       BLI_listbase_clear(&text->lines);
+  BLI_listbase_clear(&text->lines);
 
-       text->curl = text->sell = NULL;
+  text->curl = text->sell = NULL;
 }
 
 /** Free (or release) any data used by this text (does not free the text itself). */
 void BKE_text_free(Text *text)
 {
-       /* No animdata here. */
+  /* No animdata here. */
 
-       BKE_text_free_lines(text);
+  BKE_text_free_lines(text);
 
-       MEM_SAFE_FREE(text->name);
+  MEM_SAFE_FREE(text->name);
 #ifdef WITH_PYTHON
-       BPY_text_free_code(text);
+  BPY_text_free_code(text);
 #endif
 }
 
 void BKE_text_init(Text *ta)
 {
-       TextLine *tmp;
+  TextLine *tmp;
 
-       BLI_assert(MEMCMP_STRUCT_OFS_IS_ZERO(ta, id));
+  BLI_assert(MEMCMP_STRUCT_AFTER_IS_ZERO(ta, id));
 
-       ta->name = NULL;
+  ta->name = NULL;
 
-       ta->nlines = 1;
-       ta->flags = TXT_ISDIRTY | TXT_ISMEM;
-       if ((U.flag & USER_TXT_TABSTOSPACES_DISABLE) == 0)
-               ta->flags |= TXT_TABSTOSPACES;
+  ta->nlines = 1;
+  ta->flags = TXT_ISDIRTY | TXT_ISMEM;
+  if ((U.flag & USER_TXT_TABSTOSPACES_DISABLE) == 0) {
+    ta->flags |= TXT_TABSTOSPACES;
+  }
 
-       BLI_listbase_clear(&ta->lines);
+  BLI_listbase_clear(&ta->lines);
 
-       tmp = (TextLine *) MEM_mallocN(sizeof(TextLine), "textline");
-       tmp->line = (char *) MEM_mallocN(1, "textline_string");
-       tmp->format = NULL;
+  tmp = (TextLine *)MEM_mallocN(sizeof(TextLine), "textline");
+  tmp->line = (char *)MEM_mallocN(1, "textline_string");
+  tmp->format = NULL;
 
-       tmp->line[0] = 0;
-       tmp->len = 0;
+  tmp->line[0] = 0;
+  tmp->len = 0;
 
-       tmp->next = NULL;
-       tmp->prev = NULL;
+  tmp->next = NULL;
+  tmp->prev = NULL;
 
-       BLI_addhead(&ta->lines, tmp);
+  BLI_addhead(&ta->lines, tmp);
 
-       ta->curl = ta->lines.first;
-       ta->curc = 0;
-       ta->sell = ta->lines.first;
-       ta->selc = 0;
+  ta->curl = ta->lines.first;
+  ta->curc = 0;
+  ta->sell = ta->lines.first;
+  ta->selc = 0;
 }
 
 Text *BKE_text_add(Main *bmain, const char *name)
 {
-       Text *ta;
+  Text *ta;
 
-       ta = BKE_libblock_alloc(bmain, ID_TXT, name, 0);
+  ta = BKE_libblock_alloc(bmain, ID_TXT, name, 0);
 
-       BKE_text_init(ta);
+  BKE_text_init(ta);
 
-       return ta;
+  return ta;
 }
 
 /* this function replaces extended ascii characters */
 /* to a valid utf-8 sequences */
 int txt_extended_ascii_as_utf8(char **str)
 {
-       ptrdiff_t bad_char, i = 0;
-       const ptrdiff_t length = (ptrdiff_t)strlen(*str);
-       int added = 0;
+  ptrdiff_t bad_char, i = 0;
+  const ptrdiff_t length = (ptrdiff_t)strlen(*str);
+  int added = 0;
 
-       while ((*str)[i]) {
-               if ((bad_char = BLI_utf8_invalid_byte(*str + i, length - i)) == -1)
-                       break;
+  while ((*str)[i]) {
+    if ((bad_char = BLI_utf8_invalid_byte(*str + i, length - i)) == -1) {
+      break;
+    }
 
-               added++;
-               i += bad_char + 1;
-       }
+    added++;
+    i += bad_char + 1;
+  }
 
-       if (added != 0) {
-               char *newstr = MEM_mallocN(length + added + 1, "text_line");
-               ptrdiff_t mi = 0;
-               i = 0;
+  if (added != 0) {
+    char *newstr = MEM_mallocN(length + added + 1, "text_line");
+    ptrdiff_t mi = 0;
+    i = 0;
 
-               while ((*str)[i]) {
-                       if ((bad_char = BLI_utf8_invalid_byte((*str) + i, length - i)) == -1) {
-                               memcpy(newstr + mi, (*str) + i, length - i + 1);
-                               break;
-                       }
+    while ((*str)[i]) {
+      if ((bad_char = BLI_utf8_invalid_byte((*str) + i, length - i)) == -1) {
+        memcpy(newstr + mi, (*str) + i, length - i + 1);
+        break;
+      }
 
-                       memcpy(newstr + mi, (*str) + i, bad_char);
+      memcpy(newstr + mi, (*str) + i, bad_char);
 
-                       BLI_str_utf8_from_unicode((*str)[i + bad_char], newstr + mi + bad_char);
-                       i += bad_char + 1;
-                       mi += bad_char + 2;
-               }
-               newstr[length + added] = '\0';
-               MEM_freeN(*str);
-               *str = newstr;
-       }
+      BLI_str_utf8_from_unicode((*str)[i + bad_char], newstr + mi + bad_char);
+      i += bad_char + 1;
+      mi += bad_char + 2;
+    }
+    newstr[length + added] = '\0';
+    MEM_freeN(*str);
+    *str = newstr;
+  }
 
-       return added;
+  return added;
 }
 
 // this function removes any control characters from
@@ -290,16 +291,16 @@ int txt_extended_ascii_as_utf8(char **str)
 
 static void cleanup_textline(TextLine *tl)
 {
-       int i;
+  int i;
 
-       for (i = 0; i < tl->len; i++) {
-               if (tl->line[i] < ' ' && tl->line[i] != '\t') {
-                       memmove(tl->line + i, tl->line + i + 1, tl->len - i);
-                       tl->len--;
-                       i--;
-               }
-       }
-       tl->len += txt_extended_ascii_as_utf8(&tl->line);
+  for (i = 0; i < tl->len; i++) {
+    if (tl->line[i] < ' ' && tl->line[i] != '\t') {
+      memmove(tl->line + i, tl->line + i + 1, tl->len - i);
+      tl->len--;
+      i--;
+    }
+  }
+  tl->len += txt_extended_ascii_as_utf8(&tl->line);
 }
 
 /**
@@ -308,152 +309,158 @@ static void cleanup_textline(TextLine *tl)
  */
 static void text_from_buf(Text *text, const unsigned char *buffer, const int len)
 {
-       int i, llen;
+  int i, llen;
 
-       BLI_assert(BLI_listbase_is_empty(&text->lines));
+  BLI_assert(BLI_listbase_is_empty(&text->lines));
 
-       text->nlines = 0;
-       llen = 0;
-       for (i = 0; i < len; i++) {
-               if (buffer[i] == '\n') {
-                       TextLine *tmp;
+  text->nlines = 0;
+  llen = 0;
+  for (i = 0; i < len; i++) {
+    if (buffer[i] == '\n') {
+      TextLine *tmp;
 
-                       tmp = (TextLine *) MEM_mallocN(sizeof(TextLine), "textline");
-                       tmp->line = (char *) MEM_mallocN(llen + 1, "textline_string");
-                       tmp->format = NULL;
+      tmp = (TextLine *)MEM_mallocN(sizeof(TextLine), "textline");
+      tmp->line = (char *)MEM_mallocN(llen + 1, "textline_string");
+      tmp->format = NULL;
 
-                       if (llen) memcpy(tmp->line, &buffer[i - llen], llen);
-                       tmp->line[llen] = 0;
-                       tmp->len = llen;
+      if (llen) {
+        memcpy(tmp->line, &buffer[i - llen], llen);
+      }
+      tmp->line[llen] = 0;
+      tmp->len = llen;
 
-                       cleanup_textline(tmp);
+      cleanup_textline(tmp);
 
-                       BLI_addtail(&text->lines, tmp);
-                       text->nlines++;
+      BLI_addtail(&text->lines, tmp);
+      text->nlines++;
 
-                       llen = 0;
-                       continue;
-               }
-               llen++;
-       }
+      llen = 0;
+      continue;
+    }
+    llen++;
+  }
 
-       /* create new line in cases:
-        * - rest of line (if last line in file hasn't got \n terminator).
-        *   in this case content of such line would be used to fill text line buffer
-        * - file is empty. in this case new line is needed to start editing from.
-        * - last character in buffer is \n. in this case new line is needed to
-        *   deal with newline at end of file. (see [#28087]) (sergey) */
-       if (llen != 0 || text->nlines == 0 || buffer[len - 1] == '\n') {
-               TextLine *tmp;
+  /* create new line in cases:
+   * - rest of line (if last line in file hasn't got \n terminator).
+   *   in this case content of such line would be used to fill text line buffer
+   * - file is empty. in this case new line is needed to start editing from.
+   * - last character in buffer is \n. in this case new line is needed to
+   *   deal with newline at end of file. (see [#28087]) (sergey) */
+  if (llen != 0 || text->nlines == 0 || buffer[len - 1] == '\n') {
+    TextLine *tmp;
 
-               tmp = (TextLine *) MEM_mallocN(sizeof(TextLine), "textline");
-               tmp->line = (char *) MEM_mallocN(llen + 1, "textline_string");
-               tmp->format = NULL;
+    tmp = (TextLine *)MEM_mallocN(sizeof(TextLine), "textline");
+    tmp->line = (char *)MEM_mallocN(llen + 1, "textline_string");
+    tmp->format = NULL;
 
-               if (llen) memcpy(tmp->line, &buffer[i - llen], llen);
+    if (llen) {
+      memcpy(tmp->line, &buffer[i - llen], llen);
+    }
 
-               tmp->line[llen] = 0;
-               tmp->len = llen;
+    tmp->line[llen] = 0;
+    tmp->len = llen;
 
-               cleanup_textline(tmp);
+    cleanup_textline(tmp);
 
-               BLI_addtail(&text->lines, tmp);
-               text->nlines++;
-       }
+    BLI_addtail(&text->lines, tmp);
+    text->nlines++;
+  }
 
-       text->curl = text->sell = text->lines.first;
-       text->curc = text->selc = 0;
+  text->curl = text->sell = text->lines.first;
+  text->curc = text->selc = 0;
 }
 
 bool BKE_text_reload(Text *text)
 {
-       unsigned char *buffer;
-       size_t buffer_len;
-       char filepath_abs[FILE_MAX];
-       BLI_stat_t st;
+  unsigned char *buffer;
+  size_t buffer_len;
+  char filepath_abs[FILE_MAX];
+  BLI_stat_t st;
 
-       if (!text->name) {
-               return false;
-       }
+  if (!text->name) {
+    return false;
+  }
 
-       BLI_strncpy(filepath_abs, text->name, FILE_MAX);
-       BLI_path_abs(filepath_abs, BKE_main_blendfile_path_from_global());
+  BLI_strncpy(filepath_abs, text->name, FILE_MAX);
+  BLI_path_abs(filepath_abs, BKE_main_blendfile_path_from_global());
 
-       buffer = BLI_file_read_text_as_mem(filepath_abs, 0, &buffer_len);
-       if (buffer == NULL) {
-               return false;
-       }
+  buffer = BLI_file_read_text_as_mem(filepath_abs, 0, &buffer_len);
+  if (buffer == NULL) {
+    return false;
+  }
 
-       /* free memory: */
-       BKE_text_free_lines(text);
-       txt_make_dirty(text);
+  /* free memory: */
+  BKE_text_free_lines(text);
+  txt_make_dirty(text);
 
-       /* clear undo buffer */
-       if (BLI_stat(filepath_abs, &st) != -1) {
-               text->mtime = st.st_mtime;
-       }
-       else {
-               text->mtime = 0;
-       }
+  /* clear undo buffer */
+  if (BLI_stat(filepath_abs, &st) != -1) {
+    text->mtime = st.st_mtime;
+  }
+  else {
+    text->mtime = 0;
+  }
 
-       text_from_buf(text, buffer, buffer_len);
+  text_from_buf(text, buffer, buffer_len);
 
-       MEM_freeN(buffer);
-       return true;
+  MEM_freeN(buffer);
+  return true;
 }
 
 Text *BKE_text_load_ex(Main *bmain, const char *file, const char *relpath, const bool is_internal)
 {
-       unsigned char *buffer;
-       size_t buffer_len;
-       Text *ta;
-       char filepath_abs[FILE_MAX];
-       BLI_stat_t st;
+  unsigned char *buffer;
+  size_t buffer_len;
+  Text *ta;
+  char filepath_abs[FILE_MAX];
+  BLI_stat_t st;
 
-       BLI_strncpy(filepath_abs, file, FILE_MAX);
-       if (relpath) /* can be NULL (bg mode) */
-               BLI_path_abs(filepath_abs, relpath);
+  BLI_strncpy(filepath_abs, file, FILE_MAX);
+  if (relpath) { /* can be NULL (bg mode) */
+    BLI_path_abs(filepath_abs, relpath);
+  }
 
-       buffer = BLI_file_read_text_as_mem(filepath_abs, 0, &buffer_len);
-       if (buffer == NULL) {
-               return false;
-       }
+  buffer = BLI_file_read_text_as_mem(filepath_abs, 0, &buffer_len);
+  if (buffer == NULL) {
+    return false;
+  }
 
-       ta = BKE_libblock_alloc(bmain, ID_TXT, BLI_path_basename(filepath_abs), 0);
-       ta->id.us = 0;
+  ta = BKE_libblock_alloc(bmain, ID_TXT, BLI_path_basename(filepath_abs), 0);
+  ta->id.us = 0;
 
-       BLI_listbase_clear(&ta->lines);
-       ta->curl = ta->sell = NULL;
+  BLI_listbase_clear(&ta->lines);
+  ta->curl = ta->sell = NULL;
 
-       if ((U.flag & USER_TXT_TABSTOSPACES_DISABLE) == 0)
-               ta->flags = TXT_TABSTOSPACES;
+  if ((U.flag & USER_TXT_TABSTOSPACES_DISABLE) == 0) {
+    ta->flags = TXT_TABSTOSPACES;
+  }
 
-       if (is_internal == false) {
-               ta->name = MEM_mallocN(strlen(file) + 1, "text_name");
-               strcpy(ta->name, file);
-       }
-       else {
-               ta->flags |= TXT_ISMEM | TXT_ISDIRTY;
-       }
+  if (is_internal == false) {
+    ta->name = MEM_mallocN(strlen(file) + 1, "text_name");
+    strcpy(ta->name, file);
+  }
+  else {
+    ta->flags |= TXT_ISMEM | TXT_ISDIRTY;
+  }
 
-       /* clear undo buffer */
-       if (BLI_stat(filepath_abs, &st) != -1) {
-               ta->mtime = st.st_mtime;
-       }
-       else {
-               ta->mtime = 0;
-       }
+  /* clear undo buffer */
+  if (BLI_stat(filepath_abs, &st) != -1) {
+    ta->mtime = st.st_mtime;
+  }
+  else {
+    ta->mtime = 0;
+  }
 
-       text_from_buf(ta, buffer, buffer_len);
+  text_from_buf(ta, buffer, buffer_len);
 
-       MEM_freeN(buffer);
+  MEM_freeN(buffer);
 
-       return ta;
+  return ta;
 }
 
 Text *BKE_text_load(Main *bmain, const char *file, const char *relpath)
 {
-       return BKE_text_load_ex(bmain, file, relpath, false);
+  return BKE_text_load_ex(bmain, file, relpath, false);
 }
 
 /**
@@ -464,73 +471,75 @@ Text *BKE_text_load(Main *bmain, const char *file, const char *relpath)
  *
  * \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
  */
-void BKE_text_copy_data(Main *UNUSED(bmain), Text *ta_dst, const Text *ta_src, const int UNUSED(flag))
+void BKE_text_copy_data(Main *UNUSED(bmain),
+                        Text *ta_dst,
+                        const Text *ta_src,
+                        const int UNUSED(flag))
 {
-       /* file name can be NULL */
-       if (ta_src->name) {
-               ta_dst->name = BLI_strdup(ta_src->name);
-       }
+  /* file name can be NULL */
+  if (ta_src->name) {
+    ta_dst->name = BLI_strdup(ta_src->name);
+  }
 
-       ta_dst->flags |= TXT_ISDIRTY;
+  ta_dst->flags |= TXT_ISDIRTY;
 
-       BLI_listbase_clear(&ta_dst->lines);
-       ta_dst->curl = ta_dst->sell = NULL;
-       ta_dst->compiled = NULL;
+  BLI_listbase_clear(&ta_dst->lines);
+  ta_dst->curl = ta_dst->sell = NULL;
+  ta_dst->compiled = NULL;
 
-       /* Walk down, reconstructing */
-       for (TextLine *line_src = ta_src->lines.first; line_src; line_src = line_src->next) {
-               TextLine *line_dst = MEM_mallocN(sizeof(*line_dst), __func__);
+  /* Walk down, reconstructing */
+  for (TextLine *line_src = ta_src->lines.first; line_src; line_src = line_src->next) {
+    TextLine *line_dst = MEM_mallocN(sizeof(*line_dst), __func__);
 
-               line_dst->line = BLI_strdup(line_src->line);
-               line_dst->format = NULL;
-               line_dst->len = line_src->len;
+    line_dst->line = BLI_strdup(line_src->line);
+    line_dst->format = NULL;
+    line_dst->len = line_src->len;
 
-               BLI_addtail(&ta_dst->lines, line_dst);
-       }
+    BLI_addtail(&ta_dst->lines, line_dst);
+  }
 
-       ta_dst->curl = ta_dst->sell = ta_dst->lines.first;
-       ta_dst->curc = ta_dst->selc = 0;
+  ta_dst->curl = ta_dst->sell = ta_dst->lines.first;
+  ta_dst->curc = ta_dst->selc = 0;
 }
 
 Text *BKE_text_copy(Main *bmain, const Text *ta)
 {
-       Text *ta_copy;
-       BKE_id_copy(bmain, &ta->id, (ID **)&ta_copy);
-       return ta_copy;
+  Text *ta_copy;
+  BKE_id_copy(bmain, &ta->id, (ID **)&ta_copy);
+  return ta_copy;
 }
 
 void BKE_text_make_local(Main *bmain, Text *text, const bool lib_local)
 {
-       BKE_id_make_local_generic(bmain, &text->id, true, lib_local);
+  BKE_id_make_local_generic(bmain, &text->id, true, lib_local);
 }
 
 void BKE_text_clear(Text *text, TextUndoBuf *utxt) /* called directly from rna */
 {
-       const bool undoing_orig = undoing;
-       undoing = (utxt == NULL);
+  const bool undoing_orig = undoing;
+  undoing = (utxt == NULL);
 
-       txt_sel_all(text);
-       txt_delete_sel(text, utxt);
+  txt_sel_all(text);
+  txt_delete_sel(text, utxt);
 
-       undoing = undoing_orig;
+  undoing = undoing_orig;
 
-       txt_make_dirty(text);
+  txt_make_dirty(text);
 }
 
 void BKE_text_write(Text *text, TextUndoBuf *utxt, const char *str) /* called directly from rna */
 {
-       const bool undoing_orig = undoing;
-       undoing = (utxt == NULL);
+  const bool undoing_orig = undoing;
+  undoing = (utxt == NULL);
 
-       txt_insert_buf(text, utxt, str);
-       txt_move_eof(text, 0);
+  txt_insert_buf(text, utxt, str);
+  txt_move_eof(text, 0);
 
-       undoing = undoing_orig;
+  undoing = undoing_orig;
 
-       txt_make_dirty(text);
+  txt_make_dirty(text);
 }
 
-
 /* returns 0 if file on disk is the same or Text is in memory only
  * returns 1 if file has been modified on disk since last local edit
  * returns 2 if file on disk has been deleted
@@ -538,52 +547,62 @@ void BKE_text_write(Text *text, TextUndoBuf *utxt, const char *str) /* called di
 
 int BKE_text_file_modified_check(Text *text)
 {
-       BLI_stat_t st;
-       int result;
-       char file[FILE_MAX];
+  BLI_stat_t st;
+  int result;
+  char file[FILE_MAX];
 
-       if (!text->name)
-               return 0;
+  if (!text->name) {
+    return 0;
+  }
 
-       BLI_strncpy(file, text->name, FILE_MAX);
-       BLI_path_abs(file, BKE_main_blendfile_path_from_global());
+  BLI_strncpy(file, text->name, FILE_MAX);
+  BLI_path_abs(file, BKE_main_blendfile_path_from_global());
 
-       if (!BLI_exists(file))
-               return 2;
+  if (!BLI_exists(file)) {
+    return 2;
+  }
 
-       result = BLI_stat(file, &st);
+  result = BLI_stat(file, &st);
 
-       if (result == -1)
-               return -1;
+  if (result == -1) {
+    return -1;
+  }
 
-       if ((st.st_mode & S_IFMT) != S_IFREG)
-               return -1;
+  if ((st.st_mode & S_IFMT) != S_IFREG) {
+    return -1;
+  }
 
-       if (st.st_mtime > text->mtime)
-               return 1;
+  if (st.st_mtime > text->mtime) {
+    return 1;
+  }
 
-       return 0;
+  return 0;
 }
 
 void BKE_text_file_modified_ignore(Text *text)
 {
-       BLI_stat_t st;
-       int result;
-       char file[FILE_MAX];
+  BLI_stat_t st;
+  int result;
+  char file[FILE_MAX];
 
-       if (!text->name) return;
+  if (!text->name) {
+    return;
+  }
 
-       BLI_strncpy(file, text->name, FILE_MAX);
-       BLI_path_abs(file, BKE_main_blendfile_path_from_global());
+  BLI_strncpy(file, text->name, FILE_MAX);
+  BLI_path_abs(file, BKE_main_blendfile_path_from_global());
 
-       if (!BLI_exists(file)) return;
+  if (!BLI_exists(file)) {
+    return;
+  }
 
-       result = BLI_stat(file, &st);
+  result = BLI_stat(file, &st);
 
-       if (result == -1 || (st.st_mode & S_IFMT) != S_IFREG)
-               return;
+  if (result == -1 || (st.st_mode & S_IFMT) != S_IFREG) {
+    return;
+  }
 
-       text->mtime = st.st_mtime;
+  text->mtime = st.st_mtime;
 }
 
 /*****************************/
@@ -592,112 +611,144 @@ void BKE_text_file_modified_ignore(Text *text)
 
 static void make_new_line(TextLine *line, char *newline)
 {
-       if (line->line) MEM_freeN(line->line);
-       if (line->format) MEM_freeN(line->format);
+  if (line->line) {
+    MEM_freeN(line->line);
+  }
+  if (line->format) {
+    MEM_freeN(line->format);
+  }
 
-       line->line = newline;
-       line->len = strlen(newline);
-       line->format = NULL;
+  line->line = newline;
+  line->len = strlen(newline);
+  line->format = NULL;
 }
 
 static TextLine *txt_new_line(const char *str)
 {
-       TextLine *tmp;
+  TextLine *tmp;
 
-       if (!str) str = "";
+  if (!str) {
+    str = "";
+  }
 
-       tmp = (TextLine *) MEM_mallocN(sizeof(TextLine), "textline");
-       tmp->line = MEM_mallocN(strlen(str) + 1, "textline_string");
-       tmp->format = NULL;
+  tmp = (TextLine *)MEM_mallocN(sizeof(TextLine), "textline");
+  tmp->line = MEM_mallocN(strlen(str) + 1, "textline_string");
+  tmp->format = NULL;
 
-       strcpy(tmp->line, str);
+  strcpy(tmp->line, str);
 
-       tmp->len = strlen(str);
-       tmp->next = tmp->prev = NULL;
+  tmp->len = strlen(str);
+  tmp->next = tmp->prev = NULL;
 
-       return tmp;
+  return tmp;
 }
 
 static TextLine *txt_new_linen(const char *str, int n)
 {
-       TextLine *tmp;
+  TextLine *tmp;
 
-       tmp = (TextLine *) MEM_mallocN(sizeof(TextLine), "textline");
-       tmp->line = MEM_mallocN(n + 1, "textline_string");
-       tmp->format = NULL;
+  tmp = (TextLine *)MEM_mallocN(sizeof(TextLine), "textline");
+  tmp->line = MEM_mallocN(n + 1, "textline_string");
+  tmp->format = NULL;
 
-       BLI_strncpy(tmp->line, (str) ? str : "", n + 1);
+  BLI_strncpy(tmp->line, (str) ? str : "", n + 1);
 
-       tmp->len = strlen(tmp->line);
-       tmp->next = tmp->prev = NULL;
+  tmp->len = strlen(tmp->line);
+  tmp->next = tmp->prev = NULL;
 
-       return tmp;
+  return tmp;
 }
 
 void txt_clean_text(Text *text)
 {
-       TextLine **top, **bot;
-
-       if (!text->lines.first) {
-               if (text->lines.last) text->lines.first = text->lines.last;
-               else text->lines.first = text->lines.last = txt_new_line(NULL);
-       }
-
-       if (!text->lines.last) text->lines.last = text->lines.first;
-
-       top = (TextLine **) &text->lines.first;
-       bot = (TextLine **) &text->lines.last;
-
-       while ((*top)->prev) *top = (*top)->prev;
-       while ((*bot)->next) *bot = (*bot)->next;
-
-       if (!text->curl) {
-               if (text->sell) text->curl = text->sell;
-               else text->curl = text->lines.first;
-               text->curc = 0;
-       }
-
-       if (!text->sell) {
-               text->sell = text->curl;
-               text->selc = 0;
-       }
+  TextLine **top, **bot;
+
+  if (!text->lines.first) {
+    if (text->lines.last) {
+      text->lines.first = text->lines.last;
+    }
+    else {
+      text->lines.first = text->lines.last = txt_new_line(NULL);
+    }
+  }
+
+  if (!text->lines.last) {
+    text->lines.last = text->lines.first;
+  }
+
+  top = (TextLine **)&text->lines.first;
+  bot = (TextLine **)&text->lines.last;
+
+  while ((*top)->prev) {
+    *top = (*top)->prev;
+  }
+  while ((*bot)->next) {
+    *bot = (*bot)->next;
+  }
+
+  if (!text->curl) {
+    if (text->sell) {
+      text->curl = text->sell;
+    }
+    else {
+      text->curl = text->lines.first;
+    }
+    text->curc = 0;
+  }
+
+  if (!text->sell) {
+    text->sell = text->curl;
+    text->selc = 0;
+  }
 }
 
 int txt_get_span(TextLine *from, TextLine *to)
 {
-       int ret = 0;
-       TextLine *tmp = from;
-
-       if (!to || !from) return 0;
-       if (from == to) return 0;
-
-       /* Look forwards */
-       while (tmp) {
-               if (tmp == to) return ret;
-               ret++;
-               tmp = tmp->next;
-       }
-
-       /* Look backwards */
-       if (!tmp) {
-               tmp = from;
-               ret = 0;
-               while (tmp) {
-                       if (tmp == to) break;
-                       ret--;
-                       tmp = tmp->prev;
-               }
-               if (!tmp) ret = 0;
-       }
-
-       return ret;
+  int ret = 0;
+  TextLine *tmp = from;
+
+  if (!to || !from) {
+    return 0;
+  }
+  if (from == to) {
+    return 0;
+  }
+
+  /* Look forwards */
+  while (tmp) {
+    if (tmp == to) {
+      return ret;
+    }
+    ret++;
+    tmp = tmp->next;
+  }
+
+  /* Look backwards */
+  if (!tmp) {
+    tmp = from;
+    ret = 0;
+    while (tmp) {
+      if (tmp == to) {
+        break;
+      }
+      ret--;
+      tmp = tmp->prev;
+    }
+    if (!tmp) {
+      ret = 0;
+    }
+  }
+
+  return ret;
 }
 
 static void txt_make_dirty(Text *text)
 {
-       text->flags |= TXT_ISDIRTY;
+  text->flags |= TXT_ISDIRTY;
 #ifdef WITH_PYTHON
-       if (text->compiled) BPY_text_free_code(text);
+  if (text->compiled) {
+    BPY_text_free_code(text);
+  }
 #endif
 }
 
@@ -707,22 +758,24 @@ static void txt_make_dirty(Text *text)
 
 static void txt_curs_cur(Text *text, TextLine ***linep, int **charp)
 {
-       *linep = &text->curl; *charp = &text->curc;
+  *linep = &text->curl;
+  *charp = &text->curc;
 }
 
 static void txt_curs_sel(Text *text, TextLine ***linep, int **charp)
 {
-       *linep = &text->sell; *charp = &text->selc;
+  *linep = &text->sell;
+  *charp = &text->selc;
 }
 
 bool txt_cursor_is_line_start(Text *text)
 {
-       return (text->selc == 0);
+  return (text->selc == 0);
 }
 
 bool txt_cursor_is_line_end(Text *text)
 {
-       return (text->selc == text->sell->len);
+  return (text->selc == text->sell->len);
 }
 
 /*****************************/
@@ -731,316 +784,415 @@ bool txt_cursor_is_line_end(Text *text)
 
 int txt_utf8_offset_to_index(const char *str, int offset)
 {
-       int index = 0, pos = 0;
-       while (pos != offset) {
-               pos += BLI_str_utf8_size(str + pos);
-               index++;
-       }
-       return index;
+  int index = 0, pos = 0;
+  while (pos != offset) {
+    pos += BLI_str_utf8_size(str + pos);
+    index++;
+  }
+  return index;
 }
 
 int txt_utf8_index_to_offset(const char *str, int index)
 {
-       int offset = 0, pos = 0;
-       while (pos != index) {
-               offset += BLI_str_utf8_size(str + offset);
-               pos++;
-       }
-       return offset;
+  int offset = 0, pos = 0;
+  while (pos != index) {
+    offset += BLI_str_utf8_size(str + offset);
+    pos++;
+  }
+  return offset;
 }
 
 int txt_utf8_offset_to_column(const char *str, int offset)
 {
-       int column = 0, pos = 0;
-       while (pos < offset) {
-               column += BLI_str_utf8_char_width_safe(str + pos);
-               pos += BLI_str_utf8_size_safe(str + pos);
-       }
-       return column;
+  int column = 0, pos = 0;
+  while (pos < offset) {
+    column += BLI_str_utf8_char_width_safe(str + pos);
+    pos += BLI_str_utf8_size_safe(str + pos);
+  }
+  return column;
 }
 
 int txt_utf8_column_to_offset(const char *str, int column)
 {
-       int offset = 0, pos = 0, col;
-       while (*(str + offset) && pos < column) {
-               col = BLI_str_utf8_char_width_safe(str + offset);
-               if (pos + col > column)
-                       break;
-               offset += BLI_str_utf8_size_safe(str + offset);
-               pos += col;
-       }
-       return offset;
+  int offset = 0, pos = 0, col;
+  while (*(str + offset) && pos < column) {
+    col = BLI_str_utf8_char_width_safe(str + offset);
+    if (pos + col > column) {
+      break;
+    }
+    offset += BLI_str_utf8_size_safe(str + offset);
+    pos += col;
+  }
+  return offset;
 }
 
 void txt_move_up(Text *text, const bool sel)
 {
-       TextLine **linep;
-       int *charp;
-
-       if (sel) txt_curs_sel(text, &linep, &charp);
-       else { txt_pop_first(text); txt_curs_cur(text, &linep, &charp); }
-       if (!*linep) return;
-
-       if ((*linep)->prev) {
-               int column = txt_utf8_offset_to_column((*linep)->line, *charp);
-               *linep = (*linep)->prev;
-               *charp = txt_utf8_column_to_offset((*linep)->line, column);
-
-       }
-       else {
-               txt_move_bol(text, sel);
-       }
-
-       if (!sel) txt_pop_sel(text);
+  TextLine **linep;
+  int *charp;
+
+  if (sel) {
+    txt_curs_sel(text, &linep, &charp);
+  }
+  else {
+    txt_pop_first(text);
+    txt_curs_cur(text, &linep, &charp);
+  }
+  if (!*linep) {
+    return;
+  }
+
+  if ((*linep)->prev) {
+    int column = txt_utf8_offset_to_column((*linep)->line, *charp);
+    *linep = (*linep)->prev;
+    *charp = txt_utf8_column_to_offset((*linep)->line, column);
+  }
+  else {
+    txt_move_bol(text, sel);
+  }
+
+  if (!sel) {
+    txt_pop_sel(text);
+  }
 }
 
 void txt_move_down(Text *text, const bool sel)
 {
-       TextLine **linep;
-       int *charp;
-
-       if (sel) txt_curs_sel(text, &linep, &charp);
-       else { txt_pop_last(text); txt_curs_cur(text, &linep, &charp); }
-       if (!*linep) return;
-
-       if ((*linep)->next) {
-               int column = txt_utf8_offset_to_column((*linep)->line, *charp);
-               *linep = (*linep)->next;
-               *charp = txt_utf8_column_to_offset((*linep)->line, column);
-       }
-       else {
-               txt_move_eol(text, sel);
-       }
-
-       if (!sel) txt_pop_sel(text);
+  TextLine **linep;
+  int *charp;
+
+  if (sel) {
+    txt_curs_sel(text, &linep, &charp);
+  }
+  else {
+    txt_pop_last(text);
+    txt_curs_cur(text, &linep, &charp);
+  }
+  if (!*linep) {
+    return;
+  }
+
+  if ((*linep)->next) {
+    int column = txt_utf8_offset_to_column((*linep)->line, *charp);
+    *linep = (*linep)->next;
+    *charp = txt_utf8_column_to_offset((*linep)->line, column);
+  }
+  else {
+    txt_move_eol(text, sel);
+  }
+
+  if (!sel) {
+    txt_pop_sel(text);
+  }
 }
 
 int txt_calc_tab_left(TextLine *tl, int ch)
 {
-       /* do nice left only if there are only spaces */
+  /* do nice left only if there are only spaces */
 
-       int tabsize = (ch < TXT_TABSIZE) ? ch : TXT_TABSIZE;
+  int tabsize = (ch < TXT_TABSIZE) ? ch : TXT_TABSIZE;
 
-       for (int i = 0; i < ch; i++)
-               if (tl->line[i] != ' ') {
-                       tabsize = 0;
-                       break;
-               }
+  for (int i = 0; i < ch; i++) {
+    if (tl->line[i] != ' ') {
+      tabsize = 0;
+      break;
+    }
+  }
 
-       /* if in the middle of the space-tab */
-       if (tabsize && ch % TXT_TABSIZE != 0)
-               tabsize = (ch % TXT_TABSIZE);
-       return tabsize;
+  /* if in the middle of the space-tab */
+  if (tabsize && ch % TXT_TABSIZE != 0) {
+    tabsize = (ch % TXT_TABSIZE);
+  }
+  return tabsize;
 }
 
 int txt_calc_tab_right(TextLine *tl, int ch)
 {
-       if (tl->line[ch] == ' ') {
-               int i;
-               for (i = 0; i < ch; i++) {
-                       if (tl->line[i] != ' ') {
-                               return 0;
-                       }
-               }
+  if (tl->line[ch] == ' ') {
+    int i;
+    for (i = 0; i < ch; i++) {
+      if (tl->line[i] != ' ') {
+        return 0;
+      }
+    }
 
-               int tabsize = (ch) % TXT_TABSIZE + 1;
-               for (i = ch + 1; tl->line[i] == ' ' && tabsize < TXT_TABSIZE; i++) {
-                       tabsize++;
-               }
+    int tabsize = (ch) % TXT_TABSIZE + 1;
+    for (i = ch + 1; tl->line[i] == ' ' && tabsize < TXT_TABSIZE; i++) {
+      tabsize++;
+    }
 
-               return i - ch;
-       }
-       else {
-               return 0;
-       }
+    return i - ch;
+  }
+  else {
+    return 0;
+  }
 }
 
 void txt_move_left(Text *text, const bool sel)
 {
-       TextLine **linep;
-       int *charp;
-       int tabsize = 0;
-
-       if (sel) txt_curs_sel(text, &linep, &charp);
-       else { txt_pop_first(text); txt_curs_cur(text, &linep, &charp); }
-       if (!*linep) return;
-
-       if (*charp == 0) {
-               if ((*linep)->prev) {
-                       txt_move_up(text, sel);
-                       *charp = (*linep)->len;
-               }
-       }
-       else {
-               /* do nice left only if there are only spaces */
-               // TXT_TABSIZE hardcoded in DNA_text_types.h
-               if (text->flags & TXT_TABSTOSPACES) {
-                       tabsize = txt_calc_tab_left(*linep, *charp);
-               }
-
-               if (tabsize) {
-                       (*charp) -= tabsize;
-               }
-               else {
-                       const char *prev = BLI_str_prev_char_utf8((*linep)->line + *charp);
-                       *charp = prev - (*linep)->line;
-               }
-       }
-
-       if (!sel) txt_pop_sel(text);
+  TextLine **linep;
+  int *charp;
+  int tabsize = 0;
+
+  if (sel) {
+    txt_curs_sel(text, &linep, &charp);
+  }
+  else {
+    txt_pop_first(text);
+    txt_curs_cur(text, &linep, &charp);
+  }
+  if (!*linep) {
+    return;
+  }
+
+  if (*charp == 0) {
+    if ((*linep)->prev) {
+      txt_move_up(text, sel);
+      *charp = (*linep)->len;
+    }
+  }
+  else {
+    /* do nice left only if there are only spaces */
+    // TXT_TABSIZE hardcoded in DNA_text_types.h
+    if (text->flags & TXT_TABSTOSPACES) {
+      tabsize = txt_calc_tab_left(*linep, *charp);
+    }
+
+    if (tabsize) {
+      (*charp) -= tabsize;
+    }
+    else {
+      const char *prev = BLI_str_prev_char_utf8((*linep)->line + *charp);
+      *charp = prev - (*linep)->line;
+    }
+  }
+
+  if (!sel) {
+    txt_pop_sel(text);
+  }
 }
 
 void txt_move_right(Text *text, const bool sel)
 {
-       TextLine **linep;
-       int *charp;
-
-       if (sel) txt_curs_sel(text, &linep, &charp);
-       else { txt_pop_last(text); txt_curs_cur(text, &linep, &charp); }
-       if (!*linep) return;
-
-       if (*charp == (*linep)->len) {
-               if ((*linep)->next) {
-                       txt_move_down(text, sel);
-                       *charp = 0;
-               }
-       }
-       else {
-               /* do nice right only if there are only spaces */
-               /* spaces hardcoded in DNA_text_types.h */
-               int tabsize = 0;
-
-               if (text->flags & TXT_TABSTOSPACES) {
-                       tabsize = txt_calc_tab_right(*linep, *charp);
-               }
-
-               if (tabsize) {
-                       (*charp) += tabsize;
-               }
-               else {
-                       (*charp) += BLI_str_utf8_size((*linep)->line + *charp);
-               }
-       }
-
-       if (!sel) txt_pop_sel(text);
+  TextLine **linep;
+  int *charp;
+
+  if (sel) {
+    txt_curs_sel(text, &linep, &charp);
+  }
+  else {
+    txt_pop_last(text);
+    txt_curs_cur(text, &linep, &charp);
+  }
+  if (!*linep) {
+    return;
+  }
+
+  if (*charp == (*linep)->len) {
+    if ((*linep)->next) {
+      txt_move_down(text, sel);
+      *charp = 0;
+    }
+  }
+  else {
+    /* do nice right only if there are only spaces */
+    /* spaces hardcoded in DNA_text_types.h */
+    int tabsize = 0;
+
+    if (text->flags & TXT_TABSTOSPACES) {
+      tabsize = txt_calc_tab_right(*linep, *charp);
+    }
+
+    if (tabsize) {
+      (*charp) += tabsize;
+    }
+    else {
+      (*charp) += BLI_str_utf8_size((*linep)->line + *charp);
+    }
+  }
+
+  if (!sel) {
+    txt_pop_sel(text);
+  }
 }
 
 void txt_jump_left(Text *text, const bool sel, const bool use_init_step)
 {
-       TextLine **linep;
-       int *charp;
+  TextLine **linep;
+  int *charp;
 
-       if (sel) txt_curs_sel(text, &linep, &charp);
-       else { txt_pop_first(text); txt_curs_cur(text, &linep, &charp); }
-       if (!*linep) return;
+  if (sel) {
+    txt_curs_sel(text, &linep, &charp);
+  }
+  else {
+    txt_pop_first(text);
+    txt_curs_cur(text, &linep, &charp);
+  }
+  if (!*linep) {
+    return;
+  }
 
-       BLI_str_cursor_step_utf8((*linep)->line, (*linep)->len,
-                                charp, STRCUR_DIR_PREV,
-                                STRCUR_JUMP_DELIM, use_init_step);
+  BLI_str_cursor_step_utf8(
+      (*linep)->line, (*linep)->len, charp, STRCUR_DIR_PREV, STRCUR_JUMP_DELIM, use_init_step);
 
-       if (!sel) txt_pop_sel(text);
+  if (!sel) {
+    txt_pop_sel(text);
+  }
 }
 
 void txt_jump_right(Text *text, const bool sel, const bool use_init_step)
 {
-       TextLine **linep;
-       int *charp;
+  TextLine **linep;
+  int *charp;
 
-       if (sel) txt_curs_sel(text, &linep, &charp);
-       else { txt_pop_last(text); txt_curs_cur(text, &linep, &charp); }
-       if (!*linep) return;
+  if (sel) {
+    txt_curs_sel(text, &linep, &charp);
+  }
+  else {
+    txt_pop_last(text);
+    txt_curs_cur(text, &linep, &charp);
+  }
+  if (!*linep) {
+    return;
+  }
 
-       BLI_str_cursor_step_utf8((*linep)->line, (*linep)->len,
-                                charp, STRCUR_DIR_NEXT,
-                                STRCUR_JUMP_DELIM, use_init_step);
+  BLI_str_cursor_step_utf8(
+      (*linep)->line, (*linep)->len, charp, STRCUR_DIR_NEXT, STRCUR_JUMP_DELIM, use_init_step);
 
-       if (!sel) txt_pop_sel(text);
+  if (!sel) {
+    txt_pop_sel(text);
+  }
 }
 
 void txt_move_bol(Text *text, const bool sel)
 {
-       TextLine **linep;
-       int *charp;
+  TextLine **linep;
+  int *charp;
 
-       if (sel) txt_curs_sel(text, &linep, &charp);
-       else txt_curs_cur(text, &linep, &charp);
-       if (!*linep) return;
+  if (sel) {
+    txt_curs_sel(text, &linep, &charp);
+  }
+  else {
+    txt_curs_cur(text, &linep, &charp);
+  }
+  if (!*linep) {
+    return;
+  }
 
-       *charp = 0;
+  *charp = 0;
 
-       if (!sel) txt_pop_sel(text);
+  if (!sel) {
+    txt_pop_sel(text);
+  }
 }
 
 void txt_move_eol(Text *text, const bool sel)
 {
-       TextLine **linep;
-       int *charp;
+  TextLine **linep;
+  int *charp;
 
-       if (sel) txt_curs_sel(text, &linep, &charp);
-       else txt_curs_cur(text, &linep, &charp);
-       if (!*linep) return;
+  if (sel) {
+    txt_curs_sel(text, &linep, &charp);
+  }
+  else {
+    txt_curs_cur(text, &linep, &charp);
+  }
+  if (!*linep) {
+    return;
+  }
 
-       *charp = (*linep)->len;
+  *charp = (*linep)->len;
 
-       if (!sel) txt_pop_sel(text);
+  if (!sel) {
+    txt_pop_sel(text);
+  }
 }
 
 void txt_move_bof(Text *text, const bool sel)
 {
-       TextLine **linep;
-       int *charp;
+  TextLine **linep;
+  int *charp;
 
-       if (sel) txt_curs_sel(text, &linep, &charp);
-       else txt_curs_cur(text, &linep, &charp);
-       if (!*linep) return;
+  if (sel) {
+    txt_curs_sel(text, &linep, &charp);
+  }
+  else {
+    txt_curs_cur(text, &linep, &charp);
+  }
+  if (!*linep) {
+    return;
+  }
 
-       *linep = text->lines.first;
-       *charp = 0;
+  *linep = text->lines.first;
+  *charp = 0;
 
-       if (!sel) txt_pop_sel(text);
+  if (!sel) {
+    txt_pop_sel(text);
+  }
 }
 
 void txt_move_eof(Text *text, const bool sel)
 {
-       TextLine **linep;
-       int *charp;
+  TextLine **linep;
+  int *charp;
 
-       if (sel) txt_curs_sel(text, &linep, &charp);
-       else txt_curs_cur(text, &linep, &charp);
-       if (!*linep) return;
+  if (sel) {
+    txt_curs_sel(text, &linep, &charp);
+  }
+  else {
+    txt_curs_cur(text, &linep, &charp);
+  }
+  if (!*linep) {
+    return;
+  }
 
-       *linep = text->lines.last;
-       *charp = (*linep)->len;
+  *linep = text->lines.last;
+  *charp = (*linep)->len;
 
-       if (!sel) txt_pop_sel(text);
+  if (!sel) {
+    txt_pop_sel(text);
+  }
 }
 
 void txt_move_toline(Text *text, unsigned int line, const bool sel)
 {
-       txt_move_to(text, line, 0, sel);
+  txt_move_to(text, line, 0, sel);
 }
 
 /* Moves to a certain byte in a line, not a certain utf8-character! */
 void txt_move_to(Text *text, unsigned int line, unsigned int ch, const bool sel)
 {
-       TextLine **linep;
-       int *charp;
-       unsigned int i;
-
-       if (sel) txt_curs_sel(text, &linep, &charp);
-       else txt_curs_cur(text, &linep, &charp);
-       if (!*linep) return;
-
-       *linep = text->lines.first;
-       for (i = 0; i < line; i++) {
-               if ((*linep)->next) *linep = (*linep)->next;
-               else break;
-       }
-       if (ch > (unsigned int)((*linep)->len))
-               ch = (unsigned int)((*linep)->len);
-       *charp = ch;
-
-       if (!sel) txt_pop_sel(text);
+  TextLine **linep;
+  int *charp;
+  unsigned int i;
+
+  if (sel) {
+    txt_curs_sel(text, &linep, &charp);
+  }
+  else {
+    txt_curs_cur(text, &linep, &charp);
+  }
+  if (!*linep) {
+    return;
+  }
+
+  *linep = text->lines.first;
+  for (i = 0; i < line; i++) {
+    if ((*linep)->next) {
+      *linep = (*linep)->next;
+    }
+    else {
+      break;
+    }
+  }
+  if (ch > (unsigned int)((*linep)->len)) {
+    ch = (unsigned int)((*linep)->len);
+  }
+  *charp = ch;
+
+  if (!sel) {
+    txt_pop_sel(text);
+  }
 }
 
 /****************************/
@@ -1049,118 +1201,126 @@ void txt_move_to(Text *text, unsigned int line, unsigned int ch, const bool sel)
 
 static void txt_curs_swap(Text *text)
 {
-       TextLine *tmpl;
-       int tmpc;
+  TextLine *tmpl;
+  int tmpc;
 
-       tmpl = text->curl;
-       text->curl = text->sell;
-       text->sell = tmpl;
+  tmpl = text->curl;
+  text->curl = text->sell;
+  text->sell = tmpl;
 
-       tmpc = text->curc;
-       text->curc = text->selc;
-       text->selc = tmpc;
+  tmpc = text->curc;
+  text->curc = text->selc;
+  text->selc = tmpc;
 }
 
 static void txt_pop_first(Text *text)
 {
-       if (txt_get_span(text->curl, text->sell) < 0 ||
-           (text->curl == text->sell && text->curc > text->selc))
-       {
-               txt_curs_swap(text);
-       }
+  if (txt_get_span(text->curl, text->sell) < 0 ||
+      (text->curl == text->sell && text->curc > text->selc)) {
+    txt_curs_swap(text);
+  }
 
-       txt_pop_sel(text);
+  txt_pop_sel(text);
 }
 
 static void txt_pop_last(Text *text)
 {
-       if (txt_get_span(text->curl, text->sell) > 0 ||
-           (text->curl == text->sell && text->curc < text->selc))
-       {
-               txt_curs_swap(text);
-       }
+  if (txt_get_span(text->curl, text->sell) > 0 ||
+      (text->curl == text->sell && text->curc < text->selc)) {
+    txt_curs_swap(text);
+  }
 
-       txt_pop_sel(text);
+  txt_pop_sel(text);
 }
 
 void txt_pop_sel(Text *text)
 {
-       text->sell = text->curl;
-       text->selc = text->curc;
+  text->sell = text->curl;
+  text->selc = text->curc;
 }
 
 void txt_order_cursors(Text *text, const bool reverse)
 {
-       if (!text->curl) return;
-       if (!text->sell) return;
-
-       /* Flip so text->curl is before/after text->sell */
-       if (reverse == false) {
-               if ((txt_get_span(text->curl, text->sell) < 0) ||
-                   (text->curl == text->sell && text->curc > text->selc))
-               {
-                       txt_curs_swap(text);
-               }
-       }
-       else {
-               if ((txt_get_span(text->curl, text->sell) > 0) ||
-                   (text->curl == text->sell && text->curc < text->selc))
-               {
-                       txt_curs_swap(text);
-               }
-       }
+  if (!text->curl) {
+    return;
+  }
+  if (!text->sell) {
+    return;
+  }
+
+  /* Flip so text->curl is before/after text->sell */
+  if (reverse == false) {
+    if ((txt_get_span(text->curl, text->sell) < 0) ||
+        (text->curl == text->sell && text->curc > text->selc)) {
+      txt_curs_swap(text);
+    }
+  }
+  else {
+    if ((txt_get_span(text->curl, text->sell) > 0) ||
+        (text->curl == text->sell && text->curc < text->selc)) {
+      txt_curs_swap(text);
+    }
+  }
 }
 
 bool txt_has_sel(Text *text)
 {
-       return ((text->curl != text->sell) || (text->curc != text->selc));
+  return ((text->curl != text->sell) || (text->curc != text->selc));
 }
 
 static void txt_delete_sel(Text *text, TextUndoBuf *utxt)
 {
-       TextLine *tmpl;
-       char *buf;
+  TextLine *tmpl;
+  char *buf;
 
-       if (!text->curl) return;
-       if (!text->sell) return;
+  if (!text->curl) {
+    return;
+  }
+  if (!text->sell) {
+    return;
+  }
 
-       if (!txt_has_sel(text)) return;
+  if (!txt_has_sel(text)) {
+    return;
+  }
 
-       txt_order_cursors(text, false);
+  txt_order_cursors(text, false);
 
-       if (!undoing) {
-               buf = txt_sel_to_buf(text);
-               txt_undo_add_blockop(text, utxt, UNDO_DBLOCK, buf);
-               MEM_freeN(buf);
-       }
+  if (!undoing) {
+    buf = txt_sel_to_buf(text);
+    txt_undo_add_blockop(text, utxt, UNDO_DBLOCK, buf);
+    MEM_freeN(buf);
+  }
 
-       buf = MEM_mallocN(text->curc + (text->sell->len - text->selc) + 1, "textline_string");
+  buf = MEM_mallocN(text->curc + (text->sell->len - text->selc) + 1, "textline_string");
 
-       strncpy(buf, text->curl->line, text->curc);
-       strcpy(buf + text->curc, text->sell->line + text->selc);
-       buf[text->curc + (text->sell->len - text->selc)] = 0;
+  strncpy(buf, text->curl->line, text->curc);
+  strcpy(buf + text->curc, text->sell->line + text->selc);
+  buf[text->curc + (text->sell->len - text->selc)] = 0;
 
-       make_new_line(text->curl, buf);
+  make_new_line(text->curl, buf);
 
-       tmpl = text->sell;
-       while (tmpl != text->curl) {
-               tmpl = tmpl->prev;
-               if (!tmpl) break;
+  tmpl = text->sell;
+  while (tmpl != text->curl) {
+    tmpl = tmpl->prev;
+    if (!tmpl) {
+      break;
+    }
 
-               txt_delete_line(text, tmpl->next);
-       }
+    txt_delete_line(text, tmpl->next);
+  }
 
-       text->sell = text->curl;
-       text->selc = text->curc;
+  text->sell = text->curl;
+  text->selc = text->curc;
 }
 
 void txt_sel_all(Text *text)
 {
-       text->curl = text->lines.first;
-       text->curc = 0;
+  text->curl = text->lines.first;
+  text->curc = 0;
 
-       text->sell = text->lines.last;
-       text->selc = text->sell->len;
+  text->sell = text->lines.last;
+  text->selc = text->sell->len;
 }
 
 /**
@@ -1170,19 +1330,21 @@ void txt_sel_all(Text *text)
  */
 void txt_sel_clear(Text *text)
 {
-       if (text->sell) {
-               text->curl = text->sell;
-               text->curc = text->selc;
-       }
+  if (text->sell) {
+    text->curl = text->sell;
+    text->curc = text->selc;
+  }
 }
 
 void txt_sel_line(Text *text)
 {
-       if (!text->curl) return;
+  if (!text->curl) {
+    return;
+  }
 
-       text->curc = 0;
-       text->sell = text->curl;
-       text->selc = text->sell->len;
+  text->curc = 0;
+  text->sell = text->curl;
+  text->selc = text->sell->len;
 }
 
 /***************************/
@@ -1191,240 +1353,266 @@ void txt_sel_line(Text *text)
 
 char *txt_to_buf(Text *text)
 {
-       int length;
-       TextLine *tmp, *linef, *linel;
-       int charf, charl;
-       char *buf;
+  int length;
+  TextLine *tmp, *linef, *linel;
+  int charf, charl;
+  char *buf;
 
-       if (!text->curl) return NULL;
-       if (!text->sell) return NULL;
-       if (!text->lines.first) return NULL;
+  if (!text->curl) {
+    return NULL;
+  }
+  if (!text->sell) {
+    return NULL;
+  }
+  if (!text->lines.first) {
+    return NULL;
+  }
 
-       linef = text->lines.first;
-       charf = 0;
+  linef = text->lines.first;
+  charf = 0;
 
-       linel = text->lines.last;
-       charl = linel->len;
+  linel = text->lines.last;
+  charl = linel->len;
 
-       if (linef == text->lines.last) {
-               length = charl - charf;
+  if (linef == text->lines.last) {
+    length = charl - charf;
 
-               buf = MEM_mallocN(length + 2, "text buffer");
+    buf = MEM_mallocN(length + 2, "text buffer");
 
-               BLI_strncpy(buf, linef->line + charf, length + 1);
-               buf[length] = 0;
-       }
-       else {
-               length = linef->len - charf;
-               length += charl;
-               length += 2; /* For the 2 '\n' */
+    BLI_strncpy(buf, linef->line + charf, length + 1);
+    buf[length] = 0;
+  }
+  else {
+    length = linef->len - charf;
+    length += charl;
+    length += 2; /* For the 2 '\n' */
 
-               tmp = linef->next;
-               while (tmp && tmp != linel) {
-                       length += tmp->len + 1;
-                       tmp = tmp->next;
-               }
+    tmp = linef->next;
+    while (tmp && tmp != linel) {
+      length += tmp->len + 1;
+      tmp = tmp->next;
+    }
 
-               buf = MEM_mallocN(length + 1, "cut buffer");
+    buf = MEM_mallocN(length + 1, "cut buffer");
 
-               strncpy(buf, linef->line + charf, linef->len - charf);
-               length = linef->len - charf;
+    strncpy(buf, linef->line + charf, linef->len - charf);
+    length = linef->len - charf;
 
-               buf[length++] = '\n';
+    buf[length++] = '\n';
 
-               tmp = linef->next;
-               while (tmp && tmp != linel) {
-                       strncpy(buf + length, tmp->line, tmp->len);
-                       length += tmp->len;
+    tmp = linef->next;
+    while (tmp && tmp != linel) {
+      strncpy(buf + length, tmp->line, tmp->len);
+      length += tmp->len;
 
-                       buf[length++] = '\n';
+      buf[length++] = '\n';
 
-                       tmp = tmp->next;
-               }
-               strncpy(buf + length, linel->line, charl);
-               length += charl;
+      tmp = tmp->next;
+    }
+    strncpy(buf + length, linel->line, charl);
+    length += charl;
 
-               /* python compiler wants an empty end line */
-               buf[length++] = '\n';
-               buf[length] = 0;
-       }
+    /* python compiler wants an empty end line */
+    buf[length++] = '\n';
+    buf[length] = 0;
+  }
 
-       return buf;
+  return buf;
 }
 
 int txt_find_string(Text *text, const char *findstr, int wrap, int match_case)
 {
-       TextLine *tl, *startl;
-       const char *s = NULL;
-
-       if (!text->curl || !text->sell) return 0;
-
-       txt_order_cursors(text, false);
-
-       tl = startl = text->sell;
-
-       if (match_case) s = strstr(&tl->line[text->selc], findstr);
-       else s = BLI_strcasestr(&tl->line[text->selc], findstr);
-       while (!s) {
-               tl = tl->next;
-               if (!tl) {
-                       if (wrap)
-                               tl = text->lines.first;
-                       else
-                               break;
-               }
-
-               if (match_case) s = strstr(tl->line, findstr);
-               else s = BLI_strcasestr(tl->line, findstr);
-               if (tl == startl)
-                       break;
-       }
-
-       if (s) {
-               int newl = txt_get_span(text->lines.first, tl);
-               int newc = (int)(s - tl->line);
-               txt_move_to(text, newl, newc, 0);
-               txt_move_to(text, newl, newc + strlen(findstr), 1);
-               return 1;
-       }
-       else
-               return 0;
+  TextLine *tl, *startl;
+  const char *s = NULL;
+
+  if (!text->curl || !text->sell) {
+    return 0;
+  }
+
+  txt_order_cursors(text, false);
+
+  tl = startl = text->sell;
+
+  if (match_case) {
+    s = strstr(&tl->line[text->selc], findstr);
+  }
+  else {
+    s = BLI_strcasestr(&tl->line[text->selc], findstr);
+  }
+  while (!s) {
+    tl = tl->next;
+    if (!tl) {
+      if (wrap) {
+        tl = text->lines.first;
+      }
+      else {
+        break;
+      }
+    }
+
+    if (match_case) {
+      s = strstr(tl->line, findstr);
+    }
+    else {
+      s = BLI_strcasestr(tl->line, findstr);
+    }
+    if (tl == startl) {
+      break;
+    }
+  }
+
+  if (s) {
+    int newl = txt_get_span(text->lines.first, tl);
+    int newc = (int)(s - tl->line);
+    txt_move_to(text, newl, newc, 0);
+    txt_move_to(text, newl, newc + strlen(findstr), 1);
+    return 1;
+  }
+  else {
+    return 0;
+  }
 }
 
 char *txt_sel_to_buf(Text *text)
 {
-       char *buf;
-       int length = 0;
-       TextLine *tmp, *linef, *linel;
-       int charf, charl;
+  char *buf;
+  int length = 0;
+  TextLine *tmp, *linef, *linel;
+  int charf, charl;
 
-       if (!text->curl) return NULL;
-       if (!text->sell) return NULL;
+  if (!text->curl) {
+    return NULL;
+  }
+  if (!text->sell) {
+    return NULL;
+  }
 
-       if (text->curl == text->sell) {
-               linef = linel = text->curl;
+  if (text->curl == text->sell) {
+    linef = linel = text->curl;
 
-               if (text->curc < text->selc) {
-                       charf = text->curc;
-                       charl = text->selc;
-               }
-               else {
-                       charf = text->selc;
-                       charl = text->curc;
-               }
-       }
-       else if (txt_get_span(text->curl, text->sell) < 0) {
-               linef = text->sell;
-               linel = text->curl;
+    if (text->curc < text->selc) {
+      charf = text->curc;
+      charl = text->selc;
+    }
+    else {
+      charf = text->selc;
+      charl = text->curc;
+    }
+  }
+  else if (txt_get_span(text->curl, text->sell) < 0) {
+    linef = text->sell;
+    linel = text->curl;
 
-               charf = text->selc;
-               charl = text->curc;
-       }
-       else {
-               linef = text->curl;
-               linel = text->sell;
+    charf = text->selc;
+    charl = text->curc;
+  }
+  else {
+    linef = text->curl;
+    linel = text->sell;
 
-               charf = text->curc;
-               charl = text->selc;
-       }
+    charf = text->curc;
+    charl = text->selc;
+  }
 
-       if (linef == linel) {
-               length = charl - charf;
+  if (linef == linel) {
+    length = charl - charf;
 
-               buf = MEM_mallocN(length + 1, "sel buffer");
+    buf = MEM_mallocN(length + 1, "sel buffer");
 
-               BLI_strncpy(buf, linef->line + charf, length + 1);
-       }
-       else {
-               length += linef->len - charf;
-               length += charl;
-               length++; /* For the '\n' */
+    BLI_strncpy(buf, linef->line + charf, length + 1);
+  }
+  else {
+    length += linef->len - charf;
+    length += charl;
+    length++; /* For the '\n' */
 
-               tmp = linef->next;
-               while (tmp && tmp != linel) {
-                       length += tmp->len + 1;
-                       tmp = tmp->next;
-               }
+    tmp = linef->next;
+    while (tmp && tmp != linel) {
+      length += tmp->len + 1;
+      tmp = tmp->next;
+    }
 
-               buf = MEM_mallocN(length + 1, "sel buffer");
+    buf = MEM_mallocN(length + 1, "sel buffer");
 
-               strncpy(buf, linef->line + charf, linef->len - charf);
-               length = linef->len - charf;
+    strncpy(buf, linef->line + charf, linef->len - charf);
+    length = linef->len - charf;
 
-               buf[length++] = '\n';
+    buf[length++] = '\n';
 
-               tmp = linef->next;
-               while (tmp && tmp != linel) {
-                       strncpy(buf + length, tmp->line, tmp->len);
-                       length += tmp->len;
+    tmp = linef->next;
+    while (tmp && tmp != linel) {
+      strncpy(buf + length, tmp->line, tmp->len);
+      length += tmp->len;
 
-                       buf[length++] = '\n';
+      buf[length++] = '\n';
 
-                       tmp = tmp->next;
-               }
-               strncpy(buf + length, linel->line, charl);
-               length += charl;
+      tmp = tmp->next;
+    }
+    strncpy(buf + length, linel->line, charl);
+    length += charl;
 
-               buf[length] = 0;
-       }
+    buf[length] = 0;
+  }
 
-       return buf;
+  return buf;
 }
 
 void txt_insert_buf(Text *text, TextUndoBuf *utxt, const char *in_buffer)
 {
-       const bool undoing_orig = undoing;
-       int l = 0, len;
-       size_t i = 0, j;
-       TextLine *add;
-       char *buffer;
-
-       if (!in_buffer) return;
-
-       txt_delete_sel(text, utxt);
-
-       len = strlen(in_buffer);
-       buffer = BLI_strdupn(in_buffer, len);
-       len += txt_extended_ascii_as_utf8(&buffer);
-
-       if (!undoing) {
-               txt_undo_add_blockop(text, utxt, UNDO_IBLOCK, buffer);
-       }
-       undoing = true;
-
-       /* Read the first line (or as close as possible */
-       while (buffer[i] && buffer[i] != '\n') {
-               txt_add_raw_char(text, utxt, BLI_str_utf8_as_unicode_step(buffer, &i));
-       }
-
-       if (buffer[i] == '\n') {
-               txt_split_curline(text, utxt);
-               i++;
-
-               while (i < len) {
-                       l = 0;
-
-                       while (buffer[i] && buffer[i] != '\n') {
-                               i++;
-                               l++;
-                       }
-
-                       if (buffer[i] == '\n') {
-                               add = txt_new_linen(buffer + (i - l), l);
-                               BLI_insertlinkbefore(&text->lines, text->curl, add);
-                               i++;
-                       }
-                       else {
-                               for (j = i - l; j < i && j < len; ) {
-                                       txt_add_raw_char(text, utxt, BLI_str_utf8_as_unicode_step(buffer, &j));
-                               }
-                               break;
-                       }
-               }
-       }
-
-       MEM_freeN(buffer);
-       undoing = undoing_orig;
+  const bool undoing_orig = undoing;
+  int l = 0, len;
+  size_t i = 0, j;
+  TextLine *add;
+  char *buffer;
+
+  if (!in_buffer) {
+    return;
+  }
+
+  txt_delete_sel(text, utxt);
+
+  len = strlen(in_buffer);
+  buffer = BLI_strdupn(in_buffer, len);
+  len += txt_extended_ascii_as_utf8(&buffer);
+
+  if (!undoing) {
+    txt_undo_add_blockop(text, utxt, UNDO_IBLOCK, buffer);
+  }
+  undoing = true;
+
+  /* Read the first line (or as close as possible */
+  while (buffer[i] && buffer[i] != '\n') {
+    txt_add_raw_char(text, utxt, BLI_str_utf8_as_unicode_step(buffer, &i));
+  }
+
+  if (buffer[i] == '\n') {
+    txt_split_curline(text, utxt);
+    i++;
+
+    while (i < len) {
+      l = 0;
+
+      while (buffer[i] && buffer[i] != '\n') {
+        i++;
+        l++;
+      }
+
+      if (buffer[i] == '\n') {
+        add = txt_new_linen(buffer + (i - l), l);
+        BLI_insertlinkbefore(&text->lines, text->curl, add);
+        i++;
+      }
+      else {
+        for (j = i - l; j < i && j < len;) {
+          txt_add_raw_char(text, utxt, BLI_str_utf8_as_unicode_step(buffer, &j));
+        }
+        break;
+      }
+    }
+  }
+
+  MEM_freeN(buffer);
+  undoing = undoing_orig;
 }
 
 /******************/
@@ -1433,32 +1621,32 @@ void txt_insert_buf(Text *text, TextUndoBuf *utxt, const char *in_buffer)
 
 static bool max_undo_test(TextUndoBuf *utxt, int x)
 {
-       /* Normally over-allocating is preferred,
-        * however in this case the buffer is small enough and re-allocation
-        * fast enough for each undo step that it's not a problem to allocate each time.
-        * This also saves on some memory when we have many text buffers
-        * that would have an empty undo memory allocated.
-        */
-
-       /* Add one for the null terminator. */
-       utxt->len = utxt->pos + x + 1;
-       if (utxt->len > TXT_MAX_UNDO) {
-               /* XXX error("Undo limit reached, buffer cleared\n"); */
-               MEM_freeN(utxt->buf);
-               return false;
-       }
-       else {
-               /* Small reallocations on each undo step is fine. */
-               utxt->buf = MEM_recallocN(utxt->buf, utxt->len);
-       }
-       return true;
+  /* Normally over-allocating is preferred,
+   * however in this case the buffer is small enough and re-allocation
+   * fast enough for each undo step that it's not a problem to allocate each time.
+   * This also saves on some memory when we have many text buffers
+   * that would have an empty undo memory allocated.
+   */
+
+  /* Add one for the null terminator. */
+  utxt->len = utxt->pos + x + 1;
+  if (utxt->len > TXT_MAX_UNDO) {
+    /* XXX error("Undo limit reached, buffer cleared\n"); */
+    MEM_freeN(utxt->buf);
+    return false;
+  }
+  else {
+    /* Small reallocations on each undo step is fine. */
+    utxt->buf = MEM_recallocN(utxt->buf, utxt->len);
+  }
+  return true;
 }
 
 static void txt_undo_end(Text *UNUSED(text), TextUndoBuf *utxt)
 {
-       int undo_pos_end = utxt->pos + 1;
-       BLI_assert(undo_pos_end + 1 == utxt->len);
-       utxt->buf[undo_pos_end] = '\0';
+  int undo_pos_end = utxt->pos + 1;
+  BLI_assert(undo_pos_end + 1 == utxt->len);
+  utxt->buf[undo_pos_end] = '\0';
 }
 
 /* Call once undo is done. */
@@ -1466,923 +1654,997 @@ static void txt_undo_end(Text *UNUSED(text), TextUndoBuf *utxt)
 
 #endif
 
-#if 0  /* UNUSED */
+#if 0 /* UNUSED */
 static void dump_buffer(TextUndoBuf *utxt)
 {
-       int i = 0;
+  int i = 0;
 
-       while (i++ < utxt->undo_pos) printf("%d: %d %c\n", i, utxt->buf[i], utxt->buf[i]);
+  while (i++ < utxt->undo_pos)
+    printf("%d: %d %c\n", i, utxt->buf[i], utxt->buf[i]);
 }
 
 /* Note: this function is outdated and must be updated if needed for future use */
 void txt_print_undo(Text *text)
 {
-       int i = 0;
-       int op;
-       const char *ops;
-       int linep, charp;
-
-       dump_buffer(text);
-
-       printf("---< Undo Buffer >---\n");
-
-       printf("UndoPosition is %d\n", utxt->pos);
-
-       while (i <= utxt->pos) {
-               op = utxt->buf[i];
-
-               if (op == UNDO_INSERT_1) {
-                       ops = "Insert ascii ";
-               }
-               else if (op == UNDO_INSERT_2) {
-                       ops = "Insert 2 bytes ";
-               }
-               else if (op == UNDO_INSERT_3) {
-                       ops = "Insert 3 bytes ";
-               }
-               else if (op == UNDO_INSERT_4) {
-                       ops = "Insert unicode ";
-               }
-               else if (op == UNDO_BS_1) {
-                       ops = "Backspace for ascii ";
-               }
-               else if (op == UNDO_BS_2) {
-                       ops = "Backspace for 2 bytes ";
-               }
-               else if (op == UNDO_BS_3) {
-                       ops = "Backspace for 3 bytes ";
-               }
-               else if (op == UNDO_BS_4) {
-                       ops = "Backspace for unicode ";
-               }
-               else if (op == UNDO_DEL_1) {
-                       ops = "Delete ascii ";
-               }
-               else if (op == UNDO_DEL_2) {
-                       ops = "Delete 2 bytes ";
-               }
-               else if (op == UNDO_DEL_3) {
-                       ops = "Delete 3 bytes ";
-               }
-               else if (op == UNDO_DEL_4) {
-                       ops = "Delete unicode ";
-               }
-               else if (op == UNDO_DBLOCK) {
-                       ops = "Delete text block";
-               }
-               else if (op == UNDO_IBLOCK) {
-                       ops = "Insert text block";
-               }
-               else if (op == UNDO_INDENT) {
-                       ops = "Indent ";
-               }
-               else if (op == UNDO_UNINDENT) {
-                       ops = "Unindent ";
-               }
-               else if (op == UNDO_COMMENT) {
-                       ops = "Comment ";
-               }
-               else if (op == UNDO_UNCOMMENT) {
-                       ops = "Uncomment ";
-               }
-               else {
-                       ops = "Unknown";
-               }
-
-               printf("Op (%o) at %d = %s", op, i, ops);
-               if (op >= UNDO_INSERT_1 && op <= UNDO_DEL_4) {
-                       i++;
-                       printf(" - Char is ");
-                       switch (op) {
-                               case UNDO_INSERT_1: case UNDO_BS_1: case UNDO_DEL_1:
-                                       printf("%c", utxt->buf[i]);
-                                       i++;
-                                       break;
-                               case UNDO_INSERT_2: case UNDO_BS_2: case UNDO_DEL_2:
-                                       printf("%c%c", utxt->buf[i], utxt->buf[i + 1]);
-                                       i += 2;
-                                       break;
-                               case UNDO_INSERT_3: case UNDO_BS_3: case UNDO_DEL_3:
-                                       printf("%c%c%c", utxt->buf[i], utxt->buf[i + 1], utxt->buf[i + 2]);
-                                       i += 3;
-                                       break;
-                               case UNDO_INSERT_4: case UNDO_BS_4: case UNDO_DEL_4:
-                               {
-                                       unsigned int uc;
-                                       char c[BLI_UTF8_MAX + 1];
-                                       size_t c_len;
-                                       uc = utxt->buf[i]; i++;
-                                       uc = uc + (utxt->buf[i] << 8); i++;
-                                       uc = uc + (utxt->buf[i] << 16); i++;
-                                       uc = uc + (utxt->buf[i] << 24); i++;
-                                       c_len = BLI_str_utf8_from_unicode(uc, c);
-                                       c[c_len] = '\0';
-                                       puts(c);
-                                       break;
-                               }
-                       }
-               }
-               else if (op == UNDO_DBLOCK || op == UNDO_IBLOCK) {
-                       i++;
-
-                       linep = utxt->buf[i]; i++;
-                       linep = linep + (utxt->buf[i] << 8); i++;
-                       linep = linep + (utxt->buf[i] << 16); i++;
-                       linep = linep + (utxt->buf[i] << 24); i++;
-
-                       printf(" (length %d) <", linep);
-
-                       while (linep > 0) {
-                               putchar(utxt->buf[i]);
-                               linep--; i++;
-                       }
-
-                       linep = utxt->buf[i]; i++;
-                       linep = linep + (utxt->buf[i] << 8); i++;
-                       linep = linep + (utxt->buf[i] << 16); i++;
-                       linep = linep + (utxt->buf[i] << 24); i++;
-                       printf("> (%d)", linep);
-               }
-               else if (op == UNDO_INDENT || op == UNDO_UNINDENT) {
-                       i++;
-
-                       charp = utxt->buf[i]; i++;
-                       charp = charp + (utxt->buf[i] << 8); i++;
-
-                       linep = utxt->buf[i]; i++;
-                       linep = linep + (utxt->buf[i] << 8); i++;
-                       linep = linep + (utxt->buf[i] << 16); i++;
-                       linep = linep + (utxt->buf[i] << 24); i++;
-
-                       printf("to <%d, %d> ", linep, charp);
-
-                       charp = utxt->buf[i]; i++;
-                       charp = charp + (utxt->buf[i] << 8); i++;
-
-                       linep = utxt->buf[i]; i++;
-                       linep = linep + (utxt->buf[i] << 8); i++;
-                       linep = linep + (utxt->buf[i] << 16); i++;
-                       linep = linep + (utxt->buf[i] << 24); i++;
-
-                       printf("from <%d, %d>", linep, charp);
-               }
-
-               printf(" %d\n",  i);
-               i++;
-       }
+  int i = 0;
+  int op;
+  const char *ops;
+  int linep, charp;
+
+  dump_buffer(text);
+
+  printf("---< Undo Buffer >---\n");
+
+  printf("UndoPosition is %d\n", utxt->pos);
+
+  while (i <= utxt->pos) {
+    op = utxt->buf[i];
+
+    if (op == UNDO_INSERT_1) {
+      ops = "Insert ascii ";
+    }
+    else if (op == UNDO_INSERT_2) {
+      ops = "Insert 2 bytes ";
+    }
+    else if (op == UNDO_INSERT_3) {
+      ops = "Insert 3 bytes ";
+    }
+    else if (op == UNDO_INSERT_4) {
+      ops = "Insert unicode ";
+    }
+    else if (op == UNDO_BS_1) {
+      ops = "Backspace for ascii ";
+    }
+    else if (op == UNDO_BS_2) {
+      ops = "Backspace for 2 bytes ";
+    }
+    else if (op == UNDO_BS_3) {
+      ops = "Backspace for 3 bytes ";
+    }
+    else if (op == UNDO_BS_4) {
+      ops = "Backspace for unicode ";
+    }
+    else if (op == UNDO_DEL_1) {
+      ops = "Delete ascii ";
+    }
+    else if (op == UNDO_DEL_2) {
+      ops = "Delete 2 bytes ";
+    }
+    else if (op == UNDO_DEL_3) {
+      ops = "Delete 3 bytes ";
+    }
+    else if (op == UNDO_DEL_4) {
+      ops = "Delete unicode ";
+    }
+    else if (op == UNDO_DBLOCK) {
+      ops = "Delete text block";
+    }
+    else if (op == UNDO_IBLOCK) {
+      ops = "Insert text block";
+    }
+    else if (op == UNDO_INDENT) {
+      ops = "Indent ";
+    }
+    else if (op == UNDO_UNINDENT) {
+      ops = "Unindent ";
+    }
+    else if (op == UNDO_COMMENT) {
+      ops = "Comment ";
+    }
+    else if (op == UNDO_UNCOMMENT) {
+      ops = "Uncomment ";
+    }
+    else {
+      ops = "Unknown";
+    }
+
+    printf("Op (%o) at %d = %s", op, i, ops);
+    if (op >= UNDO_INSERT_1 && op <= UNDO_DEL_4) {
+      i++;
+      printf(" - Char is ");
+      switch (op) {
+        case UNDO_INSERT_1:
+        case UNDO_BS_1:
+        case UNDO_DEL_1:
+          printf("%c", utxt->buf[i]);
+          i++;
+          break;
+        case UNDO_INSERT_2:
+        case UNDO_BS_2:
+        case UNDO_DEL_2:
+          printf("%c%c", utxt->buf[i], utxt->buf[i + 1]);
+          i += 2;
+          break;
+        case UNDO_INSERT_3:
+        case UNDO_BS_3:
+        case UNDO_DEL_3:
+          printf("%c%c%c", utxt->buf[i], utxt->buf[i + 1], utxt->buf[i + 2]);
+          i += 3;
+          break;
+        case UNDO_INSERT_4:
+        case UNDO_BS_4:
+        case UNDO_DEL_4: {
+          unsigned int uc;
+          char c[BLI_UTF8_MAX + 1];
+          size_t c_len;
+          uc = utxt->buf[i];
+          i++;
+          uc = uc + (utxt->buf[i] << 8);
+          i++;
+          uc = uc + (utxt->buf[i] << 16);
+          i++;
+          uc = uc + (utxt->buf[i] << 24);
+          i++;
+          c_len = BLI_str_utf8_from_unicode(uc, c);
+          c[c_len] = '\0';
+          puts(c);
+          break;
+        }
+      }
+    }
+    else if (op == UNDO_DBLOCK || op == UNDO_IBLOCK) {
+      i++;
+
+      linep = utxt->buf[i];
+      i++;
+      linep = linep + (utxt->buf[i] << 8);
+      i++;
+      linep = linep + (utxt->buf[i] << 16);
+      i++;
+      linep = linep + (utxt->buf[i] << 24);
+      i++;
+
+      printf(" (length %d) <", linep);
+
+      while (linep > 0) {
+        putchar(utxt->buf[i]);
+        linep--;
+        i++;
+      }
+
+      linep = utxt->buf[i];
+      i++;
+      linep = linep + (utxt->buf[i] << 8);
+      i++;
+      linep = linep + (utxt->buf[i] << 16);
+      i++;
+      linep = linep + (utxt->buf[i] << 24);
+      i++;
+      printf("> (%d)", linep);
+    }
+    else if (op == UNDO_INDENT || op == UNDO_UNINDENT) {
+      i++;
+
+      charp = utxt->buf[i];
+      i++;
+      charp = charp + (utxt->buf[i] << 8);
+      i++;
+
+      linep = utxt->buf[i];
+      i++;
+      linep = linep + (utxt->buf[i] << 8);
+      i++;
+      linep = linep + (utxt->buf[i] << 16);
+      i++;
+      linep = linep + (utxt->buf[i] << 24);
+      i++;
+
+      printf("to <%d, %d> ", linep, charp);
+
+      charp = utxt->buf[i];
+      i++;
+      charp = charp + (utxt->buf[i] << 8);
+      i++;
+
+      linep = utxt->buf[i];
+      i++;
+      linep = linep + (utxt->buf[i] << 8);
+      i++;
+      linep = linep + (utxt->buf[i] << 16);
+      i++;
+      linep = linep + (utxt->buf[i] << 24);
+      i++;
+
+      printf("from <%d, %d>", linep, charp);
+    }
+
+    printf(" %d\n", i);
+    i++;
+  }
 }
 #endif
 
 static void txt_undo_store_uint16(char *undo_buf, int *undo_pos, unsigned short value)
 {
-       undo_buf[*undo_pos] = (value) & 0xff;
-       (*undo_pos)++;
-       undo_buf[*undo_pos] = (value >> 8) & 0xff;
-       (*undo_pos)++;
+  undo_buf[*undo_pos] = (value)&0xff;
+  (*undo_pos)++;
+  undo_buf[*undo_pos] = (value >> 8) & 0xff;
+  (*undo_pos)++;
 }
 
 static void txt_undo_store_uint32(char *undo_buf, int *undo_pos, unsigned int value)
 {
-       undo_buf[*undo_pos] = (value) & 0xff;
-       (*undo_pos)++;
-       undo_buf[*undo_pos] = (value >> 8) & 0xff;
-       (*undo_pos)++;
-       undo_buf[*undo_pos] = (value >> 16) & 0xff;
-       (*undo_pos)++;
-       undo_buf[*undo_pos] = (value >> 24) & 0xff;
-       (*undo_pos)++;
+  undo_buf[*undo_pos] = (value)&0xff;
+  (*undo_pos)++;
+  undo_buf[*undo_pos] = (value >> 8) & 0xff;
+  (*undo_pos)++;
+  undo_buf[*undo_pos] = (value >> 16) & 0xff;
+  (*undo_pos)++;
+  undo_buf[*undo_pos] = (value >> 24) & 0xff;
+  (*undo_pos)++;
 }
 
 /* store the cur cursor to the undo buffer (6 bytes)*/
 static void txt_undo_store_cur(Text *text, TextUndoBuf *utxt)
 {
-       txt_undo_store_uint16(utxt->buf, &utxt->pos, text->curc);
-       txt_undo_store_uint32(utxt->buf, &utxt->pos, txt_get_span(text->lines.first, text->curl));
+  txt_undo_store_uint16(utxt->buf, &utxt->pos, text->curc);
+  txt_undo_store_uint32(utxt->buf, &utxt->pos, txt_get_span(text->lines.first, text->curl));
 }
 
 /* store the sel cursor to the undo buffer (6 bytes) */
 static void txt_undo_store_sel(Text *text, TextUndoBuf *utxt)
 {
-       txt_undo_store_uint16(utxt->buf, &utxt->pos, text->selc);
-       txt_undo_store_uint32(utxt->buf, &utxt->pos, txt_get_span(text->lines.first, text->sell));
+  txt_undo_store_uint16(utxt->buf, &utxt->pos, text->selc);
+  txt_undo_store_uint32(utxt->buf, &utxt->pos, txt_get_span(text->lines.first, text->sell));
 }
 
 /* store both cursors to the undo buffer (12 bytes) */
 static void txt_undo_store_cursors(Text *text, TextUndoBuf *utxt)
 {
-       txt_undo_store_cur(text, utxt);
-       txt_undo_store_sel(text, utxt);
+  txt_undo_store_cur(text, utxt);
+  txt_undo_store_sel(text, utxt);
 }
 
 /* store an operator along with a block of data */
 static void txt_undo_add_blockop(Text *text, TextUndoBuf *utxt, int op, const char *buf)
 {
-       unsigned int length = strlen(buf);
-
-       if (!max_undo_test(utxt, 2 + 12 + 4 + length + 4 + 1)) {
-               return;
-       }
-       /* 2 bytes */
-       utxt->pos++;
-       utxt->buf[utxt->pos] = op;
-       utxt->pos++;
-       /* 12 bytes */
-       txt_undo_store_cursors(text, utxt);
-       /* 4 bytes */
-       txt_undo_store_uint32(utxt->buf, &utxt->pos, length);
-       /* 'length' bytes */
-       memcpy(utxt->buf + utxt->pos, buf, length);
-       utxt->pos += length;
-       /* 4 bytes */
-       txt_undo_store_uint32(utxt->buf, &utxt->pos, length);
-       /* 1 byte */
-       utxt->buf[utxt->pos] = op;
-
-       txt_undo_end(text, utxt);
+  unsigned int length = strlen(buf);
+
+  if (!max_undo_test(utxt, 2 + 12 + 4 + length + 4 + 1)) {
+    return;
+  }
+  /* 2 bytes */
+  utxt->pos++;
+  utxt->buf[utxt->pos] = op;
+  utxt->pos++;
+  /* 12 bytes */
+  txt_undo_store_cursors(text, utxt);
+  /* 4 bytes */
+  txt_undo_store_uint32(utxt->buf, &utxt->pos, length);
+  /* 'length' bytes */
+  memcpy(utxt->buf + utxt->pos, buf, length);
+  utxt->pos += length;
+  /* 4 bytes */
+  txt_undo_store_uint32(utxt->buf, &utxt->pos, length);
+  /* 1 byte */
+  utxt->buf[utxt->pos] = op;
+
+  txt_undo_end(text, utxt);
 }
 
 /* store a regular operator */
 void txt_undo_add_op(Text *text, TextUndoBuf *utxt, int op)
 {
-       if (!max_undo_test(utxt, 2 + 12 + 1)) {
-               return;
-       }
+  if (!max_undo_test(utxt, 2 + 12 + 1)) {
+    return;
+  }
 
-       /* 2 bytes */
-       utxt->pos++;
-       utxt->buf[utxt->pos] = op;
-       utxt->pos++;
-       /* 12 bytes */
-       txt_undo_store_cursors(text, utxt);
-       /* 1 byte */
-       utxt->buf[utxt->pos] = op;
+  /* 2 bytes */
+  utxt->pos++;
+  utxt->buf[utxt->pos] = op;
+  utxt->pos++;
+  /* 12 bytes */
+  txt_undo_store_cursors(text, utxt);
+  /* 1 byte */
+  utxt->buf[utxt->pos] = op;
 
-       txt_undo_end(text, utxt);
+  txt_undo_end(text, utxt);
 }
 
 /* store an operator for a single character */
 static void txt_undo_add_charop(Text *text, TextUndoBuf *utxt, int op_start, unsigned int c)
 {
-       char utf8[BLI_UTF8_MAX];
-       size_t i, utf8_size = BLI_str_utf8_from_unicode(c, utf8);
-
-       if (utf8_size < 4 && 0) {
-               if (!max_undo_test(utxt, 2 + 6 + utf8_size + 1)) {
-                       return;
-               }
-               /* 2 bytes */
-               utxt->pos++;
-               utxt->buf[utxt->pos] = op_start + utf8_size - 1;
-               utxt->pos++;
-               /* 6 bytes */
-               txt_undo_store_cur(text, utxt);
-               /* 'utf8_size' bytes */
-               for (i = 0; i < utf8_size; i++) {
-                       utxt->buf[utxt->pos] = utf8[i];
-                       utxt->pos++;
-               }
-               /* 1 byte */
-               utxt->buf[utxt->pos] = op_start + utf8_size - 1;
-       }
-       else {
-               if (!max_undo_test(utxt, 2 + 6 + 4 + 1)) {
-                       return;
-               }
-               /* 2 bytes */
-               utxt->pos++;
-               utxt->buf[utxt->pos] = op_start + 3;
-               utxt->pos++;
-               /* 6 bytes */
-               txt_undo_store_cur(text, utxt);
-               /* 4 bytes */
-               txt_undo_store_uint32(utxt->buf, &utxt->pos, c);
-               /* 1 byte */
-               utxt->buf[utxt->pos] = op_start + 3;
-       }
-
-       txt_undo_end(text, utxt);
+  char utf8[BLI_UTF8_MAX];
+  size_t i, utf8_size = BLI_str_utf8_from_unicode(c, utf8);
+
+  if (utf8_size < 4 && 0) {
+    if (!max_undo_test(utxt, 2 + 6 + utf8_size + 1)) {
+      return;
+    }
+    /* 2 bytes */
+    utxt->pos++;
+    utxt->buf[utxt->pos] = op_start + utf8_size - 1;
+    utxt->pos++;
+    /* 6 bytes */
+    txt_undo_store_cur(text, utxt);
+    /* 'utf8_size' bytes */
+    for (i = 0; i < utf8_size; i++) {
+      utxt->buf[utxt->pos] = utf8[i];
+      utxt->pos++;
+    }
+    /* 1 byte */
+    utxt->buf[utxt->pos] = op_start + utf8_size - 1;
+  }
+  else {
+    if (!max_undo_test(utxt, 2 + 6 + 4 + 1)) {
+      return;
+    }
+    /* 2 bytes */
+    utxt->pos++;
+    utxt->buf[utxt->pos] = op_start + 3;
+    utxt->pos++;
+    /* 6 bytes */
+    txt_undo_store_cur(text, utxt);
+    /* 4 bytes */
+    txt_undo_store_uint32(utxt->buf, &utxt->pos, c);
+    /* 1 byte */
+    utxt->buf[utxt->pos] = op_start + 3;
+  }
+
+  txt_undo_end(text, utxt);
 }
 
 /* extends Link */
 struct LinkInt {
-       struct LinkInt *next, *prev;
-       int value;
+  struct LinkInt *next, *prev;
+  int value;
 };
 
 /**
  * UnindentLines points to a #ListBase composed of #LinkInt elements, listing the numbers
  * of the lines that should not be indented back.
  */
-static void txt_undo_add_unprefix_op(
-        Text *text, TextUndoBuf *utxt, char undo_op,
-        const ListBase *line_index_mask, const int line_index_mask_len)
-{
-       struct LinkInt *idata;
-
-       BLI_assert(BLI_listbase_count(line_index_mask) == line_index_mask_len);
-
-       /* OP byte + UInt32 count + counted UInt32 line numbers + UInt32 count + 12-bytes selection + OP byte */
-       if (!max_undo_test(utxt, 2 + 4 + (line_index_mask_len * 4) + 4 + 12 + 1)) {
-               return;
-       }
-
-       /* 2 bytes */
-       utxt->pos++;
-       utxt->buf[utxt->pos] = undo_op;
-       utxt->pos++;
-       /* Adding number of line numbers to read
-        * 4 bytes */
-       txt_undo_store_uint32(utxt->buf, &utxt->pos, line_index_mask_len);
-
-       /* Adding linenumbers of lines that shall not be indented if undoing.
-        * 'line_index_mask_len * 4' bytes */
-       for (idata = line_index_mask->first; idata; idata = idata->next) {
-               txt_undo_store_uint32(utxt->buf, &utxt->pos, idata->value);
-       }
-
-       /* Adding number of line numbers to read again.
-        * 4 bytes */
-       txt_undo_store_uint32(utxt->buf, &utxt->pos, line_index_mask_len);
-       /* Adding current selection.
-        * 12 bytes */
-       txt_undo_store_cursors(text, utxt);
-       /* Closing with OP (same as above).
-        * 1 byte */
-       utxt->buf[utxt->pos] = undo_op;
-       /* Marking as last undo operation */
-       txt_undo_end(text, utxt);
+static void txt_undo_add_unprefix_op(Text *text,
+                                     TextUndoBuf *utxt,
+                                     char undo_op,
+                                     const ListBase *line_index_mask,
+                                     const int line_index_mask_len)
+{
+  struct LinkInt *idata;
+
+  BLI_assert(BLI_listbase_count(line_index_mask) == line_index_mask_len);
+
+  /* OP byte + UInt32 count + counted UInt32 line numbers + UInt32 count + 12-bytes selection + OP byte */
+  if (!max_undo_test(utxt, 2 + 4 + (line_index_mask_len * 4) + 4 + 12 + 1)) {
+    return;
+  }
+
+  /* 2 bytes */
+  utxt->pos++;
+  utxt->buf[utxt->pos] = undo_op;
+  utxt->pos++;
+  /* Adding number of line numbers to read
+   * 4 bytes */
+  txt_undo_store_uint32(utxt->buf, &utxt->pos, line_index_mask_len);
+
+  /* Adding linenumbers of lines that shall not be indented if undoing.
+   * 'line_index_mask_len * 4' bytes */
+  for (idata = line_index_mask->first; idata; idata = idata->next) {
+    txt_undo_store_uint32(utxt->buf, &utxt->pos, idata->value);
+  }
+
+  /* Adding number of line numbers to read again.
+   * 4 bytes */
+  txt_undo_store_uint32(utxt->buf, &utxt->pos, line_index_mask_len);
+  /* Adding current selection.
+   * 12 bytes */
+  txt_undo_store_cursors(text, utxt);
+  /* Closing with OP (same as above).
+   * 1 byte */
+  utxt->buf[utxt->pos] = undo_op;
+  /* Marking as last undo operation */
+  txt_undo_end(text, utxt);
 }
 
 static unsigned short txt_undo_read_uint16(const char *undo_buf, int *undo_pos)
 {
-       unsigned short val;
-       val = undo_buf[*undo_pos]; (*undo_pos)--;
-       val = (val << 8) + undo_buf[*undo_pos]; (*undo_pos)--;
-       return val;
+  unsigned short val;
+  val = undo_buf[*undo_pos];
+  (*undo_pos)--;
+  val = (val << 8) + undo_buf[*undo_pos];
+  (*undo_pos)--;
+  return val;
 }
 
 static unsigned int txt_undo_read_uint32(const char *undo_buf, int *undo_pos)
 {
-       unsigned int val;
-       val = undo_buf[*undo_pos]; (*undo_pos)--;
-       val = (val << 8) + undo_buf[*undo_pos]; (*undo_pos)--;
-       val = (val << 8) + undo_buf[*undo_pos]; (*undo_pos)--;
-       val = (val << 8) + undo_buf[*undo_pos]; (*undo_pos)--;
-       return val;
+  unsigned int val;
+  val = undo_buf[*undo_pos];
+  (*undo_pos)--;
+  val = (val << 8) + undo_buf[*undo_pos];
+  (*undo_pos)--;
+  val = (val << 8) + undo_buf[*undo_pos];
+  (*undo_pos)--;
+  val = (val << 8) + undo_buf[*undo_pos];
+  (*undo_pos)--;
+  return val;
 }
 
 /* read the cur cursor from the undo buffer */
-static void txt_undo_read_cur(const char *undo_buf, int *undo_pos, unsigned int *curln, unsigned short *curc)
+static void txt_undo_read_cur(const char *undo_buf,
+                              int *undo_pos,
+                              unsigned int *curln,
+                              unsigned short *curc)
 {
-       *curln = txt_undo_read_uint32(undo_buf, undo_pos);
-       *curc  = txt_undo_read_uint16(undo_buf, undo_pos);
+  *curln = txt_undo_read_uint32(undo_buf, undo_pos);
+  *curc = txt_undo_read_uint16(undo_buf, undo_pos);
 }
 
 /* read the sel cursor from the undo buffer */
-static void txt_undo_read_sel(const char *undo_buf, int *undo_pos, unsigned int *selln, unsigned short *selc)
+static void txt_undo_read_sel(const char *undo_buf,
+                              int *undo_pos,
+                              unsigned int *selln,
+                              unsigned short *selc)
 {
-       *selln = txt_undo_read_uint32(undo_buf, undo_pos);
-       *selc  = txt_undo_read_uint16(undo_buf, undo_pos);
+  *selln = txt_undo_read_uint32(undo_buf, undo_pos);
+  *selc = txt_undo_read_uint16(undo_buf, undo_pos);
 }
 
 /* read both cursors from the undo buffer */
-static void txt_undo_read_cursors(const char *undo_buf, int *undo_pos,
-                                  unsigned int *curln, unsigned short *curc,
-                                  unsigned int *selln, unsigned short *selc)
+static void txt_undo_read_cursors(const char *undo_buf,
+                                  int *undo_pos,
+                                  unsigned int *curln,
+                                  unsigned short *curc,
+                                  unsigned int *selln,
+                                  unsigned short *selc)
 {
-       txt_undo_read_sel(undo_buf, undo_pos, selln, selc);
-       txt_undo_read_cur(undo_buf, undo_pos, curln, curc);
+  txt_undo_read_sel(undo_buf, undo_pos, selln, selc);
+  txt_undo_read_cur(undo_buf, undo_pos, curln, curc);
 }
 
 static unsigned int txt_undo_read_unicode(const char *undo_buf, int *undo_pos, short bytes)
 {
-       unsigned int unicode;
-       char utf8[BLI_UTF8_MAX + 1];
-
-       switch (bytes) {
-               case 1: /* ascii */
-                       unicode = undo_buf[*undo_pos]; (*undo_pos)--;
-                       break;
-               case 2: /* 2-byte symbol */
-                       utf8[2] = '\0';
-                       utf8[1] = undo_buf[*undo_pos]; (*undo_pos)--;
-                       utf8[0] = undo_buf[*undo_pos]; (*undo_pos)--;
-                       unicode = BLI_str_utf8_as_unicode(utf8);
-                       break;
-               case 3: /* 3-byte symbol */
-                       utf8[3] = '\0';
-                       utf8[2] = undo_buf[*undo_pos]; (*undo_pos)--;
-                       utf8[1] = undo_buf[*undo_pos]; (*undo_pos)--;
-                       utf8[0] = undo_buf[*undo_pos]; (*undo_pos)--;
-                       unicode = BLI_str_utf8_as_unicode(utf8);
-                       break;
-               case 4: /* 32-bit unicode symbol */
-                       unicode = txt_undo_read_uint32(undo_buf, undo_pos);
-                       break;
-               default:
-                       /* should never happen */
-                       BLI_assert(0);
-                       unicode = 0;
-                       break;
-       }
-
-       return unicode;
+  unsigned int unicode;
+  char utf8[BLI_UTF8_MAX + 1];
+
+  switch (bytes) {
+    case 1: /* ascii */
+      unicode = undo_buf[*undo_pos];
+      (*undo_pos)--;
+      break;
+    case 2: /* 2-byte symbol */
+      utf8[2] = '\0';
+      utf8[1] = undo_buf[*undo_pos];
+      (*undo_pos)--;
+      utf8[0] = undo_buf[*undo_pos];
+      (*undo_pos)--;
+      unicode = BLI_str_utf8_as_unicode(utf8);
+      break;
+    case 3: /* 3-byte symbol */
+      utf8[3] = '\0';
+      utf8[2] = undo_buf[*undo_pos];
+      (*undo_pos)--;
+      utf8[1] = undo_buf[*undo_pos];
+      (*undo_pos)--;
+      utf8[0] = undo_buf[*undo_pos];
+      (*undo_pos)--;
+      unicode = BLI_str_utf8_as_unicode(utf8);
+      break;
+    case 4: /* 32-bit unicode symbol */
+      unicode = txt_undo_read_uint32(undo_buf, undo_pos);
+      break;
+    default:
+      /* should never happen */
+      BLI_assert(0);
+      unicode = 0;
+      break;
+  }
+
+  return unicode;
 }
 
 static unsigned short txt_redo_read_uint16(const char *undo_buf, int *undo_pos)
 {
-       unsigned short val;
-       val = undo_buf[*undo_pos]; (*undo_pos)++;
-       val = val + (undo_buf[*undo_pos] << 8); (*undo_pos)++;
-       return val;
+  unsigned short val;
+  val = undo_buf[*undo_pos];
+  (*undo_pos)++;
+  val = val + (undo_buf[*undo_pos] << 8);
+  (*undo_pos)++;
+  return val;
 }
 
 static unsigned int txt_redo_read_uint32(const char *undo_buf, int *undo_pos)
 {
-       unsigned int val;
-       val = undo_buf[*undo_pos]; (*undo_pos)++;
-       val = val + (undo_buf[*undo_pos] << 8); (*undo_pos)++;
-       val = val + (undo_buf[*undo_pos] << 16); (*undo_pos)++;
-       val = val + (undo_buf[*undo_pos] << 24); (*undo_pos)++;
-       return val;
+  unsigned int val;
+  val = undo_buf[*undo_pos];
+  (*undo_pos)++;
+  val = val + (undo_buf[*undo_pos] << 8);
+  (*undo_pos)++;
+  val = val + (undo_buf[*undo_pos] << 16);
+  (*undo_pos)++;
+  val = val + (undo_buf[*undo_pos] << 24);
+  (*undo_pos)++;
+  return val;
 }
 
 /* redo read cur cursor from the undo buffer */
-static void txt_redo_read_cur(const char *undo_buf, int *undo_pos, unsigned int *curln, unsigned short *curc)
+static void txt_redo_read_cur(const char *undo_buf,
+                              int *undo_pos,
+                              unsigned int *curln,
+                              unsigned short *curc)
 {
-       *curc  = txt_redo_read_uint16(undo_buf, undo_pos);
-       *curln = txt_redo_read_uint32(undo_buf, undo_pos);
+  *curc = txt_redo_read_uint16(undo_buf, undo_pos);
+  *curln = txt_redo_read_uint32(undo_buf, undo_pos);
 }
 
 /* redo read sel cursor from the undo buffer */
-static void txt_redo_read_sel(const char *undo_buf, int *undo_pos, unsigned int *selln, unsigned short *selc)
+static void txt_redo_read_sel(const char *undo_buf,
+                              int *undo_pos,
+                              unsigned int *selln,
+                              unsigned short *selc)
 {
-       *selc  = txt_redo_read_uint16(undo_buf, undo_pos);
-       *selln = txt_redo_read_uint32(undo_buf, undo_pos);
+  *selc = txt_redo_read_uint16(undo_buf, undo_pos);
+  *selln = txt_redo_read_uint32(undo_buf, undo_pos);
 }
 
 /* redo read both cursors from the undo buffer */
-static void txt_redo_read_cursors(const char *undo_buf, int *undo_pos,
-                                  unsigned int *curln, unsigned short *curc,
-                                  unsigned int *selln, unsigned short *selc)
+static void txt_redo_read_cursors(const char *undo_buf,
+                                  int *undo_pos,
+                                  unsigned int *curln,
+                                  unsigned short *curc,
+                                  unsigned int *selln,
+                                  unsigned short *selc)
 {
-       txt_redo_read_cur(undo_buf, undo_pos, curln, curc);
-       txt_redo_read_sel(undo_buf, undo_pos, selln, selc);
+  txt_redo_read_cur(undo_buf, undo_pos, curln, curc);
+  txt_redo_read_sel(undo_buf, undo_pos, selln, selc);
 }
 
 static unsigned int txt_redo_read_unicode(const char *undo_buf, int *undo_pos, short bytes)
 {
-       unsigned int unicode;
-       char utf8[BLI_UTF8_MAX + 1];
-
-       switch (bytes) {
-               case 1: /* ascii */
-                       unicode = undo_buf[*undo_pos]; (*undo_pos)++;
-                       break;
-               case 2: /* 2-byte symbol */
-                       utf8[0] = undo_buf[*undo_pos]; (*undo_pos)++;
-                       utf8[1] = undo_buf[*undo_pos]; (*undo_pos)++;
-                       utf8[2] = '\0';
-                       unicode = BLI_str_utf8_as_unicode(utf8);
-                       break;
-               case 3: /* 3-byte symbol */
-                       utf8[0] = undo_buf[*undo_pos]; (*undo_pos)++;
-                       utf8[1] = undo_buf[*undo_pos]; (*undo_pos)++;
-                       utf8[2] = undo_buf[*undo_pos]; (*undo_pos)++;
-                       utf8[3] = '\0';
-                       unicode = BLI_str_utf8_as_unicode(utf8);
-                       break;
-               case 4: /* 32-bit unicode symbol */
-                       unicode = txt_redo_read_uint32(undo_buf, undo_pos);
-                       break;
-               default:
-                       /* should never happen */
-                       BLI_assert(0);
-                       unicode = 0;
-                       break;
-       }
-
-       return unicode;
+  unsigned int unicode;
+  char utf8[BLI_UTF8_MAX + 1];
+
+  switch (bytes) {
+    case 1: /* ascii */
+      unicode = undo_buf[*undo_pos];
+      (*undo_pos)++;
+      break;
+    case 2: /* 2-byte symbol */
+      utf8[0] = undo_buf[*undo_pos];
+      (*undo_pos)++;
+      utf8[1] = undo_buf[*undo_pos];
+      (*undo_pos)++;
+      utf8[2] = '\0';
+      unicode = BLI_str_utf8_as_unicode(utf8);
+      break;
+    case 3: /* 3-byte symbol */
+      utf8[0] = undo_buf[*undo_pos];
+      (*undo_pos)++;
+      utf8[1] = undo_buf[*undo_pos];
+      (*undo_pos)++;
+      utf8[2] = undo_buf[*undo_pos];
+      (*undo_pos)++;
+      utf8[3] = '\0';
+      unicode = BLI_str_utf8_as_unicode(utf8);
+      break;
+    case 4: /* 32-bit unicode symbol */
+      unicode = txt_redo_read_uint32(undo_buf, undo_pos);
+      break;
+    default:
+      /* should never happen */
+      BLI_assert(0);
+      unicode = 0;
+      break;
+  }
+
+  return unicode;
 }
 
 void txt_do_undo(Text *text, TextUndoBuf *utxt)
 {
-       int op = utxt->buf[utxt->pos];
-       int prev_flags;
-       unsigned int linep;
-       unsigned int uni_char;
-       unsigned int curln, selln;
-       unsigned short curc, selc;
-       unsigned short charp;
-       char *buf;
+  int op = utxt->buf[utxt->pos];
+  int prev_flags;
+  unsigned int linep;
+  unsigned int uni_char;
+  unsigned int curln, selln;
+  unsigned short curc, selc;
+  unsigned short charp;
+  char *buf;
 
-       if (utxt->pos < 0) {
-               return;
-       }
-
-       utxt->pos--;
-
-       undoing = 1;
-
-       switch (op) {
-               case UNDO_INSERT_1:
-               case UNDO_INSERT_2:
-               case UNDO_INSERT_3:
-               case UNDO_INSERT_4:
-                       utxt->pos -= op - UNDO_INSERT_1 + 1;
-
-                       /* get and restore the cursors */
-                       txt_undo_read_cur(utxt->buf, &utxt->pos, &curln, &curc);
-                       txt_move_to(text, curln, curc, 0);
-                       txt_move_to(text, curln, curc, 1);
-
-                       txt_delete_char(text, utxt);
-
-                       utxt->pos--;
-                       break;
-
-               case UNDO_BS_1:
-               case UNDO_BS_2:
-               case UNDO_BS_3:
-               case UNDO_BS_4:
-                       charp = op - UNDO_BS_1 + 1;
-                       uni_char = txt_undo_read_unicode(utxt->buf, &utxt->pos, charp);
+  if (utxt->pos < 0) {
+    return;
+  }
+
+  utxt->pos--;
+
+  undoing = 1;
+
+  switch (op) {
+    case UNDO_INSERT_1:
+    case UNDO_INSERT_2:
+    case UNDO_INSERT_3:
+    case UNDO_INSERT_4:
+      utxt->pos -= op - UNDO_INSERT_1 + 1;
+
+      /* get and restore the cursors */
+      txt_undo_read_cur(utxt->buf, &utxt->pos, &curln, &curc);
+      txt_move_to(text, curln, curc, 0);
+      txt_move_to(text, curln, curc, 1);
+
+      txt_delete_char(text, utxt);
+
+      utxt->pos--;
+      break;
+
+    case UNDO_BS_1:
+    case UNDO_BS_2:
+    case UNDO_BS_3:
+    case UNDO_BS_4:
+      charp = op - UNDO_BS_1 + 1;
+      uni_char = txt_undo_read_unicode(utxt->buf, &utxt->pos, charp);
 
-                       /* get and restore the cursors */
-                       txt_undo_read_cur(utxt->buf, &utxt->pos, &curln, &curc);
-                       txt_move_to(text, curln, curc, 0);
-                       txt_move_to(text, curln, curc, 1);
-
-                       txt_add_char(text, utxt, uni_char);
-
-                       utxt->pos--;
-                       break;
-
-               case UNDO_DEL_1:
-               case UNDO_DEL_2:
-               case UNDO_DEL_3:
-               case UNDO_DEL_4:
-                       charp = op - UNDO_DEL_1 + 1;
-                       uni_char = txt_undo_read_unicode(utxt->buf, &utxt->pos, charp);
-
-                       /* get and restore the cursors */
-                       txt_undo_read_cur(utxt->buf, &utxt->pos, &curln, &curc);
-                       txt_move_to(text, curln, curc, 0);
-                       txt_move_to(text, curln, curc, 1);
-
-                       txt_add_char(text, utxt, uni_char);
-
-                       txt_move_left(text, 0);
-
-                       utxt->pos--;
-                       break;
-
-               case UNDO_DBLOCK:
-               {
-                       int i;
-                       /* length of the string in the buffer */
-                       linep = txt_undo_read_uint32(utxt->buf, &utxt->pos);
-
-                       buf = MEM_mallocN(linep + 1, "dblock buffer");
-                       for (i = 0; i < linep; i++) {
-                               buf[(linep - 1) - i] = utxt->buf[utxt->pos];
-                               utxt->pos--;
-                       }
-                       buf[i] = 0;
-
-                       /* skip over the length that was stored again */
-                       utxt->pos -= 4;
-
-                       /* Get the cursor positions */
-                       txt_undo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc);
-
-                       /* move cur to location that needs buff inserted */
-                       txt_move_to(text, curln, curc, 0);
-
-                       txt_insert_buf(text, utxt, buf);
-                       MEM_freeN(buf);
-
-                       /* restore the cursors */
-                       txt_move_to(text, curln, curc, 0);
-                       txt_move_to(text, selln, selc, 1);
-
-                       utxt->pos--;
-
-                       break;
-               }
-               case UNDO_IBLOCK:
-               {
-                       int i;
-                       /* length of the string in the buffer */
-                       linep = txt_undo_read_uint32(utxt->buf, &utxt->pos);
-
-                       /* txt_backspace_char removes utf8-characters, not bytes */
-                       buf = MEM_mallocN(linep + 1, "iblock buffer");
-                       for (i = 0; i < linep; i++) {
-                               buf[(linep - 1) - i] = utxt->buf[utxt->pos];
-                               utxt->pos--;
-                       }
-                       buf[i] = 0;
-                       linep = BLI_strlen_utf8(buf);
-                       MEM_freeN(buf);
-
-                       /* skip over the length that was stored again */
-                       utxt->pos -= 4;
-
-                       /* get and restore the cursors */
-                       txt_undo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc);
-
-                       txt_move_to(text, curln, curc, 0);
-                       txt_move_to(text, selln, selc, 1);
-
-                       if ((curln == selln) && (curc == selc)) {
-                               /* disable tabs to spaces since moving right may involve skipping multiple spaces */
-                               prev_flags = text->flags;
-                               text->flags &= ~TXT_TABSTOSPACES;
-
-                               for (i = 0; i < linep; i++)
-                                       txt_move_right(text, 1);
-
-                               text->flags = prev_flags;
-                       }
-
-                       txt_delete_selected(text, utxt);
-
-                       utxt->pos--;
-                       break;
-               }
-               case UNDO_INDENT:
-               case UNDO_COMMENT:
-               case UNDO_DUPLICATE:
-               case UNDO_MOVE_LINES_UP:
-               case UNDO_MOVE_LINES_DOWN:
-                       /* get and restore the cursors */
-                       txt_undo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc);
-                       txt_move_to(text, curln, curc, 0);
-                       txt_move_to(text, selln, selc, 1);
-
-                       if (op == UNDO_INDENT) {
-                               txt_unindent(text, utxt);
-                       }
-                       else if (op == UNDO_COMMENT) {
-                               txt_uncomment(text, utxt);
-                       }
-                       else if (op == UNDO_DUPLICATE) {
-                               txt_delete_line(text, text->curl->next);
-                       }
-                       else if (op == UNDO_MOVE_LINES_UP) {
-                               txt_move_lines(text, utxt, TXT_MOVE_LINE_DOWN);
-                       }
-                       else if (op == UNDO_MOVE_LINES_DOWN) {
-                               txt_move_lines(text, utxt, TXT_MOVE_LINE_UP);
-                       }
-
-                       utxt->pos--;
-                       break;
-               case UNDO_UNINDENT:
-               case UNDO_UNCOMMENT:
-               {
-                       void (*txt_prefix_fn)(Text *, TextUndoBuf *);
-                       void (*txt_unprefix_fn)(Text *, TextUndoBuf *);
-                       int count;
-                       int i;
-                       /* Get and restore the cursors */
-                       txt_undo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc);
-                       txt_move_to(text, curln, curc, 0);
-                       txt_move_to(text, selln, selc, 1);
-
-                       /* Un-unindent */
-                       if (op == UNDO_UNINDENT) {
-                               txt_prefix_fn = txt_indent;
-                               txt_unprefix_fn = txt_unindent;
-                       }
-                       else {
-                               txt_prefix_fn = txt_comment;
-                               txt_unprefix_fn = txt_uncomment;
-                       }
-
-                       txt_prefix_fn(text, utxt);
-
-                       /* Get the count */
-                       count = txt_undo_read_uint32(utxt->buf, &utxt->pos);
-                       /* Iterate! */
-                       txt_pop_sel(text);
-
-                       for (i = 0; i < count; i++) {
-                               txt_move_to(text, txt_undo_read_uint32(utxt->buf, &utxt->pos), 0, 0);
-                               /* Un-un-unindent/comment */
-                               txt_unprefix_fn(text, utxt);
-                       }
-                       /* Restore selection */
-                       txt_move_to(text, curln, curc, 0);
-                       txt_move_to(text, selln, selc, 1);
-                       /* Jumo over count */
-                       txt_undo_read_uint32(utxt->buf, &utxt->pos);
-                       /* Jump over closing OP byte */
-                       utxt->pos--;
-                       break;
-               }
-               default:
-                       //XXX error("Undo buffer error - resetting");
-                       utxt->pos = -1;
-
-                       break;
-       }
-
-       undoing = 0;
+      /* get and restore the cursors */
+      txt_undo_read_cur(utxt->buf, &utxt->pos, &curln, &curc);
+      txt_move_to(text, curln, curc, 0);
+      txt_move_to(text, curln, curc, 1);
+
+      txt_add_char(text, utxt, uni_char);
+
+      utxt->pos--;
+      break;
+
+    case UNDO_DEL_1:
+    case UNDO_DEL_2:
+    case UNDO_DEL_3:
+    case UNDO_DEL_4:
+      charp = op - UNDO_DEL_1 + 1;
+      uni_char = txt_undo_read_unicode(utxt->buf, &utxt->pos, charp);
+
+      /* get and restore the cursors */
+      txt_undo_read_cur(utxt->buf, &utxt->pos, &curln, &curc);
+      txt_move_to(text, curln, curc, 0);
+      txt_move_to(text, curln, curc, 1);
+
+      txt_add_char(text, utxt, uni_char);
+
+      txt_move_left(text, 0);
+
+      utxt->pos--;
+      break;
+
+    case UNDO_DBLOCK: {
+      int i;
+      /* length of the string in the buffer */
+      linep = txt_undo_read_uint32(utxt->buf, &utxt->pos);
+
+      buf = MEM_mallocN(linep + 1, "dblock buffer");
+      for (i = 0; i < linep; i++) {
+        buf[(linep - 1) - i] = utxt->buf[utxt->pos];
+        utxt->pos--;
+      }
+      buf[i] = 0;
+
+      /* skip over the length that was stored again */
+      utxt->pos -= 4;
+
+      /* Get the cursor positions */
+      txt_undo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc);
+
+      /* move cur to location that needs buff inserted */
+      txt_move_to(text, curln, curc, 0);
+
+      txt_insert_buf(text, utxt, buf);
+      MEM_freeN(buf);
+
+      /* restore the cursors */
+      txt_move_to(text, curln, curc, 0);
+      txt_move_to(text, selln, selc, 1);
+
+      utxt->pos--;
+
+      break;
+    }
+    case UNDO_IBLOCK: {
+      int i;
+      /* length of the string in the buffer */
+      linep = txt_undo_read_uint32(utxt->buf, &utxt->pos);
+
+      /* txt_backspace_char removes utf8-characters, not bytes */
+      buf = MEM_mallocN(linep + 1, "iblock buffer");
+      for (i = 0; i < linep; i++) {
+        buf[(linep - 1) - i] = utxt->buf[utxt->pos];
+        utxt->pos--;
+      }
+      buf[i] = 0;
+      linep = BLI_strlen_utf8(buf);
+      MEM_freeN(buf);
+
+      /* skip over the length that was stored again */
+      utxt->pos -= 4;
+
+      /* get and restore the cursors */
+      txt_undo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc);
+
+      txt_move_to(text, curln, curc, 0);
+      txt_move_to(text, selln, selc, 1);
+
+      if ((curln == selln) && (curc == selc)) {
+        /* disable tabs to spaces since moving right may involve skipping multiple spaces */
+        prev_flags = text->flags;
+        text->flags &= ~TXT_TABSTOSPACES;
+
+        for (i = 0; i < linep; i++) {
+          txt_move_right(text, 1);
+        }
+
+        text->flags = prev_flags;
+      }
+
+      txt_delete_selected(text, utxt);
+
+      utxt->pos--;
+      break;
+    }
+    case UNDO_INDENT:
+    case UNDO_COMMENT:
+    case UNDO_DUPLICATE:
+    case UNDO_MOVE_LINES_UP:
+    case UNDO_MOVE_LINES_DOWN:
+      /* get and restore the cursors */
+      txt_undo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc);
+      txt_move_to(text, curln, curc, 0);
+      txt_move_to(text, selln, selc, 1);
+
+      if (op == UNDO_INDENT) {
+        txt_unindent(text, utxt);
+      }
+      else if (op == UNDO_COMMENT) {
+        txt_uncomment(text, utxt);
+      }
+      else if (op == UNDO_DUPLICATE) {
+        txt_delete_line(text, text->curl->next);
+      }
+      else if (op == UNDO_MOVE_LINES_UP) {
+        txt_move_lines(text, utxt, TXT_MOVE_LINE_DOWN);
+      }
+      else if (op == UNDO_MOVE_LINES_DOWN) {
+        txt_move_lines(text, utxt, TXT_MOVE_LINE_UP);
+      }
+
+      utxt->pos--;
+      break;
+    case UNDO_UNINDENT:
+    case UNDO_UNCOMMENT: {
+      void (*txt_prefix_fn)(Text *, TextUndoBuf *);
+      void (*txt_unprefix_fn)(Text *, TextUndoBuf *);
+      int count;
+      int i;
+      /* Get and restore the cursors */
+      txt_undo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc);
+      txt_move_to(text, curln, curc, 0);
+      txt_move_to(text, selln, selc, 1);
+
+      /* Un-unindent */
+      if (op == UNDO_UNINDENT) {
+        txt_prefix_fn = txt_indent;
+        txt_unprefix_fn = txt_unindent;
+      }
+      else {
+        txt_prefix_fn = txt_comment;
+        txt_unprefix_fn = txt_uncomment;
+      }
+
+      txt_prefix_fn(text, utxt);
+
+      /* Get the count */
+      count = txt_undo_read_uint32(utxt->buf, &utxt->pos);
+      /* Iterate! */
+      txt_pop_sel(text);
+
+      for (i = 0; i < count; i++) {
+        txt_move_to(text, txt_undo_read_uint32(utxt->buf, &utxt->pos), 0, 0);
+        /* Un-un-unindent/comment */
+        txt_unprefix_fn(text, utxt);
+      }
+      /* Restore selection */
+      txt_move_to(text, curln, curc, 0);
+      txt_move_to(text, selln, selc, 1);
+      /* Jumo over count */
+      txt_undo_read_uint32(utxt->buf, &utxt->pos);
+      /* Jump over closing OP byte */
+      utxt->pos--;
+      break;
+    }
+    default:
+      //XXX error("Undo buffer error - resetting");
+      utxt->pos = -1;
+
+      break;
+  }
+
+  undoing = 0;
 }
 
 void txt_do_redo(Text *text, TextUndoBuf *utxt)
 {
-       char op;
-       char *buf;
-       unsigned int linep;
-       unsigned short charp;
-       unsigned int uni_uchar;
-       unsigned int curln, selln;
-       unsigned short curc, selc;
+  char op;
+  char *buf;
+  unsigned int linep;
+  unsigned short charp;
+  unsigned int uni_uchar;
+  unsigned int curln, selln;
+  unsigned short curc, selc;
 
-       utxt->pos++;
-       op = utxt->buf[utxt->pos];
+  utxt->pos++;
+  op = utxt->buf[utxt->pos];
 
-       if (!op) {
-               utxt->pos--;
-               return;
-       }
+  if (!op) {
+    utxt->pos--;
+    return;
+  }
 
-       undoing = 1;
+  undoing = 1;
 
-       switch (op) {
-               case UNDO_INSERT_1:
-               case UNDO_INSERT_2:
-               case UNDO_INSERT_3:
-               case UNDO_INSERT_4:
-                       utxt->pos++;
+  switch (op) {
+    case UNDO_INSERT_1:
+    case UNDO_INSERT_2:
+    case UNDO_INSERT_3:
+    case UNDO_INSERT_4:
+      utxt->pos++;
 
-                       /* get and restore the cursors */
-                       txt_redo_read_cur(utxt->buf, &utxt->pos, &curln, &curc);
-                       txt_move_to(text, curln, curc, 0);
-                       txt_move_to(text, curln, curc, 1);
+      /* get and restore the cursors */
+      txt_redo_read_cur(utxt->buf, &utxt->pos, &curln, &curc);
+      txt_move_to(text, curln, curc, 0);
+      txt_move_to(text, curln, curc, 1);
 
-                       charp = op - UNDO_INSERT_1 + 1;
-                       uni_uchar = txt_redo_read_unicode(utxt->buf, &utxt->pos, charp);
+      charp = op - UNDO_INSERT_1 + 1;
+      uni_uchar = txt_redo_read_unicode(utxt->buf, &utxt->pos, charp);
 
-                       txt_add_char(text, utxt, uni_uchar);
-                       break;
+      txt_add_char(text, utxt, uni_uchar);
+      break;
 
-               case UNDO_BS_1:
-               case UNDO_BS_2:
-               case UNDO_BS_3:
-               case UNDO_BS_4:
-                       utxt->pos++;
+    case UNDO_BS_1:
+    case UNDO_BS_2:
+    case UNDO_BS_3:
+    case UNDO_BS_4:
+      utxt->pos++;
 
-                       /* get and restore the cursors */
-                       txt_redo_read_cur(utxt->buf, &utxt->pos, &curln, &curc);
-                       txt_move_to(text, curln, curc, 0);
-                       txt_move_to(text, curln, curc, 1);
-
-                       utxt->pos += op - UNDO_BS_1 + 1;
-
-                       /* move right so we backspace the correct char */
-                       txt_move_right(text, 0);
-                       txt_backspace_char(text, utxt);
-
-                       break;
-
-               case UNDO_DEL_1:
-               case UNDO_DEL_2:
-               case UNDO_DEL_3:
-               case UNDO_DEL_4:
-                       utxt->pos++;
-
-                       /* get and restore the cursors */
-                       txt_redo_read_cur(utxt->buf, &utxt->pos, &curln, &curc);
-                       txt_move_to(text, curln, curc, 0);
-                       txt_move_to(text, curln, curc, 1);
-
-                       utxt->pos += op - UNDO_DEL_1 + 1;
-
-                       txt_delete_char(text, utxt);
-
-                       break;
-
-               case UNDO_DBLOCK:
-                       utxt->pos++;
-
-                       /* get and restore the cursors */
-                       txt_redo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc);
-                       txt_move_to(text, curln, curc, 0);
-                       txt_move_to(text, selln, selc, 1);
-
-                       /* length of the block */
-                       linep = txt_redo_read_uint32(utxt->buf, &utxt->pos);
-
-                       utxt->pos += linep;
-
-                       /* skip over the length that was stored again */
-                       utxt->pos += 4;
-
-                       txt_delete_sel(text, utxt);
-
-                       break;
-
-               case UNDO_IBLOCK:
-                       utxt->pos++;
-
-                       /* get and restore the cursors */
-                       txt_redo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc);
-                       txt_move_to(text, curln, curc, 0);
-                       txt_move_to(text, curln, curc, 1);
-
-                       /* length of the block */
-                       linep = txt_redo_read_uint32(utxt->buf, &utxt->pos);
-
-                       buf = MEM_mallocN(linep + 1, "iblock buffer");
-                       memcpy(buf, &utxt->buf[utxt->pos], linep);
-                       utxt->pos += linep;
-                       buf[linep] = 0;
-
-                       txt_insert_buf(text, utxt, buf);
-                       MEM_freeN(buf);
-
-                       /* skip over the length that was stored again */
-                       utxt->pos += 4;
-
-                       break;
-
-               case UNDO_INDENT:
-               case UNDO_COMMENT:
-               case UNDO_UNCOMMENT:
-               case UNDO_DUPLICATE:
-               case UNDO_MOVE_LINES_UP:
-               case UNDO_MOVE_LINES_DOWN:
-                       utxt->pos++;
-
-                       /* get and restore the cursors */
-                       txt_redo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc);
-                       txt_move_to(text, curln, curc, 0);
-                       txt_move_to(text, selln, selc, 1);
-
-                       if (op == UNDO_INDENT) {
-                               txt_indent(text, utxt);
-                       }
-                       else if (op == UNDO_COMMENT) {
-                               txt_comment(text, utxt);
-                       }
-                       else if (op == UNDO_UNCOMMENT) {
-                               txt_uncomment(text, utxt);
-                       }
-                       else if (op == UNDO_DUPLICATE) {
-                               txt_duplicate_line(text, utxt);
-                       }
-                       else if (op == UNDO_MOVE_LINES_UP) {
-                               /* offset the cursor by + 1 */
-                               txt_move_to(text, curln + 1, curc, 0);
-                               txt_move_to(text, selln + 1, selc, 1);
-
-                               txt_move_lines(text, utxt, TXT_MOVE_LINE_UP);
-                       }
-                       else if (op == UNDO_MOVE_LINES_DOWN) {
-                               /* offset the cursor by - 1 */
-                               txt_move_to(text, curln - 1, curc, 0);
-                               txt_move_to(text, selln - 1, selc, 1);
-
-                               txt_move_lines(text, utxt, TXT_MOVE_LINE_DOWN);
-                       }
-
-                       /* re-restore the cursors since they got moved when redoing */
-                       txt_move_to(text, curln, curc, 0);
-                       txt_move_to(text, selln, selc, 1);
-
-                       break;
-               case UNDO_UNINDENT:
-               {
-                       int count;
-                       int i;
-
-                       utxt->pos++;
-                       /* Scan all the stuff described in txt_undo_add_unindent_op */
-                       count = txt_redo_read_uint32(utxt->buf, &utxt->pos);
-                       for (i = 0; i < count; i++) {
-                               txt_redo_read_uint32(utxt->buf, &utxt->pos);
-                       }
-                       /* Count again */
-                       txt_redo_read_uint32(utxt->buf, &utxt->pos);
-                       /* Get the selection and re-unindent */
-                       txt_redo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc);
-                       txt_move_to(text, curln, curc, 0);
-                       txt_move_to(text, selln, selc, 1);
-                       txt_unindent(text, utxt);
-                       break;
-               }
-               default:
-                       //XXX error("Undo buffer error - resetting");
-                       utxt->pos = -1;
-
-                       break;
-       }
-
-       undoing = 0;
+      /* get and restore the cursors */
+      txt_redo_read_cur(utxt->buf, &utxt->pos, &curln, &curc);
+      txt_move_to(text, curln, curc, 0);
+      txt_move_to(text, curln, curc, 1);
+
+      utxt->pos += op - UNDO_BS_1 + 1;
+
+      /* move right so we backspace the correct char */
+      txt_move_right(text, 0);
+      txt_backspace_char(text, utxt);
+
+      break;
+
+    case UNDO_DEL_1:
+    case UNDO_DEL_2:
+    case UNDO_DEL_3:
+    case UNDO_DEL_4:
+      utxt->pos++;
+
+      /* get and restore the cursors */
+      txt_redo_read_cur(utxt->buf, &utxt->pos, &curln, &curc);
+      txt_move_to(text, curln, curc, 0);
+      txt_move_to(text, curln, curc, 1);
+
+      utxt->pos += op - UNDO_DEL_1 + 1;
+
+      txt_delete_char(text, utxt);
+
+      break;
+
+    case UNDO_DBLOCK:
+      utxt->pos++;
+
+      /* get and restore the cursors */
+      txt_redo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc);
+      txt_move_to(text, curln, curc, 0);
+      txt_move_to(text, selln, selc, 1);
+
+      /* length of the block */
+      linep = txt_redo_read_uint32(utxt->buf, &utxt->pos);
+
+      utxt->pos += linep;
+
+      /* skip over the length that was stored again */
+      utxt->pos += 4;
+
+      txt_delete_sel(text, utxt);
+
+      break;
+
+    case UNDO_IBLOCK:
+      utxt->pos++;
+
+      /* get and restore the cursors */
+      txt_redo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc);
+      txt_move_to(text, curln, curc, 0);
+      txt_move_to(text, curln, curc, 1);
+
+      /* length of the block */
+      linep = txt_redo_read_uint32(utxt->buf, &utxt->pos);
+
+      buf = MEM_mallocN(linep + 1, "iblock buffer");
+      memcpy(buf, &utxt->buf[utxt->pos], linep);
+      utxt->pos += linep;
+      buf[linep] = 0;
+
+      txt_insert_buf(text, utxt, buf);
+      MEM_freeN(buf);
+
+      /* skip over the length that was stored again */
+      utxt->pos += 4;
+
+      break;
+
+    case UNDO_INDENT:
+    case UNDO_COMMENT:
+    case UNDO_UNCOMMENT:
+    case UNDO_DUPLICATE:
+    case UNDO_MOVE_LINES_UP:
+    case UNDO_MOVE_LINES_DOWN:
+      utxt->pos++;
+
+      /* get and restore the cursors */
+      txt_redo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc);
+      txt_move_to(text, curln, curc, 0);
+      txt_move_to(text, selln, selc, 1);
+
+      if (op == UNDO_INDENT) {
+        txt_indent(text, utxt);
+      }
+      else if (op == UNDO_COMMENT) {
+        txt_comment(text, utxt);
+      }
+      else if (op == UNDO_UNCOMMENT) {
+        txt_uncomment(text, utxt);
+      }
+      else if (op == UNDO_DUPLICATE) {
+        txt_duplicate_line(text, utxt);
+      }
+      else if (op == UNDO_MOVE_LINES_UP) {
+        /* offset the cursor by + 1 */
+        txt_move_to(text, curln + 1, curc, 0);
+        txt_move_to(text, selln + 1, selc, 1);
+
+        txt_move_lines(text, utxt, TXT_MOVE_LINE_UP);
+      }
+      else if (op == UNDO_MOVE_LINES_DOWN) {
+        /* offset the cursor by - 1 */
+        txt_move_to(text, curln - 1, curc, 0);
+        txt_move_to(text, selln - 1, selc, 1);
+
+        txt_move_lines(text, utxt, TXT_MOVE_LINE_DOWN);
+      }
+
+      /* re-restore the cursors since they got moved when redoing */
+      txt_move_to(text, curln, curc, 0);
+      txt_move_to(text, selln, selc, 1);
+
+      break;
+    case UNDO_UNINDENT: {
+      int count;
+      int i;
+
+      utxt->pos++;
+      /* Scan all the stuff described in txt_undo_add_unindent_op */
+      count = txt_redo_read_uint32(utxt->buf, &utxt->pos);
+      for (i = 0; i < count; i++) {
+        txt_redo_read_uint32(utxt->buf, &utxt->pos);
+      }
+      /* Count again */
+      txt_redo_read_uint32(utxt->buf, &utxt->pos);
+      /* Get the selection and re-unindent */
+      txt_redo_read_cursors(utxt->buf, &utxt->pos, &curln, &curc, &selln, &selc);
+      txt_move_to(text, curln, curc, 0);
+      txt_move_to(text, selln, selc, 1);
+      txt_unindent(text, utxt);
+      break;
+    }
+    default:
+      //XXX error("Undo buffer error - resetting");
+      utxt->pos = -1;
+
+      break;
+  }
+
+  undoing = 0;
 }
 
 /**************************/
@@ -2391,192 +2653,224 @@ void txt_do_redo(Text *text, TextUndoBuf *utxt)
 
 void txt_split_curline(Text *text, TextUndoBuf *utxt)
 {
-       TextLine *ins;
-       char *left, *right;
+  TextLine *ins;
+  char *left, *right;
 
-       if (!text->curl) return;
+  if (!text->curl) {
+    return;
+  }
 
-       txt_delete_sel(text, utxt);
+  txt_delete_sel(text, utxt);
 
-       if (!undoing) txt_undo_add_charop(text, utxt, UNDO_INSERT_1, '\n');
+  if (!undoing) {
+    txt_undo_add_charop(text, utxt, UNDO_INSERT_1, '\n');
+  }
 
-       /* Make the two half strings */
+  /* Make the two half strings */
 
-       left = MEM_mallocN(text->curc + 1, "textline_string");
-       if (text->curc) memcpy(left, text->curl->line, text->curc);
-       left[text->curc] = 0;
+  left = MEM_mallocN(text->curc + 1, "textline_string");
+  if (text->curc) {
+    memcpy(left, text->curl->line, text->curc);
+  }
+  left[text->curc] = 0;
 
-       right = MEM_mallocN(text->curl->len - text->curc + 1, "textline_string");
-       memcpy(right, text->curl->line + text->curc, text->curl->len - text->curc + 1);
+  right = MEM_mallocN(text->curl->len - text->curc + 1, "textline_string");
+  memcpy(right, text->curl->line + text->curc, text->curl->len - text->curc + 1);
 
-       MEM_freeN(text->curl->line);
-       if (text->curl->format) MEM_freeN(text->curl->format);
+  MEM_freeN(text->curl->line);
+  if (text->curl->format) {
+    MEM_freeN(text->curl->format);
+  }
 
-       /* Make the new TextLine */
+  /* Make the new TextLine */
 
-       ins = MEM_mallocN(sizeof(TextLine), "textline");
-       ins->line = left;
-       ins->format = NULL;
-       ins->len = text->curc;
+  ins = MEM_mallocN(sizeof(TextLine), "textline");
+  ins->line = left;
+  ins->format = NULL;
+  ins->len = text->curc;
 
-       text->curl->line = right;
-       text->curl->format = NULL;
-       text->curl->len = text->curl->len - text->curc;
+  text->curl->line = right;
+  text->curl->format = NULL;
+  text->curl->len = text->curl->len - text->curc;
 
-       BLI_insertlinkbefore(&text->lines, text->curl, ins);
+  BLI_insertlinkbefore(&text->lines, text->curl, ins);
 
-       text->curc = 0;
+  text->curc = 0;
 
-       txt_make_dirty(text);
-       txt_clean_text(text);
+  txt_make_dirty(text);
+  txt_clean_text(text);
 
-       txt_pop_sel(text);
+  txt_pop_sel(text);
 }
 
 static void txt_delete_line(Text *text, TextLine *line)
 {
-       if (!text->curl) return;
+  if (!text->curl) {
+    return;
+  }
 
-       BLI_remlink(&text->lines, line);
+  BLI_remlink(&text->lines, line);
 
-       if (line->line) MEM_freeN(line->line);
-       if (line->format) MEM_freeN(line->format);
+  if (line->line) {
+    MEM_freeN(line->line);
+  }
+  if (line->format) {
+    MEM_freeN(line->format);
+  }
 
-       MEM_freeN(line);
+  MEM_freeN(line);
 
-       txt_make_dirty(text);
-       txt_clean_text(text);
+  txt_make_dirty(text);
+  txt_clean_text(text);
 }
 
 static void txt_combine_lines(Text *text, TextLine *linea, TextLine *lineb)
 {
-       char *tmp, *s;
-
-       if (!linea || !lineb) return;
+  char *tmp, *s;
 
+  if (!linea || !lineb) {
+    return;
+  }
 
-       tmp = MEM_mallocN(linea->len + lineb->len + 1, "textline_string");
+  tmp = MEM_mallocN(linea->len + lineb->len + 1, "textline_string");
 
-       s = tmp;
-       s += BLI_strcpy_rlen(s, linea->line);
-       s += BLI_strcpy_rlen(s, lineb->line);
-       (void)s;
+  s = tmp;
+  s += BLI_strcpy_rlen(s, linea->line);
+  s += BLI_strcpy_rlen(s, lineb->line);
+  (void)s;
 
-       make_new_line(linea, tmp);
+  make_new_line(linea, tmp);
 
-       txt_delete_line(text, lineb);
+  txt_delete_line(text, lineb);
 
-       txt_make_dirty(text);
-       txt_clean_text(text);
+  txt_make_dirty(text);
+  txt_clean_text(text);
 }
 
 void txt_duplicate_line(Text *text, TextUndoBuf *utxt)
 {
-       TextLine *textline;
+  TextLine *textline;
 
-       if (!text->curl) return;
+  if (!text->curl) {
+    return;
+  }
 
-       if (text->curl == text->sell) {
-               textline = txt_new_line(text->curl->line);
-               BLI_insertlinkafter(&text->lines, text->curl, textline);
+  if (text->curl == text->sell) {
+    textline = txt_new_line(text->curl->line);
+    BLI_insertlinkafter(&text->lines, text->curl, textline);
 
-               txt_make_dirty(text);
-               txt_clean_text(text);
+    txt_make_dirty(text);
+    txt_clean_text(text);
 
-               if (!undoing) txt_undo_add_op(text, utxt, UNDO_DUPLICATE);
-       }
+    if (!undoing) {
+      txt_undo_add_op(text, utxt, UNDO_DUPLICATE);
+    }
+  }
 }
 
 void txt_delete_char(Text *text, TextUndoBuf *utxt)
 {
-       unsigned int c = '\n';
+  unsigned int c = '\n';
 
-       if (!text->curl) return;
+  if (!text->curl) {
+    return;
+  }
 
-       if (txt_has_sel(text)) { /* deleting a selection */
-               txt_delete_sel(text, utxt);
-               txt_make_dirty(text);
-               return;
-       }
-       else if (text->curc == text->curl->len) { /* Appending two lines */
-               if (text->curl->next) {
-                       txt_combine_lines(text, text->curl, text->curl->next);
-                       txt_pop_sel(text);
-               }
-               else
-                       return;
-       }
-       else { /* Just deleting a char */
-               size_t c_len = 0;
-               c = BLI_str_utf8_as_unicode_and_size(text->curl->line + text->curc, &c_len);
+  if (txt_has_sel(text)) { /* deleting a selection */
+    txt_delete_sel(text, utxt);
+    txt_make_dirty(text);
+    return;
+  }
+  else if (text->curc == text->curl->len) { /* Appending two lines */
+    if (text->curl->next) {
+      txt_combine_lines(text, text->curl, text->curl->next);
+      txt_pop_sel(text);
+    }
+    else {
+      return;
+    }
+  }
+  else { /* Just deleting a char */
+    size_t c_len = 0;
+    c = BLI_str_utf8_as_unicode_and_size(text->curl->line + text->curc, &c_len);
 
-               memmove(text->curl->line + text->curc, text->curl->line + text->curc + c_len, text->curl->len - text->curc - c_len + 1);
+    memmove(text->curl->line + text->curc,
+            text->curl->line + text->curc + c_len,
+            text->curl->len - text->curc - c_len + 1);
 
-               text->curl->len -= c_len;
+    text->curl->len -= c_len;
 
-               txt_pop_sel(text);
-       }
+    txt_pop_sel(text);
+  }
 
-       txt_make_dirty(text);
-       txt_clean_text(text);
+  txt_make_dirty(text);
+  txt_clean_text(text);
 
-       if (!undoing) txt_undo_add_charop(text, utxt, UNDO_DEL_1, c);
+  if (!undoing) {
+    txt_undo_add_charop(text, utxt, UNDO_DEL_1, c);
+  }
 }
 
 void txt_delete_word(Text *text, TextUndoBuf *utxt)
 {
-       txt_jump_right(text, true, true);
-       txt_delete_sel(text, utxt);
-       txt_make_dirty(text);
+  txt_jump_right(text, true, true);
+  txt_delete_sel(text, utxt);
+  txt_make_dirty(text);
 }
 
 void txt_backspace_char(Text *text, TextUndoBuf *utxt)
 {
-       unsigned int c = '\n';
+  unsigned int c = '\n';
 
-       if (!text->curl) return;
+  if (!text->curl) {
+    return;
+  }
 
-       if (txt_has_sel(text)) { /* deleting a selection */
-               txt_delete_sel(text, utxt);
-               txt_make_dirty(text);
-               return;
-       }
-       else if (text->curc == 0) { /* Appending two lines */
-               if (!text->curl->prev) return;
+  if (txt_has_sel(text)) { /* deleting a selection */
+    txt_delete_sel(text, utxt);
+    txt_make_dirty(text);
+    return;
+  }
+  else if (text->curc == 0) { /* Appending two lines */
+    if (!text->curl->prev) {
+      return;
+    }
 
-               text->curl = text->curl->prev;
-               text->curc = text->curl->len;
+    text->curl = text->curl->prev;
+    text->curc = text->curl->len;
 
-               txt_combine_lines(text, text->curl, text->curl->next);
-               txt_pop_sel(text);
-       }
-       else { /* Just backspacing a char */
-               size_t c_len = 0;
-               const char *prev = BLI_str_prev_char_utf8(text->curl->line + text->curc);
-               c = BLI_str_utf8_as_unicode_and_size(prev, &c_len);
+    txt_combine_lines(text, text->curl, text->curl->next);
+    txt_pop_sel(text);
+  }
+  else { /* Just backspacing a char */
+    size_t c_len = 0;
+    const char *prev = BLI_str_prev_char_utf8(text->curl->line + text->curc);
+    c = BLI_str_utf8_as_unicode_and_size(prev, &c_len);
 
-               /* source and destination overlap, don't use memcpy() */
-               memmove(text->curl->line + text->curc - c_len,
-                       text->curl->line + text->curc,
-                       text->curl->len  - text->curc + 1);
+    /* source and destination overlap, don't use memcpy() */
+    memmove(text->curl->line + text->curc - c_len,
+            text->curl->line + text->curc,
+            text->curl->len - text->curc + 1);
 
-               text->curl->len -= c_len;
-               text->curc -= c_len;
+    text->curl->len -= c_len;
+    text->curc -= c_len;
 
-               txt_pop_sel(text);
-       }
+    txt_pop_sel(text);
+  }
 
-       txt_make_dirty(text);
-       txt_clean_text(text);
+  txt_make_dirty(text);
+  txt_clean_text(text);
 
-       if (!undoing) txt_undo_add_charop(text, utxt, UNDO_BS_1, c);
+  if (!undoing) {
+    txt_undo_add_charop(text, utxt, UNDO_BS_1, c);
+  }
 }
 
 void txt_backspace_word(Text *text, TextUndoBuf *utxt)
 {
-       txt_jump_left(text, true, true);
-       txt_delete_sel(text, utxt);
-       txt_make_dirty(text);
+  txt_jump_left(text, true, true);
+  txt_delete_sel(text, utxt);
+  txt_make_dirty(text);
 }
 
 /* Max spaces to replace a tab with, currently hardcoded to TXT_TABSIZE = 4.
@@ -2586,118 +2880,129 @@ static char tab_to_spaces[] = "    ";
 
 static void txt_convert_tab_to_spaces(Text *text, TextUndoBuf *utxt)
 {
-       /* sb aims to pad adjust the tab-width needed so that the right number of spaces
-        * is added so that the indention of the line is the right width (i.e. aligned
-        * to multiples of TXT_TABSIZE)
-        */
-       const char *sb = &tab_to_spaces[text->curc % TXT_TABSIZE];
-       txt_insert_buf(text, utxt, sb);
+  /* sb aims to pad adjust the tab-width needed so that the right number of spaces
+   * is added so that the indention of the line is the right width (i.e. aligned
+   * to multiples of TXT_TABSIZE)
+   */
+  const char *sb = &tab_to_spaces[text->curc % TXT_TABSIZE];
+  txt_insert_buf(text, utxt, sb);
 }
 
 static bool txt_add_char_intern(Text *text, TextUndoBuf *utxt, unsigned int add, bool replace_tabs)
 {
-       char *tmp, ch[BLI_UTF8_MAX];
-       size_t add_len;
+  char *tmp, ch[BLI_UTF8_MAX];
+  size_t add_len;
 
-       if (!text->curl) return 0;
+  if (!text->curl) {
+    return 0;
+  }
 
-       if (add == '\n') {
-               txt_split_curline(text, utxt);
-               return true;
-       }
+  if (add == '\n') {
+    txt_split_curline(text, utxt);
+    return true;
+  }
 
-       /* insert spaces rather than tabs */
-       if (add == '\t' && replace_tabs) {
-               txt_convert_tab_to_spaces(text, utxt);
-               return true;
-       }
+  /* insert spaces rather than tabs */
+  if (add == '\t' && replace_tabs) {
+    txt_convert_tab_to_spaces(text, utxt);
+    return true;
+  }
 
-       txt_delete_sel(text, utxt);
+  txt_delete_sel(text, utxt);
 
-       if (!undoing) txt_undo_add_charop(text, utxt, UNDO_INSERT_1, add);
+  if (!undoing) {
+    txt_undo_add_charop(text, utxt, UNDO_INSERT_1, add);
+  }
 
-       add_len = BLI_str_utf8_from_unicode(add, ch);
+  add_len = BLI_str_utf8_from_unicode(add, ch);
 
-       tmp = MEM_mallocN(text->curl->len + add_len + 1, "textline_string");
+  tmp = MEM_mallocN(text->curl->len + add_len + 1, "textline_string");
 
-       memcpy(tmp, text->curl->line, text->curc);
-       memcpy(tmp + text->curc, ch, add_len);
-       memcpy(tmp + text->curc + add_len, text->curl->line + text->curc, text->curl->len - text->curc + 1);
+  memcpy(tmp, text->curl->line, text->curc);
+  memcpy(tmp + text->curc, ch, add_len);
+  memcpy(
+      tmp + text->curc + add_len, text->curl->line + text->curc, text->curl->len - text->curc + 1);
 
-       make_new_line(text->curl, tmp);
+  make_new_line(text->curl, tmp);
 
-       text->curc += add_len;
+  text->curc += add_len;
 
-       txt_pop_sel(text);
+  txt_pop_sel(text);
 
-       txt_make_dirty(text);
-       txt_clean_text(text);
+  txt_make_dirty(text);
+  txt_clean_text(text);
 
-       return 1;
+  return 1;
 }
 
 bool txt_add_char(Text *text, TextUndoBuf *utxt, unsigned int add)
 {
-       return txt_add_char_intern(text, utxt, add, (text->flags & TXT_TABSTOSPACES) != 0);
+  return txt_add_char_intern(text, utxt, add, (text->flags & TXT_TABSTOSPACES) != 0);
 }
 
 bool txt_add_raw_char(Text *text, TextUndoBuf *utxt, unsigned int add)
 {
-       return txt_add_char_intern(text, utxt, add, 0);
+  return txt_add_char_intern(text, utxt, add, 0);
 }
 
 void txt_delete_selected(Text *text, TextUndoBuf *utxt)
 {
-       txt_delete_sel(text, utxt);
-       txt_make_dirty(text);
+  txt_delete_sel(text, utxt);
+  txt_make_dirty(text);
 }
 
 bool txt_replace_char(Text *text, TextUndoBuf *utxt, unsigned int add)
 {
-       unsigned int del;
-       size_t del_size = 0, add_size;
-       char ch[BLI_UTF8_MAX];
-
-       if (!text->curl) return false;
-
-       /* If text is selected or we're at the end of the line just use txt_add_char */
-       if (text->curc == text->curl->len || txt_has_sel(text) || add == '\n') {
-               return txt_add_char(text, utxt, add);
-       }
-
-       del = BLI_str_utf8_as_unicode_and_size(text->curl->line + text->curc, &del_size);
-       add_size = BLI_str_utf8_from_unicode(add, ch);
-
-       if (add_size > del_size) {
-               char *tmp = MEM_mallocN(text->curl->len + add_size - del_size + 1, "textline_string");
-               memcpy(tmp, text->curl->line, text->curc);
-               memcpy(tmp + text->curc + add_size, text->curl->line + text->curc + del_size, text->curl->len - text->curc - del_size + 1);
-               MEM_freeN(text->curl->line);
-               text->curl->line = tmp;
-       }
-       else if (add_size < del_size) {
-               char *tmp = text->curl->line;
-               memmove(tmp + text->curc + add_size, tmp + text->curc + del_size, text->curl->len - text->curc - del_size + 1);
-       }
-
-       memcpy(text->curl->line + text->curc, ch, add_size);
-       text->curc += add_size;
-       text->curl->len += add_size - del_size;
-
-       txt_pop_sel(text);
-       txt_make_dirty(text);
-       txt_clean_text(text);
-
-       /* Should probably create a new op for this */
-       if (!undoing) {
-               txt_undo_add_charop(text, utxt, UNDO_INSERT_1, add);
-               text->curc -= add_size;
-               txt_pop_sel(text);
-               txt_undo_add_charop(text, utxt, UNDO_DEL_1, del);
-               text->curc += add_size;
-               txt_pop_sel(text);
-       }
-       return true;
+  unsigned int del;
+  size_t del_size = 0, add_size;
+  char ch[BLI_UTF8_MAX];
+
+  if (!text->curl) {
+    return false;
+  }
+
+  /* If text is selected or we're at the end of the line just use txt_add_char */
+  if (text->curc == text->curl->len || txt_has_sel(text) || add == '\n') {
+    return txt_add_char(text, utxt, add);
+  }
+
+  del = BLI_str_utf8_as_unicode_and_size(text->curl->line + text->curc, &del_size);
+  add_size = BLI_str_utf8_from_unicode(add, ch);
+
+  if (add_size > del_size) {
+    char *tmp = MEM_mallocN(text->curl->len + add_size - del_size + 1, "textline_string");
+    memcpy(tmp, text->curl->line, text->curc);
+    memcpy(tmp + text->curc + add_size,
+           text->curl->line + text->curc + del_size,
+           text->curl->len - text->curc - del_size + 1);
+    MEM_freeN(text->curl->line);
+    text->curl->line = tmp;
+  }
+  else if (add_size < del_size) {
+    char *tmp = text->curl->line;
+    memmove(tmp + text->curc + add_size,
+            tmp + text->curc + del_size,
+            text->curl->len - text->curc - del_size + 1);
+  }
+
+  memcpy(text->curl->line + text->curc, ch, add_size);
+  text->curc += add_size;
+  text->curl->len += add_size - del_size;
+
+  txt_pop_sel(text);
+  txt_make_dirty(text);
+  txt_clean_text(text);
+
+  /* Should probably create a new op for this */
+  if (!undoing) {
+    txt_undo_add_charop(text, utxt, UNDO_INSERT_1, add);
+    text->curc -= add_size;
+    txt_pop_sel(text);
+    txt_undo_add_charop(text, utxt, UNDO_DEL_1, del);
+    text->curc += add_size;
+    txt_pop_sel(text);
+  }
+  return true;
 }
 
 /**
@@ -2707,56 +3012,64 @@ bool txt_replace_char(Text *text, TextUndoBuf *utxt, unsigned int add)
  */
 static void txt_select_prefix(Text *text, const char *add)
 {
-       int len, num, curc_old;
-       char *tmp;
+  int len, num, curc_old;
+  char *tmp;
 
-       const int indentlen = strlen(add);
+  const int indentlen = strlen(add);
 
-       BLI_assert(!ELEM(NULL, text->curl, text->sell));
+  BLI_assert(!ELEM(NULL, text->curl, text->sell));
 
-       curc_old = text->curc;
+  curc_old = text->curc;
 
-       num = 0;
-       while (true) {
+  num = 0;
+  while (true) {
 
-               /* don't indent blank lines */
-               if (text->curl->len != 0) {
-                       tmp = MEM_mallocN(text->curl->len + indentlen + 1, "textline_string");
+    /* don't indent blank lines */
+    if (text->curl->len != 0) {
+      tmp = MEM_mallocN(text->curl->len + indentlen + 1, "textline_string");
 
-                       text->curc = 0;
-                       if (text->curc) memcpy(tmp, text->curl->line, text->curc);  /* XXX never true, check prev line */
-                       memcpy(tmp + text->curc, add, indentlen);
+      text->curc = 0;
+      if (text->curc) {
+        memcpy(tmp, text->curl->line, text->curc); /* XXX never true, check prev line */
+      }
+      memcpy(tmp + text->curc, add, indentlen);
 
-                       len = text->curl->len - text->curc;
-                       if (len > 0) memcpy(tmp + text->curc + indentlen, text->curl->line + text->curc, len);
-                       tmp[text->curl->len + indentlen] = 0;
+      len = text->curl->len - text->curc;
+      if (len > 0) {
+        memcpy(tmp + text->curc + indentlen, text->curl->line + text->curc, len);
+      }
+      tmp[text->curl->len + indentlen] = 0;
 
-                       make_new_line(text->curl, tmp);
+      make_new_line(text->curl, tmp);
 
-                       text->curc += indentlen;
+      text->curc += indentlen;
 
-                       txt_make_dirty(text);
-                       txt_clean_text(text);
-               }
+      txt_make_dirty(text);
+      txt_clean_text(text);
+    }
 
-               if (text->curl == text->sell) {
-                       text->selc += indentlen;
-                       break;
-               }
-               else {
-                       text->curl = text->curl->next;
-                       num++;
-               }
-       }
-       if (!curc_old) text->curc = 0;
-       else text->curc = curc_old + indentlen;
+    if (text->curl == text->sell) {
+      text->selc += indentlen;
+      break;
+    }
+    else {
+      text->curl = text->curl->next;
+      num++;
+    }
+  }
+  if (!curc_old) {
+    text->curc = 0;
+  }
+  else {
+    text->curc = curc_old + indentlen;
+  }
 
-       while (num > 0) {
-               text->curl = text->curl->prev;
-               num--;
-       }
+  while (num > 0) {
+    text->curl = text->curl->prev;
+    num--;
+  }
 
-       /* caller must handle undo */
+  /* caller must handle undo */
 }
 
 /**
@@ -2767,225 +3080,234 @@ static void txt_select_prefix(Text *text, const char *add)
  *
  * \note caller must handle undo.
  */
-static void txt_select_unprefix(
-        Text *text, const char *remove,
-        ListBase *r_line_index_mask, int *r_line_index_mask_len)
-{
-       int num = 0;
-       const int indentlen = strlen(remove);
-       bool unindented_first = false;
-
-       int curl_span_init = 0;
-
-       BLI_assert(!ELEM(NULL, text->curl, text->sell));
-
-       BLI_listbase_clear(r_line_index_mask);
-       *r_line_index_mask_len = 0;
-
-       if (!undoing) {
-               curl_span_init = txt_get_span(text->lines.first, text->curl);
-       }
-
-       while (true) {
-               bool changed = false;
-               if (STREQLEN(text->curl->line, remove, indentlen)) {
-                       if (num == 0)
-                               unindented_first = true;
-                       text->curl->len -= indentlen;
-                       memmove(text->curl->line, text->curl->line + indentlen, text->curl->len + 1);
-                       changed = true;
-               }
-               else {
-                       if (!undoing) {
-                               /* Create list element for 0 indent line */
-                               struct LinkInt *idata = MEM_mallocN(sizeof(struct LinkInt), __func__);
-                               idata->value = curl_span_init + num;
-                               BLI_assert(idata->value == txt_get_span(text->lines.first, text->curl));
-                               BLI_addtail(r_line_index_mask, idata);
-                               (*r_line_index_mask_len) += 1;
-                       }
-               }
-
-               txt_make_dirty(text);
-               txt_clean_text(text);
-
-               if (text->curl == text->sell) {
-                       if (changed)
-                               text->selc = MAX2(text->selc - indentlen, 0);
-                       break;
-               }
-               else {
-                       text->curl = text->curl->next;
-                       num++;
-
-               }
-
-       }
-
-       if (unindented_first)
-               text->curc = MAX2(text->curc - indentlen, 0);
-
-       while (num > 0) {
-               text->curl = text->curl->prev;
-               num--;
-       }
-
-       /* caller must handle undo */
+static void txt_select_unprefix(Text *text,
+                                const char *remove,
+                                ListBase *r_line_index_mask,
+                                int *r_line_index_mask_len)
+{
+  int num = 0;
+  const int indentlen = strlen(remove);
+  bool unindented_first = false;
+
+  int curl_span_init = 0;
+
+  BLI_assert(!ELEM(NULL, text->curl, text->sell));
+
+  BLI_listbase_clear(r_line_index_mask);
+  *r_line_index_mask_len = 0;
+
+  if (!undoing) {
+    curl_span_init = txt_get_span(text->lines.first, text->curl);
+  }
+
+  while (true) {
+    bool changed = false;
+    if (STREQLEN(text->curl->line, remove, indentlen)) {
+      if (num == 0) {
+        unindented_first = true;
+      }
+      text->curl->len -= indentlen;
+      memmove(text->curl->line, text->curl->line + indentlen, text->curl->len + 1);
+      changed = true;
+    }
+    else {
+      if (!undoing) {
+        /* Create list element for 0 indent line */
+        struct LinkInt *idata = MEM_mallocN(sizeof(struct LinkInt), __func__);
+        idata->value = curl_span_init + num;
+        BLI_assert(idata->value == txt_get_span(text->lines.first, text->curl));
+        BLI_addtail(r_line_index_mask, idata);
+        (*r_line_index_mask_len) += 1;
+      }
+    }
+
+    txt_make_dirty(text);
+    txt_clean_text(text);
+
+    if (text->curl == text->sell) {
+      if (changed) {
+        text->selc = MAX2(text->selc - indentlen, 0);
+      }
+      break;
+    }
+    else {
+      text->curl = text->curl->next;
+      num++;
+    }
+  }
+
+  if (unindented_first) {
+    text->curc = MAX2(text->curc - indentlen, 0);
+  }
+
+  while (num > 0) {
+    text->curl = text->curl->prev;
+    num--;
+  }
+
+  /* caller must handle undo */
 }
 
 void txt_comment(Text *text, TextUndoBuf *utxt)
 {
-       const char *prefix = "#";
+  const char *prefix = "#";
 
-       if (ELEM(NULL, text->curl, text->sell)) {
-               return;
-       }
+  if (ELEM(NULL, text->curl, text->sell)) {
+    return;
+  }
 
-       txt_select_prefix(text, prefix);
+  txt_select_prefix(text, prefix);
 
-       if (!undoing) {
-               txt_undo_add_op(text, utxt, UNDO_COMMENT);
-       }
+  if (!undoing) {
+    txt_undo_add_op(text, utxt, UNDO_COMMENT);
+  }
 }
 
 void txt_uncomment(Text *text, TextUndoBuf *utxt)
 {
-       const char *prefix = "#";
-       ListBase line_index_mask;
-       int line_index_mask_len;
+  const char *prefix = "#";
+  ListBase line_index_mask;
+  int line_index_mask_len;
 
-       if (ELEM(NULL, text->curl, text->sell)) {
-               return;
-       }
+  if (ELEM(NULL, text->curl, text->sell)) {
+    return;
+  }
 
-       txt_select_unprefix(text, prefix, &line_index_mask, &line_index_mask_len);
+  txt_select_unprefix(text, prefix, &line_index_mask, &line_index_mask_len);
 
-       if (!undoing) {
-               txt_undo_add_unprefix_op(text, utxt, UNDO_UNCOMMENT, &line_index_mask, line_index_mask_len);
-       }
+  if (!undoing) {
+    txt_undo_add_unprefix_op(text, utxt, UNDO_UNCOMMENT, &line_index_mask, line_index_mask_len);
+  }
 
-       BLI_freelistN(&line_index_mask);
+  BLI_freelistN(&line_index_mask);
 }
 
 void txt_indent(Text *text, TextUndoBuf *utxt)
 {
-       const char *prefix = (text->flags & TXT_TABSTOSPACES) ? tab_to_spaces : "\t";
+  const char *prefix = (text->flags & TXT_TABSTOSPACES) ? tab_to_spaces : "\t";
 
-       if (ELEM(NULL, text->curl, text->sell)) {
-               return;
-       }
+  if (ELEM(NULL, text->curl, text->sell)) {
+    return;
+  }
 
-       txt_select_prefix(text, prefix);
+  txt_select_prefix(text, prefix);
 
-       if (!undoing) {
-               txt_undo_add_op(text, utxt, UNDO_INDENT);
-       }
+  if (!undoing) {
+    txt_undo_add_op(text, utxt, UNDO_INDENT);
+  }
 }
 
 void txt_unindent(Text *text, TextUndoBuf *utxt)
 {
-       const char *prefix = (text->flags & TXT_TABSTOSPACES) ? tab_to_spaces : "\t";
-       ListBase line_index_mask;
-       int line_index_mask_len;
+  const char *prefix = (text->flags & TXT_TABSTOSPACES) ? tab_to_spaces : "\t";
+  ListBase line_index_mask;
+  int line_index_mask_len;
 
-       if (ELEM(NULL, text->curl, text->sell)) {
-               return;
-       }
+  if (ELEM(NULL, text->curl, text->sell)) {
+    return;
+  }
 
-       txt_select_unprefix(text, prefix, &line_index_mask, &line_index_mask_len);
+  txt_select_unprefix(text, prefix, &line_index_mask, &line_index_mask_len);
 
-       if (!undoing) {
-               txt_undo_add_unprefix_op(text, utxt, UNDO_UNINDENT, &line_index_mask, line_index_mask_len);
-       }
+  if (!undoing) {
+    txt_undo_add_unprefix_op(text, utxt, UNDO_UNINDENT, &line_index_mask, line_index_mask_len);
+  }
 
-       BLI_freelistN(&line_index_mask);
+  BLI_freelistN(&line_index_mask);
 }
 
 void txt_move_lines(struct Text *text, TextUndoBuf *utxt, const int direction)
 {
-       TextLine *line_other;
+  TextLine *line_other;
 
-       BLI_assert(ELEM(direction, TXT_MOVE_LINE_UP, TXT_MOVE_LINE_DOWN));
+  BLI_assert(ELEM(direction, TXT_MOVE_LINE_UP, TXT_MOVE_LINE_DOWN));
 
-       if (!text->curl || !text->sell) return;
+  if (!text->curl || !text->sell) {
+    return;
+  }
 
-       txt_order_cursors(text, false);
+  txt_order_cursors(text, false);
 
-       line_other =  (direction == TXT_MOVE_LINE_DOWN) ? text->sell->next : text->curl->prev;
+  line_other = (direction == TXT_MOVE_LINE_DOWN) ? text->sell->next : text->curl->prev;
 
-       if (!line_other) return;
+  if (!line_other) {
+    return;
+  }
 
-       BLI_remlink(&text->lines, line_other);
+  BLI_remlink(&text->lines, line_other);
 
-       if (direction == TXT_MOVE_LINE_DOWN) {
-               BLI_insertlinkbefore(&text->lines, text->curl, line_other);
-       }
-       else {
-               BLI_insertlinkafter(&text->lines, text->sell, line_other);
-       }
+  if (direction == TXT_MOVE_LINE_DOWN) {
+    BLI_insertlinkbefore(&text->lines, text->curl, line_other);
+  }
+  else {
+    BLI_insertlinkafter(&text->lines, text->sell, line_other);
+  }
 
-       txt_make_dirty(text);
-       txt_clean_text(text);
+  txt_make_dirty(text);
+  txt_clean_text(text);
 
-       if (!undoing) {
-               txt_undo_add_op(text, utxt, (direction == TXT_MOVE_LINE_DOWN) ? UNDO_MOVE_LINES_DOWN : UNDO_MOVE_LINES_UP);
-       }
+  if (!undoing) {
+    txt_undo_add_op(
+        text, utxt, (direction == TXT_MOVE_LINE_DOWN) ? UNDO_MOVE_LINES_DOWN : UNDO_MOVE_LINES_UP);
+  }
 }
 
 int txt_setcurr_tab_spaces(Text *text, int space)
 {
-       int i = 0;
-       int test = 0;
-       const char *word = ":";
-       const char *comm = "#";
-       const char indent = (text->flags & TXT_TABSTOSPACES) ? ' ' : '\t';
-       static const char *back_words[] = {"return", "break", "continue", "pass", "yield", NULL};
-
-       if (!text->curl) return 0;
-
-       while (text->curl->line[i] == indent) {
-               //we only count those tabs/spaces that are before any text or before the curs;
-               if (i == text->curc) {
-                       return i;
-               }
-               else {
-                       i++;
-               }
-       }
-       if (strstr(text->curl->line, word)) {
-               /* if we find a ':' on this line, then add a tab but not if it is:
-                * 1) in a comment
-                * 2) within an identifier
-                * 3) after the cursor (text->curc), i.e. when creating space before a function def [#25414]
-                */
-               int a;
-               bool is_indent = false;
-               for (a = 0; (a < text->curc) && (text->curl->line[a] != '\0'); a++) {
-                       char ch = text->curl->line[a];
-                       if (ch == '#') {
-                               break;
-                       }
-                       else if (ch == ':') {
-                               is_indent = 1;
-                       }
-                       else if (ch != ' ' && ch != '\t') {
-                               is_indent = 0;
-                       }
-               }
-               if (is_indent) {
-                       i += space;
-               }
-       }
-
-       for (test = 0; back_words[test]; test++) {
-               /* if there are these key words then remove a tab because we are done with the block */
-               if (strstr(text->curl->line, back_words[test]) && i > 0) {
-                       if (strcspn(text->curl->line, back_words[test]) < strcspn(text->curl->line, comm)) {
-                               i -= space;
-                       }
-               }
-       }
-       return i;
+  int i = 0;
+  int test = 0;
+  const char *word = ":";
+  const char *comm = "#";
+  const char indent = (text->flags & TXT_TABSTOSPACES) ? ' ' : '\t';
+  static const char *back_words[] = {"return", "break", "continue", "pass", "yield", NULL};
+
+  if (!text->curl) {
+    return 0;
+  }
+
+  while (text->curl->line[i] == indent) {
+    //we only count those tabs/spaces that are before any text or before the curs;
+    if (i == text->curc) {
+      return i;
+    }
+    else {
+      i++;
+    }
+  }
+  if (strstr(text->curl->line, word)) {
+    /* if we find a ':' on this line, then add a tab but not if it is:
+     * 1) in a comment
+     * 2) within an identifier
+     * 3) after the cursor (text->curc), i.e. when creating space before a function def [#25414]
+     */
+    int a;
+    bool is_indent = false;
+    for (a = 0; (a < text->curc) && (text->curl->line[a] != '\0'); a++) {
+      char ch = text->curl->line[a];
+      if (ch == '#') {
+        break;
+      }
+      else if (ch == ':') {
+        is_indent = 1;
+      }
+      else if (ch != ' ' && ch != '\t') {
+        is_indent = 0;
+      }
+    }
+    if (is_indent) {
+      i += space;
+    }
+  }
+
+  for (test = 0; back_words[test]; test++) {
+    /* if there are these key words then remove a tab because we are done with the block */
+    if (strstr(text->curl->line, back_words[test]) && i > 0) {
+      if (strcspn(text->curl->line, back_words[test]) < strcspn(text->curl->line, comm)) {
+        i -= space;
+      }
+    }
+  }
+  return i;
 }
 
 /*******************************/
@@ -2994,90 +3316,120 @@ int txt_setcurr_tab_spaces(Text *text, int space)
 
 int text_check_bracket(const char ch)
 {
-       int a;
-       char opens[] = "([{";
-       char close[] = ")]}";
+  int a;
+  char opens[] = "([{";
+  char close[] = ")]}";
 
-       for (a = 0; a < (sizeof(opens) - 1); a++) {
-               if (ch == opens[a])
-                       return a + 1;
-               else if (ch == close[a])
-                       return -(a + 1);
-       }
-       return 0;
+  for (a = 0; a < (sizeof(opens) - 1); a++) {
+    if (ch == opens[a]) {
+      return a + 1;
+    }
+    else if (ch == close[a]) {
+      return -(a + 1);
+    }
+  }
+  return 0;
 }
 
 /* TODO, have a function for operators - http://docs.python.org/py3k/reference/lexical_analysis.html#operators */
 bool text_check_delim(const char ch)
 {
-       int a;
-       char delims[] = "():\"\' ~!%^&*-+=[]{};/<>|.#\t,@";
+  int a;
+  char delims[] = "():\"\' ~!%^&*-+=[]{};/<>|.#\t,@";
 
-       for (a = 0; a < (sizeof(delims) - 1); a++) {
-               if (ch == delims[a])
-                       return true;
-       }
-       return false;
+  for (a = 0; a < (sizeof(delims) - 1); a++) {
+    if (ch == delims[a]) {
+      return true;
+    }
+  }
+  return false;
 }
 
 bool text_check_digit(const char ch)
 {
-       if (ch < '0') return false;
-       if (ch <= '9') return true;
-       return false;
+  if (ch < '0') {
+    return false;
+  }
+  if (ch <= '9') {
+    return true;
+  }
+  return false;
 }
 
 bool text_check_identifier(const char ch)
 {
-       if (ch < '0') return false;
-       if (ch <= '9') return true;
-       if (ch < 'A') return false;
-       if (ch <= 'Z' || ch == '_') return true;
-       if (ch < 'a') return false;
-       if (ch <= 'z') return true;
-       return false;
+  if (ch < '0') {
+    return false;
+  }
+  if (ch <= '9') {
+    return true;
+  }
+  if (ch < 'A') {
+    return false;
+  }
+  if (ch <= 'Z' || ch == '_') {
+    return true;
+  }
+  if (ch < 'a') {
+    return false;
+  }
+  if (ch <= 'z') {
+    return true;
+  }
+  return false;
 }
 
 bool text_check_identifier_nodigit(const char ch)
 {
-       if (ch <= '9') return false;
-       if (ch < 'A') return false;
-       if (ch <= 'Z' || ch == '_') return true;
-       if (ch < 'a') return false;
-       if (ch <= 'z') return true;
-       return false;
+  if (ch <= '9') {
+    return false;
+  }
+  if (ch < 'A') {
+    return false;
+  }
+  if (ch <= 'Z' || ch == '_') {
+    return true;
+  }
+  if (ch < 'a') {
+    return false;
+  }
+  if (ch <= 'z') {
+    return true;
+  }
+  return false;
 }
 
 #ifndef WITH_PYTHON
 int text_check_identifier_unicode(const unsigned int ch)
 {
-       return (ch < 255 && text_check_identifier((unsigned int)ch));
+  return (ch < 255 && text_check_identifier((unsigned int)ch));
 }
 
 int text_check_identifier_nodigit_unicode(const unsigned int ch)
 {
-       return (ch < 255 && text_check_identifier_nodigit((char)ch));
+  return (ch < 255 && text_check_identifier_nodigit((char)ch));
 }
-#endif  /* WITH_PYTHON */
+#endif /* WITH_PYTHON */
 
 bool text_check_whitespace(const char ch)
 {
-       if (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n')
-               return true;
-       return false;
+  if (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n') {
+    return true;
+  }
+  return false;
 }
 
 int text_find_identifier_start(const char *str, int i)
 {
-       if (UNLIKELY(i <= 0)) {
-               return 0;
-       }
-
-       while (i--) {
-               if (!text_check_identifier(str[i])) {
-                       break;
-               }
-       }
-       i++;
-       return i;
+  if (UNLIKELY(i <= 0)) {
+    return 0;
+  }
+
+  while (i--) {
+    if (!text_check_identifier(str[i])) {
+      break;
+    }
+  }
+  i++;
+  return i;
 }