*.c, *.h: Replace preceding sequences of 8 spaces with tabs.

2007-01-16  Behdad Esfahbod  <behdad@gnome.org>

        *.c, *.h: Replace preceding sequences of 8 spaces with tabs.


svn path=/trunk/; revision=2165

22 files changed, 870 insertions, 870 deletions

diff --git a/modules/arabic/arabic-lang.c b/modules/arabic/arabic-lang.c
index 885977c4..7022b04e 100644
--- a/modules/arabic/arabic-lang.c
+++ b/modules/arabic/arabic-lang.c
@@ -110,7 +110,7 @@ arabic_engine_break (PangoEngineLang *engine,
 	  (prev_wc == ALEF && IS_COMPOSITE_WITH_ALEF (this_wc)) ||
 	  (this_wc == HAMZA_ABOVE && (prev_wc == WAW || prev_wc == YEH))
 	 ))
-        attrs[i+1].backspace_deletes_character = FALSE;
+	attrs[i+1].backspace_deletes_character = FALSE;
     }
 }
 
diff --git a/modules/arabic/arabic-ot.c b/modules/arabic/arabic-ot.c
index bf7cd070..ab57fd25 100644
--- a/modules/arabic/arabic-ot.c
+++ b/modules/arabic/arabic-ot.c
@@ -194,7 +194,7 @@ TT_Error  Build_Arabic_Glyph_Properties (TT_CharMap        char_map,
 	MARK_GLYPH : SIMPLE_GLYPH;
       Arabic[j].glyph_index = TT_Char_Index (char_map, i);
       if (Arabic[j].glyph_index)
-        j++;
+	j++;
     }
   num_glyphs = j;
 
@@ -222,7 +222,7 @@ TT_Error  Build_Arabic_Glyph_Properties (TT_CharMap        char_map,
       classes[j]       = Arabic[i].class;
 
       if (glyph_indices[j - 1] != glyph_indices[j])
-        j++;
+	j++;
     }
   num_glyphs = j;
 
@@ -291,26 +291,26 @@ static joining_class  Get_Joining_Class (gunichar*   string,
   while (1)
     {
       if (pos == 0 && direction < 0)
-        return none;
+	return none;
 
       pos += direction;
 
       if (pos >= length)
-        return none;
+	return none;
 
       if (string[pos] >= 0x0620 &&
-          string[pos] < 0x0700)
-        j = arabic[string[pos] - 0x0620];
+	  string[pos] < 0x0700)
+	j = arabic[string[pos] - 0x0620];
       else if (string[pos] >= 0x0750 &&
-          string[pos] < 0x0780)
-        j = arabic_supplement[string[pos] - 0x0750];
+	  string[pos] < 0x0780)
+	j = arabic_supplement[string[pos] - 0x0750];
       else if (string[pos] == 0x200D)
-        return causing;
+	return causing;
       else
-        return none;
+	return none;
 
       if (!direction || j != transparent)
-        return j;
+	return j;
     }
 }
 
