mucgly 0.1.1 → 0.2.0

data/ext/mucgly/mucgly.c

@@ -1,3 +1,14 @@
+/**
+ * @file   mucgly.c
+ * @author Tero Isannainen <tero.isannainen@gmail.com>
+ * @date   Sat Apr 23 12:41:02 2016
+ *
+ * @brief  Inline macro processor.
+ *
+ * See README.rdoc for full documentation of Mucgly.
+ */
+
+
 #include <glib.h>
 #include <glib/gstdio.h>
 #include <ruby.h>
@@ -18,10 +29,14 @@ void mucgly_main( int argc, char** argv );
  * Debugging:
  * ------------------------------------------------------------ */
 
-/* Enable the define is input char based debugging is required. Set
-   GDB breakpoint at mucgly_debug. */
+/**
+ * Enable the define if input char based debugging is required. Set
+ * GDB breakpoint at mucgly_debug.
+ */
 void mucgly_debug( void ) {}
+
 #if 0
+/** Special char for invoking the debugger. */
 # define DEBUG_CHAR '~'
 #endif
 
@@ -52,33 +67,55 @@ void mucgly_debug( void ) {}
  */
 
 
+/** Default value for hookbeg. */
 #define HOOKBEG_DEFAULT "-<"
+
+/** Default value for hookend. */
 #define HOOKEND_DEFAULT ">-"
+
+/** Default value for hookesc. */
 #define HOOKESC_DEFAULT "\\"
 
+/** Multihook count limit, also array size. */
+#define MULTI_LIMIT 128
+
+
+/**
+ * Pair of hooks for macro beginning and end.
+ */
+typedef struct hookpair_s {
+  gchar* beg;                   /**< Hookbeg for input file. */
+  gchar* end;                   /**< Hookend for input file. */
+} hookpair_t;
 
 
 /**
  * Stackfile is an entry in the Filestack. Stackfile is the input file
  * for Mucgly.
  */
-struct stackfile_s {
+typedef struct stackfile_s {
 
-  gchar* filename;  /**< Filename. */
-  FILE* fh;         /**< IO stream handle. */
-  GString* buf;     /**< Put-back buffer (oldest-is-last). */
+  gchar* filename;     /**< Filename. */
+  FILE* fh;            /**< IO stream handle. */
+  GString* buf;        /**< Put-back buffer (oldest-is-last). */
 
-  int lineno;       /**< Line number (0->). */
-  int column;       /**< Line column (0->). */
-  int old_column;   /**< Prev column (used with putback). */
+  int lineno;          /**< Line number (0->). */
+  int column;          /**< Line column (0->). */
+  int old_column;      /**< Prev column (used with putback). */
+
+  gboolean macro;      /**< Macro active. */
+  int macro_line;      /**< Macro start line. */
+  int macro_col;       /**< Macro start column. */
+  gboolean eat_tail;   /**< Eat the char after macro (if not EOF). */
+
+  hookpair_t hook;     /**< Pair of hooks for macro boundary. */
+  gchar* hookesc;      /**< Hookesc for input file. */
 
-  gboolean macro;   /**< Macro active. */
-  int macro_line;   /**< Macro start line. */
-  int macro_col;    /**< Macro start column. */
+  hookpair_t* multi;   /**< Pairs of hooks for multi-hooking. */
+  int     multi_cnt;   /**< Number of pairs in multi-hooking. */
 
-  gchar* hookbeg;   /**< Hookbeg for input file. */
-  gchar* hookend;   /**< Hookend for input file. */
-  gchar* hookesc;   /**< Hookesc for input file. */
+  /** Current hook, as stack to support nesting macros. */
+  GList* curhook;
 
   /** Hookesc is same as hookbeg. Speeds up input processing. */
   gboolean hook_esc_eq_beg;
@@ -86,11 +123,10 @@ struct stackfile_s {
   /** Hookesc is same as hookend. Speeds up input processing. */
   gboolean hook_esc_eq_end;
 
-  /** Hookesc is same as hookend. Speeds up input processing. */
+  /** Lookup-table for the first chars of hooks. Speeds up input processing. */
   guchar hook_1st_chars[ 256 ];
 
-};
-typedef struct stackfile_s stackfile_t;
+} stackfile_t;
 
 
 
@@ -102,10 +138,9 @@ typedef struct stackfile_s stackfile_t;
  * EOF is encountered, it is popped of the stack. This makes the
  * character flow continuous from the parser point of view.
  */
-struct filestack_s {
+typedef struct filestack_s {
   GList* file;           /**< Stack of files. */
-};
-typedef struct filestack_s filestack_t;
+} filestack_t;
 
 
 
@@ -114,19 +149,19 @@ typedef struct filestack_s filestack_t;
  * from the default output to another output file temporarely. Note
  * that the diverted output stream has to be closed as well.
  */
-struct outfile_s {
-  gchar* filename; /**< Filename. */
-  FILE* fh;        /**< Stream handle. */
-  int lineno;      /**< Line number (0->). */
-};
-typedef struct outfile_s outfile_t;
+typedef struct outfile_s {
+  gchar* filename;  /**< Filename. */
+  FILE* fh;         /**< Stream handle. */
+  int lineno;       /**< Line number (0->). */
+  gboolean blocked; /**< Blocked output for IO stream. */
+} outfile_t;
 
 
 
 /**
  * Parser state for Mucgly.
  */
-struct pstate_s {
+typedef struct pstate_s {
   filestack_t* fs;    /**< Stack of input streams. */
 
   GString* check_buf; /**< Preview buffer. */
@@ -138,8 +173,11 @@ struct pstate_s {
   GList* output;      /**< Stack of output streams. */
 
   gboolean flush;     /**< Flush out-stream immediately. */
-};
-typedef struct pstate_s pstate_t;
+
+  gboolean post_push; /**< Move up in fs after macro processing. */
+  gboolean post_pop;  /**< Move down in fs after macro processing. */
+
+} pstate_t;
 
 
 /** Hook type enum. */
@@ -149,11 +187,9 @@ typedef enum hook_e { hook_none, hook_end, hook_beg, hook_esc } hook_t;
 /** Current filestack from pstate_t (for convenience). */
 #define ps_has_file(ps)  ((stackfile_t*)(ps)->fs->file)
 
-
 /** Current stackfile from pstate_t (for convenience). */
 #define ps_topfile(ps)   ((stackfile_t*)(ps)->fs->file->data)
 
-
 /** Current stackfile from filestack_t (for convenience). */
 #define fs_topfile(fs) ((stackfile_t*)(fs)->file->data)
 
@@ -166,7 +202,7 @@ typedef enum hook_e { hook_none, hook_end, hook_beg, hook_esc } hook_t;
 /** Default hook settings. */
 stackfile_t* stack_default = NULL;
 
-/** Pointer to current file. Usefull for debugging. */
+/** Pointer to current file. Useful for debugging. */
 stackfile_t* csf;
 
 /** Ruby side reference to parser. */
@@ -178,7 +214,9 @@ pstate_t* ruby_ps;
  * Function declarations:
  * ------------------------------------------------------------ */
 
-void sf_set_hook( stackfile_t* sf, hook_t hook, char* value );
+void sf_update_hook_cache( stackfile_t* sf );
+void sf_multi_hook( stackfile_t* sf, const char* beg, const char* end );
+gchar* ps_current_hookend( pstate_t* ps );
 
 
 
@@ -189,10 +227,10 @@ void sf_set_hook( stackfile_t* sf, hook_t hook, char* value );
 
 /**
  * Compare two strings upto length of str1.
- * 
+ *
  * @param str1 String 1.
  * @param str2 String 2.
- * 
+ *
  * @return Match length (0 for no match).
  */
 int len_str_cmp( char* str1, char* str2 )
@@ -208,7 +246,7 @@ int len_str_cmp( char* str1, char* str2 )
 
 /**
  * Common routine for user info message output.
- * 
+ *
  * @param sf Currently processed file (or NULL).
  * @param infotype Severity type.
  * @param format Message (printf) formatter.
@@ -255,7 +293,7 @@ void mucgly_user_info( stackfile_t* sf, char* infotype, char* format, va_list ap
 
 /**
  * Report warning to user (no exit).
- * 
+ *
  * @param sf Current input file.
  * @param format Message formatter.
  */
@@ -270,7 +308,7 @@ void mucgly_warn( stackfile_t* sf, char* format, ... )
 
 /**
  * Report error to user (and exit).
- * 
+ *
  * @param sf Current input file.
  * @param format Message formatter.
  */
@@ -286,7 +324,7 @@ void mucgly_error( stackfile_t* sf, char* format, ... )
 
 /**
  * Report fatal error to user (and exit).
- * 
+ *
  * @param sf Current input file.
  * @param format Message formatter.
  */
@@ -300,12 +338,40 @@ void mucgly_fatal( stackfile_t* sf, char* format, ... )
 }
 
 
+/**
+ * Duplicate hookpair content.
+ *
+ * @param from Source.
+ * @param to   Destination.
+ *
+ * @return Destination.
+ */
+hookpair_t* hookpair_dup( hookpair_t* from, hookpair_t* to )
+{
+  to->beg = g_strdup( from->beg );
+  to->end = g_strdup( from->end );
+  return to;
+}
+
+
+/**
+ * Free allocated hookpair memory.
+ *
+ * @param pair Pair to dealloc.
+ */
+void hookpair_del( hookpair_t* pair )
+{
+  g_free( pair->beg );
+  g_free( pair->end );
+}
+
+
 /**
  * Create new Stackfile.
- * 
+ *
  * @param filename Filename (NULL for stdin).
  * @param inherit Inherit hooks source (NULL for defaults).
- * 
+ *
  * @return Stackfile.
  */
 stackfile_t* sf_new( gchar* filename, stackfile_t* inherit )
@@ -347,25 +413,41 @@ stackfile_t* sf_new( gchar* filename, stackfile_t* inherit )
   sf->macro = FALSE;
   sf->macro_line = 0;
   sf->macro_col = 0;
+  sf->eat_tail = FALSE;
+
+  sf->multi = NULL;
+  sf->multi_cnt = 0;
+
+  sf->curhook = NULL;
 
 
   if ( inherit )
     {
       /* Inherited hook values. */
-      sf->hookbeg = g_strdup( inherit->hookbeg );
-      sf->hookend = g_strdup( inherit->hookend );
+      hookpair_dup( &inherit->hook, &sf->hook );
       sf->hookesc = g_strdup( inherit->hookesc );
+
+      /* Setup fast-lookup caches. */
+      sf_update_hook_cache( sf );
+
+      if ( inherit->multi )
+        {
+          for ( int i = 0; i < inherit->multi_cnt; i++ )
+            {
+              sf_multi_hook( sf, inherit->multi[i].beg, inherit->multi[i].end );
+            }
+        }
     }
   else
     {
       /* Default hook values. */
-      sf->hookbeg = g_strdup( HOOKBEG_DEFAULT );
-      sf->hookend = g_strdup( HOOKEND_DEFAULT );
+      sf->hook.beg = g_strdup( HOOKBEG_DEFAULT );
+      sf->hook.end = g_strdup( HOOKEND_DEFAULT );
       sf->hookesc = g_strdup( HOOKESC_DEFAULT );
-    }
 
-  /* Setup fast-lookup caches. */
-  sf_set_hook( sf, hook_none, NULL );
+      /* Setup fast-lookup caches. */
+      sf_update_hook_cache( sf );
+    }
 
   return sf;
 }
