Source code for word2txt.cs

```
using System;
```
```
using System.Collections.Generic;
```
```
using System.IO;
```
```
using System.IO.Compression;
```
```
using System.Linq;
```
```
using System.Text;
```
```
using System.Text.RegularExpressions;
```
```
using System.Windows.Forms;
```

using Word = Microsoft.Office.Interop.Word;

```
 
```
```
 
```
```
namespace RobvanderWoude
```
```
{
```
```
	internal class Word2Txt
```
```
	{
```
```
		static string progver = "1.03";
```
```
 
```
```
 
```

		static string plaintext = string.Empty;

```
 
```
```
 
```
```
		static int Main( string[] args )
```
```
		{
```
```
			string document = string.Empty;
```
```
			bool success = false;
```
```
			bool usexmlencoding = false;
```
```
			string xmlencoding = string.Empty;
```
```
			Encoding encoding = null;
```
```
 
```
```
 
```
```
			#region Parse Command Line
```
```
 
```

			if ( args.Length == 0 || args.Length > 2 )

```
			{
```
```
				return ShowHelp( );
```
```
			}
```
```
 
```
```
			foreach ( string arg in args )
```
```
			{
```
```
				if ( arg[0] == '/' )
```
```
				{
```
```
					if ( arg == "/?" )
```
```
					{
```
```
						return ShowHelp( );
```
```
					}
```

					else if ( arg.StartsWith( "/D", StringComparison.OrdinalIgnoreCase ) )

```
					{
```
```
						usexmlencoding = true;
```
```
					}
```
```
					else if ( arg.ToUpper( ) == "/E" )
```
```
					{
```
```
						return ListEncodings( );
```
```
					}
```
```
					else
```
```
					{
```

						return ShowHelp( "Invalid command line switch {0}", arg );

```
					}
```
```
				}
```
```
				else
```
```
				{
```

					if ( string.IsNullOrWhiteSpace( document ) )

```
					{
```
```
						document = arg;
```
```
						if ( !File.Exists( document ) )
```
```
						{
```

							return ShowHelp( "File \"{0}\" not found", document );

```
						}
```
```
					}
```
```
					else if ( encoding == null )
```
```
					{
```
```
						encoding = GetEncoding( arg );
```
```
						if ( encoding == null )
```
```
						{
```

							return ShowHelp( "Invalid encoding \"{0}\"", args[1] );

```
						}
```
```
					}
```
```
					else
```
```
					{
```

						return ShowHelp( "Too many command line arguments" );

```
					}
```
```
				}
```
```
			}
```
```
 
```

			if ( string.IsNullOrWhiteSpace( document ) )

```
			{
```
```
				return ShowHelp( );
```
```
			}
```
```
 
```
```
			#endregion Parse Command Line
```
```
 
```
```
 
```
```
			#region Extract Text
```
```
 
```
```
			// First try using Word if possible
```
```
			if ( IsWordInstalled( ) )
```
```
			{
```

				// If Word is installed, this program can handle ANY document format that is recognized by Word

```
				success = ReadWordFile( document );
```
```
			}
```
```
 
```

			// if Word isn't available or could not extract any text, try plan B

			if ( !success || string.IsNullOrWhiteSpace( plaintext ) )

```
			{
```

				string ext = Path.GetExtension( document ).ToLower( );

```
				if ( ext == ".doc" )
```
```
				{
```
```
					success = ReadDocFile( document );
```
```
				}
```

				else if ( ext == ".docx" || ext == ".odt" )

```
				{
```

					success = ReadDocxOrOdtFile( document );

```
				}
```
```
				else if ( ext == ".rtf" )
```
```
				{
```
```
					success = ReadRTFFile( document );
```
```
				}
```
```
				else if ( ext == ".wpd" )
```
```
				{
```
```
					success = ReadWPDFile( document );
```
```
				}
```
```
				else
```
```
				{
```

					return ShowHelp( "If Word is not installed or fails to extract text, this program can only handle .DOC, .DOCX, .ODT and .WPD files" );

```
				}
```
```
			}
```
```
 
```
```
			#endregion Extract Text
```
```
 
```
```
 
```

			#region Cleanup Text and Display Result

```
 
```

			if ( success && !string.IsNullOrWhiteSpace( plaintext ) )

```
			{
```

				// convert stray carriage returns to carriage return/linefeed pairs

				plaintext = ConvertStrayCarriageReturns( plaintext ).Trim( "\n\r\t ".ToCharArray( ) );

```
 
```
```
				if ( usexmlencoding )
```
```
				{
```

					encoding = GetEncoding( xmlencoding );