@@ -345,7 +345,7 @@ FT_Error  Arabic_Assign_Properties (gunichar    *string,
       if (previous == causing ||
 	  previous == left    ||
 	  previous == dual   )
-        if (current == right)
+	if (current == right)
 	  {
 	    properties[i] |= final_p;
 	    continue;
@@ -354,7 +354,7 @@ FT_Error  Arabic_Assign_Properties (gunichar    *string,
       /* R3 */
 
       if (current == left)
-        if (next == causing ||
+	if (next == causing ||
 	    next == right   ||
 	    next == dual   )
 	  {
@@ -367,8 +367,8 @@ FT_Error  Arabic_Assign_Properties (gunichar    *string,
       if (previous == causing ||
 	  previous == left    ||
 	  previous == dual   )
-        if (current == dual)
-          if (next == causing ||
+	if (current == dual)
+	  if (next == causing ||
 	      next == right   ||
 	      next == dual   )
 	    {
@@ -381,8 +381,8 @@ FT_Error  Arabic_Assign_Properties (gunichar    *string,
       if (previous == causing ||
 	  previous == left    ||
 	  previous == dual   )
-        if (current == dual)
-          if (!(next == causing ||
+	if (current == dual)
+	  if (!(next == causing ||
 		next == right   ||
 		next == dual   ))
 	    {
@@ -395,8 +395,8 @@ FT_Error  Arabic_Assign_Properties (gunichar    *string,
       if (!(previous == causing ||
 	    previous == left    ||
 	    previous == dual   ))
-        if (current == dual)
-          if (next == causing ||
+	if (current == dual)
+	  if (next == causing ||
 	      next == right   ||
 	      next == dual   )
 	    {
diff --git a/modules/arabic/arabic.c b/modules/arabic/arabic.c
index 9b6aae75..161f4c3b 100644
--- a/modules/arabic/arabic.c
+++ b/modules/arabic/arabic.c
@@ -29,10 +29,10 @@ static PangoEngineRange arabic_range[] = {
 
 static PangoEngineInfo script_engines[] = {
     {
-        "ArabicScriptEngineX",
-        PANGO_ENGINE_TYPE_SHAPE,
-        PANGO_RENDER_TYPE_X,
-        arabic_range, G_N_ELEMENTS(arabic_range)
+	"ArabicScriptEngineX",
+	PANGO_ENGINE_TYPE_SHAPE,
+	PANGO_RENDER_TYPE_X,
+	arabic_range, G_N_ELEMENTS(arabic_range)
     }
 };
 
@@ -48,28 +48,28 @@ arabic_unicodeinit(PangoFont  *font, PangoXSubfont subfont)
     ArabicFontInfo    *fs = NULL;
 
     if (subfont != 0)
-        {
-            if ( pango_x_has_glyph /* Alif-Madda */
-                 (font,PANGO_X_MAKE_GLYPH(subfont,0xFE81)))
-                {
-                    fs              = g_new (ArabicFontInfo,1);
-                    fs->level       = ar_standard | ar_unifont;
-                    fs->subfonts[0] = subfont;
-
-                    if ( pango_x_has_glyph /* Shadda+Kasra */
-                         (font,PANGO_X_MAKE_GLYPH(subfont,0xFC62)))
-                        {
-                            fs->level   |= ar_composedtashkeel;
-                            /* extra vowels in font, hopefully */
-                        }
-                    if ( pango_x_has_glyph /* Lam-Min alone */
-                         (font,PANGO_X_MAKE_GLYPH(subfont,0xFC42)))
-                        {
-                            fs->level |= ar_lig;
-                            /* extra ligatures in font, hopefully */
-                        }
-                }
-        }
+	{
+	    if ( pango_x_has_glyph /* Alif-Madda */
+		 (font,PANGO_X_MAKE_GLYPH(subfont,0xFE81)))
+		{
+		    fs              = g_new (ArabicFontInfo,1);
+		    fs->level       = ar_standard | ar_unifont;
+		    fs->subfonts[0] = subfont;
+
+		    if ( pango_x_has_glyph /* Shadda+Kasra */
+			 (font,PANGO_X_MAKE_GLYPH(subfont,0xFC62)))
+			{
+			    fs->level   |= ar_composedtashkeel;
+			    /* extra vowels in font, hopefully */
+			}
+		    if ( pango_x_has_glyph /* Lam-Min alone */
+			 (font,PANGO_X_MAKE_GLYPH(subfont,0xFC42)))
+			{
+			    fs->level |= ar_lig;
+			    /* extra ligatures in font, hopefully */
+			}
+		}
+	}
     return fs;
 }
 
@@ -77,9 +77,9 @@ static ArabicFontInfo*
 find_unic_font (PangoFont *font)
 {
     static char *charsets[] = {
-        "iso10646-1",
-        "iso8859-6.8x",
-        "mulearabic-2",
+	"iso10646-1",
+	"iso8859-6.8x",
+	"mulearabic-2",
 	"urdunaqsh-0",
 /*          "symbol-0" */
     };
@@ -95,44 +95,44 @@ find_unic_font (PangoFont *font)
     if (fs) return fs;
 
     n_subfonts = pango_x_list_subfonts (font, charsets, 4,
-                                        &subfonts, &subfont_charsets);
+					&subfonts, &subfont_charsets);
 
     for (i=0; i < n_subfonts; i++)
-        {
-            if  ( !strcmp (charsets[subfont_charsets[i]], "mulearabic-2"))
-                {
+	{
+	    if  ( !strcmp (charsets[subfont_charsets[i]], "mulearabic-2"))
+		{
 #ifdef DEBUG
-                    if (getenv("PANGO_AR_NOMULEFONT") == NULL )
+		    if (getenv("PANGO_AR_NOMULEFONT") == NULL )
 #endif
-                        fs = arabic_muleinit(font);
-                }
-            else if ( !strcmp (charsets[subfont_charsets[i]], "iso8859-6.8x"))
-                {
+			fs = arabic_muleinit(font);
+		}
+	    else if ( !strcmp (charsets[subfont_charsets[i]], "iso8859-6.8x"))
+		{
 #ifdef DEBUG
-                    if (getenv("PANGO_AR_NOLBOXFONT") == NULL )
+		    if (getenv("PANGO_AR_NOLBOXFONT") == NULL )
 #endif
-                        fs = arabic_lboxinit(font);
-                }
-            else if ( !strcmp (charsets[subfont_charsets[i]], "urdunaqsh-0"))
-                {
+			fs = arabic_lboxinit(font);
+		}
+	    else if ( !strcmp (charsets[subfont_charsets[i]], "urdunaqsh-0"))
+		{
 #ifdef DEBUG
-                    if (getenv("PANGO_AR_NONQFONT") == NULL )
+		    if (getenv("PANGO_AR_NONQFONT") == NULL )
 #endif
-                        fs = urdu_naqshinit(font);
-                }
-            else
-                {
+			fs = urdu_naqshinit(font);
+		}
+	    else
+		{
 #ifdef DEBUG
-                    if (getenv("PANGO_AR_NOUNIFONT") == NULL )
+		    if (getenv("PANGO_AR_NOUNIFONT") == NULL )
 #endif
-                        fs = arabic_unicodeinit(font,subfonts[i]);
-                }
-            if (fs){
-                g_object_set_qdata_full (G_OBJECT (font), info_id,
-                                         fs, (GDestroyNotify)g_free);
-                break;
-            }
-        }
+			fs = arabic_unicodeinit(font,subfonts[i]);
+		}
+	    if (fs){
+		g_object_set_qdata_full (G_OBJECT (font), info_id,
+					 fs, (GDestroyNotify)g_free);
+		break;
+	    }
+	}
 
     g_free (subfonts);
     g_free (subfont_charsets);
@@ -144,8 +144,8 @@ find_unic_font (PangoFont *font)
 
 static void
 set_glyph (PangoGlyphString *glyphs,
-           PangoFont *font, PangoXSubfont subfont,
-           int i, int cluster_start, int glyph, int is_vowel)
+	   PangoFont *font, PangoXSubfont subfont,
+	   int i, int cluster_start, int glyph, int is_vowel)
 {
     PangoRectangle logical_rect;
 
@@ -157,13 +157,13 @@ set_glyph (PangoGlyphString *glyphs,
     pango_font_get_glyph_extents (font, glyphs->glyphs[i].glyph, NULL, &logical_rect);
     glyphs->log_clusters[i] = cluster_start;
     if (is_vowel)
-        {
-            glyphs->glyphs[i].geometry.width = 0;
-        }
+	{
+	    glyphs->glyphs[i].geometry.width = 0;
+	}
     else
-        {
-            glyphs->glyphs[i].geometry.width = logical_rect.width;
-        }
+	{
+	    glyphs->glyphs[i].geometry.width = logical_rect.width;
+	}
 }
 
 
@@ -171,10 +171,10 @@ set_glyph (PangoGlyphString *glyphs,
 
 static void
 arabic_engine_shape (PangoFont        *font,
-                     const char       *text,
-                     int               length,
-                     PangoAnalysis    *analysis,
-                     PangoGlyphString *glyphs)
+		     const char       *text,
+		     int               length,
+		     PangoAnalysis    *analysis,
+		     PangoGlyphString *glyphs)
 {
     PangoXSubfont   subfont;
     int             n_chars;
@@ -193,42 +193,42 @@ arabic_engine_shape (PangoFont        *font,
      */
 
     if (! (fs = find_unic_font (font)) )
-        {
+	{
 
-            PangoGlyph unknown_glyph = pango_x_get_unknown_glyph (font);
+	    PangoGlyph unknown_glyph = pango_x_get_unknown_glyph (font);
 
-            n_chars = g_utf8_strlen(text,length);
-            pango_glyph_string_set_size (glyphs, n_chars);
+	    n_chars = g_utf8_strlen(text,length);
+	    pango_glyph_string_set_size (glyphs, n_chars);
 
-            p = text;
-            for (i=0; i<n_chars; i++)
-                {
-                    set_glyph (glyphs, font,
-                               PANGO_X_GLYPH_SUBFONT (unknown_glyph), i,
-                               p - text, PANGO_X_GLYPH_INDEX (unknown_glyph),0);
-                    p = g_utf8_next_char (p);
-                }
-            return;
-        }
+	    p = text;
+	    for (i=0; i<n_chars; i++)
+		{
+		    set_glyph (glyphs, font,
+			       PANGO_X_GLYPH_SUBFONT (unknown_glyph), i,
+			       p - text, PANGO_X_GLYPH_INDEX (unknown_glyph),0);
+		    p = g_utf8_next_char (p);
+		}
+	    return;
+	}
 
 
     p = text;
     if (analysis->level % 2 == 0)
-        {
-            wc      = g_utf8_to_ucs4_fast(text,length,&n_chars);
-            /* We were called on a LTR directional run (e.g. some numbers);
-               fallback as simple as possible */
-            pango_glyph_string_set_size (glyphs, n_chars);
+	{
+	    wc      = g_utf8_to_ucs4_fast(text,length,&n_chars);
+	    /* We were called on a LTR directional run (e.g. some numbers);
+	       fallback as simple as possible */
+	    pango_glyph_string_set_size (glyphs, n_chars);
 
-        }
+	}
     else
-        {
-            wc      = (gunichar *)g_malloc(sizeof(gunichar)* (length) ); /* length is succicient: all arabic chars use at
+	{
+	    wc      = (gunichar *)g_malloc(sizeof(gunichar)* (length) ); /* length is succicient: all arabic chars use at
 									    least 2 bytes in utf-8 encoding */
-            n_chars = length;
-            arabic_reshape(&n_chars,text,wc,fs->level);
-            pango_glyph_string_set_size (glyphs, n_chars);
-        };
+	    n_chars = length;
+	    arabic_reshape(&n_chars,text,wc,fs->level);
+	    pango_glyph_string_set_size (glyphs, n_chars);
+	};
 
 
     p    = text;
@@ -237,59 +237,59 @@ arabic_engine_shape (PangoFont        *font,
     subfont = fs->subfonts[0];
 
     while(i < n_chars)
-        {
-            if (wc[i] == 0)
-                {
-                    p = g_utf8_next_char (p);
+	{
+	    if (wc[i] == 0)
+		{
+		    p = g_utf8_next_char (p);
 #ifdef DEBUG
-                    fprintf(stderr,"NULL-character detected in generated string.!");
+		    fprintf(stderr,"NULL-character detected in generated string.!");
 #endif
-                    i++;
-                }
-            else
-                {
-                    int cluster_start ;
-                    int is_vowel      = arabic_isvowel(wc[i]);
-                    cluster_start     = is_vowel ? pold - text : p - text;
-
-                    if ( fs->level & ar_mulefont )
-                        {
-                            arabic_mule_recode(&subfont,&(wc[i]),
-                                               fs->subfonts);
-                        }
-                    else if ( fs->level & ar_lboxfont )
-                        {
-                            if (( i < n_chars-1 )&&(wc[i+1] == 0))
-                                {
-                                    arabic_lbox_recode(&subfont,&(wc[i]),
-                                                       &(wc[i+1]),
-                                                       fs->subfonts);
-                                }
-                            else
-                                arabic_lbox_recode(&subfont,&(wc[i]),NULL,
-                                                   fs->subfonts);
-                        }
-                    else if ( fs->level & ar_naqshfont )
-                        {
-                            if (( i < n_chars-1 )&&(wc[i+1] == 0))
-                                {
-                                    urdu_naqsh_recode(&subfont,&(wc[i]),
-                                                      &(wc[i+1]),
-                                                      fs->subfonts);
-                                }
-                            else
-                                urdu_naqsh_recode(&subfont,&(wc[i]),NULL,
-                                                  fs->subfonts);
-                        }
-
-                    set_glyph(glyphs, font, subfont, n_chars - i - 1,
-                              cluster_start, wc[i], is_vowel);
-
-                    pold = p;
-                    p    = g_utf8_next_char (p);
-                    i++;
-                }
-        }
+		    i++;
+		}
+	    else
+		{
+		    int cluster_start ;
+		    int is_vowel      = arabic_isvowel(wc[i]);
+		    cluster_start     = is_vowel ? pold - text : p - text;
+
+		    if ( fs->level & ar_mulefont )
+			{
+			    arabic_mule_recode(&subfont,&(wc[i]),
+					       fs->subfonts);
+			}
+		    else if ( fs->level & ar_lboxfont )
+			{
+			    if (( i < n_chars-1 )&&(wc[i+1] == 0))
+				{
+				    arabic_lbox_recode(&subfont,&(wc[i]),
+						       &(wc[i+1]),
+						       fs->subfonts);
+				}
+			    else
+				arabic_lbox_recode(&subfont,&(wc[i]),NULL,
+						   fs->subfonts);
+			}
+		    else if ( fs->level & ar_naqshfont )
+			{
+			    if (( i < n_chars-1 )&&(wc[i+1] == 0))
+				{
+				    urdu_naqsh_recode(&subfont,&(wc[i]),
+						      &(wc[i+1]),
+						      fs->subfonts);
+				}
+			    else
+				urdu_naqsh_recode(&subfont,&(wc[i]),NULL,
+						  fs->subfonts);
+			}
+
+		    set_glyph(glyphs, font, subfont, n_chars - i - 1,
+			      cluster_start, wc[i], is_vowel);
+
+		    pold = p;
+		    p    = g_utf8_next_char (p);
+		    i++;
+		}
+	}
 
     g_free(wc);
 }
@@ -297,15 +297,15 @@ arabic_engine_shape (PangoFont        *font,
 
 static PangoCoverage *
 arabic_engine_get_coverage (PangoFont  *font,
-                            const char *lang)
+			    const char *lang)
 {
     gunichar i;
     PangoCoverage *result = pango_coverage_new ();
 
     for (i = 0x60B; i <= 0x66D; i++)
-        pango_coverage_set (result, i, PANGO_COVERAGE_EXACT);
+	pango_coverage_set (result, i, PANGO_COVERAGE_EXACT);
     for (i = 0x670; i <= 0x6D3; i++)
-        pango_coverage_set (result, i, PANGO_COVERAGE_EXACT);
+	pango_coverage_set (result, i, PANGO_COVERAGE_EXACT);
 
     return result;
 }
diff --git a/modules/basic/basic-fc.c b/modules/basic/basic-fc.c
index 0dcdbbd2..a4592253 100644
--- a/modules/basic/basic-fc.c
+++ b/modules/basic/basic-fc.c
@@ -174,9 +174,9 @@ fallback_shape (PangoEngineShape *engine,
 	  index = pango_fc_font_get_glyph (fc_font, wc);
 
 	  if (!index)
-            {
+	    {
 	      index = PANGO_GET_UNKNOWN_GLYPH ( wc);
-              set_glyph (font, glyphs, i, p - text, index);
+	      set_glyph (font, glyphs, i, p - text, index);
 	    }
 	  else
 	    {
@@ -262,38 +262,38 @@ get_ruleset (FT_Face face)
 
     for (i = 0; i < G_N_ELEMENTS (scripts); i++)
       {
-         PangoOTTag script_tag = FT_MAKE_TAG (scripts[i][0], scripts[i][1], scripts[i][2], scripts[i][3]);
-         guint script_index;
+	 PangoOTTag script_tag = FT_MAKE_TAG (scripts[i][0], scripts[i][1], scripts[i][2], scripts[i][3]);
+	 guint script_index;
 
 
-         if (pango_ot_info_find_script (info, PANGO_OT_TABLE_GPOS, script_tag, &script_index))
-           for (j = 0; j < G_N_ELEMENTS (gpos_features); j++)
+	 if (pango_ot_info_find_script (info, PANGO_OT_TABLE_GPOS, script_tag, &script_index))
+	   for (j = 0; j < G_N_ELEMENTS (gpos_features); j++)
 	     {
-               PangoOTTag feature_tag = FT_MAKE_TAG (gpos_features[j][0], gpos_features[j][1],
-                                                     gpos_features[j][2], gpos_features[j][3]);
-               guint feature_index;
-
-               /* 0xffff means default language */
-               if (pango_ot_info_find_feature (info, PANGO_OT_TABLE_GPOS, feature_tag, script_index, 0xffff,&feature_index))
-               {
-                 pango_ot_ruleset_add_feature (ruleset, PANGO_OT_TABLE_GPOS, feature_index, 0xffff);
+	       PangoOTTag feature_tag = FT_MAKE_TAG (gpos_features[j][0], gpos_features[j][1],
+						     gpos_features[j][2], gpos_features[j][3]);
+	       guint feature_index;
+
+	       /* 0xffff means default language */
+	       if (pango_ot_info_find_feature (info, PANGO_OT_TABLE_GPOS, feature_tag, script_index, 0xffff,&feature_index))
+	       {
+		 pango_ot_ruleset_add_feature (ruleset, PANGO_OT_TABLE_GPOS, feature_index, 0xffff);
 	       }
 	     }
 
-          if (pango_ot_info_find_script (info, PANGO_OT_TABLE_GSUB, script_tag, &script_index))
-            for (j = 0; j < G_N_ELEMENTS (gsub_features); j++)
-              {
-                PangoOTTag feature_tag = FT_MAKE_TAG (gsub_features[j][0], gsub_features[j][1],
-                                                      gsub_features[j][2], gsub_features[j][3]);
-                guint feature_index;
-
-                /* 0xffff means default language */
-                if (pango_ot_info_find_feature (info, PANGO_OT_TABLE_GSUB, feature_tag,
-                                                script_index, 0xffff, &feature_index))
-                  {
-                    pango_ot_ruleset_add_feature (ruleset, PANGO_OT_TABLE_GSUB, feature_index, 0xffff);
-                  }
-              }
+	  if (pango_ot_info_find_script (info, PANGO_OT_TABLE_GSUB, script_tag, &script_index))
+	    for (j = 0; j < G_N_ELEMENTS (gsub_features); j++)
+	      {
+		PangoOTTag feature_tag = FT_MAKE_TAG (gsub_features[j][0], gsub_features[j][1],
+						      gsub_features[j][2], gsub_features[j][3]);
+		guint feature_index;
+
+		/* 0xffff means default language */
+		if (pango_ot_info_find_feature (info, PANGO_OT_TABLE_GSUB, feature_tag,
+						script_index, 0xffff, &feature_index))
+		  {
+		    pango_ot_ruleset_add_feature (ruleset, PANGO_OT_TABLE_GSUB, feature_index, 0xffff);
+		  }
+	      }
       }
 
     g_object_set_qdata_full (G_OBJECT (info), ruleset_quark, ruleset, (GDestroyNotify) g_object_unref);
@@ -375,7 +375,7 @@ basic_engine_shape (PangoEngineShape *engine,
 	  pango_ot_buffer_add_glyph (buffer, PANGO_GLYPH_EMPTY, unknown_property, p - text);
 	}
       else
-        {
+	{
 	  index = pango_fc_font_get_glyph (fc_font, wc);
 
 	  if (!index)
diff --git a/modules/basic/basic-x.c b/modules/basic/basic-x.c
index 31784f97..fe5ad75c 100644
--- a/modules/basic/basic-x.c
+++ b/modules/basic/basic-x.c
@@ -372,8 +372,8 @@ conv_16bit (CharCache  *cache,
 
 static PangoGlyph
 conv_16bit_MSB_on (CharCache  *cache,
-	           GIConv      cd,
-	           const char *input)
+		   GIConv      cd,
+		   const char *input)
 {
   char outbuf[2];
 
diff --git a/modules/hangul/hangul-fc.c b/modules/hangul/hangul-fc.c
index 03f3b304..32470fe4 100644
--- a/modules/hangul/hangul-fc.c
+++ b/modules/hangul/hangul-fc.c
@@ -75,7 +75,7 @@ set_glyph (PangoFont *font, PangoGlyphString *glyphs, int i, int offset, PangoGl
 
 static void
 set_glyph_tone (PangoFont *font, PangoGlyphString *glyphs, int i,
-		            int offset, PangoGlyph glyph)
+			    int offset, PangoGlyph glyph)
 {
   PangoRectangle logical_rect, ink_rect;
   PangoRectangle logical_rect_cluster;
@@ -116,8 +116,8 @@ set_glyph_tone (PangoFont *font, PangoGlyphString *glyphs, int i,
       if (logical_rect.width)
 	{
 	  glyphs->glyphs[i].geometry.x_offset -= ink_rect.width;
-          glyphs->glyphs[j + 1].geometry.width += ink_rect.width;
-          glyphs->glyphs[j + 1].geometry.x_offset += ink_rect.width;
+	  glyphs->glyphs[j + 1].geometry.width += ink_rect.width;
+	  glyphs->glyphs[j + 1].geometry.x_offset += ink_rect.width;
 	}
     }
 
@@ -130,7 +130,7 @@ set_glyph_tone (PangoFont *font, PangoGlyphString *glyphs, int i,
 
 static void
 render_tone (PangoFont *font, gunichar tone, PangoGlyphString *glyphs,
-             int *n_glyphs, int cluster_offset)
+	     int *n_glyphs, int cluster_offset)
 {
   int index;
 
@@ -145,11 +145,11 @@ render_tone (PangoFont *font, gunichar tone, PangoGlyphString *glyphs,
       /* fall back : HTONE1(0x302e) => middle-dot, HTONE2(0x302f) => colon */
       index = find_char (font, tone == HTONE1 ? 0x00b7 : 0x003a);
       if (index)
-        {
-          set_glyph_tone (font, glyphs, *n_glyphs, cluster_offset, index);
-        }
+	{
+	  set_glyph_tone (font, glyphs, *n_glyphs, cluster_offset, index);
+	}
       else
-        set_glyph (font, glyphs, *n_glyphs, cluster_offset,
+	set_glyph (font, glyphs, *n_glyphs, cluster_offset,
 		   PANGO_GET_UNKNOWN_GLYPH (tone));
     }
   (*n_glyphs)++;
@@ -324,7 +324,7 @@ render_syllable (PangoFont *font, const char *str, int length,
 	  continue;
 	}
       else if (IS_S(wc))
-        {
+	{
 	  pango_glyph_string_set_size (glyphs, *n_glyphs + 1);
 	  set_glyph (font, glyphs, *n_glyphs, cluster_offset,
 		     PANGO_GET_UNKNOWN_GLYPH (wc));
diff --git a/modules/hebrew/hebrew-fc.c b/modules/hebrew/hebrew-fc.c
index d26cb52e..098b2850 100644
--- a/modules/hebrew/hebrew-fc.c
+++ b/modules/hebrew/hebrew-fc.c
@@ -77,7 +77,7 @@ get_cluster_glyphs(PangoFont      *font,
       if (pango_is_zero_width (wc))
 	glyph_num[i] = PANGO_GLYPH_EMPTY;
       else
-        {
+	{
 	  glyph_num[i] = pango_fc_font_get_glyph ((PangoFcFont *)font, wc);
 
 	  if (!glyph_num[i])
diff --git a/modules/hebrew/hebrew-shaper.c b/modules/hebrew/hebrew-shaper.c
index ae77f688..72566758 100644
--- a/modules/hebrew/hebrew-shaper.c
+++ b/modules/hebrew/hebrew-shaper.c
@@ -98,20 +98,20 @@ static const gint char_class_table[128] = {
   /*       0,   1,   2,   3,   4,   5,   6,   7 */
 
   /*00*/ _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
-         _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
+	 _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
 
   /*10*/ _ND, _NS, _NS, _NS, _NS, _NS, _NS, _NS,
-         _NS, _NS, _NS, _NS, _NS, _NS, _NS, _NS,
+	 _NS, _NS, _NS, _NS, _NS, _NS, _NS, _NS,
   /*20*/ _NS, _NS, _ND, _NS, _NS, _NS, _NS, _NS,
-         _NS, _NS, _NS, _NS, _NS, _NS, _NS, _NS,
+	 _NS, _NS, _NS, _NS, _NS, _NS, _NS, _NS,
   /*30*/ _NS, _NS, _NS, _NS, _NS, _NS, _NS, _NS,
-         _NS, _NS, _ND, _NS, _DA, _NS, _SP, _NS,
+	 _NS, _NS, _ND, _NS, _DA, _NS, _SP, _NS,
   /*40*/ _SP, _NS, _NS, _SP, _NS, _ND, _ND, _ND,
-         _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
+	 _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
   /*50*/ _SP, _SP, _SP, _SP, _SP, _SP, _SP, _SP,
-         _SP, _SP, _SP, _SP, _SP, _SP, _SP, _SP,
+	 _SP, _SP, _SP, _SP, _SP, _SP, _SP, _SP,
   /*60*/ _SP, _SP, _SP, _SP, _SP, _SP, _SP, _SP,
-         _SP, _SP, _SP, _ND, _ND, _ND, _ND, _ND,
+	 _SP, _SP, _SP, _ND, _ND, _ND, _ND, _ND,
   /*70*/ _SP, _SP, _SP, _SP, _SP, _ND, _ND, _ND,
 	 _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
 };
@@ -120,20 +120,20 @@ static const gint char_type_table[128] = {
   /*       0,   1,   2,   3,   4,   5,   6,   7 */
 
   /*00*/ __ND, __ND, __ND, __ND, __ND, __ND, __ND, __ND,
-         __ND, __ND, __ND, __ND, __ND, __ND, __ND, __ND,
+	 __ND, __ND, __ND, __ND, __ND, __ND, __ND, __ND,
 
   /*10*/ __ND, __NS, __NS, __NS, __NS, __NS, __NS, __NS,
-         __NS, __NS, __NS, __NS, __NS, __NS, __NS, __NS,
+	 __NS, __NS, __NS, __NS, __NS, __NS, __NS, __NS,
   /*20*/ __NS, __NS, __ND, __NS, __NS, __NS, __NS, __NS,
-         __NS, __NS, __NS, __NS, __NS, __NS, __NS, __NS,
+	 __NS, __NS, __NS, __NS, __NS, __NS, __NS, __NS,
   /*30*/ __NS, __NS, __NS, __NS, __NS, __NS, __NS, __NS,
-         __NS, __NS, __ND, __NS, __DA, __NS, __SP, __NS,
+	 __NS, __NS, __ND, __NS, __DA, __NS, __SP, __NS,
   /*40*/ __SP, __NS, __NS, __SP, __NS, __ND, __ND, __ND,
-         __ND, __ND, __ND, __ND, __ND, __ND, __ND, __ND,
+	 __ND, __ND, __ND, __ND, __ND, __ND, __ND, __ND,
   /*50*/ __SP, __SP, __SP, __SP, __SP, __SP, __SP, __SP,
-         __SP, __SP, __SP, __SP, __SP, __SP, __SP, __SP,
+	 __SP, __SP, __SP, __SP, __SP, __SP, __SP, __SP,
   /*60*/ __SP, __SP, __SP, __SP, __SP, __SP, __SP, __SP,
-         __SP, __SP, __SP, __ND, __ND, __ND, __ND, __ND,
+	 __SP, __SP, __SP, __ND, __ND, __ND, __ND, __ND,
   /*70*/ __SP, __SP, __SP, __SP, __SP, __ND, __ND, __ND,
 	 __ND, __ND, __ND, __ND, __ND, __ND, __ND, __ND,
 };
diff --git a/modules/indic/indic-fc.c b/modules/indic/indic-fc.c
index cdfa7696..5d81c6c4 100644
--- a/modules/indic/indic-fc.c
+++ b/modules/indic/indic-fc.c
@@ -155,7 +155,7 @@ maybe_add_GSUB_feature (PangoOTRuleset *ruleset,
 
 static void
 maybe_add_GPOS_feature (PangoOTRuleset *ruleset,
-		        PangoOTInfo    *info,
+			PangoOTInfo    *info,
 			guint           script_index,
 			PangoOTTag      feature_tag,
 			gulong          property_bit)
@@ -274,7 +274,7 @@ set_glyphs (PangoFont      *font,
 	  (!process_zwj || wcs[i] != 0x200D))
 	glyph = PANGO_GLYPH_EMPTY;
       else
-        {
+	{
 	  glyph = pango_fc_font_get_glyph (fc_font, wcs[i]);
 
 	  if (!glyph)
diff --git a/modules/indic/indic-lang.c b/modules/indic/indic-lang.c
index 89ab301f..132bedc8 100644
--- a/modules/indic/indic-lang.c
+++ b/modules/indic/indic-lang.c
@@ -154,58 +154,58 @@ indic_engine_break (PangoEngineLang *engine,
 	  attrs[i].is_mandatory_break = FALSE;
 	}
       else if (prev_wc != 0 && (this_wc == 0x200D || this_wc == 0x200C))
-        {
-          if (next_wc != 0)
-            {
-              if  (next_next_wc == 0)
-                {
-                  attrs[i].is_cursor_position = FALSE;
-	          attrs[i].is_char_break = FALSE;
-	          attrs[i].is_line_break = FALSE;
-	          attrs[i].is_mandatory_break = FALSE;
-
-                  i++;
-
-                  attrs[i].is_cursor_position = FALSE;
-	          attrs[i].is_char_break = FALSE;
-	          attrs[i].is_line_break = FALSE;
-	          attrs[i].is_mandatory_break = FALSE;
-                }
-              else if ((next_next_wc != 0) &&
-                       (next_wc == 0x09CD ||	/* Bengali */
-		        next_wc == 0x0ACD ||	/* Gujarati */
-		        next_wc == 0x094D ||	/* Hindi */
-		        next_wc == 0x0CCD ||	/* Kannada */
-		        next_wc == 0x0D4D ||	/* Malayalam */
-		        next_wc == 0x0B4D ||	/* Oriya */
-		        next_wc == 0x0A4D ||	/* Punjabi */
-		        next_wc == 0x0BCD ||	/* Tamil */
-		        next_wc == 0x0C4D ||	/* Telugu */
-                        next_wc == 0x0DCA))  /*Sinhala*/
-                {
-                  attrs[i].is_cursor_position = FALSE;
-	          attrs[i].is_char_break = FALSE;
-	          attrs[i].is_line_break = FALSE;
-	          attrs[i].is_mandatory_break = FALSE;
-
-                  i++;
-
-                  attrs[i].is_cursor_position = FALSE;
-	          attrs[i].is_char_break = FALSE;
-	          attrs[i].is_line_break = FALSE;
-	          attrs[i].is_mandatory_break = FALSE;
-
-                  i++;
-                  attrs[i].is_cursor_position = FALSE;
-                }
-            }
-          else
-            {
-              attrs[i].is_cursor_position = FALSE;
+	{
+	  if (next_wc != 0)
+	    {
+	      if  (next_next_wc == 0)
+		{
+		  attrs[i].is_cursor_position = FALSE;
+		  attrs[i].is_char_break = FALSE;
+		  attrs[i].is_line_break = FALSE;
+		  attrs[i].is_mandatory_break = FALSE;
+
+		  i++;
+
+		  attrs[i].is_cursor_position = FALSE;
+		  attrs[i].is_char_break = FALSE;
+		  attrs[i].is_line_break = FALSE;
+		  attrs[i].is_mandatory_break = FALSE;
+		}
+	      else if ((next_next_wc != 0) &&
+		       (next_wc == 0x09CD ||	/* Bengali */
+			next_wc == 0x0ACD ||	/* Gujarati */
+			next_wc == 0x094D ||	/* Hindi */
+			next_wc == 0x0CCD ||	/* Kannada */
+			next_wc == 0x0D4D ||	/* Malayalam */
+			next_wc == 0x0B4D ||	/* Oriya */
+			next_wc == 0x0A4D ||	/* Punjabi */
+			next_wc == 0x0BCD ||	/* Tamil */
+			next_wc == 0x0C4D ||	/* Telugu */
+			next_wc == 0x0DCA))  /*Sinhala*/
+		{
+		  attrs[i].is_cursor_position = FALSE;
+		  attrs[i].is_char_break = FALSE;
+		  attrs[i].is_line_break = FALSE;
+		  attrs[i].is_mandatory_break = FALSE;
+
+		  i++;
+
+		  attrs[i].is_cursor_position = FALSE;
+		  attrs[i].is_char_break = FALSE;
+		  attrs[i].is_line_break = FALSE;
+		  attrs[i].is_mandatory_break = FALSE;
+
+		  i++;
+		  attrs[i].is_cursor_position = FALSE;
+		}
+	    }
+	  else
+	    {
+	      attrs[i].is_cursor_position = FALSE;
 	      attrs[i].is_char_break = FALSE;
 	      attrs[i].is_line_break = FALSE;
 	      attrs[i].is_mandatory_break = FALSE;
-            }
+	    }
 	}
     }
 }
diff --git a/modules/indic/indic-ot-class-tables.c b/modules/indic/indic-ot-class-tables.c
index fe664bc9..5c561765 100644
--- a/modules/indic/indic-ot-class-tables.c
+++ b/modules/indic/indic-ot-class-tables.c
@@ -245,7 +245,7 @@ static const IndicOTSplitMatra tamlSplitTable[] = {{0x0BC6, 0x0BBE}, {0x0BC7, 0x
 static const IndicOTSplitMatra teluSplitTable[] = {{0x0C46, 0x0C56}};
 
 static const IndicOTSplitMatra kndaSplitTable[] = {{0x0CBF, 0x0CD5}, {0x0CC6, 0x0CD5}, {0x0CC6, 0x0CD6}, {0x0CC6, 0x0CC2},
-                                      {0x0CC6, 0x0CC2, 0x0CD5}};
+				      {0x0CC6, 0x0CC2, 0x0CD5}};
 
 static const IndicOTSplitMatra mlymSplitTable[] = {{0x0D46, 0x0D3E}, {0x0D47, 0x0D3E}, {0x0D46, 0x0D57}};
 
@@ -279,7 +279,7 @@ static const IndicOTSplitMatra sinhSplitTable[] = {{0x0DD9, 0x0DCA}, {0x0DD9, 0x
 /* Add a little macro to compute lastChar based on size of the charClasses * table */
 #define INDIC_OT_CLASS_TABLE_DEFINE(name, firstChar, worstCaseExpansion, scriptFlags, charClasses, splitMatraTable) \
   const IndicOTClassTable name = {firstChar, firstChar + G_N_ELEMENTS (charClasses) - 1, \
-                                  worstCaseExpansion, scriptFlags, charClasses, splitMatraTable}
+				  worstCaseExpansion, scriptFlags, charClasses, splitMatraTable}
 INDIC_OT_CLASS_TABLE_DEFINE (deva_class_table, 0x0900, 2, DEVA_SCRIPT_FLAGS, devaCharClasses, NULL);
 INDIC_OT_CLASS_TABLE_DEFINE (beng_class_table, 0x0980, 3, BENG_SCRIPT_FLAGS, bengCharClasses, bengSplitTable);
 INDIC_OT_CLASS_TABLE_DEFINE (guru_class_table, 0x0A00, 2, GURU_SCRIPT_FLAGS, guruCharClasses, NULL);
@@ -427,15 +427,15 @@ gboolean indic_ot_has_below_base_form(const IndicOTClassTable *class_table, guni
 IndicOTCharClass indic_ot_get_char_class(const IndicOTClassTable *class_table, gunichar ch)
 {
     if (ch == C_SIGN_ZWJ) {
-        return CF_CONSONANT | CC_ZERO_WIDTH_MARK;
+	return CF_CONSONANT | CC_ZERO_WIDTH_MARK;
     }
 
     if (ch == C_SIGN_ZWNJ) {
-        return CC_ZERO_WIDTH_MARK;
+	return CC_ZERO_WIDTH_MARK;
     }
 
     if (ch < class_table->firstChar || ch > class_table->lastChar) {
-        return CC_RESERVED;
+	return CC_RESERVED;
     }
 
     return class_table->charClasses[ch - class_table->firstChar];
@@ -464,57 +464,57 @@ glong indic_ot_find_syllable(const IndicOTClassTable *class_table, const gunicha
     gint8 state = 0;
 
     while (cursor < char_count) {
-        IndicOTCharClass char_class = indic_ot_get_char_class(class_table, chars[cursor]);
+	IndicOTCharClass char_class = indic_ot_get_char_class(class_table, chars[cursor]);
 
-        state = stateTable[state][char_class & CF_CLASS_MASK];
+	state = stateTable[state][char_class & CF_CLASS_MASK];
 
-        /*for the components of split matra*/
+	/*for the components of split matra*/
 	if ((char_count >= cursor + 3) &&
 	    (chars[cursor] == 0x0DD9 && chars[cursor + 1] == 0x0DCF && chars[cursor + 2] == 0x0DCA)) {  /*for 3 split matra of Sinhala*/
 	    return cursor + 3;
 	}
 	else if ((char_count >= cursor + 3) &&
-	         (chars[cursor] == 0x0CC6 && chars[cursor + 1] == 0x0CC2 && chars[cursor + 2] == 0x0CD5)) {  /*for 3 split matra of Kannada*/
+		 (chars[cursor] == 0x0CC6 && chars[cursor + 1] == 0x0CC2 && chars[cursor + 2] == 0x0CD5)) {  /*for 3 split matra of Kannada*/
 	    return cursor + 3;
 	}
-        /*for 2 split matra*/
+	/*for 2 split matra*/
 	else if (char_count >= cursor + 2) {
-	        /*for Bengali*/
-            if ((chars[cursor] == 0x09C7 && chars[cursor + 1] == 0x09BE) ||
-	        (chars[cursor] == 0x09C7 && chars[cursor + 1] == 0x09D7) ||
-	        /*for Oriya*/
-	        (chars[cursor] == 0x0B47 && chars[cursor + 1] == 0x0B3E) ||
-	        (chars[cursor] == 0x0B47 && chars[cursor + 1] == 0x0B56) ||
-	        (chars[cursor] == 0x0B47 && chars[cursor + 1] == 0x0B57) ||
-	        /*for Tamil*/
-	        (chars[cursor] == 0x0BC6 && chars[cursor + 1] == 0x0BBE) ||
-	        (chars[cursor] == 0x0BC6 && chars[cursor + 1] == 0x0BD7) ||
-	        (chars[cursor] == 0x0BC7 && chars[cursor + 1] == 0x0BBE) ||
-	        /*for Malayalam*/
-	        (chars[cursor] == 0x0D46 && chars[cursor + 1] == 0x0D3E) ||
-	        (chars[cursor] == 0x0D46 && chars[cursor + 1] == 0x0D57) ||
-	        (chars[cursor] == 0x0D47 && chars[cursor + 1] == 0x0D3E) ||
-	        /*for Sinhala*/
-	        (chars[cursor] == 0x0DD9 && chars[cursor + 1] == 0x0DCA) ||
-	        (chars[cursor] == 0x0DD9 && chars[cursor + 1] == 0x0DCF) ||
-	        (chars[cursor] == 0x0DD9 && chars[cursor + 1] == 0x0DDF) ||
-	        (chars[cursor] == 0x0DDC && chars[cursor + 1] == 0x0DCA) ||
-	        /*for Telugu*/
-	        (chars[cursor] == 0x0C46 && chars[cursor + 1] == 0x0C56) ||
-	        /*for Kannada*/
-	        (chars[cursor] == 0x0CBF && chars[cursor + 1] == 0x0CD5) ||
-	        (chars[cursor] == 0x0CC6 && chars[cursor + 1] == 0x0CD5) ||
-	        (chars[cursor] == 0x0CC6 && chars[cursor + 1] == 0x0CD6) ||
-	        (chars[cursor] == 0x0CC6 && chars[cursor + 1] == 0x0CC2) ||
-	        (chars[cursor] == 0x0CCA && chars[cursor + 1] == 0x0CD5))
+		/*for Bengali*/
+	    if ((chars[cursor] == 0x09C7 && chars[cursor + 1] == 0x09BE) ||
+		(chars[cursor] == 0x09C7 && chars[cursor + 1] == 0x09D7) ||
+		/*for Oriya*/
+		(chars[cursor] == 0x0B47 && chars[cursor + 1] == 0x0B3E) ||
+		(chars[cursor] == 0x0B47 && chars[cursor + 1] == 0x0B56) ||
+		(chars[cursor] == 0x0B47 && chars[cursor + 1] == 0x0B57) ||
+		/*for Tamil*/
+		(chars[cursor] == 0x0BC6 && chars[cursor + 1] == 0x0BBE) ||
+		(chars[cursor] == 0x0BC6 && chars[cursor + 1] == 0x0BD7) ||
+		(chars[cursor] == 0x0BC7 && chars[cursor + 1] == 0x0BBE) ||
+		/*for Malayalam*/
+		(chars[cursor] == 0x0D46 && chars[cursor + 1] == 0x0D3E) ||
+		(chars[cursor] == 0x0D46 && chars[cursor + 1] == 0x0D57) ||
+		(chars[cursor] == 0x0D47 && chars[cursor + 1] == 0x0D3E) ||
+		/*for Sinhala*/
+		(chars[cursor] == 0x0DD9 && chars[cursor + 1] == 0x0DCA) ||
+		(chars[cursor] == 0x0DD9 && chars[cursor + 1] == 0x0DCF) ||
+		(chars[cursor] == 0x0DD9 && chars[cursor + 1] == 0x0DDF) ||
+		(chars[cursor] == 0x0DDC && chars[cursor + 1] == 0x0DCA) ||
+		/*for Telugu*/
+		(chars[cursor] == 0x0C46 && chars[cursor + 1] == 0x0C56) ||
+		/*for Kannada*/
+		(chars[cursor] == 0x0CBF && chars[cursor + 1] == 0x0CD5) ||
+		(chars[cursor] == 0x0CC6 && chars[cursor + 1] == 0x0CD5) ||
+		(chars[cursor] == 0x0CC6 && chars[cursor + 1] == 0x0CD6) ||
+		(chars[cursor] == 0x0CC6 && chars[cursor + 1] == 0x0CC2) ||
+		(chars[cursor] == 0x0CCA && chars[cursor + 1] == 0x0CD5))
 		    return cursor + 2;
 	}
 
-        if (state < 0) {
-            break;
-        }
+	if (state < 0) {
+	    break;
+	}
 
-        cursor += 1;
+	cursor += 1;
     }
 
     return cursor;
diff --git a/modules/indic/indic-ot.c b/modules/indic/indic-ot.c
index 3b392674..477c53e9 100644
--- a/modules/indic/indic-ot.c
+++ b/modules/indic/indic-ot.c
@@ -89,17 +89,17 @@ static void saveMatra(Output *output, gunichar matra, IndicOTCharClass matraClas
 {
     /* FIXME: check if already set, or if not a matra... */
     if (IS_M_PRE(matraClass)) {
-        output->fMpre = matra;
+	output->fMpre = matra;
     } else if (IS_M_BELOW(matraClass)) {
-        output->fMbelow = matra;
+	output->fMbelow = matra;
     } else if (IS_M_ABOVE(matraClass)) {
-        output->fMabove = matra;
+	output->fMabove = matra;
     } else if (IS_M_POST(matraClass)) {
-        output->fMpost = matra;
+	output->fMpost = matra;
     } else if (IS_LENGTH_MARK(matraClass)) {
-        output->fLengthMark = matra;
+	output->fLengthMark = matra;
     } else if (IS_AL_LAKUNA(matraClass)) {
-        output->fAlLakuna = matra;
+	output->fAlLakuna = matra;
     }
 }
 
@@ -117,19 +117,19 @@ static gboolean noteMatra(Output *output, const IndicOTClassTable *classTable, g
     IndicOTCharClass matraClass = indic_ot_get_char_class(classTable, matra);
 
     if (IS_MATRA(matraClass)) {
-        if (IS_SPLIT_MATRA(matraClass)) {
-            const IndicOTSplitMatra *splitMatra = indic_ot_get_split_matra(classTable, matraClass);
-            int i;
+	if (IS_SPLIT_MATRA(matraClass)) {
+	    const IndicOTSplitMatra *splitMatra = indic_ot_get_split_matra(classTable, matraClass);
+	    int i;
 
-            for (i = 0; i < 3 && (*splitMatra)[i] != 0; i += 1) {
-                gunichar piece = (*splitMatra)[i];
-                IndicOTCharClass pieceClass = indic_ot_get_char_class(classTable, piece);
+	    for (i = 0; i < 3 && (*splitMatra)[i] != 0; i += 1) {
+		gunichar piece = (*splitMatra)[i];
+		IndicOTCharClass pieceClass = indic_ot_get_char_class(classTable, piece);
 
-                saveMatra(output, piece, pieceClass);
-            }
-        } else {
-            saveMatra(output, matra, matraClass);
-        }
+		saveMatra(output, piece, pieceClass);
+	    }
+	} else {
+	    saveMatra(output, matra, matraClass);
+	}
 
 	return TRUE;
     } else
@@ -139,7 +139,7 @@ static gboolean noteMatra(Output *output, const IndicOTClassTable *classTable, g
 static void noteBaseConsonant(Output *output)
 {
     if (output->fMPreFixups && output->fMPreOutIndex >= 0) {
-        indic_mprefixups_add(output->fMPreFixups, output->fOutIndex, output->fMPreOutIndex);
+	indic_mprefixups_add(output->fMPreFixups, output->fOutIndex, output->fMPreOutIndex);
     }
 }
 
@@ -167,9 +167,9 @@ static void swapChars(Output *output, int a, int b)
 static void writeChar(Output *output, gunichar ch, guint32 charIndex, gulong charTags)
 {
     if (output->fOutChars != NULL) {
-        output->fOutChars[output->fOutIndex]    = ch;
-        output->fCharIndices[output->fOutIndex] = output->fOriginalOffsets[charIndex];
-        output->fCharTags[output->fOutIndex]    = charTags;
+	output->fOutChars[output->fOutIndex]    = ch;
+	output->fCharIndices[output->fOutIndex] = output->fOriginalOffsets[charIndex];
+	output->fCharTags[output->fOutIndex]    = charTags;
     }
 
     output->fOutIndex += 1;
@@ -178,47 +178,47 @@ static void writeChar(Output *output, gunichar ch, guint32 charIndex, gulong cha
 static void writeMpre(Output *output)
 {
     if (output->fMpre != 0) {
-        gulong tags = output->fMatraTags;
+	gulong tags = output->fMatraTags;
 	if (output->fMatraWordStart)
 	    tags &= ~init;
 
-        output->fMPreOutIndex = output->fOutIndex;
-        writeChar(output, output->fMpre, output->fMatraIndex, tags);
+	output->fMPreOutIndex = output->fOutIndex;
+	writeChar(output, output->fMpre, output->fMatraIndex, tags);
     }
 }
 
 static void writeMbelow(Output *output)
 {
     if (output->fMbelow != 0) {
-        writeChar(output, output->fMbelow, output->fMatraIndex, output->fMatraTags);
+	writeChar(output, output->fMbelow, output->fMatraIndex, output->fMatraTags);
     }
 }
 
 static void writeMabove(Output *output)
 {
     if (output->fMabove != 0) {
-        writeChar(output, output->fMabove, output->fMatraIndex, output->fMatraTags);
+	writeChar(output, output->fMabove, output->fMatraIndex, output->fMatraTags);
     }
 }
 
 static void writeMpost(Output *output)
 {
     if (output->fMpost != 0) {
-        writeChar(output, output->fMpost, output->fMatraIndex, output->fMatraTags);
+	writeChar(output, output->fMpost, output->fMatraIndex, output->fMatraTags);
     }
 }
 
 static void writeLengthMark(Output *output)
 {
     if (output->fLengthMark != 0) {
-        writeChar(output, output->fLengthMark, output->fMatraIndex, output->fMatraTags);
+	writeChar(output, output->fLengthMark, output->fMatraIndex, output->fMatraTags);
     }
 }
 
 static void writeAlLakuna(Output *output)
 {
     if (output->fAlLakuna != 0) {
-        writeChar(output, output->fAlLakuna, output->fMatraIndex, output->fMatraTags);
+	writeChar(output, output->fAlLakuna, output->fMatraIndex, output->fMatraTags);
     }
 }
 
@@ -244,87 +244,87 @@ glong indic_ot_reorder(const gunichar *chars, const glong *utf8_offsets, glong c
     initOutput(&output, utf8_offsets, out_chars, char_indices, char_tags, mpreFixups);
 
     while (prev < char_count) {
-        glong syllable = indic_ot_find_syllable(class_table, chars, prev, char_count);
-        glong matra, vmabove, vmpost = syllable;
+	glong syllable = indic_ot_find_syllable(class_table, chars, prev, char_count);
+	glong matra, vmabove, vmpost = syllable;
 
-        while (vmpost > prev && indic_ot_is_vm_post(class_table, chars[vmpost - 1])) {
-            vmpost -= 1;
-        }
+	while (vmpost > prev && indic_ot_is_vm_post(class_table, chars[vmpost - 1])) {
+	    vmpost -= 1;
+	}
 
-        vmabove = vmpost;
-        while (vmabove > prev && indic_ot_is_vm_above(class_table, chars[vmabove - 1])) {
-            vmabove -= 1;
-        }
+	vmabove = vmpost;
+	while (vmabove > prev && indic_ot_is_vm_above(class_table, chars[vmabove - 1])) {
+	    vmabove -= 1;
+	}
 
-        matra = vmabove - 1;
+	matra = vmabove - 1;
 	initMatra(&output, prev, blwf_p, !last_in_word);
-        while (noteMatra(&output, class_table, chars[matra]) &&
-               matra != prev)
-            matra--;
+	while (noteMatra(&output, class_table, chars[matra]) &&
+	       matra != prev)
+	    matra--;
 
 	last_in_word = TRUE;
-        switch (indic_ot_get_char_class(class_table, chars[prev]) & CF_CLASS_MASK) {
-        case CC_RESERVED:
+	switch (indic_ot_get_char_class(class_table, chars[prev]) & CF_CLASS_MASK) {
+	case CC_RESERVED:
   	    last_in_word = FALSE;
 	    /* Fall through */
-        case CC_INDEPENDENT_VOWEL:
-        case CC_ZERO_WIDTH_MARK:
-            for (i = prev; i < syllable; i += 1) {
-                writeChar(&output, chars[i], /*i*/ prev, blwf_p);
-            }
-
-            break;
-
-        case CC_MODIFYING_MARK_ABOVE:
-        case CC_MODIFYING_MARK_POST:
-        case CC_NUKTA:
-        case CC_VIRAMA:
-        case CC_AL_LAKUNA:
-            writeChar(&output, C_DOTTED_CIRCLE, prev, blwf_p);
-            writeChar(&output, chars[prev], prev, blwf_p);
-            break;
-
-        case CC_DEPENDENT_VOWEL:
-            writeMpre(&output);
-            writeChar(&output, C_DOTTED_CIRCLE, prev, blwf_p);
-            writeMbelow(&output);
-            writeMabove(&output);
-            writeMpost(&output);
-            writeLengthMark(&output);
-            writeAlLakuna(&output);
-            break;
-
-        case CC_CONSONANT:
-        case CC_CONSONANT_WITH_NUKTA:
-        {
-            guint32 length = vmabove - prev;
-            glong lastConsonant = vmabove - 1;
-            glong baseLimit = prev;
-            glong baseConsonant, postBase, postBaseLimit;
+	case CC_INDEPENDENT_VOWEL:
+	case CC_ZERO_WIDTH_MARK:
+	    for (i = prev; i < syllable; i += 1) {
+		writeChar(&output, chars[i], /*i*/ prev, blwf_p);
+	    }
+
+	    break;
+
+	case CC_MODIFYING_MARK_ABOVE:
+	case CC_MODIFYING_MARK_POST:
+	case CC_NUKTA:
+	case CC_VIRAMA:
+	case CC_AL_LAKUNA:
+	    writeChar(&output, C_DOTTED_CIRCLE, prev, blwf_p);
+	    writeChar(&output, chars[prev], prev, blwf_p);
+	    break;
+
+	case CC_DEPENDENT_VOWEL:
+	    writeMpre(&output);
+	    writeChar(&output, C_DOTTED_CIRCLE, prev, blwf_p);
+	    writeMbelow(&output);
+	    writeMabove(&output);
+	    writeMpost(&output);
+	    writeLengthMark(&output);
+	    writeAlLakuna(&output);
+	    break;
+
+	case CC_CONSONANT:
+	case CC_CONSONANT_WITH_NUKTA:
+	{
+	    guint32 length = vmabove - prev;
+	    glong lastConsonant = vmabove - 1;
+	    glong baseLimit = prev;
+	    glong baseConsonant, postBase, postBaseLimit;
 	    gboolean seenVattu, seenBelowBaseForm, supressVattu;
 	    glong bcSpan;
 
-            /* Check for REPH at front of syllable */
-            if (length > 2 && indic_ot_is_reph(class_table, chars[prev]) && indic_ot_is_virama(class_table, chars[prev + 1])) {
-                baseLimit += 2;
-
-                /* Check for eyelash RA, if the script supports it */
-                if ((class_table->scriptFlags & SF_EYELASH_RA) != 0 &&
-                    chars[baseLimit] == C_SIGN_ZWJ) {
-                    if (length > 3) {
-                        baseLimit += 1;
-                    } else {
-                        baseLimit -= 2;
-                    }
-                }
-            }
+	    /* Check for REPH at front of syllable */
+	    if (length > 2 && indic_ot_is_reph(class_table, chars[prev]) && indic_ot_is_virama(class_table, chars[prev + 1])) {
+		baseLimit += 2;
+
+		/* Check for eyelash RA, if the script supports it */
+		if ((class_table->scriptFlags & SF_EYELASH_RA) != 0 &&
+		    chars[baseLimit] == C_SIGN_ZWJ) {
+		    if (length > 3) {
+			baseLimit += 1;
+		    } else {
+			baseLimit -= 2;
+		    }
+		}
+	    }
 
-            while (lastConsonant > baseLimit && !indic_ot_is_consonant(class_table, chars[lastConsonant])) {
-                lastConsonant -= 1;
-            }
+	    while (lastConsonant > baseLimit && !indic_ot_is_consonant(class_table, chars[lastConsonant])) {
+		lastConsonant -= 1;
+	    }
 
-            baseConsonant = lastConsonant;
-            postBase = lastConsonant + 1;
+	    baseConsonant = lastConsonant;
+	    postBase = lastConsonant + 1;
 
 	    postBaseLimit = class_table->scriptFlags & SF_POST_BASE_LIMIT_MASK;
 	    seenVattu = false;
@@ -412,7 +412,7 @@ glong indic_ot_reorder(const gunichar *chars, const glong *utf8_offsets, glong c
 		}
 	    }
 
-            /* note the base consonant for post-GSUB fixups */
+	    /* note the base consonant for post-GSUB fixups */
 	    noteBaseConsonant(&output);
 
 	    /* write base consonant */
@@ -420,7 +420,7 @@ glong indic_ot_reorder(const gunichar *chars, const glong *utf8_offsets, glong c
 		writeChar(&output, chars[i], /*i*/ prev, nukt_p);
 	    }
 
-            /* for the special conjuction of Cons+0x0d4d+0x0d31 or Cons+0x0d4d+0x0d30 of Malayalam */
+	    /* for the special conjuction of Cons+0x0d4d+0x0d31 or Cons+0x0d4d+0x0d30 of Malayalam */
 	    if ((baseConsonant - 2 >= 0) &&
 		(chars[baseConsonant - 1] == 0x0d4d) &&
 		((chars[baseConsonant] == 0x0d31) ||
@@ -429,25 +429,25 @@ glong indic_ot_reorder(const gunichar *chars, const glong *utf8_offsets, glong c
 		 (chars[baseConsonant - 2] <= 0x0d39)))  {
       		swapChars (&output, -1, -3);
 
-                if (mpreFixups) {
+		if (mpreFixups) {
 		    if (mpreFixups->fFixupCount > 0) {
-                        mpreFixups->fFixupCount--;
+			mpreFixups->fFixupCount--;
 		    }
-                }
+		}
 	    }
 
 	    if ((class_table->scriptFlags & SF_MATRAS_AFTER_BASE) != 0) {
 		gboolean is_for_0C48 = FALSE;
-	        if (output.fOutChars != NULL) {  /*for 0x0C48 of Telugu*/
+		if (output.fOutChars != NULL) {  /*for 0x0C48 of Telugu*/
 		    int t;
 		    for (t = prev; t < syllable; t++) {
-		        if (chars[t] == 0x0C48) {
+			if (chars[t] == 0x0C48) {
 			    writeMabove(&output);
 			    writeMbelow(&output);
 			    writeMpost(&output);
 
-                            is_for_0C48 = TRUE;
-                            break;
+			    is_for_0C48 = TRUE;
+			    break;
 			}
 		    }
 		}
@@ -532,15 +532,15 @@ glong indic_ot_reorder(const gunichar *chars, const glong *utf8_offsets, glong c
 		writeChar(&output, chars[i], /*i*/ prev, blwf_p);
 	    }
 
-            break;
-        }
+	    break;
+	}
 
-        default:
-            break;
-        }
+	default:
+	    break;
+	}
 
 
-        prev = syllable;
+	prev = syllable;
     }
 
     if (outMPreFixups) {
diff --git a/modules/khmer/khmer-fc.c b/modules/khmer/khmer-fc.c
index 3a92b05d..563a0cf8 100644
--- a/modules/khmer/khmer-fc.c
+++ b/modules/khmer/khmer-fc.c
@@ -315,7 +315,7 @@ static const gint8 khmerStateTable[][CC_COUNT] =
   {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, /*  1 - exit state (or sign to the right of the syllable) */
   {-1, -1, -1, -1,  3,  4,  5,  6, 16, 17,  1, -1}, /*  2 - Base consonant */
   {-1, -1, -1, -1, -1,  4, -1, -1, 16, -1, -1, -1}, /*  3 - First ZWNJ before a register shifter
-                                                            It can only be followed by a shifter or a vowel */
+							    It can only be followed by a shifter or a vowel */
   {-1, -1, -1, -1, 15, -1, -1,  6, 16, 17,  1, 14}, /*  4 - First register shifter */
   {-1, -1, -1, -1, -1, -1, -1, -1, 20, -1,  1, -1}, /*  5 - Robat */
   {-1,  7,  8,  9, -1, -1, -1, -1, -1, -1, -1, -1}, /*  6 - First Coeng */
@@ -417,35 +417,35 @@ find_syllable (const gunichar *chars,
 
 static void
 maybe_add_GSUB_feature (PangoOTRuleset *ruleset,
-                        PangoOTInfo    *info,
-                        guint           script_index,
-                        PangoOTTag      tag,
-                        gulong          property_bit)
+			PangoOTInfo    *info,
+			guint           script_index,
+			PangoOTTag      tag,
+			gulong          property_bit)
 {
   guint feature_index;
 
   /* 0xffff == default language system */
   if (pango_ot_info_find_feature (info, PANGO_OT_TABLE_GSUB,
-                                  tag, script_index, 0xffff, &feature_index))
+				  tag, script_index, 0xffff, &feature_index))
     pango_ot_ruleset_add_feature (ruleset, PANGO_OT_TABLE_GSUB, feature_index,
-                                  property_bit);
+				  property_bit);
 }
 
 
 static void
 maybe_add_GPOS_feature (PangoOTRuleset *ruleset,
-                        PangoOTInfo    *info,
-                        guint           script_index,
-                        PangoOTTag      tag,
-                        gulong          property_bit)
+			PangoOTInfo    *info,
+			guint           script_index,
+			PangoOTTag      tag,
+			gulong          property_bit)
 {
   guint feature_index;
 
   /* 0xffff == default language system */
   if (pango_ot_info_find_feature (info, PANGO_OT_TABLE_GPOS,
-                                  tag, script_index, 0xffff, &feature_index))
+				  tag, script_index, 0xffff, &feature_index))
     pango_ot_ruleset_add_feature (ruleset, PANGO_OT_TABLE_GPOS, feature_index,
-                                  property_bit);
+				  property_bit);
 }
 
 
@@ -473,31 +473,31 @@ get_ruleset (FT_Face face)
       ruleset = pango_ot_ruleset_new (info);
 
       if (pango_ot_info_find_script (info, PANGO_OT_TABLE_GSUB,
-                                      khmer_tag, &script_index))
-        {
-          maybe_add_GSUB_feature (ruleset, info, script_index, FT_MAKE_TAG ('p','r','e','f'), pref);
-          maybe_add_GSUB_feature (ruleset, info, script_index, FT_MAKE_TAG ('b','l','w','f'), blwf);
-          maybe_add_GSUB_feature (ruleset, info, script_index, FT_MAKE_TAG ('a','b','v','f'), abvf);
-          maybe_add_GSUB_feature (ruleset, info, script_index, FT_MAKE_TAG ('p','s','t','f'), pstf);
-
-          maybe_add_GSUB_feature (ruleset, info, script_index, FT_MAKE_TAG ('p','r','e','s'), pres);
-          maybe_add_GSUB_feature (ruleset, info, script_index, FT_MAKE_TAG ('b','l','w','s'), blws);
-          maybe_add_GSUB_feature (ruleset, info, script_index, FT_MAKE_TAG ('a','b','v','s'), abvs);
-          maybe_add_GSUB_feature (ruleset, info, script_index, FT_MAKE_TAG ('p','s','t','s'), psts);
-          maybe_add_GSUB_feature (ruleset, info, script_index, FT_MAKE_TAG ('c','l','i','g'), clig);
-        }
+				      khmer_tag, &script_index))
+	{
+	  maybe_add_GSUB_feature (ruleset, info, script_index, FT_MAKE_TAG ('p','r','e','f'), pref);
+	  maybe_add_GSUB_feature (ruleset, info, script_index, FT_MAKE_TAG ('b','l','w','f'), blwf);
+	  maybe_add_GSUB_feature (ruleset, info, script_index, FT_MAKE_TAG ('a','b','v','f'), abvf);
+	  maybe_add_GSUB_feature (ruleset, info, script_index, FT_MAKE_TAG ('p','s','t','f'), pstf);
+
+	  maybe_add_GSUB_feature (ruleset, info, script_index, FT_MAKE_TAG ('p','r','e','s'), pres);
+	  maybe_add_GSUB_feature (ruleset, info, script_index, FT_MAKE_TAG ('b','l','w','s'), blws);
+	  maybe_add_GSUB_feature (ruleset, info, script_index, FT_MAKE_TAG ('a','b','v','s'), abvs);
+	  maybe_add_GSUB_feature (ruleset, info, script_index, FT_MAKE_TAG ('p','s','t','s'), psts);
+	  maybe_add_GSUB_feature (ruleset, info, script_index, FT_MAKE_TAG ('c','l','i','g'), clig);
+	}
 
       if (pango_ot_info_find_script (info, PANGO_OT_TABLE_GPOS,
-                                      khmer_tag, &script_index))
-        {
-          maybe_add_GPOS_feature (ruleset, info, script_index, FT_MAKE_TAG ('d','i','s','t'), dist);
-          maybe_add_GPOS_feature (ruleset, info, script_index, FT_MAKE_TAG ('b','l','w','m'), blwm);
-          maybe_add_GPOS_feature (ruleset, info, script_index, FT_MAKE_TAG ('a','b','v','m'), abvm);
-          maybe_add_GPOS_feature (ruleset, info, script_index, FT_MAKE_TAG ('m','k','m','k'), mkmk);
-        }
+				      khmer_tag, &script_index))
+	{
+	  maybe_add_GPOS_feature (ruleset, info, script_index, FT_MAKE_TAG ('d','i','s','t'), dist);
+	  maybe_add_GPOS_feature (ruleset, info, script_index, FT_MAKE_TAG ('b','l','w','m'), blwm);
+	  maybe_add_GPOS_feature (ruleset, info, script_index, FT_MAKE_TAG ('a','b','v','m'), abvm);
+	  maybe_add_GPOS_feature (ruleset, info, script_index, FT_MAKE_TAG ('m','k','m','k'), mkmk);
+	}
 
       g_object_set_qdata_full (G_OBJECT (info), ruleset_quark, ruleset,
-                                (GDestroyNotify)g_object_unref);
+				(GDestroyNotify)g_object_unref);
     }
 
   return ruleset;
@@ -516,11 +516,11 @@ get_index (PangoFcFont *fc_font, gunichar wc)
 
 static void
 khmer_engine_shape (PangoEngineShape *engine,
-                    PangoFont        *font,
-                    const char       *text,
-                    int               length,
-                    const PangoAnalysis *analysis,
-                    PangoGlyphString *glyphs)
+		    PangoFont        *font,
+		    const char       *text,
+		    int               length,
+		    const PangoAnalysis *analysis,
+		    PangoGlyphString *glyphs)
 {
   PangoFcFont *fc_font;
   FT_Face face;
@@ -563,43 +563,43 @@ khmer_engine_shape (PangoEngineShape *engine,
       syllable = find_syllable (wcs, cursor, n_chars);
 
       for (i = cursor; i < syllable; i += 1)
-        {
-          charClass = get_char_class (wcs[i]);
-
-          /* if a split vowel, write the pre part. In Khmer the pre part
-           * is the same for all split vowels, same glyph as pre vowel C_VOWEL_E
-           */
-          if (charClass & CF_SPLIT_VOWEL)
-            {
-              pango_ot_buffer_add_glyph (buffer, get_index (fc_font, C_VOWEL_E), pref_p, p - text);
-              break; /* there can be only one vowel */
-            }
-
-          /* if a vowel with pos before write it out */
-          if (charClass & CF_POS_BEFORE)
-            {
-              pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), pref_p, p - text);
-              break; /* there can be only one vowel */
-            }
-
-          /* look for coeng + ro and remember position
-           * works because coeng + ro is always in front of a vowel (if there is a vowel)
-           * and because CC_CONSONANT2 is enough to identify it, as it is the only consonant
-           * with this flag
-           */
-          if ((charClass & CF_COENG) && (i + 1 < syllable) &&
-             ((get_char_class (wcs[i + 1]) & CF_CLASS_MASK) == CC_CONSONANT2))
-            {
-              coengRo = i;
-            }
-        }
+	{
+	  charClass = get_char_class (wcs[i]);
+
+	  /* if a split vowel, write the pre part. In Khmer the pre part
+	   * is the same for all split vowels, same glyph as pre vowel C_VOWEL_E
+	   */
+	  if (charClass & CF_SPLIT_VOWEL)
+	    {
+	      pango_ot_buffer_add_glyph (buffer, get_index (fc_font, C_VOWEL_E), pref_p, p - text);
+	      break; /* there can be only one vowel */
+	    }
+
+	  /* if a vowel with pos before write it out */
+	  if (charClass & CF_POS_BEFORE)
+	    {
+	      pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), pref_p, p - text);
+	      break; /* there can be only one vowel */
+	    }
+
+	  /* look for coeng + ro and remember position
+	   * works because coeng + ro is always in front of a vowel (if there is a vowel)
+	   * and because CC_CONSONANT2 is enough to identify it, as it is the only consonant
+	   * with this flag
+	   */
+	  if ((charClass & CF_COENG) && (i + 1 < syllable) &&
+	     ((get_char_class (wcs[i + 1]) & CF_CLASS_MASK) == CC_CONSONANT2))
+	    {
+	      coengRo = i;
+	    }
+	}
 
       /* write coeng + ro if found  */
       if (coengRo > -1)
-        {
-          pango_ot_buffer_add_glyph (buffer, get_index (fc_font, C_COENG), pref_p, p - text);
-          pango_ot_buffer_add_glyph (buffer, get_index (fc_font, C_RO), pref_p, p - text);
-        }
+	{
+	  pango_ot_buffer_add_glyph (buffer, get_index (fc_font, C_COENG), pref_p, p - text);
+	  pango_ot_buffer_add_glyph (buffer, get_index (fc_font, C_RO), pref_p, p - text);
+	}
 
       /* shall we add a dotted circle?
       * If in the position in which the base should be (first char in the string) there is
@@ -607,51 +607,51 @@ khmer_engine_shape (PangoEngineShape *engine,
       * then write a dotted circle
       */
       if (get_char_class (wcs[cursor]) & CF_DOTTED_CIRCLE)
-        {
-          pango_ot_buffer_add_glyph (buffer, get_index (fc_font, C_DOTTED_CIRCLE), default_p, p - text);
-        }
+	{
+	  pango_ot_buffer_add_glyph (buffer, get_index (fc_font, C_DOTTED_CIRCLE), default_p, p - text);
+	}
 
       /* copy what is left to the output, skipping before vowels and
       * coeng Ro if they are present
       */
       for (i = cursor; i < syllable; i += 1)
-        {
-          charClass = get_char_class (wcs[i]);
-
-          /* skip a before vowel, it was already processed */
-          if (charClass & CF_POS_BEFORE)
-            {
-              p = g_utf8_next_char (p);
-              continue;
-            }
-
-          /* skip coeng + ro, it was already processed */
-          if (i == coengRo)
-            {
-              p = g_utf8_next_char (p);
-              i += 1;
-              p = g_utf8_next_char (p);
-              continue;
-            }
-
-          switch (charClass & CF_POS_MASK)
-            {
-              case CF_POS_ABOVE :
+	{
+	  charClass = get_char_class (wcs[i]);
+
+	  /* skip a before vowel, it was already processed */
+	  if (charClass & CF_POS_BEFORE)
+	    {
+	      p = g_utf8_next_char (p);
+	      continue;
+	    }
+
+	  /* skip coeng + ro, it was already processed */
+	  if (i == coengRo)
+	    {
+	      p = g_utf8_next_char (p);
+	      i += 1;
+	      p = g_utf8_next_char (p);
+	      continue;
+	    }
+
+	  switch (charClass & CF_POS_MASK)
+	    {
+	      case CF_POS_ABOVE :
 		pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), abvf_p, p - text);
 		break;
 
-              case CF_POS_AFTER :
+	      case CF_POS_AFTER :
 		pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), pstf_p, p - text);
 		break;
 
-              case CF_POS_BELOW :
+	      case CF_POS_BELOW :
 		pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), blwf_p, p - text);
 		break;
 
-              default:
-                  /* assign the correct flags to a coeng consonant
-                  * Consonants of type 3 are taged as Post forms and those type 1 as below forms
-                  */
+	      default:
+		  /* assign the correct flags to a coeng consonant
+		  * Consonants of type 3 are taged as Post forms and those type 1 as below forms
+		  */
 		if ((charClass & CF_COENG) && i + 1 < syllable)
 		  {
 		    if ((get_char_class (wcs[i + 1]) & CF_CLASS_MASK) == CC_CONSONANT3)
@@ -672,47 +672,47 @@ khmer_engine_shape (PangoEngineShape *engine,
 		      }
 		  }
 
-                  /* if a shifter is followed by an above vowel change the shifter to below form,
-                  * an above vowel can have two possible positions i + 1 or i + 3
-                  * (position i+1 corresponds to unicode 3, position i+3 to Unicode 4)
-                  * and there is an extra rule for C_VOWEL_AA + C_SIGN_NIKAHIT also for two
-                  * different positions, right after the shifter or after a vowel (Unicode 4)
-                  */
-                  if ((charClass & CF_SHIFTER) && (i + 1 < syllable))
-                    {
-                      if (get_char_class (wcs[i + 1]) & CF_ABOVE_VOWEL)
-                        {
-                          pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), blwf_p, p - text);
-                          break;
-                        }
-                      if (i + 2 < syllable &&
-                          (wcs[i + 1] == C_VOWEL_AA) &&
-                          (wcs[i + 2] == C_SIGN_NIKAHIT) )
-                        {
-                          pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), blwf_p, p - text);
-                          break;
-                        }
-                      if (i + 3 < syllable && (get_char_class (wcs[i + 3]) & CF_ABOVE_VOWEL) )
-                        {
-                          pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), blwf_p, p - text);
-                          break;
-                        }
-                      if (i + 4 < syllable &&
-                          (wcs[i + 3] == C_VOWEL_AA) &&
-                          (wcs[i + 4] == C_SIGN_NIKAHIT) )
-                        {
-                          pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), blwf_p, p - text);
-                          break;
-                        }
-
-                    }
-
-                  /* default - any other characters  */
-                  pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), default_p, p - text);
-                  break;
-            } /* switch */
-          p = g_utf8_next_char (p);
-        } /* for */
+		  /* if a shifter is followed by an above vowel change the shifter to below form,
+		  * an above vowel can have two possible positions i + 1 or i + 3
+		  * (position i+1 corresponds to unicode 3, position i+3 to Unicode 4)
+		  * and there is an extra rule for C_VOWEL_AA + C_SIGN_NIKAHIT also for two
+		  * different positions, right after the shifter or after a vowel (Unicode 4)
+		  */
+		  if ((charClass & CF_SHIFTER) && (i + 1 < syllable))
+		    {
+		      if (get_char_class (wcs[i + 1]) & CF_ABOVE_VOWEL)
+			{
+			  pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), blwf_p, p - text);
+			  break;
+			}
+		      if (i + 2 < syllable &&
+			  (wcs[i + 1] == C_VOWEL_AA) &&
+			  (wcs[i + 2] == C_SIGN_NIKAHIT) )
+			{
+			  pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), blwf_p, p - text);
+			  break;
+			}
+		      if (i + 3 < syllable && (get_char_class (wcs[i + 3]) & CF_ABOVE_VOWEL) )
+			{
+			  pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), blwf_p, p - text);
+			  break;
+			}
+		      if (i + 4 < syllable &&
+			  (wcs[i + 3] == C_VOWEL_AA) &&
+			  (wcs[i + 4] == C_SIGN_NIKAHIT) )
+			{
+			  pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), blwf_p, p - text);
+			  break;
+			}
+
+		    }
+
+		  /* default - any other characters  */
+		  pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), default_p, p - text);
+		  break;
+	    } /* switch */
+	  p = g_utf8_next_char (p);
+	} /* for */
 
       cursor = syllable; /* move the pointer to the start of next syllable */
     } /* while */
@@ -741,7 +741,7 @@ khmer_engine_fc_class_init (PangoEngineShapeClass *class)
 }
 
 PANGO_ENGINE_SHAPE_DEFINE_TYPE (KhmerEngineFc, khmer_engine_fc,
-                                khmer_engine_fc_class_init, NULL)
+				khmer_engine_fc_class_init, NULL)
 
 
 void
@@ -759,7 +759,7 @@ PANGO_MODULE_ENTRY(exit) (void)
 
 void
 PANGO_MODULE_ENTRY(list) (PangoEngineInfo **engines,
-                          int              *n_engines)
+			  int              *n_engines)
 {
   *engines = script_engines;
   *n_engines = G_N_ELEMENTS (script_engines);
diff --git a/modules/syriac/syriac-ot.c b/modules/syriac/syriac-ot.c
index 4650c9da..abbe856b 100644
--- a/modules/syriac/syriac-ot.c
+++ b/modules/syriac/syriac-ot.c
@@ -77,12 +77,12 @@ Get_Joining_Class (gunichar*   string,
   while (1)
     {
       if (pos == 0 && direction < 0)
-        return none;
+	return none;
 
       pos += direction;
 
       if (pos >= length)
-        return none;
+	return none;
 
       if (string[pos] < 0x0700 ||
 	  string[pos] >= 0x074F)
@@ -93,10 +93,10 @@ Get_Joining_Class (gunichar*   string,
 	    return none;
 	}
       else
-        j =  syriac[string[pos] - 0x0700];
+	j =  syriac[string[pos] - 0x0700];
 
       if (!direction || j != transparent)
-        return j;
+	return j;
     }
 }
 
@@ -230,57 +230,57 @@ syriac_assign_properties (gunichar    *string,
       /* R1 */
 
       if (current == transparent)
-        {
+	{
 	  properties[i] |= isolated_p;
 	  continue;
-        }
+	}
 
       /* R2 */
 
       if (string[i] == 0x0722 ||
 	  string[i] == 0x071F)
-        if (previous == causing ||
-            previous == right)
-          if (!(next == causing ||
+	if (previous == causing ||
+	    previous == right)
+	  if (!(next == causing ||
 		next == right ||
 		next == dual))
-          {
-            properties[i] |= isolated_p;
-            continue;
-          }
+	  {
+	    properties[i] |= isolated_p;
+	    continue;
+	  }
 
       /* R3 */
 
       if (string[i] == 0x0710)
-        if (previous == causing ||
-            previous == right)
-          if (!(string[i - 1] == 0x0715 ||
+	if (previous == causing ||
+	    previous == right)
+	  if (!(string[i - 1] == 0x0715 ||
 		string[i - 1] == 0x0716 ||
 		string[i - 1] == 0x072A))
-          {
-            properties[i] |= final2_p;
-            continue;
-          }
+	  {
+	    properties[i] |= final2_p;
+	    continue;
+	  }
 
       /* R4 */
 
       if (string[i] == 0x0710)
-        if (previous == causing ||
-            previous == right)
-         if (string[i - 1] == 0x0715 ||
-              string[i - 1] == 0x0716 ||
-              string[i - 1] == 0x072A)
-          {
-            properties[i] |= final3_p;
-            continue;
-          }
+	if (previous == causing ||
+	    previous == right)
+	 if (string[i - 1] == 0x0715 ||
+	      string[i - 1] == 0x0716 ||
+	      string[i - 1] == 0x072A)
+	  {
+	    properties[i] |= final3_p;
+	    continue;
+	  }
 
       /* R5 */
 
       if (previous == causing ||
 	  previous == right   ||
 	  previous == dual)
-        if (current == right)
+	if (current == right)
 	    {
 	      properties[i] |= final_p;
 	      continue;
@@ -289,50 +289,50 @@ syriac_assign_properties (gunichar    *string,
       /* R6 */
 
       if (previous == causing ||
-          previous == right   ||
+	  previous == right   ||
 	  previous == dual)
-        if (current == dual)
-          if (!(next == causing ||
+	if (current == dual)
+	  if (!(next == causing ||
 		    next == right   ||
 		    next == dual   ))
 	      {
-	        properties[i] |= final_p;
-	        continue;
+		properties[i] |= final_p;
+		continue;
 	      }
 
       /* R7 */
 
       if (previous == causing ||
-          previous == left    ||
-          previous == dual)
-        if (current == dual)
-          if (next == causing ||
-              next == right   ||
-              next == dual   )
+	  previous == left    ||
+	  previous == dual)
+	if (current == dual)
+	  if (next == causing ||
+	      next == right   ||
+	      next == dual   )
 	      {
-	        properties[i] |= medial_p;
-	        continue;
+		properties[i] |= medial_p;
+		continue;
 	      }
 
       /* R8 */
 
       if (string[i] == 0x0710)
-        if (previous == causing ||
-            previous == right)
-            if (next == causing ||
-                next == right ||
-                next == dual)
-            {
-              properties[i] |= medial2_p;
-              continue;
-            }
+	if (previous == causing ||
+	    previous == right)
+	    if (next == causing ||
+		next == right ||
+		next == dual)
+	    {
+	      properties[i] |= medial2_p;
+	      continue;
+	    }
 
       /* R9 */
 
       if (current == left)
-        if (next == causing ||
-            next == right   ||
-            next == dual)
+	if (next == causing ||
+	    next == right   ||
+	    next == dual)
 	    {
 	      properties[i] |= initial_p;
 	      continue;
@@ -343,13 +343,13 @@ syriac_assign_properties (gunichar    *string,
       if (!(previous == causing ||
 	    previous == left ||
 	    previous == dual   ))
-        if (current == dual)
-          if (next == causing ||
-              next == right   ||
-              next == dual)
+	if (current == dual)
+	  if (next == causing ||
+	      next == right   ||
+	      next == dual)
 	      {
-	        properties[i] |= initial_p;
-	        continue;
+		properties[i] |= initial_p;
+		continue;
 	      }
 
       /* R11 */
diff --git a/modules/thai/thai-charprop.c b/modules/thai/thai-charprop.c
index a05592b5..26e13318 100644
--- a/modules/thai/thai-charprop.c
+++ b/modules/thai/thai-charprop.c
@@ -28,92 +28,92 @@
 
 const gshort thai_char_type[256] = {
   /*       0,   1,   2,   3,   4,   5,   6,   7,
-           8,   9,   A,   B,   C,   D,   E,   F  */
+	   8,   9,   A,   B,   C,   D,   E,   F  */
 
-         /* CL1 */
+	 /* CL1 */
   /*00*/ _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
-         _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
+	 _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
   /*10*/ _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
-         _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
+	 _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
 
-         /* Lao zone: [U+0E80..U+0EDF] */
+	 /* Lao zone: [U+0E80..U+0EDF] */
   /*20*/ _ND, _NC, _NC, _ND, _NC, _ND, _ND, _NC,
-         _NC, _ND, _NC, _ND, _ND, _NC, _ND, _ND,
+	 _NC, _ND, _NC, _ND, _ND, _NC, _ND, _ND,
   /*30*/ _ND, _ND, _ND, _ND, _NC, _NC, _NC, _NC,
-         _ND, _NC, _NC, _UC, _NC, _UC, _NC, _UC,
+	 _ND, _NC, _NC, _UC, _NC, _UC, _NC, _UC,
   /*40*/ _ND, _NC, _UC, _NC, _ND, _NC, _ND, _NC,
-         _ND, _ND, _NC, _NC, _ND, _NC, _NC, _ND,
+	 _ND, _ND, _NC, _NC, _ND, _NC, _NC, _ND,
   /*50*/ _ND, _AV, _ND, _AM, _AV, _AV, _AV, _AV,
-         _BV, _BV, _ND, _AV, _BD, _NC, _ND, _ND,
+	 _BV, _BV, _ND, _AV, _BD, _NC, _ND, _ND,
   /*60*/ _ND, _ND, _ND, _ND, _ND, _ND, _ND, _AD,
-         _TN, _TN, _TN, _TN, _AD, _AD, _ND, _ND,
+	 _TN, _TN, _TN, _TN, _AD, _AD, _ND, _ND,
   /*70*/ _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
-         _ND, _ND, _ND, _ND, _NC, _NC, _ND, _ND,
+	 _ND, _ND, _ND, _ND, _NC, _NC, _ND, _ND,
 
-         /* CL2 */
+	 /* CL2 */
   /*80*/ _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
-         _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
+	 _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
   /*90*/ _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
-         _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
+	 _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
 
-         /* Thai zone: [U+0E00..U+0E5F] */
+	 /* Thai zone: [U+0E00..U+0E5F] */
   /*A0*/ _ND, _NC, _NC, _NC, _NC, _NC, _NC, _NC,
-         _NC, _NC, _NC, _NC, _NC, _SC, _BC, _BC,
+	 _NC, _NC, _NC, _NC, _NC, _SC, _BC, _BC,
   /*B0*/ _SC, _NC, _NC, _NC, _NC, _NC, _NC, _NC,
-         _NC, _NC, _NC, _UC, _NC, _UC, _NC, _UC,
+	 _NC, _NC, _NC, _UC, _NC, _UC, _NC, _UC,
   /*C0*/ _NC, _NC, _NC, _NC, _ND, _NC, _ND, _NC,
-         _NC, _NC, _NC, _NC, _UC, _NC, _NC, _ND,
+	 _NC, _NC, _NC, _NC, _UC, _NC, _NC, _ND,
   /*D0*/ _ND, _AV, _ND, _AM, _AV, _AV, _AV, _AV,
-         _BV, _BV, _BD, _ND, _ND, _ND, _ND, _ND,
+	 _BV, _BV, _BD, _ND, _ND, _ND, _ND, _ND,
   /*E0*/ _ND, _ND, _ND, _ND, _ND, _ND, _ND, _AD,
-         _TN, _TN, _TN, _TN, _AD, _AD, _AD, _ND,
+	 _TN, _TN, _TN, _TN, _AD, _AD, _AD, _ND,
   /*F0*/ _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
-         _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
+	 _ND, _ND, _ND, _ND, _ND, _ND, _ND, _ND,
 };
 
 const gshort thai_TAC_char_class[256] = {
   /*	   0,   1,   2,   3,   4,   5,   6,   7,
-           8,   9,   A,   B,   C,   D,   E,   F  */
+	   8,   9,   A,   B,   C,   D,   E,   F  */
 
-         /* CL1 */
+	 /* CL1 */
   /*00*/ CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,
-         CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,
+	 CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,
   /*10*/ CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,
-         CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,
+	 CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,
 
-         /* Lao zone: [U+0E80..U+0EDF] */
+	 /* Lao zone: [U+0E80..U+0EDF] */
   /*20*/  NON,CONS,CONS, NON,CONS, NON, NON,CONS,
-         CONS, NON,CONS, NON, NON,CONS, NON, NON,
+	 CONS, NON,CONS, NON, NON,CONS, NON, NON,
   /*30*/  NON, NON, NON, NON,CONS,CONS,CONS,CONS,
-          NON,CONS,CONS,CONS,CONS,CONS,CONS,CONS,
+	  NON,CONS,CONS,CONS,CONS,CONS,CONS,CONS,
   /*40*/  NON,CONS,CONS,CONS, NON,CONS, NON,CONS,
-          NON, NON,CONS,CONS, NON,CONS,CONS, NON,
+	  NON, NON,CONS,CONS, NON,CONS,CONS, NON,
   /*50*/  FV1, AV2, FV1,  AM, AV1, AV3, AV2, AV3,
-          BV1, BV2, NON, AV2,BCON, FV3, NON, NON,
+	  BV1, BV2, NON, AV2,BCON, FV3, NON, NON,
   /*60*/   LV,  LV,  LV,  LV,  LV, NON, NON, NON,
-         TONE,TONE,TONE,TONE, AD1, AD4, NON, NON,
+	 TONE,TONE,TONE,TONE, AD1, AD4, NON, NON,
   /*70*/  NON, NON, NON, NON, NON, NON, NON, NON,
-          NON, NON, NON, NON,CONS,CONS, NON,CTRL,
+	  NON, NON, NON, NON,CONS,CONS, NON,CTRL,
 
-         /* CL2 */
+	 /* CL2 */
   /*80*/ CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,
-         CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,
+	 CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,
   /*90*/ CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,
-         CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,
+	 CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,CTRL,
 
-         /* Thai zone: [U+0E00..U+0E5F] */
+	 /* Thai zone: [U+0E00..U+0E5F] */
   /*A0*/  NON,CONS,CONS,CONS,CONS,CONS,CONS,CONS,
-         CONS,CONS,CONS,CONS,CONS,CONS,CONS,CONS,
+	 CONS,CONS,CONS,CONS,CONS,CONS,CONS,CONS,
   /*B0*/ CONS,CONS,CONS,CONS,CONS,CONS,CONS,CONS,
-         CONS,CONS,CONS,CONS,CONS,CONS,CONS,CONS,
+	 CONS,CONS,CONS,CONS,CONS,CONS,CONS,CONS,
   /*C0*/ CONS,CONS,CONS,CONS, FV3,CONS, FV3,CONS,
-         CONS,CONS,CONS,CONS,CONS,CONS,CONS, NON,
+	 CONS,CONS,CONS,CONS,CONS,CONS,CONS, NON,
   /*D0*/  FV1, AV2, FV1,  AM, AV1, AV3, AV2, AV3,
-          BV1, BV2,  BD, NON, NON, NON, NON, NON,
+	  BV1, BV2,  BD, NON, NON, NON, NON, NON,
   /*E0*/   LV,  LV,  LV,  LV,  LV, FV2, NON, AD2,
-         TONE,TONE,TONE,TONE, AD1, AD4, AD3, NON,
+	 TONE,TONE,TONE,TONE, AD1, AD4, AD3, NON,
   /*F0*/  NON, NON, NON, NON, NON, NON, NON, NON,
-          NON, NON, NON, NON, NON, NON, NON,CTRL,
+	  NON, NON, NON, NON, NON, NON, NON,CTRL,
 };
 
 const gchar thai_TAC_compose_input[20][20] = {
@@ -121,44 +121,44 @@ const gchar thai_TAC_compose_input[20][20] = {
       /*CTRL NON CONS LV FV1 FV2 FV3  AM BV1 BV2
        * BD TONE AD1 AD2 AD3 AD4 AV1 AV2 AV3 BCON*/
 /*CTRL*/{'X','A','A','A','A','A','A','R','R','R',
-         'R','R','R','R','R','R','R','R','R','R'},
+	 'R','R','R','R','R','R','R','R','R','R'},
 /*NON */{'X','A','A','A','S','S','A','R','R','R',
-         'R','R','R','R','R','R','R','R','R','R'},
+	 'R','R','R','R','R','R','R','R','R','R'},
 /*CONS*/{'X','A','A','A','A','S','A','C','C','C',
-         'C','C','C','C','C','C','C','C','C','C'},
+	 'C','C','C','C','C','C','C','C','C','C'},
 /*LV  */{'X','S','A','S','S','S','S','R','R','R',
-         'R','R','R','R','R','R','R','R','R','R'},
+	 'R','R','R','R','R','R','R','R','R','R'},
 /*FV1 */{'X','A','A','A','A','S','A','R','R','R',
-         'R','R','R','R','R','R','R','R','R','R'},
+	 'R','R','R','R','R','R','R','R','R','R'},
 /*FV2 */{'X','A','A','A','A','S','A','R','R','R',
-         'R','R','R','R','R','R','R','R','R','R'},
+	 'R','R','R','R','R','R','R','R','R','R'},
 /*FV3 */{'X','A','A','A','S','A','S','R','R','R',
-         'R','R','R','R','R','R','R','R','R','R'},
+	 'R','R','R','R','R','R','R','R','R','R'},
 /*AM  */{'X','A','A','A','S','S','A','R','R','R',
-         'R','R','R','R','R','R','R','R','R','R'},
+	 'R','R','R','R','R','R','R','R','R','R'},
 /*BV1 */{'X','A','A','A','S','S','A','R','R','R',
-         'R','C','C','R','R','C','R','R','R','R'},
+	 'R','C','C','R','R','C','R','R','R','R'},
 /*BV2 */{'X','A','A','A','S','S','A','R','R','R',
-         'R','C','R','R','R','R','R','R','R','R'},
+	 'R','C','R','R','R','R','R','R','R','R'},
 /*BD  */{'X','A','A','A','S','S','A','R','R','R',
-         'R','R','R','R','R','R','R','R','R','R'},
+	 'R','R','R','R','R','R','R','R','R','R'},
 /*TONE*/{'X','A','A','A','A','A','A','C','R','R',
-         'R','R','R','R','R','R','R','R','R','R'},
+	 'R','R','R','R','R','R','R','R','R','R'},
 /*AD1 */{'X','A','A','A','S','S','A','R','R','R',
-         'R','R','R','R','R','R','R','R','R','R'},
+	 'R','R','R','R','R','R','R','R','R','R'},
 /*AD2 */{'X','A','A','A','S','S','A','R','R','R',
-         'R','R','R','R','R','R','R','R','R','R'},
+	 'R','R','R','R','R','R','R','R','R','R'},
 /*AD3 */{'X','A','A','A','S','S','A','R','R','R',
-         'R','R','R','R','R','R','R','R','R','R'},
+	 'R','R','R','R','R','R','R','R','R','R'},
 /*AD4 */{'X','A','A','A','S','S','A','R','R','R',
-         'R','C','R','R','R','R','R','R','R','R'},
+	 'R','C','R','R','R','R','R','R','R','R'},
 /*AV1 */{'X','A','A','A','S','S','A','R','R','R',
-         'R','C','C','R','R','C','R','R','R','R'},
+	 'R','C','C','R','R','C','R','R','R','R'},
 /*AV2 */{'X','A','A','A','S','S','A','R','R','R',
-         'R','C','R','R','R','R','R','R','R','R'},
+	 'R','C','R','R','R','R','R','R','R','R'},
 /*AV3 */{'X','A','A','A','S','S','A','R','R','R',
-         'R','C','R','C','R','R','R','R','R','R'},
+	 'R','C','R','C','R','R','R','R','R','R'},
 /*BCON*/{'X','A','A','A','A','S','A','C','C','C',
-         'R','C','R','R','R','C','C','C','C','R'},
+	 'R','C','R','R','R','C','C','C','C','R'},
 };
 
