mirror of
https://github.com/HeidiSQL/HeidiSQL.git
synced 2025-08-06 18:24:26 +08:00
1049 lines
27 KiB
ObjectPascal
1049 lines
27 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.
|
|
|
|
Code template generated with SynGen.
|
|
The original code is: SynHighlighterWebIDL.pas, released 2013-02-14.
|
|
Description: Syntax Parser/Highlighter
|
|
The initial author of this file is Christian-W. Budde.
|
|
Copyright (c) 2013, 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: $
|
|
|
|
You may retrieve the latest version of this file at the SynEdit home page,
|
|
located at http://SynEdit.SourceForge.net
|
|
|
|
-------------------------------------------------------------------------------}
|
|
|
|
unit SynHighlighterWebIDL;
|
|
|
|
{$I SynEdit.inc}
|
|
|
|
interface
|
|
|
|
uses
|
|
Graphics,
|
|
SynEditTypes,
|
|
SynEditHighlighter,
|
|
SynUnicode,
|
|
SysUtils,
|
|
Classes;
|
|
|
|
type
|
|
TtkTokenKind = (
|
|
tkArguments,
|
|
tkComment,
|
|
tkExtendedAttributes,
|
|
tkIdentifier,
|
|
tkKey,
|
|
tkNull,
|
|
tkNumber,
|
|
tkSpace,
|
|
tkString,
|
|
tkTypes,
|
|
tkSymbol,
|
|
tkUnknown);
|
|
|
|
TstkSymbolTokenKind = (
|
|
stkBraceOpen,
|
|
stkBraceClose,
|
|
stkSquareOpen,
|
|
stkSquareClose,
|
|
stkQuestionMark,
|
|
stkColon,
|
|
stkGreater,
|
|
stkLess
|
|
);
|
|
|
|
TRangeState = (rsUnknown, rsSingleComment, rsCStyleComment, rsString,
|
|
rsExtendedAttributes);
|
|
|
|
TProcTableProc = procedure of object;
|
|
|
|
PIdentFuncTableFunc = ^TIdentFuncTableFunc;
|
|
TIdentFuncTableFunc = function (Index: Integer): TtkTokenKind of object;
|
|
|
|
type
|
|
TSynWebIDLSyn = class(TSynCustomHighlighter)
|
|
private
|
|
fRange: TRangeState;
|
|
fTokenID: TtkTokenKind;
|
|
fSymbolTokenID: TstkSymbolTokenKind;
|
|
fIdentFuncTable: array [0..58] of TIdentFuncTableFunc;
|
|
fArgumentsAttri: TSynHighlighterAttributes;
|
|
fExtendedAttri: TSynHighlighterAttributes;
|
|
fCommentAttri: TSynHighlighterAttributes;
|
|
fIdentifierAttri: TSynHighlighterAttributes;
|
|
fKeyAttri: TSynHighlighterAttributes;
|
|
fNumberAttri: TSynHighlighterAttributes;
|
|
fSpaceAttri: TSynHighlighterAttributes;
|
|
fStringAttri: TSynHighlighterAttributes;
|
|
fSymbolAttri: TSynHighlighterAttributes;
|
|
fTypesAttri: TSynHighlighterAttributes;
|
|
function HashKey(Str: PWideChar): Cardinal;
|
|
function FuncAny(Index: Integer): TtkTokenKind;
|
|
function FuncAttribute(Index: Integer): TtkTokenKind;
|
|
function FuncBoolean(Index: Integer): TtkTokenKind;
|
|
function FuncByte(Index: Integer): TtkTokenKind;
|
|
function FuncBytestring(Index: Integer): TtkTokenKind;
|
|
function FuncCallback(Index: Integer): TtkTokenKind;
|
|
function FuncConst(Index: Integer): TtkTokenKind;
|
|
function FuncCreator(Index: Integer): TtkTokenKind;
|
|
function FuncDate(Index: Integer): TtkTokenKind;
|
|
function FuncDeleter(Index: Integer): TtkTokenKind;
|
|
function FuncDictionary(Index: Integer): TtkTokenKind;
|
|
function FuncDomstring(Index: Integer): TtkTokenKind;
|
|
function FuncDouble(Index: Integer): TtkTokenKind;
|
|
function FuncEnum(Index: Integer): TtkTokenKind;
|
|
function FuncException(Index: Integer): TtkTokenKind;
|
|
function FuncFloat(Index: Integer): TtkTokenKind;
|
|
function FuncGetter(Index: Integer): TtkTokenKind;
|
|
function FuncImplements(Index: Integer): TtkTokenKind;
|
|
function FuncInherit(Index: Integer): TtkTokenKind;
|
|
function FuncInterface(Index: Integer): TtkTokenKind;
|
|
function FuncLegacycaller(Index: Integer): TtkTokenKind;
|
|
function FuncLong(Index: Integer): TtkTokenKind;
|
|
function FuncObject(Index: Integer): TtkTokenKind;
|
|
function FuncOctet(Index: Integer): TtkTokenKind;
|
|
function FuncOptional(Index: Integer): TtkTokenKind;
|
|
function FuncPartial(Index: Integer): TtkTokenKind;
|
|
function FuncReadonly(Index: Integer): TtkTokenKind;
|
|
function FuncRegexp(Index: Integer): TtkTokenKind;
|
|
function FuncSequence(Index: Integer): TtkTokenKind;
|
|
function FuncSetter(Index: Integer): TtkTokenKind;
|
|
function FuncShort(Index: Integer): TtkTokenKind;
|
|
function FuncStatic(Index: Integer): TtkTokenKind;
|
|
function FuncStringifier(Index: Integer): TtkTokenKind;
|
|
function FuncTypedef(Index: Integer): TtkTokenKind;
|
|
function FuncUnresticted(Index: Integer): TtkTokenKind;
|
|
function FuncUnrestricted(Index: Integer): TtkTokenKind;
|
|
function FuncUnsigned(Index: Integer): TtkTokenKind;
|
|
function FuncVoid(Index: Integer): TtkTokenKind;
|
|
procedure IdentProc;
|
|
procedure UnknownProc;
|
|
function AltFunc(Index: Integer): TtkTokenKind;
|
|
procedure InitIdent;
|
|
function IdentKind(MayBe: PWideChar): TtkTokenKind;
|
|
procedure BraceCloseProc;
|
|
procedure BraceOpenProc;
|
|
procedure ColonProc;
|
|
procedure CRProc;
|
|
procedure CStyleCommentProc;
|
|
procedure GreaterProc;
|
|
procedure LessProc;
|
|
procedure LFProc;
|
|
procedure NullProc;
|
|
procedure NumberProc;
|
|
procedure QuestionMarkProc;
|
|
procedure SlashProc;
|
|
procedure SpaceProc;
|
|
procedure SquareCloseProc;
|
|
procedure SquareOpenProc;
|
|
procedure StringOpenProc;
|
|
procedure StringProc;
|
|
protected
|
|
function GetSampleSource: UnicodeString; override;
|
|
function IsFilterStored: Boolean; override;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
class function GetFriendlyLanguageName: UnicodeString; override;
|
|
class function GetLanguageName: string; override;
|
|
function GetRange: Pointer; override;
|
|
procedure ResetRange; override;
|
|
procedure SetRange(Value: Pointer); override;
|
|
function GetDefaultAttribute(Index: Integer): TSynHighlighterAttributes; override;
|
|
function GetEol: Boolean; override;
|
|
function GetKeyWords(TokenKind: Integer): UnicodeString; override;
|
|
function GetTokenID: TtkTokenKind;
|
|
function GetTokenAttribute: TSynHighlighterAttributes; override;
|
|
function GetTokenKind: Integer; override;
|
|
function IsIdentChar(AChar: WideChar): Boolean; override;
|
|
procedure Next; override;
|
|
published
|
|
property ArgumentsAttri: TSynHighlighterAttributes read fArgumentsAttri write fArgumentsAttri;
|
|
property CommentAttri: TSynHighlighterAttributes read fCommentAttri write fCommentAttri;
|
|
property ExtendedAttri: TSynHighlighterAttributes read fExtendedAttri write fExtendedAttri;
|
|
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;
|
|
property TypesAttri: TSynHighlighterAttributes read fTypesAttri write fTypesAttri;
|
|
end;
|
|
|
|
implementation
|
|
|
|
uses
|
|
SynEditStrConst;
|
|
|
|
resourcestring
|
|
SYNS_FilterWebIDL = 'Web IDL (*.idl)|*.idl';
|
|
SYNS_LangWebIDL = 'Web IDL';
|
|
SYNS_FriendlyLangWebIDL = 'Web IDL';
|
|
SYNS_AttrArguments = 'Arguments';
|
|
SYNS_FriendlyAttrArguments = 'Arguments';
|
|
SYNS_AttrExtended = 'Extended';
|
|
SYNS_FriendlyAttrExtended = 'Extended';
|
|
|
|
const
|
|
// as this language is case-insensitive keywords *must* be in lowercase
|
|
KeyWords: array[0..37] of UnicodeString = (
|
|
'any', 'attribute', 'boolean', 'byte', 'bytestring', 'callback', 'const',
|
|
'creator', 'date', 'deleter', 'dictionary', 'domstring', 'double', 'enum',
|
|
'exception', 'float', 'getter', 'implements', 'inherit', 'interface',
|
|
'legacycaller', 'long', 'object', 'octet', 'optional', 'partial',
|
|
'readonly', 'regexp', 'sequence', 'setter', 'short', 'static',
|
|
'stringifier', 'typedef', 'unresticted', 'unrestricted', 'unsigned', 'void'
|
|
);
|
|
|
|
KeyIndices: array[0..58] of Integer = (
|
|
14, 28, 4, 37, 21, -1, -1, 12, 17, -1, -1, 22, -1, 3, -1, -1, 29, -1, 27,
|
|
31, -1, 1, 20, -1, 24, 15, 2, -1, -1, -1, -1, 23, -1, 19, 0, 13, 11, 16, 34,
|
|
10, 36, 25, -1, 30, -1, 33, 32, 6, -1, 9, 7, -1, 8, -1, 26, 18, -1, 5, 35
|
|
);
|
|
|
|
constructor TSynWebIDLSyn.Create(AOwner: TComponent);
|
|
begin
|
|
inherited Create(AOwner);
|
|
fCaseSensitive := False;
|
|
|
|
fArgumentsAttri := TSynHighLighterAttributes.Create(SYNS_AttrArguments,
|
|
SYNS_FriendlyAttrArguments);
|
|
fArgumentsAttri.Style := [fsBold];
|
|
fArgumentsAttri.Foreground := clNavy;
|
|
AddAttribute(fArgumentsAttri);
|
|
|
|
fCommentAttri := TSynHighLighterAttributes.Create(SYNS_AttrComment,
|
|
SYNS_FriendlyAttrComment);
|
|
fCommentAttri.Style := [fsItalic];
|
|
fCommentAttri.Foreground := clGreen;
|
|
AddAttribute(fCommentAttri);
|
|
|
|
fExtendedAttri := TSynHighlighterAttributes.Create(SYNS_AttrExtended,
|
|
SYNS_FriendlyAttrExtended);
|
|
fExtendedAttri.Style := [fsBold, fsItalic];
|
|
fExtendedAttri.Foreground := clMaroon;
|
|
AddAttribute(fExtendedAttri);
|
|
|
|
fIdentifierAttri := TSynHighLighterAttributes.Create(SYNS_AttrIdentifier,
|
|
SYNS_FriendlyAttrIdentifier);
|
|
AddAttribute(fIdentifierAttri);
|
|
|
|
fKeyAttri := TSynHighLighterAttributes.Create(SYNS_AttrReservedWord,
|
|
SYNS_FriendlyAttrReservedWord);
|
|
fKeyAttri.Style := [fsBold];
|
|
fKeyAttri.Foreground := clNavy;
|
|
AddAttribute(fKeyAttri);
|
|
|
|
fNumberAttri := TSynHighlighterAttributes.Create(SYNS_AttrNumber, SYNS_FriendlyAttrNumber);
|
|
fNumberAttri.Foreground := clBlue;
|
|
AddAttribute(fNumberAttri);
|
|
|
|
fSpaceAttri := TSynHighLighterAttributes.Create(SYNS_AttrSpace, SYNS_FriendlyAttrSpace);
|
|
AddAttribute(fSpaceAttri);
|
|
|
|
fStringAttri := TSynHighLighterAttributes.Create(SYNS_AttrString, SYNS_FriendlyAttrString);
|
|
fStringAttri.Foreground := clPurple;
|
|
AddAttribute(fStringAttri);
|
|
|
|
fSymbolAttri := TSynHighLighterAttributes.Create(SYNS_AttrSymbol, SYNS_FriendlyAttrSymbol);
|
|
fSymbolAttri.Style := [fsBold];
|
|
fSymbolAttri.Foreground := clMaroon;
|
|
AddAttribute(fSymbolAttri);
|
|
|
|
fTypesAttri := TSynHighLighterAttributes.Create(SYNS_AttrDataType, SYNS_FriendlyAttrDataType);
|
|
fTypesAttri.Foreground := clNavy;
|
|
AddAttribute(fTypesAttri);
|
|
|
|
SetAttributesOnChange(DefHighlightChange);
|
|
InitIdent;
|
|
fDefaultFilter := SYNS_FilterWebIDL;
|
|
fRange := rsUnknown;
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.InitIdent;
|
|
var
|
|
i: Integer;
|
|
begin
|
|
for i := Low(fIdentFuncTable) to High(fIdentFuncTable) do
|
|
if KeyIndices[i] = -1 then
|
|
fIdentFuncTable[i] := AltFunc;
|
|
|
|
fIdentFuncTable[34] := FuncAny;
|
|
fIdentFuncTable[21] := FuncAttribute;
|
|
fIdentFuncTable[26] := FuncBoolean;
|
|
fIdentFuncTable[13] := FuncByte;
|
|
fIdentFuncTable[2] := FuncBytestring;
|
|
fIdentFuncTable[57] := FuncCallback;
|
|
fIdentFuncTable[47] := FuncConst;
|
|
fIdentFuncTable[50] := FuncCreator;
|
|
fIdentFuncTable[52] := FuncDate;
|
|
fIdentFuncTable[49] := FuncDeleter;
|
|
fIdentFuncTable[39] := FuncDictionary;
|
|
fIdentFuncTable[36] := FuncDomstring;
|
|
fIdentFuncTable[7] := FuncDouble;
|
|
fIdentFuncTable[35] := FuncEnum;
|
|
fIdentFuncTable[0] := FuncException;
|
|
fIdentFuncTable[25] := FuncFloat;
|
|
fIdentFuncTable[37] := FuncGetter;
|
|
fIdentFuncTable[8] := FuncImplements;
|
|
fIdentFuncTable[55] := FuncInherit;
|
|
fIdentFuncTable[33] := FuncInterface;
|
|
fIdentFuncTable[22] := FuncLegacycaller;
|
|
fIdentFuncTable[4] := FuncLong;
|
|
fIdentFuncTable[11] := FuncObject;
|
|
fIdentFuncTable[31] := FuncOctet;
|
|
fIdentFuncTable[24] := FuncOptional;
|
|
fIdentFuncTable[41] := FuncPartial;
|
|
fIdentFuncTable[54] := FuncReadonly;
|
|
fIdentFuncTable[18] := FuncRegexp;
|
|
fIdentFuncTable[1] := FuncSequence;
|
|
fIdentFuncTable[16] := FuncSetter;
|
|
fIdentFuncTable[43] := FuncShort;
|
|
fIdentFuncTable[19] := FuncStatic;
|
|
fIdentFuncTable[46] := FuncStringifier;
|
|
fIdentFuncTable[45] := FuncTypedef;
|
|
fIdentFuncTable[38] := FuncUnresticted;
|
|
fIdentFuncTable[58] := FuncUnrestricted;
|
|
fIdentFuncTable[40] := FuncUnsigned;
|
|
fIdentFuncTable[3] := FuncVoid;
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.ColonProc;
|
|
begin
|
|
Inc(Run);
|
|
fTokenId := tkSymbol;
|
|
fSymbolTokenID := stkColon;
|
|
end;
|
|
|
|
{$Q-}
|
|
function TSynWebIDLSyn.HashKey(Str: PWideChar): Cardinal;
|
|
begin
|
|
Result := 0;
|
|
while IsIdentChar(Str^) do
|
|
begin
|
|
Result := Result * 622 + Ord(Str^) * 657;
|
|
inc(Str);
|
|
end;
|
|
Result := Result mod 59;
|
|
fStringLen := Str - fToIdent;
|
|
end;
|
|
{$Q+}
|
|
|
|
function TSynWebIDLSyn.FuncAny(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkTypes
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncAttribute(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkArguments
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncBoolean(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkTypes
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncByte(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkTypes
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncBytestring(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkTypes
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncCallback(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkKey
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncConst(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkArguments
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncCreator(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkArguments
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncDate(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkTypes
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncDeleter(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkArguments
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncDictionary(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkKey
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncDomstring(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkTypes
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncDouble(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkTypes
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncEnum(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkKey
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncException(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkKey
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncFloat(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkTypes
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncGetter(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkArguments
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncImplements(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkArguments
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncInherit(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkArguments
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncInterface(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkKey
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncLegacycaller(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkArguments
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncLong(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkTypes
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncObject(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkTypes
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncOctet(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkTypes
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncOptional(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkArguments
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncPartial(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkKey
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncReadonly(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkArguments
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncRegexp(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkTypes
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncSequence(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkTypes
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncSetter(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkArguments
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncShort(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkTypes
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncStatic(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkArguments
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncStringifier(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkArguments
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncTypedef(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkArguments
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncUnresticted(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkTypes
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncUnrestricted(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkArguments
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncUnsigned(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkTypes
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.FuncVoid(Index: Integer): TtkTokenKind;
|
|
begin
|
|
if IsCurrentToken(KeyWords[Index]) then
|
|
Result := tkTypes
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.AltFunc(Index: Integer): TtkTokenKind;
|
|
begin
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.IdentKind(MayBe: PWideChar): TtkTokenKind;
|
|
var
|
|
Key: Cardinal;
|
|
begin
|
|
fToIdent := MayBe;
|
|
Key := HashKey(MayBe);
|
|
if Key <= High(fIdentFuncTable) then
|
|
Result := fIdentFuncTable[Key](KeyIndices[Key])
|
|
else
|
|
Result := tkIdentifier;
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.SpaceProc;
|
|
begin
|
|
inc(Run);
|
|
fTokenID := tkSpace;
|
|
while (FLine[Run] <= #32) and not IsLineEnd(Run) do inc(Run);
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.NullProc;
|
|
begin
|
|
fTokenID := tkNull;
|
|
inc(Run);
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.NumberProc;
|
|
|
|
function IsNumberChar: Boolean;
|
|
begin
|
|
case fLine[Run] of
|
|
'0'..'9', '.', 'a'..'f', 'A'..'F', 'x', 'X':
|
|
Result := True;
|
|
else
|
|
Result := False;
|
|
end;
|
|
end;
|
|
|
|
function IsHexChar(Run: Integer): Boolean;
|
|
begin
|
|
case fLine[Run] of
|
|
'0'..'9', 'a'..'f', 'A'..'F':
|
|
Result := True;
|
|
else
|
|
Result := False;
|
|
end;
|
|
end;
|
|
|
|
var
|
|
idx1: Integer; // token[1]
|
|
isHex: Boolean;
|
|
begin
|
|
fTokenID := tkNumber;
|
|
isHex := False;
|
|
idx1 := Run;
|
|
Inc(Run);
|
|
while IsNumberChar do
|
|
begin
|
|
case FLine[Run] of
|
|
'.':
|
|
if FLine[Succ(Run)] = '.' then
|
|
Break;
|
|
'a'..'f', 'A'..'F':
|
|
if not isHex then
|
|
Break;
|
|
'x', 'X':
|
|
begin
|
|
if (FLine[idx1] <> '0') or (Run > Succ(idx1)) then
|
|
Break;
|
|
if not IsHexChar(Succ(Run)) then
|
|
Break;
|
|
isHex := True;
|
|
end;
|
|
end;
|
|
Inc(Run);
|
|
end;
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.QuestionMarkProc;
|
|
begin
|
|
Inc(Run);
|
|
fTokenID := tkSymbol;
|
|
fSymbolTokenID := stkQuestionMark;
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.CRProc;
|
|
begin
|
|
fTokenID := tkSpace;
|
|
inc(Run);
|
|
if fLine[Run] = #10 then
|
|
inc(Run);
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.GreaterProc;
|
|
begin
|
|
Inc(Run);
|
|
fTokenId := tkSymbol;
|
|
fSymbolTokenID := stkGreater;
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.LessProc;
|
|
begin
|
|
Inc(Run);
|
|
fTokenId := tkSymbol;
|
|
fSymbolTokenID := stkLess;
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.LFProc;
|
|
begin
|
|
fTokenID := tkSpace;
|
|
inc(Run);
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.SlashProc;
|
|
begin
|
|
Inc(Run);
|
|
case fLine[Run] of
|
|
'/':
|
|
begin
|
|
repeat
|
|
Inc(Run);
|
|
until IsLineEnd(Run);
|
|
fRange := rsSingleComment;
|
|
fTokenID := tkComment;
|
|
end;
|
|
'*':
|
|
begin
|
|
Inc(Run, 1);
|
|
fRange := rsCStyleComment;
|
|
fTokenID := tkComment;
|
|
end
|
|
else
|
|
fTokenID := tkIdentifier;
|
|
end;
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.CStyleCommentProc;
|
|
begin
|
|
case fLine[Run] of
|
|
#0: NullProc;
|
|
#10: LFProc;
|
|
#13: CRProc;
|
|
else
|
|
begin
|
|
fTokenID := tkComment;
|
|
repeat
|
|
if (fLine[Run] = '*') and
|
|
(fLine[Run + 1] = '/') then
|
|
begin
|
|
Inc(Run, 2);
|
|
fRange := rsUnKnown;
|
|
Break;
|
|
end;
|
|
if not IsLineEnd(Run) then
|
|
Inc(Run);
|
|
until IsLineEnd(Run);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.StringOpenProc;
|
|
begin
|
|
Inc(Run);
|
|
fRange := rsString;
|
|
fTokenID := tkString;
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.StringProc;
|
|
begin
|
|
case fLine[Run] of
|
|
#0: NullProc;
|
|
#10: LFProc;
|
|
#13: CRProc;
|
|
else
|
|
begin
|
|
fTokenID := tkString;
|
|
repeat
|
|
if (fLine[Run] = '"') then
|
|
begin
|
|
Inc(Run, 1);
|
|
fRange := rsUnKnown;
|
|
Break;
|
|
end;
|
|
if not IsLineEnd(Run) then
|
|
Inc(Run);
|
|
until IsLineEnd(Run);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.IdentProc;
|
|
begin
|
|
fTokenID := IdentKind((fLine + Run));
|
|
Inc(Run, fStringLen);
|
|
while IsIdentChar(fLine[Run]) do
|
|
Inc(Run);
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.BraceOpenProc;
|
|
begin
|
|
Inc(Run);
|
|
fTokenId := tkSymbol;
|
|
fSymbolTokenID := stkBraceOpen;
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.BraceCloseProc;
|
|
begin
|
|
Inc(Run);
|
|
fTokenId := tkSymbol;
|
|
fSymbolTokenID := stkBraceClose;
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.SquareOpenProc;
|
|
begin
|
|
Inc(Run);
|
|
fTokenID := tkSymbol;
|
|
fSymbolTokenID := stkSquareOpen;
|
|
fRange := rsExtendedAttributes;
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.SquareCloseProc;
|
|
begin
|
|
Inc(Run);
|
|
fTokenID := tkSymbol;
|
|
fSymbolTokenID := stkSquareClose;
|
|
fRange := rsUnknown
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.UnknownProc;
|
|
begin
|
|
inc(Run);
|
|
fTokenID := tkUnknown;
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.Next;
|
|
begin
|
|
fTokenPos := Run;
|
|
case fRange of
|
|
rsCStyleComment: CStyleCommentProc;
|
|
rsString: StringProc;
|
|
else
|
|
case fLine[Run] of
|
|
#0: NullProc;
|
|
#10: LFProc;
|
|
#13: CRProc;
|
|
'/': SlashProc;
|
|
'"': StringOpenProc;
|
|
#1..#9, #11, #12, #14..#32: SpaceProc;
|
|
'0'..'9': NumberProc;
|
|
'A'..'Z', 'a'..'z', '_': IdentProc;
|
|
'{': BraceOpenProc;
|
|
'}': BraceCloseProc;
|
|
']': SquareCloseProc;
|
|
'[': SquareOpenProc;
|
|
'?': QuestionMarkProc;
|
|
':': ColonProc;
|
|
'>': GreaterProc;
|
|
'<': LessProc;
|
|
else
|
|
UnknownProc;
|
|
end;
|
|
end;
|
|
inherited;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.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 TSynWebIDLSyn.GetEol: Boolean;
|
|
begin
|
|
Result := Run = fLineLen + 1;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.GetKeyWords(TokenKind: Integer): UnicodeString;
|
|
begin
|
|
Result :=
|
|
'any,attribute,boolean,byte,ByteString,callback,const,creator,Date,del' +
|
|
'eter,dictionary,DOMString,double,enum,exception,float,getter,implement' +
|
|
's,inherit,interface,legacycaller,long,object,octet,optional,partial,re' +
|
|
'adonly,RegExp,sequence,setter,short,static,stringifier,typedef,unresti' +
|
|
'cted,unrestricted,unsigned,void';
|
|
end;
|
|
|
|
function TSynWebIDLSyn.GetTokenID: TtkTokenKind;
|
|
begin
|
|
Result := fTokenId;
|
|
if (fRange = rsExtendedAttributes) and not ((fTokenID = tkSymbol) and
|
|
(fSymbolTokenID = stkSquareOpen)) then
|
|
Result := tkExtendedAttributes;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.GetTokenAttribute: TSynHighLighterAttributes;
|
|
begin
|
|
case GetTokenID of
|
|
tkArguments: Result := fArgumentsAttri;
|
|
tkComment: Result := fCommentAttri;
|
|
tkExtendedAttributes: Result := fExtendedAttri;
|
|
tkIdentifier: Result := fIdentifierAttri;
|
|
tkKey: Result := fKeyAttri;
|
|
tkNumber: Result := fNumberAttri;
|
|
tkSpace: Result := fSpaceAttri;
|
|
tkString: Result := fStringAttri;
|
|
tkSymbol: Result := fSymbolAttri;
|
|
tkTypes: Result := fTypesAttri;
|
|
tkUnknown: Result := fIdentifierAttri;
|
|
else
|
|
Result := nil;
|
|
end;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.GetTokenKind: Integer;
|
|
begin
|
|
Result := Ord(fTokenId);
|
|
end;
|
|
|
|
function TSynWebIDLSyn.IsIdentChar(AChar: WideChar): Boolean;
|
|
begin
|
|
case AChar of
|
|
'_', '0'..'9', 'a'..'z', 'A'..'Z':
|
|
Result := True;
|
|
else
|
|
Result := False;
|
|
end;
|
|
end;
|
|
|
|
function TSynWebIDLSyn.GetSampleSource: UnicodeString;
|
|
begin
|
|
Result :=
|
|
'/* WEB IDL sample source */'#13#10 +
|
|
'[Constructor]'#13#10 +
|
|
'interface GraphicalWindow {'#13#10 +
|
|
' readonly attribute unsigned long width;'#13#10 +
|
|
' readonly attribute unsigned long height;'#13#10 +
|
|
#13#10 +
|
|
' attribute Paint currentPaint;'#13#10 +
|
|
#13#10 +
|
|
' void drawRectangle(float x, float y, float width, float height);' +
|
|
#13#10#13#10 +
|
|
' void drawText(float x, float y, DOMString text);'#13#10 +
|
|
'};';
|
|
end;
|
|
|
|
function TSynWebIDLSyn.IsFilterStored: Boolean;
|
|
begin
|
|
Result := fDefaultFilter <> SYNS_FilterWebIDL;
|
|
end;
|
|
|
|
class function TSynWebIDLSyn.GetFriendlyLanguageName: UnicodeString;
|
|
begin
|
|
Result := SYNS_FriendlyLangWebIDL;
|
|
end;
|
|
|
|
class function TSynWebIDLSyn.GetLanguageName: string;
|
|
begin
|
|
Result := SYNS_LangWebIDL;
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.ResetRange;
|
|
begin
|
|
fRange := rsUnknown;
|
|
end;
|
|
|
|
procedure TSynWebIDLSyn.SetRange(Value: Pointer);
|
|
begin
|
|
fRange := TRangeState(Value);
|
|
end;
|
|
|
|
function TSynWebIDLSyn.GetRange: Pointer;
|
|
begin
|
|
Result := Pointer(fRange);
|
|
end;
|
|
|
|
initialization
|
|
{$IFNDEF SYN_CPPB_1}
|
|
RegisterPlaceableHighlighter(TSynWebIDLSyn);
|
|
{$ENDIF}
|
|
end.
|