@@ -373,7 +455,7 @@ stackfile_t* sf_new( gchar* filename, stackfile_t* inherit )
 
 /**
  * Store macro start info.
- * 
+ *
  * @param sf Stackfile.
  */
 void sf_mark_macro( stackfile_t* sf )
@@ -386,7 +468,7 @@ void sf_mark_macro( stackfile_t* sf )
 
 /**
  * Reset macro start info.
- * 
+ *
  * @param sf Stackfile.
  */
 void sf_unmark_macro( stackfile_t* sf )
@@ -397,7 +479,7 @@ void sf_unmark_macro( stackfile_t* sf )
 
 /**
  * Free Stackfile and close the file stream.
- * 
+ *
  * @param sf Stackfile.
  */
 void sf_rem( stackfile_t* sf )
@@ -411,42 +493,44 @@ void sf_rem( stackfile_t* sf )
 
   g_free( sf->filename );
 
-  g_free( sf->hookbeg );
-  g_free( sf->hookend );
+  hookpair_del( &sf->hook );
   g_free( sf->hookesc );
   
+  if ( sf->multi )
+    {
+      for ( int i = 0; i < sf->multi_cnt; i++ )
+        hookpair_del( &sf->multi[i] );
+      g_free( sf->multi );
+    }
+
   g_free( sf );
 }
 
 
 /**
  * Get char from Stackfile.
- * 
+ *
  * @param sf Stackfile.
- * 
+ *
  * @return Char or EOF.
  */
 int sf_get( stackfile_t* sf )
 {
   int ret;
-
+ 
+ re_read:
   if ( sf->buf->len > 0 )
     {
-
       /* Pending chars in buffer, don't need to read file (yet). */
-
       int pos = sf->buf->len-1;
 
       /* Use buffer as stack with oldest (first to use) on right. */
       ret = sf->buf->str[ pos ];
       g_string_truncate( sf->buf, pos );
-
     }
   else
     {
-
       /* Read from actual file stream. */
-
 #ifdef DEBUG_CHAR
       ret = fgetc( sf->fh );
       if ( DEBUG_CHAR == (char) ret )
@@ -475,16 +559,24 @@ int sf_get( stackfile_t* sf )
         }
     }
 
+  if ( sf->eat_tail == TRUE )
+    {
+      /* Eat tail if not in EOF. */
+      sf->eat_tail = FALSE;
+      if ( ret != EOF )
+        goto re_read;
+    }
+
   return ret;
 }
 
 
 /**
  * Put char back to Stackfile.
- * 
+ *
  * @param sf Stackfile.
  * @param c char.
- * 
+ *
  * @return TRUE.
  */
 gboolean sf_put( stackfile_t* sf, char c )