diff --git a/modules/thai/thai-fc.c b/modules/thai/thai-fc.c
index ebb2e97a..40ba8842 100644
--- a/modules/thai/thai-fc.c
+++ b/modules/thai/thai-fc.c
@@ -126,7 +126,7 @@ static const int lao_0[128] = {
     /**/ 0,      0,      0,      0,      0,      0,      0,      0,
     0x0020, 0x0e81, 0x0e82,      0, 0x0e84,      0,      0, 0x0e87,
     0x0e88,      0, 0x0e8a,      0,      0, 0x0e8d,      0,      0,
-         0,      0,      0,      0, 0x0e94, 0x0e95, 0x0e96, 0x0e97,
+	 0,      0,      0,      0, 0x0e94, 0x0e95, 0x0e96, 0x0e97,
     /**/ 0, 0x0e99, 0x0e9a, 0x0e9b, 0x0e9c, 0x0e9d, 0x0e9e, 0x0e9f,
     /**/ 0, 0x0ea1, 0x0ea2, 0x0ea3,      0, 0x0ea5,      0, 0x0ea7,
     /**/ 0,      0, 0x0eaa, 0x0eab,      0, 0x0ead, 0x0eae, 0x0eaf,
@@ -146,10 +146,10 @@ contain_glyphs(PangoFont *font, const int glyph_map[128])
   for (c = 0; c < 0x80; c++)
     {
       if (glyph_map[c])
-        {
+	{
 	  if (!pango_fc_font_has_char (fc_font, glyph_map[c]))
-            return 0;
-        }
+	    return 0;
+	}
     }
   return 1;
 }
