mucgly 0.2.0 → 0.2.1

data/CHANGELOG.rdoc

@@ -1,5 +1,11 @@
 = Version history
 
+[0.2.1] Suspension feature for language mode compliance.
+        Character eater.
+        Mucgly.sethook method added.
+        Mucgly.seteater method added.
+        Checks for argument types in Mucgly methods.
+
 [0.2.0] Multihook feature.
         Remote escape feature.
         Block output feature.

data/README.rdoc

@@ -63,6 +63,8 @@ For all command line options, see:
 
 * Multiple, concurrent macro start and end limiters (multihook).
 
+* Compatible with editor's language sensitive mode.
+
 * Multiple sources for configuration: default config, environment
   variable, command line.
 
@@ -165,6 +167,65 @@ happen multiple times. If a single hook set is performed (again),
 singlehook mode is entered. This can also be used as method for
 resetting the current set of multihooks.
 
+=== Suspension
+
+Suspension is a feature that helps in implementing macros that are
+compliant with the text editor's language sensitive mode.
+
+By default Mucgly macros do not look like part of the host language,
+e.g. C language. However macros can be made to emulate the host
+language.
+
+For example the user might want to make the macro to look like a
+function call in the host language.
+
+The macro could be used like this:
+
+  c = rx( inline_mult( "c", "a1" ) );
+
+Here hookbeg is "rx(" and hookend is ")". From the C language point of
+view, this looks like two nested function calls. "rx" is called and
+its argument is a return value from "inline_mult" function. From Ruby
+point of view, we want "inline_mult" to be called as a Ruby
+method. However, by default the macro would terminate to the first
+closing parenthesis, which would cause a syntax error in the end.
+
+The solution is to declare "(" as suspension character. Suspension
+character means that for each occurence of the suspension character,
+one hookend will be suspended, i.e. de-activated. Hence the first "("
+after starting the macro with "rx(", will suspend the next ")",
+i.e. hookend. Since there is only one "(", there will be only one
+suspension performed, and the final ")" will terminate the macro. The
+suspended hookend will be taken as part of the macro body.
+
+In order to get suspension, a multihook is declared including a
+suspension character/string.
+
+  /*-<+Mucgly.multihook( [ "rx(", ")", "(" ] )>-*/
+
+Suspensions could be replaced with simple escape of the first ")"
+within the macro call, but this is inconvenient, and might potentially
+cause issues with language mode of the host language.
+
+Suspension mechanism is not bullet proof, and thus does not always
+guarantee language mode compatibility. Languages with C based syntax
+work well since they use the same style of function argument lists and
+string conventions as in Ruby. Other type of languages might not
+benefit from this feature.
+
+
+=== Eater
+
+Eater is character/string which follows hookesc and designates that
+the following char should be removed. This applies to both inside and
+outside macros. The reason for adding "extra" characters to input
+could be for example to trick the language mode of the host language
+to change coloring.
+
+Eater can be set with ":eater" or with "Mucgly.seteater". If
+"Mucgly.seteater" is passed a nil, the Eater feature is disabled and
+hookesc behaves as by default.
+
 
 == Special commands
 
@@ -280,6 +341,8 @@ Complete list of Mucgly module methods:
 
 [hookesc] Get hookesc value.
 
+[sethook] Set hookbeg and hookend values.
+
 [sethookbeg] Set hookbeg value.
 
 [sethookend] Set hookend value.

data/doc/Mucgly.html

@@ -92,7 +92,7 @@
         <dt id="VERSION-constant" class="">VERSION =
           
         </dt>
-        <dd><pre class="code"><span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>0.2.0</span><span class='tstring_end'>&quot;</span></span></pre></dd>
+        <dd><pre class="code"><span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>0.2.1</span><span class='tstring_end'>&quot;</span></span></pre></dd>
       
     </dl>
   
@@ -177,9 +177,9 @@
 </div>
 
     <div id="footer">
-  Generated on Sun Apr 24 19:00:00 2016 by
+  Generated on Mon Oct 24 20:35:30 2016 by
   <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
-  0.8.7.6 (ruby-2.1.2).
+  0.8.7.6 (ruby-2.3.1).
 </div>
 
   </body>

data/doc/_index.html

@@ -104,9 +104,9 @@
 </div>
 
     <div id="footer">
-  Generated on Sun Apr 24 19:00:00 2016 by
+  Generated on Mon Oct 24 20:35:29 2016 by
   <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
-  0.8.7.6 (ruby-2.1.2).
+  0.8.7.6 (ruby-2.3.1).
 </div>
 
   </body>

data/doc/file.CHANGELOG.html

@@ -63,7 +63,12 @@
 
     <div id="content"><div id='filecontents'>
 <h1 id="label-Version+history">Version history</h1>
-<dl class="rdoc-list label-list"><dt>0.2.0
+<dl class="rdoc-list label-list"><dt>0.2.1
+<dd>
+<p>Suspension feature for language mode compliance. Character eater.
+Mucgly.sethook method added. Mucgly.seteater method added. Checks for
+argument types in Mucgly methods.</p>
+</dd><dt>0.2.0
 <dd>
 <p>Multihook feature. Remote escape feature. Block output feature. Fix for
 hook at EOF parsing.</p>
@@ -89,9 +94,9 @@ compatible with older versions.</p>
 </div></div>
 
     <div id="footer">
-  Generated on Sun Apr 24 19:00:00 2016 by
+  Generated on Mon Oct 24 20:35:30 2016 by
   <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