@@ -508,48 +600,133 @@ gboolean sf_put( stackfile_t* sf, char c )
 
 
 /**
- * Set hook value.
- * 
+ * Update the hooks related cache/lookup entries.
+ *
  * @param sf Stackfile.
- * @param hook Hook type.
+ */
+void sf_update_hook_cache( stackfile_t* sf )
+{
+  if ( sf->multi )
+    {
+      /* Esc can never match multihooks. */
+      sf->hook_esc_eq_beg = FALSE;
+      sf->hook_esc_eq_end = FALSE;
+
+      /* 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;
+
+      sf->hook_1st_chars[ sf->hookesc[0] ] = 1;
+    }
+  else
+    {
+      /* Store these equalities for speed-up. */
+      if ( !g_strcmp0( sf->hookesc, sf->hook.beg ) )
+        sf->hook_esc_eq_beg = TRUE;
+      else
+        sf->hook_esc_eq_beg = FALSE;
+
+      if ( !g_strcmp0( sf->hookesc, sf->hook.end ) )
+        sf->hook_esc_eq_end = TRUE;
+      else
+        sf->hook_esc_eq_end = FALSE;
+
+      /* Initialize 1st char lookup. */
+      memset( sf->hook_1st_chars, 0, 256 * sizeof( guchar ) );
+
+      /* Hook 1st char lookup. */
+      sf->hook_1st_chars[ sf->hook.beg[0] ] = 1;
+      sf->hook_1st_chars[ sf->hook.end[0] ] = 1;
+      sf->hook_1st_chars[ sf->hookesc[0] ] = 1;
+    }
+}
+
+
+/**
+ * Set hook value.
+ *
+ * @param sf    Stackfile.
+ * @param hook  Hook type.
  * @param value New hook value.
  */
 void sf_set_hook( stackfile_t* sf, hook_t hook, char* value )
 {
+  /* Check that we are not in multi-hook mode. */
+  if ( sf->multi && hook != hook_esc )
+    {
+      /* Disable multi-hook mode. */
+      for ( int i = 0; i < sf->multi_cnt; i++ )
+        hookpair_del( &sf->multi[i] );
+      g_free( sf->multi );
+      sf->multi_cnt = 0;
+    }
 
   /* Set values. */
   switch ( hook )
     {
-    case hook_beg: g_free( sf->hookbeg ); sf->hookbeg = g_strdup( value ); break;
-    case hook_end: g_free( sf->hookend ); sf->hookend = g_strdup( value ); break;
-    case hook_esc: g_free( sf->hookesc ); sf->hookesc = g_strdup( value ); break;
+    case hook_beg: g_free( sf->hook.beg ); sf->hook.beg = g_strdup( value ); break;
+    case hook_end: g_free( sf->hook.end ); sf->hook.end = g_strdup( value ); break;
+    case hook_esc:
+      {
+        /* Remove old esc from 1st char lookup. */
+        sf->hook_1st_chars[ sf->hookesc[0] ] = 0;
+        g_free( sf->hookesc );
+        sf->hookesc = g_strdup( value );
+        break;
+      }
     default: break;
     }
 
+  sf_update_hook_cache( sf );
+}
 
-  /* Store these equalities for speed-up. */
 
-  if ( !g_strcmp0( sf->hookesc, sf->hookbeg ) )
-    sf->hook_esc_eq_beg = TRUE;
-  else
-    sf->hook_esc_eq_beg = FALSE;
+/**
+ * Add multi-hook pair.
+ *
+ * @param sf    Stackfile.
+ * @param beg   Hookbeg of pair.
+ * @param end   Hookend of pair.
+ */
+void sf_multi_hook( stackfile_t* sf, const char* beg, const char* end )
+{
+  /* Check that hooks don't match escape. */
+  if ( !g_strcmp0( sf->hookesc, beg )
+       || !g_strcmp0( sf->hookesc, end ) )
+    {
+      g_print( "mucgly: Esc hook is not allowed to match multihooks\n" );
+      exit( EXIT_FAILURE );
+    }
 
-  if ( !g_strcmp0( sf->hookesc, sf->hookend ) )
-    sf->hook_esc_eq_end = TRUE;
-  else
-    sf->hook_esc_eq_end = FALSE;
+  if ( sf->multi == NULL )
+    {
+      /* Allocate enough pairs. */
+      sf->multi = g_new0( hookpair_t, MULTI_LIMIT );
+      sf->multi[0] = (hookpair_t) {0,0};
+      sf->multi_cnt = 0;
+
+      /* Clear non-multi-mode lookups. */
+      memset( sf->hook_1st_chars, 0, 256 * sizeof( guchar ) );
+    }
 
-  /* Hook 1st char lookup. */
-  memset( sf->hook_1st_chars, 0, 256 * sizeof( guchar ) );
-  sf->hook_1st_chars[ sf->hookbeg[0] ] = 1;
-  sf->hook_1st_chars[ sf->hookend[0] ] = 1;
-  sf->hook_1st_chars[ sf->hookesc[0] ] = 1;
+  if ( sf->multi_cnt >= (MULTI_LIMIT-1) )
+    {
+      g_print( "mucgly: Too many multihooks, 127 allowed!\n" );
+      exit( EXIT_FAILURE );
+    }
+
+  sf->multi[sf->multi_cnt].beg = g_strdup( beg );
+  sf->multi[sf->multi_cnt].end = g_strdup( end );
+  sf->multi_cnt++;
+  sf->multi[sf->multi_cnt] = (hookpair_t) {0,0};
+
+  sf_update_hook_cache( sf );
 }
 
 
 /**
  * Create new Filestack.
- * 
+ *
  * @return Filestack.
  */
 filestack_t* fs_new( void )
@@ -564,9 +741,9 @@ filestack_t* fs_new( void )
 
 /**
  * Free Filestack and close all Stackfiles.
- * 
+ *
  * @param fs Filestack.
- * 
+ *
  * @return NULL.
  */
 filestack_t* fs_rem( filestack_t* fs )
@@ -587,7 +764,7 @@ filestack_t* fs_rem( filestack_t* fs )
 
 /**
  * Push file on top of Filestack.
- * 
+ *
  * @param fs Filestack.
  * @param filename New top file.
  */
@@ -596,7 +773,7 @@ void fs_push_file( filestack_t* fs, gchar* filename )
   stackfile_t* sf;
 
   if ( fs->file )
-    /* Additinal file. */
+    /* Additional file. */
     sf = sf_new( filename, fs_topfile(fs) );
   else
     /* First file, i.e. inherit stack_default hooks. */
@@ -610,9 +787,23 @@ void fs_push_file( filestack_t* fs, gchar* filename )
 }
 
 
+/**
+ * Push file on top of Filestack for later use (i.e. current macro is
+ * completely processed).
+ *
+ * @param fs Filestack.
+ * @param filename New top file.
+ */
+void fs_push_file_delayed( filestack_t* fs, gchar* filename )
+{
+  fs_push_file( fs, filename );
+  fs->file = fs->file->next;
+}
+
+
 /**
  * Pop file from top of Filestack. File is closed.
- * 
+ *
  * @param fs Filestack.
  */
 void fs_pop_file( filestack_t* fs )
@@ -632,13 +823,31 @@ void fs_pop_file( filestack_t* fs )
 
 
 /**
- * Get char from (through) Filestack (i.e. top file).
- * 
+ * Get char from (through) Filestack (i.e. top file). Stop at EOF, and
+ * don't pop the file in order to allow putback to the file.
+ *
  * @param fs Filestack.
- * 
+ *
  * @return Char or EOF.
  */
 int fs_get( filestack_t* fs )
