Added decompose()

diff --git a/game/txt/hlp/cobra_func.hlp b/game/txt/hlp/cobra_func.hlp
index c2738991fbbe93c424d0dd670e60de73923bb5ee..8bc0f9703245e2698ce55c031652628a7b875362 100644 (file)
--- a/game/txt/hlp/cobra_func.hlp
+++ b/game/txt/hlp/cobra_func.hlp
@@ -865,6 +865,16 @@
   Note especially the last example, which will trip you up if you use
   floating point numbers with dec() and expect it to work like sub().
   See also: inc()
+& DECOMPOSE()
+  decompose(<string>)
+
+  decompose() works like escape() with the additional caveat that it inserts
+  parse-able characters to recreate <string> exactly after one parsing. It
+  takes care of multiple spaces, '%r's, and '%t's.
+
+  Someday, perhaps, it will also escape ansi() in a nice way.
+
+  See also: @decompile2
 & DECRYPT()
   decrypt(<string>, <password>)
 

diff --git a/hdrs/externs.h b/hdrs/externs.h
index 9d383aeba6db708cab3a3a67513d00048840f04c..937f1ebc0ef3ffd76210cc8427e1de74d4164e66 100644 (file)
--- a/hdrs/externs.h
+++ b/hdrs/externs.h
@@ -273,6 +273,7 @@ enum look_type { LOOK_NORMAL, LOOK_TRANS, LOOK_AUTO, LOOK_CLOUDYTRANS,
 extern void look_room(dbref player, dbref loc, enum look_type style);
 extern void do_look_around(dbref player);
 extern void do_look_at(dbref player, const char *name, int key);
+extern char *decompose_str(char *what);
 
 /* From memcheck.c */
 extern void add_check(const char *ref);

diff --git a/src/function.c b/src/function.c
index cdc92a3f76ecba530696c23f300b9cc3ec65201d..660e0973121ac6e9e67b6d8716a0240cc8a0f51d 100644 (file)
--- a/src/function.c
+++ b/src/function.c
@@ -344,6 +344,7 @@ FUNTAB flist[] = {
 #endif
   {"CTIME", fun_ctime, 1, 1, FN_REG},
   {"DEC", fun_dec, 1, 1, FN_REG},
+  {"DECOMPOSE", fun_decompose, 1, -1, FN_REG},
   {"DECRYPT", fun_decrypt, 2, 2, FN_REG},
   {"DEFAULT", fun_default, 2, 2, FN_NOPARSE},
   {"DELETE", fun_delete, 3, 3, FN_REG},

diff --git a/src/funstr.c b/src/funstr.c
index f58f459d3afd2f831830bc4cc865322eaaad4c1d..427d3fb28024922207ddefe2ec8309839e27802a 100644 (file)
--- a/src/funstr.c
+++ b/src/funstr.c
@@ -1116,6 +1116,16 @@ FUNCTION(fun_foreach)
 extern char escaped_chars[UCHAR_MAX + 1];
 extern char escaped_chars_s[UCHAR_MAX +1];
 
+/* ARGSUSED */
+FUNCTION(fun_decompose)
+{
+  /* This function simply returns a decompose'd version of
+   * the included string, such that
+   * s(decompose(str)) == str, down to the last space, tab,
+   * and newline. Except for ansi. */
+  safe_str(decompose_str(args[0]), buff, bp);
+}
+
 /* ARGSUSED */
 FUNCTION(fun_secure)
 {

diff --git a/src/look.c b/src/look.c
index 33bf5243bb8c1e168b8233e446d62ebb447a5009..7d28fc88ff65228325331a8203ead6f93c08444c 100644 (file)
--- a/src/look.c
+++ b/src/look.c
@@ -10,6 +10,7 @@
 #include "copyrite.h"
 
 #include <string.h>
+#include <ctype.h>
 
 #include "conf.h"
 #include "externs.h"
@@ -1407,6 +1408,63 @@ struct dh_args {
   int skipdef;         /**< Skip default flags on attributes if true */
 };
 
+extern char escaped_chars[UCHAR_MAX + 1];
+
+char *
+decompose_str(char *what)
+{
+  static char value[BUFFER_LEN];
+  char *ptr, *s;
+  int len;
+  int dospace;
+
+  len = strlen(what);
+  /* Go through the string, escaping characters and
+   * turning every other space into %b. */
+
+  s = value;
+  ptr = what;
+  /* Put a \ at the beginning if it won't already be put there,
+   * unless it's a space, which would require %b, %r, or %t anyway */
+  if (!escaped_chars[(unsigned int) *what] && !isspace(*what)) {
+    safe_chr('\\', value, &s);
+  }
+  dospace = 1;
+  for (; *ptr; ptr++) {
+    switch (*ptr) {
+    case ' ':
+      if (dospace) {
+        safe_str("%b", value, &s);
+      } else {
+        safe_chr(' ', value, &s);
+      }
+      dospace = !dospace;
+      break;
+    case '\n':
+      dospace = 0;
+      safe_str("%r", value, &s);
+      break;
+    case '\t':
+      dospace = 0;
+      safe_str("%t", value, &s);
+      break;
+    default:
+      if (escaped_chars[(unsigned int) *ptr]) {
+        safe_chr('\\', value, &s);
+      }
+      safe_chr(*ptr, value, &s);
+      dospace = 0;
+    }
+  }
+  /* Now check the last space. */
+  if (*(s - 1) == ' ') {
+    s -= 1;
+    safe_str("%b", value, &s);
+  }
+  *s = '\0';
+  return value;
+}
+
 static int
 decompile_helper(dbref player, dbref thing __attribute__ ((__unused__)),       
                 dbref parent __attribute__ ((__unused__)), 

diff --git a/win32/funs.h b/win32/funs.h
index 5870375c1e69c8956860d7c58f4cd91d50108e6c..3fdd4d14839348e92817942176a79a5dedf0757f 100644 (file)
--- a/win32/funs.h
+++ b/win32/funs.h
@@ -69,6 +69,7 @@ FUNCTION_PROTO(fun_ctu);
 FUNCTION_PROTO(fun_cwho);
 FUNCTION_PROTO(fun_dbwalker);
 FUNCTION_PROTO(fun_dec);
+FUNCTION_PROTO(fun_decompose);
 FUNCTION_PROTO(fun_decrypt);
 FUNCTION_PROTO(fun_default);
 FUNCTION_PROTO(fun_delete);