Add 'nofoldtabs' option to disable warning when a function generates tabs

When a function folds to a string that contains a tab, e.g. llUnescapeURL("%09"), or to a list that contains a string that contains a tab, a warning is emitted unless the foldtabs option (which forces the optimization) is used. This option allows to quiet the warning without forcing the optimization.

lslopt/lslfoldconst.py

@@ -945,16 +945,13 @@ class foldconst(object):
                         else:
                             value = fn(*tuple(arg['value'] for arg in child))
                         if not self.foldtabs:
-                            generatesTabs = ( isinstance(value, unicode)
-                                              and '\t' in value
-                                             or type(value) == list
-                                              and any(isinstance(x, unicode)
-                                                      and '\t' in x
-                                                      for x in value
-                                                     )
-                                            )
-                            if generatesTabs:
-                                warning("Can't optimize call to %s because it would generate a tab character (you can force the optimization with the foldtabs option)." % node['name'])
+                            if not self.nofoldtabs:
+                                generatesTabs = (
+                                    isinstance(value, unicode) and '\t' in value
+                                    or type(value) == list and any(isinstance(x, unicode) and '\t' in x for x in value)
+                                    )
+                                if generatesTabs:
+                                    warning("Can't optimize call to %s because it would generate a tab character (you can force the optimization with the foldtabs option, or disable this warning with the nofoldtabs option)." % node['name'])
                             return
                         parent[index] = {'nt':'CONST', 't':node['t'], 'value':value}
                     except lslfuncs.ELSLCantCompute:

lslopt/lsloptimizer.py

@@ -68,6 +68,7 @@ class optimizer(foldconst, renamer, deadcode):
         self.addstrings = 'addstrings' in options
 
         self.foldtabs = 'foldtabs' in options
+        self.nofoldtabs = 'nofoldtabs' in options
 
         self.shrinknames = 'shrinknames' in options
 

main.py

@@ -277,6 +277,8 @@ Optimizer options (+ means active by default, - means inactive by default):
                        expansion of functions that produce strings with tabs.
                        The resulting source isn't guaranteed to be
                        copy-paste-able to the viewer.
+  nofoldtabs         - Suppress warning when a function can't be optimized
+                       because it generates a string or list with a tab.
   skippreproc        + Skip preprocessor directives in the source as if they
                        were comments. Not useful unless the script is itself
                        the output of a preprocessor like GNU cpp, which inserts