{
* This Source Code Form is subject to the terms of the Mozilla Public License,
* v. 2.0. If a copy of the MPL was not distributed with this file, You can
* obtain one at http://mozilla.org/MPL/2.0/
*
* Copyright (C) 2005-2013, Peter Johnson (www.delphidabbler.com).
*
* $Rev$
* $Date$
*
* Defines a class that parses source files according to a given syntax
* highlighter brush and emits correctly styled highlighting elements.
}
unit CS.SourceCode.Hiliter.Parser;
interface
uses
// Delphi
Classes,
// 3rd party
SynEditHighlighter,
// Project
CS.SourceCode.Hiliter.Brushes;
type
/// <summary>Provides information about the brush and attribute that apply to
/// a syntax highlight element.</summary>
/// <remarks>Callers can use this information to determine the styling to
/// apply to the element.</remarks>
TSyntaxHiliteElemInfo = record
strict private
var
fBrushID: string;
fAttrID: string;
public
constructor Create(const ABrushID, AAttrID: string);
property BrushID: string read fBrushID;
property AttrID: string read fAttrID;
end;
/// <summary>Parses source code into different highlighting elements in a
/// manner dependant on a given syntax highlighter brush.</summary>
/// <remarks>Objects using this class are notified of each element via
/// events.</remarks>
TSyntaxHiliteParser = class(TObject)
public
type
/// <summary>Type of event triggered when a code element has been parsed.
/// </summary>
/// <remarks>Provides information about the element to handler.</remarks>
/// <param name="Parser">TObject [in] Reference to the parser object that
/// triggered event.</param>
/// <param name="AttrID">string [in] Identifies the highlight attribute
/// to be used to render ElemText. May be the empty string if no specific
/// attribute applies.</param>
/// <param name="ElemText">string [in] Text to be rendered.</param>
/// <remarks>The caller must determine how to style each highlight
/// atrribute.</remarks>
TParseElementEvent = procedure(Parser: TObject;
const ElemInfo: TSyntaxHiliteElemInfo; const ElemText: string)
of object;
strict private
var
/// <summary>Reference to OnElement event handler.</summary>
fOnElement: TParseElementEvent;
/// <summary>Reference to OnLineBegin event handler.</summary>
fOnLineBegin: TNotifyEvent;
/// <summary>Reference to OnLineEnd event handler.</summary>
fOnLineEnd: TNotifyEvent;
/// <summary>Performs the required highlighting operation on the given
/// source code.</summary>
/// <param name="Source">TStrings [in] Lines of source code to be
/// processed.</param>
/// <param name="Brush">TSyntaxHiliterBrush [in] Brush used to perform
/// the highlighting. Must not be a null brush.</param>
procedure DoHighlighting(const Source: TStrings;
const Brush: TSyntaxHiliterBrush);
/// <summary>Performs a null highlighting operation on the given source
/// code.</summary>
/// <param name="Source">TStrings [in] Lines of source code to be
/// processed.</param>
/// <param name="Brush">TSyntaxHiliterBrush [in] Null highlighter brush
/// that does the "highlighting". Must be a null brush.</param>
/// <remarks>The source is simply broken into lines which are emitted one
/// at a time.</remarks>
procedure DoNullHighlighting(const Source: TStrings;
const Brush: TSyntaxHiliterBrush);
strict protected
/// <summary>Triggers OnElement event for the given element text and
/// highlighting attribute.</summary>
procedure DoElement(const ElemInfo: TSyntaxHiliteElemInfo;
const ElemText: string);
/// <summary>Triggers OnLineBegin event.</summary>
procedure DoLineBegin; virtual;
/// <summary>Triggers OnLineEnd events.</summary>
procedure DoLineEnd; virtual;
public
/// <summary>Parses the given source code using the given highlighter
/// brush, triggering events to inform the caller of progress.</summary>
procedure Parse(const Source: string; const Brush: TSyntaxHiliterBrush);
/// <summary>Event triggered when a source element has been parsed to
/// inform the caller of text to be output and highlight attribute to be
/// used to render it.</summary>
property OnElement: TParseElementEvent read fOnElement write fOnElement;
/// <summary>Event triggered just before the first element on a new line is
/// parsed.</summary>
/// <remarks>Callers should emit any output required to open a new line.
/// </remarks>
property OnLineBegin: TNotifyEvent read fOnLineBegin write fOnLineBegin;
/// <summary>Event triggered at the end of each line of source code.
/// </summary>
/// <remarks>Calllers should emit any output required to end a line.
/// </remarks>
property OnLineEnd: TNotifyEvent read fOnLineEnd write fOnLineEnd;
end;
implementation
uses
// Project
UStrUtils;
{ TSyntaxHiliteParser }
procedure TSyntaxHiliteParser.DoElement(const ElemInfo: TSyntaxHiliteElemInfo;
const ElemText: string);
begin
if Assigned(fOnElement) then
fOnElement(Self, ElemInfo, ElemText);
end;
procedure TSyntaxHiliteParser.DoHighlighting(const Source: TStrings;
const Brush: TSyntaxHiliterBrush);
var
LineIdx: Integer;
Line: string;
Attr: TSynHighlighterAttributes;
Highlighter: TSynCustomHighlighter;
begin
Assert(not Brush.IsNull, ClassName + '.DoHighlighting: Brush is null');
// Do the parsing
Highlighter := Brush.CreateHighlighter;
try
Highlighter.ResetRange;
for LineIdx := 1 to Source.Count do // this is a 1-based loop deliberately
begin
DoLineBegin;
Line := StrTrimRight(Source[LineIdx - 1]); // trim trailing white space
// NOTE: LineIdx parameter to .SetLine seems to be redundant except in
// SynHighlighterMulti, which is not used here
Highlighter.SetLine(Line, LineIdx);
while not Highlighter.GetEOL do
begin
Attr := Highlighter.GetTokenAttribute;
// NOTE: We check there is an attribute since some highlighters can
// return a nil Attr: e.g. the Pascal highlighter does this if a
// trailing EOF or null terminates the code
if Assigned(Attr) then
DoElement(
TSyntaxHiliteElemInfo.Create(Brush.ID, Attr.Name),
Highlighter.GetToken
);
Highlighter.Next;
end;
DoLineEnd;
end;
finally
Highlighter.Free;
end;
end;
procedure TSyntaxHiliteParser.DoLineBegin;
begin
if Assigned(fOnLineBegin) then
fOnLineBegin(Self);
end;
procedure TSyntaxHiliteParser.DoLineEnd;
begin
if Assigned(fOnLineEnd) then
fOnLineEnd(Self);
end;
procedure TSyntaxHiliteParser.DoNullHighlighting(const Source: TStrings;
const Brush: TSyntaxHiliterBrush);
var
Line: string;
begin
for Line in Source do
begin
DoLineBegin;
DoElement(TSyntaxHiliteElemInfo.Create(Brush.ID, ''), Line);
DoLineEnd;
end;
end;
procedure TSyntaxHiliteParser.Parse(const Source: string;
const Brush: TSyntaxHiliterBrush);
var
Lines: TStringList;
begin
Assert(Assigned(Brush), ClassName + '.Parse: Brush is nil.');
// Split source code into lines, trimming leading and trailing blank lines
Lines := TStringList.Create;
try
Lines.Text := Source;
while (Lines.Count > 0) and StrIsBlank(Lines[Pred(Lines.Count)]) do
Lines.Delete(Pred(Lines.Count));
while (Lines.Count > 0) and StrIsBlank(Lines[0]) do
Lines.Delete(0);
if not Brush.IsNull then
DoHighlighting(Lines, Brush)
else
DoNullHighlighting(Lines, Brush);
finally
Lines.Free;
end
end;
{ TSyntaxHiliteElemInfo }
constructor TSyntaxHiliteElemInfo.Create(const ABrushID, AAttrID: string);
begin
fBrushID := ABrushID;
fAttrID := AAttrID;
end;
end.
