diff --git a/src/auto/configure b/src/auto/configure
index 8052ceb..db3e3b1 100755
--- a/src/auto/configure
+++ b/src/auto/configure
@@ -1498,7 +1498,7 @@
   --enable-multibyte      Include multibyte editing support.
   --disable-rightleft     Do not include Right-to-Left language support.
   --disable-arabic        Do not include Arabic language support.
-  --disable-farsi         Do not include Farsi language support.
+  --disable-farsi         Deprecated.
   --enable-hangulinput    Include Hangul input support.
   --enable-xim            Include XIM input support.
   --enable-fontset        Include X fontset output support.
@@ -7980,24 +7980,11 @@
 
 fi
 
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --disable-farsi argument" >&5
-$as_echo_n "checking --disable-farsi argument... " >&6; }
 # Check whether --enable-farsi was given.
 if test "${enable_farsi+set}" = set; then :
   enableval=$enable_farsi;
-else
-  enable_farsi="yes"
 fi
 
-if test "$enable_farsi" = "yes"; then
-	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-else
-	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-$as_echo "yes" >&6; }
-	$as_echo "#define DISABLE_FARSI 1" >>confdefs.h
-
-fi
 
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking --enable-hangulinput argument" >&5
 $as_echo_n "checking --enable-hangulinput argument... " >&6; }