+{
+  if ( fs->file != NULL )
+    return sf_get( fs_topfile(fs) );
+  else
+    return EOF;
+}
+
+
+/**
+ * Get char from (through) Filestack (i.e. top file). If EOF is
+ * encountered, continue with lower file if possible.
+ *
+ * @param fs Filestack.
+ *
+ * @return Char or EOF.
+ */
+int fs_get_one( filestack_t* fs )
 {
   int ret;
 
@@ -666,10 +875,10 @@ int fs_get( filestack_t* fs )
 
 /**
  * Put back char.
- * 
+ *
  * @param fs Filestack.
  * @param c Char.
- * 
+ *
  * @return TRUE.
  */
 gboolean fs_put( filestack_t* fs, char c )
@@ -682,11 +891,11 @@ gboolean fs_put( filestack_t* fs, char c )
 /**
  * Get n chars from Filestack. If ret is non-null, use that for
  * storage.
- * 
+ *
  * @param fs  Filestack.
  * @param n   Number of chars to get.
  * @param ret Storage for data.
- * 
+ *
  * @return Return data.
  */
 GString* fs_get_n( filestack_t* fs, int n, GString* ret )
@@ -732,11 +941,11 @@ GString* fs_get_n( filestack_t* fs, int n, GString* ret )
 /**
  * Put chars in str back to Filestack. If n is 0, then use strlen to
  * get the count.
- * 
+ *
  * @param fs Filestack.
  * @param str Content to add.
  * @param n Number of chars from content.
- * 
+ *
  * @return True if success.
  */
 gboolean fs_put_n( filestack_t* fs, gchar* str, int n )
@@ -757,9 +966,9 @@ gboolean fs_put_n( filestack_t* fs, gchar* str, int n )
 
 /**
  * Create new Outfile. If filename is NULL, then stream is stdout.
- * 
+ *
  * @param filename File name (or NULL for stdout).
- * 
+ *
  * @return Outfile.
  */
 outfile_t* outfile_new( gchar* filename )
@@ -768,10 +977,10 @@ outfile_t* outfile_new( gchar* filename )
 
   of = g_new0( outfile_t, 1 );
   of->lineno = 0;
+  of->blocked = FALSE;
 
   if ( filename )
     {
-
       /* Disk file output. */
 
       of->filename = g_strdup( filename );
@@ -787,15 +996,12 @@ outfile_t* outfile_new( gchar* filename )
 
           mucgly_fatal( err_sf, "Can't open \"%s\"", err_sf->filename );
         }
-
     }
   else
     {
-
       /* STDOUT output. */
       of->filename = g_strdup( "<STDOUT>" );
       of->fh = stdout;
-
     }
 
   return of;
@@ -804,7 +1010,7 @@ outfile_t* outfile_new( gchar* filename )
 
 /**
  * Free Outfile and close output stream if non-stdout.
- * 
+ *
  * @param of Outfile.
  */
 void outfile_rem( outfile_t* of )
@@ -820,9 +1026,9 @@ void outfile_rem( outfile_t* of )
 /**
  * Create Pstate. Create input file stack and output file
  * stack. Initialize parsing state.
- * 
+ *
  * @param outfile Initial input file name.
- * 
+ *
  * @return Pstate.
  */
 pstate_t* ps_new( gchar* outfile )
@@ -844,17 +1050,19 @@ pstate_t* ps_new( gchar* outfile )
   /* Match string buffer. */
   ps->match_buf = g_string_sized_new( 0 );
 
-
   ps->output = g_list_prepend( ps->output, outfile_new( outfile ) );
   ps->flush = FALSE;
 
+  ps->post_push = FALSE;
+  ps->post_pop = FALSE;
+
   return ps;
 }
 
 
 /**
  * Free Pstate. Close all input and output files.
- * 
+ *
  * @param ps Pstate.
  */
 void ps_rem( pstate_t* ps )
@@ -876,9 +1084,10 @@ void ps_rem( pstate_t* ps )
 /**
  * Fast check for current input char being first char of any of the
  * hooks.
- * 
+ *
  * @param ps Pstate.
- * 
+ * @param c  Char to check.
+ *
  * @return TRUE if next char matches 1st char of any hook.
  */
 gboolean ps_check_hook( pstate_t* ps, int c )
@@ -900,11 +1109,11 @@ gboolean ps_check_hook( pstate_t* ps, int c )
 /**
  * Check if input has the match string coming next. Erase the matched
  * string if erase is true and input is matched.
- * 
+ *
  * @param ps    Pstate.
  * @param match Match string.
  * @param erase Erase matched string (but only if matched).
- * 
+ *
  * @return True if match.
  */
 gboolean ps_check( pstate_t* ps, gchar* match, gboolean erase )
@@ -920,21 +1129,34 @@ gboolean ps_check( pstate_t* ps, gchar* match, gboolean erase )
 
   len = strlen( match );
   input = fs_get_n( ps->fs, len, ps->check_buf );
-  ret = !g_strcmp0( input->str, ps->match_buf->str );
 
-  if ( !ret || !erase )
-    /* Put back checked chars. */
-    fs_put_n( ps->fs, input->str, input->len );
+  if ( input->len == 0 )
+    {
+      /* We are at end-of-file. Let's give up and pop the file from
+         filestack. */
+      fs_pop_file( ps->fs );
+      return FALSE;
+    }
+  else
+    {
+      /* At least partial match string was received. */
 
-  return ret;
+      ret = !g_strcmp0( input->str, ps->match_buf->str );
+
+      if ( !ret || !erase )
+        /* Put back checked chars. */
+        fs_put_n( ps->fs, input->str, input->len );
+
+      return ret;
+    }
 }
 
 
 /**
  * Check input for hookesc.
- * 
+ *
  * @param ps Pstate.
- * 
+ *
  * @return TRUE on match.
  */
 gboolean ps_check_hookesc( pstate_t* ps )
@@ -946,11 +1168,37 @@ gboolean ps_check_hookesc( pstate_t* ps )
 }
 
 
+/**
+ * Save hookpair on top of stack.
+ *
+ * @param sf    Stackfile (as context).
+ * @param pair  Hookpair to store.
+ */
+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 ) ) );
+}
+
+
+/**
+ * Pop of top of stack hookpair.
+ *
+ * @param sf Stackfile (as context).
+ */
+void ps_pop_curhook( stackfile_t* sf )
+{
+  hookpair_del( (hookpair_t*) sf->curhook->data );
+  sf->curhook = g_list_delete_link( sf->curhook, sf->curhook );
+}
+
+
 /**
  * Check input for hookbeg.
- * 
+ *
  * @param ps Pstate.
- * 
+ *
  * @return TRUE on match.
  */
 gboolean ps_check_hookbeg( pstate_t* ps )
@@ -958,42 +1206,99 @@ gboolean ps_check_hookbeg( pstate_t* ps )
   if ( !ps_has_file(ps) )
     return FALSE;
 
-  return ps_check( ps, ps_topfile(ps)->hookbeg, TRUE );
+  gboolean ret;
+  stackfile_t* sf = ps_topfile(ps);
+
+  if ( sf->multi )
+    {
+      ret = FALSE;
+
+      /* Check all hookbegs for match. */
+      for ( int i = 0; i < sf->multi_cnt; i++ )
+        {
+          ret = ps_check( ps, sf->multi[i].beg, TRUE );
+          if ( ret )
+            {
+              ps_push_curhook( sf, &sf->multi[i] );
+              break;
+            }
+        }
+    }
+  else
+    {
+      ret = ps_check( ps, sf->hook.beg, TRUE );
+
+      if ( ret )
+        ps_push_curhook( sf, &sf->hook );
+    }
+
+  return ret;
 }
 
 
 /**
  * Check input for hookend.
- * 
+ *
  * @param ps Pstate.
- * 
+ *
  * @return TRUE on match.
  */
 gboolean ps_check_hookend( pstate_t* ps )
 {
   if ( !ps_has_file(ps) )
     return FALSE;
+  else
+    return ps_check( ps, ps_current_hookend(ps), TRUE );
+}
 