@@ -175,13 +175,13 @@ thai_get_font_info (PangoFont *font)
 
       /* detect font set by determining availibility of OT ruleset & glyphs */
       if (thai_ot_get_ruleset (font))
-        font_info->font_set = THAI_FONT_TIS;
+	font_info->font_set = THAI_FONT_TIS;
       else if (contain_glyphs(font, tis620_2))
-        font_info->font_set = THAI_FONT_TIS_WIN;
+	font_info->font_set = THAI_FONT_TIS_WIN;
       else if (contain_glyphs(font, tis620_1))
-        font_info->font_set = THAI_FONT_TIS_MAC;
+	font_info->font_set = THAI_FONT_TIS_MAC;
       else
-        font_info->font_set = THAI_FONT_TIS;
+	font_info->font_set = THAI_FONT_TIS;
 
       g_object_set_qdata_full (G_OBJECT (font), info_id, font_info, (GDestroyNotify)g_free);
     }
diff --git a/modules/thai/thai-lang.c b/modules/thai/thai-lang.c
index a6fe45c4..83d16428 100644
--- a/modules/thai/thai-lang.c
+++ b/modules/thai/thai-lang.c
@@ -69,11 +69,11 @@ utf8_to_tis (const char *text, int len)
 
 static void
 thai_engine_break (PangoEngineLang *engine,
-                   const char      *text,
-                   int              len,
-                   PangoAnalysis   *analysis,
-                   PangoLogAttr    *attrs,
-                   int              attrs_len)
+		   const char      *text,
+		   int              len,
+		   PangoAnalysis   *analysis,
+		   PangoLogAttr    *attrs,
+		   int              attrs_len)
 {
   thchar_t *tis_text;
 
@@ -88,11 +88,11 @@ thai_engine_break (PangoEngineLang *engine,
       /* find line break positions */
       brk_n = th_brk (tis_text, brk_pnts, brk_len);
       for (i = 0; i < brk_n; i++)
-        {
-          attrs[brk_pnts[i]].is_line_break = TRUE;
-          attrs[brk_pnts[i]].is_word_start = TRUE;
-          attrs[brk_pnts[i]].is_word_end = TRUE;
-        }
+	{
+	  attrs[brk_pnts[i]].is_line_break = TRUE;
+	  attrs[brk_pnts[i]].is_word_start = TRUE;
+	  attrs[brk_pnts[i]].is_word_end = TRUE;
+	}
 
       g_free (brk_pnts);
       g_free (tis_text);
@@ -106,7 +106,7 @@ thai_engine_lang_class_init (PangoEngineLangClass *class)
 }
 
 PANGO_ENGINE_LANG_DEFINE_TYPE (ThaiEngineLang, thai_engine_lang,
-                               thai_engine_lang_class_init, NULL);
+			       thai_engine_lang_class_init, NULL);
 
 void
 PANGO_MODULE_ENTRY(init) (GTypeModule *module)
