C#

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Text.RegularExpressions;

namespace SyntaxEngineClass
{
    
/// <summary>
    
/// 语法分析引擎基类
    
/// ZswangY37 wjhu111#21cn.com 2007-03-17 尊重作者,转贴请注明出处
    
/// 日期:2007-03-17
    
/// 设计:ZswangY37
    
/// 支持:wjhu111#21cn.com
    
/// 感谢CSDN中的kissknife、chinnel提供改进意见
    
/// http://community.csdn.net/Expert/TopicView.asp?id=5400165
    
/// </summary>

    class SyntaxEngine
    
{
        
/// <summary>
        
/// 语法项
        
/// </summary>

        public class SyntaxItem
        
{
            
private string FPattern; // 正则表达式
            private RegexOptions FOptions; // 正则表达式附加选项
            private string FName; // 语法名称
            private int FIndex; // 序号

            
public string Pattern get return FPattern; } } // 正则表达式
            public RegexOptions Options get return FOptions; } } // 正则表达式附加选项
            public string Name get return FName; } } // 名称
            public int Index get return FIndex; } } // 序号

            
public SyntaxItem(string APattern, RegexOptions AOptions,
                
string AName, int AIndex)
            
{
                FPattern 
= APattern;
                FOptions 
= AOptions;
                FName 
= AName;
                FIndex 
= AIndex;
            }

        }

        
/// <summary>
        
/// 语法分析返回项
        
/// </summary>

        public class AnalyzeReslut
        
{
            
private SyntaxItem FItem; // 所属语法项
            private string FBlock; // 文字块

            
public SyntaxItem Item get return FItem; } }
            
public string Block get return FBlock; } }

            
public AnalyzeReslut(SyntaxItem AItem, string ABlock)
            
{
                FItem 
= AItem;
                FBlock 
= ABlock;
            }

        }


        
private List<SyntaxItem> FSyntaxItems = new List<SyntaxItem>();
        
private List<AnalyzeReslut> FAnalyzeResluts = new List<AnalyzeReslut>();

        
public List<SyntaxItem> SyntaxItems get return FSyntaxItems; } }
        
public List<AnalyzeReslut> AnalyzeResluts get return FAnalyzeResluts; } }


        
/// <summary>
        
/// 进行语法分析
        
/// </summary>
        
/// <param name="ACode">所分析的代码</param>
        
/// <returns>返回分析是否成功</returns>

        public virtual bool Analyze(string ACode)
        
{
            
if (FSyntaxItems.Count <= 0)
                
return false;
            
if (ACode == null)
                
return false;
            AnalyzeResluts.Clear();
            
string vCode = ACode;
            
bool vFind = true;
            
while (vFind && (vCode.Length > 0))
            
{
                vFind 
= false;
                
foreach (SyntaxItem vSyntaxItem in FSyntaxItems)
                
{
                    
if (Regex.IsMatch(vCode, vSyntaxItem.Pattern, vSyntaxItem.Options))
                    
{
                        AnalyzeResluts.Add(
new AnalyzeReslut(vSyntaxItem,
                            Regex.Match(vCode, vSyntaxItem.Pattern,
                            vSyntaxItem.Options).Value));
                        vCode 
= Regex.Replace(vCode, vSyntaxItem.Pattern, "",
                            vSyntaxItem.Options);
                        vFind 
= true;
                        
break;
                    }

                }

            }

            
return true;
        }

    }


    
/// <summary>
    
/// C#语法分析引擎
    
/// ZswangY37 wjhu111#21cn.com 2007-03-17 尊重作者,转贴请注明出处
    
/// </summary>

    class CSharpEngine : SyntaxEngine
    