```
				}
```
```
 
```
```
				if ( encoding == null )
```
```
				{
```

					// send text to console using default output encoding

```
					Console.WriteLine( plaintext );
```
```
				}
```
```
				else
```
```
				{
```

					// temporarily change output encoding and send text to console

					Encoding oldencoding = Console.OutputEncoding;

```
					Console.OutputEncoding = encoding;
```
```
					Console.WriteLine( plaintext );
```

					Console.OutputEncoding = oldencoding;

```
				}
```
```
 
```
```
				return 0;
```
```
			}
```
```
			else
```
```
			{
```

				// failed to extract text from Word file

```
				return 1;
```
```
			}
```
```
 
```

			#endregion Cleanup Text and Display Result

```
		}
```
```
 
```
```
 
```

		static string ConvertStrayCarriageReturns( string text )

```
		{
```

			// convert stray carriage returns to carriage return/linefeed pairs

			// search for stray carriage returns (\r), i.e. the ones NOT followed by linefeeds (\n)

			Regex regex = new Regex( "\r(?!\n)" );

			// replace each matching stray carriage return by a carriage return/linefeed pair

			text = regex.Replace( text, Environment.NewLine );

```
			return text;
```
```
		}
```
```
 
```
```
 
```

		static Encoding GetEncoding( string myencoding )

```
		{
```

			if ( string.IsNullOrEmpty( myencoding ) )

```
			{
```
```
				return null;
```
```
			}
```
```
			// Get a list of available encodings
```

			EncodingInfo[] encodings = Encoding.GetEncodings( );

			// Try correctly spelled encodings first

			foreach ( EncodingInfo encoding in encodings )

```
			{
```

				if ( encoding.Name.ToLower( ) == myencoding.ToLower( ) )

```
				{
```

					return Encoding.GetEncoding( encoding.CodePage );

```
				}
```
```
			}
```

			// No direct match found, try again, ignoring dashes

			foreach ( EncodingInfo encoding in encodings )

```
			{
```

				if ( encoding.Name.Replace( "-", "" ).ToLower( ) == myencoding.Replace( "-", "" ).ToLower( ) )

```
				{
```

					return Encoding.GetEncoding( encoding.CodePage );

```
				}
```
```
			}
```
```
			// Still no match, try codepages
```

			foreach ( EncodingInfo encoding in encodings )

```
			{
```

				if ( encoding.CodePage.ToString( ) == myencoding )

```
				{
```

					return Encoding.GetEncoding( encoding.CodePage );

```
				}
```
```
			}
```
```
			// Still no match, giving up
```
```
			return null;
```
```
		}
```
```
 
```
```
 
```
```
		static bool IsWordInstalled( )
```
```
		{
```

			// Source: "How to Check Whether Word is Installed in the System or Not" by Tadit Dash

			// https://www.codeproject.com/Tips/689968/How-to-Check-Whether-Word-is-Installed-in-the-Syst

			return ( Type.GetTypeFromProgID( "Word.Application" ) != null );

```
		}
```
```
 
```
```
 
```
```
		static int ListEncodings( )
```
```
		{
```
```
			try
```
```
			{
```
```
				Console.Clear( );
```
```
			}
```
```
			catch
```
```
			{
```

				// Console.Clear( ) throws an IO exception if the output is redirected

```
			}
```
```
			int columnwidth = 8;
```

			EncodingInfo[] allencodings = Encoding.GetEncodings( );

			List<string> allencodingnames = new List<string>( );

			foreach ( EncodingInfo enc in allencodings )

```
			{
```
```
				allencodingnames.Add( enc.Name );
```
```
			}
```
```
			allencodingnames.Sort( );
```

			foreach ( string enc in allencodingnames )

```
			{
```

				columnwidth = Math.Max( columnwidth, enc.Length );

```
			}
```

			Console.WriteLine( "{0,-" + columnwidth + "}   {1}", "Encoding", "CodePage" );

			Console.WriteLine( "{0,-" + columnwidth + "}   {1}", "========", "========" );

			foreach ( string enc in allencodingnames )

```
			{
```

				Console.WriteLine( "{0,-" + columnwidth + "}   {1}", enc, GetEncoding( enc ).CodePage );

```
			}
```
```
			return 0;
```
```
		}
```
```
 
```
```
 
```

		static bool ReadDocFile( string docfile )

```
		{
```
```
			string doccontent = string.Empty;
```
```
			try
```
```
			{
```

				StreamReader sr = new StreamReader( docfile, false );

				doccontent = sr.ReadToEnd( ).Trim( "\n\t ".ToCharArray( ) );

