diff --git a/Source/Modules/octave.cxx b/Source/Modules/octave.cxx
index 12903166c..3ec60c31d 100644
--- a/Source/Modules/octave.cxx
+++ b/Source/Modules/octave.cxx
@@ -14,10 +14,10 @@
 #include "swigmod.h"
 #include "cparse.h"
 
-static String *global_name = 0;
-static String *op_prefix   = 0;
+static String* global_name = 0;
+static String* op_prefix   = 0;
 
-static const char *usage = "\
+static const char* usage = "\
 Octave Options (available with -octave)\n\
      -globals <name> - Set <name> used to access C global variables [default: 'cvar']\n\
                        Use '.' to load C global variables into module namespace\n\
@@ -25,39 +25,39 @@ Octave Options (available with -octave)\n\
 \n";
 
 
-class OCTAVE:public Language {
+class OCTAVE: public Language
+{
 private:
-  File *f_begin;
-  File *f_runtime;
-  File *f_header;
-  File *f_doc;
-  File *f_wrappers;
-  File *f_init;
-  File *f_initbeforefunc;
-  File *f_directors;
-  File *f_directors_h;
-  String *s_global_tab;
-  String *s_members_tab;
-  String *class_name;
+  File* f_begin;
+  File* f_runtime;
+  File* f_header;
+  File* f_doc;
+  File* f_wrappers;
+  File* f_init;
+  File* f_initbeforefunc;
+  File* f_directors;
+  File* f_directors_h;
+  String* s_global_tab;
+  String* s_members_tab;
+  String* class_name;
 
   int have_constructor;
   int have_destructor;
-  String *constructor_name;
+  String* constructor_name;
 
-  Hash *docs;
+  Hash* docs;
 
-  void Octave_begin_function(Node *n, File *f, const_String_or_char_ptr cname, const_String_or_char_ptr wname, bool dld) {
+  void Octave_begin_function(Node* n, File* f, const_String_or_char_ptr cname, const_String_or_char_ptr wname, bool dld) {
     if (dld) {
-      String *tname = texinfo_name(n, "std::string()");
+      String* tname = texinfo_name(n, "std::string()");
       Printf(f, "SWIG_DEFUN( %s, %s, %s ) {", cname, wname, tname);
-    }
-    else {
+    } else {
       Printf(f, "static octave_value_list %s (const octave_value_list& args, int nargout) {", wname);
     }
   }
 
 public:
-  OCTAVE():
+  OCTAVE() :
     f_begin(0),
     f_runtime(0),
     f_header(0),
@@ -73,10 +73,9 @@ public:
     have_constructor(0),
     have_destructor(0),
     constructor_name(0),
-    docs(0)
-  {
+    docs(0) {
     /* Add code to manage protected constructors and directors */
-    director_prot_ctor_code = NewString("");
+    director_prot_ctor_code = NewStringEmpty();
     Printv(director_prot_ctor_code,
            "if ( $comparison ) { /* subclassed */\n",
            "  $director_new \n",
@@ -89,7 +88,7 @@ public:
     docs = NewHash();
   }
 
-  virtual void main(int argc, char *argv[]) {
+  virtual void main(int argc, char* argv[]) {
     for (int i = 1; i < argc; i++) {
       if (argv[i]) {
         if (strcmp(argv[i], "-help") == 0) {
@@ -116,10 +115,12 @@ public:
       }
     }
 
-    if (!global_name)
+    if (!global_name) {
       global_name = NewString("cvar");
-    if (!op_prefix)
+    }
+    if (!op_prefix) {
       op_prefix = NewString("op_");
+    }
 
     SWIG_library_directory("octave");
     Preprocessor_define("SWIGOCTAVE 1", 0);
@@ -128,15 +129,16 @@ public:
     allow_overloading();
 
     // Octave API is C++, so output must be C++ compatibile even when wrapping C code
-    if (!cparse_cplusplus)
+    if (!cparse_cplusplus) {
       Swig_cparse_cplusplusout(1);
+    }
   }
 
-  virtual int top(Node *n) {
+  virtual int top(Node* n) {
     {
-      Node *mod = Getattr(n, "module");
+      Node* mod = Getattr(n, "module");
       if (mod) {
-        Node *options = Getattr(mod, "options");
+        Node* options = Getattr(mod, "options");
         if (options) {
           int dirprot = 0;
           if (Getattr(options, "dirprot")) {
@@ -147,29 +149,30 @@ public:
           }
           if (Getattr(options, "directors")) {
             allow_directors();
-            if (dirprot)
+            if (dirprot) {
               allow_dirprot();
+            }
           }
         }
       }
     }
 
-    String *module = Getattr(n, "name");
-    String *outfile = Getattr(n, "outfile");
+    String* module = Getattr(n, "name");
+    String* outfile = Getattr(n, "outfile");
     f_begin = NewFile(outfile, "w", SWIG_output_files());
     if (!f_begin) {
       FileErrorDisplay(outfile);
       SWIG_exit(EXIT_FAILURE);
     }
-    f_runtime = NewString("");
-    f_header = NewString("");
-    f_doc = NewString("");
-    f_wrappers = NewString("");
-    f_init = NewString("");
-    f_initbeforefunc = NewString("");
-    f_directors_h = NewString("");
-    f_directors = NewString("");
-    s_global_tab = NewString("");
+    f_runtime = NewStringEmpty();
+    f_header = NewStringEmpty();
+    f_doc = NewStringEmpty();
+    f_wrappers = NewStringEmpty();
+    f_init = NewStringEmpty();
+    f_initbeforefunc = NewStringEmpty();
+    f_directors_h = NewStringEmpty();
+    f_directors = NewStringEmpty();
+    s_global_tab = NewStringEmpty();
     Swig_register_filebyname("begin", f_begin);
     Swig_register_filebyname("runtime", f_runtime);
     Swig_register_filebyname("header", f_header);
@@ -205,19 +208,23 @@ public:
     Printf(s_global_tab, "\nstatic const struct swig_octave_member swig_globals[] = {\n");
     Printf(f_init, "static bool SWIG_init_user(octave_swig_type* module_ns)\n{\n");
 
-    if (!CPlusPlus)
-      Printf(f_header,"extern \"C\" {\n");
+    if (!CPlusPlus) {
+      Printf(f_header, "extern \"C\" {\n");
+    }
 
     Language::top(n);
 
-    if (!CPlusPlus)
-      Printf(f_header,"}\n");
+    if (!CPlusPlus) {
+      Printf(f_header, "}\n");
+    }
 
-    if (Len(docs))
+    if (Len(docs)) {
       emit_doc_texinfo();
+    }
 
-    if (directorsEnabled())
+    if (directorsEnabled()) {
       Swig_insert_file("director.swg", f_runtime);
+    }
 
     Printf(f_init, "return true;\n}\n");
     Printf(s_global_tab, "{0,0,0,0,0}\n};\n");
@@ -249,12 +256,13 @@ public:
     return SWIG_OK;
   }
 
-  String *texinfo_escape(String *_s) {
-    const char* s=(const char*)Data(_s);
-    while (*s&&(*s=='\t'||*s=='\r'||*s=='\n'||*s==' '))
+  String* texinfo_escape(String* _s) {
+    const char* s = (const char*) Data(_s);
+    while (*s && (*s == '\t' || *s == '\r' || *s == '\n' || *s == ' ')) {
       ++s;
-    String *r = NewString("");
-    for (int j=0;s[j];++j) {
+    }
+    String* r = NewStringEmpty();
+    for (int j = 0; s[j]; ++j) {
       if (s[j] == '\n') {
         Append(r, "\\n\\\n");
       } else if (s[j] == '\r') {
@@ -267,94 +275,98 @@ public:
         Append(r, "\\\'");
       } else if (s[j] == '\"') {
         Append(r, "\\\"");
-      } else
+      } else {
         Putc(s[j], r);
+      }
     }
     return r;
   }
   void emit_doc_texinfo() {
     for (Iterator it = First(docs); it.key; it = Next(it)) {
-      String *wrap_name = it.key;
+      String* wrap_name = it.key;
 
-      String *synopsis = Getattr(it.item, "synopsis");
-      String *decl_info = Getattr(it.item, "decl_info");
-      String *cdecl_info = Getattr(it.item, "cdecl_info");
-      String *args_info = Getattr(it.item, "args_info");
+      String* synopsis = Getattr(it.item, "synopsis");
+      String* decl_info = Getattr(it.item, "decl_info");
+      String* cdecl_info = Getattr(it.item, "cdecl_info");
+      String* args_info = Getattr(it.item, "args_info");
 
-      String *doc_str = NewString("");
+      String* doc_str = NewStringEmpty();
       Printv(doc_str, synopsis, decl_info, cdecl_info, args_info, NIL);
-      String *escaped_doc_str = texinfo_escape(doc_str);
+      String* escaped_doc_str = texinfo_escape(doc_str);
 
-      if (Len(doc_str)>0) {
-        Printf(f_doc,"static const char* %s_texinfo = ",wrap_name);
-        Printf(f_doc,"\"-*- texinfo -*-\\n\\\n%s", escaped_doc_str);
-        if (Len(decl_info))
-          Printf(f_doc,"\\n\\\n@end deftypefn");
-        Printf(f_doc,"\";\n");
+      if (Len(doc_str) > 0) {
+        Printf(f_doc, "static const char* %s_texinfo = ", wrap_name);
+        Printf(f_doc, "\"-*- texinfo -*-\\n\\\n%s", escaped_doc_str);
+        if (Len(decl_info)) {
+          Printf(f_doc, "\\n\\\n@end deftypefn");
+        }
+        Printf(f_doc, "\";\n");
       }
 
       Delete(escaped_doc_str);
       Delete(doc_str);
       Delete(wrap_name);
     }
-    Printf(f_doc,"\n");
+    Printf(f_doc, "\n");
   }
   bool is_empty_doc_node(Node* n) {
-    if (!n)
+    if (!n) {
       return true;
-    String *synopsis = Getattr(n, "synopsis");
-    String *decl_info = Getattr(n, "decl_info");
-    String *cdecl_info = Getattr(n, "cdecl_info");
-    String *args_info = Getattr(n, "args_info");
+    }
+    String* synopsis = Getattr(n, "synopsis");
+    String* decl_info = Getattr(n, "decl_info");
+    String* cdecl_info = Getattr(n, "cdecl_info");
+    String* args_info = Getattr(n, "args_info");
     return !Len(synopsis) && !Len(decl_info) &&
-      !Len(cdecl_info) && !Len(args_info);
+           !Len(cdecl_info) && !Len(args_info);
   }
-  String *texinfo_name(Node* n, const char* defval = "0") {
-    String *tname = NewString("");
-    String *iname = Getattr(n, "sym:name");
-    String *wname = Swig_name_wrapper(iname);
+  String* texinfo_name(Node* n, const char* defval = "0") {
+    String* tname = NewStringEmpty();
+    String* iname = Getattr(n, "sym:name");
+    String* wname = Swig_name_wrapper(iname);
     Node* d = Getattr(docs, wname);
 
-    if (is_empty_doc_node(d))
+    if (is_empty_doc_node(d)) {
       Printf(tname, defval);
-    else
+    } else {
       Printf(tname, "%s_texinfo", wname);
+    }
 
     return tname;
   }
-  void process_autodoc(Node *n) {
-    String *iname = Getattr(n, "sym:name");
-    String *name = Getattr(n, "name");
-    String *wname = Swig_name_wrapper(iname);
-    String *str = Getattr(n, "feature:docstring");
+  void process_autodoc(Node* n) {
+    String* iname = Getattr(n, "sym:name");
+    String* name = Getattr(n, "name");
+    String* wname = Swig_name_wrapper(iname);
+    String* str = Getattr(n, "feature:docstring");
     bool autodoc_enabled = !Cmp(Getattr(n, "feature:autodoc"), "1");
     Node* d = Getattr(docs, wname);
     if (!d) {
       d = NewHash();
-      Setattr(d, "synopsis", NewString(""));
-      Setattr(d, "decl_info", NewString(""));
-      Setattr(d, "cdecl_info", NewString(""));
-      Setattr(d, "args_info", NewString(""));
+      Setattr(d, "synopsis", NewStringEmpty());
+      Setattr(d, "decl_info", NewStringEmpty());
+      Setattr(d, "cdecl_info", NewStringEmpty());
+      Setattr(d, "args_info", NewStringEmpty());
       Setattr(docs, wname, d);
     }
 
-    String *synopsis = Getattr(d, "synopsis");
-    String *decl_info = Getattr(d, "decl_info");
+    String* synopsis = Getattr(d, "synopsis");
+    String* decl_info = Getattr(d, "decl_info");
     //    String *cdecl_info = Getattr(d, "cdecl_info");
-    String *args_info = Getattr(d, "args_info");
+    String* args_info = Getattr(d, "args_info");
 
     // * couldn't we just emit the docs here?
 
     if (autodoc_enabled) {
-      String *decl_str = NewString("");
-      String *args_str = NewString("");
+      String* decl_str = NewStringEmpty();
+      String* args_str = NewStringEmpty();
       make_autodocParmList(n, decl_str, args_str);
       Append(decl_info, "@deftypefn {Loadable Function} ");
 
-      SwigType *type = Getattr(n, "type");
+      SwigType* type = Getattr(n, "type");
       if (type && Strcmp(type, "void")) {
-        Node *nn = classLookup(Getattr(n, "type"));
-        String *type_str = nn ? Copy(Getattr(nn, "sym:name")) : SwigType_str(type, 0);
+        Node* nn = classLookup(Getattr(n, "type"));
+        String* type_str = nn ? Copy(Getattr(nn, "sym:name")) : SwigType_str(type, 0);
         Append(decl_info, "@var{retval} = ");
         Printf(args_str, "%s@var{retval} is of type %s. ", args_str, type_str);
         Delete(type_str);
@@ -371,7 +383,7 @@ public:
 
     if (str && Len(str) > 0) {
       // strip off {} if necessary
-      char *t = Char(str);
+      char* t = Char(str);
       if (*t == '{') {
         Delitem(str, 0);
         Delitem(str, DOH_END);
@@ -382,14 +394,15 @@ public:
     }
   }
 
-  virtual int importDirective(Node *n) {
-    String *modname = Getattr(n, "module");
-    if (modname)
+  virtual int importDirective(Node* n) {
+    String* modname = Getattr(n, "module");
+    if (modname) {
       Printf(f_init, "if (!SWIG_Octave_LoadModule(\"%s\")) return false;\n", modname);
+    }
     return Language::importDirective(n);
   }
 
-  const char *get_implicitconv_flag(Node *n) {
+  const char* get_implicitconv_flag(Node* n) {
     int conv = 0;
     if (n && GetFlag(n, "feature:implicitconv")) {
       conv = 1;
@@ -408,12 +421,12 @@ public:
    *   The "lname" attribute in each parameter in plist will be contain a parameter name
    * ----------------------------------------------------------------------------- */
 
-  void addMissingParameterNames(ParmList *plist, int arg_offset) {
-    Parm *p = plist;
+  void addMissingParameterNames(ParmList* plist, int arg_offset) {
+    Parm* p = plist;
     int i = arg_offset;
     while (p) {
       if (!Getattr(p, "lname")) {
-        String *pname = Swig_cparm_name(p, i);
+        String* pname = Swig_cparm_name(p, i);
         Delete(pname);
       }
       i++;
@@ -421,21 +434,21 @@ public:
     }
   }
 
-  void make_autodocParmList(Node *n, String *decl_str, String *args_str) {
-    String *pdocs = 0;
-    ParmList *plist = CopyParmList(Getattr(n, "parms"));
-    Parm *p;
-    Parm *pnext;
+  void make_autodocParmList(Node* n, String* decl_str, String* args_str) {
+    String* pdocs = 0;
+    ParmList* plist = CopyParmList(Getattr(n, "parms"));
+    Parm* p;
+    Parm* pnext;
     int start_arg_num = is_wrapping_class() ? 1 : 0;
 
-    addMissingParameterNames(plist, start_arg_num); // for $1_name substitutions done in Swig_typemap_attach_parms
+    addMissingParameterNames(plist, start_arg_num);    // for $1_name substitutions done in Swig_typemap_attach_parms
 
     Swig_typemap_attach_parms("in", plist, 0);
     Swig_typemap_attach_parms("doc", plist, 0);
 
     for (p = plist; p; p = pnext) {
 
-      String *tm = Getattr(p, "tmap:in");
+      String* tm = Getattr(p, "tmap:in");
       if (tm) {
         pnext = Getattr(p, "tmap:in:next");
         if (checkAttribute(p, "tmap:in:numinputs", "0")) {
@@ -445,10 +458,10 @@ public:
         pnext = nextSibling(p);
       }
 
-      String *name = 0;
-      String *type = 0;
-      String *value = 0;
-      String *pdoc = Getattr(p, "tmap:doc");
+      String* name = 0;
+      String* type = 0;
+      String* value = 0;
+      String* pdoc = Getattr(p, "tmap:doc");
       if (pdoc) {
         name = Getattr(p, "tmap:doc:name");
         type = Getattr(p, "tmap:doc:type");
@@ -458,46 +471,51 @@ public:
       // Note: the generated name should be consistent with that in kwnames[]
       name = name ? name : Getattr(p, "name");
       name = name ? name : Getattr(p, "lname");
-      name = Swig_name_make(p, 0, name, 0, 0); // rename parameter if a keyword
+      name = Swig_name_make(p, 0, name, 0, 0);    // rename parameter if a keyword
 
       type = type ? type : Getattr(p, "type");
       value = value ? value : Getattr(p, "value");
 
-      if (SwigType_isvarargs(type))
+      if (SwigType_isvarargs(type)) {
         break;
+      }
 
-      String *tex_name = NewString("");
-      if (name)
+      String* tex_name = NewStringEmpty();
+      if (name) {
         Printf(tex_name, "@var{%s}", name);
-      else
+      } else {
         Printf(tex_name, "@var{?}");
+      }
 
-      if (Len(decl_str))
+      if (Len(decl_str)) {
         Append(decl_str, ", ");
+      }
       Append(decl_str, tex_name);
 
       if (value) {
-        String *new_value = convertValue(value, Getattr(p, "type"));
+        String* new_value = convertValue(value, Getattr(p, "type"));
         if (new_value) {
           value = new_value;
         } else {
-          Node *lookup = Swig_symbol_clookup(value, 0);
-          if (lookup)
+          Node* lookup = Swig_symbol_clookup(value, 0);
+          if (lookup) {
             value = Getattr(lookup, "sym:name");
+          }
         }
         Printf(decl_str, " = %s", value);
       }
 
-      Node *nn = classLookup(Getattr(p, "type"));
-      String *type_str = nn ? Copy(Getattr(nn, "sym:name")) : SwigType_str(type, 0);
+      Node* nn = classLookup(Getattr(p, "type"));
+      String* type_str = nn ? Copy(Getattr(nn, "sym:name")) : SwigType_str(type, 0);
       Printf(args_str, "%s is of type %s. ", tex_name, type_str);
 
       Delete(type_str);
       Delete(tex_name);
       Delete(name);
     }
-    if (pdocs)
+    if (pdocs) {
       Setattr(n, "feature:pdocs", pdocs);
+    }
     Delete(plist);
   }
 
@@ -506,58 +524,65 @@ public:
    *    Check if string v can be an Octave value literal,
    *    (eg. number or string), or translate it to an Octave literal.
    * ------------------------------------------------------------ */
-  String *convertValue(String *v, SwigType *t) {
+  String* convertValue(String* v, SwigType* t) {
     if (v && Len(v) > 0) {
-      char fc = (Char(v))[0];
+      char fc = (Char(v)) [0];
       if (('0' <= fc && fc <= '9') || '\'' == fc || '"' == fc) {
         /* number or string (or maybe NULL pointer) */
-        if (SwigType_ispointer(t) && Strcmp(v, "0") == 0)
+        if (SwigType_ispointer(t) && Strcmp(v, "0") == 0) {
           return NewString("None");
-        else
+        } else {
           return v;
+        }
       }
-      if (Strcmp(v, "NULL") == 0 || Strcmp(v, "nullptr") == 0)
+      if (Strcmp(v, "NULL") == 0 || Strcmp(v, "nullptr") == 0) {
         return SwigType_ispointer(t) ? NewString("nil") : NewString("0");
-      if (Strcmp(v, "true") == 0 || Strcmp(v, "TRUE") == 0)
+      }
+      if (Strcmp(v, "true") == 0 || Strcmp(v, "TRUE") == 0) {
         return NewString("true");
-      if (Strcmp(v, "false") == 0 || Strcmp(v, "FALSE") == 0)
+      }
+      if (Strcmp(v, "false") == 0 || Strcmp(v, "FALSE") == 0) {
         return NewString("false");
+      }
     }
     return 0;
   }
 
-  virtual int functionWrapper(Node *n) {
-    Parm *p;
-    String *tm;
+  virtual int functionWrapper(Node* n) {
+    Parm* p;
+    String* tm;
     int j;
 
-    String *nodeType = Getattr(n, "nodeType");
+    String* nodeType = Getattr(n, "nodeType");
     int constructor = (!Cmp(nodeType, "constructor"));
     int destructor = (!Cmp(nodeType, "destructor"));
-    String *storage = Getattr(n, "storage");
+    String* storage = Getattr(n, "storage");
 
     bool overloaded = !!Getattr(n, "sym:overloaded");
     bool last_overload = overloaded && !Getattr(n, "sym:nextSibling");
-    String *iname = Getattr(n, "sym:name");
-    String *wname = Swig_name_wrapper(iname);
-    String *overname = Copy(wname);
-    SwigType *d = Getattr(n, "type");
-    ParmList *l = Getattr(n, "parms");
+    String* iname = Getattr(n, "sym:name");
+    String* wname = Swig_name_wrapper(iname);
+    String* overname = Copy(wname);
+    SwigType* d = Getattr(n, "type");
+    ParmList* l = Getattr(n, "parms");
 
-    if (!overloaded && !addSymbol(iname, n))
+    if (!overloaded && !addSymbol(iname, n)) {
       return SWIG_ERROR;
+    }
 
-    if (overloaded)
+    if (overloaded) {
       Append(overname, Getattr(n, "sym:overname"));
+    }
 
-    if (!overloaded || last_overload)
+    if (!overloaded || last_overload) {
       process_autodoc(n);
+    }
 
-    Wrapper *f = NewWrapper();
-    Octave_begin_function(n, f->def, iname, overname, !overloaded);
+    Wrapper* w = NewWrapper();
+    Octave_begin_function(n, w->def, iname, overname, !overloaded);
 
-    emit_parameter_variables(l, f);
-    emit_attach_parmmaps(l, f);
+    emit_parameter_variables(l, w);
+    emit_attach_parmmaps(l, w);
     Setattr(n, "wrap:parms", l);
 
     int num_arguments = emit_num_arguments(l);
@@ -565,15 +590,15 @@ public:
     int varargs = emit_isvarargs(l);
     char source[64];
 
-    Printf(f->code, "if (!SWIG_check_num_args(\"%s\",args.length(),%i,%i,%i)) "
+    Printf(w->code, "if (!SWIG_check_num_args(\"%s\",args.length(),%i,%i,%i)) "
            "{\n SWIG_fail;\n }\n", iname, num_arguments, num_required, varargs);
 
     if (constructor && num_arguments == 1 && num_required == 1) {
       if (Cmp(storage, "explicit") == 0) {
-        Node *parent = Swig_methodclass(n);
+        Node* parent = Swig_methodclass(n);
         if (GetFlag(parent, "feature:implicitconv")) {
-          String *desc = NewStringf("SWIGTYPE%s", SwigType_manglestr(Getattr(n, "type")));
-          Printf(f->code, "if (SWIG_CheckImplicit(%s)) SWIG_fail;\n", desc);
+          String* desc = NewStringf("SWIGTYPE%s", SwigType_manglestr(Getattr(n, "type")));
+          Printf(w->code, "if (SWIG_CheckImplicit(%s)) SWIG_fail;\n", desc);
           Delete(desc);
         }
       }
@@ -584,9 +609,9 @@ public:
         p = Getattr(p, "tmap:in:next");
       }
 
-      SwigType *pt = Getattr(p, "type");
+      SwigType* pt = Getattr(p, "type");
 
-      String *tm = Getattr(p, "tmap:in");
+      String* tm = Getattr(p, "tmap:in");
       if (tm) {
         if (!tm || checkAttribute(p, "tmap:in:numinputs", "0")) {
           p = nextSibling(p);
@@ -607,21 +632,22 @@ public:
         }
 
         if (Getattr(p, "tmap:in:implicitconv")) {
-          const char *convflag = "0";
+          const char* convflag = "0";
           if (!Getattr(p, "hidden")) {
-            SwigType *ptype = Getattr(p, "type");
+            SwigType* ptype = Getattr(p, "type");
             convflag = get_implicitconv_flag(classLookup(ptype));
           }
           Replaceall(tm, "$implicitconv", convflag);
           Setattr(p, "implicitconv", convflag);
         }
 
-        String *getargs = NewString("");
-        if (j >= num_required)
+        String* getargs = NewStringEmpty();
+        if (j >= num_required) {
           Printf(getargs, "if (%d<args.length()) {\n%s\n}", j, tm);
-        else
+        } else {
           Printv(getargs, tm, NIL);
-        Printv(f->code, getargs, "\n", NIL);
+        }
+        Printv(w->code, getargs, "\n", NIL);
         Delete(getargs);
 
         p = Getattr(p, "tmap:in:next");
@@ -636,7 +662,7 @@ public:
     if (varargs) {
       if (p && (tm = Getattr(p, "tmap:in"))) {
         Replaceall(tm, "$input", "varargs");
-        Printv(f->code, tm, "\n", NIL);
+        Printv(w->code, tm, "\n", NIL);
       }
     }
 
@@ -644,7 +670,7 @@ public:
     for (p = l; p;) {
       if ((tm = Getattr(p, "tmap:check"))) {
         Replaceall(tm, "$target", Getattr(p, "lname"));
-        Printv(f->code, tm, "\n", NIL);
+        Printv(w->code, tm, "\n", NIL);
         p = Getattr(p, "tmap:check:next");
       } else {
         p = nextSibling(p);
@@ -652,13 +678,13 @@ public:
     }
 
     // Insert cleanup code
-    String *cleanup = NewString("");
+    String* cleanup = NewStringEmpty();
     for (p = l; p;) {
       if ((tm = Getattr(p, "tmap:freearg"))) {
         if (Getattr(p, "tmap:freearg:implicitconv")) {
-          const char *convflag = "0";
+          const char* convflag = "0";
           if (!Getattr(p, "hidden")) {
-            SwigType *ptype = Getattr(p, "type");
+            SwigType* ptype = Getattr(p, "type");
             convflag = get_implicitconv_flag(classLookup(ptype));
           }
           if (strcmp(convflag, "0") == 0) {
@@ -676,7 +702,7 @@ public:
     }
 
     // Insert argument output code
-    String *outarg = NewString("");
+    String* outarg = NewStringEmpty();
     for (p = l; p;) {
       if ((tm = Getattr(p, "tmap:argout"))) {
         Replaceall(tm, "$source", Getattr(p, "lname"));
@@ -693,73 +719,75 @@ public:
 
     int director_method = is_member_director(n) && !is_smart_pointer() && !destructor;
     if (director_method) {
-      Wrapper_add_local(f, "upcall", "bool upcall = false");
-      Append(f->code, "upcall = !!dynamic_cast<Swig::Director*>(arg1);\n");
+      Wrapper_add_local(w, "upcall", "bool upcall = false");
+      Append(w->code, "upcall = !!dynamic_cast<Swig::Director*>(arg1);\n");
     }
 
     Setattr(n, "wrap:name", overname);
 
-    Swig_director_emit_dynamic_cast(n, f);
-    String *actioncode = emit_action(n);
+    Swig_director_emit_dynamic_cast(n, w);
+    String* actioncode = emit_action(n);
 
-    Wrapper_add_local(f, "_out", "octave_value_list _out");
-    Wrapper_add_local(f, "_outp", "octave_value_list *_outp=&_out");
-    Wrapper_add_local(f, "_outv", "octave_value _outv");
+    Wrapper_add_local(w, "_out", "octave_value_list _out");
+    Wrapper_add_local(w, "_outp", "octave_value_list *_outp=&_out");
+    Wrapper_add_local(w, "_outv", "octave_value _outv");
 
     // Return the function value
-    if ((tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode))) {
+    if ((tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), w, actioncode))) {
       Replaceall(tm, "$source", Swig_cresult_name());
       Replaceall(tm, "$target", "_outv");
       Replaceall(tm, "$result", "_outv");
 
-      if (GetFlag(n, "feature:new"))
+      if (GetFlag(n, "feature:new")) {
         Replaceall(tm, "$owner", "1");
-      else
+      } else {
         Replaceall(tm, "$owner", "0");
+      }
 
-      Printf(f->code, "%s\n", tm);
-      Printf(f->code, "if (_outv.is_defined()) _outp = " "SWIG_Octave_AppendOutput(_outp, _outv);\n");
+      Printf(w->code, "%s\n", tm);
+      Printf(w->code, "if (_outv.is_defined()) _outp = " "SWIG_Octave_AppendOutput(_outp, _outv);\n");
       Delete(tm);
     } else {
       Swig_warning(WARN_TYPEMAP_OUT_UNDEF, input_file, line_number, "Unable to use return type %s in function %s.\n", SwigType_str(d, 0), iname);
     }
-    emit_return_variable(n, d, f);
+    emit_return_variable(n, d, w);
 
-    Printv(f->code, outarg, NIL);
-    Printv(f->code, cleanup, NIL);
+    Printv(w->code, outarg, NIL);
+    Printv(w->code, cleanup, NIL);
 
     if (GetFlag(n, "feature:new")) {
       if ((tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0))) {
         Replaceall(tm, "$source", Swig_cresult_name());
-        Printf(f->code, "%s\n", tm);
+        Printf(w->code, "%s\n", tm);
       }
     }
 
     if ((tm = Swig_typemap_lookup("ret", n, Swig_cresult_name(), 0))) {
       Replaceall(tm, "$source", Swig_cresult_name());
       Replaceall(tm, "$result", "_outv");
-      Printf(f->code, "%s\n", tm);
+      Printf(w->code, "%s\n", tm);
       Delete(tm);
     }
 
-    Printf(f->code, "return _out;\n");
-    Printf(f->code, "fail:\n");	// we should free locals etc if this happens
-    Printv(f->code, cleanup, NIL);
-    Printf(f->code, "return octave_value_list();\n");
-    Printf(f->code, "}\n");
+    Printf(w->code, "return _out;\n");
+    Printf(w->code, "fail:\n");	// we should free locals etc if this happens
+    Printv(w->code, cleanup, NIL);
+    Printf(w->code, "return octave_value_list();\n");
+    Printf(w->code, "}\n");
 
     /* Substitute the cleanup code */
-    Replaceall(f->code, "$cleanup", cleanup);
+    Replaceall(w->code, "$cleanup", cleanup);
 
-    Replaceall(f->code, "$symname", iname);
-    Wrapper_print(f, f_wrappers);
-    DelWrapper(f);
+    Replaceall(w->code, "$symname", iname);
+    Wrapper_print(w, f_wrappers);
+    DelWrapper(w);
 
-    if (last_overload)
+    if (last_overload) {
       dispatchFunction(n);
+    }
 
     if (!overloaded || last_overload) {
-      String *tname = texinfo_name(n);
+      String* tname = texinfo_name(n);
       Printf(s_global_tab, "{\"%s\",%s,0,0,2,%s},\n", iname, wname, tname);
       Delete(tname);
     }
@@ -772,54 +800,56 @@ public:
     return SWIG_OK;
   }
 
-  void dispatchFunction(Node *n) {
-    Wrapper *f = NewWrapper();
+  void dispatchFunction(Node* n) {
+    Wrapper* w = NewWrapper();
 
-    String *iname = Getattr(n, "sym:name");
-    String *wname = Swig_name_wrapper(iname);
+    String* iname = Getattr(n, "sym:name");
+    String* wname = Swig_name_wrapper(iname);
     int maxargs;
-    String *dispatch = Swig_overload_dispatch(n, "return %s(args, nargout);", &maxargs);
-    String *tmp = NewString("");
+    String* dispatch = Swig_overload_dispatch(n, "return %s(args, nargout);", &maxargs);
+    String* tmp = NewStringEmpty();
 
-    Octave_begin_function(n, f->def, iname, wname, true);
-    Wrapper_add_local(f, "argc", "int argc = args.length()");
+    Octave_begin_function(n, w->def, iname, wname, true);
+    Wrapper_add_local(w, "argc", "int argc = args.length()");
     Printf(tmp, "octave_value_ref argv[%d]={", maxargs);
-    for (int j = 0; j < maxargs; ++j)
+    for (int j = 0; j < maxargs; ++j) {
       Printf(tmp, "%soctave_value_ref(args,%d)", j ? "," : " ", j);
+    }
     Printf(tmp, "}");
-    Wrapper_add_local(f, "argv", tmp);
-    Printv(f->code, dispatch, "\n", NIL);
-    Printf(f->code, "error(\"No matching function for overload\");\n", iname);
-    Printf(f->code, "return octave_value_list();\n");
-    Printv(f->code, "}\n", NIL);
+    Wrapper_add_local(w, "argv", tmp);
+    Printv(w->code, dispatch, "\n", NIL);
+    Printf(w->code, "error(\"No matching function for overload\");\n", iname);
+    Printf(w->code, "return octave_value_list();\n");
+    Printv(w->code, "}\n", NIL);
 
-    Wrapper_print(f, f_wrappers);
+    Wrapper_print(w, f_wrappers);
     Delete(tmp);
-    DelWrapper(f);
+    DelWrapper(w);
     Delete(dispatch);
     Delete(wname);
   }
 
-  virtual int variableWrapper(Node *n) {
-    String *name = Getattr(n, "name");
-    String *iname = Getattr(n, "sym:name");
-    SwigType *t = Getattr(n, "type");
+  virtual int variableWrapper(Node* n) {
+    String* name = Getattr(n, "name");
+    String* iname = Getattr(n, "sym:name");
+    SwigType* t = Getattr(n, "type");
 
-    if (!addSymbol(iname, n))
+    if (!addSymbol(iname, n)) {
       return SWIG_ERROR;
+    }
 
-    String *tm;
-    Wrapper *getf = NewWrapper();
-    Wrapper *setf = NewWrapper();
+    String* tm;
+    Wrapper* getw = NewWrapper();
+    Wrapper* setw = NewWrapper();
 
-    String *getname = Swig_name_get(NSPACE_TODO, iname);
-    String *setname = Swig_name_set(NSPACE_TODO, iname);
+    String* getname = Swig_name_get(NSPACE_TODO, iname);
+    String* setname = Swig_name_set(NSPACE_TODO, iname);
 
-    String *getwname = Swig_name_wrapper(getname);
-    String *setwname = Swig_name_wrapper(setname);
+    String* getwname = Swig_name_wrapper(getname);
+    String* setwname = Swig_name_wrapper(setname);
 
-    Octave_begin_function(n, setf->def, setname, setwname, true);
-    Printf(setf->def, "if (!SWIG_check_num_args(\"%s_set\",args.length(),1,1,0)) return octave_value_list();", iname);
+    Octave_begin_function(n, setw->def, setname, setwname, true);
+    Printf(setw->def, "if (!SWIG_check_num_args(\"%s_set\",args.length(),1,1,0)) return octave_value_list();", iname);
     if (is_assignable(n)) {
       Setattr(n, "wrap:name", setname);
       if ((tm = Swig_typemap_lookup("varin", n, name, 0))) {
@@ -829,65 +859,66 @@ public:
         if (Getattr(n, "tmap:varin:implicitconv")) {
           Replaceall(tm, "$implicitconv", get_implicitconv_flag(n));
         }
-        emit_action_code(n, setf->code, tm);
+        emit_action_code(n, setw->code, tm);
         Delete(tm);
       } else {
         Swig_warning(WARN_TYPEMAP_VARIN_UNDEF, input_file, line_number, "Unable to set variable of type %s.\n", SwigType_str(t, 0));
       }
-      Append(setf->code, "fail:\n");
-      Printf(setf->code, "return octave_value_list();\n");
+      Append(setw->code, "fail:\n");
+      Printf(setw->code, "return octave_value_list();\n");
     } else {
-      Printf(setf->code, "return octave_set_immutable(args,nargout);");
+      Printf(setw->code, "return octave_set_immutable(args,nargout);");
     }
-    Append(setf->code, "}\n");
-    Wrapper_print(setf, f_wrappers);
+    Append(setw->code, "}\n");
+    Wrapper_print(setw, f_wrappers);
 
     Setattr(n, "wrap:name", getname);
     int addfail = 0;
-    Octave_begin_function(n, getf->def, getname, getwname, true);
-    Wrapper_add_local(getf, "obj", "octave_value obj");
+    Octave_begin_function(n, getw->def, getname, getwname, true);
+    Wrapper_add_local(getw, "obj", "octave_value obj");
     if ((tm = Swig_typemap_lookup("varout", n, name, 0))) {
       Replaceall(tm, "$source", name);
       Replaceall(tm, "$target", "obj");
       Replaceall(tm, "$result", "obj");
-      addfail = emit_action_code(n, getf->code, tm);
+      addfail = emit_action_code(n, getw->code, tm);
       Delete(tm);
     } else {
       Swig_warning(WARN_TYPEMAP_VAROUT_UNDEF, input_file, line_number, "Unable to read variable of type %s\n", SwigType_str(t, 0));
     }
-    Append(getf->code, "  return obj;\n");
+    Append(getw->code, "  return obj;\n");
     if (addfail) {
-      Append(getf->code, "fail:\n");
-      Append(getf->code, "  return octave_value_list();\n");
+      Append(getw->code, "fail:\n");
+      Append(getw->code, "  return octave_value_list();\n");
     }
-    Append(getf->code, "}\n");
-    Wrapper_print(getf, f_wrappers);
+    Append(getw->code, "}\n");
+    Wrapper_print(getw, f_wrappers);
 
     Printf(s_global_tab, "{\"%s\",0,%s,%s,2,0},\n", iname, getwname, setwname);
 
     Delete(getwname);
     Delete(setwname);
-    DelWrapper(setf);
-    DelWrapper(getf);
+    DelWrapper(setw);
+    DelWrapper(getw);
 
     return SWIG_OK;
   }
 
-  virtual int constantWrapper(Node *n) {
-    String *name = Getattr(n, "name");
-    String *iname = Getattr(n, "sym:name");
-    SwigType *type = Getattr(n, "type");
-    String *rawval = Getattr(n, "rawval");
-    String *value = rawval ? rawval : Getattr(n, "value");
-    String *cppvalue = Getattr(n, "cppvalue");
-    String *tm;
+  virtual int constantWrapper(Node* n) {
+    String* name = Getattr(n, "name");
+    String* iname = Getattr(n, "sym:name");
+    SwigType* type = Getattr(n, "type");
+    String* rawval = Getattr(n, "rawval");
+    String* value = rawval ? rawval : Getattr(n, "value");
+    String* cppvalue = Getattr(n, "cppvalue");
+    String* tm;
 
-    if (!addSymbol(iname, n))
+    if (!addSymbol(iname, n)) {
       return SWIG_ERROR;
+    }
 
     if (SwigType_type(type) == T_MPOINTER) {
-      String *wname = Swig_name_wrapper(iname);
-      String *str = SwigType_str(type, wname);
+      String* wname = Swig_name_wrapper(iname);
+      String* str = SwigType_str(type, wname);
       Printf(f_header, "static %s = %s;\n", str, value);
       Delete(str);
       value = wname;
@@ -906,36 +937,37 @@ public:
     return SWIG_OK;
   }
 
-  virtual int nativeWrapper(Node *n) {
+  virtual int nativeWrapper(Node* n) {
     return Language::nativeWrapper(n);
   }
 
-  virtual int enumDeclaration(Node *n) {
+  virtual int enumDeclaration(Node* n) {
     return Language::enumDeclaration(n);
   }
 
-  virtual int enumvalueDeclaration(Node *n) {
+  virtual int enumvalueDeclaration(Node* n) {
     return Language::enumvalueDeclaration(n);
   }
 
-  virtual int classDeclaration(Node *n) {
+  virtual int classDeclaration(Node* n) {
     return Language::classDeclaration(n);
   }
 
-  virtual int classHandler(Node *n) {
+  virtual int classHandler(Node* n) {
     have_constructor = 0;
     have_destructor = 0;
     constructor_name = 0;
 
     class_name = Getattr(n, "sym:name");
 
-    if (!addSymbol(class_name, n))
+    if (!addSymbol(class_name, n)) {
       return SWIG_ERROR;
+    }
 
     // This is a bug, due to the fact that swig_type -> octave_class mapping
     // is 1-to-n.
-    static Hash *emitted = NewHash();
-    String *mangled_classname = Swig_name_mangle(Getattr(n, "name"));
+    static Hash* emitted = NewHash();
+    String* mangled_classname = Swig_name_mangle(Getattr(n, "name"));
     if (Getattr(emitted, mangled_classname)) {
       Delete(mangled_classname);
       return SWIG_NOWRAP;
@@ -944,24 +976,24 @@ public:
     Delete(mangled_classname);
 
     assert(!s_members_tab);
-    s_members_tab = NewString("");
+    s_members_tab = NewStringEmpty();
     Printv(s_members_tab, "static swig_octave_member swig_", class_name, "_members[] = {\n", NIL);
 
     Language::classHandler(n);
 
-    SwigType *t = Copy(Getattr(n, "name"));
+    SwigType* t = Copy(Getattr(n, "name"));
     SwigType_add_pointer(t);
 
-    String *wrap_class = NewStringf("&_wrap_class_%s", class_name);
+    String* wrap_class = NewStringf("&_wrap_class_%s", class_name);
     SwigType_remember_clientdata(t, wrap_class);
 
     int use_director = Swig_directorclass(n);
     if (use_director) {
-      String *nspace = Getattr(n, "sym:nspace");
-      String *cname = Swig_name_disown(nspace, class_name);
-      String *wcname = Swig_name_wrapper(cname);
-      String *cnameshdw = NewStringf("%s_shadow", cname);
-      String *wcnameshdw = Swig_name_wrapper(cnameshdw);
+      String* nspace = Getattr(n, "sym:nspace");
+      String* cname = Swig_name_disown(nspace, class_name);
+      String* wcname = Swig_name_wrapper(cname);
+      String* cnameshdw = NewStringf("%s_shadow", cname);
+      String* wcnameshdw = Swig_name_wrapper(cnameshdw);
       Octave_begin_function(n, f_wrappers, cnameshdw, wcnameshdw, true);
       Printf(f_wrappers, "  if (args.length()!=1) {\n");
       Printf(f_wrappers, "    error(\"disown takes no arguments\");\n");
@@ -980,21 +1012,21 @@ public:
     Printf(s_members_tab, "{0,0,0,0}\n};\n");
     Printv(f_wrappers, s_members_tab, NIL);
 
-    String *base_class_names = NewString("");
-    String *base_class = NewString("");
-    List *baselist = Getattr(n, "bases");
+    String* base_class_names = NewStringEmpty();
+    String* base_class = NewStringEmpty();
+    List* baselist = Getattr(n, "bases");
     if (baselist && Len(baselist)) {
       Iterator b;
       int index = 0;
       b = First(baselist);
       while (b.item) {
-        String *bname = Getattr(b.item, "name");
+        String* bname = Getattr(b.item, "name");
         if ((!bname) || GetFlag(b.item, "feature:ignore") || (!Getattr(b.item, "module"))) {
           b = Next(b);
           continue;
         }
 
-        String *bname_mangled = SwigType_manglestr(SwigType_add_pointer(Copy(bname)));
+        String* bname_mangled = SwigType_manglestr(SwigType_add_pointer(Copy(bname)));
         Printf(base_class_names, "\"%s\",", bname_mangled);
         Printf(base_class, "0,");
         b = Next(b);
@@ -1008,25 +1040,27 @@ public:
     Printv(f_wrappers, "static swig_octave_class _wrap_class_", class_name, " = {\"", class_name, "\", &SWIGTYPE", SwigType_manglestr(t), ",", NIL);
     Printv(f_wrappers, Swig_directorclass(n) ? "1," : "0,", NIL);
     if (have_constructor) {
-      String *nspace = Getattr(n, "sym:nspace");
-      String *cname = Swig_name_construct(nspace, constructor_name);
-      String *wcname = Swig_name_wrapper(cname);
-      String *tname = texinfo_name(n);
+      String* nspace = Getattr(n, "sym:nspace");
+      String* cname = Swig_name_construct(nspace, constructor_name);
+      String* wcname = Swig_name_wrapper(cname);
+      String* tname = texinfo_name(n);
       Printf(f_wrappers, "%s,%s,", wcname, tname);
       Delete(tname);
       Delete(wcname);
       Delete(cname);
-    } else
+    } else {
       Printv(f_wrappers, "0,0,", NIL);
+    }
     if (have_destructor) {
-      String *nspace = Getattr(n, "sym:nspace");
-      String *cname = Swig_name_destroy(nspace, class_name);
-      String *wcname = Swig_name_wrapper(cname);
+      String* nspace = Getattr(n, "sym:nspace");
+      String* cname = Swig_name_destroy(nspace, class_name);
+      String* wcname = Swig_name_wrapper(cname);
       Printf(f_wrappers, "%s,", wcname);
       Delete(wcname);
       Delete(cname);
-    } else
+    } else {
       Printv(f_wrappers, "0", ",", NIL);
+    }
     Printf(f_wrappers, "swig_%s_members,swig_%s_base_names,swig_%s_base };\n\n", class_name, class_name, class_name);
 
     Delete(base_class);
@@ -1039,23 +1073,24 @@ public:
     return SWIG_OK;
   }
 
-  virtual int memberfunctionHandler(Node *n) {
+  virtual int memberfunctionHandler(Node* n) {
     Language::memberfunctionHandler(n);
 
     assert(s_members_tab);
     assert(class_name);
-    String *name = Getattr(n, "name");
-    String *iname = GetChar(n, "sym:name");
-    String *realname = iname ? iname : name;
-    String *wname = Getattr(n, "wrap:name");
+    String* name = Getattr(n, "name");
+    String* iname = GetChar(n, "sym:name");
+    String* realname = iname ? iname : name;
+    String* wname = Getattr(n, "wrap:name");
     assert(wname);
 
     if (!Getattr(n, "sym:nextSibling")) {
-      String *tname = texinfo_name(n);
-      String *rname = Copy(wname);
+      String* tname = texinfo_name(n);
+      String* rname = Copy(wname);
       bool overloaded = !!Getattr(n, "sym:overloaded");
-      if (overloaded)
+      if (overloaded) {
         Delslice(rname, Len(rname) - Len(Getattr(n, "sym:overname")), DOH_END);
+      }
       Printf(s_members_tab, "{\"%s\",%s,0,0,0,%s},\n",
              realname, rname, tname);
       Delete(rname);
@@ -1065,18 +1100,18 @@ public:
     return SWIG_OK;
   }
 
-  virtual int membervariableHandler(Node *n) {
+  virtual int membervariableHandler(Node* n) {
     Setattr(n, "feature:autodoc", "0");
 
     Language::membervariableHandler(n);
 
     assert(s_members_tab);
     assert(class_name);
-    String *symname = Getattr(n, "sym:name");
-    String *getname = Swig_name_get(NSPACE_TODO, Swig_name_member(NSPACE_TODO, class_name, symname));
-    String *setname = Swig_name_set(NSPACE_TODO, Swig_name_member(NSPACE_TODO, class_name, symname));
-    String *getwname = Swig_name_wrapper(getname);
-    String *setwname = GetFlag(n, "feature:immutable") ? NewString("octave_set_immutable") : Swig_name_wrapper(setname);
+    String* symname = Getattr(n, "sym:name");
+    String* getname = Swig_name_get(NSPACE_TODO, Swig_name_member(NSPACE_TODO, class_name, symname));
+    String* setname = Swig_name_set(NSPACE_TODO, Swig_name_member(NSPACE_TODO, class_name, symname));
+    String* getwname = Swig_name_wrapper(getname);
+    String* setwname = GetFlag(n, "feature:immutable") ? NewString("octave_set_immutable") : Swig_name_wrapper(setname);
     assert(s_members_tab);
 
     Printf(s_members_tab, "{\"%s\",0,%s,%s,0,0},\n", symname, getwname, setwname);
@@ -1088,24 +1123,26 @@ public:
     return SWIG_OK;
   }
 
-  virtual int constructorHandler(Node *n) {
+  virtual int constructorHandler(Node* n) {
     have_constructor = 1;
-    if (!constructor_name)
+    if (!constructor_name) {
       constructor_name = NewString(Getattr(n, "sym:name"));
+    }
 
     int use_director = Swig_directorclass(n);
     if (use_director) {
-      Parm *parms = Getattr(n, "parms");
-      Parm *self;
-      String *name = NewString("self");
-      String *type = NewString("void");
+      Parm* parms = Getattr(n, "parms");
+      Parm* self;
+      String* name = NewString("self");
+      String* type = NewString("void");
       SwigType_add_pointer(type);
       self = NewParm(type, name, n);
       Delete(type);
       Delete(name);
       Setattr(self, "lname", "self_obj");
-      if (parms)
+      if (parms) {
         set_nextSibling(self, parms);
+      }
       Setattr(n, "parms", self);
       Setattr(n, "wrap:self", "1");
       Setattr(n, "hidden", "1");
@@ -1115,28 +1152,29 @@ public:
     return Language::constructorHandler(n);
   }
 
-  virtual int destructorHandler(Node *n) {
+  virtual int destructorHandler(Node* n) {
     have_destructor = 1;
     return Language::destructorHandler(n);
   }
 
-  virtual int staticmemberfunctionHandler(Node *n) {
+  virtual int staticmemberfunctionHandler(Node* n) {
     Language::staticmemberfunctionHandler(n);
 
     assert(s_members_tab);
     assert(class_name);
-    String *name = Getattr(n, "name");
-    String *iname = GetChar(n, "sym:name");
-    String *realname = iname ? iname : name;
-    String *wname = Getattr(n, "wrap:name");
+    String* name = Getattr(n, "name");
+    String* iname = GetChar(n, "sym:name");
+    String* realname = iname ? iname : name;
+    String* wname = Getattr(n, "wrap:name");
     assert(wname);
 
     if (!Getattr(n, "sym:nextSibling")) {
-      String *tname = texinfo_name(n);
-      String *rname = Copy(wname);
+      String* tname = texinfo_name(n);
+      String* rname = Copy(wname);
       bool overloaded = !!Getattr(n, "sym:overloaded");
-      if (overloaded)
+      if (overloaded) {
         Delslice(rname, Len(rname) - Len(Getattr(n, "sym:overname")), DOH_END);
+      }
       Printf(s_members_tab, "{\"%s\",%s,0,0,1,%s},\n",
              realname, rname, tname);
       Delete(rname);
@@ -1146,11 +1184,11 @@ public:
     return SWIG_OK;
   }
 
-  virtual int memberconstantHandler(Node *n) {
+  virtual int memberconstantHandler(Node* n) {
     return Language::memberconstantHandler(n);
   }
 
-  virtual int staticmembervariableHandler(Node *n) {
+  virtual int staticmembervariableHandler(Node* n) {
     Setattr(n, "feature:autodoc", "0");
 
     Language::staticmembervariableHandler(n);
@@ -1158,11 +1196,11 @@ public:
     if (!GetFlag(n, "wrappedasconstant")) {
       assert(s_members_tab);
       assert(class_name);
-      String *symname = Getattr(n, "sym:name");
-      String *getname = Swig_name_get(NSPACE_TODO, Swig_name_member(NSPACE_TODO, class_name, symname));
-      String *setname = Swig_name_set(NSPACE_TODO, Swig_name_member(NSPACE_TODO, class_name, symname));
-      String *getwname = Swig_name_wrapper(getname);
-      String *setwname = GetFlag(n, "feature:immutable") ? NewString("octave_set_immutable") : Swig_name_wrapper(setname);
+      String* symname = Getattr(n, "sym:name");
+      String* getname = Swig_name_get(NSPACE_TODO, Swig_name_member(NSPACE_TODO, class_name, symname));
+      String* setname = Swig_name_set(NSPACE_TODO, Swig_name_member(NSPACE_TODO, class_name, symname));
+      String* getwname = Swig_name_wrapper(getname);
+      String* setwname = GetFlag(n, "feature:immutable") ? NewString("octave_set_immutable") : Swig_name_wrapper(setname);
       assert(s_members_tab);
 
       Printf(s_members_tab, "{\"%s\",0,%s,%s,1,0},\n", symname, getwname, setwname);
@@ -1175,8 +1213,8 @@ public:
     return SWIG_OK;
   }
 
-  int classDirectorInit(Node *n) {
-    String *declaration = Swig_director_declaration(n);
+  int classDirectorInit(Node* n) {
+    String* declaration = Swig_director_declaration(n);
     Printf(f_directors_h, "\n");
     Printf(f_directors_h, "%s\n", declaration);
     Printf(f_directors_h, "public:\n");
@@ -1184,24 +1222,24 @@ public:
     return Language::classDirectorInit(n);
   }
 
-  int classDirectorEnd(Node *n) {
+  int classDirectorEnd(Node* n) {
     Printf(f_directors_h, "};\n\n");
     return Language::classDirectorEnd(n);
   }
 
-  int classDirectorConstructor(Node *n) {
-    Node *parent = Getattr(n, "parentNode");
-    String *sub = NewString("");
-    String *decl = Getattr(n, "decl");
-    String *supername = Swig_class_name(parent);
-    String *classname = NewString("");
+  int classDirectorConstructor(Node* n) {
+    Node* parent = Getattr(n, "parentNode");
+    String* sub = NewStringEmpty();
+    String* decl = Getattr(n, "decl");
+    String* supername = Swig_class_name(parent);
+    String* classname = NewStringEmpty();
     Printf(classname, "SwigDirector_%s", supername);
 
     // insert self parameter
-    Parm *p;
-    ParmList *superparms = Getattr(n, "parms");
-    ParmList *parms = CopyParmList(superparms);
-    String *type = NewString("void");
+    Parm* p;
+    ParmList* superparms = Getattr(n, "parms");
+    ParmList* parms = CopyParmList(superparms);
+    String* type = NewString("void");
     SwigType_add_pointer(type);
     p = NewParm(type, NewString("self"), n);
     set_nextSibling(p, parms);
@@ -1210,10 +1248,10 @@ public:
     if (!Getattr(n, "defaultargs")) {
       // constructor
       {
-        Wrapper *w = NewWrapper();
-        String *call;
-        String *basetype = Getattr(parent, "classtype");
-        String *target = Swig_method_decl(0, decl, classname, parms, 0, 0);
+        Wrapper* w = NewWrapper();
+        String* call;
+        String* basetype = Getattr(parent, "classtype");
+        String* target = Swig_method_decl(0, decl, classname, parms, 0, 0);
         call = Swig_csuperclass_call(0, basetype, superparms);
         Printf(w->def, "%s::%s: %s," "\nSwig::Director(static_cast<%s*>(this)) { \n", classname, target, call, basetype);
         Append(w->def, "}\n");
@@ -1225,7 +1263,7 @@ public:
 
       // constructor header
       {
-        String *target = Swig_method_decl(0, decl, classname, parms, 0, 1);
+        String* target = Swig_method_decl(0, decl, classname, parms, 0, 1);
         Printf(f_directors_h, "    %s;\n", target);
         Delete(target);
       }
@@ -1238,10 +1276,10 @@ public:
     return Language::classDirectorConstructor(n);
   }
 
-  int classDirectorDefaultConstructor(Node *n) {
-    String *classname = Swig_class_name(n);
+  int classDirectorDefaultConstructor(Node* n) {
+    String* classname = Swig_class_name(n);
     {
-      Wrapper *w = NewWrapper();
+      Wrapper* w = NewWrapper();
       Printf(w->def, "SwigDirector_%s::SwigDirector_%s(void* self) :"
              "\nSwig::Director((octave_swig_type*)self,static_cast<%s*>(this)) { \n", classname, classname, classname);
       Append(w->def, "}\n");
@@ -1253,22 +1291,22 @@ public:
     return Language::classDirectorDefaultConstructor(n);
   }
 
-  int classDirectorMethod(Node *n, Node *parent, String *super) {
+  int classDirectorMethod(Node* n, Node* parent, String* super) {
     int is_void = 0;
     int is_pointer = 0;
-    String *decl = Getattr(n, "decl");
-    String *returntype = Getattr(n, "type");
-    String *name = Getattr(n, "name");
-    String *classname = Getattr(parent, "sym:name");
-    String *c_classname = Getattr(parent, "name");
-    String *symname = Getattr(n, "sym:name");
-    String *declaration = NewString("");
-    ParmList *l = Getattr(n, "parms");
-    Wrapper *w = NewWrapper();
-    String *tm;
-    String *wrap_args = NewString("");
-    String *value = Getattr(n, "value");
-    String *storage = Getattr(n, "storage");
+    String* decl = Getattr(n, "decl");
+    String* returntype = Getattr(n, "type");
+    String* name = Getattr(n, "name");
+    String* classname = Getattr(parent, "sym:name");
+    String* c_classname = Getattr(parent, "name");
+    String* symname = Getattr(n, "sym:name");
+    String* declaration = NewStringEmpty();
+    ParmList* l = Getattr(n, "parms");
+    Wrapper* w = NewWrapper();
+    String* tm;
+    String* wrap_args = NewStringEmpty();
+    String* value = Getattr(n, "value");
+    String* storage = Getattr(n, "storage");
     bool pure_virtual = false;
     int status = SWIG_OK;
     int idx;
@@ -1285,10 +1323,10 @@ public:
     is_void = (!Cmp(returntype, "void") && !is_pointer);
 
     // virtual method definition
-    String *target;
-    String *pclassname = NewStringf("SwigDirector_%s", classname);
-    String *qualified_name = NewStringf("%s::%s", pclassname, name);
-    SwigType *rtype = Getattr(n, "conversion_operator") ? 0 : Getattr(n, "classDirectorMethods:type");
+    String* target;
+    String* pclassname = NewStringf("SwigDirector_%s", classname);
+    String* qualified_name = NewStringf("%s::%s", pclassname, name);
+    SwigType* rtype = Getattr(n, "conversion_operator") ? 0 : Getattr(n, "classDirectorMethods:type");
     target = Swig_method_decl(rtype, decl, qualified_name, l, 0, 0);
     Printf(w->def, "%s", target);
     Delete(qualified_name);
@@ -1300,24 +1338,25 @@ public:
     Delete(target);
 
     // Get any exception classes in the throws typemap
-    ParmList *throw_parm_list = 0;
+    ParmList* throw_parm_list = 0;
 
     if ((throw_parm_list = Getattr(n, "throws")) || Getattr(n, "throw")) {
-      Parm *p;
+      Parm* p;
       int gencomma = 0;
 
       Append(w->def, " throw(");
       Append(declaration, " throw(");
 
-      if (throw_parm_list)
+      if (throw_parm_list) {
         Swig_typemap_attach_parms("throws", throw_parm_list, 0);
+      }
       for (p = throw_parm_list; p; p = nextSibling(p)) {
         if (Getattr(p, "tmap:throws")) {
           if (gencomma++) {
             Append(w->def, ", ");
             Append(declaration, ", ");
           }
-          String *str = SwigType_str(Getattr(p, "type"), 0);
+          String* str = SwigType_str(Getattr(p, "type"), 0);
           Append(w->def, str);
           Append(declaration, str);
           Delete(str);
@@ -1336,7 +1375,7 @@ public:
     // handle it, including declaration of c_result ($result).
     if (!is_void) {
       if (!(ignored_method && !pure_virtual)) {
-        String *cres = SwigType_lstr(returntype, "c_result");
+        String* cres = SwigType_lstr(returntype, "c_result");
         Printf(w->code, "%s;\n", cres);
         Delete(cres);
       }
@@ -1344,9 +1383,10 @@ public:
 
     if (ignored_method) {
       if (!pure_virtual) {
-        if (!is_void)
+        if (!is_void) {
           Printf(w->code, "return ");
-        String *super_call = Swig_method_call(super, l);
+        }
+        String* super_call = Swig_method_call(super, l);
         Printf(w->code, "%s;\n", super_call);
         Delete(super_call);
       } else {
@@ -1355,7 +1395,7 @@ public:
       }
     } else {
       // attach typemaps to arguments (C/C++ -> Python)
-      String *parse_args = NewString("");
+      String* parse_args = NewStringEmpty();
 
       Swig_director_parms_fixup(l);
 
@@ -1363,11 +1403,12 @@ public:
       Swig_typemap_attach_parms("directorin", l, 0);
       Swig_typemap_attach_parms("directorargout", l, w);
 
-      Parm *p;
+      Parm* p;
 
       int outputs = 0;
-      if (!is_void)
+      if (!is_void) {
         outputs++;
+      }
 
       // build argument list and type conversion string
       p = l;
@@ -1377,15 +1418,16 @@ public:
           continue;
         }
 
-        if (Getattr(p, "tmap:directorargout") != 0)
+        if (Getattr(p, "tmap:directorargout") != 0) {
           outputs++;
+        }
 
-        String *pname = Getattr(p, "name");
-        String *ptype = Getattr(p, "type");
+        String* pname = Getattr(p, "name");
+        String* ptype = Getattr(p, "type");
         Wrapper_add_local(w, "tmpv", "octave_value tmpv");
 
         if ((tm = Getattr(p, "tmap:directorin")) != 0) {
-          String *parse = Getattr(p, "tmap:directorin:parse");
+          String* parse = Getattr(p, "tmap:directorin:parse");
           if (!parse) {
             Setattr(p, "emit:directorinput", "tmpv");
             Replaceall(tm, "$input", "tmpv");
@@ -1398,8 +1440,9 @@ public:
             Setattr(p, "emit:directorinput", pname);
             Replaceall(tm, "$input", pname);
             Replaceall(tm, "$owner", "0");
-            if (Len(tm) == 0)
+            if (Len(tm) == 0) {
               Append(tm, pname);
+            }
           }
           p = Getattr(p, "tmap:directorin:next");
           continue;
@@ -1413,7 +1456,7 @@ public:
         p = nextSibling(p);
       }
 
-      String *method_name = Getattr(n, "sym:name");
+      String* method_name = Getattr(n, "sym:name");
 
       Printv(w->code, wrap_args, NIL);
 
@@ -1425,8 +1468,8 @@ public:
       Printf(w->code, "idx.push_back(args);\n");
       Printf(w->code, "out=swig_get_self()->subsref(\".(\",idx,%d);\n", outputs);
 
-      String *cleanup = NewString("");
-      String *outarg = NewString("");
+      String* cleanup = NewStringEmpty();
+      String* outarg = NewStringEmpty();
       idx = 0;
 
       // marshal return value
@@ -1479,7 +1522,7 @@ public:
 
     if (!is_void) {
       if (!(ignored_method && !pure_virtual)) {
-        String *rettype = SwigType_str(returntype, 0);
+        String* rettype = SwigType_str(returntype, 0);
         if (!SwigType_isreference(returntype)) {
           Printf(w->code, "return (%s) c_result;\n", rettype);
         } else {
@@ -1492,15 +1535,16 @@ public:
     Append(w->code, "}\n");
 
     // We expose protected methods via an extra public inline method which makes a straight call to the wrapped class' method
-    String *inline_extra_method = NewString("");
+    String* inline_extra_method = NewStringEmpty();
     if (dirprot_mode() && !is_public(n) && !pure_virtual) {
       Printv(inline_extra_method, declaration, NIL);
-      String *extra_method_name = NewStringf("%sSwigPublic", name);
+      String* extra_method_name = NewStringf("%sSwigPublic", name);
       Replaceall(inline_extra_method, name, extra_method_name);
       Replaceall(inline_extra_method, ";\n", " {\n      ");
-      if (!is_void)
+      if (!is_void) {
         Printf(inline_extra_method, "return ");
-      String *methodcall = Swig_method_call(super, l);
+      }
+      String* methodcall = Swig_method_call(super, l);
       Printv(inline_extra_method, methodcall, ";\n    }\n", NIL);
       Delete(methodcall);
       Delete(extra_method_name);
@@ -1521,9 +1565,9 @@ public:
     return status;
   }
 
-  String *runtimeCode() {
-    String *s = NewString("");
-    String *srun = Swig_include_sys("octrun.swg");
+  String* runtimeCode() {
+    String* s = NewStringEmpty();
+    String* srun = Swig_include_sys("octrun.swg");
     if (!srun) {
       Printf(stderr, "*** Unable to open 'octrun.swg'\n");
     } else {
@@ -1533,11 +1577,12 @@ public:
     return s;
   }
 
-  String *defaultExternalRuntimeFilename() {
+  String* defaultExternalRuntimeFilename() {
     return NewString("swigoctaverun.h");
   }
 };
 
-extern "C" Language *swig_octave(void) {
+extern "C" Language* swig_octave(void)
+{
   return new OCTAVE();
 }