Prepare structure for the RTF parser

Author: manfromarce

src/DocSharp.Docx/DocxToRtf/DocxToRtfConverter.cs

@@ -28,6 +28,8 @@ public partial class DocxToRtfConverter : DocxToStringWriterBase<RtfStringWriter
     /// and escape other chars as '\xx (using code pages for chars 128-255)  
     /// or as \uc1\u{X} (using Unicode). 
     /// If an old reader does not support Unicode it will skip these characters rather than corrupting the document. 
+    /// This property only affects how the RTF file itself is written, 
+    /// and does not change how charactes are encoded in RTF text tokens. 
     /// </summary>
     public override Encoding DefaultEncoding => Encoding.ASCII; 
 

src/DocSharp.Docx/RtfToDocx/RtfControlWord.cs

@@ -0,0 +1,7 @@
+namespace DocSharp.Rtf;
+
+internal class RtfControlWord(string name) : RtfToken
+{
+    public string Name { get; set; } = name;
+}
+

src/DocSharp.Docx/RtfToDocx/RtfControlWordWithValue.cs

@@ -0,0 +1,10 @@
+namespace DocSharp.Rtf;
+
+internal class RtfControlWordWithValue<T>(string name, T value) : RtfToken
+{
+    public string Name { get; set; } = name;
+
+    public T Value { get; set; } = value;
+
+}
+

src/DocSharp.Docx/RtfToDocx/RtfDestination.cs

@@ -0,0 +1,6 @@
+namespace DocSharp.Rtf;
+
+internal class RtfDestination(string name) : RtfGroup(name)
+{
+}
+

src/DocSharp.Docx/RtfToDocx/RtfDocument.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace DocSharp.Rtf;
+
+internal class RtfDocument
+{
+    internal IEnumerable<RtfToken> Tokens = [];
+}
+

src/DocSharp.Docx/RtfToDocx/RtfGroup.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+
+namespace DocSharp.Rtf;
+
+internal class RtfGroup : RtfControlWord
+{
+    internal IEnumerable<RtfToken> Tokens;
+
+    public RtfGroup(string name) : base(name)
+    {
+        Tokens = [];
+    }
+}
+

src/DocSharp.Docx/RtfToDocx/RtfReader.cs

@@ -0,0 +1,57 @@
+using System.IO;
+using System.Text;
+
+namespace DocSharp.Rtf;
+
+internal static class RtfReader
+{
+#if !NETFRAMEWORK
+    static RtfReader()
+    {
+        Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
+    }
+#endif
+
+    public static RtfDocument ReadRtf(TextReader reader)
+    {
+        var rtf = new RtfDocument();
+
+        int i;
+        char currentChar = default;
+        char previousChar = default;
+        while ((i = reader.Read()) != -1)
+        {
+            previousChar = currentChar;
+            currentChar = (char)i;
+
+            switch (currentChar)
+            {
+                case '{':
+                    break;
+                case '}':
+                    break;
+                case '\\':
+                    break;
+                case '*':
+                    break;
+                default:
+                    if (char.IsDigit(currentChar))
+                    {
+                        
+                    }
+                    else if (IsEnglishLetter(currentChar))
+                    {
+                        
+                    }
+                    break;
+            }
+        }       
+
+        return rtf;
+    }
+
+    private static bool IsEnglishLetter(char c)
+    {
+        return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
+    }
+}

src/DocSharp.Docx/RtfToDocx/RtfText.cs

@@ -0,0 +1,9 @@
+namespace DocSharp.Rtf;
+
+internal class RtfText(string text) : RtfToken
+{
+    public string Text { get; set; } = text;
+
+    public RtfText() : this(string.Empty) { }
+}
+

src/DocSharp.Docx/RtfToDocx/RtfToDocxConverter.cs

@@ -12,17 +12,39 @@
 using System.Xml;
 using System.Diagnostics;
 using DocumentFormat.OpenXml;
+using DocSharp.Rtf;
 
 namespace DocSharp.Docx;
 
-internal class RtfToDocxConverter : ITextToDocxConverter
+public class RtfToDocxConverter : ITextToDocxConverter
 {
+    /// <summary>
+    /// RTF files typically use ASCII (chars 0-127) and escape other chars using 
+    /// code pages (e.g. \'e0 for "à") or Unicode (e.g. \u915 for Γ). 
+    /// Code pages specify chars 128-255, depend on the system region and are also called "ANSI". 
+    /// Unicode can encode many more characters and is often called "non-ANSI" in the RTF specification.  
+    /// The code page is specified by the \ansi (default), \mac, \pc or \pca control in the RTF header, 
+    /// optionally followed by \ansicpgN. For example \ansicpg1252 indicates Windows-1252 and is used by U.s. Windows 
+    /// (extends ASCII with other letters and symbols related to the english alphabet). 
+    /// If the code page is not specified, ANSI based on the system region is assumed. 
+    /// Despite this, it's possible the some old RTF files use non-ASCII-based code pages, 
+    /// or that some RTF writers directly write non-ASCII letters such as à into text tokens, 
+    /// although it's not standard. 
+    /// Therefore, the DefaultEncoding property exist, it can be set by passing a different inputEncoding parameter 
+    /// to the Convert methods; alternatively a TextReader initialized with the correct encoding can be directly passed. 
+    /// Libraries such as https://github.com/CharsetDetector/UTF-unknown can be used to detect uncommon encodings;  
+    /// they require the stream to be seekable, so DocSharp is not using this approach by default. 
+    /// Note: the DefaultEncoding property only affects how the raw RTF file is read 
+    /// (in particular the RTF header and control words), it does not change how text tokens are handled: 
+    /// special characters such as \'xx are still interpreted based on the code page detected by RtfReader. 
+    /// </summary>
+    public Encoding DefaultEncoding => Encoding.ASCII;
+
     /// <summary>
     /// Populate the target DOCX document with converted RTF content.
     /// </summary>
     /// <param name="input"></param>
     /// <param name="targetDocument"></param>
-    /// <exception cref="NotImplementedException"></exception>
     public void BuildDocx(TextReader input, WordprocessingDocument targetDocument)
     {
         if (targetDocument.MainDocumentPart == null)
@@ -31,9 +53,18 @@ public void BuildDocx(TextReader input, WordprocessingDocument targetDocument)
         if (targetDocument.MainDocumentPart!.Document == null)
             targetDocument.MainDocumentPart.Document = new Document();
 
-        // TODO
-        // var rtfDocument = ParseRtf(input);
-        // InsertRtf(rtfDocument, targetDocument);        
-        throw new NotImplementedException();
+        var rtfDocument = RtfReader.ReadRtf(input);
+        foreach (var token in rtfDocument.Tokens)
+        {
+            // TODO    
+        }
+    }
+
+    
+#if !NETFRAMEWORK
+    static RtfToDocxConverter()
+    {
+        Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
     }
-}
+#endif
+}

src/DocSharp.Docx/RtfToDocx/RtfToken.cs

@@ -0,0 +1,6 @@
+namespace DocSharp.Rtf;
+
+internal abstract class RtfToken
+{
+}
+