--- a/libinterp/corefcn/oct-tex-lexer.in.ll	Mon Sep 06 10:44:43 2021 -0700
+++ b/libinterp/corefcn/oct-tex-lexer.in.ll	Mon Sep 06 11:06:00 2021 -0700
@@ -140,7 +140,7 @@
     return FONTSIZE;
   }
 
-"\\color[rgb]" {
+"\\color[m_rgb]" {
     BEGIN (MAYBE_NUM_MODE);
     return COLOR_RGB;
   }
@@ -218,37 +218,38 @@
 {
   bool text_parser_tex::init_lexer (const std::string& s)
   {
-    if (! scanner)
-      octave_tex_lex_init (&scanner);
+    if (! m_scanner)
+      octave_tex_lex_init (&m_scanner);
 
-    if (scanner)
+    if (m_scanner)
       {
-        if (buffer_state)
+        if (m_buffer_state)
           {
-            octave_tex__delete_buffer (reinterpret_cast<YY_BUFFER_STATE> (buffer_state),
-                                       scanner);
-            buffer_state = nullptr;
+            octave_tex__delete_buffer (reinterpret_cast<YY_BUFFER_STATE> (m_buffer_state),
+                                       m_scanner);
+            m_buffer_state = nullptr;
           }
 
-        buffer_state = octave_tex__scan_bytes (s.data (), s.length (), scanner);
+        m_buffer_state = octave_tex__scan_bytes (s.data (), s.length (),
+                                                 m_scanner);
       }
 
-    return (scanner && buffer_state);
+    return (m_scanner && m_buffer_state);
   }
 
   void text_parser_tex::destroy_lexer (void)
   {
-    if (buffer_state)
+    if (m_buffer_state)
       {
-        octave_tex__delete_buffer (reinterpret_cast<YY_BUFFER_STATE> (buffer_state),
-                                   scanner);
-        buffer_state = nullptr;
+        octave_tex__delete_buffer (reinterpret_cast<YY_BUFFER_STATE> (m_buffer_state),
+                                   m_scanner);
+        m_buffer_state = nullptr;
       }
 
-    if (scanner)
+    if (m_scanner)
       {
-        octave_tex_lex_destroy (scanner);
-        scanner = nullptr;
+        octave_tex_lex_destroy (m_scanner);
+        m_scanner = nullptr;
       }
   }
 }

--- a/libinterp/corefcn/oct-tex-parser.yy	Mon Sep 06 10:44:43 2021 -0700
+++ b/libinterp/corefcn/oct-tex-parser.yy	Mon Sep 06 11:06:00 2021 -0700
@@ -39,7 +39,7 @@
 extern int octave_tex_lex (YYSTYPE *, void *);
  static void yyerror (octave::text_parser_tex& parser, const char *s);
 
-#define scanner parser.get_scanner ()
+#define m_scanner parser.get_scanner ()
 #define yyalloc octave_tex_yyalloc
 
 #if defined (HAVE_PRAGMA_GCC_DIAGNOSTIC)
@@ -57,7 +57,7 @@
 // No spaces inside the braces for the prefix definition!
 %define api.prefix {octave_tex_}
 %parse-param { octave::text_parser_tex& parser }
-%lex-param { void *scanner }
+%lex-param { void *m_scanner }
 
 %code requires {#include <string>}
 
@@ -221,10 +221,10 @@
 
     if (init_lexer (s))
       {
-        result = nullptr;
+        m_result = nullptr;
 
         if (octave_tex_parse (*this) == 0)
-          return result;
+          return m_result;
       }
 
     return new text_element_string (s);

--- a/libinterp/corefcn/text-engine.cc	Mon Sep 06 10:44:43 2021 -0700
+++ b/libinterp/corefcn/text-engine.cc	Mon Sep 06 11:06:00 2021 -0700
@@ -37,8 +37,8 @@
   {
     uint32_t code = invalid_code;
 
-    if (0 <= symbol && symbol < num_symbol_codes)
-      code = symbol_codes[symbol][0];
+    if (0 <= m_symbol && m_symbol < num_symbol_codes)
+      code = symbol_codes[m_symbol][0];
 
     return code;
   }

--- a/libinterp/corefcn/text-engine.h	Mon Sep 06 10:44:43 2021 -0700
+++ b/libinterp/corefcn/text-engine.h	Mon Sep 06 11:06:00 2021 -0700
@@ -72,19 +72,20 @@
   {
   public:
     text_element_string (const std::string& s = "")
-      : text_element (), str (s) { }
+      : text_element (), m_str (s) { }
 
     ~text_element_string (void) = default;
 
-    std::string string_value (void) const { return str; }
+    std::string string_value (void) const { return m_str; }
 
     void accept (text_processor& p);
 
   private:
-    std::string str;
+    text_element_string (const text_element_string &);
 
-  private:
-    text_element_string (const text_element_string &);
+    //--------
+
+    std::string m_str;
   };
 
   class
@@ -94,20 +95,19 @@
   public:
     enum { invalid_code = 0xFFFFFFFFU };
 
-  public:
     text_element_symbol (int sym)
-      : text_element (), symbol (sym) { }
+      : text_element (), m_symbol (sym) { }
 
     ~text_element_symbol (void) = default;
 
-    int get_symbol (void) const { return symbol; }
+    int get_symbol (void) const { return m_symbol; }
 
     uint32_t get_symbol_code (void) const;
 
     void accept (text_processor& p);
 
   private:
-    int symbol;
+    int m_symbol;
   };
 
   class
@@ -144,24 +144,26 @@
   {
   public:
     text_element_subscript (text_element *e)
-      : text_element (), elem (e) { }
+      : text_element (), m_elem (e) { }
 
     text_element_subscript (char c)
       : text_element ()
-    { elem = new text_element_string (std::string (1, c)); }
+    { m_elem = new text_element_string (std::string (1, c)); }
 
     ~text_element_subscript (void)
-    { delete elem; }
+    { delete m_elem; }
 
     void accept (text_processor& p);
 
-    text_element * get_element (void) { return elem; }
-
-  private:
-    text_element *elem;
+    text_element * get_element (void) { return m_elem; }
 
   private:
     text_element_subscript (void);
+    
+    //--------
+
+    text_element *m_elem;
+
   };
 
   class
@@ -170,24 +172,26 @@
   {
   public:
     text_element_superscript (text_element *e)
-      : text_element (), elem (e) { }
+      : text_element (), m_elem (e) { }
 
     text_element_superscript (char c)
       : text_element ()
-    { elem = new text_element_string (std::string (1, c)); }
+    { m_elem = new text_element_string (std::string (1, c)); }
 
     ~text_element_superscript (void)
-    { delete elem; }
+    { delete m_elem; }
 
     void accept (text_processor& p);
 
-    text_element * get_element (void) { return elem; }
-
-  private:
-    text_element *elem;
+    text_element * get_element (void) { return m_elem; }
 
   private:
     text_element_superscript (void);
+
+    //--------
+
+    text_element *m_elem;
+
   };
 
   class
@@ -219,19 +223,21 @@
     };
 
     text_element_fontstyle (fontstyle st)