```
				sr.Close( );
```
```
			}
```
```
			catch ( IOException )
```
```
			{
```

				ShowHelp( "Access to file \"{0}\" denied", docfile );

```
				return false;
```
```
			}
```
```
			if ( doccontent.Length == 0 )
```
```
			{
```
```
				return false;
```
```
			}
```

			if ( doccontent.Contains( "[Content_Types]" ) )

```
			{
```

				doccontent = doccontent.Substring( 0, doccontent.IndexOf( "[Content_Types]" ) );

```
			}
```

			Regex regex = new Regex( "[^\\000\\015\\367\\377]{20,}" );

			MatchCollection matches = regex.Matches( doccontent );

```
			if ( matches.Count == 0 )
```
```
			{
```
```
				return false;
```
```
			}
```
```
			plaintext = string.Empty;
```
```
			foreach ( Match match in matches )
```
```
			{
```

				string matchingtext = match.Value.Trim( "\n\t ".ToCharArray( ) );

				if ( Encoding.UTF8.GetByteCount( matchingtext ) == matchingtext.Length && !matchingtext.Contains( (char)4 ) )

```
				{
```
```
					plaintext += matchingtext + "\n";
```
```
				}
```
```
			}
```
```
			return true;
```
```
		}
```
```
 
```
```
 
```

		static bool ReadDocxOrOdtFile( string docfile )

```
		{
```
```
			string contentfile;
```

			string ext = Path.GetExtension( docfile ).ToLower( );

			if ( ext == ".odt" ) // OpenOffice document

```
			{
```
```
				contentfile = "content.xml";
```
```
			}
```

			else if ( ext == ".docx" ) // MS Office document

```
			{
```
```
				contentfile = "document.xml";
```
```
			}
```
```
			else
```
```
			{
```
```
				return false;
```
```
			}
```
```
 
```

			string tempfile = Path.GetTempFileName( );

```
			string content = string.Empty;
```
```
			bool success = false;
```
```
 
```
```
			try
```
```
			{
```

				// Open document as ZIP file and extract the XML file containing the text content

				using ( ZipArchive archive = ZipFile.OpenRead( docfile ) )

```
				{
```

					foreach ( ZipArchiveEntry entry in archive.Entries )

```
					{
```

						if ( entry.Name.ToLower( ) == contentfile )

```
						{
```

							entry.ExtractToFile( tempfile, true );

```
							success = true;
```
```
						}
```
```
					}
```
```
				}
```
```
			}
```
```
			catch ( IOException )
```
```
			{
```

				ShowHelp( "Access to file \"{0}\" denied", docfile );

```
				return false;
```
```
			}
```
```
 
```
```
			if ( success )
```
```
			{
```

				// Read the text content from the extracted file

				StreamReader sr = new StreamReader( tempfile );

				content = sr.ReadToEnd( ).Trim( "\n\r\t ".ToCharArray( ) );

```
				sr.Close( );
```
```
			}
```
```
 
```
```
			// Delete the extracted file
```
```
			File.Delete( tempfile );
```
```
 
```
```
			if ( success )
```
```
			{
```

				// The first 100 characters of the extracted XML usually contain its encoding;

				// this encoding will be used if the /D command line switch was used

				Regex regex = new Regex( " encoding=\"([^\"]+)\"" );

				string xmlencoding = regex.Match( content, 0, 100 ).Groups[1].Value;

				// insert newlines after headers, list items and paragraphs

				regex = new Regex( "</(text|w):(h|p)>" );

				string plaintext = regex.Replace( content, "\n\n" );

```
				regex = new Regex( "<w:br/>" );
```

				plaintext = regex.Replace( plaintext, "\n\n" );

```
				// remove all XML tags
```
```
				regex = new Regex( "<[^>]+>" );
```

				plaintext = regex.Replace( plaintext, "" );

```
 
```
```
				return true;
```
```
			}
```
```
			return false;
```
```
		}
```
```
 
```
```
 
```

		static bool ReadRTFFile( string rtffile )

```
		{
```

			// Use a hidden RichTextBox to convert RTF to plain text, by Wendy Zang

			// https://social.msdn.microsoft.com/Forums/vstudio/en-US/6e56af9b-d7d3-49f3-9ec4-80edde3fe54b/reading-modifying-rtf-files?forum=csharpgeneral#a64345e9-cfcb-43be-ab18-c08fae02cb2a

			RichTextBox rtbox = new RichTextBox( );

```
			string rtftext = string.Empty;
```
```
			try
```
```
			{
```

				rtftext = File.ReadAllText( rtffile );