-  return ps_check( ps, ps_topfile(ps)->hookend, TRUE );
+
+/**
+ * Return hookbeg string that opened the current macro.
+ *
+ * @param ps PState.
+ *
+ * @return 
+ */
+gchar* ps_current_hookbeg( pstate_t* ps )
+{
+  hookpair_t* h;
+  h = ps_topfile(ps)->curhook->data;
+  return h->beg;
+}
+
+
+/**
+ * Return hookend string that opened the current macro.
+ *
+ * @param ps PState.
+ *
+ * @return 
+ */
+gchar* ps_current_hookend( pstate_t* ps )
+{
+  hookpair_t* h;
+  h = ps_topfile(ps)->curhook->data;
+  return h->end;
 }
 
 
+
 /**
  * Get char (through Filestack).
- * 
+ *
  * @param ps Pstate.
- * 
+ *
  * @return Char or EOF.
  */
 int ps_in( pstate_t* ps )
 {
-  return fs_get( ps->fs );
+  return fs_get_one( ps->fs );
 }
 
 
 /**
  * Output char to current output stream.
- * 
+ *
  * @param ps Pstate.
  * @param c  Char.
  */
@@ -1001,18 +1306,21 @@ void ps_out( pstate_t* ps, int c )
 {
   outfile_t* of = ps->output->data;
 
-  if ( c == '\n' )
-    of->lineno++;
-
-  fputc( c, of->fh );
-  if ( ps->flush )
-    fflush( of->fh );
+  if ( of->blocked == FALSE )
+    {
+      if ( c == '\n' )
+        of->lineno++;
+      
+      fputc( c, of->fh );
+      if ( ps->flush )
+        fflush( of->fh );
+    }
 }
 
 
 /**
  * Output chars with ps_out.
- * 
+ *
  * @param ps  Pstate.
  * @param str Output string (or NULL for no output).
  */
@@ -1030,9 +1338,33 @@ void ps_out_str( pstate_t* ps, gchar* str )
 }
 
 
+/**
+ * Block output stream.
+ *
+ * @param ps Pstate.
+ */
+void ps_block_output( pstate_t* ps )
+{
+  outfile_t* of = ps->output->data;
+  of->blocked = TRUE;
+}
+
+
+/**
+ * Unblock output stream.
+ *
+ * @param ps Pstate.
+ */
+void ps_unblock_output( pstate_t* ps )
+{
+  outfile_t* of = ps->output->data;
+  of->blocked = FALSE;
+}
+
+
 /**
  * Push new output stream on top of output file stack.
- * 
+ *
  * @param ps Pstate.
  * @param filename File name.
  */
@@ -1045,7 +1377,7 @@ void ps_push_file( pstate_t* ps, gchar* filename )
 
 /**
  * Pop file from output file stack. Close the stream.
- * 
+ *
  * @param ps Pstate.
  */
 void ps_pop_file( pstate_t* ps )
@@ -1060,9 +1392,9 @@ void ps_pop_file( pstate_t* ps )
 
 /**
  * Return current Stackfile (input stream).
- * 
+ *
  * @param ps Pstate.
- * 
+ *
  * @return Stackfile (or NULL if none).
  */
 stackfile_t* ps_current_file( pstate_t* ps )
@@ -1076,9 +1408,10 @@ stackfile_t* ps_current_file( pstate_t* ps )
 }
 
 
+
 /**
  * Initialize macro content collection.
- * 
+ *
  * @param ps Pstate.
  */
 void ps_start_collect( pstate_t* ps )
@@ -1089,7 +1422,7 @@ void ps_start_collect( pstate_t* ps )
 
 /**
  * Add content to macro.
- * 
+ *
  * @param ps Pstate.
  * @param c  Char to add.
  */
@@ -1099,16 +1432,42 @@ void ps_collect( pstate_t* ps, int c )
 }
 
 
+/**
+ * Enter first level macro and setup state accordingly.
+ *
+ * @param ps Pstate.
+ */
+void ps_enter_macro( pstate_t* ps )
+{
+  /* New macro starting. */
+  ps->in_macro++;
+
+  /* Store macro start info. */
+  sf_mark_macro( ps_topfile( ps ) );
+                  
+  ps_start_collect( ps );
+}
+
+
 /**
  * Get current macro content.
- * 
+ *
  * @param ps Pstate.
- * 
+ *
  * @return Macro content.
  */
 char* ps_get_macro( pstate_t* ps )
 {
-  return ps->macro_buf->str;
+  if ( ps->macro_buf->str[0] == '+' )
+    {
+      /* Eat the next char after macro. */
+      ps_topfile(ps)->eat_tail = TRUE;
+      return &ps->macro_buf->str[1];
+    }
+  else
+    {
+      return ps->macro_buf->str;
+    }
 }
 
 
@@ -1116,12 +1475,12 @@ char* ps_get_macro( pstate_t* ps )
  * Evaluate str as Ruby code and convert result to string. Conversion
  * is performed if execution was successful and conversion was
  * requested.
- * 
- * @param ps Pstate.
- * @param str Ruby code string.
+ *
+ * @param ps     Pstate.
+ * @param str    Ruby code string.
  * @param to_str Result convert enable.
- * @param ctxt Context (name) for execution.
- * 
+ * @param ctxt   Context (name) for execution.
+ *
  * @return Ruby code execution as string (or NULL).
  */
 gchar* ps_eval_ruby_str( pstate_t* ps, gchar* str, gboolean to_str, char* ctxt )
@@ -1168,8 +1527,9 @@ gchar* ps_eval_ruby_str( pstate_t* ps, gchar* str, gboolean to_str, char* ctxt )
 
 
 /**
- * Load file Ruby intepreter.
- * 
+ * Load file with Ruby intepreter.
+ *
+ * @param ps       Pstate.
  * @param filename Source file.
  */
 void ps_load_ruby_file( pstate_t* ps, gchar* filename )
@@ -1185,9 +1545,9 @@ void ps_load_ruby_file( pstate_t* ps, gchar* filename )
 
 /**
  * Execute Mucgly command/macro.
- * 
+ *
  * @param ps Pstate.
- * 
+ *
  * @return TRUE if input processing should be aborted.
  */
 gboolean ps_eval_cmd( pstate_t* ps )
@@ -1239,11 +1599,20 @@ gboolean ps_eval_cmd( pstate_t* ps )
         }
 
       else if ( ( len = len_str_cmp( ":include", cmd ) ) )
-        fs_push_file( ps->fs, &cmd[ len+1 ] );
+        {
+          fs_push_file_delayed( ps->fs, &cmd[ len+1 ] );
+          ps->post_push = TRUE;
+        }
 
       else if ( ( len = len_str_cmp( ":source", cmd ) ) )
         ps_load_ruby_file( ps, &cmd[ len+1 ] );
 
+      else if ( ( len = len_str_cmp( ":block", cmd ) ) )
+        ps_block_output( ps );
+
+      else if ( ( len = len_str_cmp( ":unblock", cmd ) ) )
+        ps_unblock_output( ps );
+
       else if ( ( len = len_str_cmp( ":comment", cmd ) ) )
         {
           /* Do nothing. */
@@ -1276,12 +1645,12 @@ gboolean ps_eval_cmd( pstate_t* ps )
     {
       /* Postpone evaluation (to next round). */
 
-      ps_out_str( ps, ps_topfile(ps)->hookbeg );
+      ps_out_str( ps, ps_current_hookbeg( ps ) );
 
       /* Remove one # sign. */
       ps_out_str( ps, &cmd[1] );
 
-      ps_out_str( ps, ps_topfile(ps)->hookend );
+      ps_out_str( ps, ps_current_hookend( ps ) );
     }
         
   else
@@ -1294,51 +1663,90 @@ gboolean ps_eval_cmd( pstate_t* ps )
 }
 
 