diff --git a/modules/thai/thai-ot.c b/modules/thai/thai-ot.c
index 66c129c4..b6866321 100644
--- a/modules/thai/thai-ot.c
+++ b/modules/thai/thai-ot.c
@@ -47,7 +47,7 @@ maybe_add_gsub_feature (PangoOTRuleset *ruleset,
 
 static gint
 maybe_add_gpos_feature (PangoOTRuleset *ruleset,
-		        PangoOTInfo    *info,
+			PangoOTInfo    *info,
 			guint           script_index,
 			PangoOTTag      feature_tag,
 			gulong          property_bit)
@@ -85,51 +85,51 @@ thai_ot_get_ruleset (PangoFont *font)
       static GQuark ruleset_quark = 0;
 
       if (!ruleset_quark)
-        ruleset_quark = g_quark_from_string ("thai-ot-ruleset");
+	ruleset_quark = g_quark_from_string ("thai-ot-ruleset");
 
       ruleset = g_object_get_qdata (G_OBJECT (info), ruleset_quark);
       if (!ruleset)
-        {
-          PangoOTTag thai_tag = FT_MAKE_TAG ('t', 'h', 'a', 'i');
-          guint      script_index;
-          gint       n = 0;
+	{
+	  PangoOTTag thai_tag = FT_MAKE_TAG ('t', 'h', 'a', 'i');
+	  guint      script_index;
+	  gint       n = 0;
 
-          ruleset = pango_ot_ruleset_new (info);
+	  ruleset = pango_ot_ruleset_new (info);
 
-          if (pango_ot_info_find_script (info, PANGO_OT_TABLE_GSUB,
-				         thai_tag, &script_index))
+	  if (pango_ot_info_find_script (info, PANGO_OT_TABLE_GSUB,
+					 thai_tag, &script_index))
 	    {
 	      n += maybe_add_gsub_feature (ruleset, info, script_index,
-			                   FT_MAKE_TAG ('c','c','m','p'),
+					   FT_MAKE_TAG ('c','c','m','p'),
 					   0xFFFF);
 	      n += maybe_add_gsub_feature (ruleset, info, script_index,
-			                   FT_MAKE_TAG ('l','i','g','a'),
+					   FT_MAKE_TAG ('l','i','g','a'),
 					   0xFFFF);
 	    }
 
-          if (pango_ot_info_find_script (info, PANGO_OT_TABLE_GPOS,
-				         thai_tag, &script_index))
+	  if (pango_ot_info_find_script (info, PANGO_OT_TABLE_GPOS,
+					 thai_tag, &script_index))
 	    {
 	      n += maybe_add_gpos_feature (ruleset, info, script_index,
-			                   FT_MAKE_TAG ('k','e','r','n'),
+					   FT_MAKE_TAG ('k','e','r','n'),
 					   0xFFFF);
 	      n += maybe_add_gpos_feature (ruleset, info, script_index,
-			                   FT_MAKE_TAG ('m','a','r','k'),
+					   FT_MAKE_TAG ('m','a','r','k'),
 					   0xFFFF);
 	      n += maybe_add_gpos_feature (ruleset, info, script_index,
-			                   FT_MAKE_TAG ('m','k','m','k'),
+					   FT_MAKE_TAG ('m','k','m','k'),
 					   0xFFFF);
 	    }
 
 	  if (n > 0)
-            g_object_set_qdata_full (G_OBJECT (info), ruleset_quark, ruleset,
+	    g_object_set_qdata_full (G_OBJECT (info), ruleset_quark, ruleset,
 	    		             (GDestroyNotify)g_object_unref);
 	  else
 	    {
 	      g_object_unref (ruleset);
 	      ruleset = NULL;
 	    }
-        }
+	}
     }
 
   pango_fc_font_unlock_face (fc_font);
@@ -158,51 +158,51 @@ lao_ot_get_ruleset (PangoFont *font)
       static GQuark ruleset_quark = 0;
 
       if (!ruleset_quark)
-        ruleset_quark = g_quark_from_string ("lao-ot-ruleset");
+	ruleset_quark = g_quark_from_string ("lao-ot-ruleset");
 
       ruleset = g_object_get_qdata (G_OBJECT (info), ruleset_quark);
       if (!ruleset)
-        {
-          PangoOTTag thai_tag = FT_MAKE_TAG ('l', 'a', 'o', ' ');
-          guint      script_index;
-          gint       n = 0;
+	{
+	  PangoOTTag thai_tag = FT_MAKE_TAG ('l', 'a', 'o', ' ');
+	  guint      script_index;
+	  gint       n = 0;
 
-          ruleset = pango_ot_ruleset_new (info);
+	  ruleset = pango_ot_ruleset_new (info);
 
-          if (pango_ot_info_find_script (info, PANGO_OT_TABLE_GSUB,
-				         thai_tag, &script_index))
+	  if (pango_ot_info_find_script (info, PANGO_OT_TABLE_GSUB,
+					 thai_tag, &script_index))
 	    {
 	      n += maybe_add_gsub_feature (ruleset, info, script_index,
-			                   FT_MAKE_TAG ('c','c','m','p'),
+					   FT_MAKE_TAG ('c','c','m','p'),
 					   0xFFFF);
 	      n += maybe_add_gsub_feature (ruleset, info, script_index,
-			                   FT_MAKE_TAG ('l','i','g','a'),
+					   FT_MAKE_TAG ('l','i','g','a'),
 					   0xFFFF);
 	    }
 
-          if (pango_ot_info_find_script (info, PANGO_OT_TABLE_GPOS,
-				         thai_tag, &script_index))
+	  if (pango_ot_info_find_script (info, PANGO_OT_TABLE_GPOS,
+					 thai_tag, &script_index))
 	    {
 	      n += maybe_add_gpos_feature (ruleset, info, script_index,
-			                   FT_MAKE_TAG ('k','e','r','n'),
+					   FT_MAKE_TAG ('k','e','r','n'),
 					   0xFFFF);
 	      n += maybe_add_gpos_feature (ruleset, info, script_index,
-			                   FT_MAKE_TAG ('m','a','r','k'),
+					   FT_MAKE_TAG ('m','a','r','k'),
 					   0xFFFF);
 	      n += maybe_add_gpos_feature (ruleset, info, script_index,
-			                   FT_MAKE_TAG ('m','k','m','k'),
+					   FT_MAKE_TAG ('m','k','m','k'),
 					   0xFFFF);
 	    }
 
 	  if (n > 0)
-            g_object_set_qdata_full (G_OBJECT (info), ruleset_quark, ruleset,
+	    g_object_set_qdata_full (G_OBJECT (info), ruleset_quark, ruleset,
 	    		             (GDestroyNotify)g_object_unref);
 	  else
 	    {
 	      g_object_unref (ruleset);
 	      ruleset = NULL;
 	    }
-        }
+	}
     }
 
   pango_fc_font_unlock_face (fc_font);
@@ -213,7 +213,7 @@ lao_ot_get_ruleset (PangoFont *font)
 
 void
 thai_ot_shape (PangoFont        *font,
-               PangoGlyphString *glyphs)
+	       PangoGlyphString *glyphs)
 {
   PangoOTRuleset *th_ruleset;
   PangoOTRuleset *lo_ruleset;
@@ -229,23 +229,23 @@ thai_ot_shape (PangoFont        *font,
       /* prepare ot buffer */
       buffer = pango_ot_buffer_new (PANGO_FC_FONT (font));
       for (i = 0; i < glyphs->num_glyphs; i++)
-        {
-          pango_ot_buffer_add_glyph (buffer,
+	{
+	  pango_ot_buffer_add_glyph (buffer,
 				     glyphs->glyphs[i].glyph,
 				     0,
 				     glyphs->log_clusters[i]);
-        }
+	}
 
       if (th_ruleset != NULL)
-        {
-          pango_ot_ruleset_substitute (th_ruleset, buffer);
-          pango_ot_ruleset_position (th_ruleset, buffer);
-        }
+	{
+	  pango_ot_ruleset_substitute (th_ruleset, buffer);
+	  pango_ot_ruleset_position (th_ruleset, buffer);
+	}
       if (lo_ruleset != NULL)
-        {
-          pango_ot_ruleset_substitute (lo_ruleset, buffer);
-          pango_ot_ruleset_position (lo_ruleset, buffer);
-        }
+	{
+	  pango_ot_ruleset_substitute (lo_ruleset, buffer);
+	  pango_ot_ruleset_position (lo_ruleset, buffer);
+	}
 
       pango_ot_buffer_output (buffer, glyphs);
       pango_ot_buffer_destroy (buffer);
diff --git a/modules/thai/thai-ot.h b/modules/thai/thai-ot.h
index de18bcdd..21f713c5 100644
--- a/modules/thai/thai-ot.h
+++ b/modules/thai/thai-ot.h
@@ -30,7 +30,7 @@ thai_ot_get_ruleset (PangoFont *font);
 
 void
 thai_ot_shape (PangoFont        *font,
-               PangoGlyphString *glyphs);
+	       PangoGlyphString *glyphs);
 
 #endif /* __THAI_OT_H__ */
 
diff --git a/modules/thai/thai-shaper.c b/modules/thai/thai-shaper.c
index df6c72f1..6d65a3b4 100644
--- a/modules/thai/thai-shaper.c
+++ b/modules/thai/thai-shaper.c
@@ -164,55 +164,55 @@ get_adjusted_glyphs_list (ThaiFontInfo *font_info,
   switch (num_chrs)
     {
       case 1:
-        if (is_char_type (cluster[0],
-                          BelowVowel|BelowDiac|AboveVowel|AboveDiac|Tone|SaraAm))
+	if (is_char_type (cluster[0],
+			  BelowVowel|BelowDiac|AboveVowel|AboveDiac|Tone|SaraAm))
 	  {
 	    gint n;
 	    glyph_lists[0] = get_null_base_glyph (font_info);
 	    n = glyph_lists[0] ? 1 : 0;
-            glyph_lists[n++] =
+	    glyph_lists[n++] =
 		thai_make_glyph_tis (font_info, ucs2tis (cluster[0]));
 	    return n;
-          }
+	  }
 	else
 	  {
 	    glyph_lists[0] =
 		thai_make_glyph_tis (font_info, ucs2tis (cluster[0]));
-            return 1;
-          }
-        break;
+	    return 1;
+	  }
+	break;
 
       case 2:
-        if (is_char_type (cluster[0], NoTailCons|BotTailCons|SpltTailCons) &&
-            is_char_type (cluster[1], SaraAm))
+	if (is_char_type (cluster[0], NoTailCons|BotTailCons|SpltTailCons) &&
+	    is_char_type (cluster[1], SaraAm))
 	  {
-            glyph_lists[0] =
+	    glyph_lists[0] =
 		thai_make_glyph_tis (font_info, ucs2tis (cluster[0]));
-            glyph_lists[1] = thai_make_glyph_tis (font_info, shaping_table->AmComp[0]);
-            glyph_lists[2] = thai_make_glyph_tis (font_info, shaping_table->AmComp[1]);
-            return 3;
-          }
+	    glyph_lists[1] = thai_make_glyph_tis (font_info, shaping_table->AmComp[0]);
+	    glyph_lists[2] = thai_make_glyph_tis (font_info, shaping_table->AmComp[1]);
+	    return 3;
+	  }
 	else if (is_char_type (cluster[0], UpTailCons) &&
-          	 is_char_type (cluster[1], SaraAm))
+	  	 is_char_type (cluster[1], SaraAm))
 	  {
 	    glyph_lists[0] =
 		thai_make_glyph_tis (font_info, ucs2tis (cluster[0]));
-            glyph_lists[1] = thai_make_glyph_tis (font_info,
+	    glyph_lists[1] = thai_make_glyph_tis (font_info,
 					shiftleft_tone_ad (shaping_table->AmComp[0], shaping_table));
-            glyph_lists[2] = thai_make_glyph_tis (font_info, shaping_table->AmComp[1]);
-            return 3;
-          }
+	    glyph_lists[2] = thai_make_glyph_tis (font_info, shaping_table->AmComp[1]);
+	    return 3;
+	  }
 	else if (is_char_type (cluster[0], NoTailCons|BotTailCons|SpltTailCons) &&
-          	 is_char_type (cluster[1], AboveVowel))
+	  	 is_char_type (cluster[1], AboveVowel))
 	  {
 	    glyph_lists[0] =
 		thai_make_glyph_tis (font_info, ucs2tis (cluster[0]));
 	    glyph_lists[1] =
 		thai_make_glyph_tis (font_info, ucs2tis (cluster[1]));
 	    return 2;
-          }
+	  }
 	else if (is_char_type (cluster[0], NoTailCons|BotTailCons|SpltTailCons) &&
-          	 is_char_type (cluster[1], AboveDiac|Tone))
+	  	 is_char_type (cluster[1], AboveDiac|Tone))
 	  {
 	    glyph_lists[0] =
 		thai_make_glyph_tis (font_info, ucs2tis (cluster[0]));
@@ -221,16 +221,16 @@ get_adjusted_glyphs_list (ThaiFontInfo *font_info,
 	    return 2;
 	  }
 	else if (is_char_type (cluster[0], UpTailCons) &&
-          	 is_char_type (cluster[1], AboveVowel))
+	  	 is_char_type (cluster[1], AboveVowel))
 	  {
 	    glyph_lists[0] =
 		thai_make_glyph_tis (font_info, ucs2tis (cluster[0]));
 	    glyph_lists[1] = thai_make_glyph_tis (font_info,
 		    	shiftleft_av (ucs2tis (cluster[1]), shaping_table));
 	    return 2;
-          }
+	  }
 	else if (is_char_type (cluster[0], UpTailCons) &&
-          	 is_char_type (cluster[1], AboveDiac|Tone))
+	  	 is_char_type (cluster[1], AboveDiac|Tone))
 	  {
 	    glyph_lists[0] =
 		thai_make_glyph_tis (font_info, ucs2tis (cluster[0]));
@@ -239,14 +239,14 @@ get_adjusted_glyphs_list (ThaiFontInfo *font_info,
 	    return 2;
 	  }
 	else if (is_char_type (cluster[0], NoTailCons|UpTailCons) &&
-          	 is_char_type (cluster[1], BelowVowel|BelowDiac))
+	  	 is_char_type (cluster[1], BelowVowel|BelowDiac))
 	  {
 	    glyph_lists[0] =
 		thai_make_glyph_tis (font_info, ucs2tis (cluster[0]));
 	    glyph_lists[1] =
 		thai_make_glyph_tis (font_info, ucs2tis (cluster[1]));
 	    return 2;
-          }
+	  }
 	else if (is_char_type (cluster[0], BotTailCons) &&
 		 is_char_type (cluster[1], BelowVowel|BelowDiac))
 	  {
@@ -258,7 +258,7 @@ get_adjusted_glyphs_list (ThaiFontInfo *font_info,
 	    return 2;
 	  }
 	else if (is_char_type (cluster[0], SpltTailCons) &&
-          	 is_char_type (cluster[1], BelowVowel|BelowDiac))
+	  	 is_char_type (cluster[1], BelowVowel|BelowDiac))
 	  {
 	    glyph_lists[0] = thai_make_glyph_tis (font_info,
 		    		tailcutcons (ucs2tis (cluster[0]), shaping_table));
@@ -277,21 +277,21 @@ get_adjusted_glyphs_list (ThaiFontInfo *font_info,
 		thai_make_glyph_tis (font_info, ucs2tis (cluster[1]));
 	    return n;
 	  }
-        break;
+	break;
 
       case 3:
-        if (is_char_type (cluster[0], NoTailCons|BotTailCons|SpltTailCons) &&
-            is_char_type (cluster[1], Tone) &&
-            is_char_type (cluster[2], SaraAm))
+	if (is_char_type (cluster[0], NoTailCons|BotTailCons|SpltTailCons) &&
+	    is_char_type (cluster[1], Tone) &&
+	    is_char_type (cluster[2], SaraAm))
 	  {
-            glyph_lists[0] =
+	    glyph_lists[0] =
 		thai_make_glyph_tis (font_info, ucs2tis (cluster[0]));
-            glyph_lists[1] = thai_make_glyph_tis (font_info, shaping_table->AmComp[0]);
-            glyph_lists[2] =
+	    glyph_lists[1] = thai_make_glyph_tis (font_info, shaping_table->AmComp[0]);
+	    glyph_lists[2] =
 		thai_make_glyph_tis (font_info, ucs2tis (cluster[1]));
-            glyph_lists[3] = thai_make_glyph_tis (font_info, shaping_table->AmComp[1]);
-            return 4;
-          }
+	    glyph_lists[3] = thai_make_glyph_tis (font_info, shaping_table->AmComp[1]);
+	    return 4;
+	  }
 	else if (is_char_type (cluster[0], UpTailCons) &&
 		 is_char_type (cluster[1], Tone) &&
 		 is_char_type (cluster[2], SaraAm))
