You've already forked lazarus-ccr
75fd4af778
git-svn-id: https://svn.code.sf.net/p/lazarus-ccr/svn@6321 8e941d3f-bd1b-0410-a28a-d453659cc2b4
1450 lines
41 KiB
ObjectPascal
1450 lines
41 KiB
ObjectPascal
{-------------------------------------------------------------------------------
|
|
The contents of this file are subject to the Mozilla Public License
|
|
Version 1.1 (the "License"); you may not use this file except in compliance
|
|
with the License. You may obtain a copy of the License at
|
|
http://www.mozilla.org/MPL/
|
|
Software distributed under the License is distributed on an "AS IS" basis,
|
|
WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
|
|
the specific language governing rights and limitations under the License.
|
|
|
|
The Original Code is: SynHighlighterLua.pas, the Initial
|
|
Author of this file is Zhou Kan.
|
|
All Rights Reserved.
|
|
|
|
Contributors to the SynEdit and mwEdit projects are listed in the
|
|
Contributors.txt file.
|
|
|
|
Alternatively, the contents of this file may be used under the terms of the
|
|
GNU General Public License Version 2 or later (the "GPL"), in which case
|
|
the provisions of the GPL are applicable instead of those above.
|
|
If you wish to allow use of your version of this file only under the terms
|
|
of the GPL and not to allow others to use your version of this file
|
|
under the MPL, indicate your decision by deleting the provisions above and
|
|
replace them with the notice and other provisions required by the GPL.
|
|
If you do not delete the provisions above, a recipient may use your version
|
|
of this file under either the MPL or the GPL.
|
|
|
|
$Id: SynHighlighterLua.pas,v 1.00 2005/01/24 17:58:27 Kan Exp $
|
|
|
|
You may retrieve the latest version of this file at the SynEdit home page,
|
|
located at http://SynEdit.SourceForge.net
|
|
|
|
Known Issues:
|
|
-------------------------------------------------------------------------------}
|
|
{
|
|
@abstract(Provides a Lua Script highlighter for SynEdit)
|
|
@author(Zhou Kan [textrush@tom.com])
|
|
@created(June 2004)
|
|
@lastmod(2005-01-24)
|
|
The SynHighlighterLua unit provides SynEdit with a Lua Script (*.lua) highlighter.
|
|
The highlighter formats Lua Script source code highlighting keywords, strings, numbers and characters.
|
|
}
|
|
|
|
unit SynHighlighterLua;
|
|
|
|
// extrasyn.inc is the synedit.inc from laz 1.2.0 synedit package source,
|
|
// If it has changed in newer version you might need to copy it again.
|
|
// Remember to redclare the syn_lazarus define.
|
|
{$I extrasyn.inc}
|
|
|
|
interface
|
|
|
|
uses
|
|
SysUtils, Classes, Graphics, SynEditHighlighter, SynEditTypes, SynEditStrConst;
|
|
|
|
type
|
|
TtkTokenKind = (
|
|
tkComment,
|
|
tkFunction,
|
|
tkIdentifier,
|
|
tkKey,
|
|
tkNull,
|
|
tkNumber,
|
|
tkSpace,
|
|
tkString,
|
|
tkSymbol,
|
|
tkUnknown);
|
|
|
|
TRangeState = (rsUnKnown, rsComment, rsString, rsQuoteString, rsMultilineString);
|
|
|
|
TProcTableProc = procedure of object;
|
|
|
|
PIdentFuncTableFunc = ^TIdentFuncTableFunc;
|
|
TIdentFuncTableFunc = function: TtkTokenKind of object;
|
|
|
|
const
|
|
MaxKey = 185;
|
|
|
|
type
|
|
TSynLuaSyn = class(TSynCustomHighlighter)
|
|
private
|
|
fLineRef: string;
|
|
fLine: PChar;
|
|
fLineNumber: Integer;
|
|
fProcTable: array[#0..#255] of TProcTableProc;
|
|
fRange: TRangeState;
|
|
Run: LongInt;
|
|
fStringLen: Integer;
|
|
fToIdent: PChar;
|
|
fTokenPos: Integer;
|
|
fTokenID: TtkTokenKind;
|
|
fIdentFuncTable: array[0 .. MaxKey] of TIdentFuncTableFunc;
|
|
fCommentAttri: TSynHighlighterAttributes;
|
|
fFunctionAttri: TSynHighlighterAttributes;
|
|
fIdentifierAttri: TSynHighlighterAttributes;
|
|
fKeyAttri: TSynHighlighterAttributes;
|
|
fNumberAttri: TSynHighlighterAttributes;
|
|
fSpaceAttri: TSynHighlighterAttributes;
|
|
fStringAttri: TSynHighlighterAttributes;
|
|
fSymbolAttri: TSynHighlighterAttributes;
|
|
function KeyHash(ToHash: PChar): Integer;
|
|
function KeyComp(const aKey: string): Boolean;
|
|
function Func17: TtkTokenKind;
|
|
function Func19: TtkTokenKind;
|
|
function Func21: TtkTokenKind;
|
|
function Func22: TtkTokenKind;
|
|
function Func25: TtkTokenKind;
|
|
function Func26: TtkTokenKind;
|
|
function Func31: TtkTokenKind;
|
|
function Func32: TtkTokenKind;
|
|
function Func33: TtkTokenKind;
|
|
function Func34: TtkTokenKind;
|
|
function Func35: TtkTokenKind;
|
|
function Func37: TtkTokenKind;
|
|
function Func38: TtkTokenKind;
|
|
function Func39: TtkTokenKind;
|
|
function Func40: TtkTokenKind;
|
|
function Func41: TtkTokenKind;
|
|
function Func42: TtkTokenKind;
|
|
function Func44: TtkTokenKind;
|
|
function Func45: TtkTokenKind;
|
|
function Func46: TtkTokenKind;
|
|
function Func47: TtkTokenKind;
|
|
function Func48: TtkTokenKind;
|
|
function Func49: TtkTokenKind;
|
|
function Func50: TtkTokenKind;
|
|
function Func51: TtkTokenKind;
|
|
function Func52: TtkTokenKind;
|
|
function Func53: TtkTokenKind;
|
|
function Func56: TtkTokenKind;
|
|
function Func57: TtkTokenKind;
|
|
function Func60: TtkTokenKind;
|
|
function Func62: TtkTokenKind;
|
|
function Func63: TtkTokenKind;
|
|
function Func66: TtkTokenKind;
|
|
function Func67: TtkTokenKind;
|
|
function Func70: TtkTokenKind;
|
|
function Func71: TtkTokenKind;
|
|
function Func73: TtkTokenKind;
|
|
function Func74: TtkTokenKind;
|
|
function Func75: TtkTokenKind;
|
|
function Func76: TtkTokenKind;
|
|
function Func78: TtkTokenKind;
|
|
function Func79: TtkTokenKind;
|
|
function Func80: TtkTokenKind;
|
|
function Func81: TtkTokenKind;
|
|
function Func82: TtkTokenKind;
|
|
function Func83: TtkTokenKind;
|
|
function Func84: TtkTokenKind;
|
|
function Func88: TtkTokenKind;
|
|
function Func89: TtkTokenKind;
|
|
function Func90: TtkTokenKind;
|
|
function Func92: TtkTokenKind;
|
|
function Func94: TtkTokenKind;
|
|
function Func95: TtkTokenKind;
|
|
function Func97: TtkTokenKind;
|
|
function Func99: TtkTokenKind;
|
|
function Func101: TtkTokenKind;
|
|
function Func102: TtkTokenKind;
|
|
function Func105: TtkTokenKind;
|
|
function Func107: TtkTokenKind;
|
|
function Func108: TtkTokenKind;
|
|
function Func110: TtkTokenKind;
|
|
function Func111: TtkTokenKind;
|
|
function Func112: TtkTokenKind;
|
|
function Func113: TtkTokenKind;
|
|
function Func114: TtkTokenKind;
|
|
function Func116: TtkTokenKind;
|
|
function Func117: TtkTokenKind;
|
|
function Func125: TtkTokenKind;
|
|
function Func130: TtkTokenKind;
|
|
function Func132: TtkTokenKind;
|
|
function Func135: TtkTokenKind;
|
|
function Func137: TtkTokenKind;
|
|
function Func138: TtkTokenKind;
|
|
function Func141: TtkTokenKind;
|
|
function Func143: TtkTokenKind;
|
|
function Func144: TtkTokenKind;
|
|
function Func147: TtkTokenKind;
|
|
function Func149: TtkTokenKind;
|
|
function Func185: TtkTokenKind;
|
|
function AltFunc: TtkTokenKind;
|
|
procedure InitIdent;
|
|
function IdentKind(MayBe: PChar): TtkTokenKind;
|
|
procedure MakeMethodTables;
|
|
procedure NullProc;
|
|
procedure SpaceProc;
|
|
procedure CRProc;
|
|
procedure LFProc;
|
|
procedure IdentProc;
|
|
procedure NumberProc;
|
|
procedure UnknownProc;
|
|
procedure CommentProc;
|
|
procedure StringProc;
|
|
procedure QuoteStringProc;
|
|
procedure StringEndProc;
|
|
procedure BraceCloseProc;
|
|
procedure BraceOpenProc;
|
|
procedure GreaterProc;
|
|
procedure LowerProc;
|
|
procedure RoundCloseProc;
|
|
procedure RoundOpenProc;
|
|
procedure SquareCloseProc;
|
|
procedure SquareOpenProc;
|
|
procedure ColonProc;
|
|
procedure CommaProc;
|
|
procedure SemiColonProc;
|
|
procedure PointProc;
|
|
procedure DirectiveProc;
|
|
procedure EqualProc;
|
|
procedure PlusProc;
|
|
procedure StarProc;
|
|
procedure SlashProc;
|
|
procedure ModSymbolProc;
|
|
procedure AndSymbolProc;
|
|
procedure NotSymbolProc;
|
|
procedure OrSymbolProc;
|
|
procedure TildeProc;
|
|
procedure ArrowProc;
|
|
procedure QuestionProc;
|
|
protected
|
|
function GetIdentChars: TSynIdentChars; override;
|
|
function IsFilterStored: Boolean; override;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
function GetRange: Pointer; override;
|
|
procedure ResetRange; override;
|
|
procedure SetRange(Value: Pointer); override;
|
|
function GetDefaultAttribute(Index: integer): TSynHighlighterAttributes; override;
|
|
function GetEol: Boolean; override;
|
|
function GetTokenID: TtkTokenKind;
|
|
procedure SetLine(const NewValue: String; LineNumber: Integer); override;
|
|
function GetToken: String; override;
|
|
{$IFDEF SYN_LAZARUS}
|
|
procedure GetTokenEx(out TokenStart :PChar; out TokenLength :integer); override;
|
|
{$ENDIF}
|
|
function GetTokenAttribute: TSynHighlighterAttributes; override;
|
|
function GetTokenKind: integer; override;
|
|
function GetTokenPos: Integer; override;
|
|
procedure Next; override;
|
|
class function GetLanguageName :string; override;
|
|
published
|
|
property CommentAttri: TSynHighlighterAttributes read fCommentAttri write fCommentAttri;
|
|
property FunctionAttri: TSynHighlighterAttributes read fFunctionAttri write fFunctionAttri;
|
|
property IdentifierAttri: TSynHighlighterAttributes read fIdentifierAttri write fIdentifierAttri;
|
|
property KeyAttri: TSynHighlighterAttributes read fKeyAttri write fKeyAttri;
|
|
property NumberAttri: TSynHighlighterAttributes read fNumberAttri write fNumberAttri;
|
|
property SpaceAttri: TSynHighlighterAttributes read fSpaceAttri write fSpaceAttri;
|
|
property StringAttri: TSynHighlighterAttributes read fStringAttri write fStringAttri;
|
|
property SymbolAttri: TSynHighlighterAttributes read fSymbolAttri write fSymbolAttri;
|
|
end;
|
|
|
|
implementation
|
|
|
|
uses
|
|
SynEditStrConstExtra;
|
|
|
|
var
|
|
Identifiers: array[#0..#255] of ByteBool;
|
|
mHashTable : array[#0..#255] of Integer;
|
|
|
|
procedure MakeIdentTable;
|
|
var
|
|
I: Char;
|
|
begin
|
|
for I := #0 to #255 do
|
|
begin
|
|
case I of
|
|
'_', 'a'..'z', 'A'..'Z', '0'..'9': Identifiers[I] := True;
|
|
else
|
|
Identifiers[I] := False;
|
|
end;
|
|
case I in ['_', 'A'..'Z', 'a'..'z'] of
|
|
True:
|
|
begin
|
|
if (I > #64) and (I < #91) then
|
|
mHashTable[I] := Ord(I) - 64
|
|
else if (I > #96) then
|
|
mHashTable[I] := Ord(I) - 95;
|
|
end;
|
|
else
|
|
mHashTable[I] := 0;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.InitIdent;
|
|
var
|
|
I: Integer;
|
|
pF: PIdentFuncTableFunc;
|
|
begin
|
|
pF := PIdentFuncTableFunc(@fIdentFuncTable);
|
|
for I := Low(fIdentFuncTable) to High(fIdentFuncTable) do
|
|
begin
|
|
pF^ := {$IFDEF FPC}@{$ENDIF}AltFunc;
|
|
Inc(pF);
|
|
end;
|
|
fIdentFuncTable[17] := {$IFDEF FPC}@{$ENDIF}Func17;
|
|
fIdentFuncTable[19] := {$IFDEF FPC}@{$ENDIF}Func19;
|
|
fIdentFuncTable[21] := {$IFDEF FPC}@{$ENDIF}Func21;
|
|
fIdentFuncTable[22] := {$IFDEF FPC}@{$ENDIF}Func22;
|
|
fIdentFuncTable[25] := {$IFDEF FPC}@{$ENDIF}Func25;
|
|
fIdentFuncTable[26] := {$IFDEF FPC}@{$ENDIF}Func26;
|
|
fIdentFuncTable[31] := {$IFDEF FPC}@{$ENDIF}Func31;
|
|
fIdentFuncTable[32] := {$IFDEF FPC}@{$ENDIF}Func32;
|
|
fIdentFuncTable[33] := {$IFDEF FPC}@{$ENDIF}Func33;
|
|
fIdentFuncTable[34] := {$IFDEF FPC}@{$ENDIF}Func34;
|
|
fIdentFuncTable[35] := {$IFDEF FPC}@{$ENDIF}Func35;
|
|
fIdentFuncTable[37] := {$IFDEF FPC}@{$ENDIF}Func37;
|
|
fIdentFuncTable[38] := {$IFDEF FPC}@{$ENDIF}Func38;
|
|
fIdentFuncTable[39] := {$IFDEF FPC}@{$ENDIF}Func39;
|
|
fIdentFuncTable[40] := {$IFDEF FPC}@{$ENDIF}Func40;
|
|
fIdentFuncTable[41] := {$IFDEF FPC}@{$ENDIF}Func41;
|
|
fIdentFuncTable[42] := {$IFDEF FPC}@{$ENDIF}Func42;
|
|
fIdentFuncTable[44] := {$IFDEF FPC}@{$ENDIF}Func44;
|
|
fIdentFuncTable[45] := {$IFDEF FPC}@{$ENDIF}Func45;
|
|
fIdentFuncTable[46] := {$IFDEF FPC}@{$ENDIF}Func46;
|
|
fIdentFuncTable[47] := {$IFDEF FPC}@{$ENDIF}Func47;
|
|
fIdentFuncTable[48] := {$IFDEF FPC}@{$ENDIF}Func48;
|
|
fIdentFuncTable[49] := {$IFDEF FPC}@{$ENDIF}Func49;
|
|
fIdentFuncTable[50] := {$IFDEF FPC}@{$ENDIF}Func50;
|
|
fIdentFuncTable[51] := {$IFDEF FPC}@{$ENDIF}Func51;
|
|
fIdentFuncTable[52] := {$IFDEF FPC}@{$ENDIF}Func52;
|
|
fIdentFuncTable[53] := {$IFDEF FPC}@{$ENDIF}Func53;
|
|
fIdentFuncTable[56] := {$IFDEF FPC}@{$ENDIF}Func56;
|
|
fIdentFuncTable[57] := {$IFDEF FPC}@{$ENDIF}Func57;
|
|
fIdentFuncTable[60] := {$IFDEF FPC}@{$ENDIF}Func60;
|
|
fIdentFuncTable[62] := {$IFDEF FPC}@{$ENDIF}Func62;
|
|
fIdentFuncTable[63] := {$IFDEF FPC}@{$ENDIF}Func63;
|
|
fIdentFuncTable[66] := {$IFDEF FPC}@{$ENDIF}Func66;
|
|
fIdentFuncTable[67] := {$IFDEF FPC}@{$ENDIF}Func67;
|
|
fIdentFuncTable[70] := {$IFDEF FPC}@{$ENDIF}Func70;
|
|
fIdentFuncTable[71] := {$IFDEF FPC}@{$ENDIF}Func71;
|
|
fIdentFuncTable[73] := {$IFDEF FPC}@{$ENDIF}Func73;
|
|
fIdentFuncTable[74] := {$IFDEF FPC}@{$ENDIF}Func74;
|
|
fIdentFuncTable[75] := {$IFDEF FPC}@{$ENDIF}Func75;
|
|
fIdentFuncTable[76] := {$IFDEF FPC}@{$ENDIF}Func76;
|
|
fIdentFuncTable[78] := {$IFDEF FPC}@{$ENDIF}Func78;
|
|
fIdentFuncTable[79] := {$IFDEF FPC}@{$ENDIF}Func79;
|
|
fIdentFuncTable[80] := {$IFDEF FPC}@{$ENDIF}Func80;
|
|
fIdentFuncTable[81] := {$IFDEF FPC}@{$ENDIF}Func81;
|
|
fIdentFuncTable[82] := {$IFDEF FPC}@{$ENDIF}Func82;
|
|
fIdentFuncTable[83] := {$IFDEF FPC}@{$ENDIF}Func83;
|
|
fIdentFuncTable[84] := {$IFDEF FPC}@{$ENDIF}Func84;
|
|
fIdentFuncTable[88] := {$IFDEF FPC}@{$ENDIF}Func88;
|
|
fIdentFuncTable[89] := {$IFDEF FPC}@{$ENDIF}Func89;
|
|
fIdentFuncTable[90] := {$IFDEF FPC}@{$ENDIF}Func90;
|
|
fIdentFuncTable[92] := {$IFDEF FPC}@{$ENDIF}Func92;
|
|
fIdentFuncTable[94] := {$IFDEF FPC}@{$ENDIF}Func94;
|
|
fIdentFuncTable[95] := {$IFDEF FPC}@{$ENDIF}Func95;
|
|
fIdentFuncTable[97] := {$IFDEF FPC}@{$ENDIF}Func97;
|
|
fIdentFuncTable[99] := {$IFDEF FPC}@{$ENDIF}Func99;
|
|
fIdentFuncTable[101] := {$IFDEF FPC}@{$ENDIF}Func101;
|
|
fIdentFuncTable[102] := {$IFDEF FPC}@{$ENDIF}Func102;
|
|
fIdentFuncTable[105] := {$IFDEF FPC}@{$ENDIF}Func105;
|
|
fIdentFuncTable[107] := {$IFDEF FPC}@{$ENDIF}Func107;
|
|
fIdentFuncTable[108] := {$IFDEF FPC}@{$ENDIF}Func108;
|
|
fIdentFuncTable[110] := {$IFDEF FPC}@{$ENDIF}Func110;
|
|
fIdentFuncTable[111] := {$IFDEF FPC}@{$ENDIF}Func111;
|
|
fIdentFuncTable[112] := {$IFDEF FPC}@{$ENDIF}Func112;
|
|
fIdentFuncTable[113] := {$IFDEF FPC}@{$ENDIF}Func113;
|
|
fIdentFuncTable[114] := {$IFDEF FPC}@{$ENDIF}Func114;
|
|
fIdentFuncTable[116] := {$IFDEF FPC}@{$ENDIF}Func116;
|
|
fIdentFuncTable[117] := {$IFDEF FPC}@{$ENDIF}Func117;
|
|
fIdentFuncTable[125] := {$IFDEF FPC}@{$ENDIF}Func125;
|
|
fIdentFuncTable[130] := {$IFDEF FPC}@{$ENDIF}Func130;
|
|
fIdentFuncTable[132] := {$IFDEF FPC}@{$ENDIF}Func132;
|
|
fIdentFuncTable[135] := {$IFDEF FPC}@{$ENDIF}Func135;
|
|
fIdentFuncTable[137] := {$IFDEF FPC}@{$ENDIF}Func137;
|
|
fIdentFuncTable[138] := {$IFDEF FPC}@{$ENDIF}Func138;
|
|
fIdentFuncTable[141] := {$IFDEF FPC}@{$ENDIF}Func141;
|
|
fIdentFuncTable[143] := {$IFDEF FPC}@{$ENDIF}Func143;
|
|
fIdentFuncTable[144] := {$IFDEF FPC}@{$ENDIF}Func144;
|
|
fIdentFuncTable[147] := {$IFDEF FPC}@{$ENDIF}Func147;
|
|
fIdentFuncTable[149] := {$IFDEF FPC}@{$ENDIF}Func149;
|
|
fIdentFuncTable[185] := {$IFDEF FPC}@{$ENDIF}Func185;
|
|
end;
|
|
|
|
function TSynLuaSyn.KeyHash(ToHash: PChar): Integer;
|
|
begin
|
|
Result := 0;
|
|
while ToHash^ in ['_', 'a'..'z', 'A'..'Z', '0'..'9'] do
|
|
begin
|
|
inc(Result, mHashTable[ToHash^]);
|
|
inc(ToHash);
|
|
end;
|
|
fStringLen := ToHash - fToIdent;
|
|
end;
|
|
|
|
function TSynLuaSyn.KeyComp(const aKey :string) :Boolean;
|
|
var
|
|
I: Integer;
|
|
Temp: PChar;
|
|
begin
|
|
Temp := fToIdent;
|
|
if Length(aKey) = fStringLen then
|
|
begin
|
|
Result := True;
|
|
for i := 1 to fStringLen do
|
|
begin
|
|
if Temp^ <> aKey[i] then
|
|
begin
|
|
Result := False;
|
|
break;
|
|
end;
|
|
inc(Temp);
|
|
end;
|
|
end else Result := False;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func17: TtkTokenKind;
|
|
begin
|
|
if KeyComp('if') then Result := tkKey else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func19: TtkTokenKind;
|
|
begin
|
|
if KeyComp('deg') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func21: TtkTokenKind;
|
|
begin
|
|
if KeyComp('do') then Result := tkKey else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func22: TtkTokenKind;
|
|
begin
|
|
if KeyComp('and') then Result := tkKey else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func25: TtkTokenKind;
|
|
begin
|
|
if KeyComp('PI') then Result := tkFunction else
|
|
if KeyComp('abs') then Result := tkFunction else
|
|
if KeyComp('in') then Result := tkKey else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func26: TtkTokenKind;
|
|
begin
|
|
if KeyComp('end') then Result := tkKey else
|
|
if KeyComp('rad') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func31: TtkTokenKind;
|
|
begin
|
|
if KeyComp('tag') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func32: TtkTokenKind;
|
|
begin
|
|
if KeyComp('read') then Result := tkFunction else
|
|
if KeyComp('call') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func33: TtkTokenKind;
|
|
begin
|
|
if KeyComp('ceil') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func34: TtkTokenKind;
|
|
begin
|
|
if KeyComp('date') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func35: TtkTokenKind;
|
|
begin
|
|
if KeyComp('mod') then Result := tkFunction else
|
|
if KeyComp('or') then Result := tkKey else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func37: TtkTokenKind;
|
|
begin
|
|
if KeyComp('log') then Result := tkFunction else
|
|
if KeyComp('log10') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func38: TtkTokenKind;
|
|
begin
|
|
if KeyComp('nil') then Result := tkKey else
|
|
if KeyComp('tan') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func39: TtkTokenKind;
|
|
begin
|
|
if KeyComp('min') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func40: TtkTokenKind;
|
|
begin
|
|
if KeyComp('atan') then Result := tkFunction else
|
|
if KeyComp('cos') then Result := tkFunction else
|
|
if KeyComp('atan2') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func41: TtkTokenKind;
|
|
begin
|
|
if KeyComp('max') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func42: TtkTokenKind;
|
|
begin
|
|
if KeyComp('break') then Result := tkKey else
|
|
if KeyComp('for') then Result := tkKey else
|
|
if KeyComp('acos') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func44: TtkTokenKind;
|
|
begin
|
|
if KeyComp('debug') then Result := tkFunction else
|
|
if KeyComp('seek') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func45: TtkTokenKind;
|
|
begin
|
|
if KeyComp('else') then Result := tkKey else
|
|
if KeyComp('sin') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func46: TtkTokenKind;
|
|
begin
|
|
if KeyComp('ascii') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func47: TtkTokenKind;
|
|
begin
|
|
if KeyComp('asin') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func48: TtkTokenKind;
|
|
begin
|
|
if KeyComp('local') then Result := tkKey else
|
|
if KeyComp('exp') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func49: TtkTokenKind;
|
|
begin
|
|
if KeyComp('clock') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func50: TtkTokenKind;
|
|
begin
|
|
if KeyComp('getn') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func51: TtkTokenKind;
|
|
begin
|
|
if KeyComp('then') then Result := tkKey else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func52: TtkTokenKind;
|
|
begin
|
|
if KeyComp('not') then Result := tkKey else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func53: TtkTokenKind;
|
|
begin
|
|
if KeyComp('gsub') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func56: TtkTokenKind;
|
|
begin
|
|
if KeyComp('_ALERT') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func57: TtkTokenKind;
|
|
begin
|
|
if KeyComp('dofile') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func60: TtkTokenKind;
|
|
begin
|
|
if KeyComp('gcinfo') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func62: TtkTokenKind;
|
|
begin
|
|
if KeyComp('elseif') then Result := tkKey else
|
|
if KeyComp('exit') then Result := tkFunction else
|
|
if KeyComp('while') then Result := tkKey else
|
|
if KeyComp('rename') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func63: TtkTokenKind;
|
|
begin
|
|
if KeyComp('foreach') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func66: TtkTokenKind;
|
|
begin
|
|
if KeyComp('_STDIN') then Result := tkFunction else
|
|
if KeyComp('ldexp') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func67: TtkTokenKind;
|
|
begin
|
|
if KeyComp('next') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func70: TtkTokenKind;
|
|
begin
|
|
if KeyComp('type') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func71: TtkTokenKind;
|
|
begin
|
|
if KeyComp('random') then Result := tkFunction else
|
|
if KeyComp('repeat') then Result := tkKey else
|
|
if KeyComp('floor') then Result := tkFunction else
|
|
if KeyComp('flush') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func73: TtkTokenKind;
|
|
begin
|
|
if KeyComp('foreachi') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func74: TtkTokenKind;
|
|
begin
|
|
if KeyComp('frexp') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func75: TtkTokenKind;
|
|
begin
|
|
if KeyComp('globals') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func76: TtkTokenKind;
|
|
begin
|
|
if KeyComp('newtag') then Result := tkFunction else
|
|
if KeyComp('sort') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func78: TtkTokenKind;
|
|
begin
|
|
if KeyComp('sqrt') then Result := tkFunction else
|
|
if KeyComp('settag') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func79: TtkTokenKind;
|
|
begin
|
|
if KeyComp('format') then Result := tkFunction else
|
|
if KeyComp('getenv') then Result := tkFunction else
|
|
if KeyComp('error') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func80: TtkTokenKind;
|
|
begin
|
|
if KeyComp('_INPUT') then Result := tkFunction else
|
|
if KeyComp('write') then Result := tkFunction else
|
|
if KeyComp('rawget') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func81: TtkTokenKind;
|
|
begin
|
|
if KeyComp('until') then Result := tkKey else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func82: TtkTokenKind;
|
|
begin
|
|
if KeyComp('print') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func83: TtkTokenKind;
|
|
begin
|
|
if KeyComp('getinfo') then Result := tkFunction else
|
|
if KeyComp('getlocal') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func84: TtkTokenKind;
|
|
begin
|
|
if KeyComp('_STDERR') then Result := tkFunction else
|
|
if KeyComp('getargs') then Result := tkFunction else
|
|
if KeyComp('remove') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func88: TtkTokenKind;
|
|
begin
|
|
if KeyComp('assert') then Result := tkFunction else
|
|
if KeyComp('readfrom') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func89: TtkTokenKind;
|
|
begin
|
|
if KeyComp('tmpname') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func90: TtkTokenKind;
|
|
begin
|
|
if KeyComp('execute') then Result := tkFunction else
|
|
if KeyComp('openfile') then Result := tkFunction else
|
|
if KeyComp('getglobal') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func92: TtkTokenKind;
|
|
begin
|
|
if KeyComp('rawset') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func94: TtkTokenKind;
|
|
begin
|
|
if KeyComp('strchar') then Result := tkFunction else
|
|
if KeyComp('strlen') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func95: TtkTokenKind;
|
|
begin
|
|
if KeyComp('setlocal') then Result := tkFunction else
|
|
if KeyComp('closefile') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func97: TtkTokenKind;
|
|
begin
|
|
if KeyComp('strfind') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func99: TtkTokenKind;
|
|
begin
|
|
if KeyComp('_STDOUT') then Result := tkFunction else
|
|
if KeyComp('appendto') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func101: TtkTokenKind;
|
|
begin
|
|
if KeyComp('setlocale') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func102: TtkTokenKind;
|
|
begin
|
|
if KeyComp('setglobal') then Result := tkFunction else
|
|
if KeyComp('return') then Result := tkKey else
|
|
if KeyComp('strrep') then Result := tkFunction else
|
|
if KeyComp('_VERSION') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func105: TtkTokenKind;
|
|
begin
|
|
if KeyComp('strsub') then Result := tkFunction else
|
|
if KeyComp('tremove') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func107: TtkTokenKind;
|
|
begin
|
|
if KeyComp('foreachvar') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func108: TtkTokenKind;
|
|
begin
|
|
if KeyComp('randomseed') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func110: TtkTokenKind;
|
|
begin
|
|
if KeyComp('function') then Result := tkKey else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func111: TtkTokenKind;
|
|
begin
|
|
if KeyComp('nextvar') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func112: TtkTokenKind;
|
|
begin
|
|
if KeyComp('tinsert') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func113: TtkTokenKind;
|
|
begin
|
|
if KeyComp('_OUTPUT') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func114: TtkTokenKind;
|
|
begin
|
|
if KeyComp('dostring') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func116: TtkTokenKind;
|
|
begin
|
|
if KeyComp('tonumber') then Result := tkFunction else
|
|
if KeyComp('strbyte') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func117: TtkTokenKind;
|
|
begin
|
|
if KeyComp('writeto') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func125: TtkTokenKind;
|
|
begin
|
|
if KeyComp('rawgettable') then Result := tkFunction else
|
|
if KeyComp('collectgarbage') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func130: TtkTokenKind;
|
|
begin
|
|
if KeyComp('tostring') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func132: TtkTokenKind;
|
|
begin
|
|
if KeyComp('setcallhook') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func135: TtkTokenKind;
|
|
begin
|
|
if KeyComp('rawgetglobal') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func137: TtkTokenKind;
|
|
begin
|
|
if KeyComp('gettagmethod') then Result := tkFunction else
|
|
if KeyComp('rawsettable') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func138: TtkTokenKind;
|
|
begin
|
|
if KeyComp('strlower') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func141: TtkTokenKind;
|
|
begin
|
|
if KeyComp('strupper') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func143: TtkTokenKind;
|
|
begin
|
|
if KeyComp('_ERRORMESSAGE') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func144: TtkTokenKind;
|
|
begin
|
|
if KeyComp('setlinehook') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func147: TtkTokenKind;
|
|
begin
|
|
if KeyComp('rawsetglobal') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func149: TtkTokenKind;
|
|
begin
|
|
if KeyComp('settagmethod') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.Func185: TtkTokenKind;
|
|
begin
|
|
if KeyComp('copytagmethods') then Result := tkFunction else Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.AltFunc: TtkTokenKind;
|
|
begin
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynLuaSyn.IdentKind(MayBe: PChar): TtkTokenKind;
|
|
var
|
|
HashKey: Integer;
|
|
begin
|
|
fToIdent := MayBe;
|
|
HashKey := KeyHash(MayBe);
|
|
if HashKey <= MaxKey then
|
|
Result := fIdentFuncTable[HashKey]()
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.MakeMethodTables;
|
|
var
|
|
I: Char;
|
|
begin
|
|
for I := #0 to #255 do
|
|
case I of
|
|
#0: fProcTable[I] := {$IFDEF FPC}@{$ENDIF}NullProc;
|
|
#10: fProcTable[I] := {$IFDEF FPC}@{$ENDIF}LFProc;
|
|
#13: fProcTable[I] := {$IFDEF FPC}@{$ENDIF}CRProc;
|
|
#1..#9, #11, #12, #14..#32 : fProcTable[I] := {$IFDEF FPC}@{$ENDIF}SpaceProc;
|
|
'A'..'Z', 'a'..'z', '_': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}IdentProc;
|
|
'0'..'9': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}NumberProc;
|
|
'''': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}StringProc;
|
|
'"': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}QuoteStringProc;
|
|
'-': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}CommentProc;
|
|
'}': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}BraceCloseProc;
|
|
'{': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}BraceOpenProc;
|
|
'>': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}GreaterProc;
|
|
'<': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}LowerProc;
|
|
')': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}RoundCloseProc;
|
|
'(': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}RoundOpenProc;
|
|
']': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}SquareCloseProc;
|
|
'[': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}SquareOpenProc;
|
|
':': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}ColonProc;
|
|
',': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}CommaProc;
|
|
';': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}SemiColonProc;
|
|
'.': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}PointProc;
|
|
'#': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}DirectiveProc;
|
|
'=': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}EqualProc;
|
|
'+': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}PlusProc;
|
|
'*': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}StarProc;
|
|
'/': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}SlashProc;
|
|
'%': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}ModSymbolProc;
|
|
'&': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}AndSymbolProc;
|
|
'!': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}NotSymbolProc;
|
|
'|': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}OrSymbolProc;
|
|
'~': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}TildeProc;
|
|
'^': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}ArrowProc;
|
|
'?': fProcTable[I] := {$IFDEF FPC}@{$ENDIF}QuestionProc;
|
|
else
|
|
fProcTable[I] := {$IFDEF FPC}@{$ENDIF}UnknownProc;
|
|
end;
|
|
end;
|
|
|
|
constructor TSynLuaSyn.Create(AOwner: TComponent);
|
|
begin
|
|
inherited Create(AOwner);
|
|
fCommentAttri := TSynHighLighterAttributes.Create({$IFDEF FPC}@{$ENDIF}SYNS_AttrComment, SYNS_XML_AttrComment);
|
|
fCommentAttri.Foreground := clGreen;
|
|
AddAttribute(fCommentAttri);
|
|
|
|
fFunctionAttri := TSynHighLighterAttributes.Create({$IFDEF FPC}@{$ENDIF}SYNS_AttrFunction, SYNS_XML_AttrFunction);
|
|
fFunctionAttri.Foreground := $00C05000;
|
|
AddAttribute(fFunctionAttri);
|
|
|
|
fIdentifierAttri := TSynHighLighterAttributes.Create({$IFDEF FPC}@{$ENDIF}SYNS_AttrIdentifier, SYNS_XML_AttrIdentifier);
|
|
fIdentifierAttri.Foreground := clWindowText;
|
|
AddAttribute(fIdentifierAttri);
|
|
|
|
fKeyAttri := TSynHighLighterAttributes.Create({$IFDEF FPC}@{$ENDIF}SYNS_AttrReservedWord, SYNS_XML_AttrReservedWord);
|
|
fKeyAttri.Foreground := clBlue;
|
|
AddAttribute(fKeyAttri);
|
|
|
|
fNumberAttri := TSynHighLighterAttributes.Create({$IFDEF FPC}@{$ENDIF}SYNS_AttrNumber, SYNS_XML_AttrNumber);
|
|
fNumberAttri.Foreground := clPurple;
|
|
AddAttribute(fNumberAttri);
|
|
|
|
fSpaceAttri := TSynHighLighterAttributes.Create({$IFDEF FPC}@{$ENDIF}SYNS_AttrSpace, SYNS_XML_AttrSpace);
|
|
AddAttribute(fSpaceAttri);
|
|
|
|
fStringAttri := TSynHighLighterAttributes.Create({$IFDEF FPC}@{$ENDIF}SYNS_AttrString, SYNS_XML_AttrString);
|
|
fStringAttri.Foreground := clMaroon;
|
|
AddAttribute(fStringAttri);
|
|
|
|
fSymbolAttri := TSynHighLighterAttributes.Create({$IFDEF FPC}@{$ENDIF}SYNS_AttrSymbol, SYNS_XML_AttrSymbol);
|
|
fSymbolAttri.Foreground := clNavy;
|
|
AddAttribute(fSymbolAttri);
|
|
|
|
SetAttributesOnChange({$IFDEF FPC}@{$ENDIF}DefHighlightChange);
|
|
InitIdent;
|
|
MakeMethodTables;
|
|
fRange := rsUnknown;
|
|
fDefaultFilter := SYNS_FilterLua;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.SpaceProc;
|
|
begin
|
|
fTokenID := tkSpace;
|
|
repeat
|
|
Inc(Run);
|
|
until not (fLine[Run] in [#1..#32]);
|
|
end;
|
|
|
|
procedure TSynLuaSyn.NullProc;
|
|
begin
|
|
fTokenID := tkNull;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.CRProc;
|
|
begin
|
|
fTokenID := tkSpace;
|
|
Inc(Run);
|
|
if fLine[Run] = #10 then
|
|
Inc(Run);
|
|
end;
|
|
|
|
procedure TSynLuaSyn.LFProc;
|
|
begin
|
|
fTokenID := tkSpace;
|
|
Inc(Run);
|
|
end;
|
|
|
|
procedure TSynLuaSyn.CommentProc;
|
|
begin
|
|
case fLine[Run + 1] of
|
|
'-':
|
|
begin
|
|
fTokenID := tkComment;
|
|
repeat
|
|
Inc(Run);
|
|
until fLine[Run] in [#0, #10, #13];
|
|
end;
|
|
'=', '>':
|
|
begin
|
|
Inc(Run, 2);
|
|
fTokenID := tkSymbol;
|
|
end
|
|
else
|
|
begin
|
|
fTokenID := tkSymbol;
|
|
Inc(Run); {subtract}
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.StringProc;
|
|
begin
|
|
fTokenID := tkString;
|
|
repeat
|
|
if fLine[Run] = '\' then
|
|
begin
|
|
if fLine[Run + 1] in [#39, '\'] then
|
|
Inc(Run);
|
|
end;
|
|
Inc(Run);
|
|
until fLine[Run] in [#0, #10, #13, #39];
|
|
if fLine[Run] = #39 then
|
|
Inc(Run);
|
|
end;
|
|
|
|
procedure TSynLuaSyn.QuoteStringProc;
|
|
begin
|
|
fTokenID := tkString;
|
|
repeat
|
|
if fLine[Run] = '\' then
|
|
begin
|
|
case fLine[Run + 1] of
|
|
#34, '\':
|
|
Inc(Run);
|
|
#00:
|
|
begin
|
|
Inc(Run);
|
|
fRange := rsMultilineString;
|
|
Exit;
|
|
end;
|
|
end;
|
|
end;
|
|
Inc(Run);
|
|
until fLine[Run] in [#0, #10, #13, #34];
|
|
if FLine[Run] = #34 then
|
|
Inc(Run);
|
|
end;
|
|
|
|
procedure TSynLuaSyn.StringEndProc;
|
|
begin
|
|
fTokenID := tkString;
|
|
|
|
case FLine[Run] of
|
|
#0:
|
|
begin
|
|
NullProc;
|
|
Exit;
|
|
end;
|
|
#10:
|
|
begin
|
|
LFProc;
|
|
Exit;
|
|
end;
|
|
#13:
|
|
begin
|
|
CRProc;
|
|
Exit;
|
|
end;
|
|
end;
|
|
|
|
fRange := rsUnknown;
|
|
|
|
repeat
|
|
case FLine[Run] of
|
|
#0, #10, #13: Break;
|
|
'\':
|
|
begin
|
|
case fLine[Run + 1] of
|
|
#34, '\':
|
|
Inc(Run);
|
|
#00:
|
|
begin
|
|
Inc(Run);
|
|
fRange := rsMultilineString;
|
|
Exit;
|
|
end;
|
|
end;
|
|
end;
|
|
#34: Break;
|
|
end;
|
|
Inc(Run);
|
|
until fLine[Run] in [#0, #10, #13, #34];
|
|
if FLine[Run] = #34 then
|
|
Inc(Run);
|
|
end;
|
|
|
|
procedure TSynLuaSyn.BraceCloseProc;
|
|
begin
|
|
Inc(Run);
|
|
fTokenId := tkSymbol;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.BraceOpenProc;
|
|
begin
|
|
Inc(Run);
|
|
fTokenId := tkSymbol;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.GreaterProc;
|
|
begin
|
|
fTokenID := tkSymbol;
|
|
case FLine[Run + 1] of
|
|
'=': Inc(Run, 2); {greater than or equal to}
|
|
'>':
|
|
begin
|
|
if FLine[Run + 2] = '=' then {shift right assign}
|
|
Inc(Run, 3)
|
|
else {shift right}
|
|
Inc(Run, 2);
|
|
end;
|
|
else {greater than}
|
|
Inc(run);
|
|
end;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.LowerProc;
|
|
begin
|
|
fTokenID := tkSymbol;
|
|
case FLine[Run + 1] of
|
|
'=': Inc(Run, 2); {less than or equal to}
|
|
'<':
|
|
begin
|
|
if FLine[Run + 2] = '=' then {shift left assign}
|
|
Inc(Run, 3)
|
|
else {shift left}
|
|
Inc(Run, 2);
|
|
end;
|
|
else Inc(Run); {less than}
|
|
end;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.RoundCloseProc;
|
|
begin
|
|
Inc(Run);
|
|
fTokenID := tkSymbol;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.RoundOpenProc;
|
|
begin
|
|
Inc(Run);
|
|
FTokenID := tkSymbol;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.SquareCloseProc;
|
|
begin
|
|
Inc(Run);
|
|
fTokenID := tkSymbol;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.SquareOpenProc;
|
|
begin
|
|
Inc(Run);
|
|
fTokenID := tkSymbol;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.ColonProc;
|
|
begin
|
|
fTokenID := tkSymbol;
|
|
case FLine[Run + 1] of
|
|
':': Inc(Run, 2); {scope resolution operator}
|
|
else {colon}
|
|
Inc(Run);
|
|
end;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.CommaProc;
|
|
begin
|
|
Inc(Run);
|
|
fTokenID := tkSymbol;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.SemiColonProc;
|
|
begin
|
|
Inc(Run);
|
|
fTokenID := tkSymbol;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.PointProc;
|
|
begin
|
|
fTokenID := tkSymbol;
|
|
if (FLine[Run + 1] = '.') and (FLine[Run + 2] = '.') then {ellipse}
|
|
Inc(Run, 3)
|
|
else if FLine[Run + 1] in ['0'..'9'] then // float
|
|
begin
|
|
Dec(Run); // numberproc must see the point
|
|
NumberProc;
|
|
end
|
|
else {point}
|
|
Inc(Run);
|
|
end;
|
|
|
|
procedure TSynLuaSyn.DirectiveProc;
|
|
begin
|
|
Inc(Run);
|
|
fTokenID := tkSymbol;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.EqualProc;
|
|
begin
|
|
fTokenID := tkSymbol;
|
|
case FLine[Run + 1] of
|
|
'=': Inc(Run, 2); {logical equal}
|
|
else {assign}
|
|
Inc(Run);
|
|
end;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.IdentProc;
|
|
begin
|
|
fTokenID := IdentKind((fLine + Run));
|
|
Inc(Run, fStringLen);
|
|
while Identifiers[fLine[Run]] do Inc(Run);
|
|
end;
|
|
|
|
procedure TSynLuaSyn.PlusProc;
|
|
begin
|
|
fTokenID := tkSymbol;
|
|
case FLine[Run + 1] of
|
|
'=': Inc(Run, 2); {add assign}
|
|
'+': Inc(Run, 2); {increment}
|
|
else {add}
|
|
Inc(Run);
|
|
end;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.StarProc;
|
|
begin
|
|
fTokenID := tkSymbol;
|
|
case FLine[Run + 1] of
|
|
'=': Inc(Run, 2); {multiply assign}
|
|
else Inc(Run); {star}
|
|
end;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.SlashProc;
|
|
begin
|
|
fTokenID := tkSymbol;
|
|
case FLine[Run + 1] of
|
|
'=': Inc(Run, 2); {multiply assign}
|
|
else Inc(Run); {star}
|
|
end;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.ModSymbolProc;
|
|
begin
|
|
fTokenID := tkSymbol;
|
|
case FLine[Run + 1] of
|
|
'=': Inc(Run, 2); {mod assign}
|
|
else Inc(Run); {mod}
|
|
end;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.AndSymbolProc;
|
|
begin
|
|
fTokenID := tkSymbol;
|
|
case FLine[Run + 1] of
|
|
'=': Inc(Run, 2); // and assign
|
|
'&': Inc(Run, 2); // logical and
|
|
else Inc(Run); // and
|
|
end;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.NotSymbolProc;
|
|
begin
|
|
fTokenID := tkSymbol;
|
|
case FLine[Run + 1] of
|
|
'=': Inc(Run, 2); {not equal}
|
|
else Inc(Run); {not}
|
|
end;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.OrSymbolProc;
|
|
begin
|
|
fTokenID := tkSymbol;
|
|
case FLine[Run + 1] of
|
|
'=': Inc(Run, 2); {or assign}
|
|
'|': Inc(Run, 2); {logical or}
|
|
else Inc(Run); {or}
|
|
end;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.TildeProc;
|
|
begin
|
|
Inc(Run); {bitwise complement}
|
|
fTokenId := tkSymbol;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.ArrowProc;
|
|
begin
|
|
Inc(Run); {bitwise complement}
|
|
fTokenId := tkSymbol;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.QuestionProc;
|
|
begin
|
|
fTokenID := tkSymbol; {conditional}
|
|
Inc(Run);
|
|
end;
|
|
|
|
procedure TSynLuaSyn.NumberProc;
|
|
begin
|
|
Inc(Run);
|
|
fTokenID := tkNumber;
|
|
while FLine[Run] in
|
|
['0'..'9', '.', 'u', 'U', 'l', 'L', 'x', 'X', 'e', 'E', 'f', 'F'] do //Kan
|
|
//['0'..'9', 'A'..'F', 'a'..'f', '.', 'u', 'U', 'l', 'L', 'x', 'X'] do //Commented by Kan
|
|
begin
|
|
case FLine[Run] of
|
|
'.': if FLine[Run + 1] = '.' then break;
|
|
end;
|
|
Inc(Run);
|
|
end;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.UnknownProc;
|
|
begin
|
|
{$IFDEF SYN_MBCSSUPPORT}
|
|
if FLine[Run] in LeadBytes then
|
|
Inc(Run,2)
|
|
else
|
|
{$ENDIF}
|
|
Inc(Run);
|
|
fTokenID := tkUnknown;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.SetLine(const NewValue :String; LineNumber :Integer);
|
|
begin
|
|
fLineRef := NewValue;
|
|
fLine := PChar(fLineRef);
|
|
Run := 0;
|
|
fLineNumber := LineNumber;
|
|
Next;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.Next;
|
|
begin
|
|
fTokenPos := Run;
|
|
case fRange of
|
|
rsMultilineString: StringEndProc;
|
|
else
|
|
begin
|
|
fRange := rsUnknown;
|
|
fProcTable[fLine[Run]];
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
class function TSynLuaSyn.GetLanguageName :string;
|
|
begin
|
|
Result := SYNS_LangLua;
|
|
end;
|
|
|
|
function TSynLuaSyn.GetDefaultAttribute(Index :integer) :TSynHighlighterAttributes;
|
|
begin
|
|
case Index of
|
|
SYN_ATTR_COMMENT : Result := fCommentAttri;
|
|
SYN_ATTR_IDENTIFIER : Result := fIdentifierAttri;
|
|
SYN_ATTR_KEYWORD : Result := fKeyAttri;
|
|
SYN_ATTR_STRING : Result := fStringAttri;
|
|
SYN_ATTR_WHITESPACE : Result := fSpaceAttri;
|
|
SYN_ATTR_SYMBOL : Result := fSymbolAttri;
|
|
else
|
|
Result := nil;
|
|
end;
|
|
end;
|
|
|
|
function TSynLuaSyn.GetEol: Boolean;
|
|
begin
|
|
Result := fTokenID = tkNull;
|
|
end;
|
|
|
|
function TSynLuaSyn.GetToken: String;
|
|
var
|
|
Len: LongInt;
|
|
begin
|
|
Len := Run - fTokenPos;
|
|
SetString(Result, (FLine + fTokenPos), Len);
|
|
end;
|
|
|
|
{$IFDEF SYN_LAZARUS}
|
|
procedure TSynLuaSyn.GetTokenEx(out TokenStart :PChar; out TokenLength :integer);
|
|
begin
|
|
TokenLength := Run - fTokenPos;
|
|
TokenStart := FLine + fTokenPos;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function TSynLuaSyn.GetTokenID: TtkTokenKind;
|
|
begin
|
|
Result := fTokenId;
|
|
end;
|
|
|
|
function TSynLuaSyn.GetTokenAttribute :TSynHighlighterAttributes;
|
|
begin
|
|
case GetTokenID of
|
|
tkComment: Result := fCommentAttri;
|
|
tkFunction: Result := fFunctionAttri;
|
|
tkIdentifier: Result := fIdentifierAttri;
|
|
tkKey: Result := fKeyAttri;
|
|
tkNumber: Result := fNumberAttri;
|
|
tkSpace: Result := fSpaceAttri;
|
|
tkString: Result := fStringAttri;
|
|
tkSymbol: Result := fSymbolAttri;
|
|
tkUnknown: Result := fIdentifierAttri;
|
|
else
|
|
Result := nil;
|
|
end;
|
|
end;
|
|
|
|
function TSynLuaSyn.GetTokenKind: integer;
|
|
begin
|
|
Result := Ord(fTokenId);
|
|
end;
|
|
|
|
function TSynLuaSyn.GetTokenPos: Integer;
|
|
begin
|
|
Result := fTokenPos;
|
|
end;
|
|
|
|
function TSynLuaSyn.GetIdentChars: TSynIdentChars;
|
|
begin
|
|
Result := ['_', 'a'..'z', 'A'..'Z', '0'..'9'];
|
|
end;
|
|
|
|
function TSynLuaSyn.IsFilterStored :Boolean;
|
|
begin
|
|
Result := (fDefaultFilter <> SYNS_FilterLua);
|
|
end;
|
|
|
|
procedure TSynLuaSyn.ResetRange;
|
|
begin
|
|
fRange := rsUnknown;
|
|
end;
|
|
|
|
procedure TSynLuaSyn.SetRange(Value: Pointer);
|
|
begin
|
|
fRange := TRangeState(PtrUInt(Value));
|
|
end;
|
|
|
|
function TSynLuaSyn.GetRange: Pointer;
|
|
begin
|
|
Result := Pointer(PtrInt(fRange));
|
|
end;
|
|
|
|
initialization
|
|
MakeIdentTable;
|
|
{$IFNDEF SYN_CPPB_1}
|
|
RegisterPlaceableHighlighter(TSynLuaSyn);
|
|
{$ENDIF}
|
|
end.
|