mucgly 0.0.2 → 0.1.0

data/ext/mucgly/mucgly.c

@@ -0,0 +1,2095 @@
+#include <glib.h>
+#include <glib/gstdio.h>
+#include <ruby.h>
+
+
+/*
+ * If MUCGLY_LIB is defined, mucgly is compiled in Ruby-top (e.g. for
+ * gems) mode. Otherwise mucgly is in C-top (main) mode,
+ * i.e. standalone binary.
+ */
+#ifdef MUCGLY_LIB
+void mucgly_main( int argc, char** argv );
+#endif
+
+
+
+/* ------------------------------------------------------------
+ * Debugging:
+ * ------------------------------------------------------------ */
+
+/* Enable the define is input char based debugging is required. Set
+   GDB breakpoint at mucgly_debug. */
+void mucgly_debug( void ) {}
+#if 1
+# define DEBUG_CHAR '~'
+#endif
+
+
+
+/* ------------------------------------------------------------
+ * Data models:
+ * ------------------------------------------------------------ */
+
+/*
+ * Mucgly uses Pstate to store the parsing state of the input
+ * files. The parser has to know whether we are in or out of macro
+ * definition. The "hooks" in the input stream change the state within
+ * parsing.
+ *
+ * Pstate contains Filestack. Filestack is a stack of input files. The
+ * input file stack grows when the "lower" level files performs
+ * include command.
+ *
+ * Filestack contains Stackfiles. Stackfile presents the read status
+ * of an input file. It contains character position information for
+ * error reporting.
+ *
+ * Outfile is part of the Pstate output file stack. Each Outfile
+ * represents the output file state. Outfile stack is needed to
+ * implement redirection of output stream to different files. Output
+ * files has to be controlled explicitly from Mucgly files.
+ */
+
+
+#define HOOKBEG_DEFAULT "-<"
+#define HOOKEND_DEFAULT ">-"
+#define HOOKESC_DEFAULT "\\"
+
+
+
+/**
+ * Stackfile is an entry in the Filestack. Stackfile is the input file
+ * for Mucgly.
+ */
+struct stackfile_s {
+
+  gchar* filename;  /**< Filename. */
+  FILE* fh;         /**< 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). */
+
+  gboolean macro;   /**< Macro active. */
+  int macro_line;   /**< Macro start line. */
+  int macro_col;    /**< Macro start column. */
+
+  gchar* hookbeg;   /**< Hookbeg for input file. */
+  gchar* hookend;   /**< Hookend for input file. */
+  gchar* hookesc;   /**< Hookesc for input file. */
+
+  /** Hookesc is same as hookbeg. Speeds up input processing. */
+  gboolean hook_esc_eq_beg;
+
+  /** Hookesc is same as hookend. Speeds up input processing. */
+  gboolean hook_esc_eq_end;
+
+  /** Hookesc is same as hookend. Speeds up input processing. */
+  guchar hook_1st_chars[ 256 ];
+
+};
+typedef struct stackfile_s stackfile_t;
+
+
+
+/**
+ * Filestack is a stack of files (stackfile_t). Macro processing
+ * starts at base file. The base file is allowed to include other
+ * files (as input with ":include" command). The included file is
+ * added to the top of stack as current file at inclusion. When file
+ * EOF is encountered, it is popped of the stack. This makes the
+ * character flow continuous from the parser point of view.
+ */
+struct filestack_s {
+  GList* file;           /**< Stack of files. */
+};
+typedef struct filestack_s filestack_t;
+
+
+
+/**
+ * Outfile is output file stream descriptor. Output can be diverted
+ * 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;
+
+
+
+/**
+ * Parser state for Mucgly.
+ */
+struct pstate_s {
+  filestack_t* fs;    /**< Stack of input streams. */
+
+  GString* check_buf; /**< Preview buffer. */
+  GString* macro_buf; /**< Macro content buffer. */
+  GString* match_buf; /**< Match str buffer. */
+
+  int in_macro;       /**< Processing within macro. */
+
+  GList* output;      /**< Stack of output streams. */
+
+  gboolean flush;
+};
+typedef struct pstate_s pstate_t;
+
+
+/** Hook type enum. */
+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)
+
+
+
+/* ------------------------------------------------------------
+ * Global variables:
+ * ------------------------------------------------------------ */
+
+/** Default hook settings. */
+stackfile_t* stack_default = NULL;
+
+/** Pointer to current file. Usefull for debugging. */
+stackfile_t* csf;
+
+/** Ruby side reference to parser. */
+pstate_t* ruby_ps;
+
+
+
+/* ------------------------------------------------------------
+ * Function declarations:
+ * ------------------------------------------------------------ */
+
+void sf_set_hook( stackfile_t* sf, hook_t hook, char* value );
+
+
+
+/* ------------------------------------------------------------
+ * Mucgly C-functions:
+ * ------------------------------------------------------------ */
+
+
+/** 
+ * 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 )
+{
+  int len = strlen( str1 );
+  
+  if ( !strncmp( str1, str2, len ) )
+    return len;
+  else
+    return 0;
+}
+
+
+/** 
+ * Common utility function to output user info messages.
+ * 
+ * @param sf Currently processed file (or NULL).
+ * @param infotype Severity type.
+ * @param format Message (printf) formatter.
+ * @param ap Message args.
+ */
+void mucgly_user_info( stackfile_t* sf, char* infotype, char* format, va_list ap )
+{
+  GString* out = g_string_sized_new( 0 );
+
+  if ( sf )
+    {
+      int lineno, column;
+
+      if ( sf->macro )
+        {
+          lineno = sf->macro_line;
+          column = sf->macro_col;
+        }
+      else
+        {
+          lineno = sf->lineno;
+          column = sf->column;
+        }
+
+      g_string_append_printf( out, "mucgly %s in \"%s:%d:%d\": ",
+                              infotype,
+                              sf->filename,
+                              lineno+1,
+                              column+1
+                              );
+    }
+  else
+    {
+      g_string_append_printf( out, "mucgly %s: ", infotype );
+    }
+
+  g_string_append_vprintf( out, format, ap );
+  fputs( out->str, stderr );
+  fputc( '\n', stderr );
+  fflush( stderr );
+  g_string_free( out, TRUE );
+}
+
+
+/** 
+ * Report warning to user (no exit).
+ * 
+ * @param sf Current input file.
+ * @param format Message formatter.
+ */
+void mucgly_warn( stackfile_t* sf, char* format, ... )
+{
+  va_list ap;
+  va_start( ap, format );
+  mucgly_user_info( sf, "warning", format, ap );
+  va_end( ap );
+}
+
+
+/** 
+ * Report error to user (and exit).
+ * 
+ * @param sf Current input file.
+ * @param format Message formatter.
+ */
+void mucgly_error( stackfile_t* sf, char* format, ... )
+{
+  va_list ap;
+  va_start( ap, format );
+  mucgly_user_info( sf, "error", format, ap );
+  va_end( ap );
+  exit( EXIT_FAILURE );
+}
+
+
+/** 
+ * Report fatal error to user (and exit).
+ * 
+ * @param sf Current input file.
+ * @param format Message formatter.
+ */
+void mucgly_fatal( stackfile_t* sf, char* format, ... )
+{
+  va_list ap;
+  va_start( ap, format );
+  mucgly_user_info( sf, "fatal error", format, ap );
+  va_end( ap );
+  exit( EXIT_FAILURE );
+}
+
+
+/** 
+ * 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 )
+{
+  stackfile_t* sf;
+
+  sf = g_new0( stackfile_t, 1 );
+
+  if ( filename )
+    {
+      /* Real file. */
+
+      sf->fh = g_fopen( filename, (gchar*) "r" );
+      sf->filename = g_strdup( filename );
+
+      if ( sf->fh == NULL )
+        {
+          stackfile_t* err_sf;
+
+          /* Get the includer. */
+          err_sf = ruby_ps->fs->file->data;
+
+          mucgly_fatal( err_sf, "Can't open \"%s\"", filename );
+        }
+
+    }
+  else
+    {
+      /* Use stdin. */
+      sf->fh = stdin;
+      sf->filename = g_strdup( "<STDIN>" );
+    }
+
+  sf->buf = g_string_sized_new( 0 );
+  sf->lineno = 0;
+  sf->column = 0;
+  sf->old_column = 0;
+
+  sf->macro = FALSE;
+  sf->macro_line = 0;
+  sf->macro_col = 0;
+
+
+  if ( inherit )
+    {
+      /* Inherited hook values. */
+      sf->hookbeg = g_strdup( inherit->hookbeg );
+      sf->hookend = g_strdup( inherit->hookend );
+      sf->hookesc = g_strdup( inherit->hookesc );
+    }
+  else
+    {
+      /* Default hook values. */
+      sf->hookbeg = g_strdup( HOOKBEG_DEFAULT );
+      sf->hookend = g_strdup( HOOKEND_DEFAULT );
+      sf->hookesc = g_strdup( HOOKESC_DEFAULT );
+    }
+
+  /* Setup fast-lookup caches. */
+  sf_set_hook( sf, hook_none, NULL );
+
+  return sf;
+}
+
+
+/** 
+ * Store macro start info.
+ * 
+ * @param sf Stackfile.
+ */
+void sf_mark_macro( stackfile_t* sf )
+{
+  sf->macro = TRUE;
+  sf->macro_line = sf->lineno;
+  sf->macro_col = sf->column;
+}
+
+
+/** 
+ * Reset macro start info.
+ * 
+ * @param sf Stackfile.
+ */
+void sf_unmark_macro( stackfile_t* sf )
+{
+  sf->macro = FALSE;
+}
+
+
+/** 
+ * Free Stackfile and close the file stream.
+ * 
+ * @param sf Stackfile.
+ */
+void sf_rem( stackfile_t* sf )
+{
+  g_string_free( sf->buf, TRUE );
+
+  if ( sf->fh != stdin )
+    {
+      fclose( sf->fh );
+    }
+
+  g_free( sf->filename );
+
+  g_free( sf->hookbeg );
+  g_free( sf->hookend );
+  g_free( sf->hookesc );
+  
+  g_free( sf );
+}
+
+
+/** 
+ * Get char from Stackfile.
+ * 
+ * @param sf Stackfile.
+ * 
+ * @return Char or EOF.
+ */
+int sf_get( stackfile_t* sf )
+{
+  int ret;
+
+  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 )
+        {
+          mucgly_debug();
+          ret = fgetc( sf->fh );
+        }
+#else
+      ret = fgetc( sf->fh );
+#endif
+
+    }
+
+  /* Update file point info. */
+  if ( ret != EOF )
+    {
+      if ( ret == '\n' )
+        {
+          sf->old_column = sf->column;
+          sf->lineno++;
+          sf->column = 0;
+        }
+      else
+        {
+          sf->column++;
+        }
+    }
+
+  return ret;
+}
+
+
+/** 
+ * Put char back to Stackfile.
+ * 
+ * @param sf Stackfile.
+ * @param c char.
+ * 
+ * @return TRUE.
+ */
+gboolean sf_put( stackfile_t* sf, char c )
+{
+  if ( c == '\n' )
+    {
+      sf->lineno--;
+      sf->column = sf->old_column;
+      sf->old_column = 0;
+    }
+  else
+    {
+      sf->column--;
+    }
+
+  /* Use buffer as stack with oldest (first to use) on right. */
+  g_string_append_c( sf->buf, c );
+
+  return TRUE;
+}
+
+
+/** 
+ * 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 )
+{
+
+  /* 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;
+    default: break;
+    }
+
+
+  /* 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;
+
+  if ( !g_strcmp0( sf->hookesc, sf->hookend ) )
+    sf->hook_esc_eq_end = TRUE;
+  else
+    sf->hook_esc_eq_end = FALSE;
+
+  /* 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;
+}
+
+
+/** 
+ * Create new Filestack.
+ * 
+ * @return Filestack.
+ */
+filestack_t* fs_new( void )
+{
+  filestack_t* fs;
+
+  fs = g_new0( filestack_t, 1 );
+  fs->file = NULL;
+  return fs;
+}
+
+
+/** 
+ * Free Filestack and close all Stackfiles.
+ * 
+ * @param fs Filestack.
+ * 
+ * @return NULL.
+ */
+filestack_t* fs_rem( filestack_t* fs )
+{
+  if ( fs )
+    {
+      for ( GList* p = fs->file; p; p = p->next )
+        {
+          sf_rem( (stackfile_t*) p->data );
+        }
+
+      g_free( fs );
+    }
+
+  return NULL;
+}
+
+
+/** 
+ * Push file on top of Filestack.
+ * 
+ * @param fs Filestack.
+ * @param filename New top file.
+ */
+void fs_push_file( filestack_t* fs, gchar* filename )
+{
+  stackfile_t* sf;
+
+  if ( fs->file )
+    /* Additinal file. */
+    sf = sf_new( filename, fs_topfile(fs) );
+  else
+    /* First file, i.e. inherit stack_default hooks. */
+    sf = sf_new( filename, stack_default );
+
+  /* Push file. */
+  fs->file = g_list_prepend( fs->file, sf );
+
+  /* Set global CurrentStackfile handle. */
+  csf = (stackfile_t*) fs->file->data;
+}
+
+
+/** 
+ * Pop file from top of Filestack. File is closed.
+ * 
+ * @param fs Filestack.
+ */
+void fs_pop_file( filestack_t* fs )
+{
+  stackfile_t* sf;
+
+  sf = fs->file->data;
+  sf_rem( sf );
+  fs->file = g_list_delete_link( fs->file, fs->file );
+
+  /* Set global CurrentStackfile handle. */
+  if ( fs->file )
+    csf = (stackfile_t*) fs->file->data;
+  else
+    csf = NULL;
+}
+
+
+/** 
+ * Get char from (through) Filestack (i.e. top file).
+ * 
+ * @param fs Filestack.
+ * 
+ * @return Char or EOF.
+ */
+int fs_get( filestack_t* fs )
+{
+  int ret;
+
+  if ( fs->file != NULL )
+    {
+      ret = sf_get( fs_topfile(fs) );
+
+      /* Pop Stackfiles until no files or non-EOF char is received. */
+      while ( ret == EOF )
+        {
+          fs_pop_file( fs );
+          if ( fs->file == NULL )
+            return EOF;
+          ret = sf_get( fs_topfile(fs) );
+        }
+
+      return ret;
+    }
+  else
+    {
+      return EOF;
+    }
+}
+
+
+/** 
+ * Put back char.
+ * 
+ * @param fs Filestack.
+ * @param c Char.
+ * 
+ * @return TRUE.
+ */
+gboolean fs_put( filestack_t* fs, char c )
+{
+  sf_put( fs_topfile(fs), c );
+  return TRUE;
+}
+
+
+/** 
+ * 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 )
+{
+
+  if ( ret == NULL )
+    {
+      /* New GString is needed for storage. */
+      ret = g_string_sized_new( 0 );
+    }
+  else
+    {
+      /* Reset size of the existing storage. */
+      g_string_set_size( ret, 0 );
+    }
+
+
+  /* Get n chars from current file. If EOF is encountered, reading is
+     terminated. */
+
+  for ( int i = 0, c; ; )
+    {
+      if ( i >= n )
+        break;
+
+      c = fs_get( fs );
+
+      if ( c != EOF )
+        {
+          g_string_append_c( ret, (char) c );
+          i++;
+        }
+      else
+        {
+          break;
+        }
+    }
+
+  return 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 )
+{
+  if ( n == 0 )
+    n = strlen( str );
+
+  /* Put chars with newest first (i.e. reverse order), so that oldest
+     comes out first. */
+  for ( int i = n-1; i >= 0; i-- )
+    {
+      fs_put( fs, str[ i ] );
+    }
+
+  return TRUE;
+}
+
+
+/** 
+ * 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 )
+{
+  outfile_t* of;
+
+  of = g_new0( outfile_t, 1 );
+  of->lineno = 0;
+
+  if ( filename )
+    {
+
+      /* Disk file output. */
+
+      of->filename = g_strdup( filename );
+
+      of->fh = g_fopen( filename, (gchar*) "w" );
+
+      if ( of->fh == NULL )
+        {
+          stackfile_t* err_sf;
+
+          /* Get the includer. */
+          err_sf = ruby_ps->fs->file->data;
+
+          mucgly_fatal( err_sf, "Can't open \"%s\"", err_sf->filename );
+        }
+
+    }
+  else
+    {
+
+      /* STDOUT output. */
+      of->filename = g_strdup( "<STDOUT>" );
+      of->fh = stdout;
+
+    }
+
+  return of;
+}
+
+
+/** 
+ * Free Outfile and close output stream if non-stdout.
+ * 
+ * @param of Outfile.
+ */
+void outfile_rem( outfile_t* of )
+{
+  if ( of->fh != stdout )
+    fclose( of->fh );
+
+  g_free( of->filename );
+  g_free( 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 )
+{
+  pstate_t* ps;
+
+  ps = g_new0( pstate_t, 1 );
+
+  ps->fs = fs_new();
+
+  ps->in_macro = 0;
+
+  /* Preview input buffer. */
+  ps->check_buf = g_string_sized_new( 0 );
+  
+  /* Top level input buffer. */
+  ps->macro_buf = g_string_sized_new( 0 );
+
+  /* Match string buffer. */
+  ps->match_buf = g_string_sized_new( 0 );
+
+
+  ps->output = g_list_prepend( ps->output, outfile_new( outfile ) );
+  ps->flush = FALSE;
+
+  return ps;
+}
+
+
+/** 
+ * Free Pstate. Close all input and output files.
+ * 
+ * @param ps Pstate.
+ */
+void ps_rem( pstate_t* ps )
+{
+  fs_rem( ps->fs );
+  
+  g_string_free( ps->check_buf, TRUE );
+  g_string_free( ps->macro_buf, TRUE );
+
+  for ( GList* of = ps->output; of; of = of->next )
+    {
+      outfile_rem( (outfile_t*) of->data );
+    }
+
+  g_free( ps );
+}
+
+
+/** 
+ * Fast check for current input char being first char of any of the
+ * hooks.
+ * 
+ * @param ps Pstate.
+ * 
+ * @return TRUE if next char matches 1st char of any hook.
+ */
+gboolean ps_check_hook( pstate_t* ps, int c )
+{
+  stackfile_t* sf;
+
+  if ( c == EOF )
+    return FALSE;
+
+  sf = ps_topfile(ps);
+
+  if ( sf->hook_1st_chars[ c ] )
+    return TRUE;
+  else
+    return FALSE;
+}
+
+
+/** 
+ * 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 )
+{
+  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 );
+  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 );
+
+  return ret;
+}
+
+
+/** 
+ * Check input for hookesc.
+ * 
+ * @param ps Pstate.
+ * 
+ * @return TRUE on match.
+ */
+gboolean ps_check_hookesc( pstate_t* ps )
+{
+  if ( !ps_has_file(ps) )
+    return FALSE;
+
+  return ps_check( ps, ps_topfile(ps)->hookesc, TRUE );
+}
+
+
+/** 
+ * Check input for hookbeg.
+ * 
+ * @param ps Pstate.
+ * 
+ * @return TRUE on match.
+ */
+gboolean ps_check_hookbeg( pstate_t* ps )
+{
+  if ( !ps_has_file(ps) )
+    return FALSE;
+
+  return ps_check( ps, ps_topfile(ps)->hookbeg, TRUE );
+}
+
+
+/** 
+ * 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;
+
+  return ps_check( ps, ps_topfile(ps)->hookend, TRUE );
+}
+
+
+/** 
+ * Get char (through Filestack).
+ * 
+ * @param ps Pstate.
+ * 
+ * @return Char or EOF.
+ */
+int ps_in( pstate_t* ps )
+{
+  return fs_get( ps->fs );
+}
+
+
+/** 
+ * Output char to current output stream.
+ * 
+ * @param ps Pstate.
+ * @param c  Char.
+ */
+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 );
+}
+
+
+/** 
+ * Output chars with ps_out.
+ * 
+ * @param ps  Pstate.
+ * @param str Output string (or NULL for no output).
+ */
+void ps_out_str( pstate_t* ps, gchar* str )
+{
+  if ( str )
+    {
+      int len = strlen( str );
+
+      for ( int i = 0; i < len; i++ )
+        {
+          ps_out( ps, str[ i ] );
+        }
+    }
+}
+
+
+/** 
+ * Push new output stream on top of output file stack.
+ * 
+ * @param ps Pstate.
+ * @param filename File name.
+ */
+void ps_push_file( pstate_t* ps, gchar* filename )
+{
+  ps->output = g_list_prepend( ps->output,
+                               outfile_new( filename ) );
+}
+
+
+/** 
+ * Pop file from output file stack. Close the stream.
+ * 
+ * @param ps Pstate.
+ */
+void ps_pop_file( pstate_t* ps )
+{
+  outfile_t* of;
+
+  of = ps->output->data;
+  outfile_rem( of );
+  ps->output = g_list_delete_link( ps->output, ps->output );
+}
+
+
+/** 
+ * Return current Stackfile (input stream).
+ * 
+ * @param ps Pstate.
+ * 
+ * @return Stackfile (or NULL if none).
+ */
+stackfile_t* ps_current_file( pstate_t* ps )
+{
+  if ( ps == NULL )
+    return NULL;
+  else if ( !ps_has_file(ps) )
+    return NULL;
+  else
+    return ps_topfile(ps);
+}
+
+
+/** 
+ * Initialize macro content collection.
+ * 
+ * @param ps Pstate.
+ */
+void ps_start_collect( pstate_t* ps )
+{
+  g_string_set_size( ps->macro_buf, 0 );
+}
+
+
+/** 
+ * Add content to macro.
+ * 
+ * @param ps Pstate.
+ * @param c  Char to add.
+ */
+void ps_collect( pstate_t* ps, int c )
+{
+  g_string_append_c( ps->macro_buf, c );
+}
+
+
+/** 
+ * Get current macro content.
+ * 
+ * @param ps Pstate.
+ * 
+ * @return Macro content.
+ */
+char* ps_get_macro( pstate_t* ps )
+{
+  return ps->macro_buf->str;
+}
+
+
+/** 
+ * 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 to_str Result convert enable.
+ * @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 )
+{
+  int status = 0;
+  VALUE ret;
+
+  if ( !ctxt )
+    /* Used default context. */
+    ctxt = "macro";
+
+  ret = rb_eval_string_protect( (char*) str, &status );
+
+  if ( status == 0 )
+    {
+      /* Successfull execution. */
+      if ( to_str )
+        {
+          if ( TYPE( ret ) == T_STRING )
+            {
+              return ( (gchar*) StringValueCStr( ret ) );
+            }
+          else
+            {
+              /* Convert to Ruby String. */
+              ret = rb_inspect( ret );
+              return ( (gchar*) StringValueCStr( ret ) );
+            }
+        }
+      else
+        {
+          return NULL;
+        }
+    }
+  else
+    {
+      mucgly_error( ps_current_file( ps ), "Error in %s: \n  in ruby (%s): %s",
+                    ctxt,
+                    RSTRING_PTR(rb_inspect(RARRAY_AREF(rb_gv_get("$@"),0))),
+                    RSTRING_PTR(rb_inspect(rb_gv_get("$!"))) );
+      return NULL;
+    }
+}
+
+
+/** 
+ * Load file Ruby intepreter.
+ * 
+ * @param filename Source file.
+ */
+void ps_load_ruby_file( pstate_t* ps, gchar* filename )
+{
+  GString* cmd;
+
+  cmd = g_string_sized_new( 0 );
+  g_string_printf( cmd, "load \"%s\"", filename );
+  ps_eval_ruby_str( ps, cmd->str, FALSE, "load" );
+  g_string_free( cmd, TRUE );
+}
+
+
+/** 
+ * Execute Mucgly command/macro.
+ * 
+ * @param ps Pstate.
+ * 
+ * @return TRUE if input processing should be aborted.
+ */
+gboolean ps_eval_cmd( pstate_t* ps )
+{
+  char* cmd;
+  
+  cmd = ps_get_macro( ps );
+
+  if ( cmd[0] == ':' )
+    {
+
+      /* Mucgly internal command. */
+
+      int len;
+
+      if ( 0 ) {}
+      else if ( ( len = len_str_cmp( ":hookbeg", cmd ) ) )
+        sf_set_hook( ps_topfile(ps), hook_beg, &cmd[ len+1 ] );
+      else if ( ( len = len_str_cmp( ":hookend", cmd ) ) )
+        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( ":hookall", cmd ) ) )
+        {
+          sf_set_hook( ps_topfile(ps), hook_beg, &cmd[ len+1 ] );
+          sf_set_hook( ps_topfile(ps), hook_end, &cmd[ len+1 ] );
+          sf_set_hook( ps_topfile(ps), hook_esc, &cmd[ len+1 ] );
+        }
+
+      else if ( ( len = len_str_cmp( ":hook", cmd ) ) )
+        {
+          gchar** pieces;
+          
+          pieces = g_strsplit( &cmd[ len+1 ], " ", 2 );
+          if ( g_strv_length( pieces ) == 2 )
+            {
+              /* Two hooks separated by space. */
+              sf_set_hook( ps_topfile(ps), hook_beg, pieces[0] );
+              sf_set_hook( ps_topfile(ps), hook_end, pieces[1] );
+            }
+          else
+            {
+              /* Only one hook specified. */
+              sf_set_hook( ps_topfile(ps), hook_beg, pieces[0] );
+              sf_set_hook( ps_topfile(ps), hook_end, pieces[0] );
+            }
+          g_strfreev( pieces );
+        }
+
+      else if ( ( len = len_str_cmp( ":include", cmd ) ) )
+        fs_push_file( ps->fs, &cmd[ len+1 ] );
+
+      else if ( ( len = len_str_cmp( ":source", cmd ) ) )
+        ps_load_ruby_file( ps, &cmd[ len+1 ] );
+
+      else if ( ( len = len_str_cmp( ":comment", cmd ) ) )
+        {
+          /* Do nothing. */
+        }
+
+      else if ( ( len = len_str_cmp( ":exit", cmd ) ) )
+        {
+          /* Exit processing. */
+          return TRUE;
+        }
+
+      else
+        {
+          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. */
+    }
+
+  else if ( cmd[0] == '#' )
+    {
+      /* Postpone evaluation (to next round). */
+
+      ps_out_str( ps, ps_topfile(ps)->hookbeg );
+
+      /* Remove one # sign. */
+      ps_out_str( ps, &cmd[1] );
+
+      ps_out_str( ps, ps_topfile(ps)->hookend );
+    }
+        
+  else
+    {
+      /* Ruby code execution. */
+      ps_eval_ruby_str( ps, cmd, FALSE, NULL );
+    }
+
+  return FALSE;
+}
+
+
+/** 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 );                                              \
+      }                                                                 \
+  }
+
+
+/** 
+ * 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.
+ */
+void ps_process_file( pstate_t* ps, gchar* infile, gchar* outfile )
+{
+  int c;
+
+  fs_push_file( ps->fs, infile );
+
+  if ( outfile )
+    {
+      ps_push_file( ps, outfile );
+      g_free( outfile );
+    }
+
+  /* ------------------------------------------------------------
+   * Process input:
+   * ------------------------------------------------------------ */
+
+  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
+         encountered. Files are popped automatically after EOF. */
+
+      c = ps_in( ps );
+
+      /* Check if next char starts one of the hooks. */
+      if ( ps_check_hook( ps, c ) )
+        {
+
+          fs_put( ps->fs, c );
+
+          /* Escape is always checked before other hooks. */
+          if ( ps_check_hookesc( ps ) )
+            {
+              /* Handle ESCAPEs depending whether in macro or not. */
+
+              if ( ps->in_macro )
+                {
+
+                  /* Escape in macro. */
+
+                  /* Just transfer the following char to output. */
+                  c = ps_in( ps );
+
+                  /* Error, if EOF in macro. */
+                  if ( c == EOF )
+                    {
+                      mucgly_error( ps_current_file(ps), "Got EOF within macro!" );
+                    }
+                  else
+                    {
+                  
+                      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;
+                            }
+                        }
+                      else
+                        {
+                          ps_collect( ps, c );
+                        }
+                    }
+                }
+              else
+                {
+
+                  /* Escape outside macro. */
+
+                  /* Map next char according to escape rules. */
+                  c = ps_in( ps );
+
+                  if ( c == EOF )
+                    {
+                      /* EOF */
+                      break;
+                    }
+                  else
+                    {
+
+                      switch ( (char)c )
+                        {
+
+                        case '\n':
+                          /* Eat newlines. */
+                          break;
+
+                        case ' ':
+                          /* Eat spaces. */
+                          break;
+
+                        default:
+
+                          if ( ps_topfile(ps)->hook_esc_eq_beg )
+                            {
+
+                              if ( ps_topfile(ps)->hookesc[1] == 0
+                                   && c == ps_topfile(ps)->hookesc[0] )
+                                {
+                                  /* Escape is one char long and following
+                                     char was ESC (i.e. escaped escape). */
+                                  ps_out( ps, c );
+                                }
+                              else
+                                {
+                                  /* 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 );
+
+                                  /* Start collect the macro content. */
+                                  ps_start_collect( ps );
+                                }
+                            }
+                          else
+                            {
+                              /* Literal output. */
+                              ps_out( ps, c );
+                            }
+                        }
+                    }
+              
+                }
+            }
+          else if ( ps->in_macro && ps_check_hookend( ps ) )
+            {
+              /* Hookend has priority over hookbeg if we are in macro. */
+              HOOK_END_SEQ;
+            }
+          else if ( ps_check_hookbeg( ps ) )
+            {
+
+              if ( ps->in_macro )
+                {
+                  /* Macro in macro. */
+
+                  /* Increase macro level. */
+                  ps->in_macro++;
+
+                  /* Output the consumed hookbeg. */
+                  ps_out_str( ps, ps_topfile(ps)->hookbeg );
+                }
+              else
+                {
+                  /* New macro starting. */
+                  ps->in_macro++;
+
+                  /* Store macro start info. */
+                  sf_mark_macro( ps_topfile( ps ) );
+
+                  ps_start_collect( ps );
+                }
+
+            }
+          else if ( ps_check_hookend( ps ) )
+            {
+              HOOK_END_SEQ;
+            }
+          else
+            {
+              c = ps_in( ps );
+              NON_HOOK_SEQ;
+            }
+        }
+      else
+        {
+          NON_HOOK_SEQ;
+        }
+    }
+
+  if ( outfile )
+    ps_pop_file( ps );
+
+}
+
+
+
+
+/* ------------------------------------------------------------
+ * Mucgly Ruby-functions:
+ * ------------------------------------------------------------ */
+
+
+/** 
+ * 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 )
+{
+  char* str;
+  VALUE tmp;
+
+  if ( TYPE( rstr ) == T_STRING )
+    tmp = rstr;
+  else
+    /* Convert to Ruby String. */
+    tmp = rb_inspect( rstr );
+    
+  str = RSTRING_PTR( tmp );
+  ps_out_str( ruby_ps, str );
+  return Qnil;
+}
+
+
+/** 
+ * 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 )
+{
+  char* str;
+  VALUE tmp;
+
+  if ( TYPE( rstr ) == T_STRING )
+    tmp = rstr;
+  else
+    /* Convert to Ruby String. */
+    tmp = rb_inspect( rstr );
+    
+  str = RSTRING_PTR( tmp );
+
+  ps_out_str( ruby_ps, str );
+  ps_out( ruby_ps, '\n' );
+  return Qnil;
+}
+
+
+/** 
+ * 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 );
+}
+
+
+/** 
+ * 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 );
+}
+
+
+/** 
+ * Mucgly.hookesc method. Get hookesc.
+ * 
+ * @param obj  Not used.
+ * 
+ * @return Hookesc as Ruby String.
+ */
+VALUE mucgly_hookesc( VALUE obj )
+{
+  return rb_str_new_cstr( ps_current_file( ruby_ps )->hookesc );
+}
+
+
+/** 
+ * Mucgly.sethookbeg method. Set hookbeg.
+ * 
+ * @param obj  Not used.
+ * @param rstr Hookbeg string (Ruby String).
+ * 
+ * @return Qnil.
+ */
+VALUE mucgly_sethookbeg( VALUE obj, VALUE rstr )
+{
+  char* str;
+  str = RSTRING_PTR( rstr );
+  sf_set_hook( ps_topfile( ruby_ps ), hook_beg, str );
+  return Qnil;
+}
+
+
+/** 
+ * Mucgly.sethookend method. Set hookend.
+ * 
+ * @param obj  Not used.
+ * @param rstr Hookend string (Ruby String).
+ * 
+ * @return Qnil.
+ */
+VALUE mucgly_sethookend( VALUE obj, VALUE rstr )
+{
+  char* str;
+  str = RSTRING_PTR( rstr );
+  sf_set_hook( ps_topfile( ruby_ps ), hook_end, str );
+  return Qnil;
+}
+
+
+/** 
+ * Mucgly.sethookesc method. Set hookesc.
+ * 
+ * @param obj  Not used.
+ * @param rstr Hookesc string (Ruby String).
+ * 
+ * @return Qnil.
+ */
+VALUE mucgly_sethookesc( VALUE obj, VALUE rstr )
+{
+  char* str;
+  str = RSTRING_PTR( rstr );
+  sf_set_hook( ps_topfile( ruby_ps ), hook_esc, str );
+  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 )
+{
+  return rb_str_new_cstr( ps_topfile(ruby_ps)->filename );
+}
+
+
+/** 
+ * Mucgly.ilinenumber method. Gets current input file line.
+ * 
+ * @param obj  Not used.
+ * 
+ * @return Input file line number (Ruby Fixnum).
+ */
+VALUE mucgly_ilinenumber( VALUE obj )
+{
+  return INT2FIX( ps_topfile(ruby_ps)->lineno+1 );
+}
+
+
+/** 
+ * Mucgly.ofilename method. Gets current output file name.
+ * 
+ * @param obj  Not used.
+ * 
+ * @return Input file name (Ruby String).
+ */
+VALUE mucgly_ofilename( VALUE obj )
+{
+  outfile_t* of;
+  of = ruby_ps->output->data;
+  return rb_str_new_cstr( of->filename );
+}
+
+
+/** 
+ * Mucgly.olinenumber method. Gets current output file line.
+ * 
+ * @param obj  Not used.
+ * 
+ * @return Output file line number (Ruby Fixnum).
+ */
+VALUE mucgly_olinenumber( VALUE obj )
+{
+  outfile_t* of;
+  of = ruby_ps->output->data;
+  return INT2FIX( (of->lineno+1) );
+}
+
+
+/** 
+ * 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 )
+{
+  char* str;
+
+  str = RSTRING_PTR( rstr );
+  fs_push_file( ruby_ps->fs, str );
+  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 );
+  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 )
+{
+  char* str;
+
+  str = RSTRING_PTR( rstr );
+  ps_push_file( ruby_ps, str );
+  return Qnil;
+}
+
+
+/** 
+ * Mucgly.closeoutput method. Pop output stream and close file stream.
+ * 
+ * @param obj  Not used.
+ * 
+ * @return Qnil.
+ */
+VALUE mucgly_closeoutput( VALUE obj )
+{
+  ps_pop_file( 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 )
+{
+  int argc;
+  char** argv;
+
+  argc = RARRAY_LEN( cli );
+  argv = (char**) g_new0( gpointer, argc );
+
+  for ( int i = 0; i < argc; i++ )
+    {
+      argv[ i ] = RSTRING_PTR( RARRAY_AREF(cli,i) );
+    }
+
+  mucgly_main( argc, argv );
+
+  return Qnil;
+}
+#endif
+
+
+/** 
+ * Create Mucgly Ruby module and register all methods to it.
+ * 
+ */
+void Init_mucgly( void )
+{
+  VALUE mMucgly;
+
+  mMucgly = rb_define_module( "Mucgly" );
+
+#ifdef MUCGLY_LIB
+  rb_define_module_function( mMucgly, "run_mucgly", mucgly_run_mucgly, 1 );
+#endif
+
+  rb_define_module_function( mMucgly, "write", mucgly_write, 1 );
+  rb_define_module_function( mMucgly, "puts", mucgly_puts, 1 );
+  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, "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, "ifilename", mucgly_ifilename, 0 );
+  rb_define_module_function( mMucgly, "ilinenumber", mucgly_ilinenumber, 0 );
+  rb_define_module_function( mMucgly, "ofilename", mucgly_ofilename, 0 );
+  rb_define_module_function( mMucgly, "olinenumber", mucgly_olinenumber, 0 );
+  rb_define_module_function( mMucgly, "pushinput", mucgly_pushinput, 1 );
+  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 );
+
+}
+
+
+/** 
+ * 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 )
+{
+  gchar* tag = NULL;
+  gchar* ret;
+
+  if ( !outfile_tag )
+    return NULL;
+
+  if ( g_strrstr( infile, outfile_tag ) )
+    {
+      ret = g_strdup( infile );
+      tag = g_strrstr( ret, outfile_tag );
+      g_stpcpy( tag, tag + strlen( outfile_tag ) );
+      return ret;
+    }
+  else
+    {
+      return NULL;
+    }
+}
+
+
+
+/* ------------------------------------------------------------
+ * Main program:
+ * ------------------------------------------------------------ */
+
+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:
+   * ------------------------------------------------------------ */
+
+  gchar** opt_files = NULL;
+  gchar** opt_configs = NULL;
+  gchar* opt_output = NULL;
+  gchar* opt_genout = NULL;
+  gchar** opt_cli_cmds = NULL;
+  gchar* opt_beg_sep = NULL;
+  gchar* opt_end_sep = NULL;
+  gchar* opt_esc_sep = NULL;
+  gchar* opt_all_sep = NULL;
+  gboolean opt_module = FALSE;
+  gboolean opt_interact = FALSE;
+  gboolean opt_no_init = FALSE;
+
+
+  GOptionEntry opts_table[] =
+    {
+      { "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 },
+      { "module", 'm', 0, G_OPTION_ARG_NONE,
+        &opt_module, "Include Mucgly module at start.", NULL },
+      { "interact", 'i', 0, G_OPTION_ARG_NONE,
+        &opt_interact, "Flush output for proper interaction.", NULL },
+      { "no_init", 'n', 0, G_OPTION_ARG_NONE,
+        &opt_no_init, "No init file (MUCGLY env var).", NULL },
+      { NULL }
+    };
+
+
+  GError* opts_error = NULL;
+  GOptionContext* opts;
+
+  opts = g_option_context_new( "- Inline Macro processor" );
+  g_option_context_add_main_entries( opts, opts_table, NULL );
+  if ( !g_option_context_parse( opts, &argc, &argv, &opts_error ) )
+    {
+      g_print( "mucgly: option parsing failed: %s\n", opts_error->message );
+      exit( EXIT_FAILURE );
+    }
+
+
+  /* Create initial input state. */
+  pstate_t* ps = ps_new( opt_output );
+  ruby_ps = ps;
+
+
+  /* Read init file if existing. */
+  if ( !opt_no_init )
+    {
+      gchar* init;
+      if ( ( init = (gchar*) g_environ_getenv( g_get_environ(), "MUCGLY" ) ) )
+        {
+          if ( !g_file_test( init, G_FILE_TEST_EXISTS ) )
+            mucgly_warn( ps_current_file(ps),
+                         "MUCGLY env set, but the file \"%s\" does not exist!",
+                         init );
+          else
+            {
+              ps_load_ruby_file( ps, init );
+            }
+        }
+    }
+
+
+  /* Include Mucgly module to flatten the namespace. */
+  if ( opt_module )
+    rb_eval_string( "include Mucgly" );
+
+
+  /* Read Ruby configuration files. */
+  if ( opt_configs )
+    {
+      while ( *opt_configs )
+        {
+          ps_load_ruby_file( ps, *opt_configs );
+          opt_configs++;
+        }
+    }
+
+
+  /* Process Ruby command line options. */
+  if ( opt_cli_cmds )
+    {
+      while ( *opt_cli_cmds )
+        {
+          ps_eval_ruby_str( ps, *opt_cli_cmds, FALSE, "cli" );
+          opt_cli_cmds++;
+        }
+    }
+
+
+  /* Set hooks. */
+
+  if ( opt_beg_sep )
+    sf_set_hook( stack_default, hook_beg, opt_beg_sep );
+
+  if ( opt_end_sep )
+    sf_set_hook( stack_default, hook_end, opt_end_sep );
+
+  if ( opt_esc_sep )
+    sf_set_hook( stack_default, hook_esc, opt_esc_sep );
+
+  if ( opt_all_sep )
+    {
+      sf_set_hook( stack_default, hook_beg, opt_all_sep );
+      sf_set_hook( stack_default, hook_end, opt_all_sep );
+      sf_set_hook( stack_default, hook_esc, opt_all_sep );
+    }
+
+
+  if ( opt_interact )
+    ps->flush = TRUE;
+
+  /* Process input files. */
+  if ( opt_files )
+    {
+      /* Named files. */
+      while ( *opt_files )
+        {
+          ps_process_file( ps,
+                           *opt_files,
+                           infile_to_outfile(
+                             *opt_files,
+                             opt_genout )
+                           );
+          opt_files++;
+        }
+    }
+  else
+    {
+      /* Process STDIN. */
+      ps_process_file( ps, NULL, NULL );
+    }
+
+  ps_rem( ps );
+
+}
+
+
+#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 )
+{
+  mucgly_main( argc, argv );
+}
+#endif