@@ -379,12 +379,12 @@ get_adjusted_glyphs_list (ThaiFontInfo *font_info,
       break;
 
       default: /* e.g. Lao cluster with below cons + upper/lower vowel + tone */
-        {
-          gint i;
-          for (i = 0; i < num_chrs; i++)
-            glyph_lists[i] = thai_make_glyph_tis (font_info, ucs2tis (cluster[i]));
-          return num_chrs;
-        }
+	{
+	  gint i;
+	  for (i = 0; i < num_chrs; i++)
+	    glyph_lists[i] = thai_make_glyph_tis (font_info, ucs2tis (cluster[i]));
+	  return num_chrs;
+	}
     }
 
     return 0;
@@ -401,42 +401,42 @@ get_glyphs_list (ThaiFontInfo	*font_info,
   switch (pango_script_for_unichar (cluster[0]))
     {
       case PANGO_SCRIPT_THAI:
-        switch (font_info->font_set)
-          {
-            default:
-            case THAI_FONT_NONE:
-              for (i=0; i < num_chrs; i++)
-	        glyph_lists[i] = thai_make_unknown_glyph (font_info, cluster[i]);
-              return num_chrs;
-
-            case THAI_FONT_TIS:
+	switch (font_info->font_set)
+	  {
+	    default:
+	    case THAI_FONT_NONE:
+	      for (i=0; i < num_chrs; i++)
+		glyph_lists[i] = thai_make_unknown_glyph (font_info, cluster[i]);
+	      return num_chrs;
+
+	    case THAI_FONT_TIS:
 	      /* TIS620-0 + Wtt2.0 Extension
 	       */
-              return get_adjusted_glyphs_list (font_info, cluster,
+	      return get_adjusted_glyphs_list (font_info, cluster,
 		      num_chrs, glyph_lists, &tis620_0_shape_table);
 
-            case THAI_FONT_TIS_MAC:
+	    case THAI_FONT_TIS_MAC:
 	      /* MacIntosh Extension
 	       */
-              return get_adjusted_glyphs_list (font_info, cluster,
+	      return get_adjusted_glyphs_list (font_info, cluster,
 		      num_chrs, glyph_lists, &Mac_shape_table);
 
-            case THAI_FONT_TIS_WIN:
+	    case THAI_FONT_TIS_WIN:
 	      /* Microsoft Extension
 	       */
-              return get_adjusted_glyphs_list (font_info, cluster,
+	      return get_adjusted_glyphs_list (font_info, cluster,
 		      num_chrs, glyph_lists, &Win_shape_table);
-          }
+	  }
 	break;
 
       case PANGO_SCRIPT_LAO:
-        return get_adjusted_glyphs_list (font_info, cluster,
-	        num_chrs, glyph_lists, &Lao_shape_table);
+	return get_adjusted_glyphs_list (font_info, cluster,
+		num_chrs, glyph_lists, &Lao_shape_table);
 
       default:
-        for (i=0; i < num_chrs; i++)
+	for (i=0; i < num_chrs; i++)
 	  glyph_lists[i] = thai_make_unknown_glyph (font_info, cluster[i]);
-        return num_chrs;
+	return num_chrs;
     }
 
   return 0;			/* Quiet GCC */
@@ -485,10 +485,10 @@ is_wtt_composible (gunichar cur_wc, gunichar nxt_wc)
       case 'S':
       case 'R':
       case 'X':
-        return FALSE;
+	return FALSE;
 
       case 'C':
-        return TRUE;
+	return TRUE;
     }
 
   g_assert_not_reached ();
@@ -511,11 +511,11 @@ get_next_cluster(const char	*text,
       current = g_utf8_get_char (p);
       cur_script = pango_script_for_unichar (current);
       if (cluster_script == PANGO_SCRIPT_INVALID_CODE)
-        cluster_script = cur_script;
+	cluster_script = cur_script;
       if (cur_script != cluster_script ||
-          (n_chars > 0 &&
-           !is_wtt_composible (cluster[n_chars - 1], current)))
-        break;
+	  (n_chars > 0 &&
+	   !is_wtt_composible (cluster[n_chars - 1], current)))
+	break;
       cluster[n_chars++] = current;
     }
 
diff --git a/modules/thai/thai-shaper.h b/modules/thai/thai-shaper.h
index 3349ed3b..ea3c4039 100644
--- a/modules/thai/thai-shaper.h
+++ b/modules/thai/thai-shaper.h
@@ -79,10 +79,10 @@ thai_make_unknown_glyph (ThaiFontInfo *font_info, gunichar uc);
 void
 thai_engine_shape (PangoEngineShape *engine,
 		   PangoFont        *font,
-                   const char       *text,
-                   gint              length,
-                   const PangoAnalysis *analysis,
-                   PangoGlyphString *glyphs);
+		   const char       *text,
+		   gint              length,
+		   const PangoAnalysis *analysis,
+		   PangoGlyphString *glyphs);
 
 #endif /* __THAI_SHAPER_H__ */
 
diff --git a/modules/tibetan/tibetan-fc.c b/modules/tibetan/tibetan-fc.c
index 95dd9e57..ff773b0f 100644
--- a/modules/tibetan/tibetan-fc.c
+++ b/modules/tibetan/tibetan-fc.c
@@ -384,35 +384,35 @@ find_syllable (const gunichar *chars,
 
 static void
 maybe_add_GSUB_feature (PangoOTRuleset *ruleset,
-	                PangoOTInfo    *info,
-	                guint           script_index,
-	                PangoOTTag      tag,
-	                gulong          property_bit)
+			PangoOTInfo    *info,
+			guint           script_index,
+			PangoOTTag      tag,
+			gulong          property_bit)
 {
   guint feature_index;
 
   /* 0xffff == default language system */
   if (pango_ot_info_find_feature (info, PANGO_OT_TABLE_GSUB,
-	                          tag, script_index, 0xffff, &feature_index))
+				  tag, script_index, 0xffff, &feature_index))
     pango_ot_ruleset_add_feature (ruleset, PANGO_OT_TABLE_GSUB, feature_index,
-	                          property_bit);
+				  property_bit);
 }
 
 
 static void
 maybe_add_GPOS_feature (PangoOTRuleset *ruleset,
-	                PangoOTInfo    *info,
-	                guint           script_index,
-	                PangoOTTag      tag,
-	                gulong          property_bit)
+			PangoOTInfo    *info,
+			guint           script_index,
+			PangoOTTag      tag,
+			gulong          property_bit)
 {
   guint feature_index;
 
   /* 0xffff == default language system */
   if (pango_ot_info_find_feature (info, PANGO_OT_TABLE_GPOS,
-	                          tag, script_index, 0xffff, &feature_index))
+				  tag, script_index, 0xffff, &feature_index))
     pango_ot_ruleset_add_feature (ruleset, PANGO_OT_TABLE_GPOS, feature_index,
-	                          property_bit);
+				  property_bit);
 }
 
 /* Rules found in the Open type font features */