```
				rtbox.Rtf = rtftext;
```
```
				plaintext = rtbox.Text;
```
```
			}
```
```
			catch ( IOException )
```
```
			{
```
```
				return false;
```
```
			}
```
```
			return true;
```
```
		}
```
```
 
```
```
 
```

		static bool ReadWordFile( string wordfile )

```
		{
```
```
			try
```
```
			{
```

				Word.Application wordapp = new Word.Application( );

```
				wordapp.Visible = false;
```

				Word.Document worddoc = wordapp.Documents.Open( wordfile );

```
				wordapp.Selection.WholeStory( );
```
```
				plaintext = worddoc.Content.Text;
```

				object savechanges = Word.WdSaveOptions.wdDoNotSaveChanges;

```
				worddoc.Close( ref savechanges );
```
```
				wordapp.Quit( ref savechanges );
```
```
				return true;
```
```
			}
```
```
			catch ( Exception )
```
```
			{
```
```
				return false;
```
```
			}
```
```
		}
```
```
 
```
```
 
```

		static bool ReadWPDFile( string wpfile )

```
		{
```

			string wpcontent = File.ReadAllText( wpfile, Encoding.UTF8 );

```
 
```

			// Remove (most of) the WPD file header - WARNING: regex pattern depends on Encoding used for StreamReader!

			Regex regex = new Regex( "^[\\w\\W]*\\000{8,}([^\\w]+[B-HJ-NP-TV-Z\\d])*[^\\w-]+", RegexOptions.IgnoreCase );

			wpcontent = regex.Replace( wpcontent, "" );

```
 
```
```
			plaintext = string.Empty;
```
```
 
```

			// WPD file format info based on http://justsolve.archiveteam.org/wiki/WordPerfect

			// Modified for spaces, linefeeds and e acute by yours truly

			// More modifications are required for accented characters

```
			bool skip = false;
```
```
			int resume = -1;
```
```
			foreach ( char c in wpcontent )
```
```
			{
```
```
				int i = (int)c;
```
```
				if ( !skip )
```
```
				{
```

					if ( i == 63 || i == 128 || i == 160 || i == 65533 )

```
					{
```
```
						plaintext += ' ';
```
```
					}
```

					else if ( i >= 169 && i != 172 && i <= 174 )

```
					{
```
```
						plaintext += '-';
```
```
					}
```

					else if ( i == 10 || i == 13 || i == 208 )

```
					{
```
```
						plaintext += Environment.NewLine;
```
```
					}
```
```
					else if ( i >= 192 && i <= 236 )
```
```
					{
```
```
						skip = true;
```
```
						resume = i;
```
```
					}
```
```
					else if ( i == 15 )
```
```
					{
```
```
						plaintext += (char)233;
```
```
					}
```

					else if ( i <= 31 || ( i >= 129 && i <= 159 ) || ( i >= 161 && i <= 168 ) || i == 172 || ( i >= 175 && i <= 191 ) || ( i >= 237 && i <= 255 ) )

```
					{
```
```
						// control characters, ignore
```
```
					}
```
```
					else
```
```
					{
```
```
						plaintext += c;
```
```
					}
```
```
				}
```
```
				else if ( skip && i == resume )
```
```
				{
```
```
					skip = false;
```
```
					resume = -1;
```
```
				}
```
```
			}
```

			return !string.IsNullOrWhiteSpace( plaintext );

```
		}
```
```
 
```
```
 
```

		static int ShowHelp( params string[] errmsg )

```
		{
```
```
			#region Help Text
```
```
 
```
```
			/*
```
```
			Word2Txt,  Version 1.03
```

			Extract plain text from a Word document and send it to the screen

```
 
```

			Usage:   Word2Txt    "wordfile"  [ encoding | /D ]