-/** Convenience macro for hookend. */
-#define HOOK_END_SEQ {                                          \
-    ps->in_macro--;                                             \
-    if ( ps->in_macro )                                         \
-      {                                                         \
-        /* Multilevel macro decrement. */                       \
-        /* Output the consumed hookend. */                      \
-        ps_out_str( ps, ps_topfile(ps)->hookend );              \
-      }                                                         \
-    else                                                        \
-      {                                                         \
-        /* Back to base level from macro, eval the macro. */    \
-        gboolean do_break;                                      \
-        do_break = ps_eval_cmd( ps );                           \
-        sf_unmark_macro( ps_topfile( ps ) );                    \
-        if ( do_break )                                         \
-          break;                                                \
-      }                                                         \
-  }
-
-
-/** Convenience macro for non-hook processing. */
-#define NON_HOOK_SEQ {                                                  \
-    /* Non-hook input. */                                               \
-    if ( ps->in_macro )                                                 \
-      {                                                                 \
-        if ( c == EOF )                                                 \
-          mucgly_error( ps_current_file(ps), "Got EOF within macro!" ); \
-        /* Add content to macro. */                                     \
-        ps_collect( ps, c );                                            \
-      }                                                                 \
-    else                                                                \
-      {                                                                 \
-        if ( c == EOF )                                                 \
-          break;                                                        \
-        else                                                            \
-          /* Output to current output file. */                          \
-          ps_out( ps, c );                                              \
-      }                                                                 \
-  }
+/**
+ * Processing routine for hookend phase.
+ *
+ * @param ps       Pstate.
+ * @param do_break True if current processing phase is over.
+ */
+void ps_process_hook_end_seq( pstate_t* ps, gboolean* do_break )
+{
+  ps->in_macro--;
+
+  if ( ps->in_macro < 0 )
+    {
+      mucgly_fatal( ps_topfile(ps), "Internal error in macro status..." );
+    }
+  else if ( ps->in_macro )
+    {
+      /* Multilevel macro decrement. */
+      /* Output the consumed hookend. */
+      ps_out_str( ps, ps_current_hookend( ps ) );
+      ps_pop_curhook( ps_topfile(ps) );
+      *do_break = FALSE;
+    }
+  else
+    {
+      /* Back to base level from macro, eval the macro. */
+      *do_break = ps_eval_cmd( ps );
+      sf_unmark_macro( ps_topfile( ps ) );
+      ps_pop_curhook( ps_topfile(ps) );
+
+      if ( ps->post_push == TRUE )
+        {
+          ps->post_push = FALSE;
+          ps->fs->file = ps->fs->file->prev;
+        }
+
+      if ( ps->post_pop )
+        {
+          ps->post_pop = FALSE;
+          fs_pop_file( ps->fs );
+        }
+    }                                                         
+}
+
+
+/**
+ * Processing routine for non-hook chars.
+ *
+ * @param ps        Pstate.
+ * @param c         Current char input.
+ * @param do_break  True if should break from current phase.
+ */
+void ps_process_non_hook_seq( pstate_t* ps, int c, gboolean* do_break )
+{
+  /* Non-hook input. */
+  if ( ps->in_macro )
+    {
+      *do_break = FALSE;
+
+      if ( c == EOF )
+        mucgly_error( ps_current_file(ps), "Got EOF within macro!" );
+
+      /* Add content to macro. */
+      ps_collect( ps, c );
+    }
+  else
+    {
+      if ( c == EOF )
+        {
+          *do_break = TRUE;
+        }
+      else
+        {
+          *do_break = FALSE;
+
+          /* Output to current output file. */
+          ps_out( ps, c );
+        }
+    }
+}
 
 
 /**
  * Process input file (or stack of files).
- * 
+ *
  * @param ps Pstate.
  * @param infile Input file name.
  * @param outfile Output file name (or NULL). Outfile string is freed.
@@ -1346,6 +1754,7 @@ gboolean ps_eval_cmd( pstate_t* ps )
 void ps_process_file( pstate_t* ps, gchar* infile, gchar* outfile )
 {
   int c;
+  gboolean do_break = FALSE;
 
   fs_push_file( ps->fs, infile );
 
@@ -1399,24 +1808,10 @@ void ps_process_file( pstate_t* ps, gchar* infile, gchar* outfile )
                       if ( ( c == ' ' || c == '\n' ) &&
                            ps_topfile(ps)->hook_esc_eq_end )
                         {
-
                           /* Space/newline and hookesc is same as hookbeg. */
-
-                          ps->in_macro--;
-
-                          if ( ps->in_macro )
-                            {
-                              /* Multilevel macro decrement. */
-
-                              /* Output the consumed hookend. */
-                              ps_out_str( ps, ps_topfile(ps)->hookend );
-                            }
-                          else
-                            {
-                              /* Back to base level from macro, eval the macro. */
-                              if ( ps_eval_cmd( ps ) )
-                                break;
-                            }
+                          ps_process_hook_end_seq( ps, &do_break );
+                          if ( do_break )
+                            break;
                         }
                       else
                         {
@@ -1467,13 +1862,17 @@ 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. */
-                                  ps->in_macro++;
                           
                                   /* Put back the extra char (for safety/clarity). */
                                   fs_put( ps->fs, c );
 
+                                  /* Push hook here. For non-esc hooks
+                                     this is done while matching for
+                                     hook. */
+                                  ps_push_curhook( ps_topfile(ps), &ps_topfile(ps)->hook );
+
                                   /* Start collect the macro content. */
-                                  ps_start_collect( ps );
+                                  ps_enter_macro( ps );
                                 }
                             }
                           else
@@ -1488,8 +1887,11 @@ void ps_process_file( pstate_t* ps, gchar* infile, gchar* outfile )
             }
           else if ( ps->in_macro && ps_check_hookend( ps ) )
             {
-              /* Hookend has priority over hookbeg if we are in macro. */
-              HOOK_END_SEQ;
+              /* 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;
             }
           else if ( ps_check_hookbeg( ps ) )
             {
@@ -1502,33 +1904,26 @@ void ps_process_file( pstate_t* ps, gchar* infile, gchar* outfile )
                   ps->in_macro++;
 
                   /* Output the consumed hookbeg. */
-                  ps_out_str( ps, ps_topfile(ps)->hookbeg );
+                  ps_out_str( ps, ps_current_hookbeg( ps ) );
                 }
               else
                 {
-                  /* New macro starting. */
-                  ps->in_macro++;
-
-                  /* Store macro start info. */
-                  sf_mark_macro( ps_topfile( ps ) );
-
-                  ps_start_collect( ps );
+                  ps_enter_macro( ps );
                 }
-
-            }
-          else if ( ps_check_hookend( ps ) )
-            {
-              HOOK_END_SEQ;
             }
           else
             {
               c = ps_in( ps );
-              NON_HOOK_SEQ;
+              ps_process_non_hook_seq( ps, c, &do_break );
+              if ( do_break )
+                break;
             }
         }
       else
         {
-          NON_HOOK_SEQ;
+          ps_process_non_hook_seq( ps, c, &do_break );
+          if ( do_break )
+            break;
         }
     }
 