-      : text_element (), style (st) { }
+      : text_element (), m_style (st) { }
 
     ~text_element_fontstyle (void) = default;
 
-    fontstyle get_fontstyle (void) const { return style; }
+    fontstyle get_fontstyle (void) const { return m_style; }
 
     void accept (text_processor& p);
 
   private:
-    fontstyle style;
+    text_element_fontstyle (void);
 
-  private:
-    text_element_fontstyle (void);
+    //--------
+
+    fontstyle m_style;
+
   };
 
   class
@@ -240,19 +246,21 @@
   {
   public:
     text_element_fontname (const std::string& fname)
-      : text_element (), name (fname) { }
+      : text_element (), m_name (fname) { }
 
     ~text_element_fontname (void) = default;
 
-    const std::string& get_fontname (void) const { return name; }
+    const std::string& get_fontname (void) const { return m_name; }
 
     void accept (text_processor& p);
 
   private:
-    std::string name;
+    text_element_fontname (void);
 
-  private:
-    text_element_fontname (void);
+    //--------
+
+    std::string m_name;
+
   };
 
   class
@@ -261,19 +269,21 @@
   {
   public:
     text_element_fontsize (double fsize)
-      : text_element (), size (fsize) { }
+      : text_element (), m_size (fsize) { }
 
     ~text_element_fontsize (void) = default;
 
-    double get_fontsize (void) const { return size; }
+    double get_fontsize (void) const { return m_size; }
 
     void accept (text_processor& p);
 
   private:
-    double size;
+    text_element_fontsize (void);
 
-  private:
-    text_element_fontsize (void);
+    //--------
+
+    double m_size;
+
   };
 
   class
@@ -282,17 +292,17 @@
   {
   public:
     text_element_color (double r, double g, double b)
-      : text_element (), rgb (1, 3, 0.0)
+      : text_element (), m_rgb (1, 3, 0.0)
     {
-      rgb(0) = r;
-      rgb(1) = g;
-      rgb(2) = b;
+      m_rgb(0) = r;
+      m_rgb(1) = g;
+      m_rgb(2) = b;
     }
 
     text_element_color (const std::string& cname)
-      : text_element (), rgb (1, 3, 0.0)
+      : text_element (), m_rgb (1, 3, 0.0)
     {
-#define ASSIGN_COLOR(r,g,b) { rgb(0) = r; rgb(1) = g; rgb(2) = b; }
+#define ASSIGN_COLOR(r,g,b) { m_rgb(0) = r; m_rgb(1) = g; m_rgb(2) = b; }
       if (cname == "red") ASSIGN_COLOR(1, 0, 0)
       else if (cname == "green") ASSIGN_COLOR(0, 1, 0)
       else if (cname == "yellow") ASSIGN_COLOR(1, 1, 0)
@@ -309,12 +319,12 @@
 
     ~text_element_color (void) = default;
 
-    Matrix get_color (void) { return rgb; }
+    Matrix get_color (void) { return m_rgb; }
 
     void accept (text_processor& p);
 
   private:
-    Matrix rgb;
+    Matrix m_rgb;
   };
 
   class
@@ -418,7 +428,8 @@
   {
   public:
     text_parser_tex (void)
-      : text_parser (), scanner (nullptr), buffer_state (nullptr), result (nullptr)
+      : text_parser (), m_scanner (nullptr), m_buffer_state (nullptr),
+        m_result (nullptr)
     { }
 
     ~text_parser_tex (void)
@@ -426,23 +437,24 @@
 
     text_element * parse (const std::string& s);
 
-    void * get_scanner (void) { return scanner; }
+    void * get_scanner (void) { return m_scanner; }
 
-    void set_parse_result (text_element *e) { result = e; }
+    void set_parse_result (text_element *e) { m_result = e; }
 
-    text_element * get_parse_result (void) { return result; }
+    text_element * get_parse_result (void) { return m_result; }
 
   private:
     bool init_lexer (const std::string& s);
 
     void destroy_lexer (void);
 
-  private:
-    void *scanner;
+    //--------
+
+    void *m_scanner;
 
-    void *buffer_state;
+    void *m_buffer_state;
 
-    text_element *result;
+    text_element *m_result;
   };
 
   inline text_element*