```
 
```
```
			or:      Word2Txt    /E
```
```
 
```

			Where:   wordfile    is the path of the Word document to be read

			                     (no wildcards allowed)

			         encoding    force use of alternative encoding for plain

			                     text, e.g. UTF-8 to preserve accented characters

			                     or IBM437 to convert unicode quotes to ASCII

			         /D          use the encoding specified in the document file

			                     (for .DOCX and .ODT only, if Word isn't available)

			         /E          list all available encodings

```
 
```

			Notes:   If a "regular" (MSI based) Microsoft Word (2007 or later)

			         installation is detected, this program will use Word to read

			         the text from the Word file, which may be ANY file format

```
			         recognized by Word.
```

			         If Word was already active when this program is started, any

			         other opened document(s) will be left alone, and only the

			         document opened by this program will be closed.

			         If Word is not available, the text can still be extracted, but

			         only from .DOC, .DOCX, .ODT, .RTF and .WPD files.

			         If the specified encoding does not match any available encoding

			         name, the program will try again, ignoring dashes; if that does

			         not provide a match, the program will try matching the specified

			         encoding with the available encodings' codepages.

			         This program requires .NET 4.5.

			         Return code ("errorlevel") 0 means no errors were encounterd

			         and some text was extracted from the file; otherwise the

```
			         return code will be 1.
```
```
 
```
```
			Written by Rob van der Woude
```
```
			https://www.robvanderwoude.com
```
```
			*/
```
```
 
```
```
			#endregion Help Text
```
```
 
```
```
 
```
```
			#region Error Message
```
```
 
```
```
			if ( errmsg.Length > 0 )
```
```
			{
```

				List<string> errargs = new List<string>( errmsg );

```
				errargs.RemoveAt( 0 );
```
```
				Console.Error.WriteLine( );
```

				Console.ForegroundColor = ConsoleColor.Red;

```
				Console.Error.Write( "ERROR:\t" );
```

				Console.ForegroundColor = ConsoleColor.White;

				Console.Error.WriteLine( errmsg[0], errargs.ToArray( ) );

```
				Console.ResetColor( );
```
```
			}
```
```
 
```
```
			#endregion Error Message
```
```
 
```
```
 
```
```
			#region Display Help Text
```
```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```

			Console.Error.WriteLine( "Word2Txt,  Version {0}", progver );

```
 
```

			Console.Error.WriteLine( "Extract plain text from a Word document and send it to the screen" );

```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```
```
			Console.Error.Write( "Usage:   " );
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.WriteLine( "Word2Txt    \"wordfile\"  [ encoding | /D ]" );

```
			Console.ResetColor( );
```
```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```
```
			Console.Error.Write( "or:      " );
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.WriteLine( "Word2Txt    /E" );

```
			Console.ResetColor( );
```
```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```
```
			Console.Error.Write( "Where:   " );
```

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "wordfile" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "    is the path of the Word document to be read" );

```
 
```

			Console.Error.WriteLine( "                     (no wildcards allowed)" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "         encoding" );

```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "    force use of alternative encoding for plain" );

```
 
```

			Console.Error.Write( "                     text, e.g. " );

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "UTF-8" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( " to preserve accented characters" );

```
 
```

			Console.Error.Write( "                     or " );

			Console.ForegroundColor = ConsoleColor.White;

```
			Console.Error.Write( "IBM437" );
```
```
			Console.ResetColor( );
```

			Console.Error.WriteLine( " to convert unicode quotes to ASCII" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "         /D" );

```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "          use the encoding specified in the document file" );

```
 
```

			Console.Error.WriteLine( "                     (for .DOCX and .ODT only, if Word isn't available)" );

```
 
```

			Console.ForegroundColor = ConsoleColor.White;

			Console.Error.Write( "         /E" );

```
			Console.ResetColor( );
```

			Console.Error.WriteLine( "          list all available encodings" );

```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```

			Console.Error.WriteLine( "Notes:   If a \"regular\" (MSI based) Microsoft Word (2007 or later)" );

```
 
```

			Console.Error.WriteLine( "         installation is detected, this program will use Word to read" );

```
 
```

			Console.Error.WriteLine( "         the text from the Word file, which may be ANY file format" );

```
 
```

			Console.Error.WriteLine( "         recognized by Word." );

```
 
```

			Console.Error.WriteLine( "         If Word was already active when this program is started, any" );

```
 
```

			Console.Error.WriteLine( "         other opened document(s) will be left alone, and only the" );

```
 
```

			Console.Error.WriteLine( "         document opened by this program will be closed." );

```
 
```

			Console.Error.WriteLine( "         If Word is not available, the text can still be extracted, but" );

```
 
```

			Console.Error.WriteLine( "         only from .DOC, .DOCX, .ODT, .RTF and .WPD files." );

```
 
```

			Console.Error.WriteLine( "         This program requires .NET 4.5." );

```
 
```

			Console.Error.WriteLine( "         Return code (\"errorlevel\") 0 means no errors were encounterd" );

```
 
```

			Console.Error.WriteLine( "         and some text was extracted from the file; otherwise the" );

```
 
```

			Console.Error.WriteLine( "         return code will be 1." );

```
 
```
```
			Console.Error.WriteLine( );
```
```
 
```

			Console.Error.WriteLine( "Written by Rob van der Woude" );

```
 
```

			Console.Error.WriteLine( "https://www.robvanderwoude.com" );

```
 
```
```
			#endregion Display Help Text
```
```
 
```
```
 
```
```
			return 1;
```
```
		}
```
```
	}
```
```
}
```
```
 
```