@@ -440,7 +440,7 @@ get_ruleset (FT_Face face)
       ruleset = pango_ot_ruleset_new (info);
 
       if (pango_ot_info_find_script (info, PANGO_OT_TABLE_GSUB,
-	                              tibetan_tag, &script_index))
+				      tibetan_tag, &script_index))
 	{
 	  maybe_add_GSUB_feature (ruleset, info, script_index, FT_MAKE_TAG ('p','r','e','f'), pref);
 	  maybe_add_GSUB_feature (ruleset, info, script_index, FT_MAKE_TAG ('b','l','w','f'), blwf);
@@ -455,7 +455,7 @@ get_ruleset (FT_Face face)
 	}
 
       if (pango_ot_info_find_script (info, PANGO_OT_TABLE_GPOS,
-	                              tibetan_tag, &script_index))
+				      tibetan_tag, &script_index))
 	{
 	  maybe_add_GPOS_feature (ruleset, info, script_index, FT_MAKE_TAG ('d','i','s','t'), dist);
 	  maybe_add_GPOS_feature (ruleset, info, script_index, FT_MAKE_TAG ('b','l','w','m'), blwm);
@@ -464,7 +464,7 @@ get_ruleset (FT_Face face)
 	}
 
       g_object_set_qdata_full (G_OBJECT (info), ruleset_quark, ruleset,
-	                        (GDestroyNotify)g_object_unref);
+				(GDestroyNotify)g_object_unref);
     }
 
   return ruleset;