-  0.8.7.6 (ruby-2.1.2).
+  0.8.7.6 (ruby-2.3.1).
 </div>
 
   </body>

data/doc/file.README.html

@@ -130,6 +130,8 @@ line, configuration files, or from macro input file.</p>
 </li><li>
 <p>Multiple, concurrent macro start and end limiters (multihook).</p>
 </li><li>
+<p>Compatible with editor&#39;s language sensitive mode.</p>
+</li><li>
 <p>Multiple sources for configuration: default config, environment variable,
 command line.</p>
 </li><li>
@@ -229,6 +231,63 @@ happen multiple times. If a single hook set is performed (again),
 singlehook mode is entered. This can also be used as method for resetting
 the current set of multihooks.</p>
 
+<h3 id="label-Suspension">Suspension</h3>
+
+<p>Suspension is a feature that helps in implementing macros that are
+compliant with the text editor&#39;s language sensitive mode.</p>
+
+<p>By default Mucgly macros do not look like part of the host language, e.g. C
+language. However macros can be made to emulate the host language.</p>
+
+<p>For example the user might want to make the macro to look like a function
+call in the host language.</p>
+
+<p>The macro could be used like this:</p>
+
+<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_c'>c</span> <span class='op'>=</span> <span class='id identifier rubyid_rx'>rx</span><span class='lparen'>(</span> <span class='id identifier rubyid_inline_mult'>inline_mult</span><span class='lparen'>(</span> <span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>c</span><span class='tstring_end'>&quot;</span></span><span class='comma'>,</span> <span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>a1</span><span class='tstring_end'>&quot;</span></span> <span class='rparen'>)</span> <span class='rparen'>)</span><span class='semicolon'>;</span>
+</code></pre>
+
+<p>Here hookbeg is “rx(” and hookend is “)”. From the C language point of
+view, this looks like two nested function calls. “rx” is called and its
+argument is a return value from “inline_mult” function. From Ruby point of
+view, we want “inline_mult” to be called as a Ruby method. However, by
+default the macro would terminate to the first closing parenthesis, which
+would cause a syntax error in the end.</p>
+
+<p>The solution is to declare “(” as suspension character. Suspension
+character means that for each occurence of the suspension character, one
+hookend will be suspended, i.e. de-activated. Hence the first “(” after
+starting the macro with “rx(”, will suspend the next “)”, i.e. hookend.
+Since there is only one “(”, there will be only one suspension performed,
+and the final “)” will terminate the macro. The suspended hookend will be
+taken as part of the macro body.</p>
+
+<p>In order to get suspension, a multihook is declared including a suspension
+character/string.</p>
+
+<pre class="code ruby"><code class="ruby"><span class='tstring'><span class='regexp_beg'>/</span><span class='tstring_content'>*-&lt;+Mucgly.multihook( [ &quot;rx(&quot;, &quot;)&quot;, &quot;(&quot; ] )&gt;-*</span><span class='regexp_end'>/</span></span></code></pre>
+
+<p>Suspensions could be replaced with simple escape of the first “)” within
+the macro call, but this is inconvenient, and might potentially cause
+issues with language mode of the host language.</p>
+
+<p>Suspension mechanism is not bullet proof, and thus does not always
+guarantee language mode compatibility. Languages with C based syntax work
+well since they use the same style of function argument lists and string
+conventions as in Ruby. Other type of languages might not benefit from this
+feature.</p>
+
+<h3 id="label-Eater">Eater</h3>
+
+<p>Eater is character/string which follows hookesc and designates that the
+following char should be removed. This applies to both inside and outside
+macros. The reason for adding “extra” characters to input could be for
+example to trick the language mode of the host language to change coloring.</p>
+
+<p>Eater can be set with “:eater” or with “Mucgly.seteater”. If
+“Mucgly.seteater” is passed a nil, the Eater feature is disabled and
+hookesc behaves as by default.</p>
+
 <h2 id="label-Special+commands">Special commands</h2>
 
 <p>In addition to regular Ruby code the macros are allowed to include so
@@ -355,6 +414,9 @@ Hook-commands change the current hook values.</p>
 </dd><dt>hookesc
 <dd>
 <p>Get hookesc value.</p>
+</dd><dt>sethook
+<dd>
+<p>Set hookbeg and hookend values.</p>
 </dd><dt>sethookbeg
 <dd>
 <p>Set hookbeg value.</p>
@@ -466,9 +528,9 @@ GEM executable (i.e. same command line options).</p>
 </div></div>
 
     <div id="footer">
-  Generated on Sun Apr 24 19:00:00 2016 by
+  Generated on Mon Oct 24 20:35:30 2016 by
   <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
-  0.8.7.6 (ruby-2.1.2).
+  0.8.7.6 (ruby-2.3.1).
 </div>
 
   </body>

data/doc/index.html

@@ -130,6 +130,8 @@ line, configuration files, or from macro input file.</p>
 </li><li>
 <p>Multiple, concurrent macro start and end limiters (multihook).</p>
 </li><li>
+<p>Compatible with editor&#39;s language sensitive mode.</p>
+</li><li>
 <p>Multiple sources for configuration: default config, environment variable,
 command line.</p>
 </li><li>
@@ -229,6 +231,63 @@ happen multiple times. If a single hook set is performed (again),
 singlehook mode is entered. This can also be used as method for resetting
 the current set of multihooks.</p>
 
+<h3 id="label-Suspension">Suspension</h3>
+
+<p>Suspension is a feature that helps in implementing macros that are
+compliant with the text editor&#39;s language sensitive mode.</p>
+
+<p>By default Mucgly macros do not look like part of the host language, e.g. C
+language. However macros can be made to emulate the host language.</p>
+
+<p>For example the user might want to make the macro to look like a function
+call in the host language.</p>
+
+<p>The macro could be used like this:</p>
+
+<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_c'>c</span> <span class='op'>=</span> <span class='id identifier rubyid_rx'>rx</span><span class='lparen'>(</span> <span class='id identifier rubyid_inline_mult'>inline_mult</span><span class='lparen'>(</span> <span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>c</span><span class='tstring_end'>&quot;</span></span><span class='comma'>,</span> <span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>a1</span><span class='tstring_end'>&quot;</span></span> <span class='rparen'>)</span> <span class='rparen'>)</span><span class='semicolon'>;</span>
+</code></pre>
+
+<p>Here hookbeg is “rx(” and hookend is “)”. From the C language point of
+view, this looks like two nested function calls. “rx” is called and its
+argument is a return value from “inline_mult” function. From Ruby point of
+view, we want “inline_mult” to be called as a Ruby method. However, by
+default the macro would terminate to the first closing parenthesis, which
+would cause a syntax error in the end.</p>
+
+<p>The solution is to declare “(” as suspension character. Suspension
+character means that for each occurence of the suspension character, one
+hookend will be suspended, i.e. de-activated. Hence the first “(” after
+starting the macro with “rx(”, will suspend the next “)”, i.e. hookend.
+Since there is only one “(”, there will be only one suspension performed,
+and the final “)” will terminate the macro. The suspended hookend will be
+taken as part of the macro body.</p>
+
+<p>In order to get suspension, a multihook is declared including a suspension
+character/string.</p>
+
+<pre class="code ruby"><code class="ruby"><span class='tstring'><span class='regexp_beg'>/</span><span class='tstring_content'>*-&lt;+Mucgly.multihook( [ &quot;rx(&quot;, &quot;)&quot;, &quot;(&quot; ] )&gt;-*</span><span class='regexp_end'>/</span></span></code></pre>
+
+<p>Suspensions could be replaced with simple escape of the first “)” within
+the macro call, but this is inconvenient, and might potentially cause
+issues with language mode of the host language.</p>
+
+<p>Suspension mechanism is not bullet proof, and thus does not always
+guarantee language mode compatibility. Languages with C based syntax work
+well since they use the same style of function argument lists and string
+conventions as in Ruby. Other type of languages might not benefit from this
+feature.</p>
+
+<h3 id="label-Eater">Eater</h3>
+
+<p>Eater is character/string which follows hookesc and designates that the
+following char should be removed. This applies to both inside and outside
+macros. The reason for adding “extra” characters to input could be for
+example to trick the language mode of the host language to change coloring.</p>
+
+<p>Eater can be set with “:eater” or with “Mucgly.seteater”. If
+“Mucgly.seteater” is passed a nil, the Eater feature is disabled and
+hookesc behaves as by default.</p>
+
 <h2 id="label-Special+commands">Special commands</h2>
 
 <p>In addition to regular Ruby code the macros are allowed to include so
@@ -355,6 +414,9 @@ Hook-commands change the current hook values.</p>
 </dd><dt>hookesc
 <dd>
 <p>Get hookesc value.</p>
+</dd><dt>sethook
+<dd>
+<p>Set hookbeg and hookend values.</p>
 </dd><dt>sethookbeg
 <dd>
 <p>Set hookbeg value.</p>
@@ -466,9 +528,9 @@ GEM executable (i.e. same command line options).</p>
 </div></div>
 
     <div id="footer">
-  Generated on Sun Apr 24 19:00:00 2016 by
+  Generated on Mon Oct 24 20:35:30 2016 by
   <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
-  0.8.7.6 (ruby-2.1.2).
+  0.8.7.6 (ruby-2.3.1).
 </div>
 
   </body>

data/doc/top-level-namespace.html

@@ -103,9 +103,9 @@
 </div>
 
     <div id="footer">
-  Generated on Sun Apr 24 19:00:00 2016 by
+  Generated on Mon Oct 24 20:35:30 2016 by
   <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
-  0.8.7.6 (ruby-2.1.2).
+  0.8.7.6 (ruby-2.3.1).
 </div>
 
   </body>

data/ext/mucgly/mucgly.c

@@ -81,11 +81,13 @@ void mucgly_debug( void ) {}
 
 
 /**
- * Pair of hooks for macro beginning and end.
+ * Pair of hooks for macro beginning and end. Plus optional suspension
+ * marker.
  */
 typedef struct hookpair_s {
-  gchar* beg;                   /**< Hookbeg for input file. */
-  gchar* end;                   /**< Hookend for input file. */
+  gchar* beg;                   /**< Hookbeg for macro. */
+  gchar* end;                   /**< Hookend for macro. */
+  gchar* susp;                  /**< Suspender for macro. */
 } hookpair_t;
 
 
@@ -110,6 +112,7 @@ typedef struct stackfile_s {
 
   hookpair_t hook;     /**< Pair of hooks for macro boundary. */
   gchar* hookesc;      /**< Hookesc for input file. */
+  gchar* eater;        /**< Eater. */
 
   hookpair_t* multi;   /**< Pairs of hooks for multi-hooking. */
   int     multi_cnt;   /**< Number of pairs in multi-hooking. */
@@ -117,10 +120,10 @@ typedef struct stackfile_s {
   /** Current hook, as stack to support nesting macros. */
   GList* curhook;
 
-  /** Hookesc is same as hookbeg. Speeds up input processing. */
+  /** Hookesc is same as hookbeg. Speed-up for input processing. */
   gboolean hook_esc_eq_beg;
 
-  /** Hookesc is same as hookend. Speeds up input processing. */
+  /** Hookesc is same as hookend. Speed-up for input processing. */
   gboolean hook_esc_eq_end;
 
   /** Lookup-table for the first chars of hooks. Speeds up input processing. */
@@ -169,6 +172,7 @@ typedef struct pstate_s {
   GString* match_buf; /**< Match str buffer. */
 
   int in_macro;       /**< Processing within macro. */
+  int suspension;     /**< Suspension level. */
 
   GList* output;      /**< Stack of output streams. */
 
@@ -215,8 +219,9 @@ pstate_t* ruby_ps;
  * ------------------------------------------------------------ */
 
 void sf_update_hook_cache( stackfile_t* sf );
-void sf_multi_hook( stackfile_t* sf, const char* beg, const char* end );
+void sf_multi_hook( stackfile_t* sf, const char* beg, const char* end, const char* susp );
 gchar* ps_current_hookend( pstate_t* ps );
+gchar* ps_current_hooksusp( pstate_t* ps );
 
 
 
@@ -236,7 +241,7 @@ gchar* ps_current_hookend( pstate_t* ps );
 int len_str_cmp( char* str1, char* str2 )
 {
   int len = strlen( str1 );
-  
+
   if ( !strncmp( str1, str2, len ) )
     return len;
   else
@@ -339,17 +344,18 @@ void mucgly_fatal( stackfile_t* sf, char* format, ... )
 
 
 /**
- * Duplicate hookpair content.
+ * Copy hookpair content.
  *
  * @param from Source.
  * @param to   Destination.
  *
  * @return Destination.
  */
-hookpair_t* hookpair_dup( hookpair_t* from, hookpair_t* to )
+hookpair_t* hookpair_cpy( hookpair_t* from, hookpair_t* to )
 {
   to->beg = g_strdup( from->beg );
   to->end = g_strdup( from->end );
+  to->susp = g_strdup( from->susp );
   return to;
 }
 
@@ -363,6 +369,7 @@ void hookpair_del( hookpair_t* pair )
 {
   g_free( pair->beg );
   g_free( pair->end );
+  g_free( pair->susp );
 }
 
 
@@ -424,7 +431,7 @@ stackfile_t* sf_new( gchar* filename, stackfile_t* inherit )
   if ( inherit )
     {
       /* Inherited hook values. */
-      hookpair_dup( &inherit->hook, &sf->hook );
+      hookpair_cpy( &inherit->hook, &sf->hook );
       sf->hookesc = g_strdup( inherit->hookesc );
 
       /* Setup fast-lookup caches. */
@@ -434,7 +441,7 @@ stackfile_t* sf_new( gchar* filename, stackfile_t* inherit )
         {
           for ( int i = 0; i < inherit->multi_cnt; i++ )
             {
-              sf_multi_hook( sf, inherit->multi[i].beg, inherit->multi[i].end );
+              sf_multi_hook( sf, inherit->multi[i].beg, inherit->multi[i].end, inherit->multi[i].susp  );
             }
         }
     }
@@ -495,7 +502,7 @@ void sf_rem( stackfile_t* sf )
 
   hookpair_del( &sf->hook );
   g_free( sf->hookesc );
-  
+
   if ( sf->multi )
     {
       for ( int i = 0; i < sf->multi_cnt; i++ )
@@ -517,7 +524,7 @@ void sf_rem( stackfile_t* sf )
 int sf_get( stackfile_t* sf )
 {
   int ret;
- 
+
  re_read:
   if ( sf->buf->len > 0 )
     {
@@ -615,6 +622,8 @@ void sf_update_hook_cache( stackfile_t* sf )
       /* Add the latest addition to 1st char lookup. */
       sf->hook_1st_chars[ sf->multi[ sf->multi_cnt-1 ].beg[0] ] = 1;
       sf->hook_1st_chars[ sf->multi[ sf->multi_cnt-1 ].end[0] ] = 1;
+      if ( sf->multi[ sf->multi_cnt-1 ].susp )
+        sf->hook_1st_chars[ sf->multi[ sf->multi_cnt-1 ].susp[0] ] = 1;
 
       sf->hook_1st_chars[ sf->hookesc[0] ] = 1;
     }
@@ -681,6 +690,24 @@ void sf_set_hook( stackfile_t* sf, hook_t hook, char* value )
 }
 
 
+/**
+ * Set eater value.
+ *
+ * @param sf     Stackfile.
+ * @param value  New eater value.
+ */
+void sf_set_eater( stackfile_t* sf, char* value )
+{
+  if ( sf->eater )
+    g_free( sf->eater );
+
+  sf->eater = NULL;
+  if ( value )
+    sf->eater = g_strdup( value );
+}
+
+
+
 /**
  * Add multi-hook pair.
  *
@@ -688,7 +715,7 @@ void sf_set_hook( stackfile_t* sf, hook_t hook, char* value )
  * @param beg   Hookbeg of pair.
  * @param end   Hookend of pair.
  */
-void sf_multi_hook( stackfile_t* sf, const char* beg, const char* end )
+void sf_multi_hook( stackfile_t* sf, const char* beg, const char* end, const char* susp )
 {
   /* Check that hooks don't match escape. */
   if ( !g_strcmp0( sf->hookesc, beg )
@@ -702,7 +729,7 @@ void sf_multi_hook( stackfile_t* sf, const char* beg, const char* end )
     {
       /* Allocate enough pairs. */
       sf->multi = g_new0( hookpair_t, MULTI_LIMIT );
-      sf->multi[0] = (hookpair_t) {0,0};
+      sf->multi[0] = (hookpair_t) {0,0,0};
       sf->multi_cnt = 0;
 
       /* Clear non-multi-mode lookups. */
@@ -717,8 +744,10 @@ void sf_multi_hook( stackfile_t* sf, const char* beg, const char* end )
 
   sf->multi[sf->multi_cnt].beg = g_strdup( beg );
   sf->multi[sf->multi_cnt].end = g_strdup( end );
+  sf->multi[sf->multi_cnt].susp = g_strdup( susp );
+
   sf->multi_cnt++;
-  sf->multi[sf->multi_cnt] = (hookpair_t) {0,0};
+  sf->multi[sf->multi_cnt] = (hookpair_t) {0,0,0};
 
   sf_update_hook_cache( sf );
 }
@@ -1040,10 +1069,11 @@ pstate_t* ps_new( gchar* outfile )
   ps->fs = fs_new();
 
   ps->in_macro = 0;
+  ps->suspension = 0;
 
   /* Preview input buffer. */
   ps->check_buf = g_string_sized_new( 0 );
-  
+
   /* Top level input buffer. */
   ps->macro_buf = g_string_sized_new( 0 );
 
@@ -1068,7 +1098,7 @@ pstate_t* ps_new( gchar* outfile )
 void ps_rem( pstate_t* ps )
 {
   fs_rem( ps->fs );
-  
+
   g_string_free( ps->check_buf, TRUE );
   g_string_free( ps->macro_buf, TRUE );
 
@@ -1121,10 +1151,10 @@ gboolean ps_check( pstate_t* ps, gchar* match, gboolean erase )
   GString* input;
   int len;
   gboolean ret;
-  
+
   /* Dup match string since it might disappear if Filestack stack is
      popped. */
-  
+
   g_string_assign( ps->match_buf, match );
 
   len = strlen( match );
@@ -1178,7 +1208,7 @@ void ps_push_curhook( stackfile_t* sf, hookpair_t* pair )
 {
   sf->curhook = g_list_prepend(
     sf->curhook,
-    hookpair_dup( pair, g_new0( hookpair_t, 1 ) ) );
+    hookpair_cpy( pair, g_new0( hookpair_t, 1 ) ) );
 }
 
 
@@ -1252,12 +1282,51 @@ gboolean ps_check_hookend( pstate_t* ps )
 }
 
 
+/**
+ * Check input for hooksusp.
+ *
+ * @param ps Pstate.
+ *
+ * @return TRUE on match.
+ */
+gboolean ps_check_hooksusp( pstate_t* ps )
+{
+  gchar* susp;
+
+  if ( !ps_has_file(ps) )
+    return FALSE;
+  else if ( susp = ps_current_hooksusp(ps) )
+    return ps_check( ps, susp, TRUE );
+  else
+    return FALSE;
+}
+
+
+/**
+ * Check input for eater.
+ *
+ * @param ps Pstate.
+ *
+ * @return TRUE on match.
+ */
+gboolean ps_check_eater( pstate_t* ps )
+{
+  if ( !ps_has_file(ps) )
+    return FALSE;
+
+  if ( ps_topfile(ps)->eater )
+    return ps_check( ps, ps_topfile(ps)->eater, TRUE );
+  else
+    return FALSE;
+}
+
+
 /**
  * Return hookbeg string that opened the current macro.
  *
  * @param ps PState.
  *
- * @return 
+ * @return
  */
 gchar* ps_current_hookbeg( pstate_t* ps )
 {
@@ -1268,11 +1337,11 @@ gchar* ps_current_hookbeg( pstate_t* ps )
 
 
 /**
- * Return hookend string that opened the current macro.
+ * Return hookend string that closes the current macro.
  *
  * @param ps PState.
  *
- * @return 
+ * @return
  */
 gchar* ps_current_hookend( pstate_t* ps )
 {
@@ -1282,6 +1351,20 @@ gchar* ps_current_hookend( pstate_t* ps )
 }
 
 
+/**
+ * Return hooksusp string that suspends the current hookend.
+ *
+ * @param ps PState.
+ *
+ * @return
+ */
+gchar* ps_current_hooksusp( pstate_t* ps )
+{
+  hookpair_t* h;
+  h = ps_topfile(ps)->curhook->data;
+  return h->susp;
+}
+
 
 /**
  * Get char (through Filestack).
@@ -1310,7 +1393,7 @@ void ps_out( pstate_t* ps, int c )
     {
       if ( c == '\n' )
         of->lineno++;
-      
+
       fputc( c, of->fh );
       if ( ps->flush )
         fflush( of->fh );
@@ -1432,6 +1515,18 @@ void ps_collect( pstate_t* ps, int c )
 }
 
 
+/**
+ * Add str content to macro.
+ *
+ * @param ps  Pstate.
+ * @param str String to add.
+ */
+void ps_collect_str( pstate_t* ps, gchar* str )
+{
+  g_string_append( ps->macro_buf, str );
+}
+
+
 /**
  * Enter first level macro and setup state accordingly.
  *
@@ -1444,7 +1539,7 @@ void ps_enter_macro( pstate_t* ps )
 
   /* Store macro start info. */
   sf_mark_macro( ps_topfile( ps ) );
-                  
+
   ps_start_collect( ps );
 }
 
@@ -1553,7 +1648,7 @@ void ps_load_ruby_file( pstate_t* ps, gchar* filename )
 gboolean ps_eval_cmd( pstate_t* ps )
 {
   char* cmd;
-  
+
   cmd = ps_get_macro( ps );
 
   if ( cmd[0] == ':' )
@@ -1570,6 +1665,8 @@ gboolean ps_eval_cmd( pstate_t* ps )
         sf_set_hook( ps_topfile(ps), hook_end, &cmd[ len+1 ] );
       else if ( ( len = len_str_cmp( ":hookesc", cmd ) ) )
         sf_set_hook( ps_topfile(ps), hook_esc, &cmd[ len+1 ] );
+      else if ( ( len = len_str_cmp( ":eater", cmd ) ) )
+        sf_set_eater( ps_topfile(ps), &cmd[ len+1 ] );
 
       else if ( ( len = len_str_cmp( ":hookall", cmd ) ) )
         {
@@ -1581,7 +1678,7 @@ gboolean ps_eval_cmd( pstate_t* ps )
       else if ( ( len = len_str_cmp( ":hook", cmd ) ) )
         {
           gchar** pieces;
-          
+
           pieces = g_strsplit( &cmd[ len+1 ], " ", 2 );
           if ( g_strv_length( pieces ) == 2 )
             {
@@ -1629,13 +1726,13 @@ gboolean ps_eval_cmd( pstate_t* ps )
           mucgly_error( ps_topfile(ps), "Unknown internal command: \"%s\"", &cmd[len+1] );
         }
     }
-  
+
   else if ( cmd[0] == '.' )
     {
       /* Mucgly variable output. */
       ps_out_str( ps, ps_eval_ruby_str( ps, &cmd[1], TRUE, NULL ) );
     }
-        
+
   else if ( cmd[0] == '/' )
     {
       /* Mucgly comment, do nothing. */
@@ -1652,7 +1749,7 @@ gboolean ps_eval_cmd( pstate_t* ps )
 
       ps_out_str( ps, ps_current_hookend( ps ) );
     }
-        
+
   else
     {
       /* Ruby code execution. */
@@ -1703,7 +1800,7 @@ void ps_process_hook_end_seq( pstate_t* ps, gboolean* do_break )
           ps->post_pop = FALSE;
           fs_pop_file( ps->fs );
         }
-    }                                                         
+    }
 }
 
 
@@ -1770,7 +1867,7 @@ void ps_process_file( pstate_t* ps, gchar* infile, gchar* outfile )
 
   for (;;)
     {
-      
+
       /* For each input char, we must explicitly read it since
          otherwise the Filestack does not operate correctly, i.e. we
          are not allowed to put back to stream after EOF has been
@@ -1804,7 +1901,6 @@ void ps_process_file( pstate_t* ps, gchar* infile, gchar* outfile )
                     }
                   else
                     {
-                  
                       if ( ( c == ' ' || c == '\n' ) &&
                            ps_topfile(ps)->hook_esc_eq_end )
                         {
@@ -1813,6 +1909,15 @@ void ps_process_file( pstate_t* ps, gchar* infile, gchar* outfile )
                           if ( do_break )
                             break;
                         }
+                      else if ( ps_topfile(ps)->eater
+                                && ps_topfile(ps)->eater[0] == c )
+                        {
+                          fs_put( ps->fs, c );
+                          if ( ps_check_eater( ps ) )
+                            ps_in( ps );
+                          else
+                            ps_collect( ps, c );
+                        }
                       else
                         {
                           ps_collect( ps, c );
@@ -1832,6 +1937,15 @@ void ps_process_file( pstate_t* ps, gchar* infile, gchar* outfile )
                       /* EOF */
                       break;
                     }
+                  else if ( ps_topfile(ps)->eater
+                            && ps_topfile(ps)->eater[0] == c )
+                    {
+                      fs_put( ps->fs, c );
+                      if ( ps_check_eater( ps ) )
+                        ps_in( ps );
+                      else
+                        ps_out( ps, c );
+                    }
                   else
                     {
 
@@ -1862,7 +1976,7 @@ void ps_process_file( pstate_t* ps, gchar* infile, gchar* outfile )
                                 {
                                   /* Escape is same as hookbeg and escape is
                                      not used to eat out spaces. */
-                          
+
                                   /* Put back the extra char (for safety/clarity). */
                                   fs_put( ps->fs, c );
 
@@ -1871,7 +1985,7 @@ void ps_process_file( pstate_t* ps, gchar* infile, gchar* outfile )
                                      hook. */
                                   ps_push_curhook( ps_topfile(ps), &ps_topfile(ps)->hook );
 
-                                  /* Start collect the macro content. */
+                                  /* Start to collect the macro content. */
                                   ps_enter_macro( ps );
                                 }
                             }
@@ -1882,16 +1996,29 @@ void ps_process_file( pstate_t* ps, gchar* infile, gchar* outfile )
                             }
                         }
                     }
-              
+
                 }
             }
+          else if ( ps->in_macro && ps_check_hooksusp( ps ) )
+            {
+              ps->suspension++;
+              ps_collect_str( ps, ps_current_hooksusp( ps ) );
+            }
           else if ( ps->in_macro && ps_check_hookend( ps ) )
             {
               /* Hookend has priority over hookbeg if we are in
                  macro. Also hookend is ignored when outside macro. */
-              ps_process_hook_end_seq( ps, &do_break );
-              if ( do_break )
-                break;
+              if ( ps->suspension == 0 )
+                {
+                  ps_process_hook_end_seq( ps, &do_break );
+                  if ( do_break )
+                    break;
+                }
+              else
+                {
+                  ps->suspension--;
+                  ps_collect_str( ps, ps_current_hookend( ps ) );
+                }
             }
           else if ( ps_check_hookbeg( ps ) )
             {
@@ -1958,7 +2085,7 @@ VALUE mucgly_write( VALUE obj, VALUE rstr )
   else
     /* Convert to Ruby String. */
     tmp = rb_inspect( rstr );
-    
+
   str = RSTRING_PTR( tmp );
   ps_out_str( ruby_ps, str );
   return Qnil;
@@ -1983,7 +2110,7 @@ VALUE mucgly_puts( VALUE obj, VALUE rstr )
   else
     /* Convert to Ruby String. */
     tmp = rb_inspect( rstr );
-    
+
   str = RSTRING_PTR( tmp );
 
   ps_out_str( ruby_ps, str );
@@ -2031,6 +2158,31 @@ VALUE mucgly_hookesc( VALUE obj )
 }
 
 
+/**
+ * Mucgly.sethook method. Set both hookben and hookend.
+ *
+ * @param obj  Not used.
+ * @param ary  Array of hookpairs.
+ *
+ * @return Qnil.
+ */
+VALUE mucgly_sethook( VALUE obj, VALUE hookbeg, VALUE hookend )
+{
+  char* beg, *end;
+
+  Check_Type( hookbeg, T_STRING );
+  Check_Type( hookend, T_STRING );
+
+  beg = RSTRING_PTR( hookbeg );
+  sf_set_hook( ps_topfile( ruby_ps ), hook_beg, beg );
+
+  end = RSTRING_PTR( hookend );
+  sf_set_hook( ps_topfile( ruby_ps ), hook_end, end );
+
+  return Qnil;
+}
+
+
 /**
  * Mucgly.sethookbeg method. Set hookbeg.
  *
@@ -2042,6 +2194,7 @@ VALUE mucgly_hookesc( VALUE obj )
 VALUE mucgly_sethookbeg( VALUE obj, VALUE rstr )
 {
   char* str;
+  Check_Type( rstr, T_STRING );
   str = RSTRING_PTR( rstr );
   sf_set_hook( ps_topfile( ruby_ps ), hook_beg, str );
   return Qnil;
@@ -2059,6 +2212,7 @@ VALUE mucgly_sethookbeg( VALUE obj, VALUE rstr )
 VALUE mucgly_sethookend( VALUE obj, VALUE rstr )
 {
   char* str;
+  Check_Type( rstr, T_STRING );
   str = RSTRING_PTR( rstr );
   sf_set_hook( ps_topfile( ruby_ps ), hook_end, str );
   return Qnil;
@@ -2076,33 +2230,130 @@ VALUE mucgly_sethookend( VALUE obj, VALUE rstr )
 VALUE mucgly_sethookesc( VALUE obj, VALUE rstr )
 {
   char* str;
+  Check_Type( rstr, T_STRING );
   str = RSTRING_PTR( rstr );
   sf_set_hook( ps_topfile( ruby_ps ), hook_esc, str );
   return Qnil;
 }
 
 
+/**
+ * Mucgly.seteater method. Set eater.
+ *
+ * @param obj  Not used.
+ * @param rstr Eater string (Ruby String).
+ *
+ * @return Qnil.
+ */
+VALUE mucgly_seteater( VALUE obj, VALUE rstr )
+{
+  char* str;
+
+  if ( RB_TYPE_P( rstr, T_NIL ) )
+    {
+      sf_set_eater( ps_topfile( ruby_ps ), NULL );
+    }
+  else
+    {
+      Check_Type( rstr, T_STRING );
+      str = RSTRING_PTR( rstr );
+      sf_set_eater( ps_topfile( ruby_ps ), str );
+    }
+
+  return Qnil;
+}
+
+
 /**
  * Mucgly.multihook method. Add multihook pairs.
  *
+ * Arg options:
+ *  [ hb1, he1, su1 ], [ hb2, he2, su2 ], [ hb3, he3 ], ...
+ *  [ hb1, he1, hb2, he2, hb3, he3 ]
+ *  hb1, he1, hb2, he2, hb3, he3, ...
+ *
  * @param obj  Not used.
  * @param ary  Array of hookpairs.
  *
  * @return Qnil.
  */
-VALUE mucgly_multihook( VALUE obj, VALUE ary )
+VALUE mucgly_multihook( int argc, VALUE* argv, VALUE obj )
 {
-  if ( ( RARRAY_LEN(ary) % 2 ) != 0 )
-    rb_raise( rb_eRuntimeError,
-              "mucgly: Must have even number of multi hook args, had %d!",
-              ((int) RARRAY_LEN(ary)) );
-  
-  char* beg, *end;
-  for ( int i = 0; i < RARRAY_LEN(ary); i += 2 )
+  char* beg, *end, *susp;
+
+  if ( RB_TYPE_P( argv[0], T_STRING ) )
     {
-      beg = RSTRING_PTR( RARRAY_PTR(ary)[i] );
-      end = RSTRING_PTR( RARRAY_PTR(ary)[i+1] );
-      sf_multi_hook( ps_topfile( ruby_ps ), beg, end );
+      if ( ( argc % 2 ) == 0 )
+        {
+          for ( int i = 0; i < argc; i += 2 )
+            {
+              beg = RSTRING_PTR( argv[i] );
+              end = RSTRING_PTR( argv[i+1] );
+              sf_multi_hook( ps_topfile( ruby_ps ), beg, end, NULL );
+            }
+        }
+      else
+        {
+          rb_raise( rb_eRuntimeError,
+                    "mucgly: Argument count must be even!" );
+        }
+    }
+  else if ( RB_TYPE_P( argv[0], T_ARRAY ) )
+    {
+      VALUE ary;
+
+      if ( argc > 1 )
+        {
+          /* Using suspensions. */
+
+          for ( int i = 0; i < argc; i++ )
+            {
+              ary = argv[i];
+              if ( RARRAY_LEN(ary) == 3 )
+                {
+                  beg = RSTRING_PTR( RARRAY_PTR(ary)[0] );
+                  end = RSTRING_PTR( RARRAY_PTR(ary)[1] );
+                  susp = RSTRING_PTR( RARRAY_PTR(ary)[2] );
+                  sf_multi_hook( ps_topfile( ruby_ps ), beg, end, susp );
+                }
+              else if ( RARRAY_LEN(ary) == 2 )
+                {
+                  beg = RSTRING_PTR( RARRAY_PTR(ary)[0] );
+                  end = RSTRING_PTR( RARRAY_PTR(ary)[1] );
+                  sf_multi_hook( ps_topfile( ruby_ps ), beg, end, NULL );
+                }
+              else
+                {
+                  rb_raise( rb_eRuntimeError,
+                            "mucgly: Array argument must either two or three long, i.e. beg, end, [susp]!" );
+                }
+            }
+        }
+      else
+        {
+          ary = argv[0];
+          if ( RARRAY_LEN(ary) == 3 )
+            {
+              beg = RSTRING_PTR( RARRAY_PTR(ary)[0] );
+              end = RSTRING_PTR( RARRAY_PTR(ary)[1] );
+              susp = RSTRING_PTR( RARRAY_PTR(ary)[2] );
+              sf_multi_hook( ps_topfile( ruby_ps ), beg, end, susp );
+            }
+          else if ( (RARRAY_LEN(ary) % 2) == 0 )
+            {
+              for ( int i = 0; i < RARRAY_LEN(ary); i += 2 )
+                {
+                  beg = RSTRING_PTR( RARRAY_PTR(ary)[i] );
+                  end = RSTRING_PTR( RARRAY_PTR(ary)[i+1] );
+                  sf_multi_hook( ps_topfile( ruby_ps ), beg, end, NULL );
+                }
+            }
+          else
+            {
+              rb_raise( rb_eRuntimeError,
+                        "mucgly: Array argument must have either three or even items!" );
+            }
+        }
     }
 
   return Qnil;
@@ -2177,6 +2428,7 @@ VALUE mucgly_pushinput( VALUE obj, VALUE rstr )
 {
   char* str;
 
+  Check_Type( rstr, T_STRING );
   str = RSTRING_PTR( rstr );
   fs_push_file_delayed( ruby_ps->fs, str );
   ruby_ps->post_push = TRUE;
@@ -2210,8 +2462,10 @@ VALUE mucgly_pushoutput( VALUE obj, VALUE rstr )
 {
   char* str;
 
+  Check_Type( rstr, T_STRING );
   str = RSTRING_PTR( rstr );
   ps_push_file( ruby_ps, str );
+
   return Qnil;
 }
 
@@ -2307,10 +2561,12 @@ void Init_mucgly( void )
   rb_define_module_function( mMucgly, "hookbeg", mucgly_hookbeg, 0 );
   rb_define_module_function( mMucgly, "hookend", mucgly_hookend, 0 );
   rb_define_module_function( mMucgly, "hookesc", mucgly_hookesc, 0 );
+  rb_define_module_function( mMucgly, "sethook", mucgly_sethook, -1 );
   rb_define_module_function( mMucgly, "sethookbeg", mucgly_sethookbeg, 1 );
   rb_define_module_function( mMucgly, "sethookend", mucgly_sethookend, 1 );
   rb_define_module_function( mMucgly, "sethookesc", mucgly_sethookesc, 1 );
-  rb_define_module_function( mMucgly, "multihook", mucgly_multihook, 1 );
+  rb_define_module_function( mMucgly, "seteater", mucgly_seteater, 1 );
+  rb_define_module_function( mMucgly, "multihook", mucgly_multihook, -1 );
   rb_define_module_function( mMucgly, "ifilename", mucgly_ifilename, 0 );
   rb_define_module_function( mMucgly, "ilinenumber", mucgly_ilinenumber, 0 );
   rb_define_module_function( mMucgly, "ofilename", mucgly_ofilename, 0 );
@@ -2369,7 +2625,7 @@ gchar* infile_to_outfile( gchar* infile, gchar* outfile_tag )
  */
 void mucgly_main( int argc, char** argv )
 {
-  
+
   /* Setup default hooks etc. */
   stack_default = sf_new( NULL, NULL );
 
@@ -2535,7 +2791,8 @@ void mucgly_main( int argc, char** argv )
         {
           sf_multi_hook( stack_default,
                          opt_multi_sep[ cnt ],
-                         opt_multi_sep[ cnt+1 ] );
+                         opt_multi_sep[ cnt+1 ],
+                         NULL );
           cnt += 2;
         }
     }