{
        
public CSharpEngine()
        
{
            SyntaxItems.Add(
new SyntaxItem(@"^\s+", RegexOptions.None,
                
"空白", SyntaxItems.Count));
            SyntaxItems.Add(
new SyntaxItem(@"^\/\/[^\n]*[\n]?", RegexOptions.None,
                
"单行注释", SyntaxItems.Count));
            SyntaxItems.Add(
new SyntaxItem(@"^\/\*.*?\*\/", RegexOptions.None,
                
"多行注释", SyntaxItems.Count));
            SyntaxItems.Add(
new SyntaxItem(@"^#\s*(define|elif|else|endif|endregion|" +
                
@"error|if|line|pragma|region|undef|using|warning)\b[^\n]*[\n]?",
                RegexOptions.None, 
"指令", SyntaxItems.Count));
            SyntaxItems.Add(
new SyntaxItem(@"^(abstract|event|new|struct|as|explicit|" +
                
@"null|switch|base|extern|object|this|bool|false|operator|throw|break|" +
                
@"finally|out|true|byte|fixed|override|try|case|float|params|typeof|" +
                
@"catch|for|private|uint|char|foreach|protected|ulong|checked|goto|" +
                
@"public|unchecked|class|if|readonly|unsafe|const|implicit|ref|ushort|" +
                
@"continue|in|return|using|decimal|int|sbyte|virtual|default|interface|" +
                
@"sealed|volatile|delegate|internal|short|void|do|is|sizeof|while|" +
                
@"double|lock|stackalloc|else|long|static|enum|namespace|string)\b",
                RegexOptions.None, 
"关键字", SyntaxItems.Count));
            SyntaxItems.Add(
new SyntaxItem(@"^(get|partial|set|value|where|yield)\b",
                RegexOptions.None, 
"上下文关键字", SyntaxItems.Count));
            SyntaxItems.Add(
new SyntaxItem(@"^(\+\=|\-\=|\&\&|\|\||\/\=|\&\=|\%\=|\~|\!|\+\+|\-\-|" +
                
@"\#|\$|\%|\^|\&|\*|\(|\)|\+|\-|\=|\{|\}|\[|\]|\\|\;|\:|\<|\>|\?|\,|\.|\/)+",
                RegexOptions.None, 
"标点符号", SyntaxItems.Count));
            SyntaxItems.Add(
new SyntaxItem(@"^(\d+(?!\.|x|e|d|m)u?)|^0x([\da-f]+(?!\.|x|m)u?)",
                RegexOptions.IgnoreCase, 
"整数", SyntaxItems.Count));
            SyntaxItems.Add(
new SyntaxItem(@"^(\d+)?\.\d+((\+|\-)?e\d+)?(m|d|f)?|^\d+((\+|\-)?e\d+)?(m|d|f)",
                RegexOptions.IgnoreCase, 
"浮点数", SyntaxItems.Count));
            SyntaxItems.Add(
new SyntaxItem(@"^@""(("""")*([^""])*)*""|^""((\\\\)*(\\"")*(\\[a-z])*[^""^\\]*)*""",
                RegexOptions.None, 
"字符串", SyntaxItems.Count));
            SyntaxItems.Add(
new SyntaxItem(@"^\'(\\\')*[^\']*\'", RegexOptions.None,
                
"字符", SyntaxItems.Count));
            SyntaxItems.Add(
new SyntaxItem(@"^\w*", RegexOptions.None,
                
"标识符", SyntaxItems.Count));
        }

    }


    
/// <summary>
    
/// 语法高亮引擎
    
/// ZswangY37 wjhu111#21cn.com 2007-03-17 尊重作者,转贴请注明出处
    
/// </summary>

    class SyntaxHighlight
    
{
        
public class HighlightItem
        
{
            
private Color FForeColor; // 前景色
            private bool FBold; // 是否加粗
            private bool FItalic; // 是否斜体
            private bool FUnderline; // 是否下划线
            public Color ForeColor get return FForeColor; } } // 前景色
            public bool Bold get return FBold; } } // 是否加粗
            public bool Italic get return FItalic; } } // 是否斜体
            public bool Underline get return FUnderline; } } // 是否下划线
            public HighlightItem(Color AForeColor, bool ABold, bool AItalic, bool AUnderline)
            
{
                FForeColor 
= AForeColor;
                FBold 
= ABold;
                FItalic 
= AItalic;
                FUnderline 
= AUnderline;
            }

        }

        
private List<SyntaxEngine.AnalyzeReslut> FAnalyzeResluts;
        
private Font FDefaultFont;
        
private List<HighlightItem> FHighlightItems = new List<HighlightItem>();
        