@@ -1547,10 +1942,10 @@ void ps_process_file( pstate_t* ps, gchar* infile, gchar* outfile )
 
 /**
  * Mucgly.write method. Write output current output without NL.
- * 
+ *
  * @param obj  Not used.
  * @param rstr Written string (Ruby String).
- * 
+ *
  * @return Qnil.
  */
 VALUE mucgly_write( VALUE obj, VALUE rstr )
@@ -1572,10 +1967,10 @@ VALUE mucgly_write( VALUE obj, VALUE rstr )
 
 /**
  * Mucgly.puts method. Write output current output with NL.
- * 
+ *
  * @param obj  Not used.
  * @param rstr Written string (Ruby String).
- * 
+ *
  * @return Qnil.
  */
 VALUE mucgly_puts( VALUE obj, VALUE rstr )
@@ -1599,35 +1994,35 @@ VALUE mucgly_puts( VALUE obj, VALUE rstr )
 
 /**
  * Mucgly.hookbeg method. Get hookbeg.
- * 
+ *
  * @param obj  Not used.
- * 
+ *
  * @return Hookbeg as Ruby String.
  */
 VALUE mucgly_hookbeg( VALUE obj )
 {
-  return rb_str_new_cstr( ps_current_file( ruby_ps )->hookbeg );
+  return rb_str_new_cstr( ps_current_file( ruby_ps )->hook.beg );
 }
 
 
 /**
  * Mucgly.hookend method. Get hookend.
- * 
+ *
  * @param obj  Not used.
- * 
+ *
  * @return Hookend as Ruby String.
  */
 VALUE mucgly_hookend( VALUE obj )
 {
-  return rb_str_new_cstr( ps_current_file( ruby_ps )->hookend );
+  return rb_str_new_cstr( ps_current_file( ruby_ps )->hook.end );
 }
 
 
 /**
  * Mucgly.hookesc method. Get hookesc.
- * 
+ *
  * @param obj  Not used.
- * 
+ *
  * @return Hookesc as Ruby String.
  */
 VALUE mucgly_hookesc( VALUE obj )
@@ -1638,10 +2033,10 @@ VALUE mucgly_hookesc( VALUE obj )
 
 /**
  * Mucgly.sethookbeg method. Set hookbeg.
- * 
+ *
  * @param obj  Not used.
  * @param rstr Hookbeg string (Ruby String).
- * 
+ *
  * @return Qnil.
  */
 VALUE mucgly_sethookbeg( VALUE obj, VALUE rstr )
@@ -1655,10 +2050,10 @@ VALUE mucgly_sethookbeg( VALUE obj, VALUE rstr )
 
 /**
  * Mucgly.sethookend method. Set hookend.
- * 
+ *
  * @param obj  Not used.
  * @param rstr Hookend string (Ruby String).
- * 
+ *
  * @return Qnil.
  */
 VALUE mucgly_sethookend( VALUE obj, VALUE rstr )
@@ -1672,10 +2067,10 @@ VALUE mucgly_sethookend( VALUE obj, VALUE rstr )
 
 /**
  * Mucgly.sethookesc method. Set hookesc.
- * 
+ *
  * @param obj  Not used.
  * @param rstr Hookesc string (Ruby String).
- * 
+ *
  * @return Qnil.
  */
 VALUE mucgly_sethookesc( VALUE obj, VALUE rstr )
@@ -1687,11 +2082,38 @@ VALUE mucgly_sethookesc( VALUE obj, VALUE rstr )
 }
 
 
+/**
+ * Mucgly.multihook method. Add multihook pairs.
+ *
+ * @param obj  Not used.
+ * @param ary  Array of hookpairs.
+ *
+ * @return Qnil.
+ */
+VALUE mucgly_multihook( VALUE obj, VALUE ary )
+{
+  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 )
+    {
+      beg = RSTRING_PTR( RARRAY_PTR(ary)[i] );
+      end = RSTRING_PTR( RARRAY_PTR(ary)[i+1] );
+      sf_multi_hook( ps_topfile( ruby_ps ), beg, end );
+    }
+
+  return Qnil;
+}
+
+
 /**
  * Mucgly.ifilename method. Gets current input file name.
- * 
+ *
  * @param obj  Not used.
- * 
+ *
  * @return Input file name (Ruby String).
  */
 VALUE mucgly_ifilename( VALUE obj )
@@ -1702,9 +2124,9 @@ VALUE mucgly_ifilename( VALUE obj )
 
 /**
  * Mucgly.ilinenumber method. Gets current input file line.
- * 
+ *
  * @param obj  Not used.
- * 
+ *
  * @return Input file line number (Ruby Fixnum).
  */
 VALUE mucgly_ilinenumber( VALUE obj )
@@ -1715,9 +2137,9 @@ VALUE mucgly_ilinenumber( VALUE obj )
 
 /**
  * Mucgly.ofilename method. Gets current output file name.
- * 
+ *
  * @param obj  Not used.
- * 
+ *
  * @return Input file name (Ruby String).
  */
 VALUE mucgly_ofilename( VALUE obj )
@@ -1730,9 +2152,9 @@ VALUE mucgly_ofilename( VALUE obj )
 
 /**
  * Mucgly.olinenumber method. Gets current output file line.
- * 
+ *
  * @param obj  Not used.
- * 
+ *
  * @return Output file line number (Ruby Fixnum).
  */
 VALUE mucgly_olinenumber( VALUE obj )
@@ -1745,10 +2167,10 @@ VALUE mucgly_olinenumber( VALUE obj )
 
 /**
  * Mucgly.pushinput method. Push new input stream.
- * 
+ *
  * @param obj  Not used.
  * @param rstr Input file name (Ruby String).
- * 
+ *
  * @return Qnil.
  */
 VALUE mucgly_pushinput( VALUE obj, VALUE rstr )
@@ -1756,31 +2178,32 @@ VALUE mucgly_pushinput( VALUE obj, VALUE rstr )
   char* str;
 
   str = RSTRING_PTR( rstr );
-  fs_push_file( ruby_ps->fs, str );
+  fs_push_file_delayed( ruby_ps->fs, str );
+  ruby_ps->post_push = TRUE;
   return Qnil;
 }
 
 
 /**
  * Mucgly.closeinput method. Pop input stream and close file stream.
- * 
+ *
  * @param obj  Not used.
- * 
+ *
  * @return Qnil.
  */
 VALUE mucgly_closeinput( VALUE obj )
 {
-  fs_pop_file( ruby_ps->fs );
+  ruby_ps->post_pop = TRUE;
   return Qnil;
 }
 
 
 /**
  * Mucgly.pushoutput method. Push new output stream.
- * 
+ *
  * @param obj  Not used.
  * @param rstr Output file name (Ruby String).
- * 
+ *
  * @return Qnil.
  */
 VALUE mucgly_pushoutput( VALUE obj, VALUE rstr )
@@ -1795,9 +2218,9 @@ VALUE mucgly_pushoutput( VALUE obj, VALUE rstr )
 
 /**
  * Mucgly.closeoutput method. Pop output stream and close file stream.
- * 
+ *
  * @param obj  Not used.
- * 
+ *
  * @return Qnil.
  */
 VALUE mucgly_closeoutput( VALUE obj )
@@ -1807,14 +2230,42 @@ VALUE mucgly_closeoutput( VALUE obj )
 }
 
 