@@ -483,11 +483,11 @@ get_index (PangoFcFont *fc_font, gunichar wc)
 
 static void
 tibetan_engine_shape (PangoEngineShape *engine,
-	            PangoFont        *font,
-	            const char       *text,
-	            int               length,
-	            const PangoAnalysis *analysis,
-	            PangoGlyphString *glyphs)
+		    PangoFont        *font,
+		    const char       *text,
+		    int               length,
+		    const PangoAnalysis *analysis,
+		    PangoGlyphString *glyphs)
 {
   PangoFcFont *fc_font;
   FT_Face face;
@@ -551,21 +551,21 @@ tibetan_engine_shape (PangoEngineShape *engine,
 	  switch (charClass & CF_POS_MASK)
 	    {
 	      case CF_POS_ABOVE :
-		             pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), abvf_p, p - text);
-		             break;
+			     pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), abvf_p, p - text);
+			     break;
 
 	      case CF_POS_AFTER :
-		             pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), pstf_p, p - text);
-		             break;
+			     pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), pstf_p, p - text);
+			     break;
 
 	      case CF_POS_BELOW :
-		             pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), blwf_p, p - text);
-		             break;
+			     pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), blwf_p, p - text);
+			     break;
 
 	      default:
-	           /* default - any other characters  */
-	          pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), default_p, p - text);
-	          break;
+		   /* default - any other characters  */
+		  pango_ot_buffer_add_glyph (buffer, get_index (fc_font, wcs[i]), default_p, p - text);
+		  break;
 	    } /* switch */
 	   }
 
@@ -599,7 +599,7 @@ tibetan_engine_fc_class_init (PangoEngineShapeClass *class)
 }
 
 PANGO_ENGINE_SHAPE_DEFINE_TYPE (TibetanEngineFc, tibetan_engine_fc,
-	                        tibetan_engine_fc_class_init, NULL)
+				tibetan_engine_fc_class_init, NULL)
 
 
 void
@@ -617,7 +617,7 @@ PANGO_MODULE_ENTRY(exit) (void)
 
 void
 PANGO_MODULE_ENTRY(list) (PangoEngineInfo **engines,
-	                  int              *n_engines)
+			  int              *n_engines)
 {
   *engines = script_engines;
   *n_engines = G_N_ELEMENTS (script_engines);