public List<HighlightItem> HighlightItems get return FHighlightItems; } }
        
public SyntaxHighlight(SyntaxEngine ASyntaxEngine, Font
            ADefaultFont)
        
{
            FAnalyzeResluts 
= ASyntaxEngine.AnalyzeResluts;
            FDefaultFont 
= ADefaultFont;
        }

        
/// <summary>
        
/// 将文本中的RTF元素处理掉
        
/// </summary>
        
/// <param name="AText">输入的文本</param>
        
/// <returns>返回处理后的RTF文本</returns>

        public string TextToRtf(string AText)
        
{
            
string Result = "";
            
foreach (char vChar in AText)
            
{
                
switch (vChar)
                
{
                
case '\\':
                    Result 
+= @"\\";
                    
break;
                
case '{':
                    Result 
+= @"\{";
                    
break;
                
case '}':
                    Result 
+= @"\}";
                    
break;
                
default:
                    
if (vChar > (char127)
                        Result 
+= @"\u" + ((int) vChar).ToString() + "?";
                    
else
                        Result 
+= vChar;
                    
break;
                }

            }

            
return Result;
        }


        [DllImport(
"user32.dll")]
        
private static extern uint GetKBCodePage();
        [DllImport(
"kernel32.dll")]
        
private static extern ushort GetSystemDefaultLangID();

        
/// <summary>
        
/// 将代码处理成RTF格式
        
/// </summary>
        
/// <returns>返回处理后的RTF文本</returns>

        public string MakeRtf()
        
{
            
if (HighlightItems.Count <= 0)
                
return "";
            
string Result = @"{\rtf1\ansi\ansicpg" + GetKBCodePage().ToString() +
                
@"\deff0\deflang1033\deflangfe" + GetSystemDefaultLangID().ToString() +
                
@"{\fonttbl{\f0\fmodern " +
                FDefaultFont.Name 
+ ";}}\r\n";
            Result 
+= @"{\colortbl ;";
            
foreach (HighlightItem vHighlightItem in HighlightItems)
                Result 
+= string.Format(@"\red{0}\green{1}\blue{2};",
                    vHighlightItem.ForeColor.R, vHighlightItem.ForeColor.G,
                    vHighlightItem.ForeColor.B);
            Result 
+= "}\r\n";
            Result 
+= @"\viewkind4\uc1\pard\f0\fs20" + "\r\n";
            
bool vBold = false, vItalic = false, vUnderline = false;
            
foreach (SyntaxEngine.AnalyzeReslut vAnalyzeReslut in
              FAnalyzeResluts)
            
{
                
int i = vAnalyzeReslut.Item.Index;
                
if (i >= HighlightItems.Count)
                    i 
= 0;
                
if (vBold != HighlightItems[i].Bold)
                
{
                    
if (HighlightItems[i].Bold)
                        Result 
+= @"\b1";
                    
else
                        Result 
+= @"\b0";
                }

                
if (vItalic != HighlightItems[i].Italic)
                
{
                    
if (HighlightItems[i].Italic)
                        Result 
+= @"\i1";
                    
else
                        Result 
+= @"\i0";
                }

                
if (vItalic != HighlightItems[i].Underline)
                
{
                    
if (HighlightItems[i].Underline)
                        Result 
+= @"\ul1";
                    
else
                        Result 
+= @"\ul0";
                }

                Result 
+= string.Format(@"\cf{0} ", i + 1);
                vBold 
= HighlightItems[i].Bold;
                vItalic 
= HighlightItems[i].Italic;
                vUnderline 
= HighlightItems[i].Underline;
                Result 
+= TextToRtf(vAnalyzeReslut.Block).Replace("\r\n",
                    
"\r\n" + @"\par");
            }

            
return Result + "}";
        }


        
/// <summary>
        
/// 将文本中的HTML元素处理掉
        
/// </summary>
        
/// <param name="AText">输入的文本</param>
        
/// <returns>返回处理后的HTML文本</returns>

        private string TextToHtml(string AText)
        
{
            
string Result = "";
            
foreach (char vChar in AText)
            
{
                
switch (vChar)
                
{
                
case '&':
                    Result 
+= @"&amp;";
                    
break;
                
case ' ':
                    Result 
+= @"&nbsp;";
                    
break;
                
case '<':
                    Result 
+= @"&lt;";
                    
break;
                
case '>':
                    Result 
+= @"&gt;";
                    
break;
                
case '"':
                    Result 
+= @"&quot;";
                    
break;
                
//case '\n':
                
//    Result += @"<br>";
                
//    break;
                default:
                    
if (vChar > (char127)
                        Result 
+= @"&#" + ((int) vChar).ToString() + ";";
                    
else
                        Result 
+= vChar;
                    
break;
                }

            }

            
return Result;
        }


        
/// <summary>
        
/// 将颜色处理为HTML表达的方式
        
/// </summary>
        
/// <param name="AColor">输入的颜色</param>
        
/// <returns>返回HTML颜色表达式</returns>

        private string ColorToHtml(Color AColor)
        
{
            
return string.Format("#{0:X2}{1:X2}{2:X2}", AColor.R, AColor.G, AColor.B);
        }


        
/// <summary>
        
/// 将代码处理为HTML文本
        
/// </summary>
        
/// <returns>返回处理后的HTML文本</returns>

        public string MakeHtml()
        
{
            
string Result = @"<code><pre style=""font-size:" + FDefaultFont.Size +
                
@"pt;font-family:" + FDefaultFont.Name + @""">";
            
foreach (SyntaxEngine.AnalyzeReslut vAnalyzeReslut in
              FAnalyzeResluts)
            
{
                
int i = vAnalyzeReslut.Item.Index;
                
if (i >= HighlightItems.Count)
                    i 
= 0;
                
string vLeft = string.Format(@"<span style=""color={0}"">",
                    ColorToHtml(HighlightItems[i].ForeColor));
                
string vRight = "</span>";
                
if (HighlightItems[i].Bold)
                
{
                    vLeft 
+= "<b>";
                    vRight 
= "</b>" + vRight;
                }

                
if (HighlightItems[i].Italic)
                
{
                    vLeft 
+= "<i>";
                    vRight 
= "</i>" + vRight;
                }

                
if (HighlightItems[i].Underline)
                
{
                    vLeft 
+= "<u>";
                    vRight 
= "</u>" + vRight;
                }


                Result 
+= vLeft + TextToHtml(vAnalyzeReslut.Block) + vRight;
            }


            
return Result + "</pre></code>";
        }

    }


    
/// <summary>
    
/// C#语法高亮引擎
    
/// </summary>

    class CSharpHighlight : SyntaxHighlight
    
{
        
public CSharpHighlight(SyntaxEngine ASyntaxEngine, Font
            ADefaultFont)
            : 
base(ASyntaxEngine, ADefaultFont)
        
{
            
//空白
            HighlightItems.Add(new HighlightItem(Color.White, falsefalsefalse));
            
//单行注释
            HighlightItems.Add(new HighlightItem(Color.Green, falsefalsefalse));
            
//多行注释
            HighlightItems.Add(new HighlightItem(Color.Green, falsefalsefalse));
            
//指令
            HighlightItems.Add(new HighlightItem(Color.Blue, falsefalsefalse));
            
//关键字
            HighlightItems.Add(new HighlightItem(Color.Black, truefalsefalse));
            
//上下文关键字
            HighlightItems.Add(new HighlightItem(Color.Black, truefalsefalse));
            
//标点符号
            HighlightItems.Add(new HighlightItem(Color.BlueViolet, falsefalsefalse));
            
//整数
            HighlightItems.Add(new HighlightItem(Color.Red, truefalsefalse));
            
//浮点数
            HighlightItems.Add(new HighlightItem(Color.Red, truefalsefalse));
            
//字符串
            HighlightItems.Add(new HighlightItem(Color.Maroon, falsefalsefalse));
            
//字符
            HighlightItems.Add(new HighlightItem(Color.Maroon, falsefalsefalse));
            
//标识符
            HighlightItems.Add(new HighlightItem(Color.Black, falsefalsefalse));
        }

    }

}
posted on 2007-08-19 03:17  max chan  阅读(2689)  评论(0编辑  收藏  举报