+/**
+ * Mucgly.block method. Block output.
+ *
+ * @param obj  Not used.
+ *
+ * @return Qnil.
+ */
+VALUE mucgly_block( VALUE obj )
+{
+  ps_block_output( ruby_ps );
+  return Qnil;
+}
+
+
+/**
+ * Mucgly.block method. Block output.
+ *
+ * @param obj  Not used.
+ *
+ * @return Qnil.
+ */
+VALUE mucgly_unblock( VALUE obj )
+{
+  ps_unblock_output( ruby_ps );
+  return Qnil;
+}
+
+
 #ifdef MUCGLY_LIB
 /**
  * Call mucgly C-side entry point. Convert Ruby ARGV array to C-array
  * for C-side command line arg parsing.
- * 
+ *
  * @param obj Not used.
  * @param cli Ruby side ARGV.
- * 
+ *
  * @return Qnil.
  */
 VALUE mucgly_run_mucgly( VALUE obj, VALUE cli )
@@ -1839,7 +2290,7 @@ VALUE mucgly_run_mucgly( VALUE obj, VALUE cli )
 
 /**
  * Create Mucgly Ruby module and register all methods to it.
- * 
+ *
  */
 void Init_mucgly( void )
 {
@@ -1859,6 +2310,7 @@ void Init_mucgly( void )
   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, "ifilename", mucgly_ifilename, 0 );
   rb_define_module_function( mMucgly, "ilinenumber", mucgly_ilinenumber, 0 );
   rb_define_module_function( mMucgly, "ofilename", mucgly_ofilename, 0 );
@@ -1867,6 +2319,8 @@ void Init_mucgly( void )
   rb_define_module_function( mMucgly, "closeinput", mucgly_closeinput, 0 );
   rb_define_module_function( mMucgly, "pushoutput", mucgly_pushoutput, 1 );
   rb_define_module_function( mMucgly, "closeoutput", mucgly_closeoutput, 0 );
+  rb_define_module_function( mMucgly, "block", mucgly_block, 0 );
+  rb_define_module_function( mMucgly, "unblock", mucgly_unblock, 0 );
 
 }
 
@@ -1874,10 +2328,10 @@ void Init_mucgly( void )
 /**
  * Generate outfile name from infile by removing the outfile_tag from
  * infile name.
- * 
+ *
  * @param infile      Input file name.
  * @param outfile_tag Tag to remove from infile to get outfile.
- * 
+ *
  * @return Outfile name.
  */
 gchar* infile_to_outfile( gchar* infile, gchar* outfile_tag )
@@ -1907,21 +2361,18 @@ gchar* infile_to_outfile( gchar* infile, gchar* outfile_tag )
  * Main program:
  * ------------------------------------------------------------ */
 
+/**
+ * Mucgly entrypoint.
+ *
+ * @param argc Arg count.
+ * @param argv Arg values.
+ */
 void mucgly_main( int argc, char** argv )
 {
   
   /* Setup default hooks etc. */
   stack_default = sf_new( NULL, NULL );
 
-  /* ------------------------------------------------------------
-   * Setup Ruby features:
-   * ------------------------------------------------------------ */
-
-#ifndef MUCGLY_LIB
-  ruby_init();
-  Init_mucgly();
-#endif
-
 
   /* ------------------------------------------------------------
    * Command line parsing:
@@ -1936,6 +2387,7 @@ void mucgly_main( int argc, char** argv )
   gchar* opt_end_sep = NULL;
   gchar* opt_esc_sep = NULL;
   gchar* opt_all_sep = NULL;
+  gchar** opt_multi_sep = NULL;
   gboolean opt_module = FALSE;
   gboolean opt_interact = FALSE;
   gboolean opt_no_init = FALSE;
@@ -1945,28 +2397,43 @@ void mucgly_main( int argc, char** argv )
     {
       { "files", 'f', 0, G_OPTION_ARG_FILENAME_ARRAY, &opt_files,
         "Input file(s) (default: stdin).", NULL },
+
       { "configs", 'c', 0, G_OPTION_ARG_FILENAME_ARRAY, &opt_configs,
         "Ruby configuration file(s).", NULL },
+
       { "output", 'o', 0, G_OPTION_ARG_FILENAME, &opt_output,
         "Output file(s) (default: stdout).", NULL },
+
       { "genout", 'g', 0, G_OPTION_ARG_STRING, &opt_genout,
         "Generate output file names (remove arg from input filename).", NULL },
+
       { "cli_cmds", 'l', 0, G_OPTION_ARG_STRING_ARRAY, &opt_cli_cmds,
         "Command line configuration(s).", NULL },
+
       { "beg_sep", 'b', 0, G_OPTION_ARG_STRING, &opt_beg_sep,
         "Set hookbeg separator (default: '-<').", NULL },
+
       { "end_sep", 'e', 0, G_OPTION_ARG_STRING, &opt_end_sep,
         "Set hookend separator (default: '>-').", NULL },
+
       { "esc_sep", 's', 0, G_OPTION_ARG_STRING, &opt_esc_sep,
         "Set hookesc separator (default: '\\').", NULL },
+
       { "all_sep", 'a', 0, G_OPTION_ARG_STRING, &opt_all_sep,
         "Set all separators.", NULL },
+
+      { "multi_sep", 'u', 0, G_OPTION_ARG_STRING_ARRAY, &opt_multi_sep,
+        "Set multiple beg/end hook pairs.", NULL },
+
       { "module", 'm', 0, G_OPTION_ARG_NONE, &opt_module,
         "Include Mucgly module at startup.", NULL },
+
       { "interact", 'i', 0, G_OPTION_ARG_NONE, &opt_interact,
         "Flush output for convenient interaction.", NULL },
+
       { "no_init", 'n', 0, G_OPTION_ARG_NONE, &opt_no_init,
         "No init file (skip MUCGLY env var).", NULL },
+
       { NULL }
     };
 
@@ -2049,6 +2516,30 @@ void mucgly_main( int argc, char** argv )
       sf_set_hook( stack_default, hook_esc, opt_all_sep );
     }
 
+  /* Set multi-hooks. */
+  if ( opt_multi_sep )
+    {
+      int cnt = 0;
+
+      /* First check that we have even number of hooks. */
+      while ( opt_multi_sep[ cnt ] ) cnt++;
+
+      if ( ( cnt % 2 ) != 0 )
+        {
+          g_print( "mucgly: Must have even number of multi hook args, had %d!\n", cnt );
+          exit( EXIT_FAILURE );
+        }
+
+      cnt = 0;
+      while ( opt_multi_sep[ cnt ] )
+        {
+          sf_multi_hook( stack_default,
+                         opt_multi_sep[ cnt ],
+                         opt_multi_sep[ cnt+1 ] );
+          cnt += 2;
+        }
+    }
+
 
   if ( opt_interact )
     /* Flush output immediately in interactive mode. */
@@ -2084,14 +2575,20 @@ void mucgly_main( int argc, char** argv )
 #ifndef MUCGLY_LIB
 /**
  * C-top entry point.
- * 
+ *
  * @param argc Cli arg count.
  * @param argv Cli arg values.
- * 
+ *
  * @return Not used.
  */
 int main( int argc, char** argv )
 {
+
+  /* Setup Ruby and mucgly module. */
+  ruby_init();
+  Init_mucgly();
+
+  /* Enter mucgly. */
   mucgly_main( argc, argv );
 }
 #endif